| /* |
| * 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()); |
| } |
| } |
| } |