/*
* Copyright 2011 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy of
* the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations under
* the License.
*/
package com.google.gwt.user.server.rpc;
import com.google.gwt.user.client.rpc.IncompatibleRemoteServiceException;
import com.google.gwt.user.client.rpc.IsSerializable;
import com.google.gwt.user.client.rpc.RemoteService;
import com.google.gwt.user.client.rpc.SerializedTypeViolationException;
import com.google.gwt.user.client.rpc.TestSetFactory.ReverseSorter;
import junit.framework.TestCase;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.IdentityHashMap;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;
import java.util.Vector;
/**
* Collections test cases for the type checking code found in server-side RPC
* deserialization.
*/
@SuppressWarnings("rawtypes")
public class RPCTypeCheckCollectionsTest extends TestCase {
/*
* Test top-level generic type mismatches for all custom serialized container
* classes. These are all tested using a class that involves a pathological
* hash-code object. Hence checking that improper objects are not deserialized
* at all (the test will time out if there is a problem).
* - ArrayList<Integer>: testListHashSetSpoofingList
* - ArraysAsList<Integer>: testListHashSetSpoofingList
* - HashMap<String, Integer>: testMapHashSetSpoofingMap
* - HashSet<Integer>: testSetHashSetSpoofingSet
* - IdentityHashMap<AClass, Integer>: testMapHashSetSpoofingMap
* - LinkedHashMap<String, Integer>: testMapHashSetSpoofingMap
* - LinkedHashSet<Integer>: testSetSpoofingSet
* - LinkedList<Integer>: testListHashSetSpoofingList
* - SingletonList<Integer>: testListHashSetSpoofingList
* - TreeMap<String, Integer>: testMapHashSetSpoofingMap
* - TreeSet<Integer>: testSetHashSetSpoofingSet
* - Vector<Integer>: testVectorHashSetSpoofingVector
*
* Also tests raw version of all of these types, to verify no false positives
* for type violations.
*
* Test nested generics, at least 2 levels deep:
* - HashMap<String, HashSet<Integer>>: testNestedGenerics
* - HashMap<String, HashMap<Integer, AClass>>: testNestedGenerics
* - HashMap<String, HashMap<Integer, List<Long>>>: testNestedGenerics
* - HashMap<String, HashMap>: testNestedGenerics
*/
/**
* A class containing a method used to check type spoofing attacks on RPC
* messages containing collection types.
*/
public static class ContainerParamTestClass implements RemoteService {
@SuppressWarnings("unused")
public static void testList(List<Integer> arg1, List<Integer> arg2, List<Integer> arg3,
List<Integer> arg4) {
}
@SuppressWarnings("unused")
public static void testListRaw(List arg1, List arg2, List arg3, List arg4) {
}
@SuppressWarnings("unused")
public static void testMap(Map<String, Integer> arg1, Map<String, Integer> arg2,
Map<String, Integer> arg3, Map<String, Integer> arg4) { }
@SuppressWarnings("unused")
public static void testMapRaw(Map arg1, Map arg2, Map arg3, Map arg4) { }
@SuppressWarnings("unused")
public static void testSet(Set<Integer> arg1, Set<Integer> arg2, Set<Integer> arg3) { }
@SuppressWarnings("unused")
public static void testSetRaw(Set arg1, Set arg2, Set arg3) { }
@SuppressWarnings("unused")
public static void testVector(Vector<Integer> arg1) { }
@SuppressWarnings("unused")
public static void testVectorRaw(Vector arg1) { }
@SuppressWarnings("unused")
public static void testNestedGenerics(HashMap<String, HashSet<Integer>> arg1,
HashMap<String, HashMap<Integer, RPCTypeCheckTest.AClass>> arg2,
HashMap<String, HashMap<Integer, List<Long>>> arg3) { }
@SuppressWarnings("unused")
public static void testNestedGenericsRaw(HashMap<String, HashSet> arg1,
HashMap<String, HashMap> arg2,
HashMap<String, HashMap<Integer, List>> arg3) { }
}
/**
* Used to test a generic class that extends another generic class.
*
* Also necessary because LinkedHashSet is not serializable alone.
*/
public static class TestHashSet<T> extends LinkedHashSet<T> implements IsSerializable {
// Does nothing different.
}
private static String generateArrayListHashSetSpoofingList() {
try {
RPCTypeCheckFactory strFactory =
new RPCTypeCheckFactory(ContainerParamTestClass.class, "testList");
ArrayList<HashSet<Integer>> arrayList = new ArrayList<HashSet<Integer>>();
HashSet<Integer> hashSet = new HashSet<Integer>();
hashSet.add(12345);
arrayList.add(hashSet);
strFactory.write(arrayList);
Integer i = 54321;
Integer j = 9876;
List<Integer> arrayAsList = Arrays.asList(i, j);
strFactory.write(arrayAsList);
LinkedList<Integer> linkedList = new LinkedList<Integer>();
linkedList.add(12345);
linkedList.add(67890);
strFactory.write(linkedList);
Integer k = new Integer(45678);
List<Integer> singletonList = Collections.singletonList(k);
strFactory.write(singletonList);
return strFactory.toString();
} catch (Exception e) {
fail(e.getMessage());
return null;
}
}
private static String generateArraysAsListHashSetSpoofingList() {
try {
RPCTypeCheckFactory strFactory =
new RPCTypeCheckFactory(ContainerParamTestClass.class, "testList");
Integer i = 54321;
Integer j = 9876;
ArrayList<Integer> arrayList = new ArrayList<Integer>();
arrayList.add(i);
arrayList.add(j);
strFactory.write(arrayList);
List<HashSet> arrayAsList = Arrays.asList(RPCTypeCheckFactory.generateTestHashSet());
strFactory.write(arrayAsList);
LinkedList<Integer> linkedList = new LinkedList<Integer>();
linkedList.add(12345);
linkedList.add(67890);
strFactory.write(linkedList);
Integer k = new Integer(45678);
List<Integer> singletonList = Collections.singletonList(k);
strFactory.write(singletonList);
return strFactory.toString();
} catch (Exception e) {
fail(e.getMessage());
return null;
}
}
private static String generateArraysAsListHashSetSpoofingArraysAsList() {
try {
RPCTypeCheckFactory strFactory =
new RPCTypeCheckFactory(ContainerParamTestClass.class, "testList");
List<HashSet> arrayAsList = Arrays.asList(RPCTypeCheckFactory.generateTestHashSet());
strFactory.write(arrayAsList);
LinkedList<Integer> linkedList = new LinkedList<Integer>();
linkedList.add(12345);
linkedList.add(67890);
strFactory.write(linkedList);
return strFactory.toString();
} catch (Exception e) {
fail(e.getMessage());
return null;
}
}
private static String generateHashMapKeyHashSetSpoofingHashMap() {
try {
RPCTypeCheckFactory strFactory =
new RPCTypeCheckFactory(ContainerParamTestClass.class, "testMap");
HashMap<HashSet, Integer> hashMap = RPCTypeCheckFactory.generateTestHashMap();
strFactory.write(hashMap);
IdentityHashMap<String, Integer> identityHashMap = new IdentityHashMap<String, Integer>();
identityHashMap.put("foo", new Integer(12));
identityHashMap.put("bar", new Integer(34));
strFactory.write(identityHashMap);
LinkedHashMap<String, Integer> linkedHashMap = new LinkedHashMap<String, Integer>();
linkedHashMap.put("foo", new Integer(56));
linkedHashMap.put("bar", new Integer(78));
strFactory.write(linkedHashMap);
TreeMap<String, Integer> treeMap = new TreeMap<String, Integer>();
treeMap.put("foo", new Integer(90));
treeMap.put("bar", new Integer(12));
strFactory.write(treeMap);
return strFactory.toString();
} catch (Exception e) {
fail(e.getMessage());
return null;
}
}
private static String generateHashMapValueHashSetSpoofingHashMap() {
try {
RPCTypeCheckFactory strFactory =
new RPCTypeCheckFactory(ContainerParamTestClass.class, "testMap");
HashMap<String, HashSet> hashMap = new HashMap<String, HashSet>();
hashMap.put("foo", RPCTypeCheckFactory.generateTestHashSet());
strFactory.write(hashMap);
IdentityHashMap<String, Integer> identityHashMap = new IdentityHashMap<String, Integer>();
identityHashMap.put("foo", new Integer(12));
identityHashMap.put("bar", new Integer(34));
strFactory.write(identityHashMap);
LinkedHashMap<String, Integer> linkedHashMap = new LinkedHashMap<String, Integer>();
linkedHashMap.put("foo", new Integer(56));
linkedHashMap.put("bar", new Integer(78));
strFactory.write(linkedHashMap);
TreeMap<String, Integer> treeMap = new TreeMap<String, Integer>();
treeMap.put("foo", new Integer(90));
treeMap.put("bar", new Integer(12));
strFactory.write(treeMap);
return strFactory.toString();
} catch (Exception e) {
fail(e.getMessage());
return null;
}
}
private static String generateHashSetHashSetSpoofingSetInteger() {
try {
RPCTypeCheckFactory strFactory =
new RPCTypeCheckFactory(ContainerParamTestClass.class, "testSet");
HashSet hashSet = RPCTypeCheckFactory.generateTestHashSet();
strFactory.write(hashSet);
ReverseSorter<Integer> sorter = new ReverseSorter<Integer>();
TreeSet<Integer> treeSet = new TreeSet<Integer>(sorter);
treeSet.add(12345);
treeSet.add(67890);
strFactory.write(treeSet);
TestHashSet<Integer> treeHashSet = new TestHashSet<Integer>();
treeHashSet.add(12345);
treeHashSet.add(67890);
strFactory.write(treeHashSet);
return strFactory.toString();
} catch (Exception e) {
fail(e.getMessage());
return null;
}
}
private static String generateIdentityHashMapKeyHashSetSpoofingIdentityHashMap() {
try {
RPCTypeCheckFactory strFactory =
new RPCTypeCheckFactory(ContainerParamTestClass.class, "testMap");
HashMap<String, Integer> hashMap = new HashMap<String, Integer>();
hashMap.put("foo", new Integer(12));
hashMap.put("bar", new Integer(34));
strFactory.write(hashMap);
IdentityHashMap<HashSet, Integer> identityHashMap =
RPCTypeCheckFactory.generateTestIdentityHashMap();
strFactory.write(identityHashMap);
LinkedHashMap<String, Integer> linkedHashMap = new LinkedHashMap<String, Integer>();
linkedHashMap.put("foo", new Integer(56));
linkedHashMap.put("bar", new Integer(78));
strFactory.write(linkedHashMap);
TreeMap<String, Integer> treeMap = new TreeMap<String, Integer>();
treeMap.put("foo", new Integer(90));
treeMap.put("bar", new Integer(12));
strFactory.write(treeMap);
return strFactory.toString();
} catch (Exception e) {
fail(e.getMessage());
return null;
}
}
private static String generateIdentityHashMapValueHashSetSpoofingIdentityHashMap() {
try {
RPCTypeCheckFactory strFactory =
new RPCTypeCheckFactory(ContainerParamTestClass.class, "testMap");
HashMap<String, Integer> hashMap = new HashMap<String, Integer>();
hashMap.put("foo", new Integer(12));
hashMap.put("bar", new Integer(34));
strFactory.write(hashMap);
IdentityHashMap<String, HashSet> identityHashMap = new IdentityHashMap<String, HashSet>();
identityHashMap.put("foo", RPCTypeCheckFactory.generateTestHashSet());
strFactory.write(identityHashMap);
LinkedHashMap<String, Integer> linkedHashMap = new LinkedHashMap<String, Integer>();
linkedHashMap.put("foo", new Integer(56));
linkedHashMap.put("bar", new Integer(78));
strFactory.write(linkedHashMap);
TreeMap<String, Integer> treeMap = new TreeMap<String, Integer>();
treeMap.put("foo", new Integer(90));
treeMap.put("bar", new Integer(12));
strFactory.write(treeMap);
return strFactory.toString();
} catch (Exception e) {
fail(e.getMessage());
return null;
}
}
private static String generateLinkedHashMapKeyHashSetSpoofingLinkedHashMap() {
try {
RPCTypeCheckFactory strFactory =
new RPCTypeCheckFactory(ContainerParamTestClass.class, "testMap");
HashMap<String, Integer> hashMap = new HashMap<String, Integer>();
hashMap.put("foo", new Integer(12));
hashMap.put("bar", new Integer(34));
strFactory.write(hashMap);
IdentityHashMap<String, Integer> identityHashMap = new IdentityHashMap<String, Integer>();
identityHashMap.put("foo", new Integer(56));
identityHashMap.put("bar", new Integer(78));
strFactory.write(identityHashMap);
LinkedHashMap<HashSet, Integer> linkedHashMap =
RPCTypeCheckFactory.generateTestLinkedHashMap();
strFactory.write(linkedHashMap);
TreeMap<String, Integer> treeMap = new TreeMap<String, Integer>();
treeMap.put("foo", new Integer(90));
treeMap.put("bar", new Integer(12));
strFactory.write(treeMap);
return strFactory.toString();
} catch (Exception e) {
fail(e.getMessage());
return null;
}
}
private static String generateLinkedHashMapValueHashSetSpoofingLinkedHashMap() {
try {
RPCTypeCheckFactory strFactory =
new RPCTypeCheckFactory(ContainerParamTestClass.class, "testMap");
HashMap<String, Integer> hashMap = new HashMap<String, Integer>();
hashMap.put("foo", new Integer(12));
hashMap.put("bar", new Integer(34));
strFactory.write(hashMap);
IdentityHashMap<String, Integer> identityHashMap = new IdentityHashMap<String, Integer>();
identityHashMap.put("foo", new Integer(56));
identityHashMap.put("bar", new Integer(78));
strFactory.write(identityHashMap);
LinkedHashMap<String, HashSet> linkedHashMap = new LinkedHashMap<String, HashSet>();
linkedHashMap.put("foo", RPCTypeCheckFactory.generateTestHashSet());
strFactory.write(linkedHashMap);
TreeMap<String, Integer> treeMap = new TreeMap<String, Integer>();
treeMap.put("foo", new Integer(90));
treeMap.put("bar", new Integer(12));
strFactory.write(treeMap);
return strFactory.toString();
} catch (Exception e) {
fail(e.getMessage());
return null;
}
}
private static String generateLinkedHashSetHashSetSpoofingSetInteger() {
try {
RPCTypeCheckFactory strFactory =
new RPCTypeCheckFactory(ContainerParamTestClass.class, "testSet");
HashSet<Integer> hashSet = new HashSet<Integer>();
hashSet.add(12345);
hashSet.add(67890);
strFactory.write(hashSet);
ReverseSorter<Integer> sorter = new ReverseSorter<Integer>();
TreeSet<Integer> treeSet = new TreeSet<Integer>(sorter);
treeSet.add(12345);
treeSet.add(67890);
strFactory.write(treeSet);
LinkedHashSet linkedHashSet = RPCTypeCheckFactory.generateTestLinkedHashSet();
strFactory.write(linkedHashSet);
return strFactory.toString();
} catch (Exception e) {
fail(e.getMessage());
return null;
}
}
private static String generateLinkedListHashSetSpoofingList() {
try {
RPCTypeCheckFactory strFactory =
new RPCTypeCheckFactory(ContainerParamTestClass.class, "testList");
ArrayList<Integer> arrayList = new ArrayList<Integer>();
arrayList.add(12345);
arrayList.add(67890);
strFactory.write(arrayList);
Integer i = 54321;
Integer j = 9876;
List<Integer> arrayAsList = Arrays.asList(i, j);
strFactory.write(arrayAsList);
LinkedList<HashSet> linkedList = new LinkedList<HashSet>();
linkedList.add(RPCTypeCheckFactory.generateTestHashSet());
strFactory.write(linkedList);
Integer k = new Integer(45678);
List<Integer> singletonList = Collections.singletonList(k);
strFactory.write(singletonList);
return strFactory.toString();
} catch (Exception e) {
fail(e.getMessage());
return null;
}
}
private static String generateListStringSpoofingListInteger() {
try {
RPCTypeCheckFactory strFactory =
new RPCTypeCheckFactory(ContainerParamTestClass.class, "testList");
ArrayList<String> arrayList = new ArrayList<String>();
arrayList.add("foo");
arrayList.add("bar");
strFactory.write(arrayList);
LinkedList<String> linkedList = new LinkedList<String>();
linkedList.add("foo");
linkedList.add("bar");
strFactory.write(linkedList);
return strFactory.toString();
} catch (Exception e) {
fail(e.getMessage());
return null;
}
}
private static String generateListValid(String methodName) {
try {
RPCTypeCheckFactory strFactory =
new RPCTypeCheckFactory(ContainerParamTestClass.class, methodName);
ArrayList<Integer> arrayList = new ArrayList<Integer>();
arrayList.add(12345);
arrayList.add(67890);
strFactory.write(arrayList);
Integer i = 54321;
Integer j = 9876;
List<Integer> arrayAsList = Arrays.asList(i, j);
strFactory.write(arrayAsList);
LinkedList<Integer> linkedList = new LinkedList<Integer>();
linkedList.add(12345);
linkedList.add(67890);
strFactory.write(linkedList);
Integer k = new Integer(45678);
List<Integer> singletonList = Collections.singletonList(k);
strFactory.write(singletonList);
return strFactory.toString();
} catch (Exception e) {
fail(e.getMessage());
return null;
}
}
private static String generateMapRaw() {
try {
RPCTypeCheckFactory strFactory =
new RPCTypeCheckFactory(ContainerParamTestClass.class, "testMapRaw");
HashMap<String, Integer> hashMap = new HashMap<String, Integer>();
hashMap.put("foo", 1020);
strFactory.write(hashMap);
IdentityHashMap<String, Integer> identityHashMap = new IdentityHashMap<String, Integer>();
identityHashMap.put("foo", new Integer(12));
identityHashMap.put("bar", new Integer(34));
strFactory.write(identityHashMap);
LinkedHashMap<String, Integer> linkedHashMap = new LinkedHashMap<String, Integer>();
linkedHashMap.put("foo", new Integer(56));
linkedHashMap.put("bar", new Integer(78));
strFactory.write(linkedHashMap);
TreeMap<String, Integer> treeMap = new TreeMap<String, Integer>();
treeMap.put("foo", new Integer(90));
treeMap.put("bar", new Integer(12));
strFactory.write(treeMap);
return strFactory.toString();
} catch (Exception e) {
fail(e.getMessage());
return null;
}
}
@SuppressWarnings("unchecked")
private static String generateNestedGenericsA() {
try {
RPCTypeCheckFactory strFactory =
new RPCTypeCheckFactory(ContainerParamTestClass.class, "testNestedGenerics");
HashMap<String, HashSet<HashSet>> arg1 = new HashMap<String, HashSet<HashSet>>();
HashSet<HashSet> entry1 = RPCTypeCheckFactory.generateTestHashSetHashSet();
arg1.put("foo", entry1);
strFactory.write(arg1);
HashMap<String, HashMap<Integer, RPCTypeCheckTest.AClass>> arg2 =
new HashMap<String, HashMap<Integer, RPCTypeCheckTest.AClass>>();
HashMap<Integer, RPCTypeCheckTest.AClass> entry2 =
new HashMap<Integer, RPCTypeCheckTest.AClass>();
entry2.put(12345, new RPCTypeCheckTest.AClass(1));
arg2.put("bar", entry2);
strFactory.write(arg2);
HashMap<String, HashMap<Integer, List<Long>>> arg3 =
new HashMap<String, HashMap<Integer, List<Long>>>();
HashMap<Integer, List<Long>> entry3 = new HashMap<Integer, List<Long>>();
List<Long> entry4 = new LinkedList<Long>();
entry4.add(new Long(987654321));
entry3.put(67890, entry4);
arg3.put("baz", entry3);
strFactory.write(arg3);
return strFactory.toString();
} catch (Exception e) {
fail(e.getMessage());
return null;
}
}
private static String generateNestedGenericsB() {
try {
RPCTypeCheckFactory strFactory =
new RPCTypeCheckFactory(ContainerParamTestClass.class, "testNestedGenerics");
HashMap<String, HashSet<Integer>> arg1 = new HashMap<String, HashSet<Integer>>();
HashSet<Integer> entry1 = new HashSet<Integer>();
entry1.add(12345);
arg1.put("foo", entry1);
strFactory.write(arg1);
HashMap<String, HashMap<Integer, HashSet>> arg2 =
new HashMap<String, HashMap<Integer, HashSet>>();
HashMap<Integer, HashSet> entry2 = new HashMap<Integer, HashSet>();
entry2.put(12345, RPCTypeCheckFactory.generateTestHashSet());
arg2.put("bar", entry2);
strFactory.write(arg2);
HashMap<String, HashMap<Integer, List<Long>>> arg3 =
new HashMap<String, HashMap<Integer, List<Long>>>();
HashMap<Integer, List<Long>> entry3 = new HashMap<Integer, List<Long>>();
List<Long> entry4 = new LinkedList<Long>();
entry4.add(new Long(987654321));
entry3.put(67890, entry4);
arg3.put("baz", entry3);
strFactory.write(arg3);
return strFactory.toString();
} catch (Exception e) {
fail(e.getMessage());
return null;
}
}
private static String generateNestedGenericsC() {
try {
RPCTypeCheckFactory strFactory =
new RPCTypeCheckFactory(ContainerParamTestClass.class, "testNestedGenerics");
HashMap<String, HashSet<Integer>> arg1 = new HashMap<String, HashSet<Integer>>();
HashSet<Integer> entry1 = new HashSet<Integer>();
entry1.add(12345);
arg1.put("foo", entry1);
strFactory.write(arg1);
HashMap<String, HashMap<Integer, RPCTypeCheckTest.AClass>> arg2 =
new HashMap<String, HashMap<Integer, RPCTypeCheckTest.AClass>>();
HashMap<Integer, RPCTypeCheckTest.AClass> entry2 =
new HashMap<Integer, RPCTypeCheckTest.AClass>();
entry2.put(12345, new RPCTypeCheckTest.AClass(1));
arg2.put("bar", entry2);
strFactory.write(arg2);
HashMap<String, HashMap<Integer, List<HashSet>>> arg3 =
new HashMap<String, HashMap<Integer, List<HashSet>>>();
HashMap<Integer, List<HashSet>> entry3 = new HashMap<Integer, List<HashSet>>();
List<HashSet> entry4 = new LinkedList<HashSet>();
entry4.add(RPCTypeCheckFactory.generateTestHashSet());
entry3.put(67890, entry4);
arg3.put("baz", entry3);
strFactory.write(arg3);
return strFactory.toString();
} catch (Exception e) {
fail(e.getMessage());
return null;
}
}
private static String generateNestedGenericsRaw() {
try {
RPCTypeCheckFactory strFactory =
new RPCTypeCheckFactory(ContainerParamTestClass.class, "testNestedGenericsRaw");
HashMap<String, HashSet<Integer>> arg1 = new HashMap<String, HashSet<Integer>>();
HashSet<Integer> entry1 = new HashSet<Integer>();
entry1.add(12345);
arg1.put("foo", entry1);
strFactory.write(arg1);
HashMap<String, HashMap<Integer, RPCTypeCheckTest.AClass>> arg2 =
new HashMap<String, HashMap<Integer, RPCTypeCheckTest.AClass>>();
HashMap<Integer, RPCTypeCheckTest.AClass> entry2 =
new HashMap<Integer, RPCTypeCheckTest.AClass>();
entry2.put(12345, new RPCTypeCheckTest.AClass(1));
arg2.put("bar", entry2);
strFactory.write(arg2);
HashMap<String, HashMap<Integer, List<Long>>> arg3 =
new HashMap<String, HashMap<Integer, List<Long>>>();
HashMap<Integer, List<Long>> entry3 = new HashMap<Integer, List<Long>>();
List<Long> entry4 = new LinkedList<Long>();
entry4.add(new Long(987654321));
entry3.put(67890, entry4);
arg3.put("baz", entry3);
strFactory.write(arg3);
return strFactory.toString();
} catch (Exception e) {
fail(e.getMessage());
return null;
}
}
private static String generateSetStringSpoofingSetInteger() {
try {
RPCTypeCheckFactory strFactory =
new RPCTypeCheckFactory(ContainerParamTestClass.class, "testSet");
HashSet<Integer> hashSet = new HashSet<Integer>();
hashSet.add(12345);
hashSet.add(67890);
strFactory.write(hashSet);
ReverseSorter<String> sorter = new ReverseSorter<String>();
TreeSet<String> treeSet = new TreeSet<String>(sorter);
treeSet.add("foo");
treeSet.add("bar");
strFactory.write(treeSet);
TestHashSet<Integer> testHashSet = new TestHashSet<Integer>();
testHashSet.add(12345);
testHashSet.add(67890);
strFactory.write(testHashSet);
return strFactory.toString();
} catch (Exception e) {
fail(e.getMessage());
return null;
}
}
private static String generateSetValid(String methodName) {
try {
RPCTypeCheckFactory strFactory =
new RPCTypeCheckFactory(ContainerParamTestClass.class, methodName);
HashSet<Integer> hashSet = new HashSet<Integer>();
hashSet.add(12345);
hashSet.add(67890);
strFactory.write(hashSet);
ReverseSorter<Integer> sorter = new ReverseSorter<Integer>();
TreeSet<Integer> treeSet = new TreeSet<Integer>(sorter);
treeSet.add(12345);
treeSet.add(67890);
strFactory.write(treeSet);
TestHashSet<Integer> treeHashSet = new TestHashSet<Integer>();
treeHashSet.add(12345);
treeHashSet.add(67890);
strFactory.write(treeHashSet);
return strFactory.toString();
} catch (Exception e) {
fail(e.getMessage());
return null;
}
}
private static String generateSingletonListHashSetSpoofingList() {
try {
RPCTypeCheckFactory strFactory =
new RPCTypeCheckFactory(ContainerParamTestClass.class, "testList");
ArrayList<Integer> arrayList = new ArrayList<Integer>();
arrayList.add(12345);
arrayList.add(67890);
strFactory.write(arrayList);
Integer i = 54321;
Integer j = 9876;
List<Integer> arrayAsList = Arrays.asList(i, j);
strFactory.write(arrayAsList);
LinkedList<Integer> linkedList = new LinkedList<Integer>();
linkedList.add(12345);
linkedList.add(67890);
strFactory.write(linkedList);
List<HashSet> singletonList =
Collections.singletonList(RPCTypeCheckFactory.generateTestHashSet());
strFactory.write(singletonList);
return strFactory.toString();
} catch (Exception e) {
fail(e.getMessage());
return null;
}
}
private static String generateTreeMapKeyHashSetSpoofingTreeMap() {
try {
RPCTypeCheckFactory strFactory =
new RPCTypeCheckFactory(ContainerParamTestClass.class, "testMap");
HashMap<String, Integer> hashMap = new HashMap<String, Integer>();
hashMap.put("foo", new Integer(12));
hashMap.put("bar", new Integer(34));
strFactory.write(hashMap);
IdentityHashMap<String, Integer> identityHashMap = new IdentityHashMap<String, Integer>();
identityHashMap.put("foo", new Integer(56));
identityHashMap.put("bar", new Integer(78));
strFactory.write(identityHashMap);
LinkedHashMap<String, Integer> linkedHashMap = new LinkedHashMap<String, Integer>();
linkedHashMap.put("foo", new Integer(90));
linkedHashMap.put("bar", new Integer(12));
strFactory.write(linkedHashMap);
TreeMap<HashSet, Integer> treeMap = new TreeMap<HashSet, Integer>();
treeMap.put(RPCTypeCheckFactory.generateTestHashSet(), 12345);
strFactory.write(treeMap);
return strFactory.toString();
} catch (Exception e) {
fail(e.getMessage());
return null;
}
}
private static String generateTreeMapValueHashSetSpoofingTreeMap() {
try {
RPCTypeCheckFactory strFactory =
new RPCTypeCheckFactory(ContainerParamTestClass.class, "testMap");
HashMap<String, Integer> hashMap = new HashMap<String, Integer>();
hashMap.put("foo", new Integer(12));
hashMap.put("bar", new Integer(34));
strFactory.write(hashMap);
IdentityHashMap<String, Integer> identityHashMap = new IdentityHashMap<String, Integer>();
identityHashMap.put("foo", new Integer(56));
identityHashMap.put("bar", new Integer(78));
strFactory.write(identityHashMap);
LinkedHashMap<String, Integer> linkedHashMap = new LinkedHashMap<String, Integer>();
linkedHashMap.put("foo", new Integer(90));
linkedHashMap.put("bar", new Integer(12));
strFactory.write(linkedHashMap);
TreeMap<String, HashSet> treeMap = new TreeMap<String, HashSet>();
treeMap.put("foo", RPCTypeCheckFactory.generateTestHashSet());
strFactory.write(treeMap);
return strFactory.toString();
} catch (Exception e) {
fail(e.getMessage());
return null;
}
}
@SuppressWarnings("unchecked")
private static String generateTreeSetHashSetSpoofingSetInteger() {
try {
RPCTypeCheckFactory strFactory =
new RPCTypeCheckFactory(ContainerParamTestClass.class, "testSet");
HashSet<Integer> hashSet = new HashSet<Integer>();
hashSet.add(12345);
hashSet.add(67890);
strFactory.write(hashSet);
ReverseSorter sorter = new ReverseSorter();
TreeSet treeSet = new TreeSet(sorter);
treeSet.add(RPCTypeCheckFactory.generateTestHashSet());
strFactory.write(treeSet);
TestHashSet<Integer> treeHashSet = new TestHashSet<Integer>();
treeHashSet.add(12345);
treeHashSet.add(67890);
strFactory.write(treeHashSet);
return strFactory.toString();
} catch (Exception e) {
fail(e.getMessage());
return null;
}
}
private static String generateVectorHashSetSpoofingVector() {
try {
RPCTypeCheckFactory strFactory =
new RPCTypeCheckFactory(ContainerParamTestClass.class, "testVector");
Vector<HashSet> vector = new Vector<HashSet>();
vector.add(RPCTypeCheckFactory.generateTestHashSet());
strFactory.write(vector);
return strFactory.toString();
} catch (Exception e) {
fail(e.getMessage());
return null;
}
}
private static String generateVectorRaw() {
try {
RPCTypeCheckFactory strFactory =
new RPCTypeCheckFactory(ContainerParamTestClass.class, "testVectorRaw");
Vector<Integer> vector = new Vector<Integer>();
vector.add(12345);
vector.add(67890);
strFactory.write(vector);
return strFactory.toString();
} catch (Exception e) {
fail(e.getMessage());
return null;
}
}
/**
* This checks that a List generated by Arrays.asList correctly reports that
* it is an incorrect type.
*/
public void testArraysAsListHashSetSpoofingArraysAsList() {
try {
RPC.decodeRequest(generateArraysAsListHashSetSpoofingArraysAsList());
fail("Expected IncompatibleRemoteServiceException from " +
"testArraysAsListHashSetSpoofingArraysAsList");
} catch (IncompatibleRemoteServiceException e) {
// Expected to get here
assertEquals(SerializedTypeViolationException.class, e.getCause().getClass());
assertTrue(e.getCause().getMessage().matches(".*HashSet.*Integer.*"));
}
}
/**
* This checks that List correctly handles correct types, and reports when it
* gets and incorrectly parameterized generic type.
*/
public void testListSpoofingList() {
try {
RPC.decodeRequest(generateListValid("testList"));
} catch (Exception e) {
fail("Received unexpected Exception from testListSpoofingList (a)" + e.getMessage());
}
try {
RPC.decodeRequest(generateListStringSpoofingListInteger());
fail("Expected IncompatibleRemoteServiceException from testListSpoofingList (1)");
} catch (IncompatibleRemoteServiceException e) {
// Expected to get here
assertEquals(SerializedTypeViolationException.class, e.getCause().getClass());
assertTrue(e.getCause().getMessage().matches(".*String.*Integer.*"));
}
try {
RPC.decodeRequest(generateArrayListHashSetSpoofingList());
fail("Expected IncompatibleRemoteServiceException from testListSpoofingList (2)");
} catch (IncompatibleRemoteServiceException e) {
// Expected to get here
assertEquals(SerializedTypeViolationException.class, e.getCause().getClass());
assertTrue(e.getCause().getMessage().matches(".*HashSet.*Integer.*"));
}
try {
RPC.decodeRequest(generateArraysAsListHashSetSpoofingList());
fail("Expected IncompatibleRemoteServiceException from testListSpoofingList (3)");
} catch (IncompatibleRemoteServiceException e) {
// Expected to get here
assertEquals(SerializedTypeViolationException.class, e.getCause().getClass());
assertTrue(e.getCause().getMessage().matches(".*HashSet.*Integer.*"));
}
try {
RPC.decodeRequest(generateLinkedListHashSetSpoofingList());
fail("Expected IncompatibleRemoteServiceException from testListSpoofingList (4)");
} catch (IncompatibleRemoteServiceException e) {
// Expected to get here
assertEquals(SerializedTypeViolationException.class, e.getCause().getClass());
assertTrue(e.getCause().getMessage().matches(".*HashSet.*Integer.*"));
}
try {
RPC.decodeRequest(generateSingletonListHashSetSpoofingList());
fail("Expected IncompatibleRemoteServiceException from testListSpoofingList (5)");
} catch (IncompatibleRemoteServiceException e) {
// Expected to get here
assertEquals(SerializedTypeViolationException.class, e.getCause().getClass());
assertTrue(e.getCause().getMessage().matches(".*HashSet.*Integer.*"));
}
}
/**
* This checks that List correctly handles correct types, and reports when it
* gets and incorrectly parameterized generic type.
*/
public void testListSpoofingListRaw() {
try {
RPC.decodeRequest(generateListValid("testListRaw"));
} catch (Exception e) {
fail("Received unexpected Exception from testListSpoofingListRaw" + e.getMessage());
}
}
/**
* This checks that Maps correctly reports when it's generic parameter types
* do not match the actual contents.
*/
public void testMapHashSetSpoofingMap() {
try {
RPC.decodeRequest(generateHashMapKeyHashSetSpoofingHashMap());
fail("Expected IncompatibleRemoteServiceException from " +
"testHashMapHashSetSpoofingHashMap (1)");
} catch (IncompatibleRemoteServiceException e) {
// Expected to get here
assertEquals(SerializedTypeViolationException.class, e.getCause().getClass());
assertTrue(e.getCause().getMessage().matches(".*HashSet.*String.*"));
}
try {
RPC.decodeRequest(generateHashMapValueHashSetSpoofingHashMap());
fail("Expected IncompatibleRemoteServiceException from " +
"testHashMapHashSetSpoofingHashMap (2)");
} catch (IncompatibleRemoteServiceException e) {
// Expected to get here
assertEquals(SerializedTypeViolationException.class, e.getCause().getClass());
assertTrue(e.getCause().getMessage().matches(".*HashSet.*Integer.*"));
}
try {
RPC.decodeRequest(generateIdentityHashMapKeyHashSetSpoofingIdentityHashMap());
fail("Expected IncompatibleRemoteServiceException from " +
"testHashMapHashSetSpoofingHashMap (3)");
} catch (IncompatibleRemoteServiceException e) {
// Expected to get here
assertEquals(SerializedTypeViolationException.class, e.getCause().getClass());
assertTrue(e.getCause().getMessage().matches(".*HashSet.*String.*"));
}
try {
RPC.decodeRequest(generateIdentityHashMapValueHashSetSpoofingIdentityHashMap());
fail("Expected IncompatibleRemoteServiceException from " +
"testHashMapHashSetSpoofingHashMap (4)");
} catch (IncompatibleRemoteServiceException e) {
// Expected to get here
assertEquals(SerializedTypeViolationException.class, e.getCause().getClass());
assertTrue(e.getCause().getMessage().matches(".*HashSet.*Integer.*"));
}
try {
RPC.decodeRequest(generateLinkedHashMapKeyHashSetSpoofingLinkedHashMap());
fail("Expected IncompatibleRemoteServiceException from " +
"testHashMapHashSetSpoofingHashMap (5)");
} catch (IncompatibleRemoteServiceException e) {
// Expected to get here
assertEquals(SerializedTypeViolationException.class, e.getCause().getClass());
assertTrue(e.getCause().getMessage().matches(".*HashSet.*String.*"));
}
try {
RPC.decodeRequest(generateLinkedHashMapValueHashSetSpoofingLinkedHashMap());
fail("Expected IncompatibleRemoteServiceException from " +
"testHashMapHashSetSpoofingHashMap (6)");
} catch (IncompatibleRemoteServiceException e) {
// Expected to get here
assertEquals(SerializedTypeViolationException.class, e.getCause().getClass());
assertTrue(e.getCause().getMessage().matches(".*HashSet.*Integer.*"));
}
try {
RPC.decodeRequest(generateTreeMapKeyHashSetSpoofingTreeMap());
fail("Expected IncompatibleRemoteServiceException from " +
"testHashMapHashSetSpoofingHashMap (7)");
} catch (IncompatibleRemoteServiceException e) {
// Expected to get here
assertEquals(SerializedTypeViolationException.class, e.getCause().getClass());
assertTrue(e.getCause().getMessage().matches(".*HashSet.*String.*"));
}
try {
RPC.decodeRequest(generateTreeMapValueHashSetSpoofingTreeMap());
fail("Expected IncompatibleRemoteServiceException from " +
"testHashMapHashSetSpoofingHashMap (8)");
} catch (IncompatibleRemoteServiceException e) {
// Expected to get here
assertEquals(SerializedTypeViolationException.class, e.getCause().getClass());
assertTrue(e.getCause().getMessage().matches(".*HashSet.*Integer.*"));
}
}
/**
* This checks that Maps correctly processes raw maps without type information.
*/
public void testMapRaw() {
try {
RPC.decodeRequest(generateMapRaw());
} catch (Exception e) {
fail("Unexpected Exception from testMapRaw: " + e.getMessage());
}
}
/**
* This checks that nested generics types are checked correctly.
*/
public void testNestedGenerics() {
try {
RPC.decodeRequest(generateNestedGenericsA());
fail("Expected IncompatibleRemoteServiceException from testNestedGenerics (1)");
} catch (IncompatibleRemoteServiceException e) {
// Expected to get here
assertEquals(SerializedTypeViolationException.class, e.getCause().getClass());
assertTrue(e.getCause().getMessage().matches(".*HashSet.*Integer.*"));
}
try {
RPC.decodeRequest(generateNestedGenericsB());
fail("Expected IncompatibleRemoteServiceException from testNestedGenerics (2)");
} catch (IncompatibleRemoteServiceException e) {
// Expected to get here
assertEquals(SerializedTypeViolationException.class, e.getCause().getClass());
assertTrue(e.getCause().getMessage().matches(".*HashSet.*AClass.*"));
}
try {
RPC.decodeRequest(generateNestedGenericsC());
fail("Expected IncompatibleRemoteServiceException from testNestedGenerics (3)");
} catch (IncompatibleRemoteServiceException e) {
// Expected to get here
assertEquals(SerializedTypeViolationException.class, e.getCause().getClass());
assertTrue(e.getCause().getMessage().matches(".*HashSet.*Long.*"));
}
}
/**
* This checks that raw nested generics types are checked correctly.
*/
public void testNestedGenericsRaw() {
try {
RPC.decodeRequest(generateNestedGenericsRaw());
} catch (Exception e) {
fail("Unexpected Exception from testNestedGenericsRaw: " + e.getMessage());
}
}
/**
* This checks that Set correctly handles correct types, and reports when it
* gets and incorrectly parameterized generic type.
*/
public void testSetHashSetSpoofingSet() {
try {
RPC.decodeRequest(generateSetValid("testSet"));
} catch (Exception e) {
fail("Received unexpected Exception from testSetSpoofingSet (1)" + e.getMessage());
}
try {
RPC.decodeRequest(generateSetStringSpoofingSetInteger());
fail("Expected IncompatibleRemoteServiceException from testSetSpoofingSet (2)");
} catch (IncompatibleRemoteServiceException e) {
// Expected to get here
assertEquals(SerializedTypeViolationException.class, e.getCause().getClass());
assertTrue(e.getCause().getMessage().matches(".*String.*Integer.*"));
}
try {
RPC.decodeRequest(generateHashSetHashSetSpoofingSetInteger());
fail("Expected IncompatibleRemoteServiceException from testSetSpoofingSet (3)");
} catch (IncompatibleRemoteServiceException e) {
// Expected to get here
assertEquals(SerializedTypeViolationException.class, e.getCause().getClass());
assertTrue(e.getCause().getMessage().matches(".*HashSet.*Integer.*"));
}
try {
RPC.decodeRequest(generateLinkedHashSetHashSetSpoofingSetInteger());
fail("Expected IncompatibleRemoteServiceException from testSetSpoofingSet (4)");
} catch (IncompatibleRemoteServiceException e) {
// Expected to get here
assertEquals(SerializedTypeViolationException.class, e.getCause().getClass());
assertTrue(e.getCause().getMessage().matches(".*HashSet.*Integer.*"));
}
try {
RPC.decodeRequest(generateTreeSetHashSetSpoofingSetInteger());
fail("Expected IncompatibleRemoteServiceException from testSetSpoofingSet (5)");
} catch (IncompatibleRemoteServiceException e) {
// Expected to get here
assertEquals(SerializedTypeViolationException.class, e.getCause().getClass());
assertTrue(e.getCause().getMessage().matches(".*HashSet.*Integer.*"));
}
}
/**
* This checks that a raw Set does not generate errors.
*/
public void testSetRaw() {
try {
RPC.decodeRequest(generateSetValid("testSetRaw"));
} catch (Exception e) {
fail("Received unexpected Exception from testSetRaw:" + e.getMessage());
}
}
/**
* This checks that Vector correctly reports an incorrect generic type.
*/
public void testVectorHashSetSpoofingVector() {
try {
RPC.decodeRequest(generateVectorHashSetSpoofingVector());
fail("Expected IncompatibleRemoteServiceException from testVectorHashSetSpoofingVector");
} catch (IncompatibleRemoteServiceException e) {
// Expected to get here
assertEquals(SerializedTypeViolationException.class, e.getCause().getClass());
assertTrue(e.getCause().getMessage().matches(".*HashSet.*Integer.*"));
}
}
/**
* This checks that a raw Vector allows any type.
*/
public void testVectorRaw() {
try {
RPC.decodeRequest(generateVectorRaw());
} catch (Exception e) {
fail("Received unexpected Exception from testVectorRaw:" + e.getMessage());
}
}
}