libcore/luni/src/test/java/tests/api/java/io/ObjectStreamClassTest.java

   1 /*
   2  *  Licensed to the Apache Software Foundation (ASF) under one or more
   3  *  contributor license agreements.  See the NOTICE file distributed with
   4  *  this work for additional information regarding copyright ownership.
   5  *  The ASF licenses this file to You under the Apache License, Version 2.0
   6  *  (the "License"); you may not use this file except in compliance with
   7  *  the License.  You may obtain a copy of the License at
   8  *
   9  *     http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  *  Unless required by applicable law or agreed to in writing, software
  12  *  distributed under the License is distributed on an "AS IS" BASIS,
  13  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  *  See the License for the specific language governing permissions and
  15  *  limitations under the License.
  16  */
  17
  18 package tests.api.java.io;
  19
  20 import java.io.File;
  21 import java.io.Externalizable;
  22 import java.io.IOException;
  23 import java.io.ObjectInput;
  24 import java.io.ObjectOutput;
  25 import java.io.ObjectStreamClass;
  26 import java.io.ObjectStreamField;
  27 import java.io.Serializable;
  28 import java.net.URL;
  29 import java.net.URLClassLoader;
  30 import java.lang.reflect.Proxy;
  31
  32 import junit.framework.TestCase;
  33
  34 public class ObjectStreamClassTest extends TestCase {
  35
  36     static class DummyClass implements Serializable {
  37         private static final long serialVersionUID = 999999999999999L;
  38
  39         long bam = 999L;
  40
  41         int ham = 9999;
  42
  43                 public static long getUID() {
  44                         return serialVersionUID;
  45                 }
  46         }
  47
  48     /**
  49      * @tests java.io.ObjectStreamClass#forClass()
  50      */
  51     public void test_forClass() {
  52         // Need to test during serialization to be sure an instance is
  53         // returned
  54         ObjectStreamClass osc = ObjectStreamClass.lookup(DummyClass.class);
  55         assertEquals("forClass returned an object: " + osc.forClass(),
  56                 DummyClass.class, osc.forClass());
  57     }
  58
  59     /**
  60      * @tests java.io.ObjectStreamClass#getField(java.lang.String)
  61      */
  62     public void test_getFieldLjava_lang_String() {
  63         ObjectStreamClass osc = ObjectStreamClass.lookup(DummyClass.class);
  64         assertEquals("getField did not return correct field", 'J', osc
  65                 .getField("bam").getTypeCode());
  66         assertNull("getField did not null for non-existent field", osc
  67                 .getField("wham"));
  68     }
  69
  70     /**
  71      * @tests java.io.ObjectStreamClass#getFields()
  72      */
  73     public void test_getFields() {
  74         ObjectStreamClass osc = ObjectStreamClass.lookup(DummyClass.class);
  75         ObjectStreamField[] osfArray = osc.getFields();
  76         assertTrue(
  77                 "Array of fields should be of length 2 but is instead of length: "
  78                         + osfArray.length, osfArray.length == 2);
  79     }
  80
  81     /**
  82      * @tests java.io.ObjectStreamClass#getName()
  83      */
  84     public void test_getName() {
  85         ObjectStreamClass osc = ObjectStreamClass.lookup(DummyClass.class);
  86         assertEquals(
  87                 "getName returned incorrect name: " + osc.getName(),
  88                 "tests.api.java.io.ObjectStreamClassTest$DummyClass", // android-changed
  89                 osc.getName());
  90     }
  91
  92     /**
  93      * @tests java.io.ObjectStreamClass#getSerialVersionUID()
  94      */
  95     public void test_getSerialVersionUID() {
  96         ObjectStreamClass osc = ObjectStreamClass.lookup(DummyClass.class);
  97         assertTrue("getSerialversionUID returned incorrect uid: "
  98                 + osc.getSerialVersionUID() + " instead of "
  99                 + DummyClass.getUID(), osc.getSerialVersionUID() == DummyClass
 100                 .getUID());
 101     }
 102
 103     static class SyntheticTest implements Serializable {
 104         private int i;
 105
 106         private class X implements Serializable {
 107             public int get() {
 108                 return i;
 109             }
 110         }
 111
 112         public X foo() {
 113             return new X();
 114         }
 115     }
 116
 117     /**
 118      * @tests java.io.ObjectStreamClass#getSerialVersionUID()
 119      */
 120     public void test_getSerialVersionUID_inner_private_class() {
 121         ObjectStreamClass osc1 = ObjectStreamClass.lookup(SyntheticTest.class);
 122         assertEquals("SyntheticTest unexpected UID: "
 123                 + osc1.getSerialVersionUID(), 4405770616475181267L, osc1
 124                 .getSerialVersionUID());
 125
 126         ObjectStreamClass osc2 = ObjectStreamClass
 127                 .lookup(SyntheticTest.X.class);
 128         assertEquals("SyntheticTest.X unexpected UID: "
 129                 + osc2.getSerialVersionUID(), 676101599466902119L, osc2
 130                 .getSerialVersionUID());
 131     }
 132
 133     /**
 134      * @tests java.io.ObjectStreamClass#getSerialVersionUID()
 135      */
 136     public void test_getSerialVersionUID_classloader() throws Exception {
 137         File file = new File(
 138                 "resources/org/apache/harmony/luni/tests/ObjectStreamClassTest.jar");
 139         ClassLoader loader = new URLClassLoader(new URL[] { file.toURL() },
 140                 null);
 141         Class cl1 = Class.forName("Test1$TestVarArgs", false, loader);
 142         ObjectStreamClass osc1 = ObjectStreamClass.lookup(cl1);
 143         assertEquals("Test1$TestVarArgs unexpected UID: "
 144                 + osc1.getSerialVersionUID(), -6051121963037986215L, osc1
 145                 .getSerialVersionUID());
 146
 147         Class cl2 = Class.forName("Test1$TestBridge", false, loader);
 148         ObjectStreamClass osc2 = ObjectStreamClass.lookup(cl2);
 149         assertEquals("Test1$TestBridge unexpected UID: "
 150                 + osc2.getSerialVersionUID(), 568585976855071180L, osc2
 151                 .getSerialVersionUID());
 152     }
 153
 154     /**
 155      * @tests java.io.ObjectStreamClass#lookup(java.lang.Class)
 156      */
 157     public void test_lookupLjava_lang_Class() {
 158         ObjectStreamClass osc = ObjectStreamClass.lookup(DummyClass.class);
 159         assertEquals(
 160                 "lookup returned wrong class: " + osc.getName(),
 161                 "tests.api.java.io.ObjectStreamClassTest$DummyClass", // android-changed
 162                 osc.getName());
 163     }
 164
 165     /**
 166      * @tests java.io.ObjectStreamClass#toString()
 167      */
 168     public void test_toString() {
 169         ObjectStreamClass osc = ObjectStreamClass.lookup(DummyClass.class);
 170         String oscString = osc.toString();
 171
 172         // The previous test was more specific than the spec so it was replaced
 173         // with the test below
 174         assertTrue("toString returned incorrect string: " + osc.toString(),
 175                 oscString.indexOf("serialVersionUID") >= 0
 176                         && oscString.indexOf("999999999999999L") >= 0);
 177     }
 178
 179     public void testSerialization() {
 180         ObjectStreamClass osc = ObjectStreamClass
 181                 .lookup(ObjectStreamClass.class);
 182         assertEquals(0, osc.getFields().length);
 183     }
 184
 185     public void test_specialTypes() {
 186         Class<?> proxyClass = Proxy.getProxyClass(this.getClass()
 187                 .getClassLoader(), new Class[] { Runnable.class });
 188
 189         ObjectStreamClass proxyStreamClass = ObjectStreamClass
 190                 .lookup(proxyClass);
 191
 192         assertEquals("Proxy classes should have zero serialVersionUID", 0,
 193                 proxyStreamClass.getSerialVersionUID());
 194         ObjectStreamField[] proxyFields = proxyStreamClass.getFields();
 195         assertEquals("Proxy classes should have no serialized fields", 0,
 196                 proxyFields.length);
 197
 198         ObjectStreamClass enumStreamClass = ObjectStreamClass
 199                 .lookup(Thread.State.class);
 200
 201         assertEquals("Enum classes should have zero serialVersionUID", 0,
 202                 enumStreamClass.getSerialVersionUID());
 203         ObjectStreamField[] enumFields = enumStreamClass.getFields();
 204         assertEquals("Enum classes should have no serialized fields", 0,
 205                 enumFields.length);
 206     }
 207
 208         /**
 209      * @since 1.6
 210      */
 211     static class NonSerialzableClass {
 212         private static final long serialVersionUID = 1l;
 213         public static long getUID() {
 214             return serialVersionUID;
 215         }
 216     }
 217
 218     /**
 219      * @since 1.6
 220      */
 221     static class ExternalizableClass implements Externalizable {
 222
 223         private static final long serialVersionUID = -4285635779249689129L;
 224
 225         public void readExternal(ObjectInput input) throws IOException, ClassNotFoundException {
 226             throw new ClassNotFoundException();
 227         }
 228
 229         public void writeExternal(ObjectOutput output) throws IOException {
 230             throw new IOException();
 231         }
 232
 233         }
 234
 235     /**
 236      * @tests java.io.ObjectStreamClass#lookupAny(java.lang.Class)
 237      * @since 1.6
 238      */
 239     public void test_lookupAnyLjava_lang_Class() {
 240         // Test for method java.io.ObjectStreamClass
 241         // java.io.ObjectStreamClass.lookupAny(java.lang.Class)
 242         ObjectStreamClass osc = ObjectStreamClass.lookupAny(DummyClass.class);
 243         assertEquals("lookup returned wrong class: " + osc.getName(),
 244                 "tests.api.java.io.ObjectStreamClassTest$DummyClass", osc  // android-changed
 245                         .getName());
 246
 247         osc = ObjectStreamClass.lookupAny(NonSerialzableClass.class);
 248         assertEquals("lookup returned wrong class: " + osc.getName(),
 249                 "tests.api.java.io.ObjectStreamClassTest$NonSerialzableClass", // android-changed
 250                 osc.getName());
 251
 252         osc = ObjectStreamClass.lookupAny(ExternalizableClass.class);
 253         assertEquals("lookup returned wrong class: " + osc.getName(),
 254                 "tests.api.java.io.ObjectStreamClassTest$ExternalizableClass", // android-changed
 255                 osc.getName());
 256
 257         osc = ObjectStreamClass.lookup(NonSerialzableClass.class);
 258         assertNull(osc);
 259
 260     }
 261
 262
 263 }