#Test Results (version 2)
#Tue Oct 18 01:31:50 CEST 2016
#-----testdescription-----
$file=/home/peter/work/hg/jdk9-dev/jdk/test/java/lang/reflect/PublicMethods/PublicMethodsTest.java
$root=/home/peter/work/hg/jdk9-dev/jdk/test
keywords=bug8062389
run=USER_SPECIFIED main PublicMethodsTest\n
source=PublicMethodsTest.java
title=Nearly exhaustive test of Class.getMethod() and Class.getMethods()

#-----environment-----

#-----testresult-----
description=file\:/home/peter/work/hg/jdk9-dev/jdk/test/java/lang/reflect/PublicMethods/PublicMethodsTest.java
elapsed=15179 0\:00\:15.179
end=Tue Oct 18 01\:31\:50 CEST 2016
environment=regtest
execStatus=Failed. Execution failed\: `main' threw exception\: java.lang.RuntimeException\: There were 226 differences.
harnessLoaderMode=Classpath Loader
harnessVariety=Full Bundle
hostname=cube.rp12
javatestOS=Linux 4.7.7-100.fc23.x86_64 (amd64)
javatestVersion=4.6
jtregVersion=jtreg 4.2 dev b00
script=com.sun.javatest.regtest.RegressionScript
sections=script_messages build main
start=Tue Oct 18 01\:31\:35 CEST 2016
test=java/lang/reflect/PublicMethods/PublicMethodsTest.java
testJDK=/home/peter/Apps64/jdk9
totalTime=15183
user.name=peter
work=/home/peter/work/hg/jdk9-dev/JTwork/java/lang/reflect/PublicMethods

#section:script_messages
----------messages:(5/173)----------
JDK under test: /home/peter/Apps64/jdk9
java version "9-ea"
Java(TM) SE Runtime Environment (build 9-ea+137)
Java HotSpot(TM) 64-Bit Server VM (build 9-ea+137, mixed mode)


#section:build
----------messages:(3/102)----------
command: build PublicMethodsTest
reason: Named class compiled on demand
elapsed time (seconds): 0.001
result: Passed. All files up to date

#section:main
----------messages:(3/122)----------
command: main PublicMethodsTest
reason: User specified action: run main PublicMethodsTest 
elapsed time (seconds): 15.072
----------System.out:(2585/69998)----------
interface I { void m(); }
interface J {  }
interface K extends I, J {  }
abstract class C { public abstract void m(); }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K {  }

expected: E.gMs: [C.m]
  actual: E.gMs: [C.m, I.m]

expected: D.gMs: [C.m]
  actual: D.gMs: [C.m, I.m]


interface I { void m(); }
interface J {  }
interface K extends I, J {  }
abstract class C {  }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, I.m]


interface I { void m(); }
interface J {  }
interface K extends I, J {  }
abstract class C { public abstract void m(); }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, I.m]


interface I { void m(); }
interface J {  }
interface K extends I, J {  }
abstract class C { public void m() {} }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, I.m]


interface I { void m(); }
interface J {  }
interface K extends I, J {  }
abstract class C { public abstract void m(); }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K { public abstract void m(); }

expected: D.gMs: [C.m]
  actual: D.gMs: [C.m, I.m]


interface I { void m(); }
interface J {  }
interface K extends I, J {  }
abstract class C { public abstract void m(); }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K { public void m() {} }

expected: D.gMs: [C.m]
  actual: D.gMs: [C.m, I.m]


interface I { default void m() {} }
interface J {  }
interface K extends I, J {  }
abstract class C { public abstract void m(); }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K {  }

expected: E.gMs: [C.m]
  actual: E.gMs: [C.m, I.m]

expected: D.gMs: [C.m]
  actual: D.gMs: [C.m, I.m]


interface I { default void m() {} }
interface J {  }
interface K extends I, J {  }
abstract class C {  }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, I.m]


interface I { default void m() {} }
interface J {  }
interface K extends I, J {  }
abstract class C { public abstract void m(); }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, I.m]


interface I { default void m() {} }
interface J {  }
interface K extends I, J {  }
abstract class C { public void m() {} }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, I.m]


interface I { default void m() {} }
interface J {  }
interface K extends I, J {  }
abstract class C { public abstract void m(); }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K { public abstract void m(); }

expected: D.gMs: [C.m]
  actual: D.gMs: [C.m, I.m]


interface I { default void m() {} }
interface J {  }
interface K extends I, J {  }
abstract class C { public abstract void m(); }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K { public void m() {} }

expected: D.gMs: [C.m]
  actual: D.gMs: [C.m, I.m]


interface I {  }
interface J { void m(); }
interface K extends I, J {  }
abstract class C { public abstract void m(); }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K {  }

expected: E.gMs: [C.m]
  actual: E.gMs: [C.m, J.m]


interface I {  }
interface J { void m(); }
interface K extends I, J {  }
abstract class C {  }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, J.m]


interface I {  }
interface J { void m(); }
interface K extends I, J {  }
abstract class C { public abstract void m(); }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, J.m]


interface I {  }
interface J { void m(); }
interface K extends I, J {  }
abstract class C { public void m() {} }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, J.m]


interface I { void m(); }
interface J { void m(); }
interface K extends I, J {  }
abstract class C { public abstract void m(); }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K {  }

expected: E.gMs: [C.m]
  actual: E.gMs: [C.m, I.m, J.m]

expected: D.gMs: [C.m]
  actual: D.gMs: [C.m, I.m]


interface I { void m(); }
interface J { void m(); }
interface K extends I, J {  }
abstract class C {  }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, J.m, I.m]


interface I { void m(); }
interface J { void m(); }
interface K extends I, J {  }
abstract class C { public abstract void m(); }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, J.m, I.m]


interface I { void m(); }
interface J { void m(); }
interface K extends I, J {  }
abstract class C { public void m() {} }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, J.m, I.m]


interface I { void m(); }
interface J { void m(); }
interface K extends I, J {  }
abstract class C { public abstract void m(); }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K { public abstract void m(); }

expected: D.gMs: [C.m]
  actual: D.gMs: [C.m, I.m]


interface I { void m(); }
interface J { void m(); }
interface K extends I, J {  }
abstract class C { public abstract void m(); }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K { public void m() {} }

expected: D.gMs: [C.m]
  actual: D.gMs: [C.m, I.m]


interface I { static void m() {} }
interface J { void m(); }
interface K extends I, J {  }
abstract class C { public abstract void m(); }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K {  }

expected: E.gMs: [C.m]
  actual: E.gMs: [C.m, J.m]


interface I { static void m() {} }
interface J { void m(); }
interface K extends I, J {  }
abstract class C {  }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, J.m]


interface I { static void m() {} }
interface J { void m(); }
interface K extends I, J {  }
abstract class C { public abstract void m(); }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, J.m]


interface I { static void m() {} }
interface J { void m(); }
interface K extends I, J {  }
abstract class C { public void m() {} }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, J.m]


interface I {  }
interface J { default void m() {} }
interface K extends I, J {  }
abstract class C { public abstract void m(); }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K {  }

expected: E.gMs: [C.m]
  actual: E.gMs: [C.m, J.m]


interface I {  }
interface J { default void m() {} }
interface K extends I, J {  }
abstract class C {  }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, J.m]


interface I {  }
interface J { default void m() {} }
interface K extends I, J {  }
abstract class C { public abstract void m(); }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, J.m]


interface I {  }
interface J { default void m() {} }
interface K extends I, J {  }
abstract class C { public void m() {} }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, J.m]


interface I { static void m() {} }
interface J { default void m() {} }
interface K extends I, J {  }
abstract class C { public abstract void m(); }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K {  }

expected: E.gMs: [C.m]
  actual: E.gMs: [C.m, J.m]


interface I { static void m() {} }
interface J { default void m() {} }
interface K extends I, J {  }
abstract class C {  }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, J.m]


interface I { static void m() {} }
interface J { default void m() {} }
interface K extends I, J {  }
abstract class C { public abstract void m(); }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, J.m]


interface I { static void m() {} }
interface J { default void m() {} }
interface K extends I, J {  }
abstract class C { public void m() {} }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, J.m]


interface I { void m(); }
interface J { static void m() {} }
interface K extends I, J {  }
abstract class C { public abstract void m(); }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K {  }

expected: E.gMs: [C.m]
  actual: E.gMs: [C.m, I.m]

expected: D.gMs: [C.m]
  actual: D.gMs: [C.m, I.m]


interface I { void m(); }
interface J { static void m() {} }
interface K extends I, J {  }
abstract class C {  }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, I.m]


interface I { void m(); }
interface J { static void m() {} }
interface K extends I, J {  }
abstract class C { public abstract void m(); }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, I.m]


interface I { void m(); }
interface J { static void m() {} }
interface K extends I, J {  }
abstract class C { public void m() {} }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, I.m]


interface I { void m(); }
interface J { static void m() {} }
interface K extends I, J {  }
abstract class C { public abstract void m(); }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K { public abstract void m(); }

expected: D.gMs: [C.m]
  actual: D.gMs: [C.m, I.m]


interface I { void m(); }
interface J { static void m() {} }
interface K extends I, J {  }
abstract class C { public abstract void m(); }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K { public void m() {} }

expected: D.gMs: [C.m]
  actual: D.gMs: [C.m, I.m]


interface I { default void m() {} }
interface J { static void m() {} }
interface K extends I, J {  }
abstract class C { public abstract void m(); }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K {  }

expected: E.gMs: [C.m]
  actual: E.gMs: [C.m, I.m]

expected: D.gMs: [C.m]
  actual: D.gMs: [C.m, I.m]


interface I { default void m() {} }
interface J { static void m() {} }
interface K extends I, J {  }
abstract class C {  }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, I.m]


interface I { default void m() {} }
interface J { static void m() {} }
interface K extends I, J {  }
abstract class C { public abstract void m(); }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, I.m]


interface I { default void m() {} }
interface J { static void m() {} }
interface K extends I, J {  }
abstract class C { public void m() {} }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, I.m]


interface I { default void m() {} }
interface J { static void m() {} }
interface K extends I, J {  }
abstract class C { public abstract void m(); }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K { public abstract void m(); }

expected: D.gMs: [C.m]
  actual: D.gMs: [C.m, I.m]


interface I { default void m() {} }
interface J { static void m() {} }
interface K extends I, J {  }
abstract class C { public abstract void m(); }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K { public void m() {} }

expected: D.gMs: [C.m]
  actual: D.gMs: [C.m, I.m]


interface I {  }
interface J {  }
interface K extends I, J { void m(); }
abstract class C { public abstract void m(); }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K {  }

expected: E.gMs: [C.m]
  actual: E.gMs: [C.m, K.m]


interface I {  }
interface J {  }
interface K extends I, J { void m(); }
abstract class C {  }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, K.m]


interface I {  }
interface J {  }
interface K extends I, J { void m(); }
abstract class C { public abstract void m(); }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, K.m]


interface I {  }
interface J {  }
interface K extends I, J { void m(); }
abstract class C { public void m() {} }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, K.m]


interface I { void m(); }
interface J {  }
interface K extends I, J { void m(); }
abstract class C {  }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K {  }

expected: E.gMs: [K.m]
  actual: E.gMs: [I.m, K.m]

expected: E.gM: K.m
  actual: E.gM: I.m


interface I { void m(); }
interface J {  }
interface K extends I, J { void m(); }
abstract class C { public abstract void m(); }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K {  }

expected: E.gMs: [C.m]
  actual: E.gMs: [C.m, I.m, K.m]

expected: D.gMs: [C.m]
  actual: D.gMs: [C.m, I.m]


interface I { void m(); }
interface J {  }
interface K extends I, J { void m(); }
abstract class C {  }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, K.m]


interface I { void m(); }
interface J {  }
interface K extends I, J { void m(); }
abstract class C { public abstract void m(); }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, K.m]


interface I { void m(); }
interface J {  }
interface K extends I, J { void m(); }
abstract class C { public void m() {} }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, K.m]


interface I { void m(); }
interface J {  }
interface K extends I, J { void m(); }
abstract class C { public abstract void m(); }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K { public abstract void m(); }

expected: D.gMs: [C.m]
  actual: D.gMs: [C.m, I.m]


interface I { void m(); }
interface J {  }
interface K extends I, J { void m(); }
abstract class C { public abstract void m(); }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K { public void m() {} }

expected: D.gMs: [C.m]
  actual: D.gMs: [C.m, I.m]


interface I { default void m() {} }
interface J {  }
interface K extends I, J { void m(); }
abstract class C {  }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K {  }

expected: E.gMs: [K.m]
  actual: E.gMs: [I.m, K.m]

expected: E.gM: K.m
  actual: E.gM: I.m


interface I { default void m() {} }
interface J {  }
interface K extends I, J { void m(); }
abstract class C { public abstract void m(); }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K {  }

expected: E.gMs: [C.m]
  actual: E.gMs: [C.m, I.m, K.m]

expected: D.gMs: [C.m]
  actual: D.gMs: [C.m, I.m]


interface I { default void m() {} }
interface J {  }
interface K extends I, J { void m(); }
abstract class C {  }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, K.m]


interface I { default void m() {} }
interface J {  }
interface K extends I, J { void m(); }
abstract class C { public abstract void m(); }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, K.m]


interface I { default void m() {} }
interface J {  }
interface K extends I, J { void m(); }
abstract class C { public void m() {} }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, K.m]


interface I { default void m() {} }
interface J {  }
interface K extends I, J { void m(); }
abstract class C { public abstract void m(); }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K { public abstract void m(); }

expected: D.gMs: [C.m]
  actual: D.gMs: [C.m, I.m]


interface I { default void m() {} }
interface J {  }
interface K extends I, J { void m(); }
abstract class C { public abstract void m(); }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K { public void m() {} }

expected: D.gMs: [C.m]
  actual: D.gMs: [C.m, I.m]


interface I { static void m() {} }
interface J {  }
interface K extends I, J { void m(); }
abstract class C { public abstract void m(); }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K {  }

expected: E.gMs: [C.m]
  actual: E.gMs: [C.m, K.m]


interface I { static void m() {} }
interface J {  }
interface K extends I, J { void m(); }
abstract class C {  }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, K.m]


interface I { static void m() {} }
interface J {  }
interface K extends I, J { void m(); }
abstract class C { public abstract void m(); }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, K.m]


interface I { static void m() {} }
interface J {  }
interface K extends I, J { void m(); }
abstract class C { public void m() {} }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, K.m]


interface I {  }
interface J { void m(); }
interface K extends I, J { void m(); }
abstract class C {  }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K {  }

expected: E.gMs: [K.m]
  actual: E.gMs: [J.m, K.m]

expected: E.gM: K.m
  actual: E.gM: J.m


interface I {  }
interface J { void m(); }
interface K extends I, J { void m(); }
abstract class C { public abstract void m(); }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K {  }

expected: E.gMs: [C.m]
  actual: E.gMs: [C.m, J.m, K.m]


interface I {  }
interface J { void m(); }
interface K extends I, J { void m(); }
abstract class C {  }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, J.m, K.m]


interface I {  }
interface J { void m(); }
interface K extends I, J { void m(); }
abstract class C { public abstract void m(); }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, J.m, K.m]


interface I {  }
interface J { void m(); }
interface K extends I, J { void m(); }
abstract class C { public void m() {} }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, J.m, K.m]


interface I { void m(); }
interface J { void m(); }
interface K extends I, J { void m(); }
abstract class C {  }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K {  }

expected: E.gMs: [K.m]
  actual: E.gMs: [I.m, J.m, K.m]

expected: E.gM: K.m
  actual: E.gM: I.m


interface I { void m(); }
interface J { void m(); }
interface K extends I, J { void m(); }
abstract class C { public abstract void m(); }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K {  }

expected: E.gMs: [C.m]
  actual: E.gMs: [C.m, I.m, J.m, K.m]

expected: D.gMs: [C.m]
  actual: D.gMs: [C.m, I.m]


interface I { void m(); }
interface J { void m(); }
interface K extends I, J { void m(); }
abstract class C {  }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, J.m, K.m]


interface I { void m(); }
interface J { void m(); }
interface K extends I, J { void m(); }
abstract class C { public abstract void m(); }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, J.m, K.m]


interface I { void m(); }
interface J { void m(); }
interface K extends I, J { void m(); }
abstract class C { public void m() {} }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, J.m, K.m]


interface I { void m(); }
interface J { void m(); }
interface K extends I, J { void m(); }
abstract class C { public abstract void m(); }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K { public abstract void m(); }

expected: D.gMs: [C.m]
  actual: D.gMs: [C.m, I.m]


interface I { void m(); }
interface J { void m(); }
interface K extends I, J { void m(); }
abstract class C { public abstract void m(); }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K { public void m() {} }

expected: D.gMs: [C.m]
  actual: D.gMs: [C.m, I.m]


interface I { default void m() {} }
interface J { void m(); }
interface K extends I, J { void m(); }
abstract class C {  }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K {  }

expected: E.gMs: [K.m]
  actual: E.gMs: [I.m, J.m, K.m]

expected: E.gM: K.m
  actual: E.gM: I.m


interface I { default void m() {} }
interface J { void m(); }
interface K extends I, J { void m(); }
abstract class C { public abstract void m(); }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K {  }

expected: E.gMs: [C.m]
  actual: E.gMs: [C.m, I.m, J.m, K.m]

expected: D.gMs: [C.m]
  actual: D.gMs: [C.m, I.m]


interface I { default void m() {} }
interface J { void m(); }
interface K extends I, J { void m(); }
abstract class C {  }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, J.m, K.m]


interface I { default void m() {} }
interface J { void m(); }
interface K extends I, J { void m(); }
abstract class C { public abstract void m(); }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, J.m, K.m]


interface I { default void m() {} }
interface J { void m(); }
interface K extends I, J { void m(); }
abstract class C { public void m() {} }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, J.m, K.m]


interface I { default void m() {} }
interface J { void m(); }
interface K extends I, J { void m(); }
abstract class C { public abstract void m(); }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K { public abstract void m(); }

expected: D.gMs: [C.m]
  actual: D.gMs: [C.m, I.m]


interface I { default void m() {} }
interface J { void m(); }
interface K extends I, J { void m(); }
abstract class C { public abstract void m(); }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K { public void m() {} }

expected: D.gMs: [C.m]
  actual: D.gMs: [C.m, I.m]


interface I { static void m() {} }
interface J { void m(); }
interface K extends I, J { void m(); }
abstract class C {  }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K {  }

expected: E.gMs: [K.m]
  actual: E.gMs: [J.m, K.m]

expected: E.gM: K.m
  actual: E.gM: J.m


interface I { static void m() {} }
interface J { void m(); }
interface K extends I, J { void m(); }
abstract class C { public abstract void m(); }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K {  }

expected: E.gMs: [C.m]
  actual: E.gMs: [C.m, J.m, K.m]


interface I { static void m() {} }
interface J { void m(); }
interface K extends I, J { void m(); }
abstract class C {  }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, J.m, K.m]


interface I { static void m() {} }
interface J { void m(); }
interface K extends I, J { void m(); }
abstract class C { public abstract void m(); }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, J.m, K.m]


interface I { static void m() {} }
interface J { void m(); }
interface K extends I, J { void m(); }
abstract class C { public void m() {} }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, J.m, K.m]


interface I {  }
interface J { default void m() {} }
interface K extends I, J { void m(); }
abstract class C {  }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K {  }

expected: E.gMs: [K.m]
  actual: E.gMs: [J.m, K.m]

expected: E.gM: K.m
  actual: E.gM: J.m


interface I {  }
interface J { default void m() {} }
interface K extends I, J { void m(); }
abstract class C { public abstract void m(); }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K {  }

expected: E.gMs: [C.m]
  actual: E.gMs: [C.m, J.m, K.m]


interface I {  }
interface J { default void m() {} }
interface K extends I, J { void m(); }
abstract class C {  }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, J.m, K.m]


interface I {  }
interface J { default void m() {} }
interface K extends I, J { void m(); }
abstract class C { public abstract void m(); }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, J.m, K.m]


interface I {  }
interface J { default void m() {} }
interface K extends I, J { void m(); }
abstract class C { public void m() {} }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, J.m, K.m]


interface I { void m(); }
interface J { default void m() {} }
interface K extends I, J { void m(); }
abstract class C {  }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K {  }

expected: E.gMs: [K.m]
  actual: E.gMs: [I.m, J.m, K.m]

expected: E.gM: K.m
  actual: E.gM: I.m


interface I { void m(); }
interface J { default void m() {} }
interface K extends I, J { void m(); }
abstract class C { public abstract void m(); }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K {  }

expected: E.gMs: [C.m]
  actual: E.gMs: [C.m, I.m, J.m, K.m]

expected: D.gMs: [C.m]
  actual: D.gMs: [C.m, I.m]


interface I { void m(); }
interface J { default void m() {} }
interface K extends I, J { void m(); }
abstract class C {  }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, J.m, K.m]


interface I { void m(); }
interface J { default void m() {} }
interface K extends I, J { void m(); }
abstract class C { public abstract void m(); }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, J.m, K.m]


interface I { void m(); }
interface J { default void m() {} }
interface K extends I, J { void m(); }
abstract class C { public void m() {} }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, J.m, K.m]


interface I { void m(); }
interface J { default void m() {} }
interface K extends I, J { void m(); }
abstract class C { public abstract void m(); }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K { public abstract void m(); }

expected: D.gMs: [C.m]
  actual: D.gMs: [C.m, I.m]


interface I { void m(); }
interface J { default void m() {} }
interface K extends I, J { void m(); }
abstract class C { public abstract void m(); }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K { public void m() {} }

expected: D.gMs: [C.m]
  actual: D.gMs: [C.m, I.m]


interface I { default void m() {} }
interface J { default void m() {} }
interface K extends I, J { void m(); }
abstract class C {  }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K {  }

expected: E.gMs: [K.m]
  actual: E.gMs: [I.m, J.m, K.m]

expected: E.gM: K.m
  actual: E.gM: I.m


interface I { default void m() {} }
interface J { default void m() {} }
interface K extends I, J { void m(); }
abstract class C { public abstract void m(); }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K {  }

expected: E.gMs: [C.m]
  actual: E.gMs: [C.m, I.m, J.m, K.m]

expected: D.gMs: [C.m]
  actual: D.gMs: [C.m, I.m]


interface I { default void m() {} }
interface J { default void m() {} }
interface K extends I, J { void m(); }
abstract class C {  }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, J.m, K.m]


interface I { default void m() {} }
interface J { default void m() {} }
interface K extends I, J { void m(); }
abstract class C { public abstract void m(); }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, J.m, K.m]


interface I { default void m() {} }
interface J { default void m() {} }
interface K extends I, J { void m(); }
abstract class C { public void m() {} }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, J.m, K.m]


interface I { default void m() {} }
interface J { default void m() {} }
interface K extends I, J { void m(); }
abstract class C { public abstract void m(); }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K { public abstract void m(); }

expected: D.gMs: [C.m]
  actual: D.gMs: [C.m, I.m]


interface I { default void m() {} }
interface J { default void m() {} }
interface K extends I, J { void m(); }
abstract class C { public abstract void m(); }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K { public void m() {} }

expected: D.gMs: [C.m]
  actual: D.gMs: [C.m, I.m]


interface I { static void m() {} }
interface J { default void m() {} }
interface K extends I, J { void m(); }
abstract class C {  }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K {  }

expected: E.gMs: [K.m]
  actual: E.gMs: [J.m, K.m]

expected: E.gM: K.m
  actual: E.gM: J.m


interface I { static void m() {} }
interface J { default void m() {} }
interface K extends I, J { void m(); }
abstract class C { public abstract void m(); }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K {  }

expected: E.gMs: [C.m]
  actual: E.gMs: [C.m, J.m, K.m]


interface I { static void m() {} }
interface J { default void m() {} }
interface K extends I, J { void m(); }
abstract class C {  }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, J.m, K.m]


interface I { static void m() {} }
interface J { default void m() {} }
interface K extends I, J { void m(); }
abstract class C { public abstract void m(); }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, J.m, K.m]


interface I { static void m() {} }
interface J { default void m() {} }
interface K extends I, J { void m(); }
abstract class C { public void m() {} }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, J.m, K.m]


interface I {  }
interface J { static void m() {} }
interface K extends I, J { void m(); }
abstract class C { public abstract void m(); }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K {  }

expected: E.gMs: [C.m]
  actual: E.gMs: [C.m, K.m]


interface I {  }
interface J { static void m() {} }
interface K extends I, J { void m(); }
abstract class C {  }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, K.m]


interface I {  }
interface J { static void m() {} }
interface K extends I, J { void m(); }
abstract class C { public abstract void m(); }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, K.m]


interface I {  }
interface J { static void m() {} }
interface K extends I, J { void m(); }
abstract class C { public void m() {} }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, K.m]


interface I { void m(); }
interface J { static void m() {} }
interface K extends I, J { void m(); }
abstract class C {  }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K {  }

expected: E.gMs: [K.m]
  actual: E.gMs: [I.m, K.m]

expected: E.gM: K.m
  actual: E.gM: I.m


interface I { void m(); }
interface J { static void m() {} }
interface K extends I, J { void m(); }
abstract class C { public abstract void m(); }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K {  }

expected: E.gMs: [C.m]
  actual: E.gMs: [C.m, I.m, K.m]

expected: D.gMs: [C.m]
  actual: D.gMs: [C.m, I.m]


interface I { void m(); }
interface J { static void m() {} }
interface K extends I, J { void m(); }
abstract class C {  }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, K.m]


interface I { void m(); }
interface J { static void m() {} }
interface K extends I, J { void m(); }
abstract class C { public abstract void m(); }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, K.m]


interface I { void m(); }
interface J { static void m() {} }
interface K extends I, J { void m(); }
abstract class C { public void m() {} }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, K.m]


interface I { void m(); }
interface J { static void m() {} }
interface K extends I, J { void m(); }
abstract class C { public abstract void m(); }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K { public abstract void m(); }

expected: D.gMs: [C.m]
  actual: D.gMs: [C.m, I.m]


interface I { void m(); }
interface J { static void m() {} }
interface K extends I, J { void m(); }
abstract class C { public abstract void m(); }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K { public void m() {} }

expected: D.gMs: [C.m]
  actual: D.gMs: [C.m, I.m]


interface I { default void m() {} }
interface J { static void m() {} }
interface K extends I, J { void m(); }
abstract class C {  }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K {  }

expected: E.gMs: [K.m]
  actual: E.gMs: [I.m, K.m]

expected: E.gM: K.m
  actual: E.gM: I.m


interface I { default void m() {} }
interface J { static void m() {} }
interface K extends I, J { void m(); }
abstract class C { public abstract void m(); }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K {  }

expected: E.gMs: [C.m]
  actual: E.gMs: [C.m, I.m, K.m]

expected: D.gMs: [C.m]
  actual: D.gMs: [C.m, I.m]


interface I { default void m() {} }
interface J { static void m() {} }
interface K extends I, J { void m(); }
abstract class C {  }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, K.m]


interface I { default void m() {} }
interface J { static void m() {} }
interface K extends I, J { void m(); }
abstract class C { public abstract void m(); }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, K.m]


interface I { default void m() {} }
interface J { static void m() {} }
interface K extends I, J { void m(); }
abstract class C { public void m() {} }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, K.m]


interface I { default void m() {} }
interface J { static void m() {} }
interface K extends I, J { void m(); }
abstract class C { public abstract void m(); }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K { public abstract void m(); }

expected: D.gMs: [C.m]
  actual: D.gMs: [C.m, I.m]


interface I { default void m() {} }
interface J { static void m() {} }
interface K extends I, J { void m(); }
abstract class C { public abstract void m(); }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K { public void m() {} }

expected: D.gMs: [C.m]
  actual: D.gMs: [C.m, I.m]


interface I { static void m() {} }
interface J { static void m() {} }
interface K extends I, J { void m(); }
abstract class C { public abstract void m(); }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K {  }

expected: E.gMs: [C.m]
  actual: E.gMs: [C.m, K.m]


interface I { static void m() {} }
interface J { static void m() {} }
interface K extends I, J { void m(); }
abstract class C {  }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, K.m]


interface I { static void m() {} }
interface J { static void m() {} }
interface K extends I, J { void m(); }
abstract class C { public abstract void m(); }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, K.m]


interface I { static void m() {} }
interface J { static void m() {} }
interface K extends I, J { void m(); }
abstract class C { public void m() {} }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, K.m]


interface I {  }
interface J {  }
interface K extends I, J { default void m() {} }
abstract class C { public abstract void m(); }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K {  }

expected: E.gMs: [C.m]
  actual: E.gMs: [C.m, K.m]


interface I {  }
interface J {  }
interface K extends I, J { default void m() {} }
abstract class C {  }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, K.m]


interface I {  }
interface J {  }
interface K extends I, J { default void m() {} }
abstract class C { public abstract void m(); }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, K.m]


interface I {  }
interface J {  }
interface K extends I, J { default void m() {} }
abstract class C { public void m() {} }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, K.m]


interface I { void m(); }
interface J {  }
interface K extends I, J { default void m() {} }
abstract class C {  }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K {  }

expected: E.gM: K.m
  actual: E.gM: I.m


interface I { void m(); }
interface J {  }
interface K extends I, J { default void m() {} }
abstract class C { public abstract void m(); }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K {  }

expected: E.gMs: [C.m]
  actual: E.gMs: [C.m, K.m]

expected: D.gMs: [C.m]
  actual: D.gMs: [C.m, I.m]


interface I { void m(); }
interface J {  }
interface K extends I, J { default void m() {} }
abstract class C {  }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, K.m]


interface I { void m(); }
interface J {  }
interface K extends I, J { default void m() {} }
abstract class C { public abstract void m(); }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, K.m]


interface I { void m(); }
interface J {  }
interface K extends I, J { default void m() {} }
abstract class C { public void m() {} }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, K.m]


interface I { void m(); }
interface J {  }
interface K extends I, J { default void m() {} }
abstract class C { public abstract void m(); }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K { public abstract void m(); }

expected: D.gMs: [C.m]
  actual: D.gMs: [C.m, I.m]


interface I { void m(); }
interface J {  }
interface K extends I, J { default void m() {} }
abstract class C { public abstract void m(); }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K { public void m() {} }

expected: D.gMs: [C.m]
  actual: D.gMs: [C.m, I.m]


interface I { default void m() {} }
interface J {  }
interface K extends I, J { default void m() {} }
abstract class C {  }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K {  }

expected: E.gM: K.m
  actual: E.gM: I.m


interface I { default void m() {} }
interface J {  }
interface K extends I, J { default void m() {} }
abstract class C { public abstract void m(); }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K {  }

expected: E.gMs: [C.m]
  actual: E.gMs: [C.m, K.m]

expected: D.gMs: [C.m]
  actual: D.gMs: [C.m, I.m]


interface I { default void m() {} }
interface J {  }
interface K extends I, J { default void m() {} }
abstract class C {  }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, K.m]


interface I { default void m() {} }
interface J {  }
interface K extends I, J { default void m() {} }
abstract class C { public abstract void m(); }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, K.m]


interface I { default void m() {} }
interface J {  }
interface K extends I, J { default void m() {} }
abstract class C { public void m() {} }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, K.m]


interface I { default void m() {} }
interface J {  }
interface K extends I, J { default void m() {} }
abstract class C { public abstract void m(); }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K { public abstract void m(); }

expected: D.gMs: [C.m]
  actual: D.gMs: [C.m, I.m]


interface I { default void m() {} }
interface J {  }
interface K extends I, J { default void m() {} }
abstract class C { public abstract void m(); }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K { public void m() {} }

expected: D.gMs: [C.m]
  actual: D.gMs: [C.m, I.m]


interface I { static void m() {} }
interface J {  }
interface K extends I, J { default void m() {} }
abstract class C { public abstract void m(); }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K {  }

expected: E.gMs: [C.m]
  actual: E.gMs: [C.m, K.m]


interface I { static void m() {} }
interface J {  }
interface K extends I, J { default void m() {} }
abstract class C {  }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, K.m]


interface I { static void m() {} }
interface J {  }
interface K extends I, J { default void m() {} }
abstract class C { public abstract void m(); }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, K.m]


interface I { static void m() {} }
interface J {  }
interface K extends I, J { default void m() {} }
abstract class C { public void m() {} }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, K.m]


interface I {  }
interface J { void m(); }
interface K extends I, J { default void m() {} }
abstract class C { public abstract void m(); }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K {  }

expected: E.gMs: [C.m]
  actual: E.gMs: [C.m, K.m]


interface I {  }
interface J { void m(); }
interface K extends I, J { default void m() {} }
abstract class C {  }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, K.m]


interface I {  }
interface J { void m(); }
interface K extends I, J { default void m() {} }
abstract class C { public abstract void m(); }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, K.m]


interface I {  }
interface J { void m(); }
interface K extends I, J { default void m() {} }
abstract class C { public void m() {} }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, K.m]


interface I { void m(); }
interface J { void m(); }
interface K extends I, J { default void m() {} }
abstract class C {  }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K {  }

expected: E.gM: K.m
  actual: E.gM: I.m


interface I { void m(); }
interface J { void m(); }
interface K extends I, J { default void m() {} }
abstract class C { public abstract void m(); }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K {  }

expected: E.gMs: [C.m]
  actual: E.gMs: [C.m, K.m]

expected: D.gMs: [C.m]
  actual: D.gMs: [C.m, I.m]


interface I { void m(); }
interface J { void m(); }
interface K extends I, J { default void m() {} }
abstract class C {  }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, K.m]


interface I { void m(); }
interface J { void m(); }
interface K extends I, J { default void m() {} }
abstract class C { public abstract void m(); }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, K.m]


interface I { void m(); }
interface J { void m(); }
interface K extends I, J { default void m() {} }
abstract class C { public void m() {} }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, K.m]


interface I { void m(); }
interface J { void m(); }
interface K extends I, J { default void m() {} }
abstract class C { public abstract void m(); }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K { public abstract void m(); }

expected: D.gMs: [C.m]
  actual: D.gMs: [C.m, I.m]


interface I { void m(); }
interface J { void m(); }
interface K extends I, J { default void m() {} }
abstract class C { public abstract void m(); }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K { public void m() {} }

expected: D.gMs: [C.m]
  actual: D.gMs: [C.m, I.m]


interface I { default void m() {} }
interface J { void m(); }
interface K extends I, J { default void m() {} }
abstract class C {  }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K {  }

expected: E.gM: K.m
  actual: E.gM: I.m


interface I { default void m() {} }
interface J { void m(); }
interface K extends I, J { default void m() {} }
abstract class C { public abstract void m(); }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K {  }

expected: E.gMs: [C.m]
  actual: E.gMs: [C.m, K.m]

expected: D.gMs: [C.m]
  actual: D.gMs: [C.m, I.m]


interface I { default void m() {} }
interface J { void m(); }
interface K extends I, J { default void m() {} }
abstract class C {  }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, K.m]


interface I { default void m() {} }
interface J { void m(); }
interface K extends I, J { default void m() {} }
abstract class C { public abstract void m(); }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, K.m]


interface I { default void m() {} }
interface J { void m(); }
interface K extends I, J { default void m() {} }
abstract class C { public void m() {} }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, K.m]


interface I { default void m() {} }
interface J { void m(); }
interface K extends I, J { default void m() {} }
abstract class C { public abstract void m(); }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K { public abstract void m(); }

expected: D.gMs: [C.m]
  actual: D.gMs: [C.m, I.m]


interface I { default void m() {} }
interface J { void m(); }
interface K extends I, J { default void m() {} }
abstract class C { public abstract void m(); }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K { public void m() {} }

expected: D.gMs: [C.m]
  actual: D.gMs: [C.m, I.m]


interface I { static void m() {} }
interface J { void m(); }
interface K extends I, J { default void m() {} }
abstract class C { public abstract void m(); }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K {  }

expected: E.gMs: [C.m]
  actual: E.gMs: [C.m, K.m]


interface I { static void m() {} }
interface J { void m(); }
interface K extends I, J { default void m() {} }
abstract class C {  }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, K.m]


interface I { static void m() {} }
interface J { void m(); }
interface K extends I, J { default void m() {} }
abstract class C { public abstract void m(); }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, K.m]


interface I { static void m() {} }
interface J { void m(); }
interface K extends I, J { default void m() {} }
abstract class C { public void m() {} }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, K.m]


interface I {  }
interface J { default void m() {} }
interface K extends I, J { default void m() {} }
abstract class C { public abstract void m(); }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K {  }

expected: E.gMs: [C.m]
  actual: E.gMs: [C.m, K.m]


interface I {  }
interface J { default void m() {} }
interface K extends I, J { default void m() {} }
abstract class C {  }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, K.m]


interface I {  }
interface J { default void m() {} }
interface K extends I, J { default void m() {} }
abstract class C { public abstract void m(); }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, K.m]


interface I {  }
interface J { default void m() {} }
interface K extends I, J { default void m() {} }
abstract class C { public void m() {} }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, K.m]


interface I { void m(); }
interface J { default void m() {} }
interface K extends I, J { default void m() {} }
abstract class C {  }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K {  }

expected: E.gM: K.m
  actual: E.gM: I.m


interface I { void m(); }
interface J { default void m() {} }
interface K extends I, J { default void m() {} }
abstract class C { public abstract void m(); }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K {  }

expected: E.gMs: [C.m]
  actual: E.gMs: [C.m, K.m]

expected: D.gMs: [C.m]
  actual: D.gMs: [C.m, I.m]


interface I { void m(); }
interface J { default void m() {} }
interface K extends I, J { default void m() {} }
abstract class C {  }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, K.m]


interface I { void m(); }
interface J { default void m() {} }
interface K extends I, J { default void m() {} }
abstract class C { public abstract void m(); }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, K.m]


interface I { void m(); }
interface J { default void m() {} }
interface K extends I, J { default void m() {} }
abstract class C { public void m() {} }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, K.m]


interface I { void m(); }
interface J { default void m() {} }
interface K extends I, J { default void m() {} }
abstract class C { public abstract void m(); }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K { public abstract void m(); }

expected: D.gMs: [C.m]
  actual: D.gMs: [C.m, I.m]


interface I { void m(); }
interface J { default void m() {} }
interface K extends I, J { default void m() {} }
abstract class C { public abstract void m(); }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K { public void m() {} }

expected: D.gMs: [C.m]
  actual: D.gMs: [C.m, I.m]


interface I { default void m() {} }
interface J { default void m() {} }
interface K extends I, J { default void m() {} }
abstract class C {  }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K {  }

expected: E.gM: K.m
  actual: E.gM: I.m


interface I { default void m() {} }
interface J { default void m() {} }
interface K extends I, J { default void m() {} }
abstract class C { public abstract void m(); }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K {  }

expected: E.gMs: [C.m]
  actual: E.gMs: [C.m, K.m]

expected: D.gMs: [C.m]
  actual: D.gMs: [C.m, I.m]


interface I { default void m() {} }
interface J { default void m() {} }
interface K extends I, J { default void m() {} }
abstract class C {  }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, K.m]


interface I { default void m() {} }
interface J { default void m() {} }
interface K extends I, J { default void m() {} }
abstract class C { public abstract void m(); }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, K.m]


interface I { default void m() {} }
interface J { default void m() {} }
interface K extends I, J { default void m() {} }
abstract class C { public void m() {} }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, K.m]


interface I { default void m() {} }
interface J { default void m() {} }
interface K extends I, J { default void m() {} }
abstract class C { public abstract void m(); }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K { public abstract void m(); }

expected: D.gMs: [C.m]
  actual: D.gMs: [C.m, I.m]


interface I { default void m() {} }
interface J { default void m() {} }
interface K extends I, J { default void m() {} }
abstract class C { public abstract void m(); }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K { public void m() {} }

expected: D.gMs: [C.m]
  actual: D.gMs: [C.m, I.m]


interface I { static void m() {} }
interface J { default void m() {} }
interface K extends I, J { default void m() {} }
abstract class C { public abstract void m(); }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K {  }

expected: E.gMs: [C.m]
  actual: E.gMs: [C.m, K.m]


interface I { static void m() {} }
interface J { default void m() {} }
interface K extends I, J { default void m() {} }
abstract class C {  }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, K.m]


interface I { static void m() {} }
interface J { default void m() {} }
interface K extends I, J { default void m() {} }
abstract class C { public abstract void m(); }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, K.m]


interface I { static void m() {} }
interface J { default void m() {} }
interface K extends I, J { default void m() {} }
abstract class C { public void m() {} }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, K.m]


interface I {  }
interface J { static void m() {} }
interface K extends I, J { default void m() {} }
abstract class C { public abstract void m(); }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K {  }

expected: E.gMs: [C.m]
  actual: E.gMs: [C.m, K.m]


interface I {  }
interface J { static void m() {} }
interface K extends I, J { default void m() {} }
abstract class C {  }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, K.m]


interface I {  }
interface J { static void m() {} }
interface K extends I, J { default void m() {} }
abstract class C { public abstract void m(); }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, K.m]


interface I {  }
interface J { static void m() {} }
interface K extends I, J { default void m() {} }
abstract class C { public void m() {} }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, K.m]


interface I { void m(); }
interface J { static void m() {} }
interface K extends I, J { default void m() {} }
abstract class C {  }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K {  }

expected: E.gM: K.m
  actual: E.gM: I.m


interface I { void m(); }
interface J { static void m() {} }
interface K extends I, J { default void m() {} }
abstract class C { public abstract void m(); }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K {  }

expected: E.gMs: [C.m]
  actual: E.gMs: [C.m, K.m]

expected: D.gMs: [C.m]
  actual: D.gMs: [C.m, I.m]


interface I { void m(); }
interface J { static void m() {} }
interface K extends I, J { default void m() {} }
abstract class C {  }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, K.m]


interface I { void m(); }
interface J { static void m() {} }
interface K extends I, J { default void m() {} }
abstract class C { public abstract void m(); }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, K.m]


interface I { void m(); }
interface J { static void m() {} }
interface K extends I, J { default void m() {} }
abstract class C { public void m() {} }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, K.m]


interface I { void m(); }
interface J { static void m() {} }
interface K extends I, J { default void m() {} }
abstract class C { public abstract void m(); }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K { public abstract void m(); }

expected: D.gMs: [C.m]
  actual: D.gMs: [C.m, I.m]


interface I { void m(); }
interface J { static void m() {} }
interface K extends I, J { default void m() {} }
abstract class C { public abstract void m(); }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K { public void m() {} }

expected: D.gMs: [C.m]
  actual: D.gMs: [C.m, I.m]


interface I { default void m() {} }
interface J { static void m() {} }
interface K extends I, J { default void m() {} }
abstract class C {  }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K {  }

expected: E.gM: K.m
  actual: E.gM: I.m


interface I { default void m() {} }
interface J { static void m() {} }
interface K extends I, J { default void m() {} }
abstract class C { public abstract void m(); }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K {  }

expected: E.gMs: [C.m]
  actual: E.gMs: [C.m, K.m]

expected: D.gMs: [C.m]
  actual: D.gMs: [C.m, I.m]


interface I { default void m() {} }
interface J { static void m() {} }
interface K extends I, J { default void m() {} }
abstract class C {  }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, K.m]


interface I { default void m() {} }
interface J { static void m() {} }
interface K extends I, J { default void m() {} }
abstract class C { public abstract void m(); }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, K.m]


interface I { default void m() {} }
interface J { static void m() {} }
interface K extends I, J { default void m() {} }
abstract class C { public void m() {} }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, K.m]


interface I { default void m() {} }
interface J { static void m() {} }
interface K extends I, J { default void m() {} }
abstract class C { public abstract void m(); }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K { public abstract void m(); }

expected: D.gMs: [C.m]
  actual: D.gMs: [C.m, I.m]


interface I { default void m() {} }
interface J { static void m() {} }
interface K extends I, J { default void m() {} }
abstract class C { public abstract void m(); }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K { public void m() {} }

expected: D.gMs: [C.m]
  actual: D.gMs: [C.m, I.m]


interface I { static void m() {} }
interface J { static void m() {} }
interface K extends I, J { default void m() {} }
abstract class C { public abstract void m(); }
abstract class D extends C implements I {  }
abstract class E extends D implements J, K {  }

expected: E.gMs: [C.m]
  actual: E.gMs: [C.m, K.m]


interface I { static void m() {} }
interface J { static void m() {} }
interface K extends I, J { default void m() {} }
abstract class C {  }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, K.m]


interface I { static void m() {} }
interface J { static void m() {} }
interface K extends I, J { default void m() {} }
abstract class C { public abstract void m(); }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, K.m]


interface I { static void m() {} }
interface J { static void m() {} }
interface K extends I, J { default void m() {} }
abstract class C { public void m() {} }
abstract class D extends C implements I { public abstract void m(); }
abstract class E extends D implements J, K {  }

expected: E.gMs: [D.m]
  actual: E.gMs: [D.m, K.m]


----------System.err:(13/856)----------
java.lang.RuntimeException: There were 226 differences.
	at PublicMethodsTest.main(PublicMethodsTest.java:78)
	at jdk.internal.reflect.NativeMethodAccessorImpl.invoke0(java.base@9-ea/Native Method)
	at jdk.internal.reflect.NativeMethodAccessorImpl.invoke(java.base@9-ea/NativeMethodAccessorImpl.java:62)
	at jdk.internal.reflect.DelegatingMethodAccessorImpl.invoke(java.base@9-ea/DelegatingMethodAccessorImpl.java:43)
	at java.lang.reflect.Method.invoke(java.base@9-ea/Method.java:535)
	at com.sun.javatest.regtest.agent.MainWrapper$MainThread.run(MainWrapper.java:110)
	at java.lang.Thread.run(java.base@9-ea/Thread.java:843)

JavaTest Message: Test threw exception: java.lang.RuntimeException: There were 226 differences.
JavaTest Message: shutting down test

STATUS:Failed.`main' threw exception: java.lang.RuntimeException: There were 226 differences.
----------rerun:(18/1195)*----------
DISPLAY=:0 \\
HOME=/home/peter \\
LANG=en_US.UTF-8 \\
PATH=/bin:/usr/bin \\
CLASSPATH=/home/peter/work/hg/jdk9-dev/JTwork/classes/java/lang/reflect/PublicMethods:/home/peter/work/hg/jdk9-dev/jdk/test/java/lang/reflect/PublicMethods:/home/peter/work/hg/jtreg/build/images/jtreg/lib/javatest.jar:/home/peter/work/hg/jtreg/build/images/jtreg/lib/jtreg.jar \\
    /home/peter/Apps64/jdk9/bin/java \\
        -Dtest.src=/home/peter/work/hg/jdk9-dev/jdk/test/java/lang/reflect/PublicMethods \\
        -Dtest.src.path=/home/peter/work/hg/jdk9-dev/jdk/test/java/lang/reflect/PublicMethods \\
        -Dtest.classes=/home/peter/work/hg/jdk9-dev/JTwork/classes/java/lang/reflect/PublicMethods \\
        -Dtest.class.path=/home/peter/work/hg/jdk9-dev/JTwork/classes/java/lang/reflect/PublicMethods \\
        -Dtest.vm.opts= \\
        -Dtest.tool.vm.opts= \\
        -Dtest.compiler.opts= \\
        -Dtest.java.opts= \\
        -Dtest.jdk=/home/peter/Apps64/jdk9 \\
        -Dcompile.jdk=/home/peter/Apps64/jdk9 \\
        -Dtest.timeout.factor=1.0 \\
        com.sun.javatest.regtest.agent.MainWrapper /home/peter/work/hg/jdk9-dev/JTwork/java/lang/reflect/PublicMethods/PublicMethodsTest.d/main.0.jta
result: Failed. Execution failed: `main' threw exception: java.lang.RuntimeException: There were 226 differences.


test result: Failed. Execution failed: `main' threw exception: java.lang.RuntimeException: There were 226 differences.