ObjectStreamClassTest.java revision 747d4cd5e39da3be38ec1d2da9fb7403006ed7c4 
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
18package org.apache.harmony.luni.tests.java.io;
19
20import java.io.File;
21import java.io.Externalizable;
22import java.io.IOException;
23import java.io.ObjectInput;
24import java.io.ObjectOutput;
25import java.io.ObjectStreamClass;
26import java.io.ObjectStreamField;
27import java.io.Serializable;
28import java.net.URL;
29import java.net.URLClassLoader;
30import java.lang.reflect.Proxy;
31
32import junit.framework.TestCase;
33
34public 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                "org.apache.harmony.luni.tests.java.io.ObjectStreamClassTest$DummyClass",
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    public void test_getSerialVersionUID_inner_private_class() {
118        ObjectStreamClass osc1 = ObjectStreamClass.lookup(SyntheticTest.class);
119        assertEquals(-4332969662791850406L, osc1.getSerialVersionUID());
120
121        ObjectStreamClass osc2 = ObjectStreamClass.lookup(SyntheticTest.X.class);
122        assertEquals(-3926212872029449440L, osc2.getSerialVersionUID());
123    }
124
125    /**
126     * @tests java.io.ObjectStreamClass#getSerialVersionUID()
127     */
128    public void test_getSerialVersionUID_classloader() throws Exception {
129        File file = new File(
130                "resources/org/apache/harmony/luni/tests/ObjectStreamClassTest.jar");
131        ClassLoader loader = new URLClassLoader(new URL[] { file.toURL() },
132                null);
133        Class cl1 = Class.forName("Test1$TestVarArgs", false, loader);
134        ObjectStreamClass osc1 = ObjectStreamClass.lookup(cl1);
135        assertEquals("Test1$TestVarArgs unexpected UID: "
136                + osc1.getSerialVersionUID(), -6051121963037986215L, osc1
137                .getSerialVersionUID());
138
139        Class cl2 = Class.forName("Test1$TestBridge", false, loader);
140        ObjectStreamClass osc2 = ObjectStreamClass.lookup(cl2);
141        assertEquals("Test1$TestBridge unexpected UID: "
142                + osc2.getSerialVersionUID(), 568585976855071180L, osc2
143                .getSerialVersionUID());
144    }
145
146    /**
147     * @tests java.io.ObjectStreamClass#lookup(java.lang.Class)
148     */
149    public void test_lookupLjava_lang_Class() {
150        ObjectStreamClass osc = ObjectStreamClass.lookup(DummyClass.class);
151        assertEquals(
152                "lookup returned wrong class: " + osc.getName(),
153                "org.apache.harmony.luni.tests.java.io.ObjectStreamClassTest$DummyClass",
154                osc.getName());
155    }
156
157    /**
158     * @tests java.io.ObjectStreamClass#toString()
159     */
160    public void test_toString() {
161        ObjectStreamClass osc = ObjectStreamClass.lookup(DummyClass.class);
162        String oscString = osc.toString();
163
164        // The previous test was more specific than the spec so it was replaced
165        // with the test below
166        assertTrue("toString returned incorrect string: " + osc.toString(),
167                oscString.indexOf("serialVersionUID") >= 0
168                        && oscString.indexOf("999999999999999L") >= 0);
169    }
170
171    public void testSerialization() {
172        ObjectStreamClass osc = ObjectStreamClass
173                .lookup(ObjectStreamClass.class);
174        assertEquals(0, osc.getFields().length);
175    }
176
177    public void test_specialTypes() {
178        Class<?> proxyClass = Proxy.getProxyClass(this.getClass()
179                .getClassLoader(), new Class[] { Runnable.class });
180
181        ObjectStreamClass proxyStreamClass = ObjectStreamClass
182                .lookup(proxyClass);
183
184        assertEquals("Proxy classes should have zero serialVersionUID", 0,
185                proxyStreamClass.getSerialVersionUID());
186        ObjectStreamField[] proxyFields = proxyStreamClass.getFields();
187        assertEquals("Proxy classes should have no serialized fields", 0,
188                proxyFields.length);
189
190        ObjectStreamClass enumStreamClass = ObjectStreamClass
191                .lookup(Thread.State.class);
192
193        assertEquals("Enum classes should have zero serialVersionUID", 0,
194                enumStreamClass.getSerialVersionUID());
195        ObjectStreamField[] enumFields = enumStreamClass.getFields();
196        assertEquals("Enum classes should have no serialized fields", 0,
197                enumFields.length);
198    }
199
200        /**
201     * @since 1.6
202     */
203    static class NonSerialzableClass {
204        private static final long serialVersionUID = 1l;
205        public static long getUID() {
206            return serialVersionUID;
207        }
208    }
209
210    /**
211     * @since 1.6
212     */
213    static class ExternalizableClass implements Externalizable {
214
215        private static final long serialVersionUID = -4285635779249689129L;
216
217        public void readExternal(ObjectInput input) throws IOException, ClassNotFoundException {
218            throw new ClassNotFoundException();
219        }
220
221        public void writeExternal(ObjectOutput output) throws IOException {
222            throw new IOException();
223        }
224
225	}
226
227    /**
228     * @tests java.io.ObjectStreamClass#lookupAny(java.lang.Class)
229     * @since 1.6
230     */
231    public void test_lookupAnyLjava_lang_Class() {
232        // Test for method java.io.ObjectStreamClass
233        // java.io.ObjectStreamClass.lookupAny(java.lang.Class)
234        ObjectStreamClass osc = ObjectStreamClass.lookupAny(DummyClass.class);
235        assertEquals("lookup returned wrong class: " + osc.getName(),
236                "org.apache.harmony.luni.tests.java.io.ObjectStreamClassTest$DummyClass", osc
237                        .getName());
238
239        osc = ObjectStreamClass.lookupAny(NonSerialzableClass.class);
240        assertEquals("lookup returned wrong class: " + osc.getName(),
241                "org.apache.harmony.luni.tests.java.io.ObjectStreamClassTest$NonSerialzableClass",
242                osc.getName());
243
244        osc = ObjectStreamClass.lookupAny(ExternalizableClass.class);
245        assertEquals("lookup returned wrong class: " + osc.getName(),
246                "org.apache.harmony.luni.tests.java.io.ObjectStreamClassTest$ExternalizableClass",
247                osc.getName());
248
249        osc = ObjectStreamClass.lookup(NonSerialzableClass.class);
250        assertNull(osc);
251
252    }
253
254
255}
256