1 // Tags: JDK1.1

     2 

     3 // Copyright (C) 2005 Daniel Bonniot <bonniot@users.sf.net>

     4 

     5 // This file is part of Mauve.

     6 

     7 // Mauve is free software; you can redistribute it and/or modify

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

     9 // the Free Software Foundation; either version 2, or (at your option)

    10 // any later version.

    11 

    12 // Mauve is distributed in the hope that it will be useful,

    13 // but WITHOUT ANY WARRANTY; without even the implied warranty of

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

    15 // GNU General Public License for more details.

    16 

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

    18 // along with Mauve; see the file COPYING.  If not, write to

    19 // the Free Software Foundation, 59 Temple Place - Suite 330,

    20 // Boston, MA 02111-1307, USA.  */

    21 

    22 package gnu.testlet.java.io.Serializable;

    23 

    24 import gnu.testlet.TestHarness;

    25 import gnu.testlet.Testlet;

    26 

    27 import java.io.ByteArrayInputStream;

    28 import java.io.ByteArrayOutputStream;

    29 import java.io.ObjectInputStream;

    30 import java.io.ObjectOutputStream;

    31 

    32 /**

    33  * Check when a parent readResolve() method should be used for subclasses.

    34  *

    35  * Here is the rationale for this test, based on Sun's javadoc for

    36  * java.io.Serializable:

    37  *

    38  * First, readResolve must be declared with:

    39  *   ANY-ACCESS-MODIFIER Object readResolve() throws ObjectStreamException;

    40  * Thus, a non-private readResolve is OK.

    41  *

    42  * Second, the rules for invoking readResolve (as for writeReplace) are that

    43  * it must be called if it would be accessible from the class of the object

    44  * being deserialized. So, a non-private readSolve method in the parent must

    45  * be called, but a private one should not be.

    46  */

    47 public class ParentReadResolve implements Testlet {

    48 

    49   public void test(TestHarness harness)

    50   {

    51     try {

    52       ByteArrayOutputStream outb = new ByteArrayOutputStream();

    53       ObjectOutputStream outs = new ObjectOutputStream(outb);

    54 

    55       outs.writeObject(MySingleton.instance);

    56       outs.writeObject(new MyFoo());

    57 

    58       byte[] store = outb.toByteArray();

    59 

    60       ByteArrayInputStream inb = new ByteArrayInputStream(store);

    61       ObjectInputStream ins = new ObjectInputStream(inb);

    62 

    63       MySingleton x = (MySingleton) ins.readObject();

    64       harness.check(x == MySingleton.instance);

    65 

    66       MyFoo foo = (MyFoo) ins.readObject();

    67       harness.check(! foo.resolved);

    68     }

    69     catch (Throwable e) {

    70       harness.debug(e);

    71     }

    72   }

    73 

    74   //// Singleton/MySingleton with a non-private readResolve ////

    75 

    76   static abstract class Singleton implements java.io.Serializable

    77   {

    78     abstract Singleton getInstance();

    79 

    80     /** NOTE: this readResolve is not private.

    81      */

    82     Object readResolve() {

    83       return getInstance();

    84     }

    85   }

    86 

    87   static class MySingleton extends Singleton

    88   {

    89     static final MySingleton instance = new MySingleton();

    90 

    91     Singleton getInstance() { return instance; }

    92   }

    93 

    94   //// Foo/MyFoo with a private readResolve ////

    95 

    96   static abstract class Foo implements java.io.Serializable

    97   {

    98     boolean resolved = false;

    99 

   100     /** NOTE: this readResolve is private.

   101      */

   102     private Object readResolve() {

   103       resolved = true;

   104       return this;

   105     }

   106   }

   107 

   108   static class MyFoo extends Foo

   109   {

   110   }

   111 }