directory-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From elecha...@apache.org
Subject svn commit: r807786 [2/2] - in /directory/shared/branches/shared-schema/ldap/src: main/antlr/ main/java/org/apache/directory/shared/ldap/schema/ main/java/org/apache/directory/shared/ldap/schema/parsers/ main/java/org/apache/directory/shared/ldap/schem...
Date Tue, 25 Aug 2009 20:00:34 GMT
Modified: directory/shared/branches/shared-schema/ldap/src/test/java/org/apache/directory/shared/ldap/schema/syntax/parser/AttributeTypeDescriptionSchemaParserTest.java
URL: http://svn.apache.org/viewvc/directory/shared/branches/shared-schema/ldap/src/test/java/org/apache/directory/shared/ldap/schema/syntax/parser/AttributeTypeDescriptionSchemaParserTest.java?rev=807786&r1=807785&r2=807786&view=diff
==============================================================================
--- directory/shared/branches/shared-schema/ldap/src/test/java/org/apache/directory/shared/ldap/schema/syntax/parser/AttributeTypeDescriptionSchemaParserTest.java
(original)
+++ directory/shared/branches/shared-schema/ldap/src/test/java/org/apache/directory/shared/ldap/schema/syntax/parser/AttributeTypeDescriptionSchemaParserTest.java
Tue Aug 25 20:00:33 2009
@@ -24,7 +24,7 @@
 
 import org.apache.directory.shared.ldap.schema.UsageEnum;
 import org.apache.directory.shared.ldap.schema.parser.ConsoleParserMonitor;
-import org.apache.directory.shared.ldap.schema.parsers.AttributeTypeDescription;
+import org.apache.directory.shared.ldap.schema.AttributeType;
 import org.apache.directory.shared.ldap.schema.parsers.AttributeTypeDescriptionSchemaParser;
 import org.junit.After;
 import org.junit.Before;
@@ -120,48 +120,48 @@
     public void testSuperType() throws ParseException
     {
         String value = null;
-        AttributeTypeDescription atd = null;
+        AttributeType attributeType = null;
 
         // no SUP
         value = "( 1.1 SYNTAX 1.1 )";
-        atd = parser.parseAttributeTypeDescription( value );
-        assertNull( atd.getSuperType() );
+        attributeType = parser.parseAttributeTypeDescription( value );
+        assertNull( attributeType.getSupOid() );
 
         // SUP numericoid
         value = "( 1.1 SYNTAX 1.1 SUP 1.2.3.4.5.6.7.8.9.0 )";
-        atd = parser.parseAttributeTypeDescription( value );
-        assertEquals( "1.2.3.4.5.6.7.8.9.0", atd.getSuperType() );
+        attributeType = parser.parseAttributeTypeDescription( value );
+        assertEquals( "1.2.3.4.5.6.7.8.9.0", attributeType.getSupOid() );
 
         // SUP descr, no space
         value = "(1.1 SYNTAX1.1 SUPabcdefghijklmnopqrstuvwxyz-ABCDEFGHIJKLMNOPQRSTUVWXYZ-0123456789)";
-        atd = parser.parseAttributeTypeDescription( value );
-        assertEquals( "abcdefghijklmnopqrstuvwxyz-ABCDEFGHIJKLMNOPQRSTUVWXYZ-0123456789",
atd.getSuperType() );
+        attributeType = parser.parseAttributeTypeDescription( value );
+        assertEquals( "abcdefghijklmnopqrstuvwxyz-ABCDEFGHIJKLMNOPQRSTUVWXYZ-0123456789",
attributeType.getSupOid() );
 
         // SUP descr, newline
         value = "\t(\t1.1\tSYNTAX\t1.1\tSUP\tabcdefghijklmnopqrstuvwxyz-ABCDEFGHIJKLMNOPQRSTUVWXYZ-0123456789\t)\t";
-        atd = parser.parseAttributeTypeDescription( value );
-        assertEquals( "abcdefghijklmnopqrstuvwxyz-ABCDEFGHIJKLMNOPQRSTUVWXYZ-0123456789",
atd.getSuperType() );
+        attributeType = parser.parseAttributeTypeDescription( value );
+        assertEquals( "abcdefghijklmnopqrstuvwxyz-ABCDEFGHIJKLMNOPQRSTUVWXYZ-0123456789",
attributeType.getSupOid() );
 
         // quoted SUP value
         value = "( 1.1 SYNTAX 1.1 SUP 'name' )";
-        atd = parser.parseAttributeTypeDescription( value );
-        assertEquals( "name", atd.getSuperType() );
+        attributeType = parser.parseAttributeTypeDescription( value );
+        assertEquals( "name", attributeType.getSupOid() );
 
         // quoted SUP value
         value = "( 1.1 SYNTAX 1.1 SUP '1.2.3.4' )";
-        atd = parser.parseAttributeTypeDescription( value );
-        assertEquals( "1.2.3.4", atd.getSuperType() );
+        attributeType = parser.parseAttributeTypeDescription( value );
+        assertEquals( "1.2.3.4", attributeType.getSupOid() );
 
         // quoted SUP value
         value = "( 1.1 SYNTAX 1.1 SUP ('1.2.3.4') )";
-        atd = parser.parseAttributeTypeDescription( value );
-        assertEquals( "1.2.3.4", atd.getSuperType() );
+        attributeType = parser.parseAttributeTypeDescription( value );
+        assertEquals( "1.2.3.4", attributeType.getSupOid() );
 
         // invalid character
         value = "( 1.1 SYNTAX 1.1 SUP 1.2.3.4.A )";
         try
         {
-            atd = parser.parseAttributeTypeDescription( value );
+            attributeType = parser.parseAttributeTypeDescription( value );
             fail( "Exception expected, invalid SUP '1.2.3.4.A' (invalid character)" );
         }
         catch ( ParseException pe )
@@ -173,7 +173,7 @@
         value = "( 1.1 SYNTAX 1.1 SUP ( name1 $ name2 ) )";
         try
         {
-            atd = parser.parseAttributeTypeDescription( value );
+            attributeType = parser.parseAttributeTypeDescription( value );
             fail( "Exception expected, only single SUP allowed" );
         }
         catch ( ParseException pe )
@@ -185,7 +185,7 @@
         value = "( 1.1 SYNTAX 1.1 SUP )";
         try
         {
-            atd = parser.parseAttributeTypeDescription( value );
+            attributeType = parser.parseAttributeTypeDescription( value );
             fail( "Exception expected, no SUP value" );
         }
         catch ( ParseException pe )
@@ -205,37 +205,37 @@
     public void testEquality() throws ParseException
     {
         String value = null;
-        AttributeTypeDescription atd = null;
+        AttributeType attributeType = null;
 
         // no EQUALITY
         value = "( 1.1 SYNTAX 1.1 )";
-        atd = parser.parseAttributeTypeDescription( value );
-        assertNull( atd.getEqualityMatchingRule() );
+        attributeType = parser.parseAttributeTypeDescription( value );
+        assertNull( attributeType.getEqualityOid() );
 
         // EQUALITY numericoid
         value = "( 1.1 SYNTAX 1.1 EQUALITY 1.2.3.4567.8.9.0 )";
-        atd = parser.parseAttributeTypeDescription( value );
-        assertEquals( "1.2.3.4567.8.9.0", atd.getEqualityMatchingRule() );
+        attributeType = parser.parseAttributeTypeDescription( value );
+        assertEquals( "1.2.3.4567.8.9.0", attributeType.getEqualityOid() );
 
         // EQUALITY descr, no space
         value = "(1.1 SYNTAX1.1 EQUALITYabcdefghijklmnopqrstuvwxyz-ABCDEFGHIJKLMNOPQRSTUVWXYZ-0123456789)";
-        atd = parser.parseAttributeTypeDescription( value );
-        assertEquals( "abcdefghijklmnopqrstuvwxyz-ABCDEFGHIJKLMNOPQRSTUVWXYZ-0123456789",
atd.getEqualityMatchingRule() );
+        attributeType = parser.parseAttributeTypeDescription( value );
+        assertEquals( "abcdefghijklmnopqrstuvwxyz-ABCDEFGHIJKLMNOPQRSTUVWXYZ-0123456789",
attributeType.getEqualityOid() );
 
         // EQUALITY descr, newline
         value = "\n(\n1.1\nSYNTAX\n1.1\nEQUALITY\nabcdefghijklmnopqrstuvwxyz-ABCDEFGHIJKLMNOPQRSTUVWXYZ-0123456789\n)\n";
-        atd = parser.parseAttributeTypeDescription( value );
-        assertEquals( "abcdefghijklmnopqrstuvwxyz-ABCDEFGHIJKLMNOPQRSTUVWXYZ-0123456789",
atd.getEqualityMatchingRule() );
+        attributeType = parser.parseAttributeTypeDescription( value );
+        assertEquals( "abcdefghijklmnopqrstuvwxyz-ABCDEFGHIJKLMNOPQRSTUVWXYZ-0123456789",
attributeType.getEqualityOid() );
 
         // quoted value
         value = "( 1.1 SYNTAX 1.1 EQUALITY 'caseExcactMatch' )";
-        atd = parser.parseAttributeTypeDescription( value );
-        assertEquals( "caseExcactMatch", atd.getEqualityMatchingRule() );
+        attributeType = parser.parseAttributeTypeDescription( value );
+        assertEquals( "caseExcactMatch", attributeType.getEqualityOid() );
 
         // quote value in parentheses 
         value = "( 1.1 SYNTAX 1.1 EQUALITY ('caseExcactMatch') )";
-        atd = parser.parseAttributeTypeDescription( value );
-        assertEquals( "caseExcactMatch", atd.getEqualityMatchingRule() );
+        attributeType = parser.parseAttributeTypeDescription( value );
+        assertEquals( "caseExcactMatch", attributeType.getEqualityOid() );
     }
 
 
@@ -249,37 +249,37 @@
     public void testOrdering() throws ParseException
     {
         String value = null;
-        AttributeTypeDescription atd = null;
+        AttributeType attributeType = null;
 
         // no ORDERING
         value = "( 1.1 SYNTAX 1.1 )";
-        atd = parser.parseAttributeTypeDescription( value );
-        assertNull( atd.getOrderingMatchingRule() );
+        attributeType = parser.parseAttributeTypeDescription( value );
+        assertNull( attributeType.getOrderingOid() );
 
         // ORDERING numericoid
         value = "( 1.1 SYNTAX 1.1 ORDERING 1.2.3.4567.8.9.0 )";
-        atd = parser.parseAttributeTypeDescription( value );
-        assertEquals( "1.2.3.4567.8.9.0", atd.getOrderingMatchingRule() );
+        attributeType = parser.parseAttributeTypeDescription( value );
+        assertEquals( "1.2.3.4567.8.9.0", attributeType.getOrderingOid() );
 
         // ORDERING descr, no space
         value = "(1.1 SYNTAX1.1 ORDERINGabcdefghijklmnopqrstuvwxyz-ABCDEFGHIJKLMNOPQRSTUVWXYZ-0123456789)";
-        atd = parser.parseAttributeTypeDescription( value );
-        assertEquals( "abcdefghijklmnopqrstuvwxyz-ABCDEFGHIJKLMNOPQRSTUVWXYZ-0123456789",
atd.getOrderingMatchingRule() );
+        attributeType = parser.parseAttributeTypeDescription( value );
+        assertEquals( "abcdefghijklmnopqrstuvwxyz-ABCDEFGHIJKLMNOPQRSTUVWXYZ-0123456789",
attributeType.getOrderingOid() );
 
         // ORDERING descr, newline
         value = "\r(\r1.1\rSYNTAX\r1.1\rORDERING\rabcdefghijklmnopqrstuvwxyz-ABCDEFGHIJKLMNOPQRSTUVWXYZ-0123456789\r)\r";
-        atd = parser.parseAttributeTypeDescription( value );
-        assertEquals( "abcdefghijklmnopqrstuvwxyz-ABCDEFGHIJKLMNOPQRSTUVWXYZ-0123456789",
atd.getOrderingMatchingRule() );
+        attributeType = parser.parseAttributeTypeDescription( value );
+        assertEquals( "abcdefghijklmnopqrstuvwxyz-ABCDEFGHIJKLMNOPQRSTUVWXYZ-0123456789",
attributeType.getOrderingOid() );
 
         // quoted value
         value = "( 1.1 SYNTAX 1.1 ORDERING 'generalizedTimeOrderingMatch' )";
-        atd = parser.parseAttributeTypeDescription( value );
-        assertEquals( "generalizedTimeOrderingMatch", atd.getOrderingMatchingRule() );
+        attributeType = parser.parseAttributeTypeDescription( value );
+        assertEquals( "generalizedTimeOrderingMatch", attributeType.getOrderingOid() );
 
         // quote value in parentheses
         value = "( 1.1 SYNTAX 1.1 ORDERING ('generalizedTimeOrderingMatch') )";
-        atd = parser.parseAttributeTypeDescription( value );
-        assertEquals( "generalizedTimeOrderingMatch", atd.getOrderingMatchingRule() );
+        attributeType = parser.parseAttributeTypeDescription( value );
+        assertEquals( "generalizedTimeOrderingMatch", attributeType.getOrderingOid() );
     }
 
 
@@ -293,39 +293,39 @@
     public void testSubstring() throws ParseException
     {
         String value = null;
-        AttributeTypeDescription atd = null;
+        AttributeType attributeType = null;
 
         // no SUBSTR
         value = "( 1.1 SYNTAX 1.1 )";
-        atd = parser.parseAttributeTypeDescription( value );
-        assertNull( atd.getSubstringsMatchingRule() );
+        attributeType = parser.parseAttributeTypeDescription( value );
+        assertNull( attributeType.getSubstrOid() );
 
         // SUBSTR numericoid
         value = "( 1.1 SYNTAX 1.1 SUBSTR 1.2.3.4567.8.9.0 )";
-        atd = parser.parseAttributeTypeDescription( value );
-        assertEquals( "1.2.3.4567.8.9.0", atd.getSubstringsMatchingRule() );
+        attributeType = parser.parseAttributeTypeDescription( value );
+        assertEquals( "1.2.3.4567.8.9.0", attributeType.getSubstrOid() );
 
         // SUBSTR descr, no space
         value = "(1.1 SYNTAX1.1 SUBSTRabcdefghijklmnopqrstuvwxyz-ABCDEFGHIJKLMNOPQRSTUVWXYZ-0123456789)";
-        atd = parser.parseAttributeTypeDescription( value );
-        assertEquals( "abcdefghijklmnopqrstuvwxyz-ABCDEFGHIJKLMNOPQRSTUVWXYZ-0123456789",
atd
-            .getSubstringsMatchingRule() );
+        attributeType = parser.parseAttributeTypeDescription( value );
+        assertEquals( "abcdefghijklmnopqrstuvwxyz-ABCDEFGHIJKLMNOPQRSTUVWXYZ-0123456789",
attributeType
+            .getSubstrOid() );
 
         // SUBSTR descr, newline
         value = "\r\n(\r\n1.1\r\nSYNTAX\r\n1.1\r\nSUBSTR\r\nabcdefghijklmnopqrstuvwxyz-ABCDEFGHIJKLMNOPQRSTUVWXYZ-0123456789\r\n)\r\n";
-        atd = parser.parseAttributeTypeDescription( value );
-        assertEquals( "abcdefghijklmnopqrstuvwxyz-ABCDEFGHIJKLMNOPQRSTUVWXYZ-0123456789",
atd
-            .getSubstringsMatchingRule() );
+        attributeType = parser.parseAttributeTypeDescription( value );
+        assertEquals( "abcdefghijklmnopqrstuvwxyz-ABCDEFGHIJKLMNOPQRSTUVWXYZ-0123456789",
attributeType
+            .getSubstrOid() );
 
         // quoted value
         value = "( 1.1 SYNTAX 1.1 SUBSTR 'caseIgnoreSubstringsMatch' )";
-        atd = parser.parseAttributeTypeDescription( value );
-        assertEquals( "caseIgnoreSubstringsMatch", atd.getSubstringsMatchingRule() );
+        attributeType = parser.parseAttributeTypeDescription( value );
+        assertEquals( "caseIgnoreSubstringsMatch", attributeType.getSubstrOid() );
 
         // quote value in parentheses
         value = "( 1.1 SYNTAX 1.1 SUBSTR ('caseIgnoreSubstringsMatch') )";
-        atd = parser.parseAttributeTypeDescription( value );
-        assertEquals( "caseIgnoreSubstringsMatch", atd.getSubstringsMatchingRule() );
+        attributeType = parser.parseAttributeTypeDescription( value );
+        assertEquals( "caseIgnoreSubstringsMatch", attributeType.getSubstrOid() );
     }
 
 
@@ -338,73 +338,73 @@
     public void testSyntax() throws ParseException
     {
         String value = null;
-        AttributeTypeDescription atd = null;
+        AttributeType attributeType = null;
 
         // no SYNTAX
         value = "( 1.1 SUP 1.1 )";
-        atd = parser.parseAttributeTypeDescription( value );
-        assertNull( atd.getSyntax() );
-        assertEquals( 0, atd.getSyntaxLength() );
+        attributeType = parser.parseAttributeTypeDescription( value );
+        assertNull( attributeType.getSyntaxOid() );
+        assertEquals( 0, attributeType.getLength() );
 
         // SYNTAX string
         value = "( 1.1 SYNTAX IA5String )";
-        atd = parser.parseAttributeTypeDescription( value );
-        assertEquals( "IA5String", atd.getSyntax() );
-        assertEquals( 0, atd.getSyntaxLength() );
+        attributeType = parser.parseAttributeTypeDescription( value );
+        assertEquals( "IA5String", attributeType.getSyntaxOid() );
+        assertEquals( 0, attributeType.getLength() );
 
         // SYNTAX numericoid
         value = "( 1.1 SYNTAX 1.2.3.4567.8.9.0 )";
-        atd = parser.parseAttributeTypeDescription( value );
-        assertEquals( "1.2.3.4567.8.9.0", atd.getSyntax() );
-        assertEquals( 0, atd.getSyntaxLength() );
+        attributeType = parser.parseAttributeTypeDescription( value );
+        assertEquals( "1.2.3.4567.8.9.0", attributeType.getSyntaxOid() );
+        assertEquals( 0, attributeType.getLength() );
         
         // quoted numericoid
         value = "( 1.1 SYNTAX '1.2.3.4567.8.9.0' )";
-        atd = parser.parseAttributeTypeDescription( value );
-        assertEquals( "1.2.3.4567.8.9.0", atd.getSyntax() );
-        assertEquals( 0, atd.getSyntaxLength() );
+        attributeType = parser.parseAttributeTypeDescription( value );
+        assertEquals( "1.2.3.4567.8.9.0", attributeType.getSyntaxOid() );
+        assertEquals( 0, attributeType.getLength() );
 
         // quoted numericoid
         value = "( 1.1 SYNTAX ('1.2.3.4567.8.9.0') )";
-        atd = parser.parseAttributeTypeDescription( value );
-        assertEquals( "1.2.3.4567.8.9.0", atd.getSyntax() );
-        assertEquals( 0, atd.getSyntaxLength() );
+        attributeType = parser.parseAttributeTypeDescription( value );
+        assertEquals( "1.2.3.4567.8.9.0", attributeType.getSyntaxOid() );
+        assertEquals( 0, attributeType.getLength() );
 
         // SYNTAX numericoid and length, no spaces
         value = "(1.1 SYNTAX1.2.3.4567.8.9.0{1234567890})";
-        atd = parser.parseAttributeTypeDescription( value );
-        assertEquals( "1.2.3.4567.8.9.0", atd.getSyntax() );
-        assertEquals( 1234567890, atd.getSyntaxLength() );
+        attributeType = parser.parseAttributeTypeDescription( value );
+        assertEquals( "1.2.3.4567.8.9.0", attributeType.getSyntaxOid() );
+        assertEquals( 1234567890, attributeType.getLength() );
 
         // SYNTAX, with tabs
         value = "\t(\t1.1\tSYNTAX\t1.2.3.4567.8.9.0\t{1234567890}\t)\t";
-        atd = parser.parseAttributeTypeDescription( value );
-        assertEquals( "1.2.3.4567.8.9.0", atd.getSyntax() );
-        assertEquals( 1234567890, atd.getSyntaxLength() );
+        attributeType = parser.parseAttributeTypeDescription( value );
+        assertEquals( "1.2.3.4567.8.9.0", attributeType.getSyntaxOid() );
+        assertEquals( 1234567890, attributeType.getLength() );
 
         // SYNTAX numericoid and zero length
         value = "( 1.1 SYNTAX 1.2.3 {0} )";
-        atd = parser.parseAttributeTypeDescription( value );
-        assertEquals( "1.2.3", atd.getSyntax() );
-        assertEquals( 0, atd.getSyntaxLength() );
+        attributeType = parser.parseAttributeTypeDescription( value );
+        assertEquals( "1.2.3", attributeType.getSyntaxOid() );
+        assertEquals( 0, attributeType.getLength() );
 
         // quoted value
         value = "( 1.1 SYNTAX '1.2.3{32}' )";
-        atd = parser.parseAttributeTypeDescription( value );
-        assertEquals( "1.2.3", atd.getSyntax() );
-        assertEquals( 32, atd.getSyntaxLength() );
+        attributeType = parser.parseAttributeTypeDescription( value );
+        assertEquals( "1.2.3", attributeType.getSyntaxOid() );
+        assertEquals( 32, attributeType.getLength() );
 
         // quote value in parentheses
         value = "( 1.1 SYNTAX ( '1.2.3{32}' ) )";
-        atd = parser.parseAttributeTypeDescription( value );
-        assertEquals( "1.2.3", atd.getSyntax() );
-        assertEquals( 32, atd.getSyntaxLength() );
+        attributeType = parser.parseAttributeTypeDescription( value );
+        assertEquals( "1.2.3", attributeType.getSyntaxOid() );
+        assertEquals( 32, attributeType.getLength() );
 
         // empty length
         value = "( 1.1 SYNTAX 1.2.3.4{} )";
         try
         {
-            atd = parser.parseAttributeTypeDescription( value );
+            attributeType = parser.parseAttributeTypeDescription( value );
             fail( "Exception expected, invalid SYNTAX 1.2.3.4{} (empty length)" );
         }
         catch ( ParseException pe )
@@ -414,15 +414,15 @@
 
         // leading zero in length
         value = "( 1.1 SYNTAX 1.2.3.4{01} )";
-        atd = parser.parseAttributeTypeDescription( value );
-        assertEquals( "1.2.3.4", atd.getSyntax() );
-        assertEquals( 1, atd.getSyntaxLength() );
+        attributeType = parser.parseAttributeTypeDescription( value );
+        assertEquals( "1.2.3.4", attributeType.getSyntaxOid() );
+        assertEquals( 1, attributeType.getLength() );
 
         // invalid syntax length
         value = "( 1.1 SYNTAX 1.2.3.4{X} )";
         try
         {
-            atd = parser.parseAttributeTypeDescription( value );
+            attributeType = parser.parseAttributeTypeDescription( value );
             fail( "Exception expected, invalid SYNTAX 1.2.3.4{X} (invalid length)" );
         }
         catch ( ParseException pe )
@@ -434,7 +434,7 @@
         value = "( 1.1 SYNTAX {32} )";
         try
         {
-            atd = parser.parseAttributeTypeDescription( value );
+            attributeType = parser.parseAttributeTypeDescription( value );
             fail( "Exception expected, invalid SYNTAX {32} (no syntax)" );
         }
         catch ( ParseException pe )
@@ -446,7 +446,7 @@
         value = "( 1.1 SYNTAX 1.2.3.4{123456789012} )";
         try
         {
-            atd = parser.parseAttributeTypeDescription( value );
+            attributeType = parser.parseAttributeTypeDescription( value );
             fail( "Exception expected, invalid SYNTAX 1.2.3.4{123456789012} (length overflow)"
);
         }
         catch ( NumberFormatException nfe )
@@ -466,28 +466,28 @@
     public void testSingleValue() throws ParseException
     {
         String value = null;
-        AttributeTypeDescription atd = null;
+        AttributeType attributeType = null;
 
         // not single-value
         value = "( 1.1 SYNTAX 1.1 NAME 'test' DESC 'Descripton' )";
-        atd = parser.parseAttributeTypeDescription( value );
-        assertFalse( atd.isSingleValued() );
+        attributeType = parser.parseAttributeTypeDescription( value );
+        assertFalse( attributeType.isSingleValue() );
 
         // single-value
         value = "(1.1 SYNTAX 1.1 NAME 'test' DESC 'Descripton' SINGLE-VALUE)";
-        atd = parser.parseAttributeTypeDescription( value );
-        assertTrue( atd.isSingleValued() );
+        attributeType = parser.parseAttributeTypeDescription( value );
+        assertTrue( attributeType.isSingleValue() );
 
         // single-value 
         value = "(1.1 SYNTAX 1.1 SINGLE-VALUE)";
-        atd = parser.parseAttributeTypeDescription( value );
-        assertTrue( atd.isSingleValued() );
+        attributeType = parser.parseAttributeTypeDescription( value );
+        assertTrue( attributeType.isSingleValue() );
 
         // invalid
         value = "(1.1 SYNTAX 1.1 NAME 'test' DESC 'Descripton' SINGLE-VALU )";
         try
         {
-            atd = parser.parseAttributeTypeDescription( value );
+            attributeType = parser.parseAttributeTypeDescription( value );
             fail( "Exception expected, invalid SINGLE-VALUE value" );
         }
         catch ( ParseException pe )
@@ -506,28 +506,28 @@
     public void testCollective() throws ParseException
     {
         String value = null;
-        AttributeTypeDescription atd = null;
+        AttributeType attributeType = null;
 
         // not collective
         value = "( 1.1 SYNTAX 1.1 NAME 'test' DESC 'Descripton' )";
-        atd = parser.parseAttributeTypeDescription( value );
-        assertFalse( atd.isCollective() );
+        attributeType = parser.parseAttributeTypeDescription( value );
+        assertFalse( attributeType.isCollective() );
 
         // single-value
         value = "(1.1 SYNTAX 1.1 NAME 'test' DESC 'Descripton' COLLECTIVE )";
-        atd = parser.parseAttributeTypeDescription( value );
-        assertTrue( atd.isCollective() );
+        attributeType = parser.parseAttributeTypeDescription( value );
+        assertTrue( attributeType.isCollective() );
 
         // single-value 
         value = "(1.1 SYNTAX 1.1 COLLECTIVE)";
-        atd = parser.parseAttributeTypeDescription( value );
-        assertTrue( atd.isCollective() );
+        attributeType = parser.parseAttributeTypeDescription( value );
+        assertTrue( attributeType.isCollective() );
 
         // ivalid
         value = "(1.1 SYNTAX 1.1 NAME 'test' DESC 'Descripton' COLLECTIV )";
         try
         {
-            atd = parser.parseAttributeTypeDescription( value );
+            attributeType = parser.parseAttributeTypeDescription( value );
             fail( "Exception expected, invalid COLLECTIVE value" );
         }
         catch ( ParseException pe )
@@ -546,28 +546,28 @@
     public void testNoUserModification() throws ParseException
     {
         String value = null;
-        AttributeTypeDescription atd = null;
+        AttributeType attributeType = null;
 
         // not NO-USER-MODIFICATION
         value = "( 1.1 SYNTAX 1.1 NAME 'test' DESC 'Descripton' )";
-        atd = parser.parseAttributeTypeDescription( value );
-        assertTrue( atd.isUserModifiable() );
+        attributeType = parser.parseAttributeTypeDescription( value );
+        assertTrue( attributeType.isCanUserModify() );
 
         // NO-USER-MODIFICATION
         value = "(1.1 SYNTAX 1.1 NAME 'test' DESC 'Descripton' NO-USER-MODIFICATION USAGE
directoryOperation )";
-        atd = parser.parseAttributeTypeDescription( value );
-        assertFalse( atd.isUserModifiable() );
+        attributeType = parser.parseAttributeTypeDescription( value );
+        assertFalse( attributeType.isCanUserModify() );
 
         // NO-USER-MODIFICATION 
         value = "(1.1 SYNTAX 1.1 NO-USER-MODIFICATION USAGE directoryOperation )";
-        atd = parser.parseAttributeTypeDescription( value );
-        assertFalse( atd.isUserModifiable() );
+        attributeType = parser.parseAttributeTypeDescription( value );
+        assertFalse( attributeType.isCanUserModify() );
 
         // ivalid
         value = "(1.1 SYNTAX 1.1 NAME 'test' DESC 'Descripton' NO-USER-MODIFICATIO USAGE
directoryOperation )";
         try
         {
-            atd = parser.parseAttributeTypeDescription( value );
+            attributeType = parser.parseAttributeTypeDescription( value );
             fail( "Exception expected, invalid NO-USER-MODIFICATION value" );
         }
         catch ( ParseException pe )
@@ -586,43 +586,43 @@
     public void testUsage() throws ParseException
     {
         String value = null;
-        AttributeTypeDescription atd = null;
+        AttributeType attributeType = null;
 
         // DEFAULT is userApplications
         value = "( 1.1 SYNTAX 1.1 )";
-        atd = parser.parseAttributeTypeDescription( value );
-        assertEquals( UsageEnum.USER_APPLICATIONS, atd.getUsage() );
+        attributeType = parser.parseAttributeTypeDescription( value );
+        assertEquals( UsageEnum.USER_APPLICATIONS, attributeType.getUsage() );
 
         // userApplications
         value = "( 1.1 SYNTAX 1.1 USAGE userApplications )";
-        atd = parser.parseAttributeTypeDescription( value );
-        assertEquals( UsageEnum.USER_APPLICATIONS, atd.getUsage() );
+        attributeType = parser.parseAttributeTypeDescription( value );
+        assertEquals( UsageEnum.USER_APPLICATIONS, attributeType.getUsage() );
 
         // directoryOperation
         value = "( 1.1 SYNTAX 1.1 USAGE directoryOperation )";
-        atd = parser.parseAttributeTypeDescription( value );
-        assertEquals( UsageEnum.DIRECTORY_OPERATION, atd.getUsage() );
+        attributeType = parser.parseAttributeTypeDescription( value );
+        assertEquals( UsageEnum.DIRECTORY_OPERATION, attributeType.getUsage() );
 
         // distributedOperation, tabs
         value = "\t(\t1.1\tSYNTAX\t1.1\tUSAGE\tdistributedOperation\t)\t";
-        atd = parser.parseAttributeTypeDescription( value );
-        assertEquals( UsageEnum.DISTRIBUTED_OPERATION, atd.getUsage() );
+        attributeType = parser.parseAttributeTypeDescription( value );
+        assertEquals( UsageEnum.DISTRIBUTED_OPERATION, attributeType.getUsage() );
 
         // dSAOperation, no space
         value = "(1.1 SYNTAX1.1 USAGEdSAOperation)";
-        atd = parser.parseAttributeTypeDescription( value );
-        assertEquals( UsageEnum.DSA_OPERATION, atd.getUsage() );
+        attributeType = parser.parseAttributeTypeDescription( value );
+        assertEquals( UsageEnum.DSA_OPERATION, attributeType.getUsage() );
 
         // directoryOperation, case insensitivity
         value = "( 1.1 SYNTAX 1.1 USAGE DiReCtOrYoPeRaTiOn )";
-        atd = parser.parseAttributeTypeDescription( value );
-        assertEquals( UsageEnum.DIRECTORY_OPERATION, atd.getUsage() );
+        attributeType = parser.parseAttributeTypeDescription( value );
+        assertEquals( UsageEnum.DIRECTORY_OPERATION, attributeType.getUsage() );
 
         // ivalid
         value = "( 1.1 SYNTAX 1.1 USAGE abc )";
         try
         {
-            atd = parser.parseAttributeTypeDescription( value );
+            attributeType = parser.parseAttributeTypeDescription( value );
             fail( "Exception expected, invalid USAGE value" );
         }
         catch ( ParseException pe )
@@ -653,38 +653,38 @@
     public void testFull() throws ParseException
     {
         String value = null;
-        AttributeTypeDescription atd = null;
+        AttributeType attributeType = null;
 
         value = "( 1.2.3.4.5.6.7.8.9.0 NAME ( 'abcdefghijklmnopqrstuvwxyz-ABCDEFGHIJKLMNOPQRSTUVWXYZ-0123456789'
'test' ) DESC 'Descripton \u00E4\u00F6\u00FC\u00DF \u90E8\u9577' OBSOLETE SUP abcdefghijklmnopqrstuvwxyz-ABCDEFGHIJKLMNOPQRSTUVWXYZ-0123456789
EQUALITY 2.3.4.5.6.7.8.9.0.1 ORDERING 3.4.5.6.7.8.9.0.1.2 SUBSTR 4.5.6.7.8.9.0.1.2.3 SYNTAX
5.6.7.8.9.0.1.2.3.4{1234567890} SINGLE-VALUE NO-USER-MODIFICATION USAGE dSAOperation X-TEST-a
('test1-1' 'test1-2') X-TEST-b ('test2-1' 'test2-2') )";
-        atd = parser.parseAttributeTypeDescription( value );
+        attributeType = parser.parseAttributeTypeDescription( value );
 
-        assertEquals( "1.2.3.4.5.6.7.8.9.0", atd.getNumericOid() );
-        assertEquals( 2, atd.getNames().size() );
-        assertEquals( "abcdefghijklmnopqrstuvwxyz-ABCDEFGHIJKLMNOPQRSTUVWXYZ-0123456789",
atd.getNames().get( 0 ) );
-        assertEquals( "test", atd.getNames().get( 1 ) );
-        assertEquals( "Descripton \u00E4\u00F6\u00FC\u00DF \u90E8\u9577", atd.getDescription()
);
-        assertTrue( atd.isObsolete() );
-        assertEquals( "abcdefghijklmnopqrstuvwxyz-ABCDEFGHIJKLMNOPQRSTUVWXYZ-0123456789",
atd.getSuperType() );
-        assertEquals( "2.3.4.5.6.7.8.9.0.1", atd.getEqualityMatchingRule() );
-        assertEquals( "3.4.5.6.7.8.9.0.1.2", atd.getOrderingMatchingRule() );
-        assertEquals( "4.5.6.7.8.9.0.1.2.3", atd.getSubstringsMatchingRule() );
-        assertEquals( "5.6.7.8.9.0.1.2.3.4", atd.getSyntax() );
-        assertEquals( 1234567890, atd.getSyntaxLength() );
-
-        assertTrue( atd.isSingleValued() );
-        assertFalse( atd.isCollective() );
-        assertFalse( atd.isUserModifiable() );
-        assertEquals( UsageEnum.DSA_OPERATION, atd.getUsage() );
-
-        assertEquals( 2, atd.getExtensions().size() );
-        assertNotNull( atd.getExtensions().get( "X-TEST-a" ) );
-        assertEquals( 2, atd.getExtensions().get( "X-TEST-a" ).size() );
-        assertEquals( "test1-1", atd.getExtensions().get( "X-TEST-a" ).get( 0 ) );
-        assertEquals( "test1-2", atd.getExtensions().get( "X-TEST-a" ).get( 1 ) );
-        assertNotNull( atd.getExtensions().get( "X-TEST-b" ) );
-        assertEquals( 2, atd.getExtensions().get( "X-TEST-b" ).size() );
-        assertEquals( "test2-1", atd.getExtensions().get( "X-TEST-b" ).get( 0 ) );
-        assertEquals( "test2-2", atd.getExtensions().get( "X-TEST-b" ).get( 1 ) );
+        assertEquals( "1.2.3.4.5.6.7.8.9.0", attributeType.getOid() );
+        assertEquals( 2, attributeType.getNames().size() );
+        assertEquals( "abcdefghijklmnopqrstuvwxyz-ABCDEFGHIJKLMNOPQRSTUVWXYZ-0123456789",
attributeType.getNames().get( 0 ) );
+        assertEquals( "test", attributeType.getNames().get( 1 ) );
+        assertEquals( "Descripton \u00E4\u00F6\u00FC\u00DF \u90E8\u9577", attributeType.getDescription()
);
+        assertTrue( attributeType.isObsolete() );
+        assertEquals( "abcdefghijklmnopqrstuvwxyz-ABCDEFGHIJKLMNOPQRSTUVWXYZ-0123456789",
attributeType.getSupOid() );
+        assertEquals( "2.3.4.5.6.7.8.9.0.1", attributeType.getEqualityOid() );
+        assertEquals( "3.4.5.6.7.8.9.0.1.2", attributeType.getOrderingOid() );
+        assertEquals( "4.5.6.7.8.9.0.1.2.3", attributeType.getSubstrOid() );
+        assertEquals( "5.6.7.8.9.0.1.2.3.4", attributeType.getSyntaxOid() );
+        assertEquals( 1234567890, attributeType.getLength() );
+
+        assertTrue( attributeType.isSingleValue() );
+        assertFalse( attributeType.isCollective() );
+        assertFalse( attributeType.isCanUserModify() );
+        assertEquals( UsageEnum.DSA_OPERATION, attributeType.getUsage() );
+
+        assertEquals( 2, attributeType.getExtensions().size() );
+        assertNotNull( attributeType.getExtensions().get( "X-TEST-a" ) );
+        assertEquals( 2, attributeType.getExtensions().get( "X-TEST-a" ).size() );
+        assertEquals( "test1-1", attributeType.getExtensions().get( "X-TEST-a" ).get( 0 )
);
+        assertEquals( "test1-2", attributeType.getExtensions().get( "X-TEST-a" ).get( 1 )
);
+        assertNotNull( attributeType.getExtensions().get( "X-TEST-b" ) );
+        assertEquals( 2, attributeType.getExtensions().get( "X-TEST-b" ).size() );
+        assertEquals( "test2-1", attributeType.getExtensions().get( "X-TEST-b" ).get( 0 )
);
+        assertEquals( "test2-2", attributeType.getExtensions().get( "X-TEST-b" ).get( 1 )
);
     }
 
 
@@ -718,22 +718,22 @@
     public void testRequiredElements() throws ParseException
     {
         String value = null;
-        AttributeTypeDescription atd = null;
+        AttributeType attributeType = null;
 
         value = "( 1.2.3.4.5.6.7.8.9.0 SYNTAX 1.1 SUP 1.1 )";
-        atd = parser.parseAttributeTypeDescription( value );
-        assertNotNull( atd.getSyntax() );
-        assertNotNull( atd.getSuperType() );
+        attributeType = parser.parseAttributeTypeDescription( value );
+        assertNotNull( attributeType.getSyntaxOid() );
+        assertNotNull( attributeType.getSupOid() );
 
         value = "( 1.2.3.4.5.6.7.8.9.0 SYNTAX 1.1 )";
-        atd = parser.parseAttributeTypeDescription( value );
-        assertNotNull( atd.getSyntax() );
-        assertNull( atd.getSuperType() );
+        attributeType = parser.parseAttributeTypeDescription( value );
+        assertNotNull( attributeType.getSyntaxOid() );
+        assertNull( attributeType.getSupOid() );
 
         value = "( 1.2.3.4.5.6.7.8.9.0 SUP 1.1 )";
-        atd = parser.parseAttributeTypeDescription( value );
-        assertNull( atd.getSyntax() );
-        assertNotNull( atd.getSuperType() );
+        attributeType = parser.parseAttributeTypeDescription( value );
+        assertNull( attributeType.getSyntaxOid() );
+        assertNotNull( attributeType.getSupOid() );
 
         if ( !parser.isQuirksMode() )
         {
@@ -761,17 +761,17 @@
     public void testCollecitveConstraint() throws ParseException
     {
         String value = null;
-        AttributeTypeDescription atd = null;
+        AttributeType attributeType = null;
 
         value = "( 1.1 SYNTAX 1.1 COLLECTIVE )";
-        atd = parser.parseAttributeTypeDescription( value );
-        assertTrue( atd.isCollective() );
-        assertEquals( UsageEnum.USER_APPLICATIONS, atd.getUsage() );
+        attributeType = parser.parseAttributeTypeDescription( value );
+        assertTrue( attributeType.isCollective() );
+        assertEquals( UsageEnum.USER_APPLICATIONS, attributeType.getUsage() );
 
         value = "( 1.1 SYNTAX 1.1 COLLECTIVE USAGE userApplications )";
-        atd = parser.parseAttributeTypeDescription( value );
-        assertTrue( atd.isCollective() );
-        assertEquals( UsageEnum.USER_APPLICATIONS, atd.getUsage() );
+        attributeType = parser.parseAttributeTypeDescription( value );
+        assertTrue( attributeType.isCollective() );
+        assertEquals( UsageEnum.USER_APPLICATIONS, attributeType.getUsage() );
 
         if ( !parser.isQuirksMode() )
         {
@@ -821,22 +821,22 @@
     public void testNoUserModificatonConstraint() throws ParseException
     {
         String value = null;
-        AttributeTypeDescription atd = null;
+        AttributeType attributeType = null;
 
         value = "( 1.1 SYNTAX 1.1 NO-USER-MODIFICATION USAGE directoryOperation )";
-        atd = parser.parseAttributeTypeDescription( value );
-        assertFalse( atd.isUserModifiable() );
-        assertEquals( UsageEnum.DIRECTORY_OPERATION, atd.getUsage() );
+        attributeType = parser.parseAttributeTypeDescription( value );
+        assertFalse( attributeType.isCanUserModify() );
+        assertEquals( UsageEnum.DIRECTORY_OPERATION, attributeType.getUsage() );
 
         value = "( 1.1 SYNTAX 1.1 NO-USER-MODIFICATION USAGE dSAOperation )";
-        atd = parser.parseAttributeTypeDescription( value );
-        assertFalse( atd.isUserModifiable() );
-        assertEquals( UsageEnum.DSA_OPERATION, atd.getUsage() );
+        attributeType = parser.parseAttributeTypeDescription( value );
+        assertFalse( attributeType.isCanUserModify() );
+        assertEquals( UsageEnum.DSA_OPERATION, attributeType.getUsage() );
 
         value = "( 1.1 SYNTAX 1.1 NO-USER-MODIFICATION USAGE distributedOperation )";
-        atd = parser.parseAttributeTypeDescription( value );
-        assertFalse( atd.isUserModifiable() );
-        assertEquals( UsageEnum.DISTRIBUTED_OPERATION, atd.getUsage() );
+        attributeType = parser.parseAttributeTypeDescription( value );
+        assertFalse( attributeType.isCanUserModify() );
+        assertEquals( UsageEnum.DISTRIBUTED_OPERATION, attributeType.getUsage() );
 
         if ( !parser.isQuirksMode() )
         {
@@ -874,19 +874,19 @@
     public void testIgnoreElementOrder() throws ParseException
     {
         String value = "( 2.5.4.3 SUP name SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 USAGE userApplications
DESC 'RFC2256: common name(s) for which the entity is known by'  EQUALITY caseIgnoreMatch
SUBSTR caseIgnoreSubstringsMatch NAME ( 'cn' 'commonName' )  )";
-        AttributeTypeDescription atd = parser.parseAttributeTypeDescription( value );
+        AttributeType attributeType = parser.parseAttributeTypeDescription( value );
 
-        assertEquals( "2.5.4.3", atd.getNumericOid() );
-        assertEquals( 2, atd.getNames().size() );
-        assertEquals( "cn", atd.getNames().get( 0 ) );
-        assertEquals( "commonName", atd.getNames().get( 1 ) );
-        assertEquals( "RFC2256: common name(s) for which the entity is known by", atd.getDescription()
);
-        assertEquals( "name", atd.getSuperType() );
-        assertEquals( "caseIgnoreMatch", atd.getEqualityMatchingRule() );
-        assertEquals( "caseIgnoreSubstringsMatch", atd.getSubstringsMatchingRule() );
-        assertEquals( "1.3.6.1.4.1.1466.115.121.1.15", atd.getSyntax() );
-        assertEquals( UsageEnum.USER_APPLICATIONS, atd.getUsage() );
-        assertEquals( 0, atd.getExtensions().size() );
+        assertEquals( "2.5.4.3", attributeType.getOid() );
+        assertEquals( 2, attributeType.getNames().size() );
+        assertEquals( "cn", attributeType.getNames().get( 0 ) );
+        assertEquals( "commonName", attributeType.getNames().get( 1 ) );
+        assertEquals( "RFC2256: common name(s) for which the entity is known by", attributeType.getDescription()
);
+        assertEquals( "name", attributeType.getSupOid() );
+        assertEquals( "caseIgnoreMatch", attributeType.getEqualityOid() );
+        assertEquals( "caseIgnoreSubstringsMatch", attributeType.getSubstrOid() );
+        assertEquals( "1.3.6.1.4.1.1466.115.121.1.15", attributeType.getSyntaxOid() );
+        assertEquals( UsageEnum.USER_APPLICATIONS, attributeType.getUsage() );
+        assertEquals( 0, attributeType.getExtensions().size() );
     }
 
 
@@ -898,28 +898,28 @@
     public void testRfcUid() throws ParseException
     {
         String value = "( 0.9.2342.19200300.100.1.1 NAME ( 'uid' 'userid' ) DESC 'RFC1274:
user identifier' EQUALITY caseIgnoreMatch SUBSTR caseIgnoreSubstringsMatch SYNTAX 1.3.6.1.4.1.1466.115.121.1.15{256}
USAGE userApplications )";
-        AttributeTypeDescription atd = parser.parseAttributeTypeDescription( value );
+        AttributeType attributeType = parser.parseAttributeTypeDescription( value );
 
-        assertEquals( "0.9.2342.19200300.100.1.1", atd.getNumericOid() );
-        assertEquals( 2, atd.getNames().size() );
-        assertEquals( "uid", atd.getNames().get( 0 ) );
-        assertEquals( "userid", atd.getNames().get( 1 ) );
-        assertEquals( "RFC1274: user identifier", atd.getDescription() );
-        assertNull( atd.getSuperType() );
-
-        assertEquals( "caseIgnoreMatch", atd.getEqualityMatchingRule() );
-        assertEquals( "caseIgnoreSubstringsMatch", atd.getSubstringsMatchingRule() );
-        assertNull( atd.getOrderingMatchingRule() );
-        assertEquals( "1.3.6.1.4.1.1466.115.121.1.15", atd.getSyntax() );
-        assertEquals( 256, atd.getSyntaxLength() );
-        assertEquals( UsageEnum.USER_APPLICATIONS, atd.getUsage() );
-
-        assertFalse( atd.isObsolete() );
-        assertFalse( atd.isCollective() );
-        assertFalse( atd.isSingleValued() );
-        assertTrue( atd.isUserModifiable() );
+        assertEquals( "0.9.2342.19200300.100.1.1", attributeType.getOid() );
+        assertEquals( 2, attributeType.getNames().size() );
+        assertEquals( "uid", attributeType.getNames().get( 0 ) );
+        assertEquals( "userid", attributeType.getNames().get( 1 ) );
+        assertEquals( "RFC1274: user identifier", attributeType.getDescription() );
+        assertNull( attributeType.getSupOid() );
+
+        assertEquals( "caseIgnoreMatch", attributeType.getEqualityOid() );
+        assertEquals( "caseIgnoreSubstringsMatch", attributeType.getSubstrOid() );
+        assertNull( attributeType.getOrderingOid() );
+        assertEquals( "1.3.6.1.4.1.1466.115.121.1.15", attributeType.getSyntaxOid() );
+        assertEquals( 256, attributeType.getLength() );
+        assertEquals( UsageEnum.USER_APPLICATIONS, attributeType.getUsage() );
+
+        assertFalse( attributeType.isObsolete() );
+        assertFalse( attributeType.isCollective() );
+        assertFalse( attributeType.isSingleValue() );
+        assertTrue( attributeType.isCanUserModify() );
 
-        assertEquals( 0, atd.getExtensions().size() );
+        assertEquals( 0, attributeType.getExtensions().size() );
     }
 
 
@@ -931,13 +931,13 @@
     {
         String substrate = "( 1.3.6.1.4.1.18060.0.4.0.2.10000 NAME ( 'bogus' 'bogusName'
) "
             + "DESC 'bogus description' SUP name SINGLE-VALUE )";
-        AttributeTypeDescription desc = parser.parseAttributeTypeDescription( substrate );
-        assertEquals( "1.3.6.1.4.1.18060.0.4.0.2.10000", desc.getNumericOid() );
+        AttributeType desc = parser.parseAttributeTypeDescription( substrate );
+        assertEquals( "1.3.6.1.4.1.18060.0.4.0.2.10000", desc.getOid() );
         assertEquals( "bogus", desc.getNames().get( 0 ) );
         assertEquals( "bogusName", desc.getNames().get( 1 ) );
         assertEquals( "bogus description", desc.getDescription() );
-        assertEquals( "name", desc.getSuperType() );
-        assertEquals( true, desc.isSingleValued() );
+        assertEquals( "name", desc.getSupOid() );
+        assertEquals( true, desc.isSingleValue() );
     }
 
 
@@ -949,13 +949,13 @@
     {
         String substrate = "( 1.3.6.1.4.1.18060.0.4.0.2.10000 NAME ( 'bogus' 'bogusName'
) "
             + "DESC 'bogus description' SUP name SINGLE-VALUE X-SCHEMA 'blah' )";
-        AttributeTypeDescription desc = parser.parseAttributeTypeDescription( substrate );
-        assertEquals( "1.3.6.1.4.1.18060.0.4.0.2.10000", desc.getNumericOid() );
+        AttributeType desc = parser.parseAttributeTypeDescription( substrate );
+        assertEquals( "1.3.6.1.4.1.18060.0.4.0.2.10000", desc.getOid() );
         assertEquals( "bogus", desc.getNames().get( 0 ) );
         assertEquals( "bogusName", desc.getNames().get( 1 ) );
         assertEquals( "bogus description", desc.getDescription() );
-        assertEquals( "name", desc.getSuperType() );
-        assertEquals( true, desc.isSingleValued() );
+        assertEquals( "name", desc.getSupOid() );
+        assertEquals( true, desc.isSingleValue() );
         assertEquals( "blah", desc.getExtensions().get( "X-SCHEMA" ).get( 0 ) );
     }
 
@@ -987,7 +987,7 @@
         try
         {
             String value = null;
-            AttributeTypeDescription atd = null;
+            AttributeType attributeType = null;
 
             parser.setQuirksMode( true );
 
@@ -1018,41 +1018,41 @@
 
             // NAME with special chars
             value = "( 1.2.3 SYNTAX te_st NAME 't-e_s.t;' )";
-            atd = parser.parseAttributeTypeDescription( value );
-            assertEquals( 1, atd.getNames().size() );
-            assertEquals( "t-e_s.t;", atd.getNames().get( 0 ) );
+            attributeType = parser.parseAttributeTypeDescription( value );
+            assertEquals( 1, attributeType.getNames().size() );
+            assertEquals( "t-e_s.t;", attributeType.getNames().get( 0 ) );
 
             // SYNTAX with underscore
             value = "( 1.1 SYNTAX te_st )";
-            atd = parser.parseAttributeTypeDescription( value );
-            assertEquals( "te_st", atd.getSyntax() );
+            attributeType = parser.parseAttributeTypeDescription( value );
+            assertEquals( "te_st", attributeType.getSyntaxOid() );
 
             // SUPERTYPE with underscore
             value = "( 1.1 SYNTAX 1.1 SUP te_st )";
-            atd = parser.parseAttributeTypeDescription( value );
-            assertEquals( "te_st", atd.getSuperType() );
+            attributeType = parser.parseAttributeTypeDescription( value );
+            assertEquals( "te_st", attributeType.getSupOid() );
 
             // EQUALITY with underscore
             value = "( 1.1 SYNTAX 1.1 EQUALITY te_st )";
-            atd = parser.parseAttributeTypeDescription( value );
-            assertEquals( "te_st", atd.getEqualityMatchingRule() );
+            attributeType = parser.parseAttributeTypeDescription( value );
+            assertEquals( "te_st", attributeType.getEqualityOid() );
 
             // SUBSTR with underscore
             value = "( 1.1 SYNTAX 1.1 SUBSTR te_st )";
-            atd = parser.parseAttributeTypeDescription( value );
-            assertEquals( "te_st", atd.getSubstringsMatchingRule() );
+            attributeType = parser.parseAttributeTypeDescription( value );
+            assertEquals( "te_st", attributeType.getSubstrOid() );
 
             // ORDERING with underscore
             value = "( 1.1 SYNTAX 1.1 ORDERING te_st )";
-            atd = parser.parseAttributeTypeDescription( value );
-            assertEquals( "te_st", atd.getOrderingMatchingRule() );
+            attributeType = parser.parseAttributeTypeDescription( value );
+            assertEquals( "te_st", attributeType.getOrderingOid() );
 
             // Netscape attribute 
             value = "( nsAdminGroupName-oid NAME 'nsAdminGroupName' DESC 'Netscape defined
attribute type' SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 X-ORIGIN 'Netscape' )";
-            atd = parser.parseAttributeTypeDescription( value );
-            assertEquals( "nsAdminGroupName-oid", atd.getNumericOid() );
-            assertEquals( 1, atd.getNames().size() );
-            assertEquals( "nsAdminGroupName", atd.getNames().get( 0 ) );
+            attributeType = parser.parseAttributeTypeDescription( value );
+            assertEquals( "nsAdminGroupName-oid", attributeType.getOid() );
+            assertEquals( 1, attributeType.getNames().size() );
+            assertEquals( "nsAdminGroupName", attributeType.getNames().get( 0 ) );
         }
         finally
         {



Mime
View raw message