315 lines
8.4 KiB
Java
315 lines
8.4 KiB
Java
/*
|
|
* Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
|
|
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
*
|
|
* This code is free software; you can redistribute it and/or modify it
|
|
* under the terms of the GNU General Public License version 2 only, as
|
|
* published by the Free Software Foundation.
|
|
*
|
|
* This code is distributed in the hope that it will be useful, but WITHOUT
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
* version 2 for more details (a copy is included in the LICENSE file that
|
|
* accompanied this code).
|
|
*
|
|
* You should have received a copy of the GNU General Public License version
|
|
* 2 along with this work; if not, write to the Free Software Foundation,
|
|
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*
|
|
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
|
* or visit www.oracle.com if you need additional information or have any
|
|
* questions.
|
|
*/
|
|
|
|
package compiler.arraycopy;
|
|
|
|
import java.lang.reflect.Field;
|
|
import java.lang.reflect.Method;
|
|
import java.lang.reflect.Modifier;
|
|
import java.util.HashMap;
|
|
|
|
abstract class TestInstanceCloneUtils {
|
|
static class Base implements Cloneable {
|
|
void initialize(Class c, int i) {
|
|
for (Field f : c.getDeclaredFields()) {
|
|
setVal(f, i);
|
|
i++;
|
|
}
|
|
if (c != Base.class) {
|
|
initialize(c.getSuperclass(), i);
|
|
}
|
|
}
|
|
|
|
Base(boolean initialize) {
|
|
if (initialize) {
|
|
initialize(getClass(), 0);
|
|
}
|
|
}
|
|
|
|
void setVal(Field f, int i) {
|
|
try {
|
|
if (f.getType() == int.class) {
|
|
f.setInt(this, i);
|
|
return;
|
|
} else if (f.getType() == short.class) {
|
|
f.setShort(this, (short)i);
|
|
return;
|
|
} else if (f.getType() == byte.class) {
|
|
f.setByte(this, (byte)i);
|
|
return;
|
|
} else if (f.getType() == long.class) {
|
|
f.setLong(this, i);
|
|
return;
|
|
}
|
|
} catch(IllegalAccessException iae) {
|
|
throw new RuntimeException("Getting fields failed");
|
|
}
|
|
throw new RuntimeException("unexpected field type");
|
|
}
|
|
|
|
int getVal(Field f) {
|
|
try {
|
|
if (f.getType() == int.class) {
|
|
return f.getInt(this);
|
|
} else if (f.getType() == short.class) {
|
|
return (int)f.getShort(this);
|
|
} else if (f.getType() == byte.class) {
|
|
return (int)f.getByte(this);
|
|
} else if (f.getType() == long.class) {
|
|
return (int)f.getLong(this);
|
|
}
|
|
} catch(IllegalAccessException iae) {
|
|
throw new RuntimeException("Setting fields failed");
|
|
}
|
|
throw new RuntimeException("unexpected field type");
|
|
}
|
|
|
|
boolean fields_equal(Class c, Base o) {
|
|
for (Field f : c.getDeclaredFields()) {
|
|
if (getVal(f) != o.getVal(f)) {
|
|
return false;
|
|
}
|
|
}
|
|
if (c != Base.class) {
|
|
return fields_equal(c.getSuperclass(), o);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public boolean equals(Object obj) {
|
|
return fields_equal(getClass(), (Base)obj);
|
|
}
|
|
|
|
String print_fields(Class c, String s) {
|
|
for (Field f : c.getDeclaredFields()) {
|
|
if (s != "") {
|
|
s += "\n";
|
|
}
|
|
s = s + f + " = " + getVal(f);
|
|
}
|
|
if (c != Base.class) {
|
|
return print_fields(c.getSuperclass(), s);
|
|
}
|
|
return s;
|
|
}
|
|
|
|
public String toString() {
|
|
return print_fields(getClass(), "");
|
|
}
|
|
|
|
int fields_sum(Class c, int s) {
|
|
for (Field f : c.getDeclaredFields()) {
|
|
s += getVal(f);
|
|
}
|
|
if (c != Base.class) {
|
|
return fields_sum(c.getSuperclass(), s);
|
|
}
|
|
return s;
|
|
}
|
|
|
|
public int sum() {
|
|
return fields_sum(getClass(), 0);
|
|
}
|
|
|
|
}
|
|
|
|
static class A extends Base {
|
|
int i1;
|
|
int i2;
|
|
int i3;
|
|
int i4;
|
|
int i5;
|
|
|
|
A(boolean initialize) {
|
|
super(initialize);
|
|
}
|
|
|
|
public Object clone() throws CloneNotSupportedException {
|
|
return super.clone();
|
|
}
|
|
}
|
|
|
|
static class B extends A {
|
|
int i6;
|
|
|
|
B(boolean initialize) {
|
|
super(initialize);
|
|
}
|
|
}
|
|
|
|
static final class D extends Base {
|
|
byte i1;
|
|
short i2;
|
|
long i3;
|
|
int i4;
|
|
int i5;
|
|
|
|
D(boolean initialize) {
|
|
super(initialize);
|
|
}
|
|
|
|
public Object clone() throws CloneNotSupportedException {
|
|
return super.clone();
|
|
}
|
|
}
|
|
|
|
static final class E extends Base {
|
|
int i1;
|
|
int i2;
|
|
int i3;
|
|
int i4;
|
|
int i5;
|
|
int i6;
|
|
int i7;
|
|
int i8;
|
|
int i9;
|
|
|
|
E(boolean initialize) {
|
|
super(initialize);
|
|
}
|
|
|
|
public Object clone() throws CloneNotSupportedException {
|
|
return super.clone();
|
|
}
|
|
}
|
|
|
|
static final class F extends Base {
|
|
F(boolean initialize) {
|
|
super(initialize);
|
|
}
|
|
|
|
public Object clone() throws CloneNotSupportedException {
|
|
return super.clone();
|
|
}
|
|
}
|
|
|
|
static class G extends Base {
|
|
int i1;
|
|
int i2;
|
|
int i3;
|
|
|
|
G(boolean initialize) {
|
|
super(initialize);
|
|
}
|
|
|
|
public Object myclone() throws CloneNotSupportedException {
|
|
return clone();
|
|
}
|
|
}
|
|
|
|
static class H extends G {
|
|
int i4;
|
|
int i5;
|
|
|
|
H(boolean initialize) {
|
|
super(initialize);
|
|
}
|
|
|
|
public Object clone() throws CloneNotSupportedException {
|
|
return super.clone();
|
|
}
|
|
}
|
|
|
|
static class J extends Base {
|
|
int i1;
|
|
int i2;
|
|
int i3;
|
|
|
|
J(boolean initialize) {
|
|
super(initialize);
|
|
}
|
|
|
|
public Object myclone() throws CloneNotSupportedException {
|
|
return clone();
|
|
}
|
|
}
|
|
|
|
static class K extends J {
|
|
int i4;
|
|
int i5;
|
|
|
|
K(boolean initialize) {
|
|
super(initialize);
|
|
}
|
|
|
|
}
|
|
|
|
static final A a = new A(true);
|
|
static final B b = new B(true);
|
|
static final D d = new D(true);
|
|
static final E e = new E(true);
|
|
static final F f = new F(true);
|
|
static final G g = new G(true);
|
|
static final H h = new H(true);
|
|
static final J j = new J(true);
|
|
static final K k = new K(true);
|
|
|
|
final HashMap<String,Method> tests = new HashMap<>();
|
|
{
|
|
for (Method m : this.getClass().getDeclaredMethods()) {
|
|
if (m.getName().matches("m[0-9]+")) {
|
|
assert(Modifier.isStatic(m.getModifiers())) : m;
|
|
tests.put(m.getName(), m);
|
|
}
|
|
}
|
|
}
|
|
|
|
boolean success = true;
|
|
|
|
void doTest(Base src, String name) throws Exception {
|
|
Method m = tests.get(name);
|
|
|
|
for (int i = 0; i < 20000; i++) {
|
|
boolean failure = false;
|
|
Base res = null;
|
|
int s = 0;
|
|
Class retType = m.getReturnType();
|
|
if (retType.isPrimitive()) {
|
|
if (!retType.equals(Void.TYPE)) {
|
|
s = (int)m.invoke(null, src);
|
|
failure = (s != src.sum());
|
|
} else {
|
|
m.invoke(null, src);
|
|
}
|
|
} else {
|
|
res = (Base)m.invoke(null, src);
|
|
failure = !res.equals(src);
|
|
}
|
|
if (failure) {
|
|
System.out.println("Test " + name + " failed");
|
|
System.out.println("source: ");
|
|
System.out.println(src);
|
|
System.out.println("result: ");
|
|
if (m.getReturnType().isPrimitive()) {
|
|
System.out.println(s);
|
|
} else {
|
|
System.out.println(res);
|
|
}
|
|
success = false;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|