Java example source code file (TestSynchronization.java)

This example Java source code file (TestSynchronization.java) is included in the alvinalexander.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" ^TM.

Learn more about this Java project at its project page.

Java - Java tags/keywords

boolean_val, char_val, invoketask, method, object, object_val, reflection, runtimeexception, string_buffer_val, string_builder_val, string_val, stringbuffer, stringbuilder, suppresswarnings, testfailedexception, util

The TestSynchronization.java Java example source code

/*
 * Copyright (c) 2012, 2013, 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.
 */

/* @test
 * @bug 6206780
 * @summary Test that all public unsynchronized methods of StringBuffer are either directly or indirectly synchronized
 */
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
 * TestSynchronization tests whether synchronized methods calls on an object
 * result in synchronized calls. Note that this may not test all cases desired.
 * It only tests whether some synchronization has occurred on the object during
 * the call chain, and can't tell whether the object was locked across all
 * operations that have been performed on the object.
 */
public class TestSynchronization {

    /**
     * Define parameters used in methods of StringBuffer - admittedly a bit of
     * hack but 'purpose-built' for StringBuffer. Something more general could
     * probably be developed if the test needs to be more widely adopted.
     * <p/>
     * boolean char char[] int double float long Object CharSequence String
     * StringBuffer StringBuilder
     * <p/>
     */
    private static final boolean BOOLEAN_VAL = true;
    private static final char CHAR_VAL = 'x';
    private static final char[] CHAR_ARRAY_VAL = {'c', 'h', 'a', 'r', 'a', 'r',
        'r', 'a', 'y'};
    private static final int INT_VAL = 1;
    private static final double DOUBLE_VAL = 1.0d;
    private static final float FLOAT_VAL = 1.0f;
    private static final long LONG_VAL = 1L;
    private static final Object OBJECT_VAL = new Object();
    private static final String STRING_VAL = "String value";
    private static final StringBuilder STRING_BUILDER_VAL =
            new StringBuilder("StringBuilder value");
    private static final StringBuffer STRING_BUFFER_VAL =
            new StringBuffer("StringBuffer value");
    private static final CharSequence[] CHAR_SEQUENCE_VAL = {STRING_VAL,
        STRING_BUILDER_VAL, STRING_BUFFER_VAL};

    public static void main(String... args) throws Exception {
        // First, test the tester
        testClass(MyTestClass.class, /*
                 * self-test
                 */ true);
        // Finally, test StringBuffer
        testClass(StringBuffer.class, /*
                 * self-test
                 */ false);
    }

    /**
     * Test all the public, unsynchronized methods of the given class. If
     * isSelfTest is true, this is a self-test to ensure that the test program
     * itself is working correctly. Should help ensure correctness of this
     * program if it changes.
     * <p/>
     * @param aClass - the class to test
     * @param isSelfTest - true if this is the special self-test class
     * @throws SecurityException
     */
    private static void testClass(Class<?> aClass, boolean isSelfTest) throws
            Exception {
        // Get all unsynchronized public methods via reflection.  We don't need
        // to test synchronized methods.  By definition. they are already doing
        // the right thing.
        List<Method> methods = Arrays.asList(aClass.getDeclaredMethods());
        for (Method m : methods) {
            // skip synthetic methods, like default interface methods and lambdas
            if (m.isSynthetic()) {
                continue;
            }
            int modifiers = m.getModifiers();
            if (Modifier.isPublic(modifiers)
                    && !Modifier.isSynchronized(modifiers)) {
                try {
                    testMethod(aClass, m);
                } catch (TestFailedException e) {
                    if (isSelfTest) {
                        String methodName = e.getMethod().getName();
                        switch (methodName) {
                            case "should_pass":
                                throw new RuntimeException(
                                        "Test failed: self-test failed.  The 'should_pass' method did not pass the synchronization test. Check the test code.");
                            case "should_fail":
                                break;
                            default:
                                throw new RuntimeException(
                                        "Test failed: something is amiss with the test. A TestFailedException was generated on a call to "
                                        + methodName + " which we didn't expect to test in the first place.");
                        }
                    } else {
                        throw new RuntimeException("Test failed: the method "
                                + e.getMethod().toString()
                                + " should be synchronized, but isn't.");
                    }
                }
            }
        }
    }

    private static void invokeMethod(Class<?> aClass, final Method m,
            final Object[] args) throws TestFailedException, Exception {
        //System.out.println( "Invoking " + m.toString() + " with parameters " + Arrays.toString(args));
        final Constructor<?> objConstructor;
        Object obj = null;

        objConstructor = aClass.getConstructor(String.class);
        obj = objConstructor.newInstance("LeftPalindrome-emordnilaP-thgiR");

        // test method m for synchronization
        if (!isSynchronized(m, obj, args)) {
            throw new TestFailedException(m);
        }
    }

    private static void testMethod(Class<?> aClass, Method m) throws
            Exception {
        /*
         * Construct call with arguments of the correct type. Note that the
         * values are somewhat irrelevant. If the call actually succeeds, it
         * means we aren't synchronized and the test has failed.
         */
        Class<?>[] pTypes = m.getParameterTypes();
        List<Integer> charSequenceArgs = new ArrayList<>();
        Object[] args = new Object[pTypes.length];
        for (int i = 0; i < pTypes.length; i++) {
            // determine the type and create the corresponding actual argument
            Class<?> pType = pTypes[i];
            if (pType.equals(boolean.class)) {
                args[i] = BOOLEAN_VAL;
            } else if (pType.equals(char.class)) {
                args[i] = CHAR_VAL;
            } else if (pType.equals(int.class)) {
                args[i] = INT_VAL;
            } else if (pType.equals(double.class)) {
                args[i] = DOUBLE_VAL;
            } else if (pType.equals(float.class)) {
                args[i] = FLOAT_VAL;
            } else if (pType.equals(long.class)) {
                args[i] = LONG_VAL;
            } else if (pType.equals(Object.class)) {
                args[i] = OBJECT_VAL;
            } else if (pType.equals(StringBuilder.class)) {
                args[i] = STRING_BUILDER_VAL;
            } else if (pType.equals(StringBuffer.class)) {
                args[i] = STRING_BUFFER_VAL;
            } else if (pType.equals(String.class)) {
                args[i] = STRING_VAL;
            } else if (pType.isArray() && pType.getComponentType().equals(char.class)) {
                args[i] = CHAR_ARRAY_VAL;
            } else if (pType.equals(CharSequence.class)) {
                charSequenceArgs.add(new Integer(i));
            } else {
                throw new RuntimeException("Test Failed: not accounting for method call with parameter type of " + pType.getName() + " You must update the test.");
            }
        }
        /*
         * If there are no CharSequence args, we can simply invoke our method
         * and test it
         */
        if (charSequenceArgs.isEmpty()) {
            invokeMethod(aClass, m, args);
        } else {
            /*
             * Iterate through the different CharSequence types and invoke the
             * method for each type.
             */
            if (charSequenceArgs.size() > 1) {
                throw new RuntimeException("Test Failed: the test cannot handle a method with multiple CharSequence arguments.  You must update the test to handle the method "
                        + m.toString());
            }
            for (int j = 0; j < CHAR_SEQUENCE_VAL.length; j++) {
                args[charSequenceArgs.get(0)] = CHAR_SEQUENCE_VAL[j];
                invokeMethod(aClass, m, args);
            }
        }
    }

    @SuppressWarnings("serial")
    private static class TestFailedException extends Exception {

        final Method m;

        public Method getMethod() {
            return m;
        }

        public TestFailedException(Method m) {
            this.m = m;
        }
    }

    static class InvokeTask implements Runnable {

        private final Method m;
        private final Object target;
        private final Object[] args;

        InvokeTask(Method m, Object target, Object... args) {
            this.m = m;
            this.target = target;
            this.args = args;
        }

        @Override
        public void run() {
            try {
                m.invoke(target, args);
            } catch (IllegalAccessException | IllegalArgumentException |
                    InvocationTargetException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * isSynchronized tests whether the given method is synchronized or not by
     * invoking it in a thread and testing the thread state after starting the
     * thread
     * <p/>
     * @param m the method to test
     * @param target the object the method is executed on
     * @param args the arguments passed to the method
     * @return true iff the method is synchronized
     */
    private static boolean isSynchronized(Method m, Object target,
            Object... args) {
        Thread t = new Thread(new InvokeTask(m, target, args));

        Boolean isSynchronized = null;

        synchronized (target) {
            t.start();

            while (isSynchronized == null) {
                switch (t.getState()) {
                    case NEW:
                    case RUNNABLE:
                    case WAITING:
                    case TIMED_WAITING:
                        Thread.yield();
                        break;
                    case BLOCKED:
                        isSynchronized = true;
                        break;
                    case TERMINATED:
                        isSynchronized = false;
                        break;
                }
            }
        }

        try {
            t.join();
        } catch (InterruptedException ex) {
            ex.printStackTrace();
        }

        return isSynchronized;
    }

    /*
     * This class is used to test the synchronization tester above. It has a
     * method, should_pass, that is unsynchronized but calls a synchronized
     * method. It has another method, should_fail, which isn't synchronized and
     * doesn't call a synchronized method. The former should pass and the latter
     * should fail.
     */
    private static class MyTestClass {

        @SuppressWarnings("unused")
        public MyTestClass(String s) {
        }

        @SuppressWarnings("unused")
        public void should_pass() {
            // call sync method
            sync_shouldnt_be_tested();
        }

        @SuppressWarnings("unused")
        public void should_fail() {
        }

        public synchronized void sync_shouldnt_be_tested() {
        }
    }
}