Subversion Repositories scarts

/*************************************************************************

/* ObjectStreamClassTest.java -- Tests ObjectStreamClass class

/*

/* Copyright (c) 1998 by Free Software Foundation, Inc.

/*

/* This program is free software; you can redistribute it and/or modify

/* it under the terms of the GNU General Public License as published

/* by the Free Software Foundation, version 2. (see COPYING)

/*

/* This program is distributed in the hope that it will be useful, but

/* WITHOUT ANY WARRANTY; without even the implied warranty of

/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

/* GNU General Public License for more details.

/*

/* You should have received a copy of the GNU General Public License

/* along with this program; if not, write to the Free Software Foundation

/* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA

/*************************************************************************/

import java.io.Externalizable;

import java.io.ObjectInput;

import java.io.ObjectOutput;

import java.io.ObjectOutputStream;

import java.io.ObjectStreamClass;

import java.io.Serializable;

import java.util.Hashtable;

import java.util.Vector;

public class ObjectStreamClassTest

{

  public static void pass()

  {

    System.out.print( "PASSED: " );

  }

  public static void fail()

  {

    System.out.print( "FAILED: " );

  }

  public static void pass( boolean exp_pass )

  {

    if( exp_pass )

      pass();

    else

      System.out.print( "XPASSED: " );

  }

  public static void fail( boolean exp_pass )

  {

    if( exp_pass )

      fail();

    else

      System.out.print( "XFAIL: " );

  }

  public static void testLookup( Class cl, boolean non_null )

  {

    if( non_null == (ObjectStreamClass.lookup( cl ) != null) )

      pass();

    else

      fail();

    System.out.println( "lookup() for " + cl );

  }

  public static void testGetName( Class cl, String name )

  {

    if( ObjectStreamClass.lookup( cl ).getName().equals( name ) )

      pass();

    else

      fail();

    System.out.println( "getName() for " + cl );

  }

  public static void testForClass( Class cl, Class clazz )

  {

    if( ObjectStreamClass.lookup( cl ).forClass() == clazz )

      pass();

    else

      fail();

    System.out.println( "forClass() for " + cl );

  }

  public static void testSUID( Class cl, long suid )

  {

    testSUID( cl, suid, true );

  }

  public static void testSUID( Class cl, long suid, boolean exp_pass )

  {

    if( ObjectStreamClass.lookup( cl ).getSerialVersionUID() == suid )

      pass( exp_pass );

    else

      fail( exp_pass );

    System.out.println( "getSerialVersionUID() for " + cl );

  }

  public static void testHasWrite( Class cl, boolean has_write )

  {

    if( ObjectStreamClass.lookup( cl ).hasWriteMethod() == has_write )

      pass();

    else

      fail();

    System.out.println( "hasWriteMethod() for " + cl );

  }

  public static void testIsSerial( Class cl, boolean is_serial )

  {

    if( ObjectStreamClass.lookup( cl ).isSerializable() == is_serial )

      pass();

    else

      fail();

    System.out.println( "isSerializable() for " + cl );

  }

  public static void testIsExtern( Class cl, boolean is_extern )

  {

    if( ObjectStreamClass.lookup( cl ).isExternalizable() == is_extern )

      pass();

    else

      fail();

    System.out.println( "isExternalizable() for " + cl );

  }

  public static void main( String[] args )

  {

    try

    {

      // lookup

      testLookup( Serial.class, true );

      testLookup( NotSerial.class, false );

      // getName

      testGetName( java.lang.String.class, "java.lang.String" );

      testGetName( java.util.Hashtable.class, "java.util.Hashtable" );

      // forClass

      testForClass( java.lang.String.class, java.lang.String.class );

      testForClass( java.util.Vector.class, (new Vector()).getClass() );

      // getSerialVersionUID

      testSUID( A.class, 1577839372146469075L );

      testSUID( B.class, -7069956958769787679L );

      // NOTE: this fails for JDK 1.1.5v5 on linux because a non-null

      // jmethodID is returned from

      // GetStaticMethodID( env, C, "<clinit>", "()V" )

      // even though class C does not have a class initializer.

      // The JDK's serialver tool does not have this problem somehow.

      // I have not tested this on other platforms.

      testSUID( C.class, 7441756018870420732L, false );

      testSUID( Defined.class, 17 );

      testSUID( DefinedNotStatic.class, 8797806279193632512L );

      testSUID( DefinedNotFinal.class, -1014973327673071657L );

      // hasWriteMethod

      testHasWrite( Serial.class, false );

      testHasWrite( HasWrite.class, true );

      testHasWrite( InherWrite.class, false );

      testHasWrite( PubWrite.class, false );

      testHasWrite( StaticWrite.class, false );

      testHasWrite( ReturnWrite.class, false );

      // isSerializable

      testIsSerial( Serial.class, true );

      testIsSerial( Extern.class, false );

      testIsSerial( InherSerial.class, true );

      testIsSerial( InherExtern.class, false );

      // isExternalizable

      testIsExtern( Serial.class, false );

      testIsExtern( Extern.class, true );

      testIsExtern( InherSerial.class, false );

      testIsExtern( InherExtern.class, true );

    }

    catch( Exception e )

    {

      e.printStackTrace();

    }

  }

}

class NotSerial {}

class A implements Serializable

{

  int b;

  int a;

  public int f() { return 0; }

  float g() { return 3; }

  private float c;

}

abstract class B extends A

{

  private B( int[] ar ) {}

  public B() {}

  public static void foo() {}

  public abstract void absfoo();

  private static String s;

  public int[] a;

  static

  {

    s = "hello";

  }

}

class C extends B implements Cloneable, Externalizable

{

  public void absfoo() {}

  public void readExternal( ObjectInput i ) {}

  public void writeExternal( ObjectOutput o ) {}

}

class Defined implements Serializable

{

  static final long serialVersionUID = 17;

}

class DefinedNotStatic implements Serializable

{

  final long serialVersionUID = 17;

}

class DefinedNotFinal implements Serializable

{

  static long serialVersionUID = 17;

}

class HasWrite implements Serializable

{

  private void writeObject( ObjectOutputStream o ) {}

}

class InherWrite extends HasWrite {}

class PubWrite implements Serializable

{

  public void writeObject( ObjectOutputStream o ) {}

}

class StaticWrite implements Serializable

{

  private static void writeObject( ObjectOutputStream o ) {}

}

class ReturnWrite implements Serializable

{

  private int writeObject( ObjectOutputStream o )

  {

    return -1;

  }

}

class Serial implements Serializable {}

class Extern implements Externalizable

{

  public void readExternal( ObjectInput i )

  {}

  public void writeExternal( ObjectOutput o )

  {}

}

class InherExtern extends Extern implements Serializable {}

class InherSerial extends Serial {}