compiler/arraycopy/TestInstanceCloneUtils.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;
            }
        }
    }

}