| /* |
| * Copyright (c) 2014, 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 8015081 |
| * @modules java.management |
| * java.security.jgss |
| * @compile Subject.java |
| * @compile SubjectNullTests.java |
| * @build SubjectNullTests |
| * @run main SubjectNullTests |
| * @summary javax.security.auth.Subject.toString() throws NPE |
| */ |
| |
| import java.io.File; |
| import java.io.ByteArrayInputStream; |
| import java.io.FileInputStream; |
| import java.io.ObjectInputStream; |
| import java.io.IOException; |
| import java.security.Principal; |
| import java.util.Arrays; |
| import java.util.Collection; |
| import java.util.HashSet; |
| import java.util.LinkedList; |
| import java.util.List; |
| import java.util.Set; |
| import javax.management.remote.JMXPrincipal; |
| import javax.security.auth.Subject; |
| import javax.security.auth.x500.X500Principal; |
| import javax.security.auth.kerberos.KerberosPrincipal; |
| |
| public class SubjectNullTests { |
| |
| // Value templates for the constructor |
| private static Principal[] princVals = { |
| new X500Principal("CN=Tom Sawyer, ST=Missouri, C=US"), |
| new JMXPrincipal("Huckleberry Finn"), |
| new KerberosPrincipal("mtwain/author@LITERATURE.US") |
| }; |
| private static String[] pubVals = {"tsawyer", "hfinn", "mtwain"}; |
| private static String[] privVals = {"th3R!v3r", "oNth3R4ft", "5Cl3M3nz"}; |
| |
| // Templates for collection-based modifiers for the Subject |
| private static Principal[] tmplAddPrincs = { |
| new X500Principal("CN=John Doe, O=Bogus Corp."), |
| new KerberosPrincipal("jdoe/admin@BOGUSCORP.COM") |
| }; |
| private static String[] tmplAddPubVals = {"jdoe", "djoe"}; |
| private static String[] tmplAddPrvVals = {"b4dpa55w0rd", "pass123"}; |
| |
| /** |
| * Byte arrays used for deserialization: |
| * These byte arrays contain serialized Subjects and SecureSets, |
| * either with or without nulls. These use |
| * jjjjj.security.auth.Subject, which is a modified Subject |
| * implementation that allows the addition of null elements |
| */ |
| private static final byte[] SUBJ_NO_NULL = |
| jjjjj.security.auth.Subject.enc(makeSubjWithNull(false)); |
| private static final byte[] SUBJ_WITH_NULL = |
| jjjjj.security.auth.Subject.enc(makeSubjWithNull(true)); |
| private static final byte[] PRIN_NO_NULL = |
| jjjjj.security.auth.Subject.enc(makeSecSetWithNull(false)); |
| private static final byte[] PRIN_WITH_NULL = |
| jjjjj.security.auth.Subject.enc(makeSecSetWithNull(true)); |
| |
| /** |
| * Method to allow creation of a subject that can optionally |
| * insert a null reference into the principals Set. |
| */ |
| private static jjjjj.security.auth.Subject makeSubjWithNull( |
| boolean nullPrinc) { |
| Set<Principal> setPrinc = new HashSet<>(Arrays.asList(princVals)); |
| if (nullPrinc) { |
| setPrinc.add(null); |
| } |
| |
| return (new jjjjj.security.auth.Subject(setPrinc)); |
| } |
| |
| /** |
| * Method to allow creation of a SecureSet that can optionally |
| * insert a null reference. |
| */ |
| private static Set<Principal> makeSecSetWithNull(boolean nullPrinc) { |
| Set<Principal> setPrinc = new HashSet<>(Arrays.asList(princVals)); |
| if (nullPrinc) { |
| setPrinc.add(null); |
| } |
| |
| jjjjj.security.auth.Subject subj = |
| new jjjjj.security.auth.Subject(setPrinc); |
| |
| return subj.getPrincipals(); |
| } |
| |
| /** |
| * Construct a subject, and optionally place a null in any one |
| * of the three Sets used to initialize a Subject's values |
| */ |
| private static Subject makeSubj(boolean nullPrinc, boolean nullPub, |
| boolean nullPriv) { |
| Set<Principal> setPrinc = new HashSet<>(Arrays.asList(princVals)); |
| Set<String> setPubCreds = new HashSet<>(Arrays.asList(pubVals)); |
| Set<String> setPrvCreds = new HashSet<>(Arrays.asList(privVals)); |
| |
| if (nullPrinc) { |
| setPrinc.add(null); |
| } |
| |
| if (nullPub) { |
| setPubCreds.add(null); |
| } |
| |
| if (nullPriv) { |
| setPrvCreds.add(null); |
| } |
| |
| return (new Subject(false, setPrinc, setPubCreds, setPrvCreds)); |
| } |
| |
| /** |
| * Provide a simple interface for abstracting collection-on-collection |
| * functions |
| */ |
| public interface Function { |
| boolean execCollection(Set<?> subjSet, Collection<?> actorData); |
| } |
| |
| public static final Function methAdd = new Function() { |
| @SuppressWarnings("unchecked") |
| @Override |
| public boolean execCollection(Set<?> subjSet, Collection<?> actorData) { |
| return subjSet.addAll((Collection)actorData); |
| } |
| }; |
| |
| public static final Function methContains = new Function() { |
| @Override |
| public boolean execCollection(Set<?> subjSet, Collection<?> actorData) { |
| return subjSet.containsAll(actorData); |
| } |
| }; |
| |
| public static final Function methRemove = new Function() { |
| @Override |
| public boolean execCollection(Set<?> subjSet, Collection<?> actorData) { |
| return subjSet.removeAll(actorData); |
| } |
| }; |
| |
| public static final Function methRetain = new Function() { |
| @Override |
| public boolean execCollection(Set<?> subjSet, Collection<?> actorData) { |
| return subjSet.retainAll(actorData); |
| } |
| }; |
| |
| /** |
| * Run a test using a specified Collection method upon a Subject's |
| * SecureSet fields. This method expects NullPointerExceptions |
| * to be thrown, and throws RuntimeException when the operation |
| * succeeds |
| */ |
| private static void nullTestCollection(Function meth, Set<?> subjSet, |
| Collection<?> actorData) { |
| try { |
| meth.execCollection(subjSet, actorData); |
| throw new RuntimeException("Failed to throw NullPointerException"); |
| } catch (NullPointerException npe) { |
| System.out.println("Caught expected NullPointerException [PASS]"); |
| } |
| } |
| |
| /** |
| * Run a test using a specified Collection method upon a Subject's |
| * SecureSet fields. This method expects the function and arguments |
| * passed in to complete without exception. It returns false |
| * if either an exception occurs or the result of the operation is |
| * false. |
| */ |
| private static boolean validTestCollection(Function meth, Set<?> subjSet, |
| Collection<?> actorData) { |
| boolean result = false; |
| |
| try { |
| result = meth.execCollection(subjSet, actorData); |
| } catch (Exception exc) { |
| System.out.println("Caught exception " + exc); |
| } |
| |
| return result; |
| } |
| |
| /** |
| * Deserialize an object from a byte array. |
| * |
| * @param type The {@code Class} that the serialized file is supposed |
| * to contain. |
| * @param serBuffer The byte array containing the serialized object data |
| * |
| * @return An object of the type specified in the {@code type} parameter |
| */ |
| private static <T> T deserializeBuffer(Class<T> type, byte[] serBuffer) |
| throws IOException, ClassNotFoundException { |
| |
| ByteArrayInputStream bis = new ByteArrayInputStream(serBuffer); |
| ObjectInputStream ois = new ObjectInputStream(bis); |
| |
| T newObj = type.cast(ois.readObject()); |
| ois.close(); |
| bis.close(); |
| |
| return newObj; |
| } |
| |
| private static void testCTOR() { |
| System.out.println("------ constructor ------"); |
| |
| try { |
| // Case 1: Create a subject with a null principal |
| // Expected result: NullPointerException |
| Subject mtSubj = makeSubj(true, false, false); |
| throw new RuntimeException( |
| "constructor [principal w/ null]: Failed to throw NPE"); |
| } catch (NullPointerException npe) { |
| System.out.println("constructor [principal w/ null]: " + |
| "NullPointerException [PASS]"); |
| } |
| |
| try { |
| // Case 2: Create a subject with a null public credential element |
| // Expected result: NullPointerException |
| Subject mtSubj = makeSubj(false, true, false); |
| throw new RuntimeException( |
| "constructor [pub cred w/ null]: Failed to throw NPE"); |
| } catch (NullPointerException npe) { |
| System.out.println("constructor [pub cred w/ null]: " + |
| "NullPointerException [PASS]"); |
| } |
| |
| try { |
| // Case 3: Create a subject with a null private credential element |
| // Expected result: NullPointerException |
| Subject mtSubj = makeSubj(false, false, true); |
| throw new RuntimeException( |
| "constructor [priv cred w/ null]: Failed to throw NPE"); |
| } catch (NullPointerException npe) { |
| System.out.println("constructor [priv cred w/ null]: " + |
| "NullPointerException [PASS]"); |
| } |
| |
| // Case 4: Create a new subject using the principals, public |
| // and private credentials from another well-formed subject |
| // Expected result: Successful construction |
| Subject srcSubj = makeSubj(false, false, false); |
| Subject mtSubj = new Subject(false, srcSubj.getPrincipals(), |
| srcSubj.getPublicCredentials(), |
| srcSubj.getPrivateCredentials()); |
| System.out.println("Construction from another well-formed Subject's " + |
| "principals/creds [PASS]"); |
| } |
| |
| @SuppressWarnings("unchecked") |
| private static void testDeserialize() throws Exception { |
| System.out.println("------ deserialize -----"); |
| |
| Subject subj = null; |
| Set<Principal> prin = null; |
| |
| // Case 1: positive deserialization test of a Subject |
| // Expected result: well-formed Subject |
| subj = deserializeBuffer(Subject.class, SUBJ_NO_NULL); |
| System.out.println("Positive deserialization test (Subject) passed"); |
| |
| // Case 2: positive deserialization test of a SecureSet |
| // Expected result: well-formed Set |
| prin = deserializeBuffer(Set.class, PRIN_NO_NULL); |
| System.out.println("Positive deserialization test (SecureSet) passed"); |
| |
| System.out.println( |
| "* Testing deserialization with null-poisoned objects"); |
| // Case 3: deserialization test of a null-poisoned Subject |
| // Expected result: NullPointerException |
| try { |
| subj = deserializeBuffer(Subject.class, SUBJ_WITH_NULL); |
| throw new RuntimeException("Failed to throw NullPointerException"); |
| } catch (NullPointerException npe) { |
| System.out.println("Caught expected NullPointerException [PASS]"); |
| } |
| |
| // Case 4: deserialization test of a null-poisoned SecureSet |
| // Expected result: NullPointerException |
| try { |
| prin = deserializeBuffer(Set.class, PRIN_WITH_NULL); |
| throw new RuntimeException("Failed to throw NullPointerException"); |
| } catch (NullPointerException npe) { |
| System.out.println("Caught expected NullPointerException [PASS]"); |
| } |
| } |
| |
| private static void testAdd() { |
| System.out.println("------ add() ------"); |
| // Create a well formed subject |
| Subject mtSubj = makeSubj(false, false, false); |
| |
| try { |
| // Case 1: Attempt to add null values to principal |
| // Expected result: NullPointerException |
| mtSubj.getPrincipals().add(null); |
| throw new RuntimeException( |
| "PRINCIPAL add(null): Failed to throw NPE"); |
| } catch (NullPointerException npe) { |
| System.out.println( |
| "PRINCIPAL add(null): NullPointerException [PASS]"); |
| } |
| |
| try { |
| // Case 2: Attempt to add null into the public creds |
| // Expected result: NullPointerException |
| mtSubj.getPublicCredentials().add(null); |
| throw new RuntimeException( |
| "PUB CRED add(null): Failed to throw NPE"); |
| } catch (NullPointerException npe) { |
| System.out.println( |
| "PUB CRED add(null): NullPointerException [PASS]"); |
| } |
| |
| try { |
| // Case 3: Attempt to add null into the private creds |
| // Expected result: NullPointerException |
| mtSubj.getPrivateCredentials().add(null); |
| throw new RuntimeException( |
| "PRIV CRED add(null): Failed to throw NPE"); |
| } catch (NullPointerException npe) { |
| System.out.println( |
| "PRIV CRED add(null): NullPointerException [PASS]"); |
| } |
| } |
| |
| private static void testRemove() { |
| System.out.println("------ remove() ------"); |
| // Create a well formed subject |
| Subject mtSubj = makeSubj(false, false, false); |
| |
| try { |
| // Case 1: Attempt to remove null values from principal |
| // Expected result: NullPointerException |
| mtSubj.getPrincipals().remove(null); |
| throw new RuntimeException( |
| "PRINCIPAL remove(null): Failed to throw NPE"); |
| } catch (NullPointerException npe) { |
| System.out.println( |
| "PRINCIPAL remove(null): NullPointerException [PASS]"); |
| } |
| |
| try { |
| // Case 2: Attempt to remove null from the public creds |
| // Expected result: NullPointerException |
| mtSubj.getPublicCredentials().remove(null); |
| throw new RuntimeException( |
| "PUB CRED remove(null): Failed to throw NPE"); |
| } catch (NullPointerException npe) { |
| System.out.println( |
| "PUB CRED remove(null): NullPointerException [PASS]"); |
| } |
| |
| try { |
| // Case 3: Attempt to remove null from the private creds |
| // Expected result: NullPointerException |
| mtSubj.getPrivateCredentials().remove(null); |
| throw new RuntimeException( |
| "PRIV CRED remove(null): Failed to throw NPE"); |
| } catch (NullPointerException npe) { |
| System.out.println( |
| "PRIV CRED remove(null): NullPointerException [PASS]"); |
| } |
| } |
| |
| private static void testContains() { |
| System.out.println("------ contains() ------"); |
| // Create a well formed subject |
| Subject mtSubj = makeSubj(false, false, false); |
| |
| try { |
| // Case 1: Attempt to check for null values in principals |
| // Expected result: NullPointerException |
| mtSubj.getPrincipals().contains(null); |
| throw new RuntimeException( |
| "PRINCIPAL contains(null): Failed to throw NPE"); |
| } catch (NullPointerException npe) { |
| System.out.println( |
| "PRINCIPAL contains(null): NullPointerException [PASS]"); |
| } |
| |
| try { |
| // Case 2: Attempt to check for null in public creds |
| // Expected result: NullPointerException |
| mtSubj.getPublicCredentials().contains(null); |
| throw new RuntimeException( |
| "PUB CRED contains(null): Failed to throw NPE"); |
| } catch (NullPointerException npe) { |
| System.out.println( |
| "PUB CRED contains(null): NullPointerException [PASS]"); |
| } |
| |
| try { |
| // Case 3: Attempt to check for null in private creds |
| // Expected result: NullPointerException |
| mtSubj.getPrivateCredentials().contains(null); |
| throw new RuntimeException( |
| "PRIV CRED contains(null): Failed to throw NPE"); |
| } catch (NullPointerException npe) { |
| System.out.println( |
| "PRIV CRED contains(null): NullPointerException [PASS]"); |
| } |
| } |
| |
| private static void testAddAll() { |
| // Create a well formed subject and additional collections |
| Subject mtSubj = makeSubj(false, false, false); |
| Set<Principal> morePrincs = new HashSet<>(Arrays.asList(tmplAddPrincs)); |
| Set<Object> morePubVals = new HashSet<>(Arrays.asList(tmplAddPubVals)); |
| Set<Object> morePrvVals = new HashSet<>(Arrays.asList(tmplAddPrvVals)); |
| |
| // Run one success test for each Subject family to verify the |
| // overloaded method works as intended. |
| Set<Principal> setPrin = mtSubj.getPrincipals(); |
| Set<Object> setPubCreds = mtSubj.getPublicCredentials(); |
| Set<Object> setPrvCreds = mtSubj.getPrivateCredentials(); |
| int prinOrigSize = setPrin.size(); |
| int pubOrigSize = setPubCreds.size(); |
| int prvOrigSize = setPrvCreds.size(); |
| |
| System.out.println("------ addAll() -----"); |
| |
| // Add the new members, then check the resulting size of the |
| // Subject attributes to verify they've increased by the proper |
| // amounts. |
| if ((validTestCollection(methAdd, setPrin, morePrincs) != true) || |
| (setPrin.size() != prinOrigSize + morePrincs.size())) |
| { |
| throw new RuntimeException("Failed addAll() on principals"); |
| } |
| if ((validTestCollection(methAdd, setPubCreds, |
| morePubVals) != true) || |
| (setPubCreds.size() != pubOrigSize + morePubVals.size())) |
| { |
| throw new RuntimeException("Failed addAll() on public creds"); |
| } |
| if ((validTestCollection(methAdd, setPrvCreds, |
| morePrvVals) != true) || |
| (setPrvCreds.size() != prvOrigSize + morePrvVals.size())) |
| { |
| throw new RuntimeException("Failed addAll() on private creds"); |
| } |
| System.out.println("Positive addAll() test passed"); |
| |
| // Now add null elements into each container, then retest |
| morePrincs.add(null); |
| morePubVals.add(null); |
| morePrvVals.add(null); |
| |
| System.out.println("* Testing addAll w/ null values on Principals"); |
| nullTestCollection(methAdd, mtSubj.getPrincipals(), null); |
| nullTestCollection(methAdd, mtSubj.getPrincipals(), morePrincs); |
| |
| System.out.println("* Testing addAll w/ null values on Public Creds"); |
| nullTestCollection(methAdd, mtSubj.getPublicCredentials(), null); |
| nullTestCollection(methAdd, mtSubj.getPublicCredentials(), |
| morePubVals); |
| |
| System.out.println("* Testing addAll w/ null values on Private Creds"); |
| nullTestCollection(methAdd, mtSubj.getPrivateCredentials(), null); |
| nullTestCollection(methAdd, mtSubj.getPrivateCredentials(), |
| morePrvVals); |
| } |
| |
| private static void testRemoveAll() { |
| // Create a well formed subject and additional collections |
| Subject mtSubj = makeSubj(false, false, false); |
| Set<Principal> remPrincs = new HashSet<>(); |
| Set<Object> remPubVals = new HashSet<>(); |
| Set<Object> remPrvVals = new HashSet<>(); |
| |
| remPrincs.add(new KerberosPrincipal("mtwain/author@LITERATURE.US")); |
| remPubVals.add("mtwain"); |
| remPrvVals.add("5Cl3M3nz"); |
| |
| // Run one success test for each Subject family to verify the |
| // overloaded method works as intended. |
| Set<Principal> setPrin = mtSubj.getPrincipals(); |
| Set<Object> setPubCreds = mtSubj.getPublicCredentials(); |
| Set<Object> setPrvCreds = mtSubj.getPrivateCredentials(); |
| int prinOrigSize = setPrin.size(); |
| int pubOrigSize = setPubCreds.size(); |
| int prvOrigSize = setPrvCreds.size(); |
| |
| System.out.println("------ removeAll() -----"); |
| |
| // Remove the specified members, then check the resulting size of the |
| // Subject attributes to verify they've decreased by the proper |
| // amounts. |
| if ((validTestCollection(methRemove, setPrin, remPrincs) != true) || |
| (setPrin.size() != prinOrigSize - remPrincs.size())) |
| { |
| throw new RuntimeException("Failed removeAll() on principals"); |
| } |
| if ((validTestCollection(methRemove, setPubCreds, |
| remPubVals) != true) || |
| (setPubCreds.size() != pubOrigSize - remPubVals.size())) |
| { |
| throw new RuntimeException("Failed removeAll() on public creds"); |
| } |
| if ((validTestCollection(methRemove, setPrvCreds, |
| remPrvVals) != true) || |
| (setPrvCreds.size() != prvOrigSize - remPrvVals.size())) |
| { |
| throw new RuntimeException("Failed removeAll() on private creds"); |
| } |
| System.out.println("Positive removeAll() test passed"); |
| |
| // Now add null elements into each container, then retest |
| remPrincs.add(null); |
| remPubVals.add(null); |
| remPrvVals.add(null); |
| |
| System.out.println("* Testing removeAll w/ null values on Principals"); |
| nullTestCollection(methRemove, mtSubj.getPrincipals(), null); |
| nullTestCollection(methRemove, mtSubj.getPrincipals(), remPrincs); |
| |
| System.out.println( |
| "* Testing removeAll w/ null values on Public Creds"); |
| nullTestCollection(methRemove, mtSubj.getPublicCredentials(), null); |
| nullTestCollection(methRemove, mtSubj.getPublicCredentials(), |
| remPubVals); |
| |
| System.out.println( |
| "* Testing removeAll w/ null values on Private Creds"); |
| nullTestCollection(methRemove, mtSubj.getPrivateCredentials(), null); |
| nullTestCollection(methRemove, mtSubj.getPrivateCredentials(), |
| remPrvVals); |
| } |
| |
| private static void testContainsAll() { |
| // Create a well formed subject and additional collections |
| Subject mtSubj = makeSubj(false, false, false); |
| Set<Principal> testPrincs = new HashSet<>(Arrays.asList(princVals)); |
| Set<Object> testPubVals = new HashSet<>(Arrays.asList(pubVals)); |
| Set<Object> testPrvVals = new HashSet<>(Arrays.asList(privVals)); |
| |
| System.out.println("------ containsAll() -----"); |
| |
| // Run one success test for each Subject family to verify the |
| // overloaded method works as intended. |
| if ((validTestCollection(methContains, mtSubj.getPrincipals(), |
| testPrincs) == false) && |
| (validTestCollection(methContains, mtSubj.getPublicCredentials(), |
| testPubVals) == false) && |
| (validTestCollection(methContains, |
| mtSubj.getPrivateCredentials(), testPrvVals) == false)) { |
| throw new RuntimeException("Valid containsAll() check failed"); |
| } |
| System.out.println("Positive containsAll() test passed"); |
| |
| // Now let's add a null into each collection and watch the fireworks. |
| testPrincs.add(null); |
| testPubVals.add(null); |
| testPrvVals.add(null); |
| |
| System.out.println( |
| "* Testing containsAll w/ null values on Principals"); |
| nullTestCollection(methContains, mtSubj.getPrincipals(), null); |
| nullTestCollection(methContains, mtSubj.getPrincipals(), testPrincs); |
| |
| System.out.println( |
| "* Testing containsAll w/ null values on Public Creds"); |
| nullTestCollection(methContains, mtSubj.getPublicCredentials(), |
| null); |
| nullTestCollection(methContains, mtSubj.getPublicCredentials(), |
| testPubVals); |
| |
| System.out.println( |
| "* Testing containsAll w/ null values on Private Creds"); |
| nullTestCollection(methContains, mtSubj.getPrivateCredentials(), |
| null); |
| nullTestCollection(methContains, mtSubj.getPrivateCredentials(), |
| testPrvVals); |
| } |
| |
| private static void testRetainAll() { |
| // Create a well formed subject and additional collections |
| Subject mtSubj = makeSubj(false, false, false); |
| Set<Principal> remPrincs = new HashSet<>(Arrays.asList(tmplAddPrincs)); |
| Set<Object> remPubVals = new HashSet<>(Arrays.asList(tmplAddPubVals)); |
| Set<Object> remPrvVals = new HashSet<>(Arrays.asList(tmplAddPrvVals)); |
| |
| // Add in values that exist within the Subject |
| remPrincs.add(princVals[2]); |
| remPubVals.add(pubVals[2]); |
| remPrvVals.add(privVals[2]); |
| |
| // Run one success test for each Subject family to verify the |
| // overloaded method works as intended. |
| Set<Principal> setPrin = mtSubj.getPrincipals(); |
| Set<Object> setPubCreds = mtSubj.getPublicCredentials(); |
| Set<Object> setPrvCreds = mtSubj.getPrivateCredentials(); |
| int prinOrigSize = setPrin.size(); |
| int pubOrigSize = setPubCreds.size(); |
| int prvOrigSize = setPrvCreds.size(); |
| |
| System.out.println("------ retainAll() -----"); |
| |
| // Retain the specified members (those that exist in the Subject) |
| // and validate the results. |
| if (validTestCollection(methRetain, setPrin, remPrincs) == false || |
| setPrin.size() != 1 || setPrin.contains(princVals[2]) == false) |
| { |
| throw new RuntimeException("Failed retainAll() on principals"); |
| } |
| |
| if (validTestCollection(methRetain, setPubCreds, |
| remPubVals) == false || |
| setPubCreds.size() != 1 || |
| setPubCreds.contains(pubVals[2]) == false) |
| { |
| throw new RuntimeException("Failed retainAll() on public creds"); |
| } |
| if (validTestCollection(methRetain, setPrvCreds, |
| remPrvVals) == false || |
| setPrvCreds.size() != 1 || |
| setPrvCreds.contains(privVals[2]) == false) |
| { |
| throw new RuntimeException("Failed retainAll() on private creds"); |
| } |
| System.out.println("Positive retainAll() test passed"); |
| |
| // Now add null elements into each container, then retest |
| remPrincs.add(null); |
| remPubVals.add(null); |
| remPrvVals.add(null); |
| |
| System.out.println("* Testing retainAll w/ null values on Principals"); |
| nullTestCollection(methRetain, mtSubj.getPrincipals(), null); |
| nullTestCollection(methRetain, mtSubj.getPrincipals(), remPrincs); |
| |
| System.out.println( |
| "* Testing retainAll w/ null values on Public Creds"); |
| nullTestCollection(methRetain, mtSubj.getPublicCredentials(), null); |
| nullTestCollection(methRetain, mtSubj.getPublicCredentials(), |
| remPubVals); |
| |
| System.out.println( |
| "* Testing retainAll w/ null values on Private Creds"); |
| nullTestCollection(methRetain, mtSubj.getPrivateCredentials(), null); |
| nullTestCollection(methRetain, mtSubj.getPrivateCredentials(), |
| remPrvVals); |
| } |
| |
| private static void testIsEmpty() { |
| Subject populatedSubj = makeSubj(false, false, false); |
| Subject emptySubj = new Subject(); |
| |
| System.out.println("------ isEmpty() -----"); |
| |
| if (populatedSubj.getPrincipals().isEmpty()) { |
| throw new RuntimeException( |
| "Populated Subject Principals incorrectly returned empty"); |
| } |
| if (emptySubj.getPrincipals().isEmpty() == false) { |
| throw new RuntimeException( |
| "Empty Subject Principals incorrectly returned non-empty"); |
| } |
| System.out.println("isEmpty() test passed"); |
| } |
| |
| private static void testSecureSetEquals() { |
| System.out.println("------ SecureSet.equals() -----"); |
| |
| Subject subj = makeSubj(false, false, false); |
| Subject subjComp = makeSubj(false, false, false); |
| |
| // Case 1: null comparison [expect false] |
| if (subj.getPublicCredentials().equals(null) != false) { |
| throw new RuntimeException( |
| "equals(null) incorrectly returned true"); |
| } |
| |
| // Case 2: Self-comparison [expect true] |
| Set<Principal> princs = subj.getPrincipals(); |
| princs.equals(subj.getPrincipals()); |
| |
| // Case 3: Comparison with non-Set type [expect false] |
| List<Principal> listPrinc = new LinkedList<>(Arrays.asList(princVals)); |
| if (subj.getPublicCredentials().equals(listPrinc) != false) { |
| throw new RuntimeException( |
| "equals([Non-Set]) incorrectly returned true"); |
| } |
| |
| // Case 4: SecureSets of differing sizes [expect false] |
| Subject subj1princ = new Subject(); |
| Subject subj2princ = new Subject(); |
| subj1princ.getPrincipals().add( |
| new X500Principal("CN=Tom Sawyer, ST=Missouri, C=US")); |
| subj1princ.getPrincipals().add( |
| new X500Principal("CN=John Doe, O=Bogus Corp.")); |
| subj2princ.getPrincipals().add( |
| new X500Principal("CN=Tom Sawyer, ST=Missouri, C=US")); |
| if (subj1princ.getPrincipals().equals( |
| subj2princ.getPrincipals()) != false) { |
| throw new RuntimeException( |
| "equals([differing sizes]) incorrectly returned true"); |
| } |
| |
| // Case 5: Content equality test [expect true] |
| Set<Principal> equalSet = new HashSet<>(Arrays.asList(princVals)); |
| if (subj.getPrincipals().equals(equalSet) != true) { |
| throw new RuntimeException( |
| "equals([equivalent set]) incorrectly returned false"); |
| } |
| |
| // Case 5: Content inequality test [expect false] |
| // Note: to not fall into the size inequality check the two |
| // sets need to have the same number of elements. |
| Set<Principal> inequalSet = |
| new HashSet<Principal>(Arrays.asList(tmplAddPrincs)); |
| inequalSet.add(new JMXPrincipal("Samuel Clemens")); |
| |
| if (subj.getPrincipals().equals(inequalSet) != false) { |
| throw new RuntimeException( |
| "equals([equivalent set]) incorrectly returned false"); |
| } |
| System.out.println("SecureSet.equals() tests passed"); |
| } |
| |
| private static void testSecureSetHashCode() { |
| System.out.println("------ SecureSet.hashCode() -----"); |
| |
| Subject subj = makeSubj(false, false, false); |
| |
| // Make sure two other Set types that we know are equal per |
| // SecureSet.equals() and verify their hashCodes are also the same |
| Set<Principal> equalHashSet = new HashSet<>(Arrays.asList(princVals)); |
| |
| if (subj.getPrincipals().hashCode() != equalHashSet.hashCode()) { |
| throw new RuntimeException( |
| "SecureSet and HashSet hashCodes() differ"); |
| } |
| System.out.println("SecureSet.hashCode() tests passed"); |
| } |
| |
| private static void testToArray() { |
| System.out.println("------ toArray() -----"); |
| |
| Subject subj = makeSubj(false, false, false); |
| |
| // Case 1: no-parameter toArray with equality comparison |
| // Expected result: true |
| List<Object> alSubj = Arrays.asList(subj.getPrincipals().toArray()); |
| List<Principal> alPrincs = Arrays.asList(princVals); |
| |
| if (alSubj.size() != alPrincs.size() || |
| alSubj.containsAll(alPrincs) != true) { |
| throw new RuntimeException( |
| "Unexpected inequality on returned toArray()"); |
| } |
| |
| // Case 2: generic-type toArray where passed array is of sufficient |
| // size. |
| // Expected result: returned Array is reference-equal to input param |
| // and content equal to data used to construct the originating Subject. |
| Principal[] pBlock = new Principal[3]; |
| Principal[] pBlockRef = subj.getPrincipals().toArray(pBlock); |
| alSubj = Arrays.asList((Object[])pBlockRef); |
| |
| if (pBlockRef != pBlock) { |
| throw new RuntimeException( |
| "Unexpected reference-inequality on returned toArray(T[])"); |
| } else if (alSubj.size() != alPrincs.size() || |
| alSubj.containsAll(alPrincs) != true) { |
| throw new RuntimeException( |
| "Unexpected content-inequality on returned toArray(T[])"); |
| } |
| |
| // Case 3: generic-type toArray where passed array is of |
| // insufficient size. |
| // Expected result: returned Array is not reference-equal to |
| // input param but is content equal to data used to construct the |
| // originating Subject. |
| pBlock = new Principal[1]; |
| pBlockRef = subj.getPrincipals().toArray(pBlock); |
| alSubj = Arrays.asList((Object[])pBlockRef); |
| |
| if (pBlockRef == pBlock) { |
| throw new RuntimeException( |
| "Unexpected reference-equality on returned toArray(T[])"); |
| } else if (alSubj.size() != alPrincs.size() || |
| alSubj.containsAll(alPrincs) != true) { |
| throw new RuntimeException( |
| "Unexpected content-inequality on returned toArray(T[])"); |
| } |
| System.out.println("toArray() tests passed"); |
| } |
| |
| public static void main(String[] args) throws Exception { |
| |
| testCTOR(); |
| |
| testDeserialize(); |
| |
| testAdd(); |
| |
| testRemove(); |
| |
| testContains(); |
| |
| testAddAll(); |
| |
| testRemoveAll(); |
| |
| testContainsAll(); |
| |
| testRetainAll(); |
| |
| testIsEmpty(); |
| |
| testSecureSetEquals(); |
| |
| testSecureSetHashCode(); |
| |
| testToArray(); |
| } |
| } |
