/*
 * JTiger Unit Testing Framework for J2SE 1.5
 * Copyright (C) 2005 Tony Morris
 *
 * This software is licenced under the
 * Common Public Licence version 1.0
 * http://www.opensource.org/licenses/cpl1.0.php
 *
 * You received a copy of this licence with this software.
 */
package org.jtiger.assertion;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import org.jtiger.framework.Category;
import org.jtiger.framework.ExpectException;
import org.jtiger.framework.Fixture;
import org.jtiger.framework.Test;
import static org.jtiger.assertion.Basic.assertFalse;
import static org.jtiger.assertion.Modifier.assertAbstract;
import static org.jtiger.assertion.Modifier.assertNotAbstract;
import static org.jtiger.assertion.Modifier.assertFinal;
import static org.jtiger.assertion.Modifier.assertNotFinal;
import static org.jtiger.assertion.Modifier.assertNative;
import static org.jtiger.assertion.Modifier.assertNotNative;
import static org.jtiger.assertion.Modifier.assertPrivate;
import static org.jtiger.assertion.Modifier.assertNotPrivate;
import static org.jtiger.assertion.Modifier.assertDefaultAccess;
import static org.jtiger.assertion.Modifier.assertNotDefaultAccess;
import static org.jtiger.assertion.Modifier.assertProtected;
import static org.jtiger.assertion.Modifier.assertNotProtected;
import static org.jtiger.assertion.Modifier.assertPublic;
import static org.jtiger.assertion.Modifier.assertNotPublic;
import static org.jtiger.assertion.Modifier.assertStatic;
import static org.jtiger.assertion.Modifier.assertNotStatic;
import static org.jtiger.assertion.Modifier.assertStrictfp;
import static org.jtiger.assertion.Modifier.assertNotStrictfp;
import static org.jtiger.assertion.Modifier.assertSynchronized;
import static org.jtiger.assertion.Modifier.assertNotSynchronized;
import static org.jtiger.assertion.Modifier.assertTransient;
import static org.jtiger.assertion.Modifier.assertNotTransient;
import static org.jtiger.assertion.Modifier.assertVolatile;
import static org.jtiger.assertion.Modifier.assertNotVolatile;
import static org.jtiger.assertion.Reflection.assertHasDeclaredConstructor;
import static org.jtiger.assertion.Reflection.assertHasDeclaredField;
import static org.jtiger.assertion.Reflection.assertHasDeclaredMethod;

@Fixture(value = "Modifier", description = "Performs Unit Tests on org.jtiger.assertion.Modifier")
@Category("org.jtiger.assertion.Modifier")
public final class TestModifier
{
    public TestModifier()
    {

    }

    @Test
    public void constructor() throws InstantiationException, IllegalAccessException, InvocationTargetException
    {
        final Constructor<?> c = assertHasDeclaredConstructor(Modifier.class, null);
        assertPrivate(c);
        assertFalse(c.isAccessible());
        c.setAccessible(true);
        c.newInstance();
    }

    @Test
    public void testAssertAbstract()
    {
        final Class<?> c = AbstractClass.class;
        assertAbstract(c);
        final Method m = assertHasDeclaredMethod(c, "abstractMethod", null);
        assertAbstract(m);
    }

    @Test
    @ExpectException(value = AssertionException.class)
    public void testAssertAbstractInverse1()
    {
        final Class<?> c = NotAbstractClass.class;
        assertAbstract(c);
    }

    @Test
    @ExpectException(value = AssertionException.class)
    public void testAssertAbstractInverse2()
    {
        final Class<?> c = NotAbstractClass.class;
        final Method m = assertHasDeclaredMethod(c, "notAbstractMethod", null);
        assertAbstract(m);
    }

    @Test
    @ExpectException(value = AssertionException.class)
    public void testAssertAbstractInverse3()
    {
        final Class<?> c = NotAbstractClass.class;
        final Method m = assertHasDeclaredMethod(c, "notAbstractMethod", null);
        assertAbstract(m);
    }

    @Test
    public void testAssertNotAbstract()
    {
        final Class<?> c = NotAbstractClass.class;
        assertNotAbstract(c);
        final Method m = assertHasDeclaredMethod(c, "notAbstractMethod", null);
        assertNotAbstract(m);
    }

    @Test
    @ExpectException(value = AssertionException.class)
    public void testAssertNotAbstractInverse1()
    {
        final Class<?> c = AbstractClass.class;
        assertNotAbstract(c);
    }

    @Test
    @ExpectException(value = AssertionException.class)
    public void testAssertNotAbstractInverse2()
    {
        final Class<?> c = AbstractClass.class;
        final Method m = assertHasDeclaredMethod(c, "abstractMethod", null);
        assertNotAbstract(m);
    }

    @Test
    @ExpectException(value = AssertionException.class)
    public void testAssertNotAbstractInverse3()
    {
        final Class<?> c = AbstractClass.class;
        final Method m = assertHasDeclaredMethod(c, "abstractMethod", null);
        assertNotAbstract(m);
    }

    @Test
    public void testAssertFinal()
    {
        final Class<?> c = FinalClass.class;
        assertFinal(c);
        final Method m = assertHasDeclaredMethod(c, "finalMethod", null);
        assertFinal(m);
        final Field f = assertHasDeclaredField(c, "finalField");
        assertFinal(f);
    }

    @Test
    @ExpectException(value = AssertionException.class)
    public void testAssertFinalInverse1()
    {
        final Class<?> c = NotFinalClass.class;
        assertFinal(c);
    }

    @Test
    @ExpectException(value = AssertionException.class)
    public void testAssertFinalInverse2()
    {
        final Class<?> c = NotFinalClass.class;
        final Method m = assertHasDeclaredMethod(c, "notFinalMethod", null);
        assertFinal(m);
    }

    @Test
    @ExpectException(value = AssertionException.class)
    public void testAssertFinalInverse3()
    {
        final Class<?> c = NotFinalClass.class;
        final Field f = assertHasDeclaredField(c, "notFinalField");
        assertFinal(f);
    }

    @Test
    public void testAssertNotFinal()
    {
        final Class<?> c = NotFinalClass.class;
        assertNotFinal(c);
        final Method m = assertHasDeclaredMethod(c, "notFinalMethod", null);
        assertNotFinal(m);
        final Field f = assertHasDeclaredField(c, "notFinalField");
        assertNotFinal(f);
    }

    @Test
    @ExpectException(value = AssertionException.class)
    public void testAssertNotFinalInverse1()
    {
        final Class<?> c = FinalClass.class;
        assertNotFinal(c);
    }

    @Test
    @ExpectException(value = AssertionException.class)
    public void testAssertNotFinalInverse2()
    {
        final Class<?> c = FinalClass.class;
        final Method m = assertHasDeclaredMethod(c, "finalMethod", null);
        assertNotFinal(m);
    }

    @Test
    @ExpectException(value = AssertionException.class)
    public void testAssertNotFinalInverse3()
    {
        final Class<?> c = FinalClass.class;
        final Field f = assertHasDeclaredField(c, "finalField");
        assertNotFinal(f);
    }

    @Test
    public void testAssertNative()
    {
        final Class<?> c = NativeClass.class;
        final Method m = assertHasDeclaredMethod(c, "nativeMethod", null);
        assertNative(m);
    }

    @Test
    @ExpectException(value = AssertionException.class)
    public void testAssertNativeInverse()
    {
        final Class<?> c = NotNativeClass.class;
        final Method m = assertHasDeclaredMethod(c, "notNativeMethod", null);
        assertNative(m);
    }

    @Test
    public void testAssertNotNative()
    {
        final Class<?> c = NotNativeClass.class;
        final Method m = assertHasDeclaredMethod(c, "notNativeMethod", null);
        assertNotNative(m);
    }

    @Test
    @ExpectException(value = AssertionException.class)
    public void testAssertNotNativeInverse()
    {
        final Class<?> c = NativeClass.class;
        final Method m = assertHasDeclaredMethod(c, "nativeMethod", null);
        assertNotNative(m);
    }

    @Test
    public void testAssertPrivate()
    {
        final Class<?> c = PrivateClass.class;
        assertPrivate(c);
        final Constructor<?> ctor = assertHasDeclaredConstructor(PrivateConstructor.class, null);
        assertPrivate(ctor);
        final Method m = assertHasDeclaredMethod(c, "m", null);
        assertPrivate(m);
        final Field f = assertHasDeclaredField(c, "f");
        assertPrivate(f);
    }

    @Test
    @ExpectException(value = AssertionException.class)
    public void testAssertPrivateInverse1()
    {
        final Class<?> c = NotPrivateClass.class;
        assertPrivate(c);
    }

    @Test
    @ExpectException(value = AssertionException.class)
    public void testAssertPrivateInverse2()
    {
        final Constructor<?> ctor = assertHasDeclaredConstructor(NotPrivateConstructor.class, null);
        assertPrivate(ctor);
    }

    @Test
    @ExpectException(value = AssertionException.class)
    public void testAssertPrivateInverse3()
    {
        final Class<?> c = NotPrivateClass.class;
        final Method m = assertHasDeclaredMethod(c, "m", null);
        assertPrivate(m);
    }

    @Test
    @ExpectException(value = AssertionException.class)
    public void testAssertPrivateInverse4()
    {
        final Class<?> c = NotPrivateClass.class;
        final Field f = assertHasDeclaredField(c, "f");
        assertPrivate(f);
    }
    @Test
    public void testAssertNotPrivate()
    {
        final Class<?> c = NotPrivateClass.class;
        assertNotPrivate(c);
        final Constructor<?> ctor = assertHasDeclaredConstructor(NotPrivateConstructor.class, null);
        assertNotPrivate(ctor);
        final Method m = assertHasDeclaredMethod(c, "m", null);
        assertNotPrivate(m);
        final Field f = assertHasDeclaredField(c, "f");
        assertNotPrivate(f);
    }

    @Test
    @ExpectException(value = AssertionException.class)
    public void testAssertNotPrivateInverse1()
    {
        final Class<?> c = PrivateClass.class;
        assertNotPrivate(c);
    }

    @Test
    @ExpectException(value = AssertionException.class)
    public void testAssertNotPrivateInverse2()
    {
        final Constructor<?> ctor = assertHasDeclaredConstructor(PrivateConstructor.class, null);
        assertNotPrivate(ctor);
    }

    @Test
    @ExpectException(value = AssertionException.class)
    public void testAssertNotPrivateInverse3()
    {
        final Class<?> c = PrivateClass.class;
        final Method m = assertHasDeclaredMethod(c, "m", null);
        assertNotPrivate(m);
    }

    @Test
    @ExpectException(value = AssertionException.class)
    public void testAssertNotPrivateInverse4()
    {
        final Class<?> c = PrivateClass.class;
        final Field f = assertHasDeclaredField(c, "f");
        assertNotPrivate(f);
    }

    @Test
    public void testAssertProtected()
    {
        final Class<?> c = ProtectedClass.class;
        assertProtected(c);
        final Constructor<?> ctor = assertHasDeclaredConstructor(c, null);
        assertProtected(ctor);
        final Method m = assertHasDeclaredMethod(c, "m", null);
        assertProtected(m);
        final Field f = assertHasDeclaredField(c, "f");
        assertProtected(f);
    }

    @Test
    @ExpectException(value = AssertionException.class)
    public void testAssertProtectedInverse1()
    {
        final Class<?> c = NotProtectedClass.class;
        assertProtected(c);
    }

    @Test
    @ExpectException(value = AssertionException.class)
    public void testAssertProtectedInverse2()
    {
        final Class<?> c = NotProtectedClass.class;
        final Constructor<?> ctor = assertHasDeclaredConstructor(c, null);
        assertProtected(ctor);
    }

    @Test
    @ExpectException(value = AssertionException.class)
    public void testAssertProtectedInverse3()
    {
        final Class<?> c = NotProtectedClass.class;
        final Method m = assertHasDeclaredMethod(c, "m", null);
        assertProtected(m);
    }

    @Test
    @ExpectException(value = AssertionException.class)
    public void testAssertProtectedInverse4()
    {
        final Class<?> c = NotProtectedClass.class;
        final Field f = assertHasDeclaredField(c, "f");
        assertProtected(f);
    }

    @Test
    public void testAssertNotProtected()
    {
        final Class<?> c = NotProtectedClass.class;
        assertNotProtected(c);
        final Constructor<?> ctor = assertHasDeclaredConstructor(c, null);
        assertNotProtected(ctor);
        final Method m = assertHasDeclaredMethod(c, "m", null);
        assertNotProtected(m);
        final Field f = assertHasDeclaredField(c, "f");
        assertNotProtected(f);
    }

    @Test
    @ExpectException(value = AssertionException.class)
    public void testAssertNotProtectedInverse1()
    {
        final Class<?> c = ProtectedClass.class;
        assertNotProtected(c);
    }

    @Test
    @ExpectException(value = AssertionException.class)
    public void testAssertNotProtectedInverse2()
    {
        final Class<?> c = ProtectedClass.class;
        final Constructor<?> ctor = assertHasDeclaredConstructor(c, null);
        assertNotProtected(ctor);
    }

    @Test
    @ExpectException(value = AssertionException.class)
    public void testAssertNotProtectedInverse3()
    {
        final Class<?> c = ProtectedClass.class;
        final Method m = assertHasDeclaredMethod(c, "m", null);
        assertNotProtected(m);
    }

    @Test
    @ExpectException(value = AssertionException.class)
    public void testAssertNotProtectedInverse4()
    {
        final Class<?> c = ProtectedClass.class;
        final Field f = assertHasDeclaredField(c, "f");
        assertNotProtected(f);
    }

    @Test
    public void testAssertPublic()
    {
        final Class<?> c = PublicClass.class;
        assertPublic(c);
        final Constructor<?> ctor = assertHasDeclaredConstructor(c, null);
        assertPublic(ctor);
        final Method m = assertHasDeclaredMethod(c, "m", null);
        assertPublic(m);
        final Field f = assertHasDeclaredField(c, "f");
        assertPublic(f);
    }

    @Test
    @ExpectException(value = AssertionException.class)
    public void testAssertPublicInverse1()
    {
        final Class<?> c = NotPublicClass.class;
        assertPublic(c);
    }

    @Test
    @ExpectException(value = AssertionException.class)
    public void testAssertPublicInverse2()
    {
        final Class<?> c = NotPublicClass.class;
        final Constructor<?> ctor = assertHasDeclaredConstructor(c, null);
        assertPublic(ctor);
    }

    @Test
    @ExpectException(value = AssertionException.class)
    public void testAssertPublicInverse3()
    {
        final Class<?> c = NotPublicClass.class;
        final Method m = assertHasDeclaredMethod(c, "m", null);
        assertPublic(m);
    }

    @Test
    @ExpectException(value = AssertionException.class)
    public void testAssertPublicInverse4()
    {
        final Class<?> c = NotPublicClass.class;
        final Field f = assertHasDeclaredField(c, "f");
        assertPublic(f);
    }

    @Test
    public void testAssertNotPublic()
    {
        final Class<?> c = NotPublicClass.class;
        assertNotPublic(c);
        final Constructor<?> ctor = assertHasDeclaredConstructor(c, null);
        assertNotPublic(ctor);
        final Method m = assertHasDeclaredMethod(c, "m", null);
        assertNotPublic(m);
        final Field f = assertHasDeclaredField(c, "f");
        assertNotPublic(f);
    }

    @Test
    @ExpectException(value = AssertionException.class)
    public void testAssertNotPublicInverse1()
    {
        final Class<?> c = PublicClass.class;
        assertNotPublic(c);
    }

    @Test
    @ExpectException(value = AssertionException.class)
    public void testAssertNotPublicInverse2()
    {
        final Class<?> c = PublicClass.class;
        final Constructor<?> ctor = assertHasDeclaredConstructor(c, null);
        assertNotPublic(ctor);
    }

    @Test
    @ExpectException(value = AssertionException.class)
    public void testAssertNotPublicInverse3()
    {
        final Class<?> c = PublicClass.class;
        final Method m = assertHasDeclaredMethod(c, "m", null);
        assertNotPublic(m);
    }

    @Test
    @ExpectException(value = AssertionException.class)
    public void testAssertNotPublicInverse4()
    {
        final Class<?> c = PublicClass.class;
        final Field f = assertHasDeclaredField(c, "f");
        assertNotPublic(f);
    }

    @Test
    public void testAssertDefaultAccess()
    {
        final Class<?> c = DefaultAccessClass.class;
        assertDefaultAccess(c);
        final Constructor<?> ctor = assertHasDeclaredConstructor(c, null);
        assertDefaultAccess(ctor);
        final Method m = assertHasDeclaredMethod(c, "m", null);
        assertDefaultAccess(m);
        final Field f = assertHasDeclaredField(c, "f");
        assertDefaultAccess(f);
    }

    @Test
    @ExpectException(value = AssertionException.class)
    public void testAssertDefaultAccessInverse1()
    {
        final Class<?> c = NotDefaultAccessClass.class;
        assertDefaultAccess(c);
    }

    @Test
    @ExpectException(value = AssertionException.class)
    public void testAssertDefaultAccessInverse2()
    {
        final Class<?> c = NotDefaultAccessClass.class;
        final Constructor<?> ctor = assertHasDeclaredConstructor(c, null);
        assertDefaultAccess(ctor);
    }

    @Test
    @ExpectException(value = AssertionException.class)
    public void testAssertDefaultAccessInverse3()
    {
        final Class<?> c = NotDefaultAccessClass.class;
        final Method m = assertHasDeclaredMethod(c, "m", null);
        assertDefaultAccess(m);
    }

    @Test
    @ExpectException(value = AssertionException.class)
    public void testAssertDefaultAccessInverse4()
    {
        final Class<?> c = NotDefaultAccessClass.class;
        final Field f = assertHasDeclaredField(c, "f");
        assertDefaultAccess(f);
    }
    @Test
    public void testAssertNotDefaultAccess()
    {
        final Class<?> c = NotDefaultAccessClass.class;
        assertNotDefaultAccess(c);
        final Constructor<?> ctor = assertHasDeclaredConstructor(c, null);
        assertNotDefaultAccess(ctor);
        final Method m = assertHasDeclaredMethod(c, "m", null);
        assertNotDefaultAccess(m);
        final Field f = assertHasDeclaredField(c, "f");
        assertNotDefaultAccess(f);
    }

    @Test
    @ExpectException(value = AssertionException.class)
    public void testAssertNotDefaultAccessInverse1()
    {
        final Class<?> c = DefaultAccessClass.class;
        assertNotDefaultAccess(c);
    }

    @Test
    @ExpectException(value = AssertionException.class)
    public void testAssertNotDefaultAccessInverse2()
    {
        final Class<?> c = DefaultAccessClass.class;
        final Constructor<?> ctor = assertHasDeclaredConstructor(c, null);
        assertNotDefaultAccess(ctor);
    }

    @Test
    @ExpectException(value = AssertionException.class)
    public void testAssertNotDefaultAccessInverse3()
    {
        final Class<?> c = DefaultAccessClass.class;
        final Method m = assertHasDeclaredMethod(c, "m", null);
        assertNotDefaultAccess(m);
    }

    @Test
    @ExpectException(value = AssertionException.class)
    public void testNotAssertDefaultAccessInverse4()
    {
        final Class<?> c = DefaultAccessClass.class;
        final Field f = assertHasDeclaredField(c, "f");
        assertNotDefaultAccess(f);
    }

    @Test
    public void testAssertStatic()
    {
        final Class<?> c = StaticClass.class;
        assertStatic(c);
        final Method m = assertHasDeclaredMethod(c, "m", null);
        assertStatic(m);
        final Field f = assertHasDeclaredField(c, "f");
        assertStatic(f);
    }

    @Test
    @ExpectException(value = AssertionException.class)
    public void testAssertStaticInverse1()
    {
        final Class<?> c = NotStaticClass.class;
        assertStatic(c);
    }

    @Test
    @ExpectException(value = AssertionException.class)
    public void testAssertStaticInverse2()
    {
        final Class<?> c = NotStaticClass.class;
        final Method m = assertHasDeclaredMethod(c, "m", null);
        assertStatic(m);
    }

    @Test
    @ExpectException(value = AssertionException.class)
    public void testAssertStaticInverse3()
    {
        final Class<?> c = NotStaticClass.class;
        final Field f = assertHasDeclaredField(c, "f");
        assertStatic(f);
    }

    @Test
    public void testAssertNotStatic()
    {
        final Class<?> c = NotStaticClass.class;
        assertNotStatic(c);
        final Method m = assertHasDeclaredMethod(c, "m", null);
        assertNotStatic(m);
        final Field f = assertHasDeclaredField(c, "f");
        assertNotStatic(f);
    }

    @Test
    @ExpectException(value = AssertionException.class)
    public void testAssertNotStaticInverse1()
    {
        final Class<?> c = StaticClass.class;
        assertNotStatic(c);
    }

    @Test
    @ExpectException(value = AssertionException.class)
    public void testAssertNotStaticInverse2()
    {
        final Class<?> c = StaticClass.class;
        final Method m = assertHasDeclaredMethod(c, "m", null);
        assertNotStatic(m);
    }

    @Test
    @ExpectException(value = AssertionException.class)
    public void testAssertNotStaticInverse3()
    {
        final Class<?> c = StaticClass.class;
        final Field f = assertHasDeclaredField(c, "f");
        assertNotStatic(f);
    }

    @Test
    public void testAssertStrictfp()
    {
        final Class<?> c = StrictfpClass.class;
        assertStrictfp(c);
    }

    @Test
    @ExpectException(value = AssertionException.class)
    public void testAssertStrictfpInverse()
    {
        final Class<?> c = NotStrictfpClass.class;
        assertStrictfp(c);
    }

    @Test
    public void testAssertNotStrictfp()
    {
        final Class<?> c = NotStrictfpClass.class;
        assertNotStrictfp(c);
    }

    @Test
    @ExpectException(value = AssertionException.class)
    public void testAssertNotStrictfpInverse()
    {
        final Class<?> c = StrictfpClass.class;
        assertNotStrictfp(c);
    }

    @Test
    public void testAssertSynchronized()
    {
        final Class<?> c = SynchronizedClass.class;
        final Method m = assertHasDeclaredMethod(c, "m", null);
        assertSynchronized(m);
    }

    @Test
    @ExpectException(value = AssertionException.class)
    public void testAssertSynchronizedInverse()
    {
        final Class<?> c = NotSynchronizedClass.class;
        final Method m = assertHasDeclaredMethod(c, "m", null);
        assertSynchronized(m);
    }

    @Test
    public void testAssertNotSynchronized()
    {
        final Class<?> c = NotSynchronizedClass.class;
        final Method m = assertHasDeclaredMethod(c, "m", null);
        assertNotSynchronized(m);
    }

    @Test
    @ExpectException(value = AssertionException.class)
    public void testAssertNotSynchronizedInverse()
    {
        final Class<?> c = SynchronizedClass.class;
        final Method m = assertHasDeclaredMethod(c, "m", null);
        assertNotSynchronized(m);
    }

    @Test
    public void testAssertTransient()
    {
        final Class<?> c = TransientClass.class;
        final Field f = assertHasDeclaredField(c, "f");
        assertTransient(f);
    }

    @Test
    @ExpectException(value = AssertionException.class)
    public void testAssertTransientInverse()
    {
        final Class<?> c = NotTransientClass.class;
        final Field f = assertHasDeclaredField(c, "f");
        assertTransient(f);
    }

    @Test
    public void testAssertNotTransient()
    {
        final Class<?> c = NotTransientClass.class;
        final Field f = assertHasDeclaredField(c, "f");
        assertNotTransient(f);
    }

    @Test
    @ExpectException(value = AssertionException.class)
    public void testAssertNotTransientInverse()
    {
        final Class<?> c = TransientClass.class;
        final Field f = assertHasDeclaredField(c, "f");
        assertNotTransient(f);
    }

    @Test
    public void testAssertVolatile()
    {
        final Class<?> c = VolatileClass.class;
        final Field f = assertHasDeclaredField(c, "f");
        assertVolatile(f);
    }

    @Test
    @ExpectException(value = AssertionException.class)
    public void testAssertVolatileInverse()
    {
        final Class<?> c = NotVolatileClass.class;
        final Field f = assertHasDeclaredField(c, "f");
        assertVolatile(f);
    }

    @Test
    public void testAssertNotVolatile()
    {
        final Class<?> c = NotVolatileClass.class;
        final Field f = assertHasDeclaredField(c, "f");
        assertNotVolatile(f);
    }

    @Test
    @ExpectException(value = AssertionException.class)
    public void testAssertNotVolatileInverse()
    {
        final Class<?> c = VolatileClass.class;
        final Field f = assertHasDeclaredField(c, "f");
        assertNotVolatile(f);
    }

    abstract class AbstractClass
    {
        abstract void abstractMethod();
    }

    final class NotAbstractClass
    {
        final void notAbstractMethod()
        {

        }
    }

    private final class FinalClass
    {
        final int finalField = 7;

        final void finalMethod()
        {

        }
    }

    private class NotFinalClass
    {
        int notFinalField = 7;

        void notFinalMethod()
        {

        }
    }

    private static final class NativeClass
    {
        public native void nativeMethod();
    }

    private static final class NotNativeClass
    {
        void notNativeMethod()
        {

        }
    }

    private static final class PrivateClass
    {
        private final int f;

        private PrivateClass()
        {
            m();
            f = 7;
            new Integer(f);
        }

        private void m()
        {

        }
    }

    static final class NotPrivateClass
    {
        int f;

        NotPrivateClass()
        {

        }

        final void m()
        {

        }
    }

    protected static final class ProtectedClass
    {
        protected int f;

        protected ProtectedClass()
        {

        }

        protected final void m()
        {

        }
    }

    static final class NotProtectedClass
    {
        int f;

        NotProtectedClass()
        {

        }

        final void m()
        {

        }
    }

    static final class DefaultAccessClass
    {
        int f;

        DefaultAccessClass()
        {

        }

        final void m()
        {

        }
    }

    public static final class NotDefaultAccessClass
    {
        public int f;

        public NotDefaultAccessClass()
        {

        }

        public final void m()
        {

        }
    }

    public static final class PublicClass
    {
        public int f;

        public PublicClass()
        {

        }

        public final void m()
        {

        }
    }

    static final class NotPublicClass
    {
        int f;

        NotPublicClass()
        {

        }

        final void m()
        {

        }
    }

    private static final class StaticClass
    {
        static int f;

        static void m()
        {

        }
    }

    private final class NotStaticClass
    {
        int f;

        final void m()
        {

        }
    }

    private static final strictfp class StrictfpClass
    {

    }

    private static final class NotStrictfpClass
    {

    }

    private static final class SynchronizedClass
    {
        public synchronized void m()
        {

        }
    }

    private static final class NotSynchronizedClass
    {
        public void m()
        {

        }
    }

    private static final class TransientClass
    {
        transient int f;
    }

    private static final class NotTransientClass
    {
        int f;
    }

    private static final class VolatileClass
    {
        volatile int f;
    }

    private static final class NotVolatileClass
    {
        int f;
    }

    static final class PrivateConstructor
    {
        private PrivateConstructor()
        {

        }
    }

    static final class NotPrivateConstructor
    {
        public NotPrivateConstructor()
        {

        }
    }
}