Name: tb29552 Date: 08/13/97


company - University Of Michigan , email - ###@###.###

It would be really nice if there were
an assert-like function or macro (or at least
the compiler features that would let me write
one).

======================================================================

ronan.mandel@Eng 1997-12-01
Here is a proposal for java syntax enhancement for assertions:

The success of the Design by Contract principal upon which the assertion mechanism is founded is now well known.
I feel stongly that the Java development process would benefit enormously from such an extension.
Much more so than for, say, inner or generic classes.
(As much as I love inner classes, they do little to assist the runtime robustness of software.)

public class FooClass
{
  invariant // maximum one invariant clause per method
  { // Invariant predicates here.
     // This supplements (strengthens) the invariant
     // (if any) from the superclass
  }

  public FooClass(...)
  { // Superclass's pre-conditions (if any) inherited here
     // but may be overridden as in Eiffel's "require else"
     
     super(...); // call superclass's constructor-body

     // Body of constructor here...

     // Superclass's post-conditions (if any) inherited here
     // but may be supplemented (strengthened)
  }

  public void foo(...)
  { require // maximum one require clause per method
    { // Pre-condition predicates here e.g.
      assert( x > 0 );
      assert( a + b == c );
    };

    // Body of method here

    ensure // maximum one ensure clause per method
    { // Post-condition predicates here e.g.
      assert( y == log(x) * 4 ) throw AlternativeException("xxx");
      System.out.println("Debugging comment");
    };
  }
}

The following exceptions are thrown according to which kind of assertion fails:

public PreconditionException extends Error {...}
public PostconditionException extends Error {...}
public InvariantException extends Error {...}

The "assert" statement could optionally be augmented with a "throw SomeException" part, where SomeException
 extends one of the three exceptions given here.

Of course, require, ensure and invariant constructs are optional, although they are inherited automatically
(if present in the superclass). At runtime it should be possible to turn them off individually as required, on a
program and/or package basis. The ability to include any java construct in the clauses (not just predicates)
would be a huge plus for testers.

Perhaps even more importantly than for classes, Java interfaces could also be enhanced with require and ensure clauses.
The following syntax may not appeal to java folk, however, because of the "pseudo-body" added to the method signiture:

public interface xxx
{
   invariant
   { assert( checkA() );
   }

   public boolean checkA();
   public boolean checkB();
   public boolean checkC();

   public void yyy(...)
   { require
     { assert (checkB());
     };
     // Of course, no body allowed!
     ensure
     { assert (checkC());
     };
   }
}

I would be grateful for any feedback regarding this proposed feature.

Yours sincerely

Mike Mannion