org.jtiger.assertion
Class Modifier

java.lang.Object
  org.jtiger.assertion.Modifier

public final class Modifier
extends Object

Provides the ability make assertions that modifiers appear or do not appear on various language constructs, such as types (i.e. classes, interfaces, enums and annotations), constructors, methods and fields.

Version:

2.1
Build Number 0376
Build Time 2006-07-28 01:50.16.218 CET (GMT + 1)

Author:

Tony Morris

See Also:

Modifier

Method Summary

static void	assertAbstract(Class<?> c, Object... message) Asserts that the given Class has the abstract modifier (implicitly or explicitly).
static void	assertAbstract(Method m, Object... message) Asserts that the given Method has the abstract modifier (implicitly or explicitly).
static void	assertDefaultAccess(Class<?> c, Object... message) Asserts that the given Class has the default (none specified) access modifier.
static void	assertDefaultAccess(Constructor<?> c, Object... message) Asserts that the given Constructor has the default (none specified) access modifier.
static void	assertDefaultAccess(Field f, Object... message) Asserts that the given Field has the default (none specified) access modifier.
static void	assertDefaultAccess(Method m, Object... message) Asserts that the given Method has the default (none specified) access modifier.
static void	assertFinal(Class<?> c, Object... message) Asserts that the given Class has the final modifier (implicitly or explicitly).
static void	assertFinal(Field f, Object... message) Asserts that the given Field has the final modifier (implicitly or explicitly).
static void	assertFinal(Method m, Object... message) Asserts that the given Method has the final modifier.
static void	assertNative(Method m, Object... message) Asserts that the given Method has the native modifier.
static void	assertNotAbstract(Class<?> c, Object... message) Asserts that the given Class does not have the abstract modifier (implicitly or explicitly).
static void	assertNotAbstract(Method m, Object... message) Asserts that the given Method does not have the abstract modifier (implicitly or explicitly).
static void	assertNotDefaultAccess(Class<?> c, Object... message) Asserts that the given Class does not have the default (none specified) access modifier.
static void	assertNotDefaultAccess(Constructor<?> c, Object... message) Asserts that the given Constructor does not have the default (none specified) access modifier.
static void	assertNotDefaultAccess(Field f, Object... message) Asserts that the given Field does not have the default (none specified) access modifier.
static void	assertNotDefaultAccess(Method m, Object... message) Asserts that the given Method does not have the default (none specified) access modifier.
static void	assertNotFinal(Class<?> c, Object... message) Asserts that the given Class does not have the final modifier (implicitly or explicitly).
static void	assertNotFinal(Field f, Object... message) Asserts that the given Field does not have the final modifier (implicitly or explicitly).
static void	assertNotFinal(Method m, Object... message) Asserts that the given Method does not have the final modifier.
static void	assertNotNative(Method m, Object... message) Asserts that the given Method does not have the native modifier.
static void	assertNotPrivate(Class<?> c, Object... message) Asserts that the given Class does not have the private modifier.
static void	assertNotPrivate(Constructor<?> c, Object... message) Asserts that the given Constructor does not have the private modifier (implicitly or explicitly).
static void	assertNotPrivate(Field f, Object... message) Asserts that the given Field does not have the private modifier (implicitly or explicitly).
static void	assertNotPrivate(Method m, Object... message) Asserts that the given Method does not have the private modifier.
static void	assertNotProtected(Class<?> c, Object... message) Asserts that the given Class does not have the protected modifier.
static void	assertNotProtected(Constructor<?> c, Object... message) Asserts that the given Constructor does not have the protected modifier.
static void	assertNotProtected(Field f, Object... message) Asserts that the given Field does not have the protected modifier.
static void	assertNotProtected(Method m, Object... message) Asserts that the given Method does not have the protected modifier.
static void	assertNotPublic(Class<?> c, Object... message) Asserts that the given Class does not have the public modifier (implicitly or explicitly).
static void	assertNotPublic(Constructor<?> c, Object... message) Asserts that the given Constructor does not have the public modifier.
static void	assertNotPublic(Field f, Object... message) Asserts that the given Field does not have the public modifier (implicitly or explicitly).
static void	assertNotPublic(Method m, Object... message) Asserts that the given Method does not have the public modifier (implicitly or explicitly).
static void	assertNotStatic(Class<?> c, Object... message) Asserts that the given Class does not have the static modifier (implicitly or explicitly).
static void	assertNotStatic(Field f, Object... message) Asserts that the given Field does not have the static modifier (implicitly or explicitly).
static void	assertNotStatic(Method m, Object... message) Asserts that the given Method does not have the static modifier.
static void	assertNotStrictfp(Class<?> c, Object... message) Asserts that the given Class does not have the strictfp modifier (implicitly or explicitly).
static void	assertNotSynchronized(Method m, Object... message) Asserts that the given Method does not have the synchronized modifier.
static void	assertNotTransient(Field f, Object... message) Asserts that the given Field does not have the transient modifier.
static void	assertNotVolatile(Field f, Object... message) Asserts that the given Field does not have the volatile modifier.
static void	assertPrivate(Class<?> c, Object... message) Asserts that the given Class has the private modifier.
static void	assertPrivate(Constructor<?> c, Object... message) Asserts that the given Constructor has the private modifier (implicitly or explicitly).
static void	assertPrivate(Field f, Object... message) Asserts that the given Field has the private modifier (implicitly or explicitly).
static void	assertPrivate(Method m, Object... message) Asserts that the given Method has the private modifier.
static void	assertProtected(Class<?> c, Object... message) Asserts that the given Class has the protected modifier.
static void	assertProtected(Constructor<?> c, Object... message) Asserts that the given Constructor has the protected modifier.
static void	assertProtected(Field f, Object... message) Asserts that the given Field has the protected modifier.
static void	assertProtected(Method m, Object... message) Asserts that the given Method has the protected modifier.
static void	assertPublic(Class<?> c, Object... message) Asserts that the given Class has the public modifier (implicitly or explicitly).
static void	assertPublic(Constructor<?> c, Object... message) Asserts that the given Constructor has the public modifier.
static void	assertPublic(Field f, Object... message) Asserts that the given Field has the public modifier (implicitly or explicitly).
static void	assertPublic(Method m, Object... message) Asserts that the given Method has the public modifier (implicitly or explicitly).
static void	assertStatic(Class<?> c, Object... message) Asserts that the given Class has the static modifier (implicitly or explicitly).
static void	assertStatic(Field f, Object... message) Asserts that the given Field has the static modifier (implicitly or explicitly).
static void	assertStatic(Method m, Object... message) Asserts that the given Method has the static modifier.
static void	assertStrictfp(Class<?> c, Object... message) Asserts that the given Class has the strictfp modifier (implicitly or explicitly).
static void	assertSynchronized(Method m, Object... message) Asserts that the given Method has the synchronized modifier.
static void	assertTransient(Field f, Object... message) Asserts that the given Field has the transient modifier.
static void	assertVolatile(Field f, Object... message) Asserts that the given Field has the volatile modifier.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Method Detail

assertAbstract

public static void assertAbstract(Method m,
                                  Object... message)
                           throws AssertionException

Asserts that the given Method has the abstract modifier (implicitly or explicitly). The Java Language Specification defines that interface methods are implicitly abstract.

Parameters:

m - The Method to assert has the abstract modifier (implicitly or explicitly).

message - The assertion message.

Throws:

AssertionException - If the Method does not have the abstract modifier (implicitly or explicitly).

assertNotAbstract

public static void assertNotAbstract(Method m,
                                     Object... message)
                              throws AssertionException

Asserts that the given Method does not have the abstract modifier (implicitly or explicitly). The Java Language Specification defines that interface methods are implicitly abstract.

Parameters:

m - The Method to assert does not have the abstract modifier (implicitly or explicitly).

message - The assertion message.

Throws:

AssertionException - If the Method has the abstract modifier (implicitly or explicitly).

assertAbstract

public static void assertAbstract(Class<?> c,
                                  Object... message)
                           throws AssertionException

Asserts that the given Class has the abstract modifier (implicitly or explicitly). The Java Language Specification defines that interfaces are implicitly abstract.

Parameters:

c - The Class to assert has the abstract modifier (implicitly or explicitly).

message - The assertion message.

Throws:

AssertionException - If the Class does not have the abstract modifier (implicitly or explicitly).

assertNotAbstract

public static void assertNotAbstract(Class<?> c,
                                     Object... message)
                              throws AssertionException

Asserts that the given Class does not have the abstract modifier (implicitly or explicitly). The Java Language Specification defines that interfaces are implicitly abstract.

Parameters:

c - The Class to assert does not have the abstract modifier (implicitly or explicitly).

message - The assertion message.

Throws:

AssertionException - If the Class has the abstract modifier (implicitly or explicitly).

assertFinal

public static void assertFinal(Method m,
                               Object... message)
                        throws AssertionException

Asserts that the given Method has the final modifier.

Parameters:

m - The Method to assert has the final modifier.

message - The assertion message.

Throws:

AssertionException - If the Method does not have the final modifier.

assertNotFinal

public static void assertNotFinal(Method m,
                                  Object... message)
                           throws AssertionException

Asserts that the given Method does not have the final modifier.

Parameters:

m - The Method to assert does not have the final modifier.

message - The assertion message.

Throws:

AssertionException - If the Method has the final modifier.

assertFinal

public static void assertFinal(Class<?> c,
                               Object... message)
                        throws AssertionException

Asserts that the given Class has the final modifier (implicitly or explicitly). The Java Language Specification defines that inner classes of interfaces, and enums are implicitly final.

Parameters:

c - The Class to assert has the final modifier (implicitly or explicitly).

message - The assertion message.

Throws:

AssertionException - If the Class does not have the final modifier (implicitly or explicitly).

assertNotFinal

public static void assertNotFinal(Class<?> c,
                                  Object... message)
                           throws AssertionException

Asserts that the given Class does not have the final modifier (implicitly or explicitly). The Java Language Specification defines that inner classes of interfaces, and enums are implicitly final.

Parameters:

c - The Class to assert does not have the final modifier (implicitly or explicitly).

message - The assertion message.

Throws:

AssertionException - If the Class has the final modifier (implicitly or explicitly).

assertFinal

public static void assertFinal(Field f,
                               Object... message)
                        throws AssertionException

Asserts that the given Field has the final modifier (implicitly or explicitly). The Java Language Specification defines that interface fields are implicitly final.

Parameters:

f - The Field to assert has the final modifier.

message - The assertion message.

Throws:

AssertionException - If the Field does not have the final modifier (implicitly or explicitly).

assertNotFinal

public static void assertNotFinal(Field f,
                                  Object... message)
                           throws AssertionException

Asserts that the given Field does not have the final modifier (implicitly or explicitly). The Java Language Specification defines that interface fields are implicitly final.

Parameters:

f - The Field to assert does not have the final modifier.

message - The assertion message.

Throws:

AssertionException - If the Field has the final modifier (implicitly or explicitly).

assertNative

public static void assertNative(Method m,
                                Object... message)
                         throws AssertionException

Asserts that the given Method has the native modifier.

Parameters:

m - The Method to assert has the native modifier.

message - The assertion message.

Throws:

AssertionException - If the Method does not have the native modifier.

assertNotNative

public static void assertNotNative(Method m,
                                   Object... message)
                            throws AssertionException

Asserts that the given Method does not have the native modifier.

Parameters:

m - The Method to assert does not have the native modifier.

message - The assertion message.

Throws:

AssertionException - If the Method has the native modifier.

assertPrivate

public static void assertPrivate(Method m,
                                 Object... message)
                          throws AssertionException

Asserts that the given Method has the private modifier.

Parameters:

m - The Method to assert has the private modifier.

message - The assertion message.

Throws:

AssertionException - If the Method does not have the private modifier.

assertNotPrivate

public static void assertNotPrivate(Method m,
                                    Object... message)
                             throws AssertionException

Asserts that the given Method does not have the private modifier.

Parameters:

m - The Method to assert does not have the private modifier.

message - The assertion message.

Throws:

AssertionException - If the Method has the private modifier.

assertPrivate

public static void assertPrivate(Constructor<?> c,
                                 Object... message)
                          throws AssertionException

Asserts that the given Constructor has the private modifier (implicitly or explicitly). The Java Language Specification defines that enum constructors are implicitly private.

Parameters:

c - The Constructor to assert has the private modifier.

message - The assertion message.

Throws:

AssertionException - If the Constructor does not have the private modifier (implicitly or explicitly).

assertNotPrivate

public static void assertNotPrivate(Constructor<?> c,
                                    Object... message)
                             throws AssertionException

Asserts that the given Constructor does not have the private modifier (implicitly or explicitly). The Java Language Specification defines that enum constructors are implicitly private.

Parameters:

c - The Constructor to assert does not have the private modifier.

message - The assertion message.

Throws:

AssertionException - If the Constructor has the private modifier (implicitly or explicitly).

assertPrivate

public static void assertPrivate(Class<?> c,
                                 Object... message)
                          throws AssertionException

Asserts that the given Class has the private modifier.

Parameters:

c - The Class to assert has the private modifier.

message - The assertion message.

Throws:

AssertionException - If the Class does not have the private modifier.

assertNotPrivate

public static void assertNotPrivate(Class<?> c,
                                    Object... message)
                             throws AssertionException

Asserts that the given Class does not have the private modifier.

Parameters:

c - The Class to assert does not have the private modifier.

message - The assertion message.

Throws:

AssertionException - If the Class has the private modifier.

assertPrivate

public static void assertPrivate(Field f,
                                 Object... message)
                          throws AssertionException

Asserts that the given Field has the private modifier (implicitly or explicitly). The Java Language Specification defines that interface fields are implicitly private.

Parameters:

f - The Field to assert has the private modifier.

message - The assertion message.

Throws:

AssertionException - If the Field does not have the private modifier (implicitly or explicitly).

assertNotPrivate

public static void assertNotPrivate(Field f,
                                    Object... message)
                             throws AssertionException

Asserts that the given Field does not have the private modifier (implicitly or explicitly). The Java Language Specification defines that interface fields are implicitly private.

Parameters:

f - The Field to assert does not have the private modifier.

message - The assertion message.

Throws:

AssertionException - If the Field has the private modifier (implicitly or explicitly).

assertProtected

public static void assertProtected(Method m,
                                   Object... message)
                            throws AssertionException

Asserts that the given Method has the protected modifier.

Parameters:

m - The Method to assert has the protected modifier.

message - The assertion message.

Throws:

AssertionException - If the Method does not have the protected modifier.

assertNotProtected

public static void assertNotProtected(Method m,
                                      Object... message)
                               throws AssertionException

Asserts that the given Method does not have the protected modifier.

Parameters:

m - The Method to assert does not have the protected modifier.

message - The assertion message.

Throws:

AssertionException - If the Method has the protected modifier.

assertProtected

public static void assertProtected(Constructor<?> c,
                                   Object... message)
                            throws AssertionException

Asserts that the given Constructor has the protected modifier.

Parameters:

c - The Constructor to assert has the protected modifier.

message - The assertion message.

Throws:

AssertionException - If the Constructor does not have the protected modifier.

assertNotProtected

public static void assertNotProtected(Constructor<?> c,
                                      Object... message)
                               throws AssertionException

Asserts that the given Constructor does not have the protected modifier.

Parameters:

c - The Constructor to assert does not have the protected modifier.

message - The assertion message.

Throws:

AssertionException - If the Constructor has the protected modifier.

assertProtected

public static void assertProtected(Class<?> c,
                                   Object... message)
                            throws AssertionException

Asserts that the given Class has the protected modifier.

Parameters:

c - The Class to assert has the protected modifier.

message - The assertion message.

Throws:

AssertionException - If the Class does not have the protected modifier.

assertNotProtected

public static void assertNotProtected(Class<?> c,
                                      Object... message)
                               throws AssertionException

Asserts that the given Class does not have the protected modifier.

Parameters:

c - The Class to assert does not have the protected modifier.

message - The assertion message.

Throws:

AssertionException - If the Class has the protected modifier.

assertProtected

public static void assertProtected(Field f,
                                   Object... message)
                            throws AssertionException

Asserts that the given Field has the protected modifier.

Parameters:

f - The Field to assert has the protected modifier.

message - The assertion message.

Throws:

AssertionException - If the Field does not have the protected modifier.

assertNotProtected

public static void assertNotProtected(Field f,
                                      Object... message)
                               throws AssertionException

Asserts that the given Field does not have the protected modifier.

Parameters:

f - The Field to assert does not have the protected modifier.

message - The assertion message.

Throws:

AssertionException - If the Field has the protected modifier.

assertPublic

public static void assertPublic(Method m,
                                Object... message)
                         throws AssertionException

Asserts that the given Method has the public modifier (implicitly or explicitly). The Java Language Specification defines that interface methods are implicitly public.

Parameters:

m - The Method to assert has the public modifier.

message - The assertion message.

Throws:

AssertionException - If the Method does not have the public modifier (implicitly or explicitly).

assertNotPublic

public static void assertNotPublic(Method m,
                                   Object... message)
                            throws AssertionException

Asserts that the given Method does not have the public modifier (implicitly or explicitly). The Java Language Specification defines that interface methods are implicitly public.

Parameters:

m - The Method to assert does not have the public modifier.

message - The assertion message.

Throws:

AssertionException - If the Method has the public modifier (implicitly or explicitly).

assertPublic

public static void assertPublic(Constructor<?> c,
                                Object... message)
                         throws AssertionException

Asserts that the given Constructor has the public modifier.

Parameters:

c - The Constructor to assert has the public modifier.

message - The assertion message.

Throws:

AssertionException - If the Constructor does not have the public modifier.

assertNotPublic

public static void assertNotPublic(Constructor<?> c,
                                   Object... message)
                            throws AssertionException

Asserts that the given Constructor does not have the public modifier.

Parameters:

c - The Constructor to assert does not have the public modifier.

message - The assertion message.

Throws:

AssertionException - If the Constructor has the public modifier.

assertPublic

public static void assertPublic(Class<?> c,
                                Object... message)
                         throws AssertionException

Asserts that the given Class has the public modifier (implicitly or explicitly). The Java Language Specification defines that inner classes of interfaces are implicitly public.

Parameters:

c - The Class to assert has the public modifier.

message - The assertion message.

Throws:

AssertionException - If the Class does not have the public modifier (implicitly or explicitly).

assertNotPublic

public static void assertNotPublic(Class<?> c,
                                   Object... message)
                            throws AssertionException

Asserts that the given Class does not have the public modifier (implicitly or explicitly). The Java Language Specification defines that inner classes of interfaces are implicitly public.

Parameters:

c - The Class to assert does not have the public modifier.

message - The assertion message.

Throws:

AssertionException - If the Class has the public modifier (implicitly or explicitly).

assertPublic

public static void assertPublic(Field f,
                                Object... message)
                         throws AssertionException

Asserts that the given Field has the public modifier (implicitly or explicitly). The Java Language Specification defines that interface fields are implicitly public.

Parameters:

f - The Field to assert has the public modifier.

message - The assertion message.

Throws:

AssertionException - If the Field does not have the public modifier (implicitly or explicitly).

assertNotPublic

public static void assertNotPublic(Field f,
                                   Object... message)
                            throws AssertionException

Asserts that the given Field does not have the public modifier (implicitly or explicitly). The Java Language Specification defines that interface fields are implicitly public.

Parameters:

f - The Field to assert does not have the public modifier.

message - The assertion message.

Throws:

AssertionException - If the Field has the public modifier (implicitly or explicitly).

assertDefaultAccess

public static void assertDefaultAccess(Method m,
                                       Object... message)
                                throws AssertionException

Asserts that the given Method has the default (none specified) access modifier.

Parameters:

m - The Method to assert has the default (none specified) access modifier.

message - The assertion message.

Throws:

AssertionException - If the Method has an explicit access modifier (private, protected, or public).

assertNotDefaultAccess

public static void assertNotDefaultAccess(Method m,
                                          Object... message)
                                   throws AssertionException

Asserts that the given Method does not have the default (none specified) access modifier.

Parameters:

m - The Method to assert does not have the default (none specified) access modifier.

message - The assertion message.

Throws:

AssertionException - If the Method does not have an explicit access modifier (private, protected, or public).

assertDefaultAccess

public static void assertDefaultAccess(Constructor<?> c,
                                       Object... message)
                                throws AssertionException

Asserts that the given Constructor has the default (none specified) access modifier.

Parameters:

c - The Constructor to assert has the default (none specified) access modifier.

message - The assertion message.

Throws:

AssertionException - If the Constructor has an explicit access modifier (private, protected, or public).

assertNotDefaultAccess

public static void assertNotDefaultAccess(Constructor<?> c,
                                          Object... message)
                                   throws AssertionException

Asserts that the given Constructor does not have the default (none specified) access modifier.

Parameters:

c - The Constructor to assert does not have the default (none specified) access modifier.

message - The assertion message.

Throws:

AssertionException - If the Constructor does not have an explicit access modifier (private, protected, or public).

assertDefaultAccess

public static void assertDefaultAccess(Class<?> c,
                                       Object... message)
                                throws AssertionException

Asserts that the given Class has the default (none specified) access modifier.

Parameters:

c - The Class to assert has the default (none specified) access modifier.

message - The assertion message.

Throws:

AssertionException - If the Class has an explicit access modifier (private, protected, or public).

assertNotDefaultAccess

public static void assertNotDefaultAccess(Class<?> c,
                                          Object... message)
                                   throws AssertionException

Asserts that the given Class does not have the default (none specified) access modifier.

Parameters:

c - The Class to assert does not have the default (none specified) access modifier.

message - The assertion message.

Throws:

AssertionException - If the Class does not have an explicit access modifier (private, protected, or public).

assertDefaultAccess

public static void assertDefaultAccess(Field f,
                                       Object... message)
                                throws AssertionException

Asserts that the given Field has the default (none specified) access modifier.

Parameters:

f - The Field to assert has the default (none specified) access modifier.

message - The assertion message.

Throws:

AssertionException - If the Field has an explicit access modifier (private, protected, or public).

assertNotDefaultAccess

public static void assertNotDefaultAccess(Field f,
                                          Object... message)
                                   throws AssertionException

Asserts that the given Field does not have the default (none specified) access modifier.

Parameters:

f - The Field to assert does not have the default (none specified) access modifier.

message - The assertion message.

Throws:

AssertionException - If the Field does not have an explicit access modifier (private, protected, or public).

assertStatic

public static void assertStatic(Method m,
                                Object... message)
                         throws AssertionException

Asserts that the given Method has the static modifier.

Parameters:

m - The Method to assert has the static modifier.

message - The assertion message.

Throws:

AssertionException - If the Method does not have the static modifier.

assertNotStatic

public static void assertNotStatic(Method m,
                                   Object... message)
                            throws AssertionException

Asserts that the given Method does not have the static modifier.

Parameters:

m - The Method to assert does not have the static modifier.

message - The assertion message.

Throws:

AssertionException - If the Method has the static modifier.

assertStatic

public static void assertStatic(Class<?> c,
                                Object... message)
                         throws AssertionException

Asserts that the given Class has the static modifier (implicitly or explicitly). The Java Language Specification defines that inner classes of interfaces are implicitly static.

Parameters:

c - The Class to assert has the static modifier.

message - The assertion message.

Throws:

AssertionException - If the Class does not have the static modifier (implicitly or explicitly).

assertNotStatic

public static void assertNotStatic(Class<?> c,
                                   Object... message)
                            throws AssertionException

Asserts that the given Class does not have the static modifier (implicitly or explicitly). The Java Language Specification defines that inner classes of interfaces are implicitly static.

Parameters:

c - The Class to assert does not have the static modifier.

message - The assertion message.

Throws:

AssertionException - If the Class has the static modifier (implicitly or explicitly).

assertStatic

public static void assertStatic(Field f,
                                Object... message)
                         throws AssertionException

Asserts that the given Field has the static modifier (implicitly or explicitly). The Java Language Specification defines that interface fields are implicitly static.

Parameters:

f - The Field to assert has the static modifier.

message - The assertion message.

Throws:

AssertionException - If the Field does not have the static modifier (implicitly or explicitly).

assertNotStatic

public static void assertNotStatic(Field f,
                                   Object... message)
                            throws AssertionException

Asserts that the given Field does not have the static modifier (implicitly or explicitly). The Java Language Specification defines that interface fields are implicitly static.

Parameters:

f - The Field to assert does not have the static modifier.

message - The assertion message.

Throws:

AssertionException - If the Field has the static modifier (implicitly or explicitly).

assertStrictfp

public static void assertStrictfp(Class<?> c,
                                  Object... message)
                           throws AssertionException

Asserts that the given Class has the strictfp modifier (implicitly or explicitly). The Java Language Specification defines that methods and all nested types of a strictfp class are implicitly strictfp.

Parameters:

c - The Class to assert has the strictfp modifier.

message - The assertion message.

Throws:

AssertionException - If the Class does not have the strictfp modifier (implicitly or explicitly).

assertNotStrictfp

public static void assertNotStrictfp(Class<?> c,
                                     Object... message)
                              throws AssertionException

Asserts that the given Class does not have the strictfp modifier (implicitly or explicitly). The Java Language Specification defines that methods and all nested types of a strictfp class are implicitly strictfp.

Parameters:

c - The Class to assert does not have the strictfp modifier.

message - The assertion message.

Throws:

AssertionException - If the Class has the strictfp modifier (implicitly or explicitly).

assertSynchronized

public static void assertSynchronized(Method m,
                                      Object... message)
                               throws AssertionException

Asserts that the given Method has the synchronized modifier.

Parameters:

m - The Method to assert has the synchronized modifier.

message - The assertion message.

Throws:

AssertionException - If the Method does not have the synchronized modifier.

assertNotSynchronized

public static void assertNotSynchronized(Method m,
                                         Object... message)
                                  throws AssertionException

Asserts that the given Method does not have the synchronized modifier.

Parameters:

m - The Method to assert does not have the synchronized modifier.

message - The assertion message.

Throws:

AssertionException - If the Method has the synchronized modifier.

assertTransient

public static void assertTransient(Field f,
                                   Object... message)
                            throws AssertionException

Asserts that the given Field has the transient modifier.

Parameters:

f - The Field to assert has the transient modifier.

message - The assertion message.

Throws:

AssertionException - If the Field does not have the transient modifier.

assertNotTransient

public static void assertNotTransient(Field f,
                                      Object... message)
                               throws AssertionException

Asserts that the given Field does not have the transient modifier.

Parameters:

f - The Field to assert does not have the transient modifier.

message - The assertion message.

Throws:

AssertionException - If the Field has the transient modifier.

assertVolatile

public static void assertVolatile(Field f,
                                  Object... message)
                           throws AssertionException

Asserts that the given Field has the volatile modifier.

Parameters:

f - The Field to assert has the volatile modifier.

message - The assertion message.

Throws:

AssertionException - If the Field does not have the volatile modifier.

assertNotVolatile

public static void assertNotVolatile(Field f,
                                     Object... message)
                              throws AssertionException

Asserts that the given Field does not have the volatile modifier.

Parameters:

f - The Field to assert does not have the volatile modifier.

message - The assertion message.

Throws:

AssertionException - If the Field has the volatile modifier.