' ``` Up until now, we did not treat internal Ruby sources the same way, but Ruby 4.0 now does a similar masking of such sources: JRuby: ``` $ cx jruby-10.0.2.0 ruby -e "def foo; puts caller(0); end; tap { foo }" -e:1:in 'foo' -e:1:in 'block in

' ``` CRuby: ``` $ cx 4.0.0 ruby -e "def foo; puts caller(0); end; tap { foo }" -e:1:in 'Object#foo' -e:1:in 'block in

' -e:1:in 'Kernel#tap' -e:1:in '

' ``` This patch uses the native masking logic in backtrace building to also mask internal Ruby source frames, producing a `caller` trace that matches CRuby: ``` $ ruby -v -e "def foo; puts caller(0); end; tap { foo }" jruby 10.1.0.0-SNAPSHOT (4.0.0) 2026-01-06 ef3d5d0851 OpenJDK 64-Bit Server VM 25+36-LTS on 25+36-LTS +indy +jit [arm64-darwin] -e:1:in 'foo' -e:1:in 'block in

' -e:1:in 'tap' -e:1:in '

' ``` Additionally, this patch expands the omission of internal Ruby frames from `warn` line calculation in the case those methods have been JIT compiled (this logic was missing before). --- .../runtime/backtrace/BacktraceData.java | 53 +++++++++++++------ 1 file changed, 38 insertions(+), 15 deletions(-) diff --git a/core/src/main/java/org/jruby/runtime/backtrace/BacktraceData.java b/core/src/main/java/org/jruby/runtime/backtrace/BacktraceData.java index 91685b8ea28..8f2af94d883 100644 --- a/core/src/main/java/org/jruby/runtime/backtrace/BacktraceData.java +++ b/core/src/main/java/org/jruby/runtime/backtrace/BacktraceData.java @@ -126,8 +126,21 @@ private void eachBacktrace(Map> boundMethods, Predic continue; } - // mask internal file paths - filename = TraceType.maskInternalFiles(filename); + // skip internal sources if requested + if (TraceType.isExcludedInternal(filename)) { + // if excluding internal sources, skip frame altogether + if (excludeInternal) continue; + + // if masking internal sources, replace only the highest frame with most recent Ruby frame + if (maskNative) { + dupFrame = true; + dupFrameName = decodedName; + continue; + } + + // otherwise, mark internal file paths with "internal:" prefix + filename = TraceType.maskInternalFiles(filename); + } // construct Ruby trace element RubyStackTraceElement rubyElement = new RubyStackTraceElement(className, decodedName, filename, line, false, type); @@ -180,28 +193,38 @@ private void eachBacktrace(Map> boundMethods, Predic BacktraceElement rubyFrame = backIter.next(); // construct Ruby trace element - final String newName; + final String translatedName; switch (frameType) { - case METHOD: newName = rubyFrame.method; break; - case BLOCK: newName = rubyFrame.method; break; - case CLASS: newName = "'; break; - case MODULE: newName = "'; break; - case METACLASS: newName = "singleton class"; break; - case ROOT: newName = "

"; break; + case METHOD: translatedName = rubyFrame.method; break; + case BLOCK: translatedName = rubyFrame.method; break; + case CLASS: translatedName = "'; break; + case MODULE: translatedName = "'; break; + case METACLASS: translatedName = "singleton class"; break; + case ROOT: translatedName = "

"; break; case EVAL: - newName = rubyFrame.method == null || rubyFrame.method.isEmpty() ? "

" : rubyFrame.method; + translatedName = rubyFrame.method == null || rubyFrame.method.isEmpty() ? "

" : rubyFrame.method; break; - default: newName = rubyFrame.method; + default: translatedName = rubyFrame.method; } // skip internal sources if requested filename = rubyFrame.filename; - if (excludeInternal && TraceType.isExcludedInternal(filename)) continue; + if (TraceType.isExcludedInternal(filename)) { + // if excluding internal sources, skip frame altogether + if (excludeInternal) continue; + + // if masking internal sources, replace only the highest frame with most recent Ruby frame + if (maskNative) { + dupFrame = true; + dupFrameName = translatedName; + continue; + } - // mask internal file paths - filename = TraceType.maskInternalFiles(filename); + // otherwise, mark internal file paths with "internal:" prefix + filename = TraceType.maskInternalFiles(filename); + } - RubyStackTraceElement rubyElement = new RubyStackTraceElement("RUBY", newName, filename, rubyFrame.line + 1, false, frameType); + RubyStackTraceElement rubyElement = new RubyStackTraceElement("RUBY", translatedName, filename, rubyFrame.line + 1, false, frameType); // dup if masking native and previous frame was native if (maskNative && dupFrame) { From 33c4ae2f7fd8ee4cc087b6e138179d53723ae30f Mon Sep 17 00:00:00 2001 From: Charles Oliver Nutter Date: Tue, 13 Jan 2026 02:32:52 -0600 Subject: [PATCH 055/168] Exclude two more tests that depend on CRuby GC APIs --- test/mri/excludes/TestIOBuffer.rb | 1 + test/mri/excludes/TestVariable.rb | 3 ++- 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/test/mri/excludes/TestIOBuffer.rb b/test/mri/excludes/TestIOBuffer.rb index ea473c2015c..f379c4beec2 100644 --- a/test/mri/excludes/TestIOBuffer.rb +++ b/test/mri/excludes/TestIOBuffer.rb @@ -1,3 +1,4 @@ +exclude :test_bug_21210, "depends on CRuby GC APIs" exclude :test_copy_null_destination, "no support for null buffer" exclude :test_copy_null_source, "no support for null buffer" exclude :test_copy_overlapped_bwd, "needs investigation" diff --git a/test/mri/excludes/TestVariable.rb b/test/mri/excludes/TestVariable.rb index 18481887ad1..cfe2671167f 100644 --- a/test/mri/excludes/TestVariable.rb +++ b/test/mri/excludes/TestVariable.rb @@ -1,7 +1,8 @@ +exclude :test_cloned_allows_setting_cvar, "needs investigation" +exclude :test_exivar_resize_with_compaction_stress, "depends on CRuby GC APIs" exclude :test_global_variables, "requires dynamic listing of backref numbers for available groups" exclude :test_setting_class_variable_on_module_through_inheritance, "work in progress" exclude :test_singleton_class_included_class_variable, "work in progress" exclude :test_special_constant_ivars, "work in progress" exclude :test_svar_with_ifunc, "new isolation of proc frame captures, see https://github.com/jruby/jruby/issues/8726" exclude :test_variable, "needs investigation" -exclude :test_cloned_allows_setting_cvar, "needs investigation" From b8880cf98a7a572b504d5248e6d8a9b215c3ac02 Mon Sep 17 00:00:00 2001 From: Charles Oliver Nutter Date: Tue, 13 Jan 2026 02:56:13 -0600 Subject: [PATCH 056/168] Update deprecation for $, and $\ See https://github.com/ruby/ruby/pull/15409 and later change to the warning message in https://github.com/ruby/ruby/commit/29a12297c3594ed24102d62e16dfd6d4e5e328f3 --- core/src/main/java/org/jruby/RubyGlobal.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/core/src/main/java/org/jruby/RubyGlobal.java b/core/src/main/java/org/jruby/RubyGlobal.java index e00ac3540eb..d2190646987 100644 --- a/core/src/main/java/org/jruby/RubyGlobal.java +++ b/core/src/main/java/org/jruby/RubyGlobal.java @@ -199,7 +199,7 @@ public static RubyHash createGlobalsAndENV(ThreadContext context, GlobalVariable runtime.defineVariable(rs, GLOBAL); runtime.setRecordSeparatorVar(rs); globals.setDefaultSeparator(defaultRS); - runtime.defineVariable(new StringGlobalVariable(runtime, "$\\", context.nil), GLOBAL); + runtime.defineVariable(new DeprecatedStringGlobalVariable(runtime, "$\\", context.nil), GLOBAL); runtime.defineVariable(new DeprecatedStringGlobalVariable(runtime, "$,", context.nil), GLOBAL); runtime.defineVariable(new LineNumberGlobalVariable(runtime, "$."), GLOBAL); @@ -1073,7 +1073,7 @@ public DeprecatedStringGlobalVariable(Ruby runtime, String name, IRubyObject val public IRubyObject set(IRubyObject value) { IRubyObject result = super.set(value); - if (!value.isNil()) warnDeprecatedGlobal(runtime.getCurrentContext(), name); + if (!value.isNil()) warnDeprecatedGlobal(runtime.getCurrentContext(), "non-nil '" + name + "'"); return result; } From 8534401b79a7f59f975d6399559c334fbbc5a0cf Mon Sep 17 00:00:00 2001 From: Charles Oliver Nutter Date: Tue, 13 Jan 2026 03:05:46 -0600 Subject: [PATCH 057/168] Use strict coercion logic to reject non-Proc --- core/src/main/java/org/jruby/ir/runtime/IRRuntimeHelpers.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/core/src/main/java/org/jruby/ir/runtime/IRRuntimeHelpers.java b/core/src/main/java/org/jruby/ir/runtime/IRRuntimeHelpers.java index a40f3e1b0a5..235c4201e46 100644 --- a/core/src/main/java/org/jruby/ir/runtime/IRRuntimeHelpers.java +++ b/core/src/main/java/org/jruby/ir/runtime/IRRuntimeHelpers.java @@ -554,7 +554,7 @@ public static Block getBlockFromObject(ThreadContext context, Object value) { } else if ((value instanceof IRubyObject) && ((IRubyObject)value).isNil()) { block = Block.NULL_BLOCK; } else if (value instanceof IRubyObject) { - block = ((RubyProc) TypeConverter.convertToType((IRubyObject) value, context.runtime.getProc(), "to_proc", true)).getBlock(); + block = ((RubyProc) TypeConverter.convertToType((IRubyObject) value, context.runtime.getProc(), "to_proc")).getBlock(); } else { throw new RuntimeException("Unhandled case in CallInstr:prepareBlock. Got block arg: " + value); } From 4f7d71d3ce9036fe7b35b88a31a8a5066d03abd5 Mon Sep 17 00:00:00 2001 From: Charles Oliver Nutter Date: Tue, 13 Jan 2026 03:18:05 -0600 Subject: [PATCH 058/168] Partially fix deprecation for $/ and $; variables --- core/src/main/java/org/jruby/RubyGlobal.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/core/src/main/java/org/jruby/RubyGlobal.java b/core/src/main/java/org/jruby/RubyGlobal.java index d2190646987..f2549e9b684 100644 --- a/core/src/main/java/org/jruby/RubyGlobal.java +++ b/core/src/main/java/org/jruby/RubyGlobal.java @@ -195,7 +195,7 @@ public static RubyHash createGlobalsAndENV(ThreadContext context, GlobalVariable runtime.defineVariable(new WarningGlobalVariable(context, "$-W", verbosity), GLOBAL); IRubyObject defaultRS = RubyString.newFString(runtime, instanceConfig.getRecordSeparator()); - GlobalVariable rs = new StringGlobalVariable(runtime, "$/", defaultRS); + GlobalVariable rs = new DeprecatedStringGlobalVariable(runtime, "$/", defaultRS); runtime.defineVariable(rs, GLOBAL); runtime.setRecordSeparatorVar(rs); globals.setDefaultSeparator(defaultRS); @@ -1088,7 +1088,7 @@ public DeprecatedStringOrRegexpGlobalVariable(Ruby runtime, String name, IRubyOb public IRubyObject set(IRubyObject value) { IRubyObject result = super.set(value); - if (!result.isNil()) warnDeprecatedGlobal(runtime.getCurrentContext(), name); + if (!value.isNil()) warnDeprecatedGlobal(runtime.getCurrentContext(), "non-nil '" + name + "'"); return result; } From bf93b265650cef1fc08523730573ff5ea6611755 Mon Sep 17 00:00:00 2001 From: Charles Oliver Nutter Date: Tue, 13 Jan 2026 12:09:33 -0600 Subject: [PATCH 059/168] Tag in-place dedup test not implementable on JRuby The behavior specified here is that the first instance of a non- interned frozen string to be interned/deduplicated will be stored as-is as the interned string cache (i.e. the `-` method will return the same object). The behavior is impossible to implement predictably without races (some other thread might dedup at the same time, and then you get a copy instead of the original), and doubly impossible on JRuby since all interned strings are of a different internal Java type. This was discussed in ruby/spec#1249 where it was agreed the spec should be moved into CRuby's tests, as it is not implementable on JRuby or TruffleRuby. We exclude this behavior on JRuby for these reasons. --- test/mri/excludes/TestString.rb | 1 + test/mri/excludes/TestString2.rb | 1 + 2 files changed, 2 insertions(+) diff --git a/test/mri/excludes/TestString.rb b/test/mri/excludes/TestString.rb index 5ab75932268..8a70286f2be 100644 --- a/test/mri/excludes/TestString.rb +++ b/test/mri/excludes/TestString.rb @@ -33,6 +33,7 @@ exclude :test_tr, "needs investigation" exclude :test_tr_s!, "needs investigation" exclude :test_tr_s, "needs investigation" +exclude :test_uminus_dedup_in_place, "depends on MRI-specific interning behavior" exclude :test_uminus_frozen, "work in progress" exclude :test_uminus_no_freeze_not_bare, "work in progress" exclude :test_undump, "unfinished in initial 2.6 work, #6161" diff --git a/test/mri/excludes/TestString2.rb b/test/mri/excludes/TestString2.rb index 5ab75932268..8a70286f2be 100644 --- a/test/mri/excludes/TestString2.rb +++ b/test/mri/excludes/TestString2.rb @@ -33,6 +33,7 @@ exclude :test_tr, "needs investigation" exclude :test_tr_s!, "needs investigation" exclude :test_tr_s, "needs investigation" +exclude :test_uminus_dedup_in_place, "depends on MRI-specific interning behavior" exclude :test_uminus_frozen, "work in progress" exclude :test_uminus_no_freeze_not_bare, "work in progress" exclude :test_undump, "unfinished in initial 2.6 work, #6161" From 4e313a7bfbe8b7bd76ed82d49bd0dac2458f7de0 Mon Sep 17 00:00:00 2001 From: Charles Oliver Nutter Date: Tue, 13 Jan 2026 12:28:03 -0600 Subject: [PATCH 060/168] Exclude test for use-after-free not possible in JRuby CRuby will segv due to use-after-free of a heap object if a string is modified while being split. This is not possible in JRuby. --- test/mri/excludes/TestString.rb | 1 + test/mri/excludes/TestString2.rb | 1 + 2 files changed, 2 insertions(+) diff --git a/test/mri/excludes/TestString.rb b/test/mri/excludes/TestString.rb index 8a70286f2be..e38a9ca0e98 100644 --- a/test/mri/excludes/TestString.rb +++ b/test/mri/excludes/TestString.rb @@ -24,6 +24,7 @@ exclude :test_rstrip_bang, "needs investigation" exclude :test_scan_gc_compact_stress, "GC is not configurable" exclude :test_scan_segv, "requires ObjectSpace.each_object" +exclude :test_split_with_block, "test for use-after-free in CRuby not possible in JRuby" exclude :test_start_with?, "needs investigation" exclude :test_start_with_timeout_memory_leak, "no working assert_no_memory_leak method" exclude :test_string_interpolations_across_heaps_get_embedded, "uses internal GC constants" diff --git a/test/mri/excludes/TestString2.rb b/test/mri/excludes/TestString2.rb index 8a70286f2be..e38a9ca0e98 100644 --- a/test/mri/excludes/TestString2.rb +++ b/test/mri/excludes/TestString2.rb @@ -24,6 +24,7 @@ exclude :test_rstrip_bang, "needs investigation" exclude :test_scan_gc_compact_stress, "GC is not configurable" exclude :test_scan_segv, "requires ObjectSpace.each_object" +exclude :test_split_with_block, "test for use-after-free in CRuby not possible in JRuby" exclude :test_start_with?, "needs investigation" exclude :test_start_with_timeout_memory_leak, "no working assert_no_memory_leak method" exclude :test_string_interpolations_across_heaps_get_embedded, "uses internal GC constants" From b351ad861bf342e0fc108c9b912e34bc3534994e Mon Sep 17 00:00:00 2001 From: Charles Oliver Nutter Date: Tue, 13 Jan 2026 12:43:40 -0600 Subject: [PATCH 061/168] Verify encoding of path for File.path See https://github.com/ruby/ruby/pull/15429 --- core/src/main/java/org/jruby/RubyFile.java | 30 +++++++++++++++++++-- core/src/main/java/org/jruby/api/Error.java | 5 ++++ 2 files changed, 33 insertions(+), 2 deletions(-) diff --git a/core/src/main/java/org/jruby/RubyFile.java b/core/src/main/java/org/jruby/RubyFile.java index 6b0940c265c..0eff8c6af62 100644 --- a/core/src/main/java/org/jruby/RubyFile.java +++ b/core/src/main/java/org/jruby/RubyFile.java @@ -45,6 +45,7 @@ import org.jruby.anno.JRubyClass; import org.jruby.anno.JRubyMethod; import org.jruby.api.API; +import org.jruby.api.Error; import org.jruby.exceptions.NotImplementedError; import org.jruby.ir.runtime.IRRuntimeHelpers; import org.jruby.runtime.*; @@ -1364,12 +1365,37 @@ public static String getAdjustedPath(ThreadContext context, IRubyObject fileOrPa // mri: FilePathValue/rb_get_path/rb_get_patch_check public static RubyString get_path(ThreadContext context, IRubyObject path) { - if (path instanceof RubyString) return checkEmbeddedNulls(context, path); + return getPathCheckConvert(context, getPathCheckToString(context, path)); + } + + // CRuby rb_get_path_check_convert + private static RubyString getPathCheckConvert(ThreadContext context, RubyString path) { + path = filePathConvert(context, path); + + checkPathEncoding(context, path); + + checkEmbeddedNulls(context, path); + + return path.strDup(context.runtime); + } + + // CRuby: check_path_encoding + private static Encoding checkPathEncoding(ThreadContext context, RubyString str) { + Encoding enc = str.getEncoding(); + if (!enc.isAsciiCompatible()) { + throw Error.encodingCompatibilityError(context, "path name must be ASCII-compatible (" + enc + "): " + str); + } + return enc; + } + + // CRuby: rb_get_path_check_to_string + private static RubyString getPathCheckToString(ThreadContext context, IRubyObject path) { + if (path instanceof RubyString) return (RubyString) path; FileSites sites = sites(context); if (sites.respond_to_to_path.respondsTo(context, path, path, true)) path = sites.to_path.call(context, path, path); - return filePathConvert(context, path.convertToString()); + return path.convertToString(); } // FIXME: MRI skips this logic on windows? Does not make sense to me why so I left it in. diff --git a/core/src/main/java/org/jruby/api/Error.java b/core/src/main/java/org/jruby/api/Error.java index 48cc9483e14..9f9cc849093 100644 --- a/core/src/main/java/org/jruby/api/Error.java +++ b/core/src/main/java/org/jruby/api/Error.java @@ -6,6 +6,7 @@ import org.jruby.RubyModule; import org.jruby.exceptions.ArgumentError; import org.jruby.exceptions.EOFError; +import org.jruby.exceptions.EncodingError; import org.jruby.exceptions.IOError; import org.jruby.exceptions.NotImplementedError; import org.jruby.exceptions.RaiseException; @@ -276,4 +277,8 @@ private static IRubyObject typeFor(Ruby runtime, IRubyObject object) { public static EOFError eofError(ThreadContext context, String message) { return (EOFError) context.runtime.newEOFError(message); } + + public static EncodingError.CompatibilityError encodingCompatibilityError(ThreadContext context, String s) { + return (EncodingError.CompatibilityError) context.runtime.newEncodingCompatibilityError(s); + } } From 74f3afe7632d266410ae9a305de9dab894bc30da Mon Sep 17 00:00:00 2001 From: Charles Oliver Nutter Date: Tue, 13 Jan 2026 13:07:30 -0600 Subject: [PATCH 062/168] Avoid calling #size for to_set on Enumerable and Range See https://github.com/ruby/ruby/commit/61500c6f48135ef018f5e496ff292a86b0043c65 and https://github.com/ruby/ruby/commit/79f36c544a0431d9b76c3c11a5f622383eaca7bd The new native Set impl does not appear to have ever called #size from #initialize, so we delete that from our existing impl. --- core/src/main/java/org/jruby/RubyRange.java | 12 ++++++++++++ core/src/main/java/org/jruby/ext/set/RubySet.java | 6 ------ core/src/main/java/org/jruby/runtime/JavaSites.java | 1 + 3 files changed, 13 insertions(+), 6 deletions(-) diff --git a/core/src/main/java/org/jruby/RubyRange.java b/core/src/main/java/org/jruby/RubyRange.java index 23c98090dd8..0667aa212cd 100644 --- a/core/src/main/java/org/jruby/RubyRange.java +++ b/core/src/main/java/org/jruby/RubyRange.java @@ -69,6 +69,7 @@ import static org.jruby.api.Error.*; import static org.jruby.runtime.Helpers.hashEnd; import static org.jruby.runtime.Helpers.hashStart; +import static org.jruby.runtime.Helpers.invokeSuper; import static org.jruby.runtime.Helpers.invokedynamic; import static org.jruby.runtime.Helpers.murmurCombine; import static org.jruby.runtime.Helpers.safeHashLong; @@ -1370,6 +1371,17 @@ public IRubyObject size(ThreadContext context) { return context.nil; } + @JRubyMethod(name = "to_set", rest = true, frame = true) + public IRubyObject to_set(ThreadContext context, IRubyObject[] args) { + IRubyObject size = sites(context).size.call(context, this, this); + + if (size instanceof RubyFloat flote && flote.isInfinite()) { + throw context.runtime.newRangeError("cannot convert an infinite range to a set"); + } + + return invokeSuper(context, this, context.getFrameKlazz(), context.getFrameName(), args, Block.NULL_BLOCK); + } + private boolean discreteObject(IRubyObject object) { return object.respondsTo("succ"); } diff --git a/core/src/main/java/org/jruby/ext/set/RubySet.java b/core/src/main/java/org/jruby/ext/set/RubySet.java index a19e0175319..845ad557781 100644 --- a/core/src/main/java/org/jruby/ext/set/RubySet.java +++ b/core/src/main/java/org/jruby/ext/set/RubySet.java @@ -257,12 +257,6 @@ public IRubyObject initialize(final ThreadContext context, IRubyObject enume, fi } return set; // done } else { - if (enume.getType().isKindOfModule(context.runtime.getEnumerable()) && enume.respondsTo("size")) { - IRubyObject size = enume.callMethod(context, "size"); - if (size instanceof RubyFloat flote && flote.isInfinite()) { - throw Error.rangeError(context, "cannot initialize Set from an object with infinite size"); - } - } allocHash(context); if (block.isGiven()) { diff --git a/core/src/main/java/org/jruby/runtime/JavaSites.java b/core/src/main/java/org/jruby/runtime/JavaSites.java index a2e1fa28918..6dd889d719c 100644 --- a/core/src/main/java/org/jruby/runtime/JavaSites.java +++ b/core/src/main/java/org/jruby/runtime/JavaSites.java @@ -473,6 +473,7 @@ public static class RangeSites { public final CallSite op_lt = new FunctionalCachingCallSite("<"); public final CachingCallSite each = new FunctionalCachingCallSite("each"); public final CallSite reverse_each = new FunctionalCachingCallSite("reverse_each"); + public final CallSite size = new FunctionalCachingCallSite("size"); } public static class WarningSites { From dce61342424a7f7b69c99507cc59ddfffafa14a8 Mon Sep 17 00:00:00 2001 From: Charles Oliver Nutter Date: Tue, 13 Jan 2026 13:35:58 -0600 Subject: [PATCH 063/168] Ensure Module#name is frozen --- core/src/main/java/org/jruby/RubyModule.java | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/core/src/main/java/org/jruby/RubyModule.java b/core/src/main/java/org/jruby/RubyModule.java index 687672231b7..aa269716bbc 100644 --- a/core/src/main/java/org/jruby/RubyModule.java +++ b/core/src/main/java/org/jruby/RubyModule.java @@ -827,7 +827,7 @@ private RubyString calculateAnonymousRubyName(ThreadContext context) { anonBase.append(metaClass.getRealClass().rubyName(context)).append(newString(context, ":0x")); anonBase.append(newString(context, Integer.toHexString(System.identityHashCode(this)))).append(newString(context, ">")); - return anonBase; + return (RubyString) anonBase.freeze(context); } private RubyString calculateRubyName(ThreadContext context) { @@ -836,7 +836,7 @@ private RubyString calculateRubyName(ThreadContext context) { if (getBaseName() == null) return calculateAnonymousRubyName(context); // no name...anonymous! if (usingTemporaryName()) { // temporary name - cachedRubyName = asSymbol(context, baseName).toRubyString(context); + cachedRubyName = (RubyString) asSymbol(context, baseName).toRubyString(context).freeze(context); return cachedRubyName; } @@ -863,7 +863,7 @@ private RubyString calculateRubyName(ThreadContext context) { RubyString fullName = buildPathString(context, parents); - if (cache) cachedRubyName = fullName; + if (cache) cachedRubyName = (RubyString) fullName.freeze(context); return fullName; } From 8ca9ae00395c3a81f1b6417a8ae64d31d012c99e Mon Sep 17 00:00:00 2001 From: Charles Oliver Nutter Date: Tue, 13 Jan 2026 13:36:06 -0600 Subject: [PATCH 064/168] Check frozen status setting Module temp name --- core/src/main/java/org/jruby/RubyModule.java | 2 ++ 1 file changed, 2 insertions(+) diff --git a/core/src/main/java/org/jruby/RubyModule.java b/core/src/main/java/org/jruby/RubyModule.java index aa269716bbc..94b4d7973e8 100644 --- a/core/src/main/java/org/jruby/RubyModule.java +++ b/core/src/main/java/org/jruby/RubyModule.java @@ -999,6 +999,8 @@ private String calculateAnonymousName(ThreadContext context) { @JRubyMethod(required = 1) public IRubyObject set_temporary_name(ThreadContext context, IRubyObject arg) { + checkFrozen(); + if (baseName != null && IdUtil.isValidConstantName(baseName) && (parent == null || parent.baseName != null)) { throw runtimeError(context, "can't change permanent name"); } From de7a50855e756e7bdf1d7cabda769d5527f8a462 Mon Sep 17 00:00:00 2001 From: Charles Oliver Nutter Date: Tue, 13 Jan 2026 13:42:24 -0600 Subject: [PATCH 065/168] Delegate to Array#fetch from Array#fetch_values --- core/src/main/java/org/jruby/RubyArray.java | 8 +------- 1 file changed, 1 insertion(+), 7 deletions(-) diff --git a/core/src/main/java/org/jruby/RubyArray.java b/core/src/main/java/org/jruby/RubyArray.java index 526826e4651..986e4aa2858 100644 --- a/core/src/main/java/org/jruby/RubyArray.java +++ b/core/src/main/java/org/jruby/RubyArray.java @@ -1032,13 +1032,7 @@ public IRubyObject fetch_values(ThreadContext context, IRubyObject[] args, Block var result = Create.allocArray(context, length); for (int i = 0; i < length; i++) { int index = toInt(context, args[i]); - // FIXME: lookup the bounds part of this in error message?? - if (index >= arraySize) { - if (!block.isGiven()) throw indexError(context, "index " + index + " outside of array bounds: 0...0"); - result.append(context, block.yield(context, asFixnum(context, index))); - } else { - result.append(context, eltOk(index)); - } + result.append(context, fetch(context, args[i], block)); } return result; From e9dff455a46cb117b7ffe02bd2d14b72a1baa37b Mon Sep 17 00:00:00 2001 From: Charles Oliver Nutter Date: Tue, 13 Jan 2026 15:57:38 -0600 Subject: [PATCH 066/168] Specification#has_rdoc was finally removed --- test/jruby/test_marshal_gemspec.rb | 1 - 1 file changed, 1 deletion(-) diff --git a/test/jruby/test_marshal_gemspec.rb b/test/jruby/test_marshal_gemspec.rb index 87059830fda..4e287365d37 100644 --- a/test/jruby/test_marshal_gemspec.rb +++ b/test/jruby/test_marshal_gemspec.rb @@ -107,7 +107,6 @@ def test_dump_and_load_from_source s.date = %q{2007-11-04} s.description = %q{Install this gem to use Derby with JRuby on Rails.} s.email = %q{nick@nicksieger.com, ola.bini@gmail.com} - s.has_rdoc = true s.homepage = %q{http://jruby-extras.rubyforge.org/ActiveRecord-JDBC} s.require_paths = ["lib"] s.required_ruby_version = Gem::Requirement.new("> 0.0.0") From eedab814f83f1ed594bb340fe19b1a0d1001e90f Mon Sep 17 00:00:00 2001 From: Charles Oliver Nutter Date: Tue, 13 Jan 2026 16:18:26 -0600 Subject: [PATCH 067/168] Remove CGI gem and commit remaining pieces CGI gem has been removed and only the cgi/escape extension remains. See https://github.com/ruby/ruby/pull/13275 --- .gitignore | 1 - .../org/jruby/ext/cgi/escape/CGIEscape.java | 574 ++++++++++++++++++ lib/pom.rb | 1 - lib/pom.xml | 16 - lib/ruby/stdlib/cgi.rb | 7 + lib/ruby/stdlib/cgi/escape.rb | 236 +++++++ lib/ruby/stdlib/cgi/util.rb | 7 + 7 files changed, 824 insertions(+), 18 deletions(-) create mode 100644 core/src/main/java/org/jruby/ext/cgi/escape/CGIEscape.java create mode 100644 lib/ruby/stdlib/cgi.rb create mode 100644 lib/ruby/stdlib/cgi/escape.rb create mode 100644 lib/ruby/stdlib/cgi/util.rb diff --git a/.gitignore b/.gitignore index 60d12502420..7a6fdac04a7 100644 --- a/.gitignore +++ b/.gitignore @@ -59,7 +59,6 @@ lib/ruby/stdlib/*.jar lib/ruby/stdlib/ant* lib/ruby/stdlib/benchmark* lib/ruby/stdlib/bundler* -lib/ruby/stdlib/cgi* lib/ruby/stdlib/debug* lib/ruby/stdlib/delegate* lib/ruby/stdlib/did_you_mean* diff --git a/core/src/main/java/org/jruby/ext/cgi/escape/CGIEscape.java b/core/src/main/java/org/jruby/ext/cgi/escape/CGIEscape.java new file mode 100644 index 00000000000..63c982b1063 --- /dev/null +++ b/core/src/main/java/org/jruby/ext/cgi/escape/CGIEscape.java @@ -0,0 +1,574 @@ +/* + **** BEGIN LICENSE BLOCK ***** + * BSD 2-Clause License + * + * Copyright (c) 2016, Charles Oliver Nutter + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + ***** END LICENSE BLOCK *****/ + +package org.jruby.ext.cgi.escape; + +import org.jcodings.Encoding; +import org.jcodings.specific.ISO8859_1Encoding; +import org.jcodings.specific.UTF8Encoding; +import org.jruby.Ruby; +import org.jruby.RubyClass; +import org.jruby.RubyEncoding; +import org.jruby.RubyModule; +import org.jruby.RubyString; +import org.jruby.anno.JRubyMethod; +import org.jruby.runtime.Block; +import org.jruby.runtime.Helpers; +import org.jruby.runtime.ThreadContext; +import org.jruby.runtime.builtin.IRubyObject; +import org.jruby.runtime.load.Library; +import org.jruby.util.ByteList; +import org.jruby.util.StringSupport; +import org.jruby.util.io.EncodingUtils; + +public class CGIEscape implements Library { + public static final String ACCEPT_CHARSET = "@@accept_charset"; + public static final byte[] NO39 = "'".getBytes(RubyEncoding.UTF8); + public static final byte[] AMP = "&".getBytes(RubyEncoding.UTF8); + public static final byte[] QUOT = """.getBytes(RubyEncoding.UTF8); + public static final byte[] LT = "<".getBytes(RubyEncoding.UTF8); + public static final byte[] GT = ">".getBytes(RubyEncoding.UTF8); + public static final int UNICODE_MAX = 0x10ffff; + public static final byte[] TSEMI = "t;".getBytes(RubyEncoding.UTF8); + public static final byte[] UOTSEMI = "uot;".getBytes(RubyEncoding.UTF8); + public static final byte[] MPSEMI = "mp;".getBytes(RubyEncoding.UTF8); + public static final byte[] POSSEMI = "pos;".getBytes(RubyEncoding.UTF8); + + static void html_escaped_cat(RubyString str, byte c) { + switch (c) { + case '\'': + str.cat(NO39); + break; + case '&': + str.cat(AMP); + break; + case '"': + str.cat(QUOT); + break; + case '<': + str.cat(LT); + break; + case '>': + str.cat(GT); + break; + } + } + + static void preserve_original_state(RubyString orig, RubyString dest) { + dest.setEncoding(orig.getEncoding()); + + dest.infectBy(orig); + } + + static IRubyObject + optimized_escape_html(Ruby runtime, RubyString str) { + int i, len, beg = 0; + RubyString dest = null; + byte[] cstrBytes; + + len = str.size(); + ByteList byteList = str.getByteList(); + cstrBytes = byteList.unsafeBytes(); + int cstr = byteList.begin(); + + for (i = 0; i < len; i++) { + switch (cstrBytes[cstr + i]) { + case '\'': + case '&': + case '"': + case '<': + case '>': + if (dest == null) { + dest = RubyString.newStringLight(runtime, len); + } + + dest.cat(cstrBytes, cstr + beg, i - beg); + beg = i + 1; + + html_escaped_cat(dest, cstrBytes[cstr + i]); + break; + } + } + + if (dest != null) { + dest.cat(cstrBytes, cstr + beg, len - beg); + preserve_original_state(str, dest); + return dest; + } else { + return str.strDup(runtime); + } + } + + // Set of i has to happen outside this; see MATCH macro in MRI ext/cgi/escape/escape.c + static boolean MATCH(byte[] s, int len, int i, byte[] cstrBytes, int cstr) { + if (len - i >= s.length && ByteList.memcmp(cstrBytes, cstr + i, s, 0, s.length) == 0) { + return true; + } else { + return false; + } + } + + static IRubyObject + optimized_unescape_html(Ruby runtime, RubyString str) { + Encoding enc = str.getEncoding(); + int charlimit = (enc instanceof UTF8Encoding) ? UNICODE_MAX : + (enc instanceof ISO8859_1Encoding) ? 256 : + 128; + int i, j, len, beg = 0; + int clen = 0, plen; + boolean overflow = false; + byte[] cstrBytes; + int cstr; + byte[] buf = new byte[6]; + RubyString dest = null; + + len = str.size(); + ByteList byteList = str.getByteList(); + cstrBytes = byteList.getUnsafeBytes(); + cstr = byteList.begin(); + + for (i = 0; i < len; i++) { + int cc; + int c = cstrBytes[cstr + i]; + if (c != '&') continue; + plen = i - beg; + if (++i >= len) break; + c = cstrBytes[cstr + i] & 0xFF; + j = i; + switch (c) { + case 'a': + ++i; + if (MATCH(POSSEMI, len, i, cstrBytes, cstr)) { + i += POSSEMI.length - 1; + c = '\''; + } else if (MATCH(MPSEMI, len, i, cstrBytes, cstr)) { + i += MPSEMI.length - 1; + c = '&'; + } else { + i = j; + continue; + } + break; + case 'q': + ++i; + if (MATCH(UOTSEMI, len, i, cstrBytes, cstr)) { + i += UOTSEMI.length - 1; + c = '"'; + } else { + i = j; + continue; + } + break; + case 'g': + ++i; + if (MATCH(TSEMI, len, i, cstrBytes, cstr)) { + i += TSEMI.length - 1; + c = '>'; + } else { + i = j; + continue; + } + break; + case 'l': + ++i; + if (MATCH(TSEMI, len, i, cstrBytes, cstr)) { + i += TSEMI.length - 1; + c = '<'; + } else { + i = j; + continue; + } + break; + case '#': + if (len - ++i >= 2 && Character.isDigit(cstrBytes[cstr + i])) { + int[] clenOverflow = {clen, overflow ? 1 : 0}; + cc = ruby_scan_digits(cstrBytes, cstr + i, len - i, 10, clenOverflow); + clen = clenOverflow[0]; + overflow = clenOverflow[1] == 1; + } else if (i < len && (cstrBytes[cstr + i] == 'x' || cstrBytes[cstr + i] == 'X') && len - ++i >= 2 && ISXDIGIT(cstrBytes, cstr + i)) { + int[] clenOverflow = {clen, overflow ? 1 : 0}; + cc = ruby_scan_digits(cstrBytes, cstr + i, len - i, 16, clenOverflow); + clen = clenOverflow[0]; + overflow = clenOverflow[1] == 1; + } else { + i = j; + continue; + } + i += clen; + if (overflow || cc >= charlimit || i >= len || cstrBytes[cstr + i] != ';') { + i = j; + continue; + } + if (dest == null) { + dest = RubyString.newStringLight(runtime, len); + } + dest.cat(cstrBytes, cstr + beg, plen); + if (charlimit > 256) { + dest.cat(buf, 0, enc.codeToMbc(cc, buf, 0)); + } else { + c = cc; + dest.cat(c); + } + beg = i + 1; + continue; + default: + --i; + continue; + } + if (dest == null) { + dest = RubyString.newStringLight(runtime, len); + } + dest.cat(cstrBytes, cstr + beg, plen); + dest.cat(c); + beg = i + 1; + } + + if (dest != null) { + dest.cat(cstrBytes, cstr + beg, len - beg); + preserve_original_state(str, dest); + return dest; + } else { + return str.strDup(runtime); + } + } + + static boolean ISXDIGIT(byte[] cstrBytes, int i) { + byte cstrByte = cstrBytes[i]; + return (cstrByte >= '0' && cstrByte <= '9') || (cstrByte >= 'a' && cstrByte <= 'f') || (cstrByte >= 'A' && cstrByte <= 'F'); + } + + static boolean url_unreserved_char(int c) { + switch (c) { + case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': + case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': case 'g': case 'h': case 'i': case 'j': + case 'k': case 'l': case 'm': case 'n': case 'o': case 'p': case 'q': case 'r': case 's': case 't': + case 'u': case 'v': case 'w': case 'x': case 'y': case 'z': + case 'A': case 'B': case 'C': case 'D': case 'E': case 'F': case 'G': case 'H': case 'I': case 'J': + case 'K': case 'L': case 'M': case 'N': case 'O': case 'P': case 'Q': case 'R': case 'S': case 'T': + case 'U': case 'V': case 'W': case 'X': case 'Y': case 'Z': + case '-': case '.': case '_': case '~': + return true; + default: + break; + } + return false; + } + + static final byte[] upper_hexdigits = "0123456789ABCDEF".getBytes(RubyEncoding.UTF8); + + static IRubyObject optimized_escape(Ruby runtime, RubyString str, boolean escapePlus) { + int i, len, beg = 0; + RubyString dest = null; + byte[] cstrBytes; + int cstr; + byte[] buf = {'%', 0, 0}; + + len = str.size(); + ByteList byteList = str.getByteList(); + cstrBytes = byteList.unsafeBytes(); + cstr = byteList.begin(); + + for (i = 0; i < len; ++i) { + int c = cstrBytes[cstr + i] & 0xFF; + if (!url_unreserved_char(c)) { + if (dest == null) { + dest = RubyString.newStringLight(runtime, len); + } + + dest.cat(cstrBytes, cstr + beg, i - beg); + beg = i + 1; + + if (escapePlus && c == ' ') { + dest.cat('+'); + } else { + buf[1] = upper_hexdigits[(c >> 4) & 0xf]; + buf[2] = upper_hexdigits[c & 0xf]; + dest.cat(buf, 0, 3); + } + } + } + + if (dest != null) { + dest.cat(cstrBytes, cstr + beg, len - beg); + preserve_original_state(str, dest); + return dest; + } else { + return str.strDup(runtime); + } + } + + static IRubyObject + optimized_unescape(ThreadContext context, RubyString str, IRubyObject encoding, boolean unescapePlus) { + int i, len, beg = 0; + RubyString dest = null; + byte[] cstrBytes; + int cstr; + int cr; + Encoding origenc, encidx = EncodingUtils.rbToEncoding(context, encoding); + + len = str.size(); + ByteList byteList = str.getByteList(); + cstrBytes = byteList.unsafeBytes(); + cstr = byteList.begin(); + + int buf = 0; + Ruby runtime = context.runtime; + + for (i = 0; i < len; ++i) { + int c = cstrBytes[cstr + i] & 0xFF; + int clen = 0; + if (c == '%') { + if (i + 3 > len) break; + if (!ISXDIGIT(cstrBytes, cstr + i + 1)) continue; + if (!ISXDIGIT(cstrBytes, cstr + i + 2)) continue; + buf = ((char_to_number(cstrBytes[cstr + i + 1]) << 4) + | char_to_number(cstrBytes[cstr + i + 2])); + clen = 2; + } else if (unescapePlus && c == '+') { + buf = ' '; + } else { + continue; + } + + if (dest == null) { + dest = RubyString.newStringLight(runtime, len); + } + + dest.cat(cstrBytes, cstr + beg, i - beg); + i += clen; + beg = i + 1; + + dest.cat(buf); + } + + if (dest != null) { + dest.cat(cstrBytes, cstr + beg, len - beg); + preserve_original_state(str, dest); + cr = StringSupport.CR_UNKNOWN; + } else { + dest = str.strDup(runtime); + cr = str.getCodeRange(); + } + origenc = str.getEncoding(); + if (origenc != encidx) { + dest.setEncoding(encidx); + if (StringSupport.encCoderangeClean(dest.getCodeRange()) == 0) { + dest.setEncoding(origenc); + if (cr != StringSupport.CR_UNKNOWN) + dest.setCodeRange(cr); + } + } + return dest; + } + + /* + * call-seq: + * CGI.escapeHTML(string) -> string + * + * Returns HTML-escaped string. + * + */ + @JRubyMethod(name = "escapeHTML", module = true, frame = true) + public static IRubyObject cgiesc_escape_html(ThreadContext context, IRubyObject self, IRubyObject _str) { + RubyString str = _str.convertToString(); + + if (str.getEncoding().isAsciiCompatible()) { + return optimized_escape_html(context.runtime, str); + } else { + return Helpers.invokeSuper(context, self, _str, Block.NULL_BLOCK); + } + } + + /* + * call-seq: + * CGI.unescapeHTML(string) -> string + * + * Returns HTML-unescaped string. + * + */ + @JRubyMethod(name = "unescapeHTML", module = true, frame = true) + public static IRubyObject cgiesc_unescape_html(ThreadContext context, IRubyObject self, IRubyObject _str) { + RubyString str = _str.convertToString(); + + if (str.getEncoding().isAsciiCompatible()) { + return optimized_unescape_html(context.runtime, str); + } else { + return Helpers.invokeSuper(context, self, _str, Block.NULL_BLOCK); + } + } + + /* + * call-seq: + * CGI.escape(string) -> string + * + * Returns URL-escaped string. + * + */ + @JRubyMethod(name = "escape", module = true, frame = true) + public static IRubyObject cgiesc_escape(ThreadContext context, IRubyObject self, IRubyObject _str) { + RubyString str = _str.convertToString(); + + if (str.getEncoding().isAsciiCompatible()) { + return optimized_escape(context.runtime, str, true); + } else { + return Helpers.invokeSuper(context, self, _str, Block.NULL_BLOCK); + } + } + + /* + * call-seq: + * CGI.escapeURIComponent(string) -> string + * + * Returns URL-escaped string following RFC 3986. + * + */ + @JRubyMethod(name = "escapeURIComponent", alias = { "escape_uri_component" }, module = true, frame = true) + public static IRubyObject cgiesc_escape_uri_component(ThreadContext context, IRubyObject self, IRubyObject _str) { + RubyString str = _str.convertToString(); + + if (str.getEncoding().isAsciiCompatible()) { + return optimized_escape(context.runtime, str, false); + } else { + return Helpers.invokeSuper(context, self, _str, Block.NULL_BLOCK); + } + } + + static IRubyObject accept_charset(IRubyObject[] args, int argc, int argv, IRubyObject self) { + if (argc > 0) + return args[argv]; + return self.getMetaClass().getClassVar(ACCEPT_CHARSET); + } + + /* + * call-seq: + * CGI.unescape(string, encoding=@@accept_charset) -> string + * + * Returns URL-unescaped string. + * + */ + @JRubyMethod(name = "unescape", required = 1, optional = 1, module = true, frame = true) + public static IRubyObject cgiesc_unescape(ThreadContext context, IRubyObject self, IRubyObject[] argv) { + IRubyObject _str = argv[0]; + + RubyString str = _str.convertToString(); + + if (str.getEncoding().isAsciiCompatible()) { + IRubyObject enc = accept_charset(argv, argv.length - 1, 1, self); + return optimized_unescape(context, str, enc, true); + } else { + return Helpers.invokeSuper(context, self, argv, Block.NULL_BLOCK); + } + } + + /* + * call-seq: + * CGI.unescapeURIComponent(string, encoding=@@accept_charset) -> string + * + * Returns URL-unescaped string following RFC 3986. + * + */ + @JRubyMethod(name = "unescapeURIComponent", alias = { "unescape_uri_component" }, required = 1, optional = 1, module = true, frame = true) + public static IRubyObject cgiesc_unescape_uri_component(ThreadContext context, IRubyObject self, IRubyObject[] argv) { + IRubyObject _str = argv[0]; + + RubyString str = _str.convertToString(); + + if (str.getEncoding().isAsciiCompatible()) { + IRubyObject enc = accept_charset(argv, argv.length - 1, 1, self); + return optimized_unescape(context, str, enc, false); + } else { + return Helpers.invokeSuper(context, self, argv, Block.NULL_BLOCK); + } + } + + public void load(Ruby runtime, boolean wrap) { + RubyClass rb_cCGI = runtime.defineClass("CGI", runtime.getObject(), runtime.getObject().getAllocator()); + RubyModule rb_mEscape = rb_cCGI.defineModuleUnder("Escape"); + RubyModule rb_mUtil = rb_cCGI.defineModuleUnder("Util"); + rb_mEscape.defineAnnotatedMethods(CGIEscape.class); + rb_mUtil.prependModule(rb_mEscape); + rb_mEscape.extend_object(rb_cCGI); + } + + // PORTED FROM OTHER FILES IN MRI + + static int ruby_scan_digits(byte[] strBytes, int str, int len, int base, int[] retlenOverflow) { + int start = str; + int ret = 0, x; + int mul_overflow = Integer.MAX_VALUE / base; + + retlenOverflow[1] = 0; + + if (len == 0) { + retlenOverflow[0] = 0; + return 0; + } + + do { + int d = ruby_digit36_to_number_table[strBytes[str++]]; + if (d == -1 || base <= d) { + --str; + break; + } + if (mul_overflow < ret) + retlenOverflow[1] = 1; + ret *= base; + x = ret; + ret += d; + if (ret < x) + retlenOverflow[1] = 1; + } while (len < 0 || (--len != 0)); + retlenOverflow[0] = str - start; + return ret; + } + + static int char_to_number(int c) { + return ruby_digit36_to_number_table[c]; + } + + private static final int ruby_digit36_to_number_table[] = { + /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */ + /*0*/ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + /*1*/ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + /*2*/ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + /*3*/ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -1, -1, -1, -1, -1, -1, + /*4*/ -1, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, + /*5*/ 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, -1, -1, -1, -1, -1, + /*6*/ -1, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, + /*7*/ 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, -1, -1, -1, -1, -1, + /*8*/ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + /*9*/ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + /*a*/ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + /*b*/ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + /*c*/ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + /*d*/ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + /*e*/ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + /*f*/ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + }; +} diff --git a/lib/pom.rb b/lib/pom.rb index 6ac07d539a2..c0fbb87d113 100644 --- a/lib/pom.rb +++ b/lib/pom.rb @@ -23,7 +23,6 @@ def log(message = nil) # - we do not want bin/update_rubygems or bin/gem overrides ['rubygems-update', '4.0.3', { bin: false, require_paths: ['lib'] }], ['bundler', '4.0.3'], - ['cgi', '0.4.2'], # Currently using a stub gem for JRuby until we can incorporate our code. # https://github.com/ruby/date/issues/48 ['date', '3.5.1'], diff --git a/lib/pom.xml b/lib/pom.xml index a1037c32387..a1745224dc4 100644 --- a/lib/pom.xml +++ b/lib/pom.xml @@ -57,19 +57,6 @@ DO NOT MODIFY - GENERATED CODE - - rubygems - cgi - 0.4.2 - gem - provided - - - rubygems - jar-dependencies - - - rubygems date @@ -1133,7 +1120,6 @@ DO NOT MODIFY - GENERATED CODE specifications/default/* specifications/rubygems-update-4.0.3* specifications/bundler-4.0.3* - specifications/cgi-0.4.2* specifications/date-3.5.1* specifications/delegate-0.6.1* specifications/did_you_mean-2.0.0* @@ -1216,7 +1202,6 @@ DO NOT MODIFY - GENERATED CODE specifications/test-unit-3.7.5* gems/rubygems-update-4.0.3*/**/* gems/bundler-4.0.3*/**/* - gems/cgi-0.4.2*/**/* gems/date-3.5.1*/**/* gems/delegate-0.6.1*/**/* gems/did_you_mean-2.0.0*/**/* @@ -1299,7 +1284,6 @@ DO NOT MODIFY - GENERATED CODE gems/test-unit-3.7.5*/**/* cache/rubygems-update-4.0.3* cache/bundler-4.0.3* - cache/cgi-0.4.2* cache/date-3.5.1* cache/delegate-0.6.1* cache/did_you_mean-2.0.0* diff --git a/lib/ruby/stdlib/cgi.rb b/lib/ruby/stdlib/cgi.rb new file mode 100644 index 00000000000..bb306d2e064 --- /dev/null +++ b/lib/ruby/stdlib/cgi.rb @@ -0,0 +1,7 @@ +# frozen_string_literal: true + +require "cgi/escape" +warn <<-WARNING, uplevel: Gem::BUNDLED_GEMS.uplevel if $VERBOSE +CGI library is removed from Ruby 4.0. Please use cgi/escape instead for CGI.escape and CGI.unescape features. +If you need to use the full features of CGI library, Please install cgi gem. +WARNING diff --git a/lib/ruby/stdlib/cgi/escape.rb b/lib/ruby/stdlib/cgi/escape.rb new file mode 100644 index 00000000000..92470c81bb3 --- /dev/null +++ b/lib/ruby/stdlib/cgi/escape.rb @@ -0,0 +1,236 @@ +# frozen_string_literal: true + +# Since Ruby 4.0, \CGI is a small holder for various escaping methods, included from CGI::Escape +# +# require 'cgi/escape' +# +# CGI.escape("Ruby programming language") +# #=> "Ruby+programming+language" +# CGI.escapeURIComponent("Ruby programming language") +# #=> "Ruby%20programming%20language" +# +# See CGI::Escape module for methods list and their description. +class CGI + module Escape; end + include Escape + extend Escape + module EscapeExt; end # :nodoc: +end + +# Web-related escape/unescape functionality. +module CGI::Escape + @@accept_charset = Encoding::UTF_8 unless defined?(@@accept_charset) + + # URL-encode a string into application/x-www-form-urlencoded. + # Space characters (" ") are encoded with plus signs ("+") + # url_encoded_string = CGI.escape("'Stop!' said Fred") + # # => "%27Stop%21%27+said+Fred" + def escape(string) + encoding = string.encoding + buffer = string.b + buffer.gsub!(/([^ a-zA-Z0-9_.\-~]+)/) do |m| + '%' + m.unpack('H2' * m.bytesize).join('%').upcase + end + buffer.tr!(' ', '+') + buffer.force_encoding(encoding) + end + + # URL-decode an application/x-www-form-urlencoded string with encoding(optional). + # string = CGI.unescape("%27Stop%21%27+said+Fred") + # # => "'Stop!' said Fred" + def unescape(string, encoding = @@accept_charset) + str = string.tr('+', ' ') + str = str.b + str.gsub!(/((?:%[0-9a-fA-F]{2})+)/) do |m| + [m.delete('%')].pack('H*') + end + str.force_encoding(encoding) + str.valid_encoding? ? str : str.force_encoding(string.encoding) + end + + # URL-encode a string following RFC 3986 + # Space characters (" ") are encoded with ("%20") + # url_encoded_string = CGI.escapeURIComponent("'Stop!' said Fred") + # # => "%27Stop%21%27%20said%20Fred" + def escapeURIComponent(string) + encoding = string.encoding + buffer = string.b + buffer.gsub!(/([^a-zA-Z0-9_.\-~]+)/) do |m| + '%' + m.unpack('H2' * m.bytesize).join('%').upcase + end + buffer.force_encoding(encoding) + end + alias escape_uri_component escapeURIComponent + + # URL-decode a string following RFC 3986 with encoding(optional). + # string = CGI.unescapeURIComponent("%27Stop%21%27+said%20Fred") + # # => "'Stop!'+said Fred" + def unescapeURIComponent(string, encoding = @@accept_charset) + str = string.b + str.gsub!(/((?:%[0-9a-fA-F]{2})+)/) do |m| + [m.delete('%')].pack('H*') + end + str.force_encoding(encoding) + str.valid_encoding? ? str : str.force_encoding(string.encoding) + end + + alias unescape_uri_component unescapeURIComponent + + # The set of special characters and their escaped values + TABLE_FOR_ESCAPE_HTML__ = { # :nodoc: + "'" => ''', + '&' => '&', + '"' => '"', + '<' => '<', + '>' => '>', + } + + # \Escape special characters in HTML, namely '&\"<> + # CGI.escapeHTML('Usage: foo "bar" ') + # # => "Usage: foo "bar" <baz>" + def escapeHTML(string) + enc = string.encoding + unless enc.ascii_compatible? + if enc.dummy? + origenc = enc + enc = Encoding::Converter.asciicompat_encoding(enc) + string = enc ? string.encode(enc) : string.b + end + table = Hash[TABLE_FOR_ESCAPE_HTML__.map {|pair|pair.map {|s|s.encode(enc)}}] + string = string.gsub(/#{"['&\"<>]".encode(enc)}/, table) + string.encode!(origenc) if origenc + string + else + string = string.b + string.gsub!(/['&\"<>]/, TABLE_FOR_ESCAPE_HTML__) + string.force_encoding(enc) + end + end + + # Unescape a string that has been HTML-escaped + # CGI.unescapeHTML("Usage: foo "bar" <baz>") + # # => "Usage: foo \"bar\" " + def unescapeHTML(string) + enc = string.encoding + unless enc.ascii_compatible? + if enc.dummy? + origenc = enc + enc = Encoding::Converter.asciicompat_encoding(enc) + string = enc ? string.encode(enc) : string.b + end + string = string.gsub(Regexp.new('&(apos|amp|quot|gt|lt|#[0-9]+|#x[0-9A-Fa-f]+);'.encode(enc))) do + case $1.encode(Encoding::US_ASCII) + when 'apos' then "'".encode(enc) + when 'amp' then '&'.encode(enc) + when 'quot' then '"'.encode(enc) + when 'gt' then '>'.encode(enc) + when 'lt' then '<'.encode(enc) + when /\A#0*(\d+)\z/ then $1.to_i.chr(enc) + when /\A#x([0-9a-f]+)\z/i then $1.hex.chr(enc) + end + end + string.encode!(origenc) if origenc + return string + end + return string unless string.include? '&' + charlimit = case enc + when Encoding::UTF_8; 0x10ffff + when Encoding::ISO_8859_1; 256 + else 128 + end + string = string.b + string.gsub!(/&(apos|amp|quot|gt|lt|\#[0-9]+|\#[xX][0-9A-Fa-f]+);/) do + match = $1.dup + case match + when 'apos' then "'" + when 'amp' then '&' + when 'quot' then '"' + when 'gt' then '>' + when 'lt' then '<' + when /\A#0*(\d+)\z/ + n = $1.to_i + if n < charlimit + n.chr(enc) + else + "&##{$1};" + end + when /\A#x([0-9a-f]+)\z/i + n = $1.hex + if n < charlimit + n.chr(enc) + else + "&#x#{$1};" + end + else + "&#{match};" + end + end + string.force_encoding enc + end + + alias escape_html escapeHTML + alias h escapeHTML + + alias unescape_html unescapeHTML + + case RUBY_ENGINE + when "jruby" + JRuby::Util.load_ext("org.jruby.ext.cgi.escape.CGIEscape") + when "truffleruby" + # TruffleRuby runs the pure-Ruby variant faster, do not use the C extension there + else + begin + require 'cgi/escape.so' + rescue LoadError + end + end + + # \Escape only the tags of certain HTML elements in +string+. + # + # Takes an element or elements or array of elements. Each element + # is specified by the name of the element, without angle brackets. + # This matches both the start and the end tag of that element. + # The attribute list of the open tag will also be escaped (for + # instance, the double-quotes surrounding attribute values). + # + # print CGI.escapeElement('
', "A", "IMG") + # # "
<A HREF="url"></A>" + # + # print CGI.escapeElement('
', ["A", "IMG"]) + # # "
<A HREF="url"></A>" + def escapeElement(string, *elements) + elements = elements[0] if elements[0].kind_of?(Array) + unless elements.empty? + string.gsub(/<\/?(?:#{elements.join("|")})\b[^<>]*+>?/im) do + CGI.escapeHTML($&) + end + else + string + end + end + + # Undo escaping such as that done by CGI.escapeElement + # + # print CGI.unescapeElement( + # CGI.escapeHTML('
'), "A", "IMG") + # # "<BR>" + # + # print CGI.unescapeElement( + # CGI.escapeHTML('
'), ["A", "IMG"]) + # # "<BR>" + def unescapeElement(string, *elements) + elements = elements[0] if elements[0].kind_of?(Array) + unless elements.empty? + string.gsub(/<\/?(?:#{elements.join("|")})\b(?>[^&]+|&(?![gl]t;)\w+;)*(?:>)?/im) do + unescapeHTML($&) + end + else + string + end + end + + alias escape_element escapeElement + + alias unescape_element unescapeElement + +end diff --git a/lib/ruby/stdlib/cgi/util.rb b/lib/ruby/stdlib/cgi/util.rb new file mode 100644 index 00000000000..50a2e91665e --- /dev/null +++ b/lib/ruby/stdlib/cgi/util.rb @@ -0,0 +1,7 @@ +# frozen_string_literal: true + +require "cgi/escape" +warn <<-WARNING, uplevel: Gem::BUNDLED_GEMS.uplevel if $VERBOSE +CGI::Util is removed from Ruby 4.0. Please use cgi/escape instead for CGI.escape and CGI.unescape features. +If you are using CGI.parse, please install and use the cgi gem instead. +WARNING From 1bc93aa0c3c40327235b644e504d9f679f806ddd Mon Sep 17 00:00:00 2001 From: Charles Oliver Nutter Date: Wed, 14 Jan 2026 11:59:58 -0600 Subject: [PATCH 068/168] Implement implicit param logic for Binding See https://bugs.ruby-lang.org/issues/21049 --- core/src/main/java/org/jruby/RubyBinding.java | 38 +++++++++++ .../java/org/jruby/parser/StaticScope.java | 68 +++++++++++++++---- 2 files changed, 94 insertions(+), 12 deletions(-) diff --git a/core/src/main/java/org/jruby/RubyBinding.java b/core/src/main/java/org/jruby/RubyBinding.java index 66465e4d8ec..98e249262c2 100644 --- a/core/src/main/java/org/jruby/RubyBinding.java +++ b/core/src/main/java/org/jruby/RubyBinding.java @@ -177,6 +177,26 @@ public IRubyObject local_variable_set(ThreadContext context, IRubyObject symbol, return evalScope.setValue(slot & 0xffff, value, slot >> 16); } + @JRubyMethod(name = "implicit_parameter_defined?") + public IRubyObject implicit_parameter_defined_p(ThreadContext context, IRubyObject symbol) { + String id = checkImplicitId(context, symbol); + return asBoolean(context, binding.getEvalScope(context.runtime).getStaticScope().isDefined(id) != -1); + } + + @JRubyMethod + public IRubyObject implicit_parameter_get(ThreadContext context, IRubyObject symbol) { + String id = checkImplicitId(context, symbol); + DynamicScope evalScope = binding.getEvalScope(context.runtime); + StaticScope staticScope = evalScope.getStaticScope(); + int slot = staticScope.isDefinedNotImplicit(id); + + if (slot != StaticScope.IMPLICIT) throw undefinedImplicitVariableError(context, symbol); + + slot = staticScope.isDefined(id); + + return evalScope.getValueOrNil(slot & 0xffff, slot >> 16, context.nil); + } + private static boolean isNumberedVariable(String id) { return id.length() == 2 && id.charAt(0) == '_' && Character.isDigit(id.charAt(1)); } @@ -189,6 +209,10 @@ private RaiseException undefinedVariableError(ThreadContext context, IRubyObject return nameError(context, str(context.runtime, "local variable '", symbol, "' not defined for " + inspect(context)), symbol); } + private RaiseException undefinedImplicitVariableError(ThreadContext context, IRubyObject symbol) { + return nameError(context, str(context.runtime, "'", symbol, "' is not an implicit parameter"), symbol); + } + // MRI: check_local_id private String checkLocalId(ThreadContext context, IRubyObject obj) { String id = RubySymbol.idStringFromObject(context, obj); @@ -201,11 +225,25 @@ private String checkLocalId(ThreadContext context, IRubyObject obj) { return id; } + + private String checkImplicitId(ThreadContext context, IRubyObject obj) { + String id = RubySymbol.idStringFromObject(context, obj); + + if (!isNumberedVariable(id) && !id.equals("it")) throw undefinedImplicitVariableError(context, obj); + + return id; + } + @JRubyMethod public IRubyObject local_variables(ThreadContext context) { return binding.getEvalScope(context.runtime).getStaticScope().getLocalVariables(context); } + @JRubyMethod + public IRubyObject implicit_parameters(ThreadContext context) { + return binding.getEvalScope(context.runtime).getStaticScope().getImplicitLocalVariables(context); + } + @JRubyMethod(name = "receiver") public IRubyObject receiver(ThreadContext context) { return binding.getSelf(); diff --git a/core/src/main/java/org/jruby/parser/StaticScope.java b/core/src/main/java/org/jruby/parser/StaticScope.java index 9cd2fc288a5..8cf96735d86 100644 --- a/core/src/main/java/org/jruby/parser/StaticScope.java +++ b/core/src/main/java/org/jruby/parser/StaticScope.java @@ -547,6 +547,25 @@ public T collectVariables(IntFunction collectionFactory, BiConsumer T collectVariables(ThreadContext context, BiFunction collectionFactory, BiConsumer collectionPopulator) { + return collectVariables(context, collectionFactory, collectionPopulator, false); + } + + /** + * Populate a deduplicated collection of implicit variable names("it", "_1", etc) in scope using the given functions. + * + * This may include variables that are not strictly Ruby local variable names, so the consumer should validate + * names as appropriate. + * + * @param collectionFactory used to construct the collection + * @param collectionPopulator used to pass values into the collection + * @param resulting collection type + * @return populated collection + */ + public T collectImplicitVariables(ThreadContext context, BiFunction collectionFactory, BiConsumer collectionPopulator) { + return collectVariables(context, collectionFactory, collectionPopulator, true); + } + + public T collectVariables(ThreadContext context, BiFunction collectionFactory, BiConsumer collectionPopulator, boolean implicit) { StaticScope current = this; T collection = collectionFactory.apply(context, current.variableNamesLength); @@ -554,24 +573,34 @@ public T collectVariables(ThreadContext context, BiFunction dedup = new HashMap<>(); while (current.isBlockOrEval) { - addVariableNamesToCollection(current, collectionPopulator, dedup, collection); + addVariableNamesToCollection(current, collectionPopulator, dedup, collection, implicit); current = current.enclosingScope; } // once more for method scope - addVariableNamesToCollection(current, collectionPopulator, dedup, collection); + addVariableNamesToCollection(current, collectionPopulator, dedup, collection, implicit); return collection; } - private static void addVariableNamesToCollection(StaticScope current, BiConsumer collectionPopulator, HashMap dedup, T collection) { + private static void addVariableNamesToCollection(StaticScope current, BiConsumer collectionPopulator, HashMap dedup, T collection, boolean implicit) { BitSet implicitVariables = current.implicitVariables; - for (int i = 0; i < current.variableNamesLength; i++) { - if (implicitVariables != null && implicitVariables.get(i)) continue; - String name = current.variableNames[i]; + boolean hasImplicits = implicitVariables != null; + if (implicit && !hasImplicits) return; + + int variableNamesLength = current.variableNamesLength; + String[] variableNames = current.variableNames; + + for (int i = 0; i < variableNamesLength; i++) { + if (hasImplicits && implicitVariables.get(i)) { + if (!implicit) continue; + } else if (implicit) continue; + + String name = variableNames[i]; dedup.computeIfAbsent(name, key -> { - collectionPopulator.accept(collection, key); return key;}); + collectionPopulator.accept(collection, key); + return key;}); } } @@ -589,11 +618,26 @@ public RubyArray getLocalVariables(Ruby runtime) { public RubyArray getLocalVariables(ThreadContext context) { return collectVariables( context, - (ctxt, length) -> allocArray(ctxt, length), - (array, id) -> { - RubySymbol symbol = Convert.asSymbol(context, id); - if (symbol.validLocalVariableName()) array.append(context, symbol); - }); + Create::allocArray, + (array, id) -> appendVariableIfValid(context, array, id)); + } + + /** + * Get a Ruby Array of all implicit local variables. + * + * @param context the current context + * @return populated RubyArray + */ + public RubyArray getImplicitLocalVariables(ThreadContext context) { + return collectImplicitVariables( + context, + Create::allocArray, + (array, id) -> appendVariableIfValid(context, array, id)); + } + + private static void appendVariableIfValid(ThreadContext context, RubyArray array, String id) { + RubySymbol symbol = Convert.asSymbol(context, id); + if (symbol.validLocalVariableName()) array.append(context, symbol); } public int isDefined(String name, int depth) { From 2719a900fc48f7f66f7f40518fa965e84a2e8388 Mon Sep 17 00:00:00 2001 From: Charles Oliver Nutter Date: Wed, 14 Jan 2026 12:48:54 -0600 Subject: [PATCH 069/168] Update reline tests --- test/mri/reline/helper.rb | 42 +- test/mri/reline/test_config.rb | 17 + test/mri/reline/test_key_actor_emacs.rb | 664 +++++++++--------- test/mri/reline/test_key_actor_vi.rb | 23 +- test/mri/reline/test_reline.rb | 27 +- test/mri/reline/test_unicode.rb | 58 +- test/mri/reline/test_within_pipe.rb | 16 +- test/mri/reline/yamatanooroti/multiline_repl | 4 +- .../reline/yamatanooroti/test_rendering.rb | 105 ++- 9 files changed, 562 insertions(+), 394 deletions(-) diff --git a/test/mri/reline/helper.rb b/test/mri/reline/helper.rb index 37a99bb18a8..6f470a617fe 100644 --- a/test/mri/reline/helper.rb +++ b/test/mri/reline/helper.rb @@ -86,26 +86,12 @@ def test_rubybin end class Reline::TestCase < Test::Unit::TestCase - private def convert_str(input, options = {}, normalized = nil) - return nil if input.nil? - input = input.chars.map { |c| - if Reline::Unicode::EscapedChars.include?(c.ord) - c - else - c.encode(@line_editor.encoding, Encoding::UTF_8, **options) - end - }.join - rescue Encoding::UndefinedConversionError, Encoding::InvalidByteSequenceError - if unicode?(input.encoding) - input = input.unicode_normalize(:nfc) - if normalized - options[:undef] = :replace - options[:replace] = '?' - end - normalized = true - retry - end - input + private def convert_str(input) + input.encode(@line_editor.encoding, Encoding::UTF_8) + end + + def omit_unless_utf8 + omit "This test is for UTF-8 but the locale is #{Reline.core.encoding}" if Reline.core.encoding != Encoding::UTF_8 end def input_key_by_symbol(method_symbol, char: nil, csi: false) @@ -113,17 +99,9 @@ def input_key_by_symbol(method_symbol, char: nil, csi: false) @line_editor.input_key(Reline::Key.new(char, method_symbol, false)) end - def input_keys(input, convert = true) - # Reline does not support convert-meta, but test data includes \M-char. It should be converted to ESC+char. - # Note that mixing unicode chars and \M-char is not recommended. "\M-C\M-\C-A" is a single unicode character. - input = input.chars.map do |c| - c.valid_encoding? ? c : "\e#{(c.bytes[0] & 0x7f).chr}" - end.join - input_raw_keys(input, convert) - end + def input_keys(input) + input = convert_str(input) - def input_raw_keys(input, convert = true) - input = convert_str(input) if convert key_stroke = Reline::KeyStroke.new(@config, @encoding) input_bytes = input.bytes until input_bytes.empty? @@ -177,8 +155,4 @@ def assert_key_binding(input, method_symbol, editing_modes = [:emacs, :vi_insert assert_equal(method_symbol, @config.editing_mode.get(input.bytes)) end end - - private def unicode?(encoding) - [Encoding::UTF_8, Encoding::UTF_16BE, Encoding::UTF_16LE, Encoding::UTF_32BE, Encoding::UTF_32LE].include?(encoding) - end end diff --git a/test/mri/reline/test_config.rb b/test/mri/reline/test_config.rb index 3c9094eeced..ff3e121ab0f 100644 --- a/test/mri/reline/test_config.rb +++ b/test/mri/reline/test_config.rb @@ -613,4 +613,21 @@ def test_reload @config.reload assert_equal '@', @config.emacs_mode_string end + + def test_invalid_byte_sequence_inputrc + lines = [ + "set vi-cmd-mode-string\n", + "$if Ruby\n", + " \"\C-a\": \"Ruby\"\n", + "$else \"\xFF\"\n".dup.force_encoding(Reline.encoding_system_needs), # Invalid byte sequence + " \"\C-b\": \"NotRuby\"\n", + "$endif\n" + ] + + e = assert_raise(Reline::Config::InvalidInputrc) do + @config.read_lines(lines, "INPUTRC") + end + + assert_equal "INPUTRC:4: can't be converted to the locale #{Reline.encoding_system_needs}", e.message + end end diff --git a/test/mri/reline/test_key_actor_emacs.rb b/test/mri/reline/test_key_actor_emacs.rb index e52c6c2d9ae..aa608641c3c 100644 --- a/test/mri/reline/test_key_actor_emacs.rb +++ b/test/mri/reline/test_key_actor_emacs.rb @@ -38,11 +38,13 @@ def test_ed_insert_mbchar_two end def test_ed_insert_for_mbchar_by_plural_code_points + omit_unless_utf8 input_keys("か\u3099") assert_line_around_cursor("か\u3099", '') end def test_ed_insert_for_plural_mbchar_by_plural_code_points + omit_unless_utf8 input_keys("か\u3099き\u3099") assert_line_around_cursor("か\u3099き\u3099", '') end @@ -50,11 +52,11 @@ def test_ed_insert_for_plural_mbchar_by_plural_code_points def test_move_next_and_prev input_keys('abd') assert_line_around_cursor('abd', '') - input_keys("\C-b", false) + input_keys("\C-b") assert_line_around_cursor('ab', 'd') - input_keys("\C-b", false) + input_keys("\C-b") assert_line_around_cursor('a', 'bd') - input_keys("\C-f", false) + input_keys("\C-f") assert_line_around_cursor('ab', 'd') input_keys('c') assert_line_around_cursor('abc', 'd') @@ -63,24 +65,25 @@ def test_move_next_and_prev def test_move_next_and_prev_for_mbchar input_keys('かきけ') assert_line_around_cursor('かきけ', '') - input_keys("\C-b", false) + input_keys("\C-b") assert_line_around_cursor('かき', 'け') - input_keys("\C-b", false) + input_keys("\C-b") assert_line_around_cursor('か', 'きけ') - input_keys("\C-f", false) + input_keys("\C-f") assert_line_around_cursor('かき', 'け') input_keys('く') assert_line_around_cursor('かきく', 'け') end def test_move_next_and_prev_for_mbchar_by_plural_code_points + omit_unless_utf8 input_keys("か\u3099き\u3099け\u3099") assert_line_around_cursor("か\u3099き\u3099け\u3099", '') - input_keys("\C-b", false) + input_keys("\C-b") assert_line_around_cursor("か\u3099き\u3099", "け\u3099") - input_keys("\C-b", false) + input_keys("\C-b") assert_line_around_cursor("か\u3099", "き\u3099け\u3099") - input_keys("\C-f", false) + input_keys("\C-f") assert_line_around_cursor("か\u3099き\u3099", "け\u3099") input_keys("く\u3099") assert_line_around_cursor("か\u3099き\u3099く\u3099", "け\u3099") @@ -89,11 +92,11 @@ def test_move_next_and_prev_for_mbchar_by_plural_code_points def test_move_to_beg_end input_keys('bcd') assert_line_around_cursor('bcd', '') - input_keys("\C-a", false) + input_keys("\C-a") assert_line_around_cursor('', 'bcd') input_keys('a') assert_line_around_cursor('a', 'bcd') - input_keys("\C-e", false) + input_keys("\C-e") assert_line_around_cursor('abcd', '') input_keys('e') assert_line_around_cursor('abcde', '') @@ -103,7 +106,7 @@ def test_ed_newline_with_cr input_keys('ab') assert_line_around_cursor('ab', '') refute(@line_editor.finished?) - input_keys("\C-m", false) + input_keys("\C-m") assert_line_around_cursor('ab', '') assert(@line_editor.finished?) end @@ -112,7 +115,7 @@ def test_ed_newline_with_lf input_keys('ab') assert_line_around_cursor('ab', '') refute(@line_editor.finished?) - input_keys("\C-j", false) + input_keys("\C-j") assert_line_around_cursor('ab', '') assert(@line_editor.finished?) end @@ -120,21 +123,22 @@ def test_ed_newline_with_lf def test_em_delete_prev_char input_keys('ab') assert_line_around_cursor('ab', '') - input_keys("\C-h", false) + input_keys("\C-h") assert_line_around_cursor('a', '') end def test_em_delete_prev_char_for_mbchar input_keys('かき') assert_line_around_cursor('かき', '') - input_keys("\C-h", false) + input_keys("\C-h") assert_line_around_cursor('か', '') end def test_em_delete_prev_char_for_mbchar_by_plural_code_points + omit_unless_utf8 input_keys("か\u3099き\u3099") assert_line_around_cursor("か\u3099き\u3099", '') - input_keys("\C-h", false) + input_keys("\C-h") assert_line_around_cursor("か\u3099", '') end @@ -160,13 +164,13 @@ def test_ed_quoted_insert_with_vi_arg end def test_ed_kill_line - input_keys("\C-k", false) + input_keys("\C-k") assert_line_around_cursor('', '') input_keys('abc') assert_line_around_cursor('abc', '') - input_keys("\C-k", false) + input_keys("\C-k") assert_line_around_cursor('abc', '') - input_keys("\C-b\C-k", false) + input_keys("\C-b\C-k") assert_line_around_cursor('ab', '') end @@ -177,11 +181,11 @@ def test_em_kill_line input_key_by_symbol(:em_kill_line) assert_line_around_cursor('', '') input_keys('abc') - input_keys("\C-b", false) + input_keys("\C-b") input_key_by_symbol(:em_kill_line) assert_line_around_cursor('', '') input_keys('abc') - input_keys("\C-a", false) + input_keys("\C-a") input_key_by_symbol(:em_kill_line) assert_line_around_cursor('', '') end @@ -189,19 +193,19 @@ def test_em_kill_line def test_ed_move_to_beg input_keys('abd') assert_line_around_cursor('abd', '') - input_keys("\C-b", false) + input_keys("\C-b") assert_line_around_cursor('ab', 'd') input_keys('c') assert_line_around_cursor('abc', 'd') - input_keys("\C-a", false) + input_keys("\C-a") assert_line_around_cursor('', 'abcd') input_keys('012') assert_line_around_cursor('012', 'abcd') - input_keys("\C-a", false) + input_keys("\C-a") assert_line_around_cursor('', '012abcd') input_keys('ABC') assert_line_around_cursor('ABC', '012abcd') - input_keys("\C-f" * 10 + "\C-a", false) + input_keys("\C-f" * 10 + "\C-a") assert_line_around_cursor('', 'ABC012abcd') input_keys('a') assert_line_around_cursor('a', 'ABC012abcd') @@ -210,26 +214,26 @@ def test_ed_move_to_beg def test_ed_move_to_beg_with_blank input_keys(' abc') assert_line_around_cursor(' abc', '') - input_keys("\C-a", false) + input_keys("\C-a") assert_line_around_cursor('', ' abc') end def test_ed_move_to_end input_keys('abd') assert_line_around_cursor('abd', '') - input_keys("\C-b", false) + input_keys("\C-b") assert_line_around_cursor('ab', 'd') input_keys('c') assert_line_around_cursor('abc', 'd') - input_keys("\C-e", false) + input_keys("\C-e") assert_line_around_cursor('abcd', '') input_keys('012') assert_line_around_cursor('abcd012', '') - input_keys("\C-e", false) + input_keys("\C-e") assert_line_around_cursor('abcd012', '') input_keys('ABC') assert_line_around_cursor('abcd012ABC', '') - input_keys("\C-b" * 10 + "\C-e", false) + input_keys("\C-b" * 10 + "\C-e") assert_line_around_cursor('abcd012ABC', '') input_keys('a') assert_line_around_cursor('abcd012ABCa', '') @@ -238,27 +242,28 @@ def test_ed_move_to_end def test_em_delete input_keys('ab') assert_line_around_cursor('ab', '') - input_keys("\C-a", false) + input_keys("\C-a") assert_line_around_cursor('', 'ab') - input_keys("\C-d", false) + input_keys("\C-d") assert_line_around_cursor('', 'b') end def test_em_delete_for_mbchar input_keys('かき') assert_line_around_cursor('かき', '') - input_keys("\C-a", false) + input_keys("\C-a") assert_line_around_cursor('', 'かき') - input_keys("\C-d", false) + input_keys("\C-d") assert_line_around_cursor('', 'き') end def test_em_delete_for_mbchar_by_plural_code_points + omit_unless_utf8 input_keys("か\u3099き\u3099") assert_line_around_cursor("か\u3099き\u3099", '') - input_keys("\C-a", false) + input_keys("\C-a") assert_line_around_cursor('', "か\u3099き\u3099") - input_keys("\C-d", false) + input_keys("\C-d") assert_line_around_cursor('', "き\u3099") end @@ -270,16 +275,16 @@ def test_em_delete_ends_editing def test_ed_clear_screen @line_editor.instance_variable_get(:@rendered_screen).lines = [[]] - input_keys("\C-l", false) + input_keys("\C-l") assert_empty(@line_editor.instance_variable_get(:@rendered_screen).lines) end def test_ed_clear_screen_with_inputted input_keys('abc') - input_keys("\C-b", false) + input_keys("\C-b") @line_editor.instance_variable_get(:@rendered_screen).lines = [[]] assert_line_around_cursor('ab', 'c') - input_keys("\C-l", false) + input_keys("\C-l") assert_empty(@line_editor.instance_variable_get(:@rendered_screen).lines) assert_line_around_cursor('ab', 'c') end @@ -299,7 +304,7 @@ def test_key_delete_does_not_end_editing def test_key_delete_preserves_cursor input_keys('abc') - input_keys("\C-b", false) + input_keys("\C-b") assert_line_around_cursor('ab', 'c') input_key_by_symbol(:key_delete) assert_line_around_cursor('ab', '') @@ -308,289 +313,294 @@ def test_key_delete_preserves_cursor def test_em_next_word assert_line_around_cursor('', '') input_keys('abc def{bbb}ccc') - input_keys("\C-a\M-F", false) + input_keys("\C-a\eF") assert_line_around_cursor('abc', ' def{bbb}ccc') - input_keys("\M-F", false) + input_keys("\eF") assert_line_around_cursor('abc def', '{bbb}ccc') - input_keys("\M-F", false) + input_keys("\eF") assert_line_around_cursor('abc def{bbb', '}ccc') - input_keys("\M-F", false) + input_keys("\eF") assert_line_around_cursor('abc def{bbb}ccc', '') - input_keys("\M-F", false) + input_keys("\eF") assert_line_around_cursor('abc def{bbb}ccc', '') end def test_em_next_word_for_mbchar assert_line_around_cursor('', '') input_keys('あいうかきく{さしす}たちつ') - input_keys("\C-a\M-F", false) + input_keys("\C-a\eF") assert_line_around_cursor('あいう', ' かきく{さしす}たちつ') - input_keys("\M-F", false) + input_keys("\eF") assert_line_around_cursor('あいうかきく', '{さしす}たちつ') - input_keys("\M-F", false) + input_keys("\eF") assert_line_around_cursor('あいうかきく{さしす', '}たちつ') - input_keys("\M-F", false) + input_keys("\eF") assert_line_around_cursor('あいうかきく{さしす}たちつ', '') - input_keys("\M-F", false) + input_keys("\eF") assert_line_around_cursor('あいうかきく{さしす}たちつ', '') end def test_em_next_word_for_mbchar_by_plural_code_points + omit_unless_utf8 assert_line_around_cursor("", "") input_keys("あいうか\u3099き\u3099く\u3099{さしす}たちつ") - input_keys("\C-a\M-F", false) + input_keys("\C-a\eF") assert_line_around_cursor("あいう", " か\u3099き\u3099く\u3099{さしす}たちつ") - input_keys("\M-F", false) + input_keys("\eF") assert_line_around_cursor("あいうか\u3099き\u3099く\u3099", "{さしす}たちつ") - input_keys("\M-F", false) + input_keys("\eF") assert_line_around_cursor("あいうか\u3099き\u3099く\u3099{さしす", "}たちつ") - input_keys("\M-F", false) + input_keys("\eF") assert_line_around_cursor("あいうか\u3099き\u3099く\u3099{さしす}たちつ", "") - input_keys("\M-F", false) + input_keys("\eF") assert_line_around_cursor("あいうか\u3099き\u3099く\u3099{さしす}たちつ", "") end def test_em_prev_word input_keys('abc def{bbb}ccc') assert_line_around_cursor('abc def{bbb}ccc', '') - input_keys("\M-B", false) + input_keys("\eB") assert_line_around_cursor('abc def{bbb}', 'ccc') - input_keys("\M-B", false) + input_keys("\eB") assert_line_around_cursor('abc def{', 'bbb}ccc') - input_keys("\M-B", false) + input_keys("\eB") assert_line_around_cursor('abc ', 'def{bbb}ccc') - input_keys("\M-B", false) + input_keys("\eB") assert_line_around_cursor('', 'abc def{bbb}ccc') - input_keys("\M-B", false) + input_keys("\eB") assert_line_around_cursor('', 'abc def{bbb}ccc') end def test_em_prev_word_for_mbchar input_keys('あいうかきく{さしす}たちつ') assert_line_around_cursor('あいうかきく{さしす}たちつ', '') - input_keys("\M-B", false) + input_keys("\eB") assert_line_around_cursor('あいうかきく{さしす}', 'たちつ') - input_keys("\M-B", false) + input_keys("\eB") assert_line_around_cursor('あいうかきく{', 'さしす}たちつ') - input_keys("\M-B", false) + input_keys("\eB") assert_line_around_cursor('あいう ', 'かきく{さしす}たちつ') - input_keys("\M-B", false) + input_keys("\eB") assert_line_around_cursor('', 'あいうかきく{さしす}たちつ') - input_keys("\M-B", false) + input_keys("\eB") assert_line_around_cursor('', 'あいうかきく{さしす}たちつ') end def test_em_prev_word_for_mbchar_by_plural_code_points + omit_unless_utf8 input_keys("あいうか\u3099き\u3099く\u3099{さしす}たちつ") assert_line_around_cursor("あいうか\u3099き\u3099く\u3099{さしす}たちつ", "") - input_keys("\M-B", false) + input_keys("\eB") assert_line_around_cursor("あいうか\u3099き\u3099く\u3099{さしす}", "たちつ") - input_keys("\M-B", false) + input_keys("\eB") assert_line_around_cursor("あいうか\u3099き\u3099く\u3099{", "さしす}たちつ") - input_keys("\M-B", false) + input_keys("\eB") assert_line_around_cursor("あいう ", "か\u3099き\u3099く\u3099{さしす}たちつ") - input_keys("\M-B", false) + input_keys("\eB") assert_line_around_cursor("", "あいうか\u3099き\u3099く\u3099{さしす}たちつ") - input_keys("\M-B", false) + input_keys("\eB") assert_line_around_cursor("", "あいうか\u3099き\u3099く\u3099{さしす}たちつ") end def test_em_delete_next_word input_keys('abc def{bbb}ccc') - input_keys("\C-a", false) + input_keys("\C-a") assert_line_around_cursor('', 'abc def{bbb}ccc') - input_keys("\M-d", false) + input_keys("\ed") assert_line_around_cursor('', ' def{bbb}ccc') - input_keys("\M-d", false) + input_keys("\ed") assert_line_around_cursor('', '{bbb}ccc') - input_keys("\M-d", false) + input_keys("\ed") assert_line_around_cursor('', '}ccc') - input_keys("\M-d", false) + input_keys("\ed") assert_line_around_cursor('', '') end def test_em_delete_next_word_for_mbchar input_keys('あいうかきく{さしす}たちつ') - input_keys("\C-a", false) + input_keys("\C-a") assert_line_around_cursor('', 'あいうかきく{さしす}たちつ') - input_keys("\M-d", false) + input_keys("\ed") assert_line_around_cursor('', ' かきく{さしす}たちつ') - input_keys("\M-d", false) + input_keys("\ed") assert_line_around_cursor('', '{さしす}たちつ') - input_keys("\M-d", false) + input_keys("\ed") assert_line_around_cursor('', '}たちつ') - input_keys("\M-d", false) + input_keys("\ed") assert_line_around_cursor('', '') end def test_em_delete_next_word_for_mbchar_by_plural_code_points + omit_unless_utf8 input_keys("あいうか\u3099き\u3099く\u3099{さしす}たちつ") - input_keys("\C-a", false) + input_keys("\C-a") assert_line_around_cursor('', "あいうか\u3099き\u3099く\u3099{さしす}たちつ") - input_keys("\M-d", false) + input_keys("\ed") assert_line_around_cursor('', " か\u3099き\u3099く\u3099{さしす}たちつ") - input_keys("\M-d", false) + input_keys("\ed") assert_line_around_cursor('', '{さしす}たちつ') - input_keys("\M-d", false) + input_keys("\ed") assert_line_around_cursor('', '}たちつ') - input_keys("\M-d", false) + input_keys("\ed") assert_line_around_cursor('', '') end def test_ed_delete_prev_word input_keys('abc def{bbb}ccc') assert_line_around_cursor('abc def{bbb}ccc', '') - input_keys("\M-\C-H", false) + input_keys("\e\C-H") assert_line_around_cursor('abc def{bbb}', '') - input_keys("\M-\C-H", false) + input_keys("\e\C-H") assert_line_around_cursor('abc def{', '') - input_keys("\M-\C-H", false) + input_keys("\e\C-H") assert_line_around_cursor('abc ', '') - input_keys("\M-\C-H", false) + input_keys("\e\C-H") assert_line_around_cursor('', '') end def test_ed_delete_prev_word_for_mbchar input_keys('あいうかきく{さしす}たちつ') assert_line_around_cursor('あいうかきく{さしす}たちつ', '') - input_keys("\M-\C-H", false) + input_keys("\e\C-H") assert_line_around_cursor('あいうかきく{さしす}', '') - input_keys("\M-\C-H", false) + input_keys("\e\C-H") assert_line_around_cursor('あいうかきく{', '') - input_keys("\M-\C-H", false) + input_keys("\e\C-H") assert_line_around_cursor('あいう ', '') - input_keys("\M-\C-H", false) + input_keys("\e\C-H") assert_line_around_cursor('', '') end def test_ed_delete_prev_word_for_mbchar_by_plural_code_points + omit_unless_utf8 input_keys("あいうか\u3099き\u3099く\u3099{さしす}たちつ") assert_line_around_cursor("あいうか\u3099き\u3099く\u3099{さしす}たちつ", '') - input_keys("\M-\C-H", false) + input_keys("\e\C-H") assert_line_around_cursor("あいうか\u3099き\u3099く\u3099{さしす}", '') - input_keys("\M-\C-H", false) + input_keys("\e\C-H") assert_line_around_cursor("あいうか\u3099き\u3099く\u3099{", '') - input_keys("\M-\C-H", false) + input_keys("\e\C-H") assert_line_around_cursor('あいう ', '') - input_keys("\M-\C-H", false) + input_keys("\e\C-H") assert_line_around_cursor('', '') end def test_ed_transpose_chars input_keys('abc') - input_keys("\C-a", false) + input_keys("\C-a") assert_line_around_cursor('', 'abc') - input_keys("\C-t", false) + input_keys("\C-t") assert_line_around_cursor('', 'abc') - input_keys("\C-f\C-t", false) + input_keys("\C-f\C-t") assert_line_around_cursor('ba', 'c') - input_keys("\C-t", false) + input_keys("\C-t") assert_line_around_cursor('bca', '') - input_keys("\C-t", false) + input_keys("\C-t") assert_line_around_cursor('bac', '') end def test_ed_transpose_chars_for_mbchar input_keys('あかさ') - input_keys("\C-a", false) + input_keys("\C-a") assert_line_around_cursor('', 'あかさ') - input_keys("\C-t", false) + input_keys("\C-t") assert_line_around_cursor('', 'あかさ') - input_keys("\C-f\C-t", false) + input_keys("\C-f\C-t") assert_line_around_cursor('かあ', 'さ') - input_keys("\C-t", false) + input_keys("\C-t") assert_line_around_cursor('かさあ', '') - input_keys("\C-t", false) + input_keys("\C-t") assert_line_around_cursor('かあさ', '') end def test_ed_transpose_chars_for_mbchar_by_plural_code_points + omit_unless_utf8 input_keys("あか\u3099さ") - input_keys("\C-a", false) + input_keys("\C-a") assert_line_around_cursor('', "あか\u3099さ") - input_keys("\C-t", false) + input_keys("\C-t") assert_line_around_cursor('', "あか\u3099さ") - input_keys("\C-f\C-t", false) + input_keys("\C-f\C-t") assert_line_around_cursor("か\u3099あ", 'さ') - input_keys("\C-t", false) + input_keys("\C-t") assert_line_around_cursor("か\u3099さあ", '') - input_keys("\C-t", false) + input_keys("\C-t") assert_line_around_cursor("か\u3099あさ", '') end def test_ed_transpose_words input_keys('abc def') assert_line_around_cursor('abc def', '') - input_keys("\M-t", false) + input_keys("\et") assert_line_around_cursor('def abc', '') - input_keys("\C-a\C-k", false) + input_keys("\C-a\C-k") input_keys(' abc def ') - input_keys("\C-b" * 4, false) + input_keys("\C-b" * 4) assert_line_around_cursor(' abc de', 'f ') - input_keys("\M-t", false) + input_keys("\et") assert_line_around_cursor(' def abc', ' ') - input_keys("\C-a\C-k", false) + input_keys("\C-a\C-k") input_keys(' abc def ') - input_keys("\C-b" * 6, false) + input_keys("\C-b" * 6) assert_line_around_cursor(' abc ', 'def ') - input_keys("\M-t", false) + input_keys("\et") assert_line_around_cursor(' def abc', ' ') - input_keys("\M-t", false) + input_keys("\et") assert_line_around_cursor(' abc def', '') end def test_ed_transpose_words_for_mbchar input_keys('あいうかきく') assert_line_around_cursor('あいうかきく', '') - input_keys("\M-t", false) + input_keys("\et") assert_line_around_cursor('かきくあいう', '') - input_keys("\C-a\C-k", false) + input_keys("\C-a\C-k") input_keys(' あいうかきく ') - input_keys("\C-b" * 4, false) + input_keys("\C-b" * 4) assert_line_around_cursor(' あいうかき', 'く ') - input_keys("\M-t", false) + input_keys("\et") assert_line_around_cursor(' かきくあいう', ' ') - input_keys("\C-a\C-k", false) + input_keys("\C-a\C-k") input_keys(' あいうかきく ') - input_keys("\C-b" * 6, false) + input_keys("\C-b" * 6) assert_line_around_cursor(' あいう ', 'かきく ') - input_keys("\M-t", false) + input_keys("\et") assert_line_around_cursor(' かきくあいう', ' ') - input_keys("\M-t", false) + input_keys("\et") assert_line_around_cursor(' あいうかきく', '') end def test_ed_transpose_words_with_one_word input_keys('abc ') assert_line_around_cursor('abc ', '') - input_keys("\M-t", false) + input_keys("\et") assert_line_around_cursor('abc ', '') - input_keys("\C-b", false) + input_keys("\C-b") assert_line_around_cursor('abc ', ' ') - input_keys("\M-t", false) + input_keys("\et") assert_line_around_cursor('abc ', ' ') - input_keys("\C-b" * 2, false) + input_keys("\C-b" * 2) assert_line_around_cursor('ab', 'c ') - input_keys("\M-t", false) + input_keys("\et") assert_line_around_cursor('ab', 'c ') - input_keys("\M-t", false) + input_keys("\et") assert_line_around_cursor('ab', 'c ') end def test_ed_transpose_words_with_one_word_for_mbchar input_keys('あいう ') assert_line_around_cursor('あいう ', '') - input_keys("\M-t", false) + input_keys("\et") assert_line_around_cursor('あいう ', '') - input_keys("\C-b", false) + input_keys("\C-b") assert_line_around_cursor('あいう ', ' ') - input_keys("\M-t", false) + input_keys("\et") assert_line_around_cursor('あいう ', ' ') - input_keys("\C-b" * 2, false) + input_keys("\C-b" * 2) assert_line_around_cursor('あい', 'う ') - input_keys("\M-t", false) + input_keys("\et") assert_line_around_cursor('あい', 'う ') - input_keys("\M-t", false) + input_keys("\et") assert_line_around_cursor('あい', 'う ') end @@ -602,129 +612,130 @@ def test_ed_digit def test_ed_next_and_prev_char input_keys('abc') assert_line_around_cursor('abc', '') - input_keys("\C-b", false) + input_keys("\C-b") assert_line_around_cursor('ab', 'c') - input_keys("\C-b", false) + input_keys("\C-b") assert_line_around_cursor('a', 'bc') - input_keys("\C-b", false) + input_keys("\C-b") assert_line_around_cursor('', 'abc') - input_keys("\C-b", false) + input_keys("\C-b") assert_line_around_cursor('', 'abc') - input_keys("\C-f", false) + input_keys("\C-f") assert_line_around_cursor('a', 'bc') - input_keys("\C-f", false) + input_keys("\C-f") assert_line_around_cursor('ab', 'c') - input_keys("\C-f", false) + input_keys("\C-f") assert_line_around_cursor('abc', '') - input_keys("\C-f", false) + input_keys("\C-f") assert_line_around_cursor('abc', '') end def test_ed_next_and_prev_char_for_mbchar input_keys('あいう') assert_line_around_cursor('あいう', '') - input_keys("\C-b", false) + input_keys("\C-b") assert_line_around_cursor('あい', 'う') - input_keys("\C-b", false) + input_keys("\C-b") assert_line_around_cursor('あ', 'いう') - input_keys("\C-b", false) + input_keys("\C-b") assert_line_around_cursor('', 'あいう') - input_keys("\C-b", false) + input_keys("\C-b") assert_line_around_cursor('', 'あいう') - input_keys("\C-f", false) + input_keys("\C-f") assert_line_around_cursor('あ', 'いう') - input_keys("\C-f", false) + input_keys("\C-f") assert_line_around_cursor('あい', 'う') - input_keys("\C-f", false) + input_keys("\C-f") assert_line_around_cursor('あいう', '') - input_keys("\C-f", false) + input_keys("\C-f") assert_line_around_cursor('あいう', '') end def test_ed_next_and_prev_char_for_mbchar_by_plural_code_points + omit_unless_utf8 input_keys("か\u3099き\u3099く\u3099") assert_line_around_cursor("か\u3099き\u3099く\u3099", '') - input_keys("\C-b", false) + input_keys("\C-b") assert_line_around_cursor("か\u3099き\u3099", "く\u3099") - input_keys("\C-b", false) + input_keys("\C-b") assert_line_around_cursor("か\u3099", "き\u3099く\u3099") - input_keys("\C-b", false) + input_keys("\C-b") assert_line_around_cursor('', "か\u3099き\u3099く\u3099") - input_keys("\C-b", false) + input_keys("\C-b") assert_line_around_cursor('', "か\u3099き\u3099く\u3099") - input_keys("\C-f", false) + input_keys("\C-f") assert_line_around_cursor("か\u3099", "き\u3099く\u3099") - input_keys("\C-f", false) + input_keys("\C-f") assert_line_around_cursor("か\u3099き\u3099", "く\u3099") - input_keys("\C-f", false) + input_keys("\C-f") assert_line_around_cursor("か\u3099き\u3099く\u3099", '') - input_keys("\C-f", false) + input_keys("\C-f") assert_line_around_cursor("か\u3099き\u3099く\u3099", '') end def test_em_capitol_case input_keys('abc def{bbb}ccc') - input_keys("\C-a\M-c", false) + input_keys("\C-a\ec") assert_line_around_cursor('Abc', ' def{bbb}ccc') - input_keys("\M-c", false) + input_keys("\ec") assert_line_around_cursor('Abc Def', '{bbb}ccc') - input_keys("\M-c", false) + input_keys("\ec") assert_line_around_cursor('Abc Def{Bbb', '}ccc') - input_keys("\M-c", false) + input_keys("\ec") assert_line_around_cursor('Abc Def{Bbb}Ccc', '') end def test_em_capitol_case_with_complex_example input_keys('{}#* AaA!!!cCc ') - input_keys("\C-a\M-c", false) + input_keys("\C-a\ec") assert_line_around_cursor('{}#* Aaa', '!!!cCc ') - input_keys("\M-c", false) + input_keys("\ec") assert_line_around_cursor('{}#* Aaa!!!Ccc', ' ') - input_keys("\M-c", false) + input_keys("\ec") assert_line_around_cursor('{}#* Aaa!!!Ccc ', '') end def test_em_lower_case input_keys('AbC def{bBb}CCC') - input_keys("\C-a\M-l", false) + input_keys("\C-a\el") assert_line_around_cursor('abc', ' def{bBb}CCC') - input_keys("\M-l", false) + input_keys("\el") assert_line_around_cursor('abc def', '{bBb}CCC') - input_keys("\M-l", false) + input_keys("\el") assert_line_around_cursor('abc def{bbb', '}CCC') - input_keys("\M-l", false) + input_keys("\el") assert_line_around_cursor('abc def{bbb}ccc', '') end def test_em_lower_case_with_complex_example input_keys('{}#* AaA!!!cCc ') - input_keys("\C-a\M-l", false) + input_keys("\C-a\el") assert_line_around_cursor('{}#* aaa', '!!!cCc ') - input_keys("\M-l", false) + input_keys("\el") assert_line_around_cursor('{}#* aaa!!!ccc', ' ') - input_keys("\M-l", false) + input_keys("\el") assert_line_around_cursor('{}#* aaa!!!ccc ', '') end def test_em_upper_case input_keys('AbC def{bBb}CCC') - input_keys("\C-a\M-u", false) + input_keys("\C-a\eu") assert_line_around_cursor('ABC', ' def{bBb}CCC') - input_keys("\M-u", false) + input_keys("\eu") assert_line_around_cursor('ABC DEF', '{bBb}CCC') - input_keys("\M-u", false) + input_keys("\eu") assert_line_around_cursor('ABC DEF{BBB', '}CCC') - input_keys("\M-u", false) + input_keys("\eu") assert_line_around_cursor('ABC DEF{BBB}CCC', '') end def test_em_upper_case_with_complex_example input_keys('{}#* AaA!!!cCc ') - input_keys("\C-a\M-u", false) + input_keys("\C-a\eu") assert_line_around_cursor('{}#* AAA', '!!!cCc ') - input_keys("\M-u", false) + input_keys("\eu") assert_line_around_cursor('{}#* AAA!!!CCC', ' ') - input_keys("\M-u", false) + input_keys("\eu") assert_line_around_cursor('{}#* AAA!!!CCC ', '') end @@ -742,7 +753,7 @@ def test_em_delete_or_list input_keys('fooo') assert_line_around_cursor('fooo', '') assert_equal(nil, @line_editor.instance_variable_get(:@menu_info)) - input_keys("\C-b", false) + input_keys("\C-b") assert_line_around_cursor('foo', 'o') assert_equal(nil, @line_editor.instance_variable_get(:@menu_info)) input_key_by_symbol(:em_delete_or_list) @@ -766,10 +777,10 @@ def test_completion_duplicated_list input_keys('foo_') assert_line_around_cursor('foo_', '') assert_equal(nil, @line_editor.instance_variable_get(:@menu_info)) - input_keys("\C-i", false) + input_keys("\C-i") assert_line_around_cursor('foo_', '') assert_equal(nil, @line_editor.instance_variable_get(:@menu_info)) - input_keys("\C-i", false) + input_keys("\C-i") assert_line_around_cursor('foo_', '') assert_equal(%w{foo_foo foo_bar}, @line_editor.instance_variable_get(:@menu_info).list) end @@ -788,28 +799,28 @@ def test_completion input_keys('fo') assert_line_around_cursor('fo', '') assert_equal(nil, @line_editor.instance_variable_get(:@menu_info)) - input_keys("\C-i", false) + input_keys("\C-i") assert_line_around_cursor('foo_', '') assert_equal(nil, @line_editor.instance_variable_get(:@menu_info)) - input_keys("\C-i", false) + input_keys("\C-i") assert_line_around_cursor('foo_', '') assert_equal(%w{foo_foo foo_bar foo_baz}, @line_editor.instance_variable_get(:@menu_info).list) input_keys('a') - input_keys("\C-i", false) + input_keys("\C-i") assert_line_around_cursor('foo_a', '') - input_keys("\C-h", false) + input_keys("\C-h") input_keys('b') - input_keys("\C-i", false) + input_keys("\C-i") assert_line_around_cursor('foo_ba', '') input_keys("\C-h") input_key_by_symbol(:complete) assert_line_around_cursor('foo_ba', '') - input_keys("\C-h", false) + input_keys("\C-h") input_key_by_symbol(:menu_complete) assert_line_around_cursor('foo_bar', '') input_key_by_symbol(:menu_complete) assert_line_around_cursor('foo_baz', '') - input_keys("\C-h", false) + input_keys("\C-h") input_key_by_symbol(:menu_complete_backward) assert_line_around_cursor('foo_baz', '') input_key_by_symbol(:menu_complete_backward) @@ -829,9 +840,9 @@ def test_autocompletion } input_keys('Re') assert_line_around_cursor('Re', '') - input_keys("\C-i", false) + input_keys("\C-i") assert_line_around_cursor('Readline', '') - input_keys("\C-i", false) + input_keys("\C-i") assert_line_around_cursor('Regexp', '') input_key_by_symbol(:completion_journey_up) assert_line_around_cursor('Readline', '') @@ -859,10 +870,10 @@ def test_completion_with_indent input_keys(' fo') assert_line_around_cursor(' fo', '') assert_equal(nil, @line_editor.instance_variable_get(:@menu_info)) - input_keys("\C-i", false) + input_keys("\C-i") assert_line_around_cursor(' foo_', '') assert_equal(nil, @line_editor.instance_variable_get(:@menu_info)) - input_keys("\C-i", false) + input_keys("\C-i") assert_line_around_cursor(' foo_', '') assert_equal(%w{foo_foo foo_bar foo_baz}, @line_editor.instance_variable_get(:@menu_info).list) end @@ -884,25 +895,25 @@ def test_completion_with_perfect_match assert_line_around_cursor('fo', '') assert_equal(Reline::LineEditor::CompletionState::NORMAL, @line_editor.instance_variable_get(:@completion_state)) assert_equal(nil, matched) - input_keys("\C-i", false) + input_keys("\C-i") assert_line_around_cursor('foo', '') assert_equal(Reline::LineEditor::CompletionState::MENU_WITH_PERFECT_MATCH, @line_editor.instance_variable_get(:@completion_state)) assert_equal(nil, matched) - input_keys("\C-i", false) + input_keys("\C-i") assert_line_around_cursor('foo', '') assert_equal(Reline::LineEditor::CompletionState::PERFECT_MATCH, @line_editor.instance_variable_get(:@completion_state)) assert_equal(nil, matched) - input_keys("\C-i", false) + input_keys("\C-i") assert_line_around_cursor('foo', '') assert_equal(Reline::LineEditor::CompletionState::PERFECT_MATCH, @line_editor.instance_variable_get(:@completion_state)) assert_equal('foo', matched) matched = nil input_keys('_') - input_keys("\C-i", false) + input_keys("\C-i") assert_line_around_cursor('foo_bar', '') assert_equal(Reline::LineEditor::CompletionState::PERFECT_MATCH, @line_editor.instance_variable_get(:@completion_state)) assert_equal(nil, matched) - input_keys("\C-i", false) + input_keys("\C-i") assert_line_around_cursor('foo_bar', '') assert_equal(Reline::LineEditor::CompletionState::PERFECT_MATCH, @line_editor.instance_variable_get(:@completion_state)) assert_equal('foo_bar', matched) @@ -913,9 +924,9 @@ def test_continuous_completion_with_perfect_match word == 'f' ? ['foo'] : %w[foobar foobaz] } input_keys('f') - input_keys("\C-i", false) + input_keys("\C-i") assert_line_around_cursor('foo', '') - input_keys("\C-i", false) + input_keys("\C-i") assert_line_around_cursor('fooba', '') end @@ -925,9 +936,9 @@ def test_continuous_completion_disabled_with_perfect_match } @line_editor.dig_perfect_match_proc = proc {} input_keys('f') - input_keys("\C-i", false) + input_keys("\C-i") assert_line_around_cursor('foo', '') - input_keys("\C-i", false) + input_keys("\C-i") assert_line_around_cursor('foo', '') end @@ -937,13 +948,13 @@ def test_completion_append_character } @line_editor.completion_append_character = 'X' input_keys('f') - input_keys("\C-i", false) + input_keys("\C-i") assert_line_around_cursor('foo_', '') input_keys('f') - input_keys("\C-i", false) + input_keys("\C-i") assert_line_around_cursor('foo_fooX', '') input_keys(' foo_bar') - input_keys("\C-i", false) + input_keys("\C-i") assert_line_around_cursor('foo_fooX foo_barX', '') end @@ -952,22 +963,22 @@ def test_completion_with_quote_append %w[foo bar baz].select { |s| s.start_with? word } } set_line_around_cursor('x = "b', '') - input_keys("\C-i", false) + input_keys("\C-i") assert_line_around_cursor('x = "ba', '') set_line_around_cursor('x = "f', ' ') - input_keys("\C-i", false) + input_keys("\C-i") assert_line_around_cursor('x = "foo', ' ') set_line_around_cursor("x = 'f", '') - input_keys("\C-i", false) + input_keys("\C-i") assert_line_around_cursor("x = 'foo'", '') set_line_around_cursor('"a "f', '') - input_keys("\C-i", false) + input_keys("\C-i") assert_line_around_cursor('"a "foo', '') set_line_around_cursor('"a\\" "f', '') - input_keys("\C-i", false) + input_keys("\C-i") assert_line_around_cursor('"a\\" "foo', '') set_line_around_cursor('"a" "f', '') - input_keys("\C-i", false) + input_keys("\C-i") assert_line_around_cursor('"a" "foo"', '') end @@ -985,25 +996,25 @@ def test_completion_with_completion_ignore_case input_keys('fo') assert_line_around_cursor('fo', '') assert_equal(nil, @line_editor.instance_variable_get(:@menu_info)) - input_keys("\C-i", false) + input_keys("\C-i") assert_line_around_cursor('foo_', '') assert_equal(nil, @line_editor.instance_variable_get(:@menu_info)) - input_keys("\C-i", false) + input_keys("\C-i") assert_line_around_cursor('foo_', '') assert_equal(%w{foo_foo foo_bar}, @line_editor.instance_variable_get(:@menu_info).list) @config.completion_ignore_case = true - input_keys("\C-i", false) + input_keys("\C-i") assert_line_around_cursor('foo_', '') assert_equal(%w{foo_foo foo_bar Foo_baz}, @line_editor.instance_variable_get(:@menu_info).list) input_keys('a') - input_keys("\C-i", false) + input_keys("\C-i") assert_line_around_cursor('foo_a', '') - input_keys("\C-h", false) + input_keys("\C-h") input_keys('b') - input_keys("\C-i", false) + input_keys("\C-i") assert_line_around_cursor('foo_ba', '') input_keys('Z') - input_keys("\C-i", false) + input_keys("\C-i") assert_line_around_cursor('Foo_baz', '') end @@ -1020,9 +1031,9 @@ def test_completion_in_middle_of_line } input_keys('abcde fo ABCDE') assert_line_around_cursor('abcde fo ABCDE', '') - input_keys("\C-b" * 6 + "\C-i", false) + input_keys("\C-b" * 6 + "\C-i") assert_line_around_cursor('abcde foo_', ' ABCDE') - input_keys("\C-b" * 2 + "\C-i", false) + input_keys("\C-b" * 2 + "\C-i") assert_line_around_cursor('abcde foo_', 'o_ ABCDE') end @@ -1041,42 +1052,42 @@ def test_completion_with_nil_value input_keys('fo') assert_line_around_cursor('fo', '') assert_equal(nil, @line_editor.instance_variable_get(:@menu_info)) - input_keys("\C-i", false) + input_keys("\C-i") assert_line_around_cursor('foo_', '') assert_equal(nil, @line_editor.instance_variable_get(:@menu_info)) - input_keys("\C-i", false) + input_keys("\C-i") assert_line_around_cursor('foo_', '') assert_equal(%w{foo_foo foo_bar Foo_baz}, @line_editor.instance_variable_get(:@menu_info).list) input_keys('a') - input_keys("\C-i", false) + input_keys("\C-i") assert_line_around_cursor('foo_a', '') - input_keys("\C-h", false) + input_keys("\C-h") input_keys('b') - input_keys("\C-i", false) + input_keys("\C-i") assert_line_around_cursor('foo_ba', '') end def test_em_kill_region input_keys('abc def{bbb}ccc ddd ') assert_line_around_cursor('abc def{bbb}ccc ddd ', '') - input_keys("\C-w", false) + input_keys("\C-w") assert_line_around_cursor('abc def{bbb}ccc ', '') - input_keys("\C-w", false) + input_keys("\C-w") assert_line_around_cursor('abc ', '') - input_keys("\C-w", false) + input_keys("\C-w") assert_line_around_cursor('', '') - input_keys("\C-w", false) + input_keys("\C-w") assert_line_around_cursor('', '') end def test_em_kill_region_mbchar input_keys('あいう{う}う ') assert_line_around_cursor('あいう{う}う ', '') - input_keys("\C-w", false) + input_keys("\C-w") assert_line_around_cursor('あい ', '') - input_keys("\C-w", false) + input_keys("\C-w") assert_line_around_cursor('あ ', '') - input_keys("\C-w", false) + input_keys("\C-w") assert_line_around_cursor('', '') end @@ -1232,13 +1243,13 @@ def test_search_history_with_isearch_terminator def test_em_set_mark_and_em_exchange_mark input_keys('aaa bbb ccc ddd') assert_line_around_cursor('aaa bbb ccc ddd', '') - input_keys("\C-a\M-F\M-F", false) + input_keys("\C-a\eF\eF") assert_line_around_cursor('aaa bbb', ' ccc ddd') assert_equal(nil, @line_editor.instance_variable_get(:@mark_pointer)) - input_keys("\x00", false) # C-Space + input_keys("\x00") # C-Space assert_line_around_cursor('aaa bbb', ' ccc ddd') assert_equal([7, 0], @line_editor.instance_variable_get(:@mark_pointer)) - input_keys("\C-a", false) + input_keys("\C-a") assert_line_around_cursor('', 'aaa bbb ccc ddd') assert_equal([7, 0], @line_editor.instance_variable_get(:@mark_pointer)) input_key_by_symbol(:em_exchange_mark) @@ -1249,7 +1260,7 @@ def test_em_set_mark_and_em_exchange_mark def test_em_exchange_mark_without_mark input_keys('aaa bbb ccc ddd') assert_line_around_cursor('aaa bbb ccc ddd', '') - input_keys("\C-a\M-f", false) + input_keys("\C-a\ef") assert_line_around_cursor('aaa', ' bbb ccc ddd') assert_equal(nil, @line_editor.instance_variable_get(:@mark_pointer)) input_key_by_symbol(:em_exchange_mark) @@ -1405,9 +1416,25 @@ def test_incremental_search_history_saves_and_restores_last_input assert_line_around_cursor('abcd', '') end + def test_beginning_of_history + Reline::HISTORY.concat(['abc', '123']) + # \M-<: move history to beginning + input_key_by_symbol(:beginning_of_history) + assert_line_around_cursor('abc', '') + end + + def test_end_of_history + Reline::HISTORY.concat(['abc', '123']) + input_keys("def\C-p\C-pd") + assert_line_around_cursor('abcd', '') + # \M->: move history to end + input_key_by_symbol(:end_of_history) + assert_line_around_cursor('def', '') + end + # Unicode emoji test def test_ed_insert_for_include_zwj_emoji - omit "This test is for UTF-8 but the locale is #{Reline.core.encoding}" if Reline.core.encoding != Encoding::UTF_8 + omit_unless_utf8 # U+1F468 U+200D U+1F469 U+200D U+1F467 U+200D U+1F466 is family: man, woman, girl, boy "👨‍👩‍👧‍👦" input_keys("\u{1F468}") # U+1F468 is man "👨" assert_line_around_cursor('👨', '') @@ -1429,7 +1456,7 @@ def test_ed_insert_for_include_zwj_emoji end def test_ed_insert_for_include_valiation_selector - omit "This test is for UTF-8 but the locale is #{Reline.core.encoding}" if Reline.core.encoding != Encoding::UTF_8 + omit_unless_utf8 # U+0030 U+FE00 is DIGIT ZERO + VARIATION SELECTOR-1 "0︀" input_keys("\u0030") # U+0030 is DIGIT ZERO assert_line_around_cursor('0', '') @@ -1438,20 +1465,20 @@ def test_ed_insert_for_include_valiation_selector end def test_em_yank_pop - input_keys("def hoge\C-w\C-b\C-f\C-w", false) + input_keys("def hoge\C-w\C-b\C-f\C-w") assert_line_around_cursor('', '') - input_keys("\C-y", false) + input_keys("\C-y") assert_line_around_cursor('def ', '') - input_keys("\M-\C-y", false) + input_keys("\e\C-y") assert_line_around_cursor('hoge', '') end def test_em_kill_region_with_kill_ring - input_keys("def hoge\C-b\C-b\C-b\C-b", false) + input_keys("def hoge\C-b\C-b\C-b\C-b") assert_line_around_cursor('def ', 'hoge') - input_keys("\C-k\C-w", false) + input_keys("\C-k\C-w") assert_line_around_cursor('', '') - input_keys("\C-y", false) + input_keys("\C-y") assert_line_around_cursor('def hoge', '') end @@ -1497,34 +1524,45 @@ def test_ignore_NUL_by_ed_quoted_insert def test_ed_argument_digit_by_meta_num input_keys('abcdef') assert_line_around_cursor('abcdef', '') - input_keys("\M-2", false) - input_keys("\C-h", false) + input_keys("\e2") + input_keys("\C-h") assert_line_around_cursor('abcd', '') end + def test_ed_digit_with_ed_argument_digit + input_keys('1' * 30) + assert_line_around_cursor('1' * 30, '') + input_keys("\e2") + input_keys('3') + input_keys("\C-h") + input_keys('4') + assert_line_around_cursor('1' * 7 + '4', '') + end + def test_halfwidth_kana_width_dakuten - omit "This test is for UTF-8 but the locale is #{Reline.core.encoding}" if Reline.core.encoding != Encoding::UTF_8 - input_raw_keys('ｶﾞｷﾞｹﾞｺﾞ') + omit_unless_utf8 + input_keys('ｶﾞｷﾞｹﾞｺﾞ') assert_line_around_cursor('ｶﾞｷﾞｹﾞｺﾞ', '') - input_keys("\C-b\C-b", false) + input_keys("\C-b\C-b") assert_line_around_cursor('ｶﾞｷﾞ', 'ｹﾞｺﾞ') - input_raw_keys('ｸﾞ', false) + input_keys('ｸﾞ') assert_line_around_cursor('ｶﾞｷﾞｸﾞ', 'ｹﾞｺﾞ') end def test_input_unknown_char + omit_unless_utf8 input_keys('͸') # U+0378 (unassigned) assert_line_around_cursor('͸', '') end def test_unix_line_discard - input_keys("\C-u", false) + input_keys("\C-u") assert_line_around_cursor('', '') input_keys('abc') assert_line_around_cursor('abc', '') - input_keys("\C-b\C-u", false) + input_keys("\C-b\C-u") assert_line_around_cursor('', 'c') - input_keys("\C-f\C-u", false) + input_keys("\C-f\C-u") assert_line_around_cursor('', '') end @@ -1534,59 +1572,59 @@ def test_vi_editing_mode end def test_undo - input_keys("\C-_", false) + input_keys("\C-_") assert_line_around_cursor('', '') - input_keys("aあb\C-h\C-h\C-h".encode(@encoding), false) + input_keys("aあb\C-h\C-h\C-h") assert_line_around_cursor('', '') - input_keys("\C-_", false) + input_keys("\C-_") assert_line_around_cursor('a', '') - input_keys("\C-_", false) + input_keys("\C-_") assert_line_around_cursor('aあ', '') - input_keys("\C-_", false) + input_keys("\C-_") assert_line_around_cursor('aあb', '') - input_keys("\C-_", false) + input_keys("\C-_") assert_line_around_cursor('aあ', '') - input_keys("\C-_", false) + input_keys("\C-_") assert_line_around_cursor('a', '') - input_keys("\C-_", false) + input_keys("\C-_") assert_line_around_cursor('', '') end def test_undo_with_cursor_position - input_keys("abc\C-b\C-h", false) + input_keys("abc\C-b\C-h") assert_line_around_cursor('a', 'c') - input_keys("\C-_", false) + input_keys("\C-_") assert_line_around_cursor('ab', 'c') - input_keys("あいう\C-b\C-h".encode(@encoding), false) + input_keys("あいう\C-b\C-h") assert_line_around_cursor('abあ', 'うc') - input_keys("\C-_", false) + input_keys("\C-_") assert_line_around_cursor('abあい', 'うc') end def test_undo_with_multiline @line_editor.multiline_on @line_editor.confirm_multiline_termination_proc = proc {} - input_keys("1\n2\n3", false) + input_keys("1\n2\n3") assert_whole_lines(["1", "2", "3"]) assert_line_index(2) assert_line_around_cursor('3', '') - input_keys("\C-p\C-h\C-h", false) + input_keys("\C-p\C-h\C-h") assert_whole_lines(["1", "3"]) assert_line_index(0) assert_line_around_cursor('1', '') - input_keys("\C-_", false) + input_keys("\C-_") assert_whole_lines(["1", "", "3"]) assert_line_index(1) assert_line_around_cursor('', '') - input_keys("\C-_", false) + input_keys("\C-_") assert_whole_lines(["1", "2", "3"]) assert_line_index(1) assert_line_around_cursor('2', '') - input_keys("\C-_", false) + input_keys("\C-_") assert_whole_lines(["1", "2", ""]) assert_line_index(2) assert_line_around_cursor('', '') - input_keys("\C-_", false) + input_keys("\C-_") assert_whole_lines(["1", "2"]) assert_line_index(1) assert_line_around_cursor('2', '') @@ -1594,99 +1632,99 @@ def test_undo_with_multiline def test_undo_with_many_times str = "a" + "b" * 99 - input_keys(str, false) - 100.times { input_keys("\C-_", false) } + input_keys(str) + 100.times { input_keys("\C-_") } assert_line_around_cursor('a', '') - input_keys("\C-_", false) + input_keys("\C-_") assert_line_around_cursor('a', '') end def test_redo - input_keys("aあb".encode(@encoding), false) + input_keys("aあb") assert_line_around_cursor('aあb', '') - input_keys("\M-\C-_", false) + input_keys("\e\C-_") assert_line_around_cursor('aあb', '') - input_keys("\C-_", false) + input_keys("\C-_") assert_line_around_cursor('aあ', '') - input_keys("\C-_", false) + input_keys("\C-_") assert_line_around_cursor('a', '') - input_keys("\M-\C-_", false) + input_keys("\e\C-_") assert_line_around_cursor('aあ', '') - input_keys("\M-\C-_", false) + input_keys("\e\C-_") assert_line_around_cursor('aあb', '') - input_keys("\C-_", false) + input_keys("\C-_") assert_line_around_cursor('aあ', '') - input_keys("c", false) + input_keys("c") assert_line_around_cursor('aあc', '') - input_keys("\M-\C-_", false) + input_keys("\e\C-_") assert_line_around_cursor('aあc', '') end def test_redo_with_cursor_position - input_keys("abc\C-b\C-h", false) + input_keys("abc\C-b\C-h") assert_line_around_cursor('a', 'c') - input_keys("\M-\C-_", false) + input_keys("\e\C-_") assert_line_around_cursor('a', 'c') - input_keys("\C-_", false) + input_keys("\C-_") assert_line_around_cursor('ab', 'c') - input_keys("\M-\C-_", false) + input_keys("\e\C-_") assert_line_around_cursor('a', 'c') end def test_redo_with_multiline @line_editor.multiline_on @line_editor.confirm_multiline_termination_proc = proc {} - input_keys("1\n2\n3", false) + input_keys("1\n2\n3") assert_whole_lines(["1", "2", "3"]) assert_line_index(2) assert_line_around_cursor('3', '') - input_keys("\C-_", false) + input_keys("\C-_") assert_whole_lines(["1", "2", ""]) assert_line_index(2) assert_line_around_cursor('', '') - input_keys("\C-_", false) + input_keys("\C-_") assert_whole_lines(["1", "2"]) assert_line_index(1) assert_line_around_cursor('2', '') - input_keys("\M-\C-_", false) + input_keys("\e\C-_") assert_whole_lines(["1", "2", ""]) assert_line_index(2) assert_line_around_cursor('', '') - input_keys("\M-\C-_", false) + input_keys("\e\C-_") assert_whole_lines(["1", "2", "3"]) assert_line_index(2) assert_line_around_cursor('3', '') - input_keys("\C-p\C-h\C-h", false) + input_keys("\C-p\C-h\C-h") assert_whole_lines(["1", "3"]) assert_line_index(0) assert_line_around_cursor('1', '') - input_keys("\C-n", false) + input_keys("\C-n") assert_whole_lines(["1", "3"]) assert_line_index(1) assert_line_around_cursor('3', '') - input_keys("\C-_", false) + input_keys("\C-_") assert_whole_lines(["1", "", "3"]) assert_line_index(1) assert_line_around_cursor('', '') - input_keys("\C-_", false) + input_keys("\C-_") assert_whole_lines(["1", "2", "3"]) assert_line_index(1) assert_line_around_cursor('2', '') - input_keys("\M-\C-_", false) + input_keys("\e\C-_") assert_whole_lines(["1", "", "3"]) assert_line_index(1) assert_line_around_cursor('', '') - input_keys("\M-\C-_", false) + input_keys("\e\C-_") assert_whole_lines(["1", "3"]) assert_line_index(1) assert_line_around_cursor('3', '') @@ -1695,27 +1733,27 @@ def test_redo_with_multiline def test_undo_redo_restores_indentation @line_editor.multiline_on @line_editor.confirm_multiline_termination_proc = proc {} - input_keys(" 1", false) + input_keys(" 1") assert_whole_lines([' 1']) - input_keys("2", false) + input_keys("2") assert_whole_lines([' 12']) @line_editor.auto_indent_proc = proc { 2 } - input_keys("\C-_", false) + input_keys("\C-_") assert_whole_lines([' 1']) - input_keys("\M-\C-_", false) + input_keys("\e\C-_") assert_whole_lines([' 12']) end def test_redo_with_many_times str = "a" + "b" * 98 + "c" - input_keys(str, false) - 100.times { input_keys("\C-_", false) } + input_keys(str) + 100.times { input_keys("\C-_") } assert_line_around_cursor('a', '') - input_keys("\C-_", false) + input_keys("\C-_") assert_line_around_cursor('a', '') - 100.times { input_keys("\M-\C-_", false) } + 100.times { input_keys("\e\C-_") } assert_line_around_cursor(str, '') - input_keys("\M-\C-_", false) + input_keys("\e\C-_") assert_line_around_cursor(str, '') end end diff --git a/test/mri/reline/test_key_actor_vi.rb b/test/mri/reline/test_key_actor_vi.rb index 928adace2b4..083433f9a80 100644 --- a/test/mri/reline/test_key_actor_vi.rb +++ b/test/mri/reline/test_key_actor_vi.rb @@ -103,11 +103,13 @@ def test_ed_insert_mbchar_two end def test_ed_insert_for_mbchar_by_plural_code_points + omit_unless_utf8 input_keys("か\u3099") assert_line_around_cursor("か\u3099", '') end def test_ed_insert_for_plural_mbchar_by_plural_code_points + omit_unless_utf8 input_keys("か\u3099き\u3099") assert_line_around_cursor("か\u3099き\u3099", '') end @@ -208,6 +210,7 @@ def test_vi_paste_next_for_mbchar end def test_vi_paste_prev_for_mbchar_by_plural_code_points + omit_unless_utf8 input_keys("か\u3099き\u3099く\u3099け\u3099こ\u3099\C-[3h") assert_line_around_cursor("か\u3099", "き\u3099く\u3099け\u3099こ\u3099") input_keys('P') @@ -221,6 +224,7 @@ def test_vi_paste_prev_for_mbchar_by_plural_code_points end def test_vi_paste_next_for_mbchar_by_plural_code_points + omit_unless_utf8 input_keys("か\u3099き\u3099く\u3099け\u3099こ\u3099\C-[3h") assert_line_around_cursor("か\u3099", "き\u3099く\u3099け\u3099こ\u3099") input_keys('p') @@ -438,6 +442,7 @@ def test_vi_delete_next_char_for_mbchar end def test_vi_delete_next_char_for_mbchar_by_plural_code_points + omit_unless_utf8 input_keys("か\u3099き\u3099く\u3099\C-[h") assert_line_around_cursor("か\u3099", "き\u3099く\u3099") input_keys('x') @@ -465,6 +470,7 @@ def test_vi_delete_prev_char_for_mbchar end def test_vi_delete_prev_char_for_mbchar_by_plural_code_points + omit_unless_utf8 input_keys("か\u3099き\u3099") assert_line_around_cursor("か\u3099き\u3099", '') input_keys("\C-h") @@ -509,6 +515,7 @@ def test_ed_delete_prev_word_for_mbchar end def test_ed_delete_prev_word_for_mbchar_by_plural_code_points + omit_unless_utf8 input_keys("あいうか\u3099き\u3099く\u3099{さしす}たちつ") assert_line_around_cursor("あいうか\u3099き\u3099く\u3099{さしす}たちつ", '') input_keys("\C-w") @@ -659,9 +666,9 @@ def test_autocompletion_with_upward_navigation } input_keys('Re') assert_line_around_cursor('Re', '') - input_keys("\C-i", false) + input_keys("\C-i") assert_line_around_cursor('Readline', '') - input_keys("\C-i", false) + input_keys("\C-i") assert_line_around_cursor('Regexp', '') input_key_by_symbol(:completion_journey_up) assert_line_around_cursor('Readline', '') @@ -682,9 +689,9 @@ def test_autocompletion_with_upward_navigation_and_menu_complete_backward } input_keys('Re') assert_line_around_cursor('Re', '') - input_keys("\C-i", false) + input_keys("\C-i") assert_line_around_cursor('Readline', '') - input_keys("\C-i", false) + input_keys("\C-i") assert_line_around_cursor('Regexp', '') input_key_by_symbol(:menu_complete_backward) assert_line_around_cursor('Readline', '') @@ -924,16 +931,16 @@ def test_ed_delete_next_char_at_eol end def test_vi_kill_line_prev - input_keys("\C-u", false) + input_keys("\C-u") assert_line_around_cursor('', '') input_keys('abc') assert_line_around_cursor('abc', '') - input_keys("\C-u", false) + input_keys("\C-u") assert_line_around_cursor('', '') input_keys('abc') - input_keys("\C-[\C-u", false) + input_keys("\C-[\C-u") assert_line_around_cursor('', 'c') - input_keys("\C-u", false) + input_keys("\C-u") assert_line_around_cursor('', 'c') end diff --git a/test/mri/reline/test_reline.rb b/test/mri/reline/test_reline.rb index 0a4f38986b0..aa0fd7d29ad 100644 --- a/test/mri/reline/test_reline.rb +++ b/test/mri/reline/test_reline.rb @@ -382,18 +382,6 @@ def test_dumb_terminal assert_match(/# /, out) - end - def test_read_eof_returns_input pend if win? lib = File.expand_path("../../lib", __dir__) @@ -436,24 +424,25 @@ def win? /mswin|mingw/.match?(RUBY_PLATFORM) end - def test_tty_amibuous_width + def test_tty_ambiguous_width omit unless defined?(PTY) ruby_file = Tempfile.create('rubyfile') ruby_file.write(<<~RUBY) require 'reline' Thread.new { sleep 2; puts 'timeout'; exit } - p [Reline.ambiguous_width, gets.chomp] + line = Reline.readline('>') + p [Reline.ambiguous_width, line] RUBY ruby_file.close lib = File.expand_path('../../lib', __dir__) - cmd = [{ 'TERM' => 'xterm' }, 'ruby', '-I', lib, ruby_file.to_path] + cmd = [{ 'TERM' => 'xterm' }, Reline.test_rubybin, '-I', lib, ruby_file.to_path] # Calculate ambiguous width from cursor position [1, 2].each do |ambiguous_width| PTY.spawn(*cmd) do |r, w, pid| loop { break if r.readpartial(1024).include?("\e[6n") } - w.puts "hello\e[10;#{ambiguous_width + 1}Rworld" - assert_include(r.gets, [ambiguous_width, 'helloworld'].inspect) + w.puts "hello\e[10;#{ambiguous_width + 1}Rworld\n" + assert_include(r.gets + r.gets, [ambiguous_width, 'helloworld'].inspect) ensure r.close w.close @@ -464,8 +453,8 @@ def test_tty_amibuous_width # Ambiguous width = 1 when cursor pos timed out PTY.spawn(*cmd) do |r, w, pid| loop { break if r.readpartial(1024).include?("\e[6n") } - w.puts "hello\e[10;2Sworld" - assert_include(r.gets, [1, "hello\e[10;2Sworld"].inspect) + w.puts "helloworld\n" + assert_include(r.gets + r.gets, [1, "helloworld"].inspect) ensure r.close w.close diff --git a/test/mri/reline/test_unicode.rb b/test/mri/reline/test_unicode.rb index 0778306c323..03e3be7d731 100644 --- a/test/mri/reline/test_unicode.rb +++ b/test/mri/reline/test_unicode.rb @@ -19,7 +19,7 @@ def test_ambiguous_width end def test_csi_regexp - csi_sequences = ["\e[m", "\e[1m", "\e[12;34m", "\e[12;34H"] + csi_sequences = ["\e[m", "\e[1m", "\e[12;34m", "\e[12;34H", "\e[5 q", "\e[?2004h"] assert_equal(csi_sequences, "text#{csi_sequences.join('text')}text".scan(Reline::Unicode::CSI_REGEXP)) end @@ -107,6 +107,21 @@ def test_take_mbchar_range assert_equal ["\e[41m \e[42mい\e[43m ", 1, 4], Reline::Unicode.take_mbchar_range("\e[41mあ\e[42mい\e[43mう", 1, 4, padding: true) end + def test_three_width_characters_take_mbchar_range + halfwidth_dakuten = 0xFF9E.chr('utf-8') + a = 'あ' + halfwidth_dakuten + b = 'い' + halfwidth_dakuten + c = 'う' + halfwidth_dakuten + line = 'x' + a + b + c + 'x' + assert_equal [' ' + b + ' ', 2, 6], Reline::Unicode.take_mbchar_range(line, 2, 6, padding: true) + assert_equal [' ' + b + ' ', 3, 6], Reline::Unicode.take_mbchar_range(line, 3, 6, padding: true) + assert_equal [b + c, 4, 6], Reline::Unicode.take_mbchar_range(line, 4, 6, padding: true) + assert_equal [a + b, 1, 6], Reline::Unicode.take_mbchar_range(line, 2, 6, cover_begin: true) + assert_equal [a + b, 1, 6], Reline::Unicode.take_mbchar_range(line, 3, 6, cover_begin: true) + assert_equal [b + c, 4, 6], Reline::Unicode.take_mbchar_range(line, 2, 6, cover_end: true) + assert_equal [b + c, 4, 6], Reline::Unicode.take_mbchar_range(line, 3, 6, cover_end: true) + end + def test_common_prefix assert_equal('', Reline::Unicode.common_prefix([])) assert_equal('abc', Reline::Unicode.common_prefix(['abc'])) @@ -283,4 +298,45 @@ def test_character_type refute(Reline::Unicode.space_character?('-')) refute(Reline::Unicode.space_character?(nil)) end + + def test_halfwidth_dakuten_handakuten_combinations + assert_equal 1, Reline::Unicode.get_mbchar_width("\uFF9E") + assert_equal 1, Reline::Unicode.get_mbchar_width("\uFF9F") + assert_equal 2, Reline::Unicode.get_mbchar_width("ｶﾞ") + assert_equal 2, Reline::Unicode.get_mbchar_width("ﾊﾟ") + assert_equal 2, Reline::Unicode.get_mbchar_width("ｻﾞ") + assert_equal 2, Reline::Unicode.get_mbchar_width("aﾞ") + assert_equal 2, Reline::Unicode.get_mbchar_width("1ﾟ") + assert_equal 3, Reline::Unicode.get_mbchar_width("あﾞ") + assert_equal 3, Reline::Unicode.get_mbchar_width("紅ﾞ") + end + + def test_grapheme_cluster_width + # GB6, GB7, GB8: Hangul syllable + assert_equal 2, Reline::Unicode.get_mbchar_width('한'.unicode_normalize(:nfd)) + assert_equal 6, Reline::Unicode.get_mbchar_width('ᄀ' * 3) + + # GB9 + # Char + NonspacingMark + assert_equal 1, Reline::Unicode.get_mbchar_width('ç'.unicode_normalize(:nfd)) + assert_equal 2, Reline::Unicode.get_mbchar_width('ぱ'.unicode_normalize(:nfd)) + assert_equal 1, Reline::Unicode.get_mbchar_width("c\u{301}\u{327}") + # '1' + NonspacingMark + EnclosingMark + assert_equal 1, Reline::Unicode.get_mbchar_width('1️⃣') + # Char + SpacingMark + assert_equal 2, Reline::Unicode.get_mbchar_width('কা') + assert_equal 5, Reline::Unicode.get_mbchar_width('ｶﾞﾟﾞﾞ') + # Emoji joined with ZeroWidthJoiner + assert_equal 2, Reline::Unicode.get_mbchar_width('👨‍👩‍👧') + assert_equal 7, Reline::Unicode.get_mbchar_width('👨‍👩‍👧ﾞﾟﾟﾟﾞ') + + # GB9a: Char + GraphemeClusterBreak=SpacingMark + assert_equal 2, Reline::Unicode.get_mbchar_width('คำ') + + # GB9c: Consonant + Linker(NonspacingMark) + Consonant + assert_equal 2, Reline::Unicode.get_mbchar_width('क्त') + + # GB12, GB13: RegionalIndicator + assert_equal 2, Reline::Unicode.get_mbchar_width('🇯🇵') + end end diff --git a/test/mri/reline/test_within_pipe.rb b/test/mri/reline/test_within_pipe.rb index 4f05255301b..e5d0c12b9c9 100644 --- a/test/mri/reline/test_within_pipe.rb +++ b/test/mri/reline/test_within_pipe.rb @@ -42,9 +42,9 @@ def test_macro_commands_for_moving @config.add_default_key_binding("\C-x\C-e".bytes, :end_of_line) @config.add_default_key_binding("\C-x\C-f".bytes, :forward_char) @config.add_default_key_binding("\C-x\C-b".bytes, :backward_char) - @config.add_default_key_binding("\C-x\M-f".bytes, :forward_word) - @config.add_default_key_binding("\C-x\M-b".bytes, :backward_word) - @writer.write(" def\C-x\C-aabc\C-x\C-e ghi\C-x\C-a\C-x\C-f\C-x\C-f_\C-x\C-b\C-x\C-b_\C-x\C-f\C-x\C-f\C-x\C-f\C-x\M-f_\C-x\M-b\n") + @config.add_default_key_binding("\C-x\ef".bytes, :forward_word) + @config.add_default_key_binding("\C-x\eb".bytes, :backward_word) + @writer.write(" def\C-x\C-aabc\C-x\C-e ghi\C-x\C-a\C-x\C-f\C-x\C-f_\C-x\C-b\C-x\C-b_\C-x\C-f\C-x\C-f\C-x\C-f\C-x\ef_\C-x\eb\n") assert_equal 'a_b_c def_ ghi', Reline.readmultiline(&proc{ true }) end @@ -54,11 +54,11 @@ def test_macro_commands_for_editing @config.add_default_key_binding("\C-x\C-v".bytes, :quoted_insert) #@config.add_default_key_binding("\C-xa".bytes, :self_insert) @config.add_default_key_binding("\C-x\C-t".bytes, :transpose_chars) - @config.add_default_key_binding("\C-x\M-t".bytes, :transpose_words) - @config.add_default_key_binding("\C-x\M-u".bytes, :upcase_word) - @config.add_default_key_binding("\C-x\M-l".bytes, :downcase_word) - @config.add_default_key_binding("\C-x\M-c".bytes, :capitalize_word) - @writer.write("abcde\C-b\C-b\C-b\C-x\C-d\C-x\C-h\C-x\C-v\C-a\C-f\C-f EF\C-x\C-t gh\C-x\M-t\C-b\C-b\C-b\C-b\C-b\C-b\C-b\C-b\C-x\M-u\C-x\M-l\C-x\M-c\n") + @config.add_default_key_binding("\C-x\et".bytes, :transpose_words) + @config.add_default_key_binding("\C-x\eu".bytes, :upcase_word) + @config.add_default_key_binding("\C-x\el".bytes, :downcase_word) + @config.add_default_key_binding("\C-x\ec".bytes, :capitalize_word) + @writer.write("abcde\C-b\C-b\C-b\C-x\C-d\C-x\C-h\C-x\C-v\C-a\C-f\C-f EF\C-x\C-t gh\C-x\et\C-b\C-b\C-b\C-b\C-b\C-b\C-b\C-b\C-x\eu\C-x\el\C-x\ec\n") assert_equal "a\C-aDE gh Fe", Reline.readmultiline(&proc{ true }) end diff --git a/test/mri/reline/yamatanooroti/multiline_repl b/test/mri/reline/yamatanooroti/multiline_repl index 8b82be60f4b..4930f2e9d86 100755 --- a/test/mri/reline/yamatanooroti/multiline_repl +++ b/test/mri/reline/yamatanooroti/multiline_repl @@ -1,8 +1,6 @@ #!/usr/bin/env ruby - -require 'bundler' -Bundler.require +require 'bundler/setup' require 'reline' require 'optparse' diff --git a/test/mri/reline/yamatanooroti/test_rendering.rb b/test/mri/reline/yamatanooroti/test_rendering.rb index e9f9ee66d2a..008ff4a5e22 100644 --- a/test/mri/reline/yamatanooroti/test_rendering.rb +++ b/test/mri/reline/yamatanooroti/test_rendering.rb @@ -52,6 +52,14 @@ def teardown ENV.delete('RELINE_TEST_PROMPT') if ENV['RELINE_TEST_PROMPT'] end + # Yamatanooroti::TestCase#write converts 0x80-0xff bytes to "\e"+(byte&0x7f).chr + # This method avoids the conversion and writes the string as is. + def write_without_meta_conversion(str) + sync + @pty_input.write(str) + try_sync + end + def test_history_back start_terminal(5, 30, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl}, startup_message: 'Multiline REPL.') write(":a\n") @@ -550,9 +558,38 @@ def test_bracketed_paste prompt> 3 prompt> end EOC + write("\e[200~.tap do\r\t4\r\t5\rend\e[201~") + assert_screen(<<~EOC) + prompt> 3 + prompt> end.tap do + prompt> 4 + prompt> 5 + prompt> end + EOC close end + def test_ctrl_v_escaped_input + omit if Reline.core.io_gate.win? + + start_terminal(5, 30, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl}, startup_message: 'Multiline REPL.') + + # When a configuration "Escape non-ASCII Input with Control-V" is enabled + # in macOS Termina.app, all non-ascii characters are escaped with ^V. + write_without_meta_conversion "\C-v\xE3\C-v\x81\C-v\x82" + assert_screen(/prompt> あ/) + + # Bracketed pasted content is also escaped + write_without_meta_conversion "\e[200~\C-a\C-v\xE3\C-v\x81\C-v\x84\C-b\e[201~" + assert_screen(/prompt> あ\^Aい\^B/) + + # Invalid bytes should be ignored with timeout + write_without_meta_conversion "\C-v\x82\C-v\xA4" + sleep 1 + write 'C' + assert_screen(/prompt> あ\^Aい\^BC/) + end + def test_bracketed_paste_with_undo_redo omit if Reline.core.io_gate.win? start_terminal(5, 30, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl}, startup_message: 'Multiline REPL.') @@ -563,7 +600,7 @@ def test_bracketed_paste_with_undo_redo Multiline REPL. prompt> abc EOC - write("\M-\C-_") + write("\e\C-_") assert_screen(<<~EOC) Multiline REPL. prompt> abcdef hoge @@ -805,13 +842,30 @@ def test_autowrap_in_the_middle_of_a_line close end - def test_terminate_in_the_middle_of_lines + def test_newline_in_the_middle_of_lines start_terminal(5, 20, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl}, startup_message: 'Multiline REPL.') write("def hoge\n 1\n 2\n 3\n 4\nend\n") write("\C-p\C-p\C-p\C-e\n") assert_screen(<<~EOC) + prompt> def hoge + prompt> 1 + prompt> 2 prompt> 3 - prompt> 4 + prompt> + EOC + close + end + + def test_ed_force_submit_in_the_middle_of_lines + write_inputrc <<~LINES + "\\C-a": ed_force_submit + LINES + start_terminal(5, 20, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl}, startup_message: 'Multiline REPL.') + write("def hoge\nend") + write("\C-p\C-a") + assert_screen(<<~EOC) + Multiline REPL. + prompt> def hoge prompt> end => :hoge prompt> @@ -845,7 +899,7 @@ def test_reset_rest_height_when_clear_screen def test_meta_key start_terminal(30, 20, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl}, startup_message: 'Multiline REPL.') - write("def ge\M-bho") + write("def ge\ebho") assert_screen(<<~EOC) Multiline REPL. prompt> def hoge @@ -866,7 +920,7 @@ def test_not_meta_key def test_force_enter start_terminal(30, 120, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl}, startup_message: 'Multiline REPL.') write("def hoge\nend\C-p\C-e") - write("\M-\x0D") + write("\e\x0D") assert_screen(<<~EOC) Multiline REPL. prompt> def hoge @@ -911,7 +965,7 @@ def test_eof_without_newline def test_em_set_mark_and_em_exchange_mark start_terminal(10, 50, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl}, startup_message: 'Multiline REPL.') - write("aaa bbb ccc ddd\M-b\M-b\M-\x20\M-b\C-x\C-xX\C-x\C-xY") + write("aaa bbb ccc ddd\eb\eb\e\x20\eb\C-x\C-xX\C-x\C-xY") assert_screen(<<~'EOC') Multiline REPL. prompt> aaa Ybbb Xccc ddd @@ -1511,7 +1565,7 @@ def test_dialog_with_fullwidth_scrollbar def test_rerender_argument_prompt_after_pasting start_terminal(20, 30, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl}, startup_message: 'Multiline REPL.') write('abcdef') - write("\M-3\C-h") + write("\e3\C-h") assert_screen(<<~'EOC') Multiline REPL. prompt> abc @@ -1647,7 +1701,7 @@ def test_insert_newline_in_the_middle_of_buffer_just_after_dialog write("class A\n def a\n 3\n end\nend") write("\n") write("\C-p\C-p\C-p\C-p\C-p\C-e\C-hS") - write("\M-\x0D") + write("\e\x0D") write(" 3") assert_screen(<<~'EOC') prompt> 3 @@ -1724,6 +1778,41 @@ def test_exit_with_ctrl_d close end + def test_quoted_insert_intr_keys + omit if Reline.core.io_gate.win? + start_terminal(5, 30, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl}, startup_message: 'Multiline REPL.') + write '"' + write "\C-v" + write "\C-c" + write "\C-v" + write "\C-z" + write "\C-v" + write "\C-\\" + write "\".bytes\n" + assert_screen(<<~EOC) + Multiline REPL. + prompt> "^C^Z^\\\".bytes + => [3, 26, 28] + prompt> + EOC + close + end + + def test_quoted_insert_timeout + omit if Reline.core.io_gate.win? + + start_terminal(5, 30, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl}, startup_message: 'Multiline REPL.') + write "\C-v" + write "\C-a" + write "\C-v" + # broken bytes should be ignored with timeout + write_without_meta_conversion "\xE3\xE4\xE5" + sleep 1 + write "\C-v" + write "\C-b" + assert_screen(/prompt> \^A\^B/) + end + def test_print_before_readline code = <<~RUBY puts 'Multiline REPL.' From abd6cec6a59e6b165a95985505e3520da0581da2 Mon Sep 17 00:00:00 2001 From: Charles Oliver Nutter Date: Wed, 14 Jan 2026 23:01:48 -0600 Subject: [PATCH 070/168] Fix Data subclasses with ivars Data subclasses were set up to copy their parent class's var table manager and accessors, but did not overwrite those copies' realClass to the new class. This resulted in future variable accesses potentially walking back to the parent class, seeing an incorrect var table size, and allocating the wrong size table for the spilled instance variables. The new logic does that copying with the new realClass in hand and properly replaces it in the copied accesses and manager. This fixes all remaining issues marshaling Data with Psych and may fix other issues with Data subclasses that are not currently showing up in tests. --- core/src/main/java/org/jruby/RubyClass.java | 8 ++++---- .../runtime/invokedynamic/VariableSite.java | 8 ++++---- .../runtime/ivars/FieldVariableAccessor.java | 8 ++++++-- .../runtime/ivars/RawFieldVariableAccessor.java | 9 ++++++++- .../runtime/ivars/StampedVariableAccessor.java | 4 ++++ .../jruby/runtime/ivars/VariableAccessor.java | 4 ++++ .../runtime/ivars/VariableTableManager.java | 16 +++++++++------- test/mri/excludes/TestData.rb | 1 - 8 files changed, 39 insertions(+), 19 deletions(-) delete mode 100644 test/mri/excludes/TestData.rb diff --git a/core/src/main/java/org/jruby/RubyClass.java b/core/src/main/java/org/jruby/RubyClass.java index e099445586e..f0b140e69b4 100644 --- a/core/src/main/java/org/jruby/RubyClass.java +++ b/core/src/main/java/org/jruby/RubyClass.java @@ -550,7 +550,7 @@ public static RubyClass newClass(ThreadContext context, RubyClass superClass, St baseName(name); clazz.makeMetaClass(context, superClass.getMetaClass()); if (setParent) clazz.setParent(parent); - clazz.copyVariableTableManager(context, superClass); + clazz.copyVariableTableManager(context, superClass, clazz); parent.setConstant(context, name, clazz, file, line); superClass.invokeInherited(context, superClass, clazz); return clazz; @@ -1073,7 +1073,7 @@ private RubyClass initializeCommon(ThreadContext context, RubyClass superClazz, allocator = superClazz.allocator; makeMetaClass(context, superClazz.getMetaClass()); superClazz.addSubclass(this); - copyVariableTableManager(context, superClazz); + copyVariableTableManager(context, superClazz, this); marshal = superClazz.marshal; @@ -1083,11 +1083,11 @@ private RubyClass initializeCommon(ThreadContext context, RubyClass superClazz, return this; } - private void copyVariableTableManager(ThreadContext context, RubyClass superClazz) { + private void copyVariableTableManager(ThreadContext context, RubyClass realClass, RubyClass superClazz) { VariableTableManager variableTableManager = superClazz.getVariableTableManager(); if (variableTableManager.getRealClass().superClass() == context.runtime.getData()) { // duplicate data's variable table in subclasses - this.variableTableManager = variableTableManager.duplicate(); + this.variableTableManager = variableTableManager.duplicate(realClass); } } diff --git a/core/src/main/java/org/jruby/runtime/invokedynamic/VariableSite.java b/core/src/main/java/org/jruby/runtime/invokedynamic/VariableSite.java index 4d2b188b1d3..f71872d9fb8 100644 --- a/core/src/main/java/org/jruby/runtime/invokedynamic/VariableSite.java +++ b/core/src/main/java/org/jruby/runtime/invokedynamic/VariableSite.java @@ -145,10 +145,10 @@ public IRubyObject ivarGet(IRubyObject self) throws Throwable { MethodHandle test = findStatic(VariableSite.class, "testRealClass", methodType(boolean.class, int.class, IRubyObject.class)); test = insertArguments(test, 0, accessor.getClassId()); - getValue = guardWithTest(test, getValue, fallback); + MethodHandle guarded = guardWithTest(test, getValue, fallback); if (Options.INVOKEDYNAMIC_LOG_BINDING.load()) LOG.info(name() + "\tget on class " + self.getMetaClass().id + " bound directly" + extractSourceInfo()); - setTarget(getValue); + setTarget(guarded); return (IRubyObject)getValue.invokeExact(self); } @@ -209,10 +209,10 @@ public void ivarSet(IRubyObject self, IRubyObject value) throws Throwable { test = insertArguments(test, 0, accessor.getClassId()); test = dropArguments(test, 1, IRubyObject.class); - setValue = guardWithTest(test, setValue, fallback); + MethodHandle guarded = guardWithTest(test, setValue, fallback); if (Options.INVOKEDYNAMIC_LOG_BINDING.load()) LOG.info(name() + "\tset on class " + self.getMetaClass().id + " bound directly" + extractSourceInfo()); - setTarget(setValue); + setTarget(guarded); setValue.invokeExact(self, value); } diff --git a/core/src/main/java/org/jruby/runtime/ivars/FieldVariableAccessor.java b/core/src/main/java/org/jruby/runtime/ivars/FieldVariableAccessor.java index 4136b75f605..dbae1062472 100644 --- a/core/src/main/java/org/jruby/runtime/ivars/FieldVariableAccessor.java +++ b/core/src/main/java/org/jruby/runtime/ivars/FieldVariableAccessor.java @@ -43,8 +43,8 @@ * A variable accessor that accesses a field directly; */ public class FieldVariableAccessor extends VariableAccessor { - private final MethodHandle getter; - private final MethodHandle setter; + protected final MethodHandle getter; + protected final MethodHandle setter; /** * Construct a new FieldVariableAccessor for the given "real" class, @@ -64,6 +64,10 @@ public FieldVariableAccessor(RubyClass realClass, String name, int index, int cl this.setter = wrapSetter(setter); } + public FieldVariableAccessor cloneFor(RubyClass newRealClass) { + return new FieldVariableAccessor(newRealClass, name, index, classId, getter, setter); + } + protected MethodHandle wrapSetter(MethodHandle setter) { // mix frozen check into setter return MethodHandles.foldArguments(setter, ENSURE_SETTABLE.asType(setter.type())); diff --git a/core/src/main/java/org/jruby/runtime/ivars/RawFieldVariableAccessor.java b/core/src/main/java/org/jruby/runtime/ivars/RawFieldVariableAccessor.java index 8b62b110f8b..10f5419dd10 100644 --- a/core/src/main/java/org/jruby/runtime/ivars/RawFieldVariableAccessor.java +++ b/core/src/main/java/org/jruby/runtime/ivars/RawFieldVariableAccessor.java @@ -59,8 +59,15 @@ public class RawFieldVariableAccessor extends FieldVariableAccessor { * @param setter the setter handle for the field */ public RawFieldVariableAccessor(RubyClass realClass, boolean unwrapInSet, Class toJava, Class returnType, String name, int index, int classId, MethodHandle getter, MethodHandle setter) { - super(realClass, name, index, classId, wrapGetter(getter, realClass, returnType), wrapSetter(setter, realClass, unwrapInSet, toJava, returnType)); + this(realClass, name, index, classId, wrapGetter(getter, realClass, returnType), wrapSetter(setter, realClass, unwrapInSet, toJava, returnType)); + } + + private RawFieldVariableAccessor(RubyClass realClass, String name, int index, int classId, MethodHandle getter, MethodHandle setter) { + super(realClass, name, index, classId, getter, setter); + } + public RawFieldVariableAccessor cloneFor(RubyClass newRealClass) { + return new RawFieldVariableAccessor(newRealClass, name, index, classId, getter, setter); } @Override diff --git a/core/src/main/java/org/jruby/runtime/ivars/StampedVariableAccessor.java b/core/src/main/java/org/jruby/runtime/ivars/StampedVariableAccessor.java index 22519dcae70..2f17b2d34b9 100644 --- a/core/src/main/java/org/jruby/runtime/ivars/StampedVariableAccessor.java +++ b/core/src/main/java/org/jruby/runtime/ivars/StampedVariableAccessor.java @@ -51,6 +51,10 @@ public StampedVariableAccessor(RubyClass realClass, String name, int index, int super(realClass, name, index, classId); } + public StampedVariableAccessor cloneFor(RubyClass newRealClass) { + return new StampedVariableAccessor(newRealClass, name, index, classId); + } + /** * Set this variable into the given object using Unsafe to ensure * safe updating of the variable table. diff --git a/core/src/main/java/org/jruby/runtime/ivars/VariableAccessor.java b/core/src/main/java/org/jruby/runtime/ivars/VariableAccessor.java index 0f1c62efe4c..b458a3887a6 100644 --- a/core/src/main/java/org/jruby/runtime/ivars/VariableAccessor.java +++ b/core/src/main/java/org/jruby/runtime/ivars/VariableAccessor.java @@ -192,6 +192,10 @@ public String toString() { return "ivar:" + getName() + ":" + index; } + public VariableAccessor cloneFor(RubyClass newRealClass) { + throw new UnsupportedOperationException(); + } + /** a dummy accessor that will always return null */ public static final VariableAccessor DUMMY_ACCESSOR = new VariableAccessor(null, null, -1, -1) {}; diff --git a/core/src/main/java/org/jruby/runtime/ivars/VariableTableManager.java b/core/src/main/java/org/jruby/runtime/ivars/VariableTableManager.java index df163d4fa56..0ac1176017c 100644 --- a/core/src/main/java/org/jruby/runtime/ivars/VariableTableManager.java +++ b/core/src/main/java/org/jruby/runtime/ivars/VariableTableManager.java @@ -111,10 +111,10 @@ public VariableTableManager(RubyClass realClass) { * * @param original VariableTableManager to copy */ - VariableTableManager(VariableTableManager original) { + VariableTableManager(VariableTableManager original, RubyClass realClass) { synchronized (original) { - this.realClass = original.realClass; - this.variableAccessors = copyVariableAccessors(original.variableAccessors); + this.realClass = realClass; + this.variableAccessors = copyVariableAccessors(realClass, original.variableAccessors); this.variableNames = original.variableNames.clone(); this.hasObjectID = original.hasObjectID; this.hasFFI = original.hasFFI; @@ -282,8 +282,10 @@ VariableAccessor getVariableAccessorWithBuilder(String name, Function copyVariableAccessors(Map myVariableAccessors) { - return new LinkedHashMap<>(myVariableAccessors); + private static Map copyVariableAccessors(RubyClass realClass, Map otherVariableAccessors) { + var myVariableAccessors = new LinkedHashMap(otherVariableAccessors.size()); + otherVariableAccessors.forEach((name, accessor) -> myVariableAccessors.put(name, accessor.cloneFor(realClass))); + return myVariableAccessors; } private static Map copyVariableAccessors(Map myVariableAccessors, String name, VariableAccessor ivarAccessor) { @@ -544,8 +546,8 @@ public Object clearVariable(RubyBasicObject object, String name) { } } - public VariableTableManager duplicate() { - return new VariableTableManager(this); + public VariableTableManager duplicate(RubyClass realClass) { + return new VariableTableManager(this, realClass); } /** diff --git a/test/mri/excludes/TestData.rb b/test/mri/excludes/TestData.rb deleted file mode 100644 index 36fbe2ee228..00000000000 --- a/test/mri/excludes/TestData.rb +++ /dev/null @@ -1 +0,0 @@ -exclude :test_inspect, "fails in JIT mode on Linux CI on GHA" From 1559cdaaa9ad3bb2fe0312bab4d20dd0a7a11884 Mon Sep 17 00:00:00 2001 From: Charles Oliver Nutter Date: Thu, 22 Jan 2026 16:07:50 -0600 Subject: [PATCH 071/168] Update stdlib tests again from CRuby 4.0 All tests from CRuby 4.0 were copied over, but several older tests, tests for gems no longer bundled with Ruby, or unused fixtures still needed to be deleted. --- test/mri.stdlib.index | 9 - test/mri/benchmark/test_benchmark.rb | 167 - test/mri/cgi/test_cgi_cookie.rb | 211 - test/mri/cgi/test_cgi_core.rb | 307 - test/mri/cgi/test_cgi_header.rb | 192 - test/mri/cgi/test_cgi_modruby.rb | 149 - test/mri/cgi/test_cgi_multipart.rb | 385 -- test/mri/cgi/test_cgi_session.rb | 169 - test/mri/cgi/test_cgi_tag_helper.rb | 355 -- test/mri/cgi/test_cgi_util.rb | 312 -- test/mri/cgi/testdata/file1.html | 10 - test/mri/cgi/testdata/large.png | Bin 156414 -> 0 bytes test/mri/cgi/testdata/small.png | Bin 82 -> 0 bytes test/mri/fiddle/helper.rb | 202 - test/mri/fiddle/test_c_struct_builder.rb | 69 - test/mri/fiddle/test_c_struct_entry.rb | 171 - test/mri/fiddle/test_c_union_entity.rb | 36 - test/mri/fiddle/test_closure.rb | 173 - test/mri/fiddle/test_cparser.rb | 414 -- test/mri/fiddle/test_fiddle.rb | 91 - test/mri/fiddle/test_func.rb | 180 - test/mri/fiddle/test_function.rb | 310 -- test/mri/fiddle/test_handle.rb | 244 - test/mri/fiddle/test_import.rb | 499 -- test/mri/fiddle/test_memory_view.rb | 175 - test/mri/fiddle/test_pack.rb | 37 - test/mri/fiddle/test_pinned.rb | 34 - test/mri/fiddle/test_pointer.rb | 319 -- test/mri/irb/command/test_cd.rb | 84 - test/mri/irb/command/test_custom_command.rb | 194 - test/mri/irb/command/test_disable_irb.rb | 28 - test/mri/irb/command/test_force_exit.rb | 51 - test/mri/irb/command/test_help.rb | 75 - .../irb/command/test_multi_irb_commands.rb | 50 - test/mri/irb/command/test_show_source.rb | 410 -- test/mri/irb/helper.rb | 234 - test/mri/irb/test_color.rb | 274 - test/mri/irb/test_color_printer.rb | 69 - test/mri/irb/test_command.rb | 971 ---- test/mri/irb/test_completion.rb | 317 -- test/mri/irb/test_context.rb | 737 --- test/mri/irb/test_debugger_integration.rb | 513 -- test/mri/irb/test_eval_history.rb | 69 - test/mri/irb/test_evaluation.rb | 44 - test/mri/irb/test_helper_method.rb | 135 - test/mri/irb/test_history.rb | 532 -- test/mri/irb/test_init.rb | 388 -- test/mri/irb/test_input_method.rb | 195 - test/mri/irb/test_irb.rb | 936 ---- test/mri/irb/test_locale.rb | 118 - test/mri/irb/test_nesting_parser.rb | 339 -- test/mri/irb/test_option.rb | 13 - test/mri/irb/test_raise_exception.rb | 74 - test/mri/irb/test_ruby_lex.rb | 242 - test/mri/irb/test_tracer.rb | 90 - test/mri/irb/test_type_completor.rb | 109 - test/mri/irb/test_workspace.rb | 126 - test/mri/irb/yamatanooroti/test_rendering.rb | 478 -- test/mri/json/fixtures/fail4.json | 1 - test/mri/json/fixtures/fail9.json | 1 - test/mri/json/fixtures/pass15.json | 1 - test/mri/json/fixtures/pass16.json | 1 - test/mri/json/fixtures/pass17.json | 1 - test/mri/json/fixtures/pass26.json | 1 - test/mri/logger/test_formatter.rb | 35 - test/mri/logger/test_logdevice.rb | 859 --- test/mri/logger/test_logger.rb | 402 -- test/mri/logger/test_logperiod.rb | 67 - test/mri/logger/test_severity.rb | 94 - .../mri/openssl/fixtures/pkey/certificate.der | Bin 1325 -> 0 bytes test/mri/openssl/fixtures/pkey/dsa1024.pem | 12 - test/mri/openssl/fixtures/pkey/dsa256.pem | 8 - test/mri/openssl/fixtures/pkey/dsa512.pem | 8 - test/mri/openssl/fixtures/pkey/empty.der | 0 test/mri/openssl/fixtures/pkey/empty.pem | 0 test/mri/openssl/fixtures/pkey/fullchain.pem | 56 - test/mri/openssl/fixtures/pkey/garbage.txt | 1 - .../openssl/fixtures/pkey/p256_too_large.pem | 5 - .../openssl/fixtures/pkey/p384_invalid.pem | 6 - test/mri/openssl/fixtures/pkey/rsa1024.pem | 15 - test/mri/ostruct/test_ostruct.rb | 434 -- test/mri/prism/attribute_write_test.rb | 60 - test/mri/prism/command_line_test.rb | 69 - test/mri/prism/comments_test.rb | 138 - test/mri/prism/compiler_test.rb | 31 - test/mri/prism/constant_path_node_test.rb | 91 - test/mri/prism/desugar_compiler_test.rb | 80 - test/mri/prism/dispatcher_test.rb | 46 - test/mri/prism/encoding_test.rb | 572 -- .../errors/block_args_in_array_assignment.txt | 3 - .../dont_allow_return_inside_sclass_body.txt | 3 - .../errors/it_with_ordinary_parameter.txt | 3 - .../keyword_args_in_array_assignment.txt | 3 - .../mri/prism/fixtures/it_indirect_writes.txt | 23 - .../prism/fixtures/seattlerb/block_break.txt | 1 - .../prism/fixtures/seattlerb/block_next.txt | 1 - .../prism/fixtures/seattlerb/dasgn_icky2.txt | 8 - .../prism/fixtures/seattlerb/yield_arg.txt | 1 - .../fixtures/seattlerb/yield_call_assocs.txt | 11 - .../fixtures/seattlerb/yield_empty_parens.txt | 1 - .../unparser/corpus/literal/control.txt | 15 - .../unparser/corpus/literal/yield.txt | 3 - .../prism/fixtures/whitequark/args_assocs.txt | 11 - .../whitequark/args_assocs_legacy.txt | 11 - test/mri/prism/fixtures/whitequark/break.txt | 7 - .../prism/fixtures/whitequark/break_block.txt | 1 - .../class_definition_in_while_cond.txt | 7 - .../if_while_after_class__since_32.txt | 7 - test/mri/prism/fixtures/whitequark/next.txt | 7 - .../prism/fixtures/whitequark/next_block.txt | 1 - test/mri/prism/fixtures/whitequark/redo.txt | 1 - test/mri/prism/fixtures/whitequark/retry.txt | 1 - test/mri/prism/fixtures/whitequark/yield.txt | 7 - test/mri/prism/format_errors_test.rb | 24 - test/mri/prism/integer_parse_test.rb | 45 - test/mri/prism/location_test.rb | 945 ---- test/mri/prism/memsize_test.rb | 17 - test/mri/prism/parameters_signature_test.rb | 91 - test/mri/prism/parse_comments_test.rb | 21 - test/mri/prism/parse_stream_test.rb | 74 - test/mri/prism/parse_test.rb | 374 -- test/mri/prism/parser_test.rb | 185 - test/mri/prism/pattern_test.rb | 132 - test/mri/prism/ripper_test.rb | 85 - test/mri/prism/ruby_api_test.rb | 255 - test/mri/prism/ruby_parser_test.rb | 153 - test/mri/prism/snapshots/alias.txt | 194 - test/mri/prism/snapshots/arithmetic.txt | 255 - test/mri/prism/snapshots/arrays.txt | 2308 -------- test/mri/prism/snapshots/begin_ensure.txt | 251 - test/mri/prism/snapshots/begin_rescue.txt | 699 --- test/mri/prism/snapshots/blocks.txt | 774 --- .../mri/prism/snapshots/boolean_operators.txt | 54 - test/mri/prism/snapshots/booleans.txt | 7 - test/mri/prism/snapshots/break.txt | 239 - test/mri/prism/snapshots/case.txt | 495 -- test/mri/prism/snapshots/classes.txt | 365 -- .../prism/snapshots/command_method_call.txt | 755 --- test/mri/prism/snapshots/comments.txt | 145 - test/mri/prism/snapshots/constants.txt | 1242 ----- test/mri/prism/snapshots/dash_heredocs.txt | 256 - test/mri/prism/snapshots/defined.txt | 88 - test/mri/prism/snapshots/dos_endings.txt | 108 - test/mri/prism/snapshots/dstring.txt | 83 - test/mri/prism/snapshots/dsym_str.txt | 11 - .../snapshots/embdoc_no_newline_at_end.txt | 5 - .../prism/snapshots/emoji_method_calls.txt | 31 - test/mri/prism/snapshots/endless_methods.txt | 107 - .../endless_range_in_conditional.txt | 53 - test/mri/prism/snapshots/for.txt | 188 - test/mri/prism/snapshots/global_variables.txt | 191 - test/mri/prism/snapshots/hashes.txt | 384 -- test/mri/prism/snapshots/heredoc.txt | 11 - .../heredoc_with_carriage_returns.txt | 11 - .../prism/snapshots/heredoc_with_comment.txt | 21 - .../heredoc_with_escaped_newline_at_start.txt | 67 - .../heredoc_with_trailing_newline.txt | 11 - .../snapshots/heredocs_leading_whitespace.txt | 55 - test/mri/prism/snapshots/heredocs_nested.txt | 90 - .../heredocs_with_ignored_newlines.txt | 69 - ...cs_with_ignored_newlines_and_non_empty.txt | 11 - test/mri/prism/snapshots/if.txt | 462 -- .../mri/prism/snapshots/indented_file_end.txt | 18 - .../prism/snapshots/integer_operations.txt | 635 --- .../prism/snapshots/keyword_method_names.txt | 173 - test/mri/prism/snapshots/keywords.txt | 13 - test/mri/prism/snapshots/lambda.txt | 201 - test/mri/prism/snapshots/method_calls.txt | 2456 -------- test/mri/prism/snapshots/methods.txt | 2051 ------- test/mri/prism/snapshots/modules.txt | 183 - test/mri/prism/snapshots/multi_write.txt | 93 - .../prism/snapshots/newline_terminated.txt | 107 - test/mri/prism/snapshots/next.txt | 149 - test/mri/prism/snapshots/nils.txt | 34 - .../snapshots/non_alphanumeric_methods.txt | 503 -- test/mri/prism/snapshots/not.txt | 351 -- test/mri/prism/snapshots/numbers.txt | 142 - test/mri/prism/snapshots/patterns.txt | 4921 ----------------- test/mri/prism/snapshots/procs.txt | 403 -- .../snapshots/range_begin_open_exclusive.txt | 13 - .../snapshots/range_begin_open_inclusive.txt | 13 - test/mri/prism/snapshots/range_beginless.txt | 114 - .../snapshots/range_end_open_exclusive.txt | 13 - .../snapshots/range_end_open_inclusive.txt | 13 - test/mri/prism/snapshots/ranges.txt | 533 -- test/mri/prism/snapshots/regex.txt | 371 -- test/mri/prism/snapshots/regex_char_width.txt | 50 - .../mri/prism/snapshots/repeat_parameters.txt | 473 -- test/mri/prism/snapshots/rescue.txt | 491 -- test/mri/prism/snapshots/rescue_modifier.txt | 230 - test/mri/prism/snapshots/return.txt | 155 - test/mri/prism/snapshots/seattlerb/BEGIN.txt | 15 - .../seattlerb/TestRubyParserShared.txt | 361 -- .../snapshots/seattlerb/__ENCODING__.txt | 6 - .../seattlerb/alias_gvar_backref.txt | 13 - .../snapshots/seattlerb/alias_resword.txt | 21 - .../prism/snapshots/seattlerb/and_multi.txt | 26 - .../snapshots/seattlerb/aref_args_assocs.txt | 23 - .../seattlerb/aref_args_lit_assocs.txt | 26 - .../snapshots/seattlerb/args_kw_block.txt | 39 - .../snapshots/seattlerb/array_line_breaks.txt | 25 - .../seattlerb/array_lits_trailing_calls.txt | 35 - .../prism/snapshots/seattlerb/assoc__bare.txt | 31 - .../prism/snapshots/seattlerb/assoc_label.txt | 34 - .../seattlerb/attr_asgn_colon_id.txt | 23 - .../seattlerb/attrasgn_array_arg.txt | 42 - .../seattlerb/attrasgn_array_lhs.txt | 83 - .../attrasgn_primary_dot_constant.txt | 31 - .../backticks_interpolation_line.txt | 38 - .../mri/prism/snapshots/seattlerb/bang_eq.txt | 24 - test/mri/prism/snapshots/seattlerb/bdot2.txt | 38 - test/mri/prism/snapshots/seattlerb/bdot3.txt | 38 - .../seattlerb/begin_ensure_no_bodies.txt | 16 - .../begin_rescue_else_ensure_bodies.txt | 47 - .../begin_rescue_else_ensure_no_bodies.txt | 27 - .../begin_rescue_ensure_no_bodies.txt | 23 - .../snapshots/seattlerb/block_arg__bare.txt | 31 - .../snapshots/seattlerb/block_arg_kwsplat.txt | 39 - .../seattlerb/block_arg_opt_arg_block.txt | 54 - .../seattlerb/block_arg_opt_splat.txt | 51 - .../block_arg_opt_splat_arg_block_omfg.txt | 59 - .../seattlerb/block_arg_optional.txt | 43 - .../snapshots/seattlerb/block_arg_scope.txt | 40 - .../snapshots/seattlerb/block_arg_scope2.txt | 43 - .../seattlerb/block_arg_splat_arg.txt | 45 - .../snapshots/seattlerb/block_args_kwargs.txt | 44 - .../seattlerb/block_args_no_kwargs.txt | 37 - .../snapshots/seattlerb/block_args_opt1.txt | 59 - .../snapshots/seattlerb/block_args_opt2.txt | 52 - .../snapshots/seattlerb/block_args_opt2_2.txt | 71 - .../snapshots/seattlerb/block_args_opt3.txt | 79 - .../prism/snapshots/seattlerb/block_break.txt | 56 - .../block_call_defn_call_block_call.txt | 80 - .../block_call_dot_op2_brace_block.txt | 100 - .../block_call_dot_op2_cmd_args_do_block.txt | 113 - .../seattlerb/block_call_operation_colon.txt | 54 - .../seattlerb/block_call_operation_dot.txt | 54 - .../block_call_paren_call_block_call.txt | 60 - .../block_command_operation_colon.txt | 49 - .../seattlerb/block_command_operation_dot.txt | 49 - .../seattlerb/block_decomp_anon_splat_arg.txt | 46 - .../seattlerb/block_decomp_arg_splat.txt | 46 - .../seattlerb/block_decomp_arg_splat_arg.txt | 52 - .../seattlerb/block_decomp_splat.txt | 46 - .../prism/snapshots/seattlerb/block_kw.txt | 42 - .../seattlerb/block_kw__required.txt | 38 - .../snapshots/seattlerb/block_kwarg_lvar.txt | 50 - .../seattlerb/block_kwarg_lvar_multiple.txt | 61 - .../prism/snapshots/seattlerb/block_next.txt | 56 - .../snapshots/seattlerb/block_opt_arg.txt | 46 - .../snapshots/seattlerb/block_opt_splat.txt | 48 - .../block_opt_splat_arg_block_omfg.txt | 56 - .../snapshots/seattlerb/block_optarg.txt | 46 - .../snapshots/seattlerb/block_paren_splat.txt | 49 - .../snapshots/seattlerb/block_reg_optarg.txt | 49 - .../snapshots/seattlerb/block_return.txt | 56 - .../prism/snapshots/seattlerb/block_scope.txt | 29 - .../snapshots/seattlerb/block_splat_reg.txt | 42 - test/mri/prism/snapshots/seattlerb/bug169.txt | 28 - test/mri/prism/snapshots/seattlerb/bug179.txt | 28 - test/mri/prism/snapshots/seattlerb/bug190.txt | 11 - test/mri/prism/snapshots/seattlerb/bug191.txt | 87 - test/mri/prism/snapshots/seattlerb/bug202.txt | 22 - test/mri/prism/snapshots/seattlerb/bug236.txt | 70 - test/mri/prism/snapshots/seattlerb/bug290.txt | 24 - .../mri/prism/snapshots/seattlerb/bug_187.txt | 59 - .../mri/prism/snapshots/seattlerb/bug_215.txt | 14 - .../mri/prism/snapshots/seattlerb/bug_249.txt | 86 - .../mri/prism/snapshots/seattlerb/bug_and.txt | 21 - .../snapshots/seattlerb/bug_args__19.txt | 58 - .../snapshots/seattlerb/bug_args_masgn.txt | 49 - .../snapshots/seattlerb/bug_args_masgn2.txt | 58 - .../bug_args_masgn_outer_parens__19.txt | 55 - .../seattlerb/bug_call_arglist_parens.txt | 110 - .../seattlerb/bug_case_when_regexp.txt | 28 - .../prism/snapshots/seattlerb/bug_comma.txt | 41 - .../snapshots/seattlerb/bug_cond_pct.txt | 22 - .../snapshots/seattlerb/bug_hash_args.txt | 38 - .../bug_hash_args_trailing_comma.txt | 38 - .../seattlerb/bug_hash_interp_array.txt | 26 - .../snapshots/seattlerb/bug_masgn_right.txt | 49 - .../snapshots/seattlerb/bug_not_parens.txt | 25 - .../seattlerb/bug_op_asgn_rescue.txt | 26 - .../prism/snapshots/seattlerb/call_and.txt | 24 - .../snapshots/seattlerb/call_arg_assoc.txt | 34 - .../seattlerb/call_arg_assoc_kwsplat.txt | 43 - .../snapshots/seattlerb/call_arg_kwsplat.txt | 37 - .../seattlerb/call_args_assoc_quoted.txt | 106 - .../call_args_assoc_trailing_comma.txt | 34 - .../snapshots/seattlerb/call_args_command.txt | 54 - .../snapshots/seattlerb/call_array_arg.txt | 38 - .../seattlerb/call_array_block_call.txt | 40 - .../call_array_lambda_block_call.txt | 41 - .../seattlerb/call_array_lit_inline_hash.txt | 45 - .../prism/snapshots/seattlerb/call_assoc.txt | 31 - .../snapshots/seattlerb/call_assoc_new.txt | 34 - .../seattlerb/call_assoc_new_if_multiline.txt | 58 - .../seattlerb/call_assoc_trailing_comma.txt | 31 - .../seattlerb/call_bang_command_call.txt | 41 - .../seattlerb/call_bang_squiggle.txt | 24 - .../seattlerb/call_begin_call_block_call.txt | 53 - .../seattlerb/call_block_arg_named.txt | 28 - .../prism/snapshots/seattlerb/call_carat.txt | 24 - .../prism/snapshots/seattlerb/call_colon2.txt | 17 - .../snapshots/seattlerb/call_colon_parens.txt | 18 - .../prism/snapshots/seattlerb/call_div.txt | 24 - .../snapshots/seattlerb/call_dot_parens.txt | 18 - .../prism/snapshots/seattlerb/call_env.txt | 25 - .../prism/snapshots/seattlerb/call_eq3.txt | 24 - .../mri/prism/snapshots/seattlerb/call_gt.txt | 24 - .../snapshots/seattlerb/call_kwsplat.txt | 27 - .../snapshots/seattlerb/call_leading_dots.txt | 35 - .../seattlerb/call_leading_dots_comment.txt | 35 - .../mri/prism/snapshots/seattlerb/call_lt.txt | 24 - .../prism/snapshots/seattlerb/call_lte.txt | 24 - .../prism/snapshots/seattlerb/call_not.txt | 18 - .../prism/snapshots/seattlerb/call_pipe.txt | 24 - .../prism/snapshots/seattlerb/call_rshift.txt | 24 - .../seattlerb/call_self_brackets.txt | 22 - .../snapshots/seattlerb/call_spaceship.txt | 24 - .../call_stabby_do_end_with_block.txt | 41 - .../call_stabby_with_braces_block.txt | 41 - .../prism/snapshots/seattlerb/call_star.txt | 24 - .../prism/snapshots/seattlerb/call_star2.txt | 24 - .../seattlerb/call_trailing_comma.txt | 21 - .../seattlerb/call_trailing_dots.txt | 35 - .../snapshots/seattlerb/call_unary_bang.txt | 18 - .../mri/prism/snapshots/seattlerb/case_in.txt | 976 ---- .../prism/snapshots/seattlerb/case_in_31.txt | 49 - .../prism/snapshots/seattlerb/case_in_37.txt | 58 - .../prism/snapshots/seattlerb/case_in_42.txt | 44 - .../snapshots/seattlerb/case_in_42_2.txt | 40 - .../prism/snapshots/seattlerb/case_in_47.txt | 52 - .../prism/snapshots/seattlerb/case_in_67.txt | 33 - .../prism/snapshots/seattlerb/case_in_86.txt | 52 - .../snapshots/seattlerb/case_in_86_2.txt | 52 - .../seattlerb/case_in_array_pat_const.txt | 42 - .../seattlerb/case_in_array_pat_const2.txt | 48 - .../case_in_array_pat_paren_assign.txt | 48 - .../snapshots/seattlerb/case_in_const.txt | 28 - .../snapshots/seattlerb/case_in_else.txt | 40 - .../snapshots/seattlerb/case_in_find.txt | 47 - .../seattlerb/case_in_find_array.txt | 44 - .../snapshots/seattlerb/case_in_hash_pat.txt | 68 - .../seattlerb/case_in_hash_pat_assign.txt | 86 - .../case_in_hash_pat_paren_assign.txt | 51 - .../seattlerb/case_in_hash_pat_paren_true.txt | 47 - .../seattlerb/case_in_hash_pat_rest.txt | 55 - .../seattlerb/case_in_hash_pat_rest_solo.txt | 42 - .../seattlerb/case_in_if_unless_post_mod.txt | 67 - .../snapshots/seattlerb/case_in_multiple.txt | 59 - .../prism/snapshots/seattlerb/case_in_or.txt | 38 - .../snapshots/seattlerb/class_comments.txt | 31 - .../snapshots/seattlerb/cond_unary_minus.txt | 15 - .../seattlerb/const_2_op_asgn_or2.txt | 24 - .../seattlerb/const_3_op_asgn_or.txt | 18 - .../seattlerb/const_op_asgn_and1.txt | 19 - .../seattlerb/const_op_asgn_and2.txt | 18 - .../snapshots/seattlerb/const_op_asgn_or.txt | 20 - .../prism/snapshots/seattlerb/dasgn_icky2.txt | 61 - .../snapshots/seattlerb/defined_eh_parens.txt | 13 - .../seattlerb/defn_arg_asplat_arg.txt | 37 - .../seattlerb/defn_arg_forward_args.txt | 49 - .../seattlerb/defn_args_forward_args.txt | 61 - .../snapshots/seattlerb/defn_comments.txt | 18 - .../seattlerb/defn_endless_command.txt | 36 - .../seattlerb/defn_endless_command_rescue.txt | 43 - .../snapshots/seattlerb/defn_forward_args.txt | 43 - .../defn_forward_args__no_parens.txt | 43 - .../snapshots/seattlerb/defn_kwarg_env.txt | 55 - .../snapshots/seattlerb/defn_kwarg_kwarg.txt | 45 - .../seattlerb/defn_kwarg_kwsplat.txt | 39 - .../seattlerb/defn_kwarg_kwsplat_anon.txt | 39 - .../snapshots/seattlerb/defn_kwarg_lvar.txt | 42 - .../seattlerb/defn_kwarg_no_parens.txt | 34 - .../snapshots/seattlerb/defn_kwarg_val.txt | 37 - .../snapshots/seattlerb/defn_no_kwargs.txt | 29 - .../snapshots/seattlerb/defn_oneliner.txt | 47 - .../snapshots/seattlerb/defn_oneliner_eq2.txt | 47 - .../seattlerb/defn_oneliner_noargs.txt | 30 - .../defn_oneliner_noargs_parentheses.txt | 30 - .../seattlerb/defn_oneliner_rescue.txt | 158 - .../snapshots/seattlerb/defn_opt_last_arg.txt | 33 - .../snapshots/seattlerb/defn_opt_reg.txt | 36 - .../seattlerb/defn_opt_splat_arg.txt | 43 - .../prism/snapshots/seattlerb/defn_powarg.txt | 31 - .../snapshots/seattlerb/defn_reg_opt_reg.txt | 44 - .../snapshots/seattlerb/defn_splat_arg.txt | 34 - .../snapshots/seattlerb/defn_unary_not.txt | 21 - .../snapshots/seattlerb/defns_reserved.txt | 19 - .../defs_as_arg_with_do_block_inside.txt | 60 - .../snapshots/seattlerb/defs_comments.txt | 19 - .../seattlerb/defs_endless_command.txt | 46 - .../seattlerb/defs_endless_command_rescue.txt | 53 - .../prism/snapshots/seattlerb/defs_kwarg.txt | 35 - .../snapshots/seattlerb/defs_oneliner.txt | 48 - .../snapshots/seattlerb/defs_oneliner_eq2.txt | 48 - .../seattlerb/defs_oneliner_rescue.txt | 161 - .../prism/snapshots/seattlerb/difficult0_.txt | 72 - .../seattlerb/difficult1_line_numbers.txt | 267 - .../seattlerb/difficult1_line_numbers2.txt | 78 - .../prism/snapshots/seattlerb/difficult2_.txt | 74 - .../prism/snapshots/seattlerb/difficult3_.txt | 52 - .../snapshots/seattlerb/difficult3_2.txt | 42 - .../snapshots/seattlerb/difficult3_3.txt | 47 - .../snapshots/seattlerb/difficult3_4.txt | 38 - .../snapshots/seattlerb/difficult3_5.txt | 48 - .../snapshots/seattlerb/difficult3__10.txt | 52 - .../snapshots/seattlerb/difficult3__11.txt | 46 - .../snapshots/seattlerb/difficult3__12.txt | 49 - .../snapshots/seattlerb/difficult3__6.txt | 55 - .../snapshots/seattlerb/difficult3__7.txt | 49 - .../snapshots/seattlerb/difficult3__8.txt | 52 - .../snapshots/seattlerb/difficult3__9.txt | 49 - .../seattlerb/difficult4__leading_dots.txt | 25 - .../seattlerb/difficult4__leading_dots2.txt | 16 - .../prism/snapshots/seattlerb/difficult6_.txt | 61 - .../snapshots/seattlerb/difficult6__7.txt | 55 - .../snapshots/seattlerb/difficult6__8.txt | 55 - .../prism/snapshots/seattlerb/difficult7_.txt | 93 - test/mri/prism/snapshots/seattlerb/do_bug.txt | 63 - .../prism/snapshots/seattlerb/do_lambda.txt | 17 - .../snapshots/seattlerb/dot2_nil__26.txt | 20 - .../snapshots/seattlerb/dot3_nil__26.txt | 20 - .../prism/snapshots/seattlerb/dstr_evstr.txt | 37 - .../seattlerb/dstr_evstr_empty_end.txt | 25 - .../snapshots/seattlerb/dstr_lex_state.txt | 34 - .../prism/snapshots/seattlerb/dstr_str.txt | 27 - .../snapshots/seattlerb/dsym_esc_to_sym.txt | 11 - .../prism/snapshots/seattlerb/dsym_to_sym.txt | 37 - .../seattlerb/eq_begin_line_numbers.txt | 11 - ...gin_why_wont_people_use_their_spacebar.txt | 50 - .../prism/snapshots/seattlerb/evstr_evstr.txt | 41 - .../prism/snapshots/seattlerb/evstr_str.txt | 31 - .../snapshots/seattlerb/expr_not_bang.txt | 38 - test/mri/prism/snapshots/seattlerb/f_kw.txt | 34 - .../snapshots/seattlerb/f_kw__required.txt | 30 - .../snapshots/seattlerb/flip2_env_lvar.txt | 37 - .../seattlerb/float_with_if_modifier.txt | 17 - .../heredoc__backslash_dos_format.txt | 17 - .../seattlerb/heredoc_backslash_nl.txt | 17 - .../seattlerb/heredoc_bad_hex_escape.txt | 17 - .../seattlerb/heredoc_bad_oct_escape.txt | 17 - .../snapshots/seattlerb/heredoc_comma_arg.txt | 27 - .../snapshots/seattlerb/heredoc_lineno.txt | 26 - .../snapshots/seattlerb/heredoc_nested.txt | 41 - .../snapshots/seattlerb/heredoc_squiggly.txt | 33 - ...squiggly_blank_line_plus_interpolation.txt | 66 - .../heredoc_squiggly_blank_lines.txt | 33 - .../seattlerb/heredoc_squiggly_empty.txt | 11 - .../seattlerb/heredoc_squiggly_interp.txt | 48 - .../seattlerb/heredoc_squiggly_no_indent.txt | 11 - .../seattlerb/heredoc_squiggly_tabs.txt | 27 - .../seattlerb/heredoc_squiggly_tabs_extra.txt | 27 - .../heredoc_squiggly_visually_blank_lines.txt | 33 - .../heredoc_trailing_slash_continued_call.txt | 21 - .../snapshots/seattlerb/heredoc_unicode.txt | 11 - .../heredoc_with_carriage_return_escapes.txt | 11 - ...c_with_carriage_return_escapes_windows.txt | 11 - ...redoc_with_extra_carriage_horrible_mix.txt | 11 - .../heredoc_with_extra_carriage_returns.txt | 11 - ...oc_with_extra_carriage_returns_windows.txt | 11 - ...erpolation_and_carriage_return_escapes.txt | 26 - ...on_and_carriage_return_escapes_windows.txt | 26 - .../heredoc_with_not_global_interpolation.txt | 11 - .../heredoc_with_only_carriage_returns.txt | 11 - ...doc_with_only_carriage_returns_windows.txt | 11 - .../prism/snapshots/seattlerb/if_elsif.txt | 25 - .../prism/snapshots/seattlerb/if_symbol.txt | 31 - .../snapshots/seattlerb/in_expr_no_case.txt | 17 - .../mri/prism/snapshots/seattlerb/index_0.txt | 38 - .../snapshots/seattlerb/index_0_opasgn.txt | 36 - .../seattlerb/integer_with_if_modifier.txt | 18 - .../interpolated_symbol_array_line_breaks.txt | 25 - .../interpolated_word_array_line_breaks.txt | 25 - .../prism/snapshots/seattlerb/iter_args_1.txt | 40 - .../snapshots/seattlerb/iter_args_10_1.txt | 51 - .../snapshots/seattlerb/iter_args_10_2.txt | 56 - .../snapshots/seattlerb/iter_args_11_1.txt | 54 - .../snapshots/seattlerb/iter_args_11_2.txt | 59 - .../snapshots/seattlerb/iter_args_2__19.txt | 46 - .../prism/snapshots/seattlerb/iter_args_3.txt | 52 - .../prism/snapshots/seattlerb/iter_args_4.txt | 45 - .../prism/snapshots/seattlerb/iter_args_5.txt | 42 - .../prism/snapshots/seattlerb/iter_args_6.txt | 49 - .../snapshots/seattlerb/iter_args_7_1.txt | 48 - .../snapshots/seattlerb/iter_args_7_2.txt | 53 - .../snapshots/seattlerb/iter_args_8_1.txt | 51 - .../snapshots/seattlerb/iter_args_8_2.txt | 56 - .../snapshots/seattlerb/iter_args_9_1.txt | 46 - .../snapshots/seattlerb/iter_args_9_2.txt | 51 - .../prism/snapshots/seattlerb/iter_kwarg.txt | 42 - .../seattlerb/iter_kwarg_kwsplat.txt | 47 - .../snapshots/seattlerb/label_vs_string.txt | 34 - .../seattlerb/lambda_do_vs_brace.txt | 95 - .../seattlerb/lasgn_arg_rescue_arg.txt | 21 - .../lasgn_call_bracket_rescue_arg.txt | 34 - .../lasgn_call_nobracket_rescue_arg.txt | 34 - .../snapshots/seattlerb/lasgn_command.txt | 37 - .../prism/snapshots/seattlerb/lasgn_env.txt | 14 - .../snapshots/seattlerb/lasgn_ivar_env.txt | 13 - .../seattlerb/lasgn_lasgn_command_call.txt | 33 - .../seattlerb/lasgn_middle_splat.txt | 49 - .../seattlerb/magic_encoding_comment.txt | 46 - .../seattlerb/masgn_anon_splat_arg.txt | 29 - .../seattlerb/masgn_arg_colon_arg.txt | 42 - .../snapshots/seattlerb/masgn_arg_ident.txt | 42 - .../seattlerb/masgn_arg_splat_arg.txt | 35 - .../snapshots/seattlerb/masgn_colon2.txt | 43 - .../snapshots/seattlerb/masgn_colon3.txt | 36 - .../seattlerb/masgn_command_call.txt | 43 - .../seattlerb/masgn_double_paren.txt | 35 - .../snapshots/seattlerb/masgn_lhs_splat.txt | 33 - .../prism/snapshots/seattlerb/masgn_paren.txt | 39 - .../snapshots/seattlerb/masgn_splat_arg.txt | 32 - .../seattlerb/masgn_splat_arg_arg.txt | 35 - .../prism/snapshots/seattlerb/masgn_star.txt | 19 - .../seattlerb/masgn_var_star_var.txt | 32 - .../seattlerb/messy_op_asgn_lineno.txt | 60 - .../method_call_assoc_trailing_comma.txt | 41 - .../seattlerb/method_call_trailing_comma.txt | 31 - .../seattlerb/mlhs_back_anonsplat.txt | 35 - .../snapshots/seattlerb/mlhs_back_splat.txt | 38 - .../seattlerb/mlhs_front_anonsplat.txt | 35 - .../snapshots/seattlerb/mlhs_front_splat.txt | 38 - .../snapshots/seattlerb/mlhs_keyword.txt | 30 - .../seattlerb/mlhs_mid_anonsplat.txt | 44 - .../snapshots/seattlerb/mlhs_mid_splat.txt | 47 - .../prism/snapshots/seattlerb/mlhs_rescue.txt | 36 - .../snapshots/seattlerb/module_comments.txt | 29 - .../seattlerb/multiline_hash_declaration.txt | 95 - ..._interpolated_symbol_array_line_breaks.txt | 25 - ...on_interpolated_word_array_line_breaks.txt | 25 - .../seattlerb/op_asgn_command_call.txt | 37 - .../op_asgn_dot_ident_command_call.txt | 32 - .../seattlerb/op_asgn_index_command_call.txt | 53 - ..._asgn_primary_colon_const_command_call.txt | 41 - .../op_asgn_primary_colon_identifier1.txt | 20 - ..._primary_colon_identifier_command_call.txt | 40 - .../op_asgn_val_dot_ident_command_call.txt | 40 - .../seattlerb/parse_def_special_name.txt | 18 - .../seattlerb/parse_if_not_canonical.txt | 62 - .../seattlerb/parse_if_not_noncanonical.txt | 62 - .../snapshots/seattlerb/parse_line_block.txt | 30 - .../parse_line_block_inline_comment.txt | 35 - ..._block_inline_comment_leading_newlines.txt | 35 - ...se_line_block_inline_multiline_comment.txt | 35 - ...ine_call_ivar_arg_no_parens_line_break.txt | 20 - .../parse_line_call_ivar_line_break_paren.txt | 20 - .../seattlerb/parse_line_call_no_args.txt | 61 - .../seattlerb/parse_line_defn_complex.txt | 66 - .../seattlerb/parse_line_defn_no_parens.txt | 31 - .../parse_line_defn_no_parens_args.txt | 29 - .../snapshots/seattlerb/parse_line_dot2.txt | 51 - .../seattlerb/parse_line_dot2_open.txt | 38 - .../snapshots/seattlerb/parse_line_dot3.txt | 51 - .../seattlerb/parse_line_dot3_open.txt | 38 - .../parse_line_dstr_escaped_newline.txt | 20 - .../parse_line_dstr_soft_newline.txt | 20 - .../parse_line_evstr_after_break.txt | 35 - .../seattlerb/parse_line_hash_lit.txt | 22 - .../seattlerb/parse_line_heredoc.txt | 43 - .../seattlerb/parse_line_heredoc_evstr.txt | 37 - .../parse_line_heredoc_hardnewline.txt | 22 - .../parse_line_heredoc_regexp_chars.txt | 33 - .../parse_line_iter_call_no_parens.txt | 74 - .../seattlerb/parse_line_iter_call_parens.txt | 74 - .../seattlerb/parse_line_multiline_str.txt | 14 - .../parse_line_multiline_str_literal_n.txt | 14 - .../seattlerb/parse_line_newlines.txt | 6 - .../seattlerb/parse_line_op_asgn.txt | 32 - .../seattlerb/parse_line_postexe.txt | 22 - .../snapshots/seattlerb/parse_line_preexe.txt | 22 - .../snapshots/seattlerb/parse_line_rescue.txt | 62 - .../snapshots/seattlerb/parse_line_return.txt | 39 - .../parse_line_str_with_newline_escape.txt | 25 - .../snapshots/seattlerb/parse_line_to_ary.txt | 39 - .../parse_line_trailing_newlines.txt | 25 - .../parse_opt_call_args_assocs_comma.txt | 34 - .../parse_opt_call_args_lit_comma.txt | 24 - .../snapshots/seattlerb/parse_pattern_019.txt | 33 - .../snapshots/seattlerb/parse_pattern_044.txt | 38 - .../snapshots/seattlerb/parse_pattern_051.txt | 47 - .../snapshots/seattlerb/parse_pattern_058.txt | 73 - .../seattlerb/parse_pattern_058_2.txt | 67 - .../snapshots/seattlerb/parse_pattern_069.txt | 48 - .../snapshots/seattlerb/parse_pattern_076.txt | 58 - .../seattlerb/parse_until_not_canonical.txt | 49 - .../parse_until_not_noncanonical.txt | 49 - .../seattlerb/parse_while_not_canonical.txt | 49 - .../parse_while_not_noncanonical.txt | 49 - .../prism/snapshots/seattlerb/pctW_lineno.txt | 52 - .../seattlerb/pct_Q_backslash_nl.txt | 11 - test/mri/prism/snapshots/seattlerb/pct_nl.txt | 17 - .../seattlerb/pct_w_heredoc_interp_nested.txt | 50 - .../snapshots/seattlerb/pipe_semicolon.txt | 39 - .../prism/snapshots/seattlerb/pipe_space.txt | 36 - .../snapshots/seattlerb/qWords_space.txt | 10 - .../prism/snapshots/seattlerb/qsymbols.txt | 28 - .../snapshots/seattlerb/qsymbols_empty.txt | 10 - .../seattlerb/qsymbols_empty_space.txt | 10 - .../snapshots/seattlerb/qsymbols_interp.txt | 57 - .../seattlerb/quoted_symbol_hash_arg.txt | 35 - .../seattlerb/quoted_symbol_keys.txt | 25 - .../prism/snapshots/seattlerb/qw_escape.txt | 11 - .../snapshots/seattlerb/qw_escape_term.txt | 11 - .../snapshots/seattlerb/qwords_empty.txt | 10 - .../seattlerb/read_escape_unicode_curlies.txt | 11 - .../seattlerb/read_escape_unicode_h4.txt | 11 - test/mri/prism/snapshots/seattlerb/regexp.txt | 35 - .../seattlerb/regexp_esc_C_slash.txt | 11 - .../snapshots/seattlerb/regexp_esc_u.txt | 11 - .../seattlerb/regexp_escape_extended.txt | 11 - .../seattlerb/regexp_unicode_curlies.txt | 17 - .../seattlerb/required_kwarg_no_value.txt | 34 - .../seattlerb/rescue_do_end_ensure_result.txt | 58 - .../seattlerb/rescue_do_end_no_raise.txt | 75 - .../seattlerb/rescue_do_end_raised.txt | 52 - .../seattlerb/rescue_do_end_rescued.txt | 79 - .../snapshots/seattlerb/rescue_in_block.txt | 47 - .../snapshots/seattlerb/rescue_parens.txt | 48 - .../seattlerb/return_call_assocs.txt | 212 - .../prism/snapshots/seattlerb/rhs_asgn.txt | 15 - .../snapshots/seattlerb/ruby21_numbers.txt | 27 - .../snapshots/seattlerb/safe_attrasgn.txt | 31 - .../seattlerb/safe_attrasgn_constant.txt | 31 - .../prism/snapshots/seattlerb/safe_call.txt | 25 - .../seattlerb/safe_call_after_newline.txt | 25 - .../seattlerb/safe_call_dot_parens.txt | 25 - .../snapshots/seattlerb/safe_call_newline.txt | 25 - .../seattlerb/safe_call_operator.txt | 31 - .../seattlerb/safe_call_rhs_newline.txt | 31 - .../prism/snapshots/seattlerb/safe_calls.txt | 41 - .../snapshots/seattlerb/safe_op_asgn.txt | 41 - .../snapshots/seattlerb/safe_op_asgn2.txt | 34 - .../slashy_newlines_within_string.txt | 57 - .../seattlerb/stabby_arg_no_paren.txt | 28 - .../stabby_arg_opt_splat_arg_block_omfg.txt | 50 - .../seattlerb/stabby_block_iter_call.txt | 58 - ...bby_block_iter_call_no_target_with_arg.txt | 54 - .../snapshots/seattlerb/stabby_block_kw.txt | 33 - .../seattlerb/stabby_block_kw__required.txt | 29 - .../snapshots/seattlerb/stabby_proc_scope.txt | 31 - .../snapshots/seattlerb/str_backslashes.txt | 24 - .../str_double_double_escaped_newline.txt | 34 - .../seattlerb/str_double_escaped_newline.txt | 34 - .../seattlerb/str_double_newline.txt | 34 - .../prism/snapshots/seattlerb/str_evstr.txt | 31 - .../snapshots/seattlerb/str_evstr_escape.txt | 37 - .../seattlerb/str_heredoc_interp.txt | 31 - .../seattlerb/str_interp_ternary_or_label.txt | 104 - .../str_lit_concat_bad_encodings.txt | 21 - .../str_newline_hash_line_number.txt | 14 - .../snapshots/seattlerb/str_pct_Q_nested.txt | 37 - .../seattlerb/str_pct_nested_nested.txt | 40 - .../prism/snapshots/seattlerb/str_pct_q.txt | 11 - .../str_single_double_escaped_newline.txt | 34 - .../seattlerb/str_single_escaped_newline.txt | 34 - .../seattlerb/str_single_newline.txt | 34 - .../mri/prism/snapshots/seattlerb/str_str.txt | 27 - .../prism/snapshots/seattlerb/str_str_str.txt | 33 - .../prism/snapshots/seattlerb/super_arg.txt | 17 - .../snapshots/seattlerb/symbol_empty.txt | 11 - .../prism/snapshots/seattlerb/symbol_list.txt | 50 - .../mri/prism/snapshots/seattlerb/symbols.txt | 28 - .../snapshots/seattlerb/symbols_empty.txt | 10 - .../seattlerb/symbols_empty_space.txt | 10 - .../snapshots/seattlerb/symbols_interp.txt | 28 - test/mri/prism/snapshots/seattlerb/thingy.txt | 57 - .../snapshots/seattlerb/uminus_float.txt | 7 - .../prism/snapshots/seattlerb/unary_minus.txt | 25 - .../prism/snapshots/seattlerb/unary_plus.txt | 25 - .../seattlerb/unary_plus_on_literal.txt | 21 - .../prism/snapshots/seattlerb/unary_tilde.txt | 25 - .../prism/snapshots/seattlerb/utf8_bom.txt | 21 - .../prism/snapshots/seattlerb/when_splat.txt | 39 - .../snapshots/seattlerb/words_interp.txt | 29 - .../prism/snapshots/seattlerb/yield_arg.txt | 16 - .../snapshots/seattlerb/yield_call_assocs.txt | 224 - .../seattlerb/yield_empty_parens.txt | 10 - .../single_method_call_with_bang.txt | 15 - .../prism/snapshots/single_quote_heredocs.txt | 11 - test/mri/prism/snapshots/spanning_heredoc.txt | 409 -- .../snapshots/spanning_heredoc_newlines.txt | 155 - test/mri/prism/snapshots/strings.txt | 527 -- test/mri/prism/snapshots/super.txt | 132 - test/mri/prism/snapshots/symbols.txt | 464 -- test/mri/prism/snapshots/ternary_operator.txt | 295 - test/mri/prism/snapshots/tilde_heredocs.txt | 388 -- test/mri/prism/snapshots/undef.txt | 117 - test/mri/prism/snapshots/unescaping.txt | 34 - test/mri/prism/snapshots/unless.txt | 136 - .../unparser/corpus/literal/alias.txt | 29 - .../unparser/corpus/literal/assignment.txt | 1075 ---- .../unparser/corpus/literal/block.txt | 1402 ----- .../unparser/corpus/literal/case.txt | 446 -- .../unparser/corpus/literal/class.txt | 233 - .../unparser/corpus/literal/control.txt | 150 - .../snapshots/unparser/corpus/literal/def.txt | 1203 ---- .../unparser/corpus/literal/defined.txt | 55 - .../unparser/corpus/literal/defs.txt | 360 -- .../unparser/corpus/literal/dstr.txt | 341 -- .../unparser/corpus/literal/empty.txt | 5 - .../unparser/corpus/literal/empty_begin.txt | 9 - .../unparser/corpus/literal/flipflop.txt | 193 - .../snapshots/unparser/corpus/literal/for.txt | 171 - .../unparser/corpus/literal/hookexe.txt | 49 - .../snapshots/unparser/corpus/literal/if.txt | 288 - .../unparser/corpus/literal/kwbegin.txt | 491 -- .../unparser/corpus/literal/lambda.txt | 151 - .../unparser/corpus/literal/literal.txt | 1186 ---- .../unparser/corpus/literal/module.txt | 107 - .../unparser/corpus/literal/opasgn.txt | 509 -- .../unparser/corpus/literal/pattern.txt | 446 -- .../unparser/corpus/literal/pragma.txt | 20 - .../unparser/corpus/literal/range.txt | 55 - .../unparser/corpus/literal/rescue.txt | 101 - .../unparser/corpus/literal/send.txt | 2190 -------- .../unparser/corpus/literal/since/27.txt | 49 - .../unparser/corpus/literal/since/30.txt | 88 - .../unparser/corpus/literal/since/31.txt | 90 - .../unparser/corpus/literal/since/32.txt | 108 - .../unparser/corpus/literal/singletons.txt | 9 - .../unparser/corpus/literal/super.txt | 277 - .../unparser/corpus/literal/unary.txt | 248 - .../unparser/corpus/literal/undef.txt | 29 - .../unparser/corpus/literal/variables.txt | 53 - .../unparser/corpus/literal/while.txt | 704 --- .../unparser/corpus/literal/yield.txt | 56 - .../unparser/corpus/semantic/and.txt | 235 - .../unparser/corpus/semantic/block.txt | 191 - .../unparser/corpus/semantic/def.txt | 90 - .../unparser/corpus/semantic/dstr.txt | 570 -- .../unparser/corpus/semantic/kwbegin.txt | 259 - .../unparser/corpus/semantic/literal.txt | 103 - .../unparser/corpus/semantic/send.txt | 163 - .../unparser/corpus/semantic/undef.txt | 29 - .../unparser/corpus/semantic/while.txt | 277 - test/mri/prism/snapshots/until.txt | 143 - test/mri/prism/snapshots/variables.txt | 408 -- test/mri/prism/snapshots/while.txt | 361 -- .../snapshots/whitequark/__ENCODING__.txt | 6 - .../whitequark/__ENCODING___legacy_.txt | 6 - test/mri/prism/snapshots/whitequark/alias.txt | 21 - .../prism/snapshots/whitequark/alias_gvar.txt | 21 - ...iuous_quoted_label_in_ternary_operator.txt | 60 - test/mri/prism/snapshots/whitequark/and.txt | 53 - .../prism/snapshots/whitequark/and_asgn.txt | 59 - .../snapshots/whitequark/and_or_masgn.txt | 93 - .../whitequark/anonymous_blockarg.txt | 46 - test/mri/prism/snapshots/whitequark/arg.txt | 56 - .../whitequark/arg_duplicate_ignored.txt | 59 - .../prism/snapshots/whitequark/arg_label.txt | 115 - .../prism/snapshots/whitequark/arg_scope.txt | 34 - test/mri/prism/snapshots/whitequark/args.txt | 1075 ---- .../snapshots/whitequark/args_args_assocs.txt | 96 - .../whitequark/args_args_assocs_comma.txt | 54 - .../snapshots/whitequark/args_args_comma.txt | 38 - .../snapshots/whitequark/args_args_star.txt | 90 - .../snapshots/whitequark/args_assocs.txt | 195 - .../whitequark/args_assocs_comma.txt | 44 - .../whitequark/args_assocs_legacy.txt | 195 - .../snapshots/whitequark/args_block_pass.txt | 28 - .../prism/snapshots/whitequark/args_cmd.txt | 41 - .../prism/snapshots/whitequark/args_star.txt | 70 - .../snapshots/whitequark/array_assocs.txt | 44 - .../snapshots/whitequark/array_plain.txt | 16 - .../snapshots/whitequark/array_splat.txt | 68 - .../snapshots/whitequark/array_symbols.txt | 22 - .../whitequark/array_symbols_empty.txt | 15 - .../whitequark/array_symbols_interp.txt | 67 - .../snapshots/whitequark/array_words.txt | 22 - .../whitequark/array_words_empty.txt | 15 - .../whitequark/array_words_interp.txt | 78 - .../prism/snapshots/whitequark/asgn_cmd.txt | 55 - .../prism/snapshots/whitequark/asgn_mrhs.txt | 87 - .../prism/snapshots/whitequark/back_ref.txt | 7 - test/mri/prism/snapshots/whitequark/bang.txt | 25 - .../prism/snapshots/whitequark/bang_cmd.txt | 38 - .../snapshots/whitequark/begin_cmdarg.txt | 51 - .../beginless_erange_after_newline.txt | 23 - .../beginless_irange_after_newline.txt | 23 - .../snapshots/whitequark/beginless_range.txt | 21 - .../prism/snapshots/whitequark/blockarg.txt | 31 - .../prism/snapshots/whitequark/blockargs.txt | 1339 ----- test/mri/prism/snapshots/whitequark/break.txt | 56 - .../snapshots/whitequark/break_block.txt | 40 - .../prism/snapshots/whitequark/bug_435.txt | 38 - .../prism/snapshots/whitequark/bug_447.txt | 56 - .../prism/snapshots/whitequark/bug_452.txt | 63 - .../prism/snapshots/whitequark/bug_466.txt | 69 - .../prism/snapshots/whitequark/bug_473.txt | 33 - .../prism/snapshots/whitequark/bug_480.txt | 36 - .../prism/snapshots/whitequark/bug_481.txt | 50 - .../whitequark/bug_ascii_8bit_in_literal.txt | 11 - .../whitequark/bug_cmd_string_lookahead.txt | 30 - .../prism/snapshots/whitequark/bug_cmdarg.txt | 106 - .../whitequark/bug_def_no_paren_eql_begin.txt | 18 - .../whitequark/bug_do_block_in_call_args.txt | 50 - .../whitequark/bug_do_block_in_cmdarg.txt | 40 - .../whitequark/bug_do_block_in_hash_brace.txt | 383 -- .../snapshots/whitequark/bug_heredoc_do.txt | 30 - .../whitequark/bug_interp_single.txt | 36 - .../whitequark/bug_lambda_leakage.txt | 38 - .../whitequark/bug_regex_verification.txt | 11 - .../whitequark/bug_rescue_empty_else.txt | 25 - .../whitequark/bug_while_not_parens_do.txt | 28 - .../prism/snapshots/whitequark/case_cond.txt | 34 - .../snapshots/whitequark/case_cond_else.txt | 46 - .../prism/snapshots/whitequark/case_expr.txt | 44 - .../snapshots/whitequark/case_expr_else.txt | 60 - .../snapshots/whitequark/casgn_scoped.txt | 20 - .../snapshots/whitequark/casgn_toplevel.txt | 18 - .../snapshots/whitequark/casgn_unscoped.txt | 13 - .../prism/snapshots/whitequark/character.txt | 11 - test/mri/prism/snapshots/whitequark/class.txt | 27 - .../class_definition_in_while_cond.txt | 171 - .../snapshots/whitequark/class_super.txt | 18 - .../whitequark/class_super_label.txt | 35 - .../comments_before_leading_dot__27.txt | 85 - .../prism/snapshots/whitequark/complex.txt | 27 - .../prism/snapshots/whitequark/cond_begin.txt | 40 - .../snapshots/whitequark/cond_begin_masgn.txt | 52 - .../snapshots/whitequark/cond_eflipflop.txt | 78 - .../snapshots/whitequark/cond_iflipflop.txt | 78 - .../whitequark/cond_match_current_line.txt | 34 - .../snapshots/whitequark/const_op_asgn.txt | 101 - .../snapshots/whitequark/const_scoped.txt | 13 - .../snapshots/whitequark/const_toplevel.txt | 11 - .../snapshots/whitequark/const_unscoped.txt | 7 - test/mri/prism/snapshots/whitequark/cpath.txt | 33 - test/mri/prism/snapshots/whitequark/cvar.txt | 7 - .../mri/prism/snapshots/whitequark/cvasgn.txt | 13 - .../whitequark/dedenting_heredoc.txt | 485 -- ...olating_heredoc_fake_line_continuation.txt | 21 - ...nterpolating_heredoc_line_continuation.txt | 21 - test/mri/prism/snapshots/whitequark/def.txt | 83 - .../prism/snapshots/whitequark/defined.txt | 42 - test/mri/prism/snapshots/whitequark/defs.txt | 90 - .../prism/snapshots/whitequark/empty_stmt.txt | 5 - .../whitequark/endless_comparison_method.txt | 221 - .../snapshots/whitequark/endless_method.txt | 151 - .../endless_method_command_syntax.txt | 392 -- .../endless_method_forwarded_args_legacy.txt | 43 - .../endless_method_with_rescue_mod.txt | 56 - .../endless_method_without_args.txt | 89 - .../mri/prism/snapshots/whitequark/ensure.txt | 40 - .../snapshots/whitequark/ensure_empty.txt | 16 - test/mri/prism/snapshots/whitequark/false.txt | 6 - test/mri/prism/snapshots/whitequark/float.txt | 9 - test/mri/prism/snapshots/whitequark/for.txt | 83 - .../prism/snapshots/whitequark/for_mlhs.txt | 56 - .../snapshots/whitequark/forward_arg.txt | 43 - .../whitequark/forward_arg_with_open_args.txt | 404 -- .../whitequark/forward_args_legacy.txt | 99 - .../forwarded_argument_with_kwrestarg.txt | 58 - .../forwarded_argument_with_restarg.txt | 55 - .../whitequark/forwarded_kwrestarg.txt | 52 - ...warded_kwrestarg_with_additional_kwarg.txt | 63 - .../whitequark/forwarded_restarg.txt | 49 - test/mri/prism/snapshots/whitequark/gvar.txt | 7 - .../mri/prism/snapshots/whitequark/gvasgn.txt | 13 - .../prism/snapshots/whitequark/hash_empty.txt | 9 - .../snapshots/whitequark/hash_hashrocket.txt | 49 - .../snapshots/whitequark/hash_kwsplat.txt | 35 - .../prism/snapshots/whitequark/hash_label.txt | 22 - .../snapshots/whitequark/hash_label_end.txt | 100 - .../whitequark/hash_pair_value_omission.txt | 97 - .../prism/snapshots/whitequark/heredoc.txt | 23 - test/mri/prism/snapshots/whitequark/if.txt | 63 - .../prism/snapshots/whitequark/if_else.txt | 95 - .../prism/snapshots/whitequark/if_elsif.txt | 65 - .../snapshots/whitequark/if_masgn__24.txt | 42 - .../mri/prism/snapshots/whitequark/if_mod.txt | 34 - .../prism/snapshots/whitequark/if_nl_then.txt | 34 - .../if_while_after_class__since_32.txt | 119 - test/mri/prism/snapshots/whitequark/int.txt | 14 - .../snapshots/whitequark/int___LINE__.txt | 6 - .../snapshots/whitequark/interp_digit_var.txt | 273 - test/mri/prism/snapshots/whitequark/ivar.txt | 7 - .../mri/prism/snapshots/whitequark/ivasgn.txt | 13 - .../whitequark/keyword_argument_omission.txt | 65 - test/mri/prism/snapshots/whitequark/kwarg.txt | 30 - .../snapshots/whitequark/kwbegin_compstmt.txt | 34 - .../prism/snapshots/whitequark/kwnilarg.txt | 84 - .../prism/snapshots/whitequark/kwoptarg.txt | 34 - ...targ_with_kwrestarg_and_forwarded_args.txt | 58 - .../snapshots/whitequark/kwrestarg_named.txt | 31 - .../whitequark/kwrestarg_unnamed.txt | 31 - .../lbrace_arg_after_command_args.txt | 54 - .../lparenarg_after_lvar__since_25.txt | 67 - test/mri/prism/snapshots/whitequark/lvar.txt | 15 - .../whitequark/lvar_injecting_match.txt | 39 - .../mri/prism/snapshots/whitequark/lvasgn.txt | 17 - test/mri/prism/snapshots/whitequark/masgn.txt | 83 - .../prism/snapshots/whitequark/masgn_attr.txt | 82 - .../prism/snapshots/whitequark/masgn_cmd.txt | 35 - .../snapshots/whitequark/masgn_const.txt | 46 - .../snapshots/whitequark/masgn_nested.txt | 66 - .../snapshots/whitequark/masgn_splat.txt | 284 - .../method_definition_in_while_cond.txt | 199 - .../mri/prism/snapshots/whitequark/module.txt | 14 - .../whitequark/multiple_pattern_matches.txt | 173 - .../whitequark/newline_in_hash_argument.txt | 163 - test/mri/prism/snapshots/whitequark/next.txt | 56 - .../prism/snapshots/whitequark/next_block.txt | 40 - test/mri/prism/snapshots/whitequark/nil.txt | 6 - .../snapshots/whitequark/nil_expression.txt | 16 - .../whitequark/non_lvar_injecting_match.txt | 44 - test/mri/prism/snapshots/whitequark/not.txt | 55 - .../prism/snapshots/whitequark/not_cmd.txt | 38 - .../snapshots/whitequark/not_masgn__24.txt | 45 - .../prism/snapshots/whitequark/nth_ref.txt | 7 - .../whitequark/numbered_args_after_27.txt | 143 - .../whitequark/numparam_outside_block.txt | 114 - .../prism/snapshots/whitequark/op_asgn.txt | 74 - .../snapshots/whitequark/op_asgn_cmd.txt | 178 - .../snapshots/whitequark/op_asgn_index.txt | 38 - .../whitequark/op_asgn_index_cmd.txt | 58 - .../mri/prism/snapshots/whitequark/optarg.txt | 74 - test/mri/prism/snapshots/whitequark/or.txt | 53 - .../prism/snapshots/whitequark/or_asgn.txt | 59 - .../snapshots/whitequark/parser_bug_272.txt | 42 - .../snapshots/whitequark/parser_bug_490.txt | 106 - .../snapshots/whitequark/parser_bug_507.txt | 36 - .../snapshots/whitequark/parser_bug_518.txt | 18 - .../snapshots/whitequark/parser_bug_525.txt | 65 - .../snapshots/whitequark/parser_bug_604.txt | 57 - .../snapshots/whitequark/parser_bug_640.txt | 21 - .../snapshots/whitequark/parser_bug_645.txt | 35 - .../snapshots/whitequark/parser_bug_830.txt | 11 - ...ps_truncated_parts_of_squiggly_heredoc.txt | 19 - ...ser_slash_slash_n_escaping_in_literals.txt | 139 - .../pattern_matching__FILE__LINE_literals.txt | 54 - .../pattern_matching_blank_else.txt | 31 - .../whitequark/pattern_matching_else.txt | 36 - .../pattern_matching_single_line.txt | 45 - ...e_line_allowed_omission_of_parentheses.txt | 249 - .../prism/snapshots/whitequark/postexe.txt | 15 - .../mri/prism/snapshots/whitequark/preexe.txt | 15 - .../prism/snapshots/whitequark/procarg0.txt | 78 - .../snapshots/whitequark/range_exclusive.txt | 16 - .../snapshots/whitequark/range_inclusive.txt | 16 - .../prism/snapshots/whitequark/rational.txt | 14 - test/mri/prism/snapshots/whitequark/redo.txt | 6 - .../snapshots/whitequark/regex_interp.txt | 38 - .../snapshots/whitequark/regex_plain.txt | 11 - .../snapshots/whitequark/resbody_list.txt | 45 - .../whitequark/resbody_list_mrhs.txt | 55 - .../snapshots/whitequark/resbody_list_var.txt | 56 - .../snapshots/whitequark/resbody_var.txt | 86 - .../mri/prism/snapshots/whitequark/rescue.txt | 43 - .../snapshots/whitequark/rescue_else.txt | 59 - .../whitequark/rescue_else_ensure.txt | 75 - .../snapshots/whitequark/rescue_ensure.txt | 59 - .../whitequark/rescue_in_lambda_block.txt | 26 - .../prism/snapshots/whitequark/rescue_mod.txt | 29 - .../snapshots/whitequark/rescue_mod_asgn.txt | 35 - .../snapshots/whitequark/rescue_mod_masgn.txt | 44 - .../whitequark/rescue_mod_op_assign.txt | 36 - .../whitequark/rescue_without_begin_end.txt | 59 - .../snapshots/whitequark/restarg_named.txt | 31 - .../snapshots/whitequark/restarg_unnamed.txt | 31 - test/mri/prism/snapshots/whitequark/retry.txt | 6 - .../mri/prism/snapshots/whitequark/return.txt | 56 - .../snapshots/whitequark/return_block.txt | 40 - .../snapshots/whitequark/ruby_bug_10279.txt | 32 - .../snapshots/whitequark/ruby_bug_10653.txt | 173 - .../snapshots/whitequark/ruby_bug_11107.txt | 48 - .../snapshots/whitequark/ruby_bug_11380.txt | 55 - .../snapshots/whitequark/ruby_bug_11873.txt | 767 --- .../snapshots/whitequark/ruby_bug_11873_a.txt | 1231 ----- .../snapshots/whitequark/ruby_bug_11873_b.txt | 98 - .../snapshots/whitequark/ruby_bug_11989.txt | 24 - .../snapshots/whitequark/ruby_bug_11990.txt | 34 - .../snapshots/whitequark/ruby_bug_12073.txt | 96 - .../snapshots/whitequark/ruby_bug_12402.txt | 567 -- .../snapshots/whitequark/ruby_bug_12669.txt | 133 - .../snapshots/whitequark/ruby_bug_12686.txt | 39 - .../snapshots/whitequark/ruby_bug_13547.txt | 31 - .../snapshots/whitequark/ruby_bug_14690.txt | 59 - .../snapshots/whitequark/ruby_bug_15789.txt | 120 - .../snapshots/whitequark/ruby_bug_9669.txt | 58 - .../mri/prism/snapshots/whitequark/sclass.txt | 25 - test/mri/prism/snapshots/whitequark/self.txt | 6 - .../snapshots/whitequark/send_attr_asgn.txt | 106 - .../whitequark/send_attr_asgn_conditional.txt | 31 - .../snapshots/whitequark/send_binary_op.txt | 551 -- .../whitequark/send_block_chain_cmd.txt | 325 -- .../whitequark/send_block_conditional.txt | 31 - .../prism/snapshots/whitequark/send_call.txt | 57 - .../snapshots/whitequark/send_conditional.txt | 25 - .../prism/snapshots/whitequark/send_index.txt | 34 - .../snapshots/whitequark/send_index_asgn.txt | 37 - .../whitequark/send_index_asgn_legacy.txt | 37 - .../snapshots/whitequark/send_index_cmd.txt | 51 - .../whitequark/send_index_legacy.txt | 34 - .../snapshots/whitequark/send_lambda.txt | 44 - .../snapshots/whitequark/send_lambda_args.txt | 51 - .../whitequark/send_lambda_args_noparen.txt | 57 - .../whitequark/send_lambda_args_shadow.txt | 34 - .../whitequark/send_lambda_legacy.txt | 12 - .../whitequark/send_op_asgn_conditional.txt | 27 - .../prism/snapshots/whitequark/send_plain.txt | 65 - .../snapshots/whitequark/send_plain_cmd.txt | 104 - .../prism/snapshots/whitequark/send_self.txt | 41 - .../snapshots/whitequark/send_self_block.txt | 75 - .../snapshots/whitequark/send_unary_op.txt | 65 - .../whitequark/slash_newline_in_heredocs.txt | 33 - .../snapshots/whitequark/space_args_arg.txt | 27 - .../whitequark/space_args_arg_block.txt | 109 - .../whitequark/space_args_arg_call.txt | 37 - .../whitequark/space_args_arg_newline.txt | 27 - .../snapshots/whitequark/space_args_block.txt | 28 - .../snapshots/whitequark/space_args_cmd.txt | 47 - .../snapshots/whitequark/string___FILE__.txt | 8 - .../snapshots/whitequark/string_concat.txt | 30 - .../snapshots/whitequark/string_dvar.txt | 36 - .../snapshots/whitequark/string_interp.txt | 37 - .../snapshots/whitequark/string_plain.txt | 17 - test/mri/prism/snapshots/whitequark/super.txt | 49 - .../snapshots/whitequark/super_block.txt | 48 - .../snapshots/whitequark/symbol_interp.txt | 37 - .../snapshots/whitequark/symbol_plain.txt | 17 - .../prism/snapshots/whitequark/ternary.txt | 36 - .../whitequark/ternary_ambiguous_symbol.txt | 50 - .../whitequark/trailing_forward_arg.txt | 55 - test/mri/prism/snapshots/whitequark/true.txt | 6 - .../whitequark/unary_num_pow_precedence.txt | 80 - test/mri/prism/snapshots/whitequark/undef.txt | 39 - .../mri/prism/snapshots/whitequark/unless.txt | 63 - .../snapshots/whitequark/unless_else.txt | 95 - .../prism/snapshots/whitequark/unless_mod.txt | 34 - test/mri/prism/snapshots/whitequark/until.txt | 61 - .../prism/snapshots/whitequark/until_mod.txt | 33 - .../prism/snapshots/whitequark/until_post.txt | 42 - .../snapshots/whitequark/var_and_asgn.txt | 14 - .../snapshots/whitequark/var_op_asgn.txt | 57 - .../snapshots/whitequark/var_op_asgn_cmd.txt | 28 - .../snapshots/whitequark/var_or_asgn.txt | 14 - .../prism/snapshots/whitequark/when_multi.txt | 50 - .../prism/snapshots/whitequark/when_splat.txt | 72 - .../prism/snapshots/whitequark/when_then.txt | 44 - test/mri/prism/snapshots/whitequark/while.txt | 61 - .../prism/snapshots/whitequark/while_mod.txt | 33 - .../prism/snapshots/whitequark/while_post.txt | 42 - .../snapshots/whitequark/xstring_interp.txt | 37 - .../snapshots/whitequark/xstring_plain.txt | 11 - test/mri/prism/snapshots/whitequark/yield.txt | 51 - .../mri/prism/snapshots/whitequark/zsuper.txt | 7 - test/mri/prism/snapshots/xstring.txt | 67 - .../snapshots/xstring_with_backslash.txt | 11 - test/mri/prism/snapshots/yield.txt | 43 - test/mri/prism/static_inspect_test.rb | 90 - test/mri/prism/static_literals_test.rb | 85 - test/mri/prism/warnings_test.rb | 123 - .../Amps and angle encoding.text | 21 - .../rdoc/MarkdownTest_1.0.3/Auto links.text | 13 - .../MarkdownTest_1.0.3/Backslash escapes.text | 120 - .../Blockquotes with code blocks.text | 11 - .../rdoc/MarkdownTest_1.0.3/Code Blocks.text | 14 - .../rdoc/MarkdownTest_1.0.3/Code Spans.text | 6 - ...apped paragraphs with list-like lines.text | 8 - .../MarkdownTest_1.0.3/Horizontal rules.text | 67 - .../Inline HTML (Advanced).text | 15 - .../Inline HTML (Simple).text | 69 - .../Inline HTML comments.text | 13 - .../Links, inline style.text | 12 - .../Links, reference style.text | 71 - .../Links, shortcut references.text | 20 - .../Literal quotes in titles.text | 7 - .../Markdown Documentation - Basics.text | 306 - .../Markdown Documentation - Syntax.text | 888 --- .../Nested blockquotes.text | 5 - .../Ordered and unordered lists.text | 131 - .../Strong and em together.text | 7 - .../rdoc/rdoc/MarkdownTest_1.0.3/Tabs.text | 21 - .../rdoc/MarkdownTest_1.0.3/Tidiness.text | 5 - test/mri/rdoc/rdoc/README | 1 - test/mri/rdoc/rdoc/binary.dat | Bin 1024 -> 0 bytes test/mri/rdoc/rdoc/helper.rb | 5 - test/mri/rdoc/rdoc/hidden.zip.txt | 1 - test/mri/rdoc/rdoc/rdoc_alias_test.rb | 13 - test/mri/rdoc/rdoc/rdoc_any_method_test.rb | 609 -- test/mri/rdoc/rdoc/rdoc_attr_test.rb | 190 - test/mri/rdoc/rdoc/rdoc_class_module_test.rb | 1706 ------ test/mri/rdoc/rdoc/rdoc_code_object_test.rb | 416 -- test/mri/rdoc/rdoc/rdoc_comment_test.rb | 480 -- test/mri/rdoc/rdoc/rdoc_constant_test.rb | 182 - .../rdoc/rdoc/rdoc_context_section_test.rb | 145 - test/mri/rdoc/rdoc/rdoc_context_test.rb | 958 ---- .../rdoc/rdoc/rdoc_cross_reference_test.rb | 217 - test/mri/rdoc/rdoc/rdoc_encoding_test.rb | 184 - test/mri/rdoc/rdoc/rdoc_extend_test.rb | 94 - .../rdoc/rdoc/rdoc_generator_darkfish_test.rb | 593 -- .../rdoc/rdoc_generator_json_index_test.rb | 363 -- .../rdoc/rdoc/rdoc_generator_markup_test.rb | 59 - .../rdoc/rdoc_generator_pot_po_entry_test.rb | 140 - .../rdoc/rdoc/rdoc_generator_pot_po_test.rb | 52 - test/mri/rdoc/rdoc/rdoc_generator_pot_test.rb | 92 - test/mri/rdoc/rdoc/rdoc_generator_ri_test.rb | 76 - test/mri/rdoc/rdoc/rdoc_i18n_locale_test.rb | 74 - test/mri/rdoc/rdoc/rdoc_i18n_text_test.rb | 124 - test/mri/rdoc/rdoc/rdoc_include_test.rb | 109 - test/mri/rdoc/rdoc/rdoc_markdown_test.rb | 1140 ---- test/mri/rdoc/rdoc/rdoc_markdown_test_test.rb | 1883 ------- .../rdoc_markup_attribute_manager_test.rb | 395 -- .../rdoc/rdoc/rdoc_markup_attributes_test.rb | 39 - .../rdoc/rdoc/rdoc_markup_document_test.rb | 207 - .../rdoc/rdoc/rdoc_markup_formatter_test.rb | 181 - .../rdoc/rdoc/rdoc_markup_hard_break_test.rb | 31 - .../mri/rdoc/rdoc/rdoc_markup_heading_test.rb | 34 - .../mri/rdoc/rdoc/rdoc_markup_include_test.rb | 19 - .../rdoc_markup_indented_paragraph_test.rb | 53 - .../rdoc/rdoc/rdoc_markup_paragraph_test.rb | 32 - test/mri/rdoc/rdoc/rdoc_markup_parser_test.rb | 1684 ------ .../rdoc/rdoc/rdoc_markup_pre_process_test.rb | 481 -- test/mri/rdoc/rdoc/rdoc_markup_raw_test.rb | 22 - test/mri/rdoc/rdoc/rdoc_markup_test.rb | 95 - .../mri/rdoc/rdoc/rdoc_markup_to_ansi_test.rb | 380 -- test/mri/rdoc/rdoc/rdoc_markup_to_bs_test.rb | 363 -- .../rdoc/rdoc_markup_to_html_crossref_test.rb | 325 -- .../rdoc/rdoc_markup_to_html_snippet_test.rb | 709 --- .../mri/rdoc/rdoc/rdoc_markup_to_html_test.rb | 1024 ---- .../rdoc_markup_to_joined_paragraph_test.rb | 32 - .../rdoc/rdoc/rdoc_markup_to_label_test.rb | 112 - .../rdoc/rdoc/rdoc_markup_to_markdown_test.rb | 397 -- .../mri/rdoc/rdoc/rdoc_markup_to_rdoc_test.rb | 388 -- .../rdoc_markup_to_table_of_contents_test.rb | 126 - .../rdoc/rdoc/rdoc_markup_to_tt_only_test.rb | 246 - .../rdoc/rdoc/rdoc_markup_verbatim_test.rb | 29 - test/mri/rdoc/rdoc/rdoc_method_attr_test.rb | 210 - test/mri/rdoc/rdoc/rdoc_normal_class_test.rb | 47 - test/mri/rdoc/rdoc/rdoc_normal_module_test.rb | 42 - test/mri/rdoc/rdoc/rdoc_options_test.rb | 975 ---- test/mri/rdoc/rdoc/rdoc_parser_c_test.rb | 2150 ------- .../rdoc/rdoc/rdoc_parser_changelog_test.rb | 483 -- .../rdoc/rdoc/rdoc_parser_markdown_test.rb | 61 - .../rdoc/rdoc/rdoc_parser_prism_ruby_test.rb | 2165 -------- test/mri/rdoc/rdoc/rdoc_parser_rd_test.rb | 55 - test/mri/rdoc/rdoc/rdoc_parser_ruby_test.rb | 4396 --------------- test/mri/rdoc/rdoc/rdoc_parser_simple_test.rb | 115 - test/mri/rdoc/rdoc/rdoc_parser_test.rb | 334 -- .../rdoc/rdoc/rdoc_rd_block_parser_test.rb | 557 -- .../rdoc/rdoc/rdoc_rd_inline_parser_test.rb | 178 - test/mri/rdoc/rdoc/rdoc_rd_inline_test.rb | 63 - test/mri/rdoc/rdoc/rdoc_rd_test.rb | 30 - test/mri/rdoc/rdoc/rdoc_rdoc_test.rb | 582 -- test/mri/rdoc/rdoc/rdoc_require_test.rb | 25 - test/mri/rdoc/rdoc/rdoc_ri_driver_test.rb | 1610 ------ test/mri/rdoc/rdoc/rdoc_ri_paths_test.rb | 157 - test/mri/rdoc/rdoc/rdoc_rubygems_hook_test.rb | 329 -- test/mri/rdoc/rdoc/rdoc_servlet_test.rb | 553 -- test/mri/rdoc/rdoc/rdoc_single_class_test.rb | 20 - test/mri/rdoc/rdoc/rdoc_stats_test.rb | 720 --- test/mri/rdoc/rdoc/rdoc_store_test.rb | 1057 ---- test/mri/rdoc/rdoc/rdoc_task_test.rb | 182 - test/mri/rdoc/rdoc/rdoc_text_test.rb | 585 -- test/mri/rdoc/rdoc/rdoc_token_stream_test.rb | 109 - test/mri/rdoc/rdoc/rdoc_tom_doc_test.rb | 579 -- test/mri/rdoc/rdoc/rdoc_top_level_test.rb | 289 - .../rdoc/rdoc/support/formatter_test_case.rb | 764 --- test/mri/rdoc/rdoc/support/test_case.rb | 219 - .../rdoc/support/text_formatter_test_case.rb | 131 - test/mri/rdoc/rdoc/test.ja.largedoc | 3 - test/mri/rdoc/rdoc/test.ja.rdoc | 10 - test/mri/rdoc/rdoc/test.ja.txt | 8 - test/mri/rdoc/rdoc/test.txt | 1 - test/mri/rdoc/rdoc/xref_data.rb | 164 - test/mri/rdoc/rdoc/xref_test_case.rb | 86 - test/mri/rdoc/rdoc_alias_test.rb | 13 - test/mri/rdoc/rdoc_any_method_test.rb | 609 -- test/mri/rdoc/rdoc_attr_test.rb | 190 - test/mri/rdoc/rdoc_class_module_test.rb | 1706 ------ test/mri/rdoc/rdoc_code_object_test.rb | 416 -- test/mri/rdoc/rdoc_comment_test.rb | 480 -- test/mri/rdoc/rdoc_constant_test.rb | 182 - test/mri/rdoc/rdoc_context_section_test.rb | 145 - test/mri/rdoc/rdoc_context_test.rb | 958 ---- test/mri/rdoc/rdoc_cross_reference_test.rb | 217 - test/mri/rdoc/rdoc_encoding_test.rb | 184 - test/mri/rdoc/rdoc_extend_test.rb | 94 - test/mri/rdoc/rdoc_generator_darkfish_test.rb | 593 -- .../rdoc/rdoc_generator_json_index_test.rb | 363 -- test/mri/rdoc/rdoc_generator_markup_test.rb | 59 - .../rdoc/rdoc_generator_pot_po_entry_test.rb | 140 - test/mri/rdoc/rdoc_generator_pot_po_test.rb | 52 - test/mri/rdoc/rdoc_generator_pot_test.rb | 92 - test/mri/rdoc/rdoc_generator_ri_test.rb | 76 - test/mri/rdoc/rdoc_i18n_locale_test.rb | 74 - test/mri/rdoc/rdoc_i18n_text_test.rb | 124 - test/mri/rdoc/rdoc_include_test.rb | 109 - test/mri/rdoc/rdoc_markdown_test.rb | 1140 ---- test/mri/rdoc/rdoc_markdown_test_test.rb | 1883 ------- .../rdoc_markup_attribute_manager_test.rb | 395 -- test/mri/rdoc/rdoc_markup_attributes_test.rb | 39 - test/mri/rdoc/rdoc_markup_document_test.rb | 207 - test/mri/rdoc/rdoc_markup_formatter_test.rb | 181 - test/mri/rdoc/rdoc_markup_hard_break_test.rb | 31 - test/mri/rdoc/rdoc_markup_heading_test.rb | 34 - test/mri/rdoc/rdoc_markup_include_test.rb | 19 - .../rdoc_markup_indented_paragraph_test.rb | 53 - test/mri/rdoc/rdoc_markup_paragraph_test.rb | 32 - test/mri/rdoc/rdoc_markup_parser_test.rb | 1684 ------ test/mri/rdoc/rdoc_markup_pre_process_test.rb | 481 -- test/mri/rdoc/rdoc_markup_raw_test.rb | 22 - test/mri/rdoc/rdoc_markup_test.rb | 95 - test/mri/rdoc/rdoc_markup_to_ansi_test.rb | 380 -- test/mri/rdoc/rdoc_markup_to_bs_test.rb | 363 -- .../rdoc/rdoc_markup_to_html_crossref_test.rb | 325 -- .../rdoc/rdoc_markup_to_html_snippet_test.rb | 709 --- test/mri/rdoc/rdoc_markup_to_html_test.rb | 1024 ---- .../rdoc_markup_to_joined_paragraph_test.rb | 32 - test/mri/rdoc/rdoc_markup_to_label_test.rb | 112 - test/mri/rdoc/rdoc_markup_to_markdown_test.rb | 397 -- test/mri/rdoc/rdoc_markup_to_rdoc_test.rb | 388 -- .../rdoc_markup_to_table_of_contents_test.rb | 126 - test/mri/rdoc/rdoc_markup_to_tt_only_test.rb | 246 - test/mri/rdoc/rdoc_markup_verbatim_test.rb | 29 - test/mri/rdoc/rdoc_method_attr_test.rb | 210 - test/mri/rdoc/rdoc_normal_class_test.rb | 47 - test/mri/rdoc/rdoc_normal_module_test.rb | 42 - test/mri/rdoc/rdoc_options_test.rb | 975 ---- test/mri/rdoc/rdoc_parser_c_test.rb | 2150 ------- test/mri/rdoc/rdoc_parser_changelog_test.rb | 483 -- test/mri/rdoc/rdoc_parser_markdown_test.rb | 61 - test/mri/rdoc/rdoc_parser_prism_ruby_test.rb | 2165 -------- test/mri/rdoc/rdoc_parser_rd_test.rb | 55 - test/mri/rdoc/rdoc_parser_ruby_test.rb | 4396 --------------- test/mri/rdoc/rdoc_parser_simple_test.rb | 115 - test/mri/rdoc/rdoc_parser_test.rb | 334 -- test/mri/rdoc/rdoc_rd_block_parser_test.rb | 557 -- test/mri/rdoc/rdoc_rd_inline_parser_test.rb | 178 - test/mri/rdoc/rdoc_rd_inline_test.rb | 63 - test/mri/rdoc/rdoc_rd_test.rb | 30 - test/mri/rdoc/rdoc_rdoc_test.rb | 582 -- test/mri/rdoc/rdoc_require_test.rb | 25 - test/mri/rdoc/rdoc_ri_driver_test.rb | 1610 ------ test/mri/rdoc/rdoc_ri_paths_test.rb | 157 - test/mri/rdoc/rdoc_rubygems_hook_test.rb | 329 -- test/mri/rdoc/rdoc_servlet_test.rb | 553 -- test/mri/rdoc/rdoc_single_class_test.rb | 20 - test/mri/rdoc/rdoc_stats_test.rb | 720 --- test/mri/rdoc/rdoc_store_test.rb | 1057 ---- test/mri/rdoc/rdoc_task_test.rb | 182 - test/mri/rdoc/rdoc_text_test.rb | 585 -- test/mri/rdoc/rdoc_token_stream_test.rb | 109 - test/mri/rdoc/rdoc_tom_doc_test.rb | 579 -- test/mri/rdoc/rdoc_top_level_test.rb | 289 - test/mri/reline/helper.rb | 158 - test/mri/reline/test_ansi.rb | 72 - test/mri/reline/test_config.rb | 633 --- test/mri/reline/test_face.rb | 257 - test/mri/reline/test_history.rb | 317 -- test/mri/reline/test_key_actor_emacs.rb | 1759 ------ test/mri/reline/test_key_actor_vi.rb | 967 ---- test/mri/reline/test_key_stroke.rb | 111 - test/mri/reline/test_kill_ring.rb | 268 - test/mri/reline/test_line_editor.rb | 271 - test/mri/reline/test_macro.rb | 40 - test/mri/reline/test_reline.rb | 476 -- test/mri/reline/test_reline_key.rb | 10 - test/mri/reline/test_string_processing.rb | 46 - test/mri/reline/test_unicode.rb | 342 -- test/mri/reline/test_within_pipe.rb | 77 - .../reline/windows/test_key_event_record.rb | 41 - test/mri/reline/yamatanooroti/multiline_repl | 255 - .../yamatanooroti/termination_checker.rb | 26 - .../reline/yamatanooroti/test_rendering.rb | 1959 ------- test/mri/ruby/rjit/test_assembler.rb | 368 -- .../test_gem_commands_query_command.rb | 830 --- test/mri/test_pstore.rb | 182 - test/mri/win32ole/available_ole.rb | 41 - test/mri/win32ole/err_in_callback.rb | 10 - test/mri/win32ole/orig_data.csv | 5 - test/mri/win32ole/test_err_in_callback.rb | 56 - .../win32ole/test_folderitem2_invokeverb.rb | 66 - test/mri/win32ole/test_nil2vtempty.rb | 37 - test/mri/win32ole/test_ole_methods.rb | 35 - test/mri/win32ole/test_propertyputref.rb | 31 - test/mri/win32ole/test_thread.rb | 34 - test/mri/win32ole/test_win32ole.rb | 536 -- test/mri/win32ole/test_win32ole_event.rb | 407 -- test/mri/win32ole/test_win32ole_method.rb | 134 - .../win32ole/test_win32ole_method_event.rb | 36 - test/mri/win32ole/test_win32ole_param.rb | 98 - .../mri/win32ole/test_win32ole_param_event.rb | 30 - test/mri/win32ole/test_win32ole_record.rb | 212 - test/mri/win32ole/test_win32ole_type.rb | 199 - test/mri/win32ole/test_win32ole_type_event.rb | 44 - test/mri/win32ole/test_win32ole_typelib.rb | 117 - test/mri/win32ole/test_win32ole_variable.rb | 66 - test/mri/win32ole/test_win32ole_variant.rb | 722 --- test/mri/win32ole/test_win32ole_variant_m.rb | 37 - .../win32ole/test_win32ole_variant_outarg.rb | 69 - test/mri/win32ole/test_word.rb | 73 - 1296 files changed, 193611 deletions(-) delete mode 100644 test/mri/benchmark/test_benchmark.rb delete mode 100644 test/mri/cgi/test_cgi_cookie.rb delete mode 100644 test/mri/cgi/test_cgi_core.rb delete mode 100644 test/mri/cgi/test_cgi_header.rb delete mode 100644 test/mri/cgi/test_cgi_modruby.rb delete mode 100644 test/mri/cgi/test_cgi_multipart.rb delete mode 100644 test/mri/cgi/test_cgi_session.rb delete mode 100644 test/mri/cgi/test_cgi_tag_helper.rb delete mode 100644 test/mri/cgi/test_cgi_util.rb delete mode 100644 test/mri/cgi/testdata/file1.html delete mode 100644 test/mri/cgi/testdata/large.png delete mode 100644 test/mri/cgi/testdata/small.png delete mode 100644 test/mri/fiddle/helper.rb delete mode 100644 test/mri/fiddle/test_c_struct_builder.rb delete mode 100644 test/mri/fiddle/test_c_struct_entry.rb delete mode 100644 test/mri/fiddle/test_c_union_entity.rb delete mode 100644 test/mri/fiddle/test_closure.rb delete mode 100644 test/mri/fiddle/test_cparser.rb delete mode 100644 test/mri/fiddle/test_fiddle.rb delete mode 100644 test/mri/fiddle/test_func.rb delete mode 100644 test/mri/fiddle/test_function.rb delete mode 100644 test/mri/fiddle/test_handle.rb delete mode 100644 test/mri/fiddle/test_import.rb delete mode 100644 test/mri/fiddle/test_memory_view.rb delete mode 100644 test/mri/fiddle/test_pack.rb delete mode 100644 test/mri/fiddle/test_pinned.rb delete mode 100644 test/mri/fiddle/test_pointer.rb delete mode 100644 test/mri/irb/command/test_cd.rb delete mode 100644 test/mri/irb/command/test_custom_command.rb delete mode 100644 test/mri/irb/command/test_disable_irb.rb delete mode 100644 test/mri/irb/command/test_force_exit.rb delete mode 100644 test/mri/irb/command/test_help.rb delete mode 100644 test/mri/irb/command/test_multi_irb_commands.rb delete mode 100644 test/mri/irb/command/test_show_source.rb delete mode 100644 test/mri/irb/helper.rb delete mode 100644 test/mri/irb/test_color.rb delete mode 100644 test/mri/irb/test_color_printer.rb delete mode 100644 test/mri/irb/test_command.rb delete mode 100644 test/mri/irb/test_completion.rb delete mode 100644 test/mri/irb/test_context.rb delete mode 100644 test/mri/irb/test_debugger_integration.rb delete mode 100644 test/mri/irb/test_eval_history.rb delete mode 100644 test/mri/irb/test_evaluation.rb delete mode 100644 test/mri/irb/test_helper_method.rb delete mode 100644 test/mri/irb/test_history.rb delete mode 100644 test/mri/irb/test_init.rb delete mode 100644 test/mri/irb/test_input_method.rb delete mode 100644 test/mri/irb/test_irb.rb delete mode 100644 test/mri/irb/test_locale.rb delete mode 100644 test/mri/irb/test_nesting_parser.rb delete mode 100644 test/mri/irb/test_option.rb delete mode 100644 test/mri/irb/test_raise_exception.rb delete mode 100644 test/mri/irb/test_ruby_lex.rb delete mode 100644 test/mri/irb/test_tracer.rb delete mode 100644 test/mri/irb/test_type_completor.rb delete mode 100644 test/mri/irb/test_workspace.rb delete mode 100644 test/mri/irb/yamatanooroti/test_rendering.rb delete mode 100644 test/mri/json/fixtures/fail4.json delete mode 100644 test/mri/json/fixtures/fail9.json delete mode 100644 test/mri/json/fixtures/pass15.json delete mode 100644 test/mri/json/fixtures/pass16.json delete mode 100644 test/mri/json/fixtures/pass17.json delete mode 100644 test/mri/json/fixtures/pass26.json delete mode 100644 test/mri/logger/test_formatter.rb delete mode 100644 test/mri/logger/test_logdevice.rb delete mode 100644 test/mri/logger/test_logger.rb delete mode 100644 test/mri/logger/test_logperiod.rb delete mode 100644 test/mri/logger/test_severity.rb delete mode 100644 test/mri/openssl/fixtures/pkey/certificate.der delete mode 100644 test/mri/openssl/fixtures/pkey/dsa1024.pem delete mode 100644 test/mri/openssl/fixtures/pkey/dsa256.pem delete mode 100644 test/mri/openssl/fixtures/pkey/dsa512.pem delete mode 100644 test/mri/openssl/fixtures/pkey/empty.der delete mode 100644 test/mri/openssl/fixtures/pkey/empty.pem delete mode 100644 test/mri/openssl/fixtures/pkey/fullchain.pem delete mode 100644 test/mri/openssl/fixtures/pkey/garbage.txt delete mode 100644 test/mri/openssl/fixtures/pkey/p256_too_large.pem delete mode 100644 test/mri/openssl/fixtures/pkey/p384_invalid.pem delete mode 100644 test/mri/openssl/fixtures/pkey/rsa1024.pem delete mode 100644 test/mri/ostruct/test_ostruct.rb delete mode 100644 test/mri/prism/attribute_write_test.rb delete mode 100644 test/mri/prism/command_line_test.rb delete mode 100644 test/mri/prism/comments_test.rb delete mode 100644 test/mri/prism/compiler_test.rb delete mode 100644 test/mri/prism/constant_path_node_test.rb delete mode 100644 test/mri/prism/desugar_compiler_test.rb delete mode 100644 test/mri/prism/dispatcher_test.rb delete mode 100644 test/mri/prism/encoding_test.rb delete mode 100644 test/mri/prism/errors/block_args_in_array_assignment.txt delete mode 100644 test/mri/prism/errors/dont_allow_return_inside_sclass_body.txt delete mode 100644 test/mri/prism/errors/it_with_ordinary_parameter.txt delete mode 100644 test/mri/prism/errors/keyword_args_in_array_assignment.txt delete mode 100644 test/mri/prism/fixtures/it_indirect_writes.txt delete mode 100644 test/mri/prism/fixtures/seattlerb/block_break.txt delete mode 100644 test/mri/prism/fixtures/seattlerb/block_next.txt delete mode 100644 test/mri/prism/fixtures/seattlerb/dasgn_icky2.txt delete mode 100644 test/mri/prism/fixtures/seattlerb/yield_arg.txt delete mode 100644 test/mri/prism/fixtures/seattlerb/yield_call_assocs.txt delete mode 100644 test/mri/prism/fixtures/seattlerb/yield_empty_parens.txt delete mode 100644 test/mri/prism/fixtures/unparser/corpus/literal/control.txt delete mode 100644 test/mri/prism/fixtures/unparser/corpus/literal/yield.txt delete mode 100644 test/mri/prism/fixtures/whitequark/args_assocs.txt delete mode 100644 test/mri/prism/fixtures/whitequark/args_assocs_legacy.txt delete mode 100644 test/mri/prism/fixtures/whitequark/break.txt delete mode 100644 test/mri/prism/fixtures/whitequark/break_block.txt delete mode 100644 test/mri/prism/fixtures/whitequark/class_definition_in_while_cond.txt delete mode 100644 test/mri/prism/fixtures/whitequark/if_while_after_class__since_32.txt delete mode 100644 test/mri/prism/fixtures/whitequark/next.txt delete mode 100644 test/mri/prism/fixtures/whitequark/next_block.txt delete mode 100644 test/mri/prism/fixtures/whitequark/redo.txt delete mode 100644 test/mri/prism/fixtures/whitequark/retry.txt delete mode 100644 test/mri/prism/fixtures/whitequark/yield.txt delete mode 100644 test/mri/prism/format_errors_test.rb delete mode 100644 test/mri/prism/integer_parse_test.rb delete mode 100644 test/mri/prism/location_test.rb delete mode 100644 test/mri/prism/memsize_test.rb delete mode 100644 test/mri/prism/parameters_signature_test.rb delete mode 100644 test/mri/prism/parse_comments_test.rb delete mode 100644 test/mri/prism/parse_stream_test.rb delete mode 100644 test/mri/prism/parse_test.rb delete mode 100644 test/mri/prism/parser_test.rb delete mode 100644 test/mri/prism/pattern_test.rb delete mode 100644 test/mri/prism/ripper_test.rb delete mode 100644 test/mri/prism/ruby_api_test.rb delete mode 100644 test/mri/prism/ruby_parser_test.rb delete mode 100644 test/mri/prism/snapshots/alias.txt delete mode 100644 test/mri/prism/snapshots/arithmetic.txt delete mode 100644 test/mri/prism/snapshots/arrays.txt delete mode 100644 test/mri/prism/snapshots/begin_ensure.txt delete mode 100644 test/mri/prism/snapshots/begin_rescue.txt delete mode 100644 test/mri/prism/snapshots/blocks.txt delete mode 100644 test/mri/prism/snapshots/boolean_operators.txt delete mode 100644 test/mri/prism/snapshots/booleans.txt delete mode 100644 test/mri/prism/snapshots/break.txt delete mode 100644 test/mri/prism/snapshots/case.txt delete mode 100644 test/mri/prism/snapshots/classes.txt delete mode 100644 test/mri/prism/snapshots/command_method_call.txt delete mode 100644 test/mri/prism/snapshots/comments.txt delete mode 100644 test/mri/prism/snapshots/constants.txt delete mode 100644 test/mri/prism/snapshots/dash_heredocs.txt delete mode 100644 test/mri/prism/snapshots/defined.txt delete mode 100644 test/mri/prism/snapshots/dos_endings.txt delete mode 100644 test/mri/prism/snapshots/dstring.txt delete mode 100644 test/mri/prism/snapshots/dsym_str.txt delete mode 100644 test/mri/prism/snapshots/embdoc_no_newline_at_end.txt delete mode 100644 test/mri/prism/snapshots/emoji_method_calls.txt delete mode 100644 test/mri/prism/snapshots/endless_methods.txt delete mode 100644 test/mri/prism/snapshots/endless_range_in_conditional.txt delete mode 100644 test/mri/prism/snapshots/for.txt delete mode 100644 test/mri/prism/snapshots/global_variables.txt delete mode 100644 test/mri/prism/snapshots/hashes.txt delete mode 100644 test/mri/prism/snapshots/heredoc.txt delete mode 100644 test/mri/prism/snapshots/heredoc_with_carriage_returns.txt delete mode 100644 test/mri/prism/snapshots/heredoc_with_comment.txt delete mode 100644 test/mri/prism/snapshots/heredoc_with_escaped_newline_at_start.txt delete mode 100644 test/mri/prism/snapshots/heredoc_with_trailing_newline.txt delete mode 100644 test/mri/prism/snapshots/heredocs_leading_whitespace.txt delete mode 100644 test/mri/prism/snapshots/heredocs_nested.txt delete mode 100644 test/mri/prism/snapshots/heredocs_with_ignored_newlines.txt delete mode 100644 test/mri/prism/snapshots/heredocs_with_ignored_newlines_and_non_empty.txt delete mode 100644 test/mri/prism/snapshots/if.txt delete mode 100644 test/mri/prism/snapshots/indented_file_end.txt delete mode 100644 test/mri/prism/snapshots/integer_operations.txt delete mode 100644 test/mri/prism/snapshots/keyword_method_names.txt delete mode 100644 test/mri/prism/snapshots/keywords.txt delete mode 100644 test/mri/prism/snapshots/lambda.txt delete mode 100644 test/mri/prism/snapshots/method_calls.txt delete mode 100644 test/mri/prism/snapshots/methods.txt delete mode 100644 test/mri/prism/snapshots/modules.txt delete mode 100644 test/mri/prism/snapshots/multi_write.txt delete mode 100644 test/mri/prism/snapshots/newline_terminated.txt delete mode 100644 test/mri/prism/snapshots/next.txt delete mode 100644 test/mri/prism/snapshots/nils.txt delete mode 100644 test/mri/prism/snapshots/non_alphanumeric_methods.txt delete mode 100644 test/mri/prism/snapshots/not.txt delete mode 100644 test/mri/prism/snapshots/numbers.txt delete mode 100644 test/mri/prism/snapshots/patterns.txt delete mode 100644 test/mri/prism/snapshots/procs.txt delete mode 100644 test/mri/prism/snapshots/range_begin_open_exclusive.txt delete mode 100644 test/mri/prism/snapshots/range_begin_open_inclusive.txt delete mode 100644 test/mri/prism/snapshots/range_beginless.txt delete mode 100644 test/mri/prism/snapshots/range_end_open_exclusive.txt delete mode 100644 test/mri/prism/snapshots/range_end_open_inclusive.txt delete mode 100644 test/mri/prism/snapshots/ranges.txt delete mode 100644 test/mri/prism/snapshots/regex.txt delete mode 100644 test/mri/prism/snapshots/regex_char_width.txt delete mode 100644 test/mri/prism/snapshots/repeat_parameters.txt delete mode 100644 test/mri/prism/snapshots/rescue.txt delete mode 100644 test/mri/prism/snapshots/rescue_modifier.txt delete mode 100644 test/mri/prism/snapshots/return.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/BEGIN.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/TestRubyParserShared.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/__ENCODING__.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/alias_gvar_backref.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/alias_resword.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/and_multi.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/aref_args_assocs.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/aref_args_lit_assocs.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/args_kw_block.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/array_line_breaks.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/array_lits_trailing_calls.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/assoc__bare.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/assoc_label.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/attr_asgn_colon_id.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/attrasgn_array_arg.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/attrasgn_array_lhs.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/attrasgn_primary_dot_constant.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/backticks_interpolation_line.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/bang_eq.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/bdot2.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/bdot3.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/begin_ensure_no_bodies.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/begin_rescue_else_ensure_bodies.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/begin_rescue_else_ensure_no_bodies.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/begin_rescue_ensure_no_bodies.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/block_arg__bare.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/block_arg_kwsplat.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/block_arg_opt_arg_block.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/block_arg_opt_splat.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/block_arg_opt_splat_arg_block_omfg.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/block_arg_optional.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/block_arg_scope.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/block_arg_scope2.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/block_arg_splat_arg.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/block_args_kwargs.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/block_args_no_kwargs.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/block_args_opt1.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/block_args_opt2.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/block_args_opt2_2.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/block_args_opt3.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/block_break.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/block_call_defn_call_block_call.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/block_call_dot_op2_brace_block.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/block_call_dot_op2_cmd_args_do_block.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/block_call_operation_colon.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/block_call_operation_dot.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/block_call_paren_call_block_call.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/block_command_operation_colon.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/block_command_operation_dot.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/block_decomp_anon_splat_arg.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/block_decomp_arg_splat.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/block_decomp_arg_splat_arg.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/block_decomp_splat.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/block_kw.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/block_kw__required.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/block_kwarg_lvar.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/block_kwarg_lvar_multiple.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/block_next.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/block_opt_arg.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/block_opt_splat.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/block_opt_splat_arg_block_omfg.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/block_optarg.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/block_paren_splat.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/block_reg_optarg.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/block_return.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/block_scope.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/block_splat_reg.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/bug169.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/bug179.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/bug190.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/bug191.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/bug202.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/bug236.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/bug290.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/bug_187.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/bug_215.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/bug_249.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/bug_and.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/bug_args__19.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/bug_args_masgn.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/bug_args_masgn2.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/bug_args_masgn_outer_parens__19.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/bug_call_arglist_parens.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/bug_case_when_regexp.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/bug_comma.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/bug_cond_pct.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/bug_hash_args.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/bug_hash_args_trailing_comma.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/bug_hash_interp_array.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/bug_masgn_right.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/bug_not_parens.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/bug_op_asgn_rescue.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/call_and.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/call_arg_assoc.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/call_arg_assoc_kwsplat.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/call_arg_kwsplat.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/call_args_assoc_quoted.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/call_args_assoc_trailing_comma.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/call_args_command.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/call_array_arg.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/call_array_block_call.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/call_array_lambda_block_call.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/call_array_lit_inline_hash.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/call_assoc.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/call_assoc_new.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/call_assoc_new_if_multiline.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/call_assoc_trailing_comma.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/call_bang_command_call.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/call_bang_squiggle.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/call_begin_call_block_call.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/call_block_arg_named.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/call_carat.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/call_colon2.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/call_colon_parens.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/call_div.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/call_dot_parens.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/call_env.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/call_eq3.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/call_gt.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/call_kwsplat.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/call_leading_dots.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/call_leading_dots_comment.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/call_lt.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/call_lte.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/call_not.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/call_pipe.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/call_rshift.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/call_self_brackets.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/call_spaceship.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/call_stabby_do_end_with_block.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/call_stabby_with_braces_block.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/call_star.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/call_star2.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/call_trailing_comma.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/call_trailing_dots.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/call_unary_bang.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/case_in.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/case_in_31.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/case_in_37.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/case_in_42.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/case_in_42_2.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/case_in_47.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/case_in_67.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/case_in_86.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/case_in_86_2.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/case_in_array_pat_const.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/case_in_array_pat_const2.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/case_in_array_pat_paren_assign.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/case_in_const.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/case_in_else.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/case_in_find.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/case_in_find_array.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/case_in_hash_pat.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/case_in_hash_pat_assign.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/case_in_hash_pat_paren_assign.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/case_in_hash_pat_paren_true.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/case_in_hash_pat_rest.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/case_in_hash_pat_rest_solo.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/case_in_if_unless_post_mod.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/case_in_multiple.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/case_in_or.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/class_comments.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/cond_unary_minus.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/const_2_op_asgn_or2.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/const_3_op_asgn_or.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/const_op_asgn_and1.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/const_op_asgn_and2.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/const_op_asgn_or.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/dasgn_icky2.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/defined_eh_parens.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/defn_arg_asplat_arg.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/defn_arg_forward_args.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/defn_args_forward_args.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/defn_comments.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/defn_endless_command.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/defn_endless_command_rescue.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/defn_forward_args.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/defn_forward_args__no_parens.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/defn_kwarg_env.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/defn_kwarg_kwarg.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/defn_kwarg_kwsplat.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/defn_kwarg_kwsplat_anon.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/defn_kwarg_lvar.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/defn_kwarg_no_parens.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/defn_kwarg_val.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/defn_no_kwargs.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/defn_oneliner.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/defn_oneliner_eq2.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/defn_oneliner_noargs.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/defn_oneliner_noargs_parentheses.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/defn_oneliner_rescue.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/defn_opt_last_arg.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/defn_opt_reg.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/defn_opt_splat_arg.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/defn_powarg.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/defn_reg_opt_reg.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/defn_splat_arg.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/defn_unary_not.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/defns_reserved.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/defs_as_arg_with_do_block_inside.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/defs_comments.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/defs_endless_command.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/defs_endless_command_rescue.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/defs_kwarg.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/defs_oneliner.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/defs_oneliner_eq2.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/defs_oneliner_rescue.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/difficult0_.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/difficult1_line_numbers.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/difficult1_line_numbers2.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/difficult2_.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/difficult3_.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/difficult3_2.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/difficult3_3.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/difficult3_4.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/difficult3_5.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/difficult3__10.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/difficult3__11.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/difficult3__12.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/difficult3__6.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/difficult3__7.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/difficult3__8.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/difficult3__9.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/difficult4__leading_dots.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/difficult4__leading_dots2.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/difficult6_.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/difficult6__7.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/difficult6__8.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/difficult7_.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/do_bug.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/do_lambda.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/dot2_nil__26.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/dot3_nil__26.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/dstr_evstr.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/dstr_evstr_empty_end.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/dstr_lex_state.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/dstr_str.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/dsym_esc_to_sym.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/dsym_to_sym.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/eq_begin_line_numbers.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/eq_begin_why_wont_people_use_their_spacebar.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/evstr_evstr.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/evstr_str.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/expr_not_bang.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/f_kw.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/f_kw__required.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/flip2_env_lvar.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/float_with_if_modifier.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/heredoc__backslash_dos_format.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/heredoc_backslash_nl.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/heredoc_bad_hex_escape.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/heredoc_bad_oct_escape.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/heredoc_comma_arg.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/heredoc_lineno.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/heredoc_nested.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/heredoc_squiggly.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/heredoc_squiggly_blank_line_plus_interpolation.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/heredoc_squiggly_blank_lines.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/heredoc_squiggly_empty.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/heredoc_squiggly_interp.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/heredoc_squiggly_no_indent.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/heredoc_squiggly_tabs.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/heredoc_squiggly_tabs_extra.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/heredoc_squiggly_visually_blank_lines.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/heredoc_trailing_slash_continued_call.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/heredoc_unicode.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/heredoc_with_carriage_return_escapes.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/heredoc_with_carriage_return_escapes_windows.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/heredoc_with_extra_carriage_horrible_mix.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/heredoc_with_extra_carriage_returns.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/heredoc_with_extra_carriage_returns_windows.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/heredoc_with_interpolation_and_carriage_return_escapes.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/heredoc_with_interpolation_and_carriage_return_escapes_windows.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/heredoc_with_not_global_interpolation.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/heredoc_with_only_carriage_returns.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/heredoc_with_only_carriage_returns_windows.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/if_elsif.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/if_symbol.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/in_expr_no_case.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/index_0.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/index_0_opasgn.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/integer_with_if_modifier.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/interpolated_symbol_array_line_breaks.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/interpolated_word_array_line_breaks.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/iter_args_1.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/iter_args_10_1.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/iter_args_10_2.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/iter_args_11_1.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/iter_args_11_2.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/iter_args_2__19.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/iter_args_3.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/iter_args_4.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/iter_args_5.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/iter_args_6.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/iter_args_7_1.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/iter_args_7_2.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/iter_args_8_1.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/iter_args_8_2.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/iter_args_9_1.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/iter_args_9_2.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/iter_kwarg.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/iter_kwarg_kwsplat.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/label_vs_string.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/lambda_do_vs_brace.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/lasgn_arg_rescue_arg.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/lasgn_call_bracket_rescue_arg.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/lasgn_call_nobracket_rescue_arg.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/lasgn_command.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/lasgn_env.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/lasgn_ivar_env.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/lasgn_lasgn_command_call.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/lasgn_middle_splat.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/magic_encoding_comment.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/masgn_anon_splat_arg.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/masgn_arg_colon_arg.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/masgn_arg_ident.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/masgn_arg_splat_arg.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/masgn_colon2.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/masgn_colon3.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/masgn_command_call.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/masgn_double_paren.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/masgn_lhs_splat.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/masgn_paren.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/masgn_splat_arg.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/masgn_splat_arg_arg.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/masgn_star.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/masgn_var_star_var.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/messy_op_asgn_lineno.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/method_call_assoc_trailing_comma.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/method_call_trailing_comma.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/mlhs_back_anonsplat.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/mlhs_back_splat.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/mlhs_front_anonsplat.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/mlhs_front_splat.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/mlhs_keyword.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/mlhs_mid_anonsplat.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/mlhs_mid_splat.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/mlhs_rescue.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/module_comments.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/multiline_hash_declaration.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/non_interpolated_symbol_array_line_breaks.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/non_interpolated_word_array_line_breaks.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/op_asgn_command_call.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/op_asgn_dot_ident_command_call.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/op_asgn_index_command_call.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/op_asgn_primary_colon_const_command_call.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/op_asgn_primary_colon_identifier1.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/op_asgn_primary_colon_identifier_command_call.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/op_asgn_val_dot_ident_command_call.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/parse_def_special_name.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/parse_if_not_canonical.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/parse_if_not_noncanonical.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/parse_line_block.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/parse_line_block_inline_comment.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/parse_line_block_inline_comment_leading_newlines.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/parse_line_block_inline_multiline_comment.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/parse_line_call_ivar_arg_no_parens_line_break.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/parse_line_call_ivar_line_break_paren.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/parse_line_call_no_args.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/parse_line_defn_complex.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/parse_line_defn_no_parens.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/parse_line_defn_no_parens_args.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/parse_line_dot2.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/parse_line_dot2_open.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/parse_line_dot3.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/parse_line_dot3_open.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/parse_line_dstr_escaped_newline.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/parse_line_dstr_soft_newline.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/parse_line_evstr_after_break.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/parse_line_hash_lit.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/parse_line_heredoc.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/parse_line_heredoc_evstr.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/parse_line_heredoc_hardnewline.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/parse_line_heredoc_regexp_chars.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/parse_line_iter_call_no_parens.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/parse_line_iter_call_parens.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/parse_line_multiline_str.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/parse_line_multiline_str_literal_n.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/parse_line_newlines.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/parse_line_op_asgn.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/parse_line_postexe.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/parse_line_preexe.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/parse_line_rescue.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/parse_line_return.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/parse_line_str_with_newline_escape.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/parse_line_to_ary.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/parse_line_trailing_newlines.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/parse_opt_call_args_assocs_comma.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/parse_opt_call_args_lit_comma.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/parse_pattern_019.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/parse_pattern_044.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/parse_pattern_051.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/parse_pattern_058.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/parse_pattern_058_2.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/parse_pattern_069.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/parse_pattern_076.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/parse_until_not_canonical.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/parse_until_not_noncanonical.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/parse_while_not_canonical.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/parse_while_not_noncanonical.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/pctW_lineno.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/pct_Q_backslash_nl.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/pct_nl.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/pct_w_heredoc_interp_nested.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/pipe_semicolon.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/pipe_space.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/qWords_space.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/qsymbols.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/qsymbols_empty.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/qsymbols_empty_space.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/qsymbols_interp.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/quoted_symbol_hash_arg.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/quoted_symbol_keys.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/qw_escape.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/qw_escape_term.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/qwords_empty.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/read_escape_unicode_curlies.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/read_escape_unicode_h4.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/regexp.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/regexp_esc_C_slash.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/regexp_esc_u.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/regexp_escape_extended.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/regexp_unicode_curlies.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/required_kwarg_no_value.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/rescue_do_end_ensure_result.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/rescue_do_end_no_raise.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/rescue_do_end_raised.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/rescue_do_end_rescued.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/rescue_in_block.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/rescue_parens.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/return_call_assocs.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/rhs_asgn.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/ruby21_numbers.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/safe_attrasgn.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/safe_attrasgn_constant.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/safe_call.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/safe_call_after_newline.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/safe_call_dot_parens.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/safe_call_newline.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/safe_call_operator.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/safe_call_rhs_newline.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/safe_calls.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/safe_op_asgn.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/safe_op_asgn2.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/slashy_newlines_within_string.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/stabby_arg_no_paren.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/stabby_arg_opt_splat_arg_block_omfg.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/stabby_block_iter_call.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/stabby_block_iter_call_no_target_with_arg.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/stabby_block_kw.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/stabby_block_kw__required.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/stabby_proc_scope.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/str_backslashes.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/str_double_double_escaped_newline.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/str_double_escaped_newline.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/str_double_newline.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/str_evstr.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/str_evstr_escape.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/str_heredoc_interp.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/str_interp_ternary_or_label.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/str_lit_concat_bad_encodings.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/str_newline_hash_line_number.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/str_pct_Q_nested.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/str_pct_nested_nested.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/str_pct_q.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/str_single_double_escaped_newline.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/str_single_escaped_newline.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/str_single_newline.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/str_str.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/str_str_str.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/super_arg.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/symbol_empty.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/symbol_list.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/symbols.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/symbols_empty.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/symbols_empty_space.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/symbols_interp.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/thingy.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/uminus_float.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/unary_minus.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/unary_plus.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/unary_plus_on_literal.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/unary_tilde.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/utf8_bom.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/when_splat.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/words_interp.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/yield_arg.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/yield_call_assocs.txt delete mode 100644 test/mri/prism/snapshots/seattlerb/yield_empty_parens.txt delete mode 100644 test/mri/prism/snapshots/single_method_call_with_bang.txt delete mode 100644 test/mri/prism/snapshots/single_quote_heredocs.txt delete mode 100644 test/mri/prism/snapshots/spanning_heredoc.txt delete mode 100644 test/mri/prism/snapshots/spanning_heredoc_newlines.txt delete mode 100644 test/mri/prism/snapshots/strings.txt delete mode 100644 test/mri/prism/snapshots/super.txt delete mode 100644 test/mri/prism/snapshots/symbols.txt delete mode 100644 test/mri/prism/snapshots/ternary_operator.txt delete mode 100644 test/mri/prism/snapshots/tilde_heredocs.txt delete mode 100644 test/mri/prism/snapshots/undef.txt delete mode 100644 test/mri/prism/snapshots/unescaping.txt delete mode 100644 test/mri/prism/snapshots/unless.txt delete mode 100644 test/mri/prism/snapshots/unparser/corpus/literal/alias.txt delete mode 100644 test/mri/prism/snapshots/unparser/corpus/literal/assignment.txt delete mode 100644 test/mri/prism/snapshots/unparser/corpus/literal/block.txt delete mode 100644 test/mri/prism/snapshots/unparser/corpus/literal/case.txt delete mode 100644 test/mri/prism/snapshots/unparser/corpus/literal/class.txt delete mode 100644 test/mri/prism/snapshots/unparser/corpus/literal/control.txt delete mode 100644 test/mri/prism/snapshots/unparser/corpus/literal/def.txt delete mode 100644 test/mri/prism/snapshots/unparser/corpus/literal/defined.txt delete mode 100644 test/mri/prism/snapshots/unparser/corpus/literal/defs.txt delete mode 100644 test/mri/prism/snapshots/unparser/corpus/literal/dstr.txt delete mode 100644 test/mri/prism/snapshots/unparser/corpus/literal/empty.txt delete mode 100644 test/mri/prism/snapshots/unparser/corpus/literal/empty_begin.txt delete mode 100644 test/mri/prism/snapshots/unparser/corpus/literal/flipflop.txt delete mode 100644 test/mri/prism/snapshots/unparser/corpus/literal/for.txt delete mode 100644 test/mri/prism/snapshots/unparser/corpus/literal/hookexe.txt delete mode 100644 test/mri/prism/snapshots/unparser/corpus/literal/if.txt delete mode 100644 test/mri/prism/snapshots/unparser/corpus/literal/kwbegin.txt delete mode 100644 test/mri/prism/snapshots/unparser/corpus/literal/lambda.txt delete mode 100644 test/mri/prism/snapshots/unparser/corpus/literal/literal.txt delete mode 100644 test/mri/prism/snapshots/unparser/corpus/literal/module.txt delete mode 100644 test/mri/prism/snapshots/unparser/corpus/literal/opasgn.txt delete mode 100644 test/mri/prism/snapshots/unparser/corpus/literal/pattern.txt delete mode 100644 test/mri/prism/snapshots/unparser/corpus/literal/pragma.txt delete mode 100644 test/mri/prism/snapshots/unparser/corpus/literal/range.txt delete mode 100644 test/mri/prism/snapshots/unparser/corpus/literal/rescue.txt delete mode 100644 test/mri/prism/snapshots/unparser/corpus/literal/send.txt delete mode 100644 test/mri/prism/snapshots/unparser/corpus/literal/since/27.txt delete mode 100644 test/mri/prism/snapshots/unparser/corpus/literal/since/30.txt delete mode 100644 test/mri/prism/snapshots/unparser/corpus/literal/since/31.txt delete mode 100644 test/mri/prism/snapshots/unparser/corpus/literal/since/32.txt delete mode 100644 test/mri/prism/snapshots/unparser/corpus/literal/singletons.txt delete mode 100644 test/mri/prism/snapshots/unparser/corpus/literal/super.txt delete mode 100644 test/mri/prism/snapshots/unparser/corpus/literal/unary.txt delete mode 100644 test/mri/prism/snapshots/unparser/corpus/literal/undef.txt delete mode 100644 test/mri/prism/snapshots/unparser/corpus/literal/variables.txt delete mode 100644 test/mri/prism/snapshots/unparser/corpus/literal/while.txt delete mode 100644 test/mri/prism/snapshots/unparser/corpus/literal/yield.txt delete mode 100644 test/mri/prism/snapshots/unparser/corpus/semantic/and.txt delete mode 100644 test/mri/prism/snapshots/unparser/corpus/semantic/block.txt delete mode 100644 test/mri/prism/snapshots/unparser/corpus/semantic/def.txt delete mode 100644 test/mri/prism/snapshots/unparser/corpus/semantic/dstr.txt delete mode 100644 test/mri/prism/snapshots/unparser/corpus/semantic/kwbegin.txt delete mode 100644 test/mri/prism/snapshots/unparser/corpus/semantic/literal.txt delete mode 100644 test/mri/prism/snapshots/unparser/corpus/semantic/send.txt delete mode 100644 test/mri/prism/snapshots/unparser/corpus/semantic/undef.txt delete mode 100644 test/mri/prism/snapshots/unparser/corpus/semantic/while.txt delete mode 100644 test/mri/prism/snapshots/until.txt delete mode 100644 test/mri/prism/snapshots/variables.txt delete mode 100644 test/mri/prism/snapshots/while.txt delete mode 100644 test/mri/prism/snapshots/whitequark/__ENCODING__.txt delete mode 100644 test/mri/prism/snapshots/whitequark/__ENCODING___legacy_.txt delete mode 100644 test/mri/prism/snapshots/whitequark/alias.txt delete mode 100644 test/mri/prism/snapshots/whitequark/alias_gvar.txt delete mode 100644 test/mri/prism/snapshots/whitequark/ambiuous_quoted_label_in_ternary_operator.txt delete mode 100644 test/mri/prism/snapshots/whitequark/and.txt delete mode 100644 test/mri/prism/snapshots/whitequark/and_asgn.txt delete mode 100644 test/mri/prism/snapshots/whitequark/and_or_masgn.txt delete mode 100644 test/mri/prism/snapshots/whitequark/anonymous_blockarg.txt delete mode 100644 test/mri/prism/snapshots/whitequark/arg.txt delete mode 100644 test/mri/prism/snapshots/whitequark/arg_duplicate_ignored.txt delete mode 100644 test/mri/prism/snapshots/whitequark/arg_label.txt delete mode 100644 test/mri/prism/snapshots/whitequark/arg_scope.txt delete mode 100644 test/mri/prism/snapshots/whitequark/args.txt delete mode 100644 test/mri/prism/snapshots/whitequark/args_args_assocs.txt delete mode 100644 test/mri/prism/snapshots/whitequark/args_args_assocs_comma.txt delete mode 100644 test/mri/prism/snapshots/whitequark/args_args_comma.txt delete mode 100644 test/mri/prism/snapshots/whitequark/args_args_star.txt delete mode 100644 test/mri/prism/snapshots/whitequark/args_assocs.txt delete mode 100644 test/mri/prism/snapshots/whitequark/args_assocs_comma.txt delete mode 100644 test/mri/prism/snapshots/whitequark/args_assocs_legacy.txt delete mode 100644 test/mri/prism/snapshots/whitequark/args_block_pass.txt delete mode 100644 test/mri/prism/snapshots/whitequark/args_cmd.txt delete mode 100644 test/mri/prism/snapshots/whitequark/args_star.txt delete mode 100644 test/mri/prism/snapshots/whitequark/array_assocs.txt delete mode 100644 test/mri/prism/snapshots/whitequark/array_plain.txt delete mode 100644 test/mri/prism/snapshots/whitequark/array_splat.txt delete mode 100644 test/mri/prism/snapshots/whitequark/array_symbols.txt delete mode 100644 test/mri/prism/snapshots/whitequark/array_symbols_empty.txt delete mode 100644 test/mri/prism/snapshots/whitequark/array_symbols_interp.txt delete mode 100644 test/mri/prism/snapshots/whitequark/array_words.txt delete mode 100644 test/mri/prism/snapshots/whitequark/array_words_empty.txt delete mode 100644 test/mri/prism/snapshots/whitequark/array_words_interp.txt delete mode 100644 test/mri/prism/snapshots/whitequark/asgn_cmd.txt delete mode 100644 test/mri/prism/snapshots/whitequark/asgn_mrhs.txt delete mode 100644 test/mri/prism/snapshots/whitequark/back_ref.txt delete mode 100644 test/mri/prism/snapshots/whitequark/bang.txt delete mode 100644 test/mri/prism/snapshots/whitequark/bang_cmd.txt delete mode 100644 test/mri/prism/snapshots/whitequark/begin_cmdarg.txt delete mode 100644 test/mri/prism/snapshots/whitequark/beginless_erange_after_newline.txt delete mode 100644 test/mri/prism/snapshots/whitequark/beginless_irange_after_newline.txt delete mode 100644 test/mri/prism/snapshots/whitequark/beginless_range.txt delete mode 100644 test/mri/prism/snapshots/whitequark/blockarg.txt delete mode 100644 test/mri/prism/snapshots/whitequark/blockargs.txt delete mode 100644 test/mri/prism/snapshots/whitequark/break.txt delete mode 100644 test/mri/prism/snapshots/whitequark/break_block.txt delete mode 100644 test/mri/prism/snapshots/whitequark/bug_435.txt delete mode 100644 test/mri/prism/snapshots/whitequark/bug_447.txt delete mode 100644 test/mri/prism/snapshots/whitequark/bug_452.txt delete mode 100644 test/mri/prism/snapshots/whitequark/bug_466.txt delete mode 100644 test/mri/prism/snapshots/whitequark/bug_473.txt delete mode 100644 test/mri/prism/snapshots/whitequark/bug_480.txt delete mode 100644 test/mri/prism/snapshots/whitequark/bug_481.txt delete mode 100644 test/mri/prism/snapshots/whitequark/bug_ascii_8bit_in_literal.txt delete mode 100644 test/mri/prism/snapshots/whitequark/bug_cmd_string_lookahead.txt delete mode 100644 test/mri/prism/snapshots/whitequark/bug_cmdarg.txt delete mode 100644 test/mri/prism/snapshots/whitequark/bug_def_no_paren_eql_begin.txt delete mode 100644 test/mri/prism/snapshots/whitequark/bug_do_block_in_call_args.txt delete mode 100644 test/mri/prism/snapshots/whitequark/bug_do_block_in_cmdarg.txt delete mode 100644 test/mri/prism/snapshots/whitequark/bug_do_block_in_hash_brace.txt delete mode 100644 test/mri/prism/snapshots/whitequark/bug_heredoc_do.txt delete mode 100644 test/mri/prism/snapshots/whitequark/bug_interp_single.txt delete mode 100644 test/mri/prism/snapshots/whitequark/bug_lambda_leakage.txt delete mode 100644 test/mri/prism/snapshots/whitequark/bug_regex_verification.txt delete mode 100644 test/mri/prism/snapshots/whitequark/bug_rescue_empty_else.txt delete mode 100644 test/mri/prism/snapshots/whitequark/bug_while_not_parens_do.txt delete mode 100644 test/mri/prism/snapshots/whitequark/case_cond.txt delete mode 100644 test/mri/prism/snapshots/whitequark/case_cond_else.txt delete mode 100644 test/mri/prism/snapshots/whitequark/case_expr.txt delete mode 100644 test/mri/prism/snapshots/whitequark/case_expr_else.txt delete mode 100644 test/mri/prism/snapshots/whitequark/casgn_scoped.txt delete mode 100644 test/mri/prism/snapshots/whitequark/casgn_toplevel.txt delete mode 100644 test/mri/prism/snapshots/whitequark/casgn_unscoped.txt delete mode 100644 test/mri/prism/snapshots/whitequark/character.txt delete mode 100644 test/mri/prism/snapshots/whitequark/class.txt delete mode 100644 test/mri/prism/snapshots/whitequark/class_definition_in_while_cond.txt delete mode 100644 test/mri/prism/snapshots/whitequark/class_super.txt delete mode 100644 test/mri/prism/snapshots/whitequark/class_super_label.txt delete mode 100644 test/mri/prism/snapshots/whitequark/comments_before_leading_dot__27.txt delete mode 100644 test/mri/prism/snapshots/whitequark/complex.txt delete mode 100644 test/mri/prism/snapshots/whitequark/cond_begin.txt delete mode 100644 test/mri/prism/snapshots/whitequark/cond_begin_masgn.txt delete mode 100644 test/mri/prism/snapshots/whitequark/cond_eflipflop.txt delete mode 100644 test/mri/prism/snapshots/whitequark/cond_iflipflop.txt delete mode 100644 test/mri/prism/snapshots/whitequark/cond_match_current_line.txt delete mode 100644 test/mri/prism/snapshots/whitequark/const_op_asgn.txt delete mode 100644 test/mri/prism/snapshots/whitequark/const_scoped.txt delete mode 100644 test/mri/prism/snapshots/whitequark/const_toplevel.txt delete mode 100644 test/mri/prism/snapshots/whitequark/const_unscoped.txt delete mode 100644 test/mri/prism/snapshots/whitequark/cpath.txt delete mode 100644 test/mri/prism/snapshots/whitequark/cvar.txt delete mode 100644 test/mri/prism/snapshots/whitequark/cvasgn.txt delete mode 100644 test/mri/prism/snapshots/whitequark/dedenting_heredoc.txt delete mode 100644 test/mri/prism/snapshots/whitequark/dedenting_interpolating_heredoc_fake_line_continuation.txt delete mode 100644 test/mri/prism/snapshots/whitequark/dedenting_non_interpolating_heredoc_line_continuation.txt delete mode 100644 test/mri/prism/snapshots/whitequark/def.txt delete mode 100644 test/mri/prism/snapshots/whitequark/defined.txt delete mode 100644 test/mri/prism/snapshots/whitequark/defs.txt delete mode 100644 test/mri/prism/snapshots/whitequark/empty_stmt.txt delete mode 100644 test/mri/prism/snapshots/whitequark/endless_comparison_method.txt delete mode 100644 test/mri/prism/snapshots/whitequark/endless_method.txt delete mode 100644 test/mri/prism/snapshots/whitequark/endless_method_command_syntax.txt delete mode 100644 test/mri/prism/snapshots/whitequark/endless_method_forwarded_args_legacy.txt delete mode 100644 test/mri/prism/snapshots/whitequark/endless_method_with_rescue_mod.txt delete mode 100644 test/mri/prism/snapshots/whitequark/endless_method_without_args.txt delete mode 100644 test/mri/prism/snapshots/whitequark/ensure.txt delete mode 100644 test/mri/prism/snapshots/whitequark/ensure_empty.txt delete mode 100644 test/mri/prism/snapshots/whitequark/false.txt delete mode 100644 test/mri/prism/snapshots/whitequark/float.txt delete mode 100644 test/mri/prism/snapshots/whitequark/for.txt delete mode 100644 test/mri/prism/snapshots/whitequark/for_mlhs.txt delete mode 100644 test/mri/prism/snapshots/whitequark/forward_arg.txt delete mode 100644 test/mri/prism/snapshots/whitequark/forward_arg_with_open_args.txt delete mode 100644 test/mri/prism/snapshots/whitequark/forward_args_legacy.txt delete mode 100644 test/mri/prism/snapshots/whitequark/forwarded_argument_with_kwrestarg.txt delete mode 100644 test/mri/prism/snapshots/whitequark/forwarded_argument_with_restarg.txt delete mode 100644 test/mri/prism/snapshots/whitequark/forwarded_kwrestarg.txt delete mode 100644 test/mri/prism/snapshots/whitequark/forwarded_kwrestarg_with_additional_kwarg.txt delete mode 100644 test/mri/prism/snapshots/whitequark/forwarded_restarg.txt delete mode 100644 test/mri/prism/snapshots/whitequark/gvar.txt delete mode 100644 test/mri/prism/snapshots/whitequark/gvasgn.txt delete mode 100644 test/mri/prism/snapshots/whitequark/hash_empty.txt delete mode 100644 test/mri/prism/snapshots/whitequark/hash_hashrocket.txt delete mode 100644 test/mri/prism/snapshots/whitequark/hash_kwsplat.txt delete mode 100644 test/mri/prism/snapshots/whitequark/hash_label.txt delete mode 100644 test/mri/prism/snapshots/whitequark/hash_label_end.txt delete mode 100644 test/mri/prism/snapshots/whitequark/hash_pair_value_omission.txt delete mode 100644 test/mri/prism/snapshots/whitequark/heredoc.txt delete mode 100644 test/mri/prism/snapshots/whitequark/if.txt delete mode 100644 test/mri/prism/snapshots/whitequark/if_else.txt delete mode 100644 test/mri/prism/snapshots/whitequark/if_elsif.txt delete mode 100644 test/mri/prism/snapshots/whitequark/if_masgn__24.txt delete mode 100644 test/mri/prism/snapshots/whitequark/if_mod.txt delete mode 100644 test/mri/prism/snapshots/whitequark/if_nl_then.txt delete mode 100644 test/mri/prism/snapshots/whitequark/if_while_after_class__since_32.txt delete mode 100644 test/mri/prism/snapshots/whitequark/int.txt delete mode 100644 test/mri/prism/snapshots/whitequark/int___LINE__.txt delete mode 100644 test/mri/prism/snapshots/whitequark/interp_digit_var.txt delete mode 100644 test/mri/prism/snapshots/whitequark/ivar.txt delete mode 100644 test/mri/prism/snapshots/whitequark/ivasgn.txt delete mode 100644 test/mri/prism/snapshots/whitequark/keyword_argument_omission.txt delete mode 100644 test/mri/prism/snapshots/whitequark/kwarg.txt delete mode 100644 test/mri/prism/snapshots/whitequark/kwbegin_compstmt.txt delete mode 100644 test/mri/prism/snapshots/whitequark/kwnilarg.txt delete mode 100644 test/mri/prism/snapshots/whitequark/kwoptarg.txt delete mode 100644 test/mri/prism/snapshots/whitequark/kwoptarg_with_kwrestarg_and_forwarded_args.txt delete mode 100644 test/mri/prism/snapshots/whitequark/kwrestarg_named.txt delete mode 100644 test/mri/prism/snapshots/whitequark/kwrestarg_unnamed.txt delete mode 100644 test/mri/prism/snapshots/whitequark/lbrace_arg_after_command_args.txt delete mode 100644 test/mri/prism/snapshots/whitequark/lparenarg_after_lvar__since_25.txt delete mode 100644 test/mri/prism/snapshots/whitequark/lvar.txt delete mode 100644 test/mri/prism/snapshots/whitequark/lvar_injecting_match.txt delete mode 100644 test/mri/prism/snapshots/whitequark/lvasgn.txt delete mode 100644 test/mri/prism/snapshots/whitequark/masgn.txt delete mode 100644 test/mri/prism/snapshots/whitequark/masgn_attr.txt delete mode 100644 test/mri/prism/snapshots/whitequark/masgn_cmd.txt delete mode 100644 test/mri/prism/snapshots/whitequark/masgn_const.txt delete mode 100644 test/mri/prism/snapshots/whitequark/masgn_nested.txt delete mode 100644 test/mri/prism/snapshots/whitequark/masgn_splat.txt delete mode 100644 test/mri/prism/snapshots/whitequark/method_definition_in_while_cond.txt delete mode 100644 test/mri/prism/snapshots/whitequark/module.txt delete mode 100644 test/mri/prism/snapshots/whitequark/multiple_pattern_matches.txt delete mode 100644 test/mri/prism/snapshots/whitequark/newline_in_hash_argument.txt delete mode 100644 test/mri/prism/snapshots/whitequark/next.txt delete mode 100644 test/mri/prism/snapshots/whitequark/next_block.txt delete mode 100644 test/mri/prism/snapshots/whitequark/nil.txt delete mode 100644 test/mri/prism/snapshots/whitequark/nil_expression.txt delete mode 100644 test/mri/prism/snapshots/whitequark/non_lvar_injecting_match.txt delete mode 100644 test/mri/prism/snapshots/whitequark/not.txt delete mode 100644 test/mri/prism/snapshots/whitequark/not_cmd.txt delete mode 100644 test/mri/prism/snapshots/whitequark/not_masgn__24.txt delete mode 100644 test/mri/prism/snapshots/whitequark/nth_ref.txt delete mode 100644 test/mri/prism/snapshots/whitequark/numbered_args_after_27.txt delete mode 100644 test/mri/prism/snapshots/whitequark/numparam_outside_block.txt delete mode 100644 test/mri/prism/snapshots/whitequark/op_asgn.txt delete mode 100644 test/mri/prism/snapshots/whitequark/op_asgn_cmd.txt delete mode 100644 test/mri/prism/snapshots/whitequark/op_asgn_index.txt delete mode 100644 test/mri/prism/snapshots/whitequark/op_asgn_index_cmd.txt delete mode 100644 test/mri/prism/snapshots/whitequark/optarg.txt delete mode 100644 test/mri/prism/snapshots/whitequark/or.txt delete mode 100644 test/mri/prism/snapshots/whitequark/or_asgn.txt delete mode 100644 test/mri/prism/snapshots/whitequark/parser_bug_272.txt delete mode 100644 test/mri/prism/snapshots/whitequark/parser_bug_490.txt delete mode 100644 test/mri/prism/snapshots/whitequark/parser_bug_507.txt delete mode 100644 test/mri/prism/snapshots/whitequark/parser_bug_518.txt delete mode 100644 test/mri/prism/snapshots/whitequark/parser_bug_525.txt delete mode 100644 test/mri/prism/snapshots/whitequark/parser_bug_604.txt delete mode 100644 test/mri/prism/snapshots/whitequark/parser_bug_640.txt delete mode 100644 test/mri/prism/snapshots/whitequark/parser_bug_645.txt delete mode 100644 test/mri/prism/snapshots/whitequark/parser_bug_830.txt delete mode 100644 test/mri/prism/snapshots/whitequark/parser_drops_truncated_parts_of_squiggly_heredoc.txt delete mode 100644 test/mri/prism/snapshots/whitequark/parser_slash_slash_n_escaping_in_literals.txt delete mode 100644 test/mri/prism/snapshots/whitequark/pattern_matching__FILE__LINE_literals.txt delete mode 100644 test/mri/prism/snapshots/whitequark/pattern_matching_blank_else.txt delete mode 100644 test/mri/prism/snapshots/whitequark/pattern_matching_else.txt delete mode 100644 test/mri/prism/snapshots/whitequark/pattern_matching_single_line.txt delete mode 100644 test/mri/prism/snapshots/whitequark/pattern_matching_single_line_allowed_omission_of_parentheses.txt delete mode 100644 test/mri/prism/snapshots/whitequark/postexe.txt delete mode 100644 test/mri/prism/snapshots/whitequark/preexe.txt delete mode 100644 test/mri/prism/snapshots/whitequark/procarg0.txt delete mode 100644 test/mri/prism/snapshots/whitequark/range_exclusive.txt delete mode 100644 test/mri/prism/snapshots/whitequark/range_inclusive.txt delete mode 100644 test/mri/prism/snapshots/whitequark/rational.txt delete mode 100644 test/mri/prism/snapshots/whitequark/redo.txt delete mode 100644 test/mri/prism/snapshots/whitequark/regex_interp.txt delete mode 100644 test/mri/prism/snapshots/whitequark/regex_plain.txt delete mode 100644 test/mri/prism/snapshots/whitequark/resbody_list.txt delete mode 100644 test/mri/prism/snapshots/whitequark/resbody_list_mrhs.txt delete mode 100644 test/mri/prism/snapshots/whitequark/resbody_list_var.txt delete mode 100644 test/mri/prism/snapshots/whitequark/resbody_var.txt delete mode 100644 test/mri/prism/snapshots/whitequark/rescue.txt delete mode 100644 test/mri/prism/snapshots/whitequark/rescue_else.txt delete mode 100644 test/mri/prism/snapshots/whitequark/rescue_else_ensure.txt delete mode 100644 test/mri/prism/snapshots/whitequark/rescue_ensure.txt delete mode 100644 test/mri/prism/snapshots/whitequark/rescue_in_lambda_block.txt delete mode 100644 test/mri/prism/snapshots/whitequark/rescue_mod.txt delete mode 100644 test/mri/prism/snapshots/whitequark/rescue_mod_asgn.txt delete mode 100644 test/mri/prism/snapshots/whitequark/rescue_mod_masgn.txt delete mode 100644 test/mri/prism/snapshots/whitequark/rescue_mod_op_assign.txt delete mode 100644 test/mri/prism/snapshots/whitequark/rescue_without_begin_end.txt delete mode 100644 test/mri/prism/snapshots/whitequark/restarg_named.txt delete mode 100644 test/mri/prism/snapshots/whitequark/restarg_unnamed.txt delete mode 100644 test/mri/prism/snapshots/whitequark/retry.txt delete mode 100644 test/mri/prism/snapshots/whitequark/return.txt delete mode 100644 test/mri/prism/snapshots/whitequark/return_block.txt delete mode 100644 test/mri/prism/snapshots/whitequark/ruby_bug_10279.txt delete mode 100644 test/mri/prism/snapshots/whitequark/ruby_bug_10653.txt delete mode 100644 test/mri/prism/snapshots/whitequark/ruby_bug_11107.txt delete mode 100644 test/mri/prism/snapshots/whitequark/ruby_bug_11380.txt delete mode 100644 test/mri/prism/snapshots/whitequark/ruby_bug_11873.txt delete mode 100644 test/mri/prism/snapshots/whitequark/ruby_bug_11873_a.txt delete mode 100644 test/mri/prism/snapshots/whitequark/ruby_bug_11873_b.txt delete mode 100644 test/mri/prism/snapshots/whitequark/ruby_bug_11989.txt delete mode 100644 test/mri/prism/snapshots/whitequark/ruby_bug_11990.txt delete mode 100644 test/mri/prism/snapshots/whitequark/ruby_bug_12073.txt delete mode 100644 test/mri/prism/snapshots/whitequark/ruby_bug_12402.txt delete mode 100644 test/mri/prism/snapshots/whitequark/ruby_bug_12669.txt delete mode 100644 test/mri/prism/snapshots/whitequark/ruby_bug_12686.txt delete mode 100644 test/mri/prism/snapshots/whitequark/ruby_bug_13547.txt delete mode 100644 test/mri/prism/snapshots/whitequark/ruby_bug_14690.txt delete mode 100644 test/mri/prism/snapshots/whitequark/ruby_bug_15789.txt delete mode 100644 test/mri/prism/snapshots/whitequark/ruby_bug_9669.txt delete mode 100644 test/mri/prism/snapshots/whitequark/sclass.txt delete mode 100644 test/mri/prism/snapshots/whitequark/self.txt delete mode 100644 test/mri/prism/snapshots/whitequark/send_attr_asgn.txt delete mode 100644 test/mri/prism/snapshots/whitequark/send_attr_asgn_conditional.txt delete mode 100644 test/mri/prism/snapshots/whitequark/send_binary_op.txt delete mode 100644 test/mri/prism/snapshots/whitequark/send_block_chain_cmd.txt delete mode 100644 test/mri/prism/snapshots/whitequark/send_block_conditional.txt delete mode 100644 test/mri/prism/snapshots/whitequark/send_call.txt delete mode 100644 test/mri/prism/snapshots/whitequark/send_conditional.txt delete mode 100644 test/mri/prism/snapshots/whitequark/send_index.txt delete mode 100644 test/mri/prism/snapshots/whitequark/send_index_asgn.txt delete mode 100644 test/mri/prism/snapshots/whitequark/send_index_asgn_legacy.txt delete mode 100644 test/mri/prism/snapshots/whitequark/send_index_cmd.txt delete mode 100644 test/mri/prism/snapshots/whitequark/send_index_legacy.txt delete mode 100644 test/mri/prism/snapshots/whitequark/send_lambda.txt delete mode 100644 test/mri/prism/snapshots/whitequark/send_lambda_args.txt delete mode 100644 test/mri/prism/snapshots/whitequark/send_lambda_args_noparen.txt delete mode 100644 test/mri/prism/snapshots/whitequark/send_lambda_args_shadow.txt delete mode 100644 test/mri/prism/snapshots/whitequark/send_lambda_legacy.txt delete mode 100644 test/mri/prism/snapshots/whitequark/send_op_asgn_conditional.txt delete mode 100644 test/mri/prism/snapshots/whitequark/send_plain.txt delete mode 100644 test/mri/prism/snapshots/whitequark/send_plain_cmd.txt delete mode 100644 test/mri/prism/snapshots/whitequark/send_self.txt delete mode 100644 test/mri/prism/snapshots/whitequark/send_self_block.txt delete mode 100644 test/mri/prism/snapshots/whitequark/send_unary_op.txt delete mode 100644 test/mri/prism/snapshots/whitequark/slash_newline_in_heredocs.txt delete mode 100644 test/mri/prism/snapshots/whitequark/space_args_arg.txt delete mode 100644 test/mri/prism/snapshots/whitequark/space_args_arg_block.txt delete mode 100644 test/mri/prism/snapshots/whitequark/space_args_arg_call.txt delete mode 100644 test/mri/prism/snapshots/whitequark/space_args_arg_newline.txt delete mode 100644 test/mri/prism/snapshots/whitequark/space_args_block.txt delete mode 100644 test/mri/prism/snapshots/whitequark/space_args_cmd.txt delete mode 100644 test/mri/prism/snapshots/whitequark/string___FILE__.txt delete mode 100644 test/mri/prism/snapshots/whitequark/string_concat.txt delete mode 100644 test/mri/prism/snapshots/whitequark/string_dvar.txt delete mode 100644 test/mri/prism/snapshots/whitequark/string_interp.txt delete mode 100644 test/mri/prism/snapshots/whitequark/string_plain.txt delete mode 100644 test/mri/prism/snapshots/whitequark/super.txt delete mode 100644 test/mri/prism/snapshots/whitequark/super_block.txt delete mode 100644 test/mri/prism/snapshots/whitequark/symbol_interp.txt delete mode 100644 test/mri/prism/snapshots/whitequark/symbol_plain.txt delete mode 100644 test/mri/prism/snapshots/whitequark/ternary.txt delete mode 100644 test/mri/prism/snapshots/whitequark/ternary_ambiguous_symbol.txt delete mode 100644 test/mri/prism/snapshots/whitequark/trailing_forward_arg.txt delete mode 100644 test/mri/prism/snapshots/whitequark/true.txt delete mode 100644 test/mri/prism/snapshots/whitequark/unary_num_pow_precedence.txt delete mode 100644 test/mri/prism/snapshots/whitequark/undef.txt delete mode 100644 test/mri/prism/snapshots/whitequark/unless.txt delete mode 100644 test/mri/prism/snapshots/whitequark/unless_else.txt delete mode 100644 test/mri/prism/snapshots/whitequark/unless_mod.txt delete mode 100644 test/mri/prism/snapshots/whitequark/until.txt delete mode 100644 test/mri/prism/snapshots/whitequark/until_mod.txt delete mode 100644 test/mri/prism/snapshots/whitequark/until_post.txt delete mode 100644 test/mri/prism/snapshots/whitequark/var_and_asgn.txt delete mode 100644 test/mri/prism/snapshots/whitequark/var_op_asgn.txt delete mode 100644 test/mri/prism/snapshots/whitequark/var_op_asgn_cmd.txt delete mode 100644 test/mri/prism/snapshots/whitequark/var_or_asgn.txt delete mode 100644 test/mri/prism/snapshots/whitequark/when_multi.txt delete mode 100644 test/mri/prism/snapshots/whitequark/when_splat.txt delete mode 100644 test/mri/prism/snapshots/whitequark/when_then.txt delete mode 100644 test/mri/prism/snapshots/whitequark/while.txt delete mode 100644 test/mri/prism/snapshots/whitequark/while_mod.txt delete mode 100644 test/mri/prism/snapshots/whitequark/while_post.txt delete mode 100644 test/mri/prism/snapshots/whitequark/xstring_interp.txt delete mode 100644 test/mri/prism/snapshots/whitequark/xstring_plain.txt delete mode 100644 test/mri/prism/snapshots/whitequark/yield.txt delete mode 100644 test/mri/prism/snapshots/whitequark/zsuper.txt delete mode 100644 test/mri/prism/snapshots/xstring.txt delete mode 100644 test/mri/prism/snapshots/xstring_with_backslash.txt delete mode 100644 test/mri/prism/snapshots/yield.txt delete mode 100644 test/mri/prism/static_inspect_test.rb delete mode 100644 test/mri/prism/static_literals_test.rb delete mode 100644 test/mri/prism/warnings_test.rb delete mode 100644 test/mri/rdoc/rdoc/MarkdownTest_1.0.3/Amps and angle encoding.text delete mode 100644 test/mri/rdoc/rdoc/MarkdownTest_1.0.3/Auto links.text delete mode 100644 test/mri/rdoc/rdoc/MarkdownTest_1.0.3/Backslash escapes.text delete mode 100644 test/mri/rdoc/rdoc/MarkdownTest_1.0.3/Blockquotes with code blocks.text delete mode 100644 test/mri/rdoc/rdoc/MarkdownTest_1.0.3/Code Blocks.text delete mode 100644 test/mri/rdoc/rdoc/MarkdownTest_1.0.3/Code Spans.text delete mode 100644 test/mri/rdoc/rdoc/MarkdownTest_1.0.3/Hard-wrapped paragraphs with list-like lines.text delete mode 100644 test/mri/rdoc/rdoc/MarkdownTest_1.0.3/Horizontal rules.text delete mode 100644 test/mri/rdoc/rdoc/MarkdownTest_1.0.3/Inline HTML (Advanced).text delete mode 100644 test/mri/rdoc/rdoc/MarkdownTest_1.0.3/Inline HTML (Simple).text delete mode 100644 test/mri/rdoc/rdoc/MarkdownTest_1.0.3/Inline HTML comments.text delete mode 100644 test/mri/rdoc/rdoc/MarkdownTest_1.0.3/Links, inline style.text delete mode 100644 test/mri/rdoc/rdoc/MarkdownTest_1.0.3/Links, reference style.text delete mode 100644 test/mri/rdoc/rdoc/MarkdownTest_1.0.3/Links, shortcut references.text delete mode 100644 test/mri/rdoc/rdoc/MarkdownTest_1.0.3/Literal quotes in titles.text delete mode 100644 test/mri/rdoc/rdoc/MarkdownTest_1.0.3/Markdown Documentation - Basics.text delete mode 100644 test/mri/rdoc/rdoc/MarkdownTest_1.0.3/Markdown Documentation - Syntax.text delete mode 100644 test/mri/rdoc/rdoc/MarkdownTest_1.0.3/Nested blockquotes.text delete mode 100644 test/mri/rdoc/rdoc/MarkdownTest_1.0.3/Ordered and unordered lists.text delete mode 100644 test/mri/rdoc/rdoc/MarkdownTest_1.0.3/Strong and em together.text delete mode 100644 test/mri/rdoc/rdoc/MarkdownTest_1.0.3/Tabs.text delete mode 100644 test/mri/rdoc/rdoc/MarkdownTest_1.0.3/Tidiness.text delete mode 100644 test/mri/rdoc/rdoc/README delete mode 100644 test/mri/rdoc/rdoc/binary.dat delete mode 100644 test/mri/rdoc/rdoc/helper.rb delete mode 100644 test/mri/rdoc/rdoc/hidden.zip.txt delete mode 100644 test/mri/rdoc/rdoc/rdoc_alias_test.rb delete mode 100644 test/mri/rdoc/rdoc/rdoc_any_method_test.rb delete mode 100644 test/mri/rdoc/rdoc/rdoc_attr_test.rb delete mode 100644 test/mri/rdoc/rdoc/rdoc_class_module_test.rb delete mode 100644 test/mri/rdoc/rdoc/rdoc_code_object_test.rb delete mode 100644 test/mri/rdoc/rdoc/rdoc_comment_test.rb delete mode 100644 test/mri/rdoc/rdoc/rdoc_constant_test.rb delete mode 100644 test/mri/rdoc/rdoc/rdoc_context_section_test.rb delete mode 100644 test/mri/rdoc/rdoc/rdoc_context_test.rb delete mode 100644 test/mri/rdoc/rdoc/rdoc_cross_reference_test.rb delete mode 100644 test/mri/rdoc/rdoc/rdoc_encoding_test.rb delete mode 100644 test/mri/rdoc/rdoc/rdoc_extend_test.rb delete mode 100644 test/mri/rdoc/rdoc/rdoc_generator_darkfish_test.rb delete mode 100644 test/mri/rdoc/rdoc/rdoc_generator_json_index_test.rb delete mode 100644 test/mri/rdoc/rdoc/rdoc_generator_markup_test.rb delete mode 100644 test/mri/rdoc/rdoc/rdoc_generator_pot_po_entry_test.rb delete mode 100644 test/mri/rdoc/rdoc/rdoc_generator_pot_po_test.rb delete mode 100644 test/mri/rdoc/rdoc/rdoc_generator_pot_test.rb delete mode 100644 test/mri/rdoc/rdoc/rdoc_generator_ri_test.rb delete mode 100644 test/mri/rdoc/rdoc/rdoc_i18n_locale_test.rb delete mode 100644 test/mri/rdoc/rdoc/rdoc_i18n_text_test.rb delete mode 100644 test/mri/rdoc/rdoc/rdoc_include_test.rb delete mode 100644 test/mri/rdoc/rdoc/rdoc_markdown_test.rb delete mode 100644 test/mri/rdoc/rdoc/rdoc_markdown_test_test.rb delete mode 100644 test/mri/rdoc/rdoc/rdoc_markup_attribute_manager_test.rb delete mode 100644 test/mri/rdoc/rdoc/rdoc_markup_attributes_test.rb delete mode 100644 test/mri/rdoc/rdoc/rdoc_markup_document_test.rb delete mode 100644 test/mri/rdoc/rdoc/rdoc_markup_formatter_test.rb delete mode 100644 test/mri/rdoc/rdoc/rdoc_markup_hard_break_test.rb delete mode 100644 test/mri/rdoc/rdoc/rdoc_markup_heading_test.rb delete mode 100644 test/mri/rdoc/rdoc/rdoc_markup_include_test.rb delete mode 100644 test/mri/rdoc/rdoc/rdoc_markup_indented_paragraph_test.rb delete mode 100644 test/mri/rdoc/rdoc/rdoc_markup_paragraph_test.rb delete mode 100644 test/mri/rdoc/rdoc/rdoc_markup_parser_test.rb delete mode 100644 test/mri/rdoc/rdoc/rdoc_markup_pre_process_test.rb delete mode 100644 test/mri/rdoc/rdoc/rdoc_markup_raw_test.rb delete mode 100644 test/mri/rdoc/rdoc/rdoc_markup_test.rb delete mode 100644 test/mri/rdoc/rdoc/rdoc_markup_to_ansi_test.rb delete mode 100644 test/mri/rdoc/rdoc/rdoc_markup_to_bs_test.rb delete mode 100644 test/mri/rdoc/rdoc/rdoc_markup_to_html_crossref_test.rb delete mode 100644 test/mri/rdoc/rdoc/rdoc_markup_to_html_snippet_test.rb delete mode 100644 test/mri/rdoc/rdoc/rdoc_markup_to_html_test.rb delete mode 100644 test/mri/rdoc/rdoc/rdoc_markup_to_joined_paragraph_test.rb delete mode 100644 test/mri/rdoc/rdoc/rdoc_markup_to_label_test.rb delete mode 100644 test/mri/rdoc/rdoc/rdoc_markup_to_markdown_test.rb delete mode 100644 test/mri/rdoc/rdoc/rdoc_markup_to_rdoc_test.rb delete mode 100644 test/mri/rdoc/rdoc/rdoc_markup_to_table_of_contents_test.rb delete mode 100644 test/mri/rdoc/rdoc/rdoc_markup_to_tt_only_test.rb delete mode 100644 test/mri/rdoc/rdoc/rdoc_markup_verbatim_test.rb delete mode 100644 test/mri/rdoc/rdoc/rdoc_method_attr_test.rb delete mode 100644 test/mri/rdoc/rdoc/rdoc_normal_class_test.rb delete mode 100644 test/mri/rdoc/rdoc/rdoc_normal_module_test.rb delete mode 100644 test/mri/rdoc/rdoc/rdoc_options_test.rb delete mode 100644 test/mri/rdoc/rdoc/rdoc_parser_c_test.rb delete mode 100644 test/mri/rdoc/rdoc/rdoc_parser_changelog_test.rb delete mode 100644 test/mri/rdoc/rdoc/rdoc_parser_markdown_test.rb delete mode 100644 test/mri/rdoc/rdoc/rdoc_parser_prism_ruby_test.rb delete mode 100644 test/mri/rdoc/rdoc/rdoc_parser_rd_test.rb delete mode 100644 test/mri/rdoc/rdoc/rdoc_parser_ruby_test.rb delete mode 100644 test/mri/rdoc/rdoc/rdoc_parser_simple_test.rb delete mode 100644 test/mri/rdoc/rdoc/rdoc_parser_test.rb delete mode 100644 test/mri/rdoc/rdoc/rdoc_rd_block_parser_test.rb delete mode 100644 test/mri/rdoc/rdoc/rdoc_rd_inline_parser_test.rb delete mode 100644 test/mri/rdoc/rdoc/rdoc_rd_inline_test.rb delete mode 100644 test/mri/rdoc/rdoc/rdoc_rd_test.rb delete mode 100644 test/mri/rdoc/rdoc/rdoc_rdoc_test.rb delete mode 100644 test/mri/rdoc/rdoc/rdoc_require_test.rb delete mode 100644 test/mri/rdoc/rdoc/rdoc_ri_driver_test.rb delete mode 100644 test/mri/rdoc/rdoc/rdoc_ri_paths_test.rb delete mode 100644 test/mri/rdoc/rdoc/rdoc_rubygems_hook_test.rb delete mode 100644 test/mri/rdoc/rdoc/rdoc_servlet_test.rb delete mode 100644 test/mri/rdoc/rdoc/rdoc_single_class_test.rb delete mode 100644 test/mri/rdoc/rdoc/rdoc_stats_test.rb delete mode 100644 test/mri/rdoc/rdoc/rdoc_store_test.rb delete mode 100644 test/mri/rdoc/rdoc/rdoc_task_test.rb delete mode 100644 test/mri/rdoc/rdoc/rdoc_text_test.rb delete mode 100644 test/mri/rdoc/rdoc/rdoc_token_stream_test.rb delete mode 100644 test/mri/rdoc/rdoc/rdoc_tom_doc_test.rb delete mode 100644 test/mri/rdoc/rdoc/rdoc_top_level_test.rb delete mode 100644 test/mri/rdoc/rdoc/support/formatter_test_case.rb delete mode 100644 test/mri/rdoc/rdoc/support/test_case.rb delete mode 100644 test/mri/rdoc/rdoc/support/text_formatter_test_case.rb delete mode 100644 test/mri/rdoc/rdoc/test.ja.largedoc delete mode 100644 test/mri/rdoc/rdoc/test.ja.rdoc delete mode 100644 test/mri/rdoc/rdoc/test.ja.txt delete mode 100644 test/mri/rdoc/rdoc/test.txt delete mode 100644 test/mri/rdoc/rdoc/xref_data.rb delete mode 100644 test/mri/rdoc/rdoc/xref_test_case.rb delete mode 100644 test/mri/rdoc/rdoc_alias_test.rb delete mode 100644 test/mri/rdoc/rdoc_any_method_test.rb delete mode 100644 test/mri/rdoc/rdoc_attr_test.rb delete mode 100644 test/mri/rdoc/rdoc_class_module_test.rb delete mode 100644 test/mri/rdoc/rdoc_code_object_test.rb delete mode 100644 test/mri/rdoc/rdoc_comment_test.rb delete mode 100644 test/mri/rdoc/rdoc_constant_test.rb delete mode 100644 test/mri/rdoc/rdoc_context_section_test.rb delete mode 100644 test/mri/rdoc/rdoc_context_test.rb delete mode 100644 test/mri/rdoc/rdoc_cross_reference_test.rb delete mode 100644 test/mri/rdoc/rdoc_encoding_test.rb delete mode 100644 test/mri/rdoc/rdoc_extend_test.rb delete mode 100644 test/mri/rdoc/rdoc_generator_darkfish_test.rb delete mode 100644 test/mri/rdoc/rdoc_generator_json_index_test.rb delete mode 100644 test/mri/rdoc/rdoc_generator_markup_test.rb delete mode 100644 test/mri/rdoc/rdoc_generator_pot_po_entry_test.rb delete mode 100644 test/mri/rdoc/rdoc_generator_pot_po_test.rb delete mode 100644 test/mri/rdoc/rdoc_generator_pot_test.rb delete mode 100644 test/mri/rdoc/rdoc_generator_ri_test.rb delete mode 100644 test/mri/rdoc/rdoc_i18n_locale_test.rb delete mode 100644 test/mri/rdoc/rdoc_i18n_text_test.rb delete mode 100644 test/mri/rdoc/rdoc_include_test.rb delete mode 100644 test/mri/rdoc/rdoc_markdown_test.rb delete mode 100644 test/mri/rdoc/rdoc_markdown_test_test.rb delete mode 100644 test/mri/rdoc/rdoc_markup_attribute_manager_test.rb delete mode 100644 test/mri/rdoc/rdoc_markup_attributes_test.rb delete mode 100644 test/mri/rdoc/rdoc_markup_document_test.rb delete mode 100644 test/mri/rdoc/rdoc_markup_formatter_test.rb delete mode 100644 test/mri/rdoc/rdoc_markup_hard_break_test.rb delete mode 100644 test/mri/rdoc/rdoc_markup_heading_test.rb delete mode 100644 test/mri/rdoc/rdoc_markup_include_test.rb delete mode 100644 test/mri/rdoc/rdoc_markup_indented_paragraph_test.rb delete mode 100644 test/mri/rdoc/rdoc_markup_paragraph_test.rb delete mode 100644 test/mri/rdoc/rdoc_markup_parser_test.rb delete mode 100644 test/mri/rdoc/rdoc_markup_pre_process_test.rb delete mode 100644 test/mri/rdoc/rdoc_markup_raw_test.rb delete mode 100644 test/mri/rdoc/rdoc_markup_test.rb delete mode 100644 test/mri/rdoc/rdoc_markup_to_ansi_test.rb delete mode 100644 test/mri/rdoc/rdoc_markup_to_bs_test.rb delete mode 100644 test/mri/rdoc/rdoc_markup_to_html_crossref_test.rb delete mode 100644 test/mri/rdoc/rdoc_markup_to_html_snippet_test.rb delete mode 100644 test/mri/rdoc/rdoc_markup_to_html_test.rb delete mode 100644 test/mri/rdoc/rdoc_markup_to_joined_paragraph_test.rb delete mode 100644 test/mri/rdoc/rdoc_markup_to_label_test.rb delete mode 100644 test/mri/rdoc/rdoc_markup_to_markdown_test.rb delete mode 100644 test/mri/rdoc/rdoc_markup_to_rdoc_test.rb delete mode 100644 test/mri/rdoc/rdoc_markup_to_table_of_contents_test.rb delete mode 100644 test/mri/rdoc/rdoc_markup_to_tt_only_test.rb delete mode 100644 test/mri/rdoc/rdoc_markup_verbatim_test.rb delete mode 100644 test/mri/rdoc/rdoc_method_attr_test.rb delete mode 100644 test/mri/rdoc/rdoc_normal_class_test.rb delete mode 100644 test/mri/rdoc/rdoc_normal_module_test.rb delete mode 100644 test/mri/rdoc/rdoc_options_test.rb delete mode 100644 test/mri/rdoc/rdoc_parser_c_test.rb delete mode 100644 test/mri/rdoc/rdoc_parser_changelog_test.rb delete mode 100644 test/mri/rdoc/rdoc_parser_markdown_test.rb delete mode 100644 test/mri/rdoc/rdoc_parser_prism_ruby_test.rb delete mode 100644 test/mri/rdoc/rdoc_parser_rd_test.rb delete mode 100644 test/mri/rdoc/rdoc_parser_ruby_test.rb delete mode 100644 test/mri/rdoc/rdoc_parser_simple_test.rb delete mode 100644 test/mri/rdoc/rdoc_parser_test.rb delete mode 100644 test/mri/rdoc/rdoc_rd_block_parser_test.rb delete mode 100644 test/mri/rdoc/rdoc_rd_inline_parser_test.rb delete mode 100644 test/mri/rdoc/rdoc_rd_inline_test.rb delete mode 100644 test/mri/rdoc/rdoc_rd_test.rb delete mode 100644 test/mri/rdoc/rdoc_rdoc_test.rb delete mode 100644 test/mri/rdoc/rdoc_require_test.rb delete mode 100644 test/mri/rdoc/rdoc_ri_driver_test.rb delete mode 100644 test/mri/rdoc/rdoc_ri_paths_test.rb delete mode 100644 test/mri/rdoc/rdoc_rubygems_hook_test.rb delete mode 100644 test/mri/rdoc/rdoc_servlet_test.rb delete mode 100644 test/mri/rdoc/rdoc_single_class_test.rb delete mode 100644 test/mri/rdoc/rdoc_stats_test.rb delete mode 100644 test/mri/rdoc/rdoc_store_test.rb delete mode 100644 test/mri/rdoc/rdoc_task_test.rb delete mode 100644 test/mri/rdoc/rdoc_text_test.rb delete mode 100644 test/mri/rdoc/rdoc_token_stream_test.rb delete mode 100644 test/mri/rdoc/rdoc_tom_doc_test.rb delete mode 100644 test/mri/rdoc/rdoc_top_level_test.rb delete mode 100644 test/mri/reline/helper.rb delete mode 100644 test/mri/reline/test_ansi.rb delete mode 100644 test/mri/reline/test_config.rb delete mode 100644 test/mri/reline/test_face.rb delete mode 100644 test/mri/reline/test_history.rb delete mode 100644 test/mri/reline/test_key_actor_emacs.rb delete mode 100644 test/mri/reline/test_key_actor_vi.rb delete mode 100644 test/mri/reline/test_key_stroke.rb delete mode 100644 test/mri/reline/test_kill_ring.rb delete mode 100644 test/mri/reline/test_line_editor.rb delete mode 100644 test/mri/reline/test_macro.rb delete mode 100644 test/mri/reline/test_reline.rb delete mode 100644 test/mri/reline/test_reline_key.rb delete mode 100644 test/mri/reline/test_string_processing.rb delete mode 100644 test/mri/reline/test_unicode.rb delete mode 100644 test/mri/reline/test_within_pipe.rb delete mode 100644 test/mri/reline/windows/test_key_event_record.rb delete mode 100755 test/mri/reline/yamatanooroti/multiline_repl delete mode 100644 test/mri/reline/yamatanooroti/termination_checker.rb delete mode 100644 test/mri/reline/yamatanooroti/test_rendering.rb delete mode 100644 test/mri/ruby/rjit/test_assembler.rb delete mode 100644 test/mri/rubygems/test_gem_commands_query_command.rb delete mode 100644 test/mri/test_pstore.rb delete mode 100644 test/mri/win32ole/available_ole.rb delete mode 100644 test/mri/win32ole/err_in_callback.rb delete mode 100644 test/mri/win32ole/orig_data.csv delete mode 100644 test/mri/win32ole/test_err_in_callback.rb delete mode 100644 test/mri/win32ole/test_folderitem2_invokeverb.rb delete mode 100644 test/mri/win32ole/test_nil2vtempty.rb delete mode 100644 test/mri/win32ole/test_ole_methods.rb delete mode 100644 test/mri/win32ole/test_propertyputref.rb delete mode 100644 test/mri/win32ole/test_thread.rb delete mode 100644 test/mri/win32ole/test_win32ole.rb delete mode 100644 test/mri/win32ole/test_win32ole_event.rb delete mode 100644 test/mri/win32ole/test_win32ole_method.rb delete mode 100644 test/mri/win32ole/test_win32ole_method_event.rb delete mode 100644 test/mri/win32ole/test_win32ole_param.rb delete mode 100644 test/mri/win32ole/test_win32ole_param_event.rb delete mode 100644 test/mri/win32ole/test_win32ole_record.rb delete mode 100644 test/mri/win32ole/test_win32ole_type.rb delete mode 100644 test/mri/win32ole/test_win32ole_type_event.rb delete mode 100644 test/mri/win32ole/test_win32ole_typelib.rb delete mode 100644 test/mri/win32ole/test_win32ole_variable.rb delete mode 100644 test/mri/win32ole/test_win32ole_variant.rb delete mode 100644 test/mri/win32ole/test_win32ole_variant_m.rb delete mode 100644 test/mri/win32ole/test_win32ole_variant_outarg.rb delete mode 100644 test/mri/win32ole/test_word.rb diff --git a/test/mri.stdlib.index b/test/mri.stdlib.index index 0d38dc43262..150e69309e7 100644 --- a/test/mri.stdlib.index +++ b/test/mri.stdlib.index @@ -1,6 +1,5 @@ # MRI stdlib tests -benchmark cgi digest # only runs as root and we don't support most of this anyway @@ -10,19 +9,14 @@ etc fiber fileutils io -irb json -logger monitor net open-uri openssl optparse -ostruct pathname psych -rdoc -reline resolv ripper socket @@ -60,9 +54,6 @@ test_weakref.rb # Looks for did_you_mean in the wrong place (../lib) #did_you_mean -# Various issues setting up test libraries to load -#fiddle - # Unsupported library, tries to use "fire_update!" defined by test harness #mkmf diff --git a/test/mri/benchmark/test_benchmark.rb b/test/mri/benchmark/test_benchmark.rb deleted file mode 100644 index 2e0c47af751..00000000000 --- a/test/mri/benchmark/test_benchmark.rb +++ /dev/null @@ -1,167 +0,0 @@ -# frozen_string_literal: true -require 'test/unit' -require 'benchmark' - -class TestBenchmark < Test::Unit::TestCase - BENCH_FOR_TIMES_UPTO = lambda do |x| - n = 1000 - tf = x.report("for:") { for _ in 1..n; '1'; end } - tt = x.report("times:") { n.times do ; '1'; end } - tu = x.report("upto:") { 1.upto(n) do ; '1'; end } - [tf+tt+tu, (tf+tt+tu)/3] - end - - BENCH_FOR_TIMES_UPTO_NO_LABEL = lambda do |x| - n = 1000 - x.report { for _ in 1..n; '1'; end } - x.report { n.times do ; '1'; end } - x.report { 1.upto(n) do ; '1'; end } - end - - def labels - %w[first second third] - end - - def bench(type = :bm, *args, &block) - if block - Benchmark.send(type, *args, &block) - else - Benchmark.send(type, *args) do |x| - labels.each { |label| - x.report(label) {} - } - end - end - end - - def capture_bench_output(type, *args, &block) - capture_output { bench(type, *args, &block) }.first.gsub(/[ \-]\d\.\d{6}/, ' --time--') - end - - def test_tms_outputs_nicely - assert_equal(" 0.000000 0.000000 0.000000 ( 0.000000)\n", Benchmark::Tms.new.to_s) - assert_equal(" 1.000000 2.000000 10.000000 ( 5.000000)\n", Benchmark::Tms.new(1,2,3,4,5).to_s) - assert_equal("1.000000 2.000000 3.000000 4.000000 10.000000 (5.000000) label", - Benchmark::Tms.new(1,2,3,4,5,'label').format('%u %y %U %Y %t %r %n')) - assert_equal("1.000000 2.000", Benchmark::Tms.new(1).format('%u %.3f', 2)) - assert_equal("100.000000 150.000000 250.000000 (200.000000)\n", - Benchmark::Tms.new(100, 150, 0, 0, 200).to_s) - end - - def test_tms_wont_modify_the_format_String_given - format = "format %u" - Benchmark::Tms.new.format(format) - assert_equal("format %u", format) - end - - BENCHMARK_OUTPUT_WITH_TOTAL_AVG = <total: --time-- --time-- --time-- ( --time--) ->avg: --time-- --time-- --time-- ( --time--) -BENCH - - def test_benchmark_does_not_print_any_space_if_the_given_caption_is_empty - assert_equal(<<-BENCH, capture_bench_output(:benchmark)) -first --time-- --time-- --time-- ( --time--) -second --time-- --time-- --time-- ( --time--) -third --time-- --time-- --time-- ( --time--) -BENCH - end - - def test_benchmark_makes_extra_calculations_with_an_Array_at_the_end_of_the_benchmark_and_show_the_result - assert_equal(BENCHMARK_OUTPUT_WITH_TOTAL_AVG, - capture_bench_output(:benchmark, - Benchmark::CAPTION, 7, - Benchmark::FORMAT, ">total:", ">avg:", - &BENCH_FOR_TIMES_UPTO)) - end - - def test_bm_returns_an_Array_of_the_times_with_the_labels - [:bm, :bmbm].each do |meth| - capture_output do - results = bench(meth) - assert_instance_of(Array, results) - assert_equal(labels.size, results.size) - results.zip(labels).each { |tms, label| - assert_instance_of(Benchmark::Tms, tms) - assert_equal(label, tms.label) - } - end - end - end - - def test_bm_correctly_output_when_the_label_width_is_given - assert_equal(<<-BENCH, capture_bench_output(:bm, 6)) - user system total real -first --time-- --time-- --time-- ( --time--) -second --time-- --time-- --time-- ( --time--) -third --time-- --time-- --time-- ( --time--) -BENCH - end - - def test_bm_correctly_output_when_no_label_is_given - assert_equal(<<-BENCH, capture_bench_output(:bm, &BENCH_FOR_TIMES_UPTO_NO_LABEL)) - user system total real - --time-- --time-- --time-- ( --time--) - --time-- --time-- --time-- ( --time--) - --time-- --time-- --time-- ( --time--) -BENCH - end - - def test_bm_can_make_extra_calcultations_with_an_array_at_the_end_of_the_benchmark - assert_equal(BENCHMARK_OUTPUT_WITH_TOTAL_AVG, - capture_bench_output(:bm, 7, ">total:", ">avg:", - &BENCH_FOR_TIMES_UPTO)) - end - - BMBM_OUTPUT = < 'GET', - 'SCRIPT_NAME' => nil, - ) - @str1="\xE3\x82\x86\xE3\x82\x93\xE3\x82\x86\xE3\x82\x93".dup - @str1.force_encoding("UTF-8") if defined?(::Encoding) - end - - def teardown - ENV.update(@environ) - end - - - def test_cgi_cookie_new_simple - cookie = CGI::Cookie.new('name1', 'val1', '&<>"', @str1) - assert_equal('name1', cookie.name) - assert_equal(['val1', '&<>"', @str1], cookie.value) - assert_nil(cookie.domain) - assert_nil(cookie.expires) - assert_equal('', cookie.path) - assert_equal(false, cookie.secure) - assert_equal(false, cookie.httponly) - assert_equal("name1=val1&%26%3C%3E%22&%E3%82%86%E3%82%93%E3%82%86%E3%82%93; path=", cookie.to_s) - end - - - def test_cgi_cookie_new_complex - t = Time.gm(2030, 12, 31, 23, 59, 59) - value = ['val1', '&<>"', "\xA5\xE0\xA5\xB9\xA5\xAB".dup] - value[2].force_encoding("EUC-JP") if defined?(::Encoding) - cookie = CGI::Cookie.new('name'=>'name1', - 'value'=>value, - 'path'=>'/cgi-bin/myapp/', - 'domain'=>'www.example.com', - 'expires'=>t, - 'secure'=>true, - 'httponly'=>true - ) - assert_equal('name1', cookie.name) - assert_equal(value, cookie.value) - assert_equal('www.example.com', cookie.domain) - assert_equal(t, cookie.expires) - assert_equal('/cgi-bin/myapp/', cookie.path) - assert_equal(true, cookie.secure) - assert_equal(true, cookie.httponly) - assert_equal('name1=val1&%26%3C%3E%22&%A5%E0%A5%B9%A5%AB; domain=www.example.com; path=/cgi-bin/myapp/; expires=Tue, 31 Dec 2030 23:59:59 GMT; secure; HttpOnly', cookie.to_s) - end - - - def test_cgi_cookie_new_with_domain - h = {'name'=>'name1', 'value'=>'value1'} - cookie = CGI::Cookie.new(h.merge('domain'=>'a.example.com')) - assert_equal('a.example.com', cookie.domain) - - cookie = CGI::Cookie.new(h.merge('domain'=>'.example.com')) - assert_equal('.example.com', cookie.domain) - - cookie = CGI::Cookie.new(h.merge('domain'=>'1.example.com')) - assert_equal('1.example.com', cookie.domain, 'enhanced by RFC 1123') - - assert_raise(ArgumentError) { - CGI::Cookie.new(h.merge('domain'=>'-a.example.com')) - } - - assert_raise(ArgumentError) { - CGI::Cookie.new(h.merge('domain'=>'a-.example.com')) - } - end - - - def test_cgi_cookie_scriptname - cookie = CGI::Cookie.new('name1', 'value1') - assert_equal('', cookie.path) - cookie = CGI::Cookie.new('name'=>'name1', 'value'=>'value1') - assert_equal('', cookie.path) - ## when ENV['SCRIPT_NAME'] is set, cookie.path is set automatically - ENV['SCRIPT_NAME'] = '/cgi-bin/app/example.cgi' - cookie = CGI::Cookie.new('name1', 'value1') - assert_equal('/cgi-bin/app/', cookie.path) - cookie = CGI::Cookie.new('name'=>'name1', 'value'=>'value1') - assert_equal('/cgi-bin/app/', cookie.path) - end - - - def test_cgi_cookie_parse - ## ';' separator - cookie_str = 'name1=val1&val2; name2=val2&%26%3C%3E%22&%E3%82%86%E3%82%93%E3%82%86%E3%82%93;_session_id=12345' - cookies = CGI::Cookie.parse(cookie_str) - list = [ - ['name1', ['val1', 'val2']], - ['name2', ['val2', '&<>"',@str1]], - ['_session_id', ['12345']], - ] - list.each do |name, value| - cookie = cookies[name] - assert_equal(name, cookie.name) - assert_equal(value, cookie.value) - end - ## don't allow ',' separator - cookie_str = 'name1=val1&val2, name2=val2' - cookies = CGI::Cookie.parse(cookie_str) - list = [ - ['name1', ['val1', 'val2, name2=val2']], - ] - list.each do |name, value| - cookie = cookies[name] - assert_equal(name, cookie.name) - assert_equal(value, cookie.value) - end - end - - def test_cgi_cookie_parse_not_decode_name - cookie_str = "%66oo=baz;foo=bar" - cookies = CGI::Cookie.parse(cookie_str) - assert_equal({"%66oo" => ["baz"], "foo" => ["bar"]}, cookies) - end - - def test_cgi_cookie_arrayinterface - cookie = CGI::Cookie.new('name1', 'a', 'b', 'c') - assert_equal('a', cookie[0]) - assert_equal('c', cookie[2]) - assert_nil(cookie[3]) - assert_equal('a', cookie.first) - assert_equal('c', cookie.last) - assert_equal(['A', 'B', 'C'], cookie.collect{|e| e.upcase}) - end - - - def test_cgi_cookie_domain_injection_into_name - name = "a=b; domain=example.com;" - path = "/" - domain = "example.jp" - assert_raise(ArgumentError) do - CGI::Cookie.new('name' => name, - 'value' => "value", - 'domain' => domain, - 'path' => path) - end - end - - - def test_cgi_cookie_newline_injection_into_name - name = "a=b;\r\nLocation: http://example.com#" - path = "/" - domain = "example.jp" - assert_raise(ArgumentError) do - CGI::Cookie.new('name' => name, - 'value' => "value", - 'domain' => domain, - 'path' => path) - end - end - - - def test_cgi_cookie_multibyte_injection_into_name - name = "a=b;\u3042" - path = "/" - domain = "example.jp" - assert_raise(ArgumentError) do - CGI::Cookie.new('name' => name, - 'value' => "value", - 'domain' => domain, - 'path' => path) - end - end - - - def test_cgi_cookie_injection_into_path - name = "name" - path = "/; samesite=none" - domain = "example.jp" - assert_raise(ArgumentError) do - CGI::Cookie.new('name' => name, - 'value' => "value", - 'domain' => domain, - 'path' => path) - end - end - - - def test_cgi_cookie_injection_into_domain - name = "name" - path = "/" - domain = "example.jp; samesite=none" - assert_raise(ArgumentError) do - CGI::Cookie.new('name' => name, - 'value' => "value", - 'domain' => domain, - 'path' => path) - end - end - - - instance_methods.each do |method| - private method if method =~ /^test_(.*)/ && $1 != ENV['TEST'] - end if ENV['TEST'] - -end diff --git a/test/mri/cgi/test_cgi_core.rb b/test/mri/cgi/test_cgi_core.rb deleted file mode 100644 index f7adb7e99f1..00000000000 --- a/test/mri/cgi/test_cgi_core.rb +++ /dev/null @@ -1,307 +0,0 @@ -# frozen_string_literal: true -require 'test/unit' -require 'cgi' -require 'stringio' -require_relative 'update_env' - - -class CGICoreTest < Test::Unit::TestCase - include UpdateEnv - - def setup - @environ = {} - #@environ = { - # 'SERVER_PROTOCOL' => 'HTTP/1.1', - # 'REQUEST_METHOD' => 'GET', - # 'SERVER_SOFTWARE' => 'Apache 2.2.0', - #} - #ENV.update(@environ) - end - - def teardown - ENV.update(@environ) - $stdout = STDOUT - end - - def test_cgi_parse_illegal_query - update_env( - 'REQUEST_METHOD' => 'GET', - 'QUERY_STRING' => 'a=111&&b=222&c&d=', - 'HTTP_COOKIE' => '_session_id=12345; name1=val1&val2;', - 'SERVER_SOFTWARE' => 'Apache 2.2.0', - 'SERVER_PROTOCOL' => 'HTTP/1.1', - ) - cgi = CGI.new - assert_equal(["a","b","c","d"],cgi.keys.sort) - assert_equal("",cgi["d"]) - end - - def test_cgi_core_params_GET - update_env( - 'REQUEST_METHOD' => 'GET', - 'QUERY_STRING' => 'id=123&id=456&id=&id&str=%40h+%3D%7E+%2F%5E%24%2F', - 'HTTP_COOKIE' => '_session_id=12345; name1=val1&val2;', - 'SERVER_SOFTWARE' => 'Apache 2.2.0', - 'SERVER_PROTOCOL' => 'HTTP/1.1', - ) - cgi = CGI.new - ## cgi[] - assert_equal('123', cgi['id']) - assert_equal('@h =~ /^$/', cgi['str']) - ## cgi.params - assert_equal(['123', '456', ''], cgi.params['id']) - assert_equal(['@h =~ /^$/'], cgi.params['str']) - ## cgi.keys - assert_equal(['id', 'str'], cgi.keys.sort) - ## cgi.key?, cgi.has_key?, cgi.include? - assert_equal(true, cgi.key?('id')) - assert_equal(true, cgi.has_key?('id')) - assert_equal(true, cgi.include?('id')) - assert_equal(false, cgi.key?('foo')) - assert_equal(false, cgi.has_key?('foo')) - assert_equal(false, cgi.include?('foo')) - ## invalid parameter name - assert_equal('', cgi['*notfound*']) # [ruby-dev:30740] - assert_equal([], cgi.params['*notfound*']) - end - - - def test_cgi_core_params_POST - query_str = 'id=123&id=456&id=&str=%40h+%3D%7E+%2F%5E%24%2F' - update_env( - 'REQUEST_METHOD' => 'POST', - 'CONTENT_LENGTH' => query_str.length.to_s, - 'HTTP_COOKIE' => '_session_id=12345; name1=val1&val2;', - 'SERVER_SOFTWARE' => 'Apache 2.2.0', - 'SERVER_PROTOCOL' => 'HTTP/1.1', - ) - $stdin = StringIO.new - $stdin << query_str - $stdin.rewind - cgi = CGI.new - ## cgi[] - assert_equal('123', cgi['id']) - assert_equal('@h =~ /^$/', cgi['str']) - ## cgi.params - assert_equal(['123', '456', ''], cgi.params['id']) - assert_equal(['@h =~ /^$/'], cgi.params['str']) - ## invalid parameter name - assert_equal('', cgi['*notfound*']) - assert_equal([], cgi.params['*notfound*']) - ensure - $stdin = STDIN - end - - def test_cgi_core_params_encoding_check - query_str = 'str=%BE%BE%B9%BE' - update_env( - 'REQUEST_METHOD' => 'POST', - 'CONTENT_LENGTH' => query_str.length.to_s, - 'SERVER_SOFTWARE' => 'Apache 2.2.0', - 'SERVER_PROTOCOL' => 'HTTP/1.1', - ) - $stdin = StringIO.new - $stdin << query_str - $stdin.rewind - if defined?(::Encoding) - hash={} - cgi = CGI.new(:accept_charset=>"UTF-8"){|key,val|hash[key]=val} - ## cgi[] - assert_equal("\xBE\xBE\xB9\xBE".dup.force_encoding("UTF-8"), cgi['str']) - ## cgi.params - assert_equal(["\xBE\xBE\xB9\xBE".dup.force_encoding("UTF-8")], cgi.params['str']) - ## accept-charset error - assert_equal({"str"=>"\xBE\xBE\xB9\xBE".dup.force_encoding("UTF-8")},hash) - - $stdin.rewind - assert_raise(CGI::InvalidEncoding) do - cgi = CGI.new(:accept_charset=>"UTF-8") - end - - $stdin.rewind - cgi = CGI.new(:accept_charset=>"EUC-JP") - ## cgi[] - assert_equal("\xBE\xBE\xB9\xBE".dup.force_encoding("EUC-JP"), cgi['str']) - ## cgi.params - assert_equal(["\xBE\xBE\xB9\xBE".dup.force_encoding("EUC-JP")], cgi.params['str']) - else - assert(true) - end - ensure - $stdin = STDIN - end - - - def test_cgi_core_cookie - update_env( - 'REQUEST_METHOD' => 'GET', - 'QUERY_STRING' => 'id=123&id=456&id=&str=%40h+%3D%7E+%2F%5E%24%2F', - 'HTTP_COOKIE' => '_session_id=12345; name1=val1&val2;', - 'SERVER_SOFTWARE' => 'Apache 2.2.0', - 'SERVER_PROTOCOL' => 'HTTP/1.1', - ) - cgi = CGI.new - assert_not_equal(nil,cgi.cookies) - [ ['_session_id', ['12345'], ], - ['name1', ['val1', 'val2'], ], - ].each do |key, expected| - cookie = cgi.cookies[key] - assert_kind_of(CGI::Cookie, cookie) - assert_equal(expected, cookie.value) - assert_equal(false, cookie.secure) - assert_nil(cookie.expires) - assert_nil(cookie.domain) - assert_equal('', cookie.path) - end - end - - - def test_cgi_core_maxcontentlength - update_env( - 'REQUEST_METHOD' => 'POST', - 'CONTENT_LENGTH' => (64 * 1024 * 1024).to_s - ) - ex = assert_raise(StandardError) do - CGI.new - end - assert_equal("too large post data.", ex.message) - end if CGI.const_defined?(:MAX_CONTENT_LENGTH) - - - def test_cgi_core_out - update_env( - 'REQUEST_METHOD' => 'GET', - 'QUERY_STRING' => 'id=123&id=456&id=&str=%40h+%3D%7E+%2F%5E%24%2F', - 'HTTP_COOKIE' => '_session_id=12345; name1=val1&val2;', - 'SERVER_SOFTWARE' => 'Apache 2.2.0', - 'SERVER_PROTOCOL' => 'HTTP/1.1', - ) - cgi = CGI.new - ## euc string - euc_str = "\270\253\244\355\241\242\277\315\244\254\245\264\245\337\244\316\244\350\244\246\244\300" - ## utf8 (not converted) - options = { 'charset'=>'utf8' } - $stdout = StringIO.new - cgi.out(options) { euc_str } - assert_nil(options['language']) - actual = $stdout.string - expected = "Content-Type: text/html; charset=utf8\r\n" + - "Content-Length: 22\r\n" + - "\r\n" + - euc_str - if defined?(::Encoding) - actual.force_encoding("ASCII-8BIT") - expected.force_encoding("ASCII-8BIT") - end - assert_equal(expected, actual) - ## language is keeped - options = { 'charset'=>'Shift_JIS', 'language'=>'en' } - $stdout = StringIO.new - cgi.out(options) { euc_str } - assert_equal('en', options['language']) - ## HEAD method - update_env('REQUEST_METHOD' => 'HEAD') - options = { 'charset'=>'utf8' } - $stdout = StringIO.new - cgi.out(options) { euc_str } - actual = $stdout.string - expected = "Content-Type: text/html; charset=utf8\r\n" + - "Content-Length: 22\r\n" + - "\r\n" - assert_equal(expected, actual) - end - - - def test_cgi_core_print - update_env( - 'REQUEST_METHOD' => 'GET', - ) - cgi = CGI.new - $stdout = StringIO.new - str = "foobar" - cgi.print(str) - expected = str - actual = $stdout.string - assert_equal(expected, actual) - end - - - def test_cgi_core_environs - update_env( - 'REQUEST_METHOD' => 'GET', - ) - cgi = CGI.new - ## - list1 = %w[ AUTH_TYPE CONTENT_TYPE GATEWAY_INTERFACE PATH_INFO - PATH_TRANSLATED QUERY_STRING REMOTE_ADDR REMOTE_HOST - REMOTE_IDENT REMOTE_USER REQUEST_METHOD SCRIPT_NAME - SERVER_NAME SERVER_PROTOCOL SERVER_SOFTWARE - HTTP_ACCEPT HTTP_ACCEPT_CHARSET HTTP_ACCEPT_ENCODING - HTTP_ACCEPT_LANGUAGE HTTP_CACHE_CONTROL HTTP_FROM HTTP_HOST - HTTP_NEGOTIATE HTTP_PRAGMA HTTP_REFERER HTTP_USER_AGENT - ] - # list2 = %w[ CONTENT_LENGTH SERVER_PORT ] - ## string expected - list1.each do |name| - update_env(name => "**#{name}**") - end - list1.each do |name| - method = name.sub(/\AHTTP_/, '').downcase - actual = cgi.__send__ method - expected = "**#{name}**" - assert_equal(expected, actual) - end - ## integer expected - update_env('CONTENT_LENGTH' => '123') - update_env('SERVER_PORT' => '8080') - assert_equal(123, cgi.content_length) - assert_equal(8080, cgi.server_port) - ## raw cookie - update_env('HTTP_COOKIE' => 'name1=val1') - update_env('HTTP_COOKIE2' => 'name2=val2') - assert_equal('name1=val1', cgi.raw_cookie) - assert_equal('name2=val2', cgi.raw_cookie2) - end - - - def test_cgi_core_htmltype_header - update_env( - 'REQUEST_METHOD' => 'GET', - ) - ## no htmltype - cgi = CGI.new - assert_raise(NoMethodError) do cgi.doctype end - assert_equal("Content-Type: text/html\r\n\r\n",cgi.header) - ## html3 - cgi = CGI.new('html3') - expected = '' - assert_equal(expected, cgi.doctype) - assert_equal("Content-Type: text/html\r\n\r\n",cgi.header) - ## html4 - cgi = CGI.new('html4') - expected = '' - assert_equal(expected, cgi.doctype) - assert_equal("Content-Type: text/html\r\n\r\n",cgi.header) - ## html4 transitional - cgi = CGI.new('html4Tr') - expected = '' - assert_equal(expected, cgi.doctype) - assert_equal("Content-Type: text/html\r\n\r\n",cgi.header) - ## html4 frameset - cgi = CGI.new('html4Fr') - expected = '' - assert_equal(expected, cgi.doctype) - assert_equal("Content-Type: text/html\r\n\r\n",cgi.header) - ## html5 - cgi = CGI.new('html5') - expected = '' - assert_equal(expected, cgi.doctype) - assert_match(/^

<\/HEADER>$/i,cgi.header) - end - - - instance_methods.each do |method| - private method if method =~ /^test_(.*)/ && $1 != ENV['TEST'] - end if ENV['TEST'] - -end diff --git a/test/mri/cgi/test_cgi_header.rb b/test/mri/cgi/test_cgi_header.rb deleted file mode 100644 index ec2f4deb72b..00000000000 --- a/test/mri/cgi/test_cgi_header.rb +++ /dev/null @@ -1,192 +0,0 @@ -# frozen_string_literal: true -require 'test/unit' -require 'cgi' -require 'time' -require_relative 'update_env' - - -class CGIHeaderTest < Test::Unit::TestCase - include UpdateEnv - - - def setup - @environ = {} - update_env( - 'SERVER_PROTOCOL' => 'HTTP/1.1', - 'REQUEST_METHOD' => 'GET', - 'SERVER_SOFTWARE' => 'Apache 2.2.0', - ) - end - - - def teardown - ENV.update(@environ) - end - - - def test_cgi_http_header_simple - cgi = CGI.new - ## default content type - expected = "Content-Type: text/html\r\n\r\n" - actual = cgi.http_header - assert_equal(expected, actual) - ## content type specified as string - expected = "Content-Type: text/xhtml; charset=utf8\r\n\r\n" - actual = cgi.http_header('text/xhtml; charset=utf8') - assert_equal(expected, actual) - ## content type specified as hash - expected = "Content-Type: image/png\r\n\r\n" - actual = cgi.http_header('type'=>'image/png') - assert_equal(expected, actual) - ## charset specified - expected = "Content-Type: text/html; charset=utf8\r\n\r\n" - actual = cgi.http_header('charset'=>'utf8') - assert_equal(expected, actual) - end - - - def test_cgi_http_header_complex - cgi = CGI.new - options = { - 'type' => 'text/xhtml', - 'charset' => 'utf8', - 'status' => 'REDIRECT', - 'server' => 'webrick', - 'connection' => 'close', - 'length' => 123, - 'language' => 'ja', - 'expires' => Time.gm(2000, 1, 23, 12, 34, 56), - 'location' => 'http://www.ruby-lang.org/', - } - expected = "Status: 302 Found\r\n".dup - expected << "Server: webrick\r\n" - expected << "Connection: close\r\n" - expected << "Content-Type: text/xhtml; charset=utf8\r\n" - expected << "Content-Length: 123\r\n" - expected << "Content-Language: ja\r\n" - expected << "Expires: Sun, 23 Jan 2000 12:34:56 GMT\r\n" - expected << "location: http://www.ruby-lang.org/\r\n" - expected << "\r\n" - actual = cgi.http_header(options) - assert_equal(expected, actual) - end - - - def test_cgi_http_header_argerr - cgi = CGI.new - expected = ArgumentError - - assert_raise(expected) do - cgi.http_header(nil) - end - end - - - def test_cgi_http_header_cookie - cgi = CGI.new - cookie1 = CGI::Cookie.new('name1', 'abc', '123') - cookie2 = CGI::Cookie.new('name'=>'name2', 'value'=>'value2', 'secure'=>true) - ctype = "Content-Type: text/html\r\n" - sep = "\r\n" - c1 = "Set-Cookie: name1=abc&123; path=\r\n" - c2 = "Set-Cookie: name2=value2; path=; secure\r\n" - ## CGI::Cookie object - actual = cgi.http_header('cookie'=>cookie1) - expected = ctype + c1 + sep - assert_equal(expected, actual) - ## String - actual = cgi.http_header('cookie'=>cookie2.to_s) - expected = ctype + c2 + sep - assert_equal(expected, actual) - ## Array - actual = cgi.http_header('cookie'=>[cookie1, cookie2]) - expected = ctype + c1 + c2 + sep - assert_equal(expected, actual) - ## Hash - actual = cgi.http_header('cookie'=>{'name1'=>cookie1, 'name2'=>cookie2}) - expected = ctype + c1 + c2 + sep - assert_equal(expected, actual) - end - - - def test_cgi_http_header_output_cookies - cgi = CGI.new - ## output cookies - cookies = [ CGI::Cookie.new('name1', 'abc', '123'), - CGI::Cookie.new('name'=>'name2', 'value'=>'value2', 'secure'=>true), - ] - cgi.instance_variable_set('@output_cookies', cookies) - expected = "Content-Type: text/html; charset=utf8\r\n".dup - expected << "Set-Cookie: name1=abc&123; path=\r\n" - expected << "Set-Cookie: name2=value2; path=; secure\r\n" - expected << "\r\n" - ## header when string - actual = cgi.http_header('text/html; charset=utf8') - assert_equal(expected, actual) - ## _header_for_string - actual = cgi.http_header('type'=>'text/html', 'charset'=>'utf8') - assert_equal(expected, actual) - end - - - def test_cgi_http_header_nph - time_start = Time.now.to_i - cgi = CGI.new - ## 'nph' is true - ENV['SERVER_SOFTWARE'] = 'Apache 2.2.0' - actual1 = cgi.http_header('nph'=>true) - ## when old IIS, NPH-mode is forced - ENV['SERVER_SOFTWARE'] = 'IIS/4.0' - actual2 = cgi.http_header - actual3 = cgi.http_header('status'=>'REDIRECT', 'location'=>'http://www.example.com/') - ## newer IIS doesn't require NPH-mode ## [ruby-dev:30537] - ENV['SERVER_SOFTWARE'] = 'IIS/5.0' - actual4 = cgi.http_header - actual5 = cgi.http_header('status'=>'REDIRECT', 'location'=>'http://www.example.com/') - time_end = Time.now.to_i - date = /^Date: ([A-Z][a-z]{2}, \d{2} [A-Z][a-z]{2} \d{4} \d\d:\d\d:\d\d GMT)\r\n/ - [actual1, actual2, actual3].each do |actual| - assert_match(date, actual) - assert_include(time_start..time_end, date =~ actual && Time.parse($1).to_i) - actual.sub!(date, "Date: DATE_IS_REMOVED\r\n") - end - ## assertion - expected = "HTTP/1.1 200 OK\r\n".dup - expected << "Date: DATE_IS_REMOVED\r\n" - expected << "Server: Apache 2.2.0\r\n" - expected << "Connection: close\r\n" - expected << "Content-Type: text/html\r\n" - expected << "\r\n" - assert_equal(expected, actual1) - expected.sub!(/^Server: .*?\r\n/, "Server: IIS/4.0\r\n") - assert_equal(expected, actual2) - expected.sub!(/^HTTP\/1.1 200 OK\r\n/, "HTTP/1.1 302 Found\r\n") - expected.sub!(/\r\n\r\n/, "\r\nlocation: http://www.example.com/\r\n\r\n") - assert_equal(expected, actual3) - expected = "Content-Type: text/html\r\n".dup - expected << "\r\n" - assert_equal(expected, actual4) - expected = "Status: 302 Found\r\n".dup - expected << "Content-Type: text/html\r\n" - expected << "location: http://www.example.com/\r\n" - expected << "\r\n" - assert_equal(expected, actual5) - ensure - ENV.delete('SERVER_SOFTWARE') - end - - - def test_cgi_http_header_crlf_injection - cgi = CGI.new - assert_raise(RuntimeError) { cgi.http_header("text/xhtml\r\nBOO") } - assert_raise(RuntimeError) { cgi.http_header("type" => "text/xhtml\r\nBOO") } - assert_raise(RuntimeError) { cgi.http_header("status" => "200 OK\r\nBOO") } - assert_raise(RuntimeError) { cgi.http_header("location" => "text/xhtml\r\nBOO") } - end - - - instance_methods.each do |method| - private method if method =~ /^test_(.*)/ && $1 != ENV['TEST'] - end if ENV['TEST'] - -end diff --git a/test/mri/cgi/test_cgi_modruby.rb b/test/mri/cgi/test_cgi_modruby.rb deleted file mode 100644 index 90132962b5a..00000000000 --- a/test/mri/cgi/test_cgi_modruby.rb +++ /dev/null @@ -1,149 +0,0 @@ -# frozen_string_literal: true -require 'test/unit' -require 'cgi' -require_relative 'update_env' - - -class CGIModrubyTest < Test::Unit::TestCase - include UpdateEnv - - - def setup - @environ = {} - update_env( - 'SERVER_PROTOCOL' => 'HTTP/1.1', - 'REQUEST_METHOD' => 'GET', - #'QUERY_STRING' => 'a=foo&b=bar', - ) - CGI.class_eval { const_set(:MOD_RUBY, true) } - Apache._reset() - #@cgi = CGI.new - #@req = Apache.request - end - - - def teardown - ENV.update(@environ) - CGI.class_eval { remove_const(:MOD_RUBY) } - end - - - def test_cgi_modruby_simple - req = Apache.request - cgi = CGI.new - assert(req._setup_cgi_env_invoked?) - assert(! req._send_http_header_invoked?) - actual = cgi.http_header - assert_equal('', actual) - assert_equal('text/html', req.content_type) - assert(req._send_http_header_invoked?) - end - - - def test_cgi_modruby_complex - req = Apache.request - cgi = CGI.new - options = { - 'status' => 'FORBIDDEN', - 'location' => 'http://www.example.com/', - 'type' => 'image/gif', - 'content-encoding' => 'deflate', - 'cookie' => [ CGI::Cookie.new('name1', 'abc', '123'), - CGI::Cookie.new('name'=>'name2', 'value'=>'value2', 'secure'=>true), - ], - } - assert(req._setup_cgi_env_invoked?) - assert(! req._send_http_header_invoked?) - actual = cgi.http_header(options) - assert_equal('', actual) - assert_equal('image/gif', req.content_type) - assert_equal('403 Forbidden', req.status_line) - assert_equal(403, req.status) - assert_equal('deflate', req.content_encoding) - assert_equal('http://www.example.com/', req.headers_out['location']) - assert_equal(["name1=abc&123; path=", "name2=value2; path=; secure"], - req.headers_out['Set-Cookie']) - assert(req._send_http_header_invoked?) - end - - - def test_cgi_modruby_location - req = Apache.request - cgi = CGI.new - options = { - 'status' => '200 OK', - 'location' => 'http://www.example.com/', - } - cgi.http_header(options) - assert_equal('200 OK', req.status_line) # should be '302 Found' ? - assert_equal(302, req.status) - assert_equal('http://www.example.com/', req.headers_out['location']) - end - - - def test_cgi_modruby_requestparams - req = Apache.request - req.args = 'a=foo&b=bar' - cgi = CGI.new - assert_equal('foo', cgi['a']) - assert_equal('bar', cgi['b']) - end - - - instance_methods.each do |method| - private method if method =~ /^test_(.*)/ && $1 != ENV['TEST'] - end if ENV['TEST'] - -end - - - -## dummy class for mod_ruby -class Apache #:nodoc: - - def self._reset - @request = Request.new - end - - def self.request - return @request - end - - class Request - - def initialize - hash = {} - def hash.add(name, value) - (self[name] ||= []) << value - end - @http_header = nil - @headers_out = hash - @status_line = nil - @status = nil - @content_type = nil - @content_encoding = nil - end - attr_accessor :headers_out, :status_line, :status, :content_type, :content_encoding - - attr_accessor :args - #def args - # return ENV['QUERY_STRING'] - #end - - def send_http_header - @http_header = '*invoked*' - end - def _send_http_header_invoked? - @http_header ? true : false - end - - def setup_cgi_env - @cgi_env = '*invoked*' - end - def _setup_cgi_env_invoked? - @cgi_env ? true : false - end - - end - -end diff --git a/test/mri/cgi/test_cgi_multipart.rb b/test/mri/cgi/test_cgi_multipart.rb deleted file mode 100644 index 5e8ec253901..00000000000 --- a/test/mri/cgi/test_cgi_multipart.rb +++ /dev/null @@ -1,385 +0,0 @@ -# frozen_string_literal: true -require 'test/unit' -require 'cgi' -require 'tempfile' -require 'stringio' -require_relative 'update_env' - - -## -## usage: -## boundary = 'foobar1234' # or nil -## multipart = MultiPart.new(boundary) -## multipart.append('name1', 'value1') -## multipart.append('file1', File.read('file1.html'), 'file1.html') -## str = multipart.close() -## str.each_line {|line| p line } -## ## output: -## # "--foobar1234\r\n" -## # "Content-Disposition: form-data: name=\"name1\"\r\n" -## # "\r\n" -## # "value1\r\n" -## # "--foobar1234\r\n" -## # "Content-Disposition: form-data: name=\"file1\"; filename=\"file1.html\"\r\n" -## # "Content-Type: text/html\r\n" -## # "\r\n" -## # "\n" -## # "

Hello

\n" -## # "\n" -## # "\r\n" -## # "--foobar1234--\r\n" -## -class MultiPart - - def initialize(boundary=nil) - @boundary = boundary || create_boundary() - @buf = ''.dup - @buf.force_encoding(::Encoding::ASCII_8BIT) if defined?(::Encoding) - end - attr_reader :boundary - - def append(name, value, filename=nil, content_type=nil) - content_type = detect_content_type(filename) if filename && content_type.nil? - s = filename ? "; filename=\"#{filename}\"" : '' - buf = @buf - buf << "--#{boundary}\r\n" - buf << "Content-Disposition: form-data: name=\"#{name}\"#{s}\r\n" - buf << "Content-Type: #{content_type}\r\n" if content_type - buf << "\r\n" - buf << value.b - buf << "\r\n" - return self - end - - def close - buf = @buf - @buf = ''.dup - return buf << "--#{boundary}--\r\n" - end - - def create_boundary() #:nodoc: - return "--boundary#{rand().to_s[2..-1]}" - end - - def detect_content_type(filename) #:nodoc: - filename =~ /\.(\w+)\z/ - return MIME_TYPES[$1] || 'application/octet-stream' - end - - MIME_TYPES = { - 'gif' => 'image/gif', - 'jpg' => 'image/jpeg', - 'jpeg' => 'image/jpeg', - 'png' => 'image/png', - 'bmp' => 'image/bmp', - 'tif' => 'image/tiff', - 'tiff' => 'image/tiff', - 'htm' => 'text/html', - 'html' => 'text/html', - 'xml' => 'text/xml', - 'txt' => 'text/plain', - 'text' => 'text/plain', - 'css' => 'text/css', - 'mpg' => 'video/mpeg', - 'mpeg' => 'video/mpeg', - 'mov' => 'video/quicktime', - 'avi' => 'video/x-msvideo', - 'mp3' => 'audio/mpeg', - 'mid' => 'audio/midi', - 'wav' => 'audio/x-wav', - 'zip' => 'application/zip', - #'tar.gz' => 'application/gtar', - 'gz' => 'application/gzip', - 'bz2' => 'application/bzip2', - 'rtf' => 'application/rtf', - 'pdf' => 'application/pdf', - 'ps' => 'application/postscript', - 'js' => 'application/x-javascript', - 'xls' => 'application/vnd.ms-excel', - 'doc' => 'application/msword', - 'ppt' => 'application/vnd.ms-powerpoint', - } - -end - - - -class CGIMultipartTest < Test::Unit::TestCase - include UpdateEnv - - - def setup - @environ = {} - update_env( - 'REQUEST_METHOD' => 'POST', - 'CONTENT_TYPE' => nil, - 'CONTENT_LENGTH' => nil, - ) - @tempfiles = [] - end - - def teardown - ENV.update(@environ) - $stdin.close() if $stdin.is_a?(Tempfile) - $stdin = STDIN - @tempfiles.each {|t| - t.close! - } - end - - def _prepare(data) - ## create multipart input - multipart = MultiPart.new(defined?(@boundary) ? @boundary : nil) - data.each do |hash| - multipart.append(hash[:name], hash[:value], hash[:filename]) - end - input = multipart.close() - input = yield(input) if block_given? - #$stderr.puts "*** debug: input=\n#{input.collect{|line| line.inspect}.join("\n")}" - @boundary ||= multipart.boundary - ## set environment - ENV['CONTENT_TYPE'] = "multipart/form-data; boundary=#{@boundary}" - ENV['CONTENT_LENGTH'] = input.length.to_s - ENV['REQUEST_METHOD'] = 'POST' - ## set $stdin - tmpfile = Tempfile.new('test_cgi_multipart') - @tempfiles << tmpfile - tmpfile.binmode - tmpfile << input - tmpfile.rewind() - $stdin = tmpfile - end - - def _test_multipart(cgi_options={}) - caller(0).find {|s| s =~ /in `test_(.*?)'/ } - #testname = $1 - #$stderr.puts "*** debug: testname=#{testname.inspect}" - _prepare(@data) - options = {:accept_charset=>"UTF-8"} - options.merge! cgi_options - cgi = CGI.new(options) - expected_names = @data.collect{|hash| hash[:name] }.sort - assert_equal(expected_names, cgi.params.keys.sort) - threshold = 1024*10 - @data.each do |hash| - name = hash[:name] - expected = hash[:value] - if hash[:filename] #if file - expected_class = @expected_class || (hash[:value].length < threshold ? StringIO : Tempfile) - assert(cgi.files.keys.member?(hash[:name])) - else - expected_class = String - assert_equal(expected, cgi[name]) - assert_equal(false,cgi.files.keys.member?(hash[:name])) - end - assert_kind_of(expected_class, cgi[name]) - assert_equal(expected, cgi[name].read()) - assert_equal(hash[:filename] || '', cgi[name].original_filename) #if hash[:filename] - assert_equal(hash[:content_type] || '', cgi[name].content_type) #if hash[:content_type] - end - ensure - if cgi - cgi.params.each {|name, vals| - vals.each {|val| - if val.kind_of?(Tempfile) && val.path - val.close! - end - } - } - end - end - - - def _read(basename) - filename = File.join(File.dirname(__FILE__), 'testdata', basename) - s = File.open(filename, 'rb') {|f| f.read() } - - return s - end - - - def test_cgi_multipart_stringio - @boundary = '----WebKitFormBoundaryAAfvAII+YL9102cX' - @data = [ - {:name=>'hidden1', :value=>'foobar'}, - {:name=>'text1', :value=>"\xE3\x81\x82\xE3\x81\x84\xE3\x81\x86\xE3\x81\x88\xE3\x81\x8A".dup}, - {:name=>'file1', :value=>_read('file1.html'), - :filename=>'file1.html', :content_type=>'text/html'}, - {:name=>'image1', :value=>_read('small.png'), - :filename=>'small.png', :content_type=>'image/png'}, # small image - ] - @data[1][:value].force_encoding(::Encoding::UTF_8) if defined?(::Encoding) - @expected_class = StringIO - _test_multipart() - end - - - def test_cgi_multipart_tempfile - @boundary = '----WebKitFormBoundaryAAfvAII+YL9102cX' - @data = [ - {:name=>'hidden1', :value=>'foobar'}, - {:name=>'text1', :value=>"\xE3\x81\x82\xE3\x81\x84\xE3\x81\x86\xE3\x81\x88\xE3\x81\x8A".dup}, - {:name=>'file1', :value=>_read('file1.html'), - :filename=>'file1.html', :content_type=>'text/html'}, - {:name=>'image1', :value=>_read('large.png'), - :filename=>'large.png', :content_type=>'image/png'}, # large image - ] - @data[1][:value].force_encoding(::Encoding::UTF_8) if defined?(::Encoding) - @expected_class = Tempfile - _test_multipart() - end - - - def _set_const(klass, name, value) - old = nil - klass.class_eval do - old = const_get(name) - remove_const(name) - const_set(name, value) - end - return old - end - - - def test_cgi_multipart_maxmultipartlength - @data = [ - {:name=>'image1', :value=>_read('large.png'), - :filename=>'large.png', :content_type=>'image/png'}, # large image - ] - begin - ex = assert_raise(StandardError) do - _test_multipart(:max_multipart_length=>2 * 1024) # set via simple scalar - end - assert_equal("too large multipart data.", ex.message) - ensure - end - end - - - def test_cgi_multipart_maxmultipartlength_lambda - @data = [ - {:name=>'image1', :value=>_read('large.png'), - :filename=>'large.png', :content_type=>'image/png'}, # large image - ] - begin - ex = assert_raise(StandardError) do - _test_multipart(:max_multipart_length=>lambda{2*1024}) # set via lambda - end - assert_equal("too large multipart data.", ex.message) - ensure - end - end - - - def test_cgi_multipart_maxmultipartcount - @data = [ - {:name=>'file1', :value=>_read('file1.html'), - :filename=>'file1.html', :content_type=>'text/html'}, - ] - item = @data.first - 500.times { @data << item } - #original = _set_const(CGI, :MAX_MULTIPART_COUNT, 128) - begin - ex = assert_raise(StandardError) do - _test_multipart() - end - assert_equal("too many parameters.", ex.message) - ensure - #_set_const(CGI, :MAX_MULTIPART_COUNT, original) - end - end if CGI.const_defined?(:MAX_MULTIPART_COUNT) - - - def test_cgi_multipart_badbody ## [ruby-dev:28470] - @data = [ - {:name=>'file1', :value=>_read('file1.html'), - :filename=>'file1.html', :content_type=>'text/html'}, - ] - _prepare(@data) do |input| - input2 = input.sub(/--(\r\n)?\z/, "\r\n") - assert input2 != input - #p input2 - input2 - end - ex = assert_raise(EOFError) do - CGI.new(:accept_charset=>"UTF-8") - end - assert_equal("bad content body", ex.message) - # - _prepare(@data) do |input| - input2 = input.sub(/--(\r\n)?\z/, "") - assert input2 != input - #p input2 - input2 - end - ex = assert_raise(EOFError) do - CGI.new(:accept_charset=>"UTF-8") - end - assert_equal("bad content body", ex.message) - end - - - def test_cgi_multipart_quoteboundary ## [JVN#84798830] - @boundary = '(.|\n)*' - @data = [ - {:name=>'hidden1', :value=>'foobar'}, - {:name=>'text1', :value=>"\xE3\x81\x82\xE3\x81\x84\xE3\x81\x86\xE3\x81\x88\xE3\x81\x8A".dup}, - {:name=>'file1', :value=>_read('file1.html'), - :filename=>'file1.html', :content_type=>'text/html'}, - {:name=>'image1', :value=>_read('small.png'), - :filename=>'small.png', :content_type=>'image/png'}, # small image - ] - @data[1][:value].force_encoding("UTF-8") - _prepare(@data) - cgi = CGI.new(:accept_charset=>"UTF-8") - assert_equal('file1.html', cgi['file1'].original_filename) - end - - def test_cgi_multipart_boundary_10240 # [Bug #3866] - @boundary = 'AaB03x' - @data = [ - {:name=>'file', :value=>"b"*10134, - :filename=>'file.txt', :content_type=>'text/plain'}, - {:name=>'foo', :value=>"bar"}, - ] - _prepare(@data) - cgi = CGI.new(:accept_charset=>"UTF-8") - assert_equal(cgi['foo'], 'bar') - assert_equal(cgi['file'].read, 'b'*10134) - cgi['file'].close! if cgi['file'].kind_of? Tempfile - end - - def test_cgi_multipart_without_tempfile - assert_in_out_err([], <<-'EOM') - require 'cgi' - require 'stringio' - ENV['REQUEST_METHOD'] = 'POST' - ENV['CONTENT_TYPE'] = 'multipart/form-data; boundary=foobar1234' - body = <<-BODY.gsub(/\n/, "\r\n") ---foobar1234 -Content-Disposition: form-data: name=\"name1\" - -value1 ---foobar1234 -Content-Disposition: form-data: name=\"file1\"; filename=\"file1.html\" -Content-Type: text/html - - -

Hello

- - ---foobar1234-- -BODY - ENV['CONTENT_LENGTH'] = body.size.to_s - $stdin = StringIO.new(body) - CGI.new - EOM - end - - ### - - self.instance_methods.each do |method| - private method if method =~ /^test_(.*)/ && $1 != ENV['TEST'] - end if ENV['TEST'] - -end diff --git a/test/mri/cgi/test_cgi_session.rb b/test/mri/cgi/test_cgi_session.rb deleted file mode 100644 index b16b69766e9..00000000000 --- a/test/mri/cgi/test_cgi_session.rb +++ /dev/null @@ -1,169 +0,0 @@ -# frozen_string_literal: true -require 'test/unit' -require 'cgi' -require 'cgi/session' -require 'cgi/session/pstore' -require 'stringio' -require 'tmpdir' -require_relative 'update_env' - -class CGISessionTest < Test::Unit::TestCase - include UpdateEnv - - def setup - @environ = {} - @session_dir = Dir.mktmpdir(%w'session dir') - end - - def teardown - ENV.update(@environ) - $stdout = STDOUT - FileUtils.rm_rf(@session_dir) - end - - def test_cgi_session_filestore - update_env( - 'REQUEST_METHOD' => 'GET', - # 'QUERY_STRING' => 'id=123&id=456&id=&str=%40h+%3D%7E+%2F%5E%24%2F', - # 'HTTP_COOKIE' => '_session_id=12345; name1=val1&val2;', - 'SERVER_SOFTWARE' => 'Apache 2.2.0', - 'SERVER_PROTOCOL' => 'HTTP/1.1', - ) - value1="value1" - value2="\x8F\xBC\x8D]".dup - value2.force_encoding("SJIS") if defined?(::Encoding) - cgi = CGI.new - session = CGI::Session.new(cgi,"tmpdir"=>@session_dir) - session["key1"]=value1 - session["key2"]=value2 - assert_equal(value1,session["key1"]) - assert_equal(value2,session["key2"]) - session.close - $stdout = StringIO.new - cgi.out{""} - - update_env( - 'REQUEST_METHOD' => 'GET', - # 'HTTP_COOKIE' => "_session_id=#{session_id}", - 'QUERY_STRING' => "_session_id=#{session.session_id}", - 'SERVER_SOFTWARE' => 'Apache 2.2.0', - 'SERVER_PROTOCOL' => 'HTTP/1.1', - ) - cgi = CGI.new - session = CGI::Session.new(cgi,"tmpdir"=>@session_dir) - $stdout = StringIO.new - assert_equal(value1,session["key1"]) - assert_equal(value2,session["key2"]) - session.close - - end - def test_cgi_session_pstore - update_env( - 'REQUEST_METHOD' => 'GET', - # 'QUERY_STRING' => 'id=123&id=456&id=&str=%40h+%3D%7E+%2F%5E%24%2F', - # 'HTTP_COOKIE' => '_session_id=12345; name1=val1&val2;', - 'SERVER_SOFTWARE' => 'Apache 2.2.0', - 'SERVER_PROTOCOL' => 'HTTP/1.1', - ) - value1="value1" - value2="\x8F\xBC\x8D]".dup - value2.force_encoding("SJIS") if defined?(::Encoding) - cgi = CGI.new - session = CGI::Session.new(cgi,"tmpdir"=>@session_dir,"database_manager"=>CGI::Session::PStore) - session["key1"]=value1 - session["key2"]=value2 - assert_equal(value1,session["key1"]) - assert_equal(value2,session["key2"]) - session.close - $stdout = StringIO.new - cgi.out{""} - - update_env( - 'REQUEST_METHOD' => 'GET', - # 'HTTP_COOKIE' => "_session_id=#{session_id}", - 'QUERY_STRING' => "_session_id=#{session.session_id}", - 'SERVER_SOFTWARE' => 'Apache 2.2.0', - 'SERVER_PROTOCOL' => 'HTTP/1.1', - ) - cgi = CGI.new - session = CGI::Session.new(cgi,"tmpdir"=>@session_dir,"database_manager"=>CGI::Session::PStore) - $stdout = StringIO.new - assert_equal(value1,session["key1"]) - assert_equal(value2,session["key2"]) - session.close - end - def test_cgi_session_specify_session_id - update_env( - 'REQUEST_METHOD' => 'GET', - # 'QUERY_STRING' => 'id=123&id=456&id=&str=%40h+%3D%7E+%2F%5E%24%2F', - # 'HTTP_COOKIE' => '_session_id=12345; name1=val1&val2;', - 'SERVER_SOFTWARE' => 'Apache 2.2.0', - 'SERVER_PROTOCOL' => 'HTTP/1.1', - ) - value1="value1" - value2="\x8F\xBC\x8D]".dup - value2.force_encoding("SJIS") if defined?(::Encoding) - cgi = CGI.new - session = CGI::Session.new(cgi,"tmpdir"=>@session_dir,"session_id"=>"foo") - session["key1"]=value1 - session["key2"]=value2 - assert_equal(value1,session["key1"]) - assert_equal(value2,session["key2"]) - assert_equal("foo",session.session_id) - #session_id=session.session_id - session.close - $stdout = StringIO.new - cgi.out{""} - - update_env( - 'REQUEST_METHOD' => 'GET', - # 'HTTP_COOKIE' => "_session_id=#{session_id}", - 'QUERY_STRING' => "_session_id=#{session.session_id}", - 'SERVER_SOFTWARE' => 'Apache 2.2.0', - 'SERVER_PROTOCOL' => 'HTTP/1.1', - ) - cgi = CGI.new - session = CGI::Session.new(cgi,"tmpdir"=>@session_dir) - $stdout = StringIO.new - assert_equal(value1,session["key1"]) - assert_equal(value2,session["key2"]) - assert_equal("foo",session.session_id) - session.close - end - def test_cgi_session_specify_session_key - update_env( - 'REQUEST_METHOD' => 'GET', - # 'QUERY_STRING' => 'id=123&id=456&id=&str=%40h+%3D%7E+%2F%5E%24%2F', - # 'HTTP_COOKIE' => '_session_id=12345; name1=val1&val2;', - 'SERVER_SOFTWARE' => 'Apache 2.2.0', - 'SERVER_PROTOCOL' => 'HTTP/1.1', - ) - value1="value1" - value2="\x8F\xBC\x8D]".dup - value2.force_encoding("SJIS") if defined?(::Encoding) - cgi = CGI.new - session = CGI::Session.new(cgi,"tmpdir"=>@session_dir,"session_key"=>"bar") - session["key1"]=value1 - session["key2"]=value2 - assert_equal(value1,session["key1"]) - assert_equal(value2,session["key2"]) - session_id=session.session_id - session.close - $stdout = StringIO.new - cgi.out{""} - - update_env( - 'REQUEST_METHOD' => 'GET', - 'HTTP_COOKIE' => "bar=#{session_id}", - # 'QUERY_STRING' => "bar=#{session.session_id}", - 'SERVER_SOFTWARE' => 'Apache 2.2.0', - 'SERVER_PROTOCOL' => 'HTTP/1.1', - ) - cgi = CGI.new - session = CGI::Session.new(cgi,"tmpdir"=>@session_dir,"session_key"=>"bar") - $stdout = StringIO.new - assert_equal(value1,session["key1"]) - assert_equal(value2,session["key2"]) - session.close - end -end diff --git a/test/mri/cgi/test_cgi_tag_helper.rb b/test/mri/cgi/test_cgi_tag_helper.rb deleted file mode 100644 index 0b99dfc1bc4..00000000000 --- a/test/mri/cgi/test_cgi_tag_helper.rb +++ /dev/null @@ -1,355 +0,0 @@ -# frozen_string_literal: true -require 'test/unit' -require 'cgi' -require 'stringio' -require_relative 'update_env' - - -class CGITagHelperTest < Test::Unit::TestCase - include UpdateEnv - - - def setup - @environ = {} - #@environ = { - # 'SERVER_PROTOCOL' => 'HTTP/1.1', - # 'REQUEST_METHOD' => 'GET', - # 'SERVER_SOFTWARE' => 'Apache 2.2.0', - #} - #ENV.update(@environ) - end - - - def teardown - ENV.update(@environ) - $stdout = STDOUT - end - - - def test_cgi_tag_helper_html3 - update_env( - 'REQUEST_METHOD' => 'GET', - ) - ## html3 - cgi = CGI.new('html3') - assert_equal('',cgi.a) - assert_equal('',cgi.a('bar')) - assert_equal('foo',cgi.a{'foo'}) - assert_equal('foo',cgi.a('bar'){'foo'}) - assert_equal('',cgi.tt) - assert_equal('',cgi.tt('bar')) - assert_equal('foo',cgi.tt{'foo'}) - assert_equal('foo',cgi.tt('bar'){'foo'}) - assert_equal('',cgi.i) - assert_equal('',cgi.i('bar')) - assert_equal('foo',cgi.i{'foo'}) - assert_equal('foo',cgi.i('bar'){'foo'}) - assert_equal('',cgi.b) - assert_equal('',cgi.b('bar')) - assert_equal('foo',cgi.b{'foo'}) - assert_equal('foo',cgi.b('bar'){'foo'}) - assert_equal('',cgi.u) - assert_equal('',cgi.u('bar')) - assert_equal('foo',cgi.u{'foo'}) - assert_equal('foo',cgi.u('bar'){'foo'}) - assert_equal('',cgi.strike) - assert_equal('',cgi.strike('bar')) - assert_equal('~~foo~~',cgi.strike{'foo'}) - assert_equal('~~foo~~',cgi.strike('bar'){'foo'}) - assert_equal('',cgi.big) - assert_equal('',cgi.big('bar')) - assert_equal('foo',cgi.big{'foo'}) - assert_equal('foo',cgi.big('bar'){'foo'}) - assert_equal('',cgi.small) - assert_equal('',cgi.small('bar')) - assert_equal('foo',cgi.small{'foo'}) - assert_equal('foo',cgi.small('bar'){'foo'}) - assert_equal('',cgi.sub) - assert_equal('',cgi.sub('bar')) - assert_equal('_foo',cgi.sub{'foo'}) - assert_equal('_foo',cgi.sub('bar'){'foo'}) - assert_equal('',cgi.sup) - assert_equal('',cgi.sup('bar')) - assert_equal('^foo',cgi.sup{'foo'}) - assert_equal('^foo',cgi.sup('bar'){'foo'}) - assert_equal('',cgi.em) - assert_equal('',cgi.em('bar')) - assert_equal('foo',cgi.em{'foo'}) - assert_equal('foo',cgi.em('bar'){'foo'}) - assert_equal('',cgi.strong) - assert_equal('',cgi.strong('bar')) - assert_equal('foo',cgi.strong{'foo'}) - assert_equal('foo',cgi.strong('bar'){'foo'}) - assert_equal('',cgi.dfn) - assert_equal('',cgi.dfn('bar')) - assert_equal('foo',cgi.dfn{'foo'}) - assert_equal('foo',cgi.dfn('bar'){'foo'}) - assert_equal('',cgi.code) - assert_equal('',cgi.code('bar')) - assert_equal('foo',cgi.code{'foo'}) - assert_equal('foo',cgi.code('bar'){'foo'}) - assert_equal('',cgi.samp) - assert_equal('',cgi.samp('bar')) - assert_equal('foo',cgi.samp{'foo'}) - assert_equal('foo',cgi.samp('bar'){'foo'}) - assert_equal('',cgi.kbd) - assert_equal('',cgi.kbd('bar')) - assert_equal('foo',cgi.kbd{'foo'}) - assert_equal('foo',cgi.kbd('bar'){'foo'}) - assert_equal('',cgi.var) - assert_equal('',cgi.var('bar')) - assert_equal('foo',cgi.var{'foo'}) - assert_equal('foo',cgi.var('bar'){'foo'}) - assert_equal('',cgi.cite) - assert_equal('',cgi.cite('bar')) - assert_equal('foo',cgi.cite{'foo'}) - assert_equal('foo',cgi.cite('bar'){'foo'}) - assert_equal('',cgi.font) - assert_equal('',cgi.font('bar')) - assert_equal('foo',cgi.font{'foo'}) - assert_equal('foo',cgi.font('bar'){'foo'}) - assert_equal('

',cgi.address) - assert_equal('

',cgi.address('bar')) - assert_equal('

foo

',cgi.address{'foo'}) - assert_equal('

foo

',cgi.address('bar'){'foo'}) - assert_equal('

',cgi.div) - assert_equal('

',cgi.div('bar')) - assert_equal('

foo

',cgi.div{'foo'}) - assert_equal('

foo

',cgi.div('bar'){'foo'}) - assert_equal('',cgi.center) - assert_equal('',cgi.center('bar')) - assert_equal('foo',cgi.center{'foo'}) - assert_equal('foo',cgi.center('bar'){'foo'}) - assert_equal('',cgi.map) - assert_equal('',cgi.map('bar')) - assert_equal('foo',cgi.map{'foo'}) - assert_equal('foo',cgi.map('bar'){'foo'}) - assert_equal('',cgi.applet) - assert_equal('',cgi.applet('bar')) - assert_equal('foo',cgi.applet{'foo'}) - assert_equal('foo',cgi.applet('bar'){'foo'}) - assert_equal('

',cgi.pre) - assert_equal('

',cgi.pre('bar')) - assert_equal('

foo

',cgi.pre{'foo'}) - assert_equal('

foo

',cgi.pre('bar'){'foo'}) - assert_equal('',cgi.xmp) - assert_equal('',cgi.xmp('bar')) - assert_equal('foo',cgi.xmp{'foo'}) - assert_equal('foo',cgi.xmp('bar'){'foo'}) - assert_equal('',cgi.listing) - assert_equal('',cgi.listing('bar')) - assert_equal('foo',cgi.listing{'foo'}) - assert_equal('foo',cgi.listing('bar'){'foo'}) - assert_equal('

',cgi.dl) - assert_equal('

',cgi.dl('bar')) - assert_equal('

foo',cgi.dl{'foo'}) - assert_equal('

foo',cgi.dl('bar'){'foo'}) - assert_equal('

',cgi.ol) - assert_equal('

',cgi.ol('bar')) - assert_equal('

foo',cgi.ol{'foo'}) - assert_equal('

foo',cgi.ol('bar'){'foo'}) - assert_equal('

',cgi.ul) - assert_equal('

',cgi.ul('bar')) - assert_equal('

foo',cgi.ul{'foo'}) - assert_equal('

foo',cgi.ul('bar'){'foo'}) - assert_equal('',cgi.dir) - assert_equal('',cgi.dir('bar')) - assert_equal('foo',cgi.dir{'foo'}) - assert_equal('foo',cgi.dir('bar'){'foo'}) - assert_equal('',cgi.menu) - assert_equal('',cgi.menu('bar')) - assert_equal('foo',cgi.menu{'foo'}) - assert_equal('foo',cgi.menu('bar'){'foo'}) - assert_equal('',cgi.select) - assert_equal('',cgi.select('bar')) - assert_equal('',cgi.select{'foo'}) - assert_equal('',cgi.select('bar'){'foo'}) - assert_equal('

',cgi.table) - assert_equal('

',cgi.table('bar')) - assert_equal('foo

',cgi.table{'foo'}) - assert_equal('foo

',cgi.table('bar'){'foo'}) - assert_equal('',cgi.title) - assert_equal('',cgi.title('bar')) - assert_equal('foo',cgi.title{'foo'}) - assert_equal('foo',cgi.title('bar'){'foo'}) - assert_equal('',cgi.style) - assert_equal('',cgi.style('bar')) - assert_equal('',cgi.style{'foo'}) - assert_equal('',cgi.style('bar'){'foo'}) - assert_equal('',cgi.script) - assert_equal('',cgi.script('bar')) - assert_equal('',cgi.script{'foo'}) - assert_equal('',cgi.script('bar'){'foo'}) - assert_equal('

',cgi.h1) - assert_equal('

',cgi.h1('bar')) - assert_equal('

foo

',cgi.h1{'foo'}) - assert_equal('

foo

',cgi.h1('bar'){'foo'}) - assert_equal('

',cgi.h2) - assert_equal('

',cgi.h2('bar')) - assert_equal('

foo

',cgi.h2{'foo'}) - assert_equal('

foo

',cgi.h2('bar'){'foo'}) - assert_equal('

',cgi.h3) - assert_equal('

',cgi.h3('bar')) - assert_equal('

foo

',cgi.h3{'foo'}) - assert_equal('

foo

',cgi.h3('bar'){'foo'}) - assert_equal('

',cgi.h4) - assert_equal('

',cgi.h4('bar')) - assert_equal('

foo

',cgi.h4{'foo'}) - assert_equal('

foo

',cgi.h4('bar'){'foo'}) - assert_equal('

',cgi.h5) - assert_equal('

',cgi.h5('bar')) - assert_equal('

foo

',cgi.h5{'foo'}) - assert_equal('

foo

',cgi.h5('bar'){'foo'}) - assert_equal('

',cgi.h6) - assert_equal('

',cgi.h6('bar')) - assert_equal('

foo

',cgi.h6{'foo'}) - assert_equal('

foo

',cgi.h6('bar'){'foo'}) - assert_match(/^

<\/TEXTAREA>$/,cgi.textarea)
-    assert_match(/COLS="70"/,cgi.textarea)
-    assert_match(/ROWS="10"/,cgi.textarea)
-    assert_match(/NAME=""/,cgi.textarea)
-    assert_match(/^<TEXTAREA .*><\/TEXTAREA>$/,cgi.textarea("bar"))
-    assert_match(/COLS="70"/,cgi.textarea("bar"))
-    assert_match(/ROWS="10"/,cgi.textarea("bar"))
-    assert_match(/NAME="bar"/,cgi.textarea("bar"))
-    assert_match(/^<TEXTAREA .*>foo<\/TEXTAREA>$/,cgi.textarea{"foo"})
-    assert_match(/COLS="70"/,cgi.textarea{"foo"})
-    assert_match(/ROWS="10"/,cgi.textarea{"foo"})
-    assert_match(/NAME=""/,cgi.textarea{"foo"})
-    assert_match(/^<TEXTAREA .*>foo<\/TEXTAREA>$/,cgi.textarea("bar"){"foo"})
-    assert_match(/COLS="70"/,cgi.textarea("bar"){"foo"})
-    assert_match(/ROWS="10"/,cgi.textarea("bar"){"foo"})
-    assert_match(/NAME="bar"/,cgi.textarea("bar"){"foo"})
-    assert_match(/^<FORM .*><\/FORM>$/,cgi.form)
-    assert_match(/METHOD="post"/,cgi.form)
-    assert_match(/ENCTYPE="application\/x-www-form-urlencoded"/,cgi.form)
-    assert_match(/^<FORM .*><\/FORM>$/,cgi.form("bar"))
-    assert_match(/METHOD="bar"/,cgi.form("bar"))
-    assert_match(/ENCTYPE="application\/x-www-form-urlencoded"/,cgi.form("bar"))
-    assert_match(/^<FORM .*>foo<\/FORM>$/,cgi.form{"foo"})
-    assert_match(/METHOD="post"/,cgi.form{"foo"})
-    assert_match(/ENCTYPE="application\/x-www-form-urlencoded"/,cgi.form{"foo"})
-    assert_match(/^<FORM .*>foo<\/FORM>$/,cgi.form("bar"){"foo"})
-    assert_match(/METHOD="bar"/,cgi.form("bar"){"foo"})
-    assert_match(/ENCTYPE="application\/x-www-form-urlencoded"/,cgi.form("bar"){"foo"})
-    assert_equal('<BLOCKQUOTE></BLOCKQUOTE>',cgi.blockquote)
-    assert_equal('<BLOCKQUOTE CITE="bar"></BLOCKQUOTE>',cgi.blockquote('bar'))
-    assert_equal('<BLOCKQUOTE>foo</BLOCKQUOTE>',cgi.blockquote{'foo'})
-    assert_equal('<BLOCKQUOTE CITE="bar">foo</BLOCKQUOTE>',cgi.blockquote('bar'){'foo'})
-    assert_equal('<CAPTION></CAPTION>',cgi.caption)
-    assert_equal('<CAPTION ALIGN="bar"></CAPTION>',cgi.caption('bar'))
-    assert_equal('<CAPTION>foo</CAPTION>',cgi.caption{'foo'})
-    assert_equal('<CAPTION ALIGN="bar">foo</CAPTION>',cgi.caption('bar'){'foo'})
-    assert_equal('<IMG SRC="" ALT="">',cgi.img)
-    assert_equal('<IMG SRC="bar" ALT="">',cgi.img('bar'))
-    assert_equal('<IMG SRC="" ALT="">',cgi.img{'foo'})
-    assert_equal('<IMG SRC="bar" ALT="">',cgi.img('bar'){'foo'})
-    assert_equal('<BASE HREF="">',cgi.base)
-    assert_equal('<BASE HREF="bar">',cgi.base('bar'))
-    assert_equal('<BASE HREF="">',cgi.base{'foo'})
-    assert_equal('<BASE HREF="bar">',cgi.base('bar'){'foo'})
-    assert_equal('<BASEFONT>',cgi.basefont)
-    assert_equal('<BASEFONT>',cgi.basefont('bar'))
-    assert_equal('<BASEFONT>',cgi.basefont{'foo'})
-    assert_equal('<BASEFONT>',cgi.basefont('bar'){'foo'})
-    assert_equal('<BR>',cgi.br)
-    assert_equal('<BR>',cgi.br('bar'))
-    assert_equal('<BR>',cgi.br{'foo'})
-    assert_equal('<BR>',cgi.br('bar'){'foo'})
-    assert_equal('<AREA>',cgi.area)
-    assert_equal('<AREA>',cgi.area('bar'))
-    assert_equal('<AREA>',cgi.area{'foo'})
-    assert_equal('<AREA>',cgi.area('bar'){'foo'})
-    assert_equal('<LINK>',cgi.link)
-    assert_equal('<LINK>',cgi.link('bar'))
-    assert_equal('<LINK>',cgi.link{'foo'})
-    assert_equal('<LINK>',cgi.link('bar'){'foo'})
-    assert_equal('<PARAM>',cgi.param)
-    assert_equal('<PARAM>',cgi.param('bar'))
-    assert_equal('<PARAM>',cgi.param{'foo'})
-    assert_equal('<PARAM>',cgi.param('bar'){'foo'})
-    assert_equal('<HR>',cgi.hr)
-    assert_equal('<HR>',cgi.hr('bar'))
-    assert_equal('<HR>',cgi.hr{'foo'})
-    assert_equal('<HR>',cgi.hr('bar'){'foo'})
-    assert_equal('<INPUT>',cgi.input)
-    assert_equal('<INPUT>',cgi.input('bar'))
-    assert_equal('<INPUT>',cgi.input{'foo'})
-    assert_equal('<INPUT>',cgi.input('bar'){'foo'})
-    assert_equal('<ISINDEX>',cgi.isindex)
-    assert_equal('<ISINDEX>',cgi.isindex('bar'))
-    assert_equal('<ISINDEX>',cgi.isindex{'foo'})
-    assert_equal('<ISINDEX>',cgi.isindex('bar'){'foo'})
-    assert_equal('<META>',cgi.meta)
-    assert_equal('<META>',cgi.meta('bar'))
-    assert_equal('<META>',cgi.meta{'foo'})
-    assert_equal('<META>',cgi.meta('bar'){'foo'})
-    assert_equal('<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN"><HTML>',cgi.html)
-    assert_equal('<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN"><HTML>foo</HTML>',cgi.html{'foo'})
-    assert_equal('<HEAD>',cgi.head)
-    assert_equal('<HEAD>foo</HEAD>',cgi.head{'foo'})
-    assert_equal('<BODY>',cgi.body)
-    assert_equal('<BODY>foo</BODY>',cgi.body{'foo'})
-    assert_equal('<P>',cgi.p)
-    assert_equal('<P>foo</P>',cgi.p{'foo'})
-    assert_equal('<PLAINTEXT>',cgi.plaintext)
-    assert_equal('<PLAINTEXT>foo</PLAINTEXT>',cgi.plaintext{'foo'})
-    assert_equal('<DT>',cgi.dt)
-    assert_equal('<DT>foo</DT>',cgi.dt{'foo'})
-    assert_equal('<DD>',cgi.dd)
-    assert_equal('<DD>foo</DD>',cgi.dd{'foo'})
-    assert_equal('<LI>',cgi.li)
-    assert_equal('<LI>foo</LI>',cgi.li{'foo'})
-    assert_equal('<OPTION>',cgi.option)
-    assert_equal('<OPTION>foo</OPTION>',cgi.option{'foo'})
-    assert_equal('<TR>',cgi.tr)
-    assert_equal('<TR>foo</TR>',cgi.tr{'foo'})
-    assert_equal('<TH>',cgi.th)
-    assert_equal('<TH>foo</TH>',cgi.th{'foo'})
-    assert_equal('<TD>',cgi.td)
-    assert_equal('<TD>foo</TD>',cgi.td{'foo'})
-    str=cgi.checkbox_group("foo",["aa","bb"],["cc","dd"])
-    assert_match(/^<INPUT .*VALUE="aa".*>bb<INPUT .*VALUE="cc".*>dd$/,str)
-    assert_match(/^<INPUT .*TYPE="checkbox".*>bb<INPUT .*TYPE="checkbox".*>dd$/,str)
-    assert_match(/^<INPUT .*NAME="foo".*>bb<INPUT .*NAME="foo".*>dd$/,str)
-    str=cgi.radio_group("foo",["aa","bb"],["cc","dd"])
-    assert_match(/^<INPUT .*VALUE="aa".*>bb<INPUT .*VALUE="cc".*>dd$/,str)
-    assert_match(/^<INPUT .*TYPE="radio".*>bb<INPUT .*TYPE="radio".*>dd$/,str)
-    assert_match(/^<INPUT .*NAME="foo".*>bb<INPUT .*NAME="foo".*>dd$/,str)
-    str=cgi.checkbox_group("foo",["aa","bb"],["cc","dd",true])
-    assert_match(/^<INPUT .*VALUE="aa".*>bb<INPUT .*VALUE="cc".*>dd$/,str)
-    assert_match(/^<INPUT .*TYPE="checkbox".*>bb<INPUT .*TYPE="checkbox".*>dd$/,str)
-    assert_match(/^<INPUT .*NAME="foo".*>bb<INPUT .*NAME="foo".*>dd$/,str)
-    assert_match(/^<INPUT .*>bb<INPUT .*CHECKED.*>dd$/,str)
-    assert_match(/<INPUT .*TYPE="text".*>/,cgi.text_field(:name=>"name",:value=>"value"))
-    str=cgi.radio_group("foo",["aa","bb"],["cc","dd",false])
-    assert_match(/^<INPUT .*VALUE="aa".*>bb<INPUT .*VALUE="cc".*>dd$/,str)
-    assert_match(/^<INPUT .*TYPE="radio".*>bb<INPUT .*TYPE="radio".*>dd$/,str)
-    assert_match(/^<INPUT .*NAME="foo".*>bb<INPUT .*NAME="foo".*>dd$/,str)
-  end
-
-=begin
-  def test_cgi_tag_helper_html4
-    ## html4
-    cgi = CGI.new('html4')
-    ## html4 transitional
-    cgi = CGI.new('html4Tr')
-    ## html4 frameset
-    cgi = CGI.new('html4Fr')
-  end
-=end
-
-  def test_cgi_tag_helper_html5
-    update_env(
-      'REQUEST_METHOD' => 'GET',
-    )
-    ## html5
-    cgi = CGI.new('html5')
-    assert_equal('<HEADER></HEADER>',cgi.header)
-    assert_equal('<FOOTER></FOOTER>',cgi.footer)
-    assert_equal('<ARTICLE></ARTICLE>',cgi.article)
-    assert_equal('<SECTION></SECTION>',cgi.section)
-    assert_equal('<!DOCTYPE HTML><HTML BLA="TEST"></HTML>',cgi.html("BLA"=>"TEST"){})
-  end
-
-end
diff --git a/test/mri/cgi/test_cgi_util.rb b/test/mri/cgi/test_cgi_util.rb
deleted file mode 100644
index b0612fc87d9..00000000000
--- a/test/mri/cgi/test_cgi_util.rb
+++ /dev/null
@@ -1,312 +0,0 @@
-# frozen_string_literal: true
-require 'test/unit'
-require 'cgi'
-require 'stringio'
-require_relative 'update_env'
-
-
-class CGIUtilTest < Test::Unit::TestCase
-  include CGI::Util
-  include UpdateEnv
-
-  def setup
-    @environ = {}
-    update_env(
-      'REQUEST_METHOD' => 'GET',
-      'SCRIPT_NAME' => nil,
-    )
-    @str1="&<>\" \xE3\x82\x86\xE3\x82\x93\xE3\x82\x86\xE3\x82\x93".dup
-    @str1.force_encoding("UTF-8") if defined?(::Encoding)
-  end
-
-  def teardown
-    ENV.update(@environ)
-  end
-
-  def test_cgi_escape
-    assert_equal('%26%3C%3E%22+%E3%82%86%E3%82%93%E3%82%86%E3%82%93', CGI.escape(@str1))
-    assert_equal('%26%3C%3E%22+%E3%82%86%E3%82%93%E3%82%86%E3%82%93'.ascii_only?, CGI.escape(@str1).ascii_only?) if defined?(::Encoding)
-  end
-
-  def test_cgi_escape_with_unreserved_characters
-    assert_equal("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-._~",
-                 CGI.escape("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-._~"),
-                 "should not escape any unreserved characters, as per RFC3986 Section 2.3")
-  end
-
-  def test_cgi_escape_with_invalid_byte_sequence
-    assert_equal('%C0%3C%3C', CGI.escape("\xC0\<\<".dup.force_encoding("UTF-8")))
-  end
-
-  def test_cgi_escape_preserve_encoding
-    assert_equal(Encoding::US_ASCII, CGI.escape("\xC0\<\<".dup.force_encoding("US-ASCII")).encoding)
-    assert_equal(Encoding::ASCII_8BIT, CGI.escape("\xC0\<\<".dup.force_encoding("ASCII-8BIT")).encoding)
-    assert_equal(Encoding::UTF_8, CGI.escape("\xC0\<\<".dup.force_encoding("UTF-8")).encoding)
-  end
-
-  def test_cgi_unescape
-    str = CGI.unescape('%26%3C%3E%22+%E3%82%86%E3%82%93%E3%82%86%E3%82%93')
-    assert_equal(@str1, str)
-    return unless defined?(::Encoding)
-
-    assert_equal(@str1.encoding, str.encoding)
-    assert_equal("\u{30E1 30E2 30EA 691C 7D22}", CGI.unescape("\u{30E1 30E2 30EA}%E6%A4%9C%E7%B4%A2"))
-  end
-
-  def test_cgi_unescape_preserve_encoding
-    assert_equal(Encoding::US_ASCII, CGI.unescape("%C0%3C%3C".dup.force_encoding("US-ASCII")).encoding)
-    assert_equal(Encoding::ASCII_8BIT, CGI.unescape("%C0%3C%3C".dup.force_encoding("ASCII-8BIT")).encoding)
-    assert_equal(Encoding::UTF_8, CGI.unescape("%C0%3C%3C".dup.force_encoding("UTF-8")).encoding)
-  end
-
-  def test_cgi_unescape_accept_charset
-    return unless defined?(::Encoding)
-
-    assert_raise(TypeError) {CGI.unescape('', nil)}
-    assert_separately(%w[-rcgi/util], "#{<<-"begin;"}\n#{<<-"end;"}")
-    begin;
-      assert_equal("", CGI.unescape(''))
-    end;
-  end
-
-  def test_cgi_escapeURIComponent
-    assert_equal('%26%3C%3E%22%20%E3%82%86%E3%82%93%E3%82%86%E3%82%93', CGI.escapeURIComponent(@str1))
-    assert_equal('%26%3C%3E%22%20%E3%82%86%E3%82%93%E3%82%86%E3%82%93'.ascii_only?, CGI.escapeURIComponent(@str1).ascii_only?) if defined?(::Encoding)
-  end
-
-  def test_cgi_escape_uri_component
-    assert_equal('%26%3C%3E%22%20%E3%82%86%E3%82%93%E3%82%86%E3%82%93', CGI.escape_uri_component(@str1))
-  end
-
-  def test_cgi_escapeURIComponent_with_unreserved_characters
-    assert_equal("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-._~",
-                 CGI.escapeURIComponent("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-._~"),
-                 "should not encode any unreserved characters, as per RFC3986 Section 2.3")
-  end
-
-  def test_cgi_escapeURIComponent_with_invalid_byte_sequence
-    assert_equal('%C0%3C%3C', CGI.escapeURIComponent("\xC0\<\<".dup.force_encoding("UTF-8")))
-  end
-
-  def test_cgi_escapeURIComponent_preserve_encoding
-    assert_equal(Encoding::US_ASCII, CGI.escapeURIComponent("\xC0\<\<".dup.force_encoding("US-ASCII")).encoding)
-    assert_equal(Encoding::ASCII_8BIT, CGI.escapeURIComponent("\xC0\<\<".dup.force_encoding("ASCII-8BIT")).encoding)
-    assert_equal(Encoding::UTF_8, CGI.escapeURIComponent("\xC0\<\<".dup.force_encoding("UTF-8")).encoding)
-  end
-
-  def test_cgi_unescapeURIComponent
-    str = CGI.unescapeURIComponent('%26%3C%3E%22%20%E3%82%86%E3%82%93%E3%82%86%E3%82%93')
-    assert_equal(@str1, str)
-    return unless defined?(::Encoding)
-
-    assert_equal("foo+bar", CGI.unescapeURIComponent("foo+bar"))
-
-    assert_equal(@str1.encoding, str.encoding)
-    assert_equal("\u{30E1 30E2 30EA 691C 7D22}", CGI.unescapeURIComponent("\u{30E1 30E2 30EA}%E6%A4%9C%E7%B4%A2"))
-  end
-
-  def test_cgi_unescape_uri_component
-    str = CGI.unescape_uri_component('%26%3C%3E%22%20%E3%82%86%E3%82%93%E3%82%86%E3%82%93')
-    assert_equal(@str1, str)
-  end
-
-  def test_cgi_unescapeURIComponent_preserve_encoding
-    assert_equal(Encoding::US_ASCII, CGI.unescapeURIComponent("%C0%3C%3C".dup.force_encoding("US-ASCII")).encoding)
-    assert_equal(Encoding::ASCII_8BIT, CGI.unescapeURIComponent("%C0%3C%3C".dup.force_encoding("ASCII-8BIT")).encoding)
-    assert_equal(Encoding::UTF_8, CGI.unescapeURIComponent("%C0%3C%3C".dup.force_encoding("UTF-8")).encoding)
-  end
-
-  def test_cgi_unescapeURIComponent_accept_charset
-    return unless defined?(::Encoding)
-
-    assert_raise(TypeError) {CGI.unescapeURIComponent('', nil)}
-    assert_separately(%w[-rcgi/util], "#{<<-"begin;"}\n#{<<-"end;"}")
-    begin;
-      assert_equal("", CGI.unescapeURIComponent(''))
-    end;
-  end
-
-  def test_cgi_pretty
-    assert_equal("<HTML>\n  <BODY>\n  </BODY>\n</HTML>\n",CGI.pretty("<HTML><BODY></BODY></HTML>"))
-    assert_equal("<HTML>\n\t<BODY>\n\t</BODY>\n</HTML>\n",CGI.pretty("<HTML><BODY></BODY></HTML>","\t"))
-  end
-
-  def test_cgi_escapeHTML
-    assert_equal("'&"><", CGI.escapeHTML("'&\"><"))
-  end
-
-  def test_cgi_escape_html_duplicated
-    orig = "Ruby".dup.force_encoding("US-ASCII")
-    str = CGI.escapeHTML(orig)
-    assert_equal(orig, str)
-    assert_not_same(orig, str)
-  end
-
-  def assert_cgi_escape_html_preserve_encoding(str, encoding)
-    assert_equal(encoding, CGI.escapeHTML(str.dup.force_encoding(encoding)).encoding)
-  end
-
-  def test_cgi_escape_html_preserve_encoding
-    Encoding.list do |enc|
-      assert_cgi_escape_html_preserve_encoding("'&\"><", enc)
-      assert_cgi_escape_html_preserve_encoding("Ruby", enc)
-    end
-  end
-
-  def test_cgi_escape_html_dont_freeze
-    assert_not_predicate CGI.escapeHTML("'&\"><".dup),    :frozen?
-    assert_not_predicate CGI.escapeHTML("'&\"><".freeze), :frozen?
-    assert_not_predicate CGI.escapeHTML("Ruby".dup),      :frozen?
-    assert_not_predicate CGI.escapeHTML("Ruby".freeze),   :frozen?
-  end
-
-  def test_cgi_escape_html_large
-    return if RUBY_ENGINE == 'jruby'
-    ulong_max, size_max = RbConfig::LIMITS.values_at("ULONG_MAX", "SIZE_MAX")
-    return unless ulong_max < size_max # Platforms not concerned
-
-    size = (ulong_max / 6 + 1)
-    begin
-      str = '"' * size
-      escaped = CGI.escapeHTML(str)
-    rescue NoMemoryError
-      omit "Not enough memory"
-    rescue => e
-    end
-    assert_raise_with_message(ArgumentError, /overflow/, ->{"length = #{escaped.length}"}) do
-      raise e if e
-    end
-  end
-
-  def test_cgi_unescapeHTML
-    assert_equal("'&\"><", CGI.unescapeHTML("'&"><"))
-  end
-
-  def test_cgi_unescapeHTML_invalid
-    assert_equal('&<&>"&abcdefghijklmn', CGI.unescapeHTML('&<&>"&abcdefghijklmn'))
-  end
-
-  module UnescapeHTMLTests
-    def test_cgi_unescapeHTML_following_known_first_letter
-      assert_equal('&a>&q>&l>&g>', CGI.unescapeHTML('&a>&q>&l>&g>'))
-    end
-
-    def test_cgi_unescapeHTML_following_number_sign
-      assert_equal('&#>&#x>', CGI.unescapeHTML('&#>&#x>'))
-    end
-
-    def test_cgi_unescapeHTML_following_invalid_numeric
-      assert_equal('�>�>', CGI.unescapeHTML('�>�>'))
-    end
-  end
-
-  include UnescapeHTMLTests
-
-  Encoding.list.each do |enc|
-    begin
-      escaped = "'&"><".encode(enc)
-      unescaped = "'&\"><".encode(enc)
-    rescue Encoding::ConverterNotFoundError
-      next
-    else
-      define_method("test_cgi_escapeHTML:#{enc.name}") do
-        assert_equal(escaped, CGI.escapeHTML(unescaped))
-      end
-      define_method("test_cgi_unescapeHTML:#{enc.name}") do
-        assert_equal(unescaped, CGI.unescapeHTML(escaped))
-      end
-    end
-  end
-
-  Encoding.list.each do |enc|
-    next unless enc.ascii_compatible?
-    begin
-      escaped = "%25+%2B"
-      unescaped = "% +".encode(enc)
-    rescue Encoding::ConverterNotFoundError
-      next
-    else
-      define_method("test_cgi_escape:#{enc.name}") do
-        assert_equal(escaped, CGI.escape(unescaped))
-      end
-      define_method("test_cgi_unescape:#{enc.name}") do
-        assert_equal(unescaped, CGI.unescape(escaped, enc))
-      end
-    end
-  end
-
-  def test_cgi_unescapeHTML_uppercasecharacter
-    assert_equal("\xE3\x81\x82\xE3\x81\x84\xE3\x81\x86", CGI.unescapeHTML("あいう"))
-  end
-
-  def test_cgi_include_escape
-    assert_equal('%26%3C%3E%22+%E3%82%86%E3%82%93%E3%82%86%E3%82%93', escape(@str1))
-  end
-
-  def test_cgi_include_escapeHTML
-    assert_equal("'&"><", escapeHTML("'&\"><"))
-  end
-
-  def test_cgi_include_h
-    assert_equal("'&"><", h("'&\"><"))
-  end
-
-  def test_cgi_include_unescape
-    str = unescape('%26%3C%3E%22+%E3%82%86%E3%82%93%E3%82%86%E3%82%93')
-    assert_equal(@str1, str)
-    return unless defined?(::Encoding)
-
-    assert_equal(@str1.encoding, str.encoding)
-    assert_equal("\u{30E1 30E2 30EA 691C 7D22}", unescape("\u{30E1 30E2 30EA}%E6%A4%9C%E7%B4%A2"))
-  end
-
-  def test_cgi_include_unescapeHTML
-    assert_equal("'&\"><", unescapeHTML("'&"><"))
-  end
-
-  def test_cgi_escapeElement
-    assert_equal("<BR><A HREF="url"></A>", escapeElement('<BR><A HREF="url"></A>', "A", "IMG"))
-    assert_equal("<BR><A HREF="url"></A>", escapeElement('<BR><A HREF="url"></A>', ["A", "IMG"]))
-    assert_equal("<BR><A HREF="url"></A>", escape_element('<BR><A HREF="url"></A>', "A", "IMG"))
-    assert_equal("<BR><A HREF="url"></A>", escape_element('<BR><A HREF="url"></A>', ["A", "IMG"]))
-  end
-
-
-  def test_cgi_unescapeElement
-    assert_equal('<BR><A HREF="url"></A>', unescapeElement(escapeHTML('<BR><A HREF="url"></A>'), "A", "IMG"))
-    assert_equal('<BR><A HREF="url"></A>', unescapeElement(escapeHTML('<BR><A HREF="url"></A>'), ["A", "IMG"]))
-    assert_equal('<BR><A HREF="url"></A>', unescape_element(escapeHTML('<BR><A HREF="url"></A>'), "A", "IMG"))
-    assert_equal('<BR><A HREF="url"></A>', unescape_element(escapeHTML('<BR><A HREF="url"></A>'), ["A", "IMG"]))
-  end
-end
-
-class CGIUtilPureRubyTest < Test::Unit::TestCase
-  def setup
-    CGI::Escape.module_eval do
-      alias _escapeHTML escapeHTML
-      remove_method :escapeHTML
-      alias _unescapeHTML unescapeHTML
-      remove_method :unescapeHTML
-    end if defined?(CGI::Escape)
-  end
-
-  def teardown
-    CGI::Escape.module_eval do
-      alias escapeHTML _escapeHTML
-      remove_method :_escapeHTML
-      alias unescapeHTML _unescapeHTML
-      remove_method :_unescapeHTML
-    end if defined?(CGI::Escape)
-  end
-
-  include CGIUtilTest::UnescapeHTMLTests
-
-  def test_cgi_escapeHTML_with_invalid_byte_sequence
-    assert_equal("<\xA4??>", CGI.escapeHTML(%[<\xA4??>]))
-  end
-
-  def test_cgi_unescapeHTML_with_invalid_byte_sequence
-    input = "\xFF&"
-    assert_equal(input, CGI.unescapeHTML(input))
-  end
-end
diff --git a/test/mri/cgi/testdata/file1.html b/test/mri/cgi/testdata/file1.html
deleted file mode 100644
index 2ceaf6bc393..00000000000
--- a/test/mri/cgi/testdata/file1.html
+++ /dev/null
@@ -1,10 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-<html>
-  <head>
-    <title>ムスカ大佐のひとりごと</title>
-    <meta http-equiv="Content-Type" content="text/html; charset=UTF8">
-  </head>
-  <body>
-    <p>バカどもにはちょうどいい目くらましだ。</p>
-  </body>
-</html>
diff --git a/test/mri/cgi/testdata/large.png b/test/mri/cgi/testdata/large.png
deleted file mode 100644
index d716396fa3ed727569ea9f7ab8a724eddd348eb6..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 156414
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%0De&U?-FMZ&v*8n{@x%jNpGnw}!2HP@}q
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	PkNnAIS8w*d%uJod!u
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

diff --git a/test/mri/cgi/testdata/small.png b/test/mri/cgi/testdata/small.png
deleted file mode 100644
index 753d58e3cbbf046542f12d466989dc4089484f98..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 82
zcmeAS@N?&q;$mQ6;PUiv2?ElBAk4u8B)9NiSPP`2JY5_^G$tnh`TyUZxwD}&glln?
f+t;2~jm!*P8O-wUbY=n-F)(<#`njxgN@xNA9T*nL

diff --git a/test/mri/fiddle/helper.rb b/test/mri/fiddle/helper.rb
deleted file mode 100644
index 457e02f5951..00000000000
--- a/test/mri/fiddle/helper.rb
+++ /dev/null
@@ -1,202 +0,0 @@
-# frozen_string_literal: true
-
-require 'rbconfig/sizeof'
-require 'test/unit'
-require 'fiddle'
-
-puts("Fiddle::VERSION: #{Fiddle::VERSION}") if $VERBOSE
-
-# FIXME: this is stolen from DL and needs to be refactored.
-
-libc_so = libm_so = nil
-
-if RUBY_ENGINE == "jruby"
-  # "jruby ... [x86_64-linux]" -> "x86_64-linux"
-  ruby_platform = RUBY_DESCRIPTION.split(" ").last[1..-2]
-else
-  ruby_platform = RUBY_PLATFORM
-end
-case ruby_platform
-when /cygwin/
-  libc_so = "cygwin1.dll"
-  libm_so = "cygwin1.dll"
-when /android/
-  libdir = '/system/lib'
-  if [0].pack('L!').size == 8
-    libdir = '/system/lib64'
-  end
-  libc_so = File.join(libdir, "libc.so")
-  libm_so = File.join(libdir, "libm.so")
-when /linux-musl/
-  Dir.glob('/lib/ld-musl-*.so.1') do |ld|
-    libc_so = libm_so = ld
-  end
-when /linux/
-  libdir = '/lib'
-  case RbConfig::SIZEOF['void*']
-  when 4
-    # 32-bit ruby
-    case RUBY_PLATFORM
-    when /armv\w+-linux/
-      # In the ARM 32-bit libc package such as libc6:armhf libc6:armel,
-      # libc.so and libm.so are installed to /lib/arm-linux-gnu*.
-      # It's not installed to /lib32.
-      dir, = Dir.glob('/lib/arm-linux-gnu*')
-      libdir = dir if dir && File.directory?(dir)
-    else
-      libdir = '/lib32' if File.directory? '/lib32'
-    end
-  when 8
-    # 64-bit ruby
-    libdir = '/lib64' if File.directory? '/lib64'
-  end
-
-  # Handle musl libc
-  libc_so, = Dir.glob(File.join(libdir, "libc.musl*.so*"))
-  if libc_so
-    libm_so = libc_so
-  else
-    # glibc
-    case RUBY_PLATFORM
-    when /alpha-linux/, /ia64-linux/
-      libc_so = "libc.so.6.1"
-      libm_so = "libm.so.6.1"
-    else
-      libc_so = "libc.so.6"
-      libm_so = "libm.so.6"
-    end
-  end
-when /mingw/, /mswin/
-  require "rbconfig"
-  crtname = RbConfig::CONFIG["RUBY_SO_NAME"][/msvc\w+/] || 'ucrtbase'
-  libc_so = libm_so = "#{crtname}.dll"
-when /darwin/
-  libc_so = libm_so = "/usr/lib/libSystem.B.dylib"
-  # macOS 11.0+ removed libSystem.B.dylib from /usr/lib. But It works with dlopen.
-  rigid_path = true
-when /kfreebsd/
-  libc_so = "/lib/libc.so.0.1"
-  libm_so = "/lib/libm.so.1"
-when /gnu/	#GNU/Hurd
-  libc_so = "/lib/libc.so.0.3"
-  libm_so = "/lib/libm.so.6"
-when /mirbsd/
-  libc_so = "/usr/lib/libc.so.41.10"
-  libm_so = "/usr/lib/libm.so.7.0"
-when /freebsd/
-  libc_so = "/lib/libc.so.7"
-  libm_so = "/lib/libm.so.5"
-when /bsd|dragonfly/
-  libc_so = "/usr/lib/libc.so"
-  libm_so = "/usr/lib/libm.so"
-when /solaris/
-  libdir = '/lib'
-  case RbConfig::SIZEOF['void*']
-  when 4
-    # 32-bit ruby
-    libdir = '/lib' if File.directory? '/lib'
-  when 8
-    # 64-bit ruby
-    libdir = '/lib/64' if File.directory? '/lib/64'
-  end
-  libc_so = File.join(libdir, "libc.so")
-  libm_so = File.join(libdir, "libm.so")
-when /aix/
-  pwd=Dir.pwd
-  libc_so = libm_so = "#{pwd}/libaixdltest.so"
-  unless File.exist? libc_so
-    cobjs=%w!strcpy.o!
-    mobjs=%w!floats.o sin.o!
-    funcs=%w!sin sinf strcpy strncpy!
-    expfile='dltest.exp'
-    require 'tmpdir'
-    Dir.mktmpdir do |_dir|
-      begin
-        Dir.chdir _dir
-        %x!/usr/bin/ar x /usr/lib/libc.a #{cobjs.join(' ')}!
-        %x!/usr/bin/ar x /usr/lib/libm.a #{mobjs.join(' ')}!
-        %x!echo "#{funcs.join("\n")}\n" > #{expfile}!
-        require 'rbconfig'
-        if RbConfig::CONFIG["GCC"] = 'yes'
-          lflag='-Wl,'
-        else
-          lflag=''
-        end
-        flags="#{lflag}-bE:#{expfile} #{lflag}-bnoentry -lm"
-        %x!#{RbConfig::CONFIG["LDSHARED"]} -o #{libc_so} #{(cobjs+mobjs).join(' ')} #{flags}!
-      ensure
-        Dir.chdir pwd
-      end
-    end
-  end
-when /haiku/
-  libdir = '/system/lib'
-  case [0].pack('L!').size
-  when 4
-    # 32-bit ruby
-    libdir = '/system/lib/x86' if File.directory? '/system/lib/x86'
-  when 8
-    # 64-bit ruby
-    libdir = '/system/lib/' if File.directory? '/system/lib/'
-  end
-  libc_so = File.join(libdir, "libroot.so")
-  libm_so = File.join(libdir, "libroot.so")
-else
-  libc_so = ARGV[0] if ARGV[0] && ARGV[0][0] == ?/
-  libm_so = ARGV[1] if ARGV[1] && ARGV[1][0] == ?/
-  if( !(libc_so && libm_so) )
-    $stderr.puts("libc and libm not found: #{$0} <libc> <libm>")
-  end
-end
-
-unless rigid_path
-  libc_so = nil if libc_so && libc_so[0] == ?/ && !File.file?(libc_so)
-  libm_so = nil if libm_so && libm_so[0] == ?/ && !File.file?(libm_so)
-end
-
-if !libc_so || !libm_so
-  require "envutil"
-  ruby = EnvUtil.rubybin
-  # When the ruby binary is 32-bit and the host is 64-bit,
-  # `ldd ruby` outputs "not a dynamic executable" message.
-  # libc_so and libm_so are not set.
-  ldd = `ldd #{ruby}`
-  #puts ldd
-  libc_so = $& if !libc_so && %r{/\S*/libc\.so\S*} =~ ldd
-  libm_so = $& if !libm_so && %r{/\S*/libm\.so\S*} =~ ldd
-  #p [libc_so, libm_so]
-end
-
-Fiddle::LIBC_SO = libc_so
-Fiddle::LIBM_SO = libm_so
-
-module Fiddle
-  class TestCase < Test::Unit::TestCase
-    def setup
-      @libc = Fiddle.dlopen(LIBC_SO)
-      @libm = Fiddle.dlopen(LIBM_SO)
-    end
-
-    def teardown
-      if /linux/ =~ RUBY_PLATFORM
-        GC.start
-      end
-    end
-
-    def ffi_backend?
-      RUBY_ENGINE != 'ruby'
-    end
-
-    def under_gc_stress
-      stress, GC.stress = GC.stress, true
-      yield
-    ensure
-      GC.stress = stress
-    end
-
-    def assert_ractor_shareable(object)
-      Ractor.make_shareable(object)
-      assert_operator(Ractor, :shareable?, object)
-    end
-  end
-end
diff --git a/test/mri/fiddle/test_c_struct_builder.rb b/test/mri/fiddle/test_c_struct_builder.rb
deleted file mode 100644
index ca44c6cf7a6..00000000000
--- a/test/mri/fiddle/test_c_struct_builder.rb
+++ /dev/null
@@ -1,69 +0,0 @@
-# frozen_string_literal: true
-begin
-  require_relative 'helper'
-  require 'fiddle/struct'
-  require 'fiddle/cparser'
-  require 'fiddle/import'
-rescue LoadError
-end
-
-module Fiddle
-  class TestCStructBuilder < TestCase
-    include Fiddle::CParser
-    extend Fiddle::Importer
-
-    RBasic = struct ['void * flags',
-                     'void * klass' ]
-
-
-    RObject = struct [
-      { 'basic' => RBasic },
-      { 'as'    => union([
-                          { 'heap'=> struct([ 'uint32_t numiv',
-                                              'void * ivptr',
-                                              'void * iv_index_tbl' ]) },
-                             'void *ary[3]' ])}
-    ]
-
-
-    def test_basic_embedded_members
-      assert_equal 0, RObject.offsetof("basic.flags")
-      assert_equal Fiddle::SIZEOF_VOIDP, RObject.offsetof("basic.klass")
-    end
-
-    def test_embedded_union_members
-      assert_equal 2 * Fiddle::SIZEOF_VOIDP, RObject.offsetof("as")
-      assert_equal 2 * Fiddle::SIZEOF_VOIDP, RObject.offsetof("as.heap")
-      assert_equal 2 * Fiddle::SIZEOF_VOIDP, RObject.offsetof("as.heap.numiv")
-      assert_equal 3 * Fiddle::SIZEOF_VOIDP, RObject.offsetof("as.heap.ivptr")
-      assert_equal 4 * Fiddle::SIZEOF_VOIDP, RObject.offsetof("as.heap.iv_index_tbl")
-    end
-
-    def test_as_ary
-      assert_equal 2 * Fiddle::SIZEOF_VOIDP, RObject.offsetof("as.ary")
-    end
-
-    def test_offsetof
-      types, members = parse_struct_signature(['int64_t i','char c'])
-      my_struct = Fiddle::CStructBuilder.create(Fiddle::CStruct, types, members)
-      assert_equal 0, my_struct.offsetof("i")
-      assert_equal Fiddle::SIZEOF_INT64_T, my_struct.offsetof("c")
-    end
-
-    def test_offset_with_gap
-      types, members = parse_struct_signature(['void *p', 'char c', 'long x'])
-      my_struct = Fiddle::CStructBuilder.create(Fiddle::CStruct, types, members)
-
-      assert_equal PackInfo.align(0, ALIGN_VOIDP), my_struct.offsetof("p")
-      assert_equal PackInfo.align(SIZEOF_VOIDP, ALIGN_CHAR), my_struct.offsetof("c")
-      assert_equal SIZEOF_VOIDP + PackInfo.align(SIZEOF_CHAR, ALIGN_LONG), my_struct.offsetof("x")
-    end
-
-    def test_union_offsetof
-      types, members = parse_struct_signature(['int64_t i','char c'])
-      my_struct = Fiddle::CStructBuilder.create(Fiddle::CUnion, types, members)
-      assert_equal 0, my_struct.offsetof("i")
-      assert_equal 0, my_struct.offsetof("c")
-    end
-  end
-end if defined?(Fiddle)
diff --git a/test/mri/fiddle/test_c_struct_entry.rb b/test/mri/fiddle/test_c_struct_entry.rb
deleted file mode 100644
index 45de2efe21f..00000000000
--- a/test/mri/fiddle/test_c_struct_entry.rb
+++ /dev/null
@@ -1,171 +0,0 @@
-# frozen_string_literal: true
-begin
-  require_relative 'helper'
-  require 'fiddle/struct'
-rescue LoadError
-end
-
-module Fiddle
-  class TestCStructEntity < TestCase
-    def test_class_size
-      types = [TYPE_DOUBLE, TYPE_CHAR, TYPE_DOUBLE, TYPE_BOOL]
-
-      size = CStructEntity.size types
-
-      alignments = types.map { |type| PackInfo::ALIGN_MAP[type] }
-
-      expected = PackInfo.align 0, alignments[0]
-      expected += PackInfo::SIZE_MAP[TYPE_DOUBLE]
-
-      expected = PackInfo.align expected, alignments[1]
-      expected += PackInfo::SIZE_MAP[TYPE_CHAR]
-
-      expected = PackInfo.align expected, alignments[2]
-      expected += PackInfo::SIZE_MAP[TYPE_DOUBLE]
-
-      expected = PackInfo.align expected, alignments[3]
-      expected += PackInfo::SIZE_MAP[TYPE_BOOL]
-
-      expected = PackInfo.align expected, alignments.max
-
-      assert_equal expected, size
-    end
-
-    def test_class_size_with_count
-      size = CStructEntity.size([[TYPE_DOUBLE, 2], [TYPE_CHAR, 20]])
-
-      types = [TYPE_DOUBLE, TYPE_CHAR]
-      alignments = types.map { |type| PackInfo::ALIGN_MAP[type] }
-
-      expected = PackInfo.align 0, alignments[0]
-      expected += PackInfo::SIZE_MAP[TYPE_DOUBLE] * 2
-
-      expected = PackInfo.align expected, alignments[1]
-      expected += PackInfo::SIZE_MAP[TYPE_CHAR] * 20
-
-      expected = PackInfo.align expected, alignments.max
-
-      assert_equal expected, size
-    end
-
-    def test_set_ctypes
-      CStructEntity.malloc([TYPE_INT, TYPE_LONG], Fiddle::RUBY_FREE) do |struct|
-        struct.assign_names %w[int long]
-
-        # this test is roundabout because the stored ctypes are not accessible
-        struct['long'] = 1
-        struct['int'] = 2
-
-        assert_equal 1, struct['long']
-        assert_equal 2, struct['int']
-      end
-    end
-
-    def test_aref_pointer_array
-      CStructEntity.malloc([[TYPE_VOIDP, 2]], Fiddle::RUBY_FREE) do |team|
-        team.assign_names(["names"])
-        Fiddle::Pointer.malloc(6, Fiddle::RUBY_FREE) do |alice|
-          alice[0, 6] = "Alice\0"
-          Fiddle::Pointer.malloc(4, Fiddle::RUBY_FREE) do |bob|
-            bob[0, 4] = "Bob\0"
-            team["names"] = [alice, bob]
-            assert_equal(["Alice", "Bob"], team["names"].map(&:to_s))
-          end
-        end
-      end
-    end
-
-    def test_aref_pointer
-      CStructEntity.malloc([TYPE_VOIDP], Fiddle::RUBY_FREE) do |user|
-        user.assign_names(["name"])
-        Fiddle::Pointer.malloc(6, Fiddle::RUBY_FREE) do |alice|
-          alice[0, 6] = "Alice\0"
-          user["name"] = alice
-          assert_equal("Alice", user["name"].to_s)
-        end
-      end
-    end
-
-    def test_new_double_free
-      types = [TYPE_INT]
-      Pointer.malloc(CStructEntity.size(types), Fiddle::RUBY_FREE) do |pointer|
-        assert_raise ArgumentError do
-          CStructEntity.new(pointer, types, Fiddle::RUBY_FREE)
-        end
-      end
-    end
-
-    def test_malloc_block
-      escaped_struct = nil
-      returned = CStructEntity.malloc([TYPE_INT], Fiddle::RUBY_FREE) do |struct|
-        assert_equal Fiddle::SIZEOF_INT, struct.size
-        assert_equal Fiddle::RUBY_FREE, struct.free.to_i
-        escaped_struct = struct
-        :returned
-      end
-      assert_equal :returned, returned
-      assert escaped_struct.freed?
-    end
-
-    def test_malloc_block_no_free
-      assert_raise ArgumentError do
-        CStructEntity.malloc([TYPE_INT]) { |struct| }
-      end
-    end
-
-    def test_free
-      struct = CStructEntity.malloc([TYPE_INT])
-      begin
-        assert_nil struct.free
-      ensure
-        Fiddle.free struct
-      end
-    end
-
-    def test_free_with_func
-      struct = CStructEntity.malloc([TYPE_INT], Fiddle::RUBY_FREE)
-      refute struct.freed?
-      struct.call_free
-      assert struct.freed?
-      struct.call_free                 # you can safely run it again
-      assert struct.freed?
-      GC.start                         # you can safely run the GC routine
-      assert struct.freed?
-    end
-
-    def test_free_with_no_func
-      struct = CStructEntity.malloc([TYPE_INT])
-      refute struct.freed?
-      struct.call_free
-      refute struct.freed?
-      struct.call_free                 # you can safely run it again
-      refute struct.freed?
-    end
-
-    def test_freed?
-      struct = CStructEntity.malloc([TYPE_INT], Fiddle::RUBY_FREE)
-      refute struct.freed?
-      struct.call_free
-      assert struct.freed?
-    end
-
-    def test_null?
-      struct = CStructEntity.malloc([TYPE_INT], Fiddle::RUBY_FREE)
-      refute struct.null?
-    end
-
-    def test_size
-      CStructEntity.malloc([TYPE_INT], Fiddle::RUBY_FREE) do |struct|
-        assert_equal Fiddle::SIZEOF_INT, struct.size
-      end
-    end
-
-    def test_size=
-      CStructEntity.malloc([TYPE_INT], Fiddle::RUBY_FREE) do |struct|
-        assert_raise NoMethodError do
-          struct.size = 1
-        end
-      end
-    end
-  end
-end if defined?(Fiddle)
diff --git a/test/mri/fiddle/test_c_union_entity.rb b/test/mri/fiddle/test_c_union_entity.rb
deleted file mode 100644
index e0a37575625..00000000000
--- a/test/mri/fiddle/test_c_union_entity.rb
+++ /dev/null
@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-begin
-  require_relative 'helper'
-  require 'fiddle/struct'
-rescue LoadError
-end
-
-
-module Fiddle
-  class TestCUnionEntity < TestCase
-    def test_class_size
-      size = CUnionEntity.size([TYPE_DOUBLE, TYPE_CHAR])
-
-      assert_equal SIZEOF_DOUBLE, size
-    end
-
-    def test_class_size_with_count
-      size = CUnionEntity.size([[TYPE_DOUBLE, 2], [TYPE_CHAR, 20]])
-
-      assert_equal SIZEOF_CHAR * 20, size
-    end
-
-    def test_set_ctypes
-      CUnionEntity.malloc([TYPE_INT, TYPE_LONG], Fiddle::RUBY_FREE) do |union|
-        union.assign_names %w[int long]
-
-        # this test is roundabout because the stored ctypes are not accessible
-        union['long'] = 1
-        assert_equal 1, union['long']
-
-        union['int'] = 1
-        assert_equal 1, union['int']
-      end
-    end
-  end
-end if defined?(Fiddle)
diff --git a/test/mri/fiddle/test_closure.rb b/test/mri/fiddle/test_closure.rb
deleted file mode 100644
index 26cff8e516b..00000000000
--- a/test/mri/fiddle/test_closure.rb
+++ /dev/null
@@ -1,173 +0,0 @@
-# frozen_string_literal: true
-begin
-  require_relative 'helper'
-rescue LoadError
-end
-
-module Fiddle
-  class TestClosure < Fiddle::TestCase
-    def teardown
-      super
-      # We can't use ObjectSpace with JRuby.
-      return if RUBY_ENGINE == "jruby"
-      # Ensure freeing all closures.
-      # See https://github.com/ruby/fiddle/issues/102#issuecomment-1241763091 .
-      not_freed_closures = []
-      ObjectSpace.each_object(Fiddle::Closure) do |closure|
-        not_freed_closures << closure unless closure.freed?
-      end
-      assert_equal([], not_freed_closures)
-    end
-
-    def test_argument_errors
-      assert_raise(TypeError) do
-        Closure.new(TYPE_INT, TYPE_INT)
-      end
-
-      assert_raise(TypeError) do
-        Closure.new('foo', [TYPE_INT])
-      end
-
-      assert_raise(TypeError) do
-        Closure.new(TYPE_INT, ['meow!'])
-      end
-    end
-
-    def test_call
-      closure_class = Class.new(Closure) do
-        def call
-          10
-        end
-      end
-      closure_class.create(TYPE_INT, []) do |closure|
-        func = Function.new(closure, [], TYPE_INT)
-        assert_equal 10, func.call
-      end
-    end
-
-    def test_returner
-      closure_class = Class.new(Closure) do
-        def call thing
-          thing
-        end
-      end
-      closure_class.create(TYPE_INT, [TYPE_INT]) do |closure|
-        func = Function.new(closure, [TYPE_INT], TYPE_INT)
-        assert_equal 10, func.call(10)
-      end
-    end
-
-    def test_const_string
-      if ffi_backend?
-        omit("Closure with :const_string works but " +
-             "Function with :const_string doesn't work with FFI backend")
-      end
-
-      closure_class = Class.new(Closure) do
-        def call(string)
-          @return_string = "Hello! #{string}"
-          @return_string
-        end
-      end
-      closure_class.create(:const_string, [:const_string]) do |closure|
-        func = Function.new(closure, [:const_string], :const_string)
-        assert_equal("Hello! World!", func.call("World!"))
-      end
-    end
-
-    def test_bool
-      closure_class = Class.new(Closure) do
-        def call(bool)
-          not bool
-        end
-      end
-      closure_class.create(:bool, [:bool]) do |closure|
-        func = Function.new(closure, [:bool], :bool)
-        assert_equal(false, func.call(true))
-      end
-    end
-
-    def test_free
-      closure_class = Class.new(Closure) do
-        def call
-          10
-        end
-      end
-      closure_class.create(:int, [:void]) do |closure|
-        assert(!closure.freed?)
-        closure.free
-        assert(closure.freed?)
-        closure.free
-      end
-    end
-
-    def test_block_caller
-      cb = Closure::BlockCaller.new(TYPE_INT, [TYPE_INT]) do |one|
-        one
-      end
-      begin
-        func = Function.new(cb, [TYPE_INT], TYPE_INT)
-        assert_equal 11, func.call(11)
-      ensure
-        cb.free
-      end
-    end
-
-    def test_memsize_ruby_dev_42480
-      if RUBY_ENGINE == "jruby"
-        omit("We can't use ObjectSpace with JRuby")
-      end
-
-      require 'objspace'
-      closure_class = Class.new(Closure) do
-        def call
-          10
-        end
-      end
-      n = 10000
-      n.times do
-        closure_class.create(:int, [:void]) do |closure|
-          ObjectSpace.memsize_of(closure)
-        end
-      end
-    end
-
-    %w[INT SHORT CHAR LONG LONG_LONG].each do |name|
-      type = Fiddle.const_get("TYPE_#{name}") rescue next
-      size = Fiddle.const_get("SIZEOF_#{name}")
-      [[type, size-1, name], [-type, size, "unsigned_"+name]].each do |t, s, n|
-        define_method("test_conversion_#{n.downcase}") do
-          arg = nil
-
-          closure_class = Class.new(Closure) do
-            define_method(:call) {|x| arg = x}
-          end
-          closure_class.create(t, [t]) do |closure|
-            v = ~(~0 << (8*s))
-
-            arg = nil
-            assert_equal(v, closure.call(v))
-            assert_equal(arg, v, n)
-
-            arg = nil
-            func = Function.new(closure, [t], t)
-            assert_equal(v, func.call(v))
-            assert_equal(arg, v, n)
-          end
-        end
-      end
-    end
-
-    def test_ractor_shareable
-      omit("Need Ractor") unless defined?(Ractor)
-      closure_class = Class.new(Closure) do
-        def call
-          0
-        end
-      end
-      closure_class.create(:int, [:void]) do |c|
-        assert_ractor_shareable(c)
-      end
-    end
-  end
-end if defined?(Fiddle)
diff --git a/test/mri/fiddle/test_cparser.rb b/test/mri/fiddle/test_cparser.rb
deleted file mode 100644
index f1b67476ba8..00000000000
--- a/test/mri/fiddle/test_cparser.rb
+++ /dev/null
@@ -1,414 +0,0 @@
-# frozen_string_literal: true
-begin
-  require_relative 'helper'
-  require 'fiddle/cparser'
-  require 'fiddle/import'
-rescue LoadError
-end
-
-module Fiddle
-  class TestCParser < TestCase
-    include CParser
-
-    def test_char_ctype
-      assert_equal(TYPE_CHAR, parse_ctype('char'))
-      assert_equal(TYPE_CHAR, parse_ctype('const char'))
-      assert_equal(TYPE_CHAR, parse_ctype('signed char'))
-      assert_equal(TYPE_CHAR, parse_ctype('const signed char'))
-      assert_equal(-TYPE_CHAR, parse_ctype('unsigned char'))
-      assert_equal(-TYPE_CHAR, parse_ctype('const unsigned char'))
-    end
-
-    def test_short_ctype
-      assert_equal(TYPE_SHORT, parse_ctype('short'))
-      assert_equal(TYPE_SHORT, parse_ctype('const short'))
-      assert_equal(TYPE_SHORT, parse_ctype('short int'))
-      assert_equal(TYPE_SHORT, parse_ctype('const short int'))
-      assert_equal(TYPE_SHORT, parse_ctype('int short'))
-      assert_equal(TYPE_SHORT, parse_ctype('const int short'))
-      assert_equal(TYPE_SHORT, parse_ctype('signed short'))
-      assert_equal(TYPE_SHORT, parse_ctype('const signed short'))
-      assert_equal(TYPE_SHORT, parse_ctype('short signed'))
-      assert_equal(TYPE_SHORT, parse_ctype('const short signed'))
-      assert_equal(TYPE_SHORT, parse_ctype('signed short int'))
-      assert_equal(TYPE_SHORT, parse_ctype('const signed short int'))
-      assert_equal(TYPE_SHORT, parse_ctype('signed int short'))
-      assert_equal(TYPE_SHORT, parse_ctype('const signed int short'))
-      assert_equal(TYPE_SHORT, parse_ctype('int signed short'))
-      assert_equal(TYPE_SHORT, parse_ctype('const int signed short'))
-      assert_equal(TYPE_SHORT, parse_ctype('int short signed'))
-      assert_equal(TYPE_SHORT, parse_ctype('const int short signed'))
-      assert_equal(-TYPE_SHORT, parse_ctype('unsigned short'))
-      assert_equal(-TYPE_SHORT, parse_ctype('const unsigned short'))
-      assert_equal(-TYPE_SHORT, parse_ctype('unsigned short int'))
-      assert_equal(-TYPE_SHORT, parse_ctype('const unsigned short int'))
-      assert_equal(-TYPE_SHORT, parse_ctype('unsigned int short'))
-      assert_equal(-TYPE_SHORT, parse_ctype('const unsigned int short'))
-      assert_equal(-TYPE_SHORT, parse_ctype('short int unsigned'))
-      assert_equal(-TYPE_SHORT, parse_ctype('const short int unsigned'))
-      assert_equal(-TYPE_SHORT, parse_ctype('int unsigned short'))
-      assert_equal(-TYPE_SHORT, parse_ctype('const int unsigned short'))
-      assert_equal(-TYPE_SHORT, parse_ctype('int short unsigned'))
-      assert_equal(-TYPE_SHORT, parse_ctype('const int short unsigned'))
-    end
-
-    def test_int_ctype
-      assert_equal(TYPE_INT, parse_ctype('int'))
-      assert_equal(TYPE_INT, parse_ctype('const int'))
-      assert_equal(TYPE_INT, parse_ctype('signed int'))
-      assert_equal(TYPE_INT, parse_ctype('const signed int'))
-      assert_equal(-TYPE_INT, parse_ctype('uint'))
-      assert_equal(-TYPE_INT, parse_ctype('const uint'))
-      assert_equal(-TYPE_INT, parse_ctype('unsigned int'))
-      assert_equal(-TYPE_INT, parse_ctype('const unsigned int'))
-    end
-
-    def test_long_ctype
-      assert_equal(TYPE_LONG, parse_ctype('long'))
-      assert_equal(TYPE_LONG, parse_ctype('const long'))
-      assert_equal(TYPE_LONG, parse_ctype('long int'))
-      assert_equal(TYPE_LONG, parse_ctype('const long int'))
-      assert_equal(TYPE_LONG, parse_ctype('int long'))
-      assert_equal(TYPE_LONG, parse_ctype('const int long'))
-      assert_equal(TYPE_LONG, parse_ctype('signed long'))
-      assert_equal(TYPE_LONG, parse_ctype('const signed long'))
-      assert_equal(TYPE_LONG, parse_ctype('signed long int'))
-      assert_equal(TYPE_LONG, parse_ctype('const signed long int'))
-      assert_equal(TYPE_LONG, parse_ctype('signed int long'))
-      assert_equal(TYPE_LONG, parse_ctype('const signed int long'))
-      assert_equal(TYPE_LONG, parse_ctype('long signed'))
-      assert_equal(TYPE_LONG, parse_ctype('const long signed'))
-      assert_equal(TYPE_LONG, parse_ctype('long int signed'))
-      assert_equal(TYPE_LONG, parse_ctype('const long int signed'))
-      assert_equal(TYPE_LONG, parse_ctype('int long signed'))
-      assert_equal(TYPE_LONG, parse_ctype('const int long signed'))
-      assert_equal(-TYPE_LONG, parse_ctype('unsigned long'))
-      assert_equal(-TYPE_LONG, parse_ctype('const unsigned long'))
-      assert_equal(-TYPE_LONG, parse_ctype('unsigned long int'))
-      assert_equal(-TYPE_LONG, parse_ctype('const unsigned long int'))
-      assert_equal(-TYPE_LONG, parse_ctype('long int unsigned'))
-      assert_equal(-TYPE_LONG, parse_ctype('const long int unsigned'))
-      assert_equal(-TYPE_LONG, parse_ctype('unsigned int long'))
-      assert_equal(-TYPE_LONG, parse_ctype('const unsigned int long'))
-      assert_equal(-TYPE_LONG, parse_ctype('int unsigned long'))
-      assert_equal(-TYPE_LONG, parse_ctype('const int unsigned long'))
-      assert_equal(-TYPE_LONG, parse_ctype('int long unsigned'))
-      assert_equal(-TYPE_LONG, parse_ctype('const int long unsigned'))
-    end
-
-    def test_size_t_ctype
-      assert_equal(TYPE_SIZE_T, parse_ctype("size_t"))
-      assert_equal(TYPE_SIZE_T, parse_ctype("const size_t"))
-    end
-
-    def test_ssize_t_ctype
-      assert_equal(TYPE_SSIZE_T, parse_ctype("ssize_t"))
-      assert_equal(TYPE_SSIZE_T, parse_ctype("const ssize_t"))
-    end
-
-    def test_ptrdiff_t_ctype
-      assert_equal(TYPE_PTRDIFF_T, parse_ctype("ptrdiff_t"))
-      assert_equal(TYPE_PTRDIFF_T, parse_ctype("const ptrdiff_t"))
-    end
-
-    def test_intptr_t_ctype
-      assert_equal(TYPE_INTPTR_T, parse_ctype("intptr_t"))
-      assert_equal(TYPE_INTPTR_T, parse_ctype("const intptr_t"))
-    end
-
-    def test_uintptr_t_ctype
-      assert_equal(TYPE_UINTPTR_T, parse_ctype("uintptr_t"))
-      assert_equal(TYPE_UINTPTR_T, parse_ctype("const uintptr_t"))
-    end
-
-    def test_bool_ctype
-      assert_equal(TYPE_BOOL, parse_ctype('bool'))
-    end
-
-    def test_undefined_ctype
-      assert_raise(DLError) { parse_ctype('DWORD') }
-    end
-
-    def test_undefined_ctype_with_type_alias
-      assert_equal(-TYPE_LONG,
-                   parse_ctype('DWORD', {"DWORD" => "unsigned long"}))
-      assert_equal(-TYPE_LONG,
-                   parse_ctype('const DWORD', {"DWORD" => "unsigned long"}))
-    end
-
-    def expand_struct_types(types)
-      types.collect do |type|
-        case type
-        when Class
-          [expand_struct_types(type.types)]
-        when Array
-          [expand_struct_types([type[0]])[0][0], type[1]]
-        else
-          type
-        end
-      end
-    end
-
-    def test_struct_basic
-      assert_equal([[TYPE_INT, TYPE_CHAR], ['i', 'c']],
-                   parse_struct_signature(['int i', 'char c']))
-      assert_equal([[TYPE_INT, TYPE_CHAR], ['i', 'c']],
-                   parse_struct_signature(['const int i', 'const char c']))
-    end
-
-    def test_struct_array
-      assert_equal([[[TYPE_CHAR, 80], [TYPE_INT, 5]],
-                    ['buffer', 'x']],
-                   parse_struct_signature(['char buffer[80]',
-                                           'int[5] x']))
-      assert_equal([[[TYPE_CHAR, 80], [TYPE_INT, 5]],
-                    ['buffer', 'x']],
-                   parse_struct_signature(['const char buffer[80]',
-                                           'const int[5] x']))
-    end
-
-    def test_struct_nested_struct
-      types, members = parse_struct_signature([
-                                                'int x',
-                                                {inner: ['int i', 'char c']},
-                                              ])
-      assert_equal([[TYPE_INT, [[TYPE_INT, TYPE_CHAR]]],
-                    ['x', ['inner', ['i', 'c']]]],
-                   [expand_struct_types(types),
-                    members])
-    end
-
-    def test_struct_nested_defined_struct
-      inner = Fiddle::Importer.struct(['int i', 'char c'])
-      assert_equal([[TYPE_INT, inner],
-                    ['x', ['inner', ['i', 'c']]]],
-                   parse_struct_signature([
-                                            'int x',
-                                            {inner: inner},
-                                          ]))
-    end
-
-    def test_struct_double_nested_struct
-      types, members = parse_struct_signature([
-                                                'int x',
-                                                {
-                                                  outer: [
-                                                    'int y',
-                                                    {inner: ['int i', 'char c']},
-                                                  ],
-                                                },
-                                              ])
-      assert_equal([[TYPE_INT, [[TYPE_INT, [[TYPE_INT, TYPE_CHAR]]]]],
-                    ['x', ['outer', ['y', ['inner', ['i', 'c']]]]]],
-                   [expand_struct_types(types),
-                    members])
-    end
-
-    def test_struct_nested_struct_array
-      types, members = parse_struct_signature([
-                                                'int x',
-                                                {
-                                                  'inner[2]' => [
-                                                    'int i',
-                                                    'char c',
-                                                  ],
-                                                },
-                                              ])
-      assert_equal([[TYPE_INT, [[TYPE_INT, TYPE_CHAR], 2]],
-                    ['x', ['inner', ['i', 'c']]]],
-                   [expand_struct_types(types),
-                    members])
-    end
-
-    def test_struct_double_nested_struct_inner_array
-      types, members = parse_struct_signature(outer: [
-                                                'int x',
-                                                {
-                                                  'inner[2]' => [
-                                                    'int i',
-                                                    'char c',
-                                                  ],
-                                                },
-                                              ])
-      assert_equal([[[[TYPE_INT, [[TYPE_INT, TYPE_CHAR], 2]]]],
-                    [['outer', ['x', ['inner', ['i', 'c']]]]]],
-                   [expand_struct_types(types),
-                    members])
-    end
-
-    def test_struct_double_nested_struct_outer_array
-      types, members = parse_struct_signature([
-                                                'int x',
-                                                {
-                                                  'outer[2]' => {
-                                                    inner: [
-                                                      'int i',
-                                                      'char c',
-                                                    ],
-                                                  },
-                                                },
-                                              ])
-      assert_equal([[TYPE_INT, [[[[TYPE_INT, TYPE_CHAR]]], 2]],
-                    ['x', ['outer', [['inner', ['i', 'c']]]]]],
-                   [expand_struct_types(types),
-                    members])
-    end
-
-    def test_struct_array_str
-      assert_equal([[[TYPE_CHAR, 80], [TYPE_INT, 5]],
-                    ['buffer', 'x']],
-                   parse_struct_signature('char buffer[80], int[5] x'))
-      assert_equal([[[TYPE_CHAR, 80], [TYPE_INT, 5]],
-                    ['buffer', 'x']],
-                   parse_struct_signature('const char buffer[80], const int[5] x'))
-    end
-
-    def test_struct_function_pointer
-      assert_equal([[TYPE_VOIDP], ['cb']],
-                   parse_struct_signature(['void (*cb)(const char*)']))
-    end
-
-    def test_struct_function_pointer_str
-      assert_equal([[TYPE_VOIDP, TYPE_VOIDP], ['cb', 'data']],
-                   parse_struct_signature('void (*cb)(const char*), const char* data'))
-    end
-
-    def test_struct_string
-      assert_equal [[TYPE_INT,TYPE_VOIDP,TYPE_VOIDP], ['x', 'cb', 'name']], parse_struct_signature('int x; void (*cb)(); const char* name')
-    end
-
-    def test_struct_undefined
-      assert_raise(DLError) { parse_struct_signature(['int i', 'DWORD cb']) }
-    end
-
-    def test_struct_undefined_with_type_alias
-      assert_equal [[TYPE_INT,-TYPE_LONG], ['i', 'cb']], parse_struct_signature(['int i', 'DWORD cb'], {"DWORD" => "unsigned long"})
-    end
-
-    def test_signature_basic
-      func, ret, args = parse_signature('void func()')
-      assert_equal 'func', func
-      assert_equal TYPE_VOID, ret
-      assert_equal [], args
-    end
-
-    def test_signature_semi
-      func, ret, args = parse_signature('void func();')
-      assert_equal 'func', func
-      assert_equal TYPE_VOID, ret
-      assert_equal [], args
-    end
-
-    def test_signature_void_arg
-      func, ret, args = parse_signature('void func(void)')
-      assert_equal 'func', func
-      assert_equal TYPE_VOID, ret
-      assert_equal [], args
-    end
-
-    def test_signature_type_args
-      types = [
-        'char', 'unsigned char',
-        'short', 'unsigned short',
-        'int', 'unsigned int',
-        'long', 'unsigned long',
-        defined?(TYPE_LONG_LONG) && \
-        [
-        'long long', 'unsigned long long',
-        ],
-        'float', 'double',
-        'const char*', 'void*',
-      ].flatten.compact
-      func, ret, args = parse_signature("void func(#{types.join(',')})")
-      assert_equal 'func', func
-      assert_equal TYPE_VOID, ret
-      assert_equal [
-        TYPE_CHAR, -TYPE_CHAR,
-        TYPE_SHORT, -TYPE_SHORT,
-        TYPE_INT, -TYPE_INT,
-        TYPE_LONG, -TYPE_LONG,
-        defined?(TYPE_LONG_LONG) && \
-        [
-        TYPE_LONG_LONG, -TYPE_LONG_LONG,
-        ],
-        TYPE_FLOAT, TYPE_DOUBLE,
-        TYPE_VOIDP, TYPE_VOIDP,
-      ].flatten.compact, args
-    end
-
-    def test_signature_single_variable
-      func, ret, args = parse_signature('void func(int x)')
-      assert_equal 'func', func
-      assert_equal TYPE_VOID, ret
-      assert_equal [TYPE_INT], args
-    end
-
-    def test_signature_multiple_variables
-      func, ret, args = parse_signature('void func(int x, const char* s)')
-      assert_equal 'func', func
-      assert_equal TYPE_VOID, ret
-      assert_equal [TYPE_INT, TYPE_VOIDP], args
-    end
-
-    def test_signature_array_variable
-      func, ret, args = parse_signature('void func(int x[], int y[40])')
-      assert_equal 'func', func
-      assert_equal TYPE_VOID, ret
-      assert_equal [TYPE_VOIDP, TYPE_VOIDP], args
-    end
-
-    def test_signature_function_pointer
-      func, ret, args = parse_signature('int func(int (*sum)(int x, int y), int x, int y)')
-      assert_equal 'func', func
-      assert_equal TYPE_INT, ret
-      assert_equal [TYPE_VOIDP, TYPE_INT, TYPE_INT], args
-    end
-
-    def test_signature_variadic_arguments
-      unless Fiddle.const_defined?("TYPE_VARIADIC")
-        omit "libffi doesn't support variadic arguments"
-      end
-      assert_equal([
-                     "printf",
-                     TYPE_INT,
-                     [TYPE_VOIDP, TYPE_VARIADIC],
-                   ],
-                   parse_signature('int printf(const char *format, ...)'))
-    end
-
-    def test_signature_return_pointer
-      func, ret, args = parse_signature('void* malloc(size_t)')
-      assert_equal 'malloc', func
-      assert_equal TYPE_VOIDP, ret
-      assert_equal [TYPE_SIZE_T], args
-    end
-
-    def test_signature_return_array
-      func, ret, args = parse_signature('int (*func())[32]')
-      assert_equal 'func', func
-      assert_equal TYPE_VOIDP, ret
-      assert_equal [], args
-    end
-
-    def test_signature_return_array_with_args
-      func, ret, args = parse_signature('int (*func(const char* s))[]')
-      assert_equal 'func', func
-      assert_equal TYPE_VOIDP, ret
-      assert_equal [TYPE_VOIDP], args
-    end
-
-    def test_signature_return_function_pointer
-      func, ret, args = parse_signature('int (*func())(int x, int y)')
-      assert_equal 'func', func
-      assert_equal TYPE_VOIDP, ret
-      assert_equal [], args
-    end
-
-    def test_signature_return_function_pointer_with_args
-      func, ret, args = parse_signature('int (*func(int z))(int x, int y)')
-      assert_equal 'func', func
-      assert_equal TYPE_VOIDP, ret
-      assert_equal [TYPE_INT], args
-    end
-  end
-end if defined?(Fiddle)
diff --git a/test/mri/fiddle/test_fiddle.rb b/test/mri/fiddle/test_fiddle.rb
deleted file mode 100644
index 69d0c3d1793..00000000000
--- a/test/mri/fiddle/test_fiddle.rb
+++ /dev/null
@@ -1,91 +0,0 @@
-# frozen_string_literal: true
-begin
-  require_relative 'helper'
-rescue LoadError
-end
-
-class TestFiddle < Fiddle::TestCase
-  def test_nil_true_etc
-    if ffi_backend?
-      omit("Fiddle::Q* aren't supported with FFI backend")
-    end
-
-    assert_equal Fiddle::Qtrue, Fiddle.dlwrap(true)
-    assert_equal Fiddle::Qfalse, Fiddle.dlwrap(false)
-    assert_equal Fiddle::Qnil, Fiddle.dlwrap(nil)
-    assert Fiddle::Qundef
-  end
-
-  def test_windows_constant
-    require 'rbconfig'
-    if RbConfig::CONFIG['host_os'] =~ /mswin|mingw/
-      assert Fiddle::WINDOWS, "Fiddle::WINDOWS should be 'true' on Windows platforms"
-    else
-      refute Fiddle::WINDOWS, "Fiddle::WINDOWS should be 'false' on non-Windows platforms"
-    end
-  end
-
-  def test_dlopen_linker_script_input_linux
-    omit("This is only for Linux") unless RUBY_PLATFORM.match?("linux")
-    if Dir.glob("/usr/lib{,64}/**/libncurses.so").empty?
-      omit("libncurses.so is needed")
-    end
-    if ffi_backend?
-      omit("Fiddle::Handle#file_name doesn't exist in FFI backend")
-    end
-
-    # libncurses.so uses INPUT() on Debian GNU/Linux and Arch Linux:
-    #
-    # Debian GNU/Linux:
-    #
-    # $ cat /usr/lib/x86_64-linux-gnu/libncurses.so
-    # INPUT(libncurses.so.6 -ltinfo)
-    #
-    # Arch Linux:
-    # $ cat /usr/lib/libncurses.so
-    # INPUT(-lncursesw)
-    handle = Fiddle.dlopen("libncurses.so")
-    begin
-      # /usr/lib/x86_64-linux-gnu/libncurses.so.6 ->
-      # libncurses.so.6
-      normalized_file_name = File.basename(handle.file_name)
-      # libncurses.so.6 ->
-      # libncurses.so
-      #
-      # libncursesw.so ->
-      # libncursesw.so
-      normalized_file_name = normalized_file_name.sub(/\.so(\.\d+)+\z/, ".so")
-      # libncurses.so ->
-      # libncurses.so
-      #
-      # libncursesw.so ->
-      # libncurses.so
-      normalized_file_name = normalized_file_name.sub(/ncursesw/, "ncurses")
-      assert_equal("libncurses.so", normalized_file_name)
-    ensure
-      handle.close
-    end
-  end
-
-  def test_dlopen_linker_script_group_linux
-    omit("This is only for Linux") unless RUBY_PLATFORM.match?("linux")
-    if ffi_backend?
-      omit("Fiddle::Handle#file_name doesn't exist in FFI backend")
-    end
-
-    # libc.so uses GROUP() on Debian GNU/Linux
-    # $ cat /usr/lib/x86_64-linux-gnu/libc.so
-    # /* GNU ld script
-    #    Use the shared library, but some functions are only in
-    #    the static library, so try that secondarily.  */
-    # OUTPUT_FORMAT(elf64-x86-64)
-    # GROUP ( /lib/x86_64-linux-gnu/libc.so.6 /usr/lib/x86_64-linux-gnu/libc_nonshared.a  AS_NEEDED ( /lib64/ld-linux-x86-64.so.2 ) )
-    handle = Fiddle.dlopen("libc.so")
-    begin
-      assert_equal("libc.so",
-                   File.basename(handle.file_name, ".*"))
-    ensure
-      handle.close
-    end
-  end
-end if defined?(Fiddle)
diff --git a/test/mri/fiddle/test_func.rb b/test/mri/fiddle/test_func.rb
deleted file mode 100644
index ca503f92ad8..00000000000
--- a/test/mri/fiddle/test_func.rb
+++ /dev/null
@@ -1,180 +0,0 @@
-# frozen_string_literal: true
-begin
-  require_relative 'helper'
-rescue LoadError
-end
-
-module Fiddle
-  class TestFunc < TestCase
-    def test_random
-      f = Function.new(@libc['srand'], [-TYPE_LONG], TYPE_VOID)
-      assert_nil f.call(10)
-    end
-
-    def test_sinf
-      begin
-        f = Function.new(@libm['sinf'], [TYPE_FLOAT], TYPE_FLOAT)
-      rescue Fiddle::DLError
-        omit "libm may not have sinf()"
-      end
-      assert_in_delta 1.0, f.call(90 * Math::PI / 180), 0.0001
-    end
-
-    def test_sin
-      f = Function.new(@libm['sin'], [TYPE_DOUBLE], TYPE_DOUBLE)
-      assert_in_delta 1.0, f.call(90 * Math::PI / 180), 0.0001
-    end
-
-    def test_string
-      if RUBY_ENGINE == "jruby"
-        omit("Function that returns string doesn't work with JRuby")
-      end
-
-      under_gc_stress do
-        f = Function.new(@libc['strcpy'], [TYPE_VOIDP, TYPE_VOIDP], TYPE_VOIDP)
-        buff = +"000"
-        str = f.call(buff, "123")
-        assert_equal("123", buff)
-        assert_equal("123", str.to_s)
-      end
-    end
-
-    def test_isdigit
-      f = Function.new(@libc['isdigit'], [TYPE_INT], TYPE_INT)
-      r1 = f.call(?1.ord)
-      r2 = f.call(?2.ord)
-      rr = f.call(?r.ord)
-      assert_operator r1, :>, 0
-      assert_operator r2, :>, 0
-      assert_equal 0, rr
-    end
-
-    def test_atof
-      f = Function.new(@libc['atof'], [TYPE_VOIDP], TYPE_DOUBLE)
-      r = f.call("12.34")
-      assert_includes(12.00..13.00, r)
-    end
-
-    def test_strtod
-      f = Function.new(@libc['strtod'], [TYPE_VOIDP, TYPE_VOIDP], TYPE_DOUBLE)
-      buff1 = Pointer["12.34"]
-      buff2 = buff1 + 4
-      r = f.call(buff1, - buff2)
-      assert_in_delta(12.34, r, 0.001)
-    end
-
-    def test_qsort1
-      if RUBY_ENGINE == "jruby"
-        omit("The untouched sanity check is broken on JRuby: https://github.com/jruby/jruby/issues/8365")
-      end
-
-      closure_class = Class.new(Closure) do
-        def call(x, y)
-          Pointer.new(x)[0] <=> Pointer.new(y)[0]
-        end
-      end
-
-      closure_class.create(TYPE_INT, [TYPE_VOIDP, TYPE_VOIDP]) do |callback|
-        qsort = Function.new(@libc['qsort'],
-                             [TYPE_VOIDP, TYPE_SIZE_T, TYPE_SIZE_T, TYPE_VOIDP],
-                             TYPE_VOID)
-        untouched = "9341"
-        buff = +"9341"
-        qsort.call(buff, buff.size, 1, callback)
-        assert_equal("1349", buff)
-
-        bug4929 = '[ruby-core:37395]'
-        buff = +"9341"
-        under_gc_stress do
-          qsort.call(buff, buff.size, 1, callback)
-        end
-        assert_equal("1349", buff, bug4929)
-
-        # Ensure the test didn't mutate String literals
-        assert_equal("93" + "41", untouched)
-      end
-    ensure
-      # We can't use ObjectSpace with JRuby.
-      unless RUBY_ENGINE == "jruby"
-        # Ensure freeing all closures.
-        # See https://github.com/ruby/fiddle/issues/102#issuecomment-1241763091 .
-        not_freed_closures = []
-        ObjectSpace.each_object(Fiddle::Closure) do |closure|
-          not_freed_closures << closure unless closure.freed?
-        end
-        assert_equal([], not_freed_closures)
-      end
-    end
-
-    def test_snprintf
-      unless Fiddle.const_defined?("TYPE_VARIADIC")
-        omit "libffi doesn't support variadic arguments"
-      end
-      if Fiddle::WINDOWS
-        snprintf_name = "_snprintf"
-      else
-        snprintf_name = "snprintf"
-      end
-      begin
-        snprintf_pointer = @libc[snprintf_name]
-      rescue Fiddle::DLError
-        omit "Can't find #{snprintf_name}: #{$!.message}"
-      end
-      snprintf = Function.new(snprintf_pointer,
-                              [
-                                :voidp,
-                                :size_t,
-                                :const_string,
-                                :variadic,
-                              ],
-                              :int)
-      Pointer.malloc(1024, Fiddle::RUBY_FREE) do |output|
-        written = snprintf.call(output,
-                                output.size,
-                                "int: %d, string: %.*s, const string: %s\n",
-                                :int, -29,
-                                :int, 4,
-                                :voidp, "Hello",
-                                :const_string, "World")
-        assert_equal("int: -29, string: Hell, const string: World\n",
-                     output[0, written])
-
-        string_like_class = Class.new do
-          def initialize(string)
-            @string = string
-          end
-
-          def to_str
-            @string
-          end
-        end
-        written = snprintf.call(output,
-                                output.size,
-                                "string: %.*s, const string: %s, uint: %u\n",
-                                :int, 2,
-                                :voidp, "Hello",
-                                :const_string, string_like_class.new("World"),
-                                :int, 29)
-        assert_equal("string: He, const string: World, uint: 29\n",
-                     output[0, written])
-      end
-    end
-
-    def test_rb_memory_view_available_p
-      omit "MemoryView is unavailable" unless defined? Fiddle::MemoryView
-      libruby = Fiddle.dlopen(nil)
-      case Fiddle::SIZEOF_VOIDP
-      when Fiddle::SIZEOF_LONG_LONG
-        value_type = -Fiddle::TYPE_LONG_LONG
-      else
-        value_type = -Fiddle::TYPE_LONG
-      end
-      rb_memory_view_available_p =
-        Function.new(libruby["rb_memory_view_available_p"],
-                     [value_type],
-                     :bool,
-                     need_gvl: true)
-      assert_equal(false, rb_memory_view_available_p.call(Fiddle::Qnil))
-    end
-  end
-end if defined?(Fiddle)
diff --git a/test/mri/fiddle/test_function.rb b/test/mri/fiddle/test_function.rb
deleted file mode 100644
index b408a14ccdf..00000000000
--- a/test/mri/fiddle/test_function.rb
+++ /dev/null
@@ -1,310 +0,0 @@
-# frozen_string_literal: true
-begin
-  require_relative 'helper'
-rescue LoadError
-end
-
-module Fiddle
-  class TestFunction < Fiddle::TestCase
-    def setup
-      super
-      Fiddle.last_error = nil
-      if WINDOWS
-        Fiddle.win32_last_error = nil
-        Fiddle.win32_last_socket_error = nil
-      end
-    end
-
-    def teardown
-      # We can't use ObjectSpace with JRuby.
-      return if RUBY_ENGINE == "jruby"
-      # Ensure freeing all closures.
-      # See https://github.com/ruby/fiddle/issues/102#issuecomment-1241763091 .
-      not_freed_closures = []
-      ObjectSpace.each_object(Fiddle::Closure) do |closure|
-        not_freed_closures << closure unless closure.freed?
-      end
-      assert_equal([], not_freed_closures)
-    end
-
-    def test_default_abi
-      func = Function.new(@libm['sin'], [TYPE_DOUBLE], TYPE_DOUBLE)
-      assert_equal Function::DEFAULT, func.abi
-    end
-
-    def test_name
-      func = Function.new(@libm['sin'], [TYPE_DOUBLE], TYPE_DOUBLE, name: 'sin')
-      assert_equal 'sin', func.name
-    end
-
-    def test_name_symbol
-      func = Function.new(@libm['sin'], [TYPE_DOUBLE], TYPE_DOUBLE, name: :sin)
-      assert_equal :sin, func.name
-    end
-
-    def test_need_gvl?
-      if RUBY_ENGINE == "jruby"
-        omit("rb_str_dup() doesn't exist in JRuby")
-      end
-      if RUBY_ENGINE == "truffleruby"
-        omit("rb_str_dup() doesn't work with TruffleRuby")
-      end
-
-      libruby = Fiddle.dlopen(nil)
-      rb_str_dup = Function.new(libruby['rb_str_dup'],
-                                [:voidp],
-                                :voidp,
-                                need_gvl: true)
-      assert(rb_str_dup.need_gvl?)
-      assert_equal('Hello',
-                   Fiddle.dlunwrap(rb_str_dup.call(Fiddle.dlwrap('Hello'))))
-    end
-
-    def test_argument_errors
-      assert_raise(TypeError) do
-        Function.new(@libm['sin'], TYPE_DOUBLE, TYPE_DOUBLE)
-      end
-
-      assert_raise(TypeError) do
-        Function.new(@libm['sin'], ['foo'], TYPE_DOUBLE)
-      end
-
-      assert_raise(TypeError) do
-        Function.new(@libm['sin'], [TYPE_DOUBLE], 'foo')
-      end
-    end
-
-    def test_argument_type_conversion
-      type = Struct.new(:int, :call_count) do
-        def initialize(int)
-          super(int, 0)
-        end
-        def to_int
-          raise "exhausted" if (self.call_count += 1) > 1
-          self.int
-        end
-      end
-      type_arg = type.new(TYPE_DOUBLE)
-      type_result = type.new(TYPE_DOUBLE)
-      assert_nothing_raised(RuntimeError) do
-        Function.new(@libm['sin'], [type_arg], type_result)
-      end
-      assert_equal(1, type_arg.call_count)
-      assert_equal(1, type_result.call_count)
-    end
-
-    def test_call
-      func = Function.new(@libm['sin'], [TYPE_DOUBLE], TYPE_DOUBLE)
-      assert_in_delta 1.0, func.call(90 * Math::PI / 180), 0.0001
-    end
-
-    def test_integer_pointer_conversion
-      func = Function.new(@libc['memcpy'], [TYPE_VOIDP, TYPE_VOIDP, TYPE_SIZE_T], TYPE_VOIDP)
-      str = 'hello'
-      Pointer.malloc(str.bytesize, Fiddle::RUBY_FREE) do |dst|
-        func.call(dst.to_i, str, dst.size)
-        assert_equal(str, dst.to_str)
-      end
-    end
-
-    def test_argument_count
-      closure_class = Class.new(Closure) do
-        def call one
-          10 + one
-        end
-      end
-      closure_class.create(TYPE_INT, [TYPE_INT]) do |closure|
-        func = Function.new(closure, [TYPE_INT], TYPE_INT)
-
-        assert_raise(ArgumentError) do
-          func.call(1,2,3)
-        end
-        assert_raise(ArgumentError) do
-          func.call
-        end
-      end
-    end
-
-    def test_last_error
-      if ffi_backend?
-        omit("Fiddle.last_error doesn't work with FFI backend")
-      end
-
-      func = Function.new(@libc['strcpy'], [TYPE_VOIDP, TYPE_VOIDP], TYPE_VOIDP)
-
-      assert_nil Fiddle.last_error
-      func.call(+"000", "123")
-      refute_nil Fiddle.last_error
-    end
-
-    if WINDOWS
-      def test_win32_last_error
-        kernel32 = Fiddle.dlopen("kernel32")
-        args = [kernel32["SetLastError"], [-TYPE_LONG], TYPE_VOID]
-        args << Function::STDCALL if Function.const_defined?(:STDCALL)
-        set_last_error = Function.new(*args)
-        assert_nil(Fiddle.win32_last_error)
-        n = 1 << 29 | 1
-        set_last_error.call(n)
-        assert_equal(n, Fiddle.win32_last_error)
-      end
-
-      def test_win32_last_socket_error
-        ws2_32 = Fiddle.dlopen("ws2_32")
-        args = [ws2_32["WSASetLastError"], [TYPE_INT], TYPE_VOID]
-        args << Function::STDCALL if Function.const_defined?(:STDCALL)
-        wsa_set_last_error = Function.new(*args)
-        assert_nil(Fiddle.win32_last_socket_error)
-        n = 1 << 29 | 1
-        wsa_set_last_error.call(n)
-        assert_equal(n, Fiddle.win32_last_socket_error)
-      end
-    end
-
-    def test_strcpy
-      if RUBY_ENGINE == "jruby"
-        omit("Function that returns string doesn't work with JRuby")
-      end
-
-      f = Function.new(@libc['strcpy'], [TYPE_VOIDP, TYPE_VOIDP], TYPE_VOIDP)
-      buff = +"000"
-      str = f.call(buff, "123")
-      assert_equal("123", buff)
-      assert_equal("123", str.to_s)
-    end
-
-    def call_proc(string_to_copy)
-      buff = +"000"
-      str = yield(buff, string_to_copy)
-      [buff, str]
-    end
-
-    def test_function_as_proc
-      if RUBY_ENGINE == "jruby"
-        omit("Function that returns string doesn't work with JRuby")
-      end
-
-      f = Function.new(@libc['strcpy'], [TYPE_VOIDP, TYPE_VOIDP], TYPE_VOIDP)
-      buff, str = call_proc("123", &f)
-      assert_equal("123", buff)
-      assert_equal("123", str.to_s)
-    end
-
-    def test_function_as_method
-      if RUBY_ENGINE == "jruby"
-        omit("Function that returns string doesn't work with JRuby")
-      end
-
-      f = Function.new(@libc['strcpy'], [TYPE_VOIDP, TYPE_VOIDP], TYPE_VOIDP)
-      klass = Class.new do
-        define_singleton_method(:strcpy, &f)
-      end
-      buff = +"000"
-      str = klass.strcpy(buff, "123")
-      assert_equal("123", buff)
-      assert_equal("123", str.to_s)
-    end
-
-    def test_nogvl_poll
-      require "envutil" unless defined?(EnvUtil)
-
-      # XXX hack to quiet down CI errors on EINTR from r64353
-      # [ruby-core:88360] [Misc #14937]
-      # Making pipes (and sockets) non-blocking by default would allow
-      # us to get rid of POSIX timers / timer pthread
-      # https://bugs.ruby-lang.org/issues/14968
-      IO.pipe { |r,w| IO.select([r], [w]) }
-      begin
-        poll = @libc['poll']
-      rescue Fiddle::DLError
-        omit 'poll(2) not available'
-      end
-      f = Function.new(poll, [TYPE_VOIDP, TYPE_INT, TYPE_INT], TYPE_INT)
-
-      msec = EnvUtil.apply_timeout_scale(1000)
-      t0 = Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond)
-      th = Thread.new { f.call(nil, 0, msec) }
-      n1 = f.call(nil, 0, msec)
-      n2 = th.value
-      t1 = Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond)
-      assert_in_delta(msec, t1 - t0, EnvUtil.apply_timeout_scale(500), 'slept amount of time')
-      assert_equal(0, n1, perror("poll(2) in main-thread"))
-      assert_equal(0, n2, perror("poll(2) in sub-thread"))
-    end
-
-    def test_no_memory_leak
-      if RUBY_ENGINE == "jruby"
-        omit("rb_obj_frozen_p() doesn't exist in JRuby")
-      end
-      if RUBY_ENGINE == "truffleruby"
-        omit("memory leak detection is fragile with TruffleRuby")
-      end
-
-      if respond_to?(:assert_nothing_leaked_memory)
-        rb_obj_frozen_p_symbol = Fiddle.dlopen(nil)["rb_obj_frozen_p"]
-        rb_obj_frozen_p = Fiddle::Function.new(rb_obj_frozen_p_symbol,
-                                               [Fiddle::TYPE_UINTPTR_T],
-                                               Fiddle::TYPE_UINTPTR_T)
-        a = "a"
-        n_tries = 100_000
-        n_tries.times do
-          begin
-            a + 1
-          rescue TypeError
-          end
-        end
-        n_arguments = 1
-        sizeof_fiddle_generic = Fiddle::SIZEOF_VOIDP # Rough
-        size_per_try =
-          (sizeof_fiddle_generic * n_arguments) +
-          (Fiddle::SIZEOF_VOIDP * (n_arguments + 1))
-        assert_nothing_leaked_memory(size_per_try * n_tries) do
-          n_tries.times do
-            begin
-              rb_obj_frozen_p.call(a)
-            rescue TypeError
-            end
-          end
-        end
-      else
-        prep = 'r = Fiddle::Function.new(Fiddle.dlopen(nil)["rb_obj_frozen_p"], [Fiddle::TYPE_UINTPTR_T], Fiddle::TYPE_UINTPTR_T); a = "a"'
-        code = 'begin r.call(a); rescue TypeError; end'
-        assert_no_memory_leak(%w[-W0 -rfiddle], "#{prep}\n1000.times{#{code}}", "10_000.times {#{code}}", limit: 1.2)
-      end
-    end
-
-    def test_ractor_shareable
-      omit("Need Ractor") unless defined?(Ractor)
-      assert_ractor_shareable(Function.new(@libm["sin"],
-                                           [TYPE_DOUBLE],
-                                           TYPE_DOUBLE))
-    end
-
-    def test_ractor_shareable_name
-      omit("Need Ractor") unless defined?(Ractor)
-      assert_ractor_shareable(Function.new(@libm["sin"],
-                                           [TYPE_DOUBLE],
-                                           TYPE_DOUBLE,
-                                           name: "sin"))
-    end
-
-    def test_ractor_shareable_name_symbol
-      omit("Need Ractor") unless defined?(Ractor)
-      assert_ractor_shareable(Function.new(@libm["sin"],
-                                           [TYPE_DOUBLE],
-                                           TYPE_DOUBLE,
-                                           name: :sin))
-    end
-
-    private
-
-    def perror(m)
-      proc do
-        if e = Fiddle.last_error
-          m = "#{m}: #{SystemCallError.new(e).message}"
-        end
-        m
-      end
-    end
-  end
-end if defined?(Fiddle)
diff --git a/test/mri/fiddle/test_handle.rb b/test/mri/fiddle/test_handle.rb
deleted file mode 100644
index ad8c45a00a6..00000000000
--- a/test/mri/fiddle/test_handle.rb
+++ /dev/null
@@ -1,244 +0,0 @@
-# frozen_string_literal: true
-begin
-  require_relative 'helper'
-rescue LoadError
-end
-
-module Fiddle
-  class TestHandle < TestCase
-    include Fiddle
-
-    def test_library_unavailable
-      assert_raise(DLError) do
-        Fiddle::Handle.new("does-not-exist-library")
-      end
-      assert_raise(DLError) do
-        Fiddle::Handle.new("/does/not/exist/library.#{RbConfig::CONFIG['SOEXT']}")
-      end
-    end
-
-    def test_to_i
-      if ffi_backend?
-        omit("Fiddle::Handle#to_i is unavailable with FFI backend")
-      end
-
-      handle = Fiddle::Handle.new(LIBC_SO)
-      assert_kind_of Integer, handle.to_i
-    end
-
-    def test_to_ptr
-      if ffi_backend?
-        omit("Fiddle::Handle#to_i is unavailable with FFI backend")
-      end
-
-      handle = Fiddle::Handle.new(LIBC_SO)
-      ptr = handle.to_ptr
-      assert_equal ptr.to_i, handle.to_i
-    end
-
-    def test_static_sym_unknown
-      assert_raise(DLError) { Fiddle::Handle.sym('fooo') }
-      assert_raise(DLError) { Fiddle::Handle['fooo'] }
-      refute Fiddle::Handle.sym_defined?('fooo')
-    end
-
-    def test_static_sym
-      if ffi_backend?
-        omit("We can't assume static symbols with FFI backend")
-      end
-
-      begin
-        # Linux / Darwin / FreeBSD
-        refute_nil Fiddle::Handle.sym('dlopen')
-        assert Fiddle::Handle.sym_defined?('dlopen')
-        assert_equal Fiddle::Handle.sym('dlopen'), Fiddle::Handle['dlopen']
-        return
-      rescue
-      end
-
-      begin
-        # NetBSD
-        require '-test-/dln/empty'
-        refute_nil Fiddle::Handle.sym('Init_empty')
-        assert_equal Fiddle::Handle.sym('Init_empty'), Fiddle::Handle['Init_empty']
-        return
-      rescue
-      end
-    end unless /mswin|mingw/ =~ RUBY_PLATFORM
-
-    def test_sym_closed_handle
-      handle = Fiddle::Handle.new(LIBC_SO)
-      handle.close
-      assert_raise(DLError) { handle.sym("calloc") }
-      assert_raise(DLError) { handle["calloc"] }
-    end
-
-    def test_sym_unknown
-      handle = Fiddle::Handle.new(LIBC_SO)
-      assert_raise(DLError) { handle.sym('fooo') }
-      assert_raise(DLError) { handle['fooo'] }
-      refute handle.sym_defined?('fooo')
-    end
-
-    def test_sym_with_bad_args
-      handle = Handle.new(LIBC_SO)
-      assert_raise(TypeError) { handle.sym(nil) }
-      assert_raise(TypeError) { handle[nil] }
-    end
-
-    def test_sym
-      handle = Handle.new(LIBC_SO)
-      refute_nil handle.sym('calloc')
-      refute_nil handle['calloc']
-      assert handle.sym_defined?('calloc')
-    end
-
-    def test_handle_close
-      handle = Handle.new(LIBC_SO)
-      assert_equal 0, handle.close
-    end
-
-    def test_handle_close_twice
-      handle = Handle.new(LIBC_SO)
-      handle.close
-      assert_raise(DLError) do
-        handle.close
-      end
-    end
-
-    def test_dlopen_returns_handle
-      assert_instance_of Handle, dlopen(LIBC_SO)
-    end
-
-    def test_initialize_noargs
-      if RUBY_ENGINE == "jruby"
-        omit("rb_str_new() doesn't exist in JRuby")
-      end
-
-      handle = Handle.new
-      refute_nil handle['rb_str_new']
-    end
-
-    def test_initialize_flags
-      handle = Handle.new(LIBC_SO, RTLD_LAZY | RTLD_GLOBAL)
-      refute_nil handle['calloc']
-    end
-
-    def test_enable_close
-      handle = Handle.new(LIBC_SO)
-      assert !handle.close_enabled?, 'close is enabled'
-
-      handle.enable_close
-      assert handle.close_enabled?, 'close is not enabled'
-    end
-
-    def test_disable_close
-      handle = Handle.new(LIBC_SO)
-
-      handle.enable_close
-      assert handle.close_enabled?, 'close is enabled'
-      handle.disable_close
-      assert !handle.close_enabled?, 'close is enabled'
-    end
-
-    def test_file_name
-      if ffi_backend?
-        omit("Fiddle::Handle#file_name doesn't exist in FFI backend")
-      end
-
-      file_name = Handle.new(LIBC_SO).file_name
-      if file_name
-        assert_kind_of String, file_name
-        expected = [File.basename(LIBC_SO)]
-        begin
-          expected << File.basename(File.realpath(LIBC_SO, File.dirname(file_name)))
-        rescue Errno::ENOENT
-        end
-        basename = File.basename(file_name)
-        unless File::FNM_SYSCASE.zero?
-          basename.downcase!
-          expected.each(&:downcase!)
-        end
-        assert_include expected, basename
-      end
-    end
-
-    def test_NEXT
-      if ffi_backend?
-        omit("Fiddle::Handle::NEXT doesn't exist in FFI backend")
-      end
-
-      begin
-        # Linux / Darwin
-        #
-        # There are two special pseudo-handles, RTLD_DEFAULT and RTLD_NEXT.  The  former  will  find
-        # the  first  occurrence  of the desired symbol using the default library search order.  The
-        # latter will find the next occurrence of a function in the search order after  the  current
-        # library.   This  allows  one  to  provide  a  wrapper  around a function in another shared
-        # library.
-        # --- Ubuntu Linux 8.04 dlsym(3)
-        handle = Handle::NEXT
-        refute_nil handle['malloc']
-        return
-      rescue
-      end
-
-      begin
-        # BSD
-        #
-        # If dlsym() is called with the special handle RTLD_NEXT, then the search
-        # for the symbol is limited to the shared objects which were loaded after
-        # the one issuing the call to dlsym().  Thus, if the function is called
-        # from the main program, all the shared libraries are searched.  If it is
-        # called from a shared library, all subsequent shared libraries are
-        # searched.  RTLD_NEXT is useful for implementing wrappers around library
-        # functions.  For example, a wrapper function getpid() could access the
-        # "real" getpid() with dlsym(RTLD_NEXT, "getpid").  (Actually, the dlfunc()
-        # interface, below, should be used, since getpid() is a function and not a
-        # data object.)
-        # --- FreeBSD 8.0 dlsym(3)
-        require '-test-/dln/empty'
-        handle = Handle::NEXT
-        refute_nil handle['Init_empty']
-        return
-      rescue
-      end
-    end unless /mswin|mingw/ =~ RUBY_PLATFORM
-
-    def test_DEFAULT
-      if Fiddle::WINDOWS
-        omit("Fiddle::Handle::DEFAULT doesn't have malloc() on Windows")
-      end
-
-      handle = Handle::DEFAULT
-      refute_nil handle['malloc']
-    end
-
-    def test_dlerror
-      # FreeBSD (at least 7.2 to 7.2) calls nsdispatch(3) when it calls
-      # getaddrinfo(3). And nsdispatch(3) doesn't call dlerror(3) even if
-      # it calls _nss_cache_cycle_prevention_function with dlsym(3).
-      # So our Fiddle::Handle#sym must call dlerror(3) before call dlsym.
-      # In general uses of dlerror(3) should call it before use it.
-      verbose, $VERBOSE = $VERBOSE, nil
-      require 'socket'
-      Socket.gethostbyname("localhost")
-      Fiddle.dlopen("/lib/libc.so.7").sym('strcpy')
-    ensure
-      $VERBOSE = verbose
-    end if /freebsd/=~ RUBY_PLATFORM
-
-    if /cygwin|mingw|mswin/ =~ RUBY_PLATFORM
-      def test_fallback_to_ansi
-        k = Fiddle::Handle.new("kernel32.dll")
-        ansi = k["GetFileAttributesA"]
-        assert_equal(ansi, k["GetFileAttributes"], "should fallback to ANSI version")
-      end
-    end
-
-    def test_ractor_shareable
-      omit("Need Ractor") unless defined?(Ractor)
-      assert_ractor_shareable(Fiddle::Handle.new(LIBC_SO))
-    end
-  end
-end if defined?(Fiddle)
diff --git a/test/mri/fiddle/test_import.rb b/test/mri/fiddle/test_import.rb
deleted file mode 100644
index a6a3b66655d..00000000000
--- a/test/mri/fiddle/test_import.rb
+++ /dev/null
@@ -1,499 +0,0 @@
-# coding: US-ASCII
-# frozen_string_literal: true
-begin
-  require_relative 'helper'
-  require 'fiddle/import'
-rescue LoadError
-end
-
-module Fiddle
-  module LIBC
-    extend Importer
-    dlload LIBC_SO, LIBM_SO
-
-    typealias 'string', 'char*'
-    typealias 'FILE*', 'void*'
-
-    extern "void *strcpy(char*, char*)"
-    extern "int isdigit(int)"
-    extern "double atof(string)"
-    extern "unsigned long strtoul(char*, char **, int)"
-    extern "int qsort(void*, unsigned long, unsigned long, void*)"
-    extern "int fprintf(FILE*, char*)" rescue nil
-    extern "int gettimeofday(timeval*, timezone*)" rescue nil
-
-    Timeval = struct [
-      "long tv_sec",
-      "long tv_usec",
-    ]
-    Timezone = struct [
-      "int tz_minuteswest",
-      "int tz_dsttime",
-    ]
-    MyStruct = struct [
-      "short num[5]",
-      "char c",
-      "unsigned char buff[7]",
-    ]
-    StructNestedStruct = struct [
-      {
-        "vertices[2]" => {
-          position: ["float x", "float y", "float z"],
-          texcoord: ["float u", "float v"]
-        },
-        object: ["int id", "void *user_data"],
-      },
-      "int id"
-    ]
-    UnionNestedStruct = union [
-      {
-        keyboard: [
-          'unsigned int state',
-          'char key'
-        ],
-        mouse: [
-          'unsigned int button',
-          'unsigned short x',
-          'unsigned short y'
-        ]
-      }
-    ]
-  end
-
-  class TestImport < TestCase
-    def test_ensure_call_dlload
-      err = assert_raise(RuntimeError) do
-        Class.new do
-          extend Importer
-          extern "void *strcpy(char*, char*)"
-        end
-      end
-      assert_match(/call dlload before/, err.message)
-    end
-
-    def test_struct_memory_access()
-      # check memory operations performed directly on struct
-      Fiddle::Importer.struct(['int id']).malloc(Fiddle::RUBY_FREE) do |my_struct|
-        my_struct[0, Fiddle::SIZEOF_INT] = "\x01".b * Fiddle::SIZEOF_INT
-        assert_equal 0x01010101, my_struct.id
-
-        my_struct.id = 0
-        assert_equal "\x00".b * Fiddle::SIZEOF_INT, my_struct[0, Fiddle::SIZEOF_INT]
-      end
-    end
-
-    def test_struct_ptr_array_subscript_multiarg()
-      # check memory operations performed on struct#to_ptr
-      Fiddle::Importer.struct([ 'int x' ]).malloc(Fiddle::RUBY_FREE) do |struct|
-        ptr = struct.to_ptr
-
-        struct.x = 0x02020202
-        assert_equal("\x02".b * Fiddle::SIZEOF_INT, ptr[0, Fiddle::SIZEOF_INT])
-
-        ptr[0, Fiddle::SIZEOF_INT] = "\x01".b * Fiddle::SIZEOF_INT
-        assert_equal 0x01010101, struct.x
-      end
-    end
-
-    def test_malloc()
-      LIBC::Timeval.malloc(Fiddle::RUBY_FREE) do |s1|
-        LIBC::Timeval.malloc(Fiddle::RUBY_FREE) do |s2|
-          refute_equal(s1.to_ptr.to_i, s2.to_ptr.to_i)
-        end
-      end
-    end
-
-    def test_sizeof()
-      assert_equal(SIZEOF_VOIDP, LIBC.sizeof("FILE*"))
-      assert_equal(LIBC::MyStruct.size(), LIBC.sizeof(LIBC::MyStruct))
-      LIBC::MyStruct.malloc(Fiddle::RUBY_FREE) do |my_struct|
-        assert_equal(LIBC::MyStruct.size(), LIBC.sizeof(my_struct))
-      end
-      assert_equal(SIZEOF_LONG_LONG, LIBC.sizeof("long long")) if defined?(SIZEOF_LONG_LONG)
-      assert_equal(LIBC::StructNestedStruct.size(), LIBC.sizeof(LIBC::StructNestedStruct))
-    end
-
-    Fiddle.constants.grep(/\ATYPE_(?!VOID|VARIADIC\z)(.*)/) do
-      type = $&
-      const_type_name = $1
-      size = Fiddle.const_get("SIZEOF_#{const_type_name}")
-      if const_type_name == "CONST_STRING"
-        name = "const_string"
-        type_name = "const char*"
-      else
-        name = $1.sub(/P\z/,"*").gsub(/_(?!T\z)/, " ").downcase
-        type_name = name
-      end
-      type_name = "unsigned #{$1}" if type_name =~ /\Au(long|short|char|int|long long)\z/
-
-      define_method("test_sizeof_#{name}") do
-        assert_equal(size, Fiddle::Importer.sizeof(type_name), type)
-      end
-    end
-
-    # Assert that the unsigned constants are equal to the "negative" signed ones
-    # for backwards compatibility
-    def test_unsigned_equals_negative_signed
-      Fiddle.constants.grep(/\ATYPE_(?!VOID|VARIADIC\z)(U.*)/) do |unsigned|
-        assert_equal(-Fiddle.const_get(unsigned.to_s.sub(/U/, '')),
-                     Fiddle.const_get(unsigned))
-      end
-    end
-
-    def test_type_constants
-      Fiddle::Types.constants.each do |const|
-        assert_equal Fiddle::Types.const_get(const), Fiddle.const_get("TYPE_#{const}")
-      end
-    end
-
-    def test_unsigned_result()
-      d = (2 ** 31) + 1
-
-      r = LIBC.strtoul(d.to_s, nil, 0)
-      assert_equal(d, r)
-    end
-
-    def test_io()
-      if ffi_backend?
-        omit("BUILD_RUBY_PLATFORM doesn't exist in FFI backend")
-      end
-
-      if( RUBY_PLATFORM != BUILD_RUBY_PLATFORM ) || !defined?(LIBC.fprintf)
-        return
-      end
-      io_in,io_out = IO.pipe()
-      LIBC.fprintf(io_out, "hello")
-      io_out.flush()
-      io_out.close()
-      str = io_in.read()
-      io_in.close()
-      assert_equal("hello", str)
-    end
-
-    def test_value()
-      i = LIBC.value('int', 2)
-      assert_equal(2, i.value)
-
-      d = LIBC.value('double', 2.0)
-      assert_equal(2.0, d.value)
-
-      ary = LIBC.value('int[3]', [0,1,2])
-      assert_equal([0,1,2], ary.value)
-    end
-
-    def test_struct_array_assignment()
-      Fiddle::Importer.struct(["unsigned int stages[3]"]).malloc(Fiddle::RUBY_FREE) do |instance|
-        instance.stages[0] = 1024
-        instance.stages[1] = 10
-        instance.stages[2] = 100
-        assert_equal 1024, instance.stages[0]
-        assert_equal 10, instance.stages[1]
-        assert_equal 100, instance.stages[2]
-        assert_equal [1024, 10, 100].pack(Fiddle::PackInfo::PACK_MAP[-Fiddle::TYPE_INT] * 3),
-                    instance.to_ptr[0, 3 * Fiddle::SIZEOF_INT]
-        assert_raise(IndexError) { instance.stages[-1] = 5 }
-        assert_raise(IndexError) { instance.stages[3] = 5 }
-      end
-    end
-
-    def test_nested_struct_reusing_other_structs()
-      position_struct = Fiddle::Importer.struct(['float x', 'float y', 'float z'])
-      texcoord_struct = Fiddle::Importer.struct(['float u', 'float v'])
-      vertex_struct   = Fiddle::Importer.struct(position: position_struct, texcoord: texcoord_struct)
-      mesh_struct     = Fiddle::Importer.struct([
-                                                  {
-                                                    "vertices[2]" => vertex_struct,
-                                                    object: [
-                                                      "int id",
-                                                      "void *user_data",
-                                                    ],
-                                                  },
-                                                  "int id",
-                                                ])
-      assert_equal LIBC::StructNestedStruct.size, mesh_struct.size
-
-
-      keyboard_event_struct = Fiddle::Importer.struct(['unsigned int state', 'char key'])
-      mouse_event_struct    = Fiddle::Importer.struct(['unsigned int button', 'unsigned short x', 'unsigned short y'])
-      event_union           = Fiddle::Importer.union([{ keyboard: keyboard_event_struct, mouse: mouse_event_struct}])
-      assert_equal LIBC::UnionNestedStruct.size, event_union.size
-    end
-
-    def test_nested_struct_alignment_is_not_its_size()
-      inner = Fiddle::Importer.struct(['int x', 'int y', 'int z', 'int w'])
-      outer = Fiddle::Importer.struct(['char a', { 'nested' => inner }, 'char b'])
-      outer.malloc(Fiddle::RUBY_FREE) do |instance|
-        offset = instance.to_ptr.instance_variable_get(:"@offset")
-        assert_equal Fiddle::SIZEOF_INT * 5, offset.last
-        assert_equal Fiddle::SIZEOF_INT * 6, outer.size
-        assert_equal instance.to_ptr.size, outer.size
-      end
-    end
-
-    def test_struct_nested_struct_members()
-      LIBC::StructNestedStruct.malloc(Fiddle::RUBY_FREE) do |s|
-        Fiddle::Pointer.malloc(24, Fiddle::RUBY_FREE) do |user_data|
-          s.vertices[0].position.x = 1
-          s.vertices[0].position.y = 2
-          s.vertices[0].position.z = 3
-          s.vertices[0].texcoord.u = 4
-          s.vertices[0].texcoord.v = 5
-          s.vertices[1].position.x = 6
-          s.vertices[1].position.y = 7
-          s.vertices[1].position.z = 8
-          s.vertices[1].texcoord.u = 9
-          s.vertices[1].texcoord.v = 10
-          s.object.id              = 100
-          s.object.user_data       = user_data
-          s.id                     = 101
-          assert_equal({
-                         "vertices" => [
-                           {
-                             "position" => {
-                               "x" => 1,
-                               "y" => 2,
-                               "z" => 3,
-                             },
-                             "texcoord" => {
-                               "u" => 4,
-                               "v" => 5,
-                             },
-                           },
-                           {
-                             "position" => {
-                               "x" => 6,
-                               "y" => 7,
-                               "z" => 8,
-                             },
-                             "texcoord" => {
-                               "u" => 9,
-                               "v" => 10,
-                             },
-                           },
-                         ],
-                         "object" => {
-                           "id" => 100,
-                           "user_data" => user_data,
-                         },
-                         "id" => 101,
-                       },
-                       s.to_h)
-        end
-      end
-    end
-
-    def test_union_nested_struct_members()
-      LIBC::UnionNestedStruct.malloc(Fiddle::RUBY_FREE) do |s|
-        s.keyboard.state = 100
-        s.keyboard.key   = 101
-        assert_equal(100, s.mouse.button)
-        refute_equal(  0, s.mouse.x)
-      end
-    end
-
-    def test_struct_nested_struct_replace_array_element()
-      LIBC::StructNestedStruct.malloc(Fiddle::RUBY_FREE) do |s|
-        s.vertices[0].position.x = 5
-
-        vertex_struct = Fiddle::Importer.struct [{
-          position: ["float x", "float y", "float z"],
-          texcoord: ["float u", "float v"]
-        }]
-        vertex_struct.malloc(Fiddle::RUBY_FREE) do |vertex|
-          vertex.position.x = 100
-          s.vertices[0] = vertex
-
-          # make sure element was copied by value, but things like memory address
-          # should not be changed
-          assert_equal(100,              s.vertices[0].position.x)
-          refute_equal(vertex.object_id, s.vertices[0].object_id)
-          refute_equal(vertex.to_ptr,    s.vertices[0].to_ptr)
-        end
-      end
-    end
-
-    def test_struct_nested_struct_replace_array_element_nil()
-      LIBC::StructNestedStruct.malloc(Fiddle::RUBY_FREE) do |s|
-        s.vertices[0].position.x = 5
-        s.vertices[0] = nil
-        assert_equal({
-                       "position" => {
-                         "x" => 0.0,
-                         "y" => 0.0,
-                         "z" => 0.0,
-                       },
-                       "texcoord" => {
-                         "u" => 0.0,
-                         "v" => 0.0,
-                       },
-                     },
-                     s.vertices[0].to_h)
-      end
-    end
-
-    def test_struct_nested_struct_replace_array_element_hash()
-      LIBC::StructNestedStruct.malloc(Fiddle::RUBY_FREE) do |s|
-        s.vertices[0] = nil
-        s.vertices[0] = {
-          position: {
-            x: 10,
-            y: 100,
-          },
-        }
-        assert_equal({
-                       "position" => {
-                         "x" => 10.0,
-                         "y" => 100.0,
-                         "z" => 0.0,
-                       },
-                       "texcoord" => {
-                         "u" => 0.0,
-                         "v" => 0.0,
-                       },
-                     },
-                     s.vertices[0].to_h)
-      end
-    end
-
-    def test_struct_nested_struct_replace_entire_array()
-      LIBC::StructNestedStruct.malloc(Fiddle::RUBY_FREE) do |s|
-        vertex_struct = Fiddle::Importer.struct [{
-          position: ["float x", "float y", "float z"],
-          texcoord: ["float u", "float v"]
-        }]
-
-        vertex_struct.malloc(Fiddle::RUBY_FREE) do |same0|
-          vertex_struct.malloc(Fiddle::RUBY_FREE) do |same1|
-            same = [same0, same1]
-            same[0].position.x = 1; same[1].position.x = 6
-            same[0].position.y = 2; same[1].position.y = 7
-            same[0].position.z = 3; same[1].position.z = 8
-            same[0].texcoord.u = 4; same[1].texcoord.u = 9
-            same[0].texcoord.v = 5; same[1].texcoord.v = 10
-            s.vertices = same
-            assert_equal([
-                           {
-                             "position" => {
-                               "x" => 1.0,
-                               "y" => 2.0,
-                               "z" => 3.0,
-                             },
-                             "texcoord" => {
-                               "u" => 4.0,
-                               "v" => 5.0,
-                             },
-                           },
-                           {
-                             "position" => {
-                               "x" => 6.0,
-                               "y" => 7.0,
-                               "z" => 8.0,
-                             },
-                             "texcoord" => {
-                               "u" => 9.0,
-                               "v" => 10.0,
-                             },
-                           }
-                         ],
-                         s.vertices.collect(&:to_h))
-          end
-        end
-      end
-    end
-
-    def test_struct_nested_struct_replace_entire_array_with_different_struct()
-      LIBC::StructNestedStruct.malloc(Fiddle::RUBY_FREE) do |s|
-        different_struct_same_size = Fiddle::Importer.struct [{
-          a: ['float i', 'float j', 'float k'],
-          b: ['float l', 'float m']
-        }]
-
-        different_struct_same_size.malloc(Fiddle::RUBY_FREE) do |different0|
-          different_struct_same_size.malloc(Fiddle::RUBY_FREE) do |different1|
-            different = [different0, different1]
-            different[0].a.i = 11; different[1].a.i = 16
-            different[0].a.j = 12; different[1].a.j = 17
-            different[0].a.k = 13; different[1].a.k = 18
-            different[0].b.l = 14; different[1].b.l = 19
-            different[0].b.m = 15; different[1].b.m = 20
-            s.vertices[0][0, s.vertices[0].class.size] = different[0].to_ptr
-            s.vertices[1][0, s.vertices[1].class.size] = different[1].to_ptr
-            assert_equal([
-                           {
-                             "position" => {
-                               "x" => 11.0,
-                               "y" => 12.0,
-                               "z" => 13.0,
-                             },
-                             "texcoord" => {
-                               "u" => 14.0,
-                               "v" => 15.0,
-                             },
-                           },
-                           {
-                             "position" => {
-                               "x" => 16.0,
-                               "y" => 17.0,
-                               "z" => 18.0,
-                             },
-                             "texcoord" => {
-                               "u" => 19.0,
-                               "v" => 20.0,
-                             },
-                           }
-                         ],
-                         s.vertices.collect(&:to_h))
-          end
-        end
-      end
-    end
-
-    def test_struct()
-      LIBC::MyStruct.malloc(Fiddle::RUBY_FREE) do |s|
-        s.num = [0,1,2,3,4]
-        s.c = ?a.ord
-        s.buff = "012345\377"
-        assert_equal([0,1,2,3,4], s.num)
-        assert_equal(?a.ord, s.c)
-        assert_equal([?0.ord,?1.ord,?2.ord,?3.ord,?4.ord,?5.ord,"\xFF".ord], s.buff)
-      end
-    end
-
-    def test_gettimeofday()
-      if( defined?(LIBC.gettimeofday) )
-        LIBC::Timeval.malloc(Fiddle::RUBY_FREE) do |timeval|
-          LIBC::Timezone.malloc(Fiddle::RUBY_FREE) do |timezone|
-            LIBC.gettimeofday(timeval, timezone)
-          end
-          cur = Time.now()
-          assert(cur.to_i - 2 <= timeval.tv_sec && timeval.tv_sec <= cur.to_i)
-        end
-      end
-    end
-
-    def test_strcpy()
-      if RUBY_ENGINE == "jruby"
-        omit("Function that returns string doesn't work with JRuby")
-      end
-
-      buff = +"000"
-      str = LIBC.strcpy(buff, "123")
-      assert_equal("123", buff)
-      assert_equal("123", str.to_s)
-    end
-
-    def test_isdigit
-      r1 = LIBC.isdigit(?1.ord)
-      r2 = LIBC.isdigit(?2.ord)
-      rr = LIBC.isdigit(?r.ord)
-      assert_operator(r1, :>, 0)
-      assert_operator(r2, :>, 0)
-      assert_equal(0, rr)
-    end
-
-    def test_atof
-      r = LIBC.atof("12.34")
-      assert_includes(12.00..13.00, r)
-    end
-  end
-end if defined?(Fiddle)
diff --git a/test/mri/fiddle/test_memory_view.rb b/test/mri/fiddle/test_memory_view.rb
deleted file mode 100644
index da00d66c91b..00000000000
--- a/test/mri/fiddle/test_memory_view.rb
+++ /dev/null
@@ -1,175 +0,0 @@
-# frozen_string_literal: true
-begin
-  require_relative 'helper'
-rescue LoadError
-  return
-end
-
-begin
-  require '-test-/memory_view'
-rescue LoadError
-  return
-end
-
-module Fiddle
-  class TestMemoryView < TestCase
-    def setup
-      omit "MemoryView is unavailable" unless defined? Fiddle::MemoryView
-    end
-
-    def test_null_ptr
-      assert_raise(ArgumentError) do
-        MemoryView.new(Fiddle::NULL)
-      end
-    end
-
-    def test_memory_view_from_unsupported_obj
-      obj = Object.new
-      assert_raise(ArgumentError) do
-        MemoryView.new(obj)
-      end
-    end
-
-    def test_memory_view_from_pointer
-      str = Marshal.load(Marshal.dump("hello world"))
-      ptr = Pointer[str]
-      mview = MemoryView.new(ptr)
-      begin
-        assert_same(ptr, mview.obj)
-        assert_equal(str.bytesize, mview.byte_size)
-        assert_equal(true, mview.readonly?)
-        assert_equal(nil, mview.format)
-        assert_equal(1, mview.item_size)
-        assert_equal(1, mview.ndim)
-        assert_equal(nil, mview.shape)
-        assert_equal(nil, mview.strides)
-        assert_equal(nil, mview.sub_offsets)
-
-        codes = str.codepoints
-        assert_equal(codes, (0...str.bytesize).map {|i| mview[i] })
-      ensure
-        mview.release
-      end
-    end
-
-    def test_memory_view_multi_dimensional
-      omit "MemoryViewTestUtils is unavailable" unless defined? MemoryViewTestUtils
-
-      buf = [ 1, 2, 3, 4,
-              5, 6, 7, 8,
-              9, 10, 11, 12 ].pack("l!*")
-      shape = [3, 4]
-      md = MemoryViewTestUtils::MultiDimensionalView.new(buf, "l!", shape, nil)
-      mview = Fiddle::MemoryView.new(md)
-      begin
-        assert_equal(buf.bytesize, mview.byte_size)
-        assert_equal("l!", mview.format)
-        assert_equal(Fiddle::SIZEOF_LONG, mview.item_size)
-        assert_equal(2, mview.ndim)
-        assert_equal(shape, mview.shape)
-        assert_equal([Fiddle::SIZEOF_LONG*4, Fiddle::SIZEOF_LONG], mview.strides)
-        assert_equal(nil, mview.sub_offsets)
-        assert_equal(1, mview[0, 0])
-        assert_equal(4, mview[0, 3])
-        assert_equal(6, mview[1, 1])
-        assert_equal(10, mview[2, 1])
-      ensure
-        mview.release
-      end
-    end
-
-    def test_memory_view_multi_dimensional_with_strides
-      omit "MemoryViewTestUtils is unavailable" unless defined? MemoryViewTestUtils
-
-      buf = [ 1, 2,  3,  4,  5,  6,  7,  8,
-              9, 10, 11, 12, 13, 14, 15, 16 ].pack("l!*")
-      shape = [2, 8]
-      strides = [4*Fiddle::SIZEOF_LONG*2, Fiddle::SIZEOF_LONG*2]
-      md = MemoryViewTestUtils::MultiDimensionalView.new(buf, "l!", shape, strides)
-      mview = Fiddle::MemoryView.new(md)
-      begin
-        assert_equal("l!", mview.format)
-        assert_equal(Fiddle::SIZEOF_LONG, mview.item_size)
-        assert_equal(buf.bytesize, mview.byte_size)
-        assert_equal(2, mview.ndim)
-        assert_equal(shape, mview.shape)
-        assert_equal(strides, mview.strides)
-        assert_equal(nil, mview.sub_offsets)
-        assert_equal(1, mview[0, 0])
-        assert_equal(5, mview[0, 2])
-        assert_equal(9, mview[1, 0])
-        assert_equal(15, mview[1, 3])
-      ensure
-        mview.release
-      end
-    end
-
-    def test_memory_view_multi_dimensional_with_multiple_members
-      omit "MemoryViewTestUtils is unavailable" unless defined? MemoryViewTestUtils
-
-      buf = [ 1, 2,  3,  4,  5,  6,  7,  8,
-             -1, -2, -3, -4, -5, -6, -7, -8].pack("s*")
-      shape = [2, 4]
-      strides = [4*Fiddle::SIZEOF_SHORT*2, Fiddle::SIZEOF_SHORT*2]
-      md = MemoryViewTestUtils::MultiDimensionalView.new(buf, "ss", shape, strides)
-      mview = Fiddle::MemoryView.new(md)
-      begin
-        assert_equal("ss", mview.format)
-        assert_equal(Fiddle::SIZEOF_SHORT*2, mview.item_size)
-        assert_equal(buf.bytesize, mview.byte_size)
-        assert_equal(2, mview.ndim)
-        assert_equal(shape, mview.shape)
-        assert_equal(strides, mview.strides)
-        assert_equal(nil, mview.sub_offsets)
-        assert_equal([1, 2], mview[0, 0])
-        assert_equal([5, 6], mview[0, 2])
-        assert_equal([-1, -2], mview[1, 0])
-        assert_equal([-7, -8], mview[1, 3])
-      ensure
-        mview.release
-      end
-    end
-
-    def test_export
-      str = "hello world"
-      mview_str = MemoryView.export(Pointer[str]) do |mview|
-        mview.to_s
-      end
-      assert_equal(str, mview_str)
-    end
-
-    def test_release
-      ptr = Pointer["hello world"]
-      mview = MemoryView.new(ptr)
-      assert_same(ptr, mview.obj)
-      mview.release
-      assert_nil(mview.obj)
-    end
-
-    def test_to_s
-      # U+3042 HIRAGANA LETTER A
-      data = "\u{3042}"
-      ptr = Pointer[data]
-      mview = MemoryView.new(ptr)
-      begin
-        string = mview.to_s
-        assert_equal([data.b, true],
-                     [string, string.frozen?])
-      ensure
-        mview.release
-      end
-    end
-
-    def test_ractor_shareable
-      omit("Need Ractor") unless defined?(Ractor)
-      ptr = Pointer["hello world"]
-      mview = MemoryView.new(ptr)
-      begin
-        assert_ractor_shareable(mview)
-        assert_predicate(ptr, :frozen?)
-      ensure
-        mview.release
-      end
-    end
-  end
-end
diff --git a/test/mri/fiddle/test_pack.rb b/test/mri/fiddle/test_pack.rb
deleted file mode 100644
index ade1dd5040c..00000000000
--- a/test/mri/fiddle/test_pack.rb
+++ /dev/null
@@ -1,37 +0,0 @@
-begin
-  require_relative 'helper'
-  require 'fiddle/pack'
-rescue LoadError
-  return
-end
-
-module Fiddle
-  class TestPack < TestCase
-    def test_pack_map
-      if defined?(TYPE_LONG_LONG)
-        assert_equal [0xffff_ffff_ffff_ffff], [0xffff_ffff_ffff_ffff].pack(PackInfo::PACK_MAP[-TYPE_LONG_LONG]).unpack(PackInfo::PACK_MAP[-TYPE_LONG_LONG])
-      end
-
-      case Fiddle::SIZEOF_VOIDP
-      when 8
-        assert_equal [0xffff_ffff_ffff_ffff], [0xffff_ffff_ffff_ffff].pack(PackInfo::PACK_MAP[TYPE_VOIDP]).unpack(PackInfo::PACK_MAP[TYPE_VOIDP])
-      when 4
-        assert_equal [0xffff_ffff], [0xffff_ffff].pack(PackInfo::PACK_MAP[TYPE_VOIDP]).unpack(PackInfo::PACK_MAP[TYPE_VOIDP])
-      end
-
-      case Fiddle::SIZEOF_LONG
-      when 8
-        assert_equal [0xffff_ffff_ffff_ffff], [0xffff_ffff_ffff_ffff].pack(PackInfo::PACK_MAP[-TYPE_LONG]).unpack(PackInfo::PACK_MAP[-TYPE_LONG])
-      when 4
-        assert_equal [0xffff_ffff], [0xffff_ffff].pack(PackInfo::PACK_MAP[-TYPE_LONG]).unpack(PackInfo::PACK_MAP[-TYPE_LONG])
-      end
-
-      if Fiddle::SIZEOF_INT == 4
-        assert_equal [0xffff_ffff], [0xffff_ffff].pack(PackInfo::PACK_MAP[-TYPE_INT]).unpack(PackInfo::PACK_MAP[-TYPE_INT])
-      end
-
-      assert_equal [0xffff], [0xffff].pack(PackInfo::PACK_MAP[-TYPE_SHORT]).unpack(PackInfo::PACK_MAP[-TYPE_SHORT])
-      assert_equal [0xff], [0xff].pack(PackInfo::PACK_MAP[-TYPE_CHAR]).unpack(PackInfo::PACK_MAP[-TYPE_CHAR])
-    end
-  end
-end
diff --git a/test/mri/fiddle/test_pinned.rb b/test/mri/fiddle/test_pinned.rb
deleted file mode 100644
index ad132579b00..00000000000
--- a/test/mri/fiddle/test_pinned.rb
+++ /dev/null
@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-begin
-  require_relative 'helper'
-rescue LoadError
-  return
-end
-
-module Fiddle
-  class TestPinned < Fiddle::TestCase
-    def test_pin_object
-      x = Object.new
-      pinner = Pinned.new x
-      assert_same x, pinner.ref
-    end
-
-    def test_clear
-      pinner = Pinned.new Object.new
-      refute pinner.cleared?
-      pinner.clear
-      assert pinner.cleared?
-      ex = assert_raise(Fiddle::ClearedReferenceError) do
-        pinner.ref
-      end
-      assert_match "called on", ex.message
-    end
-
-    def test_ractor_shareable
-      omit("Need Ractor") unless defined?(Ractor)
-      obj = Object.new
-      assert_ractor_shareable(Pinned.new(obj))
-      assert_predicate(obj, :frozen?)
-    end
-  end
-end
diff --git a/test/mri/fiddle/test_pointer.rb b/test/mri/fiddle/test_pointer.rb
deleted file mode 100644
index 9d490f9f265..00000000000
--- a/test/mri/fiddle/test_pointer.rb
+++ /dev/null
@@ -1,319 +0,0 @@
-# frozen_string_literal: true
-begin
-  require_relative 'helper'
-rescue LoadError
-end
-
-module Fiddle
-  class TestPointer < TestCase
-    def dlwrap arg
-      Fiddle.dlwrap arg
-    end
-
-    def test_can_read_write_memory
-      # Allocate some memory
-      Fiddle::Pointer.malloc(Fiddle::SIZEOF_VOIDP, Fiddle::RUBY_FREE) do |pointer|
-        address = pointer.to_i
-        bytes_to_write = Fiddle::SIZEOF_VOIDP.times.to_a.pack("C*")
-
-        # Write to the memory
-        Fiddle::Pointer.write(address, bytes_to_write)
-
-        # Read the bytes out again
-        bytes = Fiddle::Pointer.read(address, Fiddle::SIZEOF_VOIDP)
-        assert_equal bytes_to_write, bytes
-      end
-    end
-
-    def test_cptr_to_int
-      null = Fiddle::NULL
-      assert_equal(null.to_i, null.to_int)
-    end
-
-    def test_malloc_free_func_int
-      free = Fiddle::Function.new(Fiddle::RUBY_FREE, [TYPE_VOIDP], TYPE_VOID)
-      assert_equal free.to_i, Fiddle::RUBY_FREE.to_i
-
-      ptr  = Pointer.malloc(10, free.to_i)
-      assert_equal 10, ptr.size
-      assert_equal free.to_i, ptr.free.to_i
-    end
-
-    def test_malloc_free_func
-      free = Fiddle::Function.new(Fiddle::RUBY_FREE, [TYPE_VOIDP], TYPE_VOID)
-
-      ptr  = Pointer.malloc(10, free)
-      assert_equal 10, ptr.size
-      assert_equal free.to_i, ptr.free.to_i
-    end
-
-    def test_malloc_block
-      escaped_ptr = nil
-      returned = Pointer.malloc(10, Fiddle::RUBY_FREE) do |ptr|
-        assert_equal 10, ptr.size
-        assert_equal Fiddle::RUBY_FREE, ptr.free.to_i
-        escaped_ptr = ptr
-        :returned
-      end
-      assert_equal :returned, returned
-      assert escaped_ptr.freed?
-    end
-
-    def test_malloc_block_no_free
-      assert_raise ArgumentError do
-        Pointer.malloc(10) { |ptr| }
-      end
-    end
-
-    def test_malloc_subclass
-      subclass = Class.new(Pointer)
-      subclass.malloc(10, Fiddle::RUBY_FREE) do |ptr|
-        assert ptr.is_a?(subclass)
-      end
-    end
-
-    def test_to_str
-      str = Marshal.load(Marshal.dump("hello world"))
-      ptr = Pointer[str]
-
-      assert_equal 3, ptr.to_str(3).length
-      assert_equal str, ptr.to_str
-
-      ptr[5] = 0
-      assert_equal "hello\0world", ptr.to_str
-    end
-
-    def test_to_s
-      str = Marshal.load(Marshal.dump("hello world"))
-      ptr = Pointer[str]
-
-      assert_equal 3, ptr.to_s(3).length
-      assert_equal str, ptr.to_s
-
-      ptr[5] = 0
-      assert_equal 'hello', ptr.to_s
-    end
-
-    def test_minus
-      str = "hello world"
-      ptr = Pointer[str]
-      assert_equal ptr.to_s, (ptr + 3 - 3).to_s
-    end
-
-    # TODO: what if the pointer size is 0?  raise an exception? do we care?
-    def test_plus
-      str = "hello world"
-      ptr = Pointer[str]
-      new_str = ptr + 3
-      assert_equal 'lo world', new_str.to_s
-    end
-
-    def test_inspect
-      if ffi_backend?
-        omit("Fiddle::Pointer#inspect is incompatible with FFI backend")
-      end
-
-      ptr = Pointer.new(0)
-      inspect = ptr.inspect
-      assert_match(/size=#{ptr.size}/, inspect)
-      assert_match(/free=#{sprintf("%#x", ptr.free.to_i)}/, inspect)
-      assert_match(/ptr=#{sprintf("%#x", ptr.to_i)}/, inspect)
-    end
-
-    def test_to_ptr_string
-      str = "hello world"
-      ptr = Pointer[str]
-      assert_equal str.length, ptr.size
-      assert_equal 'hello', ptr[0,5]
-    end
-
-    def test_to_ptr_io
-      if ffi_backend?
-        omit("Fiddle::Pointer.to_ptr(IO) isn't supported with FFI backend")
-      end
-
-      Pointer.malloc(10, Fiddle::RUBY_FREE) do |buf|
-        File.open(__FILE__, 'r') do |f|
-          ptr = Pointer.to_ptr f
-          fread = Function.new(@libc['fread'],
-                              [TYPE_VOIDP, TYPE_INT, TYPE_INT, TYPE_VOIDP],
-                              TYPE_INT)
-          fread.call(buf.to_i, Fiddle::SIZEOF_CHAR, buf.size - 1, ptr.to_i)
-        end
-
-        File.open(__FILE__, 'r') do |f|
-          assert_equal f.read(9), buf.to_s
-        end
-      end
-    end
-
-    def test_to_ptr_with_ptr
-      ptr = Pointer.new 0
-      ptr2 = Pointer.to_ptr Struct.new(:to_ptr).new(ptr)
-      assert_equal ptr, ptr2
-
-      assert_raise(Fiddle::DLError) do
-        Pointer.to_ptr Struct.new(:to_ptr).new(nil)
-      end
-    end
-
-    def test_to_ptr_with_int
-      ptr = Pointer.new 0
-      assert_equal ptr, Pointer[0]
-    end
-
-    MimicInteger = Struct.new(:to_int)
-    def test_to_ptr_with_to_int
-      ptr = Pointer.new 0
-      assert_equal ptr, Pointer[MimicInteger.new(0)]
-    end
-
-    def test_equals
-      ptr   = Pointer.new 0
-      ptr2  = Pointer.new 0
-      assert_equal ptr2, ptr
-    end
-
-    def test_not_equals
-      ptr = Pointer.new 0
-      refute_equal 10, ptr, '10 should not equal the pointer'
-    end
-
-    def test_cmp
-      ptr = Pointer.new 0
-      assert_nil(ptr <=> 10, '10 should not be comparable')
-    end
-
-    def test_ref_ptr
-      if ffi_backend?
-        omit("Fiddle.dlwrap([]) isn't supported with FFI backend")
-      end
-
-      ary = [0,1,2,4,5]
-      addr = Pointer.new(dlwrap(ary))
-      assert_equal addr.to_i, addr.ref.ptr.to_i
-
-      assert_equal addr.to_i, (+ (- addr)).to_i
-    end
-
-    def test_to_value
-      if ffi_backend?
-        omit("Fiddle.dlwrap([]) isn't supported with FFI backend")
-      end
-
-      ary = [0,1,2,4,5]
-      addr = Pointer.new(dlwrap(ary))
-      assert_equal ary, addr.to_value
-    end
-
-    def test_free
-      ptr = Pointer.malloc(4)
-      begin
-        assert_nil ptr.free
-      ensure
-        Fiddle.free ptr
-      end
-    end
-
-    def test_free=
-      free = Function.new(Fiddle::RUBY_FREE, [TYPE_VOIDP], TYPE_VOID)
-      ptr = Pointer.malloc(4)
-      ptr.free = free
-
-      assert_equal free.ptr, ptr.free.ptr
-    end
-
-    def test_free_with_func
-      ptr = Pointer.malloc(4, Fiddle::RUBY_FREE)
-      refute ptr.freed?
-      ptr.call_free
-      assert ptr.freed?
-      ptr.call_free                 # you can safely run it again
-      assert ptr.freed?
-      GC.start                      # you can safely run the GC routine
-      assert ptr.freed?
-    end
-
-    def test_free_with_no_func
-      ptr = Pointer.malloc(4)
-      refute ptr.freed?
-      ptr.call_free
-      refute ptr.freed?
-      ptr.call_free                 # you can safely run it again
-      refute ptr.freed?
-    end
-
-    def test_freed?
-      ptr = Pointer.malloc(4, Fiddle::RUBY_FREE)
-      refute ptr.freed?
-      ptr.call_free
-      assert ptr.freed?
-    end
-
-    def test_null?
-      ptr = Pointer.new(0)
-      assert ptr.null?
-    end
-
-    def test_size
-      Pointer.malloc(4, Fiddle::RUBY_FREE) do |ptr|
-        assert_equal 4, ptr.size
-      end
-    end
-
-    def test_size=
-      Pointer.malloc(4, Fiddle::RUBY_FREE) do |ptr|
-        ptr.size = 10
-        assert_equal 10, ptr.size
-      end
-    end
-
-    def test_aref_aset
-      check = Proc.new{|str,ptr|
-        assert_equal(str.size(), ptr.size())
-        assert_equal(str, ptr.to_s())
-        assert_equal(str[0,2], ptr.to_s(2))
-        assert_equal(str[0,2], ptr[0,2])
-        assert_equal(str[1,2], ptr[1,2])
-        assert_equal(str[1,0], ptr[1,0])
-        assert_equal(str[0].ord, ptr[0])
-        assert_equal(str[1].ord, ptr[1])
-      }
-      str = Marshal.load(Marshal.dump('abc'))
-      ptr = Pointer[str]
-      check.call(str, ptr)
-
-      str[0] = "c"
-      assert_equal 'c'.ord, ptr[0] = "c".ord
-      check.call(str, ptr)
-
-      str[0,2] = "aa"
-      assert_equal 'aa', ptr[0,2] = "aa"
-      check.call(str, ptr)
-
-      ptr2 = Pointer['cdeeee']
-      str[0,2] = "cd"
-      assert_equal ptr2, ptr[0,2] = ptr2
-      check.call(str, ptr)
-
-      ptr3 = Pointer['vvvv']
-      str[0,2] = "vv"
-      assert_equal ptr3.to_i, ptr[0,2] = ptr3.to_i
-      check.call(str, ptr)
-    end
-
-    def test_null_pointer
-      nullpo = Pointer.new(0)
-      assert_raise(DLError) {nullpo[0]}
-      assert_raise(DLError) {nullpo[0] = 1}
-    end
-
-    def test_ractor_shareable
-      omit("Need Ractor") unless defined?(Ractor)
-      assert_ractor_shareable(Fiddle::NULL)
-      ary = [0, 1, 2, 4, 5]
-      addr = Pointer.new(dlwrap(ary))
-      assert_ractor_shareable(addr)
-    end
-  end
-end if defined?(Fiddle)
diff --git a/test/mri/irb/command/test_cd.rb b/test/mri/irb/command/test_cd.rb
deleted file mode 100644
index 10f77f66911..00000000000
--- a/test/mri/irb/command/test_cd.rb
+++ /dev/null
@@ -1,84 +0,0 @@
-require "tempfile"
-require_relative "../helper"
-
-module TestIRB
-  class CDTest < IntegrationTestCase
-    def setup
-      super
-
-      write_ruby <<~'RUBY'
-        class Foo
-          class Bar
-            def bar
-              "this is bar"
-            end
-          end
-
-          def foo
-            "this is foo"
-          end
-        end
-
-        class BO < BasicObject
-          def baz
-            "this is baz"
-          end
-        end
-
-        binding.irb
-      RUBY
-    end
-
-    def test_cd
-      out = run_ruby_file do
-        type "cd Foo"
-        type "ls"
-        type "cd Bar"
-        type "ls"
-        type "cd .."
-        type "exit"
-      end
-
-      assert_match(/irb$Foo$:002>/, out)
-      assert_match(/Foo#methods: foo/, out)
-      assert_match(/irb$Foo::Bar$:004>/, out)
-      assert_match(/Bar#methods: bar/, out)
-      assert_match(/irb$Foo$:006>/, out)
-    end
-
-    def test_cd_basic_object_or_frozen
-      out = run_ruby_file do
-        type "cd BO.new"
-        type "cd 1"
-        type "cd Object.new.freeze"
-        type "exit"
-      end
-
-      assert_match(/irb$#<BO:.+$:002>/, out)
-      assert_match(/irb$1$:003>/, out)
-      assert_match(/irb$#<Object:.+$:004>/, out)
-    end
-
-    def test_cd_moves_top_level_with_no_args
-      out = run_ruby_file do
-        type "cd Foo"
-        type "cd Bar"
-        type "cd"
-        type "exit"
-      end
-
-      assert_match(/irb$Foo::Bar$:003>/, out)
-      assert_match(/irb$main$:004>/, out)
-    end
-
-    def test_cd_with_error
-      out = run_ruby_file do
-        type "cd Baz"
-        type "exit"
-      end
-
-      assert_match(/Error: uninitialized constant Baz/, out)
-      assert_match(/irb$main$:002>/, out) # the context should not change
-    end
-  end
-end
diff --git a/test/mri/irb/command/test_custom_command.rb b/test/mri/irb/command/test_custom_command.rb
deleted file mode 100644
index 13f412c2107..00000000000
--- a/test/mri/irb/command/test_custom_command.rb
+++ /dev/null
@@ -1,194 +0,0 @@
-# frozen_string_literal: true
-require "irb"
-
-require_relative "../helper"
-
-module TestIRB
-  class CustomCommandIntegrationTest < TestIRB::IntegrationTestCase
-    def test_command_registration_can_happen_after_irb_require
-      write_ruby <<~RUBY
-        require "irb"
-        require "irb/command"
-
-        class PrintCommand < IRB::Command::Base
-          category 'CommandTest'
-          description 'print_command'
-          def execute(*)
-            puts "Hello from PrintCommand"
-          end
-        end
-
-        IRB::Command.register(:print!, PrintCommand)
-
-        binding.irb
-      RUBY
-
-      output = run_ruby_file do
-        type "print!"
-        type "exit"
-      end
-
-      assert_include(output, "Hello from PrintCommand")
-    end
-
-    def test_command_registration_accepts_string_too
-      write_ruby <<~RUBY
-        require "irb/command"
-
-        class PrintCommand < IRB::Command::Base
-          category 'CommandTest'
-          description 'print_command'
-          def execute(*)
-            puts "Hello from PrintCommand"
-          end
-        end
-
-        IRB::Command.register("print!", PrintCommand)
-
-        binding.irb
-      RUBY
-
-      output = run_ruby_file do
-        type "print!"
-        type "exit"
-      end
-
-      assert_include(output, "Hello from PrintCommand")
-    end
-
-    def test_arguments_propagation
-      write_ruby <<~RUBY
-        require "irb/command"
-
-        class PrintArgCommand < IRB::Command::Base
-          category 'CommandTest'
-          description 'print_command_arg'
-          def execute(arg)
-            $nth_execution ||= 0
-            puts "\#{$nth_execution} arg=\#{arg.inspect}"
-            $nth_execution += 1
-          end
-        end
-
-        IRB::Command.register(:print_arg, PrintArgCommand)
-
-        binding.irb
-      RUBY
-
-      output = run_ruby_file do
-        type "print_arg"
-        type "print_arg  \n"
-        type "print_arg a r  g"
-        type "print_arg  a r  g  \n"
-        type "exit"
-      end
-
-      assert_include(output, "0 arg=\"\"")
-      assert_include(output, "1 arg=\"\"")
-      assert_include(output, "2 arg=\"a r  g\"")
-      assert_include(output, "3 arg=\"a r  g\"")
-    end
-
-    def test_def_extend_command_still_works
-      write_ruby <<~RUBY
-        require "irb"
-
-        class FooBarCommand < IRB::Command::Base
-          category 'FooBarCategory'
-          description 'foobar_description'
-          def execute(*)
-            $nth_execution ||= 1
-            puts "\#{$nth_execution} FooBar executed"
-            $nth_execution += 1
-          end
-        end
-
-        IRB::ExtendCommandBundle.def_extend_command(:foobar, FooBarCommand, nil, [:fbalias, IRB::Command::OVERRIDE_ALL])
-
-        binding.irb
-      RUBY
-
-      output = run_ruby_file do
-        type "foobar"
-        type "fbalias"
-        type "help foobar"
-        type "exit"
-      end
-
-      assert_include(output, "1 FooBar executed")
-      assert_include(output, "2 FooBar executed")
-      assert_include(output, "foobar_description")
-    end
-
-    def test_no_meta_command_also_works
-      write_ruby <<~RUBY
-        require "irb/command"
-
-        class NoMetaCommand < IRB::Command::Base
-          def execute(*)
-            puts "This command does not override meta attributes"
-          end
-        end
-
-        IRB::Command.register(:no_meta, NoMetaCommand)
-
-        binding.irb
-      RUBY
-
-      output = run_ruby_file do
-        type "no_meta"
-        type "help no_meta"
-        type "exit"
-      end
-
-      assert_include(output, "This command does not override meta attributes")
-      assert_include(output, "No description provided.")
-      assert_not_include(output, "Maybe IRB bug")
-    end
-
-    def test_command_name_local_variable
-      write_ruby <<~RUBY
-        require "irb/command"
-
-        class FooBarCommand < IRB::Command::Base
-          category 'CommandTest'
-          description 'test'
-          def execute(arg)
-            puts "arg=\#{arg.inspect}"
-          end
-        end
-
-        IRB::Command.register(:foo_bar, FooBarCommand)
-
-        binding.irb
-      RUBY
-
-      output = run_ruby_file do
-        type "binding.irb"
-        type "foo_bar == 1 || 1"
-        type "foo_bar =~ /2/ || 2"
-        type "exit"
-        type "binding.irb"
-        type "foo_bar = '3'; foo_bar"
-        type "foo_bar == 4 || '4'"
-        type "foo_bar =~ /5/ || '5'"
-        type "exit"
-        type "binding.irb"
-        type "foo_bar ||= '6'; foo_bar"
-        type "foo_bar == 7 || '7'"
-        type "foo_bar =~ /8/ || '8'"
-        type "exit"
-        type "exit"
-      end
-
-      assert_include(output, 'arg="== 1 || 1"')
-      assert_include(output, 'arg="=~ /2/ || 2"')
-      assert_include(output, '=> "3"')
-      assert_include(output, '=> "4"')
-      assert_include(output, '=> "5"')
-      assert_include(output, '=> "6"')
-      assert_include(output, '=> "7"')
-      assert_include(output, '=> "8"')
-    end
-  end
-end
diff --git a/test/mri/irb/command/test_disable_irb.rb b/test/mri/irb/command/test_disable_irb.rb
deleted file mode 100644
index 14a20043d54..00000000000
--- a/test/mri/irb/command/test_disable_irb.rb
+++ /dev/null
@@ -1,28 +0,0 @@
-# frozen_string_literal: false
-require 'irb'
-
-require_relative "../helper"
-
-module TestIRB
-  class DisableIRBTest < IntegrationTestCase
-    def test_disable_irb_disable_further_irb_breakpoints
-      write_ruby <<~'ruby'
-        puts "First line"
-        puts "Second line"
-        binding.irb
-        puts "Third line"
-        binding.irb
-        puts "Fourth line"
-      ruby
-
-      output = run_ruby_file do
-        type "disable_irb"
-      end
-
-      assert_match(/First line\r\n/, output)
-      assert_match(/Second line\r\n/, output)
-      assert_match(/Third line\r\n/, output)
-      assert_match(/Fourth line\r\n/, output)
-    end
-  end
-end
diff --git a/test/mri/irb/command/test_force_exit.rb b/test/mri/irb/command/test_force_exit.rb
deleted file mode 100644
index 191a7868721..00000000000
--- a/test/mri/irb/command/test_force_exit.rb
+++ /dev/null
@@ -1,51 +0,0 @@
-# frozen_string_literal: false
-require 'irb'
-
-require_relative "../helper"
-
-module TestIRB
-  class ForceExitTest < IntegrationTestCase
-    def test_forced_exit_finishes_process_immediately
-      write_ruby <<~'ruby'
-        puts "First line"
-        puts "Second line"
-        binding.irb
-        puts "Third line"
-        binding.irb
-        puts "Fourth line"
-      ruby
-
-      output = run_ruby_file do
-        type "123"
-        type "456"
-        type "exit!"
-      end
-
-      assert_match(/First line\r\n/, output)
-      assert_match(/Second line\r\n/, output)
-      assert_match(/irb$main$:001> 123/, output)
-      assert_match(/irb$main$:002> 456/, output)
-      refute_match(/Third line\r\n/, output)
-      refute_match(/Fourth line\r\n/, output)
-    end
-
-    def test_forced_exit_in_nested_sessions
-      write_ruby <<~'ruby'
-        def foo
-          binding.irb
-        end
-
-        binding.irb
-        binding.irb
-      ruby
-
-      output = run_ruby_file do
-        type "123"
-        type "foo"
-        type "exit!"
-      end
-
-      assert_match(/irb$main$:001> 123/, output)
-    end
-  end
-end
diff --git a/test/mri/irb/command/test_help.rb b/test/mri/irb/command/test_help.rb
deleted file mode 100644
index b34832b022e..00000000000
--- a/test/mri/irb/command/test_help.rb
+++ /dev/null
@@ -1,75 +0,0 @@
-require "tempfile"
-require_relative "../helper"
-
-module TestIRB
-  class HelpTest < IntegrationTestCase
-    def setup
-      super
-
-      write_rc <<~'RUBY'
-        IRB.conf[:USE_PAGER] = false
-      RUBY
-
-      write_ruby <<~'RUBY'
-        binding.irb
-      RUBY
-    end
-
-    def test_help
-      out = run_ruby_file do
-        type "help"
-        type "exit"
-      end
-
-      assert_match(/List all available commands/, out)
-      assert_match(/Start the debugger of debug\.gem/, out)
-    end
-
-    def test_command_help
-      out = run_ruby_file do
-        type "help ls"
-        type "exit"
-      end
-
-      assert_match(/Usage: ls \[obj\]/, out)
-    end
-
-    def test_command_help_not_found
-      out = run_ruby_file do
-        type "help foo"
-        type "exit"
-      end
-
-      assert_match(/Can't find command `foo`\. Please check the command name and try again\./, out)
-    end
-
-    def test_show_cmds
-      out = run_ruby_file do
-        type "help"
-        type "exit"
-      end
-
-      assert_match(/List all available commands/, out)
-      assert_match(/Start the debugger of debug\.gem/, out)
-    end
-
-    def test_help_lists_user_aliases
-      out = run_ruby_file do
-        type "help"
-        type "exit"
-      end
-
-      assert_match(/\$\s+Alias for `show_source`/, out)
-      assert_match(/@\s+Alias for `whereami`/, out)
-    end
-
-    def test_help_lists_helper_methods
-      out = run_ruby_file do
-        type "help"
-        type "exit"
-      end
-
-      assert_match(/Helper methods\s+conf\s+Returns the current IRB context/, out)
-    end
-  end
-end
diff --git a/test/mri/irb/command/test_multi_irb_commands.rb b/test/mri/irb/command/test_multi_irb_commands.rb
deleted file mode 100644
index e313c0c5d23..00000000000
--- a/test/mri/irb/command/test_multi_irb_commands.rb
+++ /dev/null
@@ -1,50 +0,0 @@
-require "tempfile"
-require_relative "../helper"
-
-module TestIRB
-  class MultiIRBTest < IntegrationTestCase
-    def setup
-      super
-
-      write_ruby <<~'RUBY'
-        binding.irb
-      RUBY
-    end
-
-    def test_jobs_command_with_print_deprecated_warning
-      out = run_ruby_file do
-        type "jobs"
-        type "exit"
-      end
-
-      assert_match(/Multi-irb commands are deprecated and will be removed in IRB 2\.0\.0\. Please use workspace commands instead\./, out)
-      assert_match(%r|If you have any use case for multi-irb, please leave a comment at https://github.com/ruby/irb/issues/653|, out)
-      assert_match(/#0->irb on main $#<Thread:0x.+ run>: running$/, out)
-    end
-
-    def test_irb_jobs_and_kill_commands
-      out = run_ruby_file do
-        type "irb"
-        type "jobs"
-        type "kill 1"
-        type "exit"
-      end
-
-      assert_match(/#0->irb on main $#<Thread:0x.+ sleep_forever>: stop$/, out)
-      assert_match(/#1->irb#1 on main $#<Thread:0x.+ run>: running$/, out)
-    end
-
-    def test_irb_fg_jobs_and_kill_commands
-      out = run_ruby_file do
-        type "irb"
-        type "fg 0"
-        type "jobs"
-        type "kill 1"
-        type "exit"
-      end
-
-      assert_match(/#0->irb on main $#<Thread:0x.+ run>: running$/, out)
-      assert_match(/#1->irb#1 on main $#<Thread:0x.+ sleep_forever>: stop$/, out)
-    end
-  end
-end
diff --git a/test/mri/irb/command/test_show_source.rb b/test/mri/irb/command/test_show_source.rb
deleted file mode 100644
index a4227231e4a..00000000000
--- a/test/mri/irb/command/test_show_source.rb
+++ /dev/null
@@ -1,410 +0,0 @@
-# frozen_string_literal: false
-require 'irb'
-
-require_relative "../helper"
-
-module TestIRB
-  class ShowSourceTest < IntegrationTestCase
-    def setup
-      super
-
-      write_rc <<~'RUBY'
-        IRB.conf[:USE_PAGER] = false
-      RUBY
-    end
-
-    def test_show_source
-      write_ruby <<~'RUBY'
-        binding.irb
-      RUBY
-
-      out = run_ruby_file do
-        type "show_source IRB.conf"
-        type "exit"
-      end
-
-      assert_match(%r[/irb\/init\.rb], out)
-    end
-
-    def test_show_source_alias
-      write_ruby <<~'RUBY'
-        binding.irb
-      RUBY
-
-      out = run_ruby_file do
-        type "$ IRB.conf"
-        type "exit"
-      end
-
-      assert_match(%r[/irb\/init\.rb], out)
-    end
-
-    def test_show_source_with_missing_signature
-      write_ruby <<~'RUBY'
-        binding.irb
-      RUBY
-
-      out = run_ruby_file do
-        type "show_source foo"
-        type "exit"
-      end
-
-      assert_match(%r[Couldn't locate a definition for foo], out)
-    end
-
-    def test_show_source_with_missing_constant
-      write_ruby <<~'RUBY'
-        binding.irb
-      RUBY
-
-      out = run_ruby_file do
-        type "show_source Foo"
-        type "exit"
-      end
-
-      assert_match(%r[Couldn't locate a definition for Foo], out)
-    end
-
-    def test_show_source_with_eval_error
-      write_ruby <<~'RUBY'
-        binding.irb
-      RUBY
-
-      out = run_ruby_file do
-        type "show_source raise(Exception).itself"
-        type "exit"
-      end
-
-      assert_match(%r[Couldn't locate a definition for raise$Exception$\.itself], out)
-    end
-
-    def test_show_source_string
-      write_ruby <<~'RUBY'
-        binding.irb
-      RUBY
-
-      out = run_ruby_file do
-        type "show_source 'IRB.conf'"
-        type "exit"
-      end
-
-      assert_match(%r[/irb\/init\.rb], out)
-    end
-
-    def test_show_source_method_s
-      write_ruby <<~RUBY
-        class Baz
-          def foo
-          end
-        end
-
-        class Bar < Baz
-          def foo
-            super
-          end
-        end
-
-        binding.irb
-      RUBY
-
-      out = run_ruby_file do
-        type "show_source Bar#foo -s"
-        type "exit"
-      end
-
-      assert_match(%r[#{@ruby_file.to_path}:2\s+def foo\r\n  end\r\n], out)
-    end
-
-    def test_show_source_method_s_with_incorrect_signature
-      write_ruby <<~RUBY
-        class Baz
-          def foo
-          end
-        end
-
-        class Bar < Baz
-          def foo
-            super
-          end
-        end
-
-        binding.irb
-      RUBY
-
-      out = run_ruby_file do
-        type "show_source Bar#fooo -s"
-        type "exit"
-      end
-
-      assert_match(%r[Error: Couldn't locate a super definition for Bar#fooo], out)
-    end
-
-    def test_show_source_private_method
-      write_ruby <<~RUBY
-        class Bar
-          private def foo
-          end
-        end
-        binding.irb
-      RUBY
-
-      out = run_ruby_file do
-        type "show_source Bar#foo"
-        type "exit"
-      end
-
-      assert_match(%r[#{@ruby_file.to_path}:2\s+private def foo\r\n  end\r\n], out)
-    end
-
-    def test_show_source_private_singleton_method
-      write_ruby <<~RUBY
-        class Bar
-          private def foo
-          end
-        end
-        binding.irb
-      RUBY
-
-      out = run_ruby_file do
-        type "bar = Bar.new"
-        type "show_source bar.foo"
-        type "exit"
-      end
-
-      assert_match(%r[#{@ruby_file.to_path}:2\s+private def foo\r\n  end\r\n], out)
-    end
-
-    def test_show_source_method_multiple_s
-      write_ruby <<~RUBY
-        class Baz
-          def foo
-          end
-        end
-
-        class Bar < Baz
-          def foo
-            super
-          end
-        end
-
-        class Bob < Bar
-          def foo
-            super
-          end
-        end
-
-        binding.irb
-      RUBY
-
-      out = run_ruby_file do
-        type "show_source Bob#foo -ss"
-        type "exit"
-      end
-
-      assert_match(%r[#{@ruby_file.to_path}:2\s+def foo\r\n  end\r\n], out)
-    end
-
-    def test_show_source_method_no_instance_method
-      write_ruby <<~RUBY
-        class Baz
-        end
-
-        class Bar < Baz
-          def foo
-            super
-          end
-        end
-
-        binding.irb
-      RUBY
-
-      out = run_ruby_file do
-        type "show_source Bar#foo -s"
-        type "exit"
-      end
-
-      assert_match(%r[Error: Couldn't locate a super definition for Bar#foo], out)
-    end
-
-    def test_show_source_method_exceeds_super_chain
-      write_ruby <<~RUBY
-        class Baz
-          def foo
-          end
-        end
-
-        class Bar < Baz
-          def foo
-            super
-          end
-        end
-
-        binding.irb
-      RUBY
-
-      out = run_ruby_file do
-        type "show_source Bar#foo -ss"
-        type "exit"
-      end
-
-      assert_match(%r[Error: Couldn't locate a super definition for Bar#foo], out)
-    end
-
-    def test_show_source_method_accidental_characters
-      write_ruby <<~'RUBY'
-        class Baz
-          def foo
-          end
-        end
-
-        class Bar < Baz
-          def foo
-            super
-          end
-        end
-
-        binding.irb
-      RUBY
-
-      out = run_ruby_file do
-        type "show_source Bar#foo -sddddd"
-        type "exit"
-      end
-
-      assert_match(%r[#{@ruby_file.to_path}:2\s+def foo\r\n  end], out)
-    end
-
-    def test_show_source_receiver_super
-      write_ruby <<~RUBY
-        class Baz
-          def foo
-          end
-        end
-
-        class Bar < Baz
-          def foo
-            super
-          end
-        end
-
-        binding.irb
-      RUBY
-
-      out = run_ruby_file do
-        type "bar = Bar.new"
-        type "show_source bar.foo -s"
-        type "exit"
-      end
-
-      assert_match(%r[#{@ruby_file.to_path}:2\s+def foo\r\n  end], out)
-    end
-
-    def test_show_source_with_double_colons
-      write_ruby <<~RUBY
-        class Foo
-        end
-
-        class Foo
-          class Bar
-          end
-        end
-
-        binding.irb
-      RUBY
-
-      out = run_ruby_file do
-        type "show_source ::Foo"
-        type "exit"
-      end
-
-      assert_match(%r[#{@ruby_file.to_path}:1\s+class Foo\r\nend], out)
-
-      out = run_ruby_file do
-        type "show_source ::Foo::Bar"
-        type "exit"
-      end
-
-      assert_match(%r[#{@ruby_file.to_path}:5\s+class Bar\r\n  end], out)
-    end
-
-    def test_show_source_keep_script_lines
-      pend unless defined?(RubyVM.keep_script_lines)
-
-      write_ruby <<~RUBY
-        binding.irb
-      RUBY
-
-      out = run_ruby_file do
-        type "def foo; end"
-        type "show_source foo"
-        type "exit"
-      end
-
-      assert_match(%r[#{@ruby_file.to_path}$irb$:1\s+def foo; end], out)
-    end
-
-    def test_show_source_unavailable_source
-      write_ruby <<~RUBY
-        binding.irb
-      RUBY
-
-      out = run_ruby_file do
-        type "RubyVM.keep_script_lines = false if defined?(RubyVM.keep_script_lines)"
-        type "def foo; end"
-        type "show_source foo"
-        type "exit"
-      end
-      assert_match(%r[#{@ruby_file.to_path}$irb$:2\s+Source not available], out)
-    end
-
-    def test_show_source_shows_binary_source
-      write_ruby <<~RUBY
-        # io-console is an indirect dependency of irb
-        require "io/console"
-
-        binding.irb
-      RUBY
-
-      out = run_ruby_file do
-        # IO::ConsoleMode is defined in io-console gem's C extension
-        type "show_source IO::ConsoleMode"
-        type "exit"
-      end
-
-      # A safeguard to make sure the test subject is actually defined
-      refute_match(/NameError/, out)
-      assert_match(%r[Defined in binary file:.+io/console], out)
-    end
-
-    def test_show_source_with_constant_lookup
-      write_ruby <<~RUBY
-        X = 1
-        module M
-          Y = 1
-          Z = 2
-        end
-        class A
-          Z = 1
-          Array = 1
-          class B
-            include M
-            Object.new.instance_eval { binding.irb }
-          end
-        end
-      RUBY
-
-      out = run_ruby_file do
-        type "show_source X"
-        type "show_source Y"
-        type "show_source Z"
-        type "show_source Array"
-        type "exit"
-      end
-
-      assert_match(%r[#{@ruby_file.to_path}:1\s+X = 1], out)
-      assert_match(%r[#{@ruby_file.to_path}:3\s+Y = 1], out)
-      assert_match(%r[#{@ruby_file.to_path}:7\s+Z = 1], out)
-      assert_match(%r[#{@ruby_file.to_path}:8\s+Array = 1], out)
-    end
-  end
-end
diff --git a/test/mri/irb/helper.rb b/test/mri/irb/helper.rb
deleted file mode 100644
index ea2c6ef16a4..00000000000
--- a/test/mri/irb/helper.rb
+++ /dev/null
@@ -1,234 +0,0 @@
-require "test/unit"
-require "pathname"
-require "rubygems"
-
-begin
-  require_relative "../lib/helper"
-  require_relative "../lib/envutil"
-rescue LoadError # ruby/ruby defines helpers differently
-end
-
-begin
-  require "pty"
-rescue LoadError # some platforms don't support PTY
-end
-
-module IRB
-  class InputMethod; end
-end
-
-module TestIRB
-  RUBY_3_4 = Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("3.4.0.dev")
-  class TestCase < Test::Unit::TestCase
-    class TestInputMethod < ::IRB::InputMethod
-      attr_reader :list, :line_no
-
-      def initialize(list = [])
-        @line_no = 0
-        @list = list
-      end
-
-      def gets
-        @list[@line_no]&.tap {@line_no += 1}
-      end
-
-      def eof?
-        @line_no >= @list.size
-      end
-
-      def encoding
-        Encoding.default_external
-      end
-
-      def reset
-        @line_no = 0
-      end
-    end
-
-    def ruby_core?
-      !Pathname(__dir__).join("../../", "irb.gemspec").exist?
-    end
-
-    def setup_envs(home:)
-      @backup_home = ENV["HOME"]
-      ENV["HOME"] = home
-      @backup_xdg_config_home = ENV.delete("XDG_CONFIG_HOME")
-      @backup_irbrc = ENV.delete("IRBRC")
-    end
-
-    def teardown_envs
-      ENV["HOME"] = @backup_home
-      ENV["XDG_CONFIG_HOME"] = @backup_xdg_config_home
-      ENV["IRBRC"] = @backup_irbrc
-    end
-
-    def save_encodings
-      @default_encoding = [Encoding.default_external, Encoding.default_internal]
-      @stdio_encodings = [STDIN, STDOUT, STDERR].map {|io| [io.external_encoding, io.internal_encoding] }
-    end
-
-    def restore_encodings
-      EnvUtil.suppress_warning do
-        Encoding.default_external, Encoding.default_internal = *@default_encoding
-        [STDIN, STDOUT, STDERR].zip(@stdio_encodings) do |io, encs|
-          io.set_encoding(*encs)
-        end
-      end
-    end
-
-    def without_rdoc(&block)
-      ::Kernel.send(:alias_method, :irb_original_require, :require)
-
-      ::Kernel.define_method(:require) do |name|
-        raise LoadError, "cannot load such file -- rdoc (test)" if name.match?("rdoc") || name.match?(/^rdoc\/.*/)
-        ::Kernel.send(:irb_original_require, name)
-      end
-
-      yield
-    ensure
-      EnvUtil.suppress_warning {
-        ::Kernel.send(:alias_method, :require, :irb_original_require)
-        ::Kernel.undef_method :irb_original_require
-      }
-    end
-  end
-
-  class IntegrationTestCase < TestCase
-    LIB = File.expand_path("../../lib", __dir__)
-    TIMEOUT_SEC = 3
-
-    def setup
-      @envs = {}
-      @tmpfiles = []
-
-      unless defined?(PTY)
-        omit "Integration tests require PTY."
-      end
-
-      if ruby_core?
-        omit "This test works only under ruby/irb"
-      end
-
-      write_rc <<~RUBY
-        IRB.conf[:USE_PAGER] = false
-      RUBY
-    end
-
-    def teardown
-      @tmpfiles.each do |tmpfile|
-        File.unlink(tmpfile)
-      end
-    end
-
-    def run_ruby_file(&block)
-      cmd = [EnvUtil.rubybin, "-I", LIB, @ruby_file.to_path]
-      tmp_dir = Dir.mktmpdir
-
-      @commands = []
-      lines = []
-
-      yield
-
-      # Test should not depend on user's irbrc file
-      @envs["HOME"] ||= tmp_dir
-      @envs["XDG_CONFIG_HOME"] ||= tmp_dir
-      @envs["IRBRC"] = nil unless @envs.key?("IRBRC")
-
-      envs_for_spawn = @envs.merge('TERM' => 'dumb', 'TEST_IRB_FORCE_INTERACTIVE' => 'true')
-
-      PTY.spawn(envs_for_spawn, *cmd) do |read, write, pid|
-        Timeout.timeout(TIMEOUT_SEC) do
-          while line = safe_gets(read)
-            lines << line
-
-            # means the breakpoint is triggered
-            if line.match?(/binding\.irb/)
-              while command = @commands.shift
-                write.puts(command)
-              end
-            end
-          end
-        end
-      ensure
-        read.close
-        write.close
-        kill_safely(pid)
-      end
-
-      lines.join
-    rescue Timeout::Error
-      message = <<~MSG
-      Test timedout.
-
-      #{'=' * 30} OUTPUT #{'=' * 30}
-        #{lines.map { |l| "  #{l}" }.join}
-      #{'=' * 27} END OF OUTPUT #{'=' * 27}
-      MSG
-      assert_block(message) { false }
-    ensure
-      FileUtils.remove_entry tmp_dir
-    end
-
-    # read.gets could raise exceptions on some platforms
-    # https://github.com/ruby/ruby/blob/master/ext/pty/pty.c#L721-L728
-    def safe_gets(read)
-      read.gets
-    rescue Errno::EIO
-      nil
-    end
-
-    def kill_safely pid
-      return if wait_pid pid, TIMEOUT_SEC
-
-      Process.kill :TERM, pid
-      return if wait_pid pid, 0.2
-
-      Process.kill :KILL, pid
-      Process.waitpid(pid)
-    rescue Errno::EPERM, Errno::ESRCH
-    end
-
-    def wait_pid pid, sec
-      total_sec = 0.0
-      wait_sec = 0.001 # 1ms
-
-      while total_sec < sec
-        if Process.waitpid(pid, Process::WNOHANG) == pid
-          return true
-        end
-        sleep wait_sec
-        total_sec += wait_sec
-        wait_sec *= 2
-      end
-
-      false
-    rescue Errno::ECHILD
-      true
-    end
-
-    def type(command)
-      @commands << command
-    end
-
-    def write_ruby(program)
-      @ruby_file = Tempfile.create(%w{irbtest- .rb})
-      @tmpfiles << @ruby_file
-      @ruby_file.write(program)
-      @ruby_file.close
-    end
-
-    def write_rc(content)
-      # Append irbrc content if a tempfile for it already exists
-      if @irbrc
-        @irbrc = File.open(@irbrc, "a")
-      else
-        @irbrc = Tempfile.new('irbrc')
-        @tmpfiles << @irbrc
-      end
-
-      @irbrc.write(content)
-      @irbrc.close
-      @envs['IRBRC'] = @irbrc.path
-    end
-  end
-end
diff --git a/test/mri/irb/test_color.rb b/test/mri/irb/test_color.rb
deleted file mode 100644
index 9d78f5233e2..00000000000
--- a/test/mri/irb/test_color.rb
+++ /dev/null
@@ -1,274 +0,0 @@
-# frozen_string_literal: false
-require 'irb/color'
-require 'stringio'
-
-require_relative "helper"
-
-module TestIRB
-  class ColorTest < TestCase
-    CLEAR     = "\e[0m"
-    BOLD      = "\e[1m"
-    UNDERLINE = "\e[4m"
-    REVERSE   = "\e[7m"
-    RED       = "\e[31m"
-    GREEN     = "\e[32m"
-    YELLOW    = "\e[33m"
-    BLUE      = "\e[34m"
-    MAGENTA   = "\e[35m"
-    CYAN      = "\e[36m"
-
-    def setup
-      super
-      if IRB.respond_to?(:conf)
-        @colorize, IRB.conf[:USE_COLORIZE] = IRB.conf[:USE_COLORIZE], true
-      end
-    end
-
-    def teardown
-      if instance_variable_defined?(:@colorize)
-        IRB.conf[:USE_COLORIZE] = @colorize
-      end
-      super
-    end
-
-    def test_colorize
-      text = "text"
-      {
-        [:BOLD]      => "#{BOLD}#{text}#{CLEAR}",
-        [:UNDERLINE] => "#{UNDERLINE}#{text}#{CLEAR}",
-        [:REVERSE]   => "#{REVERSE}#{text}#{CLEAR}",
-        [:RED]       => "#{RED}#{text}#{CLEAR}",
-        [:GREEN]     => "#{GREEN}#{text}#{CLEAR}",
-        [:YELLOW]    => "#{YELLOW}#{text}#{CLEAR}",
-        [:BLUE]      => "#{BLUE}#{text}#{CLEAR}",
-        [:MAGENTA]   => "#{MAGENTA}#{text}#{CLEAR}",
-        [:CYAN]      => "#{CYAN}#{text}#{CLEAR}",
-      }.each do |seq, result|
-        assert_equal_with_term(result, text, seq: seq)
-
-        assert_equal_with_term(text, text, seq: seq, tty: false)
-        assert_equal_with_term(text, text, seq: seq, colorable: false)
-        assert_equal_with_term(result, text, seq: seq, tty: false, colorable: true)
-      end
-    end
-
-    def test_colorize_code
-      # Common behaviors. Warn parser error, but do not warn compile error.
-      tests = {
-        "1" => "#{BLUE}#{BOLD}1#{CLEAR}",
-        "2.3" => "#{MAGENTA}#{BOLD}2.3#{CLEAR}",
-        "7r" => "#{BLUE}#{BOLD}7r#{CLEAR}",
-        "8i" => "#{BLUE}#{BOLD}8i#{CLEAR}",
-        "['foo', :bar]" => "[#{RED}#{BOLD}'#{CLEAR}#{RED}foo#{CLEAR}#{RED}#{BOLD}'#{CLEAR}, #{YELLOW}:#{CLEAR}#{YELLOW}bar#{CLEAR}]",
-        "class A; end" => "#{GREEN}class#{CLEAR} #{BLUE}#{BOLD}#{UNDERLINE}A#{CLEAR}; #{GREEN}end#{CLEAR}",
-        "def self.foo; bar; end" => "#{GREEN}def#{CLEAR} #{CYAN}#{BOLD}self#{CLEAR}.#{BLUE}#{BOLD}foo#{CLEAR}; bar; #{GREEN}end#{CLEAR}",
-        'erb = ERB.new("a#{nil}b", trim_mode: "-")' => "erb = #{BLUE}#{BOLD}#{UNDERLINE}ERB#{CLEAR}.new(#{RED}#{BOLD}\"#{CLEAR}#{RED}a#{CLEAR}#{RED}\#{#{CLEAR}#{CYAN}#{BOLD}nil#{CLEAR}#{RED}}#{CLEAR}#{RED}b#{CLEAR}#{RED}#{BOLD}\"#{CLEAR}, #{MAGENTA}trim_mode:#{CLEAR} #{RED}#{BOLD}\"#{CLEAR}#{RED}-#{CLEAR}#{RED}#{BOLD}\"#{CLEAR})",
-        "# comment" => "#{BLUE}#{BOLD}# comment#{CLEAR}",
-        "def f;yield(hello);end" => "#{GREEN}def#{CLEAR} #{BLUE}#{BOLD}f#{CLEAR};#{GREEN}yield#{CLEAR}(hello);#{GREEN}end#{CLEAR}",
-        '"##@var]"' => "#{RED}#{BOLD}\"#{CLEAR}#{RED}\##{CLEAR}#{RED}\##{CLEAR}@var#{RED}]#{CLEAR}#{RED}#{BOLD}\"#{CLEAR}",
-        '"foo#{a} #{b}"' => "#{RED}#{BOLD}\"#{CLEAR}#{RED}foo#{CLEAR}#{RED}\#{#{CLEAR}a#{RED}}#{CLEAR}#{RED} #{CLEAR}#{RED}\#{#{CLEAR}b#{RED}}#{CLEAR}#{RED}#{BOLD}\"#{CLEAR}",
-        '/r#{e}g/' => "#{RED}#{BOLD}/#{CLEAR}#{RED}r#{CLEAR}#{RED}\#{#{CLEAR}e#{RED}}#{CLEAR}#{RED}g#{CLEAR}#{RED}#{BOLD}/#{CLEAR}",
-        "'a\nb'" => "#{RED}#{BOLD}'#{CLEAR}#{RED}a#{CLEAR}\n#{RED}b#{CLEAR}#{RED}#{BOLD}'#{CLEAR}",
-        "%[str]" => "#{RED}#{BOLD}%[#{CLEAR}#{RED}str#{CLEAR}#{RED}#{BOLD}]#{CLEAR}",
-        "%Q[str]" => "#{RED}#{BOLD}%Q[#{CLEAR}#{RED}str#{CLEAR}#{RED}#{BOLD}]#{CLEAR}",
-        "%q[str]" => "#{RED}#{BOLD}%q[#{CLEAR}#{RED}str#{CLEAR}#{RED}#{BOLD}]#{CLEAR}",
-        "%x[cmd]" => "#{RED}#{BOLD}%x[#{CLEAR}#{RED}cmd#{CLEAR}#{RED}#{BOLD}]#{CLEAR}",
-        "%r[reg]" => "#{RED}#{BOLD}%r[#{CLEAR}#{RED}reg#{CLEAR}#{RED}#{BOLD}]#{CLEAR}",
-        "%w[a b]" => "#{RED}#{BOLD}%w[#{CLEAR}#{RED}a#{CLEAR} #{RED}b#{CLEAR}#{RED}#{BOLD}]#{CLEAR}",
-        "%W[a b]" => "#{RED}#{BOLD}%W[#{CLEAR}#{RED}a#{CLEAR} #{RED}b#{CLEAR}#{RED}#{BOLD}]#{CLEAR}",
-        "%s[a b]" => "#{YELLOW}%s[#{CLEAR}#{YELLOW}a b#{CLEAR}#{YELLOW}]#{CLEAR}",
-        "%i[c d]" => "#{YELLOW}%i[#{CLEAR}#{YELLOW}c#{CLEAR}#{YELLOW} #{CLEAR}#{YELLOW}d#{CLEAR}#{YELLOW}]#{CLEAR}",
-        "%I[c d]" => "#{YELLOW}%I[#{CLEAR}#{YELLOW}c#{CLEAR}#{YELLOW} #{CLEAR}#{YELLOW}d#{CLEAR}#{YELLOW}]#{CLEAR}",
-        "{'a': 1}" => "{#{RED}#{BOLD}'#{CLEAR}#{RED}a#{CLEAR}#{RED}#{BOLD}':#{CLEAR} #{BLUE}#{BOLD}1#{CLEAR}}",
-        ":Struct" => "#{YELLOW}:#{CLEAR}#{YELLOW}Struct#{CLEAR}",
-        '"#{}"' => "#{RED}#{BOLD}\"#{CLEAR}#{RED}\#{#{CLEAR}#{RED}}#{CLEAR}#{RED}#{BOLD}\"#{CLEAR}",
-        ':"a#{}b"' => "#{YELLOW}:\"#{CLEAR}#{YELLOW}a#{CLEAR}#{YELLOW}\#{#{CLEAR}#{YELLOW}}#{CLEAR}#{YELLOW}b#{CLEAR}#{YELLOW}\"#{CLEAR}",
-        ':"a#{ def b; end; \'c\' + "#{ :d }" }e"' => "#{YELLOW}:\"#{CLEAR}#{YELLOW}a#{CLEAR}#{YELLOW}\#{#{CLEAR} #{GREEN}def#{CLEAR} #{BLUE}#{BOLD}b#{CLEAR}; #{GREEN}end#{CLEAR}; #{RED}#{BOLD}'#{CLEAR}#{RED}c#{CLEAR}#{RED}#{BOLD}'#{CLEAR} + #{RED}#{BOLD}\"#{CLEAR}#{RED}\#{#{CLEAR} #{YELLOW}:#{CLEAR}#{YELLOW}d#{CLEAR} #{RED}}#{CLEAR}#{RED}#{BOLD}\"#{CLEAR} #{YELLOW}}#{CLEAR}#{YELLOW}e#{CLEAR}#{YELLOW}\"#{CLEAR}",
-        "[__FILE__, __LINE__, __ENCODING__]" => "[#{CYAN}#{BOLD}__FILE__#{CLEAR}, #{CYAN}#{BOLD}__LINE__#{CLEAR}, #{CYAN}#{BOLD}__ENCODING__#{CLEAR}]",
-        ":self" => "#{YELLOW}:#{CLEAR}#{YELLOW}self#{CLEAR}",
-        ":class" => "#{YELLOW}:#{CLEAR}#{YELLOW}class#{CLEAR}",
-        "[:end, 2]" => "[#{YELLOW}:#{CLEAR}#{YELLOW}end#{CLEAR}, #{BLUE}#{BOLD}2#{CLEAR}]",
-        "[:>, 3]" => "[#{YELLOW}:#{CLEAR}#{YELLOW}>#{CLEAR}, #{BLUE}#{BOLD}3#{CLEAR}]",
-        "[:`, 4]" => "[#{YELLOW}:#{CLEAR}#{YELLOW}`#{CLEAR}, #{BLUE}#{BOLD}4#{CLEAR}]",
-        ":Hello ? world : nil" => "#{YELLOW}:#{CLEAR}#{YELLOW}Hello#{CLEAR} ? world : #{CYAN}#{BOLD}nil#{CLEAR}",
-        'raise "foo#{bar}baz"' => "raise #{RED}#{BOLD}\"#{CLEAR}#{RED}foo#{CLEAR}#{RED}\#{#{CLEAR}bar#{RED}}#{CLEAR}#{RED}baz#{CLEAR}#{RED}#{BOLD}\"#{CLEAR}",
-        '["#{obj.inspect}"]' => "[#{RED}#{BOLD}\"#{CLEAR}#{RED}\#{#{CLEAR}obj.inspect#{RED}}#{CLEAR}#{RED}#{BOLD}\"#{CLEAR}]",
-        'URI.parse "#{}"' => "#{BLUE}#{BOLD}#{UNDERLINE}URI#{CLEAR}.parse #{RED}#{BOLD}\"#{CLEAR}#{RED}\#{#{CLEAR}#{RED}}#{CLEAR}#{RED}#{BOLD}\"#{CLEAR}",
-        "begin\nrescue\nend" => "#{GREEN}begin#{CLEAR}\n#{GREEN}rescue#{CLEAR}\n#{GREEN}end#{CLEAR}",
-        "foo %w[bar]" => "foo #{RED}#{BOLD}%w[#{CLEAR}#{RED}bar#{CLEAR}#{RED}#{BOLD}]#{CLEAR}",
-        "foo %i[bar]" => "foo #{YELLOW}%i[#{CLEAR}#{YELLOW}bar#{CLEAR}#{YELLOW}]#{CLEAR}",
-        "foo :@bar, baz, :@@qux, :$quux" => "foo #{YELLOW}:#{CLEAR}#{YELLOW}@bar#{CLEAR}, baz, #{YELLOW}:#{CLEAR}#{YELLOW}@@qux#{CLEAR}, #{YELLOW}:#{CLEAR}#{YELLOW}$quux#{CLEAR}",
-        "`echo`" => "#{RED}#{BOLD}`#{CLEAR}#{RED}echo#{CLEAR}#{RED}#{BOLD}`#{CLEAR}",
-        "\t" => Reline::Unicode.escape_for_print("\t") == '  ' ? '  ' : "\t", # not ^I
-        "foo(*%W(bar))" => "foo(*#{RED}#{BOLD}%W(#{CLEAR}#{RED}bar#{CLEAR}#{RED}#{BOLD})#{CLEAR})",
-        "$stdout" => "#{GREEN}#{BOLD}$stdout#{CLEAR}",
-        "__END__" => "#{GREEN}__END__#{CLEAR}",
-        "foo\n__END__\nbar" => "foo\n#{GREEN}__END__#{CLEAR}\nbar",
-        "foo\n<<A\0\0bar\nA\nbaz" => "foo\n#{RED}<<A#{CLEAR}^@^@bar\n#{RED}A#{CLEAR}\nbaz",
-        "<<A+1\nA" => "#{RED}<<A#{CLEAR}+#{BLUE}#{BOLD}1#{CLEAR}\n#{RED}A#{CLEAR}",
-      }
-
-      tests.merge!({
-        "4.5.6" => "#{MAGENTA}#{BOLD}4.5#{CLEAR}#{RED}#{REVERSE}.6#{CLEAR}",
-        "\e[0m\n" => "#{RED}#{REVERSE}^[#{CLEAR}[#{BLUE}#{BOLD}0#{CLEAR}#{RED}#{REVERSE}m#{CLEAR}\n",
-        "<<EOS\nhere\nEOS" => "#{RED}<<EOS#{CLEAR}\n#{RED}here#{CLEAR}\n#{RED}EOS#{CLEAR}",
-      })
-
-      # specific to Ruby 3.0+
-      if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('3.0.0')
-        tests.merge!({
-          "[1]]]\u0013" => "[#{BLUE}#{BOLD}1#{CLEAR}]#{RED}#{REVERSE}]#{CLEAR}#{RED}#{REVERSE}]#{CLEAR}#{RED}#{REVERSE}^S#{CLEAR}",
-        })
-        tests.merge!({
-          "def req(true) end" => "#{GREEN}def#{CLEAR} #{BLUE}#{BOLD}req#{CLEAR}(#{RED}#{REVERSE}true#{CLEAR}) #{RED}#{REVERSE}end#{CLEAR}",
-          "nil = 1" => "#{RED}#{REVERSE}nil#{CLEAR} = #{BLUE}#{BOLD}1#{CLEAR}",
-          "alias $x $1" => "#{GREEN}alias#{CLEAR} #{GREEN}#{BOLD}$x#{CLEAR} #{RED}#{REVERSE}$1#{CLEAR}",
-          "class bad; end" => "#{GREEN}class#{CLEAR} #{RED}#{REVERSE}bad#{CLEAR}; #{GREEN}end#{CLEAR}",
-          "def req(@a) end" => "#{GREEN}def#{CLEAR} #{BLUE}#{BOLD}req#{CLEAR}(#{RED}#{REVERSE}@a#{CLEAR}) #{GREEN}end#{CLEAR}",
-        })
-        if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('3.2.0')
-          tests.merge!({
-            "def req(true) end" => "#{GREEN}def#{CLEAR} #{BLUE}#{BOLD}req#{CLEAR}(#{RED}#{REVERSE}true#{CLEAR}#{RED}#{REVERSE})#{CLEAR} #{RED}#{REVERSE}end#{CLEAR}",
-          })
-        end
-      else
-        tests.merge!({
-          "[1]]]\u0013" => "[#{BLUE}#{BOLD}1#{CLEAR}]#{RED}#{REVERSE}]#{CLEAR}]^S",
-          "def req(true) end" => "#{GREEN}def#{CLEAR} #{BLUE}#{BOLD}req#{CLEAR}(#{RED}#{REVERSE}true#{CLEAR}) end",
-          "nil = 1" => "#{CYAN}#{BOLD}nil#{CLEAR} = #{BLUE}#{BOLD}1#{CLEAR}",
-          "alias $x $1" => "#{GREEN}alias#{CLEAR} #{GREEN}#{BOLD}$x#{CLEAR} $1",
-          "class bad; end" => "#{GREEN}class#{CLEAR} bad; #{GREEN}end#{CLEAR}",
-          "def req(@a) end" => "#{GREEN}def#{CLEAR} #{BLUE}#{BOLD}req#{CLEAR}(@a) #{GREEN}end#{CLEAR}",
-        })
-      end
-
-      tests.each do |code, result|
-        assert_equal_with_term(result, code, complete: true)
-        assert_equal_with_term(result, code, complete: false)
-
-        assert_equal_with_term(code, code, complete: true, tty: false)
-        assert_equal_with_term(code, code, complete: false, tty: false)
-
-        assert_equal_with_term(code, code, complete: true, colorable: false)
-
-        assert_equal_with_term(code, code, complete: false, colorable: false)
-
-        assert_equal_with_term(result, code, complete: true, tty: false, colorable: true)
-
-        assert_equal_with_term(result, code, complete: false, tty: false, colorable: true)
-      end
-    end
-
-    def test_colorize_code_with_local_variables
-      code = "a /(b +1)/i"
-      result_without_lvars = "a #{RED}#{BOLD}/#{CLEAR}#{RED}(b +1)#{CLEAR}#{RED}#{BOLD}/i#{CLEAR}"
-      result_with_lvar = "a /(b #{BLUE}#{BOLD}+1#{CLEAR})/i"
-      result_with_lvars = "a /(b +#{BLUE}#{BOLD}1#{CLEAR})/i"
-
-      assert_equal_with_term(result_without_lvars, code)
-      assert_equal_with_term(result_with_lvar, code, local_variables: ['a'])
-      assert_equal_with_term(result_with_lvars, code, local_variables: ['a', 'b'])
-    end
-
-    def test_colorize_code_complete_true
-      # `complete: true` behaviors. Warn end-of-file.
-      {
-        "'foo' + 'bar" => "#{RED}#{BOLD}'#{CLEAR}#{RED}foo#{CLEAR}#{RED}#{BOLD}'#{CLEAR} + #{RED}#{BOLD}'#{CLEAR}#{RED}#{REVERSE}bar#{CLEAR}",
-        "('foo" => "(#{RED}#{BOLD}'#{CLEAR}#{RED}#{REVERSE}foo#{CLEAR}",
-      }.each do |code, result|
-        assert_equal_with_term(result, code, complete: true)
-
-        assert_equal_with_term(code, code, complete: true, tty: false)
-
-        assert_equal_with_term(code, code, complete: true, colorable: false)
-
-        assert_equal_with_term(result, code, complete: true, tty: false, colorable: true)
-      end
-    end
-
-    def test_colorize_code_complete_false
-      # `complete: false` behaviors. Do not warn end-of-file.
-      {
-        "'foo' + 'bar" => "#{RED}#{BOLD}'#{CLEAR}#{RED}foo#{CLEAR}#{RED}#{BOLD}'#{CLEAR} + #{RED}#{BOLD}'#{CLEAR}#{RED}bar#{CLEAR}",
-        "('foo" => "(#{RED}#{BOLD}'#{CLEAR}#{RED}foo#{CLEAR}",
-      }.each do |code, result|
-        assert_equal_with_term(result, code, complete: false)
-
-        assert_equal_with_term(code, code, complete: false, tty: false)
-
-        assert_equal_with_term(code, code, complete: false, colorable: false)
-
-        assert_equal_with_term(result, code, complete: false, tty: false, colorable: true)
-      end
-    end
-
-    def test_inspect_colorable
-      {
-        1 => true,
-        2.3 => true,
-        ['foo', :bar] => true,
-        (a = []; a << a; a) => false,
-        (h = {}; h[h] = h; h) => false,
-        { a: 4 } => true,
-        /reg/ => true,
-        (1..3) => true,
-        Object.new => false,
-        Struct => true,
-        Test => true,
-        Struct.new(:a) => false,
-        Struct.new(:a).new(1) => false,
-      }.each do |object, result|
-        assert_equal(result, IRB::Color.inspect_colorable?(object), "Case: inspect_colorable?(#{object.inspect})")
-      end
-    end
-
-    private
-
-    def with_term(tty: true)
-      stdout = $stdout
-      io = StringIO.new
-      def io.tty?; true; end if tty
-      $stdout = io
-
-      env = ENV.to_h.dup
-      ENV['TERM'] = 'xterm-256color'
-
-      yield
-    ensure
-      $stdout = stdout
-      ENV.replace(env) if env
-    end
-
-    def assert_equal_with_term(result, code, seq: nil, tty: true, **opts)
-      actual = with_term(tty: tty) do
-        if seq
-          IRB::Color.colorize(code, seq, **opts)
-        else
-          IRB::Color.colorize_code(code, **opts)
-        end
-      end
-      message = -> {
-        args = [code.dump]
-        args << seq.inspect if seq
-        opts.each {|kwd, val| args << "#{kwd}: #{val}"}
-        "Case: colorize#{seq ? "" : "_code"}(#{args.join(', ')})\nResult: #{humanized_literal(actual)}"
-      }
-      assert_equal(result, actual, message)
-    end
-
-    def humanized_literal(str)
-      str
-        .gsub(CLEAR, '@@@{CLEAR}')
-        .gsub(BOLD, '@@@{BOLD}')
-        .gsub(UNDERLINE, '@@@{UNDERLINE}')
-        .gsub(REVERSE, '@@@{REVERSE}')
-        .gsub(RED, '@@@{RED}')
-        .gsub(GREEN, '@@@{GREEN}')
-        .gsub(YELLOW, '@@@{YELLOW}')
-        .gsub(BLUE, '@@@{BLUE}')
-        .gsub(MAGENTA, '@@@{MAGENTA}')
-        .gsub(CYAN, '@@@{CYAN}')
-        .dump.gsub(/@@@/, '#')
-    end
-  end
-end
diff --git a/test/mri/irb/test_color_printer.rb b/test/mri/irb/test_color_printer.rb
deleted file mode 100644
index c2c624d8689..00000000000
--- a/test/mri/irb/test_color_printer.rb
+++ /dev/null
@@ -1,69 +0,0 @@
-# frozen_string_literal: false
-require 'irb/color_printer'
-require 'stringio'
-
-require_relative "helper"
-
-module TestIRB
-  class ColorPrinterTest < TestCase
-    CLEAR     = "\e[0m"
-    BOLD      = "\e[1m"
-    RED       = "\e[31m"
-    GREEN     = "\e[32m"
-    BLUE      = "\e[34m"
-    CYAN      = "\e[36m"
-
-    def setup
-      super
-      if IRB.respond_to?(:conf)
-        @colorize, IRB.conf[:USE_COLORIZE] = IRB.conf[:USE_COLORIZE], true
-      end
-      @get_screen_size = Reline.method(:get_screen_size)
-      Reline.instance_eval { undef :get_screen_size }
-      def Reline.get_screen_size
-        [36, 80]
-      end
-    end
-
-    def teardown
-      Reline.instance_eval { undef :get_screen_size }
-      Reline.define_singleton_method(:get_screen_size, @get_screen_size)
-      if instance_variable_defined?(:@colorize)
-        IRB.conf[:USE_COLORIZE] = @colorize
-      end
-      super
-    end
-
-    IRBTestColorPrinter = Struct.new(:a)
-
-    def test_color_printer
-      {
-        1 => "#{BLUE}#{BOLD}1#{CLEAR}\n",
-        "a\nb" => %[#{RED}#{BOLD}"#{CLEAR}#{RED}a\\nb#{CLEAR}#{RED}#{BOLD}"#{CLEAR}\n],
-        IRBTestColorPrinter.new('test') => "#{GREEN}#<struct TestIRB::ColorPrinterTest::IRBTestColorPrinter#{CLEAR} a#{GREEN}=#{CLEAR}#{RED}#{BOLD}\"#{CLEAR}#{RED}test#{CLEAR}#{RED}#{BOLD}\"#{CLEAR}#{GREEN}>#{CLEAR}\n",
-        Ripper::Lexer.new('1').scan => "[#{GREEN}#<Ripper::Lexer::Elem:#{CLEAR} on_int@1:0 END token: #{RED}#{BOLD}\"#{CLEAR}#{RED}1#{CLEAR}#{RED}#{BOLD}\"#{CLEAR}#{GREEN}>#{CLEAR}]\n",
-        Class.new{define_method(:pretty_print){|q| q.text("[__FILE__, __LINE__, __ENCODING__]")}}.new => "[#{CYAN}#{BOLD}__FILE__#{CLEAR}, #{CYAN}#{BOLD}__LINE__#{CLEAR}, #{CYAN}#{BOLD}__ENCODING__#{CLEAR}]\n",
-      }.each do |object, result|
-        actual = with_term { IRB::ColorPrinter.pp(object, '') }
-        assert_equal(result, actual, "Case: IRB::ColorPrinter.pp(#{object.inspect}, '')")
-      end
-    end
-
-    private
-
-    def with_term
-      stdout = $stdout
-      io = StringIO.new
-      def io.tty?; true; end
-      $stdout = io
-
-      env = ENV.to_h.dup
-      ENV['TERM'] = 'xterm-256color'
-
-      yield
-    ensure
-      $stdout = stdout
-      ENV.replace(env) if env
-    end
-  end
-end
diff --git a/test/mri/irb/test_command.rb b/test/mri/irb/test_command.rb
deleted file mode 100644
index 21e05752b90..00000000000
--- a/test/mri/irb/test_command.rb
+++ /dev/null
@@ -1,971 +0,0 @@
-# frozen_string_literal: false
-require "irb"
-
-require_relative "helper"
-
-module TestIRB
-  class CommandTestCase < TestCase
-    def setup
-      @pwd = Dir.pwd
-      @tmpdir = File.join(Dir.tmpdir, "test_reline_config_#{$$}")
-      begin
-        Dir.mkdir(@tmpdir)
-      rescue Errno::EEXIST
-        FileUtils.rm_rf(@tmpdir)
-        Dir.mkdir(@tmpdir)
-      end
-      Dir.chdir(@tmpdir)
-      setup_envs(home: @tmpdir)
-      save_encodings
-      IRB.instance_variable_get(:@CONF).clear
-      IRB.instance_variable_set(:@existing_rc_name_generators, nil)
-      @is_win = (RbConfig::CONFIG['host_os'] =~ /mswin|msys|mingw|cygwin|bccwin|wince|emc/)
-    end
-
-    def teardown
-      teardown_envs
-      Dir.chdir(@pwd)
-      FileUtils.rm_rf(@tmpdir)
-      restore_encodings
-    end
-
-    def execute_lines(*lines, conf: {}, main: self, irb_path: nil)
-      capture_output do
-        IRB.init_config(nil)
-        IRB.conf[:VERBOSE] = false
-        IRB.conf[:PROMPT_MODE] = :SIMPLE
-        IRB.conf[:USE_PAGER] = false
-        IRB.conf.merge!(conf)
-        input = TestInputMethod.new(lines)
-        irb = IRB::Irb.new(IRB::WorkSpace.new(main), input)
-        irb.context.return_format = "=> %s\n"
-        irb.context.irb_path = irb_path if irb_path
-        IRB.conf[:MAIN_CONTEXT] = irb.context
-        irb.eval_input
-      end
-    end
-  end
-
-  class FrozenObjectTest < CommandTestCase
-    def test_calling_command_on_a_frozen_main
-      main = Object.new.freeze
-
-      out, err = execute_lines(
-        "irb_info",
-        main: main
-      )
-      assert_empty(err)
-      assert_match(/RUBY_PLATFORM/, out)
-    end
-  end
-
-  class InfoTest < CommandTestCase
-    def setup
-      super
-      @locals_backup = ENV.delete("LANG"), ENV.delete("LC_ALL")
-    end
-
-    def teardown
-      super
-      ENV["LANG"], ENV["LC_ALL"] = @locals_backup
-    end
-
-    def test_irb_info_multiline
-      FileUtils.touch("#{@tmpdir}/.inputrc")
-      FileUtils.touch("#{@tmpdir}/.irbrc")
-      FileUtils.touch("#{@tmpdir}/_irbrc")
-
-      out, err = execute_lines(
-        "irb_info",
-        conf: { USE_MULTILINE: true, USE_SINGLELINE: false }
-      )
-
-      expected = %r{
-        Ruby\sversion:\s.+\n
-        IRB\sversion:\sirb\s.+\n
-        InputMethod:\sAbstract\sInputMethod\n
-        Completion: .+\n
-        \.irbrc\spaths:.*\.irbrc.*_irbrc\n
-        RUBY_PLATFORM:\s.+\n
-        East\sAsian\sAmbiguous\sWidth:\s\d\n
-        #{@is_win ? 'Code\spage:\s\d+\n' : ''}
-      }x
-
-      assert_empty err
-      assert_match expected, out
-    end
-
-    def test_irb_info_singleline
-      FileUtils.touch("#{@tmpdir}/.inputrc")
-      FileUtils.touch("#{@tmpdir}/.irbrc")
-
-      out, err = execute_lines(
-        "irb_info",
-        conf: { USE_MULTILINE: false, USE_SINGLELINE: true }
-      )
-
-      expected = %r{
-        Ruby\sversion:\s.+\n
-        IRB\sversion:\sirb\s.+\n
-        InputMethod:\sAbstract\sInputMethod\n
-        Completion: .+\n
-        \.irbrc\spaths:\s.+\n
-        RUBY_PLATFORM:\s.+\n
-        East\sAsian\sAmbiguous\sWidth:\s\d\n
-        #{@is_win ? 'Code\spage:\s\d+\n' : ''}
-      }x
-
-      assert_empty err
-      assert_match expected, out
-    end
-
-    def test_irb_info_multiline_without_rc_files
-      inputrc_backup = ENV["INPUTRC"]
-      ENV["INPUTRC"] = "unknown_inpurc"
-      ext_backup = IRB::IRBRC_EXT
-      IRB.__send__(:remove_const, :IRBRC_EXT)
-      IRB.const_set(:IRBRC_EXT, "unknown_ext")
-
-      out, err = execute_lines(
-        "irb_info",
-        conf: { USE_MULTILINE: true, USE_SINGLELINE: false }
-      )
-
-      expected = %r{
-        Ruby\sversion:\s.+\n
-        IRB\sversion:\sirb\s.+\n
-        InputMethod:\sAbstract\sInputMethod\n
-        Completion: .+\n
-        RUBY_PLATFORM:\s.+\n
-        East\sAsian\sAmbiguous\sWidth:\s\d\n
-        #{@is_win ? 'Code\spage:\s\d+\n' : ''}
-      }x
-
-      assert_empty err
-      assert_match expected, out
-    ensure
-      ENV["INPUTRC"] = inputrc_backup
-      IRB.__send__(:remove_const, :IRBRC_EXT)
-      IRB.const_set(:IRBRC_EXT, ext_backup)
-    end
-
-    def test_irb_info_singleline_without_rc_files
-      inputrc_backup = ENV["INPUTRC"]
-      ENV["INPUTRC"] = "unknown_inpurc"
-      ext_backup = IRB::IRBRC_EXT
-      IRB.__send__(:remove_const, :IRBRC_EXT)
-      IRB.const_set(:IRBRC_EXT, "unknown_ext")
-
-      out, err = execute_lines(
-        "irb_info",
-        conf: { USE_MULTILINE: false, USE_SINGLELINE: true }
-      )
-
-      expected = %r{
-        Ruby\sversion:\s.+\n
-        IRB\sversion:\sirb\s.+\n
-        InputMethod:\sAbstract\sInputMethod\n
-        Completion: .+\n
-        RUBY_PLATFORM:\s.+\n
-        East\sAsian\sAmbiguous\sWidth:\s\d\n
-        #{@is_win ? 'Code\spage:\s\d+\n' : ''}
-      }x
-
-      assert_empty err
-      assert_match expected, out
-    ensure
-      ENV["INPUTRC"] = inputrc_backup
-      IRB.__send__(:remove_const, :IRBRC_EXT)
-      IRB.const_set(:IRBRC_EXT, ext_backup)
-    end
-
-    def test_irb_info_lang
-      FileUtils.touch("#{@tmpdir}/.inputrc")
-      FileUtils.touch("#{@tmpdir}/.irbrc")
-      ENV["LANG"] = "ja_JP.UTF-8"
-      ENV["LC_ALL"] = "en_US.UTF-8"
-
-      out, err = execute_lines(
-        "irb_info",
-        conf: { USE_MULTILINE: true, USE_SINGLELINE: false }
-      )
-
-      expected = %r{
-        Ruby\sversion: .+\n
-        IRB\sversion:\sirb .+\n
-        InputMethod:\sAbstract\sInputMethod\n
-        Completion: .+\n
-        \.irbrc\spaths: .+\n
-        RUBY_PLATFORM: .+\n
-        LANG\senv:\sja_JP\.UTF-8\n
-        LC_ALL\senv:\sen_US\.UTF-8\n
-        East\sAsian\sAmbiguous\sWidth:\s\d\n
-      }x
-
-      assert_empty err
-      assert_match expected, out
-    end
-  end
-
-  class MeasureTest < CommandTestCase
-    def test_measure
-      conf = {
-        PROMPT: {
-          DEFAULT: {
-            PROMPT_I: '> ',
-            PROMPT_S: '> ',
-            PROMPT_C: '> '
-          }
-        },
-        PROMPT_MODE: :DEFAULT,
-        MEASURE: false
-      }
-
-      c = Class.new(Object)
-      out, err = execute_lines(
-        "measure\n",
-        "3\n",
-        "measure :off\n",
-        "3\n",
-        "measure :on\n",
-        "3\n",
-        "measure :off\n",
-        "3\n",
-        conf: conf,
-        main: c
-      )
-
-      assert_empty err
-      assert_match(/\A(TIME is added\.\nprocessing time: .+\n=> 3\n=> 3\n){2}/, out)
-      assert_empty(c.class_variables)
-    end
-
-    def test_measure_keeps_previous_value
-      conf = {
-        PROMPT: {
-          DEFAULT: {
-            PROMPT_I: '> ',
-            PROMPT_S: '> ',
-            PROMPT_C: '> '
-          }
-        },
-        PROMPT_MODE: :DEFAULT,
-        MEASURE: false
-      }
-
-      c = Class.new(Object)
-      out, err = execute_lines(
-        "measure\n",
-        "3\n",
-        "_\n",
-        conf: conf,
-        main: c
-      )
-
-      assert_empty err
-      assert_match(/\ATIME is added\.\nprocessing time: .+\n=> 3\nprocessing time: .+\n=> 3/, out)
-      assert_empty(c.class_variables)
-    end
-
-    def test_measure_enabled_by_rc
-      conf = {
-        PROMPT: {
-          DEFAULT: {
-            PROMPT_I: '> ',
-            PROMPT_S: '> ',
-            PROMPT_C: '> '
-          }
-        },
-        PROMPT_MODE: :DEFAULT,
-        MEASURE: true
-      }
-
-      out, err = execute_lines(
-        "3\n",
-        "measure :off\n",
-        "3\n",
-        conf: conf,
-      )
-
-      assert_empty err
-      assert_match(/\Aprocessing time: .+\n=> 3\n=> 3\n/, out)
-    end
-
-    def test_measure_enabled_by_rc_with_custom
-      measuring_proc = proc { |line, line_no, &block|
-        time = Time.now
-        result = block.()
-        puts 'custom processing time: %fs' % (Time.now - time) if IRB.conf[:MEASURE]
-        result
-      }
-      conf = {
-        PROMPT: {
-          DEFAULT: {
-            PROMPT_I: '> ',
-            PROMPT_S: '> ',
-            PROMPT_C: '> '
-          }
-        },
-        PROMPT_MODE: :DEFAULT,
-        MEASURE: true,
-        MEASURE_PROC: { CUSTOM: measuring_proc }
-      }
-
-      out, err = execute_lines(
-        "3\n",
-        "measure :off\n",
-        "3\n",
-        conf: conf,
-      )
-      assert_empty err
-      assert_match(/\Acustom processing time: .+\n=> 3\n=> 3\n/, out)
-    end
-
-    def test_measure_with_custom
-      measuring_proc = proc { |line, line_no, &block|
-        time = Time.now
-        result = block.()
-        puts 'custom processing time: %fs' % (Time.now - time) if IRB.conf[:MEASURE]
-        result
-      }
-      conf = {
-        PROMPT: {
-          DEFAULT: {
-            PROMPT_I: '> ',
-            PROMPT_S: '> ',
-            PROMPT_C: '> '
-          }
-        },
-        PROMPT_MODE: :DEFAULT,
-        MEASURE: false,
-        MEASURE_PROC: { CUSTOM: measuring_proc }
-      }
-      out, err = execute_lines(
-        "3\n",
-        "measure\n",
-        "3\n",
-        "measure :off\n",
-        "3\n",
-        conf: conf
-      )
-
-      assert_empty err
-      assert_match(/\A=> 3\nCUSTOM is added\.\ncustom processing time: .+\n=> 3\n=> 3\n/, out)
-    end
-
-    def test_measure_toggle
-      conf = {
-        PROMPT: {
-          DEFAULT: {
-            PROMPT_I: '> ',
-            PROMPT_S: '> ',
-            PROMPT_C: '> '
-          }
-        },
-        PROMPT_MODE: :DEFAULT,
-        MEASURE: false,
-        MEASURE_PROC: {
-          FOO: proc { |&block| puts 'foo'; block.call },
-          BAR: proc { |&block| puts 'bar'; block.call }
-        }
-      }
-      out, err = execute_lines(
-        "measure :foo\n",
-        "1\n",
-        "measure :on, :bar\n",
-        "2\n",
-        "measure :off, :foo\n",
-        "3\n",
-        "measure :off, :bar\n",
-        "4\n",
-        conf: conf
-      )
-
-      assert_empty err
-      assert_match(/\AFOO is added\.\nfoo\n=> 1\nBAR is added\.\nbar\nfoo\n=> 2\nbar\n=> 3\n=> 4\n/, out)
-    end
-
-    def test_measure_with_proc_warning
-      conf = {
-        PROMPT: {
-          DEFAULT: {
-            PROMPT_I: '> ',
-            PROMPT_S: '> ',
-            PROMPT_C: '> '
-          }
-        },
-        PROMPT_MODE: :DEFAULT,
-        MEASURE: false,
-      }
-      c = Class.new(Object)
-      out, err = execute_lines(
-        "3\n",
-        "measure do\n",
-        "3\n",
-        conf: conf,
-        main: c
-      )
-
-      assert_match(/to add custom measure/, err)
-      assert_match(/\A=> 3\n=> 3\n/, out)
-      assert_empty(c.class_variables)
-    end
-  end
-
-  class IrbSourceTest < CommandTestCase
-    def test_irb_source
-      File.write("#{@tmpdir}/a.rb", "a = 'hi'\n")
-      out, err = execute_lines(
-        "a = 'bug17564'\n",
-        "a\n",
-        "irb_source '#{@tmpdir}/a.rb'\n",
-        "a\n",
-      )
-      assert_empty err
-      assert_pattern_list([
-        /=> "bug17564"\n/,
-        /=> "bug17564"\n/,
-        /   => "hi"\n/,
-        /   => "hi"\n/,
-      ], out)
-    end
-
-    def test_irb_source_without_argument
-      out, err = execute_lines(
-        "irb_source\n",
-      )
-      assert_empty err
-      assert_match(/Please specify the file name./, out)
-    end
-  end
-
-  class IrbLoadTest < CommandTestCase
-    def test_irb_load
-      File.write("#{@tmpdir}/a.rb", "a = 'hi'\n")
-      out, err = execute_lines(
-        "a = 'bug17564'\n",
-        "a\n",
-        "irb_load '#{@tmpdir}/a.rb'\n",
-        "a\n",
-      )
-      assert_empty err
-      assert_pattern_list([
-          /=> "bug17564"\n/,
-          /=> "bug17564"\n/,
-          /   => "hi"\n/,
-          /   => "bug17564"\n/,
-        ], out)
-    end
-
-    def test_irb_load_without_argument
-      out, err = execute_lines(
-        "irb_load\n",
-      )
-
-      assert_empty err
-      assert_match(/Please specify the file name./, out)
-    end
-  end
-
-  class WorkspaceCommandTestCase < CommandTestCase
-    def setup
-      super
-      # create Foo under the test class's namespace so it doesn't pollute global namespace
-      self.class.class_eval <<~RUBY
-        class Foo; end
-      RUBY
-    end
-  end
-
-  class CwwsTest < WorkspaceCommandTestCase
-    def test_cwws_returns_the_current_workspace_object
-      out, err = execute_lines(
-        "cwws"
-      )
-
-      assert_empty err
-      assert_include(out, "Current workspace: #{self}")
-    end
-  end
-
-  class PushwsTest < WorkspaceCommandTestCase
-    def test_pushws_switches_to_new_workspace_and_pushes_the_current_one_to_the_stack
-      out, err = execute_lines(
-        "pushws #{self.class}::Foo.new",
-        "self.class",
-        "popws",
-        "self.class"
-      )
-      assert_empty err
-
-      assert_match(/=> #{self.class}::Foo\n/, out)
-      assert_match(/=> #{self.class}\n$/, out)
-    end
-
-    def test_pushws_extends_the_new_workspace_with_command_bundle
-      out, err = execute_lines(
-        "pushws Object.new",
-        "self.singleton_class.ancestors"
-      )
-      assert_empty err
-      assert_include(out, "IRB::ExtendCommandBundle")
-    end
-
-    def test_pushws_prints_workspace_stack_when_no_arg_is_given
-      out, err = execute_lines(
-        "pushws",
-      )
-      assert_empty err
-      assert_include(out, "[#<TestIRB::PushwsTe...>]")
-    end
-
-    def test_pushws_without_argument_swaps_the_top_two_workspaces
-      out, err = execute_lines(
-        "pushws #{self.class}::Foo.new",
-        "self.class",
-        "pushws",
-        "self.class"
-      )
-      assert_empty err
-      assert_match(/=> #{self.class}::Foo\n/, out)
-      assert_match(/=> #{self.class}\n$/, out)
-    end
-  end
-
-  class WorkspacesTest < WorkspaceCommandTestCase
-    def test_workspaces_returns_the_stack_of_workspaces
-      out, err = execute_lines(
-        "pushws #{self.class}::Foo.new\n",
-        "workspaces",
-      )
-
-      assert_empty err
-      assert_match(/\[#<TestIRB::Workspac...>, #<TestIRB::Workspac...>\]\n/, out)
-    end
-  end
-
-  class PopwsTest < WorkspaceCommandTestCase
-    def test_popws_replaces_the_current_workspace_with_the_previous_one
-      out, err = execute_lines(
-        "pushws Foo.new\n",
-        "popws\n",
-        "cwws\n",
-        "self.class",
-      )
-      assert_empty err
-      assert_include(out, "=> #{self.class}")
-    end
-
-    def test_popws_prints_help_message_if_the_workspace_is_empty
-      out, err = execute_lines(
-        "popws\n",
-      )
-      assert_empty err
-      assert_match(/\[#<TestIRB::PopwsTes...>\]\n/, out)
-    end
-  end
-
-  class ChwsTest < WorkspaceCommandTestCase
-    def test_chws_replaces_the_current_workspace
-      out, err = execute_lines(
-        "chws #{self.class}::Foo.new\n",
-        "cwws\n",
-        "self.class\n"
-      )
-      assert_empty err
-      assert_include(out, "Current workspace: #<#{self.class.name}::Foo")
-      assert_include(out, "=> #{self.class}::Foo")
-    end
-
-    def test_chws_does_nothing_when_receiving_no_argument
-      out, err = execute_lines(
-        "chws\n",
-      )
-      assert_empty err
-      assert_include(out, "Current workspace: #{self}")
-    end
-  end
-
-  class WhereamiTest < CommandTestCase
-    def test_whereami
-      out, err = execute_lines(
-        "whereami\n",
-      )
-      assert_empty err
-      assert_match(/^From: .+ @ line \d+ :\n/, out)
-    end
-
-    def test_whereami_alias
-      out, err = execute_lines(
-        "@\n",
-      )
-      assert_empty err
-      assert_match(/^From: .+ @ line \d+ :\n/, out)
-    end
-  end
-
-  class LsTest < CommandTestCase
-    def test_ls
-      out, err = execute_lines(
-        "class P\n",
-        "  def m() end\n",
-        "  def m2() end\n",
-        "end\n",
-
-        "class C < P\n",
-        "  def m1() end\n",
-        "  def m2() end\n",
-        "end\n",
-
-        "module M\n",
-        "  def m1() end\n",
-        "  def m3() end\n",
-        "end\n",
-
-        "module M2\n",
-        "  include M\n",
-        "  def m4() end\n",
-        "end\n",
-
-        "obj = C.new\n",
-        "obj.instance_variable_set(:@a, 1)\n",
-        "obj.extend M2\n",
-        "def obj.m5() end\n",
-        "ls obj\n",
-      )
-
-      assert_empty err
-      assert_match(/^instance variables:\s+@a\n/m, out)
-      assert_match(/P#methods:\s+m\n/m, out)
-      assert_match(/C#methods:\s+m2\n/m, out)
-      assert_match(/M#methods:\s+m1\s+m3\n/m, out)
-      assert_match(/M2#methods:\s+m4\n/m, out)
-      assert_match(/C.methods:\s+m5\n/m, out)
-    end
-
-    def test_ls_class
-      out, err = execute_lines(
-        "module M1\n",
-        "  def m2; end\n",
-        "  def m3; end\n",
-        "end\n",
-
-        "class C1\n",
-        "  def m1; end\n",
-        "  def m2; end\n",
-        "end\n",
-
-        "class C2 < C1\n",
-        "  include M1\n",
-        "  def m3; end\n",
-        "  def m4; end\n",
-        "  def self.m3; end\n",
-        "  def self.m5; end\n",
-        "end\n",
-        "ls C2"
-      )
-
-      assert_empty err
-      assert_match(/C2.methods:\s+m3\s+m5\n/, out)
-      assert_match(/C2#methods:\s+m3\s+m4\n.*M1#methods:\s+m2\n.*C1#methods:\s+m1\n/, out)
-      assert_not_match(/Module#methods/, out)
-      assert_not_match(/Class#methods/, out)
-    end
-
-    def test_ls_module
-      out, err = execute_lines(
-        "module M1\n",
-        "  def m1; end\n",
-        "  def m2; end\n",
-        "end\n",
-
-        "module M2\n",
-        "  include M1\n",
-        "  def m1; end\n",
-        "  def m3; end\n",
-        "  def self.m4; end\n",
-        "end\n",
-        "ls M2"
-      )
-
-      assert_empty err
-      assert_match(/M2\.methods:\s+m4\n/, out)
-      assert_match(/M2#methods:\s+m1\s+m3\n.*M1#methods:\s+m2\n/, out)
-      assert_not_match(/Module#methods/, out)
-    end
-
-    def test_ls_instance
-      out, err = execute_lines(
-        "class Foo; def bar; end; end\n",
-        "ls Foo.new"
-      )
-
-      assert_empty err
-      assert_match(/Foo#methods:\s+bar/, out)
-      # don't duplicate
-      assert_not_match(/Foo#methods:\s+bar\n.*Foo#methods/, out)
-    end
-
-    def test_ls_grep
-      out, err = execute_lines("ls 42\n")
-      assert_empty err
-      assert_match(/times/, out)
-      assert_match(/polar/, out)
-
-      [
-        "ls 42, grep: /times/\n",
-        "ls 42 -g times\n",
-        "ls 42 -G times\n",
-      ].each do |line|
-        out, err = execute_lines(line)
-        assert_empty err
-        assert_match(/times/, out)
-        assert_not_match(/polar/, out)
-      end
-    end
-
-    def test_ls_grep_empty
-      out, err = execute_lines("ls\n")
-      assert_empty err
-      assert_match(/assert/, out)
-      assert_match(/refute/, out)
-
-      [
-        "ls grep: /assert/\n",
-        "ls -g assert\n",
-        "ls -G assert\n",
-      ].each do |line|
-        out, err = execute_lines(line)
-        assert_empty err
-        assert_match(/assert/, out)
-        assert_not_match(/refute/, out)
-      end
-    end
-
-    def test_ls_with_eval_error
-      [
-        "ls raise(Exception,'foo')\n",
-        "ls raise(Exception,'foo'), grep: /./\n",
-        "ls Integer, grep: raise(Exception,'foo')\n",
-      ].each do |line|
-        out, err = execute_lines(line)
-        assert_empty err
-        assert_match(/Exception: foo/, out)
-        assert_not_match(/Maybe IRB bug!/, out)
-      end
-    end
-
-    def test_ls_with_no_singleton_class
-      out, err = execute_lines(
-        "ls 42",
-      )
-      assert_empty err
-      assert_match(/Comparable#methods:\s+/, out)
-      assert_match(/Numeric#methods:\s+/, out)
-      assert_match(/Integer#methods:\s+/, out)
-    end
-  end
-
-  class ShowDocTest < CommandTestCase
-    def test_show_doc
-      out, err = execute_lines("show_doc String#gsub")
-
-      # the former is what we'd get without document content installed, like on CI
-      # the latter is what we may get locally
-      possible_rdoc_output = [/Nothing known about String#gsub/, /gsub$pattern$/]
-      assert_not_include err, "[Deprecation]"
-      assert(possible_rdoc_output.any? { |output| output.match?(out) }, "Expect the `show_doc` command to match one of the possible outputs. Got:\n#{out}")
-    ensure
-      # this is the only way to reset the redefined method without coupling the test with its implementation
-      EnvUtil.suppress_warning { load "irb/command/help.rb" }
-    end if defined?(RDoc)
-
-    def test_show_doc_without_rdoc
-      _, err = without_rdoc do
-        execute_lines("show_doc String#gsub")
-      end
-
-      assert_include(err, "Can't display document because `rdoc` is not installed.\n")
-    ensure
-      # this is the only way to reset the redefined method without coupling the test with its implementation
-      EnvUtil.suppress_warning { load "irb/command/help.rb" }
-    end
-  end
-
-  class EditTest < CommandTestCase
-    def setup
-      @original_visual = ENV["VISUAL"]
-      @original_editor = ENV["EDITOR"]
-      # noop the command so nothing gets executed
-      ENV["VISUAL"] = ": code"
-      ENV["EDITOR"] = ": code2"
-    end
-
-    def teardown
-      ENV["VISUAL"] = @original_visual
-      ENV["EDITOR"] = @original_editor
-    end
-
-    def test_edit_without_arg
-      out, err = execute_lines(
-        "edit",
-        irb_path: __FILE__
-      )
-
-      assert_empty err
-      assert_match("path: #{__FILE__}", out)
-      assert_match("command: ': code'", out)
-    end
-
-    def test_edit_without_arg_and_non_existing_irb_path
-      out, err = execute_lines(
-        "edit",
-        irb_path: '/path/to/file.rb(irb)'
-      )
-
-      assert_empty err
-      assert_match(/Can not find file: \/path\/to\/file\.rb$irb$/, out)
-    end
-
-    def test_edit_with_path
-      out, err = execute_lines(
-        "edit #{__FILE__}"
-      )
-
-      assert_empty err
-      assert_match("path: #{__FILE__}", out)
-      assert_match("command: ': code'", out)
-    end
-
-    def test_edit_with_non_existing_path
-      out, err = execute_lines(
-        "edit test_cmd_non_existing_path.rb"
-      )
-
-      assert_empty err
-      assert_match(/Can not find file: test_cmd_non_existing_path\.rb/, out)
-    end
-
-    def test_edit_with_constant
-      out, err = execute_lines(
-        "edit IRB::Irb"
-      )
-
-      assert_empty err
-      assert_match(/path: .*\/lib\/irb\.rb/, out)
-      assert_match("command: ': code'", out)
-    end
-
-    def test_edit_with_class_method
-      out, err = execute_lines(
-        "edit IRB.start"
-      )
-
-      assert_empty err
-      assert_match(/path: .*\/lib\/irb\.rb/, out)
-      assert_match("command: ': code'", out)
-    end
-
-    def test_edit_with_instance_method
-      out, err = execute_lines(
-        "edit IRB::Irb#run"
-      )
-
-      assert_empty err
-      assert_match(/path: .*\/lib\/irb\.rb/, out)
-      assert_match("command: ': code'", out)
-    end
-
-    def test_edit_with_editor_env_var
-      ENV.delete("VISUAL")
-
-      out, err = execute_lines(
-        "edit",
-        irb_path: __FILE__
-      )
-
-      assert_empty err
-      assert_match("path: #{__FILE__}", out)
-      assert_match("command: ': code2'", out)
-    end
-  end
-
-  class HistoryCmdTest < CommandTestCase
-    def teardown
-      TestInputMethod.send(:remove_const, "HISTORY") if defined?(TestInputMethod::HISTORY)
-      super
-    end
-
-    def test_history
-      TestInputMethod.const_set("HISTORY", %w[foo bar baz])
-
-      out, err = without_rdoc do
-        execute_lines("history")
-      end
-
-      assert_include(out, <<~EOF)
-        2: baz
-        1: bar
-        0: foo
-      EOF
-      assert_empty err
-    end
-
-    def test_multiline_history_with_truncation
-      TestInputMethod.const_set("HISTORY", ["foo", "bar", <<~INPUT])
-        [].each do |x|
-          puts x
-        end
-      INPUT
-
-      out, err = without_rdoc do
-        execute_lines("hist")
-      end
-
-      assert_include(out, <<~EOF)
-        2: [].each do |x|
-             puts x
-           ...
-        1: bar
-        0: foo
-      EOF
-      assert_empty err
-    end
-
-    def test_history_grep
-      TestInputMethod.const_set("HISTORY", ["foo", "bar", <<~INPUT])
-        [].each do |x|
-          puts x
-        end
-      INPUT
-
-      out, err = without_rdoc do
-        execute_lines("hist -g each\n")
-      end
-
-      assert_include(out, <<~EOF)
-        2: [].each do |x|
-             puts x
-           ...
-      EOF
-      assert_empty err
-    end
-
-  end
-
-  class HelperMethodInsallTest < CommandTestCase
-    def test_helper_method_install
-      IRB::ExtendCommandBundle.module_eval do
-        def foobar
-          "test_helper_method_foobar"
-        end
-      end
-
-      out, err = execute_lines("foobar.upcase")
-      assert_empty err
-      assert_include(out, '=> "TEST_HELPER_METHOD_FOOBAR"')
-    ensure
-      IRB::ExtendCommandBundle.remove_method :foobar
-    end
-  end
-end
diff --git a/test/mri/irb/test_completion.rb b/test/mri/irb/test_completion.rb
deleted file mode 100644
index c9a0eafa3d4..00000000000
--- a/test/mri/irb/test_completion.rb
+++ /dev/null
@@ -1,317 +0,0 @@
-# frozen_string_literal: false
-require "pathname"
-require "irb"
-
-require_relative "helper"
-
-module TestIRB
-  class CompletionTest < TestCase
-    def completion_candidates(target, bind)
-      IRB::RegexpCompletor.new.completion_candidates('', target, '', bind: bind)
-    end
-
-    def doc_namespace(target, bind)
-      IRB::RegexpCompletor.new.doc_namespace('', target, '', bind: bind)
-    end
-
-    class CommandCompletionTest < CompletionTest
-      def test_command_completion
-        completor = IRB::RegexpCompletor.new
-        binding.eval("some_var = 1")
-        # completion for help command's argument should only include command names
-        assert_include(completor.completion_candidates('help ', 's', '', bind: binding), 'show_source')
-        assert_not_include(completor.completion_candidates('help ', 's', '', bind: binding), 'some_var')
-
-        assert_include(completor.completion_candidates('', 'show_s', '', bind: binding), 'show_source')
-        assert_not_include(completor.completion_candidates(';', 'show_s', '', bind: binding), 'show_source')
-      end
-    end
-
-    class MethodCompletionTest < CompletionTest
-      def test_complete_string
-        assert_include(completion_candidates("'foo'.up", binding), "'foo'.upcase")
-        # completing 'foo bar'.up
-        assert_include(completion_candidates("bar'.up", binding), "bar'.upcase")
-        assert_equal("String.upcase", doc_namespace("'foo'.upcase", binding))
-      end
-
-      def test_complete_regexp
-        assert_include(completion_candidates("/foo/.ma", binding), "/foo/.match")
-        # completing /foo bar/.ma
-        assert_include(completion_candidates("bar/.ma", binding), "bar/.match")
-        assert_equal("Regexp.match", doc_namespace("/foo/.match", binding))
-      end
-
-      def test_complete_array
-        assert_include(completion_candidates("[].an", binding), "[].any?")
-        assert_equal("Array.any?", doc_namespace("[].any?", binding))
-      end
-
-      def test_complete_hash_and_proc
-        # hash
-        assert_include(completion_candidates("{}.an", binding), "{}.any?")
-        assert_equal(["Hash.any?", "Proc.any?"], doc_namespace("{}.any?", binding))
-
-        # proc
-        assert_include(completion_candidates("{}.bin", binding), "{}.binding")
-        assert_equal(["Hash.binding", "Proc.binding"], doc_namespace("{}.binding", binding))
-      end
-
-      def test_complete_numeric
-        assert_include(completion_candidates("1.positi", binding), "1.positive?")
-        assert_equal("Integer.positive?", doc_namespace("1.positive?", binding))
-
-        assert_include(completion_candidates("1r.positi", binding), "1r.positive?")
-        assert_equal("Rational.positive?", doc_namespace("1r.positive?", binding))
-
-        assert_include(completion_candidates("0xFFFF.positi", binding), "0xFFFF.positive?")
-        assert_equal("Integer.positive?", doc_namespace("0xFFFF.positive?", binding))
-
-        assert_empty(completion_candidates("1i.positi", binding))
-      end
-
-      def test_complete_symbol
-        assert_include(completion_candidates(":foo.to_p", binding), ":foo.to_proc")
-        assert_equal("Symbol.to_proc", doc_namespace(":foo.to_proc", binding))
-      end
-
-      def test_complete_class
-        assert_include(completion_candidates("String.ne", binding), "String.new")
-        assert_equal("String.new", doc_namespace("String.new", binding))
-      end
-    end
-
-    class RequireComepletionTest < CompletionTest
-      def test_complete_require
-        candidates = IRB::RegexpCompletor.new.completion_candidates("require ", "'irb", "", bind: binding)
-        %w['irb/init 'irb/ruby-lex].each do |word|
-          assert_include candidates, word
-        end
-        # Test cache
-        candidates = IRB::RegexpCompletor.new.completion_candidates("require ", "'irb", "", bind: binding)
-        %w['irb/init 'irb/ruby-lex].each do |word|
-          assert_include candidates, word
-        end
-        # Test string completion not disturbed by require completion
-        candidates = IRB::RegexpCompletor.new.completion_candidates("'string ", "'.", "", bind: binding)
-        assert_include candidates, "'.upcase"
-      end
-
-      def test_complete_require_with_pathname_in_load_path
-        temp_dir = Dir.mktmpdir
-        File.write(File.join(temp_dir, "foo.rb"), "test")
-        test_path = Pathname.new(temp_dir)
-        $LOAD_PATH << test_path
-
-        candidates = IRB::RegexpCompletor.new.completion_candidates("require ", "'foo", "", bind: binding)
-        assert_include candidates, "'foo"
-      ensure
-        $LOAD_PATH.pop if test_path
-        FileUtils.remove_entry(temp_dir) if temp_dir
-      end
-
-      def test_complete_require_with_string_convertable_in_load_path
-        temp_dir = Dir.mktmpdir
-        File.write(File.join(temp_dir, "foo.rb"), "test")
-        object = Object.new
-        object.define_singleton_method(:to_s) { temp_dir }
-        $LOAD_PATH << object
-
-        candidates = IRB::RegexpCompletor.new.completion_candidates("require ", "'foo", "", bind: binding)
-        assert_include candidates, "'foo"
-      ensure
-        $LOAD_PATH.pop if object
-        FileUtils.remove_entry(temp_dir) if temp_dir
-      end
-
-      def test_complete_require_with_malformed_object_in_load_path
-        object = Object.new
-        def object.to_s; raise; end
-        $LOAD_PATH << object
-
-        assert_nothing_raised do
-          IRB::RegexpCompletor.new.completion_candidates("require ", "'foo", "", bind: binding)
-        end
-      ensure
-        $LOAD_PATH.pop if object
-      end
-
-      def test_complete_require_library_name_first
-        # Test that library name is completed first with subdirectories
-        candidates = IRB::RegexpCompletor.new.completion_candidates("require ", "'irb", "", bind: binding)
-        assert_equal "'irb", candidates.first
-      end
-
-      def test_complete_require_relative
-        candidates = Dir.chdir(__dir__ + "/../..") do
-          IRB::RegexpCompletor.new.completion_candidates("require_relative ", "'lib/irb", "", bind: binding)
-        end
-        %w['lib/irb/init 'lib/irb/ruby-lex].each do |word|
-          assert_include candidates, word
-        end
-        # Test cache
-        candidates = Dir.chdir(__dir__ + "/../..") do
-          IRB::RegexpCompletor.new.completion_candidates("require_relative ", "'lib/irb", "", bind: binding)
-        end
-        %w['lib/irb/init 'lib/irb/ruby-lex].each do |word|
-          assert_include candidates, word
-        end
-      end
-    end
-
-    class VariableCompletionTest < CompletionTest
-      def test_complete_variable
-        # Bug fix issues https://github.com/ruby/irb/issues/368
-        # Variables other than `str_example` and `@str_example` are defined to ensure that irb completion does not cause unintended behavior
-        str_example = ''
-        @str_example = ''
-        private_methods = ''
-        methods = ''
-        global_variables = ''
-        local_variables = ''
-        instance_variables = ''
-
-        # suppress "assigned but unused variable" warning
-        str_example.clear
-        @str_example.clear
-        private_methods.clear
-        methods.clear
-        global_variables.clear
-        local_variables.clear
-        instance_variables.clear
-
-        assert_include(completion_candidates("str_examp", binding), "str_example")
-        assert_equal("String", doc_namespace("str_example", binding))
-        assert_equal("String.to_s", doc_namespace("str_example.to_s", binding))
-
-        assert_include(completion_candidates("@str_examp", binding), "@str_example")
-        assert_equal("String", doc_namespace("@str_example", binding))
-        assert_equal("String.to_s", doc_namespace("@str_example.to_s", binding))
-      end
-
-      def test_complete_sort_variables
-        xzy, xzy_1, xzy2 = '', '', ''
-
-        xzy.clear
-        xzy_1.clear
-        xzy2.clear
-
-        candidates = completion_candidates("xz", binding)
-        assert_equal(%w[xzy xzy2 xzy_1], candidates)
-      end
-    end
-
-    class ConstantCompletionTest < CompletionTest
-      class Foo
-        B3 = 1
-        B1 = 1
-        B2 = 1
-      end
-
-      def test_complete_constants
-        assert_equal(["Foo"], completion_candidates("Fo", binding))
-        assert_equal(["Foo::B1", "Foo::B2", "Foo::B3"], completion_candidates("Foo::B", binding))
-        assert_equal(["Foo::B1.positive?"], completion_candidates("Foo::B1.pos", binding))
-
-        assert_equal(["::Forwardable"], completion_candidates("::Fo", binding))
-        assert_equal("Forwardable", doc_namespace("::Forwardable", binding))
-      end
-    end
-
-    def test_not_completing_empty_string
-      assert_equal([], completion_candidates("", binding))
-      assert_equal([], completion_candidates(" ", binding))
-      assert_equal([], completion_candidates("\t", binding))
-      assert_equal(nil, doc_namespace("", binding))
-    end
-
-    def test_complete_symbol
-      symbols = %w"UTF-16LE UTF-7".map do |enc|
-        "K".force_encoding(enc).to_sym
-      rescue
-      end
-      symbols += [:aiueo, :"aiu eo"]
-      candidates = completion_candidates(":a", binding)
-      assert_include(candidates, ":aiueo")
-      assert_not_include(candidates, ":aiu eo")
-      assert_empty(completion_candidates(":irb_unknown_symbol_abcdefg", binding))
-      # Do not complete empty symbol for performance reason
-      assert_empty(completion_candidates(":", binding))
-    end
-
-    def test_complete_invalid_three_colons
-      assert_empty(completion_candidates(":::A", binding))
-      assert_empty(completion_candidates(":::", binding))
-    end
-
-    def test_complete_absolute_constants_with_special_characters
-      assert_empty(completion_candidates("::A:", binding))
-      assert_empty(completion_candidates("::A.", binding))
-      assert_empty(completion_candidates("::A(", binding))
-      assert_empty(completion_candidates("::A)", binding))
-      assert_empty(completion_candidates("::A[", binding))
-    end
-
-    def test_complete_reserved_words
-      candidates = completion_candidates("de", binding)
-      %w[def defined?].each do |word|
-        assert_include candidates, word
-      end
-
-      candidates = completion_candidates("__", binding)
-      %w[__ENCODING__ __LINE__ __FILE__].each do |word|
-        assert_include candidates, word
-      end
-    end
-
-    def test_complete_methods
-      obj = Object.new
-      obj.singleton_class.class_eval {
-        def public_hoge; end
-        private def private_hoge; end
-
-        # Support for overriding #methods etc.
-        def methods; end
-        def private_methods; end
-        def global_variables; end
-        def local_variables; end
-        def instance_variables; end
-      }
-      bind = obj.instance_exec { binding }
-
-      assert_include(completion_candidates("public_hog", bind), "public_hoge")
-      assert_include(doc_namespace("public_hoge", bind), "public_hoge")
-
-      assert_include(completion_candidates("private_hog", bind), "private_hoge")
-      assert_include(doc_namespace("private_hoge", bind), "private_hoge")
-    end
-  end
-
-  class DeprecatedInputCompletorTest < TestCase
-    def setup
-      save_encodings
-      @verbose, $VERBOSE = $VERBOSE, nil
-      IRB.init_config(nil)
-      IRB.conf[:VERBOSE] = false
-      IRB.conf[:MAIN_CONTEXT] = IRB::Context.new(IRB::WorkSpace.new(binding))
-    end
-
-    def teardown
-      restore_encodings
-      $VERBOSE = @verbose
-    end
-
-    def test_completion_proc
-      assert_include(IRB::InputCompletor::CompletionProc.call('1.ab'), '1.abs')
-      assert_include(IRB::InputCompletor::CompletionProc.call('1.ab', '', ''), '1.abs')
-    end
-
-    def test_retrieve_completion_data
-      assert_include(IRB::InputCompletor.retrieve_completion_data('1.ab'), '1.abs')
-      assert_equal(IRB::InputCompletor.retrieve_completion_data('1.abs', doc_namespace: true), 'Integer.abs')
-      bind = eval('a = 1; binding')
-      assert_include(IRB::InputCompletor.retrieve_completion_data('a.ab', bind: bind), 'a.abs')
-      assert_equal(IRB::InputCompletor.retrieve_completion_data('a.abs', bind: bind, doc_namespace: true), 'Integer.abs')
-    end
-  end
-end
diff --git a/test/mri/irb/test_context.rb b/test/mri/irb/test_context.rb
deleted file mode 100644
index b02d8dbe097..00000000000
--- a/test/mri/irb/test_context.rb
+++ /dev/null
@@ -1,737 +0,0 @@
-# frozen_string_literal: false
-require 'tempfile'
-require 'irb'
-
-require_relative "helper"
-
-module TestIRB
-  class ContextTest < TestCase
-    def setup
-      IRB.init_config(nil)
-      IRB.conf[:USE_SINGLELINE] = false
-      IRB.conf[:VERBOSE] = false
-      IRB.conf[:USE_PAGER] = false
-      workspace = IRB::WorkSpace.new(Object.new)
-      @context = IRB::Context.new(nil, workspace, TestInputMethod.new)
-
-      @get_screen_size = Reline.method(:get_screen_size)
-      Reline.instance_eval { undef :get_screen_size }
-      def Reline.get_screen_size
-        [36, 80]
-      end
-      save_encodings
-    end
-
-    def teardown
-      Reline.instance_eval { undef :get_screen_size }
-      Reline.define_singleton_method(:get_screen_size, @get_screen_size)
-      restore_encodings
-    end
-
-    def test_eval_input
-      verbose, $VERBOSE = $VERBOSE, nil
-      input = TestInputMethod.new([
-        "raise 'Foo'\n",
-        "_\n",
-        "0\n",
-        "_\n",
-      ])
-      irb = IRB::Irb.new(IRB::WorkSpace.new(Object.new), input)
-      out, err = capture_output do
-        irb.eval_input
-      end
-      assert_empty err
-
-      expected_output =
-        if RUBY_3_4
-          [
-            :*, /$irb$:1:in '<main>': Foo $RuntimeError$\n/,
-            :*, /#<RuntimeError: Foo>\n/,
-            :*, /0$/,
-            :*, /0$/,
-            /\s*/
-          ]
-        else
-          [
-            :*, /$irb$:1:in `<main>': Foo $RuntimeError$\n/,
-            :*, /#<RuntimeError: Foo>\n/,
-            :*, /0$/,
-            :*, /0$/,
-            /\s*/
-          ]
-        end
-
-      assert_pattern_list(expected_output, out)
-    ensure
-      $VERBOSE = verbose
-    end
-
-    def test_eval_input_raise2x
-      input = TestInputMethod.new([
-        "raise 'Foo'\n",
-        "raise 'Bar'\n",
-        "_\n",
-      ])
-      irb = IRB::Irb.new(IRB::WorkSpace.new(Object.new), input)
-      out, err = capture_output do
-        irb.eval_input
-      end
-      assert_empty err
-      expected_output =
-        if RUBY_3_4
-          [
-            :*, /$irb$:1:in '<main>': Foo $RuntimeError$\n/,
-            :*, /$irb$:2:in '<main>': Bar $RuntimeError$\n/,
-            :*, /#<RuntimeError: Bar>\n/,
-          ]
-        else
-          [
-            :*, /$irb$:1:in `<main>': Foo $RuntimeError$\n/,
-            :*, /$irb$:2:in `<main>': Bar $RuntimeError$\n/,
-            :*, /#<RuntimeError: Bar>\n/,
-          ]
-        end
-      assert_pattern_list(expected_output, out)
-    end
-
-    def test_prompt_n_deprecation
-      irb = IRB::Irb.new(IRB::WorkSpace.new(Object.new), TestInputMethod.new)
-
-      _, err = capture_output do
-        irb.context.prompt_n = "foo"
-        irb.context.prompt_n
-      end
-
-      assert_include err, "IRB::Context#prompt_n is deprecated"
-      assert_include err, "IRB::Context#prompt_n= is deprecated"
-    end
-
-    def test_output_to_pipe
-      require 'stringio'
-      input = TestInputMethod.new(["n=1"])
-      input.instance_variable_set(:@stdout, StringIO.new)
-      irb = IRB::Irb.new(IRB::WorkSpace.new(Object.new), input)
-      irb.context.echo_on_assignment = :truncate
-      irb.context.prompt_mode = :DEFAULT
-      out, err = capture_output do
-        irb.eval_input
-      end
-      assert_empty err
-      assert_equal "=> 1\n", out
-    end
-
-    {
-      successful: [
-        [false, "class Foo < Struct.new(:bar); end; Foo.new(123)\n", /#<struct bar=123>/],
-        [:p, "class Foo < Struct.new(:bar); end; Foo.new(123)\n", /#<struct bar=123>/],
-        [true, "class Foo < Struct.new(:bar); end; Foo.new(123)\n", /#<struct #<Class:.*>::Foo bar=123>/],
-        [:yaml, "123", /--- 123\n/],
-        [:marshal, "123", Marshal.dump(123)],
-      ],
-      failed: [
-        [false, "BasicObject.new", /#<NoMethodError: undefined method (`|')to_s' for/],
-        [:p, "class Foo; undef inspect ;end; Foo.new", /#<NoMethodError: undefined method (`|')inspect' for/],
-        [:yaml, "BasicObject.new", /#<NoMethodError: undefined method (`|')inspect' for/],
-        [:marshal, "[Object.new, Class.new]", /#<TypeError: can't dump anonymous class #<Class:/]
-      ]
-    }.each do |scenario, cases|
-      cases.each do |inspect_mode, input, expected|
-        define_method "test_#{inspect_mode}_inspect_mode_#{scenario}" do
-          verbose, $VERBOSE = $VERBOSE, nil
-          irb = IRB::Irb.new(IRB::WorkSpace.new(Object.new), TestInputMethod.new([input]))
-          irb.context.inspect_mode = inspect_mode
-          out, err = capture_output do
-            irb.eval_input
-          end
-          assert_empty err
-          assert_match(expected, out)
-        ensure
-          $VERBOSE = verbose
-        end
-      end
-    end
-
-    def test_object_inspection_handles_basic_object
-      verbose, $VERBOSE = $VERBOSE, nil
-      irb = IRB::Irb.new(IRB::WorkSpace.new(Object.new), TestInputMethod.new(["BasicObject.new"]))
-      out, err = capture_output do
-        irb.eval_input
-      end
-      assert_empty err
-      assert_not_match(/NoMethodError/, out)
-      assert_match(/#<BasicObject:.*>/, out)
-    ensure
-      $VERBOSE = verbose
-    end
-
-    def test_object_inspection_falls_back_to_kernel_inspect_when_errored
-      verbose, $VERBOSE = $VERBOSE, nil
-      main = Object.new
-      main.singleton_class.module_eval <<~RUBY
-        class Foo
-          def inspect
-            raise "foo"
-          end
-        end
-      RUBY
-
-      irb = IRB::Irb.new(IRB::WorkSpace.new(main), TestInputMethod.new(["Foo.new"]))
-      out, err = capture_output do
-        irb.eval_input
-      end
-      assert_empty err
-      assert_match(/An error occurred when inspecting the object: #<RuntimeError: foo>/, out)
-      assert_match(/Result of Kernel#inspect: #<#<Class:.*>::Foo:/, out)
-    ensure
-      $VERBOSE = verbose
-    end
-
-    def test_object_inspection_prints_useful_info_when_kernel_inspect_also_errored
-      verbose, $VERBOSE = $VERBOSE, nil
-      main = Object.new
-      main.singleton_class.module_eval <<~RUBY
-        class Foo
-          def initialize
-            # Kernel#inspect goes through instance variables with #inspect
-            # So this will cause Kernel#inspect to fail
-            @foo = BasicObject.new
-          end
-
-          def inspect
-            raise "foo"
-          end
-        end
-      RUBY
-
-      irb = IRB::Irb.new(IRB::WorkSpace.new(main), TestInputMethod.new(["Foo.new"]))
-      out, err = capture_output do
-        irb.eval_input
-      end
-      assert_empty err
-      assert_match(/An error occurred when inspecting the object: #<RuntimeError: foo>/, out)
-      assert_match(/An error occurred when running Kernel#inspect: #<NoMethodError: undefined method (`|')inspect' for/, out)
-    ensure
-      $VERBOSE = verbose
-    end
-
-    def test_default_config
-      assert_equal(true, @context.use_autocomplete?)
-    end
-
-    def test_echo_on_assignment
-      input = TestInputMethod.new([
-        "a = 1\n",
-        "a\n",
-        "a, b = 2, 3\n",
-        "a\n",
-        "b\n",
-        "b = 4\n",
-        "_\n"
-      ])
-      irb = IRB::Irb.new(IRB::WorkSpace.new(Object.new), input)
-      irb.context.return_format = "=> %s\n"
-
-      # The default
-      irb.context.echo = true
-      irb.context.echo_on_assignment = false
-      out, err = capture_output do
-        irb.eval_input
-      end
-      assert_empty err
-      assert_equal("=> 1\n=> 2\n=> 3\n=> 4\n", out)
-
-      # Everything is output, like before echo_on_assignment was introduced
-      input.reset
-      irb.context.echo = true
-      irb.context.echo_on_assignment = true
-      out, err = capture_output do
-        irb.eval_input
-      end
-      assert_empty err
-      assert_equal("=> 1\n=> 1\n=> [2, 3]\n=> 2\n=> 3\n=> 4\n=> 4\n", out)
-
-      # Nothing is output when echo is false
-      input.reset
-      irb.context.echo = false
-      irb.context.echo_on_assignment = false
-      out, err = capture_output do
-        irb.eval_input
-      end
-      assert_empty err
-      assert_equal("", out)
-
-      # Nothing is output when echo is false even if echo_on_assignment is true
-      input.reset
-      irb.context.echo = false
-      irb.context.echo_on_assignment = true
-      out, err = capture_output do
-        irb.eval_input
-      end
-      assert_empty err
-      assert_equal("", out)
-    end
-
-    def test_omit_on_assignment
-      input = TestInputMethod.new([
-        "a = [1] * 100\n",
-        "a\n",
-      ])
-      value = [1] * 100
-      irb = IRB::Irb.new(IRB::WorkSpace.new(Object.new), input)
-      irb.context.return_format = "=> %s\n"
-
-      irb.context.echo = true
-      irb.context.echo_on_assignment = false
-      out, err = capture_output do
-        irb.eval_input
-      end
-      assert_empty err
-      assert_equal("=> \n#{value.pretty_inspect}", out)
-
-      input.reset
-      irb.context.echo = true
-      irb.context.echo_on_assignment = :truncate
-      out, err = capture_output do
-        irb.eval_input
-      end
-      assert_empty err
-      assert_equal("=> \n#{value.pretty_inspect[0..3]}...\n=> \n#{value.pretty_inspect}", out)
-
-      input.reset
-      irb.context.echo = true
-      irb.context.echo_on_assignment = true
-      out, err = capture_output do
-        irb.eval_input
-      end
-      assert_empty err
-      assert_equal("=> \n#{value.pretty_inspect}=> \n#{value.pretty_inspect}", out)
-
-      input.reset
-      irb.context.echo = false
-      irb.context.echo_on_assignment = false
-      out, err = capture_output do
-        irb.eval_input
-      end
-      assert_empty err
-      assert_equal("", out)
-
-      input.reset
-      irb.context.echo = false
-      irb.context.echo_on_assignment = :truncate
-      out, err = capture_output do
-        irb.eval_input
-      end
-      assert_empty err
-      assert_equal("", out)
-
-      input.reset
-      irb.context.echo = false
-      irb.context.echo_on_assignment = true
-      out, err = capture_output do
-        irb.eval_input
-      end
-      assert_empty err
-      assert_equal("", out)
-    end
-
-    def test_omit_multiline_on_assignment
-      without_colorize do
-        input = TestInputMethod.new([
-          "class A; def inspect; ([?* * 1000] * 3).join(%{\\n}); end; end; a = A.new\n",
-          "a\n"
-        ])
-        value = ([?* * 1000] * 3).join(%{\n})
-        value_first_line = (?* * 1000).to_s
-        irb = IRB::Irb.new(IRB::WorkSpace.new(Object.new), input)
-        irb.context.return_format = "=> %s\n"
-
-        irb.context.echo = true
-        irb.context.echo_on_assignment = false
-        out, err = capture_output do
-          irb.eval_input
-        end
-        assert_empty err
-        assert_equal("=> \n#{value}\n", out)
-        irb.context.evaluate_expression('A.remove_method(:inspect)', 0)
-
-        input.reset
-        irb.context.echo = true
-        irb.context.echo_on_assignment = :truncate
-        out, err = capture_output do
-          irb.eval_input
-        end
-        assert_empty err
-        assert_equal("=> #{value_first_line[0..(input.winsize.last - 9)]}...\n=> \n#{value}\n", out)
-        irb.context.evaluate_expression('A.remove_method(:inspect)', 0)
-
-        input.reset
-        irb.context.echo = true
-        irb.context.echo_on_assignment = true
-        out, err = capture_output do
-          irb.eval_input
-        end
-        assert_empty err
-        assert_equal("=> \n#{value}\n=> \n#{value}\n", out)
-        irb.context.evaluate_expression('A.remove_method(:inspect)', 0)
-
-        input.reset
-        irb.context.echo = false
-        irb.context.echo_on_assignment = false
-        out, err = capture_output do
-          irb.eval_input
-        end
-        assert_empty err
-        assert_equal("", out)
-        irb.context.evaluate_expression('A.remove_method(:inspect)', 0)
-
-        input.reset
-        irb.context.echo = false
-        irb.context.echo_on_assignment = :truncate
-        out, err = capture_output do
-          irb.eval_input
-        end
-        assert_empty err
-        assert_equal("", out)
-        irb.context.evaluate_expression('A.remove_method(:inspect)', 0)
-
-        input.reset
-        irb.context.echo = false
-        irb.context.echo_on_assignment = true
-        out, err = capture_output do
-          irb.eval_input
-        end
-        assert_empty err
-        assert_equal("", out)
-        irb.context.evaluate_expression('A.remove_method(:inspect)', 0)
-      end
-    end
-
-    def test_echo_on_assignment_conf
-      # Default
-      IRB.conf[:ECHO] = nil
-      IRB.conf[:ECHO_ON_ASSIGNMENT] = nil
-      without_colorize do
-        input = TestInputMethod.new()
-        irb = IRB::Irb.new(IRB::WorkSpace.new(Object.new), input)
-
-        assert(irb.context.echo?, "echo? should be true by default")
-        assert_equal(:truncate, irb.context.echo_on_assignment?, "echo_on_assignment? should be :truncate by default")
-
-        # Explicitly set :ECHO to false
-        IRB.conf[:ECHO] = false
-        irb = IRB::Irb.new(IRB::WorkSpace.new(Object.new), input)
-
-        refute(irb.context.echo?, "echo? should be false when IRB.conf[:ECHO] is set to false")
-        assert_equal(:truncate, irb.context.echo_on_assignment?, "echo_on_assignment? should be :truncate by default")
-
-        # Explicitly set :ECHO_ON_ASSIGNMENT to true
-        IRB.conf[:ECHO] = nil
-        IRB.conf[:ECHO_ON_ASSIGNMENT] = false
-        irb = IRB::Irb.new(IRB::WorkSpace.new(Object.new), input)
-
-        assert(irb.context.echo?, "echo? should be true by default")
-        refute(irb.context.echo_on_assignment?, "echo_on_assignment? should be false when IRB.conf[:ECHO_ON_ASSIGNMENT] is set to false")
-      end
-    end
-
-    def test_multiline_output_on_default_inspector
-      main = Object.new
-      def main.inspect
-        "abc\ndef"
-      end
-
-      without_colorize do
-        input = TestInputMethod.new([
-          "self"
-        ])
-        irb = IRB::Irb.new(IRB::WorkSpace.new(main), input)
-        irb.context.return_format = "=> %s\n"
-
-        # The default
-        irb.context.newline_before_multiline_output = true
-        out, err = capture_output do
-          irb.eval_input
-        end
-        assert_empty err
-        assert_equal("=> \nabc\ndef\n",
-                     out)
-
-        # No newline before multiline output
-        input.reset
-        irb.context.newline_before_multiline_output = false
-        out, err = capture_output do
-          irb.eval_input
-        end
-        assert_empty err
-        assert_equal("=> abc\ndef\n", out)
-      end
-    end
-
-    def test_default_return_format
-      IRB.conf[:PROMPT][:MY_PROMPT] = {
-        :PROMPT_I => "%03n> ",
-        :PROMPT_S => "%03n> ",
-        :PROMPT_C => "%03n> "
-        # without :RETURN
-        # :RETURN => "%s\n"
-      }
-      IRB.conf[:PROMPT_MODE] = :MY_PROMPT
-      input = TestInputMethod.new([
-        "3"
-      ])
-      irb = IRB::Irb.new(IRB::WorkSpace.new(Object.new), input)
-      out, err = capture_output do
-        irb.eval_input
-      end
-      assert_empty err
-      assert_equal("3\n",
-                   out)
-    end
-
-    def test_eval_input_with_exception
-      pend if RUBY_ENGINE == 'truffleruby'
-      verbose, $VERBOSE = $VERBOSE, nil
-      input = TestInputMethod.new([
-        "def hoge() fuga; end; def fuga() raise; end; hoge\n",
-      ])
-      irb = IRB::Irb.new(IRB::WorkSpace.new(Object.new), input)
-      out, err = capture_output do
-        irb.eval_input
-      end
-      assert_empty err
-      expected_output =
-        if RUBY_3_4
-          [
-            :*, /$irb$:1:in 'fuga': unhandled exception\n/,
-            :*, /\tfrom $irb$:1:in 'hoge'\n/,
-            :*, /\tfrom $irb$:1:in '<main>'\n/,
-            :*
-          ]
-        elsif RUBY_VERSION < '3.0.0' && STDOUT.tty?
-          [
-            :*, /Traceback $most recent call last$:\n/,
-            :*, /\t 2: from $irb$:1:in `<main>'\n/,
-            :*, /\t 1: from $irb$:1:in `hoge'\n/,
-            :*, /$irb$:1:in `fuga': unhandled exception\n/,
-          ]
-        else
-          [
-            :*, /$irb$:1:in `fuga': unhandled exception\n/,
-            :*, /\tfrom $irb$:1:in `hoge'\n/,
-            :*, /\tfrom $irb$:1:in `<main>'\n/,
-            :*
-          ]
-        end
-      assert_pattern_list(expected_output, out)
-    ensure
-      $VERBOSE = verbose
-    end
-
-    def test_eval_input_with_invalid_byte_sequence_exception
-      verbose, $VERBOSE = $VERBOSE, nil
-      input = TestInputMethod.new([
-        %Q{def hoge() fuga; end; def fuga() raise "A\\xF3B"; end; hoge\n},
-      ])
-      irb = IRB::Irb.new(IRB::WorkSpace.new(Object.new), input)
-      out, err = capture_output do
-        irb.eval_input
-      end
-      assert_empty err
-      expected_output =
-        if RUBY_3_4
-          [
-            :*, /$irb$:1:in 'fuga': A\\xF3B $RuntimeError$\n/,
-            :*, /\tfrom $irb$:1:in 'hoge'\n/,
-            :*, /\tfrom $irb$:1:in '<main>'\n/,
-            :*
-          ]
-        elsif RUBY_VERSION < '3.0.0' && STDOUT.tty?
-          [
-            :*, /Traceback $most recent call last$:\n/,
-            :*, /\t 2: from $irb$:1:in `<main>'\n/,
-            :*, /\t 1: from $irb$:1:in `hoge'\n/,
-            :*, /$irb$:1:in `fuga': A\\xF3B $RuntimeError$\n/,
-          ]
-        else
-          [
-            :*, /$irb$:1:in `fuga': A\\xF3B $RuntimeError$\n/,
-            :*, /\tfrom $irb$:1:in `hoge'\n/,
-            :*, /\tfrom $irb$:1:in `<main>'\n/,
-            :*
-          ]
-        end
-
-      assert_pattern_list(expected_output, out)
-    ensure
-      $VERBOSE = verbose
-    end
-
-    def test_eval_input_with_long_exception
-      pend if RUBY_ENGINE == 'truffleruby'
-      verbose, $VERBOSE = $VERBOSE, nil
-      nesting = 20
-      generated_code = ''
-      nesting.times do |i|
-        generated_code << "def a#{i}() a#{i + 1}; end; "
-      end
-      generated_code << "def a#{nesting}() raise; end; a0\n"
-      input = TestInputMethod.new([
-        generated_code
-      ])
-      irb = IRB::Irb.new(IRB::WorkSpace.new(Object.new), input)
-      out, err = capture_output do
-        irb.eval_input
-      end
-      assert_empty err
-      if RUBY_VERSION < '3.0.0' && STDOUT.tty?
-        expected = [
-          :*, /Traceback $most recent call last$:\n/,
-          :*, /\t... \d+ levels...\n/,
-          :*, /\t16: from $irb$:1:in (`|')a4'\n/,
-          :*, /\t15: from $irb$:1:in (`|')a5'\n/,
-          :*, /\t14: from $irb$:1:in (`|')a6'\n/,
-          :*, /\t13: from $irb$:1:in (`|')a7'\n/,
-          :*, /\t12: from $irb$:1:in (`|')a8'\n/,
-          :*, /\t11: from $irb$:1:in (`|')a9'\n/,
-          :*, /\t10: from $irb$:1:in (`|')a10'\n/,
-          :*, /\t 9: from $irb$:1:in (`|')a11'\n/,
-          :*, /\t 8: from $irb$:1:in (`|')a12'\n/,
-          :*, /\t 7: from $irb$:1:in (`|')a13'\n/,
-          :*, /\t 6: from $irb$:1:in (`|')a14'\n/,
-          :*, /\t 5: from $irb$:1:in (`|')a15'\n/,
-          :*, /\t 4: from $irb$:1:in (`|')a16'\n/,
-          :*, /\t 3: from $irb$:1:in (`|')a17'\n/,
-          :*, /\t 2: from $irb$:1:in (`|')a18'\n/,
-          :*, /\t 1: from $irb$:1:in (`|')a19'\n/,
-          :*, /$irb$:1:in (`|')a20': unhandled exception\n/,
-        ]
-      else
-        expected = [
-          :*, /$irb$:1:in (`|')a20': unhandled exception\n/,
-          :*, /\tfrom $irb$:1:in (`|')a19'\n/,
-          :*, /\tfrom $irb$:1:in (`|')a18'\n/,
-          :*, /\tfrom $irb$:1:in (`|')a17'\n/,
-          :*, /\tfrom $irb$:1:in (`|')a16'\n/,
-          :*, /\tfrom $irb$:1:in (`|')a15'\n/,
-          :*, /\tfrom $irb$:1:in (`|')a14'\n/,
-          :*, /\tfrom $irb$:1:in (`|')a13'\n/,
-          :*, /\tfrom $irb$:1:in (`|')a12'\n/,
-          :*, /\tfrom $irb$:1:in (`|')a11'\n/,
-          :*, /\tfrom $irb$:1:in (`|')a10'\n/,
-          :*, /\tfrom $irb$:1:in (`|')a9'\n/,
-          :*, /\tfrom $irb$:1:in (`|')a8'\n/,
-          :*, /\tfrom $irb$:1:in (`|')a7'\n/,
-          :*, /\tfrom $irb$:1:in (`|')a6'\n/,
-          :*, /\tfrom $irb$:1:in (`|')a5'\n/,
-          :*, /\tfrom $irb$:1:in (`|')a4'\n/,
-          :*, /\t... \d+ levels...\n/,
-        ]
-      end
-      assert_pattern_list(expected, out)
-    ensure
-      $VERBOSE = verbose
-    end
-
-    def test_prompt_main_escape
-      main = Struct.new(:to_s).new("main\a\t\r\n")
-      irb = IRB::Irb.new(IRB::WorkSpace.new(main), TestInputMethod.new)
-      assert_equal("irb(main    )>", irb.send(:format_prompt, 'irb(%m)>', nil, 1, 1))
-    end
-
-    def test_prompt_main_inspect_escape
-      main = Struct.new(:inspect).new("main\\n\nmain")
-      irb = IRB::Irb.new(IRB::WorkSpace.new(main), TestInputMethod.new)
-      assert_equal("irb(main\\n main)>", irb.send(:format_prompt, 'irb(%M)>', nil, 1, 1))
-    end
-
-    def test_prompt_main_truncate
-      main = Struct.new(:to_s).new("a" * 100)
-      def main.inspect; to_s.inspect; end
-      irb = IRB::Irb.new(IRB::WorkSpace.new(main), TestInputMethod.new)
-      assert_equal('irb(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa...)>', irb.send(:format_prompt, 'irb(%m)>', nil, 1, 1))
-      assert_equal('irb("aaaaaaaaaaaaaaaaaaaaaaaaaaaa...)>', irb.send(:format_prompt, 'irb(%M)>', nil, 1, 1))
-    end
-
-    def test_prompt_main_basic_object
-      main = BasicObject.new
-      irb = IRB::Irb.new(IRB::WorkSpace.new(main), TestInputMethod.new)
-      assert_match(/irb$#<BasicObject:.+$/, irb.send(:format_prompt, 'irb(%m)>', nil, 1, 1))
-      assert_match(/irb$#<BasicObject:.+$/, irb.send(:format_prompt, 'irb(%M)>', nil, 1, 1))
-    end
-
-    def test_prompt_main_raise
-      main = Object.new
-      def main.to_s; raise TypeError; end
-      def main.inspect; raise ArgumentError; end
-      irb = IRB::Irb.new(IRB::WorkSpace.new(main), TestInputMethod.new)
-      assert_equal("irb(!TypeError)>", irb.send(:format_prompt, 'irb(%m)>', nil, 1, 1))
-      assert_equal("irb(!ArgumentError)>", irb.send(:format_prompt, 'irb(%M)>', nil, 1, 1))
-    end
-
-    def test_prompt_format
-      main = 'main'
-      irb = IRB::Irb.new(IRB::WorkSpace.new(main), TestInputMethod.new)
-      assert_equal('%% main %m %main %%m >', irb.send(:format_prompt, '%%%% %m %%m %%%m %%%%m %l', '>', 1, 1))
-      assert_equal('42,%i, 42,%3i,042,%03i', irb.send(:format_prompt, '%i,%%i,%3i,%%3i,%03i,%%03i', nil, 42, 1))
-      assert_equal('42,%n, 42,%3n,042,%03n', irb.send(:format_prompt, '%n,%%n,%3n,%%3n,%03n,%%03n', nil, 1, 42))
-    end
-
-    def test_lineno
-      input = TestInputMethod.new([
-        "\n",
-        "__LINE__\n",
-        "__LINE__\n",
-        "\n",
-        "\n",
-        "__LINE__\n",
-      ])
-      irb = IRB::Irb.new(IRB::WorkSpace.new(Object.new), input)
-      out, err = capture_output do
-        irb.eval_input
-      end
-      assert_empty err
-      assert_pattern_list([
-          :*, /\b2\n/,
-          :*, /\b3\n/,
-          :*, /\b6\n/,
-        ], out)
-    end
-
-    def test_irb_path_setter
-      @context.irb_path = __FILE__
-      assert_equal(__FILE__, @context.irb_path)
-      assert_equal("#{__FILE__}(irb)", @context.instance_variable_get(:@eval_path))
-      @context.irb_path = 'file/does/not/exist'
-      assert_equal('file/does/not/exist', @context.irb_path)
-      assert_equal('file/does/not/exist', @context.instance_variable_get(:@eval_path))
-      @context.irb_path = "#{__FILE__}(irb)"
-      assert_equal("#{__FILE__}(irb)", @context.irb_path)
-      assert_equal("#{__FILE__}(irb)", @context.instance_variable_get(:@eval_path))
-    end
-
-    def test_build_completor
-      verbose, $VERBOSE = $VERBOSE, nil
-      original_completor = IRB.conf[:COMPLETOR]
-      IRB.conf[:COMPLETOR] = nil
-      assert_match(/IRB::(Regexp|Type)Completor/, @context.send(:build_completor).class.name)
-      IRB.conf[:COMPLETOR] = :regexp
-      assert_equal 'IRB::RegexpCompletor', @context.send(:build_completor).class.name
-      IRB.conf[:COMPLETOR] = :unknown
-      assert_equal 'IRB::RegexpCompletor', @context.send(:build_completor).class.name
-      # :type is tested in test_type_completor.rb
-    ensure
-      $VERBOSE = verbose
-      IRB.conf[:COMPLETOR] = original_completor
-    end
-
-    private
-
-    def without_colorize
-      original_value = IRB.conf[:USE_COLORIZE]
-      IRB.conf[:USE_COLORIZE] = false
-      yield
-    ensure
-      IRB.conf[:USE_COLORIZE] = original_value
-    end
-  end
-end
diff --git a/test/mri/irb/test_debugger_integration.rb b/test/mri/irb/test_debugger_integration.rb
deleted file mode 100644
index 45ffb2a52e6..00000000000
--- a/test/mri/irb/test_debugger_integration.rb
+++ /dev/null
@@ -1,513 +0,0 @@
-# frozen_string_literal: true
-
-require "tempfile"
-require "tmpdir"
-
-require_relative "helper"
-
-module TestIRB
-  class DebuggerIntegrationTest < IntegrationTestCase
-    def setup
-      super
-
-      if RUBY_ENGINE == 'truffleruby'
-        omit "This test runs with ruby/debug, which doesn't work with truffleruby"
-      end
-
-      @envs.merge!("NO_COLOR" => "true", "RUBY_DEBUG_HISTORY_FILE" => '')
-    end
-
-    def test_backtrace
-      write_ruby <<~'RUBY'
-        def foo
-          binding.irb
-        end
-        foo
-      RUBY
-
-      output = run_ruby_file do
-        type "backtrace"
-        type "exit!"
-      end
-
-      assert_match(/irb$main$:001> backtrace/, output)
-      assert_match(/Object#foo at #{@ruby_file.to_path}/, output)
-    end
-
-    def test_debug
-      write_ruby <<~'ruby'
-        binding.irb
-        puts "hello"
-      ruby
-
-      output = run_ruby_file do
-        type "debug"
-        type "next"
-        type "continue"
-      end
-
-      assert_match(/irb$main$:001> debug/, output)
-      assert_match(/irb:rdbg$main$:002> next/, output)
-      assert_match(/=>   2\| puts "hello"/, output)
-    end
-
-    def test_debug_command_only_runs_once
-      write_ruby <<~'ruby'
-        binding.irb
-      ruby
-
-      output = run_ruby_file do
-        type "debug"
-        type "debug"
-        type "continue"
-      end
-
-      assert_match(/irb$main$:001> debug/, output)
-      assert_match(/irb:rdbg$main$:002> debug/, output)
-      assert_match(/IRB is already running with a debug session/, output)
-    end
-
-    def test_debug_command_can_only_be_called_from_binding_irb
-      write_ruby <<~'ruby'
-        require "irb"
-        # trick test framework
-        puts "binding.irb"
-        IRB.start
-      ruby
-
-      output = run_ruby_file do
-        type "debug"
-        type "exit"
-      end
-
-      assert_include(output, "Debugging commands are only available when IRB is started with binding.irb")
-    end
-
-    def test_next
-      write_ruby <<~'ruby'
-        binding.irb
-        puts "hello"
-      ruby
-
-      output = run_ruby_file do
-        type "next"
-        type "continue"
-      end
-
-      assert_match(/irb$main$:001> next/, output)
-      assert_match(/=>   2\| puts "hello"/, output)
-    end
-
-    def test_break
-      write_ruby <<~'RUBY'
-        binding.irb
-        puts "Hello"
-      RUBY
-
-      output = run_ruby_file do
-        type "break 2"
-        type "continue"
-        type "continue"
-      end
-
-      assert_match(/irb$main$:001> break/, output)
-      assert_match(/=>   2\| puts "Hello"/, output)
-    end
-
-    def test_delete
-      write_ruby <<~'RUBY'
-        binding.irb
-        puts "Hello"
-        binding.irb
-        puts "World"
-      RUBY
-
-      output = run_ruby_file do
-        type "break 4"
-        type "continue"
-        type "delete 0"
-        type "continue"
-      end
-
-      assert_match(/irb:rdbg$main$:003> delete/, output)
-      assert_match(/deleted: #0  BP - Line/, output)
-    end
-
-    def test_step
-      write_ruby <<~'RUBY'
-        def foo
-          puts "Hello"
-        end
-        binding.irb
-        foo
-      RUBY
-
-      output = run_ruby_file do
-        type "step"
-        type "step"
-        type "continue"
-      end
-
-      assert_match(/irb$main$:001> step/, output)
-      assert_match(/=>   5\| foo/, output)
-      assert_match(/=>   2\|   puts "Hello"/, output)
-    end
-
-    def test_long_stepping
-      write_ruby <<~'RUBY'
-        class Foo
-          def foo(num)
-            bar(num + 10)
-          end
-
-          def bar(num)
-            num
-          end
-        end
-
-        binding.irb
-        Foo.new.foo(100)
-      RUBY
-
-      output = run_ruby_file do
-        type "step"
-        type "step"
-        type "step"
-        type "step"
-        type "num"
-        type "continue"
-      end
-
-      assert_match(/irb$main$:001> step/, output)
-      assert_match(/irb:rdbg$main$:002> step/, output)
-      assert_match(/irb:rdbg$#<Foo:.*>$:003> step/, output)
-      assert_match(/irb:rdbg$#<Foo:.*>$:004> step/, output)
-      assert_match(/irb:rdbg$#<Foo:.*>$:005> num/, output)
-      assert_match(/=> 110/, output)
-    end
-
-    def test_continue
-      write_ruby <<~'RUBY'
-        binding.irb
-        puts "Hello"
-        binding.irb
-        puts "World"
-      RUBY
-
-      output = run_ruby_file do
-        type "continue"
-        type "continue"
-      end
-
-      assert_match(/irb$main$:001> continue/, output)
-      assert_match(/=> 3: binding.irb/, output)
-      assert_match(/irb:rdbg$main$:002> continue/, output)
-    end
-
-    def test_finish
-      write_ruby <<~'RUBY'
-        def foo
-          binding.irb
-          puts "Hello"
-        end
-        foo
-      RUBY
-
-      output = run_ruby_file do
-        type "finish"
-        type "continue"
-      end
-
-      assert_match(/irb$main$:001> finish/, output)
-      assert_match(/=>   4\| end/, output)
-    end
-
-    def test_info
-      write_ruby <<~'RUBY'
-        def foo
-          a = "He" + "llo"
-          binding.irb
-        end
-        foo
-      RUBY
-
-      output = run_ruby_file do
-        type "info"
-        type "continue"
-      end
-
-      assert_match(/irb$main$:001> info/, output)
-      assert_match(/%self = main/, output)
-      assert_match(/a = "Hello"/, output)
-    end
-
-    def test_catch
-      write_ruby <<~'RUBY'
-        binding.irb
-        1 / 0
-      RUBY
-
-      output = run_ruby_file do
-        type "catch ZeroDivisionError"
-        type "continue"
-        type "continue"
-      end
-
-      assert_match(/irb$main$:001> catch/, output)
-      assert_match(/Stop by #0  BP - Catch  "ZeroDivisionError"/, output)
-    end
-
-    def test_exit
-      write_ruby <<~'RUBY'
-        binding.irb
-        puts "he" + "llo"
-      RUBY
-
-      output = run_ruby_file do
-        type "debug"
-        type "exit"
-      end
-
-      assert_match(/irb:rdbg$main$:002>/, output)
-      assert_match(/hello/, output)
-    end
-
-    def test_force_exit
-      write_ruby <<~'RUBY'
-        binding.irb
-        puts "he" + "llo"
-      RUBY
-
-      output = run_ruby_file do
-        type "debug"
-        type "exit!"
-      end
-
-      assert_match(/irb:rdbg$main$:002>/, output)
-      assert_not_match(/hello/, output)
-    end
-
-    def test_quit
-      write_ruby <<~'RUBY'
-        binding.irb
-        puts "he" + "llo"
-      RUBY
-
-      output = run_ruby_file do
-        type "debug"
-        type "quit!"
-      end
-
-      assert_match(/irb:rdbg$main$:002>/, output)
-      assert_not_match(/hello/, output)
-    end
-
-    def test_prompt_line_number_continues
-      write_ruby <<~'ruby'
-        binding.irb
-        puts "Hello"
-        puts "World"
-      ruby
-
-      output = run_ruby_file do
-        type "123"
-        type "456"
-        type "next"
-        type "info"
-        type "next"
-        type "continue"
-      end
-
-      assert_match(/irb$main$:003> next/, output)
-      assert_match(/irb:rdbg$main$:004> info/, output)
-      assert_match(/irb:rdbg$main$:005> next/, output)
-    end
-
-    def test_prompt_irb_name_is_kept
-      write_rc <<~RUBY
-        IRB.conf[:IRB_NAME] = "foo"
-      RUBY
-
-      write_ruby <<~'ruby'
-        binding.irb
-        puts "Hello"
-      ruby
-
-      output = run_ruby_file do
-        type "next"
-        type "continue"
-      end
-
-      assert_match(/foo$main$:001> next/, output)
-      assert_match(/foo:rdbg$main$:002> continue/, output)
-    end
-
-    def test_irb_commands_are_available_after_moving_around_with_the_debugger
-      write_ruby <<~'ruby'
-        class Foo
-          def bar
-            puts "bar"
-          end
-        end
-
-        binding.irb
-        Foo.new.bar
-      ruby
-
-      output = run_ruby_file do
-        # Due to the way IRB defines its commands, moving into the Foo instance from main is necessary for proper testing.
-        type "next"
-        type "step"
-        type "irb_info"
-        type "continue"
-      end
-
-      assert_include(output, "InputMethod: RelineInputMethod")
-    end
-
-    def test_irb_command_can_check_local_variables
-      write_ruby <<~'ruby'
-        binding.irb
-      ruby
-
-      output = run_ruby_file do
-        type "debug"
-        type 'foobar = IRB'
-        type "show_source foobar.start"
-        type "show_source = 'Foo'"
-        type "show_source + 'Bar'"
-        type "continue"
-      end
-      assert_include(output, "def start(ap_path = nil)")
-      assert_include(output, '"FooBar"')
-    end
-
-    def test_help_command_is_delegated_to_the_debugger
-      write_ruby <<~'ruby'
-        binding.irb
-      ruby
-
-      output = run_ruby_file do
-        type "debug"
-        type "help"
-        type "continue"
-      end
-
-      assert_include(output, "### Frame control")
-    end
-
-    def test_help_display_different_content_when_debugger_is_enabled
-      write_ruby <<~'ruby'
-        binding.irb
-      ruby
-
-      output = run_ruby_file do
-        type "debug"
-        type "help"
-        type "continue"
-      end
-
-      # IRB's commands should still be listed
-      assert_match(/help\s+List all available commands/, output)
-      # debug gem's commands should be appended at the end
-      assert_match(/Debugging $from debug\.gem$\s+### Control flow/, output)
-    end
-
-    def test_input_is_evaluated_in_the_context_of_the_current_thread
-      write_ruby <<~'ruby'
-        current_thread = Thread.current
-        binding.irb
-      ruby
-
-      output = run_ruby_file do
-        type "debug"
-        type '"Threads match: #{current_thread == Thread.current}"'
-        type "continue"
-      end
-
-      assert_match(/irb$main$:001> debug/, output)
-      assert_match(/Threads match: true/, output)
-    end
-
-    def test_irb_switches_debugger_interface_if_debug_was_already_activated
-      write_ruby <<~'ruby'
-        require 'debug'
-        class Foo
-          def bar
-            puts "bar"
-          end
-        end
-
-        binding.irb
-        Foo.new.bar
-      ruby
-
-      output = run_ruby_file do
-        # Due to the way IRB defines its commands, moving into the Foo instance from main is necessary for proper testing.
-        type "next"
-        type "step"
-        type 'irb_info'
-        type "continue"
-      end
-
-      assert_match(/irb$main$:001> next/, output)
-      assert_include(output, "InputMethod: RelineInputMethod")
-    end
-
-    def test_debugger_cant_be_activated_while_multi_irb_is_active
-      write_ruby <<~'ruby'
-        binding.irb
-        a = 1
-      ruby
-
-      output = run_ruby_file do
-        type "jobs"
-        type "next"
-        type "exit"
-      end
-
-      assert_match(/irb$main$:001> jobs/, output)
-      assert_include(output, "Can't start the debugger when IRB is running in a multi-IRB session.")
-    end
-
-    def test_multi_irb_commands_are_not_available_after_activating_the_debugger
-      write_ruby <<~'ruby'
-        binding.irb
-        a = 1
-      ruby
-
-      output = run_ruby_file do
-        type "next"
-        type "jobs"
-        type "continue"
-      end
-
-      assert_match(/irb$main$:001> next/, output)
-      assert_include(output, "Multi-IRB commands are not available when the debugger is enabled.")
-    end
-
-    def test_irb_passes_empty_input_to_debugger_to_repeat_the_last_command
-      write_ruby <<~'ruby'
-        binding.irb
-        puts "foo"
-        puts "bar"
-        puts "baz"
-      ruby
-
-      output = run_ruby_file do
-        type "next"
-        type ""
-        # Test that empty input doesn't repeat expressions
-        type "123"
-        type ""
-        type "next"
-        type ""
-        type ""
-      end
-
-      assert_include(output, "=>   2\| puts \"foo\"")
-      assert_include(output, "=>   3\| puts \"bar\"")
-      assert_include(output, "=>   4\| puts \"baz\"")
-    end
-  end
-end
diff --git a/test/mri/irb/test_eval_history.rb b/test/mri/irb/test_eval_history.rb
deleted file mode 100644
index 54913ceff55..00000000000
--- a/test/mri/irb/test_eval_history.rb
+++ /dev/null
@@ -1,69 +0,0 @@
-# frozen_string_literal: true
-require "irb"
-
-require_relative "helper"
-
-module TestIRB
-  class EvalHistoryTest < TestCase
-    def setup
-      save_encodings
-      IRB.instance_variable_get(:@CONF).clear
-    end
-
-    def teardown
-      restore_encodings
-    end
-
-    def execute_lines(*lines, conf: {}, main: self, irb_path: nil)
-      IRB.init_config(nil)
-      IRB.conf[:VERBOSE] = false
-      IRB.conf[:PROMPT_MODE] = :SIMPLE
-      IRB.conf[:USE_PAGER] = false
-      IRB.conf.merge!(conf)
-      input = TestInputMethod.new(lines)
-      irb = IRB::Irb.new(IRB::WorkSpace.new(main), input)
-      irb.context.return_format = "=> %s\n"
-      irb.context.irb_path = irb_path if irb_path
-      IRB.conf[:MAIN_CONTEXT] = irb.context
-      capture_output do
-        irb.eval_input
-      end
-    end
-
-    def test_eval_history_is_disabled_by_default
-      out, err = execute_lines(
-        "a = 1",
-        "__"
-      )
-
-      assert_empty(err)
-      assert_match(/undefined local variable or method (`|')__'/, out)
-    end
-
-    def test_eval_history_can_be_retrieved_with_double_underscore
-      out, err = execute_lines(
-        "a = 1",
-        "__",
-        conf: { EVAL_HISTORY: 5 }
-      )
-
-      assert_empty(err)
-      assert_match("=> 1\n" + "=> 1 1\n", out)
-    end
-
-    def test_eval_history_respects_given_limit
-      out, err = execute_lines(
-        "'foo'\n",
-        "'bar'\n",
-        "'baz'\n",
-        "'xyz'\n",
-        "__",
-        conf: { EVAL_HISTORY: 4 }
-      )
-
-      assert_empty(err)
-      # Because eval_history injects `__` into the history AND decide to ignore it, we only get <limit> - 1 results
-      assert_match("2 \"bar\"\n" + "3 \"baz\"\n" + "4 \"xyz\"\n", out)
-    end
-  end
-end
diff --git a/test/mri/irb/test_evaluation.rb b/test/mri/irb/test_evaluation.rb
deleted file mode 100644
index adb69b20677..00000000000
--- a/test/mri/irb/test_evaluation.rb
+++ /dev/null
@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-require "tempfile"
-
-require_relative "helper"
-
-module TestIRB
-  class EchoingTest < IntegrationTestCase
-    def test_irb_echos_by_default
-      write_ruby <<~'RUBY'
-        binding.irb
-      RUBY
-
-      output = run_ruby_file do
-        type "123123"
-        type "exit"
-      end
-
-      assert_include(output, "=> 123123")
-    end
-
-    def test_irb_doesnt_echo_line_with_semicolon
-      write_ruby <<~'RUBY'
-        binding.irb
-      RUBY
-
-      output = run_ruby_file do
-        type "123123;"
-        type "123123   ;"
-        type "123123;   "
-        type <<~RUBY
-          if true
-            123123
-          end;
-        RUBY
-        type "'evaluation ends'"
-        type "exit"
-      end
-
-      assert_include(output, "=> \"evaluation ends\"")
-      assert_not_include(output, "=> 123123")
-    end
-  end
-end
diff --git a/test/mri/irb/test_helper_method.rb b/test/mri/irb/test_helper_method.rb
deleted file mode 100644
index a3e2c43b2fa..00000000000
--- a/test/mri/irb/test_helper_method.rb
+++ /dev/null
@@ -1,135 +0,0 @@
-# frozen_string_literal: true
-require "irb"
-
-require_relative "helper"
-
-module TestIRB
-  class HelperMethodTestCase < TestCase
-    def setup
-      $VERBOSE = nil
-      @verbosity = $VERBOSE
-      save_encodings
-      IRB.instance_variable_get(:@CONF).clear
-    end
-
-    def teardown
-      $VERBOSE = @verbosity
-      restore_encodings
-    end
-
-    def execute_lines(*lines, conf: {}, main: self, irb_path: nil)
-      IRB.init_config(nil)
-      IRB.conf[:VERBOSE] = false
-      IRB.conf[:PROMPT_MODE] = :SIMPLE
-      IRB.conf.merge!(conf)
-      input = TestInputMethod.new(lines)
-      irb = IRB::Irb.new(IRB::WorkSpace.new(main), input)
-      irb.context.return_format = "=> %s\n"
-      irb.context.irb_path = irb_path if irb_path
-      IRB.conf[:MAIN_CONTEXT] = irb.context
-      IRB.conf[:USE_PAGER] = false
-      capture_output do
-        irb.eval_input
-      end
-    end
-  end
-
-  module TestHelperMethod
-    class ConfTest < HelperMethodTestCase
-      def test_conf_returns_the_context_object
-        out, err = execute_lines("conf.ap_name")
-
-        assert_empty err
-        assert_include out, "=> \"irb\""
-      end
-    end
-  end
-
-  class HelperMethodIntegrationTest < IntegrationTestCase
-    def test_arguments_propogation
-      write_ruby <<~RUBY
-        require "irb/helper_method"
-
-        class MyHelper < IRB::HelperMethod::Base
-          description "This is a test helper"
-
-          def execute(
-            required_arg, optional_arg = nil, *splat_arg, required_keyword_arg:,
-            optional_keyword_arg: nil, **double_splat_arg, &block_arg
-          )
-            puts [required_arg, optional_arg, splat_arg, required_keyword_arg, optional_keyword_arg, double_splat_arg, block_arg.call].to_s
-          end
-        end
-
-        IRB::HelperMethod.register(:my_helper, MyHelper)
-
-        binding.irb
-      RUBY
-
-      output = run_ruby_file do
-        type <<~INPUT
-          my_helper(
-            "required", "optional", "splat", required_keyword_arg: "required",
-            optional_keyword_arg: "optional", a: 1, b: 2
-          ) { "block" }
-        INPUT
-        type "exit"
-      end
-
-      optional = {a: 1, b: 2}
-      assert_include(output, %[["required", "optional", ["splat"], "required", "optional", #{optional.inspect}, "block"]])
-    end
-
-    def test_helper_method_injection_can_happen_after_irb_require
-      write_ruby <<~RUBY
-        require "irb"
-
-        class MyHelper < IRB::HelperMethod::Base
-          description "This is a test helper"
-
-          def execute
-            puts "Hello from MyHelper"
-          end
-        end
-
-        IRB::HelperMethod.register(:my_helper, MyHelper)
-
-        binding.irb
-      RUBY
-
-      output = run_ruby_file do
-        type "my_helper"
-        type "exit"
-      end
-
-      assert_include(output, 'Hello from MyHelper')
-    end
-
-    def test_helper_method_instances_are_memoized
-      write_ruby <<~RUBY
-        require "irb/helper_method"
-
-        class MyHelper < IRB::HelperMethod::Base
-          description "This is a test helper"
-
-          def execute(val)
-            @val ||= val
-          end
-        end
-
-        IRB::HelperMethod.register(:my_helper, MyHelper)
-
-        binding.irb
-      RUBY
-
-      output = run_ruby_file do
-        type "my_helper(100)"
-        type "my_helper(200)"
-        type "exit"
-      end
-
-      assert_include(output, '=> 100')
-      assert_not_include(output, '=> 200')
-    end
-  end
-end
diff --git a/test/mri/irb/test_history.rb b/test/mri/irb/test_history.rb
deleted file mode 100644
index 021bb682c14..00000000000
--- a/test/mri/irb/test_history.rb
+++ /dev/null
@@ -1,532 +0,0 @@
-# frozen_string_literal: false
-require 'irb'
-require 'readline'
-require "tempfile"
-
-require_relative "helper"
-
-return if RUBY_PLATFORM.match?(/solaris|mswin|mingw/i)
-
-module TestIRB
-  class HistoryTest < TestCase
-    def setup
-      @conf_backup = IRB.conf.dup
-      @original_verbose, $VERBOSE = $VERBOSE, nil
-      @tmpdir = Dir.mktmpdir("test_irb_history_")
-      setup_envs(home: @tmpdir)
-      IRB.conf[:LC_MESSAGES] = IRB::Locale.new
-      save_encodings
-      IRB.instance_variable_set(:@existing_rc_name_generators, nil)
-    end
-
-    def teardown
-      IRB.conf.replace(@conf_backup)
-      IRB.instance_variable_set(:@existing_rc_name_generators, nil)
-      teardown_envs
-      restore_encodings
-      $VERBOSE = @original_verbose
-      FileUtils.rm_rf(@tmpdir)
-    end
-
-    class TestInputMethodWithRelineHistory < TestInputMethod
-      # When IRB.conf[:USE_MULTILINE] is true, IRB::RelineInputMethod uses Reline::History
-      HISTORY = Reline::History.new(Reline.core.config)
-
-      include IRB::HistorySavingAbility
-    end
-
-    class TestInputMethodWithReadlineHistory < TestInputMethod
-      # When IRB.conf[:USE_MULTILINE] is false, IRB::ReadlineInputMethod uses Readline::HISTORY
-      HISTORY = Readline::HISTORY
-
-      include IRB::HistorySavingAbility
-    end
-
-    def test_history_dont_save
-      omit "Skip Editline" if /EditLine/n.match(Readline::VERSION)
-      IRB.conf[:SAVE_HISTORY] = nil
-      assert_history(<<~EXPECTED_HISTORY, <<~INITIAL_HISTORY, <<~INPUT)
-        1
-        2
-      EXPECTED_HISTORY
-        1
-        2
-      INITIAL_HISTORY
-        3
-        exit
-      INPUT
-    end
-
-    def test_history_save_1
-      omit "Skip Editline" if /EditLine/n.match(Readline::VERSION)
-      IRB.conf[:SAVE_HISTORY] = 1
-      assert_history(<<~EXPECTED_HISTORY, <<~INITIAL_HISTORY, <<~INPUT)
-        exit
-      EXPECTED_HISTORY
-        1
-        2
-        3
-        4
-      INITIAL_HISTORY
-        5
-        exit
-      INPUT
-    end
-
-    def test_history_save_100
-      omit "Skip Editline" if /EditLine/n.match(Readline::VERSION)
-      IRB.conf[:SAVE_HISTORY] = 100
-      assert_history(<<~EXPECTED_HISTORY, <<~INITIAL_HISTORY, <<~INPUT)
-        1
-        2
-        3
-        4
-        5
-        exit
-      EXPECTED_HISTORY
-        1
-        2
-        3
-        4
-      INITIAL_HISTORY
-        5
-        exit
-      INPUT
-    end
-
-    def test_history_save_bignum
-      omit "Skip Editline" if /EditLine/n.match(Readline::VERSION)
-      IRB.conf[:SAVE_HISTORY] = 10 ** 19
-      assert_history(<<~EXPECTED_HISTORY, <<~INITIAL_HISTORY, <<~INPUT)
-        1
-        2
-        3
-        4
-        5
-        exit
-      EXPECTED_HISTORY
-        1
-        2
-        3
-        4
-      INITIAL_HISTORY
-        5
-        exit
-      INPUT
-    end
-
-    def test_history_save_minus_as_infinity
-      omit "Skip Editline" if /EditLine/n.match(Readline::VERSION)
-      IRB.conf[:SAVE_HISTORY] = -1 # infinity
-      assert_history(<<~EXPECTED_HISTORY, <<~INITIAL_HISTORY, <<~INPUT)
-        1
-        2
-        3
-        4
-        5
-        exit
-      EXPECTED_HISTORY
-        1
-        2
-        3
-        4
-      INITIAL_HISTORY
-        5
-        exit
-      INPUT
-    end
-
-    def test_history_concurrent_use_reline
-      omit "Skip Editline" if /EditLine/n.match(Readline::VERSION)
-      IRB.conf[:SAVE_HISTORY] = 1
-      history_concurrent_use_for_input_method(TestInputMethodWithRelineHistory)
-    end
-
-    def test_history_concurrent_use_readline
-      omit "Skip Editline" if /EditLine/n.match(Readline::VERSION)
-      IRB.conf[:SAVE_HISTORY] = 1
-      history_concurrent_use_for_input_method(TestInputMethodWithReadlineHistory)
-    end
-
-    def test_history_concurrent_use_not_present
-      IRB.conf[:SAVE_HISTORY] = 1
-      io = TestInputMethodWithRelineHistory.new
-      io.class::HISTORY.clear
-      io.load_history
-      io.class::HISTORY << 'line1'
-      io.class::HISTORY << 'line2'
-
-      history_file = IRB.rc_file("_history")
-      assert_not_send [File, :file?, history_file]
-      File.write(history_file, "line0\n")
-      io.save_history
-      assert_equal(%w"line0 line1 line2", File.read(history_file).split)
-    end
-
-    def test_history_different_encodings
-      IRB.conf[:SAVE_HISTORY] = 2
-      IRB.conf[:LC_MESSAGES] = IRB::Locale.new("en_US.ASCII")
-      IRB.__send__(:set_encoding, Encoding::US_ASCII.name, override: false)
-      assert_history(<<~EXPECTED_HISTORY.encode(Encoding::US_ASCII), <<~INITIAL_HISTORY.encode(Encoding::UTF_8), <<~INPUT)
-        ????
-        exit
-      EXPECTED_HISTORY
-        😀
-      INITIAL_HISTORY
-        exit
-      INPUT
-    end
-
-    def test_history_does_not_raise_when_history_file_directory_does_not_exist
-      backup_history_file = IRB.conf[:HISTORY_FILE]
-      IRB.conf[:SAVE_HISTORY] = 1
-      IRB.conf[:HISTORY_FILE] = "fake/fake/fake/history_file"
-      io = TestInputMethodWithRelineHistory.new
-
-      assert_warn(/ensure the folder exists/i) do
-        io.save_history
-      end
-
-      # assert_warn reverts $VERBOSE to EnvUtil.original_verbose, which is true in some cases
-      # We want to keep $VERBOSE as nil until teardown is called
-      # TODO: check if this is an assert_warn issue
-      $VERBOSE = nil
-    ensure
-      IRB.conf[:HISTORY_FILE] = backup_history_file
-    end
-
-    def test_no_home_no_history_file_does_not_raise_history_save
-      ENV['HOME'] = nil
-      io = TestInputMethodWithRelineHistory.new
-      assert_nil(IRB.rc_file('_history'))
-      assert_nothing_raised do
-        io.load_history
-        io.save_history
-      end
-    end
-
-    private
-
-    def history_concurrent_use_for_input_method(input_method)
-      assert_history(<<~EXPECTED_HISTORY, <<~INITIAL_HISTORY, <<~INPUT, input_method) do |history_file|
-        exit
-        5
-        exit
-      EXPECTED_HISTORY
-        1
-        2
-        3
-        4
-      INITIAL_HISTORY
-        5
-        exit
-      INPUT
-        assert_history(<<~EXPECTED_HISTORY2, <<~INITIAL_HISTORY2, <<~INPUT2, input_method)
-        exit
-      EXPECTED_HISTORY2
-        1
-        2
-        3
-        4
-      INITIAL_HISTORY2
-        5
-        exit
-      INPUT2
-        File.utime(File.atime(history_file), File.mtime(history_file) + 2, history_file)
-      end
-    end
-
-    def assert_history(expected_history, initial_irb_history, input, input_method = TestInputMethodWithRelineHistory)
-      actual_history = nil
-      history_file = IRB.rc_file("_history")
-      ENV["HOME"] = @tmpdir
-      File.open(history_file, "w") do |f|
-        f.write(initial_irb_history)
-      end
-
-      io = input_method.new
-      io.class::HISTORY.clear
-      io.load_history
-      if block_given?
-        previous_history = []
-        io.class::HISTORY.each { |line| previous_history << line }
-        yield history_file
-        io.class::HISTORY.clear
-        previous_history.each { |line| io.class::HISTORY << line }
-      end
-      input.split.each { |line| io.class::HISTORY << line }
-      io.save_history
-
-      io.load_history
-      File.open(history_file, "r") do |f|
-        actual_history = f.read
-      end
-      assert_equal(expected_history, actual_history, <<~MESSAGE)
-        expected:
-        #{expected_history}
-        but actual:
-        #{actual_history}
-      MESSAGE
-    end
-
-    def with_temp_stdio
-      Tempfile.create("test_readline_stdin") do |stdin|
-        Tempfile.create("test_readline_stdout") do |stdout|
-          yield stdin, stdout
-        end
-      end
-    end
-  end
-
-  class IRBHistoryIntegrationTest < IntegrationTestCase
-    def test_history_saving_with_debug
-      write_history ""
-
-      write_ruby <<~'RUBY'
-        def foo
-        end
-
-        binding.irb
-
-        foo
-      RUBY
-
-      output = run_ruby_file do
-        type "'irb session'"
-        type "next"
-        type "'irb:debug session'"
-        type "step"
-        type "irb_info"
-        type "puts Reline::HISTORY.to_a.to_s"
-        type "q!"
-      end
-
-      assert_include(output, "InputMethod: RelineInputMethod")
-      # check that in-memory history is preserved across sessions
-      assert_include output, %q(
-        ["'irb session'", "next", "'irb:debug session'", "step", "irb_info", "puts Reline::HISTORY.to_a.to_s"]
-      ).strip
-
-      assert_equal <<~HISTORY, @history_file.open.read
-        'irb session'
-        next
-        'irb:debug session'
-        step
-        irb_info
-        puts Reline::HISTORY.to_a.to_s
-        q!
-      HISTORY
-    end
-
-    def test_history_saving_with_debug_without_prior_history
-      tmpdir = Dir.mktmpdir("test_irb_history_")
-      # Intentionally not creating the file so we test the reset counter logic
-      history_file = File.join(tmpdir, "irb_history")
-
-      write_rc <<~RUBY
-        IRB.conf[:HISTORY_FILE] = "#{history_file}"
-      RUBY
-
-      write_ruby <<~'RUBY'
-        def foo
-        end
-
-        binding.irb
-
-        foo
-      RUBY
-
-      output = run_ruby_file do
-        type "'irb session'"
-        type "next"
-        type "'irb:debug session'"
-        type "step"
-        type "irb_info"
-        type "puts Reline::HISTORY.to_a.to_s"
-        type "q!"
-      end
-
-      assert_include(output, "InputMethod: RelineInputMethod")
-      # check that in-memory history is preserved across sessions
-      assert_include output, %q(
-        ["'irb session'", "next", "'irb:debug session'", "step", "irb_info", "puts Reline::HISTORY.to_a.to_s"]
-      ).strip
-
-      assert_equal <<~HISTORY, File.read(history_file)
-        'irb session'
-        next
-        'irb:debug session'
-        step
-        irb_info
-        puts Reline::HISTORY.to_a.to_s
-        q!
-      HISTORY
-    ensure
-      FileUtils.rm_rf(tmpdir)
-    end
-
-    def test_history_saving_with_nested_sessions
-      write_history ""
-
-      write_ruby <<~'RUBY'
-        def foo
-          binding.irb
-        end
-
-        binding.irb
-      RUBY
-
-      run_ruby_file do
-        type "'outer session'"
-        type "foo"
-        type "'inner session'"
-        type "exit"
-        type "'outer session again'"
-        type "exit"
-      end
-
-      assert_equal <<~HISTORY, @history_file.open.read
-        'outer session'
-        foo
-        'inner session'
-        exit
-        'outer session again'
-        exit
-      HISTORY
-    end
-
-    def test_nested_history_saving_from_inner_session_with_exit!
-      write_history ""
-
-      write_ruby <<~'RUBY'
-        def foo
-          binding.irb
-        end
-
-        binding.irb
-      RUBY
-
-      run_ruby_file do
-        type "'outer session'"
-        type "foo"
-        type "'inner session'"
-        type "exit!"
-      end
-
-      assert_equal <<~HISTORY, @history_file.open.read
-        'outer session'
-        foo
-        'inner session'
-        exit!
-      HISTORY
-    end
-
-    def test_nested_history_saving_from_outer_session_with_exit!
-      write_history ""
-
-      write_ruby <<~'RUBY'
-        def foo
-          binding.irb
-        end
-
-        binding.irb
-      RUBY
-
-      run_ruby_file do
-        type "'outer session'"
-        type "foo"
-        type "'inner session'"
-        type "exit"
-        type "'outer session again'"
-        type "exit!"
-      end
-
-      assert_equal <<~HISTORY, @history_file.open.read
-        'outer session'
-        foo
-        'inner session'
-        exit
-        'outer session again'
-        exit!
-      HISTORY
-    end
-
-    def test_history_saving_with_nested_sessions_and_prior_history
-      write_history <<~HISTORY
-        old_history_1
-        old_history_2
-        old_history_3
-      HISTORY
-
-      write_ruby <<~'RUBY'
-        def foo
-          binding.irb
-        end
-
-        binding.irb
-      RUBY
-
-      run_ruby_file do
-        type "'outer session'"
-        type "foo"
-        type "'inner session'"
-        type "exit"
-        type "'outer session again'"
-        type "exit"
-      end
-
-      assert_equal <<~HISTORY, @history_file.open.read
-        old_history_1
-        old_history_2
-        old_history_3
-        'outer session'
-        foo
-        'inner session'
-        exit
-        'outer session again'
-        exit
-      HISTORY
-    end
-
-    def test_direct_debug_session_loads_history
-      @envs['RUBY_DEBUG_IRB_CONSOLE'] = "1"
-      write_history <<~HISTORY
-        old_history_1
-        old_history_2
-        old_history_3
-      HISTORY
-
-      write_ruby <<~'RUBY'
-        require 'debug'
-        debugger
-        binding.irb # needed to satisfy run_ruby_file
-      RUBY
-
-      output = run_ruby_file do
-        type "history"
-        type "puts 'foo'"
-        type "history"
-        type "exit!"
-      end
-
-      assert_include(output, "irb:rdbg(main):002") # assert that we're in an irb:rdbg session
-      assert_include(output, "5: history")
-      assert_include(output, "4: puts 'foo'")
-      assert_include(output, "3: history")
-      assert_include(output, "2: old_history_3")
-      assert_include(output, "1: old_history_2")
-      assert_include(output, "0: old_history_1")
-    end
-
-    private
-
-    def write_history(history)
-      @history_file = Tempfile.new('irb_history')
-      @history_file.write(history)
-      @history_file.close
-      write_rc <<~RUBY
-        IRB.conf[:HISTORY_FILE] = "#{@history_file.path}"
-      RUBY
-    end
-  end
-end
diff --git a/test/mri/irb/test_init.rb b/test/mri/irb/test_init.rb
deleted file mode 100644
index f7168e02fea..00000000000
--- a/test/mri/irb/test_init.rb
+++ /dev/null
@@ -1,388 +0,0 @@
-# frozen_string_literal: false
-require "irb"
-require "fileutils"
-
-require_relative "helper"
-
-module TestIRB
-  class InitTest < TestCase
-    def setup
-      # IRBRC is for RVM...
-      @backup_env = %w[HOME XDG_CONFIG_HOME IRBRC].each_with_object({}) do |env, hash|
-        hash[env] = ENV.delete(env)
-      end
-      ENV["HOME"] = @tmpdir = File.realpath(Dir.mktmpdir("test_irb_init_#{$$}"))
-    end
-
-    def reset_rc_name_generators
-      IRB.instance_variable_set(:@existing_rc_name_generators, nil)
-    end
-
-    def teardown
-      ENV.update(@backup_env)
-      FileUtils.rm_rf(@tmpdir)
-      IRB.conf.delete(:SCRIPT)
-      reset_rc_name_generators
-    end
-
-    def test_setup_with_argv_preserves_global_argv
-      argv = ["foo", "bar"]
-      with_argv(argv) do
-        IRB.setup(eval("__FILE__"), argv: %w[-f])
-        assert_equal argv, ARGV
-      end
-    end
-
-    def test_setup_with_minimum_argv_does_not_change_dollar0
-      orig = $0.dup
-      IRB.setup(eval("__FILE__"), argv: %w[-f])
-      assert_equal orig, $0
-    end
-
-    def test_rc_files
-      tmpdir = @tmpdir
-      Dir.chdir(tmpdir) do
-        home = ENV['HOME'] = "#{tmpdir}/home"
-        xdg_config_home = ENV['XDG_CONFIG_HOME'] = "#{tmpdir}/xdg"
-        reset_rc_name_generators
-        assert_empty(IRB.irbrc_files)
-        assert_equal("#{home}/.irb_history", IRB.rc_file('_history'))
-        FileUtils.mkdir_p(home)
-        FileUtils.mkdir_p("#{xdg_config_home}/irb")
-        FileUtils.mkdir_p("#{home}/.config/irb")
-        reset_rc_name_generators
-        assert_empty(IRB.irbrc_files)
-        assert_equal("#{xdg_config_home}/irb/irb_history", IRB.rc_file('_history'))
-        home_irbrc = "#{home}/.irbrc"
-        config_irbrc = "#{home}/.config/irb/irbrc"
-        xdg_config_irbrc = "#{xdg_config_home}/irb/irbrc"
-        [home_irbrc, config_irbrc, xdg_config_irbrc].each do |file|
-          FileUtils.touch(file)
-        end
-        current_dir_irbrcs = %w[.irbrc irbrc _irbrc $irbrc].map { |file| "#{tmpdir}/#{file}" }
-        current_dir_irbrcs.each { |file| FileUtils.touch(file) }
-        reset_rc_name_generators
-        assert_equal([xdg_config_irbrc, home_irbrc, *current_dir_irbrcs], IRB.irbrc_files)
-        assert_equal(xdg_config_irbrc.sub(/rc$/, '_history'), IRB.rc_file('_history'))
-        ENV['XDG_CONFIG_HOME'] = nil
-        reset_rc_name_generators
-        assert_equal([home_irbrc, config_irbrc, *current_dir_irbrcs], IRB.irbrc_files)
-        assert_equal(home_irbrc.sub(/rc$/, '_history'), IRB.rc_file('_history'))
-        ENV['XDG_CONFIG_HOME'] = ''
-        reset_rc_name_generators
-        assert_equal([home_irbrc, config_irbrc] + current_dir_irbrcs, IRB.irbrc_files)
-        assert_equal(home_irbrc.sub(/rc$/, '_history'), IRB.rc_file('_history'))
-        ENV['XDG_CONFIG_HOME'] = xdg_config_home
-        ENV['IRBRC'] = "#{tmpdir}/.irbrc"
-        reset_rc_name_generators
-        assert_equal([ENV['IRBRC'], xdg_config_irbrc, home_irbrc] + (current_dir_irbrcs - [ENV['IRBRC']]), IRB.irbrc_files)
-        assert_equal(ENV['IRBRC'] + '_history', IRB.rc_file('_history'))
-        ENV['IRBRC'] = ENV['HOME'] = ENV['XDG_CONFIG_HOME'] = nil
-        reset_rc_name_generators
-        assert_equal(current_dir_irbrcs, IRB.irbrc_files)
-        assert_nil(IRB.rc_file('_history'))
-      end
-    end
-
-    def test_duplicated_rc_files
-      tmpdir = @tmpdir
-      Dir.chdir(tmpdir) do
-        ENV['XDG_CONFIG_HOME'] = "#{ENV['HOME']}/.config"
-        FileUtils.mkdir_p("#{ENV['XDG_CONFIG_HOME']}/irb")
-        env_irbrc = ENV['IRBRC'] = "#{tmpdir}/_irbrc"
-        xdg_config_irbrc = "#{ENV['XDG_CONFIG_HOME']}/irb/irbrc"
-        home_irbrc = "#{ENV['HOME']}/.irbrc"
-        current_dir_irbrc = "#{tmpdir}/irbrc"
-        [env_irbrc, xdg_config_irbrc, home_irbrc, current_dir_irbrc].each do |file|
-          FileUtils.touch(file)
-        end
-        reset_rc_name_generators
-        assert_equal([env_irbrc, xdg_config_irbrc, home_irbrc, current_dir_irbrc], IRB.irbrc_files)
-      end
-    end
-
-    def test_sigint_restore_default
-      pend "This test gets stuck on Solaris for unknown reason; contribution is welcome" if RUBY_PLATFORM =~ /solaris/
-      bundle_exec = ENV.key?('BUNDLE_GEMFILE') ? ['-rbundler/setup'] : []
-      # IRB should restore SIGINT handler
-      status = assert_in_out_err(bundle_exec + %w[-W0 -rirb -e Signal.trap("SIGINT","DEFAULT");binding.irb;loop{Process.kill("SIGINT",$$)} -- -f --], "exit\n", //, //)
-      Process.kill("SIGKILL", status.pid) if !status.exited? && !status.stopped? && !status.signaled?
-    end
-
-    def test_sigint_restore_block
-      bundle_exec = ENV.key?('BUNDLE_GEMFILE') ? ['-rbundler/setup'] : []
-      # IRB should restore SIGINT handler
-      status = assert_in_out_err(bundle_exec + %w[-W0 -rirb -e x=false;Signal.trap("SIGINT"){x=true};binding.irb;loop{Process.kill("SIGINT",$$);if(x);break;end} -- -f --], "exit\n", //, //)
-      Process.kill("SIGKILL", status.pid) if !status.exited? && !status.stopped? && !status.signaled?
-    end
-
-    def test_no_color_environment_variable
-      orig_no_color = ENV['NO_COLOR']
-      orig_use_colorize = IRB.conf[:USE_COLORIZE]
-      IRB.conf[:USE_COLORIZE] = true
-
-      assert IRB.conf[:USE_COLORIZE]
-
-      ENV['NO_COLOR'] = 'true'
-      IRB.setup(__FILE__)
-      refute IRB.conf[:USE_COLORIZE]
-
-      ENV['NO_COLOR'] = ''
-      IRB.setup(__FILE__)
-      assert IRB.conf[:USE_COLORIZE]
-
-      ENV['NO_COLOR'] = nil
-      IRB.setup(__FILE__)
-      assert IRB.conf[:USE_COLORIZE]
-    ensure
-      ENV['NO_COLOR'] = orig_no_color
-      IRB.conf[:USE_COLORIZE] = orig_use_colorize
-    end
-
-    def test_use_autocomplete_environment_variable
-      orig_use_autocomplete_env = ENV['IRB_USE_AUTOCOMPLETE']
-      orig_use_autocomplete_conf = IRB.conf[:USE_AUTOCOMPLETE]
-
-      ENV['IRB_USE_AUTOCOMPLETE'] = nil
-      IRB.setup(__FILE__)
-      assert IRB.conf[:USE_AUTOCOMPLETE]
-
-      ENV['IRB_USE_AUTOCOMPLETE'] = ''
-      IRB.setup(__FILE__)
-      assert IRB.conf[:USE_AUTOCOMPLETE]
-
-      ENV['IRB_USE_AUTOCOMPLETE'] = 'false'
-      IRB.setup(__FILE__)
-      refute IRB.conf[:USE_AUTOCOMPLETE]
-
-      ENV['IRB_USE_AUTOCOMPLETE'] = 'true'
-      IRB.setup(__FILE__)
-      assert IRB.conf[:USE_AUTOCOMPLETE]
-    ensure
-      ENV["IRB_USE_AUTOCOMPLETE"] = orig_use_autocomplete_env
-      IRB.conf[:USE_AUTOCOMPLETE] = orig_use_autocomplete_conf
-    end
-
-    def test_completor_environment_variable
-      orig_use_autocomplete_env = ENV['IRB_COMPLETOR']
-      orig_use_autocomplete_conf = IRB.conf[:COMPLETOR]
-
-      # Default value is nil: auto-detect
-      ENV['IRB_COMPLETOR'] = nil
-      IRB.setup(__FILE__)
-      assert_equal(nil, IRB.conf[:COMPLETOR])
-
-      ENV['IRB_COMPLETOR'] = 'regexp'
-      IRB.setup(__FILE__)
-      assert_equal(:regexp, IRB.conf[:COMPLETOR])
-
-      ENV['IRB_COMPLETOR'] = 'type'
-      IRB.setup(__FILE__)
-      assert_equal(:type, IRB.conf[:COMPLETOR])
-
-      ENV['IRB_COMPLETOR'] = 'regexp'
-      IRB.setup(__FILE__, argv: ['--type-completor'])
-      assert_equal :type, IRB.conf[:COMPLETOR]
-
-      ENV['IRB_COMPLETOR'] = 'type'
-      IRB.setup(__FILE__, argv: ['--regexp-completor'])
-      assert_equal :regexp, IRB.conf[:COMPLETOR]
-    ensure
-      ENV['IRB_COMPLETOR'] = orig_use_autocomplete_env
-      IRB.conf[:COMPLETOR] = orig_use_autocomplete_conf
-    end
-
-    def test_completor_setup_with_argv
-      orig_completor_conf = IRB.conf[:COMPLETOR]
-      orig_completor_env = ENV['IRB_COMPLETOR']
-      ENV['IRB_COMPLETOR'] = nil
-
-      # Default value is nil: auto-detect
-      IRB.setup(__FILE__, argv: [])
-      assert_equal nil, IRB.conf[:COMPLETOR]
-
-      IRB.setup(__FILE__, argv: ['--type-completor'])
-      assert_equal :type, IRB.conf[:COMPLETOR]
-
-      IRB.setup(__FILE__, argv: ['--regexp-completor'])
-      assert_equal :regexp, IRB.conf[:COMPLETOR]
-    ensure
-      IRB.conf[:COMPLETOR] = orig_completor_conf
-      ENV['IRB_COMPLETOR'] = orig_completor_env
-    end
-
-    def test_noscript
-      argv = %w[--noscript -- -f]
-      IRB.setup(eval("__FILE__"), argv: argv)
-      assert_nil IRB.conf[:SCRIPT]
-      assert_equal(['-f'], argv)
-
-      argv = %w[--noscript -- a]
-      IRB.setup(eval("__FILE__"), argv: argv)
-      assert_nil IRB.conf[:SCRIPT]
-      assert_equal(['a'], argv)
-
-      argv = %w[--noscript a]
-      IRB.setup(eval("__FILE__"), argv: argv)
-      assert_nil IRB.conf[:SCRIPT]
-      assert_equal(['a'], argv)
-
-      argv = %w[--script --noscript a]
-      IRB.setup(eval("__FILE__"), argv: argv)
-      assert_nil IRB.conf[:SCRIPT]
-      assert_equal(['a'], argv)
-
-      argv = %w[--noscript --script a]
-      IRB.setup(eval("__FILE__"), argv: argv)
-      assert_equal('a', IRB.conf[:SCRIPT])
-      assert_equal([], argv)
-    end
-
-    def test_dash
-      argv = %w[-]
-      IRB.setup(eval("__FILE__"), argv: argv)
-      assert_equal('-', IRB.conf[:SCRIPT])
-      assert_equal([], argv)
-
-      argv = %w[-- -]
-      IRB.setup(eval("__FILE__"), argv: argv)
-      assert_equal('-', IRB.conf[:SCRIPT])
-      assert_equal([], argv)
-
-      argv = %w[-- - -f]
-      IRB.setup(eval("__FILE__"), argv: argv)
-      assert_equal('-', IRB.conf[:SCRIPT])
-      assert_equal(['-f'], argv)
-    end
-
-    def test_option_tracer
-      argv = %w[--tracer]
-      IRB.setup(eval("__FILE__"), argv: argv)
-      assert_equal(true, IRB.conf[:USE_TRACER])
-    end
-
-    private
-
-    def with_argv(argv)
-      orig = ARGV.dup
-      ARGV.replace(argv)
-      yield
-    ensure
-      ARGV.replace(orig)
-    end
-  end
-
-  class ConfigValidationTest < TestCase
-    def setup
-      # To prevent the test from using the user's .irbrc file
-      @home = Dir.mktmpdir
-      setup_envs(home: @home)
-      super
-    end
-
-    def teardown
-      super
-      teardown_envs
-      File.unlink(@irbrc)
-      Dir.rmdir(@home)
-      IRB.instance_variable_set(:@existing_rc_name_generators, nil)
-    end
-
-    def test_irb_name_converts_non_string_values_to_string
-      assert_no_irb_validation_error(<<~'RUBY')
-        IRB.conf[:IRB_NAME] = :foo
-      RUBY
-
-      assert_equal "foo", IRB.conf[:IRB_NAME]
-    end
-
-    def test_irb_rc_name_only_takes_callable_objects
-      assert_irb_validation_error(<<~'RUBY', "IRB.conf[:IRB_RC] should be a callable object. Got :foo.")
-        IRB.conf[:IRB_RC] = :foo
-      RUBY
-    end
-
-    def test_back_trace_limit_only_accepts_integers
-      assert_irb_validation_error(<<~'RUBY', "IRB.conf[:BACK_TRACE_LIMIT] should be an integer. Got \"foo\".")
-        IRB.conf[:BACK_TRACE_LIMIT] = "foo"
-      RUBY
-    end
-
-    def test_prompt_only_accepts_hash
-      assert_irb_validation_error(<<~'RUBY', "IRB.conf[:PROMPT] should be a Hash. Got \"foo\".")
-        IRB.conf[:PROMPT] = "foo"
-      RUBY
-    end
-
-    def test_eval_history_only_accepts_integers
-      assert_irb_validation_error(<<~'RUBY', "IRB.conf[:EVAL_HISTORY] should be an integer. Got \"foo\".")
-        IRB.conf[:EVAL_HISTORY] = "foo"
-      RUBY
-    end
-
-    private
-
-    def assert_irb_validation_error(rc_content, error_message)
-      write_rc rc_content
-
-      assert_raise_with_message(TypeError, error_message) do
-        IRB.setup(__FILE__)
-      end
-    end
-
-    def assert_no_irb_validation_error(rc_content)
-      write_rc rc_content
-
-      assert_nothing_raised do
-        IRB.setup(__FILE__)
-      end
-    end
-
-    def write_rc(content)
-      @irbrc = Tempfile.new('irbrc')
-      @irbrc.write(content)
-      @irbrc.close
-      ENV['IRBRC'] = @irbrc.path
-    end
-  end
-
-  class InitIntegrationTest < IntegrationTestCase
-    def setup
-      super
-
-      write_ruby <<~'RUBY'
-        binding.irb
-      RUBY
-    end
-
-    def test_load_error_in_rc_file_is_warned
-      write_rc <<~'IRBRC'
-        require "file_that_does_not_exist"
-      IRBRC
-
-      output = run_ruby_file do
-        type "'foobar'"
-        type "exit"
-      end
-
-      # IRB session should still be started
-      assert_includes output, "foobar"
-      assert_includes output, 'cannot load such file -- file_that_does_not_exist (LoadError)'
-    end
-
-    def test_normal_errors_in_rc_file_is_warned
-      write_rc <<~'IRBRC'
-        raise "I'm an error"
-      IRBRC
-
-      output = run_ruby_file do
-        type "'foobar'"
-        type "exit"
-      end
-
-      # IRB session should still be started
-      assert_includes output, "foobar"
-      assert_includes output, 'I\'m an error (RuntimeError)'
-    end
-  end
-end
diff --git a/test/mri/irb/test_input_method.rb b/test/mri/irb/test_input_method.rb
deleted file mode 100644
index bd107551df4..00000000000
--- a/test/mri/irb/test_input_method.rb
+++ /dev/null
@@ -1,195 +0,0 @@
-# frozen_string_literal: false
-
-require "irb"
-begin
-  require "rdoc"
-rescue LoadError
-end
-require_relative "helper"
-
-module TestIRB
-  class InputMethodTest < TestCase
-    def setup
-      @conf_backup = IRB.conf.dup
-      IRB.init_config(nil)
-      IRB.conf[:LC_MESSAGES] = IRB::Locale.new
-      save_encodings
-    end
-
-    def teardown
-      IRB.conf.replace(@conf_backup)
-      restore_encodings
-      # Reset Reline configuration overridden by RelineInputMethod.
-      Reline.instance_variable_set(:@core, nil)
-    end
-  end
-
-  class RelineInputMethodTest < InputMethodTest
-    def test_initialization
-      Reline.completion_proc = nil
-      Reline.dig_perfect_match_proc = nil
-      IRB::RelineInputMethod.new(IRB::RegexpCompletor.new)
-
-      assert_nil Reline.completion_append_character
-      assert_equal '', Reline.completer_quote_characters
-      assert_equal IRB::InputMethod::BASIC_WORD_BREAK_CHARACTERS, Reline.basic_word_break_characters
-      assert_not_nil Reline.completion_proc
-      assert_not_nil Reline.dig_perfect_match_proc
-    end
-
-    def test_colorize
-      IRB.conf[:USE_COLORIZE] = true
-      IRB.conf[:VERBOSE] = false
-      original_colorable = IRB::Color.method(:colorable?)
-      IRB::Color.instance_eval { undef :colorable? }
-      IRB::Color.define_singleton_method(:colorable?) { true }
-      workspace = IRB::WorkSpace.new(binding)
-      input_method = IRB::RelineInputMethod.new(IRB::RegexpCompletor.new)
-      IRB.conf[:MAIN_CONTEXT] = IRB::Irb.new(workspace, input_method).context
-      assert_equal "\e[1m$\e[0m\e[m", Reline.output_modifier_proc.call('$', complete: false)
-      assert_equal "\e[1m$\e[0m\e[m  \e[34m\e[1m1\e[0m + \e[34m\e[1m2\e[0m", Reline.output_modifier_proc.call('$  1 + 2', complete: false)
-      assert_equal "\e[32m\e[1m$a\e[0m", Reline.output_modifier_proc.call('$a', complete: false)
-    ensure
-      IRB::Color.instance_eval { undef :colorable? }
-      IRB::Color.define_singleton_method(:colorable?, original_colorable)
-    end
-
-    def test_initialization_without_use_autocomplete
-      original_show_doc_proc = Reline.dialog_proc(:show_doc)&.dialog_proc
-      empty_proc = Proc.new {}
-      Reline.add_dialog_proc(:show_doc, empty_proc)
-
-      IRB.conf[:USE_AUTOCOMPLETE] = false
-
-      IRB::RelineInputMethod.new(IRB::RegexpCompletor.new)
-
-      refute Reline.autocompletion
-      assert_equal empty_proc, Reline.dialog_proc(:show_doc).dialog_proc
-    ensure
-      Reline.add_dialog_proc(:show_doc, original_show_doc_proc, Reline::DEFAULT_DIALOG_CONTEXT)
-    end
-
-    def test_initialization_with_use_autocomplete
-      omit 'This test requires RDoc' unless defined?(RDoc)
-      original_show_doc_proc = Reline.dialog_proc(:show_doc)&.dialog_proc
-      empty_proc = Proc.new {}
-      Reline.add_dialog_proc(:show_doc, empty_proc)
-
-      IRB.conf[:USE_AUTOCOMPLETE] = true
-
-      IRB::RelineInputMethod.new(IRB::RegexpCompletor.new)
-
-      assert Reline.autocompletion
-      assert_not_equal empty_proc, Reline.dialog_proc(:show_doc).dialog_proc
-    ensure
-      Reline.add_dialog_proc(:show_doc, original_show_doc_proc, Reline::DEFAULT_DIALOG_CONTEXT)
-    end
-
-    def test_initialization_with_use_autocomplete_but_without_rdoc
-      original_show_doc_proc = Reline.dialog_proc(:show_doc)&.dialog_proc
-      empty_proc = Proc.new {}
-      Reline.add_dialog_proc(:show_doc, empty_proc)
-
-      IRB.conf[:USE_AUTOCOMPLETE] = true
-
-      without_rdoc do
-        IRB::RelineInputMethod.new(IRB::RegexpCompletor.new)
-      end
-
-      assert Reline.autocompletion
-      # doesn't register show_doc dialog
-      assert_equal empty_proc, Reline.dialog_proc(:show_doc).dialog_proc
-    ensure
-      Reline.add_dialog_proc(:show_doc, original_show_doc_proc, Reline::DEFAULT_DIALOG_CONTEXT)
-    end
-  end
-
-  class DisplayDocumentTest < InputMethodTest
-    def setup
-      super
-      @driver = RDoc::RI::Driver.new(use_stdout: true)
-    end
-
-    def display_document(target, bind, driver = nil)
-      input_method = IRB::RelineInputMethod.new(IRB::RegexpCompletor.new)
-      input_method.instance_variable_set(:@rdoc_ri_driver, driver) if driver
-      input_method.instance_variable_set(:@completion_params, ['', target, '', bind])
-      input_method.display_document(target)
-    end
-
-    def test_perfectly_matched_namespace_triggers_document_display
-      omit unless has_rdoc_content?
-
-      out, err = capture_output do
-        display_document("String", binding, @driver)
-      end
-
-      assert_empty(err)
-
-      assert_include(out, " S\bSt\btr\bri\bin\bng\bg")
-    end
-
-    def test_perfectly_matched_multiple_namespaces_triggers_document_display
-      result = nil
-      out, err = capture_output do
-        result = display_document("{}.nil?", binding, @driver)
-      end
-
-      assert_empty(err)
-
-      # check if there're rdoc contents (e.g. CI doesn't generate them)
-      if has_rdoc_content?
-        # if there's rdoc content, we can verify by checking stdout
-        # rdoc generates control characters for formatting method names
-        assert_include(out, "P\bPr\bro\boc\bc.\b.n\bni\bil\bl?\b?") # Proc.nil?
-        assert_include(out, "H\bHa\bas\bsh\bh.\b.n\bni\bil\bl?\b?") # Hash.nil?
-      else
-        # this is a hacky way to verify the rdoc rendering code path because CI doesn't have rdoc content
-        # if there are multiple namespaces to be rendered, PerfectMatchedProc renders the result with a document
-        # which always returns the bytes rendered, even if it's 0
-        assert_equal(0, result)
-      end
-    end
-
-    def test_not_matched_namespace_triggers_nothing
-      result = nil
-      out, err = capture_output do
-        result = display_document("Stri", binding, @driver)
-      end
-
-      assert_empty(err)
-      assert_empty(out)
-      assert_nil(result)
-    end
-
-    def test_perfect_matching_stops_without_rdoc
-      result = nil
-
-      out, err = capture_output do
-        without_rdoc do
-          result = display_document("String", binding)
-        end
-      end
-
-      assert_empty(err)
-      assert_not_match(/from ruby core/, out)
-      assert_nil(result)
-    end
-
-    def test_perfect_matching_handles_nil_namespace
-      out, err = capture_output do
-        # symbol literal has `nil` doc namespace so it's a good test subject
-        assert_nil(display_document(":aiueo", binding, @driver))
-      end
-
-      assert_empty(err)
-      assert_empty(out)
-    end
-
-    private
-
-    def has_rdoc_content?
-      File.exist?(RDoc::RI::Paths::BASE)
-    end
-  end if defined?(RDoc)
-end
diff --git a/test/mri/irb/test_irb.rb b/test/mri/irb/test_irb.rb
deleted file mode 100644
index 617e9c9614b..00000000000
--- a/test/mri/irb/test_irb.rb
+++ /dev/null
@@ -1,936 +0,0 @@
-# frozen_string_literal: true
-require "irb"
-
-require_relative "helper"
-
-module TestIRB
-  class InputTest < IntegrationTestCase
-    def test_symbol_aliases_are_handled_correctly
-      write_ruby <<~'RUBY'
-        class Foo
-        end
-        binding.irb
-      RUBY
-
-      output = run_ruby_file do
-        type "$ Foo"
-        type "exit!"
-      end
-
-      assert_include output, "From: #{@ruby_file.path}:1"
-    end
-
-    def test_symbol_aliases_are_handled_correctly_with_singleline_mode
-      write_rc <<~RUBY
-        IRB.conf[:USE_SINGLELINE] = true
-      RUBY
-
-      write_ruby <<~'RUBY'
-        class Foo
-        end
-        binding.irb
-      RUBY
-
-      output = run_ruby_file do
-        type "irb_info"
-        type "$ Foo"
-        type "exit!"
-      end
-
-      # Make sure it's tested in singleline mode
-      assert_include output, "InputMethod: ReadlineInputMethod"
-      assert_include output, "From: #{@ruby_file.path}:1"
-    end
-
-    def test_underscore_stores_last_result
-      write_ruby <<~'RUBY'
-        binding.irb
-      RUBY
-
-      output = run_ruby_file do
-        type "1 + 1"
-        type "_ + 10"
-        type "exit!"
-      end
-
-      assert_include output, "=> 12"
-    end
-
-    def test_commands_dont_override_stored_last_result
-      write_ruby <<~'RUBY'
-        binding.irb
-      RUBY
-
-      output = run_ruby_file do
-        type "1 + 1"
-        type "ls"
-        type "_ + 10"
-        type "exit!"
-      end
-
-      assert_include output, "=> 12"
-    end
-
-    def test_evaluate_with_encoding_error_without_lineno
-      if RUBY_ENGINE == 'truffleruby'
-        omit "Remove me after https://github.com/ruby/prism/issues/2129 is addressed and adopted in TruffleRuby"
-      end
-
-      if RUBY_VERSION >= "3.3."
-        omit "Now raises SyntaxError"
-      end
-
-      write_ruby <<~'RUBY'
-        binding.irb
-      RUBY
-
-      output = run_ruby_file do
-        type %q[:"\xAE"]
-        type "exit!"
-      end
-
-      assert_include output, 'invalid symbol in encoding UTF-8 :"\xAE"'
-      # EncodingError would be wrapped with ANSI escape sequences, so we assert it separately
-      assert_include output, "EncodingError"
-    end
-
-    def test_evaluate_still_emits_warning
-      write_ruby <<~'RUBY'
-        binding.irb
-      RUBY
-
-      output = run_ruby_file do
-        type %q[def foo; END {}; end]
-        type "exit!"
-      end
-
-      assert_include output, '(irb):1: warning: END in method; use at_exit'
-    end
-
-    def test_symbol_aliases_dont_affect_ruby_syntax
-      write_ruby <<~'RUBY'
-        $foo = "It's a foo"
-        @bar = "It's a bar"
-        binding.irb
-      RUBY
-
-      output = run_ruby_file do
-        type "$foo"
-        type "@bar"
-        type "exit!"
-      end
-
-      assert_include output, "=> \"It's a foo\""
-      assert_include output, "=> \"It's a bar\""
-    end
-
-    def test_empty_input_echoing_behaviour
-      write_ruby <<~'RUBY'
-        binding.irb
-      RUBY
-
-      output = run_ruby_file do
-        type ""
-        type "  "
-        type "exit"
-      end
-
-      assert_not_match(/irb$main$:001> (\r*\n)?=> nil/, output)
-      assert_match(/irb$main$:002>   (\r*\n)?=> nil/, output)
-    end
-  end
-
-  class NestedBindingIrbTest < IntegrationTestCase
-    def test_current_context_restore
-      write_ruby <<~'RUBY'
-        binding.irb
-      RUBY
-
-      output = run_ruby_file do
-        type '$ctx = IRB.CurrentContext'
-        type 'binding.irb'
-        type 'p context_changed: IRB.CurrentContext != $ctx'
-        type 'exit'
-        type 'p context_restored: IRB.CurrentContext == $ctx'
-        type 'exit'
-      end
-
-      assert_include output, {context_changed: true}.inspect
-      assert_include output, {context_restored: true}.inspect
-    end
-  end
-
-  class IrbIOConfigurationTest < TestCase
-    Row = Struct.new(:content, :current_line_spaces, :new_line_spaces, :indent_level)
-
-    class MockIO_AutoIndent
-      attr_reader :calculated_indent
-
-      def initialize(*params)
-        @params = params
-      end
-
-      def auto_indent(&block)
-        @calculated_indent = block.call(*@params)
-      end
-    end
-
-    class MockIO_DynamicPrompt
-      attr_reader :prompt_list
-
-      def initialize(params, &assertion)
-        @params = params
-      end
-
-      def dynamic_prompt(&block)
-        @prompt_list = block.call(@params)
-      end
-    end
-
-    def setup
-      save_encodings
-      @irb = build_irb
-    end
-
-    def teardown
-      restore_encodings
-    end
-
-    class AutoIndentationTest < IrbIOConfigurationTest
-      def test_auto_indent
-        input_with_correct_indents = [
-          [%q(def each_top_level_statement), 0, 2],
-          [%q(  initialize_input), 2, 2],
-          [%q(  catch(:TERM_INPUT) do), 2, 4],
-          [%q(    loop do), 4, 6],
-          [%q(      begin), 6, 8],
-          [%q(        prompt), 8, 8],
-          [%q(        unless l = lex), 8, 10],
-          [%q(          throw :TERM_INPUT if @line == ''), 10, 10],
-          [%q(        else), 8, 10],
-          [%q(          @line_no += l.count("\n")), 10, 10],
-          [%q(          next if l == "\n"), 10, 10],
-          [%q(          @line.concat l), 10, 10],
-          [%q(          if @code_block_open or @ltype or @continue or @indent > 0), 10, 12],
-          [%q(            next), 12, 12],
-          [%q(          end), 10, 10],
-          [%q(        end), 8, 8],
-          [%q(        if @line != "\n"), 8, 10],
-          [%q(          @line.force_encoding(@io.encoding)), 10, 10],
-          [%q(          yield @line, @exp_line_no), 10, 10],
-          [%q(        end), 8, 8],
-          [%q(        break if @io.eof?), 8, 8],
-          [%q(        @line = ''), 8, 8],
-          [%q(        @exp_line_no = @line_no), 8, 8],
-          [%q(        ), nil, 8],
-          [%q(        @indent = 0), 8, 8],
-          [%q(      rescue TerminateLineInput), 6, 8],
-          [%q(        initialize_input), 8, 8],
-          [%q(        prompt), 8, 8],
-          [%q(      end), 6, 6],
-          [%q(    end), 4, 4],
-          [%q(  end), 2, 2],
-          [%q(end), 0, 0],
-        ]
-
-        assert_rows_with_correct_indents(input_with_correct_indents)
-      end
-
-      def test_braces_on_their_own_line
-        input_with_correct_indents = [
-          [%q(if true), 0, 2],
-          [%q(  [), 2, 4],
-          [%q(  ]), 2, 2],
-          [%q(end), 0, 0],
-        ]
-
-        assert_rows_with_correct_indents(input_with_correct_indents)
-      end
-
-      def test_multiple_braces_in_a_line
-        input_with_correct_indents = [
-          [%q([[[), 0, 6],
-          [%q(    ]), 4, 4],
-          [%q(  ]), 2, 2],
-          [%q(]), 0, 0],
-          [%q([<<FOO]), 0, 0],
-          [%q(hello), 0, 0],
-          [%q(FOO), 0, 0],
-        ]
-
-        assert_rows_with_correct_indents(input_with_correct_indents)
-      end
-
-      def test_a_closed_brace_and_not_closed_brace_in_a_line
-        input_with_correct_indents = [
-          [%q(p() {), 0, 2],
-          [%q(}), 0, 0],
-        ]
-
-        assert_rows_with_correct_indents(input_with_correct_indents)
-      end
-
-      def test_symbols
-        input_with_correct_indents = [
-          [%q(:a), 0, 0],
-          [%q(:A), 0, 0],
-          [%q(:+), 0, 0],
-          [%q(:@@a), 0, 0],
-          [%q(:@a), 0, 0],
-          [%q(:$a), 0, 0],
-          [%q(:def), 0, 0],
-          [%q(:`), 0, 0],
-        ]
-
-        assert_rows_with_correct_indents(input_with_correct_indents)
-      end
-
-      def test_incomplete_coding_magic_comment
-        input_with_correct_indents = [
-          [%q(#coding:u), 0, 0],
-        ]
-
-        assert_rows_with_correct_indents(input_with_correct_indents)
-      end
-
-      def test_incomplete_encoding_magic_comment
-        input_with_correct_indents = [
-          [%q(#encoding:u), 0, 0],
-        ]
-
-        assert_rows_with_correct_indents(input_with_correct_indents)
-      end
-
-      def test_incomplete_emacs_coding_magic_comment
-        input_with_correct_indents = [
-          [%q(# -*- coding: u), 0, 0],
-        ]
-
-        assert_rows_with_correct_indents(input_with_correct_indents)
-      end
-
-      def test_incomplete_vim_coding_magic_comment
-        input_with_correct_indents = [
-          [%q(# vim:set fileencoding=u), 0, 0],
-        ]
-
-        assert_rows_with_correct_indents(input_with_correct_indents)
-      end
-
-      def test_mixed_rescue
-        input_with_correct_indents = [
-          [%q(def m), 0, 2],
-          [%q(  begin), 2, 4],
-          [%q(    begin), 4, 6],
-          [%q(      x = a rescue 4), 6, 6],
-          [%q(      y = [(a rescue 5)]), 6, 6],
-          [%q(      [x, y]), 6, 6],
-          [%q(    rescue => e), 4, 6],
-          [%q(      raise e rescue 8), 6, 6],
-          [%q(    end), 4, 4],
-          [%q(  rescue), 2, 4],
-          [%q(    raise rescue 11), 4, 4],
-          [%q(  end), 2, 2],
-          [%q(rescue => e), 0, 2],
-          [%q(  raise e rescue 14), 2, 2],
-          [%q(end), 0, 0],
-        ]
-
-        assert_rows_with_correct_indents(input_with_correct_indents)
-      end
-
-      def test_oneliner_method_definition
-        input_with_correct_indents = [
-          [%q(class A), 0, 2],
-          [%q(  def foo0), 2, 4],
-          [%q(    3), 4, 4],
-          [%q(  end), 2, 2],
-          [%q(  def foo1()), 2, 4],
-          [%q(    3), 4, 4],
-          [%q(  end), 2, 2],
-          [%q(  def foo2(a, b)), 2, 4],
-          [%q(    a + b), 4, 4],
-          [%q(  end), 2, 2],
-          [%q(  def foo3 a, b), 2, 4],
-          [%q(    a + b), 4, 4],
-          [%q(  end), 2, 2],
-          [%q(  def bar0() = 3), 2, 2],
-          [%q(  def bar1(a) = a), 2, 2],
-          [%q(  def bar2(a, b) = a + b), 2, 2],
-          [%q(  def bar3() = :s), 2, 2],
-          [%q(  def bar4() = Time.now), 2, 2],
-          [%q(end), 0, 0],
-        ]
-
-        assert_rows_with_correct_indents(input_with_correct_indents)
-      end
-
-      def test_tlambda
-        input_with_correct_indents = [
-          [%q(if true), 0, 2, 1],
-          [%q(  -> {), 2, 4, 2],
-          [%q(  }), 2, 2, 1],
-          [%q(end), 0, 0, 0],
-        ]
-
-        assert_rows_with_correct_indents(input_with_correct_indents, assert_indent_level: true)
-      end
-
-      def test_corresponding_syntax_to_keyword_do_in_class
-        input_with_correct_indents = [
-          [%q(class C), 0, 2, 1],
-          [%q(  while method_name do), 2, 4, 2],
-          [%q(    3), 4, 4, 2],
-          [%q(  end), 2, 2, 1],
-          [%q(  foo do), 2, 4, 2],
-          [%q(    3), 4, 4, 2],
-          [%q(  end), 2, 2, 1],
-          [%q(end), 0, 0, 0],
-        ]
-
-        assert_rows_with_correct_indents(input_with_correct_indents, assert_indent_level: true)
-      end
-
-      def test_corresponding_syntax_to_keyword_do
-        input_with_correct_indents = [
-          [%q(while i > 0), 0, 2, 1],
-          [%q(  3), 2, 2, 1],
-          [%q(end), 0, 0, 0],
-          [%q(while true), 0, 2, 1],
-          [%q(  3), 2, 2, 1],
-          [%q(end), 0, 0, 0],
-          [%q(while ->{i > 0}.call), 0, 2, 1],
-          [%q(  3), 2, 2, 1],
-          [%q(end), 0, 0, 0],
-          [%q(while ->{true}.call), 0, 2, 1],
-          [%q(  3), 2, 2, 1],
-          [%q(end), 0, 0, 0],
-          [%q(while i > 0 do), 0, 2, 1],
-          [%q(  3), 2, 2, 1],
-          [%q(end), 0, 0, 0],
-          [%q(while true do), 0, 2, 1],
-          [%q(  3), 2, 2, 1],
-          [%q(end), 0, 0, 0],
-          [%q(while ->{i > 0}.call do), 0, 2, 1],
-          [%q(  3), 2, 2, 1],
-          [%q(end), 0, 0, 0],
-          [%q(while ->{true}.call do), 0, 2, 1],
-          [%q(  3), 2, 2, 1],
-          [%q(end), 0, 0, 0],
-          [%q(foo do), 0, 2, 1],
-          [%q(  3), 2, 2, 1],
-          [%q(end), 0, 0, 0],
-          [%q(foo true do), 0, 2, 1],
-          [%q(  3), 2, 2, 1],
-          [%q(end), 0, 0, 0],
-          [%q(foo ->{true} do), 0, 2, 1],
-          [%q(  3), 2, 2, 1],
-          [%q(end), 0, 0, 0],
-          [%q(foo ->{i > 0} do), 0, 2, 1],
-          [%q(  3), 2, 2, 1],
-          [%q(end), 0, 0, 0],
-        ]
-
-        assert_rows_with_correct_indents(input_with_correct_indents, assert_indent_level: true)
-      end
-
-      def test_corresponding_syntax_to_keyword_for
-        input_with_correct_indents = [
-          [%q(for i in [1]), 0, 2, 1],
-          [%q(  puts i), 2, 2, 1],
-          [%q(end), 0, 0, 0],
-        ]
-
-        assert_rows_with_correct_indents(input_with_correct_indents, assert_indent_level: true)
-      end
-
-      def test_corresponding_syntax_to_keyword_for_with_do
-        input_with_correct_indents = [
-          [%q(for i in [1] do), 0, 2, 1],
-          [%q(  puts i), 2, 2, 1],
-          [%q(end), 0, 0, 0],
-        ]
-
-        assert_rows_with_correct_indents(input_with_correct_indents, assert_indent_level: true)
-      end
-
-      def test_typing_incomplete_include_interpreted_as_keyword_in
-        input_with_correct_indents = [
-          [%q(module E), 0, 2, 1],
-          [%q(end), 0, 0, 0],
-          [%q(class A), 0, 2, 1],
-          [%q(  in), 2, 2, 1] # scenario typing `include E`
-        ]
-
-        assert_rows_with_correct_indents(input_with_correct_indents, assert_indent_level: true)
-
-      end
-
-      def test_bracket_corresponding_to_times
-        input_with_correct_indents = [
-          [%q(3.times { |i|), 0, 2, 1],
-          [%q(  puts i), 2, 2, 1],
-          [%q(}), 0, 0, 0],
-        ]
-
-        assert_rows_with_correct_indents(input_with_correct_indents, assert_indent_level: true)
-      end
-
-      def test_do_corresponding_to_times
-        input_with_correct_indents = [
-          [%q(3.times do |i|), 0, 2, 1],
-          [%q(  puts i), 2, 2, 1],
-          [%q(end), 0, 0, 0],
-        ]
-
-        assert_rows_with_correct_indents(input_with_correct_indents, assert_indent_level: true)
-      end
-
-      def test_bracket_corresponding_to_loop
-        input_with_correct_indents = [
-          ['loop {', 0, 2, 1],
-          ['  3', 2, 2, 1],
-          ['}', 0, 0, 0],
-        ]
-
-        assert_rows_with_correct_indents(input_with_correct_indents, assert_indent_level: true)
-      end
-
-      def test_do_corresponding_to_loop
-        input_with_correct_indents = [
-          [%q(loop do), 0, 2, 1],
-          [%q(  3), 2, 2, 1],
-          [%q(end), 0, 0, 0],
-        ]
-
-        assert_rows_with_correct_indents(input_with_correct_indents, assert_indent_level: true)
-      end
-
-      def test_embdoc_indent
-        input_with_correct_indents = [
-          [%q(=begin), 0, 0, 0],
-          [%q(a), 0, 0, 0],
-          [%q( b), 1, 1, 0],
-          [%q(=end), 0, 0, 0],
-          [%q(if 1), 0, 2, 1],
-          [%q(  2), 2, 2, 1],
-          [%q(=begin), 0, 0, 0],
-          [%q(a), 0, 0, 0],
-          [%q( b), 1, 1, 0],
-          [%q(=end), 0, 2, 1],
-          [%q(  3), 2, 2, 1],
-          [%q(end), 0, 0, 0],
-        ]
-
-        assert_rows_with_correct_indents(input_with_correct_indents, assert_indent_level: true)
-      end
-
-      def test_heredoc_with_indent
-        input_with_correct_indents = [
-          [%q(<<~Q+<<~R), 0, 2, 1],
-          [%q(a), 2, 2, 1],
-          [%q(a), 2, 2, 1],
-          [%q(  b), 2, 2, 1],
-          [%q(  b), 2, 2, 1],
-          [%q(  Q), 0, 2, 1],
-          [%q(    c), 4, 4, 1],
-          [%q(    c), 4, 4, 1],
-          [%q(    R), 0, 0, 0],
-        ]
-
-        assert_rows_with_correct_indents(input_with_correct_indents, assert_indent_level: true)
-      end
-
-      def test_oneliner_def_in_multiple_lines
-        input_with_correct_indents = [
-          [%q(def a()=[), 0, 2, 1],
-          [%q(  1,), 2, 2, 1],
-          [%q(].), 0, 0, 0],
-          [%q(to_s), 0, 0, 0],
-        ]
-
-        assert_rows_with_correct_indents(input_with_correct_indents, assert_indent_level: true)
-      end
-
-      def test_broken_heredoc
-        input_with_correct_indents = [
-          [%q(def foo), 0, 2, 1],
-          [%q(  <<~Q), 2, 4, 2],
-          [%q(  Qend), 4, 4, 2],
-        ]
-
-        assert_rows_with_correct_indents(input_with_correct_indents, assert_indent_level: true)
-      end
-
-      def test_pasted_code_keep_base_indent_spaces
-        input_with_correct_indents = [
-          [%q(    def foo), 0, 6, 1],
-          [%q(        if bar), 6, 10, 2],
-          [%q(          [1), 10, 12, 3],
-          [%q(          ]+[["a), 10, 14, 4],
-          [%q(b" + `c), 0, 14, 4],
-          [%q(d` + /e), 0, 14, 4],
-          [%q(f/ + :"g), 0, 14, 4],
-          [%q(h".tap do), 0, 16, 5],
-          [%q(                1), 16, 16, 5],
-          [%q(              end), 14, 14, 4],
-          [%q(            ]), 12, 12, 3],
-          [%q(          ]), 10, 10, 2],
-          [%q(        end), 8, 6, 1],
-          [%q(    end), 4, 0, 0],
-        ]
-
-        assert_rows_with_correct_indents(input_with_correct_indents, assert_indent_level: true)
-      end
-
-      def test_pasted_code_keep_base_indent_spaces_with_heredoc
-        input_with_correct_indents = [
-          [%q(    def foo), 0, 6, 1],
-          [%q(        if bar), 6, 10, 2],
-          [%q(          [1), 10, 12, 3],
-          [%q(          ]+[["a), 10, 14, 4],
-          [%q(b" + <<~A + <<-B + <<C), 0, 16, 5],
-          [%q(                a#{), 16, 18, 6],
-          [%q(                1), 18, 18, 6],
-          [%q(                }), 16, 16, 5],
-          [%q(              A), 14, 16, 5],
-          [%q(                b#{), 16, 18, 6],
-          [%q(                1), 18, 18, 6],
-          [%q(                }), 16, 16, 5],
-          [%q(              B), 14, 0, 0],
-          [%q(c#{), 0, 2, 1],
-          [%q(1), 2, 2, 1],
-          [%q(}), 0, 0, 0],
-          [%q(C), 0, 14, 4],
-          [%q(            ]), 12, 12, 3],
-          [%q(          ]), 10, 10, 2],
-          [%q(        end), 8, 6, 1],
-          [%q(    end), 4, 0, 0],
-        ]
-
-        assert_rows_with_correct_indents(input_with_correct_indents, assert_indent_level: true)
-      end
-
-      def test_heredoc_keep_indent_spaces
-        (1..4).each do |indent|
-          row = Row.new(' ' * indent, nil, [4, indent].max, 2)
-          lines = ['def foo', '  <<~Q', row.content]
-          assert_row_indenting(lines, row)
-          assert_indent_level(lines, row.indent_level)
-        end
-      end
-
-      private
-
-      def assert_row_indenting(lines, row)
-        actual_current_line_spaces = calculate_indenting(lines, false)
-
-        error_message = <<~MSG
-          Incorrect spaces calculation for line:
-
-          ```
-        > #{lines.last}
-          ```
-
-          All lines:
-
-          ```
-          #{lines.join("\n")}
-          ```
-        MSG
-        assert_equal(row.current_line_spaces, actual_current_line_spaces, error_message)
-
-        error_message = <<~MSG
-          Incorrect spaces calculation for line after the current line:
-
-          ```
-          #{lines.last}
-        >
-          ```
-
-          All lines:
-
-          ```
-          #{lines.join("\n")}
-          ```
-        MSG
-        actual_next_line_spaces = calculate_indenting(lines, true)
-        assert_equal(row.new_line_spaces, actual_next_line_spaces, error_message)
-      end
-
-      def assert_rows_with_correct_indents(rows_with_spaces, assert_indent_level: false)
-        lines = []
-        rows_with_spaces.map do |row|
-          row = Row.new(*row)
-          lines << row.content
-          assert_row_indenting(lines, row)
-
-          if assert_indent_level
-            assert_indent_level(lines, row.indent_level)
-          end
-        end
-      end
-
-      def assert_indent_level(lines, expected)
-        code = lines.map { |l| "#{l}\n" }.join # code should end with "\n"
-        _tokens, opens, _ = @irb.scanner.check_code_state(code, local_variables: [])
-        indent_level = @irb.scanner.calc_indent_level(opens)
-        error_message = "Calculated the wrong number of indent level for:\n #{lines.join("\n")}"
-        assert_equal(expected, indent_level, error_message)
-      end
-
-      def calculate_indenting(lines, add_new_line)
-        lines = lines + [""] if add_new_line
-        last_line_index = lines.length - 1
-        byte_pointer = lines.last.length
-
-        mock_io = MockIO_AutoIndent.new(lines, last_line_index, byte_pointer, add_new_line)
-        @irb.context.auto_indent_mode = true
-        @irb.context.io = mock_io
-        @irb.configure_io
-
-        mock_io.calculated_indent
-      end
-    end
-
-    class DynamicPromptTest < IrbIOConfigurationTest
-      def test_endless_range_at_end_of_line
-        input_with_prompt = [
-          ['001:0: :> ', %q(a = 3..)],
-          ['002:0: :> ', %q()],
-        ]
-
-        assert_dynamic_prompt(input_with_prompt)
-      end
-
-      def test_heredoc_with_embexpr
-        input_with_prompt = [
-          ['001:0:":* ', %q(<<A+%W[#{<<B)],
-          ['002:0:":* ', %q(#{<<C+%W[)],
-          ['003:0:":* ', %q(a)],
-          ['004:2:]:* ', %q(C)],
-          ['005:2:]:* ', %q(a)],
-          ['006:0:":* ', %q(]})],
-          ['007:0:":* ', %q(})],
-          ['008:0:":* ', %q(A)],
-          ['009:2:]:* ', %q(B)],
-          ['010:1:]:* ', %q(})],
-          ['011:0: :> ', %q(])],
-          ['012:0: :> ', %q()],
-        ]
-
-        assert_dynamic_prompt(input_with_prompt)
-      end
-
-      def test_heredoc_prompt_with_quotes
-        input_with_prompt = [
-          ["001:1:':* ", %q(<<~'A')],
-          ["002:1:':* ", %q(#{foobar})],
-          ["003:0: :> ", %q(A)],
-          ["004:1:`:* ", %q(<<~`A`)],
-          ["005:1:`:* ", %q(whoami)],
-          ["006:0: :> ", %q(A)],
-          ['007:1:":* ', %q(<<~"A")],
-          ['008:1:":* ', %q(foobar)],
-          ['009:0: :> ', %q(A)],
-        ]
-
-        assert_dynamic_prompt(input_with_prompt)
-      end
-
-      def test_backtick_method
-        input_with_prompt = [
-          ['001:0: :> ', %q(self.`(arg))],
-          ['002:0: :> ', %q()],
-          ['003:0: :> ', %q(def `(); end)],
-          ['004:0: :> ', %q()],
-        ]
-
-        assert_dynamic_prompt(input_with_prompt)
-      end
-
-      def test_dynamic_prompt
-        input_with_prompt = [
-          ['001:1: :* ', %q(def hoge)],
-          ['002:1: :* ', %q(  3)],
-          ['003:0: :> ', %q(end)],
-        ]
-
-        assert_dynamic_prompt(input_with_prompt)
-      end
-
-      def test_dynamic_prompt_with_double_newline_breaking_code
-        input_with_prompt = [
-          ['001:1: :* ', %q(if true)],
-          ['002:2: :* ', %q(%)],
-          ['003:1: :* ', %q(;end)],
-          ['004:1: :* ', %q(;hello)],
-          ['005:0: :> ', %q(end)],
-        ]
-
-        assert_dynamic_prompt(input_with_prompt)
-      end
-
-      def test_dynamic_prompt_with_multiline_literal
-        input_with_prompt = [
-          ['001:1: :* ', %q(if true)],
-          ['002:2:]:* ', %q(  %w[)],
-          ['003:2:]:* ', %q(  a)],
-          ['004:1: :* ', %q(  ])],
-          ['005:1: :* ', %q(  b)],
-          ['006:2:]:* ', %q(  %w[)],
-          ['007:2:]:* ', %q(  c)],
-          ['008:1: :* ', %q(  ])],
-          ['009:0: :> ', %q(end)],
-        ]
-
-        assert_dynamic_prompt(input_with_prompt)
-      end
-
-      def test_dynamic_prompt_with_blank_line
-        input_with_prompt = [
-          ['001:1:]:* ', %q(%w[)],
-          ['002:1:]:* ', %q()],
-          ['003:0: :> ', %q(])],
-        ]
-
-        assert_dynamic_prompt(input_with_prompt)
-      end
-
-      def assert_dynamic_prompt(input_with_prompt)
-        expected_prompt_list, lines = input_with_prompt.transpose
-        def @irb.generate_prompt(opens, continue, line_offset)
-          ltype = @scanner.ltype_from_open_tokens(opens)
-          indent = @scanner.calc_indent_level(opens)
-          continue = opens.any? || continue
-          line_no = @line_no + line_offset
-          '%03d:%01d:%1s:%s ' % [line_no, indent, ltype, continue ? '*' : '>']
-        end
-        io = MockIO_DynamicPrompt.new(lines)
-        @irb.context.io = io
-        @irb.configure_io
-
-        error_message = <<~EOM
-          Expected dynamic prompt:
-          #{expected_prompt_list.join("\n")}
-
-          Actual dynamic prompt:
-          #{io.prompt_list.join("\n")}
-        EOM
-        assert_equal(expected_prompt_list, io.prompt_list, error_message)
-      end
-    end
-
-    private
-
-    def build_binding
-      Object.new.instance_eval { binding }
-    end
-
-    def build_irb
-      IRB.init_config(nil)
-      workspace = IRB::WorkSpace.new(build_binding)
-
-      IRB.conf[:VERBOSE] = false
-      IRB::Irb.new(workspace, TestInputMethod.new)
-    end
-  end
-
-  class BacktraceFilteringTest < TestIRB::IntegrationTestCase
-    def setup
-      super
-      # These tests are sensitive to warnings, so we disable them
-      original_rubyopt = [ENV["RUBYOPT"], @envs["RUBYOPT"]].compact.join(" ")
-      @envs["RUBYOPT"] = original_rubyopt + " -W0"
-    end
-
-    def test_backtrace_filtering
-      write_ruby <<~'RUBY'
-        def foo
-          raise "error"
-        end
-
-        def bar
-          foo
-        end
-
-        binding.irb
-      RUBY
-
-      output = run_ruby_file do
-        type "bar"
-        type "exit"
-      end
-
-      assert_match(/irbtest-.*\.rb:2:in (`|'Object#)foo': error $RuntimeError$/, output)
-      frame_traces = output.split("\n").select { |line| line.strip.match?(/from /) }.map(&:strip)
-
-      expected_traces = if RUBY_VERSION >= "3.3.0"
-        [
-          /from .*\/irbtest-.*.rb:6:in (`|'Object#)bar'/,
-          /from .*\/irbtest-.*.rb$irb$:1:in [`']<main>'/,
-          /from <internal:kernel>:\d+:in (`|'Kernel#)loop'/,
-          /from <internal:prelude>:\d+:in (`|'Binding#)irb'/,
-          /from .*\/irbtest-.*.rb:9:in [`']<main>'/
-        ]
-      else
-        [
-          /from .*\/irbtest-.*.rb:6:in (`|'Object#)bar'/,
-          /from .*\/irbtest-.*.rb$irb$:1:in [`']<main>'/,
-          /from <internal:prelude>:\d+:in (`|'Binding#)irb'/,
-          /from .*\/irbtest-.*.rb:9:in [`']<main>'/
-        ]
-      end
-
-      expected_traces.reverse! if RUBY_VERSION < "3.0.0"
-
-      expected_traces.each_with_index do |expected_trace, index|
-        assert_match(expected_trace, frame_traces[index])
-      end
-    end
-
-    def test_backtrace_filtering_with_backtrace_filter
-      write_rc <<~'RUBY'
-        class TestBacktraceFilter
-          def self.call(backtrace)
-            backtrace.reject { |line| line.include?("internal") }
-          end
-        end
-
-        IRB.conf[:BACKTRACE_FILTER] = TestBacktraceFilter
-      RUBY
-
-      write_ruby <<~'RUBY'
-        def foo
-          raise "error"
-        end
-
-        def bar
-          foo
-        end
-
-        binding.irb
-      RUBY
-
-      output = run_ruby_file do
-        type "bar"
-        type "exit"
-      end
-
-      assert_match(/irbtest-.*\.rb:2:in (`|'Object#)foo': error $RuntimeError$/, output)
-      frame_traces = output.split("\n").select { |line| line.strip.match?(/from /) }.map(&:strip)
-
-      expected_traces = [
-        /from .*\/irbtest-.*.rb:6:in (`|'Object#)bar'/,
-        /from .*\/irbtest-.*.rb$irb$:1:in [`']<main>'/,
-        /from .*\/irbtest-.*.rb:9:in [`']<main>'/
-      ]
-
-      expected_traces.reverse! if RUBY_VERSION < "3.0.0"
-
-      expected_traces.each_with_index do |expected_trace, index|
-        assert_match(expected_trace, frame_traces[index])
-      end
-    end
-  end
-end
diff --git a/test/mri/irb/test_locale.rb b/test/mri/irb/test_locale.rb
deleted file mode 100644
index 930a38834c1..00000000000
--- a/test/mri/irb/test_locale.rb
+++ /dev/null
@@ -1,118 +0,0 @@
-require "irb"
-require "stringio"
-
-require_relative "helper"
-
-module TestIRB
-  class LocaleTestCase < TestCase
-    def test_initialize_with_en
-      locale = IRB::Locale.new("en_US.UTF-8")
-
-      assert_equal("en", locale.lang)
-      assert_equal("US", locale.territory)
-      assert_equal("UTF-8", locale.encoding.name)
-      assert_equal(nil, locale.modifier)
-    end
-
-    def test_initialize_with_ja
-      locale = IRB::Locale.new("ja_JP.UTF-8")
-
-      assert_equal("ja", locale.lang)
-      assert_equal("JP", locale.territory)
-      assert_equal("UTF-8", locale.encoding.name)
-      assert_equal(nil, locale.modifier)
-    end
-
-    def test_initialize_with_legacy_ja_encoding_ujis
-      original_stderr = $stderr
-      $stderr = StringIO.new
-
-      locale = IRB::Locale.new("ja_JP.ujis")
-
-      assert_equal("ja", locale.lang)
-      assert_equal("JP", locale.territory)
-      assert_equal(Encoding::EUC_JP, locale.encoding)
-      assert_equal(nil, locale.modifier)
-
-      assert_include $stderr.string, "ja_JP.ujis is obsolete. use ja_JP.EUC-JP"
-    ensure
-      $stderr = original_stderr
-    end
-
-    def test_initialize_with_legacy_ja_encoding_euc
-      original_stderr = $stderr
-      $stderr = StringIO.new
-
-      locale = IRB::Locale.new("ja_JP.euc")
-
-      assert_equal("ja", locale.lang)
-      assert_equal("JP", locale.territory)
-      assert_equal(Encoding::EUC_JP, locale.encoding)
-      assert_equal(nil, locale.modifier)
-
-      assert_include $stderr.string, "ja_JP.euc is obsolete. use ja_JP.EUC-JP"
-    ensure
-      $stderr = original_stderr
-    end
-
-    %w(IRB_LANG LC_MESSAGES LC_ALL LANG).each do |env_var|
-      define_method "test_initialize_with_#{env_var.downcase}" do
-        original_values = {
-          "IRB_LANG" => ENV["IRB_LANG"],
-          "LC_MESSAGES" => ENV["LC_MESSAGES"],
-          "LC_ALL" => ENV["LC_ALL"],
-          "LANG" => ENV["LANG"],
-        }
-
-        ENV["IRB_LANG"] = ENV["LC_MESSAGES"] = ENV["LC_ALL"] = ENV["LANG"] = nil
-        ENV[env_var] = "zh_TW.UTF-8"
-
-        locale = IRB::Locale.new
-
-        assert_equal("zh", locale.lang)
-        assert_equal("TW", locale.territory)
-        assert_equal("UTF-8", locale.encoding.name)
-        assert_equal(nil, locale.modifier)
-      ensure
-        original_values.each do |key, value|
-          ENV[key] = value
-        end
-      end
-    end
-
-    def test_load
-      # reset Locale's internal cache
-      IRB::Locale.class_variable_set(:@@loaded, [])
-      # Because error.rb files define the same class, loading them causes method redefinition warnings.
-      original_verbose = $VERBOSE
-      $VERBOSE = nil
-
-      jp_local = IRB::Locale.new("ja_JP.UTF-8")
-      jp_local.load("irb/error.rb")
-      msg = IRB::CantReturnToNormalMode.new.message
-      assert_equal("Normalモードに戻れません.", msg)
-
-      # reset Locale's internal cache
-      IRB::Locale.class_variable_set(:@@loaded, [])
-
-      en_local = IRB::Locale.new("en_US.UTF-8")
-      en_local.load("irb/error.rb")
-      msg = IRB::CantReturnToNormalMode.new.message
-      assert_equal("Can't return to normal mode.", msg)
-    ensure
-      # before turning warnings back on, load the error.rb file again to avoid warnings in other tests
-      IRB::Locale.new.load("irb/error.rb")
-      $VERBOSE = original_verbose
-    end
-
-    def test_find
-      jp_local = IRB::Locale.new("ja_JP.UTF-8")
-      path = jp_local.find("irb/error.rb")
-      assert_include(path, "/lib/irb/lc/ja/error.rb")
-
-      en_local = IRB::Locale.new("en_US.UTF-8")
-      path = en_local.find("irb/error.rb")
-      assert_include(path, "/lib/irb/lc/error.rb")
-    end
-  end
-end
diff --git a/test/mri/irb/test_nesting_parser.rb b/test/mri/irb/test_nesting_parser.rb
deleted file mode 100644
index 6b4f54ee212..00000000000
--- a/test/mri/irb/test_nesting_parser.rb
+++ /dev/null
@@ -1,339 +0,0 @@
-# frozen_string_literal: false
-require 'irb'
-
-require_relative "helper"
-
-module TestIRB
-  class NestingParserTest < TestCase
-    def setup
-      save_encodings
-    end
-
-    def teardown
-      restore_encodings
-    end
-
-    def parse_by_line(code)
-      IRB::NestingParser.parse_by_line(IRB::RubyLex.ripper_lex_without_warning(code))
-    end
-
-    def test_open_tokens
-      code = <<~'EOS'
-        class A
-          def f
-            if true
-              tap do
-                {
-                  x: "
-                    #{p(1, 2, 3
-      EOS
-      opens = IRB::NestingParser.open_tokens(IRB::RubyLex.ripper_lex_without_warning(code))
-      assert_equal(%w[class def if do { " #{ (], opens.map(&:tok))
-    end
-
-    def test_parse_by_line
-      code = <<~EOS
-        (((((1+2
-        ).to_s())).tap do (((
-      EOS
-      _tokens, prev_opens, next_opens, min_depth = parse_by_line(code).last
-      assert_equal(%w[( ( ( ( (], prev_opens.map(&:tok))
-      assert_equal(%w[( ( do ( ( (], next_opens.map(&:tok))
-      assert_equal(2, min_depth)
-    end
-
-    def test_ruby_syntax
-      code = <<~'EOS'
-        class A
-          1 if 2
-          1 while 2
-          1 until 2
-          1 unless 2
-          1 rescue 2
-          begin; rescue; ensure; end
-          tap do; rescue; ensure; end
-          class B; end
-          module C; end
-          def f; end
-          def `; end
-          def f() = 1
-          %(); %w[]; %q(); %r{}; %i[]
-          "#{1}"; ''; /#{1}/; `#{1}`
-          p(``); p ``; p x: ``; p 1, ``;
-          :sym; :"sym"; :+; :`; :if
-          [1, 2, 3]
-          { x: 1, y: 2 }
-          (a, (*b, c), d), e = 1, 2, 3
-          ->(a){}; ->(a) do end
-          -> a = -> b = :do do end do end
-          if 1; elsif 2; else; end
-          unless 1; end
-          while 1; end
-          until 1; end
-          for i in j; end
-          case 1; when 2; end
-          puts(1, 2, 3)
-          loop{|i|}
-          loop do |i| end
-        end
-      EOS
-      line_results = parse_by_line(code)
-      assert_equal(code.lines.size, line_results.size)
-      class_open, *inner_line_results, class_close = line_results
-      assert_equal(['class'], class_open[2].map(&:tok))
-      inner_line_results.each {|result| assert_equal(['class'], result[2].map(&:tok)) }
-      assert_equal([], class_close[2].map(&:tok))
-    end
-
-    def test_multiline_string
-      code = <<~EOS
-        "
-        aaa
-        bbb
-        "
-        <<A
-        aaa
-        bbb
-        A
-      EOS
-      line_results = parse_by_line(code)
-      assert_equal(code.lines.size, line_results.size)
-      string_content_line, string_opens = line_results[1]
-      assert_equal("\naaa\nbbb\n", string_content_line.first.first.tok)
-      assert_equal("aaa\n", string_content_line.first.last)
-      assert_equal(['"'], string_opens.map(&:tok))
-      heredoc_content_line, heredoc_opens = line_results[6]
-      assert_equal("aaa\nbbb\n", heredoc_content_line.first.first.tok)
-      assert_equal("bbb\n", heredoc_content_line.first.last)
-      assert_equal(['<<A'], heredoc_opens.map(&:tok))
-      _line, _prev_opens, next_opens, _min_depth = line_results.last
-      assert_equal([], next_opens)
-    end
-
-    def test_backslash_continued_nested_symbol
-      code = <<~'EOS'
-        x = <<A, :\
-          heredoc #{
-            here
-          }
-        A
-        =begin
-        embdoc
-        =end
-        # comment
-
-        if # this is symbol :if
-        while
-      EOS
-      line_results = parse_by_line(code)
-      assert_equal(%w[: <<A #{], line_results[2][2].map(&:tok))
-      assert_equal(%w[while], line_results.last[2].map(&:tok))
-    end
-
-    def test_oneliner_def
-      code = <<~EOC
-        if true
-          # normal oneliner def
-          def f = 1
-          def f() = 1
-          def f(*) = 1
-          # keyword, backtick, op
-          def * = 1
-          def ` = 1
-          def if = 1
-          def *() = 1
-          def `() = 1
-          def if() = 1
-          # oneliner def with receiver
-          def a.* = 1
-          def $a.* = 1
-          def @a.` = 1
-          def A.` = 1
-          def ((a;b;c)).*() = 1
-          def ((a;b;c)).if() = 1
-          def ((a;b;c)).end() = 1
-          # multiline oneliner def
-          def f =
-          1
-          def f()
-          =
-          1
-          # oneliner def with comment and embdoc
-          def # comment
-        =begin
-        embdoc
-        =end
-            ((a;b;c))
-            . # comment
-        =begin
-        embdoc
-        =end
-            f (*) # comment
-        =begin
-        embdoc
-        =end
-          =
-          1
-          # nested oneliner def
-          def f(x = def f() = 1) = def f() = 1
-      EOC
-      _tokens, _prev_opens, next_opens, min_depth = parse_by_line(code).last
-      assert_equal(['if'], next_opens.map(&:tok))
-      assert_equal(1, min_depth)
-    end
-
-    def test_heredoc_embexpr
-      code = <<~'EOS'
-        <<A+<<B+<<C+(<<D+(<<E)
-          #{
-            <<~F+"#{<<~G}
-            #{
-              here
-            }
-            F
-            G
-            "
-          }
-        A
-        B
-        C
-        D
-        E
-        )
-      EOS
-      line_results = parse_by_line(code)
-      last_opens = line_results.last[-2]
-      assert_equal([], last_opens)
-      _tokens, _prev_opens, next_opens, _min_depth = line_results[4]
-      assert_equal(%w[( <<E <<D <<C <<B <<A #{ " <<~G <<~F #{], next_opens.map(&:tok))
-    end
-
-    def test_for_in
-      code = <<~EOS
-        for i in j
-          here
-        end
-        for i in j do
-          here
-        end
-        for i in
-          j do
-          here
-        end
-        for
-          # comment
-          i in j do
-          here
-        end
-        for (a;b;c).d in (a;b;c) do
-          here
-        end
-        for i in :in + :do do
-          here
-        end
-        for i in -> do end do
-          here
-        end
-      EOS
-      line_results = parse_by_line(code).select { |tokens,| tokens.map(&:last).include?('here') }
-      assert_equal(7, line_results.size)
-      line_results.each do |_tokens, _prev_opens, next_opens, _min_depth|
-        assert_equal(['for'], next_opens.map(&:tok))
-      end
-    end
-
-    def test_while_until
-      base_code = <<~'EOS'
-        while_or_until true
-          here
-        end
-        while_or_until a < c
-          here
-        end
-        while_or_until true do
-          here
-        end
-        while_or_until
-          # comment
-          (a + b) <
-          # comment
-          c do
-          here
-        end
-        while_or_until :\
-          do do
-          here
-        end
-        while_or_until def do; end == :do do
-          here
-        end
-        while_or_until -> do end do
-          here
-        end
-      EOS
-      %w[while until].each do |keyword|
-        code = base_code.gsub('while_or_until', keyword)
-        line_results = parse_by_line(code).select { |tokens,| tokens.map(&:last).include?('here') }
-        assert_equal(7, line_results.size)
-        line_results.each do |_tokens, _prev_opens, next_opens, _min_depth|
-          assert_equal([keyword], next_opens.map(&:tok) )
-        end
-      end
-    end
-
-    def test_undef_alias
-      codes = [
-        'undef foo',
-        'alias foo bar',
-        'undef !',
-        'alias + -',
-        'alias $a $b',
-        'undef do',
-        'alias do do',
-        'undef :do',
-        'alias :do :do',
-        'undef :"#{alias do do}"',
-        'alias :"#{undef do}" do',
-        'alias do :"#{undef do}"'
-      ]
-      code_with_comment = <<~EOS
-        undef #
-        #
-        do #
-        alias #
-        #
-        do #
-        #
-        do #
-      EOS
-      code_with_heredoc = <<~EOS
-        <<~A; alias
-        A
-        :"#{<<~A}"
-        A
-        do
-      EOS
-      [*codes, code_with_comment, code_with_heredoc].each do |code|
-        opens = IRB::NestingParser.open_tokens(IRB::RubyLex.ripper_lex_without_warning('(' + code + "\nif"))
-        assert_equal(%w[( if], opens.map(&:tok))
-      end
-    end
-
-    def test_case_in
-      code = <<~EOS
-        case 1
-        in 1
-          here
-        in
-          2
-          here
-        end
-      EOS
-      line_results = parse_by_line(code).select { |tokens,| tokens.map(&:last).include?('here') }
-      assert_equal(2, line_results.size)
-      line_results.each do |_tokens, _prev_opens, next_opens, _min_depth|
-        assert_equal(['in'], next_opens.map(&:tok))
-      end
-    end
-  end
-end
diff --git a/test/mri/irb/test_option.rb b/test/mri/irb/test_option.rb
deleted file mode 100644
index fec31f384f9..00000000000
--- a/test/mri/irb/test_option.rb
+++ /dev/null
@@ -1,13 +0,0 @@
-# frozen_string_literal: false
-require_relative "helper"
-
-module TestIRB
-  class OptionTest < TestCase
-    def test_end_of_option
-      bug4117 = '[ruby-core:33574]'
-      bundle_exec = ENV.key?('BUNDLE_GEMFILE') ? ['-rbundler/setup'] : []
-      status = assert_in_out_err(bundle_exec + %w[-W0 -rirb -e IRB.start(__FILE__) -- -f --], "", //, [], bug4117)
-      assert(status.success?, bug4117)
-    end
-  end
-end
diff --git a/test/mri/irb/test_raise_exception.rb b/test/mri/irb/test_raise_exception.rb
deleted file mode 100644
index 44a5ae87e18..00000000000
--- a/test/mri/irb/test_raise_exception.rb
+++ /dev/null
@@ -1,74 +0,0 @@
-# frozen_string_literal: false
-require "tmpdir"
-
-require_relative "helper"
-
-module TestIRB
-  class RaiseExceptionTest < TestCase
-    def test_raise_exception_with_nil_backtrace
-      bundle_exec = ENV.key?('BUNDLE_GEMFILE') ? ['-rbundler/setup'] : []
-      assert_in_out_err(bundle_exec + %w[-rirb -W0 -e IRB.start(__FILE__) -- -f --], <<-IRB, /#<Exception: foo>/, [])
-      raise Exception.new("foo").tap {|e| def e.backtrace; nil; end }
-IRB
-    end
-
-    def test_raise_exception_with_message_exception
-      bundle_exec = ENV.key?('BUNDLE_GEMFILE') ? ['-rbundler/setup'] : []
-      expected = /#<Exception: foo>\nbacktraces are hidden because bar was raised when processing them/
-      assert_in_out_err(bundle_exec + %w[-rirb -W0 -e IRB.start(__FILE__) -- -f --], <<-IRB, expected, [])
-      e = Exception.new("foo")
-      def e.message; raise 'bar'; end
-      raise e
-IRB
-    end
-
-    def test_raise_exception_with_message_inspect_exception
-      bundle_exec = ENV.key?('BUNDLE_GEMFILE') ? ['-rbundler/setup'] : []
-      expected = /Uninspectable exception occurred/
-      assert_in_out_err(bundle_exec + %w[-rirb -W0 -e IRB.start(__FILE__) -- -f --], <<-IRB, expected, [])
-      e = Exception.new("foo")
-      def e.message; raise; end
-      def e.inspect; raise; end
-      raise e
-IRB
-    end
-
-    def test_raise_exception_with_invalid_byte_sequence
-      pend if RUBY_ENGINE == 'truffleruby' || /mswin|mingw/ =~ RUBY_PLATFORM
-      bundle_exec = ENV.key?('BUNDLE_GEMFILE') ? ['-rbundler/setup'] : []
-      assert_in_out_err(bundle_exec + %w[-rirb -W0 -e IRB.start(__FILE__) -- -f --], <<~IRB, /A\\xF3B $StandardError$/, [])
-        raise StandardError, "A\\xf3B"
-      IRB
-    end
-
-    def test_raise_exception_with_different_encoding_containing_invalid_byte_sequence
-      backup_home = ENV["HOME"]
-      Dir.mktmpdir("test_irb_raise_no_backtrace_exception_#{$$}") do |tmpdir|
-        ENV["HOME"] = tmpdir
-
-        bundle_exec = ENV.key?('BUNDLE_GEMFILE') ? ['-rbundler/setup'] : []
-        File.open("#{tmpdir}/euc.rb", 'w') do |f|
-          f.write(<<~EOF)
-            # encoding: euc-jp
-
-            def raise_euc_with_invalid_byte_sequence
-              raise "\xA4\xA2\\xFF"
-            end
-          EOF
-        end
-        env = {}
-        %w(LC_MESSAGES LC_ALL LC_CTYPE LANG).each {|n| env[n] = "ja_JP.UTF-8" }
-        # TruffleRuby warns when the locale does not exist
-        env['TRUFFLERUBYOPT'] = "#{ENV['TRUFFLERUBYOPT']} --log.level=SEVERE" if RUBY_ENGINE == 'truffleruby'
-        args = [env] + bundle_exec + %W[-rirb -C #{tmpdir} -W0 -e IRB.start(__FILE__) -- -f --]
-        error = /raise_euc_with_invalid_byte_sequence': あ\\xFF $RuntimeError$/
-        assert_in_out_err(args, <<~IRB, error, [], encoding: "UTF-8")
-          require_relative 'euc'
-          raise_euc_with_invalid_byte_sequence
-        IRB
-      end
-    ensure
-      ENV["HOME"] = backup_home
-    end
-  end
-end
diff --git a/test/mri/irb/test_ruby_lex.rb b/test/mri/irb/test_ruby_lex.rb
deleted file mode 100644
index 4e406a8ce08..00000000000
--- a/test/mri/irb/test_ruby_lex.rb
+++ /dev/null
@@ -1,242 +0,0 @@
-# frozen_string_literal: true
-require "irb"
-
-require_relative "helper"
-
-module TestIRB
-  class RubyLexTest < TestCase
-    def setup
-      save_encodings
-    end
-
-    def teardown
-      restore_encodings
-    end
-
-    def test_interpolate_token_with_heredoc_and_unclosed_embexpr
-      code = <<~'EOC'
-        ①+<<A-②
-        #{③*<<B/④
-        #{⑤&<<C|⑥
-      EOC
-      ripper_tokens = Ripper.tokenize(code)
-      rubylex_tokens = IRB::RubyLex.ripper_lex_without_warning(code)
-      # Assert no missing part
-      assert_equal(code, rubylex_tokens.map(&:tok).join)
-      # Assert ripper tokens are not removed
-      ripper_tokens.each do |tok|
-        assert(rubylex_tokens.any? { |t| t.tok == tok && t.tok != :on_ignored_by_ripper })
-      end
-      # Assert interpolated token position
-      rubylex_tokens.each do |t|
-        row, col = t.pos
-        assert_equal t.tok, code.lines[row - 1].byteslice(col, t.tok.bytesize)
-      end
-    end
-
-    def test_local_variables_dependent_code
-      lines = ["a /1#/ do", "2"]
-      assert_indent_level(lines, 1)
-      assert_code_block_open(lines, true)
-      assert_indent_level(lines, 0, local_variables: ['a'])
-      assert_code_block_open(lines, false, local_variables: ['a'])
-    end
-
-    def test_literal_ends_with_space
-      assert_code_block_open(['% a'], true)
-      assert_code_block_open(['% a '], false)
-    end
-
-    def test_literal_ends_with_newline
-      assert_code_block_open(['%'], true)
-      assert_code_block_open(['%', ''], false)
-    end
-
-    def test_should_continue
-      assert_should_continue(['a'], false)
-      assert_should_continue(['/a/'], false)
-      assert_should_continue(['a;'], false)
-      assert_should_continue(['<<A', 'A'], false)
-      assert_should_continue(['a...'], false)
-      assert_should_continue(['a\\'], true)
-      assert_should_continue(['a.'], true)
-      assert_should_continue(['a+'], true)
-      assert_should_continue(['a; #comment', '', '=begin', 'embdoc', '=end', ''], false)
-      assert_should_continue(['a+ #comment', '', '=begin', 'embdoc', '=end', ''], true)
-    end
-
-    def test_code_block_open_with_should_continue
-      # syntax ok
-      assert_code_block_open(['a'], false) # continue: false
-      assert_code_block_open(['a\\'], true) # continue: true
-
-      # recoverable syntax error code is not terminated
-      assert_code_block_open(['a+'], true)
-
-      # unrecoverable syntax error code is terminated
-      assert_code_block_open(['.; a+'], false)
-
-      # other syntax error that failed to determine if it is recoverable or not
-      assert_code_block_open(['@; a'], false)
-      assert_code_block_open(['@; a+'], true)
-      assert_code_block_open(['@; (a'], true)
-    end
-
-    def test_broken_percent_literal
-      tokens = IRB::RubyLex.ripper_lex_without_warning('%wwww')
-      pos_to_index = {}
-      tokens.each_with_index { |t, i|
-        assert_nil(pos_to_index[t.pos], "There is already another token in the position of #{t.inspect}.")
-        pos_to_index[t.pos] = i
-      }
-    end
-
-    def test_broken_percent_literal_in_method
-      tokens = IRB::RubyLex.ripper_lex_without_warning(<<~EOC.chomp)
-        def foo
-          %wwww
-        end
-      EOC
-      pos_to_index = {}
-      tokens.each_with_index { |t, i|
-        assert_nil(pos_to_index[t.pos], "There is already another token in the position of #{t.inspect}.")
-        pos_to_index[t.pos] = i
-      }
-    end
-
-    def test_unterminated_code
-      ['do', '<<A'].each do |code|
-        tokens = IRB::RubyLex.ripper_lex_without_warning(code)
-        assert_equal(code, tokens.map(&:tok).join, "Cannot reconstruct code from tokens")
-        error_tokens = tokens.map(&:event).grep(/error/)
-        assert_empty(error_tokens, 'Error tokens must be ignored if there is corresponding non-error token')
-      end
-    end
-
-    def test_unterminated_heredoc_string_literal
-      ['<<A;<<B', "<<A;<<B\n", "%W[\#{<<A;<<B", "%W[\#{<<A;<<B\n"].each do |code|
-        tokens = IRB::RubyLex.ripper_lex_without_warning(code)
-        string_literal = IRB::NestingParser.open_tokens(tokens).last
-        assert_equal('<<A', string_literal&.tok)
-      end
-    end
-
-    def test_indent_level_with_heredoc_and_embdoc
-      reference_code = <<~EOC.chomp
-        if true
-          hello
-          p(
-          )
-      EOC
-      code_with_heredoc = <<~EOC.chomp
-        if true
-          <<~A
-          A
-          p(
-          )
-      EOC
-      code_with_embdoc = <<~EOC.chomp
-        if true
-        =begin
-        =end
-          p(
-          )
-      EOC
-      expected = 1
-      assert_indent_level(reference_code.lines, expected)
-      assert_indent_level(code_with_heredoc.lines, expected)
-      assert_indent_level(code_with_embdoc.lines, expected)
-    end
-
-    def test_assignment_expression
-      ruby_lex = IRB::RubyLex.new
-
-      [
-        "foo = bar",
-        "@foo = bar",
-        "$foo = bar",
-        "@@foo = bar",
-        "::Foo = bar",
-        "a::Foo = bar",
-        "Foo = bar",
-        "foo.bar = 1",
-        "foo[1] = bar",
-        "foo += bar",
-        "foo -= bar",
-        "foo ||= bar",
-        "foo &&= bar",
-        "foo, bar = 1, 2",
-        "foo.bar=(1)",
-        "foo; foo = bar",
-        "foo; foo = bar; ;\n ;",
-        "foo\nfoo = bar",
-      ].each do |exp|
-        assert(
-          ruby_lex.assignment_expression?(exp, local_variables: []),
-          "#{exp.inspect}: should be an assignment expression"
-        )
-      end
-
-      [
-        "foo",
-        "foo.bar",
-        "foo[0]",
-        "foo = bar; foo",
-        "foo = bar\nfoo",
-      ].each do |exp|
-        refute(
-          ruby_lex.assignment_expression?(exp, local_variables: []),
-          "#{exp.inspect}: should not be an assignment expression"
-        )
-      end
-    end
-
-    def test_assignment_expression_with_local_variable
-      ruby_lex = IRB::RubyLex.new
-      code = "a /1;x=1#/"
-      refute(ruby_lex.assignment_expression?(code, local_variables: []), "#{code}: should not be an assignment expression")
-      assert(ruby_lex.assignment_expression?(code, local_variables: [:a]), "#{code}: should be an assignment expression")
-      refute(ruby_lex.assignment_expression?("", local_variables: [:a]), "empty code should not be an assignment expression")
-    end
-
-    def test_initialising_the_old_top_level_ruby_lex
-      assert_in_out_err(["--disable-gems", "-W:deprecated"], <<~RUBY, [], /warning: constant ::RubyLex is deprecated/)
-        require "irb"
-        ::RubyLex.new(nil)
-      RUBY
-    end
-
-    private
-
-    def assert_indent_level(lines, expected, local_variables: [])
-      indent_level, _continue, _code_block_open = check_state(lines, local_variables: local_variables)
-      error_message = "Calculated the wrong number of indent level for:\n #{lines.join("\n")}"
-      assert_equal(expected, indent_level, error_message)
-    end
-
-    def assert_should_continue(lines, expected, local_variables: [])
-      _indent_level, continue, _code_block_open = check_state(lines, local_variables: local_variables)
-      error_message = "Wrong result of should_continue for:\n #{lines.join("\n")}"
-      assert_equal(expected, continue, error_message)
-    end
-
-    def assert_code_block_open(lines, expected, local_variables: [])
-      if RUBY_ENGINE == 'truffleruby'
-        omit "Remove me after https://github.com/ruby/prism/issues/2129 is addressed and adopted in TruffleRuby"
-      end
-
-      _indent_level, _continue, code_block_open = check_state(lines, local_variables: local_variables)
-      error_message = "Wrong result of code_block_open for:\n #{lines.join("\n")}"
-      assert_equal(expected, code_block_open, error_message)
-    end
-
-    def check_state(lines, local_variables: [])
-      code = lines.map { |l| "#{l}\n" }.join # code should end with "\n"
-      ruby_lex = IRB::RubyLex.new
-      tokens, opens, terminated = ruby_lex.check_code_state(code, local_variables: local_variables)
-      indent_level = ruby_lex.calc_indent_level(opens)
-      continue = ruby_lex.should_continue?(tokens)
-      [indent_level, continue, !terminated]
-    end
-  end
-end
diff --git a/test/mri/irb/test_tracer.rb b/test/mri/irb/test_tracer.rb
deleted file mode 100644
index 540f8be1314..00000000000
--- a/test/mri/irb/test_tracer.rb
+++ /dev/null
@@ -1,90 +0,0 @@
-# frozen_string_literal: false
-require 'tempfile'
-require 'irb'
-
-require_relative "helper"
-
-module TestIRB
-  class ContextWithTracerIntegrationTest < IntegrationTestCase
-    def setup
-      super
-
-      omit "Tracer gem is not available when running on TruffleRuby" if RUBY_ENGINE == "truffleruby"
-
-      @envs.merge!("NO_COLOR" => "true")
-    end
-
-    def example_ruby_file
-      <<~'RUBY'
-        class Foo
-          def self.foo
-            100
-          end
-        end
-
-        def bar(obj)
-          obj.foo
-        end
-
-        binding.irb
-      RUBY
-    end
-
-    def test_use_tracer_enabled_when_gem_is_unavailable
-      write_rc <<~RUBY
-        # Simulate the absence of the tracer gem
-        ::Kernel.send(:alias_method, :irb_original_require, :require)
-
-        ::Kernel.define_method(:require) do |name|
-          raise LoadError, "cannot load such file -- tracer (test)" if name.match?("tracer")
-          ::Kernel.send(:irb_original_require, name)
-        end
-
-        IRB.conf[:USE_TRACER] = true
-      RUBY
-
-      write_ruby example_ruby_file
-
-      output = run_ruby_file do
-        type "bar(Foo)"
-        type "exit"
-      end
-
-      assert_include(output, "Tracer extension of IRB is enabled but tracer gem wasn't found.")
-    end
-
-    def test_use_tracer_enabled_when_gem_is_available
-      write_rc <<~RUBY
-        IRB.conf[:USE_TRACER] = true
-      RUBY
-
-      write_ruby example_ruby_file
-
-      output = run_ruby_file do
-        type "bar(Foo)"
-        type "exit"
-      end
-
-      assert_include(output, "Object#bar at")
-      assert_include(output, "Foo.foo at")
-      assert_include(output, "Foo.foo #=> 100")
-      assert_include(output, "Object#bar #=> 100")
-
-      # Test that the tracer output does not include IRB's own files
-      assert_not_include(output, "irb/workspace.rb")
-    end
-
-    def test_use_tracer_is_disabled_by_default
-      write_ruby example_ruby_file
-
-      output = run_ruby_file do
-        type "bar(Foo)"
-        type "exit"
-      end
-
-      assert_not_include(output, "#depth:")
-      assert_not_include(output, "Foo.foo")
-    end
-
-  end
-end
diff --git a/test/mri/irb/test_type_completor.rb b/test/mri/irb/test_type_completor.rb
deleted file mode 100644
index 3d0e25d19e0..00000000000
--- a/test/mri/irb/test_type_completor.rb
+++ /dev/null
@@ -1,109 +0,0 @@
-# frozen_string_literal: true
-
-# Run test only when Ruby >= 3.0 and repl_type_completor is available
-return unless RUBY_VERSION >= '3.0.0'
-return if RUBY_ENGINE == 'truffleruby' # needs endless method definition
-begin
-  require 'repl_type_completor'
-rescue LoadError
-  return
-end
-
-require 'irb'
-require 'tempfile'
-require_relative './helper'
-
-module TestIRB
-  class TypeCompletorTest < TestCase
-    DummyContext = Struct.new(:irb_path)
-
-    def setup
-      ReplTypeCompletor.load_rbs unless ReplTypeCompletor.rbs_loaded?
-      context = DummyContext.new('(irb)')
-      @completor = IRB::TypeCompletor.new(context)
-    end
-
-    def empty_binding
-      binding
-    end
-
-    def test_build_completor
-      IRB.init_config(nil)
-      verbose, $VERBOSE = $VERBOSE, nil
-      original_completor = IRB.conf[:COMPLETOR]
-      workspace = IRB::WorkSpace.new(Object.new)
-      @context = IRB::Context.new(nil, workspace, TestInputMethod.new)
-      IRB.conf[:COMPLETOR] = nil
-      expected_default_completor = RUBY_VERSION >= '3.4' ? 'IRB::TypeCompletor' : 'IRB::RegexpCompletor'
-      assert_equal expected_default_completor, @context.send(:build_completor).class.name
-      IRB.conf[:COMPLETOR] = :type
-      assert_equal 'IRB::TypeCompletor', @context.send(:build_completor).class.name
-    ensure
-      $VERBOSE = verbose
-      IRB.conf[:COMPLETOR] = original_completor
-    end
-
-    def assert_completion(preposing, target, binding: empty_binding, include: nil, exclude: nil)
-      raise ArgumentError if include.nil? && exclude.nil?
-      candidates = @completor.completion_candidates(preposing, target, '', bind: binding)
-      assert ([*include] - candidates).empty?, "Expected #{candidates} to include #{include}" if include
-      assert (candidates & [*exclude]).empty?, "Expected #{candidates} not to include #{exclude}" if exclude
-    end
-
-    def assert_doc_namespace(preposing, target, namespace, binding: empty_binding)
-      @completor.completion_candidates(preposing, target, '', bind: binding)
-      assert_equal namespace, @completor.doc_namespace(preposing, target, '', bind: binding)
-    end
-
-    def test_type_completion
-      bind = eval('num = 1; binding')
-      assert_completion('num.times.map(&:', 'ab', binding: bind, include: 'abs')
-      assert_doc_namespace('num.chr.', 'upcase', 'String#upcase', binding: bind)
-    end
-
-    def test_inspect
-      assert_match(/\AReplTypeCompletor.*\z/, @completor.inspect)
-    end
-
-    def test_empty_completion
-      candidates = @completor.completion_candidates('(', ')', '', bind: binding)
-      assert_equal [], candidates
-      assert_doc_namespace('(', ')', nil)
-    end
-
-    def test_command_completion
-      binding.eval("some_var = 1")
-      # completion for help command's argument should only include command names
-      assert_include(@completor.completion_candidates('help ', 's', '', bind: binding), 'show_source')
-      assert_not_include(@completor.completion_candidates('help ', 's', '', bind: binding), 'some_var')
-
-      assert_include(@completor.completion_candidates('', 'show_s', '', bind: binding), 'show_source')
-      assert_not_include(@completor.completion_candidates(';', 'show_s', '', bind: binding), 'show_source')
-    end
-  end
-
-  class TypeCompletorIntegrationTest < IntegrationTestCase
-    def test_type_completor
-      write_rc <<~RUBY
-        IRB.conf[:COMPLETOR] = :type
-      RUBY
-
-      write_ruby <<~'RUBY'
-        binding.irb
-      RUBY
-
-      output = run_ruby_file do
-        type "irb_info"
-        type "sleep 0.01 until ReplTypeCompletor.rbs_loaded?"
-        type "completor = IRB.CurrentContext.io.instance_variable_get(:@completor);"
-        type "n = 10"
-        type "puts completor.completion_candidates 'a = n.abs;', 'a.b', '', bind: binding"
-        type "puts completor.doc_namespace 'a = n.chr;', 'a.encoding', '', bind: binding"
-        type "exit!"
-      end
-      assert_match(/Completion: Autocomplete, ReplTypeCompletor/, output)
-      assert_match(/a\.bit_length/, output)
-      assert_match(/String#encoding/, output)
-    end
-  end
-end
diff --git a/test/mri/irb/test_workspace.rb b/test/mri/irb/test_workspace.rb
deleted file mode 100644
index ad515f91df3..00000000000
--- a/test/mri/irb/test_workspace.rb
+++ /dev/null
@@ -1,126 +0,0 @@
-# frozen_string_literal: false
-require 'tempfile'
-require 'irb'
-require 'irb/workspace'
-require 'irb/color'
-
-require_relative "helper"
-
-module TestIRB
-  class WorkSpaceTest < TestCase
-    def test_code_around_binding
-      IRB.conf[:USE_COLORIZE] = false
-      Tempfile.create('irb') do |f|
-        code = <<~RUBY
-          # 1
-          # 2
-          IRB::WorkSpace.new(binding) # 3
-          # 4
-          # 5
-        RUBY
-        f.print(code)
-        f.close
-
-        workspace = eval(code, binding, f.path)
-        assert_equal(<<~EOS, without_term { workspace.code_around_binding })
-
-          From: #{f.path} @ line 3 :
-
-              1: # 1
-              2: # 2
-           => 3: IRB::WorkSpace.new(binding) # 3
-              4: # 4
-              5: # 5
-
-        EOS
-      end
-    ensure
-      IRB.conf.delete(:USE_COLORIZE)
-    end
-
-    def test_code_around_binding_with_existing_unreadable_file
-      pend 'chmod cannot make file unreadable on windows' if windows?
-      pend 'skipped in root privilege' if Process.uid == 0
-
-      Tempfile.create('irb') do |f|
-        code = "IRB::WorkSpace.new(binding)\n"
-        f.print(code)
-        f.close
-
-        File.chmod(0, f.path)
-
-        workspace = eval(code, binding, f.path)
-        assert_equal(nil, workspace.code_around_binding)
-      end
-    end
-
-    def test_code_around_binding_with_script_lines__
-      IRB.conf[:USE_COLORIZE] = false
-      with_script_lines do |script_lines|
-        Tempfile.create('irb') do |f|
-          code = "IRB::WorkSpace.new(binding)\n"
-          script_lines[f.path] = code.split(/^/)
-
-          workspace = eval(code, binding, f.path)
-          assert_equal(<<~EOS, without_term { workspace.code_around_binding })
-
-            From: #{f.path} @ line 1 :
-
-             => 1: IRB::WorkSpace.new(binding)
-
-          EOS
-        end
-      end
-    ensure
-      IRB.conf.delete(:USE_COLORIZE)
-    end
-
-    def test_code_around_binding_on_irb
-      workspace = eval("IRB::WorkSpace.new(binding)", binding, "(irb)")
-      assert_equal(nil, workspace.code_around_binding)
-    end
-
-    def test_toplevel_binding_local_variables
-      bug17623 = '[ruby-core:102468]'
-      bundle_exec = ENV.key?('BUNDLE_GEMFILE') ? ['-rbundler/setup'] : []
-      top_srcdir = "#{__dir__}/../.."
-      irb_path = nil
-      %w[exe libexec].find do |dir|
-        irb_path = "#{top_srcdir}/#{dir}/irb"
-        File.exist?(irb_path)
-      end or omit 'irb command not found'
-      assert_in_out_err(bundle_exec + ['-W0', "-C#{top_srcdir}", '-e', <<~RUBY, '--', '-f', '--'], 'binding.local_variables', /\[:_\]/, [], bug17623)
-        version = 'xyz' # typical rubygems loading file
-        load('#{irb_path}')
-      RUBY
-    end
-
-    private
-
-    def with_script_lines
-      script_lines = nil
-      debug_lines = {}
-      Object.class_eval do
-        if defined?(SCRIPT_LINES__)
-          script_lines = SCRIPT_LINES__
-          remove_const :SCRIPT_LINES__
-        end
-        const_set(:SCRIPT_LINES__, debug_lines)
-      end
-      yield debug_lines
-    ensure
-      Object.class_eval do
-        remove_const :SCRIPT_LINES__
-        const_set(:SCRIPT_LINES__, script_lines) if script_lines
-      end
-    end
-
-    def without_term
-      env = ENV.to_h.dup
-      ENV.delete('TERM')
-      yield
-    ensure
-      ENV.replace(env)
-    end
-  end
-end
diff --git a/test/mri/irb/yamatanooroti/test_rendering.rb b/test/mri/irb/yamatanooroti/test_rendering.rb
deleted file mode 100644
index ac6ce5346ea..00000000000
--- a/test/mri/irb/yamatanooroti/test_rendering.rb
+++ /dev/null
@@ -1,478 +0,0 @@
-require 'irb'
-
-begin
-  require 'yamatanooroti'
-rescue LoadError, NameError
-  # On Ruby repository, this test suite doesn't run because Ruby repo doesn't
-  # have the yamatanooroti gem.
-  return
-end
-
-class IRB::RenderingTest < Yamatanooroti::TestCase
-  def setup
-    @original_term = ENV['TERM']
-    @home_backup = ENV['HOME']
-    @xdg_config_home_backup = ENV['XDG_CONFIG_HOME']
-    ENV['TERM'] = "xterm-256color"
-    @pwd = Dir.pwd
-    suffix = '%010d' % Random.rand(0..65535)
-    @tmpdir = File.join(File.expand_path(Dir.tmpdir), "test_irb_#{$$}_#{suffix}")
-    begin
-      Dir.mkdir(@tmpdir)
-    rescue Errno::EEXIST
-      FileUtils.rm_rf(@tmpdir)
-      Dir.mkdir(@tmpdir)
-    end
-    @irbrc_backup = ENV['IRBRC']
-    @irbrc_file = ENV['IRBRC'] = File.join(@tmpdir, 'temporaty_irbrc')
-    File.unlink(@irbrc_file) if File.exist?(@irbrc_file)
-    ENV['HOME'] = File.join(@tmpdir, 'home')
-    ENV['XDG_CONFIG_HOME'] = File.join(@tmpdir, 'xdg_config_home')
-  end
-
-  def teardown
-    FileUtils.rm_rf(@tmpdir)
-    ENV['IRBRC'] = @irbrc_backup
-    ENV['TERM'] = @original_term
-    ENV['HOME'] = @home_backup
-    ENV['XDG_CONFIG_HOME'] = @xdg_config_home_backup
-  end
-
-  def test_launch
-    start_terminal(25, 80, %W{ruby -I#{@pwd}/lib #{@pwd}/exe/irb}, startup_message: /irb$main$/)
-    write(<<~EOC)
-      'Hello, World!'
-    EOC
-    assert_screen(<<~EOC)
-      irb(main):001> 'Hello, World!'
-      => "Hello, World!"
-      irb(main):002>
-    EOC
-    close
-  end
-
-  def test_configuration_file_is_skipped_with_dash_f
-    write_irbrc <<~'LINES'
-      puts '.irbrc file should be ignored when -f is used'
-    LINES
-    start_terminal(25, 80, %W{ruby -I#{@pwd}/lib #{@pwd}/exe/irb -f}, startup_message: /irb$main$/)
-    write(<<~EOC)
-      'Hello, World!'
-    EOC
-    assert_screen(<<~EOC)
-      irb(main):001> 'Hello, World!'
-      => "Hello, World!"
-      irb(main):002>
-    EOC
-    close
-  end
-
-  def test_configuration_file_is_skipped_with_dash_f_for_nested_sessions
-    write_irbrc <<~'LINES'
-      puts '.irbrc file should be ignored when -f is used'
-    LINES
-    start_terminal(25, 80, %W{ruby -I#{@pwd}/lib #{@pwd}/exe/irb -f}, startup_message: /irb$main$/)
-    write(<<~EOC)
-      'Hello, World!'
-      binding.irb
-      exit!
-    EOC
-    assert_screen(<<~EOC)
-      irb(main):001> 'Hello, World!'
-      => "Hello, World!"
-      irb(main):002> binding.irb
-      irb(main):003> exit!
-      irb(main):001>
-    EOC
-    close
-  end
-
-  def test_nomultiline
-    start_terminal(25, 80, %W{ruby -I#{@pwd}/lib #{@pwd}/exe/irb --nomultiline}, startup_message: /irb$main$/)
-    write(<<~EOC)
-      if true
-      if false
-      a = "hello
-      world"
-      puts a
-      end
-      end
-    EOC
-    assert_screen(<<~EOC)
-      irb(main):001> if true
-      irb(main):002*   if false
-      irb(main):003*     a = "hello
-      irb(main):004" world"
-      irb(main):005*     puts a
-      irb(main):006*     end
-      irb(main):007*   end
-      => nil
-      irb(main):008>
-    EOC
-    close
-  end
-
-  def test_multiline_paste
-    start_terminal(25, 80, %W{ruby -I#{@pwd}/lib #{@pwd}/exe/irb}, startup_message: /irb$main$/)
-    write(<<~EOC)
-      class A
-        def inspect; '#<A>'; end
-        def a; self; end
-        def b; true; end
-      end
-
-      a = A.new
-
-      a
-       .a
-       .b
-      .itself
-    EOC
-    assert_screen(<<~EOC)
-      irb(main):001* class A
-      irb(main):002*   def inspect; '#<A>'; end
-      irb(main):003*   def a; self; end
-      irb(main):004*   def b; true; end
-      irb(main):005> end
-      => :b
-      irb(main):006>
-      irb(main):007> a = A.new
-      => #<A>
-      irb(main):008>
-      irb(main):009> a
-      irb(main):010>  .a
-      irb(main):011>  .b
-      irb(main):012> .itself
-      => true
-      irb(main):013>
-    EOC
-    close
-  end
-
-  def test_evaluate_each_toplevel_statement_by_multiline_paste
-    start_terminal(40, 80, %W{ruby -I#{@pwd}/lib #{@pwd}/exe/irb}, startup_message: /irb$main$/)
-    write(<<~EOC)
-      class A
-        def inspect; '#<A>'; end
-        def b; self; end
-        def c; true; end
-      end
-
-      a = A.new
-
-      a
-        .b
-        # aaa
-        .c
-
-      (a)
-        &.b()
-
-      class A def b; self; end; def c; true; end; end;
-      a = A.new
-      a
-        .b
-        # aaa
-        .c
-      (a)
-        &.b()
-      .itself
-    EOC
-    assert_screen(<<~EOC)
-      irb(main):001* class A
-      irb(main):002*   def inspect; '#<A>'; end
-      irb(main):003*   def b; self; end
-      irb(main):004*   def c; true; end
-      irb(main):005> end
-      => :c
-      irb(main):006>
-      irb(main):007> a = A.new
-      => #<A>
-      irb(main):008>
-      irb(main):009> a
-      irb(main):010>   .b
-      irb(main):011>   # aaa
-      irb(main):012>   .c
-      => true
-      irb(main):013>
-      irb(main):014> (a)
-      irb(main):015>   &.b()
-      => #<A>
-      irb(main):016>
-      irb(main):017> class A def b; self; end; def c; true; end; end;
-      irb(main):018> a = A.new
-      => #<A>
-      irb(main):019> a
-      irb(main):020>   .b
-      irb(main):021>   # aaa
-      irb(main):022>   .c
-      => true
-      irb(main):023> (a)
-      irb(main):024>   &.b()
-      irb(main):025> .itself
-      => #<A>
-      irb(main):026>
-    EOC
-    close
-  end
-
-  def test_symbol_with_backtick
-    start_terminal(40, 80, %W{ruby -I#{@pwd}/lib #{@pwd}/exe/irb}, startup_message: /irb$main$/)
-    write(<<~EOC)
-      :`
-    EOC
-    assert_screen(<<~EOC)
-      irb(main):001> :`
-      => :`
-      irb(main):002>
-    EOC
-    close
-  end
-
-  def test_autocomplete_with_multiple_doc_namespaces
-    start_terminal(3, 50, %W{ruby -I#{@pwd}/lib #{@pwd}/exe/irb}, startup_message: /irb$main$/)
-    write("{}.__id_")
-    write("\C-i")
-    assert_screen(/irb$main$:001> {}\.__id__\n                }\.__id__(?:Press )?/)
-    close
-  end
-
-  def test_autocomplete_with_showdoc_in_gaps_on_narrow_screen_right
-    rdoc_dir = File.join(@tmpdir, 'rdoc')
-    system("bundle exec rdoc -r -o #{rdoc_dir}")
-    write_irbrc <<~LINES
-      IRB.conf[:EXTRA_DOC_DIRS] = ['#{rdoc_dir}']
-      IRB.conf[:PROMPT][:MY_PROMPT] = {
-        :PROMPT_I => "%03n> ",
-        :PROMPT_S => "%03n> ",
-        :PROMPT_C => "%03n> "
-      }
-      IRB.conf[:PROMPT_MODE] = :MY_PROMPT
-    LINES
-    start_terminal(4, 19, %W{ruby -I#{@pwd}/lib #{@pwd}/exe/irb}, startup_message: /001>/)
-    write("IR")
-    write("\C-i")
-
-    # This is because on macOS we display different shortcut for displaying the full doc
-    # 'O' is for 'Option' and 'A' is for 'Alt'
-    if RUBY_PLATFORM =~ /darwin/
-      assert_screen(<<~EOC)
-        001> IRB
-             IRBPress Opti
-                IRB
-      EOC
-    else
-      assert_screen(<<~EOC)
-        001> IRB
-             IRBPress Alt+
-                IRB
-      EOC
-    end
-    close
-  end
-
-  def test_autocomplete_with_showdoc_in_gaps_on_narrow_screen_left
-    rdoc_dir = File.join(@tmpdir, 'rdoc')
-    system("bundle exec rdoc -r -o #{rdoc_dir}")
-    write_irbrc <<~LINES
-      IRB.conf[:EXTRA_DOC_DIRS] = ['#{rdoc_dir}']
-      IRB.conf[:PROMPT][:MY_PROMPT] = {
-        :PROMPT_I => "%03n> ",
-        :PROMPT_S => "%03n> ",
-        :PROMPT_C => "%03n> "
-      }
-      IRB.conf[:PROMPT_MODE] = :MY_PROMPT
-    LINES
-    start_terminal(4, 12, %W{ruby -I#{@pwd}/lib #{@pwd}/exe/irb}, startup_message: /001>/)
-    write("IR")
-    write("\C-i")
-    assert_screen(<<~EOC)
-      001> IRB
-      PressIRB
-      IRB
-    EOC
-    close
-  end
-
-  def test_assignment_expression_truncate
-    start_terminal(40, 80, %W{ruby -I#{@pwd}/lib #{@pwd}/exe/irb}, startup_message: /irb$main$/)
-    # Assignment expression code that turns into non-assignment expression after evaluation
-    code = "a /'/i if false; a=1; x=1000.times.to_a#'.size"
-    write(code + "\n")
-    assert_screen(<<~EOC)
-      irb(main):001> #{code}
-      =>
-      [0,
-      ...
-      irb(main):002>
-    EOC
-    close
-  end
-
-  def test_ctrl_c_is_handled
-    start_terminal(40, 80, %W{ruby -I#{@pwd}/lib #{@pwd}/exe/irb}, startup_message: /irb$main$/)
-    # Assignment expression code that turns into non-assignment expression after evaluation
-    write("\C-c")
-    assert_screen(<<~EOC)
-      irb(main):001>
-      ^C
-      irb(main):001>
-    EOC
-    close
-  end
-
-  def test_show_cmds_with_pager_can_quit_with_ctrl_c
-    start_terminal(40, 80, %W{ruby -I#{@pwd}/lib #{@pwd}/exe/irb}, startup_message: /irb$main$/)
-    write("help\n")
-    write("G") # move to the end of the screen
-    write("\C-c") # quit pager
-    write("'foo' + 'bar'\n") # eval something to make sure IRB resumes
-
-    # IRB should resume
-    assert_screen(/foobar/)
-    # IRB::Abort should be rescued
-    assert_screen(/\A(?!IRB::Abort)/)
-    close
-  end
-
-  def test_pager_page_content_pages_output_when_it_does_not_fit_in_the_screen_because_of_total_length
-    write_irbrc <<~'LINES'
-      require "irb/pager"
-    LINES
-    start_terminal(10, 80, %W{ruby -I#{@pwd}/lib #{@pwd}/exe/irb}, startup_message: /irb$main$/)
-    write("IRB::Pager.page_content('a' * (80 * 8))\n")
-    write("'foo' + 'bar'\n") # eval something to make sure IRB resumes
-
-    assert_screen(/a{80}/)
-    # because pager is invoked, foobar will not be evaluated
-    assert_screen(/\A(?!foobar)/)
-    close
-  end
-
-  def test_pager_page_content_pages_output_when_it_does_not_fit_in_the_screen_because_of_screen_height
-    write_irbrc <<~'LINES'
-      require "irb/pager"
-    LINES
-    start_terminal(10, 80, %W{ruby -I#{@pwd}/lib #{@pwd}/exe/irb}, startup_message: /irb$main$/)
-    write("IRB::Pager.page_content('a\n' * 8)\n")
-    write("'foo' + 'bar'\n") # eval something to make sure IRB resumes
-
-    assert_screen(/(a\n){8}/)
-    # because pager is invoked, foobar will not be evaluated
-    assert_screen(/\A(?!foobar)/)
-    close
-  end
-
-  def test_pager_page_content_doesnt_page_output_when_it_fits_in_the_screen
-    write_irbrc <<~'LINES'
-      require "irb/pager"
-    LINES
-    start_terminal(10, 80, %W{ruby -I#{@pwd}/lib #{@pwd}/exe/irb}, startup_message: /irb$main$/)
-    write("IRB::Pager.page_content('a' * (80 * 7))\n")
-    write("'foo' + 'bar'\n") # eval something to make sure IRB resumes
-
-    assert_screen(/a{80}/)
-    # because pager is not invoked, foobar will be evaluated
-    assert_screen(/foobar/)
-    close
-  end
-
-  def test_long_evaluation_output_is_paged
-    write_irbrc <<~'LINES'
-      require "irb/pager"
-    LINES
-    start_terminal(10, 80, %W{ruby -I#{@pwd}/lib #{@pwd}/exe/irb}, startup_message: /irb$main$/)
-    write("'a' * 80 * 11\n")
-    write("'foo' + 'bar'\n") # eval something to make sure IRB resumes
-
-    assert_screen(/(a{80}\n){8}/)
-    # because pager is invoked, foobar will not be evaluated
-    assert_screen(/\A(?!foobar)/)
-    close
-  end
-
-  def test_long_evaluation_output_is_preserved_after_paging
-    write_irbrc <<~'LINES'
-      require "irb/pager"
-    LINES
-    start_terminal(10, 80, %W{ruby -I#{@pwd}/lib #{@pwd}/exe/irb}, startup_message: /irb$main$/)
-    write("'a' * 80 * 11\n")
-    write("q") # quit pager
-    write("'foo' + 'bar'\n") # eval something to make sure IRB resumes
-
-    # confirm pager has exited
-    assert_screen(/foobar/)
-    # confirm output is preserved
-    assert_screen(/(a{80}\n){6}/)
-    close
-  end
-
-  def test_debug_integration_hints_debugger_commands
-    write_irbrc <<~'LINES'
-      IRB.conf[:USE_COLORIZE] = false
-    LINES
-    script = Tempfile.create(["debug", ".rb"])
-    script.write <<~RUBY
-      binding.irb
-    RUBY
-    script.close
-    start_terminal(40, 80, %W{ruby -I#{@pwd}/lib #{script.to_path}}, startup_message: /irb$main$/)
-    write("debug\n")
-    write("pp 1\n")
-    write("pp 1")
-
-    # submitted input shouldn't contain hint
-    assert_screen(/irb:rdbg$main$:002> pp 1\n/)
-    # unsubmitted input should contain hint
-    assert_screen(/irb:rdbg$main$:003> pp 1 # debug command\n/)
-    close
-  ensure
-    File.unlink(script) if script
-  end
-
-  def test_debug_integration_doesnt_hint_non_debugger_commands
-    write_irbrc <<~'LINES'
-      IRB.conf[:USE_COLORIZE] = false
-    LINES
-    script = Tempfile.create(["debug", ".rb"])
-    script.write <<~RUBY
-      binding.irb
-    RUBY
-    script.close
-    start_terminal(40, 80, %W{ruby -I#{@pwd}/lib #{script.to_path}}, startup_message: /irb$main$/)
-    write("debug\n")
-    write("foo")
-    assert_screen(/irb:rdbg$main$:002> foo\n/)
-    close
-  ensure
-    File.unlink(script) if script
-  end
-
-  def test_debug_integration_doesnt_hint_debugger_commands_in_nomultiline_mode
-    write_irbrc <<~'LINES'
-      IRB.conf[:USE_SINGLELINE] = true
-    LINES
-    script = Tempfile.create(["debug", ".rb"])
-    script.write <<~RUBY
-      puts 'start IRB'
-      binding.irb
-    RUBY
-    script.close
-    start_terminal(40, 80, %W{ruby -I#{@pwd}/lib #{script.to_path}}, startup_message: 'start IRB')
-    write("debug\n")
-    write("pp 1")
-    # submitted input shouldn't contain hint
-    assert_screen(/irb:rdbg$main$:002> pp 1\n/)
-    close
-  ensure
-    File.unlink(script) if script
-  end
-
-  private
-
-  def write_irbrc(content)
-    File.open(@irbrc_file, 'w') do |f|
-      f.write content
-    end
-  end
-end
diff --git a/test/mri/json/fixtures/fail4.json b/test/mri/json/fixtures/fail4.json
deleted file mode 100644
index 9de168bf34e..00000000000
--- a/test/mri/json/fixtures/fail4.json
+++ /dev/null
@@ -1 +0,0 @@
-["extra comma",]
\ No newline at end of file
diff --git a/test/mri/json/fixtures/fail9.json b/test/mri/json/fixtures/fail9.json
deleted file mode 100644
index 5815574f363..00000000000
--- a/test/mri/json/fixtures/fail9.json
+++ /dev/null
@@ -1 +0,0 @@
-{"Extra comma": true,}
\ No newline at end of file
diff --git a/test/mri/json/fixtures/pass15.json b/test/mri/json/fixtures/pass15.json
deleted file mode 100644
index fc8376b605d..00000000000
--- a/test/mri/json/fixtures/pass15.json
+++ /dev/null
@@ -1 +0,0 @@
-["Illegal backslash escape: \x15"]
\ No newline at end of file
diff --git a/test/mri/json/fixtures/pass16.json b/test/mri/json/fixtures/pass16.json
deleted file mode 100644
index c43ae3c2868..00000000000
--- a/test/mri/json/fixtures/pass16.json
+++ /dev/null
@@ -1 +0,0 @@
-["Illegal backslash escape: \'"]
\ No newline at end of file
diff --git a/test/mri/json/fixtures/pass17.json b/test/mri/json/fixtures/pass17.json
deleted file mode 100644
index 62b9214aeda..00000000000
--- a/test/mri/json/fixtures/pass17.json
+++ /dev/null
@@ -1 +0,0 @@
-["Illegal backslash escape: \017"]
\ No newline at end of file
diff --git a/test/mri/json/fixtures/pass26.json b/test/mri/json/fixtures/pass26.json
deleted file mode 100644
index 845d26a6a54..00000000000
--- a/test/mri/json/fixtures/pass26.json
+++ /dev/null
@@ -1 +0,0 @@
-["tab\   character\   in\  string\  "]
\ No newline at end of file
diff --git a/test/mri/logger/test_formatter.rb b/test/mri/logger/test_formatter.rb
deleted file mode 100644
index 94657229914..00000000000
--- a/test/mri/logger/test_formatter.rb
+++ /dev/null
@@ -1,35 +0,0 @@
-# coding: US-ASCII
-# frozen_string_literal: false
-require 'logger'
-
-class TestFormatter < Test::Unit::TestCase
-  def test_call
-    severity = 'INFO'
-    time = Time.now
-    progname = 'ruby'
-    msg = 'This is a test'
-    formatter = Logger::Formatter.new
-
-    result = formatter.call(severity, time, progname, msg)
-    time_matcher = /\d{4}\-\d{2}\-\d{2}T\d{2}:\d{2}:\d{2}\.\d{6}/
-    matcher = /#{severity[0..0]}, \[#{time_matcher} #\d+\]  #{severity} -- #{progname}: #{msg}\n/
-
-    assert_match(matcher, result)
-  end
-
-  class CustomFormatter < Logger::Formatter
-    def call(time)
-      format_datetime(time)
-    end
-  end
-
-  def test_format_datetime
-    time = Time.now
-    formatter = CustomFormatter.new
-
-    result = formatter.call(time)
-    matcher = /^\d{4}\-\d{2}\-\d{2}T\d{2}:\d{2}:\d{2}\.\d{6}$/
-
-    assert_match(matcher, result)
-  end
-end
diff --git a/test/mri/logger/test_logdevice.rb b/test/mri/logger/test_logdevice.rb
deleted file mode 100644
index 610905e5421..00000000000
--- a/test/mri/logger/test_logdevice.rb
+++ /dev/null
@@ -1,859 +0,0 @@
-# coding: US-ASCII
-# frozen_string_literal: false
-require 'logger'
-require 'tempfile'
-require 'tmpdir'
-
-class TestLogDevice < Test::Unit::TestCase
-  class LogExcnRaiser
-    def write(*arg)
-      raise 'disk is full'
-    end
-
-    def close
-    end
-
-    def stat
-      Object.new
-    end
-  end
-
-  def setup
-    @tempfile = Tempfile.new("logger")
-    @tempfile.close
-    @filename = @tempfile.path
-    File.unlink(@filename)
-  end
-
-  def teardown
-    @tempfile.close(true)
-  end
-
-  def d(log, opt = {})
-    Logger::LogDevice.new(log, **opt)
-  end
-
-  def test_initialize
-    logdev = d(STDERR)
-    assert_equal(STDERR, logdev.dev)
-    assert_nil(logdev.filename)
-    assert_raise(TypeError) do
-      d(nil)
-    end
-    #
-    logdev = d(@filename)
-    begin
-      assert_file.exist?(@filename)
-      assert_predicate(logdev.dev, :sync)
-      refute_predicate(logdev.dev, :binmode?)
-      assert_equal(@filename, logdev.filename)
-      logdev.write('hello')
-    ensure
-      logdev.close
-    end
-    # create logfile which is already exist.
-    logdev = d(@filename)
-    begin
-      assert_predicate(logdev.dev, :sync)
-      refute_predicate(logdev.dev, :binmode?)
-      logdev.write('world')
-      logfile = File.read(@filename)
-      assert_equal(2, logfile.split(/\n/).size)
-      assert_match(/^helloworld$/, logfile)
-    ensure
-      logdev.close
-    end
-    # logfile object with path
-    tempfile = Tempfile.new("logger")
-    tempfile.sync = true
-    logdev = d(tempfile)
-    begin
-      logdev.write('world')
-      logfile = File.read(tempfile.path)
-      assert_equal(1, logfile.split(/\n/).size)
-      assert_match(/^world$/, logfile)
-      assert_equal(tempfile.path, logdev.filename)
-    ensure
-      logdev.close
-      File.unlink(tempfile)
-      tempfile.close(true)
-    end
-  end
-
-  def test_write
-    r, w = IO.pipe
-    logdev = d(w)
-    logdev.write("msg2\n\n")
-    IO.select([r], nil, nil, 0.1)
-    w.close
-    msg = r.read
-    r.close
-    assert_equal("msg2\n\n", msg)
-    #
-    logdev = d(LogExcnRaiser.new)
-    class << (stderr = '')
-      alias write concat
-    end
-    $stderr, stderr = stderr, $stderr
-    begin
-      assert_nothing_raised do
-        logdev.write('hello')
-      end
-    ensure
-      logdev.close
-      $stderr, stderr = stderr, $stderr
-    end
-    assert_equal "log writing failed. disk is full\n", stderr
-  end
-
-  def test_close
-    r, w = IO.pipe
-    logdev = d(w)
-    logdev.write("msg2\n\n")
-    IO.select([r], nil, nil, 0.1)
-    assert_not_predicate(w, :closed?)
-    logdev.close
-    assert_predicate(w, :closed?)
-    r.close
-  end
-
-  def test_reopen_io
-    logdev  = d(STDERR)
-    old_dev = logdev.dev
-    logdev.reopen
-    assert_equal(STDERR, logdev.dev)
-    assert_not_predicate(old_dev, :closed?)
-  end
-
-  def test_reopen_io_by_io
-    logdev  = d(STDERR)
-    old_dev = logdev.dev
-    logdev.reopen(STDOUT)
-    assert_equal(STDOUT, logdev.dev)
-    assert_not_predicate(old_dev, :closed?)
-  end
-
-  def test_reopen_io_by_file
-    logdev  = d(STDERR)
-    old_dev = logdev.dev
-    logdev.reopen(@filename)
-    begin
-      assert_file.exist?(@filename)
-      assert_equal(@filename, logdev.filename)
-      assert_not_predicate(old_dev, :closed?)
-    ensure
-      logdev.close
-    end
-  end
-
-  def test_reopen_file
-    logdev = d(@filename)
-    old_dev = logdev.dev
-
-    logdev.reopen
-    begin
-      assert_file.exist?(@filename)
-      assert_equal(@filename, logdev.filename)
-      assert_predicate(old_dev, :closed?)
-    ensure
-      logdev.close
-    end
-  end
-
-  def test_reopen_file_by_io
-    logdev = d(@filename)
-    old_dev = logdev.dev
-    logdev.reopen(STDOUT)
-    assert_equal(STDOUT, logdev.dev)
-    assert_nil(logdev.filename)
-    assert_predicate(old_dev, :closed?)
-  end
-
-  def test_reopen_file_by_file
-    logdev = d(@filename)
-    old_dev = logdev.dev
-
-    tempfile2 = Tempfile.new("logger")
-    tempfile2.close
-    filename2 = tempfile2.path
-    File.unlink(filename2)
-
-    logdev.reopen(filename2)
-    begin
-      assert_file.exist?(filename2)
-      assert_equal(filename2, logdev.filename)
-      assert_predicate(old_dev, :closed?)
-    ensure
-      logdev.close
-      tempfile2.close(true)
-    end
-  end
-
-  def test_shifting_size
-    tmpfile = Tempfile.new([File.basename(__FILE__, '.*'), '_1.log'])
-    logfile = tmpfile.path
-    logfile0 = logfile + '.0'
-    logfile1 = logfile + '.1'
-    logfile2 = logfile + '.2'
-    logfile3 = logfile + '.3'
-    tmpfile.close(true)
-    File.unlink(logfile) if File.exist?(logfile)
-    File.unlink(logfile0) if File.exist?(logfile0)
-    File.unlink(logfile1) if File.exist?(logfile1)
-    File.unlink(logfile2) if File.exist?(logfile2)
-    logger = Logger.new(logfile, 4, 100)
-    logger.error("0" * 15)
-    assert_file.exist?(logfile)
-    assert_file.not_exist?(logfile0)
-    logger.error("0" * 15)
-    assert_file.exist?(logfile0)
-    assert_file.not_exist?(logfile1)
-    logger.error("0" * 15)
-    assert_file.exist?(logfile1)
-    assert_file.not_exist?(logfile2)
-    logger.error("0" * 15)
-    assert_file.exist?(logfile2)
-    assert_file.not_exist?(logfile3)
-    logger.error("0" * 15)
-    assert_file.not_exist?(logfile3)
-    logger.error("0" * 15)
-    assert_file.not_exist?(logfile3)
-    logger.close
-    File.unlink(logfile)
-    File.unlink(logfile0)
-    File.unlink(logfile1)
-    File.unlink(logfile2)
-
-    tmpfile = Tempfile.new([File.basename(__FILE__, '.*'), '_2.log'])
-    logfile = tmpfile.path
-    logfile0 = logfile + '.0'
-    logfile1 = logfile + '.1'
-    logfile2 = logfile + '.2'
-    logfile3 = logfile + '.3'
-    tmpfile.close(true)
-    logger = Logger.new(logfile, 4, 150)
-    logger.error("0" * 15)
-    assert_file.exist?(logfile)
-    assert_file.not_exist?(logfile0)
-    logger.error("0" * 15)
-    assert_file.not_exist?(logfile0)
-    logger.error("0" * 15)
-    assert_file.exist?(logfile0)
-    assert_file.not_exist?(logfile1)
-    logger.error("0" * 15)
-    assert_file.not_exist?(logfile1)
-    logger.error("0" * 15)
-    assert_file.exist?(logfile1)
-    assert_file.not_exist?(logfile2)
-    logger.error("0" * 15)
-    assert_file.not_exist?(logfile2)
-    logger.error("0" * 15)
-    assert_file.exist?(logfile2)
-    assert_file.not_exist?(logfile3)
-    logger.error("0" * 15)
-    assert_file.not_exist?(logfile3)
-    logger.error("0" * 15)
-    assert_file.not_exist?(logfile3)
-    logger.error("0" * 15)
-    assert_file.not_exist?(logfile3)
-    logger.close
-    File.unlink(logfile)
-    File.unlink(logfile0)
-    File.unlink(logfile1)
-    File.unlink(logfile2)
-  end
-
-  def test_shifting_age_variants
-    logger = Logger.new(@filename, 'daily')
-    logger.info('daily')
-    logger.close
-    logger = Logger.new(@filename, 'weekly')
-    logger.info('weekly')
-    logger.close
-    logger = Logger.new(@filename, 'monthly')
-    logger.info('monthly')
-    logger.close
-  end
-
-  def test_invalid_shifting_age
-    assert_raise(ArgumentError) { Logger::Period.next_rotate_time(Time.now, 'invalid') }
-    assert_raise(ArgumentError) { Logger::Period.previous_period_end(Time.now, 'invalid') }
-  end
-
-  def test_shifting_age
-    yyyymmdd = Time.now.strftime("%Y%m%d")
-    filename1 = @filename + ".#{yyyymmdd}"
-    filename2 = @filename + ".#{yyyymmdd}.1"
-    filename3 = @filename + ".#{yyyymmdd}.2"
-    begin
-      logger = Logger.new(@filename, 'now')
-      assert_file.exist?(@filename)
-      assert_file.not_exist?(filename1)
-      assert_file.not_exist?(filename2)
-      assert_file.not_exist?(filename3)
-      logger.info("0" * 15)
-      assert_file.exist?(@filename)
-      assert_file.exist?(filename1)
-      assert_file.not_exist?(filename2)
-      assert_file.not_exist?(filename3)
-      logger.warn("0" * 15)
-      assert_file.exist?(@filename)
-      assert_file.exist?(filename1)
-      assert_file.exist?(filename2)
-      assert_file.not_exist?(filename3)
-      logger.error("0" * 15)
-      assert_file.exist?(@filename)
-      assert_file.exist?(filename1)
-      assert_file.exist?(filename2)
-      assert_file.exist?(filename3)
-    ensure
-      logger.close if logger
-      [filename1, filename2, filename3].each do |filename|
-        File.unlink(filename) if File.exist?(filename)
-      end
-    end
-  end
-
-  def test_shifting_period_suffix
-    ['%Y%m%d', '%Y-%m-%d', '%Y'].each do |format|
-      if format == '%Y%m%d' # default
-        logger = Logger.new(@filename, 'now', 1048576)
-      else # config
-        logger = Logger.new(@filename, 'now', 1048576, shift_period_suffix: format)
-      end
-      begin
-        yyyymmdd = Time.now.strftime(format)
-        filename1 = @filename + ".#{yyyymmdd}"
-        filename2 = @filename + ".#{yyyymmdd}.1"
-        filename3 = @filename + ".#{yyyymmdd}.2"
-        logger.info("0" * 15)
-        logger.info("0" * 15)
-        logger.info("0" * 15)
-        assert_file.exist?(@filename)
-        assert_file.exist?(filename1)
-        assert_file.exist?(filename2)
-        assert_file.exist?(filename3)
-      ensure
-        logger.close if logger
-        [filename1, filename2, filename3].each do |filename|
-          File.unlink(filename) if File.exist?(filename)
-        end
-      end
-    end
-  end
-
-  def test_shifting_size_in_multiprocess
-    tmpfile = Tempfile.new([File.basename(__FILE__, '.*'), '_1.log'])
-    logfile = tmpfile.path
-    logfile0 = logfile + '.0'
-    logfile1 = logfile + '.1'
-    logfile2 = logfile + '.2'
-    tmpfile.close(true)
-    File.unlink(logfile) if File.exist?(logfile)
-    File.unlink(logfile0) if File.exist?(logfile0)
-    File.unlink(logfile1) if File.exist?(logfile1)
-    File.unlink(logfile2) if File.exist?(logfile2)
-    begin
-      stderr = run_children(2, [logfile], "#{<<-"begin;"}\n#{<<-'end;'}")
-      begin;
-        logger = Logger.new(ARGV[0], 4, 10)
-        10.times do
-          logger.info '0' * 15
-        end
-      end;
-      assert_no_match(/log shifting failed/, stderr)
-      assert_no_match(/log writing failed/, stderr)
-      assert_no_match(/log rotation inter-process lock failed/, stderr)
-    ensure
-      File.unlink(logfile) if File.exist?(logfile)
-      File.unlink(logfile0) if File.exist?(logfile0)
-      File.unlink(logfile1) if File.exist?(logfile1)
-      File.unlink(logfile2) if File.exist?(logfile2)
-    end
-  end
-
-  def test_shifting_age_in_multiprocess
-    yyyymmdd = Time.now.strftime("%Y%m%d")
-    begin
-      stderr = run_children(2, [@filename], "#{<<-"begin;"}\n#{<<-'end;'}")
-      begin;
-        logger = Logger.new(ARGV[0], 'now')
-        10.times do
-          logger.info '0' * 15
-        end
-      end;
-      assert_no_match(/log shifting failed/, stderr)
-      assert_no_match(/log writing failed/, stderr)
-      assert_no_match(/log rotation inter-process lock failed/, stderr)
-    ensure
-      Dir.glob("#{@filename}.#{yyyymmdd}{,.[1-9]*}") do |filename|
-        File.unlink(filename) if File.exist?(filename)
-      end
-    end
-  end
-
-  def test_open_logfile_in_multiprocess
-    tmpfile = Tempfile.new([File.basename(__FILE__, '.*'), '_1.log'])
-    logfile = tmpfile.path
-    tmpfile.close(true)
-    begin
-      20.times do
-        run_children(2, [logfile], "#{<<-"begin;"}\n#{<<-'end;'}")
-        begin;
-          logfile = ARGV[0]
-          logdev = Logger::LogDevice.new(logfile)
-          logdev.send(:open_logfile, logfile)
-        end;
-        assert_equal(1, File.readlines(logfile).grep(/# Logfile created on/).size)
-        File.unlink(logfile)
-      end
-    ensure
-      File.unlink(logfile) if File.exist?(logfile)
-    end
-  end
-
-  def test_shifting_size_not_rotate_too_much
-    logdev0 = d(@filename)
-    logdev0.__send__(:add_log_header, @tempfile)
-    header_size = @tempfile.size
-    message = "*" * 99 + "\n"
-    shift_size = header_size + message.size * 3 - 1
-    opt = {shift_age: 1, shift_size: shift_size}
-
-    Dir.mktmpdir do |tmpdir|
-      begin
-        log = File.join(tmpdir, "log")
-        logdev1 = d(log, opt)
-        logdev2 = d(log, opt)
-
-        assert_file.identical?(log, logdev1.dev)
-        assert_file.identical?(log, logdev2.dev)
-
-        3.times{logdev1.write(message)}
-        assert_file.identical?(log, logdev1.dev)
-        assert_file.identical?(log, logdev2.dev)
-
-        logdev1.write(message)
-        assert_file.identical?(log, logdev1.dev)
-        # NOTE: below assertion fails in JRuby 9.3 and TruffleRuby
-        assert_file.identical?(log + ".0", logdev2.dev)
-
-        logdev2.write(message)
-        assert_file.identical?(log, logdev1.dev)
-        assert_file.identical?(log, logdev2.dev)
-
-        logdev1.write(message)
-        assert_file.identical?(log, logdev1.dev)
-        assert_file.identical?(log, logdev2.dev)
-      ensure
-        logdev1.close if logdev1
-        logdev2.close if logdev2
-      end
-    end
-  ensure
-    logdev0.close
-  end
-
-  def test_shifting_midnight
-    Dir.mktmpdir do |tmpdir|
-      assert_in_out_err([*%W"--disable=gems -rlogger -C#{tmpdir} -"], "#{<<-"begin;"}\n#{<<-'end;'}")
-      begin;
-        begin
-          module FakeTime
-            attr_accessor :now
-          end
-
-          class << Time
-            prepend FakeTime
-          end
-
-          log = "log"
-          File.open(log, "w") {}
-          File.utime(*[Time.mktime(2014, 1, 2, 0, 0, 0)]*2, log)
-
-          Time.now = Time.mktime(2014, 1, 2, 23, 59, 59, 999000)
-          dev = Logger::LogDevice.new(log, shift_age: 'daily')
-          dev.write("#{Time.now} hello-1\n")
-          File.utime(Time.now, Time.now, log)
-
-          Time.now = Time.mktime(2014, 1, 3, 1, 1, 1)
-          dev.write("#{Time.now} hello-2\n")
-          File.utime(Time.now, Time.now, log)
-        ensure
-          dev.close
-        end
-      end;
-
-      bug = '[GH-539]'
-      log = File.join(tmpdir, "log")
-      cont = File.read(log)
-      assert_match(/hello-2/, cont)
-      assert_not_match(/hello-1/, cont)
-      assert_file.for(bug).exist?(log+".20140102")
-      assert_match(/hello-1/, File.read(log+".20140102"), bug)
-    end
-  end
-
-  env_tz_works = /linux|darwin|freebsd|openbsd/ =~ RUBY_PLATFORM # borrow from test/ruby/test_time_tz.rb
-
-  def test_shifting_weekly
-    Dir.mktmpdir do |tmpdir|
-      assert_in_out_err([{"TZ"=>"UTC"}, *%W"-rlogger -C#{tmpdir} -"], "#{<<-"begin;"}\n#{<<-'end;'}")
-      begin;
-        begin
-          module FakeTime
-            attr_accessor :now
-          end
-
-          class << Time
-            prepend FakeTime
-          end
-
-          log = "log"
-          File.open(log, "w") {}
-          Time.now = Time.utc(2015, 12, 14, 0, 1, 1)
-          File.utime(Time.now, Time.now, log)
-
-          dev = Logger::LogDevice.new("log", shift_age: 'weekly')
-
-          Time.now = Time.utc(2015, 12, 19, 12, 34, 56)
-          dev.write("#{Time.now} hello-1\n")
-          File.utime(Time.now, Time.now, log)
-
-          Time.now = Time.utc(2015, 12, 20, 0, 1, 1)
-          dev.write("#{Time.now} hello-2\n")
-          File.utime(Time.now, Time.now, log)
-        ensure
-          dev.close if dev
-        end
-      end;
-      log = File.join(tmpdir, "log")
-      cont = File.read(log)
-      assert_match(/hello-2/, cont)
-      assert_not_match(/hello-1/, cont)
-      log = Dir.glob(log+".*")
-      assert_equal(1, log.size)
-      log, = *log
-      cont = File.read(log)
-      assert_match(/hello-1/, cont)
-      assert_equal("2015-12-19", cont[/^[-\d]+/])
-      assert_equal("20151219", log[/\d+\z/])
-    end
-  end if env_tz_works
-
-  def test_shifting_monthly
-    Dir.mktmpdir do |tmpdir|
-      assert_in_out_err([{"TZ"=>"UTC"}, *%W"-rlogger -C#{tmpdir} -"], "#{<<-"begin;"}\n#{<<-'end;'}")
-      begin;
-        begin
-          module FakeTime
-            attr_accessor :now
-          end
-
-          class << Time
-            prepend FakeTime
-          end
-
-          log = "log"
-          File.open(log, "w") {}
-          Time.now = Time.utc(2015, 12, 14, 0, 1, 1)
-          File.utime(Time.now, Time.now, log)
-
-          dev = Logger::LogDevice.new("log", shift_age: 'monthly')
-
-          Time.now = Time.utc(2015, 12, 31, 12, 34, 56)
-          dev.write("#{Time.now} hello-1\n")
-          File.utime(Time.now, Time.now, log)
-
-          Time.now = Time.utc(2016, 1, 1, 0, 1, 1)
-          dev.write("#{Time.now} hello-2\n")
-          File.utime(Time.now, Time.now, log)
-        ensure
-          dev.close if dev
-        end
-      end;
-      log = File.join(tmpdir, "log")
-      cont = File.read(log)
-      assert_match(/hello-2/, cont)
-      assert_not_match(/hello-1/, cont)
-      log = Dir.glob(log+".*")
-      assert_equal(1, log.size)
-      log, = *log
-      cont = File.read(log)
-      assert_match(/hello-1/, cont)
-      assert_equal("2015-12-31", cont[/^[-\d]+/])
-      assert_equal("20151231", log[/\d+\z/])
-    end
-  end if env_tz_works
-
-  def test_shifting_dst_change
-    Dir.mktmpdir do |tmpdir|
-      assert_in_out_err([{"TZ"=>"Europe/London"}, *%W"--disable=gems -rlogger -C#{tmpdir} -"], "#{<<-"begin;"}\n#{<<-'end;'}")
-      begin;
-        begin
-          module FakeTime
-            attr_accessor :now
-          end
-
-          class << Time
-            prepend FakeTime
-          end
-
-          log = "log"
-          File.open(log, "w") {}
-
-          Time.now = Time.mktime(2014, 3, 30, 0, 1, 1)
-          File.utime(Time.now, Time.now, log)
-
-          dev = Logger::LogDevice.new(log, shift_age: 'daily')
-          dev.write("#{Time.now} hello-1\n")
-          File.utime(*[Time.mktime(2014, 3, 30, 0, 2, 3)]*2, log)
-
-          Time.now = Time.mktime(2014, 3, 31, 0, 1, 1)
-          dev.write("#{Time.now} hello-2\n")
-          File.utime(Time.now, Time.now, log)
-        ensure
-          dev.close
-        end
-      end;
-
-      log = File.join(tmpdir, "log")
-      cont = File.read(log)
-      assert_match(/hello-2/, cont)
-      assert_not_match(/hello-1/, cont)
-      assert_file.exist?(log+".20140330")
-    end
-  end if env_tz_works
-
-  def test_shifting_weekly_dst_change
-    Dir.mktmpdir do |tmpdir|
-      assert_separately([{"TZ"=>"Europe/London"}, *%W"-rlogger -C#{tmpdir} -"], "#{<<-"begin;"}\n#{<<-'end;'}")
-      begin;
-        begin
-          module FakeTime
-            attr_accessor :now
-          end
-
-          class << Time
-            prepend FakeTime
-          end
-
-          log = "log"
-          File.open(log, "w") {}
-          Time.now = Time.mktime(2015, 10, 25, 0, 1, 1)
-          File.utime(Time.now, Time.now, log)
-
-          dev = Logger::LogDevice.new("log", shift_age: 'weekly')
-          dev.write("#{Time.now} hello-1\n")
-          File.utime(Time.now, Time.now, log)
-        ensure
-          dev.close if dev
-        end
-      end;
-      log = File.join(tmpdir, "log")
-      cont = File.read(log)
-      assert_match(/hello-1/, cont)
-    end
-  end if env_tz_works
-
-  def test_shifting_monthly_dst_change
-    Dir.mktmpdir do |tmpdir|
-      assert_separately([{"TZ"=>"Europe/London"}, *%W"-rlogger -C#{tmpdir} -"], "#{<<-"begin;"}\n#{<<-'end;'}")
-      begin;
-        begin
-          module FakeTime
-            attr_accessor :now
-          end
-
-          class << Time
-            prepend FakeTime
-          end
-
-          log = "log"
-          File.open(log, "w") {}
-          Time.now = Time.utc(2016, 9, 1, 0, 1, 1)
-          File.utime(Time.now, Time.now, log)
-
-          dev = Logger::LogDevice.new("log", shift_age: 'monthly')
-
-          Time.now = Time.utc(2016, 9, 8, 7, 6, 5)
-          dev.write("#{Time.now} hello-1\n")
-          File.utime(Time.now, Time.now, log)
-
-          Time.now = Time.utc(2016, 10, 9, 8, 7, 6)
-          dev.write("#{Time.now} hello-2\n")
-          File.utime(Time.now, Time.now, log)
-
-          Time.now = Time.utc(2016, 10, 9, 8, 7, 7)
-          dev.write("#{Time.now} hello-3\n")
-          File.utime(Time.now, Time.now, log)
-        ensure
-          dev.close if dev
-        end
-      end;
-      log = File.join(tmpdir, "log")
-      cont = File.read(log)
-      assert_match(/hello-2/, cont)
-      assert_not_match(/hello-1/, cont)
-      log = Dir.glob(log+".*")
-      assert_equal(1, log.size)
-      log, = *log
-      cont = File.read(log)
-      assert_match(/hello-1/, cont)
-      assert_equal("2016-09-08", cont[/^[-\d]+/])
-      assert_equal("20160930", log[/\d+\z/])
-    end
-  end if env_tz_works
-
-  def test_shifting_midnight_exist_file
-    Dir.mktmpdir do |tmpdir|
-      assert_in_out_err([*%W"--disable=gems -rlogger -C#{tmpdir} -"], "#{<<-"begin;"}\n#{<<-'end;'}")
-      begin;
-        begin
-          module FakeTime
-            attr_accessor :now
-          end
-
-          class << Time
-            prepend FakeTime
-          end
-
-          log = "log"
-          File.open(log, "w") {}
-          File.utime(*[Time.mktime(2014, 1, 2, 0, 0, 0)]*2, log)
-
-          Time.now = Time.mktime(2014, 1, 2, 23, 59, 59, 999000)
-          dev = Logger::LogDevice.new(log, shift_age: 'daily')
-          dev.write("#{Time.now} hello-1\n")
-          dev.close
-          File.utime(Time.now, Time.now, log)
-
-          Time.now = Time.mktime(2014, 1, 3, 1, 1, 1)
-          dev = Logger::LogDevice.new(log, shift_age: 'daily')
-          dev.write("#{Time.now} hello-2\n")
-          File.utime(Time.now, Time.now, log)
-        ensure
-          dev.close
-        end
-      end;
-
-      bug = '[GH-539]'
-      log = File.join(tmpdir, "log")
-      cont = File.read(log)
-      assert_match(/hello-2/, cont)
-      assert_not_match(/hello-1/, cont)
-      assert_file.for(bug).exist?(log+".20140102")
-      assert_match(/hello-1/, File.read(log+".20140102"), bug)
-    end
-  end
-
-  env_tz_works = /linux|darwin|freebsd/ =~ RUBY_PLATFORM # borrow from test/ruby/test_time_tz.rb
-
-  def test_shifting_weekly_exist_file
-    Dir.mktmpdir do |tmpdir|
-      assert_in_out_err([{"TZ"=>"UTC"}, *%W"-rlogger -C#{tmpdir} -"], "#{<<-"begin;"}\n#{<<-'end;'}")
-      begin;
-        begin
-          module FakeTime
-            attr_accessor :now
-          end
-
-          class << Time
-            prepend FakeTime
-          end
-
-          log = "log"
-          File.open(log, "w") {}
-          Time.now = Time.utc(2015, 12, 14, 0, 1, 1)
-          File.utime(Time.now, Time.now, log)
-
-          dev = Logger::LogDevice.new("log", shift_age: 'weekly')
-
-          Time.now = Time.utc(2015, 12, 19, 12, 34, 56)
-          dev.write("#{Time.now} hello-1\n")
-          dev.close
-          File.utime(Time.now, Time.now, log)
-
-          Time.now = Time.utc(2015, 12, 20, 0, 1, 1)
-          dev = Logger::LogDevice.new("log", shift_age: 'weekly')
-          dev.write("#{Time.now} hello-2\n")
-          File.utime(Time.now, Time.now, log)
-        ensure
-          dev.close if dev
-        end
-      end;
-      log = File.join(tmpdir, "log")
-      cont = File.read(log)
-      assert_match(/hello-2/, cont)
-      assert_not_match(/hello-1/, cont)
-      log = Dir.glob(log+".*")
-      assert_equal(1, log.size)
-      log, = *log
-      cont = File.read(log)
-      assert_match(/hello-1/, cont)
-      assert_equal("2015-12-19", cont[/^[-\d]+/])
-      assert_equal("20151219", log[/\d+\z/])
-    end
-  end if env_tz_works
-
-  def test_shifting_monthly_exist_file
-    Dir.mktmpdir do |tmpdir|
-      assert_in_out_err([{"TZ"=>"UTC"}, *%W"-rlogger -C#{tmpdir} -"], "#{<<-"begin;"}\n#{<<-'end;'}")
-      begin;
-        begin
-          module FakeTime
-            attr_accessor :now
-          end
-
-          class << Time
-            prepend FakeTime
-          end
-
-          log = "log"
-          File.open(log, "w") {}
-          Time.now = Time.utc(2015, 12, 14, 0, 1, 1)
-          File.utime(Time.now, Time.now, log)
-
-          dev = Logger::LogDevice.new("log", shift_age: 'monthly')
-
-          Time.now = Time.utc(2015, 12, 31, 12, 34, 56)
-          dev.write("#{Time.now} hello-1\n")
-          dev.close
-          File.utime(Time.now, Time.now, log)
-
-          Time.now = Time.utc(2016, 1, 1, 0, 1, 1)
-          dev = Logger::LogDevice.new("log", shift_age: 'monthly')
-          dev.write("#{Time.now} hello-2\n")
-          File.utime(Time.now, Time.now, log)
-        ensure
-          dev.close if dev
-        end
-      end;
-      log = File.join(tmpdir, "log")
-      cont = File.read(log)
-      assert_match(/hello-2/, cont)
-      assert_not_match(/hello-1/, cont)
-      log = Dir.glob(log+".*")
-      assert_equal(1, log.size)
-      log, = *log
-      cont = File.read(log)
-      assert_match(/hello-1/, cont)
-      assert_equal("2015-12-31", cont[/^[-\d]+/])
-      assert_equal("20151231", log[/\d+\z/])
-    end
-  end if env_tz_works
-
-  private
-
-  def run_children(n, args, src)
-    r, w = IO.pipe
-    [w, *(1..n).map do
-       f = IO.popen([EnvUtil.rubybin, *%w[--disable=gems -rlogger -], *args], "w", err: w)
-       f.puts(src)
-       f
-     end].each(&:close)
-    stderr = r.read
-    r.close
-    stderr
-  end
-end
diff --git a/test/mri/logger/test_logger.rb b/test/mri/logger/test_logger.rb
deleted file mode 100644
index 2023553a6c1..00000000000
--- a/test/mri/logger/test_logger.rb
+++ /dev/null
@@ -1,402 +0,0 @@
-# coding: US-ASCII
-# frozen_string_literal: false
-require 'logger'
-require 'tempfile'
-
-class TestLogger < Test::Unit::TestCase
-  include Logger::Severity
-
-  def setup
-    @logger = Logger.new(nil)
-  end
-
-  class Log
-    attr_reader :label, :datetime, :pid, :severity, :progname, :msg
-    def initialize(line)
-      /\A(\w+), \[([^#]*) #(\d+)\]\s+(\w+) -- (\w*): ([\x0-\xff]*)/ =~ line
-      @label, @datetime, @pid, @severity, @progname, @msg = $1, $2, $3, $4, $5, $6
-    end
-  end
-
-  def log_add(logger, severity, msg, progname = nil, &block)
-    log(logger, :add, severity, msg, progname, &block)
-  end
-
-  def log(logger, msg_id, *arg, &block)
-    Log.new(log_raw(logger, msg_id, *arg, &block))
-  end
-
-  def log_raw(logger, msg_id, *arg, &block)
-    Tempfile.create(File.basename(__FILE__) + '.log') {|logdev|
-      logger.instance_eval { @logdev = Logger::LogDevice.new(logdev) }
-      logger.__send__(msg_id, *arg, &block)
-      logdev.rewind
-      logdev.read
-    }
-  end
-
-  def test_level
-    @logger.level = UNKNOWN
-    assert_equal(UNKNOWN, @logger.level)
-    @logger.level = INFO
-    assert_equal(INFO, @logger.level)
-    @logger.sev_threshold = ERROR
-    assert_equal(ERROR, @logger.sev_threshold)
-    @logger.sev_threshold = WARN
-    assert_equal(WARN, @logger.sev_threshold)
-    assert_equal(WARN, @logger.level)
-
-    @logger.level = DEBUG
-    assert(@logger.debug?)
-    assert(@logger.info?)
-    @logger.level = INFO
-    assert(!@logger.debug?)
-    assert(@logger.info?)
-    assert(@logger.warn?)
-    @logger.level = WARN
-    assert(!@logger.info?)
-    assert(@logger.warn?)
-    assert(@logger.error?)
-    @logger.level = ERROR
-    assert(!@logger.warn?)
-    assert(@logger.error?)
-    assert(@logger.fatal?)
-    @logger.level = FATAL
-    assert(!@logger.error?)
-    assert(@logger.fatal?)
-    @logger.level = UNKNOWN
-    assert(!@logger.error?)
-    assert(!@logger.fatal?)
-  end
-
-  def test_symbol_level
-    logger_symbol_levels = {
-      debug:   DEBUG,
-      info:    INFO,
-      warn:    WARN,
-      error:   ERROR,
-      fatal:   FATAL,
-      unknown: UNKNOWN,
-      DEBUG:   DEBUG,
-      INFO:    INFO,
-      WARN:    WARN,
-      ERROR:   ERROR,
-      FATAL:   FATAL,
-      UNKNOWN: UNKNOWN,
-    }
-    logger_symbol_levels.each do |symbol, level|
-      @logger.level = symbol
-      assert(@logger.level == level)
-    end
-    assert_raise(ArgumentError) { @logger.level = :something_wrong }
-  end
-
-  def test_string_level
-    logger_string_levels = {
-      'debug'   => DEBUG,
-      'info'    => INFO,
-      'warn'    => WARN,
-      'error'   => ERROR,
-      'fatal'   => FATAL,
-      'unknown' => UNKNOWN,
-      'DEBUG'   => DEBUG,
-      'INFO'    => INFO,
-      'WARN'    => WARN,
-      'ERROR'   => ERROR,
-      'FATAL'   => FATAL,
-      'UNKNOWN' => UNKNOWN,
-    }
-    logger_string_levels.each do |string, level|
-      @logger.level = string
-      assert(@logger.level == level)
-    end
-    assert_raise(ArgumentError) { @logger.level = 'something_wrong' }
-  end
-
-  def test_reraise_write_errors
-    c = Object.new
-    e = Class.new(StandardError)
-    c.define_singleton_method(:write){|*| raise e}
-    c.define_singleton_method(:close){}
-    logger = Logger.new(c, :reraise_write_errors=>[e])
-    assert_raise(e) { logger.warn('foo') }
-  end
-
-  def test_progname
-    assert_nil(@logger.progname)
-    @logger.progname = "name"
-    assert_equal("name", @logger.progname)
-  end
-
-  def test_datetime_format
-    verbose, $VERBOSE = $VERBOSE, false
-    dummy = STDERR
-    logger = Logger.new(dummy)
-    log = log_add(logger, INFO, "foo")
-    assert_match(/^\d\d\d\d-\d\d-\d\dT\d\d:\d\d:\d\d.\s*\d+$/, log.datetime)
-    logger.datetime_format = "%d%b%Y@%H:%M:%S"
-    log = log_add(logger, INFO, "foo")
-    assert_match(/^\d\d\w\w\w\d\d\d\d@\d\d:\d\d:\d\d$/, log.datetime)
-    logger.datetime_format = ""
-    log = log_add(logger, INFO, "foo")
-    assert_match(/^$/, log.datetime)
-  ensure
-    $VERBOSE = verbose
-  end
-
-  def test_formatter
-    dummy = STDERR
-    logger = Logger.new(dummy)
-    # default
-    log = log(logger, :info, "foo")
-    assert_equal("foo\n", log.msg)
-    # config
-    logger.formatter = proc { |severity, timestamp, progname, msg|
-      "#{severity}:#{msg}\n\n"
-    }
-    line = log_raw(logger, :info, "foo")
-    assert_equal("INFO:foo\n\n", line)
-    # recover
-    logger.formatter = nil
-    log = log(logger, :info, "foo")
-    assert_equal("foo\n", log.msg)
-    # again
-    o = Object.new
-    def o.call(severity, timestamp, progname, msg)
-      "<<#{severity}-#{msg}>>\n"
-    end
-    logger.formatter = o
-    line = log_raw(logger, :info, "foo")
-    assert_equal("<""<INFO-foo>>\n", line)
-  end
-
-  def test_initialize
-    logger = Logger.new(STDERR)
-    assert_nil(logger.progname)
-    assert_equal(DEBUG, logger.level)
-    assert_nil(logger.datetime_format)
-  end
-
-  def test_initialize_with_level
-    # default
-    logger = Logger.new(STDERR)
-    assert_equal(Logger::DEBUG, logger.level)
-    # config
-    logger = Logger.new(STDERR, level: :info)
-    assert_equal(Logger::INFO, logger.level)
-  end
-
-  def test_initialize_with_progname
-    # default
-    logger = Logger.new(STDERR)
-    assert_equal(nil, logger.progname)
-    # config
-    logger = Logger.new(STDERR, progname: :progname)
-    assert_equal(:progname, logger.progname)
-  end
-
-  def test_initialize_with_formatter
-    # default
-    logger = Logger.new(STDERR)
-    log = log(logger, :info, "foo")
-    assert_equal("foo\n", log.msg)
-    # config
-    logger = Logger.new(STDERR, formatter: proc { |severity, timestamp, progname, msg|
-      "#{severity}:#{msg}\n\n"
-    })
-    line = log_raw(logger, :info, "foo")
-    assert_equal("INFO:foo\n\n", line)
-  end
-
-  def test_initialize_with_datetime_format
-    # default
-    logger = Logger.new(STDERR)
-    log = log_add(logger, INFO, "foo")
-    assert_match(/^\d\d\d\d-\d\d-\d\dT\d\d:\d\d:\d\d.\s*\d+$/, log.datetime)
-    # config
-    logger = Logger.new(STDERR, datetime_format: "%d%b%Y@%H:%M:%S")
-    log = log_add(logger, INFO, "foo")
-    assert_match(/^\d\d\w\w\w\d\d\d\d@\d\d:\d\d:\d\d$/, log.datetime)
-  end
-
-  def test_reopen
-    logger = Logger.new(STDERR)
-    logger.reopen(STDOUT)
-    assert_equal(STDOUT, logger.instance_variable_get(:@logdev).dev)
-  end
-
-  def test_reopen_nil_logdevice
-    logger = Logger.new(File::NULL)
-    assert_nothing_raised do
-      logger.reopen(STDOUT)
-    end
-  end
-
-  def test_add
-    logger = Logger.new(nil)
-    logger.progname = "my_progname"
-    assert(logger.add(INFO))
-    log = log_add(logger, nil, "msg")
-    assert_equal("ANY", log.severity)
-    assert_equal("my_progname", log.progname)
-    logger.level = WARN
-    assert(logger.log(INFO))
-    assert_nil(log_add(logger, INFO, "msg").msg)
-    log = log_add(logger, WARN, nil) { "msg" }
-    assert_equal("msg\n", log.msg)
-    log = log_add(logger, WARN, "") { "msg" }
-    assert_equal("\n", log.msg)
-    assert_equal("my_progname", log.progname)
-    log = log_add(logger, WARN, nil, "progname?")
-    assert_equal("progname?\n", log.msg)
-    assert_equal("my_progname", log.progname)
-    #
-    logger = Logger.new(nil)
-    log = log_add(logger, INFO, nil, false)
-    assert_equal("false\n", log.msg)
-  end
-
-  def test_add_binary_data_with_binmode_logdev
-    EnvUtil.with_default_internal(Encoding::UTF_8) do
-      begin
-        tempfile = Tempfile.new("logger")
-        tempfile.close
-        filename = tempfile.path
-        File.unlink(filename)
-
-        logger = Logger.new filename, binmode: true
-        logger.level = Logger::DEBUG
-
-        str = +"\x80"
-        str.force_encoding("ASCII-8BIT")
-
-        logger.add Logger::DEBUG, str
-        assert_equal(2, File.binread(filename).split(/\n/).size)
-      ensure
-        logger.close
-        tempfile.unlink
-      end
-    end
-  end
-
-  def test_level_log
-    logger = Logger.new(nil)
-    logger.progname = "my_progname"
-    log = log(logger, :debug, "custom_progname") { "msg" }
-    assert_equal("msg\n", log.msg)
-    assert_equal("custom_progname", log.progname)
-    assert_equal("DEBUG", log.severity)
-    assert_equal("D", log.label)
-    #
-    log = log(logger, :debug) { "msg_block" }
-    assert_equal("msg_block\n", log.msg)
-    assert_equal("my_progname", log.progname)
-    log = log(logger, :debug, "msg_inline")
-    assert_equal("msg_inline\n", log.msg)
-    assert_equal("my_progname", log.progname)
-    #
-    log = log(logger, :info, "custom_progname") { "msg" }
-    assert_equal("msg\n", log.msg)
-    assert_equal("custom_progname", log.progname)
-    assert_equal("INFO", log.severity)
-    assert_equal("I", log.label)
-    #
-    log = log(logger, :warn, "custom_progname") { "msg" }
-    assert_equal("msg\n", log.msg)
-    assert_equal("custom_progname", log.progname)
-    assert_equal("WARN", log.severity)
-    assert_equal("W", log.label)
-    #
-    log = log(logger, :error, "custom_progname") { "msg" }
-    assert_equal("msg\n", log.msg)
-    assert_equal("custom_progname", log.progname)
-    assert_equal("ERROR", log.severity)
-    assert_equal("E", log.label)
-    #
-    log = log(logger, :fatal, "custom_progname") { "msg" }
-    assert_equal("msg\n", log.msg)
-    assert_equal("custom_progname", log.progname)
-    assert_equal("FATAL", log.severity)
-    assert_equal("F", log.label)
-    #
-    log = log(logger, :unknown, "custom_progname") { "msg" }
-    assert_equal("msg\n", log.msg)
-    assert_equal("custom_progname", log.progname)
-    assert_equal("ANY", log.severity)
-    assert_equal("A", log.label)
-  end
-
-  def test_close
-    r, w = IO.pipe
-    assert(!w.closed?)
-    logger = Logger.new(w)
-    logger.close
-    assert(w.closed?)
-    r.close
-  end
-
-  class MyError < StandardError
-  end
-
-  class MyMsg
-    def inspect
-      "my_msg"
-    end
-  end
-
-  def test_format
-    logger = Logger.new(nil)
-    log = log_add(logger, INFO, "msg\n")
-    assert_equal("msg\n\n", log.msg)
-    begin
-      raise MyError.new("excn")
-    rescue MyError => e
-      log = log_add(logger, INFO, e)
-      assert_match(/^excn $TestLogger::MyError$/, log.msg)
-      # expects backtrace is dumped across multi lines.  10 might be changed.
-      assert(log.msg.split(/\n/).size >= 10)
-    end
-    log = log_add(logger, INFO, MyMsg.new)
-    assert_equal("my_msg\n", log.msg)
-  end
-
-  def test_lshift
-    r, w = IO.pipe
-    logger = Logger.new(w)
-    logger << "msg"
-    IO.select([r], nil, nil, 0.1)
-    w.close
-    msg = r.read
-    r.close
-    assert_equal("msg", msg)
-    #
-    r, w = IO.pipe
-    logger = Logger.new(w)
-    logger << "msg2\n\n"
-    IO.select([r], nil, nil, 0.1)
-    w.close
-    msg = r.read
-    r.close
-    assert_equal("msg2\n\n", msg)
-  end
-
-  class CustomLogger < Logger
-    def level
-      INFO
-    end
-  end
-
-  def test_overriding_level
-    logger = CustomLogger.new(nil)
-    log = log(logger, :info) { "msg" }
-    assert_equal "msg\n", log.msg
-    #
-    log = log(logger, :debug) { "msg" }
-    assert_nil log.msg
-  end
-
-  def test_does_not_instantiate_log_device_for_File_NULL
-    l = Logger.new(File::NULL)
-    assert_nil(l.instance_variable_get(:@logdev))
-  end
-end
diff --git a/test/mri/logger/test_logperiod.rb b/test/mri/logger/test_logperiod.rb
deleted file mode 100644
index ee38d877c69..00000000000
--- a/test/mri/logger/test_logperiod.rb
+++ /dev/null
@@ -1,67 +0,0 @@
-# coding: US-ASCII
-# frozen_string_literal: false
-require "logger"
-require "time"
-
-class TestLogPeriod < Test::Unit::TestCase
-  def test_next_rotate_time
-    time = Time.parse("2019-07-18 13:52:02")
-
-    assert_next_rotate_time_words(time, "2019-07-19 00:00:00", ["daily", :daily])
-    assert_next_rotate_time_words(time, "2019-07-21 00:00:00", ["weekly", :weekly])
-    assert_next_rotate_time_words(time, "2019-08-01 00:00:00", ["monthly", :monthly])
-
-    assert_raise(ArgumentError) { Logger::Period.next_rotate_time(time, "invalid") }
-  end
-
-  def test_next_rotate_time_extreme_cases
-    # First day of Month and Saturday
-    time = Time.parse("2018-07-01 00:00:00")
-
-    assert_next_rotate_time_words(time, "2018-07-02 00:00:00", ["daily", :daily])
-    assert_next_rotate_time_words(time, "2018-07-08 00:00:00", ["weekly", :weekly])
-    assert_next_rotate_time_words(time, "2018-08-01 00:00:00", ["monthly", :monthly])
-
-    assert_raise(ArgumentError) { Logger::Period.next_rotate_time(time, "invalid") }
-  end
-
-  def test_previous_period_end
-    time = Time.parse("2019-07-18 13:52:02")
-
-    assert_previous_period_end_words(time, "2019-07-17 23:59:59", ["daily", :daily])
-    assert_previous_period_end_words(time, "2019-07-13 23:59:59", ["weekly", :weekly])
-    assert_previous_period_end_words(time, "2019-06-30 23:59:59", ["monthly", :monthly])
-
-    assert_raise(ArgumentError) { Logger::Period.previous_period_end(time, "invalid") }
-  end
-
-  def test_previous_period_end_extreme_cases
-    # First day of Month and Saturday
-    time = Time.parse("2018-07-01 00:00:00")
-    previous_date = "2018-06-30 23:59:59"
-
-    assert_previous_period_end_words(time, previous_date, ["daily", :daily])
-    assert_previous_period_end_words(time, previous_date, ["weekly", :weekly])
-    assert_previous_period_end_words(time, previous_date, ["monthly", :monthly])
-
-    assert_raise(ArgumentError) { Logger::Period.previous_period_end(time, "invalid") }
-  end
-
-  private
-
-  def assert_next_rotate_time_words(time, next_date, words)
-    assert_time_words(:next_rotate_time, time, next_date, words)
-  end
-
-  def assert_previous_period_end_words(time, previous_date, words)
-    assert_time_words(:previous_period_end, time, previous_date, words)
-  end
-
-  def assert_time_words(method, time, date, words)
-    words.each do |word|
-      daily_result = Logger::Period.public_send(method, time, word)
-      expected_result = Time.parse(date)
-      assert_equal(expected_result, daily_result)
-    end
-  end
-end
diff --git a/test/mri/logger/test_severity.rb b/test/mri/logger/test_severity.rb
deleted file mode 100644
index fb26939e9d9..00000000000
--- a/test/mri/logger/test_severity.rb
+++ /dev/null
@@ -1,94 +0,0 @@
-# coding: US-ASCII
-# frozen_string_literal: false
-require 'logger'
-
-class TestLoggerSeverity < Test::Unit::TestCase
-  include Logger::Severity
-
-  def test_enum
-    logger_levels = Logger.constants
-    levels = ["WARN", "UNKNOWN", "INFO", "FATAL", "DEBUG", "ERROR"]
-    Logger::Severity.constants.each do |level|
-      assert(levels.include?(level.to_s))
-      assert(logger_levels.include?(level))
-    end
-    assert_equal(levels.size, Logger::Severity.constants.size)
-  end
-
-  def test_level_assignment
-    logger = Logger.new(nil)
-
-    Logger::Severity.constants.each do |level|
-      next if level == :UNKNOWN
-
-      logger.send("#{level.downcase}!")
-      assert(logger.level) == Logger::Severity.const_get(level)
-    end
-  end
-
-  def test_fiber_local_level
-    logger = Logger.new(nil)
-    logger.level = INFO # default level
-    other = Logger.new(nil)
-    other.level = ERROR # default level
-
-    assert_equal(other.level, ERROR)
-    logger.with_level(:WARN) do
-      assert_equal(other.level, ERROR)
-      assert_equal(logger.level, WARN)
-
-      logger.with_level(DEBUG) do # verify reentrancy
-        assert_equal(logger.level, DEBUG)
-
-        Fiber.new do
-          assert_equal(logger.level, INFO)
-          logger.with_level(:WARN) do
-            assert_equal(other.level, ERROR)
-            assert_equal(logger.level, WARN)
-          end
-          assert_equal(logger.level, INFO)
-        end.resume
-
-        assert_equal(logger.level, DEBUG)
-      end
-      assert_equal(logger.level, WARN)
-    end
-    assert_equal(logger.level, INFO)
-  end
-
-  def test_thread_local_level
-    subclass = Class.new(Logger) do
-      def level_key
-        Thread.current
-      end
-    end
-
-    logger = subclass.new(nil)
-    logger.level = INFO # default level
-    other = subclass.new(nil)
-    other.level = ERROR # default level
-
-    assert_equal(other.level, ERROR)
-    logger.with_level(:WARN) do
-      assert_equal(other.level, ERROR)
-      assert_equal(logger.level, WARN)
-
-      logger.with_level(DEBUG) do # verify reentrancy
-        assert_equal(logger.level, DEBUG)
-
-        Fiber.new do
-          assert_equal(logger.level, DEBUG)
-          logger.with_level(:WARN) do
-            assert_equal(other.level, ERROR)
-            assert_equal(logger.level, WARN)
-          end
-          assert_equal(logger.level, DEBUG)
-        end.resume
-
-        assert_equal(logger.level, DEBUG)
-      end
-      assert_equal(logger.level, WARN)
-    end
-    assert_equal(logger.level, INFO)
-  end
-end
diff --git a/test/mri/openssl/fixtures/pkey/certificate.der b/test/mri/openssl/fixtures/pkey/certificate.der
deleted file mode 100644
index 7d44df8413aac2a7b71767f5926cb70c12bf77f2..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1325
zcmXqLV%0QgVi8=x%*4pVB*YS}Y5&@@R;=l@RQB2j6>jsr40zc%wc0$|zVk9Na<eiR
z7#VUKaI!Invaks=g$5gn8Hj*5T*ACQsU_;g3a)v{MU@35Fh$J5OhLv5a^k#3h6W~v
z<_1P4#)g(rV6M5L8I)@vV<=@H0WyYJSg^djTrW94B{jb!F}oDV$~9<WR6=$HBP#=Q
z6C*zZP@IdYiII`v_=?Ism+w#VdYhP&e&uU3&lZP68<(Z-l(4&<EF%(h&|LQ2ZjSio
zJKi?7wK-|p-6tlnX=pI2D*YA`t_cjX*=)3dsrH7~llj`xdGV|7DTQlEWLyXcckNMg
z-WA{XrX{^Y%W3bmj=-mT*BbNwKY!<l&R^lM-pMw3uagc$&aP8C6`sYzZxrI-V!3`o
z+4QLI;v4KFRmvuaJfF27((3T-$lZIg_D0QSJm15sRU^7_^@43K?w?cr6~A>qoMbzx
zr^>1MTJ>-D0P$2l@5%3;SHFF9AgW;h6U~I%=l@Fj-~4dnkJqkKJBxlrx;{HD*3g<N
z=qx9i7Z$gptDxNT_=&%Y=NqPJGBGnUFfMLl@-=8;@-*NBhNCP$BjbM-7G@^a1qQMp
zzA6hSo;bAG7+G1_nHk|MCIcRjv@l3HlK}%nF&~Q<i^!=?#hE)c1}Wrr+HMR=T_1ep
z^v*~Fd5~gd76}8f1`!dx&Enf5!cMOX;B<H<zkY7F$f08fp)ivf8Cg6H+zk|Ad;`Wd
z(TtLk0xNy}B4fRLy_{5FI?>B7N;gn~D`9FALnz5aDA6~N0og0aB5EMqge86WfMgX|
zTn(HJIM~?I8+jO+7!AzXxPiW9VQjh&^c<sshJhN)9wtUHDX2Zk1;s#XN{T^_0VZ0o
zdzu(o*|@-3uT?U!FtId#V`==%@R6aMVT!^YxxTBtIUU9FP2Ea5ycciz#^v}=u}!?~
zryt?F=nw+~W5wM!{~{O|SeO|+4BVI$85Tx3zdl%9^Ql5?^Rf9VA@^SBeHVDy?{9Bg
z`|WCCQlT_ZNvr?I(k)WS|7L%$sC#qe=!TEG<2$qdmui@Ci5IZCrExKoF?@@eqJOd6
zKuIJ-g2P}+Sl?q`VM*it_j&XcxX<`~OnD5o*bi*6yMZgv)NAGY>w44LcK*FplvjT;
zzOrX;*M9Rh(eEL$Grbg_w$5Nu;8m;I#dqM87_XMi(eSn)1<mvy`;3(Dwk&zJ?-RqZ
z*ME_-95CMlvm7Hsk)mPemRCVXXH5E6_(|dEN0%AFv2vL+=bvXkHT%b((`hS>)<0d%
z`rr2QKG7YmwflVgdrMEX`EQpL>%S@fJLpwIxE*I>!r55CUu7cf=@OSWdFVyF71$Bv
z9~?CKTXU>wg5=_tSGb&_8xFLn{9@i=sOc{3R1*BtXPNbD-E=+Ktrh=8I~6b6b^O{R
z`AqletB4ubtz(~fH2u4JSH{`#LjH}XKF_lKLtowPc+26nJ-T}4`t$iS*NH6n;p8h9
z*>mvJPPx@S2laVA@YL<uIgR5be`G~b_!)srcGliW@k<(~?9n{qw_0(cl0@9vrd)+9
Z0U@rN4*R}v51n<EYhLPhR_`rGH~}7;-uwUn

literal 1024
zcmV+b1poUViwFP?8!t!z1MEF(ciT3y{TluXG)a4{#CqDY8+nzpv_#w7>Q#|SoNo5$
zP!w!)E0J1~@?*QbzkO!_kOV2omJ>hPu6PogoWaZhGlRhZAmOoheREFTe7R69>=nOx
zl&b{SeznSf@1=i>>zi`9RNmPuS9i;M-@sjIfA<?weVpo~uXzw!J|W+Xov9Q0&dPFk
z;s2o5IAwopJoelN_k#P|AAXiM_J4|Nnf(Daoy;shp#FpS!dmt(?e6XFmn-{~U9kUN
zb*Hki|5IFd*}n<+GiO4-Mg|&qZ+CZv{ma$L?ta?-l~Sb&{lD~3jlAvpAGiN25?Pp(
z3zb5-lCOYC%9YYPMR}EfxJ!9Oj;Tw1YeH<#J#)_Iz7;y2OS~EW3LaKiuiyQf)-Z=1
zwXKolsuRhzlR|^`q1KlQDcynD8<@kU-UocQ|4AaZBV<eM91qlEEg{p~^NAB&DB7vn
zSAnnEYLS%iPnr=Udwu<bYHG`ohN+r*V+Cca+fZA>MoTpe&4`dEdQ%$?I?Zll*w(N)
zhM??pWn4@Z;ST${b|grKP0eV?68l<DQ_UeOv(ON=^-=v~0F9~YEv-2;v_{NT@3i!e
zHq<*OT3<H-i2?-fXwYg6d#ZWDjAJBB0cV(fy*E7SciXIlWD&h%YW)th8(Lw=Rf(w@
zU1(*a+iq(e(@3h>Pz??0)`6e0JdQL@x_vWUkF?f|Mz@zG1l$L$e+U+84^K3;8R=SL
z`VpGmXbphD5$MK{kbhG@sAvdvV0I<F3av49Wtu1mW0f9t7oEz$W<*9zs5!E!qk;|x
zrZzn8cLzNz5s5U_!=a)7EcX#k_=9q+b+kTs=+NvoyDi`$^GuMMVXj0T4vrIC>^8b;
zq}44<taa2w;Yg<5?Iev*+UhAZTsL(f{u!ExnqZ#4Q&PG;umeDcqFWwy`@=@$7-)%s
z0X!2k#1(nq;I=fV5uZ-1kd8^{kt@r09rv7A?wHJc@7$+BK&J4+I;RgD{eBwgnwizG
z(8))&-_bkASp#sLAabZ5@nA8)o}@L?NKkKEHPe(F)9N0hmeZK0R&sbjiQ~@ZA;A&t
zfz_&az`>TO)p6~~d`uN=KL#!gRjDBLrf>nlv@z%#`Ufpb4Mx#US+rQzDL5v}m0{F&
zkIOsB(!`h*G?}{a=+lP5EXz&AUe>YnmMM*r48vhVqdVv~q*%xJJ+<irZ|>WajC}7Z
zfPVI{@<j^|``wR5Dpim|GcRLENYFxGJJR}ErvWkO@Du30rDAN0$5(+g5)65+_=H`@
un#?Y&5e*$1)3k{N5z2AL^!i~dqqce{>Y)Z14vgn|r>UJL`f7Ar2Ec{_-2&<W

diff --git a/test/mri/rdoc/rdoc/helper.rb b/test/mri/rdoc/rdoc/helper.rb
deleted file mode 100644
index 79854330604..00000000000
--- a/test/mri/rdoc/rdoc/helper.rb
+++ /dev/null
@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'support/test_case'
-require_relative 'support/formatter_test_case'
-require_relative 'support/text_formatter_test_case'
diff --git a/test/mri/rdoc/rdoc/hidden.zip.txt b/test/mri/rdoc/rdoc/hidden.zip.txt
deleted file mode 100644
index 2400e38b7de..00000000000
--- a/test/mri/rdoc/rdoc/hidden.zip.txt
+++ /dev/null
@@ -1 +0,0 @@
-PK
diff --git a/test/mri/rdoc/rdoc/rdoc_alias_test.rb b/test/mri/rdoc/rdoc/rdoc_alias_test.rb
deleted file mode 100644
index 827002e729c..00000000000
--- a/test/mri/rdoc/rdoc/rdoc_alias_test.rb
+++ /dev/null
@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-require_relative 'xref_test_case'
-
-class RDocAliasTest < XrefTestCase
-
-  def test_to_s
-    a = RDoc::Alias.new nil, 'a', 'b', ''
-    a.parent = @c2
-
-    assert_equal 'alias: b -> #a in: RDoc::NormalClass C2 < Object', a.to_s
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc/rdoc_any_method_test.rb b/test/mri/rdoc/rdoc/rdoc_any_method_test.rb
deleted file mode 100644
index e963a3a3453..00000000000
--- a/test/mri/rdoc/rdoc/rdoc_any_method_test.rb
+++ /dev/null
@@ -1,609 +0,0 @@
-# frozen_string_literal: true
-require_relative 'xref_test_case'
-
-class RDocAnyMethodTest < XrefTestCase
-
-  def test_aref
-    m = RDoc::AnyMethod.new nil, 'method?'
-
-    assert_equal 'method-i-method-3F', m.aref
-
-    m.singleton = true
-
-    assert_equal 'method-c-method-3F', m.aref
-  end
-
-  def test_arglists
-    m = RDoc::AnyMethod.new nil, 'method'
-
-    assert_nil m.arglists
-
-    m.params = "(a, b)"
-    m.block_params = "c, d"
-
-    assert_equal "method(a, b) { |c, d| ... }", m.arglists
-
-    call_seq = <<-SEQ
-method(a) { |c| ... }
-method(a, b) { |c, d| ... }
-    SEQ
-
-    m.call_seq = call_seq.dup
-
-    assert_equal call_seq, m.arglists
-  end
-
-  def test_c_function
-    @c1_m.c_function = 'my_c1_m'
-
-    assert_equal 'my_c1_m', @c1_m.c_function
-  end
-
-  def test_call_seq_equals
-    m = RDoc::AnyMethod.new nil, nil
-
-    m.call_seq = ''
-
-    assert_nil m.call_seq
-
-    m.call_seq = 'foo'
-
-    assert_equal 'foo', m.call_seq
-  end
-
-  def test_call_seq_alias_for
-    a = RDoc::AnyMethod.new nil, "each"
-    m = RDoc::AnyMethod.new nil, "each_line"
-
-    a.call_seq = <<-CALLSEQ
-each(foo)
-each_line(foo)
-    CALLSEQ
-
-    m.is_alias_for = a
-
-    assert_equal "each_line(foo)", m.call_seq
-  end
-
-  def test_full_name
-    assert_equal 'C1::m', @c1.method_list.first.full_name
-  end
-
-  def test_has_call_seq?
-    m = RDoc::AnyMethod.new nil, "each_line"
-    m2 = RDoc::AnyMethod.new nil, "each"
-    assert_equal false, m.has_call_seq?
-    m.call_seq = "each_line()"
-    assert_equal true, m.has_call_seq?
-
-    m = RDoc::AnyMethod.new nil, "each_line"
-    m.is_alias_for = m2
-    assert_equal false, m.has_call_seq?
-    m2.call_seq = "each_line()"
-    assert_equal true, m.has_call_seq?
-  end
-
-  def test_is_alias_for
-    assert_equal @c2_b, @c2_a.is_alias_for
-
-    # set string on instance variable
-    loaded = Marshal.load Marshal.dump @c2_a
-
-    loaded.store = @store
-
-    assert_equal @c2_b, loaded.is_alias_for, 'Marshal.load'
-
-    m1 = RDoc::AnyMethod.new nil, 'm1'
-    m1.store = @store
-    m1.instance_variable_set :@is_alias_for, ['Missing', false, 'method']
-
-    assert_nil m1.is_alias_for, 'missing alias'
-  end
-
-  def test_call_seq_handles_aliases
-    # see 0ead786
-    @store.path = Dir.tmpdir
-    top_level = @store.add_file 'file.rb'
-    cm = top_level.add_class RDoc::ClassModule, 'Klass'
-
-    method_with_call_seq = RDoc::AnyMethod.new(nil, "method_with_call_seq")
-    method_with_call_seq.call_seq = <<~SEQ
-      method_with_call_seq(a)
-      method_with_call_seq(a, b)
-      alias_to_method(a)
-      alias_to_method(a, b)
-    SEQ
-    cm.add_method(method_with_call_seq)
-
-    alias_to_method = method_with_call_seq.add_alias(
-      RDoc::Alias.new(nil, "method_with_call_seq", "alias_to_method", "comment"),
-      cm
-    )
-
-    assert_equal("method_with_call_seq(a)\nmethod_with_call_seq(a, b)",
-                 method_with_call_seq.call_seq)
-    assert_equal("alias_to_method(a)\nalias_to_method(a, b)",
-                 alias_to_method.call_seq)
-  end
-
-  def test_call_seq_returns_nil_if_alias_is_missing_from_call_seq
-    @store.path = Dir.tmpdir
-    top_level = @store.add_file 'file.rb'
-    cm = top_level.add_class RDoc::ClassModule, 'Klass'
-
-    method_with_call_seq = RDoc::AnyMethod.new(nil, "method_with_call_seq")
-    method_with_call_seq.call_seq = <<~SEQ
-      method_with_call_seq(a)
-      method_with_call_seq(a, b)
-    SEQ
-    cm.add_method(method_with_call_seq)
-
-    alias_to_method = method_with_call_seq.add_alias(
-      RDoc::Alias.new(nil, "method_with_call_seq", "alias_to_method", "comment"),
-      cm
-    )
-
-    assert_equal("method_with_call_seq(a)\nmethod_with_call_seq(a, b)",
-                 method_with_call_seq.call_seq)
-    assert_nil(alias_to_method.call_seq)
-  end
-
-  def test_markup_code
-    tokens = [
-      { :line_no => 0, :char_no => 0, :kind => :on_const, :text => 'CONSTANT' },
-    ]
-
-    @c2_a.collect_tokens
-    @c2_a.add_tokens(tokens)
-
-    expected = '<span class="ruby-constant">CONSTANT</span>'
-
-    assert_equal expected, @c2_a.markup_code
-  end
-
-  def test_markup_code_with_line_numbers
-    position_comment = "# File #{@file_name}, line 1"
-    tokens = [
-      { :line_no => 1, :char_no => 0, :kind => :on_comment, :text => position_comment },
-      { :line_no => 1, :char_no => position_comment.size, :kind => :on_nl, :text => "\n" },
-      { :line_no => 2, :char_no => 0, :kind => :on_const, :text => 'A' },
-      { :line_no => 2, :char_no => 1, :kind => :on_nl, :text => "\n" },
-      { :line_no => 3, :char_no => 0, :kind => :on_const, :text => 'B' }
-    ]
-
-    @c2_a.collect_tokens
-    @c2_a.add_tokens(tokens)
-
-    assert_equal <<-EXPECTED.chomp, @c2_a.markup_code
-<span class="ruby-comment"># File xref_data.rb, line 1</span>
-<span class="ruby-constant">A</span>
-<span class="ruby-constant">B</span>
-    EXPECTED
-
-    @c2_a.options.line_numbers = true
-    assert_equal <<-EXPECTED.chomp, @c2_a.markup_code
-  <span class="ruby-comment"># File xref_data.rb</span>
-<span class="line-num">1</span> <span class="ruby-constant">A</span>
-<span class="line-num">2</span> <span class="ruby-constant">B</span>
-    EXPECTED
-  end
-
-  def test_markup_code_empty
-    assert_equal '', @c2_a.markup_code
-  end
-
-  def test_markup_code_with_variable_expansion
-    m = RDoc::AnyMethod.new nil, 'method'
-    m.parent = @c1
-    m.block_params = '"Hello, #{world}", yield_arg'
-    m.params = 'a'
-
-    assert_equal '(a) { |"Hello, #{world}", yield_arg| ... }', m.param_seq
-  end
-
-  def test_marshal_dump
-    @store.path = Dir.tmpdir
-    top_level = @store.add_file 'file.rb'
-
-    m = RDoc::AnyMethod.new nil, 'method'
-    m.block_params = 'some_block'
-    m.call_seq     = 'call_seq'
-    m.comment      = 'this is a comment'
-    m.params       = 'param'
-    m.record_location top_level
-
-    cm = top_level.add_class RDoc::ClassModule, 'Klass'
-    cm.add_method m
-
-    section = cm.sections.first
-
-    al = RDoc::Alias.new nil, 'method', 'aliased', 'alias comment'
-    al_m = m.add_alias al, cm
-
-    loaded = Marshal.load Marshal.dump m
-    loaded.store = @store
-
-    document = RDoc::Markup::Document.new(
-                 RDoc::Markup::Paragraph.new('this is a comment'))
-
-    assert_equal m, loaded
-
-    assert_equal [al_m.name],    loaded.aliases.map { |alas| alas.name }
-    assert_equal 'some_block',   loaded.block_params
-    assert_equal 'call_seq',     loaded.call_seq
-    assert_equal document,       loaded.comment.parse
-    assert_equal top_level,      loaded.file
-    assert_equal 'Klass#method', loaded.full_name
-    assert_equal 'method',       loaded.name
-    assert_equal 'param',        loaded.params
-    assert_equal false,          loaded.singleton
-    assert_equal :public,        loaded.visibility
-    assert_equal cm,             loaded.parent
-    assert_equal section,        loaded.section
-  end
-
-  def test_marshal_load_aliased_method
-    aliased_method = Marshal.load Marshal.dump(@c2_a)
-
-    aliased_method.store = @store
-
-    assert_equal 'C2#a',  aliased_method.full_name
-    assert_equal 'C2',    aliased_method.parent_name
-    assert_equal '()',    aliased_method.params
-    assert_equal @c2_b,   aliased_method.is_alias_for, 'is_alias_for'
-    assert                aliased_method.display?
-  end
-
-  def test_marshal_load_aliased_method_with_nil_singleton
-    aliased_method = Marshal.load Marshal.dump(@c2_a)
-
-    aliased_method.store = @store
-    aliased_method.is_alias_for = ["C2", nil, "b"]
-
-    assert_equal 'C2#a',  aliased_method.full_name
-    assert_equal 'C2',    aliased_method.parent_name
-    assert_equal '()',    aliased_method.params
-    assert_equal @c2_b,   aliased_method.is_alias_for, 'is_alias_for'
-    assert                aliased_method.display?
-  end
-
-  def test_marshal_load_class_method
-    class_method = Marshal.load Marshal.dump(@c1.find_class_method_named 'm')
-
-    assert_equal 'C1::m', class_method.full_name
-    assert_equal 'C1',    class_method.parent_name
-    assert_equal '()',    class_method.params
-    assert                class_method.display?
-  end
-
-  def test_marshal_load_instance_method
-    instance_method = Marshal.load Marshal.dump(@c1.find_instance_method_named 'm')
-
-    assert_equal 'C1#m',  instance_method.full_name
-    assert_equal 'C1',    instance_method.parent_name
-    assert_equal '(foo)', instance_method.params
-    assert                instance_method.display?
-  end
-
-  def test_marshal_load_version_0
-    @store.path = Dir.tmpdir
-    top_level = @store.add_file 'file.rb'
-
-    m = RDoc::AnyMethod.new nil, 'method'
-
-    cm = top_level.add_class RDoc::ClassModule, 'Klass'
-    cm.add_method m
-
-    section = cm.sections.first
-
-    al = RDoc::Alias.new nil, 'method', 'aliased', 'alias comment'
-    al_m = m.add_alias al, cm
-
-    loaded = Marshal.load "\x04\bU:\x14RDoc::AnyMethod[\x0Fi\x00I" +
-                          "\"\vmethod\x06:\x06EF\"\x11Klass#method0:\vpublic" +
-                          "o:\eRDoc::Markup::Document\x06:\v@parts[\x06" +
-                          "o:\x1CRDoc::Markup::Paragraph\x06;\t[\x06I" +
-                          "\"\x16this is a comment\x06;\x06FI" +
-                          "\"\rcall_seq\x06;\x06FI\"\x0Fsome_block\x06;\x06F" +
-                          "[\x06[\aI\"\faliased\x06;\x06Fo;\b\x06;\t[\x06" +
-                          "o;\n\x06;\t[\x06I\"\x12alias comment\x06;\x06FI" +
-                          "\"\nparam\x06;\x06F"
-
-    loaded.store = @store
-
-    document = RDoc::Markup::Document.new(
-                 RDoc::Markup::Paragraph.new('this is a comment'))
-
-    assert_equal m, loaded
-
-    assert_equal [al_m.name],    loaded.aliases.map { |alas| alas.name }
-    assert_equal 'some_block',   loaded.block_params
-    assert_equal 'call_seq',     loaded.call_seq
-    assert_equal document,       loaded.comment.parse
-    assert_equal 'Klass#method', loaded.full_name
-    assert_equal 'method',       loaded.name
-    assert_equal 'param',        loaded.params
-    assert_nil                   loaded.singleton # defaults to nil
-    assert_equal :public,        loaded.visibility
-    assert_nil                   loaded.file
-    assert_equal cm,             loaded.parent
-    assert_equal section,        loaded.section
-    assert_nil                   loaded.is_alias_for
-
-    assert loaded.display?
-  end
-
-  def test_marshal_dump_version_2
-    @store.path = Dir.tmpdir
-    top_level = @store.add_file 'file.rb'
-
-    m = RDoc::AnyMethod.new nil, 'method'
-    m.block_params = 'some_block'
-    m.call_seq     = 'call_seq'
-    m.comment      = 'this is a comment'
-    m.params       = 'param'
-    m.record_location top_level
-
-    cm = top_level.add_class RDoc::ClassModule, 'Klass'
-    cm.add_method m
-
-    section = cm.sections.first
-
-    al = RDoc::Alias.new nil, 'method', 'aliased', 'alias comment'
-    al_m = m.add_alias al, cm
-
-    loaded = Marshal.load "\x04\bU:\x14RDoc::AnyMethod[\x14i\bI" +
-                          "\"\vmethod\x06:\x06ETI" +
-                          "\"\x11Klass#method\x06;\x06T0:\vpublic" +
-                          "o:\eRDoc::Markup::Document\b:\v@parts[\x06" +
-                          "o:\x1CRDoc::Markup::Paragraph\x06;\t[\x06I" +
-                          "\"\x16this is a comment\x06;\x06T:\n@file0" +
-                          ":0@omit_headings_from_table_of_contents_below0" +
-                          "I\"\rcall_seq\x06;\x06TI\"\x0Fsome_block\x06" +
-                          ";\x06T[\x06[\aI\"\faliased\x06;\x06To;\b\b;\t" +
-                          "[\x06o;\n\x06;\t[\x06I\"\x12alias comment\x06" +
-                          ";\x06T;\v0;\f0I\"\nparam\x06;\x06TI" +
-                          "\"\ffile.rb\x06;\x06TFI\"\nKlass\x06;\x06T" +
-                          "c\x16RDoc::ClassModule0"
-
-    loaded.store = @store
-
-    document = doc(para('this is a comment'))
-
-    assert_equal m, loaded
-
-    assert_equal [al_m.name],    loaded.aliases.map { |alas| alas.name }
-    assert_equal 'some_block',   loaded.block_params
-    assert_equal 'call_seq',     loaded.call_seq
-    assert_equal document,       loaded.comment.parse
-    assert_equal top_level,      loaded.file
-    assert_equal 'Klass#method', loaded.full_name
-    assert_equal 'method',       loaded.name
-    assert_equal 'param',        loaded.params
-    assert_nil                   loaded.singleton # defaults to nil
-    assert_equal :public,        loaded.visibility
-    assert_equal cm,             loaded.parent
-    assert_equal section,        loaded.section
-    assert_nil                   loaded.is_alias_for
-  end
-
-  def test_name
-    m = RDoc::AnyMethod.new nil, nil
-
-    assert_nil m.name
-  end
-
-  def test_name_call_seq
-    m = RDoc::AnyMethod.new nil, nil
-
-    m.call_seq = "yields(name)\nyields(name, description)"
-
-    assert_equal 'yields', m.name
-  end
-
-  def test_name_call_seq_dot
-    m = RDoc::AnyMethod.new nil, nil
-
-    m.call_seq = "obj.yields(name)\nobj.yields(name, description)"
-
-    assert_equal 'yields', m.name
-  end
-
-  def test_param_list_block_params
-    m = RDoc::AnyMethod.new nil, 'method'
-    m.parent = @c1
-
-    m.block_params = 'c, d'
-
-    assert_equal %w[c d], m.param_list
-  end
-
-  def test_param_list_call_seq
-    m = RDoc::AnyMethod.new nil, 'method'
-    m.parent = @c1
-
-    call_seq = <<-SEQ
-method(a) { |c| ... }
-method(a, b) { |c, d| ... }
-    SEQ
-
-    m.call_seq = call_seq
-
-    assert_equal %w[a b c d], m.param_list
-  end
-
-  def test_param_list_default
-    m = RDoc::AnyMethod.new nil, 'method'
-    m.parent = @c1
-
-    m.params = '(b = default)'
-
-    assert_equal %w[b], m.param_list
-  end
-
-  def test_param_list_params
-    m = RDoc::AnyMethod.new nil, 'method'
-    m.parent = @c1
-
-    m.params = '(a, b)'
-
-    assert_equal %w[a b], m.param_list
-  end
-
-  def test_param_list_params_block_params
-    m = RDoc::AnyMethod.new nil, 'method'
-    m.parent = @c1
-
-    m.params = '(a, b)'
-    m.block_params = 'c, d'
-
-    assert_equal %w[a b c d], m.param_list
-  end
-
-  def test_param_list_empty_params_with_block
-    m = RDoc::AnyMethod.new nil, 'method'
-    m.parent = @c1
-
-    m.params = '()'
-    m.block_params = 'a, b'
-
-    assert_equal %w[a b], m.param_list
-  end
-
-  def test_param_list_ampersand_param_block_params
-    m = RDoc::AnyMethod.new nil, 'method'
-    m.parent = @c1
-
-    m.params = '(a, b, &block)'
-    m.block_params = 'c, d'
-
-    assert_equal %w[a b c d], m.param_list
-  end
-
-  def test_param_list_ampersand_param
-    m = RDoc::AnyMethod.new nil, 'method'
-    m.parent = @c1
-
-    m.params = '(a, b, &block)'
-
-    assert_equal %w[a b block], m.param_list
-  end
-
-  def test_param_seq
-    m = RDoc::AnyMethod.new nil, 'method'
-    m.parent = @c1
-    m.params = 'a'
-
-    assert_equal '(a)', m.param_seq
-
-    m.params = '(a)'
-
-    assert_equal '(a)', m.param_seq
-
-    m.params = "(a,\n  b)"
-
-    assert_equal '(a, b)', m.param_seq
-
-    m.block_params = "c,\n  d"
-
-    assert_equal '(a, b) { |c, d| ... }', m.param_seq
-  end
-
-  def test_param_seq_call_seq
-    m = RDoc::AnyMethod.new nil, 'method'
-    m.parent = @c1
-
-    call_seq = <<-SEQ
-method(a) { |c| ... }
-method(a, b) { |c, d| ... }
-    SEQ
-
-    m.call_seq = call_seq
-
-    assert_equal '(a, b) { |c, d| }', m.param_seq
-
-  end
-
-  def test_parent_name
-    assert_equal 'C1', @c1.method_list.first.parent_name
-    assert_equal 'C1', @c1.method_list.last.parent_name
-  end
-
-  def test_skip_description?
-    m = RDoc::AnyMethod.new nil, "each_line"
-    m2 = RDoc::AnyMethod.new nil, "each"
-    assert_equal false, m.skip_description?
-    assert_equal false, m2.skip_description?
-
-    m.is_alias_for = m2
-    m2.aliases << m
-    assert_equal false, m.skip_description?
-    assert_equal false, m2.skip_description?
-
-    m2.call_seq = "each()"
-    assert_equal true, m.skip_description?
-    assert_equal false, m2.skip_description?
-
-    m2.call_seq = "each_line()"
-    assert_equal false, m.skip_description?
-    assert_equal true, m2.skip_description?
-
-    m2.call_seq = "each()\neach_line()"
-    assert_equal false, m.skip_description?
-    assert_equal false, m2.skip_description?
-  end
-
-  def test_store_equals
-    loaded = Marshal.load Marshal.dump(@c1.method_list.last)
-
-    loaded.store = @store
-
-    assert_equal @store, loaded.file.store
-  end
-
-  def test_superclass_method
-    m3 = RDoc::AnyMethod.new '', 'no_super'
-
-    m2 = RDoc::AnyMethod.new '', 'supers'
-    m2.calls_super = true
-
-    m1 = RDoc::AnyMethod.new '', 'supers'
-
-    c1 = RDoc::NormalClass.new 'Outer'
-    c1.store = @store
-    c1.add_method m1
-
-    c2 = RDoc::NormalClass.new 'Inner', c1
-    c2.store = @store
-    c2.add_method m2
-    c2.add_method m3
-
-    assert_nil m3.superclass_method,
-               'no superclass method for no_super'
-
-    assert_equal m1, m2.superclass_method,
-                 'superclass method missing for supers'
-  end
-
-  def test_superclass_method_multilevel
-    m2 = RDoc::AnyMethod.new '', 'supers'
-    m2.calls_super = true
-
-    m1 = RDoc::AnyMethod.new '', 'supers'
-
-    c1 = RDoc::NormalClass.new 'Outer'
-    c1.store = @store
-    c1.add_method m1
-
-    c2 = RDoc::NormalClass.new 'Middle', c1
-    c2.store = @store
-
-    c3 = RDoc::NormalClass.new 'Inner', c2
-    c3.store = @store
-    c3.add_method m2
-
-    assert_equal m1, m2.superclass_method,
-                 'superclass method missing for supers'
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc/rdoc_attr_test.rb b/test/mri/rdoc/rdoc/rdoc_attr_test.rb
deleted file mode 100644
index fcdbdfd422c..00000000000
--- a/test/mri/rdoc/rdoc/rdoc_attr_test.rb
+++ /dev/null
@@ -1,190 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocAttrTest < RDoc::TestCase
-
-  def setup
-    super
-
-    @a = RDoc::Attr.new nil, 'attr', 'RW', ''
-  end
-
-  def test_aref
-    m = RDoc::Attr.new nil, 'attr', 'RW', nil
-
-    assert_equal 'attribute-i-attr', m.aref
-  end
-
-  def test_arglists
-    assert_nil @a.arglists
-  end
-
-  def test_block_params
-    assert_nil @a.block_params
-  end
-
-  def test_call_seq
-    assert_nil @a.call_seq
-  end
-
-  def test_definition
-    assert_equal 'attr_accessor', @a.definition
-
-    @a.rw = 'R'
-
-    assert_equal 'attr_reader', @a.definition
-
-    @a.rw = 'W'
-
-    assert_equal 'attr_writer', @a.definition
-  end
-
-  def test_full_name
-    assert_equal '(unknown)#attr', @a.full_name
-  end
-
-  def test_marshal_dump
-    tl = @store.add_file 'file.rb'
-
-    @a.comment = 'this is a comment'
-    @a.record_location tl
-
-    cm = tl.add_class RDoc::NormalClass, 'Klass'
-    cm.add_attribute @a
-
-    section = cm.sections.first
-
-    loaded = Marshal.load Marshal.dump @a
-    loaded.store = @store
-
-    assert_equal @a, loaded
-
-    document = RDoc::Markup::Document.new(
-                 RDoc::Markup::Paragraph.new('this is a comment'))
-
-    assert_equal document,      loaded.comment.parse
-    assert_equal 'file.rb',    loaded.file.relative_name
-    assert_equal 'Klass#attr', loaded.full_name
-    assert_equal 'attr',       loaded.name
-    assert_equal 'RW',         loaded.rw
-    assert_equal false,        loaded.singleton
-    assert_equal :public,      loaded.visibility
-    assert_equal tl,           loaded.file
-    assert_equal cm,           loaded.parent
-    assert_equal section,      loaded.section
-  end
-
-  def test_marshal_dump_singleton
-    tl = @store.add_file 'file.rb'
-
-    @a.comment = 'this is a comment'
-    @a.record_location tl
-
-    cm = tl.add_class RDoc::NormalClass, 'Klass'
-    cm.add_attribute @a
-
-    section = cm.sections.first
-
-    @a.rw = 'R'
-    @a.singleton = true
-    @a.visibility = :protected
-
-    loaded = Marshal.load Marshal.dump @a
-    loaded.store = @store
-
-    assert_equal @a, loaded
-
-    document = RDoc::Markup::Document.new(
-                 RDoc::Markup::Paragraph.new('this is a comment'))
-
-    assert_equal document,      loaded.comment.parse
-    assert_equal 'Klass::attr', loaded.full_name
-    assert_equal 'attr',        loaded.name
-    assert_equal 'R',           loaded.rw
-    assert_equal true,          loaded.singleton
-    assert_equal :protected,    loaded.visibility
-    assert_equal tl,            loaded.file
-    assert_equal cm,            loaded.parent
-    assert_equal section,       loaded.section
-  end
-
-  def test_marshal_load_version_1
-    tl = @store.add_file 'file.rb'
-    cm = tl.add_class RDoc::NormalClass, 'Klass'
-    section = cm.sections.first
-
-    data = "\x04\bU:\x0FRDoc::Attr[\fi\x06I\"\tattr\x06:\x06EF" +
-           "\"\x0FKlass#attrI\"\aRW\x06;\x06F:\vpublic" +
-           "o:\eRDoc::Markup::Document\x06:\v@parts[\x06" +
-           "o:\x1CRDoc::Markup::Paragraph\x06;\t[\x06I" +
-           "\"\x16this is a comment\x06;\x06FF"
-
-    loaded = Marshal.load data
-    loaded.store = @store
-
-    document = RDoc::Markup::Document.new(
-                 RDoc::Markup::Paragraph.new('this is a comment'))
-
-    assert_equal document,     loaded.comment.parse
-    assert_equal 'Klass#attr', loaded.full_name
-    assert_equal 'attr',       loaded.name
-    assert_equal 'RW',         loaded.rw
-    assert_equal false,        loaded.singleton
-    assert_equal :public,      loaded.visibility
-
-    # version 2
-    assert_nil                 loaded.file
-
-    # version 3
-    assert_equal cm,           loaded.parent
-    assert_equal section,      loaded.section
-
-    assert                     loaded.display?
-  end
-
-  def test_marshal_load_version_2
-    tl = @store.add_file 'file.rb'
-    cm = tl.add_class RDoc::NormalClass, 'Klass'
-    section = cm.sections.first
-
-    loaded = Marshal.load "\x04\bU:\x0FRDoc::Attr[\ri\aI\"\tattr\x06" +
-                          ":\x06ETI\"\x0FKlass#attr\x06;\x06TI\"\aRW\x06" +
-                          ";\x06T:\vpublico:\eRDoc::Markup::Document\a" +
-                          ":\v@parts[\x06o:\x1CRDoc::Markup::Paragraph\x06;" +
-                          "\t[\x06I\"\x16this is a comment\x06;\x06T:\n" +
-                          "@file0FI\"\ffile.rb\x06;\x06T"
-    loaded.store = @store
-
-    document = doc(para('this is a comment'))
-
-    assert_equal document,     loaded.comment.parse
-    assert_equal 'Klass#attr', loaded.full_name
-    assert_equal 'attr',       loaded.name
-    assert_equal 'RW',         loaded.rw
-    assert_equal false,        loaded.singleton
-    assert_equal :public,      loaded.visibility
-    assert_equal tl,           loaded.file
-
-    # version 3
-    assert_equal cm,           loaded.parent
-    assert_equal section,      loaded.section
-
-    assert loaded.display?
-  end
-
-  def test_params
-    assert_nil @a.params
-  end
-
-  def test_singleton
-    refute @a.singleton
-  end
-
-  def test_type
-    assert_equal 'instance', @a.type
-
-    @a.singleton = true
-    assert_equal 'class', @a.type
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc/rdoc_class_module_test.rb b/test/mri/rdoc/rdoc/rdoc_class_module_test.rb
deleted file mode 100644
index dec1a4c24b8..00000000000
--- a/test/mri/rdoc/rdoc/rdoc_class_module_test.rb
+++ /dev/null
@@ -1,1706 +0,0 @@
-# frozen_string_literal: true
-require_relative 'xref_test_case'
-
-class RDocClassModuleTest < XrefTestCase
-
-  def test_add_comment
-    tl1 = @store.add_file 'one.rb'
-    tl2 = @store.add_file 'two.rb'
-    tl3 = @store.add_file 'three.rb'
-
-    cm = RDoc::ClassModule.new 'Klass'
-    comment_tl1 = RDoc::Comment.new('# comment 1', @top_level, :ruby)
-    cm.add_comment comment_tl1, tl1
-
-    assert_equal [[comment_tl1, tl1]], cm.comment_location
-    assert_equal 'comment 1', cm.comment.text
-
-    comment_tl2 = RDoc::Comment.new('# comment 2', @top_level, :ruby)
-    cm.add_comment comment_tl2, tl2
-
-    assert_equal [[comment_tl1, tl1], [comment_tl2, tl2]], cm.comment_location
-    assert_equal "comment 1\n---\ncomment 2", cm.comment
-
-    comment_tl3 = RDoc::Comment.new('# * comment 3', @top_level, :ruby)
-    cm.add_comment comment_tl3, tl3
-
-    assert_equal [[comment_tl1, tl1],
-                  [comment_tl2, tl2],
-                  [comment_tl3, tl3]], cm.comment_location
-    assert_equal "comment 1\n---\ncomment 2\n---\n* comment 3", cm.comment
-  end
-
-  def test_add_comment_comment
-    cm = RDoc::ClassModule.new 'Klass'
-
-    cm.add_comment comment('comment'), @top_level
-
-    assert_equal 'comment', cm.comment.text
-  end
-
-  def test_add_comment_duplicate
-    tl1 = @store.add_file 'one.rb'
-
-    cm = RDoc::ClassModule.new 'Klass'
-    comment1 = RDoc::Comment.new('# comment 1', @top_level, :ruby)
-    comment2 = RDoc::Comment.new('# comment 2', @top_level, :ruby)
-    cm.add_comment comment1, tl1
-    cm.add_comment comment2, tl1
-
-    assert_equal [[comment1, tl1],
-                  [comment2, tl1]], cm.comment_location
-  end
-
-  def test_add_comment_stopdoc
-    tl = @store.add_file 'file.rb'
-
-    cm = RDoc::ClassModule.new 'Klass'
-    cm.stop_doc
-
-    cm.add_comment '# comment 1', tl
-
-    assert_empty cm.comment
-  end
-
-  def test_ancestors
-    assert_equal [@parent, @object, "BasicObject"], @child.ancestors
-  end
-
-  def test_comment_equals
-    cm = RDoc::ClassModule.new 'Klass'
-    cm.comment = RDoc::Comment.new('# comment 1', @top_level, :ruby)
-
-    assert_equal 'comment 1', cm.comment.to_s
-
-    cm.comment = RDoc::Comment.new('# comment 2', @top_level, :ruby)
-
-    assert_equal "comment 1\n---\ncomment 2", cm.comment.to_s
-
-    cm.comment = RDoc::Comment.new('# * comment 3', @top_level, :ruby)
-
-    assert_equal "comment 1\n---\ncomment 2\n---\n* comment 3", cm.comment.to_s
-  end
-
-  def test_comment_equals_comment
-    cm = RDoc::ClassModule.new 'Klass'
-
-    cm.comment = comment 'comment'
-
-    assert_equal 'comment', cm.comment.text
-  end
-
-  def test_document_self_or_methods
-    assert @c1.document_self_or_methods
-
-    @c1.document_self = false
-
-    assert @c1.document_self_or_methods
-
-    @c1_plus.document_self = false
-    @c1_m.document_self = false
-
-    assert @c1.document_self_or_methods
-
-    @c1__m.document_self = false
-
-    refute @c1.document_self_or_methods
-  end
-
-  def test_documented_eh
-    cm = RDoc::ClassModule.new 'C'
-
-    refute cm.documented?, 'no comments, no markers'
-
-    cm.add_comment '', @top_level
-
-    refute cm.documented?, 'empty comment'
-
-    cm.add_comment 'hi', @top_level
-
-    assert cm.documented?, 'commented'
-
-    cm.comment_location.clear
-
-    refute cm.documented?, 'no comment'
-
-    cm.document_self = nil # notify :nodoc:
-
-    assert cm.documented?, ':nodoc:'
-  end
-
-  def test_each_ancestor
-    assert_equal [@parent, @object], @child.each_ancestor.to_a
-  end
-
-  def test_each_ancestor_cycle
-    m_incl = RDoc::Include.new 'M', nil
-
-    m = @top_level.add_module RDoc::NormalModule, 'M'
-    m.add_include m_incl
-
-    assert_empty m.each_ancestor.to_a
-  end
-
-  # handle making a short module alias of yourself
-
-  def test_find_class_named
-    @c2.classes_hash['C2'] = @c2
-
-    assert_nil @c2.find_class_named('C1')
-  end
-
-  def test_from_module_comment
-    tl = @store.add_file 'file.rb'
-    klass = tl.add_class RDoc::NormalModule, 'Klass'
-    klass.add_comment 'really a class', tl
-
-    klass = RDoc::ClassModule.from_module RDoc::NormalClass, klass
-
-    assert_equal [['really a class', tl]], klass.comment_location
-  end
-
-  def test_marshal_dump
-    @store.path = Dir.tmpdir
-    tl = @store.add_file 'file.rb'
-
-    ns = tl.add_module RDoc::NormalModule, 'Namespace'
-
-    cm = ns.add_class RDoc::NormalClass, 'Klass', 'Super'
-    cm.document_self = true
-    cm.record_location tl
-
-    a1 = RDoc::Attr.new nil, 'a1', 'RW', ''
-    a1.record_location tl
-    a2 = RDoc::Attr.new nil, 'a2', 'RW', '', singleton: true
-    a2.record_location tl
-
-    m1 = RDoc::AnyMethod.new nil, 'm1'
-    m1.record_location tl
-
-    c1 = RDoc::Constant.new 'C1', nil, ''
-    c1.record_location tl
-
-    i1 = RDoc::Include.new 'I1', ''
-    i1.record_location tl
-
-    e1 = RDoc::Extend.new 'E1', ''
-    e1.record_location tl
-
-    section_comment = RDoc::Comment.new('section comment')
-    section_comment.location = tl
-
-    assert_equal 1, cm.sections.length, 'sanity, default section only'
-    s0 = cm.sections.first
-    s1 = cm.add_section 'section', section_comment
-
-    cm.add_attribute a1
-    cm.add_attribute a2
-    cm.add_method m1
-    cm.add_constant c1
-    cm.add_include i1
-    cm.add_extend e1
-    cm.add_comment 'this is a comment', tl
-
-    loaded = Marshal.load Marshal.dump cm
-    loaded.store = @store
-
-    assert_equal cm, loaded
-
-    inner = RDoc::Markup::Document.new(
-      RDoc::Markup::Paragraph.new('this is a comment'))
-    inner.file = tl
-
-    document = RDoc::Markup::Document.new(inner)
-
-    assert_equal [a2, a1],           loaded.attributes.sort
-    assert_equal document,           loaded.comment.parse
-    assert_equal [c1],               loaded.constants
-    assert_equal 'Namespace::Klass', loaded.full_name
-    assert_equal [i1],               loaded.includes
-    assert_equal [e1],               loaded.extends
-    assert_equal [m1],               loaded.method_list
-    assert_equal 'Klass',            loaded.name
-    assert_equal 'Super',            loaded.superclass
-    assert_equal [tl],               loaded.in_files
-    assert_equal 'Namespace',        loaded.parent.name
-
-    expected = { nil => s0, 'section' => s1 }
-    assert_equal expected, loaded.sections_hash
-
-    assert_equal tl, loaded.attributes.first.file
-
-    assert_equal tl, loaded.constants.first.file
-
-    assert_equal tl, loaded.includes.first.file
-
-    assert_equal tl, loaded.extends.first.file
-
-    assert_equal tl, loaded.method_list.first.file
-  end
-
-  def test_marshal_dump_visibility
-    @store.path = Dir.tmpdir
-    tl = @store.add_file 'file.rb'
-
-    ns = tl.add_module RDoc::NormalModule, 'Namespace'
-
-    cm = ns.add_class RDoc::NormalClass, 'Klass', 'Super'
-    cm.record_location tl
-
-    a1 = RDoc::Attr.new nil, 'a1', 'RW', ''
-    a1.record_location tl
-    a1.document_self = false
-
-    m1 = RDoc::AnyMethod.new nil, 'm1'
-    m1.record_location tl
-    m1.document_self = false
-
-    c1 = RDoc::Constant.new 'C1', nil, ''
-    c1.record_location tl
-    c1.document_self = false
-
-    i1 = RDoc::Include.new 'I1', ''
-    i1.record_location tl
-    i1.document_self = false
-
-    e1 = RDoc::Extend.new 'E1', ''
-    e1.record_location tl
-    e1.document_self = false
-
-    section_comment = RDoc::Comment.new('section comment')
-    section_comment.location = tl
-
-    assert_equal 1, cm.sections.length, 'sanity, default section only'
-
-    cm.add_attribute a1
-    cm.add_method m1
-    cm.add_constant c1
-    cm.add_include i1
-    cm.add_extend e1
-    cm.add_comment 'this is a comment', tl
-
-    loaded = Marshal.load Marshal.dump cm
-    loaded.store = @store
-
-    assert_equal cm, loaded
-
-    assert_empty loaded.attributes
-    assert_empty loaded.constants
-    assert_empty loaded.includes
-    assert_empty loaded.extends
-    assert_empty loaded.method_list
-  end
-
-  def test_marshal_load_version_0
-    tl = @store.add_file 'file.rb'
-    ns = tl.add_module RDoc::NormalModule, 'Namespace'
-    cm = ns.add_class RDoc::NormalClass, 'Klass', 'Super'
-
-    a = RDoc::Attr.new(nil, 'a1', 'RW', '')
-    m = RDoc::AnyMethod.new(nil, 'm1')
-    c = RDoc::Constant.new('C1', nil, '')
-    i = RDoc::Include.new('I1', '')
-
-    s0 = cm.sections.first
-
-    cm.add_attribute a
-    cm.add_method m
-    cm.add_constant c
-    cm.add_include i
-    cm.add_comment 'this is a comment', tl
-
-    loaded = Marshal.load "\x04\bU:\x16RDoc::NormalClass[\x0Ei\x00\"\nKlass" +
-                          "\"\x15Namespace::KlassI\"\nSuper\x06:\x06EF" +
-                          "o:\eRDoc::Markup::Document\x06:\v@parts[\x06" +
-                          "o:\x1CRDoc::Markup::Paragraph\x06;\b[\x06I" +
-                          "\"\x16this is a comment\x06;\x06F[\x06[\aI" +
-                          "\"\aa1\x06;\x06FI\"\aRW\x06;\x06F[\x06[\aI" +
-                          "\"\aC1\x06;\x06Fo;\a\x06;\b[\x00[\x06[\aI" +
-                          "\"\aI1\x06;\x06Fo;\a\x06;\b[\x00[\a[\aI" +
-                          "\"\nclass\x06;\x06F[\b[\a:\vpublic[\x00[\a" +
-                          ":\x0Eprotected[\x00[\a:\fprivate[\x00[\aI" +
-                          "\"\rinstance\x06;\x06F[\b[\a;\n[\x06I" +
-                          "\"\am1\x06;\x06F[\a;\v[\x00[\a;\f[\x00"
-
-    loaded.store = @store
-
-    assert_equal cm, loaded
-
-    document = RDoc::Markup::Document.new(
-                 RDoc::Markup::Paragraph.new('this is a comment'))
-
-    assert_equal [a],                loaded.attributes
-    assert_equal document,           loaded.comment.parse
-    assert_equal [c],                loaded.constants
-    assert_equal 'Namespace::Klass', loaded.full_name
-    assert_equal [i],                loaded.includes
-    assert_equal [m],                loaded.method_list
-    assert_equal 'Klass',            loaded.name
-    assert_equal 'Super',            loaded.superclass
-    assert_nil                       loaded.file
-    assert_empty                     loaded.in_files
-    assert_nil                       loaded.parent
-    assert                           loaded.current_section
-
-    expected = { nil => s0 }
-    assert_equal expected, loaded.sections_hash
-
-    assert loaded.display?
-  end
-
-  def test_marshal_load_version_1
-    tl = @store.add_file 'file.rb'
-
-    ns = tl.add_module RDoc::NormalModule, 'Namespace'
-
-    cm = ns.add_class RDoc::NormalClass, 'Klass', 'Super'
-    cm.record_location tl
-
-    a1 = RDoc::Attr.new nil, 'a1', 'RW', ''
-    a1.record_location tl
-    a2 = RDoc::Attr.new nil, 'a2', 'RW', '', singleton: true
-    a2.record_location tl
-
-    m1 = RDoc::AnyMethod.new nil, 'm1'
-    m1.record_location tl
-
-    c1 = RDoc::Constant.new 'C1', nil, ''
-    c1.record_location tl
-
-    i1 = RDoc::Include.new 'I1', ''
-    i1.record_location tl
-
-    s0 = cm.sections.first
-
-    cm.add_attribute a1
-    cm.add_attribute a2
-    cm.add_method m1
-    cm.add_constant c1
-    cm.add_include i1
-    cm.add_comment 'this is a comment', tl
-
-    loaded = Marshal.load "\x04\bU:\x16RDoc::NormalClass[\x0Ei\x06I\"\nKlass" +
-                          "\x06:\x06EFI\"\x15Namespace::Klass\x06;\x06FI" +
-                          "\"\nSuper\x06;\x06Fo:\eRDoc::Markup::Document\a" +
-                          ":\v@parts[\x06o;\a\a;\b[\x06o" +
-                          ":\x1CRDoc::Markup::Paragraph\x06;\b" +
-                          "[\x06I\"\x16this is a comment\x06;\x06F" +
-                          ":\n@fileI\"\ffile.rb\x06;\x06F;\n0[\a[\nI" +
-                          "\"\aa2\x06;\x06FI\"\aRW\x06;\x06F:\vpublicT@\x11" +
-                          "[\nI\"\aa1\x06;\x06FI\"\aRW\x06;\x06F;\vF@\x11" +
-                          "[\x06[\bI\"\aC1\x06;\x06Fo;\a\a;\b[\x00;\n0@\x11" +
-                          "[\x06[\bI\"\aI1\x06;\x06Fo;\a\a;\b[\x00;\n0@\x11" +
-                          "[\a[\aI\"\nclass\x06;\x06F[\b[\a;\v[\x00" +
-                          "[\a:\x0Eprotected[\x00[\a:\fprivate[\x00[\aI" +
-                          "\"\rinstance\x06;\x06F[\b[\a;\v[\x06[\aI" +
-                          "\"\am1\x06;\x06F@\x11[\a;\f[\x00[\a;\r[\x00"
-
-    loaded.store = @store
-
-    assert_equal cm, loaded
-
-    inner = RDoc::Markup::Document.new(
-      RDoc::Markup::Paragraph.new('this is a comment'))
-    inner.file = tl
-
-    document = RDoc::Markup::Document.new(inner)
-
-    assert_equal [a2, a1],           loaded.attributes.sort
-    assert_equal document,           loaded.comment.parse
-    assert_equal [c1],               loaded.constants
-    assert_equal 'Namespace::Klass', loaded.full_name
-    assert_equal [i1],               loaded.includes
-    assert_empty                     loaded.extends
-    assert_equal [m1],               loaded.method_list
-    assert_equal 'Klass',            loaded.name
-    assert_equal 'Super',            loaded.superclass
-    assert_empty                     loaded.in_files
-    assert_nil                       loaded.parent
-    assert                           loaded.current_section
-
-    assert_equal tl, loaded.attributes.first.file
-    assert_equal tl, loaded.constants.first.file
-    assert_equal tl, loaded.includes.first.file
-    assert_equal tl, loaded.method_list.first.file
-
-    expected = { nil => s0 }
-    assert_equal expected, loaded.sections_hash
-  end
-
-  def test_marshal_load_version_2
-    tl = @store.add_file 'file.rb'
-
-    ns = tl.add_module RDoc::NormalModule, 'Namespace'
-
-    cm = ns.add_class RDoc::NormalClass, 'Klass', 'Super'
-    cm.record_location tl
-
-    a1 = RDoc::Attr.new nil, 'a1', 'RW', ''
-    a1.record_location tl
-    a2 = RDoc::Attr.new nil, 'a2', 'RW', '', singleton: true
-    a2.record_location tl
-
-    m1 = RDoc::AnyMethod.new nil, 'm1'
-    m1.record_location tl
-
-    c1 = RDoc::Constant.new 'C1', nil, ''
-    c1.record_location tl
-
-    i1 = RDoc::Include.new 'I1', ''
-    i1.record_location tl
-
-    e1 = RDoc::Extend.new 'E1', ''
-    e1.record_location tl
-
-    s0 = cm.sections.first
-
-    cm.add_attribute a1
-    cm.add_attribute a2
-    cm.add_method m1
-    cm.add_constant c1
-    cm.add_include i1
-    cm.add_extend e1
-    cm.add_comment 'this is a comment', tl
-
-    loaded = Marshal.load "\x04\bU:\x16RDoc::NormalClass[\x0Fi\aI\"\nKlass" +
-                          "\x06:\x06EFI\"\x15Namespace::Klass\x06;\x06FI" +
-                          "\"\nSuper\x06;\x06Fo:\eRDoc::Markup::Document\a" +
-                          ":\v@parts[\x06o;\a\a;\b[\x06o" +
-                          ":\x1CRDoc::Markup::Paragraph\x06;\b" +
-                          "[\x06I\"\x16this is a comment\x06;\x06F" +
-                          ":\n@fileI\"\ffile.rb\x06;\x06F;\n0[\a[\nI" +
-                          "\"\aa2\x06;\x06FI\"\aRW\x06;\x06F:\vpublicT@\x11" +
-                          "[\nI\"\aa1\x06;\x06FI\"\aRW\x06;\x06F;\vF@\x11" +
-                          "[\x06[\bI\"\aC1\x06;\x06Fo;\a\a;\b[\x00;\n0@\x11" +
-                          "[\x06[\bI\"\aI1\x06;\x06Fo;\a\a;\b[\x00;\n0@\x11" +
-                          "[\a[\aI\"\nclass\x06;\x06F[\b[\a;\v[\x00" +
-                          "[\a:\x0Eprotected[\x00[\a:\fprivate[\x00[\aI" +
-                          "\"\rinstance\x06;\x06F[\b[\a;\v[\x06[\aI" +
-                          "\"\am1\x06;\x06F@\x11[\a;\f[\x00[\a;\r[\x00" +
-                          "[\x06[\bI\"\aE1\x06;\x06Fo;\a\a;\b[\x00;\n0@\x11"
-
-    loaded.store = @store
-
-    assert_equal cm, loaded
-
-    inner = RDoc::Markup::Document.new(
-      RDoc::Markup::Paragraph.new('this is a comment'))
-    inner.file = tl
-
-    document = RDoc::Markup::Document.new(inner)
-
-    assert_equal [a2, a1],           loaded.attributes.sort
-    assert_equal document,           loaded.comment.parse
-    assert_equal [c1],               loaded.constants
-    assert_equal 'Namespace::Klass', loaded.full_name
-    assert_equal [i1],               loaded.includes
-    assert_equal [e1],               loaded.extends
-    assert_equal [m1],               loaded.method_list
-    assert_equal 'Klass',            loaded.name
-    assert_equal 'Super',            loaded.superclass
-    assert_empty                     loaded.in_files
-    assert_nil                       loaded.parent
-    assert                           loaded.current_section
-
-    assert_equal tl, loaded.attributes. first.file
-    assert_equal tl, loaded.constants.  first.file
-    assert_equal tl, loaded.includes.   first.file
-    assert_equal tl, loaded.extends.    first.file
-    assert_equal tl, loaded.method_list.first.file
-
-    expected = { nil => s0 }
-    assert_equal expected, loaded.sections_hash
-  end
-
-  def test_marshal_load_version_3
-    tl = @store.add_file 'file.rb'
-
-    ns = tl.add_module RDoc::NormalModule, 'Namespace'
-
-    cm = ns.add_class RDoc::NormalClass, 'Klass', 'Super'
-    cm.record_location tl
-
-    a1 = RDoc::Attr.new nil, 'a1', 'RW', ''
-    a1.record_location tl
-    a2 = RDoc::Attr.new nil, 'a2', 'RW', '', singleton: true
-    a2.record_location tl
-
-    m1 = RDoc::AnyMethod.new nil, 'm1'
-    m1.record_location tl
-
-    c1 = RDoc::Constant.new 'C1', nil, ''
-    c1.record_location tl
-
-    i1 = RDoc::Include.new 'I1', ''
-    i1.record_location tl
-
-    e1 = RDoc::Extend.new 'E1', ''
-    e1.record_location tl
-
-    section_comment = RDoc::Comment.new('section comment')
-    section_comment.location = tl
-
-    assert_equal 1, cm.sections.length, 'sanity, default section only'
-    s0 = cm.sections.first
-    s1 = cm.add_section 'section', section_comment
-
-    cm.add_attribute a1
-    cm.add_attribute a2
-    cm.add_method m1
-    cm.add_constant c1
-    cm.add_include i1
-    cm.add_extend e1
-    cm.add_comment 'this is a comment', tl
-
-    loaded = Marshal.load "\x04\bU:\x16RDoc::NormalClass[\x13i\bI\"\nKlass" +
-                          "\x06:\x06ETI\"\x15Namespace::Klass\x06;\x06TI" +
-                          "\"\nSuper\x06;\x06To:\eRDoc::Markup::Document\a" +
-                          ":\v@parts[\x06o;\a\a;\b[\x06o" +
-                          ":\x1CRDoc::Markup::Paragraph\x06;\b[\x06I" +
-                          "\"\x16this is a comment\x06;\x06T:\n@fileI" +
-                          "\"\ffile.rb\x06;\x06T;\n0[\a[\nI\"\aa2\x06;" +
-                          "\x06TI\"\aRW\x06;\x06T:\vpublicT@\x11[\nI" +
-                          "\"\aa1\x06;\x06TI\"\aRW\x06;\x06T;\vF@\x11" +
-                          "[\x06U:\x13RDoc::Constant[\x0Fi\x00I\"\aC1\x06" +
-                          ";\x06TI\"\x19Namespace::Klass::C1\x06;\x06T00o" +
-                          ";\a\a;\b[\x00;\n0@\x11@\ac\x16RDoc::NormalClass0" +
-                          "[\x06[\bI\"\aI1\x06;\x06To;\a\a;\b[\x00;\n0@\x11" +
-                          "[\a[\aI\"\nclass\x06;\x06T[\b[\a;\v[\x00[\a" +
-                          ":\x0Eprotected[\x00[\a:\fprivate[\x00[\aI" +
-                          "\"\rinstance\x06;\x06T[\b[\a;\v[\x06[\aI" +
-                          "\"\am1\x06;\x06T@\x11[\a;\r[\x00[\a;\x0E[\x00" +
-                          "[\x06[\bI\"\aE1\x06;\x06To;\a\a;\b[\x00;\n0@\x11" +
-                          "[\aU:\eRDoc::Context::Section[\bi\x000o;\a\a;\b" +
-                          "[\x00;\n0U;\x0F[\bi\x00I\"\fsection\x06;\x06To" +
-                          ";\a\a;\b[\x06o;\a\a;\b[\x06o;\t\x06;\b[\x06I" +
-                          "\"\x14section comment\x06;\x06T;\n@\x11;\n0" +
-                          "[\x06@\x11I\"\x0ENamespace\x06" +
-                          ";\x06Tc\x17RDoc::NormalModule"
-
-    loaded.store = @store
-
-    assert_equal cm, loaded
-
-    inner = RDoc::Markup::Document.new(
-      RDoc::Markup::Paragraph.new('this is a comment'))
-    inner.file = tl
-
-    document = RDoc::Markup::Document.new(inner)
-
-    assert_equal [a2, a1],           loaded.attributes.sort
-    assert_equal document,           loaded.comment.parse
-    assert_equal [c1],               loaded.constants
-    assert_equal 'Namespace::Klass', loaded.full_name
-    assert_equal [i1],               loaded.includes
-    assert_equal [e1],               loaded.extends
-    assert_equal [m1],               loaded.method_list
-    assert_equal 'Klass',            loaded.name
-    assert_equal 'Super',            loaded.superclass
-    assert_equal 'Namespace',        loaded.parent.name
-    assert                           loaded.current_section
-
-    expected = {
-      nil       => s0,
-      'section' => s1,
-    }
-
-    assert_equal expected,           loaded.sections_hash
-    assert_equal [tl],               loaded.in_files
-
-    assert_equal tl, loaded.attributes. first.file
-    assert_equal tl, loaded.constants.  first.file
-    assert_equal tl, loaded.includes.   first.file
-    assert_equal tl, loaded.extends.    first.file
-    assert_equal tl, loaded.method_list.first.file
-  end
-
-  def test_merge
-    tl = @store.add_file 'one.rb'
-    p1  = tl.add_class RDoc::NormalClass, 'Parent'
-    c1  = p1.add_class RDoc::NormalClass, 'Klass'
-
-    c2 = RDoc::NormalClass.new 'Klass'
-
-    c2.merge c1
-
-    assert_equal 'Parent', c1.parent_name, 'original parent name'
-    assert_equal 'Parent', c2.parent_name, 'merged parent name'
-
-    assert c1.current_section, 'original current_section'
-    assert c2.current_section, 'merged current_section'
-  end
-
-  def test_merge_attributes
-    tl1 = @store.add_file 'one.rb'
-    tl2 = @store.add_file 'two.rb'
-
-    cm1 = RDoc::ClassModule.new 'Klass'
-
-    attr = cm1.add_attribute RDoc::Attr.new(nil, 'a1', 'RW', '')
-    attr.record_location tl1
-    attr = cm1.add_attribute RDoc::Attr.new(nil, 'a3', 'R', '')
-    attr.record_location tl1
-    attr = cm1.add_attribute RDoc::Attr.new(nil, 'a4', 'R', '')
-    attr.record_location tl1
-
-    cm2 = RDoc::ClassModule.new 'Klass'
-    # TODO allow merging when comment == ''
-    cm2.instance_variable_set :@comment, @RM::Document.new
-
-    attr = cm2.add_attribute RDoc::Attr.new(nil, 'a2', 'RW', '')
-    attr.record_location tl2
-    attr = cm2.add_attribute RDoc::Attr.new(nil, 'a3', 'W', '')
-    attr.record_location tl1
-    attr = cm2.add_attribute RDoc::Attr.new(nil, 'a4', 'W', '')
-    attr.record_location tl1
-
-    cm1.merge cm2
-
-    expected = [
-      RDoc::Attr.new(nil, 'a2', 'RW', ''),
-      RDoc::Attr.new(nil, 'a3', 'W',  ''),
-      RDoc::Attr.new(nil, 'a4', 'W',  ''),
-    ]
-
-    expected.each do |a| a.parent = cm1 end
-    assert_equal expected, cm1.attributes.sort
-  end
-
-  def test_merge_attributes_version_0
-    tl1 = @store.add_file 'one.rb'
-
-    cm1 = RDoc::ClassModule.new 'Klass'
-
-    attr = cm1.add_attribute RDoc::Attr.new(nil, 'a1', 'RW', '')
-    attr.record_location tl1
-    attr = cm1.add_attribute RDoc::Attr.new(nil, 'a3', 'R', '')
-    attr.record_location tl1
-    attr = cm1.add_attribute RDoc::Attr.new(nil, 'a4', 'R', '')
-    attr.record_location tl1
-
-    cm2 = RDoc::ClassModule.new 'Klass'
-    # TODO allow merging when comment == ''
-    cm2.instance_variable_set :@comment, @RM::Document.new
-
-    attr = cm2.add_attribute RDoc::Attr.new(nil, 'a2', 'RW', '')
-    attr = cm2.add_attribute RDoc::Attr.new(nil, 'a3', 'W', '')
-    attr = cm2.add_attribute RDoc::Attr.new(nil, 'a4', 'W', '')
-
-    cm1.merge cm2
-
-    expected = [
-      RDoc::Attr.new(nil, 'a1', 'RW', ''),
-      RDoc::Attr.new(nil, 'a2', 'RW', ''),
-      RDoc::Attr.new(nil, 'a3', 'RW', ''),
-      RDoc::Attr.new(nil, 'a4', 'RW', ''),
-    ]
-
-    expected.each do |a| a.parent = cm1 end
-    assert_equal expected, cm1.attributes.sort
-  end
-
-  def test_merge_collections_drop
-    tl = @store.add_file 'file'
-
-    cm1 = RDoc::ClassModule.new 'C'
-    cm1.record_location tl
-
-    const = cm1.add_constant RDoc::Constant.new('CONST', nil, nil)
-    const.record_location tl
-
-    cm2 = RDoc::ClassModule.new 'C'
-    cm2.record_location tl
-
-    added = []
-    removed = []
-
-    cm1.merge_collections cm1.constants, cm2.constants, cm2.in_files do |add, c|
-      if add then
-        added << c
-      else
-        removed << c
-      end
-    end
-
-    assert_empty added
-    assert_equal [const], removed
-  end
-
-  def test_merge_comment
-    tl1 = @store.add_file 'one.rb'
-    tl2 = @store.add_file 'two.rb'
-
-    cm1 = tl1.add_class RDoc::ClassModule, 'Klass'
-    cm1.add_comment 'klass 1', tl1
-    cm1.record_location tl1
-
-    cm2 = tl1.add_class RDoc::NormalClass, 'Klass'
-    cm2.add_comment 'klass 2', tl2
-    cm2.add_comment 'klass 3', tl1
-    cm2.record_location tl1
-    cm2.record_location tl2
-
-    cm2 = Marshal.load Marshal.dump cm2
-    cm2.store = @store
-
-    cm1.merge cm2
-
-    inner1 = @RM::Document.new @RM::Paragraph.new 'klass 3'
-    inner1.file = 'one.rb'
-    inner2 = @RM::Document.new @RM::Paragraph.new 'klass 2'
-    inner2.file = 'two.rb'
-
-    expected = @RM::Document.new inner2, inner1
-
-    assert_equal expected, cm1.comment.parse
-  end
-
-  def test_merge_comment_version_0
-    tl = @store.add_file 'file.rb'
-
-    cm1 = RDoc::ClassModule.new 'Klass'
-    cm1.add_comment 'klass 1', tl
-
-    cm2 = RDoc::ClassModule.new 'Klass'
-
-    cm2.instance_variable_set(:@comment,
-                              @RM::Document.new(
-                                @RM::Paragraph.new('klass 2')))
-    cm2.instance_variable_set :@comment_location, @RM::Document.new(cm2.comment)
-
-    cm1.merge cm2
-
-    inner = @RM::Document.new @RM::Paragraph.new 'klass 1'
-    inner.file = 'file.rb'
-
-    expected = @RM::Document.new \
-      inner,
-      @RM::Document.new(@RM::Paragraph.new('klass 2'))
-
-    assert_equal expected, cm1.comment.parse
-  end
-
-  def test_merge_constants
-    tl1 = @store.add_file 'one.rb'
-    tl2 = @store.add_file 'two.rb'
-
-    cm1 = tl1.add_class RDoc::ClassModule, 'Klass'
-
-    const = cm1.add_constant RDoc::Constant.new('C1', nil, 'one')
-    const.record_location tl1
-    const = cm1.add_constant RDoc::Constant.new('C3', nil, 'one')
-    const.record_location tl1
-
-    store = RDoc::Store.new(RDoc::Options.new)
-    tl = store.add_file 'one.rb'
-    cm2 = tl.add_class RDoc::ClassModule, 'Klass'
-    cm2.instance_variable_set :@comment, @RM::Document.new
-
-    const = cm2.add_constant RDoc::Constant.new('C2', nil, 'two')
-    const.record_location tl2
-    const = cm2.add_constant RDoc::Constant.new('C3', nil, 'one')
-    const.record_location tl1
-    const = cm2.add_constant RDoc::Constant.new('C4', nil, 'one')
-    const.record_location tl1
-
-    cm1.merge cm2
-
-    expected = [
-      RDoc::Constant.new('C2', nil, 'two'),
-      RDoc::Constant.new('C3', nil, 'one'),
-      RDoc::Constant.new('C4', nil, 'one'),
-    ]
-
-    expected.each do |a| a.parent = cm1 end
-
-    assert_equal expected, cm1.constants.sort
-  end
-
-  def test_merge_constants_version_0
-    tl1 = @store.add_file 'one.rb'
-
-    cm1 = tl1.add_class RDoc::ClassModule, 'Klass'
-
-    const = cm1.add_constant RDoc::Constant.new('C1', nil, 'one')
-    const.record_location tl1
-    const = cm1.add_constant RDoc::Constant.new('C3', nil, 'one')
-    const.record_location tl1
-
-    store = RDoc::Store.new(RDoc::Options.new)
-    tl = store.add_file 'one.rb'
-    cm2 = tl.add_class RDoc::ClassModule, 'Klass'
-    cm2.instance_variable_set :@comment, @RM::Document.new
-
-    const = cm2.add_constant RDoc::Constant.new('C2', nil, 'two')
-    const = cm2.add_constant RDoc::Constant.new('C3', nil, 'two')
-    const = cm2.add_constant RDoc::Constant.new('C4', nil, 'two')
-
-    cm1.merge cm2
-
-    expected = [
-      RDoc::Constant.new('C1', nil, 'one'),
-      RDoc::Constant.new('C2', nil, 'two'),
-      RDoc::Constant.new('C3', nil, 'one'),
-      RDoc::Constant.new('C4', nil, 'two'),
-    ]
-
-    expected.each do |a| a.parent = cm1 end
-
-    assert_equal expected, cm1.constants.sort
-  end
-
-  def test_merge_extends
-    tl1 = @store.add_file 'one.rb'
-    cm1 = tl1.add_class RDoc::ClassModule, 'Klass'
-
-    ext = cm1.add_extend RDoc::Extend.new('I1', 'one')
-    ext.record_location tl1
-    ext = cm1.add_extend RDoc::Extend.new('I3', 'one')
-    ext.record_location tl1
-
-    tl2 = @store.add_file 'two.rb'
-    tl2.store = RDoc::Store.new(RDoc::Options.new)
-
-    cm2 = tl2.add_class RDoc::ClassModule, 'Klass'
-    cm2.instance_variable_set :@comment, @RM::Document.new
-
-    ext = cm2.add_extend RDoc::Extend.new('I2', 'two')
-    ext.record_location tl2
-    ext = cm2.add_extend RDoc::Extend.new('I3', 'one')
-    ext.record_location tl1
-    ext = cm2.add_extend RDoc::Extend.new('I4', 'one')
-    ext.record_location tl1
-
-    cm1.merge cm2
-
-    expected = [
-      RDoc::Extend.new('I2', 'two'),
-      RDoc::Extend.new('I3', 'one'),
-      RDoc::Extend.new('I4', 'one'),
-    ]
-
-    expected.each do |a| a.parent = cm1 end
-
-    assert_equal expected, cm1.extends.sort
-  end
-
-  def test_merge_includes
-    tl1 = @store.add_file 'one.rb'
-
-    cm1 = tl1.add_class RDoc::ClassModule, 'Klass'
-
-    incl = cm1.add_include RDoc::Include.new('I1', 'one')
-    incl.record_location tl1
-    incl = cm1.add_include RDoc::Include.new('I3', 'one')
-    incl.record_location tl1
-
-    tl2 = @store.add_file 'two.rb'
-    tl2.store = RDoc::Store.new(RDoc::Options.new)
-
-    cm2 = tl2.add_class RDoc::ClassModule, 'Klass'
-    cm2.instance_variable_set :@comment, @RM::Document.new
-
-    incl = cm2.add_include RDoc::Include.new('I2', 'two')
-    incl.record_location tl2
-    incl = cm2.add_include RDoc::Include.new('I3', 'one')
-    incl.record_location tl1
-    incl = cm2.add_include RDoc::Include.new('I4', 'one')
-    incl.record_location tl1
-
-    cm1.merge cm2
-
-    expected = [
-      RDoc::Include.new('I2', 'two'),
-      RDoc::Include.new('I3', 'one'),
-      RDoc::Include.new('I4', 'one'),
-    ]
-
-    expected.each do |a| a.parent = cm1 end
-
-    assert_equal expected, cm1.includes.sort
-  end
-
-  def test_merge_includes_version_0
-    tl1 = @store.add_file 'one.rb'
-
-    cm1 = tl1.add_class RDoc::ClassModule, 'Klass'
-
-    incl = cm1.add_include RDoc::Include.new('I1', 'one')
-    incl.record_location tl1
-    incl = cm1.add_include RDoc::Include.new('I3', 'one')
-    incl.record_location tl1
-
-    tl2 = @store.add_file 'one.rb'
-    tl2.store = RDoc::Store.new(RDoc::Options.new)
-
-    cm2 = tl2.add_class RDoc::ClassModule, 'Klass'
-    cm2.instance_variable_set :@comment, @RM::Document.new
-
-    incl = cm2.add_include RDoc::Include.new('I2', 'two')
-    incl = cm2.add_include RDoc::Include.new('I3', 'two')
-    incl = cm2.add_include RDoc::Include.new('I4', 'two')
-
-    cm1.merge cm2
-
-    expected = [
-      RDoc::Include.new('I1', 'one'),
-      RDoc::Include.new('I2', 'two'),
-      RDoc::Include.new('I3', 'one'),
-      RDoc::Include.new('I4', 'two'),
-    ]
-
-    expected.each do |a| a.parent = cm1 end
-
-    assert_equal expected, cm1.includes.sort
-  end
-
-  def test_merge_methods
-    tl1 = @store.add_file 'one.rb'
-    tl2 = @store.add_file 'two.rb'
-
-    cm1 = tl1.add_class RDoc::NormalClass, 'Klass'
-
-    meth = cm1.add_method RDoc::AnyMethod.new(nil, 'm1')
-    meth.record_location tl1
-    meth = cm1.add_method RDoc::AnyMethod.new(nil, 'm3')
-    meth.record_location tl1
-
-    cm2 = RDoc::ClassModule.new 'Klass'
-    cm2.store = @store
-    cm2.instance_variable_set :@comment, @RM::Document.new
-
-    meth = cm2.add_method RDoc::AnyMethod.new(nil, 'm2')
-    meth.record_location tl2
-    meth = cm2.add_method RDoc::AnyMethod.new(nil, 'm3')
-    meth.record_location tl1
-    meth = cm2.add_method RDoc::AnyMethod.new(nil, 'm4')
-    meth.record_location tl1
-
-    cm1.merge cm2
-
-    expected = [
-      RDoc::AnyMethod.new(nil, 'm2'),
-      RDoc::AnyMethod.new(nil, 'm3'),
-      RDoc::AnyMethod.new(nil, 'm4'),
-    ]
-
-    expected.each do |a| a.parent = cm1 end
-
-    assert_equal expected, cm1.method_list.sort
-  end
-
-  def test_merge_methods_version_0
-    tl1 = @store.add_file 'one.rb'
-
-    cm1 = tl1.add_class RDoc::NormalClass, 'Klass'
-
-    meth = cm1.add_method RDoc::AnyMethod.new(nil, 'm1')
-    meth.record_location tl1
-    meth = cm1.add_method RDoc::AnyMethod.new(nil, 'm3')
-    meth.record_location tl1
-
-    cm2 = RDoc::ClassModule.new 'Klass'
-    cm2.store = @store
-    cm2.instance_variable_set :@comment, @RM::Document.new
-
-    meth = cm2.add_method RDoc::AnyMethod.new(nil, 'm2')
-    meth = cm2.add_method RDoc::AnyMethod.new(nil, 'm3')
-    meth = cm2.add_method RDoc::AnyMethod.new(nil, 'm4')
-
-    cm1.merge cm2
-
-    expected = [
-      RDoc::AnyMethod.new(nil, 'm1'),
-      RDoc::AnyMethod.new(nil, 'm2'),
-      RDoc::AnyMethod.new(nil, 'm3'),
-      RDoc::AnyMethod.new(nil, 'm4'),
-    ]
-
-    expected.each do |a| a.parent = cm1 end
-
-    assert_equal expected, cm1.method_list.sort
-  end
-
-  def test_merge_sections
-    store1 = @store
-
-    tl1_1 = store1.add_file 'one.rb'
-
-    cm1  = tl1_1.add_class RDoc::ClassModule, 'Klass'
-    cm1.record_location tl1_1
-
-    s1_0 = cm1.sections.first
-    s1_1 = cm1.add_section 'section 1', comment('comment 1',   tl1_1)
-           cm1.add_section 'section 2', comment('comment 2 a', tl1_1)
-           cm1.add_section 'section 4', comment('comment 4 a', tl1_1)
-
-    store2 = RDoc::Store.new(RDoc::Options.new)
-    tl2_1 = store2.add_file 'one.rb'
-    tl2_2 = store2.add_file 'two.rb'
-
-    cm2  = tl2_1.add_class RDoc::ClassModule, 'Klass'
-    cm2.record_location tl2_1
-    cm2.record_location tl2_2
-
-           cm2.sections.first
-    s2_2 = cm2.add_section 'section 2', comment('comment 2 b', tl2_1)
-    s2_3 = cm2.add_section 'section 3', comment('comment 3',   tl2_2)
-           cm2.add_section 'section 4', comment('comment 4 b', tl2_2)
-
-    cm1.merge cm2
-
-    expected = [
-      s1_0,
-      s1_1,
-      s2_2,
-      s2_3,
-      RDoc::Context::Section.new(cm1, 'section 4', nil)
-    ]
-
-    merged_sections = cm1.sections.sort_by do |s|
-      s.title || ''
-    end
-
-    assert_equal expected, merged_sections
-
-    assert_equal [comment('comment 2 b', tl2_1)],
-                 cm1.sections_hash['section 2'].comments
-
-    expected_s4_comments = [
-      comment('comment 4 a', tl2_1),
-      comment('comment 4 b', tl2_2),
-    ]
-
-    assert_equal expected_s4_comments, cm1.sections_hash['section 4'].comments
-  end
-
-  def test_merge_sections_overlap
-    store1 = @store
-
-    tl1_1 = store1.add_file 'one.rb'
-    tl1_3 = store1.add_file 'three.rb'
-
-    cm1  = tl1_1.add_class RDoc::ClassModule, 'Klass'
-    cm1.record_location tl1_1
-
-    cm1.add_section 'section', comment('comment 1 a', tl1_1)
-    cm1.add_section 'section', comment('comment 3',   tl1_3)
-
-    store2 = RDoc::Store.new(RDoc::Options.new)
-    tl2_1 = store2.add_file 'one.rb'
-    tl2_2 = store2.add_file 'two.rb'
-    tl2_3 = store2.add_file 'three.rb'
-
-    cm2  = tl2_1.add_class RDoc::ClassModule, 'Klass'
-    cm2.record_location tl2_1
-    cm2.record_location tl2_2
-
-    s2_0 = cm2.sections.first
-    s2_1 = cm2.add_section 'section', comment('comment 1 b', tl1_1)
-           cm2.add_section 'section', comment('comment 2',   tl2_2)
-
-    cm1.merge_sections cm2
-
-    expected = [
-      s2_0,
-      s2_1,
-    ]
-
-    merged_sections = cm1.sections.sort_by do |s|
-      s.title || ''
-    end
-
-    assert_equal expected, merged_sections
-
-    expected = [
-      comment('comment 1 b', tl2_1),
-      comment('comment 3',   tl2_3),
-      comment('comment 2',   tl2_2),
-    ]
-
-    comments = cm1.sections_hash['section'].comments
-
-    assert_equal expected, comments.sort_by { |c| c.file.name }
-  end
-
-  def test_parse
-    tl1 = @store.add_file 'one.rb'
-    tl2 = @store.add_file 'two.rb'
-
-    cm = RDoc::ClassModule.new 'Klass'
-    cm.add_comment 'comment 1', tl1
-    cm.add_comment 'comment 2', tl2
-
-    doc1 = @RM::Document.new @RM::Paragraph.new 'comment 1'
-    doc1.file = tl1
-    doc2 = @RM::Document.new @RM::Paragraph.new 'comment 2'
-    doc2.file = tl2
-
-    expected = @RM::Document.new doc1, doc2
-
-    assert_equal expected, cm.parse(cm.comment_location)
-  end
-
-  def test_parse_comment
-    tl1 = @store.add_file 'one.rb'
-
-    cm = RDoc::ClassModule.new 'Klass'
-    cm.comment = comment 'comment 1', tl1
-
-    doc = @RM::Document.new @RM::Paragraph.new 'comment 1'
-    doc.file = tl1
-
-    assert_equal doc, cm.parse(cm.comment)
-  end
-
-  def test_parse_comment_format
-    tl1 = @store.add_file 'one.rb'
-
-    cm = RDoc::ClassModule.new 'Klass'
-    cm.comment = comment 'comment ((*1*))', tl1
-    cm.comment.format = 'rd'
-
-    doc = @RM::Document.new @RM::Paragraph.new 'comment <em>1</em>'
-    doc.file = tl1
-
-    assert_equal doc, cm.parse(cm.comment)
-  end
-
-  def test_parse_comment_location
-    tl1 = @store.add_file 'one.rb'
-    tl2 = @store.add_file 'two.rb'
-
-    cm = tl1.add_class RDoc::NormalClass, 'Klass'
-    cm.add_comment 'comment 1', tl1
-    cm.add_comment 'comment 2', tl2
-
-    cm = Marshal.load Marshal.dump cm
-
-    doc1 = @RM::Document.new @RM::Paragraph.new 'comment 1'
-    doc1.file = tl1
-    doc2 = @RM::Document.new @RM::Paragraph.new 'comment 2'
-    doc2.file = tl2
-
-    assert_same cm.comment_location, cm.parse(cm.comment_location)
-  end
-
-  def test_remove_nodoc_children
-    parent = @top_level.add_class RDoc::ClassModule, 'A'
-    parent.modules_hash.replace 'B' => true, 'C' => true
-    @store.modules_hash.replace 'A::B' => true
-
-    parent.classes_hash.replace 'D' => true, 'E' => true
-    @store.classes_hash.replace 'A::D' => true
-
-    parent.remove_nodoc_children
-
-    assert_equal %w[B], parent.modules_hash.keys
-    assert_equal %w[D], parent.classes_hash.keys
-  end
-
-  def test_search_record
-    @c2_c3.add_comment 'This is a comment.', @xref_data
-
-    expected = [
-      'C3',
-      'C2::C3',
-      'C2::C3',
-      '',
-      'C2/C3.html',
-      '',
-      "<p>This is a comment.\n"
-    ]
-
-    assert_equal expected, @c2_c3.search_record
-  end
-
-  def test_search_record_merged
-    @c2_c3.add_comment 'comment A', @store.add_file('a.rb')
-    @c2_c3.add_comment 'comment B', @store.add_file('b.rb')
-
-    expected = [
-      'C3',
-      'C2::C3',
-      'C2::C3',
-      '',
-      'C2/C3.html',
-      '',
-      "<p>comment A\n<p>comment B\n"
-    ]
-
-    assert_equal expected, @c2_c3.search_record
-  end
-
-  def test_store_equals
-    # version 2
-    loaded = Marshal.load "\x04\bU:\x16RDoc::NormalClass[\x0Fi\aI\"\nKlass" +
-                          "\x06:\x06EFI\"\x15Namespace::Klass\x06;\x06FI" +
-                          "\"\nSuper\x06;\x06Fo:\eRDoc::Markup::Document\a" +
-                          ":\v@parts[\x06o;\a\a;\b[\x06o" +
-                          ":\x1CRDoc::Markup::Paragraph\x06;\b" +
-                          "[\x06I\"\x16this is a comment\x06;\x06F" +
-                          ":\n@fileI\"\ffile.rb\x06;\x06F;\n0[\a[\nI" +
-                          "\"\aa2\x06;\x06FI\"\aRW\x06;\x06F:\vpublicT@\x11" +
-                          "[\nI\"\aa1\x06;\x06FI\"\aRW\x06;\x06F;\vF@\x11" +
-                          "[\x06[\bI\"\aC1\x06;\x06Fo;\a\a;\b[\x00;\n0@\x11" +
-                          "[\x06[\bI\"\aI1\x06;\x06Fo;\a\a;\b[\x00;\n0@\x11" +
-                          "[\a[\aI\"\nclass\x06;\x06F[\b[\a;\v[\x00" +
-                          "[\a:\x0Eprotected[\x00[\a:\fprivate[\x00[\aI" +
-                          "\"\rinstance\x06;\x06F[\b[\a;\v[\x06[\aI" +
-                          "\"\am1\x06;\x06F@\x11[\a;\f[\x00[\a;\r[\x00" +
-                          "[\x06[\bI\"\aE1\x06;\x06Fo;\a\a;\b[\x00;\n0@\x11"
-
-    loaded.store = @store
-
-    assert_same @store, loaded.store
-
-    a = loaded.attributes.first
-    assert_same @store, a.store
-    assert_same @store, a.file.store
-
-    c = loaded.constants.first
-    assert_same @store, c.store
-    assert_same @store, c.file.store
-
-    i = loaded.includes.first
-    assert_same @store, i.store
-    assert_same @store, i.file.store
-
-    e = loaded.extends.first
-    assert_same @store, e.store
-    assert_same @store, e.file.store
-
-    m = loaded.method_list.first
-    assert_same @store, m.store
-    assert_same @store, m.file.store
-  end
-
-  def test_superclass
-    assert_equal @c3_h1, @c3_h2.superclass
-  end
-
-  def test_setting_superclass
-    @c1.superclass = nil
-    assert_nil(@c1.superclass)
-    assert_nil(@c1.instance_variable_get("@superclass")) # proxy to test marshalling
-
-    @c1.superclass = @c4_c4.full_name
-    assert_equal(@c1.superclass, @c4_c4)
-    assert_equal(@c4_c4.full_name, @c1.instance_variable_get("@superclass"))
-
-    @c1.superclass = @c4_c4
-    assert_equal(@c1.superclass, @c4_c4)
-    assert_equal(@c4_c4.full_name, @c1.instance_variable_get("@superclass"))
-
-    # we could support this if we find we need to in the future.
-    assert_raise(TypeError) { @c1.superclass = Object }
-
-    # but this doesn't make sense.
-    assert_raise(TypeError) { @c1.superclass = Object.new }
-  end
-
-  def test_super_classes
-    rdoc_c3_h1 = @xref_data.find_module_named('C3::H1')
-    rdoc_object = @xref_data.find_module_named('Object')
-    assert_equal [rdoc_c3_h1, rdoc_object, "BasicObject"], @c3_h2.super_classes
-  end
-
-  def test_update_aliases_class
-    n1 = @xref_data.add_module RDoc::NormalClass, 'N1'
-    n1_k2 = n1.add_module RDoc::NormalClass, 'N2'
-
-    a1 = RDoc::Constant.new 'A1', '', ''
-    n1.add_module_alias n1_k2, n1_k2.name, a1, @xref_data
-
-    n1_a1_c = n1.constants.find { |c| c.name == 'A1' }
-    refute_nil n1_a1_c
-    assert_equal n1_k2, n1_a1_c.is_alias_for, 'sanity check'
-
-    n1.update_aliases
-
-    n1_a1_k = @xref_data.find_class_or_module 'N1::A1'
-    refute_nil n1_a1_k
-    assert_equal n1_k2, n1_a1_k.is_alias_for
-    refute_equal n1_k2, n1_a1_k
-
-    assert_equal 1, n1_k2.aliases.length
-    assert_equal n1_a1_k, n1_k2.aliases.first
-
-    assert_equal 'N1::N2', n1_k2.full_name
-    assert_equal 'N1::A1', n1_a1_k.full_name
-  end
-
-  def test_update_aliases_module
-    n1 = @xref_data.add_module RDoc::NormalModule, 'N1'
-    n1_n2 = n1.add_module RDoc::NormalModule, 'N2'
-
-    a1 = RDoc::Constant.new 'A1', '', ''
-    n1.add_module_alias n1_n2, n1_n2.name, a1, @xref_data
-
-    n1_a1_c = n1.constants.find { |c| c.name == 'A1' }
-    refute_nil n1_a1_c
-    assert_equal n1_n2, n1_a1_c.is_alias_for, 'sanity check'
-
-    n1.update_aliases
-
-    n1_a1_m = @xref_data.find_class_or_module 'N1::A1'
-    refute_nil n1_a1_m
-    assert_equal n1_n2, n1_a1_m.is_alias_for
-    refute_equal n1_n2, n1_a1_m
-
-    assert_equal 1, n1_n2.aliases.length
-    assert_equal n1_a1_m, n1_n2.aliases.first
-
-    assert_equal 'N1::N2', n1_n2.full_name
-    assert_equal 'N1::A1', n1_a1_m.full_name
-  end
-
-  def test_update_aliases_reparent
-    l1 = @xref_data.add_module RDoc::NormalModule, 'L1'
-    l1_l2 = l1.add_module RDoc::NormalModule, 'L2'
-    o1 = @xref_data.add_module RDoc::NormalModule, 'O1'
-
-    a1 = RDoc::Constant.new 'A1', '', ''
-    o1.add_module_alias l1_l2, l1_l2.name, a1, @xref_data
-
-    o1_a1_c = o1.constants.find { |c| c.name == 'A1' }
-    refute_nil o1_a1_c
-    assert_equal l1_l2, o1_a1_c.is_alias_for
-    refute_equal l1_l2, o1_a1_c
-
-    o1.update_aliases
-
-    o1_a1_m = @xref_data.find_class_or_module 'O1::A1'
-    refute_nil o1_a1_m
-    assert_equal l1_l2, o1_a1_m.is_alias_for
-
-    assert_equal 1, l1_l2.aliases.length
-    assert_equal o1_a1_m, l1_l2.aliases[0]
-
-    assert_equal 'L1::L2', l1_l2.full_name
-    assert_equal 'O1::A1', o1_a1_m.full_name
-  end
-
-  def test_update_aliases_reparent_root
-    store = RDoc::Store.new(RDoc::Options.new)
-
-    top_level = store.add_file 'file.rb'
-
-    klass  = top_level.add_class RDoc::NormalClass, 'Klass'
-    object = top_level.add_class RDoc::NormalClass, 'Object'
-
-    const = RDoc::Constant.new 'A', nil, ''
-    const.record_location top_level
-    const.is_alias_for = klass
-
-    a = RDoc::Constant.new 'A', '', ''
-    top_level.add_module_alias klass, klass.name, a, top_level
-
-    object.add_constant const
-
-    object.update_aliases
-
-    assert_equal %w[A Klass Object], store.classes_hash.keys.sort
-
-    assert_equal 'A',     store.classes_hash['A'].full_name
-    assert_equal 'Klass', store.classes_hash['Klass'].full_name
-  end
-
-  def test_update_includes
-    a = RDoc::Include.new 'M1', nil
-    b = RDoc::Include.new 'M2', nil
-    c = RDoc::Include.new 'C', nil
-
-    @c1.add_include a
-    @c1.add_include b
-    @c1.add_include c
-    @c1.ancestors # cache included modules
-
-    @m1_m2.document_self = nil
-    assert @m1_m2.remove_from_documentation?
-
-    assert @store.modules_hash.key? @m1_m2.full_name
-    refute @store.modules_hash[@m1_m2.full_name].nil?
-
-    @store.remove_nodoc @store.modules_hash
-    refute @store.modules_hash.key? @m1_m2.full_name
-
-    @c1.update_includes
-
-    assert_equal [a, c], @c1.includes
-  end
-
-  def test_update_includes_trim
-    a = RDoc::Include.new 'D::M', nil
-    b = RDoc::Include.new 'D::M', nil
-
-    @c1.add_include a
-    @c1.add_include b
-    @c1.ancestors # cache included modules
-
-    @c1.update_includes
-
-    assert_equal [a], @c1.includes
-  end
-
-  def test_update_includes_with_colons
-    a = RDoc::Include.new 'M1', nil
-    b = RDoc::Include.new 'M1::M2', nil
-    c = RDoc::Include.new 'C', nil
-
-    @c1.add_include a
-    @c1.add_include b
-    @c1.add_include c
-    @c1.ancestors # cache included modules
-
-    @m1_m2.document_self = nil
-    assert @m1_m2.remove_from_documentation?
-
-    assert @store.modules_hash.key? @m1_m2.full_name
-    refute @store.modules_hash[@m1_m2.full_name].nil?
-    @store.remove_nodoc @store.modules_hash
-    refute @store.modules_hash.key? @m1_m2.full_name
-
-    @c1.update_includes
-
-    assert_equal [a, c], @c1.includes
-  end
-
-  def test_update_extends
-    a = RDoc::Extend.new 'M1', nil
-    b = RDoc::Extend.new 'M2', nil
-    c = RDoc::Extend.new 'C', nil
-
-    @c1.add_extend a
-    @c1.add_extend b
-    @c1.add_extend c
-    @c1.extends.each do |extend| extend.module end # cache extended modules
-
-    @m1_m2.document_self = nil
-    assert @m1_m2.remove_from_documentation?
-
-    assert @store.modules_hash.key? @m1_m2.full_name
-    refute @store.modules_hash[@m1_m2.full_name].nil?
-    @store.remove_nodoc @store.modules_hash
-    refute @store.modules_hash.key? @m1_m2.full_name
-
-    @c1.update_extends
-
-    assert_equal [a, b, c], @c1.extends
-  end
-
-  def test_update_extends_trim
-    a = RDoc::Extend.new 'D::M', nil
-    b = RDoc::Extend.new 'D::M', nil
-
-    @c1.add_extend a
-    @c1.add_extend b
-    @c1.extends.each do |extend| extend.module end # cache extended modules
-
-    @c1.update_extends
-
-    assert_equal [a], @c1.extends
-  end
-
-  def test_update_extends_with_colons
-    a = RDoc::Extend.new 'M1', nil
-    b = RDoc::Extend.new 'M1::M2', nil
-    c = RDoc::Extend.new 'C', nil
-
-    @c1.add_extend a
-    @c1.add_extend b
-    @c1.add_extend c
-    @c1.extends.each do |extend| extend.module end # cache extended modules
-
-    @m1_m2.document_self = nil
-    assert @m1_m2.remove_from_documentation?
-
-    assert @store.modules_hash.key? @m1_m2.full_name
-    refute @store.modules_hash[@m1_m2.full_name].nil?
-
-    @store.remove_nodoc @store.modules_hash
-    refute @store.modules_hash.key? @m1_m2.full_name
-
-    @c1.update_extends
-
-    assert_equal [a, c], @c1.extends
-  end
-
-  def test_nesting_namespaces
-    cm1 = RDoc::ClassModule.new "A"
-    assert_equal ["A"], cm1.nesting_namespaces
-
-    cm2 = RDoc::ClassModule.new "A::B"
-    assert_equal ["A", "B"], cm2.nesting_namespaces
-
-    cm3 = RDoc::ClassModule.new "::A::B::C"
-    assert_equal ["A", "B", "C"], cm3.nesting_namespaces
-  end
-
-  def test_fully_qualified_nesting_namespaces
-    cm1 = RDoc::ClassModule.new "A"
-    assert_equal ["A"], cm1.fully_qualified_nesting_namespaces
-
-    cm2 = RDoc::ClassModule.new "A::B"
-    assert_equal ["A", "A::B"], cm2.fully_qualified_nesting_namespaces
-
-    cm3 = RDoc::ClassModule.new "::A::B::C"
-    assert_equal ["A", "A::B", "A::B::C"], cm3.fully_qualified_nesting_namespaces
-  end
-
-  def test_path
-    assert_equal 'C1.html', @c1.path
-
-    @options.class_module_path_prefix = 'class'
-    assert_equal 'class/C1.html', @c1.path
-  end
-
-  class RDocClassModuleMixinsTest < XrefTestCase
-    def setup
-      super
-
-      klass_tl = @store.add_file("klass.rb")
-      @klass = klass_tl.add_class(RDoc::NormalClass, "Klass")
-
-      incmod_tl = @store.add_file("incmod.rb")
-      @incmod = incmod_tl.add_module(RDoc::NormalModule, "Incmod")
-
-      incmod_const = @incmod.add_constant(RDoc::Constant.new("INCMOD_CONST_WITHOUT_A_SECTION", nil, ""))
-      incmod_const = @incmod.add_constant(RDoc::Constant.new("INCMOD_CONST", nil, ""))
-      incmod_const.section = @incmod.add_section("Incmod const section")
-
-      incmod_method = @incmod.add_method(RDoc::AnyMethod.new(nil, "incmod_method_without_a_section"))
-      incmod_method = @incmod.add_method(RDoc::AnyMethod.new(nil, "incmod_method"))
-      incmod_method.section = @incmod.add_section("Incmod method section")
-
-      incmod_attr = @incmod.add_attribute(RDoc::Attr.new(nil, "incmod_attr_without_a_section", "RW", ""))
-      incmod_attr = @incmod.add_attribute(RDoc::Attr.new(nil, "incmod_attr", "RW", ""))
-      incmod_attr.section = @incmod.add_section("Incmod attr section")
-
-      incmod_private_method = @incmod.add_method(RDoc::AnyMethod.new(nil, "incmod_private_method"))
-      incmod_private_method.visibility = :private
-
-      incmod_private_attr = @incmod.add_attribute(RDoc::Attr.new(nil, "incmod_private_attr", "RW", ""))
-      incmod_private_attr.visibility = :private
-
-      extmod_tl = @store.add_file("extmod.rb")
-      @extmod = extmod_tl.add_module(RDoc::NormalModule, "Extmod")
-
-      extmod_method = @extmod.add_method(RDoc::AnyMethod.new(nil, "extmod_method_without_a_section"))
-      extmod_method = @extmod.add_method(RDoc::AnyMethod.new(nil, "extmod_method"))
-      extmod_method.section = @extmod.add_section("Extmod method section")
-
-      extmod_attr = @extmod.add_attribute(RDoc::Attr.new(nil, "extmod_attr_without_a_section", "RW", "", singleton: true))
-      extmod_attr = @extmod.add_attribute(RDoc::Attr.new(nil, "extmod_attr", "RW", "", singleton: true))
-      extmod_attr.section = @extmod.add_section("Extmod attr section")
-
-      extmod_private_method = @extmod.add_method(RDoc::AnyMethod.new(nil, "extmod_private_method"))
-      extmod_private_method.visibility = :private
-
-      extmod_private_attr = @extmod.add_attribute(RDoc::Attr.new(nil, "extmod_private_attr", "RW", "", singleton: true))
-      extmod_private_attr.visibility = :private
-
-      @klass.add_include(RDoc::Include.new("Incmod", nil))
-      @klass.add_extend(RDoc::Include.new("Extmod", nil))
-
-      @klass.add_include(RDoc::Include.new("ExternalInclude", nil))
-      # Test duplicationg removal
-      @klass.add_include(RDoc::Include.new("ExternalInclude", nil))
-
-      @klass.add_extend(RDoc::Include.new("ExternalExtend", nil))
-      # Test duplicationg removal
-      @klass.add_extend(RDoc::Include.new("ExternalExtend", nil))
-    end
-
-    def test_complete_clears_duplicated_includes_and_extends
-      @klass.complete(:protected)
-
-      assert_equal(["Incmod", "ExternalInclude"], @klass.includes.map(&:name))
-      assert_equal(["Extmod", "ExternalExtend"], @klass.extends.map(&:name))
-    end
-
-    def test_embed_mixin_when_false_does_not_embed_anything
-      assert_false(@klass.options.embed_mixins)
-      @klass.complete(:protected)
-
-      refute_includes(@klass.constants.map(&:name), "INCMOD_CONST")
-      refute_includes(@klass.method_list.map(&:name), "incmod_method")
-      refute_includes(@klass.method_list.map(&:name), "extmod_method")
-      refute_includes(@klass.attributes.map(&:name), "incmod_attr")
-      refute_includes(@klass.attributes.map(&:name), "extmod_attr")
-    end
-
-    def test_embed_mixin_when_true_embeds_methods_and_constants
-      @klass.options.embed_mixins = true
-      @klass.complete(:protected)
-
-      # assert on presence and identity of methods and constants
-      constant = @klass.constants.find { |c| c.name == "INCMOD_CONST" }
-      assert(constant, "constant from included mixin should be present")
-      assert_equal(@incmod, constant.mixin_from)
-
-      instance_method = @klass.method_list.find { |m| m.name == "incmod_method" }
-      assert(instance_method, "instance method from included mixin should be present")
-      refute(instance_method.singleton)
-      assert_equal(@incmod, instance_method.mixin_from)
-
-      instance_attr = @klass.attributes.find { |a| a.name == "incmod_attr" }
-      assert(instance_attr, "instance attr from included mixin should be present")
-      refute(instance_attr.singleton)
-      assert_equal(@incmod, instance_attr.mixin_from)
-
-      refute(@klass.method_list.find { |m| m.name == "incmod_private_method" })
-      refute(@klass.attributes.find { |m| m.name == "incmod_private_attr" })
-
-      class_method = @klass.method_list.find { |m| m.name == "extmod_method" }
-      assert(class_method, "class method from extended mixin should be present")
-      assert(class_method.singleton)
-      assert_equal(@extmod, class_method.mixin_from)
-
-      class_attr = @klass.attributes.find { |a| a.name == "extmod_attr" }
-      assert(class_attr, "class attr from extended mixin should be present")
-      assert(class_attr.singleton)
-      assert_equal(@extmod, class_attr.mixin_from)
-
-      refute(@klass.method_list.find { |m| m.name == "extmod_private_method" })
-      refute(@klass.attributes.find { |m| m.name == "extmod_private_attr" })
-
-      # assert that sections are also imported
-      constant_section = @klass.sections.find { |s| s.title == "Incmod const section" }
-      assert(constant_section, "constant from included mixin should have a section")
-      assert_equal(constant_section, constant.section)
-
-      instance_method_section = @klass.sections.find { |s| s.title == "Incmod method section" }
-      assert(instance_method_section, "instance method from included mixin should have a section")
-      assert_equal(instance_method_section, instance_method.section)
-
-      instance_attr_section = @klass.sections.find { |s| s.title == "Incmod attr section" }
-      assert(instance_attr_section, "instance attr from included mixin should have a section")
-      assert_equal(instance_attr_section, instance_attr.section)
-
-      class_method_section = @klass.sections.find { |s| s.title == "Extmod method section" }
-      assert(class_method_section, "class method from extended mixin should have a section")
-      assert_equal(class_method_section, class_method.section)
-
-      class_attr_section = @klass.sections.find { |s| s.title == "Extmod attr section" }
-      assert(class_attr_section, "class attr from extended mixin should have a section")
-      assert_equal(class_attr_section, class_attr.section)
-
-      # and check that code objects without a section still have no section
-      constant = @klass.constants.find { |c| c.name == "INCMOD_CONST_WITHOUT_A_SECTION" }
-      assert_nil(constant.section.title)
-
-      instance_method = @klass.method_list.find { |c| c.name == "incmod_method_without_a_section" }
-      assert_nil(instance_method.section.title)
-
-      instance_attr = @klass.attributes.find { |c| c.name == "incmod_attr_without_a_section" }
-      assert_nil(instance_attr.section.title)
-
-      class_method = @klass.method_list.find { |c| c.name == "extmod_method_without_a_section" }
-      assert_nil(class_method.section.title)
-
-      class_attr = @klass.attributes.find { |c| c.name == "extmod_attr_without_a_section" }
-      assert_nil(class_attr.section.title)
-    end
-  end
-end
diff --git a/test/mri/rdoc/rdoc/rdoc_code_object_test.rb b/test/mri/rdoc/rdoc/rdoc_code_object_test.rb
deleted file mode 100644
index af5c34257c6..00000000000
--- a/test/mri/rdoc/rdoc/rdoc_code_object_test.rb
+++ /dev/null
@@ -1,416 +0,0 @@
-# coding: US-ASCII
-# frozen_string_literal: true
-
-require_relative 'xref_test_case'
-
-class RDocCodeObjectTest < XrefTestCase
-
-  def setup
-    super
-
-    @co = RDoc::CodeObject.new
-  end
-
-  def test_initialize
-    assert @co.document_self, 'document_self'
-    assert @co.document_children, 'document_children'
-    refute @co.force_documentation, 'force_documentation'
-    refute @co.done_documenting, 'done_documenting'
-    refute @co.received_nodoc, 'received_nodoc'
-    assert_equal '', @co.comment, 'comment is empty'
-  end
-
-  def test_comment_equals
-    @co.comment = ''
-
-    assert_equal '', @co.comment
-
-    @co.comment = 'I am a comment'
-
-    assert_equal 'I am a comment', @co.comment
-  end
-
-  def test_comment_equals_comment
-    @co.comment = comment ''
-
-    assert_equal '', @co.comment.text
-
-    @co.comment = comment 'I am a comment'
-
-    assert_equal 'I am a comment', @co.comment.text
-  end
-
-  def test_comment_equals_empty_string
-    @co.comment = 'comment'
-
-    @co.comment = ''
-
-    assert_equal 'comment', @co.comment
-  end
-
-  def test_comment_equals_encoding
-    refute_equal Encoding::UTF_8, ''.encoding, 'Encoding sanity check'
-
-    input = 'text'
-    input = RDoc::Encoding.change_encoding input, Encoding::UTF_8
-
-    @co.comment = input
-
-    assert_equal 'text', @co.comment
-    assert_equal Encoding::UTF_8, @co.comment.encoding
-  end
-
-  def test_comment_equals_encoding_blank
-    refute_equal Encoding::UTF_8, ''.encoding, 'Encoding sanity check'
-
-    input = ''
-    input = RDoc::Encoding.change_encoding input, Encoding::UTF_8
-
-    @co.comment = input
-
-    assert_equal '', @co.comment
-    assert_equal Encoding::UTF_8, @co.comment.encoding
-  end
-
-  def test_display_eh_document_self
-    assert @co.display?
-
-    @co.document_self = false
-
-    refute @co.display?
-  end
-
-  def test_display_eh_ignore
-    assert @co.display?
-
-    @co.ignore
-
-    refute @co.display?
-
-    @co.stop_doc
-
-    refute @co.display?
-
-    @co.done_documenting = false
-
-    refute @co.display?
-  end
-
-  def test_display_eh_suppress
-    assert @co.display?
-
-    @co.suppress
-
-    refute @co.display?
-
-    @co.comment = comment('hi')
-
-    refute @co.display?
-
-    @co.done_documenting = false
-
-    assert @co.display?
-
-    @co.ignore
-    @co.done_documenting = false
-
-    refute @co.display?
-  end
-
-  def test_document_children_equals
-    @co.document_children = false
-
-    refute @co.document_children
-
-    @store.options.visibility = :nodoc
-
-    @co.store = @store
-
-    assert @co.document_children
-
-    @co.document_children = false
-
-    assert @co.document_children
-  end
-
-  def test_document_self_equals
-    @co.document_self = false
-    refute @co.document_self
-
-    @store.options.visibility = :nodoc
-
-    @co.store = @store
-
-    assert @co.document_self
-
-    @co.document_self = false
-
-    assert @co.document_self
-  end
-
-  def test_documented_eh
-    refute @co.documented?
-
-    @co.comment = 'hi'
-
-    assert @co.documented?
-
-    @co.comment.replace ''
-
-    refute @co.documented?
-
-    @co.document_self = nil # notify :nodoc:
-
-    assert @co.documented?
-  end
-
-  def test_done_documenting
-    # once done_documenting is set, other properties refuse to go to "true"
-    @co.done_documenting = true
-
-    @co.document_self = true
-    refute @co.document_self
-
-    @co.document_children = true
-    refute @co.document_children
-
-    @co.force_documentation = true
-    refute @co.force_documentation
-
-    @co.start_doc
-    refute @co.document_self
-    refute @co.document_children
-
-    # turning done_documenting on
-    # resets others to true
-
-    @co.done_documenting = false
-    assert @co.document_self
-    assert @co.document_children
-
-    @co.done_documenting = true
-
-    @store.options.visibility = :nodoc
-
-    @co.store = @store
-
-    refute @co.done_documenting
-
-    @co.done_documenting = true
-
-    refute @co.done_documenting
-  end
-
-  def test_file_name
-    assert_nil @co.file_name
-
-    @co.record_location @store.add_file 'lib/file.rb'
-
-    assert_equal 'lib/file.rb', @co.file_name
-  end
-
-  def test_full_name_equals
-    @co.full_name = 'hi'
-
-    assert_equal 'hi', @co.instance_variable_get(:@full_name)
-
-    @co.full_name = nil
-
-    assert_nil @co.instance_variable_get(:@full_name)
-  end
-
-  def test_ignore
-    @co.ignore
-
-    refute @co.document_self
-    refute @co.document_children
-    assert @co.ignored?
-
-    @store.options.visibility = :nodoc
-
-    @co.store = @store
-
-    assert @co.document_self
-    assert @co.document_children
-    refute @co.ignored?
-
-    @co.ignore
-
-    refute @co.ignored?
-  end
-
-  def test_ignore_eh
-    refute @co.ignored?
-
-    @co.ignore
-
-    assert @co.ignored?
-  end
-
-  def test_line
-    @c1_m.line = 5
-
-    assert_equal 5, @c1_m.line
-  end
-
-  def test_metadata
-    assert_empty @co.metadata
-
-    @co.metadata['markup'] = 'not_rdoc'
-
-    expected = { 'markup' => 'not_rdoc' }
-
-    assert_equal expected, @co.metadata
-
-    assert_equal 'not_rdoc', @co.metadata['markup']
-  end
-
-  def test_parent_name
-    assert_equal '(unknown)', @co.parent_name
-    assert_equal 'xref_data.rb', @c1.parent_name
-    assert_equal 'C2', @c2_c3.parent_name
-  end
-
-  def test_received_ndoc
-    @co.document_self = false
-    refute @co.received_nodoc
-
-    @co.document_self = nil
-    assert @co.received_nodoc
-
-    @co.document_self = true
-  end
-
-  def test_record_location
-    @co.record_location @xref_data
-
-    assert_equal 'xref_data.rb', @co.file.relative_name
-  end
-
-  def test_record_location_ignored
-    @co.ignore
-    @co.record_location @xref_data
-
-    refute @co.ignored?
-  end
-
-  def test_record_location_suppressed
-    @co.suppress
-    @co.record_location @xref_data
-
-    refute @co.suppressed?
-  end
-
-  def test_section
-    parent = RDoc::Context.new
-    section = parent.sections.first
-
-    @co.parent = parent
-    @co.instance_variable_set :@section, section
-
-    assert_equal section, @co.section
-
-    @co.instance_variable_set :@section, nil
-    @co.instance_variable_set :@section_title, nil
-
-    assert_equal section, @co.section
-
-    @co.instance_variable_set :@section, nil
-    @co.instance_variable_set :@section_title, 'new title'
-
-    assert_equal 'new title', @co.section.title
-  end
-
-  def test_start_doc
-    @co.document_self = false
-    @co.document_children = false
-
-    @co.start_doc
-
-    assert @co.document_self
-    assert @co.document_children
-  end
-
-  def test_start_doc_ignored
-    @co.ignore
-
-    @co.start_doc
-
-    assert @co.document_self
-    assert @co.document_children
-    refute @co.ignored?
-  end
-
-  def test_start_doc_suppressed
-    @co.suppress
-
-    @co.start_doc
-
-    assert @co.document_self
-    assert @co.document_children
-    refute @co.suppressed?
-  end
-
-  def test_store_equals
-    @co.document_self = false
-
-    @co.store = @store
-
-    refute @co.document_self
-
-    @store.options.visibility = :nodoc
-
-    @co.store = @store
-
-    assert @co.document_self
-  end
-
-  def test_stop_doc
-    @co.document_self = true
-    @co.document_children = true
-
-    @co.stop_doc
-
-    refute @co.document_self
-    refute @co.document_children
-
-    @store.options.visibility = :nodoc
-
-    @co.store = @store
-
-    assert @co.document_self
-    assert @co.document_children
-
-    @co.stop_doc
-
-    assert @co.document_self
-    assert @co.document_children
-  end
-
-  def test_suppress
-    @co.suppress
-
-    refute @co.document_self
-    refute @co.document_children
-    assert @co.suppressed?
-
-    @store.options.visibility = :nodoc
-
-    @co.store = @store
-
-    refute @co.suppressed?
-
-    @co.suppress
-
-    refute @co.suppressed?
-  end
-
-  def test_suppress_eh
-    refute @co.suppressed?
-
-    @co.suppress
-
-    assert @co.suppressed?
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc/rdoc_comment_test.rb b/test/mri/rdoc/rdoc/rdoc_comment_test.rb
deleted file mode 100644
index 1699575b9df..00000000000
--- a/test/mri/rdoc/rdoc/rdoc_comment_test.rb
+++ /dev/null
@@ -1,480 +0,0 @@
-# coding: us-ascii
-# frozen_string_literal: true
-
-require_relative 'helper'
-
-class RDocCommentTest < RDoc::TestCase
-
-  def setup
-    super
-
-    @top_level = @store.add_file 'file.rb'
-    @comment = RDoc::Comment.new
-    @comment.location = @top_level
-    @comment.text = 'this is a comment'
-  end
-
-  def test_empty
-    @comment.text = ''
-    assert_empty @comment
-    empty_doc = @comment.parse
-    assert_empty @comment
-    @comment.text = 'a'
-    refute_empty @comment
-    present_doc = @comment.parse
-    refute_empty @comment
-    assert_empty RDoc::Comment.from_document(empty_doc)
-    refute_empty RDoc::Comment.from_document(present_doc)
-  end
-
-  def test_equals2
-    assert_equal @comment, @comment.dup
-
-    c2 = @comment.dup
-    c2.text = nil
-
-    refute_equal @comment, c2
-
-    c3 = @comment.dup
-    c3.location = nil
-
-    refute_equal @comment, c3
-  end
-
-  def test_extract_call_seq
-    comment = RDoc::Comment.new <<-COMMENT, @top_level
-call-seq:
-  bla => true or false
-
-moar comment
-    COMMENT
-
-    assert_equal "bla => true or false\n", comment.extract_call_seq
-  end
-
-  def test_extract_call_seq_blank
-    comment = RDoc::Comment.new <<-COMMENT, @top_level
-call-seq:
-  bla => true or false
-
-    COMMENT
-
-    assert_equal "bla => true or false\n", comment.extract_call_seq
-  end
-
-  def test_extract_call_seq_commented
-    comment = RDoc::Comment.new <<-COMMENT, @top_level
-# call-seq:
-#   bla => true or false
-#
-# moar comment
-    COMMENT
-
-    assert_nil comment.extract_call_seq
-  end
-
-  def test_extract_call_seq_no_blank
-    comment = RDoc::Comment.new <<-COMMENT, @top_level
-call-seq:
-  bla => true or false
-    COMMENT
-
-    assert_equal "bla => true or false\n", comment.extract_call_seq
-  end
-
-  def test_extract_call_seq_undent
-    comment = RDoc::Comment.new <<-COMMENT, @top_level
-call-seq:
-  bla => true or false
-moar comment
-    COMMENT
-
-    assert_equal "bla => true or false\nmoar comment\n", comment.extract_call_seq
-  end
-
-  def test_extract_call_seq_c
-    comment = RDoc::Comment.new <<-COMMENT
-call-seq:
-  commercial() -> Date <br />
-  commercial(cwyear, cweek=41, cwday=5, sg=nil) -> Date [ruby 1.8] <br />
-  commercial(cwyear, cweek=1, cwday=1, sg=nil) -> Date [ruby 1.9]
-
-If no arguments are given:
-* ruby 1.8: returns a +Date+ for 1582-10-15 (the Day of Calendar Reform in
-  Italy)
-* ruby 1.9: returns a +Date+ for julian day 0
-
-Otherwise, returns a +Date+ for the commercial week year, commercial week,
-and commercial week day given. Ignores the 4th argument.
-    COMMENT
-
-    expected = <<-CALL_SEQ.chomp
-commercial() -> Date <br />
-commercial(cwyear, cweek=41, cwday=5, sg=nil) -> Date [ruby 1.8] <br />
-commercial(cwyear, cweek=1, cwday=1, sg=nil) -> Date [ruby 1.9]
-
-    CALL_SEQ
-
-    assert_equal expected, comment.extract_call_seq
-  end
-
-  def test_extract_call_seq_c_no_blank
-    comment = RDoc::Comment.new <<-COMMENT
-call-seq:
-  commercial() -> Date <br />
-  commercial(cwyear, cweek=41, cwday=5, sg=nil) -> Date [ruby 1.8] <br />
-  commercial(cwyear, cweek=1, cwday=1, sg=nil) -> Date [ruby 1.9]
-    COMMENT
-
-    expected = <<-CALL_SEQ.chomp
-commercial() -> Date <br />
-commercial(cwyear, cweek=41, cwday=5, sg=nil) -> Date [ruby 1.8] <br />
-commercial(cwyear, cweek=1, cwday=1, sg=nil) -> Date [ruby 1.9]
-
-    CALL_SEQ
-
-    assert_equal expected, comment.extract_call_seq
-  end
-
-  def test_extract_call_seq_c_separator
-    comment = RDoc::Comment.new <<-'COMMENT'
-call-seq:
-   ARGF.readlines(sep=$/)     -> array
-   ARGF.readlines(limit)      -> array
-   ARGF.readlines(sep, limit) -> array
-
-   ARGF.to_a(sep=$/)     -> array
-   ARGF.to_a(limit)      -> array
-   ARGF.to_a(sep, limit) -> array
-
-Reads +ARGF+'s current file in its entirety, returning an +Array+ of its
-lines, one line per element. Lines are assumed to be separated by _sep_.
-
-   lines = ARGF.readlines
-   lines[0]                #=> "This is line one\n"
-
-    COMMENT
-
-    expected = <<-CALL_SEQ
-ARGF.readlines(sep=$/)     -> array
-ARGF.readlines(limit)      -> array
-ARGF.readlines(sep, limit) -> array
-ARGF.to_a(sep=$/)     -> array
-ARGF.to_a(limit)      -> array
-ARGF.to_a(sep, limit) -> array
-    CALL_SEQ
-
-    assert_equal expected, comment.extract_call_seq
-
-    expected = <<-'COMMENT'
-
-Reads +ARGF+'s current file in its entirety, returning an +Array+ of its
-lines, one line per element. Lines are assumed to be separated by _sep_.
-
-   lines = ARGF.readlines
-   lines[0]                #=> "This is line one\n"
-
-    COMMENT
-
-    assert_equal expected, comment.text
-  end
-
-  # This test relies on AnyMethod#call_seq's behaviour as well
-  def test_extract_call_linear_performance
-    pre = ->(n) {[n, RDoc::Comment.new("\n"*n + 'call-seq:' + 'a'*n)]}
-    method_obj = RDoc::AnyMethod.new nil, 'blah'
-    assert_linear_performance((2..5).map {|i| 10**i}, pre: pre) do |n, comment|
-      method_obj.call_seq = comment.extract_call_seq
-      assert_equal n, method_obj.call_seq.size
-    end
-  end
-
-  def test_force_encoding
-    @comment = RDoc::Encoding.change_encoding @comment, Encoding::UTF_8
-
-    assert_equal Encoding::UTF_8, @comment.text.encoding
-  end
-
-  def test_format
-    assert_equal 'rdoc', @comment.format
-  end
-
-  def test_format_equals
-    c = comment 'content'
-    document = c.parse
-
-    c.format = RDoc::RD
-
-    assert_equal RDoc::RD, c.format
-    refute_same document, c.parse
-  end
-
-  def test_initialize_copy
-    copy = @comment.dup
-
-    refute_same @comment.text, copy.text
-    assert_same @comment.location, copy.location
-  end
-
-  def test_location
-    assert_equal @top_level, @comment.location
-  end
-
-  def test_normalize
-    @comment.text = <<-TEXT
-  # comment
-    TEXT
-    @comment.language = :ruby
-
-    assert_same @comment, @comment.normalize
-
-    assert_equal 'comment', @comment.text
-  end
-
-  def test_normalize_twice
-    @comment.text = <<-TEXT
-  # comment
-    TEXT
-
-    @comment.normalize
-
-    text = @comment.text
-
-    @comment.normalize
-
-    assert_same text, @comment.text, 'normalize not cached'
-  end
-
-  def test_normalize_document
-    @comment.text = nil
-    @comment.document = @RM::Document.new
-
-    assert_same @comment, @comment.normalize
-
-    assert_nil @comment.text
-  end
-
-  def test_normalize_eh
-    refute @comment.normalized?
-
-    @comment.normalize
-
-    assert @comment.normalized?
-  end
-
-  def test_text
-    assert_equal 'this is a comment', @comment.text
-  end
-
-  def test_text_equals
-    @comment.text = 'other'
-
-    assert_equal 'other', @comment.text
-    refute @comment.normalized?
-  end
-
-  def test_text_equals_no_text
-    c = RDoc::Comment.new nil, @top_level
-    c.document = @RM::Document.new
-
-    e = assert_raise RDoc::Error do
-      c.text = 'other'
-    end
-
-    assert_equal 'replacing document-only comment is not allowed', e.message
-  end
-
-  def test_text_equals_parsed
-    document = @comment.parse
-
-    @comment.text = 'other'
-
-    refute_equal document, @comment.parse
-  end
-
-  def test_tomdoc_eh
-    refute @comment.tomdoc?
-
-    @comment.format = 'tomdoc'
-
-    assert @comment.tomdoc?
-  end
-
-  def test_parse
-    parsed = @comment.parse
-
-    expected = @RM::Document.new(
-      @RM::Paragraph.new('this is a comment'))
-
-    expected.file = @top_level
-
-    assert_equal expected, parsed
-    assert_same  parsed, @comment.parse
-  end
-
-  def test_parse_rd
-    c = comment 'it ((*works*))'
-    c.format = 'rd'
-
-    expected =
-      @RM::Document.new(
-        @RM::Paragraph.new('it <em>works</em>'))
-    expected.file = @top_level
-
-    assert_equal expected, c.parse
-  end
-
-  def test_remove_private_encoding
-    comment = RDoc::Comment.new <<-EOS, @top_level
-# This is text
-#--
-# this is private
-    EOS
-
-    comment = RDoc::Encoding.change_encoding comment, Encoding::IBM437
-
-    comment.remove_private
-
-    assert_equal Encoding::IBM437, comment.text.encoding
-  end
-
-  def test_remove_private_hash
-    @comment.text = <<-TEXT
-#--
-# private
-#++
-# public
-    TEXT
-
-    @comment.remove_private
-
-    assert_equal "# public\n", @comment.text
-  end
-
-  def test_remove_private_hash_trail
-    comment = RDoc::Comment.new <<-EOS, @top_level
-# This is text
-#--
-# this is private
-    EOS
-
-    expected = RDoc::Comment.new <<-EOS, @top_level
-# This is text
-    EOS
-
-    comment.remove_private
-
-    assert_equal expected, comment
-  end
-
-  def test_remove_private_long
-    comment = RDoc::Comment.new <<-EOS, @top_level
-#-----
-#++
-# this is text
-#-----
-    EOS
-
-    expected = RDoc::Comment.new <<-EOS, @top_level
-# this is text
-    EOS
-
-    comment.remove_private
-
-    assert_equal expected, comment
-  end
-
-  def test_remove_private_rule
-    comment = RDoc::Comment.new <<-EOS, @top_level
-# This is text with a rule:
-# ---
-# this is also text
-    EOS
-
-    expected = comment.dup
-
-    comment.remove_private
-
-    assert_equal expected, comment
-  end
-
-  def test_remove_private_star
-    @comment.text = <<-TEXT
-/*
- *--
- * private
- *++
- * public
- */
-    TEXT
-
-    @comment.remove_private
-
-    assert_equal "/*\n * public\n */\n", @comment.text
-  end
-
-  def test_remove_private_star2
-    @comment.text = <<-TEXT
-/*--
- * private
- *++
- * public
- */
-    TEXT
-
-    @comment.remove_private
-
-    assert_equal "/*--\n * private\n *++\n * public\n */\n", @comment.text
-  end
-
-  def test_remove_private_toggle
-    comment = RDoc::Comment.new <<-EOS, @top_level
-# This is text
-#--
-# this is private
-#++
-# This is text again.
-    EOS
-
-    expected = RDoc::Comment.new <<-EOS, @top_level
-# This is text
-# This is text again.
-    EOS
-
-    comment.remove_private
-
-    assert_equal expected, comment
-  end
-
-  def test_remove_private_toggle_encoding
-    comment = RDoc::Comment.new <<-EOS, @top_level
-# This is text
-#--
-# this is private
-#++
-# This is text again.
-    EOS
-
-    comment = RDoc::Encoding.change_encoding comment, Encoding::IBM437
-
-    comment.remove_private
-
-    assert_equal Encoding::IBM437, comment.text.encoding
-  end
-
-  def test_remove_private_toggle_encoding_ruby_bug?
-    comment = RDoc::Comment.new <<-EOS, @top_level
-#--
-# this is private
-#++
-# This is text again.
-    EOS
-
-    comment = RDoc::Encoding.change_encoding comment, Encoding::IBM437
-
-    comment.remove_private
-
-    assert_equal Encoding::IBM437, comment.text.encoding
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc/rdoc_constant_test.rb b/test/mri/rdoc/rdoc/rdoc_constant_test.rb
deleted file mode 100644
index f9f795101c2..00000000000
--- a/test/mri/rdoc/rdoc/rdoc_constant_test.rb
+++ /dev/null
@@ -1,182 +0,0 @@
-# frozen_string_literal: true
-require_relative 'xref_test_case'
-
-class RDocConstantTest < XrefTestCase
-
-  def setup
-    super
-
-    @const = @c1.constants.first
-  end
-
-  def test_documented_eh
-    top_level = @store.add_file 'file.rb'
-
-    const = RDoc::Constant.new 'CONST', nil, nil
-    top_level.add_constant const
-
-    refute const.documented?
-
-    const.comment = comment 'comment'
-
-    assert const.documented?
-  end
-
-  def test_documented_eh_alias
-    top_level = @store.add_file 'file.rb'
-
-    const = RDoc::Constant.new 'CONST', nil, nil
-    top_level.add_constant const
-
-    refute const.documented?
-
-    const.is_alias_for = 'C1'
-
-    refute const.documented?
-
-    @c1.add_comment comment('comment'), @top_level
-
-    assert const.documented?
-  end
-
-  def test_full_name
-    assert_equal 'C1::CONST', @const.full_name
-  end
-
-  def test_is_alias_for
-    top_level = @store.add_file 'file.rb'
-
-    c = RDoc::Constant.new 'CONST', nil, 'comment'
-    top_level.add_constant c
-
-    assert_nil c.is_alias_for
-
-    c.is_alias_for = 'C1'
-
-    assert_equal @c1, c.is_alias_for
-
-    c.is_alias_for = 'unknown'
-
-    assert_equal 'unknown', c.is_alias_for
-  end
-
-  def test_marshal_dump
-    top_level = @store.add_file 'file.rb'
-
-    c = RDoc::Constant.new 'CONST', nil, 'this is a comment'
-    c.record_location top_level
-
-    aliased = top_level.add_class RDoc::NormalClass, 'Aliased'
-    c.is_alias_for = aliased
-
-    cm = top_level.add_class RDoc::NormalClass, 'Klass'
-    cm.add_constant c
-
-    section = cm.sections.first
-
-    loaded = Marshal.load Marshal.dump c
-    loaded.store = @store
-
-    document = doc(para('this is a comment'))
-
-    assert_equal c, loaded
-
-    assert_equal aliased,        loaded.is_alias_for
-    assert_equal document,       loaded.comment.parse
-    assert_equal top_level,      loaded.file
-    assert_equal 'Klass::CONST', loaded.full_name
-    assert_equal 'CONST',        loaded.name
-    assert_equal :public,        loaded.visibility
-    assert_equal cm,             loaded.parent
-    assert_equal section,        loaded.section
-  end
-
-  def test_marshal_load
-    top_level = @store.add_file 'file.rb'
-
-    c = RDoc::Constant.new 'CONST', nil, 'this is a comment'
-    c.record_location top_level
-
-    cm = top_level.add_class RDoc::NormalClass, 'Klass'
-    cm.add_constant c
-
-    section = cm.sections.first
-
-    loaded = Marshal.load Marshal.dump c
-    loaded.store = @store
-
-    document = doc(para('this is a comment'))
-
-    assert_equal c, loaded
-
-    assert_nil                   loaded.is_alias_for
-    assert_equal document,       loaded.comment.parse
-    assert_equal top_level,      loaded.file
-    assert_equal 'Klass::CONST', loaded.full_name
-    assert_equal 'CONST',        loaded.name
-    assert_equal :public,        loaded.visibility
-    assert_equal cm,             loaded.parent
-    assert_equal section,        loaded.section
-
-    assert                       loaded.display?
-  end
-
-  def test_marshal_load_version_0
-    top_level = @store.add_file 'file.rb'
-
-    aliased = top_level.add_class RDoc::NormalClass, 'Aliased'
-    cm      = top_level.add_class RDoc::NormalClass, 'Klass'
-    section = cm.sections.first
-
-    loaded = Marshal.load "\x04\bU:\x13RDoc::Constant[\x0Fi\x00I" +
-                          "\"\nCONST\x06:\x06ETI\"\x11Klass::CONST\x06" +
-                          ";\x06T0I\"\fAliased\x06;\x06To" +
-                          ":\eRDoc::Markup::Document\a:\v@parts[\x06o" +
-                          ":\x1CRDoc::Markup::Paragraph\x06;\b[\x06I" +
-                          "\"\x16this is a comment\x06;\x06T:\n@file0I" +
-                          "\"\ffile.rb\x06;\x06TI\"\nKlass\x06" +
-                          ";\x06Tc\x16RDoc::NormalClass0"
-
-    loaded.store = @store
-
-    document = doc(para('this is a comment'))
-
-    assert_equal aliased,        loaded.is_alias_for
-    assert_equal document,       loaded.comment.parse
-    assert_equal top_level,      loaded.file
-    assert_equal 'Klass::CONST', loaded.full_name
-    assert_equal 'CONST',        loaded.name
-    assert_equal :public,        loaded.visibility
-    assert_equal cm,             loaded.parent
-    assert_equal section,        loaded.section
-
-    assert loaded.display?
-  end
-
-  def test_marshal_round_trip
-    top_level = @store.add_file 'file.rb'
-
-    c = RDoc::Constant.new 'CONST', nil, 'this is a comment'
-    c.record_location top_level
-    c.is_alias_for = 'Unknown'
-
-    cm = top_level.add_class RDoc::NormalClass, 'Klass'
-    cm.add_constant c
-
-    section = cm.sections.first
-
-    loaded = Marshal.load Marshal.dump c
-    loaded.store = @store
-
-    reloaded = Marshal.load Marshal.dump loaded
-    reloaded.store = @store
-
-    assert_equal section,   reloaded.section
-    assert_equal 'Unknown', reloaded.is_alias_for
-  end
-
-  def test_path
-    assert_equal 'C1.html#CONST', @const.path
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc/rdoc_context_section_test.rb b/test/mri/rdoc/rdoc/rdoc_context_section_test.rb
deleted file mode 100644
index 179ea95014c..00000000000
--- a/test/mri/rdoc/rdoc/rdoc_context_section_test.rb
+++ /dev/null
@@ -1,145 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocContextSectionTest < RDoc::TestCase
-
-  def setup
-    super
-
-    @top_level = @store.add_file 'file.rb'
-
-    @klass = @top_level.add_class RDoc::NormalClass, 'Object'
-
-    @S = RDoc::Context::Section
-    @s = @S.new @klass, 'section', comment('# comment', @top_level, :ruby)
-  end
-
-  def test_add_comment
-    file1 = @store.add_file 'file1.rb'
-
-    klass = file1.add_class RDoc::NormalClass, 'Klass'
-
-    c1 = RDoc::Comment.new "# :section: section\n", file1
-    c2 = RDoc::Comment.new "# hello\n",             file1
-    c3 = RDoc::Comment.new "# world\n",             file1
-
-    s = @S.new klass, 'section', c1
-
-    assert_empty s.comments
-
-    s.add_comment nil
-
-    assert_empty s.comments
-
-    s.add_comment c2
-
-    assert_equal [c2], s.comments
-
-    s.add_comment c3
-
-    assert_equal [c2, c3], s.comments
-  end
-
-  def test_aref
-    assert_equal 'section', @s.aref
-
-    assert_equal '5Buntitled-5D', @S.new(nil, nil, nil).aref
-
-    assert_equal 'one+two', @S.new(nil, 'one two', nil).aref
-  end
-
-  def test_eql_eh
-    other = @S.new @klass, 'other', comment('# comment', @top_level)
-
-    assert @s.eql? @s
-    assert @s.eql? @s.dup
-    refute @s.eql? other
-  end
-
-  def test_equals
-    other = @S.new @klass, 'other', comment('# comment', @top_level)
-
-    assert_equal @s, @s
-    assert_equal @s, @s.dup
-    refute_equal @s, other
-  end
-
-  def test_extract_comment
-    assert_equal '',    @s.extract_comment(comment('')).text
-    assert_equal '',    @s.extract_comment(comment("# :section: b\n")).text
-    assert_equal '# c', @s.extract_comment(comment("# :section: b\n# c")).text
-    assert_equal '# c',
-                 @s.extract_comment(comment("# a\n# :section: b\n# c")).text
-  end
-
-  def test_hash
-    other = @S.new @klass, 'other', comment('# comment', @top_level)
-
-    assert_equal @s.hash, @s.hash
-    assert_equal @s.hash, @s.dup.hash
-    refute_equal @s.hash, other.hash
-  end
-
-  def test_marshal_dump
-    loaded = Marshal.load Marshal.dump @s
-
-    expected = doc RDoc::Comment.new('comment', @top_level).parse
-
-    assert_equal 'section', loaded.title
-    assert_equal expected,  loaded.parse
-    assert_nil              loaded.parent, 'parent is set manually'
-  end
-
-  def test_marshal_dump_no_comment
-    s = @S.new @klass, 'section', comment('')
-
-    loaded = Marshal.load Marshal.dump s
-
-    assert_equal 'section', loaded.title
-    assert_empty            loaded.comments
-    assert_nil              loaded.parent, 'parent is set manually'
-  end
-
-  def test_marshal_load_version_0
-    loaded = Marshal.load "\x04\bU:\eRDoc::Context::Section" +
-                          "[\bi\x00I\"\fsection\x06:\x06EFo" +
-                          ":\eRDoc::Markup::Document\a:\v@parts" +
-                          "[\x06o;\a\a;\b[\x06o" +
-                          ":\x1CRDoc::Markup::Paragraph\x06;\b" +
-                          "[\x06I\"\fcomment\x06;\x06F:\n@fileI" +
-                          "\"\ffile.rb\x06;\x06F;\n0"
-
-    expected = doc RDoc::Comment.new('comment', @top_level).parse
-
-    assert_equal 'section', loaded.title
-    assert_equal expected,  loaded.parse
-    assert_nil              loaded.parent, 'parent is set manually'
-  end
-
-  def test_remove_comment_array
-    other = @store.add_file 'other.rb'
-
-    other_comment = comment('bogus', other)
-
-    @s.add_comment other_comment
-
-    @s.remove_comment comment('bogus', @top_level)
-
-    assert_equal [other_comment], @s.comments
-  end
-
-  def test_remove_comment_document
-    other = @store.add_file 'other.rb'
-
-    other_comment = comment('bogus', other)
-
-    @s.add_comment other_comment
-
-    loaded = Marshal.load Marshal.dump @s
-
-    loaded.remove_comment comment('bogus', @top_level)
-
-    assert_equal doc(other_comment.parse), loaded.parse
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc/rdoc_context_test.rb b/test/mri/rdoc/rdoc/rdoc_context_test.rb
deleted file mode 100644
index eaa4f236219..00000000000
--- a/test/mri/rdoc/rdoc/rdoc_context_test.rb
+++ /dev/null
@@ -1,958 +0,0 @@
-# frozen_string_literal: true
-require_relative 'xref_test_case'
-
-class RDocContextTest < XrefTestCase
-
-  def setup
-    super
-
-    @context = RDoc::Context.new
-    @context.store = @store
-  end
-
-  def test_initialize
-    assert_empty @context.in_files
-    assert_equal 'unknown', @context.name
-    assert_equal '', @context.comment
-    assert_nil   @context.parent
-    assert_equal :public, @context.visibility
-    assert_equal 1, @context.sections.length
-    assert_nil   @context.temporary_section
-
-    assert_empty @context.classes_hash
-    assert_empty @context.modules_hash
-
-    assert_empty @context.method_list
-    assert_empty @context.attributes
-    assert_empty @context.aliases
-    assert_empty @context.requires
-    assert_empty @context.includes
-    assert_empty @context.constants
-  end
-
-  def test_add_alias
-    as = RDoc::Alias.new nil, 'old_name', 'new_name', 'comment'
-
-    @context.add_alias as
-
-    assert_equal [as], @context.external_aliases
-    assert_equal [as], @context.unmatched_alias_lists['#old_name']
-  end
-
-  def test_add
-    @context.add RDoc::Extend,  'Ext', 'comment'
-    @context.add RDoc::Include, 'Incl', 'comment'
-
-    refute_empty @context.extends
-    refute_empty @context.includes
-  end
-
-  def test_add_alias_method_attr
-    top_level = @store.add_file 'file.rb'
-
-    attr = RDoc::Attr.new nil, 'old_name', 'R', ''
-
-    as = RDoc::Alias.new nil, 'old_name', 'new_name', 'comment'
-    as.record_location top_level
-    as.parent = @context
-
-    @context.add_attribute attr
-    @context.add_alias as
-
-    assert_empty @context.aliases
-    assert_empty @context.unmatched_alias_lists
-    assert_equal %w[old_name new_name], @context.attributes.map { |m| m.name }
-
-    new = @context.attributes.last
-    assert_equal top_level, new.file
-  end
-
-  def test_add_alias_method
-    top_level = @store.add_file 'file.rb'
-
-    meth = RDoc::AnyMethod.new nil, 'old_name'
-    meth.singleton = false
-
-    as = RDoc::Alias.new nil, 'old_name', 'new_name', 'comment'
-    as.record_location top_level
-    as.parent = @context
-
-    @context.add_method meth
-    @context.add_alias as
-
-    assert_empty @context.aliases
-    assert_empty @context.unmatched_alias_lists
-    assert_equal %w[old_name new_name], @context.method_list.map { |m| m.name }
-
-    new = @context.method_list.last
-    assert_equal top_level, new.file
-  end
-
-  def test_add_alias_method_singleton
-    meth = RDoc::AnyMethod.new nil, 'old_name', singleton: true
-
-    as = RDoc::Alias.new nil, 'old_name', 'new_name', 'comment', singleton: true
-
-    as.parent = @context
-
-    @context.add_method meth
-    @context.add_alias as
-
-    assert_empty @context.aliases
-    assert_empty @context.unmatched_alias_lists
-    assert_equal %w[old_name new_name], @context.method_list.map { |m| m.name }
-
-    assert @context.method_list.last.singleton
-  end
-
-  def test_add_class
-    @c1.add_class RDoc::NormalClass, 'Klass', 'Object'
-
-    assert_includes @c1.classes.map { |k| k.full_name }, 'C1::Klass'
-    assert_includes @store.all_classes.map { |k| k.full_name }, 'C1::Klass'
-  end
-
-  def test_add_class_basic_object
-    @xref_data.add_class RDoc::NormalClass, 'BasicObject'
-
-    basic = @xref_data.find_module_named 'BasicObject'
-
-    assert_nil basic.superclass
-
-    @c1.add_class RDoc::NormalClass, 'BasicObject'
-
-    basic = @c1.find_module_named 'BasicObject'
-
-    assert_equal @object, basic.superclass
-  end
-
-  def test_add_class_object
-    @xref_data.add_class RDoc::NormalClass, 'Object'
-
-    object = @xref_data.find_module_named 'Object'
-
-    assert_equal 'BasicObject', object.superclass
-
-    @c1.add_class RDoc::NormalClass, 'Object'
-
-    object = @c1.find_module_named 'Object'
-
-    assert_equal 'Object', object.superclass.full_name
-  end
-
-  def test_add_class_singleton
-    @c1.add_class RDoc::NormalClass, 'Klass', 'Object'
-
-    assert_includes @c1.classes.map { |k| k.full_name }, 'C1::Klass'
-    assert_includes @store.all_classes.map { |k| k.full_name }, 'C1::Klass'
-  end
-
-  def test_add_class_superclass
-    @c1.add_class RDoc::NormalClass, 'Klass', 'Object'
-    @c1.add_class RDoc::NormalClass, 'Klass', 'Other'
-    @c1.add_class RDoc::NormalClass, 'Klass', 'Object'
-
-    klass = @c1.find_module_named 'Klass'
-    assert_equal 'Other', klass.superclass
-  end
-
-  def test_add_class_upgrade
-    @c1.add_module RDoc::NormalModule, 'Klass'
-    @c1.add_class RDoc::NormalClass, 'Klass', nil
-
-    assert_includes @c1.classes.map { |k| k.full_name }, 'C1::Klass',
-                    'c1 classes'
-    refute_includes @c1.modules.map { |k| k.full_name }, 'C1::Klass',
-                    'c1 modules'
-
-    assert_includes @store.all_classes.map { |k| k.full_name }, 'C1::Klass',
-                    'TopLevel classes'
-    refute_includes @store.all_modules.map { |k| k.full_name }, 'C1::Klass',
-                    'TopLevel modules'
-  end
-
-  def test_add_constant
-    const = RDoc::Constant.new 'NAME', 'value', 'comment'
-    @context.add_constant const
-
-    assert_equal [const], @context.constants
-  end
-
-  def test_add_extend
-    ext = RDoc::Extend.new 'Name', 'comment'
-    @context.add_extend ext
-
-    assert_equal [ext], @context.extends
-  end
-
-  def test_add_include
-    incl = RDoc::Include.new 'Name', 'comment'
-    @context.add_include incl
-
-    assert_equal [incl], @context.includes
-  end
-
-  def test_add_method
-    meth = RDoc::AnyMethod.new nil, 'old_name'
-    meth.visibility = nil
-
-    @context.add_method meth
-
-    assert_equal [meth], @context.method_list
-    assert_equal :public, meth.visibility
-  end
-
-  def test_add_method_alias
-    as = RDoc::Alias.new nil, 'old_name', 'new_name', 'comment'
-    meth = RDoc::AnyMethod.new nil, 'old_name'
-
-    @context.add_alias as
-    refute_empty @context.external_aliases
-
-    @context.add_method meth
-
-    assert_empty @context.external_aliases
-    assert_empty @context.unmatched_alias_lists
-    assert_equal %w[old_name new_name], @context.method_list.map { |m| m.name }
-  end
-
-  def test_add_method_duplicate
-    @store.options.verbosity = 2
-
-    meth1 = RDoc::AnyMethod.new nil, 'name'
-    meth1.record_location @store.add_file 'first.rb'
-    meth1.visibility = nil
-    meth1.comment = comment 'first'
-
-    @context.add_method meth1
-
-    meth2 = RDoc::AnyMethod.new nil, 'name'
-    meth2.record_location @store.add_file 'second.rb'
-    meth2.comment = comment 'second'
-
-    _, err = verbose_capture_output do
-      @context.add_method meth2
-    end
-
-    expected = 'Duplicate method (unknown)#name in file second.rb, ' \
-               'previously in file first.rb'
-
-    assert_equal expected, err.chomp
-
-    method = @context.method_list.first
-
-    assert_equal 'first', method.comment.text
-  end
-
-  def test_add_method_duplicate_loading
-    @context.store = nil
-
-    meth1 = RDoc::AnyMethod.new nil, 'name'
-    meth1.record_location @store.add_file 'first.rb'
-    meth1.visibility = nil
-    meth1.comment = comment 'first'
-
-    @context.add_method meth1
-
-    meth2 = RDoc::AnyMethod.new nil, 'name'
-    meth2.record_location @store.add_file 'second.rb'
-    meth2.comment = comment 'second'
-
-    _, err = verbose_capture_output do
-      @context.add_method meth2
-    end
-
-    assert_empty err
-
-    method = @context.method_list.first
-
-    assert_equal 'first', method.comment.text
-  end
-
-  def test_add_module
-    @c1.add_module RDoc::NormalModule, 'Mod'
-
-    assert_includes @c1.modules.map { |m| m.full_name }, 'C1::Mod'
-  end
-
-  def test_add_module_alias
-    tl = @store.add_file 'file.rb'
-
-    c4 = RDoc::Constant.new 'C4', '', ''
-    c3_c4 = @c2.add_module_alias @c2_c3, @c2_c3.name, c4, tl
-
-    alias_constant = @c2.constants.first
-
-    assert_equal 'C2::C4', c3_c4.full_name
-    assert_equal tl, alias_constant.file
-  end
-
-  def test_add_module_alias_top_level
-    store = RDoc::Store.new(RDoc::Options.new)
-
-    top_level = store.add_file 'file.rb'
-
-    klass  = top_level.add_class RDoc::NormalClass, 'Klass'
-    klass.comment = 'klass comment'
-
-    object = top_level.add_class RDoc::NormalClass, 'Object'
-
-    a = RDoc::Constant.new 'A', '', ''
-    top_level.add_module_alias klass, klass.name, a, top_level
-
-    refute_empty object.constants
-
-    constant = object.constants.first
-
-    assert_equal 'klass comment', constant.comment
-  end
-
-  def test_add_module_class
-    k = @c1.add_class RDoc::NormalClass, 'Klass', nil
-    m = @c1.add_module RDoc::NormalModule, 'Klass'
-
-    assert_equal k, m, 'returns class'
-    assert_empty @c1.modules
-  end
-
-  def test_add_require
-    req = RDoc::Require.new 'require', 'comment'
-    @c1.add_require req
-
-    assert_empty @c1.requires
-    assert_includes @c1.top_level.requires, req
-  end
-
-  def test_add_section
-    default_section = @context.sections.first
-
-    @context.add_section nil, comment('comment', @top_level)
-
-    assert_equal 1, @context.sections.length
-    assert_equal [comment("comment", @top_level)],
-                 @context.sections.first.comments
-
-    @context.add_section nil, comment('new comment', @top_level)
-
-    assert_equal 1, @context.sections.length
-    assert_equal [comment('comment', @top_level),
-                  comment('new comment', @top_level)],
-                 @context.sections.first.comments
-
-    @context.add_section 'other', comment('', @top_level)
-
-    assert_equal 2, @context.sections.length
-
-    new_section = @context.sections.find { |section| section.title == 'other' }
-    assert new_section
-    assert_equal default_section, @context.current_section
-  end
-
-  def test_add_section_no_comment
-    default_section = @context.sections.first
-
-    @context.add_section nil
-
-    assert_equal 1, @context.sections.length
-
-    @context.add_section 'other'
-
-    assert_equal 2, @context.sections.length
-
-    new_section = @context.sections.find { |section| section.title == 'other' }
-
-    assert new_section
-    assert_equal default_section, @context.current_section
-  end
-
-  def test_add_to
-    incl = RDoc::Include.new 'Name', 'comment'
-    arr = []
-    @context.add_to arr, incl
-
-    assert_includes arr, incl
-    assert_equal @context, incl.parent
-    assert_equal @context.current_section, incl.section
-  end
-
-  def test_add_to_temporary_section
-    incl = RDoc::Include.new 'Name', 'comment'
-    arr = []
-    section =
-      @context.add_section 'temporary', RDoc::Comment.new('', @top_level)
-    @context.temporary_section = section
-
-    @context.add_to arr, incl
-
-    assert_includes arr, incl
-    assert_equal @context, incl.parent
-    assert_equal section, incl.section
-  end
-
-  def test_add_to_no_document_self
-    incl = RDoc::Include.new 'Name', 'comment'
-    arr = []
-    @context.document_self = false
-    @context.add_to arr, incl
-
-    refute_includes arr, incl
-  end
-
-  def test_add_to_done_documenting
-    incl = RDoc::Include.new 'Name', 'comment'
-    arr = []
-    @context.done_documenting = true
-    @context.add_to arr, incl
-
-    refute_includes arr, incl
-  end
-
-  def bench_add_include
-    cm = RDoc::ClassModule.new 'Klass'
-
-    assert_performance_linear 0.5 do |count|
-      count.times do |i|
-        cm.add_include RDoc::Include.new("N::M#{i}", nil)
-      end
-    end
-  end
-
-  def test_child_name
-    assert_equal 'C1::C1', @c1.child_name('C1')
-  end
-
-  def test_classes
-    assert_equal %w[C2::C3], @c2.classes.map { |k| k.full_name }
-    assert_equal %w[C3::H1 C3::H2], @c3.classes.map { |k| k.full_name }.sort
-  end
-
-  def test_current_section
-    default_section = @context.current_section
-
-    new_section =
-      @context.add_section 'other', RDoc::Comment.new('', @top_level)
-    @context.temporary_section = new_section
-
-    assert_equal new_section, @context.current_section
-    assert_equal default_section, @context.current_section
-  end
-
-  def test_equals2
-    assert_equal @c3,    @c3
-    refute_equal @c2,    @c3
-    refute_equal @c2_c3, @c3
-  end
-
-  def test_each_method_enumerator
-    assert_kind_of Enumerator, @c1.each_method
-  end
-
-  def test_each_section
-    sects  = []
-    consts = []
-    attrs  = []
-
-    @c1.each_section do |section, constants, attributes|
-      sects  << section
-      consts << constants
-      attrs  << attributes
-    end
-
-    assert_equal [nil, 'separate'], sects.map { |section| section.title }
-
-    expected_consts = [
-      [@c1.constants.first],
-      [],
-    ]
-
-    assert_equal expected_consts, consts
-
-    expected_attrs = [
-      [@c1.attributes[0], @c1.attributes[3]],
-      [@c1.attributes[1], @c1.attributes[2]],
-    ]
-
-    assert_equal expected_attrs, attrs
-  end
-
-  def test_each_section_only_display
-    sects  = []
-    consts = []
-    attrs  = []
-
-    @c7.each_section do |section, constants, attributes|
-      sects  << section
-      consts << constants
-      attrs  << attributes
-    end
-
-    assert_equal [nil], sects.map { |section| section.title }
-
-    expected_consts = [
-      @c7.constants.select(&:display?).sort
-    ]
-
-    assert_equal expected_consts, consts
-
-    expected_attrs = [
-      @c7.attributes.select(&:display?).sort
-    ]
-
-    assert_equal expected_attrs, attrs
-  end
-
-  def test_each_section_enumerator
-    assert_kind_of Enumerator, @c1.each_section
-  end
-
-  def test_find_attribute_named
-    assert_nil         @c1.find_attribute_named('none')
-    assert_equal 'R',  @c1.find_attribute_named('attr').rw
-    assert_equal 'R',  @c1.find_attribute_named('attr_reader').rw
-    assert_equal 'W',  @c1.find_attribute_named('attr_writer').rw
-    assert_equal 'RW', @c1.find_attribute_named('attr_accessor').rw
-  end
-
-  def test_find_class_method_named
-    assert_nil @c1.find_class_method_named('none')
-
-    m = @c1.find_class_method_named('m')
-    assert_instance_of RDoc::AnyMethod, m
-    assert m.singleton
-  end
-
-  def test_find_constant_named
-    assert_nil             @c1.find_constant_named('NONE')
-    assert_equal ':const', @c1.find_constant_named('CONST').value
-  end
-
-  def test_find_enclosing_module_named
-    assert_nil        @c2_c3.find_enclosing_module_named('NONE')
-    assert_equal @c1, @c2_c3.find_enclosing_module_named('C1')
-    assert_equal @c2, @c2_c3.find_enclosing_module_named('C2')
-  end
-
-  def test_find_instance_method_named
-    assert_nil @c1.find_instance_method_named('none')
-
-    m = @c1.find_instance_method_named('m')
-    assert_instance_of RDoc::AnyMethod, m
-    refute m.singleton
-  end
-
-  def test_find_local_symbol
-    assert_equal true,       @c1.find_local_symbol('m').singleton
-    assert_equal ':const',   @c1.find_local_symbol('CONST').value
-    assert_equal 'R',        @c1.find_local_symbol('attr').rw
-    assert_equal @xref_data, @c1.find_local_symbol(@file_name)
-    assert_equal @c2_c3,     @c2.find_local_symbol('C3')
-  end
-
-  def test_find_method
-    loaded_c2 = Marshal.load Marshal.dump @c2
-    assert_equal @c2_a, loaded_c2.find_method('a', false)
-    assert_equal @c2_b, loaded_c2.find_method('b', false)
-    assert_equal @c2_a, loaded_c2.find_method('a', nil)
-    assert_equal @c2_b, loaded_c2.find_method('b', nil)
-  end
-
-  def test_find_method_named
-    assert_equal true, @c1.find_method_named('m').singleton
-  end
-
-  def test_find_module_named
-    assert_equal @c2_c3, @c2.find_module_named('C3')
-    assert_equal @c2,    @c2.find_module_named('C2')
-    assert_equal @c1,    @c2.find_module_named('C1')
-
-    assert_equal 'C2::C3', @c2.find_module_named('C3').full_name
-  end
-
-  def test_find_symbol
-    c3 = @xref_data.find_module_named('C3')
-    assert_equal c3,     @xref_data.find_symbol('C3')
-    assert_equal c3,     @c2.find_symbol('::C3')
-    assert_equal @c2_c3, @c2.find_symbol('C3')
-  end
-
-  def test_find_symbol_method
-    assert_equal @c1__m, @c1.find_symbol('m')
-    assert_equal @c1_m,  @c1.find_symbol('#m')
-    assert_equal @c1__m, @c1.find_symbol('::m')
-  end
-
-  def test_find_symbol_module
-    assert_nil @m1_m2.find_symbol_module 'N'
-    assert_nil @m1_m2.find_symbol_module 'M2::M1'
-
-    @m1_m2.parent = nil # loaded from legacy ri store
-
-    assert_nil @m1_m2.find_symbol_module 'N'
-    assert_nil @m1_m2.find_symbol_module 'M2::M1'
-  end
-
-  def test_fully_documented_eh
-    context = RDoc::Context.new
-
-    refute context.fully_documented?
-
-    context.comment = 'hi'
-
-    assert context.fully_documented?
-
-    m = @c1_m
-
-    context.add_method m
-
-    refute context.fully_documented?
-
-    m.comment = 'hi'
-
-    assert context.fully_documented?
-
-    c = RDoc::Constant.new 'C', '0', nil
-
-    context.add_constant c
-
-    refute context.fully_documented?
-
-    c.comment = 'hi'
-
-    assert context.fully_documented?
-
-    a = RDoc::Attr.new '', 'a', 'RW', nil
-
-    context.add_attribute a
-
-    refute context.fully_documented?
-
-    a.comment = 'hi'
-
-    assert context.fully_documented?
-  end
-
-  def test_spaceship
-    assert_equal(-1, @c2.<=>(@c3))
-    assert_equal 0,  @c2.<=>(@c2)
-    assert_equal 1,  @c3.<=>(@c2)
-
-    assert_equal 1,  @c2_c3.<=>(@c2)
-    assert_equal(-1, @c2_c3.<=>(@c3))
-
-    assert_nil @c2.<=>(Gem.loaded_specs.values.first)
-  end
-
-  def test_methods_by_type
-    expected = {
-      'instance' => {
-        :private   => [],
-        :protected => [],
-        :public    => [@c1_plus, @c1_m],
-      },
-      'class' => {
-        :private   => [],
-        :protected => [],
-        :public    => [@c1__m],
-      },
-    }
-
-    assert_equal expected, @c1.methods_by_type
-  end
-
-  def test_methods_by_type_section
-    separate = @c1.sections_hash['separate']
-    @c1_m.section = separate
-
-    expected = {
-      'instance' => {
-        :private   => [],
-        :protected => [],
-        :public    => [@c1_m],
-      },
-      'class' => {
-        :private   => [],
-        :protected => [],
-        :public    => [],
-      },
-    }
-
-    assert_equal expected, @c1.methods_by_type(separate)
-  end
-
-  def test_methods_matching
-    methods = []
-
-    @parent.methods_matching 'm' do |m|
-      methods << m
-    end
-
-    assert_equal [@parent_m], methods
-  end
-
-  def test_methods_matching_singleton
-    methods = []
-
-    @parent.methods_matching 'm', true do |m|
-      methods << m
-    end
-
-    assert_equal [@parent__m], methods
-  end
-
-  def test_methods_matching_inherit
-    methods = []
-
-    @child.methods_matching 'm' do |m|
-      methods << m
-    end
-
-    assert_equal [@parent_m], methods
-  end
-
-  def test_remove_invisible_private
-    util_visibilities
-
-    @vis.remove_invisible :private
-
-    assert_equal [@pub, @prot, @priv], @vis.method_list
-    assert_equal [@apub, @aprot, @apriv], @vis.attributes
-    assert_equal [@cpub, @cpriv], @vis.constants
-  end
-
-  def test_remove_invisible_nodoc
-    util_visibilities
-
-    @vis.remove_invisible :nodoc
-
-    assert_equal [@pub, @prot, @priv], @vis.method_list
-    assert_equal [@apub, @aprot, @apriv], @vis.attributes
-    assert_equal [@cpub, @cpriv], @vis.constants
-  end
-
-  def test_remove_invisible_protected
-    util_visibilities
-
-    @vis.remove_invisible :protected
-
-    assert_equal [@pub, @prot], @vis.method_list
-    assert_equal [@apub, @aprot], @vis.attributes
-    assert_equal [@cpub], @vis.constants
-  end
-
-  def test_remove_invisible_public
-    util_visibilities
-
-    @vis.remove_invisible :public
-
-    assert_equal [@pub], @vis.method_list
-    assert_equal [@apub], @vis.attributes
-    assert_equal [@cpub], @vis.constants
-  end
-
-  def test_remove_invisible_public_force
-    util_visibilities
-
-    @priv.force_documentation = true
-    @prot.force_documentation = true
-    @apriv.force_documentation = true
-    @aprot.force_documentation = true
-    @cpriv.force_documentation = true
-
-    @vis.remove_invisible :public
-
-    assert_equal [@pub, @prot, @priv], @vis.method_list
-    assert_equal [@apub, @aprot, @apriv], @vis.attributes
-    assert_equal [@cpub, @cpriv], @vis.constants
-  end
-
-  def test_remove_invisible_in_protected
-    util_visibilities
-
-    methods = [@pub, @prot, @priv]
-
-    @c1.remove_invisible_in methods, :protected
-
-    assert_equal [@pub, @prot], methods
-  end
-
-  def test_remove_invisible_in_protected_force
-    util_visibilities
-
-    @priv.force_documentation = true
-
-    methods = [@pub, @prot, @priv]
-
-    @c1.remove_invisible_in methods, :protected
-
-    assert_equal [@pub, @prot, @priv], methods
-  end
-
-  def test_remove_invisible_in_public
-    util_visibilities
-
-    methods = [@pub, @prot, @priv]
-
-    @c1.remove_invisible_in methods, :public
-
-    assert_equal [@pub], methods
-  end
-
-  def test_remove_invisible_in_public_force
-    util_visibilities
-
-    @prot.force_documentation = true
-    @priv.force_documentation = true
-
-    methods = [@pub, @prot, @priv]
-
-    @c1.remove_invisible_in methods, :public
-
-    assert_equal [@pub, @prot, @priv], methods
-  end
-
-  def test_section_contents
-    default = @context.sections.first
-    @context.add_method RDoc::AnyMethod.new(nil, 'm1')
-
-    b = @context.add_section 'B'
-    m = @context.add_method RDoc::AnyMethod.new(nil, 'm2')
-    m.section = b
-
-    assert_equal [default, b], @context.section_contents
-  end
-
-  def test_section_contents_no_default
-    @context = RDoc::Context.new
-    b = @context.add_section 'B'
-    m = @context.add_method RDoc::AnyMethod.new(nil, 'm')
-    m.section = b
-
-    assert_equal [b], @context.section_contents
-  end
-
-  def test_section_contents_only_default
-    @context = RDoc::Context.new
-
-    @context.add_method RDoc::AnyMethod.new(nil, 'm')
-
-    assert_empty @context.section_contents
-  end
-
-  def test_section_contents_unused
-    @context = RDoc::Context.new
-
-    @context.add_method RDoc::AnyMethod.new(nil, 'm')
-    @context.add_section 'B'
-
-    assert_empty @context.section_contents
-  end
-
-  def test_set_current_section
-    default_section = @context.sections.first
-
-    @context.set_current_section nil, RDoc::Comment.new('', @top_level)
-
-    assert_equal default_section, @context.current_section
-
-    @context.set_current_section 'other', RDoc::Comment.new('', @top_level)
-
-    new_section = @context.sections.find { |section|
-      section != default_section
-    }
-
-    assert_equal new_section, @context.current_section
-  end
-
-  def test_sort_sections
-    c = RDoc::Context.new
-    c.add_section 'C'
-    c.add_section 'A'
-    c.add_section 'B'
-
-    titles = c.sort_sections.map { |section| section.title }
-
-    assert_equal [nil, 'A', 'B', 'C'], titles
-  end
-
-  def test_sort_sections_tomdoc
-    c = RDoc::Context.new
-    c.add_section 'Public'
-    c.add_section 'Internal'
-    c.add_section 'Deprecated'
-
-    titles = c.sort_sections.map { |section| section.title }
-
-    assert_equal [nil, 'Public', 'Internal', 'Deprecated'], titles
-  end
-
-  def test_sort_sections_tomdoc_missing
-    c = RDoc::Context.new
-    c.add_section 'Internal'
-    c.add_section 'Public'
-
-    titles = c.sort_sections.map { |section| section.title }
-
-    assert_equal [nil, 'Public', 'Internal'], titles
-  end
-
-  def test_visibility_def
-    assert_equal :private, @c6.find_method_named('priv1').visibility
-    assert_equal :protected, @c6.find_method_named('prot1').visibility
-    assert_equal :public, @c6.find_method_named('pub1').visibility
-    assert_equal :private, @c6.find_method_named('priv2').visibility
-    assert_equal :protected, @c6.find_method_named('prot2').visibility
-    assert_equal :public, @c6.find_method_named('pub2').visibility
-    assert_equal :private, @c6.find_method_named('priv3').visibility
-    assert_equal :protected, @c6.find_method_named('prot3').visibility
-    assert_equal :public, @c6.find_method_named('pub3').visibility
-    assert_equal :private, @c6.find_method_named('priv4').visibility
-    assert_equal :protected, @c6.find_method_named('prot4').visibility
-    assert_equal :public, @c6.find_method_named('pub4').visibility
-    assert_equal :private, @c6.find_method_named('priv5').visibility
-    assert_equal :protected, @c6.find_method_named('prot5').visibility
-    assert_equal :public, @c6.find_method_named('pub5').visibility
-    assert_equal :private, @c6.find_method_named('priv6').visibility
-    assert_equal :protected, @c6.find_method_named('prot6').visibility
-    assert_equal :public, @c6.find_method_named('pub6').visibility
-    assert_equal :public, @c6.find_method_named('s_pub1').visibility
-    assert_equal :public, @c6.find_method_named('s_pub2').visibility
-    assert_equal :public, @c6.find_method_named('s_pub3').visibility
-    assert_equal :public, @c6.find_method_named('s_pub4').visibility
-    assert_equal :private, @c6.find_method_named('s_priv1').visibility
-    assert_equal :protected, @c6.find_method_named('s_prot1').visibility
-  end
-
-  def util_visibilities
-    @pub  = RDoc::AnyMethod.new nil, 'pub'
-    @prot = RDoc::AnyMethod.new nil, 'prot'
-    @priv = RDoc::AnyMethod.new nil, 'priv'
-
-    @apub  = RDoc::Attr.new nil, 'pub',  'RW', nil
-    @aprot = RDoc::Attr.new nil, 'prot', 'RW', nil
-    @apriv = RDoc::Attr.new nil, 'priv', 'RW', nil
-
-    @cpub  = RDoc::Constant.new 'CONST_PUBLIC', nil, nil
-    @cpriv = RDoc::Constant.new 'CONST_PRIVATE', nil, nil
-
-    @vis = RDoc::NormalClass.new 'Vis'
-    @vis.add_method @pub
-    @vis.add_method @prot
-    @vis.add_method @priv
-
-    @vis.add_attribute @apub
-    @vis.add_attribute @aprot
-    @vis.add_attribute @apriv
-
-    @vis.add_constant @cpub
-    @vis.add_constant @cpriv
-
-    @prot.visibility = :protected
-    @priv.visibility = :private
-
-    @aprot.visibility = :protected
-    @apriv.visibility = :private
-
-    @cpriv.visibility = :private
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc/rdoc_cross_reference_test.rb b/test/mri/rdoc/rdoc/rdoc_cross_reference_test.rb
deleted file mode 100644
index 4f24fd77009..00000000000
--- a/test/mri/rdoc/rdoc/rdoc_cross_reference_test.rb
+++ /dev/null
@@ -1,217 +0,0 @@
-# frozen_string_literal: true
-require_relative 'xref_test_case'
-
-class RDocCrossReferenceTest < XrefTestCase
-  EXAMPLE_METHODS = %w'== === != =~ !~ < > <= >= <=> [] []= << >>
-    -@ +@ ! - + * / % ** !@ ` | & ^ ~ __id__
-  '
-
-  def setup
-    super
-
-    @xref = RDoc::CrossReference.new @c1
-  end
-
-  def assert_ref(expected, name)
-    assert_equal expected, @xref.resolve(name, 'fail')
-  end
-
-  def refute_ref(name)
-    assert_equal name, @xref.resolve(name, name)
-  end
-
-  def test_METHOD_REGEXP_STR
-    re = /\A(?:#{RDoc::CrossReference::METHOD_REGEXP_STR})\z/
-
-    EXAMPLE_METHODS.each do |x|
-      re =~ x
-      assert_equal x, $&
-    end
-  end
-
-  def test_resolve_C2
-    @xref = RDoc::CrossReference.new @c2
-
-    refute_ref '#m'
-
-    assert_ref @c1__m,    'C1::m'
-    assert_ref @c2_c3,    'C2::C3'
-    assert_ref @c2_c3_m,  'C2::C3#m'
-    assert_ref @c2_c3_h1, 'C3::H1'
-    assert_ref @c4,       'C4'
-
-    assert_ref @c3_h2, 'C3::H2'
-    refute_ref 'H1'
-  end
-
-  def test_resolve_C2_C3
-    @xref = RDoc::CrossReference.new @c2_c3
-
-    assert_ref @c2_c3_m, '#m'
-
-    assert_ref @c2_c3, 'C3'
-    assert_ref @c2_c3_m, 'C3#m'
-
-    assert_ref @c2_c3_h1, 'H1'
-    assert_ref @c2_c3_h1, 'C3::H1'
-
-    assert_ref @c4, 'C4'
-
-    assert_ref @c3_h2, 'C3::H2'
-  end
-
-  def test_resolve_C3
-    @xref = RDoc::CrossReference.new @c3
-
-    assert_ref @c3, 'C3'
-
-    refute_ref '#m'
-    refute_ref 'C3#m'
-
-    assert_ref @c3_h1, 'H1'
-
-    assert_ref @c3_h1, 'C3::H1'
-    assert_ref @c3_h2, 'C3::H2'
-
-    assert_ref @c4, 'C4'
-  end
-
-  def test_resolve_C4
-    @xref = RDoc::CrossReference.new @c4
-
-    # C4 ref inside a C4 containing a C4 should resolve to the contained class
-    assert_ref @c4_c4, 'C4'
-  end
-
-  def test_resolve_C4_C4
-    @xref = RDoc::CrossReference.new @c4_c4
-
-    # A C4 reference inside a C4 class contained within a C4 class should
-    # resolve to the inner C4 class.
-    assert_ref @c4_c4, 'C4'
-  end
-
-  def test_resolve_class_and_method_of_the_same_name
-    assert_ref @c10_class, 'C10'
-    assert_ref @c10_method, '#C10'
-    assert_ref @c11_class, 'C11'
-    assert_ref @c11_method, '#C11'
-    assert_ref @c10_c11_class, 'C10::C11'
-    assert_ref @c10_c11_method, 'C10#C11'
-  end
-
-  def test_resolve_class
-    assert_ref @c1, 'C1'
-    refute_ref 'H1'
-
-    assert_ref @c2,       'C2'
-    assert_ref @c2_c3,    'C2::C3'
-    assert_ref @c2_c3_h1, 'C2::C3::H1'
-
-    assert_ref @c3,    '::C3'
-    assert_ref @c3_h1, '::C3::H1'
-
-    assert_ref @c4_c4, 'C4::C4'
-  end
-
-  def test_resolve_file
-    refute_ref 'xref_data.rb'
-  end
-
-  def test_resolve_method
-    assert_ref @c1__m,    'm'
-    assert_ref @c1__m,    '::m'
-    assert_ref @c1_m,     '#m'
-    assert_ref @c1_plus,  '#+'
-
-    assert_ref @c1_m,     'C1#m'
-    assert_ref @c1_plus,  'C1#+'
-    assert_ref @c1__m,    'C1.m'
-    assert_ref @c1__m,    'C1::m'
-
-    assert_ref @c1_m, 'C1#m'
-    assert_ref @c1_m, 'C1#m()'
-    assert_ref @c1_m, 'C1#m(*)'
-
-    assert_ref @c1_plus, 'C1#+'
-    assert_ref @c1_plus, 'C1#+()'
-    assert_ref @c1_plus, 'C1#+(*)'
-
-    assert_ref @c1__m, 'C1.m'
-    assert_ref @c1__m, 'C1.m()'
-    assert_ref @c1__m, 'C1.m(*)'
-
-    assert_ref @c1__m, 'C1::m'
-    assert_ref @c1__m, 'C1::m()'
-    assert_ref @c1__m, 'C1::m(*)'
-
-    assert_ref @c2_c3_m, 'C2::C3#m'
-
-    assert_ref @c2_c3_m, 'C2::C3.m'
-
-    # TODO stop escaping - HTML5 allows anything but space
-    assert_ref @c2_c3_h1_meh, 'C2::C3::H1#m?'
-
-    assert_ref @c2_c3_m, '::C2::C3#m'
-    assert_ref @c2_c3_m, '::C2::C3#m()'
-    assert_ref @c2_c3_m, '::C2::C3#m(*)'
-  end
-
-  def test_resolve_the_same_name_in_instance_and_class_method
-    assert_ref @c9_a_i_foo, 'C9::A#foo'
-    assert_ref @c9_a_c_bar, 'C9::A::bar'
-    assert_ref @c9_b_c_foo, 'C9::B::foo'
-    assert_ref @c9_b_i_bar, 'C9::B#bar'
-    assert_ref @c9_b_c_foo, 'C9::B.foo'
-    assert_ref @c9_a_c_bar, 'C9::B.bar'
-  end
-
-  def test_resolve_page
-    page = @store.add_file 'README.txt', parser: RDoc::Parser::Simple
-
-    assert_ref page, 'README'
-  end
-
-  def assert_resolve_method(x)
-    @c1.methods_hash.clear
-
-    i_op = RDoc::AnyMethod.new nil, x
-    @c1.add_method i_op
-
-    c_op = RDoc::AnyMethod.new nil, x, singleton: true
-    @c1.add_method c_op
-
-    assert_ref i_op, x
-    assert_ref i_op, "##{x}"
-    assert_ref c_op, "::#{x}"
-
-    assert_ref i_op, "C1##{x}"
-    assert_ref c_op, "C1::#{x}"
-  end
-
-  EXAMPLE_METHODS.each do |x|
-    define_method("test_resolve_method:#{x}") do
-      assert_resolve_method(x)
-    end
-  end
-
-  def test_resolve_no_ref
-    assert_equal '', @xref.resolve('', '')
-
-    assert_equal "bogus",     @xref.resolve("bogus",     "bogus")
-    assert_equal "\\bogus",   @xref.resolve("\\bogus",   "\\bogus")
-    assert_equal "\\\\bogus", @xref.resolve("\\\\bogus", "\\\\bogus")
-
-    assert_equal "\\#n",    @xref.resolve("\\#n",    "fail")
-    assert_equal "\\#n()",  @xref.resolve("\\#n()",  "fail")
-    assert_equal "\\#n(*)", @xref.resolve("\\#n(*)", "fail")
-
-    assert_equal "C1",   @xref.resolve("\\C1",   "fail")
-    assert_equal "::C3", @xref.resolve("\\::C3", "fail")
-
-    assert_equal "succeed",      @xref.resolve("::C3::H1#n",    "succeed")
-    assert_equal "succeed",      @xref.resolve("::C3::H1#n(*)", "succeed")
-    assert_equal "\\::C3::H1#n", @xref.resolve("\\::C3::H1#n",  "fail")
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc/rdoc_encoding_test.rb b/test/mri/rdoc/rdoc/rdoc_encoding_test.rb
deleted file mode 100644
index fdb42afd7fd..00000000000
--- a/test/mri/rdoc/rdoc/rdoc_encoding_test.rb
+++ /dev/null
@@ -1,184 +0,0 @@
-# coding: US-ASCII
-# frozen_string_literal: true
-
-require_relative 'helper'
-
-class RDocEncodingTest < RDoc::TestCase
-
-  def setup
-    super
-
-    @tempfile = Tempfile.new 'test_rdoc_encoding'
-  end
-
-  def teardown
-    @tempfile.close!
-
-    super
-  end
-
-  def test_class_read_file
-    @tempfile.write "hi everybody"
-    @tempfile.flush
-
-    assert_equal "hi everybody", RDoc::Encoding.read_file(@tempfile.path, nil)
-  end
-
-  def test_class_read_file_encoding
-    expected = "# coding: utf-8\nhi everybody"
-
-    @tempfile.write expected
-    @tempfile.flush
-
-    contents = RDoc::Encoding.read_file @tempfile.path, Encoding::UTF_8
-    assert_equal "# coding: utf-8\nhi everybody", contents
-    assert_equal Encoding::UTF_8, contents.encoding
-  end
-
-  def test_class_read_file_encoding_convert
-    content = ""
-    content = RDoc::Encoding.change_encoding content, 'ISO-8859-1'
-    content << "# coding: ISO-8859-1\nhi \xE9verybody"
-
-    @tempfile.write content
-    @tempfile.flush
-
-    contents = RDoc::Encoding.read_file @tempfile.path, Encoding::UTF_8
-    assert_equal Encoding::UTF_8, contents.encoding
-    assert_equal "# coding: ISO-8859-1\nhi \u00e9verybody", contents.sub("\r", '')
-  end
-
-  def test_class_read_file_encoding_fail
-    @tempfile.write "# coding: utf-8\n\317\200" # pi
-    @tempfile.flush
-
-    contents = :junk
-
-    _, err = verbose_capture_output do
-      contents = RDoc::Encoding.read_file @tempfile.path, Encoding::US_ASCII
-    end
-
-    assert_nil contents
-
-    assert_match %r%^unable to convert%, err
-  end
-
-  def test_class_read_file_encoding_fancy
-    expected = "# -*- coding: utf-8; fill-column: 74 -*-\nhi everybody"
-    expected = RDoc::Encoding.change_encoding expected, Encoding::UTF_8
-
-    @tempfile.write expected
-    @tempfile.flush
-
-    contents = RDoc::Encoding.read_file @tempfile.path, Encoding::UTF_8
-    assert_equal "# -*- coding: utf-8; fill-column: 74 -*-\nhi everybody", contents
-    assert_equal Encoding::UTF_8, contents.encoding
-  end
-
-  def test_class_read_file_encoding_force_transcode
-    @tempfile.write "# coding: utf-8\n\317\200" # pi
-    @tempfile.flush
-
-    contents = RDoc::Encoding.read_file @tempfile.path, Encoding::US_ASCII, true
-
-    assert_equal "# coding: utf-8\n?", contents
-    assert_equal Encoding::US_ASCII, contents.encoding
-  end
-
-  def test_class_read_file_encoding_guess
-    path = File.expand_path '../test.ja.txt', __FILE__
-    content = RDoc::Encoding.read_file path, Encoding::UTF_8
-
-    assert_equal Encoding::UTF_8, content.encoding
-  end
-
-  def test_class_read_file_encoding_invalid
-    @tempfile.write "# coding: ascii\nM\xE4r"
-    @tempfile.flush
-
-    contents = :junk
-    _, err = verbose_capture_output do
-      contents = RDoc::Encoding.read_file @tempfile.path, Encoding::UTF_8
-    end
-
-    assert_equal "unable to convert \"\\xE4\" on US-ASCII for #{@tempfile.path}, skipping\n", err
-
-    assert_nil contents
-  end
-
-  def test_class_read_file_encoding_with_signature
-    @tempfile.write "\xEF\xBB\xBFhi everybody"
-    @tempfile.flush
-
-    bug3360 = '[ruby-dev:41452]'
-    content = RDoc::Encoding.read_file @tempfile.path, Encoding::UTF_8
-    assert_equal Encoding::UTF_8, content.encoding, bug3360
-    assert_equal "hi everybody", content, bug3360
-  end
-
-  def test_class_read_file_encoding_iso_2022_jp
-    input = "# coding: ISO-2022-JP\n:\e$B%3%^%s%I\e(B:"
-
-    @tempfile.write input
-    @tempfile.flush
-
-    contents = RDoc::Encoding.read_file @tempfile.path, Encoding::UTF_8
-
-    expected = "# coding: ISO-2022-JP\n:\xe3\x82\xb3\xe3\x83\x9e\xe3\x83\xb3\xe3\x83\x89:"
-    expected = RDoc::Encoding.change_encoding expected, Encoding::UTF_8
-
-    assert_equal expected, contents
-    assert_equal Encoding::UTF_8, contents.encoding
-  end
-
-  def test_class_detect_encoding
-    s = "# coding: UTF-8\n"
-    encoding = RDoc::Encoding.detect_encoding s
-
-    # sanity check for 1.8
-
-    assert_equal Encoding::UTF_8, encoding
-
-    s = "#!/bin/ruby\n# coding: UTF-8\n"
-    encoding = RDoc::Encoding.detect_encoding s
-
-    assert_equal Encoding::UTF_8, encoding
-
-    s = "<?xml version='1.0' encoding='UTF-8'?>\n"
-    encoding = RDoc::Encoding.detect_encoding s
-
-    assert_equal Encoding::UTF_8, encoding
-
-    s = "<?xml version='1.0' encoding=\"UTF-8\"?>\n"
-    encoding = RDoc::Encoding.detect_encoding s
-
-    assert_equal Encoding::UTF_8, encoding
-  end
-
-  def test_class_set_encoding_bad
-    s = ""
-    encoding = RDoc::Encoding.detect_encoding s
-
-    assert_nil encoding
-
-    s = "# vim:set fileencoding=utf-8:\n"
-    encoding = RDoc::Encoding.detect_encoding s
-
-    assert_nil encoding
-
-    s = "# vim:set fileencoding=utf-8:\n"
-    encoding = RDoc::Encoding.detect_encoding s
-
-    assert_nil encoding
-
-    assert_raise ArgumentError do
-      s = RDoc::Encoding.detect_encoding "# -*- encoding: undecided -*-\n"
-    end
-  end
-
-  def test_sanity
-    assert_equal Encoding::US_ASCII, ''.encoding,
-                 'If this file is not ASCII tests may incorrectly pass'
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc/rdoc_extend_test.rb b/test/mri/rdoc/rdoc/rdoc_extend_test.rb
deleted file mode 100644
index cf13eba0c51..00000000000
--- a/test/mri/rdoc/rdoc/rdoc_extend_test.rb
+++ /dev/null
@@ -1,94 +0,0 @@
-# frozen_string_literal: true
-require_relative 'xref_test_case'
-
-class RDocExtendTest < XrefTestCase
-
-  def setup
-    super
-
-    @ext = RDoc::Extend.new 'M1', 'comment'
-    @ext.parent = @m1
-    @ext.store = @store
-  end
-
-  def test_module
-    assert_equal @m1, @ext.module
-    assert_equal 'Unknown', RDoc::Extend.new('Unknown', 'comment').module
-  end
-
-  def test_module_extended
-    m1 = @xref_data.add_module RDoc::NormalModule, 'Mod1'
-                  m1.add_module RDoc::NormalModule, 'Mod3'
-    m1_m2       = m1.add_module RDoc::NormalModule, 'Mod2'
-    m1_m2_m3    = m1_m2.add_module RDoc::NormalModule, 'Mod3'
-                  m1_m2_m3.add_module RDoc::NormalModule, 'Mod4'
-                  m1_m2.add_module RDoc::NormalModule, 'Mod4'
-    m1_m2_k0    = m1_m2.add_class RDoc::NormalClass, 'Klass0'
-    m1_m2_k0_m4 = m1_m2_k0.add_module RDoc::NormalModule, 'Mod4'
-                  m1_m2_k0_m4.add_module RDoc::NormalModule, 'Mod6'
-                  m1_m2_k0.add_module RDoc::NormalModule, 'Mod5'
-
-    e0_m4 = RDoc::Extend.new 'Mod4', nil
-    e0_m5 = RDoc::Extend.new 'Mod5', nil
-    e0_m6 = RDoc::Extend.new 'Mod6', nil
-    e0_m1 = RDoc::Extend.new 'Mod1', nil
-    e0_m2 = RDoc::Extend.new 'Mod2', nil
-    e0_m3 = RDoc::Extend.new 'Mod3', nil
-
-    m1_m2_k0.add_extend e0_m4
-    m1_m2_k0.add_extend e0_m5
-    m1_m2_k0.add_extend e0_m6
-    m1_m2_k0.add_extend e0_m1
-    m1_m2_k0.add_extend e0_m2
-    m1_m2_k0.add_extend e0_m3
-
-    assert_equal [e0_m4, e0_m5, e0_m6, e0_m1, e0_m2, e0_m3], m1_m2_k0.extends
-    assert_equal [@object, 'BasicObject'], m1_m2_k0.ancestors
-
-    m1_k1 = m1.add_class RDoc::NormalClass, 'Klass1'
-
-    e1_m1 = RDoc::Extend.new 'Mod1', nil
-    e1_m2 = RDoc::Extend.new 'Mod2', nil
-    e1_m3 = RDoc::Extend.new 'Mod3', nil
-    e1_m4 = RDoc::Extend.new 'Mod4', nil
-    e1_k0_m4 = RDoc::Extend.new 'Klass0::Mod4', nil
-
-    m1_k1.add_extend e1_m1
-    m1_k1.add_extend e1_m2
-    m1_k1.add_extend e1_m3
-    m1_k1.add_extend e1_m4
-    m1_k1.add_extend e1_k0_m4
-
-    assert_equal [e1_m1, e1_m2, e1_m3, e1_m4, e1_k0_m4], m1_k1.extends
-    assert_equal [@object, 'BasicObject'], m1_k1.ancestors
-
-    m1_k2 = m1.add_class RDoc::NormalClass, 'Klass2'
-
-    e2_m1 = RDoc::Extend.new 'Mod1', nil
-    e2_m2 = RDoc::Extend.new 'Mod2', nil
-    e2_m3 = RDoc::Extend.new 'Mod3', nil
-    e2_k0_m4 = RDoc::Extend.new 'Klass0::Mod4', nil
-
-    m1_k2.add_extend e2_m1
-    m1_k2.add_extend e2_m3
-    m1_k2.add_extend e2_m2
-    m1_k2.add_extend e2_k0_m4
-
-    assert_equal [e2_m1, e2_m3, e2_m2, e2_k0_m4], m1_k2.extends
-    assert_equal [@object, 'BasicObject'], m1_k2.ancestors
-
-    m1_k3 = m1.add_class RDoc::NormalClass, 'Klass3'
-
-    e3_m1 = RDoc::Extend.new 'Mod1', nil
-    e3_m2 = RDoc::Extend.new 'Mod2', nil
-    e3_m4 = RDoc::Extend.new 'Mod4', nil
-
-    m1_k3.add_extend e3_m1
-    m1_k3.add_extend e3_m2
-    m1_k3.add_extend e3_m4
-
-    assert_equal [e3_m1, e3_m2, e3_m4], m1_k3.extends
-    assert_equal [@object, 'BasicObject'], m1_k3.ancestors
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc/rdoc_generator_darkfish_test.rb b/test/mri/rdoc/rdoc/rdoc_generator_darkfish_test.rb
deleted file mode 100644
index 67715951ecb..00000000000
--- a/test/mri/rdoc/rdoc/rdoc_generator_darkfish_test.rb
+++ /dev/null
@@ -1,593 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocGeneratorDarkfishTest < RDoc::TestCase
-
-  def setup
-    super
-
-    @lib_dir = "#{@pwd}/lib"
-    $LOAD_PATH.unshift @lib_dir # ensure we load from this RDoc
-
-    @options = RDoc::Options.new
-    @options.option_parser = OptionParser.new
-
-    @tmpdir = File.join Dir.tmpdir, "test_rdoc_generator_darkfish_#{$$}"
-    FileUtils.mkdir_p @tmpdir
-    Dir.chdir @tmpdir
-    @options.op_dir = @tmpdir
-    @options.generator = RDoc::Generator::Darkfish
-
-    $LOAD_PATH.each do |path|
-      darkfish_dir = File.join path, 'rdoc/generator/template/darkfish/'
-      next unless File.directory? darkfish_dir
-      @options.template_dir = darkfish_dir
-      break
-    end
-
-    @rdoc.options = @options
-
-    @g = @options.generator.new @store, @options
-    @rdoc.generator = @g
-
-    @top_level = @store.add_file 'file.rb'
-    @top_level.parser = RDoc::Parser::Ruby
-    @klass = @top_level.add_class RDoc::NormalClass, 'Klass'
-
-    @alias_constant = RDoc::Constant.new 'A', nil, ''
-    @alias_constant.record_location @top_level
-
-    @top_level.add_constant @alias_constant
-
-    @klass.add_module_alias @klass, @klass.name, @alias_constant, @top_level
-
-    @meth = RDoc::AnyMethod.new nil, 'method'
-    @meth_bang = RDoc::AnyMethod.new nil, 'method!'
-    @meth_with_html_tag_yield = RDoc::AnyMethod.new nil, 'method_with_html_tag_yield'
-    @meth_with_html_tag_yield.block_params = '%<<script>alert("atui")</script>>, yield_arg'
-    @attr = RDoc::Attr.new nil, 'attr', 'RW', ''
-
-    @klass.add_method @meth
-    @klass.add_method @meth_bang
-    @klass.add_method @meth_with_html_tag_yield
-    @klass.add_attribute @attr
-
-    @ignored = @top_level.add_class RDoc::NormalClass, 'Ignored'
-    @ignored.ignore
-
-    @store.complete :private
-
-    @object      = @store.find_class_or_module 'Object'
-    @klass_alias = @store.find_class_or_module 'Klass::A'
-  end
-
-  def teardown
-    super
-
-    $LOAD_PATH.shift
-    Dir.chdir @pwd
-    FileUtils.rm_rf @tmpdir
-  end
-
-  def test_generate
-    top_level = @store.add_file 'file.rb'
-    top_level.add_class @klass.class, @klass.name
-    @klass.add_class RDoc::NormalClass, 'Inner'
-    @klass.add_comment <<~RDOC, top_level
-    = Heading 1
-    Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod
-    == Heading 1.1
-    tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam,
-    === Heading 1.1.1
-    quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo
-    ==== Heading 1.1.1.1
-    consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse
-    == Heading 1.2
-    cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat
-    == Heading 1.3
-    non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
-    === Heading 1.3.1
-    etc etc...
-    RDOC
-
-    @g.generate
-
-    assert_file 'index.html'
-    assert_file 'Object.html'
-    assert_file 'Klass.html'
-    assert_file 'Klass/Inner.html'
-    assert_file 'table_of_contents.html'
-    assert_file 'js/search_index.js'
-
-    assert_hard_link 'css/rdoc.css'
-    assert_hard_link 'css/fonts.css'
-
-    assert_hard_link 'fonts/SourceCodePro-Bold.ttf'
-    assert_hard_link 'fonts/SourceCodePro-Regular.ttf'
-
-    encoding = Regexp.escape Encoding::UTF_8.name
-
-    assert_match %r%<meta charset="#{encoding}">%, File.binread('index.html')
-    assert_match %r%<meta charset="#{encoding}">%, File.binread('Object.html')
-
-    refute_match(/Ignored/, File.binread('index.html'))
-    summary = File.binread('index.html')[%r[<summary.*Klass\.html.*</summary>.*</details>]m]
-    assert_match(%r[Klass/Inner\.html".*>Inner<], summary)
-
-    klass = File.binread('Klass.html')
-    klassnav = klass[%r[<div class="nav-section">.*]m]
-    assert_match(
-      %r[<li>\s*<details open>\s*<summary>\s*<a href=\S+>Heading 1</a>\s*</summary>\s*<ul]m,
-      klassnav
-    )
-    assert_match(
-      %r[<li>\s*<a href=\S+>Heading 1.1.1.1</a>\s*</ul>\s*</details>\s*</li>]m,
-      klassnav
-    )
-
-    assert_match(/<h1 id="class-Klass-label-Heading\+1">Heading 1(?!\.)/,
-                 klass[%r[<section class=\"description\">.*</section>]m])
-    toc = File.binread('table_of_contents.html')
-    assert_match(
-      %r[<a\s+href="Klass\.html#class-Klass-label-Heading\+1">Heading 1</a>]m,
-      toc[%r[<h2\s+id=\"classes\">.*(?=<h2\b)]m][%r[<a\s+href="Klass\.html".*(?=</li\b)]m]
-    )
-  end
-
-  def test_generate_index_with_main_page
-    top_level = @store.add_file 'file.rb'
-    top_level.comment = <<~RDOC
-    = Heading 1
-    Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod
-    == Heading 1.1
-    tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam,
-    === Heading 1.1.1
-    quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo
-    ==== Heading 1.1.1.1
-    consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse
-    == Heading 1.2
-    cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat
-    == Heading 1.3
-    non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
-    === Heading 1.3.1
-    etc etc...
-    RDOC
-
-    @options.main_page = 'file.rb'
-    @options.title = 'My awesome Ruby project'
-
-    @g.generate
-
-    assert_file 'index.html'
-    assert_file 'table_of_contents.html'
-    assert_file 'js/search_index.js'
-
-    assert_hard_link 'css/rdoc.css'
-    assert_hard_link 'css/fonts.css'
-
-    assert_hard_link 'fonts/SourceCodePro-Bold.ttf'
-    assert_hard_link 'fonts/SourceCodePro-Regular.ttf'
-
-    index_html = File.binread('index.html')
-
-    assert_include index_html, "<h3>Table of Contents</h3>"
-    assert_include index_html, '<h1 id="label-Heading+1">Heading 1'
-    # When there's a main page, the default description should not be shown
-    assert_not_include index_html, 'This is the API documentation for My awesome Ruby project.'
-  end
-
-  def test_generate_index_without_main_page
-    top_level = @store.add_file 'file.rb'
-    top_level.comment = <<~RDOC
-    = Heading 1
-    Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod
-    == Heading 1.1
-    tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam,
-    === Heading 1.1.1
-    quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo
-    ==== Heading 1.1.1.1
-    consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse
-    == Heading 1.2
-    cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat
-    == Heading 1.3
-    non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
-    === Heading 1.3.1
-    etc etc...
-    RDOC
-
-    @options.title = 'My awesome Ruby project'
-
-    @g.generate
-
-    assert_file 'index.html'
-    assert_file 'table_of_contents.html'
-    assert_file 'js/search_index.js'
-
-    assert_hard_link 'css/rdoc.css'
-    assert_hard_link 'css/fonts.css'
-
-    assert_hard_link 'fonts/SourceCodePro-Bold.ttf'
-    assert_hard_link 'fonts/SourceCodePro-Regular.ttf'
-
-    index_html = File.binread('index.html')
-
-    # If there is no main page, the index page should not have a table of contents
-    assert_not_include index_html, "<h3>Table of Contents</h3>"
-    assert_include index_html, 'This is the API documentation for My awesome Ruby project.'
-  end
-
-  def test_generate_page
-    @store.add_file 'outer.rdoc', parser: RDoc::Parser::Simple
-    @store.add_file 'outer/inner.rdoc', parser: RDoc::Parser::Simple
-    @g.generate
-    assert_file 'outer_rdoc.html'
-    assert_file 'outer/inner_rdoc.html'
-    index = File.binread('index.html')
-    re = %r[<summary><a href="\./outer_rdoc\.html">outer</a></summary>.*?</details>]m
-    assert_match(re, index)
-    summary = index[re]
-    assert_match %r[<a href="\./outer/inner_rdoc.html">inner</a>], summary
-    re = %r[<details open><summary><a href="\./outer_rdoc\.html">outer</a></summary>.*?</details>]m
-    assert_match(re, File.binread('outer_rdoc.html'))
-    re = %r[<details open><summary><a href="\.\./outer_rdoc\.html">outer</a></summary>.*?</details>]m
-    assert_match(re, File.binread('outer/inner_rdoc.html'))
-  end
-
-  def test_generate_dry_run
-    @g.dry_run = true
-    top_level = @store.add_file 'file.rb'
-    top_level.add_class @klass.class, @klass.name
-
-    @g.generate
-
-    refute_file 'index.html'
-    refute_file 'Object.html'
-  end
-
-  def test_generate_static
-    FileUtils.mkdir_p 'dir/images'
-    FileUtils.touch 'dir/images/image.png'
-    FileUtils.mkdir_p 'file'
-    FileUtils.touch 'file/file.txt'
-
-    @options.static_path = [
-      File.expand_path('dir'),
-      File.expand_path('file/file.txt'),
-    ]
-
-    @g.generate
-
-    assert_file 'images/image.png'
-    assert_file 'file.txt'
-  end
-
-  def test_generate_static_dry_run
-    FileUtils.mkdir 'static'
-    FileUtils.touch 'static/image.png'
-
-    @options.static_path = [File.expand_path('static')]
-    @g.dry_run = true
-
-    @g.generate
-
-    refute_file 'image.png'
-  end
-
-  def test_install_rdoc_static_file
-    src = Pathname File.expand_path(__FILE__, @pwd)
-    dst = File.join @tmpdir, File.basename(src)
-    options = {}
-
-    @g.install_rdoc_static_file src, dst, options
-
-    assert_file dst
-    assert_hard_link dst
-  end
-
-  def test_install_rdoc_static_file_missing
-    src = Pathname(__FILE__) + 'nonexistent'
-    dst = File.join @tmpdir, File.basename(src)
-    options = {}
-
-    @g.install_rdoc_static_file src, dst, options
-
-    refute_file dst
-  end
-
-  def test_setup
-    @g.setup
-
-    assert_equal [@klass_alias, @ignored, @klass, @object],
-                 @g.classes.sort_by { |klass| klass.full_name }
-    assert_equal [@top_level],                           @g.files
-    assert_equal [@meth, @meth, @meth_bang, @meth_bang, @meth_with_html_tag_yield, @meth_with_html_tag_yield], @g.methods
-    assert_equal [@klass_alias, @klass, @object], @g.modsort
-  end
-
-  def test_template_for
-    classpage = Pathname.new @options.template_dir + 'class.rhtml'
-
-    template = @g.send(:template_for, classpage, true, RDoc::ERBIO)
-    assert_kind_of RDoc::ERBIO, template
-
-    assert_same template, @g.send(:template_for, classpage)
-  end
-
-  def test_template_for_dry_run
-    classpage = Pathname.new @options.template_dir + 'class.rhtml'
-
-    template = @g.send(:template_for, classpage, true, ERB)
-    assert_kind_of ERB, template
-
-    assert_same template, @g.send(:template_for, classpage)
-  end
-
-  def test_template_for_partial
-    partial = Pathname.new @options.template_dir + '_sidebar_classes.rhtml'
-
-    template = @g.send(:template_for, partial, false, RDoc::ERBPartial)
-
-    assert_kind_of RDoc::ERBPartial, template
-
-    assert_same template, @g.send(:template_for, partial)
-  end
-
-  def test_generated_method_with_html_tag_yield
-    top_level = @store.add_file 'file.rb'
-    top_level.add_class @klass.class, @klass.name
-
-    @g.generate
-
-    path = File.join @tmpdir, 'A.html'
-
-    f = open(path)
-    internal_file = f.read
-    method_name_index = internal_file.index('<span class="method-name">method_with_html_tag_yield</span>')
-    last_of_method_name_index = method_name_index + internal_file[method_name_index..-1].index('<div class="method-description">') - 1
-    method_name = internal_file[method_name_index..last_of_method_name_index]
-    f.close
-
-    assert_includes method_name, '{ |%<<script>alert("atui")</script>>, yield_arg| ... }'
-  end
-
-  def test_generated_filename_with_html_tag
-    filename = '"><em>should be escaped'
-    begin # in @tmpdir
-      File.write(filename, '')
-    rescue SystemCallError
-      # ", <, > chars are prohibited as filename
-      return
-    else
-      File.unlink(filename)
-    end
-    @store.add_file filename
-    doc = @store.all_files.last
-    doc.parser = RDoc::Parser::Simple
-
-    @g.generate
-
-    Dir.glob("*.html", base: @tmpdir) do |html|
-      File.binread(File.join(@tmpdir, html)).scan(/.*should be escaped.*/) do |line|
-        assert_not_include line, "<em>", html
-      end
-    end
-  end
-
-  def test_template_stylesheets
-    css = Tempfile.create(%W'hoge .css', Dir.mktmpdir('tmp', '.'))
-    File.write(css, '')
-    css.close
-    base = File.basename(css)
-    refute_file(base)
-
-    @options.template_stylesheets << css
-
-    @g.generate
-
-    assert_file base
-    assert_include File.binread('index.html'), %Q[href="./#{base}"]
-  end
-
-  def test_html_lang
-    @g.generate
-
-    content = File.binread("index.html")
-    assert_include(content, '<html lang="en">')
-  end
-
-  def test_html_lang_from_locale
-    @options.locale = RDoc::I18n::Locale.new 'ja'
-    @g.generate
-
-    content = File.binread("index.html")
-    assert_include(content, '<html lang="ja">')
-  end
-
-  def test_title
-    title = "RDoc Test".freeze
-    @options.title = title
-    @g.generate
-
-    assert_main_title(File.binread('index.html'), title)
-  end
-
-  def test_title_escape
-    title = %[<script>alert("RDoc")</script>].freeze
-    @options.title = title
-    @g.generate
-
-    assert_main_title(File.binread('index.html'), title)
-  end
-
-  def test_meta_tags_for_index
-    @options.title = "My awesome Ruby project"
-    @g.generate
-
-    content = File.binread("index.html")
-
-    assert_include(content, '<meta name="keywords" content="ruby,documentation,My awesome Ruby project">')
-    assert_include(content, '<meta name="description" content="Documentation for My awesome Ruby project">')
-  end
-
-  def test_meta_tags_for_classes
-    top_level = @store.add_file("file.rb")
-    top_level.add_class(@klass.class, @klass.name)
-    inner = @klass.add_class(RDoc::NormalClass, "Inner")
-    inner.add_comment("This is a normal class. It is fully documented.", top_level)
-
-    @g.generate
-
-    content = File.binread("Klass/Inner.html")
-    assert_include(content, '<meta name="keywords" content="ruby,class,Klass::Inner">')
-    assert_include(
-      content,
-      '<meta name="description" content="class Klass::Inner: This is a normal class. It is fully documented.">',
-    )
-  end
-
-  def test_meta_tags_for_rdoc_files
-    top_level = @store.add_file("CONTRIBUTING.rdoc", parser: RDoc::Parser::Simple)
-    top_level.comment = <<~RDOC
-      = Contributing
-
-      Here are the instructions for contributing. Begin by installing Ruby.
-    RDOC
-
-    @g.generate
-
-    content = File.binread("CONTRIBUTING_rdoc.html")
-    assert_include(content, '<meta name="keywords" content="ruby,documentation,CONTRIBUTING">')
-    assert_include(
-      content,
-      "<meta name=\"description\" content=\"CONTRIBUTING: Contributing Here are the instructions for contributing." \
-      " Begin by installing Ruby.\">",
-    )
-  end
-
-  def test_meta_tags_for_markdown_files_paragraph
-    top_level = @store.add_file("README.md", parser: RDoc::Parser::Simple)
-    top_level.comment = <<~MARKDOWN
-      # Distributed Ruby: dRuby
-
-      dRuby is a distributed object system for Ruby.  It allows an object.
-    MARKDOWN
-
-    @g.generate
-
-    content = File.binread("README_md.html")
-    assert_include(
-      content,
-      "<meta name=\"description\" content=\"" \
-      "README: dRuby " \
-      "dRuby is a distributed object system for Ruby. " \
-      "It allows an object."
-    )
-  end
-
-  def test_meta_tags_for_markdown_files
-    top_level = @store.add_file("MyPage.md", parser: RDoc::Parser::Markdown)
-    top_level.comment = <<~MARKDOWN
-      # MyPage
-
-      This is a comment
-    MARKDOWN
-
-    @g.generate
-
-    content = File.binread("MyPage_md.html")
-    assert_include(content, '<meta name="keywords" content="ruby,documentation,MyPage">')
-    assert_include(
-      content,
-      '<meta name="description" content="MyPage: # MyPage This is a comment">',
-    )
-  end
-
-  def test_meta_tags_for_raw_pages
-    top_level = @store.add_file("MyPage", parser: RDoc::Parser::Simple)
-    comment = RDoc::Comment.new('this is a comment')
-    comment.document = RDoc::Markup::Document.new(RDoc::Markup::Paragraph.new('this is a comment'))
-    top_level.comment = comment
-
-    @g.generate
-
-    content = File.binread("MyPage.html")
-    assert_include(content, '<meta name="keywords" content="ruby,documentation,MyPage">')
-    assert_include(content, '<meta name="description" content="MyPage: this is a comment">')
-  end
-
-  def test_meta_tags_for_empty_document
-    top_level = @store.add_file("MyPage", parser: RDoc::Parser::Simple)
-    top_level.comment = RDoc::Comment.from_document(RDoc::Markup::Document.new)
-
-    @g.generate
-
-    content = File.binread("MyPage.html")
-    assert_include(content, '<meta name="keywords" content="ruby,documentation,MyPage">')
-    assert_include(
-      content,
-      '<meta name="description" content="MyPage: ">',
-    )
-  end
-
-  def test_canonical_url_for_index
-    @store.options.canonical_root = @options.canonical_root = "https://docs.ruby-lang.org/en/master/"
-    @g.generate
-
-    content = File.binread("index.html")
-
-    assert_include(content, '<link rel="canonical" href="https://docs.ruby-lang.org/en/master/">')
-  end
-
-  def test_canonical_url_for_classes
-    top_level = @store.add_file("file.rb")
-    top_level.add_class(@klass.class, @klass.name)
-    inner = @klass.add_class(RDoc::NormalClass, "Inner")
-
-    @store.options.canonical_root = @options.canonical_root = "https://docs.ruby-lang.org/en/master/"
-    @g.generate
-
-    content = File.binread("Klass/Inner.html")
-
-    assert_include(content, '<link rel="canonical" href="https://docs.ruby-lang.org/en/master/Klass/Inner.html">')
-  end
-
-  def test_canonical_url_for_rdoc_files
-    top_level = @store.add_file("CONTRIBUTING.rdoc", parser: RDoc::Parser::Simple)
-
-    @store.options.canonical_root = @options.canonical_root = "https://docs.ruby-lang.org/en/master/"
-    @g.generate
-
-    content = File.binread("CONTRIBUTING_rdoc.html")
-
-    assert_include(content, '<link rel="canonical" href="https://docs.ruby-lang.org/en/master/CONTRIBUTING_rdoc.html">')
-  end
-
-  ##
-  # Asserts that +filename+ has a link count greater than 1 if hard links to
-  # @tmpdir are supported.
-
-  def assert_hard_link(filename)
-    assert_file filename
-
-    src = @g.template_dir + '_head.rhtml'
-    dst = File.join @tmpdir, 'hardlinktest'
-
-    begin
-      FileUtils.ln src, dst
-      nlink = File.stat(dst).nlink if File.identical? src, dst
-      FileUtils.rm dst
-      return if nlink == 1
-    rescue SystemCallError
-      return
-    end
-
-    assert_operator File.stat(filename).nlink, :>, 1,
-                    "#{filename} is not hard-linked"
-  end
-
-  def assert_main_title(content, title)
-    title = CGI.escapeHTML(title)
-    assert_equal(title, content[%r[<title>(.*?)<\/title>]im, 1])
-    assert_include(content[%r[<main\s[^<>]*+>\s*(.*?)</main>]im, 1], title)
-  end
-end
diff --git a/test/mri/rdoc/rdoc/rdoc_generator_json_index_test.rb b/test/mri/rdoc/rdoc/rdoc_generator_json_index_test.rb
deleted file mode 100644
index aa7a2da0b16..00000000000
--- a/test/mri/rdoc/rdoc/rdoc_generator_json_index_test.rb
+++ /dev/null
@@ -1,363 +0,0 @@
-# coding: US-ASCII
-# frozen_string_literal: true
-
-require_relative 'helper'
-
-class RDocGeneratorJsonIndexTest < RDoc::TestCase
-
-  def setup
-    super
-
-    @tmpdir = Dir.mktmpdir "test_rdoc_generator_darkfish_#{$$}_"
-    FileUtils.mkdir_p @tmpdir
-
-    @options = RDoc::Options.new
-    @options.files = []
-    # JsonIndex is used in conjunction with another generator
-    @options.setup_generator 'darkfish'
-    @options.template_dir = ''
-    @options.op_dir = @tmpdir
-    @options.option_parser = OptionParser.new
-    @options.finish
-
-    @darkfish = RDoc::Generator::Darkfish.new @store, @options
-    @g = RDoc::Generator::JsonIndex.new @darkfish, @options
-
-    @rdoc.options = @options
-    @rdoc.generator = @g
-
-    @top_level = @store.add_file 'file.rb'
-    @top_level.parser = RDoc::Parser::Ruby
-
-    @klass = @top_level.add_class RDoc::NormalClass, 'C'
-
-    @meth = @klass.add_method RDoc::AnyMethod.new(nil, 'meth')
-    @meth.record_location @top_level
-
-    @nest_klass = @klass.add_class RDoc::NormalClass, 'D'
-    @nest_klass.record_location @top_level
-
-    @nest_meth = @nest_klass.add_method RDoc::AnyMethod.new(nil, 'meth')
-
-    @ignored = @top_level.add_class RDoc::NormalClass, 'Ignored'
-    @ignored.ignore
-
-    @page = @store.add_file 'page.rdoc'
-    @page.parser = RDoc::Parser::Simple
-
-    @top_levels = [@top_level, @page].sort
-    @klasses    = [@klass, @nest_klass, @ignored]
-
-    Dir.chdir @tmpdir
-  end
-
-  def teardown
-    super
-
-    Dir.chdir @pwd
-    FileUtils.rm_rf @tmpdir
-  end
-
-  def test_build_index
-    index = @g.build_index
-
-    expected = {
-      :index => {
-        :searchIndex     => %w[c d meth() meth() page],
-        :longSearchIndex => %w[c c::d c#meth() c::d#meth()],
-        :info            => [
-          @klass.search_record[2..-1],
-          @nest_klass.search_record[2..-1],
-          @meth.search_record[2..-1],
-          @nest_meth.search_record[2..-1],
-          @page.search_record[2..-1],
-        ],
-      },
-    }
-
-    expected[:index][:longSearchIndex] << ''
-
-    assert_equal expected, index
-  end
-
-  def test_generate
-    @g.generate
-
-    assert_file 'js/searcher.js'
-    assert_file 'js/navigation.js'
-    assert_file 'js/search_index.js'
-
-    srcdir = File.expand_path('lib/rdoc', @pwd)
-    if !File.directory? srcdir
-      # for Ruby core repository
-      srcdir = File.expand_path("../../../lib/rdoc", __FILE__)
-    end
-
-    orig_file = Pathname(File.join srcdir, 'generator/template/json_index/js/navigation.js')
-    generated_file = Pathname(File.join @tmpdir, 'js/navigation.js')
-
-    # The following assertion for the generated file's modified time randomly
-    # fails in a ppc64le environment.
-    # https://github.com/ruby/rdoc/issues/1048
-    if orig_file.mtime.inspect != generated_file.mtime.inspect &&
-      RUBY_PLATFORM =~ /powerpc64le/
-      pend <<~EOC
-        Unstable test in ppc64le.
-        <#{orig_file.mtime.inspect}> expected but was
-        <#{generated_file.mtime.inspect}>.
-      EOC
-    end
-
-    # This is dirty hack on JRuby
-    assert_equal orig_file.mtime.inspect, generated_file.mtime.inspect,
-      '.js files should be the same timestamp of original'
-
-    json = File.read 'js/search_index.js'
-
-    json =~ /\Avar search_data = /
-
-    assignment = $&
-    index = $'
-
-    refute_empty assignment
-
-    index = JSON.parse index
-
-    info = [
-      @klass.search_record[2..-1],
-      @nest_klass.search_record[2..-1],
-      @meth.search_record[2..-1],
-      @nest_meth.search_record[2..-1],
-      @page.search_record[2..-1],
-    ]
-
-    expected = {
-      'index' => {
-        'searchIndex' => [
-          'c',
-          'd',
-          'meth()',
-          'meth()',
-          'page',
-        ],
-        'longSearchIndex' => [
-          'c',
-          'c::d',
-          'c#meth()',
-          'c::d#meth()',
-          '',
-        ],
-        'info' => info,
-      },
-    }
-
-    assert_equal expected, index
-  end
-
-  def test_generate_search_index_with_reproducible_builds
-    backup_epoch = ENV['SOURCE_DATE_EPOCH']
-    ruby_birthday = Time.parse 'Wed, 24 Feb 1993 21:00:00 +0900'
-    ENV['SOURCE_DATE_EPOCH'] = ruby_birthday.to_i.to_s
-
-    @g.generate
-
-    assert_file 'js/search_index.js'
-    generated_search_index = Pathname(File.join @tmpdir, 'js/search_index.js')
-    assert_equal ruby_birthday, generated_search_index.mtime
-
-    ENV['SOURCE_DATE_EPOCH'] = backup_epoch
-  end
-
-  def test_generate_gzipped
-    begin
-      require 'zlib'
-    rescue LoadError
-      omit "no zlib"
-    end
-    @g.generate
-    @g.generate_gzipped
-
-    assert_file 'js/searcher.js'
-    assert_file 'js/searcher.js.gz'
-    assert_file 'js/navigation.js'
-    assert_file 'js/navigation.js.gz'
-    assert_file 'js/search_index.js'
-    assert_file 'js/search_index.js.gz'
-
-    json = File.open('js/search_index.js.gz', 'rb') {|gzip|
-      Zlib::GzipReader.new(gzip).read
-    }
-
-    json =~ /\Avar search_data = /
-
-    assignment = $&
-    index = $'
-
-    refute_empty assignment
-
-    index = JSON.parse index
-
-    info = [
-      @klass.search_record[2..-1],
-      @nest_klass.search_record[2..-1],
-      @meth.search_record[2..-1],
-      @nest_meth.search_record[2..-1],
-      @page.search_record[2..-1],
-    ]
-
-    expected = {
-      'index' => {
-        'searchIndex' => [
-          'c',
-          'd',
-          'meth()',
-          'meth()',
-          'page',
-        ],
-        'longSearchIndex' => [
-          'c',
-          'c::d',
-          'c#meth()',
-          'c::d#meth()',
-          '',
-        ],
-        'info' => info,
-      },
-    }
-
-    assert_equal expected, index
-  end
-
-  def test_generate_utf_8
-    # JRuby fails this test with:
-    #   Encoding::UndefinedConversionError: "\xC2" from ASCII-8BIT to UTF-8
-    #     org/jruby/RubyIO.java:1639:in `write'
-    #     org/jruby/RubyIO.java:1612:in `write'
-    #     json/ext/GeneratorState.java:232:in `_generate'
-    #     json/ext/GeneratorState.java:137:in `generate'
-    #     /Users/runner/work/rdoc/rdoc/vendor/bundle/jruby/3.1.0/gems/json-2.9.0-java/lib/json/common.rb:824:in `dump'
-    #     /Users/runner/work/rdoc/rdoc/lib/rdoc/generator/json_index.rb:148:in `block in generate'
-    omit if RUBY_PLATFORM =~ /java/
-
-    text = "5\xB0"
-    text = RDoc::Encoding.change_encoding text, Encoding::ISO_8859_1
-    @klass.add_comment comment(text), @top_level
-
-    @g.generate
-
-    json = File.read 'js/search_index.js'
-    json.force_encoding Encoding::UTF_8
-
-    json =~ /\Avar search_data = /
-
-    index = $'
-
-    index = JSON.parse index
-
-    klass_record = @klass.search_record[2..-1]
-    klass_record[-1] = "<p>5\xc2\xb0\n"
-    klass_record[-1] = RDoc::Encoding.change_encoding klass_record[-1], Encoding::UTF_8
-
-    info = [
-      klass_record,
-      @nest_klass.search_record[2..-1],
-      @meth.search_record[2..-1],
-      @nest_meth.search_record[2..-1],
-      @page.search_record[2..-1],
-    ]
-
-    expected = {
-      'index' => {
-        'searchIndex' => [
-          'c',
-          'd',
-          'meth()',
-          'meth()',
-          'page',
-        ],
-        'longSearchIndex' => [
-          'c',
-          'c::d',
-          'c#meth()',
-          'c::d#meth()',
-          '',
-        ],
-        'info' => info,
-      },
-    }
-
-    assert_equal expected, index
-  end
-
-  def test_index_classes
-    @g.reset @top_levels, @klasses
-
-    @g.index_classes
-
-    expected = {
-      :searchIndex     => %w[c d],
-      :longSearchIndex => %w[c c::d],
-      :info            => [
-        @klass.search_record[2..-1],
-        @nest_klass.search_record[2..-1],
-      ],
-    }
-
-    assert_equal expected, @g.index
-  end
-
-  def test_index_classes_nodoc
-    @klass.document_self      = false
-    @nest_klass.document_self = false
-    @meth.document_self       = false
-    @nest_meth.document_self  = false
-
-    @g.reset @top_levels, @klasses
-
-    @g.index_classes
-
-    expected = {
-      :searchIndex     => [],
-      :longSearchIndex => [],
-      :info            => [],
-    }
-
-    assert_equal expected, @g.index
-  end
-
-  def test_index_methods
-    @g.reset @top_levels, @klasses
-
-    @g.index_methods
-
-    expected = {
-      :searchIndex     => %w[meth() meth()],
-      :longSearchIndex => %w[c#meth() c::d#meth()],
-      :info            => [
-        @meth.search_record[2..-1],
-        @nest_meth.search_record[2..-1],
-      ],
-    }
-
-    assert_equal expected, @g.index
-  end
-
-  def test_index_pages
-    @g.reset @top_levels, @klasses
-
-    @g.index_pages
-
-    expected = {
-      :searchIndex     => %w[page],
-      :longSearchIndex => [''],
-      :info            => [@page.search_record[2..-1]],
-    }
-
-    assert_equal expected, @g.index
-  end
-
-  def test_search_string
-    assert_equal 'cd', @g.search_string('C d')
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc/rdoc_generator_markup_test.rb b/test/mri/rdoc/rdoc/rdoc_generator_markup_test.rb
deleted file mode 100644
index cd77e67e794..00000000000
--- a/test/mri/rdoc/rdoc/rdoc_generator_markup_test.rb
+++ /dev/null
@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocGeneratorMarkupTest < RDoc::TestCase
-
-  include RDoc::Text
-  include RDoc::Generator::Markup
-
-  attr_reader :store
-
-  def setup
-    super
-
-    @options = RDoc::Options.new
-    @rdoc.options = @options
-
-    @parent = self
-    @path = '/index.html'
-    @symbols = {}
-  end
-
-  def test_aref_to
-    assert_equal 'Foo/Bar.html', aref_to('Foo/Bar.html')
-  end
-
-  def test_as_href
-    assert_equal '../index.html', as_href('Foo/Bar.html')
-  end
-
-  def test_cvs_url
-    assert_equal 'http://example/this_page',
-                 cvs_url('http://example/', 'this_page')
-
-    assert_equal 'http://example/?page=this_page&foo=bar',
-                 cvs_url('http://example/?page=%s&foo=bar', 'this_page')
-  end
-
-  def test_description
-    @comment = '= Hello'
-
-    links = '<span><a href="#label-Hello">¶</a> ' +
-            '<a href="#top">↑</a></span>'
-
-    assert_equal "\n<h1 id=\"label-Hello\">Hello#{links}</h1>\n", description
-  end
-
-  def test_formatter
-    assert_kind_of RDoc::Markup::ToHtmlCrossref, formatter
-    refute formatter.show_hash
-    assert_same self, formatter.context
-  end
-
-  attr_reader :path
-
-  def find_symbol(name)
-    @symbols[name]
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc/rdoc_generator_pot_po_entry_test.rb b/test/mri/rdoc/rdoc/rdoc_generator_pot_po_entry_test.rb
deleted file mode 100644
index d058ff3f405..00000000000
--- a/test/mri/rdoc/rdoc/rdoc_generator_pot_po_entry_test.rb
+++ /dev/null
@@ -1,140 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocGeneratorPOTPOEntryTest < RDoc::TestCase
-
-  def test_msgid_normal
-    assert_equal <<-'ENTRY', entry("Hello", {}).to_s
-msgid "Hello"
-msgstr ""
-    ENTRY
-  end
-
-  def test_msgid_multiple_lines
-    assert_equal <<-'ENTRY', entry("Hello\nWorld", {}).to_s
-msgid ""
-"Hello\n"
-"World"
-msgstr ""
-    ENTRY
-  end
-
-  def test_msgid_tab
-    assert_equal <<-'ENTRY', entry("Hello\tWorld", {}).to_s
-msgid "Hello\tWorld"
-msgstr ""
-    ENTRY
-  end
-
-  def test_msgid_back_slash
-    assert_equal <<-'ENTRY', entry("Hello \\ World", {}).to_s
-msgid "Hello \\ World"
-msgstr ""
-    ENTRY
-  end
-
-  def test_msgid_double_quote
-    assert_equal <<-'ENTRY', entry("Hello \"World\"!", {}).to_s
-msgid "Hello \"World\"!"
-msgstr ""
-    ENTRY
-  end
-
-  def test_translator_comment_normal
-    options = {:translator_comment => "Greeting"}
-    assert_equal <<-'ENTRY', entry("Hello", options).to_s
-# Greeting
-msgid "Hello"
-msgstr ""
-    ENTRY
-  end
-
-  def test_translator_comment_multiple_lines
-    options = {:translator_comment => "Greeting\nfor morning"}
-    assert_equal <<-'ENTRY', entry("Hello", options).to_s
-# Greeting
-# for morning
-msgid "Hello"
-msgstr ""
-    ENTRY
-  end
-
-  def test_extracted_comment_normal
-    options = {:extracted_comment => "Object"}
-    assert_equal <<-'ENTRY', entry("Hello", options).to_s
-#. Object
-msgid "Hello"
-msgstr ""
-    ENTRY
-  end
-
-  def test_extracted_comment_multiple_lines
-    options = {:extracted_comment => "Object\nMorning#greeting"}
-    assert_equal <<-'ENTRY', entry("Hello", options).to_s
-#. Object
-#. Morning#greeting
-msgid "Hello"
-msgstr ""
-    ENTRY
-  end
-
-  def test_references_normal
-    options = {:references => [["lib/rdoc.rb", 29]]}
-    assert_equal <<-'ENTRY', entry("Hello", options).to_s
-#: lib/rdoc.rb:29
-msgid "Hello"
-msgstr ""
-    ENTRY
-  end
-
-  def test_references_multiple
-    options = {:references => [["lib/rdoc.rb", 29], ["lib/rdoc/i18n.rb", 9]]}
-    assert_equal <<-'ENTRY', entry("Hello", options).to_s
-#: lib/rdoc.rb:29
-#: lib/rdoc/i18n.rb:9
-msgid "Hello"
-msgstr ""
-    ENTRY
-  end
-
-  def test_flags_normal
-    options = {:flags => ["fuzzy"]}
-    assert_equal <<-'ENTRY', entry("Hello", options).to_s
-#, fuzzy
-msgid "Hello"
-msgstr ""
-    ENTRY
-  end
-
-  def test_flags_multiple
-    options = {:flags => ["fuzzy", "ruby-format"]}
-    assert_equal <<-'ENTRY', entry("Hello", options).to_s
-#, fuzzy,ruby-format
-msgid "Hello"
-msgstr ""
-    ENTRY
-  end
-
-  def test_full
-    options = {
-      :translator_comment => "Greeting",
-      :extracted_comment  => "Morning#greeting",
-      :references         => [["lib/rdoc.rb", 29]],
-      :flags              => ["fuzzy"],
-    }
-    assert_equal <<-'ENTRY', entry("Hello", options).to_s
-# Greeting
-#. Morning#greeting
-#: lib/rdoc.rb:29
-#, fuzzy
-msgid "Hello"
-msgstr ""
-    ENTRY
-  end
-
-  private
-  def entry(msgid, options)
-    RDoc::Generator::POT::POEntry.new(msgid, options)
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc/rdoc_generator_pot_po_test.rb b/test/mri/rdoc/rdoc/rdoc_generator_pot_po_test.rb
deleted file mode 100644
index 83b4a5f1c33..00000000000
--- a/test/mri/rdoc/rdoc/rdoc_generator_pot_po_test.rb
+++ /dev/null
@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocGeneratorPOTPOTest < RDoc::TestCase
-
-  def setup
-    super
-    @po = RDoc::Generator::POT::PO.new
-  end
-
-  def test_empty
-    assert_equal header, @po.to_s
-  end
-
-  def test_have_entry
-    @po.add(entry("Hello", {}))
-    assert_equal <<-PO, @po.to_s
-#{header}
-msgid "Hello"
-msgstr ""
-    PO
-  end
-
-  private
-
-  def entry(msgid, options)
-    RDoc::Generator::POT::POEntry.new(msgid, options)
-  end
-
-  def header
-    <<-'HEADER'
-# SOME DESCRIPTIVE TITLE.
-# Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER
-# This file is distributed under the same license as the PACKAGE package.
-# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
-#, fuzzy
-msgid ""
-msgstr ""
-"Project-Id-Version: PACKAGE VERSEION\n"
-"Report-Msgid-Bugs-To:\n"
-"PO-Revision-Date: YEAR-MO_DA HO:MI+ZONE\n"
-"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
-"Language-Team: LANGUAGE <LL@li.org>\n"
-"Language:\n"
-"MIME-Version: 1.0\n"
-"Content-Type: text/plain; charset=CHARSET\n"
-"Content-Transfer-Encoding: 8bit\n"
-"Plural-Forms: nplurals=INTEGER; plural=EXPRESSION;\n"
-    HEADER
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc/rdoc_generator_pot_test.rb b/test/mri/rdoc/rdoc/rdoc_generator_pot_test.rb
deleted file mode 100644
index 736f9765e50..00000000000
--- a/test/mri/rdoc/rdoc/rdoc_generator_pot_test.rb
+++ /dev/null
@@ -1,92 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocGeneratorPOTTest < RDoc::TestCase
-
-  def setup
-    super
-
-    @options = RDoc::Options.new
-    @tmpdir = File.join Dir.tmpdir, "test_rdoc_generator_pot_#{$$}"
-    FileUtils.mkdir_p @tmpdir
-
-    @generator = RDoc::Generator::POT.new @store, @options
-
-    @top_level = @store.add_file 'file.rb'
-    @klass = @top_level.add_class RDoc::NormalClass, 'Object'
-    @klass.add_comment 'This is a class', @top_level
-    @klass.add_section 'This is a section', comment('This is a section comment')
-
-    @const = RDoc::Constant.new "CONSTANT", "29", "This is a constant"
-
-    @meth = RDoc::AnyMethod.new nil, 'method'
-    @meth.record_location @top_level
-    @meth.comment = 'This is a method'
-
-    @attr = RDoc::Attr.new nil, 'attr', 'RW', ''
-    @attr.record_location @top_level
-    @attr.comment = 'This is an attribute'
-
-    @klass.add_constant @const
-    @klass.add_method @meth
-    @klass.add_attribute @attr
-
-    Dir.chdir @tmpdir
-  end
-
-  def teardown
-    super
-
-    Dir.chdir @pwd
-    FileUtils.rm_rf @tmpdir
-  end
-
-  def test_generate
-    @generator.generate
-
-    assert_equal <<-POT, File.read(File.join(@tmpdir, 'rdoc.pot'))
-# SOME DESCRIPTIVE TITLE.
-# Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER
-# This file is distributed under the same license as the PACKAGE package.
-# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
-#, fuzzy
-msgid ""
-msgstr ""
-"Project-Id-Version: PACKAGE VERSEION\\n"
-"Report-Msgid-Bugs-To:\\n"
-"PO-Revision-Date: YEAR-MO_DA HO:MI+ZONE\\n"
-"Last-Translator: FULL NAME <EMAIL@ADDRESS>\\n"
-"Language-Team: LANGUAGE <LL@li.org>\\n"
-"Language:\\n"
-"MIME-Version: 1.0\\n"
-"Content-Type: text/plain; charset=CHARSET\\n"
-"Content-Transfer-Encoding: 8bit\\n"
-"Plural-Forms: nplurals=INTEGER; plural=EXPRESSION;\\n"
-
-#. Object
-msgid "This is a class"
-msgstr ""
-
-#. Object::CONSTANT
-msgid "This is a constant"
-msgstr ""
-
-#. Object#method
-msgid "This is a method"
-msgstr ""
-
-#. Object: section title
-msgid "This is a section"
-msgstr ""
-
-#. Object: This is a section
-msgid "This is a section comment"
-msgstr ""
-
-#. Object#attr
-msgid "This is an attribute"
-msgstr ""
-    POT
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc/rdoc_generator_ri_test.rb b/test/mri/rdoc/rdoc/rdoc_generator_ri_test.rb
deleted file mode 100644
index 9109d220676..00000000000
--- a/test/mri/rdoc/rdoc/rdoc_generator_ri_test.rb
+++ /dev/null
@@ -1,76 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocGeneratorRITest < RDoc::TestCase
-
-  def setup
-    super
-
-    @options = RDoc::Options.new
-    @options.encoding = Encoding::UTF_8
-    @store.encoding = Encoding::UTF_8
-
-    @tmpdir = File.join Dir.tmpdir, "test_rdoc_generator_ri_#{$$}"
-    FileUtils.mkdir_p @tmpdir
-
-    @g = RDoc::Generator::RI.new @store, @options
-
-    @top_level = @store.add_file 'file.rb'
-    @klass = @top_level.add_class RDoc::NormalClass, 'Object'
-
-    @meth = RDoc::AnyMethod.new nil, 'method'
-    @meth.record_location @top_level
-
-    @meth_bang = RDoc::AnyMethod.new nil, 'method!'
-    @meth_bang.record_location @top_level
-
-    @attr = RDoc::Attr.new nil, 'attr', 'RW', ''
-    @attr.record_location @top_level
-
-    @klass.add_method @meth
-    @klass.add_method @meth_bang
-    @klass.add_attribute @attr
-
-    Dir.chdir @tmpdir
-  end
-
-  def teardown
-    super
-
-    Dir.chdir @pwd
-    FileUtils.rm_rf @tmpdir
-  end
-
-  def test_generate
-    @g.generate
-
-    assert_file File.join(@tmpdir, 'cache.ri')
-
-    assert_file File.join(@tmpdir, 'Object', 'cdesc-Object.ri')
-
-    assert_file File.join(@tmpdir, 'Object', 'attr-i.ri')
-    assert_file File.join(@tmpdir, 'Object', 'method-i.ri')
-    assert_file File.join(@tmpdir, 'Object', 'method%21-i.ri')
-
-    store = RDoc::RI::Store.new(@options, path: @tmpdir)
-    store.load_cache
-
-    encoding = Encoding::UTF_8
-
-    assert_equal encoding, store.encoding
-  end
-
-  def test_generate_dry_run
-    @store.dry_run = true
-    @g = RDoc::Generator::RI.new @store, @options
-
-    top_level = @store.add_file 'file.rb'
-    top_level.add_class @klass.class, @klass.name
-
-    @g.generate
-
-    refute_file File.join(@tmpdir, 'cache.ri')
-    refute_file File.join(@tmpdir, 'Object')
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc/rdoc_i18n_locale_test.rb b/test/mri/rdoc/rdoc/rdoc_i18n_locale_test.rb
deleted file mode 100644
index cfbc7c5bb2a..00000000000
--- a/test/mri/rdoc/rdoc/rdoc_i18n_locale_test.rb
+++ /dev/null
@@ -1,74 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocI18nLocaleTest < RDoc::TestCase
-
-  def setup
-    super
-    @locale = locale('fr')
-
-    @tmpdir = File.join Dir.tmpdir, "test_rdoc_i18n_locale_#{$$}"
-    FileUtils.mkdir_p @tmpdir
-
-    @locale_dir = @tmpdir
-  end
-
-  def teardown
-    FileUtils.rm_rf @tmpdir
-    super
-  end
-
-  def test_name
-    assert_equal 'fr', locale('fr').name
-  end
-
-  def test_load_nonexistent_po
-    locale = File.join(@locale_dir, 'nonexsitent-locale')
-    refute_file locale
-    refute @locale.load(locale)
-  end
-
-  def test_load_existent_po
-    begin
-      require 'gettext/po_parser'
-    rescue LoadError
-      omit 'gettext gem is not found'
-    end
-
-    fr_locale_dir = File.join @locale_dir, 'fr'
-    FileUtils.mkdir_p fr_locale_dir
-    File.open File.join(fr_locale_dir, 'rdoc.po'), 'w' do |po|
-      po.puts <<-PO
-msgid ""
-msgstr ""
-"Language: fr\n"
-"MIME-Version: 1.0\n"
-"Content-Type: text/plain; charset=UTF-8\n"
-"Content-Transfer-Encoding: 8bit\n"
-
-msgid "Hello"
-msgstr "Bonjour"
-      PO
-    end
-
-    assert @locale.load(@locale_dir)
-    assert_equal 'Bonjour', @locale.translate('Hello')
-  end
-
-  def test_translate_existent_message
-    messages = @locale.instance_variable_get(:@messages)
-    messages['Hello'] = 'Bonjour'
-    assert_equal 'Bonjour', @locale.translate('Hello')
-  end
-
-  def test_translate_nonexistent_message
-    assert_equal 'Hello', @locale.translate('Hello')
-  end
-
-  private
-
-  def locale(name)
-    RDoc::I18n::Locale.new(name)
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc/rdoc_i18n_text_test.rb b/test/mri/rdoc/rdoc/rdoc_i18n_text_test.rb
deleted file mode 100644
index 888479d20da..00000000000
--- a/test/mri/rdoc/rdoc/rdoc_i18n_text_test.rb
+++ /dev/null
@@ -1,124 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocI18nTextTest < RDoc::TestCase
-
-  def test_multiple_paragraphs
-    paragraph1 = <<-PARAGRAPH.strip
-RDoc produces HTML and command-line documentation for Ruby projects.  RDoc
-includes the +rdoc+ and +ri+ tools for generating and displaying documentation
-from the command-line.
-    PARAGRAPH
-
-    paragraph2 = <<-PARAGRAPH.strip
-This command generates documentation for all the Ruby and C source
-files in and below the current directory.  These will be stored in a
-documentation tree starting in the subdirectory +doc+.
-    PARAGRAPH
-
-    raw = <<-RAW
-#{paragraph1}
-
-#{paragraph2}
-    RAW
-
-    expected = [
-      {
-        :type      => :paragraph,
-        :paragraph => paragraph1,
-        :line_no   => 1,
-      },
-      {
-        :type      => :paragraph,
-        :paragraph => paragraph2,
-        :line_no   => 5,
-      },
-    ]
-    assert_equal expected, extract_messages(raw)
-  end
-
-  def test_translate_multiple_paragraphs
-    paragraph1 = <<-PARAGRAPH.strip
-Paragraph 1.
-    PARAGRAPH
-    paragraph2 = <<-PARAGRAPH.strip
-Paragraph 2.
-    PARAGRAPH
-
-    raw = <<-RAW
-#{paragraph1}
-
-#{paragraph2}
-    RAW
-
-    expected = <<-TRANSLATED
-Paragraphe 1.
-
-Paragraphe 2.
-    TRANSLATED
-    assert_equal expected, translate(raw)
-  end
-
-  def test_translate_not_translated_message
-    nonexistent_paragraph = <<-PARAGRAPH.strip
-Nonexistent paragraph.
-    PARAGRAPH
-
-    raw = <<-RAW
-#{nonexistent_paragraph}
-    RAW
-
-    expected = <<-TRANSLATED
-#{nonexistent_paragraph}
-    TRANSLATED
-    assert_equal expected, translate(raw)
-  end
-
-  def test_translate_keep_empty_lines
-    raw = <<-RAW
-Paragraph 1.
-
-
-
-
-Paragraph 2.
-    RAW
-
-    expected = <<-TRANSLATED
-Paragraphe 1.
-
-
-
-
-Paragraphe 2.
-    TRANSLATED
-    assert_equal expected, translate(raw)
-  end
-
-  private
-
-  def extract_messages(raw)
-    text = RDoc::I18n::Text.new(raw)
-    messages = []
-    text.extract_messages do |message|
-      messages << message
-    end
-    messages
-  end
-
-  def locale
-    locale = RDoc::I18n::Locale.new('fr')
-    messages = locale.instance_variable_get(:@messages)
-    messages['markdown'] = 'markdown (markdown in fr)'
-    messages['Hello'] = 'Bonjour (Hello in fr)'
-    messages['Paragraph 1.'] = 'Paragraphe 1.'
-    messages['Paragraph 2.'] = 'Paragraphe 2.'
-    locale
-  end
-
-  def translate(raw)
-    text = RDoc::I18n::Text.new(raw)
-    text.translate(locale)
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc/rdoc_include_test.rb b/test/mri/rdoc/rdoc/rdoc_include_test.rb
deleted file mode 100644
index 6b78d2a749c..00000000000
--- a/test/mri/rdoc/rdoc/rdoc_include_test.rb
+++ /dev/null
@@ -1,109 +0,0 @@
-# frozen_string_literal: true
-require_relative 'xref_test_case'
-
-class RDocIncludeTest < XrefTestCase
-
-  def setup
-    super
-
-    @inc = RDoc::Include.new 'M1', 'comment'
-    @inc.parent = @m1
-    @inc.record_location @top_level
-    @inc.store = @store
-  end
-
-  def test_module
-    assert_equal @m1, @inc.module
-    assert_equal 'Unknown', RDoc::Include.new('Unknown', 'comment').module
-  end
-
-  def test_module_extended
-    m1 = @xref_data.add_module RDoc::NormalModule, 'Mod1'
-    m1_m3 = m1.add_module RDoc::NormalModule, 'Mod3'
-    m1_m2 = m1.add_module RDoc::NormalModule, 'Mod2'
-    m1_m2_m3 = m1_m2.add_module RDoc::NormalModule, 'Mod3'
-    m1_m2_m3_m4 = m1_m2_m3.add_module RDoc::NormalModule, 'Mod4'
-    m1_m2_m4 = m1_m2.add_module RDoc::NormalModule, 'Mod4'
-    m1_m2_k0 = m1_m2.add_class RDoc::NormalClass, 'Klass0'
-    m1_m2_k0_m4 = m1_m2_k0.add_module RDoc::NormalModule, 'Mod4'
-    #m1_m2_k0_m4_m5 = m1_m2_k0_m4.add_module RDoc::NormalModule, 'Mod5'
-    m1_m2_k0_m4_m6 = m1_m2_k0_m4.add_module RDoc::NormalModule, 'Mod6'
-    m1_m2_k0_m5 = m1_m2_k0.add_module RDoc::NormalModule, 'Mod5'
-
-    i0_m4 = RDoc::Include.new 'Mod4', nil
-    i0_m5 = RDoc::Include.new 'Mod5', nil
-    i0_m6 = RDoc::Include.new 'Mod6', nil
-    i0_m1 = RDoc::Include.new 'Mod1', nil
-    i0_m2 = RDoc::Include.new 'Mod2', nil
-    i0_m3 = RDoc::Include.new 'Mod3', nil
-
-    m1_m2_k0.add_include i0_m4
-    m1_m2_k0.add_include i0_m5
-    m1_m2_k0.add_include i0_m6
-    m1_m2_k0.add_include i0_m1
-    m1_m2_k0.add_include i0_m2
-    m1_m2_k0.add_include i0_m3
-
-    assert_equal [i0_m4, i0_m5, i0_m6, i0_m1, i0_m2, i0_m3], m1_m2_k0.includes
-    assert_equal [m1_m2_m3, m1_m2, m1, m1_m2_k0_m4_m6, m1_m2_k0_m5,
-                  m1_m2_k0_m4, @object, 'BasicObject'], m1_m2_k0.ancestors
-
-    m1_k1 = m1.add_class RDoc::NormalClass, 'Klass1'
-
-    i1_m1 = RDoc::Include.new 'Mod1', nil
-    i1_m2 = RDoc::Include.new 'Mod2', nil
-    i1_m3 = RDoc::Include.new 'Mod3', nil
-    i1_m4 = RDoc::Include.new 'Mod4', nil
-    i1_k0_m4 = RDoc::Include.new 'Klass0::Mod4', nil
-
-    m1_k1.add_include i1_m1
-    m1_k1.add_include i1_m2
-    m1_k1.add_include i1_m3
-    m1_k1.add_include i1_m4
-    m1_k1.add_include i1_k0_m4
-
-    assert_equal [i1_m1, i1_m2, i1_m3, i1_m4, i1_k0_m4], m1_k1.includes
-    assert_equal [m1_m2_k0_m4, m1_m2_m3_m4, m1_m2_m3, m1_m2, m1, @object,
-                  'BasicObject'], m1_k1.ancestors
-
-    m1_k2 = m1.add_class RDoc::NormalClass, 'Klass2'
-
-    i2_m1 = RDoc::Include.new 'Mod1', nil
-    i2_m2 = RDoc::Include.new 'Mod2', nil
-    i2_m3 = RDoc::Include.new 'Mod3', nil
-    i2_k0_m4 = RDoc::Include.new 'Klass0::Mod4', nil
-
-    m1_k2.add_include i2_m1
-    m1_k2.add_include i2_m3
-    m1_k2.add_include i2_m2
-    m1_k2.add_include i2_k0_m4
-
-    assert_equal [i2_m1, i2_m3, i2_m2, i2_k0_m4], m1_k2.includes
-    assert_equal [m1_m2_k0_m4, m1_m2, m1_m3, m1, @object, 'BasicObject'],
-                 m1_k2.ancestors
-
-    m1_k3 = m1.add_class RDoc::NormalClass, 'Klass3'
-
-    i3_m1 = RDoc::Include.new 'Mod1', nil
-    i3_m2 = RDoc::Include.new 'Mod2', nil
-    i3_m4 = RDoc::Include.new 'Mod4', nil
-
-    m1_k3.add_include i3_m1
-    m1_k3.add_include i3_m2
-    m1_k3.add_include i3_m4
-
-    assert_equal [i3_m1, i3_m2, i3_m4], m1_k3.includes
-    assert_equal [m1_m2_m4, m1_m2, m1, @object, 'BasicObject'], m1_k3.ancestors
-  end
-
-  def test_store_equals
-    incl = RDoc::Include.new 'M', nil
-    incl.record_location RDoc::TopLevel.new @top_level.name
-
-    incl.store = @store
-
-    assert_same @top_level, incl.file
-    assert_same @store,     incl.file.store
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc/rdoc_markdown_test.rb b/test/mri/rdoc/rdoc/rdoc_markdown_test.rb
deleted file mode 100644
index 2764f94becd..00000000000
--- a/test/mri/rdoc/rdoc/rdoc_markdown_test.rb
+++ /dev/null
@@ -1,1140 +0,0 @@
-# coding: UTF-8
-# frozen_string_literal: true
-
-require_relative 'helper'
-require_relative '../../lib/rdoc/markup/block_quote'
-require_relative '../../lib/rdoc/markdown'
-
-class RDocMarkdownTest < RDoc::TestCase
-
-  def setup
-    super
-
-    @RM = RDoc::Markup
-
-    @parser = RDoc::Markdown.new
-
-    @to_html = RDoc::Markup::ToHtml.new(RDoc::Options.new, nil)
-  end
-
-  def test_class_parse
-    doc = RDoc::Markdown.parse "hello\n\nworld"
-
-    expected = doc(para("hello"), para("world"))
-
-    assert_equal expected, doc
-  end
-
-  def test_emphasis
-    assert_equal '_word_',             @parser.emphasis('word')
-    assert_equal '<em>two words</em>', @parser.emphasis('two words')
-    assert_equal '<em>*bold*</em>',    @parser.emphasis('*bold*')
-  end
-
-  def test_parse_auto_link_email
-    doc = parse "Autolink: <nobody-0+_./!%~$@example>"
-
-    expected = doc(para("Autolink: mailto:nobody-0+_./!%~$@example"))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_auto_link_url
-    doc = parse "Autolink: <http://example>"
-
-    expected = doc(para("Autolink: http://example"))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_block_quote
-    doc = parse <<-BLOCK_QUOTE
-> this is
-> a block quote
-    BLOCK_QUOTE
-
-    expected =
-      doc(
-        block(
-          para("this is\na block quote")))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_block_quote_continue
-    doc = parse <<-BLOCK_QUOTE
-> this is
-a block quote
-    BLOCK_QUOTE
-
-    expected =
-      doc(
-        block(
-          para("this is\na block quote")))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_block_quote_list
-    doc = parse <<-BLOCK_QUOTE
-> text
->
-> * one
-> * two
-    BLOCK_QUOTE
-
-    expected =
-      doc(
-        block(
-          para("text"),
-          list(:BULLET,
-            item(nil, para("one")),
-            item(nil, para("two")))))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_block_quote_newline
-    doc = parse <<-BLOCK_QUOTE
-> this is
-a block quote
-
-    BLOCK_QUOTE
-
-    expected =
-      doc(
-        block(
-          para("this is\na block quote")))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_block_quote_separate
-    doc = parse <<-BLOCK_QUOTE
-> this is
-a block quote
-
-> that continues
-    BLOCK_QUOTE
-
-    expected =
-      doc(
-        block(
-          para("this is\na block quote"),
-          para("that continues")))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_char_entity
-    doc = parse 'π &nn;'
-
-    expected = doc(para('π &nn;'))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_code
-    doc = parse "Code: `text`"
-    expected = doc(para("Code: <code>text</code>"))
-    assert_equal expected, doc
-
-    doc = parse "Code: ` text `"
-    expected = doc(para("Code: <code>text</code>"))
-    assert_equal expected, doc
-
-    doc = parse "Code: ``text`s``"
-    expected = doc(para("Code: <code>text`s</code>"))
-    assert_equal expected, doc
-
-    doc = parse "Code: `` text`s ``"
-    expected = doc(para("Code: <code>text`s</code>"))
-    assert_equal expected, doc
-
-    doc = parse "Code: ```text`s```"
-    expected = doc(para("Code: <code>text`s</code>"))
-    assert_equal expected, doc
-
-    doc = parse "Code: ``` text`s ```"
-    expected = doc(para("Code: <code>text`s</code>"))
-    assert_equal expected, doc
-  end
-
-  def test_parse_code_github
-    doc = <<-MD
-Example:
-
-```
-code goes here
-```
-    MD
-
-    expected =
-      doc(
-        para("Example:"),
-        verb("code goes here\n"))
-
-    assert_equal expected, parse(doc)
-    assert_equal expected, parse(doc.sub(/^\n/, ''))
-
-    @parser.github = false
-
-    expected =
-      doc(para("Example:"),
-          para("<code>\n""code goes here\n</code>"))
-
-    assert_equal expected, parse(doc)
-
-    expected =
-      doc(para("Example:\n<code>\n""code goes here\n</code>"))
-
-    assert_equal expected, parse(doc.sub(/^\n/, ''))
-  end
-
-  def test_parse_code_github_format
-    doc = <<-MD
-Example:
-
-``` ruby
-code goes here
-```
-    MD
-
-    code = verb("code goes here\n")
-    code.format = :ruby
-
-    expected =
-      doc(
-        para("Example:"),
-        code)
-
-    assert_equal expected, parse(doc)
-    assert_equal expected, parse(doc.sub(/^\n/, ''))
-
-    @parser.github = false
-
-    expected =
-      doc(para("Example:"),
-          para("<code>ruby\n""code goes here\n</code>"))
-
-    assert_equal expected, parse(doc)
-
-    expected =
-      doc(para("Example:\n<code>ruby\n""code goes here\n</code>"))
-
-    assert_equal expected, parse(doc.sub(/^\n/, ''))
-  end
-
-  def test_parse_definition_list
-    doc = parse <<-MD
-one
-:   This is a definition
-
-two
-:   This is another definition
-    MD
-
-    expected = doc(
-      list(:NOTE,
-        item(%w[one], para("This is a definition")),
-        item(%w[two], para("This is another definition"))))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_definition_list_indents
-    doc = parse <<-MD
-zero
-: Indented zero characters
-
-one
- : Indented one characters
-
-two
-  : Indented two characters
-
-three
-   : Indented three characters
-
-four
-    : Indented four characters
-
-    MD
-
-    expected = doc(
-      list(:NOTE,
-        item(%w[zero],  para("Indented zero characters")),
-        item(%w[one],   para("Indented one characters")),
-        item(%w[two],   para("Indented two characters")),
-        item(%w[three], para("Indented three characters"))),
-      para("four\n : Indented four characters"))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_definition_list_multi_description
-    doc = parse <<-MD
-label
-:   This is a definition
-
-:   This is another definition
-    MD
-
-    expected = doc(
-      list(:NOTE,
-        item(%w[label], para("This is a definition")),
-        item(nil,       para("This is another definition"))))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_definition_list_multi_label
-    doc = parse <<-MD
-one
-two
-:   This is a definition
-    MD
-
-    expected = doc(
-      list(:NOTE,
-        item(%w[one two], para("This is a definition"))))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_definition_list_multi_line
-    doc = parse <<-MD
-one
-:   This is a definition
-that extends to two lines
-
-two
-:   This is another definition
-that also extends to two lines
-    MD
-
-    expected = doc(
-      list(:NOTE,
-        item(%w[one],
-          para("This is a definition\nthat extends to two lines")),
-        item(%w[two],
-          para("This is another definition\nthat also extends to two lines"))))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_definition_list_rich_label
-    doc = parse <<-MD
-`one`
-:    This is a definition
-
-**two**
-:    This is another definition
-    MD
-
-    expected = doc(
-      list(:NOTE,
-        item(%w[<code>one</code>],
-          para("This is a definition")),
-        item(%w[*two*],
-          para("This is another definition"))))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_definition_list_no
-    @parser.definition_lists = false
-
-    doc = parse <<-MD
-one
-:   This is a definition
-
-two
-:   This is another definition
-    MD
-
-    expected = doc(
-        para("one\n: This is a definition"),
-        para("two\n: This is another definition"))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_entity_dec
-    doc = parse "Entity: A"
-
-    expected = doc(para("Entity: A"))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_entity_hex
-    doc = parse "Entity: A"
-
-    expected = doc(para("Entity: A"))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_entity_named
-    doc = parse "Entity: π"
-
-    expected = doc(para("Entity: π"))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_emphasis_star
-    doc = parse "it *works*\n"
-
-    expected = @RM::Document.new(
-      @RM::Paragraph.new("it _works_"))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_emphasis_underscore
-    doc = parse "it _works_\n"
-
-    expected =
-      doc(
-        para("it _works_"))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_emphasis_underscore_embedded
-    doc = parse "foo_bar bar_baz\n"
-
-    expected =
-      doc(
-        para("foo_bar bar_baz"))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_emphasis_underscore_in_word
-    doc = parse "it foo_bar_baz\n"
-
-    expected =
-      doc(
-        para("it foo_bar_baz"))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_escape
-    assert_equal doc(para("Backtick: `")), parse("Backtick: \\`")
-
-    assert_equal doc(para("Backslash: \\")), parse("Backslash: \\\\")
-
-    assert_equal doc(para("Colon: :")), parse("Colon: \\:")
-  end
-
-  def test_parse_heading_atx
-    # CommonMark Example 62
-    (1..6).each do |level|
-      doc = parse "#{"#" * level} heading\n"
-
-      expected = @RM::Document.new(
-        @RM::Heading.new(level, "heading"))
-
-      assert_equal expected, doc
-    end
-
-    # CommonMark Example 64
-    doc = parse "#5 bolt\n\n#hashtag\n"
-
-    expected = @RM::Document.new(
-      para("#5 bolt"),
-      para("#hashtag"),
-    )
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_heading_setext_dash
-    doc = parse <<-MD
-heading
----
-    MD
-
-    expected = @RM::Document.new(
-      @RM::Heading.new(2, "heading"))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_heading_setext_equals
-    doc = parse <<-MD
-heading
-===
-    MD
-
-    expected = @RM::Document.new(
-      @RM::Heading.new(1, "heading"))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_html
-    @parser.html = true
-
-    doc = parse "<address>Links here</address>\n"
-
-    expected = doc(
-      @RM::Raw.new("<address>Links here</address>"))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_html_hr
-    @parser.html = true
-
-    doc = parse "<hr>\n"
-
-    expected = doc(raw("<hr>"))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_html_no_html
-    @parser.html = false
-
-    doc = parse "<address>Links here</address>\n"
-
-    expected = doc()
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_image
-    doc = parse "image ![alt text](path/to/image.jpg)"
-
-    expected = doc(para("image rdoc-image:path/to/image.jpg:alt text"))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_image_link
-    @parser.html = true
-
-    doc = parse "[![alt text](path/to/image.jpg)](http://example.com)"
-
-    expected =
-      doc(
-        para('{rdoc-image:path/to/image.jpg:alt text}[http://example.com]'))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_line_break
-    doc = parse "Some text  \nwith extra lines"
-
-    expected = doc(
-      para("Some text", hard_break, "with extra lines"))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_link_reference_id
-    doc = parse <<-MD
-This is [an example][id] reference-style link.
-
-[id]: http://example.com "Optional Title Here"
-    MD
-
-    expected = doc(
-      para("This is {an example}[http://example.com] reference-style link."))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_link_reference_id_adjacent
-    doc = parse <<-MD
-[this] [this] should work
-
-[this]: example
-    MD
-
-    expected = doc(
-      para("{this}[example] should work"))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_link_reference_id_eof
-    doc = parse <<-MD.chomp
-This is [an example][id] reference-style link.
-
-[id]: http://example.com "Optional Title Here"
-    MD
-
-    expected = doc(
-      para("This is {an example}[http://example.com] reference-style link."))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_link_reference_id_many
-    doc = parse <<-MD
-This is [an example][id] reference-style link.
-
-And [another][id].
-
-[id]: http://example.com "Optional Title Here"
-    MD
-
-    expected = doc(
-      para("This is {an example}[http://example.com] reference-style link."),
-      para("And {another}[http://example.com]."))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_link_reference_implicit
-    doc = parse <<-MD
-This is [an example][] reference-style link.
-
-[an example]: http://example.com "Optional Title Here"
-    MD
-
-    expected = doc(
-      para("This is {an example}[http://example.com] reference-style link."))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_list_bullet
-    doc = parse <<-MD
-* one
-* two
-    MD
-
-    expected = doc(
-      list(:BULLET,
-        item(nil, para("one")),
-        item(nil, para("two"))))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_list_bullet_auto_link
-    doc = parse <<-MD
-* <http://example/>
-    MD
-
-    expected = doc(
-      list(:BULLET,
-        item(nil, para("http://example/"))))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_list_bullet_continue
-    doc = parse <<-MD
-* one
-
-* two
-    MD
-
-    expected = doc(
-      list(:BULLET,
-        item(nil, para("one")),
-        item(nil, para("two"))))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_list_bullet_multiline
-    doc = parse <<-MD
-* one
-  two
-    MD
-
-    expected = doc(
-      list(:BULLET,
-        item(nil, para("one\n two"))))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_list_bullet_nest
-    doc = parse <<-MD
-* outer
-    * inner
-    MD
-
-    expected = doc(
-      list(:BULLET,
-        item(nil,
-          para("outer"),
-          list(:BULLET,
-            item(nil,
-              para("inner"))))))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_list_bullet_nest_loose
-    doc = parse <<-MD
-* outer
-
-    * inner
-    MD
-
-    expected = doc(
-      list(:BULLET,
-        item(nil,
-          para("outer"),
-          list(:BULLET,
-            item(nil, para("inner"))))))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_list_bullet_nest_continue
-    doc = parse <<-MD
-* outer
-    * inner
-  continue inner
-* outer 2
-    MD
-
-    expected = doc(
-      list(:BULLET,
-        item(nil,
-          para("outer"),
-          list(:BULLET,
-            item(nil,
-              para("inner\n continue inner")))),
-        item(nil,
-          para("outer 2"))))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_list_number
-    doc = parse <<-MD
-1. one
-1. two
-    MD
-
-    expected = doc(
-      list(:NUMBER,
-        item(nil, para("one")),
-        item(nil, para("two"))))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_list_number_continue
-    doc = parse <<-MD
-1. one
-
-1. two
-    MD
-
-    expected = doc(
-      list(:NUMBER,
-        item(nil, para("one")),
-        item(nil, para("two"))))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_note
-    @parser.notes = true
-
-    doc = parse <<-MD
-Some text.[^1]
-
-[^1]: With a footnote
-    MD
-
-    expected = doc(
-      para("Some text.{*1}[rdoc-label:foottext-1:footmark-1]"),
-      @RM::Rule.new(1),
-      para("{^1}[rdoc-label:footmark-1:foottext-1] With a footnote"))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_note_indent
-    @parser.notes = true
-
-    doc = parse <<-MD
-Some text.[^1]
-
-[^1]: With a footnote
-
-    more
-    MD
-
-    expected = doc(
-      para("Some text.{*1}[rdoc-label:foottext-1:footmark-1]"),
-      rule(1),
-      para("{^1}[rdoc-label:footmark-1:foottext-1] With a footnote\n\nmore"))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_note_inline
-    @parser.notes = true
-
-    doc = parse <<-MD
-Some text. ^[With a footnote]
-    MD
-
-    expected = doc(
-      para("Some text. {*1}[rdoc-label:foottext-1:footmark-1]"),
-      @RM::Rule.new(1),
-      para("{^1}[rdoc-label:footmark-1:foottext-1] With a footnote"))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_note_no_notes
-    @parser.notes = false
-
-    assert_raise RDoc::Markdown::ParseError do
-      parse "Some text.[^1]"
-    end
-  end
-
-  def test_parse_note_multiple
-    @parser.notes = true
-
-    doc = parse <<-MD
-Some text[^1]
-with inline notes^[like this]
-and an extra note.[^2]
-
-[^1]: With a footnote
-[^2]: Which should be numbered correctly
-    MD
-
-    expected = doc(
-      para("Some text{*1}[rdoc-label:foottext-1:footmark-1]\n" +
-           "with inline notes{*2}[rdoc-label:foottext-2:footmark-2]\n" +
-           "and an extra note.{*3}[rdoc-label:foottext-3:footmark-3]"),
-
-      rule(1),
-
-      para("{^1}[rdoc-label:footmark-1:foottext-1] With a footnote"),
-      para("{^2}[rdoc-label:footmark-2:foottext-2] like this"),
-      para("{^3}[rdoc-label:footmark-3:foottext-3] " +
-           "Which should be numbered correctly"))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_paragraph
-    doc = parse "it worked\n"
-
-    expected = doc(para("it worked"))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_paragraph_break_on_newline
-    @parser.break_on_newline = true
-
-    doc = parse "one\ntwo\n"
-
-    expected = doc(para("one", hard_break, "two"))
-
-    assert_equal expected, doc
-
-    doc = parse "one  \ntwo\nthree\n"
-
-    expected = doc(para("one", hard_break, "two", hard_break, "three"))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_paragraph_stars
-    doc = parse "it worked ****\n"
-
-    expected = @RM::Document.new(
-      @RM::Paragraph.new("it worked ****"))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_paragraph_html
-    @parser.html = true
-
-    doc = parse "<address>Links here</address>"
-
-    expected = doc(raw("<address>Links here</address>"))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_paragraph_html_no_html
-    @parser.html = false
-
-    doc = parse "<address>Links here</address>"
-
-    expected = doc()
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_paragraph_indent_one
-    doc = parse <<-MD
- text
-    MD
-
-    expected = doc(para("text"))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_paragraph_indent_two
-    doc = parse <<-MD
-  text
-    MD
-
-    expected = doc(para("text"))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_paragraph_indent_three
-    doc = parse <<-MD
-   text
-    MD
-
-    expected = doc(para("text"))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_paragraph_multiline
-    doc = parse "one\ntwo"
-
-    expected = doc(para("one\ntwo"))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_paragraph_two
-    doc = parse "one\n\ntwo"
-
-    expected = @RM::Document.new(
-      @RM::Paragraph.new("one"),
-      @RM::Paragraph.new("two"))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_plain
-    doc = parse "it worked"
-
-    expected = @RM::Document.new(
-      @RM::Paragraph.new("it worked"))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_reference_link_embedded_bracket
-    doc = parse "With [embedded [brackets]] [b].\n\n[b]: /url/\n"
-
-    expected =
-      doc(
-        para("With {embedded [brackets]}[/url/]."))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_rule_dash
-    doc = parse "- - -\n\n"
-
-    expected = @RM::Document.new(@RM::Rule.new(1))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_rule_underscore
-    doc = parse "_ _ _\n\n"
-
-    expected = @RM::Document.new(@RM::Rule.new(1))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_rule_star
-    doc = parse "* * *\n\n"
-
-    expected = @RM::Document.new(@RM::Rule.new(1))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_strong_star
-    doc = parse "it **works**\n"
-
-    expected = @RM::Document.new(
-      @RM::Paragraph.new("it *works*"))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_strong_underscore
-    doc = parse "it __works__\n"
-
-    expected = @RM::Document.new(
-      @RM::Paragraph.new("it *works*"))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_strong_emphasis_star
-    doc = parse "it ***works***\n"
-
-    expected = @RM::Document.new(
-      @RM::Paragraph.new("it <b>_works_</b>"))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_strong_emphasis_underscore
-    doc = parse "it ___works___\n"
-
-    expected = @RM::Document.new(
-      @RM::Paragraph.new("it <b>_works_</b>"))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_strike_tilde
-    doc = parse "it ~~works~~\n"
-
-    expected = @RM::Document.new(
-      @RM::Paragraph.new("it ~works~"))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_strike_words_tilde
-    doc = parse "it ~~works fine~~\n"
-
-    expected = @RM::Document.new(
-      @RM::Paragraph.new("it <s>works fine</s>"))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_strike_tilde_no
-    @parser.strike = false
-
-    doc = parse "it ~~works fine~~\n"
-
-    expected = @RM::Document.new(
-      @RM::Paragraph.new("it ~~works fine~~"))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_style
-    @parser.css = true
-
-    doc = parse "<style>h1 { color: red }</style>\n"
-
-    expected = doc(
-      @RM::Raw.new("<style>h1 { color: red }</style>"))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_style_disabled
-    doc = parse "<style>h1 { color: red }</style>\n"
-
-    expected = doc()
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_verbatim
-    doc = parse <<-MD
-    text
-    MD
-
-    expected = doc(verb("text\n"))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_verbatim_eof
-    doc = parse "    text"
-
-    expected = doc(verb("text\n"))
-
-    assert_equal expected, doc
-  end
-
-  def test_strong
-    assert_equal '*word*',            @parser.strong('word')
-    assert_equal '<b>two words</b>',  @parser.strong('two words')
-    assert_equal '<b>_emphasis_</b>', @parser.strong('_emphasis_')
-  end
-
-  def test_code_fence_with_unintended_array
-    doc = parse '```<ruby>```'
-
-    expected = doc(verb('<ruby>'))
-
-    assert_equal expected, doc
-  end
-
-  def test_gfm_table
-    doc = parse <<~MD
-    |      |                 |compare-ruby|built-ruby|
-    |------|:----------------|-----------:|---------:|
-    |test  | 1               |     11.618M|   10.757M|
-    |      |                 |       1.08x|         -|
-    |test  | 10              |      1.849M|    1.723M|
-    |      |                 |       1.07x|         -|
-    MD
-
-    head = ["", "", "compare-ruby", "built-ruby"]
-    align = [nil, :left, :right, :right]
-    body = [
-      ["test", "1", "11.618M", "10.757M"],
-      ["", "", "1.08x", "-"],
-      ["test", "10", "1.849M", "1.723M"],
-      ["", "", "1.07x", "-"],
-    ]
-    expected = doc(@RM::Table.new(head, align, body))
-
-    assert_equal expected, doc
-  end
-
-  def test_gfm_table_2
-    doc = parse <<~'MD'
-    | Cmd | Returns | Meaning
-    ----- | :-----: | -------
-    |"b"  | boolean | True if file1 is a block device
-    "c"   | boolean | True if file1 is a character device
-    |"\|" | boolean | escaped bar \| test
-    MD
-
-    head = %w[Cmd Returns Meaning]
-    align = [nil, :center, nil]
-    body = [
-      ['"b"', 'boolean', 'True if file1 is a block device'],
-      ['"c"', 'boolean', 'True if file1 is a character device'],
-      ['"|"', 'boolean', 'escaped bar | test'],
-    ]
-    expected = doc(@RM::Table.new(head, align, body))
-
-    assert_equal expected, doc
-  end
-
-  def parse(text)
-    @parser.parse text
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc/rdoc_markdown_test_test.rb b/test/mri/rdoc/rdoc/rdoc_markdown_test_test.rb
deleted file mode 100644
index c28fe6bebdf..00000000000
--- a/test/mri/rdoc/rdoc/rdoc_markdown_test_test.rb
+++ /dev/null
@@ -1,1883 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-require 'pp'
-
-require_relative '../../lib/rdoc'
-require_relative '../../lib/rdoc/markdown'
-
-class RDocMarkdownTestTest < RDoc::TestCase
-
-  MARKDOWN_TEST_PATH = File.expand_path '../MarkdownTest_1.0.3/', __FILE__
-
-  def setup
-    super
-
-    @parser = RDoc::Markdown.new
-  end
-
-  def test_amps_and_angle_encoding
-    input = File.read "#{MARKDOWN_TEST_PATH}/Amps and angle encoding.text"
-
-    doc = @parser.parse input
-
-    expected =
-      doc(
-        para("AT&T has an ampersand in their name."),
-        para("AT&T is another way to write it."),
-        para("This & that."),
-        para("4 < 5."),
-        para("6 > 5."),
-        para("Here's a {link}[http://example.com/?foo=1&bar=2] with " +
-             "an ampersand in the URL."),
-        para("Here's a link with an amersand in the link text: " +
-             "{AT&T}[http://att.com/]."),
-        para("Here's an inline {link}[/script?foo=1&bar=2]."),
-        para("Here's an inline {link}[/script?foo=1&bar=2]."))
-
-    assert_equal expected, doc
-  end
-
-  def test_auto_links
-    input = File.read "#{MARKDOWN_TEST_PATH}/Auto links.text"
-
-    doc = @parser.parse input
-
-    # TODO verify rdoc auto-links too
-    expected =
-      doc(
-        para("Link: http://example.com/."),
-        para("With an ampersand: http://example.com/?foo=1&bar=2"),
-        list(:BULLET,
-          item(nil, para("In a list?")),
-          item(nil, para("http://example.com/")),
-          item(nil, para("It should."))),
-        block(
-          para("Blockquoted: http://example.com/")),
-        para("Auto-links should not occur here: " +
-             "<code><http://example.com/></code>"),
-        verb("or here: <http://example.com/>\n"))
-
-    assert_equal expected, doc
-  end
-
-  def test_backslash_escapes
-    input = File.read "#{MARKDOWN_TEST_PATH}/Backslash escapes.text"
-
-    doc = @parser.parse input
-
-    expected =
-      doc(
-        para("These should all get escaped:"),
-
-        para("Backslash: \\"),
-        para("Backtick: `"),
-        para("Asterisk: *"),
-        para("Underscore: _"),
-        para("Left brace: {"),
-        para("Right brace: }"),
-        para("Left bracket: ["),
-        para("Right bracket: ]"),
-        para("Left paren: ("),
-        para("Right paren: )"),
-        para("Greater-than: >"),
-        para("Hash: #"),
-        para("Period: ."),
-        para("Bang: !"),
-        para("Plus: +"),
-        para("Minus: -"),
-
-        para("These should not, because they occur within a code block:"),
-
-        verb("Backslash: \\\\\n",
-             "\n",
-             "Backtick: \\`\n",
-             "\n",
-             "Asterisk: \\*\n",
-             "\n",
-             "Underscore: \\_\n",
-             "\n",
-             "Left brace: \\{\n",
-             "\n",
-             "Right brace: \\}\n",
-             "\n",
-             "Left bracket: \\[\n",
-             "\n",
-             "Right bracket: \\]\n",
-             "\n",
-             "Left paren: \$\n",
-             "\n",
-             "Right paren: \$\n",
-             "\n",
-             "Greater-than: \\>\n",
-             "\n",
-             "Hash: \\#\n",
-             "\n",
-             "Period: \\.\n",
-             "\n",
-             "Bang: \\!\n",
-             "\n",
-             "Plus: \\+\n",
-             "\n",
-             "Minus: \\-\n"),
-
-        para("Nor should these, which occur in code spans:"),
-
-        para("Backslash: <code>\\\\</code>"),
-        para("Backtick: <code>\\`</code>"),
-        para("Asterisk: <code>\\*</code>"),
-        para("Underscore: <code>\\_</code>"),
-        para("Left brace: <code>\\{</code>"),
-        para("Right brace: <code>\\}</code>"),
-        para("Left bracket: <code>\\[</code>"),
-        para("Right bracket: <code>\\]</code>"),
-        para("Left paren: <code>\$</code>"),
-        para("Right paren: <code>\$</code>"),
-        para("Greater-than: <code>\\></code>"),
-        para("Hash: <code>\\#</code>"),
-        para("Period: <code>\\.</code>"),
-        para("Bang: <code>\\!</code>"),
-        para("Plus: <code>\\+</code>"),
-        para("Minus: <code>\\-</code>"),
-
-        para("These should get escaped, even though they're matching pairs for\n" +
-             "other Markdown constructs:"),
-
-        para("\*asterisks\*"),
-        para("\_underscores\_"),
-        para("`backticks`"),
-
-        para("This is a code span with a literal backslash-backtick " +
-             "sequence: <code>\\`</code>"),
-
-        para("This is a tag with unescaped backticks " +
-             "<span attr='`ticks`'>bar</span>."),
-
-        para("This is a tag with backslashes " +
-             "<span attr='\\\\backslashes\\\\'>bar</span>."))
-
-    assert_equal expected, doc
-  end
-
-  def test_blockquotes_with_code_blocks
-    input = File.read "#{MARKDOWN_TEST_PATH}/Blockquotes with code blocks.text"
-
-    doc = @parser.parse input
-
-    expected =
-      doc(
-        block(
-          para("Example:"),
-          verb("sub status {\n",
-               "    print \"working\";\n",
-               "}\n"),
-          para("Or:"),
-          verb("sub status {\n",
-               "    return \"working\";\n",
-               "}\n")))
-
-    assert_equal expected, doc
-  end
-
-  def test_code_blocks
-    input = File.read "#{MARKDOWN_TEST_PATH}/Code Blocks.text"
-
-    doc = @parser.parse input
-
-    expected =
-      doc(
-        verb("code block on the first line\n"),
-        para("Regular text."),
-
-        verb("code block indented by spaces\n"),
-        para("Regular text."),
-
-        verb("the lines in this block  \n",
-             "all contain trailing spaces  \n"),
-        para("Regular Text."),
-
-        verb("code block on the last line\n"))
-
-    assert_equal expected, doc
-  end
-
-  def test_code_spans
-    input = File.read "#{MARKDOWN_TEST_PATH}/Code Spans.text"
-
-    doc = @parser.parse input
-
-    expected = doc(
-      para("<code><test a=\"</code> content of attribute <code>\"></code>"),
-      para("Fix for backticks within HTML tag: " +
-           "<span attr='`ticks`'>like this</span>"),
-      para("Here's how you put <code>`backticks`</code> in a code span."))
-
-    assert_equal expected, doc
-  end
-
-  def test_hard_wrapped_paragraphs_with_list_like_lines
-    input = File.read "#{MARKDOWN_TEST_PATH}/Hard-wrapped paragraphs with list-like lines.text"
-
-    doc = @parser.parse input
-
-    expected =
-      doc(
-        para("In Markdown 1.0.0 and earlier. Version\n" +
-             "8. This line turns into a list item.\n"   +
-             "Because a hard-wrapped line in the\n"     +
-             "middle of a paragraph looked like a\n"    +
-             "list item."),
-        para("Here's one with a bullet.\n" +
-             "* criminey."))
-
-    assert_equal expected, doc
-  end
-
-  def test_horizontal_rules
-    input = File.read "#{MARKDOWN_TEST_PATH}/Horizontal rules.text"
-
-    doc = @parser.parse input
-
-    expected =
-      doc(
-        para("Dashes:"),
-
-        rule(1),
-        rule(1),
-        rule(1),
-        rule(1),
-        verb("---\n"),
-
-        rule(1),
-        rule(1),
-        rule(1),
-        rule(1),
-        verb("- - -\n"),
-
-        para("Asterisks:"),
-
-        rule(1),
-        rule(1),
-        rule(1),
-        rule(1),
-        verb("***\n"),
-
-        rule(1),
-        rule(1),
-        rule(1),
-        rule(1),
-        verb("* * *\n"),
-
-        para("Underscores:"),
-
-        rule(1),
-        rule(1),
-        rule(1),
-        rule(1),
-        verb("___\n"),
-
-        rule(1),
-        rule(1),
-        rule(1),
-        rule(1),
-        verb("_ _ _\n"))
-
-    assert_equal expected, doc
-  end
-
-  def test_inline_html_advanced
-    input = File.read "#{MARKDOWN_TEST_PATH}/Inline HTML (Advanced).text"
-
-    @parser.html = true
-
-    doc = @parser.parse input
-
-    expected =
-      doc(
-        para("Simple block on one line:"),
-        raw("<div>foo</div>"),
-        para("And nested without indentation:"),
-        raw(<<-RAW.chomp))
-<div>
-<div>
-<div>
-foo
-</div>
-<div style=">"/>
-</div>
-<div>bar</div>
-</div>
-        RAW
-
-    assert_equal expected, doc
-  end
-
-  def test_inline_html_simple
-    input = File.read "#{MARKDOWN_TEST_PATH}/Inline HTML (Simple).text"
-
-    @parser.html = true
-
-    doc = @parser.parse input
-
-    expected =
-      doc(
-       para("Here's a simple block:"),
-       raw("<div>\n\tfoo\n</div>"),
-
-       para("This should be a code block, though:"),
-       verb("<div>\n",
-            "\tfoo\n",
-            "</div>\n"),
-
-       para("As should this:"),
-       verb("<div>foo</div>\n"),
-
-       para("Now, nested:"),
-       raw("<div>\n\t<div>\n\t\t<div>\n\t\t\tfoo\n" +
-           "\t\t</div>\n\t</div>\n</div>"),
-
-       para("This should just be an HTML comment:"),
-       raw(""),
-
-       para("Multiline:"),
-       raw(""),
-
-       para("Code block:"),
-       verb("\n"),
-
-       para("Just plain comment, with trailing spaces on the line:"),
-       raw(""),
-
-       para("Code:"),
-       verb("<hr />\n"),
-
-       para("Hr's:"),
-       raw("<hr>"),
-       raw("<hr/>"),
-       raw("<hr />"),
-
-       raw("<hr>"),
-       raw("<hr/>"),
-       raw("<hr />"),
-
-       raw("<hr class=\"foo\" id=\"bar\" />"),
-       raw("<hr class=\"foo\" id=\"bar\"/>"),
-       raw("<hr class=\"foo\" id=\"bar\" >"))
-
-    assert_equal expected, doc
-  end
-
-  def test_inline_html_comments
-    input = File.read "#{MARKDOWN_TEST_PATH}/Inline HTML comments.text"
-
-    doc = @parser.parse input
-
-    expected =
-      doc(
-        para("Paragraph one."),
-
-        raw(""),
-
-        raw(""),
-
-        para("Paragraph two."),
-
-        raw(""),
-
-        para("The end."))
-
-    assert_equal expected, doc
-  end
-
-  def test_links_inline_style
-    input = File.read "#{MARKDOWN_TEST_PATH}/Links, inline style.text"
-
-    doc = @parser.parse input
-
-    expected =
-      doc(
-        para("Just a {URL}[/url/]."),
-        para("{URL and title}[/url/]."),
-        para("{URL and title}[/url/]."),
-        para("{URL and title}[/url/]."),
-        para("{URL and title}[/url/]."),
-        para("{Empty}[]."))
-
-    assert_equal expected, doc
-  end
-
-  def test_links_reference_style
-    input = File.read "#{MARKDOWN_TEST_PATH}/Links, reference style.text"
-
-    doc = @parser.parse input
-
-    expected =
-      doc(
-        para("Foo {bar}[/url/]."),
-        para("Foo {bar}[/url/]."),
-        para("Foo {bar}[/url/]."),
-
-        para("With {embedded [brackets]}[/url/]."),
-
-        para("Indented {once}[/url]."),
-        para("Indented {twice}[/url]."),
-        para("Indented {thrice}[/url]."),
-        para("Indented [four][] times."),
-
-        verb("[four]: /url\n"),
-
-        rule(1),
-
-        para("{this}[foo] should work"),
-        para("So should {this}[foo]."),
-        para("And {this}[foo]."),
-        para("And {this}[foo]."),
-        para("And {this}[foo]."),
-
-        para("But not [that] []."),
-        para("Nor [that][]."),
-        para("Nor [that]."),
-
-        para("[Something in brackets like {this}[foo] should work]"),
-        para("[Same with {this}[foo].]"),
-
-        para("In this case, {this}[/somethingelse/] points to something else."),
-        para("Backslashing should suppress [this] and [this]."),
-
-        rule(1),
-
-        para("Here's one where the {link breaks}[/url/] across lines."),
-        para("Here's another where the {link breaks}[/url/] across lines, " +
-             "but with a line-ending space."))
-
-    assert_equal expected, doc
-  end
-
-  def test_links_shortcut_references
-    input = File.read "#{MARKDOWN_TEST_PATH}/Links, shortcut references.text"
-
-    doc = @parser.parse input
-
-    expected =
-      doc(
-        para("This is the {simple case}[/simple]."),
-        para("This one has a {line break}[/foo]."),
-        para("This one has a {line break}[/foo] with a line-ending space."),
-        para("{this}[/that] and the {other}[/other]"))
-
-    assert_equal expected, doc
-  end
-
-  def test_literal_quotes_in_titles
-    input = File.read "#{MARKDOWN_TEST_PATH}/Literal quotes in titles.text"
-
-    doc = @parser.parse input
-
-    # TODO support title attribute
-    expected =
-      doc(
-        para("Foo {bar}[/url/]."),
-        para("Foo {bar}[/url/]."))
-
-    assert_equal expected, doc
-  end
-
-  def test_markdown_documentation_basics
-    input = File.read "#{MARKDOWN_TEST_PATH}/Markdown Documentation - Basics.text"
-
-    doc = @parser.parse input
-
-    expected =
-      doc(
-        head(1, "Markdown: Basics"),
-
-        raw(<<-RAW.chomp),
-<ul id="ProjectSubmenu">
-    <li><a href="/projects/markdown/" title="Markdown Project Page">Main</a></li>
-    <li><a class="selected" title="Markdown Basics">Basics</a></li>
-    <li><a href="/projects/markdown/syntax" title="Markdown Syntax Documentation">Syntax</a></li>
-    <li><a href="/projects/markdown/license" title="Pricing and License Information">License</a></li>
-    <li><a href="/projects/markdown/dingus" title="Online Markdown Web Form">Dingus</a></li>
-</ul>
-        RAW
-
-        head(2, "Getting the Gist of Markdown's Formatting Syntax"),
-
-        para("This page offers a brief overview of what it's like to use Markdown.\n" +
-             "The {syntax page}[/projects/markdown/syntax] provides complete, detailed documentation for\n" +
-             "every feature, but Markdown should be very easy to pick up simply by\n" +
-             "looking at a few examples of it in action. The examples on this page\n" +
-             "are written in a before/after style, showing example syntax and the\n" +
-             "HTML output produced by Markdown."),
-
-        para("It's also helpful to simply try Markdown out; the {Dingus}[/projects/markdown/dingus] is a\n" +
-             "web application that allows you type your own Markdown-formatted text\n" +
-             "and translate it to XHTML."),
-
-        para("<b>Note:</b> This document is itself written using Markdown; you\n" +
-             "can {see the source for it by adding '.text' to the URL}[/projects/markdown/basics.text]."),
-
-        head(2, "Paragraphs, Headers, Blockquotes"),
-
-        para("A paragraph is simply one or more consecutive lines of text, separated\n" +
-             "by one or more blank lines. (A blank line is any line that looks like a\n" +
-             "blank line -- a line containing nothing spaces or tabs is considered\n" +
-             "blank.) Normal paragraphs should not be intended with spaces or tabs."),
-
-        para("Markdown offers two styles of headers: _Setext_ and _atx_.\n" +
-             "Setext-style headers for <code><h1></code> and <code><h2></code> are created by\n" +
-             "\"underlining\" with equal signs (<code>=</code>) and hyphens (<code>-</code>), respectively.\n" +
-             "To create an atx-style header, you put 1-6 hash marks (<code>#</code>) at the\n" +
-             "beginning of the line -- the number of hashes equals the resulting\n" +
-             "HTML header level."),
-
-        para("Blockquotes are indicated using email-style '<code>></code>' angle brackets."),
-
-        para("Markdown:"),
-
-        verb("A First Level Header\n",
-             "====================\n",
-             "\n",
-             "A Second Level Header\n",
-             "---------------------\n",
-             "\n",
-             "Now is the time for all good men to come to\n",
-             "the aid of their country. This is just a\n",
-             "regular paragraph.\n",
-             "\n",
-             "The quick brown fox jumped over the lazy\n",
-             "dog's back.\n",
-             "\n",
-             "### Header 3\n",
-             "\n",
-             "> This is a blockquote.\n",
-             "> \n",
-             "> This is the second paragraph in the blockquote.\n",
-             ">\n",
-             "> ## This is an H2 in a blockquote\n"),
-
-        para("Output:"),
-
-        verb("<h1>A First Level Header</h1>\n",
-             "\n",
-             "<h2>A Second Level Header</h2>\n",
-             "\n",
-             "<p>Now is the time for all good men to come to\n",
-             "the aid of their country. This is just a\n",
-             "regular paragraph.</p>\n",
-             "\n",
-             "<p>The quick brown fox jumped over the lazy\n",
-             "dog's back.</p>\n",
-             "\n",
-             "<h3>Header 3</h3>\n",
-             "\n",
-             "<blockquote>\n",
-             "    <p>This is a blockquote.</p>\n",
-             "\n",
-             "    <p>This is the second paragraph in the blockquote.</p>\n",
-             "\n",
-             "    <h2>This is an H2 in a blockquote</h2>\n",
-             "</blockquote>\n"),
-
-        head(3, "Phrase Emphasis"),
-        para("Markdown uses asterisks and underscores to indicate spans of emphasis."),
-
-        para("Markdown:"),
-
-        verb("Some of these words *are emphasized*.\n",
-             "Some of these words _are emphasized also_.\n",
-             "\n",
-             "Use two asterisks for **strong emphasis**.\n",
-             "Or, if you prefer, __use two underscores instead__.\n"),
-
-        para("Output:"),
-
-        verb("<p>Some of these words <em>are emphasized</em>.\n",
-             "Some of these words <em>are emphasized also</em>.</p>\n",
-             "\n",
-             "<p>Use two asterisks for <strong>strong emphasis</strong>.\n",
-             "Or, if you prefer, <strong>use two underscores instead</strong>.</p>\n"),
-
-        head(2, "Lists"),
-
-        para("Unordered (bulleted) lists use asterisks, pluses, and hyphens (<code>*</code>,\n" +
-             "<code>+</code>, and <code>-</code>) as list markers. These three markers are\n" +
-             "interchangeable; this:"),
-
-        verb("*   Candy.\n",
-             "*   Gum.\n",
-             "*   Booze.\n"),
-
-        para("this:"),
-
-        verb("+   Candy.\n",
-             "+   Gum.\n",
-             "+   Booze.\n"),
-
-        para("and this:"),
-
-        verb("-   Candy.\n",
-             "-   Gum.\n",
-             "-   Booze.\n"),
-
-        para("all produce the same output:"),
-
-        verb("<ul>\n",
-             "<li>Candy.</li>\n",
-             "<li>Gum.</li>\n",
-             "<li>Booze.</li>\n",
-             "</ul>\n"),
-
-        para("Ordered (numbered) lists use regular numbers, followed by periods, as\n" +
-             "list markers:"),
-
-        verb("1.  Red\n",
-             "2.  Green\n",
-             "3.  Blue\n"),
-
-        para("Output:"),
-
-        verb("<ol>\n",
-             "<li>Red</li>\n",
-             "<li>Green</li>\n",
-             "<li>Blue</li>\n",
-             "</ol>\n"),
-
-        para("If you put blank lines between items, you'll get <code><p></code> tags for the\n" +
-             "list item text. You can create multi-paragraph list items by indenting\n" +
-             "the paragraphs by 4 spaces or 1 tab:"),
-
-        verb("*   A list item.\n",
-             "\n",
-             "    With multiple paragraphs.\n",
-             "\n",
-             "*   Another item in the list.\n"),
-
-        para("Output:"),
-
-        verb("<ul>\n",
-             "<li><p>A list item.</p>\n",
-             "<p>With multiple paragraphs.</p></li>\n",
-             "<li><p>Another item in the list.</p></li>\n",
-             "</ul>\n"),
-
-        head(3, "Links"),
-
-        para("Markdown supports two styles for creating links: _inline_ and\n" +
-             "_reference_. With both styles, you use square brackets to delimit the\n" +
-             "text you want to turn into a link."),
-
-        para("Inline-style links use parentheses immediately after the link text.\n" +
-             "For example:"),
-
-        verb("This is an [example link](http://example.com/).\n"),
-
-        para("Output:"),
-
-        verb("<p>This is an <a href=\"http://example.com/\">\n",
-             "example link</a>.</p>\n"),
-
-        para("Optionally, you may include a title attribute in the parentheses:"),
-
-        verb("This is an [example link](http://example.com/ \"With a Title\").\n"),
-
-        para("Output:"),
-
-        verb("<p>This is an <a href=\"http://example.com/\" title=\"With a Title\">\n",
-             "example link</a>.</p>\n"),
-
-        para("Reference-style links allow you to refer to your links by names, which\n" +
-             "you define elsewhere in your document:"),
-
-        verb("I get 10 times more traffic from [Google][1] than from\n",
-             "[Yahoo][2] or [MSN][3].\n",
-             "\n",
-             "[1]: http://google.com/        \"Google\"\n",
-             "[2]: http://search.yahoo.com/  \"Yahoo Search\"\n",
-             "[3]: http://search.msn.com/    \"MSN Search\"\n"),
-
-        para("Output:"),
-
-        verb("<p>I get 10 times more traffic from <a href=\"http://google.com/\"\n",
-             "title=\"Google\">Google</a> than from <a href=\"http://search.yahoo.com/\"\n",
-             "title=\"Yahoo Search\">Yahoo</a> or <a href=\"http://search.msn.com/\"\n",
-             "title=\"MSN Search\">MSN</a>.</p>\n"),
-
-        para("The title attribute is optional. Link names may contain letters,\n" +
-             "numbers and spaces, but are _not_ case sensitive:"),
-
-        verb("I start my morning with a cup of coffee and\n",
-             "[The New York Times][NY Times].\n",
-             "\n",
-             "[ny times]: http://www.nytimes.com/\n"),
-
-        para("Output:"),
-
-        verb("<p>I start my morning with a cup of coffee and\n",
-             "<a href=\"http://www.nytimes.com/\">The New York Times</a>.</p>\n"),
-
-        head(3, "Images"),
-
-        para("Image syntax is very much like link syntax."),
-
-        para("Inline (titles are optional):"),
-
-        verb("![alt text](/path/to/img.jpg \"Title\")\n"),
-
-        para("Reference-style:"),
-
-        verb("![alt text][id]\n",
-             "\n",
-             "[id]: /path/to/img.jpg \"Title\"\n"),
-
-        para("Both of the above examples produce the same output:"),
-
-        verb("<img src=\"/path/to/img.jpg\" alt=\"alt text\" title=\"Title\" />\n"),
-
-        head(3, "Code"),
-
-        para("In a regular paragraph, you can create code span by wrapping text in\n" +
-             "backtick quotes. Any ampersands (<code>&</code>) and angle brackets (<code><</code> or\n" +
-             "<code>></code>) will automatically be translated into HTML entities. This makes\n" +
-             "it easy to use Markdown to write about HTML example code:"),
-
-        verb(
-             "I strongly recommend against using any `<blink>` tags.\n",
-             "\n",
-             "I wish SmartyPants used named entities like `—`\n",
-             "instead of decimal-encoded entities like `—`.\n"),
-
-        para("Output:"),
-
-        verb("<p>I strongly recommend against using any\n",
-             "<code><blink></code> tags.</p>\n",
-             "\n",
-             "<p>I wish SmartyPants used named entities like\n",
-             "<code>&mdash;</code> instead of decimal-encoded\n",
-             "entities like <code>&#8212;</code>.</p>\n"),
-
-        para("To specify an entire block of pre-formatted code, indent every line of\n" +
-             "the block by 4 spaces or 1 tab. Just like with code spans, <code>&</code>, <code><</code>,\n" +
-             "and <code>></code> characters will be escaped automatically."),
-
-        para("Markdown:"),
-
-        verb("If you want your page to validate under XHTML 1.0 Strict,\n",
-             "you've got to put paragraph tags in your blockquotes:\n",
-             "\n",
-             "    <blockquote>\n",
-             "        <p>For example.</p>\n",
-             "    </blockquote>\n"),
-
-        para("Output:"),
-
-        verb("<p>If you want your page to validate under XHTML 1.0 Strict,\n",
-             "you've got to put paragraph tags in your blockquotes:</p>\n",
-             "\n",
-             "<pre><code><blockquote>\n",
-             "    <p>For example.</p>\n",
-             "</blockquote>\n",
-             "</code></pre>\n"))
-
-    assert_equal expected, doc
-  end
-
-  def test_markdown_documentation_syntax
-    input = File.read "#{MARKDOWN_TEST_PATH}/Markdown Documentation - Syntax.text"
-
-    doc = @parser.parse input
-
-    expected =
-      doc(
-        head(1, "Markdown: Syntax"),
-
-        raw(<<-RAW.chomp),
-<ul id="ProjectSubmenu">
-    <li><a href="/projects/markdown/" title="Markdown Project Page">Main</a></li>
-    <li><a href="/projects/markdown/basics" title="Markdown Basics">Basics</a></li>
-    <li><a class="selected" title="Markdown Syntax Documentation">Syntax</a></li>
-    <li><a href="/projects/markdown/license" title="Pricing and License Information">License</a></li>
-    <li><a href="/projects/markdown/dingus" title="Online Markdown Web Form">Dingus</a></li>
-</ul>
-        RAW
-
-        list(:BULLET,
-          item(nil,
-            para("{Overview}[#overview]"),
-            list(:BULLET,
-              item(nil,
-                para("{Philosophy}[#philosophy]")),
-              item(nil,
-                para("{Inline HTML}[#html]")),
-              item(nil,
-                para("{Automatic Escaping for Special Characters}[#autoescape]")))),
-          item(nil,
-            para("{Block Elements}[#block]"),
-            list(:BULLET,
-              item(nil,
-                para("{Paragraphs and Line Breaks}[#p]")),
-              item(nil,
-                para("{Headers}[#header]")),
-              item(nil,
-                para("{Blockquotes}[#blockquote]")),
-              item(nil,
-                para("{Lists}[#list]")),
-              item(nil,
-                para("{Code Blocks}[#precode]")),
-              item(nil,
-                para("{Horizontal Rules}[#hr]")))),
-          item(nil,
-            para("{Span Elements}[#span]"),
-            list(:BULLET,
-              item(nil,
-                para("{Links}[#link]")),
-              item(nil,
-                para("{Emphasis}[#em]")),
-              item(nil,
-                para("{Code}[#code]")),
-              item(nil,
-                para("{Images}[#img]")))),
-          item(nil,
-            para("{Miscellaneous}[#misc]"),
-            list(:BULLET,
-              item(nil,
-                para("{Backslash Escapes}[#backslash]")),
-              item(nil,
-                para("{Automatic Links}[#autolink]"))))),
-
-        para("<b>Note:</b> This document is itself written using Markdown; you\n" +
-             "can {see the source for it by adding '.text' to the URL}[/projects/markdown/syntax.text]."),
-
-        rule(1),
-
-        raw("<h2 id=\"overview\">Overview</h2>"),
-
-        raw("<h3 id=\"philosophy\">Philosophy</h3>"),
-
-        para("Markdown is intended to be as easy-to-read and easy-to-write as is feasible."),
-
-        para("Readability, however, is emphasized above all else. A Markdown-formatted\n" +
-             "document should be publishable as-is, as plain text, without looking\n" +
-             "like it's been marked up with tags or formatting instructions. While\n" +
-             "Markdown's syntax has been influenced by several existing text-to-HTML\n" +
-             "filters -- including {Setext}[http://docutils.sourceforge.net/mirror/setext.html], {atx}[http://www.aaronsw.com/2002/atx/], {Textile}[http://textism.com/tools/textile/], {reStructuredText}[http://docutils.sourceforge.net/rst.html],\n" +
-             "{Grutatext}[http://www.triptico.com/software/grutatxt.html], and {EtText}[http://ettext.taint.org/doc/] -- the single biggest source of\n" +
-             "inspiration for Markdown's syntax is the format of plain text email."),
-
-        para("To this end, Markdown's syntax is comprised entirely of punctuation\n" +
-             "characters, which punctuation characters have been carefully chosen so\n" +
-             "as to look like what they mean. E.g., asterisks around a word actually\n" +
-             "look like \*emphasis\*. Markdown lists look like, well, lists. Even\n" +
-             "blockquotes look like quoted passages of text, assuming you've ever\n" +
-             "used email."),
-
-        raw("<h3 id=\"html\">Inline HTML</h3>"),
-
-        para("Markdown's syntax is intended for one purpose: to be used as a\n" +
-             "format for _writing_ for the web."),
-
-        para("Markdown is not a replacement for HTML, or even close to it. Its\n" +
-             "syntax is very small, corresponding only to a very small subset of\n" +
-             "HTML tags. The idea is _not_ to create a syntax that makes it easier\n" +
-             "to insert HTML tags. In my opinion, HTML tags are already easy to\n" +
-             "insert. The idea for Markdown is to make it easy to read, write, and\n" +
-             "edit prose. HTML is a _publishing_ format; Markdown is a _writing_\n" +
-             "format. Thus, Markdown's formatting syntax only addresses issues that\n" +
-             "can be conveyed in plain text."),
-
-        para("For any markup that is not covered by Markdown's syntax, you simply\n" +
-             "use HTML itself. There's no need to preface it or delimit it to\n" +
-             "indicate that you're switching from Markdown to HTML; you just use\n" +
-             "the tags."),
-
-        para("The only restrictions are that block-level HTML elements -- e.g. <code><div></code>,\n" +
-             "<code><table></code>, <code><pre></code>, <code><p></code>, etc. -- must be separated from surrounding\n" +
-             "content by blank lines, and the start and end tags of the block should\n" +
-             "not be indented with tabs or spaces. Markdown is smart enough not\n" +
-             "to add extra (unwanted) <code><p></code> tags around HTML block-level tags."),
-
-        para("For example, to add an HTML table to a Markdown article:"),
-
-        verb("This is a regular paragraph.\n",
-             "\n",
-             "<table>\n",
-             "    <tr>\n",
-             "        <td>Foo</td>\n",
-             "    </tr>\n",
-             "</table>\n",
-             "\n",
-             "This is another regular paragraph.\n"),
-
-        para("Note that Markdown formatting syntax is not processed within block-level\n" +
-             "HTML tags. E.g., you can't use Markdown-style <code>*emphasis*</code> inside an\n" +
-             "HTML block."),
-
-        para("Span-level HTML tags -- e.g. <code><span></code>, <code><cite></code>, or <code><del></code> -- can be\n" +
-             "used anywhere in a Markdown paragraph, list item, or header. If you\n" +
-             "want, you can even use HTML tags instead of Markdown formatting; e.g. if\n" +
-             "you'd prefer to use HTML <code><a></code> or <code><img></code> tags instead of Markdown's\n" +
-             "link or image syntax, go right ahead."),
-
-        para("Unlike block-level HTML tags, Markdown syntax _is_ processed within\n" +
-             "span-level tags."),
-
-        raw("<h3 id=\"autoescape\">Automatic Escaping for Special Characters</h3>"),
-
-        para("In HTML, there are two characters that demand special treatment: <code><</code>\n" +
-             "and <code>&</code>. Left angle brackets are used to start tags; ampersands are\n" +
-             "used to denote HTML entities. If you want to use them as literal\n" +
-             "characters, you must escape them as entities, e.g. <code><</code>, and\n" +
-             "<code>&</code>."),
-
-        para("Ampersands in particular are bedeviling for web writers. If you want to\n" +
-             "write about 'AT&T', you need to write '<code>AT&T</code>'. You even need to\n" +
-             "escape ampersands within URLs. Thus, if you want to link to:"),
-
-        verb("http://images.google.com/images?num=30&q=larry+bird\n"),
-
-        para("you need to encode the URL as:"),
-
-        verb("http://images.google.com/images?num=30&q=larry+bird\n"),
-
-        para("in your anchor tag <code>href</code> attribute. Needless to say, this is easy to\n" +
-             "forget, and is probably the single most common source of HTML validation\n" +
-             "errors in otherwise well-marked-up web sites."),
-
-        para("Markdown allows you to use these characters naturally, taking care of\n" +
-             "all the necessary escaping for you. If you use an ampersand as part of\n" +
-             "an HTML entity, it remains unchanged; otherwise it will be translated\n" +
-             "into <code>&</code>."),
-
-        para("So, if you want to include a copyright symbol in your article, you can write:"),
-
-        verb("©\n"),
-
-        para("and Markdown will leave it alone. But if you write:"),
-
-        verb("AT&T\n"),
-
-        para("Markdown will translate it to:"),
-
-        verb("AT&T\n"),
-
-        para("Similarly, because Markdown supports {inline HTML}[#html], if you use\n" +
-             "angle brackets as delimiters for HTML tags, Markdown will treat them as\n" +
-             "such. But if you write:"),
-
-        verb("4 < 5\n"),
-
-        para("Markdown will translate it to:"),
-
-        verb("4 < 5\n"),
-
-        para("However, inside Markdown code spans and blocks, angle brackets and\n" +
-             "ampersands are _always_ encoded automatically. This makes it easy to use\n" +
-             "Markdown to write about HTML code. (As opposed to raw HTML, which is a\n" +
-             "terrible format for writing about HTML syntax, because every single <code><</code>\n" +
-             "and <code>&</code> in your example code needs to be escaped.)"),
-
-        rule(1),
-
-        raw("<h2 id=\"block\">Block Elements</h2>"),
-
-        raw("<h3 id=\"p\">Paragraphs and Line Breaks</h3>"),
-
-        para("A paragraph is simply one or more consecutive lines of text, separated\n" +
-             "by one or more blank lines. (A blank line is any line that looks like a\n" +
-             "blank line -- a line containing nothing but spaces or tabs is considered\n" +
-             "blank.) Normal paragraphs should not be intended with spaces or tabs."),
-
-        para("The implication of the \"one or more consecutive lines of text\" rule is\n" +
-             "that Markdown supports \"hard-wrapped\" text paragraphs. This differs\n" +
-             "significantly from most other text-to-HTML formatters (including Movable\n" +
-             "Type's \"Convert Line Breaks\" option) which translate every line break\n" +
-             "character in a paragraph into a <code><br /></code> tag."),
-
-        para("When you _do_ want to insert a <code><br /></code> break tag using Markdown, you\n" +
-             "end a line with two or more spaces, then type return."),
-
-        para("Yes, this takes a tad more effort to create a <code><br /></code>, but a simplistic\n" +
-             "\"every line break is a <code><br /></code>\" rule wouldn't work for Markdown.\n" +
-             "Markdown's email-style {blockquoting}[#blockquote] and multi-paragraph {list items}[#list]\n" +
-             "work best -- and look better -- when you format them with hard breaks."),
-
-        raw("<h3 id=\"header\">Headers</h3>"),
-
-        para("Markdown supports two styles of headers, {Setext}[http://docutils.sourceforge.net/mirror/setext.html] and {atx}[http://www.aaronsw.com/2002/atx/]."),
-
-        para("Setext-style headers are \"underlined\" using equal signs (for first-level\n" +
-             "headers) and dashes (for second-level headers). For example:"),
-
-        verb("This is an H1\n",
-             "=============\n",
-             "\n",
-             "This is an H2\n",
-             "-------------\n"),
-
-        para("Any number of underlining <code>=</code>'s or <code>-</code>'s will work."),
-
-        para("Atx-style headers use 1-6 hash characters at the start of the line,\n" +
-             "corresponding to header levels 1-6. For example:"),
-
-        verb("# This is an H1\n",
-             "\n",
-             "## This is an H2\n",
-             "\n",
-             "###### This is an H6\n"),
-
-        para("Optionally, you may \"close\" atx-style headers. This is purely\n" +
-             "cosmetic -- you can use this if you think it looks better. The\n" +
-             "closing hashes don't even need to match the number of hashes\n" +
-             "used to open the header. (The number of opening hashes\n" +
-             "determines the header level.) :"),
-
-        verb("# This is an H1 #\n",
-             "\n",
-             "## This is an H2 ##\n",
-             "\n",
-             "### This is an H3 ######\n"),
-
-        raw("<h3 id=\"blockquote\">Blockquotes</h3>"),
-
-        para(
-             "Markdown uses email-style <code>></code> characters for blockquoting. If you're\n" +
-             "familiar with quoting passages of text in an email message, then you\n" +
-             "know how to create a blockquote in Markdown. It looks best if you hard\n" +
-             "wrap the text and put a <code>></code> before every line:"),
-
-        verb("> This is a blockquote with two paragraphs. Lorem ipsum dolor sit amet,\n",
-             "> consectetuer adipiscing elit. Aliquam hendrerit mi posuere lectus.\n",
-             "> Vestibulum enim wisi, viverra nec, fringilla in, laoreet vitae, risus.\n",
-             "> \n",
-             "> Donec sit amet nisl. Aliquam semper ipsum sit amet velit. Suspendisse\n",
-             "> id sem consectetuer libero luctus adipiscing.\n"),
-
-        para("Markdown allows you to be lazy and only put the <code>></code> before the first\n" +
-             "line of a hard-wrapped paragraph:"),
-
-        verb("> This is a blockquote with two paragraphs. Lorem ipsum dolor sit amet,\n",
-             "consectetuer adipiscing elit. Aliquam hendrerit mi posuere lectus.\n",
-             "Vestibulum enim wisi, viverra nec, fringilla in, laoreet vitae, risus.\n",
-             "\n",
-             "> Donec sit amet nisl. Aliquam semper ipsum sit amet velit. Suspendisse\n",
-             "id sem consectetuer libero luctus adipiscing.\n"),
-
-        para("Blockquotes can be nested (i.e. a blockquote-in-a-blockquote) by\n" +
-             "adding additional levels of <code>></code>:"),
-
-        verb("> This is the first level of quoting.\n",
-             ">\n",
-             "> > This is nested blockquote.\n",
-             ">\n",
-             "> Back to the first level.\n"),
-
-        para("Blockquotes can contain other Markdown elements, including headers, lists,\n" +
-             "and code blocks:"),
-
-        verb("> ## This is a header.\n",
-             "> \n",
-             "> 1.   This is the first list item.\n",
-             "> 2.   This is the second list item.\n",
-             "> \n",
-             "> Here's some example code:\n",
-             "> \n",
-             ">     return shell_exec(\"echo $input | $markdown_script\");\n"),
-
-        para("Any decent text editor should make email-style quoting easy. For\n" +
-             "example, with BBEdit, you can make a selection and choose Increase\n" +
-             "Quote Level from the Text menu."),
-
-        raw("<h3 id=\"list\">Lists</h3>"),
-
-        para("Markdown supports ordered (numbered) and unordered (bulleted) lists."),
-
-        para("Unordered lists use asterisks, pluses, and hyphens -- interchangeably\n" +
-             "-- as list markers:"),
-
-        verb("*   Red\n",
-             "*   Green\n",
-             "*   Blue\n"),
-
-        para("is equivalent to:"),
-
-        verb("+   Red\n",
-             "+   Green\n",
-             "+   Blue\n"),
-
-        para("and:"),
-
-        verb("-   Red\n",
-             "-   Green\n",
-             "-   Blue\n"),
-
-        para("Ordered lists use numbers followed by periods:"),
-
-        verb("1.  Bird\n",
-             "2.  McHale\n",
-             "3.  Parish\n"),
-
-        para("It's important to note that the actual numbers you use to mark the\n" +
-             "list have no effect on the HTML output Markdown produces. The HTML\n" +
-             "Markdown produces from the above list is:"),
-
-        verb("<ol>\n",
-             "<li>Bird</li>\n",
-             "<li>McHale</li>\n",
-             "<li>Parish</li>\n",
-             "</ol>\n"),
-
-        para("If you instead wrote the list in Markdown like this:"),
-
-        verb("1.  Bird\n",
-             "1.  McHale\n",
-             "1.  Parish\n"),
-
-        para("or even:"),
-
-        verb("3. Bird\n",
-             "1. McHale\n",
-             "8. Parish\n"),
-
-        para("you'd get the exact same HTML output. The point is, if you want to,\n" +
-             "you can use ordinal numbers in your ordered Markdown lists, so that\n" +
-             "the numbers in your source match the numbers in your published HTML.\n" +
-             "But if you want to be lazy, you don't have to."),
-
-        para("If you do use lazy list numbering, however, you should still start the\n" +
-             "list with the number 1. At some point in the future, Markdown may support\n" +
-             "starting ordered lists at an arbitrary number."),
-
-        para("List markers typically start at the left margin, but may be indented by\n" +
-             "up to three spaces. List markers must be followed by one or more spaces\n" +
-             "or a tab."),
-
-        para("To make lists look nice, you can wrap items with hanging indents:"),
-
-        verb("*   Lorem ipsum dolor sit amet, consectetuer adipiscing elit.\n",
-             "    Aliquam hendrerit mi posuere lectus. Vestibulum enim wisi,\n",
-             "    viverra nec, fringilla in, laoreet vitae, risus.\n",
-             "*   Donec sit amet nisl. Aliquam semper ipsum sit amet velit.\n",
-             "    Suspendisse id sem consectetuer libero luctus adipiscing.\n"),
-
-        para("But if you want to be lazy, you don't have to:"),
-
-        verb("*   Lorem ipsum dolor sit amet, consectetuer adipiscing elit.\n",
-             "Aliquam hendrerit mi posuere lectus. Vestibulum enim wisi,\n",
-             "viverra nec, fringilla in, laoreet vitae, risus.\n",
-             "*   Donec sit amet nisl. Aliquam semper ipsum sit amet velit.\n",
-             "Suspendisse id sem consectetuer libero luctus adipiscing.\n"),
-
-        para("If list items are separated by blank lines, Markdown will wrap the\n" +
-             "items in <code><p></code> tags in the HTML output. For example, this input:"),
-
-        verb("*   Bird\n",
-             "*   Magic\n"),
-
-        para("will turn into:"),
-
-        verb("<ul>\n",
-             "<li>Bird</li>\n",
-             "<li>Magic</li>\n",
-             "</ul>\n"),
-
-        para("But this:"),
-
-        verb("*   Bird\n",
-             "\n",
-             "*   Magic\n"),
-
-        para("will turn into:"),
-
-        verb("<ul>\n",
-             "<li><p>Bird</p></li>\n",
-             "<li><p>Magic</p></li>\n",
-             "</ul>\n"),
-
-        para("List items may consist of multiple paragraphs. Each subsequent\n" +
-             "paragraph in a list item must be intended by either 4 spaces\n" +
-             "or one tab:"),
-
-        verb("1.  This is a list item with two paragraphs. Lorem ipsum dolor\n",
-             "    sit amet, consectetuer adipiscing elit. Aliquam hendrerit\n",
-             "    mi posuere lectus.\n",
-             "\n",
-             "    Vestibulum enim wisi, viverra nec, fringilla in, laoreet\n",
-             "    vitae, risus. Donec sit amet nisl. Aliquam semper ipsum\n",
-             "    sit amet velit.\n",
-             "\n",
-             "2.  Suspendisse id sem consectetuer libero luctus adipiscing.\n"),
-
-        para("It looks nice if you indent every line of the subsequent\n" +
-             "paragraphs, but here again, Markdown will allow you to be\n" +
-             "lazy:"),
-
-        verb("*   This is a list item with two paragraphs.\n",
-             "\n",
-             "    This is the second paragraph in the list item. You're\n",
-             "only required to indent the first line. Lorem ipsum dolor\n",
-             "sit amet, consectetuer adipiscing elit.\n",
-             "\n",
-             "*   Another item in the same list.\n"),
-
-        para("To put a blockquote within a list item, the blockquote's <code>></code>\n" +
-             "delimiters need to be indented:"),
-
-        verb("*   A list item with a blockquote:\n",
-             "\n",
-             "    > This is a blockquote\n",
-             "    > inside a list item.\n"),
-
-        para(
-             "To put a code block within a list item, the code block needs\n" +
-             "to be indented _twice_ -- 8 spaces or two tabs:"),
-
-        verb("*   A list item with a code block:\n",
-             "\n",
-             "        <code goes here>\n"),
-
-        para("It's worth noting that it's possible to trigger an ordered list by\n" +
-             "accident, by writing something like this:"),
-
-        verb("1986. What a great season.\n"),
-
-        para("In other words, a <em>number-period-space</em> sequence at the beginning of a\n" +
-             "line. To avoid this, you can backslash-escape the period:"),
-
-        verb("1986\\. What a great season.\n"),
-
-        raw("<h3 id=\"precode\">Code Blocks</h3>"),
-
-        para("Pre-formatted code blocks are used for writing about programming or\n" +
-             "markup source code. Rather than forming normal paragraphs, the lines\n" +
-             "of a code block are interpreted literally. Markdown wraps a code block\n" +
-             "in both <code><pre></code> and <code><code></code> tags."),
-
-        para("To produce a code block in Markdown, simply indent every line of the\n" +
-             "block by at least 4 spaces or 1 tab. For example, given this input:"),
-
-        verb("This is a normal paragraph:\n",
-             "\n",
-             "    This is a code block.\n"),
-
-        para("Markdown will generate:"),
-
-        verb("<p>This is a normal paragraph:</p>\n",
-             "\n",
-             "<pre><code>This is a code block.\n",
-             "</code></pre>\n"),
-
-        para("One level of indentation -- 4 spaces or 1 tab -- is removed from each\n" +
-             "line of the code block. For example, this:"),
-
-        verb("Here is an example of AppleScript:\n",
-             "\n",
-             "    tell application \"Foo\"\n",
-             "        beep\n",
-             "    end tell\n"),
-
-        para("will turn into:"),
-
-        verb("<p>Here is an example of AppleScript:</p>\n",
-             "\n",
-             "<pre><code>tell application \"Foo\"\n",
-             "    beep\n",
-             "end tell\n",
-             "</code></pre>\n"),
-
-        para("A code block continues until it reaches a line that is not indented\n" +
-             "(or the end of the article)."),
-
-        para("Within a code block, ampersands (<code>&</code>) and angle brackets (<code><</code> and <code>></code>)\n" +
-             "are automatically converted into HTML entities. This makes it very\n" +
-             "easy to include example HTML source code using Markdown -- just paste\n" +
-             "it and indent it, and Markdown will handle the hassle of encoding the\n" +
-             "ampersands and angle brackets. For example, this:"),
-
-        verb("    <div class=\"footer\">\n",
-             "        © 2004 Foo Corporation\n",
-             "    </div>\n"),
-
-        para("will turn into:"),
-
-        verb("<pre><code><div class=\"footer\">\n",
-             "    &copy; 2004 Foo Corporation\n",
-             "</div>\n",
-             "</code></pre>\n"),
-
-        para("Regular Markdown syntax is not processed within code blocks. E.g.,\n" +
-             "asterisks are just literal asterisks within a code block. This means\n" +
-             "it's also easy to use Markdown to write about Markdown's own syntax."),
-
-        raw("<h3 id=\"hr\">Horizontal Rules</h3>"),
-
-        para("You can produce a horizontal rule tag (<code><hr /></code>) by placing three or\n" +
-             "more hyphens, asterisks, or underscores on a line by themselves. If you\n" +
-             "wish, you may use spaces between the hyphens or asterisks. Each of the\n" +
-             "following lines will produce a horizontal rule:"),
-
-        verb("* * *\n",
-             "\n",
-             "***\n",
-             "\n",
-             "*****\n",
-             "\n",
-             "- - -\n",
-             "\n",
-             "---------------------------------------\n",
-             "\n",
-             "_ _ _\n"),
-
-        rule(1),
-
-        raw("<h2 id=\"span\">Span Elements</h2>"),
-
-        raw("<h3 id=\"link\">Links</h3>"),
-
-        para("Markdown supports two style of links: _inline_ and _reference_."),
-
-        para("In both styles, the link text is delimited by [square brackets]."),
-
-        para("To create an inline link, use a set of regular parentheses immediately\n" +
-             "after the link text's closing square bracket. Inside the parentheses,\n" +
-             "put the URL where you want the link to point, along with an _optional_\n" +
-             "title for the link, surrounded in quotes. For example:"),
-
-        verb("This is [an example](http://example.com/ \"Title\") inline link.\n",
-             "\n",
-             "[This link](http://example.net/) has no title attribute.\n"),
-
-        para("Will produce:"),
-
-        verb("<p>This is <a href=\"http://example.com/\" title=\"Title\">\n",
-             "an example</a> inline link.</p>\n",
-             "\n",
-             "<p><a href=\"http://example.net/\">This link</a> has no\n",
-             "title attribute.</p>\n"),
-
-        para("If you're referring to a local resource on the same server, you can\n" +
-             "use relative paths:"),
-
-        verb("See my [About](/about/) page for details.\n"),
-
-        para("Reference-style links use a second set of square brackets, inside\n" +
-             "which you place a label of your choosing to identify the link:"),
-
-        verb("This is [an example][id] reference-style link.\n"),
-
-        para("You can optionally use a space to separate the sets of brackets:"),
-
-        verb("This is [an example] [id] reference-style link.\n"),
-
-        para("Then, anywhere in the document, you define your link label like this,\n" +
-             "on a line by itself:"),
-
-        verb("[id]: http://example.com/  \"Optional Title Here\"\n"),
-
-        para("That is:"),
-
-        list(:BULLET,
-          item(nil,
-            para("Square brackets containing the link identifier (optionally\n" +
-                 "indented from the left margin using up to three spaces);")),
-          item(nil,
-            para("followed by a colon;")),
-          item(nil,
-            para("followed by one or more spaces (or tabs);")),
-          item(nil,
-            para("followed by the URL for the link;")),
-          item(nil,
-            para("optionally followed by a title attribute for the link, enclosed\n" +
-                 "in double or single quotes."))),
-
-        para("The link URL may, optionally, be surrounded by angle brackets:"),
-
-        verb("[id]: <http://example.com/>  \"Optional Title Here\"\n"),
-
-        para("You can put the title attribute on the next line and use extra spaces\n" +
-             "or tabs for padding, which tends to look better with longer URLs:"),
-
-        verb("[id]: http://example.com/longish/path/to/resource/here\n",
-             "    \"Optional Title Here\"\n"),
-
-        para("Link definitions are only used for creating links during Markdown\n" +
-             "processing, and are stripped from your document in the HTML output."),
-
-        para("Link definition names may consist of letters, numbers, spaces, and punctuation -- but they are _not_ case sensitive. E.g. these two links:"),
-
-        verb("[link text][a]\n",
-             "[link text][A]\n"),
-
-        para("are equivalent."),
-
-        para("The <em>implicit link name</em> shortcut allows you to omit the name of the\n" +
-             "link, in which case the link text itself is used as the name.\n" +
-             "Just use an empty set of square brackets -- e.g., to link the word\n" +
-             "\"Google\" to the google.com web site, you could simply write:"),
-
-        verb("[Google][]\n"),
-
-        para("And then define the link:"),
-
-        verb("[Google]: http://google.com/\n"),
-
-        para("Because link names may contain spaces, this shortcut even works for\n" +
-            "multiple words in the link text:"),
-
-
-        verb("Visit [Daring Fireball][] for more information.\n"),
-
-        para("And then define the link:"),
-
-        verb("[Daring Fireball]: http://daringfireball.net/\n"),
-
-        para("Link definitions can be placed anywhere in your Markdown document. I\n" +
-             "tend to put them immediately after each paragraph in which they're\n" +
-             "used, but if you want, you can put them all at the end of your\n" +
-             "document, sort of like footnotes."),
-
-        para("Here's an example of reference links in action:"),
-
-        verb("I get 10 times more traffic from [Google] [1] than from\n",
-             "[Yahoo] [2] or [MSN] [3].\n",
-             "\n",
-             "  [1]: http://google.com/        \"Google\"\n",
-             "  [2]: http://search.yahoo.com/  \"Yahoo Search\"\n",
-             "  [3]: http://search.msn.com/    \"MSN Search\"\n"),
-
-        para("Using the implicit link name shortcut, you could instead write:"),
-
-        verb("I get 10 times more traffic from [Google][] than from\n",
-             "[Yahoo][] or [MSN][].\n",
-             "\n",
-             "  [google]: http://google.com/        \"Google\"\n",
-             "  [yahoo]:  http://search.yahoo.com/  \"Yahoo Search\"\n",
-             "  [msn]:    http://search.msn.com/    \"MSN Search\"\n"),
-
-        para("Both of the above examples will produce the following HTML output:"),
-
-        verb("<p>I get 10 times more traffic from <a href=\"http://google.com/\"\n",
-             "title=\"Google\">Google</a> than from\n",
-             "<a href=\"http://search.yahoo.com/\" title=\"Yahoo Search\">Yahoo</a>\n",
-             "or <a href=\"http://search.msn.com/\" title=\"MSN Search\">MSN</a>.</p>\n"),
-
-        para("For comparison, here is the same paragraph written using\n" +
-             "Markdown's inline link style:"),
-
-        verb("I get 10 times more traffic from [Google](http://google.com/ \"Google\")\n",
-             "than from [Yahoo](http://search.yahoo.com/ \"Yahoo Search\") or\n",
-             "[MSN](http://search.msn.com/ \"MSN Search\").\n"),
-
-        para("The point of reference-style links is not that they're easier to\n" +
-             "write. The point is that with reference-style links, your document\n" +
-             "source is vastly more readable. Compare the above examples: using\n" +
-             "reference-style links, the paragraph itself is only 81 characters\n" +
-             "long; with inline-style links, it's 176 characters; and as raw HTML,\n" +
-             "it's 234 characters. In the raw HTML, there's more markup than there\n" +
-             "is text."),
-
-        para("With Markdown's reference-style links, a source document much more\n" +
-             "closely resembles the final output, as rendered in a browser. By\n" +
-             "allowing you to move the markup-related metadata out of the paragraph,\n" +
-             "you can add links without interrupting the narrative flow of your\n" +
-             "prose."),
-
-        raw("<h3 id=\"em\">Emphasis</h3>"),
-
-        para("Markdown treats asterisks (<code>*</code>) and underscores (<code>_</code>) as indicators of\n" +
-             "emphasis. Text wrapped with one <code>*</code> or <code>_</code> will be wrapped with an\n" +
-             "HTML <code><em></code> tag; double <code>*</code>'s or <code>_</code>'s will be wrapped with an HTML\n" +
-             "<code><strong></code> tag. E.g., this input:"),
-
-        verb("*single asterisks*\n",
-             "\n",
-             "_single underscores_\n",
-             "\n",
-             "**double asterisks**\n",
-             "\n",
-             "__double underscores__\n"),
-
-        para("will produce:"),
-
-        verb("<em>single asterisks</em>\n",
-             "\n",
-             "<em>single underscores</em>\n",
-             "\n",
-             "<strong>double asterisks</strong>\n",
-             "\n",
-             "<strong>double underscores</strong>\n"),
-
-        para("You can use whichever style you prefer; the lone restriction is that\n" +
-             "the same character must be used to open and close an emphasis span."),
-
-        para("Emphasis can be used in the middle of a word:"),
-
-        verb("un*fucking*believable\n"),
-
-        para("But if you surround an <code>*</code> or <code>_</code> with spaces, it'll be treated as a\n" +
-             "literal asterisk or underscore."),
-
-        para("To produce a literal asterisk or underscore at a position where it\n" +
-             "would otherwise be used as an emphasis delimiter, you can backslash\n" +
-             "escape it:"),
-
-        verb("\\*this text is surrounded by literal asterisks\\*\n"),
-
-        raw("<h3 id=\"code\">Code</h3>"),
-
-        para("To indicate a span of code, wrap it with backtick quotes (<code>`</code>).\n" +
-             "Unlike a pre-formatted code block, a code span indicates code within a\n" +
-             "normal paragraph. For example:"),
-
-        verb("Use the `printf()` function.\n"),
-
-        para("will produce:"),
-
-        verb("<p>Use the <code>printf()</code> function.</p>\n"),
-
-        para("To include a literal backtick character within a code span, you can use\n" +
-             "multiple backticks as the opening and closing delimiters:"),
-
-        verb("``There is a literal backtick (`) here.``\n"),
-
-        para("which will produce this:"),
-
-        verb("<p><code>There is a literal backtick (`) here.</code></p>\n"),
-
-        para("The backtick delimiters surrounding a code span may include spaces --\n" +
-             "one after the opening, one before the closing. This allows you to place\n" +
-             "literal backtick characters at the beginning or end of a code span:"),
-
-        verb("A single backtick in a code span: `` ` ``\n",
-             "\n",
-             "A backtick-delimited string in a code span: `` `foo` ``\n"),
-
-        para("will produce:"),
-
-        verb("<p>A single backtick in a code span: <code>`</code></p>\n",
-             "\n",
-             "<p>A backtick-delimited string in a code span: <code>`foo`</code></p>\n"),
-
-        para("With a code span, ampersands and angle brackets are encoded as HTML\n" +
-             "entities automatically, which makes it easy to include example HTML\n" +
-             "tags. Markdown will turn this:"),
-
-        verb("Please don't use any `<blink>` tags.\n"),
-
-        para("into:"),
-
-        verb("<p>Please don't use any <code><blink></code> tags.</p>\n"),
-
-        para("You can write this:"),
-
-        verb("`—` is the decimal-encoded equivalent of `—`.\n"),
-
-        para("to produce:"),
-
-        verb( "<p><code>&#8212;</code> is the decimal-encoded\n",
-             "equivalent of <code>&mdash;</code>.</p>\n"),
-
-        raw("<h3 id=\"img\">Images</h3>"),
-
-        para("Admittedly, it's fairly difficult to devise a \"natural\" syntax for\n" +
-             "placing images into a plain text document format."),
-
-        para("Markdown uses an image syntax that is intended to resemble the syntax\n" +
-             "for links, allowing for two styles: _inline_ and _reference_."),
-
-        para("Inline image syntax looks like this:"),
-
-        verb("![Alt text](/path/to/img.jpg)\n",
-             "\n",
-             "![Alt text](/path/to/img.jpg \"Optional title\")\n"),
-
-        para("That is:"),
-
-        list(:BULLET,
-          item(nil,
-            para("An exclamation mark: <code>!</code>;")),
-          item(nil,
-            para("followed by a set of square brackets, containing the <code>alt</code>\n" +
-                 "attribute text for the image;")),
-          item(nil,
-            para("followed by a set of parentheses, containing the URL or path to\n" +
-                 "the image, and an optional <code>title</code> attribute enclosed in double\n" +
-                 "or single quotes."))),
-
-        para("Reference-style image syntax looks like this:"),
-
-        verb("![Alt text][id]\n"),
-
-        para("Where \"id\" is the name of a defined image reference. Image references\n" +
-             "are defined using syntax identical to link references:"),
-
-        verb("[id]: url/to/image  \"Optional title attribute\"\n"),
-
-        para("As of this writing, Markdown has no syntax for specifying the\n" +
-             "dimensions of an image; if this is important to you, you can simply\n" +
-             "use regular HTML <code><img></code> tags."),
-
-        rule(1),
-
-        raw("<h2 id=\"misc\">Miscellaneous</h2>"),
-
-        raw("<h3 id=\"autolink\">Automatic Links</h3>"),
-
-        para("Markdown supports a shortcut style for creating \"automatic\" links for URLs and email addresses: simply surround the URL or email address with angle brackets. What this means is that if you want to show the actual text of a URL or email address, and also have it be a clickable link, you can do this:"),
-
-        verb("<http://example.com/>\n"),
-
-        para("Markdown will turn this into:"),
-
-        verb("<a href=\"http://example.com/\">http://example.com/</a>\n"),
-
-        para("Automatic links for email addresses work similarly, except that\n" +
-             "Markdown will also perform a bit of randomized decimal and hex\n" +
-             "entity-encoding to help obscure your address from address-harvesting\n" +
-             "spambots. For example, Markdown will turn this:"),
-
-        verb("<address@example.com>\n"),
-
-        para("into something like this:"),
-
-        verb("<a href=\"mailto:addre\n",
-             "ss@example.co\n",
-             "m\">address@exa\n",
-             "mple.com</a>\n"),
-
-        para("which will render in a browser as a clickable link to \"address@example.com\"."),
-
-        para("(This sort of entity-encoding trick will indeed fool many, if not\n" +
-               "most, address-harvesting bots, but it definitely won't fool all of\n" +
-               "them. It's better than nothing, but an address published in this way\n" +
-               "will probably eventually start receiving spam.)"),
-
-        raw("<h3 id=\"backslash\">Backslash Escapes</h3>"),
-
-        para("Markdown allows you to use backslash escapes to generate literal\n" +
-             "characters which would otherwise have special meaning in Markdown's\n" +
-             "formatting syntax. For example, if you wanted to surround a word with\n" +
-             "literal asterisks (instead of an HTML <code><em></code> tag), you can backslashes\n" +
-             "before the asterisks, like this:"),
-
-        verb("\\*literal asterisks\\*\n"),
-
-        para("Markdown provides backslash escapes for the following characters:"),
-
-        verb("\\   backslash\n",
-             "`   backtick\n",
-             "*   asterisk\n",
-             "_   underscore\n",
-             "{}  curly braces\n",
-             "[]  square brackets\n",
-             "()  parentheses\n",
-             "#   hash mark\n",
-             "+	plus sign\n",
-             "-	minus sign (hyphen)\n",
-             ".   dot\n",
-             "!   exclamation mark\n"))
-
-    assert_equal expected, doc
-  end
-
-  def test_nested_blockquotes
-    input = File.read "#{MARKDOWN_TEST_PATH}/Nested blockquotes.text"
-
-    doc = @parser.parse input
-
-    expected =
-      doc(
-        block(
-          para("foo"),
-          block(
-            para("bar")),
-          para("foo")))
-
-    assert_equal expected, doc
-  end
-
-  def test_ordered_and_unordered_lists
-    input = File.read "#{MARKDOWN_TEST_PATH}/Ordered and unordered lists.text"
-
-    doc = @parser.parse input
-
-    expected =
-      doc(
-        head(2, 'Unordered'),
-
-        para('Asterisks tight:'),
-        list(:BULLET,
-          item(nil, para("asterisk 1")),
-          item(nil, para("asterisk 2")),
-          item(nil, para("asterisk 3"))),
-        para('Asterisks loose:'),
-        list(:BULLET,
-          item(nil, para("asterisk 1")),
-          item(nil, para("asterisk 2")),
-          item(nil, para("asterisk 3"))),
-
-        rule(1),
-
-        para("Pluses tight:"),
-        list(:BULLET,
-          item(nil, para("Plus 1")),
-          item(nil, para("Plus 2")),
-          item(nil, para("Plus 3"))),
-        para("Pluses loose:"),
-        list(:BULLET,
-          item(nil, para("Plus 1")),
-          item(nil, para("Plus 2")),
-          item(nil, para("Plus 3"))),
-
-        rule(1),
-
-        para("Minuses tight:"),
-        list(:BULLET,
-          item(nil, para("Minus 1")),
-          item(nil, para("Minus 2")),
-          item(nil, para("Minus 3"))),
-        para("Minuses loose:"),
-        list(:BULLET,
-          item(nil, para("Minus 1")),
-          item(nil, para("Minus 2")),
-          item(nil, para("Minus 3"))),
-
-        head(2, "Ordered"),
-
-        para("Tight:"),
-        list(:NUMBER,
-          item(nil, para("First")),
-          item(nil, para("Second")),
-          item(nil, para("Third"))),
-        para("and:"),
-        list(:NUMBER,
-          item(nil, para("One")),
-          item(nil, para("Two")),
-          item(nil, para("Three"))),
-
-        para("Loose using tabs:"),
-        list(:NUMBER,
-          item(nil, para("First")),
-          item(nil, para("Second")),
-          item(nil, para("Third"))),
-        para("and using spaces:"),
-        list(:NUMBER,
-          item(nil, para("One")),
-          item(nil, para("Two")),
-          item(nil, para("Three"))),
-
-        para("Multiple paragraphs:"),
-        list(:NUMBER,
-          item(nil,
-            para("Item 1, graf one."),
-            para("Item 2. graf two. The quick brown fox " +
-                 "jumped over the lazy dog's\nback.")),
-          item(nil, para("Item 2.")),
-          item(nil, para("Item 3."))),
-
-        head(2, "Nested"),
-        list(:BULLET,
-          item(nil,
-            para("Tab"),
-            list(:BULLET,
-              item(nil,
-                para("Tab"),
-                list(:BULLET,
-                  item(nil,
-                    para("Tab"))))))),
-
-        para("Here's another:"),
-        list(:NUMBER,
-          item(nil, para("First")),
-          item(nil, para("Second:"),
-            list(:BULLET,
-              item(nil, para("Fee")),
-              item(nil, para("Fie")),
-              item(nil, para("Foe")))),
-          item(nil, para("Third"))),
-
-        para("Same thing but with paragraphs:"),
-        list(:NUMBER,
-          item(nil, para("First")),
-          item(nil, para("Second:"),
-            list(:BULLET,
-              item(nil, para("Fee")),
-              item(nil, para("Fie")),
-              item(nil, para("Foe")))),
-          item(nil, para("Third"))),
-
-        para("This was an error in Markdown 1.0.1:"),
-        list(:BULLET,
-          item(nil,
-            para("this"),
-            list(:BULLET,
-              item(nil, para("sub"))),
-            para("that"))))
-
-    assert_equal expected, doc
-  end
-
-  def test_strong_and_em_together
-    input = File.read "#{MARKDOWN_TEST_PATH}/Strong and em together.text"
-
-    doc = @parser.parse input
-
-    expected =
-      doc(
-        para("<b><em>This is strong and em.</em></b>"),
-        para("So is <b>_this_</b> word."),
-        para("<b><em>This is strong and em.</em></b>"),
-        para("So is <b>_this_</b> word."))
-
-    assert_equal expected, doc
-  end
-
-  def test_tabs
-    input = File.read "#{MARKDOWN_TEST_PATH}/Tabs.text"
-
-    doc = @parser.parse input
-
-    expected =
-      doc(
-        list(:BULLET,
-          item(nil,
-            para("this is a list item\nindented with tabs")),
-          item(nil,
-            para("this is a list item\nindented with spaces"))),
-
-        para("Code:"),
-
-        verb("this code block is indented by one tab\n"),
-
-        para("And:"),
-
-        verb("\tthis code block is indented by two tabs\n"),
-
-        para("And:"),
-
-        verb(
-          "+\tthis is an example list item\n",
-          "\tindented with tabs\n",
-          "\n",
-          "+   this is an example list item\n",
-          "    indented with spaces\n"))
-
-    assert_equal expected, doc
-  end
-
-  def test_tidiness
-    input = File.read "#{MARKDOWN_TEST_PATH}/Tidiness.text"
-
-    doc = @parser.parse input
-
-    expected =
-      doc(
-        block(
-          para("A list within a blockquote:"),
-          list(:BULLET,
-            item(nil, para("asterisk 1")),
-            item(nil, para("asterisk 2")),
-            item(nil, para("asterisk 3")))))
-
-    assert_equal expected, doc
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc/rdoc_markup_attribute_manager_test.rb b/test/mri/rdoc/rdoc/rdoc_markup_attribute_manager_test.rb
deleted file mode 100644
index 05bd9519902..00000000000
--- a/test/mri/rdoc/rdoc/rdoc_markup_attribute_manager_test.rb
+++ /dev/null
@@ -1,395 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocMarkupAttributeManagerTest < RDoc::TestCase
-
-  def setup
-    super
-
-    @am = RDoc::Markup::AttributeManager.new
-
-    @bold_on  = @am.changed_attribute_by_name([], [:BOLD])
-    @bold_off = @am.changed_attribute_by_name([:BOLD], [])
-
-    @tt_on    = @am.changed_attribute_by_name([], [:TT])
-    @tt_off   = @am.changed_attribute_by_name([:TT], [])
-
-    @em_on    = @am.changed_attribute_by_name([], [:EM])
-    @em_off   = @am.changed_attribute_by_name([:EM], [])
-
-    @bold_em_on   = @am.changed_attribute_by_name([], [:BOLD] | [:EM])
-    @bold_em_off  = @am.changed_attribute_by_name([:BOLD] | [:EM], [])
-
-    @em_then_bold = @am.changed_attribute_by_name([:EM], [:EM] | [:BOLD])
-
-    @em_to_bold   = @am.changed_attribute_by_name([:EM], [:BOLD])
-
-    @am.add_word_pair("{", "}", :WOMBAT)
-    @wombat_on    = @am.changed_attribute_by_name([], [:WOMBAT])
-    @wombat_off   = @am.changed_attribute_by_name([:WOMBAT], [])
-
-    @klass = RDoc::Markup::AttributeManager
-    @formatter = RDoc::Markup::Formatter.new @rdoc.options
-    @formatter.add_tag :BOLD, '<B>', '</B>'
-    @formatter.add_tag :EM, '<EM>', '</EM>'
-    @formatter.add_tag :TT, '<CODE>', '</CODE>'
-  end
-
-  def crossref(text)
-    crossref_bitmap = @am.attributes.bitmap_for(:_REGEXP_HANDLING_) |
-                      @am.attributes.bitmap_for(:CROSSREF)
-
-    [ @am.changed_attribute_by_name([], [:CROSSREF, :_REGEXP_HANDLING_]),
-      RDoc::Markup::RegexpHandling.new(crossref_bitmap, text),
-      @am.changed_attribute_by_name([:CROSSREF, :_REGEXP_HANDLING_], [])
-    ]
-  end
-
-  def test_adding
-    assert_equal(["cat ", @wombat_on, "and", @wombat_off, " dog" ],
-                  @am.flow("cat {and} dog"))
-    #assert_equal(["cat {and} dog" ], @am.flow("cat \\{and} dog"))
-  end
-
-  def test_add_html_tag
-    @am.add_html("Test", :TEST)
-    tags = @am.html_tags
-    assert_equal(6, tags.size)
-    assert(tags.has_key?("test"))
-  end
-
-  def test_add_regexp_handling
-    @am.add_regexp_handling "WikiWord", :WIKIWORD
-    regexp_handlings = @am.regexp_handlings
-
-    assert_equal 1, regexp_handlings.size
-    assert regexp_handlings.assoc "WikiWord"
-  end
-
-  def test_add_word_pair
-    @am.add_word_pair '%', '&', 'percent and'
-
-    assert @am.word_pair_map.include?(/(%)(\S+)(&)/)
-    assert @am.protectable.include?('%')
-    assert !@am.protectable.include?('&')
-  end
-
-  def test_add_word_pair_angle
-    e = assert_raise ArgumentError do
-      @am.add_word_pair '<', '>', 'angles'
-    end
-
-    assert_equal "Word flags may not start with '<'", e.message
-  end
-
-  def test_add_word_pair_invalid
-    assert_raise ArgumentError do
-      @am.add_word_pair("<", "<", :TEST)
-    end
-  end
-
-  def test_add_word_pair_map
-    @am.add_word_pair("x", "y", :TEST)
-
-    word_pair_map = @am.word_pair_map
-
-    assert_includes word_pair_map.keys.map { |r| r.source }, "(x)(\\S+)(y)"
-  end
-
-  def test_add_word_pair_matching
-    @am.add_word_pair '^', '^', 'caret'
-
-    assert @am.matching_word_pairs.include?('^')
-    assert @am.protectable.include?('^')
-  end
-
-  def test_basic
-    assert_equal(["cat"], @am.flow("cat"))
-
-    assert_equal(["cat ", @bold_on, "and", @bold_off, " dog"],
-                  @am.flow("cat *and* dog"))
-
-    assert_equal(["cat ", @bold_on, "AND", @bold_off, " dog"],
-                  @am.flow("cat *AND* dog"))
-
-    assert_equal(["cat ", @em_on, "And", @em_off, " dog"],
-                  @am.flow("cat _And_ dog"))
-
-    assert_equal(["cat *and dog*"], @am.flow("cat *and dog*"))
-
-    assert_equal(["*cat and* dog"], @am.flow("*cat and* dog"))
-
-    assert_equal(["cat *and ", @bold_on, "dog", @bold_off],
-                  @am.flow("cat *and *dog*"))
-
-    assert_equal(["cat ", @em_on, "and", @em_off, " dog"],
-                  @am.flow("cat _and_ dog"))
-
-    assert_equal(["cat_and_dog"],
-                  @am.flow("cat_and_dog"))
-
-    assert_equal(["cat ", @tt_on, "and", @tt_off, " dog"],
-                  @am.flow("cat +and+ dog"))
-
-    assert_equal(["cat ", @tt_on, "X::Y", @tt_off, " dog"],
-                  @am.flow("cat +X::Y+ dog"))
-
-    assert_equal(["cat ", @bold_on, "a_b_c", @bold_off, " dog"],
-                  @am.flow("cat *a_b_c* dog"))
-
-    assert_equal(["cat __ dog"],
-                  @am.flow("cat __ dog"))
-
-    assert_equal(["cat ", @em_on, "_", @em_off, " dog"],
-                  @am.flow("cat ___ dog"))
-
-    assert_equal(["cat and ", @em_on, "5", @em_off, " dogs"],
-                  @am.flow("cat and _5_ dogs"))
-
-    assert_equal([@tt_on, "__id__", @tt_off], @am.flow("+__id__+"))
-  end
-
-  def test_bold
-    assert_equal [@bold_on, 'bold', @bold_off],
-                 @am.flow("*bold*")
-
-    assert_equal [@bold_on, 'Bold:', @bold_off],
-                 @am.flow("*Bold:*")
-
-    assert_equal [@bold_on, '\\bold', @bold_off],
-                 @am.flow("*\\bold*")
-  end
-
-  def test_bold_html_escaped
-    assert_equal ['cat <b>dog</b>'], @am.flow('cat \<b>dog</b>')
-  end
-
-  def test_combined
-    assert_equal(["cat ", @em_on, "and", @em_off, " ", @bold_on, "dog", @bold_off],
-                  @am.flow("cat _and_ *dog*"))
-
-    assert_equal(["cat ", @em_on, "a__nd", @em_off, " ", @bold_on, "dog", @bold_off],
-                  @am.flow("cat _a__nd_ *dog*"))
-  end
-
-  def test_convert_attrs
-    str = '+foo+'.dup
-    attrs = RDoc::Markup::AttrSpan.new str.length, @am.exclusive_bitmap
-
-    @am.convert_attrs str, attrs, true
-    @am.convert_attrs str, attrs
-
-    assert_equal "\000foo\000", str
-
-    str = '+:foo:+'.dup
-    attrs = RDoc::Markup::AttrSpan.new str.length, @am.exclusive_bitmap
-
-    @am.convert_attrs str, attrs, true
-    @am.convert_attrs str, attrs
-
-    assert_equal "\000:foo:\000", str
-
-    str = '+x-y+'.dup
-    attrs = RDoc::Markup::AttrSpan.new str.length, @am.exclusive_bitmap
-
-    @am.convert_attrs str, attrs, true
-    @am.convert_attrs str, attrs
-
-    assert_equal "\000x-y\000", str
-  end
-
-  def test_convert_attrs_ignores_code
-    assert_equal 'foo <CODE>__send__</CODE> bar', output('foo <code>__send__</code> bar')
-  end
-
-  def test_convert_attrs_ignores_tt
-    assert_equal 'foo <CODE>__send__</CODE> bar', output('foo <tt>__send__</tt> bar')
-  end
-
-  def test_convert_attrs_preserves_double
-    assert_equal 'foo.__send__ :bar', output('foo.__send__ :bar')
-    assert_equal 'use __FILE__ to', output('use __FILE__ to')
-  end
-
-  def test_convert_attrs_does_not_ignore_after_tt
-    assert_equal 'the <CODE>IF:</CODE><EM>key</EM> directive', output('the <tt>IF:</tt>_key_ directive')
-  end
-
-  def test_escapes
-    assert_equal '<CODE>text</CODE>',   output('<tt>text</tt>')
-    assert_equal '<tt>text</tt>',       output('\\<tt>text</tt>')
-    assert_equal '<tt>',                output('\\<tt>')
-    assert_equal '<CODE><tt></CODE>',   output('<tt>\\<tt></tt>')
-    assert_equal '<CODE>\\<tt></CODE>', output('<tt>\\\\<tt></tt>')
-    assert_equal '<B>text</B>',         output('*text*')
-    assert_equal '*text*',              output('\\*text*')
-    assert_equal '\\',                  output('\\')
-    assert_equal '\\text',              output('\\text')
-    assert_equal '\\\\text',            output('\\\\text')
-    assert_equal 'text \\ text',        output('text \\ text')
-
-    assert_equal 'and <CODE>\\s</CODE> matches space',
-                 output('and <tt>\\s</tt> matches space')
-    assert_equal 'use <CODE><tt>text</CODE></tt> for code',
-                 output('use <tt>\\<tt>text</tt></tt> for code')
-    assert_equal 'use <CODE><tt>text</tt></CODE> for code',
-                 output('use <tt>\\<tt>text\\</tt></tt> for code')
-    assert_equal 'use <tt><tt>text</tt></tt> for code',
-                 output('use \\<tt>\\<tt>text</tt></tt> for code')
-    assert_equal 'use <tt><CODE>text</CODE></tt> for code',
-                 output('use \\<tt><tt>text</tt></tt> for code')
-    assert_equal 'use <CODE>+text+</CODE> for code',
-                 output('use <tt>\\+text+</tt> for code')
-    assert_equal 'use <tt><CODE>text</CODE></tt> for code',
-                 output('use \\<tt>+text+</tt> for code')
-    assert_equal 'illegal <tag>not</tag> changed',
-                 output('illegal <tag>not</tag> changed')
-    assert_equal 'unhandled <p>tag</p> unchanged',
-                 output('unhandled <p>tag</p> unchanged')
-  end
-
-  def test_exclude_tag
-    assert_equal '<CODE>aaa</CODE>[:symbol]', output('+aaa+[:symbol]')
-    assert_equal '<CODE>aaa[:symbol]</CODE>', output('+aaa[:symbol]+')
-    assert_equal 'aaa[:symbol]', output('aaa[:symbol]')
-    assert_equal '<B><CODE>index</CODE></B>', output('<b><tt>index</tt></b>')
-  end
-
-  def test_exclude_tag_flow
-    assert_equal [@tt_on, "aaa", @tt_off, "[:symbol]"],
-                  @am.flow("+aaa+[:symbol]")
-    assert_equal [@tt_on, "aaa[:symbol]", @tt_off],
-                  @am.flow("+aaa[:symbol]+")
-    assert_equal ["aaa[:symbol]"],
-                  @am.flow("aaa[:symbol]")
-  end
-
-  def test_html_like_em_bold
-    assert_equal ["cat ", @em_on, "and ", @em_to_bold, "dog", @bold_off],
-                  @am.flow("cat <i>and </i><b>dog</b>")
-  end
-
-  def test_html_like_em_bold_SGML
-    assert_equal ["cat ", @em_on, "and ", @em_to_bold, "dog", @bold_off],
-                  @am.flow("cat <i>and <b></i>dog</b>")
-  end
-
-  def test_html_like_em_bold_nested_1
-    assert_equal(["cat ", @bold_em_on, "and", @bold_em_off, " dog"],
-                  @am.flow("cat <i><b>and</b></i> dog"))
-  end
-
-  def test_html_like_em_bold_nested_2
-    assert_equal ["cat ", @em_on, "and ", @em_then_bold, "dog", @bold_em_off],
-                  @am.flow("cat <i>and <b>dog</b></i>")
-  end
-
-  def test_html_like_em_bold_nested_mixed_case
-    assert_equal ["cat ", @em_on, "and ", @em_then_bold, "dog", @bold_em_off],
-                  @am.flow("cat <i>and <B>dog</B></I>")
-  end
-
-  def test_html_like_em_bold_mixed_case
-    assert_equal ["cat ", @em_on, "and", @em_off, " ", @bold_on, "dog", @bold_off],
-                  @am.flow("cat <i>and</i> <B>dog</b>")
-  end
-
-  def test_html_like_teletype
-    assert_equal ["cat ", @tt_on, "dog", @tt_off],
-                 @am.flow("cat <tt>dog</Tt>")
-  end
-
-  def test_html_like_teletype_em_bold_SGML
-    assert_equal [@tt_on, "cat", @tt_off, " ", @em_on, "and ", @em_to_bold, "dog", @bold_off],
-                  @am.flow("<tt>cat</tt> <i>and <b></i>dog</b>")
-  end
-
-  def test_initial_html
-    html_tags = @am.html_tags
-    assert html_tags.is_a?(Hash)
-    assert_equal(5, html_tags.size)
-  end
-
-  def test_initial_word_pairs
-    word_pairs = @am.matching_word_pairs
-    assert word_pairs.is_a?(Hash)
-    assert_equal(3, word_pairs.size)
-  end
-
-  def test_mask_protected_sequence
-    def @am.str()     @str       end
-    def @am.str=(str) @str = str end
-
-    @am.str = '<code>foo</code>'.dup
-    @am.mask_protected_sequences
-
-    assert_equal "<code>foo</code>",       @am.str
-
-    @am.str = '<code>foo\\</code>'.dup
-    @am.mask_protected_sequences
-
-    assert_equal "<code>foo<\x04/code>", @am.str, 'escaped close'
-
-    @am.str = '<code>foo\\\\</code>'.dup
-    @am.mask_protected_sequences
-
-    assert_equal "<code>foo\\</code>",     @am.str, 'escaped backslash'
-  end
-
-  def test_protect
-    assert_equal(['cat \\ dog'],
-                 @am.flow('cat \\ dog'))
-
-    assert_equal(["cat <tt>dog</Tt>"],
-                 @am.flow("cat \\<tt>dog</Tt>"))
-
-    assert_equal(["cat ", @em_on, "and", @em_off, " <B>dog</b>"],
-                  @am.flow("cat <i>and</i> \\<B>dog</b>"))
-
-    assert_equal(["*word* or <b>text</b>"],
-                 @am.flow("\\*word* or \\<b>text</b>"))
-
-    assert_equal(["_cat_", @em_on, "dog", @em_off],
-                  @am.flow("\\_cat_<i>dog</i>"))
-  end
-
-  def test_lost_tag_for_the_second_time
-    str = "cat <tt>dog</tt>"
-    assert_equal(["cat ", @tt_on, "dog", @tt_off],
-                 @am.flow(str))
-    assert_equal(["cat ", @tt_on, "dog", @tt_off],
-                 @am.flow(str))
-  end
-
-  def test_regexp_handling
-    @am.add_regexp_handling(RDoc::CrossReference::CROSSREF_REGEXP, :CROSSREF)
-
-    #
-    # The apostrophes in "cats'" and "dogs'" suppress the flagging of these
-    # words as potential cross-references, which is necessary for the unit
-    # tests.  Unfortunately, the markup engine right now does not actually
-    # check whether a cross-reference is valid before flagging it.
-    #
-    assert_equal(["cats'"], @am.flow("cats'"))
-
-    assert_equal(["cats' ", crossref("#fred"), " dogs'"].flatten,
-                  @am.flow("cats' #fred dogs'"))
-
-    assert_equal([crossref("#fred"), " dogs'"].flatten,
-                  @am.flow("#fred dogs'"))
-
-    assert_equal(["cats' ", crossref("#fred")].flatten, @am.flow("cats' #fred"))
-
-    assert_equal(["(", crossref("#fred"), ")"].flatten, @am.flow("(#fred)"))
-  end
-
-  def test_tt_html
-    assert_equal [@tt_on, '"\n"', @tt_off],
-                 @am.flow('<tt>"\n"</tt>')
-  end
-
-  def output(str)
-    @formatter.convert_flow @am.flow str
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc/rdoc_markup_attributes_test.rb b/test/mri/rdoc/rdoc/rdoc_markup_attributes_test.rb
deleted file mode 100644
index f584a4762a4..00000000000
--- a/test/mri/rdoc/rdoc/rdoc_markup_attributes_test.rb
+++ /dev/null
@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocMarkupAttributesTest < RDoc::TestCase
-
-  def setup
-    super
-
-    @as = RDoc::Markup::Attributes.new
-  end
-
-  def test_bitmap_for
-    assert_equal 2, @as.bitmap_for('two')
-    assert_equal 2, @as.bitmap_for('two')
-    assert_equal 4, @as.bitmap_for('three')
-  end
-
-  def test_as_string
-    @as.bitmap_for 'two'
-    @as.bitmap_for 'three'
-
-    assert_equal 'none',                  @as.as_string(0)
-    assert_equal '_REGEXP_HANDLING_',     @as.as_string(1)
-    assert_equal 'two',                   @as.as_string(2)
-    assert_equal '_REGEXP_HANDLING_,two', @as.as_string(3)
-  end
-
-  def test_each_name_of
-    @as.bitmap_for 'two'
-    @as.bitmap_for 'three'
-
-    assert_equal %w[],          @as.each_name_of(0).to_a
-    assert_equal %w[],          @as.each_name_of(1).to_a
-    assert_equal %w[two],       @as.each_name_of(2).to_a
-    assert_equal %w[three],     @as.each_name_of(4).to_a
-    assert_equal %w[two three], @as.each_name_of(6).to_a
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc/rdoc_markup_document_test.rb b/test/mri/rdoc/rdoc/rdoc_markup_document_test.rb
deleted file mode 100644
index 6b118f4e54e..00000000000
--- a/test/mri/rdoc/rdoc/rdoc_markup_document_test.rb
+++ /dev/null
@@ -1,207 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocMarkupDocumentTest < RDoc::TestCase
-
-  def setup
-    super
-
-    @d = @RM::Document.new
-  end
-
-  def test_append
-    @d << @RM::Paragraph.new('hi')
-
-    expected = @RM::Document.new @RM::Paragraph.new('hi')
-
-    assert_equal expected, @d
-  end
-
-  def test_append_document
-    @d << @RM::Document.new
-
-    assert_empty @d
-
-    @d << @RM::Document.new(@RM::Paragraph.new('hi'))
-
-    expected = @RM::Document.new @RM::Paragraph.new('hi'), @RM::BlankLine.new
-
-    assert_equal expected, @d
-  end
-
-  def test_append_string
-    @d << ''
-
-    assert_empty @d
-
-    assert_raise ArgumentError do
-      @d << 'hi'
-    end
-  end
-
-  def test_concat
-    @d.concat [@RM::BlankLine.new, @RM::BlankLine.new]
-
-    refute_empty @d
-  end
-
-  def test_each
-    a = @RM::Document.new
-    b = @RM::Document.new(@RM::Paragraph.new('hi'))
-
-    @d.push a, b
-
-    assert_equal [a, b], @d.map { |sub_doc| sub_doc }
-  end
-
-  def test_empty_eh
-    assert_empty @d
-
-    @d << @RM::BlankLine.new
-
-    refute_empty @d
-  end
-
-  def test_empty_eh_document
-    d = @RM::Document.new @d
-
-    assert_empty d
-  end
-
-  def test_equals2
-    d2 = @RM::Document.new
-
-    assert_equal @d, d2
-
-    d2 << @RM::BlankLine.new
-
-    refute_equal @d, d2
-  end
-
-  def test_equals2_file
-    d2 = @RM::Document.new
-    d2.file = 'file.rb'
-
-    refute_equal @d, d2
-
-    @d.file = 'file.rb'
-
-    assert_equal @d, d2
-  end
-
-  def test_file_equals
-    @d.file = 'file.rb'
-
-    assert_equal 'file.rb', @d.file
-  end
-
-  def test_file_equals_top_level
-    @d.file = @store.add_file 'file.rb'
-
-    assert_equal 'file.rb', @d.file
-  end
-
-  def test_lt2
-    @d << @RM::BlankLine.new
-
-    refute_empty @d
-  end
-
-  def test_merge
-    original = @RM::Document.new @RM::Paragraph.new 'original'
-    original.file = 'file.rb'
-    root = @RM::Document.new original
-
-    replace = @RM::Document.new @RM::Paragraph.new 'replace'
-    replace.file = 'file.rb'
-
-    other = @RM::Document.new replace
-
-    result = root.merge other
-
-    inner = @RM::Document.new @RM::Paragraph.new 'replace'
-    inner.file = 'file.rb'
-    expected = @RM::Document.new inner
-
-    assert_equal expected, result
-  end
-
-  def test_merge_add
-    original = @RM::Document.new @RM::Paragraph.new 'original'
-    original.file = 'file.rb'
-    root = @RM::Document.new original
-
-    addition = @RM::Document.new @RM::Paragraph.new 'addition'
-    addition.file = 'other.rb'
-
-    other = @RM::Document.new addition
-
-    result = root.merge other
-
-    expected = @RM::Document.new original, addition
-
-    assert_equal expected, result
-  end
-
-  def test_merge_empty
-    original = @RM::Document.new
-    root = @RM::Document.new original
-
-    replace = @RM::Document.new @RM::Paragraph.new 'replace'
-    replace.file = 'file.rb'
-
-    other = @RM::Document.new replace
-
-    result = root.merge other
-
-    inner = @RM::Document.new @RM::Paragraph.new 'replace'
-    inner.file = 'file.rb'
-    expected = @RM::Document.new inner
-
-    assert_equal expected, result
-  end
-
-  def test_push
-    @d.push @RM::BlankLine.new, @RM::BlankLine.new
-
-    refute_empty @d
-  end
-
-  def test_table_of_contents
-    doc = @RM::Document.new(
-      @RM::Heading.new(1, 'A'),
-      @RM::Paragraph.new('B'),
-      @RM::Heading.new(2, 'C'),
-      @RM::Paragraph.new('D'),
-      @RM::Heading.new(1, 'E'),
-      @RM::Paragraph.new('F'))
-
-    expected = [
-      @RM::Heading.new(1, 'A'),
-      @RM::Heading.new(2, 'C'),
-      @RM::Heading.new(1, 'E'),
-    ]
-
-    assert_equal expected, doc.table_of_contents
-  end
-
-  def test_table_of_contents_omit_headings_below
-    document = doc(
-      head(1, 'A'),
-      para('B'),
-      head(2, 'C'),
-      para('D'),
-      head(1, 'E'),
-      para('F'))
-
-    document.omit_headings_below = 1
-
-    expected = [
-      head(1, 'A'),
-      head(1, 'E'),
-    ]
-
-    assert_equal expected, document.table_of_contents
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc/rdoc_markup_formatter_test.rb b/test/mri/rdoc/rdoc/rdoc_markup_formatter_test.rb
deleted file mode 100644
index ee27f24e67c..00000000000
--- a/test/mri/rdoc/rdoc/rdoc_markup_formatter_test.rb
+++ /dev/null
@@ -1,181 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocMarkupFormatterTest < RDoc::TestCase
-
-  class ToTest < RDoc::Markup::Formatter
-
-    def initialize(markup)
-      super nil, markup
-
-      add_tag :TT, '<code>', '</code>'
-    end
-
-    def accept_paragraph(paragraph)
-      @res += attributes(paragraph.text)
-    end
-
-    def attributes(text)
-      convert_flow @am.flow text.dup
-    end
-
-    def handle_regexp_CAPS(target)
-      "handled #{target.text}"
-    end
-
-    def start_accepting
-      @res = ""
-    end
-
-    def end_accepting
-      @res
-    end
-
-  end
-
-  def setup
-    super
-
-    @markup = @RM.new
-    @markup.add_regexp_handling(/[A-Z]+/, :CAPS)
-
-    @attribute_manager = @markup.attribute_manager
-    @attributes = @attribute_manager.attributes
-
-    @to = ToTest.new @markup
-
-    @caps            = @attributes.bitmap_for :CAPS
-    @regexp_handling = @attributes.bitmap_for :_REGEXP_HANDLING_
-    @tt              = @attributes.bitmap_for :TT
-  end
-
-  def test_class_gen_relative_url
-    def gen(from, to)
-      RDoc::Markup::ToHtml.gen_relative_url from, to
-    end
-
-    assert_equal 'a.html',    gen('a.html',   'a.html')
-    assert_equal 'b.html',    gen('a.html',   'b.html')
-
-    assert_equal 'd.html',    gen('a/c.html', 'a/d.html')
-    assert_equal '../a.html', gen('a/c.html', 'a.html')
-    assert_equal 'a/c.html',  gen('a.html',   'a/c.html')
-  end
-
-  def regexp_handling_names
-    @attribute_manager.regexp_handlings.map do |_, mask|
-      @attributes.as_string mask
-    end
-  end
-
-  def test_add_regexp_handling_RDOCLINK
-    @to.add_regexp_handling_RDOCLINK
-
-    assert_includes regexp_handling_names, 'RDOCLINK'
-
-    def @to.handle_regexp_RDOCLINK(target)
-      "<#{target.text}>"
-    end
-
-    document = doc(para('{foo}[rdoc-label:bar].'))
-
-    formatted = document.accept @to
-
-    assert_equal '{foo}[<rdoc-label:bar>].', formatted
-  end
-
-  def test_add_regexp_handling_TIDYLINK
-    @to.add_regexp_handling_TIDYLINK
-
-    assert_includes regexp_handling_names, 'TIDYLINK'
-
-    def @to.handle_regexp_TIDYLINK(target)
-      "<#{target.text}>"
-    end
-
-    document = doc(para('foo[rdoc-label:bar].'))
-
-    formatted = document.accept @to
-
-    assert_equal '<foo[rdoc-label:bar]>.', formatted
-
-    document = doc(para('{foo}[rdoc-label:bar].'))
-
-    formatted = document.accept @to
-
-    assert_equal '<{foo}[rdoc-label:bar]>.', formatted
-
-    document = doc(para('<tt>{abc}</tt>: {foo}[rdoc-label:bar].'))
-
-    formatted = document.accept @to
-
-    assert_equal '<code>{abc}</code>: <{foo}[rdoc-label:bar]>.', formatted
-  end
-
-  def test_parse_url
-    scheme, url, id = @to.parse_url 'example/foo'
-
-    assert_equal 'http',        scheme
-    assert_equal 'example/foo', url
-    assert_nil   id
-  end
-
-  def test_parse_url_anchor
-    scheme, url, id = @to.parse_url '#foottext-1'
-
-    assert_nil   scheme
-    assert_equal '#foottext-1', url
-    assert_nil   id
-  end
-
-  def test_parse_url_link
-    scheme, url, id = @to.parse_url 'link:README.txt'
-
-    assert_equal 'link',       scheme
-    assert_equal 'README.txt', url
-    assert_nil   id
-  end
-
-  def test_parse_url_link_id
-    scheme, url, id = @to.parse_url 'link:README.txt#label-foo'
-
-    assert_equal 'link',                 scheme
-    assert_equal 'README.txt#label-foo', url
-    assert_nil   id
-  end
-
-  def test_parse_url_rdoc_label
-    scheme, url, id = @to.parse_url 'rdoc-label:foo'
-
-    assert_equal 'link', scheme
-    assert_equal '#foo', url
-    assert_nil   id
-
-    scheme, url, id = @to.parse_url 'rdoc-label:foo:bar'
-
-    assert_equal 'link',      scheme
-    assert_equal '#foo',      url
-    assert_equal ' id="bar"', id
-  end
-
-  def test_parse_url_scheme
-    scheme, url, id = @to.parse_url 'http://example/foo'
-
-    assert_equal 'http',               scheme
-    assert_equal 'http://example/foo', url
-    assert_nil   id
-
-    scheme, url, id = @to.parse_url 'https://example/foo'
-
-    assert_equal 'https',               scheme
-    assert_equal 'https://example/foo', url
-    assert_nil   id
-  end
-
-  def test_convert_tt_regexp_handling
-    converted = @to.convert '<code>AAA</code>'
-
-    assert_equal '<code>AAA</code>', converted
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc/rdoc_markup_hard_break_test.rb b/test/mri/rdoc/rdoc/rdoc_markup_hard_break_test.rb
deleted file mode 100644
index 8ec8ffcfed6..00000000000
--- a/test/mri/rdoc/rdoc/rdoc_markup_hard_break_test.rb
+++ /dev/null
@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocMarkupHardBreakTest < RDoc::TestCase
-
-  def setup
-    super
-
-    @hb = RDoc::Markup::HardBreak.new
-  end
-
-  def test_accept
-    visitor = Object.new
-
-    def visitor.accept_hard_break(obj) @obj = obj end
-    def visitor.obj() @obj end
-
-    @hb.accept visitor
-
-    assert_same @hb, visitor.obj
-  end
-
-  def test_equals2
-    other = RDoc::Markup::HardBreak.new
-
-    assert_equal @hb, other
-
-    refute_equal @hb, Object.new
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc/rdoc_markup_heading_test.rb b/test/mri/rdoc/rdoc/rdoc_markup_heading_test.rb
deleted file mode 100644
index 3bf58ed5f77..00000000000
--- a/test/mri/rdoc/rdoc/rdoc_markup_heading_test.rb
+++ /dev/null
@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocMarkupHeadingTest < RDoc::TestCase
-
-  def setup
-    super
-
-    @h = RDoc::Markup::Heading.new 1, 'Hello *Friend*!'
-  end
-
-  def test_aref
-    assert_equal 'label-Hello+Friend-21', @h.aref
-  end
-
-  def test_label
-    assert_equal 'label-Hello+Friend-21', @h.label
-    assert_equal 'label-Hello+Friend-21', @h.label(nil)
-
-    context = RDoc::NormalClass.new 'Foo'
-
-    assert_equal 'class-Foo-label-Hello+Friend-21', @h.label(context)
-  end
-
-  def test_plain_html
-    assert_equal 'Hello <strong>Friend</strong>!', @h.plain_html
-  end
-
-  def test_plain_html_using_image_alt_as_text
-    h = RDoc::Markup::Heading.new 1, 'rdoc-image:foo.png:Hello World'
-
-    assert_equal 'Hello World', h.plain_html
-  end
-end
diff --git a/test/mri/rdoc/rdoc/rdoc_markup_include_test.rb b/test/mri/rdoc/rdoc/rdoc_markup_include_test.rb
deleted file mode 100644
index 1544d25beea..00000000000
--- a/test/mri/rdoc/rdoc/rdoc_markup_include_test.rb
+++ /dev/null
@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocMarkupIncludeTest < RDoc::TestCase
-
-  def setup
-    super
-
-    @include = @RM::Include.new 'file', [Dir.tmpdir]
-  end
-
-  def test_equals2
-    assert_equal @include, @RM::Include.new('file', [Dir.tmpdir])
-    refute_equal @include, @RM::Include.new('file', %w[.])
-    refute_equal @include, @RM::Include.new('other', [Dir.tmpdir])
-    refute_equal @include, Object.new
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc/rdoc_markup_indented_paragraph_test.rb b/test/mri/rdoc/rdoc/rdoc_markup_indented_paragraph_test.rb
deleted file mode 100644
index 3be73b81db8..00000000000
--- a/test/mri/rdoc/rdoc/rdoc_markup_indented_paragraph_test.rb
+++ /dev/null
@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocMarkupIndentedParagraphTest < RDoc::TestCase
-
-  def setup
-    super
-
-    @IP = RDoc::Markup::IndentedParagraph
-  end
-
-  def test_initialize
-    ip = @IP.new 2, 'a', 'b'
-
-    assert_equal 2, ip.indent
-    assert_equal %w[a b], ip.parts
-  end
-
-  def test_accept
-    visitor = Object.new
-    def visitor.accept_indented_paragraph(obj) @obj = obj end
-    def visitor.obj() @obj end
-
-    paragraph = @IP.new 0
-
-    paragraph.accept visitor
-
-    assert_equal paragraph, visitor.obj
-  end
-
-  def test_equals2
-    one = @IP.new 1
-    two = @IP.new 2
-
-    assert_equal one, one
-    refute_equal one, two
-  end
-
-  def test_text
-    paragraph = @IP.new(2, 'hello', ' world')
-
-    assert_equal 'hello world', paragraph.text
-  end
-
-  def test_text_break
-    paragraph = @IP.new(2, 'hello', hard_break, 'world')
-
-    assert_equal 'helloworld', paragraph.text
-
-    assert_equal "hello\n  world", paragraph.text("\n")
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc/rdoc_markup_paragraph_test.rb b/test/mri/rdoc/rdoc/rdoc_markup_paragraph_test.rb
deleted file mode 100644
index 0f1b96e123a..00000000000
--- a/test/mri/rdoc/rdoc/rdoc_markup_paragraph_test.rb
+++ /dev/null
@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocMarkupParagraphTest < RDoc::TestCase
-
-  def test_accept
-    visitor = Object.new
-    def visitor.accept_paragraph(obj) @obj = obj end
-    def visitor.obj() @obj end
-
-    paragraph = RDoc::Markup::Paragraph.new
-
-    paragraph.accept visitor
-
-    assert_same paragraph, visitor.obj
-  end
-
-  def test_text
-    paragraph = para('hello', ' world')
-
-    assert_equal 'hello world', paragraph.text
-  end
-
-  def test_text_break
-    paragraph = para('hello', hard_break, 'world')
-
-    assert_equal 'helloworld', paragraph.text
-
-    assert_equal "hello\nworld", paragraph.text("\n")
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc/rdoc_markup_parser_test.rb b/test/mri/rdoc/rdoc/rdoc_markup_parser_test.rb
deleted file mode 100644
index c157d9c213d..00000000000
--- a/test/mri/rdoc/rdoc/rdoc_markup_parser_test.rb
+++ /dev/null
@@ -1,1684 +0,0 @@
-# coding: utf-8
-# frozen_string_literal: true
-
-require_relative 'helper'
-
-class RDocMarkupParserTest < RDoc::TestCase
-
-  def setup
-    super
-
-    @RMP = @RM::Parser
-  end
-
-  def test_build_heading
-    parser = @RMP.new
-
-    parser.tokens.replace [
-      [:TEXT,    'heading three',  4, 0],
-      [:NEWLINE, "\n",            17, 0],
-    ]
-
-    assert_equal @RM::Heading.new(3, 'heading three'), parser.build_heading(3)
-  end
-
-  def test_get
-    parser = util_parser
-
-    assert_equal [:HEADER, 1, 0, 0], parser.get
-
-    assert_equal 7, parser.tokens.length
-  end
-
-  def test_parse_bullet
-    str = <<-STR
-* l1
-* l2
-    STR
-
-    expected = [
-      @RM::List.new(:BULLET, *[
-        @RM::ListItem.new(nil,
-          @RM::Paragraph.new('l1')),
-        @RM::ListItem.new(nil,
-          @RM::Paragraph.new('l2'))])]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_bullet_utf_8
-    str = <<-STR
-* 新しい機能
-    STR
-
-    expected = [
-      @RM::List.new(:BULLET, *[
-        @RM::ListItem.new(nil,
-          @RM::Paragraph.new('新しい機能'))])]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_bullet_verbatim_heading
-    str = <<-STR
-* l1
-    v
-
-= H
-    STR
-
-    expected = [
-      @RM::List.new(:BULLET, *[
-        @RM::ListItem.new(nil,
-          @RM::Paragraph.new('l1'),
-          @RM::Verbatim.new("v\n"))]),
-      @RM::Heading.new(1, 'H')]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_bullet_heading
-    str = <<-STR
-* = l1
-    STR
-
-    expected = [
-      @RM::List.new(:BULLET, *[
-        @RM::ListItem.new(nil,
-          @RM::Heading.new(1, 'l1'))])]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_bullet_indent
-    str = <<-STR
-* l1
-  * l1.1
-* l2
-    STR
-
-    expected = [
-      @RM::List.new(:BULLET, *[
-        @RM::ListItem.new(nil,
-          @RM::Paragraph.new('l1'),
-          @RM::List.new(:BULLET, *[
-            @RM::ListItem.new(nil,
-              @RM::Paragraph.new('l1.1'))])),
-        @RM::ListItem.new(nil,
-          @RM::Paragraph.new('l2'))])]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_bullet_paragraph
-    str = <<-STR
-now is
-* l1
-* l2
-the time
-    STR
-
-    expected = [
-      @RM::Paragraph.new('now is'),
-      @RM::List.new(:BULLET, *[
-        @RM::ListItem.new(nil,
-          @RM::Paragraph.new('l1')),
-        @RM::ListItem.new(nil,
-          @RM::Paragraph.new('l2')),
-      ]),
-      @RM::Paragraph.new('the time'),
-    ]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_bullet_multiline
-    str = <<-STR
-* l1
-  l1+
-* l2
-    STR
-
-    expected = [
-      list(:BULLET,
-        item(nil,
-          para('l1 ', 'l1+')),
-        item(nil,
-          para('l2')))]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_bullet_multiparagraph
-    str = <<-STR
-* l1
-
-  l1+
-    STR
-
-    expected = [
-      @RM::List.new(:BULLET, *[
-        @RM::ListItem.new(nil,
-          @RM::Paragraph.new('l1'),
-          @RM::BlankLine.new,
-          @RM::Paragraph.new('l1+')),
-      ]),
-    ]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_bullet_indent_verbatim
-    str = <<-STR
-* l1
-  * l1.1
-    text
-      code
-        code
-
-    text
-* l2
-    STR
-
-    expected = [
-      list(:BULLET,
-        item(nil,
-          para('l1'),
-          list(:BULLET,
-            item(nil,
-              para('l1.1 ', 'text'),
-              verb("code\n", "  code\n"),
-              para('text')))),
-        item(nil,
-          para('l2')))]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_dash
-    str = <<-STR
-- one
-- two
-    STR
-
-    expected = [
-      @RM::List.new(:BULLET, *[
-        @RM::ListItem.new(nil,
-          @RM::Paragraph.new('one')),
-        @RM::ListItem.new(nil,
-          @RM::Paragraph.new('two'))])]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_heading
-    str = '= heading one'
-
-    expected = [
-      @RM::Heading.new(1, 'heading one')]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_heading_three
-    str = '=== heading three'
-
-    expected = [
-      @RM::Heading.new(3, 'heading three')]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_heading_bullet
-    str = '= * heading one'
-
-    expected = [
-      @RM::Heading.new(1, '* heading one')]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_heading_empty
-    str = <<-STR
-===
-* bullet
-    STR
-
-    expected = [
-      @RM::Heading.new(3, ''),
-      @RM::BlankLine.new,
-      @RM::List.new(:BULLET, *[
-        @RM::ListItem.new(nil,
-          @RM::Paragraph.new('bullet'))]),
-    ]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_heading_heading
-    str = '= ='
-
-    expected = [
-      @RM::Heading.new(1, '=')]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_heading_lalpha
-    str = '= b. heading one'
-
-    expected = [
-      @RM::Heading.new(1, 'b. heading one')]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_heading_label
-    str = '= [heading one]'
-
-    expected = [
-      @RM::Heading.new(1, '[heading one]')]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_heading_note
-    str = '= heading one::'
-
-    expected = [
-      @RM::Heading.new(1, 'heading one::')]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_heading_number
-    str = '= 5. heading one'
-
-    expected = [
-      @RM::Heading.new(1, '5. heading one')]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_heading_ualpha
-    str = '= B. heading one'
-
-    expected = [
-      @RM::Heading.new(1, 'B. heading one')]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_label
-    str = <<-STR
-[one] item one
-[two] item two
-    STR
-
-    expected = [
-      list(:LABEL,
-        item(%w[one],
-          para('item one')),
-        item(%w[two],
-          para('item two')))]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_label_bullet
-    str = <<-STR
-[cat] l1
-      * l1.1
-[dog] l2
-    STR
-
-    expected = [
-      list(:LABEL,
-        item(%w[cat],
-          para('l1'),
-          list(:BULLET,
-            item(nil,
-              para('l1.1')))),
-        item(%w[dog],
-          para('l2')))]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_label_multi_label
-    str = <<-STR
-[one]
-[two] some description
-    STR
-
-    expected = [
-      list(:LABEL,
-        item(%w[one two],
-          para('some description')))]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_label_multi_line
-    str = <<-STR
-[cat] l1
-      continuation
-[dog] l2
-    STR
-
-    expected = [
-      list(:LABEL,
-        item(%w[cat],
-          para('l1 ', 'continuation')),
-        item(%w[dog],
-          para('l2')))]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_label_newline
-    str = <<-STR
-[one]
-  item one
-[two]
-  item two
-    STR
-
-    expected = [
-      list(:LABEL,
-        item(%w[one],
-          para('item one')),
-        item(%w[two],
-          para('item two')))]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_lalpha
-    str = <<-STR
-a. l1
-b. l2
-    STR
-
-    expected = [
-      @RM::List.new(:LALPHA, *[
-        @RM::ListItem.new(nil,
-          @RM::Paragraph.new('l1')),
-        @RM::ListItem.new(nil,
-          @RM::Paragraph.new('l2'))])]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_lalpha_ualpha
-    str = <<-STR
-a. l1
-b. l2
-A. l3
-A. l4
-    STR
-
-    expected = [
-      @RM::List.new(:LALPHA, *[
-        @RM::ListItem.new(nil,
-          @RM::Paragraph.new('l1')),
-        @RM::ListItem.new(nil,
-          @RM::Paragraph.new('l2'))]),
-      @RM::List.new(:UALPHA, *[
-        @RM::ListItem.new(nil,
-          @RM::Paragraph.new('l3')),
-        @RM::ListItem.new(nil,
-          @RM::Paragraph.new('l4'))])]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_lalpha_utf_8
-    str = <<-STR
-a. 新しい機能
-    STR
-
-    expected = [
-      @RM::List.new(:LALPHA, *[
-        @RM::ListItem.new(nil,
-          @RM::Paragraph.new('新しい機能'))])]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_line_break
-    str = "now is\nthe time  \nfor all"
-
-    expected = [
-      para('now is ', 'the time'),
-      blank_line,
-      para('for all')]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_list_list_1
-    str = <<-STR
-10. para 1
-
-    [label 1]
-      para 1.1
-
-        code
-
-      para 1.2
-    STR
-
-    expected = [
-      list(:NUMBER,
-        item(nil,
-          para('para 1'),
-          blank_line,
-          list(:LABEL,
-            item(%w[label\ 1],
-              para('para 1.1'),
-              blank_line,
-              verb("code\n"),
-              para('para 1.2')))))]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_list_list_2
-    str = <<-STR
-6. para
-
-   label 1::  text 1
-   label 2::  text 2
-    STR
-
-    expected = [
-      list(:NUMBER,
-        item(nil,
-          para('para'),
-          blank_line,
-          list(:NOTE,
-            item(%w[label\ 1],
-              para('text 1')),
-            item(%w[label\ 2],
-              para('text 2')))))]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_list_verbatim
-    str = <<-STR
-* one
-    verb1
-    verb2
-* two
-    STR
-
-    expected = [
-      @RM::List.new(:BULLET, *[
-        @RM::ListItem.new(nil,
-          @RM::Paragraph.new('one'),
-          @RM::Verbatim.new("verb1\n", "verb2\n")),
-        @RM::ListItem.new(nil,
-          @RM::Paragraph.new('two'))])]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_lists
-    str = <<-STR
-now is
-* l1
-1. n1
-2. n2
-* l2
-the time
-    STR
-
-    expected = [
-      @RM::Paragraph.new('now is'),
-      @RM::List.new(:BULLET, *[
-        @RM::ListItem.new(nil,
-          @RM::Paragraph.new('l1'))]),
-      @RM::List.new(:NUMBER, *[
-        @RM::ListItem.new(nil,
-          @RM::Paragraph.new('n1')),
-        @RM::ListItem.new(nil,
-          @RM::Paragraph.new('n2'))]),
-      @RM::List.new(:BULLET, *[
-        @RM::ListItem.new(nil,
-          @RM::Paragraph.new('l2'))]),
-      @RM::Paragraph.new('the time')]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_note
-    str = <<-STR
-one:: item one
-two:: item two
-    STR
-
-    expected = [
-      list(:NOTE,
-        item(%w[one],
-          para('item one')),
-        item(%w[two],
-          para('item two')))]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_note_empty
-    str = <<-STR
-one::
-two::
-    STR
-
-    expected = [
-      list(:NOTE,
-        item(%w[one two],
-          blank_line))]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_note_note
-    str = <<-STR
-one:: two::
-    STR
-
-    expected = [
-      list(:NOTE,
-        item(%w[one],
-          list(:NOTE,
-            item(%w[two],
-              blank_line))))]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_number_bullet
-    str = <<-STR
-1. l1
-   * l1.1
-2. l2
-    STR
-
-    expected = [
-      list(:NUMBER,
-        item(nil,
-          para('l1'),
-          list(:BULLET,
-            item(nil,
-              para('l1.1')))),
-        item(nil,
-          para('l2')))]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_paragraph
-    str = <<-STR
-now is the time
-
-for all good men
-    STR
-
-    expected = [
-      @RM::Paragraph.new('now is the time'),
-      @RM::BlankLine.new,
-      @RM::Paragraph.new('for all good men')]
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_paragraph_multiline
-    str = "now is the time\nfor all good men"
-
-    expected = @RM::Paragraph.new 'now is the time ', 'for all good men'
-    assert_equal [expected], @RMP.parse(str).parts
-  end
-
-  def test_parse_paragraph_verbatim
-    str = <<-STR
-now is the time
-  code _line_ here
-for all good men
-    STR
-
-    expected = [
-      @RM::Paragraph.new('now is the time'),
-      @RM::Verbatim.new("code _line_ here\n"),
-      @RM::Paragraph.new('for all good men'),
-    ]
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_rule
-    str = <<-STR
-now is the time
-
----
-
-for all good men
-    STR
-
-    expected = [
-      @RM::Paragraph.new('now is the time'),
-      @RM::BlankLine.new,
-      @RM::Rule.new(1),
-      @RM::BlankLine.new,
-      @RM::Paragraph.new('for all good men')]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_ualpha
-    str = <<-STR
-A. l1
-B. l2
-    STR
-
-    expected = [
-      @RM::List.new(:UALPHA, *[
-        @RM::ListItem.new(nil,
-          @RM::Paragraph.new('l1')),
-        @RM::ListItem.new(nil,
-          @RM::Paragraph.new('l2'))])]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_trailing_cr
-    expected = [ @RM::Paragraph.new('Text') ]
-    assert_equal expected, @RMP.parse("Text\r").parts
-  end
-
-  def test_parse_verbatim
-    str = <<-STR
-now is
-   code
-the time
-    STR
-
-    expected = [
-      @RM::Paragraph.new('now is'),
-      @RM::Verbatim.new("code\n"),
-      @RM::Paragraph.new('the time'),
-    ]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_verbatim_bullet
-    str = <<-STR
-  * blah
-    STR
-
-    expected = [
-      @RM::Verbatim.new("* blah\n")]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_verbatim_dash
-    str = <<-STR
-  - blah
-    STR
-
-    expected = [
-      @RM::Verbatim.new("- blah\n")]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_verbatim_fold
-    str = <<-STR
-now is
-   code
-
-
-   code1
-
-the time
-    STR
-
-    expected = [
-      @RM::Paragraph.new('now is'),
-      @RM::Verbatim.new("code\n", "\n", "code1\n"),
-      @RM::Paragraph.new('the time'),
-    ]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_verbatim_heading
-    str = <<-STR
-text
-   ===   heading three
-    STR
-
-    expected = [
-      @RM::Paragraph.new('text'),
-      @RM::Verbatim.new("===   heading three\n")]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_verbatim_heading2
-    str = "text\n   code\n=== heading three"
-
-    expected = [
-      @RM::Paragraph.new('text'),
-      @RM::Verbatim.new("code\n"),
-      @RM::Heading.new(3, 'heading three')]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_verbatim_label
-    str = <<-STR
-  [blah] blah
-    STR
-
-    expected = [
-      @RM::Verbatim.new("[blah] blah\n")]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_verbatim_lalpha
-    str = <<-STR
-  b. blah
-    STR
-
-    expected = [
-      @RM::Verbatim.new("b. blah\n")]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_verbatim_markup_example
-    str = <<-STR
-text
-   code
-   === heading three
-    STR
-
-    expected = [
-      @RM::Paragraph.new('text'),
-      @RM::Verbatim.new("code\n", "=== heading three\n")]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_verbatim_merge
-    str = <<-STR
-now is
-   code
-
-   code1
-the time
-    STR
-
-    expected = [
-      @RM::Paragraph.new('now is'),
-      @RM::Verbatim.new("code\n", "\n", "code1\n"),
-      @RM::Paragraph.new('the time'),
-    ]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_verbatim_merge2
-    str = <<-STR
-now is
-   code
-
-   code1
-
-   code2
-the time
-    STR
-
-    expected = [
-      @RM::Paragraph.new('now is'),
-      @RM::Verbatim.new("code\n", "\n", "code1\n", "\n", "code2\n"),
-      @RM::Paragraph.new('the time'),
-    ]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_verbatim_multiline
-    str = <<-STR
-now is
-   code
-   code1
-the time
-    STR
-
-    expected = [
-      @RM::Paragraph.new('now is'),
-      @RM::Verbatim.new("code\n", "code1\n"),
-      @RM::Paragraph.new('the time'),
-    ]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_verbatim_multilevel
-    str = <<-STR
-now is the time
-  code
- more code
-for all good men
-    STR
-
-    expected = [
-      @RM::Paragraph.new('now is the time'),
-      @RM::Verbatim.new(" code\n",
-                        "more code\n"),
-      @RM::Paragraph.new('for all good men'),
-    ]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_verbatim_note
-    str = <<-STR
-  blah:: blah
-    STR
-
-    expected = [
-      @RM::Verbatim.new("blah:: blah\n")]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_verbatim_number
-    str = <<-STR
-  2. blah
-    STR
-
-    expected = [
-      @RM::Verbatim.new("2. blah\n")]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_verbatim_rule
-    str = <<-STR
-text
-
-  --- lib/blah.rb.orig
-  +++ lib/blah.rb
-    STR
-
-    expected = [
-      @RM::Paragraph.new('text'),
-      @RM::BlankLine.new,
-      @RM::Verbatim.new("--- lib/blah.rb.orig\n",
-                        "+++ lib/blah.rb\n")]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_verbatim_rule2
-    str = <<-STR.chomp
-text
-
-  ---
-    STR
-
-    expected = [
-      @RM::Paragraph.new('text'),
-      @RM::BlankLine.new,
-      @RM::Verbatim.new("---")]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_verbatim_trim
-    str = <<-STR
-now is
-   code
-
-   code1
-
-the time
-    STR
-
-    expected = [
-      @RM::Paragraph.new('now is'),
-      @RM::Verbatim.new("code\n",
-                        "\n",
-                        "code1\n"),
-      @RM::Paragraph.new('the time'),
-    ]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_verbatim_ualpha
-    str = <<-STR
-  B. blah
-    STR
-
-    expected = [
-      @RM::Verbatim.new("B. blah\n")]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_whitespace
-    expected = [
-      @RM::Paragraph.new('hello'),
-    ]
-
-    assert_equal expected, @RMP.parse('hello').parts
-
-    expected = [
-      @RM::Verbatim.new('hello '),
-    ]
-
-    assert_equal expected, @RMP.parse('  hello ').parts
-
-    expected = [
-      @RM::Verbatim.new('hello          '),
-    ]
-
-    assert_equal expected, @RMP.parse('                 hello          ').parts
-
-    expected = [
-      @RM::Paragraph.new('1'),
-      @RM::Verbatim.new("2\n", ' 3'),
-    ]
-
-    assert_equal expected, @RMP.parse("1\n 2\n  3").parts
-
-    expected = [
-      @RM::Verbatim.new("1\n",
-                        " 2\n",
-                        "  3"),
-    ]
-
-    assert_equal expected, @RMP.parse("  1\n   2\n    3").parts
-
-    expected = [
-      @RM::Paragraph.new('1'),
-      @RM::Verbatim.new("2\n",
-                        " 3\n"),
-      @RM::Paragraph.new('1'),
-      @RM::Verbatim.new('2'),
-    ]
-
-    assert_equal expected, @RMP.parse("1\n 2\n  3\n1\n 2").parts
-
-    expected = [
-      @RM::Verbatim.new("1\n",
-                        " 2\n",
-                        "  3\n",
-                        "1\n",
-                        ' 2'),
-    ]
-
-    assert_equal expected, @RMP.parse("  1\n   2\n    3\n  1\n   2").parts
-
-    expected = [
-      @RM::Verbatim.new("1\n",
-                        " 2\n",
-                        "\n",
-                        '  3'),
-    ]
-
-    assert_equal expected, @RMP.parse("  1\n   2\n\n    3").parts
-  end
-
-  def test_parse_block_quote
-    expected = [
-      @RM::BlockQuote.new(@RM::Paragraph.new("foo"))
-    ]
-    assert_equal expected, @RMP.parse(<<-DOC).parts
->>>
-  foo
-    DOC
-
-    expected = [
-      @RM::BlockQuote.new(@RM::Paragraph.new("foo"),
-                          @RM::Verbatim.new("code\n"),
-                          @RM::Paragraph.new("bar"))
-    ]
-    assert_equal expected, @RMP.parse(<<-DOC).parts
->>>
-  foo
-    code
-  bar
-    DOC
-
-    expected = [
-      @RM::BlockQuote.new(@RM::Paragraph.new("foo"),
-                          @RM::BlockQuote.new(@RM::Paragraph.new("bar")),
-                          @RM::Paragraph.new("zot"))
-    ]
-    assert_equal expected, @RMP.parse(<<-DOC).parts
->>>
-  foo
-  >>>
-    bar
-  zot
-    DOC
-  end
-
-  def test_peek_token
-    parser = util_parser
-
-    assert_equal [:HEADER, 1, 0, 0], parser.peek_token
-
-    assert_equal 8, parser.tokens.length
-  end
-
-  def test_skip
-    parser = util_parser
-
-    assert_equal [:HEADER, 1, 0, 0], parser.skip(:HEADER)
-
-    assert_equal [:TEXT, 'Heading', 2, 0], parser.get
-
-    assert_equal [:NEWLINE, "\n", 9, 0], parser.peek_token
-
-    assert_raise RDoc::Markup::Parser::ParseError do
-      parser.skip :NONE
-    end
-
-    assert_equal [:NEWLINE, "\n", 9, 0], parser.peek_token
-
-    assert_nil parser.skip(:NONE, false)
-
-    assert_equal [:NEWLINE, "\n", 9, 0], parser.peek_token
-  end
-
-  def test_tokenize_bullet
-    str = <<-STR
-* l1
-    STR
-
-    expected = [
-      [:BULLET,  '*',     0, 0],
-      [:TEXT,    'l1',    2, 0],
-      [:NEWLINE, "\n",    4, 0],
-    ]
-
-    assert_equal expected, @RMP.tokenize(str)
-  end
-
-  def test_tokenize_bullet_indent
-    str = <<-STR
-* l1
-  * l1.1
-    STR
-
-    expected = [
-      [:BULLET,  '*',     0, 0],
-      [:TEXT,    'l1',    2, 0],
-      [:NEWLINE, "\n",    4, 0],
-      [:BULLET,  '*',     2, 1],
-      [:TEXT,    'l1.1',  4, 1],
-      [:NEWLINE, "\n",    8, 1],
-    ]
-
-    assert_equal expected, @RMP.tokenize(str)
-  end
-
-  def test_tokenize_heading
-    str = <<-STR
-= Heading
-== Heading 2
-    STR
-
-    expected = [
-      [:HEADER,  1,            0, 0],
-      [:TEXT,    'Heading',    2, 0],
-      [:NEWLINE, "\n",         9, 0],
-      [:HEADER,  2,            0, 1],
-      [:TEXT,    'Heading 2',  3, 1],
-      [:NEWLINE, "\n",        12, 1],
-    ]
-
-    assert_equal expected, @RMP.tokenize(str)
-  end
-
-  def test_tokenize_heading_empty
-    str = <<-STR
-===
-* bullet
-    STR
-
-    expected = [
-      [:HEADER,  3,        0, 0],
-      [:NEWLINE, "\n",     3, 0],
-      [:BULLET,  "*",      0, 1],
-      [:TEXT,    "bullet", 2, 1],
-      [:NEWLINE, "\n",     8, 1],
-    ]
-
-    assert_equal expected, @RMP.tokenize(str)
-  end
-
-  def test_tokenize_heading_heading
-    str = <<-STR
-= =
-    STR
-
-    expected = [
-      [:HEADER,  1,    0, 0],
-      [:TEXT,    '=',  2, 0],
-      [:NEWLINE, "\n", 3, 0],
-    ]
-
-    assert_equal expected, @RMP.tokenize(str)
-  end
-
-  def test_tokenize_heading_no_space
-    str = <<-STR
-=Heading
-==Heading 2
-    STR
-
-    expected = [
-      [:HEADER,  1,            0, 0],
-      [:TEXT,    'Heading',    1, 0],
-      [:NEWLINE, "\n",         8, 0],
-      [:HEADER,  2,            0, 1],
-      [:TEXT,    'Heading 2',  2, 1],
-      [:NEWLINE, "\n",        11, 1],
-    ]
-
-    assert_equal expected, @RMP.tokenize(str)
-  end
-
-  def test_tokenize_label
-    str = <<-STR
-[cat] l1
-[dog] l1.1
-    STR
-
-    expected = [
-      [:LABEL,   'cat',   0, 0],
-      [:TEXT,    'l1',    6, 0],
-      [:NEWLINE, "\n",    8, 0],
-      [:LABEL,   'dog',   0, 1],
-      [:TEXT,    'l1.1',  6, 1],
-      [:NEWLINE, "\n",   10, 1],
-    ]
-
-    assert_equal expected, @RMP.tokenize(str)
-  end
-
-  def test_tokenize_label_note
-    str = <<-STR
-[label]
-  note::
-    STR
-
-    expected = [
-      [:LABEL,   'label', 0, 0],
-      [:NEWLINE, "\n",    7, 0],
-      [:NOTE,    'note',  2, 1],
-      [:NEWLINE, "\n",    8, 1],
-    ]
-
-    assert_equal expected, @RMP.tokenize(str)
-  end
-
-  def test_tokenize_label_newline
-    str = <<-STR
-[cat]
-  l1
-    STR
-
-    expected = [
-      [:LABEL,   'cat',   0, 0],
-      [:NEWLINE, "\n",    5, 0],
-      [:TEXT,    'l1',    2, 1],
-      [:NEWLINE, "\n",    4, 1],
-    ]
-
-    assert_equal expected, @RMP.tokenize(str)
-  end
-
-  def test_tokenize_label_newline_windows
-    str = <<-STR
-[cat]\r
-  l1\r
-    STR
-
-    expected = [
-      [:LABEL,   'cat',   0, 0],
-      [:NEWLINE, "\n",    6, 0],
-      [:TEXT,    'l1',    2, 1],
-      [:NEWLINE, "\n",    5, 1],
-    ]
-
-    assert_equal expected, @RMP.tokenize(str)
-  end
-
-  def test_tokenize_lalpha
-    str = <<-STR
-a. l1
-b. l1.1
-    STR
-
-    expected = [
-      [:LALPHA,  'a',     0, 0],
-      [:TEXT,    'l1',    3, 0],
-      [:NEWLINE, "\n",    5, 0],
-      [:LALPHA,  'b',     0, 1],
-      [:TEXT,    'l1.1',  3, 1],
-      [:NEWLINE, "\n",    7, 1],
-    ]
-
-    assert_equal expected, @RMP.tokenize(str)
-  end
-
-  def test_tokenize_line_break
-    str = "now is\nthe time  \nfor all\n"
-
-    expected = [
-      [:TEXT,    'now is',    0, 0],
-      [:NEWLINE, "\n",        6, 0],
-      [:TEXT,    'the time',  0, 1],
-      [:BREAK,   "  ",        8, 1],
-      [:NEWLINE, "\n",       10, 1],
-      [:TEXT,    'for all',   0, 2],
-      [:NEWLINE, "\n",        7, 2],
-    ]
-
-    assert_equal expected, @RMP.tokenize(str)
-  end
-
-  def test_tokenize_line_break_long
-    str = "now is\nthe time   \nfor all\n"
-
-    expected = [
-      [:TEXT,    'now is',     0, 0],
-      [:NEWLINE, "\n",         6, 0],
-      [:TEXT,    'the time ',  0, 1],
-      [:BREAK,   '  ',         9, 1],
-      [:NEWLINE, "\n",        11, 1],
-      [:TEXT,    'for all',    0, 2],
-      [:NEWLINE, "\n",         7, 2],
-    ]
-
-    assert_equal expected, @RMP.tokenize(str)
-  end
-
-  def test_tokenize_line_break_no_short
-    str = "now is\nthe time \nfor all\n"
-
-    expected = [
-      [:TEXT,    'now is',    0, 0],
-      [:NEWLINE, "\n",        6, 0],
-      [:TEXT,    'the time ', 0, 1],
-      [:NEWLINE, "\n",        9, 1],
-      [:TEXT,    'for all',   0, 2],
-      [:NEWLINE, "\n",        7, 2],
-    ]
-
-    assert_equal expected, @RMP.tokenize(str)
-  end
-
-  def test_tokenize_note
-    str = <<-STR
-cat:: l1
-dog:: l1.1
-    STR
-
-    expected = [
-      [:NOTE,    'cat',   0, 0],
-      [:TEXT,    'l1',    6, 0],
-      [:NEWLINE, "\n",    8, 0],
-      [:NOTE,    'dog',   0, 1],
-      [:TEXT,    'l1.1',  6, 1],
-      [:NEWLINE, "\n",   10, 1],
-    ]
-
-    assert_equal expected, @RMP.tokenize(str)
-  end
-
-  def test_tokenize_note_empty
-    str = <<-STR
-cat::
-dog::
-    STR
-
-    expected = [
-      [:NOTE,    'cat', 0, 0],
-      [:NEWLINE, "\n",  5, 0],
-      [:NOTE,    'dog', 0, 1],
-      [:NEWLINE, "\n",  5, 1],
-    ]
-
-    assert_equal expected, @RMP.tokenize(str)
-  end
-
-  def test_tokenize_note_newline
-    str = <<-STR
-cat::
-  l1
-    STR
-
-    expected = [
-      [:NOTE,    'cat',   0, 0],
-      [:NEWLINE, "\n",    5, 0],
-      [:TEXT,    'l1',    2, 1],
-      [:NEWLINE, "\n",    4, 1],
-    ]
-
-    assert_equal expected, @RMP.tokenize(str)
-  end
-
-  def test_tokenize_note_utf_8
-    str = <<-STR
-cät:: l1a
-      l1b
-døg:: l2a
-      l2b
-    STR
-
-    expected = [
-      [:NOTE,    'cät',   0, 0],
-      [:TEXT,    'l1a',   6, 0],
-      [:NEWLINE, "\n",    9, 0],
-      [:TEXT,    'l1b',   6, 1],
-      [:NEWLINE, "\n",    9, 1],
-      [:NOTE,    'døg',   0, 2],
-      [:TEXT,    'l2a',   6, 2],
-      [:NEWLINE, "\n",    9, 2],
-      [:TEXT,    'l2b',   6, 3],
-      [:NEWLINE, "\n",    9, 3],
-    ]
-
-    assert_equal expected, @RMP.tokenize(str)
-  end
-
-  def test_tokenize_note_newline_windows
-    str = <<-STR
-cat::\r
-  l1\r
-    STR
-
-    expected = [
-      [:NOTE,    'cat',   0, 0],
-      [:NEWLINE, "\n",    6, 0],
-      [:TEXT,    'l1',    2, 1],
-      [:NEWLINE, "\n",    5, 1],
-    ]
-
-    assert_equal expected, @RMP.tokenize(str)
-  end
-
-  def test_tokenize_note_not
-    str = <<-STR
-Cat::Dog
-    STR
-
-    expected = [
-      [:TEXT,    'Cat::Dog', 0, 0],
-      [:NEWLINE, "\n",       8, 0],
-    ]
-
-    assert_equal expected, @RMP.tokenize(str)
-  end
-
-  def test_tokenize_number
-    str = <<-STR
-1. l1
-2. l1.1
-    STR
-
-    expected = [
-      [:NUMBER,  '1',     0, 0],
-      [:TEXT,    'l1',    3, 0],
-      [:NEWLINE, "\n",    5, 0],
-      [:NUMBER,  '2',     0, 1],
-      [:TEXT,    'l1.1',  3, 1],
-      [:NEWLINE, "\n",    7, 1],
-    ]
-
-    assert_equal expected, @RMP.tokenize(str)
-  end
-
-  def test_tokenize_number_period
-    str = <<-STR
-1. blah blah blah
-   l.
-2. blah blah blah blah
-   d.
-    STR
-
-    expected = [
-      [:NUMBER,  "1",                    0, 0],
-      [:TEXT,    "blah blah blah",       3, 0],
-      [:NEWLINE, "\n",                  17, 0],
-
-      [:TEXT,    "l.",                   3, 1],
-      [:NEWLINE, "\n",                   5, 1],
-
-      [:NUMBER,  "2",                    0, 2],
-      [:TEXT,    "blah blah blah blah",  3, 2],
-      [:NEWLINE, "\n",                  22, 2],
-
-      [:TEXT,    "d.",                   3, 3],
-      [:NEWLINE, "\n",                   5, 3]
-    ]
-
-    assert_equal expected, @RMP.tokenize(str)
-  end
-
-  def test_tokenize_number_period_continue
-    str = <<-STR
-1. blah blah blah
-   l.  more stuff
-2. blah blah blah blah
-   d. other stuff
-    STR
-
-    expected = [
-      [:NUMBER,  "1",                    0, 0],
-      [:TEXT,    "blah blah blah",       3, 0],
-      [:NEWLINE, "\n",                  17, 0],
-
-      [:LALPHA,  "l",                    3, 1],
-      [:TEXT,    "more stuff",           7, 1],
-      [:NEWLINE, "\n",                  17, 1],
-
-      [:NUMBER,  "2",                    0, 2],
-      [:TEXT,    "blah blah blah blah",  3, 2],
-      [:NEWLINE, "\n",                  22, 2],
-
-      [:LALPHA,  "d",                    3, 3],
-      [:TEXT,    "other stuff",          6, 3],
-      [:NEWLINE, "\n",                  17, 3]
-    ]
-
-    assert_equal expected, @RMP.tokenize(str)
-  end
-
-  def test_tokenize_paragraphs
-    str = <<-STR
-now is
-the time
-
-for all
-    STR
-
-    expected = [
-      [:TEXT,    'now is',   0, 0],
-      [:NEWLINE, "\n",       6, 0],
-      [:TEXT,    'the time', 0, 1],
-      [:NEWLINE, "\n",       8, 1],
-      [:NEWLINE, "\n",       0, 2],
-      [:TEXT,    'for all',  0, 3],
-      [:NEWLINE, "\n",       7, 3],
-    ]
-
-    assert_equal expected, @RMP.tokenize(str)
-  end
-
-  def test_tokenize_rule
-    str = <<-STR
----
-
---- blah ---
-    STR
-
-    expected = [
-      [:RULE,    1,            0, 0],
-      [:NEWLINE, "\n",         3, 0],
-      [:NEWLINE, "\n",         0, 1],
-      [:TEXT, "--- blah ---",  0, 2],
-      [:NEWLINE, "\n",        12, 2],
-    ]
-
-    assert_equal expected, @RMP.tokenize(str)
-  end
-
-  def test_tokenize_rule_windows
-    str = <<-STR
----\r
-
---- blah ---\r
-    STR
-
-    expected = [
-      [:RULE,    1,            0, 0],
-      [:NEWLINE, "\n",         4, 0],
-      [:NEWLINE, "\n",         0, 1],
-      [:TEXT, "--- blah ---",  0, 2],
-      [:NEWLINE, "\n",        13, 2],
-    ]
-
-    assert_equal expected, @RMP.tokenize(str)
-  end
-
-  def test_tokenize_ualpha
-    str = <<-STR
-A. l1
-B. l1.1
-    STR
-
-    expected = [
-      [:UALPHA,  'A',     0, 0],
-      [:TEXT,    'l1',    3, 0],
-      [:NEWLINE, "\n",    5, 0],
-      [:UALPHA,  'B',     0, 1],
-      [:TEXT,    'l1.1',  3, 1],
-      [:NEWLINE, "\n",    7, 1],
-    ]
-
-    assert_equal expected, @RMP.tokenize(str)
-  end
-
-  def test_tokenize_verbatim_heading
-    str = <<-STR
-Example heading:
-
-   === heading three
-    STR
-
-    expected = [
-      [:TEXT,    'Example heading:',  0, 0],
-      [:NEWLINE, "\n",               16, 0],
-      [:NEWLINE, "\n",                0, 1],
-      [:HEADER,  3,                   3, 2],
-      [:TEXT,    'heading three',     7, 2],
-      [:NEWLINE, "\n",               20, 2],
-    ]
-
-    assert_equal expected, @RMP.tokenize(str)
-  end
-
-  def test_tokenize_verbatim_rule
-    str = <<-STR
-  Verbatim section here that is double-underlined
-  ===============================================
-    STR
-
-    expected = [
-      [:TEXT,    'Verbatim section here that is double-underlined',  2, 0],
-      [:NEWLINE, "\n",                                              49, 0],
-      [:HEADER,  47,                                                 2, 1],
-      [:NEWLINE, "\n",                                              49, 1],
-    ]
-
-    assert_equal expected, @RMP.tokenize(str)
-  end
-
-  def test_tokenize_verbatim_rule_fancy
-    str = <<-STR
-  A
-    b
-  ===============================================
-    c
-    STR
-
-    expected = [
-      [:TEXT,    'A',   2, 0],
-      [:NEWLINE, "\n",  3, 0],
-      [:TEXT,    'b',   4, 1],
-      [:NEWLINE, "\n",  5, 1],
-      [:HEADER,  47,    2, 2],
-      [:NEWLINE, "\n", 49, 2],
-      [:TEXT,    'c',   4, 3],
-      [:NEWLINE, "\n",  5, 3],
-    ]
-
-    assert_equal expected, @RMP.tokenize(str)
-  end
-
-  # HACK move to Verbatim test case
-  def test_verbatim_normalize
-    v = @RM::Verbatim.new "foo\n", "\n", "\n", "bar\n"
-
-    v.normalize
-
-    assert_equal ["foo\n", "\n", "bar\n"], v.parts
-
-    v = @RM::Verbatim.new "foo\n", "\n"
-
-    v.normalize
-
-    assert_equal ["foo\n"], v.parts
-  end
-
-  def test_unget
-    parser = util_parser
-
-    parser.get
-
-    parser.unget
-
-    assert_equal [:HEADER, 1, 0, 0], parser.peek_token
-
-    assert_raise @RMP::Error do
-      parser.unget
-    end
-
-    assert_equal 8, parser.tokens.length
-  end
-
-  def util_parser
-    str = <<-STR
-= Heading
-
-Some text here
-some more text over here
-    STR
-
-    @parser = @RMP.new
-    @parser.tokenize str
-    @parser
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc/rdoc_markup_pre_process_test.rb b/test/mri/rdoc/rdoc/rdoc_markup_pre_process_test.rb
deleted file mode 100644
index 2a8cd92dd04..00000000000
--- a/test/mri/rdoc/rdoc/rdoc_markup_pre_process_test.rb
+++ /dev/null
@@ -1,481 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'helper'
-
-class RDoc::Markup::PreProcessTest < RDoc::TestCase
-
-  def setup
-    super
-
-    @tempfile = Tempfile.new 'test_rdoc_markup_pre_process'
-    @file_name = File.basename @tempfile.path
-    @dir  = File.dirname @tempfile.path
-
-    @pp = RDoc::Markup::PreProcess.new @tempfile.path, [@dir, File.dirname(__FILE__)]
-  end
-
-  def teardown
-    super
-
-    @tempfile.close!
-  end
-
-  def test_class_register
-    RDoc::Markup::PreProcess.register 'for_test' do raise 'fail' end
-
-    assert_equal %w[for_test], RDoc::Markup::PreProcess.registered.keys
-  end
-
-  def test_class_post_process
-    RDoc::Markup::PreProcess.post_process do end
-
-    assert_equal 1, RDoc::Markup::PreProcess.post_processors.length,
-                 proc{RDoc::Markup::PreProcess.post_processors.inspect}
-  end
-
-  def test_include_file
-    @tempfile.write <<-INCLUDE
-# -*- mode: rdoc; coding: utf-8; fill-column: 74; -*-
-
-Regular expressions (<i>regexp</i>s) are patterns which describe the
-contents of a string.
-    INCLUDE
-
-    @tempfile.flush
-    @tempfile.rewind
-
-    content = @pp.include_file @file_name, '', nil
-
-    expected = <<-EXPECTED
-Regular expressions (<i>regexp</i>s) are patterns which describe the
-contents of a string.
-    EXPECTED
-
-    assert_equal expected, content
-  end
-
-  def test_include_file_encoding_incompatible
-    @tempfile.write <<-INCLUDE
-# -*- mode: rdoc; coding: utf-8; fill-column: 74; -*-
-
-π
-    INCLUDE
-
-    @tempfile.flush
-    @tempfile.rewind
-
-    content = @pp.include_file @file_name, '', Encoding::US_ASCII
-
-    expected = "?\n"
-
-    assert_equal expected, content
-  end
-
-  def test_include_file_in_other_directory
-    content = nil
-    out, err = capture_output do
-      content = @pp.include_file "test.txt", '', nil
-    end
-
-    assert_empty out
-    assert_empty err
-
-    assert_equal "test file\n", content
-  end
-
-  def test_handle
-    text = "# :main: M\n"
-    output = nil
-    _, err = capture_output do
-      output = @pp.handle text
-    end
-
-    assert_include err, "The :main: directive is deprecated and will be removed in RDoc 7."
-    assert_equal "#\n", output
-  end
-
-  def test_handle_comment
-    text = "# :main: M\n"
-    c = comment text
-
-    output = nil
-    _, err = capture_output do
-      output = @pp.handle c
-    end
-
-    assert_include err, "The :main: directive is deprecated and will be removed in RDoc 7."
-    assert_equal "#\n", output
-  end
-
-  def test_handle_markup
-    c = comment ':markup: rd'
-
-    @pp.handle c
-
-    assert_equal 'rd', c.format
-  end
-
-  def test_handle_markup_empty
-    c = comment ':markup:'
-
-    @pp.handle c
-
-    assert_equal 'rdoc', c.format
-  end
-
-  def test_handle_post_process
-    cd = RDoc::CodeObject.new
-
-    RDoc::Markup::PreProcess.post_process do |text, code_object|
-      code_object.metadata[:stuff] = text
-
-      :junk
-    end
-
-    text = "# a b c\n"
-
-    out = @pp.handle text, cd
-
-    assert_equal "# a b c\n", out
-    assert_equal "# a b c\n", cd.metadata[:stuff]
-  end
-
-  def test_handle_unregistered
-    text = "# :x: y\n"
-    out = @pp.handle text
-
-    assert_equal text, out
-  end
-
-  def test_handle_directive_blankline
-    result = @pp.handle_directive '#', 'arg', 'a, b'
-
-    assert_equal "#:arg: a, b\n", result
-  end
-
-  def test_handle_directive_downcase
-    method = RDoc::AnyMethod.new nil, 'm'
-
-    @pp.handle_directive '', 'ARG', 'a, b', method
-
-    assert_equal 'a, b', method.params
-  end
-
-  def test_handle_directive_arg
-    method = RDoc::AnyMethod.new nil, 'm'
-
-    @pp.handle_directive '', 'arg', 'a, b', method
-
-    assert_equal 'a, b', method.params
-  end
-
-  def test_handle_directive_arg_no_context
-    result = @pp.handle_directive '', 'arg', 'a, b', nil
-
-    assert_equal ":arg: a, b\n", result
-  end
-
-  def test_handle_directive_args
-    method = RDoc::AnyMethod.new nil, 'm'
-
-    @pp.handle_directive '', 'args', 'a, b', method
-
-    assert_equal 'a, b', method.params
-  end
-
-  def test_handle_directive_block
-    result = @pp.handle_directive '', 'x', 'y' do |directive, param|
-      ''
-    end
-
-    assert_empty result
-  end
-
-  def test_handle_directive_block_false
-    result = @pp.handle_directive '', 'x', 'y' do |directive, param|
-      false
-    end
-
-    assert_equal ":x: y\n", result
-  end
-
-  def test_handle_directive_block_nil
-    result = @pp.handle_directive '', 'x', 'y' do |directive, param|
-      nil
-    end
-
-    assert_equal ":x: y\n", result
-  end
-
-  def test_handle_directive_category
-    context = RDoc::Context.new
-    original_section = context.current_section
-
-    @pp.handle_directive '', 'category', 'other', context
-
-    refute_equal original_section, context.current_section
-  end
-
-  def test_handle_directive_doc
-    code_object = RDoc::CodeObject.new
-    code_object.document_self = false
-    code_object.force_documentation = false
-
-    @pp.handle_directive '', 'doc', nil, code_object
-
-    assert code_object.document_self
-    assert code_object.force_documentation
-  end
-
-  def test_handle_directive_doc_no_context
-    result = @pp.handle_directive '', 'doc', nil
-
-    assert_equal "\n", result
-  end
-
-  def test_handle_directive_enddoc
-    code_object = RDoc::CodeObject.new
-
-    @pp.handle_directive '', 'enddoc', nil, code_object
-
-    assert code_object.done_documenting
-  end
-
-  def test_handle_directive_include
-    @tempfile.write 'included'
-    @tempfile.flush
-
-    result = @pp.handle_directive '', 'include', @file_name
-
-    assert_equal 'included', result
-  end
-
-  def test_handle_directive_main
-    @pp.options = RDoc::Options.new
-
-    _, err = capture_output do
-      @pp.handle_directive '', 'main', 'M'
-    end
-
-    assert_include err, "The :main: directive is deprecated and will be removed in RDoc 7."
-    assert_equal 'M', @pp.options.main_page
-  end
-
-  def test_handle_directive_notnew
-    m = RDoc::AnyMethod.new nil, 'm'
-
-    @pp.handle_directive '', 'notnew', nil, m
-
-    assert m.dont_rename_initialize
-  end
-
-  def test_handle_directive_not_new
-    m = RDoc::AnyMethod.new nil, 'm'
-
-    @pp.handle_directive '', 'not_new', nil, m
-
-    assert m.dont_rename_initialize
-  end
-
-  def test_handle_directive_not_dash_new
-    m = RDoc::AnyMethod.new nil, 'm'
-
-    @pp.handle_directive '', 'not-new', nil, m
-
-    assert m.dont_rename_initialize
-  end
-
-  def test_handle_directive_nodoc
-    code_object = RDoc::CodeObject.new
-    code_object.document_self = true
-    code_object.document_children = true
-
-    @pp.handle_directive '', 'nodoc', nil, code_object
-
-    refute code_object.document_self
-    assert code_object.document_children
-  end
-
-  def test_handle_directive_nodoc_all
-    code_object = RDoc::CodeObject.new
-    code_object.document_self = true
-    code_object.document_children = true
-
-    @pp.handle_directive '', 'nodoc', 'all', code_object
-
-    refute code_object.document_self
-    refute code_object.document_children
-  end
-
-  def test_handle_directive_nodoc_no_context
-    result = @pp.handle_directive '', 'nodoc', nil
-
-    assert_equal "\n", result
-  end
-
-  def test_handle_directive_registered
-    RDoc::Markup::PreProcess.register 'x'
-
-    result = @pp.handle_directive '', 'x', 'y'
-
-    assert_nil result
-
-    result = @pp.handle_directive '', 'x', 'y' do |directive, param|
-      false
-    end
-
-    assert_equal ":x: y\n", result
-
-    result = @pp.handle_directive '', 'x', 'y' do |directive, param|
-      ''
-    end
-
-    assert_equal '', result
-  end
-
-  def test_handle_directive_registered_block
-    called = nil
-
-    RDoc::Markup::PreProcess.register 'x' do |directive, param|
-      called = [directive, param]
-      'blah'
-    end
-
-    result = @pp.handle_directive '', 'x', 'y'
-
-    assert_equal 'blah', result
-    assert_equal %w[x y], called
-  end
-
-  def test_handle_directive_registered_code_object
-    RDoc::Markup::PreProcess.register 'x'
-    code_object = RDoc::CodeObject.new
-
-    @pp.handle_directive '', 'x', 'y', code_object
-
-    assert_equal 'y', code_object.metadata['x']
-
-    code_object.metadata.clear
-
-    result = @pp.handle_directive '', 'x', 'y' do |directive, param|
-      false
-    end
-
-    assert_equal ":x: y\n", result
-    assert_empty code_object.metadata
-
-    result = @pp.handle_directive '', 'x', 'y' do |directive, param|
-      ''
-    end
-
-    assert_equal '', result
-    assert_empty code_object.metadata
-  end
-
-  def test_handle_directive_startdoc
-    code_object = RDoc::CodeObject.new
-    code_object.stop_doc
-    code_object.force_documentation = false
-
-    @pp.handle_directive '', 'startdoc', nil, code_object
-
-    assert code_object.document_self
-    assert code_object.document_children
-    assert code_object.force_documentation
-  end
-
-  def test_handle_directive_stopdoc
-    code_object = RDoc::CodeObject.new
-
-    @pp.handle_directive '', 'stopdoc', nil, code_object
-
-    refute code_object.document_self
-    refute code_object.document_children
-  end
-
-  def test_handle_directive_title
-    @pp.options = RDoc::Options.new
-
-    _, err = capture_output do
-      @pp.handle_directive '', 'title', 'T'
-    end
-
-    assert_include err, "The :title: directive is deprecated and will be removed in RDoc 7."
-    assert_equal 'T', @pp.options.title
-  end
-
-  def test_handle_directive_unhandled
-    code_object = RDoc::CodeObject.new
-
-    @pp.handle_directive '', 'x', 'y', code_object
-
-    assert_equal 'y', code_object.metadata['x']
-
-    code_object.metadata.clear
-
-    @pp.handle_directive '', 'x', '', code_object
-
-    assert_includes code_object.metadata, 'x'
-  end
-
-  def test_handle_directive_unhandled_block
-    code_object = RDoc::CodeObject.new
-
-    @pp.handle_directive '', 'x', 'y', code_object do
-      false
-    end
-
-    assert_empty code_object.metadata
-
-    @pp.handle_directive '', 'x', 'y', code_object do
-      nil
-    end
-
-    assert_equal 'y', code_object.metadata['x']
-
-    code_object.metadata.clear
-
-    @pp.handle_directive '', 'x', 'y', code_object do
-      ''
-    end
-
-    assert_empty code_object.metadata
-  end
-
-  def test_handle_directive_yield
-    method = RDoc::AnyMethod.new nil, 'm'
-    method.params = 'index, &block'
-
-    @pp.handle_directive '', 'yield', 'item', method
-
-    assert_equal 'item', method.block_params
-    assert_equal 'index', method.params
-  end
-
-  def test_handle_directive_yield_block_param
-    method = RDoc::AnyMethod.new nil, 'm'
-    method.params = '&block'
-
-    @pp.handle_directive '', 'yield', 'item', method
-
-    assert_equal 'item', method.block_params
-    assert_empty method.params
-  end
-
-  def test_handle_directive_yield_no_context
-    method = RDoc::AnyMethod.new nil, 'm'
-
-    @pp.handle_directive '', 'yield', 'item', method
-
-    assert_equal 'item', method.block_params
-  end
-
-  def test_handle_directive_yields
-    method = RDoc::AnyMethod.new nil, 'm'
-
-    @pp.handle_directive '', 'yields', 'item', method
-
-    assert_equal 'item', method.block_params
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc/rdoc_markup_raw_test.rb b/test/mri/rdoc/rdoc/rdoc_markup_raw_test.rb
deleted file mode 100644
index a1599ebb6c7..00000000000
--- a/test/mri/rdoc/rdoc/rdoc_markup_raw_test.rb
+++ /dev/null
@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocMarkupRawTest < RDoc::TestCase
-
-  def setup
-    super
-
-    @p = @RM::Raw.new
-  end
-
-  def test_push
-    @p.push 'hi', 'there'
-
-    assert_equal @RM::Raw.new('hi', 'there'), @p
-  end
-
-  def test_pretty_print
-    assert_equal '[raw: ]', mu_pp(@p)
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc/rdoc_markup_test.rb b/test/mri/rdoc/rdoc/rdoc_markup_test.rb
deleted file mode 100644
index d9d3d25e227..00000000000
--- a/test/mri/rdoc/rdoc/rdoc_markup_test.rb
+++ /dev/null
@@ -1,95 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocMarkupTest < RDoc::TestCase
-
-  def test_class_parse
-    expected = @RM::Document.new(
-      @RM::Paragraph.new('hello'))
-
-    assert_equal expected, RDoc::Markup.parse('hello')
-  end
-
-  def test_convert
-    str = <<-STR
-now is
-the time
-
-  hello
-  dave
-
-1. l1
-2. l2
-    STR
-
-    m = RDoc::Markup.new
-
-    tt = RDoc::Markup::ToTest.new m
-
-    out = m.convert str, tt
-
-    expected = [
-      "now is the time",
-      "\n",
-      "  hello\n  dave\n",
-      "1: ",
-      "l1",
-      "1: ",
-      "l2",
-    ]
-
-    assert_equal expected, out
-  end
-
-  def test_convert_custom_markup
-    str = <<-STR
-{stricken}
-    STR
-
-    m = RDoc::Markup.new
-    m.add_word_pair '{', '}', :STRIKE
-
-    tt = RDoc::Markup::ToTest.new nil, m
-    tt.add_tag :STRIKE, 'STRIKE ', ' STRIKE'
-
-    out = m.convert str, tt
-
-    expected = [
-      "STRIKE stricken STRIKE",
-    ]
-
-    assert_equal expected, out
-  end
-
-  def test_convert_document
-    doc = RDoc::Markup::Parser.parse <<-STR
-now is
-the time
-
-  hello
-  dave
-
-1. l1
-2. l2
-    STR
-
-    m = RDoc::Markup.new
-
-    tt = RDoc::Markup::ToTest.new m
-
-    out = m.convert doc, tt
-
-    expected = [
-      "now is the time",
-      "\n",
-      "  hello\n  dave\n",
-      "1: ",
-      "l1",
-      "1: ",
-      "l2",
-    ]
-
-    assert_equal expected, out
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc/rdoc_markup_to_ansi_test.rb b/test/mri/rdoc/rdoc/rdoc_markup_to_ansi_test.rb
deleted file mode 100644
index 020f5469973..00000000000
--- a/test/mri/rdoc/rdoc/rdoc_markup_to_ansi_test.rb
+++ /dev/null
@@ -1,380 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocMarkupToAnsiTest < RDoc::Markup::TextFormatterTestCase
-
-  add_visitor_tests
-  add_text_tests
-
-  def setup
-    super
-
-    @to = RDoc::Markup::ToAnsi.new
-  end
-
-  def accept_blank_line
-    assert_equal "\e[0m\n", @to.res.join
-  end
-
-  def accept_block_quote
-    assert_equal "\e[0m> quote\n", @to.res.join
-  end
-
-  def accept_document
-    assert_equal "\e[0mhello\n", @to.res.join
-  end
-
-  def accept_heading
-    assert_equal "\e[0mHello\n", @to.res.join
-  end
-
-  def accept_list_end_bullet
-    assert_empty @to.list_index
-    assert_empty @to.list_type
-    assert_empty @to.list_width
-  end
-
-  def accept_list_end_label
-    assert_empty @to.list_index
-    assert_empty @to.list_type
-    assert_empty @to.list_width
-  end
-
-  def accept_list_end_lalpha
-    assert_empty @to.list_index
-    assert_empty @to.list_type
-    assert_empty @to.list_width
-  end
-
-  def accept_list_end_note
-    assert_empty @to.list_index
-    assert_empty @to.list_type
-    assert_empty @to.list_width
-  end
-
-  def accept_list_end_number
-    assert_empty @to.list_index
-    assert_empty @to.list_type
-    assert_empty @to.list_width
-  end
-
-  def accept_list_end_ualpha
-    assert_empty @to.list_index
-    assert_empty @to.list_type
-    assert_empty @to.list_width
-  end
-
-  def accept_list_item_end_bullet
-    assert_equal 0, @to.indent, 'indent'
-  end
-
-  def accept_list_item_end_label
-    assert_equal "\e[0mcat:\n", @to.res.join
-    assert_equal 0, @to.indent, 'indent'
-  end
-
-  def accept_list_item_end_lalpha
-    assert_equal 0, @to.indent, 'indent'
-    assert_equal 'b', @to.list_index.last
-  end
-
-  def accept_list_item_end_note
-    assert_equal "\e[0mcat:\n", @to.res.join
-    assert_equal 0, @to.indent, 'indent'
-  end
-
-  def accept_list_item_end_number
-    assert_equal 0, @to.indent, 'indent'
-    assert_equal 2, @to.list_index.last
-  end
-
-  def accept_list_item_end_ualpha
-    assert_equal 0, @to.indent, 'indent'
-    assert_equal 'B', @to.list_index.last
-  end
-
-  def accept_list_item_start_bullet
-    assert_equal %W"\e[0m", @to.res
-    assert_equal '* ', @to.prefix
-  end
-
-  def accept_list_item_start_label
-    assert_equal %W"\e[0m", @to.res
-    assert_equal "cat:\n  ", @to.prefix
-
-    assert_equal 2, @to.indent
-  end
-
-  def accept_list_item_start_lalpha
-    assert_equal %W"\e[0m", @to.res
-    assert_equal 'a. ', @to.prefix
-
-    assert_equal 'a', @to.list_index.last
-    assert_equal 3, @to.indent
-  end
-
-  def accept_list_item_start_note
-    assert_equal %W"\e[0m", @to.res
-    assert_equal "cat:\n  ", @to.prefix
-
-    assert_equal 2, @to.indent
-  end
-
-  def accept_list_item_start_number
-    assert_equal %W"\e[0m", @to.res
-    assert_equal '1. ', @to.prefix
-
-    assert_equal 1, @to.list_index.last
-    assert_equal 3, @to.indent
-  end
-
-  def accept_list_item_start_ualpha
-    assert_equal %W"\e[0m", @to.res
-    assert_equal 'A. ', @to.prefix
-
-    assert_equal 'A', @to.list_index.last
-    assert_equal 3, @to.indent
-  end
-
-  def accept_list_start_bullet
-    assert_equal "\e[0m",   @to.res.join
-    assert_equal [nil],     @to.list_index
-    assert_equal [:BULLET], @to.list_type
-    assert_equal [1],       @to.list_width
-  end
-
-  def accept_list_start_label
-    assert_equal "\e[0m",  @to.res.join
-    assert_equal [nil],    @to.list_index
-    assert_equal [:LABEL], @to.list_type
-    assert_equal [2],      @to.list_width
-  end
-
-  def accept_list_start_lalpha
-    assert_equal "\e[0m",   @to.res.join
-    assert_equal ['a'],     @to.list_index
-    assert_equal [:LALPHA], @to.list_type
-    assert_equal [1],       @to.list_width
-  end
-
-  def accept_list_start_note
-    assert_equal "\e[0m", @to.res.join
-    assert_equal [nil],   @to.list_index
-    assert_equal [:NOTE], @to.list_type
-    assert_equal [2],     @to.list_width
-  end
-
-  def accept_list_start_number
-    assert_equal "\e[0m",   @to.res.join
-    assert_equal [1],       @to.list_index
-    assert_equal [:NUMBER], @to.list_type
-    assert_equal [1],       @to.list_width
-  end
-
-  def accept_list_start_ualpha
-    assert_equal "\e[0m",   @to.res.join
-    assert_equal ['A'],     @to.list_index
-    assert_equal [:UALPHA], @to.list_type
-    assert_equal [1],       @to.list_width
-  end
-
-  def accept_paragraph
-    assert_equal "\e[0mhi\n", @to.res.join
-  end
-
-  def accept_raw
-    raw = <<-RAW.rstrip
-\e[0m<table>
-<tr><th>Name<th>Count
-<tr><td>a<td>1
-<tr><td>b<td>2
-</table>
-    RAW
-
-    assert_equal raw, @to.res.join
-  end
-
-  def accept_rule
-    assert_equal "\e[0m#{'-' * 78}\n", @to.res.join
-  end
-
-  def accept_verbatim
-    assert_equal "\e[0m  hi\n    world\n\n", @to.res.join
-  end
-
-  def end_accepting
-    assert_equal "\e[0mhi", @to.end_accepting
-  end
-
-  def start_accepting
-    assert_equal 0, @to.indent
-    assert_equal %W"\e[0m", @to.res
-    assert_empty @to.list_index
-    assert_empty @to.list_type
-    assert_empty @to.list_width
-  end
-
-  def accept_heading_1
-    assert_equal "\e[0m\e[1;32mHello\e[m\n", @to.end_accepting
-  end
-
-  def accept_heading_2
-    assert_equal "\e[0m\e[4;32mHello\e[m\n", @to.end_accepting
-  end
-
-  def accept_heading_3
-    assert_equal "\e[0m\e[32mHello\e[m\n", @to.end_accepting
-  end
-
-  def accept_heading_4
-    assert_equal "\e[0mHello\n", @to.end_accepting
-  end
-
-  def accept_heading_indent
-    assert_equal "\e[0m   \e[1;32mHello\e[m\n", @to.end_accepting
-  end
-
-  def accept_heading_b
-    assert_equal "\e[0m\e[1;32m\e[1mHello\e[m\e[m\n", @to.end_accepting
-  end
-
-  def accept_heading_suppressed_crossref
-    assert_equal "\e[0m\e[1;32mHello\e[m\n", @to.end_accepting
-  end
-
-  def accept_list_item_start_note_2
-    assert_equal "\e[0m\e[7mteletype\e[m:\n  teletype description\n\n",
-                 @to.res.join
-  end
-
-  def accept_list_item_start_note_multi_description
-    assert_equal "\e[0mlabel:\n  description one\n\n  description two\n\n",
-                 @to.res.join
-  end
-
-  def accept_list_item_start_note_multi_label
-    assert_equal "\e[0mone\ntwo:\n  two headers\n\n",
-                 @to.res.join
-  end
-
-  def accept_paragraph_b
-    assert_equal "\e[0mreg \e[1mbold words\e[m reg\n", @to.end_accepting
-  end
-
-  def accept_paragraph_br
-    assert_equal "\e[0mone\ntwo\n", @to.end_accepting
-  end
-
-  def accept_paragraph_break
-    assert_equal "\e[0mhello\nworld\n", @to.end_accepting
-  end
-
-  def accept_paragraph_i
-    assert_equal "\e[0mreg \e[4mitalic words\e[m reg\n", @to.end_accepting
-  end
-
-  def accept_paragraph_indent
-    expected = <<-EXPECTED
-\e[0m   words words words words words words words words words words words words
-   words words words words words words words words words words words words
-   words words words words words words
-    EXPECTED
-
-    assert_equal expected, @to.end_accepting
-  end
-
-  def accept_paragraph_plus
-    assert_equal "\e[0mreg \e[7mteletype\e[m reg\n", @to.end_accepting
-  end
-
-  def accept_paragraph_star
-    assert_equal "\e[0mreg \e[1mbold\e[m reg\n", @to.end_accepting
-  end
-
-  def accept_paragraph_underscore
-    assert_equal "\e[0mreg \e[4mitalic\e[m reg\n", @to.end_accepting
-  end
-
-  def accept_paragraph_wrap
-    expected = <<-EXPECTED
-\e[0mwords words words words words words words words words words words words words
-words words words words words words words words words words words words words
-words words words words
-    EXPECTED
-
-    assert_equal expected, @to.end_accepting
-  end
-
-  def accept_rule_indent
-    assert_equal "\e[0m   #{'-' * 75}\n", @to.end_accepting
-  end
-
-  def accept_verbatim_indent
-    assert_equal "\e[0m    hi\n     world\n\n", @to.end_accepting
-  end
-
-  def accept_verbatim_big_indent
-    assert_equal "\e[0m    hi\n    world\n\n", @to.end_accepting
-  end
-
-  def list_nested
-    expected = <<-EXPECTED
-\e[0m* l1
-  * l1.1
-* l2
-    EXPECTED
-
-    assert_equal expected, @to.end_accepting
-  end
-
-  def list_verbatim
-    expected = <<-EXPECTED # HACK overblown
-\e[0m* list stuff
-
-    * list
-      with
-
-      second
-
-      1. indented
-      2. numbered
-
-      third
-
-    * second
-
-    EXPECTED
-
-    assert_equal expected, @to.end_accepting
-  end
-
-  def accept_table_align
-    expected = "\e[0m" + <<-EXPECTED
- AA |BB |CCCCC|DDDDD
-----|---|-----|-----
-    |bbb|    c|
-aaaa|b  |     | dd
- a  |   |   cc| dd
-    EXPECTED
-    assert_equal expected, @to.end_accepting
-  end
-
-  # functional test
-  def test_convert_list_note
-    note_list = <<-NOTE_LIST
-foo ::
-bar ::
-  hi
-    NOTE_LIST
-
-    expected = <<-EXPECTED
-\e[0mfoo
-bar:
-  hi
-
-    EXPECTED
-
-    assert_equal expected, @to.convert(note_list)
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc/rdoc_markup_to_bs_test.rb b/test/mri/rdoc/rdoc/rdoc_markup_to_bs_test.rb
deleted file mode 100644
index d89d784422c..00000000000
--- a/test/mri/rdoc/rdoc/rdoc_markup_to_bs_test.rb
+++ /dev/null
@@ -1,363 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocMarkupToBsTest < RDoc::Markup::TextFormatterTestCase
-
-  add_visitor_tests
-  add_text_tests
-
-  def setup
-    super
-
-    @to = RDoc::Markup::ToBs.new
-  end
-
-  def accept_blank_line
-    assert_equal "\n", @to.res.join
-  end
-
-  def accept_block_quote
-    assert_equal "> quote\n", @to.res.join
-  end
-
-  def accept_document
-    assert_equal "hello\n", @to.res.join
-  end
-
-  def accept_heading
-    assert_equal "===== H\bHe\bel\bll\blo\bo\n", @to.res.join
-  end
-
-  def accept_list_end_bullet
-    assert_empty @to.list_index
-    assert_empty @to.list_type
-    assert_empty @to.list_width
-  end
-
-  def accept_list_end_label
-    assert_empty @to.list_index
-    assert_empty @to.list_type
-    assert_empty @to.list_width
-  end
-
-  def accept_list_end_lalpha
-    assert_empty @to.list_index
-    assert_empty @to.list_type
-    assert_empty @to.list_width
-  end
-
-  def accept_list_end_note
-    assert_empty @to.list_index
-    assert_empty @to.list_type
-    assert_empty @to.list_width
-  end
-
-  def accept_list_end_number
-    assert_empty @to.list_index
-    assert_empty @to.list_type
-    assert_empty @to.list_width
-  end
-
-  def accept_list_end_ualpha
-    assert_empty @to.list_index
-    assert_empty @to.list_type
-    assert_empty @to.list_width
-  end
-
-  def accept_list_item_end_bullet
-    assert_equal 0, @to.indent, 'indent'
-  end
-
-  def accept_list_item_end_label
-    assert_equal "cat:\n", @to.res.join
-    assert_equal 0, @to.indent, 'indent'
-  end
-
-  def accept_list_item_end_lalpha
-    assert_equal 0, @to.indent, 'indent'
-    assert_equal 'b', @to.list_index.last
-  end
-
-  def accept_list_item_end_note
-    assert_equal "cat:\n", @to.res.join
-    assert_equal 0, @to.indent, 'indent'
-  end
-
-  def accept_list_item_end_number
-    assert_equal 0, @to.indent, 'indent'
-    assert_equal 2, @to.list_index.last
-  end
-
-  def accept_list_item_end_ualpha
-    assert_equal 0, @to.indent, 'indent'
-    assert_equal 'B', @to.list_index.last
-  end
-
-  def accept_list_item_start_bullet
-    assert_equal [''], @to.res
-    assert_equal '* ', @to.prefix
-  end
-
-  def accept_list_item_start_label
-    assert_equal [''], @to.res
-    assert_equal "cat:\n  ", @to.prefix
-
-    assert_equal 2, @to.indent
-  end
-
-  def accept_list_item_start_lalpha
-    assert_equal [''], @to.res
-    assert_equal 'a. ', @to.prefix
-
-    assert_equal 'a', @to.list_index.last
-    assert_equal 3, @to.indent
-  end
-
-  def accept_list_item_start_note
-    assert_equal [''], @to.res
-    assert_equal "cat:\n  ", @to.prefix
-
-    assert_equal 2, @to.indent
-  end
-
-  def accept_list_item_start_number
-    assert_equal [''], @to.res
-    assert_equal '1. ', @to.prefix
-
-    assert_equal 1, @to.list_index.last
-    assert_equal 3, @to.indent
-  end
-
-  def accept_list_item_start_ualpha
-    assert_equal [''], @to.res
-    assert_equal 'A. ', @to.prefix
-
-    assert_equal 'A', @to.list_index.last
-    assert_equal 3, @to.indent
-  end
-
-  def accept_list_start_bullet
-    assert_equal "",   @to.res.join
-    assert_equal [nil],     @to.list_index
-    assert_equal [:BULLET], @to.list_type
-    assert_equal [1],       @to.list_width
-  end
-
-  def accept_list_start_label
-    assert_equal "",  @to.res.join
-    assert_equal [nil],    @to.list_index
-    assert_equal [:LABEL], @to.list_type
-    assert_equal [2],      @to.list_width
-  end
-
-  def accept_list_start_lalpha
-    assert_equal "",   @to.res.join
-    assert_equal ['a'],     @to.list_index
-    assert_equal [:LALPHA], @to.list_type
-    assert_equal [1],       @to.list_width
-  end
-
-  def accept_list_start_note
-    assert_equal "", @to.res.join
-    assert_equal [nil],   @to.list_index
-    assert_equal [:NOTE], @to.list_type
-    assert_equal [2],     @to.list_width
-  end
-
-  def accept_list_start_number
-    assert_equal "",   @to.res.join
-    assert_equal [1],       @to.list_index
-    assert_equal [:NUMBER], @to.list_type
-    assert_equal [1],       @to.list_width
-  end
-
-  def accept_list_start_ualpha
-    assert_equal "",   @to.res.join
-    assert_equal ['A'],     @to.list_index
-    assert_equal [:UALPHA], @to.list_type
-    assert_equal [1],       @to.list_width
-  end
-
-  def accept_paragraph
-    assert_equal "hi\n", @to.res.join
-  end
-
-  def accept_raw
-    raw = <<-RAW.rstrip
-<table>
-<tr><th>Name<th>Count
-<tr><td>a<td>1
-<tr><td>b<td>2
-</table>
-    RAW
-
-    assert_equal raw, @to.res.join
-  end
-
-  def accept_rule
-    assert_equal "#{'-' * 78}\n", @to.res.join
-  end
-
-  def accept_verbatim
-    assert_equal "  hi\n    world\n\n", @to.res.join
-  end
-
-  def end_accepting
-    assert_equal "hi", @to.end_accepting
-  end
-
-  def start_accepting
-    assert_equal 0, @to.indent
-    assert_equal [''], @to.res
-    assert_empty @to.list_index
-    assert_empty @to.list_type
-    assert_empty @to.list_width
-  end
-
-  def accept_heading_1
-    assert_equal "= H\bHe\bel\bll\blo\bo\n", @to.end_accepting
-  end
-
-  def accept_heading_2
-    assert_equal "== H\bHe\bel\bll\blo\bo\n", @to.end_accepting
-  end
-
-  def accept_heading_3
-    assert_equal "=== H\bHe\bel\bll\blo\bo\n", @to.end_accepting
-  end
-
-  def accept_heading_4
-    assert_equal "==== H\bHe\bel\bll\blo\bo\n", @to.end_accepting
-  end
-
-  def accept_heading_indent
-    assert_equal "   = H\bHe\bel\bll\blo\bo\n", @to.end_accepting
-  end
-
-  def accept_heading_b
-    assert_equal "= H\bHe\bel\bll\blo\bo\n", @to.end_accepting
-  end
-
-  def accept_heading_suppressed_crossref
-    assert_equal "= H\bHe\bel\bll\blo\bo\n", @to.end_accepting
-  end
-
-  def accept_list_item_start_note_2
-    assert_equal "teletype:\n  teletype description\n\n", @to.res.join
-  end
-
-  def accept_list_item_start_note_multi_description
-    assert_equal "label:\n  description one\n\n  description two\n\n",
-                 @to.res.join
-  end
-
-  def accept_list_item_start_note_multi_label
-    assert_equal "one\ntwo:\n  two headers\n\n", @to.res.join
-  end
-
-  def accept_paragraph_b
-    assert_equal "reg b\bbo\bol\bld\bd \b w\bwo\bor\brd\bds\bs reg\n",
-                 @to.end_accepting
-  end
-
-  def accept_paragraph_br
-    assert_equal "one\ntwo\n", @to.end_accepting
-  end
-
-  def accept_paragraph_break
-    assert_equal "hello\nworld\n",
-                 @to.end_accepting
-  end
-
-  def accept_paragraph_i
-    assert_equal "reg _\bi_\bt_\ba_\bl_\bi_\bc_\b _\bw_\bo_\br_\bd_\bs reg\n",
-                 @to.end_accepting
-  end
-
-  def accept_paragraph_indent
-    expected = <<-EXPECTED
-   words words words words words words words words words words words words
-   words words words words words words words words words words words words
-   words words words words words words
-    EXPECTED
-
-    assert_equal expected, @to.end_accepting
-  end
-
-  def accept_paragraph_plus
-    assert_equal "reg teletype reg\n", @to.end_accepting
-  end
-
-  def accept_paragraph_star
-    assert_equal "reg b\bbo\bol\bld\bd reg\n", @to.end_accepting
-  end
-
-  def accept_paragraph_underscore
-    assert_equal "reg _\bi_\bt_\ba_\bl_\bi_\bc reg\n", @to.end_accepting
-  end
-
-  def accept_paragraph_wrap
-    expected = <<-EXPECTED
-words words words words words words words words words words words words words
-words words words words words words words words words words words words words
-words words words words
-    EXPECTED
-
-    assert_equal expected, @to.end_accepting
-  end
-
-  def accept_rule_indent
-    assert_equal "   #{'-' * 75}\n", @to.end_accepting
-  end
-
-  def accept_verbatim_indent
-    assert_equal "    hi\n     world\n\n", @to.end_accepting
-  end
-
-  def accept_verbatim_big_indent
-    assert_equal "    hi\n    world\n\n", @to.end_accepting
-  end
-
-  def list_nested
-    expected = <<-EXPECTED
-* l1
-  * l1.1
-* l2
-    EXPECTED
-
-    assert_equal expected, @to.end_accepting
-  end
-
-  def list_verbatim
-    expected = <<-EXPECTED # HACK overblown
-* list stuff
-
-    * list
-      with
-
-      second
-
-      1. indented
-      2. numbered
-
-      third
-
-    * second
-
-    EXPECTED
-
-    assert_equal expected, @to.end_accepting
-  end
-
-  def accept_table_align
-    expected = <<-EXPECTED
- AA |BB |CCCCC|DDDDD
-----|---|-----|-----
-    |bbb|    c|
-aaaa|b  |     | dd
- a  |   |   cc| dd
-    EXPECTED
-    assert_equal expected, @to.end_accepting
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc/rdoc_markup_to_html_crossref_test.rb b/test/mri/rdoc/rdoc/rdoc_markup_to_html_crossref_test.rb
deleted file mode 100644
index a52c7f1506d..00000000000
--- a/test/mri/rdoc/rdoc/rdoc_markup_to_html_crossref_test.rb
+++ /dev/null
@@ -1,325 +0,0 @@
-# frozen_string_literal: true
-require_relative 'xref_test_case'
-
-class RDocMarkupToHtmlCrossrefTest < XrefTestCase
-
-  def setup
-    super
-
-    @options.hyperlink_all = true
-    @options.warn_missing_rdoc_ref = true
-
-    @to = RDoc::Markup::ToHtmlCrossref.new @options, 'index.html', @c1
-  end
-
-  def test_convert_CROSSREF
-    result = @to.convert 'C1'
-
-    assert_equal para("<a href=\"C1.html\"><code>C1</code></a>"), result
-
-    result = @to.convert '+C1+'
-    assert_equal para("<a href=\"C1.html\"><code>C1</code></a>"), result
-
-    result = @to.convert 'Constant[rdoc-ref:C1]'
-    assert_equal para("<a href=\"C1.html\">Constant</a>"), result
-
-    result = @to.convert 'FOO'
-    assert_equal para("FOO"), result
-
-    result = @to.convert '+FOO+'
-    assert_equal para("<code>FOO</code>"), result
-
-    result = @to.convert '<tt># :stopdoc:</tt>:'
-    assert_equal para("<code># :stopdoc:</code>:"), result
-  end
-
-  def test_convert_CROSSREF_ignored_excluded_words
-    @options.autolink_excluded_words = ['C1']
-
-    result = @to.convert 'C1'
-    assert_equal para("C1"), result
-
-    result = @to.convert '+C1+'
-    assert_equal para("<a href=\"C1.html\"><code>C1</code></a>"), result
-
-    # Explicit linking with rdoc-ref is not ignored
-    result = @to.convert 'Constant[rdoc-ref:C1]'
-    assert_equal para("<a href=\"C1.html\">Constant</a>"), result
-  end
-
-  def test_convert_CROSSREF_method
-    result = @to.convert 'C1#m(foo, bar, baz)'
-
-    assert_equal para("<a href=\"C1.html#method-i-m\"><code>C1#m(foo, bar, baz)</code></a>"), result
-  end
-
-  def test_convert_CROSSREF_label
-    result = @to.convert 'C1@foo'
-    assert_equal para("<a href=\"C1.html#class-C1-label-foo\">foo at <code>C1</code></a>"), result
-
-    result = @to.convert 'C1#m@foo'
-    assert_equal para("<a href=\"C1.html#method-i-m-label-foo\">foo at <code>C1#m</code></a>"),
-                 result
-  end
-
-  def test_convert_CROSSREF_label_for_md
-    result = @to.convert 'EXAMPLE@foo'
-    assert_equal para("<a href=\"EXAMPLE_md.html#label-foo\">foo at <code>EXAMPLE</code></a>"), result
-  end
-
-  def test_convert_CROSSREF_label_period
-    result = @to.convert 'C1@foo.'
-    assert_equal para("<a href=\"C1.html#class-C1-label-foo\">foo at <code>C1</code></a>."), result
-  end
-
-  def test_convert_CROSSREF_label_space
-    result = @to.convert 'C1@foo+bar'
-    assert_equal para("<a href=\"C1.html#class-C1-label-foo+bar\">foo bar at <code>C1</code></a>"),
-                 result
-  end
-
-  def test_convert_CROSSREF_section
-    @c1.add_section 'Section'
-
-    result = @to.convert 'C1@Section'
-    assert_equal para("<a href=\"C1.html#Section\">Section at <code>C1</code></a>"), result
-  end
-
-  def test_convert_CROSSREF_constant
-    result = @to.convert 'C1::CONST'
-
-    assert_equal para("<a href=\"C1.html#CONST\"><code>C1::CONST</code></a>"), result
-  end
-
-  def test_convert_RDOCLINK_rdoc_ref
-    result = @to.convert 'rdoc-ref:C1'
-
-    assert_equal para("<a href=\"C1.html\"><code>C1</code></a>"), result
-  end
-
-  def test_convert_RDOCLINK_rdoc_ref_not_found
-    result = nil
-    stdout, _ = capture_output do
-      result = @to.convert 'rdoc-ref:FOO'
-    end
-
-    assert_equal para("FOO"), result
-    assert_include stdout, "index.html: `rdoc-ref:FOO` can't be resolved for `FOO`"
-  end
-
-  def test_convert_RDOCLINK_rdoc_ref_method
-    result = @to.convert 'rdoc-ref:C1#m'
-
-    assert_equal para("<a href=\"C1.html#method-i-m\"><code>C1#m</code></a>"), result
-  end
-
-  def test_convert_RDOCLINK_rdoc_ref_method_label
-    result = @to.convert 'rdoc-ref:C1#m@foo'
-
-    assert_equal para("<a href=\"C1.html#method-i-m-label-foo\">foo at <code>C1#m</code></a>"),
-                 result, 'rdoc-ref:C1#m@foo'
-  end
-
-  def test_convert_RDOCLINK_rdoc_ref_method_percent
-    m = @c1.add_method RDoc::AnyMethod.new nil, '%'
-
-    result = @to.convert 'rdoc-ref:C1#%'
-
-    assert_equal para("<a href=\"C1.html#method-i-25\"><code>C1#%</code></a>"), result
-
-    m.singleton = true
-
-    result = @to.convert 'rdoc-ref:C1::%'
-
-    assert_equal para("<a href=\"C1.html#method-c-25\"><code>C1::%</code></a>"), result
-  end
-
-  def test_convert_RDOCLINK_rdoc_ref_method_escape_html
-    m = @c1.add_method RDoc::AnyMethod.new nil, '<<'
-
-    result = @to.convert 'rdoc-ref:C1#<<'
-
-    assert_equal para("<a href=\"C1.html#method-i-3C-3C\"><code>C1#<<</code></a>"), result
-    m.singleton = true
-
-    result = @to.convert 'rdoc-ref:C1::<<'
-
-    assert_equal para("<a href=\"C1.html#method-c-3C-3C\"><code>C1::<<</code></a>"), result
-  end
-
-  def test_convert_RDOCLINK_rdoc_ref_method_percent_label
-    m = @c1.add_method RDoc::AnyMethod.new nil, '%'
-
-    result = @to.convert 'rdoc-ref:C1#%@f'
-
-    assert_equal para("<a href=\"C1.html#method-i-25-label-f\">f at <code>C1#%</code></a>"),
-                 result
-
-    m.singleton = true
-
-    result = @to.convert 'rdoc-ref:C1::%@f'
-
-    assert_equal para("<a href=\"C1.html#method-c-25-label-f\">f at <code>C1::%</code></a>"),
-                 result
-  end
-
-  def test_convert_RDOCLINK_rdoc_ref_label
-    result = @to.convert 'rdoc-ref:C1@foo'
-
-    assert_equal para("<a href=\"C1.html#class-C1-label-foo\">foo at <code>C1</code></a>"), result,
-                 'rdoc-ref:C1@foo'
-  end
-
-  def test_convert_RDOCLINK_rdoc_ref_label_in_current_file
-    result = @to.convert 'rdoc-ref:@foo'
-
-    assert_equal para("<a href=\"#label-foo\">foo</a>"), result,
-                 'rdoc-ref:@foo'
-
-    result = @to.convert '{Foo}[rdoc-ref:@foo]'
-
-    assert_equal para("<a href=\"#label-foo\">Foo</a>"), result,
-                 '{Foo}[rdoc-ref:@foo]'
-  end
-
-  def test_gen_url
-    assert_equal '<a href="C1.html">Some class</a>',
-                 @to.gen_url('rdoc-ref:C1', 'Some class')
-
-    assert_equal '<a href="http://example">HTTP example</a>',
-                 @to.gen_url('http://example', 'HTTP example')
-  end
-
-  def test_gen_url_rdoc_ref_not_found
-    stdout, _ = capture_output do
-      @to.gen_url 'rdoc-ref:FOO', 'FOO'
-    end
-
-    assert_include stdout, "index.html: `rdoc-ref:FOO` can't be resolved for `FOO`"
-  end
-
-  def test_handle_regexp_CROSSREF
-    assert_equal "<a href=\"C2/C3.html\"><code>C2::C3</code></a>", REGEXP_HANDLING('C2::C3')
-  end
-
-  def test_handle_regexp_CROSSREF_label
-    assert_equal "<a href=\"C1.html#method-i-m-label-foo\">foo at <code>C1#m</code></a>",
-                 REGEXP_HANDLING('C1#m@foo')
-  end
-
-  def test_handle_regexp_CROSSREF_show_hash_false
-    @to.show_hash = false
-
-    assert_equal "<a href=\"C1.html#method-i-m\"><code>m</code></a>",
-                 REGEXP_HANDLING('#m')
-  end
-
-  def test_handle_regexp_CROSSREF_with_arg_looks_like_TIDYLINK
-    result = @to.convert 'C1.m[:sym]'
-
-    assert_equal para("<a href=\"C1.html#method-c-m\"><code>C1.m[:sym]</code></a>"), result,
-                 'C1.m[:sym]'
-  end
-
-  def test_handle_regexp_HYPERLINK_rdoc
-    readme = @store.add_file 'README.txt'
-    readme.parser = RDoc::Parser::Simple
-
-    @to = RDoc::Markup::ToHtmlCrossref.new @options, 'C2.html', @c2
-
-    link = @to.handle_regexp_HYPERLINK hyper 'C2::C3'
-
-    assert_equal '<a href="C2/C3.html"><code>C2::C3</code></a>', link
-
-    link = @to.handle_regexp_HYPERLINK hyper 'C4'
-
-    assert_equal '<a href="C4.html"><code>C4</code></a>', link
-
-    link = @to.handle_regexp_HYPERLINK hyper 'README.txt'
-
-    assert_equal '<a href="README_txt.html">README.txt</a>', link
-  end
-
-  def test_handle_regexp_TIDYLINK_rdoc
-    readme = @store.add_file 'README.txt'
-    readme.parser = RDoc::Parser::Simple
-
-    @to = RDoc::Markup::ToHtmlCrossref.new @options, 'C2.html', @c2
-
-    link = @to.handle_regexp_TIDYLINK tidy 'C2::C3'
-
-    assert_equal '<a href="C2/C3.html">tidy</a>', link
-
-    link = @to.handle_regexp_TIDYLINK tidy 'C4'
-
-    assert_equal '<a href="C4.html">tidy</a>', link
-
-    link = @to.handle_regexp_TIDYLINK tidy 'C1#m'
-
-    assert_equal '<a href="C1.html#method-i-m">tidy</a>', link
-
-    link = @to.handle_regexp_TIDYLINK tidy 'README.txt'
-
-    assert_equal '<a href="README_txt.html">tidy</a>', link
-  end
-
-  def test_handle_regexp_TIDYLINK_label
-    link = @to.handle_regexp_TIDYLINK tidy 'C1#m@foo'
-
-    assert_equal "<a href=\"C1.html#method-i-m-label-foo\">tidy</a>",
-                 link, 'C1#m@foo'
-  end
-
-  def test_to_html_CROSSREF_email
-    @options.hyperlink_all = false
-
-    @to = RDoc::Markup::ToHtmlCrossref.new @options, 'index.html', @c1
-
-    result = @to.to_html 'first.last@example.com'
-
-    assert_equal 'first.last@example.com', result
-  end
-
-  def test_to_html_CROSSREF_email_hyperlink_all
-    result = @to.to_html 'first.last@example.com'
-
-    assert_equal 'first.last@example.com', result
-  end
-
-  def test_link
-    assert_equal 'n', @to.link('n', 'n')
-
-    assert_equal '<a href="C1.html#method-c-m"><code>m</code></a>', @to.link('m', 'm')
-  end
-
-  def test_link_for_method_traverse
-    @to = RDoc::Markup::ToHtmlCrossref.new @options, 'C2.html', @c9
-    assert_equal '<a href="C9/A.html#method-i-foo"><code>C9::B#foo</code></a>', @to.link('C9::B#foo', 'C9::B#foo')
-  end
-
-  def test_link_class_method_full
-    assert_equal '<a href="Parent.html#method-c-m"><code>Parent::m</code></a>',
-                 @to.link('Parent::m', 'Parent::m')
-  end
-
-  def para(text)
-    "\n<p>#{text}</p>\n"
-  end
-
-  def REGEXP_HANDLING(text)
-    @to.handle_regexp_CROSSREF regexp_handling text
-  end
-
-  def hyper(reference)
-    RDoc::Markup::RegexpHandling.new 0, "rdoc-ref:#{reference}"
-  end
-
-  def regexp_handling(text)
-    RDoc::Markup::RegexpHandling.new 0, text
-  end
-
-  def tidy(reference)
-    RDoc::Markup::RegexpHandling.new 0, "{tidy}[rdoc-ref:#{reference}]"
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc/rdoc_markup_to_html_snippet_test.rb b/test/mri/rdoc/rdoc/rdoc_markup_to_html_snippet_test.rb
deleted file mode 100644
index 4a338271afe..00000000000
--- a/test/mri/rdoc/rdoc/rdoc_markup_to_html_snippet_test.rb
+++ /dev/null
@@ -1,709 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocMarkupToHtmlSnippetTest < RDoc::Markup::FormatterTestCase
-
-  add_visitor_tests
-
-  def setup
-    super
-
-    @to = RDoc::Markup::ToHtmlSnippet.new @options, 100, 100
-    @ellipsis = @to.to_html '...'
-  end
-
-  def accept_blank_line
-    assert_empty @to.res.join
-  end
-
-  def accept_block_quote
-    assert_equal "\n<blockquote><p>quote\n</blockquote>\n", @to.res.join
-
-    assert_equal 5, @to.characters
-  end
-
-  def accept_document
-    assert_equal "<p>hello\n", @to.res.join
-    assert_equal 5, @to.characters
-  end
-
-  def accept_heading
-    assert_equal "<p>Hello\n", @to.res.join
-    assert_equal 5, @to.characters
-  end
-
-  def accept_heading_1
-    assert_equal "<p>Hello\n", @to.res.join
-    assert_equal 5, @to.characters
-  end
-
-  def accept_heading_2
-    assert_equal "<p>Hello\n", @to.res.join
-    assert_equal 5, @to.characters
-  end
-
-  def accept_heading_3
-    assert_equal "<p>Hello\n", @to.res.join
-    assert_equal 5, @to.characters
-  end
-
-  def accept_heading_4
-    assert_equal "<p>Hello\n", @to.res.join
-    assert_equal 5, @to.characters
-  end
-
-  def accept_heading_b
-    assert_equal "<p><strong>Hello</strong>\n",
-                 @to.res.join
-    assert_equal 5, @to.characters
-  end
-
-  def accept_heading_suppressed_crossref
-    assert_equal "<p>Hello\n", @to.res.join
-    assert_equal 5, @to.characters
-  end
-
-  def accept_list_end_bullet
-    assert_equal [], @to.list
-    assert_equal [], @to.in_list_entry
-
-    assert_equal "\n", @to.res.join
-    assert_equal 0, @to.characters
-  end
-
-  def accept_list_end_label
-    assert_equal [], @to.list
-    assert_equal [], @to.in_list_entry
-
-    assert_equal "\n", @to.res.join
-    assert_equal 0, @to.characters
-  end
-
-  def accept_list_end_lalpha
-    assert_equal [], @to.list
-    assert_equal [], @to.in_list_entry
-
-    assert_equal "\n", @to.res.join
-    assert_equal 0, @to.characters
-  end
-
-  def accept_list_end_number
-    assert_equal [], @to.list
-    assert_equal [], @to.in_list_entry
-
-    assert_equal "\n", @to.res.join
-    assert_equal 0, @to.characters
-  end
-
-  def accept_list_end_note
-    assert_equal [], @to.list
-    assert_equal [], @to.in_list_entry
-
-    assert_equal "\n", @to.res.join
-    assert_equal 0, @to.characters
-  end
-
-  def accept_list_end_ualpha
-    assert_equal [], @to.list
-    assert_equal [], @to.in_list_entry
-
-    assert_equal "\n", @to.res.join
-    assert_equal 0, @to.characters
-  end
-
-  def accept_list_item_end_bullet
-    assert_equal [''], @to.in_list_entry
-    assert_equal 0, @to.characters
-  end
-
-  def accept_list_item_end_label
-    assert_equal [''], @to.in_list_entry
-    assert_equal 4, @to.characters
-  end
-
-  def accept_list_item_end_lalpha
-    assert_equal [''], @to.in_list_entry
-    assert_equal 0, @to.characters
-  end
-
-  def accept_list_item_end_note
-    assert_equal [''], @to.in_list_entry
-    assert_equal 4, @to.characters
-  end
-
-  def accept_list_item_end_number
-    assert_equal [''], @to.in_list_entry
-    assert_equal 0, @to.characters
-  end
-
-  def accept_list_item_end_ualpha
-    assert_equal [''], @to.in_list_entry
-    assert_equal 0, @to.characters
-  end
-
-  def accept_list_item_start_bullet
-    assert_equal "<p>", @to.res.join
-    assert_equal 0, @to.characters
-  end
-
-  def accept_list_item_start_label
-    assert_equal "<p>cat — ", @to.res.join
-    assert_equal 4, @to.characters
-  end
-
-  def accept_list_item_start_lalpha
-    assert_equal "<p>", @to.res.join
-    assert_equal 0, @to.characters
-  end
-
-  def accept_list_item_start_note
-    assert_equal "<p>cat — ",
-                 @to.res.join
-    assert_equal 4, @to.characters
-  end
-
-  def accept_list_item_start_note_2
-    expected = <<-EXPECTED
-<p><code>teletype</code> — teletype description
-
-    EXPECTED
-
-    assert_equal expected, @to.res.join
-    assert_equal 29, @to.characters
-  end
-
-  def accept_list_item_start_note_multi_description
-    expected = <<-EXPECTED
-<p>label — description one
-<p>description two
-
-    EXPECTED
-
-    assert_equal expected, @to.res.join
-    assert_equal 37, @to.characters
-  end
-
-  def accept_list_item_start_note_multi_label
-    expected = <<-EXPECTED
-<p>one, two — two headers
-
-    EXPECTED
-
-    assert_equal expected, @to.res.join
-    assert_equal 18, @to.characters
-  end
-
-  def accept_list_item_start_number
-    assert_equal "<p>", @to.res.join
-    assert_equal 0, @to.characters
-  end
-
-  def accept_list_item_start_ualpha
-    assert_equal "<p>", @to.res.join
-    assert_equal 0, @to.characters
-  end
-
-  def accept_list_start_bullet
-    assert_equal [:BULLET], @to.list
-    assert_equal [''], @to.in_list_entry
-
-    assert_equal '', @to.res.join
-    assert_equal 0, @to.characters
-  end
-
-  def accept_list_start_label
-    assert_equal [:LABEL], @to.list
-    assert_equal [''], @to.in_list_entry
-
-    assert_equal '', @to.res.join
-    assert_equal 0, @to.characters
-  end
-
-  def accept_list_start_lalpha
-    assert_equal [:LALPHA], @to.list
-    assert_equal [''], @to.in_list_entry
-
-    assert_equal '', @to.res.join
-    assert_equal 0, @to.characters
-  end
-
-  def accept_list_start_note
-    assert_equal [:NOTE], @to.list
-    assert_equal [''], @to.in_list_entry
-
-    assert_equal '', @to.res.join
-    assert_equal 0, @to.characters
-  end
-
-  def accept_list_start_number
-    assert_equal [:NUMBER], @to.list
-    assert_equal [''], @to.in_list_entry
-
-    assert_equal '', @to.res.join
-    assert_equal 0, @to.characters
-  end
-
-  def accept_list_start_ualpha
-    assert_equal [:UALPHA], @to.list
-    assert_equal [''], @to.in_list_entry
-
-    assert_equal '', @to.res.join
-    assert_equal 0, @to.characters
-  end
-
-  def accept_paragraph
-    assert_equal "<p>hi\n", @to.res.join
-
-    assert_equal 2, @to.characters
-  end
-
-  def accept_paragraph_b
-    assert_equal "<p>reg <strong>bold words</strong> reg\n", @to.res.join
-
-    assert_equal 18, @to.characters
-  end
-
-  def accept_paragraph_br
-    assert_equal "<p>one<br>two\n", @to.res.join
-
-    assert_equal 6, @to.characters
-  end
-
-  def accept_paragraph_break
-    assert_equal "<p>hello<br>\nworld\n", @to.res.join
-
-    assert_equal 11, @to.characters
-  end
-
-  def accept_paragraph_i
-    assert_equal "<p>reg <em>italic words</em> reg\n", @to.res.join
-
-    assert_equal 20, @to.characters
-  end
-
-  def accept_paragraph_plus
-    assert_equal "<p>reg <code>teletype</code> reg\n", @to.res.join
-
-    assert_equal 16, @to.characters
-  end
-
-  def accept_paragraph_star
-    assert_equal "<p>reg <strong>bold</strong> reg\n", @to.res.join
-
-    assert_equal 12, @to.characters
-  end
-
-  def accept_paragraph_underscore
-    assert_equal "<p>reg <em>italic</em> reg\n", @to.res.join
-
-    assert_equal 14, @to.characters
-  end
-
-  def accept_raw
-    assert_equal '', @to.res.join
-    assert_equal 0, @to.characters
-  end
-
-  def accept_rule
-    assert_empty @to.res
-    assert_equal 0, @to.characters
-  end
-
-  def accept_verbatim
-    assert_equal "\n<pre class=\"ruby\"><span class=\"ruby-identifier\">hi</span>\n  <span class=\"ruby-identifier\">world</span>\n</pre>\n", @to.res.join
-    assert_equal 10, @to.characters
-  end
-
-  def end_accepting
-    assert_equal 'hi', @to.res.join
-  end
-
-  def start_accepting
-    assert_equal [], @to.res
-    assert_equal [], @to.in_list_entry
-    assert_equal [], @to.list
-    assert_equal 0,  @to.characters
-  end
-
-  def list_nested
-    expected = <<-EXPECTED
-<p>l1
-<p>l1.1
-
-<p>l2
-
-    EXPECTED
-
-    assert_equal expected, @to.res.join
-    assert_equal 8, @to.characters
-  end
-
-  def list_verbatim
-    expected = <<-EXPECTED
-<p>list stuff
-
-<pre>* list
-  with
-
-  second
-
-  1. indented
-  2. numbered
-
-  third
-
-* second</pre>
-
-    EXPECTED
-
-    assert_equal expected, @to.end_accepting
-    assert_equal 81, @to.characters
-  end
-
-  def test_accept_heading_7
-    @to.start_accepting
-
-    @to.accept_heading @RM::Heading.new(7, 'Hello')
-
-    assert_equal "<p>Hello\n", @to.res.join
-    assert_equal 5, @to.characters
-  end
-
-  def test_accept_heading_aref_class
-    @to.code_object = RDoc::NormalClass.new 'Foo'
-    @to.start_accepting
-
-    @to.accept_heading @RM::Heading.new(1, 'Hello')
-
-    assert_equal "<p>Hello\n",
-                 @to.res.join
-    assert_equal 5, @to.characters
-  end
-
-  def test_accept_heading_aref_method
-    @to.code_object = RDoc::AnyMethod.new nil, 'foo'
-    @to.start_accepting
-
-    @to.accept_heading @RM::Heading.new(1, 'Hello')
-
-    assert_equal "<p>Hello\n",
-                 @to.res.join
-    assert_equal 5, @to.characters
-  end
-
-  def test_accept_verbatim_ruby
-    options = RDoc::Options.new
-    rdoc = RDoc::RDoc.new
-    rdoc.options = options
-    RDoc::RDoc.current = rdoc
-
-    verb = @RM::Verbatim.new("class C\n", "end\n")
-
-    @to.start_accepting
-    @to.accept_verbatim verb
-
-    expected = <<-EXPECTED
-
-<pre class="ruby"><span class="ruby-keyword">class</span> <span class="ruby-constant">C</span>
-<span class="ruby-keyword">end</span>
-</pre>
-    EXPECTED
-
-    assert_equal expected, @to.res.join
-    assert_equal 11, @to.characters
-  end
-
-  def test_accept_verbatim_ruby_error
-    options = RDoc::Options.new
-    rdoc = RDoc::RDoc.new
-    rdoc.options = options
-    RDoc::RDoc.current = rdoc
-
-    verb = @RM::Verbatim.new("a % 09 # => blah\n")
-
-    @to.start_accepting
-    @to.accept_verbatim verb
-
-    inner = CGI.escapeHTML "a % 09 # => blah"
-
-    expected = <<-EXPECTED
-
-<pre>#{inner}</pre>
-    EXPECTED
-
-    assert_equal expected, @to.res.join
-    assert_equal 16, @to.characters
-  end
-
-  def test_add_paragraph
-    @to = RDoc::Markup::ToHtmlSnippet.new @options, 0, 3
-    assert_throws :done do
-      @to.add_paragraph
-      @to.add_paragraph
-      @to.add_paragraph
-    end
-
-    assert_equal 3, @to.paragraphs
-  end
-
-  def test_convert_limit
-    rdoc = <<-RDOC
-= Hello
-
-This is some text, it *will* be cut off after 100 characters and an ellipsis
-must follow
-
-So there you have it
-    RDOC
-
-    expected = <<-EXPECTED
-<p>Hello
-<p>This is some text, it <strong>will</strong> be cut off after 100 characters and an ellipsis must follow
-<p>So there you #{@ellipsis}
-    EXPECTED
-
-    actual = @to.convert rdoc
-
-    assert_equal expected, actual
-    assert_equal 111, @to.characters, 'snippet character length'
-  end
-
-  def test_convert_limit_2
-    rdoc = <<-RDOC
-Outputs formatted RI data for the class or method +name+.
-
-Returns true if +name+ was found, false if it was not an alternative could
-be guessed, raises an error if +name+ couldn't be guessed.
-    RDOC
-
-    expected = <<-EXPECTED
-<p>Outputs formatted RI data for the class or method <code>name</code>.
-<p>Returns true if <code>name</code> was found, false if it was #{@ellipsis}
-    EXPECTED
-
-    actual = @to.convert rdoc
-
-    assert_equal expected, actual
-    assert_equal 159, @to.characters, 'snippet character length'
-  end
-
-  def test_convert_limit_paragraphs
-    @to = RDoc::Markup::ToHtmlSnippet.new @options, 100, 3
-
-    rdoc = <<-RDOC
-= \RDoc - Ruby Documentation System
-
-* {RDoc Project Page}[https://github.com/ruby/rdoc]
-* {RDoc Documentation}[https://ruby.github.io/rdoc]
-* {RDoc Bug Tracker}[https://github.com/ruby/rdoc/issues]
-
-== DESCRIPTION:
-
-RDoc produces HTML and command-line documentation for Ruby projects.  RDoc
-includes the +rdoc+ and +ri+ tools for generating and displaying online
-documentation.
-
-See RDoc for a description of RDoc's markup and basic use.
-    RDOC
-
-    expected = <<-EXPECTED
-<p>RDoc - Ruby Documentation System
-<p>RDoc Project Page
-<p>RDoc Documentation
-    EXPECTED
-
-    actual = @to.convert rdoc
-
-    assert_equal expected, actual
-    assert_equal 67, @to.characters
-  end
-
-  def test_convert_limit_in_tag
-    @to = RDoc::Markup::ToHtmlSnippet.new @options, 4
-    rdoc = "* ab *c* d\n"
-
-    expected = "<p>ab <strong>c</strong> #{@ellipsis}\n\n"
-
-    actual = @to.convert rdoc
-
-    assert_equal 4, @to.characters
-    assert_equal expected, actual
-  end
-
-  def test_convert_limit_verbatim
-    rdoc = <<-RDOC
-= Hello There
-
-This is some text, it *will* be cut off after 100 characters
-
-  This one is cut off in this verbatim section
-    RDOC
-
-    expected = <<-EXPECTED
-<p>Hello There
-<p>This is some text, it <strong>will</strong> be cut off after 100 characters
-
-<pre>This one is cut off in this verbatim ...</pre>
-    EXPECTED
-
-    actual = @to.convert rdoc
-
-    assert_equal expected, actual
-    assert_equal 113, @to.characters
-  end
-
-  def test_convert_limit_verbatim_2
-    rdoc = <<-RDOC
-Extracts the class, selector and method name parts from +name+ like
-Foo::Bar#baz.
-
-NOTE: Given Foo::Bar, Bar is considered a class even though it may be a
-      method
-    RDOC
-
-    expected = <<-EXPECTED
-<p>Extracts the class, selector and method name parts from <code>name</code> like Foo::Bar#baz.
-<p>NOTE: Given Foo::Bar, #{@ellipsis}
-    EXPECTED
-
-    actual = @to.convert rdoc
-
-    assert_equal expected, actual
-    assert_equal 101, @to.characters
-  end
-
-  def test_convert_limit_verbatim_multiline
-    rdoc = <<-RDOC
-Look for directives in a normal comment block:
-
-  # :stopdoc:
-  # Don't display comment from this point forward
-
-This routine modifies its +comment+ parameter.
-    RDOC
-
-    inner = CGI.escapeHTML "# Don't display comment from this point forward"
-    expected = <<-EXPECTED
-<p>Look for directives in a normal comment block:
-
-<pre class=\"ruby\"><span class=\"ruby-comment\"># :stopdoc:</span>
-<span class=\"ruby-comment\">#{inner}</span>
-</pre>
-    EXPECTED
-
-    actual = @to.convert rdoc
-
-    assert_equal expected, actual
-    assert_equal 105, @to.characters
-  end
-
-  def test_convert_limit_over
-    @to = RDoc::Markup::ToHtmlSnippet.new @options, 4
-    rdoc = "* text\n" * 2
-
-    expected = "<p>text\n"
-    expected = expected.chomp
-    expected << " #{@ellipsis}\n"
-
-    actual = @to.convert rdoc
-
-    assert_equal 4, @to.characters
-    assert_equal expected, actual
-  end
-
-  def test_convert_string
-    assert_equal '<>', @to.convert_string('<>')
-  end
-
-  def test_convert_RDOCLINK_label_label
-    result = @to.convert 'rdoc-label:label-One'
-
-    assert_equal "<p>One\n", result
-    assert_equal 3, @to.characters
-  end
-
-  def test_convert_RDOCLINK_label_foottext
-    result = @to.convert 'rdoc-label:foottext-1'
-
-    assert_equal "<p>1\n", result
-    assert_equal 1, @to.characters
-  end
-
-  def test_convert_RDOCLINK_label_footmark
-    result = @to.convert 'rdoc-label:footmark-1'
-
-    assert_equal "<p>1\n", result
-    assert_equal 1, @to.characters
-  end
-
-  def test_convert_RDOCLINK_ref
-    result = @to.convert 'rdoc-ref:C'
-
-    assert_equal "<p>C\n", result
-    assert_equal 1, @to.characters
-  end
-
-  def test_convert_TIDYLINK_rdoc_label
-    result = @to.convert '{foo}[rdoc-label:foottext-1]'
-
-    assert_equal "<p>foo\n", result
-    assert_equal 3, @to.characters
-  end
-
-  def test_handle_regexp_HYPERLINK_link
-    target = RDoc::Markup::RegexpHandling.new 0, 'link:README.txt'
-
-    link = @to.handle_regexp_HYPERLINK target
-
-    assert_equal 'README.txt', link
-  end
-
-  def test_list_verbatim_2
-    str = "* one\n    verb1\n    verb2\n* two\n"
-
-    expected = <<-EXPECTED
-<p>one
-
-<pre class=\"ruby\"><span class=\"ruby-identifier\">verb1</span>
-<span class=\"ruby-identifier\">verb2</span>
-</pre>
-<p>two
-
-    EXPECTED
-
-    assert_equal expected, @m.convert(str, @to)
-    assert_equal 17, @to.characters
-  end
-
-  def test_on_tags
-    on = RDoc::Markup::AttrChanger.new 2, 0
-
-    @to.on_tags [], on
-
-    assert_equal 2, @to.mask
-  end
-
-  def test_off_tags
-    on  = RDoc::Markup::AttrChanger.new 2, 0
-    off = RDoc::Markup::AttrChanger.new 0, 2
-
-    @to.on_tags  [], on
-    @to.off_tags [], off
-
-    assert_equal 0, @to.mask
-  end
-
-  def test_to_html
-    assert_equal "<p><code>--</code>\n", util_format("<tt>--</tt>")
-    assert_equal 2, @to.characters
-  end
-
-  def util_format(text)
-    paragraph = RDoc::Markup::Paragraph.new text
-
-    @to.start_accepting
-    @to.accept_paragraph paragraph
-    @to.end_accepting
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc/rdoc_markup_to_html_test.rb b/test/mri/rdoc/rdoc/rdoc_markup_to_html_test.rb
deleted file mode 100644
index e586e03cb9a..00000000000
--- a/test/mri/rdoc/rdoc/rdoc_markup_to_html_test.rb
+++ /dev/null
@@ -1,1024 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocMarkupToHtmlTest < RDoc::Markup::FormatterTestCase
-
-  add_visitor_tests
-
-  def setup
-    super
-
-    @to = RDoc::Markup::ToHtml.new @options
-  end
-
-  def accept_blank_line
-    assert_empty @to.res.join
-  end
-
-  def accept_block_quote
-    assert_equal "\n<blockquote>\n<p>quote</p>\n</blockquote>\n", @to.res.join
-  end
-
-  def accept_document
-    assert_equal "\n<p>hello</p>\n", @to.res.join
-  end
-
-  def accept_heading
-    links = '<span><a href="#label-Hello">¶</a> ' +
-            '<a href="#top">↑</a></span>'
-    expected = "\n<h5 id=\"label-Hello\">Hello#{links}</h5>\n"
-
-    assert_equal expected, @to.res.join
-  end
-
-  def accept_heading_1
-    links = '<span><a href="#label-Hello">¶</a> ' +
-            '<a href="#top">↑</a></span>'
-
-    assert_equal "\n<h1 id=\"label-Hello\">Hello#{links}</h1>\n", @to.res.join
-  end
-
-  def accept_heading_2
-    links = '<span><a href="#label-Hello">¶</a> ' +
-            '<a href="#top">↑</a></span>'
-
-    assert_equal "\n<h2 id=\"label-Hello\">Hello#{links}</h2>\n", @to.res.join
-  end
-
-  def accept_heading_3
-    links = '<span><a href="#label-Hello">¶</a> ' +
-            '<a href="#top">↑</a></span>'
-
-    assert_equal "\n<h3 id=\"label-Hello\">Hello#{links}</h3>\n", @to.res.join
-  end
-
-  def accept_heading_4
-    links = '<span><a href="#label-Hello">¶</a> ' +
-            '<a href="#top">↑</a></span>'
-
-    assert_equal "\n<h4 id=\"label-Hello\">Hello#{links}</h4>\n", @to.res.join
-  end
-
-  def accept_heading_b
-    links = '<span><a href="#label-Hello">¶</a> ' +
-            '<a href="#top">↑</a></span>'
-    inner = "<strong>Hello</strong>"
-
-    assert_equal "\n<h1 id=\"label-Hello\">#{inner}#{links}</h1>\n",
-                 @to.res.join
-  end
-
-  def accept_heading_suppressed_crossref
-    links = '<span><a href="#label-Hello">¶</a> ' +
-            '<a href="#top">↑</a></span>'
-
-    assert_equal "\n<h1 id=\"label-Hello\">Hello#{links}</h1>\n", @to.res.join
-  end
-
-  def accept_list_end_bullet
-    assert_equal [], @to.list
-    assert_equal [], @to.in_list_entry
-
-    assert_equal "<ul></ul>\n", @to.res.join
-  end
-
-  def accept_list_end_label
-    assert_equal [], @to.list
-    assert_equal [], @to.in_list_entry
-
-    assert_equal "<dl class=\"rdoc-list label-list\"></dl>\n", @to.res.join
-  end
-
-  def accept_list_end_lalpha
-    assert_equal [], @to.list
-    assert_equal [], @to.in_list_entry
-
-    assert_equal "<ol style=\"list-style-type: lower-alpha\"></ol>\n", @to.res.join
-  end
-
-  def accept_list_end_number
-    assert_equal [], @to.list
-    assert_equal [], @to.in_list_entry
-
-    assert_equal "<ol></ol>\n", @to.res.join
-  end
-
-  def accept_list_end_note
-    assert_equal [], @to.list
-    assert_equal [], @to.in_list_entry
-
-    assert_equal "<dl class=\"rdoc-list note-list\"></dl>\n", @to.res.join
-  end
-
-  def accept_list_end_ualpha
-    assert_equal [], @to.list
-    assert_equal [], @to.in_list_entry
-
-    assert_equal "<ol style=\"list-style-type: upper-alpha\"></ol>\n", @to.res.join
-  end
-
-  def accept_list_item_end_bullet
-    assert_equal %w[</li>], @to.in_list_entry
-  end
-
-  def accept_list_item_end_label
-    assert_equal %w[</dd>], @to.in_list_entry
-  end
-
-  def accept_list_item_end_lalpha
-    assert_equal %w[</li>], @to.in_list_entry
-  end
-
-  def accept_list_item_end_note
-    assert_equal %w[</dd>], @to.in_list_entry
-  end
-
-  def accept_list_item_end_number
-    assert_equal %w[</li>], @to.in_list_entry
-  end
-
-  def accept_list_item_end_ualpha
-    assert_equal %w[</li>], @to.in_list_entry
-  end
-
-  def accept_list_item_start_bullet
-    assert_equal "<ul><li>", @to.res.join
-  end
-
-  def accept_list_item_start_label
-    assert_equal "<dl class=\"rdoc-list label-list\"><dt>cat</dt>\n<dd>", @to.res.join
-  end
-
-  def accept_list_item_start_lalpha
-    assert_equal "<ol style=\"list-style-type: lower-alpha\"><li>", @to.res.join
-  end
-
-  def accept_list_item_start_note
-    assert_equal "<dl class=\"rdoc-list note-list\"><dt>cat</dt>\n<dd>",
-                 @to.res.join
-  end
-
-  def accept_list_item_start_note_2
-    expected = <<-EXPECTED
-<dl class="rdoc-list note-list"><dt><code>teletype</code></dt>
-<dd>
-<p>teletype description</p>
-</dd></dl>
-    EXPECTED
-
-    assert_equal expected, @to.res.join
-  end
-
-  def accept_list_item_start_note_multi_description
-    expected = <<-EXPECTED
-<dl class="rdoc-list note-list"><dt>label</dt>
-<dd>
-<p>description one</p>
-</dd><dd>
-<p>description two</p>
-</dd></dl>
-    EXPECTED
-
-    assert_equal expected, @to.res.join
-  end
-
-  def accept_list_item_start_note_multi_label
-    expected = <<-EXPECTED
-<dl class="rdoc-list note-list"><dt>one</dt>
-<dt>two</dt>
-<dd>
-<p>two headers</p>
-</dd></dl>
-    EXPECTED
-
-    assert_equal expected, @to.res.join
-  end
-
-  def accept_list_item_start_number
-    assert_equal "<ol><li>", @to.res.join
-  end
-
-  def accept_list_item_start_ualpha
-    assert_equal "<ol style=\"list-style-type: upper-alpha\"><li>", @to.res.join
-  end
-
-  def accept_list_start_bullet
-    assert_equal [:BULLET], @to.list
-    assert_equal [false], @to.in_list_entry
-
-    assert_equal "<ul>", @to.res.join
-  end
-
-  def accept_list_start_label
-    assert_equal [:LABEL], @to.list
-    assert_equal [false], @to.in_list_entry
-
-    assert_equal '<dl class="rdoc-list label-list">', @to.res.join
-  end
-
-  def accept_list_start_lalpha
-    assert_equal [:LALPHA], @to.list
-    assert_equal [false], @to.in_list_entry
-
-    assert_equal "<ol style=\"list-style-type: lower-alpha\">", @to.res.join
-  end
-
-  def accept_list_start_note
-    assert_equal [:NOTE], @to.list
-    assert_equal [false], @to.in_list_entry
-
-    assert_equal "<dl class=\"rdoc-list note-list\">", @to.res.join
-  end
-
-  def accept_list_start_number
-    assert_equal [:NUMBER], @to.list
-    assert_equal [false], @to.in_list_entry
-
-    assert_equal "<ol>", @to.res.join
-  end
-
-  def accept_list_start_ualpha
-    assert_equal [:UALPHA], @to.list
-    assert_equal [false], @to.in_list_entry
-
-    assert_equal "<ol style=\"list-style-type: upper-alpha\">", @to.res.join
-  end
-
-  def accept_paragraph
-    assert_equal "\n<p>hi</p>\n", @to.res.join
-  end
-
-  def accept_paragraph_b
-    assert_equal "\n<p>reg <strong>bold words</strong> reg</p>\n", @to.res.join
-  end
-
-  def accept_paragraph_br
-    assert_equal "\n<p>one<br>two</p>\n", @to.res.join
-  end
-
-  def accept_paragraph_break
-    assert_equal "\n<p>hello<br> world</p>\n", @to.res.join
-  end
-
-  def accept_paragraph_i
-    assert_equal "\n<p>reg <em>italic words</em> reg</p>\n", @to.res.join
-  end
-
-  def accept_paragraph_plus
-    assert_equal "\n<p>reg <code>teletype</code> reg</p>\n", @to.res.join
-  end
-
-  def accept_paragraph_star
-    assert_equal "\n<p>reg <strong>bold</strong> reg</p>\n", @to.res.join
-  end
-
-  def accept_paragraph_underscore
-    assert_equal "\n<p>reg <em>italic</em> reg</p>\n", @to.res.join
-  end
-
-  def accept_raw
-    raw = <<-RAW.rstrip
-<table>
-<tr><th>Name<th>Count
-<tr><td>a<td>1
-<tr><td>b<td>2
-</table>
-    RAW
-
-    assert_equal raw, @to.res.join
-  end
-
-  def accept_rule
-    assert_equal "<hr>\n", @to.res.join
-  end
-
-  def accept_verbatim
-    assert_equal "\n<pre class=\"ruby\"><span class=\"ruby-identifier\">hi</span>\n  <span class=\"ruby-identifier\">world</span>\n</pre>\n", @to.res.join
-  end
-
-  def end_accepting
-    assert_equal 'hi', @to.end_accepting
-  end
-
-  def start_accepting
-    assert_equal [], @to.res
-    assert_equal [], @to.in_list_entry
-    assert_equal [], @to.list
-  end
-
-  def list_nested
-    expected = <<-EXPECTED
-<ul><li>
-<p>l1</p>
-<ul><li>
-<p>l1.1</p>
-</li></ul>
-</li><li>
-<p>l2</p>
-</li></ul>
-    EXPECTED
-
-    assert_equal expected, @to.res.join
-  end
-
-  def list_verbatim
-    expected = <<-EXPECTED
-<ul><li>
-<p>list stuff</p>
-
-<pre>* list
-  with
-
-  second
-
-  1. indented
-  2. numbered
-
-  third
-
-* second</pre>
-</li></ul>
-    EXPECTED
-
-    assert_equal expected, @to.end_accepting
-  end
-
-  def test_accept_heading_7
-    @to.start_accepting
-
-    @to.accept_heading @RM::Heading.new(7, 'Hello')
-
-    links = '<span><a href="#label-Hello">¶</a> ' +
-            '<a href="#top">↑</a></span>'
-
-    assert_equal "\n<h6 id=\"label-Hello\">Hello#{links}</h6>\n", @to.res.join
-  end
-
-  def test_accept_heading_aref_class
-    @to.code_object = RDoc::NormalClass.new 'Foo'
-    @to.start_accepting
-
-    @to.accept_heading head(1, 'Hello')
-
-    links = '<span><a href="#class-Foo-label-Hello">¶</a> ' +
-            '<a href="#top">↑</a></span>'
-
-    assert_equal "\n<h1 id=\"class-Foo-label-Hello\">Hello#{links}</h1>\n",
-                 @to.res.join
-  end
-
-  def test_accept_heading_aref_method
-    @to.code_object = RDoc::AnyMethod.new nil, 'foo'
-    @to.start_accepting
-
-    @to.accept_heading @RM::Heading.new(1, 'Hello')
-
-    links = '<span><a href="#method-i-foo-label-Hello">¶</a> ' +
-            '<a href="#top">↑</a></span>'
-
-    assert_equal "\n<h1 id=\"method-i-foo-label-Hello\">Hello#{links}</h1>\n",
-                 @to.res.join
-  end
-
-  def test_accept_heading_pipe
-    @options.pipe = true
-
-    @to.start_accepting
-
-    @to.accept_heading @RM::Heading.new(1, 'Hello')
-
-    assert_equal "\n<h1 id=\"label-Hello\">Hello</h1>\n", @to.res.join
-  end
-
-  def test_accept_paragraph_newline
-    hellos = ["hello", "\u{393 3b5 3b9 3ac} \u{3c3 3bf 3c5}"]
-    worlds = ["world", "\u{3ba 3cc 3c3 3bc 3bf 3c2}"]
-    ohayo, sekai = %W"\u{304a 306f 3088 3046} \u{4e16 754c}"
-
-    hellos.product(worlds) do |hello, world|
-      @to.start_accepting
-      @to.accept_paragraph para("#{hello}\n", "#{world}\n")
-      assert_equal "\n<p>#{hello} #{world}</p>\n", @to.res.join
-    end
-
-    hellos.each do |hello|
-      @to.start_accepting
-      @to.accept_paragraph para("#{hello}\n", "#{sekai}\n")
-      assert_equal "\n<p>#{hello}#{sekai}</p>\n", @to.res.join
-    end
-
-    worlds.each do |world|
-      @to.start_accepting
-      @to.accept_paragraph para("#{ohayo}\n", "#{world}\n")
-      assert_equal "\n<p>#{ohayo}#{world}</p>\n", @to.res.join
-    end
-
-    @to.start_accepting
-    @to.accept_paragraph para("#{ohayo}\n", "#{sekai}\n")
-    assert_equal "\n<p>#{ohayo}#{sekai}</p>\n", @to.res.join
-
-    @to.start_accepting
-    @to.accept_paragraph para("+hello+\n", "world\n")
-    assert_equal "\n<p><code>hello</code> world</p>\n", @to.res.join
-
-    @to.start_accepting
-    @to.accept_paragraph para("hello\n", "+world+\n")
-    assert_equal "\n<p>hello <code>world</code></p>\n", @to.res.join
-
-    @to.start_accepting
-    @to.accept_paragraph para("+hello+\n", "+world+\n")
-    assert_equal "\n<p><code>hello</code> <code>world</code></p>\n", @to.res.join
-  end
-
-  def test_accept_heading_output_decoration
-    @options.output_decoration = false
-
-    @to.start_accepting
-
-    @to.accept_heading @RM::Heading.new(1, 'Hello')
-
-    assert_equal "\n<h1>Hello<span><a href=\"#label-Hello\">¶</a> <a href=\"#top\">↑</a></span></h1>\n", @to.res.join
-  end
-
-  def test_accept_heading_output_decoration_with_pipe
-    @options.pipe = true
-    @options.output_decoration = false
-
-    @to.start_accepting
-
-    @to.accept_heading @RM::Heading.new(1, 'Hello')
-
-    assert_equal "\n<h1>Hello</h1>\n", @to.res.join
-  end
-
-  def test_accept_verbatim_parseable
-    verb = @RM::Verbatim.new("class C\n", "end\n")
-
-    @to.start_accepting
-    @to.accept_verbatim verb
-
-    expected = <<-EXPECTED
-
-<pre class="ruby"><span class="ruby-keyword">class</span> <span class="ruby-constant">C</span>
-<span class="ruby-keyword">end</span>
-</pre>
-    EXPECTED
-
-    assert_equal expected, @to.res.join
-  end
-
-  def test_accept_verbatim_parseable_error
-    verb = @RM::Verbatim.new("a % 09 # => blah\n")
-
-    @to.start_accepting
-    @to.accept_verbatim verb
-
-    inner = CGI.escapeHTML "a % 09 # => blah"
-
-    expected = <<-EXPECTED
-
-<pre>#{inner}</pre>
-    EXPECTED
-
-    assert_equal expected, @to.res.join
-  end
-
-  def test_accept_verbatim_nl_after_backslash
-    verb = @RM::Verbatim.new("a = 1 if first_flag_var and \\\n", "  this_is_flag_var\n")
-
-    @to.start_accepting
-    @to.accept_verbatim verb
-
-    expected = <<-EXPECTED
-
-<pre class="ruby"><span class="ruby-identifier">a</span> = <span class="ruby-value">1</span> <span class="ruby-keyword">if</span> <span class="ruby-identifier">first_flag_var</span> <span class="ruby-keyword">and</span> \\
-  <span class="ruby-identifier">this_is_flag_var</span>
-</pre>
-    EXPECTED
-
-    assert_equal expected, @to.res.join
-  end
-
-  def test_accept_verbatim_pipe
-    @options.pipe = true
-
-    verb = @RM::Verbatim.new("1 + 1\n")
-    verb.format = :ruby
-
-    @to.start_accepting
-    @to.accept_verbatim verb
-
-    expected = <<-EXPECTED
-
-<pre><code>1 + 1
-</code></pre>
-    EXPECTED
-
-    assert_equal expected, @to.res.join
-  end
-
-  def test_accept_verbatim_escape_in_string
-    code = <<-'RUBY'
-def foo
-  [
-    '\\',
-    '\'',
-    "'",
-    "\'\"\`",
-    "\#",
-    "\#{}",
-    "#",
-    "#{}",
-    /'"/,
-    /\'\"/,
-    /\//,
-    /\\/,
-    /\#/,
-    /\#{}/,
-    /#/,
-    /#{}/
-  ]
-end
-def bar
-end
-    RUBY
-    verb = @RM::Verbatim.new(*code.split(/(?<=\n)/))
-
-    @to.start_accepting
-    @to.accept_verbatim verb
-
-    expected = <<-'EXPECTED'
-
-<pre class="ruby"><span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">foo</span>
-  [
-    <span class="ruby-string">'\\'</span>,
-    <span class="ruby-string">'\''</span>,
-    <span class="ruby-string">"'"</span>,
-    <span class="ruby-string">"\'\"\`"</span>,
-    <span class="ruby-string">"\#"</span>,
-    <span class="ruby-string">"\#{}"</span>,
-    <span class="ruby-string">"#"</span>,
-    <span class="ruby-node">"#{}"</span>,
-    <span class="ruby-regexp">/'"/</span>,
-    <span class="ruby-regexp">/\'\"/</span>,
-    <span class="ruby-regexp">/\//</span>,
-    <span class="ruby-regexp">/\\/</span>,
-    <span class="ruby-regexp">/\#/</span>,
-    <span class="ruby-regexp">/\#{}/</span>,
-    <span class="ruby-regexp">/#/</span>,
-    <span class="ruby-regexp">/#{}/</span>
-  ]
-<span class="ruby-keyword">end</span>
-<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">bar</span>
-<span class="ruby-keyword">end</span>
-</pre>
-    EXPECTED
-
-    assert_equal expected, @to.res.join
-  end
-
-  def test_accept_verbatim_escape_in_backtick
-    code = <<-'RUBY'
-def foo
-  [
-    `\\`,
-    `\'\"\``,
-    `\#`,
-    `\#{}`,
-    `#`,
-    `#{}`
-  ]
-end
-def bar
-end
-    RUBY
-    verb = @RM::Verbatim.new(*code.split(/(?<=\n)/))
-
-    @to.start_accepting
-    @to.accept_verbatim verb
-
-    expected = <<-'EXPECTED'
-
-<pre class="ruby"><span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">foo</span>
-  [
-    <span class="ruby-string">`\\`</span>,
-    <span class="ruby-string">`\'\"\``</span>,
-    <span class="ruby-string">`\#`</span>,
-    <span class="ruby-string">`\#{}`</span>,
-    <span class="ruby-string">`#`</span>,
-    <span class="ruby-node">`#{}`</span>
-  ]
-<span class="ruby-keyword">end</span>
-<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">bar</span>
-<span class="ruby-keyword">end</span>
-</pre>
-    EXPECTED
-
-    assert_equal expected, @to.res.join
-  end
-
-  def test_accept_verbatim_ruby
-    verb = @RM::Verbatim.new("1 + 1\n")
-    verb.format = :ruby
-
-    @to.start_accepting
-    @to.accept_verbatim verb
-
-    expected = <<-EXPECTED
-
-<pre class="ruby"><span class="ruby-value">1</span> <span class="ruby-operator">+</span> <span class="ruby-value">1</span>
-</pre>
-    EXPECTED
-
-    assert_equal expected, @to.res.join
-  end
-
-  def test_accept_verbatim_redefinable_operators
-    functions = %w[| ^ & <=> == === =~ > >= < <= << >> + - * / % ** ~ +@ -@ [] []= ` !  != !~].flat_map { |redefinable_op|
-      ["def #{redefinable_op}\n", "end\n"]
-    }
-
-    verb = @RM::Verbatim.new(*functions)
-
-    @to.start_accepting
-    @to.accept_verbatim verb
-
-    expected = <<-EXPECTED
-
-<pre class="ruby">
-    EXPECTED
-    expected = expected.rstrip
-
-    %w[| ^ & <=> == === =~ > >= < <= << >> + - * / % ** ~ +@ -@ [] []= ` !  != !~].each do |html_escaped_op|
-      expected += <<-EXPECTED
-<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">#{html_escaped_op}</span>
-<span class="ruby-keyword">end</span>
-      EXPECTED
-    end
-
-    expected += <<-EXPECTED
-</pre>
-EXPECTED
-
-    assert_equal expected, @to.res.join
-  end
-
-  def test_convert_string
-    assert_equal '<>', @to.convert_string('<>')
-  end
-
-  def test_convert_HYPERLINK_irc
-    result = @to.convert 'irc://irc.freenode.net/#ruby-lang'
-
-    assert_equal "\n<p><a href=\"irc://irc.freenode.net/#ruby-lang\">irc.freenode.net/#ruby-lang</a></p>\n", result
-  end
-
-  def test_convert_RDOCLINK_label_label
-    result = @to.convert 'rdoc-label:label-One'
-
-    assert_equal "\n<p><a href=\"#label-One\">One</a></p>\n", result
-  end
-
-  def test_convert_RDOCLINK_label_foottext
-    result = @to.convert 'rdoc-label:foottext-1'
-
-    assert_equal "\n<p><a href=\"#foottext-1\">1</a></p>\n", result
-  end
-
-  def test_convert_RDOCLINK_label_footmark
-    result = @to.convert 'rdoc-label:footmark-1'
-
-    assert_equal "\n<p><a href=\"#footmark-1\">1</a></p>\n", result
-  end
-
-  def test_convert_RDOCLINK_ref
-    result = @to.convert 'rdoc-ref:C'
-
-    assert_equal "\n<p>C</p>\n", result
-  end
-
-  def test_convert_RDOCLINK_escape_image
-    assert_escaped '<script>', 'rdoc-image:"><script>alert(`rdoc-image`)</script>"'
-  end
-
-  def test_convert_RDOCLINK_escape_label_id
-    assert_escaped '<script>', 'rdoc-label::path::"><script>alert(`rdoc-label_id`)</script>"'
-  end
-
-  def test_convert_RDOCLINK_escape_label_path
-    assert_escaped '<script>', 'rdoc-label::"><script>alert(`rdoc-label_path`)</script>"'
-  end
-
-  def test_convert_RDOCLINK_escape_ref
-    assert_escaped '<script>', 'rdoc-ref:"><script>alert(`rdoc-ref`)</script>"'
-  end
-
-  def test_convert_RDOCLINK_escape_xxx
-    assert_escaped '<script>', 'rdoc-xxx:"><script>alert(`rdoc-xxx`)</script>"'
-  end
-
-  def test_convert_TIDYLINK_footnote
-    result = @to.convert 'text{*1}[rdoc-label:foottext-1:footmark-1]'
-
-    assert_equal "\n<p>text<sup><a id=\"footmark-1\" href=\"#foottext-1\">1</a></sup></p>\n", result
-  end
-
-  def test_convert_TIDYLINK_multiple
-    result = @to.convert '{a}[http://example] {b}[http://example]'
-
-    expected = <<-EXPECTED
-
-<p><a href=\"http://example\">a</a> <a href=\"http://example\">b</a></p>
-    EXPECTED
-
-    assert_equal expected, result
-  end
-
-  def test_convert_TIDYLINK_image
-    result =
-      @to.convert '{rdoc-image:path/to/image.jpg}[http://example.com]'
-
-    expected =
-      "\n<p><a href=\"http://example.com\"><img src=\"path/to/image.jpg\"></a></p>\n"
-
-    assert_equal expected, result
-
-    result =
-      @to.convert '{rdoc-image:<script>alert`link text`</script>}[http://example.com]'
-
-    assert_not_include result, "<script>"
-  end
-
-  def test_convert_TIDYLINK_image_with_alt
-    result =
-      @to.convert '{rdoc-image:path/to/image.jpg:alt text}[http://example.com]'
-
-    expected =
-      "\n<p><a href=\"http://example.com\"><img src=\"path/to/image.jpg\" alt=\"alt text\"></a></p>\n"
-
-    assert_equal expected, result
-  end
-
-  def test_convert_TIDYLINK_image_external
-    result =
-      @to.convert '{rdoc-image:http://example.com/path/to/image.jpg}[http://example.com]'
-
-    expected =
-      "\n<p><a href=\"http://example.com\"><img src=\"http://example.com/path/to/image.jpg\"></a></p>\n"
-
-    assert_equal expected, result
-  end
-
-  def test_convert_TIDYLINK_image_external_with_alt
-    result =
-      @to.convert '{rdoc-image:http://example.com/path/to/image.jpg:alt text}[http://example.com]'
-
-    expected =
-      "\n<p><a href=\"http://example.com\"><img src=\"http://example.com/path/to/image.jpg\" alt=\"alt text\"></a></p>\n"
-
-    assert_equal expected, result
-  end
-
-  def test_convert_TIDYLINK_rdoc_label
-    result = @to.convert '{foo}[rdoc-label:foottext-1]'
-
-    assert_equal "\n<p><a href=\"#foottext-1\">foo</a></p>\n", result
-  end
-
-  def test_convert_TIDYLINK_irc
-    result = @to.convert '{ruby-lang}[irc://irc.freenode.net/#ruby-lang]'
-
-    assert_equal "\n<p><a href=\"irc://irc.freenode.net/#ruby-lang\">ruby-lang</a></p>\n", result
-  end
-
-  def test_convert_TIDYLINK_escape_text
-    assert_escaped '<script>', '{<script>alert`link text`</script>}[a]'
-    assert_escaped '<script>', 'x:/<script>alert(1);</script>[[]'
-  end
-
-  def test_convert_TIDYLINK_escape_javascript
-    assert_not_include '{click}[javascript:alert`javascript_scheme`]', '<a href="javascript:'
-  end
-
-  def test_convert_TIDYLINK_escape_onmouseover
-    assert_escaped '"/onmouseover="', '{onmouseover}[http://"/onmouseover="alert`on_mouse_link`"]'
-  end
-
-  def test_convert_TIDYLINK_escape_onerror
-    assert_escaped '"onerror="', '{link_image}[http://"onerror="alert`link_image`".png]'
-  end
-
-  def test_convert_with_exclude_tag
-    assert_equal "\n<p><code>aaa</code>[:symbol]</p>\n", @to.convert('+aaa+[:symbol]')
-    assert_equal "\n<p><code>aaa[:symbol]</code></p>\n", @to.convert('+aaa[:symbol]+')
-    assert_equal "\n<p><code>https:</code>-foobar</p>\n", @to.convert('<tt>https:</tt>-foobar')
-    assert_equal "\n<p><a href=\":symbol\">aaa</a></p>\n", @to.convert('aaa[:symbol]')
-  end
-
-  def test_convert_underscore_adjacent_to_code
-    assert_equal "\n<p><code>aaa</code>_</p>\n", @to.convert(%q{+aaa+_})
-    assert_equal "\n<p>\u{2018}<code>i386-mswin32_</code><em>MSRTVERSION</em>\u{2019}</p>\n", @to.convert(%q{`+i386-mswin32_+_MSRTVERSION_'})
-  end
-
-  def test_gen_url
-    assert_equal '<a href="example">example</a>',
-                 @to.gen_url('link:example', 'example')
-  end
-
-  def test_gen_url_rdoc_label
-    assert_equal '<a href="#foottext-1">example</a>',
-                 @to.gen_url('rdoc-label:foottext-1', 'example')
-  end
-
-  def test_gen_url_rdoc_label_id
-    assert_equal '<sup><a id="footmark-1" href="#foottext-1">example</a></sup>',
-                 @to.gen_url('rdoc-label:foottext-1:footmark-1', 'example')
-  end
-
-  def test_gen_url_image_url
-    assert_equal '<img src="http://example.com/image.png" />', @to.gen_url('http://example.com/image.png', 'ignored')
-  end
-
-  def test_gen_url_ssl_image_url
-    assert_equal '<img src="https://example.com/image.png" />', @to.gen_url('https://example.com/image.png', 'ignored')
-  end
-
-  def test_gen_url_rdoc_file
-    assert_equal '<a href="example_rdoc.html">example</a>',
-                 @to.gen_url('example.rdoc', 'example')
-    assert_equal '<a href="doc/example_rdoc.html">example</a>',
-                 @to.gen_url('doc/example.rdoc', 'example')
-    assert_equal '<a href="../ex.doc/example_rdoc.html">example</a>',
-                 @to.gen_url('../ex.doc/example.rdoc', 'example')
-    assert_equal '<a href="doc/example_rdoc.html#label-one">example</a>',
-                 @to.gen_url('doc/example.rdoc#label-one', 'example')
-    assert_equal '<a href="../ex.doc/example_rdoc.html#label-two">example</a>',
-                 @to.gen_url('../ex.doc/example.rdoc#label-two', 'example')
-  end
-
-  def test_gen_url_md_file
-    assert_equal '<a href="example_md.html">example</a>',
-                 @to.gen_url('example.md', 'example')
-    assert_equal '<a href="doc/example_md.html">example</a>',
-                 @to.gen_url('doc/example.md', 'example')
-    assert_equal '<a href="../ex.doc/example_md.html">example</a>',
-                 @to.gen_url('../ex.doc/example.md', 'example')
-    assert_equal '<a href="doc/example_md.html#label-one">example</a>',
-                 @to.gen_url('doc/example.md#label-one', 'example')
-    assert_equal '<a href="../ex.doc/example_md.html#label-two">example</a>',
-                 @to.gen_url('../ex.doc/example.md#label-two', 'example')
-  end
-
-  def test_gen_url_rb_file
-    assert_equal '<a href="example_rb.html">example</a>',
-                 @to.gen_url('example.rb', 'example')
-    assert_equal '<a href="doc/example_rb.html">example</a>',
-                 @to.gen_url('doc/example.rb', 'example')
-    assert_equal '<a href="../ex.doc/example_rb.html">example</a>',
-                 @to.gen_url('../ex.doc/example.rb', 'example')
-    assert_equal '<a href="doc/example_rb.html#label-one">example</a>',
-                 @to.gen_url('doc/example.rb#label-one', 'example')
-    assert_equal '<a href="../ex.doc/example_rb.html#label-two">example</a>',
-                 @to.gen_url('../ex.doc/example.rb#label-two', 'example')
-  end
-
-  def test_handle_regexp_HYPERLINK_link
-    target = RDoc::Markup::RegexpHandling.new 0, 'link:README.txt'
-
-    link = @to.handle_regexp_HYPERLINK target
-
-    assert_equal '<a href="README.txt">README.txt</a>', link
-  end
-
-  def test_handle_regexp_HYPERLINK_irc
-    target = RDoc::Markup::RegexpHandling.new 0, 'irc://irc.freenode.net/#ruby-lang'
-
-    link = @to.handle_regexp_HYPERLINK target
-
-    assert_equal '<a href="irc://irc.freenode.net/#ruby-lang">irc.freenode.net/#ruby-lang</a>', link
-  end
-
-  def test_handle_regexp_HYPERLINK_escape
-    code = 'irc://irc.freenode.net/"><script>alert(`irc`)</script><a"'
-    assert_escaped '<script>', code
-  end
-
-  def test_list_verbatim_2
-    str = "* one\n    verb1\n    verb2\n* two\n"
-
-    expected = <<-EXPECTED
-<ul><li>
-<p>one</p>
-
-<pre class=\"ruby\"><span class=\"ruby-identifier\">verb1</span>
-<span class=\"ruby-identifier\">verb2</span>
-</pre>
-</li><li>
-<p>two</p>
-</li></ul>
-    EXPECTED
-
-    assert_equal expected, @m.convert(str, @to)
-  end
-
-  def test_block_quote_in_verbatim
-    str = "BlockQuote\n  >>>\n"
-
-    expected = <<-EXPECTED
-<p>BlockQuote</p>
-<pre>>>></pre>
-    EXPECTED
-
-    assert_equal expected, @m.convert(str, @to).gsub(/^\n/, "")
-
-    str = "BlockQuote\n  >>>  word\n"
-
-    expected = <<-EXPECTED
-<p>BlockQuote</p>
-<pre>>>>  word</pre>
-    EXPECTED
-
-    assert_equal expected, @m.convert(str, @to).gsub(/^\n/, "")
-  end
-
-  def test_parseable_eh
-    valid_syntax = [
-      'def x() end',
-      'def x; end',
-      'class C; end',
-      "module M end",
-      'a # => blah',
-      'x { |y| nil }',
-      'x do |y| nil end',
-      '# only a comment',
-      'require "foo"',
-      'cls="foo"'
-    ]
-    invalid_syntax = [
-      'def x end',
-      'class C < end',
-      'module M < C end',
-      'a=># blah',
-      'x { |y| ... }',
-      'x do |y| ... end',
-      '// only a comment',
-      '<% require "foo" %>',
-      'class="foo"'
-    ]
-    valid_syntax.each do |t|
-      assert @to.parseable?(t), "valid syntax considered invalid: #{t}"
-    end
-    invalid_syntax.each do |t|
-      refute @to.parseable?(t), "invalid syntax considered valid: #{t}"
-    end
-  end
-
-  def test_to_html
-    assert_equal "\n<p><code>--</code></p>\n", util_format("<tt>--</tt>")
-  end
-
-  def util_format(text)
-    paragraph = RDoc::Markup::Paragraph.new text
-
-    @to.start_accepting
-    @to.accept_paragraph paragraph
-    @to.end_accepting
-  end
-
-  def test_accept_table
-    header = %w[Col1 Col2 Col3 Col4]
-    body = [
-      %w[cell1_1 cell1_2 cell1_3 cell1_4],
-      %w[cell2_1 cell2_2 cell2_3 cell2_4],
-      ['<script>alert("foo");</script>'],
-      %w[+code+ _em_ **strong** C1],
-    ]
-    aligns = [:left, :right, nil, :center]
-    @to.start_accepting
-    @to.accept_table(header, body, aligns)
-    res = @to.end_accepting
-    assert_include(res[%r<<th[^<>]*>Col1</th>>], 'align="left"')
-    assert_include(res[%r<<th[^<>]*>Col2</th>>], 'align="right"')
-    assert_not_include(res[%r<<th[^<>]*>Col3</th>>], 'align=')
-    assert_include(res[%r<<th[^<>]*>Col4</th>>], 'align="center"')
-    assert_include(res[%r<<td[^<>]*>cell1_1</td>>], 'align="left"')
-    assert_include(res[%r<<td[^<>]*>cell1_2</td>>], 'align="right"')
-    assert_not_include(res[%r<<td[^<>]*>cell1_3</td>>], 'align=')
-    assert_include(res[%r<<td[^<>]*>cell2_1</td>>], 'align="left"')
-    assert_include(res[%r<<td[^<>]*>cell2_2</td>>], 'align="right"')
-    assert_not_include(res[%r<<td[^<>]*>cell2_3</td>>], 'align=')
-    assert_include(res[%r<<td[^<>]*>cell2_4</td>>], 'align="center"')
-    assert_not_include(res, '<script>')
-    assert_include(res[%r<<td[^<>]*>.*script.*</td>>], '<script>')
-    assert_include(res[%r<<td[^<>]*>.*code.*</td>>], '<code>code</code>')
-    assert_include(res[%r<<td[^<>]*>.*em.*</td>>], '<em>em</em>')
-    assert_include(res[%r<<td[^<>]*>.*strong.*</td>>], '<strong>strong</strong>')
-    assert_include(res[%r<<td[^<>]*>C1</td>>], 'C1')
-  end
-
-  def assert_escaped(unexpected, code)
-    result = @to.convert(code)
-    assert_not_include result, unexpected
-    assert_include result, CGI.escapeHTML(unexpected)
-  end
-end
diff --git a/test/mri/rdoc/rdoc/rdoc_markup_to_joined_paragraph_test.rb b/test/mri/rdoc/rdoc/rdoc_markup_to_joined_paragraph_test.rb
deleted file mode 100644
index 89e9736e8ac..00000000000
--- a/test/mri/rdoc/rdoc/rdoc_markup_to_joined_paragraph_test.rb
+++ /dev/null
@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocMarkupToJoinedParagraphTest < RDoc::TestCase
-
-  def setup
-    super
-
-    @to = RDoc::Markup::ToJoinedParagraph.new
-  end
-
-  def test_accept_paragraph
-    parsed = para('hello', ' ', 'world')
-
-    @to.accept_paragraph parsed
-
-    expected = para('hello world')
-
-    assert_equal expected, parsed
-  end
-
-  def test_accept_paragraph_break
-    parsed = para('hello', ' ', 'world', hard_break, 'everyone')
-
-    @to.accept_paragraph parsed
-
-    expected = para('hello world', hard_break, 'everyone')
-
-    assert_equal expected, parsed
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc/rdoc_markup_to_label_test.rb b/test/mri/rdoc/rdoc/rdoc_markup_to_label_test.rb
deleted file mode 100644
index a56480de84e..00000000000
--- a/test/mri/rdoc/rdoc/rdoc_markup_to_label_test.rb
+++ /dev/null
@@ -1,112 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocMarkupToLabelTest < RDoc::Markup::FormatterTestCase
-
-  add_visitor_tests
-
-  def setup
-    super
-
-    @to = RDoc::Markup::ToLabel.new
-  end
-
-  def empty
-    assert_empty @to.res
-  end
-
-  def end_accepting
-    assert_equal %w[hi], @to.res
-  end
-
-  alias accept_blank_line                             empty
-  alias accept_block_quote                            empty
-  alias accept_document                               empty
-  alias accept_heading                                empty
-  alias accept_heading_1                              empty
-  alias accept_heading_2                              empty
-  alias accept_heading_3                              empty
-  alias accept_heading_4                              empty
-  alias accept_heading_b                              empty
-  alias accept_heading_suppressed_crossref            empty
-  alias accept_list_end_bullet                        empty
-  alias accept_list_end_label                         empty
-  alias accept_list_end_lalpha                        empty
-  alias accept_list_end_note                          empty
-  alias accept_list_end_number                        empty
-  alias accept_list_end_ualpha                        empty
-  alias accept_list_item_end_bullet                   empty
-  alias accept_list_item_end_label                    empty
-  alias accept_list_item_end_lalpha                   empty
-  alias accept_list_item_end_note                     empty
-  alias accept_list_item_end_number                   empty
-  alias accept_list_item_end_ualpha                   empty
-  alias accept_list_item_start_bullet                 empty
-  alias accept_list_item_start_label                  empty
-  alias accept_list_item_start_lalpha                 empty
-  alias accept_list_item_start_note                   empty
-  alias accept_list_item_start_note_2                 empty
-  alias accept_list_item_start_note_multi_description empty
-  alias accept_list_item_start_note_multi_label       empty
-  alias accept_list_item_start_number                 empty
-  alias accept_list_item_start_ualpha                 empty
-  alias accept_list_start_bullet                      empty
-  alias accept_list_start_label                       empty
-  alias accept_list_start_lalpha                      empty
-  alias accept_list_start_note                        empty
-  alias accept_list_start_number                      empty
-  alias accept_list_start_ualpha                      empty
-  alias accept_paragraph                              empty
-  alias accept_paragraph_b                            empty
-  alias accept_paragraph_br                           empty
-  alias accept_paragraph_break                        empty
-  alias accept_paragraph_i                            empty
-  alias accept_paragraph_plus                         empty
-  alias accept_paragraph_star                         empty
-  alias accept_paragraph_underscore                   empty
-  alias accept_raw                                    empty
-  alias accept_rule                                   empty
-  alias accept_verbatim                               empty
-  alias list_nested                                   empty
-  alias list_verbatim                                 empty
-  alias start_accepting                               empty
-
-  def test_convert_bold
-    assert_equal 'bold', @to.convert('<b>bold</b>')
-    assert_equal 'bold', @to.convert('*bold*')
-  end
-
-  def test_convert_crossref
-    assert_equal 'SomeClass', @to.convert('SomeClass')
-    assert_equal 'SomeClass', @to.convert('\\SomeClass')
-
-    assert_equal 'some_method', @to.convert('some_method')
-    assert_equal 'some_method', @to.convert('\\some_method')
-
-    assert_equal '23some_method', @to.convert('#some_method')
-    assert_equal '23some_method', @to.convert('\\#some_method')
-  end
-
-  def test_convert_em
-    assert_equal 'em', @to.convert('<em>em</em>')
-    assert_equal 'em', @to.convert('*em*')
-  end
-
-  def test_convert_em_dash # for HTML conversion
-    assert_equal '-', @to.convert('--')
-  end
-
-  def test_convert_escape
-    assert_equal 'a+-3E+b', @to.convert('a > b')
-  end
-
-  def test_convert_tidylink
-    assert_equal 'text', @to.convert('{text}[stuff]')
-    assert_equal 'text', @to.convert('text[stuff]')
-  end
-
-  def test_convert_tt
-    assert_equal 'tt', @to.convert('<tt>tt</tt>')
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc/rdoc_markup_to_markdown_test.rb b/test/mri/rdoc/rdoc/rdoc_markup_to_markdown_test.rb
deleted file mode 100644
index 86fe5ce82bc..00000000000
--- a/test/mri/rdoc/rdoc/rdoc_markup_to_markdown_test.rb
+++ /dev/null
@@ -1,397 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocMarkupToMarkdownTest < RDoc::Markup::TextFormatterTestCase
-
-  add_visitor_tests
-  add_text_tests
-
-  def setup
-    super
-
-    @to = RDoc::Markup::ToMarkdown.new
-  end
-
-  def accept_blank_line
-    assert_equal "\n", @to.res.join
-  end
-
-  def accept_block_quote
-    assert_equal "> quote\n", @to.res.join
-  end
-
-  def accept_document
-    assert_equal "hello\n", @to.res.join
-  end
-
-  def accept_heading
-    assert_equal "##### Hello\n", @to.res.join
-  end
-
-  def accept_list_end_bullet
-    assert_empty @to.list_index
-    assert_empty @to.list_type
-    assert_empty @to.list_width
-  end
-
-  def accept_list_end_label
-    assert_empty @to.list_index
-    assert_empty @to.list_type
-    assert_empty @to.list_width
-  end
-
-  def accept_list_end_lalpha
-    assert_empty @to.list_index
-    assert_empty @to.list_type
-    assert_empty @to.list_width
-  end
-
-  def accept_list_end_note
-    assert_empty @to.list_index
-    assert_empty @to.list_type
-    assert_empty @to.list_width
-  end
-
-  def accept_list_end_number
-    assert_empty @to.list_index
-    assert_empty @to.list_type
-    assert_empty @to.list_width
-  end
-
-  def accept_list_end_ualpha
-    assert_empty @to.list_index
-    assert_empty @to.list_type
-    assert_empty @to.list_width
-  end
-
-  def accept_list_item_end_bullet
-    assert_equal 0, @to.indent, 'indent'
-  end
-
-  def accept_list_item_end_label
-    assert_equal "cat\n:   \n", @to.res.join
-    assert_equal 0, @to.indent, 'indent'
-  end
-
-  def accept_list_item_end_lalpha
-    assert_equal 0, @to.indent, 'indent'
-    assert_equal 2, @to.list_index.last
-  end
-
-  def accept_list_item_end_note
-    assert_equal "cat\n:   \n", @to.res.join
-    assert_equal 0, @to.indent, 'indent'
-  end
-
-  def accept_list_item_end_number
-    assert_equal 0, @to.indent, 'indent'
-    assert_equal 2, @to.list_index.last
-  end
-
-  def accept_list_item_end_ualpha
-    assert_equal 0, @to.indent, 'indent'
-    assert_equal 2, @to.list_index.last
-  end
-
-  def accept_list_item_start_bullet
-    assert_equal [""], @to.res
-    assert_equal '*   ', @to.prefix
-  end
-
-  def accept_list_item_start_label
-    assert_equal [""], @to.res
-    assert_equal "cat\n:   ", @to.prefix
-
-    assert_equal 4, @to.indent
-  end
-
-  def accept_list_item_start_lalpha
-    assert_equal [""], @to.res
-    assert_equal '1.  ', @to.prefix
-
-    assert_equal 1, @to.list_index.last
-    assert_equal 4, @to.indent
-  end
-
-  def accept_list_item_start_note
-    assert_equal [""], @to.res
-    assert_equal "cat\n:   ", @to.prefix
-
-    assert_equal 4, @to.indent
-  end
-
-  def accept_list_item_start_number
-    assert_equal [""], @to.res
-    assert_equal '1.  ', @to.prefix
-
-    assert_equal 1, @to.list_index.last
-    assert_equal 4, @to.indent
-  end
-
-  def accept_list_item_start_ualpha
-    assert_equal [""], @to.res
-    assert_equal '1.  ', @to.prefix
-
-    assert_equal 1, @to.list_index.last
-    assert_equal 4, @to.indent
-  end
-
-  def accept_list_start_bullet
-    assert_equal "",   @to.res.join
-    assert_equal [nil],     @to.list_index
-    assert_equal [:BULLET], @to.list_type
-    assert_equal [4],       @to.list_width
-  end
-
-  def accept_list_start_label
-    assert_equal "",  @to.res.join
-    assert_equal [nil],    @to.list_index
-    assert_equal [:LABEL], @to.list_type
-    assert_equal [4],      @to.list_width
-  end
-
-  def accept_list_start_lalpha
-    assert_equal "",   @to.res.join
-    assert_equal [1],     @to.list_index
-    assert_equal [:LALPHA], @to.list_type
-    assert_equal [4],       @to.list_width
-  end
-
-  def accept_list_start_note
-    assert_equal "", @to.res.join
-    assert_equal [nil],   @to.list_index
-    assert_equal [:NOTE], @to.list_type
-    assert_equal [4],     @to.list_width
-  end
-
-  def accept_list_start_number
-    assert_equal "",   @to.res.join
-    assert_equal [1],       @to.list_index
-    assert_equal [:NUMBER], @to.list_type
-    assert_equal [4],       @to.list_width
-  end
-
-  def accept_list_start_ualpha
-    assert_equal "",   @to.res.join
-    assert_equal [1],     @to.list_index
-    assert_equal [:UALPHA], @to.list_type
-    assert_equal [4],       @to.list_width
-  end
-
-  def accept_paragraph
-    assert_equal "hi\n", @to.res.join
-  end
-
-  def accept_raw
-    raw = <<-RAW.rstrip
-<table>
-<tr><th>Name<th>Count
-<tr><td>a<td>1
-<tr><td>b<td>2
-</table>
-    RAW
-
-    assert_equal raw, @to.res.join
-  end
-
-  def accept_rule
-    assert_equal "---\n", @to.res.join
-  end
-
-  def accept_verbatim
-    assert_equal "    hi\n      world\n\n", @to.res.join
-  end
-
-  def end_accepting
-    assert_equal "hi", @to.end_accepting
-  end
-
-  def start_accepting
-    assert_equal 0, @to.indent
-    assert_equal [""], @to.res
-    assert_empty @to.list_index
-    assert_empty @to.list_type
-    assert_empty @to.list_width
-  end
-
-  def accept_heading_1
-    assert_equal "# Hello\n", @to.end_accepting
-  end
-
-  def accept_heading_2
-    assert_equal "## Hello\n", @to.end_accepting
-  end
-
-  def accept_heading_3
-    assert_equal "### Hello\n", @to.end_accepting
-  end
-
-  def accept_heading_4
-    assert_equal "#### Hello\n", @to.end_accepting
-  end
-
-  def accept_heading_indent
-    assert_equal "   # Hello\n", @to.end_accepting
-  end
-
-  def accept_heading_b
-    assert_equal "# **Hello**\n", @to.end_accepting
-  end
-
-  def accept_heading_suppressed_crossref
-    assert_equal "# Hello\n", @to.end_accepting
-  end
-
-  def accept_list_item_start_note_2
-    assert_equal "`teletype`\n:   teletype description\n\n", @to.res.join
-  end
-
-  def accept_list_item_start_note_multi_description
-    assert_equal "label\n:   description one\n\n:   description two\n\n",
-                 @to.res.join
-  end
-
-  def accept_list_item_start_note_multi_label
-    assert_equal "one\ntwo\n:   two headers\n\n", @to.res.join
-  end
-
-  def accept_paragraph_b
-    assert_equal "reg **bold words** reg\n", @to.end_accepting
-  end
-
-  def accept_paragraph_br
-    assert_equal "one  \ntwo\n", @to.end_accepting
-  end
-
-  def accept_paragraph_break
-    assert_equal "hello  \nworld\n", @to.end_accepting
-  end
-
-  def accept_paragraph_i
-    assert_equal "reg *italic words* reg\n", @to.end_accepting
-  end
-
-  def accept_paragraph_indent
-    expected = <<-EXPECTED
-   words words words words words words words words words words words words
-   words words words words words words words words words words words words
-   words words words words words words
-    EXPECTED
-
-    assert_equal expected, @to.end_accepting
-  end
-
-  def accept_paragraph_plus
-    assert_equal "reg `teletype` reg\n", @to.end_accepting
-  end
-
-  def accept_paragraph_star
-    assert_equal "reg **bold** reg\n", @to.end_accepting
-  end
-
-  def accept_paragraph_underscore
-    assert_equal "reg *italic* reg\n", @to.end_accepting
-  end
-
-  def accept_paragraph_wrap
-    expected = <<-EXPECTED
-words words words words words words words words words words words words words
-words words words words words words words words words words words words words
-words words words words
-    EXPECTED
-
-    assert_equal expected, @to.end_accepting
-  end
-
-  def accept_rule_indent
-    assert_equal "   ---\n", @to.end_accepting
-  end
-
-  def accept_verbatim_indent
-    assert_equal "      hi\n       world\n\n", @to.end_accepting
-  end
-
-  def accept_verbatim_big_indent
-    assert_equal "      hi\n      world\n\n", @to.end_accepting
-  end
-
-  def list_nested
-    expected = <<-EXPECTED
-*   l1
-    *   l1.1
-*   l2
-    EXPECTED
-
-    assert_equal expected, @to.end_accepting
-  end
-
-  def list_verbatim
-    expected = <<-EXPECTED # HACK overblown
-*   list stuff
-
-        * list
-          with
-
-          second
-
-          1. indented
-          2. numbered
-
-          third
-
-        * second
-
-    EXPECTED
-
-    assert_equal expected, @to.end_accepting
-  end
-
-  def accept_table_align
-    expected = <<-EXPECTED
- AA |BB |CCCCC|DDDDD
-----|---|-----|-----
-    |bbb|    c|
-aaaa|b  |     | dd
- a  |   |   cc| dd
-    EXPECTED
-    assert_equal expected, @to.end_accepting
-  end
-
-  def test_convert_RDOCLINK
-    result = @to.convert 'rdoc-garbage:C'
-
-    assert_equal "C\n", result
-  end
-
-  def test_convert_RDOCLINK_image
-    result = @to.convert 'rdoc-image:/path/to/image.jpg'
-
-    assert_equal "![](/path/to/image.jpg)\n", result
-  end
-
-  def test_convert_TIDYLINK
-    result = @to.convert \
-      '{DSL}[https://en.wikipedia.org/wiki/Domain-specific_language]'
-
-    expected = "[DSL](https://en.wikipedia.org/wiki/Domain-specific_language)\n"
-
-    assert_equal expected, result
-  end
-
-  def test_handle_rdoc_link_label_footmark
-    assert_equal '[^1]:', @to.handle_rdoc_link('rdoc-label:footmark-1:x')
-  end
-
-  def test_handle_rdoc_link_label_foottext
-    assert_equal '[^1]',   @to.handle_rdoc_link('rdoc-label:foottext-1:x')
-  end
-
-  def test_handle_rdoc_link_label_label
-    assert_equal '[x](#label-x)', @to.handle_rdoc_link('rdoc-label:label-x')
-  end
-
-  def test_handle_rdoc_link_ref
-    assert_equal 'x', @to.handle_rdoc_link('rdoc-ref:x')
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc/rdoc_markup_to_rdoc_test.rb b/test/mri/rdoc/rdoc/rdoc_markup_to_rdoc_test.rb
deleted file mode 100644
index c7d6120c0db..00000000000
--- a/test/mri/rdoc/rdoc/rdoc_markup_to_rdoc_test.rb
+++ /dev/null
@@ -1,388 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocMarkupToRDocTest < RDoc::Markup::TextFormatterTestCase
-
-  add_visitor_tests
-  add_text_tests
-
-  def setup
-    super
-
-    @to = RDoc::Markup::ToRdoc.new
-  end
-
-  def accept_blank_line
-    assert_equal "\n", @to.res.join
-  end
-
-  def accept_block_quote
-    assert_equal "> quote\n", @to.res.join
-  end
-
-  def accept_document
-    assert_equal "hello\n", @to.res.join
-  end
-
-  def accept_heading
-    assert_equal "===== Hello\n", @to.res.join
-  end
-
-  def accept_list_end_bullet
-    assert_empty @to.list_index
-    assert_empty @to.list_type
-    assert_empty @to.list_width
-  end
-
-  def accept_list_end_label
-    assert_empty @to.list_index
-    assert_empty @to.list_type
-    assert_empty @to.list_width
-  end
-
-  def accept_list_end_lalpha
-    assert_empty @to.list_index
-    assert_empty @to.list_type
-    assert_empty @to.list_width
-  end
-
-  def accept_list_end_note
-    assert_empty @to.list_index
-    assert_empty @to.list_type
-    assert_empty @to.list_width
-  end
-
-  def accept_list_end_number
-    assert_empty @to.list_index
-    assert_empty @to.list_type
-    assert_empty @to.list_width
-  end
-
-  def accept_list_end_ualpha
-    assert_empty @to.list_index
-    assert_empty @to.list_type
-    assert_empty @to.list_width
-  end
-
-  def accept_list_item_end_bullet
-    assert_equal 0, @to.indent, 'indent'
-  end
-
-  def accept_list_item_end_label
-    assert_equal "[cat]\n", @to.res.join
-    assert_equal 0, @to.indent, 'indent'
-  end
-
-  def accept_list_item_end_lalpha
-    assert_equal 0, @to.indent, 'indent'
-    assert_equal 'b', @to.list_index.last
-  end
-
-  def accept_list_item_end_note
-    assert_equal "cat::\n", @to.res.join
-    assert_equal 0, @to.indent, 'indent'
-  end
-
-  def accept_list_item_end_number
-    assert_equal 0, @to.indent, 'indent'
-    assert_equal 2, @to.list_index.last
-  end
-
-  def accept_list_item_end_ualpha
-    assert_equal 0, @to.indent, 'indent'
-    assert_equal 'B', @to.list_index.last
-  end
-
-  def accept_list_item_start_bullet
-    assert_equal [""], @to.res
-    assert_equal '* ', @to.prefix
-  end
-
-  def accept_list_item_start_label
-    assert_equal [""], @to.res
-    assert_equal "[cat]\n  ", @to.prefix
-
-    assert_equal 2, @to.indent
-  end
-
-  def accept_list_item_start_lalpha
-    assert_equal [""], @to.res
-    assert_equal 'a. ', @to.prefix
-
-    assert_equal 'a', @to.list_index.last
-    assert_equal 3, @to.indent
-  end
-
-  def accept_list_item_start_note
-    assert_equal [""], @to.res
-    assert_equal "cat::\n  ", @to.prefix
-
-    assert_equal 2, @to.indent
-  end
-
-  def accept_list_item_start_number
-    assert_equal [""], @to.res
-    assert_equal '1. ', @to.prefix
-
-    assert_equal 1, @to.list_index.last
-    assert_equal 3, @to.indent
-  end
-
-  def accept_list_item_start_ualpha
-    assert_equal [""], @to.res
-    assert_equal 'A. ', @to.prefix
-
-    assert_equal 'A', @to.list_index.last
-    assert_equal 3, @to.indent
-  end
-
-  def accept_list_start_bullet
-    assert_equal "",   @to.res.join
-    assert_equal [nil],     @to.list_index
-    assert_equal [:BULLET], @to.list_type
-    assert_equal [1],       @to.list_width
-  end
-
-  def accept_list_start_label
-    assert_equal "",  @to.res.join
-    assert_equal [nil],    @to.list_index
-    assert_equal [:LABEL], @to.list_type
-    assert_equal [2],      @to.list_width
-  end
-
-  def accept_list_start_lalpha
-    assert_equal "",   @to.res.join
-    assert_equal ['a'],     @to.list_index
-    assert_equal [:LALPHA], @to.list_type
-    assert_equal [1],       @to.list_width
-  end
-
-  def accept_list_start_note
-    assert_equal "", @to.res.join
-    assert_equal [nil],   @to.list_index
-    assert_equal [:NOTE], @to.list_type
-    assert_equal [2],     @to.list_width
-  end
-
-  def accept_list_start_number
-    assert_equal "",   @to.res.join
-    assert_equal [1],       @to.list_index
-    assert_equal [:NUMBER], @to.list_type
-    assert_equal [1],       @to.list_width
-  end
-
-  def accept_list_start_ualpha
-    assert_equal "",   @to.res.join
-    assert_equal ['A'],     @to.list_index
-    assert_equal [:UALPHA], @to.list_type
-    assert_equal [1],       @to.list_width
-  end
-
-  def accept_paragraph
-    assert_equal "hi\n", @to.res.join
-  end
-
-  def accept_raw
-    raw = <<-RAW.rstrip
-<table>
-<tr><th>Name<th>Count
-<tr><td>a<td>1
-<tr><td>b<td>2
-</table>
-    RAW
-
-    assert_equal raw, @to.res.join
-  end
-
-  def accept_rule
-    assert_equal "#{'-' * 78}\n", @to.res.join
-  end
-
-  def accept_verbatim
-    assert_equal "  hi\n    world\n\n", @to.res.join
-  end
-
-  def end_accepting
-    assert_equal "hi", @to.end_accepting
-  end
-
-  def start_accepting
-    assert_equal 0, @to.indent
-    assert_equal [""], @to.res
-    assert_empty @to.list_index
-    assert_empty @to.list_type
-    assert_empty @to.list_width
-  end
-
-  def accept_heading_1
-    assert_equal "= Hello\n", @to.end_accepting
-  end
-
-  def accept_heading_2
-    assert_equal "== Hello\n", @to.end_accepting
-  end
-
-  def accept_heading_3
-    assert_equal "=== Hello\n", @to.end_accepting
-  end
-
-  def accept_heading_4
-    assert_equal "==== Hello\n", @to.end_accepting
-  end
-
-  def accept_heading_indent
-    assert_equal "   = Hello\n", @to.end_accepting
-  end
-
-  def accept_heading_b
-    assert_equal "= <b>Hello</b>\n", @to.end_accepting
-  end
-
-  def accept_heading_suppressed_crossref
-    assert_equal "= Hello\n", @to.end_accepting
-  end
-
-  def accept_list_item_start_note_2
-    assert_equal "<tt>teletype</tt>::\n  teletype description\n\n", @to.res.join
-  end
-
-  def accept_list_item_start_note_multi_description
-    assert_equal "label::\n  description one\n\n  description two\n\n",
-                 @to.res.join
-  end
-
-  def accept_list_item_start_note_multi_label
-    assert_equal "one::\ntwo::\n  two headers\n\n", @to.res.join
-  end
-
-  def accept_paragraph_b
-    assert_equal "reg <b>bold words</b> reg\n", @to.end_accepting
-  end
-
-  def accept_paragraph_br
-    assert_equal "one\ntwo\n", @to.end_accepting
-  end
-
-  def accept_paragraph_break
-    assert_equal "hello\nworld\n", @to.end_accepting
-  end
-
-  def accept_paragraph_i
-    assert_equal "reg <em>italic words</em> reg\n", @to.end_accepting
-  end
-
-  def accept_paragraph_indent
-    expected = <<-EXPECTED
-   words words words words words words words words words words words words
-   words words words words words words words words words words words words
-   words words words words words words
-    EXPECTED
-
-    assert_equal expected, @to.end_accepting
-  end
-
-  def accept_paragraph_plus
-    assert_equal "reg <tt>teletype</tt> reg\n", @to.end_accepting
-  end
-
-  def accept_paragraph_star
-    assert_equal "reg <b>bold</b> reg\n", @to.end_accepting
-  end
-
-  def accept_paragraph_underscore
-    assert_equal "reg <em>italic</em> reg\n", @to.end_accepting
-  end
-
-  def accept_paragraph_wrap
-    expected = <<-EXPECTED
-words words words words words words words words words words words words words
-words words words words words words words words words words words words words
-words words words words
-    EXPECTED
-
-    assert_equal expected, @to.end_accepting
-  end
-
-  def accept_rule_indent
-    assert_equal "   #{'-' * 75}\n", @to.end_accepting
-  end
-
-  def accept_verbatim_indent
-    assert_equal "    hi\n     world\n\n", @to.end_accepting
-  end
-
-  def accept_verbatim_big_indent
-    assert_equal "    hi\n    world\n\n", @to.end_accepting
-  end
-
-  def list_nested
-    expected = <<-EXPECTED
-* l1
-  * l1.1
-* l2
-    EXPECTED
-
-    assert_equal expected, @to.end_accepting
-  end
-
-  def list_verbatim
-    expected = <<-EXPECTED # HACK overblown
-* list stuff
-
-    * list
-      with
-
-      second
-
-      1. indented
-      2. numbered
-
-      third
-
-    * second
-
-    EXPECTED
-
-    assert_equal expected, @to.end_accepting
-  end
-
-  def accept_table_align
-    expected = <<-EXPECTED
- AA |BB |CCCCC|DDDDD
-----|---|-----|-----
-    |bbb|    c|
-aaaa|b  |     | dd
- a  |   |   cc| dd
-    EXPECTED
-    assert_equal expected, @to.end_accepting
-  end
-
-  # functional test
-  def test_convert_list_note
-    note_list = <<-NOTE_LIST
-foo ::
-bar ::
-  hi
-    NOTE_LIST
-
-    expected = <<-EXPECTED
-foo::
-bar::
-  hi
-
-    EXPECTED
-
-    assert_equal expected, @to.convert(note_list)
-  end
-
-  def test_accept_indented_paragraph
-    ip = RDoc::Markup::IndentedParagraph.new 2, 'cats are cool'
-
-    @to.start_accepting
-
-    @to.accept_indented_paragraph ip
-
-    assert_equal "  cats are cool\n", @to.end_accepting
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc/rdoc_markup_to_table_of_contents_test.rb b/test/mri/rdoc/rdoc/rdoc_markup_to_table_of_contents_test.rb
deleted file mode 100644
index 3fb6fdeb427..00000000000
--- a/test/mri/rdoc/rdoc/rdoc_markup_to_table_of_contents_test.rb
+++ /dev/null
@@ -1,126 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocMarkupToTableOfContentsTest < RDoc::Markup::FormatterTestCase
-
-  add_visitor_tests
-
-  def setup
-    super
-
-    @to = RDoc::Markup::ToTableOfContents.new
-  end
-
-  def end_accepting
-    assert_equal %w[hi], @to.res
-  end
-
-  def empty
-    assert_empty @to.res
-  end
-
-  def accept_heading
-    assert_equal [@RM::Heading.new(5, 'Hello')], @to.res
-  end
-
-  def accept_heading_1
-    assert_equal [@RM::Heading.new(1, 'Hello')], @to.res
-  end
-
-  def accept_heading_2
-    assert_equal [@RM::Heading.new(2, 'Hello')], @to.res
-  end
-
-  def accept_heading_3
-    assert_equal [@RM::Heading.new(3, 'Hello')], @to.res
-  end
-
-  def accept_heading_4
-    assert_equal [@RM::Heading.new(4, 'Hello')], @to.res
-  end
-
-  def accept_heading_b
-    assert_equal [@RM::Heading.new(1, '*Hello*')], @to.res
-  end
-
-  def accept_heading_suppressed_crossref
-    assert_equal [@RM::Heading.new(1, '\\Hello')], @to.res
-  end
-
-  alias accept_blank_line                             empty
-  alias accept_block_quote                            empty
-  alias accept_document                               empty
-  alias accept_list_end_bullet                        empty
-  alias accept_list_end_label                         empty
-  alias accept_list_end_lalpha                        empty
-  alias accept_list_end_note                          empty
-  alias accept_list_end_number                        empty
-  alias accept_list_end_ualpha                        empty
-  alias accept_list_item_end_bullet                   empty
-  alias accept_list_item_end_label                    empty
-  alias accept_list_item_end_lalpha                   empty
-  alias accept_list_item_end_note                     empty
-  alias accept_list_item_end_number                   empty
-  alias accept_list_item_end_ualpha                   empty
-  alias accept_list_item_start_bullet                 empty
-  alias accept_list_item_start_label                  empty
-  alias accept_list_item_start_lalpha                 empty
-  alias accept_list_item_start_note                   empty
-  alias accept_list_item_start_note_2                 empty
-  alias accept_list_item_start_note_multi_description empty
-  alias accept_list_item_start_note_multi_label       empty
-  alias accept_list_item_start_number                 empty
-  alias accept_list_item_start_ualpha                 empty
-  alias accept_list_start_bullet                      empty
-  alias accept_list_start_label                       empty
-  alias accept_list_start_lalpha                      empty
-  alias accept_list_start_note                        empty
-  alias accept_list_start_number                      empty
-  alias accept_list_start_ualpha                      empty
-  alias accept_paragraph                              empty
-  alias accept_paragraph_b                            empty
-  alias accept_paragraph_br                           empty
-  alias accept_paragraph_break                        empty
-  alias accept_paragraph_i                            empty
-  alias accept_paragraph_plus                         empty
-  alias accept_paragraph_star                         empty
-  alias accept_paragraph_underscore                   empty
-  alias accept_raw                                    empty
-  alias accept_rule                                   empty
-  alias accept_verbatim                               empty
-  alias list_nested                                   empty
-  alias list_verbatim                                 empty
-  alias start_accepting                               empty
-
-  def test_accept_document_omit_headings_below
-    document = doc
-    document.omit_headings_below = 2
-
-    @to.accept_document document
-
-    assert_equal 2, @to.omit_headings_below
-  end
-
-  def test_accept_heading_suppressed
-    @to.start_accepting
-    @to.omit_headings_below = 4
-
-    suppressed = head 5, 'Hello'
-
-    @to.accept_heading suppressed
-
-    assert_empty @to.res
-  end
-
-  def test_suppressed_eh
-    @to.omit_headings_below = nil
-
-    refute @to.suppressed? head(1, '')
-
-    @to.omit_headings_below = 1
-
-    refute @to.suppressed? head(1, '')
-    assert @to.suppressed? head(2, '')
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc/rdoc_markup_to_tt_only_test.rb b/test/mri/rdoc/rdoc/rdoc_markup_to_tt_only_test.rb
deleted file mode 100644
index e5dfc0be963..00000000000
--- a/test/mri/rdoc/rdoc/rdoc_markup_to_tt_only_test.rb
+++ /dev/null
@@ -1,246 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocMarkupToTtOnlyTest < RDoc::Markup::FormatterTestCase
-
-  add_visitor_tests
-
-  def setup
-    super
-
-    @to = RDoc::Markup::ToTtOnly.new
-  end
-
-  def accept_blank_line
-    assert_empty @to.end_accepting
-  end
-
-  def accept_block_quote
-    assert_empty @to.end_accepting
-  end
-
-  def accept_document
-    assert_equal [], @to.res
-  end
-
-  def accept_heading
-    assert_empty @to.end_accepting
-  end
-
-  def accept_list_end_bullet
-    assert_empty @to.res
-  end
-
-  def accept_list_end_label
-    assert_empty @to.res
-  end
-
-  def accept_list_end_lalpha
-    assert_empty @to.res
-  end
-
-  def accept_list_end_note
-    assert_empty @to.res
-  end
-
-  def accept_list_end_number
-    assert_empty @to.res
-  end
-
-  def accept_list_end_ualpha
-    assert_empty @to.res
-  end
-
-  def accept_list_item_end_bullet
-    assert_empty @to.res
-  end
-
-  def accept_list_item_end_label
-    assert_empty @to.res
-  end
-
-  def accept_list_item_end_lalpha
-    assert_empty @to.res
-  end
-
-  def accept_list_item_end_note
-    assert_empty @to.res
-  end
-
-  def accept_list_item_end_number
-    assert_empty @to.res
-  end
-
-  def accept_list_item_end_ualpha
-    assert_empty @to.res
-  end
-
-  def accept_list_item_start_bullet
-    assert_empty @to.res
-  end
-
-  def accept_list_item_start_label
-    assert_empty @to.res
-  end
-
-  def accept_list_item_start_lalpha
-    assert_empty @to.res
-  end
-
-  def accept_list_item_start_note
-    assert_empty @to.res
-  end
-
-  def accept_list_item_start_number
-    assert_empty @to.res
-  end
-
-  def accept_list_item_start_ualpha
-    assert_empty @to.res
-  end
-
-  def accept_list_start_bullet
-    assert_empty @to.res
-  end
-
-  def accept_list_start_label
-    assert_empty @to.res
-  end
-
-  def accept_list_start_lalpha
-    assert_empty @to.res
-  end
-
-  def accept_list_start_note
-    assert_empty @to.res
-  end
-
-  def accept_list_start_number
-    assert_empty @to.res
-  end
-
-  def accept_list_start_ualpha
-    assert_empty @to.res
-  end
-
-  def accept_paragraph
-    assert_empty @to.end_accepting
-  end
-
-  def accept_paragraph_break
-    assert_empty @to.end_accepting
-  end
-
-  def accept_raw
-    assert_empty @to.end_accepting
-  end
-
-  def accept_rule
-    assert_empty @to.end_accepting
-  end
-
-  def accept_verbatim
-    assert_empty @to.end_accepting
-  end
-
-  def end_accepting
-    assert_equal %w[hi], @to.end_accepting
-  end
-
-  def start_accepting
-    assert_empty @to.end_accepting
-  end
-
-  def accept_heading_1
-    assert_empty @to.end_accepting
-  end
-
-  def accept_heading_2
-    assert_empty @to.end_accepting
-  end
-
-  def accept_heading_3
-    assert_empty @to.end_accepting
-  end
-
-  def accept_heading_4
-    assert_empty @to.end_accepting
-  end
-
-  def accept_heading_indent
-    assert_empty @to.end_accepting
-  end
-
-  def accept_heading_b
-    assert_empty @to.end_accepting
-  end
-
-  def accept_heading_suppressed_crossref
-    assert_empty @to.end_accepting
-  end
-
-  def accept_list_item_start_note_2
-    assert_equal [nil, 'teletype', nil], @to.res
-  end
-
-  def accept_list_item_start_note_multi_description
-    assert_empty @to.res
-  end
-
-  def accept_list_item_start_note_multi_label
-    assert_empty @to.res
-  end
-
-  def accept_paragraph_b
-    assert_empty @to.end_accepting
-  end
-
-  def accept_paragraph_br
-    assert_empty @to.end_accepting
-  end
-
-  def accept_paragraph_i
-    assert_empty @to.end_accepting
-  end
-
-  def accept_paragraph_indent
-    assert_empty @to.end_accepting
-  end
-
-  def accept_paragraph_plus
-    assert_equal %w[teletype], @to.end_accepting
-  end
-
-  def accept_paragraph_star
-    assert_empty @to.end_accepting
-  end
-
-  def accept_paragraph_underscore
-    assert_empty @to.end_accepting
-  end
-
-  def accept_paragraph_wrap
-    assert_empty @to.end_accepting
-  end
-
-  def accept_rule_indent
-    assert_empty @to.end_accepting
-  end
-
-  def accept_verbatim_indent
-    assert_empty @to.end_accepting
-  end
-
-  def accept_verbatim_big_indent
-    assert_empty @to.end_accepting
-  end
-
-  def list_nested
-    assert_empty @to.end_accepting
-  end
-
-  def list_verbatim
-    assert_empty @to.end_accepting
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc/rdoc_markup_verbatim_test.rb b/test/mri/rdoc/rdoc/rdoc_markup_verbatim_test.rb
deleted file mode 100644
index 910095c9ab4..00000000000
--- a/test/mri/rdoc/rdoc/rdoc_markup_verbatim_test.rb
+++ /dev/null
@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocMarkupVerbatimTest < RDoc::TestCase
-
-  def test_equals2
-    v1 = verb('1 + 1')
-    v2 = verb('1 + 1')
-    v3 = verb('1 + 2')
-    v4 = verb('1 + 1')
-    v4.format = :ruby
-
-    assert_equal v1, v2
-
-    refute_equal v1, v3
-    refute_equal v1, v4
-  end
-
-  def test_ruby_eh
-    verbatim = RDoc::Markup::Verbatim.new
-
-    refute verbatim.ruby?
-
-    verbatim.format = :ruby
-
-    assert verbatim.ruby?
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc/rdoc_method_attr_test.rb b/test/mri/rdoc/rdoc/rdoc_method_attr_test.rb
deleted file mode 100644
index 54a2a0d395b..00000000000
--- a/test/mri/rdoc/rdoc/rdoc_method_attr_test.rb
+++ /dev/null
@@ -1,210 +0,0 @@
-# frozen_string_literal: true
-require_relative 'xref_test_case'
-
-class RDocMethodAttrTest < XrefTestCase
-
-  def test_initialize_copy
-    refute_same @c1_m.full_name, @c1_m.dup.full_name
-  end
-
-  def test_block_params_equal
-    m = RDoc::MethodAttr.new(nil, 'foo')
-
-    m.block_params = ''
-    assert_equal '', m.block_params
-
-    m.block_params = 'a_var'
-    assert_equal 'a_var', m.block_params
-
-    m.block_params = '()'
-    assert_equal '', m.block_params
-
-    m.block_params = '(a_var, b_var)'
-    assert_equal 'a_var, b_var', m.block_params
-
-    m.block_params = '.to_s + "</#{element.upcase}>"'
-    assert_equal '', m.block_params
-
-    m.block_params = 'i.name'
-    assert_equal 'name', m.block_params
-
-    m.block_params = 'attr.expanded_name, attr.value'
-    assert_equal 'expanded_name, value', m.block_params
-
-    m.block_params = 'expanded_name, attr.value'
-    assert_equal 'expanded_name, value', m.block_params
-
-    m.block_params = 'attr.expanded_name, value'
-    assert_equal 'expanded_name, value', m.block_params
-
-    m.block_params = '(@base_notifier)'
-    assert_equal 'base_notifier', m.block_params
-
-    m.block_params = 'if @signal_status == :IN_LOAD'
-    assert_equal '', m.block_params
-
-    m.block_params = 'e if e.kind_of? Element'
-    assert_equal 'e', m.block_params
-
-    m.block_params = '(e, f) if e.kind_of? Element'
-    assert_equal 'e, f', m.block_params
-
-    m.block_params = 'back_path, back_name'
-    assert_equal 'back_path, back_name', m.block_params
-
-    m.block_params = '(*a[1..-1])'
-    assert_equal '*a', m.block_params
-
-    m.block_params = '@@context[:node] if defined? @@context[:node].namespace'
-    assert_equal 'context', m.block_params
-
-    m.block_params = '(result, klass.const_get(constant_name))'
-    assert_equal 'result, const', m.block_params
-
-    m.block_params = 'name.to_s if (bitmap & bit) != 0'
-    assert_equal 'name', m.block_params
-
-    m.block_params = 'line unless line.deleted'
-    assert_equal 'line', m.block_params
-
-    m.block_params = 'str + rs'
-    assert_equal 'str', m.block_params
-
-    m.block_params = 'f+rs'
-    assert_equal 'f', m.block_params
-
-    m.block_params = '[user, realm, hash[user]]'
-    assert_equal 'user, realm, hash', m.block_params
-
-    m.block_params = 'proc{|rc| rc == "rc" ? irbrc : irbrc+rc| ... }'
-    assert_equal 'proc', m.block_params
-
-    m.block_params = 'lambda { |x| x.to_i }'
-    assert_equal 'lambda', m.block_params
-
-    m.block_params = '$&'
-    assert_equal 'str', m.block_params
-
-    m.block_params = 'Inflections.instance'
-    assert_equal 'instance', m.block_params
-
-    m.block_params = 'self.class::STARTED'
-    assert_equal 'STARTED', m.block_params
-
-    m.block_params = 'Test::Unit::TestCase::STARTED'
-    assert_equal 'STARTED', m.block_params
-
-    m.block_params = 'ActiveSupport::OptionMerger.new(self, options)'
-    assert_equal 'option_merger', m.block_params
-
-    m.block_params = ', msg'
-    assert_equal '', m.block_params
-
-    m.block_params = '[size.to_s(16), term, chunk, term].join'
-    assert_equal '[size, term, chunk, term].join', m.block_params
-
-    m.block_params = 'YPath.new( path )'
-    assert_equal 'y_path', m.block_params
-
-  end
-
-  def test_find_method_or_attribute_recursive
-    inc = RDoc::Include.new 'M1', nil
-    @m1.add_include inc # M1 now includes itself
-
-    assert_nil @m1_m.find_method_or_attribute 'm'
-  end
-
-  def test_full_name
-    assert_equal 'C1#m',  @c1_m.full_name
-    assert_equal 'C1::m', @c1__m.full_name
-  end
-
-  def test_is_alias_for
-    assert_equal @c2_b, @c2_a.is_alias_for
-  end
-
-  def test_search_record
-    @c1_m.comment = 'This is a comment.'
-
-    expected = [
-      'm',
-      'C1#m',
-      'm',
-      'C1',
-      'C1.html#method-i-m',
-      '(foo)',
-      "<p>This is a comment.\n",
-    ]
-
-    assert_equal expected, @c1_m.search_record
-  end
-
-  def test_spaceship_returns_nil_on_inappropriate_types
-    assert_nil @c1_m.<=>(RDoc::CodeObject.new)
-  end
-
-  def test_spaceship_orders_symbols_first
-    # in the desired sort order
-    m_plus       = RDoc::AnyMethod.new nil, '+'
-    m_eqeq       = RDoc::AnyMethod.new nil, '=='
-    m_bracket    = RDoc::AnyMethod.new nil, '[]'
-    m_caret      = RDoc::AnyMethod.new nil, '^'
-    m_bar        = RDoc::AnyMethod.new nil, '|'
-    m_tilde      = RDoc::AnyMethod.new nil, '~'
-    m_Alpha      = RDoc::AnyMethod.new nil, 'Alpha'
-    m_Zero       = RDoc::AnyMethod.new nil, 'Zero'
-    m_alpha      = RDoc::AnyMethod.new nil, 'alpha'
-    m_zero       = RDoc::AnyMethod.new nil, 'zero'
-    m_konnichiwa = RDoc::AnyMethod.new nil, 'こんにちは'
-
-    assert_equal(-1, m_plus <=> m_eqeq)
-    assert_equal(-1, m_eqeq <=> m_bracket)
-    assert_equal(-1, m_bracket <=> m_caret)
-    assert_equal(-1, m_caret <=> m_bar)
-    assert_equal(-1, m_bar <=> m_tilde)
-    assert_equal(-1, m_tilde <=> m_Alpha)
-    assert_equal(-1, m_Alpha <=> m_Zero)
-    assert_equal(-1, m_Zero <=> m_alpha)
-    assert_equal(-1, m_alpha <=> m_zero)
-    assert_equal(-1, m_zero <=> m_konnichiwa)
-  end
-
-  def test_equals2
-    assert_equal @c1_m, @c1_m
-    refute_equal @c1_m, @parent_m
-  end
-
-  def test_pretty_print
-    temp_dir do |tmpdir|
-      s = RDoc::RI::Store.new(RDoc::Options.new, path: tmpdir)
-
-      top_level = s.add_file 'file.rb'
-      meth_bang = RDoc::AnyMethod.new nil, 'method!'
-      meth_bang.record_location top_level
-
-      meth_bang_alias = RDoc::Alias.new nil, 'method!', 'method_bang', ''
-      meth_bang_alias.record_location top_level
-
-      klass = top_level.add_class RDoc::NormalClass, 'Object'
-      klass.add_method meth_bang
-
-      meth_bang.add_alias meth_bang_alias, klass
-
-      s.save
-
-      meth_alias_from_store = s.load_method 'Object', '#method_bang'
-
-      expected = "[RDoc::AnyMethod Object#method_bang public alias for method!]"
-      actual =  mu_pp meth_alias_from_store
-      assert_equal expected, actual
-    end
-  end
-
-  def test_to_s
-    assert_equal 'RDoc::AnyMethod: C1#m',  @c1_m.to_s
-    assert_equal 'RDoc::AnyMethod: C2#b',  @c2_b.to_s
-    assert_equal 'RDoc::AnyMethod: C1::m', @c1__m.to_s
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc/rdoc_normal_class_test.rb b/test/mri/rdoc/rdoc/rdoc_normal_class_test.rb
deleted file mode 100644
index d61ef5ccd92..00000000000
--- a/test/mri/rdoc/rdoc/rdoc_normal_class_test.rb
+++ /dev/null
@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-require_relative 'xref_test_case'
-
-class RDocNormalClassTest < XrefTestCase
-
-  def test_ancestors
-    klass = @top_level.add_class RDoc::NormalClass, 'Klass'
-    incl = RDoc::Include.new 'Incl', ''
-
-    sub_klass = @top_level.add_class RDoc::NormalClass, 'SubClass'
-    sub_klass.superclass = klass
-    sub_klass.add_include incl
-
-    assert_equal [incl.name, klass, @object, 'BasicObject'], sub_klass.ancestors
-  end
-
-  def test_ancestors_multilevel
-    c1 = @top_level.add_class RDoc::NormalClass, 'Outer'
-    c2 = @top_level.add_class RDoc::NormalClass, 'Middle', c1.full_name
-    c3 = @top_level.add_class RDoc::NormalClass, 'Inner', c2.full_name
-
-    assert_equal [c2, c1, @object, 'BasicObject'], c3.ancestors
-  end
-
-  def test_aref
-    assert_equal 'class-C1',     @c1.aref
-    assert_equal 'class-C2::C3', @c2_c3.aref
-  end
-
-  def test_direct_ancestors
-    incl = RDoc::Include.new 'Incl', ''
-
-    c1 = @top_level.add_class RDoc::NormalClass, 'Outer'
-    c2 = @top_level.add_class RDoc::NormalClass, 'Middle', c1.full_name
-    c3 = @top_level.add_class RDoc::NormalClass, 'Inner', c2.full_name
-    c3.add_include incl
-
-    assert_equal [incl.name, c2], c3.direct_ancestors
-  end
-
-  def test_definition
-    c = RDoc::NormalClass.new 'C'
-
-    assert_equal 'class C', c.definition
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc/rdoc_normal_module_test.rb b/test/mri/rdoc/rdoc/rdoc_normal_module_test.rb
deleted file mode 100644
index bb0a2afc768..00000000000
--- a/test/mri/rdoc/rdoc/rdoc_normal_module_test.rb
+++ /dev/null
@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-require_relative 'xref_test_case'
-
-class RDocNormalModuleTest < XrefTestCase
-
-  def setup
-    super
-
-    @mod = RDoc::NormalModule.new 'Mod'
-  end
-
-  def test_ancestors_module
-    top_level = @store.add_file 'file.rb'
-    mod = top_level.add_module RDoc::NormalModule, 'Mod'
-    incl = RDoc::Include.new 'Incl', ''
-
-    mod.add_include incl
-
-    assert_equal [incl.name], mod.ancestors
-
-    mod2 = top_level.add_module RDoc::NormalModule, 'Inc2'
-    inc2 = RDoc::Include.new 'Inc2', ''
-    mod.add_include inc2
-    assert_equal [mod2, incl.name], mod.ancestors
-  end
-
-  def test_aref
-    assert_equal 'module-M1',     @m1.aref
-    assert_equal 'module-M1::M2', @m1_m2.aref
-  end
-
-  def test_definition
-    m = RDoc::NormalModule.new 'M'
-
-    assert_equal 'module M', m.definition
-  end
-
-  def test_module_eh
-    assert @mod.module?
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc/rdoc_options_test.rb b/test/mri/rdoc/rdoc/rdoc_options_test.rb
deleted file mode 100644
index 097d0f5523c..00000000000
--- a/test/mri/rdoc/rdoc/rdoc_options_test.rb
+++ /dev/null
@@ -1,975 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocOptionsTest < RDoc::TestCase
-
-  def setup
-    super
-
-    @options = RDoc::Options.new
-    @generators = RDoc::RDoc::GENERATORS.dup
-  end
-
-  def teardown
-    super
-
-    RDoc::RDoc::GENERATORS.replace @generators
-  end
-
-  def test_check_files
-    omit "assumes UNIX permission model" if /mswin|mingw/ =~ RUBY_PLATFORM
-    omit "assumes that euid is not root" if Process.euid == 0
-
-    out, err = capture_output do
-      temp_dir do
-        FileUtils.touch 'unreadable'
-        FileUtils.chmod 0, 'unreadable'
-
-        @options.files = %w[nonexistent unreadable]
-
-        @options.check_files
-      end
-    end
-
-    assert_empty @options.files
-
-    assert_empty out
-    assert_empty err
-  end
-
-  def test_check_files_warn
-    @options.verbosity = 2
-
-    out, err = verbose_capture_output do
-      @options.files = %w[nonexistent]
-
-      @options.check_files
-    end
-
-    assert_empty out
-    assert_equal "file 'nonexistent' not found\n", err
-    assert_empty @options.files
-  end
-
-  def test_dry_run_default
-    refute @options.dry_run
-  end
-
-  def test_to_yaml
-    RDoc.load_yaml
-
-    coder = YAML.load(@options.to_yaml)
-
-    encoding = 'UTF-8'
-
-    expected = {
-      'charset'               => 'UTF-8',
-      'encoding'              => encoding,
-      'embed_mixins'          => false,
-      'exclude'               => [],
-      'hyperlink_all'         => false,
-      'line_numbers'          => false,
-      'locale_dir'            => 'locale',
-      'locale_name'           => nil,
-      'main_page'             => nil,
-      'markup'                => 'rdoc',
-      'output_decoration'     => true,
-      'page_dir'              => nil,
-      'rdoc_include'          => [],
-      'show_hash'             => false,
-      'static_path'           => [],
-      'tab_width'             => 8,
-      'template_stylesheets'  => [],
-      'title'                 => nil,
-      'visibility'            => :protected,
-      'warn_missing_rdoc_ref' => true,
-      'webcvs'                => nil,
-      'skip_tests'            => true,
-      'apply_default_exclude' => true,
-      'autolink_excluded_words' => [],
-      'class_module_path_prefix' => nil,
-      'file_path_prefix' => nil,
-      'canonical_root' => nil,
-    }
-
-    assert_equal expected, coder
-  end
-
-  def test_to_yaml_trim_paths
-    RDoc.load_yaml
-
-    subdir = nil
-    coder = nil
-
-    temp_dir do |dir|
-      FileUtils.mkdir 'project'
-      FileUtils.mkdir 'dir'
-      FileUtils.touch 'file'
-
-      Dir.chdir 'project' do
-        subdir = File.expand_path 'subdir'
-        FileUtils.mkdir 'subdir'
-        @options.parse %w[
-          --copy subdir
-          --copy ../file
-          --copy ../
-          --copy /
-          --include subdir
-          --include ../dir
-          --include ../
-          --include /
-        ]
-
-        coder = YAML.load(@options.to_yaml)
-      end
-    end
-
-    assert_equal [subdir], coder['rdoc_include']
-
-    assert_equal [subdir], coder['static_path']
-  end
-
-  def test_encoding_default
-    assert_equal Encoding::UTF_8, @options.encoding
-  end
-
-  def test_generator_descriptions
-    # HACK autotest/isolate should take care of this
-    RDoc::RDoc::GENERATORS.clear
-    RDoc::RDoc::GENERATORS['darkfish'] = RDoc::Generator::Darkfish
-    RDoc::RDoc::GENERATORS['ri']       = RDoc::Generator::RI
-
-    expected = <<-EXPECTED.chomp
-  darkfish - HTML generator, written by Michael Granger
-  ri       - creates ri data files
-    EXPECTED
-
-    assert_equal expected, @options.generator_descriptions
-  end
-
-  def test_init_with_encoding
-    RDoc.load_yaml
-
-    @options.encoding = Encoding::IBM437
-
-    options = @options.to_yaml
-    options = YAML.safe_load(options, permitted_classes: [Symbol])
-    options = RDoc::Options.new(options)
-
-    assert_equal Encoding::IBM437, options.encoding
-  end
-
-  def test_init_with_trim_paths
-    RDoc.load_yaml
-
-    yaml = <<-YAML
----
-static_path:
-- /etc
-rdoc_include:
-- /etc
-    YAML
-
-    options = YAML.safe_load(yaml, permitted_classes: [Symbol])
-    options = RDoc::Options.new(options)
-
-    assert_empty options.rdoc_include
-    assert_empty options.static_path
-  end
-
-  def test_parse_copy_files_file_relative
-    file = File.basename __FILE__
-    expected = File.expand_path __FILE__
-
-    Dir.chdir File.expand_path('..', __FILE__) do
-      @options.parse %W[--copy-files #{file}]
-
-      assert_equal [expected], @options.static_path
-    end
-  end
-
-  def test_parse_copy_files_file_absolute
-    @options.parse %W[--copy-files #{File.expand_path __FILE__}]
-
-    assert_equal [File.expand_path(__FILE__)], @options.static_path
-  end
-
-  def test_parse_copy_files_directory_relative
-    @options.parse %w[--copy-files .]
-
-    assert_equal [@pwd], @options.static_path
-  end
-
-  def test_parse_copy_files_directory_absolute
-    @options.parse %w[--copy-files /]
-
-    assert_equal 1, @options.static_path.length
-
-    assert_match %r%^([A-Z]:)?/$%i, @options.static_path.first
-  end
-
-  def test_parse_coverage
-    @options.parse %w[--dcov]
-
-    assert @options.coverage_report
-    assert @options.force_update
-  end
-
-  def test_parse_coverage_C
-    @options.parse %w[-C]
-
-    assert @options.coverage_report
-    assert @options.force_update
-  end
-
-  def test_parse_coverage_no
-    @options.parse %w[--no-dcov]
-
-    refute @options.coverage_report
-  end
-
-  def test_parse_coverage_level_1
-    @options.parse %w[--dcov=1]
-
-    assert_equal 1, @options.coverage_report
-  end
-
-  def test_parse_coverage_C_level_1
-    @options.parse %w[-C1]
-
-    assert_equal 1, @options.coverage_report
-  end
-
-  def test_parse_coverage_C_level_0
-    @options.parse %w[-C0]
-
-    assert_equal 0, @options.coverage_report
-    assert @options.force_update
-  end
-
-  def test_parse_dash_p
-    out, err = capture_output do
-      @options.parse %w[-p]
-    end
-
-    assert @options.pipe
-    refute_match %r%^Usage: %, err
-    refute_match %r%^invalid options%, err
-
-    assert_empty out
-  end
-
-  def test_parse_dash_p_files
-    out, err = capture_output do
-      @options.parse ['-p', File.expand_path(__FILE__)]
-    end
-
-    refute @options.pipe
-    refute_match %r%^Usage: %, err
-    assert_match %r%^invalid options: -p .with files.%, err
-
-    assert_empty out
-  end
-
-  def test_parse_default
-    @options.parse []
-    @options.finish
-
-    assert_equal RDoc::Generator::Darkfish,             @options.generator
-    assert_equal 'darkfish',                            @options.template
-    assert_match %r%rdoc/generator/template/darkfish$%, @options.template_dir
-  end
-
-  def test_parse_deprecated
-    dep_hash = RDoc::Options::DEPRECATED
-    options = dep_hash.keys.sort
-
-    out, err = capture_output do
-      @options.parse options
-    end
-
-    dep_hash.each_pair do |opt, message|
-      assert_match %r%.*#{opt}.+#{message}%, err
-    end
-
-    assert_empty out
-  end
-
-  def test_parse_dry_run
-    @options.parse %w[--dry-run]
-
-    assert @options.dry_run
-  end
-
-  def test_parse_encoding
-    @options.parse %w[--encoding Big5]
-
-    assert_equal Encoding::Big5, @options.encoding
-    assert_equal 'Big5',         @options.charset
-  end
-
-  def test_parse_encoding_invalid
-    out, err = capture_output do
-      @options.parse %w[--encoding invalid]
-    end
-
-    assert_match %r%^invalid options: --encoding invalid%, err
-
-    assert_empty out
-  end
-
-  def test_parse_formatter
-    e = assert_raise OptionParser::InvalidOption do
-      @options.parse %w[--format darkfish --format ri]
-    end
-
-    assert_equal 'invalid option: --format generator already set to darkfish',
-                 e.message
-  end
-
-  def test_parse_force_update
-    @options.parse %w[--force-update]
-
-    assert @options.force_update
-
-    @options.parse %w[--no-force-update]
-
-    assert !@options.force_update
-
-    @options.parse %w[-U]
-
-    assert @options.force_update
-  end
-
-  def test_parse_formatter_ri
-    e = assert_raise OptionParser::InvalidOption do
-      @options.parse %w[--format darkfish --ri]
-    end
-
-    assert_equal 'invalid option: --ri generator already set to darkfish',
-                 e.message
-
-    @options = RDoc::Options.new
-
-    e = assert_raise OptionParser::InvalidOption do
-      @options.parse %w[--format darkfish -r]
-    end
-
-    assert_equal 'invalid option: -r generator already set to darkfish',
-                 e.message
-  end
-
-  def test_parse_formatter_ri_site
-    e = assert_raise OptionParser::InvalidOption do
-      @options.parse %w[--format darkfish --ri-site]
-    end
-
-    assert_equal 'invalid option: --ri-site generator already set to darkfish',
-                 e.message
-
-    @options = RDoc::Options.new
-
-    e = assert_raise OptionParser::InvalidOption do
-      @options.parse %w[--format darkfish -R]
-    end
-
-    assert_equal 'invalid option: -R generator already set to darkfish',
-                 e.message
-  end
-
-  def test_parse_h
-    out, = capture_output do
-      begin
-        @options.parse %w[-h]
-      rescue SystemExit
-      end
-    end
-
-    assert_equal 1, out.scan(/HTML generator options:/).length
-    assert_equal 1, out.scan(/ri generator options:/).  length
-  end
-
-  def test_parse_help
-    out, = capture_output do
-      begin
-        @options.parse %w[--help]
-      rescue SystemExit
-      end
-    end
-
-    assert_equal 1, out.scan(/HTML generator options:/).length
-    assert_equal 1, out.scan(/ri generator options:/).  length
-  end
-
-  def test_parse_help_extra_generator
-    RDoc::RDoc::GENERATORS['test'] = Class.new do
-      def self.setup_options(options)
-        op = options.option_parser
-
-        op.separator 'test generator options:'
-      end
-    end
-
-    out, = capture_output do
-      begin
-        @options.parse %w[--help]
-      rescue SystemExit
-      end
-    end
-
-    assert_equal 1, out.scan(/HTML generator options:/).length
-    assert_equal 1, out.scan(/ri generator options:/).  length
-    assert_equal 1, out.scan(/test generator options:/).length
-  end
-
-  def test_parse_format_for_extra_generator
-    RDoc::RDoc::GENERATORS['test'] = Class.new do
-      def self.setup_options(options)
-        op = options.option_parser
-
-        op.separator 'test generator options:'
-      end
-    end
-
-    @options.setup_generator 'test'
-
-    assert_equal @options.generator_name, 'test'
-  end
-
-  def test_parse_ignore_invalid
-    out, err = capture_output do
-      @options.parse %w[--ignore-invalid --bogus]
-    end
-
-    refute_match %r%^Usage: %, err
-    assert_match %r%^invalid options: --bogus%, err
-
-    assert_empty out
-  end
-
-  def test_parse_ignore_invalid_default
-    out, err = capture_output do
-      @options.parse %w[--bogus --main BLAH]
-    end
-
-    refute_match %r%^Usage: %, err
-    assert_match %r%^invalid options: --bogus%, err
-
-    assert_equal 'BLAH', @options.main_page
-
-    assert_empty out
-  end
-
-  def test_parse_ignore_invalid_no
-    out, err = capture_output do
-      assert_raise SystemExit do
-        @options.parse %w[--no-ignore-invalid --bogus=arg --bobogus --visibility=extended]
-      end
-    end
-
-    assert_match %r%^Usage: %, err
-    assert_match %r%^invalid options: --bogus=arg, --bobogus, --visibility=extended%, err
-
-    assert_empty out
-  end
-
-  def test_parse_ignore_invalid_no_quiet
-    out, err = capture_output do
-      assert_raise SystemExit do
-        @options.parse %w[--quiet --no-ignore-invalid --bogus=arg --bobogus --visibility=extended]
-      end
-    end
-
-    refute_match %r%^Usage: %, err
-    assert_match %r%^invalid options: --bogus=arg, --bobogus, --visibility=extended%, err
-
-    assert_empty out
-  end
-
-  def test_ignore_needless_arg
-    out, err = capture_output do
-      @options.parse %w[--ri=foo]
-    end
-
-    assert_match %r%^invalid options: --ri=foo%, err
-
-    assert_empty out
-  end
-
-  def test_ignore_missing_arg
-    out, err = capture_output do
-      @options.parse %w[--copy-files]
-    end
-
-    assert_match %r%^invalid options: --copy-files%, err
-
-    assert_empty out
-  end
-
-  def test_parse_main
-    out, err = capture_output do
-      @options.parse %w[--main MAIN]
-    end
-
-    assert_empty out
-    assert_empty err
-
-    assert_equal 'MAIN', @options.main_page
-  end
-
-  def test_parse_markup
-    out, err = capture_output do
-      @options.parse %w[--markup tomdoc]
-    end
-
-    assert_empty out
-    assert_empty err
-
-    assert_equal 'tomdoc', @options.markup
-  end
-
-  def test_parse_page_dir
-    assert_nil @options.page_dir
-
-    out, err = capture_output do
-      @options.parse %W[--page-dir #{Dir.tmpdir}]
-      @options.finish
-    end
-
-    assert_empty out
-    assert_empty err
-
-    expected = nil
-    begin
-      expected =
-        Pathname(Dir.tmpdir).expand_path.relative_path_from @options.root
-    rescue ArgumentError
-      # On Windows, sometimes crosses different drive letters.
-      expected = Pathname(Dir.tmpdir).expand_path
-    end
-
-    assert_equal expected,     @options.page_dir
-    assert_equal [Dir.tmpdir], @options.files
-  end
-
-  def test_parse_page_dir_root
-    assert_nil @options.page_dir
-
-    Dir.mktmpdir do |dir|
-      abs_root     = dir
-      abs_page_dir = File.join dir, 'pages'
-      FileUtils.mkdir abs_page_dir
-
-      out, err = capture_output do
-        @options.parse %W[--page-dir #{abs_page_dir} --root #{abs_root}]
-        @options.finish
-      end
-
-      assert_empty out
-      assert_empty err
-
-      assert_equal Pathname('pages'), @options.page_dir
-      assert_equal [abs_page_dir],    @options.files
-    end
-  end
-
-  def test_parse_ri_site
-    @options.parse %w[--ri-site]
-
-    assert_equal RDoc::Generator::RI,      @options.generator
-    assert_equal RDoc::RI::Paths.site_dir, @options.op_dir
-  end
-
-  def test_parse_root
-    assert_equal Pathname(Dir.pwd), @options.root
-
-    out, err = capture_output do
-      @options.parse %W[--root #{Dir.tmpdir}]
-    end
-
-    assert_empty out
-    assert_empty err
-
-    assert_equal Pathname(Dir.tmpdir), @options.root
-
-    @options.finish
-    assert_includes @options.rdoc_include, @options.root.to_s
-  end
-
-  def test_parse_embed_mixins
-    assert_false(@options.embed_mixins)
-
-    out, err = capture_output { @options.parse(["--embed-mixins"]) }
-    assert_empty(out)
-    assert_empty(err)
-    assert_true(@options.embed_mixins)
-
-    out, err = capture_output { @options.parse(["--no-embed-mixins"]) }
-    assert_empty(out)
-    assert_empty(err)
-    assert_false(@options.embed_mixins)
-  end
-
-  def test_parse_tab_width
-    @options.parse %w[--tab-width=1]
-    assert_equal 1, @options.tab_width
-
-    @options.parse %w[-w2]
-    assert_equal 2, @options.tab_width
-
-    _, err = capture_output do
-      @options.parse %w[-w=2]
-    end
-
-    assert_match 'invalid options', err
-
-    _, err = capture_output do
-      @options.parse %w[-w0]
-    end
-
-    assert_match 'invalid options', err
-  end
-
-  def test_parse_template
-    out, err = capture_output do
-      @options.parse %w[--template darkfish]
-    end
-
-    assert_empty out
-    assert_empty err
-
-    assert_equal 'darkfish', @options.template
-
-    assert_match %r%rdoc/generator/template/darkfish$%, @options.template_dir
-  end
-
-  def test_parse_template_nonexistent
-    out, err = capture_output do
-      @options.parse %w[--template NONEXISTENT]
-    end
-
-    assert_empty out
-    assert_equal "could not find template NONEXISTENT\n", err
-
-    @options.finish
-    assert_equal 'darkfish', @options.template
-    assert_match %r%rdoc/generator/template/darkfish$%, @options.template_dir
-  end
-
-  def test_parse_template_load_path
-    orig_LOAD_PATH = $LOAD_PATH.dup
-
-    template_dir = nil
-
-    Dir.mktmpdir do |dir|
-      $LOAD_PATH << dir
-
-      template_dir = File.join dir, 'rdoc', 'generator', 'template', 'load_path'
-
-      FileUtils.mkdir_p template_dir
-
-      out, err = capture_output do
-        @options.parse %w[--template load_path]
-      end
-
-      assert_empty out
-      assert_empty err
-    end
-
-    assert_equal 'load_path',  @options.template
-    assert_equal template_dir, @options.template_dir
-  ensure
-    $LOAD_PATH.replace orig_LOAD_PATH
-  end
-
-  def test_parse_template_stylesheets
-    css = nil
-    Dir.mktmpdir do |dir|
-      css = File.join(dir, "hoge.css")
-      File.write(css, "")
-      out, err = capture_output do
-        @options.parse %W[--template-stylesheets #{css}]
-      end
-
-      assert_empty out
-      assert_empty err
-    end
-    assert_include @options.template_stylesheets, css
-  end
-
-  def test_parse_visibility
-    @options.parse %w[--visibility=public]
-    assert_equal :public, @options.visibility
-
-    @options.parse %w[--visibility=protected]
-    assert_equal :protected, @options.visibility
-
-    @options.parse %w[--visibility=private]
-    assert_equal :private, @options.visibility
-
-    @options.parse %w[--visibility=nodoc]
-    assert_equal :nodoc, @options.visibility
-  end
-
-  def test_parse_write_options
-    tmpdir = File.join Dir.tmpdir, "test_rdoc_options_#{$$}"
-    FileUtils.mkdir_p tmpdir
-
-    Dir.chdir tmpdir do
-      e = assert_raise SystemExit do
-        @options.parse %w[--write-options]
-        @options.finish
-      end
-
-      assert_equal 0, e.status
-
-      assert File.exist? '.rdoc_options'
-    end
-  ensure
-    FileUtils.rm_rf tmpdir
-  end
-
-  def test_parse_extension_alias
-    out, err = capture_output do
-      @options.parse %w[--extension foobar=rdoc]
-    end
-
-    assert_includes RDoc::Parser.parsers, [/\.foobar$/, RDoc::Parser::Simple]
-
-    assert_empty out
-    assert_empty err
-  end
-
-  def test_parse_locale_name_default
-    temp_dir do
-      @options.parse %w[]
-      assert_equal 'locale', @options.instance_variable_get(:@locale_dir)
-      assert_nil @options.instance_variable_get(:@locale_name)
-      assert_nil @options.locale
-      @options.finish
-      assert_nil @options.locale
-    end
-  end
-
-  def test_parse_locale_name
-    temp_dir do
-      @options.parse %w[--locale fr]
-      assert_equal 'locale', @options.instance_variable_get(:@locale_dir)
-      assert_equal 'fr', @options.instance_variable_get(:@locale_name)
-      assert_nil @options.locale
-      @options.finish
-      assert_equal 'fr', @options.locale.name
-    end
-  end
-
-  def test_setup_generator
-    test_generator = Class.new do
-      def self.setup_options(op)
-        @op = op
-      end
-
-      def self.op() @op end
-    end
-
-    RDoc::RDoc::GENERATORS['test'] = test_generator
-
-    @options.setup_generator 'test'
-
-    assert_equal test_generator, @options.generator
-    assert_equal [test_generator], @options.generator_options
-
-    assert_equal @options, test_generator.op
-  ensure
-    RDoc::RDoc::GENERATORS.delete 'test'
-  end
-
-  def test_setup_generator_no_option_parser
-    test_generator = Class.new do
-      def self.setup_options(op)
-        op.option_parser.separator nil
-        @op = op
-      end
-
-      def self.op() @op end
-    end
-
-    RDoc::RDoc::GENERATORS['test'] = test_generator
-
-    @options.setup_generator 'test'
-
-    assert_equal test_generator, @options.generator
-    assert_equal [test_generator], @options.generator_options
-
-    assert_equal @options, test_generator.op
-  ensure
-    RDoc::RDoc::GENERATORS.delete 'test'
-  end
-
-  def test_update_output_dir
-    assert @options.update_output_dir
-
-    @options.update_output_dir = false
-
-    refute @options.update_output_dir
-  end
-
-  def test_warn
-    out, err = capture_output do
-      @options.warn "warnings off"
-    end
-
-    assert_empty out
-    assert_empty err
-
-    @options.verbosity = 2
-
-    out, err = verbose_capture_output do
-      @options.warn "warnings on"
-    end
-
-    assert_empty out
-    assert_equal "warnings on\n", err
-  end
-
-  def test_write_options
-    temp_dir do |dir|
-      @options.write_options
-
-      assert File.exist? '.rdoc_options'
-
-      options = File.read('.rdoc_options')
-      options = YAML.safe_load(options, permitted_classes: [Symbol])
-      assert_equal @options, RDoc::Options.new(options)
-    end
-  end
-
-  def test_version
-    out, _ = capture_output do
-      begin
-        @options.parse %w[--version]
-      rescue SystemExit
-      end
-    end
-
-    assert out.include?(RDoc::VERSION)
-
-    out, _ = capture_output do
-      begin
-        @options.parse %w[-v]
-      rescue SystemExit
-      end
-    end
-
-    assert out.include?(RDoc::VERSION)
-  end
-
-  def test_visibility
-    @options.visibility = :all
-    assert_equal :private, @options.visibility
-  end
-
-  def test_load_options
-    temp_dir do
-      options = RDoc::Options.new
-      options.markup = 'tomdoc'
-      options.write_options
-
-      options = RDoc::Options.load_options
-
-      assert_equal 'tomdoc', options.markup
-    end
-  end
-
-  def test_load_options_invalid
-    temp_dir do
-      File.open '.rdoc_options', 'w' do |io|
-        io.write "a: !ruby.yaml.org,2002:str |\nfoo"
-      end
-
-      e = assert_raise RDoc::Error do
-        RDoc::Options.load_options
-      end
-
-      options_file = File.expand_path '.rdoc_options'
-      assert_equal "#{options_file} is not a valid rdoc options file", e.message
-    end
-  end
-
-  def test_load_options_empty_file
-    temp_dir do
-      File.open '.rdoc_options', 'w' do |io|
-      end
-
-      options = RDoc::Options.load_options
-
-      assert_equal 'rdoc', options.markup
-    end
-  end
-
-  def test_load_options_partial_override
-    temp_dir do
-      File.open '.rdoc_options', 'w' do |io|
-        io.puts "markup: Markdown"
-        io.puts "encoding: iso-8859-1"
-        io.puts "static_path: [static]"
-        io.puts "rdoc_include: [.]"
-        io.puts "page_dir: pages"
-      end
-
-      options = RDoc::Options.load_options
-
-      assert_equal 'Markdown', options.markup
-      assert_equal Encoding::ISO_8859_1, options.encoding
-      assert_equal ["static"], options.static_path
-      assert_equal ["."], options.rdoc_include
-      assert_equal "pages", options.page_dir
-    end
-  end
-
-  def test_load_options_no_file
-    temp_dir do
-      options = RDoc::Options.load_options
-
-      assert_kind_of RDoc::Options, options
-    end
-  end
-
-  def test_skip_test_default_value
-    @options.parse %w[]
-    assert_equal true, @options.skip_tests
-  end
-
-  def test_no_skip_test_value
-    @options.parse %w[--no-skipping-tests]
-    assert_equal false, @options.skip_tests
-  end
-
-  def test_apply_default_exclude_option
-    @options.parse %w[]
-    exclude = @options.exclude
-    assert_kind_of Regexp, exclude
-    assert_match exclude, "foo~"
-    assert_match exclude, "foo.orig"
-    assert_match exclude, "foo.rej"
-    assert_match exclude, "foo.bak"
-    assert_match exclude, "foo.gemspec"
-  end
-
-  def test_no_apply_default_exclude_option
-    @options.parse %w[--no-apply-default-exclude]
-    assert_nil @options.exclude
-  end
-
-  def test_exclude_option_without_default
-    @options.parse %w[--no-apply-default-exclude --exclude=\.old\z]
-    exclude = @options.exclude
-    assert_match exclude, "foo.old"
-    assert_not_match exclude, "foo~"
-  end
-
-  class DummyCoder < Hash
-    alias add :[]=
-    def tag=(tag)
-    end
-  end
-end
diff --git a/test/mri/rdoc/rdoc/rdoc_parser_c_test.rb b/test/mri/rdoc/rdoc/rdoc_parser_c_test.rb
deleted file mode 100644
index 504e2f8b2ea..00000000000
--- a/test/mri/rdoc/rdoc/rdoc_parser_c_test.rb
+++ /dev/null
@@ -1,2150 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-=begin
-  TODO: test call-seq parsing
-
-/*
- *  call-seq:
- *     ARGF.readlines(sep=$/)     -> array
- *     ARGF.readlines(limit)      -> array
- *     ARGF.readlines(sep, limit) -> array
- *
- *     ARGF.to_a(sep=$/)     -> array
- *     ARGF.to_a(limit)      -> array
- *     ARGF.to_a(sep, limit) -> array
- *
- *  Reads +ARGF+'s current file in its entirety, returning an +Array+ of its
- *  lines, one line per element. Lines are assumed to be separated by _sep_.
- *
- *     lines = ARGF.readlines
- *     lines[0]                #=> "This is line one\n"
- */
-
-assert call-seq did not stop at first empty line
-
-/*
- * call-seq:
- *
- *  flt ** other  ->  float
- *
- * Raises <code>float</code> the <code>other</code> power.
- *
- *    2.0**3      #=> 8.0
- */
-
-assert call-seq correct (bug: was empty)
-
-/* call-seq: flt ** other  ->  float */
-
-assert call-seq correct
-
-=end
-
-class RDocParserCTest < RDoc::TestCase
-
-  def setup
-    super
-
-    @tempfile = Tempfile.new self.class.name
-    filename = @tempfile.path
-
-    @top_level = @store.add_file filename
-    @fn = filename
-    @options = RDoc::Options.new
-    @options.verbosity = 2
-    @stats = RDoc::Stats.new @store, 0
-  end
-
-  def teardown
-    super
-
-    @tempfile.close!
-  end
-
-  def test_class_can_parse
-    c_parser = RDoc::Parser::C
-
-    temp_dir do
-      FileUtils.touch 'file.C'
-      assert_equal c_parser, c_parser.can_parse('file.C')
-
-      FileUtils.touch 'file.CC'
-      assert_equal c_parser, c_parser.can_parse('file.CC')
-
-      FileUtils.touch 'file.H'
-      assert_equal c_parser, c_parser.can_parse('file.H')
-
-      FileUtils.touch 'file.HH'
-      assert_equal c_parser, c_parser.can_parse('file.HH')
-
-      FileUtils.touch 'file.c'
-      assert_equal c_parser, c_parser.can_parse('file.c')
-
-      FileUtils.touch 'file.cc'
-      assert_equal c_parser, c_parser.can_parse('file.cc')
-
-      FileUtils.touch 'file.cpp'
-      assert_equal c_parser, c_parser.can_parse('file.cpp')
-
-      FileUtils.touch 'file.cxx'
-      assert_equal c_parser, c_parser.can_parse('file.cxx')
-
-      FileUtils.touch 'file.h'
-      assert_equal c_parser, c_parser.can_parse('file.h')
-
-      FileUtils.touch 'file.hh'
-      assert_equal c_parser, c_parser.can_parse('file.hh')
-
-      FileUtils.touch 'file.y'
-      assert_equal c_parser, c_parser.can_parse('file.y')
-    end
-  end
-
-  def test_known_classes
-    RDoc::KNOWN_CLASSES.each do |var, name|
-      case name
-      when "Refinement"
-        next unless defined?(Refinement)
-      when "RubyVM"
-        next unless defined?(RubyVM)
-      when "Bignum", "Fixnum", "Data", "Socket", /\A(?![A-Z])/
-        next
-      end
-      obj = Object.const_get(name)
-      assert_equal obj.name, name
-      case var
-      when /\Arb_c/
-        assert_kind_of Class, obj
-      when /\Arb_m/
-        assert_kind_of Module, obj
-      when /\Arb_e/
-        assert_operator obj, :<=, Exception
-      else
-        raise "unknown prefix: #{var} => #{name}"
-      end
-    end
-  end
-
-  def test_initialize
-    some_ext        = @top_level.add_class RDoc::NormalClass, 'SomeExt'
-                      @top_level.add_class RDoc::SingleClass, 'SomeExtSingle'
-
-    @store.cache[:c_class_variables] = {
-      @fn => { 'cSomeExt' => 'SomeExt' }
-    }
-
-    @store.cache[:c_singleton_class_variables] = {
-      @fn => { 'cSomeExtSingle' => 'SomeExtSingle' }
-    }
-
-    parser = RDoc::Parser::C.new @top_level, '', @options, @stats
-
-    expected = { 'cSomeExt' => some_ext }
-    assert_equal expected, parser.classes
-
-    expected = { 'cSomeExtSingle' => 'SomeExtSingle' }
-    assert_equal expected, parser.singleton_classes
-
-    expected = {
-      'cSomeExt'       => 'SomeExt',
-      'cSomeExtSingle' => 'SomeExtSingle',
-    }
-    known_classes = parser.known_classes.delete_if do |key, _|
-      RDoc::KNOWN_CLASSES.keys.include? key
-    end
-
-    assert_equal expected, known_classes
-  end
-
-  def assert_do_attr(flags)
-    content = <<-EOF
-void Init_Blah(void) {
-  cBlah = rb_define_class("Blah", rb_cObject);
-
-  /*
-   * This is an accessor
-   */
-  #{yield "cBlah", "accessor", flags[1], flags[1]};
-
-  /*
-   * This is a reader
-   */
-  #{yield "cBlah", "reader", flags[1], flags[0]};
-
-  /*
-   * This is a writer
-   */
-  #{yield "cBlah", "writer", flags[0], flags[1]};
-}
-    EOF
-
-    klass = util_get_class content, 'cBlah'
-
-    attrs = klass.attributes
-    assert_equal 3, attrs.length, attrs.inspect
-
-    accessor = attrs.shift
-    assert_equal 'accessor',            accessor.name
-    assert_equal 'RW',                  accessor.rw
-    assert_equal 'This is an accessor', accessor.comment.text
-    assert_equal @top_level,            accessor.file
-
-    reader = attrs.shift
-    assert_equal 'reader',           reader.name
-    assert_equal 'R',                reader.rw
-    assert_equal 'This is a reader', reader.comment.text
-
-    writer = attrs.shift
-    assert_equal 'writer',           writer.name
-    assert_equal 'W',                writer.rw
-    assert_equal 'This is a writer', writer.comment.text
-  end
-
-  {
-    num: %w[0 1],
-    macro: %w[FALSE TRUE],
-    ruby: %w[Qfalse Qtrue],
-    bool: %w[false true],
-  }.each_pair do |name, values|
-    define_method("test_do_attr:rb_attr:intern:#{name}") do
-      assert_do_attr(values) {|c, name, r, w| %[rb_attr(#{c}, rb_intern("#{name}"), #{r}, #{w}, Qfalse)]}
-    end
-    define_method("test_do_attr:rb_attr:intern_const:#{name}") do
-      assert_do_attr(values) {|c, name, r, w| %[rb_attr(#{c}, rb_intern_const("#{name}"), #{r}, #{w}, Qfalse)]}
-    end
-    define_method("test_do_attr:rb_define_attr:#{name}") do
-      assert_do_attr(values) {|c, name, r, w| %[rb_define_attr(#{c}, "#{name}", #{r}, #{w})]}
-    end
-  end
-
-  def test_do_aliases
-    content = <<-EOF
-/*
- * This should show up as an alias with documentation
- */
-VALUE blah(VALUE klass, VALUE year) {
-}
-
-void Init_Blah(void) {
-  cDate = rb_define_class("Date", rb_cObject);
-
-  rb_define_method(cDate, "blah", blah, 1);
-
-  rb_define_alias(cDate, "bleh", "blah");
-}
-    EOF
-
-    klass = util_get_class content, 'cDate'
-
-    methods = klass.method_list
-    assert_equal 2,      methods.length
-    assert_equal 'bleh', methods.last.name
-    assert_equal 'blah', methods.last.is_alias_for.name
-
-    assert_equal @top_level, methods.last.is_alias_for.file
-    assert_equal @top_level, methods.last.file
-  end
-
-  def test_do_aliases_singleton
-    content = <<-EOF
-/*
- * This should show up as a method with documentation
- */
-VALUE blah(VALUE klass, VALUE year) {
-}
-
-void Init_Blah(void) {
-  cDate = rb_define_class("Date", rb_cObject);
-  sDate = rb_singleton_class(cDate);
-
-  rb_define_method(sDate, "blah", blah, 1);
-
-  /*
-   * This should show up as an alias
-   */
-  rb_define_alias(sDate, "bleh", "blah");
-}
-    EOF
-
-    klass = util_get_class content, 'cDate'
-
-    methods = klass.method_list
-
-    assert_equal 2,      methods.length
-    assert_equal 'bleh', methods.last.name
-    assert               methods.last.singleton
-    assert_equal 'blah', methods.last.is_alias_for.name
-    assert_equal 'This should show up as an alias', methods.last.comment.text
-  end
-
-  def test_do_aliases_missing_class
-    content = <<-EOF
-void Init_Blah(void) {
-  rb_define_alias(cDate, "b", "a");
-}
-    EOF
-
-    _, err = verbose_capture_output do
-      refute util_get_class(content, 'cDate')
-    end
-
-    assert_equal "Enclosing class or module \"cDate\" for alias b a is not known\n",
-                 err
-  end
-
-  def test_do_classes_class
-    content = <<-EOF
-/* Document-class: Foo
- * this is the Foo class
- */
-VALUE cFoo = rb_define_class("Foo", rb_cObject);
-    EOF
-
-    klass = util_get_class content, 'cFoo'
-    assert_equal "this is the Foo class", klass.comment.text
-  end
-
-  def test_do_classes_duplicate_class
-    content = <<-EOF
-/* Document-class: Foo
- * first
- */
-VALUE cFoo = rb_define_class("Foo", rb_cObject);
-/* Document-class: Foo
- * second
- */
-VALUE cFoo = rb_define_class("Foo", rb_cObject);
-    EOF
-
-    klass = util_get_class content, 'cFoo'
-    assert_equal 1, klass.comment_location.size
-    first = klass.comment_location.first
-    first_comment = first[0]
-    assert_equal 'first', first_comment.text
-  end
-
-  def test_do_classes_struct
-    content = <<-EOF
-/* Document-class: Foo
- * this is the Foo class
- */
-VALUE cFoo = rb_struct_define(
-        "Foo",
-        "some", "various", "fields", NULL);
-    EOF
-
-    klass = util_get_class content, 'cFoo'
-    assert_equal "this is the Foo class", klass.comment.text
-
-    attributes = klass.attributes
-    assert_equal 3, attributes.size, -> {attributes}
-    ["some", "various", "fields"].zip(attributes) do |name, attr|
-      assert_equal RDoc::Attr.new("", name, "RW", ""), attr
-    end
-  end
-
-  def test_do_classes_struct_under
-    content = <<-EOF
-/* Document-class: Kernel::Foo
- * this is the Foo class under Kernel
- */
-VALUE cFoo = rb_struct_define_under(
-        rb_mKernel, "Foo",
-        "some", "various", "fields", NULL);
-    EOF
-
-    klass = util_get_class content, 'cFoo'
-    assert_equal 'Kernel::Foo', klass.full_name
-    assert_equal "this is the Foo class under Kernel", klass.comment.text
-
-    attributes = klass.attributes
-    assert_equal 3, attributes.size, -> {attributes}
-    ["some", "various", "fields"].zip(attributes) do |name, attr|
-      assert_equal RDoc::Attr.new("", name, "RW", ""), attr
-    end
-  end
-
-  def test_do_classes_struct_without_accessor
-    content = <<-EOF
-/* Document-class: Foo
- * this is the Foo class
- */
-VALUE cFoo = rb_struct_define_without_accessor(
-        "Foo", rb_cObject, foo_alloc,
-        "some", "various", "fields", NULL);
-    EOF
-
-    klass = util_get_class content, 'cFoo'
-    assert_equal "this is the Foo class", klass.comment.text
-    assert_empty klass.attributes
-  end
-
-  def test_do_classes_struct_without_accessor_under
-    content = <<-EOF
-/* Document-class: Kernel::Foo
- * this is the Foo class under Kernel
- */
-VALUE cFoo = rb_struct_define_without_accessor_under(
-        rb_mKernel, "Foo", rb_cObject, foo_alloc,
-        "some", "various", "fields", NULL);
-    EOF
-
-    klass = util_get_class content, 'cFoo'
-    assert_equal 'Kernel::Foo', klass.full_name
-    assert_equal "this is the Foo class under Kernel", klass.comment.text
-    assert_empty klass.attributes
-  end
-
-  def test_do_classes_class_under
-    content = <<-EOF
-/* Document-class: Kernel::Foo
- * this is the Foo class under Kernel
- */
-VALUE cFoo = rb_define_class_under(rb_mKernel, "Foo", rb_cObject);
-    EOF
-
-    klass = util_get_class content, 'cFoo'
-    assert_equal 'Kernel::Foo', klass.full_name
-    assert_equal "this is the Foo class under Kernel", klass.comment.text
-  end
-
-  def test_do_classes_class_under_rb_path2class
-    content = <<-EOF
-/* Document-class: Kernel::Foo
- * this is Kernel::Foo < A::B
- */
-VALUE cFoo = rb_define_class_under(rb_mKernel, "Foo", rb_path2class("A::B"));
-    EOF
-
-    klass = util_get_class content, 'cFoo'
-
-    assert_equal 'Kernel::Foo', klass.full_name
-    assert_equal 'A::B', klass.superclass
-    assert_equal 'this is Kernel::Foo < A::B', klass.comment.text
-  end
-
-  def test_do_classes_singleton
-    content = <<-EOF
-VALUE cFoo = rb_define_class("Foo", rb_cObject);
-VALUE cFooS = rb_singleton_class(cFoo);
-    EOF
-
-    util_get_class content, 'cFooS'
-
-    assert_equal 'Foo', @parser.singleton_classes['cFooS']
-  end
-
-  def test_do_classes_module
-    content = <<-EOF
-/* Document-module: Foo
- * this is the Foo module
- */
-VALUE mFoo = rb_define_module("Foo");
-    EOF
-
-    klass = util_get_class content, 'mFoo'
-    assert_equal "this is the Foo module", klass.comment.text
-  end
-
-  def test_do_classes_module_under
-    content = <<-EOF
-/* Document-module: Kernel::Foo
- * this is the Foo module under Kernel
- */
-VALUE mFoo = rb_define_module_under(rb_mKernel, "Foo");
-    EOF
-
-    klass = util_get_class content, 'mFoo'
-    assert_equal "this is the Foo module under Kernel", klass.comment.text
-  end
-
-  def test_do_constants
-    content = <<-'EOF'
-#include <ruby.h>
-
-void Init_foo(){
-   VALUE cFoo = rb_define_class("Foo", rb_cObject);
-
-   /* 300: The highest possible score in bowling */
-   rb_define_const(cFoo, "PERFECT", INT2FIX(300));
-
-   /* Huzzah!: What you cheer when you roll a perfect game */
-   rb_define_const(cFoo, "CHEER", rb_str_new2("Huzzah!"));
-
-   /* TEST\:TEST: Checking to see if escaped colon works */
-   rb_define_const(cFoo, "TEST", rb_str_new2("TEST:TEST"));
-
-   /* TEST: TEST:Checking to see if only word-ending colon works */
-   rb_define_const(cFoo, "TEST2", rb_str_new2("TEST:TEST"));
-
-   /* \\: The file separator on MS Windows */
-   rb_define_const(cFoo, "MSEPARATOR", rb_str_new2("\\"));
-
-   /* /: The file separator on Unix */
-   rb_define_const(cFoo, "SEPARATOR", rb_str_new2("/"));
-
-   /* C:\\Program Files\\Stuff: A directory on MS Windows */
-   rb_define_const(cFoo, "STUFF", rb_str_new2("C:\\Program Files\\Stuff"));
-
-   /* Default definition */
-   rb_define_const(cFoo, "NOSEMI", INT2FIX(99));
-
-   rb_define_const(cFoo, "NOCOMMENT", rb_str_new2("No comment"));
-
-   /*
-    * Multiline comment goes here because this comment spans multiple lines.
-    * Multiline comment goes here because this comment spans multiple lines.
-    */
-   rb_define_const(cFoo, "MULTILINE", INT2FIX(1));
-
-   /*
-    * 1: Multiline comment goes here because this comment spans multiple lines.
-    * Multiline comment goes here because this comment spans multiple lines.
-    */
-   rb_define_const(cFoo, "MULTILINE_VALUE", INT2FIX(1));
-
-   /* Multiline comment goes here because this comment spans multiple lines.
-    * Multiline comment goes here because this comment spans multiple lines.
-    */
-   rb_define_const(cFoo, "MULTILINE_NOT_EMPTY", INT2FIX(1));
-
-   /*
-    * Multiline comment goes here because this comment spans multiple lines.
-    * 1: However, the value extraction should only happen for the first line
-    */
-   rb_define_const(cFoo, "MULTILINE_COLON_ON_SECOND_LINE", INT2FIX(1));
-
-}
-    EOF
-
-    @parser = util_parser content
-
-    @parser.do_classes_and_modules
-    @parser.do_constants
-
-    klass = @parser.classes['cFoo']
-    assert klass
-
-    constants = klass.constants
-    assert !klass.constants.empty?
-
-    assert_equal @top_level, constants.first.file
-
-    constants = constants.map { |c| [c.name, c.value, c.comment.text] }
-
-    assert_equal ['PERFECT', '300', 'The highest possible score in bowling   '],
-                 constants.shift
-    assert_equal ['CHEER', 'Huzzah!',
-                  'What you cheer when you roll a perfect game   '],
-                 constants.shift
-    assert_equal ['TEST', 'TEST:TEST',
-                  'Checking to see if escaped colon works   '],
-                 constants.shift
-    assert_equal ['TEST2', 'TEST',
-                  'TEST:Checking to see if only word-ending colon works   '],
-                 constants.shift
-    assert_equal ['MSEPARATOR', '\\',
-                  'The file separator on MS Windows   '],
-                 constants.shift
-    assert_equal ['SEPARATOR', '/',
-                  'The file separator on Unix   '],
-                 constants.shift
-    assert_equal ['STUFF', 'C:\\Program Files\\Stuff',
-                  'A directory on MS Windows   '],
-                 constants.shift
-    assert_equal ['NOSEMI', 'INT2FIX(99)',
-                  'Default definition   '],
-                 constants.shift
-    assert_equal ['NOCOMMENT', 'rb_str_new2("No comment")', ''],
-                 constants.shift
-
-    comment = <<-EOF.chomp
-Multiline comment goes here because this comment spans multiple lines.
-Multiline comment goes here because this comment spans multiple lines.
-    EOF
-    assert_equal ['MULTILINE',           'INT2FIX(1)', comment], constants.shift
-    assert_equal ['MULTILINE_VALUE',     '1',          comment], constants.shift
-    assert_equal ['MULTILINE_NOT_EMPTY', 'INT2FIX(1)', comment], constants.shift
-
-    comment = <<-EOF.chomp
-Multiline comment goes here because this comment spans multiple lines.
-1: However, the value extraction should only happen for the first line
-    EOF
-    assert_equal ['MULTILINE_COLON_ON_SECOND_LINE', 'INT2FIX(1)', comment],
-                 constants.shift
-
-    assert constants.empty?, constants.inspect
-  end
-
-  def test_do_constants_global
-    content = <<-'EOF'
-#include <ruby.h>
-
-void Init_foo(){
-
-   /* Toplevel const */
-   rb_define_global_const("ANSWER", INT2FIX(42));
-
-}
-    EOF
-
-    @parser = util_parser content
-
-    @parser.do_classes_and_modules
-    @parser.do_constants
-
-    klass = @parser.classes['rb_cObject']
-    assert klass
-
-    constants = klass.constants
-    assert !klass.constants.empty?
-
-    assert_equal @top_level, constants.first.file
-
-    constants = constants.map { |c| [c.name, c.value, c.comment.text] }
-    assert_equal ['ANSWER', 'INT2FIX(42)', "Toplevel const   "],
-                 constants.shift
-
-    assert constants.empty?, constants.inspect
-  end
-
-  def test_do_constants_curses
-    content = <<-EOF
-void Init_curses(){
-  mCurses = rb_define_module("Curses");
-
-  /*
-   * Value of the color black
-   */
-  rb_curses_define_const(COLOR_BLACK);
-}
-    EOF
-
-    @parser = util_parser content
-
-    @parser.do_classes_and_modules
-    @parser.do_constants
-
-    klass = @parser.classes['mCurses']
-
-    constants = klass.constants
-    refute_empty klass.constants
-
-    assert_equal 'COLOR_BLACK', constants.first.name
-    assert_equal 'UINT2NUM(COLOR_BLACK)', constants.first.value
-    assert_equal 'Value of the color black', constants.first.comment.text
-  end
-
-  def test_do_constants_file
-    content = <<-EOF
-void Init_File(void) {
-  /*
-   *  Shared lock
-   */
-  rb_file_const("LOCK_SH", INT2FIX(LOCK_SH));
-}
-    EOF
-
-    @parser = util_parser content
-
-    @parser.do_classes_and_modules
-    @parser.do_constants
-
-    klass = @parser.classes['rb_mFConst']
-
-    constants = klass.constants
-    refute_empty klass.constants
-
-    constant = constants.first
-
-    assert_equal 'LOCK_SH',          constant.name
-    assert_equal 'INT2FIX(LOCK_SH)', constant.value
-    assert_equal 'Shared lock',      constant.comment.text
-
-    @parser = util_parser <<-EOF
-void Init_File(void) {
-  rb_cFile = rb_define_class("File", rb_cIO);
-  rb_mFConst = rb_define_module_under(rb_cFile, "Constants");
-}
-    EOF
-    @parser.do_classes_and_modules
-    @parser.do_constants
-
-    assert_equal 'File::Constants',  klass.full_name
-  end
-
-  def test_do_includes
-    content = <<-EOF
-Init_foo() {
-   VALUE cFoo = rb_define_class("Foo", rb_cObject);
-   VALUE mInc = rb_define_module("Inc");
-
-   rb_include_module(cFoo, mInc);
-}
-    EOF
-
-    klass = util_get_class content, 'cFoo'
-
-    incl = klass.includes.first
-    assert_equal 'Inc',      incl.name
-    assert_equal '',         incl.comment.text
-    assert_equal @top_level, incl.file
-  end
-
-  # HACK parsing warning instead of setting up in file
-  def test_do_methods_in_c
-    content = <<-EOF
-VALUE blah(VALUE klass, VALUE year) {
-}
-
-void Init_Blah(void) {
-  cDate = rb_define_class("Date", rb_cObject);
-
-  rb_define_method(cDate, "blah", blah, 1); /* in blah.c */
-}
-    EOF
-
-    klass = nil
-
-    _, err = verbose_capture_output do
-      klass = util_get_class content, 'cDate'
-    end
-
-    assert_equal 'Date', klass.full_name
-    assert_match ' blah.c ', err
-  end
-
-  # HACK parsing warning instead of setting up in file
-  def test_do_methods_in_cpp
-    content = <<-EOF
-VALUE blah(VALUE klass, VALUE year) {
-}
-
-void Init_Blah(void) {
-  cDate = rb_define_class("Date", rb_cObject);
-
-  rb_define_method(cDate, "blah", blah, 1); /* in blah.cpp */
-}
-    EOF
-
-    klass = nil
-
-    _, err = verbose_capture_output do
-      klass = util_get_class content, 'cDate'
-    end
-
-    assert_equal 'Date', klass.full_name
-    assert_match ' blah.cpp ', err
-  end
-
-  # HACK parsing warning instead of setting up in file
-  def test_do_methods_in_y
-    content = <<-EOF
-VALUE blah(VALUE klass, VALUE year) {
-}
-
-void Init_Blah(void) {
-  cDate = rb_define_class("Date", rb_cObject);
-
-  rb_define_method(cDate, "blah", blah, 1); /* in blah.y */
-}
-    EOF
-
-    klass = nil
-
-    _, err = verbose_capture_output do
-      klass = util_get_class content, 'cDate'
-    end
-
-    assert_equal 'Date', klass.full_name
-    assert_match ' blah.y ', err
-  end
-
-  def test_do_methods_singleton_class
-    content = <<-EOF
-VALUE blah(VALUE klass, VALUE year) {
-}
-
-void Init_Blah(void) {
-  cDate = rb_define_class("Date", rb_cObject);
-  sDate = rb_singleton_class(cDate);
-
-  rb_define_method(sDate, "blah", blah, 1);
-}
-    EOF
-
-    klass = util_get_class content, 'cDate'
-
-    methods = klass.method_list
-    assert_equal 1,      methods.length
-    assert_equal 'blah', methods.first.name
-    assert               methods.first.singleton
-  end
-
-  def test_do_missing
-    parser = util_parser
-
-    klass_a = @top_level.add_class RDoc::ClassModule, 'A'
-    parser.classes['a'] = klass_a
-
-    parser.enclosure_dependencies['c'] << 'b'
-    parser.enclosure_dependencies['b'] << 'a'
-    parser.enclosure_dependencies['d'] << 'a'
-
-    parser.missing_dependencies['d'] = ['d', :class, 'D', 'Object', 'a']
-    parser.missing_dependencies['c'] = ['c', :class, 'C', 'Object', 'b']
-    parser.missing_dependencies['b'] = ['b', :class, 'B', 'Object', 'a']
-
-    parser.do_missing
-
-    assert_equal %w[A A::B A::B::C A::D],
-                 @store.all_classes_and_modules.map { |m| m.full_name }.sort
-  end
-
-  def test_do_missing_cycle
-    parser = util_parser
-
-    klass_a = @top_level.add_class RDoc::ClassModule, 'A'
-    parser.classes['a'] = klass_a
-
-    parser.enclosure_dependencies['c'] << 'b'
-    parser.enclosure_dependencies['b'] << 'a'
-
-    parser.missing_dependencies['c'] = ['c', :class, 'C', 'Object', 'b']
-    parser.missing_dependencies['b'] = ['b', :class, 'B', 'Object', 'a']
-
-    parser.enclosure_dependencies['y'] << 'z'
-    parser.enclosure_dependencies['z'] << 'y'
-
-    parser.missing_dependencies['y'] = ['y', :class, 'Y', 'Object', 'z']
-    parser.missing_dependencies['z'] = ['z', :class, 'Z', 'Object', 'y']
-
-    _, err = verbose_capture_output do
-      parser.do_missing
-    end
-
-    expected = 'Unable to create class Y (y), class Z (z) ' +
-               'due to a cyclic class or module creation'
-
-    assert_equal expected, err.chomp
-
-    assert_equal %w[A A::B A::B::C],
-                 @store.all_classes_and_modules.map { |m| m.full_name }.sort
-  end
-
-  def test_find_alias_comment
-    parser = util_parser
-
-    comment = parser.find_alias_comment 'C', '[]', 'index'
-
-    assert_equal '', comment.text
-
-    parser = util_parser <<-C
-/*
- * comment
- */
-
-rb_define_alias(C, "[]", "index");
-    C
-
-    comment = parser.find_alias_comment 'C', '[]', 'index'
-
-    assert_equal "/*\n * comment\n */\n\n", comment.text
-  end
-
-  def test_find_attr_comment_document_attr
-    parser= util_parser <<-C
-/*
- * Document-attr: y
- * comment
- */
-    C
-
-    comment = parser.find_attr_comment nil, 'y'
-
-    assert_equal "/*\n * \n * comment\n */", comment.text
-  end
-
-  def test_find_attr_comment_document_attr_oneline
-    parser= util_parser <<-C
-/* Document-attr: y
- * comment
- */
-    C
-
-    comment = parser.find_attr_comment nil, 'y'
-
-    assert_equal "/* \n * comment\n */", comment.text
-  end
-
-  def test_find_attr_comment_document_attr_overlap
-    parser= util_parser <<-C
-/* Document-attr: x
- * comment
- */
-
-/* Document-attr: y
- * comment
- */
-    C
-
-    comment = parser.find_attr_comment nil, 'y'
-
-    assert_equal "/* \n * comment\n */", comment.text
-  end
-
-  def test_find_class_comment
-    @options.rdoc_include << File.dirname(__FILE__)
-
-    content = <<-EOF
-/*
- * Comment 1
- */
-foo = rb_define_class("MyClassName1", rb_cObject);
-
-/*
- * Comment 2
- */
-bar = rb_define_class("MyClassName2", rb_cObject);
-    EOF
-
-    util_get_class content
-
-    assert_equal "Comment 1", @parser.classes['foo'].comment.text
-    assert_equal "Comment 2", @parser.classes['bar'].comment.text
-  end
-
-  def test_find_class_comment_init
-    content = <<-EOF
-/*
- * a comment for class Foo
- */
-void
-Init_Foo(void) {
-  VALUE foo = rb_define_class("Foo", rb_cObject);
-}
-    EOF
-
-    klass = util_get_class content, 'foo'
-
-    assert_equal "a comment for class Foo", klass.comment.text
-  end
-
-
-  def test_find_class_comment_initvm
-    content = <<-EOF
-/*
- * a comment for class Foo
- */
-void
-InitVM_Foo(void) {
-  VALUE foo = rb_define_class("Foo", rb_cObject);
-}
-    EOF
-
-    klass = util_get_class content, 'foo'
-
-    assert_equal "a comment for class Foo", klass.comment.text
-  end
-
-  def test_find_class_comment_define_class
-    content = <<-EOF
-/*
- * a comment for class Foo
- */
-VALUE foo = rb_define_class("Foo", rb_cObject);
-    EOF
-
-    klass = util_get_class content, 'foo'
-
-    assert_equal "a comment for class Foo", klass.comment.text
-  end
-
-  def test_find_class_comment_define_class_Init_Foo
-    content = <<-EOF
-/*
- * a comment for class Foo on Init
- */
-void
-Init_Foo(void) {
-    /*
-     * a comment for class Foo on rb_define_class
-     */
-    VALUE foo = rb_define_class("Foo", rb_cObject);
-}
-    EOF
-
-    klass = util_get_class content, 'foo'
-
-    assert_equal "a comment for class Foo on Init", klass.comment.text
-  end
-
-  def test_find_class_comment_define_class_Init_Foo_no_void
-    content = <<-EOF
-/*
- * a comment for class Foo on Init
- */
-void
-Init_Foo() {
-    /*
-     * a comment for class Foo on rb_define_class
-     */
-    VALUE foo = rb_define_class("Foo", rb_cObject);
-}
-    EOF
-
-    klass = util_get_class content, 'foo'
-
-    assert_equal "a comment for class Foo on Init", klass.comment.text
-  end
-
-  def test_find_class_comment_define_class_bogus_comment
-    content = <<-EOF
-/*
- * a comment for other_function
- */
-void
-other_function() {
-}
-
-void
-Init_Foo(void) {
-    VALUE foo = rb_define_class("Foo", rb_cObject);
-}
-    EOF
-
-    klass = util_get_class content, 'foo'
-
-    assert_equal '', klass.comment.text
-  end
-
-  def test_find_class_comment_define_class_under
-    content = <<-EOF
-/*
- * a comment for class Foo
- */
-VALUE foo = rb_define_class_under(rb_cObject, "Foo", rb_cObject);
-    EOF
-
-    klass = util_get_class content, 'foo'
-
-    assert_equal "a comment for class Foo", klass.comment.text
-  end
-
-  def test_find_class_comment_define_class_under_Init
-    content = <<-EOF
-/*
- * a comment for class Foo on Init
- */
-void
-Init_Foo(void) {
-    /*
-     * a comment for class Foo on rb_define_class
-     */
-    VALUE foo = rb_define_class_under(rb_cObject, "Foo", rb_cObject);
-}
-    EOF
-
-    klass = util_get_class content, 'foo'
-
-    # the inner comment is used since Object::Foo is not necessarily the same
-    # thing as "Foo" for Init_
-    assert_equal "a comment for class Foo on rb_define_class",
-                 klass.comment.text
-  end
-
-  def test_find_const_comment_rb_define
-    content = <<-EOF
-/*
- * A comment
- */
-rb_define_const(cFoo, "CONST", value);
-    EOF
-
-    parser = util_parser content
-
-    comment = parser.find_const_comment 'const', 'CONST'
-
-    assert_equal "/*\n * A comment\n */\n", comment.text
-  end
-
-  def test_find_const_comment_rb_define_global
-    content = <<-EOF
-/*
- * A comment
- */
-rb_define_global_const("CONST", value);
-    EOF
-
-    parser = util_parser content
-
-    comment = parser.find_const_comment 'const', 'CONST'
-
-    assert_equal "/*\n * A comment\n */\n", comment.text
-  end
-
-  def test_find_const_comment_document_const
-    content = <<-EOF
-/*
- * Document-const: CONST
- *
- * A comment
- */
-    EOF
-
-    parser = util_parser content
-
-    comment = parser.find_const_comment nil, 'CONST'
-
-    assert_equal "/*\n *\n * A comment\n */", comment.text
-  end
-
-  def test_find_const_comment_document_const_full_name
-    content = <<-EOF
-/*
- * Document-const: Foo::CONST
- *
- * A comment
- */
-    EOF
-
-    parser = util_parser content
-
-    comment = parser.find_const_comment nil, 'CONST', 'Foo'
-
-    assert_equal "/*\n *\n * A comment\n */", comment.text
-  end
-
-  def test_find_body
-    content = <<-EOF
-/*
- * a comment for other_function
- */
-VALUE
-other_function() {
-}
-
-void
-Init_Foo(void) {
-    VALUE foo = rb_define_class("Foo", rb_cObject);
-
-    rb_define_method(foo, "my_method", other_function, 0);
-}
-    EOF
-
-    klass = util_get_class content, 'foo'
-    other_function = klass.method_list.first
-
-    assert_equal 'my_method', other_function.name
-    assert_equal "a comment for other_function",
-                 other_function.comment.text
-    assert_equal '()', other_function.params
-
-    code = other_function.token_stream.first[:text]
-
-    assert_equal "VALUE\nother_function() {\n}", code
-  end
-
-  def test_find_body_2
-    content = <<-CONTENT
-/* Copyright (C) 2010  Sven Herzberg
- *
- * This file is free software; the author(s) gives unlimited
- * permission to copy and/or distribute it, with or without
- * modifications, as long as this notice is preserved.
- */
-
-#include <ruby.h>
-
-static VALUE
-wrap_initialize (VALUE  self)
-{
-  return self;
-}
-
-/* */
-static VALUE
-wrap_shift (VALUE self,
-            VALUE arg)
-{
-  return self;
-}
-
-void
-init_gi_repository (void)
-{
-  VALUE mTest = rb_define_module ("Test");
-  VALUE cTest = rb_define_class_under (mTest, "Test", rb_cObject);
-
-  rb_define_method (cTest, "initialize", wrap_initialize, 0);
-  rb_define_method (cTest, "shift", wrap_shift, 0);
-}
-    CONTENT
-
-    klass = util_get_class content, 'cTest'
-    assert_equal 2, klass.method_list.length
-  end
-
-  def test_find_body_cast
-    content = <<-EOF
-/*
- * a comment for other_function
- */
-VALUE
-other_function() {
-}
-
-void
-Init_Foo(void) {
-    VALUE foo = rb_define_class("Foo", rb_cObject);
-
-    rb_define_method(foo, "my_method", (METHOD)other_function, 0);
-}
-    EOF
-
-    klass = util_get_class content, 'foo'
-    other_function = klass.method_list.first
-
-    assert_equal 'my_method', other_function.name
-    assert_equal "a comment for other_function",
-                 other_function.comment.text
-    assert_equal '()', other_function.params
-
-    code = other_function.token_stream.first[:text]
-
-    assert_equal "VALUE\nother_function() {\n}", code
-  end
-
-  def test_find_body_define
-    content = <<-EOF
-#define something something_else
-
-#define other_function rb_other_function
-
-/*
- * a comment for rb_other_function
- */
-VALUE
-rb_other_function() {
-}
-
-void
-Init_Foo(void) {
-    VALUE foo = rb_define_class("Foo", rb_cObject);
-
-    rb_define_method(foo, "my_method", other_function, 0);
-}
-    EOF
-
-    klass = util_get_class content, 'foo'
-    other_function = klass.method_list.first
-
-    assert_equal 'my_method', other_function.name
-    assert_equal 'a comment for rb_other_function', other_function.comment.text
-    assert_equal '()', other_function.params
-    assert_equal 8, other_function.line
-
-    code = other_function.token_stream.first[:text]
-
-    assert_equal "VALUE\nrb_other_function() {\n}", code
-  end
-
-  def test_find_body_define_comment
-    content = <<-EOF
-/*
- * a comment for other_function
- */
-#define other_function rb_other_function
-
-/* */
-VALUE
-rb_other_function() {
-}
-
-void
-Init_Foo(void) {
-    VALUE foo = rb_define_class("Foo", rb_cObject);
-
-    rb_define_method(foo, "my_method", other_function, 0);
-}
-    EOF
-
-    klass = util_get_class content, 'foo'
-    other_function = klass.method_list.first
-
-    assert_equal 'my_method', other_function.name
-    assert_equal 'a comment for other_function', other_function.comment.text
-    assert_equal '()', other_function.params
-    assert_equal 4, other_function.line
-
-    code = other_function.token_stream.first[:text]
-
-    assert_equal "#define other_function rb_other_function", code
-  end
-
-  def test_find_body_document_method
-    content = <<-EOF
-/*
- * Document-method: bar
- * Document-method: baz
- *
- * a comment for bar
- */
-VALUE
-bar() {
-}
-
-void
-Init_Foo(void) {
-    VALUE foo = rb_define_class("Foo", rb_cObject);
-
-    rb_define_method(foo, "bar", bar, 0);
-    rb_define_method(foo, "baz", bar, 0);
-}
-    EOF
-
-    klass = util_get_class content, 'foo'
-    assert_equal 2, klass.method_list.length
-
-    methods = klass.method_list.sort
-
-    bar = methods.first
-    assert_equal 'Foo#bar', bar.full_name
-    assert_equal "a comment for bar", bar.comment.text
-
-    baz = methods.last
-    assert_equal 'Foo#baz', baz.full_name
-    assert_equal "a comment for bar", baz.comment.text
-  end
-
-  def test_find_body_document_method_equals
-    content = <<-EOF
-/*
- * Document-method: Zlib::GzipFile#mtime=
- *
- * A comment
- */
-static VALUE
-rb_gzfile_set_mtime(VALUE obj, VALUE mtime)
-{
-
-void
-Init_zlib() {
-    mZlib = rb_define_module("Zlib");
-    cGzipFile = rb_define_class_under(mZlib, "GzipFile", rb_cObject);
-    cGzipWriter = rb_define_class_under(mZlib, "GzipWriter", cGzipFile);
-    rb_define_method(cGzipWriter, "mtime=", rb_gzfile_set_mtime, 1);
-}
-    EOF
-
-    klass = util_get_class content, 'cGzipWriter'
-    assert_equal 1, klass.method_list.length
-
-    methods = klass.method_list.sort
-
-    bar = methods.first
-    assert_equal 'Zlib::GzipWriter#mtime=', bar.full_name
-    assert_equal 'A comment', bar.comment.text
-  end
-
-  def test_find_body_document_method_same
-    content = <<-EOF
-VALUE
-s_bar() {
-}
-
-VALUE
-bar() {
-}
-
-/*
- * Document-method: Foo::bar
- *
- * a comment for Foo::bar
- */
-
-/*
- * Document-method: Foo#bar
- *
- * a comment for Foo#bar
- */
-
-void
-Init_Foo(void) {
-    VALUE foo = rb_define_class("Foo", rb_cObject);
-
-    rb_define_singleton_method(foo, "bar", s_bar, 0);
-    rb_define_method(foo, "bar", bar, 0);
-}
-    EOF
-
-    klass = util_get_class content, 'foo'
-    assert_equal 2, klass.method_list.length
-
-    methods = klass.method_list.sort
-
-    s_bar = methods.first
-    assert_equal 'Foo::bar', s_bar.full_name
-    assert_equal "a comment for Foo::bar", s_bar.comment.text
-
-    bar = methods.last
-    assert_equal 'Foo#bar', bar.full_name
-    assert_equal "a comment for Foo#bar", bar.comment.text
-  end
-
-  def test_find_body_macro
-    content = <<-EOF
-/*
- * a comment for other_function
- */
-DLL_LOCAL VALUE
-other_function() {
-}
-
-void
-Init_Foo(void) {
-    VALUE foo = rb_define_class("Foo", rb_cObject);
-
-    rb_define_method(foo, "my_method", other_function, 0);
-}
-    EOF
-
-    klass = util_get_class content, 'foo'
-    other_function = klass.method_list.first
-
-    assert_equal 'my_method', other_function.name
-    assert_equal "a comment for other_function",
-                 other_function.comment.text
-    assert_equal '()', other_function.params
-
-    code = other_function.token_stream.first[:text]
-
-    assert_equal "DLL_LOCAL VALUE\nother_function() {\n}", code
-  end
-
-  def test_find_body_static_inline
-    content = <<-EOF
-/*
- * a comment for other_function
- */
-static inline VALUE
-other_function() {
-}
-
-void
-Init_Foo(void) {
-    VALUE foo = rb_define_class("Foo", rb_cObject);
-
-    rb_define_method(foo, "my_method", other_function, 0);
-}
-    EOF
-
-    klass = util_get_class content, 'foo'
-    other_function = klass.method_list.first
-
-    assert_equal 'my_method', other_function.name
-    assert_equal "a comment for other_function",
-                 other_function.comment.text
-    assert_equal '()', other_function.params
-
-    code = other_function.token_stream.first[:text]
-
-    assert_equal "static inline VALUE\nother_function() {\n}", code
-  end
-
-  def test_find_modifiers_call_seq
-    comment = RDoc::Comment.new <<-COMMENT
-call-seq:
-  commercial() -> Date <br />
-
-If no arguments are given:
-
-    COMMENT
-
-    parser = util_parser
-    method_obj = RDoc::AnyMethod.new nil, 'blah'
-
-    parser.find_modifiers comment, method_obj
-
-    expected = <<-CALL_SEQ.chomp
-commercial() -> Date <br />
-
-    CALL_SEQ
-
-    assert_equal expected, method_obj.call_seq
-  end
-
-  def test_find_modifiers_nodoc
-    comment = RDoc::Comment.new <<-COMMENT
-/* :nodoc:
- *
- * Blah
- */
-
-    COMMENT
-
-    parser = util_parser
-    method_obj = RDoc::AnyMethod.new nil, 'blah'
-
-    parser.find_modifiers comment, method_obj
-
-    assert_nil method_obj.document_self
-  end
-
-  def test_find_modifiers_yields
-    comment = RDoc::Comment.new <<-COMMENT, @top_level, :c
-/* :yields: a, b
- *
- * Blah
- */
-
-    COMMENT
-
-    parser = util_parser
-    method_obj = RDoc::AnyMethod.new nil, 'blah'
-
-    parser.find_modifiers comment, method_obj
-
-    assert_equal 'a, b', method_obj.block_params
-
-    assert_equal "\n\nBlah", comment.text
-  end
-
-  def test_handle_method_args_minus_1
-    parser = util_parser "Document-method: Object#m\n blah */"
-
-    parser.content = <<-BODY
-VALUE
-rb_other(VALUE obj) {
-  rb_funcall(obj, rb_intern("other"), 0);
-  return rb_str_new2("blah, blah, blah");
-}
-
-VALUE
-rb_m(int argc, VALUE *argv, VALUE obj) {
-  VALUE o1, o2;
-  rb_scan_args(argc, argv, "1", &o1, &o2);
-}
-    BODY
-
-    parser.handle_method 'method', 'rb_cObject', 'm', 'rb_m', -1
-
-    m = @top_level.find_module_named('Object').method_list.first
-
-    assert_equal 'm', m.name
-    assert_equal @top_level, m.file
-    assert_equal 7, m.line
-
-    assert_equal '(p1)', m.params
-  end
-
-  def test_handle_method_args_0
-    parser = util_parser "Document-method: BasicObject#==\n blah */"
-
-    parser.handle_method 'method', 'rb_cBasicObject', '==', 'rb_obj_equal', 0
-
-    bo = @top_level.find_module_named 'BasicObject'
-
-    assert_equal 1, bo.method_list.length
-
-    equals2 = bo.method_list.first
-
-    assert_equal '()', equals2.params
-  end
-
-  def test_handle_method_args_1
-    parser = util_parser "Document-method: BasicObject#==\n blah */"
-
-    parser.handle_method 'method', 'rb_cBasicObject', '==', 'rb_obj_equal', 1
-
-    bo = @top_level.find_module_named 'BasicObject'
-
-    assert_equal 1, bo.method_list.length
-
-    equals2 = bo.method_list.first
-
-    assert_equal '(p1)', equals2.params
-  end
-
-  def test_handle_method_args_2
-    parser = util_parser "Document-method: BasicObject#==\n blah */"
-
-    parser.handle_method 'method', 'rb_cBasicObject', '==', 'rb_obj_equal', 2
-
-    bo = @top_level.find_module_named 'BasicObject'
-
-    assert_equal 1, bo.method_list.length
-
-    equals2 = bo.method_list.first
-
-    assert_equal '(p1, p2)', equals2.params
-  end
-
-  # test_handle_args_minus_1 handled by test_handle_method
-
-  def test_handle_method_args_minus_2
-    parser = util_parser "Document-method: BasicObject#==\n blah */"
-
-    parser.handle_method 'method', 'rb_cBasicObject', '==', 'rb_obj_equal', -2
-
-    bo = @top_level.find_module_named 'BasicObject'
-
-    assert_equal 1, bo.method_list.length
-
-    equals2 = bo.method_list.first
-
-    assert_equal '(*args)', equals2.params
-  end
-
-  def test_handle_method_initialize
-    parser = util_parser "Document-method: BasicObject::new\n blah */"
-
-    parser.handle_method('private_method', 'rb_cBasicObject',
-                         'initialize', 'rb_obj_dummy', -1)
-
-    bo = @top_level.find_module_named 'BasicObject'
-
-    assert_equal 1, bo.method_list.length
-
-    new = bo.method_list.first
-
-    assert_equal 'new',   new.name
-    assert_equal :public, new.visibility
-  end
-
-  def test_handle_singleton
-    parser = util_parser <<-SINGLE
-void Init_Blah(void) {
-  cDate = rb_define_class("Date", rb_cObject);
-  sDate = rb_singleton_class(cDate);
-}
-    SINGLE
-
-    parser.scan
-
-    assert_equal 'Date', parser.known_classes['sDate']
-    assert_equal 'Date', parser.singleton_classes['sDate']
-  end
-
-  def test_look_for_directives_in
-    parser = util_parser
-
-    comment = RDoc::Comment.new "# :other: not_handled\n"
-
-    parser.look_for_directives_in @top_level, comment
-
-    assert_equal "# :other: not_handled\n", comment.text
-    assert_equal 'not_handled', @top_level.metadata['other']
-  end
-
-  def test_load_variable_map
-    some_ext = @top_level.add_class RDoc::NormalClass, 'SomeExt'
-               @top_level.add_class RDoc::NormalClass, 'OtherExt'
-
-    @store.cache[:c_class_variables][@fn]       = { 'cSomeExt'  => 'SomeExt'  }
-    @store.cache[:c_class_variables]['other.c'] = { 'cOtherExt' => 'OtherExt' }
-
-    parser = util_parser
-
-    map = parser.load_variable_map :c_class_variables
-
-    expected = { 'cSomeExt' => some_ext }
-
-    assert_equal expected, map
-
-    assert_equal 'SomeExt', parser.known_classes['cSomeExt']
-    assert_nil              parser.known_classes['cOtherExt']
-  end
-
-  def test_load_variable_map_empty
-    parser = util_parser
-
-    map = parser.load_variable_map :c_class_variables
-
-    assert_empty map
-  end
-
-  def test_load_variable_map_legacy
-    @store.cache[:c_class_variables] = nil
-
-    parser = util_parser
-
-    map = parser.load_variable_map :c_class_variables
-
-    assert_empty map
-  end
-
-  def test_load_variable_map_singleton
-    @top_level.add_class RDoc::NormalClass, 'SomeExt'
-    @top_level.add_class RDoc::NormalClass, 'OtherExt'
-
-    @store.cache[:c_singleton_class_variables][@fn] =
-      { 'cSomeExt'  => 'SomeExt'  }
-    @store.cache[:c_singleton_class_variables]['other.c'] =
-      { 'cOtherExt' => 'OtherExt' }
-
-    parser = util_parser
-
-    map = parser.load_variable_map :c_singleton_class_variables
-
-    expected = { 'cSomeExt' => 'SomeExt' }
-
-    assert_equal expected, map
-
-    assert_equal 'SomeExt', parser.known_classes['cSomeExt']
-    assert_nil              parser.known_classes['cOtherExt']
-  end
-
-  def test_load_variable_map_trim
-    a = @top_level.add_class RDoc::NormalClass, 'A'
-
-    @store.cache[:c_class_variables][@fn] = {
-      'cA'  => 'A',
-      'cB'  => 'B',
-    }
-
-    parser = util_parser
-
-    map = parser.load_variable_map :c_class_variables
-
-    expected = { 'cA' => a }
-
-    assert_equal expected, map
-  end
-
-  def test_define_method
-    content = <<-EOF
-/*Method Comment! */
-static VALUE
-rb_io_s_read(argc, argv, io)
-    int argc;
-    VALUE *argv;
-    VALUE io;
-{
-}
-
-void
-Init_IO(void) {
-    /*
-     * a comment for class Foo on rb_define_class
-     */
-    VALUE rb_cIO = rb_define_class("IO", rb_cObject);
-    rb_define_singleton_method(rb_cIO, "read", rb_io_s_read, -1);
-}
-    EOF
-
-    klass = util_get_class content, 'rb_cIO'
-    read_method = klass.method_list.first
-    assert_equal "read", read_method.name
-    assert_equal "Method Comment!   ", read_method.comment.text
-    assert_equal "rb_io_s_read", read_method.c_function
-    assert read_method.singleton
-    assert_nil read_method.section.title
-  end
-
-  def test_define_method_with_category
-    content = <<-EOF
-/* :category: Awesome Methods
-   Method Comment!
- */
-static VALUE
-rb_io_s_read(argc, argv, io)
-    int argc;
-    VALUE *argv;
-    VALUE io;
-{
-}
-
-void
-Init_IO(void) {
-    /*
-     * a comment for class Foo on rb_define_class
-     */
-    VALUE rb_cIO = rb_define_class("IO", rb_cObject);
-    rb_define_singleton_method(rb_cIO, "read", rb_io_s_read, -1);
-}
-    EOF
-
-    klass = util_get_class content, 'rb_cIO'
-    read_method = klass.method_list.first
-    assert_equal "read", read_method.name
-    assert_equal "Method Comment!", read_method.comment.text.strip
-    assert_equal "rb_io_s_read", read_method.c_function
-    assert read_method.singleton
-    assert_equal "Awesome Methods", read_method.section.title
-  end
-
-  def test_define_method_dynamically
-    content = <<-EOF
-void
-Init_foo(void)
-{
-    rb_define_singleton_method(obj, "foo", foo, -1);
-}
-    EOF
-
-    klass = util_get_class content, 'obj'
-    assert_nil klass
-  end
-
-  def test_define_method_with_prototype
-    content = <<-EOF
-static VALUE rb_io_s_read(int, VALUE*, VALUE);
-
-/* Method Comment! */
-static VALUE
-rb_io_s_read(argc, argv, io)
-    int argc;
-    VALUE *argv;
-    VALUE io;
-{
-}
-
-void
-Init_IO(void) {
-    /*
-     * a comment for class Foo on rb_define_class
-     */
-    VALUE rb_cIO = rb_define_class("IO", rb_cObject);
-    rb_define_singleton_method(rb_cIO, "read", rb_io_s_read, -1);
-}
-    EOF
-
-    klass = util_get_class content, 'rb_cIO'
-    read_method = klass.method_list.first
-    assert_equal "read", read_method.name
-    assert_equal "Method Comment!   ", read_method.comment.text
-    assert_equal "rb_io_s_read", read_method.c_function
-    assert read_method.singleton
-  end
-
-  def test_define_method_private
-    content = <<-EOF
-/*Method Comment! */
-static VALUE
-rb_io_s_read(argc, argv, io)
-    int argc;
-    VALUE *argv;
-    VALUE io;
-{
-}
-
-void
-Init_IO(void) {
-    /*
-     * a comment for class Foo on rb_define_class
-     */
-    VALUE rb_cIO = rb_define_class("IO", rb_cObject);
-    rb_define_private_method(rb_cIO, "read", rb_io_s_read, -1);
-}
-    EOF
-
-    klass = util_get_class content, 'rb_cIO'
-    read_method = klass.method_list.first
-    assert_equal 'IO#read', read_method.full_name
-    assert_equal :private, read_method.visibility
-    assert_equal "Method Comment!   ", read_method.comment.text
-  end
-
-  def test_define_method_private_singleton
-    content = <<-EOF
-/*Method Comment! */
-static VALUE
-rb_io_s_read(argc, argv, io)
-    int argc;
-    VALUE *argv;
-    VALUE io;
-{
-}
-
-void
-Init_IO(void) {
-    /*
-     * a comment for class Foo on rb_define_class
-     */
-    VALUE rb_cIO = rb_define_class("IO", rb_cObject);
-    VALUE rb_cIO_s = rb_singleton_class(rb_cIO);
-    rb_define_private_method(rb_cIO_s, "read", rb_io_s_read, -1);
-}
-    EOF
-
-    klass = util_get_class content, 'rb_cIO'
-    read_method = klass.method_list.first
-    assert_equal "read", read_method.name
-    assert_equal "Method Comment!   ", read_method.comment.text
-    assert_equal :private, read_method.visibility
-    assert read_method.singleton
-  end
-
-  def test_define_method_singleton
-    content = <<-EOF
-/*Method Comment! */
-static VALUE
-rb_io_s_read(argc, argv, io)
-    int argc;
-    VALUE *argv;
-    VALUE io;
-{
-}
-
-void
-Init_IO(void) {
-    /*
-     * a comment for class Foo on rb_define_class
-     */
-    VALUE rb_cIO = rb_define_class("IO", rb_cObject);
-    VALUE rb_cIO_s = rb_singleton_class(rb_cIO);
-    rb_define_method(rb_cIO_s, "read", rb_io_s_read, -1);
-}
-    EOF
-
-    klass = util_get_class content, 'rb_cIO'
-    read_method = klass.method_list.first
-    assert_equal "read", read_method.name
-    assert_equal "Method Comment!   ", read_method.comment.text
-    assert read_method.singleton
-  end
-
-  def test_rb_scan_args
-    parser = util_parser
-
-    assert_equal '(p1)',
-                 parser.rb_scan_args('rb_scan_args(a, b, "1",)')
-    assert_equal '(p1, p2)',
-                 parser.rb_scan_args('rb_scan_args(a, b, "2",)')
-
-    assert_equal '(p1 = v1)',
-                 parser.rb_scan_args('rb_scan_args(a, b, "01",)')
-    assert_equal '(p1 = v1, p2 = v2)',
-                 parser.rb_scan_args('rb_scan_args(a, b, "02",)')
-
-    assert_equal '(p1, p2 = v2)',
-                 parser.rb_scan_args('rb_scan_args(a, b, "11",)')
-
-    assert_equal '(p1, *args)',
-                 parser.rb_scan_args('rb_scan_args(a, b, "1*",)')
-    assert_equal '(p1, p2 = {})',
-                 parser.rb_scan_args('rb_scan_args(a, b, "1:",)')
-    assert_equal '(p1, &block)',
-                 parser.rb_scan_args('rb_scan_args(a, b, "1&",)')
-
-    assert_equal '(p1, p2)',
-                 parser.rb_scan_args('rb_scan_args(a, b, "101",)')
-
-    assert_equal '(p1, p2 = v2, p3)',
-                 parser.rb_scan_args('rb_scan_args(a, b, "111",)')
-
-    assert_equal '(p1, *args, p3)',
-                 parser.rb_scan_args('rb_scan_args(a, b, "1*1",)')
-
-    assert_equal '(p1, p2 = v2, *args)',
-                 parser.rb_scan_args('rb_scan_args(a, b, "11*",)')
-    assert_equal '(p1, p2 = v2, p3 = {})',
-                 parser.rb_scan_args('rb_scan_args(a, b, "11:",)')
-    assert_equal '(p1, p2 = v2, &block)',
-                 parser.rb_scan_args('rb_scan_args(a, b, "11&",)')
-
-    assert_equal '(p1, p2 = v2, *args, p4, p5 = {}, &block)',
-                 parser.rb_scan_args('rb_scan_args(a, b, "11*1:&",)')
-
-    # The following aren't valid according to spec but are according to the
-    # implementation.
-    assert_equal '(*args)',
-                 parser.rb_scan_args('rb_scan_args(a, b, "*",)')
-    assert_equal '(p1 = {})',
-                 parser.rb_scan_args('rb_scan_args(a, b, ":",)')
-    assert_equal '(&block)',
-                 parser.rb_scan_args('rb_scan_args(a, b, "&",)')
-
-    assert_equal '(*args, p2 = {})',
-                 parser.rb_scan_args('rb_scan_args(a, b, "*:",)')
-    assert_equal '(p1 = {}, &block)',
-                 parser.rb_scan_args('rb_scan_args(a, b, ":&",)')
-    assert_equal '(*args, p2 = {}, &block)',
-                 parser.rb_scan_args('rb_scan_args(a, b, "*:&",)')
-  end
-
-  def test_scan
-    parser = util_parser <<-C
-void Init(void) {
-    mM = rb_define_module("M");
-    cC = rb_define_class("C", rb_cObject);
-    sC = rb_singleton_class(cC);
-}
-    C
-
-    parser.scan
-
-    expected = {
-      @fn => {
-        'mM' => 'M',
-        'cC' => 'C', }}
-    assert_equal expected, @store.c_class_variables
-
-    expected = {
-      @fn => {
-        'sC' => 'C' } }
-    assert_equal expected, @store.c_singleton_class_variables
-  end
-
-  def test_scan_method_copy
-    parser = util_parser <<-C
-/*
- *  call-seq:
- *    pathname.to_s    -> string
- *    pathname.to_path -> string
- *
- *  Return the path as a String.
- *
- *  to_path is implemented so Pathname objects are usable with File.open, etc.
- */
-static VALUE
-path_to_s(VALUE self) { }
-
-/*
- *  call-seq:
- *     str[index]               -> new_str or nil
- *     str[start, length]       -> new_str or nil
- *     str.slice(index)         -> new_str or nil
- *     str.slice(start, length) -> new_str or nil
- */
-static VALUE
-path_aref_m(int argc, VALUE *argv, VALUE str) { }
-
-/*
- *  call-seq:
- *     string <=> other_string   -> -1, 0, +1 or nil
- */
-static VALUE
-path_cmp_m(VALUE str1, VALUE str2) { }
-
-/*
- *  call-seq:
- *     str == obj    -> true or false
- *     str === obj   -> true or false
- */
-VALUE
-rb_str_equal(VALUE str1, VALUE str2) { }
-
-Init_pathname()
-{
-    rb_cPathname = rb_define_class("Pathname", rb_cObject);
-
-    rb_define_method(rb_cPathname, "to_s",    path_to_s, 0);
-    rb_define_method(rb_cPathname, "to_path", path_to_s, 0);
-    rb_define_method(rb_cPathname, "[]",      path_aref_m, -1);
-    rb_define_method(rb_cPathname, "slice",   path_aref_m, -1);
-    rb_define_method(rb_cPathname, "<=>",     path_cmp_m, 1);
-    rb_define_method(rb_cPathname, "==",      rb_str_equal), 2);
-    rb_define_method(rb_cPathname, "===",     rb_str_equal), 2);
-}
-    C
-
-    parser.scan
-
-    pathname = @store.classes_hash['Pathname']
-
-    to_path = pathname.method_list.find { |m| m.name == 'to_path' }
-    assert_equal "pathname.to_path -> string", to_path.call_seq
-
-    to_s = pathname.method_list.find { |m| m.name == 'to_s' }
-    assert_equal "pathname.to_s    -> string", to_s.call_seq
-
-    index_expected = <<-EXPECTED.chomp
-str[index]               -> new_str or nil
-str[start, length]       -> new_str or nil
-    EXPECTED
-
-    index = pathname.method_list.find { |m| m.name == '[]' }
-    assert_equal index_expected, index.call_seq, '[]'
-
-    slice_expected = <<-EXPECTED.chomp
-str.slice(index)         -> new_str or nil
-str.slice(start, length) -> new_str or nil
-    EXPECTED
-
-    slice = pathname.method_list.find { |m| m.name == 'slice' }
-    assert_equal slice_expected, slice.call_seq
-
-    spaceship = pathname.method_list.find { |m| m.name == '<=>' }
-    assert_equal "string <=> other_string   -> -1, 0, +1 or nil",
-                 spaceship.call_seq
-
-    equals2 = pathname.method_list.find { |m| m.name == '==' }
-    assert_match 'str == obj', equals2.call_seq
-
-    equals3 = pathname.method_list.find { |m| m.name == '===' }
-    assert_match 'str === obj', equals3.call_seq
-  end
-
-  def test_scan_order_dependent
-    parser = util_parser <<-C
-void a(void) {
-    mA = rb_define_module("A");
-}
-
-void b(void) {
-    cB = rb_define_class_under(mA, "B", rb_cObject);
-}
-
-void c(void) {
-    mC = rb_define_module_under(cB, "C");
-}
-
-void d(void) {
-    mD = rb_define_class_under(mC, "D");
-}
-    C
-
-    parser.scan
-
-    assert_equal %w[A A::B A::B::C],
-                 @store.all_classes_and_modules.map { |m| m.full_name }.sort
-  end
-
-  def test_markup_format_default
-    content = <<-EOF
-void Init_Blah(void) {
-  cBlah = rb_define_class("Blah", rb_cObject);
-
-  /*
-   * This should be interpreted in the default format.
-   */
-  rb_attr(cBlah, rb_intern("default_format"), 1, 1, Qfalse);
-}
-    EOF
-
-    klass = util_get_class content, 'cBlah'
-    assert_equal("rdoc", klass.attributes.find {|a| a.name == "default_format"}.comment.format)
-  end
-
-  def test_markup_format_override
-    content = <<-EOF
-void Init_Blah(void) {
-  cBlah = rb_define_class("Blah", rb_cObject);
-
-  /*
-   * This should be interpreted in the default format.
-   */
-  rb_attr(cBlah, rb_intern("default_format"), 1, 1, Qfalse);
-}
-    EOF
-
-    @options.markup = "markdown"
-    klass = util_get_class content, 'cBlah'
-    assert_equal("markdown", klass.attributes.find {|a| a.name == "default_format"}.comment.format)
-  end
-
-  def util_get_class(content, name = nil)
-    @parser = util_parser content
-    @parser.scan
-
-    @parser.classes[name] if name
-  end
-
-  def util_parser(content = '')
-    RDoc::Parser::C.new @top_level, content, @options, @stats
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc/rdoc_parser_changelog_test.rb b/test/mri/rdoc/rdoc/rdoc_parser_changelog_test.rb
deleted file mode 100644
index 4557eacae1f..00000000000
--- a/test/mri/rdoc/rdoc/rdoc_parser_changelog_test.rb
+++ /dev/null
@@ -1,483 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocParserChangeLogTest < RDoc::TestCase
-
-  def setup
-    super
-
-    @tempfile  = Tempfile.new 'ChangeLog'
-    @top_level = @store.add_file @tempfile.path
-    @options   = RDoc::Options.new
-    @stats     = RDoc::Stats.new @store, 0
-  end
-
-  def teardown
-    @tempfile.close!
-
-    super
-  end
-
-  def test_class_can_parse
-    parser = RDoc::Parser::ChangeLog
-
-    temp_dir do
-      FileUtils.touch 'ChangeLog'
-      assert_equal parser, parser.can_parse('ChangeLog')
-
-      assert_equal parser, parser.can_parse(@tempfile.path)
-
-      FileUtils.touch 'ChangeLog.rb'
-      assert_equal RDoc::Parser::Ruby, parser.can_parse('ChangeLog.rb')
-    end
-  end
-
-  def test_continue_entry_body
-    parser = util_parser
-
-    entry_body = ['a'.dup]
-
-    parser.continue_entry_body entry_body, 'b'
-
-    assert_equal ['a b'], entry_body
-  end
-
-  def test_continue_entry_body_empty
-    parser = util_parser
-
-    entry_body = []
-
-    parser.continue_entry_body entry_body, ''
-
-    assert_empty entry_body
-  end
-
-  def test_continue_entry_body_function
-    parser = util_parser
-
-    entry_body = ['file: (func1)'.dup]
-
-    parser.continue_entry_body entry_body, '(func2): blah'
-
-    assert_equal ['file: (func1, func2): blah'], entry_body
-  end
-
-  def test_create_document
-    parser = util_parser
-
-    groups = {
-      '2012-12-04' => [
-        ['Tue Dec  4 08:33:46 2012  Eric Hodel  <drbrain@segment7.net>',
-          %w[a:one b:two]],
-        ['Tue Dec  4 08:32:10 2012  Eric Hodel  <drbrain@segment7.net>',
-          %w[c:three d:four]]],
-      '2012-12-03' => [
-        ['Mon Dec  3 20:28:02 2012  Koichi Sasada  <ko1@atdot.net>',
-          %w[e:five f:six]]],
-    }
-
-    expected =
-      doc(
-        head(1, File.basename(@tempfile.path)),
-        blank_line,
-        head(2, '2012-12-04'),
-        blank_line,
-        head(3, 'Tue Dec  4 08:33:46 2012  Eric Hodel  <drbrain@segment7.net>'),
-        blank_line,
-        list(:NOTE, item('a', para('one')), item('b', para('two'))),
-        head(3, 'Tue Dec  4 08:32:10 2012  Eric Hodel  <drbrain@segment7.net>'),
-        blank_line,
-        list(:NOTE, item('c', para('three')), item('d', para('four'))),
-        head(2, '2012-12-03'),
-        blank_line,
-        head(3, 'Mon Dec  3 20:28:02 2012  Koichi Sasada  <ko1@atdot.net>'),
-        blank_line,
-        list(:NOTE, item('e', para('five')), item('f', para('six'))))
-
-    expected.file = @top_level
-
-    document = parser.create_document(groups)
-
-    assert_equal expected, document
-
-    assert_equal 2, document.omit_headings_below
-
-    headings = document.parts.select do |part|
-      RDoc::Markup::Heading === part and part.level == 2
-    end
-
-    refute headings.all? { |heading| heading.text.frozen? }
-  end
-
-  def test_create_entries
-    parser = util_parser
-
-    entries = [
-      ['Tue Dec  1 02:03:04 2012  Eric Hodel  <drbrain@segment7.net>',
-        %w[a:one b:two]],
-      ['Tue Dec  5 06:07:08 2012  Eric Hodel  <drbrain@segment7.net>',
-        %w[c:three d:four]],
-    ]
-
-    expected = [
-      head(3, 'Tue Dec  1 02:03:04 2012  Eric Hodel  <drbrain@segment7.net>'),
-      blank_line,
-      list(:NOTE, item('a', para('one')), item('b', para('two'))),
-      head(3, 'Tue Dec  5 06:07:08 2012  Eric Hodel  <drbrain@segment7.net>'),
-      blank_line,
-      list(:NOTE, item('c', para('three')), item('d', para('four'))),
-    ]
-
-    entries = parser.create_entries(entries)
-    assert_equal expected, entries
-  end
-
-  def test_create_entries_colons
-    parser = util_parser
-
-    entries = [
-      ['Wed Dec  5 12:17:11 2012  Naohisa Goto  <ngotogenome@gmail.com>',
-        ['func.rb (DL::Function#bind): log stuff [ruby-core:50562]']],
-    ]
-
-    expected = [
-      head(3,
-           'Wed Dec  5 12:17:11 2012  Naohisa Goto  <ngotogenome@gmail.com>'),
-      blank_line,
-      list(:NOTE,
-           item('func.rb (DL::Function#bind)',
-                para('log stuff [ruby-core:50562]')))]
-
-    assert_equal expected, parser.create_entries(entries)
-  end
-
-  def test_create_items
-    parser = util_parser
-
-    items = [
-	    'README.EXT:  Converted to RDoc format',
-	    'README.EXT.ja:  ditto',
-    ]
-
-    expected =
-      list(:NOTE,
-        item('README.EXT',
-          para('Converted to RDoc format')),
-        item('README.EXT.ja',
-          para('ditto')))
-
-    assert_equal expected, parser.create_items(items)
-  end
-
-  def test_group_entries
-    parser = util_parser
-
-    entries = [
-      [ 'Tue Dec  4 08:33:46 2012  Eric Hodel  <drbrain@segment7.net>',
-        %w[one two]],
-      [ 'Tue Dec  4 08:32:10 2012  Eric Hodel  <drbrain@segment7.net>',
-        %w[three four]],
-      [ 'Mon Dec  3 20:28:02 2012  Koichi Sasada  <ko1@atdot.net>',
-        %w[five six]],
-      [ '2008-01-30  H.J. Lu  <hongjiu.lu@intel.com>',
-        %w[seven eight]]]
-
-    expected = {
-      '2012-12-04' => [
-        ['Tue Dec  4 08:33:46 2012  Eric Hodel  <drbrain@segment7.net>',
-          %w[one two]],
-        ['Tue Dec  4 08:32:10 2012  Eric Hodel  <drbrain@segment7.net>',
-          %w[three four]]],
-      '2012-12-03' => [
-        ['Mon Dec  3 20:28:02 2012  Koichi Sasada  <ko1@atdot.net>',
-          %w[five six]]],
-      '2008-01-30' => [
-        ['2008-01-30  H.J. Lu  <hongjiu.lu@intel.com>',
-          %w[seven eight]]],
-    }
-
-    assert_equal expected, parser.group_entries(entries)
-  end
-
-  def test_parse_entries
-    parser = util_parser <<-ChangeLog
-Tue Dec  4 08:33:46 2012  Eric Hodel  <drbrain@segment7.net>
-
-	* README.EXT:  Converted to RDoc format
-	* README.EXT.ja:  ditto
-
-Mon Dec  3 20:28:02 2012  Koichi Sasada  <ko1@atdot.net>
-
-	* compile.c (iseq_specialized_instruction):
-	  change condition of using `opt_send_simple'.
-	  More method invocations can be simple.
-
-commit\ 8187228de0142d3ac7950b7d977c2849e934c637
-
-Other note that will be ignored
-
-    ChangeLog
-
-    expected = [
-      [ 'Tue Dec  4 08:33:46 2012  Eric Hodel  <drbrain@segment7.net>',
-        [ 'README.EXT:  Converted to RDoc format',
-          'README.EXT.ja:  ditto']],
-      [ 'Mon Dec  3 20:28:02 2012  Koichi Sasada  <ko1@atdot.net>',
-        [ 'compile.c (iseq_specialized_instruction): change condition of ' +
-          'using `opt_send_simple\'. More method invocations can be simple.']]]
-
-    assert_equal expected, parser.parse_entries
-  end
-
-  def test_parse_entries_bad_time
-    parser = util_parser <<-ChangeLog
-2008-01-30  H.J. Lu  <hongjiu.lu@intel.com>
-
-        PR libffi/34612
-        * src/x86/sysv.S (ffi_closure_SYSV): Pop 4 byte from stack when
-        returning struct.
-
-    ChangeLog
-
-    expected = [
-      [ '2008-01-30  H.J. Lu  <hongjiu.lu@intel.com>',
-        [ 'src/x86/sysv.S (ffi_closure_SYSV): Pop 4 byte from stack when ' +
-          'returning struct.']]
-    ]
-
-    assert_equal expected, parser.parse_entries
-  end
-
-  def test_parse_entries_gnu
-    parser = util_parser <<-ChangeLog
-1998-08-17  Richard Stallman  <rms@gnu.org>
-
-* register.el (insert-register): Return nil.
-(jump-to-register): Likewise.
-
-* sort.el (sort-subr): Return nil.
-
-* keyboard.c (menu_bar_items, tool_bar_items)
-(Fexecute_extended_command): Deal with 'keymap' property.
-    ChangeLog
-
-    expected = [
-      [ '1998-08-17  Richard Stallman  <rms@gnu.org>',
-        [ 'register.el (insert-register): Return nil.',
-          '(jump-to-register): Likewise.',
-          'sort.el (sort-subr): Return nil.',
-          'keyboard.c (menu_bar_items, tool_bar_items, ' +
-          'Fexecute_extended_command): Deal with \'keymap\' property.']]]
-
-    assert_equal expected, parser.parse_entries
-  end
-
-  def test_parse_entries_git
-    parser = util_parser <<-ChangeLog
-commit\ 709bed2afaee50e2ce803f87bf1ee8291bea41e3
-  Author: git <svn-admin@ruby-lang.org>
-  Date:   2021-01-21 01:03:52 +0900
-
-    * 2021-01-21 [ci skip]
-ChangeLog
-
-    expected = [
-      [ "709bed2afaee50e2ce80",
-       [ "git", "svn-admin@ruby-lang.org",
-         "2021-01-21 01:03:52 +0900",
-         "* 2021-01-21 [ci skip]\n"]]]
-
-    assert_equal expected, parser.parse_entries
-  end
-
-  def test_scan
-    parser = util_parser <<-ChangeLog
-Tue Dec  4 08:32:10 2012  Eric Hodel  <drbrain@segment7.net>
-
-	* lib/rdoc/ri/driver.rb:  Fixed ri page display for files with
-	  extensions.
-	* test/rdoc/test_rdoc_ri_driver.rb:  Test for above
-
-Mon Dec  3 20:37:22 2012  Koichi Sasada  <ko1@atdot.net>
-
-	* vm_exec.c: check VM_COLLECT_USAGE_DETAILS.
-
-    ChangeLog
-
-    parser.scan
-
-    expected = doc(
-      head(1, File.basename(@tempfile.path)),
-      blank_line,
-      head(2, '2012-12-04'),
-      blank_line,
-      head(3, 'Tue Dec  4 08:32:10 2012  Eric Hodel  <drbrain@segment7.net>'),
-      blank_line,
-      list(:NOTE,
-        item('lib/rdoc/ri/driver.rb', para('Fixed ri page display for ' +
-                       'files with extensions.')),
-        item('test/rdoc/test_rdoc_ri_driver.rb', para('Test for above'))),
-      head(2, '2012-12-03'),
-      blank_line,
-      head(3, 'Mon Dec  3 20:37:22 2012  Koichi Sasada  <ko1@atdot.net>'),
-      blank_line,
-      list(:NOTE,
-        item('vm_exec.c', para('check VM_COLLECT_USAGE_DETAILS.'))))
-
-    expected.file = @top_level
-
-    assert_equal expected, @top_level.comment.parse
-  end
-
-  def test_scan_git
-    parser = util_parser <<-ChangeLog
-commit\ 38816887962ec167ee46acf500f68df5c3013163
-Author: git <svn-admin@ruby-lang.org>
-Date:   Sun Jan 24 14:35:51 2021 +0900
-
-    * 2021-01-24 [ci skip]
-
-commit\ db7d0b89f6eca66cc7eb155c95f9123133da1ffc
-Author: git <svn-admin@ruby-lang.org>
-Date:   Sat, 23 Jan 2021 06:01:39 +0900
-
-    * 2021-01-23 [ci skip]
-
-commit\ a3efbda7128ef20b55505b32d1608ea48f80af4a
-Author: git <svn-admin@ruby-lang.org>
-Date:   2021-01-22T02:49:39+09:00
-
-    * 2021-01-22 [ci skip]
-
-commit\ 709bed2afaee50e2ce803f87bf1ee8291bea41e3
-  Author: git <svn-admin@ruby-lang.org>
-  Date:   2021-01-21 01:03:52 +0900
-
-    * 2021-01-21 [ci skip]
-
-commit\ a8dc5156e183489c5121fb1759bda5d9406d9175
-  Author: git <svn-admin@ruby-lang.org>
-  Date:   2021-01-20 01:58:26 +0900
-
-    * 2021-01-20 [ci skip]
-
-commit\ de5f8a92d5001799bedb3b1a271a2d9b23c6c8fb
-  Author: Masataka Pocke Kuwabara <kuwabara@pocke.me>
-  Date:   2021-01-01 14:25:08 +0900
-
-    Make args info for RubyVM::AST to available on endless method without parens
-
-    Problem
-    ===
-
-    Arguments information is missing for endless method without parens.
-    For example:
-
-    ```ruby
-    # ok
-    ```
-
-    It causes an error if a program expects `args` node exists.
-
-    Solution
-    ===
-
-    Call `new_args` on this case.
-ChangeLog
-
-    parser.scan
-
-    expected = doc(
-      head(1, File.basename(@tempfile.path)),
-      blank_line,
-      head(2, '2021-01-24'),
-      blank_line,
-      log_entry(nil, '38816887962ec167ee46',
-                'git', 'svn-admin@ruby-lang.org', 'Sun Jan 24 14:35:51 2021 +0900',
-                [list(:BULLET, item(nil, para('2021-01-24 [ci skip]')))]),
-      head(2, '2021-01-23'),
-      blank_line,
-      log_entry(nil, 'db7d0b89f6eca66cc7eb',
-                'git', 'svn-admin@ruby-lang.org', 'Sat, 23 Jan 2021 06:01:39 +0900',
-                [list(:BULLET, item(nil, para('2021-01-23 [ci skip]')))]),
-      head(2, '2021-01-22'),
-      blank_line,
-      log_entry(nil, 'a3efbda7128ef20b5550',
-                'git', 'svn-admin@ruby-lang.org', '2021-01-22T02:49:39+09:00',
-                [list(:BULLET, item(nil, para('2021-01-22 [ci skip]')))]),
-      head(2, '2021-01-21'),
-      blank_line,
-      log_entry(nil, '709bed2afaee50e2ce80',
-                'git', 'svn-admin@ruby-lang.org', '2021-01-21 01:03:52 +0900',
-                [list(:BULLET, item(nil, para('2021-01-21 [ci skip]')))]),
-      head(2, '2021-01-20'),
-      blank_line,
-      log_entry(nil, 'a8dc5156e183489c5121',
-                'git', 'svn-admin@ruby-lang.org', '2021-01-20 01:58:26 +0900',
-                [list(:BULLET, item(nil, para('2021-01-20 [ci skip]')))]),
-      head(2, '2021-01-01'),
-      blank_line,
-      log_entry(nil, 'de5f8a92d5001799bedb',
-                'Masataka Pocke Kuwabara', 'kuwabara@pocke.me', '2021-01-01 14:25:08 +0900',
-                [head(4, 'Make args info for RubyVM::AST to available on endless method without parens'),
-                 head(5, 'Problem'),
-                 para("Arguments information is missing for endless method without parens.\n" +
-                      "For example:"),
-                 verb("# ok\n").tap {|v| v.format = :ruby},
-                 para('It causes an error if a program expects <code>args</code> node exists.'),
-                 head(5, 'Solution'),
-                 para('Call <code>new_args</code> on this case.')]))
-
-    expected.file = @top_level
-
-    assert_equal expected, @top_level.comment.parse
-  end
-
-  def test_scan_git_commit_date
-    parser = util_parser <<-ChangeLog
-commit\ ee1e690a2df901adb279d7a63fbd92c64e0a5ae6
-  Author:     Igor Zubkov <igor.zubkov@gmail.com>
-  AuthorDate: 2016-10-25 03:56:11 +0900
-  Commit:     Nobuyoshi Nakada <nobu@ruby-lang.org>
-  CommitDate: 2021-01-07 13:40:42 +0900
-
-    We don't need "require 'uri'" after "require 'net/http'".
-
-commit\ 4d0985a7bd8f591dff4b430e288bfd83af782e51
-  Author:     git <svn-admin@ruby-lang.org>
-  AuthorDate: 2021-01-07 10:21:34 +0900
-  Commit:     git <svn-admin@ruby-lang.org>
-  CommitDate: 2021-01-07 10:21:34 +0900
-
-    * 2021-01-07 [ci skip]
-ChangeLog
-
-    parser.scan
-
-    expected = doc(
-      head(1, File.basename(@tempfile.path)),
-      blank_line,
-      head(2, "2021-01-07"),
-      blank_line,
-      log_entry(nil, 'ee1e690a2df901adb279',
-                'Igor Zubkov', 'igor.zubkov@gmail.com',
-                '2016-10-25 03:56:11 +0900',
-                [head(4, %[We don't need "require 'uri'" after "require 'net/http'".])]),
-      log_entry(nil, '4d0985a7bd8f591dff4b',
-                'git', 'svn-admin@ruby-lang.org',
-                '2021-01-07 10:21:34 +0900',
-                [list(:BULLET, item(nil, para("2021-01-07 [ci skip]")))]))
-
-    expected.file = @top_level
-
-    assert_equal expected, @top_level.comment.parse
-  end
-
-  def util_parser(content = '')
-    RDoc::Parser::ChangeLog.new @top_level, content, @options, @stats
-  end
-
-  def log_entry(*a)
-    RDoc::Parser::ChangeLog::Git::LogEntry.new(*a)
-  end
-end
diff --git a/test/mri/rdoc/rdoc/rdoc_parser_markdown_test.rb b/test/mri/rdoc/rdoc/rdoc_parser_markdown_test.rb
deleted file mode 100644
index 49da5693d60..00000000000
--- a/test/mri/rdoc/rdoc/rdoc_parser_markdown_test.rb
+++ /dev/null
@@ -1,61 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocParserMarkdownTest < RDoc::TestCase
-
-  def setup
-    super
-
-    @RP = RDoc::Parser
-
-    @tempfile = Tempfile.new self.class.name
-    filename = @tempfile.path
-
-    @top_level = @store.add_file filename
-    @fn = filename
-    @options = RDoc::Options.new
-    @stats = RDoc::Stats.new @store, 0
-  end
-
-  def teardown
-    super
-
-    @tempfile.close!
-  end
-
-  def test_file
-    assert_kind_of RDoc::Parser::Text, util_parser('')
-  end
-
-  def test_class_can_parse
-    temp_dir do
-      FileUtils.touch 'foo.md'
-      assert_equal @RP::Markdown, @RP.can_parse('foo.md')
-      FileUtils.touch 'foo.md.ja'
-      assert_equal @RP::Markdown, @RP.can_parse('foo.md.ja')
-
-      FileUtils.touch 'foo.markdown'
-      assert_equal @RP::Markdown, @RP.can_parse('foo.markdown')
-      FileUtils.touch 'foo.markdown.ja'
-      assert_equal @RP::Markdown, @RP.can_parse('foo.markdown.ja')
-    end
-  end
-
-  def test_scan
-    parser = util_parser 'it *really* works'
-
-    expected =
-      @RM::Document.new(
-        @RM::Paragraph.new('it _really_ works'))
-    expected.file = @top_level
-
-    parser.scan
-
-    assert_equal expected, @top_level.comment.parse
-  end
-
-  def util_parser(content)
-    RDoc::Parser::Markdown.new @top_level, content, @options, @stats
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc/rdoc_parser_prism_ruby_test.rb b/test/mri/rdoc/rdoc/rdoc_parser_prism_ruby_test.rb
deleted file mode 100644
index 578123b740a..00000000000
--- a/test/mri/rdoc/rdoc/rdoc_parser_prism_ruby_test.rb
+++ /dev/null
@@ -1,2165 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'helper'
-require 'rdoc/parser'
-require 'rdoc/parser/prism_ruby'
-
-module RDocParserPrismTestCases
-  def setup
-    super
-
-    @tempfile = Tempfile.new self.class.name
-    @filename = @tempfile.path
-
-    @top_level = @store.add_file @filename
-
-    @options = RDoc::Options.new
-    @options.quiet = true
-    @options.option_parser = OptionParser.new
-
-    @comment = RDoc::Comment.new '', @top_level
-
-    @stats = RDoc::Stats.new @store, 0
-  end
-
-  def teardown
-    super
-
-    @tempfile.close!
-  end
-
-  def test_look_for_directives_in_section
-    util_parser <<~RUBY
-      # :section: new section
-    RUBY
-    section = @top_level.current_section
-    assert_equal 'new section', section.title
-  end
-
-  def test_look_for_directives_in_commented
-    util_parser <<~RUBY
-      # how to make a section:
-      # # :section: new section
-    RUBY
-    section = @top_level.current_section
-    assert_nil   section.title
-  end
-
-  def test_look_for_directives_in_unhandled
-    util_parser <<~RUBY
-      # :unhandled: blah
-    RUBY
-    assert_equal 'blah', @top_level.metadata['unhandled']
-  end
-
-  def test_block_comment
-    util_parser <<~RUBY
-      =begin rdoc
-      foo
-      =end
-      class A
-      =begin
-      bar
-      baz
-      =end
-        def f; end
-      end
-    RUBY
-    klass = @top_level.classes.first
-    meth = klass.method_list.first
-    assert_equal 'foo', klass.comment.text.strip
-    assert_equal "bar\nbaz", meth.comment.text.strip
-  end
-
-  def test_module
-    util_parser <<~RUBY
-      # my module
-      module Foo
-      end
-    RUBY
-    mod = @top_level.modules.first
-    assert_equal 'Foo', mod.full_name
-    assert_equal 'my module', mod.comment.text
-    assert_equal [@top_level], mod.in_files
-  end
-
-  def test_nested_module_with_colon
-    util_parser <<~RUBY
-      module Foo
-        module Bar; end
-        module Bar::Baz1; end
-        module ::Foo
-          module Bar2; end
-        end
-      end
-      module ::Baz; end
-      module Foo::Bar::Baz2
-        module ::Foo2
-          module Bar; end
-        end
-        module Blah; end
-      end
-    RUBY
-    module_names = @store.all_modules.map(&:full_name)
-    expected = %w[
-      Foo Foo::Bar Foo::Bar::Baz1 Foo::Bar2 Baz Foo::Bar::Baz2 Foo2 Foo2::Bar Foo::Bar::Baz2::Blah
-    ]
-    assert_equal expected.sort, module_names.sort
-  end
-
-  def test_class
-    util_parser <<~RUBY
-      # my class
-      class Foo
-      end
-    RUBY
-    klass = @top_level.classes.first
-    assert_equal 'Foo', klass.full_name
-    assert_equal 'my class', klass.comment.text
-    assert_equal [@top_level], klass.in_files
-    assert_equal 2, klass.line
-  end
-
-  def test_nested_class_with_colon
-    util_parser <<~RUBY
-      class Foo
-        class Bar; end
-        class Bar::Baz1; end
-        class ::Foo
-          class Bar2; end
-        end
-      end
-      class ::Baz; end
-      class Foo::Bar::Baz2
-        class ::Foo2
-          class Bar; end
-        end
-        class Blah; end
-      end
-    RUBY
-    class_names = @store.all_classes.map(&:full_name)
-    expected = %w[
-      Foo Foo::Bar Foo::Bar::Baz1 Foo::Bar2 Baz Foo::Bar::Baz2 Foo2 Foo2::Bar Foo::Bar::Baz2::Blah
-    ]
-    assert_equal expected.sort, class_names.sort
-  end
-
-  def test_open_class_with_superclass
-    util_parser <<~RUBY
-      class A; end
-
-      class B < A
-        def m1; end
-      end
-
-      class B < A
-        def m2; end
-      end
-
-      class C < String
-        def m1; end
-      end
-
-      class C < String
-        def m2; end
-      end
-    RUBY
-    classes = @top_level.classes
-    assert_equal 3, classes.size
-    _a, b, c = classes
-    assert_equal 'A', b.superclass.full_name
-    assert_equal 'String', c.superclass
-    assert_equal ['m1', 'm2'], b.method_list.map(&:name)
-    assert_equal ['m1', 'm2'], c.method_list.map(&:name)
-  end
-
-  def test_open_class_with_superclass_specified_later
-    util_parser <<~RUBY
-      # file_2
-      require 'file_1'
-      class A; end
-      class B; end
-      class C; end
-    RUBY
-    _a, b, c = @top_level.classes
-    assert_equal 'Object', b.superclass
-    assert_equal 'Object', c.superclass
-
-    util_parser <<~RUBY
-      # file_1
-      class B < A; end
-      class C < Unknown; end
-    RUBY
-    assert_equal 'A', b.superclass.full_name
-    assert_equal 'Unknown', c.superclass
-  end
-
-  def test_open_class_with_superclass_specified_later_with_object_defined
-    util_parser <<~RUBY
-      # file_2
-      require 'file_1'
-      class Object; end
-      class A; end
-      class B; end
-      class C; end
-    RUBY
-    _object, _a, b, c = @top_level.classes
-    # If Object exists, superclass will be a NormalClass(Object) instead of string "Object"
-    assert_equal 'Object', b.superclass.full_name
-    assert_equal 'Object', c.superclass.full_name
-
-    util_parser <<~RUBY
-      # file_1
-      class B < A; end
-      class C < Unknown; end
-    RUBY
-    assert_equal 'A', b.superclass.full_name
-    assert_equal 'Unknown', c.superclass
-  end
-
-  def test_confusing_superclass
-    util_parser <<~RUBY
-      module A
-        class B; end
-      end
-
-      module A
-        class C1 < A::B; end
-      end
-
-      class A::C2 < A::B; end
-
-      module A::A
-        class B; end
-      end
-
-      module A
-        class C3 < A::B; end
-      end
-
-      class A::C4 < A::B; end
-    RUBY
-    mod = @top_level.modules.first
-    classes = mod.classes
-    assert_equal ['A::B', 'A::C1', 'A::C2', 'A::C3', 'A::C4'], classes.map(&:full_name)
-    assert_equal ['A::B', 'A::B', 'A::A::B', 'A::B'], classes.drop(1).map(&:superclass).map(&:full_name)
-  end
-
-  def test_pseudo_recursive_superclass
-    util_parser <<~RUBY
-      module Foo
-        class Bar
-          class Foo < Bar; end
-          # This class definition is used in OpenSSL::Cipher::Cipher
-          class Bar < Bar; end
-          class Baz < Bar; end
-        end
-      end
-    RUBY
-    foo_klass = @store.find_class_named 'Foo::Bar::Foo'
-    bar_klass = @store.find_class_named 'Foo::Bar::Bar'
-    baz_klass = @store.find_class_named 'Foo::Bar::Baz'
-    assert_equal 'Foo::Bar', foo_klass.superclass.full_name
-    assert_equal 'Foo::Bar', bar_klass.superclass.full_name
-    assert_equal 'Foo::Bar::Bar', baz_klass.superclass.full_name
-  end
-
-  def test_class_module_nodoc
-    util_parser <<~RUBY
-      class Foo # :nodoc:
-      end
-
-      class Bar
-      end # :nodoc:
-
-      class Baz; end
-
-      class Baz::A; end # :nodoc:
-
-      module MFoo # :nodoc:
-      end
-
-      module MBar
-      end # :nodoc:
-
-      module MBaz; end
-
-      module MBaz::M; end; # :nodoc:
-    RUBY
-    documentables = @store.all_classes_and_modules.select(&:document_self)
-    assert_equal ['Baz', 'MBaz'], documentables.map(&:full_name) unless accept_legacy_bug?
-  end
-
-  def test_class_module_stopdoc
-    util_parser <<~RUBY
-      # comment
-      class Foo
-        class A; end
-        # :stopdoc:
-        class B; end
-      end
-
-      # comment
-      module Bar
-        module A; end
-        # :stopdoc:
-        module B; end
-      end
-    RUBY
-    klass = @top_level.classes.first
-    mod = @top_level.modules.first
-    assert_equal 'comment', klass.comment.text.strip
-    assert_equal 'comment', mod.comment.text.strip
-    assert_equal ['Foo::A'], klass.classes.select(&:document_self).map(&:full_name)
-    assert_equal ['Bar::A'], mod.modules.select(&:document_self).map(&:full_name)
-  end
-
-  def test_class_superclass
-    util_parser <<~RUBY
-      class Foo; end
-      class Bar < Foo
-      end
-      class Baz < (any expression)
-      end
-    RUBY
-    assert_equal ['Foo', 'Bar', 'Baz'], @top_level.classes.map(&:full_name)
-    foo, bar, baz = @top_level.classes
-    assert_equal foo, bar.superclass
-    assert_equal '(any expression)', baz.superclass
-  end
-
-  def test_class_new_notnew
-    util_parser <<~RUBY
-      class A
-        def initialize(*args); end
-      end
-
-      class B
-        ##
-        # :args: a, b, c
-        def initialize(*args); end
-      end
-
-      class C
-        def self.initialize(*args); end
-      end
-
-      class D
-        ##
-        # :args: a, b, c
-        def initialize(*args); end # :notnew:
-      end
-
-      class E
-        def initialize(*args); end # :not-new:
-      end
-
-      class F
-        def initialize(*args); end # :not_new:
-      end
-
-      class G
-        def initialize(*args)
-        end # :notnew:
-      end
-    RUBY
-
-    expected = [
-      'new(*args)', 'new(a, b, c)',
-      'initialize(*args)', 'initialize(a, b, c)',
-      'initialize(*args)', 'initialize(*args)',
-      'initialize(*args)'
-    ]
-    arglists = @top_level.classes.map { |c| c.method_list.first.arglists }
-    assert_equal expected, arglists
-  end
-
-  def test_class_mistaken_for_module
-    util_parser <<~RUBY
-      class A::Foo; end
-      class B::Foo; end
-      module C::Bar; end
-      module D::Baz; end
-      class A; end
-      class X < C; end
-    RUBY
-    assert_equal ['A', 'C', 'X'], @top_level.classes.map(&:full_name)
-    assert_equal ['B', 'D'], @top_level.modules.map(&:full_name)
-  end
-
-  def test_parenthesized_cdecl
-    util_parser <<~RUBY
-      module DidYouMean
-        # Not a module, but creates a dummy module for document
-        class << (NameErrorCheckers = Object.new)
-          def new; end
-        end
-      end
-    RUBY
-
-    mod = @store.find_class_or_module('DidYouMean').modules.first
-    assert_equal 'DidYouMean::NameErrorCheckers', mod.full_name
-    assert_equal ['DidYouMean::NameErrorCheckers::new'], mod.method_list.map(&:full_name)
-  end
-
-  def test_ghost_method
-    util_parser <<~RUBY
-      class Foo
-        ##
-        # :method: one
-        #
-        # my method one
-
-        ##
-        # :method:
-        # :call-seq:
-        #   two(name)
-        #
-        # my method two
-
-        ##
-        # :method: three
-        # :args: a, b
-        #
-        # my method three
-
-        # :stopdoc:
-
-        ##
-        # :method: hidden1
-        #
-        # comment
-
-        ##
-        # :method:
-        # :call-seq:
-        #   hidden2(name)
-        #
-        # comment
-      end
-    RUBY
-
-    klass = @store.find_class_named 'Foo'
-    assert_equal 3, klass.method_list.size
-    one, two, three = klass.method_list
-    assert_equal 'Foo#one', one.full_name
-    assert_equal 'Foo#two', two.full_name
-    assert_equal 'Foo#three', three.full_name
-    assert_equal 'two(name)', two.call_seq.chomp
-    assert_equal 'three(a, b)', three.arglists
-    assert_equal 'my method one', one.comment.text.strip
-    assert_equal 'my method two', two.comment.text.strip
-    assert_equal 'my method three', three.comment.text.strip
-    assert_equal 3, one.line
-    assert_equal 8, two.line
-    assert_equal 15, three.line
-    assert_equal @top_level, one.file
-    assert_equal @top_level, two.file
-    assert_equal @top_level, three.file
-  end
-
-  def test_invalid_meta_method
-    util_parser <<~RUBY
-      class Foo
-        # These are invalid meta method comments
-        # because meta method comment should start with `##`
-        # but rdoc accepts them as meta method comments for now.
-
-        # :method: m1
-
-        # :singleton-method: sm1
-
-        # :attr: a1
-
-        # :attr_reader: ar1
-
-        # :attr_writer: aw1
-
-        # :attr_accessor: arw1
-
-        # If there is a node following meta-like normal comment, it is not a meta method comment
-
-        # :method: m2
-        add_my_method(name)
-
-        # :singleton-method: sm2
-        add_my_singleton_method(name)
-
-        # :method:
-        add_my_method(:m3)
-
-        # :singleton-method:
-        add_my_singleton_method(:sm3)
-
-        # :attr:
-        add_my_attribute(:a2)
-
-        # :attr-reader:
-        add_my_attribute(:ar2)
-
-        # :attr-writer:
-        add_my_attribute(:aw2)
-
-        # :attr-accessor:
-        add_my_attribute(:arw2)
-
-        # :attr: a3
-        add_my_attribute_a3
-
-        # :attr-reader: ar3
-        add_my_attribute_ar3
-
-        # :attr-writer: aw3
-        add_my_attribute_aw2
-
-        # :attr-accessor: arw3
-        add_my_attribute_arw3
-      end
-    RUBY
-
-    klass = @store.find_class_named 'Foo'
-    assert_equal ['m1', 'sm1'], klass.method_list.map(&:name)
-    assert_equal ['a1', 'ar1', 'aw1', 'arw1'], klass.attributes.map(&:name)
-  end
-
-  def test_unknown_meta_method
-    util_parser <<~RUBY
-      class Foo
-        ##
-        # :call-seq:
-        #   two(name)
-        #
-        # method or singleton-method directive is missing
-      end
-
-      class Bar
-        ##
-        # unknown meta method
-        add_my_method("foo" + "bar")
-      end
-    RUBY
-
-    foo = @store.find_class_named 'Foo'
-    bar = @store.find_class_named 'Bar'
-    assert_equal [], foo.method_list.map(&:name)
-    assert_equal ['unknown'], bar.method_list.map(&:name)
-  end
-
-  def test_method
-    util_parser <<~RUBY
-      class Foo
-        # my method one
-        def one; end
-        # my method two
-        def two(x); end
-        # my method three
-        def three x; end
-      end
-    RUBY
-
-    klass = @store.find_class_named 'Foo'
-    assert_equal 3, klass.method_list.size
-    one, two, three = klass.method_list
-    assert_equal 'Foo#one', one.full_name
-    assert_equal 'Foo#two', two.full_name
-    assert_equal 'Foo#three', three.full_name
-    assert_equal 'one()', one.arglists
-    assert_equal 'two(x)', two.arglists
-    assert_equal 'three(x)', three.arglists unless accept_legacy_bug?
-    assert_equal 'my method one', one.comment.text.strip
-    assert_equal 'my method two', two.comment.text.strip
-    assert_equal 'my method three', three.comment.text.strip
-    assert_equal 3, one.line
-    assert_equal 5, two.line
-    assert_equal 7, three.line
-    assert_equal @top_level, one.file
-    assert_equal @top_level, two.file
-    assert_equal @top_level, three.file
-  end
-
-  def test_method_with_modifier_if_unless
-    util_parser <<~RUBY
-      class Foo
-        # my method one
-        def one
-        end if foo
-
-        # my method two
-        def two
-        end unless foo
-      end
-    RUBY
-
-    klass = @store.find_class_named 'Foo'
-    one, two = klass.method_list
-    assert_equal 'Foo#one', one.full_name
-    assert_equal 'my method one', one.comment.text.strip
-    assert_equal 'Foo#two', two.full_name
-    assert_equal 'my method two', two.comment.text.strip
-  end
-
-  def test_method_toplevel
-    util_parser <<~RUBY
-      # comment
-      def foo; end
-    RUBY
-
-    object = @store.find_class_named 'Object'
-    foo = object.method_list.first
-    assert_equal 'Object#foo', foo.full_name
-    assert_equal 'comment', foo.comment.text.strip
-    assert_equal @top_level, foo.file
-  end
-
-  def test_meta_method
-    util_parser <<~RUBY
-      class Foo
-        ##
-        # my method
-        add_my_method :method_foo, :arg
-      end
-    RUBY
-
-    klass = @store.find_class_named 'Foo'
-    assert_equal 1, klass.method_list.size
-    method = klass.method_list.first
-    assert_equal 'Foo#method_foo', method.full_name
-    assert_equal 'my method', method.comment.text.strip
-    assert_equal 4, method.line
-    assert_equal @top_level, method.file
-  end
-
-  def test_first_comment_is_not_a_meta_method
-    util_parser <<~RUBY
-      ##
-      # first comment is not a meta method
-      add_my_method :foo
-
-      ##
-      # this is a meta method
-      add_my_method :bar
-    RUBY
-
-    object = @store.find_class_named 'Object'
-    assert_equal ['bar'], object.method_list.map(&:name)
-  end
-
-  def test_meta_method_unknown
-    util_parser <<~RUBY
-      class Foo
-        ##
-        # my method
-        add_my_method (:foo), :bar
-      end
-    RUBY
-
-    klass = @store.find_class_named 'Foo'
-    assert_equal 1, klass.method_list.size
-    method = klass.method_list.first
-    assert_equal 'Foo#unknown', method.full_name
-    assert_equal 'my method', method.comment.text.strip
-    assert_equal 4, method.line
-    assert_equal @top_level, method.file
-  end
-
-  def test_meta_define_method
-    util_parser <<~RUBY
-      class Foo
-        ##
-        # comment 1
-        define_method :foo do end
-        ##
-        # comment 2
-        define_method :bar, ->{}
-        # not a meta comment, not a meta method
-        define_method :ignored do end
-        class << self
-          ##
-          # comment 3
-          define_method :baz do end
-        end
-      end
-    RUBY
-
-    klass = @store.find_class_named 'Foo'
-    klass.method_list.last.singleton = true if accept_legacy_bug?
-    assert_equal 3, klass.method_list.size
-    assert_equal ['Foo#foo', 'Foo#bar', 'Foo::baz'], klass.method_list.map(&:full_name)
-    assert_equal [false, false, true], klass.method_list.map(&:singleton)
-    assert_equal ['comment 1', 'comment 2', 'comment 3'], klass.method_list.map { |m| m.comment.text.strip }
-    assert_equal [4, 7, 13], klass.method_list.map(&:line)
-    assert_equal [@top_level] * 3, klass.method_list.map(&:file)
-  end
-
-  def test_method_definition_nested_inside_block
-    util_parser <<~RUBY
-      module A
-        extend ActiveSupport::Concern
-        included do
-          ##
-          # :singleton-method:
-          # comment foo
-          mattr_accessor :foo
-
-          ##
-          # :method: bar
-          # comment bar
-          add_my_method :bar
-        end
-
-        metaprogramming do
-          # class that defines this method is unknown
-          def baz1; end
-        end
-
-        my_decorator def self.baz2; end
-
-        self.my_decorator def baz3; end
-      end
-    RUBY
-    mod = @store.find_module_named 'A'
-    methods = mod.method_list
-    unless accept_legacy_bug?
-      assert_equal ['A::foo', 'A#bar', 'A::baz2', 'A#baz3'], methods.map(&:full_name)
-    end
-    assert_equal ['comment foo', 'comment bar'], methods.take(2).map { |m| m.comment.text.strip }
-  end
-
-  def test_method_yields_directive
-    util_parser <<~RUBY
-      class Foo
-        def f1(a, &b); end
-
-        def f2
-          def o.foo
-            yield :dummy
-          end
-          yield
-        end
-
-        def f3(&b)
-          yield a, *b, c: 1
-          yield 1, 2, 3
-        end
-
-        def f4(a, &b) # :yields: d, e
-          yields 1, 2
-        end
-
-        def f5 # :yield: f
-          yields 1, 2
-        end
-
-        def f6; end # :yields:
-
-        ##
-        # :yields: g, h
-        add_my_method :f7
-      end
-    RUBY
-
-    klass = @top_level.classes.first
-    methods = klass.method_list
-    expected = [
-      'f1(a, &b)',
-      'f2() { || ... }',
-      'f3() { |a, *b, c: 1| ... }',
-      'f4(a) { |d, e| ... }',
-      'f5() { |f| ... }',
-      'f6() { || ... }',
-      'f7() { |g, h| ... }'
-    ]
-    assert_equal expected, methods.map(&:arglists)
-  end
-
-  def test_calls_super
-    util_parser <<~RUBY
-      class A
-        def m1; foo; bar; end
-        def m2; if cond; super(a); end; end # SuperNode
-        def m3; tap do; super; end; end # ForwardingSuperNode
-        def m4; def a.b; super; end; end # super inside another method
-      end
-    RUBY
-
-    klass = @store.find_class_named 'A'
-    methods = klass.method_list
-    assert_equal ['m1', 'm2', 'm3', 'm4'], methods.map(&:name)
-    assert_equal [false, true, true, false], methods.map(&:calls_super)
-  end
-
-  def test_method_args_directive
-    util_parser <<~RUBY
-      class Foo
-        def method1 # :args: a, b, c
-        end
-
-        ##
-        # :args: d, e, f
-        def method2(*args); end
-
-        ##
-        # :args: g, h
-        add_my_method :method3
-      end
-    RUBY
-
-    klass = @top_level.classes.first
-    methods = klass.method_list
-    assert_equal ['method1(a, b, c)', 'method2(d, e, f)', 'method3(g, h)'], methods.map(&:arglists)
-  end
-
-  def test_class_repeatedly
-    util_parser <<~RUBY
-      class Foo
-        def foo; end
-      end
-      class Foo
-        def bar; end
-      end
-    RUBY
-    util_parser <<~RUBY
-      class Foo
-        def baz; end
-      end
-    RUBY
-
-    klass = @store.find_class_named 'Foo'
-    assert_equal ['Foo#foo', 'Foo#bar', 'Foo#baz'], klass.method_list.map(&:full_name)
-  end
-
-  def test_undefined_singleton_class_defines_module
-    util_parser <<~RUBY
-      module A
-        class << Foo
-        end
-        class << ::Bar
-        end
-        Baz1 = ''
-        class << Baz1
-        end
-        class << Baz2 # :nodoc:
-        end
-      end
-    RUBY
-
-    modules = @store.all_modules
-    modules = modules.take(3) if accept_legacy_bug?
-    assert_equal ['A', 'A::Foo', 'Bar'], modules.map(&:full_name)
-  end
-
-  def test_singleton_class
-    util_parser <<~RUBY
-      class A; end
-      class Foo
-        def self.m1; end
-        def (any expression).dummy1; end
-        class << self
-          def m2; end
-          def self.dummy2; end
-        end
-        class << A
-          def dummy3; end
-        end
-        class << Foo
-          def m3; end
-          def self.dummy4; end
-        end
-        class << ::Foo
-          def m4; end
-        end
-        class << (any expression)
-          def dummy5; end
-        end
-      end
-      class << Foo
-        def m5; end
-      end
-      class << ::Foo
-        def m6; end
-      end
-    RUBY
-
-    klass = @store.find_class_named 'Foo'
-    methods = klass.method_list
-    methods = methods.reject {|m| m.name =~ /dummy2|dummy4/ } if accept_legacy_bug?
-    assert_equal ['m1', 'm2', 'm3', 'm4', 'm5', 'm6'], methods.map(&:name)
-    assert_equal [true] * 6, methods.map(&:singleton)
-  end
-
-  def test_singleton_class_meta_method
-    util_parser <<~RUBY
-      class Foo
-        ##
-        # :singleton-method: m1
-
-        ##
-        # :singleton-method:
-        add_my_smethod :m2, :arg
-
-        ##
-        # :singleton-method:
-        add_my_smethod 'm3', :arg
-
-        # comment
-        class << self
-          ##
-          # method of a singleton class is a singleton method
-          # :method: m4
-
-          ##
-          # :singleton-method: m5
-        end
-      end
-    RUBY
-
-    klass = @store.find_class_named 'Foo'
-    assert_equal ['m1', 'm2', 'm3', 'm4', 'm5'], klass.method_list.map(&:name)
-    klass.method_list[3].singleton = true if accept_legacy_bug?
-    assert_equal [true] * 5, klass.method_list.map(&:singleton)
-  end
-
-  def test_method_nested_visibility
-    util_parser <<~RUBY
-      class A
-        def pub1; end
-        private
-        def pri1; end
-        class B
-          def pub_b1; end
-          private
-          def pri_b1; end
-          public
-          def pub_b2; end
-        end
-        def pri2; end
-      end
-      class A
-        def pub2; end
-        private
-        def pri2; end
-      end
-    RUBY
-    klass_a = @store.find_class_named 'A'
-    klass_b = klass_a.find_class_named 'B'
-    public_a = klass_a.method_list.select { |m| m.visibility == :public }.map(&:name)
-    public_b = klass_b.method_list.select { |m| m.visibility == :public }.map(&:name)
-    assert_equal ['pub1', 'pub2'], public_a
-    assert_equal ['pub_b1', 'pub_b2'], public_b
-  end
-
-  def test_attributes_visibility
-    util_parser <<~RUBY
-      class A
-        attr :pub_a
-        attr_reader :pub_r
-        attr_writer :pub_w
-        attr_accessor :pub_rw
-        private
-        attr :pri_a
-        attr_reader :pri_r
-        attr_writer :pri_w
-        attr_accessor :pri_rw
-      end
-    RUBY
-    klass = @store.find_class_named 'A'
-    assert_equal ['pub_a', 'pub_r', 'pub_w', 'pub_rw', 'pri_a', 'pri_r', 'pri_w', 'pri_rw'], klass.attributes.map(&:name)
-    assert_equal [:public] * 4 + [:private] * 4, klass.attributes.map(&:visibility)
-  end
-
-  def test_method_singleton_class_visibility
-    util_parser <<~RUBY
-      class A
-        def self.pub1; end
-        private
-        def self.pub2; end
-        class << self
-          def pub3; end
-          private
-          def pri1; end
-          public
-          def pub4; end
-          private
-        end
-      end
-    RUBY
-    klass = @store.find_class_named 'A'
-    public_singleton_methods = klass.method_list.select { |m| m.singleton && m.visibility == :public }
-    assert_equal ['pub1', 'pub2', 'pub3', 'pub4'], public_singleton_methods.map(&:name)
-  end
-
-  def test_private_def_public_def
-    util_parser <<~RUBY
-      class A
-        private def m1; end
-        public def m2; end
-        private
-        public def m3; end
-      end
-    RUBY
-    klass = @store.find_class_named 'A'
-    public_methods = klass.method_list.select { |m| m.visibility == :public }
-    assert_equal ['m2', 'm3'], public_methods.map(&:name)
-  end
-
-  def test_define_method_visibility
-    util_parser <<~RUBY
-      class A
-        private
-        ##
-        # my private method
-        define_method :m1 do end
-        public
-        ##
-        # my public method
-        define_method :m2 do end
-      end
-    RUBY
-    klass = @store.find_class_named 'A'
-    methods = klass.method_list
-    assert_equal ['m1', 'm2'], methods.map(&:name)
-    assert_equal [:private, :public], methods.map(&:visibility)
-  end
-
-  def test_module_function
-    util_parser <<~RUBY
-      module A
-        def m1; end
-        def m2; end
-        def m3; end
-        module_function :m1, :m3
-        module_function def m4; end
-      end
-    RUBY
-    mod = @store.find_module_named 'A'
-    instance_methods = mod.method_list.reject(&:singleton)
-    singleton_methods = mod.method_list.select(&:singleton)
-    if accept_legacy_bug?
-      instance_methods.last.visibility = :private
-      singleton_methods << singleton_methods.last.dup
-      singleton_methods.last.name = 'm4'
-    end
-    assert_equal ['m1', 'm2', 'm3', 'm4'], instance_methods.map(&:name)
-    assert_equal [:private, :public, :private, :private], instance_methods.map(&:visibility)
-    assert_equal ['m1', 'm3', 'm4'], singleton_methods.map(&:name)
-    assert_equal [:public, :public, :public], singleton_methods.map(&:visibility)
-  end
-
-  def test_class_method_visibility
-    util_parser <<~RUBY
-      class A
-        def self.m1; end
-        def self.m2; end
-        def self.m3; end
-        private_class_method :m1, :m2
-        public_class_method :m1, :m3
-        private_class_method def self.m4; end
-        public_class_method def self.m5; end
-      end
-    RUBY
-    klass = @store.find_class_named 'A'
-    public_methods = klass.method_list.select { |m| m.visibility == :public }
-    assert_equal ['m1', 'm3', 'm5'], public_methods.map(&:name) unless accept_legacy_bug?
-  end
-
-  def test_method_change_visibility
-    util_parser <<~RUBY
-      class A
-        def m1; end
-        def m2; end
-        def m3; end
-        def m4; end
-        def m5; end
-        private :m2, :m3, :m4
-        public :m1, :m3
-      end
-      class << A
-        def m1; end
-        def m2; end
-        def m3; end
-        def m4; end
-        def m5; end
-        private :m1, :m2, :m3
-        public :m2, :m4
-      end
-    RUBY
-    klass = @store.find_class_named 'A'
-    public_methods = klass.method_list.select { |m| !m.singleton && m.visibility == :public }
-    public_singleton_methods = klass.method_list.select { |m| m.singleton && m.visibility == :public }
-    assert_equal ['m1', 'm3', 'm5'], public_methods.map(&:name)
-    assert_equal ['m2', 'm4', 'm5'], public_singleton_methods.map(&:name)
-  end
-
-  def test_undocumentable_change_visibility
-    omit if accept_legacy_bug?
-    util_parser <<~RUBY
-      class A
-        def m1; end
-        def self.m2; end
-        private 42, :m # maybe not Module#private
-        # ignore all non-standard `private def` and `private_class_method def`
-        private def self.m1; end
-        private_class_method def m2; end
-        private def to_s.m1; end
-        private_class_method def to_s.m2; end
-      end
-    RUBY
-    klass = @store.find_class_named 'A'
-    assert_equal [:public] * 4, klass.method_list.map(&:visibility)
-  end
-
-  def test_singleton_class_def_with_visibility
-    util_parser <<~RUBY
-      class A
-        class <<self
-          private def m1; end
-        end
-        private def self.m2; end
-      end
-      class <<A
-        private def m3; end
-      end
-    RUBY
-    klass = @store.find_class_named 'A'
-    assert_equal [true, true, true], klass.method_list.map(&:singleton)
-    assert_equal [:private, :public, :private], klass.method_list.map(&:visibility)
-  end
-
-  def test_method_visibility_change_in_subclass
-    omit 'not implemented' if accept_legacy_bug?
-    util_parser <<~RUBY
-      class A
-        def m1; end
-        def m2; end
-        private :m2
-      end
-      class B < A
-        private :m1
-        public :m2
-      end
-    RUBY
-
-    superclass = @store.find_class_named('A')
-    klass = @store.find_class_named('B')
-    assert_equal ['m1', 'm2'], superclass.method_list.map(&:name)
-    assert_equal ['m1', 'm2'], klass.method_list.map(&:name)
-    assert_equal [:public, :private], superclass.method_list.map(&:visibility)
-    assert_equal [:private, :public], klass.method_list.map(&:visibility)
-  end
-
-  def test_singleton_method_visibility_change_in_subclass
-    util_parser <<~RUBY
-      class A
-        def self.m1; end
-        def self.m2; end
-        private_class_method :m2
-      end
-      class B < A
-        private_class_method :m1
-        public_class_method :m2
-      end
-    RUBY
-
-    superclass = @store.find_class_named('A')
-    klass = @store.find_class_named('B')
-    assert_equal ['m1', 'm2'], superclass.method_list.map(&:name)
-    assert_equal ['m1', 'm2'], klass.method_list.map(&:name)
-    assert_equal [:public, :private], superclass.method_list.map(&:visibility)
-    assert_equal [:private, :public], klass.method_list.map(&:visibility)
-  end
-
-  def test_alias
-    util_parser <<~RUBY
-      class Foo
-        def bar; end
-        def bar2; alias :dummy :bar; end
-        # comment
-        alias :baz1 :bar # :nodoc:
-        alias :baz2 :bar
-        # :stopdoc:
-        alias :baz3 :bar
-      end
-    RUBY
-    klass = @store.find_class_named 'Foo'
-    assert_equal ['Foo#bar', 'Foo#bar2', 'Foo#baz2'], klass.method_list.map(&:full_name)
-    m = klass.method_list.last
-    assert_equal 'Foo#bar', m.is_alias_for.full_name
-    assert_equal 'Foo#baz2', m.full_name
-    assert_equal klass, m.parent
-  end
-
-  def test_alias_singleton
-    util_parser <<~RUBY
-      class Foo
-        class << self
-          def bar; end
-          # comment
-          alias :baz :bar
-          # :stopdoc:
-          alias :baz2 :bar
-        end
-      end
-    RUBY
-    klass = @store.find_class_named 'Foo'
-    m = klass.class_method_list.last
-    assert_equal 'Foo::bar', m.is_alias_for.full_name
-    assert_equal 'Foo::baz', m.full_name
-    assert_equal 'comment', m.comment.text
-    assert_equal klass, m.parent
-  end
-
-  def test_alias_method
-    util_parser <<~RUBY
-      class Foo
-        def foo; end
-        private
-        alias_method :foo2, :foo
-        def bar; end
-        public
-        alias_method :bar2, :bar
-        private :foo
-        public :bar
-      end
-    RUBY
-    foo, foo2, bar, bar2 = @top_level.classes.first.method_list
-    assert_equal 'foo', foo.name
-    assert_equal 'bar', bar.name
-    assert_equal 'foo2', foo2.name
-    assert_equal 'bar2', bar2.name
-    assert_equal 'foo', foo2.is_alias_for.name
-    assert_equal 'bar', bar2.is_alias_for.name
-    unless accept_legacy_bug?
-      assert_equal :private, foo.visibility
-      assert_equal :public, foo2.visibility
-      assert_equal :public, bar.visibility
-      assert_equal :private, bar2.visibility
-    end
-  end
-
-  def test_invalid_alias_method
-    omit if accept_legacy_bug?
-    util_parser <<~RUBY
-      class Foo
-        def foo; end
-        alias_method
-        alias_method :foo
-        alias_method :foo, :bar, :baz
-        alias_method 42, :foo
-      end
-    RUBY
-    assert_equal ['foo'], @top_level.classes.first.method_list.map(&:name)
-  end
-
-  def test_alias_method_stopdoc_nodoc
-    util_parser <<~RUBY
-      class Foo
-        def foo; end
-        # :stopdoc:
-        alias_method :foo2, :foo
-        # :startdoc:
-        alias_method :foo3, :foo # :nodoc:
-        alias_method :foo4, :foo
-      end
-    RUBY
-    assert_equal ['foo', 'foo4'], @top_level.classes.first.method_list.map(&:name)
-  end
-
-  def test_attributes
-    util_parser <<~RUBY
-      class Foo
-        # attrs
-        attr :attr1, :attr2
-        # readers
-        attr_reader :reader1, :reader2
-        # writers
-        attr_writer :writer1, :writer2
-        # accessors
-        attr_accessor :accessor1, :accessor2
-        # :stopdoc:
-        attr :attr3, :attr4
-        attr_reader :reader3, :reader4
-        attr_writer :write3, :writer4
-        attr_accessor :accessor3, :accessor4
-      end
-    RUBY
-    klass = @store.find_class_named 'Foo'
-    if accept_legacy_bug?
-      a, r1, r2, w1, w2, rw1, rw2 = klass.attributes
-      a1 = a.dup
-      a2 = a.dup
-      a1.rw = a2.rw = 'R'
-      a2.name = 'attr2'
-    else
-      assert_equal 8, klass.attributes.size
-      a1, a2, r1, r2, w1, w2, rw1, rw2 = klass.attributes
-    end
-    assert_equal ['attr1', 'attr2'], [a1.name, a2.name]
-    assert_equal ['reader1', 'reader2'], [r1.name, r2.name]
-    assert_equal ['writer1', 'writer2'], [w1.name, w2.name]
-    assert_equal ['accessor1', 'accessor2'], [rw1.name, rw2.name]
-    assert_equal ['R', 'R'], [a1.rw, a2.rw]
-    assert_equal ['R', 'R'], [r1.rw, r2.rw]
-    assert_equal ['W', 'W'], [w1.rw, w2.rw]
-    assert_equal ['RW', 'RW'], [rw1.rw, rw2.rw]
-    assert_equal ['attrs', 'attrs'], [a1.comment.text, a2.comment.text]
-    assert_equal ['readers', 'readers'], [r1.comment.text, r2.comment.text]
-    assert_equal ['writers', 'writers'], [w1.comment.text, w2.comment.text]
-    assert_equal ['accessors', 'accessors'], [rw1.comment.text, rw2.comment.text]
-    assert_equal [3, 3], [a1.line, a2.line]
-    assert_equal [5, 5], [r1.line, r2.line]
-    assert_equal [7, 7], [w1.line, w2.line]
-    assert_equal [9, 9], [rw1.line, rw2.line]
-    assert_equal [@top_level] * 8, [a1, a2, r1, r2, w1, w2, rw1, rw2].map(&:file)
-  end
-
-  def test_undocumentable_attributes
-    util_parser <<~RUBY
-      class Foo
-        attr
-        attr 42, :foo
-      end
-    RUBY
-    klass = @store.find_class_named 'Foo'
-    assert_empty klass.method_list
-    assert_empty klass.attributes
-  end
-
-  def test_singleton_class_attributes
-    util_parser <<~RUBY
-      class Foo
-        class << self
-          attr :a
-          attr_reader :r
-          attr_writer :w
-          attr_accessor :rw
-        end
-      end
-    RUBY
-    klass = @store.find_class_named 'Foo'
-    attributes = klass.attributes
-    assert_equal ['a', 'r', 'w', 'rw'], attributes.map(&:name)
-    assert_equal [true] * 4, attributes.map(&:singleton)
-  end
-
-  def test_attributes_nodoc
-    util_parser <<~RUBY
-      class Foo
-        attr :attr1, :attr2 # :nodoc:
-        attr :attr3
-        attr_reader :reader1, :reader2 # :nodoc:
-        attr_reader :reader3
-        attr_writer :writer1, :writer2 # :nodoc:
-        attr_writer :writer3
-        attr_accessor :accessor1, :accessor2 # :nodoc:
-        attr_accessor :accessor3
-      end
-    RUBY
-    klass = @store.find_class_named 'Foo'
-    unless accept_legacy_bug?
-      assert_equal 4, klass.attributes.size
-    end
-  end
-
-  def test_attributes_nodoc_track
-    @options.visibility = :nodoc
-    util_parser <<~RUBY
-      class Foo
-        attr :attr1, :attr2 # :nodoc:
-        attr :attr3
-        attr_reader :reader1, :reader2 # :nodoc:
-        attr_reader :reader3
-        attr_writer :writer1, :writer2 # :nodoc:
-        attr_writer :writer3
-        attr_accessor :accessor1, :accessor2 # :nodoc:
-        attr_accessor :accessor3
-      end
-    RUBY
-    klass = @store.find_class_named 'Foo'
-    unless accept_legacy_bug?
-      assert_equal 12, klass.attributes.size
-    end
-  end
-
-  def test_method_nodoc_stopdoc
-    util_parser <<~RUBY
-      class Foo
-        def doc1; end
-        def nodoc1; end # :nodoc:
-        def doc2; end
-        def nodoc2 # :nodoc:
-        end
-        def doc3; end
-        def nodoc3
-        end # :nodoc:
-        def nodoc4(arg1,
-                   arg2) # :nodoc:
-        end
-        def doc4; end
-        # :stopdoc:
-        def nodoc5; end
-      end
-    RUBY
-    klass = @store.find_class_named 'Foo'
-    assert_equal ['doc1', 'doc2', 'doc3', 'doc4'], klass.method_list.map(&:name)
-  end
-
-  def test_method_nodoc_track
-    @options.visibility = :nodoc
-    util_parser <<~RUBY
-      class Foo
-        def doc1; end
-        def nodoc1; end # :nodoc:
-        def doc2; end
-        def nodoc2 # :nodoc:
-        end
-        def doc3; end
-        def nodoc3
-        end # :nodoc:
-        def doc4; end
-      end
-    RUBY
-    klass = @store.find_class_named 'Foo'
-    assert_equal ['doc1', 'nodoc1', 'doc2', 'nodoc2', 'doc3', 'nodoc3', 'doc4'], klass.method_list.map(&:name)
-    assert_equal [true, nil, true, nil, true, nil, true], klass.method_list.map(&:document_self)
-  end
-
-  def test_meta_attributes
-    util_parser <<~RUBY
-      class Foo
-        ##
-        # :attr:
-        # attrs
-        add_my_method :attr1, :attr2
-        ##
-        # :attr_reader:
-        # readers
-        add_my_method :reader1, :reader2
-        ##
-        # :attr_writer:
-        # writers
-        add_my_method :writer1, :writer2
-        ##
-        # :attr_accessor:
-        # accessors
-        add_my_method :accessor1, :accessor2
-
-        # :stopdoc:
-
-        ##
-        # :attr:
-        add_my_method :attr3
-        ##
-        # :attr_reader:
-        add_my_method :reader3
-        ##
-        # :attr_writer:
-        add_my_method :writer3
-        ##
-        # :attr_accessor:
-        add_my_method :accessor3
-      end
-    RUBY
-    klass = @store.find_class_named 'Foo'
-    assert_equal 8, klass.attributes.size
-    a1, a2, r1, r2, w1, w2, rw1, rw2 = klass.attributes
-    assert_equal ['attr1', 'attr2'], [a1.name, a2.name]
-    assert_equal ['reader1', 'reader2'], [r1.name, r2.name]
-    assert_equal ['writer1', 'writer2'], [w1.name, w2.name]
-    assert_equal ['accessor1', 'accessor2'], [rw1.name, rw2.name]
-    a1.rw = a2.rw = 'R' if accept_legacy_bug?
-    assert_equal ['R', 'R'], [a1.rw, a2.rw]
-    assert_equal ['R', 'R'], [r1.rw, r2.rw]
-    assert_equal ['W', 'W'], [w1.rw, w2.rw]
-    assert_equal ['RW', 'RW'], [rw1.rw, rw2.rw]
-    assert_equal ['attrs', 'attrs'], [a1.comment.text, a2.comment.text]
-    assert_equal ['readers', 'readers'], [r1.comment.text, r2.comment.text]
-    assert_equal ['writers', 'writers'], [w1.comment.text, w2.comment.text]
-    assert_equal ['accessors', 'accessors'], [rw1.comment.text, rw2.comment.text]
-    assert_equal [@top_level] * 8, [a1, a2, r1, r2, w1, w2, rw1, rw2].map(&:file)
-  end
-
-  def test_meta_attributes_named
-    util_parser <<~RUBY
-      class Foo
-        ##
-        # comment a
-        # :attr: attr1
-        add_my_method :a1
-        ##
-        # comment r
-        # :attr_reader: reader1
-        add_my_method :r1
-        ##
-        # comment w
-        # :attr_writer: writer1
-        add_my_method :w1
-        ##
-        # comment rw
-        # :attr_accessor: accessor1
-        add_my_method :rw1
-
-        # :stopdoc:
-
-        ##
-        # :attr: attr2
-        add_my_method :a2
-        ##
-        # :attr_reader: reader2
-        add_my_method :r2
-        ##
-        # :attr_writer: writer2
-        add_my_method :w2
-        ##
-        # :attr_accessor: accessor2
-        add_my_method :rw2
-      end
-    RUBY
-    klass = @store.find_class_named 'Foo'
-    assert_equal 4, klass.attributes.size
-    a, r, w, rw = klass.attributes
-    assert_equal 'attr1', a.name
-    assert_equal 'reader1', r.name
-    assert_equal 'writer1', w.name
-    assert_equal 'accessor1', rw.name
-    a.rw = 'R' if accept_legacy_bug?
-    assert_equal 'R', a.rw
-    assert_equal 'R', r.rw
-    assert_equal 'W', w.rw
-    assert_equal 'RW', rw.rw
-    assert_equal 'comment a', a.comment.text
-    assert_equal 'comment r', r.comment.text
-    assert_equal 'comment w', w.comment.text
-    assert_equal 'comment rw', rw.comment.text
-    assert_equal [@top_level] * 4, [a, r, w, rw].map(&:file)
-  end
-
-  def test_constant
-    util_parser <<~RUBY
-      class Foo
-        A = (any expression 1)
-        def f
-          DUMMY1 = (any expression 2)
-        end
-        class Bar; end
-        Bar::B = (any expression 3)
-        ::C = (any expression 4)
-        # :stopdoc:
-        DUMMY2 = 1
-        # :startdoc:
-        D = (any expression 5)
-        E = (any expression 6) # :nodoc:
-        F = (
-          any expression 7
-        ) # :nodoc:
-      end
-      G = (any expression 8)
-    RUBY
-    foo = @top_level.classes.first
-    bar = foo.classes.first
-    object = @top_level.find_class_or_module('Object')
-    assert_equal ['A', 'D', 'E', 'F'], foo.constants.map(&:name) unless accept_legacy_bug?
-    assert_equal '(any expression 1)', foo.constants.first.value
-    assert_equal ['B'], bar.constants.map(&:name)
-    assert_equal ['C', 'G'], object.constants.map(&:name) unless accept_legacy_bug?
-    all_constants = foo.constants + bar.constants + object.constants
-    assert_equal [@top_level] * 7, all_constants.map(&:file) unless accept_legacy_bug?
-    assert_equal [2, 12, 13, 14, 7, 8, 18], all_constants.map(&:line) unless accept_legacy_bug?
-  end
-
-  def test_nodoc_constant_assigned_without_nodoc_comment
-    util_parser <<~RUBY
-      module Foo
-        A = 1
-        B = 1 # :nodoc:
-        begin
-          C = 1 # :nodoc:
-        rescue
-          C = 2
-        end
-      end
-      Foo::B = 2
-      Foo::D = 2
-    RUBY
-    mod = @top_level.modules.first
-    assert_equal ['A', 'B', 'C', 'D'], mod.constants.map(&:name)
-    assert_equal [false, true, true, false], mod.constants.map(&:received_nodoc)
-  end
-
-  def test_constant_visibility
-    util_parser <<~RUBY
-      class C
-        A = 1
-        B = 2
-        C = 3
-        private_constant
-        private_constant foo
-        private_constant :A
-        private_constant :B, :C
-        public_constant :B
-      end
-    RUBY
-    klass = @store.find_class_named 'C'
-    const_a, const_b, const_c = klass.constants.sort_by(&:name)
-
-    assert_equal 'A', const_a.name
-    assert_equal :private, const_a.visibility
-
-    assert_equal 'B', const_b.name
-    assert_equal :public, const_b.visibility
-
-    assert_equal 'C', const_c.name
-    assert_equal :private, const_c.visibility
-  end
-
-  def test_constant_assignment_to_undefined_module_path
-    util_parser <<~RUBY
-      A::B::C = 1
-    RUBY
-    a = @top_level.find_module_named 'A'
-    b = a.find_module_named 'B'
-    c = b.constants.first
-    assert_equal 'A::B::C', c.full_name
-  end
-
-  def test_constant_alias
-    util_parser <<~RUBY
-      class Foo
-        class Bar; end
-        A = Bar
-        # B = ::Foo # master branch has bug
-        C = Foo::Bar
-      end
-    RUBY
-    klass = @top_level.classes.first
-    assert_equal [], klass.modules.map(&:full_name)
-    assert_equal ['Foo::Bar', 'Foo::A', 'Foo::C'], klass.classes.map(&:full_name)
-    assert_equal ['Foo::A', 'Foo::C'], klass.constants.map(&:full_name)
-    assert_equal 'Foo::A', klass.find_module_named('A').full_name
-    assert_equal 'Foo::C', klass.find_module_named('C').full_name
-  end
-
-  def test_constant_with_singleton_class
-    omit if accept_legacy_bug?
-    util_parser <<~RUBY
-      class Foo
-        class Bar; end
-        A = 1
-        class <<Bar
-          B = 1
-          Foo::Bar::B2 = 1
-        end
-        class Bar
-          C = 1
-        end
-        class <<(p(D = 1))
-          E = 1
-        end
-        class (F = 1)::Baz
-          G = 1
-        end
-        module (H = 1)::Baz
-          I = 1
-        end
-      end
-      J = 1
-    RUBY
-    foo, bar = @store.all_classes
-    assert_equal ['J'], @store.find_class_named('Object').constants.map(&:name)
-    assert_equal ['A', 'D', 'F', 'H'], foo.constants.map(&:name)
-    assert_equal ['B2', 'C'], bar.constants.map(&:name)
-  end
-
-  def test_constant_method
-    util_parser <<~RUBY
-      def Object.foo; end
-      class A
-        class B
-          class C
-            def B.bar; end
-          end
-        end
-      end
-      def UNKNOWN.baz; end
-    RUBY
-
-    object = @store.find_class_named 'Object'
-    klass = @store.find_class_named 'A::B'
-    unknown = @store.find_module_named('UNKNOWN')
-    assert_equal 'Object::foo', object.method_list.first.full_name
-    assert_equal 'A::B::bar', klass.method_list.first.full_name
-    assert_equal 'UNKNOWN::baz', unknown.method_list.first.full_name
-  end
-
-  def test_true_false_nil_method
-    util_parser <<~RUBY
-      def nil.foo; end
-      def true.bar; end
-      def false.baz; end
-    RUBY
-    sep = accept_legacy_bug? ? '::' : '#'
-    assert_equal "NilClass#{sep}foo", @store.find_class_named('NilClass').method_list.first.full_name
-    assert_equal "TrueClass#{sep}bar", @store.find_class_named('TrueClass').method_list.first.full_name
-    assert_equal "FalseClass#{sep}baz", @store.find_class_named('FalseClass').method_list.first.full_name
-  end
-
-  def test_include_extend
-    util_parser <<~RUBY
-      module I; end
-      module E; end
-      class C
-        # my include
-        include I
-        # my extend
-        extend E
-      end
-      module M
-        include I
-        extend E
-      end
-    RUBY
-    klass = @store.find_class_named 'C'
-    mod = @store.find_module_named 'M'
-    assert_equal ['I'], klass.includes.map(&:name)
-    assert_equal ['E'], klass.extends.map(&:name)
-    assert_equal ['I'], mod.includes.map(&:name)
-    assert_equal ['E'], mod.extends.map(&:name)
-    assert_equal 'my include', klass.includes.first.comment.text.strip
-    assert_equal 'my extend', klass.extends.first.comment.text.strip
-  end
-
-  def test_include_extend_to_singleton_class
-    omit 'not implemented' if accept_legacy_bug?
-    util_parser <<~RUBY
-      class Foo
-        class << self
-          # include to singleton class is extend
-          include I
-          # extend to singleton class is not documentable
-          extend E
-        end
-      end
-    RUBY
-
-    klass = @top_level.classes.first
-    assert_equal [], klass.includes.map(&:name)
-    assert_equal ['I'], klass.extends.map(&:name)
-  end
-
-  def test_include_with_module_nesting
-    util_parser <<~RUBY
-      module A
-        module M; end
-        module B
-          module M; end
-          module C
-            module M; end
-            module D
-              module M; end
-            end
-          end
-        end
-      end
-
-      module A::B
-        class C::D::Foo
-          include M
-        end
-      end
-      # TODO: make test pass with the following code appended
-      # module A::B::C
-      #   class D::Foo
-      #     include M
-      #   end
-      # end
-    RUBY
-    klass = @store.find_class_named 'A::B::C::D::Foo'
-    assert_equal 'A::B::M', klass.includes.first.module.full_name
-  end
-
-  def test_various_argument_include
-    omit 'not implemented' if accept_legacy_bug?
-    util_parser <<~RUBY
-      module A; end
-      module B; end
-      module C; end
-      class A
-        include
-        include A, B
-        include 42, C # Maybe not Module#include
-      end
-    RUBY
-    klass = @top_level.classes.first
-    assert_equal ['A', 'B'], klass.includes.map(&:name)
-  end
-
-  def test_require
-    util_parser <<~RUBY
-      require
-      require 'foo/bar'
-      require_relative 'is/not/supported/yet'
-      require "\#{embed}"
-      require (any expression)
-    RUBY
-    assert_equal ['foo/bar'], @top_level.requires.map(&:name)
-  end
-
-  def test_statements_identifier_alias_method_before_original_method
-    # This is not strictly legal Ruby code, but it simulates finding an alias
-    # for a method before finding the original method, which might happen
-    # to rdoc if the alias is in a different file than the original method
-    # and rdoc processes the alias' file first.
-    util_parser <<~RUBY
-      class Foo
-        alias_method :foo2, :foo
-        alias_method :foo3, :foo
-      end
-
-      class Foo
-        def foo(); end
-        alias_method :foo4, :foo
-        alias_method :foo5, :unknown
-      end
-    RUBY
-
-    foo = @top_level.classes.first.method_list[0]
-    assert_equal 'foo', foo.name
-
-    foo2 = @top_level.classes.first.method_list[1]
-    assert_equal 'foo2', foo2.name
-    assert_equal 'foo', foo2.is_alias_for.name
-
-    foo3 = @top_level.classes.first.method_list[2]
-    assert_equal 'foo3', foo3.name
-    assert_equal 'foo', foo3.is_alias_for.name
-
-    foo4 = @top_level.classes.first.method_list.last
-    assert_equal 'foo4', foo4.name
-    assert_equal 'foo', foo4.is_alias_for.name
-
-    assert_equal 'unknown', @top_level.classes.first.external_aliases[0].old_name
-  end
-
-  def test_class_definition_encountered_after_class_reference
-    # The code below is not legal Ruby (Foo must have been defined before
-    # Foo.bar is encountered), but RDoc might encounter Foo.bar before Foo if
-    # they live in different files.
-
-    util_parser <<-RUBY
-      def Foo.bar
-      end
-
-      class Foo < IO
-      end
-    RUBY
-
-    assert_empty @store.modules_hash
-    assert_empty @store.all_modules
-
-    klass = @top_level.classes.first
-    assert_equal 'Foo', klass.full_name
-    assert_equal 'IO', klass.superclass
-
-    assert_equal 'bar', klass.method_list.first.name
-  end
-
-  def test_scan_duplicate_module
-    util_parser <<~RUBY
-      # comment a
-      module Foo
-      end
-
-      # comment b
-      module Foo
-      end
-    RUBY
-
-    mod = @top_level.modules.first
-
-    expected = [
-      RDoc::Comment.new('comment a', @top_level),
-      RDoc::Comment.new('comment b', @top_level)
-    ]
-
-    assert_equal expected, mod.comment_location.map { |c, _l| c }
-  end
-
-  def test_enddoc
-    util_parser <<~RUBY
-      class A
-        class B; end
-        # :enddoc:
-        # :startdoc:
-        class C; end
-      end
-      class D; end
-      # :enddoc:
-      # :startdoc:
-      class E; end
-    RUBY
-
-    assert_equal ['A', 'A::B', 'D'], @store.all_classes.reject(&:ignored?).map(&:full_name)
-  end
-
-  def test_top_level_enddoc
-    util_parser <<~RUBY
-      class A; end
-      # :enddoc:
-      class B; end
-      # :startdoc:
-      class C; end
-    RUBY
-
-    assert_equal ['A'], @top_level.classes.reject(&:ignored?).map(&:name)
-  end
-
-  def test_section
-    util_parser <<~RUBY
-      class Foo
-        # :section: section1
-        attr :a1
-        def m1; end
-        # :section:
-        def m2; end
-        attr :a2
-        # :section: section2
-        def m3; end
-        attr :a3
-        module Bar
-          def m4; end
-          attr :a4
-          # :section: section3
-          def m5; end
-          attr :a5
-        end
-        attr :a6
-        def m6; end
-      end
-    RUBY
-    foo = @top_level.classes.first
-    bar = foo.modules.first
-    assert_equal ['section1', nil, 'section2', 'section2'], foo.attributes.map { |m| m.section.title }
-    assert_equal ['section1', nil, 'section2', 'section2'], foo.method_list.map { |m| m.section.title }
-    assert_equal [nil, 'section3'], bar.attributes.map { |m| m.section.title }
-    assert_equal [nil, 'section3'], bar.method_list.map { |m| m.section.title }
-  end
-
-  def test_category
-    util_parser <<~RUBY
-      class A
-        # :category: cat1
-
-        # comment
-        attr :a1
-        attr :a2
-        def m1; end
-        # :category: cat2
-
-        # comment
-        def m2; end
-        def m3; end
-        attr :a3
-
-        # :category:
-        attr :a4
-        # :category:
-        def m4; end
-
-        ##
-        # :category: cat3
-        def m5; end
-
-        ##
-        # :category: cat4
-        # :method: m6
-      end
-    RUBY
-    klass = @top_level.classes.first
-    assert_equal ['cat1', nil, nil, nil], klass.attributes.map { |m| m.section.title }
-    assert_equal [nil, 'cat2', nil, nil, 'cat3', 'cat4'], klass.method_list.map { |m| m.section.title }
-  end
-
-  def test_ignore_constant_assign_rhs
-    # Struct is not supported yet. Right hand side of constant assignment should be ignored.
-    util_parser <<~RUBY
-      module Foo
-        def a; end
-        Bar = Struct.new do
-          def b; end
-          ##
-          # :method: c
-        end
-        Bar::Baz = Struct.new do
-          def d; end
-          ##
-          # :method: e
-        end
-        ##
-        # :method: f
-      end
-    RUBY
-    mod = @top_level.modules.first
-    assert_equal ['a', 'f'], mod.method_list.map(&:name)
-  end
-
-  def test_include_extend_suppressed_within_block
-    util_parser <<~RUBY
-      module M; end
-      module N; end
-      module O: end
-      class A
-        metaprogramming do
-          include M
-          extend N
-          class B
-            include M
-            extend N
-          end
-          include M
-          extend N
-        end
-        include O
-        extend O
-      end
-    RUBY
-    a, b = @store.all_classes
-    unless accept_legacy_bug?
-      assert_equal ['O'], a.includes.map(&:name)
-      assert_equal ['O'], a.extends.map(&:name)
-    end
-    assert_equal ['M'], b.includes.map(&:name)
-    assert_equal ['N'], b.extends.map(&:name)
-  end
-
-  def test_multibyte_method_name
-    content = <<~RUBY
-      class Foo
-        # comment ω
-        def ω() end
-      end
-    RUBY
-    util_parser content
-    assert_equal Encoding::UTF_8, content.encoding
-    method = @top_level.classes.first.method_list.first
-    assert_equal 'comment ω', method.comment.text.strip
-    assert_equal 'ω', method.name
-  end
-
-  def test_options_encoding
-    @options.encoding = Encoding::CP852
-    util_parser <<~RUBY
-      class Foo
-        ##
-        # this is my method
-        add_my_method :foo
-      end
-    RUBY
-    foo = @top_level.classes.first.method_list.first
-    assert_equal 'foo', foo.name
-    assert_equal 'this is my method', foo.comment.text
-    assert_equal Encoding::CP852, foo.comment.text.encoding
-  end
-
-  def test_read_directive_linear_performance
-    assert_linear_performance((1..5).map{|i|10**i}) do |i|
-      util_parser '# ' + '0'*i + '=000:' + "\n def f; end"
-    end
-  end
-
-
-  def test_markup_first_comment
-    util_parser <<~RUBY
-      # :markup: rd
-
-      # ((*awesome*))
-      class C
-        # ((*radical*))
-        def m
-        end
-      end
-    RUBY
-
-    c = @top_level.classes.first
-    assert_equal 'rd', c.comment.format
-    assert_equal 'rd', c.method_list.first.comment.format
-  end
-
-  def test_markup_override
-    util_parser <<~RUBY
-      # *awesome*
-      class C
-        # :markup: rd
-        # ((*radical*))
-        def m1; end
-
-        # *awesome*
-        def m2; end
-      end
-    RUBY
-
-    c = @top_level.classes.first
-
-    assert_equal 'rdoc', c.comment.format
-
-    assert_equal ['rd', 'rdoc'], c.method_list.map { |m| m.comment.format }
-  end
-
-  def test_tomdoc_meta
-    util_parser <<~RUBY
-      # :markup: tomdoc
-
-      class C
-
-        # Signature
-        #
-        #   find_by_<field>[_and_<field>...](args)
-        #
-        # field - A field name.
-
-      end
-    RUBY
-
-    c = @top_level.classes.first
-
-    m = c.method_list.first
-
-    assert_equal "find_by_<field>[_and_<field>...]", m.name
-    assert_equal "find_by_<field>[_and_<field>...](args)\n", m.call_seq
-
-    expected =
-      doc(
-        head(3, 'Signature'),
-        list(:NOTE,
-          item(%w[field],
-            para('A field name.'))))
-    expected.file = @top_level
-
-    assert_equal expected, m.comment.parse
-  end
-end
-
-class RDocParserPrismRubyTest < RDoc::TestCase
-  include RDocParserPrismTestCases
-
-  def accept_legacy_bug?
-    false
-  end
-
-  def util_parser(content)
-    @parser = RDoc::Parser::PrismRuby.new @top_level, content, @options, @stats
-    @parser.scan
-  end
-end
-
-# Run the same test with the original RDoc::Parser::Ruby
-class RDocParserRubyWithPrismRubyTestCasesTest < RDoc::TestCase
-  include RDocParserPrismTestCases
-
-  def accept_legacy_bug?
-    true
-  end
-
-  def util_parser(content)
-    @parser = RDoc::Parser::Ruby.new @top_level, content, @options, @stats
-    @parser.scan
-  end
-end unless ENV['RDOC_USE_PRISM_PARSER']
diff --git a/test/mri/rdoc/rdoc/rdoc_parser_rd_test.rb b/test/mri/rdoc/rdoc/rdoc_parser_rd_test.rb
deleted file mode 100644
index a1e552252a4..00000000000
--- a/test/mri/rdoc/rdoc/rdoc_parser_rd_test.rb
+++ /dev/null
@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocParserRdTest < RDoc::TestCase
-
-  def setup
-    super
-
-    @RP = RDoc::Parser
-
-    @tempfile = Tempfile.new self.class.name
-    filename = @tempfile.path
-
-    @top_level = @store.add_file filename
-    @fn = filename
-    @options = RDoc::Options.new
-    @stats = RDoc::Stats.new @store, 0
-  end
-
-  def teardown
-    super
-
-    @tempfile.close!
-  end
-
-  def test_file
-    assert_kind_of RDoc::Parser::Text, util_parser('')
-  end
-
-  def test_class_can_parse
-    temp_dir do
-      FileUtils.touch 'foo.rd'
-      assert_equal @RP::RD, @RP.can_parse('foo.rd')
-
-      FileUtils.touch 'foo.rd.ja'
-      assert_equal @RP::RD, @RP.can_parse('foo.rd.ja')
-    end
-  end
-
-  def test_scan
-    parser = util_parser 'it ((*really*)) works'
-
-    expected = doc(para('it <em>really</em> works'))
-    expected.file = @top_level
-
-    parser.scan
-
-    assert_equal expected, @top_level.comment.parse
-  end
-
-  def util_parser(content)
-    RDoc::Parser::RD.new @top_level, content, @options, @stats
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc/rdoc_parser_ruby_test.rb b/test/mri/rdoc/rdoc/rdoc_parser_ruby_test.rb
deleted file mode 100644
index 2f4665a25fe..00000000000
--- a/test/mri/rdoc/rdoc/rdoc_parser_ruby_test.rb
+++ /dev/null
@@ -1,4396 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'helper'
-
-return if ENV['RDOC_USE_PRISM_PARSER']
-
-class RDocParserRubyTest < RDoc::TestCase
-
-  def setup
-    super
-
-    @tempfile = Tempfile.new self.class.name
-    @filename = @tempfile.path
-
-    # Some tests need two paths.
-    @tempfile2 = Tempfile.new self.class.name
-    @filename2 = @tempfile2.path
-
-    @top_level = @store.add_file @filename
-    @top_level2 = @store.add_file @filename2
-
-    @options = RDoc::Options.new
-    @options.quiet = true
-    @options.option_parser = OptionParser.new
-
-    @comment = RDoc::Comment.new '', @top_level
-
-    @stats = RDoc::Stats.new @store, 0
-  end
-
-  def teardown
-    super
-
-    @tempfile.close!
-    @tempfile2.close!
-  end
-
-  def test_collect_first_comment
-    p = util_parser <<-CONTENT
-# first
-
-# second
-class C; end
-    CONTENT
-
-    comment = p.collect_first_comment
-
-    assert_equal RDoc::Comment.new("# first\n", @top_level), comment
-  end
-
-  def test_collect_first_comment_encoding
-    @options.encoding = Encoding::CP852
-
-    p = util_parser <<-CONTENT
-# first
-
-# second
-class C; end
-    CONTENT
-
-    comment = p.collect_first_comment
-
-    assert_equal Encoding::CP852, comment.text.encoding
-  end
-
-  def test_collect_first_comment_rd_hash
-    parser = util_parser <<-CONTENT
-=begin
-first
-=end
-
-# second
-class C; end
-    CONTENT
-
-    comment = parser.collect_first_comment
-
-    assert_equal RDoc::Comment.new("first\n", @top_level), comment
-  end
-
-  def test_get_class_or_module
-    ctxt = RDoc::Context.new
-    ctxt.store = @store
-
-    cont, name_t, given_name = util_parser('A')    .get_class_or_module ctxt
-
-    assert_equal ctxt, cont
-    assert_equal 'A', name_t[:text]
-    assert_equal 'A', given_name
-
-    cont, name_t, given_name = util_parser('B::C') .get_class_or_module ctxt
-
-    b = @store.find_module_named('B')
-    assert_equal b, cont
-    assert_equal [@top_level], b.in_files
-    assert_equal 'C', name_t[:text]
-    assert_equal 'B::C', given_name
-
-    cont, name_t, given_name = util_parser('D:: E').get_class_or_module ctxt
-
-    assert_equal @store.find_module_named('D'), cont
-    assert_equal 'E', name_t[:text]
-    assert_equal 'D::E', given_name
-
-    assert_nothing_raised do
-      util_parser("A::\nB").get_class_or_module ctxt
-    end
-  end
-
-  def test_get_class_or_module_document_children
-    ctxt = @top_level.add_class RDoc::NormalClass, 'A'
-    ctxt.stop_doc
-
-    util_parser('B::C').get_class_or_module ctxt
-
-    b = @store.find_module_named('A::B')
-    assert b.ignored?
-
-    d = @top_level.add_class RDoc::NormalClass, 'A::D'
-
-    util_parser('D::E').get_class_or_module ctxt
-
-    refute d.ignored?
-  end
-
-  def test_get_class_or_module_ignore_constants
-    ctxt = RDoc::Context.new
-    ctxt.store = @store
-
-    util_parser('A')   .get_class_or_module ctxt, true
-    util_parser('A::B').get_class_or_module ctxt, true
-
-    assert_empty ctxt.constants
-    assert_empty @store.modules_hash.keys
-    assert_empty @store.classes_hash.keys
-  end
-
-  def test_get_class_specification
-    assert_equal 'A',    util_parser('A')   .get_class_specification
-    assert_equal 'A::B', util_parser('A::B').get_class_specification
-    assert_equal '::A',  util_parser('::A').get_class_specification
-
-    assert_equal 'self', util_parser('self').get_class_specification
-
-    assert_equal '',     util_parser('').get_class_specification
-
-    assert_equal '',     util_parser('$g').get_class_specification
-  end
-
-  def test_get_symbol_or_name
-    util_parser "* & | + 5 / 4"
-
-    assert_equal '*', @parser.get_symbol_or_name
-
-    @parser.skip_tkspace
-
-    assert_equal '&', @parser.get_symbol_or_name
-
-    @parser.skip_tkspace
-
-    assert_equal '|', @parser.get_symbol_or_name
-
-    @parser.skip_tkspace
-
-    assert_equal '+', @parser.get_symbol_or_name
-
-    @parser.skip_tkspace
-    @parser.get_tk
-    @parser.skip_tkspace
-
-    assert_equal '/', @parser.get_symbol_or_name
-  end
-
-  def test_suppress_parents
-    a = @top_level.add_class RDoc::NormalClass, 'A'
-    b = a.add_class RDoc::NormalClass, 'B'
-    c = b.add_class RDoc::NormalClass, 'C'
-
-    util_parser ''
-
-    @parser.suppress_parents c, a
-
-    assert c.suppressed?
-    assert b.suppressed?
-    refute a.suppressed?
-  end
-
-  def test_suppress_parents_documented
-    a = @top_level.add_class RDoc::NormalClass, 'A'
-    b = a.add_class RDoc::NormalClass, 'B'
-    b.add_comment RDoc::Comment.new("hello"), @top_level
-    c = b.add_class RDoc::NormalClass, 'C'
-
-    util_parser ''
-
-    @parser.suppress_parents c, a
-
-    assert c.suppressed?
-    refute b.suppressed?
-    refute a.suppressed?
-  end
-
-  def test_look_for_directives_in_attr
-    util_parser ""
-
-    comment = RDoc::Comment.new "# :attr: my_attr\n", @top_level
-
-    @parser.look_for_directives_in @top_level, comment
-
-    assert_equal "# :attr: my_attr\n", comment.text
-
-    comment = RDoc::Comment.new "# :attr_reader: my_method\n", @top_level
-
-    @parser.look_for_directives_in @top_level, comment
-
-    assert_equal "# :attr_reader: my_method\n", comment.text
-
-    comment = RDoc::Comment.new "# :attr_writer: my_method\n", @top_level
-
-    @parser.look_for_directives_in @top_level, comment
-
-    assert_equal "# :attr_writer: my_method\n", comment.text
-  end
-
-  def test_look_for_directives_in_commented
-    util_parser ""
-
-    comment = RDoc::Comment.new <<-COMMENT, @top_level
-# how to make a section:
-# # :section: new section
-    COMMENT
-
-    @parser.look_for_directives_in @top_level, comment
-
-    section = @top_level.current_section
-    assert_nil   section.title
-    assert_nil   section.comment
-
-    assert_equal "# how to make a section:\n# # :section: new section\n",
-                 comment.text
-  end
-
-  def test_look_for_directives_in_method
-    util_parser ""
-
-    comment = RDoc::Comment.new "# :method: my_method\n", @top_level
-
-    @parser.look_for_directives_in @top_level, comment
-
-    assert_equal "# :method: my_method\n", comment.text
-
-    comment = RDoc::Comment.new "# :singleton-method: my_method\n", @top_level
-
-    @parser.look_for_directives_in @top_level, comment
-
-    assert_equal "# :singleton-method: my_method\n", comment.text
-  end
-
-  def test_look_for_directives_in_section
-    util_parser ""
-
-    comment = RDoc::Comment.new <<-COMMENT, @top_level
-# :section: new section
-# woo stuff
-    COMMENT
-
-    @parser.look_for_directives_in @top_level, comment
-
-    section = @top_level.current_section
-    assert_equal 'new section', section.title
-    assert_equal [comment("# woo stuff\n", @top_level)], section.comments
-
-    assert_empty comment
-  end
-
-  def test_look_for_directives_in_unhandled
-    util_parser ""
-
-    comment = RDoc::Comment.new "# :unhandled: blah\n", @top_level
-
-    @parser.look_for_directives_in @top_level, comment
-
-    assert_equal 'blah', @top_level.metadata['unhandled']
-  end
-
-  def test_parse_for_in
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-
-    comment = RDoc::Comment.new '', @top_level
-
-    util_parser <<ruby
-def sum(n)
-  result = 0
-  for i in 1..n do
-    result += i
-  end
-  result
-end
-ruby
-
-    tk = @parser.get_tk
-
-    @parser.parse_method klass, RDoc::Parser::Ruby::NORMAL, tk, comment
-
-    sum = klass.method_list.first
-    assert_equal 'sum',      sum.name
-    assert_equal @top_level, sum.file
-  end
-
-  def test_parse_on_ignored_nl_with_nil_text
-    util_parser <<ruby
-class Foo
-  def meth
-    variable # comment
-      .chain
-  end
-end
-ruby
-
-    expected = <<EXPECTED
-<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">meth</span>
-  <span class="ruby-identifier">variable</span> <span class="ruby-comment"># comment</span>
-    .<span class="ruby-identifier">chain</span>
-<span class="ruby-keyword">end</span>
-EXPECTED
-    expected = expected.rstrip
-
-    @parser.scan
-
-    foo = @store.find_class_named 'Foo'
-    meth = foo.method_list.first
-
-    assert_equal 'meth',     meth.name
-    assert_equal @top_level, meth.file
-
-    markup_code = meth.markup_code.sub(/^.*\n/, '')
-    assert_equal expected, markup_code
-  end
-
-  def test_parse_redefined_op_with_constant
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-
-    comment = RDoc::Comment.new '', @top_level
-
-    util_parser <<ruby
-def meth
-  Integer::**()
-  return Integer::**()
-  break Integer::**()
-  case Integer::**()
-  when Integer::**()
-  end
-  while Integer::**()
-  end
-  yield Integer::**()
-  defined? Integer::**()
-  if Integer::**()
-  end
-end
-ruby
-
-    tk = @parser.get_tk
-
-    @parser.parse_method klass, RDoc::Parser::Ruby::NORMAL, tk, comment
-
-    meth = klass.method_list.first
-    assert_equal 'meth',     meth.name
-  end
-
-  def test_parse_alias
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-
-    util_parser "alias :next= :bar"
-
-    tk = @parser.get_tk
-
-    alas = @parser.parse_alias klass, RDoc::Parser::Ruby::NORMAL, tk, 'comment'
-
-    assert_equal 'bar',      alas.old_name
-    assert_equal 'next=',    alas.new_name
-    assert_equal klass,      alas.parent
-    assert_equal 'comment',  alas.comment
-    assert_equal @top_level, alas.file
-    assert_equal 1,          alas.line
-  end
-
-  def test_parse_alias_singleton
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-
-    util_parser "alias :next= :bar"
-
-    tk = @parser.get_tk
-
-    alas = @parser.parse_alias klass, RDoc::Parser::Ruby::SINGLE, tk, 'comment'
-
-    assert_equal 'bar',      alas.old_name
-    assert_equal 'next=',    alas.new_name
-    assert_equal klass,      alas.parent
-    assert_equal 'comment',  alas.comment
-    assert_equal @top_level, alas.file
-    assert                   alas.singleton
-  end
-
-  def test_parse_alias_stopdoc
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-    klass.stop_doc
-
-    util_parser "alias :next= :bar"
-
-    tk = @parser.get_tk
-
-    @parser.parse_alias klass, RDoc::Parser::Ruby::NORMAL, tk, 'comment'
-
-    assert_empty klass.aliases
-    assert_empty klass.unmatched_alias_lists
-  end
-
-  def test_parse_alias_meta
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-
-    util_parser "alias m.chop m"
-
-    tk = @parser.get_tk
-
-    alas = @parser.parse_alias klass, RDoc::Parser::Ruby::NORMAL, tk, 'comment'
-
-    assert_nil alas
-  end
-
-  def test_parse_attr
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-
-    comment = RDoc::Comment.new "##\n# my attr\n", @top_level, :ruby
-
-    util_parser "attr :foo, :bar"
-
-    tk = @parser.get_tk
-
-    @parser.parse_attr klass, RDoc::Parser::Ruby::NORMAL, tk, comment
-
-    assert_equal 1, klass.attributes.length
-
-    foo = klass.attributes.first
-    assert_equal 'foo', foo.name
-    assert_equal 'my attr', foo.comment.text
-    assert_equal @top_level, foo.file
-    assert_equal 1, foo.line
-  end
-
-  def test_parse_attr_stopdoc
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-    klass.stop_doc
-
-    comment = RDoc::Comment.new "##\n# my attr\n", @top_level
-
-    util_parser "attr :foo, :bar"
-
-    tk = @parser.get_tk
-
-    @parser.parse_attr klass, RDoc::Parser::Ruby::NORMAL, tk, comment
-
-    assert_empty klass.attributes
-  end
-
-  def test_parse_attr_accessor
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-
-    comment = RDoc::Comment.new "##\n# my attr\n", @top_level, :ruby
-
-    util_parser "attr_accessor :foo, :bar"
-
-    tk = @parser.get_tk
-
-    @parser.parse_attr_accessor klass, RDoc::Parser::Ruby::NORMAL, tk, comment
-
-    assert_equal 2, klass.attributes.length
-
-    foo = klass.attributes.first
-    assert_equal 'foo', foo.name
-    assert_equal 'RW', foo.rw
-    assert_equal 'my attr', foo.comment.text
-    assert_equal @top_level, foo.file
-    assert_equal 1, foo.line
-
-    bar = klass.attributes.last
-    assert_equal 'bar', bar.name
-    assert_equal 'RW', bar.rw
-    assert_equal 'my attr', bar.comment.text
-  end
-
-  def test_parse_attr_accessor_with_newline
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-
-    comment = RDoc::Comment.new "##\n# my attr\n", @top_level, :ruby
-
-    util_parser "attr_accessor :foo, :bar,\n  :baz,\n  :qux"
-
-    tk = @parser.get_tk
-
-    @parser.parse_attr_accessor klass, RDoc::Parser::Ruby::NORMAL, tk, comment
-
-    assert_equal 4, klass.attributes.length
-
-    foo = klass.attributes[0]
-    assert_equal 'foo', foo.name
-    assert_equal 'RW', foo.rw
-    assert_equal 'my attr', foo.comment.text
-    assert_equal @top_level, foo.file
-    assert_equal 1, foo.line
-
-    bar = klass.attributes[1]
-    assert_equal 'bar', bar.name
-    assert_equal 'RW', bar.rw
-    assert_equal 'my attr', bar.comment.text
-
-    bar = klass.attributes[2]
-    assert_equal 'baz', bar.name
-    assert_equal 'RW', bar.rw
-    assert_equal 'my attr', bar.comment.text
-
-    bar = klass.attributes[3]
-    assert_equal 'qux', bar.name
-    assert_equal 'RW', bar.rw
-    assert_equal 'my attr', bar.comment.text
-  end
-
-  def test_parse_attr_accessor_nodoc
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-
-    comment = RDoc::Comment.new "##\n# my attr\n", @top_level
-
-    util_parser "attr_accessor :foo, :bar # :nodoc:"
-
-    tk = @parser.get_tk
-
-    @parser.parse_attr_accessor klass, RDoc::Parser::Ruby::NORMAL, tk, comment
-
-    assert_equal 0, klass.attributes.length
-  end
-
-  def test_parse_attr_accessor_nodoc_track
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-
-    comment = RDoc::Comment.new "##\n# my attr\n", @top_level
-
-    @options.visibility = :nodoc
-
-    util_parser "attr_accessor :foo, :bar # :nodoc:"
-
-    tk = @parser.get_tk
-
-    @parser.parse_attr_accessor klass, RDoc::Parser::Ruby::NORMAL, tk, comment
-
-    refute_empty klass.attributes
-  end
-
-  def test_parse_attr_accessor_stopdoc
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-    klass.stop_doc
-
-    comment = RDoc::Comment.new "##\n# my attr\n", @top_level
-
-    util_parser "attr_accessor :foo, :bar"
-
-    tk = @parser.get_tk
-
-    @parser.parse_attr_accessor klass, RDoc::Parser::Ruby::NORMAL, tk, comment
-
-    assert_empty klass.attributes
-  end
-
-  def test_parse_attr_accessor_writer
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-
-    comment = RDoc::Comment.new "##\n# my attr\n", @top_level, :ruby
-
-    util_parser "attr_writer :foo, :bar"
-
-    tk = @parser.get_tk
-
-    @parser.parse_attr_accessor klass, RDoc::Parser::Ruby::NORMAL, tk, comment
-
-    assert_equal 2, klass.attributes.length
-
-    foo = klass.attributes.first
-    assert_equal 'foo', foo.name
-    assert_equal 'W', foo.rw
-    assert_equal "my attr", foo.comment.text
-    assert_equal @top_level, foo.file
-
-    bar = klass.attributes.last
-    assert_equal 'bar', bar.name
-    assert_equal 'W', bar.rw
-    assert_equal "my attr", bar.comment.text
-  end
-
-  def test_parse_meta_attr
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-
-    comment = RDoc::Comment.new "##\n# :attr: \n# my method\n", @top_level, :ruby
-
-    util_parser "add_my_method :foo, :bar"
-
-    tk = @parser.get_tk
-
-    @parser.parse_meta_attr klass, RDoc::Parser::Ruby::NORMAL, tk, comment
-
-    assert_equal 2, klass.attributes.length
-    foo = klass.attributes.first
-    assert_equal 'foo', foo.name
-    assert_equal 'RW', foo.rw
-    assert_equal "my method", foo.comment.text
-    assert_equal @top_level, foo.file
-  end
-
-  def test_parse_meta_attr_accessor
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-
-    comment =
-      RDoc::Comment.new "##\n# :attr_accessor: \n# my method\n", @top_level, :ruby
-
-    util_parser "add_my_method :foo, :bar"
-
-    tk = @parser.get_tk
-
-    @parser.parse_meta_attr klass, RDoc::Parser::Ruby::NORMAL, tk, comment
-
-    assert_equal 2, klass.attributes.length
-    foo = klass.attributes.first
-    assert_equal 'foo', foo.name
-    assert_equal 'RW', foo.rw
-    assert_equal 'my method', foo.comment.text
-    assert_equal @top_level, foo.file
-  end
-
-  def test_parse_meta_attr_named
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-
-    comment = RDoc::Comment.new "##\n# :attr: foo\n# my method\n", @top_level, :ruby
-
-    util_parser "add_my_method :foo, :bar"
-
-    tk = @parser.get_tk
-
-    @parser.parse_meta_attr klass, RDoc::Parser::Ruby::NORMAL, tk, comment
-
-    assert_equal 1, klass.attributes.length
-    foo = klass.attributes.first
-    assert_equal 'foo', foo.name
-    assert_equal 'RW', foo.rw
-    assert_equal 'my method', foo.comment.text
-    assert_equal @top_level, foo.file
-  end
-
-  def test_parse_meta_attr_reader
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-
-    comment =
-      RDoc::Comment.new "##\n# :attr_reader: \n# my method\n", @top_level, :ruby
-
-    util_parser "add_my_method :foo, :bar"
-
-    tk = @parser.get_tk
-
-    @parser.parse_meta_attr klass, RDoc::Parser::Ruby::NORMAL, tk, comment
-
-    foo = klass.attributes.first
-    assert_equal 'foo', foo.name
-    assert_equal 'R', foo.rw
-    assert_equal 'my method', foo.comment.text
-    assert_equal @top_level, foo.file
-  end
-
-  def test_parse_meta_attr_stopdoc
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-    klass.stop_doc
-
-    comment = RDoc::Comment.new "##\n# :attr: \n# my method\n", @top_level
-
-    util_parser "add_my_method :foo, :bar"
-
-    tk = @parser.get_tk
-
-    @parser.parse_meta_attr klass, RDoc::Parser::Ruby::NORMAL, tk, comment
-
-    assert_empty klass.attributes
-  end
-
-  def test_parse_meta_attr_writer
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-
-    comment =
-      RDoc::Comment.new "##\n# :attr_writer: \n# my method\n", @top_level, :ruby
-
-    util_parser "add_my_method :foo, :bar"
-
-    tk = @parser.get_tk
-
-    @parser.parse_meta_attr klass, RDoc::Parser::Ruby::NORMAL, tk, comment
-
-    foo = klass.attributes.first
-    assert_equal 'foo', foo.name
-    assert_equal 'W', foo.rw
-    assert_equal "my method", foo.comment.text
-    assert_equal @top_level, foo.file
-  end
-
-  def test_parse_class
-    comment = RDoc::Comment.new "##\n# my class\n", @top_level, :ruby
-
-    util_parser "class Foo\nend"
-
-    tk = @parser.get_tk
-
-    @parser.parse_class @top_level, RDoc::Parser::Ruby::NORMAL, tk, comment
-
-    foo = @top_level.classes.first
-    assert_equal 'Foo', foo.full_name
-    assert_equal 'my class', foo.comment.text
-    assert_equal [@top_level], foo.in_files
-    assert_equal 1, foo.line
-  end
-
-  def test_parse_class_singleton
-    comment = RDoc::Comment.new "##\n# my class\n", @top_level
-
-    util_parser <<-RUBY
-class C
-  class << self
-  end
-end
-    RUBY
-
-    tk = @parser.get_tk
-
-    @parser.parse_class @top_level, RDoc::Parser::Ruby::NORMAL, tk, comment
-
-    c = @top_level.classes.first
-    assert_equal 'C', c.full_name
-    assert_equal 1, c.line
-  end
-
-  def test_parse_class_ghost_method
-    util_parser <<-CLASS
-class Foo
-  ##
-  # :method: blah
-  # my method
-end
-    CLASS
-
-    tk = @parser.get_tk
-
-    @parser.parse_class @top_level, RDoc::Parser::Ruby::NORMAL, tk, @comment
-
-    foo = @top_level.classes.first
-    assert_equal 'Foo', foo.full_name
-
-    blah = foo.method_list.first
-    assert_equal 'Foo#blah', blah.full_name
-    assert_equal 3, blah.line
-    assert_equal @top_level, blah.file
-  end
-
-  def test_parse_class_in_a_file_repeatedly
-    @filename = 'a.rb'
-    comment_a = RDoc::Comment.new "# aaa\n", @top_level
-    util_parser "class Foo\nend"
-    tk = @parser.get_tk
-    @parser.parse_class @top_level, RDoc::Parser::Ruby::NORMAL, tk, comment_a
-    comment_b = RDoc::Comment.new "# bbb\n", @top_level
-    util_parser "class Foo\nend"
-    tk = @parser.get_tk
-    @parser.parse_class @top_level, RDoc::Parser::Ruby::NORMAL, tk, comment_b
-
-    @filename = 'b.rb'
-    comment_c = RDoc::Comment.new "# ccc\n", @top_level
-    util_parser "class Foo\nend"
-    tk = @parser.get_tk
-    @parser.parse_class @top_level, RDoc::Parser::Ruby::NORMAL, tk, comment_c
-
-    foo = @top_level.classes.first
-    assert_equal 'Foo', foo.full_name
-    assert_equal [[comment_a, @top_level],
-                  [comment_b, @top_level],
-                  [comment_c, @top_level]], foo.comment_location
-    assert_equal [@top_level], foo.in_files
-    assert_equal 1, foo.line
-  end
-
-  def test_parse_class_ghost_method_yields
-    util_parser <<-CLASS
-class Foo
-  ##
-  # :method:
-  # :call-seq:
-  #   yields(name)
-end
-    CLASS
-
-    tk = @parser.get_tk
-
-    @parser.parse_class @top_level, RDoc::Parser::Ruby::NORMAL, tk, @comment
-
-    foo = @top_level.classes.first
-    assert_equal 'Foo', foo.full_name
-
-    blah = foo.method_list.first
-    assert_equal 'Foo#yields', blah.full_name
-    assert_equal 'yields(name)', blah.call_seq
-    assert_equal 3, blah.line
-    assert_equal @top_level, blah.file
-  end
-
-  def test_parse_call_syntax_sugar_for_constant
-    util_parser <<-CODE
-Foo = proc{}
-Foo::()
-    CODE
-
-    assert_nothing_raised do
-      @parser.scan
-    end
-  end
-
-  def test_parse_class_multi_ghost_methods
-    util_parser <<-'CLASS'
-class Foo
-  ##
-  # :method: one
-  #
-  # my method
-
-  ##
-  # :method: two
-  #
-  # my method
-
-  [:one, :two].each do |t|
-    eval("def #{t}; \"#{t}\"; end")
-  end
-end
-    CLASS
-
-    tk = @parser.get_tk
-
-    @parser.parse_class @top_level, RDoc::Parser::Ruby::NORMAL, tk, @comment
-
-    foo = @top_level.classes.first
-    assert_equal 'Foo', foo.full_name
-
-    assert_equal 2, foo.method_list.length
-  end
-
-  def test_parse_class_nodoc
-    comment = RDoc::Comment.new "##\n# my class\n", @top_level
-
-    util_parser "class Foo # :nodoc:\nend"
-
-    tk = @parser.get_tk
-
-    @parser.parse_class @top_level, RDoc::Parser::Ruby::NORMAL, tk, comment
-
-    foo = @top_level.classes.first
-    assert_equal 'Foo', foo.full_name
-    assert_empty foo.comment
-    assert_equal [@top_level], foo.in_files
-    assert_equal 1, foo.line
-  end
-
-  def test_parse_class_single_root
-    comment = RDoc::Comment.new "##\n# my class\n", @top_level
-
-    util_parser "class << ::Foo\nend"
-
-    tk = @parser.get_tk
-
-    @parser.parse_class @top_level, RDoc::Parser::Ruby::NORMAL, tk, comment
-
-    foo = @store.all_modules.first
-    assert_equal 'Foo', foo.full_name
-  end
-
-  def test_parse_class_stopdoc
-    @top_level.stop_doc
-
-    comment = RDoc::Comment.new "##\n# my class\n", @top_level
-
-    util_parser "class Foo\nend"
-
-    tk = @parser.get_tk
-
-    @parser.parse_class @top_level, RDoc::Parser::Ruby::NORMAL, tk, comment
-
-    assert_empty @top_level.classes.first.comment
-  end
-
-  def test_parse_class_lower_name_warning
-    @options.verbosity = 2
-    stds = capture_output do
-      util_parser "class foo\nend"
-      tk = @parser.get_tk
-      @parser.parse_class @top_level, RDoc::Parser::Ruby::NORMAL, tk, @comment
-    end
-    err = stds[1]
-    assert_match(/Expected class name or '<<\'\. Got/, err)
-  end
-
-  def test_parse_syntax_error_code
-    @options.verbosity = 2
-    stds = capture_output do
-      begin
-        util_parser <<INVALID_CODE
-# invalid class name
-class Invalid::@@Code
-end
-INVALID_CODE
-        @parser.scan
-      rescue
-      end
-    end
-    err = stds[1]
-
-    expected = <<EXPECTED
-RDoc::Parser::Ruby failure around line 2 of
-#{@filename}
-
-class Invalid::@@Code
-EXPECTED
-
-    assert_match(expected, err)
-  end
-
-  def test_parse_multi_ghost_methods
-    util_parser <<-'CLASS'
-class Foo
-  ##
-  # :method: one
-  #
-  # my method
-
-  ##
-  # :method: two
-  #
-  # my method
-
-  [:one, :two].each do |t|
-    eval("def #{t}; \"#{t}\"; end")
-  end
-end
-    CLASS
-
-    tk = @parser.get_tk
-
-    @parser.parse_class @top_level, RDoc::Parser::Ruby::NORMAL, tk, @comment
-
-    foo = @top_level.classes.first
-    assert_equal 'Foo', foo.full_name
-
-    assert_equal 2, foo.method_list.length
-  end
-
-  def test_parse_const_fail_w_meta
-    util_parser <<-CLASS
-class ConstFailMeta
-  ##
-  # :attr: one
-  #
-  # an attribute
-
-  OtherModule.define_attr(self, :one)
-end
-    CLASS
-
-    tk = @parser.get_tk
-
-    @parser.parse_class @top_level, RDoc::Parser::Ruby::NORMAL, tk, @comment
-
-    const_fail_meta = @top_level.classes.first
-    assert_equal 'ConstFailMeta', const_fail_meta.full_name
-
-    assert_equal 1, const_fail_meta.attributes.length
-  end
-
-  def test_parse_class_nested_superclass
-    foo = @top_level.add_module RDoc::NormalModule, 'Foo'
-
-    util_parser "class Bar < Super\nend"
-
-    tk = @parser.get_tk
-
-    @parser.parse_class foo, RDoc::Parser::Ruby::NORMAL, tk, @comment
-
-    bar = foo.classes.first
-    assert_equal 'Super', bar.superclass
-  end
-
-  def test_parse_module
-    comment = RDoc::Comment.new "##\n# my module\n", @top_level, :ruby
-
-    util_parser "module Foo\nend"
-
-    tk = @parser.get_tk
-
-    @parser.parse_module @top_level, RDoc::Parser::Ruby::NORMAL, tk, comment
-
-    foo = @top_level.modules.first
-    assert_equal 'Foo', foo.full_name
-    assert_equal 'my module', foo.comment.text
-  end
-
-  def test_parse_module_nodoc
-    @top_level.stop_doc
-
-    comment = RDoc::Comment.new "##\n# my module\n", @top_level
-
-    util_parser "module Foo # :nodoc:\nend"
-
-    tk = @parser.get_tk
-
-    @parser.parse_module @top_level, RDoc::Parser::Ruby::NORMAL, tk, comment
-
-    foo = @top_level.modules.first
-    assert_equal 'Foo', foo.full_name
-    assert_empty foo.comment
-  end
-
-  def test_parse_module_stopdoc
-    @top_level.stop_doc
-
-    comment = RDoc::Comment.new "##\n# my module\n", @top_level
-
-    util_parser "module Foo\nend"
-
-    tk = @parser.get_tk
-
-    @parser.parse_module @top_level, RDoc::Parser::Ruby::NORMAL, tk, comment
-
-    foo = @top_level.modules.first
-    assert_equal 'Foo', foo.full_name
-    assert_empty foo.comment
-  end
-
-  def test_parse_class_colon3
-    code = <<-CODE
-class A
-  class ::B
-  end
-end
-    CODE
-
-    util_parser code
-
-    @parser.parse_class @top_level, false, @parser.get_tk, @comment
-
-    assert_equal %w[A B], @store.all_classes.map { |c| c.full_name }.sort
-  end
-
-  def test_parse_class_colon3_self_reference
-    code = <<-CODE
-class A::B
-  class ::A
-  end
-end
-    CODE
-
-    util_parser code
-
-    @parser.parse_class @top_level, false, @parser.get_tk, @comment
-
-    assert_equal %w[A A::B], @store.all_classes.map { |c| c.full_name }.sort
-  end
-
-  def test_parse_class_single
-    code = <<-CODE
-class A
-  class << B
-  end
-  class << d = Object.new
-    def foo; end
-    alias bar foo
-  end
-end
-    CODE
-
-    util_parser code
-
-    @parser.parse_class @top_level, false, @parser.get_tk, @comment
-
-    assert_equal %w[A], @store.all_classes.map { |c| c.full_name }
-
-    modules = @store.all_modules.sort_by { |c| c.full_name }
-    assert_equal %w[A::B A::d], modules.map { |c| c.full_name }
-
-    b = modules.first
-    assert_equal 2,  b.line
-
-    # make sure method/alias was not added to enclosing class/module
-    a = @store.classes_hash['A']
-    assert_empty a.method_list
-
-    # make sure non-constant-named module will be removed from documentation
-    d = @store.modules_hash['A::d']
-    assert d.remove_from_documentation?
-  end
-
-  def test_parse_class_single_gvar
-    code = <<-CODE
-class << $g
-  def m
-  end
-end
-    CODE
-
-    util_parser code
-
-    @parser.parse_class @top_level, false, @parser.get_tk, ''
-
-    assert_empty @store.all_classes
-    mod = @store.all_modules.first
-
-    refute mod.document_self
-
-    assert_empty mod.method_list
-  end
-
-  # TODO this is really a Context#add_class test
-  def test_parse_class_object
-    code = <<-CODE
-module A
-  class B
-  end
-  class Object
-  end
-  class C < Object
-  end
-end
-    CODE
-
-    util_parser code
-
-    @parser.parse_module @top_level, false, @parser.get_tk, @comment
-
-    assert_equal %w[A],
-      @store.all_modules.map { |c| c.full_name }
-    assert_equal %w[A::B A::C A::Object],
-      @store.all_classes.map { |c| c.full_name }.sort
-
-    assert_equal 'Object',    @store.classes_hash['A::B'].superclass
-    assert_equal 'Object',    @store.classes_hash['A::Object'].superclass
-    assert_equal 'A::Object', @store.classes_hash['A::C'].superclass.full_name
-  end
-
-  def test_parse_class_mistaken_for_module
-    # The code below is not strictly legal Ruby (Foo must have been defined
-    # before Foo::Bar is encountered), but RDoc might encounter Foo::Bar
-    # before Foo if they live in different files.
-
-    code = <<-RUBY
-class Foo::Bar
-end
-
-module Foo::Baz
-end
-
-class Foo
-end
-    RUBY
-
-    util_parser code
-
-    @parser.scan
-
-    assert_equal %w[Foo::Baz], @store.modules_hash.keys
-    assert_empty @top_level.modules
-
-    foo = @top_level.classes.first
-    assert_equal 'Foo', foo.full_name
-
-    bar = foo.classes.first
-    assert_equal 'Foo::Bar', bar.full_name
-
-    baz = foo.modules.first
-    assert_equal 'Foo::Baz', baz.full_name
-  end
-
-  def test_parse_class_definition_encountered_after_class_reference
-    # The code below is not legal Ruby (Foo must have been defined before
-    # Foo.bar is encountered), but RDoc might encounter Foo.bar before Foo if
-    # they live in different files.
-
-    code = <<-EOF
-def Foo.bar
-end
-
-class Foo < IO
-end
-    EOF
-
-    util_parser code
-
-    @parser.scan
-
-    assert_empty @store.modules_hash
-    assert_empty @store.all_modules
-
-    foo = @top_level.classes.first
-    assert_equal 'Foo', foo.full_name
-    assert_equal 'IO', foo.superclass
-
-    bar = foo.method_list.first
-    assert_equal 'bar', bar.name
-  end
-
-  def test_parse_module_relative_to_top_level_namespace
-    comment = RDoc::Comment.new <<-EOF, @top_level
-#
-# Weirdly named module
-#
-EOF
-
-    code = <<-EOF
-#{comment.text}
-module ::Foo
-  class Helper
-  end
-end
-EOF
-
-    util_parser code
-    @parser.scan()
-
-    foo = @top_level.modules.first
-    assert_equal 'Foo', foo.full_name
-    assert_equal 'Weirdly named module', foo.comment.text
-
-    helper = foo.classes.first
-    assert_equal 'Foo::Helper', helper.full_name
-  end
-
-  def test_parse_comment_attr
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-
-    comment = RDoc::Comment.new "##\n# :attr: foo\n# my attr\n", @top_level, :ruby
-
-    util_parser "\n"
-
-    tk = @parser.get_tk
-
-    @parser.parse_comment klass, tk, comment
-
-    foo = klass.attributes.first
-    assert_equal 'foo',      foo.name
-    assert_equal 'RW',       foo.rw
-    assert_equal 'my attr',  foo.comment.text
-    assert_equal @top_level, foo.file
-    assert_equal 1,          foo.line
-
-    assert_equal true,       foo.document_children
-    assert_equal true,       foo.document_self
-    assert_equal false,      foo.done_documenting
-    assert_equal false,      foo.force_documentation
-    assert_equal klass,      foo.parent
-    assert_equal :public,    foo.visibility
-    assert_equal "\n",       foo.text
-
-    assert_equal klass.current_section, foo.section
-  end
-
-  def test_parse_comment_attr_attr_reader
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-
-    comment = RDoc::Comment.new "##\n# :attr_reader: foo\n", @top_level
-
-    util_parser "\n"
-
-    tk = @parser.get_tk
-
-    @parser.parse_comment klass, tk, comment
-
-    foo = klass.attributes.first
-    assert_equal 'foo',      foo.name
-    assert_equal 'R',        foo.rw
-  end
-
-  def test_parse_comment_attr_stopdoc
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-    klass.stop_doc
-
-    comment = RDoc::Comment.new "##\n# :attr: foo\n# my attr\n", @top_level
-
-    util_parser "\n"
-
-    tk = @parser.get_tk
-
-    @parser.parse_comment klass, tk, comment
-
-    assert_empty klass.attributes
-  end
-
-  def test_parse_comment_method
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-
-    comment = RDoc::Comment.new "##\n# :method: foo\n# my method\n", @top_level, :ruby
-
-    util_parser "\n"
-
-    tk = @parser.get_tk
-
-    @parser.parse_comment klass, tk, comment
-
-    foo = klass.method_list.first
-    assert_equal 'foo',       foo.name
-    assert_equal 'my method', foo.comment.text
-    assert_equal @top_level,  foo.file
-    assert_equal 2,           foo.line
-
-    assert_equal [],          foo.aliases
-    assert_nil                foo.block_params
-    assert_nil                foo.call_seq
-    assert_nil                foo.is_alias_for
-    assert_equal true,        foo.document_children
-    assert_equal true,        foo.document_self
-    assert_equal '',          foo.params
-    assert_equal false,       foo.done_documenting
-    assert_equal false,       foo.dont_rename_initialize
-    assert_equal false,       foo.force_documentation
-    assert_equal klass,       foo.parent
-    assert_equal false,       foo.singleton
-    assert_equal :public,     foo.visibility
-    assert_equal "\n",        foo.text
-    assert_equal klass.current_section, foo.section
-
-    stream = [
-      {
-        :line_no => 2, :char_no => 1, :kind => :on_comment,
-        :text => "# File #{@top_level.relative_name}, line 2"
-      },
-      { :line_no => 0, :char_no => 0, :kind => :on_nl, :text => "\n" },
-      { :line_no => 1, :char_no => 1, :kind => :on_sp, :text => '' }
-    ]
-    parsed_stream = foo.token_stream.map { |t|
-      {
-        :line_no => t[:line_no],
-        :char_no => t[:char_no],
-        :kind => t[:kind],
-        :text => t[:text]
-      }
-    }
-
-    assert_equal stream, parsed_stream
-  end
-
-  def test_parse_comment_method_args
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-
-
-    util_parser "\n"
-
-    tk = @parser.get_tk
-
-    @parser.parse_comment klass, tk,
-                          comment("##\n# :method: foo\n# :args: a, b\n")
-
-    foo = klass.method_list.first
-    assert_equal 'foo',  foo.name
-    assert_equal 'a, b', foo.params
-  end
-
-  def test_parse_comment_method_stopdoc
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-    klass.stop_doc
-
-    comment = RDoc::Comment.new "##\n# :method: foo\n# my method\n", @top_level
-
-    util_parser "\n"
-
-    tk = @parser.get_tk
-
-    @parser.parse_comment klass, tk, comment
-
-    assert_empty klass.method_list
-  end
-
-  def test_parse_constant
-    klass = @top_level.add_class RDoc::NormalClass, 'Foo'
-
-    util_parser "A = v"
-
-    tk = @parser.get_tk
-
-    @parser.parse_constant klass, tk, @comment
-
-    foo = klass.constants.first
-
-    assert_equal 'A', foo.name
-    assert_equal @top_level, foo.file
-    assert_equal 1, foo.line
-  end
-
-  def test_parse_constant_attrasgn
-    klass = @top_level.add_class RDoc::NormalClass, 'Foo'
-
-    util_parser "A[k] = v"
-
-    tk = @parser.get_tk
-
-    @parser.parse_constant klass, tk, @comment
-
-    assert klass.constants.empty?
-  end
-
-  def test_parse_constant_alias
-    klass = @top_level.add_class RDoc::NormalClass, 'Foo'
-    klass.add_class RDoc::NormalClass, 'B'
-
-    util_parser "A = B"
-
-    tk = @parser.get_tk
-
-    @parser.parse_constant klass, tk, @comment
-
-    assert_equal [], klass.modules.map(&:full_name)
-    assert_equal ['Foo::B', 'Foo::A'], klass.classes.map(&:full_name)
-    assert_equal ['Foo::A'], klass.constants.map(&:full_name)
-    assert_equal 'Foo::A', klass.find_module_named('A').full_name
-  end
-
-  def test_parse_constant_alias_same_name
-    foo = @top_level.add_class RDoc::NormalClass, 'Foo'
-    @top_level.add_class RDoc::NormalClass, 'Bar'
-    bar = foo.add_class RDoc::NormalClass, 'Bar'
-
-    assert @store.find_class_or_module('::Bar')
-
-    util_parser "A = ::Bar"
-
-    tk = @parser.get_tk
-
-    @parser.parse_constant foo, tk, @comment
-
-    assert_equal 'A', bar.find_module_named('A').full_name
-  end
-
-  def test_parse_constant_in_method
-    klass = @top_level.add_class RDoc::NormalClass, 'Foo'
-
-    util_parser 'A::B = v'
-
-    tk = @parser.get_tk
-
-    @parser.parse_constant klass, tk, @comment, true
-
-    assert_empty klass.constants
-
-    assert_empty @store.modules_hash.keys
-    assert_equal %w[Foo], @store.classes_hash.keys
-  end
-
-  def test_parse_constant_rescue
-    klass = @top_level.add_class RDoc::NormalClass, 'Foo'
-
-    util_parser "A => e"
-
-    tk = @parser.get_tk
-
-    @parser.parse_constant klass, tk, @comment
-
-    assert_empty klass.constants
-    assert_empty klass.modules
-
-    assert_empty @store.modules_hash.keys
-    assert_equal %w[Foo], @store.classes_hash.keys
-  end
-
-  def test_parse_constant_stopdoc
-    klass = @top_level.add_class RDoc::NormalClass, 'Foo'
-    klass.stop_doc
-
-    util_parser "A = v"
-
-    tk = @parser.get_tk
-
-    @parser.parse_constant klass, tk, @comment
-
-    assert_empty klass.constants
-  end
-
-  def test_parse_comment_nested
-    content = <<-CONTENT
-A::B::C = 1
-    CONTENT
-
-    util_parser content
-
-    tk = @parser.get_tk
-
-    parsed = @parser.parse_constant @top_level, tk, 'comment'
-
-    assert parsed
-
-    a = @top_level.find_module_named 'A'
-    b = a.find_module_named 'B'
-    c = b.constants.first
-
-    assert_equal 'A::B::C', c.full_name
-    assert_equal 'comment', c.comment
-  end
-
-  def test_parse_class_the_same_of_outside
-    util_parser <<-RUBY
-module A
-  class A::B
-  end
-end
-    RUBY
-
-    @parser.scan
-
-    assert_includes @store.modules_hash, 'A'
-    module_a = @store.find_module_named 'A'
-    refute_empty module_a.classes_hash
-    assert_includes module_a.classes_hash, 'B'
-    refute_includes module_a.classes_hash, 'A'
-  end
-
-  def test_parse_constant_the_same_of_outside
-    util_parser <<-RUBY
-module A
-  class B
-    class C
-    end
-  end
-
-  def self.foo
-    A::B::C
-  end
-end
-    RUBY
-
-    expected = <<EXPECTED
-<span class="ruby-keyword">def</span> <span class="ruby-keyword">self</span>.<span class="ruby-identifier ruby-title">foo</span>
-  <span class="ruby-constant">A</span><span class="ruby-operator">::</span><span class="ruby-constant">B</span><span class="ruby-operator">::</span><span class="ruby-constant">C</span>
-<span class="ruby-keyword">end</span>
-EXPECTED
-    expected = expected.rstrip
-
-    @parser.scan
-
-    module_a = @store.find_module_named 'A'
-    foo = module_a.method_list.first
-    markup_code = foo.markup_code.sub(/^.*\n/, '')
-    assert_equal expected, markup_code
-  end
-
-  def test_parse_constant_with_bracket
-    util_parser <<-RUBY
-class Klass
-end
-
-class Klass2
-  CONSTANT = Klass
-end
-
-class Klass3
-  CONSTANT_2 = {}
-  CONSTANT_2[1] = Klass
-end
-    RUBY
-
-    @parser.scan
-
-    klass = @store.find_class_named 'Klass'
-    klass2 = @store.find_class_named 'Klass2'
-    klass3 = @store.find_class_named 'Klass3'
-    assert_equal klass, klass2.constants.first.is_alias_for
-    refute_equal klass, klass3.constants.first.is_alias_for
-    assert_nil klass3.find_module_named 'CONSTANT_2'
-  end
-
-  def test_parse_extend_or_include_extend
-    klass = RDoc::NormalClass.new 'C'
-    klass.parent = @top_level
-
-    comment = RDoc::Comment.new "# my extend\n", @top_level, :ruby
-
-    util_parser "extend I"
-
-    @parser.get_tk # extend
-
-    @parser.parse_extend_or_include RDoc::Extend, klass, comment
-
-    assert_equal 1, klass.extends.length
-
-    ext = klass.extends.first
-    assert_equal 'I', ext.name
-    assert_equal 'my extend', ext.comment.text
-    assert_equal @top_level, ext.file
-  end
-
-  def test_parse_extend_or_include_include
-    klass = RDoc::NormalClass.new 'C'
-    klass.parent = @top_level
-
-    comment = RDoc::Comment.new "# my include\n", @top_level, :ruby
-
-    util_parser "include I"
-
-    @parser.get_tk # include
-
-    @parser.parse_extend_or_include RDoc::Include, klass, comment
-
-    assert_equal 1, klass.includes.length
-
-    incl = klass.includes.first
-    assert_equal 'I', incl.name
-    assert_equal 'my include', incl.comment.text
-    assert_equal @top_level, incl.file
-  end
-
-  def test_parse_meta_method
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-
-    comment = RDoc::Comment.new "##\n# my method\n", @top_level, :ruby
-
-    util_parser "add_my_method :foo, :bar\nadd_my_method :baz"
-
-    tk = @parser.get_tk
-
-    @parser.parse_meta_method klass, RDoc::Parser::Ruby::NORMAL, tk, comment
-
-    foo = klass.method_list.first
-    assert_equal 'foo',       foo.name
-    assert_equal 'my method', foo.comment.text
-    assert_equal @top_level,  foo.file
-    assert_equal 1,           foo.line
-
-    assert_equal [],      foo.aliases
-    assert_nil            foo.block_params
-    assert_nil            foo.call_seq
-    assert_equal true,    foo.document_children
-    assert_equal true,    foo.document_self
-    assert_equal false,   foo.done_documenting
-    assert_equal false,   foo.dont_rename_initialize
-    assert_equal false,   foo.force_documentation
-    assert_nil            foo.is_alias_for
-    assert_equal '',      foo.params
-    assert_equal klass,   foo.parent
-    assert_equal false,   foo.singleton
-    assert_equal 'add_my_method :foo', foo.text
-    assert_equal :public, foo.visibility
-    assert_equal klass.current_section, foo.section
-
-    stream = [
-      {
-        :line_no => 1, :char_no => 1, :kind => :on_comment,
-        :text => "# File #{@top_level.relative_name}, line 1"
-      },
-      { :line_no => 0, :char_no => 0, :kind => :on_nl, :text => "\n" },
-      { :line_no => 1, :char_no => 1, :kind => :on_sp, :text => '' },
-      { :line_no => 1, :char_no => 0, :kind => :on_ident, :text => 'add_my_method' },
-      { :line_no => 1, :char_no => 13, :kind => :on_sp, :text => ' ' },
-      { :line_no => 1, :char_no => 14, :kind => :on_symbol, :text => ':foo' },
-      { :line_no => 1, :char_no => 18, :kind => :on_comma, :text => ',' },
-      { :line_no => 1, :char_no => 19, :kind => :on_sp, :text => ' ' },
-      { :line_no => 1, :char_no => 20, :kind => :on_symbol, :text => ':bar' },
-      { :line_no => 1, :char_no => 24, :kind => :on_nl, :text => "\n" }
-    ]
-    parsed_stream = foo.token_stream.map { |t|
-      {
-        :line_no => t[:line_no],
-        :char_no => t[:char_no],
-        :kind => t[:kind],
-        :text => t[:text]
-      }
-    }
-
-    assert_equal stream, parsed_stream
-  end
-
-  def test_parse_meta_method_block
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-
-    comment = RDoc::Comment.new "##\n# my method\n", @top_level
-
-    content = <<-CONTENT
-inline(:my_method) do |*args|
-  "this method causes z to disappear"
-end
-    CONTENT
-
-    util_parser content
-
-    tk = @parser.get_tk
-
-    @parser.parse_meta_method klass, RDoc::Parser::Ruby::NORMAL, tk, comment
-
-    rest = { :line_no => 3, :char_no => 3, :kind => :on_nl, :text => "\n" }
-    tk = @parser.get_tk
-    tk = { :line_no => tk[:line_no], :char_no => tk[:char_no], :kind => tk[:kind], :text => tk[:text] }
-    assert_equal rest, tk
-  end
-
-  def test_parse_meta_method_define_method
-    klass = RDoc::NormalClass.new 'Foo'
-    comment = RDoc::Comment.new "##\n# my method\n", @top_level, :ruby
-
-    util_parser "define_method :foo do end"
-
-    tk = @parser.get_tk
-
-    @parser.parse_meta_method klass, RDoc::Parser::Ruby::NORMAL, tk, comment
-
-    foo = klass.method_list.first
-    assert_equal 'foo', foo.name
-    assert_equal 'my method', foo.comment.text
-    assert_equal @top_level,  foo.file
-  end
-
-  def test_parse_meta_method_name
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-
-    comment =
-      RDoc::Comment.new "##\n# :method: woo_hoo!\n# my method\n", @top_level, :ruby
-
-    util_parser "add_my_method :foo, :bar\nadd_my_method :baz"
-
-    tk = @parser.get_tk
-
-    @parser.parse_meta_method klass, RDoc::Parser::Ruby::NORMAL, tk, comment
-
-    foo = klass.method_list.first
-    assert_equal 'woo_hoo!',  foo.name
-    assert_equal 'my method', foo.comment.text
-    assert_equal @top_level,  foo.file
-  end
-
-  def test_parse_meta_method_singleton
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-
-    comment =
-      RDoc::Comment.new "##\n# :singleton-method:\n# my method\n", @top_level, :ruby
-
-    util_parser "add_my_method :foo, :bar\nadd_my_method :baz"
-
-    tk = @parser.get_tk
-
-    @parser.parse_meta_method klass, RDoc::Parser::Ruby::NORMAL, tk, comment
-
-    foo = klass.method_list.first
-    assert_equal 'foo', foo.name
-    assert_equal true, foo.singleton, 'singleton method'
-    assert_equal 'my method', foo.comment.text
-    assert_equal @top_level,  foo.file
-  end
-
-  def test_parse_meta_method_singleton_name
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-
-    comment =
-      RDoc::Comment.new "##\n# :singleton-method: woo_hoo!\n# my method\n",
-                        @top_level, :ruby
-
-    util_parser "add_my_method :foo, :bar\nadd_my_method :baz"
-
-    tk = @parser.get_tk
-
-    @parser.parse_meta_method klass, RDoc::Parser::Ruby::NORMAL, tk, comment
-
-    foo = klass.method_list.first
-    assert_equal 'woo_hoo!', foo.name
-    assert_equal true, foo.singleton, 'singleton method'
-    assert_equal 'my method', foo.comment.text
-    assert_equal @top_level,  foo.file
-  end
-
-  def test_parse_meta_method_string_name
-    klass = RDoc::NormalClass.new 'Foo'
-    comment = RDoc::Comment.new "##\n# my method\n", @top_level, :ruby
-
-    util_parser "add_my_method 'foo'"
-
-    tk = @parser.get_tk
-
-    @parser.parse_meta_method klass, RDoc::Parser::Ruby::NORMAL, tk, comment
-
-    foo = klass.method_list.first
-    assert_equal 'foo', foo.name
-    assert_equal 'my method', foo.comment.text
-    assert_equal @top_level,  foo.file
-  end
-
-  def test_parse_meta_method_stopdoc
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-    klass.stop_doc
-
-    comment = RDoc::Comment.new "##\n# my method\n", @top_level
-
-    util_parser "add_my_method :foo, :bar\nadd_my_method :baz"
-
-    tk = @parser.get_tk
-
-    @parser.parse_meta_method klass, RDoc::Parser::Ruby::NORMAL, tk, comment
-
-    assert_empty klass.method_list
-  end
-
-  def test_parse_meta_method_unknown
-    klass = RDoc::NormalClass.new 'Foo'
-    comment = RDoc::Comment.new "##\n# my method\n", @top_level, :ruby
-
-    util_parser "add_my_method ('foo')"
-
-    tk = @parser.get_tk
-
-    @parser.parse_meta_method klass, RDoc::Parser::Ruby::NORMAL, tk, comment
-
-    foo = klass.method_list.first
-    assert_equal 'unknown', foo.name
-    assert_equal 'my method', foo.comment.text
-    assert_equal @top_level,  foo.file
-  end
-
-  def test_parse_method
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-
-    comment = RDoc::Comment.new "##\n# my method\n", @top_level, :ruby
-
-    util_parser "def foo() :bar end"
-
-    tk = @parser.get_tk
-
-    @parser.parse_method klass, RDoc::Parser::Ruby::NORMAL, tk, comment
-
-    foo = klass.method_list.first
-    assert_equal 'foo',       foo.name
-    assert_equal 'my method', foo.comment.text
-    assert_equal @top_level,  foo.file
-    assert_equal 1,           foo.line
-
-    assert_equal [],        foo.aliases
-    assert_nil              foo.block_params
-    assert_nil              foo.call_seq
-    assert_nil              foo.is_alias_for
-    assert_equal true,      foo.document_children
-    assert_equal true,      foo.document_self
-    assert_equal '()',      foo.params
-    assert_equal false,     foo.done_documenting
-    assert_equal false,     foo.dont_rename_initialize
-    assert_equal false,     foo.force_documentation
-    assert_equal klass,     foo.parent
-    assert_equal false,     foo.singleton
-    assert_equal :public,   foo.visibility
-    assert_equal 'def foo', foo.text
-    assert_equal klass.current_section, foo.section
-
-    stream = [
-      {
-        :line_no => 1, :char_no => 1, :kind => :on_comment,
-        :text => "# File #{@top_level.relative_name}, line 1" },
-      { :line_no => 0, :char_no => 0, :kind => :on_nl, :text => "\n" },
-      { :line_no => 1, :char_no => 1, :kind => :on_sp, :text => '' },
-      { :line_no => 1, :char_no => 0, :kind => :on_kw, :text => 'def' },
-      { :line_no => 1, :char_no => 3, :kind => :on_sp, :text => ' ' },
-      { :line_no => 1, :char_no => 4, :kind => :on_ident, :text => 'foo' },
-      { :line_no => 1, :char_no => 7, :kind => :on_lparen, :text => '(' },
-      { :line_no => 1, :char_no => 8, :kind => :on_rparen, :text => ')' },
-      { :line_no => 1, :char_no => 9, :kind => :on_sp, :text => ' ' },
-      { :line_no => 1, :char_no => 10, :kind => :on_symbol, :text => ':bar' },
-      { :line_no => 1, :char_no => 14, :kind => :on_sp, :text => ' ' },
-      { :line_no => 1, :char_no => 15, :kind => :on_kw, :text => 'end' }
-    ]
-    parsed_stream = foo.token_stream.map { |t|
-      {
-        :line_no => t[:line_no],
-        :char_no => t[:char_no],
-        :kind => t[:kind],
-        :text => t[:text]
-      }
-    }
-    assert_equal stream, parsed_stream
-  end
-
-  def test_parse_redefinable_methods
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-
-    comment = RDoc::Comment.new "", @top_level
-
-    redefinable_ops = %w[| ^ & <=> == === =~ > >= < <= << >> + - * / % ** ~ +@ -@ [] []= ` !  != !~]
-    redefinable_ops.each do |redefinable_op|
-      util_parser "def #{redefinable_op}\nend\n"
-      tk = @parser.get_tk
-      @parser.parse_method klass, RDoc::Parser::Ruby::NORMAL, tk, comment
-    end
-
-    klass.method_list.each do |method|
-      assert_equal :on_ident, method.token_stream[5][:kind]
-      assert_includes redefinable_ops, method.token_stream[5][:text]
-    end
-  end
-
-  def test_parse_method_with_args_directive
-    util_parser <<-RUBY
-class C
-  def meth_with_args_after # :args: a, b, c
-  end
-
-  ##
-  # :args: d, e, f
-  def meth_with_args_before
-end
-    RUBY
-
-    @parser.scan
-
-    c = @store.find_class_named 'C'
-
-    assert_equal 'C#meth_with_args_after', c.method_list[0].full_name
-    assert_equal 'a, b, c', c.method_list[0].params
-    assert_equal 'C#meth_with_args_before', c.method_list[1].full_name
-    assert_equal 'd, e, f', c.method_list[1].params
-  end
-
-  def test_parse_method_bracket
-    util_parser <<-RUBY
-class C
-  def []; end
-  def self.[]; end
-  def []=; end
-  def self.[]=; end
-end
-    RUBY
-
-    @parser.scan
-
-    c = @store.find_class_named 'C'
-
-    assert_equal 4, c.method_list.size
-    assert_equal 'C#[]', c.method_list[0].full_name
-    assert_equal 'C::[]', c.method_list[1].full_name
-    assert_equal 'C#[]=', c.method_list[2].full_name
-    assert_equal 'C::[]=', c.method_list[3].full_name
-    assert c.aliases.empty?
-  end
-
-  def test_parse_method_alias
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-
-    util_parser "def m() alias a b; end"
-
-    tk = @parser.get_tk
-
-    @parser.parse_method klass, RDoc::Parser::Ruby::NORMAL, tk, @comment
-
-    assert klass.aliases.empty?
-  end
-
-  def test_parse_method_ampersand
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-
-    util_parser "def self.&\nend"
-
-    tk = @parser.get_tk
-
-    @parser.parse_method klass, RDoc::Parser::Ruby::NORMAL, tk, @comment
-
-    ampersand = klass.method_list.first
-    assert_equal '&', ampersand.name
-    assert            ampersand.singleton
-  end
-
-  def test_parse_method_constant
-    c = RDoc::Constant.new 'CONST', nil, ''
-    m = @top_level.add_class RDoc::NormalModule, 'M'
-    m.add_constant c
-
-    util_parser "def CONST.m() end"
-
-    tk = @parser.get_tk
-
-    @parser.parse_method m, RDoc::Parser::Ruby::NORMAL, tk, @comment
-
-    assert_empty @store.modules_hash.keys
-    assert_equal %w[M], @store.classes_hash.keys
-  end
-
-  def test_parse_method_false
-    util_parser "def false.foo() :bar end"
-
-    tk = @parser.get_tk
-
-    @parser.parse_method @top_level, RDoc::Parser::Ruby::NORMAL, tk, @comment
-
-    klass = @store.find_class_named 'FalseClass'
-
-    foo = klass.method_list.first
-    assert_equal 'foo', foo.name
-  end
-
-  def test_parse_method_funky
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-
-    util_parser "def (blah).foo() :bar end"
-
-    tk = @parser.get_tk
-
-    @parser.parse_method klass, RDoc::Parser::Ruby::NORMAL, tk, @comment
-
-    assert_empty klass.method_list
-  end
-
-  def test_parse_method_gvar
-    util_parser "def $stdout.foo() :bar end"
-
-    tk = @parser.get_tk
-
-    @parser.parse_method @top_level, RDoc::Parser::Ruby::NORMAL, tk, @comment
-
-    assert @top_level.method_list.empty?
-  end
-
-  def test_parse_method_gvar_insane
-    util_parser "def $stdout.foo() class << $other; end; end"
-
-    tk = @parser.get_tk
-
-    @parser.parse_method @top_level, RDoc::Parser::Ruby::NORMAL, tk, @comment
-
-    assert @top_level.method_list.empty?
-
-    assert_empty @store.all_classes
-
-    assert_equal 1, @store.all_modules.length
-
-    refute @store.all_modules.first.document_self
-  end
-
-  def test_parse_method_internal_gvar
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-
-    util_parser "def foo() def $blah.bar() end end"
-
-    tk = @parser.get_tk
-
-    @parser.parse_method klass, RDoc::Parser::Ruby::NORMAL, tk, @comment
-
-    assert_equal 1, klass.method_list.length
-  end
-
-  def test_parse_method_internal_ivar
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-
-    util_parser "def foo() def @blah.bar() end end"
-
-    tk = @parser.get_tk
-
-    @parser.parse_method klass, RDoc::Parser::Ruby::NORMAL, tk, @comment
-
-    assert_equal 1, klass.method_list.length
-  end
-
-  def test_parse_method_internal_lvar
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-
-    util_parser "def foo() def blah.bar() end end"
-
-    tk = @parser.get_tk
-
-    @parser.parse_method klass, RDoc::Parser::Ruby::NORMAL, tk, @comment
-
-    assert_equal 1, klass.method_list.length
-  end
-
-  def test_parse_method_nil
-    util_parser "def nil.foo() :bar end"
-
-    tk = @parser.get_tk
-
-    @parser.parse_method @top_level, RDoc::Parser::Ruby::NORMAL, tk, @comment
-
-    klass = @store.find_class_named 'NilClass'
-
-    foo = klass.method_list.first
-    assert_equal 'foo', foo.name
-  end
-
-  def test_parse_method_nodoc
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-
-    util_parser "def foo # :nodoc:\nend"
-
-    tk = @parser.get_tk
-
-    @parser.parse_method klass, RDoc::Parser::Ruby::NORMAL, tk, comment('')
-
-    assert_empty klass.method_list
-  end
-
-  def test_parse_method_nodoc_track
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-
-    @options.visibility = :nodoc
-
-    util_parser "def foo # :nodoc:\nend"
-
-    tk = @parser.get_tk
-
-    @parser.parse_method klass, RDoc::Parser::Ruby::NORMAL, tk, comment('')
-
-    refute_empty klass.method_list
-  end
-
-  def test_parse_method_no_parens
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-
-    util_parser "def foo arg1, arg2 = {}\nend"
-
-    tk = @parser.get_tk
-
-    @parser.parse_method klass, RDoc::Parser::Ruby::NORMAL, tk, @comment
-
-    foo = klass.method_list.first
-    assert_equal '(arg1, arg2 = {})', foo.params
-    assert_equal @top_level, foo.file
-  end
-
-  def test_parse_method_parameters_comment
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-
-    util_parser "def foo arg1, arg2 # some useful comment\nend"
-
-    tk = @parser.get_tk
-
-    @parser.parse_method klass, RDoc::Parser::Ruby::NORMAL, tk, @comment
-
-    foo = klass.method_list.first
-    assert_equal '(arg1, arg2)', foo.params
-  end
-
-  def test_parse_method_parameters_comment_continue
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-
-    util_parser "def foo arg1, arg2, # some useful comment\narg3\nend"
-
-    tk = @parser.get_tk
-
-    @parser.parse_method klass, RDoc::Parser::Ruby::NORMAL, tk, @comment
-
-    foo = klass.method_list.first
-    assert_equal '(arg1, arg2, arg3)', foo.params
-  end
-
-  def test_parse_method_parameters_with_paren_comment_continue
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-
-    util_parser "def foo(arg1, arg2, # some useful comment\narg3)\nend"
-
-    tk = @parser.get_tk
-
-    @parser.parse_method klass, RDoc::Parser::Ruby::NORMAL, tk, @comment
-
-    foo = klass.method_list.first
-    assert_equal '(arg1, arg2, arg3)', foo.params
-  end
-
-  def test_parse_method_star
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-
-    util_parser "def self.*\nend"
-
-    tk = @parser.get_tk
-
-    @parser.parse_method klass, RDoc::Parser::Ruby::NORMAL, tk, @comment
-
-    ampersand = klass.method_list.first
-    assert_equal '*', ampersand.name
-    assert            ampersand.singleton
-  end
-
-  def test_parse_method_stopdoc
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-    klass.stop_doc
-
-    comment = RDoc::Comment.new "##\n# my method\n", @top_level
-
-    util_parser "def foo() :bar end"
-
-    tk = @parser.get_tk
-
-    @parser.parse_method klass, RDoc::Parser::Ruby::NORMAL, tk, comment
-
-    assert_empty klass.method_list
-  end
-
-  def test_parse_method_toplevel
-    klass = @top_level
-
-    util_parser "def foo arg1, arg2\nend"
-
-    tk = @parser.get_tk
-
-    @parser.parse_method klass, RDoc::Parser::Ruby::NORMAL, tk, @comment
-
-    object = @store.find_class_named 'Object'
-
-    foo = object.method_list.first
-    assert_equal 'Object#foo', foo.full_name
-    assert_equal @top_level, foo.file
-  end
-
-  def test_parse_method_toplevel_class
-    klass = @top_level
-
-    util_parser "def Object.foo arg1, arg2\nend"
-
-    tk = @parser.get_tk
-
-    @parser.parse_method klass, RDoc::Parser::Ruby::NORMAL, tk, @comment
-
-    object = @store.find_class_named 'Object'
-
-    foo = object.method_list.first
-    assert_equal 'Object::foo', foo.full_name
-  end
-
-  def test_parse_method_true
-    util_parser "def true.foo() :bar end"
-
-    tk = @parser.get_tk
-
-    @parser.parse_method @top_level, RDoc::Parser::Ruby::NORMAL, tk, @comment
-
-    klass = @store.find_class_named 'TrueClass'
-
-    foo = klass.method_list.first
-    assert_equal 'foo', foo.name
-  end
-
-  def test_parse_method_utf8
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-
-    method = "def ω() end"
-
-    assert_equal Encoding::UTF_8, method.encoding
-
-    util_parser method
-
-    tk = @parser.get_tk
-
-    @parser.parse_method klass, RDoc::Parser::Ruby::NORMAL, tk, @comment
-
-    omega = klass.method_list.first
-    assert_equal "def \317\211", omega.text
-  end
-
-  def test_parse_method_dummy
-    util_parser ".method() end"
-
-    @parser.parse_method_dummy @top_level
-
-    assert_nil @parser.get_tk
-  end
-
-  def test_parse_method_or_yield_parameters_hash
-    util_parser "({})\n"
-
-    m = RDoc::AnyMethod.new nil, 'm'
-
-    result = @parser.parse_method_or_yield_parameters m
-
-    assert_equal '({})', result
-  end
-
-  def test_parse_statements_class_if
-    util_parser <<-CODE
-module Foo
-  X = if TRUE then
-        ''
-      end
-
-  def blah
-  end
-end
-    CODE
-
-    @parser.parse_statements @top_level, RDoc::Parser::Ruby::NORMAL, nil
-
-    foo = @top_level.modules.first
-    assert_equal 'Foo', foo.full_name, 'module Foo'
-
-    methods = foo.method_list
-    assert_equal 1, methods.length
-    assert_equal 'Foo#blah', methods.first.full_name
-  end
-
-  def test_parse_statements_postfix_if_unless
-    util_parser <<-CODE
-class C
-  def foo
-    1 if nil
-  end
-
-  def bar
-    2 unless nil
-  end
-end
-    CODE
-
-    @parser.parse_statements @top_level, RDoc::Parser::Ruby::NORMAL, nil
-
-    c = @top_level.classes.first
-    assert_equal 'C', c.full_name, 'class C'
-
-    methods = c.method_list
-    assert_equal 2, methods.length
-    assert_equal 'C#foo', methods[0].full_name
-    assert_equal 'C#bar', methods[1].full_name
-  end
-
-  def test_parse_statements_postfix_if_unless_with_expr_mid
-    util_parser <<-CODE
-class A
-  class B
-    def foo
-      return if nil
-    end
-  end
-
-  class C
-  end
-end
-    CODE
-
-    @parser.parse_statements @top_level, RDoc::Parser::Ruby::NORMAL, nil
-
-    a = @top_level.classes.first
-    assert_equal 'A', a.full_name, 'class A'
-    assert_equal 2, a.classes.length
-    b = a.classes[0]
-    assert_equal 'A::B', b.full_name, 'class A::B'
-    c = a.classes[1]
-    assert_equal 'A::C', c.full_name, 'class A::C'
-  end
-
-  def test_parse_statements_class_nested
-    comment = RDoc::Comment.new "##\n# my method\n", @top_level
-
-    util_parser "module Foo\n#{comment.text}class Bar\nend\nend"
-
-    @parser.parse_statements @top_level, RDoc::Parser::Ruby::NORMAL
-
-    foo = @top_level.modules.first
-    assert_equal 'Foo', foo.full_name, 'module Foo'
-
-    bar = foo.classes.first
-    assert_equal 'Foo::Bar', bar.full_name, 'class Foo::Bar'
-    assert_equal 'my method', bar.comment.text
-  end
-
-  def test_parse_statements_def_percent_string_pound
-    util_parser "class C\ndef a\n%r{#}\n%r{\#{}}\nend\ndef b() end\nend"
-
-    @parser.parse_statements @top_level, RDoc::Parser::Ruby::NORMAL
-
-    x = @top_level.classes.first
-
-    assert_equal 2, x.method_list.length
-    a = x.method_list.first
-
-
-    expected = [
-      {
-        :line_no => 2, :char_no => 1, :kind => :on_comment,
-        :text => "# File #{@filename}, line 2"
-      },
-      { :line_no => 0, :char_no => 0, :kind => :on_nl, :text => "\n" },
-      { :line_no => 1, :char_no => 1, :kind => :on_sp, :text => '' },
-      { :line_no => 2, :char_no => 0, :kind => :on_kw, :text => 'def' },
-      { :line_no => 2, :char_no => 3, :kind => :on_sp, :text => ' ' },
-      { :line_no => 2, :char_no => 4, :kind => :on_ident, :text => 'a' },
-      { :line_no => 2, :char_no => 5, :kind => :on_nl, :text => "\n" },
-      { :line_no => 3, :char_no => 0, :kind => :on_regexp, :text => '%r{#}' },
-      { :line_no => 3, :char_no => 5, :kind => :on_nl, :text => "\n" },
-      { :line_no => 4, :char_no => 0, :kind => :on_regexp, :text => '%r{#{}}' },
-      { :line_no => 4, :char_no => 7, :kind => :on_nl, :text => "\n" },
-      { :line_no => 5, :char_no => 0, :kind => :on_kw, :text => 'end' }
-    ]
-    parsed_stream = a.token_stream.map { |tk|
-      {
-        :line_no => tk[:line_no],
-        :char_no => tk[:char_no],
-        :kind => tk[:kind],
-        :text => tk[:text]
-      }
-    }
-
-    assert_equal expected, parsed_stream
-  end
-
-  def test_parse_statements_encoding
-    @options.encoding = Encoding::CP852
-
-    content = <<-EOF
-class Foo
-  ##
-  # this is my method
-  add_my_method :foo
-end
-    EOF
-
-    util_parser content
-
-    @parser.parse_statements @top_level
-
-    foo = @top_level.classes.first.method_list.first
-    assert_equal 'foo', foo.name
-    assert_equal 'this is my method', foo.comment.text
-    assert_equal Encoding::CP852, foo.comment.text.encoding
-  end
-
-  def test_parse_statements_enddoc
-    klass = @top_level.add_class RDoc::NormalClass, 'Foo'
-
-    util_parser "\n# :enddoc:"
-
-    @parser.parse_statements klass, RDoc::Parser::Ruby::NORMAL, nil
-
-    assert klass.done_documenting
-  end
-
-  def test_parse_statements_enddoc_top_level
-    util_parser "\n# :enddoc:"
-
-    assert_throws :eof do
-      @parser.parse_statements @top_level, RDoc::Parser::Ruby::NORMAL, nil
-    end
-  end
-
-  def test_parse_statements_identifier_meta_method
-    content = <<-EOF
-class Foo
-  ##
-  # this is my method
-  add_my_method :foo
-end
-    EOF
-
-    util_parser content
-
-    @parser.parse_statements @top_level
-
-    foo = @top_level.classes.first.method_list.first
-    assert_equal 'foo', foo.name
-  end
-
-  def test_parse_statements_identifier_alias_method
-    content = <<-RUBY
-class Foo
-  def foo() end
-  alias_method :foo2, :foo
-end
-    RUBY
-
-    util_parser content
-
-    @parser.parse_statements @top_level
-
-    foo = @top_level.classes.first.method_list[0]
-    assert_equal 'foo', foo.name
-
-    foo2 = @top_level.classes.first.method_list.last
-    assert_equal 'foo2', foo2.name
-    assert_equal 'foo', foo2.is_alias_for.name
-    assert @top_level.classes.first.aliases.empty?
-  end
-
-  def test_parse_statements_identifier_alias_method_before_original_method
-    # This is not strictly legal Ruby code, but it simulates finding an alias
-    # for a method before finding the original method, which might happen
-    # to rdoc if the alias is in a different file than the original method
-    # and rdoc processes the alias' file first.
-    content = <<-EOF
-class Foo
-  alias_method :foo2, :foo
-
-  alias_method :foo3, :foo
-
-  def foo()
-  end
-
-  alias_method :foo4, :foo
-
-  alias_method :foo5, :unknown
-end
-EOF
-
-    util_parser content
-
-    @parser.parse_statements @top_level
-
-    foo = @top_level.classes.first.method_list[0]
-    assert_equal 'foo', foo.name
-
-    foo2 = @top_level.classes.first.method_list[1]
-    assert_equal 'foo2', foo2.name
-    assert_equal 'foo', foo2.is_alias_for.name
-
-    foo3 = @top_level.classes.first.method_list[2]
-    assert_equal 'foo3', foo3.name
-    assert_equal 'foo', foo3.is_alias_for.name
-
-    foo4 = @top_level.classes.first.method_list.last
-    assert_equal 'foo4', foo4.name
-    assert_equal 'foo', foo4.is_alias_for.name
-
-    assert_equal 'unknown', @top_level.classes.first.external_aliases[0].old_name
-  end
-
-  def test_parse_statements_identifier_args
-    comment = "##\n# :args: x\n# :method: b\n# my method\n"
-
-    util_parser "module M\n#{comment}def_delegator :a, :b, :b\nend"
-
-    @parser.parse_statements @top_level, RDoc::Parser::Ruby::NORMAL
-
-    m = @top_level.modules.first
-    assert_equal 'M', m.full_name
-
-    b = m.method_list.first
-    assert_equal 'M#b', b.full_name
-    assert_equal 'x', b.params
-    assert_equal 'my method', b.comment.text
-
-    assert_nil m.params, 'Module parameter not removed'
-  end
-
-  def test_parse_statements_identifier_constant
-    sixth_constant = <<-EOF
-Class.new do
-  rule :file do
-    all(x, y, z) {
-      def value
-        find(:require).each {|r| require r.value }
-        find(:grammar).map {|g| g.value }
-      end
-      def min; end
-    }
-  end
-end
-    EOF
-
-    content = <<-EOF
-class Foo
-  FIRST_CONSTANT = 5
-
-  SECOND_CONSTANT = [
-     1,
-     2,
-     3
-  ]
-
-  THIRD_CONSTANT = {
-     :foo => 'bar',
-     :x => 'y'
-  }
-
-  FOURTH_CONSTANT = SECOND_CONSTANT.map do |element|
-    element + 1
-    element + 2
-  end
-
-  FIFTH_CONSTANT = SECOND_CONSTANT.map { |element| element + 1 }
-
-  SIXTH_CONSTANT = #{sixth_constant}
-
-  SEVENTH_CONSTANT = proc { |i| begin i end }
-
-  EIGHTH_CONSTANT = "a" \\
-                    "b"
-end
-EOF
-
-    util_parser content
-
-    @parser.parse_statements @top_level
-
-    constants = @top_level.classes.first.constants
-
-    constant = constants[0]
-    assert_equal 'FIRST_CONSTANT', constant.name
-    assert_equal '5', constant.value
-    assert_equal @top_level, constant.file
-
-    constant = constants[1]
-    assert_equal 'SECOND_CONSTANT', constant.name
-    assert_equal "[\n1,\n2,\n3\n]", constant.value
-    assert_equal @top_level, constant.file
-
-    constant = constants[2]
-    assert_equal 'THIRD_CONSTANT', constant.name
-    assert_equal "{\n:foo => 'bar',\n:x => 'y'\n}", constant.value
-    assert_equal @top_level, constant.file
-
-    constant = constants[3]
-    assert_equal 'FOURTH_CONSTANT', constant.name
-    assert_equal "SECOND_CONSTANT.map do |element|\nelement + 1\nelement + 2\nend", constant.value
-    assert_equal @top_level, constant.file
-
-    constant = constants[4]
-    assert_equal 'FIFTH_CONSTANT', constant.name
-    assert_equal 'SECOND_CONSTANT.map { |element| element + 1 }', constant.value
-    assert_equal @top_level, constant.file
-
-    # TODO: parse as class
-    constant = constants[5]
-    assert_equal 'SIXTH_CONSTANT', constant.name
-    assert_equal sixth_constant.lines.map(&:strip).join("\n"), constant.value
-    assert_equal @top_level, constant.file
-
-    # TODO: parse as method
-    constant = constants[6]
-    assert_equal 'SEVENTH_CONSTANT', constant.name
-    assert_equal "proc { |i| begin i end }", constant.value
-    assert_equal @top_level, constant.file
-
-    constant = constants[7]
-    assert_equal 'EIGHTH_CONSTANT', constant.name
-    assert_equal "\"a\" \\\n\"b\"", constant.value
-    assert_equal @top_level, constant.file
-  end
-
-  def test_parse_statements_identifier_attr
-    content = "class Foo\nattr :foo\nend"
-
-    util_parser content
-
-    @parser.parse_statements @top_level
-
-    foo = @top_level.classes.first.attributes.first
-    assert_equal 'foo', foo.name
-    assert_equal 'R', foo.rw
-  end
-
-  def test_parse_statements_identifier_attr_accessor
-    content = "class Foo\nattr_accessor :foo\nend"
-
-    util_parser content
-
-    @parser.parse_statements @top_level
-
-    foo = @top_level.classes.first.attributes.first
-    assert_equal 'foo', foo.name
-    assert_equal 'RW', foo.rw
-  end
-
-  def test_parse_statements_identifier_define_method
-    util_parser <<-RUBY
-class C
-  ##
-  # :method: a
-  define_method :a do end
-  ##
-  # :method: b
-  define_method :b do end
-end
-    RUBY
-
-    @parser.parse_statements @top_level
-    c = @top_level.classes.first
-
-    assert_equal %w[a b], c.method_list.map { |m| m.name }
-  end
-
-  def test_parse_statements_identifier_include
-    content = "class Foo\ninclude Bar\nend"
-
-    util_parser content
-
-    @parser.parse_statements @top_level
-
-    foo = @top_level.classes.first
-    assert_equal 'Foo', foo.name
-    assert_equal 1, foo.includes.length
-  end
-
-  def test_parse_statements_identifier_module_function
-    content = "module Foo\ndef foo() end\nmodule_function :foo\nend"
-
-    util_parser content
-
-    @parser.parse_statements @top_level
-
-    foo, s_foo = @top_level.modules.first.method_list
-    assert_equal 'foo',    foo.name,       'instance method name'
-    assert_equal :private, foo.visibility, 'instance method visibility'
-    assert_equal false,    foo.singleton,  'instance method singleton'
-
-    assert_equal 'foo',   s_foo.name,       'module function name'
-    assert_equal :public, s_foo.visibility, 'module function visibility'
-    assert_equal true,    s_foo.singleton,  'module function singleton'
-  end
-
-  def test_parse_statements_identifier_private
-    content = "class Foo\nprivate\ndef foo() end\nend"
-
-    util_parser content
-
-    @parser.parse_statements @top_level
-
-    foo = @top_level.classes.first.method_list.first
-    assert_equal 'foo', foo.name
-    assert_equal :private, foo.visibility
-  end
-
-  def test_parse_statements_identifier_public_class_method
-    content = <<-CONTENT
-class Date
-  def self.now; end
-  private_class_method :now
-end
-
-class DateTime < Date
-  public_class_method :now
-end
-    CONTENT
-
-    util_parser content
-
-    @parser.parse_statements @top_level
-
-    date, date_time = @top_level.classes.sort_by { |c| c.full_name }
-
-    date_now      = date.method_list.first
-    date_time_now = date_time.method_list.sort_by { |m| m.full_name }.first
-
-    assert_equal :private, date_now.visibility
-    assert_equal :public,  date_time_now.visibility
-  end
-
-  def test_parse_statements_identifier_private_class_method
-    content = <<-CONTENT
-class Date
-  def self.now; end
-  public_class_method :now
-end
-
-class DateTime < Date
-  private_class_method :now
-end
-    CONTENT
-
-    util_parser content
-
-    @parser.parse_statements @top_level
-
-    # TODO sort classes by default
-    date, date_time = @top_level.classes.sort_by { |c| c.full_name }
-
-    date_now      = date.method_list.first
-    date_time_now = date_time.method_list.sort_by { |m| m.full_name }.first
-
-    assert_equal :public,  date_now.visibility,      date_now.full_name
-    assert_equal :private, date_time_now.visibility, date_time_now.full_name
-  end
-
-  def test_parse_statements_complex_condition_in_for
-    util_parser <<RUBY
-class Foo
-  def blah()
-    for i in (k)...n do
-    end
-    for i in (k)...n
-    end
-  end
-end
-RUBY
-
-    expected = <<EXPECTED
-<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">blah</span>()
-  <span class="ruby-keyword">for</span> <span class="ruby-identifier">i</span> <span class="ruby-keyword">in</span> (<span class="ruby-identifier">k</span>)<span class="ruby-operator">...</span><span class="ruby-identifier">n</span> <span class="ruby-keyword">do</span>
-  <span class="ruby-keyword">end</span>
-  <span class="ruby-keyword">for</span> <span class="ruby-identifier">i</span> <span class="ruby-keyword">in</span> (<span class="ruby-identifier">k</span>)<span class="ruby-operator">...</span><span class="ruby-identifier">n</span>
-  <span class="ruby-keyword">end</span>
-<span class="ruby-keyword">end</span>
-EXPECTED
-    expected = expected.rstrip
-
-    @parser.scan
-
-    foo = @top_level.classes.first
-    assert_equal 'Foo', foo.full_name
-
-    blah = foo.method_list.first
-    markup_code = blah.markup_code.sub(/^.*\n/, '')
-    assert_equal expected, markup_code
-  end
-
-  def test_parse_instance_operation_method
-    util_parser <<-RUBY
-class Foo
-  def self.& end
-end
-    RUBY
-
-    expected = <<EXPECTED
-  <span class="ruby-keyword">def</span> <span class="ruby-keyword">self</span>.<span class="ruby-identifier ruby-title">&</span> <span class="ruby-keyword">end</span>
-<span class="ruby-keyword">end</span>
-EXPECTED
-    expected = expected.rstrip
-
-    @parser.scan
-
-    foo = @top_level.classes.first
-    assert_equal 'Foo', foo.full_name
-
-    blah = foo.method_list.first
-    markup_code = blah.markup_code.sub(/^.*\n/, '')
-    assert_equal expected, markup_code
-  end
-
-  def test_parse_statements_postfix_if_after_heredocbeg
-    @filename = 'file.rb'
-    util_parser <<RUBY
-class Foo
-  def blah()
-    <<-EOM if true
-    EOM
-  end
-end
-RUBY
-
-    expected = <<EXPECTED
-  <span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">blah</span>()
-    <span class="ruby-identifier"><<-EOM</span> <span class="ruby-keyword">if</span> <span class="ruby-keyword">true</span>
-<span class="ruby-value"></span><span class="ruby-identifier">    EOM</span>
-  <span class="ruby-keyword">end</span>
-EXPECTED
-    expected = expected.rstrip
-
-    @parser.scan
-
-    foo = @top_level.classes.first
-    assert_equal 'Foo', foo.full_name
-
-    blah = foo.method_list.first
-    markup_code = blah.markup_code.sub(/^.*\n/, '')
-    assert_equal expected, markup_code
-  end
-
-  def test_parse_mutable_heredocbeg
-    @filename = 'file.rb'
-    util_parser <<RUBY
-class Foo
-  def blah()
-    @str = -<<-EOM
-    EOM
-  end
-end
-RUBY
-
-    expected = <<EXPECTED
-  <span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">blah</span>()
-    <span class="ruby-ivar">@str</span> = <span class="ruby-identifier">-<<-EOM</span>
-<span class="ruby-value"></span><span class="ruby-identifier">    EOM</span>
-  <span class="ruby-keyword">end</span>
-EXPECTED
-    expected = expected.rstrip
-
-    @parser.scan
-
-    foo = @top_level.classes.first
-    assert_equal 'Foo', foo.full_name
-
-    blah = foo.method_list.first
-    markup_code = blah.markup_code.sub(/^.*\n/, '')
-    assert_equal expected, markup_code
-  end
-
-  def test_parse_heredoc_end
-    code = "A = <<eos\n""OK\n""eos\n"
-    util_parser code
-    @parser.parse_statements @top_level
-    @parser.scan
-    c = @top_level.classes.first.constants.first
-    assert_equal("A", c.name)
-
-    util_parser code.gsub(/$/, "\r")
-    @parser.parse_statements @top_level
-    @parser.scan
-    c = @top_level.classes.first.constants.first
-    assert_equal("A", c.name)
-  end
-
-  def test_parse_statements_method_oneliner_with_regexp
-    util_parser <<RUBY
-class Foo
-  def blah() /bar/ end
-end
-RUBY
-
-    expected = <<EXPECTED
-<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">blah</span>() <span class="ruby-regexp">/bar/</span> <span class="ruby-keyword">end</span>
-EXPECTED
-    expected = expected.rstrip
-
-    @parser.scan
-
-    foo = @top_level.classes.first
-    assert_equal 'Foo', foo.full_name
-
-    blah = foo.method_list.first
-    markup_code = blah.markup_code.sub(/^.*\n/, '')
-    assert_equal expected, markup_code
-  end
-
-  def test_parse_statements_embdoc_in_document
-    @filename = 'file.rb'
-    util_parser <<RUBY
-class Foo
-  # doc
-  #
-  #   =begin
-  #   test embdoc
-  #   =end
-  #
-  def blah
-  end
-end
-RUBY
-
-    expected = <<EXPECTED
-<p>doc
-
-<pre class="ruby"><span class="ruby-comment">=begin
-test embdoc
-=end</span>
-</pre>
-EXPECTED
-
-    @parser.scan
-
-    foo = @top_level.classes.first
-    assert_equal 'Foo', foo.full_name
-
-    blah = foo.method_list.first
-    markup_comment = blah.search_record[6]
-    assert_equal expected, markup_comment
-  end
-
-  def test_parse_require_dynamic_string
-    content = <<-RUBY
-prefix = 'path'
-require "\#{prefix}/a_library"
-require 'test'
-RUBY
-
-    util_parser content
-
-    @parser.parse_statements @top_level
-
-    assert_equal 1, @top_level.requires.length
-  end
-
-  def test_parse_postfix_nodoc
-    util_parser <<-RUBY
-class A
-end # :nodoc:
-
-class B
-  def a
-  end # :nodoc:
-
-  def b
-  end
-end
-RUBY
-
-    @parser.parse_statements @top_level
-
-    c_a = @top_level.classes.select(&:document_self).first
-    assert_equal 'B', c_a.full_name
-
-    assert_equal 2, @top_level.classes.length
-    assert_equal 1, @top_level.classes.count(&:document_self)
-    assert_equal 1, c_a.method_list.length
-    assert_equal 'B#b', c_a.method_list.first.full_name
-  end
-
-  def test_parse_statements_identifier_require
-    content = "require 'bar'"
-
-    util_parser content
-
-    @parser.parse_statements @top_level
-
-    assert_equal 1, @top_level.requires.length
-  end
-
-  def test_parse_statements_identifier_yields
-    comment = "##\n# :yields: x\n# :method: b\n# my method\n"
-
-    util_parser "module M\n#{comment}def_delegator :a, :b, :b\nend"
-
-    @parser.parse_statements @top_level, RDoc::Parser::Ruby::NORMAL
-
-    m = @top_level.modules.first
-    assert_equal 'M', m.full_name
-
-    b = m.method_list.first
-    assert_equal 'M#b', b.full_name
-    assert_equal 'x', b.block_params
-    assert_equal 'my method', b.comment.text
-
-    assert_nil m.params, 'Module parameter not removed'
-  end
-
-  def test_parse_statements_nodoc_identifier_alias
-    klass = @top_level.add_class RDoc::NormalClass, 'Foo'
-
-    util_parser "\nalias :old :new # :nodoc:"
-
-    @parser.parse_statements klass, RDoc::Parser::Ruby::NORMAL, nil
-
-    assert_empty klass.aliases
-    assert_empty klass.unmatched_alias_lists
-  end
-
-  def test_parse_statements_nodoc_identifier_alias_method
-    klass = @top_level.add_class RDoc::NormalClass, 'Foo'
-
-    util_parser "\nalias_method :old :new # :nodoc:"
-
-    @parser.parse_statements klass, RDoc::Parser::Ruby::NORMAL, nil
-
-    assert_empty klass.aliases
-    assert_empty klass.unmatched_alias_lists
-  end
-
-  def test_parse_statements_stopdoc_alias
-    klass = @top_level.add_class RDoc::NormalClass, 'Foo'
-
-    util_parser "\n# :stopdoc:\nalias old new"
-
-    @parser.parse_statements klass, RDoc::Parser::Ruby::NORMAL, nil
-
-    assert_empty klass.aliases
-    assert_empty klass.unmatched_alias_lists
-  end
-
-  def test_parse_statements_stopdoc_identifier_alias_method
-    klass = @top_level.add_class RDoc::NormalClass, 'Foo'
-
-    util_parser "\n# :stopdoc:\nalias_method :old :new"
-
-    @parser.parse_statements klass, RDoc::Parser::Ruby::NORMAL, nil
-
-    assert_empty klass.aliases
-    assert_empty klass.unmatched_alias_lists
-  end
-
-  def test_parse_statements_stopdoc_identifier_metaprogrammed
-    klass = @top_level.add_class RDoc::NormalClass, 'Foo'
-
-    util_parser "\n# :stopdoc:\n# attr :meta"
-
-    @parser.parse_statements klass, RDoc::Parser::Ruby::NORMAL, nil
-
-    assert_empty klass.method_list
-    assert_empty klass.attributes
-  end
-
-  def test_parse_statements_stopdoc_constant
-    klass = @top_level.add_class RDoc::NormalClass, 'Foo'
-
-    util_parser "\n# :stopdoc:\nA = v"
-
-    @parser.parse_statements klass, RDoc::Parser::Ruby::NORMAL, nil
-
-    assert_empty klass.constants
-  end
-
-  def test_parse_statements_stopdoc_def
-    klass = @top_level.add_class RDoc::NormalClass, 'Foo'
-
-    util_parser "\n# :stopdoc:\ndef m\n end"
-
-    @parser.parse_statements klass, RDoc::Parser::Ruby::NORMAL, nil
-
-    assert_empty klass.method_list
-  end
-
-  def test_parse_statements_super
-    m = RDoc::AnyMethod.new '', 'm'
-    util_parser 'super'
-
-    @parser.parse_statements @top_level, RDoc::Parser::Ruby::NORMAL, m
-
-    assert m.calls_super
-  end
-
-  def test_parse_statements_super_no_method
-    content = "super"
-
-    util_parser content
-
-    @parser.parse_statements @top_level
-
-    assert_nil @parser.get_tk
-  end
-
-  def test_parse_statements_while_begin
-    util_parser <<-RUBY
-class A
-  def a
-    while begin a; b end
-    end
-  end
-
-  def b
-  end
-end
-    RUBY
-
-    @parser.parse_statements @top_level
-
-    c_a = @top_level.classes.first
-    assert_equal 'A', c_a.full_name
-
-    assert_equal 1, @top_level.classes.length
-
-    m_a = c_a.method_list.first
-    m_b = c_a.method_list.last
-
-    assert_equal 'A#a', m_a.full_name
-    assert_equal 'A#b', m_b.full_name
-  end
-
-
-  def test_parse_symbol_in_paren_arg
-    util_parser <<RUBY
-class Foo
-  def blah
-  end
-  private(:blah)
-end
-RUBY
-
-    @parser.scan
-
-    foo = @top_level.classes.first
-    assert_equal 'Foo', foo.full_name
-
-    blah = foo.method_list.first
-    assert_equal :private, blah.visibility
-  end
-
-  def test_parse_symbol_in_arg
-    util_parser '[:blah, "blah", "#{blah}", blah]'
-    @parser.get_tk # skip '['
-
-    assert_equal 'blah', @parser.parse_symbol_in_arg
-    @parser.get_tk # skip ','
-
-    @parser.skip_tkspace
-
-    assert_equal 'blah', @parser.parse_symbol_in_arg
-    @parser.get_tk # skip ','
-
-    @parser.skip_tkspace
-
-    assert_nil @parser.parse_symbol_in_arg
-    @parser.get_tk # skip ','
-
-    @parser.skip_tkspace
-
-    assert_nil @parser.parse_symbol_in_arg
-  end
-
-  def test_parse_percent_symbol
-    content = '%s[foo bar]'
-    util_parser content
-    tk = @parser.get_tk
-    assert_equal :on_symbol, tk[:kind]
-    assert_equal content, tk[:text]
-  end
-
-  def test_parse_statements_alias_method
-    content = <<-CONTENT
-class A
-  alias_method :a, :[] unless c
-end
-
-B = A
-
-class C
-end
-    CONTENT
-
-    util_parser content
-
-    @parser.parse_statements @top_level
-
-    # HACK where are the assertions?
-  end
-
-  def test_parse_top_level_statements_enddoc
-    util_parser <<-CONTENT
-# :enddoc:
-    CONTENT
-
-    assert_throws :eof do
-      @parser.parse_top_level_statements @top_level
-    end
-  end
-
-  def test_parse_top_level_statements_stopdoc
-    @top_level.stop_doc
-    content = "# this is the top-level comment"
-
-    util_parser content
-
-    @parser.parse_top_level_statements @top_level
-
-    assert_empty @top_level.comment
-  end
-
-  def test_parse_top_level_statements_stopdoc_integration
-    content = <<-CONTENT
-# :stopdoc:
-
-class Example
-  def method_name
-  end
-end
-    CONTENT
-
-    util_parser content
-
-    @parser.parse_top_level_statements @top_level
-
-    assert_equal 1, @top_level.classes.length
-    assert_empty @top_level.modules
-
-    assert @top_level.find_module_named('Example').ignored?
-  end
-
-  # This tests parse_comment
-  def test_parse_top_level_statements_constant_nodoc_integration
-    content = <<-CONTENT
-class A
-  C = A # :nodoc:
-end
-    CONTENT
-
-    util_parser content
-
-    @parser.parse_top_level_statements @top_level
-
-    klass = @top_level.find_module_named('A')
-
-    c = klass.constants.first
-
-    assert_nil c.document_self, 'C should not be documented'
-  end
-
-  def test_parse_yield_in_braces_with_parens
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-
-    util_parser "def foo\nn.times { |i| yield nth(i) }\nend"
-
-    tk = @parser.get_tk
-
-    @parser.parse_method klass, RDoc::Parser::Ruby::NORMAL, tk, @comment
-
-    foo = klass.method_list.first
-    assert_equal 'nth(i)', foo.block_params
-  end
-
-  def test_read_directive
-    parser = util_parser '# :category: test'
-
-    directive, value = parser.read_directive %w[category]
-
-    assert_equal 'category', directive
-    assert_equal 'test', value
-
-    assert_nil parser.get_tk
-  end
-
-  def test_read_directive_allow
-    parser = util_parser '# :category: test'
-
-    directive = parser.read_directive []
-
-    assert_nil directive
-
-    assert_nil parser.get_tk
-  end
-
-  def test_read_directive_empty
-    parser = util_parser '# test'
-
-    directive = parser.read_directive %w[category]
-
-    assert_nil directive
-
-    assert_nil parser.get_tk
-  end
-
-  def test_read_directive_no_comment
-    parser = util_parser ''
-
-    directive = parser.read_directive %w[category]
-
-    assert_nil directive
-
-    assert_nil parser.get_tk
-  end
-
-  def test_read_directive_one_liner
-    parser = util_parser 'AAA = 1 # :category: test'
-
-    directive, value = parser.read_directive %w[category]
-
-    assert_equal 'category', directive
-    assert_equal 'test', value
-
-    assert_equal :on_const, parser.get_tk[:kind]
-  end
-
-  def test_read_directive_linear_performance
-    omit "JRuby intermittently times out" if RUBY_ENGINE == 'jruby'
-    pre = ->(i) {util_parser '# ' + '0'*i + '=000:'}
-    assert_linear_performance((1..5).map{|i|10**i}, pre: pre) do |parser|
-      assert_nil parser.read_directive []
-    end
-  end
-
-  def test_read_documentation_modifiers
-    c = RDoc::Context.new
-
-    parser = util_parser '# :category: test'
-
-    parser.read_documentation_modifiers c, %w[category]
-
-    assert_equal 'test', c.current_section.title
-  end
-
-  def test_read_documentation_modifiers_notnew
-    m = RDoc::AnyMethod.new nil, 'initialize'
-
-    parser = util_parser '# :notnew: test'
-
-    parser.read_documentation_modifiers m, %w[notnew]
-
-    assert m.dont_rename_initialize
-  end
-
-  def test_read_documentation_modifiers_not_dash_new
-    m = RDoc::AnyMethod.new nil, 'initialize'
-
-    parser = util_parser '# :not-new: test'
-
-    parser.read_documentation_modifiers m, %w[not-new]
-
-    assert m.dont_rename_initialize
-  end
-
-  def test_read_documentation_modifiers_not_new
-    m = RDoc::AnyMethod.new nil, 'initialize'
-
-    parser = util_parser '# :not_new: test'
-
-    parser.read_documentation_modifiers m, %w[not_new]
-
-    assert m.dont_rename_initialize
-  end
-
-  def test_sanity_integer
-    util_parser '1'
-    assert_equal '1', @parser.get_tk[:text]
-
-    util_parser '1.0'
-    assert_equal '1.0', @parser.get_tk[:text]
-  end
-
-  def test_sanity_interpolation
-    last_tk = nil
-    util_parser 'class A; B = "#{c}"; end'
-
-    while tk = @parser.get_tk do last_tk = tk end
-
-    assert_equal 'end', last_tk[:text]
-  end
-
-  # If you're writing code like this you're doing it wrong
-
-  def test_sanity_interpolation_crazy
-    util_parser '"#{"#{"a")}" if b}"'
-
-    assert_equal '"#{"#{"a")}" if b}"', @parser.get_tk[:text]
-    assert_nil @parser.get_tk
-  end
-
-  def test_sanity_interpolation_curly
-    util_parser '%{ #{} }'
-
-    assert_equal '%{ #{} }', @parser.get_tk[:text]
-    assert_nil @parser.get_tk
-  end
-
-  def test_sanity_interpolation_format
-    util_parser '"#{stftime("%m-%d")}"'
-
-    while @parser.get_tk do end
-  end
-
-  def test_sanity_symbol_interpolation
-    util_parser ':"#{bar}="'
-
-    while @parser.get_tk do end
-  end
-
-  def test_scan_cr
-    content = <<-CONTENT
-class C\r
-  def m\r
-    a=\\\r
-      123\r
-  end\r
-end\r
-    CONTENT
-
-    util_parser content
-
-    @parser.scan
-
-    c = @top_level.classes.first
-
-    assert_equal 1, c.method_list.length
-  end
-
-  def test_scan_block_comment
-    content = <<-CONTENT
-=begin rdoc
-Foo comment
-=end
-
-class Foo
-
-=begin
-m comment
-=end
-
-  def m() end
-end
-    CONTENT
-
-    util_parser content
-
-    @parser.scan
-
-    foo = @top_level.classes.first
-
-    assert_equal 'Foo comment', foo.comment.text
-
-    m = foo.method_list.first
-
-    assert_equal 'm comment', m.comment.text
-  end
-
-  def test_scan_block_comment_nested # Issue #41
-    content = <<-CONTENT
-require 'something'
-=begin rdoc
-findmeindoc
-=end
-module Foo
-    class Bar
-    end
-end
-    CONTENT
-
-    util_parser content
-
-    @parser.scan
-
-    foo = @top_level.modules.first
-
-    assert_equal 'Foo', foo.full_name
-    assert_equal 'findmeindoc', foo.comment.text
-
-    bar = foo.classes.first
-
-    assert_equal 'Foo::Bar', bar.full_name
-    assert_equal '', bar.comment.text
-  end
-
-  def test_scan_block_comment_notflush
-  ##
-  #
-  # The previous test assumes that between the =begin/=end blocks that there
-  # is only one line, or minima formatting directives. This test tests for
-  # those who use the =begin block with longer / more advanced formatting
-  # within.
-  #
-  ##
-    content = <<-CONTENT
-=begin rdoc
-
-= DESCRIPTION
-
-This is a simple test class
-
-= RUMPUS
-
-Is a silly word
-
-=end
-class StevenSimpleClass
-  # A band on my iPhone as I wrote this test
-  FRUIT_BATS="Make nice music"
-
-=begin rdoc
-A nice girl
-=end
-
-  def lauren
-    puts "Summoning Lauren!"
-  end
-end
-    CONTENT
-    util_parser content
-
-    @parser.scan
-
-    foo = @top_level.classes.first
-
-    assert_equal "= DESCRIPTION\n\nThis is a simple test class\n\n= RUMPUS\n\nIs a silly word",
-      foo.comment.text
-
-    m = foo.method_list.first
-
-    assert_equal 'A nice girl', m.comment.text
-  end
-
-  def test_scan_class_nested_nodoc
-    content = <<-CONTENT
-class A::B # :nodoc:
-end
-    CONTENT
-
-    util_parser content
-
-    @parser.scan
-
-    visible = @store.all_classes_and_modules.select { |mod| mod.display? }
-
-    assert_empty visible.map { |mod| mod.full_name }
-  end
-
-  def test_scan_constant_in_method
-    content = <<-CONTENT # newline is after M is important
-module M
-  def m
-    A
-    B::C
-  end
-end
-    CONTENT
-
-    util_parser content
-
-    @parser.scan
-
-    m = @top_level.modules.first
-
-    assert_empty m.constants
-
-    assert_empty @store.classes_hash.keys
-    assert_equal %w[M], @store.modules_hash.keys
-  end
-
-  def test_scan_constant_in_rescue
-    content = <<-CONTENT # newline is after M is important
-module M
-  def m
-  rescue A::B
-  rescue A::C => e
-  rescue A::D, A::E
-  rescue A::F,
-         A::G
-  rescue H
-  rescue I => e
-  rescue J, K
-  rescue L =>
-    e
-  rescue M;
-  rescue N,
-         O => e
-  end
-end
-    CONTENT
-
-    util_parser content
-
-    @parser.scan
-
-    m = @top_level.modules.first
-
-    assert_empty m.constants
-
-    assert_empty @store.classes_hash.keys
-    assert_equal %w[M], @store.modules_hash.keys
-  end
-
-  def test_scan_constant_nodoc
-    content = <<-CONTENT # newline is after M is important
-module M
-
-  C = v # :nodoc:
-end
-    CONTENT
-
-    util_parser content
-
-    @parser.scan
-
-    c = @top_level.modules.first.constants.first
-
-    assert c.documented?
-  end
-
-  def test_scan_constant_nodoc_block
-    content = <<-CONTENT # newline is after M is important
-module M
-
-  C = v do # :nodoc:
-  end
-end
-    CONTENT
-
-    util_parser content
-
-    @parser.scan
-
-    c = @top_level.modules.first.constants.first
-
-    assert c.documented?
-  end
-
-  def test_scan_duplicate_module
-    content = <<-CONTENT
-# comment a
-module Foo
-end
-
-# comment b
-module Foo
-end
-    CONTENT
-
-    util_parser content
-
-    @parser.scan
-
-    foo = @top_level.modules.first
-
-    expected = [
-      RDoc::Comment.new('comment a', @top_level),
-      RDoc::Comment.new('comment b', @top_level)
-    ]
-
-    assert_equal expected, foo.comment_location.map { |c, l| c }
-  end
-
-  def test_scan_meta_method_block
-    content = <<-CONTENT
-class C
-
-  ##
-  #  my method
-
-  inline(:my_method) do |*args|
-    "this method used to cause z to disappear"
-  end
-
-  def z
-  end
-    CONTENT
-
-    util_parser content
-
-    @parser.scan
-
-    assert_equal 2, @top_level.classes.first.method_list.length
-  end
-
-  def test_scan_method_semi_method
-    content = <<-CONTENT
-class A
-  def self.m() end; def self.m=() end
-end
-
-class B
-  def self.m() end
-end
-    CONTENT
-
-    util_parser content
-
-    @parser.scan
-
-    a = @store.find_class_named 'A'
-    assert a, 'missing A'
-
-    assert_equal 2, a.method_list.length
-
-    b = @store.find_class_named 'B'
-    assert b, 'missing B'
-
-    assert_equal 1, b.method_list.length
-  end
-
-  def test_scan_markup_override
-    content = <<-CONTENT
-# *awesome*
-class C
-  # :markup: rd
-  # ((*radical*))
-  def m
-  end
-end
-    CONTENT
-
-    util_parser content
-
-    @parser.scan
-
-    c = @top_level.classes.first
-
-    assert_equal 'rdoc', c.comment.format
-
-    assert_equal 'rd', c.method_list.first.comment.format
-  end
-
-  def test_scan_markup_first_comment
-    content = <<-CONTENT
-# :markup: rd
-
-# ((*awesome*))
-class C
-  # ((*radical*))
-  def m
-  end
-end
-    CONTENT
-
-    util_parser content
-
-    @parser.scan
-
-    c = @top_level.classes.first
-
-    assert_equal 'rd', c.comment.format
-
-    assert_equal 'rd', c.method_list.first.comment.format
-  end
-
-  def test_scan_rails_routes
-    util_parser <<-ROUTES_RB
-namespace :api do
-  scope module: :v1 do
-  end
-end
-    ROUTES_RB
-
-    @parser.scan
-
-    assert_empty @top_level.classes
-    assert_empty @top_level.modules
-  end
-
-  def test_scan_tomdoc_meta
-    util_parser <<-RUBY
-# :markup: tomdoc
-
-class C
-
-  # Signature
-  #
-  #   find_by_<field>[_and_<field>...](args)
-  #
-  # field - A field name.
-
-end
-
-    RUBY
-
-    @parser.scan
-
-    c = @top_level.classes.first
-
-    m = c.method_list.first
-
-    assert_equal "find_by_<field>[_and_<field>...]", m.name
-    assert_equal "find_by_<field>[_and_<field>...](args)\n", m.call_seq
-
-    expected =
-      doc(
-        head(3, 'Signature'),
-        list(:NOTE,
-          item(%w[field],
-            para('A field name.'))))
-    expected.file = @top_level
-
-    assert_equal expected, m.comment.parse
-  end
-
-  def test_scan_stopdoc
-    util_parser <<-RUBY
-class C
-  # :stopdoc:
-  class Hidden
-  end
-end
-    RUBY
-
-    @parser.scan
-
-    c = @top_level.classes.first
-
-    hidden = c.classes.first
-
-    refute hidden.document_self
-    assert hidden.ignored?
-  end
-
-  def test_scan_stopdoc_class_alias
-    util_parser <<-RUBY
-# :stopdoc:
-module A
-  B = C
-end
-    RUBY
-
-    @parser.scan
-
-    assert_empty @store.all_classes
-
-    assert_equal 1, @store.all_modules.length
-    m = @store.all_modules.first
-
-    assert m.ignored?
-  end
-
-  def test_scan_stopdoc_nested
-    util_parser <<-RUBY
-# :stopdoc:
-class A::B
-end
-    RUBY
-
-    @parser.scan
-
-    a   = @store.modules_hash['A']
-    a_b = @store.classes_hash['A::B']
-
-    refute a.document_self, 'A is inside stopdoc'
-    assert a.ignored?,      'A is inside stopdoc'
-
-    refute a_b.document_self, 'A::B is inside stopdoc'
-    assert a_b.ignored?,      'A::B is inside stopdoc'
-  end
-
-  def test_scan_struct_self_brackets
-    util_parser <<-RUBY
-class C < M.m
-  def self.[]
-  end
-end
-    RUBY
-
-    @parser.scan
-
-    c = @store.find_class_named 'C'
-    assert_equal %w[C::[]], c.method_list.map { |m| m.full_name }
-  end
-
-  def test_scan_visibility
-    util_parser <<-RUBY
-class C
-   def a() end
-
-   private :a
-
-   class << self
-     def b() end
-     private :b
-   end
-end
-    RUBY
-
-    @parser.scan
-
-    c = @store.find_class_named 'C'
-
-    c_a = c.find_method_named 'a'
-
-    assert_equal :private, c_a.visibility
-    refute c_a.singleton
-
-    c_b = c.find_method_named 'b'
-
-    assert_equal :private, c_b.visibility
-    assert c_b.singleton
-  end
-
-  def test_scan_visibility_count
-    util_parser <<-RUBY
-class C < Original::Base
-  class C2 < Original::Base
-    def m0() end
-    def m1() end
-
-    private
-
-    def m2() end
-    def m3() end
-    def m4() end
-  end
-end
-    RUBY
-
-    @parser.scan
-
-    c = @store.find_class_named 'C::C2'
-
-    private_method_count = c.method_list.count { |m| :private == m.visibility }
-    assert_equal 3, private_method_count
-
-    public_method_count = c.method_list.count { |m| :public == m.visibility }
-    assert_equal 2, public_method_count
-  end
-
-  def test_scan_constant_visibility
-    util_parser <<-RUBY
-class C
-   CONST_A = 123
-
-   CONST_B = 234
-   private_constant :CONST_B
-
-   CONST_C = 345
-   public_constant :CONST_C
-end
-    RUBY
-
-    @parser.scan
-
-    c = @store.find_class_named 'C'
-    const_a, const_b, const_c = c.constants.sort_by(&:name)
-
-    assert_equal 'CONST_A', const_a.name
-    assert_equal :public, const_a.visibility
-
-    assert_equal 'CONST_B', const_b.name
-    assert_equal :private, const_b.visibility
-
-    assert_equal 'CONST_C', const_c.name
-    assert_equal :public, const_c.visibility
-  end
-
-  def test_document_after_rescue_inside_paren
-    util_parser <<-RUBY
-class C
-  attr_accessor :sample if (1.inexistent_method rescue false)
-  # first
-  # second
-  def a
-  end
-end
-    RUBY
-
-    @parser.scan
-
-    c = @store.find_class_named 'C'
-
-    c_a = c.find_method_named 'a'
-    assert_equal "first\nsecond", c_a.comment.text
-  end
-
-  def test_singleton_method_via_eigenclass
-    util_parser <<-RUBY
-class C
-   class << self
-     def a() end
-   end
-end
-    RUBY
-
-    @parser.scan
-
-    c   = @store.find_class_named 'C'
-    c_a = c.find_method_named 'a'
-
-    assert_equal :public, c_a.visibility
-    assert c_a.singleton
-  end
-
-  def test_stopdoc_after_comment
-    util_parser <<-EOS
-      module Bar
-        # hello
-        module Foo
-          # :stopdoc:
-        end
-        # there
-        class Baz
-          # :stopdoc:
-        end
-      end
-    EOS
-
-    @parser.parse_statements @top_level
-
-    foo = @top_level.modules.first.modules.first
-    assert_equal 'Foo', foo.name
-    assert_equal 'hello', foo.comment.text
-
-    baz = @top_level.modules.first.classes.first
-    assert_equal 'Baz', baz.name
-    assert_equal 'there', baz.comment.text
-  end
-
-  def util_parser(content)
-    @parser = RDoc::Parser::Ruby.new @top_level, content, @options, @stats
-  end
-
-  def util_two_parsers(first_file_content, second_file_content)
-    util_parser first_file_content
-
-    @parser2 = RDoc::Parser::Ruby.new @top_level2, @filename,
-                                      second_file_content, @options, @stats
-  end
-
-  def test_parse_const_third_party
-    util_parser <<-CLASS
-class A
-  true if B
-  true if B::C
-  true if B::C::D
-
-  module B
-  end
-end
-    CLASS
-
-    tk = @parser.get_tk
-
-    @parser.parse_class @top_level, RDoc::Parser::Ruby::NORMAL, tk, @comment
-
-    a = @top_level.classes.first
-    assert_equal 'A', a.full_name
-
-    visible = @store.all_modules.reject { |mod| mod.suppressed? }
-    visible = visible.map { |mod| mod.full_name }
-
-    assert_equal ['A::B'], visible
-  end
-
-  def test_parse_const_alias_defined_elsewhere
-    util_parser <<-CLASS
-module A
-  Aliased = Defined
-end
-
-module A
-  class Defined
-  end
-end
-    CLASS
-
-    @parser.scan
-
-    a = @top_level.modules.first
-    assert_equal 'A', a.full_name
-    aliased = a.constants.first
-    assert_equal 'A::Aliased', aliased.full_name
-    assert_equal [], a.modules.map(&:full_name)
-    assert_equal ['A::Defined', 'A::Aliased'], a.classes.map(&:full_name)
-    assert_equal ['A::Aliased'], a.constants.map(&:full_name)
-
-    visible = @store.all_modules.reject { |mod| mod.suppressed? }
-    visible = visible.map { |mod| mod.full_name }
-
-    assert_equal ['A'], visible
-  end
-
-  def test_parse_const_alias_defined_far_away
-    util_parser <<-CLASS
-module A
-  Aliased = ::B::C::Defined
-end
-
-module B
-  module C
-    class Defined
-    end
-  end
-end
-    CLASS
-
-    @parser.scan
-
-    a = @top_level.modules.first
-    assert_equal 'A', a.full_name
-    assert_empty a.classes
-    assert_empty a.modules
-    assert_equal ['A::Aliased'], a.constants.map(&:full_name)
-
-    defined = @store.find_class_named 'B::C::Defined'
-    assert_equal 'B::C::Defined', defined.full_name
-
-    aliased = @store.find_class_named 'B::C::Aliased'
-    assert_equal 'B::C::Aliased', aliased.full_name
-
-    visible = @store.all_modules.reject { |mod| mod.suppressed? }
-    visible = visible.map { |mod| mod.full_name }
-
-    assert_equal ['A', 'B', 'B::C'], visible
-  end
-
-  def test_parse_include_by_dynamic_definition
-    util_parser <<-CLASS
-module A
-  class B
-    include(Module.new do
-      def e(m)
-      end
-    end)
-  end
-
-  class C
-  end
-
-  class D
-  end
-end
-    CLASS
-
-    @parser.scan
-
-    a = @store.find_module_named 'A'
-    assert_equal 'A', a.full_name
-    a_b = a.find_class_named 'B'
-    assert_equal 'A::B', a_b.full_name
-    a_c = a.find_class_named 'C'
-    assert_equal 'A::C', a_c.full_name
-    a_d = a.find_class_named 'D'
-    assert_equal 'A::D', a_d.full_name
-  end
-
-  def test_parse_include_by_dynamic_definition_without_paren
-    util_parser <<-CLASS
-module A
-  class B
-    include(Module.new do
-      def e m
-      end
-    end)
-  end
-
-  class C
-  end
-
-  class D
-  end
-end
-    CLASS
-
-    @parser.scan
-
-    a = @store.find_module_named 'A'
-    assert_equal 'A', a.full_name
-    a_b = a.find_class_named 'B'
-    assert_equal 'A::B', a_b.full_name
-    a_c = a.find_class_named 'C'
-    assert_equal 'A::C', a_c.full_name
-    a_d = a.find_class_named 'D'
-    assert_equal 'A::D', a_d.full_name
-  end
-
-  def test_parse_include_by_dynamic_definition_via_variable
-    util_parser <<-CLASS
-module A
-  class B
-    m = Module.new do
-      def e(m)
-      end
-    end
-    include m
-  end
-
-  class C
-  end
-
-  class D
-  end
-end
-    CLASS
-
-    @parser.scan
-
-    a = @store.find_module_named 'A'
-    assert_equal 'A', a.full_name
-    a_b = a.find_class_named 'B'
-    assert_equal 'A::B', a_b.full_name
-    a_c = a.find_class_named 'C'
-    assert_equal 'A::C', a_c.full_name
-    a_d = a.find_class_named 'D'
-    assert_equal 'A::D', a_d.full_name
-  end
-
-  def test_parse_include_by_dynamic_definition_with_brace
-    util_parser <<-CLASS
-module A
-  class B
-    extend(e {
-      def f(g)
-      end
-    })
-  end
-
-  class C
-  end
-
-  class D
-  end
-end
-    CLASS
-
-    @parser.scan
-
-    a = @store.find_module_named 'A'
-    assert_equal 'A', a.full_name
-    a_b = a.find_class_named 'B'
-    assert_equal 'A::B', a_b.full_name
-    a_c = a.find_class_named 'C'
-    assert_equal 'A::C', a_c.full_name
-    a_d = a.find_class_named 'D'
-    assert_equal 'A::D', a_d.full_name
-  end
-
-  def test_parse_include_by_dynamic_definition_directly
-    util_parser <<-CLASS
-module A
-  class B
-    include Module.new do
-      def e m
-      end
-    end
-  end
-
-  class C
-  end
-
-  class D
-  end
-end
-    CLASS
-
-    @parser.scan
-
-    a = @store.find_module_named 'A'
-    assert_equal 'A', a.full_name
-    a_b = a.find_class_named 'B'
-    assert_equal 'A::B', a_b.full_name
-    a_c = a.find_class_named 'C'
-    assert_equal 'A::C', a_c.full_name
-    a_d = a.find_class_named 'D'
-    assert_equal 'A::D', a_d.full_name
-  end
-
-  def test_parse_included
-    util_parser <<-CLASS
-module A
-  module B
-    extend ActiveSupport::Concern
-    included do
-      ##
-      # :singleton-method:
-      # Hello
-      mattr_accessor :foo
-    end
-  end
-end
-    CLASS
-
-    @parser.scan
-
-    a = @store.find_module_named 'A'
-    assert_equal 'A', a.full_name
-    a_b = a.find_module_named 'B'
-    assert_equal 'A::B', a_b.full_name
-    meth = a_b.method_list.first
-    assert_equal 'foo', meth.name
-    assert_equal 'Hello', meth.comment.text
-  end
-
-  def test_end_that_doesnt_belong_to_class_doesnt_change_visibility
-    util_parser <<-CLASS
-class A
-  private
-
-  begin
-  end
-
-  # Hello
-  def foo() end
-end
-    CLASS
-
-    @parser.scan
-
-    a = @store.find_class_named 'A'
-    assert_equal 'A', a.full_name
-    assert_equal 'foo', a.find_method_named('foo').name
-    meth = a.method_list.first
-    assert_equal 'Hello', meth.comment.text
-  end
-
-  def test_parenthesized_cdecl
-    util_parser <<-RUBY
-module DidYouMean
-  class << (NameErrorCheckers = Object.new)
-  end
-end
-    RUBY
-
-    @parser.scan
-
-    refute_predicate @store.find_class_or_module('DidYouMean'), :nil?
-    refute_predicate @store.find_class_or_module('DidYouMean::NameErrorCheckers'), :nil?
-  end
-end
diff --git a/test/mri/rdoc/rdoc/rdoc_parser_simple_test.rb b/test/mri/rdoc/rdoc/rdoc_parser_simple_test.rb
deleted file mode 100644
index 7296a40064f..00000000000
--- a/test/mri/rdoc/rdoc/rdoc_parser_simple_test.rb
+++ /dev/null
@@ -1,115 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocParserSimpleTest < RDoc::TestCase
-
-  def setup
-    super
-
-    @tempfile = Tempfile.new self.class.name
-    filename = @tempfile.path
-
-    @top_level = @store.add_file filename
-    @fn = filename
-    @options = RDoc::Options.new
-    @stats = RDoc::Stats.new @store, 0
-  end
-
-  def teardown
-    super
-
-    @tempfile.close!
-  end
-
-  def test_initialize_metadata
-    parser = util_parser ":unhandled: \n"
-
-    assert_includes @top_level.metadata, 'unhandled'
-
-    assert_equal ":unhandled: \n", parser.content
-  end
-
-  def test_remove_coding_comment
-    parser = util_parser <<-TEXT
-# -*- mode: rdoc; coding: utf-8; fill-column: 74; -*-
-
-Regular expressions (<i>regexp</i>s) are patterns which describe the
-contents of a string.
-    TEXT
-
-    parser.scan
-
-    expected = <<-TEXT.strip
-Regular expressions (<i>regexp</i>s) are patterns which describe the
-contents of a string.
-    TEXT
-
-    assert_equal expected, @top_level.comment.text
-  end
-
-  # RDoc stops processing comments if it finds a comment line CONTAINING
-  # '<tt>#--</tt>'. This can be used to separate external from internal
-  # comments, or to stop a comment being associated with a method,
-  # class, or module. Commenting CAN be turned back on with
-  # a line that STARTS '<tt>#++</tt>'.
-  #
-  # I've seen guys that comment their code like this:
-  #   # This method....
-  #   #-----------------
-  #   def method
-  #
-  # => either we do it only in ruby code, or we require the leading #
-  #    (to avoid conflict with rules).
-  #
-  #   TODO: require the leading #, to provide the feature in simple text files.
-  #   Note: in ruby & C code, we require '#--' & '#++' or '*--' & '*++',
-  #   to allow rules:
-  #
-  #   # this is a comment
-  #   #---
-  #   # private text
-  #   #+++
-  #   # this is a rule:
-  #   # ---
-
-  def test_remove_private_comments
-    parser = util_parser "foo\n\n--\nbar\n++\n\nbaz\n"
-
-    parser.scan
-
-    expected = "foo\n\n\nbaz"
-
-    assert_equal expected, @top_level.comment.text
-  end
-
-  def test_remove_private_comments_rule
-    parser = util_parser "foo\n---\nbar"
-
-    parser.scan
-
-    expected = "foo\n---\nbar"
-
-    assert_equal expected, @top_level.comment.text
-  end
-
-  def test_remove_private_comments_star
-    parser = util_parser "* foo\n* bar\n"
-
-    parser.scan
-
-    assert_equal "* foo\n* bar", @top_level.comment.text
-  end
-
-  def test_scan
-    parser = util_parser 'it *really* works'
-
-    parser.scan
-
-    assert_equal 'it *really* works', @top_level.comment.text
-  end
-
-  def util_parser(content)
-    RDoc::Parser::Simple.new @top_level, content, @options, @stats
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc/rdoc_parser_test.rb b/test/mri/rdoc/rdoc/rdoc_parser_test.rb
deleted file mode 100644
index 7b890f703d2..00000000000
--- a/test/mri/rdoc/rdoc/rdoc_parser_test.rb
+++ /dev/null
@@ -1,334 +0,0 @@
-# -*- coding: us-ascii -*-
-# frozen_string_literal: true
-
-require_relative 'helper'
-
-class RDocParserTest < RDoc::TestCase
-  def setup
-    super
-
-    @RP = RDoc::Parser
-    @binary_dat_fixture_path = File.expand_path '../binary.dat', __FILE__
-    @options = RDoc::Options.new
-  end
-
-  def test_class_binary_eh_ISO_2022_JP
-    iso_2022_jp = File.join Dir.tmpdir, "test_rdoc_parser_#{$$}.rd"
-
-    File.open iso_2022_jp, 'wb' do |io|
-      io.write "# coding: ISO-2022-JP\n"
-      io.write ":\e$B%3%^%s%I\e(B:\n"
-    end
-
-    refute @RP.binary? iso_2022_jp
-  ensure
-    File.unlink iso_2022_jp
-  end
-
-  def test_class_binary_eh_marshal
-    marshal = File.join Dir.tmpdir, "test_rdoc_parser_#{$$}.marshal"
-    File.open marshal, 'wb' do |io|
-      io.write Marshal.dump('')
-      io.write 'lots of text ' * 500
-    end
-
-    assert @RP.binary?(marshal)
-  ensure
-    File.unlink marshal
-  end
-
-  def test_class_binary_japanese_text
-    file_name = File.expand_path '../test.ja.txt', __FILE__
-    refute @RP.binary?(file_name)
-  end
-
-  def test_class_binary_large_japanese_rdoc
-    capture_output do
-      begin
-        extenc, Encoding.default_external =
-          Encoding.default_external, Encoding::US_ASCII
-        file_name = File.expand_path '../test.ja.largedoc', __FILE__
-        assert !@RP.binary?(file_name)
-      ensure
-        Encoding.default_external = extenc
-      end
-    end
-  end
-
-  def test_class_binary_japanese_rdoc
-    file_name = File.expand_path '../test.ja.rdoc', __FILE__
-    refute @RP.binary?(file_name)
-  end
-
-  def test_class_can_parse
-    assert_equal @RP.can_parse(__FILE__), @RP::Ruby
-
-    readme_file_name = File.expand_path '../test.txt', __FILE__
-
-    assert_equal @RP::Simple, @RP.can_parse(readme_file_name)
-
-    assert_equal @RP::Simple, @RP.can_parse(@binary_dat_fixture_path)
-
-    jtest_file_name = File.expand_path '../test.ja.txt', __FILE__
-    assert_equal @RP::Simple, @RP.can_parse(jtest_file_name)
-
-    jtest_rdoc_file_name = File.expand_path '../test.ja.rdoc', __FILE__
-    assert_equal @RP::Simple, @RP.can_parse(jtest_rdoc_file_name)
-
-    readme_file_name = File.expand_path '../README', __FILE__
-    assert_equal @RP::Simple, @RP.can_parse(readme_file_name)
-
-    jtest_largerdoc_file_name = File.expand_path '../test.ja.largedoc', __FILE__
-    assert_equal @RP::Simple, @RP.can_parse(jtest_largerdoc_file_name)
-
-    @RP.alias_extension 'rdoc', 'largedoc'
-    assert_equal @RP::Simple, @RP.can_parse(jtest_largerdoc_file_name)
-  end
-
-  def test_class_for_executable
-    with_top_level("app", "#!/usr/bin/env ruby -w\n") do |top_level, content|
-      parser = @RP.for top_level, content, @options, :stats
-
-      assert_kind_of RDoc::Parser::Ruby, parser
-
-      assert_equal top_level.absolute_name, parser.file_name
-    end
-  end
-
-  def test_class_for_forbidden
-    omit 'chmod not supported' if Gem.win_platform?
-
-    tf = Tempfile.open 'forbidden' do |io|
-      begin
-        File.chmod 0000, io.path
-        forbidden = @store.add_file io.path
-
-        parser = @RP.for forbidden, '', @options, :stats
-
-        assert_nil parser
-      ensure
-        File.chmod 0400, io.path
-      end
-      io
-    end
-    tf.close!
-  end
-
-  def test_class_for_modeline
-    with_top_level("NEWS", "# -*- rdoc -*-\n= NEWS\n") do |top_level, content|
-      parser = @RP.for top_level, content, @options, :stats
-
-      assert_kind_of RDoc::Parser::Simple, parser
-
-      assert_equal "= NEWS\n", parser.content
-    end
-  end
-
-  def test_can_parse_modeline
-    readme_ext = File.join Dir.tmpdir, "README.EXT.#{$$}"
-
-    File.open readme_ext, 'w' do |io|
-      io.puts "# README.EXT -  -*- rdoc -*- created at: Mon Aug 7 16:45:54 JST 1995"
-      io.puts
-      io.puts "This document explains how to make extension libraries for Ruby."
-    end
-
-    assert_equal RDoc::Parser::Simple, @RP.can_parse(readme_ext)
-  ensure
-    File.unlink readme_ext
-  end
-
-  def test_can_parse_modeline_c
-    readme_inc = File.join Dir.tmpdir, "README.inc.#{$$}"
-
-    File.open readme_inc, 'w' do |io|
-      io.puts "/* README.inc -  -*- c -*- created at: Mon Aug 7 16:45:54 JST 1995 */"
-      io.puts
-      io.puts "/* This document explains how to make extension libraries for Ruby. */"
-    end
-
-    assert_equal RDoc::Parser::C, @RP.can_parse(readme_inc)
-  ensure
-    File.unlink readme_inc
-  end
-
-  ##
-  # Selenium hides a .jar file using a .txt extension.
-
-  def test_class_can_parse_zip
-    hidden_zip = File.expand_path '../hidden.zip.txt', __FILE__
-    assert_nil @RP.can_parse(hidden_zip)
-  end
-
-  def test_check_modeline
-    readme_ext = File.join Dir.tmpdir, "README.EXT.#{$$}"
-
-    File.open readme_ext, 'w' do |io|
-      io.puts "# README.EXT -  -*- RDoc -*- created at: Mon Aug 7 16:45:54 JST 1995"
-      io.puts
-      io.puts "This document explains how to make extension libraries for Ruby."
-    end
-
-    assert_equal 'rdoc', @RP.check_modeline(readme_ext)
-  ensure
-    File.unlink readme_ext
-  end
-
-  def test_check_modeline_coding
-    readme_ext = File.join Dir.tmpdir, "README.EXT.#{$$}"
-
-    File.open readme_ext, 'w' do |io|
-      io.puts "# -*- coding: utf-8 -*-"
-    end
-
-    assert_nil @RP.check_modeline readme_ext
-  ensure
-    File.unlink readme_ext
-  end
-
-  def test_check_modeline_with_other
-    readme_ext = File.join Dir.tmpdir, "README.EXT.#{$$}"
-
-    File.open readme_ext, 'w' do |io|
-      io.puts "# README.EXT -  -*- mode: RDoc; indent-tabs-mode: nil -*-"
-      io.puts
-      io.puts "This document explains how to make extension libraries for Ruby."
-    end
-
-    assert_equal 'rdoc', @RP.check_modeline(readme_ext)
-  ensure
-    File.unlink readme_ext
-  end
-
-  def test_check_modeline_no_modeline
-    readme_ext = File.join Dir.tmpdir, "README.EXT.#{$$}"
-
-    File.open readme_ext, 'w' do |io|
-      io.puts "This document explains how to make extension libraries for Ruby."
-    end
-
-    assert_nil @RP.check_modeline(readme_ext)
-  ensure
-    File.unlink readme_ext
-  end
-
-  def test_class_for_binary
-    dat_fixture = File.read(@binary_dat_fixture_path)
-    with_top_level("binary.dat", dat_fixture) do |top_level, content|
-      assert_nil @RP.for(top_level, content, @options, nil)
-    end
-  end
-
-  def test_class_for_markup
-    with_top_level("file.rb", "# coding: utf-8 markup: rd") do |top_level, content|
-      parser = @RP.for top_level, content, @options, nil
-
-      assert_kind_of @RP::RD, parser
-    end
-  end
-
-  def test_class_use_markup
-    content = <<-CONTENT
-# coding: utf-8 markup: rd
-    CONTENT
-
-    parser = @RP.use_markup content
-
-    assert_equal @RP::RD, parser
-  end
-
-  def test_class_use_markup_markdown
-    content = <<-CONTENT
-# coding: utf-8 markup: markdown
-    CONTENT
-
-    parser = @RP.use_markup content
-
-    assert_equal @RP::Ruby, parser
-  end
-
-  def test_class_use_markup_modeline
-    content = <<-CONTENT
-# -*- coding: utf-8 -*-
-# markup: rd
-    CONTENT
-
-    parser = @RP.use_markup content
-
-    assert_equal @RP::RD, parser
-  end
-
-  def test_class_use_markup_modeline_shebang
-    content = <<-CONTENT
-#!/bin/sh
-/* -*- coding: utf-8 -*-
- * markup: rd
- */
-    CONTENT
-
-    parser = @RP.use_markup content
-
-    assert_equal @RP::RD, parser
-  end
-
-  def test_class_use_markup_shebang
-    content = <<-CONTENT
-#!/usr/bin/env ruby
-# coding: utf-8 markup: rd
-    CONTENT
-
-    parser = @RP.use_markup content
-
-    assert_equal @RP::RD, parser
-  end
-
-  def test_class_use_markup_tomdoc
-    content = <<-CONTENT
-# coding: utf-8 markup: tomdoc
-    CONTENT
-
-    parser = @RP.use_markup content
-
-    assert_equal @RP::Ruby, parser
-  end
-
-  def test_class_use_markup_none
-    parser = @RP.use_markup ''
-
-    assert_nil parser
-  end
-
-  def test_class_use_markup_unknown
-    content = <<-CONTENT
-# :markup: RDoc
-    CONTENT
-
-    parser = @RP.use_markup content
-
-    assert_nil parser
-  end
-
-  def test_initialize
-    with_top_level("file.rb", "") do |top_level, content|
-      @RP.new top_level, content, @options, nil
-
-      assert_equal @RP, top_level.parser
-    end
-  end
-
-  private
-
-  def with_top_level(filename, content, &block)
-    absoluate_filename  = File.join Dir.tmpdir, filename
-    File.open absoluate_filename, 'w' do |io|
-      io.write content
-    end
-
-    top_level = RDoc::TopLevel.new absoluate_filename
-
-    yield(top_level, content)
-  ensure
-    File.unlink absoluate_filename
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc/rdoc_rd_block_parser_test.rb b/test/mri/rdoc/rdoc/rdoc_rd_block_parser_test.rb
deleted file mode 100644
index 50bf075a5a7..00000000000
--- a/test/mri/rdoc/rdoc/rdoc_rd_block_parser_test.rb
+++ /dev/null
@@ -1,557 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocRdBlockParserTest < RDoc::TestCase
-
-  def setup
-    super
-
-    @block_parser = RDoc::RD::BlockParser.new
-  end
-
-  def test_add_footnote
-    index = @block_parser.add_footnote 'context'
-
-    assert_equal 1, index
-
-    expected = [
-      para('{^1}[rdoc-label:footmark-1:foottext-1]', ' ', 'context'),
-      blank_line,
-    ]
-
-    assert_equal expected, @block_parser.footnotes
-
-    index = @block_parser.add_footnote 'other'
-
-    assert_equal 2, index
-  end
-
-  def test_parse_desclist
-    list = <<-LIST
-:one
-  desc one
-:two
-  desc two
-    LIST
-
-    expected =
-      doc(
-        list(:NOTE,
-          item("one", para("desc one")),
-          item("two", para("desc two"))))
-
-    assert_equal expected, parse(list)
-  end
-
-  def test_parse_enumlist
-    list = <<-LIST
-(1) one
-(1) two
-    LIST
-
-    expected =
-      doc(
-        list(:NUMBER,
-          item(nil, para("one")),
-          item(nil, para("two"))))
-
-    assert_equal expected, parse(list)
-  end
-
-  def test_parse_enumlist_paragraphs
-    list = <<-LIST
-(1) one
-
-    two
-    LIST
-
-    expected =
-      doc(
-        list(:NUMBER,
-          item(nil,
-            para("one"),
-            para("two"))))
-
-    assert_equal expected, parse(list)
-  end
-
-  def test_parse_enumlist_multiline
-    list = <<-LIST
-(1) one
-    two
-    LIST
-
-    contents = "one\n     two" # 1.8 vs 1.9
-
-    expected =
-      doc(
-        list(:NUMBER,
-          item(nil, para(*contents))))
-
-    assert_equal expected, parse(list)
-  end
-
-  def test_parse_enumlist_verbatim
-    list = <<-LIST
-(1) item
-      verbatim
-    LIST
-
-    expected =
-      doc(
-        list(:NUMBER,
-          item(nil,
-            para("item"),
-            verb("verbatim\n"))))
-
-    assert_equal expected, parse(list)
-  end
-
-  def test_parse_enumlist_verbatim_continue
-    list = <<-LIST
-(1) one
-      verbatim
-    two
-    LIST
-
-    expected =
-      doc(
-        list(:NUMBER,
-          item(nil,
-            para("one"),
-            verb("verbatim\n"),
-            para("two"))))
-
-    assert_equal expected, parse(list)
-  end
-
-  def test_parse_footnote
-    expected =
-      doc(
-        para("{*1}[rdoc-label:foottext-1:footmark-1]"),
-        rule(1),
-        para("{^1}[rdoc-label:footmark-1:foottext-1]", " ", "text"),
-        blank_line)
-
-    assert_equal expected, parse("((-text-))")
-  end
-
-  def test_parse_include
-    @block_parser.include_path = [Dir.tmpdir]
-
-    expected = doc(@RM::Include.new("parse_include", [Dir.tmpdir]))
-
-    assert_equal expected, parse("<<< parse_include")
-  end
-
-  def test_parse_include_subtree
-    @block_parser.include_path = [Dir.tmpdir]
-
-    expected =
-      doc(
-        blank_line,
-        para("include <em>worked</em>"),
-        blank_line,
-        blank_line)
-
-    tf = Tempfile.open %w[parse_include .rd] do |io|
-      io.puts "=begin\ninclude ((*worked*))\n=end"
-      io.flush
-
-      str = <<-STR
-<<< #{File.basename io.path}
-      STR
-
-      assert_equal expected, parse(str)
-      io
-    end
-    tf.close!
-  end
-
-=begin
-  def test_parse_include_other_format
-    @block_parser.include_path = [Dir.tmpdir]
-
-    expected =
-      doc(
-        blank_line,
-        para("include ((*worked*))"),
-        blank_line,
-        blank_line)
-
-    str = <<~STR
-    =begin nonrd
-    <<< worked
-    =end
-    STR
-
-    assert_equal(expected, @block_parser.parse str.lines.to_a)
-  end
-=end
-
-  def test_parse_heading
-    assert_equal doc(head(1, "H")), parse("= H")
-    assert_equal doc(head(2, "H")), parse("== H")
-    assert_equal doc(head(3, "H")), parse("=== H")
-    assert_equal doc(head(4, "H")), parse("==== H")
-    assert_equal doc(head(5, "H")), parse("+ H")
-    assert_equal doc(head(6, "H")), parse("++ H")
-  end
-
-  def test_parse_itemlist
-    list = <<-LIST
-* one
-* two
-    LIST
-
-    expected =
-      doc(
-        list(:BULLET,
-          item(nil, para("one")),
-          item(nil, para("two"))))
-
-    assert_equal expected, parse(list)
-  end
-
-  def test_parse_itemlist_multiline
-    list = <<-LIST
-* one
-  two
-    LIST
-
-    contents = "one\n   two" # 1.8 vs 1.9
-
-    expected =
-      doc(
-        list(:BULLET,
-          item(nil, para(*contents))))
-
-    assert_equal expected, parse(list)
-  end
-
-  def test_parse_itemlist_nest
-    list = <<-LIST
-* one
-  * inner
-* two
-    LIST
-
-    expected =
-      doc(
-        list(:BULLET,
-          item(nil,
-            para("one"),
-            list(:BULLET,
-              item(nil, para("inner")))),
-          item(nil,
-            para("two"))))
-
-    assert_equal expected, parse(list)
-  end
-
-  def test_parse_itemlist_paragraphs
-    list = <<-LIST
-* one
-
-  two
-    LIST
-
-    expected =
-      doc(
-        list(:BULLET,
-          item(nil,
-            para("one"),
-            para("two"))))
-
-    assert_equal expected, parse(list)
-  end
-
-  def test_parse_itemlist_verbatim
-    list = <<-LIST
-* item
-    verbatim
-    LIST
-
-    expected =
-      doc(
-        list(:BULLET,
-          item(nil,
-            para("item"),
-            verb("verbatim\n"))))
-
-    assert_equal expected, parse(list)
-  end
-
-  def test_parse_itemlist_verbatim_continue
-    list = <<-LIST
-* one
-    verbatim
-  two
-    LIST
-
-    expected =
-      doc(
-        list(:BULLET,
-          item(nil,
-            para("one"),
-            verb("verbatim\n"),
-            para("two"))))
-
-    assert_equal expected, parse(list)
-  end
-
-  def test_parse_lists
-    list = <<-LIST
-(1) one
-(1) two
-* three
-* four
-(1) five
-(1) six
-    LIST
-
-    expected =
-      doc(
-        list(:NUMBER,
-          item(nil, para("one")),
-          item(nil, para("two"))),
-        list(:BULLET,
-          item(nil, para("three")),
-          item(nil, para("four"))),
-        list(:NUMBER,
-          item(nil, para("five")),
-          item(nil, para("six"))))
-
-    assert_equal expected, parse(list)
-  end
-
-  def test_parse_lists_nest
-    list = <<-LIST
-(1) one
-(1) two
-      * three
-      * four
-(1) five
-(1) six
-    LIST
-
-    expected =
-      doc(
-        list(:NUMBER,
-          item(nil, para("one")),
-          item(nil,
-            para("two"),
-            list(:BULLET,
-              item(nil, para("three")),
-              item(nil, para("four")))),
-          item(nil, para("five")),
-          item(nil, para("six"))))
-
-    assert_equal expected, parse(list)
-  end
-
-  def test_parse_lists_nest_verbatim
-    list = <<-LIST
-(1) one
-(1) two
-      * three
-      * four
-     verbatim
-(1) five
-(1) six
-    LIST
-
-    expected =
-      doc(
-        list(:NUMBER,
-          item(nil, para("one")),
-          item(nil,
-            para("two"),
-            list(:BULLET,
-              item(nil, para("three")),
-              item(nil, para("four"))),
-            verb("verbatim\n")),
-          item(nil, para("five")),
-          item(nil, para("six"))))
-
-    assert_equal expected, parse(list)
-  end
-
-  def test_parse_lists_nest_verbatim2
-    list = <<-LIST
-(1) one
-(1) two
-      * three
-      * four
-      verbatim
-(1) five
-(1) six
-    LIST
-
-    expected =
-      doc(
-        list(:NUMBER,
-          item(nil, para("one")),
-          item(nil,
-            para("two"),
-            list(:BULLET,
-              item(nil, para("three")),
-              item(nil, para("four"))),
-            verb("verbatim\n")),
-          item(nil, para("five")),
-          item(nil, para("six"))))
-
-    assert_equal expected, parse(list)
-  end
-
-  def test_parse_methodlist
-    list = <<-LIST
---- Array#each {|i| ... }
-      yield block for each item.
---- Array#index(val)
-      return index of first item which equals with val. if it hasn't
-      same item, return nil.
-    LIST
-
-    expected =
-      doc(
-        list(:LABEL,
-          item(
-            "<tt>Array#each {|i| ... }</tt>",
-            para("yield block for each item.")),
-          item(
-            "<tt>Array#index(val)</tt>",
-            para("return index of first item which equals with val. if it hasn't same item, return nil."))))
-
-    assert_equal expected, parse(list)
-  end
-
-  def test_parse_methodlist_empty
-    list = <<-LIST
---- A#b
-
-    LIST
-
-    expected =
-      doc(
-        list(:LABEL,
-          item("<tt>A#b</tt>")))
-
-    assert_equal expected, parse(list)
-  end
-
-  def test_parse_methodlist_paragraph
-    list = <<-LIST
---- A#b
-
-    one
-    LIST
-
-    expected =
-      doc(
-        list(:LABEL,
-          item(
-            "<tt>A#b</tt>",
-            para("one"))))
-
-    assert_equal expected, parse(list)
-  end
-
-  def test_parse_methodlist_paragraph2
-    list = <<-LIST.chomp
---- A#b
-
-    one
-two
-    LIST
-
-    expected =
-      doc(
-        list(:LABEL,
-          item(
-            "<tt>A#b</tt>",
-            para("one"))),
-        para("two"))
-
-    assert_equal expected, parse(list)
-  end
-
-  def test_parse_methodlist_paragraph_verbatim
-    list = <<-LIST.chomp
---- A#b
-
-    text
-      verbatim
-    LIST
-
-    expected =
-      doc(
-        list(:LABEL,
-          item(
-            "<tt>A#b</tt>",
-            para("text"),
-            verb("verbatim\n"))))
-
-    assert_equal expected, parse(list)
-  end
-
-  def test_parse_verbatim
-    assert_equal doc(verb("verbatim\n")), parse("  verbatim")
-  end
-
-  def test_parse_verbatim_blankline
-    expected = doc(verb("one\n", "\n", "two\n"))
-
-    verbatim = <<-VERBATIM
-  one
-
-  two
-    VERBATIM
-
-    assert_equal expected, parse(verbatim)
-  end
-
-  def test_parse_verbatim_indent
-    expected = doc(verb("one\n", " two\n"))
-
-    verbatim = <<-VERBATIM
-  one
-   two
-    VERBATIM
-
-    assert_equal expected, parse(verbatim)
-  end
-
-  def test_parse_verbatim_multi
-    expected = doc(verb("one\n", "two\n"))
-
-    verbatim = <<-VERBATIM
-  one
-  two
-    VERBATIM
-
-    assert_equal expected, parse(verbatim)
-  end
-
-  def test_parse_textblock
-    assert_equal doc(para("text")), parse("text")
-  end
-
-  def test_parse_textblock_multi
-    expected = doc(para("one two"))
-
-    assert_equal expected, parse("one\ntwo")
-  end
-
-  def parse(text)
-    text = ["=begin", text, "=end"].join "\n"
-
-    doc = @block_parser.parse text.lines.to_a
-
-    assert_equal blank_line, doc.parts.shift, "=begin blankline"
-    assert_equal blank_line, doc.parts.pop, "=end blankline"
-
-    doc
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc/rdoc_rd_inline_parser_test.rb b/test/mri/rdoc/rdoc/rdoc_rd_inline_parser_test.rb
deleted file mode 100644
index e484dbe8334..00000000000
--- a/test/mri/rdoc/rdoc/rdoc_rd_inline_parser_test.rb
+++ /dev/null
@@ -1,178 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocRdInlineParserTest < RDoc::TestCase
-
-  def setup
-    super
-
-    @block_parser = RDoc::RD::BlockParser.new
-    @block_parser.instance_variable_set :@i, 0
-    @inline_parser = RDoc::RD::InlineParser.new @block_parser
-  end
-
-  def test_parse
-    assert_equal 'regular <em>emphasis</em>', parse('regular ((*emphasis*))')
-  end
-
-  def test_parse_code
-    assert_equal '<code>text</code>', parse('(({text}))')
-  end
-
-  def test_parse_em
-    assert_equal '<em>text</em>', parse('((*text*))')
-  end
-
-  def test_parse_footnote
-    assert_equal '{*1}[rdoc-label:foottext-1:footmark-1]', parse('((-text-))')
-
-    expected = [
-      @RM::Paragraph.new('{^1}[rdoc-label:footmark-1:foottext-1]', ' ', 'text'),
-      blank_line,
-    ]
-
-    assert_equal expected, @block_parser.footnotes
-  end
-
-  def test_parse_index
-    assert_equal '<span id="label-text">text</span>', parse('((:text:))')
-
-    assert_includes @block_parser.labels, 'text'
-  end
-
-  def test_parse_kbd
-    assert_equal '<tt>text</tt>', parse('((%text%))')
-  end
-
-  def test_parse_multiple
-    assert_equal '<em>one</em> <em>two</em>', parse('((*one*)) ((*two*))')
-  end
-
-  def test_parse_newline
-    assert_equal "one\ntwo", parse("one\ntwo")
-  end
-
-  def test_parse_quote
-    assert_equal 'one " two', parse('one " two')
-  end
-
-  def test_parse_ref
-    assert_equal '{text}[rdoc-label:text]', parse('((<text>))')
-  end
-
-  def test_parse_ref_em
-    assert_equal '{<em>text</em>}[rdoc-label:text]', parse('((<((*text*))>))')
-  end
-
-  def test_parse_ref_filename_quote
-    assert_equal '{RD/foo}[rdoc-label:RD/foo]', parse('((<RD/"foo">))')
-  end
-
-  def test_parse_ref_filename
-    assert_equal '{RD}[rdoc-label:RD/]', parse('((<RD/>))')
-  end
-
-  def test_parse_ref_quote
-    assert_equal '{text \\"}[rdoc-label:text \\"]', parse('((<text \">))')
-  end
-
-  def test_parse_ref_quote_content
-    assert_equal '{<em>text</em>}[rdoc-label:text]',
-                 parse('((<"((*text*))">))')
-  end
-
-  def test_parse_ref_quote_content_multi
-    assert_equal '{<em>one</em> <em>two</em>}[rdoc-label:one two]',
-                 parse('((<"((*one*)) ((*two*))">))')
-  end
-
-  def test_parse_ref_substitute
-    assert_equal '{text}[rdoc-label:thing]', parse('((<text|thing>))')
-  end
-
-  def test_parse_ref_substitute_element_quote
-    assert_equal '{text}[rdoc-label:"RD"]',
-                 parse('((<text|"RD">))')
-  end
-
-  def test_parse_ref_substitute_filename
-    assert_equal '{text}[rdoc-label:RD/]', parse('((<text|RD/>))')
-  end
-
-  def test_parse_ref_substitute_filename_label
-    assert_equal '{text}[rdoc-label:RD/label]',
-                 parse('((<text|RD/label>))')
-  end
-
-  def test_parse_ref_substitute_filename_quote
-    assert_equal '{text}[rdoc-label:"RD"/]', parse('((<text|"RD"/>))')
-  end
-
-  def test_parse_ref_substitute_multi_content
-    assert_equal '{<em>one</em> two}[rdoc-label:thing]',
-                 parse('((<((*one*)) two|thing>))')
-  end
-
-  def test_parse_ref_substitute_multi_content2
-    assert_equal '{<em>one</em> \\" two}[rdoc-label:thing]',
-                 parse('((<((*one*)) \" two|thing>))')
-  end
-
-  def test_parse_ref_substitute_multi_content3
-    assert_equal '{<em>one</em> \\" <em>two</em>}[rdoc-label:thing]',
-                 parse('((<((*one*)) \" ((*two*))|thing>))')
-  end
-
-  def test_parse_ref_substitute_quote
-    assert_equal '{one | two}[rdoc-label:thing]',
-                 parse('((<"one | two"|thing>))')
-  end
-
-  def test_parse_ref_substitute_quote_content
-    assert_equal '{<em>text</em>}[rdoc-label:thing]',
-                 parse('((<"((*text*))"|thing>))')
-  end
-
-  def test_parse_ref_substitute_url
-    assert_equal '{text}[http://example]',
-                 parse('((<text|URL:http://example>))')
-  end
-
-  def test_parse_ref_url
-    assert_equal '{http://example}[http://example]',
-                 parse('((<URL:http://example>))')
-  end
-
-  def test_parse_var
-    assert_equal '+text+', parse('((|text|))')
-  end
-
-  def test_parse_verb
-    assert_equal '<tt>text</tt>', parse("(('text'))")
-  end
-
-  def test_parse_verb_backslash
-    assert_equal "<tt>(('text'))</tt>", parse("(('(('text\\'))'))")
-  end
-
-  def test_parse_verb_backslash_backslash
-    assert_equal '<tt>text \\</tt>', parse("(('text \\\\'))")
-  end
-
-  def test_parse_verb_backslash_quote
-    assert_equal '<tt>text "</tt>', parse("(('text \\\"'))")
-  end
-
-  def test_parse_verb_emphasis
-    assert_equal '<tt>((*emphasis*))</tt>', parse("(('((*emphasis*))'))")
-  end
-
-  def test_parse_verb_multiple
-    assert_equal '<tt>((*text*))</tt>', parse("(('((*text*))'))")
-  end
-
-  def parse(text)
-    @inline_parser.parse text
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc/rdoc_rd_inline_test.rb b/test/mri/rdoc/rdoc/rdoc_rd_inline_test.rb
deleted file mode 100644
index c4984949f4c..00000000000
--- a/test/mri/rdoc/rdoc/rdoc_rd_inline_test.rb
+++ /dev/null
@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocRdInlineTest < RDoc::TestCase
-
-  def setup
-    super
-
-    @inline = RDoc::RD::Inline.new '+text+', 'text'
-  end
-
-  def test_class_new
-    inline = RDoc::RD::Inline.new @inline
-
-    refute_equal inline.rdoc, inline.reference
-  end
-
-  def test_initialize
-    inline = RDoc::RD::Inline.new 'text'
-
-    assert_equal inline.rdoc, inline.reference
-    refute_same  inline.rdoc, inline.reference
-  end
-
-  def test_initialize_inline
-    inline = RDoc::RD::Inline.new @inline
-
-    assert_equal '+text+', inline.rdoc
-    assert_equal 'text',   inline.reference
-  end
-
-  def test_append_inline
-    out = @inline.append @inline
-
-    assert_same @inline, out
-
-    assert_equal '+text++text+', @inline.rdoc
-    assert_equal 'texttext',     @inline.reference
-  end
-
-  def test_append_string
-    @inline.append ' more'
-
-    assert_equal '+text+ more', @inline.rdoc
-    assert_equal 'text more',   @inline.reference
-  end
-
-  def test_equals2
-    assert_equal @inline, RDoc::RD::Inline.new('+text+', 'text')
-    refute_equal @inline, RDoc::RD::Inline.new('+text+', 'other')
-    refute_equal @inline, RDoc::RD::Inline.new('+other+', 'text')
-    refute_equal @inline, Object.new
-  end
-
-  def test_inspect
-    assert_equal '(inline: +text+)', @inline.inspect
-  end
-
-  def test_to_s
-    assert_equal '+text+', @inline.to_s
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc/rdoc_rd_test.rb b/test/mri/rdoc/rdoc/rdoc_rd_test.rb
deleted file mode 100644
index 8842aaccbee..00000000000
--- a/test/mri/rdoc/rdoc/rdoc_rd_test.rb
+++ /dev/null
@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocRdTest < RDoc::TestCase
-
-  def test_class_parse
-    expected =
-      @RM::Document.new(
-        @RM::Paragraph.new('hello'))
-
-    assert_equal expected, RDoc::RD.parse("hello")
-  end
-
-  def test_class_parse_begin_end
-    expected =
-      @RM::Document.new(
-        @RM::Paragraph.new('hello'))
-
-    assert_equal expected, RDoc::RD.parse("=begin\nhello\n=end\n")
-  end
-
-  def test_class_parse_newline
-    expected =
-      @RM::Document.new(
-        @RM::Paragraph.new('hello'))
-
-    assert_equal expected, RDoc::RD.parse("hello\n")
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc/rdoc_rdoc_test.rb b/test/mri/rdoc/rdoc/rdoc_rdoc_test.rb
deleted file mode 100644
index 6760badfe2c..00000000000
--- a/test/mri/rdoc/rdoc/rdoc_rdoc_test.rb
+++ /dev/null
@@ -1,582 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocRDocTest < RDoc::TestCase
-
-  def setup
-    super
-
-    @rdoc = RDoc::RDoc.new
-    @options = RDoc::Options.new
-    @rdoc.options = @options
-
-    @stats = RDoc::Stats.new @store, 0, 0
-    @rdoc.instance_variable_set :@stats, @stats
-  end
-
-  def test_document # functional test
-    options = RDoc::Options.new
-    options.files = [File.expand_path('../xref_data.rb', __FILE__)]
-    options.setup_generator 'ri'
-    options.main_page = 'MAIN_PAGE.rdoc'
-    options.root      = Pathname File.expand_path('..', __FILE__)
-    options.title     = 'title'
-
-    rdoc = RDoc::RDoc.new
-
-    temp_dir do
-      options.op_dir = 'ri'
-
-      capture_output do
-        rdoc.document options
-      end
-
-      assert File.directory? 'ri'
-    end
-
-    store = rdoc.store
-
-    assert_equal 'MAIN_PAGE.rdoc', store.main
-    assert_equal 'title',          store.title
-  end
-
-  def test_document_with_dry_run # functional test
-    options = RDoc::Options.new
-    options.files = [File.expand_path('../xref_data.rb', __FILE__)]
-    options.setup_generator 'darkfish'
-    options.main_page = 'MAIN_PAGE.rdoc'
-    options.root      = Pathname File.expand_path('..', __FILE__)
-    options.title     = 'title'
-    options.dry_run = true
-
-    rdoc = RDoc::RDoc.new
-
-    out = nil
-    temp_dir do
-      out, = capture_output do
-        rdoc.document options
-      end
-
-      refute File.directory? 'doc'
-    end
-    assert_includes out, '100%'
-
-    store = rdoc.store
-
-    assert_equal 'MAIN_PAGE.rdoc', store.main
-    assert_equal 'title',          store.title
-  end
-
-  def test_gather_files
-    a = File.expand_path __FILE__
-    b = File.expand_path '../rdoc_text_test.rb', __FILE__
-
-    assert_equal [a, b], @rdoc.gather_files([b, a, b])
-
-    assert_empty @rdoc.gather_files([b, a, b])
-
-    @rdoc.last_modified[a] -= 10
-    assert_equal [a, b], @rdoc.gather_files([b, a, b])
-  end
-
-  def test_handle_pipe
-    $stdin = StringIO.new "hello"
-
-    out, = capture_output do
-      @rdoc.handle_pipe
-    end
-
-    assert_equal "\n<p>hello</p>\n", out
-  ensure
-    $stdin = STDIN
-  end
-
-  def test_handle_pipe_rd
-    $stdin = StringIO.new "=begin\nhello\n=end"
-
-    @rdoc.options.markup = 'rd'
-
-    out, = capture_output do
-      @rdoc.handle_pipe
-    end
-
-    assert_equal "\n<p>hello</p>\n", out
-  ensure
-    $stdin = STDIN
-  end
-
-  def test_normalized_file_list
-    test_path = File.expand_path(__FILE__)
-    files = temp_dir do |dir|
-      flag_file = @rdoc.output_flag_file dir
-
-      FileUtils.touch flag_file
-
-      @rdoc.normalized_file_list [test_path, flag_file]
-    end
-
-    files = files.map { |file, *| File.expand_path file }
-
-    assert_equal [test_path], files
-  end
-
-  def test_normalized_file_list_not_modified
-    @rdoc.last_modified[__FILE__] = File.stat(__FILE__).mtime
-
-    files = @rdoc.normalized_file_list [__FILE__]
-
-    files = files.collect {|file, mtime| file if mtime}.compact
-
-    assert_empty(files)
-  end
-
-  def test_normalized_file_list_non_file_directory
-    dev = File::NULL
-    omit "#{dev} is not a character special" unless
-      File.chardev? dev
-
-    files = nil
-
-    out, err = verbose_capture_output do
-      files = @rdoc.normalized_file_list [dev]
-    end
-
-    files = files.map { |file| File.expand_path file }
-
-    assert_empty files
-
-    assert_empty out
-    assert_match %r"^rdoc can't parse", err
-    assert_match %r"#{dev}$",           err
-  end
-
-  def test_normalized_file_list_with_dot_doc
-    expected_files = []
-    files = temp_dir do |dir|
-      a = File.expand_path('a.rb')
-      b = File.expand_path('b.rb')
-      c = File.expand_path('c.rb')
-      FileUtils.touch a
-      FileUtils.touch b
-      FileUtils.touch c
-      # Use Dir.glob to convert short path of Dir.tmpdir to long path.
-      a = Dir.glob(a).first
-      b = Dir.glob(b).first
-      c = Dir.glob(c).first
-
-      File.write('.document', "a.rb\n""b.rb\n")
-      expected_files << a
-      expected_files << b
-
-      @rdoc.normalized_file_list [File.realpath(dir)]
-    end
-
-    files = files.map { |file, *| File.expand_path file }
-
-    assert_equal expected_files, files
-  end
-
-  def test_normalized_file_list_with_dot_doc_overridden_by_exclude_option
-    expected_files = []
-    files = temp_dir do |dir|
-      a = File.expand_path('a.rb')
-      b = File.expand_path('b.rb')
-      c = File.expand_path('c.rb')
-      FileUtils.touch a
-      FileUtils.touch b
-      FileUtils.touch c
-      # Use Dir.glob to convert short path of Dir.tmpdir to long path.
-      a = Dir.glob(a).first
-      b = Dir.glob(b).first
-      c = Dir.glob(c).first
-
-      File.write('.document', "a.rb\n""b.rb\n")
-      expected_files << a
-
-      @rdoc.options.exclude = /b\.rb$/
-      @rdoc.normalized_file_list [File.realpath(dir)]
-    end
-
-    files = files.map { |file, *| File.expand_path file }
-
-    assert_equal expected_files, files
-  end
-
-  def test_normalized_file_list_with_skipping_tests_enabled
-    files = temp_dir do |dir|
-      @a = File.expand_path('a.rb')
-      spec_dir = File.expand_path('spec')
-      spec_file = File.expand_path(File.join('spec', 'my_spec.rb'))
-      test_dir = File.expand_path('test')
-      test_file = File.expand_path(File.join('test', 'my_test.rb'))
-      FileUtils.touch @a
-      FileUtils.mkdir_p spec_dir
-      FileUtils.touch spec_file
-      FileUtils.mkdir_p test_dir
-      FileUtils.touch test_file
-
-      @rdoc.options.skip_tests = true
-      @rdoc.normalized_file_list [File.realpath(dir)]
-    end
-
-    files = files.map { |file, *| File.expand_path file }
-    assert_equal [@a], files
-  end
-
-  def test_normalized_file_list_with_skipping_tests_disabled
-    files = temp_dir do |dir|
-      @a = File.expand_path('a.rb')
-      spec_dir = File.expand_path('spec')
-      @spec_file = File.expand_path(File.join('spec', 'my_spec.rb'))
-      test_dir = File.expand_path('test')
-      @test_file = File.expand_path(File.join('test', 'my_test.rb'))
-      FileUtils.touch @a
-      FileUtils.mkdir_p spec_dir
-      FileUtils.touch @spec_file
-      FileUtils.mkdir_p test_dir
-      FileUtils.touch @test_file
-
-      @rdoc.options.skip_tests = false
-      @rdoc.normalized_file_list [File.realpath(dir)]
-    end
-
-    files = files.map { |file, *| File.expand_path file }
-    assert_equal [@a, @spec_file, @test_file], files.sort
-  end
-
-  def test_parse_file
-    @rdoc.store = RDoc::Store.new(@options)
-
-    temp_dir do |dir|
-      @rdoc.options.root = Pathname(Dir.pwd)
-
-      File.open 'test.txt', 'w' do |io|
-        io.puts 'hi'
-      end
-
-      top_level = @rdoc.parse_file 'test.txt'
-
-      assert_equal 'test.txt', top_level.absolute_name
-      assert_equal 'test.txt', top_level.relative_name
-    end
-  end
-
-  def test_parse_file_binary
-    @rdoc.store = RDoc::Store.new(@options)
-
-    root = File.dirname __FILE__
-
-    @rdoc.options.root = Pathname root
-
-    out, err = capture_output do
-      Dir.chdir root do
-        assert_nil @rdoc.parse_file 'binary.dat'
-      end
-    end
-
-    assert_empty out
-    assert_empty err
-  end
-
-  def test_parse_file_include_root
-    @rdoc.store = RDoc::Store.new(@options)
-
-    test_path = File.expand_path('..', __FILE__)
-    top_level = nil
-    temp_dir do |dir|
-      @rdoc.options.parse %W[--root #{test_path}]
-      @rdoc.options.finish
-
-      File.open 'include.txt', 'w' do |io|
-        io.puts ':include: test.txt'
-      end
-
-      out, err = capture_output do
-        top_level = @rdoc.parse_file 'include.txt'
-      end
-      assert_empty out
-      assert_empty err
-    end
-    assert_equal "test file", top_level.comment.text
-  end
-
-  def test_parse_file_page_dir
-    @rdoc.store = RDoc::Store.new(@options)
-
-    temp_dir do |dir|
-      FileUtils.mkdir 'pages'
-      @rdoc.options.page_dir = Pathname('pages')
-      @rdoc.options.root = Pathname(Dir.pwd)
-
-      File.open 'pages/test.txt', 'w' do |io|
-        io.puts 'hi'
-      end
-
-      top_level = @rdoc.parse_file 'pages/test.txt'
-
-      assert_equal 'pages/test.txt', top_level.absolute_name
-      assert_equal 'test.txt',       top_level.relative_name
-    end
-  end
-
-  def test_parse_file_relative
-    pwd = Dir.pwd
-
-    @rdoc.store = RDoc::Store.new(@options)
-
-    temp_dir do |dir|
-      @rdoc.options.root = Pathname(dir)
-
-      File.open 'test.txt', 'w' do |io|
-        io.puts 'hi'
-      end
-
-      test_txt = File.join dir, 'test.txt'
-
-      Dir.chdir pwd do
-        top_level = @rdoc.parse_file test_txt
-
-        assert_equal test_txt,   top_level.absolute_name
-        assert_equal 'test.txt', top_level.relative_name
-      end
-    end
-  end
-
-  def test_parse_file_encoding
-    @rdoc.options.encoding = Encoding::ISO_8859_1
-    @rdoc.store = RDoc::Store.new(@options)
-
-    tf = Tempfile.open 'test.txt' do |io|
-      io.write 'hi'
-      io.rewind
-
-      top_level = @rdoc.parse_file io.path
-
-      assert_equal Encoding::ISO_8859_1, top_level.absolute_name.encoding
-      io
-    end
-    tf.close!
-  end
-
-  def test_parse_file_forbidden
-    omit 'chmod not supported' if Gem.win_platform?
-    omit "assumes that euid is not root" if Process.euid == 0
-
-    @rdoc.store = RDoc::Store.new(@options)
-
-    tf = Tempfile.open 'test.txt' do |io|
-      io.write 'hi'
-      io.rewind
-
-      File.chmod 0000, io.path
-
-      begin
-        top_level = :bug
-
-        _, err = capture_output do
-          top_level = @rdoc.parse_file io.path
-        end
-
-        assert_match "Unable to read #{io.path},", err
-
-        assert_nil top_level
-      ensure
-        File.chmod 0400, io.path
-      end
-      io
-    end
-    tf.close!
-  end
-
-  def test_remove_unparseable
-    file_list = %w[
-      blah.class
-      blah.eps
-      blah.erb
-      blah.scpt.txt
-      blah.svg
-      blah.ttf
-      blah.yml
-    ]
-
-    assert_empty @rdoc.remove_unparseable file_list
-  end
-
-  def test_remove_unparseable_tags_emacs
-    temp_dir do
-      File.open 'TAGS', 'wb' do |io| # emacs
-        io.write "\f\nlib/foo.rb,43\n"
-      end
-
-      file_list = %w[
-        TAGS
-      ]
-
-      assert_empty @rdoc.remove_unparseable file_list
-    end
-  end
-
-  def test_remove_unparseable_tags_vim
-    temp_dir do
-      File.open 'TAGS', 'w' do |io| # emacs
-        io.write "!_TAG_"
-      end
-
-      file_list = %w[
-        TAGS
-      ]
-
-      assert_empty @rdoc.remove_unparseable file_list
-    end
-  end
-
-  def test_remove_unparseable_CVE_2021_31799
-    omit 'for Un*x platforms' if Gem.win_platform?
-    temp_dir do
-      file_list = ['| touch evil.txt && echo tags']
-      file_list.each do |f|
-        FileUtils.touch f rescue omit
-      end
-
-      assert_equal file_list, @rdoc.remove_unparseable(file_list)
-      assert_equal file_list, Dir.children('.')
-    end
-  end
-
-  def test_setup_output_dir
-    Dir.mktmpdir {|d|
-      path = File.join d, 'testdir'
-
-      last = @rdoc.setup_output_dir path, false
-
-      assert_empty last
-
-      assert File.directory? path
-      assert File.exist? @rdoc.output_flag_file path
-    }
-  end
-
-  def test_setup_output_dir_dry_run
-    @rdoc.options.dry_run = true
-
-    Dir.mktmpdir do |d|
-      path = File.join d, 'testdir'
-
-      @rdoc.setup_output_dir path, false
-
-      refute File.exist? path
-    end
-  end
-
-  def test_setup_output_dir_exists
-    Dir.mktmpdir {|path|
-      File.open @rdoc.output_flag_file(path), 'w' do |io|
-        io.puts Time.at 0
-        io.puts "./lib/rdoc.rb\t#{Time.at 86400}"
-      end
-
-      last = @rdoc.setup_output_dir path, false
-
-      assert_equal 1, last.size
-      assert_equal Time.at(86400), last['./lib/rdoc.rb']
-    }
-  end
-
-  def test_setup_output_dir_exists_empty_created_rid
-    Dir.mktmpdir {|path|
-      File.open @rdoc.output_flag_file(path), 'w' do end
-
-      e = assert_raise RDoc::Error do
-        @rdoc.setup_output_dir path, false
-      end
-
-      assert_match %r%Directory #{Regexp.escape path} already exists%, e.message
-    }
-  end
-
-  def test_setup_output_dir_exists_file
-    tf = Tempfile.open 'test_rdoc_rdoc' do |tempfile|
-      path = tempfile.path
-
-      e = assert_raise RDoc::Error do
-        @rdoc.setup_output_dir path, false
-      end
-
-      assert_match(%r%#{Regexp.escape path} exists and is not a directory%,
-                   e.message)
-      tempfile
-    end
-    tf.close!
-  end
-
-  def test_setup_output_dir_exists_not_rdoc
-    Dir.mktmpdir do |dir|
-      e = assert_raise RDoc::Error do
-        @rdoc.setup_output_dir dir, false
-      end
-
-      assert_match %r%Directory #{Regexp.escape dir} already exists%, e.message
-    end
-  end
-
-  def test_update_output_dir
-    Dir.mktmpdir do |d|
-      @rdoc.update_output_dir d, Time.now, {}
-
-      assert File.exist? "#{d}/created.rid"
-    end
-  end
-
-  def test_update_output_dir_dont
-    Dir.mktmpdir do |d|
-      @rdoc.options.update_output_dir = false
-      @rdoc.update_output_dir d, Time.now, {}
-
-      refute File.exist? "#{d}/created.rid"
-    end
-  end
-
-  def test_update_output_dir_dry_run
-    Dir.mktmpdir do |d|
-      @rdoc.options.dry_run = true
-      @rdoc.update_output_dir d, Time.now, {}
-
-      refute File.exist? "#{d}/created.rid"
-    end
-  end
-
-  def test_update_output_dir_with_reproducible_time
-    Dir.mktmpdir do |d|
-      backup_epoch = ENV['SOURCE_DATE_EPOCH']
-      ruby_birthday = Time.parse 'Wed, 24 Feb 1993 21:00:00 +0900'
-      ENV['SOURCE_DATE_EPOCH'] = ruby_birthday.to_i.to_s
-
-      @rdoc.update_output_dir d, Time.now, {}
-
-      assert File.exist? "#{d}/created.rid"
-
-      f = File.open("#{d}/created.rid", 'r')
-      head_timestamp = Time.parse f.gets.chomp
-      f.close
-      assert_equal ruby_birthday, head_timestamp
-
-      ENV['SOURCE_DATE_EPOCH'] = backup_epoch
-    end
-  end
-
-  def test_normalized_file_list_removes_created_rid_dir
-    temp_dir do |d|
-      FileUtils.mkdir "doc"
-      flag_file = @rdoc.output_flag_file "doc"
-      file = File.join "doc", "test"
-      FileUtils.touch flag_file
-      FileUtils.touch file
-
-      file_list = ["doc"]
-
-      output = @rdoc.normalized_file_list file_list
-
-      assert_empty output
-    end
-  end
-end
diff --git a/test/mri/rdoc/rdoc/rdoc_require_test.rb b/test/mri/rdoc/rdoc/rdoc_require_test.rb
deleted file mode 100644
index e90f8520a21..00000000000
--- a/test/mri/rdoc/rdoc/rdoc_require_test.rb
+++ /dev/null
@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-require_relative 'xref_test_case'
-
-class RDocRequireTest < XrefTestCase
-
-  def setup
-    super
-
-    @req = RDoc::Require.new 'foo', 'comment'
-  end
-
-  def test_initialize
-    assert_equal 'foo', @req.name
-
-    RDoc::Require.new '"foo"', ''
-    assert_equal 'foo', @req.name
-
-    RDoc::Require.new '\'foo\'', ''
-    assert_equal 'foo', @req.name
-
-    RDoc::Require.new '|foo|', ''
-    assert_equal 'foo', @req.name, 'for fortran?'
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc/rdoc_ri_driver_test.rb b/test/mri/rdoc/rdoc/rdoc_ri_driver_test.rb
deleted file mode 100644
index 1cb459909a4..00000000000
--- a/test/mri/rdoc/rdoc/rdoc_ri_driver_test.rb
+++ /dev/null
@@ -1,1610 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocRIDriverTest < RDoc::TestCase
-
-  def setup
-    super
-
-    @home_ri = File.join @test_home, 'dot_ri'
-
-    FileUtils.mkdir_p @home_ri
-
-    @orig_ri = ENV.delete('RI')
-    @rdoc_home = File.join @test_home, ".rdoc"
-    FileUtils.mkdir_p @rdoc_home
-
-    @options = RDoc::RI::Driver.default_options
-    @options[:use_system] = false
-    @options[:use_site]   = false
-    @options[:use_home]   = false
-    @options[:use_gems]   = false
-
-    @options[:home]       = @rdoc_home
-    @options[:use_stdout] = true
-    @options[:formatter]  = @RM::ToRdoc
-    @rdoc_options = RDoc::Options.new
-
-    @driver = RDoc::RI::Driver.new @options
-  end
-
-  def teardown
-    defined?(@orig_ri) and ENV['RI'] = @orig_ri
-
-    super
-  end
-
-  case RUBY_PLATFORM
-  when /mswin|mingw/
-    DUMMY_PAGER = "type nul"
-  else
-    DUMMY_PAGER = "true"
-  end
-
-  def with_dummy_pager
-    pager_env, ENV['RI_PAGER'] = ENV['RI_PAGER'], DUMMY_PAGER
-    yield
-  ensure
-    ENV['RI_PAGER'] = pager_env
-  end
-
-  def test_self_dump
-    util_store
-
-    out, = capture_output do
-      RDoc::RI::Driver.dump @store1.cache_path
-    end
-
-    assert_match %r%:class_methods|class_methods:%,       out
-    assert_match %r%:modules|modules:%,                   out
-    assert_match %r%:instance_methods|instance_methods:%, out
-    assert_match %r%:ancestors|ancestors:%,               out
-  end
-
-  def test_add_also_in_empty
-    out = @RM::Document.new
-
-    @driver.add_also_in out, []
-
-    assert_empty out
-  end
-
-  def test_add_also_in
-    util_multi_store
-    @store1.type = :system
-    @store2.type = :home
-
-    out = @RM::Document.new
-
-    @driver.add_also_in out, [@store1, @store2]
-
-    expected = @RM::Document.new(
-      @RM::Rule.new(1),
-      @RM::Paragraph.new('Also found in:'),
-      @RM::Verbatim.new("ruby core", "\n",
-                        @rdoc_home, "\n"))
-
-    assert_equal expected, out
-  end
-
-  def test_add_class
-    util_multi_store
-
-    out = @RM::Document.new
-
-    @driver.add_class out, 'Bar', [@cBar]
-
-    expected = @RM::Document.new(
-      @RM::Heading.new(1, 'Bar < Foo'),
-      @RM::BlankLine.new)
-
-    assert_equal expected, out
-  end
-
-  def test_add_from
-    util_store
-    @store1.type = :system
-
-    out = @RM::Document.new
-
-    @driver.add_from out, @store1
-
-    expected = @RM::Document.new @RM::Paragraph.new("(from ruby core)")
-
-    assert_equal expected, out
-  end
-
-  def test_add_extends
-    util_store
-
-    out = @RM::Document.new
-
-    @driver.add_extends out, [[[@cFooExt], @store1]]
-
-    expected = @RM::Document.new(
-      @RM::Rule.new(1),
-      @RM::Heading.new(1, "Extended by:"),
-      @RM::Paragraph.new("Ext (from #{@store1.friendly_path})"),
-      @RM::BlankLine.new,
-      @RM::Paragraph.new("Extend thingy"),
-      @RM::BlankLine.new)
-
-    assert_equal expected, out
-  end
-
-  def test_add_extension_modules_empty
-    out = @RM::Document.new
-
-    @driver.add_extension_modules out, 'Includes', []
-
-    assert_empty out
-  end
-
-  def test_add_extension_modules_many
-    util_store
-
-    out = @RM::Document.new
-
-    enum = RDoc::Include.new 'Enumerable', nil
-    @cFoo.add_include enum
-
-    @driver.add_extension_modules out, 'Includes', [[[@cFooInc, enum], @store1]]
-
-    expected = @RM::Document.new(
-      @RM::Rule.new(1),
-      @RM::Heading.new(1, "Includes:"),
-      @RM::Paragraph.new("(from #{@store1.friendly_path})"),
-      @RM::BlankLine.new,
-      @RM::Paragraph.new("Inc"),
-      @RM::BlankLine.new,
-      @RM::Paragraph.new("Include thingy"),
-      @RM::BlankLine.new,
-      @RM::Verbatim.new("Enumerable", "\n"))
-
-    assert_equal expected, out
-  end
-
-  def test_add_extension_modules_many_no_doc
-    util_store
-
-    out = @RM::Document.new
-
-    enum = RDoc::Include.new 'Enumerable', nil
-    @cFoo.add_include enum
-    @cFooInc.instance_variable_set :@comment, ''
-
-    @driver.add_extension_modules out, 'Includes', [[[@cFooInc, enum], @store1]]
-
-    expected = @RM::Document.new(
-      @RM::Rule.new(1),
-      @RM::Heading.new(1, "Includes:"),
-      @RM::Paragraph.new("(from #{@store1.friendly_path})"),
-      @RM::Verbatim.new("Inc", "\n",
-                        "Enumerable", "\n"))
-
-    assert_equal expected, out
-  end
-
-  def test_add_extension_modules_one
-    util_store
-
-    out = @RM::Document.new
-
-    @driver.add_extension_modules out, 'Includes', [[[@cFooInc], @store1]]
-
-    expected = @RM::Document.new(
-      @RM::Rule.new(1),
-      @RM::Heading.new(1, "Includes:"),
-      @RM::Paragraph.new("Inc (from #{@store1.friendly_path})"),
-      @RM::BlankLine.new,
-      @RM::Paragraph.new("Include thingy"),
-      @RM::BlankLine.new)
-
-    assert_equal expected, out
-  end
-
-  def test_add_includes
-    util_store
-
-    out = @RM::Document.new
-
-    @driver.add_includes out, [[[@cFooInc], @store1]]
-
-    expected = @RM::Document.new(
-      @RM::Rule.new(1),
-      @RM::Heading.new(1, "Includes:"),
-      @RM::Paragraph.new("Inc (from #{@store1.friendly_path})"),
-      @RM::BlankLine.new,
-      @RM::Paragraph.new("Include thingy"),
-      @RM::BlankLine.new)
-
-    assert_equal expected, out
-  end
-
-  def test_add_method
-    util_store
-
-    out = doc
-
-    @driver.add_method out, 'Foo::Bar#blah'
-
-    expected =
-      doc(
-        head(1, 'Foo::Bar#blah'),
-        blank_line,
-        para("(from #{@rdoc_home})"),
-        head(3, 'Implementation from Bar'),
-        rule(1),
-        verb("blah(5) => 5\n",
-             "blah(6) => 6\n"),
-        rule(1),
-        blank_line,
-        blank_line)
-
-    assert_equal expected, out
-  end
-
-  def test_add_method_with_rdoc_ref_link
-    util_store
-
-    out = doc
-
-    @driver.add_method out, 'Foo::Bar#blah_with_rdoc_ref'
-
-    expected =
-      doc(
-        head(1, 'Foo::Bar#blah_with_rdoc_ref'),
-        blank_line,
-        para("(from #{@rdoc_home})"),
-        head(3, 'Implementation from Bar'),
-        rule(1),
-        verb("blah(5) => 5\n", "See also {Doc}[rdoc-ref:README.rdoc]\n"),
-        rule(1),
-        blank_line,
-        blank_line
-      )
-
-    assert_equal expected, out
-  end
-
-  def test_add_method_that_is_alias_for_original
-    util_store
-
-    out = doc
-
-    @driver.add_method out, 'Qux#aliased'
-
-    expected =
-      doc(
-        head(1, 'Qux#aliased'),
-        blank_line,
-        para("(from #{@rdoc_home})"),
-        rule(1),
-        blank_line,
-        para('alias comment'),
-        blank_line,
-        blank_line,
-        para('(This method is an alias for Qux#original.)'),
-        blank_line,
-        para('original comment'),
-        blank_line,
-        blank_line)
-
-    assert_equal expected, out
-  end
-
-  def test_add_method_attribute
-    util_store
-
-    out = doc
-
-    @driver.add_method out, 'Foo::Bar#attr'
-
-    expected =
-      doc(
-        head(1, 'Foo::Bar#attr'),
-        blank_line,
-        para("(from #{@rdoc_home})"),
-        rule(1),
-        blank_line,
-        blank_line)
-
-    assert_equal expected, out
-  end
-
-  def test_add_method_inherited
-    util_multi_store
-
-    out = doc
-
-    @driver.add_method out, 'Bar#inherit'
-
-    expected =
-      doc(
-        head(1, 'Bar#inherit'),
-        blank_line,
-        para("(from #{@rdoc_home})"),
-        head(3, 'Implementation from Foo'),
-        rule(1),
-        blank_line,
-        blank_line)
-
-    assert_equal expected, out
-  end
-
-  def test_add_method_overridden
-    util_multi_store
-
-    out = doc
-
-    @driver.add_method out, 'Bar#override'
-
-    expected =
-      doc(
-        head(1, 'Bar#override'),
-        blank_line,
-        para("(from #{@store2.path})"),
-        rule(1),
-        blank_line,
-        para('must be displayed'),
-        blank_line,
-        blank_line)
-
-    assert_equal expected, out
-  end
-
-  def test_add_method_documentation
-    util_store
-
-    out = doc()
-
-    missing = RDoc::AnyMethod.new nil, 'missing'
-    @cFoo.add_method missing
-
-    @driver.add_method_documentation out, @cFoo
-
-    expected =
-      doc(
-        head(1, 'Foo#inherit'),
-        blank_line,
-        para("(from #{@rdoc_home})"),
-        rule(1),
-        blank_line,
-        blank_line,
-        head(1, 'Foo#override'),
-        blank_line,
-        para("(from #{@rdoc_home})"),
-        rule(1),
-        blank_line,
-        para('must not be displayed in Bar#override'),
-        blank_line,
-        blank_line)
-
-    assert_equal expected, out
-  end
-
-  def test_add_method_list
-    out = @RM::Document.new
-
-    @driver.add_method_list out, %w[new parse], 'Class methods'
-
-    expected = @RM::Document.new(
-      @RM::Heading.new(1, 'Class methods:'),
-      @RM::BlankLine.new,
-      @RM::Verbatim.new('new'),
-      @RM::Verbatim.new('parse'),
-      @RM::BlankLine.new)
-
-    assert_equal expected, out
-  end
-
-  def test_output_width
-    @options[:width] = 10
-    driver = RDoc::RI::Driver.new @options
-
-    doc = @RM::Document.new
-    doc << @RM::IndentedParagraph.new(0, 'new, parse, foo, bar, baz')
-
-    out, = capture_output do
-      driver.display doc
-    end
-
-    expected = "new, parse, foo,\nbar, baz\n"
-
-    assert_equal expected, out
-  end
-
-  def test_add_method_list_interative
-    @options[:interactive] = true
-    driver = RDoc::RI::Driver.new @options
-
-    out = @RM::Document.new
-
-    driver.add_method_list out, %w[new parse], 'Class methods'
-
-    expected = @RM::Document.new(
-      @RM::Heading.new(1, 'Class methods:'),
-      @RM::BlankLine.new,
-      @RM::IndentedParagraph.new(2, 'new, parse'),
-      @RM::BlankLine.new)
-
-    assert_equal expected, out
-  end
-
-  def test_add_method_list_none
-    out = @RM::Document.new
-
-    @driver.add_method_list out, [], 'Class'
-
-    assert_equal @RM::Document.new, out
-  end
-
-  def test_ancestors_of
-    util_ancestors_store
-
-    assert_equal %w[X Mixin Object Foo], @driver.ancestors_of('Foo::Bar')
-  end
-
-  def test_ancestors_of_chained_inclusion
-    # Store represents something like:
-    #
-    #   module X
-    #   end
-    #
-    #   module Y
-    #     include X
-    #   end
-    #
-    #   class Z
-    #     include Y
-    #   end
-    #
-    # Y is not chosen randomly, it has to be after Object in the alphabet
-    # to reproduce https://github.com/ruby/rdoc/issues/814.
-    store = RDoc::RI::Store.new(@rdoc_options, path: @home_ri)
-    store.cache[:ancestors] = { "Z" => ["Object", "Y"], "Y" => ["X"] }
-    store.cache[:modules] = %W[X Y Z]
-    @driver.stores = [store]
-
-    assert_equal %w[X Y Object], @driver.ancestors_of('Z')
-  end
-
-  def test_classes
-    util_multi_store
-
-    expected = {
-      'Ambiguous' => [@store1, @store2],
-      'Bar'       => [@store2],
-      'Ext'       => [@store1],
-      'Foo'       => [@store1, @store2],
-      'Foo::Bar'  => [@store1],
-      'Foo::Baz'  => [@store1, @store2],
-      'Inc'       => [@store1],
-      'Qux'       => [@store1],
-    }
-
-    classes = @driver.classes
-
-    assert_equal expected.keys.sort, classes.keys.sort
-
-    expected.each do |klass, stores|
-      assert_equal stores, classes[klass].sort_by { |store| store.path },
-                   "mismatch for #{klass}"
-    end
-  end
-
-  def test_class_document
-    util_store
-
-    tl1 = @store1.add_file 'one.rb'
-    tl2 = @store1.add_file 'two.rb'
-
-    @cFoo.add_comment 'one', tl1
-    @cFoo.add_comment 'two', tl2
-
-    @store1.save_class @cFoo
-
-    found = [
-      [@store1, @store1.load_class(@cFoo.full_name)]
-    ]
-
-    extends  = [[[@cFooExt], @store1]]
-    includes = [[[@cFooInc], @store1]]
-
-    out = @driver.class_document @cFoo.full_name, found, [], includes, extends
-
-    expected = @RM::Document.new
-    @driver.add_class expected, 'Foo', []
-    @driver.add_includes expected, includes
-    @driver.add_extends  expected, extends
-    @driver.add_from expected, @store1
-    expected << @RM::Rule.new(1)
-
-    doc = @RM::Document.new(@RM::Paragraph.new('one'))
-    doc.file = 'one.rb'
-    expected.push doc
-    expected << @RM::BlankLine.new
-    doc = @RM::Document.new(@RM::Paragraph.new('two'))
-    doc.file = 'two.rb'
-    expected.push doc
-
-    expected << @RM::Rule.new(1)
-    expected << @RM::Heading.new(1, 'Instance methods:')
-    expected << @RM::BlankLine.new
-    expected << @RM::Verbatim.new('inherit')
-    expected << @RM::Verbatim.new('override')
-    expected << @RM::BlankLine.new
-
-    assert_equal expected, out
-  end
-
-  def test_complete
-    store = RDoc::RI::Store.new(@rdoc_options, path: @home_ri)
-    store.cache[:ancestors] = {
-      'Foo'      => %w[Object],
-      'Foo::Bar' => %w[Object],
-    }
-    store.cache[:class_methods] = {
-      'Foo' => %w[bar]
-    }
-    store.cache[:instance_methods] = {
-      'Foo' => %w[Bar]
-    }
-    store.cache[:modules] = %w[
-      Foo
-      Foo::Bar
-    ]
-
-    @driver.stores = [store]
-
-    assert_equal %w[Foo         ], @driver.complete('F')
-    assert_equal %w[    Foo::Bar], @driver.complete('Foo::B')
-
-    assert_equal %w[Foo#Bar],           @driver.complete('Foo#'),   'Foo#'
-    assert_equal %w[Foo.Bar  Foo.bar],  @driver.complete('Foo.'),   'Foo.'
-    assert_equal %w[Foo::Bar Foo::bar], @driver.complete('Foo::'),  'Foo::'
-
-    assert_equal %w[         Foo::bar], @driver.complete('Foo::b'), 'Foo::b'
-  end
-
-  def test_complete_ancestor
-    util_ancestors_store
-
-    assert_equal %w[Foo::Bar#i_method], @driver.complete('Foo::Bar#')
-
-    assert_equal %w[Foo::Bar::c_method Foo::Bar::new], @driver.complete('Foo::Bar::')
-
-    assert_equal %w[Foo::Bar.c_method Foo::Bar.i_method Foo::Bar.new],
-                 @driver.complete('Foo::Bar.')
-  end
-
-  def test_complete_classes
-    util_store
-
-    assert_equal %w[                       ], @driver.complete('[')
-    assert_equal %w[                       ], @driver.complete('[::')
-    assert_equal %w[Foo                    ], @driver.complete('F')
-    assert_equal %w[Foo:: Foo::Bar Foo::Baz], @driver.complete('Foo::')
-    assert_equal %w[      Foo::Bar Foo::Baz], @driver.complete('Foo::B')
-  end
-
-  def test_complete_multistore
-    util_multi_store
-
-    assert_equal %w[Bar], @driver.complete('B')
-    assert_equal %w[Foo], @driver.complete('F')
-    assert_equal %w[Foo::Bar Foo::Baz], @driver.complete('Foo::B')
-  end
-
-  def test_display
-    doc = @RM::Document.new(
-            @RM::Paragraph.new('hi'))
-
-    out, = capture_output do
-      @driver.display doc
-    end
-
-    assert_equal "hi\n", out
-  end
-
-  def test_display_class
-    util_store
-
-    out, = capture_output do
-      @driver.display_class 'Foo::Bar'
-    end
-
-    assert_match %r%^= Foo::Bar%, out
-    assert_match %r%^\(from%, out
-
-    assert_match %r%^= Class methods:%, out
-    assert_match %r%^  new%, out
-    assert_match %r%^= Instance methods:%, out
-    assert_match %r%^  blah%, out
-    assert_match %r%^= Attributes:%, out
-    assert_match %r%^  attr_accessor attr%, out
-
-    assert_equal 2, out.scan(/^-{50,}$/).length, out
-
-    refute_match %r%Foo::Bar#blah%, out
-  end
-
-  def test_display_class_all
-    util_store
-
-    @driver.show_all = true
-
-    out, = capture_output do
-      @driver.display_class 'Foo::Bar'
-    end
-
-    assert_match %r%^= Foo::Bar%, out
-    assert_match %r%^\(from%, out
-
-    assert_match %r%^= Class methods:%, out
-    assert_match %r%^  new%, out
-    assert_match %r%^= Instance methods:%, out
-    assert_match %r%^  blah%, out
-    assert_match %r%^= Attributes:%, out
-    assert_match %r%^  attr_accessor attr%, out
-
-    assert_equal 9, out.scan(/^-{50,}$/).length, out
-
-    assert_match %r%Foo::Bar#blah%, out
-    assert_match %r%Foo::Bar#blah_with_rdoc_ref%, out
-    # From Foo::Bar and Foo::Bar#blah_with_rdoc_ref
-    assert_equal 2, out.scan(/rdoc-ref:README.rdoc/).length
-    # But README.rdoc should only be displayed once
-    assert_equal 1, out.scan(/Expanded from README.rdoc/).length
-  end
-
-  def test_rdoc_refs_expansion_can_be_disabled
-    util_store
-
-    @driver.instance_variable_set :@expand_rdoc_refs, false
-
-    out, = capture_output do
-      @driver.display_class 'Foo::Bar'
-    end
-
-    # From Foo::Bar
-    assert_equal 1, out.scan(/rdoc-ref:README.rdoc/).length
-    # But README.rdoc should not be expanded
-    assert_empty out.scan(/Expanded from README.rdoc/)
-  end
-
-  def test_display_class_ambiguous
-    util_multi_store
-
-    out, = capture_output do
-      @driver.display_class 'Ambiguous'
-    end
-
-    assert_match %r%^= Ambiguous < Object$%, out
-  end
-
-  def test_display_class_multi_no_doc
-    util_multi_store
-
-    out, = capture_output do
-      @driver.display_class 'Foo::Baz'
-    end
-
-    assert_match %r%^= Foo::Baz%, out
-    assert_match %r%-\n%, out
-    assert_match %r%Also found in:%, out
-    assert_match %r%#{Regexp.escape @home_ri}%, out
-    assert_match %r%#{Regexp.escape @home_ri2}%, out
-  end
-
-  def test_display_class_superclass
-    util_multi_store
-
-    out, = capture_output do
-      @driver.display_class 'Bar'
-    end
-
-    assert_match %r%^= Bar < Foo%, out
-  end
-
-  def test_display_class_module
-    util_store
-
-    out, = capture_output do
-      @driver.display_class 'Inc'
-    end
-
-    assert_match %r%^= Inc$%, out
-  end
-
-  def test_display_class_page
-    out, = capture_output do
-      @driver.display_class 'ruby:README'
-    end
-
-    assert_empty out
-  end
-
-  def test_display_method
-    util_store
-
-    out, = capture_output do
-      @driver.display_method 'Foo::Bar#blah'
-    end
-
-    assert_match %r%Foo::Bar#blah%, out
-    assert_match %r%blah.5%,        out
-    assert_match %r%blah.6%,        out
-  end
-
-  def test_display_method_attribute
-    util_store
-
-    out, = capture_output do
-      @driver.display_method 'Foo::Bar#attr'
-    end
-
-    assert_match %r%Foo::Bar#attr%, out
-    refute_match %r%Implementation from%, out
-  end
-
-  def test_display_method_inherited
-    util_multi_store
-
-    out, = capture_output do
-      @driver.display_method 'Bar#inherit'
-    end
-
-    assert_match %r%^= Bar#inherit%, out
-    assert_match %r%^=== Implementation from Foo%, out
-  end
-
-  def test_display_method_overridden
-    util_multi_store
-
-    out, = capture_output do
-      @driver.display_method 'Bar#override'
-    end
-
-    refute_match %r%must not be displayed%, out
-  end
-
-  def test_display_name
-    util_store
-
-    out, = capture_output do
-      assert_equal true, @driver.display_name('home:README.rdoc')
-    end
-
-    expected = <<-EXPECTED
-= README
-This is a README
-    EXPECTED
-
-    assert_equal expected, out
-  end
-
-  def test_display_name_not_found_class
-    util_store
-
-    out, = capture_output do
-      assert_equal false, @driver.display_name('Foo::B')
-    end
-
-    expected = <<-EXPECTED
-Foo::B not found, maybe you meant:
-
-Foo::Bar
-Foo::Baz
-    EXPECTED
-
-    assert_equal expected, out
-  end
-
-  def test_display_name_not_found_method
-    util_store
-
-    out, = capture_output do
-      assert_equal false, @driver.display_name('Foo::Bar#b')
-    end
-
-    expected = <<-EXPECTED
-Foo::Bar#b not found, maybe you meant:
-
-Foo::Bar#blah
-Foo::Bar#blah_with_rdoc_ref
-Foo::Bar#bother
-    EXPECTED
-
-    assert_equal expected, out
-  end
-
-  def test_display_name_not_found_special
-    util_store
-
-    assert_raise RDoc::RI::Driver::NotFoundError do
-      assert_equal false, @driver.display_name('Set#[]')
-    end
-  end
-
-  def test_display_method_params
-    util_store
-
-    out, = capture_output do
-      @driver.display_method 'Foo::Bar#bother'
-    end
-
-    assert_match %r%things.*stuff%, out
-  end
-
-  def test_display_page
-    util_store
-
-    out, = capture_output do
-      @driver.display_page 'home:README.rdoc'
-    end
-
-    assert_match %r%= README%, out
-  end
-
-  def test_display_page_add_extension
-    util_store
-
-    out, = capture_output do
-      @driver.display_page 'home:README'
-    end
-
-    assert_match %r%= README%, out
-  end
-
-  def test_display_page_ambiguous
-    util_store
-
-    other = @store1.add_file 'README.md'
-    other.parser = RDoc::Parser::Simple
-    other.comment =
-      RDoc::Comment.from_document(doc(
-        head(1, 'README.md'),
-        para('This is the other README')))
-
-    @store1.save_page other
-
-    out, = capture_output do
-      @driver.display_page 'home:README'
-    end
-
-    assert_match %r%= README pages in #{@rdoc_home}%, out
-    assert_match %r%README\.rdoc%,               out
-    assert_match %r%README\.md%,                 out
-  end
-
-  def test_display_page_extension
-    util_store
-
-    other = @store1.add_file 'README.EXT'
-    other.parser = RDoc::Parser::Simple
-    other.comment =
-      RDoc::Comment.from_document(doc(
-        head(1, 'README.EXT'),
-        para('This is the other README')))
-
-    @store1.save_page other
-
-    out, = capture_output do
-      @driver.display_page 'home:README.EXT'
-    end
-
-    assert_match 'other README', out
-  end
-
-  def test_display_page_ignore_directory
-    util_store
-
-    other = @store1.add_file 'doc/globals.rdoc'
-    other.parser = RDoc::Parser::Simple
-    other.comment =
-      RDoc::Comment.from_document(doc(
-        head(1, 'globals.rdoc'),
-        para('Globals go here')))
-
-    @store1.save_page other
-
-    out, = capture_output do
-      @driver.display_page 'home:globals'
-    end
-
-    assert_match %r%= globals\.rdoc%, out
-  end
-
-  def test_display_page_missing
-    util_store
-
-    out, = capture_output do
-      @driver.display_page 'home:missing'
-    end
-
-    out, = capture_output do
-      @driver.display_page_list @store1
-    end
-
-    assert_match %r%= Pages in #{@rdoc_home}%, out
-    assert_match %r%README\.rdoc%,        out
-  end
-
-  def test_display_page_list
-    util_store
-
-    other = @store1.add_file 'OTHER.rdoc'
-    other.parser = RDoc::Parser::Simple
-    other.comment =
-      RDoc::Comment.from_document(doc(
-        head(1, 'OTHER'),
-        para('This is OTHER')))
-
-    @store1.save_page other
-
-    out, = capture_output do
-      @driver.display_page_list @store1
-    end
-
-    assert_match %r%= Pages in #{@rdoc_home}%, out
-    assert_match %r%README\.rdoc%,        out
-    assert_match %r%OTHER\.rdoc%,         out
-  end
-
-  def test_expand_class
-    util_store
-
-    assert_equal 'Foo',       @driver.expand_class('F')
-    assert_equal 'Foo::Bar',  @driver.expand_class('F::Bar')
-
-    assert_raise RDoc::RI::Driver::NotFoundError do
-      @driver.expand_class 'F::B'
-    end
-  end
-
-  def test_expand_class_2
-    @store1 = RDoc::RI::Store.new(@rdoc_options, path: @home_ri, type: :home)
-
-    @top_level = @store1.add_file 'file.rb'
-
-    @cFoo = @top_level.add_class RDoc::NormalClass, 'Foo'
-    @mFox = @top_level.add_module RDoc::NormalModule, 'Fox'
-    @cFoo_Bar = @cFoo.add_class RDoc::NormalClass, 'Bar'
-    @store1.save
-
-    @driver.stores = [@store1]
-    assert_raise RDoc::RI::Driver::NotFoundError do
-      @driver.expand_class 'F'
-    end
-    assert_equal 'Foo::Bar',  @driver.expand_class('F::Bar')
-    assert_equal 'Foo::Bar',  @driver.expand_class('F::B')
-  end
-
-  def test_expand_class_3
-    @store1 = RDoc::RI::Store.new(@rdoc_options, path: @home_ri, type: :home)
-
-    @top_level = @store1.add_file 'file.rb'
-
-    @cFoo = @top_level.add_class RDoc::NormalClass, 'Foo'
-    @mFox = @top_level.add_module RDoc::NormalModule, 'FooBar'
-    @store1.save
-
-    @driver.stores = [@store1]
-
-    assert_equal 'Foo',  @driver.expand_class('Foo')
-  end
-
-  def test_expand_name
-    util_store
-
-    assert_equal '.b',        @driver.expand_name('b')
-    assert_equal 'Foo',       @driver.expand_name('F')
-    assert_equal 'Foo::Bar#', @driver.expand_name('F::Bar#')
-
-    e = assert_raise RDoc::RI::Driver::NotFoundError do
-      @driver.expand_name 'Z'
-    end
-
-    assert_equal 'Z', e.name
-
-    @driver.stores << RDoc::Store.new(@rdoc_options, type: :system)
-
-    assert_equal 'ruby:README', @driver.expand_name('ruby:README')
-    assert_equal 'ruby:',       @driver.expand_name('ruby:')
-
-    e = assert_raise RDoc::RI::Driver::NotFoundError do
-      @driver.expand_name 'nonexistent_gem:'
-    end
-
-    assert_equal 'nonexistent_gem', e.name
-  end
-
-  def test_find_methods
-    util_store
-
-    items = []
-
-    @driver.find_methods 'Foo::Bar.' do |store, klass, ancestor, types, method|
-      items << [store, klass, ancestor, types, method]
-    end
-
-    expected = [
-      [@store1, 'Foo::Bar', 'Foo::Bar', :both, nil],
-    ]
-
-    assert_equal expected, items
-  end
-
-  def test_find_methods_method
-    util_store
-
-    items = []
-
-    @driver.find_methods '.blah' do |store, klass, ancestor, types, method|
-      items << [store, klass, ancestor, types, method]
-    end
-
-    expected = [
-      [@store1, 'Ambiguous', 'Ambiguous', :both, 'blah'],
-      [@store1, 'Ext',       'Ext',       :both, 'blah'],
-      [@store1, 'Foo',       'Foo',       :both, 'blah'],
-      [@store1, 'Foo::Bar',  'Foo::Bar',  :both, 'blah'],
-      [@store1, 'Foo::Baz',  'Foo::Baz',  :both, 'blah'],
-      [@store1, 'Inc',       'Inc',       :both, 'blah'],
-      [@store1, 'Qux',       'Qux',       :both, 'blah'],
-    ]
-
-    assert_equal expected, items
-  end
-
-  def test_filter_methods
-    util_multi_store
-
-    name = 'Bar#override'
-
-    found = @driver.load_methods_matching name
-
-    sorted = @driver.filter_methods found, name
-
-    expected = [[@store2, [@override]]]
-
-    assert_equal expected, sorted
-  end
-
-  def test_filter_methods_not_found
-    util_multi_store
-
-    name = 'Bar#inherit'
-
-    found = @driver.load_methods_matching name
-
-    sorted = @driver.filter_methods found, name
-
-    assert_equal found, sorted
-  end
-
-  def test_find_store
-    @driver.stores << RDoc::Store.new(@rdoc_options, type: :system)
-    @driver.stores << RDoc::Store.new(@rdoc_options, path: 'doc/gem-1.0/ri', type: :gem)
-
-    assert_equal 'ruby',    @driver.find_store('ruby')
-    assert_equal 'gem-1.0', @driver.find_store('gem-1.0')
-    assert_equal 'gem-1.0', @driver.find_store('gem')
-
-    e = assert_raise RDoc::RI::Driver::NotFoundError do
-      @driver.find_store 'nonexistent'
-    end
-
-    assert_equal 'nonexistent', e.name
-  end
-
-  def test_did_you_mean
-    omit 'skip test with did_you_men' unless defined? DidYouMean::SpellChecker
-
-    util_ancestors_store
-
-    e = assert_raise RDoc::RI::Driver::NotFoundError do
-      @driver.lookup_method 'Foo.i_methdo'
-    end
-    assert_equal "Nothing known about Foo.i_methdo\nDid you mean?  i_method", e.message
-
-    e = assert_raise RDoc::RI::Driver::NotFoundError do
-      @driver.lookup_method 'Foo#i_methdo'
-    end
-    assert_equal "Nothing known about Foo#i_methdo\nDid you mean?  i_method", e.message
-
-    e = assert_raise RDoc::RI::Driver::NotFoundError do
-      @driver.lookup_method 'Foo::i_methdo'
-    end
-    assert_equal "Nothing known about Foo::i_methdo\nDid you mean?  c_method", e.message
-  end
-
-  def test_formatter
-    tty = Object.new
-    def tty.tty?() true; end
-
-    @options.delete :use_stdout
-    @options.delete :formatter
-
-    driver = RDoc::RI::Driver.new @options
-
-    assert_instance_of @RM::ToAnsi, driver.formatter(tty)
-
-    assert_instance_of @RM::ToBs, driver.formatter(StringIO.new)
-
-    driver.instance_variable_set :@paging, true
-
-    assert_instance_of @RM::ToBs, driver.formatter(StringIO.new)
-  end
-
-  def test_method_type
-    assert_equal :both,     @driver.method_type(nil)
-    assert_equal :both,     @driver.method_type('.')
-    assert_equal :instance, @driver.method_type('#')
-    assert_equal :class,    @driver.method_type('::')
-  end
-
-  def test_name_regexp
-    assert_equal %r%^RDoc::AnyMethod#new$%,
-                 @driver.name_regexp('RDoc::AnyMethod#new')
-
-    assert_equal %r%^RDoc::AnyMethod::new$%,
-                 @driver.name_regexp('RDoc::AnyMethod::new')
-
-    assert_equal %r%^RDoc::AnyMethod(#|::)new$%,
-                 @driver.name_regexp('RDoc::AnyMethod.new')
-
-    assert_equal %r%^Hash(#|::)\[\]$%,
-                 @driver.name_regexp('Hash.[]')
-
-    assert_equal %r%^Hash::\[\]$%,
-                 @driver.name_regexp('Hash::[]')
-  end
-
-  def test_list_known_classes
-    util_store
-
-    out, = capture_output do
-      @driver.list_known_classes
-    end
-
-    assert_equal "Ambiguous\nExt\nFoo\nFoo::Bar\nFoo::Baz\nInc\nQux\n", out
-  end
-
-  def test_list_known_classes_name
-    util_store
-
-    out, = capture_output do
-      @driver.list_known_classes %w[F I]
-    end
-
-    assert_equal "Foo\nFoo::Bar\nFoo::Baz\nInc\n", out
-  end
-
-  def test_list_methods_matching
-    util_store
-
-    assert_equal %w[
-        Foo::Bar#attr
-        Foo::Bar#blah
-        Foo::Bar#blah_with_rdoc_ref
-        Foo::Bar#bother
-        Foo::Bar::new
-      ],
-      @driver.list_methods_matching('Foo::Bar.').sort
-  end
-
-  def test_list_methods_matching_inherit
-    util_multi_store
-
-    assert_equal %w[
-        Bar#baz
-        Bar#inherit
-        Bar#override
-      ],
-      @driver.list_methods_matching('Bar.').sort
-  end
-
-  def test_list_methods_matching_regexp
-    util_store
-
-    index = RDoc::AnyMethod.new nil, '[]'
-    index.record_location @top_level
-    @cFoo.add_method index
-    @store1.save_method @cFoo, index
-
-    c_index = RDoc::AnyMethod.new nil, '[]', singleton: true
-    c_index.record_location @top_level
-    @cFoo.add_method c_index
-    @store1.save_method @cFoo, c_index
-
-    @store1.save_cache
-
-    assert_equal %w[Foo#[]], @driver.list_methods_matching('Foo#[]')
-    assert_equal %w[Foo::[]], @driver.list_methods_matching('Foo::[]')
-  end
-
-  def test_load_method
-    util_store
-
-    method = @driver.load_method(@store1, :instance_methods, 'Foo', '#',
-                                 'inherit')
-
-    assert_equal @inherit, method
-  end
-
-  def test_load_method_inherited
-    util_multi_store
-
-    method = @driver.load_method(@store2, :instance_methods, 'Bar', '#',
-                                 'inherit')
-
-    assert_nil method
-  end
-
-  def test_load_methods_matching
-    util_store
-
-    expected = [[@store1, [@inherit]]]
-
-    assert_equal expected, @driver.load_methods_matching('Foo#inherit')
-
-    expected = [[@store1, [@blah]]]
-
-    assert_equal expected, @driver.load_methods_matching('.blah')
-
-    assert_empty @driver.load_methods_matching('.b')
-  end
-
-  def test_load_methods_matching_inherited
-    util_multi_store
-
-    expected = [[@store1, [@inherit]]]
-
-    assert_equal expected, @driver.load_methods_matching('Bar#inherit')
-  end
-
-  def test_load_method_missing
-    util_store
-
-    FileUtils.rm @store1.method_file 'Foo', '#inherit'
-
-    method = @driver.load_method(@store1, :instance_methods, 'Foo', '#',
-                                 'inherit')
-
-    assert_equal '(unknown)#inherit', method.full_name
-  end
-
-  def test_page
-    @driver.use_stdout = false
-
-    with_dummy_pager do
-      @driver.page do |io|
-        omit "couldn't find a standard pager" if io == $stdout
-
-        assert @driver.paging?
-      end
-    end
-
-    refute @driver.paging?
-  end
-
-  def test_page_in_presence_of_child_status
-    @driver.use_stdout = false
-
-    with_dummy_pager do
-      @driver.page do |io|
-        refute_equal $stdout, io
-        assert @driver.paging?
-      end
-    end
-  end
-
-  def test_page_stdout
-    @driver.use_stdout = true
-
-    @driver.page do |io|
-      assert_equal $stdout, io
-    end
-
-    refute @driver.paging?
-  end
-
-  def test_parse_name_method
-    klass, type, meth = @driver.parse_name 'foo'
-
-    assert_equal '',    klass, 'foo class'
-    assert_equal '.',   type,  'foo type'
-    assert_equal 'foo', meth,  'foo method'
-
-    klass, type, meth = @driver.parse_name '#foo'
-
-    assert_equal '',    klass, '#foo class'
-    assert_equal '#',   type,  '#foo type'
-    assert_equal 'foo', meth,  '#foo method'
-
-    klass, type, meth = @driver.parse_name '::foo'
-
-    assert_equal '',    klass, '::foo class'
-    assert_equal '::',  type,  '::foo type'
-    assert_equal 'foo', meth,  '::foo method'
-  end
-
-  def test_parse_name_page
-    klass, type, meth = @driver.parse_name 'ruby:README'
-
-    assert_equal 'ruby',   klass, 'ruby project'
-    assert_equal ':',      type,  'ruby type'
-    assert_equal 'README', meth,  'ruby page'
-
-    klass, type, meth = @driver.parse_name 'ruby:'
-
-    assert_equal 'ruby',   klass, 'ruby project'
-    assert_equal ':',      type,  'ruby type'
-    assert_nil             meth,  'ruby page'
-  end
-
-  def test_parse_name_page_extenson
-    klass, type, meth = @driver.parse_name 'ruby:README.EXT'
-
-    assert_equal 'ruby',      klass, 'ruby project'
-    assert_equal ':',         type,  'ruby type'
-    assert_equal 'README.EXT', meth,  'ruby page'
-  end
-
-  def test_parse_name_single_class
-    klass, type, meth = @driver.parse_name 'Foo'
-
-    assert_equal 'Foo', klass, 'Foo class'
-    assert_nil          type,  'Foo type'
-    assert_nil          meth,  'Foo method'
-
-    klass, type, meth = @driver.parse_name 'Foo#'
-
-    assert_equal 'Foo', klass, 'Foo# class'
-    assert_equal '#',   type,  'Foo# type'
-    assert_nil          meth,  'Foo# method'
-
-    klass, type, meth = @driver.parse_name 'Foo::'
-
-    assert_equal 'Foo', klass, 'Foo:: class'
-    assert_equal '::',  type,  'Foo:: type'
-    assert_nil          meth,  'Foo:: method'
-
-    klass, type, meth = @driver.parse_name 'Foo.'
-
-    assert_equal 'Foo', klass, 'Foo. class'
-    assert_equal '.',   type,  'Foo. type'
-    assert_nil          meth,  'Foo. method'
-
-    klass, type, meth = @driver.parse_name 'Foo#Bar'
-
-    assert_equal 'Foo', klass, 'Foo#Bar class'
-    assert_equal '#',   type,  'Foo#Bar type'
-    assert_equal 'Bar', meth,  'Foo#Bar method'
-
-    klass, type, meth = @driver.parse_name 'Foo.Bar'
-
-    assert_equal 'Foo', klass, 'Foo.Bar class'
-    assert_equal '.',   type,  'Foo.Bar type'
-    assert_equal 'Bar', meth,  'Foo.Bar method'
-
-    klass, type, meth = @driver.parse_name 'Foo::bar'
-
-    assert_equal 'Foo', klass, 'Foo::bar class'
-    assert_equal '::',  type,  'Foo::bar type'
-    assert_equal 'bar', meth,  'Foo::bar method'
-  end
-
-  def test_parse_name_namespace
-    klass, type, meth = @driver.parse_name 'Foo::Bar'
-
-    assert_equal 'Foo::Bar', klass, 'Foo::Bar class'
-    assert_nil               type,  'Foo::Bar type'
-    assert_nil               meth,  'Foo::Bar method'
-
-    klass, type, meth = @driver.parse_name 'Foo::Bar#'
-
-    assert_equal 'Foo::Bar', klass, 'Foo::Bar# class'
-    assert_equal '#',        type,  'Foo::Bar# type'
-    assert_nil               meth,  'Foo::Bar# method'
-
-    klass, type, meth = @driver.parse_name 'Foo::Bar#baz'
-
-    assert_equal 'Foo::Bar', klass, 'Foo::Bar#baz class'
-    assert_equal '#',        type,  'Foo::Bar#baz type'
-    assert_equal 'baz',      meth,  'Foo::Bar#baz method'
-  end
-
-  def test_parse_name_special
-    specials = %w[
-      %
-      &
-      *
-      +
-      +@
-      -
-      -@
-      /
-      <
-      <<
-      <=
-      <=>
-      ==
-      ===
-      =>
-      =~
-      >
-      >>
-      []
-      []=
-      ^
-      `
-      |
-      ~
-      ~@
-    ]
-
-    specials.each do |special|
-      parsed = @driver.parse_name special
-
-      assert_equal ['', '.', special], parsed
-    end
-  end
-
-  def test_setup_pager # this test doesn't do anything anymore :(
-    @driver.use_stdout = false
-
-    pager = with_dummy_pager do @driver.setup_pager end
-
-    omit "couldn't find a standard pager" unless pager
-
-    assert @driver.paging?
-  ensure
-    pager.close if pager
-  end
-
-  def util_ancestors_store
-    store1 = RDoc::RI::Store.new(@rdoc_options, path: @home_ri)
-    store1.cache[:ancestors] = {
-      'Foo'      => %w[Object],
-      'Foo::Bar' => %w[Foo],
-    }
-    store1.cache[:class_methods] = {
-      'Foo'      => %w[c_method new],
-      'Foo::Bar' => %w[new],
-    }
-    store1.cache[:instance_methods] = {
-      'Foo' => %w[i_method],
-    }
-    store1.cache[:modules] = %w[
-      Foo
-      Foo::Bar
-    ]
-
-    store2 = RDoc::RI::Store.new(@rdoc_options, path: @home_ri)
-    store2.cache[:ancestors] = {
-      'Foo'    => %w[Mixin Object],
-      'Mixin'  => %w[],
-      'Object' => %w[X Object],
-      'X'      => %w[Object],
-    }
-    store2.cache[:class_methods] = {
-      'Foo'    => %w[c_method new],
-      'Mixin'  => %w[],
-      'X'      => %w[],
-      'Object' => %w[],
-    }
-    store2.cache[:instance_methods] = {
-      'Foo'   => %w[i_method],
-      'Mixin' => %w[],
-    }
-    store2.cache[:modules] = %w[
-      Foo
-      Mixin
-      Object
-      X
-    ]
-
-    @driver.stores = store1, store2
-  end
-
-  def util_multi_store
-    util_store
-
-    @home_ri2 = "#{@home_ri}2"
-    @store2 = RDoc::RI::Store.new(@rdoc_options, path: @home_ri2)
-
-    @top_level = @store2.add_file 'file.rb'
-
-    # as if seen in a namespace like class Ambiguous::Other
-    @mAmbiguous = @top_level.add_module RDoc::NormalModule, 'Ambiguous'
-
-    @cFoo = @top_level.add_class RDoc::NormalClass, 'Foo'
-
-    @cBar = @top_level.add_class RDoc::NormalClass, 'Bar', 'Foo'
-    @cFoo_Baz = @cFoo.add_class RDoc::NormalClass, 'Baz'
-
-    @baz = @cBar.add_method RDoc::AnyMethod.new(nil, 'baz')
-    @baz.record_location @top_level
-
-    @override = @cBar.add_method RDoc::AnyMethod.new(nil, 'override')
-    @override.comment = 'must be displayed'
-    @override.record_location @top_level
-
-    @store2.save
-
-    @driver.stores = [@store1, @store2]
-  end
-
-  def util_store
-    @store1 = RDoc::RI::Store.new(@rdoc_options, path: @home_ri, type: :home)
-
-    @top_level = @store1.add_file 'file.rb'
-
-    @readme = @store1.add_file 'README.rdoc'
-    @readme.parser = RDoc::Parser::Simple
-    @readme.comment = RDoc::Comment.from_document(doc(head(1, 'README'), para('This is a README')))
-
-    @cFoo = @top_level.add_class RDoc::NormalClass, 'Foo'
-    @mExt = @top_level.add_module RDoc::NormalModule, 'Ext'
-    @mInc = @top_level.add_module RDoc::NormalModule, 'Inc'
-    @cAmbiguous = @top_level.add_class RDoc::NormalClass, 'Ambiguous'
-
-    doc = @RM::Document.new @RM::Paragraph.new('Extend thingy')
-    @cFooExt = @cFoo.add_extend RDoc::Extend.new('Ext', RDoc::Comment.from_document(doc))
-    @cFooExt.record_location @top_level
-    doc = @RM::Document.new @RM::Paragraph.new('Include thingy')
-    @cFooInc = @cFoo.add_include RDoc::Include.new('Inc', RDoc::Comment.from_document(doc))
-    @cFooInc.record_location @top_level
-
-    @cFoo_Bar = @cFoo.add_class RDoc::NormalClass, 'Bar'
-    @cFoo_Bar.add_comment "See also {Doc}[rdoc-ref:README.rdoc]", @top_level
-    @cFoo_Bar.record_location @top_level
-
-    @blah = @cFoo_Bar.add_method RDoc::AnyMethod.new(nil, 'blah')
-    @blah.call_seq = "blah(5) => 5\nblah(6) => 6\n"
-    @blah.record_location @top_level
-
-    @blah_with_rdoc_ref = @cFoo_Bar.add_method RDoc::AnyMethod.new(nil, 'blah_with_rdoc_ref')
-    @blah_with_rdoc_ref.call_seq = "blah(5) => 5\nSee also {Doc}[rdoc-ref:README.rdoc]"
-    @blah_with_rdoc_ref.record_location @top_level
-
-    @bother = @cFoo_Bar.add_method RDoc::AnyMethod.new(nil, 'bother')
-    @bother.block_params = "stuff"
-    @bother.params = "(things)"
-    @bother.record_location @top_level
-
-    @new = @cFoo_Bar.add_method RDoc::AnyMethod.new nil, 'new', singleton: true
-    @new.record_location @top_level
-
-    @attr = @cFoo_Bar.add_attribute RDoc::Attr.new nil, 'attr', 'RW', ''
-    @attr.record_location @top_level
-
-    @cFoo_Baz = @cFoo.add_class RDoc::NormalClass, 'Baz'
-    @cFoo_Baz.record_location @top_level
-
-    @inherit = @cFoo.add_method RDoc::AnyMethod.new(nil, 'inherit')
-    @inherit.record_location @top_level
-
-    # overridden by Bar in multi_store
-    @overridden = @cFoo.add_method RDoc::AnyMethod.new(nil, 'override')
-    @overridden.comment = 'must not be displayed in Bar#override'
-    @overridden.record_location @top_level
-
-    @cQux = @top_level.add_class RDoc::NormalClass, 'Qux'
-
-    @original = @cQux.add_method RDoc::AnyMethod.new(nil, 'original')
-    @original.comment = 'original comment'
-    @original.record_location @top_level
-
-    @aliased = @original.add_alias RDoc::Alias.new(nil, 'original', 'aliased', 'alias comment'), @cQux
-    @aliased.record_location @top_level
-
-    @store1.save
-
-    @driver.stores = [@store1]
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc/rdoc_ri_paths_test.rb b/test/mri/rdoc/rdoc/rdoc_ri_paths_test.rb
deleted file mode 100644
index 7a9fc6fde4f..00000000000
--- a/test/mri/rdoc/rdoc/rdoc_ri_paths_test.rb
+++ /dev/null
@@ -1,157 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocRIPathsTest < RDoc::TestCase
-
-  def setup
-    super
-
-    @orig_env = ENV.to_hash
-    @orig_gem_path = Gem.path
-
-    @tempdir = File.join Dir.tmpdir, "test_rdoc_ri_paths_#{$$}"
-    Gem.use_paths @tempdir
-    Gem.ensure_gem_subdirectories @tempdir
-
-    specs = [
-      @rake_10   = Gem::Specification.new('rake', '10.0.1'),
-      @rdoc_4_0  = Gem::Specification.new('rdoc', '4.0'),
-      @rdoc_3_12 = Gem::Specification.new('rdoc', '3.12'),
-      @nodoc     = Gem::Specification.new('nodoc', '1.0'),
-    ]
-
-    specs.each do |spec|
-      spec.loaded_from = spec.spec_file
-
-      File.open spec.spec_file, 'w' do |file|
-        file.write spec.to_ruby_for_cache
-      end
-
-      FileUtils.mkdir_p File.join(spec.doc_dir, 'ri') unless
-        spec.name == 'nodoc'
-    end
-
-    Gem::Specification.reset
-    Gem::Specification.all = specs
-  end
-
-  def teardown
-    Gem.use_paths(*@orig_gem_path)
-    Gem::Specification.reset
-    FileUtils.rm_rf @tempdir
-    ENV.replace(@orig_env)
-
-    super
-  end
-
-  def test_class_each
-    enum = RDoc::RI::Paths.each true, true, true, :all
-
-    path = enum.map { |dir,| dir }
-
-    assert_equal RDoc::RI::Paths.system_dir,          path.shift
-    assert_equal RDoc::RI::Paths.site_dir,            path.shift
-    assert_equal RDoc::RI::Paths.home_dir,            path.shift if RDoc::RI::Paths.home_dir
-    assert_equal File.join(@nodoc.doc_dir, 'ri'),     path.shift
-    assert_equal File.join(@rake_10.doc_dir, 'ri'),   path.shift
-    assert_equal File.join(@rdoc_4_0.doc_dir, 'ri'),  path.shift
-    assert_equal File.join(@rdoc_3_12.doc_dir, 'ri'), path.shift
-    assert_empty path
-  end
-
-  def test_class_gemdirs_latest
-    Dir.chdir @tempdir do
-      gemdirs = RDoc::RI::Paths.gemdirs :latest
-
-      expected = [
-        File.join(@rake_10.doc_dir, 'ri'),
-        File.join(@rdoc_4_0.doc_dir, 'ri'),
-      ]
-
-      assert_equal expected, gemdirs
-    end
-  end
-
-  def test_class_gemdirs_legacy
-    Dir.chdir @tempdir do
-      gemdirs = RDoc::RI::Paths.gemdirs true
-
-      expected = [
-        File.join(@rake_10.doc_dir, 'ri'),
-        File.join(@rdoc_4_0.doc_dir, 'ri'),
-      ]
-
-      assert_equal expected, gemdirs
-    end
-  end
-
-  def test_class_gemdirs_all
-    Dir.chdir @tempdir do
-      gemdirs = RDoc::RI::Paths.gemdirs :all
-
-      expected = [
-        File.join(@nodoc.doc_dir,     'ri'),
-        File.join(@rake_10.doc_dir,   'ri'),
-        File.join(@rdoc_4_0.doc_dir,  'ri'),
-        File.join(@rdoc_3_12.doc_dir, 'ri'),
-      ]
-
-      assert_equal expected, gemdirs
-    end
-  end
-
-  def test_class_gem_dir
-    dir = RDoc::RI::Paths.gem_dir 'rake', '10.0.1'
-
-    expected = File.join @rake_10.doc_dir, 'ri'
-
-    assert_equal expected, dir
-  end
-
-  def test_class_home_dir
-    dir = RDoc::RI::Paths.home_dir
-
-    assert_equal RDoc::RI::Paths::HOMEDIR, dir
-  end
-
-  def test_class_path_nonexistent
-    temp_dir do |dir|
-      nonexistent = File.join dir, 'nonexistent'
-      dir = RDoc::RI::Paths.path true, true, true, true, nonexistent
-
-      refute_includes dir, nonexistent
-    end
-  end
-
-  def test_class_raw_path
-    path = RDoc::RI::Paths.raw_path true, true, true, true
-
-    assert_equal RDoc::RI::Paths.system_dir,        path.shift
-    assert_equal RDoc::RI::Paths.site_dir,          path.shift
-    assert_equal RDoc::RI::Paths.home_dir,          path.shift if RDoc::RI::Paths.home_dir
-    assert_equal File.join(@rake_10.doc_dir, 'ri'), path.shift
-  end
-
-  def test_class_raw_path_extra_dirs
-    path = RDoc::RI::Paths.raw_path true, true, true, true, '/nonexistent'
-
-    assert_equal '/nonexistent',                    path.shift
-    assert_equal RDoc::RI::Paths.system_dir,        path.shift
-    assert_equal RDoc::RI::Paths.site_dir,          path.shift
-    assert_equal RDoc::RI::Paths.home_dir,          path.shift if RDoc::RI::Paths.home_dir
-    assert_equal File.join(@rake_10.doc_dir, 'ri'), path.shift
-  end
-
-  def test_class_site_dir
-    dir = RDoc::RI::Paths.site_dir
-
-    assert_equal File.join(RDoc::RI::Paths::BASE, 'site'), dir
-  end
-
-  def test_class_system_dir
-    dir = RDoc::RI::Paths.system_dir
-
-    assert_equal File.join(RDoc::RI::Paths::BASE, 'system'), dir
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc/rdoc_rubygems_hook_test.rb b/test/mri/rdoc/rdoc/rdoc_rubygems_hook_test.rb
deleted file mode 100644
index 99194c59d85..00000000000
--- a/test/mri/rdoc/rdoc/rdoc_rubygems_hook_test.rb
+++ /dev/null
@@ -1,329 +0,0 @@
-# frozen_string_literal: true
-require 'rubygems'
-require 'fileutils'
-require 'tmpdir'
-require_relative '../../lib/rdoc/rubygems_hook'
-require 'test/unit'
-
-class RDocRubyGemsHookTest < Test::Unit::TestCase
-  def setup
-    @a = Gem::Specification.new do |s|
-      s.platform    = Gem::Platform::RUBY
-      s.name        = "a"
-      s.version     = 2
-      s.rdoc_options = %w[--main MyTitle]
-      s.extra_rdoc_files = %w[README]
-    end
-    @tempdir = File.realpath(Dir.mktmpdir("test_rubygems_hook_"))
-
-    @orig_envs = %w[
-      GEM_VENDOR
-      GEMRC
-      XDG_CACHE_HOME
-      XDG_CONFIG_HOME
-      XDG_DATA_HOME
-      SOURCE_DATE_EPOCH
-      BUNDLER_VERSION
-      HOME
-      RDOCOPT
-    ].map {|e| [e, ENV.delete(e)]}.to_h
-    ENV["HOME"] = @tempdir
-
-    Gem.configuration = nil
-
-    @a.instance_variable_set(:@doc_dir, File.join(@tempdir, "doc"))
-    @a.instance_variable_set(:@gem_dir, File.join(@tempdir, "a-2"))
-    @a.instance_variable_set(:@full_gem_path, File.join(@tempdir, "a-2"))
-    @a.loaded_from = File.join(@tempdir, 'a-2', 'a-2.gemspec')
-
-    FileUtils.mkdir_p File.join(@tempdir, 'a-2', 'lib')
-    FileUtils.touch   File.join(@tempdir, 'a-2', 'README')
-    File.open(File.join(@tempdir, 'a-2', 'lib', 'a.rb'), 'w') do |f|
-      f.puts '# comment'
-      f.puts '# :include: include.txt'
-      f.puts 'class A; end'
-    end
-    File.open(File.join(@tempdir, 'a-2', 'include.txt'), 'w') do |f|
-      f.puts 'included content'
-    end
-
-    @hook = RDoc::RubyGemsHook.new @a
-
-    begin
-      RDoc::RubyGemsHook.load_rdoc
-    rescue Gem::DocumentError => e
-      omit e.message
-    end
-    @old_ui = Gem::DefaultUserInteraction.ui
-    Gem::DefaultUserInteraction.ui = Gem::SilentUI.new
-  end
-
-  def teardown
-    ui = Gem::DefaultUserInteraction.ui
-    Gem::DefaultUserInteraction.ui = @old_ui
-    FileUtils.rm_rf @tempdir
-    ui.close
-    ENV.update(@orig_envs)
-  end
-
-  def test_initialize
-    refute @hook.generate_rdoc
-    assert @hook.generate_ri
-
-    rdoc = RDoc::RubyGemsHook.new @a, false, false
-
-    refute rdoc.generate_rdoc
-    refute rdoc.generate_ri
-  end
-
-  def test_delete_legacy_args
-    args = %w[
-      --inline-source
-      --one-file
-      --promiscuous
-      -p
-    ]
-
-    @hook.delete_legacy_args args
-
-    assert_empty args
-  end
-
-  def test_document
-    options = RDoc::Options.new
-    options.files = []
-
-    rdoc = @hook.new_rdoc
-    rdoc.store = RDoc::Store.new(options)
-    @hook.instance_variable_set :@rdoc, rdoc
-    @hook.instance_variable_set :@file_info, []
-
-    @hook.document 'darkfish', options, @a.doc_dir('rdoc')
-
-    assert @hook.rdoc_installed?
-  end
-
-  def test_generate
-    FileUtils.mkdir_p @a.doc_dir
-    FileUtils.mkdir_p File.join(@a.gem_dir, 'lib')
-
-    @hook.generate
-
-    refute @hook.rdoc_installed?
-    assert @hook.ri_installed?
-
-    rdoc = @hook.instance_variable_get :@rdoc
-
-    refute rdoc.options.hyperlink_all
-    assert_equal Pathname(@a.full_gem_path), rdoc.options.root
-    assert_equal %w[README lib], rdoc.options.files.sort
-
-    assert_equal 'MyTitle', rdoc.store.main
-
-    klass = rdoc.store.find_class_named('A')
-    refute_nil klass
-    assert_includes klass.comment.text, 'included content'
-  end
-
-  def test_generate_all
-    @hook.generate_rdoc = true
-    @hook.generate_ri   = true
-
-    FileUtils.mkdir_p @a.doc_dir
-    FileUtils.mkdir_p File.join(@a.gem_dir, 'lib')
-
-    @hook.generate
-
-    assert @hook.rdoc_installed?
-    assert @hook.ri_installed?
-
-    rdoc = @hook.instance_variable_get :@rdoc
-
-    refute rdoc.options.hyperlink_all
-    assert_equal Pathname(@a.full_gem_path), rdoc.options.root
-    assert_equal %w[README lib], rdoc.options.files.sort
-
-    assert_equal 'MyTitle', rdoc.store.main
-  end
-
-  def test_generate_configuration_rdoc_array
-    Gem.configuration[:rdoc] = %w[-A]
-
-    FileUtils.mkdir_p @a.doc_dir
-    FileUtils.mkdir_p File.join(@a.gem_dir, 'lib')
-
-    @hook.generate
-
-    rdoc = @hook.instance_variable_get :@rdoc
-
-    assert rdoc.options.hyperlink_all
-  end
-
-  def test_generate_configuration_rdoc_string
-    Gem.configuration[:rdoc] = '-A'
-
-    FileUtils.mkdir_p @a.doc_dir
-    FileUtils.mkdir_p File.join(@a.gem_dir, 'lib')
-
-    @hook.generate
-
-    rdoc = @hook.instance_variable_get :@rdoc
-
-    assert rdoc.options.hyperlink_all
-  end
-
-  def test_generate_default_gem
-    Gem::Deprecate.skip_during do
-      if Gem.respond_to?(:default_specifications_dir)
-        klass = Gem
-      else
-        klass = Gem::Specification
-      end
-      @a.loaded_from = File.join klass.default_specifications_dir, 'a.gemspec'
-    end
-
-    @hook.generate
-
-    refute @hook.rdoc_installed?
-    refute @hook.ri_installed?
-  end
-
-  def test_generate_disabled
-    @hook.generate_rdoc = false
-    @hook.generate_ri   = false
-
-    @hook.generate
-
-    refute @hook.rdoc_installed?
-    refute @hook.ri_installed?
-  end
-
-  def test_generate_force
-    FileUtils.mkdir_p @a.doc_dir 'ri'
-    FileUtils.mkdir_p @a.doc_dir 'rdoc'
-    FileUtils.mkdir_p File.join(@a.gem_dir, 'lib')
-
-    @hook.force = true
-
-    @hook.generate
-
-    assert_path_not_exist File.join(@a.doc_dir('rdoc'), 'index.html')
-    assert_path_exist File.join(@a.doc_dir('ri'),   'cache.ri')
-  end
-
-  def test_generate_rubygems_compatible
-    original_default_gem_method = RDoc::RubygemsHook.method(:default_gem?)
-    RDoc::RubygemsHook.singleton_class.remove_method(:default_gem?)
-    RDoc::RubygemsHook.define_singleton_method(:default_gem?) { true }
-    FileUtils.mkdir_p @a.doc_dir 'ri'
-    FileUtils.mkdir_p @a.doc_dir 'rdoc'
-    FileUtils.mkdir_p File.join(@a.gem_dir, 'lib')
-
-    # rubygems/lib/rubygems/commands/rdoc_command.rb calls this
-    hook = RDoc::RubygemsHook.new @a, true, true
-    hook.force = true
-    hook.generate
-
-    assert_path_exist File.join(@a.doc_dir('rdoc'), 'index.html')
-  ensure
-    RDoc::RubygemsHook.singleton_class.remove_method(:default_gem?)
-    RDoc::RubygemsHook.define_singleton_method(:default_gem?, &original_default_gem_method)
-  end
-
-  def test_generate_no_overwrite
-    FileUtils.mkdir_p @a.doc_dir 'ri'
-    FileUtils.mkdir_p @a.doc_dir 'rdoc'
-    FileUtils.mkdir_p File.join(@a.gem_dir, 'lib')
-
-    @hook.generate
-
-    assert_path_not_exist File.join(@a.doc_dir('rdoc'), 'index.html')
-    assert_path_not_exist File.join(@a.doc_dir('ri'),   'cache.ri')
-  end
-
-  def test_generate_with_ri_opt
-    @a.rdoc_options << '--ri'
-    FileUtils.mkdir_p @a.doc_dir
-    FileUtils.mkdir_p File.join(@a.gem_dir, 'lib')
-    @hook.generate_rdoc = true
-    @hook.generate_ri   = true
-    @hook.generate
-
-    assert_path_exist File.join(@a.doc_dir('rdoc'), 'index.html')
-    assert_path_exist File.join(@a.doc_dir('ri'),   'cache.ri')
-  end
-
-  def test_new_rdoc
-    assert_kind_of RDoc::RDoc, @hook.new_rdoc
-  end
-
-  def test_rdoc_installed?
-    refute @hook.rdoc_installed?
-
-    FileUtils.mkdir_p @a.doc_dir 'rdoc'
-
-    assert @hook.rdoc_installed?
-  end
-
-  def test_remove
-    FileUtils.mkdir_p @a.doc_dir 'rdoc'
-    FileUtils.mkdir_p @a.doc_dir 'ri'
-
-    @hook.remove
-
-    refute @hook.rdoc_installed?
-    refute @hook.ri_installed?
-
-    assert_path_exist @a.doc_dir
-  end
-
-  def test_remove_unwritable
-    omit 'chmod not supported' if Gem.win_platform?
-    omit "assumes that euid is not root" if Process.euid == 0
-
-    FileUtils.mkdir_p @a.base_dir
-    FileUtils.chmod 0, @a.base_dir
-
-    e = assert_raise Gem::FilePermissionError do
-      @hook.remove
-    end
-
-    assert_equal @a.base_dir, e.directory
-  ensure
-    FileUtils.chmod(0755, @a.base_dir) if File.directory?(@a.base_dir)
-  end
-
-  def test_ri_installed?
-    refute @hook.ri_installed?
-
-    FileUtils.mkdir_p @a.doc_dir 'ri'
-
-    assert @hook.ri_installed?
-  end
-
-  def test_setup
-    @hook.setup
-
-    assert_path_exist @a.doc_dir
-  end
-
-  def test_setup_unwritable
-    omit 'chmod not supported' if Gem.win_platform?
-    omit "assumes that euid is not root" if Process.euid == 0
-
-    FileUtils.mkdir_p @a.doc_dir
-    FileUtils.chmod 0, @a.doc_dir
-
-    e = assert_raise Gem::FilePermissionError do
-      @hook.setup
-    end
-
-    assert_equal @a.doc_dir, e.directory
-  ensure
-    if File.exist? @a.doc_dir
-      FileUtils.chmod 0755, @a.doc_dir
-      FileUtils.rm_r @a.doc_dir
-    end
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc/rdoc_servlet_test.rb b/test/mri/rdoc/rdoc/rdoc_servlet_test.rb
deleted file mode 100644
index 825abdf4ab7..00000000000
--- a/test/mri/rdoc/rdoc/rdoc_servlet_test.rb
+++ /dev/null
@@ -1,553 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-begin
-  require 'webrick'
-rescue LoadError
-end
-
-class RDocServletTest < RDoc::TestCase
-
-  def setup
-    super
-
-    @orig_gem_path = Gem.path
-
-    @tempdir = File.join Dir.tmpdir, "test_rdoc_servlet_#{$$}"
-    Gem.use_paths @tempdir
-    Gem.ensure_gem_subdirectories @tempdir
-
-    @spec = Gem::Specification.new 'spec', '1.0'
-    @spec.loaded_from = @spec.spec_file
-
-    Gem::Specification.reset
-    Gem::Specification.all = [@spec]
-
-    @server = {}
-    def @server.mount(*) end
-
-    @stores = {}
-    @cache  = Hash.new { |hash, store| hash[store] = {} }
-
-    @extra_dirs = [File.join(@tempdir, 'extra1'), File.join(@tempdir, 'extra2')]
-
-    @s = RDoc::Servlet.new @server, @stores, @cache, nil, @extra_dirs
-
-    @req = WEBrick::HTTPRequest.new :Logger => nil
-    @res = WEBrick::HTTPResponse.new :HTTPVersion => '1.0'
-
-    def @req.path=(path)
-      instance_variable_set :@path, path
-    end
-
-    @req.instance_variable_set :@header, Hash.new { |h, k| h[k] = [] }
-
-    @base        = File.join @tempdir, 'base'
-    @system_dir  = File.join @tempdir, 'base', 'system'
-    @home_dir    = File.join @tempdir, 'home'
-    @gem_doc_dir = File.join @tempdir, 'doc'
-    @options     = RDoc::Options.new
-
-    @orig_base = RDoc::RI::Paths::BASE
-    RDoc::RI::Paths::BASE.replace @base
-    @orig_ri_path_homedir = RDoc::RI::Paths::HOMEDIR
-    RDoc::RI::Paths.send :remove_const, :HOMEDIR
-    RDoc::RI::Paths.const_set :HOMEDIR, @home_dir
-
-    RDoc::RI::Paths.instance_variable_set \
-      :@gemdirs, %w[/nonexistent/gems/example-1.0/ri]
-  end
-
-  def teardown
-    super
-
-    Gem.use_paths(*@orig_gem_path)
-    Gem::Specification.reset
-
-    FileUtils.rm_rf @tempdir
-
-    RDoc::RI::Paths::BASE.replace @orig_base
-    RDoc::RI::Paths.send :remove_const, :HOMEDIR
-    RDoc::RI::Paths.const_set :HOMEDIR, @orig_ri_path_homedir
-    RDoc::RI::Paths.instance_variable_set :@gemdirs, nil
-  end
-
-  def test_asset
-    temp_dir do
-      FileUtils.mkdir 'css'
-
-      now = Time.now
-      File.open 'css/rdoc.css', 'w' do |io| io.write 'h1 { color: red }' end
-      File.utime now, now, 'css/rdoc.css'
-
-      @s.asset_dirs[:darkfish] = '.'
-
-      @req.path = '/css/rdoc.css'
-
-      @s.asset :darkfish, @req, @res
-
-      assert_equal 'h1 { color: red }', @res.body
-      assert_equal 'text/css',          @res.content_type
-      assert_equal now.httpdate,        @res['last-modified']
-    end
-  end
-
-  def test_do_GET
-    touch_system_cache_path
-
-    @req.path = '/ruby/Missing.html'
-
-    @s.do_GET @req, @res
-
-    assert_equal 404, @res.status
-  end
-
-  def test_do_GET_asset_darkfish
-    temp_dir do
-      FileUtils.mkdir 'css'
-      FileUtils.touch 'css/rdoc.css'
-
-      @s.asset_dirs[:darkfish] = '.'
-
-      @req.path = '/css/rdoc.css'
-
-      @s.do_GET @req, @res
-
-      assert_equal 'text/css',          @res.content_type
-    end
-  end
-
-  def test_do_GET_asset_json_index
-    temp_dir do
-      FileUtils.mkdir 'js'
-      FileUtils.touch 'js/navigation.js'
-
-      @s.asset_dirs[:json_index] = '.'
-
-      @req.path = '/js/navigation.js'
-
-      @s.do_GET @req, @res
-
-      assert_equal 'application/javascript', @res.content_type
-    end
-  end
-
-  def test_do_GET_error
-    touch_system_cache_path
-
-    def @req.path() raise 'no' end
-
-    @s.do_GET @req, @res
-
-    assert_equal 500, @res.status
-  end
-
-  def test_do_GET_mount_path
-    @s = RDoc::Servlet.new @server, @stores, @cache, '/mount/path'
-
-    temp_dir do
-      FileUtils.mkdir 'css'
-      FileUtils.touch 'css/rdoc.css'
-
-      @s.asset_dirs[:darkfish] = '.'
-
-      @req.path = '/mount/path/css/rdoc.css'.dup
-
-      @s.do_GET @req, @res
-
-      assert_equal 'text/css', @res.content_type
-    end
-  end
-
-  def do_GET_not_found
-    touch_system_cache_path
-
-    @req.path = "/#{@spec.full_name}"
-
-    @s.do_GET @req, @res
-
-    assert_equal 404, @res.status
-  end
-
-  def test_do_GET_not_modified
-    touch_system_cache_path
-    @req.header['if-modified-since'] = [(Time.now + 10).httpdate]
-    @req.path = '/ruby/Missing.html'
-
-    assert_raise WEBrick::HTTPStatus::NotModified do
-      @s.do_GET @req, @res
-    end
-  end
-
-  def test_do_GET_root
-    touch_system_cache_path
-
-    @req.path = '/'
-
-    @s.do_GET @req, @res
-
-    assert_equal 'text/html',                                 @res.content_type
-    assert_match %r%<title>Local RDoc Documentation</title>%, @res.body
-  end
-
-  def test_do_GET_root_search
-    touch_system_cache_path
-
-    @req.path = '/js/search_index.js'
-
-    @s.do_GET @req, @res
-
-    assert_equal 'application/javascript', @res.content_type, @res.body
-  end
-
-  def test_documentation_page_class
-    store = RDoc::Store.new(@options)
-
-    generator = @s.generator_for store
-
-    file      = store.add_file 'file.rb'
-    klass     = file.add_class RDoc::NormalClass, 'Klass'
-                klass.add_class RDoc::NormalClass, 'Sub'
-
-    @s.documentation_page store, generator, 'Klass::Sub.html', @req, @res
-
-    assert_match %r%<title>class Klass::Sub - </title>%,            @res.body
-    assert_match %r%<body id="top" role="document" class="class">%, @res.body
-  end
-
-  def test_documentation_page_not_found
-    store = RDoc::Store.new(@options)
-
-    generator = @s.generator_for store
-
-    @req.path = '/ruby/Missing.html'
-
-    @s.documentation_page store, generator, 'Missing.html', @req, @res
-
-    assert_equal 404, @res.status
-  end
-
-  def test_documentation_page_page
-    store = RDoc::Store.new(@options)
-
-    generator = @s.generator_for store
-
-    store.add_file 'README.rdoc', parser: RDoc::Parser::Simple
-
-    @s.documentation_page store, generator, 'README_rdoc.html', @req, @res
-
-    assert_match %r%<title>README - </title>%, @res.body
-    assert_match %r%<body [^>]+ class="file">%,      @res.body
-  end
-
-  def test_documentation_page_page_with_nesting
-    store = RDoc::Store.new(@options)
-
-    generator = @s.generator_for store
-
-    store.add_file 'nesting/README.rdoc', parser: RDoc::Parser::Simple
-
-    @s.documentation_page store, generator, 'nesting/README_rdoc.html', @req, @res
-
-    assert_equal 200, @res.status
-  end
-
-  def test_documentation_source
-    store, path = @s.documentation_source '/ruby/Object.html'
-
-    assert_equal @system_dir, store.path
-
-    assert_equal 'Object.html', path
-  end
-
-  def test_documentation_source_cached
-    cached_store = RDoc::Store.new(@options)
-
-    @stores['ruby'] = cached_store
-
-    store, path = @s.documentation_source '/ruby/Object.html'
-
-    assert_same cached_store, store
-
-    assert_equal 'Object.html', path
-  end
-
-  def test_error
-    e = RuntimeError.new 'foo'
-    e.set_backtrace caller
-
-    @s.error e, @req, @res
-
-    assert_equal 'text/html',      @res.content_type
-    assert_equal 500,              @res.status
-    assert_match %r%<title>Error%, @res.body
-  end
-
-  def test_generator_for
-    store = RDoc::Store.new(@options)
-    store.main  = 'MAIN_PAGE.rdoc'
-    store.title = 'Title'
-
-    generator = @s.generator_for store
-
-    refute generator.file_output
-
-    assert_equal '..', generator.asset_rel_path
-
-    assert_equal 'MAIN_PAGE.rdoc', @s.options.main_page
-    assert_equal 'Title',          @s.options.title
-  end
-
-  def test_if_modified_since
-    omit 'File.utime on directory not supported' if Gem.win_platform?
-
-    temp_dir do
-      now = Time.now
-      File.utime now, now, '.'
-
-      @s.if_modified_since @req, @res, '.'
-
-      assert_equal now.to_i, Time.parse(@res['last-modified']).to_i
-    end
-  end
-
-  def test_if_modified_since_not_modified
-    omit 'File.utime on directory not supported' if Gem.win_platform?
-
-    temp_dir do
-      now = Time.now
-      File.utime now, now, '.'
-
-      @req.header['if-modified-since'] = [(now + 10).httpdate]
-
-      assert_raise WEBrick::HTTPStatus::NotModified do
-        @s.if_modified_since @req, @res, '.'
-      end
-
-      assert_equal now.to_i, Time.parse(@res['last-modified']).to_i
-    end
-  end
-
-  def test_installed_docs
-    touch_system_cache_path
-    touch_extra_cache_path
-
-    expected = [
-      ['My Extra Documentation', 'extra-1/', true, :extra,
-        @extra_dirs[0]],
-      ['Extra Documentation', 'extra-2/', false, :extra,
-        @extra_dirs[1]],
-      ['Ruby Documentation', 'ruby/', true,  :system,
-        @system_dir],
-      ['Site Documentation', 'site/', false, :site,
-        File.join(@base, 'site')],
-      ['Home Documentation', 'home/', false, :home,
-        RDoc::RI::Paths::HOMEDIR],
-      ['spec-1.0', 'spec-1.0/',       false, :gem,
-        File.join(@spec.doc_dir, 'ri')],
-    ]
-
-    assert_equal expected, @s.installed_docs
-  end
-
-  def test_not_found
-    generator = @s.generator_for RDoc::Store.new(@options)
-
-    @req.path = '/ruby/Missing.html'
-
-    @s.not_found generator, @req, @res
-
-    assert_equal 404,                                @res.status
-    assert_match %r%<title>Not Found</title>%,       @res.body
-    assert_match %r%<kbd>/ruby/Missing\.html</kbd>%, @res.body
-  end
-
-  def test_not_found_message
-    generator = @s.generator_for RDoc::Store.new(@options)
-
-    @req.path = '/ruby/Missing.html'
-
-    @s.not_found generator, @req, @res, 'woo, this is a message'
-
-    assert_equal 404,                          @res.status
-    assert_match %r%<title>Not Found</title>%, @res.body
-    assert_match %r%woo, this is a message%,   @res.body
-  end
-
-  def test_ri_paths
-    paths = @s.ri_paths
-
-    expected = [
-      [@extra_dirs[0],                 :extra],
-      [@extra_dirs[1],                 :extra],
-      [@system_dir,                    :system],
-      [File.join(@base, 'site'),       :site],
-      [RDoc::RI::Paths::HOMEDIR,       :home],
-      [File.join(@spec.doc_dir, 'ri'), :gem],
-    ]
-
-    assert_equal expected, paths.to_a
-  end
-
-  def test_root
-    @s.root @req, @res
-
-    assert_equal 'text/html',                                 @res.content_type
-    assert_match %r%<title>Local RDoc Documentation</title>%, @res.body
-  end
-
-  def test_root_search
-    touch_system_cache_path
-    touch_extra_cache_path
-
-    @s.root_search @req, @res
-
-    assert_equal 'application/javascript', @res.content_type
-
-    @res.body =~ /\{.*\}/
-
-    index = JSON.parse $&
-
-    expected = {
-      'index' => {
-        'searchIndex' => %w[
-          My\ Extra\ Documentation
-          Ruby\ Documentation
-        ],
-        'longSearchIndex' => %w[
-          My\ Extra\ Documentation
-          Ruby\ Documentation
-        ],
-        'info' => [
-          ['My Extra Documentation', '', @extra_dirs[0], '',
-            'My Extra Documentation'],
-          ['Ruby Documentation', '', 'ruby', '',
-            'Documentation for the Ruby standard library'],
-        ],
-      }
-    }
-
-    assert_equal expected, index
-  end
-
-  def test_show_documentation_index
-    touch_system_cache_path
-
-    @req.path = '/ruby'
-
-    @s.show_documentation @req, @res
-
-    assert_equal 'text/html',                               @res.content_type
-    assert_match %r%<title>Standard Library Documentation%, @res.body
-  end
-
-  def test_show_documentation_table_of_contents
-    touch_system_cache_path
-
-    @req.path = '/ruby/table_of_contents.html'
-
-    @s.show_documentation @req, @res
-
-    assert_equal 'text/html',         @res.content_type
-    assert_match %r%<title>Table of Contents - Standard Library Documentation%,
-                 @res.body
-  end
-
-  def test_show_documentation_page
-    touch_system_cache_path
-
-    @req.path = '/ruby/Missing.html'
-
-    @s.show_documentation @req, @res
-
-    assert_equal 404, @res.status
-  end
-
-  def test_show_documentation_search_index
-    touch_system_cache_path
-
-    @req.path = '/ruby/js/search_index.js'
-
-    @s.show_documentation @req, @res
-
-    assert_equal 'application/javascript', @res.content_type
-    assert_match %r%\Avar search_data =%,  @res.body
-  end
-
-  def test_store_for_gem
-    ri_dir = File.join @gem_doc_dir, 'spec-1.0', 'ri'
-    FileUtils.mkdir_p ri_dir
-    FileUtils.touch File.join ri_dir, 'cache.ri'
-
-    store = @s.store_for 'spec-1.0'
-
-    assert_equal File.join(@gem_doc_dir, 'spec-1.0', 'ri'), store.path
-    assert_equal :gem, store.type
-  end
-
-  def test_store_for_home
-    store = @s.store_for 'home'
-
-    assert_equal @home_dir, store.path
-    assert_equal :home, store.type
-  end
-
-  def test_store_for_missing_documentation
-    FileUtils.mkdir_p(File.join @gem_doc_dir, 'spec-1.0', 'ri')
-
-    e = assert_raise WEBrick::HTTPStatus::NotFound do
-      @s.store_for 'spec-1.0'
-    end
-
-    assert_equal 'Could not find documentation for "spec-1.0". Please run `gem rdoc --ri gem_name`',
-                 e.message
-  end
-
-  def test_store_for_missing_gem
-    e = assert_raise WEBrick::HTTPStatus::NotFound do
-      @s.store_for 'missing'
-    end
-
-    assert_equal 'Could not find gem "missing". Are you sure you installed it?',
-                 e.message
-  end
-
-  def test_store_for_ruby
-    store = @s.store_for 'ruby'
-
-    assert_equal @system_dir, store.path
-    assert_equal :system, store.type
-  end
-
-  def test_store_for_site
-    store = @s.store_for 'site'
-
-    assert_equal File.join(@base, 'site'), store.path
-    assert_equal :site, store.type
-  end
-
-  def test_store_for_extra
-    store = @s.store_for 'extra-1'
-
-    assert_equal @extra_dirs.first, store.path
-    assert_equal :extra, store.type
-  end
-
-  def touch_system_cache_path
-    store = RDoc::Store.new(@options, path: @system_dir)
-    store.title = 'Standard Library Documentation'
-
-    FileUtils.mkdir_p File.dirname store.cache_path
-
-    store.save
-  end
-
-  def touch_extra_cache_path
-    store = RDoc::Store.new(@options, path: @extra_dirs.first)
-    store.title = 'My Extra Documentation'
-
-    FileUtils.mkdir_p File.dirname store.cache_path
-
-    store.save
-  end
-
-end if defined?(WEBrick)
diff --git a/test/mri/rdoc/rdoc/rdoc_single_class_test.rb b/test/mri/rdoc/rdoc/rdoc_single_class_test.rb
deleted file mode 100644
index 6bbc5a2bd45..00000000000
--- a/test/mri/rdoc/rdoc/rdoc_single_class_test.rb
+++ /dev/null
@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocSingleClassTest < RDoc::TestCase
-
-  def setup
-    super
-
-    @c = RDoc::SingleClass.new 'C'
-  end
-
-  def test_aref_prefix
-    assert_equal 'sclass', @c.aref_prefix
-  end
-
-  def test_definition
-    assert_equal 'class << C', @c.definition
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc/rdoc_stats_test.rb b/test/mri/rdoc/rdoc/rdoc_stats_test.rb
deleted file mode 100644
index 1f02e460c39..00000000000
--- a/test/mri/rdoc/rdoc/rdoc_stats_test.rb
+++ /dev/null
@@ -1,720 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocStatsTest < RDoc::TestCase
-
-  def setup
-    super
-
-    @s = RDoc::Stats.new @store, 0
-
-    @tl = @store.add_file 'file.rb'
-    @tl.parser = RDoc::Parser::Ruby
-  end
-
-  def test_doc_stats
-    c = RDoc::CodeObject.new
-
-    assert_equal [1, 1], @s.doc_stats([c])
-  end
-
-  def test_doc_stats_documented
-    c = RDoc::CodeObject.new
-    c.comment = comment 'x'
-
-    assert_equal [1, 0], @s.doc_stats([c])
-  end
-
-  def test_doc_stats_display_eh
-    c = RDoc::CodeObject.new
-    c.ignore
-
-    assert_equal [0, 0], @s.doc_stats([c])
-  end
-
-  def test_report_attr
-    c = @tl.add_class RDoc::NormalClass, 'C'
-    c.record_location @tl
-    c.add_comment 'C', @tl
-
-    a = RDoc::Attr.new nil, 'a', 'RW', nil
-    a.record_location @tl
-    c.add_attribute a
-
-    @store.complete :public
-
-    report = @s.report
-
-    expected =
-      doc(
-        para('The following items are not documented:'),
-        blank_line,
-        verb(
-          "class C # is documented\n",
-          "\n",
-          "  attr_accessor :a # in file file.rb\n",
-          "\n",
-          "end\n"),
-        blank_line)
-
-    assert_equal expected, report
-  end
-
-  def test_report_attr_documented
-    c = @tl.add_class RDoc::NormalClass, 'C'
-    c.record_location @tl
-    c.add_comment 'C', @tl
-
-    a = RDoc::Attr.new nil, 'a', 'RW', 'a'
-    a.record_location @tl
-    c.add_attribute a
-
-    @store.complete :public
-
-    report = @s.report
-
-    assert_equal @s.great_job, report
-  end
-
-  def test_report_attr_line
-    c = @tl.add_class RDoc::NormalClass, 'C'
-    c.record_location @tl
-    c.add_comment 'C', @tl
-
-    a = RDoc::Attr.new nil, 'a', 'RW', nil
-    a.record_location @tl
-    a.line = 3
-    c.add_attribute a
-
-    @store.complete :public
-
-    assert_match '# in file file.rb:3', @s.report.accept(to_rdoc)
-  end
-
-  def test_report_constant
-    m = @tl.add_module RDoc::NormalModule, 'M'
-    m.record_location @tl
-    m.add_comment 'M', @tl
-
-    c = RDoc::Constant.new 'C', nil, nil
-    c.record_location @tl
-    m.add_constant c
-
-    @store.complete :public
-
-    report = @s.report
-
-    expected =
-      doc(
-        para('The following items are not documented:'),
-        blank_line,
-        verb(
-          "module M # is documented\n",
-          "\n",
-          "  # in file file.rb\n",
-          "  C = nil\n",
-          "\n",
-          "end\n"),
-        blank_line)
-
-    assert_equal expected, report
-  end
-
-  def test_report_constant_alias
-    mod = @tl.add_module RDoc::NormalModule, 'M'
-
-    c = @tl.add_class RDoc::NormalClass, 'C'
-    mod.add_constant c
-
-    ca = RDoc::Constant.new 'CA', nil, nil
-    ca.is_alias_for = c
-
-    @tl.add_constant ca
-
-    @store.complete :public
-
-    report = @s.report
-
-    # TODO change this to refute match, aliases should be ignored as they are
-    # programmer convenience constructs
-    assert_match 'class Object', report.accept(to_rdoc)
-  end
-
-  def test_report_constant_documented
-    m = @tl.add_module RDoc::NormalModule, 'M'
-    m.record_location @tl
-    m.add_comment 'M', @tl
-
-    c = RDoc::Constant.new 'C', nil, 'C'
-    c.record_location @tl
-    m.add_constant c
-
-    @store.complete :public
-
-    report = @s.report
-
-    assert_equal @s.great_job, report
-  end
-
-  def test_report_constant_line
-    m = @tl.add_module RDoc::NormalModule, 'M'
-    m.record_location @tl
-    m.add_comment 'M', @tl
-
-    c = RDoc::Constant.new 'C', nil, nil
-    c.record_location @tl
-    c.line = 5
-    m.add_constant c
-
-    @store.complete :public
-
-    assert_match '# in file file.rb:5', @s.report.accept(to_rdoc)
-  end
-
-  def test_report_class
-    c = @tl.add_class RDoc::NormalClass, 'C'
-    c.record_location @tl
-
-    m = RDoc::AnyMethod.new nil, 'm'
-    m.record_location @tl
-    c.add_method m
-    m.comment = 'm'
-
-    @store.complete :public
-
-    report = @s.report
-
-    expected =
-      doc(
-        para('The following items are not documented:'),
-        blank_line,
-        para('In files:'),
-        list(:BULLET, *[
-          item(nil, para('file.rb'))]),
-        blank_line,
-        verb("class C\n", "end\n"),
-        blank_line)
-
-    assert_equal expected, report
-  end
-
-  def test_report_skip_object
-    c = @tl.add_class RDoc::NormalClass, 'Object'
-    c.record_location @tl
-
-    m = RDoc::AnyMethod.new nil, 'm'
-    m.record_location @tl
-    c.add_method m
-    m.comment = 'm'
-
-    @store.complete :public
-
-    refute_match %r%^class Object$%, @s.report.accept(to_rdoc)
-  end
-
-  def test_report_class_documented
-    c = @tl.add_class RDoc::NormalClass, 'C'
-    c.record_location @tl
-    c.add_comment 'C', @tl
-
-    m = RDoc::AnyMethod.new nil, 'm'
-    m.record_location @tl
-    c.add_method m
-    m.comment = 'm'
-
-    @store.complete :public
-
-    report = @s.report
-
-    assert_equal @s.great_job, report
-  end
-
-  def test_report_class_documented_level_1
-    c1 = @tl.add_class RDoc::NormalClass, 'C1'
-    c1.record_location @tl
-    c1.add_comment 'C1', @tl
-
-    m1 = RDoc::AnyMethod.new nil, 'm1'
-    m1.record_location @tl
-    c1.add_method m1
-    m1.comment = 'm1'
-
-    c2 = @tl.add_class RDoc::NormalClass, 'C2'
-    c2.record_location @tl
-
-    m2 = RDoc::AnyMethod.new nil, 'm2'
-    m2.record_location @tl
-    c2.add_method m2
-    m2.comment = 'm2'
-
-    @store.complete :public
-
-    @s.coverage_level = 1
-
-    report = @s.report
-
-    expected =
-      doc(
-        para('The following items are not documented:'),
-        blank_line,
-        para('In files:'),
-        list(:BULLET, *[
-          item(nil, para('file.rb'))]),
-        blank_line,
-        verb("class C2\n", "end\n"),
-        blank_line)
-
-    assert_equal expected, report
-  end
-
-  def test_report_class_empty
-    @tl.add_class RDoc::NormalClass, 'C'
-
-    @store.complete :public
-
-    report = @s.report
-
-    expected =
-      doc(
-        para('The following items are not documented:'),
-        blank_line,
-        para('class C is referenced but empty.'),
-        para("It probably came from another project.  I'm sorry I'm holding it against you."),
-        blank_line)
-
-    assert_equal expected, report
-  end
-
-  def test_report_class_empty_2
-    c1 = @tl.add_class RDoc::NormalClass, 'C1'
-    c1.record_location @tl
-
-    c2 = @tl.add_class RDoc::NormalClass, 'C2'
-    c2.record_location @tl
-    c2.add_comment 'C2', @tl
-
-    @store.complete :public
-
-    @s.coverage_level = 1
-    report = @s.report
-
-    expected =
-      doc(
-        para('The following items are not documented:'),
-        blank_line,
-        para('In files:'),
-        list(:BULLET, *[
-          item(nil, para('file.rb'))]),
-        blank_line,
-        verb("class C1\n", "end\n"),
-        blank_line)
-
-    assert_equal expected, report
-  end
-
-  def test_report_class_method_documented
-    c = @tl.add_class RDoc::NormalClass, 'C'
-    c.record_location @tl
-
-    m = RDoc::AnyMethod.new nil, 'm'
-    m.record_location @tl
-    c.add_method m
-    m.comment = 'm'
-
-    @store.complete :public
-
-    report = @s.report
-
-    expected =
-      doc(
-        para('The following items are not documented:'),
-        blank_line,
-        para('In files:'),
-        list(:BULLET, *[
-          item(nil, para('file.rb'))]),
-        blank_line,
-        verb("class C\n", "end\n"),
-        blank_line)
-
-    assert_equal expected, report
-  end
-
-  def test_report_class_module_ignore
-    c = @tl.add_class RDoc::NormalClass, 'C'
-    c.ignore
-
-    @store.complete :public
-
-    report = @s.report_class_module c
-
-    assert_nil report
-  end
-
-  def test_report_empty
-    @store.complete :public
-
-    report = @s.report
-
-    assert_equal @s.great_job, report
-  end
-
-  def test_report_method
-    c = @tl.add_class RDoc::NormalClass, 'C'
-    c.record_location @tl
-    c.add_comment 'C', @tl
-
-    m1 = RDoc::AnyMethod.new nil, 'm1'
-    m1.record_location @tl
-    c.add_method m1
-
-    m2 = RDoc::AnyMethod.new nil, 'm2'
-    m2.record_location @tl
-    c.add_method m2
-    m2.comment = 'm2'
-
-    @store.complete :public
-
-    report = @s.report
-
-    expected =
-      doc(
-        para('The following items are not documented:'),
-        blank_line,
-        verb(*[
-          "class C # is documented\n",
-          "\n",
-          "  # in file file.rb\n",
-          "  def m1; end\n",
-          "\n",
-          "end\n"]),
-        blank_line)
-
-    assert_equal expected, report
-  end
-
-  def test_report_method_class
-    c = @tl.add_class RDoc::NormalClass, 'C'
-    c.record_location @tl
-    c.add_comment 'C', @tl
-
-    m1 = RDoc::AnyMethod.new nil, 'm1', singleton: true
-    m1.record_location @tl
-    c.add_method m1
-
-    m2 = RDoc::AnyMethod.new nil, 'm2', singleton: true
-    m2.record_location @tl
-    c.add_method m2
-    m2.comment = 'm2'
-
-    @store.complete :public
-
-    report = @s.report
-
-    expected =
-      doc(
-        para('The following items are not documented:'),
-        blank_line,
-        verb(*[
-          "class C # is documented\n",
-          "\n",
-          "  # in file file.rb\n",
-          "  def self.m1; end\n",
-          "\n",
-          "end\n"]),
-        blank_line)
-
-    assert_equal expected, report
-  end
-
-  def test_report_method_documented
-    c = @tl.add_class RDoc::NormalClass, 'C'
-    c.record_location @tl
-    c.add_comment 'C', @tl
-
-    m = RDoc::AnyMethod.new nil, 'm'
-    m.record_location @tl
-    c.add_method m
-    m.comment = 'm'
-
-    @store.complete :public
-
-    report = @s.report
-
-    assert_equal @s.great_job, report
-  end
-
-  def test_report_method_line
-    c = @tl.add_class RDoc::NormalClass, 'C'
-    c.record_location @tl
-    c.add_comment 'C', @tl
-
-    m1 = RDoc::AnyMethod.new nil, 'm1'
-    m1.record_location @tl
-    m1.line = 4
-    c.add_method m1
-
-    @store.complete :public
-
-    assert_match '# in file file.rb:4', @s.report.accept(to_rdoc)
-  end
-
-  def test_report_method_parameters
-    c = @tl.add_class RDoc::NormalClass, 'C'
-    c.record_location @tl
-    c.add_comment 'C', @tl
-
-    m1 = RDoc::AnyMethod.new nil, 'm1'
-    m1.record_location @tl
-    m1.params = '(p1, p2)'
-    m1.comment = 'Stuff with +p1+'
-    c.add_method m1
-
-    m2 = RDoc::AnyMethod.new nil, 'm2'
-    m2.record_location @tl
-    c.add_method m2
-    m2.comment = 'm2'
-
-    @store.complete :public
-
-    @s.coverage_level = 1
-    report = @s.report
-
-    expected =
-      doc(
-        para('The following items are not documented:'),
-        blank_line,
-        verb(*[
-          "class C # is documented\n",
-          "\n",
-          "  # in file file.rb\n",
-          "  # +p2+ is not documented\n",
-          "  def m1(p1, p2); end\n",
-          "\n",
-          "end\n"]),
-        blank_line)
-
-    assert_equal expected, report
-  end
-
-  def test_report_method_parameters_documented
-    @tl.parser = RDoc::Parser::Ruby
-    c = @tl.add_class RDoc::NormalClass, 'C'
-    c.record_location @tl
-    c.add_comment 'C', @tl
-
-    m = RDoc::AnyMethod.new nil, 'm'
-    m.record_location @tl
-    m.params = '(p1)'
-    m.comment = 'Stuff with +p1+'
-    c.add_method m
-
-    @store.complete :public
-
-    @s.coverage_level = 1
-    report = @s.report
-
-    assert_equal @s.great_job, report
-  end
-
-  def test_report_method_parameters_yield
-    c = @tl.add_class RDoc::NormalClass, 'C'
-    c.record_location @tl
-    c.add_comment 'C', @tl
-
-    m = RDoc::AnyMethod.new nil, 'm'
-    m.record_location @tl
-    m.call_seq = <<-SEQ
-m(a) { |c| ... }
-m(a, b) { |c, d| ... }
-    SEQ
-    m.comment = 'Stuff with +a+, yields +c+ for you to do stuff with'
-    c.add_method m
-
-    @store.complete :public
-
-    @s.coverage_level = 1
-    report = @s.report
-
-    expected =
-      doc(
-        para('The following items are not documented:'),
-        blank_line,
-        verb(
-          "class C # is documented\n",
-          "\n",
-          "  # in file file.rb\n",
-          "  # +b+, +d+ is not documented\n",
-          "  def m; end\n",
-          "\n",
-          "end\n"),
-        blank_line)
-
-    assert_equal expected, report
-  end
-
-  def test_summary
-    c = @tl.add_class RDoc::NormalClass, 'C'
-    c.record_location @tl
-
-    m = @tl.add_module RDoc::NormalModule, 'M'
-    m.record_location @tl
-
-    a = RDoc::Attr.new nil, 'a', 'RW', nil
-    a.record_location @tl
-    c.add_attribute a
-
-    c_c = RDoc::Constant.new 'C', nil, nil
-    c_c.record_location @tl
-    c.add_constant c_c
-
-    m = RDoc::AnyMethod.new nil, 'm'
-    m.record_location @tl
-    c.add_method m
-
-    @store.complete :public
-
-    summary = @s.summary.accept to_rdoc
-    summary.sub!(/  Elapsed:.*/m, '')
-
-    expected = <<-EXPECTED
-  Files:      0
-
-  Classes:    1 (1 undocumented)
-  Modules:    1 (1 undocumented)
-  Constants:  1 (1 undocumented)
-  Attributes: 1 (1 undocumented)
-  Methods:    1 (1 undocumented)
-
-  Total:      5 (5 undocumented)
-    0.00% documented
-
-    EXPECTED
-
-    assert_equal summary, expected
-  end
-
-  def test_summary_level_false
-    c = @tl.add_class RDoc::NormalClass, 'C'
-    c.record_location @tl
-
-    @store.complete :public
-
-    @s.coverage_level = false
-
-    summary = @s.summary.accept to_rdoc
-    summary.sub!(/  Elapsed:.*/m, '')
-
-    expected = <<-EXPECTED
-  Files:      0
-
-  Classes:    1 (1 undocumented)
-  Modules:    0 (0 undocumented)
-  Constants:  0 (0 undocumented)
-  Attributes: 0 (0 undocumented)
-  Methods:    0 (0 undocumented)
-
-  Total:      1 (1 undocumented)
-    0.00% documented
-
-    EXPECTED
-
-    assert_equal summary, expected
-  end
-
-  def test_summary_level_1
-    c = @tl.add_class RDoc::NormalClass, 'C'
-    c.record_location @tl
-    c.add_comment 'C', @tl
-
-    m = RDoc::AnyMethod.new nil, 'm'
-    m.record_location @tl
-    m.params = '(p1, p2)'
-    m.comment = 'Stuff with +p1+'
-    c.add_method m
-
-    @store.complete :public
-
-    @s.coverage_level = 1
-    @s.report
-
-    summary = @s.summary.accept to_rdoc
-    summary.sub!(/  Elapsed:.*/m, '')
-
-    expected = <<-EXPECTED
-  Files:      0
-
-  Classes:    1 (0 undocumented)
-  Modules:    0 (0 undocumented)
-  Constants:  0 (0 undocumented)
-  Attributes: 0 (0 undocumented)
-  Methods:    1 (0 undocumented)
-  Parameters: 2 (1 undocumented)
-
-  Total:      4 (1 undocumented)
-   75.00% documented
-
-    EXPECTED
-
-    assert_equal summary, expected
-  end
-
-  def to_rdoc
-    RDoc::Markup::ToRdoc.new
-  end
-
-  def test_undoc_params
-    method = RDoc::AnyMethod.new [], 'm'
-    method.params = '(a)'
-    method.comment = comment 'comment'
-
-    total, undoc = @s.undoc_params method
-
-    assert_equal 1,     total
-    assert_equal %w[a], undoc
-  end
-
-  def test_undoc_params_block
-    method = RDoc::AnyMethod.new [], 'm'
-    method.params = '(&a)'
-    method.comment = comment '+a+'
-
-    total, undoc = @s.undoc_params method
-
-    assert_equal 1, total
-    assert_empty    undoc
-  end
-
-  def test_undoc_params_documented
-    method = RDoc::AnyMethod.new [], 'm'
-    method.params = '(a)'
-    method.comment = comment '+a+'
-
-    total, undoc = @s.undoc_params method
-
-    assert_equal 1, total
-    assert_empty    undoc
-  end
-
-  def test_undoc_params_keywords
-    method = RDoc::AnyMethod.new [], 'm'
-    method.params = '(**a)'
-    method.comment = comment '+a+'
-
-    total, undoc = @s.undoc_params method
-
-    assert_equal 1, total
-    assert_empty    undoc
-  end
-
-  def test_undoc_params_splat
-    method = RDoc::AnyMethod.new [], 'm'
-    method.params = '(*a)'
-    method.comment = comment '+a+'
-
-    total, undoc = @s.undoc_params method
-
-    assert_equal 1, total
-    assert_empty    undoc
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc/rdoc_store_test.rb b/test/mri/rdoc/rdoc/rdoc_store_test.rb
deleted file mode 100644
index d22516100ec..00000000000
--- a/test/mri/rdoc/rdoc/rdoc_store_test.rb
+++ /dev/null
@@ -1,1057 +0,0 @@
-# frozen_string_literal: true
-require_relative 'xref_test_case'
-
-class RDocStoreTest < XrefTestCase
-
-  OBJECT_ANCESTORS = %w[BasicObject]
-
-  def setup
-    super
-
-    @tmpdir = File.join Dir.tmpdir, "test_rdoc_ri_store_#{$$}"
-    @s = RDoc::RI::Store.new(RDoc::Options.new, path: @tmpdir)
-
-    @top_level = @s.add_file 'file.rb'
-
-    @page = @s.add_file 'README.txt', parser: RDoc::Parser::Simple
-    @page.comment = RDoc::Comment.new 'This is a page', @page
-
-    @klass = @top_level.add_class RDoc::NormalClass, 'Object'
-    @klass.add_comment 'original', @top_level
-    @klass.record_location @top_level
-
-    @cmeth = RDoc::AnyMethod.new nil, 'cmethod', singleton: true
-    @cmeth.record_location @top_level
-
-    @meth_comment = RDoc::Comment.new 'method comment'
-    @meth_comment.location = @top_level
-
-    @meth = RDoc::AnyMethod.new nil, 'method'
-    @meth.record_location @top_level
-    @meth.comment = @meth_comment
-
-    @meth_bang = RDoc::AnyMethod.new nil, 'method!'
-    @meth_bang.record_location @top_level
-
-    @meth_bang_alias = RDoc::Alias.new nil, 'method!', 'method_bang', ''
-    @meth_bang_alias.record_location @top_level
-
-    @meth_bang.add_alias @meth_bang_alias, @klass
-
-    @attr_comment = RDoc::Comment.new 'attribute comment'
-    @attr_comment.location = @top_level
-
-    @attr = RDoc::Attr.new nil, 'attr', 'RW', ''
-    @attr.record_location @top_level
-    @attr.comment = @attr_comment
-
-    @klass.add_method @cmeth
-    @klass.add_method @meth
-    @klass.add_method @meth_bang
-    @klass.add_attribute @attr
-
-    @nest_klass = @klass.add_class RDoc::NormalClass, 'SubClass'
-    @nest_meth = RDoc::AnyMethod.new nil, 'method'
-    @nest_meth.record_location @top_level
-
-    @nest_incl = RDoc::Include.new 'Incl', ''
-    @nest_incl.record_location @top_level
-
-    @nest_klass.add_method @nest_meth
-    @nest_klass.add_include @nest_incl
-
-    @mod = @top_level.add_module RDoc::NormalModule, 'Mod'
-    @mod.record_location @top_level
-  end
-
-  def using_prism_ruby_parser?
-    RDoc::Parser::Ruby.name == 'RDoc::Parser::PrismRuby'
-  end
-
-  def teardown
-    super
-
-    FileUtils.rm_rf @tmpdir
-  end
-
-  def assert_cache(imethods, cmethods, attrs, modules,
-                   ancestors = {}, pages = [], main = nil, title = nil)
-    imethods ||= { 'Object' => %w[method method! method_bang] }
-    cmethods ||= { 'Object' => %w[cmethod] }
-    attrs    ||= { 'Object' => ['attr_accessor attr'] }
-
-    # this is sort-of a hack
-    @s.clean_cache_collection ancestors
-
-    expected = {
-      :ancestors                   => ancestors,
-      :attributes                  => attrs,
-      :class_methods               => cmethods,
-      :c_class_variables           => {},
-      :c_singleton_class_variables => {},
-      :encoding                    => Encoding::UTF_8,
-      :instance_methods            => imethods,
-      :modules                     => modules,
-      :pages                       => pages,
-      :main                        => main,
-      :title                       => title,
-    }
-
-    @s.save_cache
-
-    assert_equal expected, @s.cache
-  end
-
-  def test_add_c_enclosure
-    @s.add_c_enclosure 'cC1', @c1
-
-    expected = { 'cC1' => @c1 }
-
-    assert_equal expected, @s.c_enclosure_classes
-  end
-
-  def test_add_c_variables
-    options = RDoc::Options.new
-
-    c_file = @s.add_file 'ext.c'
-
-    some_ext   = c_file.add_class RDoc::NormalClass, 'SomeExt'
-                 c_file.add_class RDoc::SingleClass, 'SomeExtSingle'
-
-    c_parser = RDoc::Parser::C.new c_file, '', options, nil
-
-    c_parser.classes['cSomeExt']             = some_ext
-    c_parser.singleton_classes['s_cSomeExt'] = 'SomeExtSingle'
-
-    @s.add_c_variables c_parser
-
-    expected = { 'ext.c' => { 'cSomeExt' => 'SomeExt' } }
-
-    assert_equal expected, @s.c_class_variables
-
-    expected = { 'ext.c' => { 's_cSomeExt' => 'SomeExtSingle' } }
-
-    assert_equal expected, @s.c_singleton_class_variables
-  end
-
-  def test_add_file
-    top_level = @store.add_file 'file.rb'
-
-    assert_kind_of RDoc::TopLevel, top_level
-    assert_equal @store, top_level.store
-    assert_equal 'file.rb', top_level.name
-    assert_includes @store.all_files, top_level
-
-    assert_same top_level, @store.add_file('file.rb')
-    refute_same top_level, @store.add_file('other.rb')
-  end
-
-  def test_add_file_relative
-    top_level = @store.add_file 'path/file.rb', relative_name: 'file.rb'
-
-    assert_kind_of RDoc::TopLevel, top_level
-    assert_equal @store, top_level.store
-
-    assert_equal 'path/file.rb', top_level.absolute_name
-    assert_equal 'file.rb',      top_level.relative_name
-
-    assert_includes @store.all_files, top_level
-
-    assert_same top_level, @store.add_file('file.rb')
-    refute_same top_level, @store.add_file('other.rb')
-  end
-
-  def test_all_classes_and_modules
-    expected = %w[
-      C1 C10 C10::C11 C11 C2 C2::C3 C2::C3::H1 C3 C3::H1 C3::H2 C4 C4::C4 C5 C5::C1 C6 C7 C8 C9 C9::A C9::B
-      Child
-      M1 M1::M2
-      Object
-      Parent
-    ]
-
-    # C8::S1 does not exist. It should not be in the list.
-    # class C8; class << something; class S1; end; end; end
-    expected = (expected + ['C8::S1']).sort unless using_prism_ruby_parser?
-
-    assert_equal expected,
-                 @store.all_classes_and_modules.map { |m| m.full_name }.sort
-  end
-
-  def test_all_files
-    assert_equal %w[EXAMPLE.md xref_data.rb],
-                 @store.all_files.map { |m| m.full_name }.sort
-  end
-
-  def test_all_modules
-    assert_equal %w[M1 M1::M2],
-                 @store.all_modules.map { |m| m.full_name }.sort
-  end
-
-  def test_attributes
-    @s.cache[:attributes]['Object'] = %w[attr]
-
-    expected = { 'Object' => %w[attr] }
-
-    assert_equal expected, @s.attributes
-  end
-
-  def test_class_file
-    assert_equal File.join(@tmpdir, 'Object', 'cdesc-Object.ri'),
-                 @s.class_file('Object')
-    assert_equal File.join(@tmpdir, 'Object', 'SubClass', 'cdesc-SubClass.ri'),
-                 @s.class_file('Object::SubClass')
-  end
-
-  def test_class_methods
-    @s.cache[:class_methods]['Object'] = %w[method]
-
-    expected = { 'Object' => %w[method] }
-
-    assert_equal expected, @s.class_methods
-  end
-
-  def test_class_path
-    assert_equal File.join(@tmpdir, 'Object'), @s.class_path('Object')
-    assert_equal File.join(@tmpdir, 'Object', 'SubClass'),
-                 @s.class_path('Object::SubClass')
-  end
-
-  def test_classes
-    expected = %w[
-      C1 C10 C10::C11 C11 C2 C2::C3 C2::C3::H1 C3 C3::H1 C3::H2 C4 C4::C4 C5 C5::C1 C6 C7 C8 C9 C9::A C9::B
-      Child
-      Object
-      Parent
-    ]
-
-    # C8::S1 does not exist. It should not be in the list.
-    # class C8; class << something; class S1; end; end; end
-    expected = (expected + ['C8::S1']).sort unless using_prism_ruby_parser?
-
-    assert_equal expected, @store.all_classes.map { |m| m.full_name }.sort
-  end
-
-  def test_complete
-    a1 = RDoc::Constant.new 'A1', '', ''
-    @c2.add_module_alias @c2_c3, @c2_c3.name, a1, @top_level
-
-    @store.complete :public
-
-    a1 = @xref_data.find_class_or_module 'C2::A1'
-
-    assert_equal 'C2::A1', a1.full_name
-    refute_empty a1.aliases
-  end
-
-  def test_complete_nodoc
-    c_nodoc = @top_level.add_class RDoc::NormalClass, 'Nodoc'
-    c_nodoc.record_location @top_level
-    c_nodoc.document_self = nil
-
-    @s.complete :nodoc
-
-    assert_includes @s.classes_hash.keys, 'Nodoc'
-  end
-
-  def test_find_c_enclosure
-    assert_nil @s.find_c_enclosure 'cC1'
-
-    @s.add_c_enclosure 'cC1', @c1
-
-    assert_equal @c1, @s.find_c_enclosure('cC1')
-  end
-
-  def test_find_c_enclosure_from_cache
-    @s.save_class @klass
-    @s.classes_hash.clear
-
-    assert_nil @s.find_c_enclosure 'cObject'
-
-    @s.c_enclosure_names['cObject'] = 'Object'
-
-    klass = @s.find_c_enclosure('cObject')
-    assert_equal @klass, klass
-
-    assert_empty klass.comment_location
-    assert_equal @top_level, klass.parent
-
-    assert_includes @s.c_enclosure_classes, 'cObject'
-  end
-
-  def test_find_c_enclosure_from_cache_legacy
-    @klass.in_files.clear
-    @s.save_class @klass
-    @s.classes_hash.clear
-
-    assert_nil @s.find_c_enclosure 'cObject'
-
-    @s.c_enclosure_names['cObject'] = 'Object'
-
-    assert_nil @s.find_c_enclosure('cObject')
-  end
-
-  def test_resolve_c_superclasses
-    # first parse a child that references an unknown parent
-    c_file1 = @s.add_file 'ext1.c'
-    c_file1.add_class RDoc::NormalClass, 'Child', 'cExternParent'
-
-    # then parse the parent and register the C variable name as a C enclosure
-    c_file2 = @s.add_file 'ext2.c'
-    parent = c_file2.add_class RDoc::NormalClass, 'Parent', 'rb_cObject'
-
-    @s.add_c_enclosure('cExternParent', parent)
-
-    # at this point, the child's superclass is still the name of the C variable
-    assert_equal("cExternParent", @s.classes_hash['Child'].superclass)
-
-    @s.resolve_c_superclasses
-
-    # now the ancestor tree correctly references the NormalClass objects
-    assert_equal(parent, @s.classes_hash['Child'].superclass)
-  end
-
-  def test_find_class_named
-    assert_equal @c1, @store.find_class_named('C1')
-
-    assert_equal @c2_c3, @store.find_class_named('C2::C3')
-  end
-
-  def test_find_class_named_from
-    assert_equal @c5_c1, @store.find_class_named_from('C1', 'C5')
-
-    assert_equal @c1,    @store.find_class_named_from('C1', 'C4')
-  end
-
-  def test_find_class_or_module
-    assert_equal @m1, @store.find_class_or_module('M1')
-    assert_equal @c1, @store.find_class_or_module('C1')
-
-    assert_equal @m1, @store.find_class_or_module('::M1')
-    assert_equal @c1, @store.find_class_or_module('::C1')
-  end
-
-  def test_find_file_named
-    assert_equal @xref_data, @store.find_file_named(@file_name)
-  end
-
-  def test_find_module_named
-    assert_equal @m1,    @store.find_module_named('M1')
-    assert_equal @m1_m2, @store.find_module_named('M1::M2')
-  end
-
-  def test_find_text_page
-    page = @store.add_file 'PAGE.txt', parser: RDoc::Parser::Simple
-
-    assert_nil @store.find_text_page 'no such page'
-
-    assert_equal page, @store.find_text_page('PAGE.txt')
-  end
-
-  def test_friendly_path
-    @orig_xdg_data_home = ENV.delete('XDG_DATA_HOME')
-
-    @s.path = @tmpdir
-    @s.type = nil
-    assert_equal @s.path, @s.friendly_path
-
-    @s.type = :extra
-    assert_equal @s.path, @s.friendly_path
-
-    @s.type = :system
-    assert_equal "ruby core", @s.friendly_path
-
-    @s.type = :site
-    assert_equal "ruby site", @s.friendly_path
-
-    @s.type = :home
-    assert_equal File.expand_path("~/.local/share/rdoc"), @s.friendly_path
-
-    @s.type = :gem
-    @s.path = "#{@tmpdir}/gem_repository/doc/gem_name-1.0/ri"
-    assert_equal "gem gem_name-1.0", @s.friendly_path
-  ensure
-    ENV['XDG_DATA_HOME'] = @orig_xdg_data_home
-  end
-
-  def test_dry_run
-    refute @s.dry_run
-
-    @s.dry_run = true
-
-    assert @s.dry_run
-  end
-
-  def test_instance_methods
-    @s.cache[:instance_methods]['Object'] = %w[method]
-
-    expected = { 'Object' => %w[method] }
-
-    assert_equal expected, @s.instance_methods
-  end
-
-  def test_load_all
-    FileUtils.mkdir_p @tmpdir
-
-    @s.save
-
-    s = RDoc::Store.new(RDoc::Options.new, path: @tmpdir)
-
-    s.load_all
-
-    assert_equal [@klass, @nest_klass], s.all_classes.sort
-    assert_equal [@mod],                s.all_modules.sort
-    assert_equal [@page, @top_level],   s.all_files.sort
-
-    methods = s.all_classes_and_modules.flat_map do |mod|
-      mod.method_list
-    end.sort
-
-    _meth_bang_alias = RDoc::AnyMethod.new nil, 'method_bang'
-    _meth_bang_alias.parent = @klass
-
-    assert_equal [@meth, @meth_bang, _meth_bang_alias, @nest_meth, @cmeth],
-                 methods.sort_by { |m| m.full_name }
-
-    method = methods.find { |m| m == @meth }
-    assert_equal @meth_comment.parse, method.comment.parse
-
-    assert_equal @klass, methods.last.parent
-
-    attributes = s.all_classes_and_modules.flat_map do |mod|
-      mod.attributes
-    end.sort
-
-    assert_equal [@attr], attributes
-
-    assert_equal @attr_comment.parse, attributes.first.comment.parse
-  end
-
-  def test_load_cache
-    cache = {
-      :c_class_variables           =>
-        { 'file.c' => { 'cKlass' => 'Klass' } },
-      :c_singleton_class_variables =>
-        { 'file.c' => { 'sKlass' => 'KlassSingle' } },
-      :encoding                    => :encoding_value,
-      :methods                     => { "Object" => %w[Object#method] },
-      :main                        => @page.full_name,
-      :modules                     => %w[Object],
-      :pages                       => [],
-    }
-
-    Dir.mkdir @tmpdir
-
-    File.open File.join(@tmpdir, 'cache.ri'), 'wb' do |io|
-      Marshal.dump cache, io
-    end
-
-    # Store prioritize @encoding over the cached value
-    # See we need to unset @encoding to test the cached value
-    @s.encoding = nil
-
-    @s.load_cache
-
-    assert_equal cache, @s.cache
-
-    assert_equal :encoding_value, @s.encoding
-    assert_equal 'README.txt',    @s.main
-
-    expected = { 'file.c' => { 'cKlass' => 'Klass' } }
-    assert_equal expected, @s.cache[:c_class_variables]
-
-    expected = { 'file.c' => { 'sKlass' => 'KlassSingle' } }
-    assert_equal expected, @s.cache[:c_singleton_class_variables]
-
-    expected = { 'cKlass' => 'Klass' }
-    assert_equal expected, @s.c_enclosure_names
-  end
-
-  def test_load_cache_encoding_differs
-    cache = {
-      :c_class_variables           => {},
-      :c_singleton_class_variables => {},
-      :encoding                    => Encoding::ISO_8859_1,
-      :main                        => nil,
-      :methods                     => { "Object" => %w[Object#method] },
-      :modules                     => %w[Object],
-      :pages                       => [],
-    }
-
-    Dir.mkdir @tmpdir
-
-    File.open File.join(@tmpdir, 'cache.ri'), 'wb' do |io|
-      Marshal.dump cache, io
-    end
-
-    @s.encoding = Encoding::UTF_8
-
-    @s.load_cache
-
-    assert_equal cache, @s.cache
-
-    assert_equal Encoding::UTF_8, @s.encoding
-  end
-
-  def test_load_cache_no_cache
-    cache = {
-      :ancestors                   => {},
-      :attributes                  => {},
-      :class_methods               => {},
-      :c_class_variables           => {},
-      :c_singleton_class_variables => {},
-      :encoding                    => Encoding::UTF_8,
-      :instance_methods            => {},
-      :main                        => nil,
-      :modules                     => [],
-      :pages                       => [],
-      :title                       => nil,
-    }
-
-    @s.load_cache
-
-    assert_equal cache, @s.cache
-  end
-
-  def test_load_cache_legacy
-    cache = {
-      :ancestors        => {},
-      :attributes       => {},
-      :class_methods    => {},
-      :encoding         => :encoding_value,
-      :instance_methods => { "Object" => %w[Object#method] },
-      :modules          => %w[Object],
-      # no :pages
-      # no :main
-      # no :c_class_variables
-      # no :c_singleton_class_variables
-    }
-
-    Dir.mkdir @tmpdir
-
-    File.open File.join(@tmpdir, 'cache.ri'), 'wb' do |io|
-      Marshal.dump cache, io
-    end
-
-    # Store prioritize @encoding over the cached value
-    # See we need to unset @encoding to test the cached value
-    @s.encoding = nil
-
-    @s.load_cache
-
-    expected = {
-      :ancestors                   => {},
-      :attributes                  => {},
-      :class_methods               => {},
-      :c_class_variables           => {},
-      :c_singleton_class_variables => {},
-      :encoding                    => :encoding_value,
-      :instance_methods            => { "Object" => %w[Object#method] },
-      :main                        => nil,
-      :modules                     => %w[Object],
-      :pages                       => [],
-    }
-
-    assert_equal expected, @s.cache
-
-    assert_equal :encoding_value, @s.encoding
-    assert_nil                    @s.main
-  end
-
-  def test_load_class
-    @s.save_class @klass
-    @s.classes_hash.clear
-
-    assert_equal @klass, @s.load_class('Object')
-
-    assert_includes @s.classes_hash, 'Object'
-  end
-
-  def test_load_single_class
-    if using_prism_ruby_parser?
-      # Class defined inside singleton class is not documentable.
-      # @c8_s1 should be nil because C8::S1 does not exist.
-      assert_nil @c8_s1
-      return
-    end
-
-    @s.save_class @c8_s1
-    @s.classes_hash.clear
-
-    assert_equal @c8_s1, @s.load_class('C8::S1')
-
-    assert_includes @s.classes_hash, 'C8::S1'
-  end
-
-  def test_load_method
-    @s.save_method @klass, @meth_bang
-
-    meth = @s.load_method('Object', '#method!')
-    assert_equal @meth_bang, meth
-    assert_equal @klass, meth.parent
-    assert_equal @s, meth.store
-  end
-
-  def test_load_method_legacy
-    @s.save_method @klass, @meth
-
-    file = @s.method_file @klass.full_name, @meth.full_name
-
-    File.open file, 'wb' do |io|
-      io.write "\x04\bU:\x14RDoc::AnyMethod[\x0Fi\x00I" +
-               "\"\vmethod\x06:\x06EF\"\x11Klass#method0:\vpublic" +
-               "o:\eRDoc::Markup::Document\x06:\v@parts[\x06" +
-               "o:\x1CRDoc::Markup::Paragraph\x06;\t[\x06I" +
-               "\"\x16this is a comment\x06;\x06FI" +
-               "\"\rcall_seq\x06;\x06FI\"\x0Fsome_block\x06;\x06F" +
-               "[\x06[\aI\"\faliased\x06;\x06Fo;\b\x06;\t[\x06" +
-               "o;\n\x06;\t[\x06I\"\x12alias comment\x06;\x06FI" +
-               "\"\nparam\x06;\x06F"
-    end
-
-    meth = @s.load_method('Object', '#method')
-    assert_equal 'Klass#method', meth.full_name
-    assert_equal @klass,         meth.parent
-    assert_equal @s,             meth.store
-  end
-
-  def test_load_page
-    @s.save_page @page
-
-    assert_equal @page, @s.load_page('README.txt')
-  end
-
-  def test_main
-    assert_nil @s.main
-
-    @s.main = 'README.txt'
-
-    assert_equal 'README.txt', @s.main
-  end
-
-  def test_method_file
-    assert_equal File.join(@tmpdir, 'Object', 'method-i.ri'),
-                 @s.method_file('Object', 'Object#method')
-
-    assert_equal File.join(@tmpdir, 'Object', 'method%21-i.ri'),
-                 @s.method_file('Object', 'Object#method!')
-
-    assert_equal File.join(@tmpdir, 'Object', 'SubClass', 'method%21-i.ri'),
-                 @s.method_file('Object::SubClass', 'Object::SubClass#method!')
-
-    assert_equal File.join(@tmpdir, 'Object', 'method-c.ri'),
-                 @s.method_file('Object', 'Object::method')
-  end
-
-  def test_module_names
-    @s.save_class @klass
-
-    assert_equal %w[Object], @s.module_names
-  end
-
-  def test_page
-    page = @store.add_file 'PAGE.txt', parser: RDoc::Parser::Simple
-
-    assert_nil @store.page 'no such page'
-
-    assert_equal page, @store.page('PAGE')
-  end
-
-  def test_page_with_extension
-    page = @store.add_file 'PAGE.txt', parser: RDoc::Parser::Simple
-
-    assert_nil @store.page 'no such page'
-
-    assert_equal page, @store.page('PAGE.txt')
-  end
-
-  def test_save
-    FileUtils.mkdir_p @tmpdir
-
-    @s.save
-
-    assert_directory File.join(@tmpdir, 'Object')
-
-    assert_file File.join(@tmpdir, 'Object', 'cdesc-Object.ri')
-    assert_file File.join(@tmpdir, 'Object', 'method-i.ri')
-    assert_file File.join(@tmpdir, 'page-README_txt.ri')
-
-    assert_file File.join(@tmpdir, 'cache.ri')
-
-    expected = {
-      :ancestors => {
-        'Object::SubClass' => %w[Incl Object],
-      },
-      :attributes => { 'Object' => ['attr_accessor attr'] },
-      :class_methods => { 'Object' => %w[cmethod] },
-      :c_class_variables => {},
-      :c_singleton_class_variables => {},
-      :instance_methods => {
-        'Object' => %w[attr method method! method_bang],
-        'Object::SubClass' => %w[method],
-      },
-      :main => nil,
-      :modules => %w[Mod Object Object::SubClass],
-      :encoding => Encoding::UTF_8,
-      :pages => %w[README.txt],
-      :title => nil,
-    }
-
-    expected[:ancestors]['Object'] = %w[BasicObject]
-
-    File.open File.join(@tmpdir, 'cache.ri'), 'rb' do |io|
-      cache = Marshal.load io.read
-
-      assert_equal expected, cache
-    end
-  end
-
-  def test_save_cache
-    @s.save_class @klass
-    @s.save_method @klass, @meth
-    @s.save_method @klass, @cmeth
-    @s.save_class @nest_klass
-    @s.save_page @page
-    @s.encoding = :encoding_value
-    @s.main     = @page.full_name
-    @s.title    = 'title'
-
-    options = RDoc::Options.new
-
-    c_file = @s.add_file 'ext.c'
-
-    some_ext   = c_file.add_class RDoc::NormalClass, 'SomeExt'
-                 c_file.add_class RDoc::SingleClass, 'SomeExtSingle'
-
-    c_parser = RDoc::Parser::C.new c_file, '', options, nil
-
-    c_parser.classes['cSomeExt']             = some_ext
-    c_parser.singleton_classes['s_cSomeExt'] = 'SomeExtSingle'
-
-    @s.add_c_variables c_parser
-
-    @s.save_cache
-
-    assert_file File.join(@tmpdir, 'cache.ri')
-
-    c_class_variables = {
-      'ext.c' => {
-        'cSomeExt' => 'SomeExt'
-      }
-    }
-
-    c_singleton_class_variables = {
-      'ext.c' => {
-        's_cSomeExt' => 'SomeExtSingle'
-      }
-    }
-
-    expected = {
-      :ancestors => {
-        'Object::SubClass' => %w[Incl Object],
-      },
-      :attributes => { 'Object' => ['attr_accessor attr'] },
-      :class_methods => { 'Object' => %w[cmethod] },
-      :c_class_variables => c_class_variables,
-      :c_singleton_class_variables => c_singleton_class_variables,
-      :instance_methods => {
-        'Object' => %w[method method! method_bang],
-        'Object::SubClass' => %w[method],
-      },
-      :main => @page.full_name,
-      :modules => %w[Object Object::SubClass],
-      :encoding => :encoding_value,
-      :pages => %w[README.txt],
-      :title => 'title',
-    }
-
-    expected[:ancestors]['Object'] = %w[BasicObject]
-
-    File.open File.join(@tmpdir, 'cache.ri'), 'rb' do |io|
-      cache = Marshal.load io.read
-
-      assert_equal expected, cache
-    end
-  end
-
-  def test_save_cache_dry_run
-    @s.dry_run = true
-
-    @s.save_class @klass
-    @s.save_method @klass, @meth
-    @s.save_method @klass, @cmeth
-    @s.save_class @nest_klass
-
-    @s.save_cache
-
-    refute_file File.join(@tmpdir, 'cache.ri')
-  end
-
-  def test_save_cache_duplicate_methods
-    @s.save_method @klass, @meth
-    @s.save_method @klass, @meth
-
-    @s.save_cache
-
-    assert_cache({ 'Object' => %w[method] }, {}, {}, [])
-  end
-
-  def test_save_cache_duplicate_pages
-    @s.save_page @page
-    @s.save_page @page
-
-    @s.save_cache
-
-    assert_cache({}, {}, {}, [], {}, %w[README.txt])
-  end
-
-  def test_save_class
-    @s.save_class @klass
-
-    assert_directory File.join(@tmpdir, 'Object')
-    assert_file File.join(@tmpdir, 'Object', 'cdesc-Object.ri')
-
-    assert_cache nil, nil, nil, %w[Object], 'Object' => OBJECT_ANCESTORS
-
-    assert_equal @klass, @s.load_class('Object')
-  end
-
-  def test_save_class_basic_object
-    @klass.instance_variable_set :@superclass, nil
-
-    @s.save_class @klass
-
-    assert_directory File.join(@tmpdir, 'Object')
-    assert_file File.join(@tmpdir, 'Object', 'cdesc-Object.ri')
-
-    assert_cache(nil, nil, nil, %w[Object])
-
-    assert_equal @klass, @s.load_class('Object')
-  end
-
-  def test_save_class_delete
-    # save original
-    @s.save_class @klass
-    @s.save_method @klass, @meth
-    @s.save_method @klass, @meth_bang
-    @s.save_method @klass, @cmeth
-    @s.save_method @klass, @attr
-    @s.save_cache
-
-    klass = RDoc::NormalClass.new 'Object'
-
-    meth = klass.add_method RDoc::AnyMethod.new(nil, 'replace')
-    meth.record_location @top_level
-
-    # load original, save newly updated class
-    @s = RDoc::RI::Store.new(RDoc::Options.new, path: @tmpdir)
-    @s.load_cache
-    @s.save_class klass
-    @s.save_cache
-
-    # load from disk again
-    @s = RDoc::RI::Store.new(RDoc::Options.new, path: @tmpdir)
-    @s.load_cache
-
-    @s.load_class 'Object'
-
-    assert_cache({ 'Object' => %w[replace] }, {},
-                 { 'Object' => %w[attr_accessor\ attr] }, %w[Object],
-                   'Object' => OBJECT_ANCESTORS)
-
-    # assert these files were deleted
-    refute_file @s.method_file(@klass.full_name, @meth.full_name)
-    refute_file @s.method_file(@klass.full_name, @meth_bang.full_name)
-    refute_file @s.method_file(@klass.full_name, @cmeth.full_name)
-
-    # assert these files were not deleted
-    assert_file @s.method_file(@klass.full_name, @attr.full_name)
-  end
-
-  def test_save_class_dry_run
-    @s.dry_run = true
-
-    @s.save_class @klass
-
-    refute_file File.join(@tmpdir, 'Object')
-    refute_file File.join(@tmpdir, 'Object', 'cdesc-Object.ri')
-  end
-
-  def test_save_class_loaded
-    @s.save
-
-    assert_directory File.join(@tmpdir, 'Object')
-    assert_file      File.join(@tmpdir, 'Object', 'cdesc-Object.ri')
-
-    assert_file @s.method_file(@klass.full_name, @attr.full_name)
-    assert_file @s.method_file(@klass.full_name, @cmeth.full_name)
-    assert_file @s.method_file(@klass.full_name, @meth.full_name)
-    assert_file @s.method_file(@klass.full_name, @meth_bang.full_name)
-
-    s = RDoc::Store.new(RDoc::Options.new, path: @s.path)
-    s.load_cache
-
-    loaded = s.load_class 'Object'
-
-    assert_equal @klass, loaded
-
-    s.save_class loaded
-
-    s = RDoc::Store.new(RDoc::Options.new, path: @s.path)
-    s.load_cache
-
-    reloaded = s.load_class 'Object'
-
-    assert_equal @klass, reloaded
-
-    # assert these files were not deleted.  Bug #171
-    assert_file s.method_file(@klass.full_name, @attr.full_name)
-    assert_file s.method_file(@klass.full_name, @cmeth.full_name)
-    assert_file s.method_file(@klass.full_name, @meth.full_name)
-    assert_file s.method_file(@klass.full_name, @meth_bang.full_name)
-  end
-
-  def test_save_class_merge
-    @s.save_class @klass
-
-    klass = RDoc::NormalClass.new 'Object'
-    klass.add_comment 'new comment', @top_level
-
-    s = RDoc::RI::Store.new(RDoc::Options.new, path: @tmpdir)
-    s.save_class klass
-
-    s = RDoc::RI::Store.new(RDoc::Options.new, path: @tmpdir)
-
-    inner = @RM::Document.new @RM::Paragraph.new 'new comment'
-    inner.file = @top_level
-
-    document = @RM::Document.new inner
-
-    assert_equal document, s.load_class('Object').comment_location
-  end
-
-  # This is a functional test
-  def test_save_class_merge_constant
-    store = RDoc::Store.new(RDoc::Options.new)
-    tl = store.add_file 'file.rb'
-
-    klass = tl.add_class RDoc::NormalClass, 'C'
-    klass.add_comment 'comment', tl
-
-    const = klass.add_constant RDoc::Constant.new('CONST', nil, nil)
-    const.record_location tl
-
-    @s.save_class klass
-
-    # separate parse run, independent store
-    store = RDoc::Store.new(RDoc::Options.new)
-    tl = store.add_file 'file.rb'
-    klass2 = tl.add_class RDoc::NormalClass, 'C'
-    klass2.record_location tl
-
-    s = RDoc::RI::Store.new(RDoc::Options.new, path: @tmpdir)
-    s.save_class klass2
-
-    # separate `ri` run, independent store
-    s = RDoc::RI::Store.new(RDoc::Options.new, path: @tmpdir)
-
-    result = s.load_class 'C'
-
-    assert_empty result.constants
-  end
-
-  def test_save_class_methods
-    @s.save_class @klass
-
-    assert_directory File.join(@tmpdir, 'Object')
-    assert_file File.join(@tmpdir, 'Object', 'cdesc-Object.ri')
-
-    assert_cache nil, nil, nil, %w[Object], 'Object' => OBJECT_ANCESTORS
-
-    assert_equal @klass, @s.load_class('Object')
-  end
-
-  def test_save_class_nested
-    @s.save_class @nest_klass
-
-    assert_directory File.join(@tmpdir, 'Object', 'SubClass')
-    assert_file File.join(@tmpdir, 'Object', 'SubClass', 'cdesc-SubClass.ri')
-
-    assert_cache({ 'Object::SubClass' => %w[method] }, {}, {},
-                 %w[Object::SubClass], 'Object::SubClass' => %w[Incl Object])
-  end
-
-  def test_save_method
-    @s.save_method @klass, @meth
-
-    assert_directory File.join(@tmpdir, 'Object')
-    assert_file File.join(@tmpdir, 'Object', 'method-i.ri')
-
-    assert_cache({ 'Object' => %w[method] }, {}, {}, [])
-
-    assert_equal @meth, @s.load_method('Object', '#method')
-  end
-
-  def test_save_method_dry_run
-    @s.dry_run = true
-
-    @s.save_method @klass, @meth
-
-    refute_file File.join(@tmpdir, 'Object')
-    refute_file File.join(@tmpdir, 'Object', 'method-i.ri')
-  end
-
-  def test_save_method_nested
-    @s.save_method @nest_klass, @nest_meth
-
-    assert_directory File.join(@tmpdir, 'Object', 'SubClass')
-    assert_file File.join(@tmpdir, 'Object', 'SubClass', 'method-i.ri')
-
-    assert_cache({ 'Object::SubClass' => %w[method] }, {}, {}, [])
-  end
-
-  def test_save_page
-    @s.save_page @page
-
-    assert_file File.join(@tmpdir, 'page-README_txt.ri')
-
-    assert_cache({}, {}, {}, [], {}, %w[README.txt])
-  end
-
-  def test_save_page_file
-    @s.save_page @top_level
-
-    refute_file File.join(@tmpdir, 'page-file_rb.ri')
-  end
-
-  def test_source
-    @s.path = @tmpdir
-    @s.type = nil
-    assert_equal @s.path, @s.source
-
-    @s.type = :extra
-    assert_equal @s.path, @s.source
-
-    @s.type = :system
-    assert_equal "ruby", @s.source
-
-    @s.type = :site
-    assert_equal "site", @s.source
-
-    @s.type = :home
-    assert_equal "home", @s.source
-
-    @s.type = :gem
-    @s.path = "#{@tmpdir}/gem_repository/doc/gem_name-1.0/ri"
-    assert_equal "gem_name-1.0", @s.source
-  end
-
-  def test_title
-    assert_nil @s.title
-
-    @s.title = 'rdoc'
-
-    assert_equal 'rdoc', @s.title
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc/rdoc_task_test.rb b/test/mri/rdoc/rdoc/rdoc_task_test.rb
deleted file mode 100644
index cd37b2520e1..00000000000
--- a/test/mri/rdoc/rdoc/rdoc_task_test.rb
+++ /dev/null
@@ -1,182 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-begin
-  require 'rake'
-rescue LoadError
-end
-
-class RDocTaskTest < RDoc::TestCase
-
-  def setup
-    super
-
-    Rake::Task.clear
-
-    @t = RDoc::Task.new
-  end
-
-  def test_clobber_task_description
-    assert_equal 'Remove RDoc HTML files', @t.clobber_task_description
-  end
-
-  def test_inline_source
-    _, err = verbose_capture_output do
-      assert @t.inline_source
-    end
-
-    assert_equal "RDoc::Task#inline_source is deprecated\n", err
-
-    _, err = verbose_capture_output do
-      @t.inline_source = false
-    end
-
-    assert_equal "RDoc::Task#inline_source is deprecated\n", err
-
-    capture_output do
-      assert @t.inline_source
-    end
-  end
-
-  def test_markup_option
-    rdoc_task = RDoc::Task.new do |rd|
-      rd.markup = "tomdoc"
-    end
-
-    assert_equal %w[-o html --markup tomdoc], rdoc_task.option_list
-  end
-
-  def test_tasks_creation
-    RDoc::Task.new
-    assert Rake::Task[:rdoc]
-    assert Rake::Task[:clobber_rdoc]
-    assert Rake::Task[:rerdoc]
-    assert Rake::Task[:"rdoc:coverage"]
-    assert_equal ["html/created.rid"], Rake::Task[:rdoc].prerequisites
-  end
-
-  def test_tasks_creation_with_custom_name_symbol
-    rd = RDoc::Task.new(:rdoc_dev)
-    assert Rake::Task[:rdoc_dev]
-    assert Rake::Task[:clobber_rdoc_dev]
-    assert Rake::Task[:rerdoc_dev]
-    assert Rake::Task[:"rdoc_dev:coverage"]
-    assert_equal :rdoc_dev, rd.name
-  end
-
-  def test_tasks_option_parser
-    rdoc_task = RDoc::Task.new do |rd|
-      rd.title = "Test Tasks Option Parser"
-      rd.main = "README.md"
-      rd.rdoc_files.include("README.md")
-      rd.options << "--all"
-    end
-
-    assert_equal "Test Tasks Option Parser", rdoc_task.title
-    assert_equal "README.md", rdoc_task.main
-    assert rdoc_task.rdoc_files.include?("README.md")
-    assert rdoc_task.options.include?("--all")
-
-    args = %w[--all -o html --main README.md] << "--title" << "Test Tasks Option Parser" << "README.md"
-    assert_equal args, rdoc_task.option_list + rdoc_task.rdoc_files
-  end
-
-  def test_generator_option
-    rdoc_task = RDoc::Task.new do |rd|
-      rd.generator = "ri"
-    end
-
-    assert_equal %w[-o html -f ri], rdoc_task.option_list
-  end
-
-  def test_main_option
-    rdoc_task = RDoc::Task.new do |rd|
-      rd.main = "README.md"
-    end
-
-    assert_equal %w[-o html --main README.md], rdoc_task.option_list
-  end
-
-  def test_output_dir_option
-    rdoc_task = RDoc::Task.new do |rd|
-      rd.rdoc_dir = "zomg"
-    end
-
-    assert_equal %w[-o zomg], rdoc_task.option_list
-  end
-
-  def test_rdoc_task_description
-    assert_equal 'Build RDoc HTML files', @t.rdoc_task_description
-  end
-
-  def test_rerdoc_task_description
-    assert_equal 'Rebuild RDoc HTML files', @t.rerdoc_task_description
-  end
-
-  def test_coverage_task_description
-    assert_equal 'Print RDoc coverage report', @t.coverage_task_description
-  end
-
-  def test_tasks_creation_with_custom_name_string
-    rd = RDoc::Task.new("rdoc_dev")
-    assert Rake::Task[:rdoc_dev]
-    assert Rake::Task[:clobber_rdoc_dev]
-    assert Rake::Task[:rerdoc_dev]
-    assert Rake::Task[:"rdoc_dev:coverage"]
-    assert_equal "rdoc_dev", rd.name
-  end
-
-  def test_tasks_creation_with_custom_name_hash
-    options = {
-      :rdoc => "rdoc",
-      :clobber_rdoc => "rdoc:clean",
-      :rerdoc => "rdoc:force"
-    }
-
-    Rake::Task.clear
-
-    rd = RDoc::Task.new(options)
-    assert Rake::Task[:"rdoc"]
-    assert Rake::Task[:"rdoc:clean"]
-    assert Rake::Task[:"rdoc:force"]
-    assert Rake::Task[:"rdoc:coverage"]
-    assert_raise(RuntimeError) { Rake::Task[:clobber_rdoc] }
-    assert_equal options, rd.name
-  end
-
-  def test_tasks_creation_with_custom_name_hash_will_use_default_if_an_option_isnt_given
-    RDoc::Task.new(:clobber_rdoc => "rdoc:clean")
-    assert Rake::Task[:rdoc]
-    assert Rake::Task[:"rdoc:clean"]
-    assert Rake::Task[:rerdoc]
-    assert Rake::Task[:"rdoc:coverage"]
-  end
-
-  def test_tasks_creation_with_custom_name_hash_raises_exception_if_invalid_option_given
-    assert_raise(ArgumentError) do
-      RDoc::Task.new(:foo => "bar")
-    end
-
-    begin
-      RDoc::Task.new(:foo => "bar")
-    rescue ArgumentError => e
-      assert_match(/foo/, e.message)
-    end
-  end
-
-  def test_template_option
-    rdoc_task = RDoc::Task.new do |rd|
-      rd.template = "foo"
-    end
-
-    assert_equal %w[-o html -T foo], rdoc_task.option_list
-  end
-
-  def test_title_option
-    rdoc_task = RDoc::Task.new do |rd|
-      rd.title = "Test Title Option"
-    end
-
-    assert_equal %w[-o html] << "--title" << "Test Title Option", rdoc_task.option_list
-  end
-
-end if defined?(Rake::Task)
diff --git a/test/mri/rdoc/rdoc/rdoc_text_test.rb b/test/mri/rdoc/rdoc/rdoc_text_test.rb
deleted file mode 100644
index 2fd97614007..00000000000
--- a/test/mri/rdoc/rdoc/rdoc_text_test.rb
+++ /dev/null
@@ -1,585 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'helper'
-require 'timeout'
-
-class RDocTextTest < RDoc::TestCase
-
-  include RDoc::Text
-
-  def setup
-    super
-
-    @options = RDoc::Options.new
-
-    @top_level = @store.add_file 'file.rb'
-    @language = nil
-  end
-
-  def test_self_encode_fallback
-    assert_equal '…',
-                 RDoc::Text::encode_fallback('…', Encoding::UTF_8,    '...')
-    assert_equal '...',
-                 RDoc::Text::encode_fallback('…', Encoding::US_ASCII, '...')
-  end
-
-  def test_expand_tabs
-    assert_equal("hello\n  dave",
-                 expand_tabs("hello\n  dave"), 'spaces')
-
-    assert_equal("hello\n        dave",
-                 expand_tabs("hello\n\tdave"), 'tab')
-
-    assert_equal("hello\n        dave",
-                 expand_tabs("hello\n \tdave"), '1 space tab')
-
-    assert_equal("hello\n        dave",
-                 expand_tabs("hello\n  \tdave"), '2 space tab')
-
-    assert_equal("hello\n        dave",
-                 expand_tabs("hello\n   \tdave"), '3 space tab')
-
-    assert_equal("hello\n        dave",
-                 expand_tabs("hello\n    \tdave"), '4 space tab')
-
-    assert_equal("hello\n        dave",
-                 expand_tabs("hello\n     \tdave"), '5 space tab')
-
-    assert_equal("hello\n        dave",
-                 expand_tabs("hello\n      \tdave"), '6 space tab')
-
-    assert_equal("hello\n        dave",
-                 expand_tabs("hello\n       \tdave"), '7 space tab')
-
-    assert_equal("hello\n                dave",
-                 expand_tabs("hello\n         \tdave"), '8 space tab')
-
-    assert_equal('.               .',
-                 expand_tabs(".\t\t."), 'dot tab tab dot')
-
-    assert_equal('a       a',
-                 Timeout.timeout(1) {expand_tabs("\ra\ta")}, "carriage return")
-  end
-
-  def test_expand_tabs_encoding
-    inn = "hello\ns\tdave"
-    inn = RDoc::Encoding.change_encoding inn, Encoding::BINARY
-
-    out = expand_tabs inn
-
-    assert_equal "hello\ns       dave", out
-    assert_equal Encoding::BINARY, out.encoding
-  end
-
-  def test_flush_left
-    text = <<-TEXT
-
-  we don't worry too much.
-
-  The comments associated with
-    TEXT
-
-    expected = <<-EXPECTED
-
-we don't worry too much.
-
-The comments associated with
-    EXPECTED
-
-    assert_equal expected, flush_left(text)
-  end
-
-  def test_flush_left_encoding
-    text = <<-TEXT
-
-  we don't worry too much.
-
-  The comments associated with
-    TEXT
-
-    text = RDoc::Encoding.change_encoding text, Encoding::US_ASCII
-
-    expected = <<-EXPECTED
-
-we don't worry too much.
-
-The comments associated with
-    EXPECTED
-
-    result = flush_left text
-
-    assert_equal expected, result
-    assert_equal Encoding::US_ASCII, result.encoding
-  end
-
-  def test_markup_string
-    out = markup('hi').gsub("\n", '')
-
-    assert_equal '<p>hi</p>', out
-  end
-
-  def test_markup_comment
-    out = markup(comment('hi')).gsub("\n", '')
-
-    assert_equal '<p>hi</p>', out
-  end
-
-  def test_normalize_comment_hash
-    text = <<-TEXT
-##
-# we don't worry too much.
-#
-# The comments associated with
-    TEXT
-
-    expected = <<-EXPECTED.rstrip
-we don't worry too much.
-
-The comments associated with
-    EXPECTED
-
-    @language = :ruby
-
-    assert_equal expected, normalize_comment(text)
-  end
-
-  def test_normalize_comment_stars_single_space
-    text = <<-TEXT
-/*
- * we don't worry too much.
- *
- * The comments associated with
- */
-    TEXT
-
-    expected = <<-EXPECTED.rstrip
-we don't worry too much.
-
-The comments associated with
-    EXPECTED
-
-    @language = :c
-
-    assert_equal expected, normalize_comment(text)
-  end
-
-  def test_normalize_comment_stars_single_double_space
-    text = <<-TEXT
-/*
- *  we don't worry too much.
- *
- *  The comments associated with
- */
-    TEXT
-
-    expected = <<-EXPECTED.rstrip
-we don't worry too much.
-
-The comments associated with
-    EXPECTED
-
-    @language = :c
-
-    assert_equal expected, normalize_comment(text)
-  end
-
-  def test_parse
-    assert_kind_of RDoc::Markup::Document, parse('hi')
-  end
-
-  def test_parse_comment
-    expected = RDoc::Markup::Document.new
-    expected.file = @top_level
-
-    c = comment ''
-    parsed = parse c
-
-    assert_equal expected, parsed
-    assert_same parsed, parse(c)
-  end
-
-  def test_parse_document
-    assert_equal RDoc::Markup::Document.new, parse(RDoc::Markup::Document.new)
-  end
-
-  def test_parse_empty
-    assert_equal RDoc::Markup::Document.new, parse('')
-  end
-
-  def test_parse_empty_newline
-    @language = :ruby
-
-    assert_equal RDoc::Markup::Document.new, parse("#\n")
-  end
-
-  def test_parse_format_markdown
-    expected =
-      @RM::Document.new(
-        @RM::Paragraph.new('it _works_'))
-
-    parsed = parse 'it *works*', 'markdown'
-
-    assert_equal expected, parsed
-  end
-
-  def test_parse_format_rd
-    expected =
-      @RM::Document.new(
-        @RM::Paragraph.new('it <em>works</em>'))
-
-    parsed = parse 'it ((*works*))', 'rd'
-
-    assert_equal expected, parsed
-  end
-
-  def test_parse_format_tomdoc
-    code = verb('1 + 1')
-    code.format = :ruby
-
-    expected =
-      doc(
-        para('It does a thing'),
-        blank_line,
-        head(3, 'Examples'),
-        blank_line,
-        code)
-
-    text = <<-TOMDOC
-It does a thing
-
-Examples
-
-  1 + 1
-    TOMDOC
-
-    parsed = parse text, 'tomdoc'
-
-    assert_equal expected, parsed
-  end
-
-  def test_parse_newline
-    assert_equal RDoc::Markup::Document.new, parse("\n")
-  end
-
-  def test_snippet
-    text = <<-TEXT
-This is one-hundred characters or more of text in a single paragraph.  This
-paragraph will be cut off some point after the one-hundredth character.
-    TEXT
-
-    expected = <<-EXPECTED
-<p>This is one-hundred characters or more of text in a single paragraph.  This paragraph will be cut off …
-    EXPECTED
-
-    assert_equal expected, snippet(text)
-  end
-
-  def test_snippet_comment
-    c = comment 'This is a comment'
-
-    assert_equal "<p>This is a comment\n", snippet(c)
-  end
-
-  def test_snippet_short
-    text = 'This is a comment'
-
-    assert_equal "<p>#{text}\n", snippet(text)
-  end
-
-  def test_strip_hashes
-    text = <<-TEXT
-##
-# we don't worry too much.
-#
-# The comments associated with
-    TEXT
-
-    expected = <<-EXPECTED
-
-  we don't worry too much.
-
-  The comments associated with
-    EXPECTED
-
-    assert_equal expected, strip_hashes(text)
-  end
-
-  def test_strip_hashes_encoding
-    text = <<-TEXT
-##
-# we don't worry too much.
-#
-# The comments associated with
-    TEXT
-
-    text = RDoc::Encoding.change_encoding text, Encoding::CP852
-
-    expected = <<-EXPECTED
-
-  we don't worry too much.
-
-  The comments associated with
-    EXPECTED
-
-    stripped = strip_hashes text
-
-    assert_equal expected, stripped
-    assert_equal Encoding::CP852, stripped.encoding
-  end
-
-  def test_strip_newlines
-    assert_equal ' ',  strip_newlines("\n \n")
-
-    assert_equal 'hi', strip_newlines("\n\nhi")
-
-    assert_equal 'hi', strip_newlines(    "hi\n\n")
-
-    assert_equal 'hi', strip_newlines("\n\nhi\n\n")
-  end
-
-  def test_strip_newlines_encoding
-    assert_equal Encoding::UTF_8, ''.encoding, 'Encoding sanity check'
-
-    text = " \n"
-    text = RDoc::Encoding.change_encoding text, Encoding::US_ASCII
-
-    stripped = strip_newlines text
-
-    assert_equal ' ', stripped
-
-    assert_equal Encoding::US_ASCII, stripped.encoding
-  end
-
-  def test_strip_stars
-    text = <<-TEXT
-/*
- * * we don't worry too much.
- *
- * The comments associated with
- */
-    TEXT
-
-    expected = <<-EXPECTED
-
-   * we don't worry too much.
-
-   The comments associated with
-    EXPECTED
-
-    assert_equal expected, strip_stars(text)
-  end
-
-  def test_strip_stars_document_method
-    text = <<-TEXT
-/*
- * Document-method: Zlib::GzipFile#mtime=
- *
- * A comment
- */
-    TEXT
-
-    expected = <<-EXPECTED
-
-   A comment
-    EXPECTED
-
-    assert_equal expected, strip_stars(text)
-  end
-
-  def test_strip_stars_document_method_special
-    text = <<-TEXT
-/*
- * Document-method: Zlib::GzipFile#mtime=
- * Document-method: []
- * Document-method: `
- * Document-method: |
- * Document-method: &
- * Document-method: <=>
- * Document-method: =~
- * Document-method: +
- * Document-method: -
- * Document-method: +@
- *
- * A comment
- */
-    TEXT
-
-    expected = <<-EXPECTED
-
-   A comment
-    EXPECTED
-
-    assert_equal expected, strip_stars(text)
-  end
-
-  def test_strip_stars_encoding
-    text = <<-TEXT
-/*
- * * we don't worry too much.
- *
- * The comments associated with
- */
-    TEXT
-
-    text = RDoc::Encoding.change_encoding text, Encoding::CP852
-
-    expected = <<-EXPECTED
-
-   * we don't worry too much.
-
-   The comments associated with
-    EXPECTED
-
-    result = strip_stars text
-
-    assert_equal expected, result
-    assert_equal Encoding::CP852, result.encoding
-  end
-
-  def test_strip_stars_encoding2
-    text = <<-TEXT
-/*
- * * we don't worry too much.
- *
- * The comments associated with
- */
-    TEXT
-
-    text = RDoc::Encoding.change_encoding text, Encoding::BINARY
-
-    expected = <<-EXPECTED
-
-   * we don't worry too much.
-
-   The comments associated with
-    EXPECTED
-
-    result = strip_stars text
-
-    assert_equal expected, result
-    assert_equal Encoding::BINARY, result.encoding
-  end
-
-  def test_strip_stars_no_stars
-    text = <<-TEXT
-* we don't worry too much.
-
-The comments associated with
-
-    TEXT
-
-    expected = <<-EXPECTED
-* we don't worry too much.
-
-The comments associated with
-
-    EXPECTED
-
-    assert_equal expected, strip_stars(text)
-  end
-
-  def test_to_html_apostrophe
-    assert_equal '‘a', to_html("'a")
-    assert_equal 'a’', to_html("a'")
-
-    assert_equal '‘a’ ‘', to_html("'a' '")
-  end
-
-  def test_to_html_apostrophe_entity
-    assert_equal '‘a', to_html("'a")
-    assert_equal 'a’', to_html("a'")
-
-    assert_equal '‘a’ ‘', to_html("'a' '")
-  end
-
-  def test_to_html_backslash
-    assert_equal 'S', to_html('\\S')
-  end
-
-  def test_to_html_br
-    assert_equal '<br>', to_html('<br>')
-  end
-
-  def test_to_html_copyright
-    assert_equal '©', to_html('(c)')
-    assert_equal '©', to_html('(C)')
-  end
-
-  def test_to_html_dash
-    assert_equal '-',  to_html('-')
-    assert_equal '–',  to_html('--')
-    assert_equal '—',  to_html('---')
-    assert_equal '—-', to_html('----')
-  end
-
-  def test_to_html_double_backtick
-    assert_equal '“a',  to_html('``a')
-    assert_equal '“a“', to_html('``a``')
-    assert_equal '“a”', to_html("``a''")
-  end
-
-  def test_to_html_double_quote
-    assert_equal '“a',  to_html('"a')
-    assert_equal '“a”', to_html('"a"')
-  end
-
-  def test_to_html_double_quote_quot
-    assert_equal '“a',  to_html('"a')
-    assert_equal '“a”', to_html('"a"')
-  end
-
-  def test_to_html_double_tick
-    assert_equal '”a',        to_html("''a")
-    assert_equal '”a”', to_html("''a''")
-  end
-
-  def test_to_html_ellipsis
-    assert_equal '..', to_html('..')
-    assert_equal '…',  to_html('...')
-    assert_equal '.…', to_html('....')
-  end
-
-  def test_to_html_encoding
-    s = '...(c)'.encode Encoding::Shift_JIS
-
-    html = to_html s
-
-    assert_equal Encoding::Shift_JIS, html.encoding
-
-    expected = '…(c)'.encode Encoding::Shift_JIS
-
-    assert_equal expected, html
-  end
-
-  def test_to_html_html_tag
-    assert_equal '<a href="http://example">hi’s</a>',
-                 to_html('<a href="http://example">hi\'s</a>')
-  end
-
-  def test_to_html_registered_trademark
-    assert_equal '®', to_html('(r)')
-    assert_equal '®', to_html('(R)')
-  end
-
-  def test_to_html_tt_tag
-    assert_equal '<tt>hi\'s</tt>',   to_html('<tt>hi\'s</tt>')
-    assert_equal '<tt>hi\\\'s</tt>', to_html('<tt>hi\\\\\'s</tt>')
-  end
-
-  def test_to_html_tt_tag_mismatch
-    _, err = verbose_capture_output do
-      assert_equal '<tt>hi', to_html('<tt>hi')
-    end
-
-    assert_equal "mismatched <tt> tag\n", err
-  end
-
-  def formatter
-    RDoc::Markup::ToHtml.new @options
-  end
-
-  def options
-    @options
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc/rdoc_token_stream_test.rb b/test/mri/rdoc/rdoc/rdoc_token_stream_test.rb
deleted file mode 100644
index a5f1930daa6..00000000000
--- a/test/mri/rdoc/rdoc/rdoc_token_stream_test.rb
+++ /dev/null
@@ -1,109 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocTokenStreamTest < RDoc::TestCase
-
-  def test_class_to_html
-    tokens = [
-      { :line_no => 0, :char_no => 0, :kind => :on_const, :text => 'CONSTANT' },
-      { :line_no => 0, :char_no => 0, :kind => :on_kw, :text => 'KW' },
-      { :line_no => 0, :char_no => 0, :kind => :on_ivar, :text => 'IVAR' },
-      { :line_no => 0, :char_no => 0, :kind => :on_op, :text => 'Op' },
-      { :line_no => 0, :char_no => 0, :kind => :on_ident, :text => 'Id' },
-      { :line_no => 0, :char_no => 0, :kind => :on_backref, :text => 'Node' },
-      { :line_no => 0, :char_no => 0, :kind => :on_comment, :text => 'COMMENT' },
-      { :line_no => 0, :char_no => 0, :kind => :on_regexp, :text => 'REGEXP' },
-      { :line_no => 0, :char_no => 0, :kind => :on_tstring, :text => 'STRING' },
-      { :line_no => 0, :char_no => 0, :kind => :on_int, :text => 'Val' },
-      { :line_no => 0, :char_no => 0, :kind => :on_unknown, :text => '\\' }
-    ]
-
-    expected = [
-      '<span class="ruby-constant">CONSTANT</span>',
-      '<span class="ruby-keyword">KW</span>',
-      '<span class="ruby-ivar">IVAR</span>',
-      '<span class="ruby-operator">Op</span>',
-      '<span class="ruby-identifier">Id</span>',
-      '<span class="ruby-node">Node</span>',
-      '<span class="ruby-comment">COMMENT</span>',
-      '<span class="ruby-regexp">REGEXP</span>',
-      '<span class="ruby-string">STRING</span>',
-      '<span class="ruby-value">Val</span>',
-      '\\'
-    ].join
-
-    assert_equal expected, RDoc::TokenStream.to_html(tokens)
-  end
-
-  def test_class_to_html_empty
-    assert_equal '', RDoc::TokenStream.to_html([])
-  end
-
-  def test_add_tokens
-    foo = Class.new do
-      include RDoc::TokenStream
-    end.new
-    foo.collect_tokens
-    foo.add_tokens([:token])
-    assert_equal [:token], foo.token_stream
-  end
-
-  def test_add_token
-    foo = Class.new do
-      include RDoc::TokenStream
-    end.new
-    foo.collect_tokens
-    foo.add_token(:token)
-    assert_equal [:token], foo.token_stream
-  end
-
-  def test_collect_tokens
-    foo = Class.new do
-      include RDoc::TokenStream
-    end.new
-    foo.collect_tokens
-    assert_equal [], foo.token_stream
-  end
-
-  def test_pop_token
-    foo = Class.new do
-      include RDoc::TokenStream
-    end.new
-    foo.collect_tokens
-    foo.add_token(:token)
-    foo.pop_token
-    assert_equal [], foo.token_stream
-  end
-
-  def test_token_stream
-    foo = Class.new do
-      include RDoc::TokenStream
-    end.new
-    assert_equal nil, foo.token_stream
-  end
-
-  def test_tokens_to_s
-    foo = Class.new do
-      include RDoc::TokenStream
-
-      def initialize
-        @token_stream = [
-          { line_no: 0, char_no: 0, kind: :on_ident,   text: "foo" },
-          { line_no: 0, char_no: 0, kind: :on_sp,      text: " " },
-          { line_no: 0, char_no: 0, kind: :on_tstring, text: "'bar'" },
-        ]
-      end
-    end.new
-
-    assert_equal "foo 'bar'", foo.tokens_to_s
-
-    foo = Class.new do
-      include RDoc::TokenStream
-
-      def initialize
-        @token_stream = nil
-      end
-    end.new
-    assert_equal "", foo.tokens_to_s
-  end
-end
diff --git a/test/mri/rdoc/rdoc/rdoc_tom_doc_test.rb b/test/mri/rdoc/rdoc/rdoc_tom_doc_test.rb
deleted file mode 100644
index 941d027f243..00000000000
--- a/test/mri/rdoc/rdoc/rdoc_tom_doc_test.rb
+++ /dev/null
@@ -1,579 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocTomDocTest < RDoc::TestCase
-
-  def setup
-    super
-
-    @top_level = @store.add_file 'file.rb'
-
-    @TD = RDoc::TomDoc
-    @td = @TD.new
-  end
-
-  def test_class_add_post_processor
-    RDoc::TomDoc.add_post_processor
-
-    pp = RDoc::Markup::PreProcess.new __FILE__, []
-
-    text = "# Public: Do some stuff\n"
-
-    comment = RDoc::Comment.new text, nil
-    comment.format = 'tomdoc'
-
-    parent = RDoc::Context.new
-
-    pp.handle comment, parent
-
-    method = parent.add_method RDoc::AnyMethod.new(nil, 'm')
-
-    assert_equal 'Public', method.section.title
-    assert_equal "# Do some stuff\n", comment.text
-  end
-
-  def test_class_signature
-    c = comment <<-COMMENT
-Signature
-
-  method_<here>(args)
-
-here - something
-    COMMENT
-    c.format = 'tomdoc'
-
-    signature = @TD.signature c
-
-    assert_equal "method_<here>(args)\n", signature
-  end
-
-  def test_class_signature_no_space
-    c = comment <<-COMMENT
-Signature
-  method_<here>(args)
-
-here - something
-    COMMENT
-    c.format = 'tomdoc'
-
-    signature = @TD.signature c
-
-    assert_equal "method_<here>(args)\n", signature
-
-    expected =
-      doc(
-        head(3, 'Signature'),
-        list(:NOTE,
-          item(%w[here],
-            para('something'))))
-    expected.file = @top_level
-
-    assert_equal expected, c.parse
-  end
-
-  def test_class_signature_none
-    c = comment ''
-    c.format = 'tomdoc'
-
-    assert_nil @TD.signature c
-  end
-
-  def test_class_rdoc
-    c = comment <<-COMMENT
-=== Signature
-
-  method_<here>(args)
-
-here - something
-    COMMENT
-    c.format = 'rdoc'
-
-    signature = @TD.signature c
-
-    assert_nil signature
-  end
-
-  def test_class_signature_two_space
-    c = comment <<-COMMENT
-Signature
-
-
-  method_<here>(args)
-
-here - something
-    COMMENT
-    c.format = 'tomdoc'
-
-    signature = @TD.signature c
-
-    assert_equal "method_<here>(args)\n", signature
-
-    expected =
-      doc(
-        head(3, 'Signature'),
-        list(:NOTE,
-          item(%w[here],
-            para('something'))))
-    expected.file = @top_level
-
-    assert_equal expected, c.parse
-  end
-
-  def test_parse_paragraph
-    text = "Public: Do some stuff\n"
-
-    expected =
-      @RM::Document.new(
-        @RM::Paragraph.new('Do some stuff'))
-
-    assert_equal expected, @TD.parse(text)
-  end
-
-  def test_parse_multiline_paragraph
-    text = "Public: Do some stuff\n"
-    text += "On a new line\n"
-
-    expected =
-      doc(
-        para('Do some stuff', ' ', 'On a new line'))
-
-    assert_equal expected, @TD.parse(text)
-  end
-
-  def test_parse_arguments
-    text = <<-TEXT
-Create new Arg object.
-
-name        - name of argument
-description - arguments description
-    TEXT
-
-    expected =
-      doc(
-        para('Create new Arg object.'),
-        blank_line,
-        list(:NOTE,
-          item(%w[name],
-            para('name of argument')),
-          item(%w[description],
-            para('arguments description'))))
-
-    assert_equal expected, @TD.parse(text)
-  end
-
-  def test_parse_arguments_array
-    text = <<-TEXT
-Create new Arg object.
-
-names[] - names of arguments
-    TEXT
-
-    expected =
-      doc(
-        para('Create new Arg object.'),
-        blank_line,
-        list(:NOTE,
-          item(%w[names[]],
-            para('names of arguments'))))
-
-    assert_equal expected, @TD.parse(text)
-  end
-
-  def test_parse_arguments_multiline
-    text = <<-TEXT
-Do some stuff
-
-foo - A comment goes here
-  and is more than one line
-    TEXT
-
-    expected =
-      doc(
-        para('Do some stuff'),
-        blank_line,
-        list(:NOTE,
-          item(%w[foo],
-            para('A comment goes here', ' ', 'and is more than one line'))))
-
-    assert_equal expected, @TD.parse(text)
-  end
-
-  def test_parse_arguments_nested
-    text = <<-TEXT
-Do some stuff
-
-foo - A comment goes here
-      :bar - bar documentation
-    TEXT
-
-    expected =
-      doc(
-        para('Do some stuff'),
-        blank_line,
-        list(:NOTE,
-          item(%w[foo],
-            para('A comment goes here'),
-            list(:NOTE,
-              item(%w[:bar],
-                para('bar documentation'))))))
-
-    assert_equal expected, @TD.parse(text)
-  end
-
-  def test_parse_examples
-    text = <<-TEXT
-Do some stuff
-
-Examples
-
-  1 + 1
-    TEXT
-
-    code = verb("1 + 1\n")
-    code.format = :ruby
-
-    expected =
-      doc(
-        para('Do some stuff'),
-        blank_line,
-        head(3, 'Examples'),
-        blank_line,
-        code)
-
-    document = @TD.parse(text)
-    assert_equal expected, document
-    assert document.parts.last.ruby?
-  end
-
-  def test_parse_examples_signature
-    text = <<-TEXT
-Do some stuff
-
-Examples
-
-  1 + 1
-
-Signature
-
-  foo(args)
-    TEXT
-
-    code1 = verb("1 + 1\n")
-    code1.format = :ruby
-
-    code2 = verb("foo(args)\n")
-
-    expected =
-      doc(
-        para('Do some stuff'),
-        blank_line,
-        head(3, 'Examples'),
-        blank_line,
-        code1,
-        head(3, 'Signature'),
-        blank_line,
-        code2)
-
-    document = @TD.parse text
-
-    assert_equal expected, document
-  end
-
-  def test_parse_returns
-    text = <<-TEXT
-Do some stuff
-
-Returns a thing
-
-Returns another thing
-    TEXT
-
-    expected =
-      doc(
-        para('Do some stuff'),
-        blank_line,
-        head(3, 'Returns'),
-        blank_line,
-        para('Returns a thing'),
-        blank_line,
-        para('Returns another thing'))
-
-    assert_equal expected, @TD.parse(text)
-  end
-
-  def test_parse_returns_with_raises
-    text = <<-TEXT
-Do some stuff
-
-Returns a thing
-Raises ArgumentError when stuff
-Raises StandardError when stuff
-    TEXT
-    expected =
-      doc(
-        para('Do some stuff'),
-        blank_line,
-        head(3, 'Returns'),
-        blank_line,
-        para('Returns a thing'),
-        para('Raises ArgumentError when stuff'),
-        para('Raises StandardError when stuff'))
-
-    assert_equal expected, @TD.parse(text)
-  end
-
-  def test_parse_raises_without_returns
-    text = <<-TEXT
-Do some stuff
-
-Raises ArgumentError when stuff
-    TEXT
-    expected =
-      doc(
-        para('Do some stuff'),
-        blank_line,
-        head(3, 'Returns'),
-        blank_line,
-        para('Raises ArgumentError when stuff'))
-
-    assert_equal expected, @TD.parse(text)
-  end
-
-  def test_parse_returns_multiline
-    text = <<-TEXT
-Do some stuff
-
-Returns a thing
-  that is multiline
-    TEXT
-
-    expected =
-      doc(
-        para('Do some stuff'),
-        blank_line,
-        head(3, 'Returns'),
-        blank_line,
-        para('Returns a thing', ' ', 'that is multiline'))
-
-    assert_equal expected, @TD.parse(text)
-  end
-
-  def test_parse_returns_multiline_and_raises
-    text = <<-TEXT
-Do some stuff
-
-Returns a thing
-  that is multiline
-Raises ArgumentError
-    TEXT
-
-    expected =
-      doc(
-        para('Do some stuff'),
-        blank_line,
-        head(3, 'Returns'),
-        blank_line,
-        para('Returns a thing', ' ', 'that is multiline'),
-        para('Raises ArgumentError'))
-
-    assert_equal expected, @TD.parse(text)
-  end
-
-  def test_parse_signature
-    text = <<-TEXT
-Do some stuff
-
-Signature
-
-  some_method(args)
-    TEXT
-
-    expected =
-      @RM::Document.new(
-        @RM::Paragraph.new('Do some stuff'),
-        @RM::BlankLine.new,
-        @RM::Heading.new(3, 'Signature'),
-        @RM::BlankLine.new,
-        @RM::Verbatim.new("some_method(args)\n"))
-
-    assert_equal expected, @TD.parse(text)
-  end
-
-  def test_tokenize_paragraph
-    @td.tokenize "Public: Do some stuff\n"
-
-    expected = [
-      [:TEXT,    "Do some stuff",  0, 0],
-      [:NEWLINE, "\n",            13, 0],
-    ]
-
-    assert_equal expected, @td.tokens
-  end
-
-  def test_tokenize_multiline_paragraph
-    text = "Public: Do some stuff\n"
-    text += "On a new line\n"
-
-    @td.tokenize text
-
-    expected = [
-      [:TEXT,     "Do some stuff",   0, 0],
-      [:NEWLINE,  "\n",             13, 0],
-      [:TEXT,     "On a new line",   0, 1],
-      [:NEWLINE,  "\n",             13, 1]
-    ]
-
-    assert_equal expected, @td.tokens
-  end
-
-  def test_tokenize_arguments
-    @td.tokenize <<-TEXT
-Create new Arg object.
-
-name        - name of argument
-description - arguments description
-    TEXT
-
-    expected = [
-      [:TEXT,    "Create new Arg object.",  0, 0],
-      [:NEWLINE, "\n",                     22, 0],
-      [:NEWLINE, "\n",                      0, 1],
-      [:NOTE,    "name",                    0, 2],
-      [:TEXT,    "name of argument",       14, 2],
-      [:NEWLINE, "\n",                     30, 2],
-      [:NOTE,    "description",             0, 3],
-      [:TEXT,    "arguments description",  14, 3],
-      [:NEWLINE, "\n",                     35, 3],
-    ]
-
-    assert_equal expected, @td.tokens
-  end
-
-  def test_tokenize_arguments_array
-    @td.tokenize <<-TEXT
-Create new Arg object.
-
-names[stuff] - names of arguments
-    TEXT
-
-    expected = [
-      [:TEXT,    "Create new Arg object.",  0, 0],
-      [:NEWLINE, "\n",                     22, 0],
-      [:NEWLINE, "\n",                      0, 1],
-      [:NOTE,    "names[stuff]",            0, 2],
-      [:TEXT,    "names of arguments",     15, 2],
-      [:NEWLINE, "\n",                     33, 2],
-    ]
-
-    assert_equal expected, @td.tokens
-  end
-
-  def test_tokenize_arguments_multiline
-    @td.tokenize <<-TEXT
-Do some stuff
-
-foo - A comment goes here
-  and is more than one line
-    TEXT
-
-    expected = [
-      [:TEXT,    "Do some stuff",              0, 0],
-      [:NEWLINE, "\n",                        13, 0],
-      [:NEWLINE, "\n",                         0, 1],
-      [:NOTE,    "foo",                        0, 2],
-      [:TEXT,    "A comment goes here",        6, 2],
-      [:NEWLINE, "\n",                        25, 2],
-      [:TEXT,    "and is more than one line",  2, 3],
-      [:NEWLINE, "\n",                        27, 3],
-    ]
-
-    assert_equal expected, @td.tokens
-  end
-
-  def test_tokenize_arguments_nested
-    @td.tokenize <<-TEXT
-Do some stuff
-
-foo - A comment goes here
-      :bar - bar documentation
-    TEXT
-
-    expected = [
-      [:TEXT,    "Do some stuff",              0, 0],
-      [:NEWLINE, "\n",                        13, 0],
-      [:NEWLINE, "\n",                         0, 1],
-      [:NOTE,    "foo",                        0, 2],
-      [:TEXT,    "A comment goes here",        6, 2],
-      [:NEWLINE, "\n",                        25, 2],
-      [:NOTE,    ":bar",                       6, 3],
-      [:TEXT,    "bar documentation",         13, 3],
-      [:NEWLINE, "\n",                        30, 3],
-    ]
-
-    assert_equal expected, @td.tokens
-  end
-
-  def test_tokenize_examples
-    @td.tokenize <<-TEXT
-Do some stuff
-
-Examples
-
-  1 + 1
-    TEXT
-
-    expected = [
-      [:TEXT,    "Do some stuff",  0, 0],
-      [:NEWLINE, "\n",            13, 0],
-      [:NEWLINE, "\n",             0, 1],
-      [:HEADER,  3,                0, 2],
-      [:TEXT,    "Examples",       0, 2],
-      [:NEWLINE, "\n",             8, 2],
-      [:NEWLINE, "\n",             0, 3],
-      [:TEXT,    "1 + 1",          2, 4],
-      [:NEWLINE, "\n",             7, 4],
-    ]
-
-    assert_equal expected, @td.tokens
-  end
-
-  def test_tokenize_returns
-    @td.tokenize <<-TEXT
-Do some stuff
-
-Returns a thing
-    TEXT
-
-    expected = [
-      [:TEXT,    "Do some stuff",    0, 0],
-      [:NEWLINE, "\n",              13, 0],
-      [:NEWLINE, "\n",               0, 1],
-      [:TEXT,    "Returns a thing",  0, 2],
-      [:NEWLINE, "\n",              15, 2],
-    ]
-
-    assert_equal expected, @td.tokens
-  end
-
-  def test_tokenize_returns_multiline
-    @td.tokenize <<-TEXT
-Do some stuff
-
-Returns a thing
-  that is multiline
-    TEXT
-
-    expected = [
-      [:TEXT,    "Do some stuff",      0, 0],
-      [:NEWLINE, "\n",                13, 0],
-      [:NEWLINE, "\n",                 0, 1],
-      [:TEXT,    "Returns a thing",    0, 2],
-      [:NEWLINE, "\n",                15, 2],
-      [:TEXT,    "that is multiline",  2, 3],
-      [:NEWLINE, "\n",                19, 3],
-    ]
-
-    assert_equal expected, @td.tokens
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc/rdoc_top_level_test.rb b/test/mri/rdoc/rdoc/rdoc_top_level_test.rb
deleted file mode 100644
index 385860517b3..00000000000
--- a/test/mri/rdoc/rdoc/rdoc_top_level_test.rb
+++ /dev/null
@@ -1,289 +0,0 @@
-# frozen_string_literal: true
-require_relative 'xref_test_case'
-
-class RDocTopLevelTest < XrefTestCase
-
-  def setup
-    super
-
-    @top_level = @store.add_file 'path/top_level.rb'
-    @top_level.parser = RDoc::Parser::Ruby
-  end
-
-  def test_initialize
-    t = RDoc::TopLevel.new 'path/file.rb'
-
-    assert_equal 'path/file.rb', t.absolute_name
-    assert_equal 'path/file.rb', t.relative_name
-  end
-
-  def test_initialize_relative
-    t = RDoc::TopLevel.new 'path/file.rb', 'file.rb'
-
-    assert_equal 'path/file.rb', t.absolute_name
-    assert_equal 'file.rb',      t.relative_name
-  end
-
-  def test_add_alias
-    a = RDoc::Alias.new nil, 'old', 'new', nil
-    @top_level.add_alias a
-
-    object = @store.find_class_named 'Object'
-    expected = { '#old' => [a] }
-    assert_equal expected, object.unmatched_alias_lists
-    assert_includes object.in_files, @top_level
-  end
-
-  def test_add_alias_nodoc
-    @top_level.document_self = false
-
-    a = RDoc::Alias.new nil, 'old', 'new', nil
-    @top_level.add_alias a
-
-    object = @store.find_class_named('Object')
-    assert_empty object.unmatched_alias_lists
-    assert_includes object.in_files, @top_level
-  end
-
-  def test_add_constant
-    const = RDoc::Constant.new 'C', nil, nil
-    @top_level.add_constant const
-
-    object = @store.find_class_named 'Object'
-    assert_equal [const], object.constants
-    assert_includes object.in_files, @top_level
-  end
-
-  def test_add_constant_nodoc
-    @top_level.document_self = false
-
-    const = RDoc::Constant.new 'C', nil, nil
-    @top_level.add_constant const
-
-    object = @store.find_class_named 'Object'
-    assert_empty object.constants
-    assert_includes object.in_files, @top_level
-  end
-
-  def test_add_include
-    include = RDoc::Include.new 'C', nil
-    @top_level.add_include include
-
-    object = @store.find_class_named 'Object'
-    assert_equal [include], object.includes
-    assert_includes object.in_files, @top_level
-  end
-
-  def test_add_include_nodoc
-    @top_level.document_self = false
-
-    include = RDoc::Include.new 'C', nil
-    @top_level.add_include include
-
-    object = @store.find_class_named('Object')
-    assert_empty object.includes
-    assert_includes object.in_files, @top_level
-  end
-
-  def test_add_method
-    method = RDoc::AnyMethod.new nil, 'm'
-    @top_level.add_method method
-
-    object = @store.find_class_named 'Object'
-    assert_equal [@c10_method, @c11_method, method], object.method_list
-    assert_includes object.in_files, @top_level
-  end
-
-  def test_add_method_stopdoc
-    @top_level.document_self = false
-
-    method = RDoc::AnyMethod.new nil, 'm'
-    @top_level.add_method method
-
-    object = @store.find_class_named('Object')
-    assert_equal [@c10_method, @c11_method], object.method_list
-    assert_includes object.in_files, @top_level
-  end
-
-  def test_base_name
-    assert_equal 'top_level.rb', @top_level.base_name
-  end
-
-  def test_display_eh
-    refute @top_level.display?
-
-    page = @store.add_file 'README.txt'
-    page.parser = RDoc::Parser::Simple
-
-    assert page.display?
-  end
-
-  def test_eql_eh
-    top_level2 = @store.add_file 'path/top_level.rb'
-    other_level = @store.add_file 'path/other_level.rb'
-
-    assert_operator @top_level, :eql?, top_level2
-
-    refute_operator other_level, :eql?, @top_level
-  end
-
-  def test_equals2
-    top_level2 = @store.add_file 'path/top_level.rb'
-    other_level = @store.add_file 'path/other_level.rb'
-
-    assert_equal @top_level, top_level2
-
-    refute_equal other_level, @top_level
-  end
-
-  def test_find_class_or_module
-    assert_equal @c1,    @xref_data.find_class_or_module('C1')
-    assert_equal @c2_c3, @xref_data.find_class_or_module('C2::C3')
-    assert_equal @c4,    @xref_data.find_class_or_module('C4')
-    assert_equal @m1_m2, @xref_data.find_class_or_module('M1::M2')
-  end
-
-  def test_full_name
-    assert_equal 'path/top_level.rb', @top_level.full_name
-  end
-
-  def test_hash
-    tl2 = @store.add_file 'path/top_level.rb'
-    tl3 = @store.add_file 'other/top_level.rb'
-
-    assert_equal @top_level.hash, tl2.hash
-    refute_equal @top_level.hash, tl3.hash
-  end
-
-  def test_http_url
-    assert_equal 'path/top_level_rb.html', @top_level.http_url
-
-    other_level = @store.add_file 'path.other/level.rb'
-    assert_equal 'path_other/level_rb.html', other_level.http_url
-  end
-
-  def test_path
-    assert_equal 'path/top_level_rb.html', @top_level.path
-
-    @options.file_path_prefix = 'file'
-    assert_equal 'file/path/top_level_rb.html', @top_level.path
-  end
-
-  def test_marshal_dump
-    page = @store.add_file 'README.txt'
-    page.parser = RDoc::Parser::Simple
-    page.comment = RDoc::Comment.new 'This is a page', page
-
-    loaded = Marshal.load Marshal.dump page
-
-    document = RDoc::Markup::Document.new(
-                 RDoc::Markup::Paragraph.new('This is a page'))
-    document.file = loaded
-
-    assert_equal page, loaded
-
-    assert_equal 'README.txt', loaded.absolute_name
-    assert_equal 'README.txt', loaded.relative_name
-
-    assert_equal RDoc::Parser::Simple, loaded.parser
-
-    assert_equal document, loaded.comment.parse
-  end
-
-  def test_marshal_load_version_0
-    loaded = Marshal.load "\x04\bU:\x13RDoc::TopLevel" +
-                          "[\ti\x00I\"\x0FREADME.txt\x06:\x06EF" +
-                          "c\x19RDoc::Parser::Simple" +
-                          "o:\eRDoc::Markup::Document\a:\v@parts" +
-                          "[\x06o:\x1CRDoc::Markup::Paragraph\x06;\b" +
-                          "[\x06I\"\x13This is a page\x06;\x06F:\n@file@\a"
-
-    document = RDoc::Markup::Document.new(
-                 RDoc::Markup::Paragraph.new('This is a page'))
-    document.file = loaded
-
-    assert_equal 'README.txt', loaded.absolute_name
-    assert_equal 'README.txt', loaded.relative_name
-
-    assert_equal RDoc::Parser::Simple, loaded.parser
-
-    assert_equal document, loaded.comment.parse
-
-    assert loaded.display?
-  end
-
-  def test_name
-    assert_equal 'top_level.rb', @top_level.name
-  end
-
-  def test_page_name
-    assert_equal 'top_level', @top_level.page_name
-
-    tl = @store.add_file 'README.ja'
-
-    assert_equal 'README.ja', tl.page_name
-
-    tl = @store.add_file 'Rakefile'
-
-    assert_equal 'Rakefile', tl.page_name
-  end
-
-  def test_page_name_trim_extension
-    tl = @store.add_file 'README.ja.rdoc'
-
-    assert_equal 'README.ja', tl.page_name
-
-    tl = @store.add_file 'README.ja.md'
-
-    assert_equal 'README.ja', tl.page_name
-
-    tl = @store.add_file 'README.txt'
-
-    assert_equal 'README', tl.page_name
-  end
-
-  def test_search_record
-    assert_nil @xref_data.search_record
-  end
-
-  def test_search_record_page
-    page = @store.add_file 'README.txt'
-    page.parser = RDoc::Parser::Simple
-    page.comment = 'This is a comment.'
-
-    expected = [
-      'README',
-      '',
-      'README',
-      '',
-      'README_txt.html',
-      '',
-      "<p>This is a comment.\n",
-    ]
-
-    assert_equal expected, page.search_record
-  end
-
-  def test_text_eh
-    refute @xref_data.text?
-
-    rd = @store.add_file 'rd_format.rd'
-    rd.parser = RDoc::Parser::RD
-
-    assert rd.text?
-
-    simple = @store.add_file 'simple.txt'
-    simple.parser = RDoc::Parser::Simple
-
-    assert simple.text?
-  end
-
-  def test_text_eh_no_parser
-    refute @xref_data.text?
-
-    rd = @store.add_file 'rd_format.rd'
-
-    refute rd.text?
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc/support/formatter_test_case.rb b/test/mri/rdoc/rdoc/support/formatter_test_case.rb
deleted file mode 100644
index ae081f51880..00000000000
--- a/test/mri/rdoc/rdoc/support/formatter_test_case.rb
+++ /dev/null
@@ -1,764 +0,0 @@
-# frozen_string_literal: true
-require 'test/unit'
-
-##
-# Test case for creating new RDoc::Markup formatters.  See
-# test/test_rdoc_markup_to_*.rb for examples.
-#
-# This test case adds a variety of tests to your subclass when
-# #add_visitor_tests is called.  Most tests set up a scenario then call a
-# method you will provide to perform the assertion on the output.
-#
-# Your subclass must instantiate a visitor and assign it to <tt>@to</tt>.
-#
-# For example, test_accept_blank_line sets up a RDoc::Markup::BlockLine then
-# calls accept_blank_line on your visitor.  You are responsible for asserting
-# that the output is correct.
-#
-# Example:
-#
-#  class RDocMarkupToNewFormatTest < RDoc::Markup::FormatterTestCase
-#
-#    add_visitor_tests
-#
-#    def setup
-#      super
-#
-#      @to = RDoc::Markup::ToNewFormat.new
-#    end
-#
-#    def accept_blank_line
-#      assert_equal :junk, @to.res.join
-#    end
-#
-#    # ...
-#
-#  end
-
-class RDoc::Markup::FormatterTestCase < RDoc::TestCase
-
-  ##
-  # Call #setup when inheriting from this test case.
-  #
-  # Provides the following instance variables:
-  #
-  # +@m+::           RDoc::Markup.new
-  # +@RM+::          RDoc::Markup # to reduce typing
-  # +@bullet_list+:: @RM::List.new :BULLET, # ...
-  # +@label_list+::  @RM::List.new :LABEL, # ...
-  # +@lalpha_list+:: @RM::List.new :LALPHA, # ...
-  # +@note_list+::   @RM::List.new :NOTE, # ...
-  # +@number_list+:: @RM::List.new :NUMBER, # ...
-  # +@ualpha_list+:: @RM::List.new :UALPHA, # ...
-
-  def setup
-    super
-
-    @options = RDoc::Options.new
-
-    @m = @RM.new
-
-    @bullet_list = @RM::List.new(:BULLET,
-      @RM::ListItem.new(nil, @RM::Paragraph.new('l1')),
-      @RM::ListItem.new(nil, @RM::Paragraph.new('l2')))
-
-    @label_list = @RM::List.new(:LABEL,
-      @RM::ListItem.new('cat', @RM::Paragraph.new('cats are cool')),
-      @RM::ListItem.new('dog', @RM::Paragraph.new('dogs are cool too')))
-
-    @lalpha_list = @RM::List.new(:LALPHA,
-      @RM::ListItem.new(nil, @RM::Paragraph.new('l1')),
-      @RM::ListItem.new(nil, @RM::Paragraph.new('l2')))
-
-    @note_list = @RM::List.new(:NOTE,
-      @RM::ListItem.new('cat', @RM::Paragraph.new('cats are cool')),
-      @RM::ListItem.new('dog', @RM::Paragraph.new('dogs are cool too')))
-
-    @number_list = @RM::List.new(:NUMBER,
-      @RM::ListItem.new(nil, @RM::Paragraph.new('l1')),
-      @RM::ListItem.new(nil, @RM::Paragraph.new('l2')))
-
-    @ualpha_list = @RM::List.new(:UALPHA,
-      @RM::ListItem.new(nil, @RM::Paragraph.new('l1')),
-      @RM::ListItem.new(nil, @RM::Paragraph.new('l2')))
-  end
-
-  ##
-  # Call to add the visitor tests to your test case
-
-  def self.add_visitor_tests
-    class_eval do
-
-      ##
-      # Calls start_accepting which needs to verify startup state
-
-      def test_start_accepting
-        @to.start_accepting
-
-        start_accepting
-      end
-
-      ##
-      # Calls end_accepting on your test case which needs to call
-      # <tt>@to.end_accepting</tt> and verify document generation
-
-      def test_end_accepting
-        @to.start_accepting
-        @to.res << 'hi'
-
-        end_accepting
-      end
-
-      ##
-      # Calls accept_blank_line
-
-      def test_accept_blank_line
-        @to.start_accepting
-
-        @to.accept_blank_line @RM::BlankLine.new
-
-        accept_blank_line
-      end
-
-      ##
-      # Calls accept_block_quote
-
-      def test_accept_block_quote
-        @to.start_accepting
-
-        @to.accept_block_quote block para 'quote'
-
-        accept_block_quote
-      end
-      ##
-      # Test case that calls <tt>@to.accept_document</tt>
-
-      def test_accept_document
-        @to.start_accepting
-        @to.accept_document @RM::Document.new @RM::Paragraph.new 'hello'
-
-        accept_document
-      end
-
-      ##
-      # Calls accept_heading with a level 5 RDoc::Markup::Heading
-
-      def test_accept_heading
-        @to.start_accepting
-
-        @to.accept_heading @RM::Heading.new(5, 'Hello')
-
-        accept_heading
-      end
-
-      ##
-      # Calls accept_heading_1 with a level 1 RDoc::Markup::Heading
-
-      def test_accept_heading_1
-        @to.start_accepting
-
-        @to.accept_heading @RM::Heading.new(1, 'Hello')
-
-        accept_heading_1
-      end
-
-      ##
-      # Calls accept_heading_2 with a level 2 RDoc::Markup::Heading
-
-      def test_accept_heading_2
-        @to.start_accepting
-
-        @to.accept_heading @RM::Heading.new(2, 'Hello')
-
-        accept_heading_2
-      end
-
-      ##
-      # Calls accept_heading_3 with a level 3 RDoc::Markup::Heading
-
-      def test_accept_heading_3
-        @to.start_accepting
-
-        @to.accept_heading @RM::Heading.new(3, 'Hello')
-
-        accept_heading_3
-      end
-
-      ##
-      # Calls accept_heading_4 with a level 4 RDoc::Markup::Heading
-
-      def test_accept_heading_4
-        @to.start_accepting
-
-        @to.accept_heading @RM::Heading.new(4, 'Hello')
-
-        accept_heading_4
-      end
-
-      ##
-      # Calls accept_heading_b with a bold level 1 RDoc::Markup::Heading
-
-      def test_accept_heading_b
-        @to.start_accepting
-
-        @to.accept_heading @RM::Heading.new(1, '*Hello*')
-
-        accept_heading_b
-      end
-
-      ##
-      # Calls accept_heading_suppressed_crossref with a level 1
-      # RDoc::Markup::Heading containing a suppressed crossref
-
-      def test_accept_heading_suppressed_crossref # HACK to_html_crossref test
-        @to.start_accepting
-
-        @to.accept_heading @RM::Heading.new(1, '\\Hello')
-
-        accept_heading_suppressed_crossref
-      end
-
-      ##
-      # Calls accept_paragraph
-
-      def test_accept_paragraph
-        @to.start_accepting
-
-        @to.accept_paragraph @RM::Paragraph.new('hi')
-
-        accept_paragraph
-      end
-
-      ##
-      # Calls accept_paragraph_b with a RDoc::Markup::Paragraph containing
-      # bold words
-
-      def test_accept_paragraph_b
-        @to.start_accepting
-
-        @to.accept_paragraph @RM::Paragraph.new('reg <b>bold words</b> reg')
-
-        accept_paragraph_b
-      end
-
-      ##
-      # Calls accept_paragraph_br with a RDoc::Markup::Paragraph containing
-      # a \<br>
-
-      def test_accept_paragraph_br
-        @to.start_accepting
-
-        @to.accept_paragraph para 'one<br>two'
-
-        accept_paragraph_br
-      end
-
-      ##
-      # Calls accept_paragraph with a Paragraph containing a hard break
-
-      def test_accept_paragraph_break
-        @to.start_accepting
-
-        @to.accept_paragraph para('hello', hard_break, 'world')
-
-        accept_paragraph_break
-      end
-
-      ##
-      # Calls accept_paragraph_i with a RDoc::Markup::Paragraph containing
-      # emphasized words
-
-      def test_accept_paragraph_i
-        @to.start_accepting
-
-        @to.accept_paragraph @RM::Paragraph.new('reg <em>italic words</em> reg')
-
-        accept_paragraph_i
-      end
-
-      ##
-      # Calls accept_paragraph_plus with a RDoc::Markup::Paragraph containing
-      # teletype words
-
-      def test_accept_paragraph_plus
-        @to.start_accepting
-
-        @to.accept_paragraph @RM::Paragraph.new('reg +teletype+ reg')
-
-        accept_paragraph_plus
-      end
-
-      ##
-      # Calls accept_paragraph_star with a RDoc::Markup::Paragraph containing
-      # bold words
-
-      def test_accept_paragraph_star
-        @to.start_accepting
-
-        @to.accept_paragraph @RM::Paragraph.new('reg *bold* reg')
-
-        accept_paragraph_star
-      end
-
-      ##
-      # Calls accept_paragraph_underscore with a RDoc::Markup::Paragraph
-      # containing emphasized words
-
-      def test_accept_paragraph_underscore
-        @to.start_accepting
-
-        @to.accept_paragraph @RM::Paragraph.new('reg _italic_ reg')
-
-        accept_paragraph_underscore
-      end
-
-      ##
-      # Calls accept_verbatim with a RDoc::Markup::Verbatim
-
-      def test_accept_verbatim
-        @to.start_accepting
-
-        @to.accept_verbatim @RM::Verbatim.new("hi\n", "  world\n")
-
-        accept_verbatim
-      end
-
-      ##
-      # Calls accept_raw with a RDoc::Markup::Raw
-
-      def test_accept_raw
-        @to.start_accepting
-
-        @to.accept_raw @RM::Raw.new("<table>",
-                                    "<tr><th>Name<th>Count",
-                                    "<tr><td>a<td>1",
-                                    "<tr><td>b<td>2",
-                                    "</table>")
-
-        accept_raw
-      end
-
-      ##
-      # Calls accept_rule with a RDoc::Markup::Rule
-
-      def test_accept_rule
-        @to.start_accepting
-
-        @to.accept_rule @RM::Rule.new(4)
-
-        accept_rule
-      end
-
-      ##
-      # Calls accept_list_item_start_bullet
-
-      def test_accept_list_item_start_bullet
-        @to.start_accepting
-
-        @to.accept_list_start @bullet_list
-
-        @to.accept_list_item_start @bullet_list.items.first
-
-        accept_list_item_start_bullet
-      end
-
-      ##
-      # Calls accept_list_item_start_label
-
-      def test_accept_list_item_start_label
-        @to.start_accepting
-
-        @to.accept_list_start @label_list
-
-        @to.accept_list_item_start @label_list.items.first
-
-        accept_list_item_start_label
-      end
-
-      ##
-      # Calls accept_list_item_start_lalpha
-
-      def test_accept_list_item_start_lalpha
-        @to.start_accepting
-
-        @to.accept_list_start @lalpha_list
-
-        @to.accept_list_item_start @lalpha_list.items.first
-
-        accept_list_item_start_lalpha
-      end
-
-      ##
-      # Calls accept_list_item_start_note
-
-      def test_accept_list_item_start_note
-        @to.start_accepting
-
-        @to.accept_list_start @note_list
-
-        @to.accept_list_item_start @note_list.items.first
-
-        accept_list_item_start_note
-      end
-
-      ##
-      # Calls accept_list_item_start_note_2
-
-      def test_accept_list_item_start_note_2
-        list = list(:NOTE,
-                 item('<tt>teletype</tt>',
-                   para('teletype description')))
-
-        @to.start_accepting
-
-        list.accept @to
-
-        @to.end_accepting
-
-        accept_list_item_start_note_2
-      end
-
-      ##
-      # Calls accept_list_item_start_note_multi_description
-
-      def test_accept_list_item_start_note_multi_description
-        list = list(:NOTE,
-                 item(%w[label],
-                   para('description one')),
-                 item(nil, para('description two')))
-
-        @to.start_accepting
-
-        list.accept @to
-
-        @to.end_accepting
-
-        accept_list_item_start_note_multi_description
-      end
-
-      ##
-      # Calls accept_list_item_start_note_multi_label
-
-      def test_accept_list_item_start_note_multi_label
-        list = list(:NOTE,
-                 item(%w[one two],
-                   para('two headers')))
-
-        @to.start_accepting
-
-        list.accept @to
-
-        @to.end_accepting
-
-        accept_list_item_start_note_multi_label
-      end
-
-      ##
-      # Calls accept_list_item_start_number
-
-      def test_accept_list_item_start_number
-        @to.start_accepting
-
-        @to.accept_list_start @number_list
-
-        @to.accept_list_item_start @number_list.items.first
-
-        accept_list_item_start_number
-      end
-
-      ##
-      # Calls accept_list_item_start_ualpha
-
-      def test_accept_list_item_start_ualpha
-        @to.start_accepting
-
-        @to.accept_list_start @ualpha_list
-
-        @to.accept_list_item_start @ualpha_list.items.first
-
-        accept_list_item_start_ualpha
-      end
-
-      ##
-      # Calls accept_list_item_end_bullet
-
-      def test_accept_list_item_end_bullet
-        @to.start_accepting
-
-        @to.accept_list_start @bullet_list
-
-        @to.accept_list_item_start @bullet_list.items.first
-
-        @to.accept_list_item_end @bullet_list.items.first
-
-        accept_list_item_end_bullet
-      end
-
-      ##
-      # Calls accept_list_item_end_label
-
-      def test_accept_list_item_end_label
-        @to.start_accepting
-
-        @to.accept_list_start @label_list
-
-        @to.accept_list_item_start @label_list.items.first
-
-        @to.accept_list_item_end @label_list.items.first
-
-        accept_list_item_end_label
-      end
-
-      ##
-      # Calls accept_list_item_end_lalpha
-
-      def test_accept_list_item_end_lalpha
-        @to.start_accepting
-
-        @to.accept_list_start @lalpha_list
-
-        @to.accept_list_item_start @lalpha_list.items.first
-
-        @to.accept_list_item_end @lalpha_list.items.first
-
-        accept_list_item_end_lalpha
-      end
-
-      ##
-      # Calls accept_list_item_end_note
-
-      def test_accept_list_item_end_note
-        @to.start_accepting
-
-        @to.accept_list_start @note_list
-
-        @to.accept_list_item_start @note_list.items.first
-
-        @to.accept_list_item_end @note_list.items.first
-
-        accept_list_item_end_note
-      end
-
-      ##
-      # Calls accept_list_item_end_number
-
-      def test_accept_list_item_end_number
-        @to.start_accepting
-
-        @to.accept_list_start @number_list
-
-        @to.accept_list_item_start @number_list.items.first
-
-        @to.accept_list_item_end @number_list.items.first
-
-        accept_list_item_end_number
-      end
-
-      ##
-      # Calls accept_list_item_end_ualpha
-
-      def test_accept_list_item_end_ualpha
-        @to.start_accepting
-
-        @to.accept_list_start @ualpha_list
-
-        @to.accept_list_item_start @ualpha_list.items.first
-
-        @to.accept_list_item_end @ualpha_list.items.first
-
-        accept_list_item_end_ualpha
-      end
-
-      ##
-      # Calls accept_list_start_bullet
-
-      def test_accept_list_start_bullet
-        @to.start_accepting
-
-        @to.accept_list_start @bullet_list
-
-        accept_list_start_bullet
-      end
-
-      ##
-      # Calls accept_list_start_label
-
-      def test_accept_list_start_label
-        @to.start_accepting
-
-        @to.accept_list_start @label_list
-
-        accept_list_start_label
-      end
-
-      ##
-      # Calls accept_list_start_lalpha
-
-      def test_accept_list_start_lalpha
-        @to.start_accepting
-
-        @to.accept_list_start @lalpha_list
-
-        accept_list_start_lalpha
-      end
-
-      ##
-      # Calls accept_list_start_note
-
-      def test_accept_list_start_note
-        @to.start_accepting
-
-        @to.accept_list_start @note_list
-
-        accept_list_start_note
-      end
-
-      ##
-      # Calls accept_list_start_number
-
-      def test_accept_list_start_number
-        @to.start_accepting
-
-        @to.accept_list_start @number_list
-
-        accept_list_start_number
-      end
-
-      ##
-      # Calls accept_list_start_ualpha
-
-      def test_accept_list_start_ualpha
-        @to.start_accepting
-
-        @to.accept_list_start @ualpha_list
-
-        accept_list_start_ualpha
-      end
-
-      ##
-      # Calls accept_list_end_bullet
-
-      def test_accept_list_end_bullet
-        @to.start_accepting
-
-        @to.accept_list_start @bullet_list
-
-        @to.accept_list_end @bullet_list
-
-        accept_list_end_bullet
-      end
-
-      ##
-      # Calls accept_list_end_label
-
-      def test_accept_list_end_label
-        @to.start_accepting
-
-        @to.accept_list_start @label_list
-
-        @to.accept_list_end @label_list
-
-        accept_list_end_label
-      end
-
-      ##
-      # Calls accept_list_end_lalpha
-
-      def test_accept_list_end_lalpha
-        @to.start_accepting
-
-        @to.accept_list_start @lalpha_list
-
-        @to.accept_list_end @lalpha_list
-
-        accept_list_end_lalpha
-      end
-
-      ##
-      # Calls accept_list_end_number
-
-      def test_accept_list_end_number
-        @to.start_accepting
-
-        @to.accept_list_start @number_list
-
-        @to.accept_list_end @number_list
-
-        accept_list_end_number
-      end
-
-      ##
-      # Calls accept_list_end_note
-
-      def test_accept_list_end_note
-        @to.start_accepting
-
-        @to.accept_list_start @note_list
-
-        @to.accept_list_end @note_list
-
-        accept_list_end_note
-      end
-
-      ##
-      # Calls accept_list_end_ualpha
-
-      def test_accept_list_end_ualpha
-        @to.start_accepting
-
-        @to.accept_list_start @ualpha_list
-
-        @to.accept_list_end @ualpha_list
-
-        accept_list_end_ualpha
-      end
-
-      ##
-      # Calls list_nested with a two-level list
-
-      def test_list_nested
-        doc = @RM::Document.new(
-                @RM::List.new(:BULLET,
-                  @RM::ListItem.new(nil,
-                    @RM::Paragraph.new('l1'),
-                    @RM::List.new(:BULLET,
-                      @RM::ListItem.new(nil,
-                        @RM::Paragraph.new('l1.1')))),
-                  @RM::ListItem.new(nil,
-                    @RM::Paragraph.new('l2'))))
-
-        doc.accept @to
-
-        list_nested
-      end
-
-      ##
-      # Calls list_verbatim with a list containing a verbatim block
-
-      def test_list_verbatim # HACK overblown
-        doc =
-          doc(
-            list(:BULLET,
-              item(nil,
-                para('list stuff'),
-                blank_line,
-                verb("* list\n",
-                     "  with\n",
-                     "\n",
-                     "  second\n",
-                     "\n",
-                     "  1. indented\n",
-                     "  2. numbered\n",
-                     "\n",
-                     "  third\n",
-                     "\n",
-                     "* second\n"))))
-
-        doc.accept @to
-
-        list_verbatim
-      end
-    end
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc/support/test_case.rb b/test/mri/rdoc/rdoc/support/test_case.rb
deleted file mode 100644
index cb1a3bddd97..00000000000
--- a/test/mri/rdoc/rdoc/support/test_case.rb
+++ /dev/null
@@ -1,219 +0,0 @@
-require 'bundler/errors'
-begin
-  gem 'test-unit'
-rescue NoMethodError, Gem::LoadError, Bundler::GemfileNotFound
-  # for ruby tests
-end
-
-require 'test/unit'
-
-require 'fileutils'
-require 'pp'
-require 'tempfile'
-require 'tmpdir'
-require 'stringio'
-
-begin
-  require_relative '../../lib/helper'
-rescue LoadError
-end
-require_relative '../../../lib/rdoc'
-
-##
-# RDoc::TestCase is an abstract TestCase to provide common setup and teardown
-# across all RDoc tests.  The test case uses test-unit, so all the assertions
-# of test-unit may be used.
-#
-# The testcase provides the following:
-#
-# * A reset code-object tree
-# * A reset markup preprocessor (RDoc::Markup::PreProcess)
-# * The <code>@RM</code> alias of RDoc::Markup (for less typing)
-# * <code>@pwd</code> containing the current working directory
-# * FileUtils, pp, Tempfile, Dir.tmpdir and StringIO
-
-class RDoc::TestCase < Test::Unit::TestCase
-
-  ##
-  # Abstract test-case setup
-
-  def setup
-    super
-
-    @orig_home = ENV["HOME"]
-    FileUtils.mkdir_p(@test_home = Dir.mktmpdir("test_rdoc_"))
-    ENV["HOME"] = @test_home
-
-    @top_level = nil
-
-    @RM = RDoc::Markup
-
-    @pwd = Dir.pwd
-
-    @options = RDoc::Options.new
-    @store = RDoc::Store.new(@options)
-
-    @rdoc = RDoc::RDoc.new
-    @rdoc.store = @store
-    @rdoc.options = @options
-
-    @rdoc.generator = Object.new
-
-    RDoc::Markup::PreProcess.reset
-  end
-
-  ##
-  # Abstract test-case teardown
-
-  def teardown
-    ENV["HOME"] = @orig_home if defined?(@orig_home)
-    defined?(@test_home) and FileUtils.rm_rf @test_home
-
-    super
-  end
-
-  ##
-  # Asserts +path+ is a file
-
-  def assert_file(path)
-    assert File.file?(path), "#{path} is not a file"
-  end
-
-  ##
-  # Asserts +path+ is a directory
-
-  def assert_directory(path)
-    assert File.directory?(path), "#{path} is not a directory"
-  end
-
-  ##
-  # Refutes +path+ exists
-
-  def refute_file(path)
-    refute File.exist?(path), "#{path} exists"
-  end
-
-  ##
-  # Shortcut for RDoc::Markup::BlankLine.new
-
-  def blank_line
-    @RM::BlankLine.new
-  end
-
-  ##
-  # Shortcut for RDoc::Markup::BlockQuote.new with +contents+
-
-  def block *contents
-    @RM::BlockQuote.new(*contents)
-  end
-
-  ##
-  # Creates an RDoc::Comment with +text+ which was defined on +top_level+.
-  # By default the comment has the 'rdoc' format.
-
-  def comment(text, top_level = @top_level, language = nil)
-    comment = RDoc::Comment.new text, top_level, language
-    comment
-  end
-
-  ##
-  # Shortcut for RDoc::Markup::Document.new with +contents+
-
-  def doc *contents
-    @RM::Document.new(*contents)
-  end
-
-  ##
-  # Shortcut for RDoc::Markup::HardBreak.new
-
-  def hard_break
-    @RM::HardBreak.new
-  end
-
-  ##
-  # Shortcut for RDoc::Markup::Heading.new with +level+ and +text+
-
-  def head(level, text)
-    @RM::Heading.new level, text
-  end
-
-  ##
-  # Shortcut for RDoc::Markup::ListItem.new with +label+ and +parts+
-
-  def item label = nil, *parts
-    @RM::ListItem.new label, *parts
-  end
-
-  ##
-  # Shortcut for RDoc::Markup::List.new with +type+ and +items+
-
-  def list type = nil, *items
-    @RM::List.new type, *items
-  end
-
-  ##
-  # Enables pretty-print output
-
-  def mu_pp(obj) # :nodoc:
-    s = obj.pretty_inspect
-    s = RDoc::Encoding.change_encoding s, Encoding.default_external
-    s.chomp
-  end
-
-  ##
-  # Shortcut for RDoc::Markup::Paragraph.new with +contents+
-
-  def para *a
-    @RM::Paragraph.new(*a)
-  end
-
-  ##
-  # Shortcut for RDoc::Markup::Rule.new with +weight+
-
-  def rule(weight)
-    @RM::Rule.new weight
-  end
-
-  ##
-  # Shortcut for RDoc::Markup::Raw.new with +contents+
-
-  def raw *contents
-    @RM::Raw.new(*contents)
-  end
-
-  ##
-  # Creates a temporary directory changes the current directory to it for the
-  # duration of the block.
-  #
-  # Depends upon Dir.mktmpdir
-
-  def temp_dir
-    Dir.mktmpdir do |temp_dir|
-      Dir.chdir temp_dir do
-        yield temp_dir
-      end
-    end
-  end
-
-  ##
-  # Shortcut for RDoc::Markup::Verbatim.new with +parts+
-
-  def verb *parts
-    @RM::Verbatim.new(*parts)
-  end
-
-  ##
-  # run capture_io with setting $VERBOSE = true
-
-  def verbose_capture_output
-    capture_output do
-      begin
-        orig_verbose = $VERBOSE
-        $VERBOSE = true
-        yield
-      ensure
-        $VERBOSE = orig_verbose
-      end
-    end
-  end
-end
diff --git a/test/mri/rdoc/rdoc/support/text_formatter_test_case.rb b/test/mri/rdoc/rdoc/support/text_formatter_test_case.rb
deleted file mode 100644
index c45078ce46e..00000000000
--- a/test/mri/rdoc/rdoc/support/text_formatter_test_case.rb
+++ /dev/null
@@ -1,131 +0,0 @@
-# frozen_string_literal: true
-##
-# Test case for creating new plain-text RDoc::Markup formatters.  See also
-# RDoc::Markup::FormatterTestCase
-#
-# See test_rdoc_markup_to_rdoc.rb for a complete example.
-#
-# Example:
-#
-#  class RDocMarkupToNewTextFormatTest < RDoc::Markup::TextFormatterTestCase
-#
-#    add_visitor_tests
-#    add_text_tests
-#
-#    def setup
-#      super
-#
-#      @to = RDoc::Markup::ToNewTextFormat.new
-#    end
-#
-#    def accept_blank_line
-#      assert_equal :junk, @to.res.join
-#    end
-#
-#    # ...
-#
-#  end
-
-class RDoc::Markup::TextFormatterTestCase < RDoc::Markup::FormatterTestCase
-
-  ##
-  # Adds test cases to the calling TestCase.
-
-  def self.add_text_tests
-    self.class_eval do
-
-      ##
-      # Test case that calls <tt>@to.accept_heading</tt>
-
-      def test_accept_heading_indent
-        @to.start_accepting
-        @to.indent = 3
-        @to.accept_heading @RM::Heading.new(1, 'Hello')
-
-        accept_heading_indent
-      end
-
-      ##
-      # Test case that calls <tt>@to.accept_rule</tt>
-
-      def test_accept_rule_indent
-        @to.start_accepting
-        @to.indent = 3
-        @to.accept_rule @RM::Rule.new(1)
-
-        accept_rule_indent
-      end
-
-      ##
-      # Test case that calls <tt>@to.accept_verbatim</tt>
-
-      def test_accept_verbatim_indent
-        @to.start_accepting
-        @to.indent = 2
-        @to.accept_verbatim @RM::Verbatim.new("hi\n", " world\n")
-
-        accept_verbatim_indent
-      end
-
-      ##
-      # Test case that calls <tt>@to.accept_verbatim</tt> with a big indent
-
-      def test_accept_verbatim_big_indent
-        @to.start_accepting
-        @to.indent = 2
-        @to.accept_verbatim @RM::Verbatim.new("hi\n", "world\n")
-
-        accept_verbatim_big_indent
-      end
-
-      ##
-      # Test case that calls <tt>@to.accept_paragraph</tt> with an indent
-
-      def test_accept_paragraph_indent
-        @to.start_accepting
-        @to.indent = 3
-        @to.accept_paragraph @RM::Paragraph.new(('words ' * 30).strip)
-
-        accept_paragraph_indent
-      end
-
-      ##
-      # Test case that calls <tt>@to.accept_paragraph</tt> with a long line
-
-      def test_accept_paragraph_wrap
-        @to.start_accepting
-        @to.accept_paragraph @RM::Paragraph.new(('words ' * 30).strip)
-
-        accept_paragraph_wrap
-      end
-
-      ##
-      # Test case that calls <tt>@to.accept_table</tt>
-
-      def test_accept_table_align
-        header = ['AA', 'BB', 'CCCCC', 'DDDDD']
-        body = [
-          ['', 'bbb', 'c', ''],
-          ['aaaa', 'b', '', 'dd'],
-          ['a', '', 'cc', 'dd']
-        ]
-        aligns = [nil, :left, :right, :center]
-        @to.start_accepting
-        @to.accept_table header, body, aligns
-
-        accept_table_align
-      end
-
-      ##
-      # Test case that calls <tt>@to.attributes</tt> with an escaped
-      # cross-reference.  If this test doesn't pass something may be very
-      # wrong.
-
-      def test_attributes
-        assert_equal 'Dog', @to.attributes("\\Dog")
-      end
-
-    end
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc/test.ja.largedoc b/test/mri/rdoc/rdoc/test.ja.largedoc
deleted file mode 100644
index a9c6c4691c7..00000000000
--- a/test/mri/rdoc/rdoc/test.ja.largedoc
+++ /dev/null
@@ -1,3 +0,0 @@
-# -*- coding: utf-8 -*-
- 吾輩（わがはい）は猫である。名前はまだ無い。
- どこで生れたかとんと見当（けんとう）がつかぬ。何でも薄暗いじめじめした所でニャーニャー泣いていた事だけは記憶している。吾輩はここで始めて人間というものを見た。しかもあとで聞くとそれは書生という人間中で一番獰悪（どうあく）な種族であったそうだ。この書生というのは時々我々を捕（つかま）えて煮（に）て食うという話である。しかしその当時は何という考もなかったから別段恐しいとも思わなかった。ただ彼の掌（てのひら）に載せられてスーと持ち上げられた時何だかフワフワした感じがあったばかりである。掌の上で少し落ちついて書生の顔を見たのがいわゆる人間というものの見始（みはじめ）であろう。この時妙なものだと思った感じが今でも残っている。第一毛をもって装飾されべきはずの顔がつるつるしてまるで薬缶（やかん）だ。その後（ご）猫にもだいぶ逢（あ）ったがこんな片輪（かたわ）には一度も出会（でく）わした事がない。のみならず顔の真中があまりに突起している。そうしてその穴の中から時々ぷうぷうと煙（けむり）を吹く。どうも咽（む）せぽくて実に弱った。これが人間の飲む煙草（たばこ）というものである事はようやくこの頃知った。
diff --git a/test/mri/rdoc/rdoc/test.ja.rdoc b/test/mri/rdoc/rdoc/test.ja.rdoc
deleted file mode 100644
index cd01cab37a1..00000000000
--- a/test/mri/rdoc/rdoc/test.ja.rdoc
+++ /dev/null
@@ -1,10 +0,0 @@
-# -*- coding: utf-8 -*-
-
-こんにちは！
-
-初めまして。アーロンと申します。
-
-どんな食べ物が好きですか？私はフランスの料理が大好きです。
-日本の料理も大好きです。
-
-食べ物を食べるのが大好きだけど、お皿を洗うのが大嫌いです。
diff --git a/test/mri/rdoc/rdoc/test.ja.txt b/test/mri/rdoc/rdoc/test.ja.txt
deleted file mode 100644
index 96e1db93d36..00000000000
--- a/test/mri/rdoc/rdoc/test.ja.txt
+++ /dev/null
@@ -1,8 +0,0 @@
-こんにちは！
-
-初めまして。アーロンと申します。
-
-どんな食べ物が好きですか？私はフランスの料理が大好きです。
-日本の料理も大好きです。
-
-食べ物を食べるのが大好きだけど、お皿を洗うのが大嫌いです。
diff --git a/test/mri/rdoc/rdoc/test.txt b/test/mri/rdoc/rdoc/test.txt
deleted file mode 100644
index 16b14f5da9e..00000000000
--- a/test/mri/rdoc/rdoc/test.txt
+++ /dev/null
@@ -1 +0,0 @@
-test file
diff --git a/test/mri/rdoc/rdoc/xref_data.rb b/test/mri/rdoc/rdoc/xref_data.rb
deleted file mode 100644
index acfc0ce3ff6..00000000000
--- a/test/mri/rdoc/rdoc/xref_data.rb
+++ /dev/null
@@ -1,164 +0,0 @@
-# frozen_string_literal: true
-XREF_DATA = <<-XREF_DATA
-class C1
-
-  attr :attr
-
-  # :section: separate
-
-  attr_reader :attr_reader
-  attr_writer :attr_writer
-
-  # :section:
-  attr_accessor :attr_accessor
-
-  CONST = :const
-
-  def self.m
-  end
-
-  def m foo
-  end
-
-  def +
-  end
-end
-
-class C2
-  def b
-  end
-
-  alias a b
-
-  class C3
-    def m
-    end
-
-    class H1
-      def m?
-      end
-    end
-  end
-end
-
-class C3
-  class H1
-  end
-
-  class H2 < H1
-  end
-end
-
-class C4
-  class C4
-  end
-end
-
-class C5
-  class C1
-  end
-end
-
-class C6
-  private def priv1() end
-  def pub1() end
-  protected def prot1() end
-  def pub2() end
-  public def pub3() end
-  def pub4() end
-
-  private
-  private def priv2() end
-  def priv3() end
-  protected def prot2() end
-  def priv4() end
-  public def pub5() end
-  def priv5() end
-  def self.s_pub1() end
-  class << self
-    def s_pub2() end
-    private
-    def s_priv1() end
-  end
-
-  protected
-  private def priv6() end
-  def prot3() end
-  protected def prot4() end
-  def prot5() end
-  public def pub6() end
-  def prot6() end
-  def self.s_pub3() end
-  class << self
-    def s_pub4() end
-    protected
-    def s_prot1() end
-  end
-end
-
-class C7
-  attr_reader :attr_reader
-  attr_reader :attr_reader_nodoc # :nodoc:
-  attr_writer :attr_writer
-  attr_writer :attr_writer_nodoc # :nodoc:
-  attr_accessor :attr_accessor
-  attr_accessor :attr_accessor_nodoc # :nodoc:
-
-  CONST = :const
-  CONST_NODOC = :const_nodoc # :nodoc:
-end
-
-class C8
-  class << self
-    # This is C8.singleton_class::S1. C8::S1 does not exist.
-    class S1
-    end
-  end
-end
-
-class C9
-  class A
-    def foo() end
-    def self.bar() end
-  end
-
-  class B < A
-    def self.foo() end
-    def bar() end
-  end
-end
-
-class C10
-  class C11
-  end
-
-  def C11
-  end
-end
-
-def C10
-end
-
-class C11
-end
-
-def C11
-end
-
-module M1
-  def m
-  end
-end
-
-module M1::M2
-end
-
-class Parent
-  def m() end
-  def self.m() end
-end
-
-class Child < Parent
-end
-
-XREF_DATA
diff --git a/test/mri/rdoc/rdoc/xref_test_case.rb b/test/mri/rdoc/rdoc/xref_test_case.rb
deleted file mode 100644
index 4c3e3166b24..00000000000
--- a/test/mri/rdoc/rdoc/xref_test_case.rb
+++ /dev/null
@@ -1,86 +0,0 @@
-# frozen_string_literal: true
-ENV['RDOC_TEST'] = 'yes'
-
-require_relative 'helper'
-require File.expand_path '../xref_data', __FILE__
-
-class XrefTestCase < RDoc::TestCase
-
-  def setup
-    super
-
-    @options.quiet = true
-
-    @file_name = 'xref_data.rb'
-    @xref_data = @store.add_file @file_name
-    @top_level = @xref_data
-
-    stats = RDoc::Stats.new @store, 0
-
-    parser = RDoc::Parser::Ruby.new @xref_data, XREF_DATA, @options, stats
-
-    @example_md = @store.add_file 'EXAMPLE.md'
-    @example_md.parser = RDoc::Parser::Markdown
-
-    @top_levels = []
-    @top_levels.push parser.scan
-    @top_levels.push @example_md
-
-    generator = Object.new
-    @rdoc.generator = generator
-
-    @c1       = @xref_data.find_module_named 'C1'
-    @c1__m    = @c1.find_class_method_named 'm' # C1::m
-    @c1_m     = @c1.find_instance_method_named 'm'  # C1#m
-    @c1_plus  = @c1.find_instance_method_named '+'
-
-    @c2    = @xref_data.find_module_named 'C2'
-    @c2_a  = @c2.method_list.last
-    @c2_b  = @c2.method_list.first
-
-    @c2_c3 = @xref_data.find_module_named 'C2::C3'
-    @c2_c3_m = @c2_c3.method_list.first # C2::C3#m
-
-    @c2_c3_h1 = @xref_data.find_module_named 'C2::C3::H1'
-    @c2_c3_h1_meh = @c2_c3_h1.method_list.first # C2::C3::H1#m?
-
-    @c3    = @xref_data.find_module_named 'C3'
-    @c4    = @xref_data.find_module_named 'C4'
-    @c4_c4 = @xref_data.find_module_named 'C4::C4'
-    @c5_c1 = @xref_data.find_module_named 'C5::C1'
-    @c3_h1 = @xref_data.find_module_named 'C3::H1'
-    @c3_h2 = @xref_data.find_module_named 'C3::H2'
-    @c6    = @xref_data.find_module_named 'C6'
-    @c7    = @xref_data.find_module_named 'C7'
-    @c8    = @xref_data.find_module_named 'C8'
-    @c8_s1 = @xref_data.find_module_named 'C8::S1'
-
-    @c9         = @xref_data.find_module_named 'C9'
-    @c9_a       = @xref_data.find_module_named 'C9::A'
-    @c9_a_i_foo = @c9_a.method_list.first
-    @c9_a_c_bar = @c9_a.method_list.last
-    @c9_b       = @xref_data.find_module_named 'C9::B'
-    @c9_b_c_foo = @c9_b.method_list.first
-    @c9_b_i_bar = @c9_b.method_list.last
-
-    @object         = @xref_data.find_module_named 'Object'
-    @c10_class      = @xref_data.find_module_named 'C10'
-    @c10_method     = @object.find_method_named 'C10'
-    @c11_class      = @xref_data.find_module_named 'C11'
-    @c10_c11_class  = @c10_class.find_module_named 'C11'
-    @c10_c11_method = @c10_class.find_method_named 'C11'
-    @c11_method     = @object.find_method_named 'C11'
-
-    @m1    = @xref_data.find_module_named 'M1'
-    @m1_m  = @m1.method_list.first
-
-    @m1_m2 = @xref_data.find_module_named 'M1::M2'
-
-    @parent = @xref_data.find_module_named 'Parent'
-    @child  = @xref_data.find_module_named 'Child'
-
-    @parent_m  = @parent.method_list.first # Parent#m
-    @parent__m = @parent.method_list.last  # Parent::m
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc_alias_test.rb b/test/mri/rdoc/rdoc_alias_test.rb
deleted file mode 100644
index 827002e729c..00000000000
--- a/test/mri/rdoc/rdoc_alias_test.rb
+++ /dev/null
@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-require_relative 'xref_test_case'
-
-class RDocAliasTest < XrefTestCase
-
-  def test_to_s
-    a = RDoc::Alias.new nil, 'a', 'b', ''
-    a.parent = @c2
-
-    assert_equal 'alias: b -> #a in: RDoc::NormalClass C2 < Object', a.to_s
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc_any_method_test.rb b/test/mri/rdoc/rdoc_any_method_test.rb
deleted file mode 100644
index e963a3a3453..00000000000
--- a/test/mri/rdoc/rdoc_any_method_test.rb
+++ /dev/null
@@ -1,609 +0,0 @@
-# frozen_string_literal: true
-require_relative 'xref_test_case'
-
-class RDocAnyMethodTest < XrefTestCase
-
-  def test_aref
-    m = RDoc::AnyMethod.new nil, 'method?'
-
-    assert_equal 'method-i-method-3F', m.aref
-
-    m.singleton = true
-
-    assert_equal 'method-c-method-3F', m.aref
-  end
-
-  def test_arglists
-    m = RDoc::AnyMethod.new nil, 'method'
-
-    assert_nil m.arglists
-
-    m.params = "(a, b)"
-    m.block_params = "c, d"
-
-    assert_equal "method(a, b) { |c, d| ... }", m.arglists
-
-    call_seq = <<-SEQ
-method(a) { |c| ... }
-method(a, b) { |c, d| ... }
-    SEQ
-
-    m.call_seq = call_seq.dup
-
-    assert_equal call_seq, m.arglists
-  end
-
-  def test_c_function
-    @c1_m.c_function = 'my_c1_m'
-
-    assert_equal 'my_c1_m', @c1_m.c_function
-  end
-
-  def test_call_seq_equals
-    m = RDoc::AnyMethod.new nil, nil
-
-    m.call_seq = ''
-
-    assert_nil m.call_seq
-
-    m.call_seq = 'foo'
-
-    assert_equal 'foo', m.call_seq
-  end
-
-  def test_call_seq_alias_for
-    a = RDoc::AnyMethod.new nil, "each"
-    m = RDoc::AnyMethod.new nil, "each_line"
-
-    a.call_seq = <<-CALLSEQ
-each(foo)
-each_line(foo)
-    CALLSEQ
-
-    m.is_alias_for = a
-
-    assert_equal "each_line(foo)", m.call_seq
-  end
-
-  def test_full_name
-    assert_equal 'C1::m', @c1.method_list.first.full_name
-  end
-
-  def test_has_call_seq?
-    m = RDoc::AnyMethod.new nil, "each_line"
-    m2 = RDoc::AnyMethod.new nil, "each"
-    assert_equal false, m.has_call_seq?
-    m.call_seq = "each_line()"
-    assert_equal true, m.has_call_seq?
-
-    m = RDoc::AnyMethod.new nil, "each_line"
-    m.is_alias_for = m2
-    assert_equal false, m.has_call_seq?
-    m2.call_seq = "each_line()"
-    assert_equal true, m.has_call_seq?
-  end
-
-  def test_is_alias_for
-    assert_equal @c2_b, @c2_a.is_alias_for
-
-    # set string on instance variable
-    loaded = Marshal.load Marshal.dump @c2_a
-
-    loaded.store = @store
-
-    assert_equal @c2_b, loaded.is_alias_for, 'Marshal.load'
-
-    m1 = RDoc::AnyMethod.new nil, 'm1'
-    m1.store = @store
-    m1.instance_variable_set :@is_alias_for, ['Missing', false, 'method']
-
-    assert_nil m1.is_alias_for, 'missing alias'
-  end
-
-  def test_call_seq_handles_aliases
-    # see 0ead786
-    @store.path = Dir.tmpdir
-    top_level = @store.add_file 'file.rb'
-    cm = top_level.add_class RDoc::ClassModule, 'Klass'
-
-    method_with_call_seq = RDoc::AnyMethod.new(nil, "method_with_call_seq")
-    method_with_call_seq.call_seq = <<~SEQ
-      method_with_call_seq(a)
-      method_with_call_seq(a, b)
-      alias_to_method(a)
-      alias_to_method(a, b)
-    SEQ
-    cm.add_method(method_with_call_seq)
-
-    alias_to_method = method_with_call_seq.add_alias(
-      RDoc::Alias.new(nil, "method_with_call_seq", "alias_to_method", "comment"),
-      cm
-    )
-
-    assert_equal("method_with_call_seq(a)\nmethod_with_call_seq(a, b)",
-                 method_with_call_seq.call_seq)
-    assert_equal("alias_to_method(a)\nalias_to_method(a, b)",
-                 alias_to_method.call_seq)
-  end
-
-  def test_call_seq_returns_nil_if_alias_is_missing_from_call_seq
-    @store.path = Dir.tmpdir
-    top_level = @store.add_file 'file.rb'
-    cm = top_level.add_class RDoc::ClassModule, 'Klass'
-
-    method_with_call_seq = RDoc::AnyMethod.new(nil, "method_with_call_seq")
-    method_with_call_seq.call_seq = <<~SEQ
-      method_with_call_seq(a)
-      method_with_call_seq(a, b)
-    SEQ
-    cm.add_method(method_with_call_seq)
-
-    alias_to_method = method_with_call_seq.add_alias(
-      RDoc::Alias.new(nil, "method_with_call_seq", "alias_to_method", "comment"),
-      cm
-    )
-
-    assert_equal("method_with_call_seq(a)\nmethod_with_call_seq(a, b)",
-                 method_with_call_seq.call_seq)
-    assert_nil(alias_to_method.call_seq)
-  end
-
-  def test_markup_code
-    tokens = [
-      { :line_no => 0, :char_no => 0, :kind => :on_const, :text => 'CONSTANT' },
-    ]
-
-    @c2_a.collect_tokens
-    @c2_a.add_tokens(tokens)
-
-    expected = '<span class="ruby-constant">CONSTANT</span>'
-
-    assert_equal expected, @c2_a.markup_code
-  end
-
-  def test_markup_code_with_line_numbers
-    position_comment = "# File #{@file_name}, line 1"
-    tokens = [
-      { :line_no => 1, :char_no => 0, :kind => :on_comment, :text => position_comment },
-      { :line_no => 1, :char_no => position_comment.size, :kind => :on_nl, :text => "\n" },
-      { :line_no => 2, :char_no => 0, :kind => :on_const, :text => 'A' },
-      { :line_no => 2, :char_no => 1, :kind => :on_nl, :text => "\n" },
-      { :line_no => 3, :char_no => 0, :kind => :on_const, :text => 'B' }
-    ]
-
-    @c2_a.collect_tokens
-    @c2_a.add_tokens(tokens)
-
-    assert_equal <<-EXPECTED.chomp, @c2_a.markup_code
-<span class="ruby-comment"># File xref_data.rb, line 1</span>
-<span class="ruby-constant">A</span>
-<span class="ruby-constant">B</span>
-    EXPECTED
-
-    @c2_a.options.line_numbers = true
-    assert_equal <<-EXPECTED.chomp, @c2_a.markup_code
-  <span class="ruby-comment"># File xref_data.rb</span>
-<span class="line-num">1</span> <span class="ruby-constant">A</span>
-<span class="line-num">2</span> <span class="ruby-constant">B</span>
-    EXPECTED
-  end
-
-  def test_markup_code_empty
-    assert_equal '', @c2_a.markup_code
-  end
-
-  def test_markup_code_with_variable_expansion
-    m = RDoc::AnyMethod.new nil, 'method'
-    m.parent = @c1
-    m.block_params = '"Hello, #{world}", yield_arg'
-    m.params = 'a'
-
-    assert_equal '(a) { |"Hello, #{world}", yield_arg| ... }', m.param_seq
-  end
-
-  def test_marshal_dump
-    @store.path = Dir.tmpdir
-    top_level = @store.add_file 'file.rb'
-
-    m = RDoc::AnyMethod.new nil, 'method'
-    m.block_params = 'some_block'
-    m.call_seq     = 'call_seq'
-    m.comment      = 'this is a comment'
-    m.params       = 'param'
-    m.record_location top_level
-
-    cm = top_level.add_class RDoc::ClassModule, 'Klass'
-    cm.add_method m
-
-    section = cm.sections.first
-
-    al = RDoc::Alias.new nil, 'method', 'aliased', 'alias comment'
-    al_m = m.add_alias al, cm
-
-    loaded = Marshal.load Marshal.dump m
-    loaded.store = @store
-
-    document = RDoc::Markup::Document.new(
-                 RDoc::Markup::Paragraph.new('this is a comment'))
-
-    assert_equal m, loaded
-
-    assert_equal [al_m.name],    loaded.aliases.map { |alas| alas.name }
-    assert_equal 'some_block',   loaded.block_params
-    assert_equal 'call_seq',     loaded.call_seq
-    assert_equal document,       loaded.comment.parse
-    assert_equal top_level,      loaded.file
-    assert_equal 'Klass#method', loaded.full_name
-    assert_equal 'method',       loaded.name
-    assert_equal 'param',        loaded.params
-    assert_equal false,          loaded.singleton
-    assert_equal :public,        loaded.visibility
-    assert_equal cm,             loaded.parent
-    assert_equal section,        loaded.section
-  end
-
-  def test_marshal_load_aliased_method
-    aliased_method = Marshal.load Marshal.dump(@c2_a)
-
-    aliased_method.store = @store
-
-    assert_equal 'C2#a',  aliased_method.full_name
-    assert_equal 'C2',    aliased_method.parent_name
-    assert_equal '()',    aliased_method.params
-    assert_equal @c2_b,   aliased_method.is_alias_for, 'is_alias_for'
-    assert                aliased_method.display?
-  end
-
-  def test_marshal_load_aliased_method_with_nil_singleton
-    aliased_method = Marshal.load Marshal.dump(@c2_a)
-
-    aliased_method.store = @store
-    aliased_method.is_alias_for = ["C2", nil, "b"]
-
-    assert_equal 'C2#a',  aliased_method.full_name
-    assert_equal 'C2',    aliased_method.parent_name
-    assert_equal '()',    aliased_method.params
-    assert_equal @c2_b,   aliased_method.is_alias_for, 'is_alias_for'
-    assert                aliased_method.display?
-  end
-
-  def test_marshal_load_class_method
-    class_method = Marshal.load Marshal.dump(@c1.find_class_method_named 'm')
-
-    assert_equal 'C1::m', class_method.full_name
-    assert_equal 'C1',    class_method.parent_name
-    assert_equal '()',    class_method.params
-    assert                class_method.display?
-  end
-
-  def test_marshal_load_instance_method
-    instance_method = Marshal.load Marshal.dump(@c1.find_instance_method_named 'm')
-
-    assert_equal 'C1#m',  instance_method.full_name
-    assert_equal 'C1',    instance_method.parent_name
-    assert_equal '(foo)', instance_method.params
-    assert                instance_method.display?
-  end
-
-  def test_marshal_load_version_0
-    @store.path = Dir.tmpdir
-    top_level = @store.add_file 'file.rb'
-
-    m = RDoc::AnyMethod.new nil, 'method'
-
-    cm = top_level.add_class RDoc::ClassModule, 'Klass'
-    cm.add_method m
-
-    section = cm.sections.first
-
-    al = RDoc::Alias.new nil, 'method', 'aliased', 'alias comment'
-    al_m = m.add_alias al, cm
-
-    loaded = Marshal.load "\x04\bU:\x14RDoc::AnyMethod[\x0Fi\x00I" +
-                          "\"\vmethod\x06:\x06EF\"\x11Klass#method0:\vpublic" +
-                          "o:\eRDoc::Markup::Document\x06:\v@parts[\x06" +
-                          "o:\x1CRDoc::Markup::Paragraph\x06;\t[\x06I" +
-                          "\"\x16this is a comment\x06;\x06FI" +
-                          "\"\rcall_seq\x06;\x06FI\"\x0Fsome_block\x06;\x06F" +
-                          "[\x06[\aI\"\faliased\x06;\x06Fo;\b\x06;\t[\x06" +
-                          "o;\n\x06;\t[\x06I\"\x12alias comment\x06;\x06FI" +
-                          "\"\nparam\x06;\x06F"
-
-    loaded.store = @store
-
-    document = RDoc::Markup::Document.new(
-                 RDoc::Markup::Paragraph.new('this is a comment'))
-
-    assert_equal m, loaded
-
-    assert_equal [al_m.name],    loaded.aliases.map { |alas| alas.name }
-    assert_equal 'some_block',   loaded.block_params
-    assert_equal 'call_seq',     loaded.call_seq
-    assert_equal document,       loaded.comment.parse
-    assert_equal 'Klass#method', loaded.full_name
-    assert_equal 'method',       loaded.name
-    assert_equal 'param',        loaded.params
-    assert_nil                   loaded.singleton # defaults to nil
-    assert_equal :public,        loaded.visibility
-    assert_nil                   loaded.file
-    assert_equal cm,             loaded.parent
-    assert_equal section,        loaded.section
-    assert_nil                   loaded.is_alias_for
-
-    assert loaded.display?
-  end
-
-  def test_marshal_dump_version_2
-    @store.path = Dir.tmpdir
-    top_level = @store.add_file 'file.rb'
-
-    m = RDoc::AnyMethod.new nil, 'method'
-    m.block_params = 'some_block'
-    m.call_seq     = 'call_seq'
-    m.comment      = 'this is a comment'
-    m.params       = 'param'
-    m.record_location top_level
-
-    cm = top_level.add_class RDoc::ClassModule, 'Klass'
-    cm.add_method m
-
-    section = cm.sections.first
-
-    al = RDoc::Alias.new nil, 'method', 'aliased', 'alias comment'
-    al_m = m.add_alias al, cm
-
-    loaded = Marshal.load "\x04\bU:\x14RDoc::AnyMethod[\x14i\bI" +
-                          "\"\vmethod\x06:\x06ETI" +
-                          "\"\x11Klass#method\x06;\x06T0:\vpublic" +
-                          "o:\eRDoc::Markup::Document\b:\v@parts[\x06" +
-                          "o:\x1CRDoc::Markup::Paragraph\x06;\t[\x06I" +
-                          "\"\x16this is a comment\x06;\x06T:\n@file0" +
-                          ":0@omit_headings_from_table_of_contents_below0" +
-                          "I\"\rcall_seq\x06;\x06TI\"\x0Fsome_block\x06" +
-                          ";\x06T[\x06[\aI\"\faliased\x06;\x06To;\b\b;\t" +
-                          "[\x06o;\n\x06;\t[\x06I\"\x12alias comment\x06" +
-                          ";\x06T;\v0;\f0I\"\nparam\x06;\x06TI" +
-                          "\"\ffile.rb\x06;\x06TFI\"\nKlass\x06;\x06T" +
-                          "c\x16RDoc::ClassModule0"
-
-    loaded.store = @store
-
-    document = doc(para('this is a comment'))
-
-    assert_equal m, loaded
-
-    assert_equal [al_m.name],    loaded.aliases.map { |alas| alas.name }
-    assert_equal 'some_block',   loaded.block_params
-    assert_equal 'call_seq',     loaded.call_seq
-    assert_equal document,       loaded.comment.parse
-    assert_equal top_level,      loaded.file
-    assert_equal 'Klass#method', loaded.full_name
-    assert_equal 'method',       loaded.name
-    assert_equal 'param',        loaded.params
-    assert_nil                   loaded.singleton # defaults to nil
-    assert_equal :public,        loaded.visibility
-    assert_equal cm,             loaded.parent
-    assert_equal section,        loaded.section
-    assert_nil                   loaded.is_alias_for
-  end
-
-  def test_name
-    m = RDoc::AnyMethod.new nil, nil
-
-    assert_nil m.name
-  end
-
-  def test_name_call_seq
-    m = RDoc::AnyMethod.new nil, nil
-
-    m.call_seq = "yields(name)\nyields(name, description)"
-
-    assert_equal 'yields', m.name
-  end
-
-  def test_name_call_seq_dot
-    m = RDoc::AnyMethod.new nil, nil
-
-    m.call_seq = "obj.yields(name)\nobj.yields(name, description)"
-
-    assert_equal 'yields', m.name
-  end
-
-  def test_param_list_block_params
-    m = RDoc::AnyMethod.new nil, 'method'
-    m.parent = @c1
-
-    m.block_params = 'c, d'
-
-    assert_equal %w[c d], m.param_list
-  end
-
-  def test_param_list_call_seq
-    m = RDoc::AnyMethod.new nil, 'method'
-    m.parent = @c1
-
-    call_seq = <<-SEQ
-method(a) { |c| ... }
-method(a, b) { |c, d| ... }
-    SEQ
-
-    m.call_seq = call_seq
-
-    assert_equal %w[a b c d], m.param_list
-  end
-
-  def test_param_list_default
-    m = RDoc::AnyMethod.new nil, 'method'
-    m.parent = @c1
-
-    m.params = '(b = default)'
-
-    assert_equal %w[b], m.param_list
-  end
-
-  def test_param_list_params
-    m = RDoc::AnyMethod.new nil, 'method'
-    m.parent = @c1
-
-    m.params = '(a, b)'
-
-    assert_equal %w[a b], m.param_list
-  end
-
-  def test_param_list_params_block_params
-    m = RDoc::AnyMethod.new nil, 'method'
-    m.parent = @c1
-
-    m.params = '(a, b)'
-    m.block_params = 'c, d'
-
-    assert_equal %w[a b c d], m.param_list
-  end
-
-  def test_param_list_empty_params_with_block
-    m = RDoc::AnyMethod.new nil, 'method'
-    m.parent = @c1
-
-    m.params = '()'
-    m.block_params = 'a, b'
-
-    assert_equal %w[a b], m.param_list
-  end
-
-  def test_param_list_ampersand_param_block_params
-    m = RDoc::AnyMethod.new nil, 'method'
-    m.parent = @c1
-
-    m.params = '(a, b, &block)'
-    m.block_params = 'c, d'
-
-    assert_equal %w[a b c d], m.param_list
-  end
-
-  def test_param_list_ampersand_param
-    m = RDoc::AnyMethod.new nil, 'method'
-    m.parent = @c1
-
-    m.params = '(a, b, &block)'
-
-    assert_equal %w[a b block], m.param_list
-  end
-
-  def test_param_seq
-    m = RDoc::AnyMethod.new nil, 'method'
-    m.parent = @c1
-    m.params = 'a'
-
-    assert_equal '(a)', m.param_seq
-
-    m.params = '(a)'
-
-    assert_equal '(a)', m.param_seq
-
-    m.params = "(a,\n  b)"
-
-    assert_equal '(a, b)', m.param_seq
-
-    m.block_params = "c,\n  d"
-
-    assert_equal '(a, b) { |c, d| ... }', m.param_seq
-  end
-
-  def test_param_seq_call_seq
-    m = RDoc::AnyMethod.new nil, 'method'
-    m.parent = @c1
-
-    call_seq = <<-SEQ
-method(a) { |c| ... }
-method(a, b) { |c, d| ... }
-    SEQ
-
-    m.call_seq = call_seq
-
-    assert_equal '(a, b) { |c, d| }', m.param_seq
-
-  end
-
-  def test_parent_name
-    assert_equal 'C1', @c1.method_list.first.parent_name
-    assert_equal 'C1', @c1.method_list.last.parent_name
-  end
-
-  def test_skip_description?
-    m = RDoc::AnyMethod.new nil, "each_line"
-    m2 = RDoc::AnyMethod.new nil, "each"
-    assert_equal false, m.skip_description?
-    assert_equal false, m2.skip_description?
-
-    m.is_alias_for = m2
-    m2.aliases << m
-    assert_equal false, m.skip_description?
-    assert_equal false, m2.skip_description?
-
-    m2.call_seq = "each()"
-    assert_equal true, m.skip_description?
-    assert_equal false, m2.skip_description?
-
-    m2.call_seq = "each_line()"
-    assert_equal false, m.skip_description?
-    assert_equal true, m2.skip_description?
-
-    m2.call_seq = "each()\neach_line()"
-    assert_equal false, m.skip_description?
-    assert_equal false, m2.skip_description?
-  end
-
-  def test_store_equals
-    loaded = Marshal.load Marshal.dump(@c1.method_list.last)
-
-    loaded.store = @store
-
-    assert_equal @store, loaded.file.store
-  end
-
-  def test_superclass_method
-    m3 = RDoc::AnyMethod.new '', 'no_super'
-
-    m2 = RDoc::AnyMethod.new '', 'supers'
-    m2.calls_super = true
-
-    m1 = RDoc::AnyMethod.new '', 'supers'
-
-    c1 = RDoc::NormalClass.new 'Outer'
-    c1.store = @store
-    c1.add_method m1
-
-    c2 = RDoc::NormalClass.new 'Inner', c1
-    c2.store = @store
-    c2.add_method m2
-    c2.add_method m3
-
-    assert_nil m3.superclass_method,
-               'no superclass method for no_super'
-
-    assert_equal m1, m2.superclass_method,
-                 'superclass method missing for supers'
-  end
-
-  def test_superclass_method_multilevel
-    m2 = RDoc::AnyMethod.new '', 'supers'
-    m2.calls_super = true
-
-    m1 = RDoc::AnyMethod.new '', 'supers'
-
-    c1 = RDoc::NormalClass.new 'Outer'
-    c1.store = @store
-    c1.add_method m1
-
-    c2 = RDoc::NormalClass.new 'Middle', c1
-    c2.store = @store
-
-    c3 = RDoc::NormalClass.new 'Inner', c2
-    c3.store = @store
-    c3.add_method m2
-
-    assert_equal m1, m2.superclass_method,
-                 'superclass method missing for supers'
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc_attr_test.rb b/test/mri/rdoc/rdoc_attr_test.rb
deleted file mode 100644
index fcdbdfd422c..00000000000
--- a/test/mri/rdoc/rdoc_attr_test.rb
+++ /dev/null
@@ -1,190 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocAttrTest < RDoc::TestCase
-
-  def setup
-    super
-
-    @a = RDoc::Attr.new nil, 'attr', 'RW', ''
-  end
-
-  def test_aref
-    m = RDoc::Attr.new nil, 'attr', 'RW', nil
-
-    assert_equal 'attribute-i-attr', m.aref
-  end
-
-  def test_arglists
-    assert_nil @a.arglists
-  end
-
-  def test_block_params
-    assert_nil @a.block_params
-  end
-
-  def test_call_seq
-    assert_nil @a.call_seq
-  end
-
-  def test_definition
-    assert_equal 'attr_accessor', @a.definition
-
-    @a.rw = 'R'
-
-    assert_equal 'attr_reader', @a.definition
-
-    @a.rw = 'W'
-
-    assert_equal 'attr_writer', @a.definition
-  end
-
-  def test_full_name
-    assert_equal '(unknown)#attr', @a.full_name
-  end
-
-  def test_marshal_dump
-    tl = @store.add_file 'file.rb'
-
-    @a.comment = 'this is a comment'
-    @a.record_location tl
-
-    cm = tl.add_class RDoc::NormalClass, 'Klass'
-    cm.add_attribute @a
-
-    section = cm.sections.first
-
-    loaded = Marshal.load Marshal.dump @a
-    loaded.store = @store
-
-    assert_equal @a, loaded
-
-    document = RDoc::Markup::Document.new(
-                 RDoc::Markup::Paragraph.new('this is a comment'))
-
-    assert_equal document,      loaded.comment.parse
-    assert_equal 'file.rb',    loaded.file.relative_name
-    assert_equal 'Klass#attr', loaded.full_name
-    assert_equal 'attr',       loaded.name
-    assert_equal 'RW',         loaded.rw
-    assert_equal false,        loaded.singleton
-    assert_equal :public,      loaded.visibility
-    assert_equal tl,           loaded.file
-    assert_equal cm,           loaded.parent
-    assert_equal section,      loaded.section
-  end
-
-  def test_marshal_dump_singleton
-    tl = @store.add_file 'file.rb'
-
-    @a.comment = 'this is a comment'
-    @a.record_location tl
-
-    cm = tl.add_class RDoc::NormalClass, 'Klass'
-    cm.add_attribute @a
-
-    section = cm.sections.first
-
-    @a.rw = 'R'
-    @a.singleton = true
-    @a.visibility = :protected
-
-    loaded = Marshal.load Marshal.dump @a
-    loaded.store = @store
-
-    assert_equal @a, loaded
-
-    document = RDoc::Markup::Document.new(
-                 RDoc::Markup::Paragraph.new('this is a comment'))
-
-    assert_equal document,      loaded.comment.parse
-    assert_equal 'Klass::attr', loaded.full_name
-    assert_equal 'attr',        loaded.name
-    assert_equal 'R',           loaded.rw
-    assert_equal true,          loaded.singleton
-    assert_equal :protected,    loaded.visibility
-    assert_equal tl,            loaded.file
-    assert_equal cm,            loaded.parent
-    assert_equal section,       loaded.section
-  end
-
-  def test_marshal_load_version_1
-    tl = @store.add_file 'file.rb'
-    cm = tl.add_class RDoc::NormalClass, 'Klass'
-    section = cm.sections.first
-
-    data = "\x04\bU:\x0FRDoc::Attr[\fi\x06I\"\tattr\x06:\x06EF" +
-           "\"\x0FKlass#attrI\"\aRW\x06;\x06F:\vpublic" +
-           "o:\eRDoc::Markup::Document\x06:\v@parts[\x06" +
-           "o:\x1CRDoc::Markup::Paragraph\x06;\t[\x06I" +
-           "\"\x16this is a comment\x06;\x06FF"
-
-    loaded = Marshal.load data
-    loaded.store = @store
-
-    document = RDoc::Markup::Document.new(
-                 RDoc::Markup::Paragraph.new('this is a comment'))
-
-    assert_equal document,     loaded.comment.parse
-    assert_equal 'Klass#attr', loaded.full_name
-    assert_equal 'attr',       loaded.name
-    assert_equal 'RW',         loaded.rw
-    assert_equal false,        loaded.singleton
-    assert_equal :public,      loaded.visibility
-
-    # version 2
-    assert_nil                 loaded.file
-
-    # version 3
-    assert_equal cm,           loaded.parent
-    assert_equal section,      loaded.section
-
-    assert                     loaded.display?
-  end
-
-  def test_marshal_load_version_2
-    tl = @store.add_file 'file.rb'
-    cm = tl.add_class RDoc::NormalClass, 'Klass'
-    section = cm.sections.first
-
-    loaded = Marshal.load "\x04\bU:\x0FRDoc::Attr[\ri\aI\"\tattr\x06" +
-                          ":\x06ETI\"\x0FKlass#attr\x06;\x06TI\"\aRW\x06" +
-                          ";\x06T:\vpublico:\eRDoc::Markup::Document\a" +
-                          ":\v@parts[\x06o:\x1CRDoc::Markup::Paragraph\x06;" +
-                          "\t[\x06I\"\x16this is a comment\x06;\x06T:\n" +
-                          "@file0FI\"\ffile.rb\x06;\x06T"
-    loaded.store = @store
-
-    document = doc(para('this is a comment'))
-
-    assert_equal document,     loaded.comment.parse
-    assert_equal 'Klass#attr', loaded.full_name
-    assert_equal 'attr',       loaded.name
-    assert_equal 'RW',         loaded.rw
-    assert_equal false,        loaded.singleton
-    assert_equal :public,      loaded.visibility
-    assert_equal tl,           loaded.file
-
-    # version 3
-    assert_equal cm,           loaded.parent
-    assert_equal section,      loaded.section
-
-    assert loaded.display?
-  end
-
-  def test_params
-    assert_nil @a.params
-  end
-
-  def test_singleton
-    refute @a.singleton
-  end
-
-  def test_type
-    assert_equal 'instance', @a.type
-
-    @a.singleton = true
-    assert_equal 'class', @a.type
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc_class_module_test.rb b/test/mri/rdoc/rdoc_class_module_test.rb
deleted file mode 100644
index dec1a4c24b8..00000000000
--- a/test/mri/rdoc/rdoc_class_module_test.rb
+++ /dev/null
@@ -1,1706 +0,0 @@
-# frozen_string_literal: true
-require_relative 'xref_test_case'
-
-class RDocClassModuleTest < XrefTestCase
-
-  def test_add_comment
-    tl1 = @store.add_file 'one.rb'
-    tl2 = @store.add_file 'two.rb'
-    tl3 = @store.add_file 'three.rb'
-
-    cm = RDoc::ClassModule.new 'Klass'
-    comment_tl1 = RDoc::Comment.new('# comment 1', @top_level, :ruby)
-    cm.add_comment comment_tl1, tl1
-
-    assert_equal [[comment_tl1, tl1]], cm.comment_location
-    assert_equal 'comment 1', cm.comment.text
-
-    comment_tl2 = RDoc::Comment.new('# comment 2', @top_level, :ruby)
-    cm.add_comment comment_tl2, tl2
-
-    assert_equal [[comment_tl1, tl1], [comment_tl2, tl2]], cm.comment_location
-    assert_equal "comment 1\n---\ncomment 2", cm.comment
-
-    comment_tl3 = RDoc::Comment.new('# * comment 3', @top_level, :ruby)
-    cm.add_comment comment_tl3, tl3
-
-    assert_equal [[comment_tl1, tl1],
-                  [comment_tl2, tl2],
-                  [comment_tl3, tl3]], cm.comment_location
-    assert_equal "comment 1\n---\ncomment 2\n---\n* comment 3", cm.comment
-  end
-
-  def test_add_comment_comment
-    cm = RDoc::ClassModule.new 'Klass'
-
-    cm.add_comment comment('comment'), @top_level
-
-    assert_equal 'comment', cm.comment.text
-  end
-
-  def test_add_comment_duplicate
-    tl1 = @store.add_file 'one.rb'
-
-    cm = RDoc::ClassModule.new 'Klass'
-    comment1 = RDoc::Comment.new('# comment 1', @top_level, :ruby)
-    comment2 = RDoc::Comment.new('# comment 2', @top_level, :ruby)
-    cm.add_comment comment1, tl1
-    cm.add_comment comment2, tl1
-
-    assert_equal [[comment1, tl1],
-                  [comment2, tl1]], cm.comment_location
-  end
-
-  def test_add_comment_stopdoc
-    tl = @store.add_file 'file.rb'
-
-    cm = RDoc::ClassModule.new 'Klass'
-    cm.stop_doc
-
-    cm.add_comment '# comment 1', tl
-
-    assert_empty cm.comment
-  end
-
-  def test_ancestors
-    assert_equal [@parent, @object, "BasicObject"], @child.ancestors
-  end
-
-  def test_comment_equals
-    cm = RDoc::ClassModule.new 'Klass'
-    cm.comment = RDoc::Comment.new('# comment 1', @top_level, :ruby)
-
-    assert_equal 'comment 1', cm.comment.to_s
-
-    cm.comment = RDoc::Comment.new('# comment 2', @top_level, :ruby)
-
-    assert_equal "comment 1\n---\ncomment 2", cm.comment.to_s
-
-    cm.comment = RDoc::Comment.new('# * comment 3', @top_level, :ruby)
-
-    assert_equal "comment 1\n---\ncomment 2\n---\n* comment 3", cm.comment.to_s
-  end
-
-  def test_comment_equals_comment
-    cm = RDoc::ClassModule.new 'Klass'
-
-    cm.comment = comment 'comment'
-
-    assert_equal 'comment', cm.comment.text
-  end
-
-  def test_document_self_or_methods
-    assert @c1.document_self_or_methods
-
-    @c1.document_self = false
-
-    assert @c1.document_self_or_methods
-
-    @c1_plus.document_self = false
-    @c1_m.document_self = false
-
-    assert @c1.document_self_or_methods
-
-    @c1__m.document_self = false
-
-    refute @c1.document_self_or_methods
-  end
-
-  def test_documented_eh
-    cm = RDoc::ClassModule.new 'C'
-
-    refute cm.documented?, 'no comments, no markers'
-
-    cm.add_comment '', @top_level
-
-    refute cm.documented?, 'empty comment'
-
-    cm.add_comment 'hi', @top_level
-
-    assert cm.documented?, 'commented'
-
-    cm.comment_location.clear
-
-    refute cm.documented?, 'no comment'
-
-    cm.document_self = nil # notify :nodoc:
-
-    assert cm.documented?, ':nodoc:'
-  end
-
-  def test_each_ancestor
-    assert_equal [@parent, @object], @child.each_ancestor.to_a
-  end
-
-  def test_each_ancestor_cycle
-    m_incl = RDoc::Include.new 'M', nil
-
-    m = @top_level.add_module RDoc::NormalModule, 'M'
-    m.add_include m_incl
-
-    assert_empty m.each_ancestor.to_a
-  end
-
-  # handle making a short module alias of yourself
-
-  def test_find_class_named
-    @c2.classes_hash['C2'] = @c2
-
-    assert_nil @c2.find_class_named('C1')
-  end
-
-  def test_from_module_comment
-    tl = @store.add_file 'file.rb'
-    klass = tl.add_class RDoc::NormalModule, 'Klass'
-    klass.add_comment 'really a class', tl
-
-    klass = RDoc::ClassModule.from_module RDoc::NormalClass, klass
-
-    assert_equal [['really a class', tl]], klass.comment_location
-  end
-
-  def test_marshal_dump
-    @store.path = Dir.tmpdir
-    tl = @store.add_file 'file.rb'
-
-    ns = tl.add_module RDoc::NormalModule, 'Namespace'
-
-    cm = ns.add_class RDoc::NormalClass, 'Klass', 'Super'
-    cm.document_self = true
-    cm.record_location tl
-
-    a1 = RDoc::Attr.new nil, 'a1', 'RW', ''
-    a1.record_location tl
-    a2 = RDoc::Attr.new nil, 'a2', 'RW', '', singleton: true
-    a2.record_location tl
-
-    m1 = RDoc::AnyMethod.new nil, 'm1'
-    m1.record_location tl
-
-    c1 = RDoc::Constant.new 'C1', nil, ''
-    c1.record_location tl
-
-    i1 = RDoc::Include.new 'I1', ''
-    i1.record_location tl
-
-    e1 = RDoc::Extend.new 'E1', ''
-    e1.record_location tl
-
-    section_comment = RDoc::Comment.new('section comment')
-    section_comment.location = tl
-
-    assert_equal 1, cm.sections.length, 'sanity, default section only'
-    s0 = cm.sections.first
-    s1 = cm.add_section 'section', section_comment
-
-    cm.add_attribute a1
-    cm.add_attribute a2
-    cm.add_method m1
-    cm.add_constant c1
-    cm.add_include i1
-    cm.add_extend e1
-    cm.add_comment 'this is a comment', tl
-
-    loaded = Marshal.load Marshal.dump cm
-    loaded.store = @store
-
-    assert_equal cm, loaded
-
-    inner = RDoc::Markup::Document.new(
-      RDoc::Markup::Paragraph.new('this is a comment'))
-    inner.file = tl
-
-    document = RDoc::Markup::Document.new(inner)
-
-    assert_equal [a2, a1],           loaded.attributes.sort
-    assert_equal document,           loaded.comment.parse
-    assert_equal [c1],               loaded.constants
-    assert_equal 'Namespace::Klass', loaded.full_name
-    assert_equal [i1],               loaded.includes
-    assert_equal [e1],               loaded.extends
-    assert_equal [m1],               loaded.method_list
-    assert_equal 'Klass',            loaded.name
-    assert_equal 'Super',            loaded.superclass
-    assert_equal [tl],               loaded.in_files
-    assert_equal 'Namespace',        loaded.parent.name
-
-    expected = { nil => s0, 'section' => s1 }
-    assert_equal expected, loaded.sections_hash
-
-    assert_equal tl, loaded.attributes.first.file
-
-    assert_equal tl, loaded.constants.first.file
-
-    assert_equal tl, loaded.includes.first.file
-
-    assert_equal tl, loaded.extends.first.file
-
-    assert_equal tl, loaded.method_list.first.file
-  end
-
-  def test_marshal_dump_visibility
-    @store.path = Dir.tmpdir
-    tl = @store.add_file 'file.rb'
-
-    ns = tl.add_module RDoc::NormalModule, 'Namespace'
-
-    cm = ns.add_class RDoc::NormalClass, 'Klass', 'Super'
-    cm.record_location tl
-
-    a1 = RDoc::Attr.new nil, 'a1', 'RW', ''
-    a1.record_location tl
-    a1.document_self = false
-
-    m1 = RDoc::AnyMethod.new nil, 'm1'
-    m1.record_location tl
-    m1.document_self = false
-
-    c1 = RDoc::Constant.new 'C1', nil, ''
-    c1.record_location tl
-    c1.document_self = false
-
-    i1 = RDoc::Include.new 'I1', ''
-    i1.record_location tl
-    i1.document_self = false
-
-    e1 = RDoc::Extend.new 'E1', ''
-    e1.record_location tl
-    e1.document_self = false
-
-    section_comment = RDoc::Comment.new('section comment')
-    section_comment.location = tl
-
-    assert_equal 1, cm.sections.length, 'sanity, default section only'
-
-    cm.add_attribute a1
-    cm.add_method m1
-    cm.add_constant c1
-    cm.add_include i1
-    cm.add_extend e1
-    cm.add_comment 'this is a comment', tl
-
-    loaded = Marshal.load Marshal.dump cm
-    loaded.store = @store
-
-    assert_equal cm, loaded
-
-    assert_empty loaded.attributes
-    assert_empty loaded.constants
-    assert_empty loaded.includes
-    assert_empty loaded.extends
-    assert_empty loaded.method_list
-  end
-
-  def test_marshal_load_version_0
-    tl = @store.add_file 'file.rb'
-    ns = tl.add_module RDoc::NormalModule, 'Namespace'
-    cm = ns.add_class RDoc::NormalClass, 'Klass', 'Super'
-
-    a = RDoc::Attr.new(nil, 'a1', 'RW', '')
-    m = RDoc::AnyMethod.new(nil, 'm1')
-    c = RDoc::Constant.new('C1', nil, '')
-    i = RDoc::Include.new('I1', '')
-
-    s0 = cm.sections.first
-
-    cm.add_attribute a
-    cm.add_method m
-    cm.add_constant c
-    cm.add_include i
-    cm.add_comment 'this is a comment', tl
-
-    loaded = Marshal.load "\x04\bU:\x16RDoc::NormalClass[\x0Ei\x00\"\nKlass" +
-                          "\"\x15Namespace::KlassI\"\nSuper\x06:\x06EF" +
-                          "o:\eRDoc::Markup::Document\x06:\v@parts[\x06" +
-                          "o:\x1CRDoc::Markup::Paragraph\x06;\b[\x06I" +
-                          "\"\x16this is a comment\x06;\x06F[\x06[\aI" +
-                          "\"\aa1\x06;\x06FI\"\aRW\x06;\x06F[\x06[\aI" +
-                          "\"\aC1\x06;\x06Fo;\a\x06;\b[\x00[\x06[\aI" +
-                          "\"\aI1\x06;\x06Fo;\a\x06;\b[\x00[\a[\aI" +
-                          "\"\nclass\x06;\x06F[\b[\a:\vpublic[\x00[\a" +
-                          ":\x0Eprotected[\x00[\a:\fprivate[\x00[\aI" +
-                          "\"\rinstance\x06;\x06F[\b[\a;\n[\x06I" +
-                          "\"\am1\x06;\x06F[\a;\v[\x00[\a;\f[\x00"
-
-    loaded.store = @store
-
-    assert_equal cm, loaded
-
-    document = RDoc::Markup::Document.new(
-                 RDoc::Markup::Paragraph.new('this is a comment'))
-
-    assert_equal [a],                loaded.attributes
-    assert_equal document,           loaded.comment.parse
-    assert_equal [c],                loaded.constants
-    assert_equal 'Namespace::Klass', loaded.full_name
-    assert_equal [i],                loaded.includes
-    assert_equal [m],                loaded.method_list
-    assert_equal 'Klass',            loaded.name
-    assert_equal 'Super',            loaded.superclass
-    assert_nil                       loaded.file
-    assert_empty                     loaded.in_files
-    assert_nil                       loaded.parent
-    assert                           loaded.current_section
-
-    expected = { nil => s0 }
-    assert_equal expected, loaded.sections_hash
-
-    assert loaded.display?
-  end
-
-  def test_marshal_load_version_1
-    tl = @store.add_file 'file.rb'
-
-    ns = tl.add_module RDoc::NormalModule, 'Namespace'
-
-    cm = ns.add_class RDoc::NormalClass, 'Klass', 'Super'
-    cm.record_location tl
-
-    a1 = RDoc::Attr.new nil, 'a1', 'RW', ''
-    a1.record_location tl
-    a2 = RDoc::Attr.new nil, 'a2', 'RW', '', singleton: true
-    a2.record_location tl
-
-    m1 = RDoc::AnyMethod.new nil, 'm1'
-    m1.record_location tl
-
-    c1 = RDoc::Constant.new 'C1', nil, ''
-    c1.record_location tl
-
-    i1 = RDoc::Include.new 'I1', ''
-    i1.record_location tl
-
-    s0 = cm.sections.first
-
-    cm.add_attribute a1
-    cm.add_attribute a2
-    cm.add_method m1
-    cm.add_constant c1
-    cm.add_include i1
-    cm.add_comment 'this is a comment', tl
-
-    loaded = Marshal.load "\x04\bU:\x16RDoc::NormalClass[\x0Ei\x06I\"\nKlass" +
-                          "\x06:\x06EFI\"\x15Namespace::Klass\x06;\x06FI" +
-                          "\"\nSuper\x06;\x06Fo:\eRDoc::Markup::Document\a" +
-                          ":\v@parts[\x06o;\a\a;\b[\x06o" +
-                          ":\x1CRDoc::Markup::Paragraph\x06;\b" +
-                          "[\x06I\"\x16this is a comment\x06;\x06F" +
-                          ":\n@fileI\"\ffile.rb\x06;\x06F;\n0[\a[\nI" +
-                          "\"\aa2\x06;\x06FI\"\aRW\x06;\x06F:\vpublicT@\x11" +
-                          "[\nI\"\aa1\x06;\x06FI\"\aRW\x06;\x06F;\vF@\x11" +
-                          "[\x06[\bI\"\aC1\x06;\x06Fo;\a\a;\b[\x00;\n0@\x11" +
-                          "[\x06[\bI\"\aI1\x06;\x06Fo;\a\a;\b[\x00;\n0@\x11" +
-                          "[\a[\aI\"\nclass\x06;\x06F[\b[\a;\v[\x00" +
-                          "[\a:\x0Eprotected[\x00[\a:\fprivate[\x00[\aI" +
-                          "\"\rinstance\x06;\x06F[\b[\a;\v[\x06[\aI" +
-                          "\"\am1\x06;\x06F@\x11[\a;\f[\x00[\a;\r[\x00"
-
-    loaded.store = @store
-
-    assert_equal cm, loaded
-
-    inner = RDoc::Markup::Document.new(
-      RDoc::Markup::Paragraph.new('this is a comment'))
-    inner.file = tl
-
-    document = RDoc::Markup::Document.new(inner)
-
-    assert_equal [a2, a1],           loaded.attributes.sort
-    assert_equal document,           loaded.comment.parse
-    assert_equal [c1],               loaded.constants
-    assert_equal 'Namespace::Klass', loaded.full_name
-    assert_equal [i1],               loaded.includes
-    assert_empty                     loaded.extends
-    assert_equal [m1],               loaded.method_list
-    assert_equal 'Klass',            loaded.name
-    assert_equal 'Super',            loaded.superclass
-    assert_empty                     loaded.in_files
-    assert_nil                       loaded.parent
-    assert                           loaded.current_section
-
-    assert_equal tl, loaded.attributes.first.file
-    assert_equal tl, loaded.constants.first.file
-    assert_equal tl, loaded.includes.first.file
-    assert_equal tl, loaded.method_list.first.file
-
-    expected = { nil => s0 }
-    assert_equal expected, loaded.sections_hash
-  end
-
-  def test_marshal_load_version_2
-    tl = @store.add_file 'file.rb'
-
-    ns = tl.add_module RDoc::NormalModule, 'Namespace'
-
-    cm = ns.add_class RDoc::NormalClass, 'Klass', 'Super'
-    cm.record_location tl
-
-    a1 = RDoc::Attr.new nil, 'a1', 'RW', ''
-    a1.record_location tl
-    a2 = RDoc::Attr.new nil, 'a2', 'RW', '', singleton: true
-    a2.record_location tl
-
-    m1 = RDoc::AnyMethod.new nil, 'm1'
-    m1.record_location tl
-
-    c1 = RDoc::Constant.new 'C1', nil, ''
-    c1.record_location tl
-
-    i1 = RDoc::Include.new 'I1', ''
-    i1.record_location tl
-
-    e1 = RDoc::Extend.new 'E1', ''
-    e1.record_location tl
-
-    s0 = cm.sections.first
-
-    cm.add_attribute a1
-    cm.add_attribute a2
-    cm.add_method m1
-    cm.add_constant c1
-    cm.add_include i1
-    cm.add_extend e1
-    cm.add_comment 'this is a comment', tl
-
-    loaded = Marshal.load "\x04\bU:\x16RDoc::NormalClass[\x0Fi\aI\"\nKlass" +
-                          "\x06:\x06EFI\"\x15Namespace::Klass\x06;\x06FI" +
-                          "\"\nSuper\x06;\x06Fo:\eRDoc::Markup::Document\a" +
-                          ":\v@parts[\x06o;\a\a;\b[\x06o" +
-                          ":\x1CRDoc::Markup::Paragraph\x06;\b" +
-                          "[\x06I\"\x16this is a comment\x06;\x06F" +
-                          ":\n@fileI\"\ffile.rb\x06;\x06F;\n0[\a[\nI" +
-                          "\"\aa2\x06;\x06FI\"\aRW\x06;\x06F:\vpublicT@\x11" +
-                          "[\nI\"\aa1\x06;\x06FI\"\aRW\x06;\x06F;\vF@\x11" +
-                          "[\x06[\bI\"\aC1\x06;\x06Fo;\a\a;\b[\x00;\n0@\x11" +
-                          "[\x06[\bI\"\aI1\x06;\x06Fo;\a\a;\b[\x00;\n0@\x11" +
-                          "[\a[\aI\"\nclass\x06;\x06F[\b[\a;\v[\x00" +
-                          "[\a:\x0Eprotected[\x00[\a:\fprivate[\x00[\aI" +
-                          "\"\rinstance\x06;\x06F[\b[\a;\v[\x06[\aI" +
-                          "\"\am1\x06;\x06F@\x11[\a;\f[\x00[\a;\r[\x00" +
-                          "[\x06[\bI\"\aE1\x06;\x06Fo;\a\a;\b[\x00;\n0@\x11"
-
-    loaded.store = @store
-
-    assert_equal cm, loaded
-
-    inner = RDoc::Markup::Document.new(
-      RDoc::Markup::Paragraph.new('this is a comment'))
-    inner.file = tl
-
-    document = RDoc::Markup::Document.new(inner)
-
-    assert_equal [a2, a1],           loaded.attributes.sort
-    assert_equal document,           loaded.comment.parse
-    assert_equal [c1],               loaded.constants
-    assert_equal 'Namespace::Klass', loaded.full_name
-    assert_equal [i1],               loaded.includes
-    assert_equal [e1],               loaded.extends
-    assert_equal [m1],               loaded.method_list
-    assert_equal 'Klass',            loaded.name
-    assert_equal 'Super',            loaded.superclass
-    assert_empty                     loaded.in_files
-    assert_nil                       loaded.parent
-    assert                           loaded.current_section
-
-    assert_equal tl, loaded.attributes. first.file
-    assert_equal tl, loaded.constants.  first.file
-    assert_equal tl, loaded.includes.   first.file
-    assert_equal tl, loaded.extends.    first.file
-    assert_equal tl, loaded.method_list.first.file
-
-    expected = { nil => s0 }
-    assert_equal expected, loaded.sections_hash
-  end
-
-  def test_marshal_load_version_3
-    tl = @store.add_file 'file.rb'
-
-    ns = tl.add_module RDoc::NormalModule, 'Namespace'
-
-    cm = ns.add_class RDoc::NormalClass, 'Klass', 'Super'
-    cm.record_location tl
-
-    a1 = RDoc::Attr.new nil, 'a1', 'RW', ''
-    a1.record_location tl
-    a2 = RDoc::Attr.new nil, 'a2', 'RW', '', singleton: true
-    a2.record_location tl
-
-    m1 = RDoc::AnyMethod.new nil, 'm1'
-    m1.record_location tl
-
-    c1 = RDoc::Constant.new 'C1', nil, ''
-    c1.record_location tl
-
-    i1 = RDoc::Include.new 'I1', ''
-    i1.record_location tl
-
-    e1 = RDoc::Extend.new 'E1', ''
-    e1.record_location tl
-
-    section_comment = RDoc::Comment.new('section comment')
-    section_comment.location = tl
-
-    assert_equal 1, cm.sections.length, 'sanity, default section only'
-    s0 = cm.sections.first
-    s1 = cm.add_section 'section', section_comment
-
-    cm.add_attribute a1
-    cm.add_attribute a2
-    cm.add_method m1
-    cm.add_constant c1
-    cm.add_include i1
-    cm.add_extend e1
-    cm.add_comment 'this is a comment', tl
-
-    loaded = Marshal.load "\x04\bU:\x16RDoc::NormalClass[\x13i\bI\"\nKlass" +
-                          "\x06:\x06ETI\"\x15Namespace::Klass\x06;\x06TI" +
-                          "\"\nSuper\x06;\x06To:\eRDoc::Markup::Document\a" +
-                          ":\v@parts[\x06o;\a\a;\b[\x06o" +
-                          ":\x1CRDoc::Markup::Paragraph\x06;\b[\x06I" +
-                          "\"\x16this is a comment\x06;\x06T:\n@fileI" +
-                          "\"\ffile.rb\x06;\x06T;\n0[\a[\nI\"\aa2\x06;" +
-                          "\x06TI\"\aRW\x06;\x06T:\vpublicT@\x11[\nI" +
-                          "\"\aa1\x06;\x06TI\"\aRW\x06;\x06T;\vF@\x11" +
-                          "[\x06U:\x13RDoc::Constant[\x0Fi\x00I\"\aC1\x06" +
-                          ";\x06TI\"\x19Namespace::Klass::C1\x06;\x06T00o" +
-                          ";\a\a;\b[\x00;\n0@\x11@\ac\x16RDoc::NormalClass0" +
-                          "[\x06[\bI\"\aI1\x06;\x06To;\a\a;\b[\x00;\n0@\x11" +
-                          "[\a[\aI\"\nclass\x06;\x06T[\b[\a;\v[\x00[\a" +
-                          ":\x0Eprotected[\x00[\a:\fprivate[\x00[\aI" +
-                          "\"\rinstance\x06;\x06T[\b[\a;\v[\x06[\aI" +
-                          "\"\am1\x06;\x06T@\x11[\a;\r[\x00[\a;\x0E[\x00" +
-                          "[\x06[\bI\"\aE1\x06;\x06To;\a\a;\b[\x00;\n0@\x11" +
-                          "[\aU:\eRDoc::Context::Section[\bi\x000o;\a\a;\b" +
-                          "[\x00;\n0U;\x0F[\bi\x00I\"\fsection\x06;\x06To" +
-                          ";\a\a;\b[\x06o;\a\a;\b[\x06o;\t\x06;\b[\x06I" +
-                          "\"\x14section comment\x06;\x06T;\n@\x11;\n0" +
-                          "[\x06@\x11I\"\x0ENamespace\x06" +
-                          ";\x06Tc\x17RDoc::NormalModule"
-
-    loaded.store = @store
-
-    assert_equal cm, loaded
-
-    inner = RDoc::Markup::Document.new(
-      RDoc::Markup::Paragraph.new('this is a comment'))
-    inner.file = tl
-
-    document = RDoc::Markup::Document.new(inner)
-
-    assert_equal [a2, a1],           loaded.attributes.sort
-    assert_equal document,           loaded.comment.parse
-    assert_equal [c1],               loaded.constants
-    assert_equal 'Namespace::Klass', loaded.full_name
-    assert_equal [i1],               loaded.includes
-    assert_equal [e1],               loaded.extends
-    assert_equal [m1],               loaded.method_list
-    assert_equal 'Klass',            loaded.name
-    assert_equal 'Super',            loaded.superclass
-    assert_equal 'Namespace',        loaded.parent.name
-    assert                           loaded.current_section
-
-    expected = {
-      nil       => s0,
-      'section' => s1,
-    }
-
-    assert_equal expected,           loaded.sections_hash
-    assert_equal [tl],               loaded.in_files
-
-    assert_equal tl, loaded.attributes. first.file
-    assert_equal tl, loaded.constants.  first.file
-    assert_equal tl, loaded.includes.   first.file
-    assert_equal tl, loaded.extends.    first.file
-    assert_equal tl, loaded.method_list.first.file
-  end
-
-  def test_merge
-    tl = @store.add_file 'one.rb'
-    p1  = tl.add_class RDoc::NormalClass, 'Parent'
-    c1  = p1.add_class RDoc::NormalClass, 'Klass'
-
-    c2 = RDoc::NormalClass.new 'Klass'
-
-    c2.merge c1
-
-    assert_equal 'Parent', c1.parent_name, 'original parent name'
-    assert_equal 'Parent', c2.parent_name, 'merged parent name'
-
-    assert c1.current_section, 'original current_section'
-    assert c2.current_section, 'merged current_section'
-  end
-
-  def test_merge_attributes
-    tl1 = @store.add_file 'one.rb'
-    tl2 = @store.add_file 'two.rb'
-
-    cm1 = RDoc::ClassModule.new 'Klass'
-
-    attr = cm1.add_attribute RDoc::Attr.new(nil, 'a1', 'RW', '')
-    attr.record_location tl1
-    attr = cm1.add_attribute RDoc::Attr.new(nil, 'a3', 'R', '')
-    attr.record_location tl1
-    attr = cm1.add_attribute RDoc::Attr.new(nil, 'a4', 'R', '')
-    attr.record_location tl1
-
-    cm2 = RDoc::ClassModule.new 'Klass'
-    # TODO allow merging when comment == ''
-    cm2.instance_variable_set :@comment, @RM::Document.new
-
-    attr = cm2.add_attribute RDoc::Attr.new(nil, 'a2', 'RW', '')
-    attr.record_location tl2
-    attr = cm2.add_attribute RDoc::Attr.new(nil, 'a3', 'W', '')
-    attr.record_location tl1
-    attr = cm2.add_attribute RDoc::Attr.new(nil, 'a4', 'W', '')
-    attr.record_location tl1
-
-    cm1.merge cm2
-
-    expected = [
-      RDoc::Attr.new(nil, 'a2', 'RW', ''),
-      RDoc::Attr.new(nil, 'a3', 'W',  ''),
-      RDoc::Attr.new(nil, 'a4', 'W',  ''),
-    ]
-
-    expected.each do |a| a.parent = cm1 end
-    assert_equal expected, cm1.attributes.sort
-  end
-
-  def test_merge_attributes_version_0
-    tl1 = @store.add_file 'one.rb'
-
-    cm1 = RDoc::ClassModule.new 'Klass'
-
-    attr = cm1.add_attribute RDoc::Attr.new(nil, 'a1', 'RW', '')
-    attr.record_location tl1
-    attr = cm1.add_attribute RDoc::Attr.new(nil, 'a3', 'R', '')
-    attr.record_location tl1
-    attr = cm1.add_attribute RDoc::Attr.new(nil, 'a4', 'R', '')
-    attr.record_location tl1
-
-    cm2 = RDoc::ClassModule.new 'Klass'
-    # TODO allow merging when comment == ''
-    cm2.instance_variable_set :@comment, @RM::Document.new
-
-    attr = cm2.add_attribute RDoc::Attr.new(nil, 'a2', 'RW', '')
-    attr = cm2.add_attribute RDoc::Attr.new(nil, 'a3', 'W', '')
-    attr = cm2.add_attribute RDoc::Attr.new(nil, 'a4', 'W', '')
-
-    cm1.merge cm2
-
-    expected = [
-      RDoc::Attr.new(nil, 'a1', 'RW', ''),
-      RDoc::Attr.new(nil, 'a2', 'RW', ''),
-      RDoc::Attr.new(nil, 'a3', 'RW', ''),
-      RDoc::Attr.new(nil, 'a4', 'RW', ''),
-    ]
-
-    expected.each do |a| a.parent = cm1 end
-    assert_equal expected, cm1.attributes.sort
-  end
-
-  def test_merge_collections_drop
-    tl = @store.add_file 'file'
-
-    cm1 = RDoc::ClassModule.new 'C'
-    cm1.record_location tl
-
-    const = cm1.add_constant RDoc::Constant.new('CONST', nil, nil)
-    const.record_location tl
-
-    cm2 = RDoc::ClassModule.new 'C'
-    cm2.record_location tl
-
-    added = []
-    removed = []
-
-    cm1.merge_collections cm1.constants, cm2.constants, cm2.in_files do |add, c|
-      if add then
-        added << c
-      else
-        removed << c
-      end
-    end
-
-    assert_empty added
-    assert_equal [const], removed
-  end
-
-  def test_merge_comment
-    tl1 = @store.add_file 'one.rb'
-    tl2 = @store.add_file 'two.rb'
-
-    cm1 = tl1.add_class RDoc::ClassModule, 'Klass'
-    cm1.add_comment 'klass 1', tl1
-    cm1.record_location tl1
-
-    cm2 = tl1.add_class RDoc::NormalClass, 'Klass'
-    cm2.add_comment 'klass 2', tl2
-    cm2.add_comment 'klass 3', tl1
-    cm2.record_location tl1
-    cm2.record_location tl2
-
-    cm2 = Marshal.load Marshal.dump cm2
-    cm2.store = @store
-
-    cm1.merge cm2
-
-    inner1 = @RM::Document.new @RM::Paragraph.new 'klass 3'
-    inner1.file = 'one.rb'
-    inner2 = @RM::Document.new @RM::Paragraph.new 'klass 2'
-    inner2.file = 'two.rb'
-
-    expected = @RM::Document.new inner2, inner1
-
-    assert_equal expected, cm1.comment.parse
-  end
-
-  def test_merge_comment_version_0
-    tl = @store.add_file 'file.rb'
-
-    cm1 = RDoc::ClassModule.new 'Klass'
-    cm1.add_comment 'klass 1', tl
-
-    cm2 = RDoc::ClassModule.new 'Klass'
-
-    cm2.instance_variable_set(:@comment,
-                              @RM::Document.new(
-                                @RM::Paragraph.new('klass 2')))
-    cm2.instance_variable_set :@comment_location, @RM::Document.new(cm2.comment)
-
-    cm1.merge cm2
-
-    inner = @RM::Document.new @RM::Paragraph.new 'klass 1'
-    inner.file = 'file.rb'
-
-    expected = @RM::Document.new \
-      inner,
-      @RM::Document.new(@RM::Paragraph.new('klass 2'))
-
-    assert_equal expected, cm1.comment.parse
-  end
-
-  def test_merge_constants
-    tl1 = @store.add_file 'one.rb'
-    tl2 = @store.add_file 'two.rb'
-
-    cm1 = tl1.add_class RDoc::ClassModule, 'Klass'
-
-    const = cm1.add_constant RDoc::Constant.new('C1', nil, 'one')
-    const.record_location tl1
-    const = cm1.add_constant RDoc::Constant.new('C3', nil, 'one')
-    const.record_location tl1
-
-    store = RDoc::Store.new(RDoc::Options.new)
-    tl = store.add_file 'one.rb'
-    cm2 = tl.add_class RDoc::ClassModule, 'Klass'
-    cm2.instance_variable_set :@comment, @RM::Document.new
-
-    const = cm2.add_constant RDoc::Constant.new('C2', nil, 'two')
-    const.record_location tl2
-    const = cm2.add_constant RDoc::Constant.new('C3', nil, 'one')
-    const.record_location tl1
-    const = cm2.add_constant RDoc::Constant.new('C4', nil, 'one')
-    const.record_location tl1
-
-    cm1.merge cm2
-
-    expected = [
-      RDoc::Constant.new('C2', nil, 'two'),
-      RDoc::Constant.new('C3', nil, 'one'),
-      RDoc::Constant.new('C4', nil, 'one'),
-    ]
-
-    expected.each do |a| a.parent = cm1 end
-
-    assert_equal expected, cm1.constants.sort
-  end
-
-  def test_merge_constants_version_0
-    tl1 = @store.add_file 'one.rb'
-
-    cm1 = tl1.add_class RDoc::ClassModule, 'Klass'
-
-    const = cm1.add_constant RDoc::Constant.new('C1', nil, 'one')
-    const.record_location tl1
-    const = cm1.add_constant RDoc::Constant.new('C3', nil, 'one')
-    const.record_location tl1
-
-    store = RDoc::Store.new(RDoc::Options.new)
-    tl = store.add_file 'one.rb'
-    cm2 = tl.add_class RDoc::ClassModule, 'Klass'
-    cm2.instance_variable_set :@comment, @RM::Document.new
-
-    const = cm2.add_constant RDoc::Constant.new('C2', nil, 'two')
-    const = cm2.add_constant RDoc::Constant.new('C3', nil, 'two')
-    const = cm2.add_constant RDoc::Constant.new('C4', nil, 'two')
-
-    cm1.merge cm2
-
-    expected = [
-      RDoc::Constant.new('C1', nil, 'one'),
-      RDoc::Constant.new('C2', nil, 'two'),
-      RDoc::Constant.new('C3', nil, 'one'),
-      RDoc::Constant.new('C4', nil, 'two'),
-    ]
-
-    expected.each do |a| a.parent = cm1 end
-
-    assert_equal expected, cm1.constants.sort
-  end
-
-  def test_merge_extends
-    tl1 = @store.add_file 'one.rb'
-    cm1 = tl1.add_class RDoc::ClassModule, 'Klass'
-
-    ext = cm1.add_extend RDoc::Extend.new('I1', 'one')
-    ext.record_location tl1
-    ext = cm1.add_extend RDoc::Extend.new('I3', 'one')
-    ext.record_location tl1
-
-    tl2 = @store.add_file 'two.rb'
-    tl2.store = RDoc::Store.new(RDoc::Options.new)
-
-    cm2 = tl2.add_class RDoc::ClassModule, 'Klass'
-    cm2.instance_variable_set :@comment, @RM::Document.new
-
-    ext = cm2.add_extend RDoc::Extend.new('I2', 'two')
-    ext.record_location tl2
-    ext = cm2.add_extend RDoc::Extend.new('I3', 'one')
-    ext.record_location tl1
-    ext = cm2.add_extend RDoc::Extend.new('I4', 'one')
-    ext.record_location tl1
-
-    cm1.merge cm2
-
-    expected = [
-      RDoc::Extend.new('I2', 'two'),
-      RDoc::Extend.new('I3', 'one'),
-      RDoc::Extend.new('I4', 'one'),
-    ]
-
-    expected.each do |a| a.parent = cm1 end
-
-    assert_equal expected, cm1.extends.sort
-  end
-
-  def test_merge_includes
-    tl1 = @store.add_file 'one.rb'
-
-    cm1 = tl1.add_class RDoc::ClassModule, 'Klass'
-
-    incl = cm1.add_include RDoc::Include.new('I1', 'one')
-    incl.record_location tl1
-    incl = cm1.add_include RDoc::Include.new('I3', 'one')
-    incl.record_location tl1
-
-    tl2 = @store.add_file 'two.rb'
-    tl2.store = RDoc::Store.new(RDoc::Options.new)
-
-    cm2 = tl2.add_class RDoc::ClassModule, 'Klass'
-    cm2.instance_variable_set :@comment, @RM::Document.new
-
-    incl = cm2.add_include RDoc::Include.new('I2', 'two')
-    incl.record_location tl2
-    incl = cm2.add_include RDoc::Include.new('I3', 'one')
-    incl.record_location tl1
-    incl = cm2.add_include RDoc::Include.new('I4', 'one')
-    incl.record_location tl1
-
-    cm1.merge cm2
-
-    expected = [
-      RDoc::Include.new('I2', 'two'),
-      RDoc::Include.new('I3', 'one'),
-      RDoc::Include.new('I4', 'one'),
-    ]
-
-    expected.each do |a| a.parent = cm1 end
-
-    assert_equal expected, cm1.includes.sort
-  end
-
-  def test_merge_includes_version_0
-    tl1 = @store.add_file 'one.rb'
-
-    cm1 = tl1.add_class RDoc::ClassModule, 'Klass'
-
-    incl = cm1.add_include RDoc::Include.new('I1', 'one')
-    incl.record_location tl1
-    incl = cm1.add_include RDoc::Include.new('I3', 'one')
-    incl.record_location tl1
-
-    tl2 = @store.add_file 'one.rb'
-    tl2.store = RDoc::Store.new(RDoc::Options.new)
-
-    cm2 = tl2.add_class RDoc::ClassModule, 'Klass'
-    cm2.instance_variable_set :@comment, @RM::Document.new
-
-    incl = cm2.add_include RDoc::Include.new('I2', 'two')
-    incl = cm2.add_include RDoc::Include.new('I3', 'two')
-    incl = cm2.add_include RDoc::Include.new('I4', 'two')
-
-    cm1.merge cm2
-
-    expected = [
-      RDoc::Include.new('I1', 'one'),
-      RDoc::Include.new('I2', 'two'),
-      RDoc::Include.new('I3', 'one'),
-      RDoc::Include.new('I4', 'two'),
-    ]
-
-    expected.each do |a| a.parent = cm1 end
-
-    assert_equal expected, cm1.includes.sort
-  end
-
-  def test_merge_methods
-    tl1 = @store.add_file 'one.rb'
-    tl2 = @store.add_file 'two.rb'
-
-    cm1 = tl1.add_class RDoc::NormalClass, 'Klass'
-
-    meth = cm1.add_method RDoc::AnyMethod.new(nil, 'm1')
-    meth.record_location tl1
-    meth = cm1.add_method RDoc::AnyMethod.new(nil, 'm3')
-    meth.record_location tl1
-
-    cm2 = RDoc::ClassModule.new 'Klass'
-    cm2.store = @store
-    cm2.instance_variable_set :@comment, @RM::Document.new
-
-    meth = cm2.add_method RDoc::AnyMethod.new(nil, 'm2')
-    meth.record_location tl2
-    meth = cm2.add_method RDoc::AnyMethod.new(nil, 'm3')
-    meth.record_location tl1
-    meth = cm2.add_method RDoc::AnyMethod.new(nil, 'm4')
-    meth.record_location tl1
-
-    cm1.merge cm2
-
-    expected = [
-      RDoc::AnyMethod.new(nil, 'm2'),
-      RDoc::AnyMethod.new(nil, 'm3'),
-      RDoc::AnyMethod.new(nil, 'm4'),
-    ]
-
-    expected.each do |a| a.parent = cm1 end
-
-    assert_equal expected, cm1.method_list.sort
-  end
-
-  def test_merge_methods_version_0
-    tl1 = @store.add_file 'one.rb'
-
-    cm1 = tl1.add_class RDoc::NormalClass, 'Klass'
-
-    meth = cm1.add_method RDoc::AnyMethod.new(nil, 'm1')
-    meth.record_location tl1
-    meth = cm1.add_method RDoc::AnyMethod.new(nil, 'm3')
-    meth.record_location tl1
-
-    cm2 = RDoc::ClassModule.new 'Klass'
-    cm2.store = @store
-    cm2.instance_variable_set :@comment, @RM::Document.new
-
-    meth = cm2.add_method RDoc::AnyMethod.new(nil, 'm2')
-    meth = cm2.add_method RDoc::AnyMethod.new(nil, 'm3')
-    meth = cm2.add_method RDoc::AnyMethod.new(nil, 'm4')
-
-    cm1.merge cm2
-
-    expected = [
-      RDoc::AnyMethod.new(nil, 'm1'),
-      RDoc::AnyMethod.new(nil, 'm2'),
-      RDoc::AnyMethod.new(nil, 'm3'),
-      RDoc::AnyMethod.new(nil, 'm4'),
-    ]
-
-    expected.each do |a| a.parent = cm1 end
-
-    assert_equal expected, cm1.method_list.sort
-  end
-
-  def test_merge_sections
-    store1 = @store
-
-    tl1_1 = store1.add_file 'one.rb'
-
-    cm1  = tl1_1.add_class RDoc::ClassModule, 'Klass'
-    cm1.record_location tl1_1
-
-    s1_0 = cm1.sections.first
-    s1_1 = cm1.add_section 'section 1', comment('comment 1',   tl1_1)
-           cm1.add_section 'section 2', comment('comment 2 a', tl1_1)
-           cm1.add_section 'section 4', comment('comment 4 a', tl1_1)
-
-    store2 = RDoc::Store.new(RDoc::Options.new)
-    tl2_1 = store2.add_file 'one.rb'
-    tl2_2 = store2.add_file 'two.rb'
-
-    cm2  = tl2_1.add_class RDoc::ClassModule, 'Klass'
-    cm2.record_location tl2_1
-    cm2.record_location tl2_2
-
-           cm2.sections.first
-    s2_2 = cm2.add_section 'section 2', comment('comment 2 b', tl2_1)
-    s2_3 = cm2.add_section 'section 3', comment('comment 3',   tl2_2)
-           cm2.add_section 'section 4', comment('comment 4 b', tl2_2)
-
-    cm1.merge cm2
-
-    expected = [
-      s1_0,
-      s1_1,
-      s2_2,
-      s2_3,
-      RDoc::Context::Section.new(cm1, 'section 4', nil)
-    ]
-
-    merged_sections = cm1.sections.sort_by do |s|
-      s.title || ''
-    end
-
-    assert_equal expected, merged_sections
-
-    assert_equal [comment('comment 2 b', tl2_1)],
-                 cm1.sections_hash['section 2'].comments
-
-    expected_s4_comments = [
-      comment('comment 4 a', tl2_1),
-      comment('comment 4 b', tl2_2),
-    ]
-
-    assert_equal expected_s4_comments, cm1.sections_hash['section 4'].comments
-  end
-
-  def test_merge_sections_overlap
-    store1 = @store
-
-    tl1_1 = store1.add_file 'one.rb'
-    tl1_3 = store1.add_file 'three.rb'
-
-    cm1  = tl1_1.add_class RDoc::ClassModule, 'Klass'
-    cm1.record_location tl1_1
-
-    cm1.add_section 'section', comment('comment 1 a', tl1_1)
-    cm1.add_section 'section', comment('comment 3',   tl1_3)
-
-    store2 = RDoc::Store.new(RDoc::Options.new)
-    tl2_1 = store2.add_file 'one.rb'
-    tl2_2 = store2.add_file 'two.rb'
-    tl2_3 = store2.add_file 'three.rb'
-
-    cm2  = tl2_1.add_class RDoc::ClassModule, 'Klass'
-    cm2.record_location tl2_1
-    cm2.record_location tl2_2
-
-    s2_0 = cm2.sections.first
-    s2_1 = cm2.add_section 'section', comment('comment 1 b', tl1_1)
-           cm2.add_section 'section', comment('comment 2',   tl2_2)
-
-    cm1.merge_sections cm2
-
-    expected = [
-      s2_0,
-      s2_1,
-    ]
-
-    merged_sections = cm1.sections.sort_by do |s|
-      s.title || ''
-    end
-
-    assert_equal expected, merged_sections
-
-    expected = [
-      comment('comment 1 b', tl2_1),
-      comment('comment 3',   tl2_3),
-      comment('comment 2',   tl2_2),
-    ]
-
-    comments = cm1.sections_hash['section'].comments
-
-    assert_equal expected, comments.sort_by { |c| c.file.name }
-  end
-
-  def test_parse
-    tl1 = @store.add_file 'one.rb'
-    tl2 = @store.add_file 'two.rb'
-
-    cm = RDoc::ClassModule.new 'Klass'
-    cm.add_comment 'comment 1', tl1
-    cm.add_comment 'comment 2', tl2
-
-    doc1 = @RM::Document.new @RM::Paragraph.new 'comment 1'
-    doc1.file = tl1
-    doc2 = @RM::Document.new @RM::Paragraph.new 'comment 2'
-    doc2.file = tl2
-
-    expected = @RM::Document.new doc1, doc2
-
-    assert_equal expected, cm.parse(cm.comment_location)
-  end
-
-  def test_parse_comment
-    tl1 = @store.add_file 'one.rb'
-
-    cm = RDoc::ClassModule.new 'Klass'
-    cm.comment = comment 'comment 1', tl1
-
-    doc = @RM::Document.new @RM::Paragraph.new 'comment 1'
-    doc.file = tl1
-
-    assert_equal doc, cm.parse(cm.comment)
-  end
-
-  def test_parse_comment_format
-    tl1 = @store.add_file 'one.rb'
-
-    cm = RDoc::ClassModule.new 'Klass'
-    cm.comment = comment 'comment ((*1*))', tl1
-    cm.comment.format = 'rd'
-
-    doc = @RM::Document.new @RM::Paragraph.new 'comment <em>1</em>'
-    doc.file = tl1
-
-    assert_equal doc, cm.parse(cm.comment)
-  end
-
-  def test_parse_comment_location
-    tl1 = @store.add_file 'one.rb'
-    tl2 = @store.add_file 'two.rb'
-
-    cm = tl1.add_class RDoc::NormalClass, 'Klass'
-    cm.add_comment 'comment 1', tl1
-    cm.add_comment 'comment 2', tl2
-
-    cm = Marshal.load Marshal.dump cm
-
-    doc1 = @RM::Document.new @RM::Paragraph.new 'comment 1'
-    doc1.file = tl1
-    doc2 = @RM::Document.new @RM::Paragraph.new 'comment 2'
-    doc2.file = tl2
-
-    assert_same cm.comment_location, cm.parse(cm.comment_location)
-  end
-
-  def test_remove_nodoc_children
-    parent = @top_level.add_class RDoc::ClassModule, 'A'
-    parent.modules_hash.replace 'B' => true, 'C' => true
-    @store.modules_hash.replace 'A::B' => true
-
-    parent.classes_hash.replace 'D' => true, 'E' => true
-    @store.classes_hash.replace 'A::D' => true
-
-    parent.remove_nodoc_children
-
-    assert_equal %w[B], parent.modules_hash.keys
-    assert_equal %w[D], parent.classes_hash.keys
-  end
-
-  def test_search_record
-    @c2_c3.add_comment 'This is a comment.', @xref_data
-
-    expected = [
-      'C3',
-      'C2::C3',
-      'C2::C3',
-      '',
-      'C2/C3.html',
-      '',
-      "<p>This is a comment.\n"
-    ]
-
-    assert_equal expected, @c2_c3.search_record
-  end
-
-  def test_search_record_merged
-    @c2_c3.add_comment 'comment A', @store.add_file('a.rb')
-    @c2_c3.add_comment 'comment B', @store.add_file('b.rb')
-
-    expected = [
-      'C3',
-      'C2::C3',
-      'C2::C3',
-      '',
-      'C2/C3.html',
-      '',
-      "<p>comment A\n<p>comment B\n"
-    ]
-
-    assert_equal expected, @c2_c3.search_record
-  end
-
-  def test_store_equals
-    # version 2
-    loaded = Marshal.load "\x04\bU:\x16RDoc::NormalClass[\x0Fi\aI\"\nKlass" +
-                          "\x06:\x06EFI\"\x15Namespace::Klass\x06;\x06FI" +
-                          "\"\nSuper\x06;\x06Fo:\eRDoc::Markup::Document\a" +
-                          ":\v@parts[\x06o;\a\a;\b[\x06o" +
-                          ":\x1CRDoc::Markup::Paragraph\x06;\b" +
-                          "[\x06I\"\x16this is a comment\x06;\x06F" +
-                          ":\n@fileI\"\ffile.rb\x06;\x06F;\n0[\a[\nI" +
-                          "\"\aa2\x06;\x06FI\"\aRW\x06;\x06F:\vpublicT@\x11" +
-                          "[\nI\"\aa1\x06;\x06FI\"\aRW\x06;\x06F;\vF@\x11" +
-                          "[\x06[\bI\"\aC1\x06;\x06Fo;\a\a;\b[\x00;\n0@\x11" +
-                          "[\x06[\bI\"\aI1\x06;\x06Fo;\a\a;\b[\x00;\n0@\x11" +
-                          "[\a[\aI\"\nclass\x06;\x06F[\b[\a;\v[\x00" +
-                          "[\a:\x0Eprotected[\x00[\a:\fprivate[\x00[\aI" +
-                          "\"\rinstance\x06;\x06F[\b[\a;\v[\x06[\aI" +
-                          "\"\am1\x06;\x06F@\x11[\a;\f[\x00[\a;\r[\x00" +
-                          "[\x06[\bI\"\aE1\x06;\x06Fo;\a\a;\b[\x00;\n0@\x11"
-
-    loaded.store = @store
-
-    assert_same @store, loaded.store
-
-    a = loaded.attributes.first
-    assert_same @store, a.store
-    assert_same @store, a.file.store
-
-    c = loaded.constants.first
-    assert_same @store, c.store
-    assert_same @store, c.file.store
-
-    i = loaded.includes.first
-    assert_same @store, i.store
-    assert_same @store, i.file.store
-
-    e = loaded.extends.first
-    assert_same @store, e.store
-    assert_same @store, e.file.store
-
-    m = loaded.method_list.first
-    assert_same @store, m.store
-    assert_same @store, m.file.store
-  end
-
-  def test_superclass
-    assert_equal @c3_h1, @c3_h2.superclass
-  end
-
-  def test_setting_superclass
-    @c1.superclass = nil
-    assert_nil(@c1.superclass)
-    assert_nil(@c1.instance_variable_get("@superclass")) # proxy to test marshalling
-
-    @c1.superclass = @c4_c4.full_name
-    assert_equal(@c1.superclass, @c4_c4)
-    assert_equal(@c4_c4.full_name, @c1.instance_variable_get("@superclass"))
-
-    @c1.superclass = @c4_c4
-    assert_equal(@c1.superclass, @c4_c4)
-    assert_equal(@c4_c4.full_name, @c1.instance_variable_get("@superclass"))
-
-    # we could support this if we find we need to in the future.
-    assert_raise(TypeError) { @c1.superclass = Object }
-
-    # but this doesn't make sense.
-    assert_raise(TypeError) { @c1.superclass = Object.new }
-  end
-
-  def test_super_classes
-    rdoc_c3_h1 = @xref_data.find_module_named('C3::H1')
-    rdoc_object = @xref_data.find_module_named('Object')
-    assert_equal [rdoc_c3_h1, rdoc_object, "BasicObject"], @c3_h2.super_classes
-  end
-
-  def test_update_aliases_class
-    n1 = @xref_data.add_module RDoc::NormalClass, 'N1'
-    n1_k2 = n1.add_module RDoc::NormalClass, 'N2'
-
-    a1 = RDoc::Constant.new 'A1', '', ''
-    n1.add_module_alias n1_k2, n1_k2.name, a1, @xref_data
-
-    n1_a1_c = n1.constants.find { |c| c.name == 'A1' }
-    refute_nil n1_a1_c
-    assert_equal n1_k2, n1_a1_c.is_alias_for, 'sanity check'
-
-    n1.update_aliases
-
-    n1_a1_k = @xref_data.find_class_or_module 'N1::A1'
-    refute_nil n1_a1_k
-    assert_equal n1_k2, n1_a1_k.is_alias_for
-    refute_equal n1_k2, n1_a1_k
-
-    assert_equal 1, n1_k2.aliases.length
-    assert_equal n1_a1_k, n1_k2.aliases.first
-
-    assert_equal 'N1::N2', n1_k2.full_name
-    assert_equal 'N1::A1', n1_a1_k.full_name
-  end
-
-  def test_update_aliases_module
-    n1 = @xref_data.add_module RDoc::NormalModule, 'N1'
-    n1_n2 = n1.add_module RDoc::NormalModule, 'N2'
-
-    a1 = RDoc::Constant.new 'A1', '', ''
-    n1.add_module_alias n1_n2, n1_n2.name, a1, @xref_data
-
-    n1_a1_c = n1.constants.find { |c| c.name == 'A1' }
-    refute_nil n1_a1_c
-    assert_equal n1_n2, n1_a1_c.is_alias_for, 'sanity check'
-
-    n1.update_aliases
-
-    n1_a1_m = @xref_data.find_class_or_module 'N1::A1'
-    refute_nil n1_a1_m
-    assert_equal n1_n2, n1_a1_m.is_alias_for
-    refute_equal n1_n2, n1_a1_m
-
-    assert_equal 1, n1_n2.aliases.length
-    assert_equal n1_a1_m, n1_n2.aliases.first
-
-    assert_equal 'N1::N2', n1_n2.full_name
-    assert_equal 'N1::A1', n1_a1_m.full_name
-  end
-
-  def test_update_aliases_reparent
-    l1 = @xref_data.add_module RDoc::NormalModule, 'L1'
-    l1_l2 = l1.add_module RDoc::NormalModule, 'L2'
-    o1 = @xref_data.add_module RDoc::NormalModule, 'O1'
-
-    a1 = RDoc::Constant.new 'A1', '', ''
-    o1.add_module_alias l1_l2, l1_l2.name, a1, @xref_data
-
-    o1_a1_c = o1.constants.find { |c| c.name == 'A1' }
-    refute_nil o1_a1_c
-    assert_equal l1_l2, o1_a1_c.is_alias_for
-    refute_equal l1_l2, o1_a1_c
-
-    o1.update_aliases
-
-    o1_a1_m = @xref_data.find_class_or_module 'O1::A1'
-    refute_nil o1_a1_m
-    assert_equal l1_l2, o1_a1_m.is_alias_for
-
-    assert_equal 1, l1_l2.aliases.length
-    assert_equal o1_a1_m, l1_l2.aliases[0]
-
-    assert_equal 'L1::L2', l1_l2.full_name
-    assert_equal 'O1::A1', o1_a1_m.full_name
-  end
-
-  def test_update_aliases_reparent_root
-    store = RDoc::Store.new(RDoc::Options.new)
-
-    top_level = store.add_file 'file.rb'
-
-    klass  = top_level.add_class RDoc::NormalClass, 'Klass'
-    object = top_level.add_class RDoc::NormalClass, 'Object'
-
-    const = RDoc::Constant.new 'A', nil, ''
-    const.record_location top_level
-    const.is_alias_for = klass
-
-    a = RDoc::Constant.new 'A', '', ''
-    top_level.add_module_alias klass, klass.name, a, top_level
-
-    object.add_constant const
-
-    object.update_aliases
-
-    assert_equal %w[A Klass Object], store.classes_hash.keys.sort
-
-    assert_equal 'A',     store.classes_hash['A'].full_name
-    assert_equal 'Klass', store.classes_hash['Klass'].full_name
-  end
-
-  def test_update_includes
-    a = RDoc::Include.new 'M1', nil
-    b = RDoc::Include.new 'M2', nil
-    c = RDoc::Include.new 'C', nil
-
-    @c1.add_include a
-    @c1.add_include b
-    @c1.add_include c
-    @c1.ancestors # cache included modules
-
-    @m1_m2.document_self = nil
-    assert @m1_m2.remove_from_documentation?
-
-    assert @store.modules_hash.key? @m1_m2.full_name
-    refute @store.modules_hash[@m1_m2.full_name].nil?
-
-    @store.remove_nodoc @store.modules_hash
-    refute @store.modules_hash.key? @m1_m2.full_name
-
-    @c1.update_includes
-
-    assert_equal [a, c], @c1.includes
-  end
-
-  def test_update_includes_trim
-    a = RDoc::Include.new 'D::M', nil
-    b = RDoc::Include.new 'D::M', nil
-
-    @c1.add_include a
-    @c1.add_include b
-    @c1.ancestors # cache included modules
-
-    @c1.update_includes
-
-    assert_equal [a], @c1.includes
-  end
-
-  def test_update_includes_with_colons
-    a = RDoc::Include.new 'M1', nil
-    b = RDoc::Include.new 'M1::M2', nil
-    c = RDoc::Include.new 'C', nil
-
-    @c1.add_include a
-    @c1.add_include b
-    @c1.add_include c
-    @c1.ancestors # cache included modules
-
-    @m1_m2.document_self = nil
-    assert @m1_m2.remove_from_documentation?
-
-    assert @store.modules_hash.key? @m1_m2.full_name
-    refute @store.modules_hash[@m1_m2.full_name].nil?
-    @store.remove_nodoc @store.modules_hash
-    refute @store.modules_hash.key? @m1_m2.full_name
-
-    @c1.update_includes
-
-    assert_equal [a, c], @c1.includes
-  end
-
-  def test_update_extends
-    a = RDoc::Extend.new 'M1', nil
-    b = RDoc::Extend.new 'M2', nil
-    c = RDoc::Extend.new 'C', nil
-
-    @c1.add_extend a
-    @c1.add_extend b
-    @c1.add_extend c
-    @c1.extends.each do |extend| extend.module end # cache extended modules
-
-    @m1_m2.document_self = nil
-    assert @m1_m2.remove_from_documentation?
-
-    assert @store.modules_hash.key? @m1_m2.full_name
-    refute @store.modules_hash[@m1_m2.full_name].nil?
-    @store.remove_nodoc @store.modules_hash
-    refute @store.modules_hash.key? @m1_m2.full_name
-
-    @c1.update_extends
-
-    assert_equal [a, b, c], @c1.extends
-  end
-
-  def test_update_extends_trim
-    a = RDoc::Extend.new 'D::M', nil
-    b = RDoc::Extend.new 'D::M', nil
-
-    @c1.add_extend a
-    @c1.add_extend b
-    @c1.extends.each do |extend| extend.module end # cache extended modules
-
-    @c1.update_extends
-
-    assert_equal [a], @c1.extends
-  end
-
-  def test_update_extends_with_colons
-    a = RDoc::Extend.new 'M1', nil
-    b = RDoc::Extend.new 'M1::M2', nil
-    c = RDoc::Extend.new 'C', nil
-
-    @c1.add_extend a
-    @c1.add_extend b
-    @c1.add_extend c
-    @c1.extends.each do |extend| extend.module end # cache extended modules
-
-    @m1_m2.document_self = nil
-    assert @m1_m2.remove_from_documentation?
-
-    assert @store.modules_hash.key? @m1_m2.full_name
-    refute @store.modules_hash[@m1_m2.full_name].nil?
-
-    @store.remove_nodoc @store.modules_hash
-    refute @store.modules_hash.key? @m1_m2.full_name
-
-    @c1.update_extends
-
-    assert_equal [a, c], @c1.extends
-  end
-
-  def test_nesting_namespaces
-    cm1 = RDoc::ClassModule.new "A"
-    assert_equal ["A"], cm1.nesting_namespaces
-
-    cm2 = RDoc::ClassModule.new "A::B"
-    assert_equal ["A", "B"], cm2.nesting_namespaces
-
-    cm3 = RDoc::ClassModule.new "::A::B::C"
-    assert_equal ["A", "B", "C"], cm3.nesting_namespaces
-  end
-
-  def test_fully_qualified_nesting_namespaces
-    cm1 = RDoc::ClassModule.new "A"
-    assert_equal ["A"], cm1.fully_qualified_nesting_namespaces
-
-    cm2 = RDoc::ClassModule.new "A::B"
-    assert_equal ["A", "A::B"], cm2.fully_qualified_nesting_namespaces
-
-    cm3 = RDoc::ClassModule.new "::A::B::C"
-    assert_equal ["A", "A::B", "A::B::C"], cm3.fully_qualified_nesting_namespaces
-  end
-
-  def test_path
-    assert_equal 'C1.html', @c1.path
-
-    @options.class_module_path_prefix = 'class'
-    assert_equal 'class/C1.html', @c1.path
-  end
-
-  class RDocClassModuleMixinsTest < XrefTestCase
-    def setup
-      super
-
-      klass_tl = @store.add_file("klass.rb")
-      @klass = klass_tl.add_class(RDoc::NormalClass, "Klass")
-
-      incmod_tl = @store.add_file("incmod.rb")
-      @incmod = incmod_tl.add_module(RDoc::NormalModule, "Incmod")
-
-      incmod_const = @incmod.add_constant(RDoc::Constant.new("INCMOD_CONST_WITHOUT_A_SECTION", nil, ""))
-      incmod_const = @incmod.add_constant(RDoc::Constant.new("INCMOD_CONST", nil, ""))
-      incmod_const.section = @incmod.add_section("Incmod const section")
-
-      incmod_method = @incmod.add_method(RDoc::AnyMethod.new(nil, "incmod_method_without_a_section"))
-      incmod_method = @incmod.add_method(RDoc::AnyMethod.new(nil, "incmod_method"))
-      incmod_method.section = @incmod.add_section("Incmod method section")
-
-      incmod_attr = @incmod.add_attribute(RDoc::Attr.new(nil, "incmod_attr_without_a_section", "RW", ""))
-      incmod_attr = @incmod.add_attribute(RDoc::Attr.new(nil, "incmod_attr", "RW", ""))
-      incmod_attr.section = @incmod.add_section("Incmod attr section")
-
-      incmod_private_method = @incmod.add_method(RDoc::AnyMethod.new(nil, "incmod_private_method"))
-      incmod_private_method.visibility = :private
-
-      incmod_private_attr = @incmod.add_attribute(RDoc::Attr.new(nil, "incmod_private_attr", "RW", ""))
-      incmod_private_attr.visibility = :private
-
-      extmod_tl = @store.add_file("extmod.rb")
-      @extmod = extmod_tl.add_module(RDoc::NormalModule, "Extmod")
-
-      extmod_method = @extmod.add_method(RDoc::AnyMethod.new(nil, "extmod_method_without_a_section"))
-      extmod_method = @extmod.add_method(RDoc::AnyMethod.new(nil, "extmod_method"))
-      extmod_method.section = @extmod.add_section("Extmod method section")
-
-      extmod_attr = @extmod.add_attribute(RDoc::Attr.new(nil, "extmod_attr_without_a_section", "RW", "", singleton: true))
-      extmod_attr = @extmod.add_attribute(RDoc::Attr.new(nil, "extmod_attr", "RW", "", singleton: true))
-      extmod_attr.section = @extmod.add_section("Extmod attr section")
-
-      extmod_private_method = @extmod.add_method(RDoc::AnyMethod.new(nil, "extmod_private_method"))
-      extmod_private_method.visibility = :private
-
-      extmod_private_attr = @extmod.add_attribute(RDoc::Attr.new(nil, "extmod_private_attr", "RW", "", singleton: true))
-      extmod_private_attr.visibility = :private
-
-      @klass.add_include(RDoc::Include.new("Incmod", nil))
-      @klass.add_extend(RDoc::Include.new("Extmod", nil))
-
-      @klass.add_include(RDoc::Include.new("ExternalInclude", nil))
-      # Test duplicationg removal
-      @klass.add_include(RDoc::Include.new("ExternalInclude", nil))
-
-      @klass.add_extend(RDoc::Include.new("ExternalExtend", nil))
-      # Test duplicationg removal
-      @klass.add_extend(RDoc::Include.new("ExternalExtend", nil))
-    end
-
-    def test_complete_clears_duplicated_includes_and_extends
-      @klass.complete(:protected)
-
-      assert_equal(["Incmod", "ExternalInclude"], @klass.includes.map(&:name))
-      assert_equal(["Extmod", "ExternalExtend"], @klass.extends.map(&:name))
-    end
-
-    def test_embed_mixin_when_false_does_not_embed_anything
-      assert_false(@klass.options.embed_mixins)
-      @klass.complete(:protected)
-
-      refute_includes(@klass.constants.map(&:name), "INCMOD_CONST")
-      refute_includes(@klass.method_list.map(&:name), "incmod_method")
-      refute_includes(@klass.method_list.map(&:name), "extmod_method")
-      refute_includes(@klass.attributes.map(&:name), "incmod_attr")
-      refute_includes(@klass.attributes.map(&:name), "extmod_attr")
-    end
-
-    def test_embed_mixin_when_true_embeds_methods_and_constants
-      @klass.options.embed_mixins = true
-      @klass.complete(:protected)
-
-      # assert on presence and identity of methods and constants
-      constant = @klass.constants.find { |c| c.name == "INCMOD_CONST" }
-      assert(constant, "constant from included mixin should be present")
-      assert_equal(@incmod, constant.mixin_from)
-
-      instance_method = @klass.method_list.find { |m| m.name == "incmod_method" }
-      assert(instance_method, "instance method from included mixin should be present")
-      refute(instance_method.singleton)
-      assert_equal(@incmod, instance_method.mixin_from)
-
-      instance_attr = @klass.attributes.find { |a| a.name == "incmod_attr" }
-      assert(instance_attr, "instance attr from included mixin should be present")
-      refute(instance_attr.singleton)
-      assert_equal(@incmod, instance_attr.mixin_from)
-
-      refute(@klass.method_list.find { |m| m.name == "incmod_private_method" })
-      refute(@klass.attributes.find { |m| m.name == "incmod_private_attr" })
-
-      class_method = @klass.method_list.find { |m| m.name == "extmod_method" }
-      assert(class_method, "class method from extended mixin should be present")
-      assert(class_method.singleton)
-      assert_equal(@extmod, class_method.mixin_from)
-
-      class_attr = @klass.attributes.find { |a| a.name == "extmod_attr" }
-      assert(class_attr, "class attr from extended mixin should be present")
-      assert(class_attr.singleton)
-      assert_equal(@extmod, class_attr.mixin_from)
-
-      refute(@klass.method_list.find { |m| m.name == "extmod_private_method" })
-      refute(@klass.attributes.find { |m| m.name == "extmod_private_attr" })
-
-      # assert that sections are also imported
-      constant_section = @klass.sections.find { |s| s.title == "Incmod const section" }
-      assert(constant_section, "constant from included mixin should have a section")
-      assert_equal(constant_section, constant.section)
-
-      instance_method_section = @klass.sections.find { |s| s.title == "Incmod method section" }
-      assert(instance_method_section, "instance method from included mixin should have a section")
-      assert_equal(instance_method_section, instance_method.section)
-
-      instance_attr_section = @klass.sections.find { |s| s.title == "Incmod attr section" }
-      assert(instance_attr_section, "instance attr from included mixin should have a section")
-      assert_equal(instance_attr_section, instance_attr.section)
-
-      class_method_section = @klass.sections.find { |s| s.title == "Extmod method section" }
-      assert(class_method_section, "class method from extended mixin should have a section")
-      assert_equal(class_method_section, class_method.section)
-
-      class_attr_section = @klass.sections.find { |s| s.title == "Extmod attr section" }
-      assert(class_attr_section, "class attr from extended mixin should have a section")
-      assert_equal(class_attr_section, class_attr.section)
-
-      # and check that code objects without a section still have no section
-      constant = @klass.constants.find { |c| c.name == "INCMOD_CONST_WITHOUT_A_SECTION" }
-      assert_nil(constant.section.title)
-
-      instance_method = @klass.method_list.find { |c| c.name == "incmod_method_without_a_section" }
-      assert_nil(instance_method.section.title)
-
-      instance_attr = @klass.attributes.find { |c| c.name == "incmod_attr_without_a_section" }
-      assert_nil(instance_attr.section.title)
-
-      class_method = @klass.method_list.find { |c| c.name == "extmod_method_without_a_section" }
-      assert_nil(class_method.section.title)
-
-      class_attr = @klass.attributes.find { |c| c.name == "extmod_attr_without_a_section" }
-      assert_nil(class_attr.section.title)
-    end
-  end
-end
diff --git a/test/mri/rdoc/rdoc_code_object_test.rb b/test/mri/rdoc/rdoc_code_object_test.rb
deleted file mode 100644
index af5c34257c6..00000000000
--- a/test/mri/rdoc/rdoc_code_object_test.rb
+++ /dev/null
@@ -1,416 +0,0 @@
-# coding: US-ASCII
-# frozen_string_literal: true
-
-require_relative 'xref_test_case'
-
-class RDocCodeObjectTest < XrefTestCase
-
-  def setup
-    super
-
-    @co = RDoc::CodeObject.new
-  end
-
-  def test_initialize
-    assert @co.document_self, 'document_self'
-    assert @co.document_children, 'document_children'
-    refute @co.force_documentation, 'force_documentation'
-    refute @co.done_documenting, 'done_documenting'
-    refute @co.received_nodoc, 'received_nodoc'
-    assert_equal '', @co.comment, 'comment is empty'
-  end
-
-  def test_comment_equals
-    @co.comment = ''
-
-    assert_equal '', @co.comment
-
-    @co.comment = 'I am a comment'
-
-    assert_equal 'I am a comment', @co.comment
-  end
-
-  def test_comment_equals_comment
-    @co.comment = comment ''
-
-    assert_equal '', @co.comment.text
-
-    @co.comment = comment 'I am a comment'
-
-    assert_equal 'I am a comment', @co.comment.text
-  end
-
-  def test_comment_equals_empty_string
-    @co.comment = 'comment'
-
-    @co.comment = ''
-
-    assert_equal 'comment', @co.comment
-  end
-
-  def test_comment_equals_encoding
-    refute_equal Encoding::UTF_8, ''.encoding, 'Encoding sanity check'
-
-    input = 'text'
-    input = RDoc::Encoding.change_encoding input, Encoding::UTF_8
-
-    @co.comment = input
-
-    assert_equal 'text', @co.comment
-    assert_equal Encoding::UTF_8, @co.comment.encoding
-  end
-
-  def test_comment_equals_encoding_blank
-    refute_equal Encoding::UTF_8, ''.encoding, 'Encoding sanity check'
-
-    input = ''
-    input = RDoc::Encoding.change_encoding input, Encoding::UTF_8
-
-    @co.comment = input
-
-    assert_equal '', @co.comment
-    assert_equal Encoding::UTF_8, @co.comment.encoding
-  end
-
-  def test_display_eh_document_self
-    assert @co.display?
-
-    @co.document_self = false
-
-    refute @co.display?
-  end
-
-  def test_display_eh_ignore
-    assert @co.display?
-
-    @co.ignore
-
-    refute @co.display?
-
-    @co.stop_doc
-
-    refute @co.display?
-
-    @co.done_documenting = false
-
-    refute @co.display?
-  end
-
-  def test_display_eh_suppress
-    assert @co.display?
-
-    @co.suppress
-
-    refute @co.display?
-
-    @co.comment = comment('hi')
-
-    refute @co.display?
-
-    @co.done_documenting = false
-
-    assert @co.display?
-
-    @co.ignore
-    @co.done_documenting = false
-
-    refute @co.display?
-  end
-
-  def test_document_children_equals
-    @co.document_children = false
-
-    refute @co.document_children
-
-    @store.options.visibility = :nodoc
-
-    @co.store = @store
-
-    assert @co.document_children
-
-    @co.document_children = false
-
-    assert @co.document_children
-  end
-
-  def test_document_self_equals
-    @co.document_self = false
-    refute @co.document_self
-
-    @store.options.visibility = :nodoc
-
-    @co.store = @store
-
-    assert @co.document_self
-
-    @co.document_self = false
-
-    assert @co.document_self
-  end
-
-  def test_documented_eh
-    refute @co.documented?
-
-    @co.comment = 'hi'
-
-    assert @co.documented?
-
-    @co.comment.replace ''
-
-    refute @co.documented?
-
-    @co.document_self = nil # notify :nodoc:
-
-    assert @co.documented?
-  end
-
-  def test_done_documenting
-    # once done_documenting is set, other properties refuse to go to "true"
-    @co.done_documenting = true
-
-    @co.document_self = true
-    refute @co.document_self
-
-    @co.document_children = true
-    refute @co.document_children
-
-    @co.force_documentation = true
-    refute @co.force_documentation
-
-    @co.start_doc
-    refute @co.document_self
-    refute @co.document_children
-
-    # turning done_documenting on
-    # resets others to true
-
-    @co.done_documenting = false
-    assert @co.document_self
-    assert @co.document_children
-
-    @co.done_documenting = true
-
-    @store.options.visibility = :nodoc
-
-    @co.store = @store
-
-    refute @co.done_documenting
-
-    @co.done_documenting = true
-
-    refute @co.done_documenting
-  end
-
-  def test_file_name
-    assert_nil @co.file_name
-
-    @co.record_location @store.add_file 'lib/file.rb'
-
-    assert_equal 'lib/file.rb', @co.file_name
-  end
-
-  def test_full_name_equals
-    @co.full_name = 'hi'
-
-    assert_equal 'hi', @co.instance_variable_get(:@full_name)
-
-    @co.full_name = nil
-
-    assert_nil @co.instance_variable_get(:@full_name)
-  end
-
-  def test_ignore
-    @co.ignore
-
-    refute @co.document_self
-    refute @co.document_children
-    assert @co.ignored?
-
-    @store.options.visibility = :nodoc
-
-    @co.store = @store
-
-    assert @co.document_self
-    assert @co.document_children
-    refute @co.ignored?
-
-    @co.ignore
-
-    refute @co.ignored?
-  end
-
-  def test_ignore_eh
-    refute @co.ignored?
-
-    @co.ignore
-
-    assert @co.ignored?
-  end
-
-  def test_line
-    @c1_m.line = 5
-
-    assert_equal 5, @c1_m.line
-  end
-
-  def test_metadata
-    assert_empty @co.metadata
-
-    @co.metadata['markup'] = 'not_rdoc'
-
-    expected = { 'markup' => 'not_rdoc' }
-
-    assert_equal expected, @co.metadata
-
-    assert_equal 'not_rdoc', @co.metadata['markup']
-  end
-
-  def test_parent_name
-    assert_equal '(unknown)', @co.parent_name
-    assert_equal 'xref_data.rb', @c1.parent_name
-    assert_equal 'C2', @c2_c3.parent_name
-  end
-
-  def test_received_ndoc
-    @co.document_self = false
-    refute @co.received_nodoc
-
-    @co.document_self = nil
-    assert @co.received_nodoc
-
-    @co.document_self = true
-  end
-
-  def test_record_location
-    @co.record_location @xref_data
-
-    assert_equal 'xref_data.rb', @co.file.relative_name
-  end
-
-  def test_record_location_ignored
-    @co.ignore
-    @co.record_location @xref_data
-
-    refute @co.ignored?
-  end
-
-  def test_record_location_suppressed
-    @co.suppress
-    @co.record_location @xref_data
-
-    refute @co.suppressed?
-  end
-
-  def test_section
-    parent = RDoc::Context.new
-    section = parent.sections.first
-
-    @co.parent = parent
-    @co.instance_variable_set :@section, section
-
-    assert_equal section, @co.section
-
-    @co.instance_variable_set :@section, nil
-    @co.instance_variable_set :@section_title, nil
-
-    assert_equal section, @co.section
-
-    @co.instance_variable_set :@section, nil
-    @co.instance_variable_set :@section_title, 'new title'
-
-    assert_equal 'new title', @co.section.title
-  end
-
-  def test_start_doc
-    @co.document_self = false
-    @co.document_children = false
-
-    @co.start_doc
-
-    assert @co.document_self
-    assert @co.document_children
-  end
-
-  def test_start_doc_ignored
-    @co.ignore
-
-    @co.start_doc
-
-    assert @co.document_self
-    assert @co.document_children
-    refute @co.ignored?
-  end
-
-  def test_start_doc_suppressed
-    @co.suppress
-
-    @co.start_doc
-
-    assert @co.document_self
-    assert @co.document_children
-    refute @co.suppressed?
-  end
-
-  def test_store_equals
-    @co.document_self = false
-
-    @co.store = @store
-
-    refute @co.document_self
-
-    @store.options.visibility = :nodoc
-
-    @co.store = @store
-
-    assert @co.document_self
-  end
-
-  def test_stop_doc
-    @co.document_self = true
-    @co.document_children = true
-
-    @co.stop_doc
-
-    refute @co.document_self
-    refute @co.document_children
-
-    @store.options.visibility = :nodoc
-
-    @co.store = @store
-
-    assert @co.document_self
-    assert @co.document_children
-
-    @co.stop_doc
-
-    assert @co.document_self
-    assert @co.document_children
-  end
-
-  def test_suppress
-    @co.suppress
-
-    refute @co.document_self
-    refute @co.document_children
-    assert @co.suppressed?
-
-    @store.options.visibility = :nodoc
-
-    @co.store = @store
-
-    refute @co.suppressed?
-
-    @co.suppress
-
-    refute @co.suppressed?
-  end
-
-  def test_suppress_eh
-    refute @co.suppressed?
-
-    @co.suppress
-
-    assert @co.suppressed?
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc_comment_test.rb b/test/mri/rdoc/rdoc_comment_test.rb
deleted file mode 100644
index 1699575b9df..00000000000
--- a/test/mri/rdoc/rdoc_comment_test.rb
+++ /dev/null
@@ -1,480 +0,0 @@
-# coding: us-ascii
-# frozen_string_literal: true
-
-require_relative 'helper'
-
-class RDocCommentTest < RDoc::TestCase
-
-  def setup
-    super
-
-    @top_level = @store.add_file 'file.rb'
-    @comment = RDoc::Comment.new
-    @comment.location = @top_level
-    @comment.text = 'this is a comment'
-  end
-
-  def test_empty
-    @comment.text = ''
-    assert_empty @comment
-    empty_doc = @comment.parse
-    assert_empty @comment
-    @comment.text = 'a'
-    refute_empty @comment
-    present_doc = @comment.parse
-    refute_empty @comment
-    assert_empty RDoc::Comment.from_document(empty_doc)
-    refute_empty RDoc::Comment.from_document(present_doc)
-  end
-
-  def test_equals2
-    assert_equal @comment, @comment.dup
-
-    c2 = @comment.dup
-    c2.text = nil
-
-    refute_equal @comment, c2
-
-    c3 = @comment.dup
-    c3.location = nil
-
-    refute_equal @comment, c3
-  end
-
-  def test_extract_call_seq
-    comment = RDoc::Comment.new <<-COMMENT, @top_level
-call-seq:
-  bla => true or false
-
-moar comment
-    COMMENT
-
-    assert_equal "bla => true or false\n", comment.extract_call_seq
-  end
-
-  def test_extract_call_seq_blank
-    comment = RDoc::Comment.new <<-COMMENT, @top_level
-call-seq:
-  bla => true or false
-
-    COMMENT
-
-    assert_equal "bla => true or false\n", comment.extract_call_seq
-  end
-
-  def test_extract_call_seq_commented
-    comment = RDoc::Comment.new <<-COMMENT, @top_level
-# call-seq:
-#   bla => true or false
-#
-# moar comment
-    COMMENT
-
-    assert_nil comment.extract_call_seq
-  end
-
-  def test_extract_call_seq_no_blank
-    comment = RDoc::Comment.new <<-COMMENT, @top_level
-call-seq:
-  bla => true or false
-    COMMENT
-
-    assert_equal "bla => true or false\n", comment.extract_call_seq
-  end
-
-  def test_extract_call_seq_undent
-    comment = RDoc::Comment.new <<-COMMENT, @top_level
-call-seq:
-  bla => true or false
-moar comment
-    COMMENT
-
-    assert_equal "bla => true or false\nmoar comment\n", comment.extract_call_seq
-  end
-
-  def test_extract_call_seq_c
-    comment = RDoc::Comment.new <<-COMMENT
-call-seq:
-  commercial() -> Date <br />
-  commercial(cwyear, cweek=41, cwday=5, sg=nil) -> Date [ruby 1.8] <br />
-  commercial(cwyear, cweek=1, cwday=1, sg=nil) -> Date [ruby 1.9]
-
-If no arguments are given:
-* ruby 1.8: returns a +Date+ for 1582-10-15 (the Day of Calendar Reform in
-  Italy)
-* ruby 1.9: returns a +Date+ for julian day 0
-
-Otherwise, returns a +Date+ for the commercial week year, commercial week,
-and commercial week day given. Ignores the 4th argument.
-    COMMENT
-
-    expected = <<-CALL_SEQ.chomp
-commercial() -> Date <br />
-commercial(cwyear, cweek=41, cwday=5, sg=nil) -> Date [ruby 1.8] <br />
-commercial(cwyear, cweek=1, cwday=1, sg=nil) -> Date [ruby 1.9]
-
-    CALL_SEQ
-
-    assert_equal expected, comment.extract_call_seq
-  end
-
-  def test_extract_call_seq_c_no_blank
-    comment = RDoc::Comment.new <<-COMMENT
-call-seq:
-  commercial() -> Date <br />
-  commercial(cwyear, cweek=41, cwday=5, sg=nil) -> Date [ruby 1.8] <br />
-  commercial(cwyear, cweek=1, cwday=1, sg=nil) -> Date [ruby 1.9]
-    COMMENT
-
-    expected = <<-CALL_SEQ.chomp
-commercial() -> Date <br />
-commercial(cwyear, cweek=41, cwday=5, sg=nil) -> Date [ruby 1.8] <br />
-commercial(cwyear, cweek=1, cwday=1, sg=nil) -> Date [ruby 1.9]
-
-    CALL_SEQ
-
-    assert_equal expected, comment.extract_call_seq
-  end
-
-  def test_extract_call_seq_c_separator
-    comment = RDoc::Comment.new <<-'COMMENT'
-call-seq:
-   ARGF.readlines(sep=$/)     -> array
-   ARGF.readlines(limit)      -> array
-   ARGF.readlines(sep, limit) -> array
-
-   ARGF.to_a(sep=$/)     -> array
-   ARGF.to_a(limit)      -> array
-   ARGF.to_a(sep, limit) -> array
-
-Reads +ARGF+'s current file in its entirety, returning an +Array+ of its
-lines, one line per element. Lines are assumed to be separated by _sep_.
-
-   lines = ARGF.readlines
-   lines[0]                #=> "This is line one\n"
-
-    COMMENT
-
-    expected = <<-CALL_SEQ
-ARGF.readlines(sep=$/)     -> array
-ARGF.readlines(limit)      -> array
-ARGF.readlines(sep, limit) -> array
-ARGF.to_a(sep=$/)     -> array
-ARGF.to_a(limit)      -> array
-ARGF.to_a(sep, limit) -> array
-    CALL_SEQ
-
-    assert_equal expected, comment.extract_call_seq
-
-    expected = <<-'COMMENT'
-
-Reads +ARGF+'s current file in its entirety, returning an +Array+ of its
-lines, one line per element. Lines are assumed to be separated by _sep_.
-
-   lines = ARGF.readlines
-   lines[0]                #=> "This is line one\n"
-
-    COMMENT
-
-    assert_equal expected, comment.text
-  end
-
-  # This test relies on AnyMethod#call_seq's behaviour as well
-  def test_extract_call_linear_performance
-    pre = ->(n) {[n, RDoc::Comment.new("\n"*n + 'call-seq:' + 'a'*n)]}
-    method_obj = RDoc::AnyMethod.new nil, 'blah'
-    assert_linear_performance((2..5).map {|i| 10**i}, pre: pre) do |n, comment|
-      method_obj.call_seq = comment.extract_call_seq
-      assert_equal n, method_obj.call_seq.size
-    end
-  end
-
-  def test_force_encoding
-    @comment = RDoc::Encoding.change_encoding @comment, Encoding::UTF_8
-
-    assert_equal Encoding::UTF_8, @comment.text.encoding
-  end
-
-  def test_format
-    assert_equal 'rdoc', @comment.format
-  end
-
-  def test_format_equals
-    c = comment 'content'
-    document = c.parse
-
-    c.format = RDoc::RD
-
-    assert_equal RDoc::RD, c.format
-    refute_same document, c.parse
-  end
-
-  def test_initialize_copy
-    copy = @comment.dup
-
-    refute_same @comment.text, copy.text
-    assert_same @comment.location, copy.location
-  end
-
-  def test_location
-    assert_equal @top_level, @comment.location
-  end
-
-  def test_normalize
-    @comment.text = <<-TEXT
-  # comment
-    TEXT
-    @comment.language = :ruby
-
-    assert_same @comment, @comment.normalize
-
-    assert_equal 'comment', @comment.text
-  end
-
-  def test_normalize_twice
-    @comment.text = <<-TEXT
-  # comment
-    TEXT
-
-    @comment.normalize
-
-    text = @comment.text
-
-    @comment.normalize
-
-    assert_same text, @comment.text, 'normalize not cached'
-  end
-
-  def test_normalize_document
-    @comment.text = nil
-    @comment.document = @RM::Document.new
-
-    assert_same @comment, @comment.normalize
-
-    assert_nil @comment.text
-  end
-
-  def test_normalize_eh
-    refute @comment.normalized?
-
-    @comment.normalize
-
-    assert @comment.normalized?
-  end
-
-  def test_text
-    assert_equal 'this is a comment', @comment.text
-  end
-
-  def test_text_equals
-    @comment.text = 'other'
-
-    assert_equal 'other', @comment.text
-    refute @comment.normalized?
-  end
-
-  def test_text_equals_no_text
-    c = RDoc::Comment.new nil, @top_level
-    c.document = @RM::Document.new
-
-    e = assert_raise RDoc::Error do
-      c.text = 'other'
-    end
-
-    assert_equal 'replacing document-only comment is not allowed', e.message
-  end
-
-  def test_text_equals_parsed
-    document = @comment.parse
-
-    @comment.text = 'other'
-
-    refute_equal document, @comment.parse
-  end
-
-  def test_tomdoc_eh
-    refute @comment.tomdoc?
-
-    @comment.format = 'tomdoc'
-
-    assert @comment.tomdoc?
-  end
-
-  def test_parse
-    parsed = @comment.parse
-
-    expected = @RM::Document.new(
-      @RM::Paragraph.new('this is a comment'))
-
-    expected.file = @top_level
-
-    assert_equal expected, parsed
-    assert_same  parsed, @comment.parse
-  end
-
-  def test_parse_rd
-    c = comment 'it ((*works*))'
-    c.format = 'rd'
-
-    expected =
-      @RM::Document.new(
-        @RM::Paragraph.new('it <em>works</em>'))
-    expected.file = @top_level
-
-    assert_equal expected, c.parse
-  end
-
-  def test_remove_private_encoding
-    comment = RDoc::Comment.new <<-EOS, @top_level
-# This is text
-#--
-# this is private
-    EOS
-
-    comment = RDoc::Encoding.change_encoding comment, Encoding::IBM437
-
-    comment.remove_private
-
-    assert_equal Encoding::IBM437, comment.text.encoding
-  end
-
-  def test_remove_private_hash
-    @comment.text = <<-TEXT
-#--
-# private
-#++
-# public
-    TEXT
-
-    @comment.remove_private
-
-    assert_equal "# public\n", @comment.text
-  end
-
-  def test_remove_private_hash_trail
-    comment = RDoc::Comment.new <<-EOS, @top_level
-# This is text
-#--
-# this is private
-    EOS
-
-    expected = RDoc::Comment.new <<-EOS, @top_level
-# This is text
-    EOS
-
-    comment.remove_private
-
-    assert_equal expected, comment
-  end
-
-  def test_remove_private_long
-    comment = RDoc::Comment.new <<-EOS, @top_level
-#-----
-#++
-# this is text
-#-----
-    EOS
-
-    expected = RDoc::Comment.new <<-EOS, @top_level
-# this is text
-    EOS
-
-    comment.remove_private
-
-    assert_equal expected, comment
-  end
-
-  def test_remove_private_rule
-    comment = RDoc::Comment.new <<-EOS, @top_level
-# This is text with a rule:
-# ---
-# this is also text
-    EOS
-
-    expected = comment.dup
-
-    comment.remove_private
-
-    assert_equal expected, comment
-  end
-
-  def test_remove_private_star
-    @comment.text = <<-TEXT
-/*
- *--
- * private
- *++
- * public
- */
-    TEXT
-
-    @comment.remove_private
-
-    assert_equal "/*\n * public\n */\n", @comment.text
-  end
-
-  def test_remove_private_star2
-    @comment.text = <<-TEXT
-/*--
- * private
- *++
- * public
- */
-    TEXT
-
-    @comment.remove_private
-
-    assert_equal "/*--\n * private\n *++\n * public\n */\n", @comment.text
-  end
-
-  def test_remove_private_toggle
-    comment = RDoc::Comment.new <<-EOS, @top_level
-# This is text
-#--
-# this is private
-#++
-# This is text again.
-    EOS
-
-    expected = RDoc::Comment.new <<-EOS, @top_level
-# This is text
-# This is text again.
-    EOS
-
-    comment.remove_private
-
-    assert_equal expected, comment
-  end
-
-  def test_remove_private_toggle_encoding
-    comment = RDoc::Comment.new <<-EOS, @top_level
-# This is text
-#--
-# this is private
-#++
-# This is text again.
-    EOS
-
-    comment = RDoc::Encoding.change_encoding comment, Encoding::IBM437
-
-    comment.remove_private
-
-    assert_equal Encoding::IBM437, comment.text.encoding
-  end
-
-  def test_remove_private_toggle_encoding_ruby_bug?
-    comment = RDoc::Comment.new <<-EOS, @top_level
-#--
-# this is private
-#++
-# This is text again.
-    EOS
-
-    comment = RDoc::Encoding.change_encoding comment, Encoding::IBM437
-
-    comment.remove_private
-
-    assert_equal Encoding::IBM437, comment.text.encoding
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc_constant_test.rb b/test/mri/rdoc/rdoc_constant_test.rb
deleted file mode 100644
index f9f795101c2..00000000000
--- a/test/mri/rdoc/rdoc_constant_test.rb
+++ /dev/null
@@ -1,182 +0,0 @@
-# frozen_string_literal: true
-require_relative 'xref_test_case'
-
-class RDocConstantTest < XrefTestCase
-
-  def setup
-    super
-
-    @const = @c1.constants.first
-  end
-
-  def test_documented_eh
-    top_level = @store.add_file 'file.rb'
-
-    const = RDoc::Constant.new 'CONST', nil, nil
-    top_level.add_constant const
-
-    refute const.documented?
-
-    const.comment = comment 'comment'
-
-    assert const.documented?
-  end
-
-  def test_documented_eh_alias
-    top_level = @store.add_file 'file.rb'
-
-    const = RDoc::Constant.new 'CONST', nil, nil
-    top_level.add_constant const
-
-    refute const.documented?
-
-    const.is_alias_for = 'C1'
-
-    refute const.documented?
-
-    @c1.add_comment comment('comment'), @top_level
-
-    assert const.documented?
-  end
-
-  def test_full_name
-    assert_equal 'C1::CONST', @const.full_name
-  end
-
-  def test_is_alias_for
-    top_level = @store.add_file 'file.rb'
-
-    c = RDoc::Constant.new 'CONST', nil, 'comment'
-    top_level.add_constant c
-
-    assert_nil c.is_alias_for
-
-    c.is_alias_for = 'C1'
-
-    assert_equal @c1, c.is_alias_for
-
-    c.is_alias_for = 'unknown'
-
-    assert_equal 'unknown', c.is_alias_for
-  end
-
-  def test_marshal_dump
-    top_level = @store.add_file 'file.rb'
-
-    c = RDoc::Constant.new 'CONST', nil, 'this is a comment'
-    c.record_location top_level
-
-    aliased = top_level.add_class RDoc::NormalClass, 'Aliased'
-    c.is_alias_for = aliased
-
-    cm = top_level.add_class RDoc::NormalClass, 'Klass'
-    cm.add_constant c
-
-    section = cm.sections.first
-
-    loaded = Marshal.load Marshal.dump c
-    loaded.store = @store
-
-    document = doc(para('this is a comment'))
-
-    assert_equal c, loaded
-
-    assert_equal aliased,        loaded.is_alias_for
-    assert_equal document,       loaded.comment.parse
-    assert_equal top_level,      loaded.file
-    assert_equal 'Klass::CONST', loaded.full_name
-    assert_equal 'CONST',        loaded.name
-    assert_equal :public,        loaded.visibility
-    assert_equal cm,             loaded.parent
-    assert_equal section,        loaded.section
-  end
-
-  def test_marshal_load
-    top_level = @store.add_file 'file.rb'
-
-    c = RDoc::Constant.new 'CONST', nil, 'this is a comment'
-    c.record_location top_level
-
-    cm = top_level.add_class RDoc::NormalClass, 'Klass'
-    cm.add_constant c
-
-    section = cm.sections.first
-
-    loaded = Marshal.load Marshal.dump c
-    loaded.store = @store
-
-    document = doc(para('this is a comment'))
-
-    assert_equal c, loaded
-
-    assert_nil                   loaded.is_alias_for
-    assert_equal document,       loaded.comment.parse
-    assert_equal top_level,      loaded.file
-    assert_equal 'Klass::CONST', loaded.full_name
-    assert_equal 'CONST',        loaded.name
-    assert_equal :public,        loaded.visibility
-    assert_equal cm,             loaded.parent
-    assert_equal section,        loaded.section
-
-    assert                       loaded.display?
-  end
-
-  def test_marshal_load_version_0
-    top_level = @store.add_file 'file.rb'
-
-    aliased = top_level.add_class RDoc::NormalClass, 'Aliased'
-    cm      = top_level.add_class RDoc::NormalClass, 'Klass'
-    section = cm.sections.first
-
-    loaded = Marshal.load "\x04\bU:\x13RDoc::Constant[\x0Fi\x00I" +
-                          "\"\nCONST\x06:\x06ETI\"\x11Klass::CONST\x06" +
-                          ";\x06T0I\"\fAliased\x06;\x06To" +
-                          ":\eRDoc::Markup::Document\a:\v@parts[\x06o" +
-                          ":\x1CRDoc::Markup::Paragraph\x06;\b[\x06I" +
-                          "\"\x16this is a comment\x06;\x06T:\n@file0I" +
-                          "\"\ffile.rb\x06;\x06TI\"\nKlass\x06" +
-                          ";\x06Tc\x16RDoc::NormalClass0"
-
-    loaded.store = @store
-
-    document = doc(para('this is a comment'))
-
-    assert_equal aliased,        loaded.is_alias_for
-    assert_equal document,       loaded.comment.parse
-    assert_equal top_level,      loaded.file
-    assert_equal 'Klass::CONST', loaded.full_name
-    assert_equal 'CONST',        loaded.name
-    assert_equal :public,        loaded.visibility
-    assert_equal cm,             loaded.parent
-    assert_equal section,        loaded.section
-
-    assert loaded.display?
-  end
-
-  def test_marshal_round_trip
-    top_level = @store.add_file 'file.rb'
-
-    c = RDoc::Constant.new 'CONST', nil, 'this is a comment'
-    c.record_location top_level
-    c.is_alias_for = 'Unknown'
-
-    cm = top_level.add_class RDoc::NormalClass, 'Klass'
-    cm.add_constant c
-
-    section = cm.sections.first
-
-    loaded = Marshal.load Marshal.dump c
-    loaded.store = @store
-
-    reloaded = Marshal.load Marshal.dump loaded
-    reloaded.store = @store
-
-    assert_equal section,   reloaded.section
-    assert_equal 'Unknown', reloaded.is_alias_for
-  end
-
-  def test_path
-    assert_equal 'C1.html#CONST', @const.path
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc_context_section_test.rb b/test/mri/rdoc/rdoc_context_section_test.rb
deleted file mode 100644
index 179ea95014c..00000000000
--- a/test/mri/rdoc/rdoc_context_section_test.rb
+++ /dev/null
@@ -1,145 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocContextSectionTest < RDoc::TestCase
-
-  def setup
-    super
-
-    @top_level = @store.add_file 'file.rb'
-
-    @klass = @top_level.add_class RDoc::NormalClass, 'Object'
-
-    @S = RDoc::Context::Section
-    @s = @S.new @klass, 'section', comment('# comment', @top_level, :ruby)
-  end
-
-  def test_add_comment
-    file1 = @store.add_file 'file1.rb'
-
-    klass = file1.add_class RDoc::NormalClass, 'Klass'
-
-    c1 = RDoc::Comment.new "# :section: section\n", file1
-    c2 = RDoc::Comment.new "# hello\n",             file1
-    c3 = RDoc::Comment.new "# world\n",             file1
-
-    s = @S.new klass, 'section', c1
-
-    assert_empty s.comments
-
-    s.add_comment nil
-
-    assert_empty s.comments
-
-    s.add_comment c2
-
-    assert_equal [c2], s.comments
-
-    s.add_comment c3
-
-    assert_equal [c2, c3], s.comments
-  end
-
-  def test_aref
-    assert_equal 'section', @s.aref
-
-    assert_equal '5Buntitled-5D', @S.new(nil, nil, nil).aref
-
-    assert_equal 'one+two', @S.new(nil, 'one two', nil).aref
-  end
-
-  def test_eql_eh
-    other = @S.new @klass, 'other', comment('# comment', @top_level)
-
-    assert @s.eql? @s
-    assert @s.eql? @s.dup
-    refute @s.eql? other
-  end
-
-  def test_equals
-    other = @S.new @klass, 'other', comment('# comment', @top_level)
-
-    assert_equal @s, @s
-    assert_equal @s, @s.dup
-    refute_equal @s, other
-  end
-
-  def test_extract_comment
-    assert_equal '',    @s.extract_comment(comment('')).text
-    assert_equal '',    @s.extract_comment(comment("# :section: b\n")).text
-    assert_equal '# c', @s.extract_comment(comment("# :section: b\n# c")).text
-    assert_equal '# c',
-                 @s.extract_comment(comment("# a\n# :section: b\n# c")).text
-  end
-
-  def test_hash
-    other = @S.new @klass, 'other', comment('# comment', @top_level)
-
-    assert_equal @s.hash, @s.hash
-    assert_equal @s.hash, @s.dup.hash
-    refute_equal @s.hash, other.hash
-  end
-
-  def test_marshal_dump
-    loaded = Marshal.load Marshal.dump @s
-
-    expected = doc RDoc::Comment.new('comment', @top_level).parse
-
-    assert_equal 'section', loaded.title
-    assert_equal expected,  loaded.parse
-    assert_nil              loaded.parent, 'parent is set manually'
-  end
-
-  def test_marshal_dump_no_comment
-    s = @S.new @klass, 'section', comment('')
-
-    loaded = Marshal.load Marshal.dump s
-
-    assert_equal 'section', loaded.title
-    assert_empty            loaded.comments
-    assert_nil              loaded.parent, 'parent is set manually'
-  end
-
-  def test_marshal_load_version_0
-    loaded = Marshal.load "\x04\bU:\eRDoc::Context::Section" +
-                          "[\bi\x00I\"\fsection\x06:\x06EFo" +
-                          ":\eRDoc::Markup::Document\a:\v@parts" +
-                          "[\x06o;\a\a;\b[\x06o" +
-                          ":\x1CRDoc::Markup::Paragraph\x06;\b" +
-                          "[\x06I\"\fcomment\x06;\x06F:\n@fileI" +
-                          "\"\ffile.rb\x06;\x06F;\n0"
-
-    expected = doc RDoc::Comment.new('comment', @top_level).parse
-
-    assert_equal 'section', loaded.title
-    assert_equal expected,  loaded.parse
-    assert_nil              loaded.parent, 'parent is set manually'
-  end
-
-  def test_remove_comment_array
-    other = @store.add_file 'other.rb'
-
-    other_comment = comment('bogus', other)
-
-    @s.add_comment other_comment
-
-    @s.remove_comment comment('bogus', @top_level)
-
-    assert_equal [other_comment], @s.comments
-  end
-
-  def test_remove_comment_document
-    other = @store.add_file 'other.rb'
-
-    other_comment = comment('bogus', other)
-
-    @s.add_comment other_comment
-
-    loaded = Marshal.load Marshal.dump @s
-
-    loaded.remove_comment comment('bogus', @top_level)
-
-    assert_equal doc(other_comment.parse), loaded.parse
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc_context_test.rb b/test/mri/rdoc/rdoc_context_test.rb
deleted file mode 100644
index eaa4f236219..00000000000
--- a/test/mri/rdoc/rdoc_context_test.rb
+++ /dev/null
@@ -1,958 +0,0 @@
-# frozen_string_literal: true
-require_relative 'xref_test_case'
-
-class RDocContextTest < XrefTestCase
-
-  def setup
-    super
-
-    @context = RDoc::Context.new
-    @context.store = @store
-  end
-
-  def test_initialize
-    assert_empty @context.in_files
-    assert_equal 'unknown', @context.name
-    assert_equal '', @context.comment
-    assert_nil   @context.parent
-    assert_equal :public, @context.visibility
-    assert_equal 1, @context.sections.length
-    assert_nil   @context.temporary_section
-
-    assert_empty @context.classes_hash
-    assert_empty @context.modules_hash
-
-    assert_empty @context.method_list
-    assert_empty @context.attributes
-    assert_empty @context.aliases
-    assert_empty @context.requires
-    assert_empty @context.includes
-    assert_empty @context.constants
-  end
-
-  def test_add_alias
-    as = RDoc::Alias.new nil, 'old_name', 'new_name', 'comment'
-
-    @context.add_alias as
-
-    assert_equal [as], @context.external_aliases
-    assert_equal [as], @context.unmatched_alias_lists['#old_name']
-  end
-
-  def test_add
-    @context.add RDoc::Extend,  'Ext', 'comment'
-    @context.add RDoc::Include, 'Incl', 'comment'
-
-    refute_empty @context.extends
-    refute_empty @context.includes
-  end
-
-  def test_add_alias_method_attr
-    top_level = @store.add_file 'file.rb'
-
-    attr = RDoc::Attr.new nil, 'old_name', 'R', ''
-
-    as = RDoc::Alias.new nil, 'old_name', 'new_name', 'comment'
-    as.record_location top_level
-    as.parent = @context
-
-    @context.add_attribute attr
-    @context.add_alias as
-
-    assert_empty @context.aliases
-    assert_empty @context.unmatched_alias_lists
-    assert_equal %w[old_name new_name], @context.attributes.map { |m| m.name }
-
-    new = @context.attributes.last
-    assert_equal top_level, new.file
-  end
-
-  def test_add_alias_method
-    top_level = @store.add_file 'file.rb'
-
-    meth = RDoc::AnyMethod.new nil, 'old_name'
-    meth.singleton = false
-
-    as = RDoc::Alias.new nil, 'old_name', 'new_name', 'comment'
-    as.record_location top_level
-    as.parent = @context
-
-    @context.add_method meth
-    @context.add_alias as
-
-    assert_empty @context.aliases
-    assert_empty @context.unmatched_alias_lists
-    assert_equal %w[old_name new_name], @context.method_list.map { |m| m.name }
-
-    new = @context.method_list.last
-    assert_equal top_level, new.file
-  end
-
-  def test_add_alias_method_singleton
-    meth = RDoc::AnyMethod.new nil, 'old_name', singleton: true
-
-    as = RDoc::Alias.new nil, 'old_name', 'new_name', 'comment', singleton: true
-
-    as.parent = @context
-
-    @context.add_method meth
-    @context.add_alias as
-
-    assert_empty @context.aliases
-    assert_empty @context.unmatched_alias_lists
-    assert_equal %w[old_name new_name], @context.method_list.map { |m| m.name }
-
-    assert @context.method_list.last.singleton
-  end
-
-  def test_add_class
-    @c1.add_class RDoc::NormalClass, 'Klass', 'Object'
-
-    assert_includes @c1.classes.map { |k| k.full_name }, 'C1::Klass'
-    assert_includes @store.all_classes.map { |k| k.full_name }, 'C1::Klass'
-  end
-
-  def test_add_class_basic_object
-    @xref_data.add_class RDoc::NormalClass, 'BasicObject'
-
-    basic = @xref_data.find_module_named 'BasicObject'
-
-    assert_nil basic.superclass
-
-    @c1.add_class RDoc::NormalClass, 'BasicObject'
-
-    basic = @c1.find_module_named 'BasicObject'
-
-    assert_equal @object, basic.superclass
-  end
-
-  def test_add_class_object
-    @xref_data.add_class RDoc::NormalClass, 'Object'
-
-    object = @xref_data.find_module_named 'Object'
-
-    assert_equal 'BasicObject', object.superclass
-
-    @c1.add_class RDoc::NormalClass, 'Object'
-
-    object = @c1.find_module_named 'Object'
-
-    assert_equal 'Object', object.superclass.full_name
-  end
-
-  def test_add_class_singleton
-    @c1.add_class RDoc::NormalClass, 'Klass', 'Object'
-
-    assert_includes @c1.classes.map { |k| k.full_name }, 'C1::Klass'
-    assert_includes @store.all_classes.map { |k| k.full_name }, 'C1::Klass'
-  end
-
-  def test_add_class_superclass
-    @c1.add_class RDoc::NormalClass, 'Klass', 'Object'
-    @c1.add_class RDoc::NormalClass, 'Klass', 'Other'
-    @c1.add_class RDoc::NormalClass, 'Klass', 'Object'
-
-    klass = @c1.find_module_named 'Klass'
-    assert_equal 'Other', klass.superclass
-  end
-
-  def test_add_class_upgrade
-    @c1.add_module RDoc::NormalModule, 'Klass'
-    @c1.add_class RDoc::NormalClass, 'Klass', nil
-
-    assert_includes @c1.classes.map { |k| k.full_name }, 'C1::Klass',
-                    'c1 classes'
-    refute_includes @c1.modules.map { |k| k.full_name }, 'C1::Klass',
-                    'c1 modules'
-
-    assert_includes @store.all_classes.map { |k| k.full_name }, 'C1::Klass',
-                    'TopLevel classes'
-    refute_includes @store.all_modules.map { |k| k.full_name }, 'C1::Klass',
-                    'TopLevel modules'
-  end
-
-  def test_add_constant
-    const = RDoc::Constant.new 'NAME', 'value', 'comment'
-    @context.add_constant const
-
-    assert_equal [const], @context.constants
-  end
-
-  def test_add_extend
-    ext = RDoc::Extend.new 'Name', 'comment'
-    @context.add_extend ext
-
-    assert_equal [ext], @context.extends
-  end
-
-  def test_add_include
-    incl = RDoc::Include.new 'Name', 'comment'
-    @context.add_include incl
-
-    assert_equal [incl], @context.includes
-  end
-
-  def test_add_method
-    meth = RDoc::AnyMethod.new nil, 'old_name'
-    meth.visibility = nil
-
-    @context.add_method meth
-
-    assert_equal [meth], @context.method_list
-    assert_equal :public, meth.visibility
-  end
-
-  def test_add_method_alias
-    as = RDoc::Alias.new nil, 'old_name', 'new_name', 'comment'
-    meth = RDoc::AnyMethod.new nil, 'old_name'
-
-    @context.add_alias as
-    refute_empty @context.external_aliases
-
-    @context.add_method meth
-
-    assert_empty @context.external_aliases
-    assert_empty @context.unmatched_alias_lists
-    assert_equal %w[old_name new_name], @context.method_list.map { |m| m.name }
-  end
-
-  def test_add_method_duplicate
-    @store.options.verbosity = 2
-
-    meth1 = RDoc::AnyMethod.new nil, 'name'
-    meth1.record_location @store.add_file 'first.rb'
-    meth1.visibility = nil
-    meth1.comment = comment 'first'
-
-    @context.add_method meth1
-
-    meth2 = RDoc::AnyMethod.new nil, 'name'
-    meth2.record_location @store.add_file 'second.rb'
-    meth2.comment = comment 'second'
-
-    _, err = verbose_capture_output do
-      @context.add_method meth2
-    end
-
-    expected = 'Duplicate method (unknown)#name in file second.rb, ' \
-               'previously in file first.rb'
-
-    assert_equal expected, err.chomp
-
-    method = @context.method_list.first
-
-    assert_equal 'first', method.comment.text
-  end
-
-  def test_add_method_duplicate_loading
-    @context.store = nil
-
-    meth1 = RDoc::AnyMethod.new nil, 'name'
-    meth1.record_location @store.add_file 'first.rb'
-    meth1.visibility = nil
-    meth1.comment = comment 'first'
-
-    @context.add_method meth1
-
-    meth2 = RDoc::AnyMethod.new nil, 'name'
-    meth2.record_location @store.add_file 'second.rb'
-    meth2.comment = comment 'second'
-
-    _, err = verbose_capture_output do
-      @context.add_method meth2
-    end
-
-    assert_empty err
-
-    method = @context.method_list.first
-
-    assert_equal 'first', method.comment.text
-  end
-
-  def test_add_module
-    @c1.add_module RDoc::NormalModule, 'Mod'
-
-    assert_includes @c1.modules.map { |m| m.full_name }, 'C1::Mod'
-  end
-
-  def test_add_module_alias
-    tl = @store.add_file 'file.rb'
-
-    c4 = RDoc::Constant.new 'C4', '', ''
-    c3_c4 = @c2.add_module_alias @c2_c3, @c2_c3.name, c4, tl
-
-    alias_constant = @c2.constants.first
-
-    assert_equal 'C2::C4', c3_c4.full_name
-    assert_equal tl, alias_constant.file
-  end
-
-  def test_add_module_alias_top_level
-    store = RDoc::Store.new(RDoc::Options.new)
-
-    top_level = store.add_file 'file.rb'
-
-    klass  = top_level.add_class RDoc::NormalClass, 'Klass'
-    klass.comment = 'klass comment'
-
-    object = top_level.add_class RDoc::NormalClass, 'Object'
-
-    a = RDoc::Constant.new 'A', '', ''
-    top_level.add_module_alias klass, klass.name, a, top_level
-
-    refute_empty object.constants
-
-    constant = object.constants.first
-
-    assert_equal 'klass comment', constant.comment
-  end
-
-  def test_add_module_class
-    k = @c1.add_class RDoc::NormalClass, 'Klass', nil
-    m = @c1.add_module RDoc::NormalModule, 'Klass'
-
-    assert_equal k, m, 'returns class'
-    assert_empty @c1.modules
-  end
-
-  def test_add_require
-    req = RDoc::Require.new 'require', 'comment'
-    @c1.add_require req
-
-    assert_empty @c1.requires
-    assert_includes @c1.top_level.requires, req
-  end
-
-  def test_add_section
-    default_section = @context.sections.first
-
-    @context.add_section nil, comment('comment', @top_level)
-
-    assert_equal 1, @context.sections.length
-    assert_equal [comment("comment", @top_level)],
-                 @context.sections.first.comments
-
-    @context.add_section nil, comment('new comment', @top_level)
-
-    assert_equal 1, @context.sections.length
-    assert_equal [comment('comment', @top_level),
-                  comment('new comment', @top_level)],
-                 @context.sections.first.comments
-
-    @context.add_section 'other', comment('', @top_level)
-
-    assert_equal 2, @context.sections.length
-
-    new_section = @context.sections.find { |section| section.title == 'other' }
-    assert new_section
-    assert_equal default_section, @context.current_section
-  end
-
-  def test_add_section_no_comment
-    default_section = @context.sections.first
-
-    @context.add_section nil
-
-    assert_equal 1, @context.sections.length
-
-    @context.add_section 'other'
-
-    assert_equal 2, @context.sections.length
-
-    new_section = @context.sections.find { |section| section.title == 'other' }
-
-    assert new_section
-    assert_equal default_section, @context.current_section
-  end
-
-  def test_add_to
-    incl = RDoc::Include.new 'Name', 'comment'
-    arr = []
-    @context.add_to arr, incl
-
-    assert_includes arr, incl
-    assert_equal @context, incl.parent
-    assert_equal @context.current_section, incl.section
-  end
-
-  def test_add_to_temporary_section
-    incl = RDoc::Include.new 'Name', 'comment'
-    arr = []
-    section =
-      @context.add_section 'temporary', RDoc::Comment.new('', @top_level)
-    @context.temporary_section = section
-
-    @context.add_to arr, incl
-
-    assert_includes arr, incl
-    assert_equal @context, incl.parent
-    assert_equal section, incl.section
-  end
-
-  def test_add_to_no_document_self
-    incl = RDoc::Include.new 'Name', 'comment'
-    arr = []
-    @context.document_self = false
-    @context.add_to arr, incl
-
-    refute_includes arr, incl
-  end
-
-  def test_add_to_done_documenting
-    incl = RDoc::Include.new 'Name', 'comment'
-    arr = []
-    @context.done_documenting = true
-    @context.add_to arr, incl
-
-    refute_includes arr, incl
-  end
-
-  def bench_add_include
-    cm = RDoc::ClassModule.new 'Klass'
-
-    assert_performance_linear 0.5 do |count|
-      count.times do |i|
-        cm.add_include RDoc::Include.new("N::M#{i}", nil)
-      end
-    end
-  end
-
-  def test_child_name
-    assert_equal 'C1::C1', @c1.child_name('C1')
-  end
-
-  def test_classes
-    assert_equal %w[C2::C3], @c2.classes.map { |k| k.full_name }
-    assert_equal %w[C3::H1 C3::H2], @c3.classes.map { |k| k.full_name }.sort
-  end
-
-  def test_current_section
-    default_section = @context.current_section
-
-    new_section =
-      @context.add_section 'other', RDoc::Comment.new('', @top_level)
-    @context.temporary_section = new_section
-
-    assert_equal new_section, @context.current_section
-    assert_equal default_section, @context.current_section
-  end
-
-  def test_equals2
-    assert_equal @c3,    @c3
-    refute_equal @c2,    @c3
-    refute_equal @c2_c3, @c3
-  end
-
-  def test_each_method_enumerator
-    assert_kind_of Enumerator, @c1.each_method
-  end
-
-  def test_each_section
-    sects  = []
-    consts = []
-    attrs  = []
-
-    @c1.each_section do |section, constants, attributes|
-      sects  << section
-      consts << constants
-      attrs  << attributes
-    end
-
-    assert_equal [nil, 'separate'], sects.map { |section| section.title }
-
-    expected_consts = [
-      [@c1.constants.first],
-      [],
-    ]
-
-    assert_equal expected_consts, consts
-
-    expected_attrs = [
-      [@c1.attributes[0], @c1.attributes[3]],
-      [@c1.attributes[1], @c1.attributes[2]],
-    ]
-
-    assert_equal expected_attrs, attrs
-  end
-
-  def test_each_section_only_display
-    sects  = []
-    consts = []
-    attrs  = []
-
-    @c7.each_section do |section, constants, attributes|
-      sects  << section
-      consts << constants
-      attrs  << attributes
-    end
-
-    assert_equal [nil], sects.map { |section| section.title }
-
-    expected_consts = [
-      @c7.constants.select(&:display?).sort
-    ]
-
-    assert_equal expected_consts, consts
-
-    expected_attrs = [
-      @c7.attributes.select(&:display?).sort
-    ]
-
-    assert_equal expected_attrs, attrs
-  end
-
-  def test_each_section_enumerator
-    assert_kind_of Enumerator, @c1.each_section
-  end
-
-  def test_find_attribute_named
-    assert_nil         @c1.find_attribute_named('none')
-    assert_equal 'R',  @c1.find_attribute_named('attr').rw
-    assert_equal 'R',  @c1.find_attribute_named('attr_reader').rw
-    assert_equal 'W',  @c1.find_attribute_named('attr_writer').rw
-    assert_equal 'RW', @c1.find_attribute_named('attr_accessor').rw
-  end
-
-  def test_find_class_method_named
-    assert_nil @c1.find_class_method_named('none')
-
-    m = @c1.find_class_method_named('m')
-    assert_instance_of RDoc::AnyMethod, m
-    assert m.singleton
-  end
-
-  def test_find_constant_named
-    assert_nil             @c1.find_constant_named('NONE')
-    assert_equal ':const', @c1.find_constant_named('CONST').value
-  end
-
-  def test_find_enclosing_module_named
-    assert_nil        @c2_c3.find_enclosing_module_named('NONE')
-    assert_equal @c1, @c2_c3.find_enclosing_module_named('C1')
-    assert_equal @c2, @c2_c3.find_enclosing_module_named('C2')
-  end
-
-  def test_find_instance_method_named
-    assert_nil @c1.find_instance_method_named('none')
-
-    m = @c1.find_instance_method_named('m')
-    assert_instance_of RDoc::AnyMethod, m
-    refute m.singleton
-  end
-
-  def test_find_local_symbol
-    assert_equal true,       @c1.find_local_symbol('m').singleton
-    assert_equal ':const',   @c1.find_local_symbol('CONST').value
-    assert_equal 'R',        @c1.find_local_symbol('attr').rw
-    assert_equal @xref_data, @c1.find_local_symbol(@file_name)
-    assert_equal @c2_c3,     @c2.find_local_symbol('C3')
-  end
-
-  def test_find_method
-    loaded_c2 = Marshal.load Marshal.dump @c2
-    assert_equal @c2_a, loaded_c2.find_method('a', false)
-    assert_equal @c2_b, loaded_c2.find_method('b', false)
-    assert_equal @c2_a, loaded_c2.find_method('a', nil)
-    assert_equal @c2_b, loaded_c2.find_method('b', nil)
-  end
-
-  def test_find_method_named
-    assert_equal true, @c1.find_method_named('m').singleton
-  end
-
-  def test_find_module_named
-    assert_equal @c2_c3, @c2.find_module_named('C3')
-    assert_equal @c2,    @c2.find_module_named('C2')
-    assert_equal @c1,    @c2.find_module_named('C1')
-
-    assert_equal 'C2::C3', @c2.find_module_named('C3').full_name
-  end
-
-  def test_find_symbol
-    c3 = @xref_data.find_module_named('C3')
-    assert_equal c3,     @xref_data.find_symbol('C3')
-    assert_equal c3,     @c2.find_symbol('::C3')
-    assert_equal @c2_c3, @c2.find_symbol('C3')
-  end
-
-  def test_find_symbol_method
-    assert_equal @c1__m, @c1.find_symbol('m')
-    assert_equal @c1_m,  @c1.find_symbol('#m')
-    assert_equal @c1__m, @c1.find_symbol('::m')
-  end
-
-  def test_find_symbol_module
-    assert_nil @m1_m2.find_symbol_module 'N'
-    assert_nil @m1_m2.find_symbol_module 'M2::M1'
-
-    @m1_m2.parent = nil # loaded from legacy ri store
-
-    assert_nil @m1_m2.find_symbol_module 'N'
-    assert_nil @m1_m2.find_symbol_module 'M2::M1'
-  end
-
-  def test_fully_documented_eh
-    context = RDoc::Context.new
-
-    refute context.fully_documented?
-
-    context.comment = 'hi'
-
-    assert context.fully_documented?
-
-    m = @c1_m
-
-    context.add_method m
-
-    refute context.fully_documented?
-
-    m.comment = 'hi'
-
-    assert context.fully_documented?
-
-    c = RDoc::Constant.new 'C', '0', nil
-
-    context.add_constant c
-
-    refute context.fully_documented?
-
-    c.comment = 'hi'
-
-    assert context.fully_documented?
-
-    a = RDoc::Attr.new '', 'a', 'RW', nil
-
-    context.add_attribute a
-
-    refute context.fully_documented?
-
-    a.comment = 'hi'
-
-    assert context.fully_documented?
-  end
-
-  def test_spaceship
-    assert_equal(-1, @c2.<=>(@c3))
-    assert_equal 0,  @c2.<=>(@c2)
-    assert_equal 1,  @c3.<=>(@c2)
-
-    assert_equal 1,  @c2_c3.<=>(@c2)
-    assert_equal(-1, @c2_c3.<=>(@c3))
-
-    assert_nil @c2.<=>(Gem.loaded_specs.values.first)
-  end
-
-  def test_methods_by_type
-    expected = {
-      'instance' => {
-        :private   => [],
-        :protected => [],
-        :public    => [@c1_plus, @c1_m],
-      },
-      'class' => {
-        :private   => [],
-        :protected => [],
-        :public    => [@c1__m],
-      },
-    }
-
-    assert_equal expected, @c1.methods_by_type
-  end
-
-  def test_methods_by_type_section
-    separate = @c1.sections_hash['separate']
-    @c1_m.section = separate
-
-    expected = {
-      'instance' => {
-        :private   => [],
-        :protected => [],
-        :public    => [@c1_m],
-      },
-      'class' => {
-        :private   => [],
-        :protected => [],
-        :public    => [],
-      },
-    }
-
-    assert_equal expected, @c1.methods_by_type(separate)
-  end
-
-  def test_methods_matching
-    methods = []
-
-    @parent.methods_matching 'm' do |m|
-      methods << m
-    end
-
-    assert_equal [@parent_m], methods
-  end
-
-  def test_methods_matching_singleton
-    methods = []
-
-    @parent.methods_matching 'm', true do |m|
-      methods << m
-    end
-
-    assert_equal [@parent__m], methods
-  end
-
-  def test_methods_matching_inherit
-    methods = []
-
-    @child.methods_matching 'm' do |m|
-      methods << m
-    end
-
-    assert_equal [@parent_m], methods
-  end
-
-  def test_remove_invisible_private
-    util_visibilities
-
-    @vis.remove_invisible :private
-
-    assert_equal [@pub, @prot, @priv], @vis.method_list
-    assert_equal [@apub, @aprot, @apriv], @vis.attributes
-    assert_equal [@cpub, @cpriv], @vis.constants
-  end
-
-  def test_remove_invisible_nodoc
-    util_visibilities
-
-    @vis.remove_invisible :nodoc
-
-    assert_equal [@pub, @prot, @priv], @vis.method_list
-    assert_equal [@apub, @aprot, @apriv], @vis.attributes
-    assert_equal [@cpub, @cpriv], @vis.constants
-  end
-
-  def test_remove_invisible_protected
-    util_visibilities
-
-    @vis.remove_invisible :protected
-
-    assert_equal [@pub, @prot], @vis.method_list
-    assert_equal [@apub, @aprot], @vis.attributes
-    assert_equal [@cpub], @vis.constants
-  end
-
-  def test_remove_invisible_public
-    util_visibilities
-
-    @vis.remove_invisible :public
-
-    assert_equal [@pub], @vis.method_list
-    assert_equal [@apub], @vis.attributes
-    assert_equal [@cpub], @vis.constants
-  end
-
-  def test_remove_invisible_public_force
-    util_visibilities
-
-    @priv.force_documentation = true
-    @prot.force_documentation = true
-    @apriv.force_documentation = true
-    @aprot.force_documentation = true
-    @cpriv.force_documentation = true
-
-    @vis.remove_invisible :public
-
-    assert_equal [@pub, @prot, @priv], @vis.method_list
-    assert_equal [@apub, @aprot, @apriv], @vis.attributes
-    assert_equal [@cpub, @cpriv], @vis.constants
-  end
-
-  def test_remove_invisible_in_protected
-    util_visibilities
-
-    methods = [@pub, @prot, @priv]
-
-    @c1.remove_invisible_in methods, :protected
-
-    assert_equal [@pub, @prot], methods
-  end
-
-  def test_remove_invisible_in_protected_force
-    util_visibilities
-
-    @priv.force_documentation = true
-
-    methods = [@pub, @prot, @priv]
-
-    @c1.remove_invisible_in methods, :protected
-
-    assert_equal [@pub, @prot, @priv], methods
-  end
-
-  def test_remove_invisible_in_public
-    util_visibilities
-
-    methods = [@pub, @prot, @priv]
-
-    @c1.remove_invisible_in methods, :public
-
-    assert_equal [@pub], methods
-  end
-
-  def test_remove_invisible_in_public_force
-    util_visibilities
-
-    @prot.force_documentation = true
-    @priv.force_documentation = true
-
-    methods = [@pub, @prot, @priv]
-
-    @c1.remove_invisible_in methods, :public
-
-    assert_equal [@pub, @prot, @priv], methods
-  end
-
-  def test_section_contents
-    default = @context.sections.first
-    @context.add_method RDoc::AnyMethod.new(nil, 'm1')
-
-    b = @context.add_section 'B'
-    m = @context.add_method RDoc::AnyMethod.new(nil, 'm2')
-    m.section = b
-
-    assert_equal [default, b], @context.section_contents
-  end
-
-  def test_section_contents_no_default
-    @context = RDoc::Context.new
-    b = @context.add_section 'B'
-    m = @context.add_method RDoc::AnyMethod.new(nil, 'm')
-    m.section = b
-
-    assert_equal [b], @context.section_contents
-  end
-
-  def test_section_contents_only_default
-    @context = RDoc::Context.new
-
-    @context.add_method RDoc::AnyMethod.new(nil, 'm')
-
-    assert_empty @context.section_contents
-  end
-
-  def test_section_contents_unused
-    @context = RDoc::Context.new
-
-    @context.add_method RDoc::AnyMethod.new(nil, 'm')
-    @context.add_section 'B'
-
-    assert_empty @context.section_contents
-  end
-
-  def test_set_current_section
-    default_section = @context.sections.first
-
-    @context.set_current_section nil, RDoc::Comment.new('', @top_level)
-
-    assert_equal default_section, @context.current_section
-
-    @context.set_current_section 'other', RDoc::Comment.new('', @top_level)
-
-    new_section = @context.sections.find { |section|
-      section != default_section
-    }
-
-    assert_equal new_section, @context.current_section
-  end
-
-  def test_sort_sections
-    c = RDoc::Context.new
-    c.add_section 'C'
-    c.add_section 'A'
-    c.add_section 'B'
-
-    titles = c.sort_sections.map { |section| section.title }
-
-    assert_equal [nil, 'A', 'B', 'C'], titles
-  end
-
-  def test_sort_sections_tomdoc
-    c = RDoc::Context.new
-    c.add_section 'Public'
-    c.add_section 'Internal'
-    c.add_section 'Deprecated'
-
-    titles = c.sort_sections.map { |section| section.title }
-
-    assert_equal [nil, 'Public', 'Internal', 'Deprecated'], titles
-  end
-
-  def test_sort_sections_tomdoc_missing
-    c = RDoc::Context.new
-    c.add_section 'Internal'
-    c.add_section 'Public'
-
-    titles = c.sort_sections.map { |section| section.title }
-
-    assert_equal [nil, 'Public', 'Internal'], titles
-  end
-
-  def test_visibility_def
-    assert_equal :private, @c6.find_method_named('priv1').visibility
-    assert_equal :protected, @c6.find_method_named('prot1').visibility
-    assert_equal :public, @c6.find_method_named('pub1').visibility
-    assert_equal :private, @c6.find_method_named('priv2').visibility
-    assert_equal :protected, @c6.find_method_named('prot2').visibility
-    assert_equal :public, @c6.find_method_named('pub2').visibility
-    assert_equal :private, @c6.find_method_named('priv3').visibility
-    assert_equal :protected, @c6.find_method_named('prot3').visibility
-    assert_equal :public, @c6.find_method_named('pub3').visibility
-    assert_equal :private, @c6.find_method_named('priv4').visibility
-    assert_equal :protected, @c6.find_method_named('prot4').visibility
-    assert_equal :public, @c6.find_method_named('pub4').visibility
-    assert_equal :private, @c6.find_method_named('priv5').visibility
-    assert_equal :protected, @c6.find_method_named('prot5').visibility
-    assert_equal :public, @c6.find_method_named('pub5').visibility
-    assert_equal :private, @c6.find_method_named('priv6').visibility
-    assert_equal :protected, @c6.find_method_named('prot6').visibility
-    assert_equal :public, @c6.find_method_named('pub6').visibility
-    assert_equal :public, @c6.find_method_named('s_pub1').visibility
-    assert_equal :public, @c6.find_method_named('s_pub2').visibility
-    assert_equal :public, @c6.find_method_named('s_pub3').visibility
-    assert_equal :public, @c6.find_method_named('s_pub4').visibility
-    assert_equal :private, @c6.find_method_named('s_priv1').visibility
-    assert_equal :protected, @c6.find_method_named('s_prot1').visibility
-  end
-
-  def util_visibilities
-    @pub  = RDoc::AnyMethod.new nil, 'pub'
-    @prot = RDoc::AnyMethod.new nil, 'prot'
-    @priv = RDoc::AnyMethod.new nil, 'priv'
-
-    @apub  = RDoc::Attr.new nil, 'pub',  'RW', nil
-    @aprot = RDoc::Attr.new nil, 'prot', 'RW', nil
-    @apriv = RDoc::Attr.new nil, 'priv', 'RW', nil
-
-    @cpub  = RDoc::Constant.new 'CONST_PUBLIC', nil, nil
-    @cpriv = RDoc::Constant.new 'CONST_PRIVATE', nil, nil
-
-    @vis = RDoc::NormalClass.new 'Vis'
-    @vis.add_method @pub
-    @vis.add_method @prot
-    @vis.add_method @priv
-
-    @vis.add_attribute @apub
-    @vis.add_attribute @aprot
-    @vis.add_attribute @apriv
-
-    @vis.add_constant @cpub
-    @vis.add_constant @cpriv
-
-    @prot.visibility = :protected
-    @priv.visibility = :private
-
-    @aprot.visibility = :protected
-    @apriv.visibility = :private
-
-    @cpriv.visibility = :private
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc_cross_reference_test.rb b/test/mri/rdoc/rdoc_cross_reference_test.rb
deleted file mode 100644
index 4f24fd77009..00000000000
--- a/test/mri/rdoc/rdoc_cross_reference_test.rb
+++ /dev/null
@@ -1,217 +0,0 @@
-# frozen_string_literal: true
-require_relative 'xref_test_case'
-
-class RDocCrossReferenceTest < XrefTestCase
-  EXAMPLE_METHODS = %w'== === != =~ !~ < > <= >= <=> [] []= << >>
-    -@ +@ ! - + * / % ** !@ ` | & ^ ~ __id__
-  '
-
-  def setup
-    super
-
-    @xref = RDoc::CrossReference.new @c1
-  end
-
-  def assert_ref(expected, name)
-    assert_equal expected, @xref.resolve(name, 'fail')
-  end
-
-  def refute_ref(name)
-    assert_equal name, @xref.resolve(name, name)
-  end
-
-  def test_METHOD_REGEXP_STR
-    re = /\A(?:#{RDoc::CrossReference::METHOD_REGEXP_STR})\z/
-
-    EXAMPLE_METHODS.each do |x|
-      re =~ x
-      assert_equal x, $&
-    end
-  end
-
-  def test_resolve_C2
-    @xref = RDoc::CrossReference.new @c2
-
-    refute_ref '#m'
-
-    assert_ref @c1__m,    'C1::m'
-    assert_ref @c2_c3,    'C2::C3'
-    assert_ref @c2_c3_m,  'C2::C3#m'
-    assert_ref @c2_c3_h1, 'C3::H1'
-    assert_ref @c4,       'C4'
-
-    assert_ref @c3_h2, 'C3::H2'
-    refute_ref 'H1'
-  end
-
-  def test_resolve_C2_C3
-    @xref = RDoc::CrossReference.new @c2_c3
-
-    assert_ref @c2_c3_m, '#m'
-
-    assert_ref @c2_c3, 'C3'
-    assert_ref @c2_c3_m, 'C3#m'
-
-    assert_ref @c2_c3_h1, 'H1'
-    assert_ref @c2_c3_h1, 'C3::H1'
-
-    assert_ref @c4, 'C4'
-
-    assert_ref @c3_h2, 'C3::H2'
-  end
-
-  def test_resolve_C3
-    @xref = RDoc::CrossReference.new @c3
-
-    assert_ref @c3, 'C3'
-
-    refute_ref '#m'
-    refute_ref 'C3#m'
-
-    assert_ref @c3_h1, 'H1'
-
-    assert_ref @c3_h1, 'C3::H1'
-    assert_ref @c3_h2, 'C3::H2'
-
-    assert_ref @c4, 'C4'
-  end
-
-  def test_resolve_C4
-    @xref = RDoc::CrossReference.new @c4
-
-    # C4 ref inside a C4 containing a C4 should resolve to the contained class
-    assert_ref @c4_c4, 'C4'
-  end
-
-  def test_resolve_C4_C4
-    @xref = RDoc::CrossReference.new @c4_c4
-
-    # A C4 reference inside a C4 class contained within a C4 class should
-    # resolve to the inner C4 class.
-    assert_ref @c4_c4, 'C4'
-  end
-
-  def test_resolve_class_and_method_of_the_same_name
-    assert_ref @c10_class, 'C10'
-    assert_ref @c10_method, '#C10'
-    assert_ref @c11_class, 'C11'
-    assert_ref @c11_method, '#C11'
-    assert_ref @c10_c11_class, 'C10::C11'
-    assert_ref @c10_c11_method, 'C10#C11'
-  end
-
-  def test_resolve_class
-    assert_ref @c1, 'C1'
-    refute_ref 'H1'
-
-    assert_ref @c2,       'C2'
-    assert_ref @c2_c3,    'C2::C3'
-    assert_ref @c2_c3_h1, 'C2::C3::H1'
-
-    assert_ref @c3,    '::C3'
-    assert_ref @c3_h1, '::C3::H1'
-
-    assert_ref @c4_c4, 'C4::C4'
-  end
-
-  def test_resolve_file
-    refute_ref 'xref_data.rb'
-  end
-
-  def test_resolve_method
-    assert_ref @c1__m,    'm'
-    assert_ref @c1__m,    '::m'
-    assert_ref @c1_m,     '#m'
-    assert_ref @c1_plus,  '#+'
-
-    assert_ref @c1_m,     'C1#m'
-    assert_ref @c1_plus,  'C1#+'
-    assert_ref @c1__m,    'C1.m'
-    assert_ref @c1__m,    'C1::m'
-
-    assert_ref @c1_m, 'C1#m'
-    assert_ref @c1_m, 'C1#m()'
-    assert_ref @c1_m, 'C1#m(*)'
-
-    assert_ref @c1_plus, 'C1#+'
-    assert_ref @c1_plus, 'C1#+()'
-    assert_ref @c1_plus, 'C1#+(*)'
-
-    assert_ref @c1__m, 'C1.m'
-    assert_ref @c1__m, 'C1.m()'
-    assert_ref @c1__m, 'C1.m(*)'
-
-    assert_ref @c1__m, 'C1::m'
-    assert_ref @c1__m, 'C1::m()'
-    assert_ref @c1__m, 'C1::m(*)'
-
-    assert_ref @c2_c3_m, 'C2::C3#m'
-
-    assert_ref @c2_c3_m, 'C2::C3.m'
-
-    # TODO stop escaping - HTML5 allows anything but space
-    assert_ref @c2_c3_h1_meh, 'C2::C3::H1#m?'
-
-    assert_ref @c2_c3_m, '::C2::C3#m'
-    assert_ref @c2_c3_m, '::C2::C3#m()'
-    assert_ref @c2_c3_m, '::C2::C3#m(*)'
-  end
-
-  def test_resolve_the_same_name_in_instance_and_class_method
-    assert_ref @c9_a_i_foo, 'C9::A#foo'
-    assert_ref @c9_a_c_bar, 'C9::A::bar'
-    assert_ref @c9_b_c_foo, 'C9::B::foo'
-    assert_ref @c9_b_i_bar, 'C9::B#bar'
-    assert_ref @c9_b_c_foo, 'C9::B.foo'
-    assert_ref @c9_a_c_bar, 'C9::B.bar'
-  end
-
-  def test_resolve_page
-    page = @store.add_file 'README.txt', parser: RDoc::Parser::Simple
-
-    assert_ref page, 'README'
-  end
-
-  def assert_resolve_method(x)
-    @c1.methods_hash.clear
-
-    i_op = RDoc::AnyMethod.new nil, x
-    @c1.add_method i_op
-
-    c_op = RDoc::AnyMethod.new nil, x, singleton: true
-    @c1.add_method c_op
-
-    assert_ref i_op, x
-    assert_ref i_op, "##{x}"
-    assert_ref c_op, "::#{x}"
-
-    assert_ref i_op, "C1##{x}"
-    assert_ref c_op, "C1::#{x}"
-  end
-
-  EXAMPLE_METHODS.each do |x|
-    define_method("test_resolve_method:#{x}") do
-      assert_resolve_method(x)
-    end
-  end
-
-  def test_resolve_no_ref
-    assert_equal '', @xref.resolve('', '')
-
-    assert_equal "bogus",     @xref.resolve("bogus",     "bogus")
-    assert_equal "\\bogus",   @xref.resolve("\\bogus",   "\\bogus")
-    assert_equal "\\\\bogus", @xref.resolve("\\\\bogus", "\\\\bogus")
-
-    assert_equal "\\#n",    @xref.resolve("\\#n",    "fail")
-    assert_equal "\\#n()",  @xref.resolve("\\#n()",  "fail")
-    assert_equal "\\#n(*)", @xref.resolve("\\#n(*)", "fail")
-
-    assert_equal "C1",   @xref.resolve("\\C1",   "fail")
-    assert_equal "::C3", @xref.resolve("\\::C3", "fail")
-
-    assert_equal "succeed",      @xref.resolve("::C3::H1#n",    "succeed")
-    assert_equal "succeed",      @xref.resolve("::C3::H1#n(*)", "succeed")
-    assert_equal "\\::C3::H1#n", @xref.resolve("\\::C3::H1#n",  "fail")
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc_encoding_test.rb b/test/mri/rdoc/rdoc_encoding_test.rb
deleted file mode 100644
index fdb42afd7fd..00000000000
--- a/test/mri/rdoc/rdoc_encoding_test.rb
+++ /dev/null
@@ -1,184 +0,0 @@
-# coding: US-ASCII
-# frozen_string_literal: true
-
-require_relative 'helper'
-
-class RDocEncodingTest < RDoc::TestCase
-
-  def setup
-    super
-
-    @tempfile = Tempfile.new 'test_rdoc_encoding'
-  end
-
-  def teardown
-    @tempfile.close!
-
-    super
-  end
-
-  def test_class_read_file
-    @tempfile.write "hi everybody"
-    @tempfile.flush
-
-    assert_equal "hi everybody", RDoc::Encoding.read_file(@tempfile.path, nil)
-  end
-
-  def test_class_read_file_encoding
-    expected = "# coding: utf-8\nhi everybody"
-
-    @tempfile.write expected
-    @tempfile.flush
-
-    contents = RDoc::Encoding.read_file @tempfile.path, Encoding::UTF_8
-    assert_equal "# coding: utf-8\nhi everybody", contents
-    assert_equal Encoding::UTF_8, contents.encoding
-  end
-
-  def test_class_read_file_encoding_convert
-    content = ""
-    content = RDoc::Encoding.change_encoding content, 'ISO-8859-1'
-    content << "# coding: ISO-8859-1\nhi \xE9verybody"
-
-    @tempfile.write content
-    @tempfile.flush
-
-    contents = RDoc::Encoding.read_file @tempfile.path, Encoding::UTF_8
-    assert_equal Encoding::UTF_8, contents.encoding
-    assert_equal "# coding: ISO-8859-1\nhi \u00e9verybody", contents.sub("\r", '')
-  end
-
-  def test_class_read_file_encoding_fail
-    @tempfile.write "# coding: utf-8\n\317\200" # pi
-    @tempfile.flush
-
-    contents = :junk
-
-    _, err = verbose_capture_output do
-      contents = RDoc::Encoding.read_file @tempfile.path, Encoding::US_ASCII
-    end
-
-    assert_nil contents
-
-    assert_match %r%^unable to convert%, err
-  end
-
-  def test_class_read_file_encoding_fancy
-    expected = "# -*- coding: utf-8; fill-column: 74 -*-\nhi everybody"
-    expected = RDoc::Encoding.change_encoding expected, Encoding::UTF_8
-
-    @tempfile.write expected
-    @tempfile.flush
-
-    contents = RDoc::Encoding.read_file @tempfile.path, Encoding::UTF_8
-    assert_equal "# -*- coding: utf-8; fill-column: 74 -*-\nhi everybody", contents
-    assert_equal Encoding::UTF_8, contents.encoding
-  end
-
-  def test_class_read_file_encoding_force_transcode
-    @tempfile.write "# coding: utf-8\n\317\200" # pi
-    @tempfile.flush
-
-    contents = RDoc::Encoding.read_file @tempfile.path, Encoding::US_ASCII, true
-
-    assert_equal "# coding: utf-8\n?", contents
-    assert_equal Encoding::US_ASCII, contents.encoding
-  end
-
-  def test_class_read_file_encoding_guess
-    path = File.expand_path '../test.ja.txt', __FILE__
-    content = RDoc::Encoding.read_file path, Encoding::UTF_8
-
-    assert_equal Encoding::UTF_8, content.encoding
-  end
-
-  def test_class_read_file_encoding_invalid
-    @tempfile.write "# coding: ascii\nM\xE4r"
-    @tempfile.flush
-
-    contents = :junk
-    _, err = verbose_capture_output do
-      contents = RDoc::Encoding.read_file @tempfile.path, Encoding::UTF_8
-    end
-
-    assert_equal "unable to convert \"\\xE4\" on US-ASCII for #{@tempfile.path}, skipping\n", err
-
-    assert_nil contents
-  end
-
-  def test_class_read_file_encoding_with_signature
-    @tempfile.write "\xEF\xBB\xBFhi everybody"
-    @tempfile.flush
-
-    bug3360 = '[ruby-dev:41452]'
-    content = RDoc::Encoding.read_file @tempfile.path, Encoding::UTF_8
-    assert_equal Encoding::UTF_8, content.encoding, bug3360
-    assert_equal "hi everybody", content, bug3360
-  end
-
-  def test_class_read_file_encoding_iso_2022_jp
-    input = "# coding: ISO-2022-JP\n:\e$B%3%^%s%I\e(B:"
-
-    @tempfile.write input
-    @tempfile.flush
-
-    contents = RDoc::Encoding.read_file @tempfile.path, Encoding::UTF_8
-
-    expected = "# coding: ISO-2022-JP\n:\xe3\x82\xb3\xe3\x83\x9e\xe3\x83\xb3\xe3\x83\x89:"
-    expected = RDoc::Encoding.change_encoding expected, Encoding::UTF_8
-
-    assert_equal expected, contents
-    assert_equal Encoding::UTF_8, contents.encoding
-  end
-
-  def test_class_detect_encoding
-    s = "# coding: UTF-8\n"
-    encoding = RDoc::Encoding.detect_encoding s
-
-    # sanity check for 1.8
-
-    assert_equal Encoding::UTF_8, encoding
-
-    s = "#!/bin/ruby\n# coding: UTF-8\n"
-    encoding = RDoc::Encoding.detect_encoding s
-
-    assert_equal Encoding::UTF_8, encoding
-
-    s = "<?xml version='1.0' encoding='UTF-8'?>\n"
-    encoding = RDoc::Encoding.detect_encoding s
-
-    assert_equal Encoding::UTF_8, encoding
-
-    s = "<?xml version='1.0' encoding=\"UTF-8\"?>\n"
-    encoding = RDoc::Encoding.detect_encoding s
-
-    assert_equal Encoding::UTF_8, encoding
-  end
-
-  def test_class_set_encoding_bad
-    s = ""
-    encoding = RDoc::Encoding.detect_encoding s
-
-    assert_nil encoding
-
-    s = "# vim:set fileencoding=utf-8:\n"
-    encoding = RDoc::Encoding.detect_encoding s
-
-    assert_nil encoding
-
-    s = "# vim:set fileencoding=utf-8:\n"
-    encoding = RDoc::Encoding.detect_encoding s
-
-    assert_nil encoding
-
-    assert_raise ArgumentError do
-      s = RDoc::Encoding.detect_encoding "# -*- encoding: undecided -*-\n"
-    end
-  end
-
-  def test_sanity
-    assert_equal Encoding::US_ASCII, ''.encoding,
-                 'If this file is not ASCII tests may incorrectly pass'
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc_extend_test.rb b/test/mri/rdoc/rdoc_extend_test.rb
deleted file mode 100644
index cf13eba0c51..00000000000
--- a/test/mri/rdoc/rdoc_extend_test.rb
+++ /dev/null
@@ -1,94 +0,0 @@
-# frozen_string_literal: true
-require_relative 'xref_test_case'
-
-class RDocExtendTest < XrefTestCase
-
-  def setup
-    super
-
-    @ext = RDoc::Extend.new 'M1', 'comment'
-    @ext.parent = @m1
-    @ext.store = @store
-  end
-
-  def test_module
-    assert_equal @m1, @ext.module
-    assert_equal 'Unknown', RDoc::Extend.new('Unknown', 'comment').module
-  end
-
-  def test_module_extended
-    m1 = @xref_data.add_module RDoc::NormalModule, 'Mod1'
-                  m1.add_module RDoc::NormalModule, 'Mod3'
-    m1_m2       = m1.add_module RDoc::NormalModule, 'Mod2'
-    m1_m2_m3    = m1_m2.add_module RDoc::NormalModule, 'Mod3'
-                  m1_m2_m3.add_module RDoc::NormalModule, 'Mod4'
-                  m1_m2.add_module RDoc::NormalModule, 'Mod4'
-    m1_m2_k0    = m1_m2.add_class RDoc::NormalClass, 'Klass0'
-    m1_m2_k0_m4 = m1_m2_k0.add_module RDoc::NormalModule, 'Mod4'
-                  m1_m2_k0_m4.add_module RDoc::NormalModule, 'Mod6'
-                  m1_m2_k0.add_module RDoc::NormalModule, 'Mod5'
-
-    e0_m4 = RDoc::Extend.new 'Mod4', nil
-    e0_m5 = RDoc::Extend.new 'Mod5', nil
-    e0_m6 = RDoc::Extend.new 'Mod6', nil
-    e0_m1 = RDoc::Extend.new 'Mod1', nil
-    e0_m2 = RDoc::Extend.new 'Mod2', nil
-    e0_m3 = RDoc::Extend.new 'Mod3', nil
-
-    m1_m2_k0.add_extend e0_m4
-    m1_m2_k0.add_extend e0_m5
-    m1_m2_k0.add_extend e0_m6
-    m1_m2_k0.add_extend e0_m1
-    m1_m2_k0.add_extend e0_m2
-    m1_m2_k0.add_extend e0_m3
-
-    assert_equal [e0_m4, e0_m5, e0_m6, e0_m1, e0_m2, e0_m3], m1_m2_k0.extends
-    assert_equal [@object, 'BasicObject'], m1_m2_k0.ancestors
-
-    m1_k1 = m1.add_class RDoc::NormalClass, 'Klass1'
-
-    e1_m1 = RDoc::Extend.new 'Mod1', nil
-    e1_m2 = RDoc::Extend.new 'Mod2', nil
-    e1_m3 = RDoc::Extend.new 'Mod3', nil
-    e1_m4 = RDoc::Extend.new 'Mod4', nil
-    e1_k0_m4 = RDoc::Extend.new 'Klass0::Mod4', nil
-
-    m1_k1.add_extend e1_m1
-    m1_k1.add_extend e1_m2
-    m1_k1.add_extend e1_m3
-    m1_k1.add_extend e1_m4
-    m1_k1.add_extend e1_k0_m4
-
-    assert_equal [e1_m1, e1_m2, e1_m3, e1_m4, e1_k0_m4], m1_k1.extends
-    assert_equal [@object, 'BasicObject'], m1_k1.ancestors
-
-    m1_k2 = m1.add_class RDoc::NormalClass, 'Klass2'
-
-    e2_m1 = RDoc::Extend.new 'Mod1', nil
-    e2_m2 = RDoc::Extend.new 'Mod2', nil
-    e2_m3 = RDoc::Extend.new 'Mod3', nil
-    e2_k0_m4 = RDoc::Extend.new 'Klass0::Mod4', nil
-
-    m1_k2.add_extend e2_m1
-    m1_k2.add_extend e2_m3
-    m1_k2.add_extend e2_m2
-    m1_k2.add_extend e2_k0_m4
-
-    assert_equal [e2_m1, e2_m3, e2_m2, e2_k0_m4], m1_k2.extends
-    assert_equal [@object, 'BasicObject'], m1_k2.ancestors
-
-    m1_k3 = m1.add_class RDoc::NormalClass, 'Klass3'
-
-    e3_m1 = RDoc::Extend.new 'Mod1', nil
-    e3_m2 = RDoc::Extend.new 'Mod2', nil
-    e3_m4 = RDoc::Extend.new 'Mod4', nil
-
-    m1_k3.add_extend e3_m1
-    m1_k3.add_extend e3_m2
-    m1_k3.add_extend e3_m4
-
-    assert_equal [e3_m1, e3_m2, e3_m4], m1_k3.extends
-    assert_equal [@object, 'BasicObject'], m1_k3.ancestors
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc_generator_darkfish_test.rb b/test/mri/rdoc/rdoc_generator_darkfish_test.rb
deleted file mode 100644
index 67715951ecb..00000000000
--- a/test/mri/rdoc/rdoc_generator_darkfish_test.rb
+++ /dev/null
@@ -1,593 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocGeneratorDarkfishTest < RDoc::TestCase
-
-  def setup
-    super
-
-    @lib_dir = "#{@pwd}/lib"
-    $LOAD_PATH.unshift @lib_dir # ensure we load from this RDoc
-
-    @options = RDoc::Options.new
-    @options.option_parser = OptionParser.new
-
-    @tmpdir = File.join Dir.tmpdir, "test_rdoc_generator_darkfish_#{$$}"
-    FileUtils.mkdir_p @tmpdir
-    Dir.chdir @tmpdir
-    @options.op_dir = @tmpdir
-    @options.generator = RDoc::Generator::Darkfish
-
-    $LOAD_PATH.each do |path|
-      darkfish_dir = File.join path, 'rdoc/generator/template/darkfish/'
-      next unless File.directory? darkfish_dir
-      @options.template_dir = darkfish_dir
-      break
-    end
-
-    @rdoc.options = @options
-
-    @g = @options.generator.new @store, @options
-    @rdoc.generator = @g
-
-    @top_level = @store.add_file 'file.rb'
-    @top_level.parser = RDoc::Parser::Ruby
-    @klass = @top_level.add_class RDoc::NormalClass, 'Klass'
-
-    @alias_constant = RDoc::Constant.new 'A', nil, ''
-    @alias_constant.record_location @top_level
-
-    @top_level.add_constant @alias_constant
-
-    @klass.add_module_alias @klass, @klass.name, @alias_constant, @top_level
-
-    @meth = RDoc::AnyMethod.new nil, 'method'
-    @meth_bang = RDoc::AnyMethod.new nil, 'method!'
-    @meth_with_html_tag_yield = RDoc::AnyMethod.new nil, 'method_with_html_tag_yield'
-    @meth_with_html_tag_yield.block_params = '%<<script>alert("atui")</script>>, yield_arg'
-    @attr = RDoc::Attr.new nil, 'attr', 'RW', ''
-
-    @klass.add_method @meth
-    @klass.add_method @meth_bang
-    @klass.add_method @meth_with_html_tag_yield
-    @klass.add_attribute @attr
-
-    @ignored = @top_level.add_class RDoc::NormalClass, 'Ignored'
-    @ignored.ignore
-
-    @store.complete :private
-
-    @object      = @store.find_class_or_module 'Object'
-    @klass_alias = @store.find_class_or_module 'Klass::A'
-  end
-
-  def teardown
-    super
-
-    $LOAD_PATH.shift
-    Dir.chdir @pwd
-    FileUtils.rm_rf @tmpdir
-  end
-
-  def test_generate
-    top_level = @store.add_file 'file.rb'
-    top_level.add_class @klass.class, @klass.name
-    @klass.add_class RDoc::NormalClass, 'Inner'
-    @klass.add_comment <<~RDOC, top_level
-    = Heading 1
-    Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod
-    == Heading 1.1
-    tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam,
-    === Heading 1.1.1
-    quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo
-    ==== Heading 1.1.1.1
-    consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse
-    == Heading 1.2
-    cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat
-    == Heading 1.3
-    non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
-    === Heading 1.3.1
-    etc etc...
-    RDOC
-
-    @g.generate
-
-    assert_file 'index.html'
-    assert_file 'Object.html'
-    assert_file 'Klass.html'
-    assert_file 'Klass/Inner.html'
-    assert_file 'table_of_contents.html'
-    assert_file 'js/search_index.js'
-
-    assert_hard_link 'css/rdoc.css'
-    assert_hard_link 'css/fonts.css'
-
-    assert_hard_link 'fonts/SourceCodePro-Bold.ttf'
-    assert_hard_link 'fonts/SourceCodePro-Regular.ttf'
-
-    encoding = Regexp.escape Encoding::UTF_8.name
-
-    assert_match %r%<meta charset="#{encoding}">%, File.binread('index.html')
-    assert_match %r%<meta charset="#{encoding}">%, File.binread('Object.html')
-
-    refute_match(/Ignored/, File.binread('index.html'))
-    summary = File.binread('index.html')[%r[<summary.*Klass\.html.*</summary>.*</details>]m]
-    assert_match(%r[Klass/Inner\.html".*>Inner<], summary)
-
-    klass = File.binread('Klass.html')
-    klassnav = klass[%r[<div class="nav-section">.*]m]
-    assert_match(
-      %r[<li>\s*<details open>\s*<summary>\s*<a href=\S+>Heading 1</a>\s*</summary>\s*<ul]m,
-      klassnav
-    )
-    assert_match(
-      %r[<li>\s*<a href=\S+>Heading 1.1.1.1</a>\s*</ul>\s*</details>\s*</li>]m,
-      klassnav
-    )
-
-    assert_match(/<h1 id="class-Klass-label-Heading\+1">Heading 1(?!\.)/,
-                 klass[%r[<section class=\"description\">.*</section>]m])
-    toc = File.binread('table_of_contents.html')
-    assert_match(
-      %r[<a\s+href="Klass\.html#class-Klass-label-Heading\+1">Heading 1</a>]m,
-      toc[%r[<h2\s+id=\"classes\">.*(?=<h2\b)]m][%r[<a\s+href="Klass\.html".*(?=</li\b)]m]
-    )
-  end
-
-  def test_generate_index_with_main_page
-    top_level = @store.add_file 'file.rb'
-    top_level.comment = <<~RDOC
-    = Heading 1
-    Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod
-    == Heading 1.1
-    tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam,
-    === Heading 1.1.1
-    quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo
-    ==== Heading 1.1.1.1
-    consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse
-    == Heading 1.2
-    cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat
-    == Heading 1.3
-    non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
-    === Heading 1.3.1
-    etc etc...
-    RDOC
-
-    @options.main_page = 'file.rb'
-    @options.title = 'My awesome Ruby project'
-
-    @g.generate
-
-    assert_file 'index.html'
-    assert_file 'table_of_contents.html'
-    assert_file 'js/search_index.js'
-
-    assert_hard_link 'css/rdoc.css'
-    assert_hard_link 'css/fonts.css'
-
-    assert_hard_link 'fonts/SourceCodePro-Bold.ttf'
-    assert_hard_link 'fonts/SourceCodePro-Regular.ttf'
-
-    index_html = File.binread('index.html')
-
-    assert_include index_html, "<h3>Table of Contents</h3>"
-    assert_include index_html, '<h1 id="label-Heading+1">Heading 1'
-    # When there's a main page, the default description should not be shown
-    assert_not_include index_html, 'This is the API documentation for My awesome Ruby project.'
-  end
-
-  def test_generate_index_without_main_page
-    top_level = @store.add_file 'file.rb'
-    top_level.comment = <<~RDOC
-    = Heading 1
-    Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod
-    == Heading 1.1
-    tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam,
-    === Heading 1.1.1
-    quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo
-    ==== Heading 1.1.1.1
-    consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse
-    == Heading 1.2
-    cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat
-    == Heading 1.3
-    non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
-    === Heading 1.3.1
-    etc etc...
-    RDOC
-
-    @options.title = 'My awesome Ruby project'
-
-    @g.generate
-
-    assert_file 'index.html'
-    assert_file 'table_of_contents.html'
-    assert_file 'js/search_index.js'
-
-    assert_hard_link 'css/rdoc.css'
-    assert_hard_link 'css/fonts.css'
-
-    assert_hard_link 'fonts/SourceCodePro-Bold.ttf'
-    assert_hard_link 'fonts/SourceCodePro-Regular.ttf'
-
-    index_html = File.binread('index.html')
-
-    # If there is no main page, the index page should not have a table of contents
-    assert_not_include index_html, "<h3>Table of Contents</h3>"
-    assert_include index_html, 'This is the API documentation for My awesome Ruby project.'
-  end
-
-  def test_generate_page
-    @store.add_file 'outer.rdoc', parser: RDoc::Parser::Simple
-    @store.add_file 'outer/inner.rdoc', parser: RDoc::Parser::Simple
-    @g.generate
-    assert_file 'outer_rdoc.html'
-    assert_file 'outer/inner_rdoc.html'
-    index = File.binread('index.html')
-    re = %r[<summary><a href="\./outer_rdoc\.html">outer</a></summary>.*?</details>]m
-    assert_match(re, index)
-    summary = index[re]
-    assert_match %r[<a href="\./outer/inner_rdoc.html">inner</a>], summary
-    re = %r[<details open><summary><a href="\./outer_rdoc\.html">outer</a></summary>.*?</details>]m
-    assert_match(re, File.binread('outer_rdoc.html'))
-    re = %r[<details open><summary><a href="\.\./outer_rdoc\.html">outer</a></summary>.*?</details>]m
-    assert_match(re, File.binread('outer/inner_rdoc.html'))
-  end
-
-  def test_generate_dry_run
-    @g.dry_run = true
-    top_level = @store.add_file 'file.rb'
-    top_level.add_class @klass.class, @klass.name
-
-    @g.generate
-
-    refute_file 'index.html'
-    refute_file 'Object.html'
-  end
-
-  def test_generate_static
-    FileUtils.mkdir_p 'dir/images'
-    FileUtils.touch 'dir/images/image.png'
-    FileUtils.mkdir_p 'file'
-    FileUtils.touch 'file/file.txt'
-
-    @options.static_path = [
-      File.expand_path('dir'),
-      File.expand_path('file/file.txt'),
-    ]
-
-    @g.generate
-
-    assert_file 'images/image.png'
-    assert_file 'file.txt'
-  end
-
-  def test_generate_static_dry_run
-    FileUtils.mkdir 'static'
-    FileUtils.touch 'static/image.png'
-
-    @options.static_path = [File.expand_path('static')]
-    @g.dry_run = true
-
-    @g.generate
-
-    refute_file 'image.png'
-  end
-
-  def test_install_rdoc_static_file
-    src = Pathname File.expand_path(__FILE__, @pwd)
-    dst = File.join @tmpdir, File.basename(src)
-    options = {}
-
-    @g.install_rdoc_static_file src, dst, options
-
-    assert_file dst
-    assert_hard_link dst
-  end
-
-  def test_install_rdoc_static_file_missing
-    src = Pathname(__FILE__) + 'nonexistent'
-    dst = File.join @tmpdir, File.basename(src)
-    options = {}
-
-    @g.install_rdoc_static_file src, dst, options
-
-    refute_file dst
-  end
-
-  def test_setup
-    @g.setup
-
-    assert_equal [@klass_alias, @ignored, @klass, @object],
-                 @g.classes.sort_by { |klass| klass.full_name }
-    assert_equal [@top_level],                           @g.files
-    assert_equal [@meth, @meth, @meth_bang, @meth_bang, @meth_with_html_tag_yield, @meth_with_html_tag_yield], @g.methods
-    assert_equal [@klass_alias, @klass, @object], @g.modsort
-  end
-
-  def test_template_for
-    classpage = Pathname.new @options.template_dir + 'class.rhtml'
-
-    template = @g.send(:template_for, classpage, true, RDoc::ERBIO)
-    assert_kind_of RDoc::ERBIO, template
-
-    assert_same template, @g.send(:template_for, classpage)
-  end
-
-  def test_template_for_dry_run
-    classpage = Pathname.new @options.template_dir + 'class.rhtml'
-
-    template = @g.send(:template_for, classpage, true, ERB)
-    assert_kind_of ERB, template
-
-    assert_same template, @g.send(:template_for, classpage)
-  end
-
-  def test_template_for_partial
-    partial = Pathname.new @options.template_dir + '_sidebar_classes.rhtml'
-
-    template = @g.send(:template_for, partial, false, RDoc::ERBPartial)
-
-    assert_kind_of RDoc::ERBPartial, template
-
-    assert_same template, @g.send(:template_for, partial)
-  end
-
-  def test_generated_method_with_html_tag_yield
-    top_level = @store.add_file 'file.rb'
-    top_level.add_class @klass.class, @klass.name
-
-    @g.generate
-
-    path = File.join @tmpdir, 'A.html'
-
-    f = open(path)
-    internal_file = f.read
-    method_name_index = internal_file.index('<span class="method-name">method_with_html_tag_yield</span>')
-    last_of_method_name_index = method_name_index + internal_file[method_name_index..-1].index('<div class="method-description">') - 1
-    method_name = internal_file[method_name_index..last_of_method_name_index]
-    f.close
-
-    assert_includes method_name, '{ |%<<script>alert("atui")</script>>, yield_arg| ... }'
-  end
-
-  def test_generated_filename_with_html_tag
-    filename = '"><em>should be escaped'
-    begin # in @tmpdir
-      File.write(filename, '')
-    rescue SystemCallError
-      # ", <, > chars are prohibited as filename
-      return
-    else
-      File.unlink(filename)
-    end
-    @store.add_file filename
-    doc = @store.all_files.last
-    doc.parser = RDoc::Parser::Simple
-
-    @g.generate
-
-    Dir.glob("*.html", base: @tmpdir) do |html|
-      File.binread(File.join(@tmpdir, html)).scan(/.*should be escaped.*/) do |line|
-        assert_not_include line, "<em>", html
-      end
-    end
-  end
-
-  def test_template_stylesheets
-    css = Tempfile.create(%W'hoge .css', Dir.mktmpdir('tmp', '.'))
-    File.write(css, '')
-    css.close
-    base = File.basename(css)
-    refute_file(base)
-
-    @options.template_stylesheets << css
-
-    @g.generate
-
-    assert_file base
-    assert_include File.binread('index.html'), %Q[href="./#{base}"]
-  end
-
-  def test_html_lang
-    @g.generate
-
-    content = File.binread("index.html")
-    assert_include(content, '<html lang="en">')
-  end
-
-  def test_html_lang_from_locale
-    @options.locale = RDoc::I18n::Locale.new 'ja'
-    @g.generate
-
-    content = File.binread("index.html")
-    assert_include(content, '<html lang="ja">')
-  end
-
-  def test_title
-    title = "RDoc Test".freeze
-    @options.title = title
-    @g.generate
-
-    assert_main_title(File.binread('index.html'), title)
-  end
-
-  def test_title_escape
-    title = %[<script>alert("RDoc")</script>].freeze
-    @options.title = title
-    @g.generate
-
-    assert_main_title(File.binread('index.html'), title)
-  end
-
-  def test_meta_tags_for_index
-    @options.title = "My awesome Ruby project"
-    @g.generate
-
-    content = File.binread("index.html")
-
-    assert_include(content, '<meta name="keywords" content="ruby,documentation,My awesome Ruby project">')
-    assert_include(content, '<meta name="description" content="Documentation for My awesome Ruby project">')
-  end
-
-  def test_meta_tags_for_classes
-    top_level = @store.add_file("file.rb")
-    top_level.add_class(@klass.class, @klass.name)
-    inner = @klass.add_class(RDoc::NormalClass, "Inner")
-    inner.add_comment("This is a normal class. It is fully documented.", top_level)
-
-    @g.generate
-
-    content = File.binread("Klass/Inner.html")
-    assert_include(content, '<meta name="keywords" content="ruby,class,Klass::Inner">')
-    assert_include(
-      content,
-      '<meta name="description" content="class Klass::Inner: This is a normal class. It is fully documented.">',
-    )
-  end
-
-  def test_meta_tags_for_rdoc_files
-    top_level = @store.add_file("CONTRIBUTING.rdoc", parser: RDoc::Parser::Simple)
-    top_level.comment = <<~RDOC
-      = Contributing
-
-      Here are the instructions for contributing. Begin by installing Ruby.
-    RDOC
-
-    @g.generate
-
-    content = File.binread("CONTRIBUTING_rdoc.html")
-    assert_include(content, '<meta name="keywords" content="ruby,documentation,CONTRIBUTING">')
-    assert_include(
-      content,
-      "<meta name=\"description\" content=\"CONTRIBUTING: Contributing Here are the instructions for contributing." \
-      " Begin by installing Ruby.\">",
-    )
-  end
-
-  def test_meta_tags_for_markdown_files_paragraph
-    top_level = @store.add_file("README.md", parser: RDoc::Parser::Simple)
-    top_level.comment = <<~MARKDOWN
-      # Distributed Ruby: dRuby
-
-      dRuby is a distributed object system for Ruby.  It allows an object.
-    MARKDOWN
-
-    @g.generate
-
-    content = File.binread("README_md.html")
-    assert_include(
-      content,
-      "<meta name=\"description\" content=\"" \
-      "README: dRuby " \
-      "dRuby is a distributed object system for Ruby. " \
-      "It allows an object."
-    )
-  end
-
-  def test_meta_tags_for_markdown_files
-    top_level = @store.add_file("MyPage.md", parser: RDoc::Parser::Markdown)
-    top_level.comment = <<~MARKDOWN
-      # MyPage
-
-      This is a comment
-    MARKDOWN
-
-    @g.generate
-
-    content = File.binread("MyPage_md.html")
-    assert_include(content, '<meta name="keywords" content="ruby,documentation,MyPage">')
-    assert_include(
-      content,
-      '<meta name="description" content="MyPage: # MyPage This is a comment">',
-    )
-  end
-
-  def test_meta_tags_for_raw_pages
-    top_level = @store.add_file("MyPage", parser: RDoc::Parser::Simple)
-    comment = RDoc::Comment.new('this is a comment')
-    comment.document = RDoc::Markup::Document.new(RDoc::Markup::Paragraph.new('this is a comment'))
-    top_level.comment = comment
-
-    @g.generate
-
-    content = File.binread("MyPage.html")
-    assert_include(content, '<meta name="keywords" content="ruby,documentation,MyPage">')
-    assert_include(content, '<meta name="description" content="MyPage: this is a comment">')
-  end
-
-  def test_meta_tags_for_empty_document
-    top_level = @store.add_file("MyPage", parser: RDoc::Parser::Simple)
-    top_level.comment = RDoc::Comment.from_document(RDoc::Markup::Document.new)
-
-    @g.generate
-
-    content = File.binread("MyPage.html")
-    assert_include(content, '<meta name="keywords" content="ruby,documentation,MyPage">')
-    assert_include(
-      content,
-      '<meta name="description" content="MyPage: ">',
-    )
-  end
-
-  def test_canonical_url_for_index
-    @store.options.canonical_root = @options.canonical_root = "https://docs.ruby-lang.org/en/master/"
-    @g.generate
-
-    content = File.binread("index.html")
-
-    assert_include(content, '<link rel="canonical" href="https://docs.ruby-lang.org/en/master/">')
-  end
-
-  def test_canonical_url_for_classes
-    top_level = @store.add_file("file.rb")
-    top_level.add_class(@klass.class, @klass.name)
-    inner = @klass.add_class(RDoc::NormalClass, "Inner")
-
-    @store.options.canonical_root = @options.canonical_root = "https://docs.ruby-lang.org/en/master/"
-    @g.generate
-
-    content = File.binread("Klass/Inner.html")
-
-    assert_include(content, '<link rel="canonical" href="https://docs.ruby-lang.org/en/master/Klass/Inner.html">')
-  end
-
-  def test_canonical_url_for_rdoc_files
-    top_level = @store.add_file("CONTRIBUTING.rdoc", parser: RDoc::Parser::Simple)
-
-    @store.options.canonical_root = @options.canonical_root = "https://docs.ruby-lang.org/en/master/"
-    @g.generate
-
-    content = File.binread("CONTRIBUTING_rdoc.html")
-
-    assert_include(content, '<link rel="canonical" href="https://docs.ruby-lang.org/en/master/CONTRIBUTING_rdoc.html">')
-  end
-
-  ##
-  # Asserts that +filename+ has a link count greater than 1 if hard links to
-  # @tmpdir are supported.
-
-  def assert_hard_link(filename)
-    assert_file filename
-
-    src = @g.template_dir + '_head.rhtml'
-    dst = File.join @tmpdir, 'hardlinktest'
-
-    begin
-      FileUtils.ln src, dst
-      nlink = File.stat(dst).nlink if File.identical? src, dst
-      FileUtils.rm dst
-      return if nlink == 1
-    rescue SystemCallError
-      return
-    end
-
-    assert_operator File.stat(filename).nlink, :>, 1,
-                    "#{filename} is not hard-linked"
-  end
-
-  def assert_main_title(content, title)
-    title = CGI.escapeHTML(title)
-    assert_equal(title, content[%r[<title>(.*?)<\/title>]im, 1])
-    assert_include(content[%r[<main\s[^<>]*+>\s*(.*?)</main>]im, 1], title)
-  end
-end
diff --git a/test/mri/rdoc/rdoc_generator_json_index_test.rb b/test/mri/rdoc/rdoc_generator_json_index_test.rb
deleted file mode 100644
index aa7a2da0b16..00000000000
--- a/test/mri/rdoc/rdoc_generator_json_index_test.rb
+++ /dev/null
@@ -1,363 +0,0 @@
-# coding: US-ASCII
-# frozen_string_literal: true
-
-require_relative 'helper'
-
-class RDocGeneratorJsonIndexTest < RDoc::TestCase
-
-  def setup
-    super
-
-    @tmpdir = Dir.mktmpdir "test_rdoc_generator_darkfish_#{$$}_"
-    FileUtils.mkdir_p @tmpdir
-
-    @options = RDoc::Options.new
-    @options.files = []
-    # JsonIndex is used in conjunction with another generator
-    @options.setup_generator 'darkfish'
-    @options.template_dir = ''
-    @options.op_dir = @tmpdir
-    @options.option_parser = OptionParser.new
-    @options.finish
-
-    @darkfish = RDoc::Generator::Darkfish.new @store, @options
-    @g = RDoc::Generator::JsonIndex.new @darkfish, @options
-
-    @rdoc.options = @options
-    @rdoc.generator = @g
-
-    @top_level = @store.add_file 'file.rb'
-    @top_level.parser = RDoc::Parser::Ruby
-
-    @klass = @top_level.add_class RDoc::NormalClass, 'C'
-
-    @meth = @klass.add_method RDoc::AnyMethod.new(nil, 'meth')
-    @meth.record_location @top_level
-
-    @nest_klass = @klass.add_class RDoc::NormalClass, 'D'
-    @nest_klass.record_location @top_level
-
-    @nest_meth = @nest_klass.add_method RDoc::AnyMethod.new(nil, 'meth')
-
-    @ignored = @top_level.add_class RDoc::NormalClass, 'Ignored'
-    @ignored.ignore
-
-    @page = @store.add_file 'page.rdoc'
-    @page.parser = RDoc::Parser::Simple
-
-    @top_levels = [@top_level, @page].sort
-    @klasses    = [@klass, @nest_klass, @ignored]
-
-    Dir.chdir @tmpdir
-  end
-
-  def teardown
-    super
-
-    Dir.chdir @pwd
-    FileUtils.rm_rf @tmpdir
-  end
-
-  def test_build_index
-    index = @g.build_index
-
-    expected = {
-      :index => {
-        :searchIndex     => %w[c d meth() meth() page],
-        :longSearchIndex => %w[c c::d c#meth() c::d#meth()],
-        :info            => [
-          @klass.search_record[2..-1],
-          @nest_klass.search_record[2..-1],
-          @meth.search_record[2..-1],
-          @nest_meth.search_record[2..-1],
-          @page.search_record[2..-1],
-        ],
-      },
-    }
-
-    expected[:index][:longSearchIndex] << ''
-
-    assert_equal expected, index
-  end
-
-  def test_generate
-    @g.generate
-
-    assert_file 'js/searcher.js'
-    assert_file 'js/navigation.js'
-    assert_file 'js/search_index.js'
-
-    srcdir = File.expand_path('lib/rdoc', @pwd)
-    if !File.directory? srcdir
-      # for Ruby core repository
-      srcdir = File.expand_path("../../../lib/rdoc", __FILE__)
-    end
-
-    orig_file = Pathname(File.join srcdir, 'generator/template/json_index/js/navigation.js')
-    generated_file = Pathname(File.join @tmpdir, 'js/navigation.js')
-
-    # The following assertion for the generated file's modified time randomly
-    # fails in a ppc64le environment.
-    # https://github.com/ruby/rdoc/issues/1048
-    if orig_file.mtime.inspect != generated_file.mtime.inspect &&
-      RUBY_PLATFORM =~ /powerpc64le/
-      pend <<~EOC
-        Unstable test in ppc64le.
-        <#{orig_file.mtime.inspect}> expected but was
-        <#{generated_file.mtime.inspect}>.
-      EOC
-    end
-
-    # This is dirty hack on JRuby
-    assert_equal orig_file.mtime.inspect, generated_file.mtime.inspect,
-      '.js files should be the same timestamp of original'
-
-    json = File.read 'js/search_index.js'
-
-    json =~ /\Avar search_data = /
-
-    assignment = $&
-    index = $'
-
-    refute_empty assignment
-
-    index = JSON.parse index
-
-    info = [
-      @klass.search_record[2..-1],
-      @nest_klass.search_record[2..-1],
-      @meth.search_record[2..-1],
-      @nest_meth.search_record[2..-1],
-      @page.search_record[2..-1],
-    ]
-
-    expected = {
-      'index' => {
-        'searchIndex' => [
-          'c',
-          'd',
-          'meth()',
-          'meth()',
-          'page',
-        ],
-        'longSearchIndex' => [
-          'c',
-          'c::d',
-          'c#meth()',
-          'c::d#meth()',
-          '',
-        ],
-        'info' => info,
-      },
-    }
-
-    assert_equal expected, index
-  end
-
-  def test_generate_search_index_with_reproducible_builds
-    backup_epoch = ENV['SOURCE_DATE_EPOCH']
-    ruby_birthday = Time.parse 'Wed, 24 Feb 1993 21:00:00 +0900'
-    ENV['SOURCE_DATE_EPOCH'] = ruby_birthday.to_i.to_s
-
-    @g.generate
-
-    assert_file 'js/search_index.js'
-    generated_search_index = Pathname(File.join @tmpdir, 'js/search_index.js')
-    assert_equal ruby_birthday, generated_search_index.mtime
-
-    ENV['SOURCE_DATE_EPOCH'] = backup_epoch
-  end
-
-  def test_generate_gzipped
-    begin
-      require 'zlib'
-    rescue LoadError
-      omit "no zlib"
-    end
-    @g.generate
-    @g.generate_gzipped
-
-    assert_file 'js/searcher.js'
-    assert_file 'js/searcher.js.gz'
-    assert_file 'js/navigation.js'
-    assert_file 'js/navigation.js.gz'
-    assert_file 'js/search_index.js'
-    assert_file 'js/search_index.js.gz'
-
-    json = File.open('js/search_index.js.gz', 'rb') {|gzip|
-      Zlib::GzipReader.new(gzip).read
-    }
-
-    json =~ /\Avar search_data = /
-
-    assignment = $&
-    index = $'
-
-    refute_empty assignment
-
-    index = JSON.parse index
-
-    info = [
-      @klass.search_record[2..-1],
-      @nest_klass.search_record[2..-1],
-      @meth.search_record[2..-1],
-      @nest_meth.search_record[2..-1],
-      @page.search_record[2..-1],
-    ]
-
-    expected = {
-      'index' => {
-        'searchIndex' => [
-          'c',
-          'd',
-          'meth()',
-          'meth()',
-          'page',
-        ],
-        'longSearchIndex' => [
-          'c',
-          'c::d',
-          'c#meth()',
-          'c::d#meth()',
-          '',
-        ],
-        'info' => info,
-      },
-    }
-
-    assert_equal expected, index
-  end
-
-  def test_generate_utf_8
-    # JRuby fails this test with:
-    #   Encoding::UndefinedConversionError: "\xC2" from ASCII-8BIT to UTF-8
-    #     org/jruby/RubyIO.java:1639:in `write'
-    #     org/jruby/RubyIO.java:1612:in `write'
-    #     json/ext/GeneratorState.java:232:in `_generate'
-    #     json/ext/GeneratorState.java:137:in `generate'
-    #     /Users/runner/work/rdoc/rdoc/vendor/bundle/jruby/3.1.0/gems/json-2.9.0-java/lib/json/common.rb:824:in `dump'
-    #     /Users/runner/work/rdoc/rdoc/lib/rdoc/generator/json_index.rb:148:in `block in generate'
-    omit if RUBY_PLATFORM =~ /java/
-
-    text = "5\xB0"
-    text = RDoc::Encoding.change_encoding text, Encoding::ISO_8859_1
-    @klass.add_comment comment(text), @top_level
-
-    @g.generate
-
-    json = File.read 'js/search_index.js'
-    json.force_encoding Encoding::UTF_8
-
-    json =~ /\Avar search_data = /
-
-    index = $'
-
-    index = JSON.parse index
-
-    klass_record = @klass.search_record[2..-1]
-    klass_record[-1] = "<p>5\xc2\xb0\n"
-    klass_record[-1] = RDoc::Encoding.change_encoding klass_record[-1], Encoding::UTF_8
-
-    info = [
-      klass_record,
-      @nest_klass.search_record[2..-1],
-      @meth.search_record[2..-1],
-      @nest_meth.search_record[2..-1],
-      @page.search_record[2..-1],
-    ]
-
-    expected = {
-      'index' => {
-        'searchIndex' => [
-          'c',
-          'd',
-          'meth()',
-          'meth()',
-          'page',
-        ],
-        'longSearchIndex' => [
-          'c',
-          'c::d',
-          'c#meth()',
-          'c::d#meth()',
-          '',
-        ],
-        'info' => info,
-      },
-    }
-
-    assert_equal expected, index
-  end
-
-  def test_index_classes
-    @g.reset @top_levels, @klasses
-
-    @g.index_classes
-
-    expected = {
-      :searchIndex     => %w[c d],
-      :longSearchIndex => %w[c c::d],
-      :info            => [
-        @klass.search_record[2..-1],
-        @nest_klass.search_record[2..-1],
-      ],
-    }
-
-    assert_equal expected, @g.index
-  end
-
-  def test_index_classes_nodoc
-    @klass.document_self      = false
-    @nest_klass.document_self = false
-    @meth.document_self       = false
-    @nest_meth.document_self  = false
-
-    @g.reset @top_levels, @klasses
-
-    @g.index_classes
-
-    expected = {
-      :searchIndex     => [],
-      :longSearchIndex => [],
-      :info            => [],
-    }
-
-    assert_equal expected, @g.index
-  end
-
-  def test_index_methods
-    @g.reset @top_levels, @klasses
-
-    @g.index_methods
-
-    expected = {
-      :searchIndex     => %w[meth() meth()],
-      :longSearchIndex => %w[c#meth() c::d#meth()],
-      :info            => [
-        @meth.search_record[2..-1],
-        @nest_meth.search_record[2..-1],
-      ],
-    }
-
-    assert_equal expected, @g.index
-  end
-
-  def test_index_pages
-    @g.reset @top_levels, @klasses
-
-    @g.index_pages
-
-    expected = {
-      :searchIndex     => %w[page],
-      :longSearchIndex => [''],
-      :info            => [@page.search_record[2..-1]],
-    }
-
-    assert_equal expected, @g.index
-  end
-
-  def test_search_string
-    assert_equal 'cd', @g.search_string('C d')
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc_generator_markup_test.rb b/test/mri/rdoc/rdoc_generator_markup_test.rb
deleted file mode 100644
index cd77e67e794..00000000000
--- a/test/mri/rdoc/rdoc_generator_markup_test.rb
+++ /dev/null
@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocGeneratorMarkupTest < RDoc::TestCase
-
-  include RDoc::Text
-  include RDoc::Generator::Markup
-
-  attr_reader :store
-
-  def setup
-    super
-
-    @options = RDoc::Options.new
-    @rdoc.options = @options
-
-    @parent = self
-    @path = '/index.html'
-    @symbols = {}
-  end
-
-  def test_aref_to
-    assert_equal 'Foo/Bar.html', aref_to('Foo/Bar.html')
-  end
-
-  def test_as_href
-    assert_equal '../index.html', as_href('Foo/Bar.html')
-  end
-
-  def test_cvs_url
-    assert_equal 'http://example/this_page',
-                 cvs_url('http://example/', 'this_page')
-
-    assert_equal 'http://example/?page=this_page&foo=bar',
-                 cvs_url('http://example/?page=%s&foo=bar', 'this_page')
-  end
-
-  def test_description
-    @comment = '= Hello'
-
-    links = '<span><a href="#label-Hello">¶</a> ' +
-            '<a href="#top">↑</a></span>'
-
-    assert_equal "\n<h1 id=\"label-Hello\">Hello#{links}</h1>\n", description
-  end
-
-  def test_formatter
-    assert_kind_of RDoc::Markup::ToHtmlCrossref, formatter
-    refute formatter.show_hash
-    assert_same self, formatter.context
-  end
-
-  attr_reader :path
-
-  def find_symbol(name)
-    @symbols[name]
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc_generator_pot_po_entry_test.rb b/test/mri/rdoc/rdoc_generator_pot_po_entry_test.rb
deleted file mode 100644
index d058ff3f405..00000000000
--- a/test/mri/rdoc/rdoc_generator_pot_po_entry_test.rb
+++ /dev/null
@@ -1,140 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocGeneratorPOTPOEntryTest < RDoc::TestCase
-
-  def test_msgid_normal
-    assert_equal <<-'ENTRY', entry("Hello", {}).to_s
-msgid "Hello"
-msgstr ""
-    ENTRY
-  end
-
-  def test_msgid_multiple_lines
-    assert_equal <<-'ENTRY', entry("Hello\nWorld", {}).to_s
-msgid ""
-"Hello\n"
-"World"
-msgstr ""
-    ENTRY
-  end
-
-  def test_msgid_tab
-    assert_equal <<-'ENTRY', entry("Hello\tWorld", {}).to_s
-msgid "Hello\tWorld"
-msgstr ""
-    ENTRY
-  end
-
-  def test_msgid_back_slash
-    assert_equal <<-'ENTRY', entry("Hello \\ World", {}).to_s
-msgid "Hello \\ World"
-msgstr ""
-    ENTRY
-  end
-
-  def test_msgid_double_quote
-    assert_equal <<-'ENTRY', entry("Hello \"World\"!", {}).to_s
-msgid "Hello \"World\"!"
-msgstr ""
-    ENTRY
-  end
-
-  def test_translator_comment_normal
-    options = {:translator_comment => "Greeting"}
-    assert_equal <<-'ENTRY', entry("Hello", options).to_s
-# Greeting
-msgid "Hello"
-msgstr ""
-    ENTRY
-  end
-
-  def test_translator_comment_multiple_lines
-    options = {:translator_comment => "Greeting\nfor morning"}
-    assert_equal <<-'ENTRY', entry("Hello", options).to_s
-# Greeting
-# for morning
-msgid "Hello"
-msgstr ""
-    ENTRY
-  end
-
-  def test_extracted_comment_normal
-    options = {:extracted_comment => "Object"}
-    assert_equal <<-'ENTRY', entry("Hello", options).to_s
-#. Object
-msgid "Hello"
-msgstr ""
-    ENTRY
-  end
-
-  def test_extracted_comment_multiple_lines
-    options = {:extracted_comment => "Object\nMorning#greeting"}
-    assert_equal <<-'ENTRY', entry("Hello", options).to_s
-#. Object
-#. Morning#greeting
-msgid "Hello"
-msgstr ""
-    ENTRY
-  end
-
-  def test_references_normal
-    options = {:references => [["lib/rdoc.rb", 29]]}
-    assert_equal <<-'ENTRY', entry("Hello", options).to_s
-#: lib/rdoc.rb:29
-msgid "Hello"
-msgstr ""
-    ENTRY
-  end
-
-  def test_references_multiple
-    options = {:references => [["lib/rdoc.rb", 29], ["lib/rdoc/i18n.rb", 9]]}
-    assert_equal <<-'ENTRY', entry("Hello", options).to_s
-#: lib/rdoc.rb:29
-#: lib/rdoc/i18n.rb:9
-msgid "Hello"
-msgstr ""
-    ENTRY
-  end
-
-  def test_flags_normal
-    options = {:flags => ["fuzzy"]}
-    assert_equal <<-'ENTRY', entry("Hello", options).to_s
-#, fuzzy
-msgid "Hello"
-msgstr ""
-    ENTRY
-  end
-
-  def test_flags_multiple
-    options = {:flags => ["fuzzy", "ruby-format"]}
-    assert_equal <<-'ENTRY', entry("Hello", options).to_s
-#, fuzzy,ruby-format
-msgid "Hello"
-msgstr ""
-    ENTRY
-  end
-
-  def test_full
-    options = {
-      :translator_comment => "Greeting",
-      :extracted_comment  => "Morning#greeting",
-      :references         => [["lib/rdoc.rb", 29]],
-      :flags              => ["fuzzy"],
-    }
-    assert_equal <<-'ENTRY', entry("Hello", options).to_s
-# Greeting
-#. Morning#greeting
-#: lib/rdoc.rb:29
-#, fuzzy
-msgid "Hello"
-msgstr ""
-    ENTRY
-  end
-
-  private
-  def entry(msgid, options)
-    RDoc::Generator::POT::POEntry.new(msgid, options)
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc_generator_pot_po_test.rb b/test/mri/rdoc/rdoc_generator_pot_po_test.rb
deleted file mode 100644
index 83b4a5f1c33..00000000000
--- a/test/mri/rdoc/rdoc_generator_pot_po_test.rb
+++ /dev/null
@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocGeneratorPOTPOTest < RDoc::TestCase
-
-  def setup
-    super
-    @po = RDoc::Generator::POT::PO.new
-  end
-
-  def test_empty
-    assert_equal header, @po.to_s
-  end
-
-  def test_have_entry
-    @po.add(entry("Hello", {}))
-    assert_equal <<-PO, @po.to_s
-#{header}
-msgid "Hello"
-msgstr ""
-    PO
-  end
-
-  private
-
-  def entry(msgid, options)
-    RDoc::Generator::POT::POEntry.new(msgid, options)
-  end
-
-  def header
-    <<-'HEADER'
-# SOME DESCRIPTIVE TITLE.
-# Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER
-# This file is distributed under the same license as the PACKAGE package.
-# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
-#, fuzzy
-msgid ""
-msgstr ""
-"Project-Id-Version: PACKAGE VERSEION\n"
-"Report-Msgid-Bugs-To:\n"
-"PO-Revision-Date: YEAR-MO_DA HO:MI+ZONE\n"
-"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
-"Language-Team: LANGUAGE <LL@li.org>\n"
-"Language:\n"
-"MIME-Version: 1.0\n"
-"Content-Type: text/plain; charset=CHARSET\n"
-"Content-Transfer-Encoding: 8bit\n"
-"Plural-Forms: nplurals=INTEGER; plural=EXPRESSION;\n"
-    HEADER
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc_generator_pot_test.rb b/test/mri/rdoc/rdoc_generator_pot_test.rb
deleted file mode 100644
index 736f9765e50..00000000000
--- a/test/mri/rdoc/rdoc_generator_pot_test.rb
+++ /dev/null
@@ -1,92 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocGeneratorPOTTest < RDoc::TestCase
-
-  def setup
-    super
-
-    @options = RDoc::Options.new
-    @tmpdir = File.join Dir.tmpdir, "test_rdoc_generator_pot_#{$$}"
-    FileUtils.mkdir_p @tmpdir
-
-    @generator = RDoc::Generator::POT.new @store, @options
-
-    @top_level = @store.add_file 'file.rb'
-    @klass = @top_level.add_class RDoc::NormalClass, 'Object'
-    @klass.add_comment 'This is a class', @top_level
-    @klass.add_section 'This is a section', comment('This is a section comment')
-
-    @const = RDoc::Constant.new "CONSTANT", "29", "This is a constant"
-
-    @meth = RDoc::AnyMethod.new nil, 'method'
-    @meth.record_location @top_level
-    @meth.comment = 'This is a method'
-
-    @attr = RDoc::Attr.new nil, 'attr', 'RW', ''
-    @attr.record_location @top_level
-    @attr.comment = 'This is an attribute'
-
-    @klass.add_constant @const
-    @klass.add_method @meth
-    @klass.add_attribute @attr
-
-    Dir.chdir @tmpdir
-  end
-
-  def teardown
-    super
-
-    Dir.chdir @pwd
-    FileUtils.rm_rf @tmpdir
-  end
-
-  def test_generate
-    @generator.generate
-
-    assert_equal <<-POT, File.read(File.join(@tmpdir, 'rdoc.pot'))
-# SOME DESCRIPTIVE TITLE.
-# Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER
-# This file is distributed under the same license as the PACKAGE package.
-# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
-#, fuzzy
-msgid ""
-msgstr ""
-"Project-Id-Version: PACKAGE VERSEION\\n"
-"Report-Msgid-Bugs-To:\\n"
-"PO-Revision-Date: YEAR-MO_DA HO:MI+ZONE\\n"
-"Last-Translator: FULL NAME <EMAIL@ADDRESS>\\n"
-"Language-Team: LANGUAGE <LL@li.org>\\n"
-"Language:\\n"
-"MIME-Version: 1.0\\n"
-"Content-Type: text/plain; charset=CHARSET\\n"
-"Content-Transfer-Encoding: 8bit\\n"
-"Plural-Forms: nplurals=INTEGER; plural=EXPRESSION;\\n"
-
-#. Object
-msgid "This is a class"
-msgstr ""
-
-#. Object::CONSTANT
-msgid "This is a constant"
-msgstr ""
-
-#. Object#method
-msgid "This is a method"
-msgstr ""
-
-#. Object: section title
-msgid "This is a section"
-msgstr ""
-
-#. Object: This is a section
-msgid "This is a section comment"
-msgstr ""
-
-#. Object#attr
-msgid "This is an attribute"
-msgstr ""
-    POT
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc_generator_ri_test.rb b/test/mri/rdoc/rdoc_generator_ri_test.rb
deleted file mode 100644
index 9109d220676..00000000000
--- a/test/mri/rdoc/rdoc_generator_ri_test.rb
+++ /dev/null
@@ -1,76 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocGeneratorRITest < RDoc::TestCase
-
-  def setup
-    super
-
-    @options = RDoc::Options.new
-    @options.encoding = Encoding::UTF_8
-    @store.encoding = Encoding::UTF_8
-
-    @tmpdir = File.join Dir.tmpdir, "test_rdoc_generator_ri_#{$$}"
-    FileUtils.mkdir_p @tmpdir
-
-    @g = RDoc::Generator::RI.new @store, @options
-
-    @top_level = @store.add_file 'file.rb'
-    @klass = @top_level.add_class RDoc::NormalClass, 'Object'
-
-    @meth = RDoc::AnyMethod.new nil, 'method'
-    @meth.record_location @top_level
-
-    @meth_bang = RDoc::AnyMethod.new nil, 'method!'
-    @meth_bang.record_location @top_level
-
-    @attr = RDoc::Attr.new nil, 'attr', 'RW', ''
-    @attr.record_location @top_level
-
-    @klass.add_method @meth
-    @klass.add_method @meth_bang
-    @klass.add_attribute @attr
-
-    Dir.chdir @tmpdir
-  end
-
-  def teardown
-    super
-
-    Dir.chdir @pwd
-    FileUtils.rm_rf @tmpdir
-  end
-
-  def test_generate
-    @g.generate
-
-    assert_file File.join(@tmpdir, 'cache.ri')
-
-    assert_file File.join(@tmpdir, 'Object', 'cdesc-Object.ri')
-
-    assert_file File.join(@tmpdir, 'Object', 'attr-i.ri')
-    assert_file File.join(@tmpdir, 'Object', 'method-i.ri')
-    assert_file File.join(@tmpdir, 'Object', 'method%21-i.ri')
-
-    store = RDoc::RI::Store.new(@options, path: @tmpdir)
-    store.load_cache
-
-    encoding = Encoding::UTF_8
-
-    assert_equal encoding, store.encoding
-  end
-
-  def test_generate_dry_run
-    @store.dry_run = true
-    @g = RDoc::Generator::RI.new @store, @options
-
-    top_level = @store.add_file 'file.rb'
-    top_level.add_class @klass.class, @klass.name
-
-    @g.generate
-
-    refute_file File.join(@tmpdir, 'cache.ri')
-    refute_file File.join(@tmpdir, 'Object')
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc_i18n_locale_test.rb b/test/mri/rdoc/rdoc_i18n_locale_test.rb
deleted file mode 100644
index cfbc7c5bb2a..00000000000
--- a/test/mri/rdoc/rdoc_i18n_locale_test.rb
+++ /dev/null
@@ -1,74 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocI18nLocaleTest < RDoc::TestCase
-
-  def setup
-    super
-    @locale = locale('fr')
-
-    @tmpdir = File.join Dir.tmpdir, "test_rdoc_i18n_locale_#{$$}"
-    FileUtils.mkdir_p @tmpdir
-
-    @locale_dir = @tmpdir
-  end
-
-  def teardown
-    FileUtils.rm_rf @tmpdir
-    super
-  end
-
-  def test_name
-    assert_equal 'fr', locale('fr').name
-  end
-
-  def test_load_nonexistent_po
-    locale = File.join(@locale_dir, 'nonexsitent-locale')
-    refute_file locale
-    refute @locale.load(locale)
-  end
-
-  def test_load_existent_po
-    begin
-      require 'gettext/po_parser'
-    rescue LoadError
-      omit 'gettext gem is not found'
-    end
-
-    fr_locale_dir = File.join @locale_dir, 'fr'
-    FileUtils.mkdir_p fr_locale_dir
-    File.open File.join(fr_locale_dir, 'rdoc.po'), 'w' do |po|
-      po.puts <<-PO
-msgid ""
-msgstr ""
-"Language: fr\n"
-"MIME-Version: 1.0\n"
-"Content-Type: text/plain; charset=UTF-8\n"
-"Content-Transfer-Encoding: 8bit\n"
-
-msgid "Hello"
-msgstr "Bonjour"
-      PO
-    end
-
-    assert @locale.load(@locale_dir)
-    assert_equal 'Bonjour', @locale.translate('Hello')
-  end
-
-  def test_translate_existent_message
-    messages = @locale.instance_variable_get(:@messages)
-    messages['Hello'] = 'Bonjour'
-    assert_equal 'Bonjour', @locale.translate('Hello')
-  end
-
-  def test_translate_nonexistent_message
-    assert_equal 'Hello', @locale.translate('Hello')
-  end
-
-  private
-
-  def locale(name)
-    RDoc::I18n::Locale.new(name)
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc_i18n_text_test.rb b/test/mri/rdoc/rdoc_i18n_text_test.rb
deleted file mode 100644
index 888479d20da..00000000000
--- a/test/mri/rdoc/rdoc_i18n_text_test.rb
+++ /dev/null
@@ -1,124 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocI18nTextTest < RDoc::TestCase
-
-  def test_multiple_paragraphs
-    paragraph1 = <<-PARAGRAPH.strip
-RDoc produces HTML and command-line documentation for Ruby projects.  RDoc
-includes the +rdoc+ and +ri+ tools for generating and displaying documentation
-from the command-line.
-    PARAGRAPH
-
-    paragraph2 = <<-PARAGRAPH.strip
-This command generates documentation for all the Ruby and C source
-files in and below the current directory.  These will be stored in a
-documentation tree starting in the subdirectory +doc+.
-    PARAGRAPH
-
-    raw = <<-RAW
-#{paragraph1}
-
-#{paragraph2}
-    RAW
-
-    expected = [
-      {
-        :type      => :paragraph,
-        :paragraph => paragraph1,
-        :line_no   => 1,
-      },
-      {
-        :type      => :paragraph,
-        :paragraph => paragraph2,
-        :line_no   => 5,
-      },
-    ]
-    assert_equal expected, extract_messages(raw)
-  end
-
-  def test_translate_multiple_paragraphs
-    paragraph1 = <<-PARAGRAPH.strip
-Paragraph 1.
-    PARAGRAPH
-    paragraph2 = <<-PARAGRAPH.strip
-Paragraph 2.
-    PARAGRAPH
-
-    raw = <<-RAW
-#{paragraph1}
-
-#{paragraph2}
-    RAW
-
-    expected = <<-TRANSLATED
-Paragraphe 1.
-
-Paragraphe 2.
-    TRANSLATED
-    assert_equal expected, translate(raw)
-  end
-
-  def test_translate_not_translated_message
-    nonexistent_paragraph = <<-PARAGRAPH.strip
-Nonexistent paragraph.
-    PARAGRAPH
-
-    raw = <<-RAW
-#{nonexistent_paragraph}
-    RAW
-
-    expected = <<-TRANSLATED
-#{nonexistent_paragraph}
-    TRANSLATED
-    assert_equal expected, translate(raw)
-  end
-
-  def test_translate_keep_empty_lines
-    raw = <<-RAW
-Paragraph 1.
-
-
-
-
-Paragraph 2.
-    RAW
-
-    expected = <<-TRANSLATED
-Paragraphe 1.
-
-
-
-
-Paragraphe 2.
-    TRANSLATED
-    assert_equal expected, translate(raw)
-  end
-
-  private
-
-  def extract_messages(raw)
-    text = RDoc::I18n::Text.new(raw)
-    messages = []
-    text.extract_messages do |message|
-      messages << message
-    end
-    messages
-  end
-
-  def locale
-    locale = RDoc::I18n::Locale.new('fr')
-    messages = locale.instance_variable_get(:@messages)
-    messages['markdown'] = 'markdown (markdown in fr)'
-    messages['Hello'] = 'Bonjour (Hello in fr)'
-    messages['Paragraph 1.'] = 'Paragraphe 1.'
-    messages['Paragraph 2.'] = 'Paragraphe 2.'
-    locale
-  end
-
-  def translate(raw)
-    text = RDoc::I18n::Text.new(raw)
-    text.translate(locale)
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc_include_test.rb b/test/mri/rdoc/rdoc_include_test.rb
deleted file mode 100644
index 6b78d2a749c..00000000000
--- a/test/mri/rdoc/rdoc_include_test.rb
+++ /dev/null
@@ -1,109 +0,0 @@
-# frozen_string_literal: true
-require_relative 'xref_test_case'
-
-class RDocIncludeTest < XrefTestCase
-
-  def setup
-    super
-
-    @inc = RDoc::Include.new 'M1', 'comment'
-    @inc.parent = @m1
-    @inc.record_location @top_level
-    @inc.store = @store
-  end
-
-  def test_module
-    assert_equal @m1, @inc.module
-    assert_equal 'Unknown', RDoc::Include.new('Unknown', 'comment').module
-  end
-
-  def test_module_extended
-    m1 = @xref_data.add_module RDoc::NormalModule, 'Mod1'
-    m1_m3 = m1.add_module RDoc::NormalModule, 'Mod3'
-    m1_m2 = m1.add_module RDoc::NormalModule, 'Mod2'
-    m1_m2_m3 = m1_m2.add_module RDoc::NormalModule, 'Mod3'
-    m1_m2_m3_m4 = m1_m2_m3.add_module RDoc::NormalModule, 'Mod4'
-    m1_m2_m4 = m1_m2.add_module RDoc::NormalModule, 'Mod4'
-    m1_m2_k0 = m1_m2.add_class RDoc::NormalClass, 'Klass0'
-    m1_m2_k0_m4 = m1_m2_k0.add_module RDoc::NormalModule, 'Mod4'
-    #m1_m2_k0_m4_m5 = m1_m2_k0_m4.add_module RDoc::NormalModule, 'Mod5'
-    m1_m2_k0_m4_m6 = m1_m2_k0_m4.add_module RDoc::NormalModule, 'Mod6'
-    m1_m2_k0_m5 = m1_m2_k0.add_module RDoc::NormalModule, 'Mod5'
-
-    i0_m4 = RDoc::Include.new 'Mod4', nil
-    i0_m5 = RDoc::Include.new 'Mod5', nil
-    i0_m6 = RDoc::Include.new 'Mod6', nil
-    i0_m1 = RDoc::Include.new 'Mod1', nil
-    i0_m2 = RDoc::Include.new 'Mod2', nil
-    i0_m3 = RDoc::Include.new 'Mod3', nil
-
-    m1_m2_k0.add_include i0_m4
-    m1_m2_k0.add_include i0_m5
-    m1_m2_k0.add_include i0_m6
-    m1_m2_k0.add_include i0_m1
-    m1_m2_k0.add_include i0_m2
-    m1_m2_k0.add_include i0_m3
-
-    assert_equal [i0_m4, i0_m5, i0_m6, i0_m1, i0_m2, i0_m3], m1_m2_k0.includes
-    assert_equal [m1_m2_m3, m1_m2, m1, m1_m2_k0_m4_m6, m1_m2_k0_m5,
-                  m1_m2_k0_m4, @object, 'BasicObject'], m1_m2_k0.ancestors
-
-    m1_k1 = m1.add_class RDoc::NormalClass, 'Klass1'
-
-    i1_m1 = RDoc::Include.new 'Mod1', nil
-    i1_m2 = RDoc::Include.new 'Mod2', nil
-    i1_m3 = RDoc::Include.new 'Mod3', nil
-    i1_m4 = RDoc::Include.new 'Mod4', nil
-    i1_k0_m4 = RDoc::Include.new 'Klass0::Mod4', nil
-
-    m1_k1.add_include i1_m1
-    m1_k1.add_include i1_m2
-    m1_k1.add_include i1_m3
-    m1_k1.add_include i1_m4
-    m1_k1.add_include i1_k0_m4
-
-    assert_equal [i1_m1, i1_m2, i1_m3, i1_m4, i1_k0_m4], m1_k1.includes
-    assert_equal [m1_m2_k0_m4, m1_m2_m3_m4, m1_m2_m3, m1_m2, m1, @object,
-                  'BasicObject'], m1_k1.ancestors
-
-    m1_k2 = m1.add_class RDoc::NormalClass, 'Klass2'
-
-    i2_m1 = RDoc::Include.new 'Mod1', nil
-    i2_m2 = RDoc::Include.new 'Mod2', nil
-    i2_m3 = RDoc::Include.new 'Mod3', nil
-    i2_k0_m4 = RDoc::Include.new 'Klass0::Mod4', nil
-
-    m1_k2.add_include i2_m1
-    m1_k2.add_include i2_m3
-    m1_k2.add_include i2_m2
-    m1_k2.add_include i2_k0_m4
-
-    assert_equal [i2_m1, i2_m3, i2_m2, i2_k0_m4], m1_k2.includes
-    assert_equal [m1_m2_k0_m4, m1_m2, m1_m3, m1, @object, 'BasicObject'],
-                 m1_k2.ancestors
-
-    m1_k3 = m1.add_class RDoc::NormalClass, 'Klass3'
-
-    i3_m1 = RDoc::Include.new 'Mod1', nil
-    i3_m2 = RDoc::Include.new 'Mod2', nil
-    i3_m4 = RDoc::Include.new 'Mod4', nil
-
-    m1_k3.add_include i3_m1
-    m1_k3.add_include i3_m2
-    m1_k3.add_include i3_m4
-
-    assert_equal [i3_m1, i3_m2, i3_m4], m1_k3.includes
-    assert_equal [m1_m2_m4, m1_m2, m1, @object, 'BasicObject'], m1_k3.ancestors
-  end
-
-  def test_store_equals
-    incl = RDoc::Include.new 'M', nil
-    incl.record_location RDoc::TopLevel.new @top_level.name
-
-    incl.store = @store
-
-    assert_same @top_level, incl.file
-    assert_same @store,     incl.file.store
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc_markdown_test.rb b/test/mri/rdoc/rdoc_markdown_test.rb
deleted file mode 100644
index 2764f94becd..00000000000
--- a/test/mri/rdoc/rdoc_markdown_test.rb
+++ /dev/null
@@ -1,1140 +0,0 @@
-# coding: UTF-8
-# frozen_string_literal: true
-
-require_relative 'helper'
-require_relative '../../lib/rdoc/markup/block_quote'
-require_relative '../../lib/rdoc/markdown'
-
-class RDocMarkdownTest < RDoc::TestCase
-
-  def setup
-    super
-
-    @RM = RDoc::Markup
-
-    @parser = RDoc::Markdown.new
-
-    @to_html = RDoc::Markup::ToHtml.new(RDoc::Options.new, nil)
-  end
-
-  def test_class_parse
-    doc = RDoc::Markdown.parse "hello\n\nworld"
-
-    expected = doc(para("hello"), para("world"))
-
-    assert_equal expected, doc
-  end
-
-  def test_emphasis
-    assert_equal '_word_',             @parser.emphasis('word')
-    assert_equal '<em>two words</em>', @parser.emphasis('two words')
-    assert_equal '<em>*bold*</em>',    @parser.emphasis('*bold*')
-  end
-
-  def test_parse_auto_link_email
-    doc = parse "Autolink: <nobody-0+_./!%~$@example>"
-
-    expected = doc(para("Autolink: mailto:nobody-0+_./!%~$@example"))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_auto_link_url
-    doc = parse "Autolink: <http://example>"
-
-    expected = doc(para("Autolink: http://example"))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_block_quote
-    doc = parse <<-BLOCK_QUOTE
-> this is
-> a block quote
-    BLOCK_QUOTE
-
-    expected =
-      doc(
-        block(
-          para("this is\na block quote")))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_block_quote_continue
-    doc = parse <<-BLOCK_QUOTE
-> this is
-a block quote
-    BLOCK_QUOTE
-
-    expected =
-      doc(
-        block(
-          para("this is\na block quote")))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_block_quote_list
-    doc = parse <<-BLOCK_QUOTE
-> text
->
-> * one
-> * two
-    BLOCK_QUOTE
-
-    expected =
-      doc(
-        block(
-          para("text"),
-          list(:BULLET,
-            item(nil, para("one")),
-            item(nil, para("two")))))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_block_quote_newline
-    doc = parse <<-BLOCK_QUOTE
-> this is
-a block quote
-
-    BLOCK_QUOTE
-
-    expected =
-      doc(
-        block(
-          para("this is\na block quote")))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_block_quote_separate
-    doc = parse <<-BLOCK_QUOTE
-> this is
-a block quote
-
-> that continues
-    BLOCK_QUOTE
-
-    expected =
-      doc(
-        block(
-          para("this is\na block quote"),
-          para("that continues")))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_char_entity
-    doc = parse 'π &nn;'
-
-    expected = doc(para('π &nn;'))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_code
-    doc = parse "Code: `text`"
-    expected = doc(para("Code: <code>text</code>"))
-    assert_equal expected, doc
-
-    doc = parse "Code: ` text `"
-    expected = doc(para("Code: <code>text</code>"))
-    assert_equal expected, doc
-
-    doc = parse "Code: ``text`s``"
-    expected = doc(para("Code: <code>text`s</code>"))
-    assert_equal expected, doc
-
-    doc = parse "Code: `` text`s ``"
-    expected = doc(para("Code: <code>text`s</code>"))
-    assert_equal expected, doc
-
-    doc = parse "Code: ```text`s```"
-    expected = doc(para("Code: <code>text`s</code>"))
-    assert_equal expected, doc
-
-    doc = parse "Code: ``` text`s ```"
-    expected = doc(para("Code: <code>text`s</code>"))
-    assert_equal expected, doc
-  end
-
-  def test_parse_code_github
-    doc = <<-MD
-Example:
-
-```
-code goes here
-```
-    MD
-
-    expected =
-      doc(
-        para("Example:"),
-        verb("code goes here\n"))
-
-    assert_equal expected, parse(doc)
-    assert_equal expected, parse(doc.sub(/^\n/, ''))
-
-    @parser.github = false
-
-    expected =
-      doc(para("Example:"),
-          para("<code>\n""code goes here\n</code>"))
-
-    assert_equal expected, parse(doc)
-
-    expected =
-      doc(para("Example:\n<code>\n""code goes here\n</code>"))
-
-    assert_equal expected, parse(doc.sub(/^\n/, ''))
-  end
-
-  def test_parse_code_github_format
-    doc = <<-MD
-Example:
-
-``` ruby
-code goes here
-```
-    MD
-
-    code = verb("code goes here\n")
-    code.format = :ruby
-
-    expected =
-      doc(
-        para("Example:"),
-        code)
-
-    assert_equal expected, parse(doc)
-    assert_equal expected, parse(doc.sub(/^\n/, ''))
-
-    @parser.github = false
-
-    expected =
-      doc(para("Example:"),
-          para("<code>ruby\n""code goes here\n</code>"))
-
-    assert_equal expected, parse(doc)
-
-    expected =
-      doc(para("Example:\n<code>ruby\n""code goes here\n</code>"))
-
-    assert_equal expected, parse(doc.sub(/^\n/, ''))
-  end
-
-  def test_parse_definition_list
-    doc = parse <<-MD
-one
-:   This is a definition
-
-two
-:   This is another definition
-    MD
-
-    expected = doc(
-      list(:NOTE,
-        item(%w[one], para("This is a definition")),
-        item(%w[two], para("This is another definition"))))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_definition_list_indents
-    doc = parse <<-MD
-zero
-: Indented zero characters
-
-one
- : Indented one characters
-
-two
-  : Indented two characters
-
-three
-   : Indented three characters
-
-four
-    : Indented four characters
-
-    MD
-
-    expected = doc(
-      list(:NOTE,
-        item(%w[zero],  para("Indented zero characters")),
-        item(%w[one],   para("Indented one characters")),
-        item(%w[two],   para("Indented two characters")),
-        item(%w[three], para("Indented three characters"))),
-      para("four\n : Indented four characters"))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_definition_list_multi_description
-    doc = parse <<-MD
-label
-:   This is a definition
-
-:   This is another definition
-    MD
-
-    expected = doc(
-      list(:NOTE,
-        item(%w[label], para("This is a definition")),
-        item(nil,       para("This is another definition"))))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_definition_list_multi_label
-    doc = parse <<-MD
-one
-two
-:   This is a definition
-    MD
-
-    expected = doc(
-      list(:NOTE,
-        item(%w[one two], para("This is a definition"))))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_definition_list_multi_line
-    doc = parse <<-MD
-one
-:   This is a definition
-that extends to two lines
-
-two
-:   This is another definition
-that also extends to two lines
-    MD
-
-    expected = doc(
-      list(:NOTE,
-        item(%w[one],
-          para("This is a definition\nthat extends to two lines")),
-        item(%w[two],
-          para("This is another definition\nthat also extends to two lines"))))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_definition_list_rich_label
-    doc = parse <<-MD
-`one`
-:    This is a definition
-
-**two**
-:    This is another definition
-    MD
-
-    expected = doc(
-      list(:NOTE,
-        item(%w[<code>one</code>],
-          para("This is a definition")),
-        item(%w[*two*],
-          para("This is another definition"))))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_definition_list_no
-    @parser.definition_lists = false
-
-    doc = parse <<-MD
-one
-:   This is a definition
-
-two
-:   This is another definition
-    MD
-
-    expected = doc(
-        para("one\n: This is a definition"),
-        para("two\n: This is another definition"))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_entity_dec
-    doc = parse "Entity: A"
-
-    expected = doc(para("Entity: A"))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_entity_hex
-    doc = parse "Entity: A"
-
-    expected = doc(para("Entity: A"))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_entity_named
-    doc = parse "Entity: π"
-
-    expected = doc(para("Entity: π"))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_emphasis_star
-    doc = parse "it *works*\n"
-
-    expected = @RM::Document.new(
-      @RM::Paragraph.new("it _works_"))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_emphasis_underscore
-    doc = parse "it _works_\n"
-
-    expected =
-      doc(
-        para("it _works_"))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_emphasis_underscore_embedded
-    doc = parse "foo_bar bar_baz\n"
-
-    expected =
-      doc(
-        para("foo_bar bar_baz"))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_emphasis_underscore_in_word
-    doc = parse "it foo_bar_baz\n"
-
-    expected =
-      doc(
-        para("it foo_bar_baz"))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_escape
-    assert_equal doc(para("Backtick: `")), parse("Backtick: \\`")
-
-    assert_equal doc(para("Backslash: \\")), parse("Backslash: \\\\")
-
-    assert_equal doc(para("Colon: :")), parse("Colon: \\:")
-  end
-
-  def test_parse_heading_atx
-    # CommonMark Example 62
-    (1..6).each do |level|
-      doc = parse "#{"#" * level} heading\n"
-
-      expected = @RM::Document.new(
-        @RM::Heading.new(level, "heading"))
-
-      assert_equal expected, doc
-    end
-
-    # CommonMark Example 64
-    doc = parse "#5 bolt\n\n#hashtag\n"
-
-    expected = @RM::Document.new(
-      para("#5 bolt"),
-      para("#hashtag"),
-    )
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_heading_setext_dash
-    doc = parse <<-MD
-heading
----
-    MD
-
-    expected = @RM::Document.new(
-      @RM::Heading.new(2, "heading"))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_heading_setext_equals
-    doc = parse <<-MD
-heading
-===
-    MD
-
-    expected = @RM::Document.new(
-      @RM::Heading.new(1, "heading"))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_html
-    @parser.html = true
-
-    doc = parse "<address>Links here</address>\n"
-
-    expected = doc(
-      @RM::Raw.new("<address>Links here</address>"))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_html_hr
-    @parser.html = true
-
-    doc = parse "<hr>\n"
-
-    expected = doc(raw("<hr>"))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_html_no_html
-    @parser.html = false
-
-    doc = parse "<address>Links here</address>\n"
-
-    expected = doc()
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_image
-    doc = parse "image ![alt text](path/to/image.jpg)"
-
-    expected = doc(para("image rdoc-image:path/to/image.jpg:alt text"))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_image_link
-    @parser.html = true
-
-    doc = parse "[![alt text](path/to/image.jpg)](http://example.com)"
-
-    expected =
-      doc(
-        para('{rdoc-image:path/to/image.jpg:alt text}[http://example.com]'))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_line_break
-    doc = parse "Some text  \nwith extra lines"
-
-    expected = doc(
-      para("Some text", hard_break, "with extra lines"))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_link_reference_id
-    doc = parse <<-MD
-This is [an example][id] reference-style link.
-
-[id]: http://example.com "Optional Title Here"
-    MD
-
-    expected = doc(
-      para("This is {an example}[http://example.com] reference-style link."))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_link_reference_id_adjacent
-    doc = parse <<-MD
-[this] [this] should work
-
-[this]: example
-    MD
-
-    expected = doc(
-      para("{this}[example] should work"))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_link_reference_id_eof
-    doc = parse <<-MD.chomp
-This is [an example][id] reference-style link.
-
-[id]: http://example.com "Optional Title Here"
-    MD
-
-    expected = doc(
-      para("This is {an example}[http://example.com] reference-style link."))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_link_reference_id_many
-    doc = parse <<-MD
-This is [an example][id] reference-style link.
-
-And [another][id].
-
-[id]: http://example.com "Optional Title Here"
-    MD
-
-    expected = doc(
-      para("This is {an example}[http://example.com] reference-style link."),
-      para("And {another}[http://example.com]."))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_link_reference_implicit
-    doc = parse <<-MD
-This is [an example][] reference-style link.
-
-[an example]: http://example.com "Optional Title Here"
-    MD
-
-    expected = doc(
-      para("This is {an example}[http://example.com] reference-style link."))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_list_bullet
-    doc = parse <<-MD
-* one
-* two
-    MD
-
-    expected = doc(
-      list(:BULLET,
-        item(nil, para("one")),
-        item(nil, para("two"))))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_list_bullet_auto_link
-    doc = parse <<-MD
-* <http://example/>
-    MD
-
-    expected = doc(
-      list(:BULLET,
-        item(nil, para("http://example/"))))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_list_bullet_continue
-    doc = parse <<-MD
-* one
-
-* two
-    MD
-
-    expected = doc(
-      list(:BULLET,
-        item(nil, para("one")),
-        item(nil, para("two"))))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_list_bullet_multiline
-    doc = parse <<-MD
-* one
-  two
-    MD
-
-    expected = doc(
-      list(:BULLET,
-        item(nil, para("one\n two"))))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_list_bullet_nest
-    doc = parse <<-MD
-* outer
-    * inner
-    MD
-
-    expected = doc(
-      list(:BULLET,
-        item(nil,
-          para("outer"),
-          list(:BULLET,
-            item(nil,
-              para("inner"))))))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_list_bullet_nest_loose
-    doc = parse <<-MD
-* outer
-
-    * inner
-    MD
-
-    expected = doc(
-      list(:BULLET,
-        item(nil,
-          para("outer"),
-          list(:BULLET,
-            item(nil, para("inner"))))))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_list_bullet_nest_continue
-    doc = parse <<-MD
-* outer
-    * inner
-  continue inner
-* outer 2
-    MD
-
-    expected = doc(
-      list(:BULLET,
-        item(nil,
-          para("outer"),
-          list(:BULLET,
-            item(nil,
-              para("inner\n continue inner")))),
-        item(nil,
-          para("outer 2"))))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_list_number
-    doc = parse <<-MD
-1. one
-1. two
-    MD
-
-    expected = doc(
-      list(:NUMBER,
-        item(nil, para("one")),
-        item(nil, para("two"))))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_list_number_continue
-    doc = parse <<-MD
-1. one
-
-1. two
-    MD
-
-    expected = doc(
-      list(:NUMBER,
-        item(nil, para("one")),
-        item(nil, para("two"))))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_note
-    @parser.notes = true
-
-    doc = parse <<-MD
-Some text.[^1]
-
-[^1]: With a footnote
-    MD
-
-    expected = doc(
-      para("Some text.{*1}[rdoc-label:foottext-1:footmark-1]"),
-      @RM::Rule.new(1),
-      para("{^1}[rdoc-label:footmark-1:foottext-1] With a footnote"))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_note_indent
-    @parser.notes = true
-
-    doc = parse <<-MD
-Some text.[^1]
-
-[^1]: With a footnote
-
-    more
-    MD
-
-    expected = doc(
-      para("Some text.{*1}[rdoc-label:foottext-1:footmark-1]"),
-      rule(1),
-      para("{^1}[rdoc-label:footmark-1:foottext-1] With a footnote\n\nmore"))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_note_inline
-    @parser.notes = true
-
-    doc = parse <<-MD
-Some text. ^[With a footnote]
-    MD
-
-    expected = doc(
-      para("Some text. {*1}[rdoc-label:foottext-1:footmark-1]"),
-      @RM::Rule.new(1),
-      para("{^1}[rdoc-label:footmark-1:foottext-1] With a footnote"))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_note_no_notes
-    @parser.notes = false
-
-    assert_raise RDoc::Markdown::ParseError do
-      parse "Some text.[^1]"
-    end
-  end
-
-  def test_parse_note_multiple
-    @parser.notes = true
-
-    doc = parse <<-MD
-Some text[^1]
-with inline notes^[like this]
-and an extra note.[^2]
-
-[^1]: With a footnote
-[^2]: Which should be numbered correctly
-    MD
-
-    expected = doc(
-      para("Some text{*1}[rdoc-label:foottext-1:footmark-1]\n" +
-           "with inline notes{*2}[rdoc-label:foottext-2:footmark-2]\n" +
-           "and an extra note.{*3}[rdoc-label:foottext-3:footmark-3]"),
-
-      rule(1),
-
-      para("{^1}[rdoc-label:footmark-1:foottext-1] With a footnote"),
-      para("{^2}[rdoc-label:footmark-2:foottext-2] like this"),
-      para("{^3}[rdoc-label:footmark-3:foottext-3] " +
-           "Which should be numbered correctly"))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_paragraph
-    doc = parse "it worked\n"
-
-    expected = doc(para("it worked"))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_paragraph_break_on_newline
-    @parser.break_on_newline = true
-
-    doc = parse "one\ntwo\n"
-
-    expected = doc(para("one", hard_break, "two"))
-
-    assert_equal expected, doc
-
-    doc = parse "one  \ntwo\nthree\n"
-
-    expected = doc(para("one", hard_break, "two", hard_break, "three"))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_paragraph_stars
-    doc = parse "it worked ****\n"
-
-    expected = @RM::Document.new(
-      @RM::Paragraph.new("it worked ****"))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_paragraph_html
-    @parser.html = true
-
-    doc = parse "<address>Links here</address>"
-
-    expected = doc(raw("<address>Links here</address>"))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_paragraph_html_no_html
-    @parser.html = false
-
-    doc = parse "<address>Links here</address>"
-
-    expected = doc()
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_paragraph_indent_one
-    doc = parse <<-MD
- text
-    MD
-
-    expected = doc(para("text"))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_paragraph_indent_two
-    doc = parse <<-MD
-  text
-    MD
-
-    expected = doc(para("text"))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_paragraph_indent_three
-    doc = parse <<-MD
-   text
-    MD
-
-    expected = doc(para("text"))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_paragraph_multiline
-    doc = parse "one\ntwo"
-
-    expected = doc(para("one\ntwo"))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_paragraph_two
-    doc = parse "one\n\ntwo"
-
-    expected = @RM::Document.new(
-      @RM::Paragraph.new("one"),
-      @RM::Paragraph.new("two"))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_plain
-    doc = parse "it worked"
-
-    expected = @RM::Document.new(
-      @RM::Paragraph.new("it worked"))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_reference_link_embedded_bracket
-    doc = parse "With [embedded [brackets]] [b].\n\n[b]: /url/\n"
-
-    expected =
-      doc(
-        para("With {embedded [brackets]}[/url/]."))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_rule_dash
-    doc = parse "- - -\n\n"
-
-    expected = @RM::Document.new(@RM::Rule.new(1))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_rule_underscore
-    doc = parse "_ _ _\n\n"
-
-    expected = @RM::Document.new(@RM::Rule.new(1))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_rule_star
-    doc = parse "* * *\n\n"
-
-    expected = @RM::Document.new(@RM::Rule.new(1))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_strong_star
-    doc = parse "it **works**\n"
-
-    expected = @RM::Document.new(
-      @RM::Paragraph.new("it *works*"))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_strong_underscore
-    doc = parse "it __works__\n"
-
-    expected = @RM::Document.new(
-      @RM::Paragraph.new("it *works*"))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_strong_emphasis_star
-    doc = parse "it ***works***\n"
-
-    expected = @RM::Document.new(
-      @RM::Paragraph.new("it <b>_works_</b>"))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_strong_emphasis_underscore
-    doc = parse "it ___works___\n"
-
-    expected = @RM::Document.new(
-      @RM::Paragraph.new("it <b>_works_</b>"))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_strike_tilde
-    doc = parse "it ~~works~~\n"
-
-    expected = @RM::Document.new(
-      @RM::Paragraph.new("it ~works~"))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_strike_words_tilde
-    doc = parse "it ~~works fine~~\n"
-
-    expected = @RM::Document.new(
-      @RM::Paragraph.new("it <s>works fine</s>"))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_strike_tilde_no
-    @parser.strike = false
-
-    doc = parse "it ~~works fine~~\n"
-
-    expected = @RM::Document.new(
-      @RM::Paragraph.new("it ~~works fine~~"))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_style
-    @parser.css = true
-
-    doc = parse "<style>h1 { color: red }</style>\n"
-
-    expected = doc(
-      @RM::Raw.new("<style>h1 { color: red }</style>"))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_style_disabled
-    doc = parse "<style>h1 { color: red }</style>\n"
-
-    expected = doc()
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_verbatim
-    doc = parse <<-MD
-    text
-    MD
-
-    expected = doc(verb("text\n"))
-
-    assert_equal expected, doc
-  end
-
-  def test_parse_verbatim_eof
-    doc = parse "    text"
-
-    expected = doc(verb("text\n"))
-
-    assert_equal expected, doc
-  end
-
-  def test_strong
-    assert_equal '*word*',            @parser.strong('word')
-    assert_equal '<b>two words</b>',  @parser.strong('two words')
-    assert_equal '<b>_emphasis_</b>', @parser.strong('_emphasis_')
-  end
-
-  def test_code_fence_with_unintended_array
-    doc = parse '```<ruby>```'
-
-    expected = doc(verb('<ruby>'))
-
-    assert_equal expected, doc
-  end
-
-  def test_gfm_table
-    doc = parse <<~MD
-    |      |                 |compare-ruby|built-ruby|
-    |------|:----------------|-----------:|---------:|
-    |test  | 1               |     11.618M|   10.757M|
-    |      |                 |       1.08x|         -|
-    |test  | 10              |      1.849M|    1.723M|
-    |      |                 |       1.07x|         -|
-    MD
-
-    head = ["", "", "compare-ruby", "built-ruby"]
-    align = [nil, :left, :right, :right]
-    body = [
-      ["test", "1", "11.618M", "10.757M"],
-      ["", "", "1.08x", "-"],
-      ["test", "10", "1.849M", "1.723M"],
-      ["", "", "1.07x", "-"],
-    ]
-    expected = doc(@RM::Table.new(head, align, body))
-
-    assert_equal expected, doc
-  end
-
-  def test_gfm_table_2
-    doc = parse <<~'MD'
-    | Cmd | Returns | Meaning
-    ----- | :-----: | -------
-    |"b"  | boolean | True if file1 is a block device
-    "c"   | boolean | True if file1 is a character device
-    |"\|" | boolean | escaped bar \| test
-    MD
-
-    head = %w[Cmd Returns Meaning]
-    align = [nil, :center, nil]
-    body = [
-      ['"b"', 'boolean', 'True if file1 is a block device'],
-      ['"c"', 'boolean', 'True if file1 is a character device'],
-      ['"|"', 'boolean', 'escaped bar | test'],
-    ]
-    expected = doc(@RM::Table.new(head, align, body))
-
-    assert_equal expected, doc
-  end
-
-  def parse(text)
-    @parser.parse text
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc_markdown_test_test.rb b/test/mri/rdoc/rdoc_markdown_test_test.rb
deleted file mode 100644
index c28fe6bebdf..00000000000
--- a/test/mri/rdoc/rdoc_markdown_test_test.rb
+++ /dev/null
@@ -1,1883 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-require 'pp'
-
-require_relative '../../lib/rdoc'
-require_relative '../../lib/rdoc/markdown'
-
-class RDocMarkdownTestTest < RDoc::TestCase
-
-  MARKDOWN_TEST_PATH = File.expand_path '../MarkdownTest_1.0.3/', __FILE__
-
-  def setup
-    super
-
-    @parser = RDoc::Markdown.new
-  end
-
-  def test_amps_and_angle_encoding
-    input = File.read "#{MARKDOWN_TEST_PATH}/Amps and angle encoding.text"
-
-    doc = @parser.parse input
-
-    expected =
-      doc(
-        para("AT&T has an ampersand in their name."),
-        para("AT&T is another way to write it."),
-        para("This & that."),
-        para("4 < 5."),
-        para("6 > 5."),
-        para("Here's a {link}[http://example.com/?foo=1&bar=2] with " +
-             "an ampersand in the URL."),
-        para("Here's a link with an amersand in the link text: " +
-             "{AT&T}[http://att.com/]."),
-        para("Here's an inline {link}[/script?foo=1&bar=2]."),
-        para("Here's an inline {link}[/script?foo=1&bar=2]."))
-
-    assert_equal expected, doc
-  end
-
-  def test_auto_links
-    input = File.read "#{MARKDOWN_TEST_PATH}/Auto links.text"
-
-    doc = @parser.parse input
-
-    # TODO verify rdoc auto-links too
-    expected =
-      doc(
-        para("Link: http://example.com/."),
-        para("With an ampersand: http://example.com/?foo=1&bar=2"),
-        list(:BULLET,
-          item(nil, para("In a list?")),
-          item(nil, para("http://example.com/")),
-          item(nil, para("It should."))),
-        block(
-          para("Blockquoted: http://example.com/")),
-        para("Auto-links should not occur here: " +
-             "<code><http://example.com/></code>"),
-        verb("or here: <http://example.com/>\n"))
-
-    assert_equal expected, doc
-  end
-
-  def test_backslash_escapes
-    input = File.read "#{MARKDOWN_TEST_PATH}/Backslash escapes.text"
-
-    doc = @parser.parse input
-
-    expected =
-      doc(
-        para("These should all get escaped:"),
-
-        para("Backslash: \\"),
-        para("Backtick: `"),
-        para("Asterisk: *"),
-        para("Underscore: _"),
-        para("Left brace: {"),
-        para("Right brace: }"),
-        para("Left bracket: ["),
-        para("Right bracket: ]"),
-        para("Left paren: ("),
-        para("Right paren: )"),
-        para("Greater-than: >"),
-        para("Hash: #"),
-        para("Period: ."),
-        para("Bang: !"),
-        para("Plus: +"),
-        para("Minus: -"),
-
-        para("These should not, because they occur within a code block:"),
-
-        verb("Backslash: \\\\\n",
-             "\n",
-             "Backtick: \\`\n",
-             "\n",
-             "Asterisk: \\*\n",
-             "\n",
-             "Underscore: \\_\n",
-             "\n",
-             "Left brace: \\{\n",
-             "\n",
-             "Right brace: \\}\n",
-             "\n",
-             "Left bracket: \\[\n",
-             "\n",
-             "Right bracket: \\]\n",
-             "\n",
-             "Left paren: \$\n",
-             "\n",
-             "Right paren: \$\n",
-             "\n",
-             "Greater-than: \\>\n",
-             "\n",
-             "Hash: \\#\n",
-             "\n",
-             "Period: \\.\n",
-             "\n",
-             "Bang: \\!\n",
-             "\n",
-             "Plus: \\+\n",
-             "\n",
-             "Minus: \\-\n"),
-
-        para("Nor should these, which occur in code spans:"),
-
-        para("Backslash: <code>\\\\</code>"),
-        para("Backtick: <code>\\`</code>"),
-        para("Asterisk: <code>\\*</code>"),
-        para("Underscore: <code>\\_</code>"),
-        para("Left brace: <code>\\{</code>"),
-        para("Right brace: <code>\\}</code>"),
-        para("Left bracket: <code>\\[</code>"),
-        para("Right bracket: <code>\\]</code>"),
-        para("Left paren: <code>\$</code>"),
-        para("Right paren: <code>\$</code>"),
-        para("Greater-than: <code>\\></code>"),
-        para("Hash: <code>\\#</code>"),
-        para("Period: <code>\\.</code>"),
-        para("Bang: <code>\\!</code>"),
-        para("Plus: <code>\\+</code>"),
-        para("Minus: <code>\\-</code>"),
-
-        para("These should get escaped, even though they're matching pairs for\n" +
-             "other Markdown constructs:"),
-
-        para("\*asterisks\*"),
-        para("\_underscores\_"),
-        para("`backticks`"),
-
-        para("This is a code span with a literal backslash-backtick " +
-             "sequence: <code>\\`</code>"),
-
-        para("This is a tag with unescaped backticks " +
-             "<span attr='`ticks`'>bar</span>."),
-
-        para("This is a tag with backslashes " +
-             "<span attr='\\\\backslashes\\\\'>bar</span>."))
-
-    assert_equal expected, doc
-  end
-
-  def test_blockquotes_with_code_blocks
-    input = File.read "#{MARKDOWN_TEST_PATH}/Blockquotes with code blocks.text"
-
-    doc = @parser.parse input
-
-    expected =
-      doc(
-        block(
-          para("Example:"),
-          verb("sub status {\n",
-               "    print \"working\";\n",
-               "}\n"),
-          para("Or:"),
-          verb("sub status {\n",
-               "    return \"working\";\n",
-               "}\n")))
-
-    assert_equal expected, doc
-  end
-
-  def test_code_blocks
-    input = File.read "#{MARKDOWN_TEST_PATH}/Code Blocks.text"
-
-    doc = @parser.parse input
-
-    expected =
-      doc(
-        verb("code block on the first line\n"),
-        para("Regular text."),
-
-        verb("code block indented by spaces\n"),
-        para("Regular text."),
-
-        verb("the lines in this block  \n",
-             "all contain trailing spaces  \n"),
-        para("Regular Text."),
-
-        verb("code block on the last line\n"))
-
-    assert_equal expected, doc
-  end
-
-  def test_code_spans
-    input = File.read "#{MARKDOWN_TEST_PATH}/Code Spans.text"
-
-    doc = @parser.parse input
-
-    expected = doc(
-      para("<code><test a=\"</code> content of attribute <code>\"></code>"),
-      para("Fix for backticks within HTML tag: " +
-           "<span attr='`ticks`'>like this</span>"),
-      para("Here's how you put <code>`backticks`</code> in a code span."))
-
-    assert_equal expected, doc
-  end
-
-  def test_hard_wrapped_paragraphs_with_list_like_lines
-    input = File.read "#{MARKDOWN_TEST_PATH}/Hard-wrapped paragraphs with list-like lines.text"
-
-    doc = @parser.parse input
-
-    expected =
-      doc(
-        para("In Markdown 1.0.0 and earlier. Version\n" +
-             "8. This line turns into a list item.\n"   +
-             "Because a hard-wrapped line in the\n"     +
-             "middle of a paragraph looked like a\n"    +
-             "list item."),
-        para("Here's one with a bullet.\n" +
-             "* criminey."))
-
-    assert_equal expected, doc
-  end
-
-  def test_horizontal_rules
-    input = File.read "#{MARKDOWN_TEST_PATH}/Horizontal rules.text"
-
-    doc = @parser.parse input
-
-    expected =
-      doc(
-        para("Dashes:"),
-
-        rule(1),
-        rule(1),
-        rule(1),
-        rule(1),
-        verb("---\n"),
-
-        rule(1),
-        rule(1),
-        rule(1),
-        rule(1),
-        verb("- - -\n"),
-
-        para("Asterisks:"),
-
-        rule(1),
-        rule(1),
-        rule(1),
-        rule(1),
-        verb("***\n"),
-
-        rule(1),
-        rule(1),
-        rule(1),
-        rule(1),
-        verb("* * *\n"),
-
-        para("Underscores:"),
-
-        rule(1),
-        rule(1),
-        rule(1),
-        rule(1),
-        verb("___\n"),
-
-        rule(1),
-        rule(1),
-        rule(1),
-        rule(1),
-        verb("_ _ _\n"))
-
-    assert_equal expected, doc
-  end
-
-  def test_inline_html_advanced
-    input = File.read "#{MARKDOWN_TEST_PATH}/Inline HTML (Advanced).text"
-
-    @parser.html = true
-
-    doc = @parser.parse input
-
-    expected =
-      doc(
-        para("Simple block on one line:"),
-        raw("<div>foo</div>"),
-        para("And nested without indentation:"),
-        raw(<<-RAW.chomp))
-<div>
-<div>
-<div>
-foo
-</div>
-<div style=">"/>
-</div>
-<div>bar</div>
-</div>
-        RAW
-
-    assert_equal expected, doc
-  end
-
-  def test_inline_html_simple
-    input = File.read "#{MARKDOWN_TEST_PATH}/Inline HTML (Simple).text"
-
-    @parser.html = true
-
-    doc = @parser.parse input
-
-    expected =
-      doc(
-       para("Here's a simple block:"),
-       raw("<div>\n\tfoo\n</div>"),
-
-       para("This should be a code block, though:"),
-       verb("<div>\n",
-            "\tfoo\n",
-            "</div>\n"),
-
-       para("As should this:"),
-       verb("<div>foo</div>\n"),
-
-       para("Now, nested:"),
-       raw("<div>\n\t<div>\n\t\t<div>\n\t\t\tfoo\n" +
-           "\t\t</div>\n\t</div>\n</div>"),
-
-       para("This should just be an HTML comment:"),
-       raw(""),
-
-       para("Multiline:"),
-       raw(""),
-
-       para("Code block:"),
-       verb("\n"),
-
-       para("Just plain comment, with trailing spaces on the line:"),
-       raw(""),
-
-       para("Code:"),
-       verb("<hr />\n"),
-
-       para("Hr's:"),
-       raw("<hr>"),
-       raw("<hr/>"),
-       raw("<hr />"),
-
-       raw("<hr>"),
-       raw("<hr/>"),
-       raw("<hr />"),
-
-       raw("<hr class=\"foo\" id=\"bar\" />"),
-       raw("<hr class=\"foo\" id=\"bar\"/>"),
-       raw("<hr class=\"foo\" id=\"bar\" >"))
-
-    assert_equal expected, doc
-  end
-
-  def test_inline_html_comments
-    input = File.read "#{MARKDOWN_TEST_PATH}/Inline HTML comments.text"
-
-    doc = @parser.parse input
-
-    expected =
-      doc(
-        para("Paragraph one."),
-
-        raw(""),
-
-        raw(""),
-
-        para("Paragraph two."),
-
-        raw(""),
-
-        para("The end."))
-
-    assert_equal expected, doc
-  end
-
-  def test_links_inline_style
-    input = File.read "#{MARKDOWN_TEST_PATH}/Links, inline style.text"
-
-    doc = @parser.parse input
-
-    expected =
-      doc(
-        para("Just a {URL}[/url/]."),
-        para("{URL and title}[/url/]."),
-        para("{URL and title}[/url/]."),
-        para("{URL and title}[/url/]."),
-        para("{URL and title}[/url/]."),
-        para("{Empty}[]."))
-
-    assert_equal expected, doc
-  end
-
-  def test_links_reference_style
-    input = File.read "#{MARKDOWN_TEST_PATH}/Links, reference style.text"
-
-    doc = @parser.parse input
-
-    expected =
-      doc(
-        para("Foo {bar}[/url/]."),
-        para("Foo {bar}[/url/]."),
-        para("Foo {bar}[/url/]."),
-
-        para("With {embedded [brackets]}[/url/]."),
-
-        para("Indented {once}[/url]."),
-        para("Indented {twice}[/url]."),
-        para("Indented {thrice}[/url]."),
-        para("Indented [four][] times."),
-
-        verb("[four]: /url\n"),
-
-        rule(1),
-
-        para("{this}[foo] should work"),
-        para("So should {this}[foo]."),
-        para("And {this}[foo]."),
-        para("And {this}[foo]."),
-        para("And {this}[foo]."),
-
-        para("But not [that] []."),
-        para("Nor [that][]."),
-        para("Nor [that]."),
-
-        para("[Something in brackets like {this}[foo] should work]"),
-        para("[Same with {this}[foo].]"),
-
-        para("In this case, {this}[/somethingelse/] points to something else."),
-        para("Backslashing should suppress [this] and [this]."),
-
-        rule(1),
-
-        para("Here's one where the {link breaks}[/url/] across lines."),
-        para("Here's another where the {link breaks}[/url/] across lines, " +
-             "but with a line-ending space."))
-
-    assert_equal expected, doc
-  end
-
-  def test_links_shortcut_references
-    input = File.read "#{MARKDOWN_TEST_PATH}/Links, shortcut references.text"
-
-    doc = @parser.parse input
-
-    expected =
-      doc(
-        para("This is the {simple case}[/simple]."),
-        para("This one has a {line break}[/foo]."),
-        para("This one has a {line break}[/foo] with a line-ending space."),
-        para("{this}[/that] and the {other}[/other]"))
-
-    assert_equal expected, doc
-  end
-
-  def test_literal_quotes_in_titles
-    input = File.read "#{MARKDOWN_TEST_PATH}/Literal quotes in titles.text"
-
-    doc = @parser.parse input
-
-    # TODO support title attribute
-    expected =
-      doc(
-        para("Foo {bar}[/url/]."),
-        para("Foo {bar}[/url/]."))
-
-    assert_equal expected, doc
-  end
-
-  def test_markdown_documentation_basics
-    input = File.read "#{MARKDOWN_TEST_PATH}/Markdown Documentation - Basics.text"
-
-    doc = @parser.parse input
-
-    expected =
-      doc(
-        head(1, "Markdown: Basics"),
-
-        raw(<<-RAW.chomp),
-<ul id="ProjectSubmenu">
-    <li><a href="/projects/markdown/" title="Markdown Project Page">Main</a></li>
-    <li><a class="selected" title="Markdown Basics">Basics</a></li>
-    <li><a href="/projects/markdown/syntax" title="Markdown Syntax Documentation">Syntax</a></li>
-    <li><a href="/projects/markdown/license" title="Pricing and License Information">License</a></li>
-    <li><a href="/projects/markdown/dingus" title="Online Markdown Web Form">Dingus</a></li>
-</ul>
-        RAW
-
-        head(2, "Getting the Gist of Markdown's Formatting Syntax"),
-
-        para("This page offers a brief overview of what it's like to use Markdown.\n" +
-             "The {syntax page}[/projects/markdown/syntax] provides complete, detailed documentation for\n" +
-             "every feature, but Markdown should be very easy to pick up simply by\n" +
-             "looking at a few examples of it in action. The examples on this page\n" +
-             "are written in a before/after style, showing example syntax and the\n" +
-             "HTML output produced by Markdown."),
-
-        para("It's also helpful to simply try Markdown out; the {Dingus}[/projects/markdown/dingus] is a\n" +
-             "web application that allows you type your own Markdown-formatted text\n" +
-             "and translate it to XHTML."),
-
-        para("<b>Note:</b> This document is itself written using Markdown; you\n" +
-             "can {see the source for it by adding '.text' to the URL}[/projects/markdown/basics.text]."),
-
-        head(2, "Paragraphs, Headers, Blockquotes"),
-
-        para("A paragraph is simply one or more consecutive lines of text, separated\n" +
-             "by one or more blank lines. (A blank line is any line that looks like a\n" +
-             "blank line -- a line containing nothing spaces or tabs is considered\n" +
-             "blank.) Normal paragraphs should not be intended with spaces or tabs."),
-
-        para("Markdown offers two styles of headers: _Setext_ and _atx_.\n" +
-             "Setext-style headers for <code><h1></code> and <code><h2></code> are created by\n" +
-             "\"underlining\" with equal signs (<code>=</code>) and hyphens (<code>-</code>), respectively.\n" +
-             "To create an atx-style header, you put 1-6 hash marks (<code>#</code>) at the\n" +
-             "beginning of the line -- the number of hashes equals the resulting\n" +
-             "HTML header level."),
-
-        para("Blockquotes are indicated using email-style '<code>></code>' angle brackets."),
-
-        para("Markdown:"),
-
-        verb("A First Level Header\n",
-             "====================\n",
-             "\n",
-             "A Second Level Header\n",
-             "---------------------\n",
-             "\n",
-             "Now is the time for all good men to come to\n",
-             "the aid of their country. This is just a\n",
-             "regular paragraph.\n",
-             "\n",
-             "The quick brown fox jumped over the lazy\n",
-             "dog's back.\n",
-             "\n",
-             "### Header 3\n",
-             "\n",
-             "> This is a blockquote.\n",
-             "> \n",
-             "> This is the second paragraph in the blockquote.\n",
-             ">\n",
-             "> ## This is an H2 in a blockquote\n"),
-
-        para("Output:"),
-
-        verb("<h1>A First Level Header</h1>\n",
-             "\n",
-             "<h2>A Second Level Header</h2>\n",
-             "\n",
-             "<p>Now is the time for all good men to come to\n",
-             "the aid of their country. This is just a\n",
-             "regular paragraph.</p>\n",
-             "\n",
-             "<p>The quick brown fox jumped over the lazy\n",
-             "dog's back.</p>\n",
-             "\n",
-             "<h3>Header 3</h3>\n",
-             "\n",
-             "<blockquote>\n",
-             "    <p>This is a blockquote.</p>\n",
-             "\n",
-             "    <p>This is the second paragraph in the blockquote.</p>\n",
-             "\n",
-             "    <h2>This is an H2 in a blockquote</h2>\n",
-             "</blockquote>\n"),
-
-        head(3, "Phrase Emphasis"),
-        para("Markdown uses asterisks and underscores to indicate spans of emphasis."),
-
-        para("Markdown:"),
-
-        verb("Some of these words *are emphasized*.\n",
-             "Some of these words _are emphasized also_.\n",
-             "\n",
-             "Use two asterisks for **strong emphasis**.\n",
-             "Or, if you prefer, __use two underscores instead__.\n"),
-
-        para("Output:"),
-
-        verb("<p>Some of these words <em>are emphasized</em>.\n",
-             "Some of these words <em>are emphasized also</em>.</p>\n",
-             "\n",
-             "<p>Use two asterisks for <strong>strong emphasis</strong>.\n",
-             "Or, if you prefer, <strong>use two underscores instead</strong>.</p>\n"),
-
-        head(2, "Lists"),
-
-        para("Unordered (bulleted) lists use asterisks, pluses, and hyphens (<code>*</code>,\n" +
-             "<code>+</code>, and <code>-</code>) as list markers. These three markers are\n" +
-             "interchangeable; this:"),
-
-        verb("*   Candy.\n",
-             "*   Gum.\n",
-             "*   Booze.\n"),
-
-        para("this:"),
-
-        verb("+   Candy.\n",
-             "+   Gum.\n",
-             "+   Booze.\n"),
-
-        para("and this:"),
-
-        verb("-   Candy.\n",
-             "-   Gum.\n",
-             "-   Booze.\n"),
-
-        para("all produce the same output:"),
-
-        verb("<ul>\n",
-             "<li>Candy.</li>\n",
-             "<li>Gum.</li>\n",
-             "<li>Booze.</li>\n",
-             "</ul>\n"),
-
-        para("Ordered (numbered) lists use regular numbers, followed by periods, as\n" +
-             "list markers:"),
-
-        verb("1.  Red\n",
-             "2.  Green\n",
-             "3.  Blue\n"),
-
-        para("Output:"),
-
-        verb("<ol>\n",
-             "<li>Red</li>\n",
-             "<li>Green</li>\n",
-             "<li>Blue</li>\n",
-             "</ol>\n"),
-
-        para("If you put blank lines between items, you'll get <code><p></code> tags for the\n" +
-             "list item text. You can create multi-paragraph list items by indenting\n" +
-             "the paragraphs by 4 spaces or 1 tab:"),
-
-        verb("*   A list item.\n",
-             "\n",
-             "    With multiple paragraphs.\n",
-             "\n",
-             "*   Another item in the list.\n"),
-
-        para("Output:"),
-
-        verb("<ul>\n",
-             "<li><p>A list item.</p>\n",
-             "<p>With multiple paragraphs.</p></li>\n",
-             "<li><p>Another item in the list.</p></li>\n",
-             "</ul>\n"),
-
-        head(3, "Links"),
-
-        para("Markdown supports two styles for creating links: _inline_ and\n" +
-             "_reference_. With both styles, you use square brackets to delimit the\n" +
-             "text you want to turn into a link."),
-
-        para("Inline-style links use parentheses immediately after the link text.\n" +
-             "For example:"),
-
-        verb("This is an [example link](http://example.com/).\n"),
-
-        para("Output:"),
-
-        verb("<p>This is an <a href=\"http://example.com/\">\n",
-             "example link</a>.</p>\n"),
-
-        para("Optionally, you may include a title attribute in the parentheses:"),
-
-        verb("This is an [example link](http://example.com/ \"With a Title\").\n"),
-
-        para("Output:"),
-
-        verb("<p>This is an <a href=\"http://example.com/\" title=\"With a Title\">\n",
-             "example link</a>.</p>\n"),
-
-        para("Reference-style links allow you to refer to your links by names, which\n" +
-             "you define elsewhere in your document:"),
-
-        verb("I get 10 times more traffic from [Google][1] than from\n",
-             "[Yahoo][2] or [MSN][3].\n",
-             "\n",
-             "[1]: http://google.com/        \"Google\"\n",
-             "[2]: http://search.yahoo.com/  \"Yahoo Search\"\n",
-             "[3]: http://search.msn.com/    \"MSN Search\"\n"),
-
-        para("Output:"),
-
-        verb("<p>I get 10 times more traffic from <a href=\"http://google.com/\"\n",
-             "title=\"Google\">Google</a> than from <a href=\"http://search.yahoo.com/\"\n",
-             "title=\"Yahoo Search\">Yahoo</a> or <a href=\"http://search.msn.com/\"\n",
-             "title=\"MSN Search\">MSN</a>.</p>\n"),
-
-        para("The title attribute is optional. Link names may contain letters,\n" +
-             "numbers and spaces, but are _not_ case sensitive:"),
-
-        verb("I start my morning with a cup of coffee and\n",
-             "[The New York Times][NY Times].\n",
-             "\n",
-             "[ny times]: http://www.nytimes.com/\n"),
-
-        para("Output:"),
-
-        verb("<p>I start my morning with a cup of coffee and\n",
-             "<a href=\"http://www.nytimes.com/\">The New York Times</a>.</p>\n"),
-
-        head(3, "Images"),
-
-        para("Image syntax is very much like link syntax."),
-
-        para("Inline (titles are optional):"),
-
-        verb("![alt text](/path/to/img.jpg \"Title\")\n"),
-
-        para("Reference-style:"),
-
-        verb("![alt text][id]\n",
-             "\n",
-             "[id]: /path/to/img.jpg \"Title\"\n"),
-
-        para("Both of the above examples produce the same output:"),
-
-        verb("<img src=\"/path/to/img.jpg\" alt=\"alt text\" title=\"Title\" />\n"),
-
-        head(3, "Code"),
-
-        para("In a regular paragraph, you can create code span by wrapping text in\n" +
-             "backtick quotes. Any ampersands (<code>&</code>) and angle brackets (<code><</code> or\n" +
-             "<code>></code>) will automatically be translated into HTML entities. This makes\n" +
-             "it easy to use Markdown to write about HTML example code:"),
-
-        verb(
-             "I strongly recommend against using any `<blink>` tags.\n",
-             "\n",
-             "I wish SmartyPants used named entities like `—`\n",
-             "instead of decimal-encoded entities like `—`.\n"),
-
-        para("Output:"),
-
-        verb("<p>I strongly recommend against using any\n",
-             "<code><blink></code> tags.</p>\n",
-             "\n",
-             "<p>I wish SmartyPants used named entities like\n",
-             "<code>&mdash;</code> instead of decimal-encoded\n",
-             "entities like <code>&#8212;</code>.</p>\n"),
-
-        para("To specify an entire block of pre-formatted code, indent every line of\n" +
-             "the block by 4 spaces or 1 tab. Just like with code spans, <code>&</code>, <code><</code>,\n" +
-             "and <code>></code> characters will be escaped automatically."),
-
-        para("Markdown:"),
-
-        verb("If you want your page to validate under XHTML 1.0 Strict,\n",
-             "you've got to put paragraph tags in your blockquotes:\n",
-             "\n",
-             "    <blockquote>\n",
-             "        <p>For example.</p>\n",
-             "    </blockquote>\n"),
-
-        para("Output:"),
-
-        verb("<p>If you want your page to validate under XHTML 1.0 Strict,\n",
-             "you've got to put paragraph tags in your blockquotes:</p>\n",
-             "\n",
-             "<pre><code><blockquote>\n",
-             "    <p>For example.</p>\n",
-             "</blockquote>\n",
-             "</code></pre>\n"))
-
-    assert_equal expected, doc
-  end
-
-  def test_markdown_documentation_syntax
-    input = File.read "#{MARKDOWN_TEST_PATH}/Markdown Documentation - Syntax.text"
-
-    doc = @parser.parse input
-
-    expected =
-      doc(
-        head(1, "Markdown: Syntax"),
-
-        raw(<<-RAW.chomp),
-<ul id="ProjectSubmenu">
-    <li><a href="/projects/markdown/" title="Markdown Project Page">Main</a></li>
-    <li><a href="/projects/markdown/basics" title="Markdown Basics">Basics</a></li>
-    <li><a class="selected" title="Markdown Syntax Documentation">Syntax</a></li>
-    <li><a href="/projects/markdown/license" title="Pricing and License Information">License</a></li>
-    <li><a href="/projects/markdown/dingus" title="Online Markdown Web Form">Dingus</a></li>
-</ul>
-        RAW
-
-        list(:BULLET,
-          item(nil,
-            para("{Overview}[#overview]"),
-            list(:BULLET,
-              item(nil,
-                para("{Philosophy}[#philosophy]")),
-              item(nil,
-                para("{Inline HTML}[#html]")),
-              item(nil,
-                para("{Automatic Escaping for Special Characters}[#autoescape]")))),
-          item(nil,
-            para("{Block Elements}[#block]"),
-            list(:BULLET,
-              item(nil,
-                para("{Paragraphs and Line Breaks}[#p]")),
-              item(nil,
-                para("{Headers}[#header]")),
-              item(nil,
-                para("{Blockquotes}[#blockquote]")),
-              item(nil,
-                para("{Lists}[#list]")),
-              item(nil,
-                para("{Code Blocks}[#precode]")),
-              item(nil,
-                para("{Horizontal Rules}[#hr]")))),
-          item(nil,
-            para("{Span Elements}[#span]"),
-            list(:BULLET,
-              item(nil,
-                para("{Links}[#link]")),
-              item(nil,
-                para("{Emphasis}[#em]")),
-              item(nil,
-                para("{Code}[#code]")),
-              item(nil,
-                para("{Images}[#img]")))),
-          item(nil,
-            para("{Miscellaneous}[#misc]"),
-            list(:BULLET,
-              item(nil,
-                para("{Backslash Escapes}[#backslash]")),
-              item(nil,
-                para("{Automatic Links}[#autolink]"))))),
-
-        para("<b>Note:</b> This document is itself written using Markdown; you\n" +
-             "can {see the source for it by adding '.text' to the URL}[/projects/markdown/syntax.text]."),
-
-        rule(1),
-
-        raw("<h2 id=\"overview\">Overview</h2>"),
-
-        raw("<h3 id=\"philosophy\">Philosophy</h3>"),
-
-        para("Markdown is intended to be as easy-to-read and easy-to-write as is feasible."),
-
-        para("Readability, however, is emphasized above all else. A Markdown-formatted\n" +
-             "document should be publishable as-is, as plain text, without looking\n" +
-             "like it's been marked up with tags or formatting instructions. While\n" +
-             "Markdown's syntax has been influenced by several existing text-to-HTML\n" +
-             "filters -- including {Setext}[http://docutils.sourceforge.net/mirror/setext.html], {atx}[http://www.aaronsw.com/2002/atx/], {Textile}[http://textism.com/tools/textile/], {reStructuredText}[http://docutils.sourceforge.net/rst.html],\n" +
-             "{Grutatext}[http://www.triptico.com/software/grutatxt.html], and {EtText}[http://ettext.taint.org/doc/] -- the single biggest source of\n" +
-             "inspiration for Markdown's syntax is the format of plain text email."),
-
-        para("To this end, Markdown's syntax is comprised entirely of punctuation\n" +
-             "characters, which punctuation characters have been carefully chosen so\n" +
-             "as to look like what they mean. E.g., asterisks around a word actually\n" +
-             "look like \*emphasis\*. Markdown lists look like, well, lists. Even\n" +
-             "blockquotes look like quoted passages of text, assuming you've ever\n" +
-             "used email."),
-
-        raw("<h3 id=\"html\">Inline HTML</h3>"),
-
-        para("Markdown's syntax is intended for one purpose: to be used as a\n" +
-             "format for _writing_ for the web."),
-
-        para("Markdown is not a replacement for HTML, or even close to it. Its\n" +
-             "syntax is very small, corresponding only to a very small subset of\n" +
-             "HTML tags. The idea is _not_ to create a syntax that makes it easier\n" +
-             "to insert HTML tags. In my opinion, HTML tags are already easy to\n" +
-             "insert. The idea for Markdown is to make it easy to read, write, and\n" +
-             "edit prose. HTML is a _publishing_ format; Markdown is a _writing_\n" +
-             "format. Thus, Markdown's formatting syntax only addresses issues that\n" +
-             "can be conveyed in plain text."),
-
-        para("For any markup that is not covered by Markdown's syntax, you simply\n" +
-             "use HTML itself. There's no need to preface it or delimit it to\n" +
-             "indicate that you're switching from Markdown to HTML; you just use\n" +
-             "the tags."),
-
-        para("The only restrictions are that block-level HTML elements -- e.g. <code><div></code>,\n" +
-             "<code><table></code>, <code><pre></code>, <code><p></code>, etc. -- must be separated from surrounding\n" +
-             "content by blank lines, and the start and end tags of the block should\n" +
-             "not be indented with tabs or spaces. Markdown is smart enough not\n" +
-             "to add extra (unwanted) <code><p></code> tags around HTML block-level tags."),
-
-        para("For example, to add an HTML table to a Markdown article:"),
-
-        verb("This is a regular paragraph.\n",
-             "\n",
-             "<table>\n",
-             "    <tr>\n",
-             "        <td>Foo</td>\n",
-             "    </tr>\n",
-             "</table>\n",
-             "\n",
-             "This is another regular paragraph.\n"),
-
-        para("Note that Markdown formatting syntax is not processed within block-level\n" +
-             "HTML tags. E.g., you can't use Markdown-style <code>*emphasis*</code> inside an\n" +
-             "HTML block."),
-
-        para("Span-level HTML tags -- e.g. <code><span></code>, <code><cite></code>, or <code><del></code> -- can be\n" +
-             "used anywhere in a Markdown paragraph, list item, or header. If you\n" +
-             "want, you can even use HTML tags instead of Markdown formatting; e.g. if\n" +
-             "you'd prefer to use HTML <code><a></code> or <code><img></code> tags instead of Markdown's\n" +
-             "link or image syntax, go right ahead."),
-
-        para("Unlike block-level HTML tags, Markdown syntax _is_ processed within\n" +
-             "span-level tags."),
-
-        raw("<h3 id=\"autoescape\">Automatic Escaping for Special Characters</h3>"),
-
-        para("In HTML, there are two characters that demand special treatment: <code><</code>\n" +
-             "and <code>&</code>. Left angle brackets are used to start tags; ampersands are\n" +
-             "used to denote HTML entities. If you want to use them as literal\n" +
-             "characters, you must escape them as entities, e.g. <code><</code>, and\n" +
-             "<code>&</code>."),
-
-        para("Ampersands in particular are bedeviling for web writers. If you want to\n" +
-             "write about 'AT&T', you need to write '<code>AT&T</code>'. You even need to\n" +
-             "escape ampersands within URLs. Thus, if you want to link to:"),
-
-        verb("http://images.google.com/images?num=30&q=larry+bird\n"),
-
-        para("you need to encode the URL as:"),
-
-        verb("http://images.google.com/images?num=30&q=larry+bird\n"),
-
-        para("in your anchor tag <code>href</code> attribute. Needless to say, this is easy to\n" +
-             "forget, and is probably the single most common source of HTML validation\n" +
-             "errors in otherwise well-marked-up web sites."),
-
-        para("Markdown allows you to use these characters naturally, taking care of\n" +
-             "all the necessary escaping for you. If you use an ampersand as part of\n" +
-             "an HTML entity, it remains unchanged; otherwise it will be translated\n" +
-             "into <code>&</code>."),
-
-        para("So, if you want to include a copyright symbol in your article, you can write:"),
-
-        verb("©\n"),
-
-        para("and Markdown will leave it alone. But if you write:"),
-
-        verb("AT&T\n"),
-
-        para("Markdown will translate it to:"),
-
-        verb("AT&T\n"),
-
-        para("Similarly, because Markdown supports {inline HTML}[#html], if you use\n" +
-             "angle brackets as delimiters for HTML tags, Markdown will treat them as\n" +
-             "such. But if you write:"),
-
-        verb("4 < 5\n"),
-
-        para("Markdown will translate it to:"),
-
-        verb("4 < 5\n"),
-
-        para("However, inside Markdown code spans and blocks, angle brackets and\n" +
-             "ampersands are _always_ encoded automatically. This makes it easy to use\n" +
-             "Markdown to write about HTML code. (As opposed to raw HTML, which is a\n" +
-             "terrible format for writing about HTML syntax, because every single <code><</code>\n" +
-             "and <code>&</code> in your example code needs to be escaped.)"),
-
-        rule(1),
-
-        raw("<h2 id=\"block\">Block Elements</h2>"),
-
-        raw("<h3 id=\"p\">Paragraphs and Line Breaks</h3>"),
-
-        para("A paragraph is simply one or more consecutive lines of text, separated\n" +
-             "by one or more blank lines. (A blank line is any line that looks like a\n" +
-             "blank line -- a line containing nothing but spaces or tabs is considered\n" +
-             "blank.) Normal paragraphs should not be intended with spaces or tabs."),
-
-        para("The implication of the \"one or more consecutive lines of text\" rule is\n" +
-             "that Markdown supports \"hard-wrapped\" text paragraphs. This differs\n" +
-             "significantly from most other text-to-HTML formatters (including Movable\n" +
-             "Type's \"Convert Line Breaks\" option) which translate every line break\n" +
-             "character in a paragraph into a <code><br /></code> tag."),
-
-        para("When you _do_ want to insert a <code><br /></code> break tag using Markdown, you\n" +
-             "end a line with two or more spaces, then type return."),
-
-        para("Yes, this takes a tad more effort to create a <code><br /></code>, but a simplistic\n" +
-             "\"every line break is a <code><br /></code>\" rule wouldn't work for Markdown.\n" +
-             "Markdown's email-style {blockquoting}[#blockquote] and multi-paragraph {list items}[#list]\n" +
-             "work best -- and look better -- when you format them with hard breaks."),
-
-        raw("<h3 id=\"header\">Headers</h3>"),
-
-        para("Markdown supports two styles of headers, {Setext}[http://docutils.sourceforge.net/mirror/setext.html] and {atx}[http://www.aaronsw.com/2002/atx/]."),
-
-        para("Setext-style headers are \"underlined\" using equal signs (for first-level\n" +
-             "headers) and dashes (for second-level headers). For example:"),
-
-        verb("This is an H1\n",
-             "=============\n",
-             "\n",
-             "This is an H2\n",
-             "-------------\n"),
-
-        para("Any number of underlining <code>=</code>'s or <code>-</code>'s will work."),
-
-        para("Atx-style headers use 1-6 hash characters at the start of the line,\n" +
-             "corresponding to header levels 1-6. For example:"),
-
-        verb("# This is an H1\n",
-             "\n",
-             "## This is an H2\n",
-             "\n",
-             "###### This is an H6\n"),
-
-        para("Optionally, you may \"close\" atx-style headers. This is purely\n" +
-             "cosmetic -- you can use this if you think it looks better. The\n" +
-             "closing hashes don't even need to match the number of hashes\n" +
-             "used to open the header. (The number of opening hashes\n" +
-             "determines the header level.) :"),
-
-        verb("# This is an H1 #\n",
-             "\n",
-             "## This is an H2 ##\n",
-             "\n",
-             "### This is an H3 ######\n"),
-
-        raw("<h3 id=\"blockquote\">Blockquotes</h3>"),
-
-        para(
-             "Markdown uses email-style <code>></code> characters for blockquoting. If you're\n" +
-             "familiar with quoting passages of text in an email message, then you\n" +
-             "know how to create a blockquote in Markdown. It looks best if you hard\n" +
-             "wrap the text and put a <code>></code> before every line:"),
-
-        verb("> This is a blockquote with two paragraphs. Lorem ipsum dolor sit amet,\n",
-             "> consectetuer adipiscing elit. Aliquam hendrerit mi posuere lectus.\n",
-             "> Vestibulum enim wisi, viverra nec, fringilla in, laoreet vitae, risus.\n",
-             "> \n",
-             "> Donec sit amet nisl. Aliquam semper ipsum sit amet velit. Suspendisse\n",
-             "> id sem consectetuer libero luctus adipiscing.\n"),
-
-        para("Markdown allows you to be lazy and only put the <code>></code> before the first\n" +
-             "line of a hard-wrapped paragraph:"),
-
-        verb("> This is a blockquote with two paragraphs. Lorem ipsum dolor sit amet,\n",
-             "consectetuer adipiscing elit. Aliquam hendrerit mi posuere lectus.\n",
-             "Vestibulum enim wisi, viverra nec, fringilla in, laoreet vitae, risus.\n",
-             "\n",
-             "> Donec sit amet nisl. Aliquam semper ipsum sit amet velit. Suspendisse\n",
-             "id sem consectetuer libero luctus adipiscing.\n"),
-
-        para("Blockquotes can be nested (i.e. a blockquote-in-a-blockquote) by\n" +
-             "adding additional levels of <code>></code>:"),
-
-        verb("> This is the first level of quoting.\n",
-             ">\n",
-             "> > This is nested blockquote.\n",
-             ">\n",
-             "> Back to the first level.\n"),
-
-        para("Blockquotes can contain other Markdown elements, including headers, lists,\n" +
-             "and code blocks:"),
-
-        verb("> ## This is a header.\n",
-             "> \n",
-             "> 1.   This is the first list item.\n",
-             "> 2.   This is the second list item.\n",
-             "> \n",
-             "> Here's some example code:\n",
-             "> \n",
-             ">     return shell_exec(\"echo $input | $markdown_script\");\n"),
-
-        para("Any decent text editor should make email-style quoting easy. For\n" +
-             "example, with BBEdit, you can make a selection and choose Increase\n" +
-             "Quote Level from the Text menu."),
-
-        raw("<h3 id=\"list\">Lists</h3>"),
-
-        para("Markdown supports ordered (numbered) and unordered (bulleted) lists."),
-
-        para("Unordered lists use asterisks, pluses, and hyphens -- interchangeably\n" +
-             "-- as list markers:"),
-
-        verb("*   Red\n",
-             "*   Green\n",
-             "*   Blue\n"),
-
-        para("is equivalent to:"),
-
-        verb("+   Red\n",
-             "+   Green\n",
-             "+   Blue\n"),
-
-        para("and:"),
-
-        verb("-   Red\n",
-             "-   Green\n",
-             "-   Blue\n"),
-
-        para("Ordered lists use numbers followed by periods:"),
-
-        verb("1.  Bird\n",
-             "2.  McHale\n",
-             "3.  Parish\n"),
-
-        para("It's important to note that the actual numbers you use to mark the\n" +
-             "list have no effect on the HTML output Markdown produces. The HTML\n" +
-             "Markdown produces from the above list is:"),
-
-        verb("<ol>\n",
-             "<li>Bird</li>\n",
-             "<li>McHale</li>\n",
-             "<li>Parish</li>\n",
-             "</ol>\n"),
-
-        para("If you instead wrote the list in Markdown like this:"),
-
-        verb("1.  Bird\n",
-             "1.  McHale\n",
-             "1.  Parish\n"),
-
-        para("or even:"),
-
-        verb("3. Bird\n",
-             "1. McHale\n",
-             "8. Parish\n"),
-
-        para("you'd get the exact same HTML output. The point is, if you want to,\n" +
-             "you can use ordinal numbers in your ordered Markdown lists, so that\n" +
-             "the numbers in your source match the numbers in your published HTML.\n" +
-             "But if you want to be lazy, you don't have to."),
-
-        para("If you do use lazy list numbering, however, you should still start the\n" +
-             "list with the number 1. At some point in the future, Markdown may support\n" +
-             "starting ordered lists at an arbitrary number."),
-
-        para("List markers typically start at the left margin, but may be indented by\n" +
-             "up to three spaces. List markers must be followed by one or more spaces\n" +
-             "or a tab."),
-
-        para("To make lists look nice, you can wrap items with hanging indents:"),
-
-        verb("*   Lorem ipsum dolor sit amet, consectetuer adipiscing elit.\n",
-             "    Aliquam hendrerit mi posuere lectus. Vestibulum enim wisi,\n",
-             "    viverra nec, fringilla in, laoreet vitae, risus.\n",
-             "*   Donec sit amet nisl. Aliquam semper ipsum sit amet velit.\n",
-             "    Suspendisse id sem consectetuer libero luctus adipiscing.\n"),
-
-        para("But if you want to be lazy, you don't have to:"),
-
-        verb("*   Lorem ipsum dolor sit amet, consectetuer adipiscing elit.\n",
-             "Aliquam hendrerit mi posuere lectus. Vestibulum enim wisi,\n",
-             "viverra nec, fringilla in, laoreet vitae, risus.\n",
-             "*   Donec sit amet nisl. Aliquam semper ipsum sit amet velit.\n",
-             "Suspendisse id sem consectetuer libero luctus adipiscing.\n"),
-
-        para("If list items are separated by blank lines, Markdown will wrap the\n" +
-             "items in <code><p></code> tags in the HTML output. For example, this input:"),
-
-        verb("*   Bird\n",
-             "*   Magic\n"),
-
-        para("will turn into:"),
-
-        verb("<ul>\n",
-             "<li>Bird</li>\n",
-             "<li>Magic</li>\n",
-             "</ul>\n"),
-
-        para("But this:"),
-
-        verb("*   Bird\n",
-             "\n",
-             "*   Magic\n"),
-
-        para("will turn into:"),
-
-        verb("<ul>\n",
-             "<li><p>Bird</p></li>\n",
-             "<li><p>Magic</p></li>\n",
-             "</ul>\n"),
-
-        para("List items may consist of multiple paragraphs. Each subsequent\n" +
-             "paragraph in a list item must be intended by either 4 spaces\n" +
-             "or one tab:"),
-
-        verb("1.  This is a list item with two paragraphs. Lorem ipsum dolor\n",
-             "    sit amet, consectetuer adipiscing elit. Aliquam hendrerit\n",
-             "    mi posuere lectus.\n",
-             "\n",
-             "    Vestibulum enim wisi, viverra nec, fringilla in, laoreet\n",
-             "    vitae, risus. Donec sit amet nisl. Aliquam semper ipsum\n",
-             "    sit amet velit.\n",
-             "\n",
-             "2.  Suspendisse id sem consectetuer libero luctus adipiscing.\n"),
-
-        para("It looks nice if you indent every line of the subsequent\n" +
-             "paragraphs, but here again, Markdown will allow you to be\n" +
-             "lazy:"),
-
-        verb("*   This is a list item with two paragraphs.\n",
-             "\n",
-             "    This is the second paragraph in the list item. You're\n",
-             "only required to indent the first line. Lorem ipsum dolor\n",
-             "sit amet, consectetuer adipiscing elit.\n",
-             "\n",
-             "*   Another item in the same list.\n"),
-
-        para("To put a blockquote within a list item, the blockquote's <code>></code>\n" +
-             "delimiters need to be indented:"),
-
-        verb("*   A list item with a blockquote:\n",
-             "\n",
-             "    > This is a blockquote\n",
-             "    > inside a list item.\n"),
-
-        para(
-             "To put a code block within a list item, the code block needs\n" +
-             "to be indented _twice_ -- 8 spaces or two tabs:"),
-
-        verb("*   A list item with a code block:\n",
-             "\n",
-             "        <code goes here>\n"),
-
-        para("It's worth noting that it's possible to trigger an ordered list by\n" +
-             "accident, by writing something like this:"),
-
-        verb("1986. What a great season.\n"),
-
-        para("In other words, a <em>number-period-space</em> sequence at the beginning of a\n" +
-             "line. To avoid this, you can backslash-escape the period:"),
-
-        verb("1986\\. What a great season.\n"),
-
-        raw("<h3 id=\"precode\">Code Blocks</h3>"),
-
-        para("Pre-formatted code blocks are used for writing about programming or\n" +
-             "markup source code. Rather than forming normal paragraphs, the lines\n" +
-             "of a code block are interpreted literally. Markdown wraps a code block\n" +
-             "in both <code><pre></code> and <code><code></code> tags."),
-
-        para("To produce a code block in Markdown, simply indent every line of the\n" +
-             "block by at least 4 spaces or 1 tab. For example, given this input:"),
-
-        verb("This is a normal paragraph:\n",
-             "\n",
-             "    This is a code block.\n"),
-
-        para("Markdown will generate:"),
-
-        verb("<p>This is a normal paragraph:</p>\n",
-             "\n",
-             "<pre><code>This is a code block.\n",
-             "</code></pre>\n"),
-
-        para("One level of indentation -- 4 spaces or 1 tab -- is removed from each\n" +
-             "line of the code block. For example, this:"),
-
-        verb("Here is an example of AppleScript:\n",
-             "\n",
-             "    tell application \"Foo\"\n",
-             "        beep\n",
-             "    end tell\n"),
-
-        para("will turn into:"),
-
-        verb("<p>Here is an example of AppleScript:</p>\n",
-             "\n",
-             "<pre><code>tell application \"Foo\"\n",
-             "    beep\n",
-             "end tell\n",
-             "</code></pre>\n"),
-
-        para("A code block continues until it reaches a line that is not indented\n" +
-             "(or the end of the article)."),
-
-        para("Within a code block, ampersands (<code>&</code>) and angle brackets (<code><</code> and <code>></code>)\n" +
-             "are automatically converted into HTML entities. This makes it very\n" +
-             "easy to include example HTML source code using Markdown -- just paste\n" +
-             "it and indent it, and Markdown will handle the hassle of encoding the\n" +
-             "ampersands and angle brackets. For example, this:"),
-
-        verb("    <div class=\"footer\">\n",
-             "        © 2004 Foo Corporation\n",
-             "    </div>\n"),
-
-        para("will turn into:"),
-
-        verb("<pre><code><div class=\"footer\">\n",
-             "    &copy; 2004 Foo Corporation\n",
-             "</div>\n",
-             "</code></pre>\n"),
-
-        para("Regular Markdown syntax is not processed within code blocks. E.g.,\n" +
-             "asterisks are just literal asterisks within a code block. This means\n" +
-             "it's also easy to use Markdown to write about Markdown's own syntax."),
-
-        raw("<h3 id=\"hr\">Horizontal Rules</h3>"),
-
-        para("You can produce a horizontal rule tag (<code><hr /></code>) by placing three or\n" +
-             "more hyphens, asterisks, or underscores on a line by themselves. If you\n" +
-             "wish, you may use spaces between the hyphens or asterisks. Each of the\n" +
-             "following lines will produce a horizontal rule:"),
-
-        verb("* * *\n",
-             "\n",
-             "***\n",
-             "\n",
-             "*****\n",
-             "\n",
-             "- - -\n",
-             "\n",
-             "---------------------------------------\n",
-             "\n",
-             "_ _ _\n"),
-
-        rule(1),
-
-        raw("<h2 id=\"span\">Span Elements</h2>"),
-
-        raw("<h3 id=\"link\">Links</h3>"),
-
-        para("Markdown supports two style of links: _inline_ and _reference_."),
-
-        para("In both styles, the link text is delimited by [square brackets]."),
-
-        para("To create an inline link, use a set of regular parentheses immediately\n" +
-             "after the link text's closing square bracket. Inside the parentheses,\n" +
-             "put the URL where you want the link to point, along with an _optional_\n" +
-             "title for the link, surrounded in quotes. For example:"),
-
-        verb("This is [an example](http://example.com/ \"Title\") inline link.\n",
-             "\n",
-             "[This link](http://example.net/) has no title attribute.\n"),
-
-        para("Will produce:"),
-
-        verb("<p>This is <a href=\"http://example.com/\" title=\"Title\">\n",
-             "an example</a> inline link.</p>\n",
-             "\n",
-             "<p><a href=\"http://example.net/\">This link</a> has no\n",
-             "title attribute.</p>\n"),
-
-        para("If you're referring to a local resource on the same server, you can\n" +
-             "use relative paths:"),
-
-        verb("See my [About](/about/) page for details.\n"),
-
-        para("Reference-style links use a second set of square brackets, inside\n" +
-             "which you place a label of your choosing to identify the link:"),
-
-        verb("This is [an example][id] reference-style link.\n"),
-
-        para("You can optionally use a space to separate the sets of brackets:"),
-
-        verb("This is [an example] [id] reference-style link.\n"),
-
-        para("Then, anywhere in the document, you define your link label like this,\n" +
-             "on a line by itself:"),
-
-        verb("[id]: http://example.com/  \"Optional Title Here\"\n"),
-
-        para("That is:"),
-
-        list(:BULLET,
-          item(nil,
-            para("Square brackets containing the link identifier (optionally\n" +
-                 "indented from the left margin using up to three spaces);")),
-          item(nil,
-            para("followed by a colon;")),
-          item(nil,
-            para("followed by one or more spaces (or tabs);")),
-          item(nil,
-            para("followed by the URL for the link;")),
-          item(nil,
-            para("optionally followed by a title attribute for the link, enclosed\n" +
-                 "in double or single quotes."))),
-
-        para("The link URL may, optionally, be surrounded by angle brackets:"),
-
-        verb("[id]: <http://example.com/>  \"Optional Title Here\"\n"),
-
-        para("You can put the title attribute on the next line and use extra spaces\n" +
-             "or tabs for padding, which tends to look better with longer URLs:"),
-
-        verb("[id]: http://example.com/longish/path/to/resource/here\n",
-             "    \"Optional Title Here\"\n"),
-
-        para("Link definitions are only used for creating links during Markdown\n" +
-             "processing, and are stripped from your document in the HTML output."),
-
-        para("Link definition names may consist of letters, numbers, spaces, and punctuation -- but they are _not_ case sensitive. E.g. these two links:"),
-
-        verb("[link text][a]\n",
-             "[link text][A]\n"),
-
-        para("are equivalent."),
-
-        para("The <em>implicit link name</em> shortcut allows you to omit the name of the\n" +
-             "link, in which case the link text itself is used as the name.\n" +
-             "Just use an empty set of square brackets -- e.g., to link the word\n" +
-             "\"Google\" to the google.com web site, you could simply write:"),
-
-        verb("[Google][]\n"),
-
-        para("And then define the link:"),
-
-        verb("[Google]: http://google.com/\n"),
-
-        para("Because link names may contain spaces, this shortcut even works for\n" +
-            "multiple words in the link text:"),
-
-
-        verb("Visit [Daring Fireball][] for more information.\n"),
-
-        para("And then define the link:"),
-
-        verb("[Daring Fireball]: http://daringfireball.net/\n"),
-
-        para("Link definitions can be placed anywhere in your Markdown document. I\n" +
-             "tend to put them immediately after each paragraph in which they're\n" +
-             "used, but if you want, you can put them all at the end of your\n" +
-             "document, sort of like footnotes."),
-
-        para("Here's an example of reference links in action:"),
-
-        verb("I get 10 times more traffic from [Google] [1] than from\n",
-             "[Yahoo] [2] or [MSN] [3].\n",
-             "\n",
-             "  [1]: http://google.com/        \"Google\"\n",
-             "  [2]: http://search.yahoo.com/  \"Yahoo Search\"\n",
-             "  [3]: http://search.msn.com/    \"MSN Search\"\n"),
-
-        para("Using the implicit link name shortcut, you could instead write:"),
-
-        verb("I get 10 times more traffic from [Google][] than from\n",
-             "[Yahoo][] or [MSN][].\n",
-             "\n",
-             "  [google]: http://google.com/        \"Google\"\n",
-             "  [yahoo]:  http://search.yahoo.com/  \"Yahoo Search\"\n",
-             "  [msn]:    http://search.msn.com/    \"MSN Search\"\n"),
-
-        para("Both of the above examples will produce the following HTML output:"),
-
-        verb("<p>I get 10 times more traffic from <a href=\"http://google.com/\"\n",
-             "title=\"Google\">Google</a> than from\n",
-             "<a href=\"http://search.yahoo.com/\" title=\"Yahoo Search\">Yahoo</a>\n",
-             "or <a href=\"http://search.msn.com/\" title=\"MSN Search\">MSN</a>.</p>\n"),
-
-        para("For comparison, here is the same paragraph written using\n" +
-             "Markdown's inline link style:"),
-
-        verb("I get 10 times more traffic from [Google](http://google.com/ \"Google\")\n",
-             "than from [Yahoo](http://search.yahoo.com/ \"Yahoo Search\") or\n",
-             "[MSN](http://search.msn.com/ \"MSN Search\").\n"),
-
-        para("The point of reference-style links is not that they're easier to\n" +
-             "write. The point is that with reference-style links, your document\n" +
-             "source is vastly more readable. Compare the above examples: using\n" +
-             "reference-style links, the paragraph itself is only 81 characters\n" +
-             "long; with inline-style links, it's 176 characters; and as raw HTML,\n" +
-             "it's 234 characters. In the raw HTML, there's more markup than there\n" +
-             "is text."),
-
-        para("With Markdown's reference-style links, a source document much more\n" +
-             "closely resembles the final output, as rendered in a browser. By\n" +
-             "allowing you to move the markup-related metadata out of the paragraph,\n" +
-             "you can add links without interrupting the narrative flow of your\n" +
-             "prose."),
-
-        raw("<h3 id=\"em\">Emphasis</h3>"),
-
-        para("Markdown treats asterisks (<code>*</code>) and underscores (<code>_</code>) as indicators of\n" +
-             "emphasis. Text wrapped with one <code>*</code> or <code>_</code> will be wrapped with an\n" +
-             "HTML <code><em></code> tag; double <code>*</code>'s or <code>_</code>'s will be wrapped with an HTML\n" +
-             "<code><strong></code> tag. E.g., this input:"),
-
-        verb("*single asterisks*\n",
-             "\n",
-             "_single underscores_\n",
-             "\n",
-             "**double asterisks**\n",
-             "\n",
-             "__double underscores__\n"),
-
-        para("will produce:"),
-
-        verb("<em>single asterisks</em>\n",
-             "\n",
-             "<em>single underscores</em>\n",
-             "\n",
-             "<strong>double asterisks</strong>\n",
-             "\n",
-             "<strong>double underscores</strong>\n"),
-
-        para("You can use whichever style you prefer; the lone restriction is that\n" +
-             "the same character must be used to open and close an emphasis span."),
-
-        para("Emphasis can be used in the middle of a word:"),
-
-        verb("un*fucking*believable\n"),
-
-        para("But if you surround an <code>*</code> or <code>_</code> with spaces, it'll be treated as a\n" +
-             "literal asterisk or underscore."),
-
-        para("To produce a literal asterisk or underscore at a position where it\n" +
-             "would otherwise be used as an emphasis delimiter, you can backslash\n" +
-             "escape it:"),
-
-        verb("\\*this text is surrounded by literal asterisks\\*\n"),
-
-        raw("<h3 id=\"code\">Code</h3>"),
-
-        para("To indicate a span of code, wrap it with backtick quotes (<code>`</code>).\n" +
-             "Unlike a pre-formatted code block, a code span indicates code within a\n" +
-             "normal paragraph. For example:"),
-
-        verb("Use the `printf()` function.\n"),
-
-        para("will produce:"),
-
-        verb("<p>Use the <code>printf()</code> function.</p>\n"),
-
-        para("To include a literal backtick character within a code span, you can use\n" +
-             "multiple backticks as the opening and closing delimiters:"),
-
-        verb("``There is a literal backtick (`) here.``\n"),
-
-        para("which will produce this:"),
-
-        verb("<p><code>There is a literal backtick (`) here.</code></p>\n"),
-
-        para("The backtick delimiters surrounding a code span may include spaces --\n" +
-             "one after the opening, one before the closing. This allows you to place\n" +
-             "literal backtick characters at the beginning or end of a code span:"),
-
-        verb("A single backtick in a code span: `` ` ``\n",
-             "\n",
-             "A backtick-delimited string in a code span: `` `foo` ``\n"),
-
-        para("will produce:"),
-
-        verb("<p>A single backtick in a code span: <code>`</code></p>\n",
-             "\n",
-             "<p>A backtick-delimited string in a code span: <code>`foo`</code></p>\n"),
-
-        para("With a code span, ampersands and angle brackets are encoded as HTML\n" +
-             "entities automatically, which makes it easy to include example HTML\n" +
-             "tags. Markdown will turn this:"),
-
-        verb("Please don't use any `<blink>` tags.\n"),
-
-        para("into:"),
-
-        verb("<p>Please don't use any <code><blink></code> tags.</p>\n"),
-
-        para("You can write this:"),
-
-        verb("`—` is the decimal-encoded equivalent of `—`.\n"),
-
-        para("to produce:"),
-
-        verb( "<p><code>&#8212;</code> is the decimal-encoded\n",
-             "equivalent of <code>&mdash;</code>.</p>\n"),
-
-        raw("<h3 id=\"img\">Images</h3>"),
-
-        para("Admittedly, it's fairly difficult to devise a \"natural\" syntax for\n" +
-             "placing images into a plain text document format."),
-
-        para("Markdown uses an image syntax that is intended to resemble the syntax\n" +
-             "for links, allowing for two styles: _inline_ and _reference_."),
-
-        para("Inline image syntax looks like this:"),
-
-        verb("![Alt text](/path/to/img.jpg)\n",
-             "\n",
-             "![Alt text](/path/to/img.jpg \"Optional title\")\n"),
-
-        para("That is:"),
-
-        list(:BULLET,
-          item(nil,
-            para("An exclamation mark: <code>!</code>;")),
-          item(nil,
-            para("followed by a set of square brackets, containing the <code>alt</code>\n" +
-                 "attribute text for the image;")),
-          item(nil,
-            para("followed by a set of parentheses, containing the URL or path to\n" +
-                 "the image, and an optional <code>title</code> attribute enclosed in double\n" +
-                 "or single quotes."))),
-
-        para("Reference-style image syntax looks like this:"),
-
-        verb("![Alt text][id]\n"),
-
-        para("Where \"id\" is the name of a defined image reference. Image references\n" +
-             "are defined using syntax identical to link references:"),
-
-        verb("[id]: url/to/image  \"Optional title attribute\"\n"),
-
-        para("As of this writing, Markdown has no syntax for specifying the\n" +
-             "dimensions of an image; if this is important to you, you can simply\n" +
-             "use regular HTML <code><img></code> tags."),
-
-        rule(1),
-
-        raw("<h2 id=\"misc\">Miscellaneous</h2>"),
-
-        raw("<h3 id=\"autolink\">Automatic Links</h3>"),
-
-        para("Markdown supports a shortcut style for creating \"automatic\" links for URLs and email addresses: simply surround the URL or email address with angle brackets. What this means is that if you want to show the actual text of a URL or email address, and also have it be a clickable link, you can do this:"),
-
-        verb("<http://example.com/>\n"),
-
-        para("Markdown will turn this into:"),
-
-        verb("<a href=\"http://example.com/\">http://example.com/</a>\n"),
-
-        para("Automatic links for email addresses work similarly, except that\n" +
-             "Markdown will also perform a bit of randomized decimal and hex\n" +
-             "entity-encoding to help obscure your address from address-harvesting\n" +
-             "spambots. For example, Markdown will turn this:"),
-
-        verb("<address@example.com>\n"),
-
-        para("into something like this:"),
-
-        verb("<a href=\"mailto:addre\n",
-             "ss@example.co\n",
-             "m\">address@exa\n",
-             "mple.com</a>\n"),
-
-        para("which will render in a browser as a clickable link to \"address@example.com\"."),
-
-        para("(This sort of entity-encoding trick will indeed fool many, if not\n" +
-               "most, address-harvesting bots, but it definitely won't fool all of\n" +
-               "them. It's better than nothing, but an address published in this way\n" +
-               "will probably eventually start receiving spam.)"),
-
-        raw("<h3 id=\"backslash\">Backslash Escapes</h3>"),
-
-        para("Markdown allows you to use backslash escapes to generate literal\n" +
-             "characters which would otherwise have special meaning in Markdown's\n" +
-             "formatting syntax. For example, if you wanted to surround a word with\n" +
-             "literal asterisks (instead of an HTML <code><em></code> tag), you can backslashes\n" +
-             "before the asterisks, like this:"),
-
-        verb("\\*literal asterisks\\*\n"),
-
-        para("Markdown provides backslash escapes for the following characters:"),
-
-        verb("\\   backslash\n",
-             "`   backtick\n",
-             "*   asterisk\n",
-             "_   underscore\n",
-             "{}  curly braces\n",
-             "[]  square brackets\n",
-             "()  parentheses\n",
-             "#   hash mark\n",
-             "+	plus sign\n",
-             "-	minus sign (hyphen)\n",
-             ".   dot\n",
-             "!   exclamation mark\n"))
-
-    assert_equal expected, doc
-  end
-
-  def test_nested_blockquotes
-    input = File.read "#{MARKDOWN_TEST_PATH}/Nested blockquotes.text"
-
-    doc = @parser.parse input
-
-    expected =
-      doc(
-        block(
-          para("foo"),
-          block(
-            para("bar")),
-          para("foo")))
-
-    assert_equal expected, doc
-  end
-
-  def test_ordered_and_unordered_lists
-    input = File.read "#{MARKDOWN_TEST_PATH}/Ordered and unordered lists.text"
-
-    doc = @parser.parse input
-
-    expected =
-      doc(
-        head(2, 'Unordered'),
-
-        para('Asterisks tight:'),
-        list(:BULLET,
-          item(nil, para("asterisk 1")),
-          item(nil, para("asterisk 2")),
-          item(nil, para("asterisk 3"))),
-        para('Asterisks loose:'),
-        list(:BULLET,
-          item(nil, para("asterisk 1")),
-          item(nil, para("asterisk 2")),
-          item(nil, para("asterisk 3"))),
-
-        rule(1),
-
-        para("Pluses tight:"),
-        list(:BULLET,
-          item(nil, para("Plus 1")),
-          item(nil, para("Plus 2")),
-          item(nil, para("Plus 3"))),
-        para("Pluses loose:"),
-        list(:BULLET,
-          item(nil, para("Plus 1")),
-          item(nil, para("Plus 2")),
-          item(nil, para("Plus 3"))),
-
-        rule(1),
-
-        para("Minuses tight:"),
-        list(:BULLET,
-          item(nil, para("Minus 1")),
-          item(nil, para("Minus 2")),
-          item(nil, para("Minus 3"))),
-        para("Minuses loose:"),
-        list(:BULLET,
-          item(nil, para("Minus 1")),
-          item(nil, para("Minus 2")),
-          item(nil, para("Minus 3"))),
-
-        head(2, "Ordered"),
-
-        para("Tight:"),
-        list(:NUMBER,
-          item(nil, para("First")),
-          item(nil, para("Second")),
-          item(nil, para("Third"))),
-        para("and:"),
-        list(:NUMBER,
-          item(nil, para("One")),
-          item(nil, para("Two")),
-          item(nil, para("Three"))),
-
-        para("Loose using tabs:"),
-        list(:NUMBER,
-          item(nil, para("First")),
-          item(nil, para("Second")),
-          item(nil, para("Third"))),
-        para("and using spaces:"),
-        list(:NUMBER,
-          item(nil, para("One")),
-          item(nil, para("Two")),
-          item(nil, para("Three"))),
-
-        para("Multiple paragraphs:"),
-        list(:NUMBER,
-          item(nil,
-            para("Item 1, graf one."),
-            para("Item 2. graf two. The quick brown fox " +
-                 "jumped over the lazy dog's\nback.")),
-          item(nil, para("Item 2.")),
-          item(nil, para("Item 3."))),
-
-        head(2, "Nested"),
-        list(:BULLET,
-          item(nil,
-            para("Tab"),
-            list(:BULLET,
-              item(nil,
-                para("Tab"),
-                list(:BULLET,
-                  item(nil,
-                    para("Tab"))))))),
-
-        para("Here's another:"),
-        list(:NUMBER,
-          item(nil, para("First")),
-          item(nil, para("Second:"),
-            list(:BULLET,
-              item(nil, para("Fee")),
-              item(nil, para("Fie")),
-              item(nil, para("Foe")))),
-          item(nil, para("Third"))),
-
-        para("Same thing but with paragraphs:"),
-        list(:NUMBER,
-          item(nil, para("First")),
-          item(nil, para("Second:"),
-            list(:BULLET,
-              item(nil, para("Fee")),
-              item(nil, para("Fie")),
-              item(nil, para("Foe")))),
-          item(nil, para("Third"))),
-
-        para("This was an error in Markdown 1.0.1:"),
-        list(:BULLET,
-          item(nil,
-            para("this"),
-            list(:BULLET,
-              item(nil, para("sub"))),
-            para("that"))))
-
-    assert_equal expected, doc
-  end
-
-  def test_strong_and_em_together
-    input = File.read "#{MARKDOWN_TEST_PATH}/Strong and em together.text"
-
-    doc = @parser.parse input
-
-    expected =
-      doc(
-        para("<b><em>This is strong and em.</em></b>"),
-        para("So is <b>_this_</b> word."),
-        para("<b><em>This is strong and em.</em></b>"),
-        para("So is <b>_this_</b> word."))
-
-    assert_equal expected, doc
-  end
-
-  def test_tabs
-    input = File.read "#{MARKDOWN_TEST_PATH}/Tabs.text"
-
-    doc = @parser.parse input
-
-    expected =
-      doc(
-        list(:BULLET,
-          item(nil,
-            para("this is a list item\nindented with tabs")),
-          item(nil,
-            para("this is a list item\nindented with spaces"))),
-
-        para("Code:"),
-
-        verb("this code block is indented by one tab\n"),
-
-        para("And:"),
-
-        verb("\tthis code block is indented by two tabs\n"),
-
-        para("And:"),
-
-        verb(
-          "+\tthis is an example list item\n",
-          "\tindented with tabs\n",
-          "\n",
-          "+   this is an example list item\n",
-          "    indented with spaces\n"))
-
-    assert_equal expected, doc
-  end
-
-  def test_tidiness
-    input = File.read "#{MARKDOWN_TEST_PATH}/Tidiness.text"
-
-    doc = @parser.parse input
-
-    expected =
-      doc(
-        block(
-          para("A list within a blockquote:"),
-          list(:BULLET,
-            item(nil, para("asterisk 1")),
-            item(nil, para("asterisk 2")),
-            item(nil, para("asterisk 3")))))
-
-    assert_equal expected, doc
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc_markup_attribute_manager_test.rb b/test/mri/rdoc/rdoc_markup_attribute_manager_test.rb
deleted file mode 100644
index 05bd9519902..00000000000
--- a/test/mri/rdoc/rdoc_markup_attribute_manager_test.rb
+++ /dev/null
@@ -1,395 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocMarkupAttributeManagerTest < RDoc::TestCase
-
-  def setup
-    super
-
-    @am = RDoc::Markup::AttributeManager.new
-
-    @bold_on  = @am.changed_attribute_by_name([], [:BOLD])
-    @bold_off = @am.changed_attribute_by_name([:BOLD], [])
-
-    @tt_on    = @am.changed_attribute_by_name([], [:TT])
-    @tt_off   = @am.changed_attribute_by_name([:TT], [])
-
-    @em_on    = @am.changed_attribute_by_name([], [:EM])
-    @em_off   = @am.changed_attribute_by_name([:EM], [])
-
-    @bold_em_on   = @am.changed_attribute_by_name([], [:BOLD] | [:EM])
-    @bold_em_off  = @am.changed_attribute_by_name([:BOLD] | [:EM], [])
-
-    @em_then_bold = @am.changed_attribute_by_name([:EM], [:EM] | [:BOLD])
-
-    @em_to_bold   = @am.changed_attribute_by_name([:EM], [:BOLD])
-
-    @am.add_word_pair("{", "}", :WOMBAT)
-    @wombat_on    = @am.changed_attribute_by_name([], [:WOMBAT])
-    @wombat_off   = @am.changed_attribute_by_name([:WOMBAT], [])
-
-    @klass = RDoc::Markup::AttributeManager
-    @formatter = RDoc::Markup::Formatter.new @rdoc.options
-    @formatter.add_tag :BOLD, '<B>', '</B>'
-    @formatter.add_tag :EM, '<EM>', '</EM>'
-    @formatter.add_tag :TT, '<CODE>', '</CODE>'
-  end
-
-  def crossref(text)
-    crossref_bitmap = @am.attributes.bitmap_for(:_REGEXP_HANDLING_) |
-                      @am.attributes.bitmap_for(:CROSSREF)
-
-    [ @am.changed_attribute_by_name([], [:CROSSREF, :_REGEXP_HANDLING_]),
-      RDoc::Markup::RegexpHandling.new(crossref_bitmap, text),
-      @am.changed_attribute_by_name([:CROSSREF, :_REGEXP_HANDLING_], [])
-    ]
-  end
-
-  def test_adding
-    assert_equal(["cat ", @wombat_on, "and", @wombat_off, " dog" ],
-                  @am.flow("cat {and} dog"))
-    #assert_equal(["cat {and} dog" ], @am.flow("cat \\{and} dog"))
-  end
-
-  def test_add_html_tag
-    @am.add_html("Test", :TEST)
-    tags = @am.html_tags
-    assert_equal(6, tags.size)
-    assert(tags.has_key?("test"))
-  end
-
-  def test_add_regexp_handling
-    @am.add_regexp_handling "WikiWord", :WIKIWORD
-    regexp_handlings = @am.regexp_handlings
-
-    assert_equal 1, regexp_handlings.size
-    assert regexp_handlings.assoc "WikiWord"
-  end
-
-  def test_add_word_pair
-    @am.add_word_pair '%', '&', 'percent and'
-
-    assert @am.word_pair_map.include?(/(%)(\S+)(&)/)
-    assert @am.protectable.include?('%')
-    assert !@am.protectable.include?('&')
-  end
-
-  def test_add_word_pair_angle
-    e = assert_raise ArgumentError do
-      @am.add_word_pair '<', '>', 'angles'
-    end
-
-    assert_equal "Word flags may not start with '<'", e.message
-  end
-
-  def test_add_word_pair_invalid
-    assert_raise ArgumentError do
-      @am.add_word_pair("<", "<", :TEST)
-    end
-  end
-
-  def test_add_word_pair_map
-    @am.add_word_pair("x", "y", :TEST)
-
-    word_pair_map = @am.word_pair_map
-
-    assert_includes word_pair_map.keys.map { |r| r.source }, "(x)(\\S+)(y)"
-  end
-
-  def test_add_word_pair_matching
-    @am.add_word_pair '^', '^', 'caret'
-
-    assert @am.matching_word_pairs.include?('^')
-    assert @am.protectable.include?('^')
-  end
-
-  def test_basic
-    assert_equal(["cat"], @am.flow("cat"))
-
-    assert_equal(["cat ", @bold_on, "and", @bold_off, " dog"],
-                  @am.flow("cat *and* dog"))
-
-    assert_equal(["cat ", @bold_on, "AND", @bold_off, " dog"],
-                  @am.flow("cat *AND* dog"))
-
-    assert_equal(["cat ", @em_on, "And", @em_off, " dog"],
-                  @am.flow("cat _And_ dog"))
-
-    assert_equal(["cat *and dog*"], @am.flow("cat *and dog*"))
-
-    assert_equal(["*cat and* dog"], @am.flow("*cat and* dog"))
-
-    assert_equal(["cat *and ", @bold_on, "dog", @bold_off],
-                  @am.flow("cat *and *dog*"))
-
-    assert_equal(["cat ", @em_on, "and", @em_off, " dog"],
-                  @am.flow("cat _and_ dog"))
-
-    assert_equal(["cat_and_dog"],
-                  @am.flow("cat_and_dog"))
-
-    assert_equal(["cat ", @tt_on, "and", @tt_off, " dog"],
-                  @am.flow("cat +and+ dog"))
-
-    assert_equal(["cat ", @tt_on, "X::Y", @tt_off, " dog"],
-                  @am.flow("cat +X::Y+ dog"))
-
-    assert_equal(["cat ", @bold_on, "a_b_c", @bold_off, " dog"],
-                  @am.flow("cat *a_b_c* dog"))
-
-    assert_equal(["cat __ dog"],
-                  @am.flow("cat __ dog"))
-
-    assert_equal(["cat ", @em_on, "_", @em_off, " dog"],
-                  @am.flow("cat ___ dog"))
-
-    assert_equal(["cat and ", @em_on, "5", @em_off, " dogs"],
-                  @am.flow("cat and _5_ dogs"))
-
-    assert_equal([@tt_on, "__id__", @tt_off], @am.flow("+__id__+"))
-  end
-
-  def test_bold
-    assert_equal [@bold_on, 'bold', @bold_off],
-                 @am.flow("*bold*")
-
-    assert_equal [@bold_on, 'Bold:', @bold_off],
-                 @am.flow("*Bold:*")
-
-    assert_equal [@bold_on, '\\bold', @bold_off],
-                 @am.flow("*\\bold*")
-  end
-
-  def test_bold_html_escaped
-    assert_equal ['cat <b>dog</b>'], @am.flow('cat \<b>dog</b>')
-  end
-
-  def test_combined
-    assert_equal(["cat ", @em_on, "and", @em_off, " ", @bold_on, "dog", @bold_off],
-                  @am.flow("cat _and_ *dog*"))
-
-    assert_equal(["cat ", @em_on, "a__nd", @em_off, " ", @bold_on, "dog", @bold_off],
-                  @am.flow("cat _a__nd_ *dog*"))
-  end
-
-  def test_convert_attrs
-    str = '+foo+'.dup
-    attrs = RDoc::Markup::AttrSpan.new str.length, @am.exclusive_bitmap
-
-    @am.convert_attrs str, attrs, true
-    @am.convert_attrs str, attrs
-
-    assert_equal "\000foo\000", str
-
-    str = '+:foo:+'.dup
-    attrs = RDoc::Markup::AttrSpan.new str.length, @am.exclusive_bitmap
-
-    @am.convert_attrs str, attrs, true
-    @am.convert_attrs str, attrs
-
-    assert_equal "\000:foo:\000", str
-
-    str = '+x-y+'.dup
-    attrs = RDoc::Markup::AttrSpan.new str.length, @am.exclusive_bitmap
-
-    @am.convert_attrs str, attrs, true
-    @am.convert_attrs str, attrs
-
-    assert_equal "\000x-y\000", str
-  end
-
-  def test_convert_attrs_ignores_code
-    assert_equal 'foo <CODE>__send__</CODE> bar', output('foo <code>__send__</code> bar')
-  end
-
-  def test_convert_attrs_ignores_tt
-    assert_equal 'foo <CODE>__send__</CODE> bar', output('foo <tt>__send__</tt> bar')
-  end
-
-  def test_convert_attrs_preserves_double
-    assert_equal 'foo.__send__ :bar', output('foo.__send__ :bar')
-    assert_equal 'use __FILE__ to', output('use __FILE__ to')
-  end
-
-  def test_convert_attrs_does_not_ignore_after_tt
-    assert_equal 'the <CODE>IF:</CODE><EM>key</EM> directive', output('the <tt>IF:</tt>_key_ directive')
-  end
-
-  def test_escapes
-    assert_equal '<CODE>text</CODE>',   output('<tt>text</tt>')
-    assert_equal '<tt>text</tt>',       output('\\<tt>text</tt>')
-    assert_equal '<tt>',                output('\\<tt>')
-    assert_equal '<CODE><tt></CODE>',   output('<tt>\\<tt></tt>')
-    assert_equal '<CODE>\\<tt></CODE>', output('<tt>\\\\<tt></tt>')
-    assert_equal '<B>text</B>',         output('*text*')
-    assert_equal '*text*',              output('\\*text*')
-    assert_equal '\\',                  output('\\')
-    assert_equal '\\text',              output('\\text')
-    assert_equal '\\\\text',            output('\\\\text')
-    assert_equal 'text \\ text',        output('text \\ text')
-
-    assert_equal 'and <CODE>\\s</CODE> matches space',
-                 output('and <tt>\\s</tt> matches space')
-    assert_equal 'use <CODE><tt>text</CODE></tt> for code',
-                 output('use <tt>\\<tt>text</tt></tt> for code')
-    assert_equal 'use <CODE><tt>text</tt></CODE> for code',
-                 output('use <tt>\\<tt>text\\</tt></tt> for code')
-    assert_equal 'use <tt><tt>text</tt></tt> for code',
-                 output('use \\<tt>\\<tt>text</tt></tt> for code')
-    assert_equal 'use <tt><CODE>text</CODE></tt> for code',
-                 output('use \\<tt><tt>text</tt></tt> for code')
-    assert_equal 'use <CODE>+text+</CODE> for code',
-                 output('use <tt>\\+text+</tt> for code')
-    assert_equal 'use <tt><CODE>text</CODE></tt> for code',
-                 output('use \\<tt>+text+</tt> for code')
-    assert_equal 'illegal <tag>not</tag> changed',
-                 output('illegal <tag>not</tag> changed')
-    assert_equal 'unhandled <p>tag</p> unchanged',
-                 output('unhandled <p>tag</p> unchanged')
-  end
-
-  def test_exclude_tag
-    assert_equal '<CODE>aaa</CODE>[:symbol]', output('+aaa+[:symbol]')
-    assert_equal '<CODE>aaa[:symbol]</CODE>', output('+aaa[:symbol]+')
-    assert_equal 'aaa[:symbol]', output('aaa[:symbol]')
-    assert_equal '<B><CODE>index</CODE></B>', output('<b><tt>index</tt></b>')
-  end
-
-  def test_exclude_tag_flow
-    assert_equal [@tt_on, "aaa", @tt_off, "[:symbol]"],
-                  @am.flow("+aaa+[:symbol]")
-    assert_equal [@tt_on, "aaa[:symbol]", @tt_off],
-                  @am.flow("+aaa[:symbol]+")
-    assert_equal ["aaa[:symbol]"],
-                  @am.flow("aaa[:symbol]")
-  end
-
-  def test_html_like_em_bold
-    assert_equal ["cat ", @em_on, "and ", @em_to_bold, "dog", @bold_off],
-                  @am.flow("cat <i>and </i><b>dog</b>")
-  end
-
-  def test_html_like_em_bold_SGML
-    assert_equal ["cat ", @em_on, "and ", @em_to_bold, "dog", @bold_off],
-                  @am.flow("cat <i>and <b></i>dog</b>")
-  end
-
-  def test_html_like_em_bold_nested_1
-    assert_equal(["cat ", @bold_em_on, "and", @bold_em_off, " dog"],
-                  @am.flow("cat <i><b>and</b></i> dog"))
-  end
-
-  def test_html_like_em_bold_nested_2
-    assert_equal ["cat ", @em_on, "and ", @em_then_bold, "dog", @bold_em_off],
-                  @am.flow("cat <i>and <b>dog</b></i>")
-  end
-
-  def test_html_like_em_bold_nested_mixed_case
-    assert_equal ["cat ", @em_on, "and ", @em_then_bold, "dog", @bold_em_off],
-                  @am.flow("cat <i>and <B>dog</B></I>")
-  end
-
-  def test_html_like_em_bold_mixed_case
-    assert_equal ["cat ", @em_on, "and", @em_off, " ", @bold_on, "dog", @bold_off],
-                  @am.flow("cat <i>and</i> <B>dog</b>")
-  end
-
-  def test_html_like_teletype
-    assert_equal ["cat ", @tt_on, "dog", @tt_off],
-                 @am.flow("cat <tt>dog</Tt>")
-  end
-
-  def test_html_like_teletype_em_bold_SGML
-    assert_equal [@tt_on, "cat", @tt_off, " ", @em_on, "and ", @em_to_bold, "dog", @bold_off],
-                  @am.flow("<tt>cat</tt> <i>and <b></i>dog</b>")
-  end
-
-  def test_initial_html
-    html_tags = @am.html_tags
-    assert html_tags.is_a?(Hash)
-    assert_equal(5, html_tags.size)
-  end
-
-  def test_initial_word_pairs
-    word_pairs = @am.matching_word_pairs
-    assert word_pairs.is_a?(Hash)
-    assert_equal(3, word_pairs.size)
-  end
-
-  def test_mask_protected_sequence
-    def @am.str()     @str       end
-    def @am.str=(str) @str = str end
-
-    @am.str = '<code>foo</code>'.dup
-    @am.mask_protected_sequences
-
-    assert_equal "<code>foo</code>",       @am.str
-
-    @am.str = '<code>foo\\</code>'.dup
-    @am.mask_protected_sequences
-
-    assert_equal "<code>foo<\x04/code>", @am.str, 'escaped close'
-
-    @am.str = '<code>foo\\\\</code>'.dup
-    @am.mask_protected_sequences
-
-    assert_equal "<code>foo\\</code>",     @am.str, 'escaped backslash'
-  end
-
-  def test_protect
-    assert_equal(['cat \\ dog'],
-                 @am.flow('cat \\ dog'))
-
-    assert_equal(["cat <tt>dog</Tt>"],
-                 @am.flow("cat \\<tt>dog</Tt>"))
-
-    assert_equal(["cat ", @em_on, "and", @em_off, " <B>dog</b>"],
-                  @am.flow("cat <i>and</i> \\<B>dog</b>"))
-
-    assert_equal(["*word* or <b>text</b>"],
-                 @am.flow("\\*word* or \\<b>text</b>"))
-
-    assert_equal(["_cat_", @em_on, "dog", @em_off],
-                  @am.flow("\\_cat_<i>dog</i>"))
-  end
-
-  def test_lost_tag_for_the_second_time
-    str = "cat <tt>dog</tt>"
-    assert_equal(["cat ", @tt_on, "dog", @tt_off],
-                 @am.flow(str))
-    assert_equal(["cat ", @tt_on, "dog", @tt_off],
-                 @am.flow(str))
-  end
-
-  def test_regexp_handling
-    @am.add_regexp_handling(RDoc::CrossReference::CROSSREF_REGEXP, :CROSSREF)
-
-    #
-    # The apostrophes in "cats'" and "dogs'" suppress the flagging of these
-    # words as potential cross-references, which is necessary for the unit
-    # tests.  Unfortunately, the markup engine right now does not actually
-    # check whether a cross-reference is valid before flagging it.
-    #
-    assert_equal(["cats'"], @am.flow("cats'"))
-
-    assert_equal(["cats' ", crossref("#fred"), " dogs'"].flatten,
-                  @am.flow("cats' #fred dogs'"))
-
-    assert_equal([crossref("#fred"), " dogs'"].flatten,
-                  @am.flow("#fred dogs'"))
-
-    assert_equal(["cats' ", crossref("#fred")].flatten, @am.flow("cats' #fred"))
-
-    assert_equal(["(", crossref("#fred"), ")"].flatten, @am.flow("(#fred)"))
-  end
-
-  def test_tt_html
-    assert_equal [@tt_on, '"\n"', @tt_off],
-                 @am.flow('<tt>"\n"</tt>')
-  end
-
-  def output(str)
-    @formatter.convert_flow @am.flow str
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc_markup_attributes_test.rb b/test/mri/rdoc/rdoc_markup_attributes_test.rb
deleted file mode 100644
index f584a4762a4..00000000000
--- a/test/mri/rdoc/rdoc_markup_attributes_test.rb
+++ /dev/null
@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocMarkupAttributesTest < RDoc::TestCase
-
-  def setup
-    super
-
-    @as = RDoc::Markup::Attributes.new
-  end
-
-  def test_bitmap_for
-    assert_equal 2, @as.bitmap_for('two')
-    assert_equal 2, @as.bitmap_for('two')
-    assert_equal 4, @as.bitmap_for('three')
-  end
-
-  def test_as_string
-    @as.bitmap_for 'two'
-    @as.bitmap_for 'three'
-
-    assert_equal 'none',                  @as.as_string(0)
-    assert_equal '_REGEXP_HANDLING_',     @as.as_string(1)
-    assert_equal 'two',                   @as.as_string(2)
-    assert_equal '_REGEXP_HANDLING_,two', @as.as_string(3)
-  end
-
-  def test_each_name_of
-    @as.bitmap_for 'two'
-    @as.bitmap_for 'three'
-
-    assert_equal %w[],          @as.each_name_of(0).to_a
-    assert_equal %w[],          @as.each_name_of(1).to_a
-    assert_equal %w[two],       @as.each_name_of(2).to_a
-    assert_equal %w[three],     @as.each_name_of(4).to_a
-    assert_equal %w[two three], @as.each_name_of(6).to_a
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc_markup_document_test.rb b/test/mri/rdoc/rdoc_markup_document_test.rb
deleted file mode 100644
index 6b118f4e54e..00000000000
--- a/test/mri/rdoc/rdoc_markup_document_test.rb
+++ /dev/null
@@ -1,207 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocMarkupDocumentTest < RDoc::TestCase
-
-  def setup
-    super
-
-    @d = @RM::Document.new
-  end
-
-  def test_append
-    @d << @RM::Paragraph.new('hi')
-
-    expected = @RM::Document.new @RM::Paragraph.new('hi')
-
-    assert_equal expected, @d
-  end
-
-  def test_append_document
-    @d << @RM::Document.new
-
-    assert_empty @d
-
-    @d << @RM::Document.new(@RM::Paragraph.new('hi'))
-
-    expected = @RM::Document.new @RM::Paragraph.new('hi'), @RM::BlankLine.new
-
-    assert_equal expected, @d
-  end
-
-  def test_append_string
-    @d << ''
-
-    assert_empty @d
-
-    assert_raise ArgumentError do
-      @d << 'hi'
-    end
-  end
-
-  def test_concat
-    @d.concat [@RM::BlankLine.new, @RM::BlankLine.new]
-
-    refute_empty @d
-  end
-
-  def test_each
-    a = @RM::Document.new
-    b = @RM::Document.new(@RM::Paragraph.new('hi'))
-
-    @d.push a, b
-
-    assert_equal [a, b], @d.map { |sub_doc| sub_doc }
-  end
-
-  def test_empty_eh
-    assert_empty @d
-
-    @d << @RM::BlankLine.new
-
-    refute_empty @d
-  end
-
-  def test_empty_eh_document
-    d = @RM::Document.new @d
-
-    assert_empty d
-  end
-
-  def test_equals2
-    d2 = @RM::Document.new
-
-    assert_equal @d, d2
-
-    d2 << @RM::BlankLine.new
-
-    refute_equal @d, d2
-  end
-
-  def test_equals2_file
-    d2 = @RM::Document.new
-    d2.file = 'file.rb'
-
-    refute_equal @d, d2
-
-    @d.file = 'file.rb'
-
-    assert_equal @d, d2
-  end
-
-  def test_file_equals
-    @d.file = 'file.rb'
-
-    assert_equal 'file.rb', @d.file
-  end
-
-  def test_file_equals_top_level
-    @d.file = @store.add_file 'file.rb'
-
-    assert_equal 'file.rb', @d.file
-  end
-
-  def test_lt2
-    @d << @RM::BlankLine.new
-
-    refute_empty @d
-  end
-
-  def test_merge
-    original = @RM::Document.new @RM::Paragraph.new 'original'
-    original.file = 'file.rb'
-    root = @RM::Document.new original
-
-    replace = @RM::Document.new @RM::Paragraph.new 'replace'
-    replace.file = 'file.rb'
-
-    other = @RM::Document.new replace
-
-    result = root.merge other
-
-    inner = @RM::Document.new @RM::Paragraph.new 'replace'
-    inner.file = 'file.rb'
-    expected = @RM::Document.new inner
-
-    assert_equal expected, result
-  end
-
-  def test_merge_add
-    original = @RM::Document.new @RM::Paragraph.new 'original'
-    original.file = 'file.rb'
-    root = @RM::Document.new original
-
-    addition = @RM::Document.new @RM::Paragraph.new 'addition'
-    addition.file = 'other.rb'
-
-    other = @RM::Document.new addition
-
-    result = root.merge other
-
-    expected = @RM::Document.new original, addition
-
-    assert_equal expected, result
-  end
-
-  def test_merge_empty
-    original = @RM::Document.new
-    root = @RM::Document.new original
-
-    replace = @RM::Document.new @RM::Paragraph.new 'replace'
-    replace.file = 'file.rb'
-
-    other = @RM::Document.new replace
-
-    result = root.merge other
-
-    inner = @RM::Document.new @RM::Paragraph.new 'replace'
-    inner.file = 'file.rb'
-    expected = @RM::Document.new inner
-
-    assert_equal expected, result
-  end
-
-  def test_push
-    @d.push @RM::BlankLine.new, @RM::BlankLine.new
-
-    refute_empty @d
-  end
-
-  def test_table_of_contents
-    doc = @RM::Document.new(
-      @RM::Heading.new(1, 'A'),
-      @RM::Paragraph.new('B'),
-      @RM::Heading.new(2, 'C'),
-      @RM::Paragraph.new('D'),
-      @RM::Heading.new(1, 'E'),
-      @RM::Paragraph.new('F'))
-
-    expected = [
-      @RM::Heading.new(1, 'A'),
-      @RM::Heading.new(2, 'C'),
-      @RM::Heading.new(1, 'E'),
-    ]
-
-    assert_equal expected, doc.table_of_contents
-  end
-
-  def test_table_of_contents_omit_headings_below
-    document = doc(
-      head(1, 'A'),
-      para('B'),
-      head(2, 'C'),
-      para('D'),
-      head(1, 'E'),
-      para('F'))
-
-    document.omit_headings_below = 1
-
-    expected = [
-      head(1, 'A'),
-      head(1, 'E'),
-    ]
-
-    assert_equal expected, document.table_of_contents
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc_markup_formatter_test.rb b/test/mri/rdoc/rdoc_markup_formatter_test.rb
deleted file mode 100644
index ee27f24e67c..00000000000
--- a/test/mri/rdoc/rdoc_markup_formatter_test.rb
+++ /dev/null
@@ -1,181 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocMarkupFormatterTest < RDoc::TestCase
-
-  class ToTest < RDoc::Markup::Formatter
-
-    def initialize(markup)
-      super nil, markup
-
-      add_tag :TT, '<code>', '</code>'
-    end
-
-    def accept_paragraph(paragraph)
-      @res += attributes(paragraph.text)
-    end
-
-    def attributes(text)
-      convert_flow @am.flow text.dup
-    end
-
-    def handle_regexp_CAPS(target)
-      "handled #{target.text}"
-    end
-
-    def start_accepting
-      @res = ""
-    end
-
-    def end_accepting
-      @res
-    end
-
-  end
-
-  def setup
-    super
-
-    @markup = @RM.new
-    @markup.add_regexp_handling(/[A-Z]+/, :CAPS)
-
-    @attribute_manager = @markup.attribute_manager
-    @attributes = @attribute_manager.attributes
-
-    @to = ToTest.new @markup
-
-    @caps            = @attributes.bitmap_for :CAPS
-    @regexp_handling = @attributes.bitmap_for :_REGEXP_HANDLING_
-    @tt              = @attributes.bitmap_for :TT
-  end
-
-  def test_class_gen_relative_url
-    def gen(from, to)
-      RDoc::Markup::ToHtml.gen_relative_url from, to
-    end
-
-    assert_equal 'a.html',    gen('a.html',   'a.html')
-    assert_equal 'b.html',    gen('a.html',   'b.html')
-
-    assert_equal 'd.html',    gen('a/c.html', 'a/d.html')
-    assert_equal '../a.html', gen('a/c.html', 'a.html')
-    assert_equal 'a/c.html',  gen('a.html',   'a/c.html')
-  end
-
-  def regexp_handling_names
-    @attribute_manager.regexp_handlings.map do |_, mask|
-      @attributes.as_string mask
-    end
-  end
-
-  def test_add_regexp_handling_RDOCLINK
-    @to.add_regexp_handling_RDOCLINK
-
-    assert_includes regexp_handling_names, 'RDOCLINK'
-
-    def @to.handle_regexp_RDOCLINK(target)
-      "<#{target.text}>"
-    end
-
-    document = doc(para('{foo}[rdoc-label:bar].'))
-
-    formatted = document.accept @to
-
-    assert_equal '{foo}[<rdoc-label:bar>].', formatted
-  end
-
-  def test_add_regexp_handling_TIDYLINK
-    @to.add_regexp_handling_TIDYLINK
-
-    assert_includes regexp_handling_names, 'TIDYLINK'
-
-    def @to.handle_regexp_TIDYLINK(target)
-      "<#{target.text}>"
-    end
-
-    document = doc(para('foo[rdoc-label:bar].'))
-
-    formatted = document.accept @to
-
-    assert_equal '<foo[rdoc-label:bar]>.', formatted
-
-    document = doc(para('{foo}[rdoc-label:bar].'))
-
-    formatted = document.accept @to
-
-    assert_equal '<{foo}[rdoc-label:bar]>.', formatted
-
-    document = doc(para('<tt>{abc}</tt>: {foo}[rdoc-label:bar].'))
-
-    formatted = document.accept @to
-
-    assert_equal '<code>{abc}</code>: <{foo}[rdoc-label:bar]>.', formatted
-  end
-
-  def test_parse_url
-    scheme, url, id = @to.parse_url 'example/foo'
-
-    assert_equal 'http',        scheme
-    assert_equal 'example/foo', url
-    assert_nil   id
-  end
-
-  def test_parse_url_anchor
-    scheme, url, id = @to.parse_url '#foottext-1'
-
-    assert_nil   scheme
-    assert_equal '#foottext-1', url
-    assert_nil   id
-  end
-
-  def test_parse_url_link
-    scheme, url, id = @to.parse_url 'link:README.txt'
-
-    assert_equal 'link',       scheme
-    assert_equal 'README.txt', url
-    assert_nil   id
-  end
-
-  def test_parse_url_link_id
-    scheme, url, id = @to.parse_url 'link:README.txt#label-foo'
-
-    assert_equal 'link',                 scheme
-    assert_equal 'README.txt#label-foo', url
-    assert_nil   id
-  end
-
-  def test_parse_url_rdoc_label
-    scheme, url, id = @to.parse_url 'rdoc-label:foo'
-
-    assert_equal 'link', scheme
-    assert_equal '#foo', url
-    assert_nil   id
-
-    scheme, url, id = @to.parse_url 'rdoc-label:foo:bar'
-
-    assert_equal 'link',      scheme
-    assert_equal '#foo',      url
-    assert_equal ' id="bar"', id
-  end
-
-  def test_parse_url_scheme
-    scheme, url, id = @to.parse_url 'http://example/foo'
-
-    assert_equal 'http',               scheme
-    assert_equal 'http://example/foo', url
-    assert_nil   id
-
-    scheme, url, id = @to.parse_url 'https://example/foo'
-
-    assert_equal 'https',               scheme
-    assert_equal 'https://example/foo', url
-    assert_nil   id
-  end
-
-  def test_convert_tt_regexp_handling
-    converted = @to.convert '<code>AAA</code>'
-
-    assert_equal '<code>AAA</code>', converted
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc_markup_hard_break_test.rb b/test/mri/rdoc/rdoc_markup_hard_break_test.rb
deleted file mode 100644
index 8ec8ffcfed6..00000000000
--- a/test/mri/rdoc/rdoc_markup_hard_break_test.rb
+++ /dev/null
@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocMarkupHardBreakTest < RDoc::TestCase
-
-  def setup
-    super
-
-    @hb = RDoc::Markup::HardBreak.new
-  end
-
-  def test_accept
-    visitor = Object.new
-
-    def visitor.accept_hard_break(obj) @obj = obj end
-    def visitor.obj() @obj end
-
-    @hb.accept visitor
-
-    assert_same @hb, visitor.obj
-  end
-
-  def test_equals2
-    other = RDoc::Markup::HardBreak.new
-
-    assert_equal @hb, other
-
-    refute_equal @hb, Object.new
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc_markup_heading_test.rb b/test/mri/rdoc/rdoc_markup_heading_test.rb
deleted file mode 100644
index 3bf58ed5f77..00000000000
--- a/test/mri/rdoc/rdoc_markup_heading_test.rb
+++ /dev/null
@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocMarkupHeadingTest < RDoc::TestCase
-
-  def setup
-    super
-
-    @h = RDoc::Markup::Heading.new 1, 'Hello *Friend*!'
-  end
-
-  def test_aref
-    assert_equal 'label-Hello+Friend-21', @h.aref
-  end
-
-  def test_label
-    assert_equal 'label-Hello+Friend-21', @h.label
-    assert_equal 'label-Hello+Friend-21', @h.label(nil)
-
-    context = RDoc::NormalClass.new 'Foo'
-
-    assert_equal 'class-Foo-label-Hello+Friend-21', @h.label(context)
-  end
-
-  def test_plain_html
-    assert_equal 'Hello <strong>Friend</strong>!', @h.plain_html
-  end
-
-  def test_plain_html_using_image_alt_as_text
-    h = RDoc::Markup::Heading.new 1, 'rdoc-image:foo.png:Hello World'
-
-    assert_equal 'Hello World', h.plain_html
-  end
-end
diff --git a/test/mri/rdoc/rdoc_markup_include_test.rb b/test/mri/rdoc/rdoc_markup_include_test.rb
deleted file mode 100644
index 1544d25beea..00000000000
--- a/test/mri/rdoc/rdoc_markup_include_test.rb
+++ /dev/null
@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocMarkupIncludeTest < RDoc::TestCase
-
-  def setup
-    super
-
-    @include = @RM::Include.new 'file', [Dir.tmpdir]
-  end
-
-  def test_equals2
-    assert_equal @include, @RM::Include.new('file', [Dir.tmpdir])
-    refute_equal @include, @RM::Include.new('file', %w[.])
-    refute_equal @include, @RM::Include.new('other', [Dir.tmpdir])
-    refute_equal @include, Object.new
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc_markup_indented_paragraph_test.rb b/test/mri/rdoc/rdoc_markup_indented_paragraph_test.rb
deleted file mode 100644
index 3be73b81db8..00000000000
--- a/test/mri/rdoc/rdoc_markup_indented_paragraph_test.rb
+++ /dev/null
@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocMarkupIndentedParagraphTest < RDoc::TestCase
-
-  def setup
-    super
-
-    @IP = RDoc::Markup::IndentedParagraph
-  end
-
-  def test_initialize
-    ip = @IP.new 2, 'a', 'b'
-
-    assert_equal 2, ip.indent
-    assert_equal %w[a b], ip.parts
-  end
-
-  def test_accept
-    visitor = Object.new
-    def visitor.accept_indented_paragraph(obj) @obj = obj end
-    def visitor.obj() @obj end
-
-    paragraph = @IP.new 0
-
-    paragraph.accept visitor
-
-    assert_equal paragraph, visitor.obj
-  end
-
-  def test_equals2
-    one = @IP.new 1
-    two = @IP.new 2
-
-    assert_equal one, one
-    refute_equal one, two
-  end
-
-  def test_text
-    paragraph = @IP.new(2, 'hello', ' world')
-
-    assert_equal 'hello world', paragraph.text
-  end
-
-  def test_text_break
-    paragraph = @IP.new(2, 'hello', hard_break, 'world')
-
-    assert_equal 'helloworld', paragraph.text
-
-    assert_equal "hello\n  world", paragraph.text("\n")
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc_markup_paragraph_test.rb b/test/mri/rdoc/rdoc_markup_paragraph_test.rb
deleted file mode 100644
index 0f1b96e123a..00000000000
--- a/test/mri/rdoc/rdoc_markup_paragraph_test.rb
+++ /dev/null
@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocMarkupParagraphTest < RDoc::TestCase
-
-  def test_accept
-    visitor = Object.new
-    def visitor.accept_paragraph(obj) @obj = obj end
-    def visitor.obj() @obj end
-
-    paragraph = RDoc::Markup::Paragraph.new
-
-    paragraph.accept visitor
-
-    assert_same paragraph, visitor.obj
-  end
-
-  def test_text
-    paragraph = para('hello', ' world')
-
-    assert_equal 'hello world', paragraph.text
-  end
-
-  def test_text_break
-    paragraph = para('hello', hard_break, 'world')
-
-    assert_equal 'helloworld', paragraph.text
-
-    assert_equal "hello\nworld", paragraph.text("\n")
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc_markup_parser_test.rb b/test/mri/rdoc/rdoc_markup_parser_test.rb
deleted file mode 100644
index c157d9c213d..00000000000
--- a/test/mri/rdoc/rdoc_markup_parser_test.rb
+++ /dev/null
@@ -1,1684 +0,0 @@
-# coding: utf-8
-# frozen_string_literal: true
-
-require_relative 'helper'
-
-class RDocMarkupParserTest < RDoc::TestCase
-
-  def setup
-    super
-
-    @RMP = @RM::Parser
-  end
-
-  def test_build_heading
-    parser = @RMP.new
-
-    parser.tokens.replace [
-      [:TEXT,    'heading three',  4, 0],
-      [:NEWLINE, "\n",            17, 0],
-    ]
-
-    assert_equal @RM::Heading.new(3, 'heading three'), parser.build_heading(3)
-  end
-
-  def test_get
-    parser = util_parser
-
-    assert_equal [:HEADER, 1, 0, 0], parser.get
-
-    assert_equal 7, parser.tokens.length
-  end
-
-  def test_parse_bullet
-    str = <<-STR
-* l1
-* l2
-    STR
-
-    expected = [
-      @RM::List.new(:BULLET, *[
-        @RM::ListItem.new(nil,
-          @RM::Paragraph.new('l1')),
-        @RM::ListItem.new(nil,
-          @RM::Paragraph.new('l2'))])]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_bullet_utf_8
-    str = <<-STR
-* 新しい機能
-    STR
-
-    expected = [
-      @RM::List.new(:BULLET, *[
-        @RM::ListItem.new(nil,
-          @RM::Paragraph.new('新しい機能'))])]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_bullet_verbatim_heading
-    str = <<-STR
-* l1
-    v
-
-= H
-    STR
-
-    expected = [
-      @RM::List.new(:BULLET, *[
-        @RM::ListItem.new(nil,
-          @RM::Paragraph.new('l1'),
-          @RM::Verbatim.new("v\n"))]),
-      @RM::Heading.new(1, 'H')]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_bullet_heading
-    str = <<-STR
-* = l1
-    STR
-
-    expected = [
-      @RM::List.new(:BULLET, *[
-        @RM::ListItem.new(nil,
-          @RM::Heading.new(1, 'l1'))])]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_bullet_indent
-    str = <<-STR
-* l1
-  * l1.1
-* l2
-    STR
-
-    expected = [
-      @RM::List.new(:BULLET, *[
-        @RM::ListItem.new(nil,
-          @RM::Paragraph.new('l1'),
-          @RM::List.new(:BULLET, *[
-            @RM::ListItem.new(nil,
-              @RM::Paragraph.new('l1.1'))])),
-        @RM::ListItem.new(nil,
-          @RM::Paragraph.new('l2'))])]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_bullet_paragraph
-    str = <<-STR
-now is
-* l1
-* l2
-the time
-    STR
-
-    expected = [
-      @RM::Paragraph.new('now is'),
-      @RM::List.new(:BULLET, *[
-        @RM::ListItem.new(nil,
-          @RM::Paragraph.new('l1')),
-        @RM::ListItem.new(nil,
-          @RM::Paragraph.new('l2')),
-      ]),
-      @RM::Paragraph.new('the time'),
-    ]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_bullet_multiline
-    str = <<-STR
-* l1
-  l1+
-* l2
-    STR
-
-    expected = [
-      list(:BULLET,
-        item(nil,
-          para('l1 ', 'l1+')),
-        item(nil,
-          para('l2')))]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_bullet_multiparagraph
-    str = <<-STR
-* l1
-
-  l1+
-    STR
-
-    expected = [
-      @RM::List.new(:BULLET, *[
-        @RM::ListItem.new(nil,
-          @RM::Paragraph.new('l1'),
-          @RM::BlankLine.new,
-          @RM::Paragraph.new('l1+')),
-      ]),
-    ]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_bullet_indent_verbatim
-    str = <<-STR
-* l1
-  * l1.1
-    text
-      code
-        code
-
-    text
-* l2
-    STR
-
-    expected = [
-      list(:BULLET,
-        item(nil,
-          para('l1'),
-          list(:BULLET,
-            item(nil,
-              para('l1.1 ', 'text'),
-              verb("code\n", "  code\n"),
-              para('text')))),
-        item(nil,
-          para('l2')))]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_dash
-    str = <<-STR
-- one
-- two
-    STR
-
-    expected = [
-      @RM::List.new(:BULLET, *[
-        @RM::ListItem.new(nil,
-          @RM::Paragraph.new('one')),
-        @RM::ListItem.new(nil,
-          @RM::Paragraph.new('two'))])]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_heading
-    str = '= heading one'
-
-    expected = [
-      @RM::Heading.new(1, 'heading one')]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_heading_three
-    str = '=== heading three'
-
-    expected = [
-      @RM::Heading.new(3, 'heading three')]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_heading_bullet
-    str = '= * heading one'
-
-    expected = [
-      @RM::Heading.new(1, '* heading one')]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_heading_empty
-    str = <<-STR
-===
-* bullet
-    STR
-
-    expected = [
-      @RM::Heading.new(3, ''),
-      @RM::BlankLine.new,
-      @RM::List.new(:BULLET, *[
-        @RM::ListItem.new(nil,
-          @RM::Paragraph.new('bullet'))]),
-    ]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_heading_heading
-    str = '= ='
-
-    expected = [
-      @RM::Heading.new(1, '=')]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_heading_lalpha
-    str = '= b. heading one'
-
-    expected = [
-      @RM::Heading.new(1, 'b. heading one')]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_heading_label
-    str = '= [heading one]'
-
-    expected = [
-      @RM::Heading.new(1, '[heading one]')]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_heading_note
-    str = '= heading one::'
-
-    expected = [
-      @RM::Heading.new(1, 'heading one::')]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_heading_number
-    str = '= 5. heading one'
-
-    expected = [
-      @RM::Heading.new(1, '5. heading one')]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_heading_ualpha
-    str = '= B. heading one'
-
-    expected = [
-      @RM::Heading.new(1, 'B. heading one')]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_label
-    str = <<-STR
-[one] item one
-[two] item two
-    STR
-
-    expected = [
-      list(:LABEL,
-        item(%w[one],
-          para('item one')),
-        item(%w[two],
-          para('item two')))]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_label_bullet
-    str = <<-STR
-[cat] l1
-      * l1.1
-[dog] l2
-    STR
-
-    expected = [
-      list(:LABEL,
-        item(%w[cat],
-          para('l1'),
-          list(:BULLET,
-            item(nil,
-              para('l1.1')))),
-        item(%w[dog],
-          para('l2')))]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_label_multi_label
-    str = <<-STR
-[one]
-[two] some description
-    STR
-
-    expected = [
-      list(:LABEL,
-        item(%w[one two],
-          para('some description')))]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_label_multi_line
-    str = <<-STR
-[cat] l1
-      continuation
-[dog] l2
-    STR
-
-    expected = [
-      list(:LABEL,
-        item(%w[cat],
-          para('l1 ', 'continuation')),
-        item(%w[dog],
-          para('l2')))]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_label_newline
-    str = <<-STR
-[one]
-  item one
-[two]
-  item two
-    STR
-
-    expected = [
-      list(:LABEL,
-        item(%w[one],
-          para('item one')),
-        item(%w[two],
-          para('item two')))]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_lalpha
-    str = <<-STR
-a. l1
-b. l2
-    STR
-
-    expected = [
-      @RM::List.new(:LALPHA, *[
-        @RM::ListItem.new(nil,
-          @RM::Paragraph.new('l1')),
-        @RM::ListItem.new(nil,
-          @RM::Paragraph.new('l2'))])]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_lalpha_ualpha
-    str = <<-STR
-a. l1
-b. l2
-A. l3
-A. l4
-    STR
-
-    expected = [
-      @RM::List.new(:LALPHA, *[
-        @RM::ListItem.new(nil,
-          @RM::Paragraph.new('l1')),
-        @RM::ListItem.new(nil,
-          @RM::Paragraph.new('l2'))]),
-      @RM::List.new(:UALPHA, *[
-        @RM::ListItem.new(nil,
-          @RM::Paragraph.new('l3')),
-        @RM::ListItem.new(nil,
-          @RM::Paragraph.new('l4'))])]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_lalpha_utf_8
-    str = <<-STR
-a. 新しい機能
-    STR
-
-    expected = [
-      @RM::List.new(:LALPHA, *[
-        @RM::ListItem.new(nil,
-          @RM::Paragraph.new('新しい機能'))])]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_line_break
-    str = "now is\nthe time  \nfor all"
-
-    expected = [
-      para('now is ', 'the time'),
-      blank_line,
-      para('for all')]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_list_list_1
-    str = <<-STR
-10. para 1
-
-    [label 1]
-      para 1.1
-
-        code
-
-      para 1.2
-    STR
-
-    expected = [
-      list(:NUMBER,
-        item(nil,
-          para('para 1'),
-          blank_line,
-          list(:LABEL,
-            item(%w[label\ 1],
-              para('para 1.1'),
-              blank_line,
-              verb("code\n"),
-              para('para 1.2')))))]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_list_list_2
-    str = <<-STR
-6. para
-
-   label 1::  text 1
-   label 2::  text 2
-    STR
-
-    expected = [
-      list(:NUMBER,
-        item(nil,
-          para('para'),
-          blank_line,
-          list(:NOTE,
-            item(%w[label\ 1],
-              para('text 1')),
-            item(%w[label\ 2],
-              para('text 2')))))]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_list_verbatim
-    str = <<-STR
-* one
-    verb1
-    verb2
-* two
-    STR
-
-    expected = [
-      @RM::List.new(:BULLET, *[
-        @RM::ListItem.new(nil,
-          @RM::Paragraph.new('one'),
-          @RM::Verbatim.new("verb1\n", "verb2\n")),
-        @RM::ListItem.new(nil,
-          @RM::Paragraph.new('two'))])]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_lists
-    str = <<-STR
-now is
-* l1
-1. n1
-2. n2
-* l2
-the time
-    STR
-
-    expected = [
-      @RM::Paragraph.new('now is'),
-      @RM::List.new(:BULLET, *[
-        @RM::ListItem.new(nil,
-          @RM::Paragraph.new('l1'))]),
-      @RM::List.new(:NUMBER, *[
-        @RM::ListItem.new(nil,
-          @RM::Paragraph.new('n1')),
-        @RM::ListItem.new(nil,
-          @RM::Paragraph.new('n2'))]),
-      @RM::List.new(:BULLET, *[
-        @RM::ListItem.new(nil,
-          @RM::Paragraph.new('l2'))]),
-      @RM::Paragraph.new('the time')]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_note
-    str = <<-STR
-one:: item one
-two:: item two
-    STR
-
-    expected = [
-      list(:NOTE,
-        item(%w[one],
-          para('item one')),
-        item(%w[two],
-          para('item two')))]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_note_empty
-    str = <<-STR
-one::
-two::
-    STR
-
-    expected = [
-      list(:NOTE,
-        item(%w[one two],
-          blank_line))]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_note_note
-    str = <<-STR
-one:: two::
-    STR
-
-    expected = [
-      list(:NOTE,
-        item(%w[one],
-          list(:NOTE,
-            item(%w[two],
-              blank_line))))]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_number_bullet
-    str = <<-STR
-1. l1
-   * l1.1
-2. l2
-    STR
-
-    expected = [
-      list(:NUMBER,
-        item(nil,
-          para('l1'),
-          list(:BULLET,
-            item(nil,
-              para('l1.1')))),
-        item(nil,
-          para('l2')))]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_paragraph
-    str = <<-STR
-now is the time
-
-for all good men
-    STR
-
-    expected = [
-      @RM::Paragraph.new('now is the time'),
-      @RM::BlankLine.new,
-      @RM::Paragraph.new('for all good men')]
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_paragraph_multiline
-    str = "now is the time\nfor all good men"
-
-    expected = @RM::Paragraph.new 'now is the time ', 'for all good men'
-    assert_equal [expected], @RMP.parse(str).parts
-  end
-
-  def test_parse_paragraph_verbatim
-    str = <<-STR
-now is the time
-  code _line_ here
-for all good men
-    STR
-
-    expected = [
-      @RM::Paragraph.new('now is the time'),
-      @RM::Verbatim.new("code _line_ here\n"),
-      @RM::Paragraph.new('for all good men'),
-    ]
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_rule
-    str = <<-STR
-now is the time
-
----
-
-for all good men
-    STR
-
-    expected = [
-      @RM::Paragraph.new('now is the time'),
-      @RM::BlankLine.new,
-      @RM::Rule.new(1),
-      @RM::BlankLine.new,
-      @RM::Paragraph.new('for all good men')]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_ualpha
-    str = <<-STR
-A. l1
-B. l2
-    STR
-
-    expected = [
-      @RM::List.new(:UALPHA, *[
-        @RM::ListItem.new(nil,
-          @RM::Paragraph.new('l1')),
-        @RM::ListItem.new(nil,
-          @RM::Paragraph.new('l2'))])]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_trailing_cr
-    expected = [ @RM::Paragraph.new('Text') ]
-    assert_equal expected, @RMP.parse("Text\r").parts
-  end
-
-  def test_parse_verbatim
-    str = <<-STR
-now is
-   code
-the time
-    STR
-
-    expected = [
-      @RM::Paragraph.new('now is'),
-      @RM::Verbatim.new("code\n"),
-      @RM::Paragraph.new('the time'),
-    ]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_verbatim_bullet
-    str = <<-STR
-  * blah
-    STR
-
-    expected = [
-      @RM::Verbatim.new("* blah\n")]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_verbatim_dash
-    str = <<-STR
-  - blah
-    STR
-
-    expected = [
-      @RM::Verbatim.new("- blah\n")]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_verbatim_fold
-    str = <<-STR
-now is
-   code
-
-
-   code1
-
-the time
-    STR
-
-    expected = [
-      @RM::Paragraph.new('now is'),
-      @RM::Verbatim.new("code\n", "\n", "code1\n"),
-      @RM::Paragraph.new('the time'),
-    ]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_verbatim_heading
-    str = <<-STR
-text
-   ===   heading three
-    STR
-
-    expected = [
-      @RM::Paragraph.new('text'),
-      @RM::Verbatim.new("===   heading three\n")]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_verbatim_heading2
-    str = "text\n   code\n=== heading three"
-
-    expected = [
-      @RM::Paragraph.new('text'),
-      @RM::Verbatim.new("code\n"),
-      @RM::Heading.new(3, 'heading three')]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_verbatim_label
-    str = <<-STR
-  [blah] blah
-    STR
-
-    expected = [
-      @RM::Verbatim.new("[blah] blah\n")]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_verbatim_lalpha
-    str = <<-STR
-  b. blah
-    STR
-
-    expected = [
-      @RM::Verbatim.new("b. blah\n")]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_verbatim_markup_example
-    str = <<-STR
-text
-   code
-   === heading three
-    STR
-
-    expected = [
-      @RM::Paragraph.new('text'),
-      @RM::Verbatim.new("code\n", "=== heading three\n")]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_verbatim_merge
-    str = <<-STR
-now is
-   code
-
-   code1
-the time
-    STR
-
-    expected = [
-      @RM::Paragraph.new('now is'),
-      @RM::Verbatim.new("code\n", "\n", "code1\n"),
-      @RM::Paragraph.new('the time'),
-    ]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_verbatim_merge2
-    str = <<-STR
-now is
-   code
-
-   code1
-
-   code2
-the time
-    STR
-
-    expected = [
-      @RM::Paragraph.new('now is'),
-      @RM::Verbatim.new("code\n", "\n", "code1\n", "\n", "code2\n"),
-      @RM::Paragraph.new('the time'),
-    ]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_verbatim_multiline
-    str = <<-STR
-now is
-   code
-   code1
-the time
-    STR
-
-    expected = [
-      @RM::Paragraph.new('now is'),
-      @RM::Verbatim.new("code\n", "code1\n"),
-      @RM::Paragraph.new('the time'),
-    ]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_verbatim_multilevel
-    str = <<-STR
-now is the time
-  code
- more code
-for all good men
-    STR
-
-    expected = [
-      @RM::Paragraph.new('now is the time'),
-      @RM::Verbatim.new(" code\n",
-                        "more code\n"),
-      @RM::Paragraph.new('for all good men'),
-    ]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_verbatim_note
-    str = <<-STR
-  blah:: blah
-    STR
-
-    expected = [
-      @RM::Verbatim.new("blah:: blah\n")]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_verbatim_number
-    str = <<-STR
-  2. blah
-    STR
-
-    expected = [
-      @RM::Verbatim.new("2. blah\n")]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_verbatim_rule
-    str = <<-STR
-text
-
-  --- lib/blah.rb.orig
-  +++ lib/blah.rb
-    STR
-
-    expected = [
-      @RM::Paragraph.new('text'),
-      @RM::BlankLine.new,
-      @RM::Verbatim.new("--- lib/blah.rb.orig\n",
-                        "+++ lib/blah.rb\n")]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_verbatim_rule2
-    str = <<-STR.chomp
-text
-
-  ---
-    STR
-
-    expected = [
-      @RM::Paragraph.new('text'),
-      @RM::BlankLine.new,
-      @RM::Verbatim.new("---")]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_verbatim_trim
-    str = <<-STR
-now is
-   code
-
-   code1
-
-the time
-    STR
-
-    expected = [
-      @RM::Paragraph.new('now is'),
-      @RM::Verbatim.new("code\n",
-                        "\n",
-                        "code1\n"),
-      @RM::Paragraph.new('the time'),
-    ]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_verbatim_ualpha
-    str = <<-STR
-  B. blah
-    STR
-
-    expected = [
-      @RM::Verbatim.new("B. blah\n")]
-
-    assert_equal expected, @RMP.parse(str).parts
-  end
-
-  def test_parse_whitespace
-    expected = [
-      @RM::Paragraph.new('hello'),
-    ]
-
-    assert_equal expected, @RMP.parse('hello').parts
-
-    expected = [
-      @RM::Verbatim.new('hello '),
-    ]
-
-    assert_equal expected, @RMP.parse('  hello ').parts
-
-    expected = [
-      @RM::Verbatim.new('hello          '),
-    ]
-
-    assert_equal expected, @RMP.parse('                 hello          ').parts
-
-    expected = [
-      @RM::Paragraph.new('1'),
-      @RM::Verbatim.new("2\n", ' 3'),
-    ]
-
-    assert_equal expected, @RMP.parse("1\n 2\n  3").parts
-
-    expected = [
-      @RM::Verbatim.new("1\n",
-                        " 2\n",
-                        "  3"),
-    ]
-
-    assert_equal expected, @RMP.parse("  1\n   2\n    3").parts
-
-    expected = [
-      @RM::Paragraph.new('1'),
-      @RM::Verbatim.new("2\n",
-                        " 3\n"),
-      @RM::Paragraph.new('1'),
-      @RM::Verbatim.new('2'),
-    ]
-
-    assert_equal expected, @RMP.parse("1\n 2\n  3\n1\n 2").parts
-
-    expected = [
-      @RM::Verbatim.new("1\n",
-                        " 2\n",
-                        "  3\n",
-                        "1\n",
-                        ' 2'),
-    ]
-
-    assert_equal expected, @RMP.parse("  1\n   2\n    3\n  1\n   2").parts
-
-    expected = [
-      @RM::Verbatim.new("1\n",
-                        " 2\n",
-                        "\n",
-                        '  3'),
-    ]
-
-    assert_equal expected, @RMP.parse("  1\n   2\n\n    3").parts
-  end
-
-  def test_parse_block_quote
-    expected = [
-      @RM::BlockQuote.new(@RM::Paragraph.new("foo"))
-    ]
-    assert_equal expected, @RMP.parse(<<-DOC).parts
->>>
-  foo
-    DOC
-
-    expected = [
-      @RM::BlockQuote.new(@RM::Paragraph.new("foo"),
-                          @RM::Verbatim.new("code\n"),
-                          @RM::Paragraph.new("bar"))
-    ]
-    assert_equal expected, @RMP.parse(<<-DOC).parts
->>>
-  foo
-    code
-  bar
-    DOC
-
-    expected = [
-      @RM::BlockQuote.new(@RM::Paragraph.new("foo"),
-                          @RM::BlockQuote.new(@RM::Paragraph.new("bar")),
-                          @RM::Paragraph.new("zot"))
-    ]
-    assert_equal expected, @RMP.parse(<<-DOC).parts
->>>
-  foo
-  >>>
-    bar
-  zot
-    DOC
-  end
-
-  def test_peek_token
-    parser = util_parser
-
-    assert_equal [:HEADER, 1, 0, 0], parser.peek_token
-
-    assert_equal 8, parser.tokens.length
-  end
-
-  def test_skip
-    parser = util_parser
-
-    assert_equal [:HEADER, 1, 0, 0], parser.skip(:HEADER)
-
-    assert_equal [:TEXT, 'Heading', 2, 0], parser.get
-
-    assert_equal [:NEWLINE, "\n", 9, 0], parser.peek_token
-
-    assert_raise RDoc::Markup::Parser::ParseError do
-      parser.skip :NONE
-    end
-
-    assert_equal [:NEWLINE, "\n", 9, 0], parser.peek_token
-
-    assert_nil parser.skip(:NONE, false)
-
-    assert_equal [:NEWLINE, "\n", 9, 0], parser.peek_token
-  end
-
-  def test_tokenize_bullet
-    str = <<-STR
-* l1
-    STR
-
-    expected = [
-      [:BULLET,  '*',     0, 0],
-      [:TEXT,    'l1',    2, 0],
-      [:NEWLINE, "\n",    4, 0],
-    ]
-
-    assert_equal expected, @RMP.tokenize(str)
-  end
-
-  def test_tokenize_bullet_indent
-    str = <<-STR
-* l1
-  * l1.1
-    STR
-
-    expected = [
-      [:BULLET,  '*',     0, 0],
-      [:TEXT,    'l1',    2, 0],
-      [:NEWLINE, "\n",    4, 0],
-      [:BULLET,  '*',     2, 1],
-      [:TEXT,    'l1.1',  4, 1],
-      [:NEWLINE, "\n",    8, 1],
-    ]
-
-    assert_equal expected, @RMP.tokenize(str)
-  end
-
-  def test_tokenize_heading
-    str = <<-STR
-= Heading
-== Heading 2
-    STR
-
-    expected = [
-      [:HEADER,  1,            0, 0],
-      [:TEXT,    'Heading',    2, 0],
-      [:NEWLINE, "\n",         9, 0],
-      [:HEADER,  2,            0, 1],
-      [:TEXT,    'Heading 2',  3, 1],
-      [:NEWLINE, "\n",        12, 1],
-    ]
-
-    assert_equal expected, @RMP.tokenize(str)
-  end
-
-  def test_tokenize_heading_empty
-    str = <<-STR
-===
-* bullet
-    STR
-
-    expected = [
-      [:HEADER,  3,        0, 0],
-      [:NEWLINE, "\n",     3, 0],
-      [:BULLET,  "*",      0, 1],
-      [:TEXT,    "bullet", 2, 1],
-      [:NEWLINE, "\n",     8, 1],
-    ]
-
-    assert_equal expected, @RMP.tokenize(str)
-  end
-
-  def test_tokenize_heading_heading
-    str = <<-STR
-= =
-    STR
-
-    expected = [
-      [:HEADER,  1,    0, 0],
-      [:TEXT,    '=',  2, 0],
-      [:NEWLINE, "\n", 3, 0],
-    ]
-
-    assert_equal expected, @RMP.tokenize(str)
-  end
-
-  def test_tokenize_heading_no_space
-    str = <<-STR
-=Heading
-==Heading 2
-    STR
-
-    expected = [
-      [:HEADER,  1,            0, 0],
-      [:TEXT,    'Heading',    1, 0],
-      [:NEWLINE, "\n",         8, 0],
-      [:HEADER,  2,            0, 1],
-      [:TEXT,    'Heading 2',  2, 1],
-      [:NEWLINE, "\n",        11, 1],
-    ]
-
-    assert_equal expected, @RMP.tokenize(str)
-  end
-
-  def test_tokenize_label
-    str = <<-STR
-[cat] l1
-[dog] l1.1
-    STR
-
-    expected = [
-      [:LABEL,   'cat',   0, 0],
-      [:TEXT,    'l1',    6, 0],
-      [:NEWLINE, "\n",    8, 0],
-      [:LABEL,   'dog',   0, 1],
-      [:TEXT,    'l1.1',  6, 1],
-      [:NEWLINE, "\n",   10, 1],
-    ]
-
-    assert_equal expected, @RMP.tokenize(str)
-  end
-
-  def test_tokenize_label_note
-    str = <<-STR
-[label]
-  note::
-    STR
-
-    expected = [
-      [:LABEL,   'label', 0, 0],
-      [:NEWLINE, "\n",    7, 0],
-      [:NOTE,    'note',  2, 1],
-      [:NEWLINE, "\n",    8, 1],
-    ]
-
-    assert_equal expected, @RMP.tokenize(str)
-  end
-
-  def test_tokenize_label_newline
-    str = <<-STR
-[cat]
-  l1
-    STR
-
-    expected = [
-      [:LABEL,   'cat',   0, 0],
-      [:NEWLINE, "\n",    5, 0],
-      [:TEXT,    'l1',    2, 1],
-      [:NEWLINE, "\n",    4, 1],
-    ]
-
-    assert_equal expected, @RMP.tokenize(str)
-  end
-
-  def test_tokenize_label_newline_windows
-    str = <<-STR
-[cat]\r
-  l1\r
-    STR
-
-    expected = [
-      [:LABEL,   'cat',   0, 0],
-      [:NEWLINE, "\n",    6, 0],
-      [:TEXT,    'l1',    2, 1],
-      [:NEWLINE, "\n",    5, 1],
-    ]
-
-    assert_equal expected, @RMP.tokenize(str)
-  end
-
-  def test_tokenize_lalpha
-    str = <<-STR
-a. l1
-b. l1.1
-    STR
-
-    expected = [
-      [:LALPHA,  'a',     0, 0],
-      [:TEXT,    'l1',    3, 0],
-      [:NEWLINE, "\n",    5, 0],
-      [:LALPHA,  'b',     0, 1],
-      [:TEXT,    'l1.1',  3, 1],
-      [:NEWLINE, "\n",    7, 1],
-    ]
-
-    assert_equal expected, @RMP.tokenize(str)
-  end
-
-  def test_tokenize_line_break
-    str = "now is\nthe time  \nfor all\n"
-
-    expected = [
-      [:TEXT,    'now is',    0, 0],
-      [:NEWLINE, "\n",        6, 0],
-      [:TEXT,    'the time',  0, 1],
-      [:BREAK,   "  ",        8, 1],
-      [:NEWLINE, "\n",       10, 1],
-      [:TEXT,    'for all',   0, 2],
-      [:NEWLINE, "\n",        7, 2],
-    ]
-
-    assert_equal expected, @RMP.tokenize(str)
-  end
-
-  def test_tokenize_line_break_long
-    str = "now is\nthe time   \nfor all\n"
-
-    expected = [
-      [:TEXT,    'now is',     0, 0],
-      [:NEWLINE, "\n",         6, 0],
-      [:TEXT,    'the time ',  0, 1],
-      [:BREAK,   '  ',         9, 1],
-      [:NEWLINE, "\n",        11, 1],
-      [:TEXT,    'for all',    0, 2],
-      [:NEWLINE, "\n",         7, 2],
-    ]
-
-    assert_equal expected, @RMP.tokenize(str)
-  end
-
-  def test_tokenize_line_break_no_short
-    str = "now is\nthe time \nfor all\n"
-
-    expected = [
-      [:TEXT,    'now is',    0, 0],
-      [:NEWLINE, "\n",        6, 0],
-      [:TEXT,    'the time ', 0, 1],
-      [:NEWLINE, "\n",        9, 1],
-      [:TEXT,    'for all',   0, 2],
-      [:NEWLINE, "\n",        7, 2],
-    ]
-
-    assert_equal expected, @RMP.tokenize(str)
-  end
-
-  def test_tokenize_note
-    str = <<-STR
-cat:: l1
-dog:: l1.1
-    STR
-
-    expected = [
-      [:NOTE,    'cat',   0, 0],
-      [:TEXT,    'l1',    6, 0],
-      [:NEWLINE, "\n",    8, 0],
-      [:NOTE,    'dog',   0, 1],
-      [:TEXT,    'l1.1',  6, 1],
-      [:NEWLINE, "\n",   10, 1],
-    ]
-
-    assert_equal expected, @RMP.tokenize(str)
-  end
-
-  def test_tokenize_note_empty
-    str = <<-STR
-cat::
-dog::
-    STR
-
-    expected = [
-      [:NOTE,    'cat', 0, 0],
-      [:NEWLINE, "\n",  5, 0],
-      [:NOTE,    'dog', 0, 1],
-      [:NEWLINE, "\n",  5, 1],
-    ]
-
-    assert_equal expected, @RMP.tokenize(str)
-  end
-
-  def test_tokenize_note_newline
-    str = <<-STR
-cat::
-  l1
-    STR
-
-    expected = [
-      [:NOTE,    'cat',   0, 0],
-      [:NEWLINE, "\n",    5, 0],
-      [:TEXT,    'l1',    2, 1],
-      [:NEWLINE, "\n",    4, 1],
-    ]
-
-    assert_equal expected, @RMP.tokenize(str)
-  end
-
-  def test_tokenize_note_utf_8
-    str = <<-STR
-cät:: l1a
-      l1b
-døg:: l2a
-      l2b
-    STR
-
-    expected = [
-      [:NOTE,    'cät',   0, 0],
-      [:TEXT,    'l1a',   6, 0],
-      [:NEWLINE, "\n",    9, 0],
-      [:TEXT,    'l1b',   6, 1],
-      [:NEWLINE, "\n",    9, 1],
-      [:NOTE,    'døg',   0, 2],
-      [:TEXT,    'l2a',   6, 2],
-      [:NEWLINE, "\n",    9, 2],
-      [:TEXT,    'l2b',   6, 3],
-      [:NEWLINE, "\n",    9, 3],
-    ]
-
-    assert_equal expected, @RMP.tokenize(str)
-  end
-
-  def test_tokenize_note_newline_windows
-    str = <<-STR
-cat::\r
-  l1\r
-    STR
-
-    expected = [
-      [:NOTE,    'cat',   0, 0],
-      [:NEWLINE, "\n",    6, 0],
-      [:TEXT,    'l1',    2, 1],
-      [:NEWLINE, "\n",    5, 1],
-    ]
-
-    assert_equal expected, @RMP.tokenize(str)
-  end
-
-  def test_tokenize_note_not
-    str = <<-STR
-Cat::Dog
-    STR
-
-    expected = [
-      [:TEXT,    'Cat::Dog', 0, 0],
-      [:NEWLINE, "\n",       8, 0],
-    ]
-
-    assert_equal expected, @RMP.tokenize(str)
-  end
-
-  def test_tokenize_number
-    str = <<-STR
-1. l1
-2. l1.1
-    STR
-
-    expected = [
-      [:NUMBER,  '1',     0, 0],
-      [:TEXT,    'l1',    3, 0],
-      [:NEWLINE, "\n",    5, 0],
-      [:NUMBER,  '2',     0, 1],
-      [:TEXT,    'l1.1',  3, 1],
-      [:NEWLINE, "\n",    7, 1],
-    ]
-
-    assert_equal expected, @RMP.tokenize(str)
-  end
-
-  def test_tokenize_number_period
-    str = <<-STR
-1. blah blah blah
-   l.
-2. blah blah blah blah
-   d.
-    STR
-
-    expected = [
-      [:NUMBER,  "1",                    0, 0],
-      [:TEXT,    "blah blah blah",       3, 0],
-      [:NEWLINE, "\n",                  17, 0],
-
-      [:TEXT,    "l.",                   3, 1],
-      [:NEWLINE, "\n",                   5, 1],
-
-      [:NUMBER,  "2",                    0, 2],
-      [:TEXT,    "blah blah blah blah",  3, 2],
-      [:NEWLINE, "\n",                  22, 2],
-
-      [:TEXT,    "d.",                   3, 3],
-      [:NEWLINE, "\n",                   5, 3]
-    ]
-
-    assert_equal expected, @RMP.tokenize(str)
-  end
-
-  def test_tokenize_number_period_continue
-    str = <<-STR
-1. blah blah blah
-   l.  more stuff
-2. blah blah blah blah
-   d. other stuff
-    STR
-
-    expected = [
-      [:NUMBER,  "1",                    0, 0],
-      [:TEXT,    "blah blah blah",       3, 0],
-      [:NEWLINE, "\n",                  17, 0],
-
-      [:LALPHA,  "l",                    3, 1],
-      [:TEXT,    "more stuff",           7, 1],
-      [:NEWLINE, "\n",                  17, 1],
-
-      [:NUMBER,  "2",                    0, 2],
-      [:TEXT,    "blah blah blah blah",  3, 2],
-      [:NEWLINE, "\n",                  22, 2],
-
-      [:LALPHA,  "d",                    3, 3],
-      [:TEXT,    "other stuff",          6, 3],
-      [:NEWLINE, "\n",                  17, 3]
-    ]
-
-    assert_equal expected, @RMP.tokenize(str)
-  end
-
-  def test_tokenize_paragraphs
-    str = <<-STR
-now is
-the time
-
-for all
-    STR
-
-    expected = [
-      [:TEXT,    'now is',   0, 0],
-      [:NEWLINE, "\n",       6, 0],
-      [:TEXT,    'the time', 0, 1],
-      [:NEWLINE, "\n",       8, 1],
-      [:NEWLINE, "\n",       0, 2],
-      [:TEXT,    'for all',  0, 3],
-      [:NEWLINE, "\n",       7, 3],
-    ]
-
-    assert_equal expected, @RMP.tokenize(str)
-  end
-
-  def test_tokenize_rule
-    str = <<-STR
----
-
---- blah ---
-    STR
-
-    expected = [
-      [:RULE,    1,            0, 0],
-      [:NEWLINE, "\n",         3, 0],
-      [:NEWLINE, "\n",         0, 1],
-      [:TEXT, "--- blah ---",  0, 2],
-      [:NEWLINE, "\n",        12, 2],
-    ]
-
-    assert_equal expected, @RMP.tokenize(str)
-  end
-
-  def test_tokenize_rule_windows
-    str = <<-STR
----\r
-
---- blah ---\r
-    STR
-
-    expected = [
-      [:RULE,    1,            0, 0],
-      [:NEWLINE, "\n",         4, 0],
-      [:NEWLINE, "\n",         0, 1],
-      [:TEXT, "--- blah ---",  0, 2],
-      [:NEWLINE, "\n",        13, 2],
-    ]
-
-    assert_equal expected, @RMP.tokenize(str)
-  end
-
-  def test_tokenize_ualpha
-    str = <<-STR
-A. l1
-B. l1.1
-    STR
-
-    expected = [
-      [:UALPHA,  'A',     0, 0],
-      [:TEXT,    'l1',    3, 0],
-      [:NEWLINE, "\n",    5, 0],
-      [:UALPHA,  'B',     0, 1],
-      [:TEXT,    'l1.1',  3, 1],
-      [:NEWLINE, "\n",    7, 1],
-    ]
-
-    assert_equal expected, @RMP.tokenize(str)
-  end
-
-  def test_tokenize_verbatim_heading
-    str = <<-STR
-Example heading:
-
-   === heading three
-    STR
-
-    expected = [
-      [:TEXT,    'Example heading:',  0, 0],
-      [:NEWLINE, "\n",               16, 0],
-      [:NEWLINE, "\n",                0, 1],
-      [:HEADER,  3,                   3, 2],
-      [:TEXT,    'heading three',     7, 2],
-      [:NEWLINE, "\n",               20, 2],
-    ]
-
-    assert_equal expected, @RMP.tokenize(str)
-  end
-
-  def test_tokenize_verbatim_rule
-    str = <<-STR
-  Verbatim section here that is double-underlined
-  ===============================================
-    STR
-
-    expected = [
-      [:TEXT,    'Verbatim section here that is double-underlined',  2, 0],
-      [:NEWLINE, "\n",                                              49, 0],
-      [:HEADER,  47,                                                 2, 1],
-      [:NEWLINE, "\n",                                              49, 1],
-    ]
-
-    assert_equal expected, @RMP.tokenize(str)
-  end
-
-  def test_tokenize_verbatim_rule_fancy
-    str = <<-STR
-  A
-    b
-  ===============================================
-    c
-    STR
-
-    expected = [
-      [:TEXT,    'A',   2, 0],
-      [:NEWLINE, "\n",  3, 0],
-      [:TEXT,    'b',   4, 1],
-      [:NEWLINE, "\n",  5, 1],
-      [:HEADER,  47,    2, 2],
-      [:NEWLINE, "\n", 49, 2],
-      [:TEXT,    'c',   4, 3],
-      [:NEWLINE, "\n",  5, 3],
-    ]
-
-    assert_equal expected, @RMP.tokenize(str)
-  end
-
-  # HACK move to Verbatim test case
-  def test_verbatim_normalize
-    v = @RM::Verbatim.new "foo\n", "\n", "\n", "bar\n"
-
-    v.normalize
-
-    assert_equal ["foo\n", "\n", "bar\n"], v.parts
-
-    v = @RM::Verbatim.new "foo\n", "\n"
-
-    v.normalize
-
-    assert_equal ["foo\n"], v.parts
-  end
-
-  def test_unget
-    parser = util_parser
-
-    parser.get
-
-    parser.unget
-
-    assert_equal [:HEADER, 1, 0, 0], parser.peek_token
-
-    assert_raise @RMP::Error do
-      parser.unget
-    end
-
-    assert_equal 8, parser.tokens.length
-  end
-
-  def util_parser
-    str = <<-STR
-= Heading
-
-Some text here
-some more text over here
-    STR
-
-    @parser = @RMP.new
-    @parser.tokenize str
-    @parser
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc_markup_pre_process_test.rb b/test/mri/rdoc/rdoc_markup_pre_process_test.rb
deleted file mode 100644
index 2a8cd92dd04..00000000000
--- a/test/mri/rdoc/rdoc_markup_pre_process_test.rb
+++ /dev/null
@@ -1,481 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'helper'
-
-class RDoc::Markup::PreProcessTest < RDoc::TestCase
-
-  def setup
-    super
-
-    @tempfile = Tempfile.new 'test_rdoc_markup_pre_process'
-    @file_name = File.basename @tempfile.path
-    @dir  = File.dirname @tempfile.path
-
-    @pp = RDoc::Markup::PreProcess.new @tempfile.path, [@dir, File.dirname(__FILE__)]
-  end
-
-  def teardown
-    super
-
-    @tempfile.close!
-  end
-
-  def test_class_register
-    RDoc::Markup::PreProcess.register 'for_test' do raise 'fail' end
-
-    assert_equal %w[for_test], RDoc::Markup::PreProcess.registered.keys
-  end
-
-  def test_class_post_process
-    RDoc::Markup::PreProcess.post_process do end
-
-    assert_equal 1, RDoc::Markup::PreProcess.post_processors.length,
-                 proc{RDoc::Markup::PreProcess.post_processors.inspect}
-  end
-
-  def test_include_file
-    @tempfile.write <<-INCLUDE
-# -*- mode: rdoc; coding: utf-8; fill-column: 74; -*-
-
-Regular expressions (<i>regexp</i>s) are patterns which describe the
-contents of a string.
-    INCLUDE
-
-    @tempfile.flush
-    @tempfile.rewind
-
-    content = @pp.include_file @file_name, '', nil
-
-    expected = <<-EXPECTED
-Regular expressions (<i>regexp</i>s) are patterns which describe the
-contents of a string.
-    EXPECTED
-
-    assert_equal expected, content
-  end
-
-  def test_include_file_encoding_incompatible
-    @tempfile.write <<-INCLUDE
-# -*- mode: rdoc; coding: utf-8; fill-column: 74; -*-
-
-π
-    INCLUDE
-
-    @tempfile.flush
-    @tempfile.rewind
-
-    content = @pp.include_file @file_name, '', Encoding::US_ASCII
-
-    expected = "?\n"
-
-    assert_equal expected, content
-  end
-
-  def test_include_file_in_other_directory
-    content = nil
-    out, err = capture_output do
-      content = @pp.include_file "test.txt", '', nil
-    end
-
-    assert_empty out
-    assert_empty err
-
-    assert_equal "test file\n", content
-  end
-
-  def test_handle
-    text = "# :main: M\n"
-    output = nil
-    _, err = capture_output do
-      output = @pp.handle text
-    end
-
-    assert_include err, "The :main: directive is deprecated and will be removed in RDoc 7."
-    assert_equal "#\n", output
-  end
-
-  def test_handle_comment
-    text = "# :main: M\n"
-    c = comment text
-
-    output = nil
-    _, err = capture_output do
-      output = @pp.handle c
-    end
-
-    assert_include err, "The :main: directive is deprecated and will be removed in RDoc 7."
-    assert_equal "#\n", output
-  end
-
-  def test_handle_markup
-    c = comment ':markup: rd'
-
-    @pp.handle c
-
-    assert_equal 'rd', c.format
-  end
-
-  def test_handle_markup_empty
-    c = comment ':markup:'
-
-    @pp.handle c
-
-    assert_equal 'rdoc', c.format
-  end
-
-  def test_handle_post_process
-    cd = RDoc::CodeObject.new
-
-    RDoc::Markup::PreProcess.post_process do |text, code_object|
-      code_object.metadata[:stuff] = text
-
-      :junk
-    end
-
-    text = "# a b c\n"
-
-    out = @pp.handle text, cd
-
-    assert_equal "# a b c\n", out
-    assert_equal "# a b c\n", cd.metadata[:stuff]
-  end
-
-  def test_handle_unregistered
-    text = "# :x: y\n"
-    out = @pp.handle text
-
-    assert_equal text, out
-  end
-
-  def test_handle_directive_blankline
-    result = @pp.handle_directive '#', 'arg', 'a, b'
-
-    assert_equal "#:arg: a, b\n", result
-  end
-
-  def test_handle_directive_downcase
-    method = RDoc::AnyMethod.new nil, 'm'
-
-    @pp.handle_directive '', 'ARG', 'a, b', method
-
-    assert_equal 'a, b', method.params
-  end
-
-  def test_handle_directive_arg
-    method = RDoc::AnyMethod.new nil, 'm'
-
-    @pp.handle_directive '', 'arg', 'a, b', method
-
-    assert_equal 'a, b', method.params
-  end
-
-  def test_handle_directive_arg_no_context
-    result = @pp.handle_directive '', 'arg', 'a, b', nil
-
-    assert_equal ":arg: a, b\n", result
-  end
-
-  def test_handle_directive_args
-    method = RDoc::AnyMethod.new nil, 'm'
-
-    @pp.handle_directive '', 'args', 'a, b', method
-
-    assert_equal 'a, b', method.params
-  end
-
-  def test_handle_directive_block
-    result = @pp.handle_directive '', 'x', 'y' do |directive, param|
-      ''
-    end
-
-    assert_empty result
-  end
-
-  def test_handle_directive_block_false
-    result = @pp.handle_directive '', 'x', 'y' do |directive, param|
-      false
-    end
-
-    assert_equal ":x: y\n", result
-  end
-
-  def test_handle_directive_block_nil
-    result = @pp.handle_directive '', 'x', 'y' do |directive, param|
-      nil
-    end
-
-    assert_equal ":x: y\n", result
-  end
-
-  def test_handle_directive_category
-    context = RDoc::Context.new
-    original_section = context.current_section
-
-    @pp.handle_directive '', 'category', 'other', context
-
-    refute_equal original_section, context.current_section
-  end
-
-  def test_handle_directive_doc
-    code_object = RDoc::CodeObject.new
-    code_object.document_self = false
-    code_object.force_documentation = false
-
-    @pp.handle_directive '', 'doc', nil, code_object
-
-    assert code_object.document_self
-    assert code_object.force_documentation
-  end
-
-  def test_handle_directive_doc_no_context
-    result = @pp.handle_directive '', 'doc', nil
-
-    assert_equal "\n", result
-  end
-
-  def test_handle_directive_enddoc
-    code_object = RDoc::CodeObject.new
-
-    @pp.handle_directive '', 'enddoc', nil, code_object
-
-    assert code_object.done_documenting
-  end
-
-  def test_handle_directive_include
-    @tempfile.write 'included'
-    @tempfile.flush
-
-    result = @pp.handle_directive '', 'include', @file_name
-
-    assert_equal 'included', result
-  end
-
-  def test_handle_directive_main
-    @pp.options = RDoc::Options.new
-
-    _, err = capture_output do
-      @pp.handle_directive '', 'main', 'M'
-    end
-
-    assert_include err, "The :main: directive is deprecated and will be removed in RDoc 7."
-    assert_equal 'M', @pp.options.main_page
-  end
-
-  def test_handle_directive_notnew
-    m = RDoc::AnyMethod.new nil, 'm'
-
-    @pp.handle_directive '', 'notnew', nil, m
-
-    assert m.dont_rename_initialize
-  end
-
-  def test_handle_directive_not_new
-    m = RDoc::AnyMethod.new nil, 'm'
-
-    @pp.handle_directive '', 'not_new', nil, m
-
-    assert m.dont_rename_initialize
-  end
-
-  def test_handle_directive_not_dash_new
-    m = RDoc::AnyMethod.new nil, 'm'
-
-    @pp.handle_directive '', 'not-new', nil, m
-
-    assert m.dont_rename_initialize
-  end
-
-  def test_handle_directive_nodoc
-    code_object = RDoc::CodeObject.new
-    code_object.document_self = true
-    code_object.document_children = true
-
-    @pp.handle_directive '', 'nodoc', nil, code_object
-
-    refute code_object.document_self
-    assert code_object.document_children
-  end
-
-  def test_handle_directive_nodoc_all
-    code_object = RDoc::CodeObject.new
-    code_object.document_self = true
-    code_object.document_children = true
-
-    @pp.handle_directive '', 'nodoc', 'all', code_object
-
-    refute code_object.document_self
-    refute code_object.document_children
-  end
-
-  def test_handle_directive_nodoc_no_context
-    result = @pp.handle_directive '', 'nodoc', nil
-
-    assert_equal "\n", result
-  end
-
-  def test_handle_directive_registered
-    RDoc::Markup::PreProcess.register 'x'
-
-    result = @pp.handle_directive '', 'x', 'y'
-
-    assert_nil result
-
-    result = @pp.handle_directive '', 'x', 'y' do |directive, param|
-      false
-    end
-
-    assert_equal ":x: y\n", result
-
-    result = @pp.handle_directive '', 'x', 'y' do |directive, param|
-      ''
-    end
-
-    assert_equal '', result
-  end
-
-  def test_handle_directive_registered_block
-    called = nil
-
-    RDoc::Markup::PreProcess.register 'x' do |directive, param|
-      called = [directive, param]
-      'blah'
-    end
-
-    result = @pp.handle_directive '', 'x', 'y'
-
-    assert_equal 'blah', result
-    assert_equal %w[x y], called
-  end
-
-  def test_handle_directive_registered_code_object
-    RDoc::Markup::PreProcess.register 'x'
-    code_object = RDoc::CodeObject.new
-
-    @pp.handle_directive '', 'x', 'y', code_object
-
-    assert_equal 'y', code_object.metadata['x']
-
-    code_object.metadata.clear
-
-    result = @pp.handle_directive '', 'x', 'y' do |directive, param|
-      false
-    end
-
-    assert_equal ":x: y\n", result
-    assert_empty code_object.metadata
-
-    result = @pp.handle_directive '', 'x', 'y' do |directive, param|
-      ''
-    end
-
-    assert_equal '', result
-    assert_empty code_object.metadata
-  end
-
-  def test_handle_directive_startdoc
-    code_object = RDoc::CodeObject.new
-    code_object.stop_doc
-    code_object.force_documentation = false
-
-    @pp.handle_directive '', 'startdoc', nil, code_object
-
-    assert code_object.document_self
-    assert code_object.document_children
-    assert code_object.force_documentation
-  end
-
-  def test_handle_directive_stopdoc
-    code_object = RDoc::CodeObject.new
-
-    @pp.handle_directive '', 'stopdoc', nil, code_object
-
-    refute code_object.document_self
-    refute code_object.document_children
-  end
-
-  def test_handle_directive_title
-    @pp.options = RDoc::Options.new
-
-    _, err = capture_output do
-      @pp.handle_directive '', 'title', 'T'
-    end
-
-    assert_include err, "The :title: directive is deprecated and will be removed in RDoc 7."
-    assert_equal 'T', @pp.options.title
-  end
-
-  def test_handle_directive_unhandled
-    code_object = RDoc::CodeObject.new
-
-    @pp.handle_directive '', 'x', 'y', code_object
-
-    assert_equal 'y', code_object.metadata['x']
-
-    code_object.metadata.clear
-
-    @pp.handle_directive '', 'x', '', code_object
-
-    assert_includes code_object.metadata, 'x'
-  end
-
-  def test_handle_directive_unhandled_block
-    code_object = RDoc::CodeObject.new
-
-    @pp.handle_directive '', 'x', 'y', code_object do
-      false
-    end
-
-    assert_empty code_object.metadata
-
-    @pp.handle_directive '', 'x', 'y', code_object do
-      nil
-    end
-
-    assert_equal 'y', code_object.metadata['x']
-
-    code_object.metadata.clear
-
-    @pp.handle_directive '', 'x', 'y', code_object do
-      ''
-    end
-
-    assert_empty code_object.metadata
-  end
-
-  def test_handle_directive_yield
-    method = RDoc::AnyMethod.new nil, 'm'
-    method.params = 'index, &block'
-
-    @pp.handle_directive '', 'yield', 'item', method
-
-    assert_equal 'item', method.block_params
-    assert_equal 'index', method.params
-  end
-
-  def test_handle_directive_yield_block_param
-    method = RDoc::AnyMethod.new nil, 'm'
-    method.params = '&block'
-
-    @pp.handle_directive '', 'yield', 'item', method
-
-    assert_equal 'item', method.block_params
-    assert_empty method.params
-  end
-
-  def test_handle_directive_yield_no_context
-    method = RDoc::AnyMethod.new nil, 'm'
-
-    @pp.handle_directive '', 'yield', 'item', method
-
-    assert_equal 'item', method.block_params
-  end
-
-  def test_handle_directive_yields
-    method = RDoc::AnyMethod.new nil, 'm'
-
-    @pp.handle_directive '', 'yields', 'item', method
-
-    assert_equal 'item', method.block_params
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc_markup_raw_test.rb b/test/mri/rdoc/rdoc_markup_raw_test.rb
deleted file mode 100644
index a1599ebb6c7..00000000000
--- a/test/mri/rdoc/rdoc_markup_raw_test.rb
+++ /dev/null
@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocMarkupRawTest < RDoc::TestCase
-
-  def setup
-    super
-
-    @p = @RM::Raw.new
-  end
-
-  def test_push
-    @p.push 'hi', 'there'
-
-    assert_equal @RM::Raw.new('hi', 'there'), @p
-  end
-
-  def test_pretty_print
-    assert_equal '[raw: ]', mu_pp(@p)
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc_markup_test.rb b/test/mri/rdoc/rdoc_markup_test.rb
deleted file mode 100644
index d9d3d25e227..00000000000
--- a/test/mri/rdoc/rdoc_markup_test.rb
+++ /dev/null
@@ -1,95 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocMarkupTest < RDoc::TestCase
-
-  def test_class_parse
-    expected = @RM::Document.new(
-      @RM::Paragraph.new('hello'))
-
-    assert_equal expected, RDoc::Markup.parse('hello')
-  end
-
-  def test_convert
-    str = <<-STR
-now is
-the time
-
-  hello
-  dave
-
-1. l1
-2. l2
-    STR
-
-    m = RDoc::Markup.new
-
-    tt = RDoc::Markup::ToTest.new m
-
-    out = m.convert str, tt
-
-    expected = [
-      "now is the time",
-      "\n",
-      "  hello\n  dave\n",
-      "1: ",
-      "l1",
-      "1: ",
-      "l2",
-    ]
-
-    assert_equal expected, out
-  end
-
-  def test_convert_custom_markup
-    str = <<-STR
-{stricken}
-    STR
-
-    m = RDoc::Markup.new
-    m.add_word_pair '{', '}', :STRIKE
-
-    tt = RDoc::Markup::ToTest.new nil, m
-    tt.add_tag :STRIKE, 'STRIKE ', ' STRIKE'
-
-    out = m.convert str, tt
-
-    expected = [
-      "STRIKE stricken STRIKE",
-    ]
-
-    assert_equal expected, out
-  end
-
-  def test_convert_document
-    doc = RDoc::Markup::Parser.parse <<-STR
-now is
-the time
-
-  hello
-  dave
-
-1. l1
-2. l2
-    STR
-
-    m = RDoc::Markup.new
-
-    tt = RDoc::Markup::ToTest.new m
-
-    out = m.convert doc, tt
-
-    expected = [
-      "now is the time",
-      "\n",
-      "  hello\n  dave\n",
-      "1: ",
-      "l1",
-      "1: ",
-      "l2",
-    ]
-
-    assert_equal expected, out
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc_markup_to_ansi_test.rb b/test/mri/rdoc/rdoc_markup_to_ansi_test.rb
deleted file mode 100644
index 020f5469973..00000000000
--- a/test/mri/rdoc/rdoc_markup_to_ansi_test.rb
+++ /dev/null
@@ -1,380 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocMarkupToAnsiTest < RDoc::Markup::TextFormatterTestCase
-
-  add_visitor_tests
-  add_text_tests
-
-  def setup
-    super
-
-    @to = RDoc::Markup::ToAnsi.new
-  end
-
-  def accept_blank_line
-    assert_equal "\e[0m\n", @to.res.join
-  end
-
-  def accept_block_quote
-    assert_equal "\e[0m> quote\n", @to.res.join
-  end
-
-  def accept_document
-    assert_equal "\e[0mhello\n", @to.res.join
-  end
-
-  def accept_heading
-    assert_equal "\e[0mHello\n", @to.res.join
-  end
-
-  def accept_list_end_bullet
-    assert_empty @to.list_index
-    assert_empty @to.list_type
-    assert_empty @to.list_width
-  end
-
-  def accept_list_end_label
-    assert_empty @to.list_index
-    assert_empty @to.list_type
-    assert_empty @to.list_width
-  end
-
-  def accept_list_end_lalpha
-    assert_empty @to.list_index
-    assert_empty @to.list_type
-    assert_empty @to.list_width
-  end
-
-  def accept_list_end_note
-    assert_empty @to.list_index
-    assert_empty @to.list_type
-    assert_empty @to.list_width
-  end
-
-  def accept_list_end_number
-    assert_empty @to.list_index
-    assert_empty @to.list_type
-    assert_empty @to.list_width
-  end
-
-  def accept_list_end_ualpha
-    assert_empty @to.list_index
-    assert_empty @to.list_type
-    assert_empty @to.list_width
-  end
-
-  def accept_list_item_end_bullet
-    assert_equal 0, @to.indent, 'indent'
-  end
-
-  def accept_list_item_end_label
-    assert_equal "\e[0mcat:\n", @to.res.join
-    assert_equal 0, @to.indent, 'indent'
-  end
-
-  def accept_list_item_end_lalpha
-    assert_equal 0, @to.indent, 'indent'
-    assert_equal 'b', @to.list_index.last
-  end
-
-  def accept_list_item_end_note
-    assert_equal "\e[0mcat:\n", @to.res.join
-    assert_equal 0, @to.indent, 'indent'
-  end
-
-  def accept_list_item_end_number
-    assert_equal 0, @to.indent, 'indent'
-    assert_equal 2, @to.list_index.last
-  end
-
-  def accept_list_item_end_ualpha
-    assert_equal 0, @to.indent, 'indent'
-    assert_equal 'B', @to.list_index.last
-  end
-
-  def accept_list_item_start_bullet
-    assert_equal %W"\e[0m", @to.res
-    assert_equal '* ', @to.prefix
-  end
-
-  def accept_list_item_start_label
-    assert_equal %W"\e[0m", @to.res
-    assert_equal "cat:\n  ", @to.prefix
-
-    assert_equal 2, @to.indent
-  end
-
-  def accept_list_item_start_lalpha
-    assert_equal %W"\e[0m", @to.res
-    assert_equal 'a. ', @to.prefix
-
-    assert_equal 'a', @to.list_index.last
-    assert_equal 3, @to.indent
-  end
-
-  def accept_list_item_start_note
-    assert_equal %W"\e[0m", @to.res
-    assert_equal "cat:\n  ", @to.prefix
-
-    assert_equal 2, @to.indent
-  end
-
-  def accept_list_item_start_number
-    assert_equal %W"\e[0m", @to.res
-    assert_equal '1. ', @to.prefix
-
-    assert_equal 1, @to.list_index.last
-    assert_equal 3, @to.indent
-  end
-
-  def accept_list_item_start_ualpha
-    assert_equal %W"\e[0m", @to.res
-    assert_equal 'A. ', @to.prefix
-
-    assert_equal 'A', @to.list_index.last
-    assert_equal 3, @to.indent
-  end
-
-  def accept_list_start_bullet
-    assert_equal "\e[0m",   @to.res.join
-    assert_equal [nil],     @to.list_index
-    assert_equal [:BULLET], @to.list_type
-    assert_equal [1],       @to.list_width
-  end
-
-  def accept_list_start_label
-    assert_equal "\e[0m",  @to.res.join
-    assert_equal [nil],    @to.list_index
-    assert_equal [:LABEL], @to.list_type
-    assert_equal [2],      @to.list_width
-  end
-
-  def accept_list_start_lalpha
-    assert_equal "\e[0m",   @to.res.join
-    assert_equal ['a'],     @to.list_index
-    assert_equal [:LALPHA], @to.list_type
-    assert_equal [1],       @to.list_width
-  end
-
-  def accept_list_start_note
-    assert_equal "\e[0m", @to.res.join
-    assert_equal [nil],   @to.list_index
-    assert_equal [:NOTE], @to.list_type
-    assert_equal [2],     @to.list_width
-  end
-
-  def accept_list_start_number
-    assert_equal "\e[0m",   @to.res.join
-    assert_equal [1],       @to.list_index
-    assert_equal [:NUMBER], @to.list_type
-    assert_equal [1],       @to.list_width
-  end
-
-  def accept_list_start_ualpha
-    assert_equal "\e[0m",   @to.res.join
-    assert_equal ['A'],     @to.list_index
-    assert_equal [:UALPHA], @to.list_type
-    assert_equal [1],       @to.list_width
-  end
-
-  def accept_paragraph
-    assert_equal "\e[0mhi\n", @to.res.join
-  end
-
-  def accept_raw
-    raw = <<-RAW.rstrip
-\e[0m<table>
-<tr><th>Name<th>Count
-<tr><td>a<td>1
-<tr><td>b<td>2
-</table>
-    RAW
-
-    assert_equal raw, @to.res.join
-  end
-
-  def accept_rule
-    assert_equal "\e[0m#{'-' * 78}\n", @to.res.join
-  end
-
-  def accept_verbatim
-    assert_equal "\e[0m  hi\n    world\n\n", @to.res.join
-  end
-
-  def end_accepting
-    assert_equal "\e[0mhi", @to.end_accepting
-  end
-
-  def start_accepting
-    assert_equal 0, @to.indent
-    assert_equal %W"\e[0m", @to.res
-    assert_empty @to.list_index
-    assert_empty @to.list_type
-    assert_empty @to.list_width
-  end
-
-  def accept_heading_1
-    assert_equal "\e[0m\e[1;32mHello\e[m\n", @to.end_accepting
-  end
-
-  def accept_heading_2
-    assert_equal "\e[0m\e[4;32mHello\e[m\n", @to.end_accepting
-  end
-
-  def accept_heading_3
-    assert_equal "\e[0m\e[32mHello\e[m\n", @to.end_accepting
-  end
-
-  def accept_heading_4
-    assert_equal "\e[0mHello\n", @to.end_accepting
-  end
-
-  def accept_heading_indent
-    assert_equal "\e[0m   \e[1;32mHello\e[m\n", @to.end_accepting
-  end
-
-  def accept_heading_b
-    assert_equal "\e[0m\e[1;32m\e[1mHello\e[m\e[m\n", @to.end_accepting
-  end
-
-  def accept_heading_suppressed_crossref
-    assert_equal "\e[0m\e[1;32mHello\e[m\n", @to.end_accepting
-  end
-
-  def accept_list_item_start_note_2
-    assert_equal "\e[0m\e[7mteletype\e[m:\n  teletype description\n\n",
-                 @to.res.join
-  end
-
-  def accept_list_item_start_note_multi_description
-    assert_equal "\e[0mlabel:\n  description one\n\n  description two\n\n",
-                 @to.res.join
-  end
-
-  def accept_list_item_start_note_multi_label
-    assert_equal "\e[0mone\ntwo:\n  two headers\n\n",
-                 @to.res.join
-  end
-
-  def accept_paragraph_b
-    assert_equal "\e[0mreg \e[1mbold words\e[m reg\n", @to.end_accepting
-  end
-
-  def accept_paragraph_br
-    assert_equal "\e[0mone\ntwo\n", @to.end_accepting
-  end
-
-  def accept_paragraph_break
-    assert_equal "\e[0mhello\nworld\n", @to.end_accepting
-  end
-
-  def accept_paragraph_i
-    assert_equal "\e[0mreg \e[4mitalic words\e[m reg\n", @to.end_accepting
-  end
-
-  def accept_paragraph_indent
-    expected = <<-EXPECTED
-\e[0m   words words words words words words words words words words words words
-   words words words words words words words words words words words words
-   words words words words words words
-    EXPECTED
-
-    assert_equal expected, @to.end_accepting
-  end
-
-  def accept_paragraph_plus
-    assert_equal "\e[0mreg \e[7mteletype\e[m reg\n", @to.end_accepting
-  end
-
-  def accept_paragraph_star
-    assert_equal "\e[0mreg \e[1mbold\e[m reg\n", @to.end_accepting
-  end
-
-  def accept_paragraph_underscore
-    assert_equal "\e[0mreg \e[4mitalic\e[m reg\n", @to.end_accepting
-  end
-
-  def accept_paragraph_wrap
-    expected = <<-EXPECTED
-\e[0mwords words words words words words words words words words words words words
-words words words words words words words words words words words words words
-words words words words
-    EXPECTED
-
-    assert_equal expected, @to.end_accepting
-  end
-
-  def accept_rule_indent
-    assert_equal "\e[0m   #{'-' * 75}\n", @to.end_accepting
-  end
-
-  def accept_verbatim_indent
-    assert_equal "\e[0m    hi\n     world\n\n", @to.end_accepting
-  end
-
-  def accept_verbatim_big_indent
-    assert_equal "\e[0m    hi\n    world\n\n", @to.end_accepting
-  end
-
-  def list_nested
-    expected = <<-EXPECTED
-\e[0m* l1
-  * l1.1
-* l2
-    EXPECTED
-
-    assert_equal expected, @to.end_accepting
-  end
-
-  def list_verbatim
-    expected = <<-EXPECTED # HACK overblown
-\e[0m* list stuff
-
-    * list
-      with
-
-      second
-
-      1. indented
-      2. numbered
-
-      third
-
-    * second
-
-    EXPECTED
-
-    assert_equal expected, @to.end_accepting
-  end
-
-  def accept_table_align
-    expected = "\e[0m" + <<-EXPECTED
- AA |BB |CCCCC|DDDDD
-----|---|-----|-----
-    |bbb|    c|
-aaaa|b  |     | dd
- a  |   |   cc| dd
-    EXPECTED
-    assert_equal expected, @to.end_accepting
-  end
-
-  # functional test
-  def test_convert_list_note
-    note_list = <<-NOTE_LIST
-foo ::
-bar ::
-  hi
-    NOTE_LIST
-
-    expected = <<-EXPECTED
-\e[0mfoo
-bar:
-  hi
-
-    EXPECTED
-
-    assert_equal expected, @to.convert(note_list)
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc_markup_to_bs_test.rb b/test/mri/rdoc/rdoc_markup_to_bs_test.rb
deleted file mode 100644
index d89d784422c..00000000000
--- a/test/mri/rdoc/rdoc_markup_to_bs_test.rb
+++ /dev/null
@@ -1,363 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocMarkupToBsTest < RDoc::Markup::TextFormatterTestCase
-
-  add_visitor_tests
-  add_text_tests
-
-  def setup
-    super
-
-    @to = RDoc::Markup::ToBs.new
-  end
-
-  def accept_blank_line
-    assert_equal "\n", @to.res.join
-  end
-
-  def accept_block_quote
-    assert_equal "> quote\n", @to.res.join
-  end
-
-  def accept_document
-    assert_equal "hello\n", @to.res.join
-  end
-
-  def accept_heading
-    assert_equal "===== H\bHe\bel\bll\blo\bo\n", @to.res.join
-  end
-
-  def accept_list_end_bullet
-    assert_empty @to.list_index
-    assert_empty @to.list_type
-    assert_empty @to.list_width
-  end
-
-  def accept_list_end_label
-    assert_empty @to.list_index
-    assert_empty @to.list_type
-    assert_empty @to.list_width
-  end
-
-  def accept_list_end_lalpha
-    assert_empty @to.list_index
-    assert_empty @to.list_type
-    assert_empty @to.list_width
-  end
-
-  def accept_list_end_note
-    assert_empty @to.list_index
-    assert_empty @to.list_type
-    assert_empty @to.list_width
-  end
-
-  def accept_list_end_number
-    assert_empty @to.list_index
-    assert_empty @to.list_type
-    assert_empty @to.list_width
-  end
-
-  def accept_list_end_ualpha
-    assert_empty @to.list_index
-    assert_empty @to.list_type
-    assert_empty @to.list_width
-  end
-
-  def accept_list_item_end_bullet
-    assert_equal 0, @to.indent, 'indent'
-  end
-
-  def accept_list_item_end_label
-    assert_equal "cat:\n", @to.res.join
-    assert_equal 0, @to.indent, 'indent'
-  end
-
-  def accept_list_item_end_lalpha
-    assert_equal 0, @to.indent, 'indent'
-    assert_equal 'b', @to.list_index.last
-  end
-
-  def accept_list_item_end_note
-    assert_equal "cat:\n", @to.res.join
-    assert_equal 0, @to.indent, 'indent'
-  end
-
-  def accept_list_item_end_number
-    assert_equal 0, @to.indent, 'indent'
-    assert_equal 2, @to.list_index.last
-  end
-
-  def accept_list_item_end_ualpha
-    assert_equal 0, @to.indent, 'indent'
-    assert_equal 'B', @to.list_index.last
-  end
-
-  def accept_list_item_start_bullet
-    assert_equal [''], @to.res
-    assert_equal '* ', @to.prefix
-  end
-
-  def accept_list_item_start_label
-    assert_equal [''], @to.res
-    assert_equal "cat:\n  ", @to.prefix
-
-    assert_equal 2, @to.indent
-  end
-
-  def accept_list_item_start_lalpha
-    assert_equal [''], @to.res
-    assert_equal 'a. ', @to.prefix
-
-    assert_equal 'a', @to.list_index.last
-    assert_equal 3, @to.indent
-  end
-
-  def accept_list_item_start_note
-    assert_equal [''], @to.res
-    assert_equal "cat:\n  ", @to.prefix
-
-    assert_equal 2, @to.indent
-  end
-
-  def accept_list_item_start_number
-    assert_equal [''], @to.res
-    assert_equal '1. ', @to.prefix
-
-    assert_equal 1, @to.list_index.last
-    assert_equal 3, @to.indent
-  end
-
-  def accept_list_item_start_ualpha
-    assert_equal [''], @to.res
-    assert_equal 'A. ', @to.prefix
-
-    assert_equal 'A', @to.list_index.last
-    assert_equal 3, @to.indent
-  end
-
-  def accept_list_start_bullet
-    assert_equal "",   @to.res.join
-    assert_equal [nil],     @to.list_index
-    assert_equal [:BULLET], @to.list_type
-    assert_equal [1],       @to.list_width
-  end
-
-  def accept_list_start_label
-    assert_equal "",  @to.res.join
-    assert_equal [nil],    @to.list_index
-    assert_equal [:LABEL], @to.list_type
-    assert_equal [2],      @to.list_width
-  end
-
-  def accept_list_start_lalpha
-    assert_equal "",   @to.res.join
-    assert_equal ['a'],     @to.list_index
-    assert_equal [:LALPHA], @to.list_type
-    assert_equal [1],       @to.list_width
-  end
-
-  def accept_list_start_note
-    assert_equal "", @to.res.join
-    assert_equal [nil],   @to.list_index
-    assert_equal [:NOTE], @to.list_type
-    assert_equal [2],     @to.list_width
-  end
-
-  def accept_list_start_number
-    assert_equal "",   @to.res.join
-    assert_equal [1],       @to.list_index
-    assert_equal [:NUMBER], @to.list_type
-    assert_equal [1],       @to.list_width
-  end
-
-  def accept_list_start_ualpha
-    assert_equal "",   @to.res.join
-    assert_equal ['A'],     @to.list_index
-    assert_equal [:UALPHA], @to.list_type
-    assert_equal [1],       @to.list_width
-  end
-
-  def accept_paragraph
-    assert_equal "hi\n", @to.res.join
-  end
-
-  def accept_raw
-    raw = <<-RAW.rstrip
-<table>
-<tr><th>Name<th>Count
-<tr><td>a<td>1
-<tr><td>b<td>2
-</table>
-    RAW
-
-    assert_equal raw, @to.res.join
-  end
-
-  def accept_rule
-    assert_equal "#{'-' * 78}\n", @to.res.join
-  end
-
-  def accept_verbatim
-    assert_equal "  hi\n    world\n\n", @to.res.join
-  end
-
-  def end_accepting
-    assert_equal "hi", @to.end_accepting
-  end
-
-  def start_accepting
-    assert_equal 0, @to.indent
-    assert_equal [''], @to.res
-    assert_empty @to.list_index
-    assert_empty @to.list_type
-    assert_empty @to.list_width
-  end
-
-  def accept_heading_1
-    assert_equal "= H\bHe\bel\bll\blo\bo\n", @to.end_accepting
-  end
-
-  def accept_heading_2
-    assert_equal "== H\bHe\bel\bll\blo\bo\n", @to.end_accepting
-  end
-
-  def accept_heading_3
-    assert_equal "=== H\bHe\bel\bll\blo\bo\n", @to.end_accepting
-  end
-
-  def accept_heading_4
-    assert_equal "==== H\bHe\bel\bll\blo\bo\n", @to.end_accepting
-  end
-
-  def accept_heading_indent
-    assert_equal "   = H\bHe\bel\bll\blo\bo\n", @to.end_accepting
-  end
-
-  def accept_heading_b
-    assert_equal "= H\bHe\bel\bll\blo\bo\n", @to.end_accepting
-  end
-
-  def accept_heading_suppressed_crossref
-    assert_equal "= H\bHe\bel\bll\blo\bo\n", @to.end_accepting
-  end
-
-  def accept_list_item_start_note_2
-    assert_equal "teletype:\n  teletype description\n\n", @to.res.join
-  end
-
-  def accept_list_item_start_note_multi_description
-    assert_equal "label:\n  description one\n\n  description two\n\n",
-                 @to.res.join
-  end
-
-  def accept_list_item_start_note_multi_label
-    assert_equal "one\ntwo:\n  two headers\n\n", @to.res.join
-  end
-
-  def accept_paragraph_b
-    assert_equal "reg b\bbo\bol\bld\bd \b w\bwo\bor\brd\bds\bs reg\n",
-                 @to.end_accepting
-  end
-
-  def accept_paragraph_br
-    assert_equal "one\ntwo\n", @to.end_accepting
-  end
-
-  def accept_paragraph_break
-    assert_equal "hello\nworld\n",
-                 @to.end_accepting
-  end
-
-  def accept_paragraph_i
-    assert_equal "reg _\bi_\bt_\ba_\bl_\bi_\bc_\b _\bw_\bo_\br_\bd_\bs reg\n",
-                 @to.end_accepting
-  end
-
-  def accept_paragraph_indent
-    expected = <<-EXPECTED
-   words words words words words words words words words words words words
-   words words words words words words words words words words words words
-   words words words words words words
-    EXPECTED
-
-    assert_equal expected, @to.end_accepting
-  end
-
-  def accept_paragraph_plus
-    assert_equal "reg teletype reg\n", @to.end_accepting
-  end
-
-  def accept_paragraph_star
-    assert_equal "reg b\bbo\bol\bld\bd reg\n", @to.end_accepting
-  end
-
-  def accept_paragraph_underscore
-    assert_equal "reg _\bi_\bt_\ba_\bl_\bi_\bc reg\n", @to.end_accepting
-  end
-
-  def accept_paragraph_wrap
-    expected = <<-EXPECTED
-words words words words words words words words words words words words words
-words words words words words words words words words words words words words
-words words words words
-    EXPECTED
-
-    assert_equal expected, @to.end_accepting
-  end
-
-  def accept_rule_indent
-    assert_equal "   #{'-' * 75}\n", @to.end_accepting
-  end
-
-  def accept_verbatim_indent
-    assert_equal "    hi\n     world\n\n", @to.end_accepting
-  end
-
-  def accept_verbatim_big_indent
-    assert_equal "    hi\n    world\n\n", @to.end_accepting
-  end
-
-  def list_nested
-    expected = <<-EXPECTED
-* l1
-  * l1.1
-* l2
-    EXPECTED
-
-    assert_equal expected, @to.end_accepting
-  end
-
-  def list_verbatim
-    expected = <<-EXPECTED # HACK overblown
-* list stuff
-
-    * list
-      with
-
-      second
-
-      1. indented
-      2. numbered
-
-      third
-
-    * second
-
-    EXPECTED
-
-    assert_equal expected, @to.end_accepting
-  end
-
-  def accept_table_align
-    expected = <<-EXPECTED
- AA |BB |CCCCC|DDDDD
-----|---|-----|-----
-    |bbb|    c|
-aaaa|b  |     | dd
- a  |   |   cc| dd
-    EXPECTED
-    assert_equal expected, @to.end_accepting
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc_markup_to_html_crossref_test.rb b/test/mri/rdoc/rdoc_markup_to_html_crossref_test.rb
deleted file mode 100644
index a52c7f1506d..00000000000
--- a/test/mri/rdoc/rdoc_markup_to_html_crossref_test.rb
+++ /dev/null
@@ -1,325 +0,0 @@
-# frozen_string_literal: true
-require_relative 'xref_test_case'
-
-class RDocMarkupToHtmlCrossrefTest < XrefTestCase
-
-  def setup
-    super
-
-    @options.hyperlink_all = true
-    @options.warn_missing_rdoc_ref = true
-
-    @to = RDoc::Markup::ToHtmlCrossref.new @options, 'index.html', @c1
-  end
-
-  def test_convert_CROSSREF
-    result = @to.convert 'C1'
-
-    assert_equal para("<a href=\"C1.html\"><code>C1</code></a>"), result
-
-    result = @to.convert '+C1+'
-    assert_equal para("<a href=\"C1.html\"><code>C1</code></a>"), result
-
-    result = @to.convert 'Constant[rdoc-ref:C1]'
-    assert_equal para("<a href=\"C1.html\">Constant</a>"), result
-
-    result = @to.convert 'FOO'
-    assert_equal para("FOO"), result
-
-    result = @to.convert '+FOO+'
-    assert_equal para("<code>FOO</code>"), result
-
-    result = @to.convert '<tt># :stopdoc:</tt>:'
-    assert_equal para("<code># :stopdoc:</code>:"), result
-  end
-
-  def test_convert_CROSSREF_ignored_excluded_words
-    @options.autolink_excluded_words = ['C1']
-
-    result = @to.convert 'C1'
-    assert_equal para("C1"), result
-
-    result = @to.convert '+C1+'
-    assert_equal para("<a href=\"C1.html\"><code>C1</code></a>"), result
-
-    # Explicit linking with rdoc-ref is not ignored
-    result = @to.convert 'Constant[rdoc-ref:C1]'
-    assert_equal para("<a href=\"C1.html\">Constant</a>"), result
-  end
-
-  def test_convert_CROSSREF_method
-    result = @to.convert 'C1#m(foo, bar, baz)'
-
-    assert_equal para("<a href=\"C1.html#method-i-m\"><code>C1#m(foo, bar, baz)</code></a>"), result
-  end
-
-  def test_convert_CROSSREF_label
-    result = @to.convert 'C1@foo'
-    assert_equal para("<a href=\"C1.html#class-C1-label-foo\">foo at <code>C1</code></a>"), result
-
-    result = @to.convert 'C1#m@foo'
-    assert_equal para("<a href=\"C1.html#method-i-m-label-foo\">foo at <code>C1#m</code></a>"),
-                 result
-  end
-
-  def test_convert_CROSSREF_label_for_md
-    result = @to.convert 'EXAMPLE@foo'
-    assert_equal para("<a href=\"EXAMPLE_md.html#label-foo\">foo at <code>EXAMPLE</code></a>"), result
-  end
-
-  def test_convert_CROSSREF_label_period
-    result = @to.convert 'C1@foo.'
-    assert_equal para("<a href=\"C1.html#class-C1-label-foo\">foo at <code>C1</code></a>."), result
-  end
-
-  def test_convert_CROSSREF_label_space
-    result = @to.convert 'C1@foo+bar'
-    assert_equal para("<a href=\"C1.html#class-C1-label-foo+bar\">foo bar at <code>C1</code></a>"),
-                 result
-  end
-
-  def test_convert_CROSSREF_section
-    @c1.add_section 'Section'
-
-    result = @to.convert 'C1@Section'
-    assert_equal para("<a href=\"C1.html#Section\">Section at <code>C1</code></a>"), result
-  end
-
-  def test_convert_CROSSREF_constant
-    result = @to.convert 'C1::CONST'
-
-    assert_equal para("<a href=\"C1.html#CONST\"><code>C1::CONST</code></a>"), result
-  end
-
-  def test_convert_RDOCLINK_rdoc_ref
-    result = @to.convert 'rdoc-ref:C1'
-
-    assert_equal para("<a href=\"C1.html\"><code>C1</code></a>"), result
-  end
-
-  def test_convert_RDOCLINK_rdoc_ref_not_found
-    result = nil
-    stdout, _ = capture_output do
-      result = @to.convert 'rdoc-ref:FOO'
-    end
-
-    assert_equal para("FOO"), result
-    assert_include stdout, "index.html: `rdoc-ref:FOO` can't be resolved for `FOO`"
-  end
-
-  def test_convert_RDOCLINK_rdoc_ref_method
-    result = @to.convert 'rdoc-ref:C1#m'
-
-    assert_equal para("<a href=\"C1.html#method-i-m\"><code>C1#m</code></a>"), result
-  end
-
-  def test_convert_RDOCLINK_rdoc_ref_method_label
-    result = @to.convert 'rdoc-ref:C1#m@foo'
-
-    assert_equal para("<a href=\"C1.html#method-i-m-label-foo\">foo at <code>C1#m</code></a>"),
-                 result, 'rdoc-ref:C1#m@foo'
-  end
-
-  def test_convert_RDOCLINK_rdoc_ref_method_percent
-    m = @c1.add_method RDoc::AnyMethod.new nil, '%'
-
-    result = @to.convert 'rdoc-ref:C1#%'
-
-    assert_equal para("<a href=\"C1.html#method-i-25\"><code>C1#%</code></a>"), result
-
-    m.singleton = true
-
-    result = @to.convert 'rdoc-ref:C1::%'
-
-    assert_equal para("<a href=\"C1.html#method-c-25\"><code>C1::%</code></a>"), result
-  end
-
-  def test_convert_RDOCLINK_rdoc_ref_method_escape_html
-    m = @c1.add_method RDoc::AnyMethod.new nil, '<<'
-
-    result = @to.convert 'rdoc-ref:C1#<<'
-
-    assert_equal para("<a href=\"C1.html#method-i-3C-3C\"><code>C1#<<</code></a>"), result
-    m.singleton = true
-
-    result = @to.convert 'rdoc-ref:C1::<<'
-
-    assert_equal para("<a href=\"C1.html#method-c-3C-3C\"><code>C1::<<</code></a>"), result
-  end
-
-  def test_convert_RDOCLINK_rdoc_ref_method_percent_label
-    m = @c1.add_method RDoc::AnyMethod.new nil, '%'
-
-    result = @to.convert 'rdoc-ref:C1#%@f'
-
-    assert_equal para("<a href=\"C1.html#method-i-25-label-f\">f at <code>C1#%</code></a>"),
-                 result
-
-    m.singleton = true
-
-    result = @to.convert 'rdoc-ref:C1::%@f'
-
-    assert_equal para("<a href=\"C1.html#method-c-25-label-f\">f at <code>C1::%</code></a>"),
-                 result
-  end
-
-  def test_convert_RDOCLINK_rdoc_ref_label
-    result = @to.convert 'rdoc-ref:C1@foo'
-
-    assert_equal para("<a href=\"C1.html#class-C1-label-foo\">foo at <code>C1</code></a>"), result,
-                 'rdoc-ref:C1@foo'
-  end
-
-  def test_convert_RDOCLINK_rdoc_ref_label_in_current_file
-    result = @to.convert 'rdoc-ref:@foo'
-
-    assert_equal para("<a href=\"#label-foo\">foo</a>"), result,
-                 'rdoc-ref:@foo'
-
-    result = @to.convert '{Foo}[rdoc-ref:@foo]'
-
-    assert_equal para("<a href=\"#label-foo\">Foo</a>"), result,
-                 '{Foo}[rdoc-ref:@foo]'
-  end
-
-  def test_gen_url
-    assert_equal '<a href="C1.html">Some class</a>',
-                 @to.gen_url('rdoc-ref:C1', 'Some class')
-
-    assert_equal '<a href="http://example">HTTP example</a>',
-                 @to.gen_url('http://example', 'HTTP example')
-  end
-
-  def test_gen_url_rdoc_ref_not_found
-    stdout, _ = capture_output do
-      @to.gen_url 'rdoc-ref:FOO', 'FOO'
-    end
-
-    assert_include stdout, "index.html: `rdoc-ref:FOO` can't be resolved for `FOO`"
-  end
-
-  def test_handle_regexp_CROSSREF
-    assert_equal "<a href=\"C2/C3.html\"><code>C2::C3</code></a>", REGEXP_HANDLING('C2::C3')
-  end
-
-  def test_handle_regexp_CROSSREF_label
-    assert_equal "<a href=\"C1.html#method-i-m-label-foo\">foo at <code>C1#m</code></a>",
-                 REGEXP_HANDLING('C1#m@foo')
-  end
-
-  def test_handle_regexp_CROSSREF_show_hash_false
-    @to.show_hash = false
-
-    assert_equal "<a href=\"C1.html#method-i-m\"><code>m</code></a>",
-                 REGEXP_HANDLING('#m')
-  end
-
-  def test_handle_regexp_CROSSREF_with_arg_looks_like_TIDYLINK
-    result = @to.convert 'C1.m[:sym]'
-
-    assert_equal para("<a href=\"C1.html#method-c-m\"><code>C1.m[:sym]</code></a>"), result,
-                 'C1.m[:sym]'
-  end
-
-  def test_handle_regexp_HYPERLINK_rdoc
-    readme = @store.add_file 'README.txt'
-    readme.parser = RDoc::Parser::Simple
-
-    @to = RDoc::Markup::ToHtmlCrossref.new @options, 'C2.html', @c2
-
-    link = @to.handle_regexp_HYPERLINK hyper 'C2::C3'
-
-    assert_equal '<a href="C2/C3.html"><code>C2::C3</code></a>', link
-
-    link = @to.handle_regexp_HYPERLINK hyper 'C4'
-
-    assert_equal '<a href="C4.html"><code>C4</code></a>', link
-
-    link = @to.handle_regexp_HYPERLINK hyper 'README.txt'
-
-    assert_equal '<a href="README_txt.html">README.txt</a>', link
-  end
-
-  def test_handle_regexp_TIDYLINK_rdoc
-    readme = @store.add_file 'README.txt'
-    readme.parser = RDoc::Parser::Simple
-
-    @to = RDoc::Markup::ToHtmlCrossref.new @options, 'C2.html', @c2
-
-    link = @to.handle_regexp_TIDYLINK tidy 'C2::C3'
-
-    assert_equal '<a href="C2/C3.html">tidy</a>', link
-
-    link = @to.handle_regexp_TIDYLINK tidy 'C4'
-
-    assert_equal '<a href="C4.html">tidy</a>', link
-
-    link = @to.handle_regexp_TIDYLINK tidy 'C1#m'
-
-    assert_equal '<a href="C1.html#method-i-m">tidy</a>', link
-
-    link = @to.handle_regexp_TIDYLINK tidy 'README.txt'
-
-    assert_equal '<a href="README_txt.html">tidy</a>', link
-  end
-
-  def test_handle_regexp_TIDYLINK_label
-    link = @to.handle_regexp_TIDYLINK tidy 'C1#m@foo'
-
-    assert_equal "<a href=\"C1.html#method-i-m-label-foo\">tidy</a>",
-                 link, 'C1#m@foo'
-  end
-
-  def test_to_html_CROSSREF_email
-    @options.hyperlink_all = false
-
-    @to = RDoc::Markup::ToHtmlCrossref.new @options, 'index.html', @c1
-
-    result = @to.to_html 'first.last@example.com'
-
-    assert_equal 'first.last@example.com', result
-  end
-
-  def test_to_html_CROSSREF_email_hyperlink_all
-    result = @to.to_html 'first.last@example.com'
-
-    assert_equal 'first.last@example.com', result
-  end
-
-  def test_link
-    assert_equal 'n', @to.link('n', 'n')
-
-    assert_equal '<a href="C1.html#method-c-m"><code>m</code></a>', @to.link('m', 'm')
-  end
-
-  def test_link_for_method_traverse
-    @to = RDoc::Markup::ToHtmlCrossref.new @options, 'C2.html', @c9
-    assert_equal '<a href="C9/A.html#method-i-foo"><code>C9::B#foo</code></a>', @to.link('C9::B#foo', 'C9::B#foo')
-  end
-
-  def test_link_class_method_full
-    assert_equal '<a href="Parent.html#method-c-m"><code>Parent::m</code></a>',
-                 @to.link('Parent::m', 'Parent::m')
-  end
-
-  def para(text)
-    "\n<p>#{text}</p>\n"
-  end
-
-  def REGEXP_HANDLING(text)
-    @to.handle_regexp_CROSSREF regexp_handling text
-  end
-
-  def hyper(reference)
-    RDoc::Markup::RegexpHandling.new 0, "rdoc-ref:#{reference}"
-  end
-
-  def regexp_handling(text)
-    RDoc::Markup::RegexpHandling.new 0, text
-  end
-
-  def tidy(reference)
-    RDoc::Markup::RegexpHandling.new 0, "{tidy}[rdoc-ref:#{reference}]"
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc_markup_to_html_snippet_test.rb b/test/mri/rdoc/rdoc_markup_to_html_snippet_test.rb
deleted file mode 100644
index 4a338271afe..00000000000
--- a/test/mri/rdoc/rdoc_markup_to_html_snippet_test.rb
+++ /dev/null
@@ -1,709 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocMarkupToHtmlSnippetTest < RDoc::Markup::FormatterTestCase
-
-  add_visitor_tests
-
-  def setup
-    super
-
-    @to = RDoc::Markup::ToHtmlSnippet.new @options, 100, 100
-    @ellipsis = @to.to_html '...'
-  end
-
-  def accept_blank_line
-    assert_empty @to.res.join
-  end
-
-  def accept_block_quote
-    assert_equal "\n<blockquote><p>quote\n</blockquote>\n", @to.res.join
-
-    assert_equal 5, @to.characters
-  end
-
-  def accept_document
-    assert_equal "<p>hello\n", @to.res.join
-    assert_equal 5, @to.characters
-  end
-
-  def accept_heading
-    assert_equal "<p>Hello\n", @to.res.join
-    assert_equal 5, @to.characters
-  end
-
-  def accept_heading_1
-    assert_equal "<p>Hello\n", @to.res.join
-    assert_equal 5, @to.characters
-  end
-
-  def accept_heading_2
-    assert_equal "<p>Hello\n", @to.res.join
-    assert_equal 5, @to.characters
-  end
-
-  def accept_heading_3
-    assert_equal "<p>Hello\n", @to.res.join
-    assert_equal 5, @to.characters
-  end
-
-  def accept_heading_4
-    assert_equal "<p>Hello\n", @to.res.join
-    assert_equal 5, @to.characters
-  end
-
-  def accept_heading_b
-    assert_equal "<p><strong>Hello</strong>\n",
-                 @to.res.join
-    assert_equal 5, @to.characters
-  end
-
-  def accept_heading_suppressed_crossref
-    assert_equal "<p>Hello\n", @to.res.join
-    assert_equal 5, @to.characters
-  end
-
-  def accept_list_end_bullet
-    assert_equal [], @to.list
-    assert_equal [], @to.in_list_entry
-
-    assert_equal "\n", @to.res.join
-    assert_equal 0, @to.characters
-  end
-
-  def accept_list_end_label
-    assert_equal [], @to.list
-    assert_equal [], @to.in_list_entry
-
-    assert_equal "\n", @to.res.join
-    assert_equal 0, @to.characters
-  end
-
-  def accept_list_end_lalpha
-    assert_equal [], @to.list
-    assert_equal [], @to.in_list_entry
-
-    assert_equal "\n", @to.res.join
-    assert_equal 0, @to.characters
-  end
-
-  def accept_list_end_number
-    assert_equal [], @to.list
-    assert_equal [], @to.in_list_entry
-
-    assert_equal "\n", @to.res.join
-    assert_equal 0, @to.characters
-  end
-
-  def accept_list_end_note
-    assert_equal [], @to.list
-    assert_equal [], @to.in_list_entry
-
-    assert_equal "\n", @to.res.join
-    assert_equal 0, @to.characters
-  end
-
-  def accept_list_end_ualpha
-    assert_equal [], @to.list
-    assert_equal [], @to.in_list_entry
-
-    assert_equal "\n", @to.res.join
-    assert_equal 0, @to.characters
-  end
-
-  def accept_list_item_end_bullet
-    assert_equal [''], @to.in_list_entry
-    assert_equal 0, @to.characters
-  end
-
-  def accept_list_item_end_label
-    assert_equal [''], @to.in_list_entry
-    assert_equal 4, @to.characters
-  end
-
-  def accept_list_item_end_lalpha
-    assert_equal [''], @to.in_list_entry
-    assert_equal 0, @to.characters
-  end
-
-  def accept_list_item_end_note
-    assert_equal [''], @to.in_list_entry
-    assert_equal 4, @to.characters
-  end
-
-  def accept_list_item_end_number
-    assert_equal [''], @to.in_list_entry
-    assert_equal 0, @to.characters
-  end
-
-  def accept_list_item_end_ualpha
-    assert_equal [''], @to.in_list_entry
-    assert_equal 0, @to.characters
-  end
-
-  def accept_list_item_start_bullet
-    assert_equal "<p>", @to.res.join
-    assert_equal 0, @to.characters
-  end
-
-  def accept_list_item_start_label
-    assert_equal "<p>cat — ", @to.res.join
-    assert_equal 4, @to.characters
-  end
-
-  def accept_list_item_start_lalpha
-    assert_equal "<p>", @to.res.join
-    assert_equal 0, @to.characters
-  end
-
-  def accept_list_item_start_note
-    assert_equal "<p>cat — ",
-                 @to.res.join
-    assert_equal 4, @to.characters
-  end
-
-  def accept_list_item_start_note_2
-    expected = <<-EXPECTED
-<p><code>teletype</code> — teletype description
-
-    EXPECTED
-
-    assert_equal expected, @to.res.join
-    assert_equal 29, @to.characters
-  end
-
-  def accept_list_item_start_note_multi_description
-    expected = <<-EXPECTED
-<p>label — description one
-<p>description two
-
-    EXPECTED
-
-    assert_equal expected, @to.res.join
-    assert_equal 37, @to.characters
-  end
-
-  def accept_list_item_start_note_multi_label
-    expected = <<-EXPECTED
-<p>one, two — two headers
-
-    EXPECTED
-
-    assert_equal expected, @to.res.join
-    assert_equal 18, @to.characters
-  end
-
-  def accept_list_item_start_number
-    assert_equal "<p>", @to.res.join
-    assert_equal 0, @to.characters
-  end
-
-  def accept_list_item_start_ualpha
-    assert_equal "<p>", @to.res.join
-    assert_equal 0, @to.characters
-  end
-
-  def accept_list_start_bullet
-    assert_equal [:BULLET], @to.list
-    assert_equal [''], @to.in_list_entry
-
-    assert_equal '', @to.res.join
-    assert_equal 0, @to.characters
-  end
-
-  def accept_list_start_label
-    assert_equal [:LABEL], @to.list
-    assert_equal [''], @to.in_list_entry
-
-    assert_equal '', @to.res.join
-    assert_equal 0, @to.characters
-  end
-
-  def accept_list_start_lalpha
-    assert_equal [:LALPHA], @to.list
-    assert_equal [''], @to.in_list_entry
-
-    assert_equal '', @to.res.join
-    assert_equal 0, @to.characters
-  end
-
-  def accept_list_start_note
-    assert_equal [:NOTE], @to.list
-    assert_equal [''], @to.in_list_entry
-
-    assert_equal '', @to.res.join
-    assert_equal 0, @to.characters
-  end
-
-  def accept_list_start_number
-    assert_equal [:NUMBER], @to.list
-    assert_equal [''], @to.in_list_entry
-
-    assert_equal '', @to.res.join
-    assert_equal 0, @to.characters
-  end
-
-  def accept_list_start_ualpha
-    assert_equal [:UALPHA], @to.list
-    assert_equal [''], @to.in_list_entry
-
-    assert_equal '', @to.res.join
-    assert_equal 0, @to.characters
-  end
-
-  def accept_paragraph
-    assert_equal "<p>hi\n", @to.res.join
-
-    assert_equal 2, @to.characters
-  end
-
-  def accept_paragraph_b
-    assert_equal "<p>reg <strong>bold words</strong> reg\n", @to.res.join
-
-    assert_equal 18, @to.characters
-  end
-
-  def accept_paragraph_br
-    assert_equal "<p>one<br>two\n", @to.res.join
-
-    assert_equal 6, @to.characters
-  end
-
-  def accept_paragraph_break
-    assert_equal "<p>hello<br>\nworld\n", @to.res.join
-
-    assert_equal 11, @to.characters
-  end
-
-  def accept_paragraph_i
-    assert_equal "<p>reg <em>italic words</em> reg\n", @to.res.join
-
-    assert_equal 20, @to.characters
-  end
-
-  def accept_paragraph_plus
-    assert_equal "<p>reg <code>teletype</code> reg\n", @to.res.join
-
-    assert_equal 16, @to.characters
-  end
-
-  def accept_paragraph_star
-    assert_equal "<p>reg <strong>bold</strong> reg\n", @to.res.join
-
-    assert_equal 12, @to.characters
-  end
-
-  def accept_paragraph_underscore
-    assert_equal "<p>reg <em>italic</em> reg\n", @to.res.join
-
-    assert_equal 14, @to.characters
-  end
-
-  def accept_raw
-    assert_equal '', @to.res.join
-    assert_equal 0, @to.characters
-  end
-
-  def accept_rule
-    assert_empty @to.res
-    assert_equal 0, @to.characters
-  end
-
-  def accept_verbatim
-    assert_equal "\n<pre class=\"ruby\"><span class=\"ruby-identifier\">hi</span>\n  <span class=\"ruby-identifier\">world</span>\n</pre>\n", @to.res.join
-    assert_equal 10, @to.characters
-  end
-
-  def end_accepting
-    assert_equal 'hi', @to.res.join
-  end
-
-  def start_accepting
-    assert_equal [], @to.res
-    assert_equal [], @to.in_list_entry
-    assert_equal [], @to.list
-    assert_equal 0,  @to.characters
-  end
-
-  def list_nested
-    expected = <<-EXPECTED
-<p>l1
-<p>l1.1
-
-<p>l2
-
-    EXPECTED
-
-    assert_equal expected, @to.res.join
-    assert_equal 8, @to.characters
-  end
-
-  def list_verbatim
-    expected = <<-EXPECTED
-<p>list stuff
-
-<pre>* list
-  with
-
-  second
-
-  1. indented
-  2. numbered
-
-  third
-
-* second</pre>
-
-    EXPECTED
-
-    assert_equal expected, @to.end_accepting
-    assert_equal 81, @to.characters
-  end
-
-  def test_accept_heading_7
-    @to.start_accepting
-
-    @to.accept_heading @RM::Heading.new(7, 'Hello')
-
-    assert_equal "<p>Hello\n", @to.res.join
-    assert_equal 5, @to.characters
-  end
-
-  def test_accept_heading_aref_class
-    @to.code_object = RDoc::NormalClass.new 'Foo'
-    @to.start_accepting
-
-    @to.accept_heading @RM::Heading.new(1, 'Hello')
-
-    assert_equal "<p>Hello\n",
-                 @to.res.join
-    assert_equal 5, @to.characters
-  end
-
-  def test_accept_heading_aref_method
-    @to.code_object = RDoc::AnyMethod.new nil, 'foo'
-    @to.start_accepting
-
-    @to.accept_heading @RM::Heading.new(1, 'Hello')
-
-    assert_equal "<p>Hello\n",
-                 @to.res.join
-    assert_equal 5, @to.characters
-  end
-
-  def test_accept_verbatim_ruby
-    options = RDoc::Options.new
-    rdoc = RDoc::RDoc.new
-    rdoc.options = options
-    RDoc::RDoc.current = rdoc
-
-    verb = @RM::Verbatim.new("class C\n", "end\n")
-
-    @to.start_accepting
-    @to.accept_verbatim verb
-
-    expected = <<-EXPECTED
-
-<pre class="ruby"><span class="ruby-keyword">class</span> <span class="ruby-constant">C</span>
-<span class="ruby-keyword">end</span>
-</pre>
-    EXPECTED
-
-    assert_equal expected, @to.res.join
-    assert_equal 11, @to.characters
-  end
-
-  def test_accept_verbatim_ruby_error
-    options = RDoc::Options.new
-    rdoc = RDoc::RDoc.new
-    rdoc.options = options
-    RDoc::RDoc.current = rdoc
-
-    verb = @RM::Verbatim.new("a % 09 # => blah\n")
-
-    @to.start_accepting
-    @to.accept_verbatim verb
-
-    inner = CGI.escapeHTML "a % 09 # => blah"
-
-    expected = <<-EXPECTED
-
-<pre>#{inner}</pre>
-    EXPECTED
-
-    assert_equal expected, @to.res.join
-    assert_equal 16, @to.characters
-  end
-
-  def test_add_paragraph
-    @to = RDoc::Markup::ToHtmlSnippet.new @options, 0, 3
-    assert_throws :done do
-      @to.add_paragraph
-      @to.add_paragraph
-      @to.add_paragraph
-    end
-
-    assert_equal 3, @to.paragraphs
-  end
-
-  def test_convert_limit
-    rdoc = <<-RDOC
-= Hello
-
-This is some text, it *will* be cut off after 100 characters and an ellipsis
-must follow
-
-So there you have it
-    RDOC
-
-    expected = <<-EXPECTED
-<p>Hello
-<p>This is some text, it <strong>will</strong> be cut off after 100 characters and an ellipsis must follow
-<p>So there you #{@ellipsis}
-    EXPECTED
-
-    actual = @to.convert rdoc
-
-    assert_equal expected, actual
-    assert_equal 111, @to.characters, 'snippet character length'
-  end
-
-  def test_convert_limit_2
-    rdoc = <<-RDOC
-Outputs formatted RI data for the class or method +name+.
-
-Returns true if +name+ was found, false if it was not an alternative could
-be guessed, raises an error if +name+ couldn't be guessed.
-    RDOC
-
-    expected = <<-EXPECTED
-<p>Outputs formatted RI data for the class or method <code>name</code>.
-<p>Returns true if <code>name</code> was found, false if it was #{@ellipsis}
-    EXPECTED
-
-    actual = @to.convert rdoc
-
-    assert_equal expected, actual
-    assert_equal 159, @to.characters, 'snippet character length'
-  end
-
-  def test_convert_limit_paragraphs
-    @to = RDoc::Markup::ToHtmlSnippet.new @options, 100, 3
-
-    rdoc = <<-RDOC
-= \RDoc - Ruby Documentation System
-
-* {RDoc Project Page}[https://github.com/ruby/rdoc]
-* {RDoc Documentation}[https://ruby.github.io/rdoc]
-* {RDoc Bug Tracker}[https://github.com/ruby/rdoc/issues]
-
-== DESCRIPTION:
-
-RDoc produces HTML and command-line documentation for Ruby projects.  RDoc
-includes the +rdoc+ and +ri+ tools for generating and displaying online
-documentation.
-
-See RDoc for a description of RDoc's markup and basic use.
-    RDOC
-
-    expected = <<-EXPECTED
-<p>RDoc - Ruby Documentation System
-<p>RDoc Project Page
-<p>RDoc Documentation
-    EXPECTED
-
-    actual = @to.convert rdoc
-
-    assert_equal expected, actual
-    assert_equal 67, @to.characters
-  end
-
-  def test_convert_limit_in_tag
-    @to = RDoc::Markup::ToHtmlSnippet.new @options, 4
-    rdoc = "* ab *c* d\n"
-
-    expected = "<p>ab <strong>c</strong> #{@ellipsis}\n\n"
-
-    actual = @to.convert rdoc
-
-    assert_equal 4, @to.characters
-    assert_equal expected, actual
-  end
-
-  def test_convert_limit_verbatim
-    rdoc = <<-RDOC
-= Hello There
-
-This is some text, it *will* be cut off after 100 characters
-
-  This one is cut off in this verbatim section
-    RDOC
-
-    expected = <<-EXPECTED
-<p>Hello There
-<p>This is some text, it <strong>will</strong> be cut off after 100 characters
-
-<pre>This one is cut off in this verbatim ...</pre>
-    EXPECTED
-
-    actual = @to.convert rdoc
-
-    assert_equal expected, actual
-    assert_equal 113, @to.characters
-  end
-
-  def test_convert_limit_verbatim_2
-    rdoc = <<-RDOC
-Extracts the class, selector and method name parts from +name+ like
-Foo::Bar#baz.
-
-NOTE: Given Foo::Bar, Bar is considered a class even though it may be a
-      method
-    RDOC
-
-    expected = <<-EXPECTED
-<p>Extracts the class, selector and method name parts from <code>name</code> like Foo::Bar#baz.
-<p>NOTE: Given Foo::Bar, #{@ellipsis}
-    EXPECTED
-
-    actual = @to.convert rdoc
-
-    assert_equal expected, actual
-    assert_equal 101, @to.characters
-  end
-
-  def test_convert_limit_verbatim_multiline
-    rdoc = <<-RDOC
-Look for directives in a normal comment block:
-
-  # :stopdoc:
-  # Don't display comment from this point forward
-
-This routine modifies its +comment+ parameter.
-    RDOC
-
-    inner = CGI.escapeHTML "# Don't display comment from this point forward"
-    expected = <<-EXPECTED
-<p>Look for directives in a normal comment block:
-
-<pre class=\"ruby\"><span class=\"ruby-comment\"># :stopdoc:</span>
-<span class=\"ruby-comment\">#{inner}</span>
-</pre>
-    EXPECTED
-
-    actual = @to.convert rdoc
-
-    assert_equal expected, actual
-    assert_equal 105, @to.characters
-  end
-
-  def test_convert_limit_over
-    @to = RDoc::Markup::ToHtmlSnippet.new @options, 4
-    rdoc = "* text\n" * 2
-
-    expected = "<p>text\n"
-    expected = expected.chomp
-    expected << " #{@ellipsis}\n"
-
-    actual = @to.convert rdoc
-
-    assert_equal 4, @to.characters
-    assert_equal expected, actual
-  end
-
-  def test_convert_string
-    assert_equal '<>', @to.convert_string('<>')
-  end
-
-  def test_convert_RDOCLINK_label_label
-    result = @to.convert 'rdoc-label:label-One'
-
-    assert_equal "<p>One\n", result
-    assert_equal 3, @to.characters
-  end
-
-  def test_convert_RDOCLINK_label_foottext
-    result = @to.convert 'rdoc-label:foottext-1'
-
-    assert_equal "<p>1\n", result
-    assert_equal 1, @to.characters
-  end
-
-  def test_convert_RDOCLINK_label_footmark
-    result = @to.convert 'rdoc-label:footmark-1'
-
-    assert_equal "<p>1\n", result
-    assert_equal 1, @to.characters
-  end
-
-  def test_convert_RDOCLINK_ref
-    result = @to.convert 'rdoc-ref:C'
-
-    assert_equal "<p>C\n", result
-    assert_equal 1, @to.characters
-  end
-
-  def test_convert_TIDYLINK_rdoc_label
-    result = @to.convert '{foo}[rdoc-label:foottext-1]'
-
-    assert_equal "<p>foo\n", result
-    assert_equal 3, @to.characters
-  end
-
-  def test_handle_regexp_HYPERLINK_link
-    target = RDoc::Markup::RegexpHandling.new 0, 'link:README.txt'
-
-    link = @to.handle_regexp_HYPERLINK target
-
-    assert_equal 'README.txt', link
-  end
-
-  def test_list_verbatim_2
-    str = "* one\n    verb1\n    verb2\n* two\n"
-
-    expected = <<-EXPECTED
-<p>one
-
-<pre class=\"ruby\"><span class=\"ruby-identifier\">verb1</span>
-<span class=\"ruby-identifier\">verb2</span>
-</pre>
-<p>two
-
-    EXPECTED
-
-    assert_equal expected, @m.convert(str, @to)
-    assert_equal 17, @to.characters
-  end
-
-  def test_on_tags
-    on = RDoc::Markup::AttrChanger.new 2, 0
-
-    @to.on_tags [], on
-
-    assert_equal 2, @to.mask
-  end
-
-  def test_off_tags
-    on  = RDoc::Markup::AttrChanger.new 2, 0
-    off = RDoc::Markup::AttrChanger.new 0, 2
-
-    @to.on_tags  [], on
-    @to.off_tags [], off
-
-    assert_equal 0, @to.mask
-  end
-
-  def test_to_html
-    assert_equal "<p><code>--</code>\n", util_format("<tt>--</tt>")
-    assert_equal 2, @to.characters
-  end
-
-  def util_format(text)
-    paragraph = RDoc::Markup::Paragraph.new text
-
-    @to.start_accepting
-    @to.accept_paragraph paragraph
-    @to.end_accepting
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc_markup_to_html_test.rb b/test/mri/rdoc/rdoc_markup_to_html_test.rb
deleted file mode 100644
index e586e03cb9a..00000000000
--- a/test/mri/rdoc/rdoc_markup_to_html_test.rb
+++ /dev/null
@@ -1,1024 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocMarkupToHtmlTest < RDoc::Markup::FormatterTestCase
-
-  add_visitor_tests
-
-  def setup
-    super
-
-    @to = RDoc::Markup::ToHtml.new @options
-  end
-
-  def accept_blank_line
-    assert_empty @to.res.join
-  end
-
-  def accept_block_quote
-    assert_equal "\n<blockquote>\n<p>quote</p>\n</blockquote>\n", @to.res.join
-  end
-
-  def accept_document
-    assert_equal "\n<p>hello</p>\n", @to.res.join
-  end
-
-  def accept_heading
-    links = '<span><a href="#label-Hello">¶</a> ' +
-            '<a href="#top">↑</a></span>'
-    expected = "\n<h5 id=\"label-Hello\">Hello#{links}</h5>\n"
-
-    assert_equal expected, @to.res.join
-  end
-
-  def accept_heading_1
-    links = '<span><a href="#label-Hello">¶</a> ' +
-            '<a href="#top">↑</a></span>'
-
-    assert_equal "\n<h1 id=\"label-Hello\">Hello#{links}</h1>\n", @to.res.join
-  end
-
-  def accept_heading_2
-    links = '<span><a href="#label-Hello">¶</a> ' +
-            '<a href="#top">↑</a></span>'
-
-    assert_equal "\n<h2 id=\"label-Hello\">Hello#{links}</h2>\n", @to.res.join
-  end
-
-  def accept_heading_3
-    links = '<span><a href="#label-Hello">¶</a> ' +
-            '<a href="#top">↑</a></span>'
-
-    assert_equal "\n<h3 id=\"label-Hello\">Hello#{links}</h3>\n", @to.res.join
-  end
-
-  def accept_heading_4
-    links = '<span><a href="#label-Hello">¶</a> ' +
-            '<a href="#top">↑</a></span>'
-
-    assert_equal "\n<h4 id=\"label-Hello\">Hello#{links}</h4>\n", @to.res.join
-  end
-
-  def accept_heading_b
-    links = '<span><a href="#label-Hello">¶</a> ' +
-            '<a href="#top">↑</a></span>'
-    inner = "<strong>Hello</strong>"
-
-    assert_equal "\n<h1 id=\"label-Hello\">#{inner}#{links}</h1>\n",
-                 @to.res.join
-  end
-
-  def accept_heading_suppressed_crossref
-    links = '<span><a href="#label-Hello">¶</a> ' +
-            '<a href="#top">↑</a></span>'
-
-    assert_equal "\n<h1 id=\"label-Hello\">Hello#{links}</h1>\n", @to.res.join
-  end
-
-  def accept_list_end_bullet
-    assert_equal [], @to.list
-    assert_equal [], @to.in_list_entry
-
-    assert_equal "<ul></ul>\n", @to.res.join
-  end
-
-  def accept_list_end_label
-    assert_equal [], @to.list
-    assert_equal [], @to.in_list_entry
-
-    assert_equal "<dl class=\"rdoc-list label-list\"></dl>\n", @to.res.join
-  end
-
-  def accept_list_end_lalpha
-    assert_equal [], @to.list
-    assert_equal [], @to.in_list_entry
-
-    assert_equal "<ol style=\"list-style-type: lower-alpha\"></ol>\n", @to.res.join
-  end
-
-  def accept_list_end_number
-    assert_equal [], @to.list
-    assert_equal [], @to.in_list_entry
-
-    assert_equal "<ol></ol>\n", @to.res.join
-  end
-
-  def accept_list_end_note
-    assert_equal [], @to.list
-    assert_equal [], @to.in_list_entry
-
-    assert_equal "<dl class=\"rdoc-list note-list\"></dl>\n", @to.res.join
-  end
-
-  def accept_list_end_ualpha
-    assert_equal [], @to.list
-    assert_equal [], @to.in_list_entry
-
-    assert_equal "<ol style=\"list-style-type: upper-alpha\"></ol>\n", @to.res.join
-  end
-
-  def accept_list_item_end_bullet
-    assert_equal %w[</li>], @to.in_list_entry
-  end
-
-  def accept_list_item_end_label
-    assert_equal %w[</dd>], @to.in_list_entry
-  end
-
-  def accept_list_item_end_lalpha
-    assert_equal %w[</li>], @to.in_list_entry
-  end
-
-  def accept_list_item_end_note
-    assert_equal %w[</dd>], @to.in_list_entry
-  end
-
-  def accept_list_item_end_number
-    assert_equal %w[</li>], @to.in_list_entry
-  end
-
-  def accept_list_item_end_ualpha
-    assert_equal %w[</li>], @to.in_list_entry
-  end
-
-  def accept_list_item_start_bullet
-    assert_equal "<ul><li>", @to.res.join
-  end
-
-  def accept_list_item_start_label
-    assert_equal "<dl class=\"rdoc-list label-list\"><dt>cat</dt>\n<dd>", @to.res.join
-  end
-
-  def accept_list_item_start_lalpha
-    assert_equal "<ol style=\"list-style-type: lower-alpha\"><li>", @to.res.join
-  end
-
-  def accept_list_item_start_note
-    assert_equal "<dl class=\"rdoc-list note-list\"><dt>cat</dt>\n<dd>",
-                 @to.res.join
-  end
-
-  def accept_list_item_start_note_2
-    expected = <<-EXPECTED
-<dl class="rdoc-list note-list"><dt><code>teletype</code></dt>
-<dd>
-<p>teletype description</p>
-</dd></dl>
-    EXPECTED
-
-    assert_equal expected, @to.res.join
-  end
-
-  def accept_list_item_start_note_multi_description
-    expected = <<-EXPECTED
-<dl class="rdoc-list note-list"><dt>label</dt>
-<dd>
-<p>description one</p>
-</dd><dd>
-<p>description two</p>
-</dd></dl>
-    EXPECTED
-
-    assert_equal expected, @to.res.join
-  end
-
-  def accept_list_item_start_note_multi_label
-    expected = <<-EXPECTED
-<dl class="rdoc-list note-list"><dt>one</dt>
-<dt>two</dt>
-<dd>
-<p>two headers</p>
-</dd></dl>
-    EXPECTED
-
-    assert_equal expected, @to.res.join
-  end
-
-  def accept_list_item_start_number
-    assert_equal "<ol><li>", @to.res.join
-  end
-
-  def accept_list_item_start_ualpha
-    assert_equal "<ol style=\"list-style-type: upper-alpha\"><li>", @to.res.join
-  end
-
-  def accept_list_start_bullet
-    assert_equal [:BULLET], @to.list
-    assert_equal [false], @to.in_list_entry
-
-    assert_equal "<ul>", @to.res.join
-  end
-
-  def accept_list_start_label
-    assert_equal [:LABEL], @to.list
-    assert_equal [false], @to.in_list_entry
-
-    assert_equal '<dl class="rdoc-list label-list">', @to.res.join
-  end
-
-  def accept_list_start_lalpha
-    assert_equal [:LALPHA], @to.list
-    assert_equal [false], @to.in_list_entry
-
-    assert_equal "<ol style=\"list-style-type: lower-alpha\">", @to.res.join
-  end
-
-  def accept_list_start_note
-    assert_equal [:NOTE], @to.list
-    assert_equal [false], @to.in_list_entry
-
-    assert_equal "<dl class=\"rdoc-list note-list\">", @to.res.join
-  end
-
-  def accept_list_start_number
-    assert_equal [:NUMBER], @to.list
-    assert_equal [false], @to.in_list_entry
-
-    assert_equal "<ol>", @to.res.join
-  end
-
-  def accept_list_start_ualpha
-    assert_equal [:UALPHA], @to.list
-    assert_equal [false], @to.in_list_entry
-
-    assert_equal "<ol style=\"list-style-type: upper-alpha\">", @to.res.join
-  end
-
-  def accept_paragraph
-    assert_equal "\n<p>hi</p>\n", @to.res.join
-  end
-
-  def accept_paragraph_b
-    assert_equal "\n<p>reg <strong>bold words</strong> reg</p>\n", @to.res.join
-  end
-
-  def accept_paragraph_br
-    assert_equal "\n<p>one<br>two</p>\n", @to.res.join
-  end
-
-  def accept_paragraph_break
-    assert_equal "\n<p>hello<br> world</p>\n", @to.res.join
-  end
-
-  def accept_paragraph_i
-    assert_equal "\n<p>reg <em>italic words</em> reg</p>\n", @to.res.join
-  end
-
-  def accept_paragraph_plus
-    assert_equal "\n<p>reg <code>teletype</code> reg</p>\n", @to.res.join
-  end
-
-  def accept_paragraph_star
-    assert_equal "\n<p>reg <strong>bold</strong> reg</p>\n", @to.res.join
-  end
-
-  def accept_paragraph_underscore
-    assert_equal "\n<p>reg <em>italic</em> reg</p>\n", @to.res.join
-  end
-
-  def accept_raw
-    raw = <<-RAW.rstrip
-<table>
-<tr><th>Name<th>Count
-<tr><td>a<td>1
-<tr><td>b<td>2
-</table>
-    RAW
-
-    assert_equal raw, @to.res.join
-  end
-
-  def accept_rule
-    assert_equal "<hr>\n", @to.res.join
-  end
-
-  def accept_verbatim
-    assert_equal "\n<pre class=\"ruby\"><span class=\"ruby-identifier\">hi</span>\n  <span class=\"ruby-identifier\">world</span>\n</pre>\n", @to.res.join
-  end
-
-  def end_accepting
-    assert_equal 'hi', @to.end_accepting
-  end
-
-  def start_accepting
-    assert_equal [], @to.res
-    assert_equal [], @to.in_list_entry
-    assert_equal [], @to.list
-  end
-
-  def list_nested
-    expected = <<-EXPECTED
-<ul><li>
-<p>l1</p>
-<ul><li>
-<p>l1.1</p>
-</li></ul>
-</li><li>
-<p>l2</p>
-</li></ul>
-    EXPECTED
-
-    assert_equal expected, @to.res.join
-  end
-
-  def list_verbatim
-    expected = <<-EXPECTED
-<ul><li>
-<p>list stuff</p>
-
-<pre>* list
-  with
-
-  second
-
-  1. indented
-  2. numbered
-
-  third
-
-* second</pre>
-</li></ul>
-    EXPECTED
-
-    assert_equal expected, @to.end_accepting
-  end
-
-  def test_accept_heading_7
-    @to.start_accepting
-
-    @to.accept_heading @RM::Heading.new(7, 'Hello')
-
-    links = '<span><a href="#label-Hello">¶</a> ' +
-            '<a href="#top">↑</a></span>'
-
-    assert_equal "\n<h6 id=\"label-Hello\">Hello#{links}</h6>\n", @to.res.join
-  end
-
-  def test_accept_heading_aref_class
-    @to.code_object = RDoc::NormalClass.new 'Foo'
-    @to.start_accepting
-
-    @to.accept_heading head(1, 'Hello')
-
-    links = '<span><a href="#class-Foo-label-Hello">¶</a> ' +
-            '<a href="#top">↑</a></span>'
-
-    assert_equal "\n<h1 id=\"class-Foo-label-Hello\">Hello#{links}</h1>\n",
-                 @to.res.join
-  end
-
-  def test_accept_heading_aref_method
-    @to.code_object = RDoc::AnyMethod.new nil, 'foo'
-    @to.start_accepting
-
-    @to.accept_heading @RM::Heading.new(1, 'Hello')
-
-    links = '<span><a href="#method-i-foo-label-Hello">¶</a> ' +
-            '<a href="#top">↑</a></span>'
-
-    assert_equal "\n<h1 id=\"method-i-foo-label-Hello\">Hello#{links}</h1>\n",
-                 @to.res.join
-  end
-
-  def test_accept_heading_pipe
-    @options.pipe = true
-
-    @to.start_accepting
-
-    @to.accept_heading @RM::Heading.new(1, 'Hello')
-
-    assert_equal "\n<h1 id=\"label-Hello\">Hello</h1>\n", @to.res.join
-  end
-
-  def test_accept_paragraph_newline
-    hellos = ["hello", "\u{393 3b5 3b9 3ac} \u{3c3 3bf 3c5}"]
-    worlds = ["world", "\u{3ba 3cc 3c3 3bc 3bf 3c2}"]
-    ohayo, sekai = %W"\u{304a 306f 3088 3046} \u{4e16 754c}"
-
-    hellos.product(worlds) do |hello, world|
-      @to.start_accepting
-      @to.accept_paragraph para("#{hello}\n", "#{world}\n")
-      assert_equal "\n<p>#{hello} #{world}</p>\n", @to.res.join
-    end
-
-    hellos.each do |hello|
-      @to.start_accepting
-      @to.accept_paragraph para("#{hello}\n", "#{sekai}\n")
-      assert_equal "\n<p>#{hello}#{sekai}</p>\n", @to.res.join
-    end
-
-    worlds.each do |world|
-      @to.start_accepting
-      @to.accept_paragraph para("#{ohayo}\n", "#{world}\n")
-      assert_equal "\n<p>#{ohayo}#{world}</p>\n", @to.res.join
-    end
-
-    @to.start_accepting
-    @to.accept_paragraph para("#{ohayo}\n", "#{sekai}\n")
-    assert_equal "\n<p>#{ohayo}#{sekai}</p>\n", @to.res.join
-
-    @to.start_accepting
-    @to.accept_paragraph para("+hello+\n", "world\n")
-    assert_equal "\n<p><code>hello</code> world</p>\n", @to.res.join
-
-    @to.start_accepting
-    @to.accept_paragraph para("hello\n", "+world+\n")
-    assert_equal "\n<p>hello <code>world</code></p>\n", @to.res.join
-
-    @to.start_accepting
-    @to.accept_paragraph para("+hello+\n", "+world+\n")
-    assert_equal "\n<p><code>hello</code> <code>world</code></p>\n", @to.res.join
-  end
-
-  def test_accept_heading_output_decoration
-    @options.output_decoration = false
-
-    @to.start_accepting
-
-    @to.accept_heading @RM::Heading.new(1, 'Hello')
-
-    assert_equal "\n<h1>Hello<span><a href=\"#label-Hello\">¶</a> <a href=\"#top\">↑</a></span></h1>\n", @to.res.join
-  end
-
-  def test_accept_heading_output_decoration_with_pipe
-    @options.pipe = true
-    @options.output_decoration = false
-
-    @to.start_accepting
-
-    @to.accept_heading @RM::Heading.new(1, 'Hello')
-
-    assert_equal "\n<h1>Hello</h1>\n", @to.res.join
-  end
-
-  def test_accept_verbatim_parseable
-    verb = @RM::Verbatim.new("class C\n", "end\n")
-
-    @to.start_accepting
-    @to.accept_verbatim verb
-
-    expected = <<-EXPECTED
-
-<pre class="ruby"><span class="ruby-keyword">class</span> <span class="ruby-constant">C</span>
-<span class="ruby-keyword">end</span>
-</pre>
-    EXPECTED
-
-    assert_equal expected, @to.res.join
-  end
-
-  def test_accept_verbatim_parseable_error
-    verb = @RM::Verbatim.new("a % 09 # => blah\n")
-
-    @to.start_accepting
-    @to.accept_verbatim verb
-
-    inner = CGI.escapeHTML "a % 09 # => blah"
-
-    expected = <<-EXPECTED
-
-<pre>#{inner}</pre>
-    EXPECTED
-
-    assert_equal expected, @to.res.join
-  end
-
-  def test_accept_verbatim_nl_after_backslash
-    verb = @RM::Verbatim.new("a = 1 if first_flag_var and \\\n", "  this_is_flag_var\n")
-
-    @to.start_accepting
-    @to.accept_verbatim verb
-
-    expected = <<-EXPECTED
-
-<pre class="ruby"><span class="ruby-identifier">a</span> = <span class="ruby-value">1</span> <span class="ruby-keyword">if</span> <span class="ruby-identifier">first_flag_var</span> <span class="ruby-keyword">and</span> \\
-  <span class="ruby-identifier">this_is_flag_var</span>
-</pre>
-    EXPECTED
-
-    assert_equal expected, @to.res.join
-  end
-
-  def test_accept_verbatim_pipe
-    @options.pipe = true
-
-    verb = @RM::Verbatim.new("1 + 1\n")
-    verb.format = :ruby
-
-    @to.start_accepting
-    @to.accept_verbatim verb
-
-    expected = <<-EXPECTED
-
-<pre><code>1 + 1
-</code></pre>
-    EXPECTED
-
-    assert_equal expected, @to.res.join
-  end
-
-  def test_accept_verbatim_escape_in_string
-    code = <<-'RUBY'
-def foo
-  [
-    '\\',
-    '\'',
-    "'",
-    "\'\"\`",
-    "\#",
-    "\#{}",
-    "#",
-    "#{}",
-    /'"/,
-    /\'\"/,
-    /\//,
-    /\\/,
-    /\#/,
-    /\#{}/,
-    /#/,
-    /#{}/
-  ]
-end
-def bar
-end
-    RUBY
-    verb = @RM::Verbatim.new(*code.split(/(?<=\n)/))
-
-    @to.start_accepting
-    @to.accept_verbatim verb
-
-    expected = <<-'EXPECTED'
-
-<pre class="ruby"><span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">foo</span>
-  [
-    <span class="ruby-string">'\\'</span>,
-    <span class="ruby-string">'\''</span>,
-    <span class="ruby-string">"'"</span>,
-    <span class="ruby-string">"\'\"\`"</span>,
-    <span class="ruby-string">"\#"</span>,
-    <span class="ruby-string">"\#{}"</span>,
-    <span class="ruby-string">"#"</span>,
-    <span class="ruby-node">"#{}"</span>,
-    <span class="ruby-regexp">/'"/</span>,
-    <span class="ruby-regexp">/\'\"/</span>,
-    <span class="ruby-regexp">/\//</span>,
-    <span class="ruby-regexp">/\\/</span>,
-    <span class="ruby-regexp">/\#/</span>,
-    <span class="ruby-regexp">/\#{}/</span>,
-    <span class="ruby-regexp">/#/</span>,
-    <span class="ruby-regexp">/#{}/</span>
-  ]
-<span class="ruby-keyword">end</span>
-<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">bar</span>
-<span class="ruby-keyword">end</span>
-</pre>
-    EXPECTED
-
-    assert_equal expected, @to.res.join
-  end
-
-  def test_accept_verbatim_escape_in_backtick
-    code = <<-'RUBY'
-def foo
-  [
-    `\\`,
-    `\'\"\``,
-    `\#`,
-    `\#{}`,
-    `#`,
-    `#{}`
-  ]
-end
-def bar
-end
-    RUBY
-    verb = @RM::Verbatim.new(*code.split(/(?<=\n)/))
-
-    @to.start_accepting
-    @to.accept_verbatim verb
-
-    expected = <<-'EXPECTED'
-
-<pre class="ruby"><span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">foo</span>
-  [
-    <span class="ruby-string">`\\`</span>,
-    <span class="ruby-string">`\'\"\``</span>,
-    <span class="ruby-string">`\#`</span>,
-    <span class="ruby-string">`\#{}`</span>,
-    <span class="ruby-string">`#`</span>,
-    <span class="ruby-node">`#{}`</span>
-  ]
-<span class="ruby-keyword">end</span>
-<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">bar</span>
-<span class="ruby-keyword">end</span>
-</pre>
-    EXPECTED
-
-    assert_equal expected, @to.res.join
-  end
-
-  def test_accept_verbatim_ruby
-    verb = @RM::Verbatim.new("1 + 1\n")
-    verb.format = :ruby
-
-    @to.start_accepting
-    @to.accept_verbatim verb
-
-    expected = <<-EXPECTED
-
-<pre class="ruby"><span class="ruby-value">1</span> <span class="ruby-operator">+</span> <span class="ruby-value">1</span>
-</pre>
-    EXPECTED
-
-    assert_equal expected, @to.res.join
-  end
-
-  def test_accept_verbatim_redefinable_operators
-    functions = %w[| ^ & <=> == === =~ > >= < <= << >> + - * / % ** ~ +@ -@ [] []= ` !  != !~].flat_map { |redefinable_op|
-      ["def #{redefinable_op}\n", "end\n"]
-    }
-
-    verb = @RM::Verbatim.new(*functions)
-
-    @to.start_accepting
-    @to.accept_verbatim verb
-
-    expected = <<-EXPECTED
-
-<pre class="ruby">
-    EXPECTED
-    expected = expected.rstrip
-
-    %w[| ^ & <=> == === =~ > >= < <= << >> + - * / % ** ~ +@ -@ [] []= ` !  != !~].each do |html_escaped_op|
-      expected += <<-EXPECTED
-<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">#{html_escaped_op}</span>
-<span class="ruby-keyword">end</span>
-      EXPECTED
-    end
-
-    expected += <<-EXPECTED
-</pre>
-EXPECTED
-
-    assert_equal expected, @to.res.join
-  end
-
-  def test_convert_string
-    assert_equal '<>', @to.convert_string('<>')
-  end
-
-  def test_convert_HYPERLINK_irc
-    result = @to.convert 'irc://irc.freenode.net/#ruby-lang'
-
-    assert_equal "\n<p><a href=\"irc://irc.freenode.net/#ruby-lang\">irc.freenode.net/#ruby-lang</a></p>\n", result
-  end
-
-  def test_convert_RDOCLINK_label_label
-    result = @to.convert 'rdoc-label:label-One'
-
-    assert_equal "\n<p><a href=\"#label-One\">One</a></p>\n", result
-  end
-
-  def test_convert_RDOCLINK_label_foottext
-    result = @to.convert 'rdoc-label:foottext-1'
-
-    assert_equal "\n<p><a href=\"#foottext-1\">1</a></p>\n", result
-  end
-
-  def test_convert_RDOCLINK_label_footmark
-    result = @to.convert 'rdoc-label:footmark-1'
-
-    assert_equal "\n<p><a href=\"#footmark-1\">1</a></p>\n", result
-  end
-
-  def test_convert_RDOCLINK_ref
-    result = @to.convert 'rdoc-ref:C'
-
-    assert_equal "\n<p>C</p>\n", result
-  end
-
-  def test_convert_RDOCLINK_escape_image
-    assert_escaped '<script>', 'rdoc-image:"><script>alert(`rdoc-image`)</script>"'
-  end
-
-  def test_convert_RDOCLINK_escape_label_id
-    assert_escaped '<script>', 'rdoc-label::path::"><script>alert(`rdoc-label_id`)</script>"'
-  end
-
-  def test_convert_RDOCLINK_escape_label_path
-    assert_escaped '<script>', 'rdoc-label::"><script>alert(`rdoc-label_path`)</script>"'
-  end
-
-  def test_convert_RDOCLINK_escape_ref
-    assert_escaped '<script>', 'rdoc-ref:"><script>alert(`rdoc-ref`)</script>"'
-  end
-
-  def test_convert_RDOCLINK_escape_xxx
-    assert_escaped '<script>', 'rdoc-xxx:"><script>alert(`rdoc-xxx`)</script>"'
-  end
-
-  def test_convert_TIDYLINK_footnote
-    result = @to.convert 'text{*1}[rdoc-label:foottext-1:footmark-1]'
-
-    assert_equal "\n<p>text<sup><a id=\"footmark-1\" href=\"#foottext-1\">1</a></sup></p>\n", result
-  end
-
-  def test_convert_TIDYLINK_multiple
-    result = @to.convert '{a}[http://example] {b}[http://example]'
-
-    expected = <<-EXPECTED
-
-<p><a href=\"http://example\">a</a> <a href=\"http://example\">b</a></p>
-    EXPECTED
-
-    assert_equal expected, result
-  end
-
-  def test_convert_TIDYLINK_image
-    result =
-      @to.convert '{rdoc-image:path/to/image.jpg}[http://example.com]'
-
-    expected =
-      "\n<p><a href=\"http://example.com\"><img src=\"path/to/image.jpg\"></a></p>\n"
-
-    assert_equal expected, result
-
-    result =
-      @to.convert '{rdoc-image:<script>alert`link text`</script>}[http://example.com]'
-
-    assert_not_include result, "<script>"
-  end
-
-  def test_convert_TIDYLINK_image_with_alt
-    result =
-      @to.convert '{rdoc-image:path/to/image.jpg:alt text}[http://example.com]'
-
-    expected =
-      "\n<p><a href=\"http://example.com\"><img src=\"path/to/image.jpg\" alt=\"alt text\"></a></p>\n"
-
-    assert_equal expected, result
-  end
-
-  def test_convert_TIDYLINK_image_external
-    result =
-      @to.convert '{rdoc-image:http://example.com/path/to/image.jpg}[http://example.com]'
-
-    expected =
-      "\n<p><a href=\"http://example.com\"><img src=\"http://example.com/path/to/image.jpg\"></a></p>\n"
-
-    assert_equal expected, result
-  end
-
-  def test_convert_TIDYLINK_image_external_with_alt
-    result =
-      @to.convert '{rdoc-image:http://example.com/path/to/image.jpg:alt text}[http://example.com]'
-
-    expected =
-      "\n<p><a href=\"http://example.com\"><img src=\"http://example.com/path/to/image.jpg\" alt=\"alt text\"></a></p>\n"
-
-    assert_equal expected, result
-  end
-
-  def test_convert_TIDYLINK_rdoc_label
-    result = @to.convert '{foo}[rdoc-label:foottext-1]'
-
-    assert_equal "\n<p><a href=\"#foottext-1\">foo</a></p>\n", result
-  end
-
-  def test_convert_TIDYLINK_irc
-    result = @to.convert '{ruby-lang}[irc://irc.freenode.net/#ruby-lang]'
-
-    assert_equal "\n<p><a href=\"irc://irc.freenode.net/#ruby-lang\">ruby-lang</a></p>\n", result
-  end
-
-  def test_convert_TIDYLINK_escape_text
-    assert_escaped '<script>', '{<script>alert`link text`</script>}[a]'
-    assert_escaped '<script>', 'x:/<script>alert(1);</script>[[]'
-  end
-
-  def test_convert_TIDYLINK_escape_javascript
-    assert_not_include '{click}[javascript:alert`javascript_scheme`]', '<a href="javascript:'
-  end
-
-  def test_convert_TIDYLINK_escape_onmouseover
-    assert_escaped '"/onmouseover="', '{onmouseover}[http://"/onmouseover="alert`on_mouse_link`"]'
-  end
-
-  def test_convert_TIDYLINK_escape_onerror
-    assert_escaped '"onerror="', '{link_image}[http://"onerror="alert`link_image`".png]'
-  end
-
-  def test_convert_with_exclude_tag
-    assert_equal "\n<p><code>aaa</code>[:symbol]</p>\n", @to.convert('+aaa+[:symbol]')
-    assert_equal "\n<p><code>aaa[:symbol]</code></p>\n", @to.convert('+aaa[:symbol]+')
-    assert_equal "\n<p><code>https:</code>-foobar</p>\n", @to.convert('<tt>https:</tt>-foobar')
-    assert_equal "\n<p><a href=\":symbol\">aaa</a></p>\n", @to.convert('aaa[:symbol]')
-  end
-
-  def test_convert_underscore_adjacent_to_code
-    assert_equal "\n<p><code>aaa</code>_</p>\n", @to.convert(%q{+aaa+_})
-    assert_equal "\n<p>\u{2018}<code>i386-mswin32_</code><em>MSRTVERSION</em>\u{2019}</p>\n", @to.convert(%q{`+i386-mswin32_+_MSRTVERSION_'})
-  end
-
-  def test_gen_url
-    assert_equal '<a href="example">example</a>',
-                 @to.gen_url('link:example', 'example')
-  end
-
-  def test_gen_url_rdoc_label
-    assert_equal '<a href="#foottext-1">example</a>',
-                 @to.gen_url('rdoc-label:foottext-1', 'example')
-  end
-
-  def test_gen_url_rdoc_label_id
-    assert_equal '<sup><a id="footmark-1" href="#foottext-1">example</a></sup>',
-                 @to.gen_url('rdoc-label:foottext-1:footmark-1', 'example')
-  end
-
-  def test_gen_url_image_url
-    assert_equal '<img src="http://example.com/image.png" />', @to.gen_url('http://example.com/image.png', 'ignored')
-  end
-
-  def test_gen_url_ssl_image_url
-    assert_equal '<img src="https://example.com/image.png" />', @to.gen_url('https://example.com/image.png', 'ignored')
-  end
-
-  def test_gen_url_rdoc_file
-    assert_equal '<a href="example_rdoc.html">example</a>',
-                 @to.gen_url('example.rdoc', 'example')
-    assert_equal '<a href="doc/example_rdoc.html">example</a>',
-                 @to.gen_url('doc/example.rdoc', 'example')
-    assert_equal '<a href="../ex.doc/example_rdoc.html">example</a>',
-                 @to.gen_url('../ex.doc/example.rdoc', 'example')
-    assert_equal '<a href="doc/example_rdoc.html#label-one">example</a>',
-                 @to.gen_url('doc/example.rdoc#label-one', 'example')
-    assert_equal '<a href="../ex.doc/example_rdoc.html#label-two">example</a>',
-                 @to.gen_url('../ex.doc/example.rdoc#label-two', 'example')
-  end
-
-  def test_gen_url_md_file
-    assert_equal '<a href="example_md.html">example</a>',
-                 @to.gen_url('example.md', 'example')
-    assert_equal '<a href="doc/example_md.html">example</a>',
-                 @to.gen_url('doc/example.md', 'example')
-    assert_equal '<a href="../ex.doc/example_md.html">example</a>',
-                 @to.gen_url('../ex.doc/example.md', 'example')
-    assert_equal '<a href="doc/example_md.html#label-one">example</a>',
-                 @to.gen_url('doc/example.md#label-one', 'example')
-    assert_equal '<a href="../ex.doc/example_md.html#label-two">example</a>',
-                 @to.gen_url('../ex.doc/example.md#label-two', 'example')
-  end
-
-  def test_gen_url_rb_file
-    assert_equal '<a href="example_rb.html">example</a>',
-                 @to.gen_url('example.rb', 'example')
-    assert_equal '<a href="doc/example_rb.html">example</a>',
-                 @to.gen_url('doc/example.rb', 'example')
-    assert_equal '<a href="../ex.doc/example_rb.html">example</a>',
-                 @to.gen_url('../ex.doc/example.rb', 'example')
-    assert_equal '<a href="doc/example_rb.html#label-one">example</a>',
-                 @to.gen_url('doc/example.rb#label-one', 'example')
-    assert_equal '<a href="../ex.doc/example_rb.html#label-two">example</a>',
-                 @to.gen_url('../ex.doc/example.rb#label-two', 'example')
-  end
-
-  def test_handle_regexp_HYPERLINK_link
-    target = RDoc::Markup::RegexpHandling.new 0, 'link:README.txt'
-
-    link = @to.handle_regexp_HYPERLINK target
-
-    assert_equal '<a href="README.txt">README.txt</a>', link
-  end
-
-  def test_handle_regexp_HYPERLINK_irc
-    target = RDoc::Markup::RegexpHandling.new 0, 'irc://irc.freenode.net/#ruby-lang'
-
-    link = @to.handle_regexp_HYPERLINK target
-
-    assert_equal '<a href="irc://irc.freenode.net/#ruby-lang">irc.freenode.net/#ruby-lang</a>', link
-  end
-
-  def test_handle_regexp_HYPERLINK_escape
-    code = 'irc://irc.freenode.net/"><script>alert(`irc`)</script><a"'
-    assert_escaped '<script>', code
-  end
-
-  def test_list_verbatim_2
-    str = "* one\n    verb1\n    verb2\n* two\n"
-
-    expected = <<-EXPECTED
-<ul><li>
-<p>one</p>
-
-<pre class=\"ruby\"><span class=\"ruby-identifier\">verb1</span>
-<span class=\"ruby-identifier\">verb2</span>
-</pre>
-</li><li>
-<p>two</p>
-</li></ul>
-    EXPECTED
-
-    assert_equal expected, @m.convert(str, @to)
-  end
-
-  def test_block_quote_in_verbatim
-    str = "BlockQuote\n  >>>\n"
-
-    expected = <<-EXPECTED
-<p>BlockQuote</p>
-<pre>>>></pre>
-    EXPECTED
-
-    assert_equal expected, @m.convert(str, @to).gsub(/^\n/, "")
-
-    str = "BlockQuote\n  >>>  word\n"
-
-    expected = <<-EXPECTED
-<p>BlockQuote</p>
-<pre>>>>  word</pre>
-    EXPECTED
-
-    assert_equal expected, @m.convert(str, @to).gsub(/^\n/, "")
-  end
-
-  def test_parseable_eh
-    valid_syntax = [
-      'def x() end',
-      'def x; end',
-      'class C; end',
-      "module M end",
-      'a # => blah',
-      'x { |y| nil }',
-      'x do |y| nil end',
-      '# only a comment',
-      'require "foo"',
-      'cls="foo"'
-    ]
-    invalid_syntax = [
-      'def x end',
-      'class C < end',
-      'module M < C end',
-      'a=># blah',
-      'x { |y| ... }',
-      'x do |y| ... end',
-      '// only a comment',
-      '<% require "foo" %>',
-      'class="foo"'
-    ]
-    valid_syntax.each do |t|
-      assert @to.parseable?(t), "valid syntax considered invalid: #{t}"
-    end
-    invalid_syntax.each do |t|
-      refute @to.parseable?(t), "invalid syntax considered valid: #{t}"
-    end
-  end
-
-  def test_to_html
-    assert_equal "\n<p><code>--</code></p>\n", util_format("<tt>--</tt>")
-  end
-
-  def util_format(text)
-    paragraph = RDoc::Markup::Paragraph.new text
-
-    @to.start_accepting
-    @to.accept_paragraph paragraph
-    @to.end_accepting
-  end
-
-  def test_accept_table
-    header = %w[Col1 Col2 Col3 Col4]
-    body = [
-      %w[cell1_1 cell1_2 cell1_3 cell1_4],
-      %w[cell2_1 cell2_2 cell2_3 cell2_4],
-      ['<script>alert("foo");</script>'],
-      %w[+code+ _em_ **strong** C1],
-    ]
-    aligns = [:left, :right, nil, :center]
-    @to.start_accepting
-    @to.accept_table(header, body, aligns)
-    res = @to.end_accepting
-    assert_include(res[%r<<th[^<>]*>Col1</th>>], 'align="left"')
-    assert_include(res[%r<<th[^<>]*>Col2</th>>], 'align="right"')
-    assert_not_include(res[%r<<th[^<>]*>Col3</th>>], 'align=')
-    assert_include(res[%r<<th[^<>]*>Col4</th>>], 'align="center"')
-    assert_include(res[%r<<td[^<>]*>cell1_1</td>>], 'align="left"')
-    assert_include(res[%r<<td[^<>]*>cell1_2</td>>], 'align="right"')
-    assert_not_include(res[%r<<td[^<>]*>cell1_3</td>>], 'align=')
-    assert_include(res[%r<<td[^<>]*>cell2_1</td>>], 'align="left"')
-    assert_include(res[%r<<td[^<>]*>cell2_2</td>>], 'align="right"')
-    assert_not_include(res[%r<<td[^<>]*>cell2_3</td>>], 'align=')
-    assert_include(res[%r<<td[^<>]*>cell2_4</td>>], 'align="center"')
-    assert_not_include(res, '<script>')
-    assert_include(res[%r<<td[^<>]*>.*script.*</td>>], '<script>')
-    assert_include(res[%r<<td[^<>]*>.*code.*</td>>], '<code>code</code>')
-    assert_include(res[%r<<td[^<>]*>.*em.*</td>>], '<em>em</em>')
-    assert_include(res[%r<<td[^<>]*>.*strong.*</td>>], '<strong>strong</strong>')
-    assert_include(res[%r<<td[^<>]*>C1</td>>], 'C1')
-  end
-
-  def assert_escaped(unexpected, code)
-    result = @to.convert(code)
-    assert_not_include result, unexpected
-    assert_include result, CGI.escapeHTML(unexpected)
-  end
-end
diff --git a/test/mri/rdoc/rdoc_markup_to_joined_paragraph_test.rb b/test/mri/rdoc/rdoc_markup_to_joined_paragraph_test.rb
deleted file mode 100644
index 89e9736e8ac..00000000000
--- a/test/mri/rdoc/rdoc_markup_to_joined_paragraph_test.rb
+++ /dev/null
@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocMarkupToJoinedParagraphTest < RDoc::TestCase
-
-  def setup
-    super
-
-    @to = RDoc::Markup::ToJoinedParagraph.new
-  end
-
-  def test_accept_paragraph
-    parsed = para('hello', ' ', 'world')
-
-    @to.accept_paragraph parsed
-
-    expected = para('hello world')
-
-    assert_equal expected, parsed
-  end
-
-  def test_accept_paragraph_break
-    parsed = para('hello', ' ', 'world', hard_break, 'everyone')
-
-    @to.accept_paragraph parsed
-
-    expected = para('hello world', hard_break, 'everyone')
-
-    assert_equal expected, parsed
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc_markup_to_label_test.rb b/test/mri/rdoc/rdoc_markup_to_label_test.rb
deleted file mode 100644
index a56480de84e..00000000000
--- a/test/mri/rdoc/rdoc_markup_to_label_test.rb
+++ /dev/null
@@ -1,112 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocMarkupToLabelTest < RDoc::Markup::FormatterTestCase
-
-  add_visitor_tests
-
-  def setup
-    super
-
-    @to = RDoc::Markup::ToLabel.new
-  end
-
-  def empty
-    assert_empty @to.res
-  end
-
-  def end_accepting
-    assert_equal %w[hi], @to.res
-  end
-
-  alias accept_blank_line                             empty
-  alias accept_block_quote                            empty
-  alias accept_document                               empty
-  alias accept_heading                                empty
-  alias accept_heading_1                              empty
-  alias accept_heading_2                              empty
-  alias accept_heading_3                              empty
-  alias accept_heading_4                              empty
-  alias accept_heading_b                              empty
-  alias accept_heading_suppressed_crossref            empty
-  alias accept_list_end_bullet                        empty
-  alias accept_list_end_label                         empty
-  alias accept_list_end_lalpha                        empty
-  alias accept_list_end_note                          empty
-  alias accept_list_end_number                        empty
-  alias accept_list_end_ualpha                        empty
-  alias accept_list_item_end_bullet                   empty
-  alias accept_list_item_end_label                    empty
-  alias accept_list_item_end_lalpha                   empty
-  alias accept_list_item_end_note                     empty
-  alias accept_list_item_end_number                   empty
-  alias accept_list_item_end_ualpha                   empty
-  alias accept_list_item_start_bullet                 empty
-  alias accept_list_item_start_label                  empty
-  alias accept_list_item_start_lalpha                 empty
-  alias accept_list_item_start_note                   empty
-  alias accept_list_item_start_note_2                 empty
-  alias accept_list_item_start_note_multi_description empty
-  alias accept_list_item_start_note_multi_label       empty
-  alias accept_list_item_start_number                 empty
-  alias accept_list_item_start_ualpha                 empty
-  alias accept_list_start_bullet                      empty
-  alias accept_list_start_label                       empty
-  alias accept_list_start_lalpha                      empty
-  alias accept_list_start_note                        empty
-  alias accept_list_start_number                      empty
-  alias accept_list_start_ualpha                      empty
-  alias accept_paragraph                              empty
-  alias accept_paragraph_b                            empty
-  alias accept_paragraph_br                           empty
-  alias accept_paragraph_break                        empty
-  alias accept_paragraph_i                            empty
-  alias accept_paragraph_plus                         empty
-  alias accept_paragraph_star                         empty
-  alias accept_paragraph_underscore                   empty
-  alias accept_raw                                    empty
-  alias accept_rule                                   empty
-  alias accept_verbatim                               empty
-  alias list_nested                                   empty
-  alias list_verbatim                                 empty
-  alias start_accepting                               empty
-
-  def test_convert_bold
-    assert_equal 'bold', @to.convert('<b>bold</b>')
-    assert_equal 'bold', @to.convert('*bold*')
-  end
-
-  def test_convert_crossref
-    assert_equal 'SomeClass', @to.convert('SomeClass')
-    assert_equal 'SomeClass', @to.convert('\\SomeClass')
-
-    assert_equal 'some_method', @to.convert('some_method')
-    assert_equal 'some_method', @to.convert('\\some_method')
-
-    assert_equal '23some_method', @to.convert('#some_method')
-    assert_equal '23some_method', @to.convert('\\#some_method')
-  end
-
-  def test_convert_em
-    assert_equal 'em', @to.convert('<em>em</em>')
-    assert_equal 'em', @to.convert('*em*')
-  end
-
-  def test_convert_em_dash # for HTML conversion
-    assert_equal '-', @to.convert('--')
-  end
-
-  def test_convert_escape
-    assert_equal 'a+-3E+b', @to.convert('a > b')
-  end
-
-  def test_convert_tidylink
-    assert_equal 'text', @to.convert('{text}[stuff]')
-    assert_equal 'text', @to.convert('text[stuff]')
-  end
-
-  def test_convert_tt
-    assert_equal 'tt', @to.convert('<tt>tt</tt>')
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc_markup_to_markdown_test.rb b/test/mri/rdoc/rdoc_markup_to_markdown_test.rb
deleted file mode 100644
index 86fe5ce82bc..00000000000
--- a/test/mri/rdoc/rdoc_markup_to_markdown_test.rb
+++ /dev/null
@@ -1,397 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocMarkupToMarkdownTest < RDoc::Markup::TextFormatterTestCase
-
-  add_visitor_tests
-  add_text_tests
-
-  def setup
-    super
-
-    @to = RDoc::Markup::ToMarkdown.new
-  end
-
-  def accept_blank_line
-    assert_equal "\n", @to.res.join
-  end
-
-  def accept_block_quote
-    assert_equal "> quote\n", @to.res.join
-  end
-
-  def accept_document
-    assert_equal "hello\n", @to.res.join
-  end
-
-  def accept_heading
-    assert_equal "##### Hello\n", @to.res.join
-  end
-
-  def accept_list_end_bullet
-    assert_empty @to.list_index
-    assert_empty @to.list_type
-    assert_empty @to.list_width
-  end
-
-  def accept_list_end_label
-    assert_empty @to.list_index
-    assert_empty @to.list_type
-    assert_empty @to.list_width
-  end
-
-  def accept_list_end_lalpha
-    assert_empty @to.list_index
-    assert_empty @to.list_type
-    assert_empty @to.list_width
-  end
-
-  def accept_list_end_note
-    assert_empty @to.list_index
-    assert_empty @to.list_type
-    assert_empty @to.list_width
-  end
-
-  def accept_list_end_number
-    assert_empty @to.list_index
-    assert_empty @to.list_type
-    assert_empty @to.list_width
-  end
-
-  def accept_list_end_ualpha
-    assert_empty @to.list_index
-    assert_empty @to.list_type
-    assert_empty @to.list_width
-  end
-
-  def accept_list_item_end_bullet
-    assert_equal 0, @to.indent, 'indent'
-  end
-
-  def accept_list_item_end_label
-    assert_equal "cat\n:   \n", @to.res.join
-    assert_equal 0, @to.indent, 'indent'
-  end
-
-  def accept_list_item_end_lalpha
-    assert_equal 0, @to.indent, 'indent'
-    assert_equal 2, @to.list_index.last
-  end
-
-  def accept_list_item_end_note
-    assert_equal "cat\n:   \n", @to.res.join
-    assert_equal 0, @to.indent, 'indent'
-  end
-
-  def accept_list_item_end_number
-    assert_equal 0, @to.indent, 'indent'
-    assert_equal 2, @to.list_index.last
-  end
-
-  def accept_list_item_end_ualpha
-    assert_equal 0, @to.indent, 'indent'
-    assert_equal 2, @to.list_index.last
-  end
-
-  def accept_list_item_start_bullet
-    assert_equal [""], @to.res
-    assert_equal '*   ', @to.prefix
-  end
-
-  def accept_list_item_start_label
-    assert_equal [""], @to.res
-    assert_equal "cat\n:   ", @to.prefix
-
-    assert_equal 4, @to.indent
-  end
-
-  def accept_list_item_start_lalpha
-    assert_equal [""], @to.res
-    assert_equal '1.  ', @to.prefix
-
-    assert_equal 1, @to.list_index.last
-    assert_equal 4, @to.indent
-  end
-
-  def accept_list_item_start_note
-    assert_equal [""], @to.res
-    assert_equal "cat\n:   ", @to.prefix
-
-    assert_equal 4, @to.indent
-  end
-
-  def accept_list_item_start_number
-    assert_equal [""], @to.res
-    assert_equal '1.  ', @to.prefix
-
-    assert_equal 1, @to.list_index.last
-    assert_equal 4, @to.indent
-  end
-
-  def accept_list_item_start_ualpha
-    assert_equal [""], @to.res
-    assert_equal '1.  ', @to.prefix
-
-    assert_equal 1, @to.list_index.last
-    assert_equal 4, @to.indent
-  end
-
-  def accept_list_start_bullet
-    assert_equal "",   @to.res.join
-    assert_equal [nil],     @to.list_index
-    assert_equal [:BULLET], @to.list_type
-    assert_equal [4],       @to.list_width
-  end
-
-  def accept_list_start_label
-    assert_equal "",  @to.res.join
-    assert_equal [nil],    @to.list_index
-    assert_equal [:LABEL], @to.list_type
-    assert_equal [4],      @to.list_width
-  end
-
-  def accept_list_start_lalpha
-    assert_equal "",   @to.res.join
-    assert_equal [1],     @to.list_index
-    assert_equal [:LALPHA], @to.list_type
-    assert_equal [4],       @to.list_width
-  end
-
-  def accept_list_start_note
-    assert_equal "", @to.res.join
-    assert_equal [nil],   @to.list_index
-    assert_equal [:NOTE], @to.list_type
-    assert_equal [4],     @to.list_width
-  end
-
-  def accept_list_start_number
-    assert_equal "",   @to.res.join
-    assert_equal [1],       @to.list_index
-    assert_equal [:NUMBER], @to.list_type
-    assert_equal [4],       @to.list_width
-  end
-
-  def accept_list_start_ualpha
-    assert_equal "",   @to.res.join
-    assert_equal [1],     @to.list_index
-    assert_equal [:UALPHA], @to.list_type
-    assert_equal [4],       @to.list_width
-  end
-
-  def accept_paragraph
-    assert_equal "hi\n", @to.res.join
-  end
-
-  def accept_raw
-    raw = <<-RAW.rstrip
-<table>
-<tr><th>Name<th>Count
-<tr><td>a<td>1
-<tr><td>b<td>2
-</table>
-    RAW
-
-    assert_equal raw, @to.res.join
-  end
-
-  def accept_rule
-    assert_equal "---\n", @to.res.join
-  end
-
-  def accept_verbatim
-    assert_equal "    hi\n      world\n\n", @to.res.join
-  end
-
-  def end_accepting
-    assert_equal "hi", @to.end_accepting
-  end
-
-  def start_accepting
-    assert_equal 0, @to.indent
-    assert_equal [""], @to.res
-    assert_empty @to.list_index
-    assert_empty @to.list_type
-    assert_empty @to.list_width
-  end
-
-  def accept_heading_1
-    assert_equal "# Hello\n", @to.end_accepting
-  end
-
-  def accept_heading_2
-    assert_equal "## Hello\n", @to.end_accepting
-  end
-
-  def accept_heading_3
-    assert_equal "### Hello\n", @to.end_accepting
-  end
-
-  def accept_heading_4
-    assert_equal "#### Hello\n", @to.end_accepting
-  end
-
-  def accept_heading_indent
-    assert_equal "   # Hello\n", @to.end_accepting
-  end
-
-  def accept_heading_b
-    assert_equal "# **Hello**\n", @to.end_accepting
-  end
-
-  def accept_heading_suppressed_crossref
-    assert_equal "# Hello\n", @to.end_accepting
-  end
-
-  def accept_list_item_start_note_2
-    assert_equal "`teletype`\n:   teletype description\n\n", @to.res.join
-  end
-
-  def accept_list_item_start_note_multi_description
-    assert_equal "label\n:   description one\n\n:   description two\n\n",
-                 @to.res.join
-  end
-
-  def accept_list_item_start_note_multi_label
-    assert_equal "one\ntwo\n:   two headers\n\n", @to.res.join
-  end
-
-  def accept_paragraph_b
-    assert_equal "reg **bold words** reg\n", @to.end_accepting
-  end
-
-  def accept_paragraph_br
-    assert_equal "one  \ntwo\n", @to.end_accepting
-  end
-
-  def accept_paragraph_break
-    assert_equal "hello  \nworld\n", @to.end_accepting
-  end
-
-  def accept_paragraph_i
-    assert_equal "reg *italic words* reg\n", @to.end_accepting
-  end
-
-  def accept_paragraph_indent
-    expected = <<-EXPECTED
-   words words words words words words words words words words words words
-   words words words words words words words words words words words words
-   words words words words words words
-    EXPECTED
-
-    assert_equal expected, @to.end_accepting
-  end
-
-  def accept_paragraph_plus
-    assert_equal "reg `teletype` reg\n", @to.end_accepting
-  end
-
-  def accept_paragraph_star
-    assert_equal "reg **bold** reg\n", @to.end_accepting
-  end
-
-  def accept_paragraph_underscore
-    assert_equal "reg *italic* reg\n", @to.end_accepting
-  end
-
-  def accept_paragraph_wrap
-    expected = <<-EXPECTED
-words words words words words words words words words words words words words
-words words words words words words words words words words words words words
-words words words words
-    EXPECTED
-
-    assert_equal expected, @to.end_accepting
-  end
-
-  def accept_rule_indent
-    assert_equal "   ---\n", @to.end_accepting
-  end
-
-  def accept_verbatim_indent
-    assert_equal "      hi\n       world\n\n", @to.end_accepting
-  end
-
-  def accept_verbatim_big_indent
-    assert_equal "      hi\n      world\n\n", @to.end_accepting
-  end
-
-  def list_nested
-    expected = <<-EXPECTED
-*   l1
-    *   l1.1
-*   l2
-    EXPECTED
-
-    assert_equal expected, @to.end_accepting
-  end
-
-  def list_verbatim
-    expected = <<-EXPECTED # HACK overblown
-*   list stuff
-
-        * list
-          with
-
-          second
-
-          1. indented
-          2. numbered
-
-          third
-
-        * second
-
-    EXPECTED
-
-    assert_equal expected, @to.end_accepting
-  end
-
-  def accept_table_align
-    expected = <<-EXPECTED
- AA |BB |CCCCC|DDDDD
-----|---|-----|-----
-    |bbb|    c|
-aaaa|b  |     | dd
- a  |   |   cc| dd
-    EXPECTED
-    assert_equal expected, @to.end_accepting
-  end
-
-  def test_convert_RDOCLINK
-    result = @to.convert 'rdoc-garbage:C'
-
-    assert_equal "C\n", result
-  end
-
-  def test_convert_RDOCLINK_image
-    result = @to.convert 'rdoc-image:/path/to/image.jpg'
-
-    assert_equal "![](/path/to/image.jpg)\n", result
-  end
-
-  def test_convert_TIDYLINK
-    result = @to.convert \
-      '{DSL}[https://en.wikipedia.org/wiki/Domain-specific_language]'
-
-    expected = "[DSL](https://en.wikipedia.org/wiki/Domain-specific_language)\n"
-
-    assert_equal expected, result
-  end
-
-  def test_handle_rdoc_link_label_footmark
-    assert_equal '[^1]:', @to.handle_rdoc_link('rdoc-label:footmark-1:x')
-  end
-
-  def test_handle_rdoc_link_label_foottext
-    assert_equal '[^1]',   @to.handle_rdoc_link('rdoc-label:foottext-1:x')
-  end
-
-  def test_handle_rdoc_link_label_label
-    assert_equal '[x](#label-x)', @to.handle_rdoc_link('rdoc-label:label-x')
-  end
-
-  def test_handle_rdoc_link_ref
-    assert_equal 'x', @to.handle_rdoc_link('rdoc-ref:x')
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc_markup_to_rdoc_test.rb b/test/mri/rdoc/rdoc_markup_to_rdoc_test.rb
deleted file mode 100644
index c7d6120c0db..00000000000
--- a/test/mri/rdoc/rdoc_markup_to_rdoc_test.rb
+++ /dev/null
@@ -1,388 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocMarkupToRDocTest < RDoc::Markup::TextFormatterTestCase
-
-  add_visitor_tests
-  add_text_tests
-
-  def setup
-    super
-
-    @to = RDoc::Markup::ToRdoc.new
-  end
-
-  def accept_blank_line
-    assert_equal "\n", @to.res.join
-  end
-
-  def accept_block_quote
-    assert_equal "> quote\n", @to.res.join
-  end
-
-  def accept_document
-    assert_equal "hello\n", @to.res.join
-  end
-
-  def accept_heading
-    assert_equal "===== Hello\n", @to.res.join
-  end
-
-  def accept_list_end_bullet
-    assert_empty @to.list_index
-    assert_empty @to.list_type
-    assert_empty @to.list_width
-  end
-
-  def accept_list_end_label
-    assert_empty @to.list_index
-    assert_empty @to.list_type
-    assert_empty @to.list_width
-  end
-
-  def accept_list_end_lalpha
-    assert_empty @to.list_index
-    assert_empty @to.list_type
-    assert_empty @to.list_width
-  end
-
-  def accept_list_end_note
-    assert_empty @to.list_index
-    assert_empty @to.list_type
-    assert_empty @to.list_width
-  end
-
-  def accept_list_end_number
-    assert_empty @to.list_index
-    assert_empty @to.list_type
-    assert_empty @to.list_width
-  end
-
-  def accept_list_end_ualpha
-    assert_empty @to.list_index
-    assert_empty @to.list_type
-    assert_empty @to.list_width
-  end
-
-  def accept_list_item_end_bullet
-    assert_equal 0, @to.indent, 'indent'
-  end
-
-  def accept_list_item_end_label
-    assert_equal "[cat]\n", @to.res.join
-    assert_equal 0, @to.indent, 'indent'
-  end
-
-  def accept_list_item_end_lalpha
-    assert_equal 0, @to.indent, 'indent'
-    assert_equal 'b', @to.list_index.last
-  end
-
-  def accept_list_item_end_note
-    assert_equal "cat::\n", @to.res.join
-    assert_equal 0, @to.indent, 'indent'
-  end
-
-  def accept_list_item_end_number
-    assert_equal 0, @to.indent, 'indent'
-    assert_equal 2, @to.list_index.last
-  end
-
-  def accept_list_item_end_ualpha
-    assert_equal 0, @to.indent, 'indent'
-    assert_equal 'B', @to.list_index.last
-  end
-
-  def accept_list_item_start_bullet
-    assert_equal [""], @to.res
-    assert_equal '* ', @to.prefix
-  end
-
-  def accept_list_item_start_label
-    assert_equal [""], @to.res
-    assert_equal "[cat]\n  ", @to.prefix
-
-    assert_equal 2, @to.indent
-  end
-
-  def accept_list_item_start_lalpha
-    assert_equal [""], @to.res
-    assert_equal 'a. ', @to.prefix
-
-    assert_equal 'a', @to.list_index.last
-    assert_equal 3, @to.indent
-  end
-
-  def accept_list_item_start_note
-    assert_equal [""], @to.res
-    assert_equal "cat::\n  ", @to.prefix
-
-    assert_equal 2, @to.indent
-  end
-
-  def accept_list_item_start_number
-    assert_equal [""], @to.res
-    assert_equal '1. ', @to.prefix
-
-    assert_equal 1, @to.list_index.last
-    assert_equal 3, @to.indent
-  end
-
-  def accept_list_item_start_ualpha
-    assert_equal [""], @to.res
-    assert_equal 'A. ', @to.prefix
-
-    assert_equal 'A', @to.list_index.last
-    assert_equal 3, @to.indent
-  end
-
-  def accept_list_start_bullet
-    assert_equal "",   @to.res.join
-    assert_equal [nil],     @to.list_index
-    assert_equal [:BULLET], @to.list_type
-    assert_equal [1],       @to.list_width
-  end
-
-  def accept_list_start_label
-    assert_equal "",  @to.res.join
-    assert_equal [nil],    @to.list_index
-    assert_equal [:LABEL], @to.list_type
-    assert_equal [2],      @to.list_width
-  end
-
-  def accept_list_start_lalpha
-    assert_equal "",   @to.res.join
-    assert_equal ['a'],     @to.list_index
-    assert_equal [:LALPHA], @to.list_type
-    assert_equal [1],       @to.list_width
-  end
-
-  def accept_list_start_note
-    assert_equal "", @to.res.join
-    assert_equal [nil],   @to.list_index
-    assert_equal [:NOTE], @to.list_type
-    assert_equal [2],     @to.list_width
-  end
-
-  def accept_list_start_number
-    assert_equal "",   @to.res.join
-    assert_equal [1],       @to.list_index
-    assert_equal [:NUMBER], @to.list_type
-    assert_equal [1],       @to.list_width
-  end
-
-  def accept_list_start_ualpha
-    assert_equal "",   @to.res.join
-    assert_equal ['A'],     @to.list_index
-    assert_equal [:UALPHA], @to.list_type
-    assert_equal [1],       @to.list_width
-  end
-
-  def accept_paragraph
-    assert_equal "hi\n", @to.res.join
-  end
-
-  def accept_raw
-    raw = <<-RAW.rstrip
-<table>
-<tr><th>Name<th>Count
-<tr><td>a<td>1
-<tr><td>b<td>2
-</table>
-    RAW
-
-    assert_equal raw, @to.res.join
-  end
-
-  def accept_rule
-    assert_equal "#{'-' * 78}\n", @to.res.join
-  end
-
-  def accept_verbatim
-    assert_equal "  hi\n    world\n\n", @to.res.join
-  end
-
-  def end_accepting
-    assert_equal "hi", @to.end_accepting
-  end
-
-  def start_accepting
-    assert_equal 0, @to.indent
-    assert_equal [""], @to.res
-    assert_empty @to.list_index
-    assert_empty @to.list_type
-    assert_empty @to.list_width
-  end
-
-  def accept_heading_1
-    assert_equal "= Hello\n", @to.end_accepting
-  end
-
-  def accept_heading_2
-    assert_equal "== Hello\n", @to.end_accepting
-  end
-
-  def accept_heading_3
-    assert_equal "=== Hello\n", @to.end_accepting
-  end
-
-  def accept_heading_4
-    assert_equal "==== Hello\n", @to.end_accepting
-  end
-
-  def accept_heading_indent
-    assert_equal "   = Hello\n", @to.end_accepting
-  end
-
-  def accept_heading_b
-    assert_equal "= <b>Hello</b>\n", @to.end_accepting
-  end
-
-  def accept_heading_suppressed_crossref
-    assert_equal "= Hello\n", @to.end_accepting
-  end
-
-  def accept_list_item_start_note_2
-    assert_equal "<tt>teletype</tt>::\n  teletype description\n\n", @to.res.join
-  end
-
-  def accept_list_item_start_note_multi_description
-    assert_equal "label::\n  description one\n\n  description two\n\n",
-                 @to.res.join
-  end
-
-  def accept_list_item_start_note_multi_label
-    assert_equal "one::\ntwo::\n  two headers\n\n", @to.res.join
-  end
-
-  def accept_paragraph_b
-    assert_equal "reg <b>bold words</b> reg\n", @to.end_accepting
-  end
-
-  def accept_paragraph_br
-    assert_equal "one\ntwo\n", @to.end_accepting
-  end
-
-  def accept_paragraph_break
-    assert_equal "hello\nworld\n", @to.end_accepting
-  end
-
-  def accept_paragraph_i
-    assert_equal "reg <em>italic words</em> reg\n", @to.end_accepting
-  end
-
-  def accept_paragraph_indent
-    expected = <<-EXPECTED
-   words words words words words words words words words words words words
-   words words words words words words words words words words words words
-   words words words words words words
-    EXPECTED
-
-    assert_equal expected, @to.end_accepting
-  end
-
-  def accept_paragraph_plus
-    assert_equal "reg <tt>teletype</tt> reg\n", @to.end_accepting
-  end
-
-  def accept_paragraph_star
-    assert_equal "reg <b>bold</b> reg\n", @to.end_accepting
-  end
-
-  def accept_paragraph_underscore
-    assert_equal "reg <em>italic</em> reg\n", @to.end_accepting
-  end
-
-  def accept_paragraph_wrap
-    expected = <<-EXPECTED
-words words words words words words words words words words words words words
-words words words words words words words words words words words words words
-words words words words
-    EXPECTED
-
-    assert_equal expected, @to.end_accepting
-  end
-
-  def accept_rule_indent
-    assert_equal "   #{'-' * 75}\n", @to.end_accepting
-  end
-
-  def accept_verbatim_indent
-    assert_equal "    hi\n     world\n\n", @to.end_accepting
-  end
-
-  def accept_verbatim_big_indent
-    assert_equal "    hi\n    world\n\n", @to.end_accepting
-  end
-
-  def list_nested
-    expected = <<-EXPECTED
-* l1
-  * l1.1
-* l2
-    EXPECTED
-
-    assert_equal expected, @to.end_accepting
-  end
-
-  def list_verbatim
-    expected = <<-EXPECTED # HACK overblown
-* list stuff
-
-    * list
-      with
-
-      second
-
-      1. indented
-      2. numbered
-
-      third
-
-    * second
-
-    EXPECTED
-
-    assert_equal expected, @to.end_accepting
-  end
-
-  def accept_table_align
-    expected = <<-EXPECTED
- AA |BB |CCCCC|DDDDD
-----|---|-----|-----
-    |bbb|    c|
-aaaa|b  |     | dd
- a  |   |   cc| dd
-    EXPECTED
-    assert_equal expected, @to.end_accepting
-  end
-
-  # functional test
-  def test_convert_list_note
-    note_list = <<-NOTE_LIST
-foo ::
-bar ::
-  hi
-    NOTE_LIST
-
-    expected = <<-EXPECTED
-foo::
-bar::
-  hi
-
-    EXPECTED
-
-    assert_equal expected, @to.convert(note_list)
-  end
-
-  def test_accept_indented_paragraph
-    ip = RDoc::Markup::IndentedParagraph.new 2, 'cats are cool'
-
-    @to.start_accepting
-
-    @to.accept_indented_paragraph ip
-
-    assert_equal "  cats are cool\n", @to.end_accepting
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc_markup_to_table_of_contents_test.rb b/test/mri/rdoc/rdoc_markup_to_table_of_contents_test.rb
deleted file mode 100644
index 3fb6fdeb427..00000000000
--- a/test/mri/rdoc/rdoc_markup_to_table_of_contents_test.rb
+++ /dev/null
@@ -1,126 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocMarkupToTableOfContentsTest < RDoc::Markup::FormatterTestCase
-
-  add_visitor_tests
-
-  def setup
-    super
-
-    @to = RDoc::Markup::ToTableOfContents.new
-  end
-
-  def end_accepting
-    assert_equal %w[hi], @to.res
-  end
-
-  def empty
-    assert_empty @to.res
-  end
-
-  def accept_heading
-    assert_equal [@RM::Heading.new(5, 'Hello')], @to.res
-  end
-
-  def accept_heading_1
-    assert_equal [@RM::Heading.new(1, 'Hello')], @to.res
-  end
-
-  def accept_heading_2
-    assert_equal [@RM::Heading.new(2, 'Hello')], @to.res
-  end
-
-  def accept_heading_3
-    assert_equal [@RM::Heading.new(3, 'Hello')], @to.res
-  end
-
-  def accept_heading_4
-    assert_equal [@RM::Heading.new(4, 'Hello')], @to.res
-  end
-
-  def accept_heading_b
-    assert_equal [@RM::Heading.new(1, '*Hello*')], @to.res
-  end
-
-  def accept_heading_suppressed_crossref
-    assert_equal [@RM::Heading.new(1, '\\Hello')], @to.res
-  end
-
-  alias accept_blank_line                             empty
-  alias accept_block_quote                            empty
-  alias accept_document                               empty
-  alias accept_list_end_bullet                        empty
-  alias accept_list_end_label                         empty
-  alias accept_list_end_lalpha                        empty
-  alias accept_list_end_note                          empty
-  alias accept_list_end_number                        empty
-  alias accept_list_end_ualpha                        empty
-  alias accept_list_item_end_bullet                   empty
-  alias accept_list_item_end_label                    empty
-  alias accept_list_item_end_lalpha                   empty
-  alias accept_list_item_end_note                     empty
-  alias accept_list_item_end_number                   empty
-  alias accept_list_item_end_ualpha                   empty
-  alias accept_list_item_start_bullet                 empty
-  alias accept_list_item_start_label                  empty
-  alias accept_list_item_start_lalpha                 empty
-  alias accept_list_item_start_note                   empty
-  alias accept_list_item_start_note_2                 empty
-  alias accept_list_item_start_note_multi_description empty
-  alias accept_list_item_start_note_multi_label       empty
-  alias accept_list_item_start_number                 empty
-  alias accept_list_item_start_ualpha                 empty
-  alias accept_list_start_bullet                      empty
-  alias accept_list_start_label                       empty
-  alias accept_list_start_lalpha                      empty
-  alias accept_list_start_note                        empty
-  alias accept_list_start_number                      empty
-  alias accept_list_start_ualpha                      empty
-  alias accept_paragraph                              empty
-  alias accept_paragraph_b                            empty
-  alias accept_paragraph_br                           empty
-  alias accept_paragraph_break                        empty
-  alias accept_paragraph_i                            empty
-  alias accept_paragraph_plus                         empty
-  alias accept_paragraph_star                         empty
-  alias accept_paragraph_underscore                   empty
-  alias accept_raw                                    empty
-  alias accept_rule                                   empty
-  alias accept_verbatim                               empty
-  alias list_nested                                   empty
-  alias list_verbatim                                 empty
-  alias start_accepting                               empty
-
-  def test_accept_document_omit_headings_below
-    document = doc
-    document.omit_headings_below = 2
-
-    @to.accept_document document
-
-    assert_equal 2, @to.omit_headings_below
-  end
-
-  def test_accept_heading_suppressed
-    @to.start_accepting
-    @to.omit_headings_below = 4
-
-    suppressed = head 5, 'Hello'
-
-    @to.accept_heading suppressed
-
-    assert_empty @to.res
-  end
-
-  def test_suppressed_eh
-    @to.omit_headings_below = nil
-
-    refute @to.suppressed? head(1, '')
-
-    @to.omit_headings_below = 1
-
-    refute @to.suppressed? head(1, '')
-    assert @to.suppressed? head(2, '')
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc_markup_to_tt_only_test.rb b/test/mri/rdoc/rdoc_markup_to_tt_only_test.rb
deleted file mode 100644
index e5dfc0be963..00000000000
--- a/test/mri/rdoc/rdoc_markup_to_tt_only_test.rb
+++ /dev/null
@@ -1,246 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocMarkupToTtOnlyTest < RDoc::Markup::FormatterTestCase
-
-  add_visitor_tests
-
-  def setup
-    super
-
-    @to = RDoc::Markup::ToTtOnly.new
-  end
-
-  def accept_blank_line
-    assert_empty @to.end_accepting
-  end
-
-  def accept_block_quote
-    assert_empty @to.end_accepting
-  end
-
-  def accept_document
-    assert_equal [], @to.res
-  end
-
-  def accept_heading
-    assert_empty @to.end_accepting
-  end
-
-  def accept_list_end_bullet
-    assert_empty @to.res
-  end
-
-  def accept_list_end_label
-    assert_empty @to.res
-  end
-
-  def accept_list_end_lalpha
-    assert_empty @to.res
-  end
-
-  def accept_list_end_note
-    assert_empty @to.res
-  end
-
-  def accept_list_end_number
-    assert_empty @to.res
-  end
-
-  def accept_list_end_ualpha
-    assert_empty @to.res
-  end
-
-  def accept_list_item_end_bullet
-    assert_empty @to.res
-  end
-
-  def accept_list_item_end_label
-    assert_empty @to.res
-  end
-
-  def accept_list_item_end_lalpha
-    assert_empty @to.res
-  end
-
-  def accept_list_item_end_note
-    assert_empty @to.res
-  end
-
-  def accept_list_item_end_number
-    assert_empty @to.res
-  end
-
-  def accept_list_item_end_ualpha
-    assert_empty @to.res
-  end
-
-  def accept_list_item_start_bullet
-    assert_empty @to.res
-  end
-
-  def accept_list_item_start_label
-    assert_empty @to.res
-  end
-
-  def accept_list_item_start_lalpha
-    assert_empty @to.res
-  end
-
-  def accept_list_item_start_note
-    assert_empty @to.res
-  end
-
-  def accept_list_item_start_number
-    assert_empty @to.res
-  end
-
-  def accept_list_item_start_ualpha
-    assert_empty @to.res
-  end
-
-  def accept_list_start_bullet
-    assert_empty @to.res
-  end
-
-  def accept_list_start_label
-    assert_empty @to.res
-  end
-
-  def accept_list_start_lalpha
-    assert_empty @to.res
-  end
-
-  def accept_list_start_note
-    assert_empty @to.res
-  end
-
-  def accept_list_start_number
-    assert_empty @to.res
-  end
-
-  def accept_list_start_ualpha
-    assert_empty @to.res
-  end
-
-  def accept_paragraph
-    assert_empty @to.end_accepting
-  end
-
-  def accept_paragraph_break
-    assert_empty @to.end_accepting
-  end
-
-  def accept_raw
-    assert_empty @to.end_accepting
-  end
-
-  def accept_rule
-    assert_empty @to.end_accepting
-  end
-
-  def accept_verbatim
-    assert_empty @to.end_accepting
-  end
-
-  def end_accepting
-    assert_equal %w[hi], @to.end_accepting
-  end
-
-  def start_accepting
-    assert_empty @to.end_accepting
-  end
-
-  def accept_heading_1
-    assert_empty @to.end_accepting
-  end
-
-  def accept_heading_2
-    assert_empty @to.end_accepting
-  end
-
-  def accept_heading_3
-    assert_empty @to.end_accepting
-  end
-
-  def accept_heading_4
-    assert_empty @to.end_accepting
-  end
-
-  def accept_heading_indent
-    assert_empty @to.end_accepting
-  end
-
-  def accept_heading_b
-    assert_empty @to.end_accepting
-  end
-
-  def accept_heading_suppressed_crossref
-    assert_empty @to.end_accepting
-  end
-
-  def accept_list_item_start_note_2
-    assert_equal [nil, 'teletype', nil], @to.res
-  end
-
-  def accept_list_item_start_note_multi_description
-    assert_empty @to.res
-  end
-
-  def accept_list_item_start_note_multi_label
-    assert_empty @to.res
-  end
-
-  def accept_paragraph_b
-    assert_empty @to.end_accepting
-  end
-
-  def accept_paragraph_br
-    assert_empty @to.end_accepting
-  end
-
-  def accept_paragraph_i
-    assert_empty @to.end_accepting
-  end
-
-  def accept_paragraph_indent
-    assert_empty @to.end_accepting
-  end
-
-  def accept_paragraph_plus
-    assert_equal %w[teletype], @to.end_accepting
-  end
-
-  def accept_paragraph_star
-    assert_empty @to.end_accepting
-  end
-
-  def accept_paragraph_underscore
-    assert_empty @to.end_accepting
-  end
-
-  def accept_paragraph_wrap
-    assert_empty @to.end_accepting
-  end
-
-  def accept_rule_indent
-    assert_empty @to.end_accepting
-  end
-
-  def accept_verbatim_indent
-    assert_empty @to.end_accepting
-  end
-
-  def accept_verbatim_big_indent
-    assert_empty @to.end_accepting
-  end
-
-  def list_nested
-    assert_empty @to.end_accepting
-  end
-
-  def list_verbatim
-    assert_empty @to.end_accepting
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc_markup_verbatim_test.rb b/test/mri/rdoc/rdoc_markup_verbatim_test.rb
deleted file mode 100644
index 910095c9ab4..00000000000
--- a/test/mri/rdoc/rdoc_markup_verbatim_test.rb
+++ /dev/null
@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocMarkupVerbatimTest < RDoc::TestCase
-
-  def test_equals2
-    v1 = verb('1 + 1')
-    v2 = verb('1 + 1')
-    v3 = verb('1 + 2')
-    v4 = verb('1 + 1')
-    v4.format = :ruby
-
-    assert_equal v1, v2
-
-    refute_equal v1, v3
-    refute_equal v1, v4
-  end
-
-  def test_ruby_eh
-    verbatim = RDoc::Markup::Verbatim.new
-
-    refute verbatim.ruby?
-
-    verbatim.format = :ruby
-
-    assert verbatim.ruby?
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc_method_attr_test.rb b/test/mri/rdoc/rdoc_method_attr_test.rb
deleted file mode 100644
index 54a2a0d395b..00000000000
--- a/test/mri/rdoc/rdoc_method_attr_test.rb
+++ /dev/null
@@ -1,210 +0,0 @@
-# frozen_string_literal: true
-require_relative 'xref_test_case'
-
-class RDocMethodAttrTest < XrefTestCase
-
-  def test_initialize_copy
-    refute_same @c1_m.full_name, @c1_m.dup.full_name
-  end
-
-  def test_block_params_equal
-    m = RDoc::MethodAttr.new(nil, 'foo')
-
-    m.block_params = ''
-    assert_equal '', m.block_params
-
-    m.block_params = 'a_var'
-    assert_equal 'a_var', m.block_params
-
-    m.block_params = '()'
-    assert_equal '', m.block_params
-
-    m.block_params = '(a_var, b_var)'
-    assert_equal 'a_var, b_var', m.block_params
-
-    m.block_params = '.to_s + "</#{element.upcase}>"'
-    assert_equal '', m.block_params
-
-    m.block_params = 'i.name'
-    assert_equal 'name', m.block_params
-
-    m.block_params = 'attr.expanded_name, attr.value'
-    assert_equal 'expanded_name, value', m.block_params
-
-    m.block_params = 'expanded_name, attr.value'
-    assert_equal 'expanded_name, value', m.block_params
-
-    m.block_params = 'attr.expanded_name, value'
-    assert_equal 'expanded_name, value', m.block_params
-
-    m.block_params = '(@base_notifier)'
-    assert_equal 'base_notifier', m.block_params
-
-    m.block_params = 'if @signal_status == :IN_LOAD'
-    assert_equal '', m.block_params
-
-    m.block_params = 'e if e.kind_of? Element'
-    assert_equal 'e', m.block_params
-
-    m.block_params = '(e, f) if e.kind_of? Element'
-    assert_equal 'e, f', m.block_params
-
-    m.block_params = 'back_path, back_name'
-    assert_equal 'back_path, back_name', m.block_params
-
-    m.block_params = '(*a[1..-1])'
-    assert_equal '*a', m.block_params
-
-    m.block_params = '@@context[:node] if defined? @@context[:node].namespace'
-    assert_equal 'context', m.block_params
-
-    m.block_params = '(result, klass.const_get(constant_name))'
-    assert_equal 'result, const', m.block_params
-
-    m.block_params = 'name.to_s if (bitmap & bit) != 0'
-    assert_equal 'name', m.block_params
-
-    m.block_params = 'line unless line.deleted'
-    assert_equal 'line', m.block_params
-
-    m.block_params = 'str + rs'
-    assert_equal 'str', m.block_params
-
-    m.block_params = 'f+rs'
-    assert_equal 'f', m.block_params
-
-    m.block_params = '[user, realm, hash[user]]'
-    assert_equal 'user, realm, hash', m.block_params
-
-    m.block_params = 'proc{|rc| rc == "rc" ? irbrc : irbrc+rc| ... }'
-    assert_equal 'proc', m.block_params
-
-    m.block_params = 'lambda { |x| x.to_i }'
-    assert_equal 'lambda', m.block_params
-
-    m.block_params = '$&'
-    assert_equal 'str', m.block_params
-
-    m.block_params = 'Inflections.instance'
-    assert_equal 'instance', m.block_params
-
-    m.block_params = 'self.class::STARTED'
-    assert_equal 'STARTED', m.block_params
-
-    m.block_params = 'Test::Unit::TestCase::STARTED'
-    assert_equal 'STARTED', m.block_params
-
-    m.block_params = 'ActiveSupport::OptionMerger.new(self, options)'
-    assert_equal 'option_merger', m.block_params
-
-    m.block_params = ', msg'
-    assert_equal '', m.block_params
-
-    m.block_params = '[size.to_s(16), term, chunk, term].join'
-    assert_equal '[size, term, chunk, term].join', m.block_params
-
-    m.block_params = 'YPath.new( path )'
-    assert_equal 'y_path', m.block_params
-
-  end
-
-  def test_find_method_or_attribute_recursive
-    inc = RDoc::Include.new 'M1', nil
-    @m1.add_include inc # M1 now includes itself
-
-    assert_nil @m1_m.find_method_or_attribute 'm'
-  end
-
-  def test_full_name
-    assert_equal 'C1#m',  @c1_m.full_name
-    assert_equal 'C1::m', @c1__m.full_name
-  end
-
-  def test_is_alias_for
-    assert_equal @c2_b, @c2_a.is_alias_for
-  end
-
-  def test_search_record
-    @c1_m.comment = 'This is a comment.'
-
-    expected = [
-      'm',
-      'C1#m',
-      'm',
-      'C1',
-      'C1.html#method-i-m',
-      '(foo)',
-      "<p>This is a comment.\n",
-    ]
-
-    assert_equal expected, @c1_m.search_record
-  end
-
-  def test_spaceship_returns_nil_on_inappropriate_types
-    assert_nil @c1_m.<=>(RDoc::CodeObject.new)
-  end
-
-  def test_spaceship_orders_symbols_first
-    # in the desired sort order
-    m_plus       = RDoc::AnyMethod.new nil, '+'
-    m_eqeq       = RDoc::AnyMethod.new nil, '=='
-    m_bracket    = RDoc::AnyMethod.new nil, '[]'
-    m_caret      = RDoc::AnyMethod.new nil, '^'
-    m_bar        = RDoc::AnyMethod.new nil, '|'
-    m_tilde      = RDoc::AnyMethod.new nil, '~'
-    m_Alpha      = RDoc::AnyMethod.new nil, 'Alpha'
-    m_Zero       = RDoc::AnyMethod.new nil, 'Zero'
-    m_alpha      = RDoc::AnyMethod.new nil, 'alpha'
-    m_zero       = RDoc::AnyMethod.new nil, 'zero'
-    m_konnichiwa = RDoc::AnyMethod.new nil, 'こんにちは'
-
-    assert_equal(-1, m_plus <=> m_eqeq)
-    assert_equal(-1, m_eqeq <=> m_bracket)
-    assert_equal(-1, m_bracket <=> m_caret)
-    assert_equal(-1, m_caret <=> m_bar)
-    assert_equal(-1, m_bar <=> m_tilde)
-    assert_equal(-1, m_tilde <=> m_Alpha)
-    assert_equal(-1, m_Alpha <=> m_Zero)
-    assert_equal(-1, m_Zero <=> m_alpha)
-    assert_equal(-1, m_alpha <=> m_zero)
-    assert_equal(-1, m_zero <=> m_konnichiwa)
-  end
-
-  def test_equals2
-    assert_equal @c1_m, @c1_m
-    refute_equal @c1_m, @parent_m
-  end
-
-  def test_pretty_print
-    temp_dir do |tmpdir|
-      s = RDoc::RI::Store.new(RDoc::Options.new, path: tmpdir)
-
-      top_level = s.add_file 'file.rb'
-      meth_bang = RDoc::AnyMethod.new nil, 'method!'
-      meth_bang.record_location top_level
-
-      meth_bang_alias = RDoc::Alias.new nil, 'method!', 'method_bang', ''
-      meth_bang_alias.record_location top_level
-
-      klass = top_level.add_class RDoc::NormalClass, 'Object'
-      klass.add_method meth_bang
-
-      meth_bang.add_alias meth_bang_alias, klass
-
-      s.save
-
-      meth_alias_from_store = s.load_method 'Object', '#method_bang'
-
-      expected = "[RDoc::AnyMethod Object#method_bang public alias for method!]"
-      actual =  mu_pp meth_alias_from_store
-      assert_equal expected, actual
-    end
-  end
-
-  def test_to_s
-    assert_equal 'RDoc::AnyMethod: C1#m',  @c1_m.to_s
-    assert_equal 'RDoc::AnyMethod: C2#b',  @c2_b.to_s
-    assert_equal 'RDoc::AnyMethod: C1::m', @c1__m.to_s
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc_normal_class_test.rb b/test/mri/rdoc/rdoc_normal_class_test.rb
deleted file mode 100644
index d61ef5ccd92..00000000000
--- a/test/mri/rdoc/rdoc_normal_class_test.rb
+++ /dev/null
@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-require_relative 'xref_test_case'
-
-class RDocNormalClassTest < XrefTestCase
-
-  def test_ancestors
-    klass = @top_level.add_class RDoc::NormalClass, 'Klass'
-    incl = RDoc::Include.new 'Incl', ''
-
-    sub_klass = @top_level.add_class RDoc::NormalClass, 'SubClass'
-    sub_klass.superclass = klass
-    sub_klass.add_include incl
-
-    assert_equal [incl.name, klass, @object, 'BasicObject'], sub_klass.ancestors
-  end
-
-  def test_ancestors_multilevel
-    c1 = @top_level.add_class RDoc::NormalClass, 'Outer'
-    c2 = @top_level.add_class RDoc::NormalClass, 'Middle', c1.full_name
-    c3 = @top_level.add_class RDoc::NormalClass, 'Inner', c2.full_name
-
-    assert_equal [c2, c1, @object, 'BasicObject'], c3.ancestors
-  end
-
-  def test_aref
-    assert_equal 'class-C1',     @c1.aref
-    assert_equal 'class-C2::C3', @c2_c3.aref
-  end
-
-  def test_direct_ancestors
-    incl = RDoc::Include.new 'Incl', ''
-
-    c1 = @top_level.add_class RDoc::NormalClass, 'Outer'
-    c2 = @top_level.add_class RDoc::NormalClass, 'Middle', c1.full_name
-    c3 = @top_level.add_class RDoc::NormalClass, 'Inner', c2.full_name
-    c3.add_include incl
-
-    assert_equal [incl.name, c2], c3.direct_ancestors
-  end
-
-  def test_definition
-    c = RDoc::NormalClass.new 'C'
-
-    assert_equal 'class C', c.definition
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc_normal_module_test.rb b/test/mri/rdoc/rdoc_normal_module_test.rb
deleted file mode 100644
index bb0a2afc768..00000000000
--- a/test/mri/rdoc/rdoc_normal_module_test.rb
+++ /dev/null
@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-require_relative 'xref_test_case'
-
-class RDocNormalModuleTest < XrefTestCase
-
-  def setup
-    super
-
-    @mod = RDoc::NormalModule.new 'Mod'
-  end
-
-  def test_ancestors_module
-    top_level = @store.add_file 'file.rb'
-    mod = top_level.add_module RDoc::NormalModule, 'Mod'
-    incl = RDoc::Include.new 'Incl', ''
-
-    mod.add_include incl
-
-    assert_equal [incl.name], mod.ancestors
-
-    mod2 = top_level.add_module RDoc::NormalModule, 'Inc2'
-    inc2 = RDoc::Include.new 'Inc2', ''
-    mod.add_include inc2
-    assert_equal [mod2, incl.name], mod.ancestors
-  end
-
-  def test_aref
-    assert_equal 'module-M1',     @m1.aref
-    assert_equal 'module-M1::M2', @m1_m2.aref
-  end
-
-  def test_definition
-    m = RDoc::NormalModule.new 'M'
-
-    assert_equal 'module M', m.definition
-  end
-
-  def test_module_eh
-    assert @mod.module?
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc_options_test.rb b/test/mri/rdoc/rdoc_options_test.rb
deleted file mode 100644
index 097d0f5523c..00000000000
--- a/test/mri/rdoc/rdoc_options_test.rb
+++ /dev/null
@@ -1,975 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocOptionsTest < RDoc::TestCase
-
-  def setup
-    super
-
-    @options = RDoc::Options.new
-    @generators = RDoc::RDoc::GENERATORS.dup
-  end
-
-  def teardown
-    super
-
-    RDoc::RDoc::GENERATORS.replace @generators
-  end
-
-  def test_check_files
-    omit "assumes UNIX permission model" if /mswin|mingw/ =~ RUBY_PLATFORM
-    omit "assumes that euid is not root" if Process.euid == 0
-
-    out, err = capture_output do
-      temp_dir do
-        FileUtils.touch 'unreadable'
-        FileUtils.chmod 0, 'unreadable'
-
-        @options.files = %w[nonexistent unreadable]
-
-        @options.check_files
-      end
-    end
-
-    assert_empty @options.files
-
-    assert_empty out
-    assert_empty err
-  end
-
-  def test_check_files_warn
-    @options.verbosity = 2
-
-    out, err = verbose_capture_output do
-      @options.files = %w[nonexistent]
-
-      @options.check_files
-    end
-
-    assert_empty out
-    assert_equal "file 'nonexistent' not found\n", err
-    assert_empty @options.files
-  end
-
-  def test_dry_run_default
-    refute @options.dry_run
-  end
-
-  def test_to_yaml
-    RDoc.load_yaml
-
-    coder = YAML.load(@options.to_yaml)
-
-    encoding = 'UTF-8'
-
-    expected = {
-      'charset'               => 'UTF-8',
-      'encoding'              => encoding,
-      'embed_mixins'          => false,
-      'exclude'               => [],
-      'hyperlink_all'         => false,
-      'line_numbers'          => false,
-      'locale_dir'            => 'locale',
-      'locale_name'           => nil,
-      'main_page'             => nil,
-      'markup'                => 'rdoc',
-      'output_decoration'     => true,
-      'page_dir'              => nil,
-      'rdoc_include'          => [],
-      'show_hash'             => false,
-      'static_path'           => [],
-      'tab_width'             => 8,
-      'template_stylesheets'  => [],
-      'title'                 => nil,
-      'visibility'            => :protected,
-      'warn_missing_rdoc_ref' => true,
-      'webcvs'                => nil,
-      'skip_tests'            => true,
-      'apply_default_exclude' => true,
-      'autolink_excluded_words' => [],
-      'class_module_path_prefix' => nil,
-      'file_path_prefix' => nil,
-      'canonical_root' => nil,
-    }
-
-    assert_equal expected, coder
-  end
-
-  def test_to_yaml_trim_paths
-    RDoc.load_yaml
-
-    subdir = nil
-    coder = nil
-
-    temp_dir do |dir|
-      FileUtils.mkdir 'project'
-      FileUtils.mkdir 'dir'
-      FileUtils.touch 'file'
-
-      Dir.chdir 'project' do
-        subdir = File.expand_path 'subdir'
-        FileUtils.mkdir 'subdir'
-        @options.parse %w[
-          --copy subdir
-          --copy ../file
-          --copy ../
-          --copy /
-          --include subdir
-          --include ../dir
-          --include ../
-          --include /
-        ]
-
-        coder = YAML.load(@options.to_yaml)
-      end
-    end
-
-    assert_equal [subdir], coder['rdoc_include']
-
-    assert_equal [subdir], coder['static_path']
-  end
-
-  def test_encoding_default
-    assert_equal Encoding::UTF_8, @options.encoding
-  end
-
-  def test_generator_descriptions
-    # HACK autotest/isolate should take care of this
-    RDoc::RDoc::GENERATORS.clear
-    RDoc::RDoc::GENERATORS['darkfish'] = RDoc::Generator::Darkfish
-    RDoc::RDoc::GENERATORS['ri']       = RDoc::Generator::RI
-
-    expected = <<-EXPECTED.chomp
-  darkfish - HTML generator, written by Michael Granger
-  ri       - creates ri data files
-    EXPECTED
-
-    assert_equal expected, @options.generator_descriptions
-  end
-
-  def test_init_with_encoding
-    RDoc.load_yaml
-
-    @options.encoding = Encoding::IBM437
-
-    options = @options.to_yaml
-    options = YAML.safe_load(options, permitted_classes: [Symbol])
-    options = RDoc::Options.new(options)
-
-    assert_equal Encoding::IBM437, options.encoding
-  end
-
-  def test_init_with_trim_paths
-    RDoc.load_yaml
-
-    yaml = <<-YAML
----
-static_path:
-- /etc
-rdoc_include:
-- /etc
-    YAML
-
-    options = YAML.safe_load(yaml, permitted_classes: [Symbol])
-    options = RDoc::Options.new(options)
-
-    assert_empty options.rdoc_include
-    assert_empty options.static_path
-  end
-
-  def test_parse_copy_files_file_relative
-    file = File.basename __FILE__
-    expected = File.expand_path __FILE__
-
-    Dir.chdir File.expand_path('..', __FILE__) do
-      @options.parse %W[--copy-files #{file}]
-
-      assert_equal [expected], @options.static_path
-    end
-  end
-
-  def test_parse_copy_files_file_absolute
-    @options.parse %W[--copy-files #{File.expand_path __FILE__}]
-
-    assert_equal [File.expand_path(__FILE__)], @options.static_path
-  end
-
-  def test_parse_copy_files_directory_relative
-    @options.parse %w[--copy-files .]
-
-    assert_equal [@pwd], @options.static_path
-  end
-
-  def test_parse_copy_files_directory_absolute
-    @options.parse %w[--copy-files /]
-
-    assert_equal 1, @options.static_path.length
-
-    assert_match %r%^([A-Z]:)?/$%i, @options.static_path.first
-  end
-
-  def test_parse_coverage
-    @options.parse %w[--dcov]
-
-    assert @options.coverage_report
-    assert @options.force_update
-  end
-
-  def test_parse_coverage_C
-    @options.parse %w[-C]
-
-    assert @options.coverage_report
-    assert @options.force_update
-  end
-
-  def test_parse_coverage_no
-    @options.parse %w[--no-dcov]
-
-    refute @options.coverage_report
-  end
-
-  def test_parse_coverage_level_1
-    @options.parse %w[--dcov=1]
-
-    assert_equal 1, @options.coverage_report
-  end
-
-  def test_parse_coverage_C_level_1
-    @options.parse %w[-C1]
-
-    assert_equal 1, @options.coverage_report
-  end
-
-  def test_parse_coverage_C_level_0
-    @options.parse %w[-C0]
-
-    assert_equal 0, @options.coverage_report
-    assert @options.force_update
-  end
-
-  def test_parse_dash_p
-    out, err = capture_output do
-      @options.parse %w[-p]
-    end
-
-    assert @options.pipe
-    refute_match %r%^Usage: %, err
-    refute_match %r%^invalid options%, err
-
-    assert_empty out
-  end
-
-  def test_parse_dash_p_files
-    out, err = capture_output do
-      @options.parse ['-p', File.expand_path(__FILE__)]
-    end
-
-    refute @options.pipe
-    refute_match %r%^Usage: %, err
-    assert_match %r%^invalid options: -p .with files.%, err
-
-    assert_empty out
-  end
-
-  def test_parse_default
-    @options.parse []
-    @options.finish
-
-    assert_equal RDoc::Generator::Darkfish,             @options.generator
-    assert_equal 'darkfish',                            @options.template
-    assert_match %r%rdoc/generator/template/darkfish$%, @options.template_dir
-  end
-
-  def test_parse_deprecated
-    dep_hash = RDoc::Options::DEPRECATED
-    options = dep_hash.keys.sort
-
-    out, err = capture_output do
-      @options.parse options
-    end
-
-    dep_hash.each_pair do |opt, message|
-      assert_match %r%.*#{opt}.+#{message}%, err
-    end
-
-    assert_empty out
-  end
-
-  def test_parse_dry_run
-    @options.parse %w[--dry-run]
-
-    assert @options.dry_run
-  end
-
-  def test_parse_encoding
-    @options.parse %w[--encoding Big5]
-
-    assert_equal Encoding::Big5, @options.encoding
-    assert_equal 'Big5',         @options.charset
-  end
-
-  def test_parse_encoding_invalid
-    out, err = capture_output do
-      @options.parse %w[--encoding invalid]
-    end
-
-    assert_match %r%^invalid options: --encoding invalid%, err
-
-    assert_empty out
-  end
-
-  def test_parse_formatter
-    e = assert_raise OptionParser::InvalidOption do
-      @options.parse %w[--format darkfish --format ri]
-    end
-
-    assert_equal 'invalid option: --format generator already set to darkfish',
-                 e.message
-  end
-
-  def test_parse_force_update
-    @options.parse %w[--force-update]
-
-    assert @options.force_update
-
-    @options.parse %w[--no-force-update]
-
-    assert !@options.force_update
-
-    @options.parse %w[-U]
-
-    assert @options.force_update
-  end
-
-  def test_parse_formatter_ri
-    e = assert_raise OptionParser::InvalidOption do
-      @options.parse %w[--format darkfish --ri]
-    end
-
-    assert_equal 'invalid option: --ri generator already set to darkfish',
-                 e.message
-
-    @options = RDoc::Options.new
-
-    e = assert_raise OptionParser::InvalidOption do
-      @options.parse %w[--format darkfish -r]
-    end
-
-    assert_equal 'invalid option: -r generator already set to darkfish',
-                 e.message
-  end
-
-  def test_parse_formatter_ri_site
-    e = assert_raise OptionParser::InvalidOption do
-      @options.parse %w[--format darkfish --ri-site]
-    end
-
-    assert_equal 'invalid option: --ri-site generator already set to darkfish',
-                 e.message
-
-    @options = RDoc::Options.new
-
-    e = assert_raise OptionParser::InvalidOption do
-      @options.parse %w[--format darkfish -R]
-    end
-
-    assert_equal 'invalid option: -R generator already set to darkfish',
-                 e.message
-  end
-
-  def test_parse_h
-    out, = capture_output do
-      begin
-        @options.parse %w[-h]
-      rescue SystemExit
-      end
-    end
-
-    assert_equal 1, out.scan(/HTML generator options:/).length
-    assert_equal 1, out.scan(/ri generator options:/).  length
-  end
-
-  def test_parse_help
-    out, = capture_output do
-      begin
-        @options.parse %w[--help]
-      rescue SystemExit
-      end
-    end
-
-    assert_equal 1, out.scan(/HTML generator options:/).length
-    assert_equal 1, out.scan(/ri generator options:/).  length
-  end
-
-  def test_parse_help_extra_generator
-    RDoc::RDoc::GENERATORS['test'] = Class.new do
-      def self.setup_options(options)
-        op = options.option_parser
-
-        op.separator 'test generator options:'
-      end
-    end
-
-    out, = capture_output do
-      begin
-        @options.parse %w[--help]
-      rescue SystemExit
-      end
-    end
-
-    assert_equal 1, out.scan(/HTML generator options:/).length
-    assert_equal 1, out.scan(/ri generator options:/).  length
-    assert_equal 1, out.scan(/test generator options:/).length
-  end
-
-  def test_parse_format_for_extra_generator
-    RDoc::RDoc::GENERATORS['test'] = Class.new do
-      def self.setup_options(options)
-        op = options.option_parser
-
-        op.separator 'test generator options:'
-      end
-    end
-
-    @options.setup_generator 'test'
-
-    assert_equal @options.generator_name, 'test'
-  end
-
-  def test_parse_ignore_invalid
-    out, err = capture_output do
-      @options.parse %w[--ignore-invalid --bogus]
-    end
-
-    refute_match %r%^Usage: %, err
-    assert_match %r%^invalid options: --bogus%, err
-
-    assert_empty out
-  end
-
-  def test_parse_ignore_invalid_default
-    out, err = capture_output do
-      @options.parse %w[--bogus --main BLAH]
-    end
-
-    refute_match %r%^Usage: %, err
-    assert_match %r%^invalid options: --bogus%, err
-
-    assert_equal 'BLAH', @options.main_page
-
-    assert_empty out
-  end
-
-  def test_parse_ignore_invalid_no
-    out, err = capture_output do
-      assert_raise SystemExit do
-        @options.parse %w[--no-ignore-invalid --bogus=arg --bobogus --visibility=extended]
-      end
-    end
-
-    assert_match %r%^Usage: %, err
-    assert_match %r%^invalid options: --bogus=arg, --bobogus, --visibility=extended%, err
-
-    assert_empty out
-  end
-
-  def test_parse_ignore_invalid_no_quiet
-    out, err = capture_output do
-      assert_raise SystemExit do
-        @options.parse %w[--quiet --no-ignore-invalid --bogus=arg --bobogus --visibility=extended]
-      end
-    end
-
-    refute_match %r%^Usage: %, err
-    assert_match %r%^invalid options: --bogus=arg, --bobogus, --visibility=extended%, err
-
-    assert_empty out
-  end
-
-  def test_ignore_needless_arg
-    out, err = capture_output do
-      @options.parse %w[--ri=foo]
-    end
-
-    assert_match %r%^invalid options: --ri=foo%, err
-
-    assert_empty out
-  end
-
-  def test_ignore_missing_arg
-    out, err = capture_output do
-      @options.parse %w[--copy-files]
-    end
-
-    assert_match %r%^invalid options: --copy-files%, err
-
-    assert_empty out
-  end
-
-  def test_parse_main
-    out, err = capture_output do
-      @options.parse %w[--main MAIN]
-    end
-
-    assert_empty out
-    assert_empty err
-
-    assert_equal 'MAIN', @options.main_page
-  end
-
-  def test_parse_markup
-    out, err = capture_output do
-      @options.parse %w[--markup tomdoc]
-    end
-
-    assert_empty out
-    assert_empty err
-
-    assert_equal 'tomdoc', @options.markup
-  end
-
-  def test_parse_page_dir
-    assert_nil @options.page_dir
-
-    out, err = capture_output do
-      @options.parse %W[--page-dir #{Dir.tmpdir}]
-      @options.finish
-    end
-
-    assert_empty out
-    assert_empty err
-
-    expected = nil
-    begin
-      expected =
-        Pathname(Dir.tmpdir).expand_path.relative_path_from @options.root
-    rescue ArgumentError
-      # On Windows, sometimes crosses different drive letters.
-      expected = Pathname(Dir.tmpdir).expand_path
-    end
-
-    assert_equal expected,     @options.page_dir
-    assert_equal [Dir.tmpdir], @options.files
-  end
-
-  def test_parse_page_dir_root
-    assert_nil @options.page_dir
-
-    Dir.mktmpdir do |dir|
-      abs_root     = dir
-      abs_page_dir = File.join dir, 'pages'
-      FileUtils.mkdir abs_page_dir
-
-      out, err = capture_output do
-        @options.parse %W[--page-dir #{abs_page_dir} --root #{abs_root}]
-        @options.finish
-      end
-
-      assert_empty out
-      assert_empty err
-
-      assert_equal Pathname('pages'), @options.page_dir
-      assert_equal [abs_page_dir],    @options.files
-    end
-  end
-
-  def test_parse_ri_site
-    @options.parse %w[--ri-site]
-
-    assert_equal RDoc::Generator::RI,      @options.generator
-    assert_equal RDoc::RI::Paths.site_dir, @options.op_dir
-  end
-
-  def test_parse_root
-    assert_equal Pathname(Dir.pwd), @options.root
-
-    out, err = capture_output do
-      @options.parse %W[--root #{Dir.tmpdir}]
-    end
-
-    assert_empty out
-    assert_empty err
-
-    assert_equal Pathname(Dir.tmpdir), @options.root
-
-    @options.finish
-    assert_includes @options.rdoc_include, @options.root.to_s
-  end
-
-  def test_parse_embed_mixins
-    assert_false(@options.embed_mixins)
-
-    out, err = capture_output { @options.parse(["--embed-mixins"]) }
-    assert_empty(out)
-    assert_empty(err)
-    assert_true(@options.embed_mixins)
-
-    out, err = capture_output { @options.parse(["--no-embed-mixins"]) }
-    assert_empty(out)
-    assert_empty(err)
-    assert_false(@options.embed_mixins)
-  end
-
-  def test_parse_tab_width
-    @options.parse %w[--tab-width=1]
-    assert_equal 1, @options.tab_width
-
-    @options.parse %w[-w2]
-    assert_equal 2, @options.tab_width
-
-    _, err = capture_output do
-      @options.parse %w[-w=2]
-    end
-
-    assert_match 'invalid options', err
-
-    _, err = capture_output do
-      @options.parse %w[-w0]
-    end
-
-    assert_match 'invalid options', err
-  end
-
-  def test_parse_template
-    out, err = capture_output do
-      @options.parse %w[--template darkfish]
-    end
-
-    assert_empty out
-    assert_empty err
-
-    assert_equal 'darkfish', @options.template
-
-    assert_match %r%rdoc/generator/template/darkfish$%, @options.template_dir
-  end
-
-  def test_parse_template_nonexistent
-    out, err = capture_output do
-      @options.parse %w[--template NONEXISTENT]
-    end
-
-    assert_empty out
-    assert_equal "could not find template NONEXISTENT\n", err
-
-    @options.finish
-    assert_equal 'darkfish', @options.template
-    assert_match %r%rdoc/generator/template/darkfish$%, @options.template_dir
-  end
-
-  def test_parse_template_load_path
-    orig_LOAD_PATH = $LOAD_PATH.dup
-
-    template_dir = nil
-
-    Dir.mktmpdir do |dir|
-      $LOAD_PATH << dir
-
-      template_dir = File.join dir, 'rdoc', 'generator', 'template', 'load_path'
-
-      FileUtils.mkdir_p template_dir
-
-      out, err = capture_output do
-        @options.parse %w[--template load_path]
-      end
-
-      assert_empty out
-      assert_empty err
-    end
-
-    assert_equal 'load_path',  @options.template
-    assert_equal template_dir, @options.template_dir
-  ensure
-    $LOAD_PATH.replace orig_LOAD_PATH
-  end
-
-  def test_parse_template_stylesheets
-    css = nil
-    Dir.mktmpdir do |dir|
-      css = File.join(dir, "hoge.css")
-      File.write(css, "")
-      out, err = capture_output do
-        @options.parse %W[--template-stylesheets #{css}]
-      end
-
-      assert_empty out
-      assert_empty err
-    end
-    assert_include @options.template_stylesheets, css
-  end
-
-  def test_parse_visibility
-    @options.parse %w[--visibility=public]
-    assert_equal :public, @options.visibility
-
-    @options.parse %w[--visibility=protected]
-    assert_equal :protected, @options.visibility
-
-    @options.parse %w[--visibility=private]
-    assert_equal :private, @options.visibility
-
-    @options.parse %w[--visibility=nodoc]
-    assert_equal :nodoc, @options.visibility
-  end
-
-  def test_parse_write_options
-    tmpdir = File.join Dir.tmpdir, "test_rdoc_options_#{$$}"
-    FileUtils.mkdir_p tmpdir
-
-    Dir.chdir tmpdir do
-      e = assert_raise SystemExit do
-        @options.parse %w[--write-options]
-        @options.finish
-      end
-
-      assert_equal 0, e.status
-
-      assert File.exist? '.rdoc_options'
-    end
-  ensure
-    FileUtils.rm_rf tmpdir
-  end
-
-  def test_parse_extension_alias
-    out, err = capture_output do
-      @options.parse %w[--extension foobar=rdoc]
-    end
-
-    assert_includes RDoc::Parser.parsers, [/\.foobar$/, RDoc::Parser::Simple]
-
-    assert_empty out
-    assert_empty err
-  end
-
-  def test_parse_locale_name_default
-    temp_dir do
-      @options.parse %w[]
-      assert_equal 'locale', @options.instance_variable_get(:@locale_dir)
-      assert_nil @options.instance_variable_get(:@locale_name)
-      assert_nil @options.locale
-      @options.finish
-      assert_nil @options.locale
-    end
-  end
-
-  def test_parse_locale_name
-    temp_dir do
-      @options.parse %w[--locale fr]
-      assert_equal 'locale', @options.instance_variable_get(:@locale_dir)
-      assert_equal 'fr', @options.instance_variable_get(:@locale_name)
-      assert_nil @options.locale
-      @options.finish
-      assert_equal 'fr', @options.locale.name
-    end
-  end
-
-  def test_setup_generator
-    test_generator = Class.new do
-      def self.setup_options(op)
-        @op = op
-      end
-
-      def self.op() @op end
-    end
-
-    RDoc::RDoc::GENERATORS['test'] = test_generator
-
-    @options.setup_generator 'test'
-
-    assert_equal test_generator, @options.generator
-    assert_equal [test_generator], @options.generator_options
-
-    assert_equal @options, test_generator.op
-  ensure
-    RDoc::RDoc::GENERATORS.delete 'test'
-  end
-
-  def test_setup_generator_no_option_parser
-    test_generator = Class.new do
-      def self.setup_options(op)
-        op.option_parser.separator nil
-        @op = op
-      end
-
-      def self.op() @op end
-    end
-
-    RDoc::RDoc::GENERATORS['test'] = test_generator
-
-    @options.setup_generator 'test'
-
-    assert_equal test_generator, @options.generator
-    assert_equal [test_generator], @options.generator_options
-
-    assert_equal @options, test_generator.op
-  ensure
-    RDoc::RDoc::GENERATORS.delete 'test'
-  end
-
-  def test_update_output_dir
-    assert @options.update_output_dir
-
-    @options.update_output_dir = false
-
-    refute @options.update_output_dir
-  end
-
-  def test_warn
-    out, err = capture_output do
-      @options.warn "warnings off"
-    end
-
-    assert_empty out
-    assert_empty err
-
-    @options.verbosity = 2
-
-    out, err = verbose_capture_output do
-      @options.warn "warnings on"
-    end
-
-    assert_empty out
-    assert_equal "warnings on\n", err
-  end
-
-  def test_write_options
-    temp_dir do |dir|
-      @options.write_options
-
-      assert File.exist? '.rdoc_options'
-
-      options = File.read('.rdoc_options')
-      options = YAML.safe_load(options, permitted_classes: [Symbol])
-      assert_equal @options, RDoc::Options.new(options)
-    end
-  end
-
-  def test_version
-    out, _ = capture_output do
-      begin
-        @options.parse %w[--version]
-      rescue SystemExit
-      end
-    end
-
-    assert out.include?(RDoc::VERSION)
-
-    out, _ = capture_output do
-      begin
-        @options.parse %w[-v]
-      rescue SystemExit
-      end
-    end
-
-    assert out.include?(RDoc::VERSION)
-  end
-
-  def test_visibility
-    @options.visibility = :all
-    assert_equal :private, @options.visibility
-  end
-
-  def test_load_options
-    temp_dir do
-      options = RDoc::Options.new
-      options.markup = 'tomdoc'
-      options.write_options
-
-      options = RDoc::Options.load_options
-
-      assert_equal 'tomdoc', options.markup
-    end
-  end
-
-  def test_load_options_invalid
-    temp_dir do
-      File.open '.rdoc_options', 'w' do |io|
-        io.write "a: !ruby.yaml.org,2002:str |\nfoo"
-      end
-
-      e = assert_raise RDoc::Error do
-        RDoc::Options.load_options
-      end
-
-      options_file = File.expand_path '.rdoc_options'
-      assert_equal "#{options_file} is not a valid rdoc options file", e.message
-    end
-  end
-
-  def test_load_options_empty_file
-    temp_dir do
-      File.open '.rdoc_options', 'w' do |io|
-      end
-
-      options = RDoc::Options.load_options
-
-      assert_equal 'rdoc', options.markup
-    end
-  end
-
-  def test_load_options_partial_override
-    temp_dir do
-      File.open '.rdoc_options', 'w' do |io|
-        io.puts "markup: Markdown"
-        io.puts "encoding: iso-8859-1"
-        io.puts "static_path: [static]"
-        io.puts "rdoc_include: [.]"
-        io.puts "page_dir: pages"
-      end
-
-      options = RDoc::Options.load_options
-
-      assert_equal 'Markdown', options.markup
-      assert_equal Encoding::ISO_8859_1, options.encoding
-      assert_equal ["static"], options.static_path
-      assert_equal ["."], options.rdoc_include
-      assert_equal "pages", options.page_dir
-    end
-  end
-
-  def test_load_options_no_file
-    temp_dir do
-      options = RDoc::Options.load_options
-
-      assert_kind_of RDoc::Options, options
-    end
-  end
-
-  def test_skip_test_default_value
-    @options.parse %w[]
-    assert_equal true, @options.skip_tests
-  end
-
-  def test_no_skip_test_value
-    @options.parse %w[--no-skipping-tests]
-    assert_equal false, @options.skip_tests
-  end
-
-  def test_apply_default_exclude_option
-    @options.parse %w[]
-    exclude = @options.exclude
-    assert_kind_of Regexp, exclude
-    assert_match exclude, "foo~"
-    assert_match exclude, "foo.orig"
-    assert_match exclude, "foo.rej"
-    assert_match exclude, "foo.bak"
-    assert_match exclude, "foo.gemspec"
-  end
-
-  def test_no_apply_default_exclude_option
-    @options.parse %w[--no-apply-default-exclude]
-    assert_nil @options.exclude
-  end
-
-  def test_exclude_option_without_default
-    @options.parse %w[--no-apply-default-exclude --exclude=\.old\z]
-    exclude = @options.exclude
-    assert_match exclude, "foo.old"
-    assert_not_match exclude, "foo~"
-  end
-
-  class DummyCoder < Hash
-    alias add :[]=
-    def tag=(tag)
-    end
-  end
-end
diff --git a/test/mri/rdoc/rdoc_parser_c_test.rb b/test/mri/rdoc/rdoc_parser_c_test.rb
deleted file mode 100644
index 504e2f8b2ea..00000000000
--- a/test/mri/rdoc/rdoc_parser_c_test.rb
+++ /dev/null
@@ -1,2150 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-=begin
-  TODO: test call-seq parsing
-
-/*
- *  call-seq:
- *     ARGF.readlines(sep=$/)     -> array
- *     ARGF.readlines(limit)      -> array
- *     ARGF.readlines(sep, limit) -> array
- *
- *     ARGF.to_a(sep=$/)     -> array
- *     ARGF.to_a(limit)      -> array
- *     ARGF.to_a(sep, limit) -> array
- *
- *  Reads +ARGF+'s current file in its entirety, returning an +Array+ of its
- *  lines, one line per element. Lines are assumed to be separated by _sep_.
- *
- *     lines = ARGF.readlines
- *     lines[0]                #=> "This is line one\n"
- */
-
-assert call-seq did not stop at first empty line
-
-/*
- * call-seq:
- *
- *  flt ** other  ->  float
- *
- * Raises <code>float</code> the <code>other</code> power.
- *
- *    2.0**3      #=> 8.0
- */
-
-assert call-seq correct (bug: was empty)
-
-/* call-seq: flt ** other  ->  float */
-
-assert call-seq correct
-
-=end
-
-class RDocParserCTest < RDoc::TestCase
-
-  def setup
-    super
-
-    @tempfile = Tempfile.new self.class.name
-    filename = @tempfile.path
-
-    @top_level = @store.add_file filename
-    @fn = filename
-    @options = RDoc::Options.new
-    @options.verbosity = 2
-    @stats = RDoc::Stats.new @store, 0
-  end
-
-  def teardown
-    super
-
-    @tempfile.close!
-  end
-
-  def test_class_can_parse
-    c_parser = RDoc::Parser::C
-
-    temp_dir do
-      FileUtils.touch 'file.C'
-      assert_equal c_parser, c_parser.can_parse('file.C')
-
-      FileUtils.touch 'file.CC'
-      assert_equal c_parser, c_parser.can_parse('file.CC')
-
-      FileUtils.touch 'file.H'
-      assert_equal c_parser, c_parser.can_parse('file.H')
-
-      FileUtils.touch 'file.HH'
-      assert_equal c_parser, c_parser.can_parse('file.HH')
-
-      FileUtils.touch 'file.c'
-      assert_equal c_parser, c_parser.can_parse('file.c')
-
-      FileUtils.touch 'file.cc'
-      assert_equal c_parser, c_parser.can_parse('file.cc')
-
-      FileUtils.touch 'file.cpp'
-      assert_equal c_parser, c_parser.can_parse('file.cpp')
-
-      FileUtils.touch 'file.cxx'
-      assert_equal c_parser, c_parser.can_parse('file.cxx')
-
-      FileUtils.touch 'file.h'
-      assert_equal c_parser, c_parser.can_parse('file.h')
-
-      FileUtils.touch 'file.hh'
-      assert_equal c_parser, c_parser.can_parse('file.hh')
-
-      FileUtils.touch 'file.y'
-      assert_equal c_parser, c_parser.can_parse('file.y')
-    end
-  end
-
-  def test_known_classes
-    RDoc::KNOWN_CLASSES.each do |var, name|
-      case name
-      when "Refinement"
-        next unless defined?(Refinement)
-      when "RubyVM"
-        next unless defined?(RubyVM)
-      when "Bignum", "Fixnum", "Data", "Socket", /\A(?![A-Z])/
-        next
-      end
-      obj = Object.const_get(name)
-      assert_equal obj.name, name
-      case var
-      when /\Arb_c/
-        assert_kind_of Class, obj
-      when /\Arb_m/
-        assert_kind_of Module, obj
-      when /\Arb_e/
-        assert_operator obj, :<=, Exception
-      else
-        raise "unknown prefix: #{var} => #{name}"
-      end
-    end
-  end
-
-  def test_initialize
-    some_ext        = @top_level.add_class RDoc::NormalClass, 'SomeExt'
-                      @top_level.add_class RDoc::SingleClass, 'SomeExtSingle'
-
-    @store.cache[:c_class_variables] = {
-      @fn => { 'cSomeExt' => 'SomeExt' }
-    }
-
-    @store.cache[:c_singleton_class_variables] = {
-      @fn => { 'cSomeExtSingle' => 'SomeExtSingle' }
-    }
-
-    parser = RDoc::Parser::C.new @top_level, '', @options, @stats
-
-    expected = { 'cSomeExt' => some_ext }
-    assert_equal expected, parser.classes
-
-    expected = { 'cSomeExtSingle' => 'SomeExtSingle' }
-    assert_equal expected, parser.singleton_classes
-
-    expected = {
-      'cSomeExt'       => 'SomeExt',
-      'cSomeExtSingle' => 'SomeExtSingle',
-    }
-    known_classes = parser.known_classes.delete_if do |key, _|
-      RDoc::KNOWN_CLASSES.keys.include? key
-    end
-
-    assert_equal expected, known_classes
-  end
-
-  def assert_do_attr(flags)
-    content = <<-EOF
-void Init_Blah(void) {
-  cBlah = rb_define_class("Blah", rb_cObject);
-
-  /*
-   * This is an accessor
-   */
-  #{yield "cBlah", "accessor", flags[1], flags[1]};
-
-  /*
-   * This is a reader
-   */
-  #{yield "cBlah", "reader", flags[1], flags[0]};
-
-  /*
-   * This is a writer
-   */
-  #{yield "cBlah", "writer", flags[0], flags[1]};
-}
-    EOF
-
-    klass = util_get_class content, 'cBlah'
-
-    attrs = klass.attributes
-    assert_equal 3, attrs.length, attrs.inspect
-
-    accessor = attrs.shift
-    assert_equal 'accessor',            accessor.name
-    assert_equal 'RW',                  accessor.rw
-    assert_equal 'This is an accessor', accessor.comment.text
-    assert_equal @top_level,            accessor.file
-
-    reader = attrs.shift
-    assert_equal 'reader',           reader.name
-    assert_equal 'R',                reader.rw
-    assert_equal 'This is a reader', reader.comment.text
-
-    writer = attrs.shift
-    assert_equal 'writer',           writer.name
-    assert_equal 'W',                writer.rw
-    assert_equal 'This is a writer', writer.comment.text
-  end
-
-  {
-    num: %w[0 1],
-    macro: %w[FALSE TRUE],
-    ruby: %w[Qfalse Qtrue],
-    bool: %w[false true],
-  }.each_pair do |name, values|
-    define_method("test_do_attr:rb_attr:intern:#{name}") do
-      assert_do_attr(values) {|c, name, r, w| %[rb_attr(#{c}, rb_intern("#{name}"), #{r}, #{w}, Qfalse)]}
-    end
-    define_method("test_do_attr:rb_attr:intern_const:#{name}") do
-      assert_do_attr(values) {|c, name, r, w| %[rb_attr(#{c}, rb_intern_const("#{name}"), #{r}, #{w}, Qfalse)]}
-    end
-    define_method("test_do_attr:rb_define_attr:#{name}") do
-      assert_do_attr(values) {|c, name, r, w| %[rb_define_attr(#{c}, "#{name}", #{r}, #{w})]}
-    end
-  end
-
-  def test_do_aliases
-    content = <<-EOF
-/*
- * This should show up as an alias with documentation
- */
-VALUE blah(VALUE klass, VALUE year) {
-}
-
-void Init_Blah(void) {
-  cDate = rb_define_class("Date", rb_cObject);
-
-  rb_define_method(cDate, "blah", blah, 1);
-
-  rb_define_alias(cDate, "bleh", "blah");
-}
-    EOF
-
-    klass = util_get_class content, 'cDate'
-
-    methods = klass.method_list
-    assert_equal 2,      methods.length
-    assert_equal 'bleh', methods.last.name
-    assert_equal 'blah', methods.last.is_alias_for.name
-
-    assert_equal @top_level, methods.last.is_alias_for.file
-    assert_equal @top_level, methods.last.file
-  end
-
-  def test_do_aliases_singleton
-    content = <<-EOF
-/*
- * This should show up as a method with documentation
- */
-VALUE blah(VALUE klass, VALUE year) {
-}
-
-void Init_Blah(void) {
-  cDate = rb_define_class("Date", rb_cObject);
-  sDate = rb_singleton_class(cDate);
-
-  rb_define_method(sDate, "blah", blah, 1);
-
-  /*
-   * This should show up as an alias
-   */
-  rb_define_alias(sDate, "bleh", "blah");
-}
-    EOF
-
-    klass = util_get_class content, 'cDate'
-
-    methods = klass.method_list
-
-    assert_equal 2,      methods.length
-    assert_equal 'bleh', methods.last.name
-    assert               methods.last.singleton
-    assert_equal 'blah', methods.last.is_alias_for.name
-    assert_equal 'This should show up as an alias', methods.last.comment.text
-  end
-
-  def test_do_aliases_missing_class
-    content = <<-EOF
-void Init_Blah(void) {
-  rb_define_alias(cDate, "b", "a");
-}
-    EOF
-
-    _, err = verbose_capture_output do
-      refute util_get_class(content, 'cDate')
-    end
-
-    assert_equal "Enclosing class or module \"cDate\" for alias b a is not known\n",
-                 err
-  end
-
-  def test_do_classes_class
-    content = <<-EOF
-/* Document-class: Foo
- * this is the Foo class
- */
-VALUE cFoo = rb_define_class("Foo", rb_cObject);
-    EOF
-
-    klass = util_get_class content, 'cFoo'
-    assert_equal "this is the Foo class", klass.comment.text
-  end
-
-  def test_do_classes_duplicate_class
-    content = <<-EOF
-/* Document-class: Foo
- * first
- */
-VALUE cFoo = rb_define_class("Foo", rb_cObject);
-/* Document-class: Foo
- * second
- */
-VALUE cFoo = rb_define_class("Foo", rb_cObject);
-    EOF
-
-    klass = util_get_class content, 'cFoo'
-    assert_equal 1, klass.comment_location.size
-    first = klass.comment_location.first
-    first_comment = first[0]
-    assert_equal 'first', first_comment.text
-  end
-
-  def test_do_classes_struct
-    content = <<-EOF
-/* Document-class: Foo
- * this is the Foo class
- */
-VALUE cFoo = rb_struct_define(
-        "Foo",
-        "some", "various", "fields", NULL);
-    EOF
-
-    klass = util_get_class content, 'cFoo'
-    assert_equal "this is the Foo class", klass.comment.text
-
-    attributes = klass.attributes
-    assert_equal 3, attributes.size, -> {attributes}
-    ["some", "various", "fields"].zip(attributes) do |name, attr|
-      assert_equal RDoc::Attr.new("", name, "RW", ""), attr
-    end
-  end
-
-  def test_do_classes_struct_under
-    content = <<-EOF
-/* Document-class: Kernel::Foo
- * this is the Foo class under Kernel
- */
-VALUE cFoo = rb_struct_define_under(
-        rb_mKernel, "Foo",
-        "some", "various", "fields", NULL);
-    EOF
-
-    klass = util_get_class content, 'cFoo'
-    assert_equal 'Kernel::Foo', klass.full_name
-    assert_equal "this is the Foo class under Kernel", klass.comment.text
-
-    attributes = klass.attributes
-    assert_equal 3, attributes.size, -> {attributes}
-    ["some", "various", "fields"].zip(attributes) do |name, attr|
-      assert_equal RDoc::Attr.new("", name, "RW", ""), attr
-    end
-  end
-
-  def test_do_classes_struct_without_accessor
-    content = <<-EOF
-/* Document-class: Foo
- * this is the Foo class
- */
-VALUE cFoo = rb_struct_define_without_accessor(
-        "Foo", rb_cObject, foo_alloc,
-        "some", "various", "fields", NULL);
-    EOF
-
-    klass = util_get_class content, 'cFoo'
-    assert_equal "this is the Foo class", klass.comment.text
-    assert_empty klass.attributes
-  end
-
-  def test_do_classes_struct_without_accessor_under
-    content = <<-EOF
-/* Document-class: Kernel::Foo
- * this is the Foo class under Kernel
- */
-VALUE cFoo = rb_struct_define_without_accessor_under(
-        rb_mKernel, "Foo", rb_cObject, foo_alloc,
-        "some", "various", "fields", NULL);
-    EOF
-
-    klass = util_get_class content, 'cFoo'
-    assert_equal 'Kernel::Foo', klass.full_name
-    assert_equal "this is the Foo class under Kernel", klass.comment.text
-    assert_empty klass.attributes
-  end
-
-  def test_do_classes_class_under
-    content = <<-EOF
-/* Document-class: Kernel::Foo
- * this is the Foo class under Kernel
- */
-VALUE cFoo = rb_define_class_under(rb_mKernel, "Foo", rb_cObject);
-    EOF
-
-    klass = util_get_class content, 'cFoo'
-    assert_equal 'Kernel::Foo', klass.full_name
-    assert_equal "this is the Foo class under Kernel", klass.comment.text
-  end
-
-  def test_do_classes_class_under_rb_path2class
-    content = <<-EOF
-/* Document-class: Kernel::Foo
- * this is Kernel::Foo < A::B
- */
-VALUE cFoo = rb_define_class_under(rb_mKernel, "Foo", rb_path2class("A::B"));
-    EOF
-
-    klass = util_get_class content, 'cFoo'
-
-    assert_equal 'Kernel::Foo', klass.full_name
-    assert_equal 'A::B', klass.superclass
-    assert_equal 'this is Kernel::Foo < A::B', klass.comment.text
-  end
-
-  def test_do_classes_singleton
-    content = <<-EOF
-VALUE cFoo = rb_define_class("Foo", rb_cObject);
-VALUE cFooS = rb_singleton_class(cFoo);
-    EOF
-
-    util_get_class content, 'cFooS'
-
-    assert_equal 'Foo', @parser.singleton_classes['cFooS']
-  end
-
-  def test_do_classes_module
-    content = <<-EOF
-/* Document-module: Foo
- * this is the Foo module
- */
-VALUE mFoo = rb_define_module("Foo");
-    EOF
-
-    klass = util_get_class content, 'mFoo'
-    assert_equal "this is the Foo module", klass.comment.text
-  end
-
-  def test_do_classes_module_under
-    content = <<-EOF
-/* Document-module: Kernel::Foo
- * this is the Foo module under Kernel
- */
-VALUE mFoo = rb_define_module_under(rb_mKernel, "Foo");
-    EOF
-
-    klass = util_get_class content, 'mFoo'
-    assert_equal "this is the Foo module under Kernel", klass.comment.text
-  end
-
-  def test_do_constants
-    content = <<-'EOF'
-#include <ruby.h>
-
-void Init_foo(){
-   VALUE cFoo = rb_define_class("Foo", rb_cObject);
-
-   /* 300: The highest possible score in bowling */
-   rb_define_const(cFoo, "PERFECT", INT2FIX(300));
-
-   /* Huzzah!: What you cheer when you roll a perfect game */
-   rb_define_const(cFoo, "CHEER", rb_str_new2("Huzzah!"));
-
-   /* TEST\:TEST: Checking to see if escaped colon works */
-   rb_define_const(cFoo, "TEST", rb_str_new2("TEST:TEST"));
-
-   /* TEST: TEST:Checking to see if only word-ending colon works */
-   rb_define_const(cFoo, "TEST2", rb_str_new2("TEST:TEST"));
-
-   /* \\: The file separator on MS Windows */
-   rb_define_const(cFoo, "MSEPARATOR", rb_str_new2("\\"));
-
-   /* /: The file separator on Unix */
-   rb_define_const(cFoo, "SEPARATOR", rb_str_new2("/"));
-
-   /* C:\\Program Files\\Stuff: A directory on MS Windows */
-   rb_define_const(cFoo, "STUFF", rb_str_new2("C:\\Program Files\\Stuff"));
-
-   /* Default definition */
-   rb_define_const(cFoo, "NOSEMI", INT2FIX(99));
-
-   rb_define_const(cFoo, "NOCOMMENT", rb_str_new2("No comment"));
-
-   /*
-    * Multiline comment goes here because this comment spans multiple lines.
-    * Multiline comment goes here because this comment spans multiple lines.
-    */
-   rb_define_const(cFoo, "MULTILINE", INT2FIX(1));
-
-   /*
-    * 1: Multiline comment goes here because this comment spans multiple lines.
-    * Multiline comment goes here because this comment spans multiple lines.
-    */
-   rb_define_const(cFoo, "MULTILINE_VALUE", INT2FIX(1));
-
-   /* Multiline comment goes here because this comment spans multiple lines.
-    * Multiline comment goes here because this comment spans multiple lines.
-    */
-   rb_define_const(cFoo, "MULTILINE_NOT_EMPTY", INT2FIX(1));
-
-   /*
-    * Multiline comment goes here because this comment spans multiple lines.
-    * 1: However, the value extraction should only happen for the first line
-    */
-   rb_define_const(cFoo, "MULTILINE_COLON_ON_SECOND_LINE", INT2FIX(1));
-
-}
-    EOF
-
-    @parser = util_parser content
-
-    @parser.do_classes_and_modules
-    @parser.do_constants
-
-    klass = @parser.classes['cFoo']
-    assert klass
-
-    constants = klass.constants
-    assert !klass.constants.empty?
-
-    assert_equal @top_level, constants.first.file
-
-    constants = constants.map { |c| [c.name, c.value, c.comment.text] }
-
-    assert_equal ['PERFECT', '300', 'The highest possible score in bowling   '],
-                 constants.shift
-    assert_equal ['CHEER', 'Huzzah!',
-                  'What you cheer when you roll a perfect game   '],
-                 constants.shift
-    assert_equal ['TEST', 'TEST:TEST',
-                  'Checking to see if escaped colon works   '],
-                 constants.shift
-    assert_equal ['TEST2', 'TEST',
-                  'TEST:Checking to see if only word-ending colon works   '],
-                 constants.shift
-    assert_equal ['MSEPARATOR', '\\',
-                  'The file separator on MS Windows   '],
-                 constants.shift
-    assert_equal ['SEPARATOR', '/',
-                  'The file separator on Unix   '],
-                 constants.shift
-    assert_equal ['STUFF', 'C:\\Program Files\\Stuff',
-                  'A directory on MS Windows   '],
-                 constants.shift
-    assert_equal ['NOSEMI', 'INT2FIX(99)',
-                  'Default definition   '],
-                 constants.shift
-    assert_equal ['NOCOMMENT', 'rb_str_new2("No comment")', ''],
-                 constants.shift
-
-    comment = <<-EOF.chomp
-Multiline comment goes here because this comment spans multiple lines.
-Multiline comment goes here because this comment spans multiple lines.
-    EOF
-    assert_equal ['MULTILINE',           'INT2FIX(1)', comment], constants.shift
-    assert_equal ['MULTILINE_VALUE',     '1',          comment], constants.shift
-    assert_equal ['MULTILINE_NOT_EMPTY', 'INT2FIX(1)', comment], constants.shift
-
-    comment = <<-EOF.chomp
-Multiline comment goes here because this comment spans multiple lines.
-1: However, the value extraction should only happen for the first line
-    EOF
-    assert_equal ['MULTILINE_COLON_ON_SECOND_LINE', 'INT2FIX(1)', comment],
-                 constants.shift
-
-    assert constants.empty?, constants.inspect
-  end
-
-  def test_do_constants_global
-    content = <<-'EOF'
-#include <ruby.h>
-
-void Init_foo(){
-
-   /* Toplevel const */
-   rb_define_global_const("ANSWER", INT2FIX(42));
-
-}
-    EOF
-
-    @parser = util_parser content
-
-    @parser.do_classes_and_modules
-    @parser.do_constants
-
-    klass = @parser.classes['rb_cObject']
-    assert klass
-
-    constants = klass.constants
-    assert !klass.constants.empty?
-
-    assert_equal @top_level, constants.first.file
-
-    constants = constants.map { |c| [c.name, c.value, c.comment.text] }
-    assert_equal ['ANSWER', 'INT2FIX(42)', "Toplevel const   "],
-                 constants.shift
-
-    assert constants.empty?, constants.inspect
-  end
-
-  def test_do_constants_curses
-    content = <<-EOF
-void Init_curses(){
-  mCurses = rb_define_module("Curses");
-
-  /*
-   * Value of the color black
-   */
-  rb_curses_define_const(COLOR_BLACK);
-}
-    EOF
-
-    @parser = util_parser content
-
-    @parser.do_classes_and_modules
-    @parser.do_constants
-
-    klass = @parser.classes['mCurses']
-
-    constants = klass.constants
-    refute_empty klass.constants
-
-    assert_equal 'COLOR_BLACK', constants.first.name
-    assert_equal 'UINT2NUM(COLOR_BLACK)', constants.first.value
-    assert_equal 'Value of the color black', constants.first.comment.text
-  end
-
-  def test_do_constants_file
-    content = <<-EOF
-void Init_File(void) {
-  /*
-   *  Shared lock
-   */
-  rb_file_const("LOCK_SH", INT2FIX(LOCK_SH));
-}
-    EOF
-
-    @parser = util_parser content
-
-    @parser.do_classes_and_modules
-    @parser.do_constants
-
-    klass = @parser.classes['rb_mFConst']
-
-    constants = klass.constants
-    refute_empty klass.constants
-
-    constant = constants.first
-
-    assert_equal 'LOCK_SH',          constant.name
-    assert_equal 'INT2FIX(LOCK_SH)', constant.value
-    assert_equal 'Shared lock',      constant.comment.text
-
-    @parser = util_parser <<-EOF
-void Init_File(void) {
-  rb_cFile = rb_define_class("File", rb_cIO);
-  rb_mFConst = rb_define_module_under(rb_cFile, "Constants");
-}
-    EOF
-    @parser.do_classes_and_modules
-    @parser.do_constants
-
-    assert_equal 'File::Constants',  klass.full_name
-  end
-
-  def test_do_includes
-    content = <<-EOF
-Init_foo() {
-   VALUE cFoo = rb_define_class("Foo", rb_cObject);
-   VALUE mInc = rb_define_module("Inc");
-
-   rb_include_module(cFoo, mInc);
-}
-    EOF
-
-    klass = util_get_class content, 'cFoo'
-
-    incl = klass.includes.first
-    assert_equal 'Inc',      incl.name
-    assert_equal '',         incl.comment.text
-    assert_equal @top_level, incl.file
-  end
-
-  # HACK parsing warning instead of setting up in file
-  def test_do_methods_in_c
-    content = <<-EOF
-VALUE blah(VALUE klass, VALUE year) {
-}
-
-void Init_Blah(void) {
-  cDate = rb_define_class("Date", rb_cObject);
-
-  rb_define_method(cDate, "blah", blah, 1); /* in blah.c */
-}
-    EOF
-
-    klass = nil
-
-    _, err = verbose_capture_output do
-      klass = util_get_class content, 'cDate'
-    end
-
-    assert_equal 'Date', klass.full_name
-    assert_match ' blah.c ', err
-  end
-
-  # HACK parsing warning instead of setting up in file
-  def test_do_methods_in_cpp
-    content = <<-EOF
-VALUE blah(VALUE klass, VALUE year) {
-}
-
-void Init_Blah(void) {
-  cDate = rb_define_class("Date", rb_cObject);
-
-  rb_define_method(cDate, "blah", blah, 1); /* in blah.cpp */
-}
-    EOF
-
-    klass = nil
-
-    _, err = verbose_capture_output do
-      klass = util_get_class content, 'cDate'
-    end
-
-    assert_equal 'Date', klass.full_name
-    assert_match ' blah.cpp ', err
-  end
-
-  # HACK parsing warning instead of setting up in file
-  def test_do_methods_in_y
-    content = <<-EOF
-VALUE blah(VALUE klass, VALUE year) {
-}
-
-void Init_Blah(void) {
-  cDate = rb_define_class("Date", rb_cObject);
-
-  rb_define_method(cDate, "blah", blah, 1); /* in blah.y */
-}
-    EOF
-
-    klass = nil
-
-    _, err = verbose_capture_output do
-      klass = util_get_class content, 'cDate'
-    end
-
-    assert_equal 'Date', klass.full_name
-    assert_match ' blah.y ', err
-  end
-
-  def test_do_methods_singleton_class
-    content = <<-EOF
-VALUE blah(VALUE klass, VALUE year) {
-}
-
-void Init_Blah(void) {
-  cDate = rb_define_class("Date", rb_cObject);
-  sDate = rb_singleton_class(cDate);
-
-  rb_define_method(sDate, "blah", blah, 1);
-}
-    EOF
-
-    klass = util_get_class content, 'cDate'
-
-    methods = klass.method_list
-    assert_equal 1,      methods.length
-    assert_equal 'blah', methods.first.name
-    assert               methods.first.singleton
-  end
-
-  def test_do_missing
-    parser = util_parser
-
-    klass_a = @top_level.add_class RDoc::ClassModule, 'A'
-    parser.classes['a'] = klass_a
-
-    parser.enclosure_dependencies['c'] << 'b'
-    parser.enclosure_dependencies['b'] << 'a'
-    parser.enclosure_dependencies['d'] << 'a'
-
-    parser.missing_dependencies['d'] = ['d', :class, 'D', 'Object', 'a']
-    parser.missing_dependencies['c'] = ['c', :class, 'C', 'Object', 'b']
-    parser.missing_dependencies['b'] = ['b', :class, 'B', 'Object', 'a']
-
-    parser.do_missing
-
-    assert_equal %w[A A::B A::B::C A::D],
-                 @store.all_classes_and_modules.map { |m| m.full_name }.sort
-  end
-
-  def test_do_missing_cycle
-    parser = util_parser
-
-    klass_a = @top_level.add_class RDoc::ClassModule, 'A'
-    parser.classes['a'] = klass_a
-
-    parser.enclosure_dependencies['c'] << 'b'
-    parser.enclosure_dependencies['b'] << 'a'
-
-    parser.missing_dependencies['c'] = ['c', :class, 'C', 'Object', 'b']
-    parser.missing_dependencies['b'] = ['b', :class, 'B', 'Object', 'a']
-
-    parser.enclosure_dependencies['y'] << 'z'
-    parser.enclosure_dependencies['z'] << 'y'
-
-    parser.missing_dependencies['y'] = ['y', :class, 'Y', 'Object', 'z']
-    parser.missing_dependencies['z'] = ['z', :class, 'Z', 'Object', 'y']
-
-    _, err = verbose_capture_output do
-      parser.do_missing
-    end
-
-    expected = 'Unable to create class Y (y), class Z (z) ' +
-               'due to a cyclic class or module creation'
-
-    assert_equal expected, err.chomp
-
-    assert_equal %w[A A::B A::B::C],
-                 @store.all_classes_and_modules.map { |m| m.full_name }.sort
-  end
-
-  def test_find_alias_comment
-    parser = util_parser
-
-    comment = parser.find_alias_comment 'C', '[]', 'index'
-
-    assert_equal '', comment.text
-
-    parser = util_parser <<-C
-/*
- * comment
- */
-
-rb_define_alias(C, "[]", "index");
-    C
-
-    comment = parser.find_alias_comment 'C', '[]', 'index'
-
-    assert_equal "/*\n * comment\n */\n\n", comment.text
-  end
-
-  def test_find_attr_comment_document_attr
-    parser= util_parser <<-C
-/*
- * Document-attr: y
- * comment
- */
-    C
-
-    comment = parser.find_attr_comment nil, 'y'
-
-    assert_equal "/*\n * \n * comment\n */", comment.text
-  end
-
-  def test_find_attr_comment_document_attr_oneline
-    parser= util_parser <<-C
-/* Document-attr: y
- * comment
- */
-    C
-
-    comment = parser.find_attr_comment nil, 'y'
-
-    assert_equal "/* \n * comment\n */", comment.text
-  end
-
-  def test_find_attr_comment_document_attr_overlap
-    parser= util_parser <<-C
-/* Document-attr: x
- * comment
- */
-
-/* Document-attr: y
- * comment
- */
-    C
-
-    comment = parser.find_attr_comment nil, 'y'
-
-    assert_equal "/* \n * comment\n */", comment.text
-  end
-
-  def test_find_class_comment
-    @options.rdoc_include << File.dirname(__FILE__)
-
-    content = <<-EOF
-/*
- * Comment 1
- */
-foo = rb_define_class("MyClassName1", rb_cObject);
-
-/*
- * Comment 2
- */
-bar = rb_define_class("MyClassName2", rb_cObject);
-    EOF
-
-    util_get_class content
-
-    assert_equal "Comment 1", @parser.classes['foo'].comment.text
-    assert_equal "Comment 2", @parser.classes['bar'].comment.text
-  end
-
-  def test_find_class_comment_init
-    content = <<-EOF
-/*
- * a comment for class Foo
- */
-void
-Init_Foo(void) {
-  VALUE foo = rb_define_class("Foo", rb_cObject);
-}
-    EOF
-
-    klass = util_get_class content, 'foo'
-
-    assert_equal "a comment for class Foo", klass.comment.text
-  end
-
-
-  def test_find_class_comment_initvm
-    content = <<-EOF
-/*
- * a comment for class Foo
- */
-void
-InitVM_Foo(void) {
-  VALUE foo = rb_define_class("Foo", rb_cObject);
-}
-    EOF
-
-    klass = util_get_class content, 'foo'
-
-    assert_equal "a comment for class Foo", klass.comment.text
-  end
-
-  def test_find_class_comment_define_class
-    content = <<-EOF
-/*
- * a comment for class Foo
- */
-VALUE foo = rb_define_class("Foo", rb_cObject);
-    EOF
-
-    klass = util_get_class content, 'foo'
-
-    assert_equal "a comment for class Foo", klass.comment.text
-  end
-
-  def test_find_class_comment_define_class_Init_Foo
-    content = <<-EOF
-/*
- * a comment for class Foo on Init
- */
-void
-Init_Foo(void) {
-    /*
-     * a comment for class Foo on rb_define_class
-     */
-    VALUE foo = rb_define_class("Foo", rb_cObject);
-}
-    EOF
-
-    klass = util_get_class content, 'foo'
-
-    assert_equal "a comment for class Foo on Init", klass.comment.text
-  end
-
-  def test_find_class_comment_define_class_Init_Foo_no_void
-    content = <<-EOF
-/*
- * a comment for class Foo on Init
- */
-void
-Init_Foo() {
-    /*
-     * a comment for class Foo on rb_define_class
-     */
-    VALUE foo = rb_define_class("Foo", rb_cObject);
-}
-    EOF
-
-    klass = util_get_class content, 'foo'
-
-    assert_equal "a comment for class Foo on Init", klass.comment.text
-  end
-
-  def test_find_class_comment_define_class_bogus_comment
-    content = <<-EOF
-/*
- * a comment for other_function
- */
-void
-other_function() {
-}
-
-void
-Init_Foo(void) {
-    VALUE foo = rb_define_class("Foo", rb_cObject);
-}
-    EOF
-
-    klass = util_get_class content, 'foo'
-
-    assert_equal '', klass.comment.text
-  end
-
-  def test_find_class_comment_define_class_under
-    content = <<-EOF
-/*
- * a comment for class Foo
- */
-VALUE foo = rb_define_class_under(rb_cObject, "Foo", rb_cObject);
-    EOF
-
-    klass = util_get_class content, 'foo'
-
-    assert_equal "a comment for class Foo", klass.comment.text
-  end
-
-  def test_find_class_comment_define_class_under_Init
-    content = <<-EOF
-/*
- * a comment for class Foo on Init
- */
-void
-Init_Foo(void) {
-    /*
-     * a comment for class Foo on rb_define_class
-     */
-    VALUE foo = rb_define_class_under(rb_cObject, "Foo", rb_cObject);
-}
-    EOF
-
-    klass = util_get_class content, 'foo'
-
-    # the inner comment is used since Object::Foo is not necessarily the same
-    # thing as "Foo" for Init_
-    assert_equal "a comment for class Foo on rb_define_class",
-                 klass.comment.text
-  end
-
-  def test_find_const_comment_rb_define
-    content = <<-EOF
-/*
- * A comment
- */
-rb_define_const(cFoo, "CONST", value);
-    EOF
-
-    parser = util_parser content
-
-    comment = parser.find_const_comment 'const', 'CONST'
-
-    assert_equal "/*\n * A comment\n */\n", comment.text
-  end
-
-  def test_find_const_comment_rb_define_global
-    content = <<-EOF
-/*
- * A comment
- */
-rb_define_global_const("CONST", value);
-    EOF
-
-    parser = util_parser content
-
-    comment = parser.find_const_comment 'const', 'CONST'
-
-    assert_equal "/*\n * A comment\n */\n", comment.text
-  end
-
-  def test_find_const_comment_document_const
-    content = <<-EOF
-/*
- * Document-const: CONST
- *
- * A comment
- */
-    EOF
-
-    parser = util_parser content
-
-    comment = parser.find_const_comment nil, 'CONST'
-
-    assert_equal "/*\n *\n * A comment\n */", comment.text
-  end
-
-  def test_find_const_comment_document_const_full_name
-    content = <<-EOF
-/*
- * Document-const: Foo::CONST
- *
- * A comment
- */
-    EOF
-
-    parser = util_parser content
-
-    comment = parser.find_const_comment nil, 'CONST', 'Foo'
-
-    assert_equal "/*\n *\n * A comment\n */", comment.text
-  end
-
-  def test_find_body
-    content = <<-EOF
-/*
- * a comment for other_function
- */
-VALUE
-other_function() {
-}
-
-void
-Init_Foo(void) {
-    VALUE foo = rb_define_class("Foo", rb_cObject);
-
-    rb_define_method(foo, "my_method", other_function, 0);
-}
-    EOF
-
-    klass = util_get_class content, 'foo'
-    other_function = klass.method_list.first
-
-    assert_equal 'my_method', other_function.name
-    assert_equal "a comment for other_function",
-                 other_function.comment.text
-    assert_equal '()', other_function.params
-
-    code = other_function.token_stream.first[:text]
-
-    assert_equal "VALUE\nother_function() {\n}", code
-  end
-
-  def test_find_body_2
-    content = <<-CONTENT
-/* Copyright (C) 2010  Sven Herzberg
- *
- * This file is free software; the author(s) gives unlimited
- * permission to copy and/or distribute it, with or without
- * modifications, as long as this notice is preserved.
- */
-
-#include <ruby.h>
-
-static VALUE
-wrap_initialize (VALUE  self)
-{
-  return self;
-}
-
-/* */
-static VALUE
-wrap_shift (VALUE self,
-            VALUE arg)
-{
-  return self;
-}
-
-void
-init_gi_repository (void)
-{
-  VALUE mTest = rb_define_module ("Test");
-  VALUE cTest = rb_define_class_under (mTest, "Test", rb_cObject);
-
-  rb_define_method (cTest, "initialize", wrap_initialize, 0);
-  rb_define_method (cTest, "shift", wrap_shift, 0);
-}
-    CONTENT
-
-    klass = util_get_class content, 'cTest'
-    assert_equal 2, klass.method_list.length
-  end
-
-  def test_find_body_cast
-    content = <<-EOF
-/*
- * a comment for other_function
- */
-VALUE
-other_function() {
-}
-
-void
-Init_Foo(void) {
-    VALUE foo = rb_define_class("Foo", rb_cObject);
-
-    rb_define_method(foo, "my_method", (METHOD)other_function, 0);
-}
-    EOF
-
-    klass = util_get_class content, 'foo'
-    other_function = klass.method_list.first
-
-    assert_equal 'my_method', other_function.name
-    assert_equal "a comment for other_function",
-                 other_function.comment.text
-    assert_equal '()', other_function.params
-
-    code = other_function.token_stream.first[:text]
-
-    assert_equal "VALUE\nother_function() {\n}", code
-  end
-
-  def test_find_body_define
-    content = <<-EOF
-#define something something_else
-
-#define other_function rb_other_function
-
-/*
- * a comment for rb_other_function
- */
-VALUE
-rb_other_function() {
-}
-
-void
-Init_Foo(void) {
-    VALUE foo = rb_define_class("Foo", rb_cObject);
-
-    rb_define_method(foo, "my_method", other_function, 0);
-}
-    EOF
-
-    klass = util_get_class content, 'foo'
-    other_function = klass.method_list.first
-
-    assert_equal 'my_method', other_function.name
-    assert_equal 'a comment for rb_other_function', other_function.comment.text
-    assert_equal '()', other_function.params
-    assert_equal 8, other_function.line
-
-    code = other_function.token_stream.first[:text]
-
-    assert_equal "VALUE\nrb_other_function() {\n}", code
-  end
-
-  def test_find_body_define_comment
-    content = <<-EOF
-/*
- * a comment for other_function
- */
-#define other_function rb_other_function
-
-/* */
-VALUE
-rb_other_function() {
-}
-
-void
-Init_Foo(void) {
-    VALUE foo = rb_define_class("Foo", rb_cObject);
-
-    rb_define_method(foo, "my_method", other_function, 0);
-}
-    EOF
-
-    klass = util_get_class content, 'foo'
-    other_function = klass.method_list.first
-
-    assert_equal 'my_method', other_function.name
-    assert_equal 'a comment for other_function', other_function.comment.text
-    assert_equal '()', other_function.params
-    assert_equal 4, other_function.line
-
-    code = other_function.token_stream.first[:text]
-
-    assert_equal "#define other_function rb_other_function", code
-  end
-
-  def test_find_body_document_method
-    content = <<-EOF
-/*
- * Document-method: bar
- * Document-method: baz
- *
- * a comment for bar
- */
-VALUE
-bar() {
-}
-
-void
-Init_Foo(void) {
-    VALUE foo = rb_define_class("Foo", rb_cObject);
-
-    rb_define_method(foo, "bar", bar, 0);
-    rb_define_method(foo, "baz", bar, 0);
-}
-    EOF
-
-    klass = util_get_class content, 'foo'
-    assert_equal 2, klass.method_list.length
-
-    methods = klass.method_list.sort
-
-    bar = methods.first
-    assert_equal 'Foo#bar', bar.full_name
-    assert_equal "a comment for bar", bar.comment.text
-
-    baz = methods.last
-    assert_equal 'Foo#baz', baz.full_name
-    assert_equal "a comment for bar", baz.comment.text
-  end
-
-  def test_find_body_document_method_equals
-    content = <<-EOF
-/*
- * Document-method: Zlib::GzipFile#mtime=
- *
- * A comment
- */
-static VALUE
-rb_gzfile_set_mtime(VALUE obj, VALUE mtime)
-{
-
-void
-Init_zlib() {
-    mZlib = rb_define_module("Zlib");
-    cGzipFile = rb_define_class_under(mZlib, "GzipFile", rb_cObject);
-    cGzipWriter = rb_define_class_under(mZlib, "GzipWriter", cGzipFile);
-    rb_define_method(cGzipWriter, "mtime=", rb_gzfile_set_mtime, 1);
-}
-    EOF
-
-    klass = util_get_class content, 'cGzipWriter'
-    assert_equal 1, klass.method_list.length
-
-    methods = klass.method_list.sort
-
-    bar = methods.first
-    assert_equal 'Zlib::GzipWriter#mtime=', bar.full_name
-    assert_equal 'A comment', bar.comment.text
-  end
-
-  def test_find_body_document_method_same
-    content = <<-EOF
-VALUE
-s_bar() {
-}
-
-VALUE
-bar() {
-}
-
-/*
- * Document-method: Foo::bar
- *
- * a comment for Foo::bar
- */
-
-/*
- * Document-method: Foo#bar
- *
- * a comment for Foo#bar
- */
-
-void
-Init_Foo(void) {
-    VALUE foo = rb_define_class("Foo", rb_cObject);
-
-    rb_define_singleton_method(foo, "bar", s_bar, 0);
-    rb_define_method(foo, "bar", bar, 0);
-}
-    EOF
-
-    klass = util_get_class content, 'foo'
-    assert_equal 2, klass.method_list.length
-
-    methods = klass.method_list.sort
-
-    s_bar = methods.first
-    assert_equal 'Foo::bar', s_bar.full_name
-    assert_equal "a comment for Foo::bar", s_bar.comment.text
-
-    bar = methods.last
-    assert_equal 'Foo#bar', bar.full_name
-    assert_equal "a comment for Foo#bar", bar.comment.text
-  end
-
-  def test_find_body_macro
-    content = <<-EOF
-/*
- * a comment for other_function
- */
-DLL_LOCAL VALUE
-other_function() {
-}
-
-void
-Init_Foo(void) {
-    VALUE foo = rb_define_class("Foo", rb_cObject);
-
-    rb_define_method(foo, "my_method", other_function, 0);
-}
-    EOF
-
-    klass = util_get_class content, 'foo'
-    other_function = klass.method_list.first
-
-    assert_equal 'my_method', other_function.name
-    assert_equal "a comment for other_function",
-                 other_function.comment.text
-    assert_equal '()', other_function.params
-
-    code = other_function.token_stream.first[:text]
-
-    assert_equal "DLL_LOCAL VALUE\nother_function() {\n}", code
-  end
-
-  def test_find_body_static_inline
-    content = <<-EOF
-/*
- * a comment for other_function
- */
-static inline VALUE
-other_function() {
-}
-
-void
-Init_Foo(void) {
-    VALUE foo = rb_define_class("Foo", rb_cObject);
-
-    rb_define_method(foo, "my_method", other_function, 0);
-}
-    EOF
-
-    klass = util_get_class content, 'foo'
-    other_function = klass.method_list.first
-
-    assert_equal 'my_method', other_function.name
-    assert_equal "a comment for other_function",
-                 other_function.comment.text
-    assert_equal '()', other_function.params
-
-    code = other_function.token_stream.first[:text]
-
-    assert_equal "static inline VALUE\nother_function() {\n}", code
-  end
-
-  def test_find_modifiers_call_seq
-    comment = RDoc::Comment.new <<-COMMENT
-call-seq:
-  commercial() -> Date <br />
-
-If no arguments are given:
-
-    COMMENT
-
-    parser = util_parser
-    method_obj = RDoc::AnyMethod.new nil, 'blah'
-
-    parser.find_modifiers comment, method_obj
-
-    expected = <<-CALL_SEQ.chomp
-commercial() -> Date <br />
-
-    CALL_SEQ
-
-    assert_equal expected, method_obj.call_seq
-  end
-
-  def test_find_modifiers_nodoc
-    comment = RDoc::Comment.new <<-COMMENT
-/* :nodoc:
- *
- * Blah
- */
-
-    COMMENT
-
-    parser = util_parser
-    method_obj = RDoc::AnyMethod.new nil, 'blah'
-
-    parser.find_modifiers comment, method_obj
-
-    assert_nil method_obj.document_self
-  end
-
-  def test_find_modifiers_yields
-    comment = RDoc::Comment.new <<-COMMENT, @top_level, :c
-/* :yields: a, b
- *
- * Blah
- */
-
-    COMMENT
-
-    parser = util_parser
-    method_obj = RDoc::AnyMethod.new nil, 'blah'
-
-    parser.find_modifiers comment, method_obj
-
-    assert_equal 'a, b', method_obj.block_params
-
-    assert_equal "\n\nBlah", comment.text
-  end
-
-  def test_handle_method_args_minus_1
-    parser = util_parser "Document-method: Object#m\n blah */"
-
-    parser.content = <<-BODY
-VALUE
-rb_other(VALUE obj) {
-  rb_funcall(obj, rb_intern("other"), 0);
-  return rb_str_new2("blah, blah, blah");
-}
-
-VALUE
-rb_m(int argc, VALUE *argv, VALUE obj) {
-  VALUE o1, o2;
-  rb_scan_args(argc, argv, "1", &o1, &o2);
-}
-    BODY
-
-    parser.handle_method 'method', 'rb_cObject', 'm', 'rb_m', -1
-
-    m = @top_level.find_module_named('Object').method_list.first
-
-    assert_equal 'm', m.name
-    assert_equal @top_level, m.file
-    assert_equal 7, m.line
-
-    assert_equal '(p1)', m.params
-  end
-
-  def test_handle_method_args_0
-    parser = util_parser "Document-method: BasicObject#==\n blah */"
-
-    parser.handle_method 'method', 'rb_cBasicObject', '==', 'rb_obj_equal', 0
-
-    bo = @top_level.find_module_named 'BasicObject'
-
-    assert_equal 1, bo.method_list.length
-
-    equals2 = bo.method_list.first
-
-    assert_equal '()', equals2.params
-  end
-
-  def test_handle_method_args_1
-    parser = util_parser "Document-method: BasicObject#==\n blah */"
-
-    parser.handle_method 'method', 'rb_cBasicObject', '==', 'rb_obj_equal', 1
-
-    bo = @top_level.find_module_named 'BasicObject'
-
-    assert_equal 1, bo.method_list.length
-
-    equals2 = bo.method_list.first
-
-    assert_equal '(p1)', equals2.params
-  end
-
-  def test_handle_method_args_2
-    parser = util_parser "Document-method: BasicObject#==\n blah */"
-
-    parser.handle_method 'method', 'rb_cBasicObject', '==', 'rb_obj_equal', 2
-
-    bo = @top_level.find_module_named 'BasicObject'
-
-    assert_equal 1, bo.method_list.length
-
-    equals2 = bo.method_list.first
-
-    assert_equal '(p1, p2)', equals2.params
-  end
-
-  # test_handle_args_minus_1 handled by test_handle_method
-
-  def test_handle_method_args_minus_2
-    parser = util_parser "Document-method: BasicObject#==\n blah */"
-
-    parser.handle_method 'method', 'rb_cBasicObject', '==', 'rb_obj_equal', -2
-
-    bo = @top_level.find_module_named 'BasicObject'
-
-    assert_equal 1, bo.method_list.length
-
-    equals2 = bo.method_list.first
-
-    assert_equal '(*args)', equals2.params
-  end
-
-  def test_handle_method_initialize
-    parser = util_parser "Document-method: BasicObject::new\n blah */"
-
-    parser.handle_method('private_method', 'rb_cBasicObject',
-                         'initialize', 'rb_obj_dummy', -1)
-
-    bo = @top_level.find_module_named 'BasicObject'
-
-    assert_equal 1, bo.method_list.length
-
-    new = bo.method_list.first
-
-    assert_equal 'new',   new.name
-    assert_equal :public, new.visibility
-  end
-
-  def test_handle_singleton
-    parser = util_parser <<-SINGLE
-void Init_Blah(void) {
-  cDate = rb_define_class("Date", rb_cObject);
-  sDate = rb_singleton_class(cDate);
-}
-    SINGLE
-
-    parser.scan
-
-    assert_equal 'Date', parser.known_classes['sDate']
-    assert_equal 'Date', parser.singleton_classes['sDate']
-  end
-
-  def test_look_for_directives_in
-    parser = util_parser
-
-    comment = RDoc::Comment.new "# :other: not_handled\n"
-
-    parser.look_for_directives_in @top_level, comment
-
-    assert_equal "# :other: not_handled\n", comment.text
-    assert_equal 'not_handled', @top_level.metadata['other']
-  end
-
-  def test_load_variable_map
-    some_ext = @top_level.add_class RDoc::NormalClass, 'SomeExt'
-               @top_level.add_class RDoc::NormalClass, 'OtherExt'
-
-    @store.cache[:c_class_variables][@fn]       = { 'cSomeExt'  => 'SomeExt'  }
-    @store.cache[:c_class_variables]['other.c'] = { 'cOtherExt' => 'OtherExt' }
-
-    parser = util_parser
-
-    map = parser.load_variable_map :c_class_variables
-
-    expected = { 'cSomeExt' => some_ext }
-
-    assert_equal expected, map
-
-    assert_equal 'SomeExt', parser.known_classes['cSomeExt']
-    assert_nil              parser.known_classes['cOtherExt']
-  end
-
-  def test_load_variable_map_empty
-    parser = util_parser
-
-    map = parser.load_variable_map :c_class_variables
-
-    assert_empty map
-  end
-
-  def test_load_variable_map_legacy
-    @store.cache[:c_class_variables] = nil
-
-    parser = util_parser
-
-    map = parser.load_variable_map :c_class_variables
-
-    assert_empty map
-  end
-
-  def test_load_variable_map_singleton
-    @top_level.add_class RDoc::NormalClass, 'SomeExt'
-    @top_level.add_class RDoc::NormalClass, 'OtherExt'
-
-    @store.cache[:c_singleton_class_variables][@fn] =
-      { 'cSomeExt'  => 'SomeExt'  }
-    @store.cache[:c_singleton_class_variables]['other.c'] =
-      { 'cOtherExt' => 'OtherExt' }
-
-    parser = util_parser
-
-    map = parser.load_variable_map :c_singleton_class_variables
-
-    expected = { 'cSomeExt' => 'SomeExt' }
-
-    assert_equal expected, map
-
-    assert_equal 'SomeExt', parser.known_classes['cSomeExt']
-    assert_nil              parser.known_classes['cOtherExt']
-  end
-
-  def test_load_variable_map_trim
-    a = @top_level.add_class RDoc::NormalClass, 'A'
-
-    @store.cache[:c_class_variables][@fn] = {
-      'cA'  => 'A',
-      'cB'  => 'B',
-    }
-
-    parser = util_parser
-
-    map = parser.load_variable_map :c_class_variables
-
-    expected = { 'cA' => a }
-
-    assert_equal expected, map
-  end
-
-  def test_define_method
-    content = <<-EOF
-/*Method Comment! */
-static VALUE
-rb_io_s_read(argc, argv, io)
-    int argc;
-    VALUE *argv;
-    VALUE io;
-{
-}
-
-void
-Init_IO(void) {
-    /*
-     * a comment for class Foo on rb_define_class
-     */
-    VALUE rb_cIO = rb_define_class("IO", rb_cObject);
-    rb_define_singleton_method(rb_cIO, "read", rb_io_s_read, -1);
-}
-    EOF
-
-    klass = util_get_class content, 'rb_cIO'
-    read_method = klass.method_list.first
-    assert_equal "read", read_method.name
-    assert_equal "Method Comment!   ", read_method.comment.text
-    assert_equal "rb_io_s_read", read_method.c_function
-    assert read_method.singleton
-    assert_nil read_method.section.title
-  end
-
-  def test_define_method_with_category
-    content = <<-EOF
-/* :category: Awesome Methods
-   Method Comment!
- */
-static VALUE
-rb_io_s_read(argc, argv, io)
-    int argc;
-    VALUE *argv;
-    VALUE io;
-{
-}
-
-void
-Init_IO(void) {
-    /*
-     * a comment for class Foo on rb_define_class
-     */
-    VALUE rb_cIO = rb_define_class("IO", rb_cObject);
-    rb_define_singleton_method(rb_cIO, "read", rb_io_s_read, -1);
-}
-    EOF
-
-    klass = util_get_class content, 'rb_cIO'
-    read_method = klass.method_list.first
-    assert_equal "read", read_method.name
-    assert_equal "Method Comment!", read_method.comment.text.strip
-    assert_equal "rb_io_s_read", read_method.c_function
-    assert read_method.singleton
-    assert_equal "Awesome Methods", read_method.section.title
-  end
-
-  def test_define_method_dynamically
-    content = <<-EOF
-void
-Init_foo(void)
-{
-    rb_define_singleton_method(obj, "foo", foo, -1);
-}
-    EOF
-
-    klass = util_get_class content, 'obj'
-    assert_nil klass
-  end
-
-  def test_define_method_with_prototype
-    content = <<-EOF
-static VALUE rb_io_s_read(int, VALUE*, VALUE);
-
-/* Method Comment! */
-static VALUE
-rb_io_s_read(argc, argv, io)
-    int argc;
-    VALUE *argv;
-    VALUE io;
-{
-}
-
-void
-Init_IO(void) {
-    /*
-     * a comment for class Foo on rb_define_class
-     */
-    VALUE rb_cIO = rb_define_class("IO", rb_cObject);
-    rb_define_singleton_method(rb_cIO, "read", rb_io_s_read, -1);
-}
-    EOF
-
-    klass = util_get_class content, 'rb_cIO'
-    read_method = klass.method_list.first
-    assert_equal "read", read_method.name
-    assert_equal "Method Comment!   ", read_method.comment.text
-    assert_equal "rb_io_s_read", read_method.c_function
-    assert read_method.singleton
-  end
-
-  def test_define_method_private
-    content = <<-EOF
-/*Method Comment! */
-static VALUE
-rb_io_s_read(argc, argv, io)
-    int argc;
-    VALUE *argv;
-    VALUE io;
-{
-}
-
-void
-Init_IO(void) {
-    /*
-     * a comment for class Foo on rb_define_class
-     */
-    VALUE rb_cIO = rb_define_class("IO", rb_cObject);
-    rb_define_private_method(rb_cIO, "read", rb_io_s_read, -1);
-}
-    EOF
-
-    klass = util_get_class content, 'rb_cIO'
-    read_method = klass.method_list.first
-    assert_equal 'IO#read', read_method.full_name
-    assert_equal :private, read_method.visibility
-    assert_equal "Method Comment!   ", read_method.comment.text
-  end
-
-  def test_define_method_private_singleton
-    content = <<-EOF
-/*Method Comment! */
-static VALUE
-rb_io_s_read(argc, argv, io)
-    int argc;
-    VALUE *argv;
-    VALUE io;
-{
-}
-
-void
-Init_IO(void) {
-    /*
-     * a comment for class Foo on rb_define_class
-     */
-    VALUE rb_cIO = rb_define_class("IO", rb_cObject);
-    VALUE rb_cIO_s = rb_singleton_class(rb_cIO);
-    rb_define_private_method(rb_cIO_s, "read", rb_io_s_read, -1);
-}
-    EOF
-
-    klass = util_get_class content, 'rb_cIO'
-    read_method = klass.method_list.first
-    assert_equal "read", read_method.name
-    assert_equal "Method Comment!   ", read_method.comment.text
-    assert_equal :private, read_method.visibility
-    assert read_method.singleton
-  end
-
-  def test_define_method_singleton
-    content = <<-EOF
-/*Method Comment! */
-static VALUE
-rb_io_s_read(argc, argv, io)
-    int argc;
-    VALUE *argv;
-    VALUE io;
-{
-}
-
-void
-Init_IO(void) {
-    /*
-     * a comment for class Foo on rb_define_class
-     */
-    VALUE rb_cIO = rb_define_class("IO", rb_cObject);
-    VALUE rb_cIO_s = rb_singleton_class(rb_cIO);
-    rb_define_method(rb_cIO_s, "read", rb_io_s_read, -1);
-}
-    EOF
-
-    klass = util_get_class content, 'rb_cIO'
-    read_method = klass.method_list.first
-    assert_equal "read", read_method.name
-    assert_equal "Method Comment!   ", read_method.comment.text
-    assert read_method.singleton
-  end
-
-  def test_rb_scan_args
-    parser = util_parser
-
-    assert_equal '(p1)',
-                 parser.rb_scan_args('rb_scan_args(a, b, "1",)')
-    assert_equal '(p1, p2)',
-                 parser.rb_scan_args('rb_scan_args(a, b, "2",)')
-
-    assert_equal '(p1 = v1)',
-                 parser.rb_scan_args('rb_scan_args(a, b, "01",)')
-    assert_equal '(p1 = v1, p2 = v2)',
-                 parser.rb_scan_args('rb_scan_args(a, b, "02",)')
-
-    assert_equal '(p1, p2 = v2)',
-                 parser.rb_scan_args('rb_scan_args(a, b, "11",)')
-
-    assert_equal '(p1, *args)',
-                 parser.rb_scan_args('rb_scan_args(a, b, "1*",)')
-    assert_equal '(p1, p2 = {})',
-                 parser.rb_scan_args('rb_scan_args(a, b, "1:",)')
-    assert_equal '(p1, &block)',
-                 parser.rb_scan_args('rb_scan_args(a, b, "1&",)')
-
-    assert_equal '(p1, p2)',
-                 parser.rb_scan_args('rb_scan_args(a, b, "101",)')
-
-    assert_equal '(p1, p2 = v2, p3)',
-                 parser.rb_scan_args('rb_scan_args(a, b, "111",)')
-
-    assert_equal '(p1, *args, p3)',
-                 parser.rb_scan_args('rb_scan_args(a, b, "1*1",)')
-
-    assert_equal '(p1, p2 = v2, *args)',
-                 parser.rb_scan_args('rb_scan_args(a, b, "11*",)')
-    assert_equal '(p1, p2 = v2, p3 = {})',
-                 parser.rb_scan_args('rb_scan_args(a, b, "11:",)')
-    assert_equal '(p1, p2 = v2, &block)',
-                 parser.rb_scan_args('rb_scan_args(a, b, "11&",)')
-
-    assert_equal '(p1, p2 = v2, *args, p4, p5 = {}, &block)',
-                 parser.rb_scan_args('rb_scan_args(a, b, "11*1:&",)')
-
-    # The following aren't valid according to spec but are according to the
-    # implementation.
-    assert_equal '(*args)',
-                 parser.rb_scan_args('rb_scan_args(a, b, "*",)')
-    assert_equal '(p1 = {})',
-                 parser.rb_scan_args('rb_scan_args(a, b, ":",)')
-    assert_equal '(&block)',
-                 parser.rb_scan_args('rb_scan_args(a, b, "&",)')
-
-    assert_equal '(*args, p2 = {})',
-                 parser.rb_scan_args('rb_scan_args(a, b, "*:",)')
-    assert_equal '(p1 = {}, &block)',
-                 parser.rb_scan_args('rb_scan_args(a, b, ":&",)')
-    assert_equal '(*args, p2 = {}, &block)',
-                 parser.rb_scan_args('rb_scan_args(a, b, "*:&",)')
-  end
-
-  def test_scan
-    parser = util_parser <<-C
-void Init(void) {
-    mM = rb_define_module("M");
-    cC = rb_define_class("C", rb_cObject);
-    sC = rb_singleton_class(cC);
-}
-    C
-
-    parser.scan
-
-    expected = {
-      @fn => {
-        'mM' => 'M',
-        'cC' => 'C', }}
-    assert_equal expected, @store.c_class_variables
-
-    expected = {
-      @fn => {
-        'sC' => 'C' } }
-    assert_equal expected, @store.c_singleton_class_variables
-  end
-
-  def test_scan_method_copy
-    parser = util_parser <<-C
-/*
- *  call-seq:
- *    pathname.to_s    -> string
- *    pathname.to_path -> string
- *
- *  Return the path as a String.
- *
- *  to_path is implemented so Pathname objects are usable with File.open, etc.
- */
-static VALUE
-path_to_s(VALUE self) { }
-
-/*
- *  call-seq:
- *     str[index]               -> new_str or nil
- *     str[start, length]       -> new_str or nil
- *     str.slice(index)         -> new_str or nil
- *     str.slice(start, length) -> new_str or nil
- */
-static VALUE
-path_aref_m(int argc, VALUE *argv, VALUE str) { }
-
-/*
- *  call-seq:
- *     string <=> other_string   -> -1, 0, +1 or nil
- */
-static VALUE
-path_cmp_m(VALUE str1, VALUE str2) { }
-
-/*
- *  call-seq:
- *     str == obj    -> true or false
- *     str === obj   -> true or false
- */
-VALUE
-rb_str_equal(VALUE str1, VALUE str2) { }
-
-Init_pathname()
-{
-    rb_cPathname = rb_define_class("Pathname", rb_cObject);
-
-    rb_define_method(rb_cPathname, "to_s",    path_to_s, 0);
-    rb_define_method(rb_cPathname, "to_path", path_to_s, 0);
-    rb_define_method(rb_cPathname, "[]",      path_aref_m, -1);
-    rb_define_method(rb_cPathname, "slice",   path_aref_m, -1);
-    rb_define_method(rb_cPathname, "<=>",     path_cmp_m, 1);
-    rb_define_method(rb_cPathname, "==",      rb_str_equal), 2);
-    rb_define_method(rb_cPathname, "===",     rb_str_equal), 2);
-}
-    C
-
-    parser.scan
-
-    pathname = @store.classes_hash['Pathname']
-
-    to_path = pathname.method_list.find { |m| m.name == 'to_path' }
-    assert_equal "pathname.to_path -> string", to_path.call_seq
-
-    to_s = pathname.method_list.find { |m| m.name == 'to_s' }
-    assert_equal "pathname.to_s    -> string", to_s.call_seq
-
-    index_expected = <<-EXPECTED.chomp
-str[index]               -> new_str or nil
-str[start, length]       -> new_str or nil
-    EXPECTED
-
-    index = pathname.method_list.find { |m| m.name == '[]' }
-    assert_equal index_expected, index.call_seq, '[]'
-
-    slice_expected = <<-EXPECTED.chomp
-str.slice(index)         -> new_str or nil
-str.slice(start, length) -> new_str or nil
-    EXPECTED
-
-    slice = pathname.method_list.find { |m| m.name == 'slice' }
-    assert_equal slice_expected, slice.call_seq
-
-    spaceship = pathname.method_list.find { |m| m.name == '<=>' }
-    assert_equal "string <=> other_string   -> -1, 0, +1 or nil",
-                 spaceship.call_seq
-
-    equals2 = pathname.method_list.find { |m| m.name == '==' }
-    assert_match 'str == obj', equals2.call_seq
-
-    equals3 = pathname.method_list.find { |m| m.name == '===' }
-    assert_match 'str === obj', equals3.call_seq
-  end
-
-  def test_scan_order_dependent
-    parser = util_parser <<-C
-void a(void) {
-    mA = rb_define_module("A");
-}
-
-void b(void) {
-    cB = rb_define_class_under(mA, "B", rb_cObject);
-}
-
-void c(void) {
-    mC = rb_define_module_under(cB, "C");
-}
-
-void d(void) {
-    mD = rb_define_class_under(mC, "D");
-}
-    C
-
-    parser.scan
-
-    assert_equal %w[A A::B A::B::C],
-                 @store.all_classes_and_modules.map { |m| m.full_name }.sort
-  end
-
-  def test_markup_format_default
-    content = <<-EOF
-void Init_Blah(void) {
-  cBlah = rb_define_class("Blah", rb_cObject);
-
-  /*
-   * This should be interpreted in the default format.
-   */
-  rb_attr(cBlah, rb_intern("default_format"), 1, 1, Qfalse);
-}
-    EOF
-
-    klass = util_get_class content, 'cBlah'
-    assert_equal("rdoc", klass.attributes.find {|a| a.name == "default_format"}.comment.format)
-  end
-
-  def test_markup_format_override
-    content = <<-EOF
-void Init_Blah(void) {
-  cBlah = rb_define_class("Blah", rb_cObject);
-
-  /*
-   * This should be interpreted in the default format.
-   */
-  rb_attr(cBlah, rb_intern("default_format"), 1, 1, Qfalse);
-}
-    EOF
-
-    @options.markup = "markdown"
-    klass = util_get_class content, 'cBlah'
-    assert_equal("markdown", klass.attributes.find {|a| a.name == "default_format"}.comment.format)
-  end
-
-  def util_get_class(content, name = nil)
-    @parser = util_parser content
-    @parser.scan
-
-    @parser.classes[name] if name
-  end
-
-  def util_parser(content = '')
-    RDoc::Parser::C.new @top_level, content, @options, @stats
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc_parser_changelog_test.rb b/test/mri/rdoc/rdoc_parser_changelog_test.rb
deleted file mode 100644
index 4557eacae1f..00000000000
--- a/test/mri/rdoc/rdoc_parser_changelog_test.rb
+++ /dev/null
@@ -1,483 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocParserChangeLogTest < RDoc::TestCase
-
-  def setup
-    super
-
-    @tempfile  = Tempfile.new 'ChangeLog'
-    @top_level = @store.add_file @tempfile.path
-    @options   = RDoc::Options.new
-    @stats     = RDoc::Stats.new @store, 0
-  end
-
-  def teardown
-    @tempfile.close!
-
-    super
-  end
-
-  def test_class_can_parse
-    parser = RDoc::Parser::ChangeLog
-
-    temp_dir do
-      FileUtils.touch 'ChangeLog'
-      assert_equal parser, parser.can_parse('ChangeLog')
-
-      assert_equal parser, parser.can_parse(@tempfile.path)
-
-      FileUtils.touch 'ChangeLog.rb'
-      assert_equal RDoc::Parser::Ruby, parser.can_parse('ChangeLog.rb')
-    end
-  end
-
-  def test_continue_entry_body
-    parser = util_parser
-
-    entry_body = ['a'.dup]
-
-    parser.continue_entry_body entry_body, 'b'
-
-    assert_equal ['a b'], entry_body
-  end
-
-  def test_continue_entry_body_empty
-    parser = util_parser
-
-    entry_body = []
-
-    parser.continue_entry_body entry_body, ''
-
-    assert_empty entry_body
-  end
-
-  def test_continue_entry_body_function
-    parser = util_parser
-
-    entry_body = ['file: (func1)'.dup]
-
-    parser.continue_entry_body entry_body, '(func2): blah'
-
-    assert_equal ['file: (func1, func2): blah'], entry_body
-  end
-
-  def test_create_document
-    parser = util_parser
-
-    groups = {
-      '2012-12-04' => [
-        ['Tue Dec  4 08:33:46 2012  Eric Hodel  <drbrain@segment7.net>',
-          %w[a:one b:two]],
-        ['Tue Dec  4 08:32:10 2012  Eric Hodel  <drbrain@segment7.net>',
-          %w[c:three d:four]]],
-      '2012-12-03' => [
-        ['Mon Dec  3 20:28:02 2012  Koichi Sasada  <ko1@atdot.net>',
-          %w[e:five f:six]]],
-    }
-
-    expected =
-      doc(
-        head(1, File.basename(@tempfile.path)),
-        blank_line,
-        head(2, '2012-12-04'),
-        blank_line,
-        head(3, 'Tue Dec  4 08:33:46 2012  Eric Hodel  <drbrain@segment7.net>'),
-        blank_line,
-        list(:NOTE, item('a', para('one')), item('b', para('two'))),
-        head(3, 'Tue Dec  4 08:32:10 2012  Eric Hodel  <drbrain@segment7.net>'),
-        blank_line,
-        list(:NOTE, item('c', para('three')), item('d', para('four'))),
-        head(2, '2012-12-03'),
-        blank_line,
-        head(3, 'Mon Dec  3 20:28:02 2012  Koichi Sasada  <ko1@atdot.net>'),
-        blank_line,
-        list(:NOTE, item('e', para('five')), item('f', para('six'))))
-
-    expected.file = @top_level
-
-    document = parser.create_document(groups)
-
-    assert_equal expected, document
-
-    assert_equal 2, document.omit_headings_below
-
-    headings = document.parts.select do |part|
-      RDoc::Markup::Heading === part and part.level == 2
-    end
-
-    refute headings.all? { |heading| heading.text.frozen? }
-  end
-
-  def test_create_entries
-    parser = util_parser
-
-    entries = [
-      ['Tue Dec  1 02:03:04 2012  Eric Hodel  <drbrain@segment7.net>',
-        %w[a:one b:two]],
-      ['Tue Dec  5 06:07:08 2012  Eric Hodel  <drbrain@segment7.net>',
-        %w[c:three d:four]],
-    ]
-
-    expected = [
-      head(3, 'Tue Dec  1 02:03:04 2012  Eric Hodel  <drbrain@segment7.net>'),
-      blank_line,
-      list(:NOTE, item('a', para('one')), item('b', para('two'))),
-      head(3, 'Tue Dec  5 06:07:08 2012  Eric Hodel  <drbrain@segment7.net>'),
-      blank_line,
-      list(:NOTE, item('c', para('three')), item('d', para('four'))),
-    ]
-
-    entries = parser.create_entries(entries)
-    assert_equal expected, entries
-  end
-
-  def test_create_entries_colons
-    parser = util_parser
-
-    entries = [
-      ['Wed Dec  5 12:17:11 2012  Naohisa Goto  <ngotogenome@gmail.com>',
-        ['func.rb (DL::Function#bind): log stuff [ruby-core:50562]']],
-    ]
-
-    expected = [
-      head(3,
-           'Wed Dec  5 12:17:11 2012  Naohisa Goto  <ngotogenome@gmail.com>'),
-      blank_line,
-      list(:NOTE,
-           item('func.rb (DL::Function#bind)',
-                para('log stuff [ruby-core:50562]')))]
-
-    assert_equal expected, parser.create_entries(entries)
-  end
-
-  def test_create_items
-    parser = util_parser
-
-    items = [
-	    'README.EXT:  Converted to RDoc format',
-	    'README.EXT.ja:  ditto',
-    ]
-
-    expected =
-      list(:NOTE,
-        item('README.EXT',
-          para('Converted to RDoc format')),
-        item('README.EXT.ja',
-          para('ditto')))
-
-    assert_equal expected, parser.create_items(items)
-  end
-
-  def test_group_entries
-    parser = util_parser
-
-    entries = [
-      [ 'Tue Dec  4 08:33:46 2012  Eric Hodel  <drbrain@segment7.net>',
-        %w[one two]],
-      [ 'Tue Dec  4 08:32:10 2012  Eric Hodel  <drbrain@segment7.net>',
-        %w[three four]],
-      [ 'Mon Dec  3 20:28:02 2012  Koichi Sasada  <ko1@atdot.net>',
-        %w[five six]],
-      [ '2008-01-30  H.J. Lu  <hongjiu.lu@intel.com>',
-        %w[seven eight]]]
-
-    expected = {
-      '2012-12-04' => [
-        ['Tue Dec  4 08:33:46 2012  Eric Hodel  <drbrain@segment7.net>',
-          %w[one two]],
-        ['Tue Dec  4 08:32:10 2012  Eric Hodel  <drbrain@segment7.net>',
-          %w[three four]]],
-      '2012-12-03' => [
-        ['Mon Dec  3 20:28:02 2012  Koichi Sasada  <ko1@atdot.net>',
-          %w[five six]]],
-      '2008-01-30' => [
-        ['2008-01-30  H.J. Lu  <hongjiu.lu@intel.com>',
-          %w[seven eight]]],
-    }
-
-    assert_equal expected, parser.group_entries(entries)
-  end
-
-  def test_parse_entries
-    parser = util_parser <<-ChangeLog
-Tue Dec  4 08:33:46 2012  Eric Hodel  <drbrain@segment7.net>
-
-	* README.EXT:  Converted to RDoc format
-	* README.EXT.ja:  ditto
-
-Mon Dec  3 20:28:02 2012  Koichi Sasada  <ko1@atdot.net>
-
-	* compile.c (iseq_specialized_instruction):
-	  change condition of using `opt_send_simple'.
-	  More method invocations can be simple.
-
-commit\ 8187228de0142d3ac7950b7d977c2849e934c637
-
-Other note that will be ignored
-
-    ChangeLog
-
-    expected = [
-      [ 'Tue Dec  4 08:33:46 2012  Eric Hodel  <drbrain@segment7.net>',
-        [ 'README.EXT:  Converted to RDoc format',
-          'README.EXT.ja:  ditto']],
-      [ 'Mon Dec  3 20:28:02 2012  Koichi Sasada  <ko1@atdot.net>',
-        [ 'compile.c (iseq_specialized_instruction): change condition of ' +
-          'using `opt_send_simple\'. More method invocations can be simple.']]]
-
-    assert_equal expected, parser.parse_entries
-  end
-
-  def test_parse_entries_bad_time
-    parser = util_parser <<-ChangeLog
-2008-01-30  H.J. Lu  <hongjiu.lu@intel.com>
-
-        PR libffi/34612
-        * src/x86/sysv.S (ffi_closure_SYSV): Pop 4 byte from stack when
-        returning struct.
-
-    ChangeLog
-
-    expected = [
-      [ '2008-01-30  H.J. Lu  <hongjiu.lu@intel.com>',
-        [ 'src/x86/sysv.S (ffi_closure_SYSV): Pop 4 byte from stack when ' +
-          'returning struct.']]
-    ]
-
-    assert_equal expected, parser.parse_entries
-  end
-
-  def test_parse_entries_gnu
-    parser = util_parser <<-ChangeLog
-1998-08-17  Richard Stallman  <rms@gnu.org>
-
-* register.el (insert-register): Return nil.
-(jump-to-register): Likewise.
-
-* sort.el (sort-subr): Return nil.
-
-* keyboard.c (menu_bar_items, tool_bar_items)
-(Fexecute_extended_command): Deal with 'keymap' property.
-    ChangeLog
-
-    expected = [
-      [ '1998-08-17  Richard Stallman  <rms@gnu.org>',
-        [ 'register.el (insert-register): Return nil.',
-          '(jump-to-register): Likewise.',
-          'sort.el (sort-subr): Return nil.',
-          'keyboard.c (menu_bar_items, tool_bar_items, ' +
-          'Fexecute_extended_command): Deal with \'keymap\' property.']]]
-
-    assert_equal expected, parser.parse_entries
-  end
-
-  def test_parse_entries_git
-    parser = util_parser <<-ChangeLog
-commit\ 709bed2afaee50e2ce803f87bf1ee8291bea41e3
-  Author: git <svn-admin@ruby-lang.org>
-  Date:   2021-01-21 01:03:52 +0900
-
-    * 2021-01-21 [ci skip]
-ChangeLog
-
-    expected = [
-      [ "709bed2afaee50e2ce80",
-       [ "git", "svn-admin@ruby-lang.org",
-         "2021-01-21 01:03:52 +0900",
-         "* 2021-01-21 [ci skip]\n"]]]
-
-    assert_equal expected, parser.parse_entries
-  end
-
-  def test_scan
-    parser = util_parser <<-ChangeLog
-Tue Dec  4 08:32:10 2012  Eric Hodel  <drbrain@segment7.net>
-
-	* lib/rdoc/ri/driver.rb:  Fixed ri page display for files with
-	  extensions.
-	* test/rdoc/test_rdoc_ri_driver.rb:  Test for above
-
-Mon Dec  3 20:37:22 2012  Koichi Sasada  <ko1@atdot.net>
-
-	* vm_exec.c: check VM_COLLECT_USAGE_DETAILS.
-
-    ChangeLog
-
-    parser.scan
-
-    expected = doc(
-      head(1, File.basename(@tempfile.path)),
-      blank_line,
-      head(2, '2012-12-04'),
-      blank_line,
-      head(3, 'Tue Dec  4 08:32:10 2012  Eric Hodel  <drbrain@segment7.net>'),
-      blank_line,
-      list(:NOTE,
-        item('lib/rdoc/ri/driver.rb', para('Fixed ri page display for ' +
-                       'files with extensions.')),
-        item('test/rdoc/test_rdoc_ri_driver.rb', para('Test for above'))),
-      head(2, '2012-12-03'),
-      blank_line,
-      head(3, 'Mon Dec  3 20:37:22 2012  Koichi Sasada  <ko1@atdot.net>'),
-      blank_line,
-      list(:NOTE,
-        item('vm_exec.c', para('check VM_COLLECT_USAGE_DETAILS.'))))
-
-    expected.file = @top_level
-
-    assert_equal expected, @top_level.comment.parse
-  end
-
-  def test_scan_git
-    parser = util_parser <<-ChangeLog
-commit\ 38816887962ec167ee46acf500f68df5c3013163
-Author: git <svn-admin@ruby-lang.org>
-Date:   Sun Jan 24 14:35:51 2021 +0900
-
-    * 2021-01-24 [ci skip]
-
-commit\ db7d0b89f6eca66cc7eb155c95f9123133da1ffc
-Author: git <svn-admin@ruby-lang.org>
-Date:   Sat, 23 Jan 2021 06:01:39 +0900
-
-    * 2021-01-23 [ci skip]
-
-commit\ a3efbda7128ef20b55505b32d1608ea48f80af4a
-Author: git <svn-admin@ruby-lang.org>
-Date:   2021-01-22T02:49:39+09:00
-
-    * 2021-01-22 [ci skip]
-
-commit\ 709bed2afaee50e2ce803f87bf1ee8291bea41e3
-  Author: git <svn-admin@ruby-lang.org>
-  Date:   2021-01-21 01:03:52 +0900
-
-    * 2021-01-21 [ci skip]
-
-commit\ a8dc5156e183489c5121fb1759bda5d9406d9175
-  Author: git <svn-admin@ruby-lang.org>
-  Date:   2021-01-20 01:58:26 +0900
-
-    * 2021-01-20 [ci skip]
-
-commit\ de5f8a92d5001799bedb3b1a271a2d9b23c6c8fb
-  Author: Masataka Pocke Kuwabara <kuwabara@pocke.me>
-  Date:   2021-01-01 14:25:08 +0900
-
-    Make args info for RubyVM::AST to available on endless method without parens
-
-    Problem
-    ===
-
-    Arguments information is missing for endless method without parens.
-    For example:
-
-    ```ruby
-    # ok
-    ```
-
-    It causes an error if a program expects `args` node exists.
-
-    Solution
-    ===
-
-    Call `new_args` on this case.
-ChangeLog
-
-    parser.scan
-
-    expected = doc(
-      head(1, File.basename(@tempfile.path)),
-      blank_line,
-      head(2, '2021-01-24'),
-      blank_line,
-      log_entry(nil, '38816887962ec167ee46',
-                'git', 'svn-admin@ruby-lang.org', 'Sun Jan 24 14:35:51 2021 +0900',
-                [list(:BULLET, item(nil, para('2021-01-24 [ci skip]')))]),
-      head(2, '2021-01-23'),
-      blank_line,
-      log_entry(nil, 'db7d0b89f6eca66cc7eb',
-                'git', 'svn-admin@ruby-lang.org', 'Sat, 23 Jan 2021 06:01:39 +0900',
-                [list(:BULLET, item(nil, para('2021-01-23 [ci skip]')))]),
-      head(2, '2021-01-22'),
-      blank_line,
-      log_entry(nil, 'a3efbda7128ef20b5550',
-                'git', 'svn-admin@ruby-lang.org', '2021-01-22T02:49:39+09:00',
-                [list(:BULLET, item(nil, para('2021-01-22 [ci skip]')))]),
-      head(2, '2021-01-21'),
-      blank_line,
-      log_entry(nil, '709bed2afaee50e2ce80',
-                'git', 'svn-admin@ruby-lang.org', '2021-01-21 01:03:52 +0900',
-                [list(:BULLET, item(nil, para('2021-01-21 [ci skip]')))]),
-      head(2, '2021-01-20'),
-      blank_line,
-      log_entry(nil, 'a8dc5156e183489c5121',
-                'git', 'svn-admin@ruby-lang.org', '2021-01-20 01:58:26 +0900',
-                [list(:BULLET, item(nil, para('2021-01-20 [ci skip]')))]),
-      head(2, '2021-01-01'),
-      blank_line,
-      log_entry(nil, 'de5f8a92d5001799bedb',
-                'Masataka Pocke Kuwabara', 'kuwabara@pocke.me', '2021-01-01 14:25:08 +0900',
-                [head(4, 'Make args info for RubyVM::AST to available on endless method without parens'),
-                 head(5, 'Problem'),
-                 para("Arguments information is missing for endless method without parens.\n" +
-                      "For example:"),
-                 verb("# ok\n").tap {|v| v.format = :ruby},
-                 para('It causes an error if a program expects <code>args</code> node exists.'),
-                 head(5, 'Solution'),
-                 para('Call <code>new_args</code> on this case.')]))
-
-    expected.file = @top_level
-
-    assert_equal expected, @top_level.comment.parse
-  end
-
-  def test_scan_git_commit_date
-    parser = util_parser <<-ChangeLog
-commit\ ee1e690a2df901adb279d7a63fbd92c64e0a5ae6
-  Author:     Igor Zubkov <igor.zubkov@gmail.com>
-  AuthorDate: 2016-10-25 03:56:11 +0900
-  Commit:     Nobuyoshi Nakada <nobu@ruby-lang.org>
-  CommitDate: 2021-01-07 13:40:42 +0900
-
-    We don't need "require 'uri'" after "require 'net/http'".
-
-commit\ 4d0985a7bd8f591dff4b430e288bfd83af782e51
-  Author:     git <svn-admin@ruby-lang.org>
-  AuthorDate: 2021-01-07 10:21:34 +0900
-  Commit:     git <svn-admin@ruby-lang.org>
-  CommitDate: 2021-01-07 10:21:34 +0900
-
-    * 2021-01-07 [ci skip]
-ChangeLog
-
-    parser.scan
-
-    expected = doc(
-      head(1, File.basename(@tempfile.path)),
-      blank_line,
-      head(2, "2021-01-07"),
-      blank_line,
-      log_entry(nil, 'ee1e690a2df901adb279',
-                'Igor Zubkov', 'igor.zubkov@gmail.com',
-                '2016-10-25 03:56:11 +0900',
-                [head(4, %[We don't need "require 'uri'" after "require 'net/http'".])]),
-      log_entry(nil, '4d0985a7bd8f591dff4b',
-                'git', 'svn-admin@ruby-lang.org',
-                '2021-01-07 10:21:34 +0900',
-                [list(:BULLET, item(nil, para("2021-01-07 [ci skip]")))]))
-
-    expected.file = @top_level
-
-    assert_equal expected, @top_level.comment.parse
-  end
-
-  def util_parser(content = '')
-    RDoc::Parser::ChangeLog.new @top_level, content, @options, @stats
-  end
-
-  def log_entry(*a)
-    RDoc::Parser::ChangeLog::Git::LogEntry.new(*a)
-  end
-end
diff --git a/test/mri/rdoc/rdoc_parser_markdown_test.rb b/test/mri/rdoc/rdoc_parser_markdown_test.rb
deleted file mode 100644
index 49da5693d60..00000000000
--- a/test/mri/rdoc/rdoc_parser_markdown_test.rb
+++ /dev/null
@@ -1,61 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocParserMarkdownTest < RDoc::TestCase
-
-  def setup
-    super
-
-    @RP = RDoc::Parser
-
-    @tempfile = Tempfile.new self.class.name
-    filename = @tempfile.path
-
-    @top_level = @store.add_file filename
-    @fn = filename
-    @options = RDoc::Options.new
-    @stats = RDoc::Stats.new @store, 0
-  end
-
-  def teardown
-    super
-
-    @tempfile.close!
-  end
-
-  def test_file
-    assert_kind_of RDoc::Parser::Text, util_parser('')
-  end
-
-  def test_class_can_parse
-    temp_dir do
-      FileUtils.touch 'foo.md'
-      assert_equal @RP::Markdown, @RP.can_parse('foo.md')
-      FileUtils.touch 'foo.md.ja'
-      assert_equal @RP::Markdown, @RP.can_parse('foo.md.ja')
-
-      FileUtils.touch 'foo.markdown'
-      assert_equal @RP::Markdown, @RP.can_parse('foo.markdown')
-      FileUtils.touch 'foo.markdown.ja'
-      assert_equal @RP::Markdown, @RP.can_parse('foo.markdown.ja')
-    end
-  end
-
-  def test_scan
-    parser = util_parser 'it *really* works'
-
-    expected =
-      @RM::Document.new(
-        @RM::Paragraph.new('it _really_ works'))
-    expected.file = @top_level
-
-    parser.scan
-
-    assert_equal expected, @top_level.comment.parse
-  end
-
-  def util_parser(content)
-    RDoc::Parser::Markdown.new @top_level, content, @options, @stats
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc_parser_prism_ruby_test.rb b/test/mri/rdoc/rdoc_parser_prism_ruby_test.rb
deleted file mode 100644
index 578123b740a..00000000000
--- a/test/mri/rdoc/rdoc_parser_prism_ruby_test.rb
+++ /dev/null
@@ -1,2165 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'helper'
-require 'rdoc/parser'
-require 'rdoc/parser/prism_ruby'
-
-module RDocParserPrismTestCases
-  def setup
-    super
-
-    @tempfile = Tempfile.new self.class.name
-    @filename = @tempfile.path
-
-    @top_level = @store.add_file @filename
-
-    @options = RDoc::Options.new
-    @options.quiet = true
-    @options.option_parser = OptionParser.new
-
-    @comment = RDoc::Comment.new '', @top_level
-
-    @stats = RDoc::Stats.new @store, 0
-  end
-
-  def teardown
-    super
-
-    @tempfile.close!
-  end
-
-  def test_look_for_directives_in_section
-    util_parser <<~RUBY
-      # :section: new section
-    RUBY
-    section = @top_level.current_section
-    assert_equal 'new section', section.title
-  end
-
-  def test_look_for_directives_in_commented
-    util_parser <<~RUBY
-      # how to make a section:
-      # # :section: new section
-    RUBY
-    section = @top_level.current_section
-    assert_nil   section.title
-  end
-
-  def test_look_for_directives_in_unhandled
-    util_parser <<~RUBY
-      # :unhandled: blah
-    RUBY
-    assert_equal 'blah', @top_level.metadata['unhandled']
-  end
-
-  def test_block_comment
-    util_parser <<~RUBY
-      =begin rdoc
-      foo
-      =end
-      class A
-      =begin
-      bar
-      baz
-      =end
-        def f; end
-      end
-    RUBY
-    klass = @top_level.classes.first
-    meth = klass.method_list.first
-    assert_equal 'foo', klass.comment.text.strip
-    assert_equal "bar\nbaz", meth.comment.text.strip
-  end
-
-  def test_module
-    util_parser <<~RUBY
-      # my module
-      module Foo
-      end
-    RUBY
-    mod = @top_level.modules.first
-    assert_equal 'Foo', mod.full_name
-    assert_equal 'my module', mod.comment.text
-    assert_equal [@top_level], mod.in_files
-  end
-
-  def test_nested_module_with_colon
-    util_parser <<~RUBY
-      module Foo
-        module Bar; end
-        module Bar::Baz1; end
-        module ::Foo
-          module Bar2; end
-        end
-      end
-      module ::Baz; end
-      module Foo::Bar::Baz2
-        module ::Foo2
-          module Bar; end
-        end
-        module Blah; end
-      end
-    RUBY
-    module_names = @store.all_modules.map(&:full_name)
-    expected = %w[
-      Foo Foo::Bar Foo::Bar::Baz1 Foo::Bar2 Baz Foo::Bar::Baz2 Foo2 Foo2::Bar Foo::Bar::Baz2::Blah
-    ]
-    assert_equal expected.sort, module_names.sort
-  end
-
-  def test_class
-    util_parser <<~RUBY
-      # my class
-      class Foo
-      end
-    RUBY
-    klass = @top_level.classes.first
-    assert_equal 'Foo', klass.full_name
-    assert_equal 'my class', klass.comment.text
-    assert_equal [@top_level], klass.in_files
-    assert_equal 2, klass.line
-  end
-
-  def test_nested_class_with_colon
-    util_parser <<~RUBY
-      class Foo
-        class Bar; end
-        class Bar::Baz1; end
-        class ::Foo
-          class Bar2; end
-        end
-      end
-      class ::Baz; end
-      class Foo::Bar::Baz2
-        class ::Foo2
-          class Bar; end
-        end
-        class Blah; end
-      end
-    RUBY
-    class_names = @store.all_classes.map(&:full_name)
-    expected = %w[
-      Foo Foo::Bar Foo::Bar::Baz1 Foo::Bar2 Baz Foo::Bar::Baz2 Foo2 Foo2::Bar Foo::Bar::Baz2::Blah
-    ]
-    assert_equal expected.sort, class_names.sort
-  end
-
-  def test_open_class_with_superclass
-    util_parser <<~RUBY
-      class A; end
-
-      class B < A
-        def m1; end
-      end
-
-      class B < A
-        def m2; end
-      end
-
-      class C < String
-        def m1; end
-      end
-
-      class C < String
-        def m2; end
-      end
-    RUBY
-    classes = @top_level.classes
-    assert_equal 3, classes.size
-    _a, b, c = classes
-    assert_equal 'A', b.superclass.full_name
-    assert_equal 'String', c.superclass
-    assert_equal ['m1', 'm2'], b.method_list.map(&:name)
-    assert_equal ['m1', 'm2'], c.method_list.map(&:name)
-  end
-
-  def test_open_class_with_superclass_specified_later
-    util_parser <<~RUBY
-      # file_2
-      require 'file_1'
-      class A; end
-      class B; end
-      class C; end
-    RUBY
-    _a, b, c = @top_level.classes
-    assert_equal 'Object', b.superclass
-    assert_equal 'Object', c.superclass
-
-    util_parser <<~RUBY
-      # file_1
-      class B < A; end
-      class C < Unknown; end
-    RUBY
-    assert_equal 'A', b.superclass.full_name
-    assert_equal 'Unknown', c.superclass
-  end
-
-  def test_open_class_with_superclass_specified_later_with_object_defined
-    util_parser <<~RUBY
-      # file_2
-      require 'file_1'
-      class Object; end
-      class A; end
-      class B; end
-      class C; end
-    RUBY
-    _object, _a, b, c = @top_level.classes
-    # If Object exists, superclass will be a NormalClass(Object) instead of string "Object"
-    assert_equal 'Object', b.superclass.full_name
-    assert_equal 'Object', c.superclass.full_name
-
-    util_parser <<~RUBY
-      # file_1
-      class B < A; end
-      class C < Unknown; end
-    RUBY
-    assert_equal 'A', b.superclass.full_name
-    assert_equal 'Unknown', c.superclass
-  end
-
-  def test_confusing_superclass
-    util_parser <<~RUBY
-      module A
-        class B; end
-      end
-
-      module A
-        class C1 < A::B; end
-      end
-
-      class A::C2 < A::B; end
-
-      module A::A
-        class B; end
-      end
-
-      module A
-        class C3 < A::B; end
-      end
-
-      class A::C4 < A::B; end
-    RUBY
-    mod = @top_level.modules.first
-    classes = mod.classes
-    assert_equal ['A::B', 'A::C1', 'A::C2', 'A::C3', 'A::C4'], classes.map(&:full_name)
-    assert_equal ['A::B', 'A::B', 'A::A::B', 'A::B'], classes.drop(1).map(&:superclass).map(&:full_name)
-  end
-
-  def test_pseudo_recursive_superclass
-    util_parser <<~RUBY
-      module Foo
-        class Bar
-          class Foo < Bar; end
-          # This class definition is used in OpenSSL::Cipher::Cipher
-          class Bar < Bar; end
-          class Baz < Bar; end
-        end
-      end
-    RUBY
-    foo_klass = @store.find_class_named 'Foo::Bar::Foo'
-    bar_klass = @store.find_class_named 'Foo::Bar::Bar'
-    baz_klass = @store.find_class_named 'Foo::Bar::Baz'
-    assert_equal 'Foo::Bar', foo_klass.superclass.full_name
-    assert_equal 'Foo::Bar', bar_klass.superclass.full_name
-    assert_equal 'Foo::Bar::Bar', baz_klass.superclass.full_name
-  end
-
-  def test_class_module_nodoc
-    util_parser <<~RUBY
-      class Foo # :nodoc:
-      end
-
-      class Bar
-      end # :nodoc:
-
-      class Baz; end
-
-      class Baz::A; end # :nodoc:
-
-      module MFoo # :nodoc:
-      end
-
-      module MBar
-      end # :nodoc:
-
-      module MBaz; end
-
-      module MBaz::M; end; # :nodoc:
-    RUBY
-    documentables = @store.all_classes_and_modules.select(&:document_self)
-    assert_equal ['Baz', 'MBaz'], documentables.map(&:full_name) unless accept_legacy_bug?
-  end
-
-  def test_class_module_stopdoc
-    util_parser <<~RUBY
-      # comment
-      class Foo
-        class A; end
-        # :stopdoc:
-        class B; end
-      end
-
-      # comment
-      module Bar
-        module A; end
-        # :stopdoc:
-        module B; end
-      end
-    RUBY
-    klass = @top_level.classes.first
-    mod = @top_level.modules.first
-    assert_equal 'comment', klass.comment.text.strip
-    assert_equal 'comment', mod.comment.text.strip
-    assert_equal ['Foo::A'], klass.classes.select(&:document_self).map(&:full_name)
-    assert_equal ['Bar::A'], mod.modules.select(&:document_self).map(&:full_name)
-  end
-
-  def test_class_superclass
-    util_parser <<~RUBY
-      class Foo; end
-      class Bar < Foo
-      end
-      class Baz < (any expression)
-      end
-    RUBY
-    assert_equal ['Foo', 'Bar', 'Baz'], @top_level.classes.map(&:full_name)
-    foo, bar, baz = @top_level.classes
-    assert_equal foo, bar.superclass
-    assert_equal '(any expression)', baz.superclass
-  end
-
-  def test_class_new_notnew
-    util_parser <<~RUBY
-      class A
-        def initialize(*args); end
-      end
-
-      class B
-        ##
-        # :args: a, b, c
-        def initialize(*args); end
-      end
-
-      class C
-        def self.initialize(*args); end
-      end
-
-      class D
-        ##
-        # :args: a, b, c
-        def initialize(*args); end # :notnew:
-      end
-
-      class E
-        def initialize(*args); end # :not-new:
-      end
-
-      class F
-        def initialize(*args); end # :not_new:
-      end
-
-      class G
-        def initialize(*args)
-        end # :notnew:
-      end
-    RUBY
-
-    expected = [
-      'new(*args)', 'new(a, b, c)',
-      'initialize(*args)', 'initialize(a, b, c)',
-      'initialize(*args)', 'initialize(*args)',
-      'initialize(*args)'
-    ]
-    arglists = @top_level.classes.map { |c| c.method_list.first.arglists }
-    assert_equal expected, arglists
-  end
-
-  def test_class_mistaken_for_module
-    util_parser <<~RUBY
-      class A::Foo; end
-      class B::Foo; end
-      module C::Bar; end
-      module D::Baz; end
-      class A; end
-      class X < C; end
-    RUBY
-    assert_equal ['A', 'C', 'X'], @top_level.classes.map(&:full_name)
-    assert_equal ['B', 'D'], @top_level.modules.map(&:full_name)
-  end
-
-  def test_parenthesized_cdecl
-    util_parser <<~RUBY
-      module DidYouMean
-        # Not a module, but creates a dummy module for document
-        class << (NameErrorCheckers = Object.new)
-          def new; end
-        end
-      end
-    RUBY
-
-    mod = @store.find_class_or_module('DidYouMean').modules.first
-    assert_equal 'DidYouMean::NameErrorCheckers', mod.full_name
-    assert_equal ['DidYouMean::NameErrorCheckers::new'], mod.method_list.map(&:full_name)
-  end
-
-  def test_ghost_method
-    util_parser <<~RUBY
-      class Foo
-        ##
-        # :method: one
-        #
-        # my method one
-
-        ##
-        # :method:
-        # :call-seq:
-        #   two(name)
-        #
-        # my method two
-
-        ##
-        # :method: three
-        # :args: a, b
-        #
-        # my method three
-
-        # :stopdoc:
-
-        ##
-        # :method: hidden1
-        #
-        # comment
-
-        ##
-        # :method:
-        # :call-seq:
-        #   hidden2(name)
-        #
-        # comment
-      end
-    RUBY
-
-    klass = @store.find_class_named 'Foo'
-    assert_equal 3, klass.method_list.size
-    one, two, three = klass.method_list
-    assert_equal 'Foo#one', one.full_name
-    assert_equal 'Foo#two', two.full_name
-    assert_equal 'Foo#three', three.full_name
-    assert_equal 'two(name)', two.call_seq.chomp
-    assert_equal 'three(a, b)', three.arglists
-    assert_equal 'my method one', one.comment.text.strip
-    assert_equal 'my method two', two.comment.text.strip
-    assert_equal 'my method three', three.comment.text.strip
-    assert_equal 3, one.line
-    assert_equal 8, two.line
-    assert_equal 15, three.line
-    assert_equal @top_level, one.file
-    assert_equal @top_level, two.file
-    assert_equal @top_level, three.file
-  end
-
-  def test_invalid_meta_method
-    util_parser <<~RUBY
-      class Foo
-        # These are invalid meta method comments
-        # because meta method comment should start with `##`
-        # but rdoc accepts them as meta method comments for now.
-
-        # :method: m1
-
-        # :singleton-method: sm1
-
-        # :attr: a1
-
-        # :attr_reader: ar1
-
-        # :attr_writer: aw1
-
-        # :attr_accessor: arw1
-
-        # If there is a node following meta-like normal comment, it is not a meta method comment
-
-        # :method: m2
-        add_my_method(name)
-
-        # :singleton-method: sm2
-        add_my_singleton_method(name)
-
-        # :method:
-        add_my_method(:m3)
-
-        # :singleton-method:
-        add_my_singleton_method(:sm3)
-
-        # :attr:
-        add_my_attribute(:a2)
-
-        # :attr-reader:
-        add_my_attribute(:ar2)
-
-        # :attr-writer:
-        add_my_attribute(:aw2)
-
-        # :attr-accessor:
-        add_my_attribute(:arw2)
-
-        # :attr: a3
-        add_my_attribute_a3
-
-        # :attr-reader: ar3
-        add_my_attribute_ar3
-
-        # :attr-writer: aw3
-        add_my_attribute_aw2
-
-        # :attr-accessor: arw3
-        add_my_attribute_arw3
-      end
-    RUBY
-
-    klass = @store.find_class_named 'Foo'
-    assert_equal ['m1', 'sm1'], klass.method_list.map(&:name)
-    assert_equal ['a1', 'ar1', 'aw1', 'arw1'], klass.attributes.map(&:name)
-  end
-
-  def test_unknown_meta_method
-    util_parser <<~RUBY
-      class Foo
-        ##
-        # :call-seq:
-        #   two(name)
-        #
-        # method or singleton-method directive is missing
-      end
-
-      class Bar
-        ##
-        # unknown meta method
-        add_my_method("foo" + "bar")
-      end
-    RUBY
-
-    foo = @store.find_class_named 'Foo'
-    bar = @store.find_class_named 'Bar'
-    assert_equal [], foo.method_list.map(&:name)
-    assert_equal ['unknown'], bar.method_list.map(&:name)
-  end
-
-  def test_method
-    util_parser <<~RUBY
-      class Foo
-        # my method one
-        def one; end
-        # my method two
-        def two(x); end
-        # my method three
-        def three x; end
-      end
-    RUBY
-
-    klass = @store.find_class_named 'Foo'
-    assert_equal 3, klass.method_list.size
-    one, two, three = klass.method_list
-    assert_equal 'Foo#one', one.full_name
-    assert_equal 'Foo#two', two.full_name
-    assert_equal 'Foo#three', three.full_name
-    assert_equal 'one()', one.arglists
-    assert_equal 'two(x)', two.arglists
-    assert_equal 'three(x)', three.arglists unless accept_legacy_bug?
-    assert_equal 'my method one', one.comment.text.strip
-    assert_equal 'my method two', two.comment.text.strip
-    assert_equal 'my method three', three.comment.text.strip
-    assert_equal 3, one.line
-    assert_equal 5, two.line
-    assert_equal 7, three.line
-    assert_equal @top_level, one.file
-    assert_equal @top_level, two.file
-    assert_equal @top_level, three.file
-  end
-
-  def test_method_with_modifier_if_unless
-    util_parser <<~RUBY
-      class Foo
-        # my method one
-        def one
-        end if foo
-
-        # my method two
-        def two
-        end unless foo
-      end
-    RUBY
-
-    klass = @store.find_class_named 'Foo'
-    one, two = klass.method_list
-    assert_equal 'Foo#one', one.full_name
-    assert_equal 'my method one', one.comment.text.strip
-    assert_equal 'Foo#two', two.full_name
-    assert_equal 'my method two', two.comment.text.strip
-  end
-
-  def test_method_toplevel
-    util_parser <<~RUBY
-      # comment
-      def foo; end
-    RUBY
-
-    object = @store.find_class_named 'Object'
-    foo = object.method_list.first
-    assert_equal 'Object#foo', foo.full_name
-    assert_equal 'comment', foo.comment.text.strip
-    assert_equal @top_level, foo.file
-  end
-
-  def test_meta_method
-    util_parser <<~RUBY
-      class Foo
-        ##
-        # my method
-        add_my_method :method_foo, :arg
-      end
-    RUBY
-
-    klass = @store.find_class_named 'Foo'
-    assert_equal 1, klass.method_list.size
-    method = klass.method_list.first
-    assert_equal 'Foo#method_foo', method.full_name
-    assert_equal 'my method', method.comment.text.strip
-    assert_equal 4, method.line
-    assert_equal @top_level, method.file
-  end
-
-  def test_first_comment_is_not_a_meta_method
-    util_parser <<~RUBY
-      ##
-      # first comment is not a meta method
-      add_my_method :foo
-
-      ##
-      # this is a meta method
-      add_my_method :bar
-    RUBY
-
-    object = @store.find_class_named 'Object'
-    assert_equal ['bar'], object.method_list.map(&:name)
-  end
-
-  def test_meta_method_unknown
-    util_parser <<~RUBY
-      class Foo
-        ##
-        # my method
-        add_my_method (:foo), :bar
-      end
-    RUBY
-
-    klass = @store.find_class_named 'Foo'
-    assert_equal 1, klass.method_list.size
-    method = klass.method_list.first
-    assert_equal 'Foo#unknown', method.full_name
-    assert_equal 'my method', method.comment.text.strip
-    assert_equal 4, method.line
-    assert_equal @top_level, method.file
-  end
-
-  def test_meta_define_method
-    util_parser <<~RUBY
-      class Foo
-        ##
-        # comment 1
-        define_method :foo do end
-        ##
-        # comment 2
-        define_method :bar, ->{}
-        # not a meta comment, not a meta method
-        define_method :ignored do end
-        class << self
-          ##
-          # comment 3
-          define_method :baz do end
-        end
-      end
-    RUBY
-
-    klass = @store.find_class_named 'Foo'
-    klass.method_list.last.singleton = true if accept_legacy_bug?
-    assert_equal 3, klass.method_list.size
-    assert_equal ['Foo#foo', 'Foo#bar', 'Foo::baz'], klass.method_list.map(&:full_name)
-    assert_equal [false, false, true], klass.method_list.map(&:singleton)
-    assert_equal ['comment 1', 'comment 2', 'comment 3'], klass.method_list.map { |m| m.comment.text.strip }
-    assert_equal [4, 7, 13], klass.method_list.map(&:line)
-    assert_equal [@top_level] * 3, klass.method_list.map(&:file)
-  end
-
-  def test_method_definition_nested_inside_block
-    util_parser <<~RUBY
-      module A
-        extend ActiveSupport::Concern
-        included do
-          ##
-          # :singleton-method:
-          # comment foo
-          mattr_accessor :foo
-
-          ##
-          # :method: bar
-          # comment bar
-          add_my_method :bar
-        end
-
-        metaprogramming do
-          # class that defines this method is unknown
-          def baz1; end
-        end
-
-        my_decorator def self.baz2; end
-
-        self.my_decorator def baz3; end
-      end
-    RUBY
-    mod = @store.find_module_named 'A'
-    methods = mod.method_list
-    unless accept_legacy_bug?
-      assert_equal ['A::foo', 'A#bar', 'A::baz2', 'A#baz3'], methods.map(&:full_name)
-    end
-    assert_equal ['comment foo', 'comment bar'], methods.take(2).map { |m| m.comment.text.strip }
-  end
-
-  def test_method_yields_directive
-    util_parser <<~RUBY
-      class Foo
-        def f1(a, &b); end
-
-        def f2
-          def o.foo
-            yield :dummy
-          end
-          yield
-        end
-
-        def f3(&b)
-          yield a, *b, c: 1
-          yield 1, 2, 3
-        end
-
-        def f4(a, &b) # :yields: d, e
-          yields 1, 2
-        end
-
-        def f5 # :yield: f
-          yields 1, 2
-        end
-
-        def f6; end # :yields:
-
-        ##
-        # :yields: g, h
-        add_my_method :f7
-      end
-    RUBY
-
-    klass = @top_level.classes.first
-    methods = klass.method_list
-    expected = [
-      'f1(a, &b)',
-      'f2() { || ... }',
-      'f3() { |a, *b, c: 1| ... }',
-      'f4(a) { |d, e| ... }',
-      'f5() { |f| ... }',
-      'f6() { || ... }',
-      'f7() { |g, h| ... }'
-    ]
-    assert_equal expected, methods.map(&:arglists)
-  end
-
-  def test_calls_super
-    util_parser <<~RUBY
-      class A
-        def m1; foo; bar; end
-        def m2; if cond; super(a); end; end # SuperNode
-        def m3; tap do; super; end; end # ForwardingSuperNode
-        def m4; def a.b; super; end; end # super inside another method
-      end
-    RUBY
-
-    klass = @store.find_class_named 'A'
-    methods = klass.method_list
-    assert_equal ['m1', 'm2', 'm3', 'm4'], methods.map(&:name)
-    assert_equal [false, true, true, false], methods.map(&:calls_super)
-  end
-
-  def test_method_args_directive
-    util_parser <<~RUBY
-      class Foo
-        def method1 # :args: a, b, c
-        end
-
-        ##
-        # :args: d, e, f
-        def method2(*args); end
-
-        ##
-        # :args: g, h
-        add_my_method :method3
-      end
-    RUBY
-
-    klass = @top_level.classes.first
-    methods = klass.method_list
-    assert_equal ['method1(a, b, c)', 'method2(d, e, f)', 'method3(g, h)'], methods.map(&:arglists)
-  end
-
-  def test_class_repeatedly
-    util_parser <<~RUBY
-      class Foo
-        def foo; end
-      end
-      class Foo
-        def bar; end
-      end
-    RUBY
-    util_parser <<~RUBY
-      class Foo
-        def baz; end
-      end
-    RUBY
-
-    klass = @store.find_class_named 'Foo'
-    assert_equal ['Foo#foo', 'Foo#bar', 'Foo#baz'], klass.method_list.map(&:full_name)
-  end
-
-  def test_undefined_singleton_class_defines_module
-    util_parser <<~RUBY
-      module A
-        class << Foo
-        end
-        class << ::Bar
-        end
-        Baz1 = ''
-        class << Baz1
-        end
-        class << Baz2 # :nodoc:
-        end
-      end
-    RUBY
-
-    modules = @store.all_modules
-    modules = modules.take(3) if accept_legacy_bug?
-    assert_equal ['A', 'A::Foo', 'Bar'], modules.map(&:full_name)
-  end
-
-  def test_singleton_class
-    util_parser <<~RUBY
-      class A; end
-      class Foo
-        def self.m1; end
-        def (any expression).dummy1; end
-        class << self
-          def m2; end
-          def self.dummy2; end
-        end
-        class << A
-          def dummy3; end
-        end
-        class << Foo
-          def m3; end
-          def self.dummy4; end
-        end
-        class << ::Foo
-          def m4; end
-        end
-        class << (any expression)
-          def dummy5; end
-        end
-      end
-      class << Foo
-        def m5; end
-      end
-      class << ::Foo
-        def m6; end
-      end
-    RUBY
-
-    klass = @store.find_class_named 'Foo'
-    methods = klass.method_list
-    methods = methods.reject {|m| m.name =~ /dummy2|dummy4/ } if accept_legacy_bug?
-    assert_equal ['m1', 'm2', 'm3', 'm4', 'm5', 'm6'], methods.map(&:name)
-    assert_equal [true] * 6, methods.map(&:singleton)
-  end
-
-  def test_singleton_class_meta_method
-    util_parser <<~RUBY
-      class Foo
-        ##
-        # :singleton-method: m1
-
-        ##
-        # :singleton-method:
-        add_my_smethod :m2, :arg
-
-        ##
-        # :singleton-method:
-        add_my_smethod 'm3', :arg
-
-        # comment
-        class << self
-          ##
-          # method of a singleton class is a singleton method
-          # :method: m4
-
-          ##
-          # :singleton-method: m5
-        end
-      end
-    RUBY
-
-    klass = @store.find_class_named 'Foo'
-    assert_equal ['m1', 'm2', 'm3', 'm4', 'm5'], klass.method_list.map(&:name)
-    klass.method_list[3].singleton = true if accept_legacy_bug?
-    assert_equal [true] * 5, klass.method_list.map(&:singleton)
-  end
-
-  def test_method_nested_visibility
-    util_parser <<~RUBY
-      class A
-        def pub1; end
-        private
-        def pri1; end
-        class B
-          def pub_b1; end
-          private
-          def pri_b1; end
-          public
-          def pub_b2; end
-        end
-        def pri2; end
-      end
-      class A
-        def pub2; end
-        private
-        def pri2; end
-      end
-    RUBY
-    klass_a = @store.find_class_named 'A'
-    klass_b = klass_a.find_class_named 'B'
-    public_a = klass_a.method_list.select { |m| m.visibility == :public }.map(&:name)
-    public_b = klass_b.method_list.select { |m| m.visibility == :public }.map(&:name)
-    assert_equal ['pub1', 'pub2'], public_a
-    assert_equal ['pub_b1', 'pub_b2'], public_b
-  end
-
-  def test_attributes_visibility
-    util_parser <<~RUBY
-      class A
-        attr :pub_a
-        attr_reader :pub_r
-        attr_writer :pub_w
-        attr_accessor :pub_rw
-        private
-        attr :pri_a
-        attr_reader :pri_r
-        attr_writer :pri_w
-        attr_accessor :pri_rw
-      end
-    RUBY
-    klass = @store.find_class_named 'A'
-    assert_equal ['pub_a', 'pub_r', 'pub_w', 'pub_rw', 'pri_a', 'pri_r', 'pri_w', 'pri_rw'], klass.attributes.map(&:name)
-    assert_equal [:public] * 4 + [:private] * 4, klass.attributes.map(&:visibility)
-  end
-
-  def test_method_singleton_class_visibility
-    util_parser <<~RUBY
-      class A
-        def self.pub1; end
-        private
-        def self.pub2; end
-        class << self
-          def pub3; end
-          private
-          def pri1; end
-          public
-          def pub4; end
-          private
-        end
-      end
-    RUBY
-    klass = @store.find_class_named 'A'
-    public_singleton_methods = klass.method_list.select { |m| m.singleton && m.visibility == :public }
-    assert_equal ['pub1', 'pub2', 'pub3', 'pub4'], public_singleton_methods.map(&:name)
-  end
-
-  def test_private_def_public_def
-    util_parser <<~RUBY
-      class A
-        private def m1; end
-        public def m2; end
-        private
-        public def m3; end
-      end
-    RUBY
-    klass = @store.find_class_named 'A'
-    public_methods = klass.method_list.select { |m| m.visibility == :public }
-    assert_equal ['m2', 'm3'], public_methods.map(&:name)
-  end
-
-  def test_define_method_visibility
-    util_parser <<~RUBY
-      class A
-        private
-        ##
-        # my private method
-        define_method :m1 do end
-        public
-        ##
-        # my public method
-        define_method :m2 do end
-      end
-    RUBY
-    klass = @store.find_class_named 'A'
-    methods = klass.method_list
-    assert_equal ['m1', 'm2'], methods.map(&:name)
-    assert_equal [:private, :public], methods.map(&:visibility)
-  end
-
-  def test_module_function
-    util_parser <<~RUBY
-      module A
-        def m1; end
-        def m2; end
-        def m3; end
-        module_function :m1, :m3
-        module_function def m4; end
-      end
-    RUBY
-    mod = @store.find_module_named 'A'
-    instance_methods = mod.method_list.reject(&:singleton)
-    singleton_methods = mod.method_list.select(&:singleton)
-    if accept_legacy_bug?
-      instance_methods.last.visibility = :private
-      singleton_methods << singleton_methods.last.dup
-      singleton_methods.last.name = 'm4'
-    end
-    assert_equal ['m1', 'm2', 'm3', 'm4'], instance_methods.map(&:name)
-    assert_equal [:private, :public, :private, :private], instance_methods.map(&:visibility)
-    assert_equal ['m1', 'm3', 'm4'], singleton_methods.map(&:name)
-    assert_equal [:public, :public, :public], singleton_methods.map(&:visibility)
-  end
-
-  def test_class_method_visibility
-    util_parser <<~RUBY
-      class A
-        def self.m1; end
-        def self.m2; end
-        def self.m3; end
-        private_class_method :m1, :m2
-        public_class_method :m1, :m3
-        private_class_method def self.m4; end
-        public_class_method def self.m5; end
-      end
-    RUBY
-    klass = @store.find_class_named 'A'
-    public_methods = klass.method_list.select { |m| m.visibility == :public }
-    assert_equal ['m1', 'm3', 'm5'], public_methods.map(&:name) unless accept_legacy_bug?
-  end
-
-  def test_method_change_visibility
-    util_parser <<~RUBY
-      class A
-        def m1; end
-        def m2; end
-        def m3; end
-        def m4; end
-        def m5; end
-        private :m2, :m3, :m4
-        public :m1, :m3
-      end
-      class << A
-        def m1; end
-        def m2; end
-        def m3; end
-        def m4; end
-        def m5; end
-        private :m1, :m2, :m3
-        public :m2, :m4
-      end
-    RUBY
-    klass = @store.find_class_named 'A'
-    public_methods = klass.method_list.select { |m| !m.singleton && m.visibility == :public }
-    public_singleton_methods = klass.method_list.select { |m| m.singleton && m.visibility == :public }
-    assert_equal ['m1', 'm3', 'm5'], public_methods.map(&:name)
-    assert_equal ['m2', 'm4', 'm5'], public_singleton_methods.map(&:name)
-  end
-
-  def test_undocumentable_change_visibility
-    omit if accept_legacy_bug?
-    util_parser <<~RUBY
-      class A
-        def m1; end
-        def self.m2; end
-        private 42, :m # maybe not Module#private
-        # ignore all non-standard `private def` and `private_class_method def`
-        private def self.m1; end
-        private_class_method def m2; end
-        private def to_s.m1; end
-        private_class_method def to_s.m2; end
-      end
-    RUBY
-    klass = @store.find_class_named 'A'
-    assert_equal [:public] * 4, klass.method_list.map(&:visibility)
-  end
-
-  def test_singleton_class_def_with_visibility
-    util_parser <<~RUBY
-      class A
-        class <<self
-          private def m1; end
-        end
-        private def self.m2; end
-      end
-      class <<A
-        private def m3; end
-      end
-    RUBY
-    klass = @store.find_class_named 'A'
-    assert_equal [true, true, true], klass.method_list.map(&:singleton)
-    assert_equal [:private, :public, :private], klass.method_list.map(&:visibility)
-  end
-
-  def test_method_visibility_change_in_subclass
-    omit 'not implemented' if accept_legacy_bug?
-    util_parser <<~RUBY
-      class A
-        def m1; end
-        def m2; end
-        private :m2
-      end
-      class B < A
-        private :m1
-        public :m2
-      end
-    RUBY
-
-    superclass = @store.find_class_named('A')
-    klass = @store.find_class_named('B')
-    assert_equal ['m1', 'm2'], superclass.method_list.map(&:name)
-    assert_equal ['m1', 'm2'], klass.method_list.map(&:name)
-    assert_equal [:public, :private], superclass.method_list.map(&:visibility)
-    assert_equal [:private, :public], klass.method_list.map(&:visibility)
-  end
-
-  def test_singleton_method_visibility_change_in_subclass
-    util_parser <<~RUBY
-      class A
-        def self.m1; end
-        def self.m2; end
-        private_class_method :m2
-      end
-      class B < A
-        private_class_method :m1
-        public_class_method :m2
-      end
-    RUBY
-
-    superclass = @store.find_class_named('A')
-    klass = @store.find_class_named('B')
-    assert_equal ['m1', 'm2'], superclass.method_list.map(&:name)
-    assert_equal ['m1', 'm2'], klass.method_list.map(&:name)
-    assert_equal [:public, :private], superclass.method_list.map(&:visibility)
-    assert_equal [:private, :public], klass.method_list.map(&:visibility)
-  end
-
-  def test_alias
-    util_parser <<~RUBY
-      class Foo
-        def bar; end
-        def bar2; alias :dummy :bar; end
-        # comment
-        alias :baz1 :bar # :nodoc:
-        alias :baz2 :bar
-        # :stopdoc:
-        alias :baz3 :bar
-      end
-    RUBY
-    klass = @store.find_class_named 'Foo'
-    assert_equal ['Foo#bar', 'Foo#bar2', 'Foo#baz2'], klass.method_list.map(&:full_name)
-    m = klass.method_list.last
-    assert_equal 'Foo#bar', m.is_alias_for.full_name
-    assert_equal 'Foo#baz2', m.full_name
-    assert_equal klass, m.parent
-  end
-
-  def test_alias_singleton
-    util_parser <<~RUBY
-      class Foo
-        class << self
-          def bar; end
-          # comment
-          alias :baz :bar
-          # :stopdoc:
-          alias :baz2 :bar
-        end
-      end
-    RUBY
-    klass = @store.find_class_named 'Foo'
-    m = klass.class_method_list.last
-    assert_equal 'Foo::bar', m.is_alias_for.full_name
-    assert_equal 'Foo::baz', m.full_name
-    assert_equal 'comment', m.comment.text
-    assert_equal klass, m.parent
-  end
-
-  def test_alias_method
-    util_parser <<~RUBY
-      class Foo
-        def foo; end
-        private
-        alias_method :foo2, :foo
-        def bar; end
-        public
-        alias_method :bar2, :bar
-        private :foo
-        public :bar
-      end
-    RUBY
-    foo, foo2, bar, bar2 = @top_level.classes.first.method_list
-    assert_equal 'foo', foo.name
-    assert_equal 'bar', bar.name
-    assert_equal 'foo2', foo2.name
-    assert_equal 'bar2', bar2.name
-    assert_equal 'foo', foo2.is_alias_for.name
-    assert_equal 'bar', bar2.is_alias_for.name
-    unless accept_legacy_bug?
-      assert_equal :private, foo.visibility
-      assert_equal :public, foo2.visibility
-      assert_equal :public, bar.visibility
-      assert_equal :private, bar2.visibility
-    end
-  end
-
-  def test_invalid_alias_method
-    omit if accept_legacy_bug?
-    util_parser <<~RUBY
-      class Foo
-        def foo; end
-        alias_method
-        alias_method :foo
-        alias_method :foo, :bar, :baz
-        alias_method 42, :foo
-      end
-    RUBY
-    assert_equal ['foo'], @top_level.classes.first.method_list.map(&:name)
-  end
-
-  def test_alias_method_stopdoc_nodoc
-    util_parser <<~RUBY
-      class Foo
-        def foo; end
-        # :stopdoc:
-        alias_method :foo2, :foo
-        # :startdoc:
-        alias_method :foo3, :foo # :nodoc:
-        alias_method :foo4, :foo
-      end
-    RUBY
-    assert_equal ['foo', 'foo4'], @top_level.classes.first.method_list.map(&:name)
-  end
-
-  def test_attributes
-    util_parser <<~RUBY
-      class Foo
-        # attrs
-        attr :attr1, :attr2
-        # readers
-        attr_reader :reader1, :reader2
-        # writers
-        attr_writer :writer1, :writer2
-        # accessors
-        attr_accessor :accessor1, :accessor2
-        # :stopdoc:
-        attr :attr3, :attr4
-        attr_reader :reader3, :reader4
-        attr_writer :write3, :writer4
-        attr_accessor :accessor3, :accessor4
-      end
-    RUBY
-    klass = @store.find_class_named 'Foo'
-    if accept_legacy_bug?
-      a, r1, r2, w1, w2, rw1, rw2 = klass.attributes
-      a1 = a.dup
-      a2 = a.dup
-      a1.rw = a2.rw = 'R'
-      a2.name = 'attr2'
-    else
-      assert_equal 8, klass.attributes.size
-      a1, a2, r1, r2, w1, w2, rw1, rw2 = klass.attributes
-    end
-    assert_equal ['attr1', 'attr2'], [a1.name, a2.name]
-    assert_equal ['reader1', 'reader2'], [r1.name, r2.name]
-    assert_equal ['writer1', 'writer2'], [w1.name, w2.name]
-    assert_equal ['accessor1', 'accessor2'], [rw1.name, rw2.name]
-    assert_equal ['R', 'R'], [a1.rw, a2.rw]
-    assert_equal ['R', 'R'], [r1.rw, r2.rw]
-    assert_equal ['W', 'W'], [w1.rw, w2.rw]
-    assert_equal ['RW', 'RW'], [rw1.rw, rw2.rw]
-    assert_equal ['attrs', 'attrs'], [a1.comment.text, a2.comment.text]
-    assert_equal ['readers', 'readers'], [r1.comment.text, r2.comment.text]
-    assert_equal ['writers', 'writers'], [w1.comment.text, w2.comment.text]
-    assert_equal ['accessors', 'accessors'], [rw1.comment.text, rw2.comment.text]
-    assert_equal [3, 3], [a1.line, a2.line]
-    assert_equal [5, 5], [r1.line, r2.line]
-    assert_equal [7, 7], [w1.line, w2.line]
-    assert_equal [9, 9], [rw1.line, rw2.line]
-    assert_equal [@top_level] * 8, [a1, a2, r1, r2, w1, w2, rw1, rw2].map(&:file)
-  end
-
-  def test_undocumentable_attributes
-    util_parser <<~RUBY
-      class Foo
-        attr
-        attr 42, :foo
-      end
-    RUBY
-    klass = @store.find_class_named 'Foo'
-    assert_empty klass.method_list
-    assert_empty klass.attributes
-  end
-
-  def test_singleton_class_attributes
-    util_parser <<~RUBY
-      class Foo
-        class << self
-          attr :a
-          attr_reader :r
-          attr_writer :w
-          attr_accessor :rw
-        end
-      end
-    RUBY
-    klass = @store.find_class_named 'Foo'
-    attributes = klass.attributes
-    assert_equal ['a', 'r', 'w', 'rw'], attributes.map(&:name)
-    assert_equal [true] * 4, attributes.map(&:singleton)
-  end
-
-  def test_attributes_nodoc
-    util_parser <<~RUBY
-      class Foo
-        attr :attr1, :attr2 # :nodoc:
-        attr :attr3
-        attr_reader :reader1, :reader2 # :nodoc:
-        attr_reader :reader3
-        attr_writer :writer1, :writer2 # :nodoc:
-        attr_writer :writer3
-        attr_accessor :accessor1, :accessor2 # :nodoc:
-        attr_accessor :accessor3
-      end
-    RUBY
-    klass = @store.find_class_named 'Foo'
-    unless accept_legacy_bug?
-      assert_equal 4, klass.attributes.size
-    end
-  end
-
-  def test_attributes_nodoc_track
-    @options.visibility = :nodoc
-    util_parser <<~RUBY
-      class Foo
-        attr :attr1, :attr2 # :nodoc:
-        attr :attr3
-        attr_reader :reader1, :reader2 # :nodoc:
-        attr_reader :reader3
-        attr_writer :writer1, :writer2 # :nodoc:
-        attr_writer :writer3
-        attr_accessor :accessor1, :accessor2 # :nodoc:
-        attr_accessor :accessor3
-      end
-    RUBY
-    klass = @store.find_class_named 'Foo'
-    unless accept_legacy_bug?
-      assert_equal 12, klass.attributes.size
-    end
-  end
-
-  def test_method_nodoc_stopdoc
-    util_parser <<~RUBY
-      class Foo
-        def doc1; end
-        def nodoc1; end # :nodoc:
-        def doc2; end
-        def nodoc2 # :nodoc:
-        end
-        def doc3; end
-        def nodoc3
-        end # :nodoc:
-        def nodoc4(arg1,
-                   arg2) # :nodoc:
-        end
-        def doc4; end
-        # :stopdoc:
-        def nodoc5; end
-      end
-    RUBY
-    klass = @store.find_class_named 'Foo'
-    assert_equal ['doc1', 'doc2', 'doc3', 'doc4'], klass.method_list.map(&:name)
-  end
-
-  def test_method_nodoc_track
-    @options.visibility = :nodoc
-    util_parser <<~RUBY
-      class Foo
-        def doc1; end
-        def nodoc1; end # :nodoc:
-        def doc2; end
-        def nodoc2 # :nodoc:
-        end
-        def doc3; end
-        def nodoc3
-        end # :nodoc:
-        def doc4; end
-      end
-    RUBY
-    klass = @store.find_class_named 'Foo'
-    assert_equal ['doc1', 'nodoc1', 'doc2', 'nodoc2', 'doc3', 'nodoc3', 'doc4'], klass.method_list.map(&:name)
-    assert_equal [true, nil, true, nil, true, nil, true], klass.method_list.map(&:document_self)
-  end
-
-  def test_meta_attributes
-    util_parser <<~RUBY
-      class Foo
-        ##
-        # :attr:
-        # attrs
-        add_my_method :attr1, :attr2
-        ##
-        # :attr_reader:
-        # readers
-        add_my_method :reader1, :reader2
-        ##
-        # :attr_writer:
-        # writers
-        add_my_method :writer1, :writer2
-        ##
-        # :attr_accessor:
-        # accessors
-        add_my_method :accessor1, :accessor2
-
-        # :stopdoc:
-
-        ##
-        # :attr:
-        add_my_method :attr3
-        ##
-        # :attr_reader:
-        add_my_method :reader3
-        ##
-        # :attr_writer:
-        add_my_method :writer3
-        ##
-        # :attr_accessor:
-        add_my_method :accessor3
-      end
-    RUBY
-    klass = @store.find_class_named 'Foo'
-    assert_equal 8, klass.attributes.size
-    a1, a2, r1, r2, w1, w2, rw1, rw2 = klass.attributes
-    assert_equal ['attr1', 'attr2'], [a1.name, a2.name]
-    assert_equal ['reader1', 'reader2'], [r1.name, r2.name]
-    assert_equal ['writer1', 'writer2'], [w1.name, w2.name]
-    assert_equal ['accessor1', 'accessor2'], [rw1.name, rw2.name]
-    a1.rw = a2.rw = 'R' if accept_legacy_bug?
-    assert_equal ['R', 'R'], [a1.rw, a2.rw]
-    assert_equal ['R', 'R'], [r1.rw, r2.rw]
-    assert_equal ['W', 'W'], [w1.rw, w2.rw]
-    assert_equal ['RW', 'RW'], [rw1.rw, rw2.rw]
-    assert_equal ['attrs', 'attrs'], [a1.comment.text, a2.comment.text]
-    assert_equal ['readers', 'readers'], [r1.comment.text, r2.comment.text]
-    assert_equal ['writers', 'writers'], [w1.comment.text, w2.comment.text]
-    assert_equal ['accessors', 'accessors'], [rw1.comment.text, rw2.comment.text]
-    assert_equal [@top_level] * 8, [a1, a2, r1, r2, w1, w2, rw1, rw2].map(&:file)
-  end
-
-  def test_meta_attributes_named
-    util_parser <<~RUBY
-      class Foo
-        ##
-        # comment a
-        # :attr: attr1
-        add_my_method :a1
-        ##
-        # comment r
-        # :attr_reader: reader1
-        add_my_method :r1
-        ##
-        # comment w
-        # :attr_writer: writer1
-        add_my_method :w1
-        ##
-        # comment rw
-        # :attr_accessor: accessor1
-        add_my_method :rw1
-
-        # :stopdoc:
-
-        ##
-        # :attr: attr2
-        add_my_method :a2
-        ##
-        # :attr_reader: reader2
-        add_my_method :r2
-        ##
-        # :attr_writer: writer2
-        add_my_method :w2
-        ##
-        # :attr_accessor: accessor2
-        add_my_method :rw2
-      end
-    RUBY
-    klass = @store.find_class_named 'Foo'
-    assert_equal 4, klass.attributes.size
-    a, r, w, rw = klass.attributes
-    assert_equal 'attr1', a.name
-    assert_equal 'reader1', r.name
-    assert_equal 'writer1', w.name
-    assert_equal 'accessor1', rw.name
-    a.rw = 'R' if accept_legacy_bug?
-    assert_equal 'R', a.rw
-    assert_equal 'R', r.rw
-    assert_equal 'W', w.rw
-    assert_equal 'RW', rw.rw
-    assert_equal 'comment a', a.comment.text
-    assert_equal 'comment r', r.comment.text
-    assert_equal 'comment w', w.comment.text
-    assert_equal 'comment rw', rw.comment.text
-    assert_equal [@top_level] * 4, [a, r, w, rw].map(&:file)
-  end
-
-  def test_constant
-    util_parser <<~RUBY
-      class Foo
-        A = (any expression 1)
-        def f
-          DUMMY1 = (any expression 2)
-        end
-        class Bar; end
-        Bar::B = (any expression 3)
-        ::C = (any expression 4)
-        # :stopdoc:
-        DUMMY2 = 1
-        # :startdoc:
-        D = (any expression 5)
-        E = (any expression 6) # :nodoc:
-        F = (
-          any expression 7
-        ) # :nodoc:
-      end
-      G = (any expression 8)
-    RUBY
-    foo = @top_level.classes.first
-    bar = foo.classes.first
-    object = @top_level.find_class_or_module('Object')
-    assert_equal ['A', 'D', 'E', 'F'], foo.constants.map(&:name) unless accept_legacy_bug?
-    assert_equal '(any expression 1)', foo.constants.first.value
-    assert_equal ['B'], bar.constants.map(&:name)
-    assert_equal ['C', 'G'], object.constants.map(&:name) unless accept_legacy_bug?
-    all_constants = foo.constants + bar.constants + object.constants
-    assert_equal [@top_level] * 7, all_constants.map(&:file) unless accept_legacy_bug?
-    assert_equal [2, 12, 13, 14, 7, 8, 18], all_constants.map(&:line) unless accept_legacy_bug?
-  end
-
-  def test_nodoc_constant_assigned_without_nodoc_comment
-    util_parser <<~RUBY
-      module Foo
-        A = 1
-        B = 1 # :nodoc:
-        begin
-          C = 1 # :nodoc:
-        rescue
-          C = 2
-        end
-      end
-      Foo::B = 2
-      Foo::D = 2
-    RUBY
-    mod = @top_level.modules.first
-    assert_equal ['A', 'B', 'C', 'D'], mod.constants.map(&:name)
-    assert_equal [false, true, true, false], mod.constants.map(&:received_nodoc)
-  end
-
-  def test_constant_visibility
-    util_parser <<~RUBY
-      class C
-        A = 1
-        B = 2
-        C = 3
-        private_constant
-        private_constant foo
-        private_constant :A
-        private_constant :B, :C
-        public_constant :B
-      end
-    RUBY
-    klass = @store.find_class_named 'C'
-    const_a, const_b, const_c = klass.constants.sort_by(&:name)
-
-    assert_equal 'A', const_a.name
-    assert_equal :private, const_a.visibility
-
-    assert_equal 'B', const_b.name
-    assert_equal :public, const_b.visibility
-
-    assert_equal 'C', const_c.name
-    assert_equal :private, const_c.visibility
-  end
-
-  def test_constant_assignment_to_undefined_module_path
-    util_parser <<~RUBY
-      A::B::C = 1
-    RUBY
-    a = @top_level.find_module_named 'A'
-    b = a.find_module_named 'B'
-    c = b.constants.first
-    assert_equal 'A::B::C', c.full_name
-  end
-
-  def test_constant_alias
-    util_parser <<~RUBY
-      class Foo
-        class Bar; end
-        A = Bar
-        # B = ::Foo # master branch has bug
-        C = Foo::Bar
-      end
-    RUBY
-    klass = @top_level.classes.first
-    assert_equal [], klass.modules.map(&:full_name)
-    assert_equal ['Foo::Bar', 'Foo::A', 'Foo::C'], klass.classes.map(&:full_name)
-    assert_equal ['Foo::A', 'Foo::C'], klass.constants.map(&:full_name)
-    assert_equal 'Foo::A', klass.find_module_named('A').full_name
-    assert_equal 'Foo::C', klass.find_module_named('C').full_name
-  end
-
-  def test_constant_with_singleton_class
-    omit if accept_legacy_bug?
-    util_parser <<~RUBY
-      class Foo
-        class Bar; end
-        A = 1
-        class <<Bar
-          B = 1
-          Foo::Bar::B2 = 1
-        end
-        class Bar
-          C = 1
-        end
-        class <<(p(D = 1))
-          E = 1
-        end
-        class (F = 1)::Baz
-          G = 1
-        end
-        module (H = 1)::Baz
-          I = 1
-        end
-      end
-      J = 1
-    RUBY
-    foo, bar = @store.all_classes
-    assert_equal ['J'], @store.find_class_named('Object').constants.map(&:name)
-    assert_equal ['A', 'D', 'F', 'H'], foo.constants.map(&:name)
-    assert_equal ['B2', 'C'], bar.constants.map(&:name)
-  end
-
-  def test_constant_method
-    util_parser <<~RUBY
-      def Object.foo; end
-      class A
-        class B
-          class C
-            def B.bar; end
-          end
-        end
-      end
-      def UNKNOWN.baz; end
-    RUBY
-
-    object = @store.find_class_named 'Object'
-    klass = @store.find_class_named 'A::B'
-    unknown = @store.find_module_named('UNKNOWN')
-    assert_equal 'Object::foo', object.method_list.first.full_name
-    assert_equal 'A::B::bar', klass.method_list.first.full_name
-    assert_equal 'UNKNOWN::baz', unknown.method_list.first.full_name
-  end
-
-  def test_true_false_nil_method
-    util_parser <<~RUBY
-      def nil.foo; end
-      def true.bar; end
-      def false.baz; end
-    RUBY
-    sep = accept_legacy_bug? ? '::' : '#'
-    assert_equal "NilClass#{sep}foo", @store.find_class_named('NilClass').method_list.first.full_name
-    assert_equal "TrueClass#{sep}bar", @store.find_class_named('TrueClass').method_list.first.full_name
-    assert_equal "FalseClass#{sep}baz", @store.find_class_named('FalseClass').method_list.first.full_name
-  end
-
-  def test_include_extend
-    util_parser <<~RUBY
-      module I; end
-      module E; end
-      class C
-        # my include
-        include I
-        # my extend
-        extend E
-      end
-      module M
-        include I
-        extend E
-      end
-    RUBY
-    klass = @store.find_class_named 'C'
-    mod = @store.find_module_named 'M'
-    assert_equal ['I'], klass.includes.map(&:name)
-    assert_equal ['E'], klass.extends.map(&:name)
-    assert_equal ['I'], mod.includes.map(&:name)
-    assert_equal ['E'], mod.extends.map(&:name)
-    assert_equal 'my include', klass.includes.first.comment.text.strip
-    assert_equal 'my extend', klass.extends.first.comment.text.strip
-  end
-
-  def test_include_extend_to_singleton_class
-    omit 'not implemented' if accept_legacy_bug?
-    util_parser <<~RUBY
-      class Foo
-        class << self
-          # include to singleton class is extend
-          include I
-          # extend to singleton class is not documentable
-          extend E
-        end
-      end
-    RUBY
-
-    klass = @top_level.classes.first
-    assert_equal [], klass.includes.map(&:name)
-    assert_equal ['I'], klass.extends.map(&:name)
-  end
-
-  def test_include_with_module_nesting
-    util_parser <<~RUBY
-      module A
-        module M; end
-        module B
-          module M; end
-          module C
-            module M; end
-            module D
-              module M; end
-            end
-          end
-        end
-      end
-
-      module A::B
-        class C::D::Foo
-          include M
-        end
-      end
-      # TODO: make test pass with the following code appended
-      # module A::B::C
-      #   class D::Foo
-      #     include M
-      #   end
-      # end
-    RUBY
-    klass = @store.find_class_named 'A::B::C::D::Foo'
-    assert_equal 'A::B::M', klass.includes.first.module.full_name
-  end
-
-  def test_various_argument_include
-    omit 'not implemented' if accept_legacy_bug?
-    util_parser <<~RUBY
-      module A; end
-      module B; end
-      module C; end
-      class A
-        include
-        include A, B
-        include 42, C # Maybe not Module#include
-      end
-    RUBY
-    klass = @top_level.classes.first
-    assert_equal ['A', 'B'], klass.includes.map(&:name)
-  end
-
-  def test_require
-    util_parser <<~RUBY
-      require
-      require 'foo/bar'
-      require_relative 'is/not/supported/yet'
-      require "\#{embed}"
-      require (any expression)
-    RUBY
-    assert_equal ['foo/bar'], @top_level.requires.map(&:name)
-  end
-
-  def test_statements_identifier_alias_method_before_original_method
-    # This is not strictly legal Ruby code, but it simulates finding an alias
-    # for a method before finding the original method, which might happen
-    # to rdoc if the alias is in a different file than the original method
-    # and rdoc processes the alias' file first.
-    util_parser <<~RUBY
-      class Foo
-        alias_method :foo2, :foo
-        alias_method :foo3, :foo
-      end
-
-      class Foo
-        def foo(); end
-        alias_method :foo4, :foo
-        alias_method :foo5, :unknown
-      end
-    RUBY
-
-    foo = @top_level.classes.first.method_list[0]
-    assert_equal 'foo', foo.name
-
-    foo2 = @top_level.classes.first.method_list[1]
-    assert_equal 'foo2', foo2.name
-    assert_equal 'foo', foo2.is_alias_for.name
-
-    foo3 = @top_level.classes.first.method_list[2]
-    assert_equal 'foo3', foo3.name
-    assert_equal 'foo', foo3.is_alias_for.name
-
-    foo4 = @top_level.classes.first.method_list.last
-    assert_equal 'foo4', foo4.name
-    assert_equal 'foo', foo4.is_alias_for.name
-
-    assert_equal 'unknown', @top_level.classes.first.external_aliases[0].old_name
-  end
-
-  def test_class_definition_encountered_after_class_reference
-    # The code below is not legal Ruby (Foo must have been defined before
-    # Foo.bar is encountered), but RDoc might encounter Foo.bar before Foo if
-    # they live in different files.
-
-    util_parser <<-RUBY
-      def Foo.bar
-      end
-
-      class Foo < IO
-      end
-    RUBY
-
-    assert_empty @store.modules_hash
-    assert_empty @store.all_modules
-
-    klass = @top_level.classes.first
-    assert_equal 'Foo', klass.full_name
-    assert_equal 'IO', klass.superclass
-
-    assert_equal 'bar', klass.method_list.first.name
-  end
-
-  def test_scan_duplicate_module
-    util_parser <<~RUBY
-      # comment a
-      module Foo
-      end
-
-      # comment b
-      module Foo
-      end
-    RUBY
-
-    mod = @top_level.modules.first
-
-    expected = [
-      RDoc::Comment.new('comment a', @top_level),
-      RDoc::Comment.new('comment b', @top_level)
-    ]
-
-    assert_equal expected, mod.comment_location.map { |c, _l| c }
-  end
-
-  def test_enddoc
-    util_parser <<~RUBY
-      class A
-        class B; end
-        # :enddoc:
-        # :startdoc:
-        class C; end
-      end
-      class D; end
-      # :enddoc:
-      # :startdoc:
-      class E; end
-    RUBY
-
-    assert_equal ['A', 'A::B', 'D'], @store.all_classes.reject(&:ignored?).map(&:full_name)
-  end
-
-  def test_top_level_enddoc
-    util_parser <<~RUBY
-      class A; end
-      # :enddoc:
-      class B; end
-      # :startdoc:
-      class C; end
-    RUBY
-
-    assert_equal ['A'], @top_level.classes.reject(&:ignored?).map(&:name)
-  end
-
-  def test_section
-    util_parser <<~RUBY
-      class Foo
-        # :section: section1
-        attr :a1
-        def m1; end
-        # :section:
-        def m2; end
-        attr :a2
-        # :section: section2
-        def m3; end
-        attr :a3
-        module Bar
-          def m4; end
-          attr :a4
-          # :section: section3
-          def m5; end
-          attr :a5
-        end
-        attr :a6
-        def m6; end
-      end
-    RUBY
-    foo = @top_level.classes.first
-    bar = foo.modules.first
-    assert_equal ['section1', nil, 'section2', 'section2'], foo.attributes.map { |m| m.section.title }
-    assert_equal ['section1', nil, 'section2', 'section2'], foo.method_list.map { |m| m.section.title }
-    assert_equal [nil, 'section3'], bar.attributes.map { |m| m.section.title }
-    assert_equal [nil, 'section3'], bar.method_list.map { |m| m.section.title }
-  end
-
-  def test_category
-    util_parser <<~RUBY
-      class A
-        # :category: cat1
-
-        # comment
-        attr :a1
-        attr :a2
-        def m1; end
-        # :category: cat2
-
-        # comment
-        def m2; end
-        def m3; end
-        attr :a3
-
-        # :category:
-        attr :a4
-        # :category:
-        def m4; end
-
-        ##
-        # :category: cat3
-        def m5; end
-
-        ##
-        # :category: cat4
-        # :method: m6
-      end
-    RUBY
-    klass = @top_level.classes.first
-    assert_equal ['cat1', nil, nil, nil], klass.attributes.map { |m| m.section.title }
-    assert_equal [nil, 'cat2', nil, nil, 'cat3', 'cat4'], klass.method_list.map { |m| m.section.title }
-  end
-
-  def test_ignore_constant_assign_rhs
-    # Struct is not supported yet. Right hand side of constant assignment should be ignored.
-    util_parser <<~RUBY
-      module Foo
-        def a; end
-        Bar = Struct.new do
-          def b; end
-          ##
-          # :method: c
-        end
-        Bar::Baz = Struct.new do
-          def d; end
-          ##
-          # :method: e
-        end
-        ##
-        # :method: f
-      end
-    RUBY
-    mod = @top_level.modules.first
-    assert_equal ['a', 'f'], mod.method_list.map(&:name)
-  end
-
-  def test_include_extend_suppressed_within_block
-    util_parser <<~RUBY
-      module M; end
-      module N; end
-      module O: end
-      class A
-        metaprogramming do
-          include M
-          extend N
-          class B
-            include M
-            extend N
-          end
-          include M
-          extend N
-        end
-        include O
-        extend O
-      end
-    RUBY
-    a, b = @store.all_classes
-    unless accept_legacy_bug?
-      assert_equal ['O'], a.includes.map(&:name)
-      assert_equal ['O'], a.extends.map(&:name)
-    end
-    assert_equal ['M'], b.includes.map(&:name)
-    assert_equal ['N'], b.extends.map(&:name)
-  end
-
-  def test_multibyte_method_name
-    content = <<~RUBY
-      class Foo
-        # comment ω
-        def ω() end
-      end
-    RUBY
-    util_parser content
-    assert_equal Encoding::UTF_8, content.encoding
-    method = @top_level.classes.first.method_list.first
-    assert_equal 'comment ω', method.comment.text.strip
-    assert_equal 'ω', method.name
-  end
-
-  def test_options_encoding
-    @options.encoding = Encoding::CP852
-    util_parser <<~RUBY
-      class Foo
-        ##
-        # this is my method
-        add_my_method :foo
-      end
-    RUBY
-    foo = @top_level.classes.first.method_list.first
-    assert_equal 'foo', foo.name
-    assert_equal 'this is my method', foo.comment.text
-    assert_equal Encoding::CP852, foo.comment.text.encoding
-  end
-
-  def test_read_directive_linear_performance
-    assert_linear_performance((1..5).map{|i|10**i}) do |i|
-      util_parser '# ' + '0'*i + '=000:' + "\n def f; end"
-    end
-  end
-
-
-  def test_markup_first_comment
-    util_parser <<~RUBY
-      # :markup: rd
-
-      # ((*awesome*))
-      class C
-        # ((*radical*))
-        def m
-        end
-      end
-    RUBY
-
-    c = @top_level.classes.first
-    assert_equal 'rd', c.comment.format
-    assert_equal 'rd', c.method_list.first.comment.format
-  end
-
-  def test_markup_override
-    util_parser <<~RUBY
-      # *awesome*
-      class C
-        # :markup: rd
-        # ((*radical*))
-        def m1; end
-
-        # *awesome*
-        def m2; end
-      end
-    RUBY
-
-    c = @top_level.classes.first
-
-    assert_equal 'rdoc', c.comment.format
-
-    assert_equal ['rd', 'rdoc'], c.method_list.map { |m| m.comment.format }
-  end
-
-  def test_tomdoc_meta
-    util_parser <<~RUBY
-      # :markup: tomdoc
-
-      class C
-
-        # Signature
-        #
-        #   find_by_<field>[_and_<field>...](args)
-        #
-        # field - A field name.
-
-      end
-    RUBY
-
-    c = @top_level.classes.first
-
-    m = c.method_list.first
-
-    assert_equal "find_by_<field>[_and_<field>...]", m.name
-    assert_equal "find_by_<field>[_and_<field>...](args)\n", m.call_seq
-
-    expected =
-      doc(
-        head(3, 'Signature'),
-        list(:NOTE,
-          item(%w[field],
-            para('A field name.'))))
-    expected.file = @top_level
-
-    assert_equal expected, m.comment.parse
-  end
-end
-
-class RDocParserPrismRubyTest < RDoc::TestCase
-  include RDocParserPrismTestCases
-
-  def accept_legacy_bug?
-    false
-  end
-
-  def util_parser(content)
-    @parser = RDoc::Parser::PrismRuby.new @top_level, content, @options, @stats
-    @parser.scan
-  end
-end
-
-# Run the same test with the original RDoc::Parser::Ruby
-class RDocParserRubyWithPrismRubyTestCasesTest < RDoc::TestCase
-  include RDocParserPrismTestCases
-
-  def accept_legacy_bug?
-    true
-  end
-
-  def util_parser(content)
-    @parser = RDoc::Parser::Ruby.new @top_level, content, @options, @stats
-    @parser.scan
-  end
-end unless ENV['RDOC_USE_PRISM_PARSER']
diff --git a/test/mri/rdoc/rdoc_parser_rd_test.rb b/test/mri/rdoc/rdoc_parser_rd_test.rb
deleted file mode 100644
index a1e552252a4..00000000000
--- a/test/mri/rdoc/rdoc_parser_rd_test.rb
+++ /dev/null
@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocParserRdTest < RDoc::TestCase
-
-  def setup
-    super
-
-    @RP = RDoc::Parser
-
-    @tempfile = Tempfile.new self.class.name
-    filename = @tempfile.path
-
-    @top_level = @store.add_file filename
-    @fn = filename
-    @options = RDoc::Options.new
-    @stats = RDoc::Stats.new @store, 0
-  end
-
-  def teardown
-    super
-
-    @tempfile.close!
-  end
-
-  def test_file
-    assert_kind_of RDoc::Parser::Text, util_parser('')
-  end
-
-  def test_class_can_parse
-    temp_dir do
-      FileUtils.touch 'foo.rd'
-      assert_equal @RP::RD, @RP.can_parse('foo.rd')
-
-      FileUtils.touch 'foo.rd.ja'
-      assert_equal @RP::RD, @RP.can_parse('foo.rd.ja')
-    end
-  end
-
-  def test_scan
-    parser = util_parser 'it ((*really*)) works'
-
-    expected = doc(para('it <em>really</em> works'))
-    expected.file = @top_level
-
-    parser.scan
-
-    assert_equal expected, @top_level.comment.parse
-  end
-
-  def util_parser(content)
-    RDoc::Parser::RD.new @top_level, content, @options, @stats
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc_parser_ruby_test.rb b/test/mri/rdoc/rdoc_parser_ruby_test.rb
deleted file mode 100644
index 2f4665a25fe..00000000000
--- a/test/mri/rdoc/rdoc_parser_ruby_test.rb
+++ /dev/null
@@ -1,4396 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'helper'
-
-return if ENV['RDOC_USE_PRISM_PARSER']
-
-class RDocParserRubyTest < RDoc::TestCase
-
-  def setup
-    super
-
-    @tempfile = Tempfile.new self.class.name
-    @filename = @tempfile.path
-
-    # Some tests need two paths.
-    @tempfile2 = Tempfile.new self.class.name
-    @filename2 = @tempfile2.path
-
-    @top_level = @store.add_file @filename
-    @top_level2 = @store.add_file @filename2
-
-    @options = RDoc::Options.new
-    @options.quiet = true
-    @options.option_parser = OptionParser.new
-
-    @comment = RDoc::Comment.new '', @top_level
-
-    @stats = RDoc::Stats.new @store, 0
-  end
-
-  def teardown
-    super
-
-    @tempfile.close!
-    @tempfile2.close!
-  end
-
-  def test_collect_first_comment
-    p = util_parser <<-CONTENT
-# first
-
-# second
-class C; end
-    CONTENT
-
-    comment = p.collect_first_comment
-
-    assert_equal RDoc::Comment.new("# first\n", @top_level), comment
-  end
-
-  def test_collect_first_comment_encoding
-    @options.encoding = Encoding::CP852
-
-    p = util_parser <<-CONTENT
-# first
-
-# second
-class C; end
-    CONTENT
-
-    comment = p.collect_first_comment
-
-    assert_equal Encoding::CP852, comment.text.encoding
-  end
-
-  def test_collect_first_comment_rd_hash
-    parser = util_parser <<-CONTENT
-=begin
-first
-=end
-
-# second
-class C; end
-    CONTENT
-
-    comment = parser.collect_first_comment
-
-    assert_equal RDoc::Comment.new("first\n", @top_level), comment
-  end
-
-  def test_get_class_or_module
-    ctxt = RDoc::Context.new
-    ctxt.store = @store
-
-    cont, name_t, given_name = util_parser('A')    .get_class_or_module ctxt
-
-    assert_equal ctxt, cont
-    assert_equal 'A', name_t[:text]
-    assert_equal 'A', given_name
-
-    cont, name_t, given_name = util_parser('B::C') .get_class_or_module ctxt
-
-    b = @store.find_module_named('B')
-    assert_equal b, cont
-    assert_equal [@top_level], b.in_files
-    assert_equal 'C', name_t[:text]
-    assert_equal 'B::C', given_name
-
-    cont, name_t, given_name = util_parser('D:: E').get_class_or_module ctxt
-
-    assert_equal @store.find_module_named('D'), cont
-    assert_equal 'E', name_t[:text]
-    assert_equal 'D::E', given_name
-
-    assert_nothing_raised do
-      util_parser("A::\nB").get_class_or_module ctxt
-    end
-  end
-
-  def test_get_class_or_module_document_children
-    ctxt = @top_level.add_class RDoc::NormalClass, 'A'
-    ctxt.stop_doc
-
-    util_parser('B::C').get_class_or_module ctxt
-
-    b = @store.find_module_named('A::B')
-    assert b.ignored?
-
-    d = @top_level.add_class RDoc::NormalClass, 'A::D'
-
-    util_parser('D::E').get_class_or_module ctxt
-
-    refute d.ignored?
-  end
-
-  def test_get_class_or_module_ignore_constants
-    ctxt = RDoc::Context.new
-    ctxt.store = @store
-
-    util_parser('A')   .get_class_or_module ctxt, true
-    util_parser('A::B').get_class_or_module ctxt, true
-
-    assert_empty ctxt.constants
-    assert_empty @store.modules_hash.keys
-    assert_empty @store.classes_hash.keys
-  end
-
-  def test_get_class_specification
-    assert_equal 'A',    util_parser('A')   .get_class_specification
-    assert_equal 'A::B', util_parser('A::B').get_class_specification
-    assert_equal '::A',  util_parser('::A').get_class_specification
-
-    assert_equal 'self', util_parser('self').get_class_specification
-
-    assert_equal '',     util_parser('').get_class_specification
-
-    assert_equal '',     util_parser('$g').get_class_specification
-  end
-
-  def test_get_symbol_or_name
-    util_parser "* & | + 5 / 4"
-
-    assert_equal '*', @parser.get_symbol_or_name
-
-    @parser.skip_tkspace
-
-    assert_equal '&', @parser.get_symbol_or_name
-
-    @parser.skip_tkspace
-
-    assert_equal '|', @parser.get_symbol_or_name
-
-    @parser.skip_tkspace
-
-    assert_equal '+', @parser.get_symbol_or_name
-
-    @parser.skip_tkspace
-    @parser.get_tk
-    @parser.skip_tkspace
-
-    assert_equal '/', @parser.get_symbol_or_name
-  end
-
-  def test_suppress_parents
-    a = @top_level.add_class RDoc::NormalClass, 'A'
-    b = a.add_class RDoc::NormalClass, 'B'
-    c = b.add_class RDoc::NormalClass, 'C'
-
-    util_parser ''
-
-    @parser.suppress_parents c, a
-
-    assert c.suppressed?
-    assert b.suppressed?
-    refute a.suppressed?
-  end
-
-  def test_suppress_parents_documented
-    a = @top_level.add_class RDoc::NormalClass, 'A'
-    b = a.add_class RDoc::NormalClass, 'B'
-    b.add_comment RDoc::Comment.new("hello"), @top_level
-    c = b.add_class RDoc::NormalClass, 'C'
-
-    util_parser ''
-
-    @parser.suppress_parents c, a
-
-    assert c.suppressed?
-    refute b.suppressed?
-    refute a.suppressed?
-  end
-
-  def test_look_for_directives_in_attr
-    util_parser ""
-
-    comment = RDoc::Comment.new "# :attr: my_attr\n", @top_level
-
-    @parser.look_for_directives_in @top_level, comment
-
-    assert_equal "# :attr: my_attr\n", comment.text
-
-    comment = RDoc::Comment.new "# :attr_reader: my_method\n", @top_level
-
-    @parser.look_for_directives_in @top_level, comment
-
-    assert_equal "# :attr_reader: my_method\n", comment.text
-
-    comment = RDoc::Comment.new "# :attr_writer: my_method\n", @top_level
-
-    @parser.look_for_directives_in @top_level, comment
-
-    assert_equal "# :attr_writer: my_method\n", comment.text
-  end
-
-  def test_look_for_directives_in_commented
-    util_parser ""
-
-    comment = RDoc::Comment.new <<-COMMENT, @top_level
-# how to make a section:
-# # :section: new section
-    COMMENT
-
-    @parser.look_for_directives_in @top_level, comment
-
-    section = @top_level.current_section
-    assert_nil   section.title
-    assert_nil   section.comment
-
-    assert_equal "# how to make a section:\n# # :section: new section\n",
-                 comment.text
-  end
-
-  def test_look_for_directives_in_method
-    util_parser ""
-
-    comment = RDoc::Comment.new "# :method: my_method\n", @top_level
-
-    @parser.look_for_directives_in @top_level, comment
-
-    assert_equal "# :method: my_method\n", comment.text
-
-    comment = RDoc::Comment.new "# :singleton-method: my_method\n", @top_level
-
-    @parser.look_for_directives_in @top_level, comment
-
-    assert_equal "# :singleton-method: my_method\n", comment.text
-  end
-
-  def test_look_for_directives_in_section
-    util_parser ""
-
-    comment = RDoc::Comment.new <<-COMMENT, @top_level
-# :section: new section
-# woo stuff
-    COMMENT
-
-    @parser.look_for_directives_in @top_level, comment
-
-    section = @top_level.current_section
-    assert_equal 'new section', section.title
-    assert_equal [comment("# woo stuff\n", @top_level)], section.comments
-
-    assert_empty comment
-  end
-
-  def test_look_for_directives_in_unhandled
-    util_parser ""
-
-    comment = RDoc::Comment.new "# :unhandled: blah\n", @top_level
-
-    @parser.look_for_directives_in @top_level, comment
-
-    assert_equal 'blah', @top_level.metadata['unhandled']
-  end
-
-  def test_parse_for_in
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-
-    comment = RDoc::Comment.new '', @top_level
-
-    util_parser <<ruby
-def sum(n)
-  result = 0
-  for i in 1..n do
-    result += i
-  end
-  result
-end
-ruby
-
-    tk = @parser.get_tk
-
-    @parser.parse_method klass, RDoc::Parser::Ruby::NORMAL, tk, comment
-
-    sum = klass.method_list.first
-    assert_equal 'sum',      sum.name
-    assert_equal @top_level, sum.file
-  end
-
-  def test_parse_on_ignored_nl_with_nil_text
-    util_parser <<ruby
-class Foo
-  def meth
-    variable # comment
-      .chain
-  end
-end
-ruby
-
-    expected = <<EXPECTED
-<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">meth</span>
-  <span class="ruby-identifier">variable</span> <span class="ruby-comment"># comment</span>
-    .<span class="ruby-identifier">chain</span>
-<span class="ruby-keyword">end</span>
-EXPECTED
-    expected = expected.rstrip
-
-    @parser.scan
-
-    foo = @store.find_class_named 'Foo'
-    meth = foo.method_list.first
-
-    assert_equal 'meth',     meth.name
-    assert_equal @top_level, meth.file
-
-    markup_code = meth.markup_code.sub(/^.*\n/, '')
-    assert_equal expected, markup_code
-  end
-
-  def test_parse_redefined_op_with_constant
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-
-    comment = RDoc::Comment.new '', @top_level
-
-    util_parser <<ruby
-def meth
-  Integer::**()
-  return Integer::**()
-  break Integer::**()
-  case Integer::**()
-  when Integer::**()
-  end
-  while Integer::**()
-  end
-  yield Integer::**()
-  defined? Integer::**()
-  if Integer::**()
-  end
-end
-ruby
-
-    tk = @parser.get_tk
-
-    @parser.parse_method klass, RDoc::Parser::Ruby::NORMAL, tk, comment
-
-    meth = klass.method_list.first
-    assert_equal 'meth',     meth.name
-  end
-
-  def test_parse_alias
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-
-    util_parser "alias :next= :bar"
-
-    tk = @parser.get_tk
-
-    alas = @parser.parse_alias klass, RDoc::Parser::Ruby::NORMAL, tk, 'comment'
-
-    assert_equal 'bar',      alas.old_name
-    assert_equal 'next=',    alas.new_name
-    assert_equal klass,      alas.parent
-    assert_equal 'comment',  alas.comment
-    assert_equal @top_level, alas.file
-    assert_equal 1,          alas.line
-  end
-
-  def test_parse_alias_singleton
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-
-    util_parser "alias :next= :bar"
-
-    tk = @parser.get_tk
-
-    alas = @parser.parse_alias klass, RDoc::Parser::Ruby::SINGLE, tk, 'comment'
-
-    assert_equal 'bar',      alas.old_name
-    assert_equal 'next=',    alas.new_name
-    assert_equal klass,      alas.parent
-    assert_equal 'comment',  alas.comment
-    assert_equal @top_level, alas.file
-    assert                   alas.singleton
-  end
-
-  def test_parse_alias_stopdoc
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-    klass.stop_doc
-
-    util_parser "alias :next= :bar"
-
-    tk = @parser.get_tk
-
-    @parser.parse_alias klass, RDoc::Parser::Ruby::NORMAL, tk, 'comment'
-
-    assert_empty klass.aliases
-    assert_empty klass.unmatched_alias_lists
-  end
-
-  def test_parse_alias_meta
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-
-    util_parser "alias m.chop m"
-
-    tk = @parser.get_tk
-
-    alas = @parser.parse_alias klass, RDoc::Parser::Ruby::NORMAL, tk, 'comment'
-
-    assert_nil alas
-  end
-
-  def test_parse_attr
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-
-    comment = RDoc::Comment.new "##\n# my attr\n", @top_level, :ruby
-
-    util_parser "attr :foo, :bar"
-
-    tk = @parser.get_tk
-
-    @parser.parse_attr klass, RDoc::Parser::Ruby::NORMAL, tk, comment
-
-    assert_equal 1, klass.attributes.length
-
-    foo = klass.attributes.first
-    assert_equal 'foo', foo.name
-    assert_equal 'my attr', foo.comment.text
-    assert_equal @top_level, foo.file
-    assert_equal 1, foo.line
-  end
-
-  def test_parse_attr_stopdoc
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-    klass.stop_doc
-
-    comment = RDoc::Comment.new "##\n# my attr\n", @top_level
-
-    util_parser "attr :foo, :bar"
-
-    tk = @parser.get_tk
-
-    @parser.parse_attr klass, RDoc::Parser::Ruby::NORMAL, tk, comment
-
-    assert_empty klass.attributes
-  end
-
-  def test_parse_attr_accessor
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-
-    comment = RDoc::Comment.new "##\n# my attr\n", @top_level, :ruby
-
-    util_parser "attr_accessor :foo, :bar"
-
-    tk = @parser.get_tk
-
-    @parser.parse_attr_accessor klass, RDoc::Parser::Ruby::NORMAL, tk, comment
-
-    assert_equal 2, klass.attributes.length
-
-    foo = klass.attributes.first
-    assert_equal 'foo', foo.name
-    assert_equal 'RW', foo.rw
-    assert_equal 'my attr', foo.comment.text
-    assert_equal @top_level, foo.file
-    assert_equal 1, foo.line
-
-    bar = klass.attributes.last
-    assert_equal 'bar', bar.name
-    assert_equal 'RW', bar.rw
-    assert_equal 'my attr', bar.comment.text
-  end
-
-  def test_parse_attr_accessor_with_newline
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-
-    comment = RDoc::Comment.new "##\n# my attr\n", @top_level, :ruby
-
-    util_parser "attr_accessor :foo, :bar,\n  :baz,\n  :qux"
-
-    tk = @parser.get_tk
-
-    @parser.parse_attr_accessor klass, RDoc::Parser::Ruby::NORMAL, tk, comment
-
-    assert_equal 4, klass.attributes.length
-
-    foo = klass.attributes[0]
-    assert_equal 'foo', foo.name
-    assert_equal 'RW', foo.rw
-    assert_equal 'my attr', foo.comment.text
-    assert_equal @top_level, foo.file
-    assert_equal 1, foo.line
-
-    bar = klass.attributes[1]
-    assert_equal 'bar', bar.name
-    assert_equal 'RW', bar.rw
-    assert_equal 'my attr', bar.comment.text
-
-    bar = klass.attributes[2]
-    assert_equal 'baz', bar.name
-    assert_equal 'RW', bar.rw
-    assert_equal 'my attr', bar.comment.text
-
-    bar = klass.attributes[3]
-    assert_equal 'qux', bar.name
-    assert_equal 'RW', bar.rw
-    assert_equal 'my attr', bar.comment.text
-  end
-
-  def test_parse_attr_accessor_nodoc
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-
-    comment = RDoc::Comment.new "##\n# my attr\n", @top_level
-
-    util_parser "attr_accessor :foo, :bar # :nodoc:"
-
-    tk = @parser.get_tk
-
-    @parser.parse_attr_accessor klass, RDoc::Parser::Ruby::NORMAL, tk, comment
-
-    assert_equal 0, klass.attributes.length
-  end
-
-  def test_parse_attr_accessor_nodoc_track
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-
-    comment = RDoc::Comment.new "##\n# my attr\n", @top_level
-
-    @options.visibility = :nodoc
-
-    util_parser "attr_accessor :foo, :bar # :nodoc:"
-
-    tk = @parser.get_tk
-
-    @parser.parse_attr_accessor klass, RDoc::Parser::Ruby::NORMAL, tk, comment
-
-    refute_empty klass.attributes
-  end
-
-  def test_parse_attr_accessor_stopdoc
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-    klass.stop_doc
-
-    comment = RDoc::Comment.new "##\n# my attr\n", @top_level
-
-    util_parser "attr_accessor :foo, :bar"
-
-    tk = @parser.get_tk
-
-    @parser.parse_attr_accessor klass, RDoc::Parser::Ruby::NORMAL, tk, comment
-
-    assert_empty klass.attributes
-  end
-
-  def test_parse_attr_accessor_writer
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-
-    comment = RDoc::Comment.new "##\n# my attr\n", @top_level, :ruby
-
-    util_parser "attr_writer :foo, :bar"
-
-    tk = @parser.get_tk
-
-    @parser.parse_attr_accessor klass, RDoc::Parser::Ruby::NORMAL, tk, comment
-
-    assert_equal 2, klass.attributes.length
-
-    foo = klass.attributes.first
-    assert_equal 'foo', foo.name
-    assert_equal 'W', foo.rw
-    assert_equal "my attr", foo.comment.text
-    assert_equal @top_level, foo.file
-
-    bar = klass.attributes.last
-    assert_equal 'bar', bar.name
-    assert_equal 'W', bar.rw
-    assert_equal "my attr", bar.comment.text
-  end
-
-  def test_parse_meta_attr
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-
-    comment = RDoc::Comment.new "##\n# :attr: \n# my method\n", @top_level, :ruby
-
-    util_parser "add_my_method :foo, :bar"
-
-    tk = @parser.get_tk
-
-    @parser.parse_meta_attr klass, RDoc::Parser::Ruby::NORMAL, tk, comment
-
-    assert_equal 2, klass.attributes.length
-    foo = klass.attributes.first
-    assert_equal 'foo', foo.name
-    assert_equal 'RW', foo.rw
-    assert_equal "my method", foo.comment.text
-    assert_equal @top_level, foo.file
-  end
-
-  def test_parse_meta_attr_accessor
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-
-    comment =
-      RDoc::Comment.new "##\n# :attr_accessor: \n# my method\n", @top_level, :ruby
-
-    util_parser "add_my_method :foo, :bar"
-
-    tk = @parser.get_tk
-
-    @parser.parse_meta_attr klass, RDoc::Parser::Ruby::NORMAL, tk, comment
-
-    assert_equal 2, klass.attributes.length
-    foo = klass.attributes.first
-    assert_equal 'foo', foo.name
-    assert_equal 'RW', foo.rw
-    assert_equal 'my method', foo.comment.text
-    assert_equal @top_level, foo.file
-  end
-
-  def test_parse_meta_attr_named
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-
-    comment = RDoc::Comment.new "##\n# :attr: foo\n# my method\n", @top_level, :ruby
-
-    util_parser "add_my_method :foo, :bar"
-
-    tk = @parser.get_tk
-
-    @parser.parse_meta_attr klass, RDoc::Parser::Ruby::NORMAL, tk, comment
-
-    assert_equal 1, klass.attributes.length
-    foo = klass.attributes.first
-    assert_equal 'foo', foo.name
-    assert_equal 'RW', foo.rw
-    assert_equal 'my method', foo.comment.text
-    assert_equal @top_level, foo.file
-  end
-
-  def test_parse_meta_attr_reader
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-
-    comment =
-      RDoc::Comment.new "##\n# :attr_reader: \n# my method\n", @top_level, :ruby
-
-    util_parser "add_my_method :foo, :bar"
-
-    tk = @parser.get_tk
-
-    @parser.parse_meta_attr klass, RDoc::Parser::Ruby::NORMAL, tk, comment
-
-    foo = klass.attributes.first
-    assert_equal 'foo', foo.name
-    assert_equal 'R', foo.rw
-    assert_equal 'my method', foo.comment.text
-    assert_equal @top_level, foo.file
-  end
-
-  def test_parse_meta_attr_stopdoc
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-    klass.stop_doc
-
-    comment = RDoc::Comment.new "##\n# :attr: \n# my method\n", @top_level
-
-    util_parser "add_my_method :foo, :bar"
-
-    tk = @parser.get_tk
-
-    @parser.parse_meta_attr klass, RDoc::Parser::Ruby::NORMAL, tk, comment
-
-    assert_empty klass.attributes
-  end
-
-  def test_parse_meta_attr_writer
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-
-    comment =
-      RDoc::Comment.new "##\n# :attr_writer: \n# my method\n", @top_level, :ruby
-
-    util_parser "add_my_method :foo, :bar"
-
-    tk = @parser.get_tk
-
-    @parser.parse_meta_attr klass, RDoc::Parser::Ruby::NORMAL, tk, comment
-
-    foo = klass.attributes.first
-    assert_equal 'foo', foo.name
-    assert_equal 'W', foo.rw
-    assert_equal "my method", foo.comment.text
-    assert_equal @top_level, foo.file
-  end
-
-  def test_parse_class
-    comment = RDoc::Comment.new "##\n# my class\n", @top_level, :ruby
-
-    util_parser "class Foo\nend"
-
-    tk = @parser.get_tk
-
-    @parser.parse_class @top_level, RDoc::Parser::Ruby::NORMAL, tk, comment
-
-    foo = @top_level.classes.first
-    assert_equal 'Foo', foo.full_name
-    assert_equal 'my class', foo.comment.text
-    assert_equal [@top_level], foo.in_files
-    assert_equal 1, foo.line
-  end
-
-  def test_parse_class_singleton
-    comment = RDoc::Comment.new "##\n# my class\n", @top_level
-
-    util_parser <<-RUBY
-class C
-  class << self
-  end
-end
-    RUBY
-
-    tk = @parser.get_tk
-
-    @parser.parse_class @top_level, RDoc::Parser::Ruby::NORMAL, tk, comment
-
-    c = @top_level.classes.first
-    assert_equal 'C', c.full_name
-    assert_equal 1, c.line
-  end
-
-  def test_parse_class_ghost_method
-    util_parser <<-CLASS
-class Foo
-  ##
-  # :method: blah
-  # my method
-end
-    CLASS
-
-    tk = @parser.get_tk
-
-    @parser.parse_class @top_level, RDoc::Parser::Ruby::NORMAL, tk, @comment
-
-    foo = @top_level.classes.first
-    assert_equal 'Foo', foo.full_name
-
-    blah = foo.method_list.first
-    assert_equal 'Foo#blah', blah.full_name
-    assert_equal 3, blah.line
-    assert_equal @top_level, blah.file
-  end
-
-  def test_parse_class_in_a_file_repeatedly
-    @filename = 'a.rb'
-    comment_a = RDoc::Comment.new "# aaa\n", @top_level
-    util_parser "class Foo\nend"
-    tk = @parser.get_tk
-    @parser.parse_class @top_level, RDoc::Parser::Ruby::NORMAL, tk, comment_a
-    comment_b = RDoc::Comment.new "# bbb\n", @top_level
-    util_parser "class Foo\nend"
-    tk = @parser.get_tk
-    @parser.parse_class @top_level, RDoc::Parser::Ruby::NORMAL, tk, comment_b
-
-    @filename = 'b.rb'
-    comment_c = RDoc::Comment.new "# ccc\n", @top_level
-    util_parser "class Foo\nend"
-    tk = @parser.get_tk
-    @parser.parse_class @top_level, RDoc::Parser::Ruby::NORMAL, tk, comment_c
-
-    foo = @top_level.classes.first
-    assert_equal 'Foo', foo.full_name
-    assert_equal [[comment_a, @top_level],
-                  [comment_b, @top_level],
-                  [comment_c, @top_level]], foo.comment_location
-    assert_equal [@top_level], foo.in_files
-    assert_equal 1, foo.line
-  end
-
-  def test_parse_class_ghost_method_yields
-    util_parser <<-CLASS
-class Foo
-  ##
-  # :method:
-  # :call-seq:
-  #   yields(name)
-end
-    CLASS
-
-    tk = @parser.get_tk
-
-    @parser.parse_class @top_level, RDoc::Parser::Ruby::NORMAL, tk, @comment
-
-    foo = @top_level.classes.first
-    assert_equal 'Foo', foo.full_name
-
-    blah = foo.method_list.first
-    assert_equal 'Foo#yields', blah.full_name
-    assert_equal 'yields(name)', blah.call_seq
-    assert_equal 3, blah.line
-    assert_equal @top_level, blah.file
-  end
-
-  def test_parse_call_syntax_sugar_for_constant
-    util_parser <<-CODE
-Foo = proc{}
-Foo::()
-    CODE
-
-    assert_nothing_raised do
-      @parser.scan
-    end
-  end
-
-  def test_parse_class_multi_ghost_methods
-    util_parser <<-'CLASS'
-class Foo
-  ##
-  # :method: one
-  #
-  # my method
-
-  ##
-  # :method: two
-  #
-  # my method
-
-  [:one, :two].each do |t|
-    eval("def #{t}; \"#{t}\"; end")
-  end
-end
-    CLASS
-
-    tk = @parser.get_tk
-
-    @parser.parse_class @top_level, RDoc::Parser::Ruby::NORMAL, tk, @comment
-
-    foo = @top_level.classes.first
-    assert_equal 'Foo', foo.full_name
-
-    assert_equal 2, foo.method_list.length
-  end
-
-  def test_parse_class_nodoc
-    comment = RDoc::Comment.new "##\n# my class\n", @top_level
-
-    util_parser "class Foo # :nodoc:\nend"
-
-    tk = @parser.get_tk
-
-    @parser.parse_class @top_level, RDoc::Parser::Ruby::NORMAL, tk, comment
-
-    foo = @top_level.classes.first
-    assert_equal 'Foo', foo.full_name
-    assert_empty foo.comment
-    assert_equal [@top_level], foo.in_files
-    assert_equal 1, foo.line
-  end
-
-  def test_parse_class_single_root
-    comment = RDoc::Comment.new "##\n# my class\n", @top_level
-
-    util_parser "class << ::Foo\nend"
-
-    tk = @parser.get_tk
-
-    @parser.parse_class @top_level, RDoc::Parser::Ruby::NORMAL, tk, comment
-
-    foo = @store.all_modules.first
-    assert_equal 'Foo', foo.full_name
-  end
-
-  def test_parse_class_stopdoc
-    @top_level.stop_doc
-
-    comment = RDoc::Comment.new "##\n# my class\n", @top_level
-
-    util_parser "class Foo\nend"
-
-    tk = @parser.get_tk
-
-    @parser.parse_class @top_level, RDoc::Parser::Ruby::NORMAL, tk, comment
-
-    assert_empty @top_level.classes.first.comment
-  end
-
-  def test_parse_class_lower_name_warning
-    @options.verbosity = 2
-    stds = capture_output do
-      util_parser "class foo\nend"
-      tk = @parser.get_tk
-      @parser.parse_class @top_level, RDoc::Parser::Ruby::NORMAL, tk, @comment
-    end
-    err = stds[1]
-    assert_match(/Expected class name or '<<\'\. Got/, err)
-  end
-
-  def test_parse_syntax_error_code
-    @options.verbosity = 2
-    stds = capture_output do
-      begin
-        util_parser <<INVALID_CODE
-# invalid class name
-class Invalid::@@Code
-end
-INVALID_CODE
-        @parser.scan
-      rescue
-      end
-    end
-    err = stds[1]
-
-    expected = <<EXPECTED
-RDoc::Parser::Ruby failure around line 2 of
-#{@filename}
-
-class Invalid::@@Code
-EXPECTED
-
-    assert_match(expected, err)
-  end
-
-  def test_parse_multi_ghost_methods
-    util_parser <<-'CLASS'
-class Foo
-  ##
-  # :method: one
-  #
-  # my method
-
-  ##
-  # :method: two
-  #
-  # my method
-
-  [:one, :two].each do |t|
-    eval("def #{t}; \"#{t}\"; end")
-  end
-end
-    CLASS
-
-    tk = @parser.get_tk
-
-    @parser.parse_class @top_level, RDoc::Parser::Ruby::NORMAL, tk, @comment
-
-    foo = @top_level.classes.first
-    assert_equal 'Foo', foo.full_name
-
-    assert_equal 2, foo.method_list.length
-  end
-
-  def test_parse_const_fail_w_meta
-    util_parser <<-CLASS
-class ConstFailMeta
-  ##
-  # :attr: one
-  #
-  # an attribute
-
-  OtherModule.define_attr(self, :one)
-end
-    CLASS
-
-    tk = @parser.get_tk
-
-    @parser.parse_class @top_level, RDoc::Parser::Ruby::NORMAL, tk, @comment
-
-    const_fail_meta = @top_level.classes.first
-    assert_equal 'ConstFailMeta', const_fail_meta.full_name
-
-    assert_equal 1, const_fail_meta.attributes.length
-  end
-
-  def test_parse_class_nested_superclass
-    foo = @top_level.add_module RDoc::NormalModule, 'Foo'
-
-    util_parser "class Bar < Super\nend"
-
-    tk = @parser.get_tk
-
-    @parser.parse_class foo, RDoc::Parser::Ruby::NORMAL, tk, @comment
-
-    bar = foo.classes.first
-    assert_equal 'Super', bar.superclass
-  end
-
-  def test_parse_module
-    comment = RDoc::Comment.new "##\n# my module\n", @top_level, :ruby
-
-    util_parser "module Foo\nend"
-
-    tk = @parser.get_tk
-
-    @parser.parse_module @top_level, RDoc::Parser::Ruby::NORMAL, tk, comment
-
-    foo = @top_level.modules.first
-    assert_equal 'Foo', foo.full_name
-    assert_equal 'my module', foo.comment.text
-  end
-
-  def test_parse_module_nodoc
-    @top_level.stop_doc
-
-    comment = RDoc::Comment.new "##\n# my module\n", @top_level
-
-    util_parser "module Foo # :nodoc:\nend"
-
-    tk = @parser.get_tk
-
-    @parser.parse_module @top_level, RDoc::Parser::Ruby::NORMAL, tk, comment
-
-    foo = @top_level.modules.first
-    assert_equal 'Foo', foo.full_name
-    assert_empty foo.comment
-  end
-
-  def test_parse_module_stopdoc
-    @top_level.stop_doc
-
-    comment = RDoc::Comment.new "##\n# my module\n", @top_level
-
-    util_parser "module Foo\nend"
-
-    tk = @parser.get_tk
-
-    @parser.parse_module @top_level, RDoc::Parser::Ruby::NORMAL, tk, comment
-
-    foo = @top_level.modules.first
-    assert_equal 'Foo', foo.full_name
-    assert_empty foo.comment
-  end
-
-  def test_parse_class_colon3
-    code = <<-CODE
-class A
-  class ::B
-  end
-end
-    CODE
-
-    util_parser code
-
-    @parser.parse_class @top_level, false, @parser.get_tk, @comment
-
-    assert_equal %w[A B], @store.all_classes.map { |c| c.full_name }.sort
-  end
-
-  def test_parse_class_colon3_self_reference
-    code = <<-CODE
-class A::B
-  class ::A
-  end
-end
-    CODE
-
-    util_parser code
-
-    @parser.parse_class @top_level, false, @parser.get_tk, @comment
-
-    assert_equal %w[A A::B], @store.all_classes.map { |c| c.full_name }.sort
-  end
-
-  def test_parse_class_single
-    code = <<-CODE
-class A
-  class << B
-  end
-  class << d = Object.new
-    def foo; end
-    alias bar foo
-  end
-end
-    CODE
-
-    util_parser code
-
-    @parser.parse_class @top_level, false, @parser.get_tk, @comment
-
-    assert_equal %w[A], @store.all_classes.map { |c| c.full_name }
-
-    modules = @store.all_modules.sort_by { |c| c.full_name }
-    assert_equal %w[A::B A::d], modules.map { |c| c.full_name }
-
-    b = modules.first
-    assert_equal 2,  b.line
-
-    # make sure method/alias was not added to enclosing class/module
-    a = @store.classes_hash['A']
-    assert_empty a.method_list
-
-    # make sure non-constant-named module will be removed from documentation
-    d = @store.modules_hash['A::d']
-    assert d.remove_from_documentation?
-  end
-
-  def test_parse_class_single_gvar
-    code = <<-CODE
-class << $g
-  def m
-  end
-end
-    CODE
-
-    util_parser code
-
-    @parser.parse_class @top_level, false, @parser.get_tk, ''
-
-    assert_empty @store.all_classes
-    mod = @store.all_modules.first
-
-    refute mod.document_self
-
-    assert_empty mod.method_list
-  end
-
-  # TODO this is really a Context#add_class test
-  def test_parse_class_object
-    code = <<-CODE
-module A
-  class B
-  end
-  class Object
-  end
-  class C < Object
-  end
-end
-    CODE
-
-    util_parser code
-
-    @parser.parse_module @top_level, false, @parser.get_tk, @comment
-
-    assert_equal %w[A],
-      @store.all_modules.map { |c| c.full_name }
-    assert_equal %w[A::B A::C A::Object],
-      @store.all_classes.map { |c| c.full_name }.sort
-
-    assert_equal 'Object',    @store.classes_hash['A::B'].superclass
-    assert_equal 'Object',    @store.classes_hash['A::Object'].superclass
-    assert_equal 'A::Object', @store.classes_hash['A::C'].superclass.full_name
-  end
-
-  def test_parse_class_mistaken_for_module
-    # The code below is not strictly legal Ruby (Foo must have been defined
-    # before Foo::Bar is encountered), but RDoc might encounter Foo::Bar
-    # before Foo if they live in different files.
-
-    code = <<-RUBY
-class Foo::Bar
-end
-
-module Foo::Baz
-end
-
-class Foo
-end
-    RUBY
-
-    util_parser code
-
-    @parser.scan
-
-    assert_equal %w[Foo::Baz], @store.modules_hash.keys
-    assert_empty @top_level.modules
-
-    foo = @top_level.classes.first
-    assert_equal 'Foo', foo.full_name
-
-    bar = foo.classes.first
-    assert_equal 'Foo::Bar', bar.full_name
-
-    baz = foo.modules.first
-    assert_equal 'Foo::Baz', baz.full_name
-  end
-
-  def test_parse_class_definition_encountered_after_class_reference
-    # The code below is not legal Ruby (Foo must have been defined before
-    # Foo.bar is encountered), but RDoc might encounter Foo.bar before Foo if
-    # they live in different files.
-
-    code = <<-EOF
-def Foo.bar
-end
-
-class Foo < IO
-end
-    EOF
-
-    util_parser code
-
-    @parser.scan
-
-    assert_empty @store.modules_hash
-    assert_empty @store.all_modules
-
-    foo = @top_level.classes.first
-    assert_equal 'Foo', foo.full_name
-    assert_equal 'IO', foo.superclass
-
-    bar = foo.method_list.first
-    assert_equal 'bar', bar.name
-  end
-
-  def test_parse_module_relative_to_top_level_namespace
-    comment = RDoc::Comment.new <<-EOF, @top_level
-#
-# Weirdly named module
-#
-EOF
-
-    code = <<-EOF
-#{comment.text}
-module ::Foo
-  class Helper
-  end
-end
-EOF
-
-    util_parser code
-    @parser.scan()
-
-    foo = @top_level.modules.first
-    assert_equal 'Foo', foo.full_name
-    assert_equal 'Weirdly named module', foo.comment.text
-
-    helper = foo.classes.first
-    assert_equal 'Foo::Helper', helper.full_name
-  end
-
-  def test_parse_comment_attr
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-
-    comment = RDoc::Comment.new "##\n# :attr: foo\n# my attr\n", @top_level, :ruby
-
-    util_parser "\n"
-
-    tk = @parser.get_tk
-
-    @parser.parse_comment klass, tk, comment
-
-    foo = klass.attributes.first
-    assert_equal 'foo',      foo.name
-    assert_equal 'RW',       foo.rw
-    assert_equal 'my attr',  foo.comment.text
-    assert_equal @top_level, foo.file
-    assert_equal 1,          foo.line
-
-    assert_equal true,       foo.document_children
-    assert_equal true,       foo.document_self
-    assert_equal false,      foo.done_documenting
-    assert_equal false,      foo.force_documentation
-    assert_equal klass,      foo.parent
-    assert_equal :public,    foo.visibility
-    assert_equal "\n",       foo.text
-
-    assert_equal klass.current_section, foo.section
-  end
-
-  def test_parse_comment_attr_attr_reader
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-
-    comment = RDoc::Comment.new "##\n# :attr_reader: foo\n", @top_level
-
-    util_parser "\n"
-
-    tk = @parser.get_tk
-
-    @parser.parse_comment klass, tk, comment
-
-    foo = klass.attributes.first
-    assert_equal 'foo',      foo.name
-    assert_equal 'R',        foo.rw
-  end
-
-  def test_parse_comment_attr_stopdoc
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-    klass.stop_doc
-
-    comment = RDoc::Comment.new "##\n# :attr: foo\n# my attr\n", @top_level
-
-    util_parser "\n"
-
-    tk = @parser.get_tk
-
-    @parser.parse_comment klass, tk, comment
-
-    assert_empty klass.attributes
-  end
-
-  def test_parse_comment_method
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-
-    comment = RDoc::Comment.new "##\n# :method: foo\n# my method\n", @top_level, :ruby
-
-    util_parser "\n"
-
-    tk = @parser.get_tk
-
-    @parser.parse_comment klass, tk, comment
-
-    foo = klass.method_list.first
-    assert_equal 'foo',       foo.name
-    assert_equal 'my method', foo.comment.text
-    assert_equal @top_level,  foo.file
-    assert_equal 2,           foo.line
-
-    assert_equal [],          foo.aliases
-    assert_nil                foo.block_params
-    assert_nil                foo.call_seq
-    assert_nil                foo.is_alias_for
-    assert_equal true,        foo.document_children
-    assert_equal true,        foo.document_self
-    assert_equal '',          foo.params
-    assert_equal false,       foo.done_documenting
-    assert_equal false,       foo.dont_rename_initialize
-    assert_equal false,       foo.force_documentation
-    assert_equal klass,       foo.parent
-    assert_equal false,       foo.singleton
-    assert_equal :public,     foo.visibility
-    assert_equal "\n",        foo.text
-    assert_equal klass.current_section, foo.section
-
-    stream = [
-      {
-        :line_no => 2, :char_no => 1, :kind => :on_comment,
-        :text => "# File #{@top_level.relative_name}, line 2"
-      },
-      { :line_no => 0, :char_no => 0, :kind => :on_nl, :text => "\n" },
-      { :line_no => 1, :char_no => 1, :kind => :on_sp, :text => '' }
-    ]
-    parsed_stream = foo.token_stream.map { |t|
-      {
-        :line_no => t[:line_no],
-        :char_no => t[:char_no],
-        :kind => t[:kind],
-        :text => t[:text]
-      }
-    }
-
-    assert_equal stream, parsed_stream
-  end
-
-  def test_parse_comment_method_args
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-
-
-    util_parser "\n"
-
-    tk = @parser.get_tk
-
-    @parser.parse_comment klass, tk,
-                          comment("##\n# :method: foo\n# :args: a, b\n")
-
-    foo = klass.method_list.first
-    assert_equal 'foo',  foo.name
-    assert_equal 'a, b', foo.params
-  end
-
-  def test_parse_comment_method_stopdoc
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-    klass.stop_doc
-
-    comment = RDoc::Comment.new "##\n# :method: foo\n# my method\n", @top_level
-
-    util_parser "\n"
-
-    tk = @parser.get_tk
-
-    @parser.parse_comment klass, tk, comment
-
-    assert_empty klass.method_list
-  end
-
-  def test_parse_constant
-    klass = @top_level.add_class RDoc::NormalClass, 'Foo'
-
-    util_parser "A = v"
-
-    tk = @parser.get_tk
-
-    @parser.parse_constant klass, tk, @comment
-
-    foo = klass.constants.first
-
-    assert_equal 'A', foo.name
-    assert_equal @top_level, foo.file
-    assert_equal 1, foo.line
-  end
-
-  def test_parse_constant_attrasgn
-    klass = @top_level.add_class RDoc::NormalClass, 'Foo'
-
-    util_parser "A[k] = v"
-
-    tk = @parser.get_tk
-
-    @parser.parse_constant klass, tk, @comment
-
-    assert klass.constants.empty?
-  end
-
-  def test_parse_constant_alias
-    klass = @top_level.add_class RDoc::NormalClass, 'Foo'
-    klass.add_class RDoc::NormalClass, 'B'
-
-    util_parser "A = B"
-
-    tk = @parser.get_tk
-
-    @parser.parse_constant klass, tk, @comment
-
-    assert_equal [], klass.modules.map(&:full_name)
-    assert_equal ['Foo::B', 'Foo::A'], klass.classes.map(&:full_name)
-    assert_equal ['Foo::A'], klass.constants.map(&:full_name)
-    assert_equal 'Foo::A', klass.find_module_named('A').full_name
-  end
-
-  def test_parse_constant_alias_same_name
-    foo = @top_level.add_class RDoc::NormalClass, 'Foo'
-    @top_level.add_class RDoc::NormalClass, 'Bar'
-    bar = foo.add_class RDoc::NormalClass, 'Bar'
-
-    assert @store.find_class_or_module('::Bar')
-
-    util_parser "A = ::Bar"
-
-    tk = @parser.get_tk
-
-    @parser.parse_constant foo, tk, @comment
-
-    assert_equal 'A', bar.find_module_named('A').full_name
-  end
-
-  def test_parse_constant_in_method
-    klass = @top_level.add_class RDoc::NormalClass, 'Foo'
-
-    util_parser 'A::B = v'
-
-    tk = @parser.get_tk
-
-    @parser.parse_constant klass, tk, @comment, true
-
-    assert_empty klass.constants
-
-    assert_empty @store.modules_hash.keys
-    assert_equal %w[Foo], @store.classes_hash.keys
-  end
-
-  def test_parse_constant_rescue
-    klass = @top_level.add_class RDoc::NormalClass, 'Foo'
-
-    util_parser "A => e"
-
-    tk = @parser.get_tk
-
-    @parser.parse_constant klass, tk, @comment
-
-    assert_empty klass.constants
-    assert_empty klass.modules
-
-    assert_empty @store.modules_hash.keys
-    assert_equal %w[Foo], @store.classes_hash.keys
-  end
-
-  def test_parse_constant_stopdoc
-    klass = @top_level.add_class RDoc::NormalClass, 'Foo'
-    klass.stop_doc
-
-    util_parser "A = v"
-
-    tk = @parser.get_tk
-
-    @parser.parse_constant klass, tk, @comment
-
-    assert_empty klass.constants
-  end
-
-  def test_parse_comment_nested
-    content = <<-CONTENT
-A::B::C = 1
-    CONTENT
-
-    util_parser content
-
-    tk = @parser.get_tk
-
-    parsed = @parser.parse_constant @top_level, tk, 'comment'
-
-    assert parsed
-
-    a = @top_level.find_module_named 'A'
-    b = a.find_module_named 'B'
-    c = b.constants.first
-
-    assert_equal 'A::B::C', c.full_name
-    assert_equal 'comment', c.comment
-  end
-
-  def test_parse_class_the_same_of_outside
-    util_parser <<-RUBY
-module A
-  class A::B
-  end
-end
-    RUBY
-
-    @parser.scan
-
-    assert_includes @store.modules_hash, 'A'
-    module_a = @store.find_module_named 'A'
-    refute_empty module_a.classes_hash
-    assert_includes module_a.classes_hash, 'B'
-    refute_includes module_a.classes_hash, 'A'
-  end
-
-  def test_parse_constant_the_same_of_outside
-    util_parser <<-RUBY
-module A
-  class B
-    class C
-    end
-  end
-
-  def self.foo
-    A::B::C
-  end
-end
-    RUBY
-
-    expected = <<EXPECTED
-<span class="ruby-keyword">def</span> <span class="ruby-keyword">self</span>.<span class="ruby-identifier ruby-title">foo</span>
-  <span class="ruby-constant">A</span><span class="ruby-operator">::</span><span class="ruby-constant">B</span><span class="ruby-operator">::</span><span class="ruby-constant">C</span>
-<span class="ruby-keyword">end</span>
-EXPECTED
-    expected = expected.rstrip
-
-    @parser.scan
-
-    module_a = @store.find_module_named 'A'
-    foo = module_a.method_list.first
-    markup_code = foo.markup_code.sub(/^.*\n/, '')
-    assert_equal expected, markup_code
-  end
-
-  def test_parse_constant_with_bracket
-    util_parser <<-RUBY
-class Klass
-end
-
-class Klass2
-  CONSTANT = Klass
-end
-
-class Klass3
-  CONSTANT_2 = {}
-  CONSTANT_2[1] = Klass
-end
-    RUBY
-
-    @parser.scan
-
-    klass = @store.find_class_named 'Klass'
-    klass2 = @store.find_class_named 'Klass2'
-    klass3 = @store.find_class_named 'Klass3'
-    assert_equal klass, klass2.constants.first.is_alias_for
-    refute_equal klass, klass3.constants.first.is_alias_for
-    assert_nil klass3.find_module_named 'CONSTANT_2'
-  end
-
-  def test_parse_extend_or_include_extend
-    klass = RDoc::NormalClass.new 'C'
-    klass.parent = @top_level
-
-    comment = RDoc::Comment.new "# my extend\n", @top_level, :ruby
-
-    util_parser "extend I"
-
-    @parser.get_tk # extend
-
-    @parser.parse_extend_or_include RDoc::Extend, klass, comment
-
-    assert_equal 1, klass.extends.length
-
-    ext = klass.extends.first
-    assert_equal 'I', ext.name
-    assert_equal 'my extend', ext.comment.text
-    assert_equal @top_level, ext.file
-  end
-
-  def test_parse_extend_or_include_include
-    klass = RDoc::NormalClass.new 'C'
-    klass.parent = @top_level
-
-    comment = RDoc::Comment.new "# my include\n", @top_level, :ruby
-
-    util_parser "include I"
-
-    @parser.get_tk # include
-
-    @parser.parse_extend_or_include RDoc::Include, klass, comment
-
-    assert_equal 1, klass.includes.length
-
-    incl = klass.includes.first
-    assert_equal 'I', incl.name
-    assert_equal 'my include', incl.comment.text
-    assert_equal @top_level, incl.file
-  end
-
-  def test_parse_meta_method
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-
-    comment = RDoc::Comment.new "##\n# my method\n", @top_level, :ruby
-
-    util_parser "add_my_method :foo, :bar\nadd_my_method :baz"
-
-    tk = @parser.get_tk
-
-    @parser.parse_meta_method klass, RDoc::Parser::Ruby::NORMAL, tk, comment
-
-    foo = klass.method_list.first
-    assert_equal 'foo',       foo.name
-    assert_equal 'my method', foo.comment.text
-    assert_equal @top_level,  foo.file
-    assert_equal 1,           foo.line
-
-    assert_equal [],      foo.aliases
-    assert_nil            foo.block_params
-    assert_nil            foo.call_seq
-    assert_equal true,    foo.document_children
-    assert_equal true,    foo.document_self
-    assert_equal false,   foo.done_documenting
-    assert_equal false,   foo.dont_rename_initialize
-    assert_equal false,   foo.force_documentation
-    assert_nil            foo.is_alias_for
-    assert_equal '',      foo.params
-    assert_equal klass,   foo.parent
-    assert_equal false,   foo.singleton
-    assert_equal 'add_my_method :foo', foo.text
-    assert_equal :public, foo.visibility
-    assert_equal klass.current_section, foo.section
-
-    stream = [
-      {
-        :line_no => 1, :char_no => 1, :kind => :on_comment,
-        :text => "# File #{@top_level.relative_name}, line 1"
-      },
-      { :line_no => 0, :char_no => 0, :kind => :on_nl, :text => "\n" },
-      { :line_no => 1, :char_no => 1, :kind => :on_sp, :text => '' },
-      { :line_no => 1, :char_no => 0, :kind => :on_ident, :text => 'add_my_method' },
-      { :line_no => 1, :char_no => 13, :kind => :on_sp, :text => ' ' },
-      { :line_no => 1, :char_no => 14, :kind => :on_symbol, :text => ':foo' },
-      { :line_no => 1, :char_no => 18, :kind => :on_comma, :text => ',' },
-      { :line_no => 1, :char_no => 19, :kind => :on_sp, :text => ' ' },
-      { :line_no => 1, :char_no => 20, :kind => :on_symbol, :text => ':bar' },
-      { :line_no => 1, :char_no => 24, :kind => :on_nl, :text => "\n" }
-    ]
-    parsed_stream = foo.token_stream.map { |t|
-      {
-        :line_no => t[:line_no],
-        :char_no => t[:char_no],
-        :kind => t[:kind],
-        :text => t[:text]
-      }
-    }
-
-    assert_equal stream, parsed_stream
-  end
-
-  def test_parse_meta_method_block
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-
-    comment = RDoc::Comment.new "##\n# my method\n", @top_level
-
-    content = <<-CONTENT
-inline(:my_method) do |*args|
-  "this method causes z to disappear"
-end
-    CONTENT
-
-    util_parser content
-
-    tk = @parser.get_tk
-
-    @parser.parse_meta_method klass, RDoc::Parser::Ruby::NORMAL, tk, comment
-
-    rest = { :line_no => 3, :char_no => 3, :kind => :on_nl, :text => "\n" }
-    tk = @parser.get_tk
-    tk = { :line_no => tk[:line_no], :char_no => tk[:char_no], :kind => tk[:kind], :text => tk[:text] }
-    assert_equal rest, tk
-  end
-
-  def test_parse_meta_method_define_method
-    klass = RDoc::NormalClass.new 'Foo'
-    comment = RDoc::Comment.new "##\n# my method\n", @top_level, :ruby
-
-    util_parser "define_method :foo do end"
-
-    tk = @parser.get_tk
-
-    @parser.parse_meta_method klass, RDoc::Parser::Ruby::NORMAL, tk, comment
-
-    foo = klass.method_list.first
-    assert_equal 'foo', foo.name
-    assert_equal 'my method', foo.comment.text
-    assert_equal @top_level,  foo.file
-  end
-
-  def test_parse_meta_method_name
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-
-    comment =
-      RDoc::Comment.new "##\n# :method: woo_hoo!\n# my method\n", @top_level, :ruby
-
-    util_parser "add_my_method :foo, :bar\nadd_my_method :baz"
-
-    tk = @parser.get_tk
-
-    @parser.parse_meta_method klass, RDoc::Parser::Ruby::NORMAL, tk, comment
-
-    foo = klass.method_list.first
-    assert_equal 'woo_hoo!',  foo.name
-    assert_equal 'my method', foo.comment.text
-    assert_equal @top_level,  foo.file
-  end
-
-  def test_parse_meta_method_singleton
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-
-    comment =
-      RDoc::Comment.new "##\n# :singleton-method:\n# my method\n", @top_level, :ruby
-
-    util_parser "add_my_method :foo, :bar\nadd_my_method :baz"
-
-    tk = @parser.get_tk
-
-    @parser.parse_meta_method klass, RDoc::Parser::Ruby::NORMAL, tk, comment
-
-    foo = klass.method_list.first
-    assert_equal 'foo', foo.name
-    assert_equal true, foo.singleton, 'singleton method'
-    assert_equal 'my method', foo.comment.text
-    assert_equal @top_level,  foo.file
-  end
-
-  def test_parse_meta_method_singleton_name
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-
-    comment =
-      RDoc::Comment.new "##\n# :singleton-method: woo_hoo!\n# my method\n",
-                        @top_level, :ruby
-
-    util_parser "add_my_method :foo, :bar\nadd_my_method :baz"
-
-    tk = @parser.get_tk
-
-    @parser.parse_meta_method klass, RDoc::Parser::Ruby::NORMAL, tk, comment
-
-    foo = klass.method_list.first
-    assert_equal 'woo_hoo!', foo.name
-    assert_equal true, foo.singleton, 'singleton method'
-    assert_equal 'my method', foo.comment.text
-    assert_equal @top_level,  foo.file
-  end
-
-  def test_parse_meta_method_string_name
-    klass = RDoc::NormalClass.new 'Foo'
-    comment = RDoc::Comment.new "##\n# my method\n", @top_level, :ruby
-
-    util_parser "add_my_method 'foo'"
-
-    tk = @parser.get_tk
-
-    @parser.parse_meta_method klass, RDoc::Parser::Ruby::NORMAL, tk, comment
-
-    foo = klass.method_list.first
-    assert_equal 'foo', foo.name
-    assert_equal 'my method', foo.comment.text
-    assert_equal @top_level,  foo.file
-  end
-
-  def test_parse_meta_method_stopdoc
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-    klass.stop_doc
-
-    comment = RDoc::Comment.new "##\n# my method\n", @top_level
-
-    util_parser "add_my_method :foo, :bar\nadd_my_method :baz"
-
-    tk = @parser.get_tk
-
-    @parser.parse_meta_method klass, RDoc::Parser::Ruby::NORMAL, tk, comment
-
-    assert_empty klass.method_list
-  end
-
-  def test_parse_meta_method_unknown
-    klass = RDoc::NormalClass.new 'Foo'
-    comment = RDoc::Comment.new "##\n# my method\n", @top_level, :ruby
-
-    util_parser "add_my_method ('foo')"
-
-    tk = @parser.get_tk
-
-    @parser.parse_meta_method klass, RDoc::Parser::Ruby::NORMAL, tk, comment
-
-    foo = klass.method_list.first
-    assert_equal 'unknown', foo.name
-    assert_equal 'my method', foo.comment.text
-    assert_equal @top_level,  foo.file
-  end
-
-  def test_parse_method
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-
-    comment = RDoc::Comment.new "##\n# my method\n", @top_level, :ruby
-
-    util_parser "def foo() :bar end"
-
-    tk = @parser.get_tk
-
-    @parser.parse_method klass, RDoc::Parser::Ruby::NORMAL, tk, comment
-
-    foo = klass.method_list.first
-    assert_equal 'foo',       foo.name
-    assert_equal 'my method', foo.comment.text
-    assert_equal @top_level,  foo.file
-    assert_equal 1,           foo.line
-
-    assert_equal [],        foo.aliases
-    assert_nil              foo.block_params
-    assert_nil              foo.call_seq
-    assert_nil              foo.is_alias_for
-    assert_equal true,      foo.document_children
-    assert_equal true,      foo.document_self
-    assert_equal '()',      foo.params
-    assert_equal false,     foo.done_documenting
-    assert_equal false,     foo.dont_rename_initialize
-    assert_equal false,     foo.force_documentation
-    assert_equal klass,     foo.parent
-    assert_equal false,     foo.singleton
-    assert_equal :public,   foo.visibility
-    assert_equal 'def foo', foo.text
-    assert_equal klass.current_section, foo.section
-
-    stream = [
-      {
-        :line_no => 1, :char_no => 1, :kind => :on_comment,
-        :text => "# File #{@top_level.relative_name}, line 1" },
-      { :line_no => 0, :char_no => 0, :kind => :on_nl, :text => "\n" },
-      { :line_no => 1, :char_no => 1, :kind => :on_sp, :text => '' },
-      { :line_no => 1, :char_no => 0, :kind => :on_kw, :text => 'def' },
-      { :line_no => 1, :char_no => 3, :kind => :on_sp, :text => ' ' },
-      { :line_no => 1, :char_no => 4, :kind => :on_ident, :text => 'foo' },
-      { :line_no => 1, :char_no => 7, :kind => :on_lparen, :text => '(' },
-      { :line_no => 1, :char_no => 8, :kind => :on_rparen, :text => ')' },
-      { :line_no => 1, :char_no => 9, :kind => :on_sp, :text => ' ' },
-      { :line_no => 1, :char_no => 10, :kind => :on_symbol, :text => ':bar' },
-      { :line_no => 1, :char_no => 14, :kind => :on_sp, :text => ' ' },
-      { :line_no => 1, :char_no => 15, :kind => :on_kw, :text => 'end' }
-    ]
-    parsed_stream = foo.token_stream.map { |t|
-      {
-        :line_no => t[:line_no],
-        :char_no => t[:char_no],
-        :kind => t[:kind],
-        :text => t[:text]
-      }
-    }
-    assert_equal stream, parsed_stream
-  end
-
-  def test_parse_redefinable_methods
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-
-    comment = RDoc::Comment.new "", @top_level
-
-    redefinable_ops = %w[| ^ & <=> == === =~ > >= < <= << >> + - * / % ** ~ +@ -@ [] []= ` !  != !~]
-    redefinable_ops.each do |redefinable_op|
-      util_parser "def #{redefinable_op}\nend\n"
-      tk = @parser.get_tk
-      @parser.parse_method klass, RDoc::Parser::Ruby::NORMAL, tk, comment
-    end
-
-    klass.method_list.each do |method|
-      assert_equal :on_ident, method.token_stream[5][:kind]
-      assert_includes redefinable_ops, method.token_stream[5][:text]
-    end
-  end
-
-  def test_parse_method_with_args_directive
-    util_parser <<-RUBY
-class C
-  def meth_with_args_after # :args: a, b, c
-  end
-
-  ##
-  # :args: d, e, f
-  def meth_with_args_before
-end
-    RUBY
-
-    @parser.scan
-
-    c = @store.find_class_named 'C'
-
-    assert_equal 'C#meth_with_args_after', c.method_list[0].full_name
-    assert_equal 'a, b, c', c.method_list[0].params
-    assert_equal 'C#meth_with_args_before', c.method_list[1].full_name
-    assert_equal 'd, e, f', c.method_list[1].params
-  end
-
-  def test_parse_method_bracket
-    util_parser <<-RUBY
-class C
-  def []; end
-  def self.[]; end
-  def []=; end
-  def self.[]=; end
-end
-    RUBY
-
-    @parser.scan
-
-    c = @store.find_class_named 'C'
-
-    assert_equal 4, c.method_list.size
-    assert_equal 'C#[]', c.method_list[0].full_name
-    assert_equal 'C::[]', c.method_list[1].full_name
-    assert_equal 'C#[]=', c.method_list[2].full_name
-    assert_equal 'C::[]=', c.method_list[3].full_name
-    assert c.aliases.empty?
-  end
-
-  def test_parse_method_alias
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-
-    util_parser "def m() alias a b; end"
-
-    tk = @parser.get_tk
-
-    @parser.parse_method klass, RDoc::Parser::Ruby::NORMAL, tk, @comment
-
-    assert klass.aliases.empty?
-  end
-
-  def test_parse_method_ampersand
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-
-    util_parser "def self.&\nend"
-
-    tk = @parser.get_tk
-
-    @parser.parse_method klass, RDoc::Parser::Ruby::NORMAL, tk, @comment
-
-    ampersand = klass.method_list.first
-    assert_equal '&', ampersand.name
-    assert            ampersand.singleton
-  end
-
-  def test_parse_method_constant
-    c = RDoc::Constant.new 'CONST', nil, ''
-    m = @top_level.add_class RDoc::NormalModule, 'M'
-    m.add_constant c
-
-    util_parser "def CONST.m() end"
-
-    tk = @parser.get_tk
-
-    @parser.parse_method m, RDoc::Parser::Ruby::NORMAL, tk, @comment
-
-    assert_empty @store.modules_hash.keys
-    assert_equal %w[M], @store.classes_hash.keys
-  end
-
-  def test_parse_method_false
-    util_parser "def false.foo() :bar end"
-
-    tk = @parser.get_tk
-
-    @parser.parse_method @top_level, RDoc::Parser::Ruby::NORMAL, tk, @comment
-
-    klass = @store.find_class_named 'FalseClass'
-
-    foo = klass.method_list.first
-    assert_equal 'foo', foo.name
-  end
-
-  def test_parse_method_funky
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-
-    util_parser "def (blah).foo() :bar end"
-
-    tk = @parser.get_tk
-
-    @parser.parse_method klass, RDoc::Parser::Ruby::NORMAL, tk, @comment
-
-    assert_empty klass.method_list
-  end
-
-  def test_parse_method_gvar
-    util_parser "def $stdout.foo() :bar end"
-
-    tk = @parser.get_tk
-
-    @parser.parse_method @top_level, RDoc::Parser::Ruby::NORMAL, tk, @comment
-
-    assert @top_level.method_list.empty?
-  end
-
-  def test_parse_method_gvar_insane
-    util_parser "def $stdout.foo() class << $other; end; end"
-
-    tk = @parser.get_tk
-
-    @parser.parse_method @top_level, RDoc::Parser::Ruby::NORMAL, tk, @comment
-
-    assert @top_level.method_list.empty?
-
-    assert_empty @store.all_classes
-
-    assert_equal 1, @store.all_modules.length
-
-    refute @store.all_modules.first.document_self
-  end
-
-  def test_parse_method_internal_gvar
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-
-    util_parser "def foo() def $blah.bar() end end"
-
-    tk = @parser.get_tk
-
-    @parser.parse_method klass, RDoc::Parser::Ruby::NORMAL, tk, @comment
-
-    assert_equal 1, klass.method_list.length
-  end
-
-  def test_parse_method_internal_ivar
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-
-    util_parser "def foo() def @blah.bar() end end"
-
-    tk = @parser.get_tk
-
-    @parser.parse_method klass, RDoc::Parser::Ruby::NORMAL, tk, @comment
-
-    assert_equal 1, klass.method_list.length
-  end
-
-  def test_parse_method_internal_lvar
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-
-    util_parser "def foo() def blah.bar() end end"
-
-    tk = @parser.get_tk
-
-    @parser.parse_method klass, RDoc::Parser::Ruby::NORMAL, tk, @comment
-
-    assert_equal 1, klass.method_list.length
-  end
-
-  def test_parse_method_nil
-    util_parser "def nil.foo() :bar end"
-
-    tk = @parser.get_tk
-
-    @parser.parse_method @top_level, RDoc::Parser::Ruby::NORMAL, tk, @comment
-
-    klass = @store.find_class_named 'NilClass'
-
-    foo = klass.method_list.first
-    assert_equal 'foo', foo.name
-  end
-
-  def test_parse_method_nodoc
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-
-    util_parser "def foo # :nodoc:\nend"
-
-    tk = @parser.get_tk
-
-    @parser.parse_method klass, RDoc::Parser::Ruby::NORMAL, tk, comment('')
-
-    assert_empty klass.method_list
-  end
-
-  def test_parse_method_nodoc_track
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-
-    @options.visibility = :nodoc
-
-    util_parser "def foo # :nodoc:\nend"
-
-    tk = @parser.get_tk
-
-    @parser.parse_method klass, RDoc::Parser::Ruby::NORMAL, tk, comment('')
-
-    refute_empty klass.method_list
-  end
-
-  def test_parse_method_no_parens
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-
-    util_parser "def foo arg1, arg2 = {}\nend"
-
-    tk = @parser.get_tk
-
-    @parser.parse_method klass, RDoc::Parser::Ruby::NORMAL, tk, @comment
-
-    foo = klass.method_list.first
-    assert_equal '(arg1, arg2 = {})', foo.params
-    assert_equal @top_level, foo.file
-  end
-
-  def test_parse_method_parameters_comment
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-
-    util_parser "def foo arg1, arg2 # some useful comment\nend"
-
-    tk = @parser.get_tk
-
-    @parser.parse_method klass, RDoc::Parser::Ruby::NORMAL, tk, @comment
-
-    foo = klass.method_list.first
-    assert_equal '(arg1, arg2)', foo.params
-  end
-
-  def test_parse_method_parameters_comment_continue
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-
-    util_parser "def foo arg1, arg2, # some useful comment\narg3\nend"
-
-    tk = @parser.get_tk
-
-    @parser.parse_method klass, RDoc::Parser::Ruby::NORMAL, tk, @comment
-
-    foo = klass.method_list.first
-    assert_equal '(arg1, arg2, arg3)', foo.params
-  end
-
-  def test_parse_method_parameters_with_paren_comment_continue
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-
-    util_parser "def foo(arg1, arg2, # some useful comment\narg3)\nend"
-
-    tk = @parser.get_tk
-
-    @parser.parse_method klass, RDoc::Parser::Ruby::NORMAL, tk, @comment
-
-    foo = klass.method_list.first
-    assert_equal '(arg1, arg2, arg3)', foo.params
-  end
-
-  def test_parse_method_star
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-
-    util_parser "def self.*\nend"
-
-    tk = @parser.get_tk
-
-    @parser.parse_method klass, RDoc::Parser::Ruby::NORMAL, tk, @comment
-
-    ampersand = klass.method_list.first
-    assert_equal '*', ampersand.name
-    assert            ampersand.singleton
-  end
-
-  def test_parse_method_stopdoc
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-    klass.stop_doc
-
-    comment = RDoc::Comment.new "##\n# my method\n", @top_level
-
-    util_parser "def foo() :bar end"
-
-    tk = @parser.get_tk
-
-    @parser.parse_method klass, RDoc::Parser::Ruby::NORMAL, tk, comment
-
-    assert_empty klass.method_list
-  end
-
-  def test_parse_method_toplevel
-    klass = @top_level
-
-    util_parser "def foo arg1, arg2\nend"
-
-    tk = @parser.get_tk
-
-    @parser.parse_method klass, RDoc::Parser::Ruby::NORMAL, tk, @comment
-
-    object = @store.find_class_named 'Object'
-
-    foo = object.method_list.first
-    assert_equal 'Object#foo', foo.full_name
-    assert_equal @top_level, foo.file
-  end
-
-  def test_parse_method_toplevel_class
-    klass = @top_level
-
-    util_parser "def Object.foo arg1, arg2\nend"
-
-    tk = @parser.get_tk
-
-    @parser.parse_method klass, RDoc::Parser::Ruby::NORMAL, tk, @comment
-
-    object = @store.find_class_named 'Object'
-
-    foo = object.method_list.first
-    assert_equal 'Object::foo', foo.full_name
-  end
-
-  def test_parse_method_true
-    util_parser "def true.foo() :bar end"
-
-    tk = @parser.get_tk
-
-    @parser.parse_method @top_level, RDoc::Parser::Ruby::NORMAL, tk, @comment
-
-    klass = @store.find_class_named 'TrueClass'
-
-    foo = klass.method_list.first
-    assert_equal 'foo', foo.name
-  end
-
-  def test_parse_method_utf8
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-
-    method = "def ω() end"
-
-    assert_equal Encoding::UTF_8, method.encoding
-
-    util_parser method
-
-    tk = @parser.get_tk
-
-    @parser.parse_method klass, RDoc::Parser::Ruby::NORMAL, tk, @comment
-
-    omega = klass.method_list.first
-    assert_equal "def \317\211", omega.text
-  end
-
-  def test_parse_method_dummy
-    util_parser ".method() end"
-
-    @parser.parse_method_dummy @top_level
-
-    assert_nil @parser.get_tk
-  end
-
-  def test_parse_method_or_yield_parameters_hash
-    util_parser "({})\n"
-
-    m = RDoc::AnyMethod.new nil, 'm'
-
-    result = @parser.parse_method_or_yield_parameters m
-
-    assert_equal '({})', result
-  end
-
-  def test_parse_statements_class_if
-    util_parser <<-CODE
-module Foo
-  X = if TRUE then
-        ''
-      end
-
-  def blah
-  end
-end
-    CODE
-
-    @parser.parse_statements @top_level, RDoc::Parser::Ruby::NORMAL, nil
-
-    foo = @top_level.modules.first
-    assert_equal 'Foo', foo.full_name, 'module Foo'
-
-    methods = foo.method_list
-    assert_equal 1, methods.length
-    assert_equal 'Foo#blah', methods.first.full_name
-  end
-
-  def test_parse_statements_postfix_if_unless
-    util_parser <<-CODE
-class C
-  def foo
-    1 if nil
-  end
-
-  def bar
-    2 unless nil
-  end
-end
-    CODE
-
-    @parser.parse_statements @top_level, RDoc::Parser::Ruby::NORMAL, nil
-
-    c = @top_level.classes.first
-    assert_equal 'C', c.full_name, 'class C'
-
-    methods = c.method_list
-    assert_equal 2, methods.length
-    assert_equal 'C#foo', methods[0].full_name
-    assert_equal 'C#bar', methods[1].full_name
-  end
-
-  def test_parse_statements_postfix_if_unless_with_expr_mid
-    util_parser <<-CODE
-class A
-  class B
-    def foo
-      return if nil
-    end
-  end
-
-  class C
-  end
-end
-    CODE
-
-    @parser.parse_statements @top_level, RDoc::Parser::Ruby::NORMAL, nil
-
-    a = @top_level.classes.first
-    assert_equal 'A', a.full_name, 'class A'
-    assert_equal 2, a.classes.length
-    b = a.classes[0]
-    assert_equal 'A::B', b.full_name, 'class A::B'
-    c = a.classes[1]
-    assert_equal 'A::C', c.full_name, 'class A::C'
-  end
-
-  def test_parse_statements_class_nested
-    comment = RDoc::Comment.new "##\n# my method\n", @top_level
-
-    util_parser "module Foo\n#{comment.text}class Bar\nend\nend"
-
-    @parser.parse_statements @top_level, RDoc::Parser::Ruby::NORMAL
-
-    foo = @top_level.modules.first
-    assert_equal 'Foo', foo.full_name, 'module Foo'
-
-    bar = foo.classes.first
-    assert_equal 'Foo::Bar', bar.full_name, 'class Foo::Bar'
-    assert_equal 'my method', bar.comment.text
-  end
-
-  def test_parse_statements_def_percent_string_pound
-    util_parser "class C\ndef a\n%r{#}\n%r{\#{}}\nend\ndef b() end\nend"
-
-    @parser.parse_statements @top_level, RDoc::Parser::Ruby::NORMAL
-
-    x = @top_level.classes.first
-
-    assert_equal 2, x.method_list.length
-    a = x.method_list.first
-
-
-    expected = [
-      {
-        :line_no => 2, :char_no => 1, :kind => :on_comment,
-        :text => "# File #{@filename}, line 2"
-      },
-      { :line_no => 0, :char_no => 0, :kind => :on_nl, :text => "\n" },
-      { :line_no => 1, :char_no => 1, :kind => :on_sp, :text => '' },
-      { :line_no => 2, :char_no => 0, :kind => :on_kw, :text => 'def' },
-      { :line_no => 2, :char_no => 3, :kind => :on_sp, :text => ' ' },
-      { :line_no => 2, :char_no => 4, :kind => :on_ident, :text => 'a' },
-      { :line_no => 2, :char_no => 5, :kind => :on_nl, :text => "\n" },
-      { :line_no => 3, :char_no => 0, :kind => :on_regexp, :text => '%r{#}' },
-      { :line_no => 3, :char_no => 5, :kind => :on_nl, :text => "\n" },
-      { :line_no => 4, :char_no => 0, :kind => :on_regexp, :text => '%r{#{}}' },
-      { :line_no => 4, :char_no => 7, :kind => :on_nl, :text => "\n" },
-      { :line_no => 5, :char_no => 0, :kind => :on_kw, :text => 'end' }
-    ]
-    parsed_stream = a.token_stream.map { |tk|
-      {
-        :line_no => tk[:line_no],
-        :char_no => tk[:char_no],
-        :kind => tk[:kind],
-        :text => tk[:text]
-      }
-    }
-
-    assert_equal expected, parsed_stream
-  end
-
-  def test_parse_statements_encoding
-    @options.encoding = Encoding::CP852
-
-    content = <<-EOF
-class Foo
-  ##
-  # this is my method
-  add_my_method :foo
-end
-    EOF
-
-    util_parser content
-
-    @parser.parse_statements @top_level
-
-    foo = @top_level.classes.first.method_list.first
-    assert_equal 'foo', foo.name
-    assert_equal 'this is my method', foo.comment.text
-    assert_equal Encoding::CP852, foo.comment.text.encoding
-  end
-
-  def test_parse_statements_enddoc
-    klass = @top_level.add_class RDoc::NormalClass, 'Foo'
-
-    util_parser "\n# :enddoc:"
-
-    @parser.parse_statements klass, RDoc::Parser::Ruby::NORMAL, nil
-
-    assert klass.done_documenting
-  end
-
-  def test_parse_statements_enddoc_top_level
-    util_parser "\n# :enddoc:"
-
-    assert_throws :eof do
-      @parser.parse_statements @top_level, RDoc::Parser::Ruby::NORMAL, nil
-    end
-  end
-
-  def test_parse_statements_identifier_meta_method
-    content = <<-EOF
-class Foo
-  ##
-  # this is my method
-  add_my_method :foo
-end
-    EOF
-
-    util_parser content
-
-    @parser.parse_statements @top_level
-
-    foo = @top_level.classes.first.method_list.first
-    assert_equal 'foo', foo.name
-  end
-
-  def test_parse_statements_identifier_alias_method
-    content = <<-RUBY
-class Foo
-  def foo() end
-  alias_method :foo2, :foo
-end
-    RUBY
-
-    util_parser content
-
-    @parser.parse_statements @top_level
-
-    foo = @top_level.classes.first.method_list[0]
-    assert_equal 'foo', foo.name
-
-    foo2 = @top_level.classes.first.method_list.last
-    assert_equal 'foo2', foo2.name
-    assert_equal 'foo', foo2.is_alias_for.name
-    assert @top_level.classes.first.aliases.empty?
-  end
-
-  def test_parse_statements_identifier_alias_method_before_original_method
-    # This is not strictly legal Ruby code, but it simulates finding an alias
-    # for a method before finding the original method, which might happen
-    # to rdoc if the alias is in a different file than the original method
-    # and rdoc processes the alias' file first.
-    content = <<-EOF
-class Foo
-  alias_method :foo2, :foo
-
-  alias_method :foo3, :foo
-
-  def foo()
-  end
-
-  alias_method :foo4, :foo
-
-  alias_method :foo5, :unknown
-end
-EOF
-
-    util_parser content
-
-    @parser.parse_statements @top_level
-
-    foo = @top_level.classes.first.method_list[0]
-    assert_equal 'foo', foo.name
-
-    foo2 = @top_level.classes.first.method_list[1]
-    assert_equal 'foo2', foo2.name
-    assert_equal 'foo', foo2.is_alias_for.name
-
-    foo3 = @top_level.classes.first.method_list[2]
-    assert_equal 'foo3', foo3.name
-    assert_equal 'foo', foo3.is_alias_for.name
-
-    foo4 = @top_level.classes.first.method_list.last
-    assert_equal 'foo4', foo4.name
-    assert_equal 'foo', foo4.is_alias_for.name
-
-    assert_equal 'unknown', @top_level.classes.first.external_aliases[0].old_name
-  end
-
-  def test_parse_statements_identifier_args
-    comment = "##\n# :args: x\n# :method: b\n# my method\n"
-
-    util_parser "module M\n#{comment}def_delegator :a, :b, :b\nend"
-
-    @parser.parse_statements @top_level, RDoc::Parser::Ruby::NORMAL
-
-    m = @top_level.modules.first
-    assert_equal 'M', m.full_name
-
-    b = m.method_list.first
-    assert_equal 'M#b', b.full_name
-    assert_equal 'x', b.params
-    assert_equal 'my method', b.comment.text
-
-    assert_nil m.params, 'Module parameter not removed'
-  end
-
-  def test_parse_statements_identifier_constant
-    sixth_constant = <<-EOF
-Class.new do
-  rule :file do
-    all(x, y, z) {
-      def value
-        find(:require).each {|r| require r.value }
-        find(:grammar).map {|g| g.value }
-      end
-      def min; end
-    }
-  end
-end
-    EOF
-
-    content = <<-EOF
-class Foo
-  FIRST_CONSTANT = 5
-
-  SECOND_CONSTANT = [
-     1,
-     2,
-     3
-  ]
-
-  THIRD_CONSTANT = {
-     :foo => 'bar',
-     :x => 'y'
-  }
-
-  FOURTH_CONSTANT = SECOND_CONSTANT.map do |element|
-    element + 1
-    element + 2
-  end
-
-  FIFTH_CONSTANT = SECOND_CONSTANT.map { |element| element + 1 }
-
-  SIXTH_CONSTANT = #{sixth_constant}
-
-  SEVENTH_CONSTANT = proc { |i| begin i end }
-
-  EIGHTH_CONSTANT = "a" \\
-                    "b"
-end
-EOF
-
-    util_parser content
-
-    @parser.parse_statements @top_level
-
-    constants = @top_level.classes.first.constants
-
-    constant = constants[0]
-    assert_equal 'FIRST_CONSTANT', constant.name
-    assert_equal '5', constant.value
-    assert_equal @top_level, constant.file
-
-    constant = constants[1]
-    assert_equal 'SECOND_CONSTANT', constant.name
-    assert_equal "[\n1,\n2,\n3\n]", constant.value
-    assert_equal @top_level, constant.file
-
-    constant = constants[2]
-    assert_equal 'THIRD_CONSTANT', constant.name
-    assert_equal "{\n:foo => 'bar',\n:x => 'y'\n}", constant.value
-    assert_equal @top_level, constant.file
-
-    constant = constants[3]
-    assert_equal 'FOURTH_CONSTANT', constant.name
-    assert_equal "SECOND_CONSTANT.map do |element|\nelement + 1\nelement + 2\nend", constant.value
-    assert_equal @top_level, constant.file
-
-    constant = constants[4]
-    assert_equal 'FIFTH_CONSTANT', constant.name
-    assert_equal 'SECOND_CONSTANT.map { |element| element + 1 }', constant.value
-    assert_equal @top_level, constant.file
-
-    # TODO: parse as class
-    constant = constants[5]
-    assert_equal 'SIXTH_CONSTANT', constant.name
-    assert_equal sixth_constant.lines.map(&:strip).join("\n"), constant.value
-    assert_equal @top_level, constant.file
-
-    # TODO: parse as method
-    constant = constants[6]
-    assert_equal 'SEVENTH_CONSTANT', constant.name
-    assert_equal "proc { |i| begin i end }", constant.value
-    assert_equal @top_level, constant.file
-
-    constant = constants[7]
-    assert_equal 'EIGHTH_CONSTANT', constant.name
-    assert_equal "\"a\" \\\n\"b\"", constant.value
-    assert_equal @top_level, constant.file
-  end
-
-  def test_parse_statements_identifier_attr
-    content = "class Foo\nattr :foo\nend"
-
-    util_parser content
-
-    @parser.parse_statements @top_level
-
-    foo = @top_level.classes.first.attributes.first
-    assert_equal 'foo', foo.name
-    assert_equal 'R', foo.rw
-  end
-
-  def test_parse_statements_identifier_attr_accessor
-    content = "class Foo\nattr_accessor :foo\nend"
-
-    util_parser content
-
-    @parser.parse_statements @top_level
-
-    foo = @top_level.classes.first.attributes.first
-    assert_equal 'foo', foo.name
-    assert_equal 'RW', foo.rw
-  end
-
-  def test_parse_statements_identifier_define_method
-    util_parser <<-RUBY
-class C
-  ##
-  # :method: a
-  define_method :a do end
-  ##
-  # :method: b
-  define_method :b do end
-end
-    RUBY
-
-    @parser.parse_statements @top_level
-    c = @top_level.classes.first
-
-    assert_equal %w[a b], c.method_list.map { |m| m.name }
-  end
-
-  def test_parse_statements_identifier_include
-    content = "class Foo\ninclude Bar\nend"
-
-    util_parser content
-
-    @parser.parse_statements @top_level
-
-    foo = @top_level.classes.first
-    assert_equal 'Foo', foo.name
-    assert_equal 1, foo.includes.length
-  end
-
-  def test_parse_statements_identifier_module_function
-    content = "module Foo\ndef foo() end\nmodule_function :foo\nend"
-
-    util_parser content
-
-    @parser.parse_statements @top_level
-
-    foo, s_foo = @top_level.modules.first.method_list
-    assert_equal 'foo',    foo.name,       'instance method name'
-    assert_equal :private, foo.visibility, 'instance method visibility'
-    assert_equal false,    foo.singleton,  'instance method singleton'
-
-    assert_equal 'foo',   s_foo.name,       'module function name'
-    assert_equal :public, s_foo.visibility, 'module function visibility'
-    assert_equal true,    s_foo.singleton,  'module function singleton'
-  end
-
-  def test_parse_statements_identifier_private
-    content = "class Foo\nprivate\ndef foo() end\nend"
-
-    util_parser content
-
-    @parser.parse_statements @top_level
-
-    foo = @top_level.classes.first.method_list.first
-    assert_equal 'foo', foo.name
-    assert_equal :private, foo.visibility
-  end
-
-  def test_parse_statements_identifier_public_class_method
-    content = <<-CONTENT
-class Date
-  def self.now; end
-  private_class_method :now
-end
-
-class DateTime < Date
-  public_class_method :now
-end
-    CONTENT
-
-    util_parser content
-
-    @parser.parse_statements @top_level
-
-    date, date_time = @top_level.classes.sort_by { |c| c.full_name }
-
-    date_now      = date.method_list.first
-    date_time_now = date_time.method_list.sort_by { |m| m.full_name }.first
-
-    assert_equal :private, date_now.visibility
-    assert_equal :public,  date_time_now.visibility
-  end
-
-  def test_parse_statements_identifier_private_class_method
-    content = <<-CONTENT
-class Date
-  def self.now; end
-  public_class_method :now
-end
-
-class DateTime < Date
-  private_class_method :now
-end
-    CONTENT
-
-    util_parser content
-
-    @parser.parse_statements @top_level
-
-    # TODO sort classes by default
-    date, date_time = @top_level.classes.sort_by { |c| c.full_name }
-
-    date_now      = date.method_list.first
-    date_time_now = date_time.method_list.sort_by { |m| m.full_name }.first
-
-    assert_equal :public,  date_now.visibility,      date_now.full_name
-    assert_equal :private, date_time_now.visibility, date_time_now.full_name
-  end
-
-  def test_parse_statements_complex_condition_in_for
-    util_parser <<RUBY
-class Foo
-  def blah()
-    for i in (k)...n do
-    end
-    for i in (k)...n
-    end
-  end
-end
-RUBY
-
-    expected = <<EXPECTED
-<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">blah</span>()
-  <span class="ruby-keyword">for</span> <span class="ruby-identifier">i</span> <span class="ruby-keyword">in</span> (<span class="ruby-identifier">k</span>)<span class="ruby-operator">...</span><span class="ruby-identifier">n</span> <span class="ruby-keyword">do</span>
-  <span class="ruby-keyword">end</span>
-  <span class="ruby-keyword">for</span> <span class="ruby-identifier">i</span> <span class="ruby-keyword">in</span> (<span class="ruby-identifier">k</span>)<span class="ruby-operator">...</span><span class="ruby-identifier">n</span>
-  <span class="ruby-keyword">end</span>
-<span class="ruby-keyword">end</span>
-EXPECTED
-    expected = expected.rstrip
-
-    @parser.scan
-
-    foo = @top_level.classes.first
-    assert_equal 'Foo', foo.full_name
-
-    blah = foo.method_list.first
-    markup_code = blah.markup_code.sub(/^.*\n/, '')
-    assert_equal expected, markup_code
-  end
-
-  def test_parse_instance_operation_method
-    util_parser <<-RUBY
-class Foo
-  def self.& end
-end
-    RUBY
-
-    expected = <<EXPECTED
-  <span class="ruby-keyword">def</span> <span class="ruby-keyword">self</span>.<span class="ruby-identifier ruby-title">&</span> <span class="ruby-keyword">end</span>
-<span class="ruby-keyword">end</span>
-EXPECTED
-    expected = expected.rstrip
-
-    @parser.scan
-
-    foo = @top_level.classes.first
-    assert_equal 'Foo', foo.full_name
-
-    blah = foo.method_list.first
-    markup_code = blah.markup_code.sub(/^.*\n/, '')
-    assert_equal expected, markup_code
-  end
-
-  def test_parse_statements_postfix_if_after_heredocbeg
-    @filename = 'file.rb'
-    util_parser <<RUBY
-class Foo
-  def blah()
-    <<-EOM if true
-    EOM
-  end
-end
-RUBY
-
-    expected = <<EXPECTED
-  <span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">blah</span>()
-    <span class="ruby-identifier"><<-EOM</span> <span class="ruby-keyword">if</span> <span class="ruby-keyword">true</span>
-<span class="ruby-value"></span><span class="ruby-identifier">    EOM</span>
-  <span class="ruby-keyword">end</span>
-EXPECTED
-    expected = expected.rstrip
-
-    @parser.scan
-
-    foo = @top_level.classes.first
-    assert_equal 'Foo', foo.full_name
-
-    blah = foo.method_list.first
-    markup_code = blah.markup_code.sub(/^.*\n/, '')
-    assert_equal expected, markup_code
-  end
-
-  def test_parse_mutable_heredocbeg
-    @filename = 'file.rb'
-    util_parser <<RUBY
-class Foo
-  def blah()
-    @str = -<<-EOM
-    EOM
-  end
-end
-RUBY
-
-    expected = <<EXPECTED
-  <span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">blah</span>()
-    <span class="ruby-ivar">@str</span> = <span class="ruby-identifier">-<<-EOM</span>
-<span class="ruby-value"></span><span class="ruby-identifier">    EOM</span>
-  <span class="ruby-keyword">end</span>
-EXPECTED
-    expected = expected.rstrip
-
-    @parser.scan
-
-    foo = @top_level.classes.first
-    assert_equal 'Foo', foo.full_name
-
-    blah = foo.method_list.first
-    markup_code = blah.markup_code.sub(/^.*\n/, '')
-    assert_equal expected, markup_code
-  end
-
-  def test_parse_heredoc_end
-    code = "A = <<eos\n""OK\n""eos\n"
-    util_parser code
-    @parser.parse_statements @top_level
-    @parser.scan
-    c = @top_level.classes.first.constants.first
-    assert_equal("A", c.name)
-
-    util_parser code.gsub(/$/, "\r")
-    @parser.parse_statements @top_level
-    @parser.scan
-    c = @top_level.classes.first.constants.first
-    assert_equal("A", c.name)
-  end
-
-  def test_parse_statements_method_oneliner_with_regexp
-    util_parser <<RUBY
-class Foo
-  def blah() /bar/ end
-end
-RUBY
-
-    expected = <<EXPECTED
-<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">blah</span>() <span class="ruby-regexp">/bar/</span> <span class="ruby-keyword">end</span>
-EXPECTED
-    expected = expected.rstrip
-
-    @parser.scan
-
-    foo = @top_level.classes.first
-    assert_equal 'Foo', foo.full_name
-
-    blah = foo.method_list.first
-    markup_code = blah.markup_code.sub(/^.*\n/, '')
-    assert_equal expected, markup_code
-  end
-
-  def test_parse_statements_embdoc_in_document
-    @filename = 'file.rb'
-    util_parser <<RUBY
-class Foo
-  # doc
-  #
-  #   =begin
-  #   test embdoc
-  #   =end
-  #
-  def blah
-  end
-end
-RUBY
-
-    expected = <<EXPECTED
-<p>doc
-
-<pre class="ruby"><span class="ruby-comment">=begin
-test embdoc
-=end</span>
-</pre>
-EXPECTED
-
-    @parser.scan
-
-    foo = @top_level.classes.first
-    assert_equal 'Foo', foo.full_name
-
-    blah = foo.method_list.first
-    markup_comment = blah.search_record[6]
-    assert_equal expected, markup_comment
-  end
-
-  def test_parse_require_dynamic_string
-    content = <<-RUBY
-prefix = 'path'
-require "\#{prefix}/a_library"
-require 'test'
-RUBY
-
-    util_parser content
-
-    @parser.parse_statements @top_level
-
-    assert_equal 1, @top_level.requires.length
-  end
-
-  def test_parse_postfix_nodoc
-    util_parser <<-RUBY
-class A
-end # :nodoc:
-
-class B
-  def a
-  end # :nodoc:
-
-  def b
-  end
-end
-RUBY
-
-    @parser.parse_statements @top_level
-
-    c_a = @top_level.classes.select(&:document_self).first
-    assert_equal 'B', c_a.full_name
-
-    assert_equal 2, @top_level.classes.length
-    assert_equal 1, @top_level.classes.count(&:document_self)
-    assert_equal 1, c_a.method_list.length
-    assert_equal 'B#b', c_a.method_list.first.full_name
-  end
-
-  def test_parse_statements_identifier_require
-    content = "require 'bar'"
-
-    util_parser content
-
-    @parser.parse_statements @top_level
-
-    assert_equal 1, @top_level.requires.length
-  end
-
-  def test_parse_statements_identifier_yields
-    comment = "##\n# :yields: x\n# :method: b\n# my method\n"
-
-    util_parser "module M\n#{comment}def_delegator :a, :b, :b\nend"
-
-    @parser.parse_statements @top_level, RDoc::Parser::Ruby::NORMAL
-
-    m = @top_level.modules.first
-    assert_equal 'M', m.full_name
-
-    b = m.method_list.first
-    assert_equal 'M#b', b.full_name
-    assert_equal 'x', b.block_params
-    assert_equal 'my method', b.comment.text
-
-    assert_nil m.params, 'Module parameter not removed'
-  end
-
-  def test_parse_statements_nodoc_identifier_alias
-    klass = @top_level.add_class RDoc::NormalClass, 'Foo'
-
-    util_parser "\nalias :old :new # :nodoc:"
-
-    @parser.parse_statements klass, RDoc::Parser::Ruby::NORMAL, nil
-
-    assert_empty klass.aliases
-    assert_empty klass.unmatched_alias_lists
-  end
-
-  def test_parse_statements_nodoc_identifier_alias_method
-    klass = @top_level.add_class RDoc::NormalClass, 'Foo'
-
-    util_parser "\nalias_method :old :new # :nodoc:"
-
-    @parser.parse_statements klass, RDoc::Parser::Ruby::NORMAL, nil
-
-    assert_empty klass.aliases
-    assert_empty klass.unmatched_alias_lists
-  end
-
-  def test_parse_statements_stopdoc_alias
-    klass = @top_level.add_class RDoc::NormalClass, 'Foo'
-
-    util_parser "\n# :stopdoc:\nalias old new"
-
-    @parser.parse_statements klass, RDoc::Parser::Ruby::NORMAL, nil
-
-    assert_empty klass.aliases
-    assert_empty klass.unmatched_alias_lists
-  end
-
-  def test_parse_statements_stopdoc_identifier_alias_method
-    klass = @top_level.add_class RDoc::NormalClass, 'Foo'
-
-    util_parser "\n# :stopdoc:\nalias_method :old :new"
-
-    @parser.parse_statements klass, RDoc::Parser::Ruby::NORMAL, nil
-
-    assert_empty klass.aliases
-    assert_empty klass.unmatched_alias_lists
-  end
-
-  def test_parse_statements_stopdoc_identifier_metaprogrammed
-    klass = @top_level.add_class RDoc::NormalClass, 'Foo'
-
-    util_parser "\n# :stopdoc:\n# attr :meta"
-
-    @parser.parse_statements klass, RDoc::Parser::Ruby::NORMAL, nil
-
-    assert_empty klass.method_list
-    assert_empty klass.attributes
-  end
-
-  def test_parse_statements_stopdoc_constant
-    klass = @top_level.add_class RDoc::NormalClass, 'Foo'
-
-    util_parser "\n# :stopdoc:\nA = v"
-
-    @parser.parse_statements klass, RDoc::Parser::Ruby::NORMAL, nil
-
-    assert_empty klass.constants
-  end
-
-  def test_parse_statements_stopdoc_def
-    klass = @top_level.add_class RDoc::NormalClass, 'Foo'
-
-    util_parser "\n# :stopdoc:\ndef m\n end"
-
-    @parser.parse_statements klass, RDoc::Parser::Ruby::NORMAL, nil
-
-    assert_empty klass.method_list
-  end
-
-  def test_parse_statements_super
-    m = RDoc::AnyMethod.new '', 'm'
-    util_parser 'super'
-
-    @parser.parse_statements @top_level, RDoc::Parser::Ruby::NORMAL, m
-
-    assert m.calls_super
-  end
-
-  def test_parse_statements_super_no_method
-    content = "super"
-
-    util_parser content
-
-    @parser.parse_statements @top_level
-
-    assert_nil @parser.get_tk
-  end
-
-  def test_parse_statements_while_begin
-    util_parser <<-RUBY
-class A
-  def a
-    while begin a; b end
-    end
-  end
-
-  def b
-  end
-end
-    RUBY
-
-    @parser.parse_statements @top_level
-
-    c_a = @top_level.classes.first
-    assert_equal 'A', c_a.full_name
-
-    assert_equal 1, @top_level.classes.length
-
-    m_a = c_a.method_list.first
-    m_b = c_a.method_list.last
-
-    assert_equal 'A#a', m_a.full_name
-    assert_equal 'A#b', m_b.full_name
-  end
-
-
-  def test_parse_symbol_in_paren_arg
-    util_parser <<RUBY
-class Foo
-  def blah
-  end
-  private(:blah)
-end
-RUBY
-
-    @parser.scan
-
-    foo = @top_level.classes.first
-    assert_equal 'Foo', foo.full_name
-
-    blah = foo.method_list.first
-    assert_equal :private, blah.visibility
-  end
-
-  def test_parse_symbol_in_arg
-    util_parser '[:blah, "blah", "#{blah}", blah]'
-    @parser.get_tk # skip '['
-
-    assert_equal 'blah', @parser.parse_symbol_in_arg
-    @parser.get_tk # skip ','
-
-    @parser.skip_tkspace
-
-    assert_equal 'blah', @parser.parse_symbol_in_arg
-    @parser.get_tk # skip ','
-
-    @parser.skip_tkspace
-
-    assert_nil @parser.parse_symbol_in_arg
-    @parser.get_tk # skip ','
-
-    @parser.skip_tkspace
-
-    assert_nil @parser.parse_symbol_in_arg
-  end
-
-  def test_parse_percent_symbol
-    content = '%s[foo bar]'
-    util_parser content
-    tk = @parser.get_tk
-    assert_equal :on_symbol, tk[:kind]
-    assert_equal content, tk[:text]
-  end
-
-  def test_parse_statements_alias_method
-    content = <<-CONTENT
-class A
-  alias_method :a, :[] unless c
-end
-
-B = A
-
-class C
-end
-    CONTENT
-
-    util_parser content
-
-    @parser.parse_statements @top_level
-
-    # HACK where are the assertions?
-  end
-
-  def test_parse_top_level_statements_enddoc
-    util_parser <<-CONTENT
-# :enddoc:
-    CONTENT
-
-    assert_throws :eof do
-      @parser.parse_top_level_statements @top_level
-    end
-  end
-
-  def test_parse_top_level_statements_stopdoc
-    @top_level.stop_doc
-    content = "# this is the top-level comment"
-
-    util_parser content
-
-    @parser.parse_top_level_statements @top_level
-
-    assert_empty @top_level.comment
-  end
-
-  def test_parse_top_level_statements_stopdoc_integration
-    content = <<-CONTENT
-# :stopdoc:
-
-class Example
-  def method_name
-  end
-end
-    CONTENT
-
-    util_parser content
-
-    @parser.parse_top_level_statements @top_level
-
-    assert_equal 1, @top_level.classes.length
-    assert_empty @top_level.modules
-
-    assert @top_level.find_module_named('Example').ignored?
-  end
-
-  # This tests parse_comment
-  def test_parse_top_level_statements_constant_nodoc_integration
-    content = <<-CONTENT
-class A
-  C = A # :nodoc:
-end
-    CONTENT
-
-    util_parser content
-
-    @parser.parse_top_level_statements @top_level
-
-    klass = @top_level.find_module_named('A')
-
-    c = klass.constants.first
-
-    assert_nil c.document_self, 'C should not be documented'
-  end
-
-  def test_parse_yield_in_braces_with_parens
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
-
-    util_parser "def foo\nn.times { |i| yield nth(i) }\nend"
-
-    tk = @parser.get_tk
-
-    @parser.parse_method klass, RDoc::Parser::Ruby::NORMAL, tk, @comment
-
-    foo = klass.method_list.first
-    assert_equal 'nth(i)', foo.block_params
-  end
-
-  def test_read_directive
-    parser = util_parser '# :category: test'
-
-    directive, value = parser.read_directive %w[category]
-
-    assert_equal 'category', directive
-    assert_equal 'test', value
-
-    assert_nil parser.get_tk
-  end
-
-  def test_read_directive_allow
-    parser = util_parser '# :category: test'
-
-    directive = parser.read_directive []
-
-    assert_nil directive
-
-    assert_nil parser.get_tk
-  end
-
-  def test_read_directive_empty
-    parser = util_parser '# test'
-
-    directive = parser.read_directive %w[category]
-
-    assert_nil directive
-
-    assert_nil parser.get_tk
-  end
-
-  def test_read_directive_no_comment
-    parser = util_parser ''
-
-    directive = parser.read_directive %w[category]
-
-    assert_nil directive
-
-    assert_nil parser.get_tk
-  end
-
-  def test_read_directive_one_liner
-    parser = util_parser 'AAA = 1 # :category: test'
-
-    directive, value = parser.read_directive %w[category]
-
-    assert_equal 'category', directive
-    assert_equal 'test', value
-
-    assert_equal :on_const, parser.get_tk[:kind]
-  end
-
-  def test_read_directive_linear_performance
-    omit "JRuby intermittently times out" if RUBY_ENGINE == 'jruby'
-    pre = ->(i) {util_parser '# ' + '0'*i + '=000:'}
-    assert_linear_performance((1..5).map{|i|10**i}, pre: pre) do |parser|
-      assert_nil parser.read_directive []
-    end
-  end
-
-  def test_read_documentation_modifiers
-    c = RDoc::Context.new
-
-    parser = util_parser '# :category: test'
-
-    parser.read_documentation_modifiers c, %w[category]
-
-    assert_equal 'test', c.current_section.title
-  end
-
-  def test_read_documentation_modifiers_notnew
-    m = RDoc::AnyMethod.new nil, 'initialize'
-
-    parser = util_parser '# :notnew: test'
-
-    parser.read_documentation_modifiers m, %w[notnew]
-
-    assert m.dont_rename_initialize
-  end
-
-  def test_read_documentation_modifiers_not_dash_new
-    m = RDoc::AnyMethod.new nil, 'initialize'
-
-    parser = util_parser '# :not-new: test'
-
-    parser.read_documentation_modifiers m, %w[not-new]
-
-    assert m.dont_rename_initialize
-  end
-
-  def test_read_documentation_modifiers_not_new
-    m = RDoc::AnyMethod.new nil, 'initialize'
-
-    parser = util_parser '# :not_new: test'
-
-    parser.read_documentation_modifiers m, %w[not_new]
-
-    assert m.dont_rename_initialize
-  end
-
-  def test_sanity_integer
-    util_parser '1'
-    assert_equal '1', @parser.get_tk[:text]
-
-    util_parser '1.0'
-    assert_equal '1.0', @parser.get_tk[:text]
-  end
-
-  def test_sanity_interpolation
-    last_tk = nil
-    util_parser 'class A; B = "#{c}"; end'
-
-    while tk = @parser.get_tk do last_tk = tk end
-
-    assert_equal 'end', last_tk[:text]
-  end
-
-  # If you're writing code like this you're doing it wrong
-
-  def test_sanity_interpolation_crazy
-    util_parser '"#{"#{"a")}" if b}"'
-
-    assert_equal '"#{"#{"a")}" if b}"', @parser.get_tk[:text]
-    assert_nil @parser.get_tk
-  end
-
-  def test_sanity_interpolation_curly
-    util_parser '%{ #{} }'
-
-    assert_equal '%{ #{} }', @parser.get_tk[:text]
-    assert_nil @parser.get_tk
-  end
-
-  def test_sanity_interpolation_format
-    util_parser '"#{stftime("%m-%d")}"'
-
-    while @parser.get_tk do end
-  end
-
-  def test_sanity_symbol_interpolation
-    util_parser ':"#{bar}="'
-
-    while @parser.get_tk do end
-  end
-
-  def test_scan_cr
-    content = <<-CONTENT
-class C\r
-  def m\r
-    a=\\\r
-      123\r
-  end\r
-end\r
-    CONTENT
-
-    util_parser content
-
-    @parser.scan
-
-    c = @top_level.classes.first
-
-    assert_equal 1, c.method_list.length
-  end
-
-  def test_scan_block_comment
-    content = <<-CONTENT
-=begin rdoc
-Foo comment
-=end
-
-class Foo
-
-=begin
-m comment
-=end
-
-  def m() end
-end
-    CONTENT
-
-    util_parser content
-
-    @parser.scan
-
-    foo = @top_level.classes.first
-
-    assert_equal 'Foo comment', foo.comment.text
-
-    m = foo.method_list.first
-
-    assert_equal 'm comment', m.comment.text
-  end
-
-  def test_scan_block_comment_nested # Issue #41
-    content = <<-CONTENT
-require 'something'
-=begin rdoc
-findmeindoc
-=end
-module Foo
-    class Bar
-    end
-end
-    CONTENT
-
-    util_parser content
-
-    @parser.scan
-
-    foo = @top_level.modules.first
-
-    assert_equal 'Foo', foo.full_name
-    assert_equal 'findmeindoc', foo.comment.text
-
-    bar = foo.classes.first
-
-    assert_equal 'Foo::Bar', bar.full_name
-    assert_equal '', bar.comment.text
-  end
-
-  def test_scan_block_comment_notflush
-  ##
-  #
-  # The previous test assumes that between the =begin/=end blocks that there
-  # is only one line, or minima formatting directives. This test tests for
-  # those who use the =begin block with longer / more advanced formatting
-  # within.
-  #
-  ##
-    content = <<-CONTENT
-=begin rdoc
-
-= DESCRIPTION
-
-This is a simple test class
-
-= RUMPUS
-
-Is a silly word
-
-=end
-class StevenSimpleClass
-  # A band on my iPhone as I wrote this test
-  FRUIT_BATS="Make nice music"
-
-=begin rdoc
-A nice girl
-=end
-
-  def lauren
-    puts "Summoning Lauren!"
-  end
-end
-    CONTENT
-    util_parser content
-
-    @parser.scan
-
-    foo = @top_level.classes.first
-
-    assert_equal "= DESCRIPTION\n\nThis is a simple test class\n\n= RUMPUS\n\nIs a silly word",
-      foo.comment.text
-
-    m = foo.method_list.first
-
-    assert_equal 'A nice girl', m.comment.text
-  end
-
-  def test_scan_class_nested_nodoc
-    content = <<-CONTENT
-class A::B # :nodoc:
-end
-    CONTENT
-
-    util_parser content
-
-    @parser.scan
-
-    visible = @store.all_classes_and_modules.select { |mod| mod.display? }
-
-    assert_empty visible.map { |mod| mod.full_name }
-  end
-
-  def test_scan_constant_in_method
-    content = <<-CONTENT # newline is after M is important
-module M
-  def m
-    A
-    B::C
-  end
-end
-    CONTENT
-
-    util_parser content
-
-    @parser.scan
-
-    m = @top_level.modules.first
-
-    assert_empty m.constants
-
-    assert_empty @store.classes_hash.keys
-    assert_equal %w[M], @store.modules_hash.keys
-  end
-
-  def test_scan_constant_in_rescue
-    content = <<-CONTENT # newline is after M is important
-module M
-  def m
-  rescue A::B
-  rescue A::C => e
-  rescue A::D, A::E
-  rescue A::F,
-         A::G
-  rescue H
-  rescue I => e
-  rescue J, K
-  rescue L =>
-    e
-  rescue M;
-  rescue N,
-         O => e
-  end
-end
-    CONTENT
-
-    util_parser content
-
-    @parser.scan
-
-    m = @top_level.modules.first
-
-    assert_empty m.constants
-
-    assert_empty @store.classes_hash.keys
-    assert_equal %w[M], @store.modules_hash.keys
-  end
-
-  def test_scan_constant_nodoc
-    content = <<-CONTENT # newline is after M is important
-module M
-
-  C = v # :nodoc:
-end
-    CONTENT
-
-    util_parser content
-
-    @parser.scan
-
-    c = @top_level.modules.first.constants.first
-
-    assert c.documented?
-  end
-
-  def test_scan_constant_nodoc_block
-    content = <<-CONTENT # newline is after M is important
-module M
-
-  C = v do # :nodoc:
-  end
-end
-    CONTENT
-
-    util_parser content
-
-    @parser.scan
-
-    c = @top_level.modules.first.constants.first
-
-    assert c.documented?
-  end
-
-  def test_scan_duplicate_module
-    content = <<-CONTENT
-# comment a
-module Foo
-end
-
-# comment b
-module Foo
-end
-    CONTENT
-
-    util_parser content
-
-    @parser.scan
-
-    foo = @top_level.modules.first
-
-    expected = [
-      RDoc::Comment.new('comment a', @top_level),
-      RDoc::Comment.new('comment b', @top_level)
-    ]
-
-    assert_equal expected, foo.comment_location.map { |c, l| c }
-  end
-
-  def test_scan_meta_method_block
-    content = <<-CONTENT
-class C
-
-  ##
-  #  my method
-
-  inline(:my_method) do |*args|
-    "this method used to cause z to disappear"
-  end
-
-  def z
-  end
-    CONTENT
-
-    util_parser content
-
-    @parser.scan
-
-    assert_equal 2, @top_level.classes.first.method_list.length
-  end
-
-  def test_scan_method_semi_method
-    content = <<-CONTENT
-class A
-  def self.m() end; def self.m=() end
-end
-
-class B
-  def self.m() end
-end
-    CONTENT
-
-    util_parser content
-
-    @parser.scan
-
-    a = @store.find_class_named 'A'
-    assert a, 'missing A'
-
-    assert_equal 2, a.method_list.length
-
-    b = @store.find_class_named 'B'
-    assert b, 'missing B'
-
-    assert_equal 1, b.method_list.length
-  end
-
-  def test_scan_markup_override
-    content = <<-CONTENT
-# *awesome*
-class C
-  # :markup: rd
-  # ((*radical*))
-  def m
-  end
-end
-    CONTENT
-
-    util_parser content
-
-    @parser.scan
-
-    c = @top_level.classes.first
-
-    assert_equal 'rdoc', c.comment.format
-
-    assert_equal 'rd', c.method_list.first.comment.format
-  end
-
-  def test_scan_markup_first_comment
-    content = <<-CONTENT
-# :markup: rd
-
-# ((*awesome*))
-class C
-  # ((*radical*))
-  def m
-  end
-end
-    CONTENT
-
-    util_parser content
-
-    @parser.scan
-
-    c = @top_level.classes.first
-
-    assert_equal 'rd', c.comment.format
-
-    assert_equal 'rd', c.method_list.first.comment.format
-  end
-
-  def test_scan_rails_routes
-    util_parser <<-ROUTES_RB
-namespace :api do
-  scope module: :v1 do
-  end
-end
-    ROUTES_RB
-
-    @parser.scan
-
-    assert_empty @top_level.classes
-    assert_empty @top_level.modules
-  end
-
-  def test_scan_tomdoc_meta
-    util_parser <<-RUBY
-# :markup: tomdoc
-
-class C
-
-  # Signature
-  #
-  #   find_by_<field>[_and_<field>...](args)
-  #
-  # field - A field name.
-
-end
-
-    RUBY
-
-    @parser.scan
-
-    c = @top_level.classes.first
-
-    m = c.method_list.first
-
-    assert_equal "find_by_<field>[_and_<field>...]", m.name
-    assert_equal "find_by_<field>[_and_<field>...](args)\n", m.call_seq
-
-    expected =
-      doc(
-        head(3, 'Signature'),
-        list(:NOTE,
-          item(%w[field],
-            para('A field name.'))))
-    expected.file = @top_level
-
-    assert_equal expected, m.comment.parse
-  end
-
-  def test_scan_stopdoc
-    util_parser <<-RUBY
-class C
-  # :stopdoc:
-  class Hidden
-  end
-end
-    RUBY
-
-    @parser.scan
-
-    c = @top_level.classes.first
-
-    hidden = c.classes.first
-
-    refute hidden.document_self
-    assert hidden.ignored?
-  end
-
-  def test_scan_stopdoc_class_alias
-    util_parser <<-RUBY
-# :stopdoc:
-module A
-  B = C
-end
-    RUBY
-
-    @parser.scan
-
-    assert_empty @store.all_classes
-
-    assert_equal 1, @store.all_modules.length
-    m = @store.all_modules.first
-
-    assert m.ignored?
-  end
-
-  def test_scan_stopdoc_nested
-    util_parser <<-RUBY
-# :stopdoc:
-class A::B
-end
-    RUBY
-
-    @parser.scan
-
-    a   = @store.modules_hash['A']
-    a_b = @store.classes_hash['A::B']
-
-    refute a.document_self, 'A is inside stopdoc'
-    assert a.ignored?,      'A is inside stopdoc'
-
-    refute a_b.document_self, 'A::B is inside stopdoc'
-    assert a_b.ignored?,      'A::B is inside stopdoc'
-  end
-
-  def test_scan_struct_self_brackets
-    util_parser <<-RUBY
-class C < M.m
-  def self.[]
-  end
-end
-    RUBY
-
-    @parser.scan
-
-    c = @store.find_class_named 'C'
-    assert_equal %w[C::[]], c.method_list.map { |m| m.full_name }
-  end
-
-  def test_scan_visibility
-    util_parser <<-RUBY
-class C
-   def a() end
-
-   private :a
-
-   class << self
-     def b() end
-     private :b
-   end
-end
-    RUBY
-
-    @parser.scan
-
-    c = @store.find_class_named 'C'
-
-    c_a = c.find_method_named 'a'
-
-    assert_equal :private, c_a.visibility
-    refute c_a.singleton
-
-    c_b = c.find_method_named 'b'
-
-    assert_equal :private, c_b.visibility
-    assert c_b.singleton
-  end
-
-  def test_scan_visibility_count
-    util_parser <<-RUBY
-class C < Original::Base
-  class C2 < Original::Base
-    def m0() end
-    def m1() end
-
-    private
-
-    def m2() end
-    def m3() end
-    def m4() end
-  end
-end
-    RUBY
-
-    @parser.scan
-
-    c = @store.find_class_named 'C::C2'
-
-    private_method_count = c.method_list.count { |m| :private == m.visibility }
-    assert_equal 3, private_method_count
-
-    public_method_count = c.method_list.count { |m| :public == m.visibility }
-    assert_equal 2, public_method_count
-  end
-
-  def test_scan_constant_visibility
-    util_parser <<-RUBY
-class C
-   CONST_A = 123
-
-   CONST_B = 234
-   private_constant :CONST_B
-
-   CONST_C = 345
-   public_constant :CONST_C
-end
-    RUBY
-
-    @parser.scan
-
-    c = @store.find_class_named 'C'
-    const_a, const_b, const_c = c.constants.sort_by(&:name)
-
-    assert_equal 'CONST_A', const_a.name
-    assert_equal :public, const_a.visibility
-
-    assert_equal 'CONST_B', const_b.name
-    assert_equal :private, const_b.visibility
-
-    assert_equal 'CONST_C', const_c.name
-    assert_equal :public, const_c.visibility
-  end
-
-  def test_document_after_rescue_inside_paren
-    util_parser <<-RUBY
-class C
-  attr_accessor :sample if (1.inexistent_method rescue false)
-  # first
-  # second
-  def a
-  end
-end
-    RUBY
-
-    @parser.scan
-
-    c = @store.find_class_named 'C'
-
-    c_a = c.find_method_named 'a'
-    assert_equal "first\nsecond", c_a.comment.text
-  end
-
-  def test_singleton_method_via_eigenclass
-    util_parser <<-RUBY
-class C
-   class << self
-     def a() end
-   end
-end
-    RUBY
-
-    @parser.scan
-
-    c   = @store.find_class_named 'C'
-    c_a = c.find_method_named 'a'
-
-    assert_equal :public, c_a.visibility
-    assert c_a.singleton
-  end
-
-  def test_stopdoc_after_comment
-    util_parser <<-EOS
-      module Bar
-        # hello
-        module Foo
-          # :stopdoc:
-        end
-        # there
-        class Baz
-          # :stopdoc:
-        end
-      end
-    EOS
-
-    @parser.parse_statements @top_level
-
-    foo = @top_level.modules.first.modules.first
-    assert_equal 'Foo', foo.name
-    assert_equal 'hello', foo.comment.text
-
-    baz = @top_level.modules.first.classes.first
-    assert_equal 'Baz', baz.name
-    assert_equal 'there', baz.comment.text
-  end
-
-  def util_parser(content)
-    @parser = RDoc::Parser::Ruby.new @top_level, content, @options, @stats
-  end
-
-  def util_two_parsers(first_file_content, second_file_content)
-    util_parser first_file_content
-
-    @parser2 = RDoc::Parser::Ruby.new @top_level2, @filename,
-                                      second_file_content, @options, @stats
-  end
-
-  def test_parse_const_third_party
-    util_parser <<-CLASS
-class A
-  true if B
-  true if B::C
-  true if B::C::D
-
-  module B
-  end
-end
-    CLASS
-
-    tk = @parser.get_tk
-
-    @parser.parse_class @top_level, RDoc::Parser::Ruby::NORMAL, tk, @comment
-
-    a = @top_level.classes.first
-    assert_equal 'A', a.full_name
-
-    visible = @store.all_modules.reject { |mod| mod.suppressed? }
-    visible = visible.map { |mod| mod.full_name }
-
-    assert_equal ['A::B'], visible
-  end
-
-  def test_parse_const_alias_defined_elsewhere
-    util_parser <<-CLASS
-module A
-  Aliased = Defined
-end
-
-module A
-  class Defined
-  end
-end
-    CLASS
-
-    @parser.scan
-
-    a = @top_level.modules.first
-    assert_equal 'A', a.full_name
-    aliased = a.constants.first
-    assert_equal 'A::Aliased', aliased.full_name
-    assert_equal [], a.modules.map(&:full_name)
-    assert_equal ['A::Defined', 'A::Aliased'], a.classes.map(&:full_name)
-    assert_equal ['A::Aliased'], a.constants.map(&:full_name)
-
-    visible = @store.all_modules.reject { |mod| mod.suppressed? }
-    visible = visible.map { |mod| mod.full_name }
-
-    assert_equal ['A'], visible
-  end
-
-  def test_parse_const_alias_defined_far_away
-    util_parser <<-CLASS
-module A
-  Aliased = ::B::C::Defined
-end
-
-module B
-  module C
-    class Defined
-    end
-  end
-end
-    CLASS
-
-    @parser.scan
-
-    a = @top_level.modules.first
-    assert_equal 'A', a.full_name
-    assert_empty a.classes
-    assert_empty a.modules
-    assert_equal ['A::Aliased'], a.constants.map(&:full_name)
-
-    defined = @store.find_class_named 'B::C::Defined'
-    assert_equal 'B::C::Defined', defined.full_name
-
-    aliased = @store.find_class_named 'B::C::Aliased'
-    assert_equal 'B::C::Aliased', aliased.full_name
-
-    visible = @store.all_modules.reject { |mod| mod.suppressed? }
-    visible = visible.map { |mod| mod.full_name }
-
-    assert_equal ['A', 'B', 'B::C'], visible
-  end
-
-  def test_parse_include_by_dynamic_definition
-    util_parser <<-CLASS
-module A
-  class B
-    include(Module.new do
-      def e(m)
-      end
-    end)
-  end
-
-  class C
-  end
-
-  class D
-  end
-end
-    CLASS
-
-    @parser.scan
-
-    a = @store.find_module_named 'A'
-    assert_equal 'A', a.full_name
-    a_b = a.find_class_named 'B'
-    assert_equal 'A::B', a_b.full_name
-    a_c = a.find_class_named 'C'
-    assert_equal 'A::C', a_c.full_name
-    a_d = a.find_class_named 'D'
-    assert_equal 'A::D', a_d.full_name
-  end
-
-  def test_parse_include_by_dynamic_definition_without_paren
-    util_parser <<-CLASS
-module A
-  class B
-    include(Module.new do
-      def e m
-      end
-    end)
-  end
-
-  class C
-  end
-
-  class D
-  end
-end
-    CLASS
-
-    @parser.scan
-
-    a = @store.find_module_named 'A'
-    assert_equal 'A', a.full_name
-    a_b = a.find_class_named 'B'
-    assert_equal 'A::B', a_b.full_name
-    a_c = a.find_class_named 'C'
-    assert_equal 'A::C', a_c.full_name
-    a_d = a.find_class_named 'D'
-    assert_equal 'A::D', a_d.full_name
-  end
-
-  def test_parse_include_by_dynamic_definition_via_variable
-    util_parser <<-CLASS
-module A
-  class B
-    m = Module.new do
-      def e(m)
-      end
-    end
-    include m
-  end
-
-  class C
-  end
-
-  class D
-  end
-end
-    CLASS
-
-    @parser.scan
-
-    a = @store.find_module_named 'A'
-    assert_equal 'A', a.full_name
-    a_b = a.find_class_named 'B'
-    assert_equal 'A::B', a_b.full_name
-    a_c = a.find_class_named 'C'
-    assert_equal 'A::C', a_c.full_name
-    a_d = a.find_class_named 'D'
-    assert_equal 'A::D', a_d.full_name
-  end
-
-  def test_parse_include_by_dynamic_definition_with_brace
-    util_parser <<-CLASS
-module A
-  class B
-    extend(e {
-      def f(g)
-      end
-    })
-  end
-
-  class C
-  end
-
-  class D
-  end
-end
-    CLASS
-
-    @parser.scan
-
-    a = @store.find_module_named 'A'
-    assert_equal 'A', a.full_name
-    a_b = a.find_class_named 'B'
-    assert_equal 'A::B', a_b.full_name
-    a_c = a.find_class_named 'C'
-    assert_equal 'A::C', a_c.full_name
-    a_d = a.find_class_named 'D'
-    assert_equal 'A::D', a_d.full_name
-  end
-
-  def test_parse_include_by_dynamic_definition_directly
-    util_parser <<-CLASS
-module A
-  class B
-    include Module.new do
-      def e m
-      end
-    end
-  end
-
-  class C
-  end
-
-  class D
-  end
-end
-    CLASS
-
-    @parser.scan
-
-    a = @store.find_module_named 'A'
-    assert_equal 'A', a.full_name
-    a_b = a.find_class_named 'B'
-    assert_equal 'A::B', a_b.full_name
-    a_c = a.find_class_named 'C'
-    assert_equal 'A::C', a_c.full_name
-    a_d = a.find_class_named 'D'
-    assert_equal 'A::D', a_d.full_name
-  end
-
-  def test_parse_included
-    util_parser <<-CLASS
-module A
-  module B
-    extend ActiveSupport::Concern
-    included do
-      ##
-      # :singleton-method:
-      # Hello
-      mattr_accessor :foo
-    end
-  end
-end
-    CLASS
-
-    @parser.scan
-
-    a = @store.find_module_named 'A'
-    assert_equal 'A', a.full_name
-    a_b = a.find_module_named 'B'
-    assert_equal 'A::B', a_b.full_name
-    meth = a_b.method_list.first
-    assert_equal 'foo', meth.name
-    assert_equal 'Hello', meth.comment.text
-  end
-
-  def test_end_that_doesnt_belong_to_class_doesnt_change_visibility
-    util_parser <<-CLASS
-class A
-  private
-
-  begin
-  end
-
-  # Hello
-  def foo() end
-end
-    CLASS
-
-    @parser.scan
-
-    a = @store.find_class_named 'A'
-    assert_equal 'A', a.full_name
-    assert_equal 'foo', a.find_method_named('foo').name
-    meth = a.method_list.first
-    assert_equal 'Hello', meth.comment.text
-  end
-
-  def test_parenthesized_cdecl
-    util_parser <<-RUBY
-module DidYouMean
-  class << (NameErrorCheckers = Object.new)
-  end
-end
-    RUBY
-
-    @parser.scan
-
-    refute_predicate @store.find_class_or_module('DidYouMean'), :nil?
-    refute_predicate @store.find_class_or_module('DidYouMean::NameErrorCheckers'), :nil?
-  end
-end
diff --git a/test/mri/rdoc/rdoc_parser_simple_test.rb b/test/mri/rdoc/rdoc_parser_simple_test.rb
deleted file mode 100644
index 7296a40064f..00000000000
--- a/test/mri/rdoc/rdoc_parser_simple_test.rb
+++ /dev/null
@@ -1,115 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocParserSimpleTest < RDoc::TestCase
-
-  def setup
-    super
-
-    @tempfile = Tempfile.new self.class.name
-    filename = @tempfile.path
-
-    @top_level = @store.add_file filename
-    @fn = filename
-    @options = RDoc::Options.new
-    @stats = RDoc::Stats.new @store, 0
-  end
-
-  def teardown
-    super
-
-    @tempfile.close!
-  end
-
-  def test_initialize_metadata
-    parser = util_parser ":unhandled: \n"
-
-    assert_includes @top_level.metadata, 'unhandled'
-
-    assert_equal ":unhandled: \n", parser.content
-  end
-
-  def test_remove_coding_comment
-    parser = util_parser <<-TEXT
-# -*- mode: rdoc; coding: utf-8; fill-column: 74; -*-
-
-Regular expressions (<i>regexp</i>s) are patterns which describe the
-contents of a string.
-    TEXT
-
-    parser.scan
-
-    expected = <<-TEXT.strip
-Regular expressions (<i>regexp</i>s) are patterns which describe the
-contents of a string.
-    TEXT
-
-    assert_equal expected, @top_level.comment.text
-  end
-
-  # RDoc stops processing comments if it finds a comment line CONTAINING
-  # '<tt>#--</tt>'. This can be used to separate external from internal
-  # comments, or to stop a comment being associated with a method,
-  # class, or module. Commenting CAN be turned back on with
-  # a line that STARTS '<tt>#++</tt>'.
-  #
-  # I've seen guys that comment their code like this:
-  #   # This method....
-  #   #-----------------
-  #   def method
-  #
-  # => either we do it only in ruby code, or we require the leading #
-  #    (to avoid conflict with rules).
-  #
-  #   TODO: require the leading #, to provide the feature in simple text files.
-  #   Note: in ruby & C code, we require '#--' & '#++' or '*--' & '*++',
-  #   to allow rules:
-  #
-  #   # this is a comment
-  #   #---
-  #   # private text
-  #   #+++
-  #   # this is a rule:
-  #   # ---
-
-  def test_remove_private_comments
-    parser = util_parser "foo\n\n--\nbar\n++\n\nbaz\n"
-
-    parser.scan
-
-    expected = "foo\n\n\nbaz"
-
-    assert_equal expected, @top_level.comment.text
-  end
-
-  def test_remove_private_comments_rule
-    parser = util_parser "foo\n---\nbar"
-
-    parser.scan
-
-    expected = "foo\n---\nbar"
-
-    assert_equal expected, @top_level.comment.text
-  end
-
-  def test_remove_private_comments_star
-    parser = util_parser "* foo\n* bar\n"
-
-    parser.scan
-
-    assert_equal "* foo\n* bar", @top_level.comment.text
-  end
-
-  def test_scan
-    parser = util_parser 'it *really* works'
-
-    parser.scan
-
-    assert_equal 'it *really* works', @top_level.comment.text
-  end
-
-  def util_parser(content)
-    RDoc::Parser::Simple.new @top_level, content, @options, @stats
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc_parser_test.rb b/test/mri/rdoc/rdoc_parser_test.rb
deleted file mode 100644
index 7b890f703d2..00000000000
--- a/test/mri/rdoc/rdoc_parser_test.rb
+++ /dev/null
@@ -1,334 +0,0 @@
-# -*- coding: us-ascii -*-
-# frozen_string_literal: true
-
-require_relative 'helper'
-
-class RDocParserTest < RDoc::TestCase
-  def setup
-    super
-
-    @RP = RDoc::Parser
-    @binary_dat_fixture_path = File.expand_path '../binary.dat', __FILE__
-    @options = RDoc::Options.new
-  end
-
-  def test_class_binary_eh_ISO_2022_JP
-    iso_2022_jp = File.join Dir.tmpdir, "test_rdoc_parser_#{$$}.rd"
-
-    File.open iso_2022_jp, 'wb' do |io|
-      io.write "# coding: ISO-2022-JP\n"
-      io.write ":\e$B%3%^%s%I\e(B:\n"
-    end
-
-    refute @RP.binary? iso_2022_jp
-  ensure
-    File.unlink iso_2022_jp
-  end
-
-  def test_class_binary_eh_marshal
-    marshal = File.join Dir.tmpdir, "test_rdoc_parser_#{$$}.marshal"
-    File.open marshal, 'wb' do |io|
-      io.write Marshal.dump('')
-      io.write 'lots of text ' * 500
-    end
-
-    assert @RP.binary?(marshal)
-  ensure
-    File.unlink marshal
-  end
-
-  def test_class_binary_japanese_text
-    file_name = File.expand_path '../test.ja.txt', __FILE__
-    refute @RP.binary?(file_name)
-  end
-
-  def test_class_binary_large_japanese_rdoc
-    capture_output do
-      begin
-        extenc, Encoding.default_external =
-          Encoding.default_external, Encoding::US_ASCII
-        file_name = File.expand_path '../test.ja.largedoc', __FILE__
-        assert !@RP.binary?(file_name)
-      ensure
-        Encoding.default_external = extenc
-      end
-    end
-  end
-
-  def test_class_binary_japanese_rdoc
-    file_name = File.expand_path '../test.ja.rdoc', __FILE__
-    refute @RP.binary?(file_name)
-  end
-
-  def test_class_can_parse
-    assert_equal @RP.can_parse(__FILE__), @RP::Ruby
-
-    readme_file_name = File.expand_path '../test.txt', __FILE__
-
-    assert_equal @RP::Simple, @RP.can_parse(readme_file_name)
-
-    assert_equal @RP::Simple, @RP.can_parse(@binary_dat_fixture_path)
-
-    jtest_file_name = File.expand_path '../test.ja.txt', __FILE__
-    assert_equal @RP::Simple, @RP.can_parse(jtest_file_name)
-
-    jtest_rdoc_file_name = File.expand_path '../test.ja.rdoc', __FILE__
-    assert_equal @RP::Simple, @RP.can_parse(jtest_rdoc_file_name)
-
-    readme_file_name = File.expand_path '../README', __FILE__
-    assert_equal @RP::Simple, @RP.can_parse(readme_file_name)
-
-    jtest_largerdoc_file_name = File.expand_path '../test.ja.largedoc', __FILE__
-    assert_equal @RP::Simple, @RP.can_parse(jtest_largerdoc_file_name)
-
-    @RP.alias_extension 'rdoc', 'largedoc'
-    assert_equal @RP::Simple, @RP.can_parse(jtest_largerdoc_file_name)
-  end
-
-  def test_class_for_executable
-    with_top_level("app", "#!/usr/bin/env ruby -w\n") do |top_level, content|
-      parser = @RP.for top_level, content, @options, :stats
-
-      assert_kind_of RDoc::Parser::Ruby, parser
-
-      assert_equal top_level.absolute_name, parser.file_name
-    end
-  end
-
-  def test_class_for_forbidden
-    omit 'chmod not supported' if Gem.win_platform?
-
-    tf = Tempfile.open 'forbidden' do |io|
-      begin
-        File.chmod 0000, io.path
-        forbidden = @store.add_file io.path
-
-        parser = @RP.for forbidden, '', @options, :stats
-
-        assert_nil parser
-      ensure
-        File.chmod 0400, io.path
-      end
-      io
-    end
-    tf.close!
-  end
-
-  def test_class_for_modeline
-    with_top_level("NEWS", "# -*- rdoc -*-\n= NEWS\n") do |top_level, content|
-      parser = @RP.for top_level, content, @options, :stats
-
-      assert_kind_of RDoc::Parser::Simple, parser
-
-      assert_equal "= NEWS\n", parser.content
-    end
-  end
-
-  def test_can_parse_modeline
-    readme_ext = File.join Dir.tmpdir, "README.EXT.#{$$}"
-
-    File.open readme_ext, 'w' do |io|
-      io.puts "# README.EXT -  -*- rdoc -*- created at: Mon Aug 7 16:45:54 JST 1995"
-      io.puts
-      io.puts "This document explains how to make extension libraries for Ruby."
-    end
-
-    assert_equal RDoc::Parser::Simple, @RP.can_parse(readme_ext)
-  ensure
-    File.unlink readme_ext
-  end
-
-  def test_can_parse_modeline_c
-    readme_inc = File.join Dir.tmpdir, "README.inc.#{$$}"
-
-    File.open readme_inc, 'w' do |io|
-      io.puts "/* README.inc -  -*- c -*- created at: Mon Aug 7 16:45:54 JST 1995 */"
-      io.puts
-      io.puts "/* This document explains how to make extension libraries for Ruby. */"
-    end
-
-    assert_equal RDoc::Parser::C, @RP.can_parse(readme_inc)
-  ensure
-    File.unlink readme_inc
-  end
-
-  ##
-  # Selenium hides a .jar file using a .txt extension.
-
-  def test_class_can_parse_zip
-    hidden_zip = File.expand_path '../hidden.zip.txt', __FILE__
-    assert_nil @RP.can_parse(hidden_zip)
-  end
-
-  def test_check_modeline
-    readme_ext = File.join Dir.tmpdir, "README.EXT.#{$$}"
-
-    File.open readme_ext, 'w' do |io|
-      io.puts "# README.EXT -  -*- RDoc -*- created at: Mon Aug 7 16:45:54 JST 1995"
-      io.puts
-      io.puts "This document explains how to make extension libraries for Ruby."
-    end
-
-    assert_equal 'rdoc', @RP.check_modeline(readme_ext)
-  ensure
-    File.unlink readme_ext
-  end
-
-  def test_check_modeline_coding
-    readme_ext = File.join Dir.tmpdir, "README.EXT.#{$$}"
-
-    File.open readme_ext, 'w' do |io|
-      io.puts "# -*- coding: utf-8 -*-"
-    end
-
-    assert_nil @RP.check_modeline readme_ext
-  ensure
-    File.unlink readme_ext
-  end
-
-  def test_check_modeline_with_other
-    readme_ext = File.join Dir.tmpdir, "README.EXT.#{$$}"
-
-    File.open readme_ext, 'w' do |io|
-      io.puts "# README.EXT -  -*- mode: RDoc; indent-tabs-mode: nil -*-"
-      io.puts
-      io.puts "This document explains how to make extension libraries for Ruby."
-    end
-
-    assert_equal 'rdoc', @RP.check_modeline(readme_ext)
-  ensure
-    File.unlink readme_ext
-  end
-
-  def test_check_modeline_no_modeline
-    readme_ext = File.join Dir.tmpdir, "README.EXT.#{$$}"
-
-    File.open readme_ext, 'w' do |io|
-      io.puts "This document explains how to make extension libraries for Ruby."
-    end
-
-    assert_nil @RP.check_modeline(readme_ext)
-  ensure
-    File.unlink readme_ext
-  end
-
-  def test_class_for_binary
-    dat_fixture = File.read(@binary_dat_fixture_path)
-    with_top_level("binary.dat", dat_fixture) do |top_level, content|
-      assert_nil @RP.for(top_level, content, @options, nil)
-    end
-  end
-
-  def test_class_for_markup
-    with_top_level("file.rb", "# coding: utf-8 markup: rd") do |top_level, content|
-      parser = @RP.for top_level, content, @options, nil
-
-      assert_kind_of @RP::RD, parser
-    end
-  end
-
-  def test_class_use_markup
-    content = <<-CONTENT
-# coding: utf-8 markup: rd
-    CONTENT
-
-    parser = @RP.use_markup content
-
-    assert_equal @RP::RD, parser
-  end
-
-  def test_class_use_markup_markdown
-    content = <<-CONTENT
-# coding: utf-8 markup: markdown
-    CONTENT
-
-    parser = @RP.use_markup content
-
-    assert_equal @RP::Ruby, parser
-  end
-
-  def test_class_use_markup_modeline
-    content = <<-CONTENT
-# -*- coding: utf-8 -*-
-# markup: rd
-    CONTENT
-
-    parser = @RP.use_markup content
-
-    assert_equal @RP::RD, parser
-  end
-
-  def test_class_use_markup_modeline_shebang
-    content = <<-CONTENT
-#!/bin/sh
-/* -*- coding: utf-8 -*-
- * markup: rd
- */
-    CONTENT
-
-    parser = @RP.use_markup content
-
-    assert_equal @RP::RD, parser
-  end
-
-  def test_class_use_markup_shebang
-    content = <<-CONTENT
-#!/usr/bin/env ruby
-# coding: utf-8 markup: rd
-    CONTENT
-
-    parser = @RP.use_markup content
-
-    assert_equal @RP::RD, parser
-  end
-
-  def test_class_use_markup_tomdoc
-    content = <<-CONTENT
-# coding: utf-8 markup: tomdoc
-    CONTENT
-
-    parser = @RP.use_markup content
-
-    assert_equal @RP::Ruby, parser
-  end
-
-  def test_class_use_markup_none
-    parser = @RP.use_markup ''
-
-    assert_nil parser
-  end
-
-  def test_class_use_markup_unknown
-    content = <<-CONTENT
-# :markup: RDoc
-    CONTENT
-
-    parser = @RP.use_markup content
-
-    assert_nil parser
-  end
-
-  def test_initialize
-    with_top_level("file.rb", "") do |top_level, content|
-      @RP.new top_level, content, @options, nil
-
-      assert_equal @RP, top_level.parser
-    end
-  end
-
-  private
-
-  def with_top_level(filename, content, &block)
-    absoluate_filename  = File.join Dir.tmpdir, filename
-    File.open absoluate_filename, 'w' do |io|
-      io.write content
-    end
-
-    top_level = RDoc::TopLevel.new absoluate_filename
-
-    yield(top_level, content)
-  ensure
-    File.unlink absoluate_filename
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc_rd_block_parser_test.rb b/test/mri/rdoc/rdoc_rd_block_parser_test.rb
deleted file mode 100644
index 50bf075a5a7..00000000000
--- a/test/mri/rdoc/rdoc_rd_block_parser_test.rb
+++ /dev/null
@@ -1,557 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocRdBlockParserTest < RDoc::TestCase
-
-  def setup
-    super
-
-    @block_parser = RDoc::RD::BlockParser.new
-  end
-
-  def test_add_footnote
-    index = @block_parser.add_footnote 'context'
-
-    assert_equal 1, index
-
-    expected = [
-      para('{^1}[rdoc-label:footmark-1:foottext-1]', ' ', 'context'),
-      blank_line,
-    ]
-
-    assert_equal expected, @block_parser.footnotes
-
-    index = @block_parser.add_footnote 'other'
-
-    assert_equal 2, index
-  end
-
-  def test_parse_desclist
-    list = <<-LIST
-:one
-  desc one
-:two
-  desc two
-    LIST
-
-    expected =
-      doc(
-        list(:NOTE,
-          item("one", para("desc one")),
-          item("two", para("desc two"))))
-
-    assert_equal expected, parse(list)
-  end
-
-  def test_parse_enumlist
-    list = <<-LIST
-(1) one
-(1) two
-    LIST
-
-    expected =
-      doc(
-        list(:NUMBER,
-          item(nil, para("one")),
-          item(nil, para("two"))))
-
-    assert_equal expected, parse(list)
-  end
-
-  def test_parse_enumlist_paragraphs
-    list = <<-LIST
-(1) one
-
-    two
-    LIST
-
-    expected =
-      doc(
-        list(:NUMBER,
-          item(nil,
-            para("one"),
-            para("two"))))
-
-    assert_equal expected, parse(list)
-  end
-
-  def test_parse_enumlist_multiline
-    list = <<-LIST
-(1) one
-    two
-    LIST
-
-    contents = "one\n     two" # 1.8 vs 1.9
-
-    expected =
-      doc(
-        list(:NUMBER,
-          item(nil, para(*contents))))
-
-    assert_equal expected, parse(list)
-  end
-
-  def test_parse_enumlist_verbatim
-    list = <<-LIST
-(1) item
-      verbatim
-    LIST
-
-    expected =
-      doc(
-        list(:NUMBER,
-          item(nil,
-            para("item"),
-            verb("verbatim\n"))))
-
-    assert_equal expected, parse(list)
-  end
-
-  def test_parse_enumlist_verbatim_continue
-    list = <<-LIST
-(1) one
-      verbatim
-    two
-    LIST
-
-    expected =
-      doc(
-        list(:NUMBER,
-          item(nil,
-            para("one"),
-            verb("verbatim\n"),
-            para("two"))))
-
-    assert_equal expected, parse(list)
-  end
-
-  def test_parse_footnote
-    expected =
-      doc(
-        para("{*1}[rdoc-label:foottext-1:footmark-1]"),
-        rule(1),
-        para("{^1}[rdoc-label:footmark-1:foottext-1]", " ", "text"),
-        blank_line)
-
-    assert_equal expected, parse("((-text-))")
-  end
-
-  def test_parse_include
-    @block_parser.include_path = [Dir.tmpdir]
-
-    expected = doc(@RM::Include.new("parse_include", [Dir.tmpdir]))
-
-    assert_equal expected, parse("<<< parse_include")
-  end
-
-  def test_parse_include_subtree
-    @block_parser.include_path = [Dir.tmpdir]
-
-    expected =
-      doc(
-        blank_line,
-        para("include <em>worked</em>"),
-        blank_line,
-        blank_line)
-
-    tf = Tempfile.open %w[parse_include .rd] do |io|
-      io.puts "=begin\ninclude ((*worked*))\n=end"
-      io.flush
-
-      str = <<-STR
-<<< #{File.basename io.path}
-      STR
-
-      assert_equal expected, parse(str)
-      io
-    end
-    tf.close!
-  end
-
-=begin
-  def test_parse_include_other_format
-    @block_parser.include_path = [Dir.tmpdir]
-
-    expected =
-      doc(
-        blank_line,
-        para("include ((*worked*))"),
-        blank_line,
-        blank_line)
-
-    str = <<~STR
-    =begin nonrd
-    <<< worked
-    =end
-    STR
-
-    assert_equal(expected, @block_parser.parse str.lines.to_a)
-  end
-=end
-
-  def test_parse_heading
-    assert_equal doc(head(1, "H")), parse("= H")
-    assert_equal doc(head(2, "H")), parse("== H")
-    assert_equal doc(head(3, "H")), parse("=== H")
-    assert_equal doc(head(4, "H")), parse("==== H")
-    assert_equal doc(head(5, "H")), parse("+ H")
-    assert_equal doc(head(6, "H")), parse("++ H")
-  end
-
-  def test_parse_itemlist
-    list = <<-LIST
-* one
-* two
-    LIST
-
-    expected =
-      doc(
-        list(:BULLET,
-          item(nil, para("one")),
-          item(nil, para("two"))))
-
-    assert_equal expected, parse(list)
-  end
-
-  def test_parse_itemlist_multiline
-    list = <<-LIST
-* one
-  two
-    LIST
-
-    contents = "one\n   two" # 1.8 vs 1.9
-
-    expected =
-      doc(
-        list(:BULLET,
-          item(nil, para(*contents))))
-
-    assert_equal expected, parse(list)
-  end
-
-  def test_parse_itemlist_nest
-    list = <<-LIST
-* one
-  * inner
-* two
-    LIST
-
-    expected =
-      doc(
-        list(:BULLET,
-          item(nil,
-            para("one"),
-            list(:BULLET,
-              item(nil, para("inner")))),
-          item(nil,
-            para("two"))))
-
-    assert_equal expected, parse(list)
-  end
-
-  def test_parse_itemlist_paragraphs
-    list = <<-LIST
-* one
-
-  two
-    LIST
-
-    expected =
-      doc(
-        list(:BULLET,
-          item(nil,
-            para("one"),
-            para("two"))))
-
-    assert_equal expected, parse(list)
-  end
-
-  def test_parse_itemlist_verbatim
-    list = <<-LIST
-* item
-    verbatim
-    LIST
-
-    expected =
-      doc(
-        list(:BULLET,
-          item(nil,
-            para("item"),
-            verb("verbatim\n"))))
-
-    assert_equal expected, parse(list)
-  end
-
-  def test_parse_itemlist_verbatim_continue
-    list = <<-LIST
-* one
-    verbatim
-  two
-    LIST
-
-    expected =
-      doc(
-        list(:BULLET,
-          item(nil,
-            para("one"),
-            verb("verbatim\n"),
-            para("two"))))
-
-    assert_equal expected, parse(list)
-  end
-
-  def test_parse_lists
-    list = <<-LIST
-(1) one
-(1) two
-* three
-* four
-(1) five
-(1) six
-    LIST
-
-    expected =
-      doc(
-        list(:NUMBER,
-          item(nil, para("one")),
-          item(nil, para("two"))),
-        list(:BULLET,
-          item(nil, para("three")),
-          item(nil, para("four"))),
-        list(:NUMBER,
-          item(nil, para("five")),
-          item(nil, para("six"))))
-
-    assert_equal expected, parse(list)
-  end
-
-  def test_parse_lists_nest
-    list = <<-LIST
-(1) one
-(1) two
-      * three
-      * four
-(1) five
-(1) six
-    LIST
-
-    expected =
-      doc(
-        list(:NUMBER,
-          item(nil, para("one")),
-          item(nil,
-            para("two"),
-            list(:BULLET,
-              item(nil, para("three")),
-              item(nil, para("four")))),
-          item(nil, para("five")),
-          item(nil, para("six"))))
-
-    assert_equal expected, parse(list)
-  end
-
-  def test_parse_lists_nest_verbatim
-    list = <<-LIST
-(1) one
-(1) two
-      * three
-      * four
-     verbatim
-(1) five
-(1) six
-    LIST
-
-    expected =
-      doc(
-        list(:NUMBER,
-          item(nil, para("one")),
-          item(nil,
-            para("two"),
-            list(:BULLET,
-              item(nil, para("three")),
-              item(nil, para("four"))),
-            verb("verbatim\n")),
-          item(nil, para("five")),
-          item(nil, para("six"))))
-
-    assert_equal expected, parse(list)
-  end
-
-  def test_parse_lists_nest_verbatim2
-    list = <<-LIST
-(1) one
-(1) two
-      * three
-      * four
-      verbatim
-(1) five
-(1) six
-    LIST
-
-    expected =
-      doc(
-        list(:NUMBER,
-          item(nil, para("one")),
-          item(nil,
-            para("two"),
-            list(:BULLET,
-              item(nil, para("three")),
-              item(nil, para("four"))),
-            verb("verbatim\n")),
-          item(nil, para("five")),
-          item(nil, para("six"))))
-
-    assert_equal expected, parse(list)
-  end
-
-  def test_parse_methodlist
-    list = <<-LIST
---- Array#each {|i| ... }
-      yield block for each item.
---- Array#index(val)
-      return index of first item which equals with val. if it hasn't
-      same item, return nil.
-    LIST
-
-    expected =
-      doc(
-        list(:LABEL,
-          item(
-            "<tt>Array#each {|i| ... }</tt>",
-            para("yield block for each item.")),
-          item(
-            "<tt>Array#index(val)</tt>",
-            para("return index of first item which equals with val. if it hasn't same item, return nil."))))
-
-    assert_equal expected, parse(list)
-  end
-
-  def test_parse_methodlist_empty
-    list = <<-LIST
---- A#b
-
-    LIST
-
-    expected =
-      doc(
-        list(:LABEL,
-          item("<tt>A#b</tt>")))
-
-    assert_equal expected, parse(list)
-  end
-
-  def test_parse_methodlist_paragraph
-    list = <<-LIST
---- A#b
-
-    one
-    LIST
-
-    expected =
-      doc(
-        list(:LABEL,
-          item(
-            "<tt>A#b</tt>",
-            para("one"))))
-
-    assert_equal expected, parse(list)
-  end
-
-  def test_parse_methodlist_paragraph2
-    list = <<-LIST.chomp
---- A#b
-
-    one
-two
-    LIST
-
-    expected =
-      doc(
-        list(:LABEL,
-          item(
-            "<tt>A#b</tt>",
-            para("one"))),
-        para("two"))
-
-    assert_equal expected, parse(list)
-  end
-
-  def test_parse_methodlist_paragraph_verbatim
-    list = <<-LIST.chomp
---- A#b
-
-    text
-      verbatim
-    LIST
-
-    expected =
-      doc(
-        list(:LABEL,
-          item(
-            "<tt>A#b</tt>",
-            para("text"),
-            verb("verbatim\n"))))
-
-    assert_equal expected, parse(list)
-  end
-
-  def test_parse_verbatim
-    assert_equal doc(verb("verbatim\n")), parse("  verbatim")
-  end
-
-  def test_parse_verbatim_blankline
-    expected = doc(verb("one\n", "\n", "two\n"))
-
-    verbatim = <<-VERBATIM
-  one
-
-  two
-    VERBATIM
-
-    assert_equal expected, parse(verbatim)
-  end
-
-  def test_parse_verbatim_indent
-    expected = doc(verb("one\n", " two\n"))
-
-    verbatim = <<-VERBATIM
-  one
-   two
-    VERBATIM
-
-    assert_equal expected, parse(verbatim)
-  end
-
-  def test_parse_verbatim_multi
-    expected = doc(verb("one\n", "two\n"))
-
-    verbatim = <<-VERBATIM
-  one
-  two
-    VERBATIM
-
-    assert_equal expected, parse(verbatim)
-  end
-
-  def test_parse_textblock
-    assert_equal doc(para("text")), parse("text")
-  end
-
-  def test_parse_textblock_multi
-    expected = doc(para("one two"))
-
-    assert_equal expected, parse("one\ntwo")
-  end
-
-  def parse(text)
-    text = ["=begin", text, "=end"].join "\n"
-
-    doc = @block_parser.parse text.lines.to_a
-
-    assert_equal blank_line, doc.parts.shift, "=begin blankline"
-    assert_equal blank_line, doc.parts.pop, "=end blankline"
-
-    doc
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc_rd_inline_parser_test.rb b/test/mri/rdoc/rdoc_rd_inline_parser_test.rb
deleted file mode 100644
index e484dbe8334..00000000000
--- a/test/mri/rdoc/rdoc_rd_inline_parser_test.rb
+++ /dev/null
@@ -1,178 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocRdInlineParserTest < RDoc::TestCase
-
-  def setup
-    super
-
-    @block_parser = RDoc::RD::BlockParser.new
-    @block_parser.instance_variable_set :@i, 0
-    @inline_parser = RDoc::RD::InlineParser.new @block_parser
-  end
-
-  def test_parse
-    assert_equal 'regular <em>emphasis</em>', parse('regular ((*emphasis*))')
-  end
-
-  def test_parse_code
-    assert_equal '<code>text</code>', parse('(({text}))')
-  end
-
-  def test_parse_em
-    assert_equal '<em>text</em>', parse('((*text*))')
-  end
-
-  def test_parse_footnote
-    assert_equal '{*1}[rdoc-label:foottext-1:footmark-1]', parse('((-text-))')
-
-    expected = [
-      @RM::Paragraph.new('{^1}[rdoc-label:footmark-1:foottext-1]', ' ', 'text'),
-      blank_line,
-    ]
-
-    assert_equal expected, @block_parser.footnotes
-  end
-
-  def test_parse_index
-    assert_equal '<span id="label-text">text</span>', parse('((:text:))')
-
-    assert_includes @block_parser.labels, 'text'
-  end
-
-  def test_parse_kbd
-    assert_equal '<tt>text</tt>', parse('((%text%))')
-  end
-
-  def test_parse_multiple
-    assert_equal '<em>one</em> <em>two</em>', parse('((*one*)) ((*two*))')
-  end
-
-  def test_parse_newline
-    assert_equal "one\ntwo", parse("one\ntwo")
-  end
-
-  def test_parse_quote
-    assert_equal 'one " two', parse('one " two')
-  end
-
-  def test_parse_ref
-    assert_equal '{text}[rdoc-label:text]', parse('((<text>))')
-  end
-
-  def test_parse_ref_em
-    assert_equal '{<em>text</em>}[rdoc-label:text]', parse('((<((*text*))>))')
-  end
-
-  def test_parse_ref_filename_quote
-    assert_equal '{RD/foo}[rdoc-label:RD/foo]', parse('((<RD/"foo">))')
-  end
-
-  def test_parse_ref_filename
-    assert_equal '{RD}[rdoc-label:RD/]', parse('((<RD/>))')
-  end
-
-  def test_parse_ref_quote
-    assert_equal '{text \\"}[rdoc-label:text \\"]', parse('((<text \">))')
-  end
-
-  def test_parse_ref_quote_content
-    assert_equal '{<em>text</em>}[rdoc-label:text]',
-                 parse('((<"((*text*))">))')
-  end
-
-  def test_parse_ref_quote_content_multi
-    assert_equal '{<em>one</em> <em>two</em>}[rdoc-label:one two]',
-                 parse('((<"((*one*)) ((*two*))">))')
-  end
-
-  def test_parse_ref_substitute
-    assert_equal '{text}[rdoc-label:thing]', parse('((<text|thing>))')
-  end
-
-  def test_parse_ref_substitute_element_quote
-    assert_equal '{text}[rdoc-label:"RD"]',
-                 parse('((<text|"RD">))')
-  end
-
-  def test_parse_ref_substitute_filename
-    assert_equal '{text}[rdoc-label:RD/]', parse('((<text|RD/>))')
-  end
-
-  def test_parse_ref_substitute_filename_label
-    assert_equal '{text}[rdoc-label:RD/label]',
-                 parse('((<text|RD/label>))')
-  end
-
-  def test_parse_ref_substitute_filename_quote
-    assert_equal '{text}[rdoc-label:"RD"/]', parse('((<text|"RD"/>))')
-  end
-
-  def test_parse_ref_substitute_multi_content
-    assert_equal '{<em>one</em> two}[rdoc-label:thing]',
-                 parse('((<((*one*)) two|thing>))')
-  end
-
-  def test_parse_ref_substitute_multi_content2
-    assert_equal '{<em>one</em> \\" two}[rdoc-label:thing]',
-                 parse('((<((*one*)) \" two|thing>))')
-  end
-
-  def test_parse_ref_substitute_multi_content3
-    assert_equal '{<em>one</em> \\" <em>two</em>}[rdoc-label:thing]',
-                 parse('((<((*one*)) \" ((*two*))|thing>))')
-  end
-
-  def test_parse_ref_substitute_quote
-    assert_equal '{one | two}[rdoc-label:thing]',
-                 parse('((<"one | two"|thing>))')
-  end
-
-  def test_parse_ref_substitute_quote_content
-    assert_equal '{<em>text</em>}[rdoc-label:thing]',
-                 parse('((<"((*text*))"|thing>))')
-  end
-
-  def test_parse_ref_substitute_url
-    assert_equal '{text}[http://example]',
-                 parse('((<text|URL:http://example>))')
-  end
-
-  def test_parse_ref_url
-    assert_equal '{http://example}[http://example]',
-                 parse('((<URL:http://example>))')
-  end
-
-  def test_parse_var
-    assert_equal '+text+', parse('((|text|))')
-  end
-
-  def test_parse_verb
-    assert_equal '<tt>text</tt>', parse("(('text'))")
-  end
-
-  def test_parse_verb_backslash
-    assert_equal "<tt>(('text'))</tt>", parse("(('(('text\\'))'))")
-  end
-
-  def test_parse_verb_backslash_backslash
-    assert_equal '<tt>text \\</tt>', parse("(('text \\\\'))")
-  end
-
-  def test_parse_verb_backslash_quote
-    assert_equal '<tt>text "</tt>', parse("(('text \\\"'))")
-  end
-
-  def test_parse_verb_emphasis
-    assert_equal '<tt>((*emphasis*))</tt>', parse("(('((*emphasis*))'))")
-  end
-
-  def test_parse_verb_multiple
-    assert_equal '<tt>((*text*))</tt>', parse("(('((*text*))'))")
-  end
-
-  def parse(text)
-    @inline_parser.parse text
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc_rd_inline_test.rb b/test/mri/rdoc/rdoc_rd_inline_test.rb
deleted file mode 100644
index c4984949f4c..00000000000
--- a/test/mri/rdoc/rdoc_rd_inline_test.rb
+++ /dev/null
@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocRdInlineTest < RDoc::TestCase
-
-  def setup
-    super
-
-    @inline = RDoc::RD::Inline.new '+text+', 'text'
-  end
-
-  def test_class_new
-    inline = RDoc::RD::Inline.new @inline
-
-    refute_equal inline.rdoc, inline.reference
-  end
-
-  def test_initialize
-    inline = RDoc::RD::Inline.new 'text'
-
-    assert_equal inline.rdoc, inline.reference
-    refute_same  inline.rdoc, inline.reference
-  end
-
-  def test_initialize_inline
-    inline = RDoc::RD::Inline.new @inline
-
-    assert_equal '+text+', inline.rdoc
-    assert_equal 'text',   inline.reference
-  end
-
-  def test_append_inline
-    out = @inline.append @inline
-
-    assert_same @inline, out
-
-    assert_equal '+text++text+', @inline.rdoc
-    assert_equal 'texttext',     @inline.reference
-  end
-
-  def test_append_string
-    @inline.append ' more'
-
-    assert_equal '+text+ more', @inline.rdoc
-    assert_equal 'text more',   @inline.reference
-  end
-
-  def test_equals2
-    assert_equal @inline, RDoc::RD::Inline.new('+text+', 'text')
-    refute_equal @inline, RDoc::RD::Inline.new('+text+', 'other')
-    refute_equal @inline, RDoc::RD::Inline.new('+other+', 'text')
-    refute_equal @inline, Object.new
-  end
-
-  def test_inspect
-    assert_equal '(inline: +text+)', @inline.inspect
-  end
-
-  def test_to_s
-    assert_equal '+text+', @inline.to_s
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc_rd_test.rb b/test/mri/rdoc/rdoc_rd_test.rb
deleted file mode 100644
index 8842aaccbee..00000000000
--- a/test/mri/rdoc/rdoc_rd_test.rb
+++ /dev/null
@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocRdTest < RDoc::TestCase
-
-  def test_class_parse
-    expected =
-      @RM::Document.new(
-        @RM::Paragraph.new('hello'))
-
-    assert_equal expected, RDoc::RD.parse("hello")
-  end
-
-  def test_class_parse_begin_end
-    expected =
-      @RM::Document.new(
-        @RM::Paragraph.new('hello'))
-
-    assert_equal expected, RDoc::RD.parse("=begin\nhello\n=end\n")
-  end
-
-  def test_class_parse_newline
-    expected =
-      @RM::Document.new(
-        @RM::Paragraph.new('hello'))
-
-    assert_equal expected, RDoc::RD.parse("hello\n")
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc_rdoc_test.rb b/test/mri/rdoc/rdoc_rdoc_test.rb
deleted file mode 100644
index 6760badfe2c..00000000000
--- a/test/mri/rdoc/rdoc_rdoc_test.rb
+++ /dev/null
@@ -1,582 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocRDocTest < RDoc::TestCase
-
-  def setup
-    super
-
-    @rdoc = RDoc::RDoc.new
-    @options = RDoc::Options.new
-    @rdoc.options = @options
-
-    @stats = RDoc::Stats.new @store, 0, 0
-    @rdoc.instance_variable_set :@stats, @stats
-  end
-
-  def test_document # functional test
-    options = RDoc::Options.new
-    options.files = [File.expand_path('../xref_data.rb', __FILE__)]
-    options.setup_generator 'ri'
-    options.main_page = 'MAIN_PAGE.rdoc'
-    options.root      = Pathname File.expand_path('..', __FILE__)
-    options.title     = 'title'
-
-    rdoc = RDoc::RDoc.new
-
-    temp_dir do
-      options.op_dir = 'ri'
-
-      capture_output do
-        rdoc.document options
-      end
-
-      assert File.directory? 'ri'
-    end
-
-    store = rdoc.store
-
-    assert_equal 'MAIN_PAGE.rdoc', store.main
-    assert_equal 'title',          store.title
-  end
-
-  def test_document_with_dry_run # functional test
-    options = RDoc::Options.new
-    options.files = [File.expand_path('../xref_data.rb', __FILE__)]
-    options.setup_generator 'darkfish'
-    options.main_page = 'MAIN_PAGE.rdoc'
-    options.root      = Pathname File.expand_path('..', __FILE__)
-    options.title     = 'title'
-    options.dry_run = true
-
-    rdoc = RDoc::RDoc.new
-
-    out = nil
-    temp_dir do
-      out, = capture_output do
-        rdoc.document options
-      end
-
-      refute File.directory? 'doc'
-    end
-    assert_includes out, '100%'
-
-    store = rdoc.store
-
-    assert_equal 'MAIN_PAGE.rdoc', store.main
-    assert_equal 'title',          store.title
-  end
-
-  def test_gather_files
-    a = File.expand_path __FILE__
-    b = File.expand_path '../rdoc_text_test.rb', __FILE__
-
-    assert_equal [a, b], @rdoc.gather_files([b, a, b])
-
-    assert_empty @rdoc.gather_files([b, a, b])
-
-    @rdoc.last_modified[a] -= 10
-    assert_equal [a, b], @rdoc.gather_files([b, a, b])
-  end
-
-  def test_handle_pipe
-    $stdin = StringIO.new "hello"
-
-    out, = capture_output do
-      @rdoc.handle_pipe
-    end
-
-    assert_equal "\n<p>hello</p>\n", out
-  ensure
-    $stdin = STDIN
-  end
-
-  def test_handle_pipe_rd
-    $stdin = StringIO.new "=begin\nhello\n=end"
-
-    @rdoc.options.markup = 'rd'
-
-    out, = capture_output do
-      @rdoc.handle_pipe
-    end
-
-    assert_equal "\n<p>hello</p>\n", out
-  ensure
-    $stdin = STDIN
-  end
-
-  def test_normalized_file_list
-    test_path = File.expand_path(__FILE__)
-    files = temp_dir do |dir|
-      flag_file = @rdoc.output_flag_file dir
-
-      FileUtils.touch flag_file
-
-      @rdoc.normalized_file_list [test_path, flag_file]
-    end
-
-    files = files.map { |file, *| File.expand_path file }
-
-    assert_equal [test_path], files
-  end
-
-  def test_normalized_file_list_not_modified
-    @rdoc.last_modified[__FILE__] = File.stat(__FILE__).mtime
-
-    files = @rdoc.normalized_file_list [__FILE__]
-
-    files = files.collect {|file, mtime| file if mtime}.compact
-
-    assert_empty(files)
-  end
-
-  def test_normalized_file_list_non_file_directory
-    dev = File::NULL
-    omit "#{dev} is not a character special" unless
-      File.chardev? dev
-
-    files = nil
-
-    out, err = verbose_capture_output do
-      files = @rdoc.normalized_file_list [dev]
-    end
-
-    files = files.map { |file| File.expand_path file }
-
-    assert_empty files
-
-    assert_empty out
-    assert_match %r"^rdoc can't parse", err
-    assert_match %r"#{dev}$",           err
-  end
-
-  def test_normalized_file_list_with_dot_doc
-    expected_files = []
-    files = temp_dir do |dir|
-      a = File.expand_path('a.rb')
-      b = File.expand_path('b.rb')
-      c = File.expand_path('c.rb')
-      FileUtils.touch a
-      FileUtils.touch b
-      FileUtils.touch c
-      # Use Dir.glob to convert short path of Dir.tmpdir to long path.
-      a = Dir.glob(a).first
-      b = Dir.glob(b).first
-      c = Dir.glob(c).first
-
-      File.write('.document', "a.rb\n""b.rb\n")
-      expected_files << a
-      expected_files << b
-
-      @rdoc.normalized_file_list [File.realpath(dir)]
-    end
-
-    files = files.map { |file, *| File.expand_path file }
-
-    assert_equal expected_files, files
-  end
-
-  def test_normalized_file_list_with_dot_doc_overridden_by_exclude_option
-    expected_files = []
-    files = temp_dir do |dir|
-      a = File.expand_path('a.rb')
-      b = File.expand_path('b.rb')
-      c = File.expand_path('c.rb')
-      FileUtils.touch a
-      FileUtils.touch b
-      FileUtils.touch c
-      # Use Dir.glob to convert short path of Dir.tmpdir to long path.
-      a = Dir.glob(a).first
-      b = Dir.glob(b).first
-      c = Dir.glob(c).first
-
-      File.write('.document', "a.rb\n""b.rb\n")
-      expected_files << a
-
-      @rdoc.options.exclude = /b\.rb$/
-      @rdoc.normalized_file_list [File.realpath(dir)]
-    end
-
-    files = files.map { |file, *| File.expand_path file }
-
-    assert_equal expected_files, files
-  end
-
-  def test_normalized_file_list_with_skipping_tests_enabled
-    files = temp_dir do |dir|
-      @a = File.expand_path('a.rb')
-      spec_dir = File.expand_path('spec')
-      spec_file = File.expand_path(File.join('spec', 'my_spec.rb'))
-      test_dir = File.expand_path('test')
-      test_file = File.expand_path(File.join('test', 'my_test.rb'))
-      FileUtils.touch @a
-      FileUtils.mkdir_p spec_dir
-      FileUtils.touch spec_file
-      FileUtils.mkdir_p test_dir
-      FileUtils.touch test_file
-
-      @rdoc.options.skip_tests = true
-      @rdoc.normalized_file_list [File.realpath(dir)]
-    end
-
-    files = files.map { |file, *| File.expand_path file }
-    assert_equal [@a], files
-  end
-
-  def test_normalized_file_list_with_skipping_tests_disabled
-    files = temp_dir do |dir|
-      @a = File.expand_path('a.rb')
-      spec_dir = File.expand_path('spec')
-      @spec_file = File.expand_path(File.join('spec', 'my_spec.rb'))
-      test_dir = File.expand_path('test')
-      @test_file = File.expand_path(File.join('test', 'my_test.rb'))
-      FileUtils.touch @a
-      FileUtils.mkdir_p spec_dir
-      FileUtils.touch @spec_file
-      FileUtils.mkdir_p test_dir
-      FileUtils.touch @test_file
-
-      @rdoc.options.skip_tests = false
-      @rdoc.normalized_file_list [File.realpath(dir)]
-    end
-
-    files = files.map { |file, *| File.expand_path file }
-    assert_equal [@a, @spec_file, @test_file], files.sort
-  end
-
-  def test_parse_file
-    @rdoc.store = RDoc::Store.new(@options)
-
-    temp_dir do |dir|
-      @rdoc.options.root = Pathname(Dir.pwd)
-
-      File.open 'test.txt', 'w' do |io|
-        io.puts 'hi'
-      end
-
-      top_level = @rdoc.parse_file 'test.txt'
-
-      assert_equal 'test.txt', top_level.absolute_name
-      assert_equal 'test.txt', top_level.relative_name
-    end
-  end
-
-  def test_parse_file_binary
-    @rdoc.store = RDoc::Store.new(@options)
-
-    root = File.dirname __FILE__
-
-    @rdoc.options.root = Pathname root
-
-    out, err = capture_output do
-      Dir.chdir root do
-        assert_nil @rdoc.parse_file 'binary.dat'
-      end
-    end
-
-    assert_empty out
-    assert_empty err
-  end
-
-  def test_parse_file_include_root
-    @rdoc.store = RDoc::Store.new(@options)
-
-    test_path = File.expand_path('..', __FILE__)
-    top_level = nil
-    temp_dir do |dir|
-      @rdoc.options.parse %W[--root #{test_path}]
-      @rdoc.options.finish
-
-      File.open 'include.txt', 'w' do |io|
-        io.puts ':include: test.txt'
-      end
-
-      out, err = capture_output do
-        top_level = @rdoc.parse_file 'include.txt'
-      end
-      assert_empty out
-      assert_empty err
-    end
-    assert_equal "test file", top_level.comment.text
-  end
-
-  def test_parse_file_page_dir
-    @rdoc.store = RDoc::Store.new(@options)
-
-    temp_dir do |dir|
-      FileUtils.mkdir 'pages'
-      @rdoc.options.page_dir = Pathname('pages')
-      @rdoc.options.root = Pathname(Dir.pwd)
-
-      File.open 'pages/test.txt', 'w' do |io|
-        io.puts 'hi'
-      end
-
-      top_level = @rdoc.parse_file 'pages/test.txt'
-
-      assert_equal 'pages/test.txt', top_level.absolute_name
-      assert_equal 'test.txt',       top_level.relative_name
-    end
-  end
-
-  def test_parse_file_relative
-    pwd = Dir.pwd
-
-    @rdoc.store = RDoc::Store.new(@options)
-
-    temp_dir do |dir|
-      @rdoc.options.root = Pathname(dir)
-
-      File.open 'test.txt', 'w' do |io|
-        io.puts 'hi'
-      end
-
-      test_txt = File.join dir, 'test.txt'
-
-      Dir.chdir pwd do
-        top_level = @rdoc.parse_file test_txt
-
-        assert_equal test_txt,   top_level.absolute_name
-        assert_equal 'test.txt', top_level.relative_name
-      end
-    end
-  end
-
-  def test_parse_file_encoding
-    @rdoc.options.encoding = Encoding::ISO_8859_1
-    @rdoc.store = RDoc::Store.new(@options)
-
-    tf = Tempfile.open 'test.txt' do |io|
-      io.write 'hi'
-      io.rewind
-
-      top_level = @rdoc.parse_file io.path
-
-      assert_equal Encoding::ISO_8859_1, top_level.absolute_name.encoding
-      io
-    end
-    tf.close!
-  end
-
-  def test_parse_file_forbidden
-    omit 'chmod not supported' if Gem.win_platform?
-    omit "assumes that euid is not root" if Process.euid == 0
-
-    @rdoc.store = RDoc::Store.new(@options)
-
-    tf = Tempfile.open 'test.txt' do |io|
-      io.write 'hi'
-      io.rewind
-
-      File.chmod 0000, io.path
-
-      begin
-        top_level = :bug
-
-        _, err = capture_output do
-          top_level = @rdoc.parse_file io.path
-        end
-
-        assert_match "Unable to read #{io.path},", err
-
-        assert_nil top_level
-      ensure
-        File.chmod 0400, io.path
-      end
-      io
-    end
-    tf.close!
-  end
-
-  def test_remove_unparseable
-    file_list = %w[
-      blah.class
-      blah.eps
-      blah.erb
-      blah.scpt.txt
-      blah.svg
-      blah.ttf
-      blah.yml
-    ]
-
-    assert_empty @rdoc.remove_unparseable file_list
-  end
-
-  def test_remove_unparseable_tags_emacs
-    temp_dir do
-      File.open 'TAGS', 'wb' do |io| # emacs
-        io.write "\f\nlib/foo.rb,43\n"
-      end
-
-      file_list = %w[
-        TAGS
-      ]
-
-      assert_empty @rdoc.remove_unparseable file_list
-    end
-  end
-
-  def test_remove_unparseable_tags_vim
-    temp_dir do
-      File.open 'TAGS', 'w' do |io| # emacs
-        io.write "!_TAG_"
-      end
-
-      file_list = %w[
-        TAGS
-      ]
-
-      assert_empty @rdoc.remove_unparseable file_list
-    end
-  end
-
-  def test_remove_unparseable_CVE_2021_31799
-    omit 'for Un*x platforms' if Gem.win_platform?
-    temp_dir do
-      file_list = ['| touch evil.txt && echo tags']
-      file_list.each do |f|
-        FileUtils.touch f rescue omit
-      end
-
-      assert_equal file_list, @rdoc.remove_unparseable(file_list)
-      assert_equal file_list, Dir.children('.')
-    end
-  end
-
-  def test_setup_output_dir
-    Dir.mktmpdir {|d|
-      path = File.join d, 'testdir'
-
-      last = @rdoc.setup_output_dir path, false
-
-      assert_empty last
-
-      assert File.directory? path
-      assert File.exist? @rdoc.output_flag_file path
-    }
-  end
-
-  def test_setup_output_dir_dry_run
-    @rdoc.options.dry_run = true
-
-    Dir.mktmpdir do |d|
-      path = File.join d, 'testdir'
-
-      @rdoc.setup_output_dir path, false
-
-      refute File.exist? path
-    end
-  end
-
-  def test_setup_output_dir_exists
-    Dir.mktmpdir {|path|
-      File.open @rdoc.output_flag_file(path), 'w' do |io|
-        io.puts Time.at 0
-        io.puts "./lib/rdoc.rb\t#{Time.at 86400}"
-      end
-
-      last = @rdoc.setup_output_dir path, false
-
-      assert_equal 1, last.size
-      assert_equal Time.at(86400), last['./lib/rdoc.rb']
-    }
-  end
-
-  def test_setup_output_dir_exists_empty_created_rid
-    Dir.mktmpdir {|path|
-      File.open @rdoc.output_flag_file(path), 'w' do end
-
-      e = assert_raise RDoc::Error do
-        @rdoc.setup_output_dir path, false
-      end
-
-      assert_match %r%Directory #{Regexp.escape path} already exists%, e.message
-    }
-  end
-
-  def test_setup_output_dir_exists_file
-    tf = Tempfile.open 'test_rdoc_rdoc' do |tempfile|
-      path = tempfile.path
-
-      e = assert_raise RDoc::Error do
-        @rdoc.setup_output_dir path, false
-      end
-
-      assert_match(%r%#{Regexp.escape path} exists and is not a directory%,
-                   e.message)
-      tempfile
-    end
-    tf.close!
-  end
-
-  def test_setup_output_dir_exists_not_rdoc
-    Dir.mktmpdir do |dir|
-      e = assert_raise RDoc::Error do
-        @rdoc.setup_output_dir dir, false
-      end
-
-      assert_match %r%Directory #{Regexp.escape dir} already exists%, e.message
-    end
-  end
-
-  def test_update_output_dir
-    Dir.mktmpdir do |d|
-      @rdoc.update_output_dir d, Time.now, {}
-
-      assert File.exist? "#{d}/created.rid"
-    end
-  end
-
-  def test_update_output_dir_dont
-    Dir.mktmpdir do |d|
-      @rdoc.options.update_output_dir = false
-      @rdoc.update_output_dir d, Time.now, {}
-
-      refute File.exist? "#{d}/created.rid"
-    end
-  end
-
-  def test_update_output_dir_dry_run
-    Dir.mktmpdir do |d|
-      @rdoc.options.dry_run = true
-      @rdoc.update_output_dir d, Time.now, {}
-
-      refute File.exist? "#{d}/created.rid"
-    end
-  end
-
-  def test_update_output_dir_with_reproducible_time
-    Dir.mktmpdir do |d|
-      backup_epoch = ENV['SOURCE_DATE_EPOCH']
-      ruby_birthday = Time.parse 'Wed, 24 Feb 1993 21:00:00 +0900'
-      ENV['SOURCE_DATE_EPOCH'] = ruby_birthday.to_i.to_s
-
-      @rdoc.update_output_dir d, Time.now, {}
-
-      assert File.exist? "#{d}/created.rid"
-
-      f = File.open("#{d}/created.rid", 'r')
-      head_timestamp = Time.parse f.gets.chomp
-      f.close
-      assert_equal ruby_birthday, head_timestamp
-
-      ENV['SOURCE_DATE_EPOCH'] = backup_epoch
-    end
-  end
-
-  def test_normalized_file_list_removes_created_rid_dir
-    temp_dir do |d|
-      FileUtils.mkdir "doc"
-      flag_file = @rdoc.output_flag_file "doc"
-      file = File.join "doc", "test"
-      FileUtils.touch flag_file
-      FileUtils.touch file
-
-      file_list = ["doc"]
-
-      output = @rdoc.normalized_file_list file_list
-
-      assert_empty output
-    end
-  end
-end
diff --git a/test/mri/rdoc/rdoc_require_test.rb b/test/mri/rdoc/rdoc_require_test.rb
deleted file mode 100644
index e90f8520a21..00000000000
--- a/test/mri/rdoc/rdoc_require_test.rb
+++ /dev/null
@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-require_relative 'xref_test_case'
-
-class RDocRequireTest < XrefTestCase
-
-  def setup
-    super
-
-    @req = RDoc::Require.new 'foo', 'comment'
-  end
-
-  def test_initialize
-    assert_equal 'foo', @req.name
-
-    RDoc::Require.new '"foo"', ''
-    assert_equal 'foo', @req.name
-
-    RDoc::Require.new '\'foo\'', ''
-    assert_equal 'foo', @req.name
-
-    RDoc::Require.new '|foo|', ''
-    assert_equal 'foo', @req.name, 'for fortran?'
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc_ri_driver_test.rb b/test/mri/rdoc/rdoc_ri_driver_test.rb
deleted file mode 100644
index 1cb459909a4..00000000000
--- a/test/mri/rdoc/rdoc_ri_driver_test.rb
+++ /dev/null
@@ -1,1610 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocRIDriverTest < RDoc::TestCase
-
-  def setup
-    super
-
-    @home_ri = File.join @test_home, 'dot_ri'
-
-    FileUtils.mkdir_p @home_ri
-
-    @orig_ri = ENV.delete('RI')
-    @rdoc_home = File.join @test_home, ".rdoc"
-    FileUtils.mkdir_p @rdoc_home
-
-    @options = RDoc::RI::Driver.default_options
-    @options[:use_system] = false
-    @options[:use_site]   = false
-    @options[:use_home]   = false
-    @options[:use_gems]   = false
-
-    @options[:home]       = @rdoc_home
-    @options[:use_stdout] = true
-    @options[:formatter]  = @RM::ToRdoc
-    @rdoc_options = RDoc::Options.new
-
-    @driver = RDoc::RI::Driver.new @options
-  end
-
-  def teardown
-    defined?(@orig_ri) and ENV['RI'] = @orig_ri
-
-    super
-  end
-
-  case RUBY_PLATFORM
-  when /mswin|mingw/
-    DUMMY_PAGER = "type nul"
-  else
-    DUMMY_PAGER = "true"
-  end
-
-  def with_dummy_pager
-    pager_env, ENV['RI_PAGER'] = ENV['RI_PAGER'], DUMMY_PAGER
-    yield
-  ensure
-    ENV['RI_PAGER'] = pager_env
-  end
-
-  def test_self_dump
-    util_store
-
-    out, = capture_output do
-      RDoc::RI::Driver.dump @store1.cache_path
-    end
-
-    assert_match %r%:class_methods|class_methods:%,       out
-    assert_match %r%:modules|modules:%,                   out
-    assert_match %r%:instance_methods|instance_methods:%, out
-    assert_match %r%:ancestors|ancestors:%,               out
-  end
-
-  def test_add_also_in_empty
-    out = @RM::Document.new
-
-    @driver.add_also_in out, []
-
-    assert_empty out
-  end
-
-  def test_add_also_in
-    util_multi_store
-    @store1.type = :system
-    @store2.type = :home
-
-    out = @RM::Document.new
-
-    @driver.add_also_in out, [@store1, @store2]
-
-    expected = @RM::Document.new(
-      @RM::Rule.new(1),
-      @RM::Paragraph.new('Also found in:'),
-      @RM::Verbatim.new("ruby core", "\n",
-                        @rdoc_home, "\n"))
-
-    assert_equal expected, out
-  end
-
-  def test_add_class
-    util_multi_store
-
-    out = @RM::Document.new
-
-    @driver.add_class out, 'Bar', [@cBar]
-
-    expected = @RM::Document.new(
-      @RM::Heading.new(1, 'Bar < Foo'),
-      @RM::BlankLine.new)
-
-    assert_equal expected, out
-  end
-
-  def test_add_from
-    util_store
-    @store1.type = :system
-
-    out = @RM::Document.new
-
-    @driver.add_from out, @store1
-
-    expected = @RM::Document.new @RM::Paragraph.new("(from ruby core)")
-
-    assert_equal expected, out
-  end
-
-  def test_add_extends
-    util_store
-
-    out = @RM::Document.new
-
-    @driver.add_extends out, [[[@cFooExt], @store1]]
-
-    expected = @RM::Document.new(
-      @RM::Rule.new(1),
-      @RM::Heading.new(1, "Extended by:"),
-      @RM::Paragraph.new("Ext (from #{@store1.friendly_path})"),
-      @RM::BlankLine.new,
-      @RM::Paragraph.new("Extend thingy"),
-      @RM::BlankLine.new)
-
-    assert_equal expected, out
-  end
-
-  def test_add_extension_modules_empty
-    out = @RM::Document.new
-
-    @driver.add_extension_modules out, 'Includes', []
-
-    assert_empty out
-  end
-
-  def test_add_extension_modules_many
-    util_store
-
-    out = @RM::Document.new
-
-    enum = RDoc::Include.new 'Enumerable', nil
-    @cFoo.add_include enum
-
-    @driver.add_extension_modules out, 'Includes', [[[@cFooInc, enum], @store1]]
-
-    expected = @RM::Document.new(
-      @RM::Rule.new(1),
-      @RM::Heading.new(1, "Includes:"),
-      @RM::Paragraph.new("(from #{@store1.friendly_path})"),
-      @RM::BlankLine.new,
-      @RM::Paragraph.new("Inc"),
-      @RM::BlankLine.new,
-      @RM::Paragraph.new("Include thingy"),
-      @RM::BlankLine.new,
-      @RM::Verbatim.new("Enumerable", "\n"))
-
-    assert_equal expected, out
-  end
-
-  def test_add_extension_modules_many_no_doc
-    util_store
-
-    out = @RM::Document.new
-
-    enum = RDoc::Include.new 'Enumerable', nil
-    @cFoo.add_include enum
-    @cFooInc.instance_variable_set :@comment, ''
-
-    @driver.add_extension_modules out, 'Includes', [[[@cFooInc, enum], @store1]]
-
-    expected = @RM::Document.new(
-      @RM::Rule.new(1),
-      @RM::Heading.new(1, "Includes:"),
-      @RM::Paragraph.new("(from #{@store1.friendly_path})"),
-      @RM::Verbatim.new("Inc", "\n",
-                        "Enumerable", "\n"))
-
-    assert_equal expected, out
-  end
-
-  def test_add_extension_modules_one
-    util_store
-
-    out = @RM::Document.new
-
-    @driver.add_extension_modules out, 'Includes', [[[@cFooInc], @store1]]
-
-    expected = @RM::Document.new(
-      @RM::Rule.new(1),
-      @RM::Heading.new(1, "Includes:"),
-      @RM::Paragraph.new("Inc (from #{@store1.friendly_path})"),
-      @RM::BlankLine.new,
-      @RM::Paragraph.new("Include thingy"),
-      @RM::BlankLine.new)
-
-    assert_equal expected, out
-  end
-
-  def test_add_includes
-    util_store
-
-    out = @RM::Document.new
-
-    @driver.add_includes out, [[[@cFooInc], @store1]]
-
-    expected = @RM::Document.new(
-      @RM::Rule.new(1),
-      @RM::Heading.new(1, "Includes:"),
-      @RM::Paragraph.new("Inc (from #{@store1.friendly_path})"),
-      @RM::BlankLine.new,
-      @RM::Paragraph.new("Include thingy"),
-      @RM::BlankLine.new)
-
-    assert_equal expected, out
-  end
-
-  def test_add_method
-    util_store
-
-    out = doc
-
-    @driver.add_method out, 'Foo::Bar#blah'
-
-    expected =
-      doc(
-        head(1, 'Foo::Bar#blah'),
-        blank_line,
-        para("(from #{@rdoc_home})"),
-        head(3, 'Implementation from Bar'),
-        rule(1),
-        verb("blah(5) => 5\n",
-             "blah(6) => 6\n"),
-        rule(1),
-        blank_line,
-        blank_line)
-
-    assert_equal expected, out
-  end
-
-  def test_add_method_with_rdoc_ref_link
-    util_store
-
-    out = doc
-
-    @driver.add_method out, 'Foo::Bar#blah_with_rdoc_ref'
-
-    expected =
-      doc(
-        head(1, 'Foo::Bar#blah_with_rdoc_ref'),
-        blank_line,
-        para("(from #{@rdoc_home})"),
-        head(3, 'Implementation from Bar'),
-        rule(1),
-        verb("blah(5) => 5\n", "See also {Doc}[rdoc-ref:README.rdoc]\n"),
-        rule(1),
-        blank_line,
-        blank_line
-      )
-
-    assert_equal expected, out
-  end
-
-  def test_add_method_that_is_alias_for_original
-    util_store
-
-    out = doc
-
-    @driver.add_method out, 'Qux#aliased'
-
-    expected =
-      doc(
-        head(1, 'Qux#aliased'),
-        blank_line,
-        para("(from #{@rdoc_home})"),
-        rule(1),
-        blank_line,
-        para('alias comment'),
-        blank_line,
-        blank_line,
-        para('(This method is an alias for Qux#original.)'),
-        blank_line,
-        para('original comment'),
-        blank_line,
-        blank_line)
-
-    assert_equal expected, out
-  end
-
-  def test_add_method_attribute
-    util_store
-
-    out = doc
-
-    @driver.add_method out, 'Foo::Bar#attr'
-
-    expected =
-      doc(
-        head(1, 'Foo::Bar#attr'),
-        blank_line,
-        para("(from #{@rdoc_home})"),
-        rule(1),
-        blank_line,
-        blank_line)
-
-    assert_equal expected, out
-  end
-
-  def test_add_method_inherited
-    util_multi_store
-
-    out = doc
-
-    @driver.add_method out, 'Bar#inherit'
-
-    expected =
-      doc(
-        head(1, 'Bar#inherit'),
-        blank_line,
-        para("(from #{@rdoc_home})"),
-        head(3, 'Implementation from Foo'),
-        rule(1),
-        blank_line,
-        blank_line)
-
-    assert_equal expected, out
-  end
-
-  def test_add_method_overridden
-    util_multi_store
-
-    out = doc
-
-    @driver.add_method out, 'Bar#override'
-
-    expected =
-      doc(
-        head(1, 'Bar#override'),
-        blank_line,
-        para("(from #{@store2.path})"),
-        rule(1),
-        blank_line,
-        para('must be displayed'),
-        blank_line,
-        blank_line)
-
-    assert_equal expected, out
-  end
-
-  def test_add_method_documentation
-    util_store
-
-    out = doc()
-
-    missing = RDoc::AnyMethod.new nil, 'missing'
-    @cFoo.add_method missing
-
-    @driver.add_method_documentation out, @cFoo
-
-    expected =
-      doc(
-        head(1, 'Foo#inherit'),
-        blank_line,
-        para("(from #{@rdoc_home})"),
-        rule(1),
-        blank_line,
-        blank_line,
-        head(1, 'Foo#override'),
-        blank_line,
-        para("(from #{@rdoc_home})"),
-        rule(1),
-        blank_line,
-        para('must not be displayed in Bar#override'),
-        blank_line,
-        blank_line)
-
-    assert_equal expected, out
-  end
-
-  def test_add_method_list
-    out = @RM::Document.new
-
-    @driver.add_method_list out, %w[new parse], 'Class methods'
-
-    expected = @RM::Document.new(
-      @RM::Heading.new(1, 'Class methods:'),
-      @RM::BlankLine.new,
-      @RM::Verbatim.new('new'),
-      @RM::Verbatim.new('parse'),
-      @RM::BlankLine.new)
-
-    assert_equal expected, out
-  end
-
-  def test_output_width
-    @options[:width] = 10
-    driver = RDoc::RI::Driver.new @options
-
-    doc = @RM::Document.new
-    doc << @RM::IndentedParagraph.new(0, 'new, parse, foo, bar, baz')
-
-    out, = capture_output do
-      driver.display doc
-    end
-
-    expected = "new, parse, foo,\nbar, baz\n"
-
-    assert_equal expected, out
-  end
-
-  def test_add_method_list_interative
-    @options[:interactive] = true
-    driver = RDoc::RI::Driver.new @options
-
-    out = @RM::Document.new
-
-    driver.add_method_list out, %w[new parse], 'Class methods'
-
-    expected = @RM::Document.new(
-      @RM::Heading.new(1, 'Class methods:'),
-      @RM::BlankLine.new,
-      @RM::IndentedParagraph.new(2, 'new, parse'),
-      @RM::BlankLine.new)
-
-    assert_equal expected, out
-  end
-
-  def test_add_method_list_none
-    out = @RM::Document.new
-
-    @driver.add_method_list out, [], 'Class'
-
-    assert_equal @RM::Document.new, out
-  end
-
-  def test_ancestors_of
-    util_ancestors_store
-
-    assert_equal %w[X Mixin Object Foo], @driver.ancestors_of('Foo::Bar')
-  end
-
-  def test_ancestors_of_chained_inclusion
-    # Store represents something like:
-    #
-    #   module X
-    #   end
-    #
-    #   module Y
-    #     include X
-    #   end
-    #
-    #   class Z
-    #     include Y
-    #   end
-    #
-    # Y is not chosen randomly, it has to be after Object in the alphabet
-    # to reproduce https://github.com/ruby/rdoc/issues/814.
-    store = RDoc::RI::Store.new(@rdoc_options, path: @home_ri)
-    store.cache[:ancestors] = { "Z" => ["Object", "Y"], "Y" => ["X"] }
-    store.cache[:modules] = %W[X Y Z]
-    @driver.stores = [store]
-
-    assert_equal %w[X Y Object], @driver.ancestors_of('Z')
-  end
-
-  def test_classes
-    util_multi_store
-
-    expected = {
-      'Ambiguous' => [@store1, @store2],
-      'Bar'       => [@store2],
-      'Ext'       => [@store1],
-      'Foo'       => [@store1, @store2],
-      'Foo::Bar'  => [@store1],
-      'Foo::Baz'  => [@store1, @store2],
-      'Inc'       => [@store1],
-      'Qux'       => [@store1],
-    }
-
-    classes = @driver.classes
-
-    assert_equal expected.keys.sort, classes.keys.sort
-
-    expected.each do |klass, stores|
-      assert_equal stores, classes[klass].sort_by { |store| store.path },
-                   "mismatch for #{klass}"
-    end
-  end
-
-  def test_class_document
-    util_store
-
-    tl1 = @store1.add_file 'one.rb'
-    tl2 = @store1.add_file 'two.rb'
-
-    @cFoo.add_comment 'one', tl1
-    @cFoo.add_comment 'two', tl2
-
-    @store1.save_class @cFoo
-
-    found = [
-      [@store1, @store1.load_class(@cFoo.full_name)]
-    ]
-
-    extends  = [[[@cFooExt], @store1]]
-    includes = [[[@cFooInc], @store1]]
-
-    out = @driver.class_document @cFoo.full_name, found, [], includes, extends
-
-    expected = @RM::Document.new
-    @driver.add_class expected, 'Foo', []
-    @driver.add_includes expected, includes
-    @driver.add_extends  expected, extends
-    @driver.add_from expected, @store1
-    expected << @RM::Rule.new(1)
-
-    doc = @RM::Document.new(@RM::Paragraph.new('one'))
-    doc.file = 'one.rb'
-    expected.push doc
-    expected << @RM::BlankLine.new
-    doc = @RM::Document.new(@RM::Paragraph.new('two'))
-    doc.file = 'two.rb'
-    expected.push doc
-
-    expected << @RM::Rule.new(1)
-    expected << @RM::Heading.new(1, 'Instance methods:')
-    expected << @RM::BlankLine.new
-    expected << @RM::Verbatim.new('inherit')
-    expected << @RM::Verbatim.new('override')
-    expected << @RM::BlankLine.new
-
-    assert_equal expected, out
-  end
-
-  def test_complete
-    store = RDoc::RI::Store.new(@rdoc_options, path: @home_ri)
-    store.cache[:ancestors] = {
-      'Foo'      => %w[Object],
-      'Foo::Bar' => %w[Object],
-    }
-    store.cache[:class_methods] = {
-      'Foo' => %w[bar]
-    }
-    store.cache[:instance_methods] = {
-      'Foo' => %w[Bar]
-    }
-    store.cache[:modules] = %w[
-      Foo
-      Foo::Bar
-    ]
-
-    @driver.stores = [store]
-
-    assert_equal %w[Foo         ], @driver.complete('F')
-    assert_equal %w[    Foo::Bar], @driver.complete('Foo::B')
-
-    assert_equal %w[Foo#Bar],           @driver.complete('Foo#'),   'Foo#'
-    assert_equal %w[Foo.Bar  Foo.bar],  @driver.complete('Foo.'),   'Foo.'
-    assert_equal %w[Foo::Bar Foo::bar], @driver.complete('Foo::'),  'Foo::'
-
-    assert_equal %w[         Foo::bar], @driver.complete('Foo::b'), 'Foo::b'
-  end
-
-  def test_complete_ancestor
-    util_ancestors_store
-
-    assert_equal %w[Foo::Bar#i_method], @driver.complete('Foo::Bar#')
-
-    assert_equal %w[Foo::Bar::c_method Foo::Bar::new], @driver.complete('Foo::Bar::')
-
-    assert_equal %w[Foo::Bar.c_method Foo::Bar.i_method Foo::Bar.new],
-                 @driver.complete('Foo::Bar.')
-  end
-
-  def test_complete_classes
-    util_store
-
-    assert_equal %w[                       ], @driver.complete('[')
-    assert_equal %w[                       ], @driver.complete('[::')
-    assert_equal %w[Foo                    ], @driver.complete('F')
-    assert_equal %w[Foo:: Foo::Bar Foo::Baz], @driver.complete('Foo::')
-    assert_equal %w[      Foo::Bar Foo::Baz], @driver.complete('Foo::B')
-  end
-
-  def test_complete_multistore
-    util_multi_store
-
-    assert_equal %w[Bar], @driver.complete('B')
-    assert_equal %w[Foo], @driver.complete('F')
-    assert_equal %w[Foo::Bar Foo::Baz], @driver.complete('Foo::B')
-  end
-
-  def test_display
-    doc = @RM::Document.new(
-            @RM::Paragraph.new('hi'))
-
-    out, = capture_output do
-      @driver.display doc
-    end
-
-    assert_equal "hi\n", out
-  end
-
-  def test_display_class
-    util_store
-
-    out, = capture_output do
-      @driver.display_class 'Foo::Bar'
-    end
-
-    assert_match %r%^= Foo::Bar%, out
-    assert_match %r%^\(from%, out
-
-    assert_match %r%^= Class methods:%, out
-    assert_match %r%^  new%, out
-    assert_match %r%^= Instance methods:%, out
-    assert_match %r%^  blah%, out
-    assert_match %r%^= Attributes:%, out
-    assert_match %r%^  attr_accessor attr%, out
-
-    assert_equal 2, out.scan(/^-{50,}$/).length, out
-
-    refute_match %r%Foo::Bar#blah%, out
-  end
-
-  def test_display_class_all
-    util_store
-
-    @driver.show_all = true
-
-    out, = capture_output do
-      @driver.display_class 'Foo::Bar'
-    end
-
-    assert_match %r%^= Foo::Bar%, out
-    assert_match %r%^\(from%, out
-
-    assert_match %r%^= Class methods:%, out
-    assert_match %r%^  new%, out
-    assert_match %r%^= Instance methods:%, out
-    assert_match %r%^  blah%, out
-    assert_match %r%^= Attributes:%, out
-    assert_match %r%^  attr_accessor attr%, out
-
-    assert_equal 9, out.scan(/^-{50,}$/).length, out
-
-    assert_match %r%Foo::Bar#blah%, out
-    assert_match %r%Foo::Bar#blah_with_rdoc_ref%, out
-    # From Foo::Bar and Foo::Bar#blah_with_rdoc_ref
-    assert_equal 2, out.scan(/rdoc-ref:README.rdoc/).length
-    # But README.rdoc should only be displayed once
-    assert_equal 1, out.scan(/Expanded from README.rdoc/).length
-  end
-
-  def test_rdoc_refs_expansion_can_be_disabled
-    util_store
-
-    @driver.instance_variable_set :@expand_rdoc_refs, false
-
-    out, = capture_output do
-      @driver.display_class 'Foo::Bar'
-    end
-
-    # From Foo::Bar
-    assert_equal 1, out.scan(/rdoc-ref:README.rdoc/).length
-    # But README.rdoc should not be expanded
-    assert_empty out.scan(/Expanded from README.rdoc/)
-  end
-
-  def test_display_class_ambiguous
-    util_multi_store
-
-    out, = capture_output do
-      @driver.display_class 'Ambiguous'
-    end
-
-    assert_match %r%^= Ambiguous < Object$%, out
-  end
-
-  def test_display_class_multi_no_doc
-    util_multi_store
-
-    out, = capture_output do
-      @driver.display_class 'Foo::Baz'
-    end
-
-    assert_match %r%^= Foo::Baz%, out
-    assert_match %r%-\n%, out
-    assert_match %r%Also found in:%, out
-    assert_match %r%#{Regexp.escape @home_ri}%, out
-    assert_match %r%#{Regexp.escape @home_ri2}%, out
-  end
-
-  def test_display_class_superclass
-    util_multi_store
-
-    out, = capture_output do
-      @driver.display_class 'Bar'
-    end
-
-    assert_match %r%^= Bar < Foo%, out
-  end
-
-  def test_display_class_module
-    util_store
-
-    out, = capture_output do
-      @driver.display_class 'Inc'
-    end
-
-    assert_match %r%^= Inc$%, out
-  end
-
-  def test_display_class_page
-    out, = capture_output do
-      @driver.display_class 'ruby:README'
-    end
-
-    assert_empty out
-  end
-
-  def test_display_method
-    util_store
-
-    out, = capture_output do
-      @driver.display_method 'Foo::Bar#blah'
-    end
-
-    assert_match %r%Foo::Bar#blah%, out
-    assert_match %r%blah.5%,        out
-    assert_match %r%blah.6%,        out
-  end
-
-  def test_display_method_attribute
-    util_store
-
-    out, = capture_output do
-      @driver.display_method 'Foo::Bar#attr'
-    end
-
-    assert_match %r%Foo::Bar#attr%, out
-    refute_match %r%Implementation from%, out
-  end
-
-  def test_display_method_inherited
-    util_multi_store
-
-    out, = capture_output do
-      @driver.display_method 'Bar#inherit'
-    end
-
-    assert_match %r%^= Bar#inherit%, out
-    assert_match %r%^=== Implementation from Foo%, out
-  end
-
-  def test_display_method_overridden
-    util_multi_store
-
-    out, = capture_output do
-      @driver.display_method 'Bar#override'
-    end
-
-    refute_match %r%must not be displayed%, out
-  end
-
-  def test_display_name
-    util_store
-
-    out, = capture_output do
-      assert_equal true, @driver.display_name('home:README.rdoc')
-    end
-
-    expected = <<-EXPECTED
-= README
-This is a README
-    EXPECTED
-
-    assert_equal expected, out
-  end
-
-  def test_display_name_not_found_class
-    util_store
-
-    out, = capture_output do
-      assert_equal false, @driver.display_name('Foo::B')
-    end
-
-    expected = <<-EXPECTED
-Foo::B not found, maybe you meant:
-
-Foo::Bar
-Foo::Baz
-    EXPECTED
-
-    assert_equal expected, out
-  end
-
-  def test_display_name_not_found_method
-    util_store
-
-    out, = capture_output do
-      assert_equal false, @driver.display_name('Foo::Bar#b')
-    end
-
-    expected = <<-EXPECTED
-Foo::Bar#b not found, maybe you meant:
-
-Foo::Bar#blah
-Foo::Bar#blah_with_rdoc_ref
-Foo::Bar#bother
-    EXPECTED
-
-    assert_equal expected, out
-  end
-
-  def test_display_name_not_found_special
-    util_store
-
-    assert_raise RDoc::RI::Driver::NotFoundError do
-      assert_equal false, @driver.display_name('Set#[]')
-    end
-  end
-
-  def test_display_method_params
-    util_store
-
-    out, = capture_output do
-      @driver.display_method 'Foo::Bar#bother'
-    end
-
-    assert_match %r%things.*stuff%, out
-  end
-
-  def test_display_page
-    util_store
-
-    out, = capture_output do
-      @driver.display_page 'home:README.rdoc'
-    end
-
-    assert_match %r%= README%, out
-  end
-
-  def test_display_page_add_extension
-    util_store
-
-    out, = capture_output do
-      @driver.display_page 'home:README'
-    end
-
-    assert_match %r%= README%, out
-  end
-
-  def test_display_page_ambiguous
-    util_store
-
-    other = @store1.add_file 'README.md'
-    other.parser = RDoc::Parser::Simple
-    other.comment =
-      RDoc::Comment.from_document(doc(
-        head(1, 'README.md'),
-        para('This is the other README')))
-
-    @store1.save_page other
-
-    out, = capture_output do
-      @driver.display_page 'home:README'
-    end
-
-    assert_match %r%= README pages in #{@rdoc_home}%, out
-    assert_match %r%README\.rdoc%,               out
-    assert_match %r%README\.md%,                 out
-  end
-
-  def test_display_page_extension
-    util_store
-
-    other = @store1.add_file 'README.EXT'
-    other.parser = RDoc::Parser::Simple
-    other.comment =
-      RDoc::Comment.from_document(doc(
-        head(1, 'README.EXT'),
-        para('This is the other README')))
-
-    @store1.save_page other
-
-    out, = capture_output do
-      @driver.display_page 'home:README.EXT'
-    end
-
-    assert_match 'other README', out
-  end
-
-  def test_display_page_ignore_directory
-    util_store
-
-    other = @store1.add_file 'doc/globals.rdoc'
-    other.parser = RDoc::Parser::Simple
-    other.comment =
-      RDoc::Comment.from_document(doc(
-        head(1, 'globals.rdoc'),
-        para('Globals go here')))
-
-    @store1.save_page other
-
-    out, = capture_output do
-      @driver.display_page 'home:globals'
-    end
-
-    assert_match %r%= globals\.rdoc%, out
-  end
-
-  def test_display_page_missing
-    util_store
-
-    out, = capture_output do
-      @driver.display_page 'home:missing'
-    end
-
-    out, = capture_output do
-      @driver.display_page_list @store1
-    end
-
-    assert_match %r%= Pages in #{@rdoc_home}%, out
-    assert_match %r%README\.rdoc%,        out
-  end
-
-  def test_display_page_list
-    util_store
-
-    other = @store1.add_file 'OTHER.rdoc'
-    other.parser = RDoc::Parser::Simple
-    other.comment =
-      RDoc::Comment.from_document(doc(
-        head(1, 'OTHER'),
-        para('This is OTHER')))
-
-    @store1.save_page other
-
-    out, = capture_output do
-      @driver.display_page_list @store1
-    end
-
-    assert_match %r%= Pages in #{@rdoc_home}%, out
-    assert_match %r%README\.rdoc%,        out
-    assert_match %r%OTHER\.rdoc%,         out
-  end
-
-  def test_expand_class
-    util_store
-
-    assert_equal 'Foo',       @driver.expand_class('F')
-    assert_equal 'Foo::Bar',  @driver.expand_class('F::Bar')
-
-    assert_raise RDoc::RI::Driver::NotFoundError do
-      @driver.expand_class 'F::B'
-    end
-  end
-
-  def test_expand_class_2
-    @store1 = RDoc::RI::Store.new(@rdoc_options, path: @home_ri, type: :home)
-
-    @top_level = @store1.add_file 'file.rb'
-
-    @cFoo = @top_level.add_class RDoc::NormalClass, 'Foo'
-    @mFox = @top_level.add_module RDoc::NormalModule, 'Fox'
-    @cFoo_Bar = @cFoo.add_class RDoc::NormalClass, 'Bar'
-    @store1.save
-
-    @driver.stores = [@store1]
-    assert_raise RDoc::RI::Driver::NotFoundError do
-      @driver.expand_class 'F'
-    end
-    assert_equal 'Foo::Bar',  @driver.expand_class('F::Bar')
-    assert_equal 'Foo::Bar',  @driver.expand_class('F::B')
-  end
-
-  def test_expand_class_3
-    @store1 = RDoc::RI::Store.new(@rdoc_options, path: @home_ri, type: :home)
-
-    @top_level = @store1.add_file 'file.rb'
-
-    @cFoo = @top_level.add_class RDoc::NormalClass, 'Foo'
-    @mFox = @top_level.add_module RDoc::NormalModule, 'FooBar'
-    @store1.save
-
-    @driver.stores = [@store1]
-
-    assert_equal 'Foo',  @driver.expand_class('Foo')
-  end
-
-  def test_expand_name
-    util_store
-
-    assert_equal '.b',        @driver.expand_name('b')
-    assert_equal 'Foo',       @driver.expand_name('F')
-    assert_equal 'Foo::Bar#', @driver.expand_name('F::Bar#')
-
-    e = assert_raise RDoc::RI::Driver::NotFoundError do
-      @driver.expand_name 'Z'
-    end
-
-    assert_equal 'Z', e.name
-
-    @driver.stores << RDoc::Store.new(@rdoc_options, type: :system)
-
-    assert_equal 'ruby:README', @driver.expand_name('ruby:README')
-    assert_equal 'ruby:',       @driver.expand_name('ruby:')
-
-    e = assert_raise RDoc::RI::Driver::NotFoundError do
-      @driver.expand_name 'nonexistent_gem:'
-    end
-
-    assert_equal 'nonexistent_gem', e.name
-  end
-
-  def test_find_methods
-    util_store
-
-    items = []
-
-    @driver.find_methods 'Foo::Bar.' do |store, klass, ancestor, types, method|
-      items << [store, klass, ancestor, types, method]
-    end
-
-    expected = [
-      [@store1, 'Foo::Bar', 'Foo::Bar', :both, nil],
-    ]
-
-    assert_equal expected, items
-  end
-
-  def test_find_methods_method
-    util_store
-
-    items = []
-
-    @driver.find_methods '.blah' do |store, klass, ancestor, types, method|
-      items << [store, klass, ancestor, types, method]
-    end
-
-    expected = [
-      [@store1, 'Ambiguous', 'Ambiguous', :both, 'blah'],
-      [@store1, 'Ext',       'Ext',       :both, 'blah'],
-      [@store1, 'Foo',       'Foo',       :both, 'blah'],
-      [@store1, 'Foo::Bar',  'Foo::Bar',  :both, 'blah'],
-      [@store1, 'Foo::Baz',  'Foo::Baz',  :both, 'blah'],
-      [@store1, 'Inc',       'Inc',       :both, 'blah'],
-      [@store1, 'Qux',       'Qux',       :both, 'blah'],
-    ]
-
-    assert_equal expected, items
-  end
-
-  def test_filter_methods
-    util_multi_store
-
-    name = 'Bar#override'
-
-    found = @driver.load_methods_matching name
-
-    sorted = @driver.filter_methods found, name
-
-    expected = [[@store2, [@override]]]
-
-    assert_equal expected, sorted
-  end
-
-  def test_filter_methods_not_found
-    util_multi_store
-
-    name = 'Bar#inherit'
-
-    found = @driver.load_methods_matching name
-
-    sorted = @driver.filter_methods found, name
-
-    assert_equal found, sorted
-  end
-
-  def test_find_store
-    @driver.stores << RDoc::Store.new(@rdoc_options, type: :system)
-    @driver.stores << RDoc::Store.new(@rdoc_options, path: 'doc/gem-1.0/ri', type: :gem)
-
-    assert_equal 'ruby',    @driver.find_store('ruby')
-    assert_equal 'gem-1.0', @driver.find_store('gem-1.0')
-    assert_equal 'gem-1.0', @driver.find_store('gem')
-
-    e = assert_raise RDoc::RI::Driver::NotFoundError do
-      @driver.find_store 'nonexistent'
-    end
-
-    assert_equal 'nonexistent', e.name
-  end
-
-  def test_did_you_mean
-    omit 'skip test with did_you_men' unless defined? DidYouMean::SpellChecker
-
-    util_ancestors_store
-
-    e = assert_raise RDoc::RI::Driver::NotFoundError do
-      @driver.lookup_method 'Foo.i_methdo'
-    end
-    assert_equal "Nothing known about Foo.i_methdo\nDid you mean?  i_method", e.message
-
-    e = assert_raise RDoc::RI::Driver::NotFoundError do
-      @driver.lookup_method 'Foo#i_methdo'
-    end
-    assert_equal "Nothing known about Foo#i_methdo\nDid you mean?  i_method", e.message
-
-    e = assert_raise RDoc::RI::Driver::NotFoundError do
-      @driver.lookup_method 'Foo::i_methdo'
-    end
-    assert_equal "Nothing known about Foo::i_methdo\nDid you mean?  c_method", e.message
-  end
-
-  def test_formatter
-    tty = Object.new
-    def tty.tty?() true; end
-
-    @options.delete :use_stdout
-    @options.delete :formatter
-
-    driver = RDoc::RI::Driver.new @options
-
-    assert_instance_of @RM::ToAnsi, driver.formatter(tty)
-
-    assert_instance_of @RM::ToBs, driver.formatter(StringIO.new)
-
-    driver.instance_variable_set :@paging, true
-
-    assert_instance_of @RM::ToBs, driver.formatter(StringIO.new)
-  end
-
-  def test_method_type
-    assert_equal :both,     @driver.method_type(nil)
-    assert_equal :both,     @driver.method_type('.')
-    assert_equal :instance, @driver.method_type('#')
-    assert_equal :class,    @driver.method_type('::')
-  end
-
-  def test_name_regexp
-    assert_equal %r%^RDoc::AnyMethod#new$%,
-                 @driver.name_regexp('RDoc::AnyMethod#new')
-
-    assert_equal %r%^RDoc::AnyMethod::new$%,
-                 @driver.name_regexp('RDoc::AnyMethod::new')
-
-    assert_equal %r%^RDoc::AnyMethod(#|::)new$%,
-                 @driver.name_regexp('RDoc::AnyMethod.new')
-
-    assert_equal %r%^Hash(#|::)\[\]$%,
-                 @driver.name_regexp('Hash.[]')
-
-    assert_equal %r%^Hash::\[\]$%,
-                 @driver.name_regexp('Hash::[]')
-  end
-
-  def test_list_known_classes
-    util_store
-
-    out, = capture_output do
-      @driver.list_known_classes
-    end
-
-    assert_equal "Ambiguous\nExt\nFoo\nFoo::Bar\nFoo::Baz\nInc\nQux\n", out
-  end
-
-  def test_list_known_classes_name
-    util_store
-
-    out, = capture_output do
-      @driver.list_known_classes %w[F I]
-    end
-
-    assert_equal "Foo\nFoo::Bar\nFoo::Baz\nInc\n", out
-  end
-
-  def test_list_methods_matching
-    util_store
-
-    assert_equal %w[
-        Foo::Bar#attr
-        Foo::Bar#blah
-        Foo::Bar#blah_with_rdoc_ref
-        Foo::Bar#bother
-        Foo::Bar::new
-      ],
-      @driver.list_methods_matching('Foo::Bar.').sort
-  end
-
-  def test_list_methods_matching_inherit
-    util_multi_store
-
-    assert_equal %w[
-        Bar#baz
-        Bar#inherit
-        Bar#override
-      ],
-      @driver.list_methods_matching('Bar.').sort
-  end
-
-  def test_list_methods_matching_regexp
-    util_store
-
-    index = RDoc::AnyMethod.new nil, '[]'
-    index.record_location @top_level
-    @cFoo.add_method index
-    @store1.save_method @cFoo, index
-
-    c_index = RDoc::AnyMethod.new nil, '[]', singleton: true
-    c_index.record_location @top_level
-    @cFoo.add_method c_index
-    @store1.save_method @cFoo, c_index
-
-    @store1.save_cache
-
-    assert_equal %w[Foo#[]], @driver.list_methods_matching('Foo#[]')
-    assert_equal %w[Foo::[]], @driver.list_methods_matching('Foo::[]')
-  end
-
-  def test_load_method
-    util_store
-
-    method = @driver.load_method(@store1, :instance_methods, 'Foo', '#',
-                                 'inherit')
-
-    assert_equal @inherit, method
-  end
-
-  def test_load_method_inherited
-    util_multi_store
-
-    method = @driver.load_method(@store2, :instance_methods, 'Bar', '#',
-                                 'inherit')
-
-    assert_nil method
-  end
-
-  def test_load_methods_matching
-    util_store
-
-    expected = [[@store1, [@inherit]]]
-
-    assert_equal expected, @driver.load_methods_matching('Foo#inherit')
-
-    expected = [[@store1, [@blah]]]
-
-    assert_equal expected, @driver.load_methods_matching('.blah')
-
-    assert_empty @driver.load_methods_matching('.b')
-  end
-
-  def test_load_methods_matching_inherited
-    util_multi_store
-
-    expected = [[@store1, [@inherit]]]
-
-    assert_equal expected, @driver.load_methods_matching('Bar#inherit')
-  end
-
-  def test_load_method_missing
-    util_store
-
-    FileUtils.rm @store1.method_file 'Foo', '#inherit'
-
-    method = @driver.load_method(@store1, :instance_methods, 'Foo', '#',
-                                 'inherit')
-
-    assert_equal '(unknown)#inherit', method.full_name
-  end
-
-  def test_page
-    @driver.use_stdout = false
-
-    with_dummy_pager do
-      @driver.page do |io|
-        omit "couldn't find a standard pager" if io == $stdout
-
-        assert @driver.paging?
-      end
-    end
-
-    refute @driver.paging?
-  end
-
-  def test_page_in_presence_of_child_status
-    @driver.use_stdout = false
-
-    with_dummy_pager do
-      @driver.page do |io|
-        refute_equal $stdout, io
-        assert @driver.paging?
-      end
-    end
-  end
-
-  def test_page_stdout
-    @driver.use_stdout = true
-
-    @driver.page do |io|
-      assert_equal $stdout, io
-    end
-
-    refute @driver.paging?
-  end
-
-  def test_parse_name_method
-    klass, type, meth = @driver.parse_name 'foo'
-
-    assert_equal '',    klass, 'foo class'
-    assert_equal '.',   type,  'foo type'
-    assert_equal 'foo', meth,  'foo method'
-
-    klass, type, meth = @driver.parse_name '#foo'
-
-    assert_equal '',    klass, '#foo class'
-    assert_equal '#',   type,  '#foo type'
-    assert_equal 'foo', meth,  '#foo method'
-
-    klass, type, meth = @driver.parse_name '::foo'
-
-    assert_equal '',    klass, '::foo class'
-    assert_equal '::',  type,  '::foo type'
-    assert_equal 'foo', meth,  '::foo method'
-  end
-
-  def test_parse_name_page
-    klass, type, meth = @driver.parse_name 'ruby:README'
-
-    assert_equal 'ruby',   klass, 'ruby project'
-    assert_equal ':',      type,  'ruby type'
-    assert_equal 'README', meth,  'ruby page'
-
-    klass, type, meth = @driver.parse_name 'ruby:'
-
-    assert_equal 'ruby',   klass, 'ruby project'
-    assert_equal ':',      type,  'ruby type'
-    assert_nil             meth,  'ruby page'
-  end
-
-  def test_parse_name_page_extenson
-    klass, type, meth = @driver.parse_name 'ruby:README.EXT'
-
-    assert_equal 'ruby',      klass, 'ruby project'
-    assert_equal ':',         type,  'ruby type'
-    assert_equal 'README.EXT', meth,  'ruby page'
-  end
-
-  def test_parse_name_single_class
-    klass, type, meth = @driver.parse_name 'Foo'
-
-    assert_equal 'Foo', klass, 'Foo class'
-    assert_nil          type,  'Foo type'
-    assert_nil          meth,  'Foo method'
-
-    klass, type, meth = @driver.parse_name 'Foo#'
-
-    assert_equal 'Foo', klass, 'Foo# class'
-    assert_equal '#',   type,  'Foo# type'
-    assert_nil          meth,  'Foo# method'
-
-    klass, type, meth = @driver.parse_name 'Foo::'
-
-    assert_equal 'Foo', klass, 'Foo:: class'
-    assert_equal '::',  type,  'Foo:: type'
-    assert_nil          meth,  'Foo:: method'
-
-    klass, type, meth = @driver.parse_name 'Foo.'
-
-    assert_equal 'Foo', klass, 'Foo. class'
-    assert_equal '.',   type,  'Foo. type'
-    assert_nil          meth,  'Foo. method'
-
-    klass, type, meth = @driver.parse_name 'Foo#Bar'
-
-    assert_equal 'Foo', klass, 'Foo#Bar class'
-    assert_equal '#',   type,  'Foo#Bar type'
-    assert_equal 'Bar', meth,  'Foo#Bar method'
-
-    klass, type, meth = @driver.parse_name 'Foo.Bar'
-
-    assert_equal 'Foo', klass, 'Foo.Bar class'
-    assert_equal '.',   type,  'Foo.Bar type'
-    assert_equal 'Bar', meth,  'Foo.Bar method'
-
-    klass, type, meth = @driver.parse_name 'Foo::bar'
-
-    assert_equal 'Foo', klass, 'Foo::bar class'
-    assert_equal '::',  type,  'Foo::bar type'
-    assert_equal 'bar', meth,  'Foo::bar method'
-  end
-
-  def test_parse_name_namespace
-    klass, type, meth = @driver.parse_name 'Foo::Bar'
-
-    assert_equal 'Foo::Bar', klass, 'Foo::Bar class'
-    assert_nil               type,  'Foo::Bar type'
-    assert_nil               meth,  'Foo::Bar method'
-
-    klass, type, meth = @driver.parse_name 'Foo::Bar#'
-
-    assert_equal 'Foo::Bar', klass, 'Foo::Bar# class'
-    assert_equal '#',        type,  'Foo::Bar# type'
-    assert_nil               meth,  'Foo::Bar# method'
-
-    klass, type, meth = @driver.parse_name 'Foo::Bar#baz'
-
-    assert_equal 'Foo::Bar', klass, 'Foo::Bar#baz class'
-    assert_equal '#',        type,  'Foo::Bar#baz type'
-    assert_equal 'baz',      meth,  'Foo::Bar#baz method'
-  end
-
-  def test_parse_name_special
-    specials = %w[
-      %
-      &
-      *
-      +
-      +@
-      -
-      -@
-      /
-      <
-      <<
-      <=
-      <=>
-      ==
-      ===
-      =>
-      =~
-      >
-      >>
-      []
-      []=
-      ^
-      `
-      |
-      ~
-      ~@
-    ]
-
-    specials.each do |special|
-      parsed = @driver.parse_name special
-
-      assert_equal ['', '.', special], parsed
-    end
-  end
-
-  def test_setup_pager # this test doesn't do anything anymore :(
-    @driver.use_stdout = false
-
-    pager = with_dummy_pager do @driver.setup_pager end
-
-    omit "couldn't find a standard pager" unless pager
-
-    assert @driver.paging?
-  ensure
-    pager.close if pager
-  end
-
-  def util_ancestors_store
-    store1 = RDoc::RI::Store.new(@rdoc_options, path: @home_ri)
-    store1.cache[:ancestors] = {
-      'Foo'      => %w[Object],
-      'Foo::Bar' => %w[Foo],
-    }
-    store1.cache[:class_methods] = {
-      'Foo'      => %w[c_method new],
-      'Foo::Bar' => %w[new],
-    }
-    store1.cache[:instance_methods] = {
-      'Foo' => %w[i_method],
-    }
-    store1.cache[:modules] = %w[
-      Foo
-      Foo::Bar
-    ]
-
-    store2 = RDoc::RI::Store.new(@rdoc_options, path: @home_ri)
-    store2.cache[:ancestors] = {
-      'Foo'    => %w[Mixin Object],
-      'Mixin'  => %w[],
-      'Object' => %w[X Object],
-      'X'      => %w[Object],
-    }
-    store2.cache[:class_methods] = {
-      'Foo'    => %w[c_method new],
-      'Mixin'  => %w[],
-      'X'      => %w[],
-      'Object' => %w[],
-    }
-    store2.cache[:instance_methods] = {
-      'Foo'   => %w[i_method],
-      'Mixin' => %w[],
-    }
-    store2.cache[:modules] = %w[
-      Foo
-      Mixin
-      Object
-      X
-    ]
-
-    @driver.stores = store1, store2
-  end
-
-  def util_multi_store
-    util_store
-
-    @home_ri2 = "#{@home_ri}2"
-    @store2 = RDoc::RI::Store.new(@rdoc_options, path: @home_ri2)
-
-    @top_level = @store2.add_file 'file.rb'
-
-    # as if seen in a namespace like class Ambiguous::Other
-    @mAmbiguous = @top_level.add_module RDoc::NormalModule, 'Ambiguous'
-
-    @cFoo = @top_level.add_class RDoc::NormalClass, 'Foo'
-
-    @cBar = @top_level.add_class RDoc::NormalClass, 'Bar', 'Foo'
-    @cFoo_Baz = @cFoo.add_class RDoc::NormalClass, 'Baz'
-
-    @baz = @cBar.add_method RDoc::AnyMethod.new(nil, 'baz')
-    @baz.record_location @top_level
-
-    @override = @cBar.add_method RDoc::AnyMethod.new(nil, 'override')
-    @override.comment = 'must be displayed'
-    @override.record_location @top_level
-
-    @store2.save
-
-    @driver.stores = [@store1, @store2]
-  end
-
-  def util_store
-    @store1 = RDoc::RI::Store.new(@rdoc_options, path: @home_ri, type: :home)
-
-    @top_level = @store1.add_file 'file.rb'
-
-    @readme = @store1.add_file 'README.rdoc'
-    @readme.parser = RDoc::Parser::Simple
-    @readme.comment = RDoc::Comment.from_document(doc(head(1, 'README'), para('This is a README')))
-
-    @cFoo = @top_level.add_class RDoc::NormalClass, 'Foo'
-    @mExt = @top_level.add_module RDoc::NormalModule, 'Ext'
-    @mInc = @top_level.add_module RDoc::NormalModule, 'Inc'
-    @cAmbiguous = @top_level.add_class RDoc::NormalClass, 'Ambiguous'
-
-    doc = @RM::Document.new @RM::Paragraph.new('Extend thingy')
-    @cFooExt = @cFoo.add_extend RDoc::Extend.new('Ext', RDoc::Comment.from_document(doc))
-    @cFooExt.record_location @top_level
-    doc = @RM::Document.new @RM::Paragraph.new('Include thingy')
-    @cFooInc = @cFoo.add_include RDoc::Include.new('Inc', RDoc::Comment.from_document(doc))
-    @cFooInc.record_location @top_level
-
-    @cFoo_Bar = @cFoo.add_class RDoc::NormalClass, 'Bar'
-    @cFoo_Bar.add_comment "See also {Doc}[rdoc-ref:README.rdoc]", @top_level
-    @cFoo_Bar.record_location @top_level
-
-    @blah = @cFoo_Bar.add_method RDoc::AnyMethod.new(nil, 'blah')
-    @blah.call_seq = "blah(5) => 5\nblah(6) => 6\n"
-    @blah.record_location @top_level
-
-    @blah_with_rdoc_ref = @cFoo_Bar.add_method RDoc::AnyMethod.new(nil, 'blah_with_rdoc_ref')
-    @blah_with_rdoc_ref.call_seq = "blah(5) => 5\nSee also {Doc}[rdoc-ref:README.rdoc]"
-    @blah_with_rdoc_ref.record_location @top_level
-
-    @bother = @cFoo_Bar.add_method RDoc::AnyMethod.new(nil, 'bother')
-    @bother.block_params = "stuff"
-    @bother.params = "(things)"
-    @bother.record_location @top_level
-
-    @new = @cFoo_Bar.add_method RDoc::AnyMethod.new nil, 'new', singleton: true
-    @new.record_location @top_level
-
-    @attr = @cFoo_Bar.add_attribute RDoc::Attr.new nil, 'attr', 'RW', ''
-    @attr.record_location @top_level
-
-    @cFoo_Baz = @cFoo.add_class RDoc::NormalClass, 'Baz'
-    @cFoo_Baz.record_location @top_level
-
-    @inherit = @cFoo.add_method RDoc::AnyMethod.new(nil, 'inherit')
-    @inherit.record_location @top_level
-
-    # overridden by Bar in multi_store
-    @overridden = @cFoo.add_method RDoc::AnyMethod.new(nil, 'override')
-    @overridden.comment = 'must not be displayed in Bar#override'
-    @overridden.record_location @top_level
-
-    @cQux = @top_level.add_class RDoc::NormalClass, 'Qux'
-
-    @original = @cQux.add_method RDoc::AnyMethod.new(nil, 'original')
-    @original.comment = 'original comment'
-    @original.record_location @top_level
-
-    @aliased = @original.add_alias RDoc::Alias.new(nil, 'original', 'aliased', 'alias comment'), @cQux
-    @aliased.record_location @top_level
-
-    @store1.save
-
-    @driver.stores = [@store1]
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc_ri_paths_test.rb b/test/mri/rdoc/rdoc_ri_paths_test.rb
deleted file mode 100644
index 7a9fc6fde4f..00000000000
--- a/test/mri/rdoc/rdoc_ri_paths_test.rb
+++ /dev/null
@@ -1,157 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocRIPathsTest < RDoc::TestCase
-
-  def setup
-    super
-
-    @orig_env = ENV.to_hash
-    @orig_gem_path = Gem.path
-
-    @tempdir = File.join Dir.tmpdir, "test_rdoc_ri_paths_#{$$}"
-    Gem.use_paths @tempdir
-    Gem.ensure_gem_subdirectories @tempdir
-
-    specs = [
-      @rake_10   = Gem::Specification.new('rake', '10.0.1'),
-      @rdoc_4_0  = Gem::Specification.new('rdoc', '4.0'),
-      @rdoc_3_12 = Gem::Specification.new('rdoc', '3.12'),
-      @nodoc     = Gem::Specification.new('nodoc', '1.0'),
-    ]
-
-    specs.each do |spec|
-      spec.loaded_from = spec.spec_file
-
-      File.open spec.spec_file, 'w' do |file|
-        file.write spec.to_ruby_for_cache
-      end
-
-      FileUtils.mkdir_p File.join(spec.doc_dir, 'ri') unless
-        spec.name == 'nodoc'
-    end
-
-    Gem::Specification.reset
-    Gem::Specification.all = specs
-  end
-
-  def teardown
-    Gem.use_paths(*@orig_gem_path)
-    Gem::Specification.reset
-    FileUtils.rm_rf @tempdir
-    ENV.replace(@orig_env)
-
-    super
-  end
-
-  def test_class_each
-    enum = RDoc::RI::Paths.each true, true, true, :all
-
-    path = enum.map { |dir,| dir }
-
-    assert_equal RDoc::RI::Paths.system_dir,          path.shift
-    assert_equal RDoc::RI::Paths.site_dir,            path.shift
-    assert_equal RDoc::RI::Paths.home_dir,            path.shift if RDoc::RI::Paths.home_dir
-    assert_equal File.join(@nodoc.doc_dir, 'ri'),     path.shift
-    assert_equal File.join(@rake_10.doc_dir, 'ri'),   path.shift
-    assert_equal File.join(@rdoc_4_0.doc_dir, 'ri'),  path.shift
-    assert_equal File.join(@rdoc_3_12.doc_dir, 'ri'), path.shift
-    assert_empty path
-  end
-
-  def test_class_gemdirs_latest
-    Dir.chdir @tempdir do
-      gemdirs = RDoc::RI::Paths.gemdirs :latest
-
-      expected = [
-        File.join(@rake_10.doc_dir, 'ri'),
-        File.join(@rdoc_4_0.doc_dir, 'ri'),
-      ]
-
-      assert_equal expected, gemdirs
-    end
-  end
-
-  def test_class_gemdirs_legacy
-    Dir.chdir @tempdir do
-      gemdirs = RDoc::RI::Paths.gemdirs true
-
-      expected = [
-        File.join(@rake_10.doc_dir, 'ri'),
-        File.join(@rdoc_4_0.doc_dir, 'ri'),
-      ]
-
-      assert_equal expected, gemdirs
-    end
-  end
-
-  def test_class_gemdirs_all
-    Dir.chdir @tempdir do
-      gemdirs = RDoc::RI::Paths.gemdirs :all
-
-      expected = [
-        File.join(@nodoc.doc_dir,     'ri'),
-        File.join(@rake_10.doc_dir,   'ri'),
-        File.join(@rdoc_4_0.doc_dir,  'ri'),
-        File.join(@rdoc_3_12.doc_dir, 'ri'),
-      ]
-
-      assert_equal expected, gemdirs
-    end
-  end
-
-  def test_class_gem_dir
-    dir = RDoc::RI::Paths.gem_dir 'rake', '10.0.1'
-
-    expected = File.join @rake_10.doc_dir, 'ri'
-
-    assert_equal expected, dir
-  end
-
-  def test_class_home_dir
-    dir = RDoc::RI::Paths.home_dir
-
-    assert_equal RDoc::RI::Paths::HOMEDIR, dir
-  end
-
-  def test_class_path_nonexistent
-    temp_dir do |dir|
-      nonexistent = File.join dir, 'nonexistent'
-      dir = RDoc::RI::Paths.path true, true, true, true, nonexistent
-
-      refute_includes dir, nonexistent
-    end
-  end
-
-  def test_class_raw_path
-    path = RDoc::RI::Paths.raw_path true, true, true, true
-
-    assert_equal RDoc::RI::Paths.system_dir,        path.shift
-    assert_equal RDoc::RI::Paths.site_dir,          path.shift
-    assert_equal RDoc::RI::Paths.home_dir,          path.shift if RDoc::RI::Paths.home_dir
-    assert_equal File.join(@rake_10.doc_dir, 'ri'), path.shift
-  end
-
-  def test_class_raw_path_extra_dirs
-    path = RDoc::RI::Paths.raw_path true, true, true, true, '/nonexistent'
-
-    assert_equal '/nonexistent',                    path.shift
-    assert_equal RDoc::RI::Paths.system_dir,        path.shift
-    assert_equal RDoc::RI::Paths.site_dir,          path.shift
-    assert_equal RDoc::RI::Paths.home_dir,          path.shift if RDoc::RI::Paths.home_dir
-    assert_equal File.join(@rake_10.doc_dir, 'ri'), path.shift
-  end
-
-  def test_class_site_dir
-    dir = RDoc::RI::Paths.site_dir
-
-    assert_equal File.join(RDoc::RI::Paths::BASE, 'site'), dir
-  end
-
-  def test_class_system_dir
-    dir = RDoc::RI::Paths.system_dir
-
-    assert_equal File.join(RDoc::RI::Paths::BASE, 'system'), dir
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc_rubygems_hook_test.rb b/test/mri/rdoc/rdoc_rubygems_hook_test.rb
deleted file mode 100644
index 99194c59d85..00000000000
--- a/test/mri/rdoc/rdoc_rubygems_hook_test.rb
+++ /dev/null
@@ -1,329 +0,0 @@
-# frozen_string_literal: true
-require 'rubygems'
-require 'fileutils'
-require 'tmpdir'
-require_relative '../../lib/rdoc/rubygems_hook'
-require 'test/unit'
-
-class RDocRubyGemsHookTest < Test::Unit::TestCase
-  def setup
-    @a = Gem::Specification.new do |s|
-      s.platform    = Gem::Platform::RUBY
-      s.name        = "a"
-      s.version     = 2
-      s.rdoc_options = %w[--main MyTitle]
-      s.extra_rdoc_files = %w[README]
-    end
-    @tempdir = File.realpath(Dir.mktmpdir("test_rubygems_hook_"))
-
-    @orig_envs = %w[
-      GEM_VENDOR
-      GEMRC
-      XDG_CACHE_HOME
-      XDG_CONFIG_HOME
-      XDG_DATA_HOME
-      SOURCE_DATE_EPOCH
-      BUNDLER_VERSION
-      HOME
-      RDOCOPT
-    ].map {|e| [e, ENV.delete(e)]}.to_h
-    ENV["HOME"] = @tempdir
-
-    Gem.configuration = nil
-
-    @a.instance_variable_set(:@doc_dir, File.join(@tempdir, "doc"))
-    @a.instance_variable_set(:@gem_dir, File.join(@tempdir, "a-2"))
-    @a.instance_variable_set(:@full_gem_path, File.join(@tempdir, "a-2"))
-    @a.loaded_from = File.join(@tempdir, 'a-2', 'a-2.gemspec')
-
-    FileUtils.mkdir_p File.join(@tempdir, 'a-2', 'lib')
-    FileUtils.touch   File.join(@tempdir, 'a-2', 'README')
-    File.open(File.join(@tempdir, 'a-2', 'lib', 'a.rb'), 'w') do |f|
-      f.puts '# comment'
-      f.puts '# :include: include.txt'
-      f.puts 'class A; end'
-    end
-    File.open(File.join(@tempdir, 'a-2', 'include.txt'), 'w') do |f|
-      f.puts 'included content'
-    end
-
-    @hook = RDoc::RubyGemsHook.new @a
-
-    begin
-      RDoc::RubyGemsHook.load_rdoc
-    rescue Gem::DocumentError => e
-      omit e.message
-    end
-    @old_ui = Gem::DefaultUserInteraction.ui
-    Gem::DefaultUserInteraction.ui = Gem::SilentUI.new
-  end
-
-  def teardown
-    ui = Gem::DefaultUserInteraction.ui
-    Gem::DefaultUserInteraction.ui = @old_ui
-    FileUtils.rm_rf @tempdir
-    ui.close
-    ENV.update(@orig_envs)
-  end
-
-  def test_initialize
-    refute @hook.generate_rdoc
-    assert @hook.generate_ri
-
-    rdoc = RDoc::RubyGemsHook.new @a, false, false
-
-    refute rdoc.generate_rdoc
-    refute rdoc.generate_ri
-  end
-
-  def test_delete_legacy_args
-    args = %w[
-      --inline-source
-      --one-file
-      --promiscuous
-      -p
-    ]
-
-    @hook.delete_legacy_args args
-
-    assert_empty args
-  end
-
-  def test_document
-    options = RDoc::Options.new
-    options.files = []
-
-    rdoc = @hook.new_rdoc
-    rdoc.store = RDoc::Store.new(options)
-    @hook.instance_variable_set :@rdoc, rdoc
-    @hook.instance_variable_set :@file_info, []
-
-    @hook.document 'darkfish', options, @a.doc_dir('rdoc')
-
-    assert @hook.rdoc_installed?
-  end
-
-  def test_generate
-    FileUtils.mkdir_p @a.doc_dir
-    FileUtils.mkdir_p File.join(@a.gem_dir, 'lib')
-
-    @hook.generate
-
-    refute @hook.rdoc_installed?
-    assert @hook.ri_installed?
-
-    rdoc = @hook.instance_variable_get :@rdoc
-
-    refute rdoc.options.hyperlink_all
-    assert_equal Pathname(@a.full_gem_path), rdoc.options.root
-    assert_equal %w[README lib], rdoc.options.files.sort
-
-    assert_equal 'MyTitle', rdoc.store.main
-
-    klass = rdoc.store.find_class_named('A')
-    refute_nil klass
-    assert_includes klass.comment.text, 'included content'
-  end
-
-  def test_generate_all
-    @hook.generate_rdoc = true
-    @hook.generate_ri   = true
-
-    FileUtils.mkdir_p @a.doc_dir
-    FileUtils.mkdir_p File.join(@a.gem_dir, 'lib')
-
-    @hook.generate
-
-    assert @hook.rdoc_installed?
-    assert @hook.ri_installed?
-
-    rdoc = @hook.instance_variable_get :@rdoc
-
-    refute rdoc.options.hyperlink_all
-    assert_equal Pathname(@a.full_gem_path), rdoc.options.root
-    assert_equal %w[README lib], rdoc.options.files.sort
-
-    assert_equal 'MyTitle', rdoc.store.main
-  end
-
-  def test_generate_configuration_rdoc_array
-    Gem.configuration[:rdoc] = %w[-A]
-
-    FileUtils.mkdir_p @a.doc_dir
-    FileUtils.mkdir_p File.join(@a.gem_dir, 'lib')
-
-    @hook.generate
-
-    rdoc = @hook.instance_variable_get :@rdoc
-
-    assert rdoc.options.hyperlink_all
-  end
-
-  def test_generate_configuration_rdoc_string
-    Gem.configuration[:rdoc] = '-A'
-
-    FileUtils.mkdir_p @a.doc_dir
-    FileUtils.mkdir_p File.join(@a.gem_dir, 'lib')
-
-    @hook.generate
-
-    rdoc = @hook.instance_variable_get :@rdoc
-
-    assert rdoc.options.hyperlink_all
-  end
-
-  def test_generate_default_gem
-    Gem::Deprecate.skip_during do
-      if Gem.respond_to?(:default_specifications_dir)
-        klass = Gem
-      else
-        klass = Gem::Specification
-      end
-      @a.loaded_from = File.join klass.default_specifications_dir, 'a.gemspec'
-    end
-
-    @hook.generate
-
-    refute @hook.rdoc_installed?
-    refute @hook.ri_installed?
-  end
-
-  def test_generate_disabled
-    @hook.generate_rdoc = false
-    @hook.generate_ri   = false
-
-    @hook.generate
-
-    refute @hook.rdoc_installed?
-    refute @hook.ri_installed?
-  end
-
-  def test_generate_force
-    FileUtils.mkdir_p @a.doc_dir 'ri'
-    FileUtils.mkdir_p @a.doc_dir 'rdoc'
-    FileUtils.mkdir_p File.join(@a.gem_dir, 'lib')
-
-    @hook.force = true
-
-    @hook.generate
-
-    assert_path_not_exist File.join(@a.doc_dir('rdoc'), 'index.html')
-    assert_path_exist File.join(@a.doc_dir('ri'),   'cache.ri')
-  end
-
-  def test_generate_rubygems_compatible
-    original_default_gem_method = RDoc::RubygemsHook.method(:default_gem?)
-    RDoc::RubygemsHook.singleton_class.remove_method(:default_gem?)
-    RDoc::RubygemsHook.define_singleton_method(:default_gem?) { true }
-    FileUtils.mkdir_p @a.doc_dir 'ri'
-    FileUtils.mkdir_p @a.doc_dir 'rdoc'
-    FileUtils.mkdir_p File.join(@a.gem_dir, 'lib')
-
-    # rubygems/lib/rubygems/commands/rdoc_command.rb calls this
-    hook = RDoc::RubygemsHook.new @a, true, true
-    hook.force = true
-    hook.generate
-
-    assert_path_exist File.join(@a.doc_dir('rdoc'), 'index.html')
-  ensure
-    RDoc::RubygemsHook.singleton_class.remove_method(:default_gem?)
-    RDoc::RubygemsHook.define_singleton_method(:default_gem?, &original_default_gem_method)
-  end
-
-  def test_generate_no_overwrite
-    FileUtils.mkdir_p @a.doc_dir 'ri'
-    FileUtils.mkdir_p @a.doc_dir 'rdoc'
-    FileUtils.mkdir_p File.join(@a.gem_dir, 'lib')
-
-    @hook.generate
-
-    assert_path_not_exist File.join(@a.doc_dir('rdoc'), 'index.html')
-    assert_path_not_exist File.join(@a.doc_dir('ri'),   'cache.ri')
-  end
-
-  def test_generate_with_ri_opt
-    @a.rdoc_options << '--ri'
-    FileUtils.mkdir_p @a.doc_dir
-    FileUtils.mkdir_p File.join(@a.gem_dir, 'lib')
-    @hook.generate_rdoc = true
-    @hook.generate_ri   = true
-    @hook.generate
-
-    assert_path_exist File.join(@a.doc_dir('rdoc'), 'index.html')
-    assert_path_exist File.join(@a.doc_dir('ri'),   'cache.ri')
-  end
-
-  def test_new_rdoc
-    assert_kind_of RDoc::RDoc, @hook.new_rdoc
-  end
-
-  def test_rdoc_installed?
-    refute @hook.rdoc_installed?
-
-    FileUtils.mkdir_p @a.doc_dir 'rdoc'
-
-    assert @hook.rdoc_installed?
-  end
-
-  def test_remove
-    FileUtils.mkdir_p @a.doc_dir 'rdoc'
-    FileUtils.mkdir_p @a.doc_dir 'ri'
-
-    @hook.remove
-
-    refute @hook.rdoc_installed?
-    refute @hook.ri_installed?
-
-    assert_path_exist @a.doc_dir
-  end
-
-  def test_remove_unwritable
-    omit 'chmod not supported' if Gem.win_platform?
-    omit "assumes that euid is not root" if Process.euid == 0
-
-    FileUtils.mkdir_p @a.base_dir
-    FileUtils.chmod 0, @a.base_dir
-
-    e = assert_raise Gem::FilePermissionError do
-      @hook.remove
-    end
-
-    assert_equal @a.base_dir, e.directory
-  ensure
-    FileUtils.chmod(0755, @a.base_dir) if File.directory?(@a.base_dir)
-  end
-
-  def test_ri_installed?
-    refute @hook.ri_installed?
-
-    FileUtils.mkdir_p @a.doc_dir 'ri'
-
-    assert @hook.ri_installed?
-  end
-
-  def test_setup
-    @hook.setup
-
-    assert_path_exist @a.doc_dir
-  end
-
-  def test_setup_unwritable
-    omit 'chmod not supported' if Gem.win_platform?
-    omit "assumes that euid is not root" if Process.euid == 0
-
-    FileUtils.mkdir_p @a.doc_dir
-    FileUtils.chmod 0, @a.doc_dir
-
-    e = assert_raise Gem::FilePermissionError do
-      @hook.setup
-    end
-
-    assert_equal @a.doc_dir, e.directory
-  ensure
-    if File.exist? @a.doc_dir
-      FileUtils.chmod 0755, @a.doc_dir
-      FileUtils.rm_r @a.doc_dir
-    end
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc_servlet_test.rb b/test/mri/rdoc/rdoc_servlet_test.rb
deleted file mode 100644
index 825abdf4ab7..00000000000
--- a/test/mri/rdoc/rdoc_servlet_test.rb
+++ /dev/null
@@ -1,553 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-begin
-  require 'webrick'
-rescue LoadError
-end
-
-class RDocServletTest < RDoc::TestCase
-
-  def setup
-    super
-
-    @orig_gem_path = Gem.path
-
-    @tempdir = File.join Dir.tmpdir, "test_rdoc_servlet_#{$$}"
-    Gem.use_paths @tempdir
-    Gem.ensure_gem_subdirectories @tempdir
-
-    @spec = Gem::Specification.new 'spec', '1.0'
-    @spec.loaded_from = @spec.spec_file
-
-    Gem::Specification.reset
-    Gem::Specification.all = [@spec]
-
-    @server = {}
-    def @server.mount(*) end
-
-    @stores = {}
-    @cache  = Hash.new { |hash, store| hash[store] = {} }
-
-    @extra_dirs = [File.join(@tempdir, 'extra1'), File.join(@tempdir, 'extra2')]
-
-    @s = RDoc::Servlet.new @server, @stores, @cache, nil, @extra_dirs
-
-    @req = WEBrick::HTTPRequest.new :Logger => nil
-    @res = WEBrick::HTTPResponse.new :HTTPVersion => '1.0'
-
-    def @req.path=(path)
-      instance_variable_set :@path, path
-    end
-
-    @req.instance_variable_set :@header, Hash.new { |h, k| h[k] = [] }
-
-    @base        = File.join @tempdir, 'base'
-    @system_dir  = File.join @tempdir, 'base', 'system'
-    @home_dir    = File.join @tempdir, 'home'
-    @gem_doc_dir = File.join @tempdir, 'doc'
-    @options     = RDoc::Options.new
-
-    @orig_base = RDoc::RI::Paths::BASE
-    RDoc::RI::Paths::BASE.replace @base
-    @orig_ri_path_homedir = RDoc::RI::Paths::HOMEDIR
-    RDoc::RI::Paths.send :remove_const, :HOMEDIR
-    RDoc::RI::Paths.const_set :HOMEDIR, @home_dir
-
-    RDoc::RI::Paths.instance_variable_set \
-      :@gemdirs, %w[/nonexistent/gems/example-1.0/ri]
-  end
-
-  def teardown
-    super
-
-    Gem.use_paths(*@orig_gem_path)
-    Gem::Specification.reset
-
-    FileUtils.rm_rf @tempdir
-
-    RDoc::RI::Paths::BASE.replace @orig_base
-    RDoc::RI::Paths.send :remove_const, :HOMEDIR
-    RDoc::RI::Paths.const_set :HOMEDIR, @orig_ri_path_homedir
-    RDoc::RI::Paths.instance_variable_set :@gemdirs, nil
-  end
-
-  def test_asset
-    temp_dir do
-      FileUtils.mkdir 'css'
-
-      now = Time.now
-      File.open 'css/rdoc.css', 'w' do |io| io.write 'h1 { color: red }' end
-      File.utime now, now, 'css/rdoc.css'
-
-      @s.asset_dirs[:darkfish] = '.'
-
-      @req.path = '/css/rdoc.css'
-
-      @s.asset :darkfish, @req, @res
-
-      assert_equal 'h1 { color: red }', @res.body
-      assert_equal 'text/css',          @res.content_type
-      assert_equal now.httpdate,        @res['last-modified']
-    end
-  end
-
-  def test_do_GET
-    touch_system_cache_path
-
-    @req.path = '/ruby/Missing.html'
-
-    @s.do_GET @req, @res
-
-    assert_equal 404, @res.status
-  end
-
-  def test_do_GET_asset_darkfish
-    temp_dir do
-      FileUtils.mkdir 'css'
-      FileUtils.touch 'css/rdoc.css'
-
-      @s.asset_dirs[:darkfish] = '.'
-
-      @req.path = '/css/rdoc.css'
-
-      @s.do_GET @req, @res
-
-      assert_equal 'text/css',          @res.content_type
-    end
-  end
-
-  def test_do_GET_asset_json_index
-    temp_dir do
-      FileUtils.mkdir 'js'
-      FileUtils.touch 'js/navigation.js'
-
-      @s.asset_dirs[:json_index] = '.'
-
-      @req.path = '/js/navigation.js'
-
-      @s.do_GET @req, @res
-
-      assert_equal 'application/javascript', @res.content_type
-    end
-  end
-
-  def test_do_GET_error
-    touch_system_cache_path
-
-    def @req.path() raise 'no' end
-
-    @s.do_GET @req, @res
-
-    assert_equal 500, @res.status
-  end
-
-  def test_do_GET_mount_path
-    @s = RDoc::Servlet.new @server, @stores, @cache, '/mount/path'
-
-    temp_dir do
-      FileUtils.mkdir 'css'
-      FileUtils.touch 'css/rdoc.css'
-
-      @s.asset_dirs[:darkfish] = '.'
-
-      @req.path = '/mount/path/css/rdoc.css'.dup
-
-      @s.do_GET @req, @res
-
-      assert_equal 'text/css', @res.content_type
-    end
-  end
-
-  def do_GET_not_found
-    touch_system_cache_path
-
-    @req.path = "/#{@spec.full_name}"
-
-    @s.do_GET @req, @res
-
-    assert_equal 404, @res.status
-  end
-
-  def test_do_GET_not_modified
-    touch_system_cache_path
-    @req.header['if-modified-since'] = [(Time.now + 10).httpdate]
-    @req.path = '/ruby/Missing.html'
-
-    assert_raise WEBrick::HTTPStatus::NotModified do
-      @s.do_GET @req, @res
-    end
-  end
-
-  def test_do_GET_root
-    touch_system_cache_path
-
-    @req.path = '/'
-
-    @s.do_GET @req, @res
-
-    assert_equal 'text/html',                                 @res.content_type
-    assert_match %r%<title>Local RDoc Documentation</title>%, @res.body
-  end
-
-  def test_do_GET_root_search
-    touch_system_cache_path
-
-    @req.path = '/js/search_index.js'
-
-    @s.do_GET @req, @res
-
-    assert_equal 'application/javascript', @res.content_type, @res.body
-  end
-
-  def test_documentation_page_class
-    store = RDoc::Store.new(@options)
-
-    generator = @s.generator_for store
-
-    file      = store.add_file 'file.rb'
-    klass     = file.add_class RDoc::NormalClass, 'Klass'
-                klass.add_class RDoc::NormalClass, 'Sub'
-
-    @s.documentation_page store, generator, 'Klass::Sub.html', @req, @res
-
-    assert_match %r%<title>class Klass::Sub - </title>%,            @res.body
-    assert_match %r%<body id="top" role="document" class="class">%, @res.body
-  end
-
-  def test_documentation_page_not_found
-    store = RDoc::Store.new(@options)
-
-    generator = @s.generator_for store
-
-    @req.path = '/ruby/Missing.html'
-
-    @s.documentation_page store, generator, 'Missing.html', @req, @res
-
-    assert_equal 404, @res.status
-  end
-
-  def test_documentation_page_page
-    store = RDoc::Store.new(@options)
-
-    generator = @s.generator_for store
-
-    store.add_file 'README.rdoc', parser: RDoc::Parser::Simple
-
-    @s.documentation_page store, generator, 'README_rdoc.html', @req, @res
-
-    assert_match %r%<title>README - </title>%, @res.body
-    assert_match %r%<body [^>]+ class="file">%,      @res.body
-  end
-
-  def test_documentation_page_page_with_nesting
-    store = RDoc::Store.new(@options)
-
-    generator = @s.generator_for store
-
-    store.add_file 'nesting/README.rdoc', parser: RDoc::Parser::Simple
-
-    @s.documentation_page store, generator, 'nesting/README_rdoc.html', @req, @res
-
-    assert_equal 200, @res.status
-  end
-
-  def test_documentation_source
-    store, path = @s.documentation_source '/ruby/Object.html'
-
-    assert_equal @system_dir, store.path
-
-    assert_equal 'Object.html', path
-  end
-
-  def test_documentation_source_cached
-    cached_store = RDoc::Store.new(@options)
-
-    @stores['ruby'] = cached_store
-
-    store, path = @s.documentation_source '/ruby/Object.html'
-
-    assert_same cached_store, store
-
-    assert_equal 'Object.html', path
-  end
-
-  def test_error
-    e = RuntimeError.new 'foo'
-    e.set_backtrace caller
-
-    @s.error e, @req, @res
-
-    assert_equal 'text/html',      @res.content_type
-    assert_equal 500,              @res.status
-    assert_match %r%<title>Error%, @res.body
-  end
-
-  def test_generator_for
-    store = RDoc::Store.new(@options)
-    store.main  = 'MAIN_PAGE.rdoc'
-    store.title = 'Title'
-
-    generator = @s.generator_for store
-
-    refute generator.file_output
-
-    assert_equal '..', generator.asset_rel_path
-
-    assert_equal 'MAIN_PAGE.rdoc', @s.options.main_page
-    assert_equal 'Title',          @s.options.title
-  end
-
-  def test_if_modified_since
-    omit 'File.utime on directory not supported' if Gem.win_platform?
-
-    temp_dir do
-      now = Time.now
-      File.utime now, now, '.'
-
-      @s.if_modified_since @req, @res, '.'
-
-      assert_equal now.to_i, Time.parse(@res['last-modified']).to_i
-    end
-  end
-
-  def test_if_modified_since_not_modified
-    omit 'File.utime on directory not supported' if Gem.win_platform?
-
-    temp_dir do
-      now = Time.now
-      File.utime now, now, '.'
-
-      @req.header['if-modified-since'] = [(now + 10).httpdate]
-
-      assert_raise WEBrick::HTTPStatus::NotModified do
-        @s.if_modified_since @req, @res, '.'
-      end
-
-      assert_equal now.to_i, Time.parse(@res['last-modified']).to_i
-    end
-  end
-
-  def test_installed_docs
-    touch_system_cache_path
-    touch_extra_cache_path
-
-    expected = [
-      ['My Extra Documentation', 'extra-1/', true, :extra,
-        @extra_dirs[0]],
-      ['Extra Documentation', 'extra-2/', false, :extra,
-        @extra_dirs[1]],
-      ['Ruby Documentation', 'ruby/', true,  :system,
-        @system_dir],
-      ['Site Documentation', 'site/', false, :site,
-        File.join(@base, 'site')],
-      ['Home Documentation', 'home/', false, :home,
-        RDoc::RI::Paths::HOMEDIR],
-      ['spec-1.0', 'spec-1.0/',       false, :gem,
-        File.join(@spec.doc_dir, 'ri')],
-    ]
-
-    assert_equal expected, @s.installed_docs
-  end
-
-  def test_not_found
-    generator = @s.generator_for RDoc::Store.new(@options)
-
-    @req.path = '/ruby/Missing.html'
-
-    @s.not_found generator, @req, @res
-
-    assert_equal 404,                                @res.status
-    assert_match %r%<title>Not Found</title>%,       @res.body
-    assert_match %r%<kbd>/ruby/Missing\.html</kbd>%, @res.body
-  end
-
-  def test_not_found_message
-    generator = @s.generator_for RDoc::Store.new(@options)
-
-    @req.path = '/ruby/Missing.html'
-
-    @s.not_found generator, @req, @res, 'woo, this is a message'
-
-    assert_equal 404,                          @res.status
-    assert_match %r%<title>Not Found</title>%, @res.body
-    assert_match %r%woo, this is a message%,   @res.body
-  end
-
-  def test_ri_paths
-    paths = @s.ri_paths
-
-    expected = [
-      [@extra_dirs[0],                 :extra],
-      [@extra_dirs[1],                 :extra],
-      [@system_dir,                    :system],
-      [File.join(@base, 'site'),       :site],
-      [RDoc::RI::Paths::HOMEDIR,       :home],
-      [File.join(@spec.doc_dir, 'ri'), :gem],
-    ]
-
-    assert_equal expected, paths.to_a
-  end
-
-  def test_root
-    @s.root @req, @res
-
-    assert_equal 'text/html',                                 @res.content_type
-    assert_match %r%<title>Local RDoc Documentation</title>%, @res.body
-  end
-
-  def test_root_search
-    touch_system_cache_path
-    touch_extra_cache_path
-
-    @s.root_search @req, @res
-
-    assert_equal 'application/javascript', @res.content_type
-
-    @res.body =~ /\{.*\}/
-
-    index = JSON.parse $&
-
-    expected = {
-      'index' => {
-        'searchIndex' => %w[
-          My\ Extra\ Documentation
-          Ruby\ Documentation
-        ],
-        'longSearchIndex' => %w[
-          My\ Extra\ Documentation
-          Ruby\ Documentation
-        ],
-        'info' => [
-          ['My Extra Documentation', '', @extra_dirs[0], '',
-            'My Extra Documentation'],
-          ['Ruby Documentation', '', 'ruby', '',
-            'Documentation for the Ruby standard library'],
-        ],
-      }
-    }
-
-    assert_equal expected, index
-  end
-
-  def test_show_documentation_index
-    touch_system_cache_path
-
-    @req.path = '/ruby'
-
-    @s.show_documentation @req, @res
-
-    assert_equal 'text/html',                               @res.content_type
-    assert_match %r%<title>Standard Library Documentation%, @res.body
-  end
-
-  def test_show_documentation_table_of_contents
-    touch_system_cache_path
-
-    @req.path = '/ruby/table_of_contents.html'
-
-    @s.show_documentation @req, @res
-
-    assert_equal 'text/html',         @res.content_type
-    assert_match %r%<title>Table of Contents - Standard Library Documentation%,
-                 @res.body
-  end
-
-  def test_show_documentation_page
-    touch_system_cache_path
-
-    @req.path = '/ruby/Missing.html'
-
-    @s.show_documentation @req, @res
-
-    assert_equal 404, @res.status
-  end
-
-  def test_show_documentation_search_index
-    touch_system_cache_path
-
-    @req.path = '/ruby/js/search_index.js'
-
-    @s.show_documentation @req, @res
-
-    assert_equal 'application/javascript', @res.content_type
-    assert_match %r%\Avar search_data =%,  @res.body
-  end
-
-  def test_store_for_gem
-    ri_dir = File.join @gem_doc_dir, 'spec-1.0', 'ri'
-    FileUtils.mkdir_p ri_dir
-    FileUtils.touch File.join ri_dir, 'cache.ri'
-
-    store = @s.store_for 'spec-1.0'
-
-    assert_equal File.join(@gem_doc_dir, 'spec-1.0', 'ri'), store.path
-    assert_equal :gem, store.type
-  end
-
-  def test_store_for_home
-    store = @s.store_for 'home'
-
-    assert_equal @home_dir, store.path
-    assert_equal :home, store.type
-  end
-
-  def test_store_for_missing_documentation
-    FileUtils.mkdir_p(File.join @gem_doc_dir, 'spec-1.0', 'ri')
-
-    e = assert_raise WEBrick::HTTPStatus::NotFound do
-      @s.store_for 'spec-1.0'
-    end
-
-    assert_equal 'Could not find documentation for "spec-1.0". Please run `gem rdoc --ri gem_name`',
-                 e.message
-  end
-
-  def test_store_for_missing_gem
-    e = assert_raise WEBrick::HTTPStatus::NotFound do
-      @s.store_for 'missing'
-    end
-
-    assert_equal 'Could not find gem "missing". Are you sure you installed it?',
-                 e.message
-  end
-
-  def test_store_for_ruby
-    store = @s.store_for 'ruby'
-
-    assert_equal @system_dir, store.path
-    assert_equal :system, store.type
-  end
-
-  def test_store_for_site
-    store = @s.store_for 'site'
-
-    assert_equal File.join(@base, 'site'), store.path
-    assert_equal :site, store.type
-  end
-
-  def test_store_for_extra
-    store = @s.store_for 'extra-1'
-
-    assert_equal @extra_dirs.first, store.path
-    assert_equal :extra, store.type
-  end
-
-  def touch_system_cache_path
-    store = RDoc::Store.new(@options, path: @system_dir)
-    store.title = 'Standard Library Documentation'
-
-    FileUtils.mkdir_p File.dirname store.cache_path
-
-    store.save
-  end
-
-  def touch_extra_cache_path
-    store = RDoc::Store.new(@options, path: @extra_dirs.first)
-    store.title = 'My Extra Documentation'
-
-    FileUtils.mkdir_p File.dirname store.cache_path
-
-    store.save
-  end
-
-end if defined?(WEBrick)
diff --git a/test/mri/rdoc/rdoc_single_class_test.rb b/test/mri/rdoc/rdoc_single_class_test.rb
deleted file mode 100644
index 6bbc5a2bd45..00000000000
--- a/test/mri/rdoc/rdoc_single_class_test.rb
+++ /dev/null
@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocSingleClassTest < RDoc::TestCase
-
-  def setup
-    super
-
-    @c = RDoc::SingleClass.new 'C'
-  end
-
-  def test_aref_prefix
-    assert_equal 'sclass', @c.aref_prefix
-  end
-
-  def test_definition
-    assert_equal 'class << C', @c.definition
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc_stats_test.rb b/test/mri/rdoc/rdoc_stats_test.rb
deleted file mode 100644
index 1f02e460c39..00000000000
--- a/test/mri/rdoc/rdoc_stats_test.rb
+++ /dev/null
@@ -1,720 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocStatsTest < RDoc::TestCase
-
-  def setup
-    super
-
-    @s = RDoc::Stats.new @store, 0
-
-    @tl = @store.add_file 'file.rb'
-    @tl.parser = RDoc::Parser::Ruby
-  end
-
-  def test_doc_stats
-    c = RDoc::CodeObject.new
-
-    assert_equal [1, 1], @s.doc_stats([c])
-  end
-
-  def test_doc_stats_documented
-    c = RDoc::CodeObject.new
-    c.comment = comment 'x'
-
-    assert_equal [1, 0], @s.doc_stats([c])
-  end
-
-  def test_doc_stats_display_eh
-    c = RDoc::CodeObject.new
-    c.ignore
-
-    assert_equal [0, 0], @s.doc_stats([c])
-  end
-
-  def test_report_attr
-    c = @tl.add_class RDoc::NormalClass, 'C'
-    c.record_location @tl
-    c.add_comment 'C', @tl
-
-    a = RDoc::Attr.new nil, 'a', 'RW', nil
-    a.record_location @tl
-    c.add_attribute a
-
-    @store.complete :public
-
-    report = @s.report
-
-    expected =
-      doc(
-        para('The following items are not documented:'),
-        blank_line,
-        verb(
-          "class C # is documented\n",
-          "\n",
-          "  attr_accessor :a # in file file.rb\n",
-          "\n",
-          "end\n"),
-        blank_line)
-
-    assert_equal expected, report
-  end
-
-  def test_report_attr_documented
-    c = @tl.add_class RDoc::NormalClass, 'C'
-    c.record_location @tl
-    c.add_comment 'C', @tl
-
-    a = RDoc::Attr.new nil, 'a', 'RW', 'a'
-    a.record_location @tl
-    c.add_attribute a
-
-    @store.complete :public
-
-    report = @s.report
-
-    assert_equal @s.great_job, report
-  end
-
-  def test_report_attr_line
-    c = @tl.add_class RDoc::NormalClass, 'C'
-    c.record_location @tl
-    c.add_comment 'C', @tl
-
-    a = RDoc::Attr.new nil, 'a', 'RW', nil
-    a.record_location @tl
-    a.line = 3
-    c.add_attribute a
-
-    @store.complete :public
-
-    assert_match '# in file file.rb:3', @s.report.accept(to_rdoc)
-  end
-
-  def test_report_constant
-    m = @tl.add_module RDoc::NormalModule, 'M'
-    m.record_location @tl
-    m.add_comment 'M', @tl
-
-    c = RDoc::Constant.new 'C', nil, nil
-    c.record_location @tl
-    m.add_constant c
-
-    @store.complete :public
-
-    report = @s.report
-
-    expected =
-      doc(
-        para('The following items are not documented:'),
-        blank_line,
-        verb(
-          "module M # is documented\n",
-          "\n",
-          "  # in file file.rb\n",
-          "  C = nil\n",
-          "\n",
-          "end\n"),
-        blank_line)
-
-    assert_equal expected, report
-  end
-
-  def test_report_constant_alias
-    mod = @tl.add_module RDoc::NormalModule, 'M'
-
-    c = @tl.add_class RDoc::NormalClass, 'C'
-    mod.add_constant c
-
-    ca = RDoc::Constant.new 'CA', nil, nil
-    ca.is_alias_for = c
-
-    @tl.add_constant ca
-
-    @store.complete :public
-
-    report = @s.report
-
-    # TODO change this to refute match, aliases should be ignored as they are
-    # programmer convenience constructs
-    assert_match 'class Object', report.accept(to_rdoc)
-  end
-
-  def test_report_constant_documented
-    m = @tl.add_module RDoc::NormalModule, 'M'
-    m.record_location @tl
-    m.add_comment 'M', @tl
-
-    c = RDoc::Constant.new 'C', nil, 'C'
-    c.record_location @tl
-    m.add_constant c
-
-    @store.complete :public
-
-    report = @s.report
-
-    assert_equal @s.great_job, report
-  end
-
-  def test_report_constant_line
-    m = @tl.add_module RDoc::NormalModule, 'M'
-    m.record_location @tl
-    m.add_comment 'M', @tl
-
-    c = RDoc::Constant.new 'C', nil, nil
-    c.record_location @tl
-    c.line = 5
-    m.add_constant c
-
-    @store.complete :public
-
-    assert_match '# in file file.rb:5', @s.report.accept(to_rdoc)
-  end
-
-  def test_report_class
-    c = @tl.add_class RDoc::NormalClass, 'C'
-    c.record_location @tl
-
-    m = RDoc::AnyMethod.new nil, 'm'
-    m.record_location @tl
-    c.add_method m
-    m.comment = 'm'
-
-    @store.complete :public
-
-    report = @s.report
-
-    expected =
-      doc(
-        para('The following items are not documented:'),
-        blank_line,
-        para('In files:'),
-        list(:BULLET, *[
-          item(nil, para('file.rb'))]),
-        blank_line,
-        verb("class C\n", "end\n"),
-        blank_line)
-
-    assert_equal expected, report
-  end
-
-  def test_report_skip_object
-    c = @tl.add_class RDoc::NormalClass, 'Object'
-    c.record_location @tl
-
-    m = RDoc::AnyMethod.new nil, 'm'
-    m.record_location @tl
-    c.add_method m
-    m.comment = 'm'
-
-    @store.complete :public
-
-    refute_match %r%^class Object$%, @s.report.accept(to_rdoc)
-  end
-
-  def test_report_class_documented
-    c = @tl.add_class RDoc::NormalClass, 'C'
-    c.record_location @tl
-    c.add_comment 'C', @tl
-
-    m = RDoc::AnyMethod.new nil, 'm'
-    m.record_location @tl
-    c.add_method m
-    m.comment = 'm'
-
-    @store.complete :public
-
-    report = @s.report
-
-    assert_equal @s.great_job, report
-  end
-
-  def test_report_class_documented_level_1
-    c1 = @tl.add_class RDoc::NormalClass, 'C1'
-    c1.record_location @tl
-    c1.add_comment 'C1', @tl
-
-    m1 = RDoc::AnyMethod.new nil, 'm1'
-    m1.record_location @tl
-    c1.add_method m1
-    m1.comment = 'm1'
-
-    c2 = @tl.add_class RDoc::NormalClass, 'C2'
-    c2.record_location @tl
-
-    m2 = RDoc::AnyMethod.new nil, 'm2'
-    m2.record_location @tl
-    c2.add_method m2
-    m2.comment = 'm2'
-
-    @store.complete :public
-
-    @s.coverage_level = 1
-
-    report = @s.report
-
-    expected =
-      doc(
-        para('The following items are not documented:'),
-        blank_line,
-        para('In files:'),
-        list(:BULLET, *[
-          item(nil, para('file.rb'))]),
-        blank_line,
-        verb("class C2\n", "end\n"),
-        blank_line)
-
-    assert_equal expected, report
-  end
-
-  def test_report_class_empty
-    @tl.add_class RDoc::NormalClass, 'C'
-
-    @store.complete :public
-
-    report = @s.report
-
-    expected =
-      doc(
-        para('The following items are not documented:'),
-        blank_line,
-        para('class C is referenced but empty.'),
-        para("It probably came from another project.  I'm sorry I'm holding it against you."),
-        blank_line)
-
-    assert_equal expected, report
-  end
-
-  def test_report_class_empty_2
-    c1 = @tl.add_class RDoc::NormalClass, 'C1'
-    c1.record_location @tl
-
-    c2 = @tl.add_class RDoc::NormalClass, 'C2'
-    c2.record_location @tl
-    c2.add_comment 'C2', @tl
-
-    @store.complete :public
-
-    @s.coverage_level = 1
-    report = @s.report
-
-    expected =
-      doc(
-        para('The following items are not documented:'),
-        blank_line,
-        para('In files:'),
-        list(:BULLET, *[
-          item(nil, para('file.rb'))]),
-        blank_line,
-        verb("class C1\n", "end\n"),
-        blank_line)
-
-    assert_equal expected, report
-  end
-
-  def test_report_class_method_documented
-    c = @tl.add_class RDoc::NormalClass, 'C'
-    c.record_location @tl
-
-    m = RDoc::AnyMethod.new nil, 'm'
-    m.record_location @tl
-    c.add_method m
-    m.comment = 'm'
-
-    @store.complete :public
-
-    report = @s.report
-
-    expected =
-      doc(
-        para('The following items are not documented:'),
-        blank_line,
-        para('In files:'),
-        list(:BULLET, *[
-          item(nil, para('file.rb'))]),
-        blank_line,
-        verb("class C\n", "end\n"),
-        blank_line)
-
-    assert_equal expected, report
-  end
-
-  def test_report_class_module_ignore
-    c = @tl.add_class RDoc::NormalClass, 'C'
-    c.ignore
-
-    @store.complete :public
-
-    report = @s.report_class_module c
-
-    assert_nil report
-  end
-
-  def test_report_empty
-    @store.complete :public
-
-    report = @s.report
-
-    assert_equal @s.great_job, report
-  end
-
-  def test_report_method
-    c = @tl.add_class RDoc::NormalClass, 'C'
-    c.record_location @tl
-    c.add_comment 'C', @tl
-
-    m1 = RDoc::AnyMethod.new nil, 'm1'
-    m1.record_location @tl
-    c.add_method m1
-
-    m2 = RDoc::AnyMethod.new nil, 'm2'
-    m2.record_location @tl
-    c.add_method m2
-    m2.comment = 'm2'
-
-    @store.complete :public
-
-    report = @s.report
-
-    expected =
-      doc(
-        para('The following items are not documented:'),
-        blank_line,
-        verb(*[
-          "class C # is documented\n",
-          "\n",
-          "  # in file file.rb\n",
-          "  def m1; end\n",
-          "\n",
-          "end\n"]),
-        blank_line)
-
-    assert_equal expected, report
-  end
-
-  def test_report_method_class
-    c = @tl.add_class RDoc::NormalClass, 'C'
-    c.record_location @tl
-    c.add_comment 'C', @tl
-
-    m1 = RDoc::AnyMethod.new nil, 'm1', singleton: true
-    m1.record_location @tl
-    c.add_method m1
-
-    m2 = RDoc::AnyMethod.new nil, 'm2', singleton: true
-    m2.record_location @tl
-    c.add_method m2
-    m2.comment = 'm2'
-
-    @store.complete :public
-
-    report = @s.report
-
-    expected =
-      doc(
-        para('The following items are not documented:'),
-        blank_line,
-        verb(*[
-          "class C # is documented\n",
-          "\n",
-          "  # in file file.rb\n",
-          "  def self.m1; end\n",
-          "\n",
-          "end\n"]),
-        blank_line)
-
-    assert_equal expected, report
-  end
-
-  def test_report_method_documented
-    c = @tl.add_class RDoc::NormalClass, 'C'
-    c.record_location @tl
-    c.add_comment 'C', @tl
-
-    m = RDoc::AnyMethod.new nil, 'm'
-    m.record_location @tl
-    c.add_method m
-    m.comment = 'm'
-
-    @store.complete :public
-
-    report = @s.report
-
-    assert_equal @s.great_job, report
-  end
-
-  def test_report_method_line
-    c = @tl.add_class RDoc::NormalClass, 'C'
-    c.record_location @tl
-    c.add_comment 'C', @tl
-
-    m1 = RDoc::AnyMethod.new nil, 'm1'
-    m1.record_location @tl
-    m1.line = 4
-    c.add_method m1
-
-    @store.complete :public
-
-    assert_match '# in file file.rb:4', @s.report.accept(to_rdoc)
-  end
-
-  def test_report_method_parameters
-    c = @tl.add_class RDoc::NormalClass, 'C'
-    c.record_location @tl
-    c.add_comment 'C', @tl
-
-    m1 = RDoc::AnyMethod.new nil, 'm1'
-    m1.record_location @tl
-    m1.params = '(p1, p2)'
-    m1.comment = 'Stuff with +p1+'
-    c.add_method m1
-
-    m2 = RDoc::AnyMethod.new nil, 'm2'
-    m2.record_location @tl
-    c.add_method m2
-    m2.comment = 'm2'
-
-    @store.complete :public
-
-    @s.coverage_level = 1
-    report = @s.report
-
-    expected =
-      doc(
-        para('The following items are not documented:'),
-        blank_line,
-        verb(*[
-          "class C # is documented\n",
-          "\n",
-          "  # in file file.rb\n",
-          "  # +p2+ is not documented\n",
-          "  def m1(p1, p2); end\n",
-          "\n",
-          "end\n"]),
-        blank_line)
-
-    assert_equal expected, report
-  end
-
-  def test_report_method_parameters_documented
-    @tl.parser = RDoc::Parser::Ruby
-    c = @tl.add_class RDoc::NormalClass, 'C'
-    c.record_location @tl
-    c.add_comment 'C', @tl
-
-    m = RDoc::AnyMethod.new nil, 'm'
-    m.record_location @tl
-    m.params = '(p1)'
-    m.comment = 'Stuff with +p1+'
-    c.add_method m
-
-    @store.complete :public
-
-    @s.coverage_level = 1
-    report = @s.report
-
-    assert_equal @s.great_job, report
-  end
-
-  def test_report_method_parameters_yield
-    c = @tl.add_class RDoc::NormalClass, 'C'
-    c.record_location @tl
-    c.add_comment 'C', @tl
-
-    m = RDoc::AnyMethod.new nil, 'm'
-    m.record_location @tl
-    m.call_seq = <<-SEQ
-m(a) { |c| ... }
-m(a, b) { |c, d| ... }
-    SEQ
-    m.comment = 'Stuff with +a+, yields +c+ for you to do stuff with'
-    c.add_method m
-
-    @store.complete :public
-
-    @s.coverage_level = 1
-    report = @s.report
-
-    expected =
-      doc(
-        para('The following items are not documented:'),
-        blank_line,
-        verb(
-          "class C # is documented\n",
-          "\n",
-          "  # in file file.rb\n",
-          "  # +b+, +d+ is not documented\n",
-          "  def m; end\n",
-          "\n",
-          "end\n"),
-        blank_line)
-
-    assert_equal expected, report
-  end
-
-  def test_summary
-    c = @tl.add_class RDoc::NormalClass, 'C'
-    c.record_location @tl
-
-    m = @tl.add_module RDoc::NormalModule, 'M'
-    m.record_location @tl
-
-    a = RDoc::Attr.new nil, 'a', 'RW', nil
-    a.record_location @tl
-    c.add_attribute a
-
-    c_c = RDoc::Constant.new 'C', nil, nil
-    c_c.record_location @tl
-    c.add_constant c_c
-
-    m = RDoc::AnyMethod.new nil, 'm'
-    m.record_location @tl
-    c.add_method m
-
-    @store.complete :public
-
-    summary = @s.summary.accept to_rdoc
-    summary.sub!(/  Elapsed:.*/m, '')
-
-    expected = <<-EXPECTED
-  Files:      0
-
-  Classes:    1 (1 undocumented)
-  Modules:    1 (1 undocumented)
-  Constants:  1 (1 undocumented)
-  Attributes: 1 (1 undocumented)
-  Methods:    1 (1 undocumented)
-
-  Total:      5 (5 undocumented)
-    0.00% documented
-
-    EXPECTED
-
-    assert_equal summary, expected
-  end
-
-  def test_summary_level_false
-    c = @tl.add_class RDoc::NormalClass, 'C'
-    c.record_location @tl
-
-    @store.complete :public
-
-    @s.coverage_level = false
-
-    summary = @s.summary.accept to_rdoc
-    summary.sub!(/  Elapsed:.*/m, '')
-
-    expected = <<-EXPECTED
-  Files:      0
-
-  Classes:    1 (1 undocumented)
-  Modules:    0 (0 undocumented)
-  Constants:  0 (0 undocumented)
-  Attributes: 0 (0 undocumented)
-  Methods:    0 (0 undocumented)
-
-  Total:      1 (1 undocumented)
-    0.00% documented
-
-    EXPECTED
-
-    assert_equal summary, expected
-  end
-
-  def test_summary_level_1
-    c = @tl.add_class RDoc::NormalClass, 'C'
-    c.record_location @tl
-    c.add_comment 'C', @tl
-
-    m = RDoc::AnyMethod.new nil, 'm'
-    m.record_location @tl
-    m.params = '(p1, p2)'
-    m.comment = 'Stuff with +p1+'
-    c.add_method m
-
-    @store.complete :public
-
-    @s.coverage_level = 1
-    @s.report
-
-    summary = @s.summary.accept to_rdoc
-    summary.sub!(/  Elapsed:.*/m, '')
-
-    expected = <<-EXPECTED
-  Files:      0
-
-  Classes:    1 (0 undocumented)
-  Modules:    0 (0 undocumented)
-  Constants:  0 (0 undocumented)
-  Attributes: 0 (0 undocumented)
-  Methods:    1 (0 undocumented)
-  Parameters: 2 (1 undocumented)
-
-  Total:      4 (1 undocumented)
-   75.00% documented
-
-    EXPECTED
-
-    assert_equal summary, expected
-  end
-
-  def to_rdoc
-    RDoc::Markup::ToRdoc.new
-  end
-
-  def test_undoc_params
-    method = RDoc::AnyMethod.new [], 'm'
-    method.params = '(a)'
-    method.comment = comment 'comment'
-
-    total, undoc = @s.undoc_params method
-
-    assert_equal 1,     total
-    assert_equal %w[a], undoc
-  end
-
-  def test_undoc_params_block
-    method = RDoc::AnyMethod.new [], 'm'
-    method.params = '(&a)'
-    method.comment = comment '+a+'
-
-    total, undoc = @s.undoc_params method
-
-    assert_equal 1, total
-    assert_empty    undoc
-  end
-
-  def test_undoc_params_documented
-    method = RDoc::AnyMethod.new [], 'm'
-    method.params = '(a)'
-    method.comment = comment '+a+'
-
-    total, undoc = @s.undoc_params method
-
-    assert_equal 1, total
-    assert_empty    undoc
-  end
-
-  def test_undoc_params_keywords
-    method = RDoc::AnyMethod.new [], 'm'
-    method.params = '(**a)'
-    method.comment = comment '+a+'
-
-    total, undoc = @s.undoc_params method
-
-    assert_equal 1, total
-    assert_empty    undoc
-  end
-
-  def test_undoc_params_splat
-    method = RDoc::AnyMethod.new [], 'm'
-    method.params = '(*a)'
-    method.comment = comment '+a+'
-
-    total, undoc = @s.undoc_params method
-
-    assert_equal 1, total
-    assert_empty    undoc
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc_store_test.rb b/test/mri/rdoc/rdoc_store_test.rb
deleted file mode 100644
index d22516100ec..00000000000
--- a/test/mri/rdoc/rdoc_store_test.rb
+++ /dev/null
@@ -1,1057 +0,0 @@
-# frozen_string_literal: true
-require_relative 'xref_test_case'
-
-class RDocStoreTest < XrefTestCase
-
-  OBJECT_ANCESTORS = %w[BasicObject]
-
-  def setup
-    super
-
-    @tmpdir = File.join Dir.tmpdir, "test_rdoc_ri_store_#{$$}"
-    @s = RDoc::RI::Store.new(RDoc::Options.new, path: @tmpdir)
-
-    @top_level = @s.add_file 'file.rb'
-
-    @page = @s.add_file 'README.txt', parser: RDoc::Parser::Simple
-    @page.comment = RDoc::Comment.new 'This is a page', @page
-
-    @klass = @top_level.add_class RDoc::NormalClass, 'Object'
-    @klass.add_comment 'original', @top_level
-    @klass.record_location @top_level
-
-    @cmeth = RDoc::AnyMethod.new nil, 'cmethod', singleton: true
-    @cmeth.record_location @top_level
-
-    @meth_comment = RDoc::Comment.new 'method comment'
-    @meth_comment.location = @top_level
-
-    @meth = RDoc::AnyMethod.new nil, 'method'
-    @meth.record_location @top_level
-    @meth.comment = @meth_comment
-
-    @meth_bang = RDoc::AnyMethod.new nil, 'method!'
-    @meth_bang.record_location @top_level
-
-    @meth_bang_alias = RDoc::Alias.new nil, 'method!', 'method_bang', ''
-    @meth_bang_alias.record_location @top_level
-
-    @meth_bang.add_alias @meth_bang_alias, @klass
-
-    @attr_comment = RDoc::Comment.new 'attribute comment'
-    @attr_comment.location = @top_level
-
-    @attr = RDoc::Attr.new nil, 'attr', 'RW', ''
-    @attr.record_location @top_level
-    @attr.comment = @attr_comment
-
-    @klass.add_method @cmeth
-    @klass.add_method @meth
-    @klass.add_method @meth_bang
-    @klass.add_attribute @attr
-
-    @nest_klass = @klass.add_class RDoc::NormalClass, 'SubClass'
-    @nest_meth = RDoc::AnyMethod.new nil, 'method'
-    @nest_meth.record_location @top_level
-
-    @nest_incl = RDoc::Include.new 'Incl', ''
-    @nest_incl.record_location @top_level
-
-    @nest_klass.add_method @nest_meth
-    @nest_klass.add_include @nest_incl
-
-    @mod = @top_level.add_module RDoc::NormalModule, 'Mod'
-    @mod.record_location @top_level
-  end
-
-  def using_prism_ruby_parser?
-    RDoc::Parser::Ruby.name == 'RDoc::Parser::PrismRuby'
-  end
-
-  def teardown
-    super
-
-    FileUtils.rm_rf @tmpdir
-  end
-
-  def assert_cache(imethods, cmethods, attrs, modules,
-                   ancestors = {}, pages = [], main = nil, title = nil)
-    imethods ||= { 'Object' => %w[method method! method_bang] }
-    cmethods ||= { 'Object' => %w[cmethod] }
-    attrs    ||= { 'Object' => ['attr_accessor attr'] }
-
-    # this is sort-of a hack
-    @s.clean_cache_collection ancestors
-
-    expected = {
-      :ancestors                   => ancestors,
-      :attributes                  => attrs,
-      :class_methods               => cmethods,
-      :c_class_variables           => {},
-      :c_singleton_class_variables => {},
-      :encoding                    => Encoding::UTF_8,
-      :instance_methods            => imethods,
-      :modules                     => modules,
-      :pages                       => pages,
-      :main                        => main,
-      :title                       => title,
-    }
-
-    @s.save_cache
-
-    assert_equal expected, @s.cache
-  end
-
-  def test_add_c_enclosure
-    @s.add_c_enclosure 'cC1', @c1
-
-    expected = { 'cC1' => @c1 }
-
-    assert_equal expected, @s.c_enclosure_classes
-  end
-
-  def test_add_c_variables
-    options = RDoc::Options.new
-
-    c_file = @s.add_file 'ext.c'
-
-    some_ext   = c_file.add_class RDoc::NormalClass, 'SomeExt'
-                 c_file.add_class RDoc::SingleClass, 'SomeExtSingle'
-
-    c_parser = RDoc::Parser::C.new c_file, '', options, nil
-
-    c_parser.classes['cSomeExt']             = some_ext
-    c_parser.singleton_classes['s_cSomeExt'] = 'SomeExtSingle'
-
-    @s.add_c_variables c_parser
-
-    expected = { 'ext.c' => { 'cSomeExt' => 'SomeExt' } }
-
-    assert_equal expected, @s.c_class_variables
-
-    expected = { 'ext.c' => { 's_cSomeExt' => 'SomeExtSingle' } }
-
-    assert_equal expected, @s.c_singleton_class_variables
-  end
-
-  def test_add_file
-    top_level = @store.add_file 'file.rb'
-
-    assert_kind_of RDoc::TopLevel, top_level
-    assert_equal @store, top_level.store
-    assert_equal 'file.rb', top_level.name
-    assert_includes @store.all_files, top_level
-
-    assert_same top_level, @store.add_file('file.rb')
-    refute_same top_level, @store.add_file('other.rb')
-  end
-
-  def test_add_file_relative
-    top_level = @store.add_file 'path/file.rb', relative_name: 'file.rb'
-
-    assert_kind_of RDoc::TopLevel, top_level
-    assert_equal @store, top_level.store
-
-    assert_equal 'path/file.rb', top_level.absolute_name
-    assert_equal 'file.rb',      top_level.relative_name
-
-    assert_includes @store.all_files, top_level
-
-    assert_same top_level, @store.add_file('file.rb')
-    refute_same top_level, @store.add_file('other.rb')
-  end
-
-  def test_all_classes_and_modules
-    expected = %w[
-      C1 C10 C10::C11 C11 C2 C2::C3 C2::C3::H1 C3 C3::H1 C3::H2 C4 C4::C4 C5 C5::C1 C6 C7 C8 C9 C9::A C9::B
-      Child
-      M1 M1::M2
-      Object
-      Parent
-    ]
-
-    # C8::S1 does not exist. It should not be in the list.
-    # class C8; class << something; class S1; end; end; end
-    expected = (expected + ['C8::S1']).sort unless using_prism_ruby_parser?
-
-    assert_equal expected,
-                 @store.all_classes_and_modules.map { |m| m.full_name }.sort
-  end
-
-  def test_all_files
-    assert_equal %w[EXAMPLE.md xref_data.rb],
-                 @store.all_files.map { |m| m.full_name }.sort
-  end
-
-  def test_all_modules
-    assert_equal %w[M1 M1::M2],
-                 @store.all_modules.map { |m| m.full_name }.sort
-  end
-
-  def test_attributes
-    @s.cache[:attributes]['Object'] = %w[attr]
-
-    expected = { 'Object' => %w[attr] }
-
-    assert_equal expected, @s.attributes
-  end
-
-  def test_class_file
-    assert_equal File.join(@tmpdir, 'Object', 'cdesc-Object.ri'),
-                 @s.class_file('Object')
-    assert_equal File.join(@tmpdir, 'Object', 'SubClass', 'cdesc-SubClass.ri'),
-                 @s.class_file('Object::SubClass')
-  end
-
-  def test_class_methods
-    @s.cache[:class_methods]['Object'] = %w[method]
-
-    expected = { 'Object' => %w[method] }
-
-    assert_equal expected, @s.class_methods
-  end
-
-  def test_class_path
-    assert_equal File.join(@tmpdir, 'Object'), @s.class_path('Object')
-    assert_equal File.join(@tmpdir, 'Object', 'SubClass'),
-                 @s.class_path('Object::SubClass')
-  end
-
-  def test_classes
-    expected = %w[
-      C1 C10 C10::C11 C11 C2 C2::C3 C2::C3::H1 C3 C3::H1 C3::H2 C4 C4::C4 C5 C5::C1 C6 C7 C8 C9 C9::A C9::B
-      Child
-      Object
-      Parent
-    ]
-
-    # C8::S1 does not exist. It should not be in the list.
-    # class C8; class << something; class S1; end; end; end
-    expected = (expected + ['C8::S1']).sort unless using_prism_ruby_parser?
-
-    assert_equal expected, @store.all_classes.map { |m| m.full_name }.sort
-  end
-
-  def test_complete
-    a1 = RDoc::Constant.new 'A1', '', ''
-    @c2.add_module_alias @c2_c3, @c2_c3.name, a1, @top_level
-
-    @store.complete :public
-
-    a1 = @xref_data.find_class_or_module 'C2::A1'
-
-    assert_equal 'C2::A1', a1.full_name
-    refute_empty a1.aliases
-  end
-
-  def test_complete_nodoc
-    c_nodoc = @top_level.add_class RDoc::NormalClass, 'Nodoc'
-    c_nodoc.record_location @top_level
-    c_nodoc.document_self = nil
-
-    @s.complete :nodoc
-
-    assert_includes @s.classes_hash.keys, 'Nodoc'
-  end
-
-  def test_find_c_enclosure
-    assert_nil @s.find_c_enclosure 'cC1'
-
-    @s.add_c_enclosure 'cC1', @c1
-
-    assert_equal @c1, @s.find_c_enclosure('cC1')
-  end
-
-  def test_find_c_enclosure_from_cache
-    @s.save_class @klass
-    @s.classes_hash.clear
-
-    assert_nil @s.find_c_enclosure 'cObject'
-
-    @s.c_enclosure_names['cObject'] = 'Object'
-
-    klass = @s.find_c_enclosure('cObject')
-    assert_equal @klass, klass
-
-    assert_empty klass.comment_location
-    assert_equal @top_level, klass.parent
-
-    assert_includes @s.c_enclosure_classes, 'cObject'
-  end
-
-  def test_find_c_enclosure_from_cache_legacy
-    @klass.in_files.clear
-    @s.save_class @klass
-    @s.classes_hash.clear
-
-    assert_nil @s.find_c_enclosure 'cObject'
-
-    @s.c_enclosure_names['cObject'] = 'Object'
-
-    assert_nil @s.find_c_enclosure('cObject')
-  end
-
-  def test_resolve_c_superclasses
-    # first parse a child that references an unknown parent
-    c_file1 = @s.add_file 'ext1.c'
-    c_file1.add_class RDoc::NormalClass, 'Child', 'cExternParent'
-
-    # then parse the parent and register the C variable name as a C enclosure
-    c_file2 = @s.add_file 'ext2.c'
-    parent = c_file2.add_class RDoc::NormalClass, 'Parent', 'rb_cObject'
-
-    @s.add_c_enclosure('cExternParent', parent)
-
-    # at this point, the child's superclass is still the name of the C variable
-    assert_equal("cExternParent", @s.classes_hash['Child'].superclass)
-
-    @s.resolve_c_superclasses
-
-    # now the ancestor tree correctly references the NormalClass objects
-    assert_equal(parent, @s.classes_hash['Child'].superclass)
-  end
-
-  def test_find_class_named
-    assert_equal @c1, @store.find_class_named('C1')
-
-    assert_equal @c2_c3, @store.find_class_named('C2::C3')
-  end
-
-  def test_find_class_named_from
-    assert_equal @c5_c1, @store.find_class_named_from('C1', 'C5')
-
-    assert_equal @c1,    @store.find_class_named_from('C1', 'C4')
-  end
-
-  def test_find_class_or_module
-    assert_equal @m1, @store.find_class_or_module('M1')
-    assert_equal @c1, @store.find_class_or_module('C1')
-
-    assert_equal @m1, @store.find_class_or_module('::M1')
-    assert_equal @c1, @store.find_class_or_module('::C1')
-  end
-
-  def test_find_file_named
-    assert_equal @xref_data, @store.find_file_named(@file_name)
-  end
-
-  def test_find_module_named
-    assert_equal @m1,    @store.find_module_named('M1')
-    assert_equal @m1_m2, @store.find_module_named('M1::M2')
-  end
-
-  def test_find_text_page
-    page = @store.add_file 'PAGE.txt', parser: RDoc::Parser::Simple
-
-    assert_nil @store.find_text_page 'no such page'
-
-    assert_equal page, @store.find_text_page('PAGE.txt')
-  end
-
-  def test_friendly_path
-    @orig_xdg_data_home = ENV.delete('XDG_DATA_HOME')
-
-    @s.path = @tmpdir
-    @s.type = nil
-    assert_equal @s.path, @s.friendly_path
-
-    @s.type = :extra
-    assert_equal @s.path, @s.friendly_path
-
-    @s.type = :system
-    assert_equal "ruby core", @s.friendly_path
-
-    @s.type = :site
-    assert_equal "ruby site", @s.friendly_path
-
-    @s.type = :home
-    assert_equal File.expand_path("~/.local/share/rdoc"), @s.friendly_path
-
-    @s.type = :gem
-    @s.path = "#{@tmpdir}/gem_repository/doc/gem_name-1.0/ri"
-    assert_equal "gem gem_name-1.0", @s.friendly_path
-  ensure
-    ENV['XDG_DATA_HOME'] = @orig_xdg_data_home
-  end
-
-  def test_dry_run
-    refute @s.dry_run
-
-    @s.dry_run = true
-
-    assert @s.dry_run
-  end
-
-  def test_instance_methods
-    @s.cache[:instance_methods]['Object'] = %w[method]
-
-    expected = { 'Object' => %w[method] }
-
-    assert_equal expected, @s.instance_methods
-  end
-
-  def test_load_all
-    FileUtils.mkdir_p @tmpdir
-
-    @s.save
-
-    s = RDoc::Store.new(RDoc::Options.new, path: @tmpdir)
-
-    s.load_all
-
-    assert_equal [@klass, @nest_klass], s.all_classes.sort
-    assert_equal [@mod],                s.all_modules.sort
-    assert_equal [@page, @top_level],   s.all_files.sort
-
-    methods = s.all_classes_and_modules.flat_map do |mod|
-      mod.method_list
-    end.sort
-
-    _meth_bang_alias = RDoc::AnyMethod.new nil, 'method_bang'
-    _meth_bang_alias.parent = @klass
-
-    assert_equal [@meth, @meth_bang, _meth_bang_alias, @nest_meth, @cmeth],
-                 methods.sort_by { |m| m.full_name }
-
-    method = methods.find { |m| m == @meth }
-    assert_equal @meth_comment.parse, method.comment.parse
-
-    assert_equal @klass, methods.last.parent
-
-    attributes = s.all_classes_and_modules.flat_map do |mod|
-      mod.attributes
-    end.sort
-
-    assert_equal [@attr], attributes
-
-    assert_equal @attr_comment.parse, attributes.first.comment.parse
-  end
-
-  def test_load_cache
-    cache = {
-      :c_class_variables           =>
-        { 'file.c' => { 'cKlass' => 'Klass' } },
-      :c_singleton_class_variables =>
-        { 'file.c' => { 'sKlass' => 'KlassSingle' } },
-      :encoding                    => :encoding_value,
-      :methods                     => { "Object" => %w[Object#method] },
-      :main                        => @page.full_name,
-      :modules                     => %w[Object],
-      :pages                       => [],
-    }
-
-    Dir.mkdir @tmpdir
-
-    File.open File.join(@tmpdir, 'cache.ri'), 'wb' do |io|
-      Marshal.dump cache, io
-    end
-
-    # Store prioritize @encoding over the cached value
-    # See we need to unset @encoding to test the cached value
-    @s.encoding = nil
-
-    @s.load_cache
-
-    assert_equal cache, @s.cache
-
-    assert_equal :encoding_value, @s.encoding
-    assert_equal 'README.txt',    @s.main
-
-    expected = { 'file.c' => { 'cKlass' => 'Klass' } }
-    assert_equal expected, @s.cache[:c_class_variables]
-
-    expected = { 'file.c' => { 'sKlass' => 'KlassSingle' } }
-    assert_equal expected, @s.cache[:c_singleton_class_variables]
-
-    expected = { 'cKlass' => 'Klass' }
-    assert_equal expected, @s.c_enclosure_names
-  end
-
-  def test_load_cache_encoding_differs
-    cache = {
-      :c_class_variables           => {},
-      :c_singleton_class_variables => {},
-      :encoding                    => Encoding::ISO_8859_1,
-      :main                        => nil,
-      :methods                     => { "Object" => %w[Object#method] },
-      :modules                     => %w[Object],
-      :pages                       => [],
-    }
-
-    Dir.mkdir @tmpdir
-
-    File.open File.join(@tmpdir, 'cache.ri'), 'wb' do |io|
-      Marshal.dump cache, io
-    end
-
-    @s.encoding = Encoding::UTF_8
-
-    @s.load_cache
-
-    assert_equal cache, @s.cache
-
-    assert_equal Encoding::UTF_8, @s.encoding
-  end
-
-  def test_load_cache_no_cache
-    cache = {
-      :ancestors                   => {},
-      :attributes                  => {},
-      :class_methods               => {},
-      :c_class_variables           => {},
-      :c_singleton_class_variables => {},
-      :encoding                    => Encoding::UTF_8,
-      :instance_methods            => {},
-      :main                        => nil,
-      :modules                     => [],
-      :pages                       => [],
-      :title                       => nil,
-    }
-
-    @s.load_cache
-
-    assert_equal cache, @s.cache
-  end
-
-  def test_load_cache_legacy
-    cache = {
-      :ancestors        => {},
-      :attributes       => {},
-      :class_methods    => {},
-      :encoding         => :encoding_value,
-      :instance_methods => { "Object" => %w[Object#method] },
-      :modules          => %w[Object],
-      # no :pages
-      # no :main
-      # no :c_class_variables
-      # no :c_singleton_class_variables
-    }
-
-    Dir.mkdir @tmpdir
-
-    File.open File.join(@tmpdir, 'cache.ri'), 'wb' do |io|
-      Marshal.dump cache, io
-    end
-
-    # Store prioritize @encoding over the cached value
-    # See we need to unset @encoding to test the cached value
-    @s.encoding = nil
-
-    @s.load_cache
-
-    expected = {
-      :ancestors                   => {},
-      :attributes                  => {},
-      :class_methods               => {},
-      :c_class_variables           => {},
-      :c_singleton_class_variables => {},
-      :encoding                    => :encoding_value,
-      :instance_methods            => { "Object" => %w[Object#method] },
-      :main                        => nil,
-      :modules                     => %w[Object],
-      :pages                       => [],
-    }
-
-    assert_equal expected, @s.cache
-
-    assert_equal :encoding_value, @s.encoding
-    assert_nil                    @s.main
-  end
-
-  def test_load_class
-    @s.save_class @klass
-    @s.classes_hash.clear
-
-    assert_equal @klass, @s.load_class('Object')
-
-    assert_includes @s.classes_hash, 'Object'
-  end
-
-  def test_load_single_class
-    if using_prism_ruby_parser?
-      # Class defined inside singleton class is not documentable.
-      # @c8_s1 should be nil because C8::S1 does not exist.
-      assert_nil @c8_s1
-      return
-    end
-
-    @s.save_class @c8_s1
-    @s.classes_hash.clear
-
-    assert_equal @c8_s1, @s.load_class('C8::S1')
-
-    assert_includes @s.classes_hash, 'C8::S1'
-  end
-
-  def test_load_method
-    @s.save_method @klass, @meth_bang
-
-    meth = @s.load_method('Object', '#method!')
-    assert_equal @meth_bang, meth
-    assert_equal @klass, meth.parent
-    assert_equal @s, meth.store
-  end
-
-  def test_load_method_legacy
-    @s.save_method @klass, @meth
-
-    file = @s.method_file @klass.full_name, @meth.full_name
-
-    File.open file, 'wb' do |io|
-      io.write "\x04\bU:\x14RDoc::AnyMethod[\x0Fi\x00I" +
-               "\"\vmethod\x06:\x06EF\"\x11Klass#method0:\vpublic" +
-               "o:\eRDoc::Markup::Document\x06:\v@parts[\x06" +
-               "o:\x1CRDoc::Markup::Paragraph\x06;\t[\x06I" +
-               "\"\x16this is a comment\x06;\x06FI" +
-               "\"\rcall_seq\x06;\x06FI\"\x0Fsome_block\x06;\x06F" +
-               "[\x06[\aI\"\faliased\x06;\x06Fo;\b\x06;\t[\x06" +
-               "o;\n\x06;\t[\x06I\"\x12alias comment\x06;\x06FI" +
-               "\"\nparam\x06;\x06F"
-    end
-
-    meth = @s.load_method('Object', '#method')
-    assert_equal 'Klass#method', meth.full_name
-    assert_equal @klass,         meth.parent
-    assert_equal @s,             meth.store
-  end
-
-  def test_load_page
-    @s.save_page @page
-
-    assert_equal @page, @s.load_page('README.txt')
-  end
-
-  def test_main
-    assert_nil @s.main
-
-    @s.main = 'README.txt'
-
-    assert_equal 'README.txt', @s.main
-  end
-
-  def test_method_file
-    assert_equal File.join(@tmpdir, 'Object', 'method-i.ri'),
-                 @s.method_file('Object', 'Object#method')
-
-    assert_equal File.join(@tmpdir, 'Object', 'method%21-i.ri'),
-                 @s.method_file('Object', 'Object#method!')
-
-    assert_equal File.join(@tmpdir, 'Object', 'SubClass', 'method%21-i.ri'),
-                 @s.method_file('Object::SubClass', 'Object::SubClass#method!')
-
-    assert_equal File.join(@tmpdir, 'Object', 'method-c.ri'),
-                 @s.method_file('Object', 'Object::method')
-  end
-
-  def test_module_names
-    @s.save_class @klass
-
-    assert_equal %w[Object], @s.module_names
-  end
-
-  def test_page
-    page = @store.add_file 'PAGE.txt', parser: RDoc::Parser::Simple
-
-    assert_nil @store.page 'no such page'
-
-    assert_equal page, @store.page('PAGE')
-  end
-
-  def test_page_with_extension
-    page = @store.add_file 'PAGE.txt', parser: RDoc::Parser::Simple
-
-    assert_nil @store.page 'no such page'
-
-    assert_equal page, @store.page('PAGE.txt')
-  end
-
-  def test_save
-    FileUtils.mkdir_p @tmpdir
-
-    @s.save
-
-    assert_directory File.join(@tmpdir, 'Object')
-
-    assert_file File.join(@tmpdir, 'Object', 'cdesc-Object.ri')
-    assert_file File.join(@tmpdir, 'Object', 'method-i.ri')
-    assert_file File.join(@tmpdir, 'page-README_txt.ri')
-
-    assert_file File.join(@tmpdir, 'cache.ri')
-
-    expected = {
-      :ancestors => {
-        'Object::SubClass' => %w[Incl Object],
-      },
-      :attributes => { 'Object' => ['attr_accessor attr'] },
-      :class_methods => { 'Object' => %w[cmethod] },
-      :c_class_variables => {},
-      :c_singleton_class_variables => {},
-      :instance_methods => {
-        'Object' => %w[attr method method! method_bang],
-        'Object::SubClass' => %w[method],
-      },
-      :main => nil,
-      :modules => %w[Mod Object Object::SubClass],
-      :encoding => Encoding::UTF_8,
-      :pages => %w[README.txt],
-      :title => nil,
-    }
-
-    expected[:ancestors]['Object'] = %w[BasicObject]
-
-    File.open File.join(@tmpdir, 'cache.ri'), 'rb' do |io|
-      cache = Marshal.load io.read
-
-      assert_equal expected, cache
-    end
-  end
-
-  def test_save_cache
-    @s.save_class @klass
-    @s.save_method @klass, @meth
-    @s.save_method @klass, @cmeth
-    @s.save_class @nest_klass
-    @s.save_page @page
-    @s.encoding = :encoding_value
-    @s.main     = @page.full_name
-    @s.title    = 'title'
-
-    options = RDoc::Options.new
-
-    c_file = @s.add_file 'ext.c'
-
-    some_ext   = c_file.add_class RDoc::NormalClass, 'SomeExt'
-                 c_file.add_class RDoc::SingleClass, 'SomeExtSingle'
-
-    c_parser = RDoc::Parser::C.new c_file, '', options, nil
-
-    c_parser.classes['cSomeExt']             = some_ext
-    c_parser.singleton_classes['s_cSomeExt'] = 'SomeExtSingle'
-
-    @s.add_c_variables c_parser
-
-    @s.save_cache
-
-    assert_file File.join(@tmpdir, 'cache.ri')
-
-    c_class_variables = {
-      'ext.c' => {
-        'cSomeExt' => 'SomeExt'
-      }
-    }
-
-    c_singleton_class_variables = {
-      'ext.c' => {
-        's_cSomeExt' => 'SomeExtSingle'
-      }
-    }
-
-    expected = {
-      :ancestors => {
-        'Object::SubClass' => %w[Incl Object],
-      },
-      :attributes => { 'Object' => ['attr_accessor attr'] },
-      :class_methods => { 'Object' => %w[cmethod] },
-      :c_class_variables => c_class_variables,
-      :c_singleton_class_variables => c_singleton_class_variables,
-      :instance_methods => {
-        'Object' => %w[method method! method_bang],
-        'Object::SubClass' => %w[method],
-      },
-      :main => @page.full_name,
-      :modules => %w[Object Object::SubClass],
-      :encoding => :encoding_value,
-      :pages => %w[README.txt],
-      :title => 'title',
-    }
-
-    expected[:ancestors]['Object'] = %w[BasicObject]
-
-    File.open File.join(@tmpdir, 'cache.ri'), 'rb' do |io|
-      cache = Marshal.load io.read
-
-      assert_equal expected, cache
-    end
-  end
-
-  def test_save_cache_dry_run
-    @s.dry_run = true
-
-    @s.save_class @klass
-    @s.save_method @klass, @meth
-    @s.save_method @klass, @cmeth
-    @s.save_class @nest_klass
-
-    @s.save_cache
-
-    refute_file File.join(@tmpdir, 'cache.ri')
-  end
-
-  def test_save_cache_duplicate_methods
-    @s.save_method @klass, @meth
-    @s.save_method @klass, @meth
-
-    @s.save_cache
-
-    assert_cache({ 'Object' => %w[method] }, {}, {}, [])
-  end
-
-  def test_save_cache_duplicate_pages
-    @s.save_page @page
-    @s.save_page @page
-
-    @s.save_cache
-
-    assert_cache({}, {}, {}, [], {}, %w[README.txt])
-  end
-
-  def test_save_class
-    @s.save_class @klass
-
-    assert_directory File.join(@tmpdir, 'Object')
-    assert_file File.join(@tmpdir, 'Object', 'cdesc-Object.ri')
-
-    assert_cache nil, nil, nil, %w[Object], 'Object' => OBJECT_ANCESTORS
-
-    assert_equal @klass, @s.load_class('Object')
-  end
-
-  def test_save_class_basic_object
-    @klass.instance_variable_set :@superclass, nil
-
-    @s.save_class @klass
-
-    assert_directory File.join(@tmpdir, 'Object')
-    assert_file File.join(@tmpdir, 'Object', 'cdesc-Object.ri')
-
-    assert_cache(nil, nil, nil, %w[Object])
-
-    assert_equal @klass, @s.load_class('Object')
-  end
-
-  def test_save_class_delete
-    # save original
-    @s.save_class @klass
-    @s.save_method @klass, @meth
-    @s.save_method @klass, @meth_bang
-    @s.save_method @klass, @cmeth
-    @s.save_method @klass, @attr
-    @s.save_cache
-
-    klass = RDoc::NormalClass.new 'Object'
-
-    meth = klass.add_method RDoc::AnyMethod.new(nil, 'replace')
-    meth.record_location @top_level
-
-    # load original, save newly updated class
-    @s = RDoc::RI::Store.new(RDoc::Options.new, path: @tmpdir)
-    @s.load_cache
-    @s.save_class klass
-    @s.save_cache
-
-    # load from disk again
-    @s = RDoc::RI::Store.new(RDoc::Options.new, path: @tmpdir)
-    @s.load_cache
-
-    @s.load_class 'Object'
-
-    assert_cache({ 'Object' => %w[replace] }, {},
-                 { 'Object' => %w[attr_accessor\ attr] }, %w[Object],
-                   'Object' => OBJECT_ANCESTORS)
-
-    # assert these files were deleted
-    refute_file @s.method_file(@klass.full_name, @meth.full_name)
-    refute_file @s.method_file(@klass.full_name, @meth_bang.full_name)
-    refute_file @s.method_file(@klass.full_name, @cmeth.full_name)
-
-    # assert these files were not deleted
-    assert_file @s.method_file(@klass.full_name, @attr.full_name)
-  end
-
-  def test_save_class_dry_run
-    @s.dry_run = true
-
-    @s.save_class @klass
-
-    refute_file File.join(@tmpdir, 'Object')
-    refute_file File.join(@tmpdir, 'Object', 'cdesc-Object.ri')
-  end
-
-  def test_save_class_loaded
-    @s.save
-
-    assert_directory File.join(@tmpdir, 'Object')
-    assert_file      File.join(@tmpdir, 'Object', 'cdesc-Object.ri')
-
-    assert_file @s.method_file(@klass.full_name, @attr.full_name)
-    assert_file @s.method_file(@klass.full_name, @cmeth.full_name)
-    assert_file @s.method_file(@klass.full_name, @meth.full_name)
-    assert_file @s.method_file(@klass.full_name, @meth_bang.full_name)
-
-    s = RDoc::Store.new(RDoc::Options.new, path: @s.path)
-    s.load_cache
-
-    loaded = s.load_class 'Object'
-
-    assert_equal @klass, loaded
-
-    s.save_class loaded
-
-    s = RDoc::Store.new(RDoc::Options.new, path: @s.path)
-    s.load_cache
-
-    reloaded = s.load_class 'Object'
-
-    assert_equal @klass, reloaded
-
-    # assert these files were not deleted.  Bug #171
-    assert_file s.method_file(@klass.full_name, @attr.full_name)
-    assert_file s.method_file(@klass.full_name, @cmeth.full_name)
-    assert_file s.method_file(@klass.full_name, @meth.full_name)
-    assert_file s.method_file(@klass.full_name, @meth_bang.full_name)
-  end
-
-  def test_save_class_merge
-    @s.save_class @klass
-
-    klass = RDoc::NormalClass.new 'Object'
-    klass.add_comment 'new comment', @top_level
-
-    s = RDoc::RI::Store.new(RDoc::Options.new, path: @tmpdir)
-    s.save_class klass
-
-    s = RDoc::RI::Store.new(RDoc::Options.new, path: @tmpdir)
-
-    inner = @RM::Document.new @RM::Paragraph.new 'new comment'
-    inner.file = @top_level
-
-    document = @RM::Document.new inner
-
-    assert_equal document, s.load_class('Object').comment_location
-  end
-
-  # This is a functional test
-  def test_save_class_merge_constant
-    store = RDoc::Store.new(RDoc::Options.new)
-    tl = store.add_file 'file.rb'
-
-    klass = tl.add_class RDoc::NormalClass, 'C'
-    klass.add_comment 'comment', tl
-
-    const = klass.add_constant RDoc::Constant.new('CONST', nil, nil)
-    const.record_location tl
-
-    @s.save_class klass
-
-    # separate parse run, independent store
-    store = RDoc::Store.new(RDoc::Options.new)
-    tl = store.add_file 'file.rb'
-    klass2 = tl.add_class RDoc::NormalClass, 'C'
-    klass2.record_location tl
-
-    s = RDoc::RI::Store.new(RDoc::Options.new, path: @tmpdir)
-    s.save_class klass2
-
-    # separate `ri` run, independent store
-    s = RDoc::RI::Store.new(RDoc::Options.new, path: @tmpdir)
-
-    result = s.load_class 'C'
-
-    assert_empty result.constants
-  end
-
-  def test_save_class_methods
-    @s.save_class @klass
-
-    assert_directory File.join(@tmpdir, 'Object')
-    assert_file File.join(@tmpdir, 'Object', 'cdesc-Object.ri')
-
-    assert_cache nil, nil, nil, %w[Object], 'Object' => OBJECT_ANCESTORS
-
-    assert_equal @klass, @s.load_class('Object')
-  end
-
-  def test_save_class_nested
-    @s.save_class @nest_klass
-
-    assert_directory File.join(@tmpdir, 'Object', 'SubClass')
-    assert_file File.join(@tmpdir, 'Object', 'SubClass', 'cdesc-SubClass.ri')
-
-    assert_cache({ 'Object::SubClass' => %w[method] }, {}, {},
-                 %w[Object::SubClass], 'Object::SubClass' => %w[Incl Object])
-  end
-
-  def test_save_method
-    @s.save_method @klass, @meth
-
-    assert_directory File.join(@tmpdir, 'Object')
-    assert_file File.join(@tmpdir, 'Object', 'method-i.ri')
-
-    assert_cache({ 'Object' => %w[method] }, {}, {}, [])
-
-    assert_equal @meth, @s.load_method('Object', '#method')
-  end
-
-  def test_save_method_dry_run
-    @s.dry_run = true
-
-    @s.save_method @klass, @meth
-
-    refute_file File.join(@tmpdir, 'Object')
-    refute_file File.join(@tmpdir, 'Object', 'method-i.ri')
-  end
-
-  def test_save_method_nested
-    @s.save_method @nest_klass, @nest_meth
-
-    assert_directory File.join(@tmpdir, 'Object', 'SubClass')
-    assert_file File.join(@tmpdir, 'Object', 'SubClass', 'method-i.ri')
-
-    assert_cache({ 'Object::SubClass' => %w[method] }, {}, {}, [])
-  end
-
-  def test_save_page
-    @s.save_page @page
-
-    assert_file File.join(@tmpdir, 'page-README_txt.ri')
-
-    assert_cache({}, {}, {}, [], {}, %w[README.txt])
-  end
-
-  def test_save_page_file
-    @s.save_page @top_level
-
-    refute_file File.join(@tmpdir, 'page-file_rb.ri')
-  end
-
-  def test_source
-    @s.path = @tmpdir
-    @s.type = nil
-    assert_equal @s.path, @s.source
-
-    @s.type = :extra
-    assert_equal @s.path, @s.source
-
-    @s.type = :system
-    assert_equal "ruby", @s.source
-
-    @s.type = :site
-    assert_equal "site", @s.source
-
-    @s.type = :home
-    assert_equal "home", @s.source
-
-    @s.type = :gem
-    @s.path = "#{@tmpdir}/gem_repository/doc/gem_name-1.0/ri"
-    assert_equal "gem_name-1.0", @s.source
-  end
-
-  def test_title
-    assert_nil @s.title
-
-    @s.title = 'rdoc'
-
-    assert_equal 'rdoc', @s.title
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc_task_test.rb b/test/mri/rdoc/rdoc_task_test.rb
deleted file mode 100644
index cd37b2520e1..00000000000
--- a/test/mri/rdoc/rdoc_task_test.rb
+++ /dev/null
@@ -1,182 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-begin
-  require 'rake'
-rescue LoadError
-end
-
-class RDocTaskTest < RDoc::TestCase
-
-  def setup
-    super
-
-    Rake::Task.clear
-
-    @t = RDoc::Task.new
-  end
-
-  def test_clobber_task_description
-    assert_equal 'Remove RDoc HTML files', @t.clobber_task_description
-  end
-
-  def test_inline_source
-    _, err = verbose_capture_output do
-      assert @t.inline_source
-    end
-
-    assert_equal "RDoc::Task#inline_source is deprecated\n", err
-
-    _, err = verbose_capture_output do
-      @t.inline_source = false
-    end
-
-    assert_equal "RDoc::Task#inline_source is deprecated\n", err
-
-    capture_output do
-      assert @t.inline_source
-    end
-  end
-
-  def test_markup_option
-    rdoc_task = RDoc::Task.new do |rd|
-      rd.markup = "tomdoc"
-    end
-
-    assert_equal %w[-o html --markup tomdoc], rdoc_task.option_list
-  end
-
-  def test_tasks_creation
-    RDoc::Task.new
-    assert Rake::Task[:rdoc]
-    assert Rake::Task[:clobber_rdoc]
-    assert Rake::Task[:rerdoc]
-    assert Rake::Task[:"rdoc:coverage"]
-    assert_equal ["html/created.rid"], Rake::Task[:rdoc].prerequisites
-  end
-
-  def test_tasks_creation_with_custom_name_symbol
-    rd = RDoc::Task.new(:rdoc_dev)
-    assert Rake::Task[:rdoc_dev]
-    assert Rake::Task[:clobber_rdoc_dev]
-    assert Rake::Task[:rerdoc_dev]
-    assert Rake::Task[:"rdoc_dev:coverage"]
-    assert_equal :rdoc_dev, rd.name
-  end
-
-  def test_tasks_option_parser
-    rdoc_task = RDoc::Task.new do |rd|
-      rd.title = "Test Tasks Option Parser"
-      rd.main = "README.md"
-      rd.rdoc_files.include("README.md")
-      rd.options << "--all"
-    end
-
-    assert_equal "Test Tasks Option Parser", rdoc_task.title
-    assert_equal "README.md", rdoc_task.main
-    assert rdoc_task.rdoc_files.include?("README.md")
-    assert rdoc_task.options.include?("--all")
-
-    args = %w[--all -o html --main README.md] << "--title" << "Test Tasks Option Parser" << "README.md"
-    assert_equal args, rdoc_task.option_list + rdoc_task.rdoc_files
-  end
-
-  def test_generator_option
-    rdoc_task = RDoc::Task.new do |rd|
-      rd.generator = "ri"
-    end
-
-    assert_equal %w[-o html -f ri], rdoc_task.option_list
-  end
-
-  def test_main_option
-    rdoc_task = RDoc::Task.new do |rd|
-      rd.main = "README.md"
-    end
-
-    assert_equal %w[-o html --main README.md], rdoc_task.option_list
-  end
-
-  def test_output_dir_option
-    rdoc_task = RDoc::Task.new do |rd|
-      rd.rdoc_dir = "zomg"
-    end
-
-    assert_equal %w[-o zomg], rdoc_task.option_list
-  end
-
-  def test_rdoc_task_description
-    assert_equal 'Build RDoc HTML files', @t.rdoc_task_description
-  end
-
-  def test_rerdoc_task_description
-    assert_equal 'Rebuild RDoc HTML files', @t.rerdoc_task_description
-  end
-
-  def test_coverage_task_description
-    assert_equal 'Print RDoc coverage report', @t.coverage_task_description
-  end
-
-  def test_tasks_creation_with_custom_name_string
-    rd = RDoc::Task.new("rdoc_dev")
-    assert Rake::Task[:rdoc_dev]
-    assert Rake::Task[:clobber_rdoc_dev]
-    assert Rake::Task[:rerdoc_dev]
-    assert Rake::Task[:"rdoc_dev:coverage"]
-    assert_equal "rdoc_dev", rd.name
-  end
-
-  def test_tasks_creation_with_custom_name_hash
-    options = {
-      :rdoc => "rdoc",
-      :clobber_rdoc => "rdoc:clean",
-      :rerdoc => "rdoc:force"
-    }
-
-    Rake::Task.clear
-
-    rd = RDoc::Task.new(options)
-    assert Rake::Task[:"rdoc"]
-    assert Rake::Task[:"rdoc:clean"]
-    assert Rake::Task[:"rdoc:force"]
-    assert Rake::Task[:"rdoc:coverage"]
-    assert_raise(RuntimeError) { Rake::Task[:clobber_rdoc] }
-    assert_equal options, rd.name
-  end
-
-  def test_tasks_creation_with_custom_name_hash_will_use_default_if_an_option_isnt_given
-    RDoc::Task.new(:clobber_rdoc => "rdoc:clean")
-    assert Rake::Task[:rdoc]
-    assert Rake::Task[:"rdoc:clean"]
-    assert Rake::Task[:rerdoc]
-    assert Rake::Task[:"rdoc:coverage"]
-  end
-
-  def test_tasks_creation_with_custom_name_hash_raises_exception_if_invalid_option_given
-    assert_raise(ArgumentError) do
-      RDoc::Task.new(:foo => "bar")
-    end
-
-    begin
-      RDoc::Task.new(:foo => "bar")
-    rescue ArgumentError => e
-      assert_match(/foo/, e.message)
-    end
-  end
-
-  def test_template_option
-    rdoc_task = RDoc::Task.new do |rd|
-      rd.template = "foo"
-    end
-
-    assert_equal %w[-o html -T foo], rdoc_task.option_list
-  end
-
-  def test_title_option
-    rdoc_task = RDoc::Task.new do |rd|
-      rd.title = "Test Title Option"
-    end
-
-    assert_equal %w[-o html] << "--title" << "Test Title Option", rdoc_task.option_list
-  end
-
-end if defined?(Rake::Task)
diff --git a/test/mri/rdoc/rdoc_text_test.rb b/test/mri/rdoc/rdoc_text_test.rb
deleted file mode 100644
index 2fd97614007..00000000000
--- a/test/mri/rdoc/rdoc_text_test.rb
+++ /dev/null
@@ -1,585 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'helper'
-require 'timeout'
-
-class RDocTextTest < RDoc::TestCase
-
-  include RDoc::Text
-
-  def setup
-    super
-
-    @options = RDoc::Options.new
-
-    @top_level = @store.add_file 'file.rb'
-    @language = nil
-  end
-
-  def test_self_encode_fallback
-    assert_equal '…',
-                 RDoc::Text::encode_fallback('…', Encoding::UTF_8,    '...')
-    assert_equal '...',
-                 RDoc::Text::encode_fallback('…', Encoding::US_ASCII, '...')
-  end
-
-  def test_expand_tabs
-    assert_equal("hello\n  dave",
-                 expand_tabs("hello\n  dave"), 'spaces')
-
-    assert_equal("hello\n        dave",
-                 expand_tabs("hello\n\tdave"), 'tab')
-
-    assert_equal("hello\n        dave",
-                 expand_tabs("hello\n \tdave"), '1 space tab')
-
-    assert_equal("hello\n        dave",
-                 expand_tabs("hello\n  \tdave"), '2 space tab')
-
-    assert_equal("hello\n        dave",
-                 expand_tabs("hello\n   \tdave"), '3 space tab')
-
-    assert_equal("hello\n        dave",
-                 expand_tabs("hello\n    \tdave"), '4 space tab')
-
-    assert_equal("hello\n        dave",
-                 expand_tabs("hello\n     \tdave"), '5 space tab')
-
-    assert_equal("hello\n        dave",
-                 expand_tabs("hello\n      \tdave"), '6 space tab')
-
-    assert_equal("hello\n        dave",
-                 expand_tabs("hello\n       \tdave"), '7 space tab')
-
-    assert_equal("hello\n                dave",
-                 expand_tabs("hello\n         \tdave"), '8 space tab')
-
-    assert_equal('.               .',
-                 expand_tabs(".\t\t."), 'dot tab tab dot')
-
-    assert_equal('a       a',
-                 Timeout.timeout(1) {expand_tabs("\ra\ta")}, "carriage return")
-  end
-
-  def test_expand_tabs_encoding
-    inn = "hello\ns\tdave"
-    inn = RDoc::Encoding.change_encoding inn, Encoding::BINARY
-
-    out = expand_tabs inn
-
-    assert_equal "hello\ns       dave", out
-    assert_equal Encoding::BINARY, out.encoding
-  end
-
-  def test_flush_left
-    text = <<-TEXT
-
-  we don't worry too much.
-
-  The comments associated with
-    TEXT
-
-    expected = <<-EXPECTED
-
-we don't worry too much.
-
-The comments associated with
-    EXPECTED
-
-    assert_equal expected, flush_left(text)
-  end
-
-  def test_flush_left_encoding
-    text = <<-TEXT
-
-  we don't worry too much.
-
-  The comments associated with
-    TEXT
-
-    text = RDoc::Encoding.change_encoding text, Encoding::US_ASCII
-
-    expected = <<-EXPECTED
-
-we don't worry too much.
-
-The comments associated with
-    EXPECTED
-
-    result = flush_left text
-
-    assert_equal expected, result
-    assert_equal Encoding::US_ASCII, result.encoding
-  end
-
-  def test_markup_string
-    out = markup('hi').gsub("\n", '')
-
-    assert_equal '<p>hi</p>', out
-  end
-
-  def test_markup_comment
-    out = markup(comment('hi')).gsub("\n", '')
-
-    assert_equal '<p>hi</p>', out
-  end
-
-  def test_normalize_comment_hash
-    text = <<-TEXT
-##
-# we don't worry too much.
-#
-# The comments associated with
-    TEXT
-
-    expected = <<-EXPECTED.rstrip
-we don't worry too much.
-
-The comments associated with
-    EXPECTED
-
-    @language = :ruby
-
-    assert_equal expected, normalize_comment(text)
-  end
-
-  def test_normalize_comment_stars_single_space
-    text = <<-TEXT
-/*
- * we don't worry too much.
- *
- * The comments associated with
- */
-    TEXT
-
-    expected = <<-EXPECTED.rstrip
-we don't worry too much.
-
-The comments associated with
-    EXPECTED
-
-    @language = :c
-
-    assert_equal expected, normalize_comment(text)
-  end
-
-  def test_normalize_comment_stars_single_double_space
-    text = <<-TEXT
-/*
- *  we don't worry too much.
- *
- *  The comments associated with
- */
-    TEXT
-
-    expected = <<-EXPECTED.rstrip
-we don't worry too much.
-
-The comments associated with
-    EXPECTED
-
-    @language = :c
-
-    assert_equal expected, normalize_comment(text)
-  end
-
-  def test_parse
-    assert_kind_of RDoc::Markup::Document, parse('hi')
-  end
-
-  def test_parse_comment
-    expected = RDoc::Markup::Document.new
-    expected.file = @top_level
-
-    c = comment ''
-    parsed = parse c
-
-    assert_equal expected, parsed
-    assert_same parsed, parse(c)
-  end
-
-  def test_parse_document
-    assert_equal RDoc::Markup::Document.new, parse(RDoc::Markup::Document.new)
-  end
-
-  def test_parse_empty
-    assert_equal RDoc::Markup::Document.new, parse('')
-  end
-
-  def test_parse_empty_newline
-    @language = :ruby
-
-    assert_equal RDoc::Markup::Document.new, parse("#\n")
-  end
-
-  def test_parse_format_markdown
-    expected =
-      @RM::Document.new(
-        @RM::Paragraph.new('it _works_'))
-
-    parsed = parse 'it *works*', 'markdown'
-
-    assert_equal expected, parsed
-  end
-
-  def test_parse_format_rd
-    expected =
-      @RM::Document.new(
-        @RM::Paragraph.new('it <em>works</em>'))
-
-    parsed = parse 'it ((*works*))', 'rd'
-
-    assert_equal expected, parsed
-  end
-
-  def test_parse_format_tomdoc
-    code = verb('1 + 1')
-    code.format = :ruby
-
-    expected =
-      doc(
-        para('It does a thing'),
-        blank_line,
-        head(3, 'Examples'),
-        blank_line,
-        code)
-
-    text = <<-TOMDOC
-It does a thing
-
-Examples
-
-  1 + 1
-    TOMDOC
-
-    parsed = parse text, 'tomdoc'
-
-    assert_equal expected, parsed
-  end
-
-  def test_parse_newline
-    assert_equal RDoc::Markup::Document.new, parse("\n")
-  end
-
-  def test_snippet
-    text = <<-TEXT
-This is one-hundred characters or more of text in a single paragraph.  This
-paragraph will be cut off some point after the one-hundredth character.
-    TEXT
-
-    expected = <<-EXPECTED
-<p>This is one-hundred characters or more of text in a single paragraph.  This paragraph will be cut off …
-    EXPECTED
-
-    assert_equal expected, snippet(text)
-  end
-
-  def test_snippet_comment
-    c = comment 'This is a comment'
-
-    assert_equal "<p>This is a comment\n", snippet(c)
-  end
-
-  def test_snippet_short
-    text = 'This is a comment'
-
-    assert_equal "<p>#{text}\n", snippet(text)
-  end
-
-  def test_strip_hashes
-    text = <<-TEXT
-##
-# we don't worry too much.
-#
-# The comments associated with
-    TEXT
-
-    expected = <<-EXPECTED
-
-  we don't worry too much.
-
-  The comments associated with
-    EXPECTED
-
-    assert_equal expected, strip_hashes(text)
-  end
-
-  def test_strip_hashes_encoding
-    text = <<-TEXT
-##
-# we don't worry too much.
-#
-# The comments associated with
-    TEXT
-
-    text = RDoc::Encoding.change_encoding text, Encoding::CP852
-
-    expected = <<-EXPECTED
-
-  we don't worry too much.
-
-  The comments associated with
-    EXPECTED
-
-    stripped = strip_hashes text
-
-    assert_equal expected, stripped
-    assert_equal Encoding::CP852, stripped.encoding
-  end
-
-  def test_strip_newlines
-    assert_equal ' ',  strip_newlines("\n \n")
-
-    assert_equal 'hi', strip_newlines("\n\nhi")
-
-    assert_equal 'hi', strip_newlines(    "hi\n\n")
-
-    assert_equal 'hi', strip_newlines("\n\nhi\n\n")
-  end
-
-  def test_strip_newlines_encoding
-    assert_equal Encoding::UTF_8, ''.encoding, 'Encoding sanity check'
-
-    text = " \n"
-    text = RDoc::Encoding.change_encoding text, Encoding::US_ASCII
-
-    stripped = strip_newlines text
-
-    assert_equal ' ', stripped
-
-    assert_equal Encoding::US_ASCII, stripped.encoding
-  end
-
-  def test_strip_stars
-    text = <<-TEXT
-/*
- * * we don't worry too much.
- *
- * The comments associated with
- */
-    TEXT
-
-    expected = <<-EXPECTED
-
-   * we don't worry too much.
-
-   The comments associated with
-    EXPECTED
-
-    assert_equal expected, strip_stars(text)
-  end
-
-  def test_strip_stars_document_method
-    text = <<-TEXT
-/*
- * Document-method: Zlib::GzipFile#mtime=
- *
- * A comment
- */
-    TEXT
-
-    expected = <<-EXPECTED
-
-   A comment
-    EXPECTED
-
-    assert_equal expected, strip_stars(text)
-  end
-
-  def test_strip_stars_document_method_special
-    text = <<-TEXT
-/*
- * Document-method: Zlib::GzipFile#mtime=
- * Document-method: []
- * Document-method: `
- * Document-method: |
- * Document-method: &
- * Document-method: <=>
- * Document-method: =~
- * Document-method: +
- * Document-method: -
- * Document-method: +@
- *
- * A comment
- */
-    TEXT
-
-    expected = <<-EXPECTED
-
-   A comment
-    EXPECTED
-
-    assert_equal expected, strip_stars(text)
-  end
-
-  def test_strip_stars_encoding
-    text = <<-TEXT
-/*
- * * we don't worry too much.
- *
- * The comments associated with
- */
-    TEXT
-
-    text = RDoc::Encoding.change_encoding text, Encoding::CP852
-
-    expected = <<-EXPECTED
-
-   * we don't worry too much.
-
-   The comments associated with
-    EXPECTED
-
-    result = strip_stars text
-
-    assert_equal expected, result
-    assert_equal Encoding::CP852, result.encoding
-  end
-
-  def test_strip_stars_encoding2
-    text = <<-TEXT
-/*
- * * we don't worry too much.
- *
- * The comments associated with
- */
-    TEXT
-
-    text = RDoc::Encoding.change_encoding text, Encoding::BINARY
-
-    expected = <<-EXPECTED
-
-   * we don't worry too much.
-
-   The comments associated with
-    EXPECTED
-
-    result = strip_stars text
-
-    assert_equal expected, result
-    assert_equal Encoding::BINARY, result.encoding
-  end
-
-  def test_strip_stars_no_stars
-    text = <<-TEXT
-* we don't worry too much.
-
-The comments associated with
-
-    TEXT
-
-    expected = <<-EXPECTED
-* we don't worry too much.
-
-The comments associated with
-
-    EXPECTED
-
-    assert_equal expected, strip_stars(text)
-  end
-
-  def test_to_html_apostrophe
-    assert_equal '‘a', to_html("'a")
-    assert_equal 'a’', to_html("a'")
-
-    assert_equal '‘a’ ‘', to_html("'a' '")
-  end
-
-  def test_to_html_apostrophe_entity
-    assert_equal '‘a', to_html("'a")
-    assert_equal 'a’', to_html("a'")
-
-    assert_equal '‘a’ ‘', to_html("'a' '")
-  end
-
-  def test_to_html_backslash
-    assert_equal 'S', to_html('\\S')
-  end
-
-  def test_to_html_br
-    assert_equal '<br>', to_html('<br>')
-  end
-
-  def test_to_html_copyright
-    assert_equal '©', to_html('(c)')
-    assert_equal '©', to_html('(C)')
-  end
-
-  def test_to_html_dash
-    assert_equal '-',  to_html('-')
-    assert_equal '–',  to_html('--')
-    assert_equal '—',  to_html('---')
-    assert_equal '—-', to_html('----')
-  end
-
-  def test_to_html_double_backtick
-    assert_equal '“a',  to_html('``a')
-    assert_equal '“a“', to_html('``a``')
-    assert_equal '“a”', to_html("``a''")
-  end
-
-  def test_to_html_double_quote
-    assert_equal '“a',  to_html('"a')
-    assert_equal '“a”', to_html('"a"')
-  end
-
-  def test_to_html_double_quote_quot
-    assert_equal '“a',  to_html('"a')
-    assert_equal '“a”', to_html('"a"')
-  end
-
-  def test_to_html_double_tick
-    assert_equal '”a',        to_html("''a")
-    assert_equal '”a”', to_html("''a''")
-  end
-
-  def test_to_html_ellipsis
-    assert_equal '..', to_html('..')
-    assert_equal '…',  to_html('...')
-    assert_equal '.…', to_html('....')
-  end
-
-  def test_to_html_encoding
-    s = '...(c)'.encode Encoding::Shift_JIS
-
-    html = to_html s
-
-    assert_equal Encoding::Shift_JIS, html.encoding
-
-    expected = '…(c)'.encode Encoding::Shift_JIS
-
-    assert_equal expected, html
-  end
-
-  def test_to_html_html_tag
-    assert_equal '<a href="http://example">hi’s</a>',
-                 to_html('<a href="http://example">hi\'s</a>')
-  end
-
-  def test_to_html_registered_trademark
-    assert_equal '®', to_html('(r)')
-    assert_equal '®', to_html('(R)')
-  end
-
-  def test_to_html_tt_tag
-    assert_equal '<tt>hi\'s</tt>',   to_html('<tt>hi\'s</tt>')
-    assert_equal '<tt>hi\\\'s</tt>', to_html('<tt>hi\\\\\'s</tt>')
-  end
-
-  def test_to_html_tt_tag_mismatch
-    _, err = verbose_capture_output do
-      assert_equal '<tt>hi', to_html('<tt>hi')
-    end
-
-    assert_equal "mismatched <tt> tag\n", err
-  end
-
-  def formatter
-    RDoc::Markup::ToHtml.new @options
-  end
-
-  def options
-    @options
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc_token_stream_test.rb b/test/mri/rdoc/rdoc_token_stream_test.rb
deleted file mode 100644
index a5f1930daa6..00000000000
--- a/test/mri/rdoc/rdoc_token_stream_test.rb
+++ /dev/null
@@ -1,109 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocTokenStreamTest < RDoc::TestCase
-
-  def test_class_to_html
-    tokens = [
-      { :line_no => 0, :char_no => 0, :kind => :on_const, :text => 'CONSTANT' },
-      { :line_no => 0, :char_no => 0, :kind => :on_kw, :text => 'KW' },
-      { :line_no => 0, :char_no => 0, :kind => :on_ivar, :text => 'IVAR' },
-      { :line_no => 0, :char_no => 0, :kind => :on_op, :text => 'Op' },
-      { :line_no => 0, :char_no => 0, :kind => :on_ident, :text => 'Id' },
-      { :line_no => 0, :char_no => 0, :kind => :on_backref, :text => 'Node' },
-      { :line_no => 0, :char_no => 0, :kind => :on_comment, :text => 'COMMENT' },
-      { :line_no => 0, :char_no => 0, :kind => :on_regexp, :text => 'REGEXP' },
-      { :line_no => 0, :char_no => 0, :kind => :on_tstring, :text => 'STRING' },
-      { :line_no => 0, :char_no => 0, :kind => :on_int, :text => 'Val' },
-      { :line_no => 0, :char_no => 0, :kind => :on_unknown, :text => '\\' }
-    ]
-
-    expected = [
-      '<span class="ruby-constant">CONSTANT</span>',
-      '<span class="ruby-keyword">KW</span>',
-      '<span class="ruby-ivar">IVAR</span>',
-      '<span class="ruby-operator">Op</span>',
-      '<span class="ruby-identifier">Id</span>',
-      '<span class="ruby-node">Node</span>',
-      '<span class="ruby-comment">COMMENT</span>',
-      '<span class="ruby-regexp">REGEXP</span>',
-      '<span class="ruby-string">STRING</span>',
-      '<span class="ruby-value">Val</span>',
-      '\\'
-    ].join
-
-    assert_equal expected, RDoc::TokenStream.to_html(tokens)
-  end
-
-  def test_class_to_html_empty
-    assert_equal '', RDoc::TokenStream.to_html([])
-  end
-
-  def test_add_tokens
-    foo = Class.new do
-      include RDoc::TokenStream
-    end.new
-    foo.collect_tokens
-    foo.add_tokens([:token])
-    assert_equal [:token], foo.token_stream
-  end
-
-  def test_add_token
-    foo = Class.new do
-      include RDoc::TokenStream
-    end.new
-    foo.collect_tokens
-    foo.add_token(:token)
-    assert_equal [:token], foo.token_stream
-  end
-
-  def test_collect_tokens
-    foo = Class.new do
-      include RDoc::TokenStream
-    end.new
-    foo.collect_tokens
-    assert_equal [], foo.token_stream
-  end
-
-  def test_pop_token
-    foo = Class.new do
-      include RDoc::TokenStream
-    end.new
-    foo.collect_tokens
-    foo.add_token(:token)
-    foo.pop_token
-    assert_equal [], foo.token_stream
-  end
-
-  def test_token_stream
-    foo = Class.new do
-      include RDoc::TokenStream
-    end.new
-    assert_equal nil, foo.token_stream
-  end
-
-  def test_tokens_to_s
-    foo = Class.new do
-      include RDoc::TokenStream
-
-      def initialize
-        @token_stream = [
-          { line_no: 0, char_no: 0, kind: :on_ident,   text: "foo" },
-          { line_no: 0, char_no: 0, kind: :on_sp,      text: " " },
-          { line_no: 0, char_no: 0, kind: :on_tstring, text: "'bar'" },
-        ]
-      end
-    end.new
-
-    assert_equal "foo 'bar'", foo.tokens_to_s
-
-    foo = Class.new do
-      include RDoc::TokenStream
-
-      def initialize
-        @token_stream = nil
-      end
-    end.new
-    assert_equal "", foo.tokens_to_s
-  end
-end
diff --git a/test/mri/rdoc/rdoc_tom_doc_test.rb b/test/mri/rdoc/rdoc_tom_doc_test.rb
deleted file mode 100644
index 941d027f243..00000000000
--- a/test/mri/rdoc/rdoc_tom_doc_test.rb
+++ /dev/null
@@ -1,579 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class RDocTomDocTest < RDoc::TestCase
-
-  def setup
-    super
-
-    @top_level = @store.add_file 'file.rb'
-
-    @TD = RDoc::TomDoc
-    @td = @TD.new
-  end
-
-  def test_class_add_post_processor
-    RDoc::TomDoc.add_post_processor
-
-    pp = RDoc::Markup::PreProcess.new __FILE__, []
-
-    text = "# Public: Do some stuff\n"
-
-    comment = RDoc::Comment.new text, nil
-    comment.format = 'tomdoc'
-
-    parent = RDoc::Context.new
-
-    pp.handle comment, parent
-
-    method = parent.add_method RDoc::AnyMethod.new(nil, 'm')
-
-    assert_equal 'Public', method.section.title
-    assert_equal "# Do some stuff\n", comment.text
-  end
-
-  def test_class_signature
-    c = comment <<-COMMENT
-Signature
-
-  method_<here>(args)
-
-here - something
-    COMMENT
-    c.format = 'tomdoc'
-
-    signature = @TD.signature c
-
-    assert_equal "method_<here>(args)\n", signature
-  end
-
-  def test_class_signature_no_space
-    c = comment <<-COMMENT
-Signature
-  method_<here>(args)
-
-here - something
-    COMMENT
-    c.format = 'tomdoc'
-
-    signature = @TD.signature c
-
-    assert_equal "method_<here>(args)\n", signature
-
-    expected =
-      doc(
-        head(3, 'Signature'),
-        list(:NOTE,
-          item(%w[here],
-            para('something'))))
-    expected.file = @top_level
-
-    assert_equal expected, c.parse
-  end
-
-  def test_class_signature_none
-    c = comment ''
-    c.format = 'tomdoc'
-
-    assert_nil @TD.signature c
-  end
-
-  def test_class_rdoc
-    c = comment <<-COMMENT
-=== Signature
-
-  method_<here>(args)
-
-here - something
-    COMMENT
-    c.format = 'rdoc'
-
-    signature = @TD.signature c
-
-    assert_nil signature
-  end
-
-  def test_class_signature_two_space
-    c = comment <<-COMMENT
-Signature
-
-
-  method_<here>(args)
-
-here - something
-    COMMENT
-    c.format = 'tomdoc'
-
-    signature = @TD.signature c
-
-    assert_equal "method_<here>(args)\n", signature
-
-    expected =
-      doc(
-        head(3, 'Signature'),
-        list(:NOTE,
-          item(%w[here],
-            para('something'))))
-    expected.file = @top_level
-
-    assert_equal expected, c.parse
-  end
-
-  def test_parse_paragraph
-    text = "Public: Do some stuff\n"
-
-    expected =
-      @RM::Document.new(
-        @RM::Paragraph.new('Do some stuff'))
-
-    assert_equal expected, @TD.parse(text)
-  end
-
-  def test_parse_multiline_paragraph
-    text = "Public: Do some stuff\n"
-    text += "On a new line\n"
-
-    expected =
-      doc(
-        para('Do some stuff', ' ', 'On a new line'))
-
-    assert_equal expected, @TD.parse(text)
-  end
-
-  def test_parse_arguments
-    text = <<-TEXT
-Create new Arg object.
-
-name        - name of argument
-description - arguments description
-    TEXT
-
-    expected =
-      doc(
-        para('Create new Arg object.'),
-        blank_line,
-        list(:NOTE,
-          item(%w[name],
-            para('name of argument')),
-          item(%w[description],
-            para('arguments description'))))
-
-    assert_equal expected, @TD.parse(text)
-  end
-
-  def test_parse_arguments_array
-    text = <<-TEXT
-Create new Arg object.
-
-names[] - names of arguments
-    TEXT
-
-    expected =
-      doc(
-        para('Create new Arg object.'),
-        blank_line,
-        list(:NOTE,
-          item(%w[names[]],
-            para('names of arguments'))))
-
-    assert_equal expected, @TD.parse(text)
-  end
-
-  def test_parse_arguments_multiline
-    text = <<-TEXT
-Do some stuff
-
-foo - A comment goes here
-  and is more than one line
-    TEXT
-
-    expected =
-      doc(
-        para('Do some stuff'),
-        blank_line,
-        list(:NOTE,
-          item(%w[foo],
-            para('A comment goes here', ' ', 'and is more than one line'))))
-
-    assert_equal expected, @TD.parse(text)
-  end
-
-  def test_parse_arguments_nested
-    text = <<-TEXT
-Do some stuff
-
-foo - A comment goes here
-      :bar - bar documentation
-    TEXT
-
-    expected =
-      doc(
-        para('Do some stuff'),
-        blank_line,
-        list(:NOTE,
-          item(%w[foo],
-            para('A comment goes here'),
-            list(:NOTE,
-              item(%w[:bar],
-                para('bar documentation'))))))
-
-    assert_equal expected, @TD.parse(text)
-  end
-
-  def test_parse_examples
-    text = <<-TEXT
-Do some stuff
-
-Examples
-
-  1 + 1
-    TEXT
-
-    code = verb("1 + 1\n")
-    code.format = :ruby
-
-    expected =
-      doc(
-        para('Do some stuff'),
-        blank_line,
-        head(3, 'Examples'),
-        blank_line,
-        code)
-
-    document = @TD.parse(text)
-    assert_equal expected, document
-    assert document.parts.last.ruby?
-  end
-
-  def test_parse_examples_signature
-    text = <<-TEXT
-Do some stuff
-
-Examples
-
-  1 + 1
-
-Signature
-
-  foo(args)
-    TEXT
-
-    code1 = verb("1 + 1\n")
-    code1.format = :ruby
-
-    code2 = verb("foo(args)\n")
-
-    expected =
-      doc(
-        para('Do some stuff'),
-        blank_line,
-        head(3, 'Examples'),
-        blank_line,
-        code1,
-        head(3, 'Signature'),
-        blank_line,
-        code2)
-
-    document = @TD.parse text
-
-    assert_equal expected, document
-  end
-
-  def test_parse_returns
-    text = <<-TEXT
-Do some stuff
-
-Returns a thing
-
-Returns another thing
-    TEXT
-
-    expected =
-      doc(
-        para('Do some stuff'),
-        blank_line,
-        head(3, 'Returns'),
-        blank_line,
-        para('Returns a thing'),
-        blank_line,
-        para('Returns another thing'))
-
-    assert_equal expected, @TD.parse(text)
-  end
-
-  def test_parse_returns_with_raises
-    text = <<-TEXT
-Do some stuff
-
-Returns a thing
-Raises ArgumentError when stuff
-Raises StandardError when stuff
-    TEXT
-    expected =
-      doc(
-        para('Do some stuff'),
-        blank_line,
-        head(3, 'Returns'),
-        blank_line,
-        para('Returns a thing'),
-        para('Raises ArgumentError when stuff'),
-        para('Raises StandardError when stuff'))
-
-    assert_equal expected, @TD.parse(text)
-  end
-
-  def test_parse_raises_without_returns
-    text = <<-TEXT
-Do some stuff
-
-Raises ArgumentError when stuff
-    TEXT
-    expected =
-      doc(
-        para('Do some stuff'),
-        blank_line,
-        head(3, 'Returns'),
-        blank_line,
-        para('Raises ArgumentError when stuff'))
-
-    assert_equal expected, @TD.parse(text)
-  end
-
-  def test_parse_returns_multiline
-    text = <<-TEXT
-Do some stuff
-
-Returns a thing
-  that is multiline
-    TEXT
-
-    expected =
-      doc(
-        para('Do some stuff'),
-        blank_line,
-        head(3, 'Returns'),
-        blank_line,
-        para('Returns a thing', ' ', 'that is multiline'))
-
-    assert_equal expected, @TD.parse(text)
-  end
-
-  def test_parse_returns_multiline_and_raises
-    text = <<-TEXT
-Do some stuff
-
-Returns a thing
-  that is multiline
-Raises ArgumentError
-    TEXT
-
-    expected =
-      doc(
-        para('Do some stuff'),
-        blank_line,
-        head(3, 'Returns'),
-        blank_line,
-        para('Returns a thing', ' ', 'that is multiline'),
-        para('Raises ArgumentError'))
-
-    assert_equal expected, @TD.parse(text)
-  end
-
-  def test_parse_signature
-    text = <<-TEXT
-Do some stuff
-
-Signature
-
-  some_method(args)
-    TEXT
-
-    expected =
-      @RM::Document.new(
-        @RM::Paragraph.new('Do some stuff'),
-        @RM::BlankLine.new,
-        @RM::Heading.new(3, 'Signature'),
-        @RM::BlankLine.new,
-        @RM::Verbatim.new("some_method(args)\n"))
-
-    assert_equal expected, @TD.parse(text)
-  end
-
-  def test_tokenize_paragraph
-    @td.tokenize "Public: Do some stuff\n"
-
-    expected = [
-      [:TEXT,    "Do some stuff",  0, 0],
-      [:NEWLINE, "\n",            13, 0],
-    ]
-
-    assert_equal expected, @td.tokens
-  end
-
-  def test_tokenize_multiline_paragraph
-    text = "Public: Do some stuff\n"
-    text += "On a new line\n"
-
-    @td.tokenize text
-
-    expected = [
-      [:TEXT,     "Do some stuff",   0, 0],
-      [:NEWLINE,  "\n",             13, 0],
-      [:TEXT,     "On a new line",   0, 1],
-      [:NEWLINE,  "\n",             13, 1]
-    ]
-
-    assert_equal expected, @td.tokens
-  end
-
-  def test_tokenize_arguments
-    @td.tokenize <<-TEXT
-Create new Arg object.
-
-name        - name of argument
-description - arguments description
-    TEXT
-
-    expected = [
-      [:TEXT,    "Create new Arg object.",  0, 0],
-      [:NEWLINE, "\n",                     22, 0],
-      [:NEWLINE, "\n",                      0, 1],
-      [:NOTE,    "name",                    0, 2],
-      [:TEXT,    "name of argument",       14, 2],
-      [:NEWLINE, "\n",                     30, 2],
-      [:NOTE,    "description",             0, 3],
-      [:TEXT,    "arguments description",  14, 3],
-      [:NEWLINE, "\n",                     35, 3],
-    ]
-
-    assert_equal expected, @td.tokens
-  end
-
-  def test_tokenize_arguments_array
-    @td.tokenize <<-TEXT
-Create new Arg object.
-
-names[stuff] - names of arguments
-    TEXT
-
-    expected = [
-      [:TEXT,    "Create new Arg object.",  0, 0],
-      [:NEWLINE, "\n",                     22, 0],
-      [:NEWLINE, "\n",                      0, 1],
-      [:NOTE,    "names[stuff]",            0, 2],
-      [:TEXT,    "names of arguments",     15, 2],
-      [:NEWLINE, "\n",                     33, 2],
-    ]
-
-    assert_equal expected, @td.tokens
-  end
-
-  def test_tokenize_arguments_multiline
-    @td.tokenize <<-TEXT
-Do some stuff
-
-foo - A comment goes here
-  and is more than one line
-    TEXT
-
-    expected = [
-      [:TEXT,    "Do some stuff",              0, 0],
-      [:NEWLINE, "\n",                        13, 0],
-      [:NEWLINE, "\n",                         0, 1],
-      [:NOTE,    "foo",                        0, 2],
-      [:TEXT,    "A comment goes here",        6, 2],
-      [:NEWLINE, "\n",                        25, 2],
-      [:TEXT,    "and is more than one line",  2, 3],
-      [:NEWLINE, "\n",                        27, 3],
-    ]
-
-    assert_equal expected, @td.tokens
-  end
-
-  def test_tokenize_arguments_nested
-    @td.tokenize <<-TEXT
-Do some stuff
-
-foo - A comment goes here
-      :bar - bar documentation
-    TEXT
-
-    expected = [
-      [:TEXT,    "Do some stuff",              0, 0],
-      [:NEWLINE, "\n",                        13, 0],
-      [:NEWLINE, "\n",                         0, 1],
-      [:NOTE,    "foo",                        0, 2],
-      [:TEXT,    "A comment goes here",        6, 2],
-      [:NEWLINE, "\n",                        25, 2],
-      [:NOTE,    ":bar",                       6, 3],
-      [:TEXT,    "bar documentation",         13, 3],
-      [:NEWLINE, "\n",                        30, 3],
-    ]
-
-    assert_equal expected, @td.tokens
-  end
-
-  def test_tokenize_examples
-    @td.tokenize <<-TEXT
-Do some stuff
-
-Examples
-
-  1 + 1
-    TEXT
-
-    expected = [
-      [:TEXT,    "Do some stuff",  0, 0],
-      [:NEWLINE, "\n",            13, 0],
-      [:NEWLINE, "\n",             0, 1],
-      [:HEADER,  3,                0, 2],
-      [:TEXT,    "Examples",       0, 2],
-      [:NEWLINE, "\n",             8, 2],
-      [:NEWLINE, "\n",             0, 3],
-      [:TEXT,    "1 + 1",          2, 4],
-      [:NEWLINE, "\n",             7, 4],
-    ]
-
-    assert_equal expected, @td.tokens
-  end
-
-  def test_tokenize_returns
-    @td.tokenize <<-TEXT
-Do some stuff
-
-Returns a thing
-    TEXT
-
-    expected = [
-      [:TEXT,    "Do some stuff",    0, 0],
-      [:NEWLINE, "\n",              13, 0],
-      [:NEWLINE, "\n",               0, 1],
-      [:TEXT,    "Returns a thing",  0, 2],
-      [:NEWLINE, "\n",              15, 2],
-    ]
-
-    assert_equal expected, @td.tokens
-  end
-
-  def test_tokenize_returns_multiline
-    @td.tokenize <<-TEXT
-Do some stuff
-
-Returns a thing
-  that is multiline
-    TEXT
-
-    expected = [
-      [:TEXT,    "Do some stuff",      0, 0],
-      [:NEWLINE, "\n",                13, 0],
-      [:NEWLINE, "\n",                 0, 1],
-      [:TEXT,    "Returns a thing",    0, 2],
-      [:NEWLINE, "\n",                15, 2],
-      [:TEXT,    "that is multiline",  2, 3],
-      [:NEWLINE, "\n",                19, 3],
-    ]
-
-    assert_equal expected, @td.tokens
-  end
-
-end
diff --git a/test/mri/rdoc/rdoc_top_level_test.rb b/test/mri/rdoc/rdoc_top_level_test.rb
deleted file mode 100644
index 385860517b3..00000000000
--- a/test/mri/rdoc/rdoc_top_level_test.rb
+++ /dev/null
@@ -1,289 +0,0 @@
-# frozen_string_literal: true
-require_relative 'xref_test_case'
-
-class RDocTopLevelTest < XrefTestCase
-
-  def setup
-    super
-
-    @top_level = @store.add_file 'path/top_level.rb'
-    @top_level.parser = RDoc::Parser::Ruby
-  end
-
-  def test_initialize
-    t = RDoc::TopLevel.new 'path/file.rb'
-
-    assert_equal 'path/file.rb', t.absolute_name
-    assert_equal 'path/file.rb', t.relative_name
-  end
-
-  def test_initialize_relative
-    t = RDoc::TopLevel.new 'path/file.rb', 'file.rb'
-
-    assert_equal 'path/file.rb', t.absolute_name
-    assert_equal 'file.rb',      t.relative_name
-  end
-
-  def test_add_alias
-    a = RDoc::Alias.new nil, 'old', 'new', nil
-    @top_level.add_alias a
-
-    object = @store.find_class_named 'Object'
-    expected = { '#old' => [a] }
-    assert_equal expected, object.unmatched_alias_lists
-    assert_includes object.in_files, @top_level
-  end
-
-  def test_add_alias_nodoc
-    @top_level.document_self = false
-
-    a = RDoc::Alias.new nil, 'old', 'new', nil
-    @top_level.add_alias a
-
-    object = @store.find_class_named('Object')
-    assert_empty object.unmatched_alias_lists
-    assert_includes object.in_files, @top_level
-  end
-
-  def test_add_constant
-    const = RDoc::Constant.new 'C', nil, nil
-    @top_level.add_constant const
-
-    object = @store.find_class_named 'Object'
-    assert_equal [const], object.constants
-    assert_includes object.in_files, @top_level
-  end
-
-  def test_add_constant_nodoc
-    @top_level.document_self = false
-
-    const = RDoc::Constant.new 'C', nil, nil
-    @top_level.add_constant const
-
-    object = @store.find_class_named 'Object'
-    assert_empty object.constants
-    assert_includes object.in_files, @top_level
-  end
-
-  def test_add_include
-    include = RDoc::Include.new 'C', nil
-    @top_level.add_include include
-
-    object = @store.find_class_named 'Object'
-    assert_equal [include], object.includes
-    assert_includes object.in_files, @top_level
-  end
-
-  def test_add_include_nodoc
-    @top_level.document_self = false
-
-    include = RDoc::Include.new 'C', nil
-    @top_level.add_include include
-
-    object = @store.find_class_named('Object')
-    assert_empty object.includes
-    assert_includes object.in_files, @top_level
-  end
-
-  def test_add_method
-    method = RDoc::AnyMethod.new nil, 'm'
-    @top_level.add_method method
-
-    object = @store.find_class_named 'Object'
-    assert_equal [@c10_method, @c11_method, method], object.method_list
-    assert_includes object.in_files, @top_level
-  end
-
-  def test_add_method_stopdoc
-    @top_level.document_self = false
-
-    method = RDoc::AnyMethod.new nil, 'm'
-    @top_level.add_method method
-
-    object = @store.find_class_named('Object')
-    assert_equal [@c10_method, @c11_method], object.method_list
-    assert_includes object.in_files, @top_level
-  end
-
-  def test_base_name
-    assert_equal 'top_level.rb', @top_level.base_name
-  end
-
-  def test_display_eh
-    refute @top_level.display?
-
-    page = @store.add_file 'README.txt'
-    page.parser = RDoc::Parser::Simple
-
-    assert page.display?
-  end
-
-  def test_eql_eh
-    top_level2 = @store.add_file 'path/top_level.rb'
-    other_level = @store.add_file 'path/other_level.rb'
-
-    assert_operator @top_level, :eql?, top_level2
-
-    refute_operator other_level, :eql?, @top_level
-  end
-
-  def test_equals2
-    top_level2 = @store.add_file 'path/top_level.rb'
-    other_level = @store.add_file 'path/other_level.rb'
-
-    assert_equal @top_level, top_level2
-
-    refute_equal other_level, @top_level
-  end
-
-  def test_find_class_or_module
-    assert_equal @c1,    @xref_data.find_class_or_module('C1')
-    assert_equal @c2_c3, @xref_data.find_class_or_module('C2::C3')
-    assert_equal @c4,    @xref_data.find_class_or_module('C4')
-    assert_equal @m1_m2, @xref_data.find_class_or_module('M1::M2')
-  end
-
-  def test_full_name
-    assert_equal 'path/top_level.rb', @top_level.full_name
-  end
-
-  def test_hash
-    tl2 = @store.add_file 'path/top_level.rb'
-    tl3 = @store.add_file 'other/top_level.rb'
-
-    assert_equal @top_level.hash, tl2.hash
-    refute_equal @top_level.hash, tl3.hash
-  end
-
-  def test_http_url
-    assert_equal 'path/top_level_rb.html', @top_level.http_url
-
-    other_level = @store.add_file 'path.other/level.rb'
-    assert_equal 'path_other/level_rb.html', other_level.http_url
-  end
-
-  def test_path
-    assert_equal 'path/top_level_rb.html', @top_level.path
-
-    @options.file_path_prefix = 'file'
-    assert_equal 'file/path/top_level_rb.html', @top_level.path
-  end
-
-  def test_marshal_dump
-    page = @store.add_file 'README.txt'
-    page.parser = RDoc::Parser::Simple
-    page.comment = RDoc::Comment.new 'This is a page', page
-
-    loaded = Marshal.load Marshal.dump page
-
-    document = RDoc::Markup::Document.new(
-                 RDoc::Markup::Paragraph.new('This is a page'))
-    document.file = loaded
-
-    assert_equal page, loaded
-
-    assert_equal 'README.txt', loaded.absolute_name
-    assert_equal 'README.txt', loaded.relative_name
-
-    assert_equal RDoc::Parser::Simple, loaded.parser
-
-    assert_equal document, loaded.comment.parse
-  end
-
-  def test_marshal_load_version_0
-    loaded = Marshal.load "\x04\bU:\x13RDoc::TopLevel" +
-                          "[\ti\x00I\"\x0FREADME.txt\x06:\x06EF" +
-                          "c\x19RDoc::Parser::Simple" +
-                          "o:\eRDoc::Markup::Document\a:\v@parts" +
-                          "[\x06o:\x1CRDoc::Markup::Paragraph\x06;\b" +
-                          "[\x06I\"\x13This is a page\x06;\x06F:\n@file@\a"
-
-    document = RDoc::Markup::Document.new(
-                 RDoc::Markup::Paragraph.new('This is a page'))
-    document.file = loaded
-
-    assert_equal 'README.txt', loaded.absolute_name
-    assert_equal 'README.txt', loaded.relative_name
-
-    assert_equal RDoc::Parser::Simple, loaded.parser
-
-    assert_equal document, loaded.comment.parse
-
-    assert loaded.display?
-  end
-
-  def test_name
-    assert_equal 'top_level.rb', @top_level.name
-  end
-
-  def test_page_name
-    assert_equal 'top_level', @top_level.page_name
-
-    tl = @store.add_file 'README.ja'
-
-    assert_equal 'README.ja', tl.page_name
-
-    tl = @store.add_file 'Rakefile'
-
-    assert_equal 'Rakefile', tl.page_name
-  end
-
-  def test_page_name_trim_extension
-    tl = @store.add_file 'README.ja.rdoc'
-
-    assert_equal 'README.ja', tl.page_name
-
-    tl = @store.add_file 'README.ja.md'
-
-    assert_equal 'README.ja', tl.page_name
-
-    tl = @store.add_file 'README.txt'
-
-    assert_equal 'README', tl.page_name
-  end
-
-  def test_search_record
-    assert_nil @xref_data.search_record
-  end
-
-  def test_search_record_page
-    page = @store.add_file 'README.txt'
-    page.parser = RDoc::Parser::Simple
-    page.comment = 'This is a comment.'
-
-    expected = [
-      'README',
-      '',
-      'README',
-      '',
-      'README_txt.html',
-      '',
-      "<p>This is a comment.\n",
-    ]
-
-    assert_equal expected, page.search_record
-  end
-
-  def test_text_eh
-    refute @xref_data.text?
-
-    rd = @store.add_file 'rd_format.rd'
-    rd.parser = RDoc::Parser::RD
-
-    assert rd.text?
-
-    simple = @store.add_file 'simple.txt'
-    simple.parser = RDoc::Parser::Simple
-
-    assert simple.text?
-  end
-
-  def test_text_eh_no_parser
-    refute @xref_data.text?
-
-    rd = @store.add_file 'rd_format.rd'
-
-    refute rd.text?
-  end
-
-end
diff --git a/test/mri/reline/helper.rb b/test/mri/reline/helper.rb
deleted file mode 100644
index 6f470a617fe..00000000000
--- a/test/mri/reline/helper.rb
+++ /dev/null
@@ -1,158 +0,0 @@
-$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
-
-ENV['TERM'] = 'xterm' # for some CI environments
-
-require 'reline'
-require 'test/unit'
-
-begin
-  require 'rbconfig'
-rescue LoadError
-end
-
-begin
-  # This should exist and available in load path when this file is mirrored to ruby/ruby and running at there
-  if File.exist?(File.expand_path('../../tool/lib/envutil.rb', __dir__))
-    require 'envutil'
-  end
-rescue LoadError
-end
-
-module Reline
-  class << self
-    def test_mode(ansi: false)
-      @original_iogate = IOGate
-
-      if defined?(RELINE_TEST_ENCODING)
-        encoding = RELINE_TEST_ENCODING
-      else
-        encoding = Encoding::UTF_8
-      end
-
-      if ansi
-        new_io_gate = ANSI.new
-        # Setting ANSI gate's screen size through set_screen_size will also change the tester's stdin's screen size
-        # Let's avoid that side-effect by stubbing the get_screen_size method
-        new_io_gate.define_singleton_method(:get_screen_size) do
-          [24, 80]
-        end
-        new_io_gate.define_singleton_method(:encoding) do
-          encoding
-        end
-      else
-        new_io_gate = Dumb.new(encoding: encoding)
-      end
-
-      remove_const('IOGate')
-      const_set('IOGate', new_io_gate)
-      core.config.instance_variable_set(:@test_mode, true)
-      core.config.reset
-    end
-
-    def test_reset
-      remove_const('IOGate')
-      const_set('IOGate', @original_iogate)
-      Reline.instance_variable_set(:@core, nil)
-    end
-
-    # Return a executable name to spawn Ruby process. In certain build configuration,
-    # "ruby" may not be available.
-    def test_rubybin
-      # When this test suite is running in ruby/ruby, prefer EnvUtil result over original implementation
-      if const_defined?(:EnvUtil)
-        return EnvUtil.rubybin
-      end
-
-      # The following is a simplified port of EnvUtil.rubybin in ruby/ruby
-      if ruby = ENV["RUBY"]
-        return ruby
-      end
-      ruby = "ruby"
-      exeext = RbConfig::CONFIG["EXEEXT"]
-      rubyexe = (ruby + exeext if exeext and !exeext.empty?)
-      if File.exist? ruby and File.executable? ruby and !File.directory? ruby
-        return File.expand_path(ruby)
-      end
-      if rubyexe and File.exist? rubyexe and File.executable? rubyexe
-        return File.expand_path(rubyexe)
-      end
-      if defined?(RbConfig.ruby)
-        RbConfig.ruby
-      else
-        "ruby"
-      end
-    end
-  end
-end
-
-class Reline::TestCase < Test::Unit::TestCase
-  private def convert_str(input)
-    input.encode(@line_editor.encoding, Encoding::UTF_8)
-  end
-
-  def omit_unless_utf8
-    omit "This test is for UTF-8 but the locale is #{Reline.core.encoding}" if Reline.core.encoding != Encoding::UTF_8
-  end
-
-  def input_key_by_symbol(method_symbol, char: nil, csi: false)
-    char ||= csi ? "\e[A" : "\C-a"
-    @line_editor.input_key(Reline::Key.new(char, method_symbol, false))
-  end
-
-  def input_keys(input)
-    input = convert_str(input)
-
-    key_stroke = Reline::KeyStroke.new(@config, @encoding)
-    input_bytes = input.bytes
-    until input_bytes.empty?
-      expanded, input_bytes = key_stroke.expand(input_bytes)
-      expanded.each do |key|
-        @line_editor.input_key(key)
-      end
-    end
-  end
-
-  def set_line_around_cursor(before, after)
-    input_keys("\C-a\C-k")
-    input_keys(after)
-    input_keys("\C-a")
-    input_keys(before)
-  end
-
-  def assert_line_around_cursor(before, after)
-    before = convert_str(before)
-    after = convert_str(after)
-    line = @line_editor.current_line
-    byte_pointer = @line_editor.instance_variable_get(:@byte_pointer)
-    actual_before = line.byteslice(0, byte_pointer)
-    actual_after = line.byteslice(byte_pointer..)
-    assert_equal([before, after], [actual_before, actual_after])
-  end
-
-  def assert_byte_pointer_size(expected)
-    expected = convert_str(expected)
-    byte_pointer = @line_editor.instance_variable_get(:@byte_pointer)
-    chunk = @line_editor.line.byteslice(0, byte_pointer)
-    assert_equal(
-      expected.bytesize, byte_pointer,
-      <<~EOM)
-        <#{expected.inspect} (#{expected.encoding.inspect})> expected but was
-        <#{chunk.inspect} (#{chunk.encoding.inspect})> in <Terminal #{Reline::Dumb.new.encoding.inspect}>
-      EOM
-  end
-
-  def assert_line_index(expected)
-    assert_equal(expected, @line_editor.instance_variable_get(:@line_index))
-  end
-
-  def assert_whole_lines(expected)
-    assert_equal(expected, @line_editor.whole_lines)
-  end
-
-  def assert_key_binding(input, method_symbol, editing_modes = [:emacs, :vi_insert, :vi_command])
-    editing_modes.each do |editing_mode|
-      @config.editing_mode = editing_mode
-      assert_equal(method_symbol, @config.editing_mode.get(input.bytes))
-    end
-  end
-end
diff --git a/test/mri/reline/test_ansi.rb b/test/mri/reline/test_ansi.rb
deleted file mode 100644
index 5e28e72b06c..00000000000
--- a/test/mri/reline/test_ansi.rb
+++ /dev/null
@@ -1,72 +0,0 @@
-require_relative 'helper'
-require 'reline'
-
-class Reline::ANSITest < Reline::TestCase
-  def setup
-    Reline.send(:test_mode, ansi: true)
-    @config = Reline::Config.new
-    Reline.core.io_gate.set_default_key_bindings(@config)
-  end
-
-  def teardown
-    Reline.test_reset
-  end
-
-  def test_home
-    assert_key_binding("\e[1~", :ed_move_to_beg) # Console (80x25)
-    assert_key_binding("\e[H", :ed_move_to_beg) # KDE
-    assert_key_binding("\e[7~", :ed_move_to_beg) # urxvt / exoterm
-    assert_key_binding("\eOH", :ed_move_to_beg) # GNOME
-  end
-
-  def test_end
-    assert_key_binding("\e[4~", :ed_move_to_end) # Console (80x25)
-    assert_key_binding("\e[F", :ed_move_to_end) # KDE
-    assert_key_binding("\e[8~", :ed_move_to_end) # urxvt / exoterm
-    assert_key_binding("\eOF", :ed_move_to_end) # GNOME
-  end
-
-  def test_delete
-    assert_key_binding("\e[3~", :key_delete)
-  end
-
-  def test_up_arrow
-    assert_key_binding("\e[A", :ed_prev_history) # Console (80x25)
-    assert_key_binding("\eOA", :ed_prev_history)
-  end
-
-  def test_down_arrow
-    assert_key_binding("\e[B", :ed_next_history) # Console (80x25)
-    assert_key_binding("\eOB", :ed_next_history)
-  end
-
-  def test_right_arrow
-    assert_key_binding("\e[C", :ed_next_char) # Console (80x25)
-    assert_key_binding("\eOC", :ed_next_char)
-  end
-
-  def test_left_arrow
-    assert_key_binding("\e[D", :ed_prev_char) # Console (80x25)
-    assert_key_binding("\eOD", :ed_prev_char)
-  end
-
-  # Ctrl+arrow and Meta+arrow
-  def test_extended
-    assert_key_binding("\e[1;5C", :em_next_word) # Ctrl+→
-    assert_key_binding("\e[1;5D", :ed_prev_word) # Ctrl+←
-    assert_key_binding("\e[1;3C", :em_next_word) # Meta+→
-    assert_key_binding("\e[1;3D", :ed_prev_word) # Meta+←
-    assert_key_binding("\e\e[C", :em_next_word) # Meta+→
-    assert_key_binding("\e\e[D", :ed_prev_word) # Meta+←
-  end
-
-  def test_shift_tab
-    assert_key_binding("\e[Z", :completion_journey_up, [:emacs, :vi_insert])
-  end
-
-  # A few emacs bindings that are always mapped
-  def test_more_emacs
-    assert_key_binding("\e ", :em_set_mark, [:emacs])
-    assert_key_binding("\C-x\C-x", :em_exchange_mark, [:emacs])
-  end
-end
diff --git a/test/mri/reline/test_config.rb b/test/mri/reline/test_config.rb
deleted file mode 100644
index ff3e121ab0f..00000000000
--- a/test/mri/reline/test_config.rb
+++ /dev/null
@@ -1,633 +0,0 @@
-require_relative 'helper'
-
-class Reline::Config::Test < Reline::TestCase
-  def setup
-    @pwd = Dir.pwd
-    @tmpdir = File.join(Dir.tmpdir, "test_reline_config_#{$$}")
-    begin
-      Dir.mkdir(@tmpdir)
-    rescue Errno::EEXIST
-      FileUtils.rm_rf(@tmpdir)
-      Dir.mkdir(@tmpdir)
-    end
-    Dir.chdir(@tmpdir)
-    Reline.test_mode
-    @config = Reline::Config.new
-    @inputrc_backup = ENV['INPUTRC']
-  end
-
-  def teardown
-    Dir.chdir(@pwd)
-    FileUtils.rm_rf(@tmpdir)
-    Reline.test_reset
-    @config.reset
-    ENV['INPUTRC'] = @inputrc_backup
-  end
-
-  def get_config_variable(variable)
-    @config.instance_variable_get(variable)
-  end
-
-  def additional_key_bindings(keymap_label)
-    get_config_variable(:@additional_key_bindings)[keymap_label].instance_variable_get(:@key_bindings)
-  end
-
-  def registered_key_bindings(keys)
-    key_bindings = @config.key_bindings
-    keys.to_h { |key| [key, key_bindings.get(key)] }
-  end
-
-  def test_read_lines
-    @config.read_lines(<<~LINES.lines)
-      set show-mode-in-prompt on
-    LINES
-
-    assert_equal true, get_config_variable(:@show_mode_in_prompt)
-  end
-
-  def test_read_lines_with_variable
-    @config.read_lines(<<~LINES.lines)
-      set disable-completion on
-    LINES
-
-    assert_equal true, get_config_variable(:@disable_completion)
-  end
-
-  def test_string_value
-    @config.read_lines(<<~LINES.lines)
-      set show-mode-in-prompt on
-      set emacs-mode-string Emacs
-    LINES
-
-    assert_equal 'Emacs', get_config_variable(:@emacs_mode_string)
-  end
-
-  def test_string_value_with_brackets
-    @config.read_lines(<<~LINES.lines)
-      set show-mode-in-prompt on
-      set emacs-mode-string [Emacs]
-    LINES
-
-    assert_equal '[Emacs]', get_config_variable(:@emacs_mode_string)
-  end
-
-  def test_string_value_with_brackets_and_quotes
-    @config.read_lines(<<~LINES.lines)
-      set show-mode-in-prompt on
-      set emacs-mode-string "[Emacs]"
-    LINES
-
-    assert_equal '[Emacs]', get_config_variable(:@emacs_mode_string)
-  end
-
-  def test_string_value_with_parens
-    @config.read_lines(<<~LINES.lines)
-      set show-mode-in-prompt on
-      set emacs-mode-string (Emacs)
-    LINES
-
-    assert_equal '(Emacs)', get_config_variable(:@emacs_mode_string)
-  end
-
-  def test_string_value_with_parens_and_quotes
-    @config.read_lines(<<~LINES.lines)
-      set show-mode-in-prompt on
-      set emacs-mode-string "(Emacs)"
-    LINES
-
-    assert_equal '(Emacs)', get_config_variable(:@emacs_mode_string)
-  end
-
-  def test_encoding_is_ascii
-    @config.reset
-    Reline.core.io_gate.instance_variable_set(:@encoding, Encoding::US_ASCII)
-    @config = Reline::Config.new
-
-    assert_equal true, @config.convert_meta
-  end
-
-  def test_encoding_is_not_ascii
-    @config = Reline::Config.new
-
-    assert_equal false, @config.convert_meta
-  end
-
-  def test_invalid_keystroke
-    @config.read_lines(<<~LINES.lines)
-      #"a": comment
-      a: error
-      "b": no-error
-    LINES
-    key_bindings = additional_key_bindings(:emacs)
-    assert_not_include key_bindings, 'a'.bytes
-    assert_not_include key_bindings, nil
-    assert_not_include key_bindings, []
-    assert_include key_bindings, 'b'.bytes
-  end
-
-  def test_bind_key
-    assert_equal ['input'.bytes, 'abcde'.bytes], @config.parse_key_binding('"input"', '"abcde"')
-  end
-
-  def test_bind_key_with_macro
-
-    assert_equal ['input'.bytes, :abcde], @config.parse_key_binding('"input"', 'abcde')
-  end
-
-  def test_bind_key_with_escaped_chars
-    assert_equal ['input'.bytes, "\e \\ \" ' \a \b \d \f \n \r \t \v".bytes], @config.parse_key_binding('"input"', '"\\e \\\\ \\" \\\' \\a \\b \\d \\f \\n \\r \\t \\v"')
-  end
-
-  def test_bind_key_with_ctrl_chars
-    assert_equal ['input'.bytes, "\C-h\C-h\C-_".bytes], @config.parse_key_binding('"input"', '"\C-h\C-H\C-_"')
-    assert_equal ['input'.bytes, "\C-h\C-h\C-_".bytes], @config.parse_key_binding('"input"', '"\Control-h\Control-H\Control-_"')
-  end
-
-  def test_bind_key_with_meta_chars
-    assert_equal ['input'.bytes, "\eh\eH\e_".bytes], @config.parse_key_binding('"input"', '"\M-h\M-H\M-_"')
-    assert_equal ['input'.bytes, "\eh\eH\e_".bytes], @config.parse_key_binding('"input"', '"\Meta-h\Meta-H\M-_"')
-  end
-
-  def test_bind_key_with_ctrl_meta_chars
-    assert_equal ['input'.bytes, "\e\C-h\e\C-h\e\C-_".bytes], @config.parse_key_binding('"input"', '"\M-\C-h\C-\M-H\M-\C-_"')
-    assert_equal ['input'.bytes, "\e\C-h\e\C-_".bytes], @config.parse_key_binding('"input"', '"\Meta-\Control-h\Control-\Meta-_"')
-  end
-
-  def test_bind_key_with_octal_number
-    input = %w{i n p u t}.map(&:ord)
-    assert_equal [input, "\1".bytes], @config.parse_key_binding('"input"', '"\1"')
-    assert_equal [input, "\12".bytes], @config.parse_key_binding('"input"', '"\12"')
-    assert_equal [input, "\123".bytes], @config.parse_key_binding('"input"', '"\123"')
-    assert_equal [input, "\123".bytes + '4'.bytes], @config.parse_key_binding('"input"', '"\1234"')
-  end
-
-  def test_bind_key_with_hexadecimal_number
-    input = %w{i n p u t}.map(&:ord)
-    assert_equal [input, "\x4".bytes], @config.parse_key_binding('"input"', '"\x4"')
-    assert_equal [input, "\x45".bytes], @config.parse_key_binding('"input"', '"\x45"')
-    assert_equal [input, "\x45".bytes + '6'.bytes], @config.parse_key_binding('"input"', '"\x456"')
-  end
-
-  def test_include
-    File.open('included_partial', 'wt') do |f|
-      f.write(<<~PARTIAL_LINES)
-        set show-mode-in-prompt on
-      PARTIAL_LINES
-    end
-    @config.read_lines(<<~LINES.lines)
-      $include included_partial
-    LINES
-
-    assert_equal true, get_config_variable(:@show_mode_in_prompt)
-  end
-
-  def test_include_expand_path
-    home_backup = ENV['HOME']
-    File.open('included_partial', 'wt') do |f|
-      f.write(<<~PARTIAL_LINES)
-        set show-mode-in-prompt on
-      PARTIAL_LINES
-    end
-    ENV['HOME'] = Dir.pwd
-    @config.read_lines(<<~LINES.lines)
-      $include ~/included_partial
-    LINES
-
-    assert_equal true, get_config_variable(:@show_mode_in_prompt)
-  ensure
-    ENV['HOME'] = home_backup
-  end
-
-  def test_if
-    @config.read_lines(<<~LINES.lines)
-      $if Ruby
-      set vi-cmd-mode-string (cmd)
-      $else
-      set vi-cmd-mode-string [cmd]
-      $endif
-    LINES
-
-    assert_equal '(cmd)', get_config_variable(:@vi_cmd_mode_string)
-  end
-
-  def test_if_with_false
-    @config.read_lines(<<~LINES.lines)
-      $if Python
-      set vi-cmd-mode-string (cmd)
-      $else
-      set vi-cmd-mode-string [cmd]
-      $endif
-    LINES
-
-    assert_equal '[cmd]', get_config_variable(:@vi_cmd_mode_string)
-  end
-
-  def test_if_with_indent
-    %w[Ruby Reline].each do |cond|
-      @config.read_lines(<<~LINES.lines)
-        set vi-cmd-mode-string {cmd}
-          $if #{cond}
-            set vi-cmd-mode-string (cmd)
-          $else
-            set vi-cmd-mode-string [cmd]
-          $endif
-      LINES
-
-      assert_equal '(cmd)', get_config_variable(:@vi_cmd_mode_string)
-    end
-  end
-
-  def test_nested_if_else
-    @config.read_lines(<<~LINES.lines)
-      $if Ruby
-        "\x1": "O"
-        $if NotRuby
-          "\x2": "X"
-        $else
-          "\x3": "O"
-          $if Ruby
-            "\x4": "O"
-          $else
-            "\x5": "X"
-          $endif
-          "\x6": "O"
-        $endif
-        "\x7": "O"
-      $else
-        "\x8": "X"
-        $if NotRuby
-          "\x9": "X"
-        $else
-          "\xA": "X"
-        $endif
-        "\xB": "X"
-      $endif
-      "\xC": "O"
-    LINES
-    keys = [0x1, 0x3, 0x4, 0x6, 0x7, 0xC]
-    key_bindings = keys.to_h { |k| [[k], ['O'.ord]] }
-    assert_equal(key_bindings, additional_key_bindings(:emacs))
-  end
-
-  def test_unclosed_if
-    e = assert_raise(Reline::Config::InvalidInputrc) do
-      @config.read_lines(<<~LINES.lines, "INPUTRC")
-        $if Ruby
-      LINES
-    end
-    assert_equal "INPUTRC:1: unclosed if", e.message
-  end
-
-  def test_unmatched_else
-    e = assert_raise(Reline::Config::InvalidInputrc) do
-      @config.read_lines(<<~LINES.lines, "INPUTRC")
-        $else
-      LINES
-    end
-    assert_equal "INPUTRC:1: unmatched else", e.message
-  end
-
-  def test_unmatched_endif
-    e = assert_raise(Reline::Config::InvalidInputrc) do
-      @config.read_lines(<<~LINES.lines, "INPUTRC")
-        $endif
-      LINES
-    end
-    assert_equal "INPUTRC:1: unmatched endif", e.message
-  end
-
-  def test_if_with_mode
-    @config.read_lines(<<~LINES.lines)
-      $if mode=emacs
-        "\C-e": history-search-backward # comment
-      $else
-        "\C-f": history-search-forward
-      $endif
-    LINES
-
-    assert_equal({[5] => :history_search_backward}, additional_key_bindings(:emacs))
-    assert_equal({}, additional_key_bindings(:vi_insert))
-    assert_equal({}, additional_key_bindings(:vi_command))
-  end
-
-  def test_else
-    @config.read_lines(<<~LINES.lines)
-      $if mode=vi
-        "\C-e": history-search-backward # comment
-      $else
-        "\C-f": history-search-forward
-      $endif
-    LINES
-
-    assert_equal({[6] => :history_search_forward}, additional_key_bindings(:emacs))
-    assert_equal({}, additional_key_bindings(:vi_insert))
-    assert_equal({}, additional_key_bindings(:vi_command))
-  end
-
-  def test_if_with_invalid_mode
-    @config.read_lines(<<~LINES.lines)
-      $if mode=vim
-        "\C-e": history-search-backward
-      $else
-        "\C-f": history-search-forward # comment
-      $endif
-    LINES
-
-    assert_equal({[6] => :history_search_forward}, additional_key_bindings(:emacs))
-    assert_equal({}, additional_key_bindings(:vi_insert))
-    assert_equal({}, additional_key_bindings(:vi_command))
-  end
-
-  def test_mode_label_differs_from_keymap_label
-    @config.read_lines(<<~LINES.lines)
-      # Sets mode_label and keymap_label to vi
-      set editing-mode vi
-      # Change keymap_label to emacs. mode_label is still vi.
-      set keymap emacs
-      # condition=true because current mode_label is vi
-      $if mode=vi
-        # sets keybinding to current keymap_label=emacs
-        "\C-e": history-search-backward
-      $endif
-    LINES
-    assert_equal({[5] => :history_search_backward}, additional_key_bindings(:emacs))
-    assert_equal({}, additional_key_bindings(:vi_insert))
-    assert_equal({}, additional_key_bindings(:vi_command))
-  end
-
-  def test_if_without_else_condition
-    @config.read_lines(<<~LINES.lines)
-      set editing-mode vi
-      $if mode=vi
-        "\C-e": history-search-backward
-      $endif
-    LINES
-
-    assert_equal({}, additional_key_bindings(:emacs))
-    assert_equal({[5] => :history_search_backward}, additional_key_bindings(:vi_insert))
-    assert_equal({}, additional_key_bindings(:vi_command))
-  end
-
-  def test_default_key_bindings
-    @config.add_default_key_binding('abcd'.bytes, 'EFGH'.bytes)
-    @config.read_lines(<<~'LINES'.lines)
-      "abcd": "ABCD"
-      "ijkl": "IJKL"
-    LINES
-
-    expected = { 'abcd'.bytes => 'ABCD'.bytes, 'ijkl'.bytes => 'IJKL'.bytes }
-    assert_equal expected, registered_key_bindings(expected.keys)
-  end
-
-  def test_additional_key_bindings
-    @config.read_lines(<<~'LINES'.lines)
-      "ef": "EF"
-      "gh": "GH"
-    LINES
-
-    expected = { 'ef'.bytes => 'EF'.bytes, 'gh'.bytes => 'GH'.bytes }
-    assert_equal expected, registered_key_bindings(expected.keys)
-  end
-
-  def test_unquoted_additional_key_bindings
-    @config.read_lines(<<~'LINES'.lines)
-      Meta-a: "Ma"
-      Control-b: "Cb"
-      Meta-Control-c: "MCc"
-      Control-Meta-d: "CMd"
-      M-C-e: "MCe"
-      C-M-f: "CMf"
-    LINES
-
-    expected = { "\ea".bytes => 'Ma'.bytes, "\C-b".bytes => 'Cb'.bytes, "\e\C-c".bytes => 'MCc'.bytes, "\e\C-d".bytes => 'CMd'.bytes, "\e\C-e".bytes => 'MCe'.bytes, "\e\C-f".bytes => 'CMf'.bytes }
-    assert_equal expected, registered_key_bindings(expected.keys)
-  end
-
-  def test_additional_key_bindings_with_nesting_and_comment_out
-    @config.read_lines(<<~'LINES'.lines)
-      #"ab": "AB"
-        #"cd": "cd"
-      "ef": "EF"
-        "gh": "GH"
-    LINES
-
-    expected = { 'ef'.bytes => 'EF'.bytes, 'gh'.bytes => 'GH'.bytes }
-    assert_equal expected, registered_key_bindings(expected.keys)
-  end
-
-  def test_additional_key_bindings_for_other_keymap
-    @config.read_lines(<<~'LINES'.lines)
-      set keymap vi-command
-      "ab": "AB"
-      set keymap vi-insert
-      "cd": "CD"
-      set keymap emacs
-      "ef": "EF"
-      set editing-mode vi # keymap changes to be vi-insert
-    LINES
-
-    expected = { 'cd'.bytes => 'CD'.bytes }
-    assert_equal expected, registered_key_bindings(expected.keys)
-  end
-
-  def test_additional_key_bindings_for_auxiliary_emacs_keymaps
-    @config.read_lines(<<~'LINES'.lines)
-      set keymap emacs
-      "ab": "AB"
-      set keymap emacs-standard
-      "cd": "CD"
-      set keymap emacs-ctlx
-      "ef": "EF"
-      set keymap emacs-meta
-      "gh": "GH"
-      set editing-mode emacs # keymap changes to be emacs
-    LINES
-
-    expected = {
-      'ab'.bytes => 'AB'.bytes,
-      'cd'.bytes => 'CD'.bytes,
-      "\C-xef".bytes => 'EF'.bytes,
-      "\egh".bytes => 'GH'.bytes,
-    }
-    assert_equal expected, registered_key_bindings(expected.keys)
-  end
-
-  def test_key_bindings_with_reset
-    # @config.reset is called after each readline.
-    # inputrc file is read once, so key binding shouldn't be cleared by @config.reset
-    @config.add_default_key_binding('default'.bytes, 'DEFAULT'.bytes)
-    @config.read_lines(<<~'LINES'.lines)
-      "additional": "ADDITIONAL"
-    LINES
-    @config.reset
-    expected = { 'default'.bytes => 'DEFAULT'.bytes, 'additional'.bytes => 'ADDITIONAL'.bytes }
-    assert_equal expected, registered_key_bindings(expected.keys)
-  end
-
-  def test_history_size
-    @config.read_lines(<<~LINES.lines)
-      set history-size 5000
-    LINES
-
-    assert_equal 5000, get_config_variable(:@history_size)
-    history = Reline::History.new(@config)
-    history << "a\n"
-    assert_equal 1, history.size
-  end
-
-  def test_empty_inputrc_env
-    inputrc_backup = ENV['INPUTRC']
-    ENV['INPUTRC'] = ''
-    assert_nothing_raised do
-      @config.read
-    end
-  ensure
-    ENV['INPUTRC'] = inputrc_backup
-  end
-
-  def test_inputrc
-    inputrc_backup = ENV['INPUTRC']
-    expected = "#{@tmpdir}/abcde"
-    ENV['INPUTRC'] = expected
-    assert_equal expected, @config.inputrc_path
-  ensure
-    ENV['INPUTRC'] = inputrc_backup
-  end
-
-  def test_inputrc_raw_value
-    @config.read_lines(<<~'LINES'.lines)
-      set editing-mode vi ignored-string
-      set vi-ins-mode-string aaa aaa
-      set vi-cmd-mode-string bbb ccc # comment
-    LINES
-    assert_equal :vi_insert, get_config_variable(:@editing_mode_label)
-    assert_equal 'aaa aaa', @config.vi_ins_mode_string
-    assert_equal 'bbb ccc # comment', @config.vi_cmd_mode_string
-  end
-
-  def test_inputrc_with_utf8
-    # This file is encoded by UTF-8 so this heredoc string is also UTF-8.
-    @config.read_lines(<<~'LINES'.lines)
-      set editing-mode vi
-      set vi-cmd-mode-string 🍸
-      set vi-ins-mode-string 🍶
-    LINES
-    assert_equal '🍸', @config.vi_cmd_mode_string
-    assert_equal '🍶', @config.vi_ins_mode_string
-  rescue Reline::ConfigEncodingConversionError
-    # do nothing
-  end
-
-  def test_inputrc_with_eucjp
-    @config.read_lines(<<~"LINES".encode(Encoding::EUC_JP).lines)
-      set editing-mode vi
-      set vi-cmd-mode-string ｫｬｯ
-      set vi-ins-mode-string 能
-    LINES
-    assert_equal 'ｫｬｯ'.encode(Reline.encoding_system_needs), @config.vi_cmd_mode_string
-    assert_equal '能'.encode(Reline.encoding_system_needs), @config.vi_ins_mode_string
-  rescue Reline::ConfigEncodingConversionError
-    # do nothing
-  end
-
-  def test_empty_inputrc
-    assert_nothing_raised do
-      @config.read_lines([])
-    end
-  end
-
-  def test_xdg_config_home
-    home_backup = ENV['HOME']
-    xdg_config_home_backup = ENV['XDG_CONFIG_HOME']
-    inputrc_backup = ENV['INPUTRC']
-    xdg_config_home = File.expand_path("#{@tmpdir}/.config/example_dir")
-    expected = File.expand_path("#{xdg_config_home}/readline/inputrc")
-    FileUtils.mkdir_p(File.dirname(expected))
-    FileUtils.touch(expected)
-    ENV['HOME'] = @tmpdir
-    ENV['XDG_CONFIG_HOME'] = xdg_config_home
-    ENV['INPUTRC'] = ''
-    assert_equal expected, @config.inputrc_path
-  ensure
-    FileUtils.rm(expected)
-    ENV['XDG_CONFIG_HOME'] = xdg_config_home_backup
-    ENV['HOME'] = home_backup
-    ENV['INPUTRC'] = inputrc_backup
-  end
-
-  def test_empty_xdg_config_home
-    home_backup = ENV['HOME']
-    xdg_config_home_backup = ENV['XDG_CONFIG_HOME']
-    inputrc_backup = ENV['INPUTRC']
-    ENV['HOME'] = @tmpdir
-    ENV['XDG_CONFIG_HOME'] = ''
-    ENV['INPUTRC'] = ''
-    expected = File.expand_path('~/.config/readline/inputrc')
-    FileUtils.mkdir_p(File.dirname(expected))
-    FileUtils.touch(expected)
-    assert_equal expected, @config.inputrc_path
-  ensure
-    FileUtils.rm(expected)
-    ENV['XDG_CONFIG_HOME'] = xdg_config_home_backup
-    ENV['HOME'] = home_backup
-    ENV['INPUTRC'] = inputrc_backup
-  end
-
-  def test_relative_xdg_config_home
-    home_backup = ENV['HOME']
-    xdg_config_home_backup = ENV['XDG_CONFIG_HOME']
-    inputrc_backup = ENV['INPUTRC']
-    ENV['HOME'] = @tmpdir
-    ENV['INPUTRC'] = ''
-    expected = File.expand_path('~/.config/readline/inputrc')
-    FileUtils.mkdir_p(File.dirname(expected))
-    FileUtils.touch(expected)
-    result = Dir.chdir(@tmpdir) do
-      xdg_config_home = ".config/example_dir"
-      ENV['XDG_CONFIG_HOME'] = xdg_config_home
-      inputrc = "#{xdg_config_home}/readline/inputrc"
-      FileUtils.mkdir_p(File.dirname(inputrc))
-      FileUtils.touch(inputrc)
-      @config.inputrc_path
-    end
-    assert_equal expected, result
-    FileUtils.rm(expected)
-    ENV['XDG_CONFIG_HOME'] = xdg_config_home_backup
-    ENV['HOME'] = home_backup
-    ENV['INPUTRC'] = inputrc_backup
-  end
-
-  def test_reload
-    inputrc = "#{@tmpdir}/inputrc"
-    ENV['INPUTRC'] = inputrc
-
-    File.write(inputrc, "set emacs-mode-string !")
-    @config.read
-    assert_equal '!', @config.emacs_mode_string
-
-    File.write(inputrc, "set emacs-mode-string ?")
-    @config.reload
-    assert_equal '?', @config.emacs_mode_string
-
-    File.write(inputrc, "")
-    @config.reload
-    assert_equal '@', @config.emacs_mode_string
-  end
-
-  def test_invalid_byte_sequence_inputrc
-    lines = [
-      "set vi-cmd-mode-string\n",
-      "$if Ruby\n",
-      "  \"\C-a\": \"Ruby\"\n",
-      "$else \"\xFF\"\n".dup.force_encoding(Reline.encoding_system_needs), # Invalid byte sequence
-      "  \"\C-b\": \"NotRuby\"\n",
-      "$endif\n"
-    ]
-
-    e = assert_raise(Reline::Config::InvalidInputrc) do
-      @config.read_lines(lines, "INPUTRC")
-    end
-
-    assert_equal "INPUTRC:4: can't be converted to the locale #{Reline.encoding_system_needs}", e.message
-  end
-end
diff --git a/test/mri/reline/test_face.rb b/test/mri/reline/test_face.rb
deleted file mode 100644
index 8fa2be8fa44..00000000000
--- a/test/mri/reline/test_face.rb
+++ /dev/null
@@ -1,257 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'helper'
-
-class Reline::Face::Test < Reline::TestCase
-  RESET_SGR = "\e[0m"
-
-  def setup
-    @colorterm_backup = ENV['COLORTERM']
-    ENV['COLORTERM'] = 'truecolor'
-  end
-
-  def teardown
-    Reline::Face.reset_to_initial_configs
-    ENV['COLORTERM'] = @colorterm_backup
-  end
-
-  class WithInsufficientSetupTest < self
-    def setup
-      super
-      Reline::Face.config(:my_insufficient_config) do |face|
-      end
-      @face = Reline::Face[:my_insufficient_config]
-    end
-
-    def test_my_insufficient_config_line
-      assert_equal RESET_SGR, @face[:default]
-      assert_equal RESET_SGR, @face[:enhanced]
-      assert_equal RESET_SGR, @face[:scrollbar]
-    end
-
-    def test_my_insufficient_configs
-      my_configs = Reline::Face.configs[:my_insufficient_config]
-      assert_equal(
-        {
-          default: { style: :reset, escape_sequence: RESET_SGR },
-          enhanced: { style: :reset, escape_sequence: RESET_SGR },
-          scrollbar: { style: :reset, escape_sequence: RESET_SGR }
-        },
-        my_configs
-      )
-    end
-  end
-
-  class WithSetupTest < self
-    def setup
-      super
-      Reline::Face.config(:my_config) do |face|
-        face.define :default, foreground: :blue
-        face.define :enhanced, foreground: "#FF1020", background: :black, style: [:bold, :underlined]
-      end
-      Reline::Face.config(:another_config) do |face|
-        face.define :another_label, foreground: :red
-      end
-      @face = Reline::Face[:my_config]
-    end
-
-    def test_now_there_are_four_configs
-      assert_equal %i(default completion_dialog my_config another_config), Reline::Face.configs.keys
-    end
-
-    def test_resetting_config_discards_user_defined_configs
-      Reline::Face.reset_to_initial_configs
-      assert_equal %i(default completion_dialog), Reline::Face.configs.keys
-    end
-
-    def test_my_configs
-      my_configs = Reline::Face.configs[:my_config]
-      assert_equal(
-        {
-          default: {
-            escape_sequence: "#{RESET_SGR}\e[34m", foreground: :blue
-          },
-          enhanced: {
-            background: :black,
-            foreground: "#FF1020",
-            style: [:bold, :underlined],
-            escape_sequence: "\e[0m\e[38;2;255;16;32;40;1;4m"
-          },
-          scrollbar: {
-            style: :reset,
-            escape_sequence: "\e[0m"
-          }
-        },
-        my_configs
-      )
-    end
-
-    def test_my_config_line
-      assert_equal "#{RESET_SGR}\e[34m", @face[:default]
-    end
-
-    def test_my_config_enhanced
-      assert_equal "#{RESET_SGR}\e[38;2;255;16;32;40;1;4m", @face[:enhanced]
-    end
-
-    def test_not_respond_to_another_label
-      assert_equal false, @face.respond_to?(:another_label)
-    end
-  end
-
-  class WithoutSetupTest < self
-    def test_my_config_default
-      Reline::Face.config(:my_config) do |face|
-        # do nothing
-      end
-      face = Reline::Face[:my_config]
-      assert_equal RESET_SGR, face[:default]
-    end
-
-    def test_style_does_not_exist
-      face = Reline::Face[:default]
-      assert_raise ArgumentError do
-        face[:style_does_not_exist]
-      end
-    end
-
-    def test_invalid_keyword
-      assert_raise ArgumentError do
-        Reline::Face.config(:invalid_config) do |face|
-          face.define :default, invalid_keyword: :red
-        end
-      end
-    end
-
-    def test_invalid_foreground_name
-      assert_raise ArgumentError do
-        Reline::Face.config(:invalid_config) do |face|
-          face.define :default, foreground: :invalid_name
-        end
-      end
-    end
-
-    def test_invalid_background_name
-      assert_raise ArgumentError do
-        Reline::Face.config(:invalid_config) do |face|
-          face.define :default, background: :invalid_name
-        end
-      end
-    end
-
-    def test_invalid_style_name
-      assert_raise ArgumentError do
-        Reline::Face.config(:invalid_config) do |face|
-          face.define :default, style: :invalid_name
-        end
-      end
-    end
-
-    def test_private_constants
-      [:SGR_PARAMETER, :Config, :CONFIGS].each do |name|
-        assert_equal false, Reline::Face.constants.include?(name)
-      end
-    end
-  end
-
-  class ConfigTest < self
-    def setup
-      super
-      @config = Reline::Face.const_get(:Config).new(:my_config) { }
-    end
-
-    def teardown
-      super
-      Reline::Face.instance_variable_set(:@force_truecolor, nil)
-    end
-
-    def test_rgb?
-      assert_equal true, @config.send(:rgb_expression?, "#FFFFFF")
-    end
-
-    def test_invalid_rgb?
-      assert_equal false, @config.send(:rgb_expression?, "FFFFFF")
-      assert_equal false, @config.send(:rgb_expression?, "#FFFFF")
-    end
-
-    def test_format_to_sgr_preserves_order
-      assert_equal(
-        "#{RESET_SGR}\e[37;41;1;3m",
-        @config.send(:format_to_sgr, foreground: :white, background: :red, style: [:bold, :italicized])
-      )
-
-      assert_equal(
-        "#{RESET_SGR}\e[37;1;3;41m",
-        @config.send(:format_to_sgr, foreground: :white, style: [:bold, :italicized], background: :red)
-      )
-    end
-
-    def test_format_to_sgr_with_reset
-      assert_equal(
-        RESET_SGR,
-        @config.send(:format_to_sgr, style: :reset)
-      )
-      assert_equal(
-        "#{RESET_SGR}\e[37;0;41m",
-        @config.send(:format_to_sgr, foreground: :white, style: :reset, background: :red)
-      )
-    end
-
-    def test_format_to_sgr_with_single_style
-      assert_equal(
-        "#{RESET_SGR}\e[37;41;1m",
-        @config.send(:format_to_sgr, foreground: :white, background: :red, style: :bold)
-      )
-    end
-
-    def test_truecolor
-      ENV['COLORTERM'] = 'truecolor'
-      assert_equal true, Reline::Face.truecolor?
-      ENV['COLORTERM'] = '24bit'
-      assert_equal true, Reline::Face.truecolor?
-      ENV['COLORTERM'] = nil
-      assert_equal false, Reline::Face.truecolor?
-      Reline::Face.force_truecolor
-      assert_equal true, Reline::Face.truecolor?
-    end
-
-    def test_sgr_rgb_truecolor
-      ENV['COLORTERM'] = 'truecolor'
-      assert_equal "38;2;255;255;255", @config.send(:sgr_rgb, :foreground, "#ffffff")
-      assert_equal "48;2;18;52;86", @config.send(:sgr_rgb, :background, "#123456")
-    end
-
-    def test_sgr_rgb_256color
-      ENV['COLORTERM'] = nil
-      assert_equal '38;5;231', @config.send(:sgr_rgb, :foreground, '#ffffff')
-      assert_equal '48;5;16', @config.send(:sgr_rgb, :background, '#000000')
-      # Color steps are [0x00, 0x5f, 0x87, 0xaf, 0xd7, 0xff]
-      assert_equal '38;5;24', @config.send(:sgr_rgb, :foreground, '#005f87')
-      assert_equal '38;5;67', @config.send(:sgr_rgb, :foreground, '#5f87af')
-      assert_equal '48;5;110', @config.send(:sgr_rgb, :background, '#87afd7')
-      assert_equal '48;5;153', @config.send(:sgr_rgb, :background, '#afd7ff')
-      # Boundary values are [0x30, 0x73, 0x9b, 0xc3, 0xeb]
-      assert_equal '38;5;24', @config.send(:sgr_rgb, :foreground, '#2f729a')
-      assert_equal '38;5;67', @config.send(:sgr_rgb, :foreground, '#30739b')
-      assert_equal '48;5;110', @config.send(:sgr_rgb, :background, '#9ac2ea')
-      assert_equal '48;5;153', @config.send(:sgr_rgb, :background, '#9bc3eb')
-    end
-
-    def test_force_truecolor_reconfigure
-      ENV['COLORTERM'] = nil
-
-      Reline::Face.config(:my_config) do |face|
-        face.define :default, foreground: '#005f87'
-        face.define :enhanced, background: '#afd7ff'
-      end
-
-      assert_equal "\e[0m\e[38;5;24m", Reline::Face[:my_config][:default]
-      assert_equal "\e[0m\e[48;5;153m", Reline::Face[:my_config][:enhanced]
-
-      Reline::Face.force_truecolor
-
-      assert_equal "\e[0m\e[38;2;0;95;135m", Reline::Face[:my_config][:default]
-      assert_equal "\e[0m\e[48;2;175;215;255m", Reline::Face[:my_config][:enhanced]
-    end
-  end
-end
diff --git a/test/mri/reline/test_history.rb b/test/mri/reline/test_history.rb
deleted file mode 100644
index ea902b06539..00000000000
--- a/test/mri/reline/test_history.rb
+++ /dev/null
@@ -1,317 +0,0 @@
-require_relative 'helper'
-require "reline/history"
-
-class Reline::History::Test < Reline::TestCase
-  def setup
-    Reline.send(:test_mode)
-  end
-
-  def teardown
-    Reline.test_reset
-  end
-
-  def test_ancestors
-    assert_equal(Reline::History.ancestors.include?(Array), true)
-  end
-
-  def test_to_s
-    history = history_new
-    expected = "HISTORY"
-    assert_equal(expected, history.to_s)
-  end
-
-  def test_get
-    history, lines = lines = history_new_and_push_history(5)
-    lines.each_with_index do |s, i|
-      assert_external_string_equal(s, history[i])
-    end
-  end
-
-  def test_get__negative
-    history, lines = lines = history_new_and_push_history(5)
-    (1..5).each do |i|
-      assert_equal(lines[-i], history[-i])
-    end
-  end
-
-  def test_get__out_of_range
-    history, _ = history_new_and_push_history(5)
-    invalid_indexes = [5, 6, 100, -6, -7, -100]
-    invalid_indexes.each do |i|
-      assert_raise(IndexError, "i=<#{i}>") do
-        history[i]
-      end
-    end
-
-    invalid_indexes = [100_000_000_000_000_000_000,
-                       -100_000_000_000_000_000_000]
-    invalid_indexes.each do |i|
-      assert_raise(RangeError, "i=<#{i}>") do
-        history[i]
-      end
-    end
-  end
-
-  def test_set
-    begin
-      history, _ = history_new_and_push_history(5)
-      5.times do |i|
-        expected = "set: #{i}"
-        history[i] = expected
-        assert_external_string_equal(expected, history[i])
-      end
-    rescue NotImplementedError
-    end
-  end
-
-  def test_set__out_of_range
-    history = history_new
-    assert_raise(IndexError, NotImplementedError, "index=<0>") do
-      history[0] = "set: 0"
-    end
-
-    history, _ = history_new_and_push_history(5)
-    invalid_indexes = [5, 6, 100, -6, -7, -100]
-    invalid_indexes.each do |i|
-      assert_raise(IndexError, NotImplementedError, "index=<#{i}>") do
-        history[i] = "set: #{i}"
-      end
-    end
-
-    invalid_indexes = [100_000_000_000_000_000_000,
-                       -100_000_000_000_000_000_000]
-    invalid_indexes.each do |i|
-      assert_raise(RangeError, NotImplementedError, "index=<#{i}>") do
-        history[i] = "set: #{i}"
-      end
-    end
-  end
-
-  def test_push
-    history = history_new
-    5.times do |i|
-      s = i.to_s
-      assert_equal(history, history.push(s))
-      assert_external_string_equal(s, history[i])
-    end
-    assert_equal(5, history.length)
-  end
-
-  def test_push__operator
-    history = history_new
-    5.times do |i|
-      s = i.to_s
-      assert_equal(history, history << s)
-      assert_external_string_equal(s, history[i])
-    end
-    assert_equal(5, history.length)
-  end
-
-  def test_push__plural
-    history = history_new
-    assert_equal(history, history.push("0", "1", "2", "3", "4"))
-    (0..4).each do |i|
-      assert_external_string_equal(i.to_s, history[i])
-    end
-    assert_equal(5, history.length)
-
-    assert_equal(history, history.push("5", "6", "7", "8", "9"))
-    (5..9).each do |i|
-      assert_external_string_equal(i.to_s, history[i])
-    end
-    assert_equal(10, history.length)
-  end
-
-  def test_pop
-    history = history_new
-    begin
-      assert_equal(nil, history.pop)
-
-      history, lines = lines = history_new_and_push_history(5)
-      (1..5).each do |i|
-        assert_external_string_equal(lines[-i], history.pop)
-        assert_equal(lines.length - i, history.length)
-      end
-
-      assert_equal(nil, history.pop)
-    rescue NotImplementedError
-    end
-  end
-
-  def test_shift
-    history = history_new
-    begin
-      assert_equal(nil, history.shift)
-
-      history, lines = lines = history_new_and_push_history(5)
-      (0..4).each do |i|
-        assert_external_string_equal(lines[i], history.shift)
-        assert_equal(lines.length - (i + 1), history.length)
-      end
-
-      assert_equal(nil, history.shift)
-    rescue NotImplementedError
-    end
-  end
-
-  def test_each
-    history = history_new
-    e = history.each do |s|
-      assert(false) # not reachable
-    end
-    assert_equal(history, e)
-    history, lines = lines = history_new_and_push_history(5)
-    i = 0
-    e = history.each do |s|
-      assert_external_string_equal(history[i], s)
-      assert_external_string_equal(lines[i], s)
-      i += 1
-    end
-    assert_equal(history, e)
-  end
-
-  def test_each__enumerator
-    history = history_new
-    e = history.each
-    assert_instance_of(Enumerator, e)
-  end
-
-  def test_length
-    history = history_new
-    assert_equal(0, history.length)
-    push_history(history, 1)
-    assert_equal(1, history.length)
-    push_history(history, 4)
-    assert_equal(5, history.length)
-    history.clear
-    assert_equal(0, history.length)
-  end
-
-  def test_empty_p
-    history = history_new
-    2.times do
-      assert(history.empty?)
-      history.push("s")
-      assert_equal(false, history.empty?)
-      history.clear
-      assert(history.empty?)
-    end
-  end
-
-  def test_delete_at
-    begin
-      history, lines = lines = history_new_and_push_history(5)
-      (0..4).each do |i|
-        assert_external_string_equal(lines[i], history.delete_at(0))
-      end
-      assert(history.empty?)
-
-      history, lines = lines = history_new_and_push_history(5)
-      (1..5).each do |i|
-        assert_external_string_equal(lines[lines.length - i], history.delete_at(-1))
-      end
-      assert(history.empty?)
-
-      history, lines = lines = history_new_and_push_history(5)
-      assert_external_string_equal(lines[0], history.delete_at(0))
-      assert_external_string_equal(lines[4], history.delete_at(3))
-      assert_external_string_equal(lines[1], history.delete_at(0))
-      assert_external_string_equal(lines[3], history.delete_at(1))
-      assert_external_string_equal(lines[2], history.delete_at(0))
-      assert(history.empty?)
-    rescue NotImplementedError
-    end
-  end
-
-  def test_delete_at__out_of_range
-    history = history_new
-    assert_raise(IndexError, NotImplementedError, "index=<0>") do
-      history.delete_at(0)
-    end
-
-    history, _ = history_new_and_push_history(5)
-    invalid_indexes = [5, 6, 100, -6, -7, -100]
-    invalid_indexes.each do |i|
-      assert_raise(IndexError, NotImplementedError, "index=<#{i}>") do
-        history.delete_at(i)
-      end
-    end
-
-    invalid_indexes = [100_000_000_000_000_000_000,
-                       -100_000_000_000_000_000_000]
-    invalid_indexes.each do |i|
-      assert_raise(RangeError, NotImplementedError, "index=<#{i}>") do
-        history.delete_at(i)
-      end
-    end
-  end
-
-  def test_history_size_zero
-    history = history_new(history_size: 0)
-    assert_equal 0, history.size
-    history << 'aa'
-    history << 'bb'
-    assert_equal 0, history.size
-    history.push(*%w{aa bb cc})
-    assert_equal 0, history.size
-  end
-
-  def test_history_size_negative_unlimited
-    history = history_new(history_size: -1)
-    assert_equal 0, history.size
-    history << 'aa'
-    history << 'bb'
-    assert_equal 2, history.size
-    history.push(*%w{aa bb cc})
-    assert_equal 5, history.size
-  end
-
-  def test_history_encoding_conversion
-    history = history_new
-    text1 = String.new("a\u{65535}b\xFFc", encoding: Encoding::UTF_8)
-    text2 = String.new("d\xFFe", encoding: Encoding::Shift_JIS)
-    history.push(text1.dup, text2.dup)
-    expected = [text1, text2].map { |s| s.encode(Reline.encoding_system_needs, invalid: :replace, undef: :replace) }
-    assert_equal(expected, history.to_a)
-  end
-
-  private
-
-  def history_new(history_size: 10)
-    Reline::History.new(Struct.new(:history_size).new(history_size))
-  end
-
-  def push_history(history, num)
-    lines = []
-    num.times do |i|
-      s = "a"
-      i.times do
-        s = s.succ
-      end
-      lines.push("#{i + 1}:#{s}")
-    end
-    history.push(*lines)
-    return history, lines
-  end
-
-  def history_new_and_push_history(num)
-    history = history_new(history_size: 100)
-    return push_history(history, num)
-  end
-
-  def assert_external_string_equal(expected, actual)
-    assert_equal(expected, actual)
-    mes = "Encoding of #{actual.inspect} is expected #{get_default_internal_encoding.inspect} but #{actual.encoding}"
-    assert_equal(get_default_internal_encoding, actual.encoding, mes)
-  end
-
-  def get_default_internal_encoding
-    if encoding = Reline.core.encoding
-      encoding
-    elsif RUBY_PLATFORM =~ /mswin|mingw/
-      Encoding.default_internal || Encoding::UTF_8
-    else
-      Encoding.default_internal || Encoding.find("locale")
-    end
-  end
-end
diff --git a/test/mri/reline/test_key_actor_emacs.rb b/test/mri/reline/test_key_actor_emacs.rb
deleted file mode 100644
index aa608641c3c..00000000000
--- a/test/mri/reline/test_key_actor_emacs.rb
+++ /dev/null
@@ -1,1759 +0,0 @@
-require_relative 'helper'
-
-class Reline::KeyActor::EmacsTest < Reline::TestCase
-  def setup
-    Reline.send(:test_mode)
-    @prompt = '> '
-    @config = Reline::Config.new # Emacs mode is default
-    @config.autocompletion = false
-    Reline::HISTORY.instance_variable_set(:@config, @config)
-    Reline::HISTORY.clear
-    @encoding = Reline.core.encoding
-    @line_editor = Reline::LineEditor.new(@config)
-    @line_editor.reset(@prompt)
-  end
-
-  def teardown
-    Reline.test_reset
-  end
-
-  def test_ed_insert_one
-    input_keys('a')
-    assert_line_around_cursor('a', '')
-  end
-
-  def test_ed_insert_two
-    input_keys('ab')
-    assert_line_around_cursor('ab', '')
-  end
-
-  def test_ed_insert_mbchar_one
-    input_keys('か')
-    assert_line_around_cursor('か', '')
-  end
-
-  def test_ed_insert_mbchar_two
-    input_keys('かき')
-    assert_line_around_cursor('かき', '')
-  end
-
-  def test_ed_insert_for_mbchar_by_plural_code_points
-    omit_unless_utf8
-    input_keys("か\u3099")
-    assert_line_around_cursor("か\u3099", '')
-  end
-
-  def test_ed_insert_for_plural_mbchar_by_plural_code_points
-    omit_unless_utf8
-    input_keys("か\u3099き\u3099")
-    assert_line_around_cursor("か\u3099き\u3099", '')
-  end
-
-  def test_move_next_and_prev
-    input_keys('abd')
-    assert_line_around_cursor('abd', '')
-    input_keys("\C-b")
-    assert_line_around_cursor('ab', 'd')
-    input_keys("\C-b")
-    assert_line_around_cursor('a', 'bd')
-    input_keys("\C-f")
-    assert_line_around_cursor('ab', 'd')
-    input_keys('c')
-    assert_line_around_cursor('abc', 'd')
-  end
-
-  def test_move_next_and_prev_for_mbchar
-    input_keys('かきけ')
-    assert_line_around_cursor('かきけ', '')
-    input_keys("\C-b")
-    assert_line_around_cursor('かき', 'け')
-    input_keys("\C-b")
-    assert_line_around_cursor('か', 'きけ')
-    input_keys("\C-f")
-    assert_line_around_cursor('かき', 'け')
-    input_keys('く')
-    assert_line_around_cursor('かきく', 'け')
-  end
-
-  def test_move_next_and_prev_for_mbchar_by_plural_code_points
-    omit_unless_utf8
-    input_keys("か\u3099き\u3099け\u3099")
-    assert_line_around_cursor("か\u3099き\u3099け\u3099", '')
-    input_keys("\C-b")
-    assert_line_around_cursor("か\u3099き\u3099", "け\u3099")
-    input_keys("\C-b")
-    assert_line_around_cursor("か\u3099", "き\u3099け\u3099")
-    input_keys("\C-f")
-    assert_line_around_cursor("か\u3099き\u3099", "け\u3099")
-    input_keys("く\u3099")
-    assert_line_around_cursor("か\u3099き\u3099く\u3099", "け\u3099")
-  end
-
-  def test_move_to_beg_end
-    input_keys('bcd')
-    assert_line_around_cursor('bcd', '')
-    input_keys("\C-a")
-    assert_line_around_cursor('', 'bcd')
-    input_keys('a')
-    assert_line_around_cursor('a', 'bcd')
-    input_keys("\C-e")
-    assert_line_around_cursor('abcd', '')
-    input_keys('e')
-    assert_line_around_cursor('abcde', '')
-  end
-
-  def test_ed_newline_with_cr
-    input_keys('ab')
-    assert_line_around_cursor('ab', '')
-    refute(@line_editor.finished?)
-    input_keys("\C-m")
-    assert_line_around_cursor('ab', '')
-    assert(@line_editor.finished?)
-  end
-
-  def test_ed_newline_with_lf
-    input_keys('ab')
-    assert_line_around_cursor('ab', '')
-    refute(@line_editor.finished?)
-    input_keys("\C-j")
-    assert_line_around_cursor('ab', '')
-    assert(@line_editor.finished?)
-  end
-
-  def test_em_delete_prev_char
-    input_keys('ab')
-    assert_line_around_cursor('ab', '')
-    input_keys("\C-h")
-    assert_line_around_cursor('a', '')
-  end
-
-  def test_em_delete_prev_char_for_mbchar
-    input_keys('かき')
-    assert_line_around_cursor('かき', '')
-    input_keys("\C-h")
-    assert_line_around_cursor('か', '')
-  end
-
-  def test_em_delete_prev_char_for_mbchar_by_plural_code_points
-    omit_unless_utf8
-    input_keys("か\u3099き\u3099")
-    assert_line_around_cursor("か\u3099き\u3099", '')
-    input_keys("\C-h")
-    assert_line_around_cursor("か\u3099", '')
-  end
-
-  def test_bracketed_paste_insert
-    set_line_around_cursor('A', 'Z')
-    input_key_by_symbol(:insert_multiline_text, char: "abc\n\C-abc")
-    assert_whole_lines(['Aabc', "\C-abcZ"])
-    assert_line_around_cursor("\C-abc", 'Z')
-  end
-
-  def test_ed_quoted_insert
-    set_line_around_cursor('A', 'Z')
-    input_key_by_symbol(:insert_raw_char, char: "\C-a")
-    assert_line_around_cursor("A\C-a", 'Z')
-  end
-
-  def test_ed_quoted_insert_with_vi_arg
-    input_keys("a\C-[3")
-    input_key_by_symbol(:insert_raw_char, char: "\C-a")
-    input_keys("b\C-[4")
-    input_key_by_symbol(:insert_raw_char, char: '1')
-    assert_line_around_cursor("a\C-a\C-a\C-ab1111", '')
-  end
-
-  def test_ed_kill_line
-    input_keys("\C-k")
-    assert_line_around_cursor('', '')
-    input_keys('abc')
-    assert_line_around_cursor('abc', '')
-    input_keys("\C-k")
-    assert_line_around_cursor('abc', '')
-    input_keys("\C-b\C-k")
-    assert_line_around_cursor('ab', '')
-  end
-
-  def test_em_kill_line
-    input_key_by_symbol(:em_kill_line)
-    assert_line_around_cursor('', '')
-    input_keys('abc')
-    input_key_by_symbol(:em_kill_line)
-    assert_line_around_cursor('', '')
-    input_keys('abc')
-    input_keys("\C-b")
-    input_key_by_symbol(:em_kill_line)
-    assert_line_around_cursor('', '')
-    input_keys('abc')
-    input_keys("\C-a")
-    input_key_by_symbol(:em_kill_line)
-    assert_line_around_cursor('', '')
-  end
-
-  def test_ed_move_to_beg
-    input_keys('abd')
-    assert_line_around_cursor('abd', '')
-    input_keys("\C-b")
-    assert_line_around_cursor('ab', 'd')
-    input_keys('c')
-    assert_line_around_cursor('abc', 'd')
-    input_keys("\C-a")
-    assert_line_around_cursor('', 'abcd')
-    input_keys('012')
-    assert_line_around_cursor('012', 'abcd')
-    input_keys("\C-a")
-    assert_line_around_cursor('', '012abcd')
-    input_keys('ABC')
-    assert_line_around_cursor('ABC', '012abcd')
-    input_keys("\C-f" * 10 + "\C-a")
-    assert_line_around_cursor('', 'ABC012abcd')
-    input_keys('a')
-    assert_line_around_cursor('a', 'ABC012abcd')
-  end
-
-  def test_ed_move_to_beg_with_blank
-    input_keys('  abc')
-    assert_line_around_cursor('  abc', '')
-    input_keys("\C-a")
-    assert_line_around_cursor('', '  abc')
-  end
-
-  def test_ed_move_to_end
-    input_keys('abd')
-    assert_line_around_cursor('abd', '')
-    input_keys("\C-b")
-    assert_line_around_cursor('ab', 'd')
-    input_keys('c')
-    assert_line_around_cursor('abc', 'd')
-    input_keys("\C-e")
-    assert_line_around_cursor('abcd', '')
-    input_keys('012')
-    assert_line_around_cursor('abcd012', '')
-    input_keys("\C-e")
-    assert_line_around_cursor('abcd012', '')
-    input_keys('ABC')
-    assert_line_around_cursor('abcd012ABC', '')
-    input_keys("\C-b" * 10 + "\C-e")
-    assert_line_around_cursor('abcd012ABC', '')
-    input_keys('a')
-    assert_line_around_cursor('abcd012ABCa', '')
-  end
-
-  def test_em_delete
-    input_keys('ab')
-    assert_line_around_cursor('ab', '')
-    input_keys("\C-a")
-    assert_line_around_cursor('', 'ab')
-    input_keys("\C-d")
-    assert_line_around_cursor('', 'b')
-  end
-
-  def test_em_delete_for_mbchar
-    input_keys('かき')
-    assert_line_around_cursor('かき', '')
-    input_keys("\C-a")
-    assert_line_around_cursor('', 'かき')
-    input_keys("\C-d")
-    assert_line_around_cursor('', 'き')
-  end
-
-  def test_em_delete_for_mbchar_by_plural_code_points
-    omit_unless_utf8
-    input_keys("か\u3099き\u3099")
-    assert_line_around_cursor("か\u3099き\u3099", '')
-    input_keys("\C-a")
-    assert_line_around_cursor('', "か\u3099き\u3099")
-    input_keys("\C-d")
-    assert_line_around_cursor('', "き\u3099")
-  end
-
-  def test_em_delete_ends_editing
-    input_keys("\C-d") # quit from inputing
-    assert_nil(@line_editor.line)
-    assert(@line_editor.finished?)
-  end
-
-  def test_ed_clear_screen
-    @line_editor.instance_variable_get(:@rendered_screen).lines = [[]]
-    input_keys("\C-l")
-    assert_empty(@line_editor.instance_variable_get(:@rendered_screen).lines)
-  end
-
-  def test_ed_clear_screen_with_inputted
-    input_keys('abc')
-    input_keys("\C-b")
-    @line_editor.instance_variable_get(:@rendered_screen).lines = [[]]
-    assert_line_around_cursor('ab', 'c')
-    input_keys("\C-l")
-    assert_empty(@line_editor.instance_variable_get(:@rendered_screen).lines)
-    assert_line_around_cursor('ab', 'c')
-  end
-
-  def test_key_delete
-    input_keys('abc')
-    assert_line_around_cursor('abc', '')
-    input_key_by_symbol(:key_delete)
-    assert_line_around_cursor('abc', '')
-  end
-
-  def test_key_delete_does_not_end_editing
-    input_key_by_symbol(:key_delete)
-    assert_line_around_cursor('', '')
-    refute(@line_editor.finished?)
-  end
-
-  def test_key_delete_preserves_cursor
-    input_keys('abc')
-    input_keys("\C-b")
-    assert_line_around_cursor('ab', 'c')
-    input_key_by_symbol(:key_delete)
-    assert_line_around_cursor('ab', '')
-  end
-
-  def test_em_next_word
-    assert_line_around_cursor('', '')
-    input_keys('abc def{bbb}ccc')
-    input_keys("\C-a\eF")
-    assert_line_around_cursor('abc', ' def{bbb}ccc')
-    input_keys("\eF")
-    assert_line_around_cursor('abc def', '{bbb}ccc')
-    input_keys("\eF")
-    assert_line_around_cursor('abc def{bbb', '}ccc')
-    input_keys("\eF")
-    assert_line_around_cursor('abc def{bbb}ccc', '')
-    input_keys("\eF")
-    assert_line_around_cursor('abc def{bbb}ccc', '')
-  end
-
-  def test_em_next_word_for_mbchar
-    assert_line_around_cursor('', '')
-    input_keys('あいう かきく{さしす}たちつ')
-    input_keys("\C-a\eF")
-    assert_line_around_cursor('あいう', ' かきく{さしす}たちつ')
-    input_keys("\eF")
-    assert_line_around_cursor('あいう かきく', '{さしす}たちつ')
-    input_keys("\eF")
-    assert_line_around_cursor('あいう かきく{さしす', '}たちつ')
-    input_keys("\eF")
-    assert_line_around_cursor('あいう かきく{さしす}たちつ', '')
-    input_keys("\eF")
-    assert_line_around_cursor('あいう かきく{さしす}たちつ', '')
-  end
-
-  def test_em_next_word_for_mbchar_by_plural_code_points
-    omit_unless_utf8
-    assert_line_around_cursor("", "")
-    input_keys("あいう か\u3099き\u3099く\u3099{さしす}たちつ")
-    input_keys("\C-a\eF")
-    assert_line_around_cursor("あいう", " か\u3099き\u3099く\u3099{さしす}たちつ")
-    input_keys("\eF")
-    assert_line_around_cursor("あいう か\u3099き\u3099く\u3099", "{さしす}たちつ")
-    input_keys("\eF")
-    assert_line_around_cursor("あいう か\u3099き\u3099く\u3099{さしす", "}たちつ")
-    input_keys("\eF")
-    assert_line_around_cursor("あいう か\u3099き\u3099く\u3099{さしす}たちつ", "")
-    input_keys("\eF")
-    assert_line_around_cursor("あいう か\u3099き\u3099く\u3099{さしす}たちつ", "")
-  end
-
-  def test_em_prev_word
-    input_keys('abc def{bbb}ccc')
-    assert_line_around_cursor('abc def{bbb}ccc', '')
-    input_keys("\eB")
-    assert_line_around_cursor('abc def{bbb}', 'ccc')
-    input_keys("\eB")
-    assert_line_around_cursor('abc def{', 'bbb}ccc')
-    input_keys("\eB")
-    assert_line_around_cursor('abc ', 'def{bbb}ccc')
-    input_keys("\eB")
-    assert_line_around_cursor('', 'abc def{bbb}ccc')
-    input_keys("\eB")
-    assert_line_around_cursor('', 'abc def{bbb}ccc')
-  end
-
-  def test_em_prev_word_for_mbchar
-    input_keys('あいう かきく{さしす}たちつ')
-    assert_line_around_cursor('あいう かきく{さしす}たちつ', '')
-    input_keys("\eB")
-    assert_line_around_cursor('あいう かきく{さしす}', 'たちつ')
-    input_keys("\eB")
-    assert_line_around_cursor('あいう かきく{', 'さしす}たちつ')
-    input_keys("\eB")
-    assert_line_around_cursor('あいう ', 'かきく{さしす}たちつ')
-    input_keys("\eB")
-    assert_line_around_cursor('', 'あいう かきく{さしす}たちつ')
-    input_keys("\eB")
-    assert_line_around_cursor('', 'あいう かきく{さしす}たちつ')
-  end
-
-  def test_em_prev_word_for_mbchar_by_plural_code_points
-    omit_unless_utf8
-    input_keys("あいう か\u3099き\u3099く\u3099{さしす}たちつ")
-    assert_line_around_cursor("あいう か\u3099き\u3099く\u3099{さしす}たちつ", "")
-    input_keys("\eB")
-    assert_line_around_cursor("あいう か\u3099き\u3099く\u3099{さしす}", "たちつ")
-    input_keys("\eB")
-    assert_line_around_cursor("あいう か\u3099き\u3099く\u3099{", "さしす}たちつ")
-    input_keys("\eB")
-    assert_line_around_cursor("あいう ", "か\u3099き\u3099く\u3099{さしす}たちつ")
-    input_keys("\eB")
-    assert_line_around_cursor("", "あいう か\u3099き\u3099く\u3099{さしす}たちつ")
-    input_keys("\eB")
-    assert_line_around_cursor("", "あいう か\u3099き\u3099く\u3099{さしす}たちつ")
-  end
-
-  def test_em_delete_next_word
-    input_keys('abc def{bbb}ccc')
-    input_keys("\C-a")
-    assert_line_around_cursor('', 'abc def{bbb}ccc')
-    input_keys("\ed")
-    assert_line_around_cursor('', ' def{bbb}ccc')
-    input_keys("\ed")
-    assert_line_around_cursor('', '{bbb}ccc')
-    input_keys("\ed")
-    assert_line_around_cursor('', '}ccc')
-    input_keys("\ed")
-    assert_line_around_cursor('', '')
-  end
-
-  def test_em_delete_next_word_for_mbchar
-    input_keys('あいう かきく{さしす}たちつ')
-    input_keys("\C-a")
-    assert_line_around_cursor('', 'あいう かきく{さしす}たちつ')
-    input_keys("\ed")
-    assert_line_around_cursor('', ' かきく{さしす}たちつ')
-    input_keys("\ed")
-    assert_line_around_cursor('', '{さしす}たちつ')
-    input_keys("\ed")
-    assert_line_around_cursor('', '}たちつ')
-    input_keys("\ed")
-    assert_line_around_cursor('', '')
-  end
-
-  def test_em_delete_next_word_for_mbchar_by_plural_code_points
-    omit_unless_utf8
-    input_keys("あいう か\u3099き\u3099く\u3099{さしす}たちつ")
-    input_keys("\C-a")
-    assert_line_around_cursor('', "あいう か\u3099き\u3099く\u3099{さしす}たちつ")
-    input_keys("\ed")
-    assert_line_around_cursor('', " か\u3099き\u3099く\u3099{さしす}たちつ")
-    input_keys("\ed")
-    assert_line_around_cursor('', '{さしす}たちつ')
-    input_keys("\ed")
-    assert_line_around_cursor('', '}たちつ')
-    input_keys("\ed")
-    assert_line_around_cursor('', '')
-  end
-
-  def test_ed_delete_prev_word
-    input_keys('abc def{bbb}ccc')
-    assert_line_around_cursor('abc def{bbb}ccc', '')
-    input_keys("\e\C-H")
-    assert_line_around_cursor('abc def{bbb}', '')
-    input_keys("\e\C-H")
-    assert_line_around_cursor('abc def{', '')
-    input_keys("\e\C-H")
-    assert_line_around_cursor('abc ', '')
-    input_keys("\e\C-H")
-    assert_line_around_cursor('', '')
-  end
-
-  def test_ed_delete_prev_word_for_mbchar
-    input_keys('あいう かきく{さしす}たちつ')
-    assert_line_around_cursor('あいう かきく{さしす}たちつ', '')
-    input_keys("\e\C-H")
-    assert_line_around_cursor('あいう かきく{さしす}', '')
-    input_keys("\e\C-H")
-    assert_line_around_cursor('あいう かきく{', '')
-    input_keys("\e\C-H")
-    assert_line_around_cursor('あいう ', '')
-    input_keys("\e\C-H")
-    assert_line_around_cursor('', '')
-  end
-
-  def test_ed_delete_prev_word_for_mbchar_by_plural_code_points
-    omit_unless_utf8
-    input_keys("あいう か\u3099き\u3099く\u3099{さしす}たちつ")
-    assert_line_around_cursor("あいう か\u3099き\u3099く\u3099{さしす}たちつ", '')
-    input_keys("\e\C-H")
-    assert_line_around_cursor("あいう か\u3099き\u3099く\u3099{さしす}", '')
-    input_keys("\e\C-H")
-    assert_line_around_cursor("あいう か\u3099き\u3099く\u3099{", '')
-    input_keys("\e\C-H")
-    assert_line_around_cursor('あいう ', '')
-    input_keys("\e\C-H")
-    assert_line_around_cursor('', '')
-  end
-
-  def test_ed_transpose_chars
-    input_keys('abc')
-    input_keys("\C-a")
-    assert_line_around_cursor('', 'abc')
-    input_keys("\C-t")
-    assert_line_around_cursor('', 'abc')
-    input_keys("\C-f\C-t")
-    assert_line_around_cursor('ba', 'c')
-    input_keys("\C-t")
-    assert_line_around_cursor('bca', '')
-    input_keys("\C-t")
-    assert_line_around_cursor('bac', '')
-  end
-
-  def test_ed_transpose_chars_for_mbchar
-    input_keys('あかさ')
-    input_keys("\C-a")
-    assert_line_around_cursor('', 'あかさ')
-    input_keys("\C-t")
-    assert_line_around_cursor('', 'あかさ')
-    input_keys("\C-f\C-t")
-    assert_line_around_cursor('かあ', 'さ')
-    input_keys("\C-t")
-    assert_line_around_cursor('かさあ', '')
-    input_keys("\C-t")
-    assert_line_around_cursor('かあさ', '')
-  end
-
-  def test_ed_transpose_chars_for_mbchar_by_plural_code_points
-    omit_unless_utf8
-    input_keys("あか\u3099さ")
-    input_keys("\C-a")
-    assert_line_around_cursor('', "あか\u3099さ")
-    input_keys("\C-t")
-    assert_line_around_cursor('', "あか\u3099さ")
-    input_keys("\C-f\C-t")
-    assert_line_around_cursor("か\u3099あ", 'さ')
-    input_keys("\C-t")
-    assert_line_around_cursor("か\u3099さあ", '')
-    input_keys("\C-t")
-    assert_line_around_cursor("か\u3099あさ", '')
-  end
-
-  def test_ed_transpose_words
-    input_keys('abc def')
-    assert_line_around_cursor('abc def', '')
-    input_keys("\et")
-    assert_line_around_cursor('def abc', '')
-    input_keys("\C-a\C-k")
-    input_keys(' abc  def   ')
-    input_keys("\C-b" * 4)
-    assert_line_around_cursor(' abc  de', 'f   ')
-    input_keys("\et")
-    assert_line_around_cursor(' def  abc', '   ')
-    input_keys("\C-a\C-k")
-    input_keys(' abc  def   ')
-    input_keys("\C-b" * 6)
-    assert_line_around_cursor(' abc  ', 'def   ')
-    input_keys("\et")
-    assert_line_around_cursor(' def  abc', '   ')
-    input_keys("\et")
-    assert_line_around_cursor(' abc     def', '')
-  end
-
-  def test_ed_transpose_words_for_mbchar
-    input_keys('あいう かきく')
-    assert_line_around_cursor('あいう かきく', '')
-    input_keys("\et")
-    assert_line_around_cursor('かきく あいう', '')
-    input_keys("\C-a\C-k")
-    input_keys(' あいう  かきく   ')
-    input_keys("\C-b" * 4)
-    assert_line_around_cursor(' あいう  かき', 'く   ')
-    input_keys("\et")
-    assert_line_around_cursor(' かきく  あいう', '   ')
-    input_keys("\C-a\C-k")
-    input_keys(' あいう  かきく   ')
-    input_keys("\C-b" * 6)
-    assert_line_around_cursor(' あいう  ', 'かきく   ')
-    input_keys("\et")
-    assert_line_around_cursor(' かきく  あいう', '   ')
-    input_keys("\et")
-    assert_line_around_cursor(' あいう     かきく', '')
-  end
-
-  def test_ed_transpose_words_with_one_word
-    input_keys('abc  ')
-    assert_line_around_cursor('abc  ', '')
-    input_keys("\et")
-    assert_line_around_cursor('abc  ', '')
-    input_keys("\C-b")
-    assert_line_around_cursor('abc ', ' ')
-    input_keys("\et")
-    assert_line_around_cursor('abc ', ' ')
-    input_keys("\C-b" * 2)
-    assert_line_around_cursor('ab', 'c  ')
-    input_keys("\et")
-    assert_line_around_cursor('ab', 'c  ')
-    input_keys("\et")
-    assert_line_around_cursor('ab', 'c  ')
-  end
-
-  def test_ed_transpose_words_with_one_word_for_mbchar
-    input_keys('あいう  ')
-    assert_line_around_cursor('あいう  ', '')
-    input_keys("\et")
-    assert_line_around_cursor('あいう  ', '')
-    input_keys("\C-b")
-    assert_line_around_cursor('あいう ', ' ')
-    input_keys("\et")
-    assert_line_around_cursor('あいう ', ' ')
-    input_keys("\C-b" * 2)
-    assert_line_around_cursor('あい', 'う  ')
-    input_keys("\et")
-    assert_line_around_cursor('あい', 'う  ')
-    input_keys("\et")
-    assert_line_around_cursor('あい', 'う  ')
-  end
-
-  def test_ed_digit
-    input_keys('0123')
-    assert_line_around_cursor('0123', '')
-  end
-
-  def test_ed_next_and_prev_char
-    input_keys('abc')
-    assert_line_around_cursor('abc', '')
-    input_keys("\C-b")
-    assert_line_around_cursor('ab', 'c')
-    input_keys("\C-b")
-    assert_line_around_cursor('a', 'bc')
-    input_keys("\C-b")
-    assert_line_around_cursor('', 'abc')
-    input_keys("\C-b")
-    assert_line_around_cursor('', 'abc')
-    input_keys("\C-f")
-    assert_line_around_cursor('a', 'bc')
-    input_keys("\C-f")
-    assert_line_around_cursor('ab', 'c')
-    input_keys("\C-f")
-    assert_line_around_cursor('abc', '')
-    input_keys("\C-f")
-    assert_line_around_cursor('abc', '')
-  end
-
-  def test_ed_next_and_prev_char_for_mbchar
-    input_keys('あいう')
-    assert_line_around_cursor('あいう', '')
-    input_keys("\C-b")
-    assert_line_around_cursor('あい', 'う')
-    input_keys("\C-b")
-    assert_line_around_cursor('あ', 'いう')
-    input_keys("\C-b")
-    assert_line_around_cursor('', 'あいう')
-    input_keys("\C-b")
-    assert_line_around_cursor('', 'あいう')
-    input_keys("\C-f")
-    assert_line_around_cursor('あ', 'いう')
-    input_keys("\C-f")
-    assert_line_around_cursor('あい', 'う')
-    input_keys("\C-f")
-    assert_line_around_cursor('あいう', '')
-    input_keys("\C-f")
-    assert_line_around_cursor('あいう', '')
-  end
-
-  def test_ed_next_and_prev_char_for_mbchar_by_plural_code_points
-    omit_unless_utf8
-    input_keys("か\u3099き\u3099く\u3099")
-    assert_line_around_cursor("か\u3099き\u3099く\u3099", '')
-    input_keys("\C-b")
-    assert_line_around_cursor("か\u3099き\u3099", "く\u3099")
-    input_keys("\C-b")
-    assert_line_around_cursor("か\u3099", "き\u3099く\u3099")
-    input_keys("\C-b")
-    assert_line_around_cursor('', "か\u3099き\u3099く\u3099")
-    input_keys("\C-b")
-    assert_line_around_cursor('', "か\u3099き\u3099く\u3099")
-    input_keys("\C-f")
-    assert_line_around_cursor("か\u3099", "き\u3099く\u3099")
-    input_keys("\C-f")
-    assert_line_around_cursor("か\u3099き\u3099", "く\u3099")
-    input_keys("\C-f")
-    assert_line_around_cursor("か\u3099き\u3099く\u3099", '')
-    input_keys("\C-f")
-    assert_line_around_cursor("か\u3099き\u3099く\u3099", '')
-  end
-
-  def test_em_capitol_case
-    input_keys('abc def{bbb}ccc')
-    input_keys("\C-a\ec")
-    assert_line_around_cursor('Abc', ' def{bbb}ccc')
-    input_keys("\ec")
-    assert_line_around_cursor('Abc Def', '{bbb}ccc')
-    input_keys("\ec")
-    assert_line_around_cursor('Abc Def{Bbb', '}ccc')
-    input_keys("\ec")
-    assert_line_around_cursor('Abc Def{Bbb}Ccc', '')
-  end
-
-  def test_em_capitol_case_with_complex_example
-    input_keys('{}#*    AaA!!!cCc   ')
-    input_keys("\C-a\ec")
-    assert_line_around_cursor('{}#*    Aaa', '!!!cCc   ')
-    input_keys("\ec")
-    assert_line_around_cursor('{}#*    Aaa!!!Ccc', '   ')
-    input_keys("\ec")
-    assert_line_around_cursor('{}#*    Aaa!!!Ccc   ', '')
-  end
-
-  def test_em_lower_case
-    input_keys('AbC def{bBb}CCC')
-    input_keys("\C-a\el")
-    assert_line_around_cursor('abc', ' def{bBb}CCC')
-    input_keys("\el")
-    assert_line_around_cursor('abc def', '{bBb}CCC')
-    input_keys("\el")
-    assert_line_around_cursor('abc def{bbb', '}CCC')
-    input_keys("\el")
-    assert_line_around_cursor('abc def{bbb}ccc', '')
-  end
-
-  def test_em_lower_case_with_complex_example
-    input_keys('{}#*    AaA!!!cCc   ')
-    input_keys("\C-a\el")
-    assert_line_around_cursor('{}#*    aaa', '!!!cCc   ')
-    input_keys("\el")
-    assert_line_around_cursor('{}#*    aaa!!!ccc', '   ')
-    input_keys("\el")
-    assert_line_around_cursor('{}#*    aaa!!!ccc   ', '')
-  end
-
-  def test_em_upper_case
-    input_keys('AbC def{bBb}CCC')
-    input_keys("\C-a\eu")
-    assert_line_around_cursor('ABC', ' def{bBb}CCC')
-    input_keys("\eu")
-    assert_line_around_cursor('ABC DEF', '{bBb}CCC')
-    input_keys("\eu")
-    assert_line_around_cursor('ABC DEF{BBB', '}CCC')
-    input_keys("\eu")
-    assert_line_around_cursor('ABC DEF{BBB}CCC', '')
-  end
-
-  def test_em_upper_case_with_complex_example
-    input_keys('{}#*    AaA!!!cCc   ')
-    input_keys("\C-a\eu")
-    assert_line_around_cursor('{}#*    AAA', '!!!cCc   ')
-    input_keys("\eu")
-    assert_line_around_cursor('{}#*    AAA!!!CCC', '   ')
-    input_keys("\eu")
-    assert_line_around_cursor('{}#*    AAA!!!CCC   ', '')
-  end
-
-  def test_em_delete_or_list
-    @line_editor.completion_proc = proc { |word|
-      %w{
-        foo_foo
-        foo_bar
-        foo_baz
-        qux
-      }.map { |i|
-        i.encode(@encoding)
-      }
-    }
-    input_keys('fooo')
-    assert_line_around_cursor('fooo', '')
-    assert_equal(nil, @line_editor.instance_variable_get(:@menu_info))
-    input_keys("\C-b")
-    assert_line_around_cursor('foo', 'o')
-    assert_equal(nil, @line_editor.instance_variable_get(:@menu_info))
-    input_key_by_symbol(:em_delete_or_list)
-    assert_line_around_cursor('foo', '')
-    assert_equal(nil, @line_editor.instance_variable_get(:@menu_info))
-    input_key_by_symbol(:em_delete_or_list)
-    assert_line_around_cursor('foo', '')
-    assert_equal(%w{foo_foo foo_bar foo_baz}, @line_editor.instance_variable_get(:@menu_info).list)
-  end
-
-  def test_completion_duplicated_list
-    @line_editor.completion_proc = proc { |word|
-      %w{
-        foo_foo
-        foo_foo
-        foo_bar
-      }.map { |i|
-        i.encode(@encoding)
-      }
-    }
-    input_keys('foo_')
-    assert_line_around_cursor('foo_', '')
-    assert_equal(nil, @line_editor.instance_variable_get(:@menu_info))
-    input_keys("\C-i")
-    assert_line_around_cursor('foo_', '')
-    assert_equal(nil, @line_editor.instance_variable_get(:@menu_info))
-    input_keys("\C-i")
-    assert_line_around_cursor('foo_', '')
-    assert_equal(%w{foo_foo foo_bar}, @line_editor.instance_variable_get(:@menu_info).list)
-  end
-
-  def test_completion
-    @line_editor.completion_proc = proc { |word|
-      %w{
-        foo_foo
-        foo_bar
-        foo_baz
-        qux
-      }.map { |i|
-        i.encode(@encoding)
-      }
-    }
-    input_keys('fo')
-    assert_line_around_cursor('fo', '')
-    assert_equal(nil, @line_editor.instance_variable_get(:@menu_info))
-    input_keys("\C-i")
-    assert_line_around_cursor('foo_', '')
-    assert_equal(nil, @line_editor.instance_variable_get(:@menu_info))
-    input_keys("\C-i")
-    assert_line_around_cursor('foo_', '')
-    assert_equal(%w{foo_foo foo_bar foo_baz}, @line_editor.instance_variable_get(:@menu_info).list)
-    input_keys('a')
-    input_keys("\C-i")
-    assert_line_around_cursor('foo_a', '')
-    input_keys("\C-h")
-    input_keys('b')
-    input_keys("\C-i")
-    assert_line_around_cursor('foo_ba', '')
-    input_keys("\C-h")
-    input_key_by_symbol(:complete)
-    assert_line_around_cursor('foo_ba', '')
-    input_keys("\C-h")
-    input_key_by_symbol(:menu_complete)
-    assert_line_around_cursor('foo_bar', '')
-    input_key_by_symbol(:menu_complete)
-    assert_line_around_cursor('foo_baz', '')
-    input_keys("\C-h")
-    input_key_by_symbol(:menu_complete_backward)
-    assert_line_around_cursor('foo_baz', '')
-    input_key_by_symbol(:menu_complete_backward)
-    assert_line_around_cursor('foo_bar', '')
-  end
-
-  def test_autocompletion
-    @config.autocompletion = true
-    @line_editor.completion_proc = proc { |word|
-      %w{
-        Readline
-        Regexp
-        RegexpError
-      }.map { |i|
-        i.encode(@encoding)
-      }
-    }
-    input_keys('Re')
-    assert_line_around_cursor('Re', '')
-    input_keys("\C-i")
-    assert_line_around_cursor('Readline', '')
-    input_keys("\C-i")
-    assert_line_around_cursor('Regexp', '')
-    input_key_by_symbol(:completion_journey_up)
-    assert_line_around_cursor('Readline', '')
-    input_key_by_symbol(:complete)
-    assert_line_around_cursor('Regexp', '')
-    input_key_by_symbol(:menu_complete_backward)
-    assert_line_around_cursor('Readline', '')
-    input_key_by_symbol(:menu_complete)
-    assert_line_around_cursor('Regexp', '')
-  ensure
-    @config.autocompletion = false
-  end
-
-  def test_completion_with_indent
-    @line_editor.completion_proc = proc { |word|
-      %w{
-        foo_foo
-        foo_bar
-        foo_baz
-        qux
-      }.map { |i|
-        i.encode(@encoding)
-      }
-    }
-    input_keys('  fo')
-    assert_line_around_cursor('  fo', '')
-    assert_equal(nil, @line_editor.instance_variable_get(:@menu_info))
-    input_keys("\C-i")
-    assert_line_around_cursor('  foo_', '')
-    assert_equal(nil, @line_editor.instance_variable_get(:@menu_info))
-    input_keys("\C-i")
-    assert_line_around_cursor('  foo_', '')
-    assert_equal(%w{foo_foo foo_bar foo_baz}, @line_editor.instance_variable_get(:@menu_info).list)
-  end
-
-  def test_completion_with_perfect_match
-    @line_editor.completion_proc = proc { |word|
-      %w{
-        foo
-        foo_bar
-      }.map { |i|
-        i.encode(@encoding)
-      }
-    }
-    matched = nil
-    @line_editor.dig_perfect_match_proc = proc { |m|
-      matched = m
-    }
-    input_keys('fo')
-    assert_line_around_cursor('fo', '')
-    assert_equal(Reline::LineEditor::CompletionState::NORMAL, @line_editor.instance_variable_get(:@completion_state))
-    assert_equal(nil, matched)
-    input_keys("\C-i")
-    assert_line_around_cursor('foo', '')
-    assert_equal(Reline::LineEditor::CompletionState::MENU_WITH_PERFECT_MATCH, @line_editor.instance_variable_get(:@completion_state))
-    assert_equal(nil, matched)
-    input_keys("\C-i")
-    assert_line_around_cursor('foo', '')
-    assert_equal(Reline::LineEditor::CompletionState::PERFECT_MATCH, @line_editor.instance_variable_get(:@completion_state))
-    assert_equal(nil, matched)
-    input_keys("\C-i")
-    assert_line_around_cursor('foo', '')
-    assert_equal(Reline::LineEditor::CompletionState::PERFECT_MATCH, @line_editor.instance_variable_get(:@completion_state))
-    assert_equal('foo', matched)
-    matched = nil
-    input_keys('_')
-    input_keys("\C-i")
-    assert_line_around_cursor('foo_bar', '')
-    assert_equal(Reline::LineEditor::CompletionState::PERFECT_MATCH, @line_editor.instance_variable_get(:@completion_state))
-    assert_equal(nil, matched)
-    input_keys("\C-i")
-    assert_line_around_cursor('foo_bar', '')
-    assert_equal(Reline::LineEditor::CompletionState::PERFECT_MATCH, @line_editor.instance_variable_get(:@completion_state))
-    assert_equal('foo_bar', matched)
-  end
-
-  def test_continuous_completion_with_perfect_match
-    @line_editor.completion_proc = proc { |word|
-      word == 'f' ? ['foo'] : %w[foobar foobaz]
-    }
-    input_keys('f')
-    input_keys("\C-i")
-    assert_line_around_cursor('foo', '')
-    input_keys("\C-i")
-    assert_line_around_cursor('fooba', '')
-  end
-
-  def test_continuous_completion_disabled_with_perfect_match
-    @line_editor.completion_proc = proc { |word|
-      word == 'f' ? ['foo'] : %w[foobar foobaz]
-    }
-    @line_editor.dig_perfect_match_proc = proc {}
-    input_keys('f')
-    input_keys("\C-i")
-    assert_line_around_cursor('foo', '')
-    input_keys("\C-i")
-    assert_line_around_cursor('foo', '')
-  end
-
-  def test_completion_append_character
-    @line_editor.completion_proc = proc { |word|
-      %w[foo_ foo_foo foo_bar].select { |s| s.start_with? word }
-    }
-    @line_editor.completion_append_character = 'X'
-    input_keys('f')
-    input_keys("\C-i")
-    assert_line_around_cursor('foo_', '')
-    input_keys('f')
-    input_keys("\C-i")
-    assert_line_around_cursor('foo_fooX', '')
-    input_keys(' foo_bar')
-    input_keys("\C-i")
-    assert_line_around_cursor('foo_fooX foo_barX', '')
-  end
-
-  def test_completion_with_quote_append
-    @line_editor.completion_proc = proc { |word|
-      %w[foo bar baz].select { |s| s.start_with? word }
-    }
-    set_line_around_cursor('x = "b', '')
-    input_keys("\C-i")
-    assert_line_around_cursor('x = "ba', '')
-    set_line_around_cursor('x = "f', ' ')
-    input_keys("\C-i")
-    assert_line_around_cursor('x = "foo', ' ')
-    set_line_around_cursor("x = 'f", '')
-    input_keys("\C-i")
-    assert_line_around_cursor("x = 'foo'", '')
-    set_line_around_cursor('"a "f', '')
-    input_keys("\C-i")
-    assert_line_around_cursor('"a "foo', '')
-    set_line_around_cursor('"a\\" "f', '')
-    input_keys("\C-i")
-    assert_line_around_cursor('"a\\" "foo', '')
-    set_line_around_cursor('"a" "f', '')
-    input_keys("\C-i")
-    assert_line_around_cursor('"a" "foo"', '')
-  end
-
-  def test_completion_with_completion_ignore_case
-    @line_editor.completion_proc = proc { |word|
-      %w{
-        foo_foo
-        foo_bar
-        Foo_baz
-        qux
-      }.map { |i|
-        i.encode(@encoding)
-      }
-    }
-    input_keys('fo')
-    assert_line_around_cursor('fo', '')
-    assert_equal(nil, @line_editor.instance_variable_get(:@menu_info))
-    input_keys("\C-i")
-    assert_line_around_cursor('foo_', '')
-    assert_equal(nil, @line_editor.instance_variable_get(:@menu_info))
-    input_keys("\C-i")
-    assert_line_around_cursor('foo_', '')
-    assert_equal(%w{foo_foo foo_bar}, @line_editor.instance_variable_get(:@menu_info).list)
-    @config.completion_ignore_case = true
-    input_keys("\C-i")
-    assert_line_around_cursor('foo_', '')
-    assert_equal(%w{foo_foo foo_bar Foo_baz}, @line_editor.instance_variable_get(:@menu_info).list)
-    input_keys('a')
-    input_keys("\C-i")
-    assert_line_around_cursor('foo_a', '')
-    input_keys("\C-h")
-    input_keys('b')
-    input_keys("\C-i")
-    assert_line_around_cursor('foo_ba', '')
-    input_keys('Z')
-    input_keys("\C-i")
-    assert_line_around_cursor('Foo_baz', '')
-  end
-
-  def test_completion_in_middle_of_line
-    @line_editor.completion_proc = proc { |word|
-      %w{
-        foo_foo
-        foo_bar
-        foo_baz
-        qux
-      }.map { |i|
-        i.encode(@encoding)
-      }
-    }
-    input_keys('abcde fo ABCDE')
-    assert_line_around_cursor('abcde fo ABCDE', '')
-    input_keys("\C-b" * 6 + "\C-i")
-    assert_line_around_cursor('abcde foo_', ' ABCDE')
-    input_keys("\C-b" * 2 + "\C-i")
-    assert_line_around_cursor('abcde foo_', 'o_ ABCDE')
-  end
-
-  def test_completion_with_nil_value
-    @line_editor.completion_proc = proc { |word|
-      %w{
-        foo_foo
-        foo_bar
-        Foo_baz
-        qux
-      }.map { |i|
-        i.encode(@encoding)
-      }.prepend(nil)
-    }
-    @config.completion_ignore_case = true
-    input_keys('fo')
-    assert_line_around_cursor('fo', '')
-    assert_equal(nil, @line_editor.instance_variable_get(:@menu_info))
-    input_keys("\C-i")
-    assert_line_around_cursor('foo_', '')
-    assert_equal(nil, @line_editor.instance_variable_get(:@menu_info))
-    input_keys("\C-i")
-    assert_line_around_cursor('foo_', '')
-    assert_equal(%w{foo_foo foo_bar Foo_baz}, @line_editor.instance_variable_get(:@menu_info).list)
-    input_keys('a')
-    input_keys("\C-i")
-    assert_line_around_cursor('foo_a', '')
-    input_keys("\C-h")
-    input_keys('b')
-    input_keys("\C-i")
-    assert_line_around_cursor('foo_ba', '')
-  end
-
-  def test_em_kill_region
-    input_keys('abc   def{bbb}ccc   ddd   ')
-    assert_line_around_cursor('abc   def{bbb}ccc   ddd   ', '')
-    input_keys("\C-w")
-    assert_line_around_cursor('abc   def{bbb}ccc   ', '')
-    input_keys("\C-w")
-    assert_line_around_cursor('abc   ', '')
-    input_keys("\C-w")
-    assert_line_around_cursor('', '')
-    input_keys("\C-w")
-    assert_line_around_cursor('', '')
-  end
-
-  def test_em_kill_region_mbchar
-    input_keys('あ   い   う{う}う   ')
-    assert_line_around_cursor('あ   い   う{う}う   ', '')
-    input_keys("\C-w")
-    assert_line_around_cursor('あ   い   ', '')
-    input_keys("\C-w")
-    assert_line_around_cursor('あ   ', '')
-    input_keys("\C-w")
-    assert_line_around_cursor('', '')
-  end
-
-  def test_vi_search_prev
-    Reline::HISTORY.concat(%w{abc 123 AAA})
-    assert_line_around_cursor('', '')
-    input_keys("\C-ra\C-j")
-    assert_line_around_cursor('', 'abc')
-  end
-
-  def test_larger_histories_than_history_size
-    history_size = @config.history_size
-    @config.history_size = 2
-    Reline::HISTORY.concat(%w{abc 123 AAA})
-    assert_line_around_cursor('', '')
-    input_keys("\C-p")
-    assert_line_around_cursor('AAA', '')
-    input_keys("\C-p")
-    assert_line_around_cursor('123', '')
-    input_keys("\C-p")
-    assert_line_around_cursor('123', '')
-  ensure
-    @config.history_size = history_size
-  end
-
-  def test_search_history_to_back
-    Reline::HISTORY.concat([
-      '1235', # old
-      '12aa',
-      '1234' # new
-    ])
-    assert_line_around_cursor('', '')
-    input_keys("\C-r123")
-    assert_line_around_cursor('1234', '')
-    input_keys("\C-ha")
-    assert_line_around_cursor('12aa', '')
-    input_keys("\C-h3")
-    assert_line_around_cursor('1235', '')
-  end
-
-  def test_search_history_to_front
-    Reline::HISTORY.concat([
-      '1235', # old
-      '12aa',
-      '1234' # new
-    ])
-    assert_line_around_cursor('', '')
-    input_keys("\C-s123")
-    assert_line_around_cursor('1235', '')
-    input_keys("\C-ha")
-    assert_line_around_cursor('12aa', '')
-    input_keys("\C-h3")
-    assert_line_around_cursor('1234', '')
-  end
-
-  def test_search_history_front_and_back
-    Reline::HISTORY.concat([
-      '1235', # old
-      '12aa',
-      '1234' # new
-    ])
-    assert_line_around_cursor('', '')
-    input_keys("\C-s12")
-    assert_line_around_cursor('1235', '')
-    input_keys("\C-s")
-    assert_line_around_cursor('12aa', '')
-    input_keys("\C-r")
-    assert_line_around_cursor('12aa', '')
-    input_keys("\C-r")
-    assert_line_around_cursor('1235', '')
-  end
-
-  def test_search_history_back_and_front
-    Reline::HISTORY.concat([
-      '1235', # old
-      '12aa',
-      '1234' # new
-    ])
-    assert_line_around_cursor('', '')
-    input_keys("\C-r12")
-    assert_line_around_cursor('1234', '')
-    input_keys("\C-r")
-    assert_line_around_cursor('12aa', '')
-    input_keys("\C-s")
-    assert_line_around_cursor('12aa', '')
-    input_keys("\C-s")
-    assert_line_around_cursor('1234', '')
-  end
-
-  def test_search_history_to_back_in_the_middle_of_histories
-    Reline::HISTORY.concat([
-      '1235', # old
-      '12aa',
-      '1234' # new
-    ])
-    assert_line_around_cursor('', '')
-    input_keys("\C-p\C-p")
-    assert_line_around_cursor('12aa', '')
-    input_keys("\C-r123")
-    assert_line_around_cursor('1235', '')
-  end
-
-  def test_search_history_twice
-    Reline::HISTORY.concat([
-      '1235', # old
-      '12aa',
-      '1234' # new
-    ])
-    assert_line_around_cursor('', '')
-    input_keys("\C-r123")
-    assert_line_around_cursor('1234', '')
-    input_keys("\C-r")
-    assert_line_around_cursor('1235', '')
-  end
-
-  def test_search_history_by_last_determined
-    Reline::HISTORY.concat([
-      '1235', # old
-      '12aa',
-      '1234' # new
-    ])
-    assert_line_around_cursor('', '')
-    input_keys("\C-r123")
-    assert_line_around_cursor('1234', '')
-    input_keys("\C-j")
-    assert_line_around_cursor('', '1234')
-    input_keys("\C-k") # delete
-    assert_line_around_cursor('', '')
-    input_keys("\C-r")
-    assert_line_around_cursor('', '')
-    input_keys("\C-r")
-    assert_line_around_cursor('1235', '')
-  end
-
-  def test_search_history_with_isearch_terminator
-    @config.read_lines(<<~LINES.split(/(?<=\n)/))
-      set isearch-terminators "XYZ"
-    LINES
-    Reline::HISTORY.concat([
-      '1235', # old
-      '12aa',
-      '1234' # new
-    ])
-    assert_line_around_cursor('', '')
-    input_keys("\C-r12a")
-    assert_line_around_cursor('12aa', '')
-    input_keys('Y')
-    assert_line_around_cursor('', '12aa')
-    input_keys('x')
-    assert_line_around_cursor('x', '12aa')
-  end
-
-  def test_em_set_mark_and_em_exchange_mark
-    input_keys('aaa bbb ccc ddd')
-    assert_line_around_cursor('aaa bbb ccc ddd', '')
-    input_keys("\C-a\eF\eF")
-    assert_line_around_cursor('aaa bbb', ' ccc ddd')
-    assert_equal(nil, @line_editor.instance_variable_get(:@mark_pointer))
-    input_keys("\x00") # C-Space
-    assert_line_around_cursor('aaa bbb', ' ccc ddd')
-    assert_equal([7, 0], @line_editor.instance_variable_get(:@mark_pointer))
-    input_keys("\C-a")
-    assert_line_around_cursor('', 'aaa bbb ccc ddd')
-    assert_equal([7, 0], @line_editor.instance_variable_get(:@mark_pointer))
-    input_key_by_symbol(:em_exchange_mark)
-    assert_line_around_cursor('aaa bbb', ' ccc ddd')
-    assert_equal([0, 0], @line_editor.instance_variable_get(:@mark_pointer))
-  end
-
-  def test_em_exchange_mark_without_mark
-    input_keys('aaa bbb ccc ddd')
-    assert_line_around_cursor('aaa bbb ccc ddd', '')
-    input_keys("\C-a\ef")
-    assert_line_around_cursor('aaa', ' bbb ccc ddd')
-    assert_equal(nil, @line_editor.instance_variable_get(:@mark_pointer))
-    input_key_by_symbol(:em_exchange_mark)
-    assert_line_around_cursor('aaa', ' bbb ccc ddd')
-    assert_equal(nil, @line_editor.instance_variable_get(:@mark_pointer))
-  end
-
-  def test_modify_lines_with_wrong_rs
-    verbose, $VERBOSE = $VERBOSE, nil
-    original_global_slash = $/
-    $/ = 'b'
-    $VERBOSE = verbose
-    @line_editor.output_modifier_proc = proc { |output| Reline::Unicode.escape_for_print(output) }
-    input_keys("abcdef\n")
-    result = @line_editor.__send__(:modify_lines, @line_editor.whole_lines, @line_editor.finished?)
-    $/ = nil
-    assert_equal(['abcdef'], result)
-  ensure
-    $VERBOSE = nil
-    $/ = original_global_slash
-    $VERBOSE = verbose
-  end
-
-  def test_ed_search_prev_history
-    Reline::HISTORY.concat([
-      '12356', # old
-      '12aaa',
-      '12345' # new
-    ])
-    input_keys('123')
-    # The ed_search_prev_history doesn't have default binding
-    @line_editor.__send__(:ed_search_prev_history, "\C-p".ord)
-    assert_line_around_cursor('123', '45')
-    @line_editor.__send__(:ed_search_prev_history, "\C-p".ord)
-    assert_line_around_cursor('123', '56')
-    @line_editor.__send__(:ed_search_prev_history, "\C-p".ord)
-    assert_line_around_cursor('123', '56')
-  end
-
-  def test_ed_search_prev_history_with_empty
-    Reline::HISTORY.concat([
-      '12356', # old
-      '12aaa',
-      '12345' # new
-    ])
-    # The ed_search_prev_history doesn't have default binding
-    input_key_by_symbol(:ed_search_prev_history)
-    assert_line_around_cursor('12345', '')
-    input_key_by_symbol(:ed_search_prev_history)
-    assert_line_around_cursor('12aaa', '')
-    input_key_by_symbol(:ed_search_prev_history)
-    assert_line_around_cursor('12356', '')
-    input_key_by_symbol(:ed_search_next_history)
-    assert_line_around_cursor('12aaa', '')
-    input_key_by_symbol(:ed_prev_char)
-    input_key_by_symbol(:ed_next_char)
-    assert_line_around_cursor('12aaa', '')
-    input_key_by_symbol(:ed_search_prev_history)
-    assert_line_around_cursor('12aaa', '')
-    3.times { input_key_by_symbol(:ed_prev_char) }
-    input_key_by_symbol(:ed_search_prev_history)
-    assert_line_around_cursor('12', '356')
-  end
-
-  def test_ed_search_prev_history_without_match
-    Reline::HISTORY.concat([
-      '12356', # old
-      '12aaa',
-      '12345' # new
-    ])
-    input_keys('ABC')
-    # The ed_search_prev_history doesn't have default binding
-    @line_editor.__send__(:ed_search_prev_history, "\C-p".ord)
-    assert_line_around_cursor('ABC', '')
-  end
-
-  def test_ed_search_next_history
-    Reline::HISTORY.concat([
-      '12356', # old
-      '12aaa',
-      '12345' # new
-    ])
-    input_keys('123')
-    # The ed_search_prev_history and ed_search_next_history doesn't have default binding
-    @line_editor.__send__(:ed_search_prev_history, "\C-p".ord)
-    assert_line_around_cursor('123', '45')
-    @line_editor.__send__(:ed_search_prev_history, "\C-p".ord)
-    assert_line_around_cursor('123', '56')
-    @line_editor.__send__(:ed_search_prev_history, "\C-p".ord)
-    assert_line_around_cursor('123', '56')
-    @line_editor.__send__(:ed_search_next_history, "\C-n".ord)
-    assert_line_around_cursor('123', '45')
-    @line_editor.__send__(:ed_search_next_history, "\C-n".ord)
-    assert_line_around_cursor('123', '45')
-  end
-
-  def test_ed_search_next_history_with_empty
-    Reline::HISTORY.concat([
-      '12356', # old
-      '12aaa',
-      '12345' # new
-    ])
-    # The ed_search_prev_history and ed_search_next_history doesn't have default binding
-    input_key_by_symbol(:ed_search_prev_history)
-    assert_line_around_cursor('12345', '')
-    input_key_by_symbol(:ed_search_prev_history)
-    assert_line_around_cursor('12aaa', '')
-    input_key_by_symbol(:ed_search_prev_history)
-    assert_line_around_cursor('12356', '')
-    input_key_by_symbol(:ed_search_next_history)
-    assert_line_around_cursor('12aaa', '')
-    input_key_by_symbol(:ed_search_next_history)
-    assert_line_around_cursor('12345', '')
-    input_key_by_symbol(:ed_search_prev_history)
-    assert_line_around_cursor('12aaa', '')
-    input_key_by_symbol(:ed_prev_char)
-    input_key_by_symbol(:ed_next_char)
-    input_key_by_symbol(:ed_search_next_history)
-    assert_line_around_cursor('12aaa', '')
-    3.times { input_key_by_symbol(:ed_prev_char) }
-    input_key_by_symbol(:ed_search_next_history)
-    assert_line_around_cursor('12', '345')
-  end
-
-  def test_incremental_search_history_cancel_by_symbol_key
-    # ed_prev_char should move cursor left and cancel incremental search
-    input_keys("abc\C-r")
-    input_key_by_symbol(:ed_prev_char, csi: true)
-    input_keys('d')
-    assert_line_around_cursor('abd', 'c')
-  end
-
-  def test_incremental_search_history_saves_and_restores_last_input
-    Reline::HISTORY.concat(['abc', '123'])
-    input_keys("abcd")
-    # \C-j: terminate incremental search
-    input_keys("\C-r12\C-j")
-    assert_line_around_cursor('', '123')
-    input_key_by_symbol(:ed_next_history)
-    assert_line_around_cursor('abcd', '')
-    # Most non-printable keys also terminates incremental search
-    input_keys("\C-r12\C-i")
-    assert_line_around_cursor('', '123')
-    input_key_by_symbol(:ed_next_history)
-    assert_line_around_cursor('abcd', '')
-    # \C-g: cancel incremental search and restore input, cursor position and history index
-    input_key_by_symbol(:ed_prev_history)
-    input_keys("\C-b\C-b")
-    assert_line_around_cursor('1', '23')
-    input_keys("\C-rab\C-g")
-    assert_line_around_cursor('1', '23')
-    input_key_by_symbol(:ed_next_history)
-    assert_line_around_cursor('abcd', '')
-  end
-
-  def test_beginning_of_history
-    Reline::HISTORY.concat(['abc', '123'])
-    # \M-<: move history to beginning
-    input_key_by_symbol(:beginning_of_history)
-    assert_line_around_cursor('abc', '')
-  end
-
-  def test_end_of_history
-    Reline::HISTORY.concat(['abc', '123'])
-    input_keys("def\C-p\C-pd")
-    assert_line_around_cursor('abcd', '')
-    # \M->: move history to end
-    input_key_by_symbol(:end_of_history)
-    assert_line_around_cursor('def', '')
-  end
-
-  # Unicode emoji test
-  def test_ed_insert_for_include_zwj_emoji
-    omit_unless_utf8
-    # U+1F468 U+200D U+1F469 U+200D U+1F467 U+200D U+1F466 is family: man, woman, girl, boy "👨‍👩‍👧‍👦"
-    input_keys("\u{1F468}") # U+1F468 is man "👨"
-    assert_line_around_cursor('👨', '')
-    input_keys("\u200D") # U+200D is ZERO WIDTH JOINER
-    assert_line_around_cursor('👨‍', '')
-    input_keys("\u{1F469}") # U+1F469 is woman "👩"
-    assert_line_around_cursor('👨‍👩', '')
-    input_keys("\u200D") # U+200D is ZERO WIDTH JOINER
-    assert_line_around_cursor('👨‍👩‍', '')
-    input_keys("\u{1F467}") # U+1F467 is girl "👧"
-    assert_line_around_cursor('👨‍👩‍👧', '')
-    input_keys("\u200D") # U+200D is ZERO WIDTH JOINER
-    assert_line_around_cursor('👨‍👩‍👧‍', '')
-    input_keys("\u{1F466}") # U+1F466 is boy "👦"
-    assert_line_around_cursor('👨‍👩‍👧‍👦', '')
-    # U+1F468 U+200D U+1F469 U+200D U+1F467 U+200D U+1F466 is family: man, woman, girl, boy "👨‍👩‍👧‍👦"
-    input_keys("\u{1F468 200D 1F469 200D 1F467 200D 1F466}")
-    assert_line_around_cursor('👨‍👩‍👧‍👦👨‍👩‍👧‍👦', '')
-  end
-
-  def test_ed_insert_for_include_valiation_selector
-    omit_unless_utf8
-    # U+0030 U+FE00 is DIGIT ZERO + VARIATION SELECTOR-1 "0︀"
-    input_keys("\u0030") # U+0030 is DIGIT ZERO
-    assert_line_around_cursor('0', '')
-    input_keys("\uFE00") # U+FE00 is VARIATION SELECTOR-1
-    assert_line_around_cursor('0︀', '')
-  end
-
-  def test_em_yank_pop
-    input_keys("def hoge\C-w\C-b\C-f\C-w")
-    assert_line_around_cursor('', '')
-    input_keys("\C-y")
-    assert_line_around_cursor('def ', '')
-    input_keys("\e\C-y")
-    assert_line_around_cursor('hoge', '')
-  end
-
-  def test_em_kill_region_with_kill_ring
-    input_keys("def hoge\C-b\C-b\C-b\C-b")
-    assert_line_around_cursor('def ', 'hoge')
-    input_keys("\C-k\C-w")
-    assert_line_around_cursor('', '')
-    input_keys("\C-y")
-    assert_line_around_cursor('def hoge', '')
-  end
-
-  def test_ed_search_prev_next_history_in_multibyte
-    Reline::HISTORY.concat([
-      "def hoge\n  67890\n  12345\nend", # old
-      "def aiu\n  0xDEADBEEF\nend",
-      "def foo\n  12345\nend" # new
-    ])
-    @line_editor.multiline_on
-    input_keys('  123')
-    # The ed_search_prev_history doesn't have default binding
-    @line_editor.__send__(:ed_search_prev_history, "\C-p".ord)
-    assert_whole_lines(['def foo', '  12345', 'end'])
-    assert_line_index(1)
-    assert_whole_lines(['def foo', '  12345', 'end'])
-    assert_line_around_cursor('  123', '45')
-    @line_editor.__send__(:ed_search_prev_history, "\C-p".ord)
-    assert_line_index(2)
-    assert_whole_lines(['def hoge', '  67890', '  12345', 'end'])
-    assert_line_around_cursor('  123', '45')
-    @line_editor.__send__(:ed_search_prev_history, "\C-p".ord)
-    assert_line_index(2)
-    assert_whole_lines(['def hoge', '  67890', '  12345', 'end'])
-    assert_line_around_cursor('  123', '45')
-    @line_editor.__send__(:ed_search_next_history, "\C-n".ord)
-    assert_line_index(1)
-    assert_whole_lines(['def foo', '  12345', 'end'])
-    assert_line_around_cursor('  123', '45')
-    @line_editor.__send__(:ed_search_next_history, "\C-n".ord)
-    assert_line_index(1)
-    assert_whole_lines(['def foo', '  12345', 'end'])
-    assert_line_around_cursor('  123', '45')
-  end
-
-  def test_ignore_NUL_by_ed_quoted_insert
-    input_keys('"')
-    input_key_by_symbol(:insert_raw_char, char: 0.chr)
-    input_keys('"')
-    assert_line_around_cursor('""', '')
-  end
-
-  def test_ed_argument_digit_by_meta_num
-    input_keys('abcdef')
-    assert_line_around_cursor('abcdef', '')
-    input_keys("\e2")
-    input_keys("\C-h")
-    assert_line_around_cursor('abcd', '')
-  end
-
-  def test_ed_digit_with_ed_argument_digit
-    input_keys('1' * 30)
-    assert_line_around_cursor('1' * 30, '')
-    input_keys("\e2")
-    input_keys('3')
-    input_keys("\C-h")
-    input_keys('4')
-    assert_line_around_cursor('1' * 7 + '4', '')
-  end
-
-  def test_halfwidth_kana_width_dakuten
-    omit_unless_utf8
-    input_keys('ｶﾞｷﾞｹﾞｺﾞ')
-    assert_line_around_cursor('ｶﾞｷﾞｹﾞｺﾞ', '')
-    input_keys("\C-b\C-b")
-    assert_line_around_cursor('ｶﾞｷﾞ', 'ｹﾞｺﾞ')
-    input_keys('ｸﾞ')
-    assert_line_around_cursor('ｶﾞｷﾞｸﾞ', 'ｹﾞｺﾞ')
-  end
-
-  def test_input_unknown_char
-    omit_unless_utf8
-    input_keys('͸') # U+0378 (unassigned)
-    assert_line_around_cursor('͸', '')
-  end
-
-  def test_unix_line_discard
-    input_keys("\C-u")
-    assert_line_around_cursor('', '')
-    input_keys('abc')
-    assert_line_around_cursor('abc', '')
-    input_keys("\C-b\C-u")
-    assert_line_around_cursor('', 'c')
-    input_keys("\C-f\C-u")
-    assert_line_around_cursor('', '')
-  end
-
-  def test_vi_editing_mode
-    @line_editor.__send__(:vi_editing_mode, nil)
-    assert(@config.editing_mode_is?(:vi_insert))
-  end
-
-  def test_undo
-    input_keys("\C-_")
-    assert_line_around_cursor('', '')
-    input_keys("aあb\C-h\C-h\C-h")
-    assert_line_around_cursor('', '')
-    input_keys("\C-_")
-    assert_line_around_cursor('a', '')
-    input_keys("\C-_")
-    assert_line_around_cursor('aあ', '')
-    input_keys("\C-_")
-    assert_line_around_cursor('aあb', '')
-    input_keys("\C-_")
-    assert_line_around_cursor('aあ', '')
-    input_keys("\C-_")
-    assert_line_around_cursor('a', '')
-    input_keys("\C-_")
-    assert_line_around_cursor('', '')
-  end
-
-  def test_undo_with_cursor_position
-    input_keys("abc\C-b\C-h")
-    assert_line_around_cursor('a', 'c')
-    input_keys("\C-_")
-    assert_line_around_cursor('ab', 'c')
-    input_keys("あいう\C-b\C-h")
-    assert_line_around_cursor('abあ', 'うc')
-    input_keys("\C-_")
-    assert_line_around_cursor('abあい', 'うc')
-  end
-
-  def test_undo_with_multiline
-    @line_editor.multiline_on
-    @line_editor.confirm_multiline_termination_proc = proc {}
-    input_keys("1\n2\n3")
-    assert_whole_lines(["1", "2", "3"])
-    assert_line_index(2)
-    assert_line_around_cursor('3', '')
-    input_keys("\C-p\C-h\C-h")
-    assert_whole_lines(["1", "3"])
-    assert_line_index(0)
-    assert_line_around_cursor('1', '')
-    input_keys("\C-_")
-    assert_whole_lines(["1", "", "3"])
-    assert_line_index(1)
-    assert_line_around_cursor('', '')
-    input_keys("\C-_")
-    assert_whole_lines(["1", "2", "3"])
-    assert_line_index(1)
-    assert_line_around_cursor('2', '')
-    input_keys("\C-_")
-    assert_whole_lines(["1", "2", ""])
-    assert_line_index(2)
-    assert_line_around_cursor('', '')
-    input_keys("\C-_")
-    assert_whole_lines(["1", "2"])
-    assert_line_index(1)
-    assert_line_around_cursor('2', '')
-  end
-
-  def test_undo_with_many_times
-    str = "a" + "b" * 99
-    input_keys(str)
-    100.times { input_keys("\C-_") }
-    assert_line_around_cursor('a', '')
-    input_keys("\C-_")
-    assert_line_around_cursor('a', '')
-  end
-
-  def test_redo
-    input_keys("aあb")
-    assert_line_around_cursor('aあb', '')
-    input_keys("\e\C-_")
-    assert_line_around_cursor('aあb', '')
-    input_keys("\C-_")
-    assert_line_around_cursor('aあ', '')
-    input_keys("\C-_")
-    assert_line_around_cursor('a', '')
-    input_keys("\e\C-_")
-    assert_line_around_cursor('aあ', '')
-    input_keys("\e\C-_")
-    assert_line_around_cursor('aあb', '')
-    input_keys("\C-_")
-    assert_line_around_cursor('aあ', '')
-    input_keys("c")
-    assert_line_around_cursor('aあc', '')
-    input_keys("\e\C-_")
-    assert_line_around_cursor('aあc', '')
-  end
-
-  def test_redo_with_cursor_position
-    input_keys("abc\C-b\C-h")
-    assert_line_around_cursor('a', 'c')
-    input_keys("\e\C-_")
-    assert_line_around_cursor('a', 'c')
-    input_keys("\C-_")
-    assert_line_around_cursor('ab', 'c')
-    input_keys("\e\C-_")
-    assert_line_around_cursor('a', 'c')
-  end
-
-  def test_redo_with_multiline
-    @line_editor.multiline_on
-    @line_editor.confirm_multiline_termination_proc = proc {}
-    input_keys("1\n2\n3")
-    assert_whole_lines(["1", "2", "3"])
-    assert_line_index(2)
-    assert_line_around_cursor('3', '')
-
-    input_keys("\C-_")
-    assert_whole_lines(["1", "2", ""])
-    assert_line_index(2)
-    assert_line_around_cursor('', '')
-
-    input_keys("\C-_")
-    assert_whole_lines(["1", "2"])
-    assert_line_index(1)
-    assert_line_around_cursor('2', '')
-
-    input_keys("\e\C-_")
-    assert_whole_lines(["1", "2", ""])
-    assert_line_index(2)
-    assert_line_around_cursor('', '')
-
-    input_keys("\e\C-_")
-    assert_whole_lines(["1", "2", "3"])
-    assert_line_index(2)
-    assert_line_around_cursor('3', '')
-
-    input_keys("\C-p\C-h\C-h")
-    assert_whole_lines(["1", "3"])
-    assert_line_index(0)
-    assert_line_around_cursor('1', '')
-
-    input_keys("\C-n")
-    assert_whole_lines(["1", "3"])
-    assert_line_index(1)
-    assert_line_around_cursor('3', '')
-
-    input_keys("\C-_")
-    assert_whole_lines(["1", "", "3"])
-    assert_line_index(1)
-    assert_line_around_cursor('', '')
-
-    input_keys("\C-_")
-    assert_whole_lines(["1", "2", "3"])
-    assert_line_index(1)
-    assert_line_around_cursor('2', '')
-
-    input_keys("\e\C-_")
-    assert_whole_lines(["1", "", "3"])
-    assert_line_index(1)
-    assert_line_around_cursor('', '')
-
-    input_keys("\e\C-_")
-    assert_whole_lines(["1", "3"])
-    assert_line_index(1)
-    assert_line_around_cursor('3', '')
-  end
-
-  def test_undo_redo_restores_indentation
-    @line_editor.multiline_on
-    @line_editor.confirm_multiline_termination_proc = proc {}
-    input_keys(" 1")
-    assert_whole_lines([' 1'])
-    input_keys("2")
-    assert_whole_lines([' 12'])
-    @line_editor.auto_indent_proc = proc { 2 }
-    input_keys("\C-_")
-    assert_whole_lines([' 1'])
-    input_keys("\e\C-_")
-    assert_whole_lines([' 12'])
-  end
-
-  def test_redo_with_many_times
-    str = "a" + "b" * 98 + "c"
-    input_keys(str)
-    100.times { input_keys("\C-_") }
-    assert_line_around_cursor('a', '')
-    input_keys("\C-_")
-    assert_line_around_cursor('a', '')
-    100.times { input_keys("\e\C-_") }
-    assert_line_around_cursor(str, '')
-    input_keys("\e\C-_")
-    assert_line_around_cursor(str, '')
-  end
-end
diff --git a/test/mri/reline/test_key_actor_vi.rb b/test/mri/reline/test_key_actor_vi.rb
deleted file mode 100644
index 083433f9a80..00000000000
--- a/test/mri/reline/test_key_actor_vi.rb
+++ /dev/null
@@ -1,967 +0,0 @@
-require_relative 'helper'
-
-class Reline::ViInsertTest < Reline::TestCase
-  def setup
-    Reline.send(:test_mode)
-    @prompt = '> '
-    @config = Reline::Config.new
-    @config.read_lines(<<~LINES.split(/(?<=\n)/))
-      set editing-mode vi
-    LINES
-    @encoding = Reline.core.encoding
-    @line_editor = Reline::LineEditor.new(@config)
-    @line_editor.reset(@prompt)
-  end
-
-  def editing_mode_label
-    @config.instance_variable_get(:@editing_mode_label)
-  end
-
-  def teardown
-    Reline.test_reset
-  end
-
-  def test_vi_command_mode
-    input_keys("\C-[")
-    assert_equal(:vi_command, editing_mode_label)
-  end
-
-  def test_vi_command_mode_with_input
-    input_keys("abc\C-[")
-    assert_equal(:vi_command, editing_mode_label)
-    assert_line_around_cursor('ab', 'c')
-  end
-
-  def test_vi_insert
-    assert_equal(:vi_insert, editing_mode_label)
-    input_keys('i')
-    assert_line_around_cursor('i', '')
-    assert_equal(:vi_insert, editing_mode_label)
-    input_keys("\C-[")
-    assert_line_around_cursor('', 'i')
-    assert_equal(:vi_command, editing_mode_label)
-    input_keys('i')
-    assert_line_around_cursor('', 'i')
-    assert_equal(:vi_insert, editing_mode_label)
-  end
-
-  def test_vi_add
-    assert_equal(:vi_insert, editing_mode_label)
-    input_keys('a')
-    assert_line_around_cursor('a', '')
-    assert_equal(:vi_insert, editing_mode_label)
-    input_keys("\C-[")
-    assert_line_around_cursor('', 'a')
-    assert_equal(:vi_command, editing_mode_label)
-    input_keys('a')
-    assert_line_around_cursor('a', '')
-    assert_equal(:vi_insert, editing_mode_label)
-  end
-
-  def test_vi_insert_at_bol
-    input_keys('I')
-    assert_line_around_cursor('I', '')
-    assert_equal(:vi_insert, editing_mode_label)
-    input_keys("12345\C-[hh")
-    assert_line_around_cursor('I12', '345')
-    assert_equal(:vi_command, editing_mode_label)
-    input_keys('I')
-    assert_line_around_cursor('', 'I12345')
-    assert_equal(:vi_insert, editing_mode_label)
-  end
-
-  def test_vi_add_at_eol
-    input_keys('A')
-    assert_line_around_cursor('A', '')
-    assert_equal(:vi_insert, editing_mode_label)
-    input_keys("12345\C-[hh")
-    assert_line_around_cursor('A12', '345')
-    assert_equal(:vi_command, editing_mode_label)
-    input_keys('A')
-    assert_line_around_cursor('A12345', '')
-    assert_equal(:vi_insert, editing_mode_label)
-  end
-
-  def test_ed_insert_one
-    input_keys('a')
-    assert_line_around_cursor('a', '')
-  end
-
-  def test_ed_insert_two
-    input_keys('ab')
-    assert_line_around_cursor('ab', '')
-  end
-
-  def test_ed_insert_mbchar_one
-    input_keys('か')
-    assert_line_around_cursor('か', '')
-  end
-
-  def test_ed_insert_mbchar_two
-    input_keys('かき')
-    assert_line_around_cursor('かき', '')
-  end
-
-  def test_ed_insert_for_mbchar_by_plural_code_points
-    omit_unless_utf8
-    input_keys("か\u3099")
-    assert_line_around_cursor("か\u3099", '')
-  end
-
-  def test_ed_insert_for_plural_mbchar_by_plural_code_points
-    omit_unless_utf8
-    input_keys("か\u3099き\u3099")
-    assert_line_around_cursor("か\u3099き\u3099", '')
-  end
-
-  def test_ed_insert_ignore_in_vi_command
-    input_keys("\C-[")
-    chars_to_be_ignored = "\C-Oあ=".chars
-    input_keys(chars_to_be_ignored.join)
-    assert_line_around_cursor('', '')
-    input_keys(chars_to_be_ignored.map {|c| "5#{c}" }.join)
-    assert_line_around_cursor('', '')
-    input_keys('iい')
-    assert_line_around_cursor("い", '')
-  end
-
-  def test_ed_next_char
-    input_keys("abcdef\C-[0")
-    assert_line_around_cursor('', 'abcdef')
-    input_keys('l')
-    assert_line_around_cursor('a', 'bcdef')
-    input_keys('2l')
-    assert_line_around_cursor('abc', 'def')
-  end
-
-  def test_ed_prev_char
-    input_keys("abcdef\C-[")
-    assert_line_around_cursor('abcde', 'f')
-    input_keys('h')
-    assert_line_around_cursor('abcd', 'ef')
-    input_keys('2h')
-    assert_line_around_cursor('ab', 'cdef')
-  end
-
-  def test_history
-    Reline::HISTORY.concat(%w{abc 123 AAA})
-    input_keys("\C-[")
-    assert_line_around_cursor('', '')
-    input_keys('k')
-    assert_line_around_cursor('', 'AAA')
-    input_keys('2k')
-    assert_line_around_cursor('', 'abc')
-    input_keys('j')
-    assert_line_around_cursor('', '123')
-    input_keys('2j')
-    assert_line_around_cursor('', '')
-  end
-
-  def test_vi_paste_prev
-    input_keys("abcde\C-[3h")
-    assert_line_around_cursor('a', 'bcde')
-    input_keys('P')
-    assert_line_around_cursor('a', 'bcde')
-    input_keys('d$')
-    assert_line_around_cursor('', 'a')
-    input_keys('P')
-    assert_line_around_cursor('bcd', 'ea')
-    input_keys('2P')
-    assert_line_around_cursor('bcdbcdbcd', 'eeea')
-  end
-
-  def test_vi_paste_next
-    input_keys("abcde\C-[3h")
-    assert_line_around_cursor('a', 'bcde')
-    input_keys('p')
-    assert_line_around_cursor('a', 'bcde')
-    input_keys('d$')
-    assert_line_around_cursor('', 'a')
-    input_keys('p')
-    assert_line_around_cursor('abcd', 'e')
-    input_keys('2p')
-    assert_line_around_cursor('abcdebcdebcd', 'e')
-  end
-
-  def test_vi_paste_prev_for_mbchar
-    input_keys("あいうえお\C-[3h")
-    assert_line_around_cursor('あ', 'いうえお')
-    input_keys('P')
-    assert_line_around_cursor('あ', 'いうえお')
-    input_keys('d$')
-    assert_line_around_cursor('', 'あ')
-    input_keys('P')
-    assert_line_around_cursor('いうえ', 'おあ')
-    input_keys('2P')
-    assert_line_around_cursor('いうえいうえいうえ', 'おおおあ')
-  end
-
-  def test_vi_paste_next_for_mbchar
-    input_keys("あいうえお\C-[3h")
-    assert_line_around_cursor('あ', 'いうえお')
-    input_keys('p')
-    assert_line_around_cursor('あ', 'いうえお')
-    input_keys('d$')
-    assert_line_around_cursor('', 'あ')
-    input_keys('p')
-    assert_line_around_cursor('あいうえ', 'お')
-    input_keys('2p')
-    assert_line_around_cursor('あいうえおいうえおいうえ', 'お')
-  end
-
-  def test_vi_paste_prev_for_mbchar_by_plural_code_points
-    omit_unless_utf8
-    input_keys("か\u3099き\u3099く\u3099け\u3099こ\u3099\C-[3h")
-    assert_line_around_cursor("か\u3099", "き\u3099く\u3099け\u3099こ\u3099")
-    input_keys('P')
-    assert_line_around_cursor("か\u3099", "き\u3099く\u3099け\u3099こ\u3099")
-    input_keys('d$')
-    assert_line_around_cursor('', "か\u3099")
-    input_keys('P')
-    assert_line_around_cursor("き\u3099く\u3099け\u3099", "こ\u3099か\u3099")
-    input_keys('2P')
-    assert_line_around_cursor("き\u3099く\u3099け\u3099き\u3099く\u3099け\u3099き\u3099く\u3099け\u3099", "こ\u3099こ\u3099こ\u3099か\u3099")
-  end
-
-  def test_vi_paste_next_for_mbchar_by_plural_code_points
-    omit_unless_utf8
-    input_keys("か\u3099き\u3099く\u3099け\u3099こ\u3099\C-[3h")
-    assert_line_around_cursor("か\u3099", "き\u3099く\u3099け\u3099こ\u3099")
-    input_keys('p')
-    assert_line_around_cursor("か\u3099", "き\u3099く\u3099け\u3099こ\u3099")
-    input_keys('d$')
-    assert_line_around_cursor('', "か\u3099")
-    input_keys('p')
-    assert_line_around_cursor("か\u3099き\u3099く\u3099け\u3099", "こ\u3099")
-    input_keys('2p')
-    assert_line_around_cursor("か\u3099き\u3099く\u3099け\u3099こ\u3099き\u3099く\u3099け\u3099こ\u3099き\u3099く\u3099け\u3099", "こ\u3099")
-  end
-
-  def test_vi_prev_next_word
-    input_keys("aaa b{b}b ccc\C-[0")
-    assert_line_around_cursor('', 'aaa b{b}b ccc')
-    input_keys('w')
-    assert_line_around_cursor('aaa ', 'b{b}b ccc')
-    input_keys('w')
-    assert_line_around_cursor('aaa b', '{b}b ccc')
-    input_keys('w')
-    assert_line_around_cursor('aaa b{', 'b}b ccc')
-    input_keys('w')
-    assert_line_around_cursor('aaa b{b', '}b ccc')
-    input_keys('w')
-    assert_line_around_cursor('aaa b{b}', 'b ccc')
-    input_keys('w')
-    assert_line_around_cursor('aaa b{b}b ', 'ccc')
-    input_keys('w')
-    assert_line_around_cursor('aaa b{b}b cc', 'c')
-    input_keys('b')
-    assert_line_around_cursor('aaa b{b}b ', 'ccc')
-    input_keys('b')
-    assert_line_around_cursor('aaa b{b}', 'b ccc')
-    input_keys('b')
-    assert_line_around_cursor('aaa b{b', '}b ccc')
-    input_keys('b')
-    assert_line_around_cursor('aaa b{', 'b}b ccc')
-    input_keys('b')
-    assert_line_around_cursor('aaa b', '{b}b ccc')
-    input_keys('b')
-    assert_line_around_cursor('aaa ', 'b{b}b ccc')
-    input_keys('b')
-    assert_line_around_cursor('', 'aaa b{b}b ccc')
-    input_keys('3w')
-    assert_line_around_cursor('aaa b{', 'b}b ccc')
-    input_keys('3w')
-    assert_line_around_cursor('aaa b{b}b ', 'ccc')
-    input_keys('3w')
-    assert_line_around_cursor('aaa b{b}b cc', 'c')
-    input_keys('3b')
-    assert_line_around_cursor('aaa b{b', '}b ccc')
-    input_keys('3b')
-    assert_line_around_cursor('aaa ', 'b{b}b ccc')
-    input_keys('3b')
-    assert_line_around_cursor('', 'aaa b{b}b ccc')
-  end
-
-  def test_vi_end_word
-    input_keys("aaa   b{b}}}b   ccc\C-[0")
-    assert_line_around_cursor('', 'aaa   b{b}}}b   ccc')
-    input_keys('e')
-    assert_line_around_cursor('aa', 'a   b{b}}}b   ccc')
-    input_keys('e')
-    assert_line_around_cursor('aaa   ', 'b{b}}}b   ccc')
-    input_keys('e')
-    assert_line_around_cursor('aaa   b', '{b}}}b   ccc')
-    input_keys('e')
-    assert_line_around_cursor('aaa   b{', 'b}}}b   ccc')
-    input_keys('e')
-    assert_line_around_cursor('aaa   b{b}}', '}b   ccc')
-    input_keys('e')
-    assert_line_around_cursor('aaa   b{b}}}', 'b   ccc')
-    input_keys('e')
-    assert_line_around_cursor('aaa   b{b}}}b   cc', 'c')
-    input_keys('e')
-    assert_line_around_cursor('aaa   b{b}}}b   cc', 'c')
-    input_keys('03e')
-    assert_line_around_cursor('aaa   b', '{b}}}b   ccc')
-    input_keys('3e')
-    assert_line_around_cursor('aaa   b{b}}}', 'b   ccc')
-    input_keys('3e')
-    assert_line_around_cursor('aaa   b{b}}}b   cc', 'c')
-  end
-
-  def test_vi_prev_next_big_word
-    input_keys("aaa b{b}b ccc\C-[0")
-    assert_line_around_cursor('', 'aaa b{b}b ccc')
-    input_keys('W')
-    assert_line_around_cursor('aaa ', 'b{b}b ccc')
-    input_keys('W')
-    assert_line_around_cursor('aaa b{b}b ', 'ccc')
-    input_keys('W')
-    assert_line_around_cursor('aaa b{b}b cc', 'c')
-    input_keys('B')
-    assert_line_around_cursor('aaa b{b}b ', 'ccc')
-    input_keys('B')
-    assert_line_around_cursor('aaa ', 'b{b}b ccc')
-    input_keys('B')
-    assert_line_around_cursor('', 'aaa b{b}b ccc')
-    input_keys('2W')
-    assert_line_around_cursor('aaa b{b}b ', 'ccc')
-    input_keys('2W')
-    assert_line_around_cursor('aaa b{b}b cc', 'c')
-    input_keys('2B')
-    assert_line_around_cursor('aaa ', 'b{b}b ccc')
-    input_keys('2B')
-    assert_line_around_cursor('', 'aaa b{b}b ccc')
-  end
-
-  def test_vi_end_big_word
-    input_keys("aaa   b{b}}}b   ccc\C-[0")
-    assert_line_around_cursor('', 'aaa   b{b}}}b   ccc')
-    input_keys('E')
-    assert_line_around_cursor('aa', 'a   b{b}}}b   ccc')
-    input_keys('E')
-    assert_line_around_cursor('aaa   b{b}}}', 'b   ccc')
-    input_keys('E')
-    assert_line_around_cursor('aaa   b{b}}}b   cc', 'c')
-    input_keys('E')
-    assert_line_around_cursor('aaa   b{b}}}b   cc', 'c')
-  end
-
-  def test_ed_quoted_insert
-    input_keys('ab')
-    input_key_by_symbol(:insert_raw_char, char: "\C-a")
-    assert_line_around_cursor("ab\C-a", '')
-  end
-
-  def test_ed_quoted_insert_with_vi_arg
-    input_keys("ab\C-[3")
-    input_key_by_symbol(:insert_raw_char, char: "\C-a")
-    input_keys('4')
-    input_key_by_symbol(:insert_raw_char, char: '1')
-    assert_line_around_cursor("a\C-a\C-a\C-a1111", 'b')
-  end
-
-  def test_vi_replace_char
-    input_keys("abcdef\C-[03l")
-    assert_line_around_cursor('abc', 'def')
-    input_keys('rz')
-    assert_line_around_cursor('abc', 'zef')
-    input_keys('2rx')
-    assert_line_around_cursor('abcxx', 'f')
-  end
-
-  def test_vi_replace_char_with_mbchar
-    input_keys("あいうえお\C-[0l")
-    assert_line_around_cursor('あ', 'いうえお')
-    input_keys('rx')
-    assert_line_around_cursor('あ', 'xうえお')
-    input_keys('l2ry')
-    assert_line_around_cursor('あxyy', 'お')
-  end
-
-  def test_vi_next_char
-    input_keys("abcdef\C-[0")
-    assert_line_around_cursor('', 'abcdef')
-    input_keys('fz')
-    assert_line_around_cursor('', 'abcdef')
-    input_keys('fe')
-    assert_line_around_cursor('abcd', 'ef')
-  end
-
-  def test_vi_to_next_char
-    input_keys("abcdef\C-[0")
-    assert_line_around_cursor('', 'abcdef')
-    input_keys('tz')
-    assert_line_around_cursor('', 'abcdef')
-    input_keys('te')
-    assert_line_around_cursor('abc', 'def')
-  end
-
-  def test_vi_prev_char
-    input_keys("abcdef\C-[")
-    assert_line_around_cursor('abcde', 'f')
-    input_keys('Fz')
-    assert_line_around_cursor('abcde', 'f')
-    input_keys('Fa')
-    assert_line_around_cursor('', 'abcdef')
-  end
-
-  def test_vi_to_prev_char
-    input_keys("abcdef\C-[")
-    assert_line_around_cursor('abcde', 'f')
-    input_keys('Tz')
-    assert_line_around_cursor('abcde', 'f')
-    input_keys('Ta')
-    assert_line_around_cursor('a', 'bcdef')
-  end
-
-  def test_vi_delete_next_char
-    input_keys("abc\C-[h")
-    assert_line_around_cursor('a', 'bc')
-    input_keys('x')
-    assert_line_around_cursor('a', 'c')
-    input_keys('x')
-    assert_line_around_cursor('', 'a')
-    input_keys('x')
-    assert_line_around_cursor('', '')
-    input_keys('x')
-    assert_line_around_cursor('', '')
-  end
-
-  def test_vi_delete_next_char_for_mbchar
-    input_keys("あいう\C-[h")
-    assert_line_around_cursor('あ', 'いう')
-    input_keys('x')
-    assert_line_around_cursor('あ', 'う')
-    input_keys('x')
-    assert_line_around_cursor('', 'あ')
-    input_keys('x')
-    assert_line_around_cursor('', '')
-    input_keys('x')
-    assert_line_around_cursor('', '')
-  end
-
-  def test_vi_delete_next_char_for_mbchar_by_plural_code_points
-    omit_unless_utf8
-    input_keys("か\u3099き\u3099く\u3099\C-[h")
-    assert_line_around_cursor("か\u3099", "き\u3099く\u3099")
-    input_keys('x')
-    assert_line_around_cursor("か\u3099", "く\u3099")
-    input_keys('x')
-    assert_line_around_cursor('', "か\u3099")
-    input_keys('x')
-    assert_line_around_cursor('', '')
-    input_keys('x')
-    assert_line_around_cursor('', '')
-  end
-
-  def test_vi_delete_prev_char
-    input_keys('ab')
-    assert_line_around_cursor('ab', '')
-    input_keys("\C-h")
-    assert_line_around_cursor('a', '')
-  end
-
-  def test_vi_delete_prev_char_for_mbchar
-    input_keys('かき')
-    assert_line_around_cursor('かき', '')
-    input_keys("\C-h")
-    assert_line_around_cursor('か', '')
-  end
-
-  def test_vi_delete_prev_char_for_mbchar_by_plural_code_points
-    omit_unless_utf8
-    input_keys("か\u3099き\u3099")
-    assert_line_around_cursor("か\u3099き\u3099", '')
-    input_keys("\C-h")
-    assert_line_around_cursor("か\u3099", '')
-  end
-
-  def test_ed_delete_prev_char
-    input_keys("abcdefg\C-[h")
-    assert_line_around_cursor('abcde', 'fg')
-    input_keys('X')
-    assert_line_around_cursor('abcd', 'fg')
-    input_keys('3X')
-    assert_line_around_cursor('a', 'fg')
-    input_keys('p')
-    assert_line_around_cursor('afbc', 'dg')
-  end
-
-  def test_ed_delete_prev_word
-    input_keys('abc def{bbb}ccc')
-    assert_line_around_cursor('abc def{bbb}ccc', '')
-    input_keys("\C-w")
-    assert_line_around_cursor('abc def{bbb}', '')
-    input_keys("\C-w")
-    assert_line_around_cursor('abc def{', '')
-    input_keys("\C-w")
-    assert_line_around_cursor('abc ', '')
-    input_keys("\C-w")
-    assert_line_around_cursor('', '')
-  end
-
-  def test_ed_delete_prev_word_for_mbchar
-    input_keys('あいう かきく{さしす}たちつ')
-    assert_line_around_cursor('あいう かきく{さしす}たちつ', '')
-    input_keys("\C-w")
-    assert_line_around_cursor('あいう かきく{さしす}', '')
-    input_keys("\C-w")
-    assert_line_around_cursor('あいう かきく{', '')
-    input_keys("\C-w")
-    assert_line_around_cursor('あいう ', '')
-    input_keys("\C-w")
-    assert_line_around_cursor('', '')
-  end
-
-  def test_ed_delete_prev_word_for_mbchar_by_plural_code_points
-    omit_unless_utf8
-    input_keys("あいう か\u3099き\u3099く\u3099{さしす}たちつ")
-    assert_line_around_cursor("あいう か\u3099き\u3099く\u3099{さしす}たちつ", '')
-    input_keys("\C-w")
-    assert_line_around_cursor("あいう か\u3099き\u3099く\u3099{さしす}", '')
-    input_keys("\C-w")
-    assert_line_around_cursor("あいう か\u3099き\u3099く\u3099{", '')
-    input_keys("\C-w")
-    assert_line_around_cursor('あいう ', '')
-    input_keys("\C-w")
-    assert_line_around_cursor('', '')
-  end
-
-  def test_ed_newline_with_cr
-    input_keys('ab')
-    assert_line_around_cursor('ab', '')
-    refute(@line_editor.finished?)
-    input_keys("\C-m")
-    assert_line_around_cursor('ab', '')
-    assert(@line_editor.finished?)
-  end
-
-  def test_ed_newline_with_lf
-    input_keys('ab')
-    assert_line_around_cursor('ab', '')
-    refute(@line_editor.finished?)
-    input_keys("\C-j")
-    assert_line_around_cursor('ab', '')
-    assert(@line_editor.finished?)
-  end
-
-  def test_vi_list_or_eof
-    input_keys("\C-d") # quit from inputing
-    assert_nil(@line_editor.line)
-    assert(@line_editor.finished?)
-  end
-
-  def test_vi_list_or_eof_with_non_empty_line
-    input_keys('ab')
-    assert_line_around_cursor('ab', '')
-    refute(@line_editor.finished?)
-    input_keys("\C-d")
-    assert_line_around_cursor('ab', '')
-    assert(@line_editor.finished?)
-  end
-
-  def test_completion_journey
-    @line_editor.completion_proc = proc { |word|
-      %w{
-        foo_bar
-        foo_bar_baz
-      }.map { |i|
-        i.encode(@encoding)
-      }
-    }
-    input_keys('foo')
-    assert_line_around_cursor('foo', '')
-    input_keys("\C-n")
-    assert_line_around_cursor('foo_bar', '')
-    input_keys("\C-n")
-    assert_line_around_cursor('foo_bar_baz', '')
-    input_keys("\C-n")
-    assert_line_around_cursor('foo', '')
-    input_keys("\C-n")
-    assert_line_around_cursor('foo_bar', '')
-    input_keys("_\C-n")
-    assert_line_around_cursor('foo_bar_baz', '')
-    input_keys("\C-n")
-    assert_line_around_cursor('foo_bar_', '')
-  end
-
-  def test_completion_journey_reverse
-    @line_editor.completion_proc = proc { |word|
-      %w{
-        foo_bar
-        foo_bar_baz
-      }.map { |i|
-        i.encode(@encoding)
-      }
-    }
-    input_keys('foo')
-    assert_line_around_cursor('foo', '')
-    input_keys("\C-p")
-    assert_line_around_cursor('foo_bar_baz', '')
-    input_keys("\C-p")
-    assert_line_around_cursor('foo_bar', '')
-    input_keys("\C-p")
-    assert_line_around_cursor('foo', '')
-    input_keys("\C-p")
-    assert_line_around_cursor('foo_bar_baz', '')
-    input_keys("\C-h\C-p")
-    assert_line_around_cursor('foo_bar_baz', '')
-    input_keys("\C-p")
-    assert_line_around_cursor('foo_bar_ba', '')
-  end
-
-  def test_completion_journey_in_middle_of_line
-    @line_editor.completion_proc = proc { |word|
-      %w{
-        foo_bar
-        foo_bar_baz
-      }.map { |i|
-        i.encode(@encoding)
-      }
-    }
-    input_keys('abcde fo ABCDE')
-    assert_line_around_cursor('abcde fo ABCDE', '')
-    input_keys("\C-[" + 'h' * 5 + "i\C-n")
-    assert_line_around_cursor('abcde foo_bar', ' ABCDE')
-    input_keys("\C-n")
-    assert_line_around_cursor('abcde foo_bar_baz', ' ABCDE')
-    input_keys("\C-n")
-    assert_line_around_cursor('abcde fo', ' ABCDE')
-    input_keys("\C-n")
-    assert_line_around_cursor('abcde foo_bar', ' ABCDE')
-    input_keys("_\C-n")
-    assert_line_around_cursor('abcde foo_bar_baz', ' ABCDE')
-    input_keys("\C-n")
-    assert_line_around_cursor('abcde foo_bar_', ' ABCDE')
-    input_keys("\C-n")
-    assert_line_around_cursor('abcde foo_bar_baz', ' ABCDE')
-  end
-
-  def test_completion
-    @line_editor.completion_proc = proc { |word|
-      %w{
-        foo_bar
-        foo_bar_baz
-      }.map { |i|
-        i.encode(@encoding)
-      }
-    }
-    input_keys('foo')
-    assert_line_around_cursor('foo', '')
-    input_keys("\C-i")
-    assert_line_around_cursor('foo_bar', '')
-  end
-
-  def test_autocompletion_with_upward_navigation
-    @config.autocompletion = true
-    @line_editor.completion_proc = proc { |word|
-      %w{
-        Readline
-        Regexp
-        RegexpError
-      }.map { |i|
-        i.encode(@encoding)
-      }
-    }
-    input_keys('Re')
-    assert_line_around_cursor('Re', '')
-    input_keys("\C-i")
-    assert_line_around_cursor('Readline', '')
-    input_keys("\C-i")
-    assert_line_around_cursor('Regexp', '')
-    input_key_by_symbol(:completion_journey_up)
-    assert_line_around_cursor('Readline', '')
-  ensure
-    @config.autocompletion = false
-  end
-
-  def test_autocompletion_with_upward_navigation_and_menu_complete_backward
-    @config.autocompletion = true
-    @line_editor.completion_proc = proc { |word|
-      %w{
-        Readline
-        Regexp
-        RegexpError
-      }.map { |i|
-        i.encode(@encoding)
-      }
-    }
-    input_keys('Re')
-    assert_line_around_cursor('Re', '')
-    input_keys("\C-i")
-    assert_line_around_cursor('Readline', '')
-    input_keys("\C-i")
-    assert_line_around_cursor('Regexp', '')
-    input_key_by_symbol(:menu_complete_backward)
-    assert_line_around_cursor('Readline', '')
-  ensure
-    @config.autocompletion = false
-  end
-
-  def test_completion_with_disable_completion
-    @config.disable_completion = true
-    @line_editor.completion_proc = proc { |word|
-      %w{
-        foo_bar
-        foo_bar_baz
-      }.map { |i|
-        i.encode(@encoding)
-      }
-    }
-    input_keys('foo')
-    assert_line_around_cursor('foo', '')
-    input_keys("\C-i")
-    assert_line_around_cursor('foo', '')
-  end
-
-  def test_vi_first_print
-    input_keys("abcde\C-[^")
-    assert_line_around_cursor('', 'abcde')
-    input_keys("0\C-ki")
-    input_keys(" abcde\C-[^")
-    assert_line_around_cursor(' ', 'abcde')
-    input_keys("0\C-ki")
-    input_keys("   abcde  ABCDE  \C-[^")
-    assert_line_around_cursor('   ', 'abcde  ABCDE  ')
-  end
-
-  def test_ed_move_to_beg
-    input_keys("abcde\C-[0")
-    assert_line_around_cursor('', 'abcde')
-    input_keys("0\C-ki")
-    input_keys(" abcde\C-[0")
-    assert_line_around_cursor('', ' abcde')
-    input_keys("0\C-ki")
-    input_keys("   abcde  ABCDE  \C-[0")
-    assert_line_around_cursor('', '   abcde  ABCDE  ')
-  end
-
-  def test_vi_to_column
-    input_keys("a一二三\C-[0")
-    input_keys('1|')
-    assert_line_around_cursor('', 'a一二三')
-    input_keys('2|')
-    assert_line_around_cursor('a', '一二三')
-    input_keys('3|')
-    assert_line_around_cursor('a', '一二三')
-    input_keys('4|')
-    assert_line_around_cursor('a一', '二三')
-    input_keys('9|')
-    assert_line_around_cursor('a一二', '三')
-  end
-
-  def test_vi_delete_meta
-    input_keys("aaa bbb ccc ddd eee\C-[02w")
-    assert_line_around_cursor('aaa bbb ', 'ccc ddd eee')
-    input_keys('dw')
-    assert_line_around_cursor('aaa bbb ', 'ddd eee')
-    input_keys('db')
-    assert_line_around_cursor('aaa ', 'ddd eee')
-  end
-
-  def test_vi_delete_meta_nothing
-    input_keys("foo\C-[0")
-    assert_line_around_cursor('', 'foo')
-    input_keys('dhp')
-    assert_line_around_cursor('', 'foo')
-  end
-
-  def test_vi_delete_meta_with_vi_next_word_at_eol
-    input_keys("foo bar\C-[0w")
-    assert_line_around_cursor('foo ', 'bar')
-    input_keys('w')
-    assert_line_around_cursor('foo ba', 'r')
-    input_keys('0dw')
-    assert_line_around_cursor('', 'bar')
-    input_keys('dw')
-    assert_line_around_cursor('', '')
-  end
-
-  def test_vi_delete_meta_with_vi_next_char
-    input_keys("aaa bbb ccc ___ ddd\C-[02w")
-    assert_line_around_cursor('aaa bbb ', 'ccc ___ ddd')
-    input_keys('df_')
-    assert_line_around_cursor('aaa bbb ', '__ ddd')
-  end
-
-  def test_vi_delete_meta_with_arg
-    input_keys("aaa bbb ccc ddd\C-[03w")
-    assert_line_around_cursor('aaa bbb ccc ', 'ddd')
-    input_keys('2dl')
-    assert_line_around_cursor('aaa bbb ccc ', 'd')
-    input_keys('d2h')
-    assert_line_around_cursor('aaa bbb cc', 'd')
-    input_keys('2d3h')
-    assert_line_around_cursor('aaa ', 'd')
-    input_keys('dd')
-    assert_line_around_cursor('', '')
-  end
-
-  def test_vi_change_meta
-    input_keys("aaa bbb ccc ddd eee\C-[02w")
-    assert_line_around_cursor('aaa bbb ', 'ccc ddd eee')
-    input_keys('cwaiueo')
-    assert_line_around_cursor('aaa bbb aiueo', ' ddd eee')
-    input_keys("\C-[")
-    assert_line_around_cursor('aaa bbb aiue', 'o ddd eee')
-    input_keys('cb')
-    assert_line_around_cursor('aaa bbb ', 'o ddd eee')
-  end
-
-  def test_vi_change_meta_with_vi_next_word
-    input_keys("foo  bar  baz\C-[0w")
-    assert_line_around_cursor('foo  ', 'bar  baz')
-    input_keys('cwhoge')
-    assert_line_around_cursor('foo  hoge', '  baz')
-    input_keys("\C-[")
-    assert_line_around_cursor('foo  hog', 'e  baz')
-  end
-
-  def test_vi_waiting_operator_with_waiting_proc
-    input_keys("foo foo foo foo foo\C-[0")
-    input_keys('2d3fo')
-    assert_line_around_cursor('', ' foo foo')
-    input_keys('fo')
-    assert_line_around_cursor(' f', 'oo foo')
-  end
-
-  def test_waiting_operator_arg_including_zero
-    input_keys("a111111111111222222222222\C-[0")
-    input_keys('10df1')
-    assert_line_around_cursor('', '11222222222222')
-    input_keys('d10f2')
-    assert_line_around_cursor('', '22')
-  end
-
-  def test_vi_waiting_operator_cancel
-    input_keys("aaa bbb ccc\C-[02w")
-    assert_line_around_cursor('aaa bbb ', 'ccc')
-    # dc dy should cancel delete_meta
-    input_keys('dch')
-    input_keys('dyh')
-    # cd cy should cancel change_meta
-    input_keys('cdh')
-    input_keys('cyh')
-    # yd yc should cancel yank_meta
-    # P should not paste yanked text because yank_meta is canceled
-    input_keys('ydhP')
-    input_keys('ychP')
-    assert_line_around_cursor('aa', 'a bbb ccc')
-  end
-
-  def test_cancel_waiting_with_symbol_key
-    input_keys("aaa bbb lll\C-[0")
-    assert_line_around_cursor('', 'aaa bbb lll')
-    # ed_next_char should move cursor right and cancel vi_next_char
-    input_keys('f')
-    input_key_by_symbol(:ed_next_char, csi: true)
-    input_keys('l')
-    assert_line_around_cursor('aa', 'a bbb lll')
-    # vi_delete_meta + ed_next_char should delete character
-    input_keys('d')
-    input_key_by_symbol(:ed_next_char, csi: true)
-    input_keys('l')
-    assert_line_around_cursor('aa ', 'bbb lll')
-  end
-
-  def test_unimplemented_vi_command_should_be_no_op
-    input_keys("abc\C-[h")
-    assert_line_around_cursor('a', 'bc')
-    input_keys('@')
-    assert_line_around_cursor('a', 'bc')
-  end
-
-  def test_vi_yank
-    input_keys("foo bar\C-[2h")
-    assert_line_around_cursor('foo ', 'bar')
-    input_keys('y3l')
-    assert_line_around_cursor('foo ', 'bar')
-    input_keys('P')
-    assert_line_around_cursor('foo ba', 'rbar')
-    input_keys('3h3yhP')
-    assert_line_around_cursor('foofo', 'o barbar')
-    input_keys('yyP')
-    assert_line_around_cursor('foofofoofoo barba', 'ro barbar')
-  end
-
-  def test_vi_yank_nothing
-    input_keys("foo\C-[0")
-    assert_line_around_cursor('', 'foo')
-    input_keys('yhp')
-    assert_line_around_cursor('', 'foo')
-  end
-
-  def test_vi_end_word_with_operator
-    input_keys("foo bar\C-[0")
-    assert_line_around_cursor('', 'foo bar')
-    input_keys('de')
-    assert_line_around_cursor('', ' bar')
-    input_keys('de')
-    assert_line_around_cursor('', '')
-    input_keys('de')
-    assert_line_around_cursor('', '')
-  end
-
-  def test_vi_end_big_word_with_operator
-    input_keys("aaa   b{b}}}b\C-[0")
-    assert_line_around_cursor('', 'aaa   b{b}}}b')
-    input_keys('dE')
-    assert_line_around_cursor('', '   b{b}}}b')
-    input_keys('dE')
-    assert_line_around_cursor('', '')
-    input_keys('dE')
-    assert_line_around_cursor('', '')
-  end
-
-  def test_vi_next_char_with_operator
-    input_keys("foo bar\C-[0")
-    assert_line_around_cursor('', 'foo bar')
-    input_keys('df ')
-    assert_line_around_cursor('', 'bar')
-  end
-
-  def test_ed_delete_next_char_at_eol
-    input_keys('"あ"')
-    assert_line_around_cursor('"あ"', '')
-    input_keys("\C-[")
-    assert_line_around_cursor('"あ', '"')
-    input_keys('xa"')
-    assert_line_around_cursor('"あ"', '')
-  end
-
-  def test_vi_kill_line_prev
-    input_keys("\C-u")
-    assert_line_around_cursor('', '')
-    input_keys('abc')
-    assert_line_around_cursor('abc', '')
-    input_keys("\C-u")
-    assert_line_around_cursor('', '')
-    input_keys('abc')
-    input_keys("\C-[\C-u")
-    assert_line_around_cursor('', 'c')
-    input_keys("\C-u")
-    assert_line_around_cursor('', 'c')
-  end
-
-  def test_vi_change_to_eol
-    input_keys("abcdef\C-[2hC")
-    assert_line_around_cursor('abc', '')
-    input_keys("\C-[0C")
-    assert_line_around_cursor('', '')
-    assert_equal(:vi_insert, editing_mode_label)
-  end
-
-  def test_vi_motion_operators
-    assert_equal(:vi_insert, editing_mode_label)
-
-    assert_nothing_raised do
-      input_keys("test = { foo: bar }\C-[BBBldt}b")
-    end
-  end
-
-  def test_emacs_editing_mode
-    @line_editor.__send__(:emacs_editing_mode, nil)
-    assert(@config.editing_mode_is?(:emacs))
-  end
-end
diff --git a/test/mri/reline/test_key_stroke.rb b/test/mri/reline/test_key_stroke.rb
deleted file mode 100644
index fb2cb1c8b82..00000000000
--- a/test/mri/reline/test_key_stroke.rb
+++ /dev/null
@@ -1,111 +0,0 @@
-require_relative 'helper'
-
-class Reline::KeyStroke::Test < Reline::TestCase
-  def encoding
-    Reline.core.encoding
-  end
-
-  def test_match_status
-    config = Reline::Config.new
-    {
-      'a' => 'xx',
-      'ab' => 'y',
-      'abc' => 'z',
-      'x' => 'rr'
-    }.each_pair do |key, func|
-      config.add_default_key_binding(key.bytes, func.bytes)
-    end
-    stroke = Reline::KeyStroke.new(config, encoding)
-    assert_equal(Reline::KeyStroke::MATCHING_MATCHED, stroke.match_status("a".bytes))
-    assert_equal(Reline::KeyStroke::MATCHING_MATCHED, stroke.match_status("ab".bytes))
-    assert_equal(Reline::KeyStroke::MATCHED, stroke.match_status("abc".bytes))
-    assert_equal(Reline::KeyStroke::UNMATCHED, stroke.match_status("abz".bytes))
-    assert_equal(Reline::KeyStroke::UNMATCHED, stroke.match_status("abcx".bytes))
-    assert_equal(Reline::KeyStroke::UNMATCHED, stroke.match_status("aa".bytes))
-    assert_equal(Reline::KeyStroke::MATCHED, stroke.match_status("x".bytes))
-    assert_equal(Reline::KeyStroke::UNMATCHED, stroke.match_status("xa".bytes))
-  end
-
-  def test_match_unknown
-    config = Reline::Config.new
-    config.add_default_key_binding("\e[9abc".bytes, 'x')
-    stroke = Reline::KeyStroke.new(config, encoding)
-    sequences = [
-      "\e[9abc",
-      "\e[9d",
-      "\e[A", # Up
-      "\e[1;1R", # Cursor position report
-      "\e[15~", # F5
-      "\eOP", # F1
-      "\e\e[A", # Option+Up
-      "\eX",
-      "\e\eX"
-    ]
-    sequences.each do |seq|
-      assert_equal(Reline::KeyStroke::MATCHED, stroke.match_status(seq.bytes))
-      assert_equal(Reline::KeyStroke::UNMATCHED, stroke.match_status(seq.bytes + [32]))
-      (2...seq.size).each do |i|
-        assert_equal(Reline::KeyStroke::MATCHING, stroke.match_status(seq.bytes.take(i)))
-      end
-    end
-  end
-
-  def test_expand
-    config = Reline::Config.new
-    {
-      'abc' => 'AB',
-      'ab' => "1\C-a"
-    }.each_pair do |key, func|
-      config.add_default_key_binding(key.bytes, func.bytes)
-    end
-    stroke = Reline::KeyStroke.new(config, encoding)
-    assert_equal([[Reline::Key.new('A', :ed_insert, false), Reline::Key.new('B', :ed_insert, false)], 'de'.bytes], stroke.expand('abcde'.bytes))
-    assert_equal([[Reline::Key.new('1', :ed_digit, false), Reline::Key.new("\C-a", :ed_move_to_beg, false)], 'de'.bytes], stroke.expand('abde'.bytes))
-    # CSI sequence
-    assert_equal([[], 'bc'.bytes], stroke.expand("\e[1;2;3;4;5abc".bytes))
-    assert_equal([[], 'BC'.bytes], stroke.expand("\e\e[ABC".bytes))
-    # SS3 sequence
-    assert_equal([[], 'QR'.bytes], stroke.expand("\eOPQR".bytes))
-  end
-
-  def test_oneshot_key_bindings
-    config = Reline::Config.new
-    {
-      'abc'.bytes => '123',
-      # IRB version <= 1.13.1 wrongly uses Reline::Key with wrong argument. It should be ignored without error.
-      [Reline::Key.new(nil, 0xE4, true)] => '012',
-      "\eda".bytes => 'abc', # Alt+d a
-      [195, 164] => 'def'
-    }.each_pair do |key, func|
-      config.add_oneshot_key_binding(key, func.bytes)
-    end
-    stroke = Reline::KeyStroke.new(config, encoding)
-    assert_equal(Reline::KeyStroke::UNMATCHED, stroke.match_status('zzz'.bytes))
-    assert_equal(Reline::KeyStroke::MATCHED, stroke.match_status('abc'.bytes))
-    assert_equal(Reline::KeyStroke::UNMATCHED, stroke.match_status('da'.bytes))
-    assert_equal(Reline::KeyStroke::MATCHED, stroke.match_status("\eda".bytes))
-    assert_equal(Reline::KeyStroke::UNMATCHED, stroke.match_status(" \eda".bytes))
-    assert_equal(Reline::KeyStroke::MATCHED, stroke.match_status([195, 164]))
-  end
-
-  def test_multibyte_matching
-    begin
-      char = 'あ'.encode(encoding)
-    rescue Encoding::UndefinedConversionError
-      omit
-    end
-    config = Reline::Config.new
-    stroke = Reline::KeyStroke.new(config, encoding)
-    key = Reline::Key.new(char, :ed_insert, false)
-    bytes = char.bytes
-    assert_equal(Reline::KeyStroke::MATCHED, stroke.match_status(bytes))
-    assert_equal([[key], []], stroke.expand(bytes))
-    assert_equal(Reline::KeyStroke::UNMATCHED, stroke.match_status(bytes * 2))
-    assert_equal([[key], bytes], stroke.expand(bytes * 2))
-    (1...bytes.size).each do |i|
-      partial_bytes = bytes.take(i)
-      assert_equal(Reline::KeyStroke::MATCHING_MATCHED, stroke.match_status(partial_bytes))
-      assert_equal([[], []], stroke.expand(partial_bytes))
-    end
-  end
-end
diff --git a/test/mri/reline/test_kill_ring.rb b/test/mri/reline/test_kill_ring.rb
deleted file mode 100644
index 9f6e0c3e74e..00000000000
--- a/test/mri/reline/test_kill_ring.rb
+++ /dev/null
@@ -1,268 +0,0 @@
-require_relative 'helper'
-
-class Reline::KillRing::Test < Reline::TestCase
-  def setup
-    @prompt = '> '
-    @kill_ring = Reline::KillRing.new
-  end
-
-  def test_append_one
-    assert_equal(Reline::KillRing::State::FRESH, @kill_ring.instance_variable_get(:@state))
-    @kill_ring.append('a')
-    assert_equal(Reline::KillRing::State::CONTINUED, @kill_ring.instance_variable_get(:@state))
-    @kill_ring.process
-    assert_equal(Reline::KillRing::State::PROCESSED, @kill_ring.instance_variable_get(:@state))
-    assert_equal('a', @kill_ring.yank)
-    assert_equal(Reline::KillRing::State::YANK, @kill_ring.instance_variable_get(:@state))
-    assert_equal('a', @kill_ring.yank)
-    assert_equal(Reline::KillRing::State::YANK, @kill_ring.instance_variable_get(:@state))
-    assert_equal(['a', 'a'], @kill_ring.yank_pop)
-    assert_equal(Reline::KillRing::State::YANK, @kill_ring.instance_variable_get(:@state))
-    assert_equal(['a', 'a'], @kill_ring.yank_pop)
-    assert_equal(Reline::KillRing::State::YANK, @kill_ring.instance_variable_get(:@state))
-  end
-
-  def test_append_two
-    assert_equal(Reline::KillRing::State::FRESH, @kill_ring.instance_variable_get(:@state))
-    @kill_ring.append('a')
-    assert_equal(Reline::KillRing::State::CONTINUED, @kill_ring.instance_variable_get(:@state))
-    @kill_ring.process
-    assert_equal(Reline::KillRing::State::PROCESSED, @kill_ring.instance_variable_get(:@state))
-    @kill_ring.process
-    assert_equal(Reline::KillRing::State::FRESH, @kill_ring.instance_variable_get(:@state))
-    @kill_ring.append('b')
-    assert_equal(Reline::KillRing::State::CONTINUED, @kill_ring.instance_variable_get(:@state))
-    @kill_ring.process
-    assert_equal(Reline::KillRing::State::PROCESSED, @kill_ring.instance_variable_get(:@state))
-    assert_equal('b', @kill_ring.yank)
-    assert_equal(Reline::KillRing::State::YANK, @kill_ring.instance_variable_get(:@state))
-    assert_equal('b', @kill_ring.yank)
-    assert_equal(Reline::KillRing::State::YANK, @kill_ring.instance_variable_get(:@state))
-    assert_equal(['a', 'b'], @kill_ring.yank_pop)
-    assert_equal(Reline::KillRing::State::YANK, @kill_ring.instance_variable_get(:@state))
-    assert_equal(['b', 'a'], @kill_ring.yank_pop)
-    assert_equal(Reline::KillRing::State::YANK, @kill_ring.instance_variable_get(:@state))
-  end
-
-  def test_append_three
-    assert_equal(Reline::KillRing::State::FRESH, @kill_ring.instance_variable_get(:@state))
-    @kill_ring.append('a')
-    assert_equal(Reline::KillRing::State::CONTINUED, @kill_ring.instance_variable_get(:@state))
-    @kill_ring.process
-    assert_equal(Reline::KillRing::State::PROCESSED, @kill_ring.instance_variable_get(:@state))
-    @kill_ring.process
-    assert_equal(Reline::KillRing::State::FRESH, @kill_ring.instance_variable_get(:@state))
-    @kill_ring.append('b')
-    assert_equal(Reline::KillRing::State::CONTINUED, @kill_ring.instance_variable_get(:@state))
-    @kill_ring.process
-    assert_equal(Reline::KillRing::State::PROCESSED, @kill_ring.instance_variable_get(:@state))
-    @kill_ring.process
-    assert_equal(Reline::KillRing::State::FRESH, @kill_ring.instance_variable_get(:@state))
-    @kill_ring.append('c')
-    assert_equal(Reline::KillRing::State::CONTINUED, @kill_ring.instance_variable_get(:@state))
-    @kill_ring.process
-    assert_equal(Reline::KillRing::State::PROCESSED, @kill_ring.instance_variable_get(:@state))
-    assert_equal('c', @kill_ring.yank)
-    assert_equal(Reline::KillRing::State::YANK, @kill_ring.instance_variable_get(:@state))
-    assert_equal('c', @kill_ring.yank)
-    assert_equal(Reline::KillRing::State::YANK, @kill_ring.instance_variable_get(:@state))
-    assert_equal(['b', 'c'], @kill_ring.yank_pop)
-    assert_equal(Reline::KillRing::State::YANK, @kill_ring.instance_variable_get(:@state))
-    assert_equal(['a', 'b'], @kill_ring.yank_pop)
-    assert_equal(Reline::KillRing::State::YANK, @kill_ring.instance_variable_get(:@state))
-    assert_equal(['c', 'a'], @kill_ring.yank_pop)
-    assert_equal(Reline::KillRing::State::YANK, @kill_ring.instance_variable_get(:@state))
-  end
-
-  def test_append_three_with_max_two
-    @kill_ring = Reline::KillRing.new(2)
-    assert_equal(Reline::KillRing::State::FRESH, @kill_ring.instance_variable_get(:@state))
-    @kill_ring.append('a')
-    assert_equal(Reline::KillRing::State::CONTINUED, @kill_ring.instance_variable_get(:@state))
-    @kill_ring.process
-    assert_equal(Reline::KillRing::State::PROCESSED, @kill_ring.instance_variable_get(:@state))
-    @kill_ring.process
-    assert_equal(Reline::KillRing::State::FRESH, @kill_ring.instance_variable_get(:@state))
-    @kill_ring.append('b')
-    assert_equal(Reline::KillRing::State::CONTINUED, @kill_ring.instance_variable_get(:@state))
-    @kill_ring.process
-    assert_equal(Reline::KillRing::State::PROCESSED, @kill_ring.instance_variable_get(:@state))
-    @kill_ring.process
-    assert_equal(Reline::KillRing::State::FRESH, @kill_ring.instance_variable_get(:@state))
-    @kill_ring.append('c')
-    assert_equal(Reline::KillRing::State::CONTINUED, @kill_ring.instance_variable_get(:@state))
-    @kill_ring.process
-    assert_equal(Reline::KillRing::State::PROCESSED, @kill_ring.instance_variable_get(:@state))
-    assert_equal('c', @kill_ring.yank)
-    assert_equal(Reline::KillRing::State::YANK, @kill_ring.instance_variable_get(:@state))
-    assert_equal('c', @kill_ring.yank)
-    assert_equal(Reline::KillRing::State::YANK, @kill_ring.instance_variable_get(:@state))
-    assert_equal(['b', 'c'], @kill_ring.yank_pop)
-    assert_equal(Reline::KillRing::State::YANK, @kill_ring.instance_variable_get(:@state))
-    assert_equal(['c', 'b'], @kill_ring.yank_pop)
-    assert_equal(Reline::KillRing::State::YANK, @kill_ring.instance_variable_get(:@state))
-    assert_equal(['b', 'c'], @kill_ring.yank_pop)
-    assert_equal(Reline::KillRing::State::YANK, @kill_ring.instance_variable_get(:@state))
-  end
-
-  def test_append_four_with_max_two
-    @kill_ring = Reline::KillRing.new(2)
-    assert_equal(Reline::KillRing::State::FRESH, @kill_ring.instance_variable_get(:@state))
-    @kill_ring.append('a')
-    assert_equal(Reline::KillRing::State::CONTINUED, @kill_ring.instance_variable_get(:@state))
-    @kill_ring.process
-    assert_equal(Reline::KillRing::State::PROCESSED, @kill_ring.instance_variable_get(:@state))
-    @kill_ring.process
-    assert_equal(Reline::KillRing::State::FRESH, @kill_ring.instance_variable_get(:@state))
-    @kill_ring.append('b')
-    assert_equal(Reline::KillRing::State::CONTINUED, @kill_ring.instance_variable_get(:@state))
-    @kill_ring.process
-    assert_equal(Reline::KillRing::State::PROCESSED, @kill_ring.instance_variable_get(:@state))
-    @kill_ring.process
-    assert_equal(Reline::KillRing::State::FRESH, @kill_ring.instance_variable_get(:@state))
-    @kill_ring.append('c')
-    assert_equal(Reline::KillRing::State::CONTINUED, @kill_ring.instance_variable_get(:@state))
-    @kill_ring.process
-    assert_equal(Reline::KillRing::State::PROCESSED, @kill_ring.instance_variable_get(:@state))
-    @kill_ring.process
-    assert_equal(Reline::KillRing::State::FRESH, @kill_ring.instance_variable_get(:@state))
-    @kill_ring.append('d')
-    assert_equal(Reline::KillRing::State::CONTINUED, @kill_ring.instance_variable_get(:@state))
-    @kill_ring.process
-    assert_equal(Reline::KillRing::State::PROCESSED, @kill_ring.instance_variable_get(:@state))
-    assert_equal('d', @kill_ring.yank)
-    assert_equal(Reline::KillRing::State::YANK, @kill_ring.instance_variable_get(:@state))
-    assert_equal('d', @kill_ring.yank)
-    assert_equal(Reline::KillRing::State::YANK, @kill_ring.instance_variable_get(:@state))
-    assert_equal(['c', 'd'], @kill_ring.yank_pop)
-    assert_equal(Reline::KillRing::State::YANK, @kill_ring.instance_variable_get(:@state))
-    assert_equal(['d', 'c'], @kill_ring.yank_pop)
-    assert_equal(Reline::KillRing::State::YANK, @kill_ring.instance_variable_get(:@state))
-    assert_equal(['c', 'd'], @kill_ring.yank_pop)
-    assert_equal(Reline::KillRing::State::YANK, @kill_ring.instance_variable_get(:@state))
-  end
-
-  def test_append_after
-    assert_equal(Reline::KillRing::State::FRESH, @kill_ring.instance_variable_get(:@state))
-    @kill_ring.append('a')
-    assert_equal(Reline::KillRing::State::CONTINUED, @kill_ring.instance_variable_get(:@state))
-    @kill_ring.process
-    assert_equal(Reline::KillRing::State::PROCESSED, @kill_ring.instance_variable_get(:@state))
-    @kill_ring.append('b')
-    assert_equal(Reline::KillRing::State::CONTINUED, @kill_ring.instance_variable_get(:@state))
-    @kill_ring.process
-    assert_equal(Reline::KillRing::State::PROCESSED, @kill_ring.instance_variable_get(:@state))
-    assert_equal('ab', @kill_ring.yank)
-    assert_equal(Reline::KillRing::State::YANK, @kill_ring.instance_variable_get(:@state))
-    assert_equal('ab', @kill_ring.yank)
-    assert_equal(Reline::KillRing::State::YANK, @kill_ring.instance_variable_get(:@state))
-    assert_equal(['ab', 'ab'], @kill_ring.yank_pop)
-    assert_equal(Reline::KillRing::State::YANK, @kill_ring.instance_variable_get(:@state))
-    assert_equal(['ab', 'ab'], @kill_ring.yank_pop)
-    assert_equal(Reline::KillRing::State::YANK, @kill_ring.instance_variable_get(:@state))
-  end
-
-  def test_append_before
-    assert_equal(Reline::KillRing::State::FRESH, @kill_ring.instance_variable_get(:@state))
-    @kill_ring.append('a')
-    assert_equal(Reline::KillRing::State::CONTINUED, @kill_ring.instance_variable_get(:@state))
-    @kill_ring.process
-    assert_equal(Reline::KillRing::State::PROCESSED, @kill_ring.instance_variable_get(:@state))
-    @kill_ring.append('b', true)
-    assert_equal(Reline::KillRing::State::CONTINUED, @kill_ring.instance_variable_get(:@state))
-    @kill_ring.process
-    assert_equal(Reline::KillRing::State::PROCESSED, @kill_ring.instance_variable_get(:@state))
-    assert_equal('ba', @kill_ring.yank)
-    assert_equal(Reline::KillRing::State::YANK, @kill_ring.instance_variable_get(:@state))
-    assert_equal('ba', @kill_ring.yank)
-    assert_equal(Reline::KillRing::State::YANK, @kill_ring.instance_variable_get(:@state))
-    assert_equal(['ba', 'ba'], @kill_ring.yank_pop)
-    assert_equal(Reline::KillRing::State::YANK, @kill_ring.instance_variable_get(:@state))
-    assert_equal(['ba', 'ba'], @kill_ring.yank_pop)
-    assert_equal(Reline::KillRing::State::YANK, @kill_ring.instance_variable_get(:@state))
-  end
-
-  def test_append_chain_two
-    assert_equal(Reline::KillRing::State::FRESH, @kill_ring.instance_variable_get(:@state))
-    @kill_ring.append('a')
-    assert_equal(Reline::KillRing::State::CONTINUED, @kill_ring.instance_variable_get(:@state))
-    @kill_ring.process
-    assert_equal(Reline::KillRing::State::PROCESSED, @kill_ring.instance_variable_get(:@state))
-    @kill_ring.append('b')
-    assert_equal(Reline::KillRing::State::CONTINUED, @kill_ring.instance_variable_get(:@state))
-    @kill_ring.process
-    assert_equal(Reline::KillRing::State::PROCESSED, @kill_ring.instance_variable_get(:@state))
-    @kill_ring.process
-    assert_equal(Reline::KillRing::State::FRESH, @kill_ring.instance_variable_get(:@state))
-    @kill_ring.append('c')
-    assert_equal(Reline::KillRing::State::CONTINUED, @kill_ring.instance_variable_get(:@state))
-    @kill_ring.process
-    assert_equal(Reline::KillRing::State::PROCESSED, @kill_ring.instance_variable_get(:@state))
-    @kill_ring.append('d')
-    assert_equal(Reline::KillRing::State::CONTINUED, @kill_ring.instance_variable_get(:@state))
-    @kill_ring.process
-    assert_equal(Reline::KillRing::State::PROCESSED, @kill_ring.instance_variable_get(:@state))
-    assert_equal('cd', @kill_ring.yank)
-    assert_equal(Reline::KillRing::State::YANK, @kill_ring.instance_variable_get(:@state))
-    assert_equal('cd', @kill_ring.yank)
-    assert_equal(Reline::KillRing::State::YANK, @kill_ring.instance_variable_get(:@state))
-    assert_equal(['ab', 'cd'], @kill_ring.yank_pop)
-    assert_equal(Reline::KillRing::State::YANK, @kill_ring.instance_variable_get(:@state))
-    assert_equal(['cd', 'ab'], @kill_ring.yank_pop)
-    assert_equal(Reline::KillRing::State::YANK, @kill_ring.instance_variable_get(:@state))
-  end
-
-  def test_append_complex_chain
-    assert_equal(Reline::KillRing::State::FRESH, @kill_ring.instance_variable_get(:@state))
-    @kill_ring.append('c')
-    assert_equal(Reline::KillRing::State::CONTINUED, @kill_ring.instance_variable_get(:@state))
-    @kill_ring.process
-    assert_equal(Reline::KillRing::State::PROCESSED, @kill_ring.instance_variable_get(:@state))
-    @kill_ring.append('d')
-    assert_equal(Reline::KillRing::State::CONTINUED, @kill_ring.instance_variable_get(:@state))
-    @kill_ring.process
-    assert_equal(Reline::KillRing::State::PROCESSED, @kill_ring.instance_variable_get(:@state))
-    @kill_ring.append('b', true)
-    assert_equal(Reline::KillRing::State::CONTINUED, @kill_ring.instance_variable_get(:@state))
-    @kill_ring.process
-    assert_equal(Reline::KillRing::State::PROCESSED, @kill_ring.instance_variable_get(:@state))
-    @kill_ring.append('e')
-    assert_equal(Reline::KillRing::State::CONTINUED, @kill_ring.instance_variable_get(:@state))
-    @kill_ring.process
-    assert_equal(Reline::KillRing::State::PROCESSED, @kill_ring.instance_variable_get(:@state))
-    @kill_ring.append('a', true)
-    assert_equal(Reline::KillRing::State::CONTINUED, @kill_ring.instance_variable_get(:@state))
-    @kill_ring.process
-    assert_equal(Reline::KillRing::State::PROCESSED, @kill_ring.instance_variable_get(:@state))
-    @kill_ring.process
-    assert_equal(Reline::KillRing::State::FRESH, @kill_ring.instance_variable_get(:@state))
-    @kill_ring.append('A')
-    assert_equal(Reline::KillRing::State::CONTINUED, @kill_ring.instance_variable_get(:@state))
-    @kill_ring.process
-    assert_equal(Reline::KillRing::State::PROCESSED, @kill_ring.instance_variable_get(:@state))
-    @kill_ring.append('B')
-    assert_equal(Reline::KillRing::State::CONTINUED, @kill_ring.instance_variable_get(:@state))
-    @kill_ring.process
-    assert_equal(Reline::KillRing::State::PROCESSED, @kill_ring.instance_variable_get(:@state))
-    assert_equal('AB', @kill_ring.yank)
-    assert_equal(Reline::KillRing::State::YANK, @kill_ring.instance_variable_get(:@state))
-    assert_equal('AB', @kill_ring.yank)
-    assert_equal(Reline::KillRing::State::YANK, @kill_ring.instance_variable_get(:@state))
-    assert_equal(['abcde', 'AB'], @kill_ring.yank_pop)
-    assert_equal(Reline::KillRing::State::YANK, @kill_ring.instance_variable_get(:@state))
-    assert_equal(['AB', 'abcde'], @kill_ring.yank_pop)
-    assert_equal(Reline::KillRing::State::YANK, @kill_ring.instance_variable_get(:@state))
-  end
-
-  def test_enumerable
-    @kill_ring.append('a')
-    @kill_ring.process
-    @kill_ring.process
-    @kill_ring.append('b')
-    @kill_ring.process
-    @kill_ring.process
-    @kill_ring.append('c')
-    @kill_ring.process
-    assert_equal(%w{c b a}, @kill_ring.to_a)
-  end
-end
diff --git a/test/mri/reline/test_line_editor.rb b/test/mri/reline/test_line_editor.rb
deleted file mode 100644
index 28fcbfa6df8..00000000000
--- a/test/mri/reline/test_line_editor.rb
+++ /dev/null
@@ -1,271 +0,0 @@
-require_relative 'helper'
-require 'reline/line_editor'
-require 'stringio'
-
-class Reline::LineEditor
-
-  class CompletionBlockTest < Reline::TestCase
-    def setup
-      @original_quote_characters = Reline.completer_quote_characters
-      @original_word_break_characters = Reline.completer_word_break_characters
-      @line_editor = Reline::LineEditor.new(nil)
-    end
-
-    def retrieve_completion_block(lines, line_index, byte_pointer)
-      @line_editor.instance_variable_set(:@buffer_of_lines, lines)
-      @line_editor.instance_variable_set(:@line_index, line_index)
-      @line_editor.instance_variable_set(:@byte_pointer, byte_pointer)
-      @line_editor.retrieve_completion_block
-    end
-
-    def retrieve_completion_quote(line)
-      _, _, _, quote = retrieve_completion_block([line], 0, line.bytesize)
-      quote
-    end
-
-    def teardown
-      Reline.completer_quote_characters = @original_quote_characters
-      Reline.completer_word_break_characters = @original_word_break_characters
-    end
-
-    def test_retrieve_completion_block
-      Reline.completer_word_break_characters = ' ([{'
-      Reline.completer_quote_characters = ''
-      assert_equal(['', '', 'foo', nil], retrieve_completion_block(['foo'], 0, 0))
-      assert_equal(['', 'f', 'oo', nil], retrieve_completion_block(['foo'], 0, 1))
-      assert_equal(['foo ', 'ba', 'r baz', nil], retrieve_completion_block(['foo bar baz'], 0, 6))
-      assert_equal(['foo([', 'b', 'ar])baz', nil], retrieve_completion_block(['foo([bar])baz'], 0, 6))
-      assert_equal(['foo([{', '', '}])baz', nil], retrieve_completion_block(['foo([{}])baz'], 0, 6))
-      assert_equal(["abc\nfoo ", 'ba', "r baz\ndef", nil], retrieve_completion_block(['abc', 'foo bar baz', 'def'], 1, 6))
-    end
-
-    def test_retrieve_completion_block_with_quote_characters
-      Reline.completer_word_break_characters = ' ([{'
-      Reline.completer_quote_characters = ''
-      assert_equal(['"" ', '"wo', 'rd', nil], retrieve_completion_block(['"" "word'], 0, 6))
-      Reline.completer_quote_characters = '"'
-      assert_equal(['"" "', 'wo', 'rd', nil], retrieve_completion_block(['"" "word'], 0, 6))
-    end
-
-    def test_retrieve_completion_quote
-      Reline.completer_quote_characters = '"\''
-      assert_equal('"', retrieve_completion_quote('"\''))
-      assert_equal(nil, retrieve_completion_quote('""'))
-      assert_equal("'", retrieve_completion_quote('""\'"'))
-      assert_equal(nil, retrieve_completion_quote('""\'\''))
-      assert_equal('"', retrieve_completion_quote('"\\"'))
-      assert_equal(nil, retrieve_completion_quote('"\\""'))
-      assert_equal(nil, retrieve_completion_quote('"\\\\"'))
-    end
-  end
-
-  class CursorPositionTest < Reline::TestCase
-    def setup
-      @line_editor = Reline::LineEditor.new(nil)
-      @line_editor.instance_variable_set(:@config, Reline::Config.new)
-    end
-
-    def test_cursor_position_with_escaped_input
-      @line_editor.instance_variable_set(:@screen_size, [4, 16])
-      @line_editor.instance_variable_set(:@prompt, "\e[1mprompt\e[0m> ")
-      @line_editor.instance_variable_set(:@buffer_of_lines, ["\e[1m\0\1\2\3\4\5\6\7abcd"])
-      @line_editor.instance_variable_set(:@line_index, 0)
-      # prompt> ^[[1m^@^
-      # A^B^C^D^E^F^Gabc
-      # d
-      @line_editor.instance_variable_set(:@byte_pointer, 0)
-      assert_equal [8, 0], @line_editor.wrapped_cursor_position
-      @line_editor.instance_variable_set(:@byte_pointer, 5)
-      assert_equal [15, 0], @line_editor.wrapped_cursor_position
-      @line_editor.instance_variable_set(:@byte_pointer, 6)
-      assert_equal [1, 1], @line_editor.wrapped_cursor_position
-      @line_editor.instance_variable_set(:@byte_pointer, 14)
-      assert_equal [15, 1], @line_editor.wrapped_cursor_position
-      @line_editor.instance_variable_set(:@byte_pointer, 15)
-      assert_equal [0, 2], @line_editor.wrapped_cursor_position
-      @line_editor.instance_variable_set(:@byte_pointer, 16)
-      assert_equal [1, 2], @line_editor.wrapped_cursor_position
-    end
-  end
-
-  class RenderLineDifferentialTest < Reline::TestCase
-    class TestIO < Reline::IO
-      def write(string)
-        @output << string
-      end
-
-      def move_cursor_column(col)
-        @output << "[COL_#{col}]"
-      end
-
-      def erase_after_cursor
-        @output << '[ERASE]'
-      end
-    end
-
-    def setup
-      verbose, $VERBOSE = $VERBOSE, nil
-      @line_editor = Reline::LineEditor.new(nil)
-      @original_iogate = Reline::IOGate
-      @output = StringIO.new
-      @line_editor.instance_variable_set(:@screen_size, [24, 80])
-      Reline.send(:remove_const, :IOGate)
-      Reline.const_set(:IOGate, TestIO.new)
-      Reline::IOGate.instance_variable_set(:@output, @output)
-    ensure
-      $VERBOSE = verbose
-    end
-
-    def assert_output(expected)
-      @output.reopen(+'')
-      yield
-      actual = @output.string
-      assert_equal(expected, actual.gsub("\e[0m", ''))
-    end
-
-    def teardown
-      Reline.send(:remove_const, :IOGate)
-      Reline.const_set(:IOGate, @original_iogate)
-    end
-
-    def test_line_increase_decrease
-      assert_output '[COL_0]bb' do
-        @line_editor.render_line_differential([[0, 1, 'a']], [[0, 2, 'bb']])
-      end
-
-      assert_output '[COL_0]b[COL_1][ERASE]' do
-        @line_editor.render_line_differential([[0, 2, 'aa']], [[0, 1, 'b']])
-      end
-    end
-
-    def test_dialog_appear_disappear
-      assert_output '[COL_3]dialog' do
-        @line_editor.render_line_differential([[0, 1, 'a']], [[0, 1, 'a'], [3, 6, 'dialog']])
-      end
-
-      assert_output '[COL_3]dialog' do
-        @line_editor.render_line_differential([[0, 10, 'a' * 10]], [[0, 10, 'a' * 10], [3, 6, 'dialog']])
-      end
-
-      assert_output '[COL_1][ERASE]' do
-        @line_editor.render_line_differential([[0, 1, 'a'], [3, 6, 'dialog']], [[0, 1, 'a']])
-      end
-
-      assert_output '[COL_3]aaaaaa' do
-        @line_editor.render_line_differential([[0, 10, 'a' * 10], [3, 6, 'dialog']], [[0, 10, 'a' * 10]])
-      end
-    end
-
-    def test_dialog_change
-      assert_output '[COL_3]DIALOG' do
-        @line_editor.render_line_differential([[0, 2, 'a'], [3, 6, 'dialog']], [[0, 2, 'a'], [3, 6, 'DIALOG']])
-      end
-
-      assert_output '[COL_3]DIALOG' do
-        @line_editor.render_line_differential([[0, 10, 'a' * 10], [3, 6, 'dialog']], [[0, 10, 'a' * 10], [3, 6, 'DIALOG']])
-      end
-    end
-
-    def test_update_under_dialog
-      assert_output '[COL_0]b[COL_1] ' do
-        @line_editor.render_line_differential([[0, 2, 'aa'], [4, 6, 'dialog']], [[0, 1, 'b'], [4, 6, 'dialog']])
-      end
-
-      assert_output '[COL_0]bbb[COL_9]b' do
-        @line_editor.render_line_differential([[0, 10, 'a' * 10], [3, 6, 'dialog']], [[0, 10, 'b' * 10], [3, 6, 'dialog']])
-      end
-
-      assert_output '[COL_0]b[COL_1]  [COL_9][ERASE]' do
-        @line_editor.render_line_differential([[0, 10, 'a' * 10], [3, 6, 'dialog']], [[0, 1, 'b'], [3, 6, 'dialog']])
-      end
-    end
-
-    def test_dialog_move
-      assert_output '[COL_3]dialog[COL_9][ERASE]' do
-        @line_editor.render_line_differential([[0, 1, 'a'], [4, 6, 'dialog']], [[0, 1, 'a'], [3, 6, 'dialog']])
-      end
-
-      assert_output '[COL_4] [COL_5]dialog' do
-        @line_editor.render_line_differential([[0, 1, 'a'], [4, 6, 'dialog']], [[0, 1, 'a'], [5, 6, 'dialog']])
-      end
-
-      assert_output '[COL_2]dialog[COL_8]a' do
-        @line_editor.render_line_differential([[0, 10, 'a' * 10], [3, 6, 'dialog']], [[0, 10, 'a' * 10], [2, 6, 'dialog']])
-      end
-
-      assert_output '[COL_2]a[COL_3]dialog' do
-        @line_editor.render_line_differential([[0, 10, 'a' * 10], [2, 6, 'dialog']], [[0, 10, 'a' * 10], [3, 6, 'dialog']])
-      end
-    end
-
-    def test_multibyte
-      base = [0, 12, '一二三一二三']
-      left = [0, 3, 'LLL']
-      right = [9, 3, 'RRR']
-      front = [3, 6, 'FFFFFF']
-      # 一 FFFFFF 三
-      # 一二三一二三
-      assert_output '[COL_2]二三一二' do
-        @line_editor.render_line_differential([base, front], [base, nil])
-      end
-
-      # LLLFFFFFF 三
-      # LLL 三一二三
-      assert_output '[COL_3] 三一二' do
-        @line_editor.render_line_differential([base, left, front], [base, left, nil])
-      end
-
-      # 一 FFFFFFRRR
-      # 一二三一 RRR
-      assert_output '[COL_2]二三一 ' do
-        @line_editor.render_line_differential([base, right, front], [base, right, nil])
-      end
-
-      # LLLFFFFFFRRR
-      # LLL 三一 RRR
-      assert_output '[COL_3] 三一 ' do
-        @line_editor.render_line_differential([base, left, right, front], [base, left, right, nil])
-      end
-    end
-
-    def test_complicated
-      state_a = [nil, [19, 7, 'bbbbbbb'], [15, 8, 'cccccccc'], [10, 5, 'ddddd'], [18, 4, 'eeee'], [1, 3, 'fff'], [17, 2, 'gg'], [7, 1, 'h']]
-      state_b = [[5, 9, 'aaaaaaaaa'], nil, [15, 8, 'cccccccc'], nil, [18, 4, 'EEEE'], [25, 4, 'ffff'], [17, 2, 'gg'], [2, 2, 'hh']]
-      # state_a: " fff   h  dddddccggeeecbbb"
-      # state_b: "  hh aaaaaaaaa ccggEEEc  ffff"
-
-      assert_output '[COL_1] [COL_2]hh[COL_5]aaaaaaaaa[COL_14] [COL_19]EEE[COL_23]  [COL_25]ffff' do
-        @line_editor.render_line_differential(state_a, state_b)
-      end
-
-      assert_output '[COL_1]fff[COL_5]  [COL_7]h[COL_8]  [COL_10]ddddd[COL_19]eee[COL_23]bbb[COL_26][ERASE]' do
-        @line_editor.render_line_differential(state_b, state_a)
-      end
-    end
-  end
-
-  def test_menu_info_format
-    list = %w[aa b c d e f g hhh i j k]
-    col3 = [
-      'aa   e    i',
-      'b    f    j',
-      'c    g    k',
-      'd    hhh'
-    ]
-    col2 = [
-      'aa   g',
-      'b    hhh',
-      'c    i',
-      'd    j',
-      'e    k',
-      'f'
-    ]
-    assert_equal(col3, Reline::LineEditor::MenuInfo.new(list).lines(19))
-    assert_equal(col3, Reline::LineEditor::MenuInfo.new(list).lines(15))
-    assert_equal(col2, Reline::LineEditor::MenuInfo.new(list).lines(14))
-    assert_equal(col2, Reline::LineEditor::MenuInfo.new(list).lines(10))
-    assert_equal(list, Reline::LineEditor::MenuInfo.new(list).lines(9))
-    assert_equal(list, Reline::LineEditor::MenuInfo.new(list).lines(0))
-    assert_equal([], Reline::LineEditor::MenuInfo.new([]).lines(10))
-  end
-end
diff --git a/test/mri/reline/test_macro.rb b/test/mri/reline/test_macro.rb
deleted file mode 100644
index cacdb76c603..00000000000
--- a/test/mri/reline/test_macro.rb
+++ /dev/null
@@ -1,40 +0,0 @@
-require_relative 'helper'
-
-class Reline::MacroTest < Reline::TestCase
-  def setup
-    Reline.send(:test_mode)
-    @config = Reline::Config.new
-    @encoding = Reline.core.encoding
-    @line_editor = Reline::LineEditor.new(@config)
-    @output = Reline::IOGate.output = File.open(IO::NULL, "w")
-  end
-
-  def teardown
-    @output.close
-    Reline.test_reset
-  end
-
-  def input_key(char, method_symbol = :ed_insert)
-    @line_editor.input_key(Reline::Key.new(char, method_symbol, false))
-  end
-
-  def input(str)
-    str.each_char {|c| input_key(c)}
-  end
-
-  def test_simple_input
-    input('abc')
-    assert_equal 'abc', @line_editor.line
-  end
-
-  def test_alias
-    class << @line_editor
-      alias delete_char ed_delete_prev_char
-    end
-    input('abc')
-    assert_nothing_raised(ArgumentError) {
-      input_key('x', :delete_char)
-    }
-    assert_equal 'ab', @line_editor.line
-  end
-end
diff --git a/test/mri/reline/test_reline.rb b/test/mri/reline/test_reline.rb
deleted file mode 100644
index aa0fd7d29ad..00000000000
--- a/test/mri/reline/test_reline.rb
+++ /dev/null
@@ -1,476 +0,0 @@
-require_relative 'helper'
-require 'reline'
-require 'stringio'
-begin
-  require "pty"
-rescue LoadError # some platforms don't support PTY
-end
-
-class Reline::Test < Reline::TestCase
-  class DummyCallbackObject
-    def call; end
-  end
-
-  def setup
-    Reline.send(:test_mode)
-    Reline.output_modifier_proc = nil
-    Reline.completion_proc = nil
-    Reline.prompt_proc = nil
-    Reline.auto_indent_proc = nil
-    Reline.pre_input_hook = nil
-    Reline.dig_perfect_match_proc = nil
-  end
-
-  def teardown
-    Reline.test_reset
-  end
-
-  def test_completion_append_character
-    completion_append_character = Reline.completion_append_character
-
-    assert_equal(nil, Reline.completion_append_character)
-
-    Reline.completion_append_character = ""
-    assert_equal(nil, Reline.completion_append_character)
-
-    Reline.completion_append_character = "a".encode(Encoding::ASCII)
-    assert_equal("a", Reline.completion_append_character)
-    assert_equal(get_reline_encoding, Reline.completion_append_character.encoding)
-
-    Reline.completion_append_character = "ba".encode(Encoding::ASCII)
-    assert_equal("b", Reline.completion_append_character)
-    assert_equal(get_reline_encoding, Reline.completion_append_character.encoding)
-
-    Reline.completion_append_character = "cba".encode(Encoding::ASCII)
-    assert_equal("c", Reline.completion_append_character)
-    assert_equal(get_reline_encoding, Reline.completion_append_character.encoding)
-
-    Reline.completion_append_character = nil
-    assert_equal(nil, Reline.completion_append_character)
-  ensure
-    Reline.completion_append_character = completion_append_character
-  end
-
-  def test_basic_word_break_characters
-    basic_word_break_characters = Reline.basic_word_break_characters
-
-    assert_equal(" \t\n`><=;|&{(", Reline.basic_word_break_characters)
-
-    Reline.basic_word_break_characters = "[".encode(Encoding::ASCII)
-    assert_equal("[", Reline.basic_word_break_characters)
-    assert_equal(get_reline_encoding, Reline.basic_word_break_characters.encoding)
-  ensure
-    Reline.basic_word_break_characters = basic_word_break_characters
-  end
-
-  def test_completer_word_break_characters
-    completer_word_break_characters = Reline.completer_word_break_characters
-
-    assert_equal(" \t\n`><=;|&{(", Reline.completer_word_break_characters)
-
-    Reline.completer_word_break_characters = "[".encode(Encoding::ASCII)
-    assert_equal("[", Reline.completer_word_break_characters)
-    assert_equal(get_reline_encoding, Reline.completer_word_break_characters.encoding)
-
-    assert_nothing_raised { Reline.completer_word_break_characters = '' }
-  ensure
-    Reline.completer_word_break_characters = completer_word_break_characters
-  end
-
-  def test_basic_quote_characters
-    basic_quote_characters = Reline.basic_quote_characters
-
-    assert_equal('"\'', Reline.basic_quote_characters)
-
-    Reline.basic_quote_characters = "`".encode(Encoding::ASCII)
-    assert_equal("`", Reline.basic_quote_characters)
-    assert_equal(get_reline_encoding, Reline.basic_quote_characters.encoding)
-  ensure
-    Reline.basic_quote_characters = basic_quote_characters
-  end
-
-  def test_completer_quote_characters
-    completer_quote_characters = Reline.completer_quote_characters
-
-    assert_equal('"\'', Reline.completer_quote_characters)
-
-    Reline.completer_quote_characters = "`".encode(Encoding::ASCII)
-    assert_equal("`", Reline.completer_quote_characters)
-    assert_equal(get_reline_encoding, Reline.completer_quote_characters.encoding)
-
-    assert_nothing_raised { Reline.completer_quote_characters = '' }
-  ensure
-    Reline.completer_quote_characters = completer_quote_characters
-  end
-
-  def test_filename_quote_characters
-    filename_quote_characters = Reline.filename_quote_characters
-
-    assert_equal('', Reline.filename_quote_characters)
-
-    Reline.filename_quote_characters = "\'".encode(Encoding::ASCII)
-    assert_equal("\'", Reline.filename_quote_characters)
-    assert_equal(get_reline_encoding, Reline.filename_quote_characters.encoding)
-  ensure
-    Reline.filename_quote_characters = filename_quote_characters
-  end
-
-  def test_special_prefixes
-    special_prefixes = Reline.special_prefixes
-
-    assert_equal('', Reline.special_prefixes)
-
-    Reline.special_prefixes = "\'".encode(Encoding::ASCII)
-    assert_equal("\'", Reline.special_prefixes)
-    assert_equal(get_reline_encoding, Reline.special_prefixes.encoding)
-  ensure
-    Reline.special_prefixes = special_prefixes
-  end
-
-  def test_completion_case_fold
-    completion_case_fold = Reline.completion_case_fold
-
-    assert_equal(nil, Reline.completion_case_fold)
-
-    Reline.completion_case_fold = true
-    assert_equal(true, Reline.completion_case_fold)
-
-    Reline.completion_case_fold = "hoge".encode(Encoding::ASCII)
-    assert_equal("hoge", Reline.completion_case_fold)
-  ensure
-    Reline.completion_case_fold = completion_case_fold
-  end
-
-  def test_completion_proc
-    omit unless Reline.completion_proc == nil
-    # Another test can set Reline.completion_proc
-
-    # assert_equal(nil, Reline.completion_proc)
-
-    dummy_proc = proc {}
-    Reline.completion_proc = dummy_proc
-    assert_equal(dummy_proc, Reline.completion_proc)
-
-    l = lambda {}
-    Reline.completion_proc = l
-    assert_equal(l, Reline.completion_proc)
-
-    assert_raise(ArgumentError) { Reline.completion_proc = 42 }
-    assert_raise(ArgumentError) { Reline.completion_proc = "hoge" }
-
-    dummy = DummyCallbackObject.new
-    Reline.completion_proc = dummy
-    assert_equal(dummy, Reline.completion_proc)
-  end
-
-  def test_output_modifier_proc
-    assert_equal(nil, Reline.output_modifier_proc)
-
-    dummy_proc = proc {}
-    Reline.output_modifier_proc = dummy_proc
-    assert_equal(dummy_proc, Reline.output_modifier_proc)
-
-    l = lambda {}
-    Reline.output_modifier_proc = l
-    assert_equal(l, Reline.output_modifier_proc)
-
-    assert_raise(ArgumentError) { Reline.output_modifier_proc = 42 }
-    assert_raise(ArgumentError) { Reline.output_modifier_proc = "hoge" }
-
-    dummy = DummyCallbackObject.new
-    Reline.output_modifier_proc = dummy
-    assert_equal(dummy, Reline.output_modifier_proc)
-  end
-
-  def test_prompt_proc
-    assert_equal(nil, Reline.prompt_proc)
-
-    dummy_proc = proc {}
-    Reline.prompt_proc = dummy_proc
-    assert_equal(dummy_proc, Reline.prompt_proc)
-
-    l = lambda {}
-    Reline.prompt_proc = l
-    assert_equal(l, Reline.prompt_proc)
-
-    assert_raise(ArgumentError) { Reline.prompt_proc = 42 }
-    assert_raise(ArgumentError) { Reline.prompt_proc = "hoge" }
-
-    dummy = DummyCallbackObject.new
-    Reline.prompt_proc = dummy
-    assert_equal(dummy, Reline.prompt_proc)
-  end
-
-  def test_auto_indent_proc
-    assert_equal(nil, Reline.auto_indent_proc)
-
-    dummy_proc = proc {}
-    Reline.auto_indent_proc = dummy_proc
-    assert_equal(dummy_proc, Reline.auto_indent_proc)
-
-    l = lambda {}
-    Reline.auto_indent_proc = l
-    assert_equal(l, Reline.auto_indent_proc)
-
-    assert_raise(ArgumentError) { Reline.auto_indent_proc = 42 }
-    assert_raise(ArgumentError) { Reline.auto_indent_proc = "hoge" }
-
-    dummy = DummyCallbackObject.new
-    Reline.auto_indent_proc = dummy
-    assert_equal(dummy, Reline.auto_indent_proc)
-  end
-
-  def test_pre_input_hook
-    assert_equal(nil, Reline.pre_input_hook)
-
-    dummy_proc = proc {}
-    Reline.pre_input_hook = dummy_proc
-    assert_equal(dummy_proc, Reline.pre_input_hook)
-
-    l = lambda {}
-    Reline.pre_input_hook = l
-    assert_equal(l, Reline.pre_input_hook)
-  end
-
-  def test_dig_perfect_match_proc
-    assert_equal(nil, Reline.dig_perfect_match_proc)
-
-    dummy_proc = proc {}
-    Reline.dig_perfect_match_proc = dummy_proc
-    assert_equal(dummy_proc, Reline.dig_perfect_match_proc)
-
-    l = lambda {}
-    Reline.dig_perfect_match_proc = l
-    assert_equal(l, Reline.dig_perfect_match_proc)
-
-    assert_raise(ArgumentError) { Reline.dig_perfect_match_proc = 42 }
-    assert_raise(ArgumentError) { Reline.dig_perfect_match_proc = "hoge" }
-
-    dummy = DummyCallbackObject.new
-    Reline.dig_perfect_match_proc = dummy
-    assert_equal(dummy, Reline.dig_perfect_match_proc)
-  end
-
-  def test_insert_text
-    assert_equal('', Reline.line_buffer)
-    assert_equal(0, Reline.point)
-    Reline.insert_text('abc')
-    assert_equal('abc', Reline.line_buffer)
-    assert_equal(3, Reline.point)
-  end
-
-  def test_delete_text
-    assert_equal('', Reline.line_buffer)
-    assert_equal(0, Reline.point)
-    Reline.insert_text('abc')
-    assert_equal('abc', Reline.line_buffer)
-    assert_equal(3, Reline.point)
-    Reline.delete_text()
-    assert_equal('', Reline.line_buffer)
-    assert_equal(0, Reline.point)
-    Reline.insert_text('abc')
-    Reline.delete_text(1)
-    assert_equal('a', Reline.line_buffer)
-    assert_equal(1, Reline.point)
-    Reline.insert_text('defghi')
-    Reline.delete_text(2, 2)
-    assert_equal('adghi', Reline.line_buffer)
-    assert_equal(5, Reline.point)
-  end
-
-  def test_set_input_and_output
-    assert_raise(TypeError) do
-      Reline.input = "This is not a file."
-    end
-    assert_raise(TypeError) do
-      Reline.output = "This is not a file."
-    end
-
-    input, to_write = IO.pipe
-    to_read, output = IO.pipe
-    unless Reline.__send__(:input=, input)
-      omit "Setting to input is not effective on #{Reline.core.io_gate}"
-    end
-    Reline.output = output
-
-    to_write.write "a\n"
-    result = Reline.readline
-    to_write.close
-    read_text = to_read.read_nonblock(100)
-    assert_equal('a', result)
-    refute(read_text.empty?)
-  ensure
-    input&.close
-    output&.close
-    to_read&.close
-  end
-
-  def test_vi_editing_mode
-    Reline.vi_editing_mode
-    assert_equal(:vi_insert, Reline.core.config.instance_variable_get(:@editing_mode_label))
-  end
-
-  def test_emacs_editing_mode
-    Reline.emacs_editing_mode
-    assert_equal(:emacs, Reline.core.config.instance_variable_get(:@editing_mode_label))
-  end
-
-  def test_add_dialog_proc
-    dummy_proc = proc {}
-    Reline.add_dialog_proc(:test_proc, dummy_proc)
-    d = Reline.dialog_proc(:test_proc)
-    assert_equal(dummy_proc, d.dialog_proc)
-
-    dummy_proc_2 = proc {}
-    Reline.add_dialog_proc(:test_proc, dummy_proc_2)
-    d = Reline.dialog_proc(:test_proc)
-    assert_equal(dummy_proc_2, d.dialog_proc)
-
-    Reline.add_dialog_proc(:test_proc, nil)
-    assert_nil(Reline.dialog_proc(:test_proc))
-
-    l = lambda {}
-    Reline.add_dialog_proc(:test_lambda, l)
-    d = Reline.dialog_proc(:test_lambda)
-    assert_equal(l, d.dialog_proc)
-
-    assert_equal(nil, Reline.dialog_proc(:test_nothing))
-
-    assert_raise(ArgumentError) { Reline.add_dialog_proc(:error, 42) }
-    assert_raise(ArgumentError) { Reline.add_dialog_proc(:error, 'hoge') }
-    assert_raise(ArgumentError) { Reline.add_dialog_proc('error', proc {} ) }
-
-    dummy = DummyCallbackObject.new
-    Reline.add_dialog_proc(:dummy, dummy)
-    d = Reline.dialog_proc(:dummy)
-    assert_equal(dummy, d.dialog_proc)
-  end
-
-  def test_add_dialog_proc_with_context
-    dummy_proc = proc {}
-    array = Array.new
-    Reline.add_dialog_proc(:test_proc, dummy_proc, array)
-    d = Reline.dialog_proc(:test_proc)
-    assert_equal(dummy_proc, d.dialog_proc)
-    assert_equal(array, d.context)
-
-    Reline.add_dialog_proc(:test_proc, dummy_proc, nil)
-    d = Reline.dialog_proc(:test_proc)
-    assert_equal(dummy_proc, d.dialog_proc)
-    assert_equal(nil, d.context)
-  end
-
-  def test_readmultiline
-    # readmultiline is module function
-    assert_include(Reline.methods, :readmultiline)
-    assert_include(Reline.private_instance_methods, :readmultiline)
-  end
-
-  def test_readline
-    # readline is module function
-    assert_include(Reline.methods, :readline)
-    assert_include(Reline.private_instance_methods, :readline)
-  end
-
-  def test_read_io
-    # TODO in Reline::Core
-  end
-
-  def test_dumb_terminal
-    lib = File.expand_path("../../lib", __dir__)
-    out = IO.popen([{"TERM"=>"dumb"}, Reline.test_rubybin, "-I#{lib}", "-rreline", "-e", "p Reline.core.io_gate"], &:read)
-    assert_match(/#<Reline::Dumb/, out.chomp)
-  end
-
-  def test_read_eof_returns_input
-    pend if win?
-    lib = File.expand_path("../../lib", __dir__)
-    code = "p result: Reline.readline"
-    out = IO.popen([Reline.test_rubybin, "-I#{lib}", "-rreline", "-e", code], "r+") do |io|
-      io.write "a\C-a"
-      io.close_write
-      io.read
-    end
-    assert_include(out, { result: 'a' }.inspect)
-  end
-
-  def test_read_eof_returns_nil_if_empty
-    pend if win?
-    lib = File.expand_path("../../lib", __dir__)
-    code = "p result: Reline.readline"
-    out = IO.popen([Reline.test_rubybin, "-I#{lib}", "-rreline", "-e", code], "r+") do |io|
-      io.write "a\C-h"
-      io.close_write
-      io.read
-    end
-    assert_include(out, { result: nil }.inspect)
-  end
-
-  def test_require_reline_should_not_trigger_winsize
-    pend if win?
-    lib = File.expand_path("../../lib", __dir__)
-    code = <<~RUBY
-      require "io/console"
-      def STDIN.tty?; true; end
-      def STDOUT.tty?; true; end
-      def STDIN.winsize; raise; end
-      require("reline") && p(Reline.core.io_gate)
-    RUBY
-    out = IO.popen([{}, Reline.test_rubybin, "-I#{lib}", "-e", code], &:read)
-    assert_include(out.chomp, "Reline::ANSI")
-  end
-
-  def win?
-    /mswin|mingw/.match?(RUBY_PLATFORM)
-  end
-
-  def test_tty_ambiguous_width
-    omit unless defined?(PTY)
-    ruby_file = Tempfile.create('rubyfile')
-    ruby_file.write(<<~RUBY)
-      require 'reline'
-      Thread.new { sleep 2; puts 'timeout'; exit }
-      line = Reline.readline('>')
-      p [Reline.ambiguous_width, line]
-    RUBY
-    ruby_file.close
-    lib = File.expand_path('../../lib', __dir__)
-    cmd = [{ 'TERM' => 'xterm' }, Reline.test_rubybin, '-I', lib, ruby_file.to_path]
-
-    # Calculate ambiguous width from cursor position
-    [1, 2].each do |ambiguous_width|
-      PTY.spawn(*cmd) do |r, w, pid|
-        loop { break if r.readpartial(1024).include?("\e[6n") }
-        w.puts "hello\e[10;#{ambiguous_width + 1}Rworld\n"
-        assert_include(r.gets + r.gets, [ambiguous_width, 'helloworld'].inspect)
-      ensure
-        r.close
-        w.close
-        Process.waitpid pid
-      end
-    end
-
-    # Ambiguous width = 1 when cursor pos timed out
-    PTY.spawn(*cmd) do |r, w, pid|
-      loop { break if r.readpartial(1024).include?("\e[6n") }
-      w.puts "helloworld\n"
-      assert_include(r.gets + r.gets, [1, "helloworld"].inspect)
-    ensure
-      r.close
-      w.close
-      Process.waitpid pid
-    end
-  ensure
-    File.delete(ruby_file.path) if ruby_file
-  end
-
-  def get_reline_encoding
-    if encoding = Reline.core.encoding
-      encoding
-    elsif win?
-      Encoding::UTF_8
-    else
-      Encoding::default_external
-    end
-  end
-end
diff --git a/test/mri/reline/test_reline_key.rb b/test/mri/reline/test_reline_key.rb
deleted file mode 100644
index b6260d57d6f..00000000000
--- a/test/mri/reline/test_reline_key.rb
+++ /dev/null
@@ -1,10 +0,0 @@
-require_relative 'helper'
-require "reline"
-
-class Reline::TestKey < Reline::TestCase
-  def test_match_symbol
-    assert(Reline::Key.new('a', :key1, false).match?(:key1))
-    refute(Reline::Key.new('a', :key1, false).match?(:key2))
-    refute(Reline::Key.new('a', :key1, false).match?(nil))
-  end
-end
diff --git a/test/mri/reline/test_string_processing.rb b/test/mri/reline/test_string_processing.rb
deleted file mode 100644
index a105be9abad..00000000000
--- a/test/mri/reline/test_string_processing.rb
+++ /dev/null
@@ -1,46 +0,0 @@
-require_relative 'helper'
-
-class Reline::LineEditor::StringProcessingTest < Reline::TestCase
-  def setup
-    Reline.send(:test_mode)
-    @prompt = '> '
-    @config = Reline::Config.new
-    Reline::HISTORY.instance_variable_set(:@config, @config)
-    @line_editor = Reline::LineEditor.new(@config)
-    @line_editor.reset(@prompt)
-  end
-
-  def teardown
-    Reline.test_reset
-  end
-
-  def test_calculate_width
-    width = @line_editor.send(:calculate_width, 'Ruby string')
-    assert_equal('Ruby string'.size, width)
-  end
-
-  def test_calculate_width_with_escape_sequence
-    width = @line_editor.send(:calculate_width, "\1\e[31m\2RubyColor\1\e[34m\2 default string \1\e[m\2>", true)
-    assert_equal('RubyColor default string >'.size, width)
-  end
-
-  def test_completion_proc_with_preposing_and_postposing
-    buf = ['def hoge', '  puts :aaa', 'end']
-
-    @line_editor.instance_variable_set(:@is_multiline, true)
-    @line_editor.instance_variable_set(:@buffer_of_lines, buf)
-    @line_editor.instance_variable_set(:@byte_pointer, 6)
-    @line_editor.instance_variable_set(:@line_index, 1)
-    completion_proc_called = false
-    @line_editor.instance_variable_set(:@completion_proc, proc { |target, pre, post|
-      assert_equal('puts', target)
-      assert_equal("def hoge\n  ", pre)
-      assert_equal(" :aaa\nend", post)
-      completion_proc_called = true
-    })
-
-    assert_equal(["def hoge\n  ", 'puts', " :aaa\nend", nil], @line_editor.retrieve_completion_block)
-    @line_editor.__send__(:call_completion_proc, "def hoge\n  ", 'puts', " :aaa\nend", nil)
-    assert(completion_proc_called)
-  end
-end
diff --git a/test/mri/reline/test_unicode.rb b/test/mri/reline/test_unicode.rb
deleted file mode 100644
index 03e3be7d731..00000000000
--- a/test/mri/reline/test_unicode.rb
+++ /dev/null
@@ -1,342 +0,0 @@
-require_relative 'helper'
-require "reline/unicode"
-
-class Reline::Unicode::Test < Reline::TestCase
-  def setup
-    Reline.send(:test_mode)
-  end
-
-  def teardown
-    Reline.test_reset
-  end
-
-  def test_get_mbchar_width
-    assert_equal Reline.ambiguous_width, Reline::Unicode.get_mbchar_width('é')
-  end
-
-  def test_ambiguous_width
-    assert_equal 1, Reline::Unicode.calculate_width('√', true)
-  end
-
-  def test_csi_regexp
-    csi_sequences = ["\e[m", "\e[1m", "\e[12;34m", "\e[12;34H", "\e[5 q", "\e[?2004h"]
-    assert_equal(csi_sequences, "text#{csi_sequences.join('text')}text".scan(Reline::Unicode::CSI_REGEXP))
-  end
-
-  def test_osc_regexp
-    osc_sequences = ["\e]1\a", "\e]0;OSC\a", "\e]1\e\\", "\e]0;OSC\e\\"]
-    separator = "text\atext"
-    assert_equal(osc_sequences, "#{separator}#{osc_sequences.join(separator)}#{separator}".scan(Reline::Unicode::OSC_REGEXP))
-  end
-
-  def test_split_by_width
-    # IRB uses this method.
-    assert_equal [['abc', 'de'], 2], Reline::Unicode.split_by_width('abcde', 3)
-  end
-
-  def test_split_line_by_width
-    assert_equal ['abc', 'de'], Reline::Unicode.split_line_by_width('abcde', 3)
-    assert_equal ['abc', 'def', ''], Reline::Unicode.split_line_by_width('abcdef', 3)
-    assert_equal ['ab', 'あd', 'ef'], Reline::Unicode.split_line_by_width('abあdef', 3)
-    assert_equal ['ab[zero]c', 'def', ''], Reline::Unicode.split_line_by_width("ab\1[zero]\2cdef", 3)
-    assert_equal ["\e[31mabc", "\e[31md\e[42mef", "\e[31m\e[42mg"], Reline::Unicode.split_line_by_width("\e[31mabcd\e[42mefg", 3)
-    assert_equal ["ab\e]0;1\ac", "\e]0;1\ad"], Reline::Unicode.split_line_by_width("ab\e]0;1\acd", 3)
-  end
-
-  def test_split_line_by_width_csi_reset_sgr_optimization
-    assert_equal ["\e[1ma\e[mb\e[2mc", "\e[2md\e[0me\e[3mf", "\e[3mg"], Reline::Unicode.split_line_by_width("\e[1ma\e[mb\e[2mcd\e[0me\e[3mfg", 3)
-    assert_equal ["\e[1ma\e[mzero\e[0m\e[2mb", "\e[1m\e[2mc"], Reline::Unicode.split_line_by_width("\e[1ma\1\e[mzero\e[0m\2\e[2mbc", 2)
-  end
-
-  def test_take_range
-    assert_equal 'cdef', Reline::Unicode.take_range('abcdefghi', 2, 4)
-    assert_equal 'あde', Reline::Unicode.take_range('abあdef', 2, 4)
-    assert_equal '[zero]cdef', Reline::Unicode.take_range("ab\1[zero]\2cdef", 2, 4)
-    assert_equal 'b[zero]cde', Reline::Unicode.take_range("ab\1[zero]\2cdef", 1, 4)
-    assert_equal "\e[31mcd\e[42mef", Reline::Unicode.take_range("\e[31mabcd\e[42mefg", 2, 4)
-    assert_equal "\e]0;1\acd", Reline::Unicode.take_range("ab\e]0;1\acd", 2, 3)
-    assert_equal 'いう', Reline::Unicode.take_range('あいうえお', 2, 4)
-  end
-
-  def test_nonprinting_start_end
-    # \1 and \2 should be removed
-    assert_equal 'ab[zero]cd', Reline::Unicode.take_range("ab\1[zero]\2cdef", 0, 4)
-    assert_equal ['ab[zero]cd', 'ef'], Reline::Unicode.split_line_by_width("ab\1[zero]\2cdef", 4)
-    # CSI between \1 and \2 does not need to be applied to the sebsequent line
-    assert_equal ["\e[31mab\e[32mcd", "\e[31mef"], Reline::Unicode.split_line_by_width("\e[31mab\1\e[32m\2cdef", 4)
-  end
-
-  def test_strip_non_printing_start_end
-    assert_equal "ab[zero]cd[ze\1ro]ef[zero]", Reline::Unicode.strip_non_printing_start_end("ab\1[zero]\2cd\1[ze\1ro]\2ef\1[zero]")
-  end
-
-  def test_calculate_width
-    assert_equal 9, Reline::Unicode.calculate_width('abcdefghi')
-    assert_equal 9, Reline::Unicode.calculate_width('abcdefghi', true)
-    assert_equal 7, Reline::Unicode.calculate_width('abあdef')
-    assert_equal 7, Reline::Unicode.calculate_width('abあdef', true)
-    assert_equal 16, Reline::Unicode.calculate_width("ab\1[zero]\2cdef")
-    assert_equal 6, Reline::Unicode.calculate_width("ab\1[zero]\2cdef", true)
-    assert_equal 19, Reline::Unicode.calculate_width("\e[31mabcd\e[42mefg")
-    assert_equal 7, Reline::Unicode.calculate_width("\e[31mabcd\e[42mefg", true)
-    assert_equal 12, Reline::Unicode.calculate_width("ab\e]0;1\acd")
-    assert_equal 4, Reline::Unicode.calculate_width("ab\e]0;1\acd", true)
-    assert_equal 10, Reline::Unicode.calculate_width('あいうえお')
-    assert_equal 10, Reline::Unicode.calculate_width('あいうえお', true)
-  end
-
-  def test_take_mbchar_range
-    assert_equal ['cdef', 2, 4], Reline::Unicode.take_mbchar_range('abcdefghi', 2, 4)
-    assert_equal ['cdef', 2, 4], Reline::Unicode.take_mbchar_range('abcdefghi', 2, 4, padding: true)
-    assert_equal ['cdef', 2, 4], Reline::Unicode.take_mbchar_range('abcdefghi', 2, 4, cover_begin: true)
-    assert_equal ['cdef', 2, 4], Reline::Unicode.take_mbchar_range('abcdefghi', 2, 4, cover_end: true)
-    assert_equal ['いう', 2, 4], Reline::Unicode.take_mbchar_range('あいうえお', 2, 4)
-    assert_equal ['いう', 2, 4], Reline::Unicode.take_mbchar_range('あいうえお', 2, 4, padding: true)
-    assert_equal ['いう', 2, 4], Reline::Unicode.take_mbchar_range('あいうえお', 2, 4, cover_begin: true)
-    assert_equal ['いう', 2, 4], Reline::Unicode.take_mbchar_range('あいうえお', 2, 4, cover_end: true)
-    assert_equal ['う', 4, 2], Reline::Unicode.take_mbchar_range('あいうえお', 3, 4)
-    assert_equal [' う ', 3, 4], Reline::Unicode.take_mbchar_range('あいうえお', 3, 4, padding: true)
-    assert_equal ['いう', 2, 4], Reline::Unicode.take_mbchar_range('あいうえお', 3, 4, cover_begin: true)
-    assert_equal ['うえ', 4, 4], Reline::Unicode.take_mbchar_range('あいうえお', 3, 4, cover_end: true)
-    assert_equal ['いう ', 2, 5], Reline::Unicode.take_mbchar_range('あいうえお', 3, 4, cover_begin: true, padding: true)
-    assert_equal [' うえ', 3, 5], Reline::Unicode.take_mbchar_range('あいうえお', 3, 4, cover_end: true, padding: true)
-    assert_equal [' うえお   ', 3, 10], Reline::Unicode.take_mbchar_range('あいうえお', 3, 10, padding: true)
-    assert_equal [" \e[41mうえお\e[0m   ", 3, 10], Reline::Unicode.take_mbchar_range("あい\e[41mうえお", 3, 10, padding: true)
-    assert_equal ["\e[41m \e[42mい\e[43m ", 1, 4], Reline::Unicode.take_mbchar_range("\e[41mあ\e[42mい\e[43mう", 1, 4, padding: true)
-    assert_equal ["\e[31mc[ABC]d\e[0mef", 2, 4], Reline::Unicode.take_mbchar_range("\e[31mabc\1[ABC]\2d\e[0mefghi", 2, 4)
-    assert_equal ["\e[41m \e[42mい\e[43m ", 1, 4], Reline::Unicode.take_mbchar_range("\e[41mあ\e[42mい\e[43mう", 1, 4, padding: true)
-  end
-
-  def test_three_width_characters_take_mbchar_range
-    halfwidth_dakuten = 0xFF9E.chr('utf-8')
-    a = 'あ' + halfwidth_dakuten
-    b = 'い' + halfwidth_dakuten
-    c = 'う' + halfwidth_dakuten
-    line = 'x' + a + b + c + 'x'
-    assert_equal ['  ' + b + ' ', 2, 6], Reline::Unicode.take_mbchar_range(line, 2, 6, padding: true)
-    assert_equal [' ' + b + '  ', 3, 6], Reline::Unicode.take_mbchar_range(line, 3, 6, padding: true)
-    assert_equal [b + c, 4, 6], Reline::Unicode.take_mbchar_range(line, 4, 6, padding: true)
-    assert_equal [a + b, 1, 6], Reline::Unicode.take_mbchar_range(line, 2, 6, cover_begin: true)
-    assert_equal [a + b, 1, 6], Reline::Unicode.take_mbchar_range(line, 3, 6, cover_begin: true)
-    assert_equal [b + c, 4, 6], Reline::Unicode.take_mbchar_range(line, 2, 6, cover_end: true)
-    assert_equal [b + c, 4, 6], Reline::Unicode.take_mbchar_range(line, 3, 6, cover_end: true)
-  end
-
-  def test_common_prefix
-    assert_equal('', Reline::Unicode.common_prefix([]))
-    assert_equal('abc', Reline::Unicode.common_prefix(['abc']))
-    assert_equal('12', Reline::Unicode.common_prefix(['123', '123️⃣']))
-    assert_equal('', Reline::Unicode.common_prefix(['abc', 'xyz']))
-    assert_equal('ab', Reline::Unicode.common_prefix(['abcd', 'abc', 'abx', 'abcd']))
-    assert_equal('A', Reline::Unicode.common_prefix(['AbcD', 'ABC', 'AbX', 'AbCD']))
-    assert_equal('Ab', Reline::Unicode.common_prefix(['AbcD', 'ABC', 'AbX', 'AbCD'], ignore_case: true))
-  end
-
-  def test_encoding_conversion
-    texts = [
-      String.new("invalid\xFFutf8", encoding: 'utf-8'),
-      String.new("invalid\xFFsjis", encoding: 'sjis'),
-      "utf8#{33111.chr('sjis')}convertible",
-      "utf8#{33222.chr('sjis')}inconvertible",
-      "sjis->utf8->sjis#{60777.chr('sjis')}irreversible"
-    ]
-    utf8_texts = [
-      'invalid�utf8',
-      'invalid�sjis',
-      'utf8仝convertible',
-      'utf8�inconvertible',
-      'sjis->utf8->sjis劦irreversible'
-    ]
-    sjis_texts = [
-      'invalid?utf8',
-      'invalid?sjis',
-      "utf8#{33111.chr('sjis')}convertible",
-      'utf8?inconvertible',
-      "sjis->utf8->sjis#{60777.chr('sjis')}irreversible"
-    ]
-    assert_equal(utf8_texts, texts.map { |s| Reline::Unicode.safe_encode(s, 'utf-8') })
-    assert_equal(utf8_texts, texts.map { |s| Reline::Unicode.safe_encode(s, Encoding::UTF_8) })
-    assert_equal(sjis_texts, texts.map { |s| Reline::Unicode.safe_encode(s, 'sjis') })
-    assert_equal(sjis_texts, texts.map { |s| Reline::Unicode.safe_encode(s, Encoding::Windows_31J) })
-  end
-
-  def test_em_forward_word
-    assert_equal(12, Reline::Unicode.em_forward_word('abc---fooあbar-baz', 3))
-    assert_equal(11, Reline::Unicode.em_forward_word('abc---fooあbar-baz'.encode('sjis'), 3))
-    assert_equal(3, Reline::Unicode.em_forward_word('abcfoo', 3))
-    assert_equal(3, Reline::Unicode.em_forward_word('abc---', 3))
-    assert_equal(0, Reline::Unicode.em_forward_word('abc', 3))
-  end
-
-  def test_em_forward_word_with_capitalization
-    assert_equal([12, '---Fooあbar'], Reline::Unicode.em_forward_word_with_capitalization('abc---foOあBar-baz', 3))
-    assert_equal([11, '---Fooあbar'.encode('sjis')], Reline::Unicode.em_forward_word_with_capitalization('abc---foOあBar-baz'.encode('sjis'), 3))
-    assert_equal([3, 'Foo'], Reline::Unicode.em_forward_word_with_capitalization('abcfOo', 3))
-    assert_equal([3, '---'], Reline::Unicode.em_forward_word_with_capitalization('abc---', 3))
-    assert_equal([0, ''], Reline::Unicode.em_forward_word_with_capitalization('abc', 3))
-    assert_equal([6, 'Ii̇i̇'], Reline::Unicode.em_forward_word_with_capitalization('ıİİ', 0))
-  end
-
-  def test_em_backward_word
-    assert_equal(12, Reline::Unicode.em_backward_word('abc foo-barあbaz--- xyz', 20))
-    assert_equal(11, Reline::Unicode.em_backward_word('abc foo-barあbaz--- xyz'.encode('sjis'), 19))
-    assert_equal(2, Reline::Unicode.em_backward_word('  ', 2))
-    assert_equal(2, Reline::Unicode.em_backward_word('ab', 2))
-    assert_equal(0, Reline::Unicode.em_backward_word('ab', 0))
-  end
-
-  def test_em_big_backward_word
-    assert_equal(16, Reline::Unicode.em_big_backward_word('abc foo-barあbaz--- xyz', 20))
-    assert_equal(15, Reline::Unicode.em_big_backward_word('abc foo-barあbaz--- xyz'.encode('sjis'), 19))
-    assert_equal(2, Reline::Unicode.em_big_backward_word('  ', 2))
-    assert_equal(2, Reline::Unicode.em_big_backward_word('ab', 2))
-    assert_equal(0, Reline::Unicode.em_big_backward_word('ab', 0))
-  end
-
-  def test_ed_transpose_words
-    # any value that does not trigger transpose
-    assert_equal([0, 0, 0, 2], Reline::Unicode.ed_transpose_words('aa bb cc  ', 1))
-
-    assert_equal([0, 2, 3, 5], Reline::Unicode.ed_transpose_words('aa bb cc  ', 2))
-    assert_equal([0, 2, 3, 5], Reline::Unicode.ed_transpose_words('aa bb cc  ', 4))
-    assert_equal([3, 5, 6, 8], Reline::Unicode.ed_transpose_words('aa bb cc  ', 5))
-    assert_equal([3, 5, 6, 8], Reline::Unicode.ed_transpose_words('aa bb cc  ', 7))
-    assert_equal([3, 5, 6, 10], Reline::Unicode.ed_transpose_words('aa bb cc  ', 8))
-    assert_equal([3, 5, 6, 10], Reline::Unicode.ed_transpose_words('aa bb cc  ', 9))
-    ['sjis', 'utf-8'].each do |encoding|
-      texts = ['fooあ', 'barあbaz', 'aaa  -', '- -', '-  bbb']
-      word1, word2, left, middle, right = texts.map { |text| text.encode(encoding) }
-      expected = [left.bytesize, (left + word1).bytesize, (left + word1 + middle).bytesize, (left + word1 + middle + word2).bytesize]
-      assert_equal(expected, Reline::Unicode.ed_transpose_words(left + word1 + middle + word2 + right, left.bytesize + word1.bytesize))
-      assert_equal(expected, Reline::Unicode.ed_transpose_words(left + word1 + middle + word2 + right, left.bytesize + word1.bytesize + middle.bytesize))
-      assert_equal(expected, Reline::Unicode.ed_transpose_words(left + word1 + middle + word2 + right, left.bytesize + word1.bytesize + middle.bytesize + word2.bytesize - 1))
-    end
-  end
-
-  def test_vi_big_forward_word
-    assert_equal(18, Reline::Unicode.vi_big_forward_word('abc---fooあbar-baz  xyz', 3))
-    assert_equal(8, Reline::Unicode.vi_big_forward_word('abcfooあ  --', 3))
-    assert_equal(7, Reline::Unicode.vi_big_forward_word('abcfooあ  --'.encode('sjis'), 3))
-    assert_equal(6, Reline::Unicode.vi_big_forward_word('abcfooあ', 3))
-    assert_equal(3, Reline::Unicode.vi_big_forward_word('abc-  ', 3))
-    assert_equal(0, Reline::Unicode.vi_big_forward_word('abc', 3))
-  end
-
-  def test_vi_big_forward_end_word
-    assert_equal(4, Reline::Unicode.vi_big_forward_end_word('a  bb c', 0))
-    assert_equal(4, Reline::Unicode.vi_big_forward_end_word('-  bb c', 0))
-    assert_equal(1, Reline::Unicode.vi_big_forward_end_word('-a b', 0))
-    assert_equal(1, Reline::Unicode.vi_big_forward_end_word('a- b', 0))
-    assert_equal(1, Reline::Unicode.vi_big_forward_end_word('aa b', 0))
-    assert_equal(3, Reline::Unicode.vi_big_forward_end_word('  aa b', 0))
-    assert_equal(15, Reline::Unicode.vi_big_forward_end_word('abc---fooあbar-baz  xyz', 3))
-    assert_equal(14, Reline::Unicode.vi_big_forward_end_word('abc---fooあbar-baz  xyz'.encode('sjis'), 3))
-    assert_equal(3, Reline::Unicode.vi_big_forward_end_word('abcfooあ  --', 3))
-    assert_equal(3, Reline::Unicode.vi_big_forward_end_word('abcfooあ', 3))
-    assert_equal(2, Reline::Unicode.vi_big_forward_end_word('abc-  ', 3))
-    assert_equal(0, Reline::Unicode.vi_big_forward_end_word('abc', 3))
-  end
-
-  def test_vi_big_backward_word
-    assert_equal(16, Reline::Unicode.vi_big_backward_word('abc foo-barあbaz--- xyz', 20))
-    assert_equal(15, Reline::Unicode.vi_big_backward_word('abc foo-barあbaz--- xyz'.encode('sjis'), 19))
-    assert_equal(2, Reline::Unicode.vi_big_backward_word('  ', 2))
-    assert_equal(2, Reline::Unicode.vi_big_backward_word('ab', 2))
-    assert_equal(0, Reline::Unicode.vi_big_backward_word('ab', 0))
-  end
-
-  def test_vi_forward_word
-    assert_equal(3, Reline::Unicode.vi_forward_word('abc---fooあbar-baz', 3))
-    assert_equal(9, Reline::Unicode.vi_forward_word('abc---fooあbar-baz', 6))
-    assert_equal(8, Reline::Unicode.vi_forward_word('abc---fooあbar-baz'.encode('sjis'), 6))
-    assert_equal(6, Reline::Unicode.vi_forward_word('abcfooあ', 3))
-    assert_equal(3, Reline::Unicode.vi_forward_word('abc---', 3))
-    assert_equal(0, Reline::Unicode.vi_forward_word('abc', 3))
-    assert_equal(2, Reline::Unicode.vi_forward_word('abc   def', 1, true))
-    assert_equal(5, Reline::Unicode.vi_forward_word('abc   def', 1, false))
-  end
-
-  def test_vi_forward_end_word
-    assert_equal(2, Reline::Unicode.vi_forward_end_word('abc---fooあbar-baz', 3))
-    assert_equal(8, Reline::Unicode.vi_forward_end_word('abc---fooあbar-baz', 6))
-    assert_equal(7, Reline::Unicode.vi_forward_end_word('abc---fooあbar-baz'.encode('sjis'), 6))
-    assert_equal(3, Reline::Unicode.vi_forward_end_word('abcfooあ', 3))
-    assert_equal(2, Reline::Unicode.vi_forward_end_word('abc---', 3))
-    assert_equal(0, Reline::Unicode.vi_forward_end_word('abc', 3))
-  end
-
-  def test_vi_backward_word
-    assert_equal(3, Reline::Unicode.vi_backward_word('abc foo-barあbaz--- xyz', 20))
-    assert_equal(9, Reline::Unicode.vi_backward_word('abc foo-barあbaz--- xyz', 17))
-    assert_equal(8, Reline::Unicode.vi_backward_word('abc foo-barあbaz--- xyz'.encode('sjis'), 16))
-    assert_equal(2, Reline::Unicode.vi_backward_word('  ', 2))
-    assert_equal(2, Reline::Unicode.vi_backward_word('ab', 2))
-    assert_equal(0, Reline::Unicode.vi_backward_word('ab', 0))
-  end
-
-  def test_vi_first_print
-    assert_equal(3, Reline::Unicode.vi_first_print('   abcdefg'))
-    assert_equal(3, Reline::Unicode.vi_first_print('   '))
-    assert_equal(0, Reline::Unicode.vi_first_print('abc'))
-    assert_equal(0, Reline::Unicode.vi_first_print('あ'))
-    assert_equal(0, Reline::Unicode.vi_first_print('あ'.encode('sjis')))
-    assert_equal(0, Reline::Unicode.vi_first_print(''))
-  end
-
-  def test_character_type
-    assert(Reline::Unicode.word_character?('a'))
-    assert(Reline::Unicode.word_character?('あ'))
-    assert(Reline::Unicode.word_character?('あ'.encode('sjis')))
-    refute(Reline::Unicode.word_character?(33345.chr('sjis')))
-    refute(Reline::Unicode.word_character?('-'))
-    refute(Reline::Unicode.word_character?(nil))
-
-    assert(Reline::Unicode.space_character?(' '))
-    refute(Reline::Unicode.space_character?('あ'))
-    refute(Reline::Unicode.space_character?('あ'.encode('sjis')))
-    refute(Reline::Unicode.space_character?(33345.chr('sjis')))
-    refute(Reline::Unicode.space_character?('-'))
-    refute(Reline::Unicode.space_character?(nil))
-  end
-
-  def test_halfwidth_dakuten_handakuten_combinations
-    assert_equal 1, Reline::Unicode.get_mbchar_width("\uFF9E")
-    assert_equal 1, Reline::Unicode.get_mbchar_width("\uFF9F")
-    assert_equal 2, Reline::Unicode.get_mbchar_width("ｶﾞ")
-    assert_equal 2, Reline::Unicode.get_mbchar_width("ﾊﾟ")
-    assert_equal 2, Reline::Unicode.get_mbchar_width("ｻﾞ")
-    assert_equal 2, Reline::Unicode.get_mbchar_width("aﾞ")
-    assert_equal 2, Reline::Unicode.get_mbchar_width("1ﾟ")
-    assert_equal 3, Reline::Unicode.get_mbchar_width("あﾞ")
-    assert_equal 3, Reline::Unicode.get_mbchar_width("紅ﾞ")
-  end
-
-  def test_grapheme_cluster_width
-    # GB6, GB7, GB8: Hangul syllable
-    assert_equal 2, Reline::Unicode.get_mbchar_width('한'.unicode_normalize(:nfd))
-    assert_equal 6, Reline::Unicode.get_mbchar_width('ᄀ' * 3)
-
-    # GB9
-    # Char + NonspacingMark
-    assert_equal 1, Reline::Unicode.get_mbchar_width('ç'.unicode_normalize(:nfd))
-    assert_equal 2, Reline::Unicode.get_mbchar_width('ぱ'.unicode_normalize(:nfd))
-    assert_equal 1, Reline::Unicode.get_mbchar_width("c\u{301}\u{327}")
-    # '1' + NonspacingMark + EnclosingMark
-    assert_equal 1, Reline::Unicode.get_mbchar_width('1️⃣')
-    # Char + SpacingMark
-    assert_equal 2, Reline::Unicode.get_mbchar_width('কা')
-    assert_equal 5, Reline::Unicode.get_mbchar_width('ｶﾞﾟﾞﾞ')
-    # Emoji joined with ZeroWidthJoiner
-    assert_equal 2, Reline::Unicode.get_mbchar_width('👨‍👩‍👧')
-    assert_equal 7, Reline::Unicode.get_mbchar_width('👨‍👩‍👧ﾞﾟﾟﾟﾞ')
-
-    # GB9a: Char + GraphemeClusterBreak=SpacingMark
-    assert_equal 2, Reline::Unicode.get_mbchar_width('คำ')
-
-    # GB9c: Consonant + Linker(NonspacingMark) + Consonant
-    assert_equal 2, Reline::Unicode.get_mbchar_width('क्त')
-
-    # GB12, GB13: RegionalIndicator
-    assert_equal 2, Reline::Unicode.get_mbchar_width('🇯🇵')
-  end
-end
diff --git a/test/mri/reline/test_within_pipe.rb b/test/mri/reline/test_within_pipe.rb
deleted file mode 100644
index e5d0c12b9c9..00000000000
--- a/test/mri/reline/test_within_pipe.rb
+++ /dev/null
@@ -1,77 +0,0 @@
-require_relative 'helper'
-
-class Reline::WithinPipeTest < Reline::TestCase
-  def setup
-    Reline.send(:test_mode)
-    @encoding = Reline.core.encoding
-    @input_reader, @writer = IO.pipe(@encoding)
-    Reline.input = @input_reader
-    @reader, @output_writer = IO.pipe(@encoding)
-    @output = Reline.output = @output_writer
-    @config = Reline.core.config
-    @config.keyseq_timeout *= 600 if defined?(RubyVM::RJIT) && RubyVM::RJIT.enabled? # for --jit-wait CI
-    @line_editor = Reline.core.line_editor
-  end
-
-  def teardown
-    Reline.input = STDIN
-    Reline.output = STDOUT
-    Reline.point = 0
-    Reline.delete_text
-    @input_reader.close
-    @writer.close
-    @reader.close
-    @output_writer.close
-    @config.reset
-    Reline.test_reset
-  end
-
-  def test_simple_input
-    @writer.write("abc\n")
-    assert_equal 'abc', Reline.readmultiline(&proc{ true })
-  end
-
-  def test_unknown_macro
-    @config.add_default_key_binding('abc'.bytes, :unknown_macro)
-    @writer.write("abcd\n")
-    assert_equal 'd', Reline.readmultiline(&proc{ true })
-  end
-
-  def test_macro_commands_for_moving
-    @config.add_default_key_binding("\C-x\C-a".bytes, :beginning_of_line)
-    @config.add_default_key_binding("\C-x\C-e".bytes, :end_of_line)
-    @config.add_default_key_binding("\C-x\C-f".bytes, :forward_char)
-    @config.add_default_key_binding("\C-x\C-b".bytes, :backward_char)
-    @config.add_default_key_binding("\C-x\ef".bytes, :forward_word)
-    @config.add_default_key_binding("\C-x\eb".bytes, :backward_word)
-    @writer.write(" def\C-x\C-aabc\C-x\C-e ghi\C-x\C-a\C-x\C-f\C-x\C-f_\C-x\C-b\C-x\C-b_\C-x\C-f\C-x\C-f\C-x\C-f\C-x\ef_\C-x\eb\n")
-    assert_equal 'a_b_c def_ ghi', Reline.readmultiline(&proc{ true })
-  end
-
-  def test_macro_commands_for_editing
-    @config.add_default_key_binding("\C-x\C-d".bytes, :delete_char)
-    @config.add_default_key_binding("\C-x\C-h".bytes, :backward_delete_char)
-    @config.add_default_key_binding("\C-x\C-v".bytes, :quoted_insert)
-    #@config.add_default_key_binding("\C-xa".bytes, :self_insert)
-    @config.add_default_key_binding("\C-x\C-t".bytes, :transpose_chars)
-    @config.add_default_key_binding("\C-x\et".bytes, :transpose_words)
-    @config.add_default_key_binding("\C-x\eu".bytes, :upcase_word)
-    @config.add_default_key_binding("\C-x\el".bytes, :downcase_word)
-    @config.add_default_key_binding("\C-x\ec".bytes, :capitalize_word)
-    @writer.write("abcde\C-b\C-b\C-b\C-x\C-d\C-x\C-h\C-x\C-v\C-a\C-f\C-f EF\C-x\C-t gh\C-x\et\C-b\C-b\C-b\C-b\C-b\C-b\C-b\C-b\C-x\eu\C-x\el\C-x\ec\n")
-    assert_equal "a\C-aDE gh Fe", Reline.readmultiline(&proc{ true })
-  end
-
-  def test_delete_text_in_multiline
-    @writer.write("abc\ndef\nxyz\n")
-    result = Reline.readmultiline(&proc{ |str|
-      if str.include?('xyz')
-        Reline.delete_text
-        true
-      else
-        false
-      end
-    })
-    assert_equal "abc\ndef", result
-  end
-end
diff --git a/test/mri/reline/windows/test_key_event_record.rb b/test/mri/reline/windows/test_key_event_record.rb
deleted file mode 100644
index 25c860606ac..00000000000
--- a/test/mri/reline/windows/test_key_event_record.rb
+++ /dev/null
@@ -1,41 +0,0 @@
-require_relative '../helper'
-return unless Reline.const_defined?(:Windows)
-
-class Reline::Windows
-  class KeyEventRecord::Test < Reline::TestCase
-
-    def setup
-      # Ctrl+A
-      @key = Reline::Windows::KeyEventRecord.new(0x41, 1, Reline::Windows::LEFT_CTRL_PRESSED)
-    end
-
-    def test_matches__with_no_arguments_raises_error
-      assert_raise(ArgumentError) { @key.match? }
-    end
-
-    def test_matches_char_code
-      assert @key.match?(char_code: 0x1)
-    end
-
-    def test_matches_virtual_key_code
-      assert @key.match?(virtual_key_code: 0x41)
-    end
-
-    def test_matches_control_keys
-      assert @key.match?(control_keys: :CTRL)
-    end
-
-    def test_doesnt_match_alt
-      refute @key.match?(control_keys: :ALT)
-    end
-
-    def test_doesnt_match_empty_control_key
-      refute @key.match?(control_keys: [])
-    end
-
-    def test_matches_control_keys_and_virtual_key_code
-      assert @key.match?(control_keys: :CTRL, virtual_key_code: 0x41)
-    end
-
-  end
-end
diff --git a/test/mri/reline/yamatanooroti/multiline_repl b/test/mri/reline/yamatanooroti/multiline_repl
deleted file mode 100755
index 4930f2e9d86..00000000000
--- a/test/mri/reline/yamatanooroti/multiline_repl
+++ /dev/null
@@ -1,255 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'bundler/setup'
-
-require 'reline'
-require 'optparse'
-require_relative 'termination_checker'
-
-opt = OptionParser.new
-opt.on('--dynamic-prompt') {
-  Reline.prompt_proc = proc { |lines|
-    lines.each_with_index.map { |l, i|
-      "\e[1m[%04d]>\e[m " % i
-    }
-  }
-}
-opt.on('--broken-dynamic-prompt') {
-  Reline.prompt_proc = proc { |lines|
-    range = lines.size > 1 ? (0..(lines.size - 2)) : (0..0)
-    lines[range].each_with_index.map { |l, i|
-      '[%04d]> ' % i
-    }
-  }
-}
-opt.on('--dynamic-prompt-returns-empty') {
-  Reline.prompt_proc = proc { |l| [] }
-}
-opt.on('--dynamic-prompt-with-newline') {
-  Reline.prompt_proc = proc { |lines|
-    range = lines.size > 1 ? (0..(lines.size - 2)) : (0..0)
-    lines[range].each_with_index.map { |l, i|
-      '[%04d\n]> ' % i
-    }
-  }
-}
-opt.on('--broken-dynamic-prompt-assert-no-escape-sequence') {
-  Reline.prompt_proc = proc { |lines|
-    has_escape_sequence = lines.join.include?("\e")
-    (lines.size + 1).times.map { |i|
-      has_escape_sequence ? 'error>' : '[%04d]> ' % i
-    }
-  }
-}
-opt.on('--color-bold') {
-  Reline.output_modifier_proc = ->(output, complete:){
-    output.gsub(/./) { |c| "\e[1m#{c}\e[0m" }
-  }
-}
-opt.on('--dynamic-prompt-show-line') {
-  Reline.prompt_proc = proc { |lines|
-    lines.map { |l|
-      '[%4.4s]> ' % l
-    }
-  }
-}
-
-def assert_auto_indent_params(lines, line_index, byte_pointer, is_newline)
-  raise 'Wrong lines type' unless lines.all?(String)
-
-  line = lines[line_index]
-  raise 'Wrong line_index value' unless line
-
-  # The condition `byte_pointer <= line.bytesize` is not satisfied. Maybe bug.
-  # Instead, loose constraint `byte_pointer <= line.bytesize + 1` seems to be satisfied when is_newline is false.
-  return if is_newline
-
-  raise 'byte_pointer out of bounds' unless byte_pointer <= line.bytesize + 1
-  raise 'Invalid byte_pointer' unless line.byteslice(0, byte_pointer).valid_encoding?
-end
-
-opt.on('--auto-indent') {
-  Reline.auto_indent_proc = lambda do |lines, line_index, byte_pointer, is_newline|
-    assert_auto_indent_params(lines, line_index, byte_pointer, is_newline)
-    AutoIndent.calculate_indent(lines, line_index, byte_pointer, is_newline)
-  end
-}
-opt.on('--dialog VAL') { |v|
-  Reline.add_dialog_proc(:simple_dialog, lambda {
-    return nil if v.include?('nil')
-    if v.include?('simple')
-      contents = <<~RUBY.split("\n")
-        Ruby is...
-        A dynamic, open source programming
-        language with a focus on simplicity
-        and productivity. It has an elegant
-        syntax that is natural to read and
-        easy to write.
-      RUBY
-    elsif v.include?('long')
-      contents = <<~RUBY.split("\n")
-        Ruby is...
-        A dynamic, open
-        source programming
-        language with a
-        focus on simplicity
-        and productivity.
-        It has an elegant
-        syntax that is
-        natural to read
-        and easy to write.
-      RUBY
-    elsif v.include?('fullwidth')
-      contents = <<~RUBY.split("\n")
-        Rubyとは...
-
-        オープンソースの動的なプログラミン
-        グ言語で、シンプルさと高い生産性を
-        備えています。エレガントな文法を持
-        ち、自然に読み書きができます。
-      RUBY
-    end
-    if v.include?('scrollkey')
-      dialog.trap_key = nil
-      if key and key.match?(dialog.name)
-        if dialog.pointer.nil?
-          dialog.pointer = 0
-        elsif dialog.pointer >= (contents.size - 1)
-          dialog.pointer = 0
-        else
-          dialog.pointer += 1
-        end
-      end
-      dialog.trap_key = [?j.ord]
-      height = 4
-    end
-    scrollbar = false
-    if v.include?('scrollbar')
-      scrollbar = true
-    end
-    if v.include?('alt-scrollbar')
-      scrollbar = true
-    end
-    Reline::DialogRenderInfo.new(pos: cursor_pos, contents: contents, height: height, scrollbar: scrollbar, face: :completion_dialog)
-  })
-  if v.include?('alt-scrollbar')
-    ENV['RELINE_ALT_SCROLLBAR'] = '1'
-  end
-}
-opt.on('--complete') {
-  Reline.completion_proc = lambda { |target, preposing = nil, postposing = nil|
-    %w{String ScriptError SyntaxError Signal}.select{ |c| c.start_with?(target) }
-  }
-}
-opt.on('--complete-menu-with-perfect-match') {
-  Reline.completion_proc = lambda { |target, preposing = nil, postposing = nil|
-    %w{abs abs2}.select{ |c| c.start_with?(target) }
-  }
-}
-opt.on('--autocomplete') {
-  Reline.autocompletion = true
-  Reline.completion_proc = lambda { |target, preposing = nil, postposing = nil|
-    %w{String Struct Symbol ScriptError SyntaxError Signal}.select{ |c| c.start_with?(target) }
-  }
-}
-opt.on('--autocomplete-empty') {
-  Reline.autocompletion = true
-  Reline.completion_proc = lambda { |target, preposing = nil, postposing = nil| [] }
-}
-opt.on('--autocomplete-long') {
-  Reline.autocompletion = true
-  Reline.completion_proc = lambda { |target, preposing = nil, postposing = nil|
-    %w{
-      String
-      Struct
-      Symbol
-      StopIteration
-      SystemCallError
-      SystemExit
-      SystemStackError
-      ScriptError
-      SyntaxError
-      Signal
-      SizedQueue
-      Set
-      SecureRandom
-      Socket
-      StringIO
-      StringScanner
-      Shellwords
-      Syslog
-      Singleton
-      SDBM
-    }.select{ |c| c.start_with?(target) }
-  }
-}
-opt.on('--autocomplete-super-long') {
-  Reline.autocompletion = true
-  Reline.completion_proc = lambda { |target, preposing = nil, postposing = nil|
-    c = +'A'
-    2000.times.map{ s = "Str_#{c}"; c.succ!; s }.select{ |c| c.start_with?(target) }
-  }
-}
-
-opt.on('--autocomplete-width-long') {
-  Reline.autocompletion = true
-  Reline.completion_proc = lambda { |target, preposing = nil, postposing = nil|
-    %w{
-        remove_instance_variable
-        respond_to?
-        ruby2_keywords
-        rand
-        readline
-        readlines
-        require
-        require_relative
-        raise
-        respond_to_missing?
-        redo
-        rescue
-        retry
-        return
-    }.select{ |c| c.start_with?(target) }
-  }
-}
-opt.parse!(ARGV)
-
-begin
-  stty_save = `stty -g`.chomp
-rescue
-end
-
-begin
-  prompt = ENV['RELINE_TEST_PROMPT'] || "\e[1mprompt>\e[m "
-  puts 'Multiline REPL.'
-  while code = Reline.readmultiline(prompt, true) { |code| TerminationChecker.terminated?(code) }
-    case code.chomp
-    when 'exit', 'quit', 'q'
-      exit 0
-    when ''
-      # NOOP
-    else
-      begin
-        result = eval(code)
-        puts "=> #{result.inspect}"
-      rescue ScriptError, StandardError => e
-        puts "Traceback (most recent call last):"
-        e.backtrace.reverse_each do |f|
-          puts "        #{f}"
-        end
-        puts e.message
-      end
-    end
-  end
-rescue Interrupt
-  puts '^C'
-  `stty #{stty_save}` if stty_save
-  exit 0
-ensure
-  `stty #{stty_save}` if stty_save
-end
-begin
-  puts
-rescue Errno::EIO
-  # Maybe the I/O has been closed.
-end
diff --git a/test/mri/reline/yamatanooroti/termination_checker.rb b/test/mri/reline/yamatanooroti/termination_checker.rb
deleted file mode 100644
index b97c798c593..00000000000
--- a/test/mri/reline/yamatanooroti/termination_checker.rb
+++ /dev/null
@@ -1,26 +0,0 @@
-require 'ripper'
-
-module TerminationChecker
-  def self.terminated?(code)
-    Ripper.sexp(code) ? true : false
-  end
-end
-
-module AutoIndent
-  def self.calculate_indent(lines, line_index, byte_pointer, is_newline)
-    if is_newline
-      2 * nesting_level(lines[0..line_index - 1])
-    else
-      lines = lines.dup
-      lines[line_index] = lines[line_index]&.byteslice(0, byte_pointer)
-      prev_level = nesting_level(lines[0..line_index - 1])
-      level = nesting_level(lines[0..line_index])
-      2 * level if level < prev_level
-    end
-  end
-
-  def self.nesting_level(lines)
-    code = lines.join("\n")
-    code.scan(/if|def|$|\[|\{/).size - code.scan(/end|$|\]|\}/).size
-  end
-end
diff --git a/test/mri/reline/yamatanooroti/test_rendering.rb b/test/mri/reline/yamatanooroti/test_rendering.rb
deleted file mode 100644
index 008ff4a5e22..00000000000
--- a/test/mri/reline/yamatanooroti/test_rendering.rb
+++ /dev/null
@@ -1,1959 +0,0 @@
-require 'reline'
-
-begin
-  require 'yamatanooroti'
-
-  class Reline::RenderingTest < Yamatanooroti::TestCase
-
-    FACE_CONFIGS = { no_config: "", valid_config: <<~VALID_CONFIG, incomplete_config: <<~INCOMPLETE_CONFIG }
-      require "reline"
-      Reline::Face.config(:completion_dialog) do |face|
-        face.define :default, foreground: :white, background: :blue
-        face.define :enhanced, foreground: :white, background: :magenta
-        face.define :scrollbar, foreground: :white, background: :blue
-      end
-    VALID_CONFIG
-      require "reline"
-      Reline::Face.config(:completion_dialog) do |face|
-        face.define :default, foreground: :white, background: :black
-        face.define :scrollbar, foreground: :white, background: :cyan
-      end
-    INCOMPLETE_CONFIG
-
-    def iterate_over_face_configs(&block)
-      FACE_CONFIGS.each do |config_name, face_config|
-        config_file = Tempfile.create(%w{face_config- .rb})
-        config_file.write face_config
-        block.call(config_name, config_file)
-      ensure
-        config_file.close
-        File.delete(config_file)
-      end
-    end
-
-    def setup
-      @pwd = Dir.pwd
-      suffix = '%010d' % Random.rand(0..65535)
-      @tmpdir = File.join(File.expand_path(Dir.tmpdir), "test_reline_config_#{$$}_#{suffix}")
-      begin
-        Dir.mkdir(@tmpdir)
-      rescue Errno::EEXIST
-        FileUtils.rm_rf(@tmpdir)
-        Dir.mkdir(@tmpdir)
-      end
-      @inputrc_backup = ENV['INPUTRC']
-      @inputrc_file = ENV['INPUTRC'] = File.join(@tmpdir, 'temporaty_inputrc')
-      File.unlink(@inputrc_file) if File.exist?(@inputrc_file)
-    end
-
-    def teardown
-      FileUtils.rm_rf(@tmpdir)
-      ENV['INPUTRC'] = @inputrc_backup
-      ENV.delete('RELINE_TEST_PROMPT') if ENV['RELINE_TEST_PROMPT']
-    end
-
-    # Yamatanooroti::TestCase#write converts 0x80-0xff bytes to "\e"+(byte&0x7f).chr
-    # This method avoids the conversion and writes the string as is.
-    def write_without_meta_conversion(str)
-      sync
-      @pty_input.write(str)
-      try_sync
-    end
-
-    def test_history_back
-      start_terminal(5, 30, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl}, startup_message: 'Multiline REPL.')
-      write(":a\n")
-      write("\C-p")
-      assert_screen(<<~EOC)
-        Multiline REPL.
-        prompt> :a
-        => :a
-        prompt> :a
-      EOC
-      close
-    end
-
-    def test_backspace
-      start_terminal(5, 30, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl}, startup_message: 'Multiline REPL.')
-      write(":abc\C-h\n")
-      assert_screen(<<~EOC)
-        Multiline REPL.
-        prompt> :ab
-        => :ab
-        prompt>
-      EOC
-      close
-    end
-
-    def test_autowrap
-      start_terminal(5, 30, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl}, startup_message: 'Multiline REPL.')
-      write('01234567890123456789012')
-      assert_screen(<<~EOC)
-        Multiline REPL.
-        prompt> 0123456789012345678901
-        2
-      EOC
-      close
-    end
-
-    def test_fullwidth
-      start_terminal(5, 30, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl}, startup_message: 'Multiline REPL.')
-      write(":あ\n")
-      assert_screen(<<~EOC)
-        Multiline REPL.
-        prompt> :あ
-        => :あ
-        prompt>
-      EOC
-      close
-    end
-
-    def test_two_fullwidth
-      start_terminal(5, 30, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl}, startup_message: 'Multiline REPL.')
-      write(":あい\n")
-      assert_screen(<<~EOC)
-        Multiline REPL.
-        prompt> :あい
-        => :あい
-        prompt>
-      EOC
-      close
-    end
-
-    def test_finish_autowrapped_line
-      start_terminal(10, 40, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl}, startup_message: 'Multiline REPL.')
-      write("[{'user'=>{'email'=>'a@a', 'id'=>'ABC'}, 'version'=>4, 'status'=>'succeeded'}]\n")
-      expected = [{'user'=>{'email'=>'a@a', 'id'=>'ABC'}, 'version'=>4, 'status'=>'succeeded'}].inspect
-      assert_screen(<<~EOC)
-        Multiline REPL.
-        prompt> [{'user'=>{'email'=>'a@a', 'id'=
-        >'ABC'}, 'version'=>4, 'status'=>'succee
-        ded'}]
-        #{fold_multiline("=> " + expected, 40)}
-        prompt>
-      EOC
-      close
-    end
-
-    def test_finish_autowrapped_line_in_the_middle_of_lines
-      start_terminal(20, 30, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl}, startup_message: 'Multiline REPL.')
-      write("[{'user'=>{'email'=>'abcdef@abcdef', 'id'=>'ABC'}, 'version'=>4, 'status'=>'succeeded'}]#{"\C-b"*7}")
-      write("\n")
-      expected = [{'user'=>{'email'=>'abcdef@abcdef', 'id'=>'ABC'}, 'version'=>4, 'status'=>'succeeded'}].inspect
-      assert_screen(<<~EOC)
-        Multiline REPL.
-        prompt> [{'user'=>{'email'=>'a
-        bcdef@abcdef', 'id'=>'ABC'}, '
-        version'=>4, 'status'=>'succee
-        ded'}]
-        #{fold_multiline("=> " + expected, 30)}
-        prompt>
-      EOC
-      close
-    end
-
-    def test_finish_autowrapped_line_in_the_middle_of_multilines
-      omit if RUBY_VERSION < '2.7'
-      start_terminal(30, 16, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl}, startup_message: 'Multiline REPL.')
-      write("<<~EOM\n  ABCDEFG\nEOM\n")
-      assert_screen(<<~'EOC')
-        Multiline REPL.
-        prompt> <<~EOM
-        prompt>   ABCDEF
-        G
-        prompt> EOM
-        => "ABCDEFG\n"
-        prompt>
-      EOC
-      close
-    end
-
-    def test_prompt
-      write_inputrc <<~'LINES'
-        "abc": "123"
-      LINES
-      start_terminal(5, 30, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl}, startup_message: 'Multiline REPL.')
-      write("abc\n")
-      assert_screen(<<~EOC)
-        Multiline REPL.
-        prompt> 123
-        => 123
-        prompt>
-      EOC
-      close
-    end
-
-    def test_mode_string_emacs
-      write_inputrc <<~LINES
-        set show-mode-in-prompt on
-      LINES
-      start_terminal(5, 30, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl}, startup_message: 'Multiline REPL.')
-      assert_screen(<<~EOC)
-        Multiline REPL.
-        @prompt>
-      EOC
-      close
-    end
-
-    def test_mode_string_vi
-      write_inputrc <<~LINES
-        set editing-mode vi
-        set show-mode-in-prompt on
-      LINES
-      start_terminal(5, 30, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl}, startup_message: 'Multiline REPL.')
-      write(":a\n\C-[k")
-      write("i\n:a")
-      write("\C-[h")
-      assert_screen(<<~EOC)
-        (ins)prompt> :a
-        => :a
-        (ins)prompt> :a
-        => :a
-        (cmd)prompt> :a
-      EOC
-      close
-    end
-
-    def test_original_mode_string_emacs
-      write_inputrc <<~LINES
-        set show-mode-in-prompt on
-        set emacs-mode-string [emacs]
-      LINES
-      start_terminal(5, 30, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl}, startup_message: 'Multiline REPL.')
-      assert_screen(<<~EOC)
-        Multiline REPL.
-        [emacs]prompt>
-      EOC
-      close
-    end
-
-    def test_original_mode_string_with_quote
-      write_inputrc <<~LINES
-        set show-mode-in-prompt on
-        set emacs-mode-string "[emacs]"
-      LINES
-      start_terminal(5, 30, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl}, startup_message: 'Multiline REPL.')
-      assert_screen(<<~EOC)
-        Multiline REPL.
-        [emacs]prompt>
-      EOC
-      close
-    end
-
-    def test_original_mode_string_vi
-      write_inputrc <<~LINES
-        set editing-mode vi
-        set show-mode-in-prompt on
-        set vi-ins-mode-string "{InS}"
-        set vi-cmd-mode-string "{CmD}"
-      LINES
-      start_terminal(5, 30, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl}, startup_message: 'Multiline REPL.')
-      write(":a\n\C-[k")
-      assert_screen(<<~EOC)
-        Multiline REPL.
-        {InS}prompt> :a
-        => :a
-        {CmD}prompt> :a
-      EOC
-      close
-    end
-
-    def test_mode_string_vi_changing
-      write_inputrc <<~LINES
-        set editing-mode vi
-        set show-mode-in-prompt on
-      LINES
-      start_terminal(5, 30, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl}, startup_message: 'Multiline REPL.')
-      write(":a\C-[ab\C-[ac\C-h\C-h\C-h\C-h:a")
-      assert_screen(<<~EOC)
-        Multiline REPL.
-        (ins)prompt> :a
-      EOC
-      close
-    end
-
-    def test_esc_input
-      omit if Reline::IOGate.win?
-      start_terminal(5, 20, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl}, startup_message: 'Multiline REPL.')
-      write("def\C-aabc")
-      write("\e") # single ESC
-      sleep 1
-      write("A")
-      write("B\eAC") # ESC + A (M-A, no key specified in Reline::KeyActor::Emacs)
-      assert_screen(<<~EOC)
-        Multiline REPL.
-        prompt> abcABCdef
-      EOC
-      close
-    end
-
-    def test_prompt_with_escape_sequence
-      ENV['RELINE_TEST_PROMPT'] = "\1\e[30m\2prompt> \1\e[m\2"
-      start_terminal(5, 20, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl}, startup_message: 'Multiline REPL.')
-      write("123\n")
-      assert_screen(<<~EOC)
-        Multiline REPL.
-        prompt> 123
-        => 123
-        prompt>
-      EOC
-      close
-    end
-
-    def test_prompt_with_escape_sequence_and_autowrap
-      ENV['RELINE_TEST_PROMPT'] = "\1\e[30m\2prompt> \1\e[m\2"
-      start_terminal(5, 20, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl}, startup_message: 'Multiline REPL.')
-      write("1234567890123\n")
-      assert_screen(<<~EOC)
-        Multiline REPL.
-        prompt> 123456789012
-        3
-        => 1234567890123
-        prompt>
-      EOC
-      close
-    end
-
-    def test_readline_with_multiline_input
-      start_terminal(5, 50, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl --dynamic-prompt}, startup_message: 'Multiline REPL.')
-      write("def foo\n  bar\nend\n")
-      write("Reline.readline('prompt> ')\n")
-      write("\C-p\C-p")
-      assert_screen(<<~EOC)
-        => :foo
-        [0000]> Reline.readline('prompt> ')
-        prompt> def foo
-          bar
-        end
-      EOC
-      close
-    end
-
-    def test_multiline_and_autowrap
-      start_terminal(10, 20, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl}, startup_message: 'Multiline REPL.')
-      write("def aaaaaaaaaa\n  33333333\n           end\C-a\C-pputs\C-e\e\C-m888888888888888")
-      assert_screen(<<~EOC)
-        Multiline REPL.
-        prompt> def aaaaaaaa
-        aa
-        prompt> puts  333333
-        33
-        prompt> 888888888888
-        888
-        prompt>            e
-        nd
-      EOC
-      close
-    end
-
-    def test_multiline_add_new_line_and_autowrap
-      start_terminal(10, 20, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl}, startup_message: 'Multiline REPL.')
-      write("def aaaaaaaaaa")
-      write("\n")
-      write("  bbbbbbbbbbbb")
-      write("\n")
-      assert_screen(<<~EOC)
-        Multiline REPL.
-        prompt> def aaaaaaaa
-        aa
-        prompt>   bbbbbbbbbb
-        bb
-        prompt>
-      EOC
-      close
-    end
-
-    def test_clear
-      start_terminal(10, 15, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl}, startup_message: 'Multiline REPL.')
-      write("3\C-l")
-      assert_screen(<<~EOC)
-        prompt> 3
-      EOC
-      close
-    end
-
-    def test_clear_multiline_and_autowrap
-      start_terminal(10, 15, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl}, startup_message: 'Multiline REPL.')
-      write("def aaaaaa\n  3\n\C-lend")
-      assert_screen(<<~EOC)
-        prompt> def aaa
-        aaa
-        prompt>   3
-        prompt> end
-      EOC
-      close
-    end
-
-    def test_nearest_cursor
-      start_terminal(10, 20, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl}, startup_message: 'Multiline REPL.')
-      write("def ああ\n  :いい\nend\C-pbb\C-pcc")
-      assert_screen(<<~EOC)
-        Multiline REPL.
-        prompt> def ccああ
-        prompt>   :bbいい
-        prompt> end
-      EOC
-      close
-    end
-
-    def test_delete_line
-      start_terminal(10, 20, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl}, startup_message: 'Multiline REPL.')
-      write("def a\n\nend\C-p\C-h")
-      assert_screen(<<~EOC)
-        Multiline REPL.
-        prompt> def a
-        prompt> end
-      EOC
-      close
-    end
-
-    def test_last_line_of_screen
-      start_terminal(5, 20, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl}, startup_message: 'Multiline REPL.')
-      write("\n\n\n\n\ndef a\nend")
-      assert_screen(<<~EOC)
-        prompt>
-        prompt>
-        prompt>
-        prompt> def a
-        prompt> end
-      EOC
-      close
-    end
-
-    # c17a09b7454352e2aff5a7d8722e80afb73e454b
-    def test_autowrap_at_last_line_of_screen
-      start_terminal(5, 15, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl}, startup_message: 'Multiline REPL.')
-      write("def a\nend\n\C-p")
-      assert_screen(<<~EOC)
-        prompt> def a
-        prompt> end
-        => :a
-        prompt> def a
-        prompt> end
-      EOC
-      close
-    end
-
-    # f002483b27cdb325c5edf9e0fe4fa4e1c71c4b0e
-    def test_insert_line_in_the_middle_of_line
-      start_terminal(5, 20, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl}, startup_message: 'Multiline REPL.')
-      write("333\C-b\C-b\e\C-m8")
-      assert_screen(<<~EOC)
-        Multiline REPL.
-        prompt> 3
-        prompt> 833
-      EOC
-      close
-    end
-
-    # 9d8978961c5de5064f949d56d7e0286df9e18f43
-    def test_insert_line_in_the_middle_of_line_at_last_line_of_screen
-      start_terminal(3, 20, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl}, startup_message: 'Multiline REPL.')
-      write("333333333333333\C-a\C-f\e\C-m")
-      assert_screen(<<~EOC)
-        prompt> 3
-        prompt> 333333333333
-        33
-      EOC
-      close
-    end
-
-    def test_insert_after_clear
-      start_terminal(10, 20, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl}, startup_message: 'Multiline REPL.')
-      write("def a\n  01234\nend\C-l\C-p5678")
-      assert_screen(<<~EOC)
-        prompt> def a
-        prompt>   056781234
-        prompt> end
-      EOC
-      close
-    end
-
-    def test_foced_newline_insertion
-      start_terminal(10, 20, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl}, startup_message: 'Multiline REPL.')
-      #write("def a\nend\C-p\C-e\e\C-m  3")
-      write("def a\nend\C-p\C-e\e\x0D")
-      assert_screen(<<~EOC)
-        Multiline REPL.
-        prompt> def a
-        prompt>
-        prompt> end
-      EOC
-      close
-    end
-
-    def test_multiline_incremental_search
-      start_terminal(6, 25, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl}, startup_message: 'Multiline REPL.')
-      write("def a\n  8\nend\ndef b\n  3\nend\C-s8")
-      assert_screen(<<~EOC)
-        prompt>   8
-        prompt> end
-        => :a
-        (i-search)`8'def a
-        (i-search)`8'  8
-        (i-search)`8'end
-      EOC
-      close
-    end
-
-    def test_multiline_incremental_search_finish
-      start_terminal(6, 25, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl}, startup_message: 'Multiline REPL.')
-      write("def a\n  8\nend\ndef b\n  3\nend\C-r8\C-j")
-      assert_screen(<<~EOC)
-        prompt>   8
-        prompt> end
-        => :a
-        prompt> def a
-        prompt>   8
-        prompt> end
-      EOC
-      close
-    end
-
-    def test_binding_for_vi_movement_mode
-      write_inputrc <<~LINES
-        set editing-mode vi
-        "\\C-a": vi-movement-mode
-      LINES
-      start_terminal(5, 30, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl}, startup_message: 'Multiline REPL.')
-      write(":1234\C-ahhhi0")
-      assert_screen(<<~EOC)
-        Multiline REPL.
-        prompt> :01234
-      EOC
-      close
-    end
-
-    def test_broken_prompt_list
-      start_terminal(5, 30, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl --broken-dynamic-prompt}, startup_message: 'Multiline REPL.')
-      write("def hoge\n  3\nend")
-      assert_screen(<<~EOC)
-        Multiline REPL.
-        [0000]> def hoge
-        [0001]>   3
-        [0001]> end
-      EOC
-      close
-    end
-
-    def test_no_escape_sequence_passed_to_dynamic_prompt
-      start_terminal(10, 30, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl  --autocomplete --color-bold --broken-dynamic-prompt-assert-no-escape-sequence}, startup_message: 'Multiline REPL.')
-      write("%[ S")
-      write("\n")
-      assert_screen(<<~EOC)
-        Multiline REPL.
-        [0000]> %[ S
-        [0001]>
-      EOC
-      close
-    end
-
-    def test_bracketed_paste
-      omit if Reline.core.io_gate.win?
-      start_terminal(5, 30, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl}, startup_message: 'Multiline REPL.')
-      write("\e[200~def hoge\r\t3\rend\e[201~")
-      assert_screen(<<~EOC)
-        Multiline REPL.
-        prompt> def hoge
-        prompt>   3
-        prompt> end
-      EOC
-      write("\e[200~.tap do\r\t4\r\t5\rend\e[201~")
-      assert_screen(<<~EOC)
-        prompt>   3
-        prompt> end.tap do
-        prompt>   4
-        prompt>   5
-        prompt> end
-      EOC
-      close
-    end
-
-    def test_ctrl_v_escaped_input
-      omit if Reline.core.io_gate.win?
-
-      start_terminal(5, 30, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl}, startup_message: 'Multiline REPL.')
-
-      # When a configuration "Escape non-ASCII Input with Control-V" is enabled
-      # in macOS Termina.app, all non-ascii characters are escaped with ^V.
-      write_without_meta_conversion "\C-v\xE3\C-v\x81\C-v\x82"
-      assert_screen(/prompt> あ/)
-
-      # Bracketed pasted content is also escaped
-      write_without_meta_conversion "\e[200~\C-a\C-v\xE3\C-v\x81\C-v\x84\C-b\e[201~"
-      assert_screen(/prompt> あ\^Aい\^B/)
-
-      # Invalid bytes should be ignored with timeout
-      write_without_meta_conversion "\C-v\x82\C-v\xA4"
-      sleep 1
-      write 'C'
-      assert_screen(/prompt> あ\^Aい\^BC/)
-    end
-
-    def test_bracketed_paste_with_undo_redo
-      omit if Reline.core.io_gate.win?
-      start_terminal(5, 30, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl}, startup_message: 'Multiline REPL.')
-      write("abc")
-      write("\e[200~def hoge\r\t3\rend\e[201~")
-      write("\C-_")
-      assert_screen(<<~EOC)
-        Multiline REPL.
-        prompt> abc
-      EOC
-      write("\e\C-_")
-      assert_screen(<<~EOC)
-        Multiline REPL.
-        prompt> abcdef hoge
-        prompt>   3
-        prompt> end
-      EOC
-      close
-    end
-
-    def test_backspace_until_returns_to_initial
-      start_terminal(5, 30, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl}, startup_message: 'Multiline REPL.')
-      write("ABC")
-      write("\C-h\C-h\C-h")
-      assert_screen(<<~EOC)
-        Multiline REPL.
-        prompt>
-      EOC
-      close
-    end
-
-    def test_longer_than_screen_height
-      start_terminal(5, 30, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl}, startup_message: 'Multiline REPL.')
-      write(<<~EOC.chomp)
-        def each_top_level_statement
-          initialize_input
-          catch(:TERM_INPUT) do
-            loop do
-              begin
-                prompt
-                unless l = lex
-                  throw :TERM_INPUT if @line == ''
-                else
-                  @line_no += l.count("\n")
-                  next if l == "\n"
-                  @line.concat l
-                  if @code_block_open or @ltype or @continue or @indent > 0
-                    next
-                  end
-                end
-                if @line != "\n"
-                  @line.force_encoding(@io.encoding)
-                  yield @line, @exp_line_no
-                end
-                break if @io.eof?
-                @line = ''
-                @exp_line_no = @line_no
-                #
-                @indent = 0
-              rescue TerminateLineInput
-                initialize_input
-                prompt
-              end
-            end
-          end
-        end
-      EOC
-      assert_screen(<<~EOC)
-        prompt>         prompt
-        prompt>       end
-        prompt>     end
-        prompt>   end
-        prompt> end
-      EOC
-      write("\C-p" * 6)
-      assert_screen(<<~EOC)
-        prompt>       rescue Terminate
-        LineInput
-        prompt>         initialize_inp
-        ut
-        prompt>         prompt
-      EOC
-      write("\C-n" * 4)
-      assert_screen(<<~EOC)
-        prompt>         initialize_inp
-        ut
-        prompt>         prompt
-        prompt>       end
-        prompt>     end
-      EOC
-      close
-    end
-
-    def test_longer_than_screen_height_nearest_cursor_with_scroll_back
-      start_terminal(5, 30, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl}, startup_message: 'Multiline REPL.')
-      write(<<~EOC.chomp)
-        if 1
-          if 2
-            if 3
-              if 4
-                puts
-              end
-            end
-          end
-        end
-      EOC
-      write("\C-p" * 4 + "\C-e" + "\C-p" * 4)
-      write("2")
-      assert_screen(<<~EOC)
-        prompt> if 12
-        prompt>   if 2
-        prompt>     if 3
-        prompt>       if 4
-        prompt>         puts
-      EOC
-      close
-    end
-
-    def test_update_cursor_correctly_when_just_cursor_moving
-      start_terminal(5, 30, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl}, startup_message: 'Multiline REPL.')
-      write("def hoge\n  01234678")
-      write("\C-p")
-      write("\C-b")
-      write("\C-n")
-      write('5')
-      write("\C-e")
-      write('9')
-      assert_screen(<<~EOC)
-        Multiline REPL.
-        prompt> def hoge
-        prompt>   0123456789
-      EOC
-      close
-    end
-
-    def test_auto_indent
-      start_terminal(10, 30, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl --auto-indent}, startup_message: 'Multiline REPL.')
-      "def hoge\nputs(\n1,\n2\n)\nend".lines do |line|
-        write line
-      end
-      assert_screen(<<~EOC)
-        Multiline REPL.
-        prompt> def hoge
-        prompt>   puts(
-        prompt>     1,
-        prompt>     2
-        prompt>   )
-        prompt> end
-      EOC
-      close
-    end
-
-    def test_auto_indent_when_inserting_line
-      start_terminal(5, 30, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl --auto-indent}, startup_message: 'Multiline REPL.')
-      write 'aa(bb(cc(dd(ee('
-      write "\C-b" * 5 + "\n"
-      assert_screen(<<~EOC)
-        Multiline REPL.
-        prompt> aa(bb(cc(d
-        prompt>       d(ee(
-      EOC
-      close
-    end
-
-    def test_auto_indent_multibyte_insert_line
-      start_terminal(10, 30, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl --auto-indent}, startup_message: 'Multiline REPL.')
-      write "if true\n"
-      write "あいうえお\n"
-      4.times { write "\C-b\C-b\C-b\C-b\e\r" }
-      assert_screen(<<~EOC)
-        Multiline REPL.
-        prompt> if true
-        prompt>   あ
-        prompt>   い
-        prompt>   う
-        prompt>   え
-        prompt>   お
-        prompt>
-      EOC
-      close
-    end
-
-    def test_newline_after_wrong_indent
-      start_terminal(5, 30, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl --auto-indent}, startup_message: 'Multiline REPL.')
-      write "if 1\n    aa"
-      write "\n"
-      assert_screen(<<~EOC)
-        Multiline REPL.
-        prompt> if 1
-        prompt>   aa
-        prompt>
-      EOC
-      close
-    end
-
-    def test_suppress_auto_indent_just_after_pasted
-      start_terminal(5, 30, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl --auto-indent}, startup_message: 'Multiline REPL.')
-      write("def hoge\n  [[\n      3]]\ned")
-      write("\C-bn")
-      assert_screen(<<~EOC)
-        Multiline REPL.
-        prompt> def hoge
-        prompt>   [[
-        prompt>       3]]
-        prompt> end
-      EOC
-      close
-    end
-
-    def test_suppress_auto_indent_for_adding_newlines_in_pasting
-      start_terminal(5, 30, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl --auto-indent}, startup_message: 'Multiline REPL.')
-      write("<<~Q\n")
-      write("{\n  #\n}")
-      write("#")
-      assert_screen(<<~EOC)
-        Multiline REPL.
-        prompt> <<~Q
-        prompt> {
-        prompt>   #
-        prompt> }#
-      EOC
-      close
-    end
-
-    def test_auto_indent_with_various_spaces
-      start_terminal(5, 30, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl --auto-indent}, startup_message: 'Multiline REPL.')
-      write "(\n\C-v"
-      write "\C-k\n\C-v"
-      write "\C-k)"
-      assert_screen(<<~EOC)
-        Multiline REPL.
-        prompt> (
-        prompt> ^K
-        prompt> )
-      EOC
-      close
-    end
-
-    def test_autowrap_in_the_middle_of_a_line
-      start_terminal(5, 20, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl}, startup_message: 'Multiline REPL.')
-      write("def abcdefg; end\C-b\C-b\C-b\C-b\C-b")
-      %w{h i}.each do |c|
-        write(c)
-      end
-      assert_screen(<<~EOC)
-        Multiline REPL.
-        prompt> def abcdefgh
-        i; end
-      EOC
-      close
-    end
-
-    def test_newline_in_the_middle_of_lines
-      start_terminal(5, 20, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl}, startup_message: 'Multiline REPL.')
-      write("def hoge\n  1\n  2\n  3\n  4\nend\n")
-      write("\C-p\C-p\C-p\C-e\n")
-      assert_screen(<<~EOC)
-        prompt> def hoge
-        prompt>   1
-        prompt>   2
-        prompt>   3
-        prompt>
-      EOC
-      close
-    end
-
-    def test_ed_force_submit_in_the_middle_of_lines
-      write_inputrc <<~LINES
-        "\\C-a": ed_force_submit
-      LINES
-      start_terminal(5, 20, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl}, startup_message: 'Multiline REPL.')
-      write("def hoge\nend")
-      write("\C-p\C-a")
-      assert_screen(<<~EOC)
-        Multiline REPL.
-        prompt> def hoge
-        prompt> end
-        => :hoge
-        prompt>
-      EOC
-      close
-    end
-
-    def test_dynamic_prompt_returns_empty
-      start_terminal(5, 20, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl --dynamic-prompt-returns-empty}, startup_message: 'Multiline REPL.')
-      write("def hoge\nend\n")
-      assert_screen(<<~EOC)
-        Multiline REPL.
-        prompt> def hoge
-        prompt> end
-        => :hoge
-        prompt>
-      EOC
-      close
-    end
-
-    def test_reset_rest_height_when_clear_screen
-      start_terminal(5, 20, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl}, startup_message: 'Multiline REPL.')
-      write("\n\n\n\C-l3\n")
-      assert_screen(<<~EOC)
-        prompt> 3
-        => 3
-        prompt>
-      EOC
-      close
-    end
-
-    def test_meta_key
-      start_terminal(30, 20, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl}, startup_message: 'Multiline REPL.')
-      write("def ge\ebho")
-      assert_screen(<<~EOC)
-        Multiline REPL.
-        prompt> def hoge
-      EOC
-      close
-    end
-
-    def test_not_meta_key
-      start_terminal(5, 30, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl}, startup_message: 'Multiline REPL.')
-      write("おだんご") # "だ" in UTF-8 contains "\xA0"
-      assert_screen(<<~EOC)
-        Multiline REPL.
-        prompt> おだんご
-      EOC
-      close
-    end
-
-    def test_force_enter
-      start_terminal(30, 120, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl}, startup_message: 'Multiline REPL.')
-      write("def hoge\nend\C-p\C-e")
-      write("\e\x0D")
-      assert_screen(<<~EOC)
-        Multiline REPL.
-        prompt> def hoge
-        prompt>
-        prompt> end
-      EOC
-      close
-    end
-
-    def test_nontty
-      omit if Reline.core.io_gate.win?
-      cmd = %Q{ruby -e 'puts(%Q{ello\C-ah\C-e})' | ruby -I#{@pwd}/lib -rreline -e 'p Reline.readline(%{> })' | ruby -e 'print STDIN.read'}
-      start_terminal(40, 50, ['bash', '-c', cmd])
-      assert_screen(<<~'EOC')
-        > hello
-        "hello"
-      EOC
-      close
-    end
-
-    def test_eof_with_newline
-      omit if Reline.core.io_gate.win?
-      cmd = %Q{ruby -e 'print(%Q{abc def \\e\\r})' | ruby -I#{@pwd}/lib -rreline -e 'p Reline.readline(%{> })'}
-      start_terminal(40, 50, ['bash', '-c', cmd])
-      assert_screen(<<~'EOC')
-        > abc def
-        "abc def "
-      EOC
-      close
-    end
-
-    def test_eof_without_newline
-      omit if Reline.core.io_gate.win?
-      cmd = %Q{ruby -e 'print(%{hello})' | ruby -I#{@pwd}/lib -rreline -e 'p Reline.readline(%{> })'}
-      start_terminal(40, 50, ['bash', '-c', cmd])
-      assert_screen(<<~'EOC')
-        > hello
-        "hello"
-      EOC
-      close
-    end
-
-    def test_em_set_mark_and_em_exchange_mark
-      start_terminal(10, 50, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl}, startup_message: 'Multiline REPL.')
-      write("aaa bbb ccc ddd\eb\eb\e\x20\eb\C-x\C-xX\C-x\C-xY")
-      assert_screen(<<~'EOC')
-        Multiline REPL.
-        prompt> aaa Ybbb Xccc ddd
-      EOC
-      close
-    end
-
-    def test_multiline_completion
-      start_terminal(10, 50, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl --complete}, startup_message: 'Multiline REPL.')
-      write("def hoge\n  St\n  St\C-p\t")
-      assert_screen(<<~'EOC')
-        Multiline REPL.
-        prompt> def hoge
-        prompt>   String
-        prompt>   St
-      EOC
-      close
-    end
-
-    def test_completion_journey_2nd_line
-      write_inputrc <<~LINES
-        set editing-mode vi
-      LINES
-      start_terminal(10, 50, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl --complete}, startup_message: 'Multiline REPL.')
-      write("def hoge\n  S\C-n")
-      assert_screen(<<~'EOC')
-        Multiline REPL.
-        prompt> def hoge
-        prompt>   String
-      EOC
-      close
-    end
-
-    def test_completion_journey_with_empty_line
-      write_inputrc <<~LINES
-        set editing-mode vi
-      LINES
-      start_terminal(10, 50, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl --complete}, startup_message: 'Multiline REPL.')
-      write("\C-n\C-p")
-      assert_screen(<<~'EOC')
-        Multiline REPL.
-        prompt>
-      EOC
-      close
-    end
-
-    def test_completion_menu_is_displayed_horizontally
-      start_terminal(20, 50, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl --complete}, startup_message: 'Multiline REPL.')
-      write("S\t\t")
-      assert_screen(<<~'EOC')
-        Multiline REPL.
-        prompt> S
-        ScriptError  String
-        Signal       SyntaxError
-      EOC
-      close
-    end
-
-    def test_show_all_if_ambiguous_on
-      write_inputrc <<~LINES
-        set show-all-if-ambiguous on
-      LINES
-      start_terminal(20, 50, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl --complete}, startup_message: 'Multiline REPL.')
-      write("S\t")
-      assert_screen(<<~'EOC')
-        Multiline REPL.
-        prompt> S
-        ScriptError  String
-        Signal       SyntaxError
-      EOC
-      close
-    end
-
-    def test_show_all_if_ambiguous_on_and_menu_with_perfect_match
-      write_inputrc <<~LINES
-        set show-all-if-ambiguous on
-      LINES
-      start_terminal(20, 50, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl --complete-menu-with-perfect-match}, startup_message: 'Multiline REPL.')
-      write("a\t")
-      assert_screen(<<~'EOC')
-        Multiline REPL.
-        prompt> abs
-        abs   abs2
-      EOC
-      close
-    end
-
-    def test_simple_dialog
-      iterate_over_face_configs do |config_name, config_file|
-        start_terminal(20, 50, %W{ruby -I#{@pwd}/lib -r#{config_file.path} #{@pwd}/test/reline/yamatanooroti/multiline_repl --dialog simple}, startup_message: 'Multiline REPL.')
-        write('a')
-        write('b')
-        write('c')
-        write("\C-h")
-        close
-        assert_screen(<<~'EOC', "Failed with `#{config_name}` in Face")
-          Multiline REPL.
-          prompt> ab
-                    Ruby is...
-                    A dynamic, open source programming
-                    language with a focus on simplicity
-                    and productivity. It has an elegant
-                    syntax that is natural to read and
-                    easy to write.
-        EOC
-      end
-    end
-
-    def test_simple_dialog_at_right_edge
-      iterate_over_face_configs do |config_name, config_file|
-        start_terminal(20, 40, %W{ruby -I#{@pwd}/lib -r#{config_file.path} #{@pwd}/test/reline/yamatanooroti/multiline_repl --dialog simple}, startup_message: 'Multiline REPL.')
-        write('a')
-        write('b')
-        write('c')
-        write("\C-h")
-        close
-        assert_screen(<<~'EOC')
-          Multiline REPL.
-          prompt> ab
-               Ruby is...
-               A dynamic, open source programming
-               language with a focus on simplicity
-               and productivity. It has an elegant
-               syntax that is natural to read and
-               easy to write.
-        EOC
-      end
-    end
-
-    def test_dialog_scroll_pushup_condition
-      iterate_over_face_configs do |config_name, config_file|
-        start_terminal(10, 50, %W{ruby -I#{@pwd}/lib -r#{config_file.path} #{@pwd}/test/reline/yamatanooroti/multiline_repl --autocomplete}, startup_message: 'Multiline REPL.')
-        write("\n" * 10)
-        write("if 1\n  sSts\nend")
-        write("\C-p\C-h\C-e\C-h")
-        assert_screen(<<~'EOC')
-          prompt>
-          prompt>
-          prompt>
-          prompt>
-          prompt>
-          prompt>
-          prompt> if 1
-          prompt>   St
-          prompt> enString
-                    Struct
-        EOC
-        close
-      end
-    end
-
-    def test_simple_dialog_with_scroll_screen
-      iterate_over_face_configs do |config_name, config_file|
-        start_terminal(5, 50, %W{ruby -I#{@pwd}/lib -r#{config_file.path} #{@pwd}/test/reline/yamatanooroti/multiline_repl --dialog simple}, startup_message: /prompt>/)
-        write("if 1\n  2\n  3\n  4\n  5\n  6")
-        write("\C-p\C-n\C-p\C-p\C-p#")
-        close
-        assert_screen(<<~'EOC')
-          prompt>   2
-          prompt>   3#
-          prompt>   4
-          prompt>   5 Ruby is...
-          prompt>   6 A dynamic, open source programming
-        EOC
-      end
-    end
-
-    def test_autocomplete_at_bottom
-      start_terminal(15, 50, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl --autocomplete}, startup_message: 'Multiline REPL.')
-      write('def hoge' + "\C-m" * 10 + "end\C-p  ")
-      write('S')
-      assert_screen(<<~'EOC')
-        Multiline REPL.
-        prompt> def hoge
-        prompt>
-        prompt>
-        prompt>   String
-        prompt>   Struct
-        prompt>   Symbol
-        prompt>   ScriptError
-        prompt>   SyntaxError
-        prompt>   Signal
-        prompt>   S
-        prompt> end
-      EOC
-      close
-    end
-
-    def test_autocomplete_return_to_original
-      start_terminal(20, 20, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl --autocomplete}, startup_message: 'Multiline REPL.')
-      write('S')
-      write('t')
-      write('r')
-      3.times{ write("\C-i") }
-      assert_screen(<<~'EOC')
-        Multiline REPL.
-        prompt> Str
-                String
-                Struct
-      EOC
-      close
-    end
-
-    def test_autocomplete_target_is_wrapped
-      start_terminal(20, 20, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl --autocomplete}, startup_message: 'Multiline REPL.')
-      write('          ')
-      write('S')
-      write('t')
-      write('r')
-      assert_screen(<<~'EOC')
-        Multiline REPL.
-        prompt>           St
-        r
-        String
-        Struct
-      EOC
-      close
-    end
-
-    def test_autocomplete_target_at_end_of_line
-      start_terminal(20, 20, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl --autocomplete}, startup_message: 'Multiline REPL.')
-      write('         ')
-      write('Str')
-      write("\C-i")
-      assert_screen(<<~'EOC')
-        Multiline REPL.
-        prompt>          Str
-        ing           String
-                      Struct
-      EOC
-      close
-    end
-
-    def test_autocomplete_completed_input_is_wrapped
-      start_terminal(20, 20, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl --autocomplete}, startup_message: 'Multiline REPL.')
-      write('        ')
-      write('Str')
-      write("\C-i")
-      assert_screen(<<~'EOC')
-        Multiline REPL.
-        prompt>         Stri
-        ng            String
-                      Struct
-      EOC
-      close
-    end
-
-    def test_force_insert_before_autocomplete
-      start_terminal(20, 20, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl --autocomplete}, startup_message: 'Multiline REPL.')
-      write('Sy')
-      write(";St\t\t")
-      assert_screen(<<~'EOC')
-        Multiline REPL.
-        prompt> Sy;Struct
-                   String
-                   Struct
-      EOC
-      close
-    end
-
-    def test_simple_dialog_with_scroll_key
-      start_terminal(20, 50, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl --dialog long,scrollkey}, startup_message: 'Multiline REPL.')
-      write('a')
-      5.times{ write('j') }
-      assert_screen(<<~'EOC')
-        Multiline REPL.
-        prompt> a
-                 A dynamic, open
-                 source programming
-                 language with a
-                 focus on simplicity
-      EOC
-      close
-    end
-
-    def test_simple_dialog_scrollbar_with_moving_to_right
-      start_terminal(20, 50, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl --dialog long,scrollkey,scrollbar}, startup_message: 'Multiline REPL.')
-      6.times{ write('j') }
-      write('a')
-      assert_screen(<<~'EOC')
-        Multiline REPL.
-        prompt> a
-                 source programming ▄
-                 language with a    █
-                 focus on simplicity
-                 and productivity.
-      EOC
-      close
-    end
-
-    def test_simple_dialog_scrollbar_with_moving_to_left
-      start_terminal(20, 50, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl --dialog long,scrollkey,scrollbar}, startup_message: 'Multiline REPL.')
-      write('a')
-      6.times{ write('j') }
-      write("\C-h")
-      assert_screen(<<~'EOC')
-        Multiline REPL.
-        prompt>
-                source programming ▄
-                language with a    █
-                focus on simplicity
-                and productivity.
-      EOC
-      close
-    end
-
-    def test_dialog_with_fullwidth_chars
-      ENV['RELINE_TEST_PROMPT'] = '> '
-      start_terminal(20, 5, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl --dialog fullwidth,scrollkey,scrollbar}, startup_message: 'Multiline REPL.')
-      6.times{ write('j') }
-      assert_screen(<<~'EOC')
-        Multi
-        line
-        REPL.
-        >
-        オー
-        グ言▄
-        備え█
-        ち、█
-      EOC
-      close
-    end
-
-    def test_dialog_with_fullwidth_chars_split
-      ENV['RELINE_TEST_PROMPT'] = '> '
-      start_terminal(20, 6, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl --dialog fullwidth,scrollkey,scrollbar}, startup_message: 'Multiline REPL.')
-      6.times{ write('j') }
-      assert_screen(<<~'EOC')
-        Multil
-        ine RE
-        PL.
-        >
-        オー
-        グ言 ▄
-        備え █
-        ち、 █
-      EOC
-      close
-    end
-
-    def test_autocomplete_empty
-      start_terminal(20, 30, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl --autocomplete}, startup_message: 'Multiline REPL.')
-      write('Street')
-      assert_screen(<<~'EOC')
-        Multiline REPL.
-        prompt> Street
-      EOC
-      close
-    end
-
-    def test_autocomplete
-      start_terminal(20, 30, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl --autocomplete}, startup_message: 'Multiline REPL.')
-      write('Str')
-      assert_screen(<<~'EOC')
-        Multiline REPL.
-        prompt> Str
-                String
-                Struct
-      EOC
-      close
-    end
-
-    def test_autocomplete_empty_string
-      start_terminal(5, 30, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl --autocomplete}, startup_message: 'Multiline REPL.')
-      write("\C-i")
-      assert_screen(<<~'EOC')
-        Multiline REPL.
-        prompt> String
-                String     █
-                Struct     ▀
-                Symbol
-      EOC
-      close
-    end
-
-    def test_paste_code_with_tab_indent_does_not_fail
-      start_terminal(5, 30, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl --autocomplete-empty}, startup_message: 'Multiline REPL.')
-      write("2.times do\n\tputs\n\tputs\nend")
-      assert_screen(<<~'EOC')
-        Multiline REPL.
-        prompt> 2.times do
-        prompt> puts
-        prompt> puts
-        prompt> end
-      EOC
-      close
-    end
-
-    def test_autocomplete_after_2nd_line
-      start_terminal(20, 30, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl --autocomplete}, startup_message: 'Multiline REPL.')
-      write("def hoge\n  Str")
-      assert_screen(<<~'EOC')
-        Multiline REPL.
-        prompt> def hoge
-        prompt>   Str
-                  String
-                  Struct
-      EOC
-      close
-    end
-
-    def test_autocomplete_rerender_under_dialog
-      start_terminal(20, 30, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl --autocomplete}, startup_message: 'Multiline REPL.')
-      write("def hoge\n\n  123456\n  456789\nend\C-p\C-p\C-p  a = Str")
-      write('i')
-      assert_screen(<<~'EOC')
-        Multiline REPL.
-        prompt> def hoge
-        prompt>   a = Stri
-        prompt>   1234String
-        prompt>   456789
-        prompt> end
-      EOC
-      close
-    end
-
-    def test_rerender_multiple_dialog
-      start_terminal(20, 60, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl --autocomplete --dialog simple}, startup_message: 'Multiline REPL.')
-      write("if\n  abcdef\n  123456\n  456789\nend\C-p\C-p\C-p\C-p Str")
-      write("\t")
-      assert_screen(<<~'EOC')
-        Multiline REPL.
-        prompt> if String
-        prompt>   aStringRuby is...
-        prompt>   1StructA dynamic, open source programming
-        prompt>   456789 language with a focus on simplicity
-        prompt> end      and productivity. It has an elegant
-                         syntax that is natural to read and
-                         easy to write.
-      EOC
-      close
-    end
-
-    def test_autocomplete_long_with_scrollbar
-      start_terminal(20, 30, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl --autocomplete-long}, startup_message: 'Multiline REPL.')
-      write('S')
-      assert_screen(<<~'EOC')
-        Multiline REPL.
-        prompt> S
-                String          █
-                Struct          █
-                Symbol          █
-                StopIteration   █
-                SystemCallError █
-                SystemExit      █
-                SystemStackError█
-                ScriptError     █
-                SyntaxError     █
-                Signal          █
-                SizedQueue      █
-                Set
-                SecureRandom
-                Socket
-                StringIO
-      EOC
-      write("\C-i" * 16)
-      assert_screen(<<~'EOC')
-        Multiline REPL.
-        prompt> StringScanner
-                Struct          ▄
-                Symbol          █
-                StopIteration   █
-                SystemCallError █
-                SystemExit      █
-                SystemStackError█
-                ScriptError     █
-                SyntaxError     █
-                Signal          █
-                SizedQueue      █
-                Set             █
-                SecureRandom    ▀
-                Socket
-                StringIO
-                StringScanner
-      EOC
-      close
-    end
-
-    def test_autocomplete_super_long_scroll_to_bottom
-      start_terminal(20, 30, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl --autocomplete-super-long}, startup_message: 'Multiline REPL.')
-      shift_tab = [27, 91, 90]
-      write('S' + shift_tab.map(&:chr).join)
-      assert_screen(<<~'EOC')
-        Multiline REPL.
-        prompt> Str_BXX
-                Str_BXJ
-                Str_BXK
-                Str_BXL
-                Str_BXM
-                Str_BXN
-                Str_BXO
-                Str_BXP
-                Str_BXQ
-                Str_BXR
-                Str_BXS
-                Str_BXT
-                Str_BXU
-                Str_BXV
-                Str_BXW
-                Str_BXX▄
-      EOC
-      close
-    end
-
-    def test_autocomplete_super_long_and_backspace
-      start_terminal(20, 30, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl --autocomplete-super-long}, startup_message: 'Multiline REPL.')
-      shift_tab = [27, 91, 90]
-      write('S' + shift_tab.map(&:chr).join)
-      write("\C-h")
-      assert_screen(<<~'EOC')
-        Multiline REPL.
-        prompt> Str_BX
-                Str_BX █
-                Str_BXA█
-                Str_BXB█
-                Str_BXC█
-                Str_BXD█
-                Str_BXE█
-                Str_BXF█
-                Str_BXG█
-                Str_BXH█
-                Str_BXI
-                Str_BXJ
-                Str_BXK
-                Str_BXL
-                Str_BXM
-                Str_BXN
-      EOC
-      close
-    end
-
-    def test_dialog_callback_returns_nil
-      start_terminal(20, 30, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl --dialog nil}, startup_message: 'Multiline REPL.')
-      write('a')
-      assert_screen(<<~'EOC')
-        Multiline REPL.
-        prompt> a
-      EOC
-      close
-    end
-
-    def test_dialog_narrower_than_screen
-      start_terminal(20, 11, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl --dialog simple}, startup_message: 'Multiline REPL.')
-      assert_screen(<<~'EOC')
-        Multiline R
-        EPL.
-        prompt>
-        Ruby is...
-        A dynamic,
-        language wi
-        and product
-        syntax that
-        easy to wri
-      EOC
-      close
-    end
-
-    def test_dialog_narrower_than_screen_with_scrollbar
-      start_terminal(20, 11, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl --autocomplete-long}, startup_message: 'Multiline REPL.')
-      write('S' + "\C-i" * 3)
-      assert_screen(<<~'EOC')
-        Multiline R
-        EPL.
-        prompt> Sym
-        String    █
-        Struct    █
-        Symbol    █
-        StopIterat█
-        SystemCall█
-        SystemExit█
-        SystemStac█
-        ScriptErro█
-        SyntaxErro█
-        Signal    █
-        SizedQueue█
-        Set
-        SecureRand
-        Socket
-        StringIO
-      EOC
-      close
-    end
-
-    def test_dialog_with_fullwidth_scrollbar
-      start_terminal(20, 40, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl --dialog simple,scrollkey,alt-scrollbar}, startup_message: 'Multiline REPL.')
-      assert_screen(<<~'EOC')
-        Multiline REPL.
-        prompt>
-           Ruby is...                         ::
-           A dynamic, open source programming ::
-           language with a focus on simplicity''
-           and productivity. It has an elegant
-      EOC
-      close
-    end
-
-    def test_rerender_argument_prompt_after_pasting
-      start_terminal(20, 30, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl}, startup_message: 'Multiline REPL.')
-      write('abcdef')
-      write("\e3\C-h")
-      assert_screen(<<~'EOC')
-        Multiline REPL.
-        prompt> abc
-      EOC
-      close
-    end
-
-    def test_autocomplete_old_dialog_width_greater_than_dialog_width
-      start_terminal(40, 40, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl --autocomplete-width-long}, startup_message: 'Multiline REPL.')
-      write("0+ \n12345678901234")
-      write("\C-p")
-      write("r")
-      write("a")
-      assert_screen(<<~'EOC')
-        Multiline REPL.
-        prompt> 0+ ra
-        prompt> 123rand 901234
-                   raise
-      EOC
-      close
-    end
-
-    def test_scroll_at_bottom_for_dialog
-      start_terminal(10, 40, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl --autocomplete}, startup_message: 'Multiline REPL.')
-      write("\n\n\n\n\n\n\n\n\n\n\n")
-      write("def hoge\n\nend\C-p\C-e")
-      write("  S")
-      assert_screen(<<~'EOC')
-        prompt>
-        prompt>
-        prompt>
-        prompt>
-        prompt>
-        prompt> def hoge
-        prompt>   S
-        prompt> enString     █
-                  Struct     ▀
-                  Symbol
-      EOC
-      close
-    end
-
-    def test_clear_dialog_in_pasting
-      start_terminal(10, 40, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl --autocomplete}, startup_message: 'Multiline REPL.')
-      write("S")
-      write("tring ")
-      assert_screen(<<~'EOC')
-        Multiline REPL.
-        prompt> String
-      EOC
-      close
-    end
-
-    def test_prompt_with_newline
-      ENV['RELINE_TEST_PROMPT'] = "::\n> "
-      start_terminal(5, 30, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl}, startup_message: 'Multiline REPL.')
-      write("def hoge\n  3\nend")
-      assert_screen(<<~'EOC')
-        Multiline REPL.
-        ::\n> def hoge
-        ::\n>   3
-        ::\n> end
-      EOC
-      close
-    end
-
-    def test_dynamic_prompt_with_newline
-      start_terminal(5, 30, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl --dynamic-prompt-with-newline}, startup_message: 'Multiline REPL.')
-      write("def hoge\n  3\nend")
-      assert_screen(<<~'EOC')
-        Multiline REPL.
-        [0000\n]> def hoge
-        [0001\n]>   3
-        [0001\n]> end
-      EOC
-      close
-    end
-
-    def test_lines_passed_to_dynamic_prompt
-      start_terminal(5, 30, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl --dynamic-prompt-show-line}, startup_message: 'Multiline REPL.')
-      write("if true")
-      write("\n")
-      assert_screen(<<~EOC)
-        Multiline REPL.
-        [if t]> if true
-        [    ]>
-      EOC
-      close
-    end
-
-    def test_clear_dialog_when_just_move_cursor_at_last_line
-      start_terminal(10, 30, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl --autocomplete}, startup_message: 'Multiline REPL.')
-      write("class A\n  3\nend\n\n\n")
-      write("\C-p\C-p\C-e; S")
-      assert_screen(/String/)
-      write("\C-n")
-      write(";")
-      assert_screen(<<~'EOC')
-        prompt>   3
-        prompt> end
-        => 3
-        prompt>
-        prompt>
-        prompt> class A
-        prompt>   3; S
-        prompt> end;
-      EOC
-      close
-    end
-
-    def test_clear_dialog_when_adding_new_line_to_end_of_buffer
-      start_terminal(10, 30, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl --autocomplete}, startup_message: 'Multiline REPL.')
-      write("class A\n  def a\n    3\n    3\n  end\nend")
-      write("\n")
-      write("class S")
-      write("\n")
-      write("  3")
-      assert_screen(<<~'EOC')
-        prompt>   def a
-        prompt>     3
-        prompt>     3
-        prompt>   end
-        prompt> end
-        => :a
-        prompt> class S
-        prompt>   3
-      EOC
-      close
-    end
-
-    def test_insert_newline_in_the_middle_of_buffer_just_after_dialog
-      start_terminal(10, 30, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl --autocomplete}, startup_message: 'Multiline REPL.')
-      write("class A\n  def a\n    3\n  end\nend")
-      write("\n")
-      write("\C-p\C-p\C-p\C-p\C-p\C-e\C-hS")
-      write("\e\x0D")
-      write("  3")
-      assert_screen(<<~'EOC')
-        prompt>     3
-        prompt>   end
-        prompt> end
-        => :a
-        prompt> class S
-        prompt>   3
-        prompt>   def a
-        prompt>     3
-        prompt>   end
-        prompt> end
-      EOC
-      close
-    end
-
-    def test_incremental_search_on_not_last_line
-      start_terminal(10, 40, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl --autocomplete}, startup_message: 'Multiline REPL.')
-      write("def abc\nend\n")
-      write("def def\nend\n")
-      write("\C-p\C-p\C-e")
-      write("\C-r")
-      write("a")
-      write("\n\n")
-      assert_screen(<<~'EOC')
-        prompt> def abc
-        prompt> end
-        => :abc
-        prompt> def def
-        prompt> end
-        => :def
-        prompt> def abc
-        prompt> end
-        => :abc
-        prompt>
-      EOC
-      close
-    end
-
-    def test_bracket_newline_indent
-      start_terminal(5, 30, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl --auto-indent}, startup_message: 'Multiline REPL.')
-      write("[\n")
-      write("1")
-      assert_screen(<<~EOC)
-        Multiline REPL.
-        prompt> [
-        prompt>   1
-      EOC
-      close
-    end
-
-    def test_repeated_input_delete
-      start_terminal(5, 30, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl}, startup_message: 'Multiline REPL.')
-      write("a\C-h" * 4000)
-      assert_screen(<<~'EOC')
-        Multiline REPL.
-        prompt>
-      EOC
-      close
-    end
-
-    def test_exit_with_ctrl_d
-      start_terminal(5, 30, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl --auto-indent}, startup_message: 'Multiline REPL.')
-      begin
-        write("\C-d")
-        close
-      rescue EOFError
-        # EOFError is raised when process terminated.
-      end
-      assert_screen(<<~EOC)
-        Multiline REPL.
-        prompt>
-      EOC
-      close
-    end
-
-    def test_quoted_insert_intr_keys
-      omit if Reline.core.io_gate.win?
-      start_terminal(5, 30, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl}, startup_message: 'Multiline REPL.')
-      write '"'
-      write "\C-v"
-      write "\C-c"
-      write "\C-v"
-      write "\C-z"
-      write "\C-v"
-      write "\C-\\"
-      write "\".bytes\n"
-      assert_screen(<<~EOC)
-        Multiline REPL.
-        prompt> "^C^Z^\\\".bytes
-        => [3, 26, 28]
-        prompt>
-      EOC
-      close
-    end
-
-    def test_quoted_insert_timeout
-      omit if Reline.core.io_gate.win?
-
-      start_terminal(5, 30, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl}, startup_message: 'Multiline REPL.')
-      write "\C-v"
-      write "\C-a"
-      write "\C-v"
-      # broken bytes should be ignored with timeout
-      write_without_meta_conversion "\xE3\xE4\xE5"
-      sleep 1
-      write "\C-v"
-      write "\C-b"
-      assert_screen(/prompt> \^A\^B/)
-    end
-
-    def test_print_before_readline
-      code = <<~RUBY
-        puts 'Multiline REPL.'
-        2.times do
-          print 'a' * 10
-          Reline.readline '>'
-        end
-      RUBY
-      start_terminal(6, 30, ['ruby', "-I#{@pwd}/lib", '-rreline', '-e', code], startup_message: 'Multiline REPL.')
-      write "x\n"
-      assert_screen(<<~EOC)
-        Multiline REPL.
-        >x
-        >
-      EOC
-      close
-    end
-
-    def test_pre_input_hook_with_redisplay
-      code = <<~'RUBY'
-        puts 'Multiline REPL.'
-        Reline.pre_input_hook = -> do
-          Reline.insert_text 'abc'
-          Reline.redisplay # Reline doesn't need this but Readline requires calling redisplay
-        end
-        Reline.readline('prompt> ')
-      RUBY
-      start_terminal(6, 30, ['ruby', "-I#{@pwd}/lib", '-rreline', '-e', code], startup_message: 'Multiline REPL.')
-      assert_screen(<<~EOC)
-        Multiline REPL.
-        prompt> abc
-      EOC
-      close
-    end
-
-    def test_pre_input_hook_with_multiline_text_insert
-      # Frequently used pattern of pre_input_hook
-      code = <<~'RUBY'
-        puts 'Multiline REPL.'
-        Reline.pre_input_hook = -> do
-          Reline.insert_text "abc\nef"
-        end
-        Reline.readline('>')
-      RUBY
-      start_terminal(6, 30, ['ruby', "-I#{@pwd}/lib", '-rreline', '-e', code], startup_message: 'Multiline REPL.')
-      write("\C-ad")
-      assert_screen(<<~EOC)
-        Multiline REPL.
-        >abc
-        def
-      EOC
-      close
-    end
-
-    def test_thread_safe
-      start_terminal(6, 30, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl --auto-indent}, startup_message: 'Multiline REPL.')
-      write("[Thread.new{Reline.readline'>'},Thread.new{Reline.readmultiline('>'){true}}].map(&:join).size\n")
-      write("exit\n")
-      write("exit\n")
-      write("42\n")
-      assert_screen(<<~EOC)
-        >exit
-        >exit
-        => 2
-        prompt> 42
-        => 42
-        prompt>
-      EOC
-      close
-    end
-
-    def test_user_defined_winch
-      omit if Reline.core.io_gate.win?
-      pidfile = Tempfile.create('pidfile')
-      rubyfile = Tempfile.create('rubyfile')
-      rubyfile.write <<~RUBY
-        File.write(#{pidfile.path.inspect}, Process.pid)
-        winch_called = false
-        Signal.trap(:WINCH, ->(_arg){ winch_called = true })
-        p Reline.readline('>')
-        puts "winch: \#{winch_called}"
-      RUBY
-      rubyfile.close
-
-      start_terminal(10, 50, %W{ruby -I#{@pwd}/lib -rreline #{rubyfile.path}})
-      assert_screen(/^>/)
-      write 'a'
-      assert_screen(/^>a/)
-      pid = pidfile.tap(&:rewind).read.to_i
-      Process.kill(:WINCH, pid) unless pid.zero?
-      write "b\n"
-      assert_screen(/"ab"\nwinch: true/)
-      close
-    ensure
-      File.delete(rubyfile.path) if rubyfile
-      pidfile.close if pidfile
-      File.delete(pidfile.path) if pidfile
-    end
-
-    def test_stop_continue
-      omit if Reline.core.io_gate.win?
-      pidfile = Tempfile.create('pidfile')
-      rubyfile = Tempfile.create('rubyfile')
-      rubyfile.write <<~RUBY
-        File.write(#{pidfile.path.inspect}, Process.pid)
-        cont_called = false
-        Signal.trap(:CONT, ->(_arg){ cont_called = true })
-        Reline.readmultiline('>'){|input| input.match?(/ghi/) }
-        puts "cont: \#{cont_called}"
-      RUBY
-      rubyfile.close
-      start_terminal(10, 50, ['bash'])
-      write "ruby -I#{@pwd}/lib -rreline #{rubyfile.path}\n"
-      assert_screen(/^>/)
-      write "abc\ndef\nhi"
-      pid = pidfile.tap(&:rewind).read.to_i
-      Process.kill(:STOP, pid) unless pid.zero?
-      write "fg\n"
-      assert_screen(/fg\n.*>/m)
-      write "\ebg"
-      assert_screen(/>abc\n>def\n>ghi\n/)
-      write "\n"
-      assert_screen(/cont: true/)
-      close
-    ensure
-      File.delete(rubyfile.path) if rubyfile
-      pidfile.close if pidfile
-      File.delete(pidfile.path) if pidfile
-    end
-
-    def write_inputrc(content)
-      File.open(@inputrc_file, 'w') do |f|
-        f.write content
-      end
-    end
-
-    def fold_multiline(str, width)
-      str.scan(/.{1,#{width}}/).each(&:rstrip!).join("\n")
-    end
-  end
-rescue LoadError, NameError
-  # On Ruby repository, this test suit doesn't run because Ruby repo doesn't
-  # have the yamatanooroti gem.
-end
diff --git a/test/mri/ruby/rjit/test_assembler.rb b/test/mri/ruby/rjit/test_assembler.rb
deleted file mode 100644
index fbf780d6c3e..00000000000
--- a/test/mri/ruby/rjit/test_assembler.rb
+++ /dev/null
@@ -1,368 +0,0 @@
-require 'test/unit'
-require_relative '../../lib/jit_support'
-
-return unless JITSupport.rjit_supported?
-return unless RubyVM::RJIT.enabled?
-return unless RubyVM::RJIT::C.HAVE_LIBCAPSTONE
-
-require 'stringio'
-require 'ruby_vm/rjit/assembler'
-
-module RubyVM::RJIT
-  class TestAssembler < Test::Unit::TestCase
-    MEM_SIZE = 16 * 1024
-
-    def setup
-      @mem_block ||= C.mmap(MEM_SIZE)
-      @cb = CodeBlock.new(mem_block: @mem_block, mem_size: MEM_SIZE)
-    end
-
-    def test_add
-      asm = Assembler.new
-      asm.add([:rcx], 1)        # ADD r/m64, imm8 (Mod 00: [reg])
-      asm.add(:rax, 0x7f)       # ADD r/m64, imm8 (Mod 11: reg)
-      asm.add(:rbx, 0x7fffffff) # ADD r/m64 imm32 (Mod 11: reg)
-      asm.add(:rsi, :rdi)       # ADD r/m64, r64 (Mod 11: reg)
-      assert_compile(asm, <<~EOS)
-        0x0: add qword ptr [rcx], 1
-        0x4: add rax, 0x7f
-        0x8: add rbx, 0x7fffffff
-        0xf: add rsi, rdi
-      EOS
-    end
-
-    def test_and
-      asm = Assembler.new
-      asm.and(:rax, 0)          # AND r/m64, imm8 (Mod 11: reg)
-      asm.and(:rbx, 0x7fffffff) # AND r/m64, imm32 (Mod 11: reg)
-      asm.and(:rcx, [:rdi, 8])  # AND r64, r/m64 (Mod 01: [reg]+disp8)
-      assert_compile(asm, <<~EOS)
-        0x0: and rax, 0
-        0x4: and rbx, 0x7fffffff
-        0xb: and rcx, qword ptr [rdi + 8]
-      EOS
-    end
-
-    def test_call
-      asm = Assembler.new
-      asm.call(rel32(0xff)) # CALL rel32
-      asm.call(:rax)        # CALL r/m64 (Mod 11: reg)
-      assert_compile(asm, <<~EOS)
-        0x0: call 0xff
-        0x5: call rax
-      EOS
-    end
-
-    def test_cmove
-      asm = Assembler.new
-      asm.cmove(:rax, :rcx) # CMOVE r64, r/m64 (Mod 11: reg)
-      assert_compile(asm, <<~EOS)
-        0x0: cmove rax, rcx
-      EOS
-    end
-
-    def test_cmovg
-      asm = Assembler.new
-      asm.cmovg(:rbx, :rdi) # CMOVG r64, r/m64 (Mod 11: reg)
-      assert_compile(asm, <<~EOS)
-        0x0: cmovg rbx, rdi
-      EOS
-    end
-
-    def test_cmovge
-      asm = Assembler.new
-      asm.cmovge(:rsp, :rbp) # CMOVGE r64, r/m64 (Mod 11: reg)
-      assert_compile(asm, <<~EOS)
-        0x0: cmovge rsp, rbp
-      EOS
-    end
-
-    def test_cmovl
-      asm = Assembler.new
-      asm.cmovl(:rdx, :rsp) # CMOVL r64, r/m64 (Mod 11: reg)
-      assert_compile(asm, <<~EOS)
-        0x0: cmovl rdx, rsp
-      EOS
-    end
-
-    def test_cmovle
-      asm = Assembler.new
-      asm.cmovle(:rax, :rax) # CMOVLE r64, r/m64 (Mod 11: reg)
-      assert_compile(asm, <<~EOS)
-        0x0: cmovle rax, rax
-      EOS
-    end
-
-    def test_cmovne
-      asm = Assembler.new
-      asm.cmovne(:rax, :rbx) # CMOVNE r64, r/m64 (Mod 11: reg)
-      assert_compile(asm, <<~EOS) # cmovne == cmovnz
-        0x0: cmovne rax, rbx
-      EOS
-    end
-
-    def test_cmovnz
-      asm = Assembler.new
-      asm.cmovnz(:rax, :rbx) # CMOVNZ r64, r/m64 (Mod 11: reg)
-      assert_compile(asm, <<~EOS) # cmovne == cmovnz
-        0x0: cmovne rax, rbx
-      EOS
-    end
-
-    def test_cmovz
-      asm = Assembler.new
-      asm.cmovz(:rax, :rbx) # CMOVZ r64, r/m64 (Mod 11: reg)
-      assert_compile(asm, <<~EOS) # cmove == cmovz
-        0x0: cmove rax, rbx
-      EOS
-    end
-
-    def test_cmp
-      asm = Assembler.new
-      asm.cmp(BytePtr[:rax, 8], 8)      # CMP r/m8, imm8 (Mod 01: [reg]+disp8)
-      asm.cmp(DwordPtr[:rax, 8], 0x100) # CMP r/m32, imm32 (Mod 01: [reg]+disp8)
-      asm.cmp([:rax, 8], 8)             # CMP r/m64, imm8 (Mod 01: [reg]+disp8)
-      asm.cmp([:rbx, 8], 0x100)         # CMP r/m64, imm32 (Mod 01: [reg]+disp8)
-      asm.cmp([:rax, 0x100], 8)         # CMP r/m64, imm8 (Mod 10: [reg]+disp32)
-      asm.cmp(:rax, 8)                  # CMP r/m64, imm8 (Mod 11: reg)
-      asm.cmp(:rax, 0x100)              # CMP r/m64, imm32 (Mod 11: reg)
-      asm.cmp([:rax, 8], :rbx)          # CMP r/m64, r64 (Mod 01: [reg]+disp8)
-      asm.cmp([:rax, -0x100], :rbx)     # CMP r/m64, r64 (Mod 10: [reg]+disp32)
-      asm.cmp(:rax, :rbx)               # CMP r/m64, r64 (Mod 11: reg)
-      assert_compile(asm, <<~EOS)
-        0x0: cmp byte ptr [rax + 8], 8
-        0x4: cmp dword ptr [rax + 8], 0x100
-        0xb: cmp qword ptr [rax + 8], 8
-        0x10: cmp qword ptr [rbx + 8], 0x100
-        0x18: cmp qword ptr [rax + 0x100], 8
-        0x20: cmp rax, 8
-        0x24: cmp rax, 0x100
-        0x2b: cmp qword ptr [rax + 8], rbx
-        0x2f: cmp qword ptr [rax - 0x100], rbx
-        0x36: cmp rax, rbx
-      EOS
-    end
-
-    def test_jbe
-      asm = Assembler.new
-      asm.jbe(rel32(0xff)) # JBE rel32
-      assert_compile(asm, <<~EOS)
-        0x0: jbe 0xff
-      EOS
-    end
-
-    def test_je
-      asm = Assembler.new
-      asm.je(rel32(0xff)) # JE rel32
-      assert_compile(asm, <<~EOS)
-        0x0: je 0xff
-      EOS
-    end
-
-    def test_jl
-      asm = Assembler.new
-      asm.jl(rel32(0xff)) # JL rel32
-      assert_compile(asm, <<~EOS)
-        0x0: jl 0xff
-      EOS
-    end
-
-    def test_jmp
-      asm = Assembler.new
-      label = asm.new_label('label')
-      asm.jmp(label)       # JZ rel8
-      asm.write_label(label)
-      asm.jmp(rel32(0xff)) # JMP rel32
-      asm.jmp([:rax, 8])   # JMP r/m64 (Mod 01: [reg]+disp8)
-      asm.jmp(:rax)        # JMP r/m64 (Mod 11: reg)
-      assert_compile(asm, <<~EOS)
-        0x0: jmp 2
-        0x2: jmp 0xff
-        0x7: jmp qword ptr [rax + 8]
-        0xa: jmp rax
-      EOS
-    end
-
-    def test_jne
-      asm = Assembler.new
-      asm.jne(rel32(0xff)) # JNE rel32
-      assert_compile(asm, <<~EOS)
-        0x0: jne 0xff
-      EOS
-    end
-
-    def test_jnz
-      asm = Assembler.new
-      asm.jnz(rel32(0xff)) # JNZ rel32
-      assert_compile(asm, <<~EOS)
-        0x0: jne 0xff
-      EOS
-    end
-
-    def test_jo
-      asm = Assembler.new
-      asm.jo(rel32(0xff)) # JO rel32
-      assert_compile(asm, <<~EOS)
-        0x0: jo 0xff
-      EOS
-    end
-
-    def test_jz
-      asm = Assembler.new
-      asm.jz(rel32(0xff)) # JZ rel32
-      assert_compile(asm, <<~EOS)
-        0x0: je 0xff
-      EOS
-    end
-
-    def test_lea
-      asm = Assembler.new
-      asm.lea(:rax, [:rax, 8])      # LEA r64,m (Mod 01: [reg]+disp8)
-      asm.lea(:rax, [:rax, 0xffff]) # LEA r64,m (Mod 10: [reg]+disp32)
-      assert_compile(asm, <<~EOS)
-        0x0: lea rax, [rax + 8]
-        0x4: lea rax, [rax + 0xffff]
-      EOS
-    end
-
-    def test_mov
-      asm = Assembler.new
-      asm.mov(:eax, DwordPtr[:rbx, 8])  # MOV r32 r/m32 (Mod 01: [reg]+disp8)
-      asm.mov(:eax, 0x100)              # MOV r32, imm32 (Mod 11: reg)
-      asm.mov(:rax, [:rbx])             # MOV r64, r/m64 (Mod 00: [reg])
-      asm.mov(:rax, [:rbx, 8])          # MOV r64, r/m64 (Mod 01: [reg]+disp8)
-      asm.mov(:rax, [:rbx, 0x100])      # MOV r64, r/m64 (Mod 10: [reg]+disp32)
-      asm.mov(:rax, :rbx)               # MOV r64, r/m64 (Mod 11: reg)
-      asm.mov(:rax, 0x100)              # MOV r/m64, imm32 (Mod 11: reg)
-      asm.mov(:rax, 0x100000000)        # MOV r64, imm64
-      asm.mov(DwordPtr[:rax, 8], 0x100) # MOV r/m32, imm32 (Mod 01: [reg]+disp8)
-      asm.mov([:rax], 0x100)            # MOV r/m64, imm32 (Mod 00: [reg])
-      asm.mov([:rax], :rbx)             # MOV r/m64, r64 (Mod 00: [reg])
-      asm.mov([:rax, 8], 0x100)         # MOV r/m64, imm32 (Mod 01: [reg]+disp8)
-      asm.mov([:rax, 8], :rbx)          # MOV r/m64, r64 (Mod 01: [reg]+disp8)
-      asm.mov([:rax, 0x100], 0x100)     # MOV r/m64, imm32 (Mod 10: [reg]+disp32)
-      asm.mov([:rax, 0x100], :rbx)      # MOV r/m64, r64 (Mod 10: [reg]+disp32)
-      assert_compile(asm, <<~EOS)
-        0x0: mov eax, dword ptr [rbx + 8]
-        0x3: mov eax, 0x100
-        0x8: mov rax, qword ptr [rbx]
-        0xb: mov rax, qword ptr [rbx + 8]
-        0xf: mov rax, qword ptr [rbx + 0x100]
-        0x16: mov rax, rbx
-        0x19: mov rax, 0x100
-        0x20: movabs rax, 0x100000000
-        0x2a: mov dword ptr [rax + 8], 0x100
-        0x31: mov qword ptr [rax], 0x100
-        0x38: mov qword ptr [rax], rbx
-        0x3b: mov qword ptr [rax + 8], 0x100
-        0x43: mov qword ptr [rax + 8], rbx
-        0x47: mov qword ptr [rax + 0x100], 0x100
-        0x52: mov qword ptr [rax + 0x100], rbx
-      EOS
-    end
-
-    def test_or
-      asm = Assembler.new
-      asm.or(:rax, 0)         # OR r/m64, imm8 (Mod 11: reg)
-      asm.or(:rax, 0xffff)    # OR r/m64, imm32 (Mod 11: reg)
-      asm.or(:rax, [:rbx, 8]) # OR r64, r/m64 (Mod 01: [reg]+disp8)
-      assert_compile(asm, <<~EOS)
-        0x0: or rax, 0
-        0x4: or rax, 0xffff
-        0xb: or rax, qword ptr [rbx + 8]
-      EOS
-    end
-
-    def test_push
-      asm = Assembler.new
-      asm.push(:rax) # PUSH r64
-      assert_compile(asm, <<~EOS)
-        0x0: push rax
-      EOS
-    end
-
-    def test_pop
-      asm = Assembler.new
-      asm.pop(:rax) # POP r64
-      assert_compile(asm, <<~EOS)
-        0x0: pop rax
-      EOS
-    end
-
-    def test_ret
-      asm = Assembler.new
-      asm.ret # RET
-      assert_compile(asm, "0x0: ret \n")
-    end
-
-    def test_sar
-      asm = Assembler.new
-      asm.sar(:rax, 0) # SAR r/m64, imm8 (Mod 11: reg)
-      assert_compile(asm, <<~EOS)
-        0x0: sar rax, 0
-      EOS
-    end
-
-    def test_sub
-      asm = Assembler.new
-      asm.sub(:rax, 8)    # SUB r/m64, imm8 (Mod 11: reg)
-      asm.sub(:rax, :rbx) # SUB r/m64, r64 (Mod 11: reg)
-      assert_compile(asm, <<~EOS)
-        0x0: sub rax, 8
-        0x4: sub rax, rbx
-      EOS
-    end
-
-    def test_test
-      asm = Assembler.new
-      asm.test(BytePtr[:rax, 8], 16)   # TEST r/m8*, imm8 (Mod 01: [reg]+disp8)
-      asm.test([:rax, 8], 8)           # TEST r/m64, imm32 (Mod 01: [reg]+disp8)
-      asm.test([:rax, 0xffff], 0xffff) # TEST r/m64, imm32 (Mod 10: [reg]+disp32)
-      asm.test(:rax, 0xffff)           # TEST r/m64, imm32 (Mod 11: reg)
-      asm.test(:eax, :ebx)             # TEST r/m32, r32 (Mod 11: reg)
-      asm.test(:rax, :rbx)             # TEST r/m64, r64 (Mod 11: reg)
-      assert_compile(asm, <<~EOS)
-        0x0: test byte ptr [rax + 8], 0x10
-        0x4: test qword ptr [rax + 8], 8
-        0xc: test qword ptr [rax + 0xffff], 0xffff
-        0x17: test rax, 0xffff
-        0x1e: test eax, ebx
-        0x20: test rax, rbx
-      EOS
-    end
-
-    def test_xor
-      asm = Assembler.new
-      asm.xor(:rax, :rbx)
-      assert_compile(asm, <<~EOS)
-        0x0: xor rax, rbx
-      EOS
-    end
-
-    private
-
-    def rel32(offset)
-      @cb.write_addr + 0xff
-    end
-
-    def assert_compile(asm, expected)
-      actual = compile(asm)
-      assert_equal expected, actual, "---\n#{actual}---"
-    end
-
-    def compile(asm)
-      start_addr = @cb.write_addr
-      @cb.write(asm)
-      end_addr = @cb.write_addr
-
-      io = StringIO.new
-      @cb.dump_disasm(start_addr, end_addr, io:, color: false, test: true)
-      io.seek(0)
-      disasm = io.read
-
-      disasm.gsub!(/^  /, '')
-      disasm.sub!(/\n\z/, '')
-      disasm
-    end
-  end
-end
diff --git a/test/mri/rubygems/test_gem_commands_query_command.rb b/test/mri/rubygems/test_gem_commands_query_command.rb
deleted file mode 100644
index 8e590df1244..00000000000
--- a/test/mri/rubygems/test_gem_commands_query_command.rb
+++ /dev/null
@@ -1,830 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "helper"
-require "rubygems/commands/query_command"
-
-module TestGemCommandsQueryCommandSetup
-  def setup
-    super
-
-    @cmd = Gem::Commands::QueryCommand.new
-
-    @specs = add_gems_to_fetcher
-    @stub_ui = Gem::MockGemUi.new
-    @stub_fetcher = Gem::FakeFetcher.new
-
-    @stub_fetcher.data["#{@gem_repo}Marshal.#{Gem.marshal_version}"] = proc do
-      raise Gem::RemoteFetcher::FetchError
-    end
-  end
-end
-
-class TestGemCommandsQueryCommandWithInstalledGems < Gem::TestCase
-  include TestGemCommandsQueryCommandSetup
-
-  def test_execute
-    spec_fetcher(&:legacy_platform)
-
-    @cmd.handle_options %w[-r]
-
-    use_ui @stub_ui do
-      @cmd.execute
-    end
-
-    expected = <<-EOF
-
-*** REMOTE GEMS ***
-
-a (2)
-pl (1 i386-linux)
-    EOF
-
-    assert_equal expected, @stub_ui.output
-    assert_equal "", @stub_ui.error
-  end
-
-  def test_execute_all
-    spec_fetcher(&:legacy_platform)
-
-    @cmd.handle_options %w[-r --all]
-
-    use_ui @stub_ui do
-      @cmd.execute
-    end
-
-    expected = <<-EOF
-
-*** REMOTE GEMS ***
-
-a (2, 1)
-pl (1 i386-linux)
-    EOF
-
-    assert_equal expected, @stub_ui.output
-    assert_equal "", @stub_ui.error
-  end
-
-  def test_execute_all_prerelease
-    spec_fetcher(&:legacy_platform)
-
-    @cmd.handle_options %w[-r --all --prerelease]
-
-    use_ui @stub_ui do
-      @cmd.execute
-    end
-
-    expected = <<-EOF
-
-*** REMOTE GEMS ***
-
-a (3.a, 2, 1)
-pl (1 i386-linux)
-    EOF
-
-    assert_equal expected, @stub_ui.output
-    assert_equal "", @stub_ui.error
-  end
-
-  def test_execute_details
-    spec_fetcher do |fetcher|
-      fetcher.spec "a", 2 do |s|
-        s.summary = "This is a lot of text. " * 4
-        s.authors = ["Abraham Lincoln", "Hirohito"]
-        s.homepage = "http://a.example.com/"
-      end
-
-      fetcher.legacy_platform
-    end
-
-    @cmd.handle_options %w[-r -d]
-
-    use_ui @stub_ui do
-      @cmd.execute
-    end
-
-    expected = <<-EOF
-
-*** REMOTE GEMS ***
-
-a (2)
-    Authors: Abraham Lincoln, Hirohito
-    Homepage: http://a.example.com/
-
-    This is a lot of text. This is a lot of text. This is a lot of text.
-    This is a lot of text.
-
-pl (1)
-    Platform: i386-linux
-    Author: A User
-    Homepage: http://example.com
-
-    this is a summary
-    EOF
-
-    assert_equal expected, @stub_ui.output
-    assert_equal "", @stub_ui.error
-  end
-
-  def test_execute_details_cleans_text
-    spec_fetcher do |fetcher|
-      fetcher.spec "a", 2 do |s|
-        s.summary = "This is a lot of text. " * 4
-        s.authors = ["Abraham Lincoln \x01", "\x02 Hirohito"]
-        s.homepage = "http://a.example.com/\x03"
-      end
-
-      fetcher.legacy_platform
-    end
-
-    @cmd.handle_options %w[-r -d]
-
-    use_ui @stub_ui do
-      @cmd.execute
-    end
-
-    expected = <<-EOF
-
-*** REMOTE GEMS ***
-
-a (2)
-    Authors: Abraham Lincoln ., . Hirohito
-    Homepage: http://a.example.com/.
-
-    This is a lot of text. This is a lot of text. This is a lot of text.
-    This is a lot of text.
-
-pl (1)
-    Platform: i386-linux
-    Author: A User
-    Homepage: http://example.com
-
-    this is a summary
-    EOF
-
-    assert_equal expected, @stub_ui.output
-    assert_equal "", @stub_ui.error
-  end
-
-  def test_execute_details_truncates_summary
-    spec_fetcher do |fetcher|
-      fetcher.spec "a", 2 do |s|
-        s.summary = "This is a lot of text. " * 10_000
-        s.authors = ["Abraham Lincoln \x01", "\x02 Hirohito"]
-        s.homepage = "http://a.example.com/\x03"
-      end
-
-      fetcher.legacy_platform
-    end
-
-    @cmd.handle_options %w[-r -d]
-
-    use_ui @stub_ui do
-      @cmd.execute
-    end
-
-    expected = <<-EOF
-
-*** REMOTE GEMS ***
-
-a (2)
-    Authors: Abraham Lincoln ., . Hirohito
-    Homepage: http://a.example.com/.
-
-    Truncating the summary for a-2 to 100,000 characters:
-#{"    This is a lot of text. This is a lot of text. This is a lot of text.\n" * 1449}    This is a lot of te
-
-pl (1)
-    Platform: i386-linux
-    Author: A User
-    Homepage: http://example.com
-
-    this is a summary
-    EOF
-
-    assert_equal expected, @stub_ui.output
-    assert_equal "", @stub_ui.error
-  end
-
-  def test_execute_installed
-    @cmd.handle_options %w[-n a --installed]
-
-    assert_raise Gem::MockGemUi::SystemExitException do
-      use_ui @stub_ui do
-        @cmd.execute
-      end
-    end
-
-    assert_equal "true\n", @stub_ui.output
-    assert_equal "", @stub_ui.error
-  end
-
-  def test_execute_installed_inverse
-    @cmd.handle_options %w[-n a --no-installed]
-
-    e = assert_raise Gem::MockGemUi::TermError do
-      use_ui @stub_ui do
-        @cmd.execute
-      end
-    end
-
-    assert_equal "false\n", @stub_ui.output
-    assert_equal "", @stub_ui.error
-
-    assert_equal 1, e.exit_code
-  end
-
-  def test_execute_installed_inverse_not_installed
-    @cmd.handle_options %w[-n not_installed --no-installed]
-
-    assert_raise Gem::MockGemUi::SystemExitException do
-      use_ui @stub_ui do
-        @cmd.execute
-      end
-    end
-
-    assert_equal "true\n", @stub_ui.output
-    assert_equal "", @stub_ui.error
-  end
-
-  def test_execute_installed_no_name
-    @cmd.handle_options %w[--installed]
-
-    e = assert_raise Gem::MockGemUi::TermError do
-      use_ui @stub_ui do
-        @cmd.execute
-      end
-    end
-
-    assert_equal "", @stub_ui.output
-    assert_equal "ERROR:  You must specify a gem name\n", @stub_ui.error
-
-    assert_equal 4, e.exit_code
-  end
-
-  def test_execute_installed_not_installed
-    @cmd.handle_options %w[-n not_installed --installed]
-
-    e = assert_raise Gem::MockGemUi::TermError do
-      use_ui @stub_ui do
-        @cmd.execute
-      end
-    end
-
-    assert_equal "false\n", @stub_ui.output
-    assert_equal "", @stub_ui.error
-
-    assert_equal 1, e.exit_code
-  end
-
-  def test_execute_installed_version
-    @cmd.handle_options %w[-n a --installed --version 2]
-
-    assert_raise Gem::MockGemUi::SystemExitException do
-      use_ui @stub_ui do
-        @cmd.execute
-      end
-    end
-
-    assert_equal "true\n", @stub_ui.output
-    assert_equal "", @stub_ui.error
-  end
-
-  def test_execute_installed_version_not_installed
-    @cmd.handle_options %w[-n c --installed --version 2]
-
-    e = assert_raise Gem::MockGemUi::TermError do
-      use_ui @stub_ui do
-        @cmd.execute
-      end
-    end
-
-    assert_equal "false\n", @stub_ui.output
-    assert_equal "", @stub_ui.error
-
-    assert_equal 1, e.exit_code
-  end
-
-  def test_execute_local
-    spec_fetcher(&:legacy_platform)
-
-    @cmd.options[:domain] = :local
-
-    use_ui @stub_ui do
-      @cmd.execute
-    end
-
-    expected = <<-EOF
-
-*** LOCAL GEMS ***
-
-a (3.a, 2, 1)
-pl (1 i386-linux)
-    EOF
-
-    assert_equal expected, @stub_ui.output
-    assert_equal "", @stub_ui.error
-  end
-
-  def test_execute_local_notty
-    spec_fetcher(&:legacy_platform)
-
-    @cmd.handle_options %w[]
-
-    @stub_ui.outs.tty = false
-
-    use_ui @stub_ui do
-      @cmd.execute
-    end
-
-    expected = <<-EOF
-a (3.a, 2, 1)
-pl (1 i386-linux)
-    EOF
-
-    assert_equal expected, @stub_ui.output
-    assert_equal "", @stub_ui.error
-  end
-
-  def test_execute_local_quiet
-    spec_fetcher(&:legacy_platform)
-
-    @cmd.options[:domain] = :local
-    Gem.configuration.verbose = false
-
-    use_ui @stub_ui do
-      @cmd.execute
-    end
-
-    expected = <<-EOF
-a (3.a, 2, 1)
-pl (1 i386-linux)
-    EOF
-
-    assert_equal expected, @stub_ui.output
-    assert_equal "", @stub_ui.error
-  end
-
-  def test_execute_no_versions
-    spec_fetcher(&:legacy_platform)
-
-    @cmd.handle_options %w[-r --no-versions]
-
-    use_ui @stub_ui do
-      @cmd.execute
-    end
-
-    expected = <<-EOF
-
-*** REMOTE GEMS ***
-
-a
-pl
-    EOF
-
-    assert_equal expected, @stub_ui.output
-    assert_equal "", @stub_ui.error
-  end
-
-  def test_execute_notty
-    spec_fetcher(&:legacy_platform)
-
-    @cmd.handle_options %w[-r]
-
-    @stub_ui.outs.tty = false
-
-    use_ui @stub_ui do
-      @cmd.execute
-    end
-
-    expected = <<-EOF
-a (2)
-pl (1 i386-linux)
-    EOF
-
-    assert_equal expected, @stub_ui.output
-    assert_equal "", @stub_ui.error
-  end
-
-  def test_execute_prerelease
-    @cmd.handle_options %w[-r --prerelease]
-
-    use_ui @stub_ui do
-      @cmd.execute
-    end
-
-    expected = <<-EOF
-
-*** REMOTE GEMS ***
-
-a (3.a)
-    EOF
-
-    assert_equal expected, @stub_ui.output
-    assert_equal "", @stub_ui.error
-  end
-
-  def test_execute_prerelease_local
-    spec_fetcher(&:legacy_platform)
-
-    @cmd.handle_options %w[-l --prerelease]
-
-    use_ui @stub_ui do
-      @cmd.execute
-    end
-
-    expected = <<-EOF
-
-*** LOCAL GEMS ***
-
-a (3.a, 2, 1)
-pl (1 i386-linux)
-    EOF
-
-    assert_equal expected, @stub_ui.output
-  end
-
-  def test_execute_no_prerelease_local
-    spec_fetcher(&:legacy_platform)
-
-    @cmd.handle_options %w[-l --no-prerelease]
-
-    use_ui @stub_ui do
-      @cmd.execute
-    end
-
-    expected = <<-EOF
-
-*** LOCAL GEMS ***
-
-a (2, 1)
-pl (1 i386-linux)
-    EOF
-
-    assert_equal expected, @stub_ui.output
-  end
-
-  def test_execute_remote
-    spec_fetcher(&:legacy_platform)
-
-    @cmd.options[:domain] = :remote
-
-    use_ui @stub_ui do
-      @cmd.execute
-    end
-
-    expected = <<-EOF
-
-*** REMOTE GEMS ***
-
-a (2)
-pl (1 i386-linux)
-    EOF
-
-    assert_equal expected, @stub_ui.output
-    assert_equal "", @stub_ui.error
-  end
-
-  def test_execute_remote_notty
-    spec_fetcher(&:legacy_platform)
-
-    @cmd.handle_options %w[]
-
-    @stub_ui.outs.tty = false
-
-    use_ui @stub_ui do
-      @cmd.execute
-    end
-
-    expected = <<-EOF
-a (3.a, 2, 1)
-pl (1 i386-linux)
-    EOF
-
-    assert_equal expected, @stub_ui.output
-    assert_equal "", @stub_ui.error
-  end
-
-  def test_execute_remote_quiet
-    spec_fetcher(&:legacy_platform)
-
-    @cmd.options[:domain] = :remote
-    Gem.configuration.verbose = false
-
-    use_ui @stub_ui do
-      @cmd.execute
-    end
-
-    expected = <<-EOF
-a (2)
-pl (1 i386-linux)
-    EOF
-
-    assert_equal expected, @stub_ui.output
-    assert_equal "", @stub_ui.error
-  end
-
-  def test_make_entry
-    a_2_name = @specs["a-2"].original_name
-
-    @stub_fetcher.data.delete \
-      "#{@gem_repo}quick/Marshal.#{Gem.marshal_version}/#{a_2_name}.gemspec.rz"
-
-    a2 = @specs["a-2"]
-    entry_tuples = [
-      [Gem::NameTuple.new(a2.name, a2.version, a2.platform),
-       Gem.sources.first],
-    ]
-
-    platforms = { a2.version => [a2.platform] }
-
-    entry = @cmd.send :make_entry, entry_tuples, platforms
-
-    assert_equal "a (2)", entry
-  end
-
-  # Test for multiple args handling!
-  def test_execute_multiple_args
-    spec_fetcher(&:legacy_platform)
-
-    @cmd.handle_options %w[a pl]
-
-    use_ui @stub_ui do
-      @cmd.execute
-    end
-
-    assert_match(/^a /, @stub_ui.output)
-    assert_match(/^pl /, @stub_ui.output)
-    assert_equal "", @stub_ui.error
-  end
-
-  def test_show_gems
-    @cmd.options[:name] = //
-    @cmd.options[:domain] = :remote
-
-    use_ui @stub_ui do
-      @cmd.send :show_gems, /a/i
-    end
-
-    assert_match(/^a /,  @stub_ui.output)
-    refute_match(/^pl /, @stub_ui.output)
-    assert_empty @stub_ui.error
-  end
-
-  private
-
-  def add_gems_to_fetcher
-    spec_fetcher do |fetcher|
-      fetcher.spec "a", 1
-      fetcher.spec "a", 2
-      fetcher.spec "a", "3.a"
-    end
-  end
-end
-
-class TestGemCommandsQueryCommandWithoutInstalledGems < Gem::TestCase
-  include TestGemCommandsQueryCommandSetup
-
-  def test_execute_platform
-    spec_fetcher do |fetcher|
-      fetcher.spec "a", 1
-      fetcher.spec "a", 1 do |s|
-        s.platform = "x86-linux"
-      end
-
-      fetcher.spec "a", 2 do |s|
-        s.platform = "universal-darwin"
-      end
-    end
-
-    @cmd.handle_options %w[-r -a]
-
-    use_ui @stub_ui do
-      @cmd.execute
-    end
-
-    expected = <<-EOF
-
-*** REMOTE GEMS ***
-
-a (2 universal-darwin, 1 ruby x86-linux)
-    EOF
-
-    assert_equal expected, @stub_ui.output
-    assert_equal "", @stub_ui.error
-  end
-
-  def test_execute_show_default_gems
-    spec_fetcher {|fetcher| fetcher.spec "a", 2 }
-
-    a1 = new_default_spec "a", 1
-    install_default_gems a1
-
-    use_ui @stub_ui do
-      @cmd.execute
-    end
-
-    expected = <<-EOF
-
-*** LOCAL GEMS ***
-
-a (2, default: 1)
-EOF
-
-    assert_equal expected, @stub_ui.output
-  end
-
-  def test_execute_show_default_gems_with_platform
-    a1 = new_default_spec "a", 1
-    a1.platform = "java"
-    install_default_gems a1
-
-    use_ui @stub_ui do
-      @cmd.execute
-    end
-
-    expected = <<-EOF
-
-*** LOCAL GEMS ***
-
-a (default: 1 java)
-EOF
-
-    assert_equal expected, @stub_ui.output
-  end
-
-  def test_execute_default_details
-    spec_fetcher do |fetcher|
-      fetcher.spec "a", 2
-    end
-
-    a1 = new_default_spec "a", 1
-    install_default_gems a1
-
-    @cmd.handle_options %w[-l -d]
-
-    use_ui @stub_ui do
-      @cmd.execute
-    end
-
-    expected = <<-EOF
-
-*** LOCAL GEMS ***
-
-a (2, 1)
-    Author: A User
-    Homepage: http://example.com
-    Installed at (2): #{@gemhome}
-                 (1, default): #{a1.base_dir}
-
-    this is a summary
-    EOF
-
-    assert_equal expected, @stub_ui.output
-  end
-
-  def test_execute_local_details
-    spec_fetcher do |fetcher|
-      fetcher.spec "a", 1 do |s|
-        s.platform = "x86-linux"
-      end
-
-      fetcher.spec "a", 2 do |s|
-        s.summary = "This is a lot of text. " * 4
-        s.authors = ["Abraham Lincoln", "Hirohito"]
-        s.homepage = "http://a.example.com/"
-        s.platform = "universal-darwin"
-      end
-
-      fetcher.legacy_platform
-    end
-
-    @cmd.handle_options %w[-l -d]
-
-    use_ui @stub_ui do
-      @cmd.execute
-    end
-
-    str = @stub_ui.output
-
-    str.gsub!(/$\d$: [^\n]*/, "-")
-    str.gsub!(/at: [^\n]*/, "at: -")
-
-    expected = <<-EOF
-
-*** LOCAL GEMS ***
-
-a (2, 1)
-    Platforms:
-        1: x86-linux
-        2: universal-darwin
-    Authors: Abraham Lincoln, Hirohito
-    Homepage: http://a.example.com/
-    Installed at -
-                 -
-
-    This is a lot of text. This is a lot of text. This is a lot of text.
-    This is a lot of text.
-
-pl (1)
-    Platform: i386-linux
-    Author: A User
-    Homepage: http://example.com
-    Installed at: -
-
-    this is a summary
-    EOF
-
-    assert_equal expected, @stub_ui.output
-  end
-
-  def test_execute_exact_remote
-    spec_fetcher do |fetcher|
-      fetcher.spec "coolgem-omg", 3
-      fetcher.spec "coolgem", "4.2.1"
-      fetcher.spec "wow_coolgem", 1
-    end
-
-    @cmd.handle_options %w[--remote --exact coolgem]
-
-    use_ui @stub_ui do
-      @cmd.execute
-    end
-
-    expected = <<-EOF
-
-*** REMOTE GEMS ***
-
-coolgem (4.2.1)
-    EOF
-
-    assert_equal expected, @stub_ui.output
-  end
-
-  def test_execute_exact_local
-    spec_fetcher do |fetcher|
-      fetcher.spec "coolgem-omg", 3
-      fetcher.spec "coolgem", "4.2.1"
-      fetcher.spec "wow_coolgem", 1
-    end
-
-    @cmd.handle_options %w[--exact coolgem]
-
-    use_ui @stub_ui do
-      @cmd.execute
-    end
-
-    expected = <<-EOF
-
-*** LOCAL GEMS ***
-
-coolgem (4.2.1)
-    EOF
-
-    assert_equal expected, @stub_ui.output
-  end
-
-  def test_execute_exact_multiple
-    spec_fetcher do |fetcher|
-      fetcher.spec "coolgem-omg", 3
-      fetcher.spec "coolgem", "4.2.1"
-      fetcher.spec "wow_coolgem", 1
-
-      fetcher.spec "othergem-omg", 3
-      fetcher.spec "othergem", "1.2.3"
-      fetcher.spec "wow_othergem", 1
-    end
-
-    @cmd.handle_options %w[--exact coolgem othergem]
-
-    use_ui @stub_ui do
-      @cmd.execute
-    end
-
-    expected = <<-EOF
-
-*** LOCAL GEMS ***
-
-coolgem (4.2.1)
-
-*** LOCAL GEMS ***
-
-othergem (1.2.3)
-    EOF
-
-    assert_equal expected, @stub_ui.output
-  end
-
-  def test_depprecated
-    assert @cmd.deprecated?
-  end
-
-  private
-
-  def add_gems_to_fetcher
-    spec_fetcher do |fetcher|
-      fetcher.download "a", 1
-      fetcher.download "a", 2
-      fetcher.download "a", "3.a"
-    end
-  end
-end
diff --git a/test/mri/test_pstore.rb b/test/mri/test_pstore.rb
deleted file mode 100644
index 7dfbdca367a..00000000000
--- a/test/mri/test_pstore.rb
+++ /dev/null
@@ -1,182 +0,0 @@
-# frozen_string_literal: true
-require 'test/unit'
-require 'pstore'
-require 'tmpdir'
-
-class PStoreTest < Test::Unit::TestCase
-  def setup
-    @pstore_file = File.join(Dir.tmpdir, "pstore.tmp.#{Process.pid}")
-    @pstore = PStore.new(@pstore_file)
-  end
-
-  def teardown
-    File.unlink(@pstore_file) rescue nil
-  end
-
-  def test_opening_new_file_in_readonly_mode_should_result_in_empty_values
-    @pstore.transaction(true) do
-      assert_nil @pstore[:foo]
-      assert_nil @pstore[:bar]
-    end
-  end
-
-  def test_opening_new_file_in_readwrite_mode_should_result_in_empty_values
-    @pstore.transaction do
-      assert_nil @pstore[:foo]
-      assert_nil @pstore[:bar]
-    end
-  end
-
-  def test_data_should_be_loaded_correctly_when_in_readonly_mode
-    @pstore.transaction do
-      @pstore[:foo] = "bar"
-    end
-    @pstore.transaction(true) do
-      assert_equal "bar", @pstore[:foo]
-    end
-  end
-
-  def test_data_should_be_loaded_correctly_when_in_readwrite_mode
-    @pstore.transaction do
-      @pstore[:foo] = "bar"
-    end
-    @pstore.transaction do
-      assert_equal "bar", @pstore[:foo]
-    end
-  end
-
-  def test_changes_after_commit_are_discarded
-    @pstore.transaction do
-      @pstore[:foo] = "bar"
-      @pstore.commit
-      @pstore[:foo] = "baz"
-    end
-    @pstore.transaction(true) do
-      assert_equal "bar", @pstore[:foo]
-    end
-  end
-
-  def test_changes_are_not_written_on_abort
-    @pstore.transaction do
-      @pstore[:foo] = "bar"
-      @pstore.abort
-    end
-    @pstore.transaction(true) do
-      assert_nil @pstore[:foo]
-    end
-  end
-
-  def test_writing_inside_readonly_transaction_raises_error
-    assert_raise(PStore::Error) do
-      @pstore.transaction(true) do
-        @pstore[:foo] = "bar"
-      end
-    end
-  end
-
-  def test_thread_safe
-    q1 = Thread::Queue.new
-    assert_raise(PStore::Error) do
-      th = Thread.new do
-        @pstore.transaction do
-          @pstore[:foo] = "bar"
-          q1.push true
-          sleep
-        end
-      end
-      begin
-        q1.pop
-        @pstore.transaction {}
-      ensure
-        th.kill
-        th.join
-      end
-    end
-    q2 = Thread::Queue.new
-    begin
-      pstore = PStore.new(second_file, true)
-      cur = Thread.current
-      th = Thread.new do
-        pstore.transaction do
-          pstore[:foo] = "bar"
-          q1.push true
-          q2.pop
-          # wait for cur to enter a transaction
-          sleep 0.1 until cur.stop?
-        end
-      end
-      begin
-        q1.pop
-        q2.push true
-        assert_equal("bar", pstore.transaction { pstore[:foo] })
-      ensure
-        th.join
-      end
-    end
-  ensure
-    File.unlink(second_file) rescue nil
-  end
-
-  def test_nested_transaction_raises_error
-    assert_raise(PStore::Error) do
-      @pstore.transaction { @pstore.transaction { } }
-    end
-    pstore = PStore.new(second_file, true)
-    assert_raise(PStore::Error) do
-      pstore.transaction { pstore.transaction { } }
-    end
-  ensure
-    File.unlink(second_file) rescue nil
-  end
-
-  # Test that PStore's file operations do not blow up when default encodings are set
-  def test_pstore_files_are_accessed_as_binary_files
-    bug5311 = '[ruby-core:39503]'
-    n = 128
-    assert_in_out_err(["-Eutf-8:utf-8", "-rpstore", "-", @pstore_file], <<-SRC, [bug5311], [], bug5311, timeout: 30)
-      @pstore = PStore.new(ARGV[0])
-      (1..#{n}).each do |i|
-        @pstore.transaction {@pstore["Key\#{i}"] = "value \#{i}"}
-      end
-      @pstore.transaction {@pstore["Bug5311"] = '#{bug5311}'}
-      puts @pstore.transaction {@pstore["Bug5311"]}
-    SRC
-    assert_equal(bug5311, @pstore.transaction {@pstore["Bug5311"]}, bug5311)
-  end
-
-  def test_key_p
-    [:key?, :root?].each do |method|
-      clear_store
-      @pstore.transaction do
-        @pstore[:foo] = 0
-        assert_equal(true, @pstore.send(method, :foo))
-        assert_equal(false, @pstore.send(method, :bar))
-      end
-    end
-  end
-
-  def test_keys
-    [:keys, :roots].each do |method|
-      clear_store
-      @pstore.transaction do
-        assert_equal([], @pstore.send(method))
-      end
-      @pstore.transaction do
-        @pstore[:foo] = 0
-        assert_equal([:foo], @pstore.send(method))
-      end
-    end
-  end
-
-  def clear_store
-    @pstore.transaction do
-      @pstore.keys.each do |key|
-        @pstore.delete(key)
-      end
-    end
-  end
-
-  def second_file
-    File.join(Dir.tmpdir, "pstore.tmp2.#{Process.pid}")
-  end
-end
diff --git a/test/mri/win32ole/available_ole.rb b/test/mri/win32ole/available_ole.rb
deleted file mode 100644
index af397e00b59..00000000000
--- a/test/mri/win32ole/available_ole.rb
+++ /dev/null
@@ -1,41 +0,0 @@
-begin
-  require 'win32ole'
-rescue LoadError
-end
-
-if defined?(WIN32OLE)
-  module AvailableOLE
-    module_function
-
-    def sysmon_available?
-      WIN32OLE::Type.new('System Monitor Control', 'SystemMonitor')
-      true
-    rescue
-      false
-    end
-
-    def ado_available?
-      WIN32OLE.new('ADODB.Connection')
-      true
-    rescue
-      false
-    end
-
-    def msxml_available?
-      !WIN32OLE::TypeLib.typelibs.find { |t| t.name.start_with?('Microsoft XML') }.nil?
-    end
-
-    def event_param
-      method = if msxml_available?
-                 typelib = WIN32OLE::TypeLib.typelibs.find { |t| t.name.start_with?('Microsoft XML') }
-                 ole_type = WIN32OLE::Type.new(typelib.name, 'IVBSAXContentHandler')
-                 WIN32OLE::Method.new(ole_type, 'startElement')
-               elsif ado_available?
-                 typelib = WIN32OLE.new('ADODB.Connection').ole_typelib
-                 ole_type = WIN32OLE::Type.new(typelib.name, 'Connection')
-                 WIN32OLE::Method.new(ole_type, 'WillConnect')
-               end
-      method && method.params[0]
-    end
-  end
-end
diff --git a/test/mri/win32ole/err_in_callback.rb b/test/mri/win32ole/err_in_callback.rb
deleted file mode 100644
index baecf780b67..00000000000
--- a/test/mri/win32ole/err_in_callback.rb
+++ /dev/null
@@ -1,10 +0,0 @@
-# frozen_string_literal: false
-require 'win32ole'
-db = WIN32OLE.new('ADODB.Connection')
-db.connectionString = "Driver={Microsoft Text Driver (*.txt; *.csv)};DefaultDir=.;"
-ev = WIN32OLE::Event.new(db)
-ev.on_event('WillConnect') {|*args|
-  foo
-}
-db.open
-WIN32OLE::Event.message_loop
diff --git a/test/mri/win32ole/orig_data.csv b/test/mri/win32ole/orig_data.csv
deleted file mode 100644
index 3931c6ad1b9..00000000000
--- a/test/mri/win32ole/orig_data.csv
+++ /dev/null
@@ -1,5 +0,0 @@
-ID,VALUE
-1,"A"
-2,"B"
-3,"C"
-4,"B"
diff --git a/test/mri/win32ole/test_err_in_callback.rb b/test/mri/win32ole/test_err_in_callback.rb
deleted file mode 100644
index bea5781bc9e..00000000000
--- a/test/mri/win32ole/test_err_in_callback.rb
+++ /dev/null
@@ -1,56 +0,0 @@
-# frozen_string_literal: false
-#
-# test Win32OLE avoids cfp consistency error when the exception raised
-# in WIN32OLE::Event handler block. [ruby-dev:35450]
-#
-
-begin
-  require 'win32ole'
-rescue LoadError
-end
-if defined?(WIN32OLE)
-  require 'mkmf'
-  require 'pathname'
-  require 'test/unit'
-  require 'tmpdir'
-  class TestErrInCallBack < Test::Unit::TestCase
-    def setup
-      @ruby = nil
-      if File.exist?("./" + CONFIG["RUBY_INSTALL_NAME"] + CONFIG["EXEEXT"])
-        sep = File::ALT_SEPARATOR || "/"
-        @ruby = "." + sep + CONFIG["RUBY_INSTALL_NAME"]
-        cwd = Pathname.new(File.expand_path('.'))
-        @iopt = $:.map {|e|
-          " -I " + (Pathname.new(e).relative_path_from(cwd).to_s rescue e)
-        }.join("")
-        script = File.join(File.dirname(__FILE__), "err_in_callback.rb")
-        @script = Pathname.new(script).relative_path_from(cwd).to_s rescue script
-      end
-    end
-
-    def available_adodb?
-      begin
-        WIN32OLE.new('ADODB.Connection')
-      rescue WIN32OLE::RuntimeError
-        return false
-      end
-      return true
-    end
-
-    def test_err_in_callback
-      omit "'ADODB.Connection' is not available" unless available_adodb?
-      if @ruby
-        Dir.mktmpdir do |tmpdir|
-          logfile = File.join(tmpdir, "test_err_in_callback.log")
-          cmd = "#{@ruby} -v #{@iopt} #{@script} > #{logfile.gsub(%r(/), '\\')} 2>&1"
-          system(cmd)
-          str = ""
-          open(logfile) {|ifs|
-            str = ifs.read
-          }
-          assert_match(/NameError/, str)
-        end
-      end
-    end
-  end
-end
diff --git a/test/mri/win32ole/test_folderitem2_invokeverb.rb b/test/mri/win32ole/test_folderitem2_invokeverb.rb
deleted file mode 100644
index a1c2b2f472c..00000000000
--- a/test/mri/win32ole/test_folderitem2_invokeverb.rb
+++ /dev/null
@@ -1,66 +0,0 @@
-# frozen_string_literal: false
-#
-# This script check that Win32OLE can execute InvokeVerb method of FolderItem2.
-#
-
-begin
-  require 'win32ole'
-rescue LoadError
-end
-require 'test/unit'
-
-if defined?(WIN32OLE)
-  class TestInvokeVerb < Test::Unit::TestCase
-    def setup
-      # make dummy file for InvokeVerb test.
-      @fso = WIN32OLE.new('Scripting.FileSystemObject')
-      dummy_file = @fso.GetTempName
-      @cfolder = @fso.getFolder(".")
-      f = @cfolder.CreateTextFile(dummy_file)
-      f.close
-      @dummy_path = @cfolder.path + "\\" + dummy_file
-
-      shell=WIN32OLE.new('Shell.Application')
-      @nsp = shell.NameSpace(@cfolder.path)
-      @fi2 = @nsp.parseName(dummy_file)
-    end
-
-    def find_link(path)
-      arlink = []
-      @cfolder.files.each do |f|
-        if /\.lnk$/ =~ f.path
-          linkinfo = @nsp.parseName(f.name).getLink
-          arlink.push f if linkinfo.path == path
-        end
-      end
-      arlink
-    end
-
-    def test_invokeverb
-      # in Windows Vista (not tested), Windows 7
-      # The verb must be in English.
-      # Creating Shortcut is "Link"
-      links = find_link(@dummy_path)
-      assert_equal(0, links.size)
-
-      # Now create shortcut to @dummy_path
-      arg = WIN32OLE::Variant.new("Link")
-      @fi2.InvokeVerb(arg)
-
-      # Now search shortcut to @dummy_path
-      links = find_link(@dummy_path)
-      assert_equal(1, links.size)
-      @lpath = links[0].path
-    end
-
-    def teardown
-      if @lpath
-        @fso.deleteFile(@lpath)
-      end
-      if @dummy_path
-        @fso.deleteFile(@dummy_path)
-      end
-    end
-
-  end
-end
diff --git a/test/mri/win32ole/test_nil2vtempty.rb b/test/mri/win32ole/test_nil2vtempty.rb
deleted file mode 100644
index bd864036766..00000000000
--- a/test/mri/win32ole/test_nil2vtempty.rb
+++ /dev/null
@@ -1,37 +0,0 @@
-# frozen_string_literal: false
-# This is test script to check that WIN32OLE should convert nil to VT_EMPTY in second try.
-# [ruby-talk:137054]
-begin
-  require 'win32ole'
-rescue LoadError
-end
-require 'test/unit'
-
-if defined?(WIN32OLE)
-  class TestNIL2VT_EMPTY < Test::Unit::TestCase
-    def setup
-      fs = WIN32OLE.new('Scripting.FileSystemObject')
-      @path = fs.GetFolder(".").path
-    end
-    def test_openSchema
-      con = nil
-      begin
-        con = WIN32OLE.new('ADODB.Connection')
-        con.connectionString = "Provider=MSDASQL;Extended Properties="
-        con.connectionString +="\"DRIVER={Microsoft Text Driver (*.txt; *.csv)};DBQ=#{@path}\""
-        con.open
-      rescue
-        con = nil
-      end
-      if con
-        rs = con.openSchema(4, [nil,nil,"DUMMY", "TABLE"])
-        assert(rs)
-        assert_equal("_Recordset", rs.ole_type.name)
-
-        rs = con.openSchema(4, [WIN32OLE::Variant::Empty, WIN32OLE::Variant::Empty, "DUMMY", "TABLE"])
-        assert(rs)
-        assert_equal("_Recordset", rs.ole_type.name)
-      end
-    end
-  end
-end
diff --git a/test/mri/win32ole/test_ole_methods.rb b/test/mri/win32ole/test_ole_methods.rb
deleted file mode 100644
index fbade04e482..00000000000
--- a/test/mri/win32ole/test_ole_methods.rb
+++ /dev/null
@@ -1,35 +0,0 @@
-# frozen_string_literal: false
-#
-# This is test for [ruby-talk:196897]
-#
-begin
-  require 'win32ole'
-rescue LoadError
-end
-require "test/unit"
-
-if defined?(WIN32OLE)
-  class TestWIN32OLE_FOR_PROPERTYPUTREF < Test::Unit::TestCase
-
-    def setup
-      @obj = WIN32OLE.new('Scripting.Dictionary')
-    end
-
-    def test_ole_methods
-      x = @obj.ole_methods.select {|m|
-        m.invoke_kind == 'PROPERTYPUTREF'
-      }
-      assert_equal(1, x.size)
-      assert_equal('Item', x[0].name)
-    end
-
-    def test_ole_put_methods
-      x = @obj.ole_put_methods.select {|m|
-        m.invoke_kind == 'PROPERTYPUTREF'
-      }
-      assert_equal(1, x.size)
-      assert_equal('Item', x[0].name)
-    end
-
-  end
-end
diff --git a/test/mri/win32ole/test_propertyputref.rb b/test/mri/win32ole/test_propertyputref.rb
deleted file mode 100644
index 83418140c2e..00000000000
--- a/test/mri/win32ole/test_propertyputref.rb
+++ /dev/null
@@ -1,31 +0,0 @@
-# frozen_string_literal: false
-require 'test/unit'
-begin
-  require 'win32ole'
-rescue LoadError
-end
-
-if defined?(WIN32OLE)
-  class TestWIN32OLE_PROPERTYPUTREF < Test::Unit::TestCase
-    def setup
-      begin
-        @sapi = WIN32OLE.new('SAPI.SpVoice')
-        @sv = @sapi.voice
-      rescue WIN32OLE::RuntimeError
-        @sapi = nil
-      end
-    end
-    def test_sapi
-      if @sapi
-        new_id = @sapi.getvoices.item(0).Id
-        @sapi.voice = @sapi.getvoices.item(0)
-        assert_equal(new_id, @sapi.voice.Id)
-      end
-    end
-    def teardown
-      if @sapi
-        @sapi.voice = @sv
-      end
-    end
-  end
-end
diff --git a/test/mri/win32ole/test_thread.rb b/test/mri/win32ole/test_thread.rb
deleted file mode 100644
index b30b2349c5f..00000000000
--- a/test/mri/win32ole/test_thread.rb
+++ /dev/null
@@ -1,34 +0,0 @@
-# frozen_string_literal: false
-begin
-  require 'win32ole'
-rescue LoadError
-end
-require 'test/unit'
-
-if defined?(WIN32OLE)
-  class TestWIN32OLE_THREAD < Test::Unit::TestCase
-    #
-    # test for Bug #2618(ruby-core:27634)
-    #
-    def assert_creating_win32ole_object_in_thread(meth)
-      t = Thread.__send__(meth) {
-        WIN32OLE.new('Scripting.Dictionary')
-      }
-      assert_nothing_raised(WIN32OLE::RuntimeError, "[Bug #2618] Thread.#{meth}") {
-        t.join
-      }
-    end
-
-    def test_creating_win32ole_object_in_thread_new
-      assert_creating_win32ole_object_in_thread(:new)
-    end
-
-    def test_creating_win32ole_object_in_thread_start
-      assert_creating_win32ole_object_in_thread(:start)
-    end
-
-    def test_creating_win32ole_object_in_thread_fork
-      assert_creating_win32ole_object_in_thread(:fork)
-    end
-  end
-end
diff --git a/test/mri/win32ole/test_win32ole.rb b/test/mri/win32ole/test_win32ole.rb
deleted file mode 100644
index b0c147b3116..00000000000
--- a/test/mri/win32ole/test_win32ole.rb
+++ /dev/null
@@ -1,536 +0,0 @@
-# coding: us-ascii
-# frozen_string_literal: false
-
-begin
-  require 'win32ole'
-rescue LoadError
-end
-require 'test/unit'
-
-if defined?(WIN32OLE)
-  module CONST1
-  end
-  module CONST2
-  end
-
-  module TestCaseForDict
-    def test_convert_bignum
-      @dict1.add("a", 9999999999)
-      @dict1.add("b", 999999999)
-      @dict1.add("c", @dict1.item("b") * 10 + 9)
-      assert_equal(9999999999, @dict1.item("a"))
-      assert_equal(9999999999, @dict1.item("c"))
-    end
-    def test_add
-      @dict1.add("a", 1000)
-      assert_equal(1000, @dict1.item("a"))
-    end
-    def test_setproperty_equal_ended
-      @dict1.compareMode = 1
-      @dict1.add("one", 1)
-      assert_equal(1, @dict1.item("ONE"))
-      @dict2.add("one", 1)
-      assert_nil(@dict2.item("ONE"))
-      assert_equal(1, @dict2.item("one"))
-    end
-    def test_non_exist_property
-      assert_raise(WIN32OLE::RuntimeError) {
-        @dict1.unknown_property = 1
-      }
-    end
-
-    def test_raise_message
-      exc = assert_raise(WIN32OLE::RuntimeError) {
-        @dict1.add
-      }
-      assert_match(/^$in OLE method `add': $/, exc.message) #`
-
-      exc = assert_raise(WIN32OLE::RuntimeError) {
-        @dict1._invoke(1, [], [])
-      }
-      assert_match(/^$in OLE method `<dispatch id:1>': $/, exc.message) #`
-
-      exc = assert_raise(WIN32OLE::RuntimeError) {
-        @dict1.compareMode = -1
-      }
-      assert_match(/^$in setting property `compareMode': $/, exc.message) #`
-    end
-
-    def test_no_method_error
-      exc = assert_raise(NoMethodError) {
-        @dict1.non_exist_method
-      }
-      assert_match(/non_exist_method/, exc.message)
-      assert_kind_of(WIN32OLE, exc.receiver)
-    end
-
-    def test_ole_methods
-      methods = @dict1.ole_methods
-      mnames = methods.collect {|m|
-        m.name
-      }
-      assert_include(mnames, 'Add')
-    end
-
-    def test_methods
-      methods = @dict1.methods
-      assert_include(methods, :Add)
-    end
-
-    def test_ole_func_methods
-      methods = @dict1.ole_func_methods
-      mnames = methods.collect {|m|
-        m.name
-      }
-      assert_include(mnames, 'Add')
-    end
-
-    def test_ole_put_methods
-      methods = @dict1.ole_put_methods
-      mnames = methods.collect {|m|
-        m.name
-      }
-      assert_include(mnames, 'CompareMode')
-    end
-
-    def test_ole_get_methods
-      methods = @dict1.ole_get_methods
-      mnames = methods.collect {|m|
-        m.name
-      }
-      assert_include(mnames, 'Count')
-    end
-
-    def test_ole_method_help
-      minfo = @dict1.ole_method_help("Add")
-      assert_equal(2, minfo.size_params)
-    end
-
-    def test_ole_typelib
-      tlib = @dict1.ole_typelib
-      assert_equal("Microsoft Scripting Runtime", tlib.name);
-    end
-
-    def test_each
-      @dict1.add("one", 1)
-      @dict1.add("two", 2)
-      i = 0
-      @dict1.keys.each do |item|
-        i += 1
-      end
-      assert_equal(2, i)
-    end
-
-    def test_bracket
-      @dict1.add("foo", "FOO")
-      assert_equal("FOO", @dict1.item("foo"))
-      assert_equal("FOO", @dict1["foo"])
-    end
-
-    def test_bracket_equal
-      @dict1.add("foo", "FOO")
-      @dict1["foo"] = "BAR"
-      assert_equal("BAR", @dict1["foo"])
-    end
-
-    def test_bracket_with_numkey
-      @dict1.add(1, "ONE")
-      @dict1.add(2, "two")
-      assert_equal("ONE", @dict1[1])
-      @dict1[2] = "TWO"
-      assert_equal("TWO", @dict1[2])
-    end
-
-    def test_invoke_with_array
-      @dict1.add("ary1", [1,2,3])
-      assert_equal([1,2,3], @dict1["ary1"])
-
-      @dict1.add("ary2", [[1,2,"a"], [3,4,"b"]])
-      assert_equal([[1,2,"a"], [3,4,"b"]], @dict1["ary2"])
-
-      @dict1.add("ary3", [[[1]]])
-      assert_equal([[[1]]], @dict1["ary3"])
-
-      @dict1.add("ary4", [[[1], [2], [3]], [[4], [5], [6]]])
-      assert_equal([[[1],[2], [3]], [[4], [5], [6]]], @dict1["ary4"])
-    end
-  end
-
-  class TestWin32OLE < Test::Unit::TestCase
-    include TestCaseForDict
-    def setup
-      @dict1 = WIN32OLE.new('Scripting.Dictionary')
-      @dict2 = WIN32OLE.new('Scripting.Dictionary')
-    end
-    def test_s_new
-      assert_instance_of(WIN32OLE, @dict1)
-      assert_instance_of(WIN32OLE, @dict2)
-    end
-
-    def test_s_new_exc
-      assert_raise(TypeError) {
-        WIN32OLE.new(1)
-      }
-      assert_raise(TypeError) {
-        WIN32OLE.new("Scripting.Dictionary", 1)
-      }
-    end
-
-    def test_s_new_DCOM
-      rshell = WIN32OLE.new("Shell.Application")
-      assert_instance_of(WIN32OLE, rshell)
-    end
-
-    def test_s_new_from_clsid
-      shell = WIN32OLE.new("{13709620-C279-11CE-A49E-444553540000}")
-      assert_instance_of(WIN32OLE, shell)
-      exc = assert_raise(WIN32OLE::RuntimeError) {
-        WIN32OLE.new("{000}")
-      }
-      assert_match(/unknown OLE server: `\{000\}'/, exc.message) #`
-    end
-
-    def test_s_connect
-      obj = WIN32OLE.connect("winmgmts:")
-      assert_instance_of(WIN32OLE, obj)
-    end
-
-    def test_s_connect_exc
-      assert_raise(TypeError) {
-        WIN32OLE.connect(1)
-      }
-    end
-
-    def test_invoke_accept_symbol_hash_key
-      fso = WIN32OLE.new('Scripting.FileSystemObject')
-      afolder = fso.getFolder(".")
-      bfolder = fso.getFolder({"FolderPath" => "."})
-      cfolder = fso.getFolder({:FolderPath => "."})
-      assert_equal(afolder.path, bfolder.path)
-      assert_equal(afolder.path, cfolder.path)
-      fso = nil
-    end
-
-    def test_setproperty
-      installer = WIN32OLE.new("WindowsInstaller.Installer")
-      record = installer.CreateRecord(2)
-      # this is the way to set property with argument in Win32OLE.
-      record.setproperty( "StringData", 1, 'dddd')
-      assert_equal('dddd', record.StringData(1))
-    end
-
-    def test_ole_type
-      fso = WIN32OLE.new('Scripting.FileSystemObject')
-      tobj = fso.ole_type
-      assert_match(/^IFileSystem/, tobj.name)
-    end
-
-    def test_ole_obj_help
-      fso = WIN32OLE.new('Scripting.FileSystemObject')
-      tobj = fso.ole_obj_help
-      assert_match(/^IFileSystem/, tobj.name)
-    end
-
-
-    def test_invoke_hash_key_non_str_sym
-      fso = WIN32OLE.new('Scripting.FileSystemObject')
-      begin
-        fso.getFolder({1 => "."})
-        assert(false)
-      rescue TypeError
-        assert(true)
-      end
-      fso = nil
-    end
-
-    def test_get_win32ole_object
-      shell = WIN32OLE.new('Shell.Application')
-      folder = shell.nameSpace(0)
-      assert_instance_of(WIN32OLE, folder)
-    end
-
-    def test_invoke_accept_multi_hash_key
-      shell = WIN32OLE.new('Shell.Application')
-      folder = shell.nameSpace(0)
-      item = folder.items.item(0)
-      name = folder.getDetailsOf(item, 0)
-      assert_equal(item.name, name)
-      name = folder.getDetailsOf({:vItem => item, :iColumn => 0})
-      assert_equal(item.name, name)
-      name = folder.getDetailsOf({"vItem" => item, :iColumn => 0})
-      assert_equal(item.name, name)
-    end
-
-    def test_ole_invoke_with_named_arg_last
-      shell = WIN32OLE.new('Shell.Application')
-      folder = shell.nameSpace(0)
-      item = folder.items.item(0)
-      name = folder.getDetailsOf(item, {:iColumn => 0})
-      assert_equal(item.name, name)
-    end
-
-    def test__invoke
-      shell=WIN32OLE.new('Shell.Application')
-      assert_equal(shell.NameSpace(0).title, shell._invoke(0x60020002, [0], [WIN32OLE::VARIANT::VT_VARIANT]).title)
-    end
-
-    def test_ole_query_interface
-      shell=WIN32OLE.new('Shell.Application')
-      assert_raise(ArgumentError) {
-        shell.ole_query_interface
-      }
-      assert_raise(TypeError) {
-        shell.ole_query_interface(0x11223344)
-      }
-      shell2 = shell.ole_query_interface('{A4C6892C-3BA9-11D2-9DEA-00C04FB16162}')
-      assert_instance_of(WIN32OLE, shell2)
-    end
-
-    def test_ole_respond_to
-      fso = WIN32OLE.new('Scripting.FileSystemObject')
-      assert(fso.ole_respond_to?('getFolder'))
-      assert(fso.ole_respond_to?('GETFOLDER'))
-      assert(fso.ole_respond_to?(:getFolder))
-      assert(!fso.ole_respond_to?('XXXXX'))
-      assert_raise(TypeError) {
-        assert_raise(fso.ole_respond_to?(1))
-      }
-    end
-
-    def test_invoke
-      fso = WIN32OLE.new('Scripting.FileSystemObject')
-      assert(fso.invoke(:getFolder, "."))
-      assert(fso.invoke('getFolder', "."))
-    end
-
-    def test_s_const_load
-      assert(!defined?(CONST1::SsfWINDOWS))
-      shell=WIN32OLE.new('Shell.Application')
-      WIN32OLE.const_load(shell, CONST1)
-      assert_equal(36, CONST1::SsfWINDOWS)
-
-      assert(!defined?(CONST2::SsfWINDOWS))
-      WIN32OLE.const_load("Microsoft Shell Controls And Automation", CONST2)
-      assert_equal(36, CONST2::SsfWINDOWS)
-    end
-
-    def test_s_create_guid
-      guid = WIN32OLE.create_guid
-      assert_match(/^\{[A-Z0-9]{8}\-[A-Z0-9]{4}\-[A-Z0-9]{4}\-[A-Z0-9]{4}\-[A-Z0-9]{12}/,
-                   guid)
-    end
-
-    #
-    # WIN32OLE.codepage is initialized according to Encoding.default_external.
-    #
-    # def test_s_codepage
-    #   assert_equal(WIN32OLE::CP_ACP, WIN32OLE.codepage)
-    # end
-
-    def test_s_codepage_set
-      cp = WIN32OLE.codepage
-      WIN32OLE.codepage = WIN32OLE::CP_UTF8
-      assert_equal(WIN32OLE::CP_UTF8, WIN32OLE.codepage)
-      WIN32OLE.codepage = cp
-    end
-
-    def test_s_codepage_changed
-      omit if RUBY_PLATFORM.match("mswin")
-
-      cp = WIN32OLE.codepage
-      fso = WIN32OLE.new("Scripting.FileSystemObject")
-      fname = fso.getTempName
-      begin
-        obj = WIN32OLE::Variant.new([0x3042].pack("U*").force_encoding("UTF-8"))
-        WIN32OLE.codepage = WIN32OLE::CP_UTF8
-        assert_equal("\xE3\x81\x82".force_encoding("CP65001"), obj.value)
-
-        begin
-          WIN32OLE.codepage = 932 # Windows-31J
-        rescue WIN32OLE::RuntimeError
-        end
-        if (WIN32OLE.codepage == 932)
-          assert_equal("\x82\xA0".force_encoding("CP932"), obj.value)
-        end
-
-        begin
-          WIN32OLE.codepage = 20932 # MS EUC-JP
-        rescue WIN32OLE::RuntimeError
-        end
-        if (WIN32OLE.codepage == 20932)
-          assert_equal("\xA4\xA2".force_encoding("CP20932"), obj.value)
-        end
-
-        WIN32OLE.codepage = cp
-        file = fso.opentextfile(fname, 2, true)
-        test_str = [0x3042].pack("U*").encode("UTF-16LE")
-        begin
-          file.write test_str.force_encoding("UTF-16")
-        ensure
-          file.close
-        end
-        str = ""
-        open(fname, "r:ascii-8bit") {|ifs|
-          str = ifs.read
-        }
-        assert_equal(test_str.force_encoding("ascii-8bit"), str)
-
-        # This test fail if codepage 20932 (euc) is not installed.
-        begin
-          WIN32OLE.codepage = 20932
-        rescue WIN32OLE::RuntimeError
-        end
-        if (WIN32OLE.codepage == 20932)
-          WIN32OLE.codepage = cp
-          file = fso.opentextfile(fname, 2, true)
-          begin
-            file.write [164, 162].pack("c*").force_encoding("UTF-16")
-          ensure
-            file.close
-          end
-          open(fname, "r:ascii-8bit") {|ifs|
-            str = ifs.read
-          }
-          assert_equal("\244\242", str)
-        end
-
-      ensure
-        WIN32OLE.codepage = cp
-        if (File.exist?(fname))
-          File.unlink(fname)
-        end
-      end
-    end
-
-    def test_cp51932
-      cp = WIN32OLE.codepage
-      begin
-        obj = WIN32OLE::Variant.new([0x3042].pack("U*").force_encoding("UTF-8"))
-        begin
-          WIN32OLE.codepage = 51932
-        rescue
-        end
-        if WIN32OLE.codepage == 51932
-          assert_equal("\xA4\xA2".force_encoding("CP51932"), obj.value)
-        end
-      ensure
-        WIN32OLE.codepage = cp
-      end
-    end
-
-    def test_s_locale
-      assert_equal(WIN32OLE::LOCALE_SYSTEM_DEFAULT, WIN32OLE.locale)
-    end
-
-    def test_s_locale_set
-      begin
-        begin
-          WIN32OLE.locale = 1041
-        rescue WIN32OLE::RuntimeError
-          STDERR.puts("\n#{__FILE__}:#{__LINE__}:#{self.class.name}.test_s_locale_set is skipped(Japanese locale is not installed)")
-          return
-        end
-        assert_equal(1041, WIN32OLE.locale)
-        WIN32OLE.locale = WIN32OLE::LOCALE_SYSTEM_DEFAULT
-        assert_raise(WIN32OLE::RuntimeError) {
-          WIN32OLE.locale = 111
-        }
-        assert_equal(WIN32OLE::LOCALE_SYSTEM_DEFAULT, WIN32OLE.locale)
-      ensure
-        WIN32OLE.locale = WIN32OLE::LOCALE_SYSTEM_DEFAULT
-      end
-    end
-
-    def test_s_locale_change
-      begin
-        begin
-          WIN32OLE.locale = 0x0411
-        rescue WIN32OLE::RuntimeError
-        end
-        if WIN32OLE.locale == 0x0411
-          obj = WIN32OLE::Variant.new("\\100,000", WIN32OLE::VARIANT::VT_CY)
-          assert_equal("100000", obj.value)
-          assert_raise(WIN32OLE::RuntimeError) {
-            obj = WIN32OLE::Variant.new("$100.000", WIN32OLE::VARIANT::VT_CY)
-          }
-        else
-          STDERR.puts("\n#{__FILE__}:#{__LINE__}:#{self.class.name}.test_s_locale_change is skipped(Japanese locale is not installed)")
-        end
-
-        begin
-          WIN32OLE.locale = 1033
-        rescue WIN32OLE::RuntimeError
-        end
-        if WIN32OLE.locale == 1033
-          obj = WIN32OLE::Variant.new("$100,000", WIN32OLE::VARIANT::VT_CY)
-          assert_equal("100000", obj.value)
-        else
-          STDERR.puts("\n#{__FILE__}:#{__LINE__}:#{self.class.name}.test_s_locale_change is skipped(US English locale is not installed)")
-        end
-      ensure
-        WIN32OLE.locale = WIN32OLE::LOCALE_SYSTEM_DEFAULT
-      end
-    end
-
-    def test_const_CP_ACP
-      assert_equal(0, WIN32OLE::CP_ACP)
-    end
-
-    def test_const_CP_OEMCP
-      assert_equal(1, WIN32OLE::CP_OEMCP)
-    end
-
-    def test_const_CP_MACCP
-      assert_equal(2, WIN32OLE::CP_MACCP)
-    end
-
-    def test_const_CP_THREAD_ACP
-      assert_equal(3, WIN32OLE::CP_THREAD_ACP)
-    end
-
-    def test_const_CP_SYMBOL
-      assert_equal(42, WIN32OLE::CP_SYMBOL)
-    end
-
-    def test_const_CP_UTF7
-      assert_equal(65000, WIN32OLE::CP_UTF7)
-    end
-
-    def test_const_CP_UTF8
-      assert_equal(65001, WIN32OLE::CP_UTF8)
-    end
-
-    def test_const_LOCALE_SYSTEM_DEFAULT
-      assert_equal(0x0800, WIN32OLE::LOCALE_SYSTEM_DEFAULT);
-    end
-
-    def test_const_LOCALE_USER_DEFAULT
-      assert_equal(0x0400, WIN32OLE::LOCALE_USER_DEFAULT);
-    end
-
-    def test_method_missing
-      assert_raise(ArgumentError) {@dict1.method_missing}
-      assert_raise(TypeError) {@dict1.method_missing(1)}
-      assert_raise(ArgumentError) {@dict1.method_missing("foo=")}
-      assert_raise(ArgumentError) {@dict1.method_missing("foo=", 1, 2)}
-    end
-  end
-
-  # test of subclass of WIN32OLE
-  class MyDict < WIN32OLE
-    def MyDict.new
-      super('Scripting.Dictionary')
-    end
-  end
-  class TestMyDict < Test::Unit::TestCase
-    include TestCaseForDict
-    def setup
-      @dict1 = MyDict.new
-      @dict2 = MyDict.new
-    end
-    def test_s_new
-      assert_instance_of(MyDict, @dict1)
-      assert_instance_of(MyDict, @dict2)
-    end
-  end
-end
diff --git a/test/mri/win32ole/test_win32ole_event.rb b/test/mri/win32ole/test_win32ole_event.rb
deleted file mode 100644
index da3ee8567e8..00000000000
--- a/test/mri/win32ole/test_win32ole_event.rb
+++ /dev/null
@@ -1,407 +0,0 @@
-# frozen_string_literal: false
-begin
-  require 'win32ole'
-rescue LoadError
-end
-require 'test/unit'
-
-ado_installed =
-  if defined?(WIN32OLE)
-    db = nil
-    begin
-      db = WIN32OLE.new('ADODB.Connection')
-      db.connectionString = "Driver={Microsoft Text Driver (*.txt; *.csv)};DefaultDir=.;"
-      db.open
-      db.close
-      db = nil
-      true
-    rescue
-    end
-  end
-
-swbemsink_available =
-  if defined?(WIN32OLE)
-    begin
-      WIN32OLE.new('WbemScripting.SWbemSink')
-      true
-    rescue
-    end
-  end
-
-if defined?(WIN32OLE::Event)
-  class TestWIN32OLE_EVENT < Test::Unit::TestCase
-    def test_s_new_exception
-      assert_raise(TypeError) {
-        WIN32OLE::Event.new("A")
-      }
-    end
-    def test_s_new_non_exist_event
-      dict = WIN32OLE.new('Scripting.Dictionary')
-      assert_raise(RuntimeError) {
-        WIN32OLE::Event.new(dict)
-      }
-    end
-  end
-
-  if swbemsink_available
-    class TestWIN32OLE_EVENT_SWbemSink < Test::Unit::TestCase
-      def setup
-        @wmi = WIN32OLE.connect('winmgmts://localhost/root/cimv2')
-        @sws = WIN32OLE.new('WbemScripting.SWbemSink')
-        @event = @event1 = @event2 = ""
-        @sql = "SELECT * FROM __InstanceModificationEvent WITHIN 1 WHERE TargetInstance ISA 'Win32_LocalTime'"
-      end
-
-      def message_loop(watch_ivar = nil)
-        if watch_ivar
-          orig_ivar = instance_variable_get(watch_ivar)
-        end
-
-        2.times do
-          WIN32OLE::Event.message_loop
-          sleep 1
-        end
-
-        if watch_ivar
-          # wait until event is proceeded
-          tries = 0
-          seconds = EnvUtil.apply_timeout_scale(1)
-          while tries < 5 && instance_variable_get(watch_ivar) == orig_ivar
-            $stderr.puts "test_win32ole_event.rb: retrying and sleeping #{seconds}s until #{watch_ivar} is changed from #{orig_ivar.inspect}..."
-            WIN32OLE::Event.message_loop
-            sleep(seconds)
-            tries += 1
-            seconds *= 2 # sleep at most 31s in total
-          end
-        end
-      end
-
-      def default_handler(event, *args)
-        @event += event
-      end
-
-      def handler1
-        @event1 = "handler1"
-      end
-
-      def test_s_new_non_exist_event
-        assert_raise(RuntimeError) {
-          WIN32OLE::Event.new(@sws, 'XXXXX')
-        }
-      end
-
-      def test_s_new
-        obj = WIN32OLE::Event.new(@sws, 'ISWbemSinkEvents')
-        assert_instance_of(WIN32OLE::Event, obj)
-        obj = WIN32OLE::Event.new(@sws)
-        assert_instance_of(WIN32OLE::Event, obj)
-      end
-
-      def test_s_new_loop
-        exec_notification_query_async
-        ev = WIN32OLE::Event.new(@sws)
-        ev.on_event {|*args| default_handler(*args)}
-        message_loop
-        10.times do |i|
-          WIN32OLE::Event.new(@sws)
-          message_loop
-          GC.start
-        end
-
-        # @event randomly becomes "OnCompleted" here. Try to wait until it matches.
-        # https://ci.appveyor.com/project/ruby/ruby/builds/19963142/job/8gaxepksa0i3b998
-        assert_match_with_retries(/OnObjectReady/, :@event)
-      end
-
-      def test_on_event
-        exec_notification_query_async
-        ev = WIN32OLE::Event.new(@sws, 'ISWbemSinkEvents')
-        ev.on_event {|*args| default_handler(*args)}
-        message_loop(:@event)
-        assert_match(/OnObjectReady/, @event)
-      end
-
-      def test_on_event_symbol
-        exec_notification_query_async
-        ev = WIN32OLE::Event.new(@sws)
-        ev.on_event(:OnObjectReady) {|*args|
-          handler1
-        }
-        message_loop(:@event1)
-        assert_equal("handler1", @event1)
-      end
-
-      private
-      def exec_notification_query_async
-        @wmi.ExecNotificationQueryAsync(@sws, @sql)
-      rescue => e
-        if /OLE error code:80041008 in SWbemServicesEx/ =~ e.message
-          omit "No administrator privilege?"
-        end
-        raise
-      end
-
-      def assert_match_with_retries(regexp, ivarname)
-        ivar = instance_variable_get(ivarname)
-
-        tries = 0
-        while tries < 6 && !ivar.match(regexp)
-          $stderr.puts "test_win32ole_event.rb: retrying until #{ivarname} (#{ivar}) matches #{regexp} (tries: #{tries})..."
-          sleep(2 ** tries) # sleep at most 63s in total
-          ivar = instance_variable_get(ivarname)
-          tries += 1
-        end
-
-        assert_match(regexp, ivar)
-      end
-    end
-  end
-
-  if ado_installed
-    class TestWIN32OLE_EVENT_ADO < Test::Unit::TestCase
-      CONNSTR="Driver={Microsoft Text Driver (*.txt; *.csv)};DefaultDir=.;"
-      module ADO
-      end
-      def message_loop
-        WIN32OLE::Event.message_loop
-      end
-
-      def default_handler(event, *args)
-        @event += event
-      end
-
-      def setup
-        @db = WIN32OLE.new('ADODB.Connection')
-        if !defined?(ADO::AdStateOpen)
-          WIN32OLE.const_load(@db, ADO)
-        end
-        @db.connectionString = CONNSTR
-        @event = ""
-        @event2 = ""
-        @event3 = ""
-      end
-
-      def test_on_event2
-        ev = WIN32OLE::Event.new(@db, 'ConnectionEvents')
-        ev.on_event('WillConnect') {|*args| handler1}
-        ev.on_event('WillConnect') {|*args| handler2}
-        @db.open
-        message_loop
-        assert_equal("handler2", @event2)
-      end
-
-      def test_on_event4
-        ev = WIN32OLE::Event.new(@db, 'ConnectionEvents')
-        ev.on_event{|*args| handler1}
-        ev.on_event{|*args| handler2}
-        ev.on_event('WillConnect'){|*args| handler3(*args)}
-        @db.open
-        message_loop
-        assert_equal(CONNSTR, @event3)
-        assert("handler2", @event2)
-      end
-
-      def test_on_event5
-        ev = WIN32OLE::Event.new(@db, 'ConnectionEvents')
-        ev.on_event {|*args| default_handler(*args)}
-        ev.on_event('WillConnect'){|*args| handler3(*args)}
-        @db.open
-        message_loop
-        assert_match(/ConnectComplete/, @event)
-        assert(/WillConnect/ !~ @event)
-        assert_equal(CONNSTR, @event3)
-      end
-
-      def test_unadvise
-        ev = WIN32OLE::Event.new(@db, 'ConnectionEvents')
-        ev.on_event {|*args| default_handler(*args)}
-        @db.open
-        message_loop
-        assert_match(/WillConnect/, @event)
-        ev.unadvise
-        @event = ""
-        @db.close
-        @db.open
-        message_loop
-        assert_equal("", @event);
-        assert_raise(WIN32OLE::RuntimeError) {
-          ev.on_event {|*args| default_handler(*args)}
-        }
-      end
-
-
-      def test_on_event_with_outargs
-        ev = WIN32OLE::Event.new(@db)
-        @db.connectionString = 'XXX' # set illegal connection string
-        assert_raise(WIN32OLE::RuntimeError) {
-          @db.open
-        }
-        ev.on_event_with_outargs('WillConnect'){|*args|
-          args.last[0] = CONNSTR # ConnectionString = CONNSTR
-        }
-        @db.open
-        message_loop
-        assert(true)
-      end
-
-      def test_on_event_hash_return
-        ev = WIN32OLE::Event.new(@db)
-        ev.on_event('WillConnect'){|*args|
-          {:return => 1, :ConnectionString => CONNSTR}
-        }
-        @db.connectionString = 'XXX'
-        @db.open
-        assert(true)
-      end
-
-      def test_on_event_hash_return2
-        ev = WIN32OLE::Event.new(@db)
-        ev.on_event('WillConnect'){|*args|
-          {:ConnectionString => CONNSTR}
-        }
-        @db.connectionString = 'XXX'
-        @db.open
-        assert(true)
-      end
-
-      def test_on_event_hash_return3
-        ev = WIN32OLE::Event.new(@db)
-        ev.on_event('WillConnect'){|*args|
-          {'ConnectionString' => CONNSTR}
-        }
-        @db.connectionString = 'XXX'
-        @db.open
-        assert(true)
-      end
-
-      def test_on_event_hash_return4
-        ev = WIN32OLE::Event.new(@db)
-        ev.on_event('WillConnect'){|*args|
-          {'return' => 1, 'ConnectionString' => CONNSTR}
-        }
-        @db.connectionString = 'XXX'
-        @db.open
-        assert(true)
-      end
-
-      def test_on_event_hash_return5
-        ev = WIN32OLE::Event.new(@db)
-        ev.on_event('WillConnect'){|*args|
-          {0 => CONNSTR}
-        }
-        @db.connectionString = 'XXX'
-        @db.open
-        assert(true)
-      end
-
-      def test_off_event
-        ev = WIN32OLE::Event.new(@db)
-        ev.on_event{handler1}
-        ev.off_event
-        @db.open
-        message_loop
-        assert_equal("", @event2)
-      end
-
-      def test_off_event_arg
-        ev = WIN32OLE::Event.new(@db)
-        ev.on_event('WillConnect'){handler1}
-        ev.off_event('WillConnect')
-        @db.open
-        message_loop
-        assert_equal("", @event2)
-      end
-
-      def test_off_event_arg2
-        ev = WIN32OLE::Event.new(@db)
-        ev.on_event('WillConnect'){handler1}
-        ev.on_event('ConnectComplete'){handler1}
-        ev.off_event('WillConnect')
-        @db.open
-        message_loop
-        assert_equal("handler1", @event2)
-      end
-
-      def test_off_event_sym_arg
-        ev = WIN32OLE::Event.new(@db)
-        ev.on_event('WillConnect'){handler1}
-        ev.off_event(:WillConnect)
-        @db.open
-        message_loop
-        assert_equal("", @event2)
-      end
-
-      def handler1
-        @event2 = "handler1"
-      end
-
-      def handler2
-        @event2 = "handler2"
-      end
-
-      def handler3(*arg)
-        @event3 += arg[0]
-      end
-
-      def teardown
-        if @db && @db.state == ADO::AdStateOpen
-          @db.close
-        end
-        message_loop
-        @db = nil
-      end
-
-      class Handler1
-        attr_reader :val1, :val2, :val3, :val4
-        def initialize
-          @val1 = nil
-          @val2 = nil
-          @val3 = nil
-          @val4 = nil
-        end
-        def onWillConnect(conn, uid, pwd, opts, stat, pconn)
-          @val1 = conn
-        end
-        def onConnectComplete(err, stat, pconn)
-          @val2 = err
-          @val3 = stat
-        end
-        def onInfoMessage(err, stat, pconn)
-          @val4 = stat
-        end
-      end
-
-      class Handler2
-        attr_reader :ev
-        def initialize
-          @ev = ""
-        end
-        def method_missing(ev, *arg)
-          @ev += ev
-        end
-      end
-
-      def test_handler1
-        ev = WIN32OLE::Event.new(@db)
-        h1 = Handler1.new
-        ev.handler = h1
-        @db.open
-        message_loop
-        assert_equal(CONNSTR, h1.val1)
-        assert_equal(h1.val1, ev.handler.val1)
-        assert_equal(nil, h1.val2)
-        assert_equal(ADO::AdStateOpen, h1.val3)
-        assert_equal(ADO::AdStateOpen, h1.val4)
-      end
-
-      def test_handler2
-        ev = WIN32OLE::Event.new(@db)
-        h2 = Handler2.new
-        ev.handler = h2
-        @db.open
-        message_loop
-        assert(h2.ev != "")
-      end
-    end
-  end
-end
diff --git a/test/mri/win32ole/test_win32ole_method.rb b/test/mri/win32ole/test_win32ole_method.rb
deleted file mode 100644
index 4b3e255fdc9..00000000000
--- a/test/mri/win32ole/test_win32ole_method.rb
+++ /dev/null
@@ -1,134 +0,0 @@
-# frozen_string_literal: false
-begin
-  require 'win32ole'
-rescue LoadError
-end
-require "test/unit"
-
-if defined?(WIN32OLE::Method)
-  class TestWIN32OLE_METHOD < Test::Unit::TestCase
-
-    def setup
-      ole_type = WIN32OLE::Type.new("Microsoft Shell Controls And Automation", "Shell")
-      @m_open = WIN32OLE::Method.new(ole_type, "open")
-      @m_namespace = WIN32OLE::Method.new(ole_type, "namespace")
-      @m_parent = WIN32OLE::Method.new(ole_type, "parent")
-      @m_invoke = WIN32OLE::Method.new(ole_type, "invoke")
-      @m_browse_for_folder = WIN32OLE::Method.new(ole_type, "BrowseForFolder")
-
-      ole_type = WIN32OLE::Type.new("Microsoft Scripting Runtime", "File")
-      @m_file_name = WIN32OLE::Method.new(ole_type, "name")
-    end
-
-    def test_initialize
-      ole_type = WIN32OLE::Type.new("Microsoft Shell Controls And Automation", "Shell")
-      assert_raise(TypeError) {
-        WIN32OLE::Method.new(1, 2)
-      }
-      assert_raise(ArgumentError) {
-        WIN32OLE::Method.new("foo")
-      }
-      assert_raise(ArgumentError) {
-        WIN32OLE::Method.new(ole_type)
-      }
-      assert_raise(WIN32OLE::RuntimeError) {
-        WIN32OLE::Method.new(ole_type, "NonExistMethod")
-      }
-      assert_raise(TypeError) {
-        WIN32OLE::Method.new(ole_type, 1)
-      }
-      method  = WIN32OLE::Method.new(ole_type, "Open")
-      assert_instance_of(WIN32OLE::Method, method)
-      method  = WIN32OLE::Method.new(ole_type, "open")
-      assert_instance_of(WIN32OLE::Method, method)
-    end
-
-    def test_name
-      assert_equal("Open", @m_open.name)
-    end
-
-    def test_return_type
-      assert_equal("VOID", @m_open.return_type)
-      assert_equal("Folder", @m_namespace.return_type)
-    end
-
-    def test_return_vtype
-      assert_equal(24, @m_open.return_vtype)
-      assert_equal(26, @m_namespace.return_vtype)
-    end
-
-    def test_return_type_detail
-      assert_equal(['VOID'], @m_open.return_type_detail)
-      assert_equal(['PTR', 'USERDEFINED', 'Folder'], @m_namespace.return_type_detail)
-    end
-
-    def test_invoke_kind
-      assert_equal('FUNC', @m_open.invoke_kind)
-      assert_equal('FUNC', @m_namespace.invoke_kind)
-      assert_equal('PROPERTYGET', @m_parent.invoke_kind)
-    end
-
-    def test_invkind
-      assert_equal(1, @m_namespace.invkind)
-      assert_equal(2, @m_parent.invkind)
-    end
-
-    def test_visible?
-      assert(@m_namespace.visible?)
-      assert(!@m_invoke.visible?)
-    end
-
-    def test_helpstring
-      assert_equal("Get special folder from ShellSpecialFolderConstants", @m_namespace.helpstring)
-    end
-
-    def test_helpfile
-      assert_equal("", @m_namespace.helpfile)
-      assert_match(/VBENLR.*\.CHM$/i, @m_file_name.helpfile)
-    end
-
-    def test_helpcontext
-      assert_equal(0, @m_namespace.helpcontext)
-      assert_equal(2181996, @m_file_name.helpcontext)
-    end
-
-    def test_dispid
-      assert_equal(1610743810, @m_namespace.dispid)
-    end
-
-    def is_ruby64?
-      /mswin64|x64-mingw/ =~ RUBY_PLATFORM
-    end
-
-    def test_offset_vtbl
-      exp = is_ruby64? ? 48 : 24
-      assert_equal(exp, @m_invoke.offset_vtbl)
-    end
-
-    def test_size_params
-      assert_equal(1, @m_open.size_params)
-      assert_equal(4, @m_browse_for_folder.size_params)
-    end
-
-    def test_size_opt_params
-      assert_equal(0, @m_open.size_opt_params)
-      assert_equal(1, @m_browse_for_folder.size_opt_params)
-    end
-
-    def test_params
-      params = @m_browse_for_folder.params
-      assert_instance_of(Array, params)
-      assert_equal(4, params.size)
-      assert_instance_of(WIN32OLE::Param, params[0])
-    end
-
-    def test_to_s
-      assert_equal(@m_namespace.name, @m_namespace.to_s)
-    end
-
-    def test_inspect
-      assert_equal("#<WIN32OLE::Method:NameSpace>", @m_namespace.inspect)
-    end
-
-  end
-end
diff --git a/test/mri/win32ole/test_win32ole_method_event.rb b/test/mri/win32ole/test_win32ole_method_event.rb
deleted file mode 100644
index ab409a1f2d5..00000000000
--- a/test/mri/win32ole/test_win32ole_method_event.rb
+++ /dev/null
@@ -1,36 +0,0 @@
-begin
-  require 'win32ole'
-rescue LoadError
-end
-
-require 'test/unit'
-
-if defined?(WIN32OLE::Method)
-  require_relative 'available_ole'
-  class TestWIN32OLE_METHOD_EVENT < Test::Unit::TestCase
-    unless AvailableOLE.sysmon_available?
-      def test_dummy_for_skip_message
-        omit 'System Monitor Control is not available'
-      end
-    else
-      def setup
-        ole_type = WIN32OLE::Type.new('System Monitor Control', 'SystemMonitor')
-        @on_dbl_click = WIN32OLE::Method.new(ole_type, 'OnDblClick')
-        ole_type = WIN32OLE::Type.new('Microsoft Shell Controls And Automation', 'Shell')
-        @namespace = WIN32OLE::Method.new(ole_type, 'namespace')
-      end
-
-      def test_event?
-        assert(@on_dbl_click.event?)
-      end
-
-      def test_event_interface
-        assert('DISystemMonitorEvents', @on_dbl_click.event_interface)
-      end
-
-      def test_event_interface_is_nil
-        assert_equal(nil, @namespace.event_interface)
-      end
-    end
-  end
-end
diff --git a/test/mri/win32ole/test_win32ole_param.rb b/test/mri/win32ole/test_win32ole_param.rb
deleted file mode 100644
index 551da537fc7..00000000000
--- a/test/mri/win32ole/test_win32ole_param.rb
+++ /dev/null
@@ -1,98 +0,0 @@
-# frozen_string_literal: false
-begin
-  require 'win32ole'
-rescue LoadError
-end
-require "test/unit"
-
-if defined?(WIN32OLE::Param)
-  class TestWIN32OLE_PARAM < Test::Unit::TestCase
-
-    def setup
-      ole_type = WIN32OLE::Type.new("Microsoft Shell Controls And Automation", "ShellLinkObject")
-      m_geticonlocation = WIN32OLE::Method.new(ole_type, "GetIconLocation")
-      @param_pbs = m_geticonlocation.params[0]
-
-      ole_type = WIN32OLE::Type.new("Microsoft HTML Object Library", "FontNames")
-      m_count = WIN32OLE::Method.new(ole_type, "Count")
-      @param_p = m_count.params[0]
-
-      ole_type = WIN32OLE::Type.new("Microsoft Scripting Runtime", "FileSystemObject")
-      m_copyfile = WIN32OLE::Method.new(ole_type, "CopyFile")
-      @param_source = m_copyfile.params[0]
-      @param_overwritefiles = m_copyfile.params[2]
-
-      ole_type = WIN32OLE::Type.new("Microsoft Scripting Runtime", "Dictionary")
-      m_add = WIN32OLE::Method.new(ole_type, "Add")
-      @param_key = m_add.params[0]
-    end
-
-    def test_s_new
-      assert_raise(ArgumentError) {
-        WIN32OLE::Param.new("hoge")
-      }
-      ole_type = WIN32OLE::Type.new("Microsoft Scripting Runtime", "FileSystemObject")
-      m_copyfile = WIN32OLE::Method.new(ole_type, "CopyFile")
-      assert_raise(IndexError) {
-        WIN32OLE::Param.new(m_copyfile, 4);
-      }
-      assert_raise(IndexError) {
-        WIN32OLE::Param.new(m_copyfile, 0);
-      }
-      param = WIN32OLE::Param.new(m_copyfile, 3)
-      assert_equal("OverWriteFiles", param.name)
-      assert_equal(WIN32OLE::Param, param.class)
-      assert_equal(true, param.default)
-      assert_equal("#<WIN32OLE::Param:OverWriteFiles=true>", param.inspect)
-    end
-
-    def test_name
-      assert_equal('Source', @param_source.name)
-      assert_equal('Key', @param_key.name)
-    end
-
-    def test_ole_type
-      assert_equal('BSTR', @param_source.ole_type)
-      assert_equal('VARIANT', @param_key.ole_type)
-    end
-
-    def test_ole_type_detail
-      assert_equal(['BSTR'], @param_source.ole_type_detail)
-      assert_equal(['PTR', 'VARIANT'], @param_key.ole_type_detail)
-    end
-
-    def test_input?
-      assert_equal(true, @param_source.input?)
-      assert_equal(false, @param_pbs.input?)
-    end
-
-    def test_output?
-      assert_equal(false, @param_source.output?)
-      assert_equal(true, @param_pbs.output?)
-    end
-
-    def test_optional?
-      assert_equal(false, @param_source.optional?)
-      assert_equal(true, @param_overwritefiles.optional?)
-    end
-
-    def test_retval?
-      assert_equal(false, @param_source.retval?)
-      assert_equal(true, @param_p.retval?)
-    end
-
-    def test_default
-      assert_equal(nil, @param_source.default)
-      assert_equal(true, @param_overwritefiles.default)
-    end
-
-    def test_to_s
-      assert_equal(@param_source.name, @param_source.to_s)
-    end
-
-    def test_inspect
-      assert_equal("#<WIN32OLE::Param:Source>", @param_source.inspect)
-      assert_equal("#<WIN32OLE::Param:OverWriteFiles=true>", @param_overwritefiles.inspect)
-    end
-  end
-end
diff --git a/test/mri/win32ole/test_win32ole_param_event.rb b/test/mri/win32ole/test_win32ole_param_event.rb
deleted file mode 100644
index f5a16ead766..00000000000
--- a/test/mri/win32ole/test_win32ole_param_event.rb
+++ /dev/null
@@ -1,30 +0,0 @@
-begin
-  require 'win32ole'
-rescue LoadError
-end
-
-require 'test/unit'
-
-if defined?(WIN32OLE::Param)
-  require_relative 'available_ole'
-
-  class TestWIN32OLE_PARAM_EVENT < Test::Unit::TestCase
-    if AvailableOLE.msxml_available? || AvailableOLE.ado_available?
-      def setup
-        @param = AvailableOLE.event_param
-      end
-
-      def test_input?
-        assert_equal(true, @param.input?)
-      end
-
-      def test_output?
-        assert_equal(true, @param.output?)
-      end
-    else
-      def test_dummy_for_skip_message
-        omit 'ActiveX Data Object Library and MS XML not found'
-      end
-    end
-  end
-end
diff --git a/test/mri/win32ole/test_win32ole_record.rb b/test/mri/win32ole/test_win32ole_record.rb
deleted file mode 100644
index 2fae16788d7..00000000000
--- a/test/mri/win32ole/test_win32ole_record.rb
+++ /dev/null
@@ -1,212 +0,0 @@
-# coding: us-ascii
-# frozen_string_literal: false
-
-begin
-  require 'win32ole'
-rescue LoadError
-end
-require 'test/unit'
-
-PROGID_RBCOMTEST='RbComTest.ComSrvTest'
-
-=begin
-RbComTest.ComSrvTest is following VB.NET COM server(RbComTest solution).
-(You must check COM interoperability.)
-
-Imports System.Runtime.InteropServices
-Public Class ComSrvTest
-    <StructLayout(LayoutKind.Sequential)> _
-    Public Structure Book
-        <MarshalAs(UnmanagedType.BStr)> _
-        Public title As String
-        Public cost As Integer
-    End Structure
-
-    Public Function getBook() As Book
-        Dim book As New Book
-        book.title = "The Ruby Book"
-        book.cost = 20
-        Return book
-    End Function
-
-    Public Function getBooks() As Book()
-        Dim book() As Book = {New Book, New Book}
-        book(0).title = "The CRuby Book"
-        book(0).cost = 30
-        book(1).title = "The JRuby Book"
-        book(1).cost = 40
-        Return book
-    End Function
-
-    Public Sub getBookByRefObject(ByRef obj As Object)
-        Dim book As New Book
-        book.title = "The Ruby Reference Book"
-        book.cost = 50
-        obj = book
-    End Sub
-
-    Public Function getVer2BookByValBook(<MarshalAs(UnmanagedType.Struct)> ByVal book As Book) As Book
-        Dim ret As New Book
-        ret.title = book.title + " ver2"
-        ret.cost = book.cost * 1.1
-        Return ret
-    End Function
-
-    Public Sub getBookByRefBook(<MarshalAs(UnmanagedType.LPStruct)> ByRef book As Book)
-        book.title = "The Ruby Reference Book2"
-        book.cost = 44
-    End Sub
-
-    Public Sub getVer3BookByRefBook(<MarshalAs(UnmanagedType.LPStruct)> ByRef book As Book)
-        book.title += " ver3"
-        book.cost *= 1.2
-    End Sub
-End Class
-=end
-
-
-if defined?(WIN32OLE::Record)
-  class TestWIN32OLE_RECORD < Test::Unit::TestCase
-  end
-
-  def rbcomtest_exist?
-    WIN32OLE.new(PROGID_RBCOMTEST)
-    true
-  rescue WIN32OLE::RuntimeError
-    false
-  end
-
-  class TestWIN32OLE_RECORD_BY_RBCOMTEST < Test::Unit::TestCase
-    unless rbcomtest_exist?
-      def test_dummy_for_skip_message
-        omit "#{PROGID_RBCOMTEST} for WIN32OLE::Record test is not installed"
-      end
-    else
-      def setup
-        @obj = WIN32OLE.new(PROGID_RBCOMTEST)
-      end
-
-      def test_s_new_from_win32ole
-        rec = WIN32OLE::Record.new('Book', @obj)
-        assert(rec)
-        assert_instance_of(WIN32OLE::Record, rec)
-      end
-
-      def test_s_new_from_win32ole_typelib
-        tlib = @obj.ole_typelib
-        rec = WIN32OLE::Record.new('Book', tlib)
-        assert(rec)
-        assert_instance_of(WIN32OLE::Record, rec)
-      end
-
-      def test_s_new_raise
-        assert_raise(WIN32OLE::RuntimeError) {
-          WIN32OLE::Record.new('NonExistRecordName', @obj)
-        }
-        assert_raise(ArgumentError) {
-          WIN32OLE::Record.new
-        }
-        assert_raise(ArgumentError) {
-          WIN32OLE::Record.new('NonExistRecordName')
-        }
-      end
-
-      def test_to_h
-        rec = WIN32OLE::Record.new('Book', @obj)
-        assert_equal({'title'=>nil, 'cost'=>nil}, rec.to_h)
-      end
-
-      def test_typename
-        rec = WIN32OLE::Record.new('Book', @obj)
-        assert_equal('Book', rec.typename)
-      end
-
-      def test_method_missing_getter
-        rec = WIN32OLE::Record.new('Book', @obj)
-        assert_equal(nil, rec.title)
-        assert_raise(KeyError) {
-          rec.non_exist_name
-        }
-      end
-
-      def test_method_missing_setter
-        rec = WIN32OLE::Record.new('Book', @obj)
-        rec.title = "Ruby Book"
-        assert_equal("Ruby Book", rec.title)
-      end
-
-      def test_get_record_from_comserver
-        rec = @obj.getBook
-        assert_instance_of(WIN32OLE::Record, rec)
-        assert_equal("The Ruby Book", rec.title)
-        assert_equal(20, rec.cost)
-      end
-
-      def test_get_record_array_from_comserver
-        rec = @obj.getBooks
-        assert_instance_of(Array, rec)
-        assert_equal(2, rec.size)
-        assert_instance_of(WIN32OLE::Record, rec[0])
-        assert_equal("The CRuby Book", rec[0].title)
-        assert_equal(30, rec[0].cost)
-        assert_instance_of(WIN32OLE::Record, rec[1])
-        assert_equal("The JRuby Book", rec[1].title)
-        assert_equal(40, rec[1].cost)
-      end
-
-      def test_pass_record_parameter
-        rec = WIN32OLE::Record.new('Book', @obj)
-        rec.title = "Ruby Book"
-        rec.cost = 60
-        book = @obj.getVer2BookByValBook(rec)
-        assert_equal("Ruby Book ver2", book.title)
-        assert_equal(66, book.cost)
-      end
-
-      def test_pass_variant_parameter_byref
-        obj = WIN32OLE::Variant.new(nil, WIN32OLE::VARIANT::VT_VARIANT|WIN32OLE::VARIANT::VT_BYREF)
-        @obj.getBookByRefBook(obj)
-        assert_instance_of(WIN32OLE::Record, obj.value)
-        book = obj.value
-        assert_equal("The Ruby Reference Book2", book.title)
-        assert_equal(44, book.cost)
-      end
-
-      def test_pass_record_parameter_byref
-        book = WIN32OLE::Record.new('Book', @obj)
-        @obj.getBookByRefBook(book)
-        assert_equal("The Ruby Reference Book2", book.title)
-        assert_equal(44, book.cost)
-      end
-
-      def test_pass_and_get_record_parameter_byref
-        book = WIN32OLE::Record.new('Book', @obj)
-        book.title = "Ruby Book"
-        book.cost = 60
-        @obj.getVer3BookByRefBook(book)
-        assert_equal("Ruby Book ver3", book.title)
-        assert_equal(72, book.cost)
-      end
-
-      def test_ole_instance_variable_get
-        obj = WIN32OLE::Record.new('Book', @obj)
-        assert_equal(nil, obj.ole_instance_variable_get(:title))
-        assert_equal(nil, obj.ole_instance_variable_get('title'))
-      end
-
-      def test_ole_instance_variable_set
-        book = WIN32OLE::Record.new('Book', @obj)
-        book.ole_instance_variable_set(:title, "Ruby Book")
-        assert_equal("Ruby Book", book.title)
-        book.ole_instance_variable_set('title', "Ruby Book2")
-        assert_equal("Ruby Book2", book.title)
-      end
-
-      def test_inspect
-        book = WIN32OLE::Record.new('Book', @obj)
-        assert_equal(%q[#<WIN32OLE::Record(Book) {"title"=>nil, "cost"=>nil}>], book.inspect)
-      end
-    end
-  end
-
-end
diff --git a/test/mri/win32ole/test_win32ole_type.rb b/test/mri/win32ole/test_win32ole_type.rb
deleted file mode 100644
index df1ba6556c6..00000000000
--- a/test/mri/win32ole/test_win32ole_type.rb
+++ /dev/null
@@ -1,199 +0,0 @@
-# frozen_string_literal: false
-begin
-  require 'win32ole'
-rescue LoadError
-end
-require "test/unit"
-
-if defined?(WIN32OLE::Type)
-  class TestWIN32OLE_TYPE < Test::Unit::TestCase
-    def test_s_progids
-      progids = WIN32OLE::Type.progids
-      assert_instance_of(Array, progids)
-      assert(progids.size > 0)
-      assert_instance_of(String, progids[0])
-      assert(progids.include?("Shell.Application.1"))
-    end
-
-    def test_initialize
-      assert_raise(ArgumentError) {
-        WIN32OLE::Type.new
-      }
-      assert_raise(ArgumentError) {
-        WIN32OLE::Type.new("foo")
-      }
-      assert_raise(TypeError) {
-        WIN32OLE::Type.new(1, 2)
-      }
-      assert_raise(TypeError) {
-        WIN32OLE::Type.new("Microsoft Shell Controls And Automation", 1)
-      }
-      assert_raise(WIN32OLE::RuntimeError) {
-        WIN32OLE::Type.new("Microsoft Shell Controls And Automation", "foo")
-      }
-      assert_raise(WIN32OLE::RuntimeError) {
-        WIN32OLE::Type.new("Microsoft Shell Controls And Automation", "Application")
-      }
-      ole_type = WIN32OLE::Type.new("Microsoft Shell Controls And Automation", "Shell")
-      assert_instance_of(WIN32OLE::Type, ole_type)
-      assert_equal("Shell", ole_type.name)
-      assert_equal("Class", ole_type.ole_type)
-      assert_equal("{13709620-C279-11CE-A49E-444553540000}", ole_type.guid)
-      assert_equal("Shell.Application.1", ole_type.progid)
-      assert_equal(true, ole_type.visible?)
-      assert_equal("Shell", ole_type.to_s)
-      assert_equal(0, ole_type.major_version)
-      assert_equal(0, ole_type.minor_version)
-      assert_equal(5, ole_type.typekind)
-      assert_equal("Shell Object Type Information", ole_type.helpstring)
-      assert_equal(nil, ole_type.src_type)
-      assert_equal("", ole_type.helpfile)
-      assert_equal(0, ole_type.helpcontext)
-      assert_equal([], ole_type.variables)
-      assert(ole_type.ole_methods.select{|m|/NameSpace/i =~ m.name}.size > 0)
-
-      ole_type2 = WIN32OLE::Type.new("{13709620-C279-11CE-A49E-444553540000}", "Shell")
-      assert_instance_of(WIN32OLE::Type, ole_type)
-      assert_equal(ole_type.name, ole_type2.name)
-      assert_equal(ole_type.ole_type, ole_type2.ole_type)
-      assert_equal(ole_type.guid, ole_type2.guid)
-      assert_equal(ole_type.progid, ole_type2.progid)
-      assert_equal(ole_type.visible?, ole_type2.visible?)
-      assert_equal(ole_type.to_s, ole_type2.to_s)
-      assert_equal(ole_type.major_version, ole_type2.major_version)
-      assert_equal(ole_type.minor_version, ole_type2.minor_version)
-      assert_equal(ole_type.typekind, ole_type2.typekind)
-      assert_equal(ole_type.helpstring, ole_type2.helpstring)
-      assert_equal(ole_type.src_type, ole_type2.src_type)
-      assert_equal(ole_type.helpfile, ole_type2.helpfile)
-      assert_equal(ole_type.helpcontext, ole_type2.helpcontext)
-      assert_equal(ole_type.variables.size, ole_type2.variables.size)
-      assert_equal(ole_type.ole_methods[0].name, ole_type2.ole_methods[0].name)
-      assert_equal(ole_type.ole_typelib.name, ole_type2.ole_typelib.name)
-      assert_equal(ole_type.implemented_ole_types.size, ole_type2.implemented_ole_types.size)
-      assert_equal(ole_type.inspect, ole_type2.inspect)
-    end
-
-    def setup
-      @ole_type = WIN32OLE::Type.new("Microsoft Shell Controls And Automation", "Shell")
-    end
-
-    def test_name
-      assert_equal("Shell", @ole_type.name)
-    end
-
-    def test_ole_type
-      assert_equal("Class", @ole_type.ole_type)
-    end
-
-    def test_guid
-      assert_equal("{13709620-C279-11CE-A49E-444553540000}", @ole_type.guid)
-    end
-
-    def test_progid
-      assert_equal("Shell.Application.1", @ole_type.progid)
-    end
-
-    def test_visible?
-      assert(@ole_type.visible?)
-      ole_type = WIN32OLE::Type.new("Microsoft Shell Controls And Automation", "IShellDispatch")
-      assert(!ole_type.visible?)
-    end
-
-    def test_to_s
-      assert_equal(@ole_type.to_s, @ole_type.name)
-    end
-
-    def test_major_version
-      assert_equal(0, @ole_type.major_version)
-      # ole_type = WIN32OLE::Type.new("Microsoft Word 11.0 Object Library", "Documents")
-      # assert_equal(8, ole_type.major_version)
-    end
-
-    def test_minor_version
-      assert_equal(0, @ole_type.minor_version)
-      # ole_type = WIN32OLE::Type.new("Microsoft Word 11.0 Object Library", "Documents")
-      # assert_equal(3, ole_type.minor_version)
-    end
-
-    def test_typekind
-      assert_equal(5, @ole_type.typekind)
-    end
-
-    def test_helpstring
-      assert_equal("Shell Object Type Information", @ole_type.helpstring)
-    end
-
-    def test_src_type
-      ole_type = WIN32OLE::Type.new("Microsoft Scripting Runtime", "DriveTypeConst")
-      assert_match(/__MIDL___MIDL_itf_scrrun_/, ole_type.src_type)
-      assert_equal(nil, @ole_type.src_type)
-    end
-
-    def test_helpfile
-      assert_equal("", @ole_type.helpfile)
-      ole_type = WIN32OLE::Type.new("Microsoft Scripting Runtime", "Folders")
-      assert_match(/VBENLR98\.CHM$/i, ole_type.helpfile)
-    end
-
-    def test_helpcontext
-      assert_equal(0, @ole_type.helpcontext)
-      ole_type = WIN32OLE::Type.new("Microsoft Scripting Runtime", "Folders")
-      assert_equal(2181929, ole_type.helpcontext)
-    end
-
-    def test_variables
-      variables = @ole_type.variables
-      assert_instance_of(Array, variables)
-      assert(variables.size == 0)
-
-      ole_type = WIN32OLE::Type.new("Microsoft Shell Controls And Automation", "ShellSpecialFolderConstants")
-      variables = ole_type.variables
-      assert_instance_of(Array, variables)
-      assert(variables.size > 0)
-
-      assert_instance_of(WIN32OLE::Variable, variables[0])
-    end
-
-    def test_ole_methods
-      methods = @ole_type.ole_methods
-      assert_instance_of(Array, methods)
-      assert(methods.size > 0)
-      assert_instance_of(WIN32OLE::Method, methods[0]);
-      assert(methods.collect{|m| m.name}.include?("Application"))
-    end
-
-    def test_ole_typelib
-      tlib = @ole_type.ole_typelib
-      assert_instance_of(WIN32OLE::TypeLib, tlib)
-      assert_equal("Microsoft Shell Controls And Automation", tlib.name)
-    end
-
-    def test_implemented_ole_types
-      ole_types = @ole_type.implemented_ole_types
-      assert_instance_of(Array, ole_types)
-      assert_equal(1, ole_types.size)
-      assert_match(/^IShellDispatch\d{0,1}$/, ole_types[0].name)
-    end
-
-    def test_inspect
-      assert_equal("#<WIN32OLE::Type:Shell>", @ole_type.inspect)
-    end
-
-    # WIN32OLE::Type.typelibs will be obsoleted.
-    def test_s_typelibs
-      tlibs = WIN32OLE::Type.typelibs.sort
-      tlibs2 = WIN32OLE::TypeLib.typelibs.collect{|t|t.name}.sort
-      assert_equal(tlibs2, tlibs)
-    end
-
-    # WIN32OLE::Type.ole_classes will be obsoleted.
-    def test_s_ole_classes
-      ots1 = WIN32OLE::Type.ole_classes("Microsoft Shell Controls And Automation")
-      ots2 = WIN32OLE::TypeLib.new("Microsoft Shell Controls And Automation").ole_types
-      otns1 = ots1.collect{|t| t.name}.sort
-      otns2 = ots2.collect{|t| t.name}.sort
-      assert_equal(otns2, otns1)
-    end
-  end
-end
diff --git a/test/mri/win32ole/test_win32ole_type_event.rb b/test/mri/win32ole/test_win32ole_type_event.rb
deleted file mode 100644
index 5d1c9fc44c9..00000000000
--- a/test/mri/win32ole/test_win32ole_type_event.rb
+++ /dev/null
@@ -1,44 +0,0 @@
-# frozen_string_literal: false
-begin
-  require 'win32ole'
-rescue LoadError
-end
-
-require 'test/unit'
-
-if defined?(WIN32OLE::Type)
-  require_relative 'available_ole'
-
-  class TestWIN32OLE_TYPE_EVENT < Test::Unit::TestCase
-    unless AvailableOLE.sysmon_available?
-      def test_dummy_for_skip_message
-        omit 'System Monitor Control is not available'
-      end
-    else
-
-      def setup
-        @ole_type = WIN32OLE::Type.new('System Monitor Control', 'SystemMonitor')
-      end
-
-      def test_implemented_ole_types
-        ole_types = @ole_type.implemented_ole_types.map(&:name).sort
-        assert_equal(['DISystemMonitor', 'DISystemMonitorEvents', 'ISystemMonitor'], ole_types)
-      end
-
-      def test_default_ole_types
-        ole_types = @ole_type.default_ole_types.map(&:name).sort
-        assert_equal(['DISystemMonitor', 'DISystemMonitorEvents'], ole_types)
-      end
-
-      def test_source_ole_types
-        ole_types = @ole_type.source_ole_types.map(&:name)
-        assert_equal(['DISystemMonitorEvents'], ole_types)
-      end
-
-      def test_default_event_sources
-        event_sources = @ole_type.default_event_sources.map(&:name)
-        assert_equal(['DISystemMonitorEvents'], event_sources)
-      end
-    end
-  end
-end
diff --git a/test/mri/win32ole/test_win32ole_typelib.rb b/test/mri/win32ole/test_win32ole_typelib.rb
deleted file mode 100644
index f743ad68f90..00000000000
--- a/test/mri/win32ole/test_win32ole_typelib.rb
+++ /dev/null
@@ -1,117 +0,0 @@
-# frozen_string_literal: false
-begin
-  require 'win32ole'
-rescue LoadError
-end
-require "test/unit"
-
-if defined?(WIN32OLE::TypeLib)
-  class TestWIN32OLE_TYPELIB < Test::Unit::TestCase
-    def test_s_typelibs
-      tlibs = WIN32OLE::TypeLib.typelibs
-      assert_instance_of(Array, tlibs)
-      assert(tlibs.size > 0)
-      tlib = tlibs.find {|t| t.name == "Microsoft Shell Controls And Automation"}
-      assert(tlib)
-    end
-
-    def test_initialize
-      assert_raise(ArgumentError) {
-        WIN32OLE::TypeLib.new(1,2,3,4)
-      }
-
-      assert_raise(TypeError) {
-        WIN32OLE::TypeLib.new(100)
-      }
-
-      tlib = WIN32OLE::TypeLib.new("Microsoft Shell Controls And Automation")
-      assert_instance_of(WIN32OLE::TypeLib, tlib)
-
-      tlib = WIN32OLE::TypeLib.new("Microsoft Shell Controls And Automation", 1.0)
-      assert_instance_of(WIN32OLE::TypeLib, tlib)
-
-      tlib = WIN32OLE::TypeLib.new("Microsoft Shell Controls And Automation", 1, 0)
-      assert_instance_of(WIN32OLE::TypeLib, tlib)
-      guid = tlib.guid
-
-      tlib_by_guid = WIN32OLE::TypeLib.new(guid, 1, 0)
-      assert_instance_of(WIN32OLE::TypeLib, tlib_by_guid)
-      assert_equal("Microsoft Shell Controls And Automation" , tlib_by_guid.name)
-
-      path = tlib.path
-      tlib_by_path =  WIN32OLE::TypeLib.new(path)
-      assert_equal("Microsoft Shell Controls And Automation" , tlib_by_path.name)
-
-      assert_raise(WIN32OLE::RuntimeError) {
-        WIN32OLE::TypeLib.new("Non Exist Type Library")
-      }
-    end
-
-    # #Bug:3907 [ruby-dev:42338]
-    def test_initialize_with_REG_EXPAND_SZ
-      tlib = WIN32OLE::TypeLib.new("Disk Management Snap-In Object Library")
-      assert_instance_of(WIN32OLE::TypeLib, tlib)
-    end
-
-    def test_guid
-      tlib = WIN32OLE::TypeLib.new("Microsoft Shell Controls And Automation")
-      assert_equal("{50A7E9B0-70EF-11D1-B75A-00A0C90564FE}", tlib.guid)
-    end
-
-    def test_name
-      tlib = WIN32OLE::TypeLib.new("Microsoft Shell Controls And Automation")
-      assert_equal("Microsoft Shell Controls And Automation", tlib.name)
-      tlib = WIN32OLE::TypeLib.new("{50A7E9B0-70EF-11D1-B75A-00A0C90564FE}")
-      assert_equal("Microsoft Shell Controls And Automation", tlib.name)
-    end
-
-    def test_version
-      tlib = WIN32OLE::TypeLib.new("Microsoft Shell Controls And Automation")
-      assert_equal("1.0", tlib.version)
-    end
-
-    def test_major_version
-      tlib = WIN32OLE::TypeLib.new("Microsoft Shell Controls And Automation")
-      assert_equal(1, tlib.major_version)
-    end
-
-    def test_minor_version
-      tlib = WIN32OLE::TypeLib.new("Microsoft Shell Controls And Automation")
-      assert_equal(0, tlib.minor_version)
-    end
-
-    def test_path
-      tlib = WIN32OLE::TypeLib.new("Microsoft Shell Controls And Automation")
-      assert_match(/shell32\.dll$/i, tlib.path)
-    end
-
-    def test_visible?
-      tlib = WIN32OLE::TypeLib.new("Microsoft Shell Controls And Automation")
-      assert(tlib.visible?)
-    end
-
-    def test_library_name
-      tlib = WIN32OLE::TypeLib.new("Microsoft Shell Controls And Automation")
-      assert_equal("Shell32", tlib.library_name)
-    end
-
-    def test_to_s
-      tlib = WIN32OLE::TypeLib.new("Microsoft Shell Controls And Automation")
-      assert_equal("Microsoft Shell Controls And Automation", tlib.to_s)
-    end
-
-    def test_ole_types
-      tlib = WIN32OLE::TypeLib.new("Microsoft Shell Controls And Automation")
-      ole_types = tlib.ole_types
-      assert_instance_of(Array, ole_types)
-      assert(ole_types.size > 0)
-      assert_instance_of(WIN32OLE::Type, ole_types[0])
-    end
-
-    def test_inspect
-      tlib = WIN32OLE::TypeLib.new("Microsoft Shell Controls And Automation")
-      assert_equal("#<WIN32OLE::TypeLib:Microsoft Shell Controls And Automation>", tlib.inspect)
-    end
-
-  end
-end
diff --git a/test/mri/win32ole/test_win32ole_variable.rb b/test/mri/win32ole/test_win32ole_variable.rb
deleted file mode 100644
index 74a6cbd890a..00000000000
--- a/test/mri/win32ole/test_win32ole_variable.rb
+++ /dev/null
@@ -1,66 +0,0 @@
-# frozen_string_literal: false
-begin
-  require 'win32ole'
-rescue LoadError
-end
-require "test/unit"
-
-if defined?(WIN32OLE::Variable)
-  class TestWIN32OLE_VARIABLE < Test::Unit::TestCase
-
-    def setup
-      ole_type = WIN32OLE::Type.new("Microsoft Shell Controls And Automation", "ShellSpecialFolderConstants")
-      @var1 = ole_type.variables.find {|v| v.name == 'ssfDESKTOP'}
-
-      variables = WIN32OLE::Type.new("Microsoft Windows Installer Object Library", "Installer").variables
-      @var2 = variables.find {|v| v.name == 'UILevel'}
-    end
-
-    def test_initialize
-      assert_raise(TypeError) {WIN32OLE::Variable.new}
-    end
-
-    def test_name
-      assert_equal('ssfDESKTOP', @var1.name)
-    end
-
-    def test_ole_type
-      assert_equal('INT', @var1.ole_type)
-      assert_equal('MsiUILevel', @var2.ole_type)
-    end
-
-    def test_ole_type_detail
-      assert_equal(['INT'], @var1.ole_type_detail)
-      assert_equal(['USERDEFINED', 'MsiUILevel'], @var2.ole_type_detail)
-    end
-
-    def test_ole_type_value
-      assert_equal(0, @var1.value)
-      assert_equal(nil, @var2.value)
-    end
-
-    def test_ole_type_visible?
-      assert(@var1.visible?)
-    end
-
-    def test_ole_type_variable_kind
-      assert_equal("CONSTANT", @var1.variable_kind)
-      assert_equal("DISPATCH", @var2.variable_kind)
-    end
-
-    def test_ole_type_varkind
-      assert_equal(2, @var1.varkind)
-      assert_equal(3, @var2.varkind)
-    end
-
-    def test_to_s
-      assert_equal(@var1.name, @var1.to_s)
-    end
-
-    def test_inspect
-      assert_equal("#<WIN32OLE::Variable:ssfDESKTOP=0>",  @var1.inspect)
-      assert_equal("#<WIN32OLE::Variable:UILevel=nil>", @var2.inspect)
-    end
-
-  end
-end
diff --git a/test/mri/win32ole/test_win32ole_variant.rb b/test/mri/win32ole/test_win32ole_variant.rb
deleted file mode 100644
index 1837a1e1d63..00000000000
--- a/test/mri/win32ole/test_win32ole_variant.rb
+++ /dev/null
@@ -1,722 +0,0 @@
-# frozen_string_literal: false
-begin
-  require 'win32ole'
-rescue LoadError
-end
-require "test/unit"
-
-if defined?(WIN32OLE::Variant)
-
-  class TestWIN32OLE_VARIANT < Test::Unit::TestCase
-    def setup
-      @orglocale = WIN32OLE.locale
-      WIN32OLE.locale = 0x0409 # set locale  US-Eng
-    end
-
-    def teardown
-      WIN32OLE.locale = @orglocale
-    end
-
-    def test_s_new
-      obj = WIN32OLE::Variant.new('foo')
-      assert_instance_of(WIN32OLE::Variant, obj)
-    end
-
-    def test_s_new_exc
-      assert_raise(TypeError) {
-        WIN32OLE::Variant.new(/foo/)
-      }
-    end
-
-    def test_s_new_ary
-      obj = WIN32OLE::Variant.new([1])
-      assert_instance_of(WIN32OLE::Variant, obj)
-      assert_raise(TypeError) {
-        WIN32OLE::Variant.new([/foo/])
-      }
-    end
-
-    def test_s_new_no_argument
-      pat = /wrong number of arguments $.*\b0\b.* 1\.\.3$/
-      assert_raise_with_message(ArgumentError, pat) do
-        WIN32OLE::Variant.new
-      end
-    end
-
-    def test_s_new_one_argument
-      ex = nil
-      begin
-        WIN32OLE::Variant.new('foo')
-      rescue
-        ex = $!
-      end
-      assert_equal(nil, ex);
-    end
-
-    def test_s_new_with_nil
-      obj = WIN32OLE::Variant.new(nil, WIN32OLE::VARIANT::VT_I2)
-      assert_equal(0, obj.value)
-      assert_equal(WIN32OLE::VARIANT::VT_I2, obj.vartype)
-
-      obj = WIN32OLE::Variant.new(nil, WIN32OLE::VARIANT::VT_I4)
-      assert_equal(0, obj.value)
-      assert_equal(WIN32OLE::VARIANT::VT_I4, obj.vartype)
-
-      obj = WIN32OLE::Variant.new(nil, WIN32OLE::VARIANT::VT_R4)
-      assert_equal(0, obj.value)
-      assert_equal(WIN32OLE::VARIANT::VT_R4, obj.vartype)
-
-      obj = WIN32OLE::Variant.new(nil, WIN32OLE::VARIANT::VT_R8)
-      assert_equal(0, obj.value)
-      assert_equal(WIN32OLE::VARIANT::VT_R8, obj.vartype)
-
-      obj = WIN32OLE::Variant.new(nil, WIN32OLE::VARIANT::VT_CY)
-      assert_equal("0", obj.value)
-      assert_equal(WIN32OLE::VARIANT::VT_CY, obj.vartype)
-
-      obj = WIN32OLE::Variant.new(nil, WIN32OLE::VARIANT::VT_DATE)
-      assert_equal(Time.new(1899,12,30), obj.value)
-      assert_equal(WIN32OLE::VARIANT::VT_DATE, obj.vartype)
-
-      obj = WIN32OLE::Variant.new(nil, WIN32OLE::VARIANT::VT_BSTR)
-      assert_equal("", obj.value)
-      assert_equal(WIN32OLE::VARIANT::VT_BSTR, obj.vartype)
-
-      obj = WIN32OLE::Variant.new(nil, WIN32OLE::VARIANT::VT_DISPATCH)
-      assert_nil(obj.value)
-      assert_equal(WIN32OLE::VARIANT::VT_DISPATCH, obj.vartype)
-
-      obj = WIN32OLE::Variant.new(nil, WIN32OLE::VARIANT::VT_BOOL)
-      assert_equal(false, obj.value)
-      assert_equal(WIN32OLE::VARIANT::VT_BOOL, obj.vartype)
-
-      obj = WIN32OLE::Variant.new(nil, WIN32OLE::VARIANT::VT_VARIANT)
-      assert_nil(obj.value)
-      assert_equal(WIN32OLE::VARIANT::VT_VARIANT, obj.vartype)
-
-      obj = WIN32OLE::Variant.new(nil, WIN32OLE::VARIANT::VT_I1)
-      assert_equal(0, obj.value)
-      assert_equal(WIN32OLE::VARIANT::VT_I1, obj.vartype)
-
-      obj = WIN32OLE::Variant.new(nil, WIN32OLE::VARIANT::VT_UI1)
-      assert_equal(0, obj.value)
-      assert_equal(WIN32OLE::VARIANT::VT_UI1, obj.vartype)
-
-      obj = WIN32OLE::Variant.new(nil, WIN32OLE::VARIANT::VT_UI2)
-      assert_equal(0, obj.value)
-      assert_equal(WIN32OLE::VARIANT::VT_UI2, obj.vartype)
-
-      obj = WIN32OLE::Variant.new(nil, WIN32OLE::VARIANT::VT_UI4)
-      assert_equal(0, obj.value)
-      assert_equal(WIN32OLE::VARIANT::VT_UI4, obj.vartype)
-
-
-      if defined?(WIN32OLE::VARIANT::VT_I8)
-        obj = WIN32OLE::Variant.new(nil, WIN32OLE::VARIANT::VT_I8)
-        assert_equal(0, obj.value)
-        assert_equal(WIN32OLE::VARIANT::VT_I8, obj.vartype)
-      end
-
-      if defined?(WIN32OLE::VARIANT::VT_UI8)
-        obj = WIN32OLE::Variant.new(nil, WIN32OLE::VARIANT::VT_UI8)
-        assert_equal(0, obj.value)
-        assert_equal(WIN32OLE::VARIANT::VT_UI8, obj.vartype)
-      end
-
-      obj = WIN32OLE::Variant.new(nil, WIN32OLE::VARIANT::VT_INT)
-      assert_equal(0, obj.value)
-      assert_equal(WIN32OLE::VARIANT::VT_INT, obj.vartype)
-
-      obj = WIN32OLE::Variant.new(nil, WIN32OLE::VARIANT::VT_UINT)
-      assert_equal(0, obj.value)
-      assert_equal(WIN32OLE::VARIANT::VT_UINT, obj.vartype)
-    end
-
-    def test_s_new_with_non_nil
-      obj = WIN32OLE::Variant.new(2, WIN32OLE::VARIANT::VT_I2)
-      assert_equal(2, obj.value)
-      assert_equal(WIN32OLE::VARIANT::VT_I2, obj.vartype)
-
-      obj = WIN32OLE::Variant.new(3, WIN32OLE::VARIANT::VT_I4)
-      assert_equal(3, obj.value)
-      assert_equal(WIN32OLE::VARIANT::VT_I4, obj.vartype)
-
-      obj = WIN32OLE::Variant.new(4.5, WIN32OLE::VARIANT::VT_R4)
-      assert_equal(4.5, obj.value)
-      assert_equal(WIN32OLE::VARIANT::VT_R4, obj.vartype)
-
-      obj = WIN32OLE::Variant.new(5.5, WIN32OLE::VARIANT::VT_R8)
-      assert_equal(5.5, obj.value)
-      assert_equal(WIN32OLE::VARIANT::VT_R8, obj.vartype)
-
-      obj = WIN32OLE::Variant.new(600, WIN32OLE::VARIANT::VT_CY)
-      assert_equal("600", obj.value)
-      assert_equal(WIN32OLE::VARIANT::VT_CY, obj.vartype)
-
-      obj = WIN32OLE::Variant.new("2001-06-15 12:17:34", WIN32OLE::VARIANT::VT_DATE)
-      assert_equal(Time.new(2001,06,15,12,17,34), obj.value)
-      assert_equal(WIN32OLE::VARIANT::VT_DATE, obj.vartype)
-
-      obj = WIN32OLE::Variant.new("foo", WIN32OLE::VARIANT::VT_BSTR)
-      assert_equal("foo", obj.value)
-      assert_equal(WIN32OLE::VARIANT::VT_BSTR, obj.vartype)
-
-      obj = WIN32OLE::Variant.new(true, WIN32OLE::VARIANT::VT_BOOL)
-      assert_equal(true, obj.value)
-      assert_equal(WIN32OLE::VARIANT::VT_BOOL, obj.vartype)
-
-      obj = WIN32OLE::Variant.new(2, WIN32OLE::VARIANT::VT_I1)
-      assert_equal(2, obj.value)
-      assert_equal(WIN32OLE::VARIANT::VT_I1, obj.vartype)
-
-      obj = WIN32OLE::Variant.new(3, WIN32OLE::VARIANT::VT_UI1)
-      assert_equal(3, obj.value)
-      assert_equal(WIN32OLE::VARIANT::VT_UI1, obj.vartype)
-
-      obj = WIN32OLE::Variant.new(4, WIN32OLE::VARIANT::VT_UI2)
-      assert_equal(4, obj.value)
-      assert_equal(WIN32OLE::VARIANT::VT_UI2, obj.vartype)
-
-      obj = WIN32OLE::Variant.new(5, WIN32OLE::VARIANT::VT_UI4)
-      assert_equal(5, obj.value)
-      assert_equal(WIN32OLE::VARIANT::VT_UI4, obj.vartype)
-
-      if defined?(WIN32OLE::VARIANT::VT_I8)
-        obj = WIN32OLE::Variant.new(-123456789012345, WIN32OLE::VARIANT::VT_I8)
-        assert_equal(-123456789012345, obj.value)
-        assert_equal(WIN32OLE::VARIANT::VT_I8, obj.vartype)
-      end
-
-      if defined?(WIN32OLE::VARIANT::VT_UI8)
-        obj = WIN32OLE::Variant.new(123456789012345, WIN32OLE::VARIANT::VT_UI8)
-        assert_equal(123456789012345, obj.value)
-        assert_equal(WIN32OLE::VARIANT::VT_UI8, obj.vartype)
-      end
-
-      obj = WIN32OLE::Variant.new(4, WIN32OLE::VARIANT::VT_INT)
-      assert_equal(4, obj.value)
-      assert_equal(WIN32OLE::VARIANT::VT_INT, obj.vartype)
-
-      obj = WIN32OLE::Variant.new(5, WIN32OLE::VARIANT::VT_UINT)
-      assert_equal(5, obj.value)
-      assert_equal(WIN32OLE::VARIANT::VT_UINT, obj.vartype)
-    end
-
-    def test_s_new_with_non_nil_byref
-      obj = WIN32OLE::Variant.new(2, WIN32OLE::VARIANT::VT_I2|WIN32OLE::VARIANT::VT_BYREF)
-      assert_equal(2, obj.value)
-      assert_equal(WIN32OLE::VARIANT::VT_I2|WIN32OLE::VARIANT::VT_BYREF, obj.vartype)
-
-      obj = WIN32OLE::Variant.new(3, WIN32OLE::VARIANT::VT_I4|WIN32OLE::VARIANT::VT_BYREF)
-      assert_equal(3, obj.value)
-      assert_equal(WIN32OLE::VARIANT::VT_I4|WIN32OLE::VARIANT::VT_BYREF, obj.vartype)
-
-      obj = WIN32OLE::Variant.new(4.5, WIN32OLE::VARIANT::VT_R4|WIN32OLE::VARIANT::VT_BYREF)
-      assert_equal(4.5, obj.value)
-      assert_equal(WIN32OLE::VARIANT::VT_R4|WIN32OLE::VARIANT::VT_BYREF, obj.vartype)
-
-      obj = WIN32OLE::Variant.new(5.5, WIN32OLE::VARIANT::VT_R8|WIN32OLE::VARIANT::VT_BYREF)
-      assert_equal(5.5, obj.value)
-      assert_equal(WIN32OLE::VARIANT::VT_R8|WIN32OLE::VARIANT::VT_BYREF, obj.vartype)
-
-      obj = WIN32OLE::Variant.new(600, WIN32OLE::VARIANT::VT_CY|WIN32OLE::VARIANT::VT_BYREF)
-      assert_equal("600", obj.value)
-      assert_equal(WIN32OLE::VARIANT::VT_CY|WIN32OLE::VARIANT::VT_BYREF, obj.vartype)
-
-      obj = WIN32OLE::Variant.new("2001-06-15 12:17:34", WIN32OLE::VARIANT::VT_DATE|WIN32OLE::VARIANT::VT_BYREF)
-      assert_equal(Time.new(2001,06,15,12,17,34), obj.value)
-      assert_equal(WIN32OLE::VARIANT::VT_DATE|WIN32OLE::VARIANT::VT_BYREF, obj.vartype)
-
-      obj = WIN32OLE::Variant.new("foo", WIN32OLE::VARIANT::VT_BSTR|WIN32OLE::VARIANT::VT_BYREF)
-      assert_equal("foo", obj.value)
-      assert_equal(WIN32OLE::VARIANT::VT_BSTR|WIN32OLE::VARIANT::VT_BYREF, obj.vartype)
-
-      obj = WIN32OLE::Variant.new(true, WIN32OLE::VARIANT::VT_BOOL|WIN32OLE::VARIANT::VT_BYREF)
-      assert_equal(true, obj.value)
-      assert_equal(WIN32OLE::VARIANT::VT_BOOL|WIN32OLE::VARIANT::VT_BYREF, obj.vartype)
-
-      obj = WIN32OLE::Variant.new(2, WIN32OLE::VARIANT::VT_I1|WIN32OLE::VARIANT::VT_BYREF)
-      assert_equal(2, obj.value)
-      assert_equal(WIN32OLE::VARIANT::VT_I1|WIN32OLE::VARIANT::VT_BYREF, obj.vartype)
-
-      obj = WIN32OLE::Variant.new(3, WIN32OLE::VARIANT::VT_UI1|WIN32OLE::VARIANT::VT_BYREF)
-      assert_equal(3, obj.value)
-      assert_equal(WIN32OLE::VARIANT::VT_UI1|WIN32OLE::VARIANT::VT_BYREF, obj.vartype)
-
-      obj = WIN32OLE::Variant.new(4, WIN32OLE::VARIANT::VT_UI2|WIN32OLE::VARIANT::VT_BYREF)
-      assert_equal(4, obj.value)
-      assert_equal(WIN32OLE::VARIANT::VT_UI2|WIN32OLE::VARIANT::VT_BYREF, obj.vartype)
-
-      obj = WIN32OLE::Variant.new(5, WIN32OLE::VARIANT::VT_UI4|WIN32OLE::VARIANT::VT_BYREF)
-      assert_equal(5, obj.value)
-      assert_equal(WIN32OLE::VARIANT::VT_UI4|WIN32OLE::VARIANT::VT_BYREF, obj.vartype)
-
-      obj = WIN32OLE::Variant.new(4, WIN32OLE::VARIANT::VT_INT|WIN32OLE::VARIANT::VT_BYREF)
-      assert_equal(4, obj.value)
-      assert_equal(WIN32OLE::VARIANT::VT_INT|WIN32OLE::VARIANT::VT_BYREF, obj.vartype)
-
-      obj = WIN32OLE::Variant.new(5, WIN32OLE::VARIANT::VT_UINT|WIN32OLE::VARIANT::VT_BYREF)
-      assert_equal(5, obj.value)
-      assert_equal(WIN32OLE::VARIANT::VT_UINT|WIN32OLE::VARIANT::VT_BYREF, obj.vartype)
-    end
-
-    def test_s_new_with_i8_byref
-      obj = WIN32OLE::Variant.new(-123456789012345, WIN32OLE::VARIANT::VT_I8|WIN32OLE::VARIANT::VT_BYREF)
-      assert_equal(-123456789012345, obj.value)
-      assert_equal(WIN32OLE::VARIANT::VT_I8|WIN32OLE::VARIANT::VT_BYREF, obj.vartype)
-    end
-
-    def test_s_new_with_ui8_byref
-      obj = WIN32OLE::Variant.new(123456789012345, WIN32OLE::VARIANT::VT_UI8|WIN32OLE::VARIANT::VT_BYREF)
-      assert_equal(123456789012345, obj.value)
-      assert_equal(WIN32OLE::VARIANT::VT_UI8|WIN32OLE::VARIANT::VT_BYREF, obj.vartype)
-    end
-
-    def test_value
-      obj = WIN32OLE::Variant.new('foo')
-      assert_equal('foo', obj.value)
-    end
-
-    def test_s_new_2_argument
-      obj = WIN32OLE::Variant.new('foo', WIN32OLE::VARIANT::VT_BSTR|WIN32OLE::VARIANT::VT_BYREF)
-      assert_equal('foo', obj.value);
-    end
-
-    def test_s_new_2_argument2
-      obj = WIN32OLE::Variant.new('foo', WIN32OLE::VARIANT::VT_BSTR)
-      assert_equal('foo', obj.value);
-    end
-
-    def test_s_new_dispatch_array
-      vt = WIN32OLE::VARIANT::VT_ARRAY|WIN32OLE::VARIANT::VT_DISPATCH
-      obj = WIN32OLE::Variant.new(nil, vt)
-      assert_equal(vt, obj.vartype)
-      assert_nil(obj.value)
-
-      vt = WIN32OLE::VARIANT::VT_ARRAY|WIN32OLE::VARIANT::VT_DISPATCH|WIN32OLE::VARIANT::VT_BYREF
-      obj = WIN32OLE::Variant.new(nil, vt)
-      assert_equal(vt, obj.vartype)
-      assert_nil(obj.value)
-    end
-
-    def test_s_new_array
-      # should not occur stack over flow
-      ar = (1..500000).to_a.map{|i| [i]}
-      ar2 = WIN32OLE::Variant.new(ar)
-      assert_equal(ar, ar2.value)
-    end
-
-    def test_s_new_vt_record_exc
-      # VT_RECORD (= 36) should not be allowed in WIN32OLE::Variant#new
-      assert_raise(ArgumentError) {
-        WIN32OLE::Variant.new(nil, 36)
-      }
-    end
-
-    def test_s_array
-      obj = WIN32OLE::Variant.array([2,3], WIN32OLE::VARIANT::VT_I4)
-      assert_instance_of(WIN32OLE::Variant, obj)
-      assert_equal(WIN32OLE::VARIANT::VT_I4|WIN32OLE::VARIANT::VT_ARRAY, obj.vartype)
-      assert_equal([[0, 0, 0],[0, 0, 0]], obj.value)
-
-      obj = WIN32OLE::Variant.array([2,3], WIN32OLE::VARIANT::VT_I4|WIN32OLE::VARIANT::VT_BYREF)
-      assert_equal(WIN32OLE::VARIANT::VT_I4|WIN32OLE::VARIANT::VT_BYREF|WIN32OLE::VARIANT::VT_ARRAY, obj.vartype)
-      assert_equal([[0, 0, 0],[0, 0, 0]], obj.value)
-
-      obj = WIN32OLE::Variant.array([2,3], WIN32OLE::VARIANT::VT_I4|WIN32OLE::VARIANT::VT_ARRAY)
-      assert_instance_of(WIN32OLE::Variant, obj)
-      assert_equal(WIN32OLE::VARIANT::VT_I4|WIN32OLE::VARIANT::VT_ARRAY, obj.vartype)
-      assert_equal([[0, 0, 0],[0, 0, 0]], obj.value)
-
-      assert_equal(0, obj[0,0])
-      obj[0,0] = 10
-      assert_equal([[10, 0, 0],[0, 0, 0]], obj.value)
-      obj[0,1] = "13.2"
-      assert_equal([[10, 13, 0],[0, 0, 0]], obj.value)
-
-      obj = WIN32OLE::Variant.array([3, 2], WIN32OLE::VARIANT::VT_VARIANT)
-      obj[0,0] = 10
-      obj[0,1] = "string"
-      obj[1,0] = 12.735
-      assert_equal([[10, "string"],[12.735, nil],[nil,nil]], obj.value)
-
-      obj = WIN32OLE::Variant.array([2,3], WIN32OLE::VARIANT::VT_DISPATCH)
-      assert_equal([[nil, nil, nil],[nil,nil,nil]], obj.value)
-
-    end
-
-    def test_s_array_exc
-      assert_raise(TypeError) {
-        WIN32OLE::Variant.array(2, WIN32OLE::VARIANT::VT_I4)
-      }
-    end
-
-    def test_conversion_num2str
-      obj = WIN32OLE::Variant.new(124, WIN32OLE::VARIANT::VT_BSTR)
-      assert_equal("124", obj.value);
-    end
-
-    def test_conversion_float2int
-      obj = WIN32OLE::Variant.new(12.345, WIN32OLE::VARIANT::VT_I4)
-      assert_equal(12, obj.value)
-      obj = WIN32OLE::Variant.new(12.345, WIN32OLE::VARIANT::VT_I4|WIN32OLE::VARIANT::VT_BYREF)
-      assert_equal(12, obj.value)
-    end
-
-    def test_conversion_str2num
-      obj = WIN32OLE::Variant.new("12.345", WIN32OLE::VARIANT::VT_R8)
-      assert_equal(12.345, obj.value)
-    end
-
-    def test_conversion_ole_variant2ole_variant
-      obj = WIN32OLE::Variant.new("12.345", WIN32OLE::VARIANT::VT_R4)
-      obj = WIN32OLE::Variant.new(obj, WIN32OLE::VARIANT::VT_I4)
-      assert_equal(12, obj.value)
-    end
-
-    def test_conversion_str2date
-      obj = WIN32OLE::Variant.new("2004-12-24 12:24:45", WIN32OLE::VARIANT::VT_DATE)
-      assert_equal(Time.new(2004,12,24,12,24,45), obj.value)
-    end
-
-    def test_conversion_time2date
-      dt = Time.mktime(2004, 12, 24, 12, 24, 45)
-      obj = WIN32OLE::Variant.new(dt, WIN32OLE::VARIANT::VT_DATE)
-      assert_equal(dt, obj.value)
-    end
-
-    def test_conversion_dbl2date_with_msec
-      # Date is "2014/8/27 12:34:56.789"
-      obj = WIN32OLE::Variant.new(41878.524268391200167, WIN32OLE::VARIANT::VT_DATE)
-      t = obj.value
-      assert_equal("2014-08-27 12:34:56", t.strftime('%Y-%m-%d %H:%M:%S'))
-      assert_in_delta(0.789, t.nsec / 1000000000.0, 0.001)
-    end
-
-    def test_conversion_time2date_with_msec
-      t0 = Time.new(2014, 8, 27, 12, 34, 56)
-      t0 += 0.789
-      t1 = WIN32OLE::Variant.new(t0).value
-
-      # The t0.nsec is 789000000 and t1.nsec is 789000465
-      # because of error range by conversion Time between VT_DATE Variant.
-      # So check t1 and t0 are in error by less than one millisecond.
-      msg = "Expected:#{t0.strftime('%Y-%m-%dT%H:%M:%S.%N')} but was:#{t1.strftime('%Y-%m-%dT%H:%M:%S.%N')}"
-      assert_in_delta(t0, t1, 0.001, msg)
-
-      t0 = Time.new(2014, 8, 27, 12, 34, 56)
-      t0 += 0.999999999
-      t1 = WIN32OLE::Variant.new(t0).value
-      msg = "Expected:#{t0.strftime('%Y-%m-%dT%H:%M:%S.%N')} but was:#{t1.strftime('%Y-%m-%dT%H:%M:%S.%N')}"
-
-      # The t0 is "2014/08/27 12:34.56.999999999" and
-      # the t1 is "2014/08/27 12:34:57.000000628"
-      assert_in_delta(t0, t1, 0.001, msg)
-
-      t0 = Time.now
-      t1 = WIN32OLE::Variant.new(t0).value
-      msg = "Expected:#{t0.strftime('%Y-%m-%dT%H:%M:%S.%N')} but was:#{t1.strftime('%Y-%m-%dT%H:%M:%S.%N')}"
-      assert_in_delta(t0, t1, 0.001, msg)
-    end
-
-    # this test failed because of VariantTimeToSystemTime
-    # and SystemTimeToVariantTime API ignores wMilliseconds
-    # member of SYSTEMTIME  struct.
-    #
-    # def test_conversion_time_nsec2date
-    #   dt = Time.new(2004, 12,24, 12, 24, 45)
-    #   dt += 0.1
-    #   obj = WIN32OLE::Variant.new(dt, WIN32OLE::VARIANT::VT_DATE)
-    #   assert_equal(dt, obj.value)
-    # end
-
-    def test_conversion_str2cy
-      begin
-        WIN32OLE.locale = 0x0411 # set locale Japanese
-      rescue WIN32OLE::RuntimeError
-        omit("Japanese locale is not installed")
-      end
-      if WIN32OLE.locale == 0x0411
-        obj = WIN32OLE::Variant.new("\\10,000", WIN32OLE::VARIANT::VT_CY)
-        assert_equal("10000", obj.value)
-      end
-    end
-
-    def test_create_vt_array
-      obj = WIN32OLE::Variant.new([1.2, 2.3], WIN32OLE::VARIANT::VT_ARRAY|WIN32OLE::VARIANT::VT_R8)
-      assert_equal([1.2, 2.3], obj.value)
-      assert_equal(WIN32OLE::VARIANT::VT_ARRAY|WIN32OLE::VARIANT::VT_R8, obj.vartype)
-
-      obj = WIN32OLE::Variant.new([1.2, 2.3], WIN32OLE::VARIANT::VT_ARRAY|WIN32OLE::VARIANT::VT_R8|WIN32OLE::VARIANT::VT_BYREF)
-      assert_equal([1.2, 2.3], obj.value)
-      assert_equal(WIN32OLE::VARIANT::VT_ARRAY|WIN32OLE::VARIANT::VT_R8|WIN32OLE::VARIANT::VT_BYREF, obj.vartype)
-    end
-
-    def test_create_vt_array2
-      obj = WIN32OLE::Variant.new([1.2, "a"], WIN32OLE::VARIANT::VT_ARRAY)
-      assert_equal([1.2, "a"], obj.value)
-      assert_equal(WIN32OLE::VARIANT::VT_ARRAY|WIN32OLE::VARIANT::VT_VARIANT, obj.vartype)
-
-      obj = WIN32OLE::Variant.new([1.2, "a"])
-      assert_equal([1.2, "a"], obj.value)
-      assert_equal(WIN32OLE::VARIANT::VT_ARRAY|WIN32OLE::VARIANT::VT_VARIANT, obj.vartype)
-    end
-
-
-    def test_create_vt_nested_array
-      obj = WIN32OLE::Variant.new([[1.2, "a", "b"], [3.4, "C", "D"]], WIN32OLE::VARIANT::VT_ARRAY)
-      assert_equal([[1.2, "a", "b"], [3.4, "C", "D"]], obj.value)
-
-      obj = WIN32OLE::Variant.new([[1.2, "a", "b"], [3.4, "C", "D"]])
-      assert_equal([[1.2, "a", "b"], [3.4, "C", "D"]], obj.value)
-
-      obj = WIN32OLE::Variant.new([[1.2, "a", "b"], [3.4, "C", "D"], [5.6, "E", "F"]])
-      assert_equal([[1.2, "a", "b"], [3.4, "C", "D"], [5.6, "E", "F"]], obj.value)
-
-      obj = WIN32OLE::Variant.new([[[1.2], [3.4]], [[5.6], [7.8]], [[9.1],[9.2]]])
-      assert_equal([[[1.2], [3.4]], [[5.6], [7.8]], [[9.1],[9.2]]], obj.value)
-    end
-
-    def test_create_vt_array3
-      obj = WIN32OLE::Variant.new([])
-      assert_equal([], obj.value)
-
-      obj = WIN32OLE::Variant.new([[]])
-      assert_equal([[]], obj.value)
-
-      obj = WIN32OLE::Variant.new([[],[]])
-      assert_equal([[],[]], obj.value)
-
-      obj = WIN32OLE::Variant.new([], WIN32OLE::VARIANT::VT_ARRAY|WIN32OLE::VARIANT::VT_BYREF)
-      assert_equal([], obj.value)
-
-      obj = WIN32OLE::Variant.new([[]], WIN32OLE::VARIANT::VT_ARRAY|WIN32OLE::VARIANT::VT_BYREF)
-      assert_equal([[]], obj.value)
-
-      obj = WIN32OLE::Variant.new([[],[]], WIN32OLE::VARIANT::VT_ARRAY|WIN32OLE::VARIANT::VT_BYREF)
-      assert_equal([[],[]], obj.value)
-    end
-
-    def test_create_vt_array_nil
-      vartype = WIN32OLE::VARIANT::VT_ARRAY|WIN32OLE::VARIANT::VT_DISPATCH|WIN32OLE::VARIANT::VT_BYREF
-      obj = WIN32OLE::Variant.new(nil, vartype)
-      assert_nil(obj.value)
-      assert_equal(vartype, obj.vartype)
-
-      vartype = WIN32OLE::VARIANT::VT_ARRAY|WIN32OLE::VARIANT::VT_DISPATCH
-      obj = WIN32OLE::Variant.new(nil, vartype)
-      assert_nil(obj.value)
-      assert_equal(vartype, obj.vartype)
-    end
-
-    def test_create_vt_array_str
-      vartype = WIN32OLE::VARIANT::VT_ARRAY|WIN32OLE::VARIANT::VT_BSTR
-      obj = WIN32OLE::Variant.new(["abc", "123"], vartype)
-      assert_equal(vartype, obj.vartype)
-      assert_equal(["abc", "123"], obj.value)
-
-      vartype = WIN32OLE::VARIANT::VT_ARRAY|WIN32OLE::VARIANT::VT_BYREF|WIN32OLE::VARIANT::VT_BSTR
-      obj = WIN32OLE::Variant.new(["abc", "123"], vartype)
-      assert_equal(vartype, obj.vartype)
-      assert_equal(["abc", "123"], obj.value)
-    end
-
-    def test_create_vt_array_exc
-      exc = assert_raise(TypeError) {
-        WIN32OLE::Variant.new("", WIN32OLE::VARIANT::VT_ARRAY)
-      }
-      assert_match(/wrong argument type String $expected Array$/, exc.message)
-    end
-
-    def test_create_vt_array_str2ui1array
-      obj = WIN32OLE::Variant.new("ABC", WIN32OLE::VARIANT::VT_ARRAY|WIN32OLE::VARIANT::VT_UI1)
-      assert_equal("ABC", obj.value)
-
-      obj.value = "DEF"
-      assert_equal("DEF", obj.value)
-      obj[0] = 71
-      assert_equal("GEF", obj.value)
-
-      obj = WIN32OLE::Variant.new([65, 0].pack("C*"), WIN32OLE::VARIANT::VT_ARRAY|WIN32OLE::VARIANT::VT_UI1)
-      assert_equal([65, 0].pack("C*"), obj.value)
-
-      obj = WIN32OLE::Variant.new("abc", WIN32OLE::VARIANT::VT_ARRAY|WIN32OLE::VARIANT::VT_UI1|WIN32OLE::VARIANT::VT_BYREF)
-      assert_equal("abc", obj.value)
-      obj.value = "DEF"
-      assert_equal("DEF", obj.value)
-      assert_equal(WIN32OLE::VARIANT::VT_ARRAY|WIN32OLE::VARIANT::VT_UI1|WIN32OLE::VARIANT::VT_BYREF, obj.vartype)
-      obj[1] = 71
-      assert_equal("DGF", obj.value)
-
-    end
-
-    def test_create_vt_array_int
-      obj = WIN32OLE::Variant.new([65, 0], WIN32OLE::VARIANT::VT_ARRAY|WIN32OLE::VARIANT::VT_UI1)
-      assert_equal([65, 0].pack("C*"), obj.value)
-
-      obj = WIN32OLE::Variant.new([65, 0])
-      assert_equal([65, 0], obj.value)
-
-      obj = WIN32OLE::Variant.new([65, 0], WIN32OLE::VARIANT::VT_I2|WIN32OLE::VARIANT::VT_ARRAY)
-      assert_equal([65, 0], obj.value)
-
-    end
-
-    def test_vt_array_bracket
-      obj = WIN32OLE::Variant.new([[1,2,3],[4,5,6]])
-      assert_equal(1, obj[0,0])
-      assert_equal(2, obj[0,1])
-      assert_equal(3, obj[0,2])
-      assert_equal(4, obj[1,0])
-      assert_equal(5, obj[1,1])
-      assert_equal(6, obj[1,2])
-
-      assert_raise(WIN32OLE::RuntimeError) {
-        obj[0,4]
-      }
-      assert_raise(WIN32OLE::RuntimeError) {
-        obj[0,-1]
-      }
-      assert_raise(ArgumentError) {
-        obj[0]
-      }
-
-      obj[0,0] = 7
-      obj[1,2] = 8
-      assert_equal([[7,2,3], [4,5,8]], obj.value)
-
-      assert_raise(WIN32OLE::RuntimeError) {
-        obj[0,4] = 9
-      }
-      assert_raise(WIN32OLE::RuntimeError) {
-        obj[0,-1] = 10
-      }
-      assert_raise(ArgumentError) {
-        obj[0] = 11
-      }
-    end
-
-    def test_conversion_vt_date
-      obj = WIN32OLE::Variant.new(-657434, WIN32OLE::VARIANT::VT_DATE)
-      assert_equal(Time.new(100,1,1), obj.value)
-
-      obj = WIN32OLE::Variant.new("1500/12/29 23:59:59", WIN32OLE::VARIANT::VT_DATE)
-      assert_equal(Time.new(1500,12,29,23,59,59), obj.value)
-
-      obj = WIN32OLE::Variant.new("1500/12/30 00:00:00", WIN32OLE::VARIANT::VT_DATE)
-      assert_equal(Time.new(1500,12,30), obj.value)
-
-      obj = WIN32OLE::Variant.new("1500/12/30 00:00:01", WIN32OLE::VARIANT::VT_DATE)
-      assert_equal(Time.new(1500,12,30,0,0,1), obj.value)
-
-      obj = WIN32OLE::Variant.new("1899/12/29 23:59:59", WIN32OLE::VARIANT::VT_DATE)
-      assert_equal(Time.new(1899,12,29,23,59,59), obj.value)
-
-      obj = WIN32OLE::Variant.new("1899/12/30 00:00:00", WIN32OLE::VARIANT::VT_DATE)
-      assert_equal(Time.new(1899,12,30), obj.value)
-
-      obj = WIN32OLE::Variant.new("1899/12/30 00:00:01", WIN32OLE::VARIANT::VT_DATE)
-      assert_equal(Time.new(1899,12,30,0,0,1), obj.value)
-
-      obj = WIN32OLE::Variant.new(0, WIN32OLE::VARIANT::VT_DATE)
-      assert_equal(Time.new(1899,12,30), obj.value)
-
-      obj = WIN32OLE::Variant.new("2008/12/29 23:59:59", WIN32OLE::VARIANT::VT_DATE)
-      assert_equal(Time.new(2008,12,29,23,59,59), obj.value)
-
-      obj = WIN32OLE::Variant.new("2008/12/30 00:00:00", WIN32OLE::VARIANT::VT_DATE)
-      assert_equal(Time.new(2008,12,30,0,0,0), obj.value)
-
-      obj = WIN32OLE::Variant.new("2008/12/30 00:00:01", WIN32OLE::VARIANT::VT_DATE)
-      assert_equal(Time.new(2008,12,30,0,0,1), obj.value)
-
-      obj = WIN32OLE::Variant.new("9999/12/31 23:59:59", WIN32OLE::VARIANT::VT_DATE)
-      assert_equal(Time.new(9999,12,31,23,59,59), obj.value)
-    end
-
-    def test_create_nil_dispatch
-      var = WIN32OLE::Variant.new(nil, WIN32OLE::VARIANT::VT_DISPATCH)
-      assert_nil(var.value)
-    end
-
-    def test_create_variant_byref
-      obj = WIN32OLE::Variant.new("Str", WIN32OLE::VARIANT::VT_VARIANT|WIN32OLE::VARIANT::VT_BYREF);
-      assert_equal("Str", obj.value);
-    end
-
-    def test_vartype
-      obj = WIN32OLE::Variant.new("Str")
-      assert_equal(WIN32OLE::VARIANT::VT_BSTR, obj.vartype)
-    end
-
-    def test_set_value
-      obj = WIN32OLE::Variant.new(10)
-      obj.value = 12
-      assert_equal(12, obj.value)
-      assert_equal(WIN32OLE::VARIANT::VT_I4, obj.vartype)
-      obj.value = "14"
-      assert_equal(14, obj.value)
-      assert_equal(WIN32OLE::VARIANT::VT_I4, obj.vartype)
-      obj.value = 11.2
-      assert_equal(11, obj.value)
-      assert_equal(WIN32OLE::VARIANT::VT_I4, obj.vartype)
-
-      obj = WIN32OLE::Variant.new([1,2])
-      assert_raise(WIN32OLE::RuntimeError) {
-        obj.value = [3,4]
-      }
-
-      obj = WIN32OLE::Variant.new("2007/01/01", WIN32OLE::VARIANT::VT_DATE)
-      assert_raise(WIN32OLE::RuntimeError) {
-        obj.value = "hogehoge"
-      }
-      assert_equal(Time.new(2007,1,1), obj.value)
-
-      obj2 = WIN32OLE::Variant.new("2006/01/01", WIN32OLE::VARIANT::VT_DATE)
-      obj.value = obj2
-      assert_equal(Time.new(2006,01,01), obj.value)
-    end
-
-    def test_c_nothing
-      assert_nil(WIN32OLE::Variant::Nothing.value)
-    end
-
-    def test_c_empty
-      assert_nil(WIN32OLE::Variant::Empty.value)
-    end
-
-    def test_c_null
-      assert_nil(WIN32OLE::Variant::Null.value)
-    end
-
-    def test_c_noparam
-      # DISP_E_PARAMNOTFOUND
-      assert_equal(-2147352572, WIN32OLE::Variant::NoParam.value)
-    end
-
-    def test_vt_error_noparam
-      v = WIN32OLE::Variant.new(-1, WIN32OLE::VARIANT::VT_ERROR)
-      assert_equal(-1, v.value)
-      fso = WIN32OLE.new("Scripting.FileSystemObject")
-      exc = assert_raise(WIN32OLE::RuntimeError) {
-        fso.openTextFile("NonExistingFile", v, false)
-      }
-      assert_match(/Type mismatch/i, exc.message)
-      exc = assert_raise(WIN32OLE::RuntimeError) {
-        fso.openTextFile("NonExistingFile", WIN32OLE::Variant::NoParam, false)
-      }
-      # 800A0035 is 'file not found' error.
-      assert_match(/800A0035/, exc.message)
-
-      # -2147352572 is DISP_E_PARAMNOTFOUND
-      v = WIN32OLE::Variant.new(-2147352572, WIN32OLE::VARIANT::VT_ERROR)
-      exc = assert_raise(WIN32OLE::RuntimeError) {
-        fso.openTextFile("NonExistingFile", WIN32OLE::Variant::NoParam, false)
-      }
-      # 800A0035 is 'file not found' error code.
-      assert_match(/800A0035/, exc.message)
-    end
-
-  end
-end
-
diff --git a/test/mri/win32ole/test_win32ole_variant_m.rb b/test/mri/win32ole/test_win32ole_variant_m.rb
deleted file mode 100644
index f176d1a51e2..00000000000
--- a/test/mri/win32ole/test_win32ole_variant_m.rb
+++ /dev/null
@@ -1,37 +0,0 @@
-# frozen_string_literal: false
-begin
-  require 'win32ole'
-rescue LoadError
-end
-require "test/unit"
-
-if defined?(WIN32OLE::VARIANT)
-  class TestWin32OLE_VARIANT_MODULE < Test::Unit::TestCase
-    include WIN32OLE::VARIANT
-
-    def test_variant
-      assert_equal(0, VT_EMPTY)
-      assert_equal(1, VT_NULL)
-      assert_equal(2, VT_I2)
-      assert_equal(3, VT_I4)
-      assert_equal(4, VT_R4)
-      assert_equal(5, VT_R8)
-      assert_equal(6, VT_CY)
-      assert_equal(7, VT_DATE)
-      assert_equal(8, VT_BSTR)
-      assert_equal(9, VT_DISPATCH)
-      assert_equal(10, VT_ERROR)
-      assert_equal(11, VT_BOOL)
-      assert_equal(12, VT_VARIANT)
-      assert_equal(13, VT_UNKNOWN)
-      assert_equal(16, VT_I1)
-      assert_equal(17, VT_UI1)
-      assert_equal(18, VT_UI2)
-      assert_equal(19, VT_UI4)
-      assert_equal(22, VT_INT)
-      assert_equal(23, VT_UINT)
-      assert_equal(0x2000, VT_ARRAY)
-      assert_equal(0x4000, VT_BYREF)
-    end
-  end
-end
diff --git a/test/mri/win32ole/test_win32ole_variant_outarg.rb b/test/mri/win32ole/test_win32ole_variant_outarg.rb
deleted file mode 100644
index 9301a76aaa5..00000000000
--- a/test/mri/win32ole/test_win32ole_variant_outarg.rb
+++ /dev/null
@@ -1,69 +0,0 @@
-# frozen_string_literal: false
-begin
-  require 'win32ole'
-rescue LoadError
-end
-require 'test/unit'
-require 'fileutils'
-
-def ado_csv_installed?
-  installed = false
-  if defined?(WIN32OLE)
-    db = nil
-    begin
-      db = WIN32OLE.new('ADODB.Connection')
-      db.connectionString = "Driver={Microsoft Text Driver (*.txt; *.csv)};DefaultDir=.;"
-      db.open
-      db.close
-      db = nil
-      installed = true
-    rescue
-    end
-  end
-  installed
-end
-
-if defined?(WIN32OLE::Variant)
-    class TestWIN32OLE_VARIANT_OUTARG < Test::Unit::TestCase
-      module ADO
-      end
-      CONNSTR="Driver={Microsoft Text Driver (*.txt; *.csv)};DefaultDir=.;"
-      def setup
-        return if !ado_csv_installed?
-
-        FileUtils.cp(File.dirname(__FILE__) + '/orig_data.csv', './data.csv')
-        @db = WIN32OLE.new('ADODB.Connection')
-        if !defined?(ADO::AdStateOpen)
-          WIN32OLE.const_load(@db, ADO)
-        end
-        @db.connectionString = CONNSTR
-        @db.open
-      end
-
-      def test_variant_ref_and_argv
-        if !ado_csv_installed?
-          omit("ActiveX Data Object Library not found")
-        end
-        sql = "INSERT INTO data.csv VALUES (5, 'E')"
-        @db.execute(sql, -1)
-        c = WIN32OLE::ARGV[1]
-        assert_equal(1, c)
-        obj = WIN32OLE::Variant.new(nil, WIN32OLE::VARIANT::VT_VARIANT|WIN32OLE::VARIANT::VT_BYREF)
-        assert_equal(nil, obj.value)
-        @db.execute(sql , obj)
-        assert_equal(1, obj.value)
-        obj = WIN32OLE::Variant.new(-100, WIN32OLE::VARIANT::VT_VARIANT|WIN32OLE::VARIANT::VT_BYREF)
-        assert_equal(-100, obj.value)
-        @db.execute(sql, obj)
-        assert_equal(1, obj.value)
-      end
-
-      def teardown
-        return if !ado_csv_installed?
-        if @db && @db.state == ADO::AdStateOpen
-          @db.close
-        end
-        File.unlink("data.csv")
-      end
-    end
-end
diff --git a/test/mri/win32ole/test_word.rb b/test/mri/win32ole/test_word.rb
deleted file mode 100644
index 34cfbbc2a4d..00000000000
--- a/test/mri/win32ole/test_word.rb
+++ /dev/null
@@ -1,73 +0,0 @@
-# frozen_string_literal: false
-#
-# This is test for [ruby-Bugs#3237]
-#
-begin
-  require 'win32ole'
-rescue LoadError
-end
-require "test/unit"
-
-if defined?(WIN32OLE)
-  module Word; end
-end
-
-def word_installed?
-  installed = false
-  w = nil
-  if defined?(WIN32OLE)
-    begin
-      w = WIN32OLE.new('Word.Application')
-      WIN32OLE.const_load(w, Word)
-      installed = true
-    rescue
-    ensure
-      if w
-        w.quit(Word::WdDoNotSaveChanges)
-        w = nil
-      end
-    end
-  end
-  return installed
-end
-
-if defined?(WIN32OLE)
-  class TestWIN32OLE_WITH_WORD < Test::Unit::TestCase
-    unless word_installed?
-      def test_dummy_for_skip_message
-        omit "Microsoft Word is not installed"
-      end
-    else
-      def setup
-        begin
-          @obj = WIN32OLE.new('Word.Application')
-        rescue WIN32OLE::RuntimeError
-          @obj = nil
-        end
-      end
-
-      def test_ole_methods
-        if @obj
-          @obj.visible = true
-          @obj.wordbasic.disableAutoMacros(true)
-          assert(true)
-        end
-      end
-
-      def test_s_connect
-        if @obj
-          obj2 = WIN32OLE.connect("Word.Application")
-          assert_instance_of(WIN32OLE, obj2)
-          obj2.visible = true
-        end
-      end
-
-      def teardown
-        if @obj
-          @obj.quit(Word::WdDoNotSaveChanges)
-          @obj = nil
-        end
-      end
-    end
-  end
-end

From ca2f450d62a33e2d1a1ed2f7df9a8ccc3059e371 Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Thu, 22 Jan 2026 16:45:22 -0600
Subject: [PATCH 072/168] Exclude more ObjSpace tests specific to CRuby

---
 test/mri/excludes/TestObjSpace.rb | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/test/mri/excludes/TestObjSpace.rb b/test/mri/excludes/TestObjSpace.rb
index ef09e9dfef7..3fefafe7b99 100644
--- a/test/mri/excludes/TestObjSpace.rb
+++ b/test/mri/excludes/TestObjSpace.rb
@@ -16,12 +16,15 @@
 exclude :test_dump_control_char, "dumping is largely a CRuby-specific feature"
 exclude :test_dump_dynamic_symbol, "dumping is largely a CRuby-specific feature"
 exclude :test_dump_escapes_method_name, "dumping is largely a CRuby-specific feature"
+exclude :test_dump_flag_age, "depends on running without GC"
 exclude :test_dump_flags, "dumping is largely a CRuby-specific feature"
+exclude :test_dump_include_shareable, "dumping is largely a CRuby-specific feature"
 exclude :test_dump_includes_imemo_type, "dumping is largely a CRuby-specific feature"
 exclude :test_dump_includes_slot_size, "dumping is largely a CRuby-specific feature"
 exclude :test_dump_not_too_complex_shape, "dumping is largely a CRuby-specific feature"
 exclude :test_dump_object, "dumping is largely a CRuby-specific feature"
 exclude :test_dump_objects_dumps_page_slot_sizes, "dumping is largely a CRuby-specific feature"
+exclude :test_dump_outputs_object_id, "dumping is largely a CRuby-specific feature"
 exclude :test_dump_reference_addresses_match_dump_all_addresses, "dumping is largely a CRuby-specific feature"
 exclude :test_dump_shapes, "dumping is largely a CRuby-specific feature"
 exclude :test_dump_singleton_class, "dumping is largely a CRuby-specific feature"
@@ -52,4 +55,5 @@
 exclude :test_trace_object_allocations_gc_stress, "no support on JVM for live allocation tracking"
 exclude :test_trace_object_allocations_start_stop_clear, "no support on JVM for live allocation tracking"
 exclude :test_trace_object_allocations_stop_first, "no support on JVM for live allocation tracking"
+exclude :test_trace_object_allocations_with_other_tracepoint, "no support on JVM for live allocation tracking"
 exclude :test_utf8_method_names, "needs investigation"

From 40ccf3f26fd41e7d54b621092d7595371c4af1d9 Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Thu, 22 Jan 2026 17:01:05 -0600
Subject: [PATCH 073/168] Add TracePoint.stat

This may not be exactly the same result as CRuby but it's close
enough and stat is impl-specific.
---
 .../org/jruby/ext/tracepoint/TracePoint.java    | 17 ++++++++++++++++-
 .../org/jruby/runtime/TraceEventManager.java    | 11 ++++++++++-
 2 files changed, 26 insertions(+), 2 deletions(-)

diff --git a/core/src/main/java/org/jruby/ext/tracepoint/TracePoint.java b/core/src/main/java/org/jruby/ext/tracepoint/TracePoint.java
index 3a2469f1cd1..8257a347c08 100644
--- a/core/src/main/java/org/jruby/ext/tracepoint/TracePoint.java
+++ b/core/src/main/java/org/jruby/ext/tracepoint/TracePoint.java
@@ -2,6 +2,7 @@
 
 import java.util.ArrayList;
 import java.util.EnumSet;
+
 import org.jruby.Ruby;
 import org.jruby.RubyBinding;
 import org.jruby.RubyClass;
@@ -18,8 +19,13 @@
 import org.jruby.runtime.builtin.IRubyObject;
 import org.jruby.util.TypeConverter;
 
+import static org.jruby.RubyHash.newHash;
+import static org.jruby.api.Access.getModule;
 import static org.jruby.api.Access.symbolClass;
-import static org.jruby.api.Convert.*;
+import static org.jruby.api.Convert.asBoolean;
+import static org.jruby.api.Convert.asFixnum;
+import static org.jruby.api.Convert.asSymbol;
+import static org.jruby.api.Create.newArray;
 import static org.jruby.api.Create.newString;
 import static org.jruby.api.Define.defineClass;
 import static org.jruby.api.Error.argumentError;
@@ -231,6 +237,15 @@ public static IRubyObject trace(ThreadContext context, IRubyObject self, IRubyOb
         tp.enable(context, Block.NULL_BLOCK);
         return tp;
     }
+
+    @JRubyMethod(meta = true)
+    public static IRubyObject stat(ThreadContext context, IRubyObject self) {
+        Ruby runtime = context.runtime;
+        var stats = runtime.getTraceEvents().eventHookStats();
+        return newHash(runtime,
+                getModule(context, "JRuby"),
+                newArray(context, asFixnum(context, stats[0]), asFixnum(context, stats[1])));
+    }
     
     private void update(String eventName, String file, int line, String name, IRubyObject type, IRubyObject exception, IRubyObject returnValue, IRubyObject binding) {
         // TODO: missing exception, self, return value
diff --git a/core/src/main/java/org/jruby/runtime/TraceEventManager.java b/core/src/main/java/org/jruby/runtime/TraceEventManager.java
index d234960f6a5..3b14a3559b9 100644
--- a/core/src/main/java/org/jruby/runtime/TraceEventManager.java
+++ b/core/src/main/java/org/jruby/runtime/TraceEventManager.java
@@ -21,7 +21,7 @@
 import java.util.stream.Collectors;
 
 import static org.jruby.api.Convert.asFixnum;
-import static org.jruby.api.Create.*;
+import static org.jruby.api.Create.newString;
 import static org.jruby.api.Warn.warn;
 
 public class TraceEventManager {
@@ -46,6 +46,8 @@ public class TraceEventManager {
     private final Ruby runtime;
     private volatile EventHook[] eventHooks = EMPTY_HOOKS;
     private boolean hasEventHooks;
+    private volatile int added;
+    private volatile int deleted;
     private final CallTraceFuncHook callTraceFuncHook = new CallTraceFuncHook(null);
 
     private final MutableCallSite callTrace = new MutableCallSite(TRACE_OFF);
@@ -84,6 +86,7 @@ public synchronized void addEventHook(ThreadContext context, EventHook hook) {
         eventHooks = newHooks;
 
         hasEventHooks = true;
+        added++;
 
         enableTraceSites(hook);
     }
@@ -115,6 +118,8 @@ public synchronized void removeEventHook(EventHook hook) {
 
             disableTraceSites(hook);
         }
+        added--;
+        deleted++;
     }
 
     private void enableTraceSites(EventHook hook) {
@@ -211,6 +216,10 @@ public boolean hasEventHooks() {
         return hasEventHooks;
     }
 
+    public int[] eventHookStats() {
+        return new int[] {added, deleted};
+    }
+
     public static class CallTraceFuncHook extends EventHook {
         private RubyProc traceFunc;
         private final ThreadContext thread; // if non-null only call traceFunc if it is from this thread.

From a14ab67b64866b1d5a9355c94b2bdfffeb4b3a80 Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Thu, 22 Jan 2026 17:20:52 -0600
Subject: [PATCH 074/168] Update test/tool/lib from CRuby tool/lib

---
 test/tool/lib/_tmpdir.rb              | 100 +++++
 test/tool/lib/bundle_env.rb           |   4 +
 test/tool/lib/bundled_gem.rb          | 126 +++++++
 test/tool/lib/colorize.rb             |  35 +-
 test/tool/lib/core_assertions.rb      |  67 +++-
 test/tool/lib/dump.gdb                |  17 +
 test/tool/lib/dump.lldb               |  13 +
 test/tool/lib/envutil.rb              | 190 ++++++++--
 test/tool/lib/gem_env.rb              |   1 +
 test/tool/lib/iseq_loader_checker.rb  |   9 +
 test/tool/lib/launchable.rb           |  91 +++++
 test/tool/lib/leakchecker.rb          |  21 +-
 test/tool/lib/memory_status.rb        | 102 +++---
 test/tool/lib/output.rb               |  70 ++++
 test/tool/lib/path.rb                 | 101 +++++
 test/tool/lib/test/jobserver.rb       |  47 +++
 test/tool/lib/test/unit.rb            | 374 +++++++++++++------
 test/tool/lib/test/unit/assertions.rb |  32 +-
 test/tool/lib/test/unit/parallel.rb   |  27 +-
 test/tool/lib/test/unit/testcase.rb   |  22 +-
 test/tool/lib/vcs.rb                  | 506 +++++++++++---------------
 test/tool/lib/vpath.rb                |   7 +-
 22 files changed, 1413 insertions(+), 549 deletions(-)
 create mode 100644 test/tool/lib/_tmpdir.rb
 create mode 100644 test/tool/lib/bundle_env.rb
 create mode 100644 test/tool/lib/bundled_gem.rb
 create mode 100644 test/tool/lib/dump.gdb
 create mode 100644 test/tool/lib/dump.lldb
 create mode 100644 test/tool/lib/gem_env.rb
 create mode 100644 test/tool/lib/launchable.rb
 create mode 100644 test/tool/lib/output.rb
 create mode 100644 test/tool/lib/path.rb
 create mode 100644 test/tool/lib/test/jobserver.rb

diff --git a/test/tool/lib/_tmpdir.rb b/test/tool/lib/_tmpdir.rb
new file mode 100644
index 00000000000..daa1a1f2350
--- /dev/null
+++ b/test/tool/lib/_tmpdir.rb
@@ -0,0 +1,100 @@
+template = "rubytest."
+
+# This path is only for tests.
+# Assume the directory by these environment variables are safe.
+base = [ENV["TMPDIR"], ENV["TMP"], "/tmp"].find do |tmp|
+  next unless tmp and tmp.size <= 50 and File.directory?(tmp)
+  # On macOS, the default TMPDIR is very long, in spite of UNIX socket
+  # path length being limited.
+  #
+  # Also Rubygems creates its own temporary directory per tests, and
+  # some tests copy the full path of gemhome there.  In that case, the
+  # path contains both temporary names twice, and can exceed path name
+  # limit very easily.
+  tmp
+end
+begin
+  tmpdir = File.join(base, template + Random.new_seed.to_s(36)[-6..-1])
+  Dir.mkdir(tmpdir, 0o700)
+rescue Errno::EEXIST
+  retry
+end
+# warn "tmpdir(#{tmpdir.size}) = #{tmpdir}"
+
+pid = $$
+END {
+  if pid == $$
+    begin
+      Dir.rmdir(tmpdir)
+    rescue Errno::ENOENT
+    rescue Errno::ENOTEMPTY
+      require_relative "colorize"
+      colorize = Colorize.new
+      ls = Struct.new(:colorize) do
+        def mode_inspect(m, s)
+          [
+            (m & 0o4 == 0 ? ?- : ?r),
+            (m & 0o2 == 0 ? ?- : ?w),
+            (m & 0o1 == 0 ? (s ? s.upcase : ?-) : (s || ?x)),
+          ]
+        end
+        def decorate_path(path, st)
+          case
+          when st.directory?
+            color = "bold;blue"
+            type = "/"
+          when st.symlink?
+            color = "bold;cyan"
+            # type = "@"
+          when st.executable?
+            color = "bold;green"
+            type = "*"
+          when path.end_with?(".gem")
+            color = "green"
+          end
+          colorize.decorate(path, color) + (type || "")
+        end
+        def list_tree(parent, indent = "", &block)
+          children = Dir.children(parent).map do |child|
+            [child, path = File.join(parent, child), File.lstat(path)]
+          end
+          nlink_width = children.map {|child, path, st| st.nlink}.max.to_s.size
+          size_width = children.map {|child, path, st| st.size}.max.to_s.size
+
+          children.each do |child, path, st|
+            m = st.mode
+            m = [
+              (st.file? ? ?- : st.ftype[0]),
+              mode_inspect(m >> 6, (?s unless m & 04000 == 0)),
+              mode_inspect(m >> 3, (?s unless m & 02000 == 0)),
+              mode_inspect(m,      (?t unless m & 01000 == 0)),
+            ].join("")
+            warn sprintf("%s* %s %*d %*d %s % s%s",
+                         indent, m, nlink_width, st.nlink, size_width, st.size,
+                         st.mtime.to_s, decorate_path(child,  st),
+                         (" -> " + decorate_path(File.readlink(path), File.stat(path)) if
+                           st.symlink?))
+            if st.directory?
+              list_tree(File.join(parent, child), indent + "  ", &block)
+            end
+            yield path, st if block
+          end
+        end
+      end.new(colorize)
+      warn colorize.notice("Children under ")+colorize.fail(tmpdir)+":"
+      Dir.chdir(tmpdir) do
+        ls.list_tree(".") do |path, st|
+          if st.directory?
+            Dir.rmdir(path)
+          else
+            File.unlink(path)
+          end
+        end
+      end
+      require "fileutils"
+      FileUtils.rm_rf(tmpdir)
+    end
+  end
+}
+
+ENV["TMPDIR"] = ENV["SPEC_TEMP_DIR"] = ENV["GEM_TEST_TMPDIR"] = tmpdir
diff --git a/test/tool/lib/bundle_env.rb b/test/tool/lib/bundle_env.rb
new file mode 100644
index 00000000000..9ad5ea220b4
--- /dev/null
+++ b/test/tool/lib/bundle_env.rb
@@ -0,0 +1,4 @@
+ENV["GEM_HOME"] = File.expand_path("../../.bundle", __dir__)
+ENV["BUNDLE_APP_CONFIG"] = File.expand_path("../../.bundle", __dir__)
+ENV["BUNDLE_PATH__SYSTEM"] = "true"
+ENV["BUNDLE_WITHOUT"] = "lint doc"
diff --git a/test/tool/lib/bundled_gem.rb b/test/tool/lib/bundled_gem.rb
new file mode 100644
index 00000000000..d2ed61a508f
--- /dev/null
+++ b/test/tool/lib/bundled_gem.rb
@@ -0,0 +1,126 @@
+require 'fileutils'
+require 'rubygems'
+require 'rubygems/package'
+
+# This library is used by "make extract-gems" to
+# unpack bundled gem files.
+
+module BundledGem
+  DEFAULT_GEMS_DEPENDENCIES = [
+    "net-protocol", # net-ftp
+    "time", # net-ftp
+    "singleton", # prime
+    "ipaddr", # rinda
+    "forwardable", # prime, rinda
+    "strscan", # rexml
+    "psych" # rdoc
+  ]
+
+  module_function
+
+  def unpack(file, *rest)
+    pkg = Gem::Package.new(file)
+    prepare_test(pkg.spec, *rest) do |dir|
+      pkg.extract_files(dir)
+      FileUtils.rm_rf(Dir.glob(".git*", base: dir).map {|n| File.join(dir, n)})
+    end
+    puts "Unpacked #{file}"
+  rescue Gem::Package::FormatError, Errno::ENOENT
+    puts "Try with hash version of bundled gems instead of #{file}. We don't use this gem with release version of Ruby."
+    if file =~ /^gems\/(\w+)-/
+      file = Dir.glob("gems/#{$1}-*.gem").first
+    end
+    retry
+  end
+
+  def build(gemspec, version, outdir = ".", validation: true)
+    outdir = File.expand_path(outdir)
+    gemdir, gemfile = File.split(gemspec)
+    Dir.chdir(gemdir) do
+      spec = Gem::Specification.load(gemfile)
+      abort "Failed to load #{gemspec}" unless spec
+      output = File.join(outdir, spec.file_name)
+      FileUtils.rm_rf(output)
+      package = Gem::Package.new(output)
+      package.spec = spec
+      package.build(validation == false)
+    end
+  end
+
+  def copy(path, *rest)
+    path, n = File.split(path)
+    spec = Dir.chdir(path) {Gem::Specification.load(n)} or raise "Cannot load #{path}"
+    prepare_test(spec, *rest) do |dir|
+      FileUtils.rm_rf(dir)
+      files = spec.files.reject {|f| f.start_with?(".git")}
+      dirs = files.map {|f| File.dirname(f) if f.include?("/")}.uniq
+      FileUtils.mkdir_p(dirs.map {|d| d ? "#{dir}/#{d}" : dir}.sort_by {|d| d.count("/")})
+      files.each do |f|
+        File.copy_stream(File.join(path, f), File.join(dir, f))
+      end
+    end
+    puts "Copied #{path}"
+  end
+
+  def prepare_test(spec, dir = ".")
+    target = spec.full_name
+    Gem.ensure_gem_subdirectories(dir)
+    gem_dir = File.join(dir, "gems", target)
+    yield gem_dir
+    spec_dir = spec.extensions.empty? ? "specifications" : File.join("gems", target)
+    if spec.extensions.empty?
+      spec.dependencies.reject! {|dep| DEFAULT_GEMS_DEPENDENCIES.include?(dep.name)}
+    end
+    File.binwrite(File.join(dir, spec_dir, "#{target}.gemspec"), spec.to_ruby)
+    unless spec.extensions.empty?
+      spec.dependencies.clear
+      File.binwrite(File.join(dir, spec_dir, ".bundled.#{target}.gemspec"), spec.to_ruby)
+    end
+    if spec.bindir and spec.executables
+      bindir = File.join(dir, "bin")
+      Dir.mkdir(bindir) rescue nil
+      spec.executables.each do |exe|
+        File.open(File.join(bindir, exe), "wb", 0o777) {|f|
+          f.print "#!ruby\n",
+                  %[load File.realpath("../gems/#{target}/#{spec.bindir}/#{exe}", __dir__)\n]
+        }
+      end
+    end
+    FileUtils.rm_rf(Dir.glob("#{gem_dir}/.git*"))
+  end
+
+  def dummy_gemspec(gemspec)
+    return if File.exist?(gemspec)
+    gemdir, gemfile = File.split(gemspec)
+    Dir.chdir(gemdir) do
+      spec = Gem::Specification.new do |s|
+        s.name = gemfile.chomp(".gemspec")
+        s.version =
+          File.read("lib/#{s.name}.rb")[/VERSION = "(.+?)"/, 1] ||
+          begin File.read("lib/#{s.name}/version.rb")[/VERSION = "(.+?)"/, 1]; rescue; nil; end ||
+          raise("cannot find the version of #{ s.name } gem")
+        s.authors = ["DUMMY"]
+        s.email = ["dummy@ruby-lang.org"]
+        s.files = Dir.glob("{lib,ext}/**/*").select {|f| File.file?(f)}
+        s.licenses = ["Ruby"]
+        s.description = "DO NOT USE; dummy gemspec only for test"
+        s.summary = "(dummy gemspec)"
+      end
+      File.write(gemfile, spec.to_ruby)
+    end
+  end
+
+  def checkout(gemdir, repo, rev, git: $git)
+    return unless rev or !git or git.empty?
+    unless File.exist?("#{gemdir}/.git")
+      puts "Cloning #{repo}"
+      command = "#{git} clone #{repo} #{gemdir}"
+      system(command) or raise "failed: #{command}"
+    end
+    puts "Update #{File.basename(gemdir)} to #{rev}"
+    command = "#{git} fetch origin #{rev}"
+    system(command, chdir: gemdir) or raise "failed: #{command}"
+    command = "#{git} checkout --detach #{rev}"
+    system(command, chdir: gemdir) or raise "failed: #{command}"
+  end
+end
diff --git a/test/tool/lib/colorize.rb b/test/tool/lib/colorize.rb
index 11b878d3182..09043121193 100644
--- a/test/tool/lib/colorize.rb
+++ b/test/tool/lib/colorize.rb
@@ -6,8 +6,8 @@ class Colorize
   #   Colorize.new(color: color, colors_file: colors_file)
   def initialize(color = nil, opts = ((_, color = color, nil)[0] if Hash === color))
     @colors = @reset = nil
-    @color = (opts[:color] if opts)
-    if color or (color == nil && STDOUT.tty?)
+    @color = opts && opts[:color] || color
+    if color or (color == nil && coloring?)
       if (%w[smso so].any? {|attr| /\A\e\[.*m\z/ =~ IO.popen("tput #{attr}", "r", :err => IO::NULL, &:read)} rescue nil)
         @beg = "\e["
         colors = (colors = ENV['TEST_COLORS']) ? Hash[colors.scan(/(\w+)=([^:\n]*)/)] : {}
@@ -27,21 +27,48 @@ def initialize(color = nil, opts = ((_, color = color, nil)[0] if Hash === color
   end
 
   DEFAULTS = {
-    "pass"=>"32", "fail"=>"31;1", "skip"=>"33;1",
+    # color names
     "black"=>"30", "red"=>"31", "green"=>"32", "yellow"=>"33",
     "blue"=>"34", "magenta"=>"35", "cyan"=>"36", "white"=>"37",
     "bold"=>"1", "underline"=>"4", "reverse"=>"7",
+    "bright_black"=>"90", "bright_red"=>"91", "bright_green"=>"92", "bright_yellow"=>"93",
+    "bright_blue"=>"94", "bright_magenta"=>"95", "bright_cyan"=>"96", "bright_white"=>"97",
+
+    # abstract decorations
+    "pass"=>"green", "fail"=>"red;bold", "skip"=>"yellow;bold",
+    "note"=>"bright_yellow", "notice"=>"bright_yellow", "info"=>"bright_magenta",
   }
 
+  def coloring?
+    STDOUT.tty? && (!(nc = ENV['NO_COLOR']) || nc.empty?)
+  end
+
   # colorize.decorate(str, name = color_name)
   def decorate(str, name = @color)
-    if @colors and color = (@colors[name] || DEFAULTS[name])
+    if coloring? and color = resolve_color(name)
       "#{@beg}#{color}m#{str}#{@reset}"
     else
       str
     end
   end
 
+  def resolve_color(color = @color, seen = {}, colors = nil)
+    return unless @colors
+    color.to_s.gsub(/\b[a-z][\w ]+/) do |n|
+      n.gsub!(/\W+/, "_")
+      n.downcase!
+      c = seen[n] and next c
+      if colors
+        c = colors[n]
+      elsif (c = (tbl = @colors)[n] || (tbl = DEFAULTS)[n])
+        colors = tbl
+      else
+        next n
+      end
+      seen[n] = resolve_color(c, seen, colors)
+    end
+  end
+
   DEFAULTS.each_key do |name|
     define_method(name) {|str|
       decorate(str, name)
diff --git a/test/tool/lib/core_assertions.rb b/test/tool/lib/core_assertions.rb
index 5c5c9390f99..bab3a00ac70 100644
--- a/test/tool/lib/core_assertions.rb
+++ b/test/tool/lib/core_assertions.rb
@@ -75,9 +75,18 @@ module CoreAssertions
       require_relative 'envutil'
       require 'pp'
       begin
-        require '-test-/asan'
+        require '-test-/sanitizers'
       rescue LoadError
+        # in test-unit-ruby-core gem
+        def sanitizers
+          nil
+        end
+      else
+        def sanitizers
+          Test::Sanitizers
+        end
       end
+      module_function :sanitizers
 
       nil.pretty_inspect
 
@@ -97,11 +106,14 @@ def assert_file
       end
 
       def assert_in_out_err(args, test_stdin = "", test_stdout = [], test_stderr = [], message = nil,
-                            success: nil, **opt)
+                            success: nil, failed: nil, gems: false, **opt)
         args = Array(args).dup
-        args.insert((Hash === args[0] ? 1 : 0), '--disable=gems')
+        unless gems.nil?
+          args.insert((Hash === args[0] ? 1 : 0), "--#{gems ? 'enable' : 'disable'}=gems")
+        end
         stdout, stderr, status = EnvUtil.invoke_ruby(args, test_stdin, true, true, **opt)
-        desc = FailDesc[status, message, stderr]
+        desc = failed[status, message, stderr] if failed
+        desc ||= FailDesc[status, message, stderr]
         if block_given?
           raise "test_stdout ignored, use block only or without block" if test_stdout != []
           raise "test_stderr ignored, use block only or without block" if test_stderr != []
@@ -159,7 +171,7 @@ def assert_no_memory_leak(args, prepare, code, message=nil, limit: 2.0, rss: fal
         pend 'assert_no_memory_leak may consider MJIT memory usage as leak' if defined?(RubyVM::MJIT) && RubyVM::MJIT.enabled?
         # ASAN has the same problem - its shadow memory greatly increases memory usage
         # (plus asan has better ways to detect memory leaks than this assertion)
-        pend 'assert_no_memory_leak may consider ASAN memory usage as leak' if defined?(Test::ASAN) && Test::ASAN.enabled?
+        pend 'assert_no_memory_leak may consider ASAN memory usage as leak' if sanitizers&.asan_enabled?
 
         require_relative 'memory_status'
         raise Test::Unit::PendedError, "unsupported platform" unless defined?(Memory::Status)
@@ -327,7 +339,16 @@ def assert_separately(args, file = nil, line = nil, src, ignore_stderr: nil, **o
         args = args.dup
         args.insert((Hash === args.first ? 1 : 0), "-w", "--disable=gems", *$:.map {|l| "-I#{l}"})
         args << "--debug" if RUBY_ENGINE == 'jruby' # warning: tracing (e.g. set_trace_func) will not capture all events without --debug flag
+        # power_assert 3 requires ruby 3.1 or later
+        args << "-W:no-experimental" if RUBY_VERSION < "3.1."
         stdout, stderr, status = EnvUtil.invoke_ruby(args, src, capture_stdout, true, **opt)
+
+        if sanitizers&.lsan_enabled?
+          # LSAN may output messages like the following line into stderr. We should ignore it.
+          #   ==276855==Running thread 276851 was not suspended. False leaks are possible.
+          # See https://github.com/google/sanitizers/issues/1479
+          stderr.gsub!(/==\d+==Running thread \d+ was not suspended\. False leaks are possible\.\n/, "")
+        end
       ensure
         if res_c
           res_c.close
@@ -369,9 +390,17 @@ def assert_separately(args, file = nil, line = nil, src, ignore_stderr: nil, **o
 
       # Run Ractor-related test without influencing the main test suite
       def assert_ractor(src, args: [], require: nil, require_relative: nil, file: nil, line: nil, ignore_stderr: nil, **opt)
-        return unless defined?(Ractor)
+        omit unless defined?(Ractor)
+
+        # https://bugs.ruby-lang.org/issues/21262
+        shim_value = "class Ractor; alias value take; end" unless Ractor.method_defined?(:value)
+        shim_join = "class Ractor; alias join take; end" unless Ractor.method_defined?(:join)
+
+        if require
+          require = [require] unless require.is_a?(Array)
+          require = require.map {|r| "require #{r.inspect}"}.join("\n")
+        end
 
-        require = "require #{require.inspect}" if require
         if require_relative
           dir = File.dirname(caller_locations[0,1][0].absolute_path)
           full_path = File.expand_path(require_relative, dir)
@@ -379,6 +408,8 @@ def assert_ractor(src, args: [], require: nil, require_relative: nil, file: nil,
         end
 
         assert_separately(args, file, line, <<~RUBY, ignore_stderr: ignore_stderr, **opt)
+          #{shim_value}
+          #{shim_join}
           #{require}
           previous_verbose = $VERBOSE
           $VERBOSE = nil
@@ -494,13 +525,10 @@ def assert_raise_with_message(exception, expected, msg = nil, &block)
           assert = :assert_match
         end
 
-        ex = m = nil
-        EnvUtil.with_default_internal(of: expected) do
-          ex = assert_raise(exception, msg || proc {"Exception(#{exception}) with message matches to #{expected.inspect}"}) do
-            yield
-          end
-          m = ex.message
+        ex = assert_raise(exception, msg || proc {"Exception(#{exception}) with message matches to #{expected.inspect}"}) do
+          yield
         end
+        m = ex.message
         msg = message(msg, "") {"Expected Exception(#{exception}) was raised, but the message doesn't match"}
 
         if assert == :assert_equal
@@ -683,17 +711,15 @@ def assert_warn(*args)
         assert_warning(*args) {$VERBOSE = false; yield}
       end
 
-      def assert_deprecated_warning(mesg = /deprecated/)
+      def assert_deprecated_warning(mesg = /deprecated/, &block)
         assert_warning(mesg) do
-          Warning[:deprecated] = true if Warning.respond_to?(:[]=)
-          yield
+          EnvUtil.deprecation_warning(&block)
         end
       end
 
-      def assert_deprecated_warn(mesg = /deprecated/)
+      def assert_deprecated_warn(mesg = /deprecated/, &block)
         assert_warn(mesg) do
-          Warning[:deprecated] = true if Warning.respond_to?(:[]=)
-          yield
+          EnvUtil.deprecation_warning(&block)
         end
       end
 
@@ -830,6 +856,9 @@ def assert_all_assertions_foreach(msg = nil, *keys, &block)
             rescue
               # Constants may be defined but not implemented, e.g., mingw.
             else
+              unless Process.clock_getres(clk) < 1.0e-03
+                next # needs msec precision
+              end
               PERFORMANCE_CLOCK = clk
             end
           end
diff --git a/test/tool/lib/dump.gdb b/test/tool/lib/dump.gdb
new file mode 100644
index 00000000000..56b420a5461
--- /dev/null
+++ b/test/tool/lib/dump.gdb
@@ -0,0 +1,17 @@
+set height 0
+set width 0
+set confirm off
+
+echo \n>>> Threads\n\n
+info threads
+
+echo \n>>> Machine level backtrace\n\n
+thread apply all info stack full
+
+echo \n>>> Dump Ruby level backtrace (if possible)\n\n
+call rb_vmdebug_stack_dump_all_threads()
+call fflush(stderr)
+
+echo ">>> Finish\n"
+detach
+quit
diff --git a/test/tool/lib/dump.lldb b/test/tool/lib/dump.lldb
new file mode 100644
index 00000000000..ed9cb890104
--- /dev/null
+++ b/test/tool/lib/dump.lldb
@@ -0,0 +1,13 @@
+script print("\n>>> Threads\n\n")
+thread list
+
+script print("\n>>> Machine level backtrace\n\n")
+thread backtrace all
+
+script print("\n>>> Dump Ruby level backtrace (if possible)\n\n")
+call rb_vmdebug_stack_dump_all_threads()
+call fflush(stderr)
+
+script print(">>> Finish\n")
+detach
+quit
diff --git a/test/tool/lib/envutil.rb b/test/tool/lib/envutil.rb
index cfd2f92c5aa..60896050567 100644
--- a/test/tool/lib/envutil.rb
+++ b/test/tool/lib/envutil.rb
@@ -15,23 +15,22 @@
 module EnvUtil
   def rubybin
     if ruby = ENV["RUBY"]
-      return ruby
-    end
-    ruby = "ruby"
-    exeext = RbConfig::CONFIG["EXEEXT"]
-    rubyexe = (ruby + exeext if exeext and !exeext.empty?)
-    3.times do
-      if File.exist? ruby and File.executable? ruby and !File.directory? ruby
-        return File.expand_path(ruby)
-      end
-      if rubyexe and File.exist? rubyexe and File.executable? rubyexe
-        return File.expand_path(rubyexe)
-      end
-      ruby = File.join("..", ruby)
-    end
-    if defined?(RbConfig.ruby)
+      ruby
+    elsif defined?(RbConfig.ruby)
       RbConfig.ruby
     else
+      ruby = "ruby"
+      exeext = RbConfig::CONFIG["EXEEXT"]
+      rubyexe = (ruby + exeext if exeext and !exeext.empty?)
+      3.times do
+        if File.exist? ruby and File.executable? ruby and !File.directory? ruby
+          return File.expand_path(ruby)
+        end
+        if rubyexe and File.exist? rubyexe and File.executable? rubyexe
+          return File.expand_path(rubyexe)
+        end
+        ruby = File.join("..", ruby)
+      end
       "ruby"
     end
   end
@@ -53,7 +52,14 @@ def capture_global_values
       @original_internal_encoding = Encoding.default_internal
       @original_external_encoding = Encoding.default_external
       @original_verbose = $VERBOSE
-      @original_warning = defined?(Warning.[]) ? %i[deprecated experimental].to_h {|i| [i, Warning[i]]} : nil
+      @original_warning =
+        if defined?(Warning.categories)
+          Warning.categories.to_h {|i| [i, Warning[i]]}
+        elsif defined?(Warning.[]) # 2.7+
+          %i[deprecated experimental performance].to_h do |i|
+            [i, begin Warning[i]; rescue ArgumentError; end]
+          end.compact
+        end
     end
   end
 
@@ -73,6 +79,72 @@ def timeout(sec, klass = nil, message = nil, &blk)
   end
   module_function :timeout
 
+  class Debugger
+    @list = []
+
+    attr_accessor :name
+
+    def self.register(name, &block)
+      @list << new(name, &block)
+    end
+
+    def initialize(name, &block)
+      @name = name
+      instance_eval(&block)
+    end
+
+    def usable?; false; end
+
+    def start(pid, *args) end
+
+    def dump(pid, timeout: 60, reprieve: timeout&.div(4))
+      dpid = start(pid, *command_file(File.join(__dir__, "dump.#{name}")), out: :err)
+    rescue Errno::ENOENT
+      return
+    else
+      return unless dpid
+      [[timeout, :TERM], [reprieve, :KILL]].find do |t, sig|
+        begin
+          return EnvUtil.timeout(t) {Process.wait(dpid)}
+        rescue Timeout::Error
+          Process.kill(sig, dpid)
+        end
+      end
+      true
+    end
+
+    # sudo -n: --non-interactive
+    PRECOMMAND = (%[sudo -n] if /darwin/ =~ RUBY_PLATFORM)
+
+    def spawn(*args, **opts)
+      super(*PRECOMMAND, *args, **opts)
+    end
+
+    register("gdb") do
+      class << self
+        def usable?; system(*%w[gdb --batch --quiet --nx -ex exit]); end
+        def start(pid, *args, **opts)
+          spawn(*%W[gdb --batch --quiet --pid #{pid}], *args, **opts)
+        end
+        def command_file(file) "--command=#{file}"; end
+      end
+    end
+
+    register("lldb") do
+      class << self
+        def usable?; system(*%w[lldb -Q --no-lldbinit -o exit]); end
+        def start(pid, *args, **opts)
+          spawn(*%W[lldb --batch -Q --attach-pid #{pid}], *args, **opts)
+        end
+        def command_file(file) ["--source", file]; end
+      end
+    end
+
+    def self.search
+      @debugger ||= @list.find(&:usable?)
+    end
+  end
+
   def terminate(pid, signal = :TERM, pgroup = nil, reprieve = 1)
     reprieve = apply_timeout_scale(reprieve) if reprieve
 
@@ -88,17 +160,12 @@ def terminate(pid, signal = :TERM, pgroup = nil, reprieve = 1)
       pgroup = pid
     end
 
-    lldb = true if /darwin/ =~ RUBY_PLATFORM
-
+    dumped = false
     while signal = signals.shift
 
-      if lldb and [:ABRT, :KILL].include?(signal)
-        lldb = false
-        # sudo -n: --non-interactive
-        # lldb -p: attach
-        #      -o: run command
-        system(*%W[sudo -n lldb -p #{pid} --batch -o bt\ all -o call\ rb_vmdebug_stack_dump_all_threads() -o quit])
-        true
+      if !dumped and [:ABRT, :KILL].include?(signal)
+        Debugger.search&.dump(pid)
+        dumped = true
       end
 
       begin
@@ -152,8 +219,18 @@ def invoke_ruby(args, stdin_data = "", capture_stdout = false, capture_stderr =
     if RUBYLIB and lib = child_env["RUBYLIB"]
       child_env["RUBYLIB"] = [lib, RUBYLIB].join(File::PATH_SEPARATOR)
     end
-    child_env['ASAN_OPTIONS'] = ENV['ASAN_OPTIONS'] if ENV['ASAN_OPTIONS']
+
+    # remain env
+    %w(ASAN_OPTIONS RUBY_ON_BUG).each{|name|
+      child_env[name] = ENV[name] if !child_env.key?(name) and ENV.key?(name)
+    }
+
     args = [args] if args.kind_of?(String)
+    # use the same parser as current ruby
+    if (args.none? { |arg| arg.start_with?("--parser=") } and
+        /^ +--parser=/ =~ IO.popen([rubybin, "--help"], &:read))
+      args = ["--parser=#{current_parser}"] + args
+    end
     pid = spawn(child_env, *precommand, rubybin, *args, opt)
     in_c.close
     out_c&.close
@@ -201,6 +278,12 @@ def invoke_ruby(args, stdin_data = "", capture_stdout = false, capture_stderr =
   end
   module_function :invoke_ruby
 
+  def current_parser
+    features = RUBY_DESCRIPTION[%r{\)\K [-+*/%._0-9a-zA-Z\[\] ]*(?=\[[-+*/%._0-9a-zA-Z]+\]\z)}]
+    features&.split&.include?("+PRISM") ? "prism" : "parse.y"
+  end
+  module_function :current_parser
+
   def verbose_warning
     class << (stderr = "".dup)
       alias write concat
@@ -217,6 +300,21 @@ def flush; end
   end
   module_function :verbose_warning
 
+  if defined?(Warning.[]=)
+    def deprecation_warning
+      previous_deprecated = Warning[:deprecated]
+      Warning[:deprecated] = true
+      yield
+    ensure
+      Warning[:deprecated] = previous_deprecated
+    end
+  else
+    def deprecation_warning
+      yield
+    end
+  end
+  module_function :deprecation_warning
+
   def default_warning
     $VERBOSE = false
     yield
@@ -241,6 +339,28 @@ def under_gc_stress(stress = true)
   end
   module_function :under_gc_stress
 
+  def under_gc_compact_stress(val = :empty, &block)
+    raise "compaction doesn't work well on s390x. Omit the test in the caller." if RUBY_PLATFORM =~ /s390x/ # https://github.com/ruby/ruby/pull/5077
+
+    if GC.respond_to?(:auto_compact)
+      auto_compact = GC.auto_compact
+      GC.auto_compact = val
+    end
+
+    under_gc_stress(&block)
+  ensure
+    GC.auto_compact = auto_compact if GC.respond_to?(:auto_compact)
+  end
+  module_function :under_gc_compact_stress
+
+  def without_gc
+    prev_disabled = GC.disable
+    yield
+  ensure
+    GC.enable unless prev_disabled
+  end
+  module_function :without_gc
+
   def with_default_external(enc = nil, of: nil)
     enc = of.encoding if defined?(of.encoding)
     suppress_warning { Encoding.default_external = enc }
@@ -294,16 +414,24 @@ def self.diagnostic_reports(signame, pid, now)
       cmd = @ruby_install_name if "ruby-runner#{RbConfig::CONFIG["EXEEXT"]}" == cmd
       path = DIAGNOSTIC_REPORTS_PATH
       timeformat = DIAGNOSTIC_REPORTS_TIMEFORMAT
-      pat = "#{path}/#{cmd}_#{now.strftime(timeformat)}[-_]*.crash"
+      pat = "#{path}/#{cmd}_#{now.strftime(timeformat)}[-_]*.{crash,ips}"
       first = true
       30.times do
         first ? (first = false) : sleep(0.1)
         Dir.glob(pat) do |name|
           log = File.read(name) rescue next
-          if /\AProcess:\s+#{cmd} \[#{pid}\]$/ =~ log
-            File.unlink(name)
-            File.unlink("#{path}/.#{File.basename(name)}.plist") rescue nil
-            return log
+          case name
+          when /\.crash\z/
+            if /\AProcess:\s+#{cmd} \[#{pid}\]$/ =~ log
+              File.unlink(name)
+              File.unlink("#{path}/.#{File.basename(name)}.plist") rescue nil
+              return log
+            end
+          when /\.ips\z/
+            if /^ *"pid" *: *#{pid},/ =~ log
+              File.unlink(name)
+              return log
+            end
           end
         end
       end
diff --git a/test/tool/lib/gem_env.rb b/test/tool/lib/gem_env.rb
new file mode 100644
index 00000000000..1893e076573
--- /dev/null
+++ b/test/tool/lib/gem_env.rb
@@ -0,0 +1 @@
+ENV['GEM_HOME'] = File.expand_path('../../.bundle', __dir__)
diff --git a/test/tool/lib/iseq_loader_checker.rb b/test/tool/lib/iseq_loader_checker.rb
index 3f07b3a999e..73784f8450f 100644
--- a/test/tool/lib/iseq_loader_checker.rb
+++ b/test/tool/lib/iseq_loader_checker.rb
@@ -76,6 +76,15 @@ def self.translate i1
     # return value
     i2_bin if CHECK_TO_BINARY
   end if CHECK_TO_A || CHECK_TO_BINARY
+
+  if opt == "prism"
+    # If RUBY_ISEQ_DUMP_DEBUG is "prism", we'll set up
+    # InstructionSequence.load_iseq to intercept loading filepaths to compile
+    # using prism.
+    def self.load_iseq(filepath)
+      RubyVM::InstructionSequence.compile_file_prism(filepath)
+    end
+  end
 end
 
 #require_relative 'x'; exit(1)
diff --git a/test/tool/lib/launchable.rb b/test/tool/lib/launchable.rb
new file mode 100644
index 00000000000..38f4fe92b3e
--- /dev/null
+++ b/test/tool/lib/launchable.rb
@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+require 'json'
+require 'uri'
+
+module Launchable
+  ##
+  # JsonStreamWriter writes a JSON file using a stream.
+  # By utilizing a stream, we can minimize memory usage, especially for large files.
+  class JsonStreamWriter
+    def initialize(path)
+      @file = File.open(path, "w")
+      @file.write("{")
+      @indent_level = 0
+      @is_first_key_val = true
+      @is_first_obj = true
+      write_new_line
+    end
+
+    def write_object obj
+      if @is_first_obj
+        @is_first_obj = false
+      else
+        write_comma
+        write_new_line
+      end
+      @indent_level += 1
+      @file.write(to_json_str(obj))
+      @indent_level -= 1
+      @is_first_key_val = true
+      # Occasionally, invalid JSON will be created as shown below, especially when `--repeat-count` is specified.
+      # {
+      #   "testPath": "file=test%2Ftest_timeout.rb&class=TestTimeout&testcase=test_allows_zero_seconds",
+      #   "status": "TEST_PASSED",
+      #   "duration": 2.7e-05,
+      #   "createdAt": "2024-02-09 12:21:07 +0000",
+      #   "stderr": null,
+      #   "stdout": null
+      # }: null <- here
+      # },
+      # To prevent this, IO#flush is called here.
+      @file.flush
+    end
+
+    def write_array(key)
+      @indent_level += 1
+      @file.write(to_json_str(key))
+      write_colon
+      @file.write(" ", "[")
+      write_new_line
+    end
+
+    def close
+      return if @file.closed?
+      close_array
+      @indent_level -= 1
+      write_new_line
+      @file.write("}", "\n")
+      @file.flush
+      @file.close
+    end
+
+    private
+    def to_json_str(obj)
+      json = JSON.pretty_generate(obj)
+      json.gsub(/^/, ' ' * (2 * @indent_level))
+    end
+
+    def write_indent
+      @file.write(" " * 2 * @indent_level)
+    end
+
+    def write_new_line
+      @file.write("\n")
+    end
+
+    def write_comma
+      @file.write(',')
+    end
+
+    def write_colon
+      @file.write(":")
+    end
+
+    def close_array
+      write_new_line
+      write_indent
+      @file.write("]")
+      @indent_level -= 1
+    end
+  end
+end
diff --git a/test/tool/lib/leakchecker.rb b/test/tool/lib/leakchecker.rb
index ed507969402..69df9a64b87 100644
--- a/test/tool/lib/leakchecker.rb
+++ b/test/tool/lib/leakchecker.rb
@@ -112,7 +112,7 @@ def check_fd_leak(test_name)
       }
       unless fd_leaked.empty?
         unless @@try_lsof == false
-          @@try_lsof |= system(*%W[lsof -a -d #{fd_leaked.minmax.uniq.join("-")} -p #$$], out: Test::Unit::Runner.output)
+          @@try_lsof |= system(*%W[lsof -w -a -d #{fd_leaked.minmax.uniq.join("-")} -p #$$], out: Test::Unit::Runner.output)
         end
       end
       h.each {|fd, list|
@@ -136,14 +136,14 @@ class << self
         attr_accessor :count
       end
 
-      def new(data)
+      def new(...)
         LeakChecker::TempfileCounter.count += 1
-        super(data)
+        super
       end
     }
     LeakChecker.const_set(:TempfileCounter, m)
 
-    class << Tempfile::Remover
+    class << Tempfile
       prepend LeakChecker::TempfileCounter
     end
   end
@@ -155,8 +155,8 @@ def find_tempfiles(prev_count=-1)
     if prev_count == count
       [prev_count, []]
     else
-      tempfiles = ObjectSpace.each_object(Tempfile).find_all {|t|
-        t.instance_variable_defined?(:@tmpfile) and t.path
+      tempfiles = ObjectSpace.each_object(Tempfile).reject {|t|
+        t.instance_variables.empty? || t.closed?
       }
       [count, tempfiles]
     end
@@ -182,7 +182,8 @@ def check_tempfile_leak(test_name)
 
   def find_threads
     Thread.list.find_all {|t|
-      t != Thread.current && t.alive?
+      t != Thread.current && t.alive? &&
+        !(t.thread_variable?(:"\0__detached_thread__") && t.thread_variable_get(:"\0__detached_thread__"))
     }
   end
 
@@ -232,7 +233,13 @@ def check_env(test_name)
     old_env = @env_info
     new_env = find_env
     return false if old_env == new_env
+    if defined?(Bundler::EnvironmentPreserver)
+      bundler_prefix = Bundler::EnvironmentPreserver::BUNDLER_PREFIX
+    end
     (old_env.keys | new_env.keys).sort.each {|k|
+      # Don't report changed environment variables caused by Bundler's backups
+      next if bundler_prefix and k.start_with?(bundler_prefix)
+
       if old_env.has_key?(k)
         if new_env.has_key?(k)
           if old_env[k] != new_env[k]
diff --git a/test/tool/lib/memory_status.rb b/test/tool/lib/memory_status.rb
index 5e9e80a68a6..429e5f6a1d3 100644
--- a/test/tool/lib/memory_status.rb
+++ b/test/tool/lib/memory_status.rb
@@ -12,7 +12,7 @@ module Memory
     PROC_FILE = procfile
     VM_PAT = pat
     def self.read_status
-      IO.foreach(PROC_FILE, encoding: Encoding::ASCII_8BIT) do |l|
+      File.foreach(PROC_FILE, encoding: Encoding::ASCII_8BIT) do |l|
         yield($1.downcase.intern, $2.to_i * 1024) if VM_PAT =~ l
       end
     end
@@ -20,48 +20,68 @@ def self.read_status
     data.scan(pat) {|k, v| keys << k.downcase.intern}
 
   when /mswin|mingw/ =~ RUBY_PLATFORM
-    require 'fiddle/import'
-    require 'fiddle/types'
-
-    module Win32
-      extend Fiddle::Importer
-      dlload "kernel32.dll", "psapi.dll"
-      include Fiddle::Win32Types
-      typealias "SIZE_T", "size_t"
-
-      PROCESS_MEMORY_COUNTERS = struct [
-        "DWORD  cb",
-        "DWORD  PageFaultCount",
-        "SIZE_T PeakWorkingSetSize",
-        "SIZE_T WorkingSetSize",
-        "SIZE_T QuotaPeakPagedPoolUsage",
-        "SIZE_T QuotaPagedPoolUsage",
-        "SIZE_T QuotaPeakNonPagedPoolUsage",
-        "SIZE_T QuotaNonPagedPoolUsage",
-        "SIZE_T PagefileUsage",
-        "SIZE_T PeakPagefileUsage",
-      ]
-
-      typealias "PPROCESS_MEMORY_COUNTERS", "PROCESS_MEMORY_COUNTERS*"
-
-      extern "HANDLE GetCurrentProcess()", :stdcall
-      extern "BOOL GetProcessMemoryInfo(HANDLE, PPROCESS_MEMORY_COUNTERS, DWORD)", :stdcall
-
-      module_function
-      def memory_info
-        size = PROCESS_MEMORY_COUNTERS.size
-        data = PROCESS_MEMORY_COUNTERS.malloc
-        data.cb = size
-        data if GetProcessMemoryInfo(GetCurrentProcess(), data, size)
+    keys.push(:size, :rss, :peak)
+
+    begin
+      require 'fiddle/import'
+      require 'fiddle/types'
+    rescue LoadError
+      # Fallback to PowerShell command to get memory information for current process
+      def self.read_status
+        cmd = [
+          "powershell.exe", "-NoProfile", "-Command",
+          "Get-Process -Id #{$$} | " \
+          "% { Write-Output $_.PagedMemorySize64 $_.WorkingSet64 $_.PeakWorkingSet64 }"
+        ]
+
+        IO.popen(cmd, "r", err: [:child, :out]) do |out|
+          if /^(\d+)\n(\d+)\n(\d+)$/ =~ out.read
+            yield :size, $1.to_i
+            yield :rss, $2.to_i
+            yield :peak, $3.to_i
+          end
+        end
+      end
+    else
+      module Win32
+        extend Fiddle::Importer
+        dlload "kernel32.dll", "psapi.dll"
+        include Fiddle::Win32Types
+        typealias "SIZE_T", "size_t"
+
+        PROCESS_MEMORY_COUNTERS = struct [
+          "DWORD  cb",
+          "DWORD  PageFaultCount",
+          "SIZE_T PeakWorkingSetSize",
+          "SIZE_T WorkingSetSize",
+          "SIZE_T QuotaPeakPagedPoolUsage",
+          "SIZE_T QuotaPagedPoolUsage",
+          "SIZE_T QuotaPeakNonPagedPoolUsage",
+          "SIZE_T QuotaNonPagedPoolUsage",
+          "SIZE_T PagefileUsage",
+          "SIZE_T PeakPagefileUsage",
+        ]
+
+        typealias "PPROCESS_MEMORY_COUNTERS", "PROCESS_MEMORY_COUNTERS*"
+
+        extern "HANDLE GetCurrentProcess()", :stdcall
+        extern "BOOL GetProcessMemoryInfo(HANDLE, PPROCESS_MEMORY_COUNTERS, DWORD)", :stdcall
+
+        module_function
+        def memory_info
+          size = PROCESS_MEMORY_COUNTERS.size
+          data = PROCESS_MEMORY_COUNTERS.malloc
+          data.cb = size
+          data if GetProcessMemoryInfo(GetCurrentProcess(), data, size)
+        end
       end
-    end
 
-    keys.push(:size, :rss, :peak)
-    def self.read_status
-      if info = Win32.memory_info
-        yield :size, info.PagefileUsage
-        yield :rss, info.WorkingSetSize
-        yield :peak, info.PeakWorkingSetSize
+      def self.read_status
+        if info = Win32.memory_info
+          yield :size, info.PagefileUsage
+          yield :rss, info.WorkingSetSize
+          yield :peak, info.PeakWorkingSetSize
+        end
       end
     end
   when (require_relative 'find_executable'
diff --git a/test/tool/lib/output.rb b/test/tool/lib/output.rb
new file mode 100644
index 00000000000..8cb426ae4af
--- /dev/null
+++ b/test/tool/lib/output.rb
@@ -0,0 +1,70 @@
+require_relative 'vpath'
+require_relative 'colorize'
+
+class Output
+  attr_reader :path, :vpath
+
+  def initialize(path: nil, timestamp: nil, ifchange: nil, color: nil,
+                 overwrite: false, create_only: false, vpath: VPath.new)
+    @path = path
+    @timestamp = timestamp
+    @ifchange = ifchange
+    @color = color
+    @overwrite = overwrite
+    @create_only = create_only
+    @vpath = vpath
+  end
+
+  COLOR_WHEN = {
+    'always' => true, 'auto' => nil, 'never' => false,
+    nil => true, false => false,
+  }
+
+  def def_options(opt)
+    opt.separator("  Output common options:")
+    opt.on('-o', '--output=PATH') {|v| @path = v}
+    opt.on('-t', '--timestamp[=PATH]') {|v| @timestamp = v || true}
+    opt.on('-c', '--[no-]if-change') {|v| @ifchange = v}
+    opt.on('--[no-]color=[WHEN]', COLOR_WHEN.keys) {|v| @color = COLOR_WHEN[v]}
+    opt.on('--[no-]create-only') {|v| @create_only = v}
+    opt.on('--[no-]overwrite') {|v| @overwrite = v}
+    @vpath.def_options(opt)
+  end
+
+  def write(data, overwrite: @overwrite, create_only: @create_only)
+    unless @path
+      $stdout.print data
+      return true
+    end
+    color = Colorize.new(@color)
+    unchanged = color.pass("unchanged")
+    updated = color.fail("updated")
+    outpath = nil
+
+    if (@ifchange or overwrite or create_only) and (@vpath.open(@path, "rb") {|f|
+      outpath = f.path
+      if @ifchange or create_only
+        original = f.read
+        (@ifchange and original == data) or (create_only and !original.empty?)
+      end
+    } rescue false)
+      puts "#{outpath} #{unchanged}"
+      written = false
+    else
+      unless overwrite and outpath and (File.binwrite(outpath, data) rescue nil)
+        File.binwrite(outpath = @path, data)
+      end
+      puts "#{outpath} #{updated}"
+      written = true
+    end
+    if timestamp = @timestamp
+      if timestamp == true
+        dir, base = File.split(@path)
+        timestamp = File.join(dir, ".time." + base)
+      end
+      File.binwrite(timestamp, '')
+      File.utime(nil, nil, timestamp)
+    end
+    written
+  end
+end
diff --git a/test/tool/lib/path.rb b/test/tool/lib/path.rb
new file mode 100644
index 00000000000..f16a164338d
--- /dev/null
+++ b/test/tool/lib/path.rb
@@ -0,0 +1,101 @@
+module Path
+  module_function
+
+  def clean(path)
+    path = "#{path}/".gsub(/(\A|\/)(?:\.\/)+/, '\1').tr_s('/', '/')
+    nil while path.sub!(/[^\/]+\/\.\.\//, '')
+    path
+  end
+
+  def relative(path, base)
+    path = clean(path)
+    base = clean(base)
+    path, base = [path, base].map{|s|s.split("/")}
+    until path.empty? or base.empty? or path[0] != base[0]
+      path.shift
+      base.shift
+    end
+    path, base = [path, base].map{|s|s.join("/")}
+    if base.empty?
+      path
+    elsif base.start_with?("../") or File.absolute_path?(base)
+      File.expand_path(path)
+    else
+      base.gsub!(/[^\/]+/, '..')
+      File.join(base, path)
+    end
+  end
+
+  def clean_link(src, dest)
+    begin
+      link = File.readlink(dest)
+    rescue
+    else
+      return if link == src
+      File.unlink(dest)
+    end
+    yield src, dest
+  end
+
+  # Extensions to FileUtils
+
+  module Mswin
+    def ln_safe(src, dest, real_src, *opt)
+      cmd = ["mklink", dest.tr("/", "\\"), src.tr("/", "\\")]
+      cmd[1, 0] = opt
+      return if system("cmd", "/c", *cmd)
+      # TODO: use RUNAS or something
+      puts cmd.join(" ")
+    end
+
+    def ln_dir_safe(src, dest, real_src)
+      ln_safe(src, dest, "/d")
+    end
+  end
+
+  module HardlinkExcutable
+    def ln_exe(relative_src, dest, src)
+      ln(src, dest, force: true)
+    end
+  end
+
+  def ln_safe(src, dest, real_src)
+    ln_sf(src, dest)
+  rescue Errno::ENOENT
+    # Windows disallows to create broken symboic links, probably because
+    # it is a kind of reparse points.
+    raise if File.exist?(real_src)
+  end
+
+  alias ln_dir_safe ln_safe
+  alias ln_exe ln_safe
+
+  def ln_relative(src, dest, executable = false)
+    return if File.identical?(src, dest)
+    parent = File.dirname(dest)
+    File.directory?(parent) or mkdir_p(parent)
+    if executable
+      return (ln_exe(relative(src, parent), dest, src) if File.exist?(src))
+    end
+    clean_link(relative(src, parent), dest) {|s, d| ln_safe(s, d, src)}
+  end
+
+  def ln_dir_relative(src, dest)
+    return if File.identical?(src, dest)
+    parent = File.dirname(dest)
+    File.directory?(parent) or mkdir_p(parent)
+    clean_link(relative(src, parent), dest) {|s, d| ln_dir_safe(s, d, src)}
+  end
+
+  case (CROSS_COMPILING || RUBY_PLATFORM)
+  when /linux|darwin|solaris/
+    prepend HardlinkExcutable
+    extend HardlinkExcutable
+  when /mingw|mswin/
+    unless File.respond_to?(:symlink)
+      prepend Mswin
+      extend Mswin
+    end
+  else
+  end
+end
diff --git a/test/tool/lib/test/jobserver.rb b/test/tool/lib/test/jobserver.rb
new file mode 100644
index 00000000000..7b889163b02
--- /dev/null
+++ b/test/tool/lib/test/jobserver.rb
@@ -0,0 +1,47 @@
+module Test
+  module JobServer
+  end
+end
+
+class << Test::JobServer
+  def connect(makeflags = ENV["MAKEFLAGS"])
+    return unless /(?:\A|\s)--jobserver-(?:auth|fds)=(?:(\d+),(\d+)|fifo:((?:\\.|\S)+))/ =~ makeflags
+    begin
+      if fifo = $3
+        fifo.gsub!(/\\(?=.)/, '')
+        r = File.open(fifo, IO::RDONLY|IO::NONBLOCK|IO::BINARY)
+        w = File.open(fifo, IO::WRONLY|IO::NONBLOCK|IO::BINARY)
+      else
+        r = IO.for_fd($1.to_i(10), "rb", autoclose: false)
+        w = IO.for_fd($2.to_i(10), "wb", autoclose: false)
+      end
+    rescue
+      r&.close
+      nil
+    else
+      return r, w
+    end
+  end
+
+  def acquire_possible(r, w, max)
+    return unless tokens = r.read_nonblock(max - 1, exception: false)
+    if (jobs = tokens.size) > 0
+      jobserver, w = w, nil
+      at_exit do
+        jobserver.print(tokens)
+        jobserver.close
+      end
+    end
+    return jobs + 1
+  rescue Errno::EBADF
+  ensure
+    r&.close
+    w&.close
+  end
+
+  def max_jobs(max = 2, makeflags = ENV["MAKEFLAGS"])
+    if max > 1 and (r, w = connect(makeflags))
+      acquire_possible(r, w, max)
+    end
+  end
+end
diff --git a/test/tool/lib/test/unit.rb b/test/tool/lib/test/unit.rb
index 54e1c601ce9..4ee5b66a7d7 100644
--- a/test/tool/lib/test/unit.rb
+++ b/test/tool/lib/test/unit.rb
@@ -1,50 +1,30 @@
 # frozen_string_literal: true
 
+# Enable deprecation warnings for test-all, so deprecated methods/constants/functions are dealt with early.
+Warning[:deprecated] = true
+
+if ENV['BACKTRACE_FOR_DEPRECATION_WARNINGS']
+  Warning.extend Module.new {
+    def warn(message, category: nil, **kwargs)
+      if category == :deprecated and $stderr.respond_to?(:puts)
+        $stderr.puts nil, message, caller, nil
+      else
+        super
+      end
+    end
+  }
+end
+
 require_relative '../envutil'
 require_relative '../colorize'
 require_relative '../leakchecker' if RUBY_ENGINE == 'ruby'
 require_relative '../test/unit/testcase'
+require_relative '../test/jobserver'
 require 'optparse'
 
 # See Test::Unit
 module Test
 
-  class << self
-    ##
-    # Filter object for backtraces.
-
-    attr_accessor :backtrace_filter
-  end
-
-  class BacktraceFilter # :nodoc:
-    def filter bt
-      return ["No backtrace"] unless bt
-
-      new_bt = []
-      pattern = %r[/(?:lib\/test/|core_assertions\.rb:)]
-
-      unless $DEBUG then
-        bt.each do |line|
-          break if pattern.match?(line)
-          new_bt << line
-        end
-
-        new_bt = bt.reject { |line| pattern.match?(line) } if new_bt.empty?
-        new_bt = bt.dup if new_bt.empty?
-      else
-        new_bt = bt.dup
-      end
-
-      new_bt
-    end
-  end
-
-  self.backtrace_filter = BacktraceFilter.new
-
-  def self.filter_backtrace bt # :nodoc:
-    backtrace_filter.filter bt
-  end
-
   ##
   # Test::Unit is an implementation of the xUnit testing framework for Ruby.
   module Unit
@@ -58,6 +38,26 @@ class AssertionFailedError < Exception; end
 
     class PendedError < AssertionFailedError; end
 
+    class << self
+      ##
+      # Extract the location where the last assertion method was
+      # called.  Returns "<empty>" if _e_ does not have backtrace, or
+      # an empty string if no assertion method location was found.
+
+      def location e
+        last_before_assertion = nil
+
+        return '<empty>' unless e&.backtrace # SystemStackError can return nil.
+
+        e.backtrace.reverse_each do |s|
+          break if s =~ /:in \W(?:.*\#)?(?:assert|refute|flunk|pass|fail|raise|must|wont)/
+          last_before_assertion = s
+        end
+        return "" unless last_before_assertion
+        /:in / =~ last_before_assertion ? $` : last_before_assertion
+      end
+    end
+
     module Order
       class NoSort
         def initialize(seed)
@@ -74,17 +74,7 @@ def group(list)
         end
       end
 
-      module JITFirst
-        def group(list)
-          # JIT first
-          jit, others = list.partition {|e| /test_jit/ =~ e}
-          jit + others
-        end
-      end
-
       class Alpha < NoSort
-        include JITFirst
-
         def sort_by_name(list)
           list.sort_by(&:name)
         end
@@ -97,8 +87,6 @@ def sort_by_string(list)
 
       # shuffle test suites based on CRC32 of their names
       Shuffle = Struct.new(:seed, :salt) do
-        include JITFirst
-
         def initialize(seed)
           self.class::CRC_TBL ||= (0..255).map {|i|
             (0..7).inject(i) {|c,| (c & 1 == 1) ? (0xEDB88320 ^ (c >> 1)) : (c >> 1) }
@@ -116,6 +104,10 @@ def sort_by_string(list)
           list.sort_by {|e| randomize_key(e)}
         end
 
+        def group(list)
+          list
+        end
+
         private
 
         def crc32(str, crc32 = 0xffffffff)
@@ -199,6 +191,7 @@ def process_args(args = [])
         @help = "\n" + orig_args.map { |s|
           "  " + (s =~ /[\s|&<>$()]/ ? s.inspect : s)
         }.join("\n")
+
         @options = options
       end
 
@@ -257,6 +250,8 @@ def non_options(files, options)
     end
 
     module Parallel # :nodoc: all
+      attr_accessor :prefix
+
       def process_args(args = [])
         return @options if @options
         options = super
@@ -268,23 +263,10 @@ def process_args(args = [])
 
       def non_options(files, options)
         @jobserver = nil
-        makeflags = ENV.delete("MAKEFLAGS")
-        if !options[:parallel] and
-          /(?:\A|\s)--jobserver-(?:auth|fds)=(\d+),(\d+)/ =~ makeflags
-          begin
-            r = IO.for_fd($1.to_i(10), "rb", autoclose: false)
-            w = IO.for_fd($2.to_i(10), "wb", autoclose: false)
-          rescue
-            r.close if r
-            nil
-          else
-            r.close_on_exec = true
-            w.close_on_exec = true
-            @jobserver = [r, w]
-            options[:parallel] ||= 1
-          end
+        if !options[:parallel] and @jobserver = Test::JobServer.connect(ENV.delete("MAKEFLAGS"))
+          options[:parallel] ||= 256 # number of tokens to acquire first
         end
-        @worker_timeout = EnvUtil.apply_timeout_scale(options[:worker_timeout] || 180)
+        @worker_timeout = EnvUtil.apply_timeout_scale(options[:worker_timeout] || 1200)
         super
       end
 
@@ -300,7 +282,7 @@ def setup_options(opts, options)
 
         opts.separator "parallel test options:"
 
-        options[:retry] = true
+        options[:retry] = false
 
         opts.on '-j N', '--jobs N', /\A(t)?(\d+)\z/, "Allow run tests with N jobs at once" do |_, t, a|
           options[:testing] = true & t # For testing
@@ -324,7 +306,8 @@ def setup_options(opts, options)
           options[:retry] = false
         end
 
-        opts.on '--ruby VAL', "Path to ruby which is used at -j option" do |a|
+        opts.on '--ruby VAL', "Path to ruby which is used at -j option",
+                "Also used as EnvUtil.rubybin by some assertion methods" do |a|
           options[:ruby] = a.split(/ /).reject(&:empty?)
         end
 
@@ -371,8 +354,12 @@ def puts(*args)
           @io.puts(*args)
         end
 
-        def run(task,type)
-          @file = File.basename(task, ".rb")
+        def run(task, type, base = nil)
+          if base
+            @file = task.delete_prefix(base).chomp(".rb")
+          else
+            @file = File.basename(task, ".rb")
+          end
           @real_file = task
           begin
             puts "loadpath #{[Marshal.dump($:-@loadpath)].pack("m0")}"
@@ -407,16 +394,19 @@ def close
         rescue IOError
         end
 
-        def quit
+        def quit(reason = :normal)
           return if @io.closed?
           @quit_called = true
-          @io.puts "quit"
+          @io.puts "quit #{reason}"
         rescue Errno::EPIPE => e
           warn "#{@pid}:#{@status.to_s.ljust(7)}:#{@file}: #{e.message}"
         end
 
         def kill
-          Process.kill(:KILL, @pid)
+          EnvUtil::Debugger.search&.dump(@pid)
+          signal = RUBY_PLATFORM =~ /mswin|mingw/ ? :KILL : :SEGV
+          Process.kill(signal, @pid)
+          warn "worker #{to_s} does not respond; #{signal} is sent"
         rescue Errno::ESRCH
         end
 
@@ -470,8 +460,8 @@ def after_worker_down(worker, e=nil, c=false)
         real_file = worker.real_file and warn "running file: #{real_file}"
         @need_quit = true
         warn ""
-        warn "Some worker was crashed. It seems ruby interpreter's bug"
-        warn "or, a bug of test/unit/parallel.rb. try again without -j"
+        warn "A test worker crashed. It might be an interpreter bug or"
+        warn "a bug in test/unit/parallel.rb. Try again without the -j"
         warn "option."
         warn ""
         if File.exist?('core')
@@ -534,15 +524,15 @@ def quit_workers(&cond)
         @workers.reject! do |worker|
           next unless cond&.call(worker)
           begin
-            Timeout.timeout(1) do
-              worker.quit
+            Timeout.timeout(5) do
+              worker.quit(cond ? :timeout : :normal)
             end
           rescue Errno::EPIPE
           rescue Timeout::Error
           end
           closed&.push worker
           begin
-            Timeout.timeout(0.2) do
+            Timeout.timeout(1) do
               worker.close
             end
           rescue Timeout::Error
@@ -555,7 +545,7 @@ def quit_workers(&cond)
         return if (closed ||= @workers).empty?
         pids = closed.map(&:pid)
         begin
-          Timeout.timeout(0.2 * closed.size) do
+          Timeout.timeout(1 * closed.size) do
             Process.waitall
           end
         rescue Timeout::Error
@@ -596,7 +586,7 @@ def deal(io, type, result, rep, shutting_down = false)
             worker.quit
             worker = launch_worker
           end
-          worker.run(task, type)
+          worker.run(task, type, (@prefix unless @options[:job_status] == :replace))
           @test_count += 1
 
           jobs_status(worker)
@@ -674,14 +664,22 @@ def _run_parallel suites, type, result
         @ios          = [] # Array of worker IOs
         @job_tokens   = String.new(encoding: Encoding::ASCII_8BIT) if @jobserver
         begin
-          [@tasks.size, @options[:parallel]].min.times {launch_worker}
-
           while true
-            timeout = [(@workers.filter_map {|w| w.response_at}.min&.-(Time.now) || 0) + @worker_timeout, 1].max
+            newjobs = [@tasks.size, @options[:parallel]].min - @workers.size
+            if newjobs > 0
+              if @jobserver
+                t = @jobserver[0].read_nonblock(newjobs, exception: false)
+                @job_tokens << t if String === t
+                newjobs = @job_tokens.size + 1 - @workers.size
+              end
+              newjobs.times {launch_worker}
+            end
+
+            timeout = [(@workers.filter_map {|w| w.response_at}.min&.-(Time.now) || 0), 0].max + @worker_timeout
 
             if !(_io = IO.select(@ios, nil, nil, timeout))
               timeout = Time.now - @worker_timeout
-              quit_workers {|w| w.response_at < timeout}&.map {|w|
+              quit_workers {|w| w.response_at&.<(timeout) }&.map {|w|
                 rep << {file: w.real_file, result: nil, testcase: w.current[0], error: w.current}
               }
             elsif _io.first.any? {|io|
@@ -691,15 +689,9 @@ def _run_parallel suites, type, result
             }
               break
             end
-            break if @tasks.empty? and @workers.empty?
-            if @jobserver and @job_tokens and !@tasks.empty? and
-               ((newjobs = [@tasks.size, @options[:parallel]].min) > @workers.size or
-                !@workers.any? {|x| x.status == :ready})
-              t = @jobserver[0].read_nonblock(newjobs, exception: false)
-              if String === t
-                @job_tokens << t
-                t.size.times {launch_worker}
-              end
+            if @tasks.empty?
+              break if @workers.empty?
+              next # wait for all workers to finish
             end
           end
         rescue Interrupt => ex
@@ -707,7 +699,7 @@ def _run_parallel suites, type, result
           return result
         ensure
           if file = @options[:timetable_data]
-            open(file, 'w'){|f|
+            File.open(file, 'w'){|f|
               @records.each{|(worker, suite), (st, ed)|
                 f.puts '[' + [worker.dump, suite.dump, st.to_f * 1_000, ed.to_f * 1_000].join(", ") + '],'
               }
@@ -735,14 +727,34 @@ def _run_parallel suites, type, result
             del_status_line or puts
             error, suites = suites.partition {|r| r[:error]}
             unless suites.empty?
-              puts "\n""Retrying..."
+              puts "\n"
+              @failed_output.puts "Failed tests:"
+              suites.each {|r|
+                r[:report].each {|c, m, e|
+                  @failed_output.puts "#{c}##{m}: #{e&.class}: #{e&.message&.slice(/\A.*/)}"
+                }
+              }
+              @failed_output.puts "\n"
+              puts "Retrying..."
               @verbose = options[:verbose]
               suites.map! {|r| ::Object.const_get(r[:testcase])}
               _run_suites(suites, type)
             end
             unless error.empty?
               puts "\n""Retrying hung up testcases..."
-              error.map! {|r| ::Object.const_get(r[:testcase])}
+              error = error.map do |r|
+                begin
+                  ::Object.const_get(r[:testcase])
+                rescue NameError
+                  # testcase doesn't specify the correct case, so show `r` for information
+                  require 'pp'
+
+                  $stderr.puts "Retrying is failed because the file and testcase is not consistent:"
+                  PP.pp r, $stderr
+                  @errors += 1
+                  nil
+                end
+              end.compact
               verbose = @verbose
               job_status = options[:job_status]
               options[:verbose] = @verbose = true
@@ -759,7 +771,7 @@ def _run_parallel suites, type, result
           unless rep.empty?
             rep.each do |r|
               if r[:error]
-                puke(*r[:error], Timeout::Error)
+                puke(*r[:error], Timeout::Error.new)
                 next
               end
               r[:report]&.each do |f|
@@ -779,6 +791,7 @@ def _run_parallel suites, type, result
             warn ""
             @warnings.uniq! {|w| w[1].message}
             @warnings.each do |w|
+              @errors += 1
               warn "#{w[0]}: #{w[1].message} (#{w[1].class})"
             end
             warn ""
@@ -848,7 +861,7 @@ def update_list(list, rec, max)
         end
       end
 
-      def record(suite, method, assertions, time, error)
+      def record(suite, method, assertions, time, error, source_location = nil)
         if @options.values_at(:longest, :most_asserted).any?
           @tops ||= {}
           rec = [suite.name, method, assertions, time, error]
@@ -946,7 +959,7 @@ def output
       end
 
       def _prepare_run(suites, type)
-        options[:job_status] ||= :replace if @tty && !@verbose
+        options[:job_status] ||= @tty ? :replace : :normal unless @verbose
         case options[:color]
         when :always
           color = true
@@ -962,11 +975,14 @@ def _prepare_run(suites, type)
         @output = Output.new(self) unless @options[:testing]
         filter = options[:filter]
         type = "#{type}_methods"
-        total = if filter
-                  suites.inject(0) {|n, suite| n + suite.send(type).grep(filter).size}
-                else
-                  suites.inject(0) {|n, suite| n + suite.send(type).size}
-                end
+        total = suites.sum {|suite|
+          methods = suite.send(type)
+          if filter
+            methods.count {|method| filter === "#{suite}##{method}"}
+          else
+            methods.size
+          end
+        }
         @test_count = 0
         @total_tests = total.to_s(10)
       end
@@ -1004,7 +1020,7 @@ def failed(s)
           end
           first, msg = msg.split(/$/, 2)
           first = sprintf("%3d) %s", @report_count += 1, first)
-          $stdout.print(sep, @colorize.decorate(first, color), msg, "\n")
+          @failed_output.print(sep, @colorize.decorate(first, color), msg, "\n")
           sep = nil
         end
         report.clear
@@ -1060,7 +1076,7 @@ def print(s)
             runner.add_status(" = #$1")
           when /\A\.+\z/
             runner.succeed
-          when /\A\.*[EFS][EFS.]*\z/
+          when /\A\.*[EFST][EFST.]*\z/
             runner.failed(s)
           else
             $stdout.print(s)
@@ -1165,6 +1181,28 @@ def non_options(files, options)
       end
     end
 
+    module OutputOption # :nodoc: all
+      def setup_options(parser, options)
+        super
+        parser.separator "output options:"
+
+        options[:failed_output] = $stdout
+        parser.on '--stderr-on-failure', 'Use stderr to print failure messages' do
+          options[:failed_output] = $stderr
+        end
+        parser.on '--stdout-on-failure', 'Use stdout to print failure messages', '(default)' do
+          options[:failed_output] = $stdout
+        end
+      end
+
+      def process_args(args = [])
+        return @options if @options
+        options = super
+        @failed_output = options[:failed_output]
+        options
+      end
+    end
+
     module GCOption # :nodoc: all
       def setup_options(parser, options)
         super
@@ -1226,8 +1264,13 @@ def non_options(files, options)
             puts "#{f}: #{$!}"
           end
         }
+        @load_failed = errors.size.nonzero?
         result
       end
+
+      def run(*)
+        super or @load_failed
+      end
     end
 
     module RepeatOption # :nodoc: all
@@ -1238,10 +1281,15 @@ def setup_options(parser, options)
         parser.on '--repeat-count=NUM', "Number of times to repeat", Integer do |n|
           options[:repeat_count] = n
         end
+        options[:keep_repeating] = false
+        parser.on '--[no-]keep-repeating', "Keep repeating even failed" do |n|
+          options[:keep_repeating] = true
+        end
       end
 
       def _run_anything(type)
         @repeat_count = @options[:repeat_count]
+        @keep_repeating = @options[:keep_repeating]
         super
       end
     end
@@ -1329,6 +1377,95 @@ def non_options(files, options)
       end
     end
 
+    module LaunchableOption
+      module Nothing
+        private
+        def setup_options(opts, options)
+          super
+          opts.define_tail 'Launchable options:'
+          # This is expected to be called by Test::Unit::Worker.
+          opts.on_tail '--launchable-test-reports=PATH', String, 'Do nothing'
+        end
+      end
+
+      def record(suite, method, assertions, time, error, source_location = nil)
+        if writer = @options[:launchable_test_reports]
+          if loc = (source_location || suite.instance_method(method).source_location)
+            path, lineno = loc
+            # Launchable JSON schema is defined at
+            # https://github.com/search?q=repo%3Alaunchableinc%2Fcli+https%3A%2F%2Flaunchableinc.com%2Fschema%2FRecordTestInput&type=code.
+            e = case error
+                when nil
+                  status = 'TEST_PASSED'
+                  nil
+                when Test::Unit::PendedError
+                  status = 'TEST_SKIPPED'
+                  "Skipped:\n#{suite.name}##{method} [#{location error}]:\n#{error.message}\n"
+                when Test::Unit::AssertionFailedError
+                  status = 'TEST_FAILED'
+                  "Failure:\n#{suite.name}##{method} [#{location error}]:\n#{error.message}\n"
+                when Timeout::Error
+                  status = 'TEST_FAILED'
+                  "Timeout:\n#{suite.name}##{method}\n"
+                else
+                  status = 'TEST_FAILED'
+                  bt = Test::filter_backtrace(error.backtrace).join "\n    "
+                  "Error:\n#{suite.name}##{method}:\n#{error.class}: #{error.message.b}\n    #{bt}\n"
+                end
+            repo_path = File.expand_path("#{__dir__}/../../../")
+            relative_path = path.delete_prefix("#{repo_path}/")
+            # The test path is a URL-encoded representation.
+            # https://github.com/launchableinc/cli/blob/v1.81.0/launchable/testpath.py#L18
+            test_path = {file: relative_path, class: suite.name, testcase: method}.map{|key, val|
+              "#{encode_test_path_component(key)}=#{encode_test_path_component(val)}"
+            }.join('#')
+          end
+        end
+        super
+      ensure
+        if writer && test_path && status
+          # Occasionally, the file writing operation may be paused, especially when `--repeat-count` is specified.
+          # In such cases, we proceed to execute the operation here.
+          writer.write_object(
+            {
+              testPath: test_path,
+              status: status,
+              duration: time,
+              createdAt: Time.now.to_s,
+              stderr: e,
+              stdout: nil,
+              data: {
+                lineNumber: lineno
+              }
+            }
+          )
+        end
+      end
+
+      private
+      def setup_options(opts, options)
+        super
+        opts.on_tail '--launchable-test-reports=PATH', String, 'Report test results in Launchable JSON format' do |path|
+          require_relative '../launchable'
+          options[:launchable_test_reports] = writer = Launchable::JsonStreamWriter.new(path)
+          writer.write_array('testCases')
+          main_pid = Process.pid
+          at_exit {
+            # This block is executed when the fork block in a test is completed.
+            # Therefore, we need to verify whether all tests have been completed.
+            stack = caller
+            if stack.size == 0 && main_pid == Process.pid && $!.is_a?(SystemExit)
+              writer.close
+            end
+          }
+        end
+
+        def encode_test_path_component component
+          component.to_s.gsub('%', '%25').gsub('=', '%3D').gsub('#', '%23').gsub('&', '%26')
+        end
+      end
+    end
+
     class Runner # :nodoc: all
 
       attr_accessor :report, :failures, :errors, :skips # :nodoc:
@@ -1474,7 +1611,7 @@ def _run_anything type
               [(@repeat_count ? "(#{@@current_repeat_count}/#{@repeat_count}) " : ""), type,
                 t, @test_count.fdiv(t), @assertion_count.fdiv(t)]
         end while @repeat_count && @@current_repeat_count < @repeat_count &&
-                  report.empty? && failures.zero? && errors.zero?
+                  (@keep_repeating || report.empty? && failures.zero? && errors.zero?)
 
         output.sync = old_sync if sync
 
@@ -1518,7 +1655,7 @@ def _run_suite suite, type
           _start_method(inst)
           inst._assertions = 0
 
-          print "#{suite}##{method} = " if @verbose
+          print "#{suite}##{method.inspect.sub(/\A:/, '')} = " if @verbose
 
           start_time = Time.now if @verbose
           result =
@@ -1533,9 +1670,7 @@ def _run_suite suite, type
           puts if @verbose
           $stdout.flush
 
-          unless defined?(RubyVM::MJIT) && RubyVM::MJIT.enabled? # compiler process is wrongly considered as leak
-            leakchecker.check("#{inst.class}\##{inst.__name__}") if RUBY_ENGINE == 'ruby'
-          end
+          leakchecker.check("#{inst.class}\##{inst.__name__}") if RUBY_ENGINE == 'ruby'
 
           _end_method(inst)
 
@@ -1566,19 +1701,11 @@ def _end_method(inst)
       # failure or error in teardown, it will be sent again with the
       # error or failure.
 
-      def record suite, method, assertions, time, error
+      def record suite, method, assertions, time, error, source_location = nil
       end
 
       def location e # :nodoc:
-        last_before_assertion = ""
-
-        return '<empty>' unless e.backtrace # SystemStackError can return nil.
-
-        e.backtrace.reverse_each do |s|
-          break if s =~ /in .(assert|refute|flunk|pass|fail|raise|must|wont)/
-          last_before_assertion = s
-        end
-        last_before_assertion.sub(/:in .*$/, '')
+        Test::Unit.location e
       end
 
       ##
@@ -1624,7 +1751,7 @@ def _run args = []
           break unless report.empty?
         end
 
-        return failures + errors if self.test_count > 0 # or return nil...
+        return (failures + errors).nonzero? # or return nil...
       rescue Interrupt
         abort 'Interrupted'
       end
@@ -1650,12 +1777,14 @@ def status io = self.output
       prepend Test::Unit::Statistics
       prepend Test::Unit::Skipping
       prepend Test::Unit::GlobOption
+      prepend Test::Unit::OutputOption
       prepend Test::Unit::RepeatOption
       prepend Test::Unit::LoadPathOption
       prepend Test::Unit::GCOption
       prepend Test::Unit::ExcludesOption
       prepend Test::Unit::TimeoutOption
       prepend Test::Unit::RunCount
+      prepend Test::Unit::LaunchableOption::Nothing
 
       ##
       # Begins the full test run. Delegates to +runner+'s #_run method.
@@ -1691,6 +1820,9 @@ def puke klass, meth, e
             when Test::Unit::AssertionFailedError then
               @failures += 1
               "Failure:\n#{klass}##{meth} [#{location e}]:\n#{e.message}\n"
+            when Timeout::Error
+              @errors += 1
+              "Timeout:\n#{klass}##{meth}\n"
             else
               @errors += 1
               bt = Test::filter_backtrace(e.backtrace).join "\n    "
@@ -1709,6 +1841,7 @@ def puke klass, meth, e
     class AutoRunner # :nodoc: all
       class Runner < Test::Unit::Runner
         include Test::Unit::RequireFiles
+        include Test::Unit::LaunchableOption
       end
 
       attr_accessor :to_run, :options
@@ -1717,6 +1850,7 @@ def initialize(force_standalone = false, default_dir = nil, argv = ARGV)
         @force_standalone = force_standalone
         @runner = Runner.new do |files, options|
           base = options[:base_directory] ||= default_dir
+          @runner.prefix = base ? (base + "/") : nil
           files << default_dir if files.empty? and default_dir
           @to_run = files
           yield self if block_given?
diff --git a/test/tool/lib/test/unit/assertions.rb b/test/tool/lib/test/unit/assertions.rb
index fe3351107ec..19581fc3ab3 100644
--- a/test/tool/lib/test/unit/assertions.rb
+++ b/test/tool/lib/test/unit/assertions.rb
@@ -798,33 +798,37 @@ def assert_no_warning(pat, msg = nil)
       MIN_MEASURABLE = 1.0 / MIN_HZ
 
       def assert_cpu_usage_low(msg = nil, pct: 0.05, wait: 1.0, stop: nil)
-        require 'benchmark'
-
         wait = EnvUtil.apply_timeout_scale(wait)
         if wait < 0.1 # TIME_QUANTUM_USEC in thread_pthread.c
           warn "test #{msg || 'assert_cpu_usage_low'} too short to be accurate"
         end
-        tms = Benchmark.measure(msg || '') do
-          if stop
-            th = Thread.start {sleep wait; stop.call}
-            yield
-            th.join
-          else
-            begin
-              Timeout.timeout(wait) {yield}
-            rescue Timeout::Error
-            end
+
+        t0, r0 = Process.times, Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+        if stop
+          th = Thread.start {sleep wait; stop.call}
+          yield
+          th.join
+        else
+          begin
+            Timeout.timeout(wait) {yield}
+          rescue Timeout::Error
           end
         end
 
-        max = pct * tms.real
+        t1, r1 = Process.times, Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+        total = t1.utime - t0.utime + t1.stime - t0.stime + t1.cutime - t0.cutime + t1.cstime - t0.cstime
+        real = r1 - r0
+
+        max = pct * real
         min_measurable = MIN_MEASURABLE
         min_measurable *= 1.30 # add a little (30%) to account for misc. overheads
         if max < min_measurable
           max = min_measurable
         end
 
-        assert_operator tms.total, :<=, max, msg
+        assert_operator total, :<=, max, msg
       end
 
       def assert_is_minus_zero(f)
diff --git a/test/tool/lib/test/unit/parallel.rb b/test/tool/lib/test/unit/parallel.rb
index b3a8957f26e..188a0d1a191 100644
--- a/test/tool/lib/test/unit/parallel.rb
+++ b/test/tool/lib/test/unit/parallel.rb
@@ -1,12 +1,6 @@
 # frozen_string_literal: true
-$LOAD_PATH.unshift "#{__dir__}/../.."
-require_relative '../../test/unit'
 
-require_relative '../../profile_test_all' if ENV.key?('RUBY_TEST_ALL_PROFILE')
-require_relative '../../tracepointchecker'
-require_relative '../../zombie_hunter'
-require_relative '../../iseq_loader_checker'
-require_relative '../../gc_checker'
+require_relative "../../../test/init"
 
 module Test
   module Unit
@@ -133,7 +127,18 @@ def run(args = []) # :nodoc:
               else
                 _report "ready"
               end
-            when /^quit$/
+            when /^quit (.+?)$/, "quit"
+              if $1 == "timeout"
+                err = ["", "!!! worker #{$$} killed due to timeout:"]
+                Thread.list.each do |th|
+                  err << "#{ th.inspect }:"
+                  th.backtrace.each do |s|
+                    err << "  #{ s }"
+                  end
+                end
+                err << ""
+                STDERR.puts err.join("\n")
+              end
               _report "bye"
               exit
             end
@@ -186,7 +191,7 @@ def record(suite, method, assertions, time, error) # :nodoc:
         else
           error = ProxyError.new(error)
         end
-        _report "record", Marshal.dump([suite.name, method, assertions, time, error])
+        _report "record", Marshal.dump([suite.name, method, assertions, time, error, suite.instance_method(method).source_location])
         super
       end
     end
@@ -208,5 +213,9 @@ def self.on_parallel_worker?
     end
   end
   require 'rubygems'
+  begin
+    require 'rake'
+  rescue LoadError
+  end
   Test::Unit::Worker.new.run(ARGV)
 end
diff --git a/test/tool/lib/test/unit/testcase.rb b/test/tool/lib/test/unit/testcase.rb
index 44d9ba7fdbf..51ffff37ebc 100644
--- a/test/tool/lib/test/unit/testcase.rb
+++ b/test/tool/lib/test/unit/testcase.rb
@@ -137,6 +137,9 @@ class TestCase
 
       attr_reader :__name__ # :nodoc:
 
+      # Method name of this test.
+      alias method_name __name__
+
       PASSTHROUGH_EXCEPTIONS = [NoMemoryError, SignalException,
                                 Interrupt, SystemExit] # :nodoc:
 
@@ -144,8 +147,7 @@ class TestCase
       # Runs the tests reporting the status to +runner+
 
       def run runner
-        @options = runner.options
-
+        @__runner_options__ = runner.options
         trap "INFO" do
           runner.report.each_with_index do |msg, i|
             warn "\n%3d) %s" % [i + 1, msg]
@@ -161,7 +163,7 @@ def run runner
         result = ""
 
         begin
-          @passed = nil
+          @__passed__ = nil
           self.before_setup
           self.setup
           self.after_setup
@@ -169,11 +171,11 @@ def run runner
           result = "." unless io?
           time = Time.now - start_time
           runner.record self.class, self.__name__, self._assertions, time, nil
-          @passed = true
+          @__passed__ = true
         rescue *PASSTHROUGH_EXCEPTIONS
           raise
         rescue Exception => e
-          @passed = Test::Unit::PendedError === e
+          @__passed__ = Test::Unit::PendedError === e
           time = Time.now - start_time
           runner.record self.class, self.__name__, self._assertions, time, e
           result = runner.puke self.class, self.__name__, e
@@ -184,7 +186,7 @@ def run runner
             rescue *PASSTHROUGH_EXCEPTIONS
               raise
             rescue Exception => e
-              @passed = false
+              @__passed__ = false
               runner.record self.class, self.__name__, self._assertions, time, e
               result = runner.puke self.class, self.__name__, e
             end
@@ -206,12 +208,12 @@ def run_test(name)
       def initialize name # :nodoc:
         @__name__ = name
         @__io__ = nil
-        @passed = nil
-        @@current = self # FIX: make thread local
+        @__passed__ = nil
+        @@__current__ = self # FIX: make thread local
       end
 
       def self.current # :nodoc:
-        @@current # FIX: make thread local
+        @@__current__ # FIX: make thread local
       end
 
       ##
@@ -263,7 +265,7 @@ def self.test_methods # :nodoc:
       # Returns true if the test passed.
 
       def passed?
-        @passed
+        @__passed__
       end
 
       ##
diff --git a/test/tool/lib/vcs.rb b/test/tool/lib/vcs.rb
index c41276e3b49..602f6dd519c 100644
--- a/test/tool/lib/vcs.rb
+++ b/test/tool/lib/vcs.rb
@@ -1,6 +1,8 @@
 # vcs
 require 'fileutils'
 require 'optparse'
+require 'pp'
+require 'tempfile'
 
 # This library is used by several other tools/ scripts to detect the current
 # VCS in use (e.g. SVN, Git) or to interact with that VCS.
@@ -9,6 +11,22 @@
 
 class VCS
   DEBUG_OUT = STDERR.dup
+
+  def self.dump(obj, pre = nil)
+    out = DEBUG_OUT
+    @pp ||= PP.new(out)
+    @pp.guard_inspect_key do
+      if pre
+        @pp.group(pre.size, pre) {
+          obj.pretty_print(@pp)
+        }
+      else
+        obj.pretty_print(@pp)
+      end
+      @pp.flush
+      out << "\n"
+    end
+  end
 end
 
 unless File.respond_to? :realpath
@@ -19,37 +37,23 @@ def File.realpath(arg)
 end
 
 def IO.pread(*args)
-  VCS::DEBUG_OUT.puts(args.inspect) if $DEBUG
+  VCS.dump(args, "args: ") if $DEBUG
   popen(*args) {|f|f.read}
 end
 
 module DebugPOpen
   refine IO.singleton_class do
     def popen(*args)
-      VCS::DEBUG_OUT.puts args.inspect if $DEBUG
+      VCS.dump(args, "args: ") if $DEBUG
       super
     end
   end
 end
 using DebugPOpen
 module DebugSystem
-  def system(*args)
-    VCS::DEBUG_OUT.puts args.inspect if $DEBUG
-    exception = false
-    opts = Hash.try_convert(args[-1])
-    if RUBY_VERSION >= "2.6"
-      unless opts
-        opts = {}
-        args << opts
-      end
-      exception = opts.fetch(:exception) {opts[:exception] = true}
-    elsif opts
-      exception = opts.delete(:exception) {true}
-      args.pop if opts.empty?
-    end
-    ret = super(*args)
-    raise "Command failed with status (#$?): #{args[0]}" if exception and !ret
-    ret
+  def system(*args, exception: true, **opts)
+    VCS.dump(args, "args: ") if $DEBUG
+    super(*args, exception: exception, **opts)
   end
 end
 
@@ -69,6 +73,9 @@ def self.detect(path = '.', options = {}, parser = nil, **opts)
     begin
       @@dirs.each do |dir, klass, pred|
         if pred ? pred[curr, dir] : File.directory?(File.join(curr, dir))
+          if klass.const_defined?(:COMMAND)
+            IO.pread([{'LANG' => 'C', 'LC_ALL' => 'C'}, klass::COMMAND, "--version"]) rescue next
+          end
           vcs = klass.new(curr)
           vcs.define_options(parser) if parser
           vcs.set_options(options)
@@ -92,9 +99,23 @@ def self.define_options(parser, opts = {})
     parser.separator("  VCS common options:")
     parser.define("--[no-]dryrun") {|v| opts[:dryrun] = v}
     parser.define("--[no-]debug") {|v| opts[:debug] = v}
+    parser.define("-z", "--zone=OFFSET", /\A[-+]\d\d:\d\d\z/) {|v| opts[:zone] = v}
     opts
   end
 
+  def release_date(time)
+    t = time.getlocal(@zone)
+    [
+      t.strftime('#define RUBY_RELEASE_YEAR %Y'),
+      t.strftime('#define RUBY_RELEASE_MONTH %-m'),
+      t.strftime('#define RUBY_RELEASE_DAY %-d'),
+    ]
+  end
+
+  def self.short_revision(rev)
+    rev
+  end
+
   attr_reader :srcdir
 
   def initialize(path)
@@ -112,14 +133,14 @@ def define_options(parser)
   def set_options(opts)
     @debug = opts.fetch(:debug) {$DEBUG}
     @dryrun = opts.fetch(:dryrun) {@debug}
+    @zone = opts.fetch(:zone) {'+09:00'}
   end
 
   attr_reader :dryrun, :debug
   alias dryrun? dryrun
   alias debug? debug
 
-  NullDevice = defined?(IO::NULL) ? IO::NULL :
-    %w[/dev/null NUL NIL: NL:].find {|dev| File.exist?(dev)}
+  NullDevice = IO::NULL
 
   # returns
   # * the last revision of the current branch
@@ -132,7 +153,7 @@ def get_revisions(path)
     end
     last, changed, modified, *rest = (
       begin
-        if NullDevice
+        if NullDevice and !debug?
           save_stderr = STDERR.dup
           STDERR.reopen NullDevice, 'w'
         end
@@ -159,6 +180,7 @@ def get_revisions(path)
       rescue ArgumentError
         modified = Time.utc(*$~[1..6]) + $7.to_i * 3600 + $8.to_i * 60
       end
+      modified = modified.getlocal(@zone)
     end
     return last, changed, modified, *rest
   end
@@ -190,6 +212,7 @@ def relative_to(path)
 
   def after_export(dir)
     FileUtils.rm_rf(Dir.glob("#{dir}/.git*"))
+    FileUtils.rm_rf(Dir.glob("#{dir}/.mailmap"))
   end
 
   def revision_handler(rev)
@@ -204,170 +227,60 @@ def short_revision(rev)
     revision_handler(rev).short_revision(rev)
   end
 
-  class SVN < self
-    register(".svn")
-    COMMAND = ENV['SVN'] || 'svn'
-
-    def self.revision_name(rev)
-      "r#{rev}"
-    end
-
-    def self.short_revision(rev)
-      rev
-    end
-
-    def _get_revisions(path, srcdir = nil)
-      if srcdir and self.class.local_path?(path)
-        path = File.join(srcdir, path)
-      end
-      if srcdir
-        info_xml = IO.pread(%W"#{COMMAND} info --xml #{srcdir}")
-        info_xml = nil unless info_xml[/<url>(.*)<\/url>/, 1] == path.to_s
-      end
-      info_xml ||= IO.pread(%W"#{COMMAND} info --xml #{path}")
-      _, last, _, changed, _ = info_xml.split(/revision="(\d+)"/)
-      modified = info_xml[/<date>([^<>]*)/, 1]
-      branch = info_xml[%r'<relative-url>\^/(?:branches/|tags/)?([^<>]+)', 1]
-      [Integer(last), Integer(changed), modified, branch]
-    end
-
-    def self.search_root(path)
-      return unless local_path?(path)
-      parent = File.realpath(path)
-      begin
-        parent = File.dirname(wkdir = parent)
-        return wkdir if File.directory?(wkdir + "/.svn")
-      end until parent == wkdir
-    end
-
-    def get_info
-      @info ||= IO.pread(%W"#{COMMAND} info --xml #{@srcdir}")
-    end
-
-    def url
-      @url ||= begin
-        url = get_info[/<root>(.*)<\/root>/, 1]
-        @url = URI.parse(url+"/") if url
-      end
-    end
-
-    def wcroot
-      @wcroot ||= begin
-        info = get_info
-        @wcroot = info[/<wcroot-abspath>(.*)<\/wcroot-abspath>/, 1]
-        @wcroot ||= self.class.search_root(@srcdir)
-      end
-    end
-
-    def branch(name)
-      return trunk if name == "trunk"
-      url + "branches/#{name}"
-    end
-
-    def tag(name)
-      url + "tags/#{name}"
-    end
-
-    def trunk
-      url + "trunk"
-    end
-    alias master trunk
-
-    def branch_list(pat)
-      IO.popen(%W"#{COMMAND} ls #{branch('')}") do |f|
-        f.each do |line|
-          line.chomp!
-          line.chomp!('/')
-          yield(line) if File.fnmatch?(pat, line)
-        end
-      end
-    end
-
-    def grep(pat, tag, *files, &block)
-      cmd = %W"#{COMMAND} cat"
-      files.map! {|n| File.join(tag, n)} if tag
-      set = block.binding.eval("proc {|match| $~ = match}")
-      IO.popen([cmd, *files]) do |f|
-        f.grep(pat) do |s|
-          set[$~]
-          yield s
-        end
-      end
-    end
+  # make-snapshot generates only release_date whereas file2lastrev generates both release_date and release_datetime
+  def revision_header(last, release_date, release_datetime = nil, branch = nil, title = nil, limit: 20)
+    short = short_revision(last)
+    if /[^\x00-\x7f]/ =~ title and title.respond_to?(:force_encoding)
+      title = title.dup.force_encoding("US-ASCII")
+    end
+    code = [
+      "#define RUBY_REVISION #{short.inspect}",
+    ]
+    unless short == last
+      code << "#define RUBY_FULL_REVISION #{last.inspect}"
+    end
+    if branch
+      e = '..'
+      name = branch.sub(/\A(.{#{limit-e.size}}).{#{e.size+1},}/o) {$1+e}
+      name = name.dump.sub(/\\#/, '#')
+      code << "#define RUBY_BRANCH_NAME #{name}"
+    end
+    if title
+      title = title.dump.sub(/\\#/, '#')
+      code << "#define RUBY_LAST_COMMIT_TITLE #{title}"
+    end
+    if release_datetime
+      t = release_datetime.utc
+      code << t.strftime('#define RUBY_RELEASE_DATETIME "%FT%TZ"')
+    end
+    code += self.release_date(release_date)
+    code
+  end
 
-    def export(revision, url, dir, keep_temp = false)
-      if @srcdir and (rootdir = wcroot)
-        srcdir = File.realpath(@srcdir)
-        rootdir << "/"
-        if srcdir.start_with?(rootdir)
-          subdir = srcdir[rootdir.size..-1]
-          subdir = nil if subdir.empty?
-          FileUtils.mkdir_p(svndir = dir+"/.svn")
-          FileUtils.ln_s(Dir.glob(rootdir+"/.svn/*"), svndir)
-          system(COMMAND, "-q", "revert", "-R", subdir || ".", :chdir => dir) or return false
-          FileUtils.rm_rf(svndir) unless keep_temp
-          if subdir
-            tmpdir = Dir.mktmpdir("tmp-co.", "#{dir}/#{subdir}")
-            File.rename(tmpdir, tmpdir = "#{dir}/#{File.basename(tmpdir)}")
-            FileUtils.mv(Dir.glob("#{dir}/#{subdir}/{.[^.]*,..?*,*}"), tmpdir)
-            begin
-              Dir.rmdir("#{dir}/#{subdir}")
-            end until (subdir = File.dirname(subdir)) == '.'
-            FileUtils.mv(Dir.glob("#{tmpdir}/#{subdir}/{.[^.]*,..?*,*}"), dir)
-            Dir.rmdir(tmpdir)
-          end
-          return self
+  class GIT < self
+    register(".git") do |path, dir|
+      SAFE_DIRECTORIES ||=
+        begin
+          command = ENV["GIT"] || 'git'
+          dirs = IO.popen(%W"#{command} config --global --get-all safe.directory", &:read).split("\n")
+        rescue
+          command = nil
+          dirs = []
+        ensure
+          VCS.dump(dirs, "safe.directory: ") if $DEBUG
+          COMMAND = command
         end
-      end
-      IO.popen(%W"#{COMMAND} export -r #{revision} #{url} #{dir}") do |pipe|
-        pipe.each {|line| /^A/ =~ line or yield line}
-      end
-      self if $?.success?
-    end
 
-    def after_export(dir)
-      super
-      FileUtils.rm_rf(dir+"/.svn")
+      COMMAND and File.exist?(File.join(path, dir))
     end
 
-    def branch_beginning(url)
-      # `--limit` of svn-log is useless in this case, because it is
-      # applied before `--search`.
-      rev = IO.pread(%W[ #{COMMAND} log --xml
-                         --search=matz --search-and=has\ started
-                         -- #{url}/version.h])[/<logentry\s+revision="(\d+)"/m, 1]
-      rev.to_i if rev
-    end
-
-    def export_changelog(url = '.', from = nil, to = nil, _path = nil, path: _path)
-      range = [to || 'HEAD', (from ? from+1 : branch_beginning(url))].compact.join(':')
-      IO.popen({'TZ' => 'JST-9', 'LANG' => 'C', 'LC_ALL' => 'C'},
-               %W"#{COMMAND} log -r#{range} #{url}") do |r|
-        IO.copy_stream(r, path)
-      end
-    end
-
-    def commit
-      args = %W"#{COMMAND} commit"
-      if dryrun?
-        VCS::DEBUG_OUT.puts(args.inspect)
-        return true
-      end
-      system(*args)
-    end
-  end
-
-  class GIT < self
-    register(".git") {|path, dir| File.exist?(File.join(path, dir))}
-    COMMAND = ENV["GIT"] || 'git'
-
     def cmd_args(cmds, srcdir = nil)
       (opts = cmds.last).kind_of?(Hash) or cmds << (opts = {})
       opts[:external_encoding] ||= "UTF-8"
       if srcdir
         opts[:chdir] ||= srcdir
       end
-      VCS::DEBUG_OUT.puts cmds.inspect if debug?
+      VCS.dump(cmds, "cmds: ") if debug? and !$DEBUG
       cmds
     end
 
@@ -377,7 +290,7 @@ def cmd_pipe_at(srcdir, cmds, &block)
 
     def cmd_read_at(srcdir, cmds)
       result = without_gitconfig { IO.pread(*cmd_args(cmds, srcdir)) }
-      VCS::DEBUG_OUT.puts result.inspect if debug?
+      VCS.dump(result, "result: ") if debug?
       result
     end
 
@@ -398,7 +311,14 @@ def svn_revision(log)
     def _get_revisions(path, srcdir = nil)
       ref = Branch === path ? path.to_str : 'HEAD'
       gitcmd = [COMMAND]
-      last = cmd_read_at(srcdir, [[*gitcmd, 'rev-parse', ref]]).rstrip
+      last = nil
+      IO.pipe do |r, w|
+        last = cmd_read_at(srcdir, [[*gitcmd, 'rev-parse', ref, err: w]]).rstrip
+        w.close
+        unless r.eof?
+          raise VCS::NotFoundError, "#{COMMAND} rev-parse failed\n#{r.read.gsub(/^(?=\s*\S)/, '  ')}"
+        end
+      end
       log = cmd_read_at(srcdir, [[*gitcmd, 'log', '-n1', '--date=iso', '--pretty=fuller', *path]])
       changed = log[/\Acommit (\h+)/, 1]
       modified = log[/^CommitDate:\s+(.*)/, 1]
@@ -450,26 +370,36 @@ def self.short_revision(rev)
       rev[0, 10]
     end
 
-    def revision_handler(rev)
-      case rev
-      when Integer
-        SVN
-      else
-        super
-      end
-    end
-
     def without_gitconfig
-      home = ENV.delete('HOME')
+      envs = (%w'HOME XDG_CONFIG_HOME' + ENV.keys.grep(/\AGIT_/)).each_with_object({}) do |v, h|
+        h[v] = ENV.delete(v)
+      end
+      ENV['GIT_CONFIG_SYSTEM'] = NullDevice
+      ENV['GIT_CONFIG_GLOBAL'] = global_config
       yield
     ensure
-      ENV['HOME'] = home if home
+      ENV.update(envs)
+    end
+
+    def global_config
+      return NullDevice if SAFE_DIRECTORIES.empty?
+      unless @gitconfig
+        @gitconfig = Tempfile.new(%w"vcs_ .gitconfig")
+        @gitconfig.close
+        ENV['GIT_CONFIG_GLOBAL'] = @gitconfig.path
+        SAFE_DIRECTORIES.each do |dir|
+          system(*%W[#{COMMAND} config --global --add safe.directory #{dir}])
+        end
+        VCS.dump(`#{COMMAND} config --global --get-all safe.directory`, "safe.directory: ") if debug?
+      end
+      @gitconfig.path
     end
 
     def initialize(*)
       super
       @srcdir = File.realpath(@srcdir)
-      VCS::DEBUG_OUT.puts @srcdir.inspect if debug?
+      @gitconfig = nil
+      VCS.dump(@srcdir, "srcdir: ") if debug?
       self
     end
 
@@ -514,7 +444,7 @@ def grep(pat, tag, *files, &block)
 
     def export(revision, url, dir, keep_temp = false)
       system(COMMAND, "clone", "-c", "advice.detachedHead=false", "-s", (@srcdir || '.').to_s, "-b", url, dir) or return
-      (Integer === revision ? GITSVN : GIT).new(File.expand_path(dir))
+      GIT.new(File.expand_path(dir))
     end
 
     def branch_beginning(url)
@@ -524,22 +454,15 @@ def branch_beginning(url)
     end
 
     def export_changelog(url = '@', from = nil, to = nil, _path = nil, path: _path, base_url: nil)
-      svn = nil
       from, to = [from, to].map do |rev|
         rev or next
-        if Integer === rev
-          svn = true
-          rev = cmd_read({'LANG' => 'C', 'LC_ALL' => 'C'},
-                         %W"#{COMMAND} log -n1 --format=format:%H" <<
-                         "--grep=^ *git-svn-id: .*@#{rev} ")
-        end
         rev unless rev.empty?
       end
       unless (from && /./.match(from)) or ((from = branch_beginning(url)) && /./.match(from))
         warn "no starting commit found", uplevel: 1
         from = nil
       end
-      if svn or system(*%W"#{COMMAND} fetch origin refs/notes/commits:refs/notes/commits",
+      if system(*%W"#{COMMAND} fetch origin refs/notes/commits:refs/notes/commits",
                            chdir: @srcdir, exception: false)
         system(*%W"#{COMMAND} fetch origin refs/notes/log-fix:refs/notes/log-fix",
                chdir: @srcdir, exception: false)
@@ -552,22 +475,17 @@ def export_changelog(url = '@', from = nil, to = nil, _path = nil, path: _path,
       else
         arg = ["--since=25 Dec 00:00:00", to]
       end
-      writer =
-        if svn
-          format_changelog_as_svn(path, arg)
-        else
-          if base_url == true
-            remote, = upstream
-            if remote &&= cmd_read(env, %W[#{COMMAND} remote get-url --no-push #{remote}])
-              remote.chomp!
-              # hack to redirect git.r-l.o to github
-              remote.sub!(/\Agit@git\.ruby-lang\.org:/, 'git@github.com:ruby/')
-              remote.sub!(/\Agit@(.*?):(.*?)(?:\.git)?\z/, 'https://\1/\2/commit/')
-            end
-            base_url = remote
-          end
-          format_changelog(path, arg, base_url)
+      if base_url == true
+        remote, = upstream
+        if remote &&= cmd_read(env, %W[#{COMMAND} remote get-url --no-push #{remote}])
+          remote.chomp!
+          # hack to redirect git.r-l.o to github
+          remote.sub!(/\Agit@git\.ruby-lang\.org:/, 'git@github.com:ruby/')
+          remote.sub!(/\Agit@(.*?):(.*?)(?:\.git)?\z/, 'https://\1/\2/commit/')
         end
+        base_url = remote
+      end
+      writer = changelog_formatter(path, arg, base_url)
       if !path or path == '-'
         writer[$stdout]
       else
@@ -577,35 +495,82 @@ def export_changelog(url = '@', from = nil, to = nil, _path = nil, path: _path,
 
     LOG_FIX_REGEXP_SEPARATORS = '/!:;|,#%&'
 
-    def format_changelog(path, arg, base_url = nil)
+    def changelog_formatter(path, arg, base_url = nil)
       env = {'TZ' => 'JST-9', 'LANG' => 'C', 'LC_ALL' => 'C'}
-      cmd = %W"#{COMMAND} log --format=fuller --notes=commits --notes=log-fix --topo-order --no-merges"
+      cmd = %W[#{COMMAND} log
+        --format=fuller --notes=commits --notes=log-fix --topo-order --no-merges
+        --fixed-strings --invert-grep --grep=[ci\ skip] --grep=[skip\ ci]
+      ]
       date = "--date=iso-local"
-      unless system(env, *cmd, date, chdir: @srcdir, out: NullDevice, exception: false)
+      unless system(env, *cmd, date, "-1", chdir: @srcdir, out: NullDevice, exception: false)
         date = "--date=iso"
       end
       cmd << date
       cmd.concat(arg)
       proc do |w|
-        w.print "-*- coding: utf-8 -*-\n\n"
-        w.print "base-url = #{base_url}\n\n" if base_url
+        w.print "-*- coding: utf-8 -*-\n"
+        w.print "\n""base-url = #{base_url}\n" if base_url
+
+        begin
+          ignore_revs = File.readlines(File.join(@srcdir, ".git-blame-ignore-revs"), chomp: true)
+                          .grep_v(/^ *(?:#|$)/)
+                          .to_h {|v| [v, true]}
+          ignore_revs = nil if ignore_revs.empty?
+        rescue Errno::ENOENT
+        end
+
         cmd_pipe(env, cmd, chdir: @srcdir) do |r|
-          while s = r.gets("\ncommit ")
+          r.gets(sep = "commit ")
+          sep = "\n" + sep
+          while s = r.gets(sep, chomp: true)
             h, s = s.split(/^$/, 2)
+            if ignore_revs&.key?(h[/\A\h{40}/])
+              next
+            end
+
+            next if /^Author: *dependabot\[bot\]/ =~ h
+
             h.gsub!(/^(?:(?:Author|Commit)(?:Date)?|Date): /, '  \&')
             if s.sub!(/\nNotes $log-fix$:\n((?: +.*\n)+)/, '')
               fix = $1
+              next if /\A *skip\Z/ =~ fix
               s = s.lines
               fix.each_line do |x|
+                next unless x.sub!(/^(\s+)(?:(\d+)|\$(?:-\d+)?)/, '')
+                b = ($2&.to_i || (s.size - 1 + $3.to_i))
+                sp = $1
+                if x.sub!(/^,(?:(\d+)|\$(?:-\d+)?)/, '')
+                  range = b..($1&.to_i || (s.size - 1 + $2.to_i))
+                else
+                  range = b..b
+                end
                 case x
-                when %r[^ +(\d+)s([#{LOG_FIX_REGEXP_SEPARATORS}])(.+)\2(.*)\2]o
-                  n = $1.to_i
-                  wrong = $3
-                  correct = $4
-                  begin
-                    s[n][wrong] = correct
-                  rescue IndexError
-                    message = ["format_changelog failed to replace #{wrong.dump} with #{correct.dump} at #$1\n"]
+                when %r[^s([#{LOG_FIX_REGEXP_SEPARATORS}])(.+)\1(.*)\1([gr]+)?]o
+                  wrong = $2
+                  correct = $3
+                  if opt = $4 and opt.include?("r") # regexp
+                    wrong = Regexp.new(wrong)
+                    correct.gsub!(/(?<!\\)(?:\\\\)*\K(?:\\n)+/) {"\n" * ($&.size / 2)}
+                    sub = opt.include?("g") ? :gsub! : :sub!
+                  else
+                    sub = false
+                  end
+                  range.each do |n|
+                    if sub
+                      ss = s[n].sub(/^#{sp}/, "") # un-indent for /^/
+                      if ss.__send__(sub, wrong, correct)
+                        s[n, 1] = ss.lines.map {|l| "#{sp}#{l}"}
+                        next
+                      end
+                    else
+                      begin
+                        s[n][wrong] = correct
+                      rescue IndexError
+                      else
+                        next
+                      end
+                    end
+                    message = ["changelog_formatter failed to replace #{wrong.dump} with #{correct.dump} at #{n}\n"]
                     from = [1, n-2].max
                     to = [s.size-1, n+2].min
                     s.each_with_index do |e, i|
@@ -615,46 +580,30 @@ def format_changelog(path, arg, base_url = nil)
                     end
                     raise message.join('')
                   end
-                when %r[^( +)(\d+)i([#{LOG_FIX_REGEXP_SEPARATORS}])(.*)\3]o
-                  s[$2.to_i, 0] = "#{$1}#{$4}\n"
-                when %r[^ +(\d+)(?:,(\d+))?d]
-                  n = $1.to_i
-                  e = $2
-                  s[n..(e ? e.to_i : n)] = []
+                when %r[^i([#{LOG_FIX_REGEXP_SEPARATORS}])(.*)\1]o
+                  insert = "#{sp}#{$2}\n"
+                  range.reverse_each do |n|
+                    s[n, 0] = insert
+                  end
+                when %r[^d]
+                  s[range] = []
                 end
               end
               s = s.join('')
             end
 
+            s.gsub!(%r[(?!<\w)([-\w]+/[-\w]+)(?:@(\h{8,40})|#(\d{5,}))\b]) do
+              path = defined?($2) ? "commit/#{$2}" : "pull/#{$3}"
+              "[#$&](https://github.com/#{$1}/#{path})"
+            end
             if %r[^ +(https://github\.com/[^/]+/[^/]+/)commit/\h+\n(?=(?: +\n(?i: +Co-authored-by: .*\n)+)?(?:\n|\Z))] =~ s
               issue = "#{$1}pull/"
-              s.gsub!(/\b[Ff]ix(?:e[sd])? \K#(?=\d+)/) {issue}
+              s.gsub!(/\b(?:(?i:fix(?:e[sd])?) +|GH-)\K#(?=\d+\b)|$\K#(?=\d+$)/) {issue}
             end
 
             s.gsub!(/ +\n/, "\n")
             s.sub!(/^Notes:/, '  \&')
-            w.print h, s
-          end
-        end
-      end
-    end
-
-    def format_changelog_as_svn(path, arg)
-      cmd = %W"#{COMMAND} log --topo-order --no-notes -z --format=%an%n%at%n%B"
-      cmd.concat(arg)
-      proc do |w|
-        sep = "-"*72 + "\n"
-        w.print sep
-        cmd_pipe(cmd) do |r|
-          while s = r.gets("\0")
-            s.chomp!("\0")
-            author, time, s = s.split("\n", 3)
-            s.sub!(/\n\ngit-svn-id: .*@(\d+) .*\n\Z/, '')
-            rev = $1
-            time = Time.at(time.to_i).getlocal("+09:00").strftime("%F %T %z (%a, %d %b %Y)")
-            lines = s.count("\n") + 1
-            lines = "#{lines} line#{lines == 1 ? '' : 's'}"
-            w.print "r#{rev} | #{author} | #{time} | #{lines}\n\n", s, "\n", sep
+            w.print sep, h, s
           end
         end
       end
@@ -674,13 +623,13 @@ def upstream
 
     def commit(opts = {})
       args = [COMMAND, "push"]
-      args << "-n" if dryrun
+      args << "-n" if dryrun?
       remote, branch = upstream
       args << remote
       branches = %W[refs/notes/commits:refs/notes/commits HEAD:#{branch}]
       if dryrun?
         branches.each do |b|
-          VCS::DEBUG_OUT.puts((args + [b]).inspect)
+          VCS.dump(args + [b], "commit: ")
         end
         return true
       end
@@ -691,43 +640,14 @@ def commit(opts = {})
     end
   end
 
-  class GITSVN < GIT
-    def self.revision_name(rev)
-      SVN.revision_name(rev)
-    end
-
-    def last_changed_revision
-      rev = cmd_read(%W"#{COMMAND} svn info"+[STDERR=>[:child, :out]])[/^Last Changed Rev: (\d+)/, 1]
-      com = cmd_read(%W"#{COMMAND} svn find-rev r#{rev}").chomp
-      return rev, com
+  class Null < self
+    def get_revisions(path, srcdir = nil)
+      @modified ||= Time.now - 10
+      return nil, nil, @modified
     end
 
-    def commit(opts = {})
-      rev, com = last_changed_revision
-      head = cmd_read(%W"#{COMMAND} symbolic-ref --short HEAD").chomp
-
-      commits = cmd_read([COMMAND, "log", "--reverse", "--format=%H %ae %ce", "#{com}..@"], "rb").split("\n")
-      commits.each_with_index do |l, i|
-        r, a, c = l.split(' ')
-        dcommit = [COMMAND, "svn", "dcommit"]
-        dcommit.insert(-2, "-n") if dryrun
-        dcommit << "--add-author-from" unless a == c
-        dcommit << r
-        system(*dcommit) or return false
-        system(COMMAND, "checkout", head) or return false
-        system(COMMAND, "rebase") or return false
-      end
-
-      if rev
-        old = [cmd_read(%W"#{COMMAND} log -1 --format=%H").chomp]
-        old << cmd_read(%W"#{COMMAND} svn reset -r#{rev}")[/^r#{rev} = (\h+)/, 1]
-        3.times do
-          sleep 2
-          system(*%W"#{COMMAND} pull --no-edit --rebase")
-          break unless old.include?(cmd_read(%W"#{COMMAND} log -1 --format=%H").chomp)
-        end
-      end
-      true
+    def revision_header(last, release_date, release_datetime = nil, branch = nil, title = nil, limit: 20)
+      self.release_date(release_date)
     end
   end
 end
diff --git a/test/tool/lib/vpath.rb b/test/tool/lib/vpath.rb
index 48ab148405d..fa819f32423 100644
--- a/test/tool/lib/vpath.rb
+++ b/test/tool/lib/vpath.rb
@@ -53,10 +53,11 @@ def foreach(file, *args, &block)
   end
 
   def def_options(opt)
+    opt.separator("  VPath common options:")
     opt.on("-I", "--srcdir=DIR", "add a directory to search path") {|dir|
       @additional << dir
     }
-    opt.on("-L", "--vpath=PATH LIST", "add directories to search path") {|dirs|
+    opt.on("-L", "--vpath=PATH-LIST", "add directories to search path") {|dirs|
       @additional << [dirs]
     }
     opt.on("--path-separator=SEP", /\A(?:\W\z|\.(\W).+)/, "separator for vpath") {|sep, vsep|
@@ -80,6 +81,10 @@ def list
     @list
   end
 
+  def add(path)
+    @additional << path
+  end
+
   def strip(path)
     prefix = list.map {|dir| Regexp.quote(dir)}
     path.sub(/\A#{prefix.join('|')}(?:\/|\z)/, '')

From ddcd04930e614a5fc37927f5bcb31425dd083f37 Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Thu, 22 Jan 2026 17:29:50 -0600
Subject: [PATCH 075/168] Add utility methods from CRuby rbconfig.rb

---
 lib/ruby/stdlib/rbconfig.rb | 75 +++++++++++++++++++++++++++++++++++++
 1 file changed, 75 insertions(+)

diff --git a/lib/ruby/stdlib/rbconfig.rb b/lib/ruby/stdlib/rbconfig.rb
index 3c5c35c499c..33f674f17cf 100644
--- a/lib/ruby/stdlib/rbconfig.rb
+++ b/lib/ruby/stdlib/rbconfig.rb
@@ -1,2 +1,77 @@
 # Load built-in rbconfig library
 JRuby::Util.load_ext("org.jruby.ext.rbconfig.RbConfigLibrary")
+
+module RbConfig
+  # call-seq:
+  #
+  #   RbConfig.expand(val)         -> string
+  #   RbConfig.expand(val, config) -> string
+  #
+  # expands variable with given +val+ value.
+  #
+  #   RbConfig.expand("$(bindir)") # => /home/foobar/all-ruby/ruby19x/bin
+  def RbConfig::expand(val, config = CONFIG)
+    newval = val.gsub(/\$\$|\$$([^()]+)$|\$\{([^{}]+)\}/) {
+      var = $&
+      if !(v = $1 || $2)
+        '$'
+      elsif key = config[v = v[/\A[^:]+(?=(?::(.*?)=(.*))?\z)/]]
+        pat, sub = $1, $2
+        config[v] = false
+        config[v] = RbConfig::expand(key, config)
+        key = key.gsub(/#{Regexp.quote(pat)}(?=\s|\z)/n) {sub} if pat
+        key
+      else
+        var
+      end
+    }
+    val.replace(newval) unless newval == val
+    val
+  end
+  CONFIG.each_value do |val|
+    RbConfig::expand(val)
+  end
+
+  # call-seq:
+  #
+  #   RbConfig.fire_update!(key, val)               -> array
+  #   RbConfig.fire_update!(key, val, mkconf, conf) -> array
+  #
+  # updates +key+ in +mkconf+ with +val+, and all values depending on
+  # the +key+ in +mkconf+.
+  #
+  #   RbConfig::MAKEFILE_CONFIG.values_at("CC", "LDSHARED") # => ["gcc", "$(CC) -shared"]
+  #   RbConfig::CONFIG.values_at("CC", "LDSHARED")          # => ["gcc", "gcc -shared"]
+  #   RbConfig.fire_update!("CC", "gcc-8")                  # => ["CC", "LDSHARED"]
+  #   RbConfig::MAKEFILE_CONFIG.values_at("CC", "LDSHARED") # => ["gcc-8", "$(CC) -shared"]
+  #   RbConfig::CONFIG.values_at("CC", "LDSHARED")          # => ["gcc-8", "gcc-8 -shared"]
+  #
+  # returns updated keys list, or +nil+ if nothing changed.
+  def RbConfig.fire_update!(key, val, mkconf = MAKEFILE_CONFIG, conf = CONFIG) # :nodoc:
+    return if mkconf[key] == val
+    mkconf[key] = val
+    keys = [key]
+    deps = []
+    begin
+      re = Regexp.new("\\$\$(?:%1$s)\$|\\$\\{(?:%1$s)\\}" % keys.join('|'))
+      deps |= keys
+      keys.clear
+      mkconf.each {|k,v| keys << k if re =~ v}
+    end until keys.empty?
+    deps.each {|k| conf[k] = mkconf[k].dup}
+    deps.each {|k| expand(conf[k])}
+    deps
+  end
+
+  # call-seq:
+  #
+  #   RbConfig.ruby -> path
+  #
+  # returns the absolute pathname of the ruby command.
+  def RbConfig.ruby
+    File.join(
+      RbConfig::CONFIG["bindir"],
+      RbConfig::CONFIG["ruby_install_name"] + RbConfig::CONFIG["EXEEXT"]
+    )
+  end
+end

From 0a19eeb528dbc986798ae806c7d9cc42a96449c4 Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Thu, 22 Jan 2026 17:38:47 -0600
Subject: [PATCH 076/168] Add dummy Sanitizers for CRuby tests

---
 test/tool/lib/-test-/sanitizers.rb | 6 ++++++
 1 file changed, 6 insertions(+)
 create mode 100644 test/tool/lib/-test-/sanitizers.rb

diff --git a/test/tool/lib/-test-/sanitizers.rb b/test/tool/lib/-test-/sanitizers.rb
new file mode 100644
index 00000000000..38ca997b714
--- /dev/null
+++ b/test/tool/lib/-test-/sanitizers.rb
@@ -0,0 +1,6 @@
+module Test
+  module Sanitizers
+    def self.asan_enabled? = false
+    def self.lsan_enabled? = false
+  end
+end

From 6cf9fcb55b119a943cadd8e77a783f5caa7c904f Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Thu, 22 Jan 2026 17:41:14 -0600
Subject: [PATCH 077/168] Remove win32ole tests already deleted

---
 test/mri.stdlib.index | 1 -
 1 file changed, 1 deletion(-)

diff --git a/test/mri.stdlib.index b/test/mri.stdlib.index
index 150e69309e7..6c70fe04b62 100644
--- a/test/mri.stdlib.index
+++ b/test/mri.stdlib.index
@@ -23,7 +23,6 @@ socket
 stringio
 strscan
 uri
-win32ole
 yaml
 zlib

From 883925b769d2be4700717b67532157cfc6ee9150 Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Thu, 22 Jan 2026 18:28:35 -0600
Subject: [PATCH 078/168] Implement remaining 4.0 predefined var changes

Mostly surrounding the handling of `$/`, `$\`, and `$,` with
regards to duping and freezing and assignment of non-nil warnings.
---
 core/src/main/java/org/jruby/RubyGlobal.java | 33 +++++++++++++++++---
 1 file changed, 29 insertions(+), 4 deletions(-)

diff --git a/core/src/main/java/org/jruby/RubyGlobal.java b/core/src/main/java/org/jruby/RubyGlobal.java
index f2549e9b684..a944bb16b2e 100644
--- a/core/src/main/java/org/jruby/RubyGlobal.java
+++ b/core/src/main/java/org/jruby/RubyGlobal.java
@@ -195,12 +195,12 @@ public static RubyHash createGlobalsAndENV(ThreadContext context, GlobalVariable
         runtime.defineVariable(new WarningGlobalVariable(context, "$-W", verbosity), GLOBAL);
 
         IRubyObject defaultRS = RubyString.newFString(runtime, instanceConfig.getRecordSeparator());
-        GlobalVariable rs = new DeprecatedStringGlobalVariable(runtime, "$/", defaultRS);
+        GlobalVariable rs = new DeprecatedFrozenStringGlobalVariable(runtime, "$/", defaultRS);
         runtime.defineVariable(rs, GLOBAL);
         runtime.setRecordSeparatorVar(rs);
         globals.setDefaultSeparator(defaultRS);
         runtime.defineVariable(new DeprecatedStringGlobalVariable(runtime, "$\\", context.nil), GLOBAL);
-        runtime.defineVariable(new DeprecatedStringGlobalVariable(runtime, "$,", context.nil), GLOBAL);
+        runtime.defineVariable(new DeprecatedFrozenStringGlobalVariable(runtime, "$,", context.nil), GLOBAL);
 
         runtime.defineVariable(new LineNumberGlobalVariable(runtime, "$."), GLOBAL);
         runtime.defineVariable(new LastlineGlobalVariable(runtime, "$_"), FRAME);
@@ -463,8 +463,8 @@ private static RubyHash defineGlobalEnvConstants(ThreadContext context) {
         return env;
     }
 
-    private static void warnDeprecatedGlobal(ThreadContext context, final String name) {
-        warnDeprecated(context, "'" + name + "' is deprecated");
+    private static void warnDeprecatedGlobal(ThreadContext context, final String subject) {
+        warnDeprecated(context, subject + " is deprecated");
     }
 
     /**
@@ -1079,6 +1079,31 @@ public IRubyObject set(IRubyObject value) {
         }
     }
 
+    public static class DeprecatedFrozenStringGlobalVariable extends StringGlobalVariable {
+        public DeprecatedFrozenStringGlobalVariable(Ruby runtime, String name, IRubyObject value) {
+            super(runtime, name, value);
+        }
+
+        @Override
+        public IRubyObject set(IRubyObject value) {
+            ThreadContext currentContext = runtime.getCurrentContext();
+            IRubyObject setValue = value;
+            if (setValue instanceof RubyString stringValue) {
+                if (!stringValue.isBare(currentContext) || !stringValue.isFrozen()) {
+                    stringValue = newSharedString(currentContext, stringValue.getByteList());
+                    stringValue.setFrozen(true);
+                }
+                setValue = stringValue;
+            }
+
+            super.set(setValue);
+
+            if (!value.isNil()) warnDeprecatedGlobal(currentContext, "non-nil '" + name + "'");
+
+            return value;
+        }
+    }
+
     public static class DeprecatedStringOrRegexpGlobalVariable extends StringOrRegexpGlobalVariable {
         public DeprecatedStringOrRegexpGlobalVariable(Ruby runtime, String name, IRubyObject value) {
             super(runtime, name, value);

From f20b3249a4282a36ac6a676770c2901ffb8eff2a Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Thu, 22 Jan 2026 18:51:32 -0600
Subject: [PATCH 079/168] Separate configurable separator from default

CRuby has for a long time had separate C globals for the default
record separator (`rb_default_rs`) and the configurable record
separator (`rb_rs`), while we only used a single global slot for
both. This led to failures expecting that the configurable version
could be configured using the `-0` flag (as in `-072`) without
affecting e.g. the output of `puts`.

This change may modify behavior in JRuby where we go after the real
global variable (rather than the JRuby global default separator)
but as the `-0` flag and the `$/` and `$-0` globals are being
deprecated, I'm not really worried about it.
---
 core/src/main/java/org/jruby/RubyGlobal.java       | 5 +++--
 core/src/main/java/org/jruby/util/cli/Options.java | 2 +-
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/core/src/main/java/org/jruby/RubyGlobal.java b/core/src/main/java/org/jruby/RubyGlobal.java
index a944bb16b2e..139a3ae9c53 100644
--- a/core/src/main/java/org/jruby/RubyGlobal.java
+++ b/core/src/main/java/org/jruby/RubyGlobal.java
@@ -194,8 +194,9 @@ public static RubyHash createGlobalsAndENV(ThreadContext context, GlobalVariable
         RubyInstanceConfig.Verbosity verbosity = instanceConfig.getVerbosity();
         runtime.defineVariable(new WarningGlobalVariable(context, "$-W", verbosity), GLOBAL);
 
-        IRubyObject defaultRS = RubyString.newFString(runtime, instanceConfig.getRecordSeparator());
-        GlobalVariable rs = new DeprecatedFrozenStringGlobalVariable(runtime, "$/", defaultRS);
+        IRubyObject defaultRS = RubyString.newFString(runtime, "\n");
+        IRubyObject configRS = RubyString.newFString(runtime, instanceConfig.getRecordSeparator());
+        GlobalVariable rs = new DeprecatedFrozenStringGlobalVariable(runtime, "$/", configRS);
         runtime.defineVariable(rs, GLOBAL);
         runtime.setRecordSeparatorVar(rs);
         globals.setDefaultSeparator(defaultRS);
diff --git a/core/src/main/java/org/jruby/util/cli/Options.java b/core/src/main/java/org/jruby/util/cli/Options.java
index d47a98a1ac0..878adf18a02 100644
--- a/core/src/main/java/org/jruby/util/cli/Options.java
+++ b/core/src/main/java/org/jruby/util/cli/Options.java
@@ -251,7 +251,7 @@ public class Options {
     public static final Option<String> CLI_ENCODING_INTERNAL = string(CLI, "cli.encoding.internal", "Encoding name to use internally.");
     public static final Option<String> CLI_ENCODING_EXTERNAL = string(CLI, "cli.encoding.external", "Encoding name to treat external data.");
     public static final Option<String> CLI_ENCODING_SOURCE = string(CLI, "cli.encoding.source", "Encoding name to treat source code.");
-    public static final Option<String> CLI_RECORD_SEPARATOR = string(CLI, "cli.record.separator", "\n", "Default record separator.");
+    public static final Option<String> CLI_RECORD_SEPARATOR = string(CLI, "cli.record.separator", "\n", "Configurable record separator.");
     public static final Option<String> CLI_BACKUP_EXTENSION = string(CLI, "cli.backup.extension", "Backup extension for in-place ARGV files. Same as -i.");
     public static final Option<ProfilingMode> CLI_PROFILING_MODE = enumeration(CLI, "cli.profiling.mode", ProfilingMode.class, ProfilingMode.OFF, "Enable instrumented profiling modes.");
     public static final Option<String> CLI_PROFILING_SERVICE = string(CLI, "cli.profiling.service", "Profiling service class to use.");

From a5894a2af9b1a9aeb918811de4aa104cae0fce57 Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Thu, 22 Jan 2026 19:04:05 -0600
Subject: [PATCH 080/168] Update error message to match CRuby

This was updated in 2015 but not tested until recently.

See https://github.com/ruby/ruby/commit/f830ace8a831a954db7a6aae280a530651a5b58a
---
 core/src/main/java/org/jruby/api/Convert.java | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/core/src/main/java/org/jruby/api/Convert.java b/core/src/main/java/org/jruby/api/Convert.java
index 9e37bce0f39..c4aa981a1d9 100644
--- a/core/src/main/java/org/jruby/api/Convert.java
+++ b/core/src/main/java/org/jruby/api/Convert.java
@@ -516,9 +516,9 @@ public static double toDouble(ThreadContext context, IRubyObject arg) {
             case RubyFixnum fixnum when sites.Fixnum.to_f.isBuiltin(fixnum) -> fixnum.asDouble(context);
             case RubyBignum bignum when sites.Bignum.to_f.isBuiltin(bignum) -> bignum.asDouble(context);
             case RubyRational rational when sites.Rational.to_f.isBuiltin(rational) -> rational.asDouble(context);
-            case RubyString a -> throw typeError(context, "no implicit conversion to float from string");
-            case RubyNil a -> throw typeError(context, "no implicit conversion to float from nil");
-            case RubyBoolean a -> throw typeError(context, "no implicit conversion to float from " + (arg.isTrue() ? "true" : "false"));
+            case RubyString a -> throw typeError(context, "can't convert String to Float");
+            case RubyNil a -> throw typeError(context, "can't convert nil to Float");
+            case RubyBoolean a -> throw typeError(context, "can't convert " + (arg.isTrue() ? "true" : "false" + " to Float"));
             default -> ((RubyFloat) TypeConverter.convertToType(arg, floatClass(context), "to_f")).getValue();
         };
     }

From f091520677748de1abb90fa13b33e276ff2c804d Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Thu, 22 Jan 2026 19:11:57 -0600
Subject: [PATCH 081/168] Also skip ruby2_keywords when there's post args

---
 core/src/main/java/org/jruby/RubyModule.java | 2 +-
 core/src/main/java/org/jruby/RubyProc.java   | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/core/src/main/java/org/jruby/RubyModule.java b/core/src/main/java/org/jruby/RubyModule.java
index 559996f7f81..336aaff4616 100644
--- a/core/src/main/java/org/jruby/RubyModule.java
+++ b/core/src/main/java/org/jruby/RubyModule.java
@@ -3500,7 +3500,7 @@ public IRubyObject ruby2_keywords(ThreadContext context, IRubyObject[] args) {
             if (method.getDefinedClass() == this) {
                 if (!method.isNative()) {
                     Signature signature = method.getSignature();
-                    if (!signature.hasRest()) {
+                    if (!signature.hasRest() || signature.post() != 0) {
                         warn(context, str(context.runtime, "Skipping set of ruby2_keywords flag for ", ids(context.runtime, name), " (method accepts keywords or post arguments or method does not accept argument splat)"));
                     } else if (!signature.hasKwargs()) {
                         method.setRuby2Keywords();
diff --git a/core/src/main/java/org/jruby/RubyProc.java b/core/src/main/java/org/jruby/RubyProc.java
index 9e5af18d56a..afed57dbaea 100644
--- a/core/src/main/java/org/jruby/RubyProc.java
+++ b/core/src/main/java/org/jruby/RubyProc.java
@@ -299,7 +299,7 @@ public IRubyObject ruby2_keywords(ThreadContext context) {
         BlockBody body = block.getBody();
         if (body.isRubyBlock()) {
             Signature signature = body.getSignature();
-            if (signature.hasRest() && !signature.hasKwargs()) {
+            if (signature.hasRest() && !signature.hasKwargs() && signature.post() == 0) {
                 ((IRBlockBody) body).getScope().setRuby2Keywords();
             } else {
                 warn(context, "Skipping set of ruby2_keywords flag for proc (proc accepts keywords or post arguments or proc does not accept argument splat)");

From aec59cb2fcc7d89a3d4dca5fcb807f8b062c0ae2 Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Thu, 22 Jan 2026 19:14:54 -0600
Subject: [PATCH 082/168] Only error for endless set

Now that to_set does not force a size, only endless is rejected.

See https://github.com/ruby/ruby/pull/15173
---
 core/src/main/java/org/jruby/RubyRange.java | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/core/src/main/java/org/jruby/RubyRange.java b/core/src/main/java/org/jruby/RubyRange.java
index 39b2f689134..366fc2ada7b 100644
--- a/core/src/main/java/org/jruby/RubyRange.java
+++ b/core/src/main/java/org/jruby/RubyRange.java
@@ -1373,10 +1373,8 @@ public IRubyObject size(ThreadContext context) {
 
     @JRubyMethod(name = "to_set", rest = true, frame = true)
     public IRubyObject to_set(ThreadContext context, IRubyObject[] args) {
-        IRubyObject size = sites(context).size.call(context, this, this);
-
-        if (size instanceof RubyFloat flote && flote.isInfinite()) {
-            throw context.runtime.newRangeError("cannot convert an infinite range to a set");
+        if (isEndless) {
+            throw context.runtime.newRangeError("cannot convert endless range to a set");
         }
 
         return invokeSuper(context, this, context.getFrameKlazz(), context.getFrameName(), args, Block.NULL_BLOCK);

From 35547a89756def214532c332036582bf110e7b5a Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Thu, 22 Jan 2026 19:36:35 -0600
Subject: [PATCH 083/168] Need to actually scan for dest code range here

---
 core/src/main/java/org/jruby/ext/cgi/escape/CGIEscape.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/core/src/main/java/org/jruby/ext/cgi/escape/CGIEscape.java b/core/src/main/java/org/jruby/ext/cgi/escape/CGIEscape.java
index 63c982b1063..6785caaa761 100644
--- a/core/src/main/java/org/jruby/ext/cgi/escape/CGIEscape.java
+++ b/core/src/main/java/org/jruby/ext/cgi/escape/CGIEscape.java
@@ -378,7 +378,7 @@ static IRubyObject optimized_escape(Ruby runtime, RubyString str, boolean escape
         origenc = str.getEncoding();
         if (origenc != encidx) {
             dest.setEncoding(encidx);
-            if (StringSupport.encCoderangeClean(dest.getCodeRange()) == 0) {
+            if (StringSupport.encCoderangeClean(dest.scanForCodeRange()) == 0) {
                 dest.setEncoding(origenc);
                 if (cr != StringSupport.CR_UNKNOWN)
                     dest.setCodeRange(cr);

From 8992389d4331d4253964760153bc9cfea0e34bb0 Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Thu, 22 Jan 2026 19:46:28 -0600
Subject: [PATCH 084/168] Tweak Kernel#inspect when requested ivars is nil or
 non-ary

* All vars if nil is given
* Error if non-nil, non-array given
---
 core/src/main/java/org/jruby/RubyBasicObject.java | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/core/src/main/java/org/jruby/RubyBasicObject.java b/core/src/main/java/org/jruby/RubyBasicObject.java
index 70cfb8db30a..3e0b322cacb 100644
--- a/core/src/main/java/org/jruby/RubyBasicObject.java
+++ b/core/src/main/java/org/jruby/RubyBasicObject.java
@@ -1143,6 +1143,10 @@ public final IRubyObject hashyInspect() {
     public final IRubyObject hashyInspect(ThreadContext context) {
         IRubyObject ivars = Helpers.invokeChecked(context, this, sites(context).instance_variables_to_inspect_checked);
 
+        if (ivars != null && !ivars.isNil() && !(ivars instanceof RubyArray)) {
+            throw typeError(context, "Expected #instance_variables_to_inspect to return an Array or nil, but it returned " + ivars.getMetaClass());
+        }
+
         RubyString part = inspectPrefix(context, metaClass.getRealClass(), inspectHashCode());
 
         Ruby runtime = context.runtime;
@@ -1197,7 +1201,7 @@ protected int inspectHashCode() {
     private RubyString inspectObj(final ThreadContext context, RubyString part, IRubyObject ivars) {
         Ruby runtime = context.runtime;
 
-        if (ivars == null) {
+        if (ivars == null || ivars.isNil()) {
             // no ivars specified, do all of them
             boolean first = true;
             for (Map.Entry<String, VariableAccessor> entry : metaClass.getVariableTableManager().getVariableAccessorsForRead().entrySet()) {
@@ -1208,7 +1212,7 @@ private RubyString inspectObj(final ThreadContext context, RubyString part, IRub
 
                 first = false;
             }
-        } else if (!ivars.isNil()) {
+        } else {
             // ivars specified, do only those
             RubyArray ivarsAry = Convert.castAsArray(context, ivars);
 
@@ -1223,7 +1227,7 @@ private RubyString inspectObj(final ThreadContext context, RubyString part, IRub
 
                 first = false;
             }
-        } // else ivars was provided and is nil, so do none
+        }
 
         encStrBufCat(runtime, part, GT);
         return part;

From e2afba11d1e5548af46b8a7187801f19aa6b0441 Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Thu, 22 Jan 2026 19:51:51 -0600
Subject: [PATCH 085/168] Don't double-coerce in fetch_values

When I switched to using fetch, I did not notice it also coerces.
Remove the extra coercion here.
---
 core/src/main/java/org/jruby/RubyArray.java | 2 --
 1 file changed, 2 deletions(-)

diff --git a/core/src/main/java/org/jruby/RubyArray.java b/core/src/main/java/org/jruby/RubyArray.java
index 056002c3e30..1e4ed176d21 100644
--- a/core/src/main/java/org/jruby/RubyArray.java
+++ b/core/src/main/java/org/jruby/RubyArray.java
@@ -1028,10 +1028,8 @@ public IRubyObject fetch_values(ThreadContext context, IRubyObject[] args, Block
         int length = args.length;
         if (length == 0) return Create.newEmptyArray(context);
 
-        int arraySize = size();
         var result = Create.allocArray(context, length);
         for (int i = 0; i < length; i++) {
-            int index = toInt(context, args[i]);
             result.append(context, fetch(context, args[i], block));
         }

From 9937e857213e6b7354c3496514e392a44b0db5e0 Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Thu, 22 Jan 2026 19:52:21 -0600
Subject: [PATCH 086/168] Add doco about the fail return value

I always forget which methods return null and which return UNDEF.
We should unify that some day but for now at least document it.
---
 core/src/main/java/org/jruby/RubyClass.java   |  8 ++++++
 .../main/java/org/jruby/runtime/Helpers.java  | 25 +++++++++++++++----
 2 files changed, 28 insertions(+), 5 deletions(-)

diff --git a/core/src/main/java/org/jruby/RubyClass.java b/core/src/main/java/org/jruby/RubyClass.java
index 7cbed54f295..c7049e5ecb2 100644
--- a/core/src/main/java/org/jruby/RubyClass.java
+++ b/core/src/main/java/org/jruby/RubyClass.java
@@ -718,6 +718,8 @@ public IRubyObject invokePublic(ThreadContext context, IRubyObject self, String
     /**
      * Safely attempt to invoke the given method name on self, using respond_to? and method_missing as appropriate.
      *
+     * Return null if the method does not exist.
+     *
      * MRI: rb_check_funcall
      */
     public final IRubyObject finvokeChecked(ThreadContext context, IRubyObject self, String name) {
@@ -727,6 +729,8 @@ public final IRubyObject finvokeChecked(ThreadContext context, IRubyObject self,
     /**
      * Safely attempt to invoke the given method name on self, using respond_to? and method_missing as appropriate.
      *
+     * Return null if the method does not exist.
+     *
      * MRI: rb_check_funcall
      */
     public final IRubyObject finvokeChecked(ThreadContext context, IRubyObject self, JavaSites.CheckedSites sites) {
@@ -736,6 +740,8 @@ public final IRubyObject finvokeChecked(ThreadContext context, IRubyObject self,
     /**
      * Safely attempt to invoke the given method name on self, using respond_to? and method_missing as appropriate.
      *
+     * Return null if the method does not exist.
+     *
      * MRI: rb_check_funcall
      */
     public final IRubyObject finvokeChecked(ThreadContext context, IRubyObject self, String name, IRubyObject... args) {
@@ -745,6 +751,8 @@ public final IRubyObject finvokeChecked(ThreadContext context, IRubyObject self,
     /**
      * Safely attempt to invoke the given method name on self, using respond_to? and method_missing as appropriate.
      *
+     * Return null if the method does not exist.
+     *
      * MRI: rb_check_funcall
      */
     public final IRubyObject finvokeChecked(ThreadContext context, IRubyObject self, JavaSites.CheckedSites sites, IRubyObject... args) {
diff --git a/core/src/main/java/org/jruby/runtime/Helpers.java b/core/src/main/java/org/jruby/runtime/Helpers.java
index e96f5bdf97f..fa4edb1f79b 100644
--- a/core/src/main/java/org/jruby/runtime/Helpers.java
+++ b/core/src/main/java/org/jruby/runtime/Helpers.java
@@ -827,27 +827,42 @@ public static IRubyObject invokePublic(ThreadContext context, IRubyObject self,
         return getMetaClass(self).invokePublic(context, self, name, arg);
     }
 
-    // MRI: rb_check_funcall
+    /**
+     * Invoke the method requested if the given object respond_to? it, returning null if it is not defined.
+     * MRI: rb_check_funcall
+     */
     public static IRubyObject invokeChecked(ThreadContext context, IRubyObject self, String name) {
         return getMetaClass(self).finvokeChecked(context, self, name);
     }
 
-    // MRI: rb_check_funcall
+    /**
+     * Invoke the method requested if the given object respond_to? it, returning null if it is not defined.
+     * MRI: rb_check_funcall
+     */
     public static IRubyObject invokeChecked(ThreadContext context, IRubyObject self, JavaSites.CheckedSites sites) {
         return getMetaClass(self).finvokeChecked(context, self, sites);
     }
 
-    // MRI: rb_check_funcall
+    /**
+     * Invoke the method requested if the given object respond_to? it, returning null if it is not defined.
+     * MRI: rb_check_funcall
+     */
     public static IRubyObject invokeChecked(ThreadContext context, IRubyObject self, String name, IRubyObject... args) {
         return getMetaClass(self).finvokeChecked(context, self, name, args);
     }
 
-    // MRI: rb_check_funcall
+    /**
+     * Invoke the method requested if the given object respond_to? it, returning null if it is not defined.
+     * MRI: rb_check_funcall
+     */
     public static IRubyObject invokeChecked(ThreadContext context, IRubyObject self, JavaSites.CheckedSites sites, IRubyObject arg0) {
         return getMetaClass(self).finvokeChecked(context, self, sites, arg0);
     }
 
-    // MRI: rb_check_funcall
+    /**
+     * Invoke the method requested if the given object respond_to? it, returning null if it is not defined.
+     * MRI: rb_check_funcall
+     */
     public static IRubyObject invokeChecked(ThreadContext context, IRubyObject self, JavaSites.CheckedSites sites, IRubyObject... args) {
         return getMetaClass(self).finvokeChecked(context, self, sites, args);
     }

From ce62ffe3bcd26c0c8b3669c948a18c541da0ffc8 Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Fri, 23 Jan 2026 01:05:14 -0600
Subject: [PATCH 087/168] Rework double conversion to match CRuby

CRuby has both rb_num2dbl and rb_num_to_dbl, which have slightly
different logic and raise slightly different errors. This patch
matches that to allow both forms of errors to be thrown in the
appropriate places.
---
 core/src/main/java/org/jruby/RubyMath.java    |  54 ++++-----
 core/src/main/java/org/jruby/api/Convert.java | 114 ++++++++++++++++--
 2 files changed, 130 insertions(+), 38 deletions(-)

diff --git a/core/src/main/java/org/jruby/RubyMath.java b/core/src/main/java/org/jruby/RubyMath.java
index b4308f02a08..c56c5cfd819 100644
--- a/core/src/main/java/org/jruby/RubyMath.java
+++ b/core/src/main/java/org/jruby/RubyMath.java
@@ -40,7 +40,7 @@
 
 import static org.jruby.api.Convert.asFixnum;
 import static org.jruby.api.Convert.asFloat;
-import static org.jruby.api.Convert.toDouble;
+import static org.jruby.api.Convert.numToDouble;
 import static org.jruby.api.Convert.toInt;
 import static org.jruby.api.Create.newArray;
 import static org.jruby.api.Define.defineModule;
@@ -83,27 +83,27 @@ public static double sign(double x, double y) {
 
     @JRubyMethod(name = "atan2", module = true, visibility = Visibility.PRIVATE)
     public static RubyFloat atan2(ThreadContext context, IRubyObject recv, IRubyObject x, IRubyObject y) {
-        return asFloat(context, Math.atan2(toDouble(context, x), toDouble(context, y)));
+        return asFloat(context, Math.atan2(numToDouble(context, x), numToDouble(context, y)));
     }
 
     @JRubyMethod(name = "cos", module = true, visibility = Visibility.PRIVATE)
     public static RubyFloat cos(ThreadContext context, IRubyObject recv, IRubyObject x) {
-        return asFloat(context, Math.cos(toDouble(context, x)));
+        return asFloat(context, Math.cos(numToDouble(context, x)));
     }
 
     @JRubyMethod(name = "sin", module = true, visibility = Visibility.PRIVATE)
     public static RubyFloat sin(ThreadContext context, IRubyObject recv, IRubyObject x) {
-        return asFloat(context, Math.sin(toDouble(context, x)));
+        return asFloat(context, Math.sin(numToDouble(context, x)));
     }
 
     @JRubyMethod(name = "tan", module = true, visibility = Visibility.PRIVATE)
     public static RubyFloat tan(ThreadContext context, IRubyObject recv,  IRubyObject x) {
-        return asFloat(context, Math.tan(toDouble(context, x)));
+        return asFloat(context, Math.tan(numToDouble(context, x)));
     }
 
     @JRubyMethod(name = "asin", module = true, visibility = Visibility.PRIVATE)
     public static RubyFloat asin(ThreadContext context, IRubyObject recv, IRubyObject x) {
-        double value = toDouble(context, x);
+        double value = numToDouble(context, x);
 
         if (value < -1.0 || value > 1.0) throw context.runtime.newMathDomainError("asin");
 
@@ -112,7 +112,7 @@ public static RubyFloat asin(ThreadContext context, IRubyObject recv, IRubyObjec
 
     @JRubyMethod(name = "acos", module = true, visibility = Visibility.PRIVATE)
     public static RubyFloat acos(ThreadContext context, IRubyObject recv, IRubyObject x) {
-        double value = toDouble(context, x);
+        double value = numToDouble(context, x);
 
         if (value < -1.0 || value > 1.0) throw context.runtime.newMathDomainError("acos");
 
@@ -121,31 +121,31 @@ public static RubyFloat acos(ThreadContext context, IRubyObject recv, IRubyObjec
 
     @JRubyMethod(name = "atan", module = true, visibility = Visibility.PRIVATE)
     public static RubyFloat atan(ThreadContext context, IRubyObject recv, IRubyObject x) {
-        return asFloat(context, Math.atan(toDouble(context, x)));
+        return asFloat(context, Math.atan(numToDouble(context, x)));
     }
 
     @JRubyMethod(name = "cosh", module = true, visibility = Visibility.PRIVATE)
     public static RubyFloat cosh(ThreadContext context, IRubyObject recv, IRubyObject x) {
-        double value = toDouble(context, x);
+        double value = numToDouble(context, x);
         
         return asFloat(context, (Math.exp(value) + Math.exp(-value)) / 2.0);
     }
 
     @JRubyMethod(name = "sinh", module = true, visibility = Visibility.PRIVATE)
     public static RubyFloat sinh(ThreadContext context, IRubyObject recv, IRubyObject x) {
-        double value = toDouble(context, x);
+        double value = numToDouble(context, x);
         
         return asFloat(context, (Math.exp(value) - Math.exp(-value)) / 2.0);
     }
 
     @JRubyMethod(name = "tanh", module = true, visibility = Visibility.PRIVATE)
     public static RubyFloat tanh(ThreadContext context, IRubyObject recv, IRubyObject x) {
-        return asFloat(context, Math.tanh(toDouble(context, x)));
+        return asFloat(context, Math.tanh(numToDouble(context, x)));
     }
 
     @JRubyMethod(name = "acosh", module = true, visibility = Visibility.PRIVATE)
     public static RubyFloat acosh(ThreadContext context, IRubyObject recv, IRubyObject x) {
-        double value = toDouble(context, x);
+        double value = numToDouble(context, x);
         double result;
         
         if (Double.isNaN(value)) {
@@ -187,7 +187,7 @@ public static RubyFloat acosh(ThreadContext context, IRubyObject recv, IRubyObje
 
     @JRubyMethod(name = "asinh", module = true, visibility = Visibility.PRIVATE)
     public static RubyFloat asinh(ThreadContext context, IRubyObject recv, IRubyObject x) {
-        double value = toDouble(context, x);
+        double value = numToDouble(context, x);
         double  y = Math.abs(value);
         double result;
         
@@ -228,7 +228,7 @@ public static RubyFloat asinh(ThreadContext context, IRubyObject recv, IRubyObje
 
     @JRubyMethod(name = "atanh", module = true, visibility = Visibility.PRIVATE)
     public static RubyFloat atanh(ThreadContext context, IRubyObject recv, IRubyObject x) {
-        double value = toDouble(context, x);
+        double value = numToDouble(context, x);
 
         if (value < -1.0 || value > 1.0) throw context.runtime.newMathDomainError("atanh");
 
@@ -258,7 +258,7 @@ public static RubyFloat exp(ThreadContext context, IRubyObject recv, IRubyObject
     }
 
     public static RubyFloat exp(ThreadContext context, IRubyObject exponent) {
-        return asFloat(context, Math.exp(toDouble(context, exponent)));
+        return asFloat(context, Math.exp(numToDouble(context, exponent)));
     }
 
     // MRI : get_double_rshift
@@ -275,7 +275,7 @@ private static double[] get_double_rshift(ThreadContext context, IRubyObject x)
             }
         }
 
-        return new double[]{toDouble(context, x), numbits};
+        return new double[]{numToDouble(context, x), numbits};
     }
 
     private static int DBL_MANT_DIG = 53;
@@ -303,7 +303,7 @@ public static RubyFloat log(ThreadContext context, IRubyObject val) {
     @JRubyMethod(name = "log", module = true, visibility = Visibility.PRIVATE)
     public static RubyFloat log(ThreadContext context, IRubyObject recv, IRubyObject val, IRubyObject base) {
         double [] ret = get_double_rshift(context, val);
-        double _base = toDouble(context, base);
+        double _base = numToDouble(context, base);
 
         if (ret[0] < 0 || _base < 0) throw context.runtime.newMathDomainError("log");
 
@@ -343,7 +343,7 @@ public static RubyFloat log2(ThreadContext context, IRubyObject recv, IRubyObjec
 
     @JRubyMethod(name = "sqrt", module = true, visibility = Visibility.PRIVATE)
     public static RubyFloat sqrt(ThreadContext context, IRubyObject recv, IRubyObject x) {
-        double value = toDouble(context, x);
+        double value = numToDouble(context, x);
 
         if (value < 0) throw context.runtime.newMathDomainError("sqrt");
 
@@ -352,7 +352,7 @@ public static RubyFloat sqrt(ThreadContext context, IRubyObject recv, IRubyObjec
 
     @JRubyMethod(name = "cbrt", module = true, visibility = Visibility.PRIVATE)
     public static RubyFloat cbrt(ThreadContext context, IRubyObject recv, IRubyObject x) {
-        return asFloat(context, Math.cbrt(toDouble(context, x)));
+        return asFloat(context, Math.cbrt(numToDouble(context, x)));
     }
 
     @Deprecated(since = "10.0.0.0")
@@ -362,8 +362,8 @@ public static RubyFloat hypot19(ThreadContext context, IRubyObject recv, IRubyOb
 
     @JRubyMethod(name = "hypot", module = true, visibility = Visibility.PRIVATE)
     public static RubyFloat hypot(ThreadContext context, IRubyObject recv, IRubyObject x, IRubyObject y) {
-        double valuea = toDouble(context, x);
-        double valueb = toDouble(context, y);
+        double valuea = numToDouble(context, x);
+        double valueb = numToDouble(context, y);
         double result;
         
         if (Math.abs(valuea) > Math.abs(valueb)) {
@@ -390,7 +390,7 @@ public static RubyFloat hypot(ThreadContext context, IRubyObject recv, IRubyObje
      */
     @JRubyMethod(name = "frexp", module = true, visibility = Visibility.PRIVATE)
     public static RubyArray frexp(ThreadContext context, IRubyObject recv, IRubyObject other) {
-        double mantissa = toDouble(context, other);
+        double mantissa = numToDouble(context, other);
         short sign = 1;
         long exponent = 0;
 
@@ -416,7 +416,7 @@ public static RubyArray frexp(ThreadContext context, IRubyObject recv, IRubyObje
      */
     @JRubyMethod(name = "ldexp", module = true, visibility = Visibility.PRIVATE)
     public static RubyFloat ldexp(ThreadContext context, IRubyObject recv, IRubyObject mantissa, IRubyObject exponent) {
-        double m = toDouble(context, mantissa);
+        double m = numToDouble(context, mantissa);
         int e = toInt(context, exponent);
 
         return e > 1023 ? // avoid overflow. Math.power(2.0, 1024) is greater than Math.MAX_VALUE.
@@ -443,7 +443,7 @@ public static RubyFloat ldexp(ThreadContext context, IRubyObject recv, IRubyObje
 
     @JRubyMethod(name = "erf", module = true, visibility = Visibility.PRIVATE)
     public static RubyFloat erf(ThreadContext context, IRubyObject recv, IRubyObject x) {
-        double value = toDouble(context, x);
+        double value = numToDouble(context, x);
         double  y = Math.abs(value);
         double  result;
 
@@ -526,7 +526,7 @@ public static RubyFloat erf(ThreadContext context, IRubyObject recv, IRubyObject
 
     @JRubyMethod(name = "erfc", module = true, visibility = Visibility.PRIVATE)
     public static RubyFloat erfc(ThreadContext context, IRubyObject recv, IRubyObject x) {
-        double value = toDouble(context, x);
+        double value = numToDouble(context, x);
         double  result;
         double  y = Math.abs(value);
 
@@ -723,12 +723,12 @@ private static boolean negZero(final double x) {
 
     @JRubyMethod(module = true, visibility = Visibility.PRIVATE)
     public static IRubyObject expm1(ThreadContext context, IRubyObject unused, IRubyObject x) {
-        return asFloat(context, Math.expm1(toDouble(context, x)));
+        return asFloat(context, Math.expm1(numToDouble(context, x)));
     }
 
     @JRubyMethod(module = true, visibility = Visibility.PRIVATE)
     public static IRubyObject log1p(ThreadContext context, IRubyObject unused, IRubyObject x) {
-        double xDouble = toDouble(context, x);
+        double xDouble = numToDouble(context, x);
 
         if (xDouble < -1.0) {
             throw context.runtime.newMathDomainError("Numerical argument is out of domain - log1p");
diff --git a/core/src/main/java/org/jruby/api/Convert.java b/core/src/main/java/org/jruby/api/Convert.java
index b4adf37c973..dd5769e86f7 100644
--- a/core/src/main/java/org/jruby/api/Convert.java
+++ b/core/src/main/java/org/jruby/api/Convert.java
@@ -40,6 +40,7 @@
 import static org.jruby.api.Error.floatDomainError;
 import static org.jruby.api.Error.rangeError;
 import static org.jruby.api.Error.typeError;
+import static org.jruby.util.TypeConverter.convertToType;
 import static org.jruby.util.TypeConverter.convertToTypeWithCheck;
 import static org.jruby.util.TypeConverter.sites;
 
@@ -507,19 +508,110 @@ public static byte toByte(ThreadContext context, IRubyObject arg) {
     /**
      * Safely convert a Ruby Numeric into a java double value.  Raising if the value will not fit.
      * @param context the current thread context
-     * @param arg the Object to convert
+     * @param val the Object to convert
      * @return the value
      */
-    public static double toDouble(ThreadContext context, IRubyObject arg) {
-        return switch (arg) {
-            case RubyFloat flote -> flote.getValue();
-            case RubyInteger integer when Builtins.checkIntegerToF(context) -> integer.asDouble(context);
-            case RubyRational rational when Builtins.checkRationalToF(context) -> rational.asDouble(context);
-            case RubyString a -> throw typeError(context, "can't convert String to Float");
-            case RubyNil a -> throw typeError(context, "can't convert nil to Float");
-            case RubyBoolean a -> throw typeError(context, "can't convert " + (arg.isTrue() ? "true" : "false" + " to Float"));
-            default -> ((RubyFloat) TypeConverter.convertToType(arg, floatClass(context), "to_f")).getValue();
-        };
+    public static double toDouble(ThreadContext context, IRubyObject val) {
+        if (isSpecialConst(context, val)) {
+            switch (val) {
+                case RubyFixnum fixnum when Builtins.checkIntegerToF(context):
+                    return fixnum.asDouble(context);
+                case RubyFloat flote:
+                    return flote.getValue();
+                default:
+                    implicitConversionToFloat(context, val);
+            }
+        } else {
+            switch (val) {
+                case RubyFloat flote:
+                    return flote.getValue();
+                case RubyInteger integer when Builtins.checkIntegerToF(context):
+                    return integer.asDouble(context);
+                case RubyRational rational when Builtins.checkRationalToF(context):
+                    return rational.asDouble(context);
+                case RubyString a:
+                    throw typeError(context, "no implicit conversion to float from string");
+                default:
+                    // slow path below
+            }
+        }
+        return ((RubyFloat) TypeConverter.convertToType(val, floatClass(context), "to_f")).getValue();
+    }
+
+    // MRI: rb_num_to_dbl and Get_Double
+    /**
+     * Convert value to a double with appropriate optimizations and type checks.
+     *
+     * @param context the current thread context
+     * @param val the Object to convert
+     * @return the value
+     */
+    public static double numToDouble(ThreadContext context, IRubyObject val) {
+        if (isSpecialConst(context, val)) {
+            switch (val) {
+                case RubyFixnum fixnum:
+                    if (Builtins.checkIntegerToF(context)) {
+                        return fixnum.asDouble(context);
+                    }
+                    break;
+                case RubyFloat flote:
+                    return flote.getValue();
+                default:
+                    conversionToFloat(context, val);
+            }
+        } else {
+            switch (val) {
+                case RubyFloat flote:
+                    return flote.getValue();
+                case RubyInteger fixnum:
+                    if (Builtins.checkIntegerToF(context)) {
+                        return fixnum.asDouble(context);
+                    }
+                    break;
+                case RubyRational rational:
+                    if (Builtins.checkRationalToF(context))
+                        return rational.asDouble(context);
+                    break;
+                default:
+                    break;
+            }
+        }
+
+        return numericToFloat(context, val).getValue();
+    }
+
+    // MRI: SPECIAL_CONST_P, used to identify false and immediate values nil, true, fixnums, flonums, and symbols
+    private static boolean isSpecialConst(ThreadContext context, IRubyObject val) {
+        return val == context.fals || val.isImmediate();
+    }
+
+    // MRI: conversion_to_float
+    private static void conversionToFloat(ThreadContext context, IRubyObject val) {
+        specialConstToFloat(context, val, "can't convert ", " into Float");
+    }
+
+    // MRI: implicit_conversion_to_float
+    private static void implicitConversionToFloat(ThreadContext context, IRubyObject val) {
+        specialConstToFloat(context, val, "no implicit conversion to float from ", "");
+    }
+
+    private static void specialConstToFloat(ThreadContext context, IRubyObject val, String pre, String post) {
+        switch (val) {
+            case RubyNil nil:
+                throw typeError(context, pre + "nil" + post);
+            case RubyBoolean.True tru:
+                throw typeError(context, pre + "true" + post);
+            case RubyBoolean.False fals:
+                throw typeError(context, pre + "false" + post);
+            default:
+        }
+    }
+
+    private static RubyFloat numericToFloat(ThreadContext context, IRubyObject val) {
+        if (!(val instanceof RubyNumeric)) {
+            throw typeError(context, "can't convert " + val.getMetaClass() + " into Float");
+        }
+        return (RubyFloat) convertToTypeWithCheck(context, val, context.runtime.getFloat(), sites(context).to_f_checked);
     }
 
     // MRI: rb_num2long and FIX2LONG (numeric.c)

From b34cfb2d96238e18e922578d4f6e7dc8fcdc0c1a Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Fri, 23 Jan 2026 01:06:27 -0600
Subject: [PATCH 088/168] Correct immediate flag for core types

CRuby frequently checks if a given VALUE is "immediate", which
in their terms means it has no presence on the heap. We do not
have immediates in JRuby, but we mark these types as such for
optimizations that check for it.

* False is not immediate but True is, so lower that override.
* Float is both in CRuby, but we mark it immediate for fast-path
  logic that checks this.
---
 core/src/main/java/org/jruby/RubyBoolean.java | 10 +++++-----
 core/src/main/java/org/jruby/RubyFloat.java   |  5 +++++
 2 files changed, 10 insertions(+), 5 deletions(-)

diff --git a/core/src/main/java/org/jruby/RubyBoolean.java b/core/src/main/java/org/jruby/RubyBoolean.java
index 9383790c153..6bcb8ea0755 100644
--- a/core/src/main/java/org/jruby/RubyBoolean.java
+++ b/core/src/main/java/org/jruby/RubyBoolean.java
@@ -81,11 +81,6 @@ public ClassIndex getNativeClassIndex() {
         return (flags & FALSE) == 0 ? ClassIndex.TRUE : ClassIndex.FALSE;
     }
     
-    @Override
-    public boolean isImmediate() {
-        return true;
-    }
-
     public RubyClass singletonClass(ThreadContext context) {
         return metaClass;
     }
@@ -224,6 +219,11 @@ public <T> T toJava(Class<T> target) {
             }
             return super.toJava(target);
         }
+
+        @Override
+        public boolean isImmediate() {
+            return true;
+        }
     }
     
     @JRubyMethod(name = "hash")
diff --git a/core/src/main/java/org/jruby/RubyFloat.java b/core/src/main/java/org/jruby/RubyFloat.java
index 94f317d38ab..9a5bcdb54a5 100644
--- a/core/src/main/java/org/jruby/RubyFloat.java
+++ b/core/src/main/java/org/jruby/RubyFloat.java
@@ -1312,6 +1312,11 @@ public void appendIntoString(RubyString target) {
         target.catWithCodeRange((RubyString) to_s(getRuntime().getCurrentContext()));
     }
 
+    @Override
+    public boolean isImmediate() {
+        return true;
+    }
+
     @Deprecated(since = "9.2.0.0")
     public IRubyObject zero_p() {
         return zero_p(getCurrentContext());

From b49556e93a82b9373f96b6c91e4a70d643113b67 Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Fri, 23 Jan 2026 01:11:20 -0600
Subject: [PATCH 089/168] Remove another test previously deleted

---
 test/mri.stdlib.index | 1 -
 1 file changed, 1 deletion(-)

diff --git a/test/mri.stdlib.index b/test/mri.stdlib.index
index 6c70fe04b62..622a4732f6a 100644
--- a/test/mri.stdlib.index
+++ b/test/mri.stdlib.index
@@ -35,7 +35,6 @@ test_ipaddr.rb
 test_open3.rb
 test_pp.rb
 test_prettyprint.rb
-test_pstore.rb
 test_pty.rb
 test_rbconfig.rb
 test_securerandom.rb

From efcd1a2e9a4dba5ed595d203f0b26c915c2d79c0 Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Fri, 23 Jan 2026 01:20:23 -0600
Subject: [PATCH 090/168] Fix formatting of some MathDomainError messages

---
 core/src/main/java/org/jruby/Ruby.java       | 2 +-
 core/src/main/java/org/jruby/RubyBignum.java | 2 +-
 core/src/main/java/org/jruby/RubyFixnum.java | 2 +-
 core/src/main/java/org/jruby/RubyMath.java   | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/core/src/main/java/org/jruby/Ruby.java b/core/src/main/java/org/jruby/Ruby.java
index 66312ee049b..d172e925983 100644
--- a/core/src/main/java/org/jruby/Ruby.java
+++ b/core/src/main/java/org/jruby/Ruby.java
@@ -4399,7 +4399,7 @@ public RaiseException newFloatDomainError(String message){
     }
 
     public RaiseException newMathDomainError(String message) {
-        return newRaiseException(getMathDomainError(), "Numerical argument is out of domain - \"" + message + "\"");
+        return newRaiseException(getMathDomainError(), "Numerical argument is out of domain - " + message);
     }
 
     public RaiseException newEncodingError(String message){
diff --git a/core/src/main/java/org/jruby/RubyBignum.java b/core/src/main/java/org/jruby/RubyBignum.java
index 62526f4ed5f..8cc8343cbab 100644
--- a/core/src/main/java/org/jruby/RubyBignum.java
+++ b/core/src/main/java/org/jruby/RubyBignum.java
@@ -1332,7 +1332,7 @@ public RubyRational convertToRational(ThreadContext context) {
     // MRI: rb_int_s_isqrt, Fixnum portion
     @Override
     public IRubyObject sqrt(ThreadContext context) {
-        if (isNegativeNumber(context)) throw context.runtime.newMathDomainError("Numerical argument is out of domain - isqrt");
+        if (isNegativeNumber(context)) throw context.runtime.newMathDomainError("isqrt");
 
         return bignorm(context.runtime, floorSqrt(value));
     }
diff --git a/core/src/main/java/org/jruby/RubyFixnum.java b/core/src/main/java/org/jruby/RubyFixnum.java
index 087b3353339..e30a38af828 100644
--- a/core/src/main/java/org/jruby/RubyFixnum.java
+++ b/core/src/main/java/org/jruby/RubyFixnum.java
@@ -1607,7 +1607,7 @@ public IRubyObject remainder(ThreadContext context, IRubyObject y) {
     // MRI: rb_int_s_isqrt, Fixnum portion
     @Override
     public IRubyObject sqrt(ThreadContext context) {
-        if (isNegativeNumber(context)) throw context.runtime.newMathDomainError("Numerical argument is out of domain - isqrt");
+        if (isNegativeNumber(context)) throw context.runtime.newMathDomainError("isqrt");
 
         return asFixnum(context, floorSqrt(getValue()));
     }
diff --git a/core/src/main/java/org/jruby/RubyMath.java b/core/src/main/java/org/jruby/RubyMath.java
index c56c5cfd819..6d88443401a 100644
--- a/core/src/main/java/org/jruby/RubyMath.java
+++ b/core/src/main/java/org/jruby/RubyMath.java
@@ -731,7 +731,7 @@ public static IRubyObject log1p(ThreadContext context, IRubyObject unused, IRuby
         double xDouble = numToDouble(context, x);
 
         if (xDouble < -1.0) {
-            throw context.runtime.newMathDomainError("Numerical argument is out of domain - log1p");
+            throw context.runtime.newMathDomainError("log1p");
         }
 
         return asFloat(context, Math.log1p(xDouble));

From 97d9efabb3b7b6b870b785de0405d4d80a5dde87 Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Fri, 23 Jan 2026 03:36:56 -0600
Subject: [PATCH 091/168] Restore immediate status to False

We are using this to represent all core singleton literals (nil,
false, true), fixnum-ranged integers and all floats and symbols.
This restores immediate status to false.
---
 core/src/main/java/org/jruby/RubyBoolean.java | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/core/src/main/java/org/jruby/RubyBoolean.java b/core/src/main/java/org/jruby/RubyBoolean.java
index 6bcb8ea0755..9383790c153 100644
--- a/core/src/main/java/org/jruby/RubyBoolean.java
+++ b/core/src/main/java/org/jruby/RubyBoolean.java
@@ -81,6 +81,11 @@ public ClassIndex getNativeClassIndex() {
         return (flags & FALSE) == 0 ? ClassIndex.TRUE : ClassIndex.FALSE;
     }
     
+    @Override
+    public boolean isImmediate() {
+        return true;
+    }
+
     public RubyClass singletonClass(ThreadContext context) {
         return metaClass;
     }
@@ -219,11 +224,6 @@ public <T> T toJava(Class<T> target) {
             }
             return super.toJava(target);
         }
-
-        @Override
-        public boolean isImmediate() {
-            return true;
-        }
     }
     
     @JRubyMethod(name = "hash")

From e7ff21ebe95599b67cfad8ccc617bada64850ef0 Mon Sep 17 00:00:00 2001
From: Evan Brooks <evaniainbrooks@gmail.com>
Date: Thu, 29 Jan 2026 22:34:19 -0400
Subject: [PATCH 092/168] A Data object should be frozen even if it has no
 members

---
 core/src/main/java/org/jruby/RubyData.java | 2 ++
 spec/ruby/core/data/initialize_spec.rb     | 8 ++++++++
 2 files changed, 10 insertions(+)

diff --git a/core/src/main/java/org/jruby/RubyData.java b/core/src/main/java/org/jruby/RubyData.java
index f2fa5088c14..111151430d9 100644
--- a/core/src/main/java/org/jruby/RubyData.java
+++ b/core/src/main/java/org/jruby/RubyData.java
@@ -98,6 +98,8 @@ public static void initialize(ThreadContext context, IRubyObject self, IRubyObje
             if (numMembers > 0) {
                 throw keywordError(context, "missing", members);
             }
+
+            selfObj.setFrozen(true);
             return;
         }
 
diff --git a/spec/ruby/core/data/initialize_spec.rb b/spec/ruby/core/data/initialize_spec.rb
index 010c73b91b8..2f413de1ee4 100644
--- a/spec/ruby/core/data/initialize_spec.rb
+++ b/spec/ruby/core/data/initialize_spec.rb
@@ -2,6 +2,14 @@
 require_relative 'fixtures/classes'
 
 describe "Data#initialize" do
+  context "with no members" do
+    it "is frozen" do
+      data = Data.define
+
+      data.new.frozen?.should == true
+    end
+  end
+
   it "accepts positional arguments" do
     data = DataSpecs::Measure.new(42, "km")

From 0d0c1eba5e8b3320cc9859f9e40cbc3f2d725416 Mon Sep 17 00:00:00 2001
From: Herwin <herwinw@users.noreply.github.com>
Date: Tue, 3 Feb 2026 08:34:24 +0100
Subject: [PATCH 093/168] Add ruby_bug for spec of Data with no members being
 frozen

This makes the spec pass on Ruby 4.0.0 and earlies as well. This saves
some issues with the next spec sync.
---
 spec/ruby/core/data/initialize_spec.rb | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/spec/ruby/core/data/initialize_spec.rb b/spec/ruby/core/data/initialize_spec.rb
index 2f413de1ee4..786a0a59da4 100644
--- a/spec/ruby/core/data/initialize_spec.rb
+++ b/spec/ruby/core/data/initialize_spec.rb
@@ -3,10 +3,12 @@
 
 describe "Data#initialize" do
   context "with no members" do
-    it "is frozen" do
-      data = Data.define
+    ruby_bug "#21819", ""..."4.0.1" do
+      it "is frozen" do
+        data = Data.define
 
-      data.new.frozen?.should == true
+        data.new.frozen?.should == true
+      end
     end
   end

From b491f334f79eaa8026757b56284950ed298712f3 Mon Sep 17 00:00:00 2001
From: Herwin <herwinw@users.noreply.github.com>
Date: Tue, 3 Feb 2026 08:36:03 +0100
Subject: [PATCH 094/168] Rewrite spec for Data with no members being frozen

The style `.should.predicate?` is slightly more idiomatic, and seems to
be preferred (see https://github.com/ruby/mspec/issues/80 for a related
discussion).
---
 spec/ruby/core/data/initialize_spec.rb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/spec/ruby/core/data/initialize_spec.rb b/spec/ruby/core/data/initialize_spec.rb
index 786a0a59da4..74f0a05ce94 100644
--- a/spec/ruby/core/data/initialize_spec.rb
+++ b/spec/ruby/core/data/initialize_spec.rb
@@ -7,7 +7,7 @@
       it "is frozen" do
         data = Data.define
 
-        data.new.frozen?.should == true
+        data.new.should.frozen?
       end
     end
   end

From 506f5d40df4542876d05a98a248c98a81a770093 Mon Sep 17 00:00:00 2001
From: Herwin <herwinw@users.noreply.github.com>
Date: Tue, 3 Feb 2026 10:19:35 +0100
Subject: [PATCH 095/168] Remove Process::Status#& and Process::Status#>>

---
 core/src/main/java/org/jruby/RubyProcess.java | 54 -------------------
 1 file changed, 54 deletions(-)

diff --git a/core/src/main/java/org/jruby/RubyProcess.java b/core/src/main/java/org/jruby/RubyProcess.java
index c7bd163f798..9c0930d03c3 100644
--- a/core/src/main/java/org/jruby/RubyProcess.java
+++ b/core/src/main/java/org/jruby/RubyProcess.java
@@ -260,31 +260,6 @@ public static IRubyObject wait(ThreadContext context, IRubyObject self, IRubyObj
             //checkErrno(runtime, pid, ECHILD);
         }
 
-        @JRubyMethod(name = "&")
-        public IRubyObject op_and(ThreadContext context, IRubyObject arg) {
-            long mask = toInt(context, arg);
-
-            if (mask < 0) throw argumentError(context, "negative mask value: " + mask);
-            if (mask > Integer.MAX_VALUE || mask < Integer.MIN_VALUE) {
-                throw rangeError(context, "mask value out of range: " + mask);
-            }
-
-            String message = switch ((int) mask) {
-                case 0x80 -> "Process::Status#coredump?";
-                case 0x7f -> "Process::Status#signaled? or Process::Status#termsig";
-                case 0xff -> "Process::Status#exited?, Process::Status#stopped? or Process::Status#coredump?";
-                case 0xff00 -> "Process::Status#exitstatus or Process::Status#stopsig";
-                default -> "other Process::Status predicates";
-            };
-            deprecateAndSuggest(context, "Process::Status#&", "3.5", message);
-
-            return asFixnum(context, status & mask);
-        }
-
-        private static void deprecateAndSuggest(ThreadContext context, String method, String version, String suggest) {
-            context.runtime.getWarnings().warnDeprecatedForRemovalAlternate(method, version, suggest);
-        }
-
         @JRubyMethod(name = "stopped?")
         public IRubyObject stopped_p(ThreadContext context) {
             return asBoolean(context, PosixShim.WAIT_MACROS.WIFSTOPPED(status));
@@ -347,23 +322,6 @@ public IRubyObject exitstatus(ThreadContext context) {
                 asFixnum(context, PosixShim.WAIT_MACROS.WEXITSTATUS(status)) : context.nil;
         }
 
-        @JRubyMethod(name = ">>")
-        public IRubyObject op_rshift(ThreadContext context, IRubyObject other) {
-            long places = toInt(context, other);
-
-            if (places < 0) throw argumentError(context, "negative shift value: " + places);
-            if (places > Integer.MAX_VALUE) throw rangeError(context, "shift value out of range: " + places);
-
-            String message = switch ((int) places) {
-                case 7 -> "Process::Status#coredump?";
-                case 8 -> "Process::Status#exitstatus or Process::Status#stopsig";
-                default -> "other Process::Status attributes";
-            };
-            deprecateAndSuggest(context, "Process::Status#>>", "3.5", message);
-
-            return asFixnum(context, status >> places);
-        }
-
         @Override
         @JRubyMethod(name = "==")
         public IRubyObject op_equal(ThreadContext context, IRubyObject other) {
@@ -467,18 +425,6 @@ public static String pst_message(String prefix, long pid, long status) {
         public IRubyObject to_i() {
             return to_i(getCurrentContext().runtime);
         }
-
-        @Deprecated(since = "9.0.0.0")
-        public IRubyObject op_rshift(Ruby runtime, IRubyObject other) {
-            var context = getCurrentContext();
-            long shiftValue = toLong(context, other);
-            return asFixnum(context, status >> shiftValue);
-        }
-
-        @Deprecated(since = "10.0.0.0")
-        public IRubyObject op_and(IRubyObject arg) {
-            return op_and(getCurrentContext(), arg);
-        }
     }
 
     @JRubyModule(name="Process::UID")

From ed58f1045dea97015662911c54b71a719b1f087e Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Wed, 11 Feb 2026 15:38:17 -0600
Subject: [PATCH 096/168] Update Exception#cause behavior to match 4.0

* Detect circular causes
* Ignore specified cause when same as raise exception
* Allow 4th argument to Kernel (for cause: keyword args)

This also fixes some failures for Thread#raise and Fiber#raise.
---
 core/src/main/java/org/jruby/Ruby.java          |  5 +++--
 core/src/main/java/org/jruby/RubyException.java | 17 +++++++++++++++++
 core/src/main/java/org/jruby/RubyKernel.java    | 12 +++++++-----
 core/src/main/java/org/jruby/RubyThread.java    |  2 +-
 4 files changed, 28 insertions(+), 8 deletions(-)

diff --git a/core/src/main/java/org/jruby/Ruby.java b/core/src/main/java/org/jruby/Ruby.java
index d172e925983..371875c8cca 100644
--- a/core/src/main/java/org/jruby/Ruby.java
+++ b/core/src/main/java/org/jruby/Ruby.java
@@ -4460,12 +4460,13 @@ public RaiseException newBufferMaskError(String message) {
      * @return a new RaiseException wrapping a new Ruby exception
      */
     public RaiseException newRaiseException(RubyClass exceptionClass, String message) {
-        IRubyObject cause = getCurrentContext().getErrorInfo();
+        ThreadContext context = getCurrentContext();
+        IRubyObject cause = context.getErrorInfo();
 
         RaiseException exception = RaiseException.from(this, exceptionClass, message);
 
         if (cause != null && !cause.isNil()) {
-            exception.getException().setCause(cause);
+            exception.getException().setCause(context, cause);
         }
 
         return exception;
diff --git a/core/src/main/java/org/jruby/RubyException.java b/core/src/main/java/org/jruby/RubyException.java
index 9cdf133e42e..c49313d1131 100644
--- a/core/src/main/java/org/jruby/RubyException.java
+++ b/core/src/main/java/org/jruby/RubyException.java
@@ -495,6 +495,23 @@ public RaiseException toThrowable() {
     }
 
     public void setCause(IRubyObject cause) {
+        setCause(getRuntime().getCurrentContext(), cause);
+    }
+
+    public void setCause(ThreadContext context, IRubyObject cause) {
+        if (cause == this) {
+            this.cause = context.nil;
+            return;
+        }
+
+        Object c = cause;
+        while (c instanceof RubyException causeException) {
+            if (c == this) {
+                throw argumentError(context, "circular causes");
+            }
+            c = causeException.getCause();
+        }
+
         this.cause = cause;
 
         // don't do anything to throwable for null/nil cause to avoid forcing backtrace
diff --git a/core/src/main/java/org/jruby/RubyKernel.java b/core/src/main/java/org/jruby/RubyKernel.java
index 0005255049e..a0b7d5ebba3 100644
--- a/core/src/main/java/org/jruby/RubyKernel.java
+++ b/core/src/main/java/org/jruby/RubyKernel.java
@@ -1048,7 +1048,7 @@ public static IRubyObject raise(ThreadContext context, IRubyObject self, IRubyOb
             var exception = raise.getException();
 
             if (context.runtime.isDebug()) printExceptionSummary(context, exception);
-            if (exception.getCause() == null && cause != exception) exception.setCause(cause);
+            if (exception.getCause() == null && cause != exception) exception.setCause(context, cause);
 
             throwable = raise;
         }
@@ -1057,9 +1057,9 @@ public static IRubyObject raise(ThreadContext context, IRubyObject self, IRubyOb
         return null; // not reached
     }
 
-    @JRubyMethod(name = {"raise", "fail"}, optional = 3, checkArity = false, module = true, visibility = PRIVATE, omit = true)
+    @JRubyMethod(name = {"raise", "fail"}, optional = 4, checkArity = false, module = true, visibility = PRIVATE, omit = true)
     public static IRubyObject raise(ThreadContext context, IRubyObject recv, IRubyObject[] args, Block block) {
-        int argc = Arity.checkArgumentCount(context, args, 0, 3);
+        int argc = args.length;
         boolean forceCause = false;
 
         // semi extract_raise_opts :
@@ -1078,6 +1078,8 @@ public static IRubyObject raise(ThreadContext context, IRubyObject recv, IRubyOb
             }
         }
 
+        Arity.checkArgumentCount(context, argc, 0, 3);
+
         if ( argc > 0 ) { // for argc == 0 we will be raising $!
             // NOTE: getErrorInfo needs to happen before new RaiseException(...)
             if ( cause == null ) cause = context.getErrorInfo(); // returns nil for no error-info
@@ -1099,7 +1101,7 @@ public static IRubyObject raise(ThreadContext context, IRubyObject recv, IRubyOb
                     break;
                 case 1:
                     if (args[0] instanceof RubyString) {
-                        raise = ((RubyException) runtimeErrorClass(context).newInstance(context, args, block)).toThrowable();
+                        raise = ((RubyException) runtimeErrorClass(context).newInstance(context, args[0], block)).toThrowable();
                     } else {
                         raise = convertToException(context, args[0], null).toThrowable();
                     }
@@ -1116,7 +1118,7 @@ public static IRubyObject raise(ThreadContext context, IRubyObject recv, IRubyOb
 
             var exception = raise.getException();
             if (context.runtime.isDebug()) printExceptionSummary(context, exception);
-            if (forceCause || argc > 0 && exception.getCause() == null && cause != exception) exception.setCause(cause);
+            if (forceCause || argc > 0 && exception.getCause() == null && cause != exception) exception.setCause(context, cause);
 
             throwable = raise;
         }
diff --git a/core/src/main/java/org/jruby/RubyThread.java b/core/src/main/java/org/jruby/RubyThread.java
index 4e51f0f05fa..e4e79d3f7cc 100644
--- a/core/src/main/java/org/jruby/RubyThread.java
+++ b/core/src/main/java/org/jruby/RubyThread.java
@@ -1610,7 +1610,7 @@ public static IRubyObject prepareRaiseException(ThreadContext context, IRubyObje
                 }
                 cur = curException.getCause();
             }
-            exception.setCause(cause);
+            exception.setCause(context, cause);
         }
 
         return exception;

From 078bb4de50722ab25ccbb835a2e081e20a35c0b4 Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Wed, 11 Feb 2026 17:27:43 -0600
Subject: [PATCH 097/168] Modify our exception test to match CRuby 4 behavior

---
 test/jruby/test_exception.rb | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/test/jruby/test_exception.rb b/test/jruby/test_exception.rb
index 9502608188b..5d6daa31a23 100644
--- a/test/jruby/test_exception.rb
+++ b/test/jruby/test_exception.rb
@@ -18,7 +18,7 @@ def test_good_stack_trace
     begin
       rescue_an_error
     rescue RuntimeError => e
-      assert_match(/'raise_an_error'/, e.backtrace[0])
+      assert_match(/raise_an_error/, e.backtrace[0])
     end
   end
 
@@ -35,10 +35,9 @@ def test_circular_cause_handle
     begin
       raise_circular_cause
     rescue => e
-      assert_match(/'raise_circular_cause'/, e.backtrace[0])
-      assert_equal(e.message, "error 1")
-      assert_equal(e.cause.message, "error 2")
-      assert_equal(e.cause.cause.message, "error 1")
+      assert_match(/raise_circular_cause/, e.backtrace[0])
+      assert_equal("circular causes", e.message)
+      assert_equal("error 1", e.cause.message)
     end
   end
 end

From 1b25b3996f5ba133f08bdfe4e082fc6313ae8ac7 Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Thu, 12 Feb 2026 16:31:37 -0600
Subject: [PATCH 098/168] Use capitalized Class and Module for frozen errors

---
 core/src/main/java/org/jruby/RubyModule.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/core/src/main/java/org/jruby/RubyModule.java b/core/src/main/java/org/jruby/RubyModule.java
index fd01d368fef..c6e615b381a 100644
--- a/core/src/main/java/org/jruby/RubyModule.java
+++ b/core/src/main/java/org/jruby/RubyModule.java
@@ -1924,7 +1924,7 @@ public IRubyObject singleton_class_p(ThreadContext context) {
     }
 
     private String frozenType() {
-        return isClass() ? "class" : "module";
+        return isClass() ? "Class" : "Module";
     }
 
     @Deprecated(since = "10.0.0.0")
@@ -6356,7 +6356,7 @@ private void checkAndRaiseIfFrozen(ThreadContext context) throws RaiseException
     @Override
     public final void checkFrozen() {
        if ( isFrozen() ) {
-           throw getRuntime().newFrozenError(isClass() ? "class" : "module", this);
+           throw getRuntime().newFrozenError(frozenType(), this);
        }
     }

From 4743855a51eb33a496c968a0e0f4667836626401 Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Thu, 12 Feb 2026 17:18:29 -0600
Subject: [PATCH 099/168] Properly handle keywords in
 {Kernel|Thread|Fiber}#raise

Any code calling these methods from Java and wishing to pass the
cause: keyword must set callInfo.
---
 core/src/main/java/org/jruby/RubyKernel.java  |  5 ++--
 core/src/main/java/org/jruby/RubyThread.java  | 26 ++++++++++++-------
 .../java/org/jruby/ext/fiber/ThreadFiber.java |  2 +-
 3 files changed, 20 insertions(+), 13 deletions(-)

diff --git a/core/src/main/java/org/jruby/RubyKernel.java b/core/src/main/java/org/jruby/RubyKernel.java
index a0b7d5ebba3..df6ce77b233 100644
--- a/core/src/main/java/org/jruby/RubyKernel.java
+++ b/core/src/main/java/org/jruby/RubyKernel.java
@@ -1057,14 +1057,15 @@ public static IRubyObject raise(ThreadContext context, IRubyObject self, IRubyOb
         return null; // not reached
     }
 
-    @JRubyMethod(name = {"raise", "fail"}, optional = 4, checkArity = false, module = true, visibility = PRIVATE, omit = true)
+    @JRubyMethod(name = {"raise", "fail"}, optional = 4, checkArity = false, module = true, visibility = PRIVATE, omit = true, keywords = true)
     public static IRubyObject raise(ThreadContext context, IRubyObject recv, IRubyObject[] args, Block block) {
         int argc = args.length;
         boolean forceCause = false;
 
         // semi extract_raise_opts :
+        int callInfo = ThreadContext.resetCallInfo(context);
         IRubyObject cause = null;
-        if (argc > 0) {
+        if (ThreadContext.hasNonemptyKeywords(callInfo) && argc > 0) {
             IRubyObject last = args[argc - 1];
             if (last instanceof RubyHash opt) {
                 RubySymbol key;
diff --git a/core/src/main/java/org/jruby/RubyThread.java b/core/src/main/java/org/jruby/RubyThread.java
index e4e79d3f7cc..ce6b2668fbc 100644
--- a/core/src/main/java/org/jruby/RubyThread.java
+++ b/core/src/main/java/org/jruby/RubyThread.java
@@ -300,9 +300,13 @@ private void executeInterrupts(ThreadContext context, boolean blockingTiming) {
                     if (getStatus() == Status.SLEEP) exitSleep();
 
                     // if it's a Ruby exception, force the cause through
-                    IRubyObject[] args = err instanceof RubyException exc ?
-                            Helpers.arrayOf(err, RubyHash.newKwargs(runtime, "cause", exc.cause(context))) :
-                            Helpers.arrayOf(err);
+                    IRubyObject[] args;
+                    if (err instanceof RubyException exc ) {
+                        context.callInfo = ThreadContext.CALL_KEYWORD;
+                        args = Helpers.arrayOf(err, RubyHash.newKwargs(runtime, "cause", exc.cause(context)));
+                    } else {
+                        args = Helpers.arrayOf(err);
+                    }
                     RubyKernel.raise(context, this, args, Block.NULL_BLOCK);
                 }
             }
@@ -1492,10 +1496,8 @@ public final IRubyObject raise(IRubyObject exception, RubyString message) {
         return genericRaise(context, context.getThread(), exception, message);
     }
 
-    @JRubyMethod(optional = 4, checkArity = false)
+    @JRubyMethod(optional = 4, checkArity = false, keywords = true)
     public IRubyObject raise(ThreadContext context, IRubyObject[] args, Block block) {
-        Arity.checkArgumentCount(context, args, 0, 4);
-
         return genericRaise(context, context.getThread(), args);
     }
 
@@ -1521,7 +1523,10 @@ public IRubyObject native_thread_id(ThreadContext context) {
     }
 
     private IRubyObject genericRaise(ThreadContext context, RubyThread currentThread, IRubyObject... args) {
-        if (!isAlive()) return context.nil;
+        if (!isAlive()) {
+            ThreadContext.resetCallInfo(context);
+            return context.nil;
+        }
 
         pendingInterruptEnqueue(prepareRaiseException(context, args));
         interrupt();
@@ -1534,14 +1539,14 @@ private IRubyObject genericRaise(ThreadContext context, RubyThread currentThread
     }
 
     public static IRubyObject prepareRaiseException(ThreadContext context, IRubyObject[] args) {
+        int argc = args.length;
         IRubyObject errorInfo = context.getErrorInfo();
-
-        int argc = Arity.checkArgumentCount(context, args, 0, 4);
         IRubyObject tmp =  context.nil;
 
         // semi extract_raise_opts, duplicated from RubyKernel.raise
+        int callInfo = ThreadContext.resetCallInfo(context);
         IRubyObject cause = null;
-        if (argc > 0) {
+        if (ThreadContext.hasNonemptyKeywords(callInfo) && argc > 0) {
             IRubyObject last = args[argc - 1];
             if (last instanceof RubyHash opt) {
                 RubySymbol key;
@@ -1553,6 +1558,7 @@ public static IRubyObject prepareRaiseException(ThreadContext context, IRubyObje
                 }
             }
         }
+        Arity.checkArgumentCount(context, argc, 0, 3);
 
         switch (argc) {
             case 0:
diff --git a/core/src/main/java/org/jruby/ext/fiber/ThreadFiber.java b/core/src/main/java/org/jruby/ext/fiber/ThreadFiber.java
index 33886a71db0..f18c1d05d30 100644
--- a/core/src/main/java/org/jruby/ext/fiber/ThreadFiber.java
+++ b/core/src/main/java/org/jruby/ext/fiber/ThreadFiber.java
@@ -227,7 +227,7 @@ private static void fiberCalledAcrossThreads(Ruby runtime) {
         throw runtime.newFiberError("fiber called across threads");
     }
 
-    @JRubyMethod(optional = 4)
+    @JRubyMethod(optional = 4, checkArity = false, keywords = true)
     public IRubyObject raise(ThreadContext context, IRubyObject[] args) {
         return raise(context, RubyThread.prepareRaiseException(context, args));
     }

From 2616578076cd5cf0480e6f3244e8f141b1424f72 Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Fri, 13 Feb 2026 10:09:30 -0600
Subject: [PATCH 100/168] Guard against Ruby::Box accesses

See ruby/ruby#16172
---
 test/mri/ruby/test_autoload.rb | 24 +++++++++++++++---------
 1 file changed, 15 insertions(+), 9 deletions(-)

diff --git a/test/mri/ruby/test_autoload.rb b/test/mri/ruby/test_autoload.rb
index 50949274a36..feadafc2e52 100644
--- a/test/mri/ruby/test_autoload.rb
+++ b/test/mri/ruby/test_autoload.rb
@@ -224,17 +224,21 @@ def ruby_impl_require
     Kernel.module_eval do
       alias old_require require
     end
-    Ruby::Box.module_eval do
-      alias old_require require
+    if defined?(Ruby::Box)
+      Ruby::Box.module_eval do
+        alias old_require require
+      end
     end
     called_with = []
     Kernel.send :define_method, :require do |path|
       called_with << path
       old_require path
     end
-    Ruby::Box.send :define_method, :require do |path|
-      called_with << path
-      old_require path
+    if defined?(Ruby::Box)
+      Ruby::Box.send :define_method, :require do |path|
+        called_with << path
+        old_require path
+      end
     end
     yield called_with
   ensure
@@ -243,10 +247,12 @@ def ruby_impl_require
       alias require old_require
       undef old_require
     end
-    Ruby::Box.module_eval do
-      undef require
-      alias require old_require
-      undef old_require
+    if defined?(Ruby::Box)
+      Ruby::Box.module_eval do
+        undef require
+        alias require old_require
+        undef old_require
+      end
     end
   end

From 3732a82d5418c0642511bd07541cbc54f24b6ba5 Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Fri, 13 Feb 2026 21:35:56 -0600
Subject: [PATCH 101/168] Implement CRuby 4.0 Bignum slicing

This is a clean-room impl of the rb_big_aref2 logic in CRuby based
on tests and documentation.
---
 core/src/main/java/org/jruby/RubyBignum.java | 24 ++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/core/src/main/java/org/jruby/RubyBignum.java b/core/src/main/java/org/jruby/RubyBignum.java
index 8cc8343cbab..a84b7ecac69 100644
--- a/core/src/main/java/org/jruby/RubyBignum.java
+++ b/core/src/main/java/org/jruby/RubyBignum.java
@@ -905,6 +905,30 @@ protected IRubyObject op_aref_subclass(ThreadContext context, IRubyObject other)
         return asFixnum(context, value.testBit((int)position) ? 1: 0);
     }
 
+    // MRI: rb_big_aref2
+    @Override
+    public IRubyObject op_aref(ThreadContext context, IRubyObject index, IRubyObject length) {
+        long shift = index.convertToInteger().asLong(context);
+        if (shift >= Integer.MAX_VALUE) {
+            throw rangeError(context, "offset too big");
+        }
+        if (shift <= Integer.MIN_VALUE) {
+            return RubyFixnum.zero(context.runtime);
+        }
+        BigInteger shifted = value.shiftRight((int) shift);
+        long bitLength = length.convertToInteger().asLong(context);
+        long len = bitLength;
+        if (value.signum() > 0) {
+            len = Math.min(bitLength, shifted.bitLength());
+        }
+        if (len >= Integer.MAX_VALUE) {
+            throw rangeError(context, "length too big");
+        }
+        BigInteger mask = BigInteger.ONE.shiftLeft((int) bitLength).subtract(BigInteger.ONE);
+        BigInteger slice = shifted.and(mask);
+        return bignorm(context.runtime, slice);
+    }
+
     private enum BIGNUM_OP_T {
         BIGNUM_OP_GT,
         BIGNUM_OP_GE,

From 31b2971bef7f6868f2613d1ef41ab4ffe99d6f0d Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Fri, 13 Feb 2026 21:59:17 -0600
Subject: [PATCH 102/168] Allow instance variable names for Data

---
 core/src/main/java/org/jruby/RubyData.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/core/src/main/java/org/jruby/RubyData.java b/core/src/main/java/org/jruby/RubyData.java
index f26544addb6..1e685cbc203 100644
--- a/core/src/main/java/org/jruby/RubyData.java
+++ b/core/src/main/java/org/jruby/RubyData.java
@@ -125,7 +125,7 @@ public static void initialize(ThreadContext context, IRubyObject self, IRubyObje
             String keyString = toSymbol(context, k).idString();
             VariableAccessor variableAccessor = variableAccessors.get(keyString);
             if (variableAccessor != null) {
-                selfObj.setInternalVariable(keyString, v);
+                selfObj.setInstanceVariable(keyString, v);
             } else {
                 RubyArray unknownKeywords = unknownKeywordsPtr[0];
                 if (unknownKeywords == null) {

From 8c367c54384989527d0eee65449cc5639aa21136 Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Fri, 13 Feb 2026 22:07:09 -0600
Subject: [PATCH 103/168] Don't mutate either set while doing xor

---
 core/src/main/java/org/jruby/ext/set/RubySet.java | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/core/src/main/java/org/jruby/ext/set/RubySet.java b/core/src/main/java/org/jruby/ext/set/RubySet.java
index 845ad557781..83c795b6cfa 100644
--- a/core/src/main/java/org/jruby/ext/set/RubySet.java
+++ b/core/src/main/java/org/jruby/ext/set/RubySet.java
@@ -861,14 +861,15 @@ IRubyObject yieldImpl(ThreadContext context, IRubyObject obj) {
      */
     @JRubyMethod(name = "^")
     public IRubyObject op_xor(final ThreadContext context, IRubyObject enume) {
-        RubySet newSet;
+        RubySet newSet = (RubySet) dup(context);
+        RubySet otherSet;
         if (enume instanceof RubySet set) {
-            newSet = set;
+            otherSet = set;
         } else {
-            newSet = new RubySet(context.runtime, getMetaClass(), false);
-            newSet.initialize(context, enume, Block.NULL_BLOCK); // Set.new(enum)
+            otherSet = new RubySet(context.runtime, getMetaClass(), false);
+            otherSet.initialize(context, enume, Block.NULL_BLOCK); // Set.new(enum)
         }
-        for (IRubyObject o : elementsOrdered()) {
+        for (IRubyObject o : otherSet.elementsOrdered()) {
             if (newSet.containsImpl(o)) {
                 newSet.deleteImpl(o); // exclusive or
             } else {

From 88331a6db9d2ae06eeaa04567b3c2289142a5275 Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Fri, 13 Feb 2026 22:10:12 -0600
Subject: [PATCH 104/168] Exclude aliased global variable deprecation tests

See jruby/jruby#9177
---
 test/mri/excludes/TestString.rb | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/test/mri/excludes/TestString.rb b/test/mri/excludes/TestString.rb
index e38a9ca0e98..ee16aaf5085 100644
--- a/test/mri/excludes/TestString.rb
+++ b/test/mri/excludes/TestString.rb
@@ -40,3 +40,5 @@
 exclude :test_undump, "unfinished in initial 2.6 work, #6161"
 exclude :test_undump_gc_compact_stress, "GC is not configurable"
 exclude :test_uplus_minus, "only seems to fail in a full test run"
+exclude :test_fs, "aliased globals do not know their new name (https://github.com/jruby/jruby/issues/9177)"
+exclude :test_rs, "aliased globals do not know their new name (https://github.com/jruby/jruby/issues/9177)"

From 5d72958729e657bf0fa57aebfe13ddd77dd27ca5 Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Sat, 14 Feb 2026 00:23:46 -0600
Subject: [PATCH 105/168] Fix another error capitalization change

---
 core/src/main/java/org/jruby/RubyBasicObject.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/core/src/main/java/org/jruby/RubyBasicObject.java b/core/src/main/java/org/jruby/RubyBasicObject.java
index 3e0b322cacb..9cd5355592c 100644
--- a/core/src/main/java/org/jruby/RubyBasicObject.java
+++ b/core/src/main/java/org/jruby/RubyBasicObject.java
@@ -315,7 +315,7 @@ protected final void testFrozen(String message) {
    protected final void testFrozen() {
        if (isFrozen()) {
            var context = getRuntime().getCurrentContext();
-           throw context.runtime.newFrozenError((isClass() ? "Class: " : (isModule() ? "Module: " : "object: ")) + inspect(context), this);
+           throw context.runtime.newFrozenError((isClass() ? "Class: " : (isModule() ? "Module: " : "Object: ")) + inspect(context), this);
        }
    }

From e03966ef8978b698fee9504375b65e1023dc5268 Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Sat, 14 Feb 2026 00:24:44 -0600
Subject: [PATCH 106/168] Eagerly init copied module/class

See https://github.com/ruby/ruby/pull/14412
---
 core/src/main/java/org/jruby/RubyBasicObject.java |  1 +
 core/src/main/java/org/jruby/RubyClass.java       | 13 ++++---------
 core/src/main/java/org/jruby/RubyModule.java      | 12 +++++++-----
 3 files changed, 12 insertions(+), 14 deletions(-)

diff --git a/core/src/main/java/org/jruby/RubyBasicObject.java b/core/src/main/java/org/jruby/RubyBasicObject.java
index 9cd5355592c..50bcbf45556 100644
--- a/core/src/main/java/org/jruby/RubyBasicObject.java
+++ b/core/src/main/java/org/jruby/RubyBasicObject.java
@@ -905,6 +905,7 @@ private static void initCopy(ThreadContext context, IRubyObject clone, IRubyObje
             RubyModule cloneMod = (RubyModule)clone;
             cloneMod.syncConstants((RubyModule)original);
             cloneMod.syncClassVariables((RubyModule)original);
+            cloneMod.initializeCopiedModule(context, original);
         }
     }
 
diff --git a/core/src/main/java/org/jruby/RubyClass.java b/core/src/main/java/org/jruby/RubyClass.java
index c7049e5ecb2..e223b20de5c 100644
--- a/core/src/main/java/org/jruby/RubyClass.java
+++ b/core/src/main/java/org/jruby/RubyClass.java
@@ -1099,16 +1099,11 @@ private void copyVariableTableManagerForData(ThreadContext context, RubyClass su
         }
     }
 
-    /** rb_class_init_copy
-     *
+    /**
+     * Class-specific logic for {@link RubyModule#initializeCopiedModule(ThreadContext, IRubyObject)}
      */
-    @JRubyMethod(name = "initialize_copy", visibility = PRIVATE)
-    public IRubyObject initialize_copy(ThreadContext context, IRubyObject original) {
-        checkNotInitialized(context);
-        if (original == basicObjectClass(context)) throw typeError(context, "can't copy the root class");
-        if (original instanceof MetaClass) throw typeError(context, "can't copy singleton class");
-
-        super.initialize_copy(context, original);
+    public IRubyObject initializeCopiedModule(ThreadContext context, IRubyObject original) {
+        super.initializeCopiedModule(context, original);
         RubyClass originalClazz = (RubyClass) original;
         allocator = originalClazz.allocator;
 
diff --git a/core/src/main/java/org/jruby/RubyModule.java b/core/src/main/java/org/jruby/RubyModule.java
index c6e615b381a..98931f38432 100644
--- a/core/src/main/java/org/jruby/RubyModule.java
+++ b/core/src/main/java/org/jruby/RubyModule.java
@@ -3122,12 +3122,14 @@ protected final IRubyObject cloneMethods(ThreadContext context, RubyModule clone
         return clone;
     }
 
-    /** mri: rb_mod_init_copy
+    /**
+     * mri: rb_mod_init_copy
      *
+     * This no longer overrides {@link RubyBasicObject#initialize_copy(ThreadContext, IRubyObject)} to ensure a cloned
+     * class or module is internally initialized before calling any user `initialize_copy` that might be defined.
      */
-    @JRubyMethod(name = "initialize_copy", visibility = Visibility.PRIVATE)
-    public IRubyObject initialize_copy(ThreadContext context, IRubyObject original) {
-        if (this instanceof RubyClass klazz) checkSafeTypeToCopy(context, klazz);
+    public IRubyObject initializeCopiedModule(ThreadContext context, IRubyObject original) {
+        if (original instanceof RubyClass klazz) checkSafeTypeToCopy(context, klazz);
 
         super.initialize_copy(context, original);
 
@@ -3152,7 +3154,7 @@ private void checkSafeTypeToCopy(ThreadContext context, RubyClass original) {
         var BasicObject = basicObjectClass(context);
         if (original == BasicObject) throw typeError(context, "can't copy the root class");
         if (getSuperClass() == BasicObject) throw typeError(context, "already initialized class");
-        if (original.isSingleton()) throw typeError(context, "can't copy singleton class");
+        if (original instanceof MetaClass) throw typeError(context, "can't copy singleton class");
     }
 
     public void syncConstants(RubyModule other) {

From 163629e29815d53d8ee40ceca2bbce0c92772160 Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Sat, 14 Feb 2026 00:26:22 -0600
Subject: [PATCH 107/168] Fix inspect recursion logic to match CRuby

---
 .../main/java/org/jruby/RubyBasicObject.java  | 24 ++++++++-----------
 1 file changed, 10 insertions(+), 14 deletions(-)

diff --git a/core/src/main/java/org/jruby/RubyBasicObject.java b/core/src/main/java/org/jruby/RubyBasicObject.java
index 50bcbf45556..3a89433007b 100644
--- a/core/src/main/java/org/jruby/RubyBasicObject.java
+++ b/core/src/main/java/org/jruby/RubyBasicObject.java
@@ -1133,7 +1133,7 @@ public IRubyObject inspect() {
     // MRI: rb_obj_inspect
     public IRubyObject inspect(ThreadContext context) {
         return !isImmediate() && !(this instanceof RubyModule) && hasVariables() ?
-                hashyInspect(context) : to_s(context);
+                hashyInspect(context) : Convert.anyToString(context, this);
     }
 
     @Deprecated(since = "10.1.0.0")
@@ -1150,18 +1150,9 @@ public final IRubyObject hashyInspect(ThreadContext context) {
 
         RubyString part = inspectPrefix(context, metaClass.getRealClass(), inspectHashCode());
 
-        Ruby runtime = context.runtime;
-
-        if (runtime.isInspecting(this)) {
-            encStrBufCat(runtime, part, SPACE_DOT_DOT_DOT_GT);
-            return part;
-        }
-        try {
-            runtime.registerInspecting(this);
-            return inspectObj(context, part, ivars);
-        } finally {
-            runtime.unregisterInspecting(this);
-        }
+        return context.safeRecurse(
+                (ctx, p, obj, recur) -> inspectObj(ctx, p, ivars, recur),
+                part, this, "inspect", true);
     }
 
     // MRI: rb_inspect, which does dispatch
@@ -1199,9 +1190,14 @@ protected int inspectHashCode() {
      * The internal helper method that takes care of the part of the
      * inspection that inspects instance variables.
      */
-    private RubyString inspectObj(final ThreadContext context, RubyString part, IRubyObject ivars) {
+    private RubyString inspectObj(final ThreadContext context, RubyString part, IRubyObject ivars, boolean recur) {
         Ruby runtime = context.runtime;
 
+        if (recur) {
+            encStrBufCat(runtime, part, SPACE_DOT_DOT_DOT_GT);
+            return part;
+        }
+
         if (ivars == null || ivars.isNil()) {
             // no ivars specified, do all of them
             boolean first = true;

From f81eb73a1b80c2936be2a3bbfa68fe539c4930cc Mon Sep 17 00:00:00 2001
From: Evan Brooks <evaniainbrooks@gmail.com>
Date: Sun, 15 Feb 2026 11:34:00 -0400
Subject: [PATCH 108/168] Fix for cloned class singleton class has too many
 ancestors

---
 core/src/main/java/org/jruby/RubyBasicObject.java | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/core/src/main/java/org/jruby/RubyBasicObject.java b/core/src/main/java/org/jruby/RubyBasicObject.java
index 3a89433007b..0b343857fd6 100644
--- a/core/src/main/java/org/jruby/RubyBasicObject.java
+++ b/core/src/main/java/org/jruby/RubyBasicObject.java
@@ -1029,7 +1029,13 @@ protected RubyClass getSingletonClassCloneAndAttach(ThreadContext context, RubyB
         MetaClass clone = new MetaClass(context.runtime, klass.getSuperClass(), attach);
         clone.flags = klass.flags;
 
-        clone.setMetaClass(this instanceof RubyClass ? clone : klass.getSingletonClassCloneAndAttach(context, null));
+        if (this instanceof RubyClass) {
+            clone.setMetaClass(clone);
+        } else {
+            MetaClass metaClone = (MetaClass) klass.getSingletonClassCloneAndAttach(context, null);
+            clone.setMetaClass(metaClone);
+            metaClone.setAttached(clone);
+        }
 
         if (klass.hasVariables()) clone.syncVariables(klass);
 
@@ -1037,8 +1043,6 @@ protected RubyClass getSingletonClassCloneAndAttach(ThreadContext context, RubyB
 
         klass.cloneMethods(context, clone);
 
-        ((MetaClass) clone.getMetaClass()).setAttached(clone);
-
         return clone;
     }

From 0e8bc2380818e38552f6d4793f1466309fd6ee67 Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Sat, 14 Feb 2026 00:37:32 -0600
Subject: [PATCH 109/168] Remove commented code

---
 core/src/main/java/org/jruby/ir/runtime/IRRuntimeHelpers.java | 2 --
 1 file changed, 2 deletions(-)

diff --git a/core/src/main/java/org/jruby/ir/runtime/IRRuntimeHelpers.java b/core/src/main/java/org/jruby/ir/runtime/IRRuntimeHelpers.java
index 8ef56a89fec..64da2c58673 100644
--- a/core/src/main/java/org/jruby/ir/runtime/IRRuntimeHelpers.java
+++ b/core/src/main/java/org/jruby/ir/runtime/IRRuntimeHelpers.java
@@ -1851,8 +1851,6 @@ private static RubyClass checkClassForDef(ThreadContext context, String id, IRub
                     ids(context.runtime, id), "\" for ", obj.getMetaClass().rubyBaseName(context)));
         }
 
-        // if (obj.isFrozen()) throw context.runtime.newFrozenError("object");
-
         return obj.singletonClass(context);
     }

From b42564d09d10db174557b593564016a6e2885229 Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Tue, 17 Feb 2026 22:16:04 -0600
Subject: [PATCH 110/168] Restore overridden to_s call

The infinite recursion happening before seems to have been a side
effect of adding too many metaclasses into the hierarchy when
getting the singleton class of a class (see jruby/jruby#9238, fixed
by jruby/jruby#9239).
---
 core/src/main/java/org/jruby/RubyBasicObject.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/core/src/main/java/org/jruby/RubyBasicObject.java b/core/src/main/java/org/jruby/RubyBasicObject.java
index 0b343857fd6..7c4e5a3d09d 100644
--- a/core/src/main/java/org/jruby/RubyBasicObject.java
+++ b/core/src/main/java/org/jruby/RubyBasicObject.java
@@ -1137,7 +1137,7 @@ public IRubyObject inspect() {
     // MRI: rb_obj_inspect
     public IRubyObject inspect(ThreadContext context) {
         return !isImmediate() && !(this instanceof RubyModule) && hasVariables() ?
-                hashyInspect(context) : Convert.anyToString(context, this);
+                hashyInspect(context) : to_s(context);
     }
 
     @Deprecated(since = "10.1.0.0")

From 8d1fd29303fd9e66931b2f23b9325f044a0f4405 Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Tue, 17 Feb 2026 22:50:53 -0600
Subject: [PATCH 111/168] Fix bad merge of require_spec

---
 spec/ruby/core/kernel/require_spec.rb | 13 ++++++-------
 1 file changed, 6 insertions(+), 7 deletions(-)

diff --git a/spec/ruby/core/kernel/require_spec.rb b/spec/ruby/core/kernel/require_spec.rb
index 852919fd7bc..60d17242fe1 100644
--- a/spec/ruby/core/kernel/require_spec.rb
+++ b/spec/ruby/core/kernel/require_spec.rb
@@ -22,14 +22,13 @@
     provided << "pathname"
   end
 
-  provided_requires = provided.dup.to_h {|f| [f,f]}
-  ruby_version_is "3.5" do
-    provided_requires["pathname"] = "pathname.so"
-  end
+  it "#{provided.join(', ')} are already required" do
+    out = ruby_exe("puts $LOADED_FEATURES", options: '--disable-gems --disable-did-you-mean')
+    features = out.lines.map { |line| File.basename(line.chomp, '.*') }
 
-  provided.each do |feature|
-    it "#{feature} is already required and provided in loaded features at boot" do
-      feature_require = provided_requires[feature]
+    # Ignore CRuby internals
+    features -= %w[encdb transdb windows_1252 windows_31j]
+    features.reject! { |feature| feature.end_with?('-fake') }
 
     features.sort.should == provided.sort

From 9f30e6898c23adad8ac8420f15ae5488daed8185 Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Tue, 17 Feb 2026 22:53:18 -0600
Subject: [PATCH 112/168] Pass block through Range#to_set

---
 core/src/main/java/org/jruby/RubyRange.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/core/src/main/java/org/jruby/RubyRange.java b/core/src/main/java/org/jruby/RubyRange.java
index 366fc2ada7b..c0a5bf29803 100644
--- a/core/src/main/java/org/jruby/RubyRange.java
+++ b/core/src/main/java/org/jruby/RubyRange.java
@@ -1372,12 +1372,12 @@ public IRubyObject size(ThreadContext context) {
     }
 
     @JRubyMethod(name = "to_set", rest = true, frame = true)
-    public IRubyObject to_set(ThreadContext context, IRubyObject[] args) {
+    public IRubyObject to_set(ThreadContext context, IRubyObject[] args, Block block) {
         if (isEndless) {
             throw context.runtime.newRangeError("cannot convert endless range to a set");
         }
 
-        return invokeSuper(context, this, context.getFrameKlazz(), context.getFrameName(), args, Block.NULL_BLOCK);
+        return invokeSuper(context, this, context.getFrameKlazz(), context.getFrameName(), args, block);
     }
 
     private boolean discreteObject(IRubyObject object) {

From 50dd6ff41f3afd643e9ac6a80fa3093d9e0236cc Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Tue, 17 Feb 2026 23:08:33 -0600
Subject: [PATCH 113/168] Clean up last failure in imported cgi/escape

For unescape when the source has characters that can't be
represented in the target encoding, use the source encoding for the
destination string.

Remove "infectBy" call from tainting days.
---
 core/src/main/java/org/jruby/ext/cgi/escape/CGIEscape.java | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/core/src/main/java/org/jruby/ext/cgi/escape/CGIEscape.java b/core/src/main/java/org/jruby/ext/cgi/escape/CGIEscape.java
index 6785caaa761..072005f9aaf 100644
--- a/core/src/main/java/org/jruby/ext/cgi/escape/CGIEscape.java
+++ b/core/src/main/java/org/jruby/ext/cgi/escape/CGIEscape.java
@@ -82,8 +82,6 @@ static void html_escaped_cat(RubyString str, byte c) {
 
     static void preserve_original_state(RubyString orig, RubyString dest) {
         dest.setEncoding(orig.getEncoding());
-
-        dest.infectBy(orig);
     }
 
     static IRubyObject
@@ -379,7 +377,7 @@ static IRubyObject optimized_escape(Ruby runtime, RubyString str, boolean escape
         if (origenc != encidx) {
             dest.setEncoding(encidx);
             if (StringSupport.encCoderangeClean(dest.scanForCodeRange()) == 0) {
-                dest.setEncoding(origenc);
+                EncodingUtils.encAssociateIndex(dest, origenc);
                 if (cr != StringSupport.CR_UNKNOWN)
                     dest.setCodeRange(cr);
             }

From dd809d44dcea007d64dc30641983f54bc009c338 Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Tue, 17 Feb 2026 23:15:25 -0600
Subject: [PATCH 114/168] Native files can't be mapped by IO::Buffer yet

See https://github.com/jruby/jruby/issues/8714
---
 spec/tags/ruby/core/io/buffer/map_tags.txt | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/spec/tags/ruby/core/io/buffer/map_tags.txt b/spec/tags/ruby/core/io/buffer/map_tags.txt
index 502b5f018aa..f71bcc3dd8d 100644
--- a/spec/tags/ruby/core/io/buffer/map_tags.txt
+++ b/spec/tags/ruby/core/io/buffer/map_tags.txt
@@ -20,3 +20,8 @@ fails:IO::Buffer.map with flags argument when READONLY flag is specified causes
 fails:IO::Buffer.map with flags argument when PRIVATE is specified sets private flag on the buffer, making it freely modifiable
 fails:IO::Buffer.map with flags argument when PRIVATE is specified allows mapping read-only files and modifying the buffer
 fails:IO::Buffer.map with flags argument when PRIVATE is specified is not shared across processes
+fails(native files cannot be mapped yet, https://github.com/jruby/jruby/issues/8714):IO::Buffer.map with an empty file raises ArgumentError
+fails(native files cannot be mapped yet, https://github.com/jruby/jruby/issues/8714):IO::Buffer.map with size argument raises ArgumentError if size is larger than file size
+fails(native files cannot be mapped yet, https://github.com/jruby/jruby/issues/8714):IO::Buffer.map with size argument if size is 0 raises ArgumentError
+fails(native files cannot be mapped yet, https://github.com/jruby/jruby/issues/8714):IO::Buffer.map with size and offset arguments raises ArgumentError if offset+size is larger than file size
+fails(native files cannot be mapped yet, https://github.com/jruby/jruby/issues/8714):IO::Buffer.map with size and offset arguments raises ArgumentError if offset is negative

From ffcd2b8e11c5fb2ebf1a8c9ec72f2e50cece9000 Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Tue, 17 Feb 2026 23:15:51 -0600
Subject: [PATCH 115/168] Still need work to include class name in backtrace

See https://github.com/jruby/jruby/issues/8660
---
 spec/tags/ruby/core/kernel/caller_locations_tags.txt | 1 +
 1 file changed, 1 insertion(+)

diff --git a/spec/tags/ruby/core/kernel/caller_locations_tags.txt b/spec/tags/ruby/core/kernel/caller_locations_tags.txt
index 5dc5365380a..ca68622aa07 100644
--- a/spec/tags/ruby/core/kernel/caller_locations_tags.txt
+++ b/spec/tags/ruby/core/kernel/caller_locations_tags.txt
@@ -2,3 +2,4 @@ fails:Kernel#caller_locations can be called with a range whose end is negative
 fails:Kernel#caller_locations must return nil if omitting more locations than available
 fails:Kernel#caller_locations must return the same locations when called with 1..-1 and when called with no arguments
 fails(https://github.com/jruby/jruby/issues/8660):Kernel#caller_locations includes core library methods defined in Ruby
+fails(https://github.com/jruby/jruby/issues/8660):Kernel#caller_locations does not include core library methods defined in Ruby

From bf2f0db9b386a5dd10b462c92d978740c1b02eca Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Tue, 17 Feb 2026 23:19:18 -0600
Subject: [PATCH 116/168] Defer updating unicode for now

See https://github.com/jruby/jruby/issues/9250
---
 spec/tags/ruby/library/rbconfig/unicode_emoji_version_tags.txt | 1 +
 spec/tags/ruby/library/rbconfig/unicode_version_tags.txt       | 1 +
 2 files changed, 2 insertions(+)
 create mode 100644 spec/tags/ruby/library/rbconfig/unicode_emoji_version_tags.txt
 create mode 100644 spec/tags/ruby/library/rbconfig/unicode_version_tags.txt

diff --git a/spec/tags/ruby/library/rbconfig/unicode_emoji_version_tags.txt b/spec/tags/ruby/library/rbconfig/unicode_emoji_version_tags.txt
new file mode 100644
index 00000000000..75f5bf3708d
--- /dev/null
+++ b/spec/tags/ruby/library/rbconfig/unicode_emoji_version_tags.txt
@@ -0,0 +1 @@
+fails(not updated unicode yet, https://github.com/jruby/jruby/issues/9250):RbConfig::CONFIG['UNICODE_EMOJI_VERSION'] is 17.0
diff --git a/spec/tags/ruby/library/rbconfig/unicode_version_tags.txt b/spec/tags/ruby/library/rbconfig/unicode_version_tags.txt
new file mode 100644
index 00000000000..b6e242cfd20
--- /dev/null
+++ b/spec/tags/ruby/library/rbconfig/unicode_version_tags.txt
@@ -0,0 +1 @@
+fails(not updated unicode yet, https://github.com/jruby/jruby/issues/9250):RbConfig::CONFIG['UNICODE_VERSION'] is 17.0.0

From 50227651bddac738b58eae40f8e0d886632a6702 Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Wed, 18 Feb 2026 00:44:42 -0600
Subject: [PATCH 117/168] Match CRuby CGI::Escape module setup

---
 core/src/main/java/org/jruby/RubyModule.java   |  7 +++++++
 core/src/main/java/org/jruby/api/Define.java   | 14 ++++++++++++++
 .../org/jruby/ext/cgi/escape/CGIEscape.java    | 18 ++++++++++++------
 3 files changed, 33 insertions(+), 6 deletions(-)

diff --git a/core/src/main/java/org/jruby/RubyModule.java b/core/src/main/java/org/jruby/RubyModule.java
index 98931f38432..da3c9efbc34 100644
--- a/core/src/main/java/org/jruby/RubyModule.java
+++ b/core/src/main/java/org/jruby/RubyModule.java
@@ -3857,6 +3857,13 @@ public IRubyObject extend_object(ThreadContext context, IRubyObject obj) {
         return obj;
     }
 
+    @JRubyAPI
+    public RubyModule extendObject(ThreadContext context, IRubyObject obj) {
+        extend_object(context, obj);
+
+        return this;
+    }
+
     @Deprecated(since = "10.0.0.0")
     public RubyModule include(IRubyObject[] modules) {
         return include(getCurrentContext(), modules);
diff --git a/core/src/main/java/org/jruby/api/Define.java b/core/src/main/java/org/jruby/api/Define.java
index 71674178cf8..2d286704287 100644
--- a/core/src/main/java/org/jruby/api/Define.java
+++ b/core/src/main/java/org/jruby/api/Define.java
@@ -42,6 +42,20 @@ public static RubyModule defineModule(ThreadContext context, String name) {
         return context.runtime.defineModuleUnder(context, name, objectClass(context));
     }
 
+    /**
+     * Define a new module under the given namespace. Roughly equivalent to
+     * rb_define_module_under in MRI.  Note: If a module already exists for this name
+     * it returns it or errors if it is not a Module at all.
+     *
+     * @param context the current context
+     * @param parent the parent module
+     * @param name The name of the new module
+     * @return The new module or existing one if it has already been defined.
+     */
+    public static RubyModule defineModuleUnder(ThreadContext context, RubyModule parent, String name) {
+        return context.runtime.defineModuleUnder(context, name, parent);
+    }
+
     /**
      * There are times when an anonymous module is needed.  It is up to the caller
      * to set it up as a constant or include methods or whatever else is needed.
diff --git a/core/src/main/java/org/jruby/ext/cgi/escape/CGIEscape.java b/core/src/main/java/org/jruby/ext/cgi/escape/CGIEscape.java
index 072005f9aaf..00f7d033223 100644
--- a/core/src/main/java/org/jruby/ext/cgi/escape/CGIEscape.java
+++ b/core/src/main/java/org/jruby/ext/cgi/escape/CGIEscape.java
@@ -38,6 +38,7 @@
 import org.jruby.RubyModule;
 import org.jruby.RubyString;
 import org.jruby.anno.JRubyMethod;
+import org.jruby.api.Define;
 import org.jruby.runtime.Block;
 import org.jruby.runtime.Helpers;
 import org.jruby.runtime.ThreadContext;
@@ -506,12 +507,17 @@ public static IRubyObject cgiesc_unescape_uri_component(ThreadContext context, I
     }
 
     public void load(Ruby runtime, boolean wrap) {
-        RubyClass rb_cCGI = runtime.defineClass("CGI", runtime.getObject(), runtime.getObject().getAllocator());
-        RubyModule rb_mEscape = rb_cCGI.defineModuleUnder("Escape");
-        RubyModule rb_mUtil = rb_cCGI.defineModuleUnder("Util");
-        rb_mEscape.defineAnnotatedMethods(CGIEscape.class);
-        rb_mUtil.prependModule(rb_mEscape);
-        rb_mEscape.extend_object(rb_cCGI);
+        ThreadContext context = runtime.getCurrentContext();
+
+        RubyClass rb_cCGI = Define.defineClass(context, "CGI", runtime.getObject(), runtime.getObject().getAllocator());
+
+        RubyModule rb_mEscapeExt =
+                Define.defineModuleUnder(context, rb_cCGI, "EscapeExt")
+                        .defineMethods(context, CGIEscape.class)
+                        .extendObject(context, rb_cCGI);
+
+        Define.defineModuleUnder(context, rb_cCGI, "Escape")
+                .prependModule(context, rb_mEscapeExt);
     }
 
     // PORTED FROM OTHER FILES IN MRI

From 39b1834611deaedca0247f35c41fad407a0cc3a7 Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Wed, 18 Feb 2026 00:48:14 -0600
Subject: [PATCH 118/168] Exclude pure-Ruby tests with problematic alias trick

This aliasing and unaliasing of methods to temporarily remove them
does not appear to work properly in JRuby. Im excluding the tests
since this is a very peculiar scenario users probably will never
run into, and excluding the hacky tests allows the others to all
pass.

See https://github.com/jruby/jruby/issues/9251
---
 test/mri/excludes/CGIEscapePureRubyTest.rb | 5 +++++
 1 file changed, 5 insertions(+)
 create mode 100644 test/mri/excludes/CGIEscapePureRubyTest.rb

diff --git a/test/mri/excludes/CGIEscapePureRubyTest.rb b/test/mri/excludes/CGIEscapePureRubyTest.rb
new file mode 100644
index 00000000000..e3f898c3e90
--- /dev/null
+++ b/test/mri/excludes/CGIEscapePureRubyTest.rb
@@ -0,0 +1,5 @@
+exclude :test_cgi_unescapeHTML_following_known_first_letter, "broken aliasing logic causes this test to break others, see https://github.com/jruby/jruby/issues/9251"
+exclude :test_cgi_escapeHTML_with_invalid_byte_sequence, "broken aliasing logic causes this test to break others, see https://github.com/jruby/jruby/issues/9251"
+exclude :test_cgi_unescapeHTML_following_number_sign, "broken aliasing logic causes this test to break others, see https://github.com/jruby/jruby/issues/9251"
+exclude :test_cgi_unescapeHTML_following_invalid_numeric, "broken aliasing logic causes this test to break others, see https://github.com/jruby/jruby/issues/9251"
+exclude :test_cgi_unescapeHTML_with_invalid_byte_sequence, "broken aliasing logic causes this test to break others, see https://github.com/jruby/jruby/issues/9251"

From 4dcdcac1e84970f2d011b62de2e219cc22065755 Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Wed, 18 Feb 2026 00:56:57 -0600
Subject: [PATCH 119/168] Exclude tests that want class on backtrace frames

See https://github.com/jruby/jruby/issues/8660
---
 test/mri/excludes/TestBacktrace.rb | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/test/mri/excludes/TestBacktrace.rb b/test/mri/excludes/TestBacktrace.rb
index 6a67eeda616..009f22d0c45 100644
--- a/test/mri/excludes/TestBacktrace.rb
+++ b/test/mri/excludes/TestBacktrace.rb
@@ -7,3 +7,5 @@
 exclude :test_each_backtrace_location, "work in progress"
 exclude :test_no_receiver_for_anonymous_class, "line number is off by one in JIT modes"
 exclude :test_notty_backtrace, "work in progress"
+exclude :test_backtrace_internal_frame, "no classes in backtrace yet, https://github.com/jruby/jruby/issues/8660"
+exclude :test_backtrace_on_argument_error, "no classes in backtrace yet, https://github.com/jruby/jruby/issues/8660"

From ef9a131b3a5212b997d80feedfe7cd33245ea185 Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Wed, 18 Feb 2026 00:57:34 -0600
Subject: [PATCH 120/168] Exclude tests of IO::Buffer file mapping

See https://github.com/jruby/jruby/issues/8714
---
 test/mri/excludes/TestIOBuffer.rb | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/test/mri/excludes/TestIOBuffer.rb b/test/mri/excludes/TestIOBuffer.rb
index f379c4beec2..063f646f2d9 100644
--- a/test/mri/excludes/TestIOBuffer.rb
+++ b/test/mri/excludes/TestIOBuffer.rb
@@ -3,6 +3,12 @@
 exclude :test_copy_null_source, "no support for null buffer"
 exclude :test_copy_overlapped_bwd, "needs investigation"
 exclude :test_file_mapped, "open files can't be memory-mapped due to jnr-enxio (https://github.com/jruby/jruby/issues/8714)"
+exclude :test_file_mapped_size_just_enough, "open files can't be memory-mapped due to jnr-enxio (https://github.com/jruby/jruby/issues/8714)"
+exclude :test_file_mapped_with_size, "open files can't be memory-mapped due to jnr-enxio (https://github.com/jruby/jruby/issues/8714)"
+exclude :test_file_mapped_offset_too_large, "open files can't be memory-mapped due to jnr-enxio (https://github.com/jruby/jruby/issues/8714)"
+exclude :test_file_mapped_negative_offset, "open files can't be memory-mapped due to jnr-enxio (https://github.com/jruby/jruby/issues/8714)"
+exclude :test_file_mapped_size_too_large, "open files can't be memory-mapped due to jnr-enxio (https://github.com/jruby/jruby/issues/8714)"
+exclude :test_file_mapped_zero_size, "open files can't be memory-mapped due to jnr-enxio (https://github.com/jruby/jruby/issues/8714)"
 exclude :test_private, "open files can't be memory-mapped due to jnr-enxio (https://github.com/jruby/jruby/issues/8714)"
 exclude :test_read_with_length_and_offset, "read of zero is supposed to read as much as it can"
 exclude :test_resize_zero_external, "missing AccessError"

From 8c5d04a29c3c351c42b8082fa4d28f7efde189d0 Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Wed, 18 Feb 2026 00:57:55 -0600
Subject: [PATCH 121/168] Exclude tests of unicode level

See https://github.com/jruby/jruby/issues/9250
---
 test/mri/excludes/TestRegexp.rb | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/test/mri/excludes/TestRegexp.rb b/test/mri/excludes/TestRegexp.rb
index 2bbacdd1782..e51c91e7872 100644
--- a/test/mri/excludes/TestRegexp.rb
+++ b/test/mri/excludes/TestRegexp.rb
@@ -32,4 +32,6 @@
 exclude :test_to_s, "needs investigation"
 exclude :test_to_s_under_gc_compact_stress, "GC is not configurable"
 exclude :test_unescape, "needs investigation"
+exclude :test_unicode_age_15_1, "needs update to support unicode 15.1, 16 and 17, https://github.com/jruby/jruby/issues/9250"
+exclude :test_unicode_age_16_0, "needs update to support unicode 15.1, 16 and 17, https://github.com/jruby/jruby/issues/9250"
 exclude :test_union, "unfinished in initial 2.6 work, #6161"

From 424a7d607f8e5f96835a5ab5d5c021c1b9b6ce43 Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Wed, 18 Feb 2026 03:07:02 -0600
Subject: [PATCH 122/168] Add pathname to provided libraries

---
 core/src/main/java/org/jruby/Ruby.java | 1 +
 1 file changed, 1 insertion(+)

diff --git a/core/src/main/java/org/jruby/Ruby.java b/core/src/main/java/org/jruby/Ruby.java
index 371875c8cca..7f25ce3e134 100644
--- a/core/src/main/java/org/jruby/Ruby.java
+++ b/core/src/main/java/org/jruby/Ruby.java
@@ -606,6 +606,7 @@ private void initBootLibraries(ThreadContext context) {
         loadService.provide("fiber.rb");
         loadService.provide("ruby2_keywords.rb");
         loadService.provide("set.rb");
+        loadService.provide("pathname.rb");
 
         // Load preludes
         initRubyPreludes();

From 18bc039c5f27a786a3e43fee69aa94c1284627c0 Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Wed, 18 Feb 2026 12:47:49 -0600
Subject: [PATCH 123/168] Remove JRuby internals before testing

---
 spec/ruby/core/kernel/require_spec.rb | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/spec/ruby/core/kernel/require_spec.rb b/spec/ruby/core/kernel/require_spec.rb
index 60d17242fe1..2ded082a284 100644
--- a/spec/ruby/core/kernel/require_spec.rb
+++ b/spec/ruby/core/kernel/require_spec.rb
@@ -26,8 +26,13 @@
     out = ruby_exe("puts $LOADED_FEATURES", options: '--disable-gems --disable-did-you-mean')
     features = out.lines.map { |line| File.basename(line.chomp, '.*') }
 
-    # Ignore CRuby internals
-    features -= %w[encdb transdb windows_1252 windows_31j]
+    # Ignore engine-specific internals
+    case RUBY_ENGINE
+    when "jruby"
+      features -= %w[java util]
+    else
+      features -= %w[encdb transdb windows_1252 windows_31j]
+    end
     features.reject! { |feature| feature.end_with?('-fake') }
 
     features.sort.should == provided.sort

From 6db771b87401c956b7947ff08193794d8071c6f8 Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Thu, 19 Feb 2026 20:05:03 -0600
Subject: [PATCH 124/168] Upgrade jcodings to 1.0.64 for Unicode 17

---
 core/pom.rb                                                    | 2 +-
 core/pom.xml                                                   | 2 +-
 spec/tags/ruby/library/rbconfig/unicode_emoji_version_tags.txt | 1 -
 spec/tags/ruby/library/rbconfig/unicode_version_tags.txt       | 1 -
 test/mri/excludes/TestRegexp.rb                                | 2 --
 5 files changed, 2 insertions(+), 6 deletions(-)
 delete mode 100644 spec/tags/ruby/library/rbconfig/unicode_emoji_version_tags.txt
 delete mode 100644 spec/tags/ruby/library/rbconfig/unicode_version_tags.txt

diff --git a/core/pom.rb b/core/pom.rb
index b05d52b3c61..e4ae4963707 100644
--- a/core/pom.rb
+++ b/core/pom.rb
@@ -54,7 +54,7 @@
   jar 'com.github.jnr:jffi:${jffi.version}:native'
 
   jar 'org.jruby.joni:joni:2.2.6'
-  jar 'org.jruby.jcodings:jcodings:1.0.63'
+  jar 'org.jruby.jcodings:jcodings:1.0.64'
   jar 'org.jruby:dirgra:0.5'
 
   jar 'com.headius:invokebinder:1.14'
diff --git a/core/pom.xml b/core/pom.xml
index 7669516b318..c1bd99eebe4 100644
--- a/core/pom.xml
+++ b/core/pom.xml
@@ -154,7 +154,7 @@ DO NOT MODIFY - GENERATED CODE
     <dependency>
       <groupId>org.jruby.jcodings</groupId>
       <artifactId>jcodings</artifactId>
-      <version>1.0.63</version>
+      <version>1.0.64</version>
     </dependency>
     <dependency>
       <groupId>org.jruby</groupId>
diff --git a/spec/tags/ruby/library/rbconfig/unicode_emoji_version_tags.txt b/spec/tags/ruby/library/rbconfig/unicode_emoji_version_tags.txt
deleted file mode 100644
index 75f5bf3708d..00000000000
--- a/spec/tags/ruby/library/rbconfig/unicode_emoji_version_tags.txt
+++ /dev/null
@@ -1 +0,0 @@
-fails(not updated unicode yet, https://github.com/jruby/jruby/issues/9250):RbConfig::CONFIG['UNICODE_EMOJI_VERSION'] is 17.0
diff --git a/spec/tags/ruby/library/rbconfig/unicode_version_tags.txt b/spec/tags/ruby/library/rbconfig/unicode_version_tags.txt
deleted file mode 100644
index b6e242cfd20..00000000000
--- a/spec/tags/ruby/library/rbconfig/unicode_version_tags.txt
+++ /dev/null
@@ -1 +0,0 @@
-fails(not updated unicode yet, https://github.com/jruby/jruby/issues/9250):RbConfig::CONFIG['UNICODE_VERSION'] is 17.0.0
diff --git a/test/mri/excludes/TestRegexp.rb b/test/mri/excludes/TestRegexp.rb
index e51c91e7872..2bbacdd1782 100644
--- a/test/mri/excludes/TestRegexp.rb
+++ b/test/mri/excludes/TestRegexp.rb
@@ -32,6 +32,4 @@
 exclude :test_to_s, "needs investigation"
 exclude :test_to_s_under_gc_compact_stress, "GC is not configurable"
 exclude :test_unescape, "needs investigation"
-exclude :test_unicode_age_15_1, "needs update to support unicode 15.1, 16 and 17, https://github.com/jruby/jruby/issues/9250"
-exclude :test_unicode_age_16_0, "needs update to support unicode 15.1, 16 and 17, https://github.com/jruby/jruby/issues/9250"
 exclude :test_union, "unfinished in initial 2.6 work, #6161"

From eb3751f2d52c17e8e8b8127d9c466839f8726a9a Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Tue, 24 Feb 2026 17:49:06 -0600
Subject: [PATCH 125/168] Internalize pathname for now

Ideally we would be able to use the same pure-Ruby sources as the
gem (see jruby/jruby#9062) but there are additional tweaks needed
there to support our URI forms. For now we just internalize our
existing implementation to get things working.

See ruby/pathname#57 and ruby/pathname#17 for the Pathname move in
Ruby 4.0 and jruby/jruby#9060 for our issue to switch to the pure-
Ruby version.
---
 core/src/main/ruby/jruby/kernel.rb                               | 1 +
 {lib/ruby/stdlib => core/src/main/ruby/jruby/kernel}/pathname.rb | 0
 2 files changed, 1 insertion(+)
 rename {lib/ruby/stdlib => core/src/main/ruby/jruby/kernel}/pathname.rb (100%)

diff --git a/core/src/main/ruby/jruby/kernel.rb b/core/src/main/ruby/jruby/kernel.rb
index db8b8b2b44f..f21aee737b6 100644
--- a/core/src/main/ruby/jruby/kernel.rb
+++ b/core/src/main/ruby/jruby/kernel.rb
@@ -31,3 +31,4 @@ module JRuby
 load 'jruby/kernel/time.rb'
 load 'jruby/kernel/set.rb'
 load 'jruby/kernel/string.rb'
+load 'jruby/kernel/pathname.rb'
diff --git a/lib/ruby/stdlib/pathname.rb b/core/src/main/ruby/jruby/kernel/pathname.rb
similarity index 100%
rename from lib/ruby/stdlib/pathname.rb
rename to core/src/main/ruby/jruby/kernel/pathname.rb

From 17dc4a97fcbe48178793a7685a945a16b30dc74c Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Tue, 24 Feb 2026 18:10:52 -0600
Subject: [PATCH 126/168] Update joni to 2.2.7

No changes other than jcodings 1.0.64.
---
 core/pom.rb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/core/pom.rb b/core/pom.rb
index e4ae4963707..fc51b3391a7 100644
--- a/core/pom.rb
+++ b/core/pom.rb
@@ -53,7 +53,7 @@
   jar 'com.github.jnr:jffi:${jffi.version}'
   jar 'com.github.jnr:jffi:${jffi.version}:native'
 
-  jar 'org.jruby.joni:joni:2.2.6'
+  jar 'org.jruby.joni:joni:2.2.7'
   jar 'org.jruby.jcodings:jcodings:1.0.64'
   jar 'org.jruby:dirgra:0.5'

From 2afcfff15b8aee33ee0096de7ace193abb542adb Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Wed, 25 Feb 2026 18:47:14 -0600
Subject: [PATCH 127/168] Don't set @hash ivar on Set anymore

Set no longer aggregates a Hash in CRuby. Ours does for now, but
don't expose it anymore.
---
 core/src/main/java/org/jruby/ext/set/RubySet.java | 1 -
 1 file changed, 1 deletion(-)

diff --git a/core/src/main/java/org/jruby/ext/set/RubySet.java b/core/src/main/java/org/jruby/ext/set/RubySet.java
index 76167732f43..3a66d5e269f 100644
--- a/core/src/main/java/org/jruby/ext/set/RubySet.java
+++ b/core/src/main/java/org/jruby/ext/set/RubySet.java
@@ -172,7 +172,6 @@ final void allocHash(final ThreadContext context, final int size) {
 
     final void setHash(final RubyHash hash) {
         this.hash = hash;
-        setInstanceVariable("@hash", hash); // MRI compat with set.rb
     }
 
     /**

From 7533940bcbd18b8c95eb80705cd61f49845743af Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Wed, 25 Feb 2026 18:53:36 -0600
Subject: [PATCH 128/168] Don't map pathname to pathname.so on JRuby

JRuby never loads extensions as .so and pathname is provided as a
pathname.rb.
---
 spec/ruby/core/kernel/require_spec.rb | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/spec/ruby/core/kernel/require_spec.rb b/spec/ruby/core/kernel/require_spec.rb
index 2ded082a284..cd97cc9bb01 100644
--- a/spec/ruby/core/kernel/require_spec.rb
+++ b/spec/ruby/core/kernel/require_spec.rb
@@ -39,7 +39,9 @@
 
     requires = provided
     ruby_version_is "4.0" do
-      requires = requires.map { |f| f == "pathname" ? "pathname.so" : f }
+      if RUBY_ENGINE != "jruby"
+        requires = requires.map { |f| f == "pathname" ? "pathname.so" : f }
+      end
     end
 
     code = requires.map { |f| "puts require #{f.inspect}\n" }.join

From f2cddafff1784fc52098ea59402c143446b4d3e4 Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Wed, 25 Feb 2026 19:04:23 -0600
Subject: [PATCH 129/168] Tag last file-mapping fail in IO::Buffer.map specs

---
 spec/tags/ruby/core/io/buffer/map_tags.txt | 1 +
 1 file changed, 1 insertion(+)

diff --git a/spec/tags/ruby/core/io/buffer/map_tags.txt b/spec/tags/ruby/core/io/buffer/map_tags.txt
index f71bcc3dd8d..190f7bc2234 100644
--- a/spec/tags/ruby/core/io/buffer/map_tags.txt
+++ b/spec/tags/ruby/core/io/buffer/map_tags.txt
@@ -25,3 +25,4 @@ fails(native files cannot be mapped yet, https://github.com/jruby/jruby/issues/8
 fails(native files cannot be mapped yet, https://github.com/jruby/jruby/issues/8714):IO::Buffer.map with size argument if size is 0 raises ArgumentError
 fails(native files cannot be mapped yet, https://github.com/jruby/jruby/issues/8714):IO::Buffer.map with size and offset arguments raises ArgumentError if offset+size is larger than file size
 fails(native files cannot be mapped yet, https://github.com/jruby/jruby/issues/8714):IO::Buffer.map with size and offset arguments raises ArgumentError if offset is negative
+fails(native files cannot be mapped yet, https://github.com/jruby/jruby/issues/8714):IO::Buffer.map with size and offset arguments if offset is an allowed value for system call if size is nil sets buffer's size to file's remaining size

From 4ad76183a97083fa82d51974bdfd122f70dbbd0b Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Wed, 25 Feb 2026 19:46:19 -0600
Subject: [PATCH 130/168] Implement Array#fetch_vaues in terms of fetch

---
 .../src/main/java/org/jruby/RubyArrayNative.java | 16 +++-------------
 1 file changed, 3 insertions(+), 13 deletions(-)

diff --git a/core/src/main/java/org/jruby/RubyArrayNative.java b/core/src/main/java/org/jruby/RubyArrayNative.java
index 6790d5aff67..14540c99a25 100644
--- a/core/src/main/java/org/jruby/RubyArrayNative.java
+++ b/core/src/main/java/org/jruby/RubyArrayNative.java
@@ -923,20 +923,10 @@ public T eltInternalSet(int offset, T item) {
 
     public IRubyObject fetch_values(ThreadContext context, IRubyObject[] args, Block block) {
         int length = args.length;
-        if (length == 0) return Create.newEmptyArray(context);
-
-        int arraySize = size();
-        var result = Create.allocArray(context, length);
-
-        for (int index = 0; index < length; index++) {
-            if (index >= arraySize) {
-                if (!block.isGiven()) throw indexError(context, "index " + index + " outside of array bounds: 0...0");
-                result.append(context, block.yield(context, asFixnum(context, index)));
-            } else {
-                result.append(context, eltOk(index));
-            }
+        RubyArray result = RubyArrayNative.newBlankArrayInternal(context.runtime, length);
+        for (int i = 0; i < args.length; i++) {
+            result.storeInternal(context, i, fetch(context, args[i], block));
         }
-
         return result;
     }

From e49f1a43fbe8d897675995107121232dea639c66 Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Wed, 25 Feb 2026 19:51:10 -0600
Subject: [PATCH 131/168] Exclud negative lines from coverage

---
 core/src/main/java/org/jruby/ext/coverage/CoverageData.java | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/core/src/main/java/org/jruby/ext/coverage/CoverageData.java b/core/src/main/java/org/jruby/ext/coverage/CoverageData.java
index 0c0942e240a..27c6cf03d12 100644
--- a/core/src/main/java/org/jruby/ext/coverage/CoverageData.java
+++ b/core/src/main/java/org/jruby/ext/coverage/CoverageData.java
@@ -91,6 +91,9 @@ public Map<String, IntList> getCoverage() {
     public synchronized void coverLine(String filename, int line) {
         Map<String, IntList> coverage = this.coverage;
 
+        // negative lines are not included in coverage
+        if (line < 0) return;
+
         if (coverage != null) {
             IntList lines = coverage.get(filename);

From ec11fd927488f99688d17402c2346fb1ef0169b4 Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Wed, 25 Feb 2026 20:04:34 -0600
Subject: [PATCH 132/168] Unwrap Java exceptions for Thread#raise enqueueing

---
 core/src/main/java/org/jruby/RubyKernel.java | 2 +-
 core/src/main/java/org/jruby/RubyThread.java | 6 ++++++
 2 files changed, 7 insertions(+), 1 deletion(-)

diff --git a/core/src/main/java/org/jruby/RubyKernel.java b/core/src/main/java/org/jruby/RubyKernel.java
index df6ce77b233..a18fc8c0b6f 100644
--- a/core/src/main/java/org/jruby/RubyKernel.java
+++ b/core/src/main/java/org/jruby/RubyKernel.java
@@ -1137,7 +1137,7 @@ public static IRubyObject raise(ThreadContext context, IRubyObject recv, IRubyOb
      * @param argc the count of arguments passed to Kernel#raise
      * @return a Java Throwable for the unwrapped exception, or null if no Java exception is available
      */
-    private static Throwable unwrapJavaException(ThreadContext context, final IRubyObject[] args, final int argc) {
+    public static Throwable unwrapJavaException(ThreadContext context, final IRubyObject[] args, final int argc) {
         // Check for a Java exception
         IRubyObject maybeException = null;
         switch (argc) {
diff --git a/core/src/main/java/org/jruby/RubyThread.java b/core/src/main/java/org/jruby/RubyThread.java
index ce6b2668fbc..d63e1b1df16 100644
--- a/core/src/main/java/org/jruby/RubyThread.java
+++ b/core/src/main/java/org/jruby/RubyThread.java
@@ -1560,6 +1560,12 @@ public static IRubyObject prepareRaiseException(ThreadContext context, IRubyObje
         }
         Arity.checkArgumentCount(context, argc, 0, 3);
 
+        Throwable throwable = RubyKernel.unwrapJavaException(context, args, argc);
+
+        if (throwable != null) {
+            return args[0];
+        }
+
         switch (argc) {
             case 0:
                 if (errorInfo.isNil()) {

From 1fe490aad9384cb29b55f5a5e3c9d5532898d870 Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Wed, 25 Feb 2026 20:05:05 -0600
Subject: [PATCH 133/168] Remove extra whitespace

---
 core/src/main/java/org/jruby/RubyThread.java | 1 -
 1 file changed, 1 deletion(-)

diff --git a/core/src/main/java/org/jruby/RubyThread.java b/core/src/main/java/org/jruby/RubyThread.java
index d63e1b1df16..6bae8653124 100644
--- a/core/src/main/java/org/jruby/RubyThread.java
+++ b/core/src/main/java/org/jruby/RubyThread.java
@@ -1601,7 +1601,6 @@ public static IRubyObject prepareRaiseException(ThreadContext context, IRubyObje
             break;
         }
 
-
         if (!exceptionClass(context).isInstance(tmp)) throw typeError(context, "exception object expected");
 
         RubyException exception = (RubyException) tmp;

From 58ad113c430b7094591d5df454c5f42c9c48fa5b Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Wed, 25 Feb 2026 20:21:32 -0600
Subject: [PATCH 134/168] Mark implicit arg nodes for handling in #parameters

---
 core/src/main/java/org/jruby/ast/ArgumentNode.java     | 10 ++++++++++
 .../src/main/java/org/jruby/parser/RubyParserBase.java |  2 +-
 .../java/org/jruby/runtime/ArgumentDescriptor.java     |  6 +++++-
 core/src/main/java/org/jruby/runtime/Helpers.java      |  7 ++++++-
 4 files changed, 22 insertions(+), 3 deletions(-)

diff --git a/core/src/main/java/org/jruby/ast/ArgumentNode.java b/core/src/main/java/org/jruby/ast/ArgumentNode.java
index a84a45acc19..85bff2e452c 100644
--- a/core/src/main/java/org/jruby/ast/ArgumentNode.java
+++ b/core/src/main/java/org/jruby/ast/ArgumentNode.java
@@ -43,12 +43,18 @@
 public class ArgumentNode extends Node implements INameNode {
     private final RubySymbol identifier;
     private final int location;
+    private final boolean implicit;
 
     public ArgumentNode(int line, RubySymbol identifier, int location) {
+        this(line, identifier, location, false);
+    }
+
+    public ArgumentNode(int line, RubySymbol identifier, int location, boolean implicit) {
         super(line, false);
 
         this.identifier = identifier;
         this.location = location; // All variables should be depth 0 in this case
+        this.implicit = implicit;
     }
 
     public NodeType getNodeType() {
@@ -86,4 +92,8 @@ public RubySymbol getName() {
     public List<Node> childNodes() {
         return EMPTY_LIST;
     }
+
+    public boolean isImplicit() {
+        return implicit;
+    }
 }
diff --git a/core/src/main/java/org/jruby/parser/RubyParserBase.java b/core/src/main/java/org/jruby/parser/RubyParserBase.java
index b14b1212f2a..4878a85924c 100644
--- a/core/src/main/java/org/jruby/parser/RubyParserBase.java
+++ b/core/src/main/java/org/jruby/parser/RubyParserBase.java
@@ -205,7 +205,7 @@ public ArgsNode args_with_numbered(ArgsNode args, int paramCount, Node itNode) {
             args = new_args(lexer.getRubySourceline(), pre, null, null, null, null);
         } else if (itNode != null) {
             DVarNode dvar = (DVarNode) itNode;
-            Node arg = new ArgumentNode(dvar.getLine(), dvar.getName(), dvar.getDepth());
+            Node arg = new ArgumentNode(dvar.getLine(), dvar.getName(), dvar.getDepth(), true);
             args = new_args(lexer.getRubySourceline(), newArrayNode(arg.getLine(), arg), null, null, null, null);
         }
         return args;
diff --git a/core/src/main/java/org/jruby/runtime/ArgumentDescriptor.java b/core/src/main/java/org/jruby/runtime/ArgumentDescriptor.java
index 7b5de43bedc..17b75530431 100644
--- a/core/src/main/java/org/jruby/runtime/ArgumentDescriptor.java
+++ b/core/src/main/java/org/jruby/runtime/ArgumentDescriptor.java
@@ -46,7 +46,11 @@ public final RubyArray toArrayForm(Ruby runtime, boolean isLambda) {
     }
 
     public final RubyArray toArrayForm(ThreadContext context, boolean isLambda) {
-        ArgumentType argType = type == ArgumentType.req && !isLambda ? ArgumentType.opt : type;
+        ArgumentType argType = type;
+        if (!isLambda) {
+            if (argType == ArgumentType.req) argType = ArgumentType.opt;
+            if (argType == ArgumentType.anonreq) argType = ArgumentType.anonopt;
+        }
         RubySymbol name = this.name;
 
         // FIXME: When consolidating block and method parameter arg descriptors eliminate this special *,** handling.
diff --git a/core/src/main/java/org/jruby/runtime/Helpers.java b/core/src/main/java/org/jruby/runtime/Helpers.java
index 8ed8eb405ed..4c5bd7c6d18 100644
--- a/core/src/main/java/org/jruby/runtime/Helpers.java
+++ b/core/src/main/java/org/jruby/runtime/Helpers.java
@@ -2642,7 +2642,12 @@ public static ArgumentDescriptor[] argsNodeToArgumentDescriptors(ArgsNode argsNo
                 if (args[i] instanceof MultipleAsgnNode) {
                     descs.add(new ArgumentDescriptor(ArgumentType.anonreq));
                 } else {
-                    descs.add(new ArgumentDescriptor(ArgumentType.req, ((ArgumentNode) args[i]).getName()));
+                    ArgumentNode arg = (ArgumentNode) args[i];
+                    ArgumentDescriptor desc =
+                            arg.isImplicit() ?
+                                    new ArgumentDescriptor(ArgumentType.anonreq) :
+                                    new ArgumentDescriptor(ArgumentType.req, arg.getName());
+                    descs.add(desc);
                 }
             }
         }

From 8f7bfda17cb61553f2f5b85435ecc872a7b2661a Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Wed, 25 Feb 2026 20:26:33 -0600
Subject: [PATCH 135/168] Implicits are -2 so filter all < 0

---
 core/src/main/java/org/jruby/RubyBinding.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/core/src/main/java/org/jruby/RubyBinding.java b/core/src/main/java/org/jruby/RubyBinding.java
index 98e249262c2..955221d071a 100644
--- a/core/src/main/java/org/jruby/RubyBinding.java
+++ b/core/src/main/java/org/jruby/RubyBinding.java
@@ -144,7 +144,7 @@ public IRubyObject eval(ThreadContext context, IRubyObject[] args) {
     @JRubyMethod(name = "local_variable_defined?")
     public IRubyObject local_variable_defined_p(ThreadContext context, IRubyObject symbol) {
         String id = checkLocalId(context, symbol);
-        return asBoolean(context, binding.getEvalScope(context.runtime).getStaticScope().isDefined(id) != -1);
+        return asBoolean(context, binding.getEvalScope(context.runtime).getStaticScope().isDefinedNotImplicit(id) >= 0);
     }
 
     @JRubyMethod

From 73630b2b0f7be6017b0002e34257f9fd75c5d229 Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Wed, 25 Feb 2026 21:09:49 -0600
Subject: [PATCH 136/168] Separate logic for implicit params and local
 variables

---
 core/src/main/java/org/jruby/RubyBinding.java | 18 ++---
 .../java/org/jruby/parser/RubyParserBase.java |  4 +-
 .../java/org/jruby/parser/StaticScope.java    | 70 +++++++++++++------
 3 files changed, 58 insertions(+), 34 deletions(-)

diff --git a/core/src/main/java/org/jruby/RubyBinding.java b/core/src/main/java/org/jruby/RubyBinding.java
index 955221d071a..10358f1e884 100644
--- a/core/src/main/java/org/jruby/RubyBinding.java
+++ b/core/src/main/java/org/jruby/RubyBinding.java
@@ -144,7 +144,7 @@ public IRubyObject eval(ThreadContext context, IRubyObject[] args) {
     @JRubyMethod(name = "local_variable_defined?")
     public IRubyObject local_variable_defined_p(ThreadContext context, IRubyObject symbol) {
         String id = checkLocalId(context, symbol);
-        return asBoolean(context, binding.getEvalScope(context.runtime).getStaticScope().isDefinedNotImplicit(id) >= 0);
+        return asBoolean(context, binding.getEvalScope(context.runtime).getStaticScope().isDefinedOrImplicit(id) >= 0);
     }
 
     @JRubyMethod
@@ -152,7 +152,7 @@ public IRubyObject local_variable_get(ThreadContext context, IRubyObject symbol)
         String id = checkLocalId(context, symbol);
         DynamicScope evalScope = binding.getEvalScope(context.runtime);
         StaticScope staticScope = evalScope.getStaticScope();
-        int slot = staticScope.isDefinedNotImplicit(id);
+        int slot = staticScope.isDefinedOrImplicit(id);
 
         if (slot < 0) throw undefinedVariableError(context, symbol);
 
@@ -164,7 +164,7 @@ public IRubyObject local_variable_set(ThreadContext context, IRubyObject symbol,
         String id = checkLocalId(context, symbol);
         DynamicScope evalScope = binding.getEvalScope(context.runtime);
         StaticScope staticScope = evalScope.getStaticScope();
-        int slot = staticScope.isDefinedNotImplicit(id);
+        int slot = staticScope.isDefinedOrImplicit(id);
 
         // for the implicit "it" variable
         if (slot == StaticScope.IMPLICIT) throw undefinedVariableError(context, symbol);
@@ -180,21 +180,21 @@ public IRubyObject local_variable_set(ThreadContext context, IRubyObject symbol,
     @JRubyMethod(name = "implicit_parameter_defined?")
     public IRubyObject implicit_parameter_defined_p(ThreadContext context, IRubyObject symbol) {
         String id = checkImplicitId(context, symbol);
-        return asBoolean(context, binding.getEvalScope(context.runtime).getStaticScope().isDefined(id) != -1);
+        return asBoolean(context, binding.getDynamicScope().getStaticScope().isDefinedImplicitParameter(id) != -1);
     }
 
     @JRubyMethod
     public IRubyObject implicit_parameter_get(ThreadContext context, IRubyObject symbol) {
         String id = checkImplicitId(context, symbol);
-        DynamicScope evalScope = binding.getEvalScope(context.runtime);
-        StaticScope staticScope = evalScope.getStaticScope();
-        int slot = staticScope.isDefinedNotImplicit(id);
+        DynamicScope dynamicScope = binding.getDynamicScope();
+        StaticScope staticScope = dynamicScope.getStaticScope();
+        int slot = staticScope.isDefinedImplicitParameter(id);
 
         if (slot != StaticScope.IMPLICIT) throw undefinedImplicitVariableError(context, symbol);
 
         slot = staticScope.isDefined(id);
 
-        return evalScope.getValueOrNil(slot & 0xffff, slot >> 16, context.nil);
+        return dynamicScope.getValueOrNil(slot & 0xffff, slot >> 16, context.nil);
     }
 
     private static boolean isNumberedVariable(String id) {
@@ -241,7 +241,7 @@ public IRubyObject local_variables(ThreadContext context) {
 
     @JRubyMethod
     public IRubyObject implicit_parameters(ThreadContext context) {
-        return binding.getEvalScope(context.runtime).getStaticScope().getImplicitLocalVariables(context);
+        return binding.getEvalScope(context.runtime).getStaticScope().getEnclosingScope().getImplicitParameters(context);
     }
 
     @JRubyMethod(name = "receiver")
diff --git a/core/src/main/java/org/jruby/parser/RubyParserBase.java b/core/src/main/java/org/jruby/parser/RubyParserBase.java
index 4878a85924c..e32586fd392 100644
--- a/core/src/main/java/org/jruby/parser/RubyParserBase.java
+++ b/core/src/main/java/org/jruby/parser/RubyParserBase.java
@@ -397,7 +397,7 @@ public Node declareIdentifier(ByteList byteName) {
             node = new LocalVarNode(lexer.tokline, slot, name);
         } else if (dyna_in_block() && id.equals("it")) {
             if (!hasArguments()) {
-                int existing = currentScope.isDefinedNotImplicit(id);
+                int existing = currentScope.isDefinedOrImplicit(id);
                 boolean newIt = false;
 
                 if (existing == -1) {
@@ -416,7 +416,7 @@ public Node declareIdentifier(ByteList byteName) {
                 node = new DVarNode(lexer.tokline, slot, name);
                 if (newIt) set_it_id(node);
             } else {
-                slot = currentScope.isDefinedNotImplicit(id);
+                slot = currentScope.isDefinedOrImplicit(id);
                 // A special it cannot exist without being marked as a special it.
                 if (it_id() != null) compile_error("`it` is not allowed when an ordinary parameter is defined");
 
diff --git a/core/src/main/java/org/jruby/parser/StaticScope.java b/core/src/main/java/org/jruby/parser/StaticScope.java
index 78f0b2d7ed0..4ae833d2772 100644
--- a/core/src/main/java/org/jruby/parser/StaticScope.java
+++ b/core/src/main/java/org/jruby/parser/StaticScope.java
@@ -430,7 +430,7 @@ public int exists(String name) {
      * @param name of the variable to find
      * @return index of variable; -1 if it does not exist; -2 if is implicit.
      */
-    public int existsAndNotImplicit(String name) {
+    public int existsOrImplicit(String name) {
         int slot = findVariableName(name);
         if (slot >= 0 && isImplicitVariable(slot)) return IMPLICIT;
         return slot;
@@ -455,14 +455,25 @@ public int isDefined(String name) {
     }
 
     /**
-     * Is this name visible to the current scope and not an implicit variable ("it", "_1", etc).
+     * Is this name visible to the current scope as either a variable or an implicit variable
+     *
+     * @param name to be looked for
+     * @return a location where the left-most 16 bits of number of scopes down it is and the
+     * right-most 16 bits represents its index in that scope
+     */
+    public int isDefinedOrImplicit(String name) {
+        return isDefinedOrImplicit(name, 0);
+    }
+
+    /**
+     * Is this name visible to the current scope and not an implicit parameter ("it", "_1", etc).
      *
      * @param name to be looked for
      * @return -1 if it is not defined; -2 if it is implicit; or a location where the left-most 16 bits of number of scopes down it is and the
      * right-most 16 bits represents its index in that scope.
      */
-    public int isDefinedNotImplicit(String name) {
-        return isDefinedNotImplicit(name, 0);
+    public int isDefinedImplicitParameter(String name) {
+        return isDefinedImplicitParameter(name, 0);
     }
 
     /**
@@ -547,8 +558,8 @@ public <T> T collectVariables(IntFunction<T> collectionFactory, BiConsumer<T, St
      * @return populated collection
      */
     public <T> T collectAllVariables(ThreadContext context, BiFunction<ThreadContext, Integer, T> collectionFactory, BiConsumer<T, String> collectionPopulator) {
-        T collection = collectVariables(context, collectionFactory, collectionPopulator, false);
-        return collectVariables(context, (t, i) -> collection, collectionPopulator, true);
+        T collection = collectVariables(context, collectionFactory, collectionPopulator, false, true);
+        return collectVariables(context, (t, i) -> collection, collectionPopulator, true, true);
     }
 
     /**
@@ -563,7 +574,7 @@ public <T> T collectAllVariables(ThreadContext context, BiFunction<ThreadContext
      * @return populated collection
      */
     public <T> T collectVariables(ThreadContext context, BiFunction<ThreadContext, Integer, T> collectionFactory, BiConsumer<T, String> collectionPopulator) {
-        return collectVariables(context, collectionFactory, collectionPopulator, false);
+        return collectVariables(context, collectionFactory, collectionPopulator, false, true);
     }
 
     /**
@@ -577,24 +588,30 @@ public <T> T collectVariables(ThreadContext context, BiFunction<ThreadContext, I
      * @param <T> resulting collection type
      * @return populated collection
      */
-    public <T> T collectImplicitVariables(ThreadContext context, BiFunction<ThreadContext, Integer, T> collectionFactory, BiConsumer<T, String> collectionPopulator) {
-        return collectVariables(context, collectionFactory, collectionPopulator, true);
+    public <T> T collectImplicitParameters(ThreadContext context, BiFunction<ThreadContext, Integer, T> collectionFactory, BiConsumer<T, String> collectionPopulator) {
+        return collectVariables(context, collectionFactory, collectionPopulator, true, false);
     }
 
-    public <T> T collectVariables(ThreadContext context, BiFunction<ThreadContext, Integer, T> collectionFactory, BiConsumer<T, String> collectionPopulator, boolean implicit) {
+    private <T> T collectVariables(ThreadContext context, BiFunction<ThreadContext, Integer, T> collectionFactory, BiConsumer<T, String> collectionPopulator, boolean implicit, boolean parents) {
         StaticScope current = this;
 
         T collection = collectionFactory.apply(context, current.variableNamesLength);
 
         HashMap<String, Object> dedup = new HashMap<>();
 
-        while (current.isBlockOrEval) {
-            addVariableNamesToCollection(current, collectionPopulator, dedup, collection, implicit);
+        addVariableNamesToCollection(current, collectionPopulator, dedup, collection, implicit);
+
+        if (parents) {
             current = current.enclosingScope;
-        }
 
-        // once more for method scope
-        addVariableNamesToCollection(current, collectionPopulator, dedup, collection, implicit);
+            while (current.isBlockOrEval) {
+                addVariableNamesToCollection(current, collectionPopulator, dedup, collection, implicit);
+                current = current.enclosingScope;
+            }
+
+            // once more for method scope
+            addVariableNamesToCollection(current, collectionPopulator, dedup, collection, implicit);
+        }
 
         return collection;
     }
@@ -644,8 +661,8 @@ public RubyArray getLocalVariables(ThreadContext context) {
      * @param context the current context
      * @return populated RubyArray
      */
-    public RubyArray getImplicitLocalVariables(ThreadContext context) {
-        return collectImplicitVariables(
+    public RubyArray getImplicitParameters(ThreadContext context) {
+        return collectImplicitParameters(
                 context,
                 Create::allocArray,
                 (array, id) -> appendVariableIfValid(context, array, id));
@@ -667,19 +684,26 @@ public int isDefined(String name, int depth) {
         }
     }
 
-    public int isDefinedNotImplicit(String name, int depth) {
-        int slot = existsAndNotImplicit(name);
-        if (slot == IMPLICIT) return slot;
-
+    public int isDefinedOrImplicit(String name, int depth) {
         if (isBlockOrEval) {
+            int slot = existsOrImplicit(name);
+            if (slot == IMPLICIT) return slot;
+
             if (slot >= 0) return (depth << 16) | slot;
 
-            return enclosingScope.isDefinedNotImplicit(name, depth + 1);
+            return enclosingScope.isDefinedOrImplicit(name, depth + 1);
         } else {
-            return (depth << 16) | slot;
+            return (depth << 16) | existsOrImplicit(name);
         }
     }
 
+    public int isDefinedImplicitParameter(String name, int depth) {
+        int slot = existsOrImplicit(name);
+        if (slot == IMPLICIT) return slot;
+
+        return -1;
+    }
+
     public AssignableNode addAssign(int line, RubySymbol symbolID, Node value) {
         int slot = addVariable(symbolID.idString());
         // No bit math to store level since we know level is zero for this case

From 326063d16964afc8b5026937053b572f8179d50d Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Thu, 26 Feb 2026 16:19:01 -0600
Subject: [PATCH 137/168] Exclude last weird "it" case from MRI tests

See https://github.com/jruby/jruby/issues/9265
---
 test/mri/excludes/TestProc.rb | 1 +
 1 file changed, 1 insertion(+)

diff --git a/test/mri/excludes/TestProc.rb b/test/mri/excludes/TestProc.rb
index a633c0661a9..c6352cae2ab 100644
--- a/test/mri/excludes/TestProc.rb
+++ b/test/mri/excludes/TestProc.rb
@@ -5,6 +5,7 @@
 exclude :test_dup_clone, "needs investigation"
 exclude :test_hash_does_not_change_after_compaction, "needs investigation"
 exclude :test_hash_equal, "needs investigation"
+exclude :test_implicit_parameters_for_it_complex, "parser needs to treat `it` assignment as a new local variable (https://github.com/jruby/jruby/issues/9265)"
 exclude :test_lambda_warning_pass_block, "fails in JIT mode on Linux CI on GHA"
 exclude :test_parameters, "needs investigation"
 exclude :test_proc_args_single_kw_no_autosplat, "needs investigation"

From 8bfae830cbe0cfce4a3c8bdcb86a84785b9eb5ce Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Thu, 26 Feb 2026 17:08:17 -0600
Subject: [PATCH 138/168] Exclude modified endless def syntax test

See https://github.com/jruby/jruby/issues/9266
---
 test/mri/excludes/TestSyntax.rb | 1 +
 1 file changed, 1 insertion(+)

diff --git a/test/mri/excludes/TestSyntax.rb b/test/mri/excludes/TestSyntax.rb
index 45c3d8df864..e9817d7795e 100644
--- a/test/mri/excludes/TestSyntax.rb
+++ b/test/mri/excludes/TestSyntax.rb
@@ -24,6 +24,7 @@
 exclude :test_it, "missing error for combining `it` with `_2`"
 exclude :test_keyword_invalid_name, "work in progress"
 exclude :test_keyword_self_reference, "circular variable reference error"
+exclude :test_methoddef_endless_command, "endless method with modifier call does not parse successfully (https://github.com/jruby/jruby/issues/9266)"
 exclude :test_numbered_parameter, "work in progress"
 exclude :test_optional_self_reference, "circular variable reference error"
 exclude :test_return_in_proc_in_class, "may be expecting SyntaxError for something but we reaise LocalJumpError at runtime"

From a889511e1dbf43346cc7411cf08a20cc515964db Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Thu, 26 Feb 2026 17:17:08 -0600
Subject: [PATCH 139/168] Exclude String#split/rsplit with selectors tests

See https://github.com/jruby/jruby/issues/9267
---
 test/mri/excludes/TestString.rb  | 11 +++++++++--
 test/mri/excludes/TestString2.rb |  6 ++++++
 2 files changed, 15 insertions(+), 2 deletions(-)

diff --git a/test/mri/excludes/TestString.rb b/test/mri/excludes/TestString.rb
index ee16aaf5085..9f8b2b44849 100644
--- a/test/mri/excludes/TestString.rb
+++ b/test/mri/excludes/TestString.rb
@@ -10,6 +10,8 @@
 exclude :test_encode_fallback_not_string_memory_leak, "no working assert_no_memory_leak method"
 exclude :test_encode_fallback_raise_memory_leak, "no working assert_no_memory_leak method"
 exclude :test_encode_fallback_too_big_memory_leak, "no working assert_no_memory_leak method"
+exclude :test_eq_tilde_can_be_overridden, "selectors are not yet supported (https://github.com/jruby/jruby/issues/9267)"
+exclude :test_fs, "aliased globals do not know their new name (https://github.com/jruby/jruby/issues/9177)"
 exclude :test_fs_setter, "needs investigation"
 exclude :test_grapheme_clusters, "unfinished in initial 2.6 work, #6161"
 exclude :test_grapheme_clusters_memory_leak, "no working assert_no_memory_leak method"
@@ -20,14 +22,21 @@
 exclude :test_initialize_memory_leak, "no working assert_no_memory_leak method"
 exclude :test_initialize_nofree_memory_leak, "no working assert_no_memory_leak method"
 exclude :test_inspect_next_line, "needs investigation"
+exclude :test_lstrip_bang_with_chars, "selectors are not yet supported (https://github.com/jruby/jruby/issues/9267)"
+exclude :test_lstrip_with_selectors, "selectors are not yet supported (https://github.com/jruby/jruby/issues/9267)"
 exclude :test_rindex, "needs investigation"
+exclude :test_rs, "aliased globals do not know their new name (https://github.com/jruby/jruby/issues/9177)"
 exclude :test_rstrip_bang, "needs investigation"
+exclude :test_rstrip_bang_with_chars, "selectors are not yet supported (https://github.com/jruby/jruby/issues/9267)"
+exclude :test_rstrip_with_selectors, "selectors are not yet supported (https://github.com/jruby/jruby/issues/9267)"
 exclude :test_scan_gc_compact_stress, "GC is not configurable"
 exclude :test_scan_segv, "requires ObjectSpace.each_object"
 exclude :test_split_with_block, "test for use-after-free in CRuby not possible in JRuby"
 exclude :test_start_with?, "needs investigation"
 exclude :test_start_with_timeout_memory_leak, "no working assert_no_memory_leak method"
 exclude :test_string_interpolations_across_heaps_get_embedded, "uses internal GC constants"
+exclude :test_strip_bang_with_chars, "selectors are not yet supported (https://github.com/jruby/jruby/issues/9267)"
+exclude :test_strip_with_selectors, "selectors are not yet supported (https://github.com/jruby/jruby/issues/9267)"
 exclude :test_sub_gc_compact_stress, "GC is not configurable"
 exclude :test_sum_2, "needs investigation"
 exclude :test_tr!, "needs investigation"
@@ -40,5 +49,3 @@
 exclude :test_undump, "unfinished in initial 2.6 work, #6161"
 exclude :test_undump_gc_compact_stress, "GC is not configurable"
 exclude :test_uplus_minus, "only seems to fail in a full test run"
-exclude :test_fs, "aliased globals do not know their new name (https://github.com/jruby/jruby/issues/9177)"
-exclude :test_rs, "aliased globals do not know their new name (https://github.com/jruby/jruby/issues/9177)"
diff --git a/test/mri/excludes/TestString2.rb b/test/mri/excludes/TestString2.rb
index e38a9ca0e98..753b704ba88 100644
--- a/test/mri/excludes/TestString2.rb
+++ b/test/mri/excludes/TestString2.rb
@@ -20,14 +20,20 @@
 exclude :test_initialize_memory_leak, "no working assert_no_memory_leak method"
 exclude :test_initialize_nofree_memory_leak, "no working assert_no_memory_leak method"
 exclude :test_inspect_next_line, "needs investigation"
+exclude :test_lstrip_bang_with_chars, "selectors are not yet supported (https://github.com/jruby/jruby/issues/9267)"
+exclude :test_lstrip_with_selectors, "selectors are not yet supported (https://github.com/jruby/jruby/issues/9267)"
 exclude :test_rindex, "needs investigation"
 exclude :test_rstrip_bang, "needs investigation"
+exclude :test_rstrip_bang_with_chars, "selectors are not yet supported (https://github.com/jruby/jruby/issues/9267)"
+exclude :test_rstrip_with_selectors, "selectors are not yet supported (https://github.com/jruby/jruby/issues/9267)"
 exclude :test_scan_gc_compact_stress, "GC is not configurable"
 exclude :test_scan_segv, "requires ObjectSpace.each_object"
 exclude :test_split_with_block, "test for use-after-free in CRuby not possible in JRuby"
 exclude :test_start_with?, "needs investigation"
 exclude :test_start_with_timeout_memory_leak, "no working assert_no_memory_leak method"
 exclude :test_string_interpolations_across_heaps_get_embedded, "uses internal GC constants"
+exclude :test_strip_bang_with_chars, "selectors are not yet supported (https://github.com/jruby/jruby/issues/9267)"
+exclude :test_strip_with_selectors, "selectors are not yet supported (https://github.com/jruby/jruby/issues/9267)"
 exclude :test_sub_gc_compact_stress, "GC is not configurable"
 exclude :test_sum_2, "needs investigation"
 exclude :test_tr!, "needs investigation"

From 83c17e8f613dd07d6d5268da726c9913f70ac5a9 Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Thu, 26 Feb 2026 17:30:14 -0600
Subject: [PATCH 140/168] Exclude rehash-during-update Hash tests

See https://github.com/jruby/jruby/issues/9268
---
 test/mri/excludes/TestHash.rb             | 1 +
 test/mri/excludes/TestHash/TestSubHash.rb | 1 +
 2 files changed, 2 insertions(+)

diff --git a/test/mri/excludes/TestHash.rb b/test/mri/excludes/TestHash.rb
index 7f806560c66..dcb9bd52057 100644
--- a/test/mri/excludes/TestHash.rb
+++ b/test/mri/excludes/TestHash.rb
@@ -3,3 +3,4 @@
 exclude :test_fetch_error, "needs investigation"
 exclude :test_inspect, "not matching special symbols requiring hashrocket vs colon"
 exclude :test_st_literal_memory_leak, "no working assert_no_memory_leak method"
+exclude :test_update_modify_in_block, "JRuby Hash does not detect or prevent modification during iteration (https://github.com/jruby/jruby/issues/9268)"
diff --git a/test/mri/excludes/TestHash/TestSubHash.rb b/test/mri/excludes/TestHash/TestSubHash.rb
index cff51669777..e26b99e2575 100644
--- a/test/mri/excludes/TestHash/TestSubHash.rb
+++ b/test/mri/excludes/TestHash/TestSubHash.rb
@@ -3,3 +3,4 @@
 exclude :test_inspect, "not matching special symbols requiring hashrocket vs colon"
 exclude :test_replace_memory_leak, "no working assert_no_memory_leak method"
 exclude :test_st_literal_memory_leak, "no working assert_no_memory_leak method"
+exclude :test_update_modify_in_block, "JRuby Hash does not detect or prevent modification during iteration (https://github.com/jruby/jruby/issues/9268)"

From 2822e7cf03cf30b052ee0b6f7361bdb7dfd24e88 Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Thu, 26 Feb 2026 17:30:36 -0600
Subject: [PATCH 141/168] Exclude deadlock output test

JRuby does not detect deadlock beyond what JVM already does (only
when dumping thread statuses).
---
 test/mri/excludes/TestThread.rb | 1 +
 1 file changed, 1 insertion(+)

diff --git a/test/mri/excludes/TestThread.rb b/test/mri/excludes/TestThread.rb
index 112780e7815..608024fb80a 100644
--- a/test/mri/excludes/TestThread.rb
+++ b/test/mri/excludes/TestThread.rb
@@ -1,4 +1,5 @@
 exclude :test_abort_on_exception, "very sensitive to thread timing and parallelism"
+exclude :test_deadlock_backtrace, "JRuby does not do deadlock detection beyond what JVM provides"
 exclude :test_inspect_with_fiber, "Thread.current is known to reflect the fiber, not the thread, in JRuby"
 exclude :test_list, "JVM finalizer threads get adopted, randomly skewing the result (#4960)"
 exclude :test_machine_stack_size, "slow and unreliable"

From b4068f1d21dbf4e67a0aa574c0041ecb71bc44c9 Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Thu, 26 Feb 2026 17:37:26 -0600
Subject: [PATCH 142/168] Exclude tests for alternative pattern with local vars

Does not parse currently.

See https://github.com/jruby/jruby/issues/9269
---
 test/mri/excludes/TestPatternMatching.rb | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/test/mri/excludes/TestPatternMatching.rb b/test/mri/excludes/TestPatternMatching.rb
index a74f1125f40..dbd06eb71b3 100644
--- a/test/mri/excludes/TestPatternMatching.rb
+++ b/test/mri/excludes/TestPatternMatching.rb
@@ -1,3 +1,5 @@
+exclude :test_alternative_pattern, "alternative patterns with local variables do not parse (https://github.com/jruby/jruby/issues/9269)"
+exclude :test_alternative_pattern_nested, "alternative patterns with local variables do not parse (https://github.com/jruby/jruby/issues/9269)"
 exclude :test_hash_pattern, "work in progress"
 exclude :test_single_pattern_error_find_pattern, "work in progress"
 exclude :test_single_pattern_error_guard_clause, "work in progress"

From 8fc6e9d7bf11f935def28c6a7ff1d739e6d317a4 Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Thu, 26 Feb 2026 17:52:07 -0600
Subject: [PATCH 143/168] These complex block+call forms do not parse

See https://github.com/jruby/jruby/issues/9270
---
 test/mri/excludes/TestParse.rb | 1 +
 1 file changed, 1 insertion(+)

diff --git a/test/mri/excludes/TestParse.rb b/test/mri/excludes/TestParse.rb
index c14c74fb579..210234cacf7 100644
--- a/test/mri/excludes/TestParse.rb
+++ b/test/mri/excludes/TestParse.rb
@@ -1,4 +1,5 @@
 exclude :test_assign_in_conditional, "needs investigation"
+exclude :test_call_command, "does not parse (https://github.com/jruby/jruby/issues/9270)"
 exclude :test_define_singleton_error, "work in progress"
 exclude :test_dynamic_constant_assignment, "needs investigation"
 exclude :test_embedded_rd, "work in progress"

From ccf62915525726237cd11de5e30e0428741caac4 Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Thu, 26 Feb 2026 18:07:25 -0600
Subject: [PATCH 144/168] Disallow recursive userdef dumps

See https://github.com/ruby/ruby/pull/12914
---
 .../java/org/jruby/runtime/marshal/MarshalDumper.java  | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/core/src/main/java/org/jruby/runtime/marshal/MarshalDumper.java b/core/src/main/java/org/jruby/runtime/marshal/MarshalDumper.java
index 5f733d63a51..9580dbaa3a1 100644
--- a/core/src/main/java/org/jruby/runtime/marshal/MarshalDumper.java
+++ b/core/src/main/java/org/jruby/runtime/marshal/MarshalDumper.java
@@ -67,6 +67,7 @@
 
 import java.io.Serializable;
 import java.nio.charset.StandardCharsets;
+import java.util.IdentityHashMap;
 import java.util.Map;
 import java.util.function.BiConsumer;
 
@@ -91,6 +92,8 @@ public class MarshalDumper {
     private final HashMapInt<IRubyObject> linkCache = new HashMapInt<>(4, true);
     // lazy for simple cases that encounter no symbols
     private HashMapInt<RubySymbol> symbolCache;
+    // lazy unless userdef dumps are needed
+    private IdentityHashMap<IRubyObject, Object> activeUserdefs;
 
     public MarshalDumper(int depthLimit) {
         this.depthLimit = depthLimit >= 0 ? depthLimit : Integer.MAX_VALUE;
@@ -437,6 +440,10 @@ private void userCommon(ThreadContext context, RubyOutputStream out, IRubyObject
         
         RubyString marshaled = castAsString(context, dumpResult);
 
+        if (activeUserdefs != null && activeUserdefs.containsKey(value)) {
+            throw runtimeError(context, "can't dump recursive object using _dump()");
+        }
+
         if (marshaled.hasVariables()) {
             var ivarAccessors = countVariables(marshaled);
             int size = variableCount;
@@ -448,7 +455,10 @@ private void userCommon(ThreadContext context, RubyOutputStream out, IRubyObject
 
                 writeInt(out, size);
 
+                if (activeUserdefs == null) activeUserdefs = new IdentityHashMap<>();
+                activeUserdefs.put(value, null);
                 ivarAccessors.forEach(new VariableDumper(context, out, marshaled));
+                activeUserdefs.remove(value);
             } else {
                 dumpUserdefBase(context, out, klass, marshaled);
             }

From a797c550bd71aa9028dc9f6456e893132aa2df2e Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Fri, 27 Feb 2026 18:56:24 -0600
Subject: [PATCH 145/168] Exclude new Ruby 4.0 OpenSSL failures

We'll address these in jruby-openssl via fixes in
jruby/jruby-openssl#341 etc.

See https://github.com/jruby/jruby/issues/9271
---
 test/mri/excludes/OpenSSL/TestASN1.rb            |  2 ++
 test/mri/excludes/OpenSSL/TestCipher.rb          |  1 +
 test/mri/excludes/OpenSSL/TestDigest.rb          |  2 ++
 test/mri/excludes/OpenSSL/TestEC.rb              |  4 ++++
 test/mri/excludes/OpenSSL/TestKDF.rb             |  3 +++
 test/mri/excludes/OpenSSL/TestOSSL.rb            |  1 +
 test/mri/excludes/OpenSSL/TestPKCS7.rb           |  6 ++++++
 test/mri/excludes/OpenSSL/TestPKey.rb            |  6 ++++++
 test/mri/excludes/OpenSSL/TestPKeyDH.rb          |  1 +
 test/mri/excludes/OpenSSL/TestPKeyDSA.rb         |  7 +++++++
 test/mri/excludes/OpenSSL/TestPKeyRSA.rb         |  4 ++++
 test/mri/excludes/OpenSSL/TestSSL.rb             | 15 +++++++++++++++
 test/mri/excludes/OpenSSL/TestX509CRL.rb         |  2 ++
 test/mri/excludes/OpenSSL/TestX509Certificate.rb |  2 ++
 test/mri/excludes/OpenSSL/TestX509Request.rb     |  5 +++++
 15 files changed, 61 insertions(+)
 create mode 100644 test/mri/excludes/OpenSSL/TestKDF.rb
 create mode 100644 test/mri/excludes/OpenSSL/TestOSSL.rb

diff --git a/test/mri/excludes/OpenSSL/TestASN1.rb b/test/mri/excludes/OpenSSL/TestASN1.rb
index bb0190a6d74..a6dfab8c80f 100644
--- a/test/mri/excludes/OpenSSL/TestASN1.rb
+++ b/test/mri/excludes/OpenSSL/TestASN1.rb
@@ -10,6 +10,7 @@
 exclude :test_decode_constructed_overread, "work in progress"
 exclude :test_decode_x509_certificate, "work in progress"
 exclude :test_end_of_content, "work in progress"
+exclude :test_generalizedtime, "new failure with Ruby 4.0 tests, tested on MacOS, https://github.com/jruby/jruby/issues/9271"
 exclude :test_object_identifier, "work in progress"
 exclude :test_octet_string_constructed_tagging, "work in progress"
 exclude :test_octet_string_infinite_length_explicit_tagging, 'needs investigation'
@@ -21,3 +22,4 @@
 exclude :test_sequence, "work in progress"
 exclude :test_set, "work in progress"
 exclude :test_string_basic, "work in progress"
+exclude :test_utctime, "new failure with Ruby 4.0 tests, tested on MacOS, https://github.com/jruby/jruby/issues/9271"
diff --git a/test/mri/excludes/OpenSSL/TestCipher.rb b/test/mri/excludes/OpenSSL/TestCipher.rb
index 495a6a68803..d743b4f0c3f 100644
--- a/test/mri/excludes/OpenSSL/TestCipher.rb
+++ b/test/mri/excludes/OpenSSL/TestCipher.rb
@@ -1,6 +1,7 @@
 exclude :test_AES, 'works - just need to enable JCE unlimited strength'
 exclude :test_AES_crush, 'needs investigation'
 exclude :test_aes_gcm, "work in progress"
+exclude :test_auth_tag_error_inheritance, "new failure with Ruby 4.0 tests, tested on MacOS, https://github.com/jruby/jruby/issues/9271"
 exclude :test_ciphers, "work in progress"
 exclude :test_crypt_after_key, "work in progress"
 exclude :test_key_iv_set, "work in progress"
diff --git a/test/mri/excludes/OpenSSL/TestDigest.rb b/test/mri/excludes/OpenSSL/TestDigest.rb
index 73eb16f2dcd..a643fe9b328 100644
--- a/test/mri/excludes/OpenSSL/TestDigest.rb
+++ b/test/mri/excludes/OpenSSL/TestDigest.rb
@@ -1,3 +1,5 @@
+exclude :test_digest_by_oid_and_name, "new failure with Ruby 4.0 tests, tested on MacOS, https://github.com/jruby/jruby/issues/9271, Unsupported digest algorithm (RSA-SHA256)"
 exclude :test_digests, "work in progress"
+exclude :test_initialize, "new failure with Ruby 4.0 tests, tested on MacOS, https://github.com/jruby/jruby/issues/9271, uninitialized constant OpenSSL::Digest::DigestError"
 exclude :test_sha3, "work in progress"
 exclude :test_sha512_truncate, "work in progress"
diff --git a/test/mri/excludes/OpenSSL/TestEC.rb b/test/mri/excludes/OpenSSL/TestEC.rb
index 6b253f280bf..31cc3b8959c 100644
--- a/test/mri/excludes/OpenSSL/TestEC.rb
+++ b/test/mri/excludes/OpenSSL/TestEC.rb
@@ -7,8 +7,12 @@
 exclude :test_dsa_sign_asn1_FIPS186_3, "work in progress"
 exclude :test_ec_group, "work in progress"
 exclude :test_ec_key, "work in progress"
+exclude :test_ec_key_new, "new failure with Ruby 4.0 tests, tested on MacOS, https://github.com/jruby/jruby/issues/9271, private key as well as public key are null"
+exclude :test_ec_key_new_empty, "new failure with Ruby 4.0 tests, tested on MacOS, https://github.com/jruby/jruby/issues/9271, null curve name"
 exclude :test_ec_point, "work in progress"
 exclude :test_ec_point_add, "work in progress"
 exclude :test_ec_point_mul, "work in progress"
+exclude :test_generate, "new failure with Ruby 4.0 tests, tested on MacOS, https://github.com/jruby/jruby/issues/9271"
 exclude :test_generate_key, "work in progress"
 exclude :test_sign_verify_raw, "work in progress"
+exclude :test_small_curve, "new failure with Ruby 4.0 tests, tested on MacOS, https://github.com/jruby/jruby/issues/9271, null curve name"
diff --git a/test/mri/excludes/OpenSSL/TestKDF.rb b/test/mri/excludes/OpenSSL/TestKDF.rb
new file mode 100644
index 00000000000..208b59cb061
--- /dev/null
+++ b/test/mri/excludes/OpenSSL/TestKDF.rb
@@ -0,0 +1,3 @@
+exclude :test_hkdf_rfc5869_test_case_1, "new failure with Ruby 4.0 tests, tested on MacOS, https://github.com/jruby/jruby/issues/9271, undefined method 'hkdf' for module OpenSSL::KDF"
+exclude :test_hkdf_rfc5869_test_case_3, "new failure with Ruby 4.0 tests, tested on MacOS, https://github.com/jruby/jruby/issues/9271, undefined method 'hkdf' for module OpenSSL::KDF"
+exclude :test_hkdf_rfc5869_test_case_4, "new failure with Ruby 4.0 tests, tested on MacOS, https://github.com/jruby/jruby/issues/9271, undefined method 'hkdf' for module OpenSSL::KDF"
diff --git a/test/mri/excludes/OpenSSL/TestOSSL.rb b/test/mri/excludes/OpenSSL/TestOSSL.rb
new file mode 100644
index 00000000000..800d7b89451
--- /dev/null
+++ b/test/mri/excludes/OpenSSL/TestOSSL.rb
@@ -0,0 +1 @@
+exclude :test_error_data, "new failure with Ruby 4.0 tests, tested on MacOS, https://github.com/jruby/jruby/issues/9271, IllegalArgumentException: IP Address is invalid"
diff --git a/test/mri/excludes/OpenSSL/TestPKCS7.rb b/test/mri/excludes/OpenSSL/TestPKCS7.rb
index 70a7882e308..9b256a958fd 100644
--- a/test/mri/excludes/OpenSSL/TestPKCS7.rb
+++ b/test/mri/excludes/OpenSSL/TestPKCS7.rb
@@ -1,6 +1,12 @@
+exclude :test_data, "new failure with Ruby 4.0 tests, tested on MacOS, https://github.com/jruby/jruby/issues/9271, PKCS7Error: PKCS7[Method: 105, Reason: 112, Data: null]"
+exclude :test_decode_ber_constructed_string, "new failure with Ruby 4.0 tests, tested on MacOS, https://github.com/jruby/jruby/issues/9271, need to retrieve Cipher from String parameter"
+exclude :test_detached_sign, "new failure with Ruby 4.0 tests, tested on MacOS, https://github.com/jruby/jruby/issues/9271"
 exclude :test_empty_signed_data_ruby_bug_19974, "work in progress"
 exclude :test_enveloped, "work in progress"
+exclude :test_enveloped_add_recipient, "new failure with Ruby 4.0 tests, tested on MacOS, https://github.com/jruby/jruby/issues/9271, PKCS7Error: PKCS7[Method: 105, Reason: 116, Data: null]"
 exclude :test_graceful_parsing_failure, 'needs investigation'
 exclude :test_signed_add_signer, "work in progress"
+exclude :test_signed_authenticated_attributes, "new failure with Ruby 4.0 tests, tested on MacOS, https://github.com/jruby/jruby/issues/9271"
+exclude :test_signed_flags, "new failure with Ruby 4.0 tests, tested on MacOS, https://github.com/jruby/jruby/issues/9271, NullPointerException: 'element' cannot be null in SignerInfoWithPkey.toASN1Object"
 exclude :test_smime, "work in progress"
 exclude :test_to_text, "work in progress"
diff --git a/test/mri/excludes/OpenSSL/TestPKey.rb b/test/mri/excludes/OpenSSL/TestPKey.rb
index 03e943093d3..a6d3ea0440d 100644
--- a/test/mri/excludes/OpenSSL/TestPKey.rb
+++ b/test/mri/excludes/OpenSSL/TestPKey.rb
@@ -1,8 +1,14 @@
 exclude :"test_compare?", "work in progress"
 exclude :test_ed25519, "work in progress"
 exclude :test_generic_oid_inspect, "work in progress"
+exclude :test_generic_oid_inspect_rsa, "new failure with Ruby 4.0 tests, tested on MacOS, https://github.com/jruby/jruby/issues/9271"
 exclude :test_hmac_sign_verify, "work in progress"
+exclude :test_legacy_error_classes, "new failure with Ruby 4.0 tests, tested on MacOS, https://github.com/jruby/jruby/issues/9271"
+exclude :test_raw_initialize_errors, "new failure with Ruby 4.0 tests, tested on MacOS, https://github.com/jruby/jruby/issues/9271"
 exclude :test_s_generate_key, "work in progress"
 exclude :test_s_generate_parameters, "work in progress"
 exclude :test_s_generate_parameters_with_block, "work in progress"
+exclude :test_s_read_der_then_pem, "new failure with Ruby 4.0 tests, tested on MacOS, https://github.com/jruby/jruby/issues/9271, undefined method 'private_to_pem' for an instance of OpenSSL::PKey::RSA"
+exclude :test_s_read_passphrase, "new failure with Ruby 4.0 tests, tested on MacOS, https://github.com/jruby/jruby/issues/9271, undefined method 'private_to_pem' for an instance of OpenSSL::PKey::RSA"
+exclude :test_s_read_pem_unknown_block, "new failure with Ruby 4.0 tests, tested on MacOS, https://github.com/jruby/jruby/issues/9271, undefined method 'private_to_pem' for an instance of OpenSSL::PKey::RSA"
 exclude :test_x25519, "work in progress"
diff --git a/test/mri/excludes/OpenSSL/TestPKeyDH.rb b/test/mri/excludes/OpenSSL/TestPKeyDH.rb
index 2952eb18e5e..c79466b24ad 100644
--- a/test/mri/excludes/OpenSSL/TestPKeyDH.rb
+++ b/test/mri/excludes/OpenSSL/TestPKeyDH.rb
@@ -6,5 +6,6 @@
 exclude :test_marshal, "work in progress"
 exclude :test_new_break, 'needs investigation'
 exclude :test_new_break_on_non_fips, "hangs (tested on macos M1)"
+exclude :test_params, "new failure with Ruby 4.0 tests, tested on MacOS, https://github.com/jruby/jruby/issues/9271"
 exclude :test_params_ok?, "work in progress"
 exclude :test_public_key, 'needs investigation'
diff --git a/test/mri/excludes/OpenSSL/TestPKeyDSA.rb b/test/mri/excludes/OpenSSL/TestPKeyDSA.rb
index 3fd9c1685fe..b35eba94b6c 100644
--- a/test/mri/excludes/OpenSSL/TestPKeyDSA.rb
+++ b/test/mri/excludes/OpenSSL/TestPKeyDSA.rb
@@ -1,5 +1,12 @@
+exclude :test_DSAPrivateKey, "new failure with Ruby 4.0 tests, tested on MacOS, https://github.com/jruby/jruby/issues/9271, IllegalArgumentException: Bad sequence size: 3"
+exclude :test_DSAPrivateKey_encrypted, "new failure with Ruby 4.0 tests, tested on MacOS, https://github.com/jruby/jruby/issues/9271, IllegalArgumentException: Bad sequence size: 3"
+exclude :test_PUBKEY, "new failure with Ruby 4.0 tests, tested on MacOS, https://github.com/jruby/jruby/issues/9271, IllegalArgumentException: Bad sequence size: 3"
 exclude :test_dup, 'passes except for setting (invalid) `key2.p + 1` as validation happens early'
 exclude :test_export_password_length, 'needs investigation'
+exclude :test_marshal, "new failure with Ruby 4.0 tests, tested on MacOS, https://github.com/jruby/jruby/issues/9271, IllegalArgumentException: Bad sequence size: 3"
 exclude :test_new_break, 'needs investigation'
+exclude :test_new_empty, "new failure with Ruby 4.0 tests, tested on MacOS, https://github.com/jruby/jruby/issues/9271"
+exclude :test_params, "new failure with Ruby 4.0 tests, tested on MacOS, https://github.com/jruby/jruby/issues/9271, IllegalArgumentException: Bad sequence size: 3"
+exclude :test_private, "new failure with Ruby 4.0 tests, tested on MacOS, https://github.com/jruby/jruby/issues/9271, IllegalArgumentException: Bad sequence size: 3"
 exclude :test_sign_verify, "work in progress"
 exclude :test_sign_verify_raw, "TODO: sign_raw not implemented"
diff --git a/test/mri/excludes/OpenSSL/TestPKeyRSA.rb b/test/mri/excludes/OpenSSL/TestPKeyRSA.rb
index 3f35458101d..ff9c0340acf 100644
--- a/test/mri/excludes/OpenSSL/TestPKeyRSA.rb
+++ b/test/mri/excludes/OpenSSL/TestPKeyRSA.rb
@@ -1,9 +1,12 @@
+exclude :test_RSAPrivateKey_encrypted, "new failure with Ruby 4.0 tests, tested on MacOS, https://github.com/jruby/jruby/issues/9271"
 exclude :test_dup, "work in progress"
 exclude :test_encrypt_decrypt, "work in progress"
 exclude :test_encrypt_decrypt_legacy, "work in progress"
 exclude :test_export, "work in progress"
 exclude :test_export_password_length, 'needs investigation'
 exclude :test_new_break, 'needs investigation'
+exclude :test_no_private_exp, "new failure with Ruby 4.0 tests, tested on MacOS, https://github.com/jruby/jruby/issues/9271"
+exclude :test_params, "new failure with Ruby 4.0 tests, tested on MacOS, https://github.com/jruby/jruby/issues/9271"
 exclude :test_pem_passwd, "work in progress"
 exclude :test_private_encoding, "work in progress"
 exclude :test_private_encoding_encrypted, "work in progress"
@@ -12,4 +15,5 @@
 exclude :test_sign_verify_options, "work in progress"
 exclude :test_sign_verify_pss, "work in progress"
 exclude :test_sign_verify_raw, "work in progress"
+exclude :test_sign_verify_raw_legacy, "new failure with Ruby 4.0 tests, tested on MacOS, https://github.com/jruby/jruby/issues/9271"
 exclude :test_to_der, "work in progress"
diff --git a/test/mri/excludes/OpenSSL/TestSSL.rb b/test/mri/excludes/OpenSSL/TestSSL.rb
index 2bf58fa257e..7600410d848 100644
--- a/test/mri/excludes/OpenSSL/TestSSL.rb
+++ b/test/mri/excludes/OpenSSL/TestSSL.rb
@@ -6,8 +6,13 @@
 exclude :test_ciphers_method_bogus_csuite, "work in progress"
 exclude :test_ciphers_method_frozen_object, "work in progress"
 exclude :test_ciphers_method_tls_connection, "work in progress"
+exclude :test_ciphersuites_method_bogus_csuite, "new failure with Ruby 4.0 tests, tested on MacOS, https://github.com/jruby/jruby/issues/9271, missing method on SSLContext"
+exclude :test_ciphersuites_method_frozen_object, "new failure with Ruby 4.0 tests, tested on MacOS, https://github.com/jruby/jruby/issues/9271"
+exclude :test_ciphersuites_method_nil_argument, "new failure with Ruby 4.0 tests, tested on MacOS, https://github.com/jruby/jruby/issues/9271, missing method on SSLContext"
+exclude :test_ciphersuites_method_tls_connection, "new failure with Ruby 4.0 tests, tested on MacOS, https://github.com/jruby/jruby/issues/9271, missing method on SSLContext"
 exclude :test_client_ca, 'needs investigation'
 exclude :test_client_cert_cb_ignore_error, "work in progress"
+exclude :test_client_sigalgs, "new failure with Ruby 4.0 tests, tested on MacOS, https://github.com/jruby/jruby/issues/9271, undefined method 'client_sigalgs=' for an instance of OpenSSL::SSL::SSLContext"
 exclude :test_connect_certificate_verify_failed_exception_message, "work in progress"
 exclude :test_connect_works_when_setting_dh_callback_to_nil, "work in progress"
 exclude :test_ctx_options_config, "work in progress"
@@ -17,11 +22,13 @@
 exclude :test_ecdh_curves_tls13, "work in progress"
 exclude :test_exception_in_verify_callback_is_ignored, "work in progress"
 exclude :test_export_keying_material, "work in progress"
+exclude :test_extra_chain_cert_auto_chain, "new failure with Ruby 4.0 tests, tested on MacOS, https://github.com/jruby/jruby/issues/9271"
 exclude :test_finished_messages, 'hangs for a long time and then fails'
 exclude :test_freeze_calls_setup, "work in progress"
 exclude :test_get_ephemeral_key, "work in progress"
 exclude :test_getbyte, "work in progress"
 exclude :test_keylog_cb, "work in progress"
+exclude :test_minmax_version_system_default, "new failure with Ruby 4.0 tests, tested on MacOS, https://github.com/jruby/jruby/issues/9271, TLS version mismatch"
 exclude :test_npn_advertised_protocol_too_long, 'SSLContext#npn_protocols= not supported'
 exclude :test_npn_protocol_selection_ary, 'SSLContext#npn_protocols= not supported'
 exclude :test_npn_protocol_selection_cancel, 'SSLContext#npn_protocols= not supported'
@@ -33,16 +40,24 @@
 exclude :test_read_nonblock_without_session, 'HANGS'
 exclude :test_readbyte, "work in progress"
 exclude :test_renegotiation_cb, 'SSLContext#renegotiation_cb= not supported'
+exclude :test_respect_system_default_min, "new failure with Ruby 4.0 tests, tested on MacOS, https://github.com/jruby/jruby/issues/9271"
+exclude :test_s_read_der_then_pem, "new failure with Ruby 4.0 tests, tested on MacOS, https://github.com/jruby/jruby/issues/9271, undefined method 'private_to_pem' for an instance of OpenSSL::PKey::RSA"
+exclude :test_s_read_passphrase, "new failure with Ruby 4.0 tests, tested on MacOS, https://github.com/jruby/jruby/issues/9271, undefined method 'private_to_pem' for an instance of OpenSSL::PKey::RSA"
+exclude :test_s_read_pem_unknown_block, "new failure with Ruby 4.0 tests, tested on MacOS, https://github.com/jruby/jruby/issues/9271, undefined method 'private_to_pem' for an instance of OpenSSL::PKey::RSA"
 exclude :test_security_level, "work in progress"
 exclude :test_servername_cb, 'Errno::EOPNOTSUPP: Operation not supported - Socket.socketpair only supports streaming UNIX sockets'
 exclude :test_servername_cb_calls_setup_on_returned_ctx, 'Errno::EOPNOTSUPP: Operation not supported - Socket.socketpair only supports streaming UNIX sockets'
 exclude :test_servername_cb_can_return_nil, 'Errno::EOPNOTSUPP: Operation not supported - Socket.socketpair only supports streaming UNIX sockets'
 exclude :test_servername_cb_raises_an_exception_on_unknown_objects, 'Errno::EOPNOTSUPP: Operation not supported - Socket.socketpair only supports streaming UNIX sockets'
 exclude :test_servername_cb_sets_context_on_the_socket, 'Errno::EOPNOTSUPP: Operation not supported - Socket.socketpair only supports streaming UNIX sockets'
+exclude :test_set_groups_tls12, "new failure with Ruby 4.0 tests, tested on MacOS, https://github.com/jruby/jruby/issues/9271, OpenSSL::SSL::SSLError: no cipher match"
+exclude :test_set_groups_tls13, "new failure with Ruby 4.0 tests, tested on MacOS, https://github.com/jruby/jruby/issues/9271, undefined method 'groups=' for an instance of OpenSSL::SSL::SSLContext"
+exclude :test_sigalgs, "new failure with Ruby 4.0 tests, tested on MacOS, https://github.com/jruby/jruby/issues/9271, undefined method 'add_certificate' for an instance of OpenSSL::SSL::SSLContext"
 exclude :test_socket_close_write, "work in progress"
 exclude :test_ssl_sysread_blocking_error, 'works except JRuby-OpenSSL does not raise TypeError on SSLSocket#sysread(4, exception: false)'
 exclude :test_ssl_with_server_cert, "work in progress"
 exclude :test_sslctx_set_params, "work in progress"
+exclude :test_sysread_and_syswrite, "new failure with Ruby 4.0 tests, tested on MacOS, https://github.com/jruby/jruby/issues/9271, appears to hang and timeout"
 exclude :test_tlsext_hostname, "work in progress"
 exclude :test_tmp_dh, "work in progress"
 exclude :test_tmp_dh_callback, "work in progress"
diff --git a/test/mri/excludes/OpenSSL/TestX509CRL.rb b/test/mri/excludes/OpenSSL/TestX509CRL.rb
index 046523ecd2e..14c2762fa51 100644
--- a/test/mri/excludes/OpenSSL/TestX509CRL.rb
+++ b/test/mri/excludes/OpenSSL/TestX509CRL.rb
@@ -1,5 +1,7 @@
+exclude :test_basic, "new failure with Ruby 4.0 tests, tested on MacOS, https://github.com/jruby/jruby/issues/9271"
 exclude :test_eq, "work in progress"
 exclude :test_extension, "work in progress"
 exclude :test_marshal, "work in progress"
 exclude :test_revoked_to_der, "work in progress"
 exclude :test_sign_and_verify_ed25519, "work in progress"
+exclude :test_sign_and_verify_nil_digest, "new failure with Ruby 4.0 tests, tested on MacOS, https://github.com/jruby/jruby/issues/9271"
diff --git a/test/mri/excludes/OpenSSL/TestX509Certificate.rb b/test/mri/excludes/OpenSSL/TestX509Certificate.rb
index a4b605e0817..bf072be7b3c 100644
--- a/test/mri/excludes/OpenSSL/TestX509Certificate.rb
+++ b/test/mri/excludes/OpenSSL/TestX509Certificate.rb
@@ -5,6 +5,8 @@
 exclude :test_crl_uris_no_uris, "work in progress"
 exclude :test_eq, "work in progress"
 exclude :test_extension, "work in progress"
+exclude :test_inspect, "new failure with Ruby 4.0 tests, tested on MacOS, https://github.com/jruby/jruby/issues/9271"
+exclude :test_sign_and_verify_nil_digest, "new failure with Ruby 4.0 tests, tested on MacOS, https://github.com/jruby/jruby/issues/9271, undefined method 'generate_key' for module OpenSSL::PKey"
 exclude :test_invalid_extension, "work in progress"
 exclude :test_load_file_certificate_der, "work in progress"
 exclude :test_load_file_empty_pem, "work in progress"
diff --git a/test/mri/excludes/OpenSSL/TestX509Request.rb b/test/mri/excludes/OpenSSL/TestX509Request.rb
index 3a9872df215..fc9d89ef885 100644
--- a/test/mri/excludes/OpenSSL/TestX509Request.rb
+++ b/test/mri/excludes/OpenSSL/TestX509Request.rb
@@ -2,7 +2,12 @@
 exclude :test_dup, "work in progress"
 exclude :test_eq, "work in progress"
 exclude :test_marshal, "work in progress"
+exclude :test_public_key, "new failure with Ruby 4.0 tests, tested on MacOS, https://github.com/jruby/jruby/issues/9271, Digest must be retrieve from String parameter"
 exclude :test_sign_and_verify, 'Version broke in recent rewrite'
 exclude :test_sign_and_verify_ed25519, "work in progress"
+exclude :test_sign_and_verify_nil_digest, "new failure with Ruby 4.0 tests, tested on MacOS, https://github.com/jruby/jruby/issues/9271, undefined method 'generate_key' for module OpenSSL::PKey"
 exclude :test_sign_and_verify_rsa_sha1, "work in progress"
+exclude :test_sign_digest_instance, "new failure with Ruby 4.0 tests, tested on MacOS, https://github.com/jruby/jruby/issues/9271, Digest must be retrieve from String parameter"
+exclude :test_signature_algorithm, "new failure with Ruby 4.0 tests, tested on MacOS, https://github.com/jruby/jruby/issues/9271, Digest must be retrieve from String parameter"
+exclude :test_subject, "new failure with Ruby 4.0 tests, tested on MacOS, https://github.com/jruby/jruby/issues/9271, Digest must be retrieve from String parameter"
 exclude :test_version, 'Version broke in recent rewrite'

From be519a6de4ed6b9b83506d3e36ec14c6a8da60da Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Sat, 28 Feb 2026 13:56:11 -0600
Subject: [PATCH 146/168] Exclude another HTTP proxy test that appears to hang

Test on MacOS
---
 test/mri/excludes/TestOpenURIProxy.rb | 1 +
 1 file changed, 1 insertion(+)

diff --git a/test/mri/excludes/TestOpenURIProxy.rb b/test/mri/excludes/TestOpenURIProxy.rb
index 7b9abc58a11..176191328d1 100644
--- a/test/mri/excludes/TestOpenURIProxy.rb
+++ b/test/mri/excludes/TestOpenURIProxy.rb
@@ -1,3 +1,4 @@
 exclude :test_authenticated_proxy_http_basic_authentication_success, "hangs on Linux or very slow"
 exclude :test_proxy, "hangs or very slow on Linux"
 exclude :test_proxy_http_basic_authentication_failure, "hangs or very slow on Linux"
+exclude :test_proxy_http_basic_authentication_success, "hangs or very slow on MacOS"

From d52a9ed91280b950301f8cf5612958ae1e25b956 Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Sat, 28 Feb 2026 14:24:39 -0600
Subject: [PATCH 147/168] Update socket.rb from CRuby

---
 lib/ruby/stdlib/socket.rb | 103 +++++++++++++++++++++++++++-----------
 1 file changed, 73 insertions(+), 30 deletions(-)

diff --git a/lib/ruby/stdlib/socket.rb b/lib/ruby/stdlib/socket.rb
index 889c523c843..4455bde2756 100644
--- a/lib/ruby/stdlib/socket.rb
+++ b/lib/ruby/stdlib/socket.rb
@@ -63,7 +63,7 @@ def connect_internal(local_addrinfo, timeout=nil) # :yields: socket
           break
         when :wait_writable
           sock.wait_writable(timeout) or
-            raise Errno::ETIMEDOUT, 'user specified timeout'
+            raise Errno::ETIMEDOUT, "user specified timeout for #{self.ip_address}:#{self.ip_port}"
         end while true
       else
         sock.connect(self)
@@ -615,8 +615,9 @@ def ipv6only!
   HOSTNAME_RESOLUTION_QUEUE_UPDATED = 0
   private_constant :HOSTNAME_RESOLUTION_QUEUE_UPDATED
 
-  IPV6_ADRESS_FORMAT = /\A(?i:(?:(?:[0-9A-F]{1,4}:){7}(?:[0-9A-F]{1,4}|:)|(?:[0-9A-F]{1,4}:){6}(?:[0-9A-F]{1,4}|:(?:[0-9A-F]{1,4}:){1,5}[0-9A-F]{1,4}|:)|(?:[0-9A-F]{1,4}:){5}(?:(?::[0-9A-F]{1,4}){1,2}|:(?:[0-9A-F]{1,4}:){1,4}[0-9A-F]{1,4}|:)|(?:[0-9A-F]{1,4}:){4}(?:(?::[0-9A-F]{1,4}){1,3}|:(?:[0-9A-F]{1,4}:){1,3}[0-9A-F]{1,4}|:)|(?:[0-9A-F]{1,4}:){3}(?:(?::[0-9A-F]{1,4}){1,4}|:(?:[0-9A-F]{1,4}:){1,2}[0-9A-F]{1,4}|:)|(?:[0-9A-F]{1,4}:){2}(?:(?::[0-9A-F]{1,4}){1,5}|:(?:[0-9A-F]{1,4}:)[0-9A-F]{1,4}|:)|(?:[0-9A-F]{1,4}:){1}(?:(?::[0-9A-F]{1,4}){1,6}|:(?:[0-9A-F]{1,4}:){0,5}[0-9A-F]{1,4}|:)|(?:::(?:[0-9A-F]{1,4}:){0,7}[0-9A-F]{1,4}|::)))(?:%.+)?\z/
-  private_constant :IPV6_ADRESS_FORMAT
+  IPV6_ADDRESS_FORMAT = /\A(?i:(?:(?:[0-9A-F]{1,4}:){7}(?:[0-9A-F]{1,4}|:)|(?:[0-9A-F]{1,4}:){6}(?:[0-9A-F]{1,4}|:(?:[0-9A-F]{1,4}:){1,5}[0-9A-F]{1,4}|:)|(?:[0-9A-F]{1,4}:){5}(?:(?::[0-9A-F]{1,4}){1,2}|:(?:[0-9A-F]{1,4}:){1,4}[0-9A-F]{1,4}|:)|(?:[0-9A-F]{1,4}:){4}(?:(?::[0-9A-F]{1,4}){1,3}|:(?:[0-9A-F]{1,4}:){1,3}[0-9A-F]{1,4}|:)|(?:[0-9A-F]{1,4}:){3}(?:(?::[0-9A-F]{1,4}){1,4}|:(?:[0-9A-F]{1,4}:){1,2}[0-9A-F]{1,4}|:)|(?:[0-9A-F]{1,4}:){2}(?:(?::[0-9A-F]{1,4}){1,5}|:(?:[0-9A-F]{1,4}:)[0-9A-F]{1,4}|:)|(?:[0-9A-F]{1,4}:){1}(?:(?::[0-9A-F]{1,4}){1,6}|:(?:[0-9A-F]{1,4}:){0,5}[0-9A-F]{1,4}|:)|(?:::(?:[0-9A-F]{1,4}:){0,7}[0-9A-F]{1,4}|::)))(?:%.+)?\z/
+  private_constant :IPV6_ADDRESS_FORMAT
+  # :startdoc:
 
   # :call-seq:
   #   Socket.tcp(host, port, local_host=nil, local_port=nil, [opts]) {|socket| ... }
@@ -644,6 +645,7 @@ def ipv6only!
   #
   # [:resolv_timeout] Specifies the timeout in seconds from when the hostname resolution starts.
   # [:connect_timeout] This method sequentially attempts connecting to all candidate destination addresses.<br>The +connect_timeout+ specifies the timeout in seconds from the start of the connection attempt to the last candidate.<br>By default, all connection attempts continue until the timeout occurs.<br>When +fast_fallback:false+ is explicitly specified,<br>a timeout is set for each connection attempt and any connection attempt that exceeds its timeout will be canceled.
+  # [:open_timeout] Specifies the timeout in seconds from the start of the method execution.<br>If this timeout is reached while there are still addresses that have not yet been attempted for connection, no further attempts will be made.<br>If this option is specified together with other timeout options, an +ArgumentError+ will be raised.
   # [:fast_fallback] Enables the Happy Eyeballs Version 2 algorithm (enabled by default).
   #
   # If a block is given, the block is called with the socket.
@@ -657,11 +659,16 @@ def ipv6only!
   #     sock.close_write
   #     puts sock.read
   #   }
-  def self.tcp(host, port, local_host = nil, local_port = nil, connect_timeout: nil, resolv_timeout: nil, fast_fallback: tcp_fast_fallback, &) # :yield: socket
+  def self.tcp(host, port, local_host = nil, local_port = nil, connect_timeout: nil, resolv_timeout: nil, open_timeout: nil, fast_fallback: tcp_fast_fallback, &) # :yield: socket
+
+    if open_timeout && (connect_timeout || resolv_timeout)
+      raise ArgumentError, "Cannot specify open_timeout along with connect_timeout or resolv_timeout"
+    end
+
     sock = if fast_fallback && !(host && ip_address?(host))
-      tcp_with_fast_fallback(host, port, local_host, local_port, connect_timeout:, resolv_timeout:)
+      tcp_with_fast_fallback(host, port, local_host, local_port, connect_timeout:, resolv_timeout:, open_timeout:)
     else
-      tcp_without_fast_fallback(host, port, local_host, local_port, connect_timeout:, resolv_timeout:)
+      tcp_without_fast_fallback(host, port, local_host, local_port, connect_timeout:, resolv_timeout:, open_timeout:)
     end
 
     if block_given?
@@ -675,9 +682,10 @@ def self.tcp(host, port, local_host = nil, local_port = nil, connect_timeout: ni
     end
   end
 
-  def self.tcp_with_fast_fallback(host, port, local_host = nil, local_port = nil, connect_timeout: nil, resolv_timeout: nil)
+  # :stopdoc:
+  def self.tcp_with_fast_fallback(host, port, local_host = nil, local_port = nil, connect_timeout: nil, resolv_timeout: nil, open_timeout: nil)
     if local_host || local_port
-      local_addrinfos = Addrinfo.getaddrinfo(local_host, local_port, nil, :STREAM, timeout: resolv_timeout)
+      local_addrinfos = Addrinfo.getaddrinfo(local_host, local_port, nil, :STREAM, timeout: open_timeout || resolv_timeout)
       resolving_family_names = local_addrinfos.map { |lai| ADDRESS_FAMILIES.key(lai.afamily) }.uniq
     else
       local_addrinfos = []
@@ -690,14 +698,17 @@ def self.tcp_with_fast_fallback(host, port, local_host = nil, local_port = nil,
     is_windows_environment ||= (RUBY_PLATFORM =~ /mswin|mingw|cygwin/)
 
     now = current_clock_time
+    starts_at = now
     resolution_delay_expires_at = nil
     connection_attempt_delay_expires_at = nil
     user_specified_connect_timeout_at = nil
+    user_specified_open_timeout_at = open_timeout ? now + open_timeout : nil
     last_error = nil
+    last_error_from_thread = false
 
     if resolving_family_names.size == 1
       family_name = resolving_family_names.first
-      addrinfos = Addrinfo.getaddrinfo(host, port, family_name, :STREAM, timeout: resolv_timeout)
+      addrinfos = Addrinfo.getaddrinfo(host, port, ADDRESS_FAMILIES[:family_name], :STREAM, timeout: open_timeout || resolv_timeout)
       resolution_store.add_resolved(family_name, addrinfos)
       hostname_resolution_result = nil
       hostname_resolution_notifier = nil
@@ -714,7 +725,6 @@ def self.tcp_with_fast_fallback(host, port, local_host = nil, local_port = nil,
           thread
         }
       )
-
       user_specified_resolv_timeout_at = resolv_timeout ? now + resolv_timeout : Float::INFINITY
     end
 
@@ -748,9 +758,16 @@ def self.tcp_with_fast_fallback(host, port, local_host = nil, local_port = nil,
               socket.bind(local_addrinfo) if local_addrinfo
               result = socket.connect_nonblock(addrinfo, exception: false)
             else
+              timeout =
+                if open_timeout
+                  t = open_timeout - (current_clock_time - starts_at)
+                  t.negative? ? 0 : t
+                else
+                  connect_timeout
+                end
               result = socket = local_addrinfo ?
-                addrinfo.connect_from(local_addrinfo, timeout: connect_timeout) :
-                addrinfo.connect(timeout: connect_timeout)
+                addrinfo.connect_from(local_addrinfo, timeout:) :
+                addrinfo.connect(timeout:)
             end
 
             if result == :wait_writable
@@ -784,7 +801,10 @@ def self.tcp_with_fast_fallback(host, port, local_host = nil, local_port = nil,
 
       ends_at =
         if resolution_store.any_addrinfos?
-          resolution_delay_expires_at || connection_attempt_delay_expires_at
+          [(resolution_delay_expires_at || connection_attempt_delay_expires_at),
+           user_specified_open_timeout_at].compact.min
+        elsif user_specified_open_timeout_at
+          user_specified_open_timeout_at
         else
           [user_specified_resolv_timeout_at, user_specified_connect_timeout_at].compact.max
         end
@@ -866,6 +886,7 @@ def self.tcp_with_fast_fallback(host, port, local_host = nil, local_port = nil,
               other = family_name == :ipv6 ? :ipv4 : :ipv6
               if !resolution_store.resolved?(other) || !resolution_store.resolved_successfully?(other)
                 last_error = result
+                last_error_from_thread = true
               end
             end
           else
@@ -884,14 +905,22 @@ def self.tcp_with_fast_fallback(host, port, local_host = nil, local_port = nil,
         end
       end
 
+      if expired?(now, user_specified_open_timeout_at)
+        raise(IO::TimeoutError, "user specified timeout for #{host}:#{port}")
+      end
+
       if resolution_store.empty_addrinfos?
         if connecting_sockets.empty? && resolution_store.resolved_all_families?
-          raise last_error
+          if last_error_from_thread
+            raise last_error.class, last_error.message, cause: last_error
+          else
+            raise last_error
+          end
         end
 
         if (expired?(now, user_specified_resolv_timeout_at) || resolution_store.resolved_all_families?) &&
            (expired?(now, user_specified_connect_timeout_at) || connecting_sockets.empty?)
-          raise Errno::ETIMEDOUT, 'user specified timeout'
+          raise(IO::TimeoutError, "user specified timeout for #{host}:#{port}")
         end
       end
     end
@@ -906,17 +935,21 @@ def self.tcp_with_fast_fallback(host, port, local_host = nil, local_port = nil,
       connecting_socket.close
     end
   end
+  private_class_method :tcp_with_fast_fallback
 
-  def self.tcp_without_fast_fallback(host, port, local_host, local_port, connect_timeout:, resolv_timeout:)
+  def self.tcp_without_fast_fallback(host, port, local_host, local_port, connect_timeout:, resolv_timeout:, open_timeout:)
     last_error = nil
     ret = nil
 
     local_addr_list = nil
     if local_host != nil || local_port != nil
-      local_addr_list = Addrinfo.getaddrinfo(local_host, local_port, nil, :STREAM, nil)
+      local_addr_list = Addrinfo.getaddrinfo(local_host, local_port, nil, :STREAM, nil, timeout: open_timeout || resolv_timeout)
     end
 
-    Addrinfo.foreach(host, port, nil, :STREAM, timeout: resolv_timeout) {|ai|
+    timeout = open_timeout ? open_timeout : resolv_timeout
+    starts_at = current_clock_time
+
+    Addrinfo.foreach(host, port, nil, :STREAM, timeout:) {|ai|
       if local_addr_list
         local_addr = local_addr_list.find {|local_ai| local_ai.afamily == ai.afamily }
         next unless local_addr
@@ -924,9 +957,17 @@ def self.tcp_without_fast_fallback(host, port, local_host, local_port, connect_t
         local_addr = nil
       end
       begin
+        timeout =
+          if open_timeout
+            t = open_timeout - (current_clock_time - starts_at)
+            t.negative? ? 0 : t
+          else
+            connect_timeout
+          end
+
         sock = local_addr ?
-          ai.connect_from(local_addr, timeout: connect_timeout) :
-          ai.connect(timeout: connect_timeout)
+          ai.connect_from(local_addr, timeout:) :
+          ai.connect(timeout:)
       rescue SystemCallError
         last_error = $!
         next
@@ -947,7 +988,7 @@ def self.tcp_without_fast_fallback(host, port, local_host, local_port, connect_t
   private_class_method :tcp_without_fast_fallback
 
   def self.ip_address?(hostname)
-    hostname.match?(IPV6_ADRESS_FORMAT) || hostname.match?(/\A([0-9]{1,3}\.){3}[0-9]{1,3}\z/)
+    hostname.match?(IPV6_ADDRESS_FORMAT) || hostname.match?(/\A([0-9]{1,3}\.){3}[0-9]{1,3}\z/)
   end
   private_class_method :ip_address?
 
@@ -1085,7 +1126,6 @@ def any_unresolved_family?
   end
   private_constant :HostnameResolutionStore
 
-  # :stopdoc:
   def self.ip_sockets_port0(ai_list, reuseaddr)
     sockets = []
     begin
@@ -1118,9 +1158,7 @@ def self.ip_sockets_port0(ai_list, reuseaddr)
     end
     sockets
   end
-  class << self
-    private :ip_sockets_port0
-  end
+  private_class_method :ip_sockets_port0
 
   def self.tcp_server_sockets_port0(host)
     ai_list = Addrinfo.getaddrinfo(host, 0, nil, :STREAM, nil, Socket::AI_PASSIVE)
@@ -1548,13 +1586,18 @@ def self.unix_server_socket(path)
     end
   end
 
-  class << self
-    private
-
-    def unix_socket_abstract_name?(path)
-      /linux/ =~ RUBY_PLATFORM && /\A(\0|\z)/ =~ path
+  # :stopdoc:
+  if RUBY_PLATFORM.include?("linux")
+    def self.unix_socket_abstract_name?(path)
+      path.empty? or path.start_with?("\0")
+    end
+  else
+    def self.unix_socket_abstract_name?(path)
+      false
     end
   end
+  private_class_method :unix_socket_abstract_name?
+  # :startdoc:
 
   # creates a UNIX socket server on _path_.
   # It calls the block for each socket accepted.

From 801abb912285a437ac7b0416ff57921e9e7b512d Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Sat, 28 Feb 2026 16:27:34 -0600
Subject: [PATCH 148/168] Accept :open_timeout keyword but ignore for now

Not sure yet if there's a way to have separate open and connect
timeouts with JVM sockets.
---
 core/src/main/java/org/jruby/ext/socket/RubyTCPSocket.java | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/core/src/main/java/org/jruby/ext/socket/RubyTCPSocket.java b/core/src/main/java/org/jruby/ext/socket/RubyTCPSocket.java
index b7eeb51d1b9..50b94288e10 100644
--- a/core/src/main/java/org/jruby/ext/socket/RubyTCPSocket.java
+++ b/core/src/main/java/org/jruby/ext/socket/RubyTCPSocket.java
@@ -95,9 +95,10 @@ private SocketChannel attemptConnect(ThreadContext context, IRubyObject host, St
 
                 long timeout = -1;
                 if (opts != null) {
-                    IRubyObject timeoutObj = ArgsUtil.extractKeywordArg(context, opts, "connect_timeout");
-                    if (!timeoutObj.isNil()) {
-                        timeout = (long) (timeoutObj.convertToFloat().asDouble(context) * 1000);
+                    IRubyObject[] timeouts = ArgsUtil.extractKeywordArgs(context, opts, "connect_timeout", "open_timeout");
+                    IRubyObject connectTimeout = timeouts[0];
+                    if (connectTimeout != null && !connectTimeout.isNil()) {
+                        timeout = (long) (connectTimeout.convertToFloat().asDouble(context) * 1000);
                     }
                 }

From 0ffed866f0fddbcabf78e90ba1c38f1f39d27ca3 Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Sat, 28 Feb 2026 16:28:17 -0600
Subject: [PATCH 149/168] Fix recursion check for Kernel#inspect

Still not sure I get what "outer" is intended to mean but this
matches CRuby and now there's an equivalent function for
rb_exec_recursive.
---
 core/src/main/java/org/jruby/RubyBasicObject.java       | 4 ++--
 core/src/main/java/org/jruby/runtime/ThreadContext.java | 5 +++++
 2 files changed, 7 insertions(+), 2 deletions(-)

diff --git a/core/src/main/java/org/jruby/RubyBasicObject.java b/core/src/main/java/org/jruby/RubyBasicObject.java
index 7c4e5a3d09d..1e9d2defc3e 100644
--- a/core/src/main/java/org/jruby/RubyBasicObject.java
+++ b/core/src/main/java/org/jruby/RubyBasicObject.java
@@ -1154,9 +1154,9 @@ public final IRubyObject hashyInspect(ThreadContext context) {
 
         RubyString part = inspectPrefix(context, metaClass.getRealClass(), inspectHashCode());
 
-        return context.safeRecurse(
+        return context.execRecursive(
                 (ctx, p, obj, recur) -> inspectObj(ctx, p, ivars, recur),
-                part, this, "inspect", true);
+                part, this, "inspect");
     }
 
     // MRI: rb_inspect, which does dispatch
diff --git a/core/src/main/java/org/jruby/runtime/ThreadContext.java b/core/src/main/java/org/jruby/runtime/ThreadContext.java
index f0626ed51df..8cf5fb32d20 100644
--- a/core/src/main/java/org/jruby/runtime/ThreadContext.java
+++ b/core/src/main/java/org/jruby/runtime/ThreadContext.java
@@ -1437,6 +1437,11 @@ public interface RecursiveFunctionEx<T> {
         IRubyObject call(ThreadContext context, T state, IRubyObject obj, boolean recur);
     }
 
+    // MRI: rb_exec_recursive
+    public <T> IRubyObject execRecursive(RecursiveFunctionEx<T> func, T state, IRubyObject obj, String name) {
+        return safeRecurse(func, state, obj, name, false);
+    }
+
     public <T> IRubyObject safeRecurse(RecursiveFunctionEx<T> func, T state, IRubyObject obj, String name, boolean outer) {
         Map<IRubyObject, IRubyObject> guards = safeRecurseGetGuards(name);

From f6318a920f8cbeb39bb45bef8802ce0ef9adbe11 Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Sat, 28 Feb 2026 17:36:16 -0600
Subject: [PATCH 150/168] Implement Pathname#initialze as in CRuby

This ensures appropriate encoding and path conversion errors are
raised.
---
 .../org/jruby/ext/pathname/RubyPathname.java   | 18 ++++++++++--------
 1 file changed, 10 insertions(+), 8 deletions(-)

diff --git a/core/src/main/java/org/jruby/ext/pathname/RubyPathname.java b/core/src/main/java/org/jruby/ext/pathname/RubyPathname.java
index 02406aa3061..9adfcb19fd9 100644
--- a/core/src/main/java/org/jruby/ext/pathname/RubyPathname.java
+++ b/core/src/main/java/org/jruby/ext/pathname/RubyPathname.java
@@ -35,6 +35,7 @@
 import static org.jruby.api.Convert.asSymbol;
 import static org.jruby.api.Create.*;
 import static org.jruby.api.Error.argumentError;
+import static org.jruby.api.Error.typeError;
 
 import org.jruby.*;
 import org.jruby.anno.JRubyClass;
@@ -42,6 +43,7 @@
 import org.jruby.api.Access;
 import org.jruby.api.Define;
 import org.jruby.exceptions.RaiseException;
+import org.jruby.exceptions.TypeError;
 import org.jruby.internal.runtime.methods.JavaMethod;
 import org.jruby.runtime.*;
 import org.jruby.runtime.builtin.IRubyObject;
@@ -152,7 +154,8 @@ public RubyPathname(Ruby runtime, RubyClass metaClass) {
 
     public static RubyPathname newInstance(ThreadContext context, RubyClass klass, IRubyObject path) {
         RubyPathname pathname = new RubyPathname(context.runtime, klass);
-        return (RubyPathname) pathname.initialize(context, path);
+        pathname.initialize(context, path);
+        return pathname;
     }
 
     public static RubyPathname newInstance(ThreadContext context, IRubyObject path) {
@@ -161,13 +164,12 @@ public static RubyPathname newInstance(ThreadContext context, IRubyObject path)
 
     @JRubyMethod(visibility = Visibility.PRIVATE)
     public IRubyObject initialize(ThreadContext context, IRubyObject path) {
-        if (path.respondsTo("to_path")) path = path.callMethod(context, "to_path");
-
-        RubyString str = path.convertToString();
-        if (str.getByteList().indexOf('\0') != -1) throw argumentError(context, "pathname contains null byte");
-
-        setPath((RubyString) str.dup());
-        return this;
+        try {
+            setPath((RubyString) RubyFile.get_path(context, path).dup());
+        } catch (TypeError te) {
+            throw typeError(context, "Pathname.new requires a String, #to_path or #to_str");
+        }
+        return context.nil;
     }
 
     @JRubyMethod(visibility = Visibility.PRIVATE)

From 91ba2e35b3c3694976452553fa032c1234c5caea Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Sat, 28 Feb 2026 17:50:03 -0600
Subject: [PATCH 151/168] Implement Pathname#lutime, arity split
 File.lutime/utime

---
 core/src/main/java/org/jruby/RubyFile.java    | 102 ++++++++++++++----
 .../org/jruby/ext/pathname/RubyPathname.java  |   5 +
 2 files changed, 85 insertions(+), 22 deletions(-)

diff --git a/core/src/main/java/org/jruby/RubyFile.java b/core/src/main/java/org/jruby/RubyFile.java
index c50b9d1c84e..9cb94783108 100644
--- a/core/src/main/java/org/jruby/RubyFile.java
+++ b/core/src/main/java/org/jruby/RubyFile.java
@@ -92,7 +92,6 @@
 import static org.jruby.api.Define.defineClass;
 import static org.jruby.api.Error.argumentError;
 import static org.jruby.api.Error.runtimeError;
-import static org.jruby.runtime.ThreadContext.hasKeywords;
 import static org.jruby.runtime.Visibility.PRIVATE;
 import static org.jruby.util.StringSupport.*;
 import static org.jruby.util.io.EncodingUtils.vmode;
@@ -1127,6 +1126,31 @@ public static IRubyObject umask(ThreadContext context, IRubyObject recv, IRubyOb
         return asFixnum(context, oldMask);
     }
 
+    @JRubyMethod(meta = true)
+    public static IRubyObject lutime(ThreadContext context, IRubyObject recv, IRubyObject atime, IRubyObject mtime) {
+        if (atime != context.nil || mtime != context.nil) {
+            extractTimespec(context, atime);
+            extractTimespec(context, mtime);
+        }
+
+        return asFixnum(context, 0);
+    }
+
+    @JRubyMethod(meta = true)
+    public static IRubyObject lutime(ThreadContext context, IRubyObject recv, IRubyObject atime, IRubyObject mtime, IRubyObject path) {
+        long[] atimeval = null;
+        long[] mtimeval = null;
+
+        if (atime != context.nil || mtime != context.nil) {
+            atimeval = convertTimespecToTimeval(extractTimespec(context, atime));
+            mtimeval = convertTimespecToTimeval(extractTimespec(context, mtime));
+        }
+
+        lutime(context, path, atimeval, mtimeval);
+
+        return asFixnum(context, 1);
+    }
+
     @JRubyMethod(required = 2, rest = true, checkArity = false, meta = true)
     public static IRubyObject lutime(ThreadContext context, IRubyObject recv, IRubyObject[] args) {
         int argc = Arity.checkArgumentCount(context, args, 2, -1);
@@ -1141,22 +1165,52 @@ public static IRubyObject lutime(ThreadContext context, IRubyObject recv, IRubyO
         }
 
         for (int i = 2, j = argc; i < j; i++) {
-            var filename = get_path(context, args[i]).toString();
-            JRubyFile fileToTouch = JRubyFile.create(runtime.getCurrentDirectory(), filename);
-            if (!fileToTouch.exists()) throw runtime.newErrnoENOENTError(filename);
-
-            int result = runtime.getPosix().lutimes(fileToTouch.getAbsolutePath(), atimeval, mtimeval);
-            if (result == -1) throw runtime.newErrnoFromInt(runtime.getPosix().errno());
+            lutime(context, args[i], atimeval, mtimeval);
         }
 
         return asFixnum(context, argc - 2);
     }
 
+    private static void lutime(ThreadContext context, IRubyObject _path, long[] atimeval, long[] mtimeval) {
+        Ruby runtime = context.runtime;
+
+        var filename = get_path(context, _path).toString();
+
+        JRubyFile fileToTouch = JRubyFile.create(runtime.getCurrentDirectory(), filename);
+        if (!fileToTouch.exists()) throw runtime.newErrnoENOENTError(filename);
+
+        int result = runtime.getPosix().lutimes(fileToTouch.getAbsolutePath(), atimeval, mtimeval);
+        if (result == -1) throw runtime.newErrnoFromInt(runtime.getPosix().errno());
+    }
+
+    @JRubyMethod(meta = true)
+    public static IRubyObject utime(ThreadContext context, IRubyObject recv, IRubyObject atime, IRubyObject mtime) {
+        if (atime != context.nil || mtime != context.nil) {
+            extractTimespec(context, atime);
+            extractTimespec(context, mtime);
+        }
+
+        return asFixnum(context, 0);
+    }
+
+    @JRubyMethod(meta = true)
+    public static IRubyObject utime(ThreadContext context, IRubyObject recv, IRubyObject atime, IRubyObject mtime, IRubyObject path) {
+        long[] atimespec = null;
+        long[] mtimespec = null;
+        if (atime != context.nil || mtime != context.nil) {
+            atimespec = extractTimespec(context, atime);
+            mtimespec = extractTimespec(context, mtime);
+        }
+
+        utime(context, atimespec, mtimespec, path);
+
+        return asFixnum(context, 1);
+    }
+
     @JRubyMethod(required = 2, rest = true, checkArity = false, meta = true)
     public static IRubyObject utime(ThreadContext context, IRubyObject recv, IRubyObject[] args) {
         int argc = Arity.checkArgumentCount(context, args, 2, -1);
 
-        Ruby runtime = context.runtime;
         long[] atimespec = null;
         long[] mtimespec = null;
 
@@ -1166,26 +1220,30 @@ public static IRubyObject utime(ThreadContext context, IRubyObject recv, IRubyOb
         }
 
         for (int i = 2, j = argc; i < j; i++) {
-            var filename = get_path(context, args[i]).toString();
-
-            JRubyFile fileToTouch = JRubyFile.create(runtime.getCurrentDirectory(), filename);
-            if (!fileToTouch.exists()) throw runtime.newErrnoENOENTError(filename);
-
-            int result;
-            try {
-                result = runtime.getPosix().utimensat(0, fileToTouch.getAbsolutePath(), atimespec, mtimespec, 0);
-            } catch (NotImplementedError re) {
-                // fall back on utimes
-                result = runtime.getPosix().utimes(fileToTouch.getAbsolutePath(),
-                        convertTimespecToTimeval(atimespec), convertTimespecToTimeval(mtimespec));
-            }
+            utime(context, atimespec, mtimespec, args[i]);
 
-            if (result == -1) throw runtime.newErrnoFromInt(runtime.getPosix().errno());
         }
 
         return asFixnum(context, argc - 2);
     }
 
+    private static void utime(ThreadContext context, long[] atimespec, long[] mtimespec, IRubyObject args) {
+        Ruby runtime = context.runtime;
+
+        var filename = get_path(context, args).toString();
+        JRubyFile fileToTouch = JRubyFile.create(runtime.getCurrentDirectory(), filename);
+        if (!fileToTouch.exists()) throw runtime.newErrnoENOENTError(filename);
+        int result;
+        try {
+            result = runtime.getPosix().utimensat(0, fileToTouch.getAbsolutePath(), atimespec, mtimespec, 0);
+        } catch (NotImplementedError re) {
+            // fall back on utimes
+            result = runtime.getPosix().utimes(fileToTouch.getAbsolutePath(),
+                    convertTimespecToTimeval(atimespec), convertTimespecToTimeval(mtimespec));
+        }
+        if (result == -1) throw runtime.newErrnoFromInt(runtime.getPosix().errno());
+    }
+
     @JRubyMethod(rest = true, meta = true)
     public static IRubyObject delete(ThreadContext context, IRubyObject recv, IRubyObject[] args) {
         for (int i = 0; i < args.length; i++) {
diff --git a/core/src/main/java/org/jruby/ext/pathname/RubyPathname.java b/core/src/main/java/org/jruby/ext/pathname/RubyPathname.java
index 9adfcb19fd9..c6f26c1c366 100644
--- a/core/src/main/java/org/jruby/ext/pathname/RubyPathname.java
+++ b/core/src/main/java/org/jruby/ext/pathname/RubyPathname.java
@@ -378,6 +378,11 @@ public IRubyObject empty_p(ThreadContext context) {
                 fileTest.callMethod(context, "empty?", getPath());
     }
 
+    @JRubyMethod(name = "lutime")
+    public IRubyObject lutime(ThreadContext context, IRubyObject atime, IRubyObject mtime) {
+        return RubyFile.lutime(context, context.runtime.getFile(), atime, mtime, getPath());
+    }
+
     /* Helpers */
 
     private IRubyObject[] insertPath(IRubyObject[] args, int i) {

From 90c8785115c6b9bbbbb9e4620d55f5f0c03af9c5 Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Sat, 28 Feb 2026 17:58:35 -0600
Subject: [PATCH 152/168] Exclude some Fiber scheduler tests that aren't hooked
 up

See https://github.com/jruby/jruby/issues/9275
---
 test/mri/excludes/TestFiberScheduler.rb | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/test/mri/excludes/TestFiberScheduler.rb b/test/mri/excludes/TestFiberScheduler.rb
index 7a49ae467c2..d6231274c75 100644
--- a/test/mri/excludes/TestFiberScheduler.rb
+++ b/test/mri/excludes/TestFiberScheduler.rb
@@ -1,3 +1,7 @@
 exclude :test_condition_variable, "hangs on macos M1"
 exclude :test_current_scheduler, "fails intermittently on Linux CI on GHA"
+exclude :test_io_read_error, "not hooked up to Scheduler yet, https://github.com/jruby/jruby/issues/9275"
+exclude :test_io_write_error, "not hooked up to Scheduler yet, https://github.com/jruby/jruby/issues/9275"
+exclude :test_io_write_flush_error, "not hooked up to Scheduler yet, https://github.com/jruby/jruby/issues/9275"
+exclude :test_io_write_on_flush, "not hooked up to Scheduler yet, https://github.com/jruby/jruby/issues/9275"
 exclude :test_iseq_compile_under_gc_stress_bug_21180, "uses RubyVM"

From 8cf0a7e5b64a06faf54192a90804b77ae1372b0a Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Sat, 28 Feb 2026 18:04:48 -0600
Subject: [PATCH 153/168] Exclude some OpenURI tests that fail in util code

See https://github.com/jruby/jruby/issues/9276
---
 test/mri/excludes/TestOpenURI.rb | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/test/mri/excludes/TestOpenURI.rb b/test/mri/excludes/TestOpenURI.rb
index f15908ab192..eeadfd4a5ef 100644
--- a/test/mri/excludes/TestOpenURI.rb
+++ b/test/mri/excludes/TestOpenURI.rb
@@ -1 +1,8 @@
+exclude :test_encoding, "fails in http test logic, https://github.com/jruby/jruby/issues/9276"
+exclude :test_mode, "fails in http test logic, https://github.com/jruby/jruby/issues/9276"
+exclude :test_multiple_cookies, "fails in http test logic, https://github.com/jruby/jruby/issues/9276"
 exclude :test_open_timeout, "hangs on macos m1"
+exclude :test_progress, "fails in http test logic, https://github.com/jruby/jruby/issues/9276"
+exclude :test_redirect, "fails in http test logic, https://github.com/jruby/jruby/issues/9276"
+exclude :test_redirect_auth_failure_r2, "fails in http test logic, https://github.com/jruby/jruby/issues/9276"
+exclude :test_redirect_auth_success, "fails in http test logic, https://github.com/jruby/jruby/issues/9276"

From 32129d92a10c1d12579e627f3742d1e1dd3c6e77 Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Sat, 28 Feb 2026 19:06:25 -0600
Subject: [PATCH 154/168] Implement state management for IO#timeout

Functionality is not yet hooked up.
---
 core/src/main/java/org/jruby/RubyIO.java        | 17 +++++++++++++++++
 .../main/java/org/jruby/util/io/OpenFile.java   |  9 +++++++++
 2 files changed, 26 insertions(+)

diff --git a/core/src/main/java/org/jruby/RubyIO.java b/core/src/main/java/org/jruby/RubyIO.java
index cec47dd22e4..c18daa091da 100644
--- a/core/src/main/java/org/jruby/RubyIO.java
+++ b/core/src/main/java/org/jruby/RubyIO.java
@@ -2279,6 +2279,7 @@ public IRubyObject initialize_copy(ThreadContext context, IRubyObject _io){
             fptr.encs = orig.encs;
             fptr.setProcess(orig.getProcess());
             fptr.setLineNumber(orig.getLineNumber());
+            fptr.setTimeout(orig.getTimeout());
             if (orig.getPath() != null) fptr.setPath(orig.getPath());
             fptr.setFinalizer(orig.getFinalizer());
             // TODO: not using pipe_finalize yet
@@ -5302,6 +5303,22 @@ protected void setPath(String path) {
         openFile.setPath(path);
     }
 
+    @JRubyMethod(name = "timeout")
+    public IRubyObject timeout_get(ThreadContext context) {
+        return getOpenFileInitialized().getTimeout();
+    }
+
+    @JRubyMethod(name = "timeout=")
+    public IRubyObject timeout_set(ThreadContext context, IRubyObject timeout) {
+        if (timeout.isTrue()) {
+            RubyTime.convertTimeInterval(context, timeout);
+        }
+
+        getOpenFileInitialized().setTimeout(timeout);
+
+        return this;
+    }
+
     /**
      * Add a thread to the list of blocking threads for this IO.
      *
diff --git a/core/src/main/java/org/jruby/util/io/OpenFile.java b/core/src/main/java/org/jruby/util/io/OpenFile.java
index 25ca5972d81..1cdc5922f0c 100644
--- a/core/src/main/java/org/jruby/util/io/OpenFile.java
+++ b/core/src/main/java/org/jruby/util/io/OpenFile.java
@@ -134,6 +134,7 @@ public static interface Finalizer {
     private Finalizer finalizer;
     public Closeable stdio_file;
     public volatile FileLock currentLock;
+    private IRubyObject timeout;
 
     public static class Buffer {
         public byte[] ptr;
@@ -3044,6 +3045,14 @@ public boolean lockedByMe() {
         return lock.isHeldByCurrentThread();
     }
 
+    public IRubyObject getTimeout() {
+        return timeout;
+    }
+
+    public void setTimeout(IRubyObject timeout) {
+        this.timeout = timeout;
+    }
+
     @Deprecated(since = "9.3.0.0")
     public long binwrite(ThreadContext context, byte[] ptrBytes, int ptr, int len, boolean nosync) {
         return binwriteInt(context, ptrBytes, ptr, len, nosync);

From 22f3658a3b7a50026639740cf02bf5fcc0c66612 Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Sat, 28 Feb 2026 19:36:26 -0600
Subject: [PATCH 155/168] Unexclude IO#timeout-related tests

---
 test/mri/excludes/TestIO.rb | 2 --
 1 file changed, 2 deletions(-)

diff --git a/test/mri/excludes/TestIO.rb b/test/mri/excludes/TestIO.rb
index 7c282d059e9..e26e58b86c2 100644
--- a/test/mri/excludes/TestIO.rb
+++ b/test/mri/excludes/TestIO.rb
@@ -6,7 +6,6 @@
 exclude :test_copy_stream_socket7, "uses fork"
 exclude :test_cross_thread_close_stdio, "needs investigation"
 exclude :test_dup_many, "needs investigation"
-exclude :test_dup_timeout, "IO#timeout is not implemented yet (https://github.com/jruby/jruby/pull/8662)"
 exclude :test_each_line, "needs investigation"
 exclude :test_each_line_limit_0, "fails in JIT mode on Linux CI on GHA"
 exclude :test_fcntl_dupfd, "needs investigation"
@@ -21,7 +20,6 @@
 exclude :test_readlines_limit_0, "hangs"
 exclude :test_readpartial_lock, "needs investigation"
 exclude :test_readpartial_locktmp, "requires string locking we do not support"
-exclude :test_recycled_fd_close, "IO#timeout is not implemented yet (https://github.com/jruby/jruby/pull/8662)"
 exclude :test_reinitialize, "needs investigation"
 exclude :test_reopen_encoding_from_io, "needs investigation"
 exclude :test_reopen_opt, "needs investigation"

From 57551bb4273c69e407a916091bc0eece74189909 Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Sat, 28 Feb 2026 20:05:00 -0600
Subject: [PATCH 156/168] Exclude a few more OpenURI tests failing in util code

---
 test/mri/excludes/TestOpenURI.rb | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/test/mri/excludes/TestOpenURI.rb b/test/mri/excludes/TestOpenURI.rb
index eeadfd4a5ef..d5a0d660d31 100644
--- a/test/mri/excludes/TestOpenURI.rb
+++ b/test/mri/excludes/TestOpenURI.rb
@@ -1,4 +1,7 @@
+exclude :test_404, "fails in http test logic, https://github.com/jruby/jruby/issues/9276"
 exclude :test_encoding, "fails in http test logic, https://github.com/jruby/jruby/issues/9276"
+exclude :test_header, "fails in http test logic, https://github.com/jruby/jruby/issues/9276"
+exclude :test_max_redirects_success, "fails in http test logic, https://github.com/jruby/jruby/issues/9276"
 exclude :test_mode, "fails in http test logic, https://github.com/jruby/jruby/issues/9276"
 exclude :test_multiple_cookies, "fails in http test logic, https://github.com/jruby/jruby/issues/9276"
 exclude :test_open_timeout, "hangs on macos m1"
@@ -6,3 +9,5 @@
 exclude :test_redirect, "fails in http test logic, https://github.com/jruby/jruby/issues/9276"
 exclude :test_redirect_auth_failure_r2, "fails in http test logic, https://github.com/jruby/jruby/issues/9276"
 exclude :test_redirect_auth_success, "fails in http test logic, https://github.com/jruby/jruby/issues/9276"
+exclude :test_redirect_loop, "fails in http test logic, https://github.com/jruby/jruby/issues/9276"
+exclude :test_redirect_without_request_specific_fields_hash, "fails in http test logic, https://github.com/jruby/jruby/issues/9276"

From 38ff55f9ddf167c4305c87579c1ff2a8a0db5e5e Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Sat, 28 Feb 2026 17:26:52 -0600
Subject: [PATCH 157/168] Define Encoding::UNICODE_VERSION

---
 core/src/main/java/org/jruby/RubyEncoding.java | 6 ++++++
 core/src/main/java/org/jruby/RubyModule.java   | 8 +++++---
 2 files changed, 11 insertions(+), 3 deletions(-)

diff --git a/core/src/main/java/org/jruby/RubyEncoding.java b/core/src/main/java/org/jruby/RubyEncoding.java
index bda699916e8..6a7a35d55e4 100755
--- a/core/src/main/java/org/jruby/RubyEncoding.java
+++ b/core/src/main/java/org/jruby/RubyEncoding.java
@@ -35,6 +35,7 @@
 import java.nio.charset.CodingErrorAction;
 import java.nio.charset.StandardCharsets;
 
+import org.jcodings.Config;
 import org.jcodings.Encoding;
 import org.jcodings.EncodingDB.Entry;
 import org.jcodings.specific.ASCIIEncoding;
@@ -44,6 +45,7 @@
 import org.jcodings.util.CaseInsensitiveBytesHash;
 import org.jcodings.util.Hash.HashEntryIterator;
 import org.jruby.anno.JRubyClass;
+import org.jruby.anno.JRubyConstant;
 import org.jruby.anno.JRubyMethod;
 import org.jruby.compiler.Constantizable;
 import org.jruby.runtime.ClassIndex;
@@ -77,12 +79,16 @@ public class RubyEncoding extends RubyObject implements Constantizable {
     public static final ByteList INTERNAL = new ByteList(encodeISO("internal"), false);
     public static final ByteList BINARY_ASCII_NAME = new ByteList(encodeISO("BINARY (ASCII-8BIT)"), false);
 
+    @JRubyConstant("UNICODE_VERSION")
+    public static final String UNICODE_VERSION = Config.UNICODE_VERSION_STRING;
+
     public static RubyClass createEncodingClass(ThreadContext context, RubyClass Object) {
         return defineClass(context, "Encoding", Object, NOT_ALLOCATABLE_ALLOCATOR).
                 reifiedClass(RubyEncoding.class).
                 kindOf(new RubyModule.JavaClassKindOf(RubyEncoding.class)).
                 classIndex(ClassIndex.ENCODING).
                 defineMethods(context, RubyEncoding.class).
+                defineConstants(context, RubyEncoding.class).
                 tap(c -> c.singletonClass(context).undefMethods(context, "allocate"));
     }
 
diff --git a/core/src/main/java/org/jruby/RubyModule.java b/core/src/main/java/org/jruby/RubyModule.java
index b1aab490637..a35d46c9099 100644
--- a/core/src/main/java/org/jruby/RubyModule.java
+++ b/core/src/main/java/org/jruby/RubyModule.java
@@ -1477,12 +1477,14 @@ private boolean defineAnnotatedConstant(ThreadContext context, Field field) {
         IRubyObject realVal;
 
         try {
-            if(tp == Integer.class || tp == Integer.TYPE || tp == Short.class || tp == Short.TYPE || tp == Byte.class || tp == Byte.TYPE) {
+            if (tp == Integer.class || tp == Integer.TYPE || tp == Short.class || tp == Short.TYPE || tp == Byte.class || tp == Byte.TYPE) {
                 realVal = asFixnum(context, field.getInt(null));
-            } else if(tp == Boolean.class || tp == Boolean.TYPE) {
+            } else if (tp == Boolean.class || tp == Boolean.TYPE) {
                 realVal = asBoolean(context, field.getBoolean(null));
+            } else if (tp == String.class) {
+                realVal = newString(context, field.get(null).toString());
             } else {
-                realVal = context.nil;
+                throw new RuntimeException("Unsupported type for annotated constant: " + tp.getName());
             }
         } catch(Exception e) {
             realVal = context.nil;

From 60216693f95a4b922198b11abca2ab68f6562e25 Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Sat, 28 Feb 2026 17:27:19 -0600
Subject: [PATCH 158/168] Update unicode_normalize sources from CRuby

---
 .../stdlib/unicode_normalize/normalize.rb     |  32 +-
 lib/ruby/stdlib/unicode_normalize/tables.rb   | 374 +++++++++++++++++-
 2 files changed, 391 insertions(+), 15 deletions(-)

diff --git a/lib/ruby/stdlib/unicode_normalize/normalize.rb b/lib/ruby/stdlib/unicode_normalize/normalize.rb
index b27cdadaaac..0447df8de70 100644
--- a/lib/ruby/stdlib/unicode_normalize/normalize.rb
+++ b/lib/ruby/stdlib/unicode_normalize/normalize.rb
@@ -20,7 +20,7 @@
 
 require_relative 'tables'
 
-
+# :stopdoc:
 module UnicodeNormalize  # :nodoc:
   ## Constant for max hash capacity to avoid DoS attack
   MAX_HASH_LENGTH = 18000 # enough for all test cases, otherwise tests get slow
@@ -82,16 +82,22 @@ def self.hangul_comp_one(string)
 
   ## Canonical Ordering
   def self.canonical_ordering_one(string)
-    sorting = string.each_char.collect { |c| [c, CLASS_TABLE[c]] }
-    (sorting.length-2).downto(0) do |i| # almost, but not exactly bubble sort
-      (0..i).each do |j|
-        later_class = sorting[j+1].last
-        if 0<later_class and later_class<sorting[j].last
-          sorting[j], sorting[j+1] = sorting[j+1], sorting[j]
-        end
+    result = ''
+    unordered = []
+    chars = string.chars
+    n = chars.size
+    chars.each_with_index do |char, i|
+      ccc = CLASS_TABLE[char]
+      if ccc == 0
+        unordered.sort!.each { result << chars[it % n] }
+        unordered.clear
+        result << char
+      else
+        unordered << ccc * n + i
       end
     end
-    return sorting.collect(&:first).join('')
+    unordered.sort!.each { result << chars[it % n] }
+    result
   end
 
   ## Normalization Forms for Patterns (not whole Strings)
@@ -105,16 +111,22 @@ def self.nfc_one(string)
     start = nfd_string[0]
     last_class = CLASS_TABLE[start]-1
     accents = ''
+    result = ''
     nfd_string[1..-1].each_char do |accent|
       accent_class = CLASS_TABLE[accent]
       if last_class<accent_class and composite = COMPOSITION_TABLE[start+accent]
         start = composite
+      elsif accent_class == 0
+        result << start << accents
+        start = accent
+        accents = ''
+        last_class = -1
       else
         accents << accent
         last_class = accent_class
       end
     end
-    hangul_comp_one(start+accents)
+    hangul_comp_one(result+start+accents)
   end
 
   def self.normalize(string, form = :nfc)
diff --git a/lib/ruby/stdlib/unicode_normalize/tables.rb b/lib/ruby/stdlib/unicode_normalize/tables.rb
index a7a387d13cb..dd5d3499b81 100644
--- a/lib/ruby/stdlib/unicode_normalize/tables.rb
+++ b/lib/ruby/stdlib/unicode_normalize/tables.rb
@@ -1,6 +1,9 @@
 # coding: us-ascii
 # frozen_string_literal: true
 
+Encoding::UNICODE_VERSION == "17.0.0" or
+  raise "Unicode version mismatch: 17.0.0 expected but #{Encoding::UNICODE_VERSION}"
+
 # automatically generated by template/unicode_norm_gen.tmpl
 
 module UnicodeNormalize  # :nodoc:
@@ -29,7 +32,8 @@ module UnicodeNormalize  # :nodoc:
     "\u0825-\u0827" \
     "\u0829-\u082D" \
     "\u0859-\u085B" \
-    "\u08D3-\u08E1" \
+    "\u0897-\u089F" \
+    "\u08CA-\u08E1" \
     "\u08E3-\u08FF" \
     "\u093C" \
     "\u094D" \
@@ -50,6 +54,7 @@ module UnicodeNormalize  # :nodoc:
     "\u0BBE" \
     "\u0BCD" \
     "\u0BD7" \
+    "\u0C3C" \
     "\u0C4D" \
     "\u0C55\u0C56" \
     "\u0CBC" \
@@ -83,7 +88,7 @@ module UnicodeNormalize  # :nodoc:
     "\u1039\u103A" \
     "\u108D" \
     "\u135D-\u135F" \
-    "\u1714" \
+    "\u1714\u1715" \
     "\u1734" \
     "\u17D2" \
     "\u17DD" \
@@ -94,7 +99,8 @@ module UnicodeNormalize  # :nodoc:
     "\u1A75-\u1A7C" \
     "\u1A7F" \
     "\u1AB0-\u1ABD" \
-    "\u1ABF\u1AC0" \
+    "\u1ABF-\u1ADD" \
+    "\u1AE0-\u1AEB" \
     "\u1B34\u1B35" \
     "\u1B44" \
     "\u1B6B-\u1B73" \
@@ -108,8 +114,7 @@ module UnicodeNormalize  # :nodoc:
     "\u1CED" \
     "\u1CF4" \
     "\u1CF8\u1CF9" \
-    "\u1DC0-\u1DF9" \
-    "\u1DFB-\u1DFF" \
+    "\u1DC0-\u1DFF" \
     "\u20D0-\u20DC" \
     "\u20E1" \
     "\u20E5-\u20F0" \
@@ -148,9 +153,14 @@ module UnicodeNormalize  # :nodoc:
     "\u{10A3F}" \
     "\u{10AE5}\u{10AE6}" \
     "\u{10D24}-\u{10D27}" \
+    "\u{10D69}-\u{10D6D}" \
     "\u{10EAB}\u{10EAC}" \
+    "\u{10EFA}\u{10EFB}" \
+    "\u{10EFD}-\u{10EFF}" \
     "\u{10F46}-\u{10F50}" \
+    "\u{10F82}-\u{10F85}" \
     "\u{11046}" \
+    "\u{11070}" \
     "\u{1107F}" \
     "\u{110B9}\u{110BA}" \
     "\u{11100}-\u{11102}" \
@@ -167,6 +177,12 @@ module UnicodeNormalize  # :nodoc:
     "\u{11357}" \
     "\u{11366}-\u{1136C}" \
     "\u{11370}-\u{11374}" \
+    "\u{113B8}" \
+    "\u{113BB}" \
+    "\u{113C2}" \
+    "\u{113C5}" \
+    "\u{113C7}-\u{113C9}" \
+    "\u{113CE}-\u{113D0}" \
     "\u{11442}" \
     "\u{11446}" \
     "\u{1145E}" \
@@ -191,8 +207,12 @@ module UnicodeNormalize  # :nodoc:
     "\u{11D42}" \
     "\u{11D44}\u{11D45}" \
     "\u{11D97}" \
+    "\u{11F41}\u{11F42}" \
+    "\u{1611E}-\u{16129}" \
+    "\u{1612F}" \
     "\u{16AF0}-\u{16AF4}" \
     "\u{16B30}-\u{16B36}" \
+    "\u{16D67}\u{16D68}" \
     "\u{16FF0}\u{16FF1}" \
     "\u{1BC9E}" \
     "\u{1D165}-\u{1D169}" \
@@ -206,8 +226,16 @@ module UnicodeNormalize  # :nodoc:
     "\u{1E01B}-\u{1E021}" \
     "\u{1E023}\u{1E024}" \
     "\u{1E026}-\u{1E02A}" \
+    "\u{1E08F}" \
     "\u{1E130}-\u{1E136}" \
+    "\u{1E2AE}" \
     "\u{1E2EC}-\u{1E2EF}" \
+    "\u{1E4EC}-\u{1E4EF}" \
+    "\u{1E5EE}\u{1E5EF}" \
+    "\u{1E6E3}" \
+    "\u{1E6E6}" \
+    "\u{1E6EE}\u{1E6EF}" \
+    "\u{1E6F5}" \
     "\u{1E8D0}-\u{1E8D6}" \
     "\u{1E944}-\u{1E94A}" \
     "]"
@@ -433,15 +461,25 @@ module UnicodeNormalize  # :nodoc:
     "\uFB40\uFB41" \
     "\uFB43\uFB44" \
     "\uFB46-\uFB4E" \
+    "\u{105C9}" \
+    "\u{105E4}" \
     "\u{1109A}" \
     "\u{1109C}" \
     "\u{110AB}" \
     "\u{1112E}\u{1112F}" \
     "\u{1134B}\u{1134C}" \
+    "\u{11383}" \
+    "\u{11385}" \
+    "\u{1138E}" \
+    "\u{11391}" \
+    "\u{113C5}" \
+    "\u{113C7}\u{113C8}" \
     "\u{114BB}\u{114BC}" \
     "\u{114BE}" \
     "\u{115BA}\u{115BB}" \
     "\u{11938}" \
+    "\u{16121}-\u{16128}" \
+    "\u{16D68}-\u{16D6A}" \
     "\u{1D15E}-\u{1D164}" \
     "\u{1D1BB}-\u{1D1C0}" \
     "\u{2F800}-\u{2FA1D}" \
@@ -605,14 +643,25 @@ module UnicodeNormalize  # :nodoc:
     "\u30DB" \
     "\u30EF-\u30F2" \
     "\u30FD" \
+    "\u{105D2}" \
+    "\u{105DA}" \
     "\u{11099}" \
     "\u{1109B}" \
     "\u{110A5}" \
     "\u{11131}\u{11132}" \
     "\u{11347}" \
+    "\u{11382}" \
+    "\u{11384}" \
+    "\u{1138B}" \
+    "\u{11390}" \
+    "\u{113C2}" \
     "\u{114B9}" \
     "\u{115B8}\u{115B9}" \
     "\u{11935}" \
+    "\u{1611E}" \
+    "\u{16129}" \
+    "\u{16D63}" \
+    "\u{16D67}" \
     "]?#{accents}+" \
     "|#{''  # precomposed Hangul syllables
     }" \
@@ -883,6 +932,10 @@ module UnicodeNormalize  # :nodoc:
     "\u30F4" \
     "\u30F7-\u30FA" \
     "\u30FD\u30FE" \
+    "\u{105C9}" \
+    "\u{105D2}" \
+    "\u{105DA}" \
+    "\u{105E4}" \
     "\u{11099}-\u{1109C}" \
     "\u{110A5}" \
     "\u{110AB}" \
@@ -890,12 +943,23 @@ module UnicodeNormalize  # :nodoc:
     "\u{11131}\u{11132}" \
     "\u{11347}" \
     "\u{1134B}\u{1134C}" \
+    "\u{11382}-\u{11385}" \
+    "\u{1138B}" \
+    "\u{1138E}" \
+    "\u{11390}\u{11391}" \
+    "\u{113C2}" \
+    "\u{113C5}" \
+    "\u{113C7}\u{113C8}" \
     "\u{114B9}" \
     "\u{114BB}\u{114BC}" \
     "\u{114BE}" \
     "\u{115B8}-\u{115BB}" \
     "\u{11935}" \
     "\u{11938}" \
+    "\u{1611E}" \
+    "\u{16121}-\u{16129}" \
+    "\u{16D63}" \
+    "\u{16D67}-\u{16D6A}" \
     "]?#{accents}+" \
     "|#{''  # Hangul syllables with separate trailer
     }" \
@@ -1402,6 +1466,7 @@ module UnicodeNormalize  # :nodoc:
     "\u3280-\u33FF" \
     "\uA69C\uA69D" \
     "\uA770" \
+    "\uA7F1-\uA7F4" \
     "\uA7F8\uA7F9" \
     "\uAB5C-\uAB5F" \
     "\uAB69" \
@@ -1428,6 +1493,10 @@ module UnicodeNormalize  # :nodoc:
     "\uFFDA-\uFFDC" \
     "\uFFE0-\uFFE6" \
     "\uFFE8-\uFFEE" \
+    "\u{10781}-\u{10785}" \
+    "\u{10787}-\u{107B0}" \
+    "\u{107B2}-\u{107BA}" \
+    "\u{1CCD6}-\u{1CCF9}" \
     "\u{1D400}-\u{1D454}" \
     "\u{1D456}-\u{1D49C}" \
     "\u{1D49E}\u{1D49F}" \
@@ -1449,6 +1518,7 @@ module UnicodeNormalize  # :nodoc:
     "\u{1D552}-\u{1D6A5}" \
     "\u{1D6A8}-\u{1D7CB}" \
     "\u{1D7CE}-\u{1D7FF}" \
+    "\u{1E030}-\u{1E06D}" \
     "\u{1EE00}-\u{1EE03}" \
     "\u{1EE05}-\u{1EE1F}" \
     "\u{1EE21}\u{1EE22}" \
@@ -1776,6 +1846,24 @@ module UnicodeNormalize  # :nodoc:
     "\u0859"=>220,
     "\u085A"=>220,
     "\u085B"=>220,
+    "\u0897"=>230,
+    "\u0898"=>230,
+    "\u0899"=>220,
+    "\u089A"=>220,
+    "\u089B"=>220,
+    "\u089C"=>230,
+    "\u089D"=>230,
+    "\u089E"=>230,
+    "\u089F"=>230,
+    "\u08CA"=>230,
+    "\u08CB"=>230,
+    "\u08CC"=>230,
+    "\u08CD"=>230,
+    "\u08CE"=>230,
+    "\u08CF"=>220,
+    "\u08D0"=>220,
+    "\u08D1"=>220,
+    "\u08D2"=>220,
     "\u08D3"=>220,
     "\u08D4"=>230,
     "\u08D5"=>230,
@@ -1836,6 +1924,7 @@ module UnicodeNormalize  # :nodoc:
     "\u0B3C"=>7,
     "\u0B4D"=>9,
     "\u0BCD"=>9,
+    "\u0C3C"=>7,
     "\u0C4D"=>9,
     "\u0C55"=>84,
     "\u0C56"=>91,
@@ -1886,6 +1975,7 @@ module UnicodeNormalize  # :nodoc:
     "\u135E"=>230,
     "\u135F"=>230,
     "\u1714"=>9,
+    "\u1715"=>9,
     "\u1734"=>9,
     "\u17D2"=>9,
     "\u17DD"=>230,
@@ -1921,6 +2011,47 @@ module UnicodeNormalize  # :nodoc:
     "\u1ABD"=>220,
     "\u1ABF"=>220,
     "\u1AC0"=>220,
+    "\u1AC1"=>230,
+    "\u1AC2"=>230,
+    "\u1AC3"=>220,
+    "\u1AC4"=>220,
+    "\u1AC5"=>230,
+    "\u1AC6"=>230,
+    "\u1AC7"=>230,
+    "\u1AC8"=>230,
+    "\u1AC9"=>230,
+    "\u1ACA"=>220,
+    "\u1ACB"=>230,
+    "\u1ACC"=>230,
+    "\u1ACD"=>230,
+    "\u1ACE"=>230,
+    "\u1ACF"=>230,
+    "\u1AD0"=>230,
+    "\u1AD1"=>230,
+    "\u1AD2"=>230,
+    "\u1AD3"=>230,
+    "\u1AD4"=>230,
+    "\u1AD5"=>230,
+    "\u1AD6"=>230,
+    "\u1AD7"=>230,
+    "\u1AD8"=>230,
+    "\u1AD9"=>230,
+    "\u1ADA"=>230,
+    "\u1ADB"=>230,
+    "\u1ADC"=>230,
+    "\u1ADD"=>220,
+    "\u1AE0"=>230,
+    "\u1AE1"=>230,
+    "\u1AE2"=>230,
+    "\u1AE3"=>230,
+    "\u1AE4"=>230,
+    "\u1AE5"=>230,
+    "\u1AE6"=>220,
+    "\u1AE7"=>230,
+    "\u1AE8"=>230,
+    "\u1AE9"=>230,
+    "\u1AEA"=>230,
+    "\u1AEB"=>234,
     "\u1B34"=>7,
     "\u1B44"=>9,
     "\u1B6B"=>230,
@@ -2023,6 +2154,7 @@ module UnicodeNormalize  # :nodoc:
     "\u1DF7"=>228,
     "\u1DF8"=>228,
     "\u1DF9"=>220,
+    "\u1DFA"=>218,
     "\u1DFB"=>230,
     "\u1DFC"=>233,
     "\u1DFD"=>220,
@@ -2187,8 +2319,18 @@ module UnicodeNormalize  # :nodoc:
     "\u{10D25}"=>230,
     "\u{10D26}"=>230,
     "\u{10D27}"=>230,
+    "\u{10D69}"=>230,
+    "\u{10D6A}"=>230,
+    "\u{10D6B}"=>230,
+    "\u{10D6C}"=>230,
+    "\u{10D6D}"=>230,
     "\u{10EAB}"=>230,
     "\u{10EAC}"=>230,
+    "\u{10EFA}"=>220,
+    "\u{10EFB}"=>220,
+    "\u{10EFD}"=>220,
+    "\u{10EFE}"=>220,
+    "\u{10EFF}"=>220,
     "\u{10F46}"=>220,
     "\u{10F47}"=>220,
     "\u{10F48}"=>230,
@@ -2200,7 +2342,12 @@ module UnicodeNormalize  # :nodoc:
     "\u{10F4E}"=>220,
     "\u{10F4F}"=>220,
     "\u{10F50}"=>220,
+    "\u{10F82}"=>230,
+    "\u{10F83}"=>220,
+    "\u{10F84}"=>230,
+    "\u{10F85}"=>220,
     "\u{11046}"=>9,
+    "\u{11070}"=>9,
     "\u{1107F}"=>9,
     "\u{110B9}"=>9,
     "\u{110BA}"=>7,
@@ -2231,6 +2378,9 @@ module UnicodeNormalize  # :nodoc:
     "\u{11372}"=>230,
     "\u{11373}"=>230,
     "\u{11374}"=>230,
+    "\u{113CE}"=>9,
+    "\u{113CF}"=>9,
+    "\u{113D0}"=>9,
     "\u{11442}"=>9,
     "\u{11446}"=>7,
     "\u{1145E}"=>230,
@@ -2256,6 +2406,9 @@ module UnicodeNormalize  # :nodoc:
     "\u{11D44}"=>9,
     "\u{11D45}"=>9,
     "\u{11D97}"=>9,
+    "\u{11F41}"=>9,
+    "\u{11F42}"=>9,
+    "\u{1612F}"=>9,
     "\u{16AF0}"=>1,
     "\u{16AF1}"=>1,
     "\u{16AF2}"=>1,
@@ -2342,6 +2495,7 @@ module UnicodeNormalize  # :nodoc:
     "\u{1E028}"=>230,
     "\u{1E029}"=>230,
     "\u{1E02A}"=>230,
+    "\u{1E08F}"=>230,
     "\u{1E130}"=>230,
     "\u{1E131}"=>230,
     "\u{1E132}"=>230,
@@ -2349,10 +2503,22 @@ module UnicodeNormalize  # :nodoc:
     "\u{1E134}"=>230,
     "\u{1E135}"=>230,
     "\u{1E136}"=>230,
+    "\u{1E2AE}"=>230,
     "\u{1E2EC}"=>230,
     "\u{1E2ED}"=>230,
     "\u{1E2EE}"=>230,
     "\u{1E2EF}"=>230,
+    "\u{1E4EC}"=>232,
+    "\u{1E4ED}"=>232,
+    "\u{1E4EE}"=>220,
+    "\u{1E4EF}"=>230,
+    "\u{1E5EE}"=>230,
+    "\u{1E5EF}"=>220,
+    "\u{1E6E3}"=>230,
+    "\u{1E6E6}"=>230,
+    "\u{1E6EE}"=>230,
+    "\u{1E6EF}"=>230,
+    "\u{1E6F5}"=>230,
     "\u{1E8D0}"=>220,
     "\u{1E8D1}"=>220,
     "\u{1E8D2}"=>220,
@@ -3865,6 +4031,8 @@ module UnicodeNormalize  # :nodoc:
     "\uFB4C"=>"\u05D1\u05BF",
     "\uFB4D"=>"\u05DB\u05BF",
     "\uFB4E"=>"\u05E4\u05BF",
+    "\u{105C9}"=>"\u{105D2}\u0307",
+    "\u{105E4}"=>"\u{105DA}\u0307",
     "\u{1109A}"=>"\u{11099}\u{110BA}",
     "\u{1109C}"=>"\u{1109B}\u{110BA}",
     "\u{110AB}"=>"\u{110A5}\u{110BA}",
@@ -3872,12 +4040,30 @@ module UnicodeNormalize  # :nodoc:
     "\u{1112F}"=>"\u{11132}\u{11127}",
     "\u{1134B}"=>"\u{11347}\u{1133E}",
     "\u{1134C}"=>"\u{11347}\u{11357}",
+    "\u{11383}"=>"\u{11382}\u{113C9}",
+    "\u{11385}"=>"\u{11384}\u{113BB}",
+    "\u{1138E}"=>"\u{1138B}\u{113C2}",
+    "\u{11391}"=>"\u{11390}\u{113C9}",
+    "\u{113C5}"=>"\u{113C2}\u{113C2}",
+    "\u{113C7}"=>"\u{113C2}\u{113B8}",
+    "\u{113C8}"=>"\u{113C2}\u{113C9}",
     "\u{114BB}"=>"\u{114B9}\u{114BA}",
     "\u{114BC}"=>"\u{114B9}\u{114B0}",
     "\u{114BE}"=>"\u{114B9}\u{114BD}",
     "\u{115BA}"=>"\u{115B8}\u{115AF}",
     "\u{115BB}"=>"\u{115B9}\u{115AF}",
     "\u{11938}"=>"\u{11935}\u{11930}",
+    "\u{16121}"=>"\u{1611E}\u{1611E}",
+    "\u{16122}"=>"\u{1611E}\u{16129}",
+    "\u{16123}"=>"\u{1611E}\u{1611F}",
+    "\u{16124}"=>"\u{16129}\u{1611F}",
+    "\u{16125}"=>"\u{1611E}\u{16120}",
+    "\u{16126}"=>"\u{1611E}\u{1611E}\u{1611F}",
+    "\u{16127}"=>"\u{1611E}\u{16129}\u{1611F}",
+    "\u{16128}"=>"\u{1611E}\u{1611E}\u{16120}",
+    "\u{16D68}"=>"\u{16D67}\u{16D67}",
+    "\u{16D69}"=>"\u{16D63}\u{16D67}",
+    "\u{16D6A}"=>"\u{16D63}\u{16D67}\u{16D67}",
     "\u{1D15E}"=>"\u{1D157}\u{1D165}",
     "\u{1D15F}"=>"\u{1D158}\u{1D165}",
     "\u{1D160}"=>"\u{1D158}\u{1D165}\u{1D16E}",
@@ -5776,6 +5962,10 @@ module UnicodeNormalize  # :nodoc:
     "\uA69C"=>"\u044A",
     "\uA69D"=>"\u044C",
     "\uA770"=>"\uA76F",
+    "\uA7F1"=>"S",
+    "\uA7F2"=>"C",
+    "\uA7F3"=>"F",
+    "\uA7F4"=>"Q",
     "\uA7F8"=>"\u0126",
     "\uA7F9"=>"\u0153",
     "\uAB5C"=>"\uA727",
@@ -6828,6 +7018,98 @@ module UnicodeNormalize  # :nodoc:
     "\uFFEC"=>"\u2193",
     "\uFFED"=>"\u25A0",
     "\uFFEE"=>"\u25CB",
+    "\u{10781}"=>"\u02D0",
+    "\u{10782}"=>"\u02D1",
+    "\u{10783}"=>"\u00E6",
+    "\u{10784}"=>"\u0299",
+    "\u{10785}"=>"\u0253",
+    "\u{10787}"=>"\u02A3",
+    "\u{10788}"=>"\uAB66",
+    "\u{10789}"=>"\u02A5",
+    "\u{1078A}"=>"\u02A4",
+    "\u{1078B}"=>"\u0256",
+    "\u{1078C}"=>"\u0257",
+    "\u{1078D}"=>"\u1D91",
+    "\u{1078E}"=>"\u0258",
+    "\u{1078F}"=>"\u025E",
+    "\u{10790}"=>"\u02A9",
+    "\u{10791}"=>"\u0264",
+    "\u{10792}"=>"\u0262",
+    "\u{10793}"=>"\u0260",
+    "\u{10794}"=>"\u029B",
+    "\u{10795}"=>"\u0127",
+    "\u{10796}"=>"\u029C",
+    "\u{10797}"=>"\u0267",
+    "\u{10798}"=>"\u0284",
+    "\u{10799}"=>"\u02AA",
+    "\u{1079A}"=>"\u02AB",
+    "\u{1079B}"=>"\u026C",
+    "\u{1079C}"=>"\u{1DF04}",
+    "\u{1079D}"=>"\uA78E",
+    "\u{1079E}"=>"\u026E",
+    "\u{1079F}"=>"\u{1DF05}",
+    "\u{107A0}"=>"\u028E",
+    "\u{107A1}"=>"\u{1DF06}",
+    "\u{107A2}"=>"\u00F8",
+    "\u{107A3}"=>"\u0276",
+    "\u{107A4}"=>"\u0277",
+    "\u{107A5}"=>"q",
+    "\u{107A6}"=>"\u027A",
+    "\u{107A7}"=>"\u{1DF08}",
+    "\u{107A8}"=>"\u027D",
+    "\u{107A9}"=>"\u027E",
+    "\u{107AA}"=>"\u0280",
+    "\u{107AB}"=>"\u02A8",
+    "\u{107AC}"=>"\u02A6",
+    "\u{107AD}"=>"\uAB67",
+    "\u{107AE}"=>"\u02A7",
+    "\u{107AF}"=>"\u0288",
+    "\u{107B0}"=>"\u2C71",
+    "\u{107B2}"=>"\u028F",
+    "\u{107B3}"=>"\u02A1",
+    "\u{107B4}"=>"\u02A2",
+    "\u{107B5}"=>"\u0298",
+    "\u{107B6}"=>"\u01C0",
+    "\u{107B7}"=>"\u01C1",
+    "\u{107B8}"=>"\u01C2",
+    "\u{107B9}"=>"\u{1DF0A}",
+    "\u{107BA}"=>"\u{1DF1E}",
+    "\u{1CCD6}"=>"A",
+    "\u{1CCD7}"=>"B",
+    "\u{1CCD8}"=>"C",
+    "\u{1CCD9}"=>"D",
+    "\u{1CCDA}"=>"E",
+    "\u{1CCDB}"=>"F",
+    "\u{1CCDC}"=>"G",
+    "\u{1CCDD}"=>"H",
+    "\u{1CCDE}"=>"I",
+    "\u{1CCDF}"=>"J",
+    "\u{1CCE0}"=>"K",
+    "\u{1CCE1}"=>"L",
+    "\u{1CCE2}"=>"M",
+    "\u{1CCE3}"=>"N",
+    "\u{1CCE4}"=>"O",
+    "\u{1CCE5}"=>"P",
+    "\u{1CCE6}"=>"Q",
+    "\u{1CCE7}"=>"R",
+    "\u{1CCE8}"=>"S",
+    "\u{1CCE9}"=>"T",
+    "\u{1CCEA}"=>"U",
+    "\u{1CCEB}"=>"V",
+    "\u{1CCEC}"=>"W",
+    "\u{1CCED}"=>"X",
+    "\u{1CCEE}"=>"Y",
+    "\u{1CCEF}"=>"Z",
+    "\u{1CCF0}"=>"0",
+    "\u{1CCF1}"=>"1",
+    "\u{1CCF2}"=>"2",
+    "\u{1CCF3}"=>"3",
+    "\u{1CCF4}"=>"4",
+    "\u{1CCF5}"=>"5",
+    "\u{1CCF6}"=>"6",
+    "\u{1CCF7}"=>"7",
+    "\u{1CCF8}"=>"8",
+    "\u{1CCF9}"=>"9",
     "\u{1D400}"=>"A",
     "\u{1D401}"=>"B",
     "\u{1D402}"=>"C",
@@ -7824,6 +8106,68 @@ module UnicodeNormalize  # :nodoc:
     "\u{1D7FD}"=>"7",
     "\u{1D7FE}"=>"8",
     "\u{1D7FF}"=>"9",
+    "\u{1E030}"=>"\u0430",
+    "\u{1E031}"=>"\u0431",
+    "\u{1E032}"=>"\u0432",
+    "\u{1E033}"=>"\u0433",
+    "\u{1E034}"=>"\u0434",
+    "\u{1E035}"=>"\u0435",
+    "\u{1E036}"=>"\u0436",
+    "\u{1E037}"=>"\u0437",
+    "\u{1E038}"=>"\u0438",
+    "\u{1E039}"=>"\u043A",
+    "\u{1E03A}"=>"\u043B",
+    "\u{1E03B}"=>"\u043C",
+    "\u{1E03C}"=>"\u043E",
+    "\u{1E03D}"=>"\u043F",
+    "\u{1E03E}"=>"\u0440",
+    "\u{1E03F}"=>"\u0441",
+    "\u{1E040}"=>"\u0442",
+    "\u{1E041}"=>"\u0443",
+    "\u{1E042}"=>"\u0444",
+    "\u{1E043}"=>"\u0445",
+    "\u{1E044}"=>"\u0446",
+    "\u{1E045}"=>"\u0447",
+    "\u{1E046}"=>"\u0448",
+    "\u{1E047}"=>"\u044B",
+    "\u{1E048}"=>"\u044D",
+    "\u{1E049}"=>"\u044E",
+    "\u{1E04A}"=>"\uA689",
+    "\u{1E04B}"=>"\u04D9",
+    "\u{1E04C}"=>"\u0456",
+    "\u{1E04D}"=>"\u0458",
+    "\u{1E04E}"=>"\u04E9",
+    "\u{1E04F}"=>"\u04AF",
+    "\u{1E050}"=>"\u04CF",
+    "\u{1E051}"=>"\u0430",
+    "\u{1E052}"=>"\u0431",
+    "\u{1E053}"=>"\u0432",
+    "\u{1E054}"=>"\u0433",
+    "\u{1E055}"=>"\u0434",
+    "\u{1E056}"=>"\u0435",
+    "\u{1E057}"=>"\u0436",
+    "\u{1E058}"=>"\u0437",
+    "\u{1E059}"=>"\u0438",
+    "\u{1E05A}"=>"\u043A",
+    "\u{1E05B}"=>"\u043B",
+    "\u{1E05C}"=>"\u043E",
+    "\u{1E05D}"=>"\u043F",
+    "\u{1E05E}"=>"\u0441",
+    "\u{1E05F}"=>"\u0443",
+    "\u{1E060}"=>"\u0444",
+    "\u{1E061}"=>"\u0445",
+    "\u{1E062}"=>"\u0446",
+    "\u{1E063}"=>"\u0447",
+    "\u{1E064}"=>"\u0448",
+    "\u{1E065}"=>"\u044A",
+    "\u{1E066}"=>"\u044B",
+    "\u{1E067}"=>"\u0491",
+    "\u{1E068}"=>"\u0456",
+    "\u{1E069}"=>"\u0455",
+    "\u{1E06A}"=>"\u045F",
+    "\u{1E06B}"=>"\u04AB",
+    "\u{1E06C}"=>"\uA651",
+    "\u{1E06D}"=>"\u04B1",
     "\u{1EE00}"=>"\u0627",
     "\u{1EE01}"=>"\u0628",
     "\u{1EE02}"=>"\u062C",
@@ -9058,6 +9402,8 @@ module UnicodeNormalize  # :nodoc:
     "\u30F1\u3099"=>"\u30F9",
     "\u30F2\u3099"=>"\u30FA",
     "\u30FD\u3099"=>"\u30FE",
+    "\u{105D2}\u0307"=>"\u{105C9}",
+    "\u{105DA}\u0307"=>"\u{105E4}",
     "\u{11099}\u{110BA}"=>"\u{1109A}",
     "\u{1109B}\u{110BA}"=>"\u{1109C}",
     "\u{110A5}\u{110BA}"=>"\u{110AB}",
@@ -9065,11 +9411,29 @@ module UnicodeNormalize  # :nodoc:
     "\u{11132}\u{11127}"=>"\u{1112F}",
     "\u{11347}\u{1133E}"=>"\u{1134B}",
     "\u{11347}\u{11357}"=>"\u{1134C}",
+    "\u{11382}\u{113C9}"=>"\u{11383}",
+    "\u{11384}\u{113BB}"=>"\u{11385}",
+    "\u{1138B}\u{113C2}"=>"\u{1138E}",
+    "\u{11390}\u{113C9}"=>"\u{11391}",
+    "\u{113C2}\u{113C2}"=>"\u{113C5}",
+    "\u{113C2}\u{113B8}"=>"\u{113C7}",
+    "\u{113C2}\u{113C9}"=>"\u{113C8}",
     "\u{114B9}\u{114BA}"=>"\u{114BB}",
     "\u{114B9}\u{114B0}"=>"\u{114BC}",
     "\u{114B9}\u{114BD}"=>"\u{114BE}",
     "\u{115B8}\u{115AF}"=>"\u{115BA}",
     "\u{115B9}\u{115AF}"=>"\u{115BB}",
     "\u{11935}\u{11930}"=>"\u{11938}",
+    "\u{1611E}\u{1611E}"=>"\u{16121}",
+    "\u{1611E}\u{16129}"=>"\u{16122}",
+    "\u{1611E}\u{1611F}"=>"\u{16123}",
+    "\u{16129}\u{1611F}"=>"\u{16124}",
+    "\u{1611E}\u{16120}"=>"\u{16125}",
+    "\u{16121}\u{1611F}"=>"\u{16126}",
+    "\u{16122}\u{1611F}"=>"\u{16127}",
+    "\u{16121}\u{16120}"=>"\u{16128}",
+    "\u{16D67}\u{16D67}"=>"\u{16D68}",
+    "\u{16D63}\u{16D67}"=>"\u{16D69}",
+    "\u{16D69}\u{16D67}"=>"\u{16D6A}",
   }.freeze
 end

From 9875b6170daec910fd39f1f8a3ac468529ab8262 Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Sat, 28 Feb 2026 21:09:38 -0600
Subject: [PATCH 159/168] Tag SSL test for timeout

Not yet implemented on SSLSocket.

See https://github.com/jruby/jruby-openssl/issues/342
---
 test/mri/excludes/OpenSSL/TestSSL.rb | 1 +
 1 file changed, 1 insertion(+)

diff --git a/test/mri/excludes/OpenSSL/TestSSL.rb b/test/mri/excludes/OpenSSL/TestSSL.rb
index 7600410d848..7b29d857c3f 100644
--- a/test/mri/excludes/OpenSSL/TestSSL.rb
+++ b/test/mri/excludes/OpenSSL/TestSSL.rb
@@ -38,6 +38,7 @@
 exclude :test_options_setting_nil_means_all, 'needs investigation'
 exclude :test_post_connect_check_with_anon_ciphers, 'needs investigation'
 exclude :test_read_nonblock_without_session, 'HANGS'
+exclude :test_read_with_timeout, "timeout methods not implemented, https://github.com/jruby/jruby-openssl/issues/342"
 exclude :test_readbyte, "work in progress"
 exclude :test_renegotiation_cb, 'SSLContext#renegotiation_cb= not supported'
 exclude :test_respect_system_default_min, "new failure with Ruby 4.0 tests, tested on MacOS, https://github.com/jruby/jruby/issues/9271"

From b0701090e2ae1f912304073ecbda299849565d92 Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Sat, 28 Feb 2026 20:05:00 -0600
Subject: [PATCH 160/168] Exclude a few more OpenURI tests failing in util code

---
 test/mri/excludes/TestOpenURI.rb | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/test/mri/excludes/TestOpenURI.rb b/test/mri/excludes/TestOpenURI.rb
index d5a0d660d31..ba8f5199439 100644
--- a/test/mri/excludes/TestOpenURI.rb
+++ b/test/mri/excludes/TestOpenURI.rb
@@ -1,3 +1,4 @@
+exclude :test_200, "fails in http test logic, https://github.com/jruby/jruby/issues/9276"
 exclude :test_404, "fails in http test logic, https://github.com/jruby/jruby/issues/9276"
 exclude :test_encoding, "fails in http test logic, https://github.com/jruby/jruby/issues/9276"
 exclude :test_header, "fails in http test logic, https://github.com/jruby/jruby/issues/9276"
@@ -5,6 +6,7 @@
 exclude :test_mode, "fails in http test logic, https://github.com/jruby/jruby/issues/9276"
 exclude :test_multiple_cookies, "fails in http test logic, https://github.com/jruby/jruby/issues/9276"
 exclude :test_open_timeout, "hangs on macos m1"
+exclude :test_open_uri, "fails in http test logic, https://github.com/jruby/jruby/issues/9276"
 exclude :test_progress, "fails in http test logic, https://github.com/jruby/jruby/issues/9276"
 exclude :test_redirect, "fails in http test logic, https://github.com/jruby/jruby/issues/9276"
 exclude :test_redirect_auth_failure_r2, "fails in http test logic, https://github.com/jruby/jruby/issues/9276"

From a8b344a85a847e91d7dc9e02f3c64b43338e41ba Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Sat, 28 Feb 2026 21:15:57 -0600
Subject: [PATCH 161/168] Accept fast_fallback and test_mode_settings kwargs

Unimplemented because I'm unsure how we can provide HEv2 atop JVM
sockets.

See https://github.com/ruby/ruby/pull/11653
---
 core/src/main/java/org/jruby/ext/socket/RubyTCPSocket.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/core/src/main/java/org/jruby/ext/socket/RubyTCPSocket.java b/core/src/main/java/org/jruby/ext/socket/RubyTCPSocket.java
index 50b94288e10..5f324edc8ee 100644
--- a/core/src/main/java/org/jruby/ext/socket/RubyTCPSocket.java
+++ b/core/src/main/java/org/jruby/ext/socket/RubyTCPSocket.java
@@ -95,8 +95,8 @@ private SocketChannel attemptConnect(ThreadContext context, IRubyObject host, St
 
                 long timeout = -1;
                 if (opts != null) {
-                    IRubyObject[] timeouts = ArgsUtil.extractKeywordArgs(context, opts, "connect_timeout", "open_timeout");
-                    IRubyObject connectTimeout = timeouts[0];
+                    IRubyObject[] kwargs = ArgsUtil.extractKeywordArgs(context, opts, "connect_timeout", "open_timeout", "fast_fallback", "test_mode_settings");
+                    IRubyObject connectTimeout = kwargs[0];
                     if (connectTimeout != null && !connectTimeout.isNil()) {
                         timeout = (long) (connectTimeout.convertToFloat().asDouble(context) * 1000);
                     }

From bbdeaca5a869e7fad44e964c45f55699c82c7b32 Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Sat, 28 Feb 2026 21:19:49 -0600
Subject: [PATCH 162/168] Coerce path argument to UNIXServer.open

---
 core/src/main/java/org/jruby/ext/socket/RubyUNIXSocket.java | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/core/src/main/java/org/jruby/ext/socket/RubyUNIXSocket.java b/core/src/main/java/org/jruby/ext/socket/RubyUNIXSocket.java
index bc9c8181634..3b069bfc48b 100644
--- a/core/src/main/java/org/jruby/ext/socket/RubyUNIXSocket.java
+++ b/core/src/main/java/org/jruby/ext/socket/RubyUNIXSocket.java
@@ -42,6 +42,7 @@
 import jnr.unixsocket.UnixSocketChannel;
 import org.jruby.Ruby;
 import org.jruby.RubyClass;
+import org.jruby.RubyFile;
 import org.jruby.RubyFixnum;
 import org.jruby.RubyIO;
 import org.jruby.RubyNumeric;
@@ -350,7 +351,7 @@ protected void init_unixsock(ThreadContext context, IRubyObject _path, boolean s
 
     // MRI: unixsock_path_value
     private static RubyString unixsockPathValue(ThreadContext context, IRubyObject path) {
-        return checkEmbeddedNulls(context, path.convertToString());
+        return checkEmbeddedNulls(context, RubyFile.get_path(context, path));
     }

From ba9c568e9ce95fc9ed6b420af644cf06db30acb9 Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Sat, 28 Feb 2026 21:21:51 -0600
Subject: [PATCH 163/168] Match CRuby frozen error for class/module

---
 core/src/main/java/org/jruby/RubyBasicObject.java | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/core/src/main/java/org/jruby/RubyBasicObject.java b/core/src/main/java/org/jruby/RubyBasicObject.java
index 1e9d2defc3e..bd4053d4097 100644
--- a/core/src/main/java/org/jruby/RubyBasicObject.java
+++ b/core/src/main/java/org/jruby/RubyBasicObject.java
@@ -1734,8 +1734,10 @@ public void forEachInstanceVariable(BiConsumer<String, IRubyObject> accessor) {
     }
 
     private void raiseFrozenError() throws RaiseException {
-        if (this instanceof RubyModule) {
-            throw getRuntime().newFrozenError("class/module ", this);
+        if (this instanceof RubyClass) {
+            throw getRuntime().newFrozenError("Class", this);
+        } else if (this instanceof RubyModule) {
+            throw getRuntime().newFrozenError("Module", this);
         } else {
             throw getRuntime().newFrozenError(this);
         }

From 249506f0ec926534b786b21f43c8b07291f0b8f7 Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Sat, 28 Feb 2026 21:23:47 -0600
Subject: [PATCH 164/168] Exclude test failing on GHA Linux

---
 test/mri/excludes/TestIO.rb | 1 +
 1 file changed, 1 insertion(+)

diff --git a/test/mri/excludes/TestIO.rb b/test/mri/excludes/TestIO.rb
index e26e58b86c2..d4224a5230d 100644
--- a/test/mri/excludes/TestIO.rb
+++ b/test/mri/excludes/TestIO.rb
@@ -20,6 +20,7 @@
 exclude :test_readlines_limit_0, "hangs"
 exclude :test_readpartial_lock, "needs investigation"
 exclude :test_readpartial_locktmp, "requires string locking we do not support"
+exclude :test_recycled_fd_close, 'fails on GHA Linux CI, NullPointerException: Cannot invoke "Object.getClass()" because "object" is null'
 exclude :test_reinitialize, "needs investigation"
 exclude :test_reopen_encoding_from_io, "needs investigation"
 exclude :test_reopen_opt, "needs investigation"

From e597aab1972d2859883830daf783dc358d392fa8 Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Sat, 28 Feb 2026 21:59:06 -0600
Subject: [PATCH 165/168] Exclude remaining open-uri test failures

All relate to the same failing behavior in the HTTP server it sets
up.

See https://github.com/jruby/jruby/issues/9276
---
 test/mri/excludes/TestOpenURI.rb | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/test/mri/excludes/TestOpenURI.rb b/test/mri/excludes/TestOpenURI.rb
index ba8f5199439..e0fbd2f2e23 100644
--- a/test/mri/excludes/TestOpenURI.rb
+++ b/test/mri/excludes/TestOpenURI.rb
@@ -1,15 +1,29 @@
 exclude :test_200, "fails in http test logic, https://github.com/jruby/jruby/issues/9276"
+exclude :test_200_uri_open, "fails in http test logic, https://github.com/jruby/jruby/issues/9276"
+exclude :test_200big, "fails in http test logic, https://github.com/jruby/jruby/issues/9276"
 exclude :test_404, "fails in http test logic, https://github.com/jruby/jruby/issues/9276"
+exclude :test_close_in_block_big, "fails in http test logic, https://github.com/jruby/jruby/issues/9276"
+exclude :test_close_in_block_small, "fails in http test logic, https://github.com/jruby/jruby/issues/9276"
+exclude :test_content_encoding, "fails in http test logic, https://github.com/jruby/jruby/issues/9276"
 exclude :test_encoding, "fails in http test logic, https://github.com/jruby/jruby/issues/9276"
 exclude :test_header, "fails in http test logic, https://github.com/jruby/jruby/issues/9276"
+exclude :test_last_modified, "fails in http test logic, https://github.com/jruby/jruby/issues/9276"
 exclude :test_max_redirects_success, "fails in http test logic, https://github.com/jruby/jruby/issues/9276"
+exclude :test_max_redirects_too_many, "fails in http test logic, https://github.com/jruby/jruby/issues/9276"
 exclude :test_mode, "fails in http test logic, https://github.com/jruby/jruby/issues/9276"
 exclude :test_multiple_cookies, "fails in http test logic, https://github.com/jruby/jruby/issues/9276"
 exclude :test_open_timeout, "hangs on macos m1"
 exclude :test_open_uri, "fails in http test logic, https://github.com/jruby/jruby/issues/9276"
 exclude :test_progress, "fails in http test logic, https://github.com/jruby/jruby/issues/9276"
+exclude :test_progress_chunked, "fails in http test logic, https://github.com/jruby/jruby/issues/9276"
 exclude :test_redirect, "fails in http test logic, https://github.com/jruby/jruby/issues/9276"
+exclude :test_redirect_auth_failure_r1, "fails in http test logic, https://github.com/jruby/jruby/issues/9276"
 exclude :test_redirect_auth_failure_r2, "fails in http test logic, https://github.com/jruby/jruby/issues/9276"
 exclude :test_redirect_auth_success, "fails in http test logic, https://github.com/jruby/jruby/issues/9276"
 exclude :test_redirect_loop, "fails in http test logic, https://github.com/jruby/jruby/issues/9276"
+exclude :test_redirect_with_invalid_request_specific_fields_format, "fails in http test logic, https://github.com/jruby/jruby/issues/9276"
+exclude :test_redirect_with_request_specific_fields_hash, "fails in http test logic, https://github.com/jruby/jruby/issues/9276"
+exclude :test_redirect_with_request_specific_fields_proc, "fails in http test logic, https://github.com/jruby/jruby/issues/9276"
 exclude :test_redirect_without_request_specific_fields_hash, "fails in http test logic, https://github.com/jruby/jruby/issues/9276"
+exclude :test_uri_read, "fails in http test logic, https://github.com/jruby/jruby/issues/9276"
+exclude :test_without_block, "fails in http test logic, https://github.com/jruby/jruby/issues/9276"

From c58da66d700e00920e57a70f106d29e1032082d7 Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Sat, 28 Feb 2026 22:41:35 -0600
Subject: [PATCH 166/168] Additional failure due to new callable form

See https://github.com/jruby/jruby/issues/9270
---
 test/mri/excludes/TestRipper/ParserEvents.rb | 1 +
 1 file changed, 1 insertion(+)

diff --git a/test/mri/excludes/TestRipper/ParserEvents.rb b/test/mri/excludes/TestRipper/ParserEvents.rb
index c87fd8f7282..3ed6523b1f2 100644
--- a/test/mri/excludes/TestRipper/ParserEvents.rb
+++ b/test/mri/excludes/TestRipper/ParserEvents.rb
@@ -3,6 +3,7 @@
 exclude :test_anonymous_rest_forwarding, "needs investigation"
 exclude :test_args_forward, "needs investigation"
 exclude :test_assign_error_backref, "needs investigation"
+exclude :test_call, "needs parser work, https://github.com/jruby/jruby/issues/9270"
 exclude :test_call_colon2, "needs investigation"
 exclude :test_event_coverage, "needs investigation"
 exclude :test_return_out_of_compile_error_no_memory_leak, "uses CRuby memory leak detection"

From 252027326e82dcf5c354c61f178e6f8a55983c68 Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Sat, 28 Feb 2026 22:42:10 -0600
Subject: [PATCH 167/168] Exclude remaining IO and socket failures

---
 test/mri/excludes/TestIOWaitUncommon.rb   | 1 +
 test/mri/excludes/TestNetHTTPLocalBind.rb | 1 +
 test/mri/excludes/TestSocket_TCPSocket.rb | 1 +
 3 files changed, 3 insertions(+)
 create mode 100644 test/mri/excludes/TestIOWaitUncommon.rb
 create mode 100644 test/mri/excludes/TestNetHTTPLocalBind.rb

diff --git a/test/mri/excludes/TestIOWaitUncommon.rb b/test/mri/excludes/TestIOWaitUncommon.rb
new file mode 100644
index 00000000000..ebcb9e1e0e9
--- /dev/null
+++ b/test/mri/excludes/TestIOWaitUncommon.rb
@@ -0,0 +1 @@
+exclude :test_after_ungetc_in_text_wait_readable, "needs investigation, may relate to text/binary mode"
diff --git a/test/mri/excludes/TestNetHTTPLocalBind.rb b/test/mri/excludes/TestNetHTTPLocalBind.rb
new file mode 100644
index 00000000000..112d42c34fd
--- /dev/null
+++ b/test/mri/excludes/TestNetHTTPLocalBind.rb
@@ -0,0 +1 @@
+exclude :test_bind_to_local_port, "port mismatch in final assertion"
diff --git a/test/mri/excludes/TestSocket_TCPSocket.rb b/test/mri/excludes/TestSocket_TCPSocket.rb
index 2e3e5d90fa9..f2059ce3187 100644
--- a/test/mri/excludes/TestSocket_TCPSocket.rb
+++ b/test/mri/excludes/TestSocket_TCPSocket.rb
@@ -12,3 +12,4 @@
 exclude :test_initialize_with_hostname_resolution_failure_after_connection_failure, "needs investigation"
 exclude :test_inspect, "missing socket information"
 exclude :test_recvfrom, "no addrinfo returned"
+exclude :test_tcp_initialize_open_timeout, "connection refused to localhost"

From 6a826d6d3e02a0e6d07e8782164c3b695d17e65d Mon Sep 17 00:00:00 2001
From: Charles Oliver Nutter <headius@headius.com>
Date: Sat, 28 Feb 2026 23:10:54 -0600
Subject: [PATCH 168/168] Exclude remaining unfinished Ruby 4.0 tests

---
 test/mri/excludes/TestAlias.rb   | 1 +
 test/mri/excludes/TestDefined.rb | 1 +
 test/mri/excludes/TestModule.rb  | 1 +
 test/mri/excludes/TestRegexp.rb  | 1 +
 4 files changed, 4 insertions(+)

diff --git a/test/mri/excludes/TestAlias.rb b/test/mri/excludes/TestAlias.rb
index 9107d29bead..1643df06ed2 100644
--- a/test/mri/excludes/TestAlias.rb
+++ b/test/mri/excludes/TestAlias.rb
@@ -1,2 +1,3 @@
 exclude :test_alias_memory_leak, "no working assert_no_memory_leak method"
 exclude :test_alias_wb_miss, "no GC.verify_internal_consistency method"
+exclude :test_undef_method_error_message_with_zsuper_method, "strange undef case with module prepends"
diff --git a/test/mri/excludes/TestDefined.rb b/test/mri/excludes/TestDefined.rb
index f78bfb6d91e..78f1319f383 100644
--- a/test/mri/excludes/TestDefined.rb
+++ b/test/mri/excludes/TestDefined.rb
@@ -1,6 +1,7 @@
 exclude :test_defined_empty_paren_expr, "work in progress"
 exclude :test_defined_matchdata, "work in progress"
 exclude :test_defined_method_single_call, "work in progress"
+exclude :test_defined_paren_void_stmts, "needs investigation"
 exclude :test_defined_protected_method, "work in progress"
 exclude :test_defined_refined_call_with_using, "work in progress"
 exclude :test_defined_refined_vcall_with_using, "work in progress"
diff --git a/test/mri/excludes/TestModule.rb b/test/mri/excludes/TestModule.rb
index f3038c18b8a..48294eace57 100644
--- a/test/mri/excludes/TestModule.rb
+++ b/test/mri/excludes/TestModule.rb
@@ -21,4 +21,5 @@
 exclude :test_private_constant_with_no_args, "needs investigation"
 exclude :test_protected_singleton_method, "needs investigation"
 exclude :test_redefinition_mismatch, "work in progress"
+exclude :test_set_temporary_name, "anonymous classes must update contained classes when temp name set"
 exclude :test_undef, "missing warning about undefining __id__"
diff --git a/test/mri/excludes/TestRegexp.rb b/test/mri/excludes/TestRegexp.rb
index 2bbacdd1782..9092ca8a3d1 100644
--- a/test/mri/excludes/TestRegexp.rb
+++ b/test/mri/excludes/TestRegexp.rb
@@ -27,6 +27,7 @@
 exclude :test_posix_bracket, "work in progress"
 exclude :test_regsub_no_memory_leak, "no working assert_no_memory_leak method"
 exclude :test_s_timeout_memory_leak, "no working assert_no_memory_leak method"
+exclude :test_ss_in_look_behind, "new syntax for Ruby 4.0"
 exclude :test_timeout_memory_leak, "no working assert_no_memory_leak method"
 exclude :test_timeout_nil, "times out without error on JRuby, adds 10s for no value"
 exclude :test_to_s, "needs investigation"