org.jtiger.assertion
Class Modifier

java.lang.Object
  extended by 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.