Merge "Import missing harmony tests for javax.security.auth."

23 files changed, 3242 insertions, 289 deletions

diff --git a/harmony-tests/src/test/java/org/apache/harmony/tests/javax/security/auth/DestroyFailedExceptionTest.java b/harmony-tests/src/test/java/org/apache/harmony/tests/javax/security/auth/DestroyFailedExceptionTest.java
index 4472241..e274c5c 100644
--- a/harmony-tests/src/test/java/org/apache/harmony/tests/javax/security/auth/DestroyFailedExceptionTest.java
+++ b/harmony-tests/src/test/java/org/apache/harmony/tests/javax/security/auth/DestroyFailedExceptionTest.java
@@ -15,11 +15,11 @@
  *  limitations under the License.
  */
 
-package tests.api.javax.security.auth;
+package org.apache.harmony.tests.javax.security.auth;
 
 import junit.framework.TestCase;
-
 import javax.security.auth.DestroyFailedException;
+import org.apache.harmony.testframework.serialization.SerializationTest;
 
 /**
  * Tests for <code>DestroyFailedException</code> class constructors and methods.
@@ -66,4 +66,16 @@ public class DestroyFailedExceptionTest extends TestCase {
         assertNull("getMessage() must return null.", dfE.getMessage());
         assertNull("getCause() must return null", dfE.getCause());
     }
+
+    public void testSerializationSelf() throws Exception {
+        SerializationTest.verifySelf(getSerializationData());
+    }
+
+    public void testSerializationGolden() throws Exception {
+        SerializationTest.verifyGolden(this, getSerializationData());
+    }
+
+    private Object[] getSerializationData() {
+        return new Object[] { new DestroyFailedException("message") };
+    }
 }
diff --git a/harmony-tests/src/test/java/org/apache/harmony/tests/javax/security/auth/DestroyableTest.java b/harmony-tests/src/test/java/org/apache/harmony/tests/javax/security/auth/DestroyableTest.java
index 4ae47ce..c419f64 100644
--- a/harmony-tests/src/test/java/org/apache/harmony/tests/javax/security/auth/DestroyableTest.java
+++ b/harmony-tests/src/test/java/org/apache/harmony/tests/javax/security/auth/DestroyableTest.java
@@ -15,7 +15,7 @@
  *  limitations under the License.
  */
 
-package tests.api.javax.security.auth;
+package org.apache.harmony.tests.javax.security.auth;
 
 import junit.framework.TestCase;
 
diff --git a/harmony-tests/src/test/java/org/apache/harmony/tests/javax/security/auth/LoginExceptionTest.java b/harmony-tests/src/test/java/org/apache/harmony/tests/javax/security/auth/LoginExceptionTest.java
index 307d401..c0540bc 100644
--- a/harmony-tests/src/test/java/org/apache/harmony/tests/javax/security/auth/LoginExceptionTest.java
+++ b/harmony-tests/src/test/java/org/apache/harmony/tests/javax/security/auth/LoginExceptionTest.java
@@ -15,7 +15,7 @@
  *  limitations under the License.
  */
 
-package tests.api.javax.security.auth;
+package org.apache.harmony.tests.javax.security.auth;
 
 import junit.framework.TestCase;
 
diff --git a/harmony-tests/src/test/java/org/apache/harmony/tests/javax/security/auth/SubjectTest.java b/harmony-tests/src/test/java/org/apache/harmony/tests/javax/security/auth/SubjectTest.java
index 05741a9..f2ef564 100644
--- a/harmony-tests/src/test/java/org/apache/harmony/tests/javax/security/auth/SubjectTest.java
+++ b/harmony-tests/src/test/java/org/apache/harmony/tests/javax/security/auth/SubjectTest.java
@@ -15,24 +15,17 @@
  *  limitations under the License.
  */
 
-package tests.api.javax.security.auth;
+package org.apache.harmony.tests.javax.security.auth;
 
 import junit.framework.TestCase;
-
-import javax.security.auth.AuthPermission;
-import javax.security.auth.PrivateCredentialPermission;
 import javax.security.auth.Subject;
-
-import java.util.Set;
-import java.util.HashSet;
-import java.security.Permission;
-import java.security.Principal;
+import java.security.AccessControlContext;
+import java.security.AccessController;
 import java.security.PrivilegedAction;
 import java.security.PrivilegedActionException;
 import java.security.PrivilegedExceptionAction;
-import java.security.AccessControlContext;
-import java.security.AccessController;
 import java.security.ProtectionDomain;
+import org.apache.harmony.testframework.serialization.SerializationTest;
 
 /**
  * Tests for <code>Subject</code> class constructors and methods.
@@ -232,6 +225,20 @@ public class SubjectTest extends TestCase {
             fail("Unexpected exception: " + e);
         }
     }
+
+    public void testSerializationSelf() throws Exception {
+        SerializationTest.verifySelf(getSerializationData());
+    }
+
+    public void testSerializationGolden() throws Exception {
+        SerializationTest.verifyGolden(this, getSerializationData());
+    }
+
+    private Object[] getSerializationData() {
+        Subject subject = new Subject();
+        return new Object[] { subject, subject.getPrincipals(),
+                subject.getPrivateCredentials(), subject.getPublicCredentials() };
+    }
 }
 
 
diff --git a/harmony-tests/src/test/java/org/apache/harmony/tests/javax/security/auth/X500PrincipalTest.java b/harmony-tests/src/test/java/org/apache/harmony/tests/javax/security/auth/X500PrincipalTest.java
deleted file mode 100644
index 7cb81bb..0000000
--- a/harmony-tests/src/test/java/org/apache/harmony/tests/javax/security/auth/X500PrincipalTest.java
+++ /dev/null
@@ -1,270 +0,0 @@
-/*
- *  Licensed to the Apache Software Foundation (ASF) under one or more
- *  contributor license agreements.  See the NOTICE file distributed with
- *  this work for additional information regarding copyright ownership.
- *  The ASF licenses this file to You 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 tests.api.javax.security.auth;
-
-import junit.framework.TestCase;
-
-import javax.security.auth.x500.X500Principal;
-
-import java.io.ByteArrayInputStream;
-import java.io.InputStream;
-import java.security.cert.CertificateFactory;
-import java.security.cert.X509Certificate;
-import org.apache.harmony.security.tests.support.cert.TestUtils;
-
-/**
- * Tests for <code>X500Principal</code> class constructors and methods.
- *
- */
-public class X500PrincipalTest extends TestCase {
-
-    /**
-     * javax.security.auth.x500.X500Principal#X500Principal(String name)
-     */
-    public void test_X500Principal_01() {
-        String name = "CN=Duke,OU=JavaSoft,O=Sun Microsystems,C=US";
-
-        try {
-            X500Principal xpr = new X500Principal(name);
-            assertNotNull("Null object returned", xpr);
-            String resName = xpr.getName();
-            assertEquals(name, resName);
-        } catch (Exception e) {
-            fail("Unexpected exception: " + e);
-        }
-
-        try {
-            X500Principal xpr = new X500Principal((String)null);
-            fail("NullPointerException wasn't thrown");
-        } catch (NullPointerException npe) {
-        } catch (Exception e) {
-            fail(e + " was thrown instead of NullPointerException");
-        }
-
-        try {
-            X500Principal xpr = new X500Principal("X500PrincipalName");
-            fail("IllegalArgumentException wasn't thrown");
-        } catch (IllegalArgumentException npe) {
-        } catch (Exception e) {
-            fail(e + " was thrown instead of IllegalArgumentException");
-        }
-    }
-
-    /**
-     * javax.security.auth.x500.X500Principal#X500Principal(InputStream is)
-     */
-    public void test_X500Principal_02() {
-        String name = "CN=Duke,OU=JavaSoft,O=Sun Microsystems,C=US";
-        byte[] ba = getByteArray(TestUtils.getX509Certificate_v1());
-        ByteArrayInputStream is = new ByteArrayInputStream(ba);
-        InputStream isNull = null;
-
-        try {
-            X500Principal xpr = new X500Principal(is);
-            assertNotNull("Null object returned", xpr);
-            byte[] resArray = xpr.getEncoded();
-            assertEquals(ba.length, resArray.length);
-        } catch (Exception e) {
-            fail("Unexpected exception: " + e);
-        }
-
-        try {
-            X500Principal xpr = new X500Principal(isNull);
-            fail("NullPointerException wasn't thrown");
-        } catch (NullPointerException npe) {
-        } catch (Exception e) {
-            fail(e + " was thrown instead of NullPointerException");
-        }
-
-        is = new ByteArrayInputStream(name.getBytes());
-        try {
-            X500Principal xpr = new X500Principal(is);
-            fail("IllegalArgumentException wasn't thrown");
-        } catch (IllegalArgumentException npe) {
-        } catch (Exception e) {
-            fail(e + " was thrown instead of IllegalArgumentException");
-        }
-    }
-
-    /**
-     * javax.security.auth.x500.X500Principal#X500Principal(byte[] name)
-     */
-    public void test_X500Principal_03() {
-        String name = "CN=Duke,OU=JavaSoft,O=Sun Microsystems,C=US";
-        byte[] ba = getByteArray(TestUtils.getX509Certificate_v1());
-        byte[] baNull = null;
-
-        try {
-            X500Principal xpr = new X500Principal(ba);
-            assertNotNull("Null object returned", xpr);
-            byte[] resArray = xpr.getEncoded();
-            assertEquals(ba.length, resArray.length);
-        } catch (Exception e) {
-            fail("Unexpected exception: " + e);
-        }
-
-        try {
-            X500Principal xpr = new X500Principal(baNull);
-            fail("IllegalArgumentException wasn't thrown");
-        } catch (IllegalArgumentException npe) {
-        } catch (Exception e) {
-            fail(e + " was thrown instead of IllegalArgumentException");
-        }
-
-        ba = name.getBytes();
-        try {
-            X500Principal xpr = new X500Principal(ba);
-            fail("IllegalArgumentException wasn't thrown");
-        } catch (IllegalArgumentException npe) {
-        } catch (Exception e) {
-            fail(e + " was thrown instead of IllegalArgumentException");
-        }
-    }
-
-    /**
-     * javax.security.auth.x500.X500Principal#getName()
-     */
-    public void test_getName() {
-        String name = "CN=Duke,OU=JavaSoft,O=Sun Microsystems,C=US";
-        X500Principal xpr = new X500Principal(name);
-        try {
-            String resName = xpr.getName();
-            assertEquals(name, resName);
-        } catch (Exception e) {
-            fail("Unexpected exception: " + e);
-        }
-    }
-
-    /**
-     * javax.security.auth.x500.X500Principal#getName(String format)
-     */
-    public void test_getName_Format() {
-        String name = "CN=Duke,OU=JavaSoft,O=Sun Microsystems,C=US";
-        String expectedName = "cn=duke,ou=javasoft,o=sun microsystems,c=us";
-        X500Principal xpr = new X500Principal(name);
-        try {
-            String resName = xpr.getName(X500Principal.CANONICAL);
-            assertEquals(expectedName, resName);
-        } catch (Exception e) {
-            fail("Unexpected exception: " + e);
-        }
-
-        expectedName = "CN=Duke, OU=JavaSoft, O=Sun Microsystems, C=US";
-        try {
-            String resName = xpr.getName(X500Principal.RFC1779);
-            assertEquals(expectedName, resName);
-        } catch (Exception e) {
-            fail("Unexpected exception: " + e);
-        }
-
-        try {
-            String resName = xpr.getName(X500Principal.RFC2253);
-            assertEquals(name, resName);
-        } catch (Exception e) {
-            fail("Unexpected exception: " + e);
-        }
-
-        try {
-            String resName = xpr.getName(null);
-            fail("IllegalArgumentException  wasn't thrown");
-        } catch (IllegalArgumentException  iae) {
-        }
-        try {
-            String resName = xpr.getName("RFC2254");
-            fail("IllegalArgumentException  wasn't thrown");
-        } catch (IllegalArgumentException  iae) {
-        }
-    }
-
-    /**
-     * javax.security.auth.x500.X500Principal#hashCode()
-     */
-    public void test_hashCode() {
-        String name = "CN=Duke,OU=JavaSoft,O=Sun Microsystems,C=US";
-        X500Principal xpr = new X500Principal(name);
-        try {
-            int res = xpr.hashCode();
-            assertNotNull(res);
-        } catch (Exception e) {
-            fail("Unexpected exception: " + e);
-        }
-    }
-
-    /**
-     * javax.security.auth.x500.X500Principal#toString()
-     */
-    public void test_toString() {
-        String name = "CN=Duke, OU=JavaSoft, O=Sun Microsystems, C=US";
-        X500Principal xpr = new X500Principal(name);
-        try {
-            String res = xpr.toString();
-            assertNotNull(res);
-            assertEquals(name, res);
-        } catch (Exception e) {
-            fail("Unexpected exception: " + e);
-        }
-    }
-
-    /**
-     * javax.security.auth.x500.X500Principal#getEncoded()
-     */
-    public void test_getEncoded() {
-        byte[] ba = getByteArray(TestUtils.getX509Certificate_v1());
-        X500Principal xpr = new X500Principal(ba);
-        try {
-            byte[] res = xpr.getEncoded();
-            assertNotNull(res);
-            assertEquals(ba.length, res.length);
-        } catch (Exception e) {
-            fail("Unexpected exception: " + e);
-        }
-    }
-
-    /**
-     * javax.security.auth.x500.X500Principal#equals(Object o)
-     */
-    public void test_equals() {
-        String name1 = "CN=Duke, OU=JavaSoft, O=Sun Microsystems, C=US";
-        String name2 = "cn=duke,ou=javasoft,o=sun microsystems,c=us";
-        String name3 = "CN=Alex Astapchuk, OU=SSG, O=Intel ZAO, C=RU";
-        X500Principal xpr1 = new X500Principal(name1);
-        X500Principal xpr2 = new X500Principal(name2);
-        X500Principal xpr3 = new X500Principal(name3);
-        try {
-            assertTrue("False returned", xpr1.equals(xpr2));
-            assertFalse("True returned", xpr1.equals(xpr3));
-        } catch (Exception e) {
-            fail("Unexpected exception: " + e);
-        }
-    }
-
-    private byte[] getByteArray(byte[] array) {
-        byte[] x = null;
-        try {
-            ByteArrayInputStream is = new ByteArrayInputStream(array);
-            CertificateFactory cf = CertificateFactory.getInstance("X.509");
-            X509Certificate cert = (X509Certificate)cf.generateCertificate(is);
-            X500Principal xx = cert.getIssuerX500Principal();
-            x = xx.getEncoded();
-        } catch (Exception e) {
-            return null;
-        }
-        return x;
-    }
-}
-
diff --git a/harmony-tests/src/test/java/org/apache/harmony/tests/javax/security/auth/CallbackHandlerTest.java b/harmony-tests/src/test/java/org/apache/harmony/tests/javax/security/auth/callback/CallbackHandlerTest.java
index 76c860a..0b4d0fe 100644
--- a/harmony-tests/src/test/java/org/apache/harmony/tests/javax/security/auth/CallbackHandlerTest.java
+++ b/harmony-tests/src/test/java/org/apache/harmony/tests/javax/security/auth/callback/CallbackHandlerTest.java
@@ -15,7 +15,7 @@
  *  limitations under the License.
  */
 
-package tests.api.javax.security.auth;
+package org.apache.harmony.tests.javax.security.auth.callback;
 
 import junit.framework.TestCase;
 
diff --git a/harmony-tests/src/test/java/org/apache/harmony/tests/javax/security/auth/PasswordCallbackTest.java b/harmony-tests/src/test/java/org/apache/harmony/tests/javax/security/auth/callback/PasswordCallbackTest.java
index cdd992b..983879a 100644
--- a/harmony-tests/src/test/java/org/apache/harmony/tests/javax/security/auth/PasswordCallbackTest.java
+++ b/harmony-tests/src/test/java/org/apache/harmony/tests/javax/security/auth/callback/PasswordCallbackTest.java
@@ -15,11 +15,12 @@
  *  limitations under the License.
  */
 
-package tests.api.javax.security.auth;
+package org.apache.harmony.tests.javax.security.auth.callback;
 
 import junit.framework.TestCase;
-
+import javax.security.auth.DestroyFailedException;
 import javax.security.auth.callback.PasswordCallback;
+import org.apache.harmony.testframework.serialization.SerializationTest;
 
 /**
  * Tests for <code>PasswordCallback</code> class constructors and methods.
@@ -104,4 +105,20 @@ public class PasswordCallbackTest extends TestCase {
             fail("Unexpected exception: " + e);
         }
     }
+
+
+    public void testSerializationSelf() throws Exception {
+        SerializationTest.verifySelf(getSerializationData());
+    }
+
+    public void testSerializationGolden() throws Exception {
+        SerializationTest.verifyGolden(this, getSerializationData());
+    }
+
+    private Object[] getSerializationData() {
+        char[] pwd = { 'a', 'b', 'c' };
+        PasswordCallback p = new PasswordCallback("prmpt", true);
+        p.setPassword(pwd);
+        return new Object[] { new PasswordCallback("prompt", true), p };
+    }
 }
diff --git a/harmony-tests/src/test/java/org/apache/harmony/tests/javax/security/auth/UnsupportedCallbackExceptionTest.java b/harmony-tests/src/test/java/org/apache/harmony/tests/javax/security/auth/callback/UnsupportedCallbackExceptionTest.java
index abef563..defdbc7 100644
--- a/harmony-tests/src/test/java/org/apache/harmony/tests/javax/security/auth/UnsupportedCallbackExceptionTest.java
+++ b/harmony-tests/src/test/java/org/apache/harmony/tests/javax/security/auth/callback/UnsupportedCallbackExceptionTest.java
@@ -15,7 +15,7 @@
  *  limitations under the License.
  */
 
-package tests.api.javax.security.auth;
+package org.apache.harmony.tests.javax.security.auth.callback;
 
 import junit.framework.TestCase;
 
diff --git a/harmony-tests/src/test/java/org/apache/harmony/tests/javax/security/auth/login/LoginExceptionTest.java b/harmony-tests/src/test/java/org/apache/harmony/tests/javax/security/auth/login/LoginExceptionTest.java
new file mode 100644
index 0000000..2d63f16
--- /dev/null
+++ b/harmony-tests/src/test/java/org/apache/harmony/tests/javax/security/auth/login/LoginExceptionTest.java
@@ -0,0 +1,83 @@
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one or more
+ *  contributor license agreements.  See the NOTICE file distributed with
+ *  this work for additional information regarding copyright ownership.
+ *  The ASF licenses this file to You 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 org.apache.harmony.tests.javax.security.auth.login;
+
+import junit.framework.TestCase;
+
+import javax.security.auth.callback.PasswordCallback;
+import javax.security.auth.login.LoginException;
+import org.apache.harmony.testframework.serialization.SerializationTest;
+
+/**
+ * Tests for <code>LoginException</code> class constructors and methods.
+ *
+ */
+public class LoginExceptionTest extends TestCase {
+
+    private static String[] msgs = {
+            "",
+            "Check new message",
+            "Check new message Check new message Check new message Check new message Check new message" };
+
+
+    /**
+     * javax.security.auth.login.LoginException#LoginException()
+     * Assertion: constructs LoginException with no detail message
+     */
+    public void testLoginException01() {
+        LoginException lE = new LoginException();
+        assertNull("getMessage() must return null.", lE.getMessage());
+        assertNull("getCause() must return null", lE.getCause());
+    }
+
+    /**
+     * javax.security.auth.login.LoginException#LoginException(String msg)
+     * Assertion: constructs with not null parameter.
+     */
+    public void testLoginException02() {
+        LoginException lE;
+        for (int i = 0; i < msgs.length; i++) {
+            lE = new LoginException(msgs[i]);
+            assertEquals("getMessage() must return: ".concat(msgs[i]), lE.getMessage(), msgs[i]);
+            assertNull("getCause() must return null", lE.getCause());
+        }
+    }
+
+    /**
+     * javax.security.auth.login.LoginException#LoginException(String msg)
+     * Assertion: constructs with null parameter.
+     */
+    public void testLoginException03() {
+        String msg = null;
+        LoginException lE = new LoginException(msg);
+        assertNull("getMessage() must return null.", lE.getMessage());
+        assertNull("getCause() must return null", lE.getCause());
+    }
+
+    public void testSerializationSelf() throws Exception {
+        SerializationTest.verifySelf(getSerializationData());
+    }
+
+    public void testSerializationGolden() throws Exception {
+        SerializationTest.verifyGolden(this, getSerializationData());
+    }
+
+    private Object[] getSerializationData() {
+        return new Object[] { new LoginException("message") };
+    }
+}
diff --git a/harmony-tests/src/test/java/org/apache/harmony/tests/javax/security/auth/x500/X500PrincipalTest.java b/harmony-tests/src/test/java/org/apache/harmony/tests/javax/security/auth/x500/X500PrincipalTest.java
new file mode 100644
index 0000000..7eacf69
--- /dev/null
+++ b/harmony-tests/src/test/java/org/apache/harmony/tests/javax/security/auth/x500/X500PrincipalTest.java
@@ -0,0 +1,3094 @@
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one or more
+ *  contributor license agreements.  See the NOTICE file distributed with
+ *  this work for additional information regarding copyright ownership.
+ *  The ASF licenses this file to You 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 org.apache.harmony.tests.javax.security.auth.x500;
+
+import javax.security.auth.x500.X500Principal;
+import java.io.ByteArrayInputStream;
+import java.io.InputStream;
+import java.security.cert.CertificateFactory;
+import java.security.cert.X509Certificate;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Locale;
+import java.util.Map;
+import junit.framework.TestCase;
+import org.apache.harmony.testframework.serialization.SerializationTest;
+import org.apache.harmony.security.tests.support.cert.TestUtils;
+import tests.support.resource.Support_Resources;
+
+
+/**
+ * Tests for <code>X500Principal</code> class constructors and methods.
+ *
+ */
+public class X500PrincipalTest extends TestCase {
+
+    /**
+     * javax.security.auth.x500.X500Principal#X500Principal(String name)
+     */
+    public void test_X500Principal_01() {
+        String name = "CN=Duke,OU=JavaSoft,O=Sun Microsystems,C=US";
+
+        try {
+            X500Principal xpr = new X500Principal(name);
+            assertNotNull("Null object returned", xpr);
+            String resName = xpr.getName();
+            assertEquals(name, resName);
+        } catch (Exception e) {
+            fail("Unexpected exception: " + e);
+        }
+
+        try {
+            X500Principal xpr = new X500Principal((String)null);
+            fail("NullPointerException wasn't thrown");
+        } catch (NullPointerException npe) {
+        } catch (Exception e) {
+            fail(e + " was thrown instead of NullPointerException");
+        }
+
+        try {
+            X500Principal xpr = new X500Principal("X500PrincipalName");
+            fail("IllegalArgumentException wasn't thrown");
+        } catch (IllegalArgumentException npe) {
+        } catch (Exception e) {
+            fail(e + " was thrown instead of IllegalArgumentException");
+        }
+    }
+
+    /**
+     * javax.security.auth.x500.X500Principal#X500Principal(InputStream is)
+     */
+    public void test_X500Principal_02() {
+        String name = "CN=Duke,OU=JavaSoft,O=Sun Microsystems,C=US";
+        byte[] ba = getByteArray(TestUtils.getX509Certificate_v1());
+        ByteArrayInputStream is = new ByteArrayInputStream(ba);
+        InputStream isNull = null;
+
+        try {
+            X500Principal xpr = new X500Principal(is);
+            assertNotNull("Null object returned", xpr);
+            byte[] resArray = xpr.getEncoded();
+            assertEquals(ba.length, resArray.length);
+        } catch (Exception e) {
+            fail("Unexpected exception: " + e);
+        }
+
+        try {
+            X500Principal xpr = new X500Principal(isNull);
+            fail("NullPointerException wasn't thrown");
+        } catch (NullPointerException npe) {
+        } catch (Exception e) {
+            fail(e + " was thrown instead of NullPointerException");
+        }
+
+        is = new ByteArrayInputStream(name.getBytes());
+        try {
+            X500Principal xpr = new X500Principal(is);
+            fail("IllegalArgumentException wasn't thrown");
+        } catch (IllegalArgumentException npe) {
+        } catch (Exception e) {
+            fail(e + " was thrown instead of IllegalArgumentException");
+        }
+    }
+
+    /**
+     * javax.security.auth.x500.X500Principal#X500Principal(byte[] name)
+     */
+    public void test_X500Principal_03() {
+        String name = "CN=Duke,OU=JavaSoft,O=Sun Microsystems,C=US";
+        byte[] ba = getByteArray(TestUtils.getX509Certificate_v1());
+        byte[] baNull = null;
+
+        try {
+            X500Principal xpr = new X500Principal(ba);
+            assertNotNull("Null object returned", xpr);
+            byte[] resArray = xpr.getEncoded();
+            assertEquals(ba.length, resArray.length);
+        } catch (Exception e) {
+            fail("Unexpected exception: " + e);
+        }
+
+        try {
+            X500Principal xpr = new X500Principal(baNull);
+            fail("IllegalArgumentException wasn't thrown");
+        } catch (IllegalArgumentException npe) {
+        } catch (Exception e) {
+            fail(e + " was thrown instead of IllegalArgumentException");
+        }
+
+        ba = name.getBytes();
+        try {
+            X500Principal xpr = new X500Principal(ba);
+            fail("IllegalArgumentException wasn't thrown");
+        } catch (IllegalArgumentException npe) {
+        } catch (Exception e) {
+            fail(e + " was thrown instead of IllegalArgumentException");
+        }
+    }
+
+    /**
+     * javax.security.auth.x500.X500Principal#getName()
+     */
+    public void test_getName() {
+        String name = "CN=Duke,OU=JavaSoft,O=Sun Microsystems,C=US";
+        X500Principal xpr = new X500Principal(name);
+        try {
+            String resName = xpr.getName();
+            assertEquals(name, resName);
+        } catch (Exception e) {
+            fail("Unexpected exception: " + e);
+        }
+    }
+
+    /**
+     * javax.security.auth.x500.X500Principal#getName(String format)
+     */
+    public void test_getName_Format() {
+        String name = "CN=Duke,OU=JavaSoft,O=Sun Microsystems,C=US";
+        String expectedName = "cn=duke,ou=javasoft,o=sun microsystems,c=us";
+        X500Principal xpr = new X500Principal(name);
+        try {
+            String resName = xpr.getName(X500Principal.CANONICAL);
+            assertEquals(expectedName, resName);
+        } catch (Exception e) {
+            fail("Unexpected exception: " + e);
+        }
+
+        expectedName = "CN=Duke, OU=JavaSoft, O=Sun Microsystems, C=US";
+        try {
+            String resName = xpr.getName(X500Principal.RFC1779);
+            assertEquals(expectedName, resName);
+        } catch (Exception e) {
+            fail("Unexpected exception: " + e);
+        }
+
+        try {
+            String resName = xpr.getName(X500Principal.RFC2253);
+            assertEquals(name, resName);
+        } catch (Exception e) {
+            fail("Unexpected exception: " + e);
+        }
+
+        try {
+            String resName = xpr.getName(null);
+            fail("IllegalArgumentException  wasn't thrown");
+        } catch (IllegalArgumentException  iae) {
+        }
+        try {
+            String resName = xpr.getName("RFC2254");
+            fail("IllegalArgumentException  wasn't thrown");
+        } catch (IllegalArgumentException  iae) {
+        }
+    }
+
+    /**
+     * javax.security.auth.x500.X500Principal#hashCode()
+     */
+    public void test_hashCode() {
+        String name = "CN=Duke,OU=JavaSoft,O=Sun Microsystems,C=US";
+        X500Principal xpr = new X500Principal(name);
+        try {
+            int res = xpr.hashCode();
+            assertNotNull(res);
+        } catch (Exception e) {
+            fail("Unexpected exception: " + e);
+        }
+    }
+
+    /**
+     * javax.security.auth.x500.X500Principal#toString()
+     */
+    public void test_toString() {
+        String name = "CN=Duke, OU=JavaSoft, O=Sun Microsystems, C=US";
+        X500Principal xpr = new X500Principal(name);
+        try {
+            String res = xpr.toString();
+            assertNotNull(res);
+            assertEquals(name, res);
+        } catch (Exception e) {
+            fail("Unexpected exception: " + e);
+        }
+    }
+
+    /**
+     * javax.security.auth.x500.X500Principal#getEncoded()
+     */
+    public void test_getEncoded() {
+        byte[] ba = getByteArray(TestUtils.getX509Certificate_v1());
+        X500Principal xpr = new X500Principal(ba);
+        try {
+            byte[] res = xpr.getEncoded();
+            assertNotNull(res);
+            assertEquals(ba.length, res.length);
+        } catch (Exception e) {
+            fail("Unexpected exception: " + e);
+        }
+    }
+
+    /**
+     * javax.security.auth.x500.X500Principal#equals(Object o)
+     */
+    public void test_equals() {
+        String name1 = "CN=Duke, OU=JavaSoft, O=Sun Microsystems, C=US";
+        String name2 = "cn=duke,ou=javasoft,o=sun microsystems,c=us";
+        String name3 = "CN=Alex Astapchuk, OU=SSG, O=Intel ZAO, C=RU";
+        X500Principal xpr1 = new X500Principal(name1);
+        X500Principal xpr2 = new X500Principal(name2);
+        X500Principal xpr3 = new X500Principal(name3);
+        try {
+            assertTrue("False returned", xpr1.equals(xpr2));
+            assertFalse("True returned", xpr1.equals(xpr3));
+        } catch (Exception e) {
+            fail("Unexpected exception: " + e);
+        }
+    }
+
+    private byte[] getByteArray(byte[] array) {
+        byte[] x = null;
+        try {
+            ByteArrayInputStream is = new ByteArrayInputStream(array);
+            CertificateFactory cf = CertificateFactory.getInstance("X.509");
+            X509Certificate cert = (X509Certificate)cf.generateCertificate(is);
+            X500Principal xx = cert.getIssuerX500Principal();
+            x = xx.getEncoded();
+        } catch (Exception e) {
+            return null;
+        }
+        return x;
+    }
+
+        /**
+     * @tests javax.security.auth.x500.X500Principal#X500Principal(java.lang.String)
+     */
+    public void test_ConstructorLjava_lang_String() {
+        X500Principal principal = new X500Principal(
+                "CN=Hermione Granger, O=Apache Software Foundation, OU=Harmony, L=Hogwarts, ST=Hants, C=GB");
+        String name = principal.getName();
+        String expectedOuput = "CN=Hermione Granger,O=Apache Software Foundation,OU=Harmony,L=Hogwarts,ST=Hants,C=GB";
+        assertEquals("Output order precedence problem", expectedOuput, name);
+    }
+
+    /**
+     * @tests javax.security.auth.x500.X500Principal#X500Principal(java.lang.String, java.util.Map)
+     */
+    public void test_ConstructorLjava_lang_String_java_util_Map() {
+        Map<String, String> keyword = new HashMap<String, String>();
+        keyword.put("CN", "2.19");
+        keyword.put("OU", "1.2.5.19");
+        keyword.put("O", "1.2.5");
+        X500Principal X500p = new X500Principal("CN=Duke, OU=JavaSoft, O=Sun Microsystems, C=US ,CN=DD", keyword);
+        String name = X500p.getName();
+        String expectedOut = "2.19=#130444756b65,1.2.5.19=#13084a617661536f6674,1.2.5=#131053756e204d6963726f73797374656d73,C=US,2.19=#13024444";
+        assertEquals("Output order precedence problem", expectedOut, name);
+    }
+
+    /**
+     * @tests javax.security.auth.x500.X500Principal#getName(java.lang.String)
+     */
+    public void test_getNameLjava_lang_String() {
+        X500Principal principal = new X500Principal(
+                "CN=Dumbledore, OU=Administration, O=Hogwarts School, C=GB");
+        String canonical = principal.getName(X500Principal.CANONICAL);
+        String expected = "cn=dumbledore,ou=administration,o=hogwarts school,c=gb";
+        assertEquals("CANONICAL output differs from expected result", expected,
+                canonical);
+    }
+
+    /**
+     * @tests javax.security.auth.x500.X500Principal#getName(java.lang.String, java.util.Map)
+     */
+    public void test_getNameLjava_lang_String_java_util_Map() {
+        Map<String, String> keyword = new HashMap<String, String>();
+        keyword.put("CN", "2.19");
+        keyword.put("OU", "1.2.5.19");
+        keyword.put("O", "1.2.5");
+        X500Principal X500p = new X500Principal("CN=Duke, OU=JavaSoft, O=Sun Microsystems, C=US ,CN=DD", keyword);
+        keyword = new HashMap<String, String>();
+        keyword.put("2.19", "mystring");
+        String rfc1779Name = X500p.getName("RFC1779", keyword);
+        String rfc2253Name = X500p.getName("RFC2253", keyword);
+        String expected1779Out = "mystring=Duke, OID.1.2.5.19=JavaSoft, OID.1.2.5=Sun Microsystems, C=US, mystring=DD";
+        String expected2253Out = "mystring=Duke,1.2.5.19=#13084a617661536f6674,1.2.5=#131053756e204d6963726f73797374656d73,C=US,mystring=DD";
+        assertEquals("Output order precedence problem", expected1779Out, rfc1779Name);
+        assertEquals("Output order precedence problem", expected2253Out, rfc2253Name);
+        try {
+            X500p.getName("CANONICAL", keyword);
+            fail("Should throw IllegalArgumentException exception here");
+        } catch (IllegalArgumentException e) {
+            //expected IllegalArgumentException here
+        }
+    }
+
+      private boolean testing = false;
+
+    public void testStreamPosition() throws Exception {
+        //this encoding is read from the file
+        /*byte [] mess = {0x30, 0x30,
+         0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x42, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x41,
+         0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x42, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x41,
+         1, 2, 3//extra bytes
+         };
+         */
+
+        InputStream is = Support_Resources
+                .getResourceStream("X500PrincipalTest.0.dat");
+        X500Principal principal = new X500Principal(is);
+        String s = principal.toString();
+        assertEquals("CN=A, CN=B, CN=A, CN=B", s);
+        byte[] restBytes = new byte[] { 0, 0, 0 };
+        is.read(restBytes);
+        assertEquals(restBytes[0], 1);
+        assertEquals(restBytes[1], 2);
+        assertEquals(restBytes[2], 3);
+        is.close();
+    }
+
+    public void testStreamPosition_0() throws Exception {
+        //this encoding is read from the file
+        /*byte [] mess = {0x30, 0x30,
+         0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x42, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x41,
+         0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x42, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x41,
+         };
+         */
+
+        InputStream is = Support_Resources
+                .getResourceStream("X500PrincipalTest.1.dat");
+        X500Principal principal = new X500Principal(is);
+        String s = principal.toString();
+        assertEquals("CN=A, CN=B, CN=A, CN=B", s);
+        assertEquals(0, is.available());
+        is.close();
+    }
+
+    public void testStreamPosition_1() throws Exception {
+        byte[] mess = { 0x30, (byte) 0x81, (byte) 0x9A, 0x31, 0x0A, 0x30, 0x08,
+                0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x5A, 0x31, 0x0A,
+                0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x0B, 0x13, 0x01, 0x45,
+                0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x06, 0x13,
+                0x01, 0x44, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55, 0x04,
+                0x07, 0x13, 0x01, 0x43, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03,
+                0x55, 0x04, 0x0A, 0x13, 0x01, 0x42, 0x31, 0x15, 0x30, 0x08,
+                0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x41, 0x30, 0x09,
+                0x06, 0x03, 0x55, 0x04, 0x08, 0x13, 0x02, 0x43, 0x41, 0x31,
+                0x0A, 0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x0B, 0x13, 0x01,
+                0x45, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x06,
+                0x13, 0x01, 0x44, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55,
+                0x04, 0x07, 0x13, 0x01, 0x43, 0x31, 0x0A, 0x30, 0x08, 0x06,
+                0x03, 0x55, 0x04, 0x0A, 0x13, 0x01, 0x42, 0x31, 0x15, 0x30,
+                0x08, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x41, 0x30,
+                0x09, 0x06, 0x03, 0x55, 0x04, 0x08, 0x13, 0x02, 0x43, 0x41, 2,
+                3, 4 };
+
+        ByteArrayInputStream is = new ByteArrayInputStream(mess);
+        X500Principal principal = new X500Principal(is);
+
+        String s = principal.getName(X500Principal.RFC1779);
+        assertEquals(
+                "CN=A + ST=CA, O=B, L=C, C=D, OU=E, CN=A + ST=CA, O=B, L=C, C=D, OU=E, CN=Z",
+                s);
+        assertEquals(3, is.available());
+        assertEquals(2, is.read());
+        assertEquals(3, is.read());
+        assertEquals(4, is.read());
+    }
+
+    public void testStreamPosition_2() throws Exception {
+        byte[] mess = { 0x30, 0x0C, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55,
+                0x04, 0x03, 0x13, 0x01, 0x41, 2 };
+        ByteArrayInputStream is = new ByteArrayInputStream(mess);
+        X500Principal principal = new X500Principal(is);
+        String s = principal.getName(X500Principal.RFC1779);
+        assertEquals("CN=A", s);
+        assertEquals(1, is.available());
+        assertEquals(2, is.read());
+    }
+
+    public void testEncodingFromFile() throws Exception {
+        //this encoding is read from the file
+        /*byte [] mess = {0x30, 0x30,
+         0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x42, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x41,
+         0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x42, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x41
+         };
+         */
+        InputStream is = Support_Resources
+                .getResourceStream("X500PrincipalTest.1.dat");
+        X500Principal principal = new X500Principal(is);
+        String s = principal.toString();
+        assertEquals("CN=A, CN=B, CN=A, CN=B", s);
+        is.close();
+    }
+
+    public void testEncodingFromEncoding() {
+        byte[] arr1 = new X500Principal("O=Org.").getEncoded();
+        byte[] arr2 = new X500Principal(new X500Principal("O=Org.")
+                .getEncoded()).getEncoded();
+        assertTrue(Arrays.equals(arr1, arr2));
+    }
+
+    /**
+     * tests if the encoding is backed
+     */
+    public void testSafeEncoding() {
+        byte[] mess = { 0x30, 0x0C, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55,
+                0x04, 0x03, 0x13, 0x01, 0x41 };
+        X500Principal principal = new X500Principal(mess);
+        mess[mess.length - 1] = (byte) 0xFF;
+        byte[] enc = principal.getEncoded();
+        assertEquals(enc[mess.length - 1], 0x41);
+    }
+
+    /**
+     * Inits X500Principal with byte array
+     * gets toString
+     * checks the result
+     */
+    public void testToString() throws Exception {
+        byte[] mess = { 0x30, 0x18, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55,
+                0x04, 0x03, 0x13, 0x01, 0x42, 0x31, 0x0A, 0x30, 0x08, 0x06,
+                0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x41 };
+        X500Principal principal = new X500Principal(mess);
+        String s = principal.toString();
+        assertNotNull(s);
+    }
+
+    /**
+     * Inits X500Principal with byte array
+     * gets hashCode
+     * compares with expected value
+     */
+    public void testHashCode() throws Exception {
+        byte[] mess = { 0x30, 0x18, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55,
+                0x04, 0x03, 0x13, 0x01, 0x42, 0x31, 0x0A, 0x30, 0x08, 0x06,
+                0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x41 };
+        X500Principal principal = new X500Principal(mess);
+        int hash = principal.hashCode();
+        assertEquals(principal.getName(X500Principal.CANONICAL).hashCode(),
+                hash);
+    }
+
+    /**
+     * Inits X500Principal with byte array
+     * Inits other X500Principal with equivalent string
+     * checks if <code>equals</code> returns true for first against second one
+     */
+    public void testEquals() throws Exception {
+        byte[] mess = { 0x30, 0x18, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55,
+                0x04, 0x03, 0x13, 0x01, 0x42, 0x31, 0x0A, 0x30, 0x08, 0x06,
+                0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x41 };
+        X500Principal principal = new X500Principal(mess);
+        X500Principal principal2 = new X500Principal("CN=A, CN=B");
+        assertTrue(principal.equals(principal2));
+    }
+
+    /**
+     * @tests javax.security.auth.x500.X500Principal#equals(Object)
+     */
+    public void test_equalsLjava_lang_Object() {
+        X500Principal xp1 = new X500Principal(
+                "C=US, ST=California, L=San Diego, O=Apache, OU=Project Harmony, CN=Test cert");
+        assertEquals(
+                "C=US,ST=California,L=San Diego,O=Apache,OU=Project Harmony,CN=Test cert",
+                xp1.getName());
+    }
+
+    /**
+     * Inits X500Principal with byte array, where Oid does fall into any keyword, but not given as a keyword
+     * Value is given as hex value
+     * (extra spaces are given)
+     * gets Name in RFC1779 format
+     * compares with expected value of name
+     */
+    public void testKWAsOid_RFC1779() throws Exception {
+        String dn = "CN=A, OID.2.5.4.3  =    #130142";
+        X500Principal principal = new X500Principal(dn);
+
+        String s = principal.getName(X500Principal.RFC1779);
+        assertEquals("CN=A, CN=B", s);
+    }
+
+    /**
+     * Inits X500Principal with byte array, where Oid does fall into any keyword, but not given as a keyword
+     * Value is given as hex value
+     * (extra spaces are given)
+     * gets Name in RFC2253 format
+     * compares with expected value of name
+     */
+    public void testKWAsOid_RFC2253() throws Exception {
+        String dn = "CN=A, OID.2.5.4.3 =  #130142";
+        X500Principal principal = new X500Principal(dn);
+
+        String s = principal.getName(X500Principal.RFC2253);
+        assertEquals("CN=A,CN=B", s);
+    }
+
+    /**
+     * Inits X500Principal with byte array, where Oid does fall into any keyword, but not given as a keyword
+     * Value is given as hex value
+     * (extra spaces are given)
+     * gets Name in CANONICAL format
+     * compares with expected value of name
+     */
+    public void testKWAsOid_CANONICAL() throws Exception {
+        String dn = "CN=A, OID.2.5.4.3 =  #130142";
+        X500Principal principal = new X500Principal(dn);
+
+        String s = principal.getName(X500Principal.CANONICAL);
+        assertEquals("cn=a,cn=b", s);
+    }
+
+    /**
+     * Inits X500Principal with byte array, where Oid does not fall into any keyword
+     * gets Name in RFC1779 format
+     * compares with expected value of name
+     */
+    public void testOid_RFC1779() throws Exception {
+        byte[] mess = { 0x30, 0x18, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55,
+                0x04, 0x03, 0x13, 0x01, 0x42, 0x31, 0x0A, 0x30, 0x08, 0x06,
+                0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x41 };
+        mess[8] = 0x60;
+        X500Principal principal = new X500Principal(mess);
+
+        String s = principal.getName(X500Principal.RFC1779);
+        assertEquals("CN=A, OID.2.16.4.3=B", s);
+    }
+
+    /**
+     * Inits X500Principal with byte array, where Oid does not fall into any keyword
+     * gets Name in RFC2253 format
+     * compares with expected value of name
+     */
+    public void testOid_RFC2253() throws Exception {
+        byte[] mess = { 0x30, 0x18, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55,
+                0x04, 0x03, 0x13, 0x01, 0x4F, 0x31, 0x0A, 0x30, 0x08, 0x06,
+                0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x41 };
+        mess[8] = 0x60;
+        X500Principal principal = new X500Principal(mess);
+
+        String s = principal.getName(X500Principal.RFC2253);
+        assertEquals("CN=A,2.16.4.3=#13014f", s);
+    }
+
+    /**
+     * Inits X500Principal with byte array, where Oid does not fall into any keyword
+     * gets Name in CANONICAL format
+     * compares with expected value of name
+     */
+    public void testOid_CANONICAL() throws Exception {
+        byte[] mess = { 0x30, 0x18, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55,
+                0x04, 0x03, 0x13, 0x01, 0x4F, 0x31, 0x0A, 0x30, 0x08, 0x06,
+                0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x41 };
+        mess[8] = 0x60;
+        X500Principal principal = new X500Principal(mess);
+
+        String s = principal.getName(X500Principal.CANONICAL);
+        assertEquals("cn=a,2.16.4.3=#13014f", s);
+    }
+
+    /**
+     * Inits X500Principal with a string
+     * gets encoded form
+     * compares with expected byte array
+     */
+    public void testNameGetEncoding() throws Exception {
+        byte[] mess = { 0x30, (byte) 0x81, (byte) 0x9A, 0x31, 0x0A, 0x30, 0x08,
+                0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x5A, 0x31, 0x0A,
+                0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x0B, 0x13, 0x01, 0x45,
+                0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x06, 0x13,
+                0x01, 0x44, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55, 0x04,
+                0x07, 0x13, 0x01, 0x43, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03,
+                0x55, 0x04, 0x0A, 0x13, 0x01, 0x42, 0x31, 0x15, 0x30, 0x08,
+                0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x41, 0x30, 0x09,
+                0x06, 0x03, 0x55, 0x04, 0x08, 0x13, 0x02, 0x43, 0x41, 0x31,
+                0x0A, 0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x0B, 0x13, 0x01,
+                0x45, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x06,
+                0x13, 0x01, 0x44, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55,
+                0x04, 0x07, 0x13, 0x01, 0x43, 0x31, 0x0A, 0x30, 0x08, 0x06,
+                0x03, 0x55, 0x04, 0x0A, 0x13, 0x01, 0x42, 0x31, 0x15, 0x30,
+                0x08, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x41, 0x30,
+                0x09, 0x06, 0x03, 0x55, 0x04, 0x08, 0x13, 0x02, 0x43, 0x41 };
+        String dn = "CN=A+ST=CA,O=B,L=C,C=D,OU=E,CN=A+ST=CA,O=B,L=C,C=D,OU=E,CN=Z";
+        X500Principal principal = new X500Principal(dn);
+        byte[] s = principal.getEncoded();
+
+        assertTrue(Arrays.equals(mess, s));
+    }
+
+    /**
+     * Inits X500Principal with a string
+     * gets encoded form
+     * compares with expected byte array
+     */
+    public void testNameGetEncoding_01() throws Exception {
+        byte[] mess = { 0x30, 0x18, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55,
+                0x04, 0x03, 0x13, 0x01, 0x42, 0x31, 0x0A, 0x30, 0x08, 0x06,
+                0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x41 };
+        String dn = "CN=A,CN=B";
+        X500Principal principal = new X500Principal(dn);
+        byte[] s = principal.getEncoded();
+
+        assertTrue(Arrays.equals(mess, s));
+    }
+
+    /**
+     * Inits X500Principal with byte array
+     * gets Name in RFC1779 format
+     * compares with expected value of name
+     */
+    public void testGetName_RFC1779() throws Exception {
+        byte[] mess = { 0x30, (byte) 0x81, (byte) 0x9A, 0x31, 0x0A, 0x30, 0x08,
+                0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x5A, 0x31, 0x0A,
+                0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x0B, 0x13, 0x01, 0x45,
+                0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x06, 0x13,
+                0x01, 0x44, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55, 0x04,
+                0x07, 0x13, 0x01, 0x43, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03,
+                0x55, 0x04, 0x0A, 0x13, 0x01, 0x42, 0x31, 0x15, 0x30, 0x08,
+                0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x41, 0x30, 0x09,
+                0x06, 0x03, 0x55, 0x04, 0x08, 0x13, 0x02, 0x43, 0x41, 0x31,
+                0x0A, 0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x0B, 0x13, 0x01,
+                0x45, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x06,
+                0x13, 0x01, 0x44, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55,
+                0x04, 0x07, 0x13, 0x01, 0x43, 0x31, 0x0A, 0x30, 0x08, 0x06,
+                0x03, 0x55, 0x04, 0x0A, 0x13, 0x01, 0x42, 0x31, 0x15, 0x30,
+                0x08, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x41, 0x30,
+                0x09, 0x06, 0x03, 0x55, 0x04, 0x08, 0x13, 0x02, 0x43, 0x41 };
+        X500Principal principal = new X500Principal(mess);
+
+        String s = principal.getName(X500Principal.RFC1779);
+        assertEquals(
+                "CN=A + ST=CA, O=B, L=C, C=D, OU=E, CN=A + ST=CA, O=B, L=C, C=D, OU=E, CN=Z",
+                s);
+
+    }
+
+    /**
+     * Inits X500Principal with byte array
+     * gets Name in RFC2253 format
+     * compares with expected value of name
+     */
+    public void testGetName_RFC2253() throws Exception {
+        byte[] mess = { 0x30, (byte) 0x81, (byte) 0x9A, 0x31, 0x0A, 0x30, 0x08,
+                0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x5A, 0x31, 0x0A,
+                0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x0B, 0x13, 0x01, 0x45,
+                0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x06, 0x13,
+                0x01, 0x44, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55, 0x04,
+                0x07, 0x13, 0x01, 0x43, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03,
+                0x55, 0x04, 0x0A, 0x13, 0x01, 0x42, 0x31, 0x15, 0x30, 0x08,
+                0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x41, 0x30, 0x09,
+                0x06, 0x03, 0x55, 0x04, 0x08, 0x13, 0x02, 0x43, 0x41, 0x31,
+                0x0A, 0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x0B, 0x13, 0x01,
+                0x45, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x06,
+                0x13, 0x01, 0x44, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55,
+                0x04, 0x07, 0x13, 0x01, 0x43, 0x31, 0x0A, 0x30, 0x08, 0x06,
+                0x03, 0x55, 0x04, 0x0A, 0x13, 0x01, 0x42, 0x31, 0x15, 0x30,
+                0x08, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x41, 0x30,
+                0x09, 0x06, 0x03, 0x55, 0x04, 0x08, 0x13, 0x02, 0x43, 0x41 };
+        X500Principal principal = new X500Principal(mess);
+
+        String s = principal.getName(X500Principal.RFC2253);
+        assertEquals(
+                "CN=A+ST=CA,O=B,L=C,C=D,OU=E,CN=A+ST=CA,O=B,L=C,C=D,OU=E,CN=Z",
+                s);
+    }
+
+    /**
+     * Inits X500Principal with byte array
+     * gets Name in CANONICAL format
+     * compares with expected value of name
+     */
+    public void testGetName_CANONICAL() throws Exception {
+        byte[] mess = { 0x30, (byte) 0x81, (byte) 0x9A, 0x31, 0x0A, 0x30, 0x08,
+                0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x5A, 0x31, 0x0A,
+                0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x0B, 0x13, 0x01, 0x45,
+                0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x06, 0x13,
+                0x01, 0x44, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55, 0x04,
+                0x07, 0x13, 0x01, 0x43, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03,
+                0x55, 0x04, 0x0A, 0x13, 0x01, 0x42, 0x31, 0x15, 0x30, 0x08,
+                0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x41, 0x30, 0x09,
+                0x06, 0x03, 0x55, 0x04, 0x08, 0x13, 0x02, 0x43, 0x41, 0x31,
+                0x0A, 0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x0B, 0x13, 0x01,
+                0x45, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x06,
+                0x13, 0x01, 0x44, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55,
+                0x04, 0x07, 0x13, 0x01, 0x43, 0x31, 0x0A, 0x30, 0x08, 0x06,
+                0x03, 0x55, 0x04, 0x0A, 0x13, 0x01, 0x42, 0x31, 0x15, 0x30,
+                0x08, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x41, 0x30,
+                0x09, 0x06, 0x03, 0x55, 0x04, 0x08, 0x13, 0x02, 0x43, 0x41 };
+        X500Principal principal = new X500Principal(mess);
+
+        String s = principal.getName(X500Principal.CANONICAL);
+        assertEquals(
+                "CN=A+ST=CA,O=B,L=C,C=D,OU=E,CN=A+ST=CA,O=B,L=C,C=D,OU=E,CN=Z"
+                        .toLowerCase(Locale.US), s);
+    }
+
+    /**
+     * Inits X500Principal with byte array
+     * gets Name in RFC1779 format
+     * compares with expected value of name
+     */
+    public void testStreamGetName_RFC1779() throws Exception {
+        byte[] mess = { 0x30, (byte) 0x81, (byte) 0x9A, 0x31, 0x0A, 0x30, 0x08,
+                0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x5A, 0x31, 0x0A,
+                0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x0B, 0x13, 0x01, 0x45,
+                0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x06, 0x13,
+                0x01, 0x44, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55, 0x04,
+                0x07, 0x13, 0x01, 0x43, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03,
+                0x55, 0x04, 0x0A, 0x13, 0x01, 0x42, 0x31, 0x15, 0x30, 0x08,
+                0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x41, 0x30, 0x09,
+                0x06, 0x03, 0x55, 0x04, 0x08, 0x13, 0x02, 0x43, 0x41, 0x31,
+                0x0A, 0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x0B, 0x13, 0x01,
+                0x45, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x06,
+                0x13, 0x01, 0x44, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55,
+                0x04, 0x07, 0x13, 0x01, 0x43, 0x31, 0x0A, 0x30, 0x08, 0x06,
+                0x03, 0x55, 0x04, 0x0A, 0x13, 0x01, 0x42, 0x31, 0x15, 0x30,
+                0x08, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x41, 0x30,
+                0x09, 0x06, 0x03, 0x55, 0x04, 0x08, 0x13, 0x02, 0x43, 0x41 };
+        ByteArrayInputStream is = new ByteArrayInputStream(mess);
+        X500Principal principal = new X500Principal(is);
+
+        String s = principal.getName(X500Principal.RFC1779);
+        assertEquals(
+                "CN=A + ST=CA, O=B, L=C, C=D, OU=E, CN=A + ST=CA, O=B, L=C, C=D, OU=E, CN=Z",
+                s);
+    }
+
+    /**
+     * Inits X500Principal with byte array
+     * gets Name in RFC2253 format
+     * compares with expected value of name
+     */
+    public void testStreamGetName_RFC2253() throws Exception {
+        byte[] mess = { 0x30, (byte) 0x81, (byte) 0x9A, 0x31, 0x0A, 0x30, 0x08,
+                0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x5A, 0x31, 0x0A,
+                0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x0B, 0x13, 0x01, 0x45,
+                0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x06, 0x13,
+                0x01, 0x44, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55, 0x04,
+                0x07, 0x13, 0x01, 0x43, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03,
+                0x55, 0x04, 0x0A, 0x13, 0x01, 0x42, 0x31, 0x15, 0x30, 0x08,
+                0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x41, 0x30, 0x09,
+                0x06, 0x03, 0x55, 0x04, 0x08, 0x13, 0x02, 0x43, 0x41, 0x31,
+                0x0A, 0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x0B, 0x13, 0x01,
+                0x45, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x06,
+                0x13, 0x01, 0x44, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55,
+                0x04, 0x07, 0x13, 0x01, 0x43, 0x31, 0x0A, 0x30, 0x08, 0x06,
+                0x03, 0x55, 0x04, 0x0A, 0x13, 0x01, 0x42, 0x31, 0x15, 0x30,
+                0x08, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x41, 0x30,
+                0x09, 0x06, 0x03, 0x55, 0x04, 0x08, 0x13, 0x02, 0x43, 0x41 };
+        ByteArrayInputStream is = new ByteArrayInputStream(mess);
+        X500Principal principal = new X500Principal(is);
+
+        String s = principal.getName(X500Principal.RFC2253);
+        assertEquals(
+                "CN=A+ST=CA,O=B,L=C,C=D,OU=E,CN=A+ST=CA,O=B,L=C,C=D,OU=E,CN=Z",
+                s);
+    }
+
+    /**
+     * Inits X500Principal with byte array
+     * gets Name in CANONICAL format
+     * compares with expected value of name
+     */
+    public void testStreamGetName_CANONICAL() throws Exception {
+        byte[] mess = { 0x30, (byte) 0x81, (byte) 0x9A, 0x31, 0x0A, 0x30, 0x08,
+                0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x5A, 0x31, 0x0A,
+                0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x0B, 0x13, 0x01, 0x45,
+                0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x06, 0x13,
+                0x01, 0x44, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55, 0x04,
+                0x07, 0x13, 0x01, 0x43, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03,
+                0x55, 0x04, 0x0A, 0x13, 0x01, 0x42, 0x31, 0x15, 0x30, 0x08,
+                0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x41, 0x30, 0x09,
+                0x06, 0x03, 0x55, 0x04, 0x08, 0x13, 0x02, 0x43, 0x41, 0x31,
+                0x0A, 0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x0B, 0x13, 0x01,
+                0x45, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x06,
+                0x13, 0x01, 0x44, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55,
+                0x04, 0x07, 0x13, 0x01, 0x43, 0x31, 0x0A, 0x30, 0x08, 0x06,
+                0x03, 0x55, 0x04, 0x0A, 0x13, 0x01, 0x42, 0x31, 0x15, 0x30,
+                0x08, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x41, 0x30,
+                0x09, 0x06, 0x03, 0x55, 0x04, 0x08, 0x13, 0x02, 0x43, 0x41 };
+        ByteArrayInputStream is = new ByteArrayInputStream(mess);
+        X500Principal principal = new X500Principal(is);
+
+        String s = principal.getName(X500Principal.CANONICAL);
+        assertEquals(
+                "CN=A+ST=CA,O=B,L=C,C=D,OU=E,CN=A+ST=CA,O=B,L=C,C=D,OU=E,CN=Z"
+                        .toLowerCase(Locale.US), s);
+    }
+
+    /**
+     * Inits X500Principal with a string, where OID does not fall into any keyword
+     * gets encoded form
+     * inits new X500Principal with the encoding
+     * gets string in RFC1779 format
+     * compares with expected value
+     */
+    public void testGetName_EncodingWithWrongOidButGoodName_SeveralRDNs_RFC1779()
+            throws Exception {
+        String dn = "OID.2.16.4.3=B; CN=A";
+        X500Principal principal = new X500Principal(dn);
+        byte[] enc = principal.getEncoded();
+        X500Principal principal2 = new X500Principal(enc);
+        String s = principal2.getName(X500Principal.RFC1779);
+        assertEquals("OID.2.16.4.3=B, CN=A", s);
+
+    }
+
+    /**
+     * Inits X500Principal with a string, where OID does not fall into any keyword
+     * gets encoded form
+     * inits new X500Principal with the encoding
+     * gets string in RFC2253 format
+     * compares with expected value
+     */
+    public void testGetName_EncodingWithWrongOidButGoodName_SeveralRDNs_RFC2253()
+            throws Exception {
+        String dn = "OID.2.16.4.3=B; CN=A";
+        X500Principal principal = new X500Principal(dn);
+        byte[] enc = principal.getEncoded();
+        X500Principal principal2 = new X500Principal(enc);
+        String s = principal2.getName(X500Principal.RFC2253);
+        assertEquals("2.16.4.3=#130142,CN=A", s);
+
+    }
+
+    /**
+     * Inits X500Principal with a string, where OID does not fall into any keyword
+     * gets encoded form
+     * inits new X500Principal with the encoding
+     * gets string in CANONICAL format
+     * compares with expected value
+     */
+    public void testGetName_EncodingWithWrongOidButGoodName_SeveralRDNs_CANONICAL()
+            throws Exception {
+        String dn = "OID.2.16.4.3=B; CN=A";
+        X500Principal principal = new X500Principal(dn);
+        byte[] enc = principal.getEncoded();
+        X500Principal principal2 = new X500Principal(enc);
+        String s = principal2.getName(X500Principal.CANONICAL);
+        assertEquals("2.16.4.3=#130142,cn=a", s);
+
+    }
+
+    /**
+     * Inits X500Principal with a string, where OID does not fall into any keyword
+     * gets string in RFC1779 format
+     * compares with expected value
+     */
+    public void testGetName_wrongOidButGoodName_RFC1779() throws Exception {
+        String dn = "OID.2.16.4.3=B + CN=A";
+        X500Principal principal = new X500Principal(dn);
+
+        String s = principal.getName(X500Principal.RFC1779);
+        assertEquals("OID.2.16.4.3=B + CN=A", s);
+    }
+
+    /**
+     * Inits X500Principal with a string, where OID does not fall into any keyword
+     * gets string in RFC2253 format
+     * compares with expected value
+     */
+    public void testGetName_wrongOidButGoodName_RFC2253() throws Exception {
+        String dn = "OID.2.16.4.3=B + CN=A";
+        X500Principal principal = new X500Principal(dn);
+
+        String s = principal.getName(X500Principal.RFC2253);
+        assertEquals("2.16.4.3=#130142+CN=A", s);
+    }
+
+    /**
+     * Inits X500Principal with a string, there are multiple AVAs
+     * gets string in CANONICAL format
+     * compares with expected value paying attention on sorting order of AVAs
+     */
+    public void testGetName_CANONICAL_SortOrder() throws Exception {
+        String dn = "ST=C + CN=A; OU=B + CN=D";
+        X500Principal principal = new X500Principal(dn);
+
+        String s = principal.getName(X500Principal.CANONICAL);
+        assertEquals("cn=a+st=c,cn=d+ou=b", s);
+
+    }
+
+    /**
+     * Inits X500Principal with a string, there are multiple AVAs and Oid which does not fall into any keyword
+     * gets string in CANONICAL format
+     * compares with expected value paying attention on sorting order of AVAs
+     */
+    public void testGetName_CANONICAL_SortOrder_01() throws Exception {
+        String dn = "OID.2.16.4.3=B + CN=A";
+        X500Principal principal = new X500Principal(dn);
+
+        String s = principal.getName(X500Principal.CANONICAL);
+        assertEquals("cn=a+2.16.4.3=#130142", s);
+
+    }
+
+    /**
+     * Inits X500Principal with a string, there are multiple AVAs and Oid which does not fall into any keyword, and value given in hex format
+     * gets string in CANONICAL format
+     * compares with expected value paying attention on sorting order of AVAs
+     */
+    public void testGetName_CANONICAL_SortOrder_02() throws Exception {
+        String dn = "OID.2.16.4.3=#13024220+ CN=A";
+        X500Principal principal = new X500Principal(dn);
+
+        String s = principal.getName(X500Principal.CANONICAL);
+        assertEquals("cn=a+2.16.4.3=#13024220", s);
+
+    }
+
+    /**
+     * Inits X500Principal with a string, there are multiple AVAs and 2 Oids which do not fall into any keyword
+     * gets string in CANONICAL format
+     * compares with expected value paying attention on sorting order of AVAs
+     */
+    public void testGetName_CANONICAL_SortOrder_03() throws Exception {
+        String dn = "OID.2.16.4.9=A + OID.2.16.4.3=B";
+        X500Principal principal = new X500Principal(dn);
+
+        String s = principal.getName(X500Principal.CANONICAL);
+        assertEquals("2.16.4.3=#130142+2.16.4.9=#130141", s);
+
+    }
+
+    /**
+     * Inits X500Principal with a string, there are multiple AVAs and 2 Oids which do not fall into any keyword
+     * gets string in CANONICAL format
+     * compares with expected value paying attention on sorting order of AVAs
+     */
+    public void testGetName_CANONICAL_SortOrder_04() throws Exception {
+        String dn = "OID.2.2.2.2=A + OID.1.1.1.1=B";
+        X500Principal principal = new X500Principal(dn);
+
+        String s = principal.getName(X500Principal.CANONICAL);
+        assertEquals("1.1.1.1=#130142+2.2.2.2=#130141", s);
+
+    }
+
+    /**
+     * Inits X500Principal with a string, there are multiple AVAs and 2 Oids which do not fall into any keyword
+     * gets string in CANONICAL format
+     * compares with expected value paying attention on sorting order of AVAs
+     */
+    public void testGetName_CANONICAL_SortOrder_05() throws Exception {
+        String dn = "OID.2.16.4.9=A + OID.2.16.4=B";
+        X500Principal principal = new X500Principal(dn);
+
+        String s = principal.getName(X500Principal.CANONICAL);
+        assertEquals("2.16.4=#130142+2.16.4.9=#130141", s);
+
+    }
+
+    /**
+     * Inits X500Principal with a string, there are multiple AVAs and 2 Oids which do not fall into any keyword
+     * gets string in CANONICAL format
+     * compares with expected value paying attention on sorting order of AVAs
+     */
+    public void testGetName_CANONICAL_SortOrder_06() throws Exception {
+        String dn = "OID.1.1.2=A + OID.1.2=B";
+        X500Principal principal = new X500Principal(dn);
+
+        String s = principal.getName(X500Principal.CANONICAL);
+        assertEquals("1.1.2=#130141+1.2=#130142", s);
+
+    }
+
+    /**
+     * Inits X500Principal with a string, there are multiple AVAs and 2 Oids which do not fall into any keyword
+     * gets string in CANONICAL format
+     * compares with expected value paying attention on sorting order of AVAs
+     */
+    public void testGetName_CANONICAL_SortOrder_07() throws Exception {
+        String dn = "OID.1.1.1=A + OID.1.1=B";
+        X500Principal principal = new X500Principal(dn);
+
+        String s = principal.getName(X500Principal.CANONICAL);
+        assertEquals("1.1=#130142+1.1.1=#130141", s);
+
+    }
+
+    /**
+     * FIXME test is failed - implement unicode normalization
+     *
+     * @throws Exception
+     */
+    public void testGetNameUnicodeNormalized() throws Exception {
+        String unicodeStr = "CN= \u0401\u0410";
+        X500Principal principal = new X500Principal(unicodeStr);
+        principal.getName(X500Principal.CANONICAL);
+    }
+
+    /**
+     * Inits X500Principal with empty string
+     * gets encoding
+     * compares with expected encoding
+     */
+    public void testEmptyInputName() {
+        String dn = "CN=\"\"";
+        byte[] mess = { 0x30, 0x0B, 0x31, 0x09, 0x30, 0x07, 0x06, 0x03, 0x55,
+                0x04, 0x03, 0x13, 0x00 };
+        X500Principal principal = new X500Principal(dn);
+        assertTrue(Arrays.equals(mess, principal.getEncoded()));
+    }
+
+    /**
+     * Inits X500Principal with string as single escaped space
+     * gets encoding
+     * compares with expected encoding
+     */
+    public void testNameSingleEscapedSpace() {
+        String dn = "CN=\\ ";
+        byte[] mess = { 0x30, 0x0C, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55,
+                0x04, 0x03, 0x13, 0x01, 0x20 };
+        X500Principal principal = new X500Principal(dn);
+        assertTrue(Arrays.equals(mess, principal.getEncoded()));
+    }
+
+    /**
+     * Inits X500Principal with string with spaces
+     * gets Name in RFC2253 format
+     * compares with expected value of name
+     */
+    public void testNameOnlySpaces_RFC1779() {
+        String dn = "CN=\"  \"";
+        X500Principal principal = new X500Principal(dn);
+        assertEquals("CN=\"  \"", principal.getName(X500Principal.RFC1779));
+    }
+
+    /**
+     * Inits X500Principal with string with spaces
+     * gets Name in RFC2253 format
+     * compares with expected value of name
+     */
+    public void testNameOnlySpaces_RFC2253() {
+        String dn = "CN=\"  \"";
+        X500Principal principal = new X500Principal(dn);
+        assertEquals("CN=\\ \\ ", principal.getName(X500Principal.RFC2253));
+    }
+
+    /**
+     * Inits X500Principal with string with only spaces,
+     * gets Name in CANONICAL format:leading and trailing white space
+     * chars are removed even string doesn't have other chars (bug???)
+     */
+    public void testNameOnlySpaces_CANONICAL() {
+        String dn = "CN=\"  \"";
+        X500Principal principal = new X500Principal(dn);
+        assertEquals("cn=", principal.getName(X500Principal.CANONICAL));
+    }
+
+    ///*** Negative Tests ***///
+
+    /**
+     * Inits X500Principal with string, where DN name is improper "CNN"
+     * checks if proper exception is thrown
+     */
+    public void testIllegalInputName() {
+        try {
+            String dn = "CNN=A";
+            new X500Principal(dn);
+            fail("No IllegalArgumentException on improper input name \"CNN\"");
+        } catch (IllegalArgumentException e) {
+        }
+    }
+
+    /**
+     * Inits X500Principal with string, where there is leading ';'
+     * checks if proper exception is thrown
+     */
+    public void testIllegalInputName_01() {
+        try {
+            String dn = ";CN=A";
+            new X500Principal(dn);
+            fail("No IllegalArgumentException on leading ';' in input name");
+        } catch (IllegalArgumentException e) {
+        }
+    }
+
+    /**
+     * Inits X500Principal with string, where there is leading '='
+     * checks if proper exception is thrown
+     */
+    public void testIllegalInputName_02() {
+        try {
+            String dn = "=CN=A";
+            new X500Principal(dn);
+            fail("No IllegalArgumentException on leading '=' in input name");
+        } catch (IllegalArgumentException e) {
+        }
+    }
+
+    /**
+     * Inits X500Principal with string, where there is no value
+     * checks if proper exception is thrown
+     */
+    public void testEmptyInputName_0() {
+        String dn = "CN=";
+        byte[] mess = { 0x30, 0x0B, 0x31, 0x09, 0x30, 0x07, 0x06, 0x03, 0x55,
+                0x04, 0x03, 0x13, 0x00 };
+        X500Principal principal = new X500Principal(dn);
+        assertTrue(Arrays.equals(mess, principal.getEncoded()));
+    }
+
+    public void testEmptyInputName_1() {
+        String dn = "CN=\"\", C=\"\"";
+        X500Principal principal = new X500Principal(dn);
+        dn = "CN=, C=";
+        X500Principal principal2 = new X500Principal(dn);
+        assertTrue(Arrays.equals(principal.getEncoded(), principal2
+                .getEncoded()));
+
+    }
+
+    public void testEmptyInputName_2() {
+        String dn = "CN=\"\" + OU=A, C=\"\"";
+        X500Principal principal = new X500Principal(dn);
+        dn = "CN=+OU=A, C=";
+        X500Principal principal2 = new X500Principal(dn);
+        assertTrue(Arrays.equals(principal.getEncoded(), principal2
+                .getEncoded()));
+
+    }
+
+    public void testIllegalInputName_15() {
+        try {
+            String dn = "CN=,C";
+            new X500Principal(dn);
+            fail("No IllegalArgumentException on improper attribute value");
+        } catch (IllegalArgumentException e) {
+        }
+    }
+
+    public void testIllegalInputName_16() {
+        try {
+            String dn = "CN=,C=+";
+            new X500Principal(dn);
+            fail("No IllegalArgumentException on improper attribute value");
+        } catch (IllegalArgumentException e) {
+        }
+    }
+
+    /**
+     * Inits X500Principal with string, where value is given in wrong hex format
+     * checks if proper exception is thrown
+     */
+    public void testIllegalInputName_04() {
+        try {
+            String dn = "CN=#XYZ";
+            new X500Principal(dn);
+            fail("No IllegalArgumentException on improper hex value");
+        } catch (IllegalArgumentException e) {
+        }
+    }
+
+    /**
+     * Inits X500Principal with string, where value is given with special chars
+     * checks if proper exception is thrown
+     */
+    public void testIllegalInputName_05() {
+        try {
+            String dn = "CN=X+YZ";
+            new X500Principal(dn);
+            fail("No IllegalArgumentException on improper attribute value");
+        } catch (IllegalArgumentException e) {
+        }
+    }
+
+    /**
+     * Inits X500Principal with string, where value is given with special chars
+     * Compatibility issue: according RFC 2253 such string is invalid
+     * but we accept it, not string char is escaped
+     */
+    public void testIllegalInputName_06() {
+        String dn = "CN=X=YZ";
+        X500Principal p = new X500Principal(dn);
+        assertEquals("CN=X\\=YZ", p.getName(X500Principal.RFC2253));
+    }
+
+    /**
+     * Inits X500Principal with string, where value is given with not string chars
+     * Compatibility issue: according RFC 2253 such string is invalid
+     * but we accept it, not string char is escaped
+     */
+    public void testIllegalInputName_07() {
+        String dn = "CN=X\"YZ";
+        X500Principal p = new X500Principal(dn);
+        assertEquals("CN=X\\\"YZ", p.getName(X500Principal.RFC2253));
+    }
+
+    /**
+     * Inits X500Principal with string, where value is given with special chars
+     * Compatibility issue: according RFC 2253 such string is invalid
+     * but we accept it, special char is escaped
+     */
+    public void testIllegalInputName_08() {
+        String dn = "CN=X<YZ";
+        X500Principal p = new X500Principal(dn);
+        assertEquals("CN=X\\<YZ", p.getName(X500Principal.RFC2253));
+    }
+
+    /**
+     * Inits X500Principal with string, where value is given with special chars
+     * checks if proper exception is thrown
+     */
+    public void testIllegalInputName_09() {
+        try {
+            String dn = "CN=#";
+            new X500Principal(dn);
+            fail("No IllegalArgumentException on improper attribute hex value");
+        } catch (IllegalArgumentException e) {
+            //ignore
+        }
+
+    }
+
+    /**
+     * Inits X500Principal with string, where value is given with special chars
+     * checks if proper exception is thrown
+     */
+    public void testIllegalInputName_10() {
+        try {
+            String dn = "CN=#13";
+            new X500Principal(dn);
+            fail("No IllegalArgumentException on improper attribute hex value");
+        } catch (IllegalArgumentException e) {
+            //ignore
+        }
+
+    }
+
+    /**
+     * Inits X500Principal with string, where value is given with special chars
+     * checks if proper exception is thrown
+     */
+    public void testIllegalInputName_11() {
+        try {
+            String dn = "CN=#1301";
+            new X500Principal(dn);
+            fail("No IllegalArgumentException on improper attribute hex value");
+        } catch (IllegalArgumentException e) {
+            //ignore
+        }
+
+    }
+
+    /**
+     * Inits X500Principal with string, where value is given with special chars
+     * checks if proper exception is thrown
+     */
+    public void testIllegalInputName_12() {
+        try {
+            String dn = "CN=#13010101";
+            new X500Principal(dn);
+            fail("No IllegalArgumentException on improper attribute hex value");
+        } catch (IllegalArgumentException e) {
+        }
+    }
+
+    /**
+     * Inits X500Principal with string, where value is given with special chars
+     * checks if proper exception is thrown
+     */
+    public void testIllegalInputName_13() {
+        try {
+            String dn = "CN=# 0";
+            new X500Principal(dn);
+            fail("No IllegalArgumentException on improper attribute hex value");
+        } catch (IllegalArgumentException e) {
+        }
+    }
+
+    /**
+     * Inits X500Principal with string, where value is given in hex format, but improper tag
+     * checks if it is ignored
+     */
+    public void testSemiIllegalInputName_14() {
+        String dn = "CN=#7E0142";
+        new X500Principal(dn);
+    }
+
+    public void testInitClause() {
+        try {
+            byte[] mess = { 0x30, 0x18, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03,
+                    0x55, 0x04, 0x03, 0x13, 0x01, 0x42, 0x31, 0x0A, 0x30, 0x08,
+                    0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x41 };
+            mess[3] = 0x12;//length field
+            new X500Principal(mess);
+
+            fail("No IllegalArgumentException on input array with improper length field");
+        } catch (IllegalArgumentException e) {
+        }
+    }
+
+    /**
+     * Inits X500Principal with byte array = null
+     * checks if proper exception is thrown
+     */
+    public void testIllegalInputArray_0() {
+        try {
+            byte[] mess = null;
+            new X500Principal(mess);
+            fail("No IllegalArgumentException on input array with improper length field");
+        } catch (IllegalArgumentException e) {
+        }
+    }
+
+    /**
+     * Inits X500Principal with byte array with wrong length field
+     * checks if proper exception is thrown
+     */
+    public void testIllegalInputArray() {
+        try {
+            byte[] mess = { 0x30, 0x18, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03,
+                    0x55, 0x04, 0x03, 0x13, 0x01, 0x42, 0x31, 0x0A, 0x30, 0x08,
+                    0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x41 };
+            mess[3] = 0x12;//length field
+            new X500Principal(mess);
+
+            fail("No IllegalArgumentException on input array with improper length field");
+        } catch (IllegalArgumentException e) {
+        }
+    }
+
+    /**
+     * Inits X500Principal with input stream with wrong length field
+     * checks if proper exception is thrown
+     */
+    public void testIllegalInputArray_is() {
+        try {
+            byte[] mess = { 0x30, 0x18, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03,
+                    0x55, 0x04, 0x03, 0x13, 0x01, 0x42, 0x31, 0x0A, 0x30, 0x08,
+                    0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x41 };
+            mess[3] = 0x12;//length field
+            ByteArrayInputStream is = new ByteArrayInputStream(mess);
+            new X500Principal(is);
+
+            fail("No IllegalArgumentException on input array with improper length field");
+        } catch (IllegalArgumentException e) {
+        }
+    }
+
+    /**
+     * Inits X500Principal with byte array with wrong inner Sequence tag field
+     * checks if proper exception is thrown
+     */
+    public void testIllegalInputArray_01() {
+        try {
+            byte[] mess = { 0x30, 0x18, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03,
+                    0x55, 0x04, 0x03, 0x13, 0x01, 0x42, 0x31, 0x0A, 0x30, 0x08,
+                    0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x41 };
+            mess[4] = 0x12;//inner Sequence tag field
+            new X500Principal(mess);
+
+            fail("No IllegalArgumentException on input array with improper inner Sequence tag field");
+        } catch (IllegalArgumentException e) {
+        }
+    }
+
+    /**
+     * Inits X500Principal with byte array with wrong last byte of OID
+     * checks if proper exception is thrown
+     */
+    public void testIllegalInputArray_02() {
+        try {
+            byte[] mess = { 0x30, 0x18, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03,
+                    0x55, 0x04, 0x03, 0x13, 0x01, 0x42, 0x31, 0x0A, 0x30, 0x08,
+                    0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x41 };
+            mess[10] = (byte) 0xFE;//last byte of OID
+            new X500Principal(mess);
+
+            fail("No IllegalArgumentException on input array with improper last byte of OID");
+        } catch (IllegalArgumentException e) {
+        }
+    }
+
+    /**
+     * Inits X500Principal with byte array with wrong length of OID
+     * checks if proper exception is thrown
+     */
+    public void testIllegalInputArray_03() {
+        try {
+            byte[] mess = { 0x30, 0x18, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03,
+                    0x55, 0x04, 0x03, 0x13, 0x01, 0x42, 0x31, 0x0A, 0x30, 0x08,
+                    0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x41 };
+            mess[7] = 2;//length of OID
+            new X500Principal(mess);
+
+            fail("No IllegalArgumentException on input array with improper length of OID");
+        } catch (IllegalArgumentException e) {
+        }
+    }
+
+    /**
+     * Inits X500Principal with byte array with wrong tag of value
+     * checks if it is ignored
+     */
+    public void testSemiIllegalInputArray_04() {
+        byte[] mess = { 0x30, 0x18, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55,
+                0x04, 0x03, 0x13, 0x01, 0x42, 0x31, 0x0A, 0x30, 0x08, 0x06,
+                0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x41 };
+        mess[11] = (byte) 0x0F;//tag of value
+        new X500Principal(mess);
+    }
+
+    /**
+     * Inits X500Principal with byte array with wrong length of value
+     * checks if proper exception is thrown
+     */
+    public void testIllegalInputArray_05() {
+        try {
+            byte[] mess = { 0x30, 0x18, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03,
+                    0x55, 0x04, 0x03, 0x13, 0x01, 0x42, 0x31, 0x0A, 0x30, 0x08,
+                    0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x41 };
+            mess[12] = 2;//length of value
+            new X500Principal(mess);
+
+            fail("No IllegalArgumentException on input array with improper length of value");
+        } catch (IllegalArgumentException e) {
+        }
+    }
+
+    /**
+     * Inits X500Principal with input stream with wrong length of value
+     * checks if proper exception is thrown
+     */
+    public void testIllegalInputArray_05_is() {
+        try {
+            byte[] mess = { 0x30, 0x18, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03,
+                    0x55, 0x04, 0x03, 0x13, 0x01, 0x42, 0x31, 0x0A, 0x30, 0x08,
+                    0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x41 };
+            mess[12] = 2;//length of value
+            ByteArrayInputStream is = new ByteArrayInputStream(mess);
+            new X500Principal(is);
+
+            fail("No IllegalArgumentException on input array with improper length of value");
+        } catch (IllegalArgumentException e) {
+        }
+    }
+
+    /**
+     * Inits X500Principal with string
+     * Calls getName with improper parameter as format
+     * checks if proper exception is thrown
+     */
+    public void testIllegalFormat() {
+        try {
+            String dn = "CN=A";
+            X500Principal principal = new X500Principal(dn);
+            principal.getName("WRONG FORMAT");
+            fail("No IllegalArgumentException on improper parameter as format");
+        } catch (IllegalArgumentException e) {
+        }
+    }
+
+    /**
+     * Inits X500Principal with a string, there are multiple AVAs and Oid which does not fall into any keyword
+     * Gets encoding
+     * Inits other X500Principal with the encoding
+     * gets string in RFC1779 format
+     * compares with expected value paying attention on sorting order of AVAs
+     */
+    public void testGetName_EncodingWithWrongOidButGoodName_MultAVA_RFC1779()
+            throws Exception {
+        String dn = "OID.2.16.4.3=B + CN=A";
+        X500Principal principal = new X500Principal(dn);
+        byte[] enc = principal.getEncoded();
+        X500Principal principal2 = new X500Principal(enc);
+        String s = principal2.getName(X500Principal.RFC1779);
+        assertEquals("OID.2.16.4.3=B + CN=A", s);
+
+    }
+
+    /**
+     * Inits X500Principal with a string, there are multiple AVAs and Oid which does not fall into any keyword
+     * Gets encoding
+     * Inits other X500Principal with the encoding
+     * gets string in RFC2253 format
+     * compares with expected value paying attention on sorting order of AVAs
+     */
+    public void testGetName_EncodingWithWrongOidButGoodName_MultAVA_RFC2253()
+            throws Exception {
+        String dn = "OID.2.16.4.3=B + CN=A";
+        X500Principal principal = new X500Principal(dn);
+        byte[] enc = principal.getEncoded();
+        X500Principal principal2 = new X500Principal(enc);
+        String s = principal2.getName(X500Principal.RFC2253);
+        assertEquals("2.16.4.3=#130142+CN=A", s);
+
+    }
+
+    /**
+     * Inits X500Principal with a string, there are multiple AVAs and Oid which does not fall into any keyword
+     * Gets encoding
+     * Inits other X500Principal with the encoding
+     * gets string in CANONICAL format
+     * compares with expected value paying attention on sorting order of AVAs
+     */
+    public void testGetName_EncodingWithWrongOidButGoodName_MultAVA_CANONICAL()
+            throws Exception {
+        String dn = "OID.2.16.4.3=B + CN=A";
+        X500Principal principal = new X500Principal(dn);
+        byte[] enc = principal.getEncoded();
+        X500Principal principal2 = new X500Principal(enc);
+        String s = principal2.getName(X500Principal.CANONICAL);
+        assertEquals("cn=a+2.16.4.3=#130142", s);
+
+    }
+
+    /**
+     * Inits X500Principal with byte array, where there are leading and tailing spaces
+     * gets Name in RFC1779 format
+     * compares with expected value of name
+     */
+    public void testNameSpaceFromEncoding_RFC1779() throws Exception {
+        byte[] mess = { 0x30, 0x0E, 0x31, 0x0C, 0x30, 0x0A, 0x06, 0x03, 0x55,
+                0x04, 0x03, 0x13, 0x03, 0x20, 0x41, 0x20, };
+        X500Principal principal = new X500Principal(mess);
+        String s = principal.getName(X500Principal.RFC1779);
+        assertEquals("CN=\" A \"", s);
+
+    }
+
+    /**
+     * Inits X500Principal with byte array, where there are leading and tailing spaces
+     * gets Name in RFC2253 format
+     * compares with expected value of name
+     */
+    public void testNameSpaceFromEncoding_RFC2253() throws Exception {
+        byte[] mess = { 0x30, 0x0E, 0x31, 0x0C, 0x30, 0x0A, 0x06, 0x03, 0x55,
+                0x04, 0x03, 0x13, 0x03, 0x20, 0x41, 0x20, };
+        X500Principal principal = new X500Principal(mess);
+        String s = principal.getName(X500Principal.RFC2253);
+        assertEquals("CN=\\ A\\ ", s);
+
+    }
+
+    /**
+     * Inits X500Principal with byte array, where there are leading and tailing spaces
+     * gets Name in CANONICAL format
+     * compares with expected value of name
+     */
+    public void testNameSpaceFromEncoding_CANONICAL() throws Exception {
+        byte[] mess = { 0x30, 0x0E, 0x31, 0x0C, 0x30, 0x0A, 0x06, 0x03, 0x55,
+                0x04, 0x03, 0x13, 0x03, 0x20, 0x41, 0x20, };
+        X500Principal principal = new X500Principal(mess);
+        String s = principal.getName(X500Principal.CANONICAL);
+        assertEquals("cn=a", s);
+
+    }
+
+    /**
+     * Inits X500Principal with byte array, where there are special characters
+     * gets Name in RFC1779 format
+     * compares with expected value of name, checks if the string is in quotes
+     */
+    public void testNameSpecialCharsFromEncoding_RFC1779() throws Exception {
+        byte[] mess = { 0x30, 0x0D, 0x31, 0x0B, 0x30, 0x09, 0x06, 0x03, 0x55,
+                0x04, 0x03, 0x0C, 0x02, 0x3B, 0x2C };
+        X500Principal principal = new X500Principal(mess);
+        String s = principal.getName(X500Principal.RFC1779);
+        assertEquals("CN=\";,\"", s);
+
+    }
+
+    /**
+     * Inits X500Principal with byte array, where there are special characters
+     * gets Name in RFC1779 format
+     * compares with expected value of name, checks if the characters are escaped
+     */
+    public void testNameSpecialCharsFromEncoding_RFC2253() throws Exception {
+        byte[] mess = { 0x30, 0x0D, 0x31, 0x0B, 0x30, 0x09, 0x06, 0x03, 0x55,
+                0x04, 0x03, 0x0C, 0x02, 0x3B, 0x2C };
+        X500Principal principal = new X500Principal(mess);
+        String s = principal.getName(X500Principal.RFC2253);
+        assertEquals("CN=\\;\\,", s);
+
+    }
+
+    /**
+     * Inits X500Principal with byte array, where there are special characters
+     * gets Name in CANONICAL format
+     * compares with expected value of name, checks if the characters are escaped
+     */
+    public void testNameSpecialCharsFromEncoding_CANONICAL() throws Exception {
+        byte[] mess = { 0x30, 0x0D, 0x31, 0x0B, 0x30, 0x09, 0x06, 0x03, 0x55,
+                0x04, 0x03, 0x0C, 0x02, 0x3B, 0x2C };
+        X500Principal principal = new X500Principal(mess);
+        String s = principal.getName(X500Principal.CANONICAL);
+        assertEquals("cn=\\;\\,", s);
+
+    }
+
+    /**
+     * Inits X500Principal with the string with special characters - \"B
+     * gets Name in RFC1779 format
+     * compares with expected value of name - "\B"
+     */
+    public void testNameSpecialChars_RFC1779() throws Exception {
+        String dn = "CN=A,CN=\\\"B";
+        X500Principal principal = new X500Principal(dn);
+        String s = principal.getName(X500Principal.RFC1779);
+        assertEquals("CN=A, CN=\"\\\"B\"", s);
+
+    }
+
+    /**
+     * Inits X500Principal with the string with special characters - \"B
+     * gets Name in RFC2253 format
+     * compares with expected value of name - "\B"
+     */
+    public void testNameSpecialChars_RFC2253() throws Exception {
+        String dn = "CN=A,CN=\\\"B";
+        X500Principal principal = new X500Principal(dn);
+        String s = principal.getName(X500Principal.RFC2253);
+        assertEquals("CN=A,CN=\\\"B", s);
+
+    }
+
+    /**
+     * Inits X500Principal with the string with special characters - \"B
+     * gets Name in CANONICAL format
+     * compares with expected value of name - "\b"
+     */
+    public void testNameSpecialChars_CANONICAL() throws Exception {
+        String dn = "CN=A,CN=\\\"B";
+        X500Principal principal = new X500Principal(dn);
+        String s = principal.getName(X500Principal.CANONICAL);
+        assertEquals("cn=a,cn=\\\"b", s);
+
+    }
+
+    /**
+     * Inits X500Principal with the string with special characters - \\nB
+     * gets Name in RFC1779 format
+     * compares with expected value of name - "\nB"
+     */
+    public void testNameSpecialChars_RFC1779_01() throws Exception {
+        //FIXME see testNameSpecialChars_RFC2253_01
+        //        String dn = "CN=\\\nB";
+        //        X500Principal principal = new X500Principal(dn);
+        //        String s = principal.getName(X500Principal.RFC1779);
+        //        assertEquals("CN=\"\nB\"", s);
+
+    }
+
+    /**
+     * Inits X500Principal with the string with special characters - \\nB
+     * gets Name in RFC2253 format
+     * compares with expected value of name - \\nB
+     */
+    public void testNameSpecialChars_RFC2253_01() throws Exception {
+
+        try {
+            // compatibility issue:
+            // don't accept escaped \n because it is not a special char
+            new X500Principal("CN=\\\nB");
+            fail("No expected IllegalArgumentException");
+        } catch (IllegalArgumentException e) {
+        }
+    }
+
+    /**
+     * Inits X500Principal with the string with special characters - \\nB
+     * gets Name in CANONICAL format
+     * compares with expected value of name - \\nb
+     */
+    public void testNameSpecialChars_CANONICAL_01() throws Exception {
+        //FIXME testNameSpecialChars_RFC2253_01
+        //        String dn = "CN=\\\nB";
+        //        X500Principal principal = new X500Principal(dn);
+        //        String s = principal.getName(X500Principal.CANONICAL);
+        //        assertEquals("cn=b", s);
+
+    }
+
+    /**
+     * Inits X500Principal with the string with special characters - \\B
+     * gets Name in RFC1779 format
+     * compares with expected value of name - "\B"
+     */
+    public void testNameSpecialChars_RFC1779_02() throws Exception {
+        String dn = "CN=\\\\B";
+        X500Principal principal = new X500Principal(dn);
+        String s = principal.getName(X500Principal.RFC1779);
+        assertEquals("CN=\"\\\\B\"", s);
+
+    }
+
+    /**
+     * Inits X500Principal with the string with special characters - \\B
+     * gets Name in RFC2253 format
+     * compares with expected value of name - \\B
+     */
+    public void testNameSpecialChars_RFC2253_02() throws Exception {
+        String dn = "CN=\\\\B";
+        X500Principal principal = new X500Principal(dn);
+        String s = principal.getName(X500Principal.RFC2253);
+        assertEquals("CN=\\\\B", s);
+
+    }
+
+    /**
+     * Inits X500Principal with the string with special characters - \\B
+     * gets Name in CANONICAL format
+     * compares with expected value of name - \\b
+     */
+    public void testNameSpecialChars_CANONICAL_02() throws Exception {
+        String dn = "CN=\\\\B";
+        X500Principal principal = new X500Principal(dn);
+        String s = principal.getName(X500Principal.CANONICAL);
+        assertEquals("cn=\\\\b", s);
+
+    }
+
+    /**
+     * Inits X500Principal with the string with special characters - ABC"DEF"
+     * gets encoding
+     * compares with expected encoding
+     */
+    public void testNameWithQuotation() throws Exception {
+        String dn = "CN=\"ABCDEF\"";
+
+        X500Principal principal = new X500Principal(dn);
+        byte[] enc = principal.getEncoded();
+        assertTrue(Arrays.equals(new byte[] { 0x30, 0x11, 0x31, 0x0F, 0x30,
+                0x0D, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x06, 0x41, 0x42,
+                0x43, 0x44, 0x45, 0x46 }, enc));
+
+    }
+
+    /**
+     * Inits X500Principal with the string with special characters - "ABCDEF
+     * checks if the proper exception is thrown
+     */
+    public void testNameWithQuotation_01() throws Exception {
+        String dn = "CN=\"ABCDEF";
+        try {
+            new X500Principal(dn);
+            fail("No IllegalArgumentException on string with no closing quotations");
+        } catch (IllegalArgumentException e) {
+        }
+    }
+
+    /**
+     * Inits X500Principal with the string with special characters - ABC"D#EF"
+     * gets encoding
+     * compares with expected encoding
+     */
+    public void testNameWithQuotation_02() throws Exception {
+        String dn = "CN=\"ABCD#EF\"";
+        X500Principal principal = new X500Principal(dn);
+        byte[] enc = principal.getEncoded();
+        assertTrue(Arrays.equals(new byte[] { 0x30, 0x12, 0x31, 0x10, 0x30,
+                0x0E, 0x06, 0x03, 0x55, 0x04, 0x03, 0x0C, 0x07, 0x41, 0x42,
+                0x43, 0x44, 0x23, 0x45, 0x46 }, enc));
+    }
+
+    /**
+     * Inits X500Principal with the string with special characters - ABC"DEF"
+     * Compatibility issue: according RFC 2253 such string is invalid
+     * but we accept it, not string char is escaped
+     */
+    public void testNameWithQuotation_03() throws Exception {
+        String dn = "CN=ABC\"DEF\"";
+        X500Principal principal = new X500Principal(dn);
+        assertEquals("CN=ABC\\\"DEF\\\"", principal
+                .getName(X500Principal.RFC2253));
+    }
+
+    /**
+     * Inits X500Principal with the string with special characters - ABC"DEF"
+     * gets Name in RFC1779 format
+     * compares with expected value of name - "ABCDEF"
+     */
+    public void testNameSpecialChars_RFC1779_03() throws Exception {
+        String dn = "CN=\"ABCDEF\"";
+        X500Principal principal = new X500Principal(dn);
+        String s = principal.getName(X500Principal.RFC1779);
+        assertEquals("CN=ABCDEF", s);
+
+    }
+
+    /**
+     * Inits X500Principal with the string with special characters - ABC"DEF"
+     * gets Name in RFC2253 format
+     * compares with expected value of name - ABC"DEF"
+     */
+    public void testNameSpecialChars_RFC2253_03() throws Exception {
+        String dn = "CN=\"ABCDEF\"";
+        X500Principal principal = new X500Principal(dn);
+        String s = principal.getName(X500Principal.RFC2253);
+        assertEquals("CN=ABCDEF", s);
+
+    }
+
+    /**
+     * Inits X500Principal with the string with special characters - ABC"DEF"
+     * gets Name in CANONICAL format
+     * compares with expected value of name - abc"def"
+     */
+    public void testNameSpecialChars_CANONICAL_03() throws Exception {
+        String dn = "CN=\"ABCDEF\"";
+        X500Principal principal = new X500Principal(dn);
+        String s = principal.getName(X500Principal.CANONICAL);
+        assertEquals("cn=abcdef", s);
+
+    }
+
+    /**
+     * Inits X500Principal with the string with special characters - ABC"D#EF"
+     * gets Name in RFC1779 format
+     * compares with expected value of name - "ABCD#EF"
+     */
+    public void testNameSpecialChars_RFC1779_04() throws Exception {
+        String dn = "CN=\"ABCD#EF\"";
+        X500Principal principal = new X500Principal(dn);
+        String s = principal.getName(X500Principal.RFC1779);
+        assertEquals("CN=\"ABCD#EF\"", s);
+
+    }
+
+    /**
+     * Inits X500Principal with the string with special characters - ABC"D#EF"
+     * gets Name in RFC1779 format
+     * compares with expected value of name - ABCD\#EF
+     */
+    public void testNameSpecialChars_RFC2253_04() throws Exception {
+        String dn = "CN=\"ABCD#EF\"";
+        X500Principal principal = new X500Principal(dn);
+        String s = principal.getName(X500Principal.RFC2253);
+        assertEquals("CN=ABCD\\#EF", s);
+
+    }
+
+    /**
+     * Inits X500Principal with the string with special characters - ABC"D#EF"
+     * gets Name in RFC1779 format
+     * compares with expected value of name - abc"d#ef"
+     */
+    public void testNameSpecialChars_CANONICAL_04() throws Exception {
+        String dn = "CN=\"ABCD#EF\"";
+        X500Principal principal = new X500Principal(dn);
+        String s = principal.getName(X500Principal.CANONICAL);
+        assertEquals("cn=abcd#ef", s);
+
+    }
+
+    /**
+     * Inits X500Principal with the string with special characters - X#YZ
+     * gets Name in RFC1779 format
+     * compares with expected value of name - "X#YZ"
+     */
+    public void testNameSpecialChars_RFC1779_05() {
+        String dn = "CN=X#YZ";
+        X500Principal principal = new X500Principal(dn);
+
+        String s = principal.getName(X500Principal.RFC1779);
+        assertEquals("CN=\"X#YZ\"", s);
+
+    }
+
+    /**
+     * Inits X500Principal with the string with special characters - X#YZ
+     * gets Name in RFC2253 format
+     * compares with expected value of name - X\#YZ
+     */
+    public void testNameSpecialChars_RFC2253_05() {
+        String dn = "CN=X#YZ";
+        X500Principal principal = new X500Principal(dn);
+
+        String s = principal.getName(X500Principal.RFC2253);
+
+        assertEquals("CN=X\\#YZ", s);
+
+    }
+
+    /**
+     * Inits X500Principal with the string with special characters - X#YZ
+     * gets Name in CANONICAL format
+     * compares with expected value of name - x#yz
+     */
+    public void testNameSpecialChars_CANONICAL_05() {
+        String dn = "CN=X#YZ";
+        X500Principal principal = new X500Principal(dn);
+
+        String s = principal.getName(X500Principal.CANONICAL);
+        assertEquals("cn=x#yz", s);
+
+    }
+
+    /**
+     * Inits X500Principal with the string with special characters - CN=\#XYZ
+     * gets Name in RFC1779 format
+     * compares with expected value of name - CN="#XYZ"
+     */
+    public void testNameSpecialChars_RFC1779_6() throws Exception {
+        String dn = "CN=\\#XYZ";
+        X500Principal principal = new X500Principal(dn);
+        String s = principal.getName(X500Principal.RFC1779);
+        assertEquals("CN=\"#XYZ\"", s);
+
+    }
+
+    /**
+     * Inits X500Principal with the string with special characters - CN=\#XYZ
+     * gets Name in RFC2253 format
+     * compares with expected value of name - CN=\#XYZ
+     */
+    public void testNameSpecialChars_RFC2253_6() throws Exception {
+        String dn = "CN=\\#XYZ";
+        X500Principal principal = new X500Principal(dn);
+        String s = principal.getName(X500Principal.RFC2253);
+        assertEquals("CN=\\#XYZ", s);
+    }
+
+    /**
+     * Inits X500Principal with the string with special characters - CN=\#XYZ
+     * gets Name in CANONICAL format
+     * compares with expected value of name - cn=\#xyz
+     */
+    public void testNameSpecialChars_CANONICAL_6() throws Exception {
+        String dn = "CN=\\#XYZ";
+        X500Principal principal = new X500Principal(dn);
+        String s = principal.getName(X500Principal.CANONICAL);
+        assertEquals("cn=\\#xyz", s);
+    }
+
+    /**
+     * Inits X500Principal with the string with special characters - B\'space'
+     * gets Name in RFC1779 format
+     * compares with expected value of name - "B "
+     */
+    public void testNameSpaces_RFC1779() throws Exception {
+        String dn = "CN=A,CN=B\\ ";
+        X500Principal principal = new X500Principal(dn);
+        String s = principal.getName(X500Principal.RFC1779);
+        assertEquals("CN=A, CN=\"B \"", s);
+
+    }
+
+    /**
+     * Inits X500Principal with the string with special characters - B\'space'
+     * gets Name in RFC2253 format
+     * compares with expected value of name - B\'space'
+     */
+    public void testNameSpaces_RFC2253() throws Exception {
+        String dn = "CN=A,CN=B\\ ";
+        X500Principal principal = new X500Principal(dn);
+        String s = principal.getName(X500Principal.RFC2253);
+        assertEquals("CN=A,CN=B\\ ", s);
+
+    }
+
+    /**
+     * Inits X500Principal with the string with special characters - B\'space'
+     * gets Name in CANONICAL format
+     * compares with expected value of name - B\
+     */
+    public void testNameSpaces_CANONICAL() throws Exception {
+        String dn = "CN=A,CN=B\\ ";
+        X500Principal principal = new X500Principal(dn);
+        String s = principal.getName(X500Principal.CANONICAL);
+        assertEquals("cn=a,cn=b", s);
+
+    }
+
+    /**
+     * Inits X500Principal with the string with special characters - "B'space''space''space'A"
+     * gets Name in RFC1779 format
+     * compares with expected value of name - "B   A"
+     */
+    public void testNameSpaces_RFC1779_01() throws Exception {
+        String dn = "CN=\"B   A\"";
+        X500Principal principal = new X500Principal(dn);
+        String s = principal.getName(X500Principal.RFC1779);
+        assertEquals("CN=B   A", s);
+
+    }
+
+    /**
+     * Inits X500Principal with the string with special characters - "B'space''space''space'A"
+     * gets Name in 2253 format
+     * compares with expected value of name - B'space''space''space'A
+     */
+    public void testNameSpaces_RFC2253_01() throws Exception {
+        String dn = "CN=\"B   A\"";
+        X500Principal principal = new X500Principal(dn);
+        String s = principal.getName(X500Principal.RFC2253);
+        assertEquals("CN=B   A", s);
+
+    }
+
+    /**
+     * Inits X500Principal with the string with special characters - "B'space''space''space'A"
+     * gets Name in CANONICAL format
+     * compares with expected value of name - b'space'a
+     */
+    public void testNameSpaces_CANONICAL_01() throws Exception {
+        String dn = "CN=\"B   A\"";
+        X500Principal principal = new X500Principal(dn);
+        String s = principal.getName(X500Principal.CANONICAL);
+        assertEquals("cn=b a", s);
+
+    }
+
+    /**
+     * Inits X500Principal with the string with special characters - \\'space''space'B
+     * gets Name in RFC1779 format
+     * compares with expected value of name - "  B"
+     */
+    public void testNameSpaces_RFC1779_02() throws Exception {
+        String dn = "CN=\\  B";
+        X500Principal principal = new X500Principal(dn);
+        String s = principal.getName(X500Principal.RFC1779);
+        assertEquals("CN=\"  B\"", s);
+
+    }
+
+    /**
+     * Inits X500Principal with the string with special characters - \\'space''space'B
+     * gets Name in RFC1779 format
+     * compares with expected value of name - \'space''space'B
+     */
+    public void testNameSpaces_RFC2253_02() throws Exception {
+        String dn = "CN=\\  B";
+        X500Principal principal = new X500Principal(dn);
+        String s = principal.getName(X500Principal.RFC2253);
+        assertEquals("CN=\\  B", s);
+
+    }
+
+    /**
+     * Inits X500Principal with the string with special characters - \\'space''space'B
+     * gets Name in CANONICAL format
+     * compares with expected value of name - \'space''space'b
+     */
+    public void testNameSpaces_CANONICAL_02() throws Exception {
+        String dn = "CN=\\  B";
+        X500Principal principal = new X500Principal(dn);
+        String s = principal.getName(X500Principal.CANONICAL);
+        assertEquals("cn=b", s);
+
+    }
+
+    /**
+     * Inits X500Principal with the string with special characters - ""B
+     * checks if the proper exception is thrown
+     */
+    public void testNameQu() throws Exception {
+        String dn = "CN=\"\"B";
+        try {
+            new X500Principal(dn);
+            fail("No IllegalArgumentException on improper string");
+        } catch (IllegalArgumentException e) {
+        }
+    }
+
+    /**
+     * Inits X500Principal with the string with special characters - "A\"B"
+     * gets Name in RFC1779 format
+     * compares with expected value of name - "A\"B"
+     */
+    public void testNameQu_RFC1779_2() throws Exception {
+        String dn = "CN=\"A\\\"B\"";
+        X500Principal principal = new X500Principal(dn);
+        String s = principal.getName(X500Principal.RFC1779);
+        assertEquals("CN=\"A\\\"B\"", s);
+    }
+
+    /**
+     * Inits X500Principal with the string with special characters - "A\"B"
+     * gets Name in RFC2253 format
+     * compares with expected value of name - A\"B
+     */
+    public void testNameQu_RFC2253_2() throws Exception {
+        String dn = "CN=\"A\\\"B\"";
+        X500Principal principal = new X500Principal(dn);
+        String s = principal.getName(X500Principal.RFC2253);
+        assertEquals("CN=A\\\"B", s);
+    }
+
+    /**
+     * Inits X500Principal with the string with special characters - "A\"B"
+     * gets Name in CANONICAL format
+     * compares with expected value of name - a\"b
+     */
+    public void testNameQu_CANONICAL_2() throws Exception {
+        String dn = "CN=\"A\\\"B\"";
+        X500Principal principal = new X500Principal(dn);
+        String s = principal.getName(X500Principal.CANONICAL);
+        assertEquals("cn=a\\\"b", s);
+
+    }
+
+    /**
+     * Inits X500Principal with the string with special characters - "A\""
+     * gets Name in RFC1779 format
+     * compares with expected value of name - "A\""
+     */
+    public void testNameQu_RFC1779_3() throws Exception {
+        String dn = "CN=\"A\\\"\"";
+        X500Principal principal = new X500Principal(dn);
+        String s = principal.getName(X500Principal.RFC1779);
+        assertEquals("CN=\"A\\\"\"", s);
+    }
+
+    /**
+     * Inits X500Principal with the string with special characters - "A\""
+     * gets Name in RFC2253 format
+     * compares with expected value of name - A\"
+     */
+    public void testNameQu_RFC2253_3() throws Exception {
+        String dn = "CN=\"A\\\"\"";
+        X500Principal principal = new X500Principal(dn);
+        String s = principal.getName(X500Principal.RFC2253);
+        assertEquals("CN=A\\\"", s);
+    }
+
+    /**
+     * Inits X500Principal with the string with special characters - "A\""
+     * gets Name in CANONICAL format
+     * compares with expected value of name - A\"
+     */
+    public void testNameQu_CANONICAL_3() throws Exception {
+        String dn = "CN=\"A\\\"\"";
+        X500Principal principal = new X500Principal(dn);
+        String s = principal.getName(X500Principal.CANONICAL);
+        assertEquals("cn=a\\\"", s);
+
+    }
+
+    /**
+     * Inits X500Principal with the string with special characters - "A\", C=B"
+     * gets Name in RFC1779 format
+     * compares with expected value of name - "A\", C=B"
+     */
+    public void testNameQu_4() throws Exception {
+        String dn = "CN=\"A\\\", C=B\"";
+        X500Principal principal = new X500Principal(dn);
+        String s = principal.getName(X500Principal.RFC1779);
+        assertEquals("CN=\"A\\\", C=B\"", s);
+
+    }
+
+    /**
+     * Inits X500Principal with the string with special characters - CN="A\\", C=B
+     * gets Name in RFC1779 format
+     * compares with expected value of name - CN="A\\", C=B
+     */
+    public void testNameQu_5() throws Exception {
+        String dn = "CN=\"A\\\\\", C=B";
+        X500Principal principal = new X500Principal(dn);
+        String s = principal.getName(X500Principal.RFC1779);
+        assertEquals("CN=\"A\\\\\", C=B", s);
+
+    }
+
+    /**
+     * Inits X500Principal with the string with special characters - CN=A\nB
+     * gets Name in RFC1779 format
+     * compares with expected value of name - CN="A\nB"
+     */
+    public void testNameCR_RFC1779() throws Exception {
+        String dn = "CN=A\nB";
+        X500Principal principal = new X500Principal(dn);
+        String s = principal.getName(X500Principal.RFC1779);
+        assertEquals("CN=A\nB", s);
+    }
+
+    /**
+     * Inits X500Principal with the string with special characters - CN=A\nB
+     * gets Name in RFC2253 format
+     * compares with expected value of name - CN=A\nB
+     */
+    public void testNameCR_RFC2253() throws Exception {
+        String dn = "CN=A\nB";
+        X500Principal principal = new X500Principal(dn);
+        String s = principal.getName(X500Principal.RFC2253);
+        assertEquals("CN=A\nB", s);
+    }
+
+    /**
+     * Inits X500Principal with the string with special characters - CN=A\nB
+     * gets Name in CANONICAL format
+     * compares with expected value of name - cn=a\nb
+     */
+    public void testNameCR_CANONICAL() throws Exception {
+        String dn = "CN=A\nB";
+        X500Principal principal = new X500Principal(dn);
+        String s = principal.getName(X500Principal.CANONICAL);
+        assertEquals("cn=a\nb", s);
+    }
+
+    public static final String[] RFC2253_SPECIAL = new String[] { ",", "=",
+            "+", "<", ">", "#", ";" };
+
+    public void testValidDN() throws Exception {
+
+        TestList list = new TestList();
+
+        list.add("", "", "", "", new byte[] { 0x30, 0x00 }); // empty RDN sequence
+
+        // sequence of RDN: RDN *("," RDN)
+        list.add("CN=A,C=B", "CN=A,C=B", "CN=A, C=B", "cn=a,c=b");
+        list.add("C=B,CN=A", "C=B,CN=A", "C=B, CN=A", "c=b,cn=a");
+        list.add("CN=A,CN=A", "CN=A,CN=A", "CN=A, CN=A", "cn=a,cn=a"); // duplicate RDNs
+
+        // sequence of RDN: RFC 1779 compatibility
+        list.add("CN=A , C=B", "CN=A,C=B", "CN=A, C=B");
+        list.add("CN=A  ,  C=B", "CN=A,C=B", "CN=A, C=B");
+        list.add("CN=A;C=B", "CN=A,C=B", "CN=A, C=B");
+        list.add("CN=A ; C=B", "CN=A,C=B", "CN=A, C=B");
+        //FIXME list.add("CN=A\r,\rC=B", "CN=A,C=B"); // <CR> & comma => comma
+        list.add("  CN=A,C=B  ", "CN=A,C=B", "CN=A, C=B"); // spaces at beg&end
+        list.add("  CN=A,C=\"B\"  ", "CN=A,C=B", "CN=A, C=B"); // spaces at beg&end
+
+        // set of ATAV: ATAV *("+" ATAV)
+        list.add("CN=A+ST=CA", "CN=A+ST=CA", "CN=A + ST=CA", "cn=a+st=ca");
+        list.add("CN=A+CN=A", "CN=A+CN=A", "CN=A + CN=A", "cn=a+cn=a"); // duplicate AT
+        list
+                .add("2.5.4.3=A+2.5.4.3=A", "CN=A+CN=A", "CN=A + CN=A",
+                        "cn=a+cn=a"); // duplicate AT
+
+        // set of ATAV: RFC 1779 compatibility
+        list.add("CN=A + ST=CA", "CN=A+ST=CA", "CN=A + ST=CA");
+        list.add("CN=A  +  ST=CA", "CN=A+ST=CA", "CN=A + ST=CA");
+        //FIXME list.add("CN=A\r+\rST=CA", "CN=A+ST=CA"); // <CR> & '+' => '+'
+
+        // ATAV = AttributeType "=" AttributeValue
+        list.add("CN=A", "CN=A", "CN=A");
+        list.add("cn=A", "CN=A", "CN=A"); // AT case insensitive
+        list.add("cN=A", "CN=A", "CN=A"); // AT case insensitive
+        list.add("cn=a", "CN=a", "CN=a"); // AT case insensitive
+
+        // ATAV : RFC 1779 compatibility
+        list.add("CN = A", "CN=A", "CN=A");
+        list.add("CN  =  A", "CN=A", "CN=A");
+        // FIXME list.add("CN\r=\rA", "CN=A"); // <CR> & '=' => '='
+
+        // AttributeType = <name string> | <OID>
+        // testing OID case :  OID => <name string>
+        // tested all OIDs from RFC 2253 (2.3) and RFC 1779 (Table 1)
+
+        // different variants of 2.5.4.3 (CN) OID
+        list.add("OID.2.5.4.3=A", "CN=A", "CN=A");
+        list.add("oid.2.5.4.3=A", "CN=A", "CN=A");
+        list.add("2.5.4.3=A", "CN=A", "CN=A");
+        list.add("02.5.4.3=A", "CN=A", "CN=A"); // first: 02 => 2
+        list.add("2.5.4.0003=A", "CN=A", "CN=A"); // last: 0003 => 3
+
+        // the rest of OIDs
+        list.add("2.5.4.7=A", "L=A", "L=A", "l=a");
+        list.add("2.5.4.8=A", "ST=A", "ST=A", "st=a");
+        list.add("2.5.4.10=A", "O=A", "O=A", "o=a");
+        list.add("2.5.4.11=A", "OU=A", "OU=A", "ou=a");
+        list.add("2.5.4.6=A", "C=A", "C=A", "c=a");
+        list.add("2.5.4.9=A", "STREET=A", "STREET=A", "street=a");
+        list.add("0.9.2342.19200300.100.1.25=A", "DC=A",
+                "OID.0.9.2342.19200300.100.1.25=A", "dc=a");
+        list.add("0.9.2342.19200300.100.1.1=A", "UID=A",
+                "OID.0.9.2342.19200300.100.1.1=A", "uid=a");
+
+        // attribute types from RFC 2459 (see Appendix A)
+        // keywords are from the API spec
+        list.add("T=A", "2.5.4.12=#130141", "OID.2.5.4.12=A",
+                "2.5.4.12=#130141");
+        list.add("DNQ=A", "2.5.4.46=#130141", "OID.2.5.4.46=A",
+                "2.5.4.46=#130141");
+        list.add("DNQUALIFIER=A", "2.5.4.46=#130141", "OID.2.5.4.46=A",
+                "2.5.4.46=#130141");
+        list.add("SURNAME=A", "2.5.4.4=#130141", "OID.2.5.4.4=A",
+                "2.5.4.4=#130141");
+        list.add("GIVENNAME=A", "2.5.4.42=#130141", "OID.2.5.4.42=A",
+                "2.5.4.42=#130141");
+        list.add("INITIALS=A", "2.5.4.43=#130141", "OID.2.5.4.43=A",
+                "2.5.4.43=#130141");
+        list.add("GENERATION=A", "2.5.4.44=#130141", "OID.2.5.4.44=A",
+                "2.5.4.44=#130141");
+        list.add("EMAILADDRESS=A", "1.2.840.113549.1.9.1=#130141",
+                "OID.1.2.840.113549.1.9.1=A", "1.2.840.113549.1.9.1=#130141",
+                null, (byte) 0x05); //FIXME bug???
+        list.add("SERIALNUMBER=A", "2.5.4.5=#130141", "OID.2.5.4.5=A",
+                "2.5.4.5=#130141");
+
+        // AttributeValue => BER encoding (if OID in dotted-decimal form)
+        // see RFC 2253 (2.4)
+        list.add("OID.2.5.4.12=A", "2.5.4.12=#130141", "OID.2.5.4.12=A");
+        list.add("oid.2.5.4.12=A", "2.5.4.12=#130141", "OID.2.5.4.12=A");
+        list.add("2.5.4.12=A", "2.5.4.12=#130141", "OID.2.5.4.12=A");
+        list.add("1.1=A", "1.1=#130141", "OID.1.1=A");
+
+        //
+        // AttributeValue first alternative : *( stringchar / pair )
+        // testing pair characters.
+        //
+        // Note: for RFC1779 quoted string is returned (unspecified)
+        //
+        list.add("CN=", "CN=", "CN="); // zero string chars
+        list.add("CN= ", "CN=", "CN="); // zero string chars
+        list.add("CN=A+ST=", "CN=A+ST=", "CN=A + ST="); // zero string chars
+        list.add("CN=+ST=A", "CN=+ST=A", "CN= + ST=A"); // empty value for 1 RDN
+        list.add("CN=A+ST= ", "CN=A+ST=", "CN=A + ST="); // empty value for 1 RDN
+        list.add("CN=+ST=", "CN=+ST=", "CN= + ST="); // empty value for both RDNs
+        list.add("CN=,ST=B", "CN=,ST=B", "CN=, ST=B"); // empty value for 1 RDN
+        list.add("CN=,ST=", "CN=,ST=", "CN=, ST="); // empty value for both RDNs
+        list.add("CN=;ST=B", "CN=,ST=B", "CN=, ST=B"); // empty value for 1 RDN
+        list.add("CN=;ST=", "CN=,ST=", "CN=, ST="); // empty value for both RDNs
+        for (String element : RFC2253_SPECIAL) {
+            // \special
+            list.add("CN=\\" + element,
+                    "CN=\\" + element, "CN=\"" + element
+                    + "\"");
+
+            // A + \special + B
+            list.add("CN=A\\" + element + "B", "CN=A\\"
+                    + element + "B", "CN=\"A" + element
+                    + "B\"");
+        }
+
+        // pair = \"
+        list.add("CN=\\\"", "CN=\\\"", "CN=\"\\\"\"", null, (byte) 0x02);
+        list.add("CN=\\\"A", "CN=\\\"A", "CN=\"\\\"A\"", null, (byte) 0x02);
+        list.add("CN=\\\",C=\\\"", "CN=\\\",C=\\\"", "CN=\"\\\"\", C=\"\\\"\"",
+                null, (byte) 0x02); // 2 RDN
+        list.add("CN=A\\\"B", "CN=A\\\"B", "CN=\"A\\\"B\"", null, (byte) 0x02); // A\"B
+        list.add("CN=A ST=B", "CN=A ST\\=B", "CN=\"A ST=B\""); // no RDN separator
+
+        // pair = \space
+        list.add("CN=\\ ", "CN=\\ ", "CN=\" \"", "cn=");
+
+        // pair = \hexpair
+        list.add("CN=\\41", "CN=A", "CN=A"); // 0x41=='A'
+        list.add("CN=\\41\\2C", "CN=A\\,", "CN=\"A,\""); // 0x41=='A', 0x2C=','
+        list.add("CN=\\41\\2c", "CN=A\\,", "CN=\"A,\""); // 0x41=='A', 0x2c=','
+        list.add("CN=\\D0\\AF", "CN=" + ((char) 1071), "CN=" + ((char) 1071),
+                new byte[] { 0x30, 0x0D, 0x31, 0x0B, 0x30, 0x09, 0x06, 0x03,
+                        0x55, 0x04, 0x03,
+                        // UTF8 String
+                        0x0C, 0x02, (byte) 0xD0, (byte) 0xAF }); // 0xD0AF == the last letter(capital) of Russian alphabet
+        list.add("CN=\\D0\\AFA\\41", "CN=" + ((char) 1071) + "AA", "CN="
+                + ((char) 1071) + "AA", new byte[] { 0x30, 0x0F, 0x31, 0x0D,
+                0x30, 0x0B, 0x06, 0x03, 0x55, 0x04, 0x03,
+                // UTF8 String
+                0x0C, 0x04, (byte) 0xD0, (byte) 0xAF, 0x41, 0x41 }); // 0xD0AF == the last letter(capital) of Russian alphabet
+        // UTF-8(0xE090AF) is non-shortest form of UTF-8(0xD0AF)
+        //FIXME list.add("CN=\\E0\\90\\AF", "CN=" + ((char) 1071), "CN="
+        //        + ((char) 1071), new byte[] { 0x30, 0x0D, 0x31, 0x0B, 0x30,
+        //        0x09, 0x06, 0x03, 0x55, 0x04, 0x03,
+        //        // UTF8 String
+        //        0x0C, 0x02, (byte) 0xD0, (byte) 0xAF });
+        // UTF-8(0xF08090AF) is non-shortest form of UTF-8(0xD0AF)
+        //FIXME list.add("CN=\\F0\\80\\90\\AF", "CN=" + ((char) 1071), "CN="
+        //        + ((char) 1071), new byte[] { 0x30, 0x0D, 0x31, 0x0B, 0x30,
+        //        0x09, 0x06, 0x03, 0x55, 0x04, 0x03,
+        //        // UTF8 String
+        //        0x0C, 0x02, (byte) 0xD0, (byte) 0xAF });
+        //FIXME        list.add("CN=\\D0", "CN=" + ((char) 65533), "CN=" + ((char) 65533),
+        //                new byte[] { 0x30, 0x0C, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03,
+        //                        0x55, 0x04, 0x03,
+        //                        // UTF8 String
+        //                        0x0C, 0x01, 0x3F }); // 0xD0 is not correct UTF8 char => '?'
+        list.add("CN=\\41+ST=A", "CN=A+ST=A", "CN=A + ST=A"); // 0x41=='A'
+        list.add("CN=\\41\\2C+ST=A", "CN=A\\,+ST=A", "CN=\"A,\" + ST=A"); // 0x41=='A', 0x2C=','
+        list.add("CN=\\41\\2c+ST=A", "CN=A\\,+ST=A", "CN=\"A,\" + ST=A"); // 0x41=='A', 0x2c=','
+
+        // stringchar '=' or not leading '#'
+        //FIXME RFC 2253 grammar violation: '=' and '#' is a special char
+        list.add("CN==", "CN=\\=", "CN=\"=\"");
+        list.add("CN=A=", "CN=A\\=", "CN=\"A=\"");
+        list.add("CN=A#", "CN=A\\#", "CN=\"A#\"");
+
+        // not leading or trailing spaces
+        list.add("CN=A B", "CN=A B", "CN=A B", "cn=a b");
+        list.add("CN=A\\ B", "CN=A B", "CN=A B", "cn=a b");
+        list.add("CN=A \\,B", "CN=A \\,B", "CN=\"A ,B\"", "cn=a \\,b");
+
+        //not alphabet chars
+        list.add("CN=$", "CN=$", "CN=$", new byte[] { 0x30, 0x0C, 0x31, 0x0A,
+                0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x03,
+                //UTF-8 String: "$"
+                0x0C, 0x01, 0x24 });
+        list.add("CN=(", "CN=(", "CN=(", new byte[] { 0x30, 0x0C, 0x31, 0x0A,
+                0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x03,
+                //PrintableString: "("
+                0x13, 0x01, 0x28 });
+
+        //
+        //
+        // AttributeValue second alternative : "#" hexstring
+        //
+        //
+        list.add("CN=#130141", "CN=A", "CN=A", "cn=a"); // ASN1 Printable hex string = 'A'
+        list.add("CN=#140141", "CN=A", "CN=A", "cn=#140141", new byte[] { 0x30,
+                0x0C, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x03,
+                0x14, 0x01, 0x41 }); // ASN1 Teletex hex string = 'A'
+
+        list.add("CN=#010100", "CN=#010100", "CN=#010100", "cn=#010100"); // ASN1 Boolean = FALSE
+        list.add("CN=#0101fF", "CN=#0101ff", "CN=#0101FF", "cn=#0101ff"); // ASN1 Boolean = TRUE
+        //FIXME list.add("CN=#3000", "CN=#3000", "CN=#3000"); // ASN1 Sequence
+        //FIXME list.add("CN=#0500", "CN=A", "CN=A"); // ASN1 Null
+        list.add("CN= #0101fF", "CN=#0101ff", "CN=#0101FF", // space at beginning
+                new byte[] { 0x30, 0x0C, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03,
+                        0x55, 0x04, 0x03, 0x01, 0x01, (byte) 0xFF } // ASN.1 Boolean = TRUE
+        );
+        list.add("CN= #0101fF+ST=A", "CN=#0101ff+ST=A", "CN=#0101FF + ST=A",
+                "cn=#0101ff+st=a"); //space
+        list.add("CN= #0101fF ", "CN=#0101ff", "CN=#0101FF", // space at the end
+                new byte[] { 0x30, 0x0C, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03,
+                        0x55, 0x04, 0x03, 0x01, 0x01, (byte) 0xFF } // ASN.1 Boolean = TRUE
+                , (byte) 0x00);
+
+        //FIXME unspecified output for RFC1779
+        //FIXME list.add("CN=#1C0141", "CN=A", "CN=A"); // ASN1 Universal hex string = 'A'
+        //FIXME list.add("CN=#1E0141", "CN=A", "CN=A"); // ASN1 Bmp hex string = 'A'
+
+        //
+        // AttributeValue third alternative : " *( quotechar / pair ) "
+        // quotechar = <any character except '\' or '"' >
+        //
+        // Note:
+        // RFC2253: passed quoted AV string is unquoted, special chars are escaped
+        // RFC1779: escaped quoted chars are unescaped
+        //
+        list.add("CN=\"\"", "CN=", "CN="); // empty quoted string
+        list.add("CN=\"A\"", "CN=A", "CN=A"); // "A"
+        for (String element : RFC2253_SPECIAL) {
+            // "special" => \special
+            list.add("CN=\"" + element + "\"", "CN=\\"
+                    + element, "CN=\"" + element + "\"");
+
+            // "A + special + B" => A + \special + B
+            list.add("CN=\"A" + element + "B\"", "CN=A\\"
+                    + element + "B", "CN=\"A" + element
+                    + "B\"");
+        }
+        for (String element : RFC2253_SPECIAL) {
+            // "\special" => \special
+            list.add("CN=\"\\" + element + "\"", "CN=\\"
+                    + element, "CN=\"" + element + "\"");
+
+            // "A + \special + B" => A + \special + B
+            list.add("CN=\"A\\" + element + "B\"", "CN=A\\"
+                    + element + "B", "CN=\"A" + element
+                    + "B\"");
+        }
+        list.add("CN=\"\\\"\"", "CN=\\\"", "CN=\"\\\"\"", null, (byte) 0x02); // "\""
+        list.add("CN=\"A\\\"B\"", "CN=A\\\"B", "CN=\"A\\\"B\"", null,
+                (byte) 0x02); // "A\"B"
+
+        // pair = \hexpair (test cases are the same as for the first alternative)
+        list.add("CN=\"\\41\"", "CN=A", "CN=A"); // 0x41=='A'
+        list.add("CN=\"\\41\\2C\"", "CN=A\\,", "CN=\"A,\""); // 0x41=='A', 0x2C=','
+        list.add("CN=\"\\41\\2c\"", "CN=A\\,", "CN=\"A,\""); // 0x41=='A', 0x2c=','
+        list.add("CN=\"\\D0\\AF\"", "CN=" + ((char) 1071), "CN="
+                + ((char) 1071), new byte[] { 0x30, 0x0D, 0x31, 0x0B, 0x30,
+                0x09, 0x06, 0x03, 0x55, 0x04, 0x03,
+                // UTF8 String
+                0x0C, 0x02, (byte) 0xD0, (byte) 0xAF }); // 0xD0AF == the last letter(capital) of Russian alphabet
+        list.add("CN=\"\\D0\\AFA\\41\"", "CN=" + ((char) 1071) + "AA", "CN="
+                + ((char) 1071) + "AA", new byte[] { 0x30, 0x0F, 0x31, 0x0D,
+                0x30, 0x0B, 0x06, 0x03, 0x55, 0x04, 0x03,
+                // UTF8 String
+                0x0C, 0x04, (byte) 0xD0, (byte) 0xAF, 0x41, 0x41 }); // 0xD0AF == the last letter(capital) of Russian alphabet
+        list.add("CN=\"\\E0\\90\\AF\"", "CN=" + ((char) 1071), "CN="
+                + ((char) 1071), new byte[] { 0x30, 0x0D, 0x31, 0x0B, 0x30,
+                0x09, 0x06, 0x03, 0x55, 0x04, 0x03,
+                // UTF8 String
+                0x0C, 0x02, (byte) 0xD0, (byte) 0xAF }); // UTF8(0xE090AF that is not quite correct)== UTF8(0xD0AF) == the last letter(capital) of Russian alphabet
+        list.add("CN=\"\\F0\\80\\90\\AF\"", "CN=" + ((char) 1071), "CN="
+                + ((char) 1071), new byte[] { 0x30, 0x0D, 0x31, 0x0B, 0x30,
+                0x09, 0x06, 0x03, 0x55, 0x04, 0x03,
+                // UTF8 String
+                0x0C, 0x02, (byte) 0xD0, (byte) 0xAF }); // UTF8(0xF08090AF that is not quite correct)== UTF8(0xD0AF) == the last letter(capital) of Russian alphabet
+
+        list.add("CN=\"\\41\"+ST=A", "CN=A+ST=A", "CN=A + ST=A"); // 0x41=='A'
+        list.add("CN=\"\\41\\2C\"+ST=A", "CN=A\\,+ST=A", "CN=\"A,\" + ST=A"); // 0x41=='A', 0x2C=','
+        list.add("CN=\"\\41\\2c\"+ST=A", "CN=A\\,+ST=A", "CN=\"A,\" + ST=A"); // 0x41=='A', 0x2c=','
+
+        // AttributeValue third alternative : RFC 1779 compatibility
+        //FIXME list.add("CN=\"\r\"", "CN=\"\r\""); // "<CR>"
+        //FIXME list.add("CN=\"\\\r\"", "CN=\"\\\r\""); // "\<CR>"
+
+        // AttributeValue : RFC 1779 compatibility
+        list.add("CN=  A  ", "CN=A", "CN=A", "cn=a"); // leading & trailing spaces
+        list.add("CN=\\  A  ", "CN=\\  A", "CN=\"  A\"", "cn=a", null,
+                (byte) 0x01); // escaped leading space
+        list.add("CN=  A \\ ", "CN=A \\ ", "CN=\"A  \"", "cn=a", null,
+                (byte) 0x01); // escaped trailing space
+
+        list.add("CN=  \"A\"  ", "CN=A", "CN=A", "cn=a"); // leading & trailing spaces
+
+        StringBuffer errorMsg = new StringBuffer();
+        for (int i = 0; i < list.size(); i++) {
+
+            Object[] obj = list.get(i);
+
+            String dn = (String) obj[0];
+            String rfc2253 = (String) obj[1];
+            String rfc1779 = (String) obj[2];
+            String canonical = (String) obj[3];
+            byte[] encoded = (byte[]) obj[4];
+            byte mask = ((byte[]) obj[5])[0];
+
+            try {
+                X500Principal p = new X500Principal(dn);
+                if (!rfc2253.equals(p.getName(X500Principal.RFC2253))) {
+                    if (!testing || ((mask & 0x01) == 0)) {
+
+                        errorMsg.append("RFC2253: " + i);
+                        errorMsg.append("\tparm: '" + dn + "'");
+                        errorMsg.append("\t\texpected: '" + rfc2253 + "'");
+                        errorMsg.append("\treturned: '"
+                                + p.getName(X500Principal.RFC2253) + "'\n");
+                    }
+                }
+
+                if (!rfc1779.equals(p.getName(X500Principal.RFC1779))) {
+                    if (!testing || ((mask & 0x02) == 0)) {
+
+                        errorMsg.append("RFC1779: " + i);
+                        errorMsg.append("\tparm: '" + dn + "'");
+                        errorMsg.append("\t\texpected: " + rfc1779 + "'");
+                        errorMsg.append("\treturned: '"
+                                + p.getName(X500Principal.RFC1779) + "'\n");
+                    }
+                }
+
+                if (canonical != null) {
+                    if (!canonical.equals(p.getName(X500Principal.CANONICAL))) {
+                        if (!testing || ((mask & 0x04) == 0)) {
+
+                            errorMsg.append("CANONICAL: " + i);
+                            errorMsg.append("\tparm: '" + dn + "'");
+                            errorMsg.append("\t\texpected: " + canonical + "'");
+                            errorMsg.append("\treturned: '"
+                                    + p.getName(X500Principal.CANONICAL)
+                                    + "'\n");
+                        }
+                    }
+                }
+
+                if (encoded != null) {
+                    if (!Arrays.equals(encoded, p.getEncoded())) {
+                        if (!testing || ((mask & 0x08) == 0)) {
+
+                            errorMsg.append("Unexpected encoding for: " + i
+                                    + ", dn= '" + dn + "'\n");
+
+                            System.out.println("\nI " + i);
+                            byte[] enc = p.getEncoded();
+                            for (byte element : enc) {
+                                System.out.print(", 0x"
+                                        + Integer.toHexString(element));
+                            }
+                        }
+                    }
+                }
+            } catch (IllegalArgumentException e) {
+                errorMsg.append("IllegalArgumentException: " + i);
+                errorMsg.append("\tparm: '" + dn + "'\n");
+            } catch (Exception e) {
+                errorMsg.append("Exception: " + i);
+                errorMsg.append("\tparm: '" + dn + "'");
+                errorMsg.append("\texcep: " + e.getClass().getName() + "\n");
+            }
+        }
+
+        if (errorMsg.length() != 0) {
+            fail(errorMsg.toString());
+        }
+
+    }
+
+    public void testInvalidDN() {
+        String[] illegalDN = new String[] {
+                // RDN
+                //FIXME " ", // space only
+                "CN", // attribute type only
+                "CN=A;", // RFC 1779: BNF allows this, but ...
+                "CN=A,", // RFC 1779: BNF allows this, but ...
+                ",CN=A", // no AttributeType for first RDN
+                "CN=,A", // no AttributeType for second RDN
+                "CN=A+", // no AttributeTypeAndValue for second RDN
+                "CN=#130141 ST=B", // no RDN separator
+
+                // AttributeType = <name string> | <OID>
+                "AAA=A", // no such <name string>
+                "1..1=A", // wrong OID
+                ".1.1=A", // wrong OID
+                "11=A", // wrong OID
+                "1=A", // wrong OID
+                "AID.1.1=A", // wrong OID
+                "1.50=A", // wrong OID
+                "5.1.0=A", // wrong OID
+                "2.-5.4.3=A", // wrong OID
+                "2.5.-4.3=A", // wrong OID
+                "2.5.4-.3=A", // wrong OID
+                //FIXME "2.5.4.-3=A", // wrong OID
+
+                // AttributeValue first alternative : *( stringchar / pair )
+                "CN=,", // stringchar = ','
+                //FIXME "CN==",
+                "CN=+", // stringchar = '+'
+                //FIXME "CN=<", // stringchar = '<'
+                //FIXME "CN=>", // stringchar = '>'
+                "CN=#", // stringchar = '#'
+                //FIXME "CN=Z#", // stringchar = '#'
+                "CN=;", // stringchar = ';'
+                "CN=\"", // stringchar = "
+                //FIXME "CN=A\"B", // stringchar = "
+                "CN=\\", // stringchar = \
+                "CN=A\\", // stringchar = \
+                "CN=A\\B", // stringchar = \
+                "CN=\\z", // invalid pair = \z
+                "CN=\\4", // invalid pair = \4
+                "CN=\\4Z", // invalid pair = \4Z
+                "CN=\\4\\2c", // invalid pair = \4\2c
+
+                // AttributeValue second alternative : "#" hexstring
+                "CN=#", // no hex string
+                "CN=#2", // no hex pair
+                "CN=#22", // hexpair is not BER encoding
+                "CN=#0001", // invalid BER encoding (missed content)
+                "CN=#000201", // invalid BER encoding (wrong length)
+                "CN=#0002010101", // invalid BER encoding (wrong length)
+                "CN=#00FF", // invalid BER encoding (wrong length)
+                "CN=#ZZ", // not hex pair
+
+                // FIXME boolean with indefinite length
+                //"CN=#0100010000", // invalid BER encoding (wrong length)
+
+                // AttributeValue third alternative : " *( quotechar / pair ) "
+                "CN=\"A\" B", // TODO comment me
+                "CN=\"A\\", // TODO comment me
+                "CN=\"\\4\"", // invalid pair = \4
+                "CN=\"\\4Z\"", // invalid pair = \4Z
+                "CN=\"\\4\\2c\"", // invalid pair = \4\2c
+        };
+
+        StringBuffer errorMsg = new StringBuffer();
+        for (String element : illegalDN) {
+
+            try {
+                new X500Principal(element);
+                errorMsg.append("No IllegalArgumentException: '" + element
+                        + "'\n");
+            } catch (IllegalArgumentException e) {
+            }
+        }
+
+        if (errorMsg.length() != 0) {
+            fail(errorMsg.toString());
+        }
+    }
+
+    public void testValidEncoding() {
+        TestList list = new TestList();
+
+        //
+        // Empty
+        //
+        list.add(new byte[] { 0x30, 0x00 }, "", "", "");
+        list.add(new byte[] { 0x30, 0x02, 0x31, 0x00 }, "", "", ""); //??? invalid size constraints
+
+        //
+        // Known OID + string with different tags(all string)
+        //
+        list.add(new byte[] { 0x30, 0x0C, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03,
+                0x55, 0x04, 0x03,
+                // PrintableString
+                0x13, 0x01, 0x5A }, "CN=Z", "CN=Z", "cn=z");
+        list.add(new byte[] { 0x30, 0x0C, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03,
+                0x55, 0x04, 0x03,
+                // TeletexString
+                0x14, 0x01, 0x5A }, "CN=Z", "CN=Z", "cn=#14015a");
+        //FIXME:compatibility        list.add(new byte[] { 0x30, 0x0C, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03,
+        //                0x55, 0x04, 0x03,
+        //                // UniversalString
+        //                0x1C, 0x01, 0x5A }, "CN=Z", "CN=Z", "cn=z");
+        list.add(new byte[] { 0x30, 0x0C, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03,
+                0x55, 0x04, 0x03,
+                // UTF8String
+                0x0C, 0x01, 0x5A }, "CN=Z", "CN=Z", "cn=z");
+        //FIXME:compatibility        list.add(new byte[] { 0x30, 0x0C, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03,
+        //                0x55, 0x04, 0x03,
+        //                // BMPString
+        //                0x1E, 0x01, 0x5A }, "CN=Z", "CN=Z", "cn=z");
+
+        //
+        // Unknown OID + string with different tags(all string)
+        //
+        list.add(new byte[] { 0x30, 0x0A, 0x31, 0x08, 0x30, 0x06, 0x06, 0x01,
+                0x00,
+                // PrintableString
+                0x13, 0x01, 0x5A }, "0.0=#13015a", "OID.0.0=Z", "0.0=#13015a");
+        list.add(new byte[] { 0x30, 0x0A, 0x31, 0x08, 0x30, 0x06, 0x06, 0x01,
+                0x00,
+                // TeletexString
+                0x14, 0x01, 0x5A }, "0.0=#14015a", "OID.0.0=Z", "0.0=#14015a");
+        //FIXME:compatibility        list.add(new byte[] { 0x30, 0x0A, 0x31, 0x08, 0x30, 0x06, 0x06, 0x01,
+        //                0x00,
+        //                // UniversalString
+        //                0x1C, 0x01, 0x5A }, "0.0=#1c015a", "OID.0.0=Z", "cn=z");
+        list.add(new byte[] { 0x30, 0x0A, 0x31, 0x08, 0x30, 0x06, 0x06, 0x01,
+                0x00,
+                // UTF8String
+                0x0C, 0x01, 0x5A }, "0.0=#0c015a", "OID.0.0=Z", "0.0=#0c015a");
+        //FIXME:compatibility        list.add(new byte[] { 0x30, 0x0A, 0x31, 0x08, 0x30, 0x06, 0x06, 0x01,
+        //                0x00,
+        //                // BMPString
+        //                0x1E, 0x01, 0x5A }, "0.0=#1e015a", "OID.0.0=Z", "cn=z");
+
+        //
+        // Known OID + not a string value
+        //
+        list.add(new byte[] { 0x30, 0x0C, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03,
+                0x55, 0x04, 0x03,
+                // Boolean
+                0x01, 0x01, (byte) 0xFF }, "CN=#0101ff", "CN=#0101FF",
+                "cn=#0101ff");
+        list.add(new byte[] { 0x30, 0x0C, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03,
+                0x55, 0x04, 0x03,
+                // Integer
+                0x02, 0x01, 0x0F }, "CN=#02010f", "CN=#02010F", "cn=#02010f");
+        list.add(new byte[] { 0x30, 0x0C, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03,
+                0x55, 0x04, 0x03,
+                // BitString
+                0x03, 0x01, 0x00 }, "CN=#030100", "CN=#030100", "cn=#030100");
+        list.add(new byte[] { 0x30, 0x0C, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03,
+                0x55, 0x04, 0x03,
+                // SEQUENCE
+                0x30, 0x01, 0x0A }, "CN=#30010a", "CN=#30010A", "cn=#30010a");
+
+        //
+        // unknown OID + not a string value
+        //
+        list.add(new byte[] { 0x30, 0x0A, 0x31, 0x08, 0x30, 0x06, 0x06, 0x01,
+                0x00,
+                // Boolean
+                0x01, 0x01, (byte) 0xFF }, "0.0=#0101ff", "OID.0.0=#0101FF",
+                "0.0=#0101ff");
+        list.add(new byte[] { 0x30, 0x0A, 0x31, 0x08, 0x30, 0x06, 0x06, 0x01,
+                0x00,
+                // Integer
+                0x02, 0x01, 0x0F }, "0.0=#02010f", "OID.0.0=#02010F",
+                "0.0=#02010f");
+        list.add(new byte[] { 0x30, 0x0A, 0x31, 0x08, 0x30, 0x06, 0x06, 0x01,
+                0x00,
+                // BitString
+                0x03, 0x01, 0x00 }, "0.0=#030100", "OID.0.0=#030100",
+                "0.0=#030100");
+        list.add(new byte[] { 0x30, 0x0A, 0x31, 0x08, 0x30, 0x06, 0x06, 0x01,
+                0x00,
+                // SEQUENCE
+                0x30, 0x01, 0x0A }, "0.0=#30010a", "OID.0.0=#30010A",
+                "0.0=#30010a");
+
+        //
+        // Known OID + UTF-8 string with chars to be escaped
+        //
+
+        // spaces
+        list.add(new byte[] { 0x30, 0x0C, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03,
+                0x55, 0x04, 0x03,
+                // UTF8String: a single space char
+                0x0C, 0x01, 0x20 }, "CN=\\ ", "CN=\" \"", "cn=");
+        list.add(new byte[] { 0x30, 0x0D, 0x31, 0x0B, 0x30, 0x09, 0x06, 0x03,
+                0x55, 0x04, 0x03,
+                // UTF8String: a space char at the beginning
+                0x0C, 0x02, 0x20, 0x5A }, "CN=\\ Z", "CN=\" Z\"", "cn=z");
+        list.add(new byte[] { 0x30, 0x0E, 0x31, 0x0C, 0x30, 0x0A, 0x06, 0x03,
+                0x55, 0x04, 0x03,
+                // UTF8String: two space chars at the beginning
+                0x0C, 0x03, 0x20, 0x20, 0x5A }, "CN=\\  Z", "CN=\"  Z\"",
+                "cn=z", (byte) 0x01);
+        list.add(new byte[] { 0x30, 0x0D, 0x31, 0x0B, 0x30, 0x09, 0x06, 0x03,
+                0x55, 0x04, 0x03,
+                // UTF8String: a space char at the end
+                0x0C, 0x02, 0x5A, 0x20 }, "CN=Z\\ ", "CN=\"Z \"", "cn=z");
+        list.add(new byte[] { 0x30, 0x0E, 0x31, 0x0C, 0x30, 0x0A, 0x06, 0x03,
+                0x55, 0x04, 0x03,
+                // UTF8String: two space chars at the end
+                0x0C, 0x03, 0x5A, 0x20, 0x20 }, "CN=Z \\ ", "CN=\"Z  \"",
+                "cn=z", (byte) 0x01);
+
+        // special chars
+        list.add(new byte[] { 0x30, 0x0D, 0x31, 0x0B, 0x30, 0x09, 0x06, 0x03,
+                0x55, 0x04, 0x03,
+                // UTF8String: a '#' char at the beginning
+                0x0C, 0x02, 0x23, 0x5A }, "CN=\\#Z", "CN=\"#Z\"", "cn=\\#z");
+        list.add(new byte[] { 0x30, 0x0E, 0x31, 0x0C, 0x30, 0x0A, 0x06, 0x03,
+                0x55, 0x04, 0x03,
+                // UTF8String: two '#' chars
+                0x0C, 0x03, 0x23, 0x5A, 0x23 }, "CN=\\#Z\\#", "CN=\"#Z#\"",
+                "cn=\\#z#");
+        list.add(new byte[] { 0x30, 0x0D, 0x31, 0x0B, 0x30, 0x09, 0x06, 0x03,
+                0x55, 0x04, 0x03,
+                // UTF8String: ','
+                0x0C, 0x02, 0x5A, 0x2C }, "CN=Z\\,", "CN=\"Z,\"", "cn=z\\,");
+        list.add(new byte[] { 0x30, 0x0D, 0x31, 0x0B, 0x30, 0x09, 0x06, 0x03,
+                0x55, 0x04, 0x03,
+                // UTF8String: '+'
+                0x0C, 0x02, 0x5A, 0x2B }, "CN=Z\\+", "CN=\"Z+\"", "cn=z\\+");
+        list.add(new byte[] { 0x30, 0x0D, 0x31, 0x0B, 0x30, 0x09, 0x06, 0x03,
+                0x55, 0x04, 0x03,
+                // UTF8String: '"'
+                0x0C, 0x02, 0x5A, 0x22 }, "CN=Z\\\"", "CN=\"Z\\\"\"",
+                "cn=z\\\"", (byte) 0x02);
+        list.add(new byte[] { 0x30, 0x0D, 0x31, 0x0B, 0x30, 0x09, 0x06, 0x03,
+                0x55, 0x04, 0x03,
+                // UTF8String: '\'
+                0x0C, 0x02, 0x5A, 0x5C }, "CN=Z\\\\", "CN=\"Z\\\\\"",
+                "cn=z\\\\", (byte) 0x02);
+        list.add(new byte[] { 0x30, 0x0D, 0x31, 0x0B, 0x30, 0x09, 0x06, 0x03,
+                0x55, 0x04, 0x03,
+                // UTF8String: '<'
+                0x0C, 0x02, 0x5A, 0x3C }, "CN=Z\\<", "CN=\"Z<\"", "cn=z\\<");
+        list.add(new byte[] { 0x30, 0x0D, 0x31, 0x0B, 0x30, 0x09, 0x06, 0x03,
+                0x55, 0x04, 0x03,
+                // UTF8String: '>'
+                0x0C, 0x02, 0x5A, 0x3E }, "CN=Z\\>", "CN=\"Z>\"", "cn=z\\>");
+        list.add(new byte[] { 0x30, 0x0D, 0x31, 0x0B, 0x30, 0x09, 0x06, 0x03,
+                0x55, 0x04, 0x03,
+                // UTF8String: ';'
+                0x0C, 0x02, 0x5A, 0x3B }, "CN=Z\\;", "CN=\"Z;\"", "cn=z\\;");
+        list.add(new byte[] { 0x30, 0x0D, 0x31, 0x0B, 0x30, 0x09, 0x06, 0x03,
+                0x55, 0x04, 0x03,
+                // UTF8String: '='
+                0x0C, 0x02, 0x5A, 0x3D }, "CN=Z\\=", "CN=\"Z=\"", "cn=z=");
+        //FIXME        list.add(new byte[] { 0x30, 0x0D, 0x31, 0x0B, 0x30, 0x09, 0x06, 0x03,
+        //                0x55, 0x04, 0x03,
+        //                // UTF8String: ';'
+        //                0x0C, 0x02, 0x5A, 0x0D }, "CN=Z\\\r", "CN=\"Z\r\"", "cn=z");
+
+        // combinations
+        list.add(new byte[] { 0x30, 0x0D, 0x31, 0x0B, 0x30, 0x09, 0x06, 0x03,
+                0x55, 0x04, 0x03,
+                // UTF8String: '\ '
+                0x0C, 0x02, 0x5C, 0x20 }, "CN=\\\\\\ ", "CN=\"\\\\ \"",
+                "cn=\\\\", (byte) 0x02);
+        list.add(new byte[] { 0x30, 0x0D, 0x31, 0x0B, 0x30, 0x09, 0x06, 0x03,
+                0x55, 0x04, 0x03,
+                // UTF8String: ' \'
+                0x0C, 0x02, 0x20, 0x5C }, "CN=\\ \\\\", "CN=\" \\\\\"",
+                "cn=\\\\", (byte) 0x02);
+        list.add(new byte[] { 0x30, 0x0E, 0x31, 0x0C, 0x30, 0x0A, 0x06, 0x03,
+                0x55, 0x04, 0x03,
+                // UTF8String: ' \ '
+                0x0C, 0x03, 0x20, 0x5C, 0x20 }, "CN=\\ \\\\\\ ",
+                "CN=\" \\\\ \"", "cn=\\\\", (byte) 0x02);
+        list.add(new byte[] { 0x30, 0x0E, 0x31, 0x0C, 0x30, 0x0A, 0x06, 0x03,
+                0x55, 0x04, 0x03,
+                // UTF8String: 'Z Z' no escaping
+                0x0C, 0x03, 0x5A, 0x20, 0x5A }, "CN=Z Z", "CN=Z Z", "cn=z z");
+        list.add(new byte[] { 0x30, 0x0F, 0x31, 0x0D, 0x30, 0x0B, 0x06, 0x03,
+                0x55, 0x04, 0x03,
+                // UTF8String: 'Z  Z' no escaping
+                0x0C, 0x04, 0x5A, 0x20, 0x20, 0x5A }, "CN=Z  Z", "CN=Z  Z",
+                "cn=z z", (byte) 0x02);
+        list.add(new byte[] { 0x30, 0x0F, 0x31, 0x0D, 0x30, 0x0B, 0x06, 0x03,
+                0x55, 0x04, 0x03,
+                // UTF8String: ' #Z ' no escaping
+                0x0C, 0x04, 0x20, 0x23, 0x5A, 0x20 }, "CN=\\ \\#Z\\ ",
+                "CN=\" #Z \"", "cn=#z");
+
+        //
+        // Special cases
+        //
+        //        list.add(new byte[] {
+        //        // Name
+        //                0x30, 0x13, 0x31, 0x11, 0x30, 0x0F,
+        //                // OID
+        //                0x06, 0x0A, 0x09, (byte) 0x92, 0x26, (byte) 0x89, (byte) 0x93,
+        //                (byte) 0xF2, 0x2C, 0x64, 0x01, 0x01,
+        //                // ANY
+        //                0x13, 0x01, 0x41 }, "UID=A", "OID.0.9.2342.19200300.100.1.1=A",
+        //                "uid=a");
+        //
+        //        list.add(new byte[] { 0x30, 0x0C, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03,
+        //                0x55, 0x04, 0x03, 0x1E, 0x01, 0x5A }, "CN=Z", "CN=Z",
+        //                "cn=#1e015a");
+
+        //
+        // Multi-valued DN
+        //
+        list.add(new byte[] { 0x30, 0x14, 0x31, 0x12,
+                // 1
+                0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x03,
+                // UTF8String: 'Z'
+                0x0C, 0x01, 0x5A,
+                //2
+                0x30, 0x06, 0x06, 0x01, 0x01,
+                // UTF8String: 'A'
+                0x0C, 0x01, 0x41 }, "CN=Z+0.1=#0c0141", "CN=Z + OID.0.1=A",
+                "cn=z+0.1=#0c0141");
+
+        //
+        //
+        //
+        list.add(new byte[] { 0x30, 0x0D, 0x31, 0x0B, 0x30, 0x09, 0x06, 0x03,
+                0x55, 0x04, 0x03,
+                // UTF8String: the last letter(capital) of Russian alphabet
+                0x0C, 0x02, (byte) 0xD0, (byte) 0xAF }, "CN=" + ((char) 1071),
+                "CN=" + ((char) 1071), "cn=" + ((char) 1103));
+        // FIXME list.add(new byte[] { 0x30, 0x0E, 0x31, 0x0C, 0x30, 0x0A, 0x06, 0x03,
+        //        0x55, 0x04, 0x03,
+        //        // UTF8String: the last letter(capital) of Russian alphabet
+        //        0x0C, 0x03, (byte) 0xE0, (byte) 0x90, (byte) 0xAF }, "CN="
+        //        + ((char) 1071), "CN=" + ((char) 1071), "cn=" + ((char) 1103));
+        // FIXME list.add(
+        //        new byte[] { 0x30, 0x0F, 0x31, 0x0D, 0x30, 0x0B, 0x06, 0x03,
+        //                0x55, 0x04, 0x03,
+        //                // UTF8String: the last letter(capital) of Russian alphabet
+        //                0x0C, 0x04, (byte) 0xF0, (byte) 0x80, (byte) 0x90,
+        //                (byte) 0xAF }, "CN=" + ((char) 1071), "CN="
+        //                + ((char) 1071), "cn=" + ((char) 1103));
+        list.add(new byte[] { 0x30, 0x0C, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03,
+                0x55, 0x04, 0x03,
+                // PrintableString: char '$' is not in table 8 (X.680)
+                0x13, 0x01, 0x24 }, "CN=$", "CN=$", "cn=$");
+
+        StringBuffer errorMsg = new StringBuffer();
+        for (int i = 0; i < list.size(); i++) {
+
+            Object[] values = list.get(i);
+            byte[] encoded = (byte[]) values[0];
+            String rfc2253 = (String) values[1];
+            String rfc1179 = (String) values[2];
+            String canonical = (String) values[3];
+            byte mask = ((byte[]) values[4])[0];
+
+            X500Principal p;
+            try {
+                p = new X500Principal(encoded);
+
+                if (!rfc2253.equals(p.getName(X500Principal.RFC2253))) {
+                    if (!testing || ((mask & 0x01) == 0)) {
+                        errorMsg.append("RFC2253: " + i);
+                        errorMsg.append("\t\texpected: '" + rfc2253 + "'");
+                        errorMsg.append("\treturned: '"
+                                + p.getName(X500Principal.RFC2253) + "'\n");
+                    }
+                }
+
+                if (!rfc1179.equals(p.getName(X500Principal.RFC1779))) {
+                    if (!testing || ((mask & 0x02) == 0)) {
+                        errorMsg.append("RFC1779: " + i);
+                        errorMsg.append("\t\texpected: '" + rfc1179 + "'");
+                        errorMsg.append("\treturned: '"
+                                + p.getName(X500Principal.RFC1779) + "'\n");
+                    }
+                }
+
+                if (!canonical.equals(p.getName(X500Principal.CANONICAL))) {
+                    if (!testing || ((mask & 0x04) == 0)) {
+                        errorMsg.append("CANONICAL: " + i);
+                        errorMsg.append("\t\texpected: " + canonical + "'");
+                        errorMsg.append("\treturned: '"
+                                + p.getName(X500Principal.CANONICAL) + "'\n");
+                    }
+                }
+
+            } catch (IllegalArgumentException e) {
+                errorMsg.append("\nIllegalArgumentException: " + i + ", for "
+                        + rfc2253);
+                continue;
+            } catch (Exception e) {
+                errorMsg.append("Exception: " + i + ", for " + rfc2253);
+                errorMsg.append("\texcep: " + e.getClass().getName() + "\n");
+                continue;
+            }
+
+        }
+
+        if (errorMsg.length() != 0) {
+            fail(errorMsg.toString());
+        }
+    }
+
+    @SuppressWarnings("serial")
+    public static class TestList extends ArrayList<Object[]> {
+        //
+        // TODO comment me
+        //
+        public void add(String param, String rfc2253, String rfc1779) {
+            add(param, rfc2253, rfc1779, (byte[]) null);
+        }
+
+        public void add(String param, String rfc2253, String rfc1779,
+                String canonical) {
+            add(param, rfc2253, rfc1779, canonical, null);
+        }
+
+        public void add(String param, String rfc2253, String rfc1779,
+                byte[] encoded) {
+            add(new Object[] { param, rfc2253, rfc1779, null, encoded,
+                    emptyMask });
+        }
+
+        public void add(String param, String rfc2253, String rfc1779,
+                byte[] encoded, byte mask) {
+            add(new Object[] { param, rfc2253, rfc1779, null, encoded,
+                    new byte[] { mask } });
+        }
+
+        public void add(String param, String rfc2253, String rfc1779,
+                String canonical, byte[] encoded) {
+            add(new Object[] { param, rfc2253, rfc1779, canonical, encoded,
+                    emptyMask });
+        }
+
+        public void add(String param, String rfc2253, String rfc1779,
+                String canonical, byte[] encoded, byte mask) {
+            add(new Object[] { param, rfc2253, rfc1779, canonical, encoded,
+                    new byte[] { mask } });
+        }
+
+        //
+        // TODO comment me
+        //
+
+        private static final byte[] emptyMask = new byte[] { 0x00 };
+
+        public void add(byte[] encoding, String rfc2253, String rfc1779,
+                String canonical) {
+            add(new Object[] { encoding, rfc2253, rfc1779, canonical, emptyMask });
+        }
+
+        public void add(byte[] encoding, String rfc2253, String rfc1779,
+                String canonical, byte mask) {
+            add(new Object[] { encoding, rfc2253, rfc1779, canonical,
+                    new byte[] { mask } });
+        }
+    }
+
+
+    public void testSerializationSelf() throws Exception {
+        SerializationTest.verifySelf(getSerializationData());
+    }
+
+    public void testSerializationGolden() throws Exception {
+        SerializationTest.verifyGolden(this, getSerializationData());
+    }
+
+    private Object[] getSerializationData() {
+        return new Object[] { new X500Principal("CN=A"),
+                new X500Principal("CN=A, C=B"),
+                new X500Principal("CN=A, CN=B + C=C") };
+    }
+}
+
diff --git a/harmony-tests/src/test/resources/serialization/org/apache/harmony/tests/javax/security/auth/DestroyFailedExceptionTest.golden.0.ser b/harmony-tests/src/test/resources/serialization/org/apache/harmony/tests/javax/security/auth/DestroyFailedExceptionTest.golden.0.ser
new file mode 100644
index 0000000..70de6c8
--- /dev/null
+++ b/harmony-tests/src/test/resources/serialization/org/apache/harmony/tests/javax/security/auth/DestroyFailedExceptionTest.golden.0.ser
diff --git a/harmony-tests/src/test/resources/serialization/org/apache/harmony/tests/javax/security/auth/SubjectTest.golden.0.ser b/harmony-tests/src/test/resources/serialization/org/apache/harmony/tests/javax/security/auth/SubjectTest.golden.0.ser
new file mode 100644
index 0000000..05b3098
--- /dev/null
+++ b/harmony-tests/src/test/resources/serialization/org/apache/harmony/tests/javax/security/auth/SubjectTest.golden.0.ser
diff --git a/harmony-tests/src/test/resources/serialization/org/apache/harmony/tests/javax/security/auth/SubjectTest.golden.1.ser b/harmony-tests/src/test/resources/serialization/org/apache/harmony/tests/javax/security/auth/SubjectTest.golden.1.ser
new file mode 100644
index 0000000..82dfd74
--- /dev/null
+++ b/harmony-tests/src/test/resources/serialization/org/apache/harmony/tests/javax/security/auth/SubjectTest.golden.1.ser
diff --git a/harmony-tests/src/test/resources/serialization/org/apache/harmony/tests/javax/security/auth/SubjectTest.golden.2.ser b/harmony-tests/src/test/resources/serialization/org/apache/harmony/tests/javax/security/auth/SubjectTest.golden.2.ser
new file mode 100644
index 0000000..1030381
--- /dev/null
+++ b/harmony-tests/src/test/resources/serialization/org/apache/harmony/tests/javax/security/auth/SubjectTest.golden.2.ser
diff --git a/harmony-tests/src/test/resources/serialization/org/apache/harmony/tests/javax/security/auth/SubjectTest.golden.3.ser b/harmony-tests/src/test/resources/serialization/org/apache/harmony/tests/javax/security/auth/SubjectTest.golden.3.ser
new file mode 100644
index 0000000..a83e565
--- /dev/null
+++ b/harmony-tests/src/test/resources/serialization/org/apache/harmony/tests/javax/security/auth/SubjectTest.golden.3.ser
diff --git a/harmony-tests/src/test/resources/serialization/org/apache/harmony/tests/javax/security/auth/callback/PasswordCallbackTest.golden.0.ser b/harmony-tests/src/test/resources/serialization/org/apache/harmony/tests/javax/security/auth/callback/PasswordCallbackTest.golden.0.ser
new file mode 100644
index 0000000..f1b0320
--- /dev/null
+++ b/harmony-tests/src/test/resources/serialization/org/apache/harmony/tests/javax/security/auth/callback/PasswordCallbackTest.golden.0.ser
diff --git a/harmony-tests/src/test/resources/serialization/org/apache/harmony/tests/javax/security/auth/callback/PasswordCallbackTest.golden.1.ser b/harmony-tests/src/test/resources/serialization/org/apache/harmony/tests/javax/security/auth/callback/PasswordCallbackTest.golden.1.ser
new file mode 100644
index 0000000..ec1350c
--- /dev/null
+++ b/harmony-tests/src/test/resources/serialization/org/apache/harmony/tests/javax/security/auth/callback/PasswordCallbackTest.golden.1.ser
diff --git a/harmony-tests/src/test/resources/serialization/org/apache/harmony/tests/javax/security/auth/login/LoginExceptionTest.golden.0.ser b/harmony-tests/src/test/resources/serialization/org/apache/harmony/tests/javax/security/auth/login/LoginExceptionTest.golden.0.ser
new file mode 100644
index 0000000..c5000c4
--- /dev/null
+++ b/harmony-tests/src/test/resources/serialization/org/apache/harmony/tests/javax/security/auth/login/LoginExceptionTest.golden.0.ser
diff --git a/harmony-tests/src/test/resources/serialization/org/apache/harmony/tests/javax/security/auth/x500/X500PrincipalTest.golden.0.ser b/harmony-tests/src/test/resources/serialization/org/apache/harmony/tests/javax/security/auth/x500/X500PrincipalTest.golden.0.ser
new file mode 100644
index 0000000..6d81da2
--- /dev/null
+++ b/harmony-tests/src/test/resources/serialization/org/apache/harmony/tests/javax/security/auth/x500/X500PrincipalTest.golden.0.ser
diff --git a/harmony-tests/src/test/resources/serialization/org/apache/harmony/tests/javax/security/auth/x500/X500PrincipalTest.golden.1.ser b/harmony-tests/src/test/resources/serialization/org/apache/harmony/tests/javax/security/auth/x500/X500PrincipalTest.golden.1.ser
new file mode 100644
index 0000000..c209895
--- /dev/null
+++ b/harmony-tests/src/test/resources/serialization/org/apache/harmony/tests/javax/security/auth/x500/X500PrincipalTest.golden.1.ser
diff --git a/harmony-tests/src/test/resources/serialization/org/apache/harmony/tests/javax/security/auth/x500/X500PrincipalTest.golden.2.ser b/harmony-tests/src/test/resources/serialization/org/apache/harmony/tests/javax/security/auth/x500/X500PrincipalTest.golden.2.ser
new file mode 100644
index 0000000..426a364
--- /dev/null
+++ b/harmony-tests/src/test/resources/serialization/org/apache/harmony/tests/javax/security/auth/x500/X500PrincipalTest.golden.2.ser
diff --git a/harmony-tests/src/test/resources/tests/resources/X500PrincipalTest.0.dat b/harmony-tests/src/test/resources/tests/resources/X500PrincipalTest.0.dat
new file mode 100644
index 0000000..5a10bf9
--- /dev/null
+++ b/harmony-tests/src/test/resources/tests/resources/X500PrincipalTest.0.dat
@@ -0,0 +1,5 @@
+001
+0U
B1
+0U
A1
+0U
B1
+0U
A

\ No newline at end of file
diff --git a/harmony-tests/src/test/resources/tests/resources/X500PrincipalTest.1.dat b/harmony-tests/src/test/resources/tests/resources/X500PrincipalTest.1.dat
new file mode 100644
index 0000000..2606b98
--- /dev/null
+++ b/harmony-tests/src/test/resources/tests/resources/X500PrincipalTest.1.dat
@@ -0,0 +1,5 @@
+001
+0U
B1
+0U
A1
+0U
B1
+0U
A
\ No newline at end of file