/*
* Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code 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
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
/*
* @test
* @bug 8011200
* @run testng BasicSerialization
* @summary Ensure Maps can be serialized and deserialized.
* @author Mike Duigou
*/
import java.io.ByteArrayOutputStream;
import java.io.InputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.ByteArrayInputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentSkipListMap;
import org.testng.annotations.Test;
import org.testng.annotations.DataProvider;
import static org.testng.Assert.fail;
import static org.testng.Assert.assertEquals;
import static org.testng.Assert.assertTrue;
import static org.testng.Assert.assertFalse;
import static org.testng.Assert.assertSame;
public class BasicSerialization {
enum IntegerEnum {
e0, e1, e2, e3, e4, e5, e6, e7, e8, e9,
e10, e11, e12, e13, e14, e15, e16, e17, e18, e19,
e20, e21, e22, e23, e24, e25, e26, e27, e28, e29,
e30, e31, e32, e33, e34, e35, e36, e37, e38, e39,
e40, e41, e42, e43, e44, e45, e46, e47, e48, e49,
e50, e51, e52, e53, e54, e55, e56, e57, e58, e59,
e60, e61, e62, e63, e64, e65, e66, e67, e68, e69,
e70, e71, e72, e73, e74, e75, e76, e77, e78, e79,
e80, e81, e82, e83, e84, e85, e86, e87, e88, e89,
e90, e91, e92, e93, e94, e95, e96, e97, e98, e99,
EXTRA_KEY;
public static final int SIZE = values().length;
};
private static final int TEST_SIZE = IntegerEnum.SIZE - 1;
/**
* Realized keys ensure that there is always a hard ref to all test objects.
*/
private static final IntegerEnum[] KEYS = new IntegerEnum[TEST_SIZE];
/**
* Realized values ensure that there is always a hard ref to all test
* objects.
*/
private static final String[] VALUES = new String[TEST_SIZE];
static {
IntegerEnum[] keys = IntegerEnum.values();
for (int each = 0; each < TEST_SIZE; each++) {
KEYS[each] = keys[each];
VALUES[each] = keys[each].name();
}
}
private static final IntegerEnum EXTRA_KEY = IntegerEnum.EXTRA_KEY;
private static final String EXTRA_VALUE = IntegerEnum.EXTRA_KEY.name();
public static <K, V> Map<K, V> mapClone(Map<K, V> map) {
Method cloneMethod;
try {
cloneMethod = map.getClass().getMethod("clone", new Class[]{});
} catch (NoSuchMethodException | SecurityException all) {
cloneMethod = null;
}
if (null != cloneMethod) {
try {
Map<K, V> result = (Map<K, V>)cloneMethod.invoke(map, new Object[]{});
return result;
} catch (Exception all) {
fail("clone() failed " + map.getClass().getSimpleName(), all);
return null;
}
} else {
Constructor<? extends Map> copyConstructor;
try {
copyConstructor = (Constructor<? extends Map>)map.getClass().getConstructor(new Class[]{Map.class});
Map<K, V> result = (Map<K, V>)copyConstructor.newInstance(new Object[]{map});
return result;
} catch (Exception all) {
return serialClone(map);
}
}
}
@Test(dataProvider = "Map<IntegerEnum,String>")
public void testSerialization(String description, Map<IntegerEnum, String> map) {
Object foo = new Object();
Map<IntegerEnum, String> clone = mapClone(map);
Map<IntegerEnum, String> serialClone = serialClone(map);
assertEquals(map, map, description + ":should equal self");
assertEquals(clone, map, description + ":should equal clone");
assertEquals(map, clone, description + ": should equal orginal map");
assertEquals(serialClone, map, description + ": should equal deserialized clone");
assertEquals(map, serialClone, description + ": should equal original map");
assertEquals(serialClone, clone, description + ": deserialized clone should equal clone");
assertEquals(clone, serialClone, description + ": clone should equal deserialized clone");
assertFalse(map.containsKey(EXTRA_KEY), description + ":unexpected key");
assertFalse(clone.containsKey(EXTRA_KEY), description + ":unexpected key");
assertFalse(serialClone.containsKey(EXTRA_KEY), description + ":unexpected key");
map.put(EXTRA_KEY, EXTRA_VALUE);
clone.put(EXTRA_KEY, EXTRA_VALUE);
serialClone.put(EXTRA_KEY, EXTRA_VALUE);
assertTrue(map.containsKey(EXTRA_KEY), description + ":missing key");
assertTrue(clone.containsKey(EXTRA_KEY), description + ":missing key");
assertTrue(serialClone.containsKey(EXTRA_KEY), description + ":missing key");
assertSame(map.get(EXTRA_KEY), EXTRA_VALUE, description + ":wrong value");
assertSame(clone.get(EXTRA_KEY), EXTRA_VALUE, description + ":wrong value");
assertSame(serialClone.get(EXTRA_KEY), EXTRA_VALUE, description + ":wrong value");
assertEquals(map, map, description + ":should equal self");
assertEquals(clone, map, description + ":should equal clone");
assertEquals(map, clone, description + ": should equal orginal map");
assertEquals(serialClone, map, description + ": should equal deserialized clone");
assertEquals(map, serialClone, description + ": should equal original map");
assertEquals(serialClone, clone, description + ": deserialized clone should equal clone");
assertEquals(clone, serialClone, description + ": clone should equal deserialized clone");
}
static byte[] serializedForm(Object obj) {
try {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
new ObjectOutputStream(baos).writeObject(obj);
return baos.toByteArray();
} catch (IOException e) {
fail("Unexpected Exception", e);
return null;
}
}
static Object readObject(byte[] bytes) throws IOException, ClassNotFoundException {
InputStream is = new ByteArrayInputStream(bytes);
return new ObjectInputStream(is).readObject();
}
@SuppressWarnings("unchecked")
static <T> T serialClone(T obj) {
try {
return (T)readObject(serializedForm(obj));
} catch (IOException | ClassNotFoundException e) {
fail("Unexpected Exception", e);
return null;
}
}
@DataProvider(name = "Map<IntegerEnum,String>", parallel = true)
private static Iterator<Object[]> makeMaps() {
return Arrays.asList(
// empty
new Object[]{"HashMap", new HashMap()},
new Object[]{"LinkedHashMap", new LinkedHashMap()},
new Object[]{"Collections.checkedMap(HashMap)", Collections.checkedMap(new HashMap(), IntegerEnum.class, String.class)},
new Object[]{"Collections.synchronizedMap(HashMap)", Collections.synchronizedMap(new HashMap())},
// null hostile
new Object[]{"EnumMap", new EnumMap(IntegerEnum.class)},
new Object[]{"Hashtable", new Hashtable()},
new Object[]{"TreeMap", new TreeMap()},
new Object[]{"ConcurrentHashMap", new ConcurrentHashMap()},
new Object[]{"ConcurrentSkipListMap", new ConcurrentSkipListMap()},
new Object[]{"Collections.checkedMap(ConcurrentHashMap)", Collections.checkedMap(new ConcurrentHashMap(), IntegerEnum.class, String.class)},
new Object[]{"Collections.synchronizedMap(EnumMap)", Collections.synchronizedMap(new EnumMap(IntegerEnum.class))},
// filled
new Object[]{"HashMap", fillMap(new HashMap())},
new Object[]{"LinkedHashMap", fillMap(new LinkedHashMap())},
new Object[]{"Collections.checkedMap(HashMap)", Collections.checkedMap(fillMap(new HashMap()), IntegerEnum.class, String.class)},
new Object[]{"Collections.synchronizedMap(HashMap)", Collections.synchronizedMap(fillMap(new HashMap()))},
// null hostile
new Object[]{"EnumMap", fillMap(new EnumMap(IntegerEnum.class))},
new Object[]{"Hashtable", fillMap(new Hashtable())},
new Object[]{"TreeMap", fillMap(new TreeMap())},
new Object[]{"ConcurrentHashMap", fillMap(new ConcurrentHashMap())},
new Object[]{"ConcurrentSkipListMap", fillMap(new ConcurrentSkipListMap())},
new Object[]{"Collections.checkedMap(ConcurrentHashMap)", Collections.checkedMap(fillMap(new ConcurrentHashMap()), IntegerEnum.class, String.class)},
new Object[]{"Collections.synchronizedMap(EnumMap)", Collections.synchronizedMap(fillMap(new EnumMap(IntegerEnum.class)))}).iterator();
}
private static Map<IntegerEnum, String> fillMap(Map<IntegerEnum, String> result) {
for (int each = 0; each < TEST_SIZE; each++) {
result.put(KEYS[each], VALUES[each]);
}
return result;
}
}