Makefile usage:

"make verify" verifies serializable compatibility of the current JAVA release
against a REFERENCE Java release.  See "make setup" below to see how
to generate a new REFERENCE file.

The following command line specifies which java to verify the 
REFERENCE against. By default, the java that is current on the path is
used to verify the REFERENCE against.

   make verify JAVABIN=<path to java to verify>


To specify a different java release to use as a REFERENCE to verify 
serializable compatibility against.

   make verify REFERENCE=JDK1_1_4.ref


Generates a reference file to verify against.

   make setup REFERENCE=JDK1_2_<release#>.ref JAVABIN=<path to java release#>

Note:  JDK1_2_#.ref files should be generated from a JDK1.2.* release.
       The JDK 1.2 SerialVerify will generate reference files 
       that reflect a class that overrides the default Serializable
       Persistent Fields.

****************

SerialVerify README info

As the Serialization specification notes, when java objects use Serialization 
to save state, the potential arises that the version of a class reading the 
data is different than the version that wrote the data.

WHAT THE PROGRAM DOES:
The SerialVerify program can be used to see what changes a class has made when 
it evolved and whether these changes are considered compatible or incompatible
in terms of assuring interoperability between the two versions of the class.

The program first checks for changes in the SerialVersionUID. Serializable 
Classes that are different versions of each other must have the same SUID. The
evolved class, therefore, must declaring a serialVersionUID field, whose value
is the original class's serialVerisonUID. 

The incompatible changes that the program checks for and reports:
     1. Deleted persistent fields (including changing the field from being
	non-static to static, or non-transient to transient)
     2. Changing the type of a field
     3. Changing from Serializable to Externalizable or visa-versa
     4. Removing Serializable or Externalizable
     5. Moving classes up or down the hierarchy 

The compatible changes that the program checks for and reports:

     1. Added Persistent fields (including changing the field from being
	static to non-static, or transient to non-transient)
     2. Added Superclasses
     3. Deleted Superclasses


HOW TO USE THE PROGRAM:

The SerialVerify program needs to be first used to setup a file that contains 
the relevant information about the original classe(s). Then, when it is run
with the verify flag, the program will compare the contents of this file with
the evolved classe(s) to write out the compatible and incompatible changes that
have taken place.

         [-v] -setup filename  packagename/classname [packagename/classname ..] 
         [-v] [-i | -l] -verify filename 
                  
         -v ---> verbose mode.
         -i ---> only check for illegal (incompatible) changes.
         -l ---> only check for legal (compatible) changes.
         the default is to check for both legal and illegal changes.

Example 1 of usage:

So suppose I have a class called MyClass in a package called MyPackage, I can
use the program as follows:

      SerialVerify -setup MyInfoFile MyPackage.MyClass

This will put the relevant information about MyClass in MyInfoFile.

Then, after MyClass has evolved, I can see what changes have been made and 
whether they are compatible or incompatible as follows:

     SerialVerify -verify MyInfoFile.

Example 2 of usage:

So suppose I wanted to check all classes in package java for changes between 
JDK1.1 and JDK1.2:

       1. First I would set my classpath to use JDK1.1
       2. SerialVerify -v -setup javainfofile java
       3. Set the classpath to use JDK1.2
       4. SerialVerify -v -verify javainfofile

       This will print out both legal and illegal changes that have been made
       in the evolution of classes from JDK1.1 to JDK1.2.

Example 3 of usage:

Supposed I wanted to do java.util.Hashtable class and all the classes 
java.lang package

	change the classpath to original java you want to use.	
	1. SerialVerify -v -setup myfile java.util.Hashtable java.lang

	change the classpath to the new java you want to use.
	2. SerialVerify -v -verify myfile 
