auth/Subject/SubjectNullTests.java

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