Synchronize SDK on java.net with internal repository.

matthew_swift

28.47.2010 f2160f4bd1c8ac67e5a86a6710d431e8932877f9

 sdk/tests/unit-tests-testng/src/org/opends/sdk/AttributeDescriptionTestCase.java

File was renamed from sdk/tests/unit-tests-testng/src/org/opends/sdk/AttributeDescriptionTest.java
@@ -22,7 +22,7 @@
 * CDDL HEADER END
 *
 *
 *      Copyright 2009 Sun Microsystems, Inc.
 *      Copyright 200-2010 Sun Microsystems, Inc.
 */

package org.opends.sdk;
@@ -36,102 +36,29 @@
import org.testng.annotations.DataProvider;
import org.testng.annotations.Test;

import org.opends.sdk.LocalizedIllegalArgumentException;



/**
 * Test {@code AttributeDescription}.
 */
@Test(groups = { "precommit", "types", "sdk" }, sequential = true)
public final class AttributeDescriptionTest extends OpenDSTestCase
public final class AttributeDescriptionTestCase extends OpenDSTestCase
{
  @DataProvider(name = "dataForValueOfNoSchema")
  public Object[][] dataForValueOfNoSchema()
  @DataProvider(name = "dataForCompareCoreSchema")
  public Object[][] dataForCompareCoreSchema()
  {
    // Value, type, options, containsOptions("foo")
    return new Object[][] {
        { "cn", "cn", new String[0], false },
        { " cn ", "cn", new String[0], false },
        { "  cn  ", "cn", new String[0], false },
        { "CN", "CN", new String[0], false },
        { "1", "1", new String[0], false },
        { "1.2", "1.2", new String[0], false },
        { "1.2.3", "1.2.3", new String[0], false },
        { "111.222.333", "111.222.333", new String[0], false },
        { "objectClass", "objectClass", new String[0], false },
        { "cn;foo", "cn", new String[] { "foo" }, true },
        { "cn;FOO", "cn", new String[] { "FOO" }, true },
        { "cn;bar", "cn", new String[] { "bar" }, false },
        { "cn;BAR", "cn", new String[] { "BAR" }, false },
        { "cn;foo;bar", "cn", new String[] { "foo", "bar" }, true },
        { "cn;FOO;bar", "cn", new String[] { "FOO", "bar" }, true },
        { "cn;foo;BAR", "cn", new String[] { "foo", "BAR" }, true },
        { "cn;FOO;BAR", "cn", new String[] { "FOO", "BAR" }, true },
        { "cn;bar;FOO", "cn", new String[] { "bar", "FOO" }, true },
        { "cn;BAR;foo", "cn", new String[] { "BAR", "foo" }, true },
        { "cn;bar;FOO", "cn", new String[] { "bar", "FOO" }, true },
        { "cn;BAR;FOO", "cn", new String[] { "BAR", "FOO" }, true },
        { " cn;BAR;FOO ", "cn", new String[] { "BAR", "FOO" }, true },
        { "  cn;BAR;FOO  ", "cn", new String[] { "BAR", "FOO" }, true },
        { "cn;xxx;yyy;zzz", "cn", new String[] { "xxx", "yyy", "zzz" },
            false },
        { "cn;zzz;YYY;xxx", "cn", new String[] { "zzz", "YYY", "xxx" },
            false }, };
  }



  @Test(dataProvider = "dataForValueOfNoSchema")
  public void testValueOfNoSchema(String ad, String at,
      String[] options, boolean containsFoo)
  {
    AttributeDescription attributeDescription =
        AttributeDescription.valueOf(ad, Schema.getEmptySchema());

    Assert.assertEquals(attributeDescription.toString(), ad);

    Assert.assertEquals(attributeDescription.getAttributeType()
        .getNameOrOID(), at);

    Assert.assertFalse(attributeDescription.isObjectClass());

    if (options.length == 0)
    {
      Assert.assertFalse(attributeDescription.hasOptions());
    }
    else
    {
      Assert.assertTrue(attributeDescription.hasOptions());
    }

    Assert.assertFalse(attributeDescription.containsOption("dummy"));
    if (containsFoo)
    {
      Assert.assertTrue(attributeDescription.containsOption("foo"));
      Assert.assertTrue(attributeDescription.containsOption("FOO"));
      Assert.assertTrue(attributeDescription.containsOption("FoO"));
    }
    else
    {
      Assert.assertFalse(attributeDescription.containsOption("foo"));
      Assert.assertFalse(attributeDescription.containsOption("FOO"));
      Assert.assertFalse(attributeDescription.containsOption("FoO"));
    }

    for (String option : options)
    {
      Assert.assertTrue(attributeDescription.containsOption(option));
    }

    Iterator<String> iterator =
        attributeDescription.getOptions().iterator();
    for (int i = 0; i < options.length; i++)
    {
      Assert.assertTrue(iterator.hasNext());
      Assert.assertEquals(iterator.next(), options[i]);
    }
    Assert.assertFalse(iterator.hasNext());
    // AD1, AD2, compare result, isSubtype, isSuperType
    return new Object[][] { { "cn", "cn", 0, true, true },
        { "cn", "commonName", 0, true, true },
        { " cn", "commonName ", 0, true, true },
        { "commonName", "cn", 0, true, true },
        { "commonName", "commonName", 0, true, true },
        { "cn", "objectClass", 1, false, false },
        { "objectClass", "cn", -1, false, false },
        { "name", "cn", 1, false, true }, { "cn", "name", -1, true, false },
        { "name;foo", "cn", 1, false, false },
        { "cn;foo", "name", -1, true, false },
        { "name", "cn;foo", 1, false, true },
        { "cn", "name;foo", -1, false, false }, };
  }


@@ -170,74 +97,12 @@



  @Test(dataProvider = "dataForCompareNoSchema")
  public void testCompareNoSchema(String ad1, String ad2, int compare,
      boolean isSubType, boolean isSuperType)
  @DataProvider(name = "dataForValueOfCoreSchema")
  public Object[][] dataForValueOfCoreSchema()
  {
    AttributeDescription attributeDescription1 =
        AttributeDescription.valueOf(ad1, Schema.getEmptySchema());

    AttributeDescription attributeDescription2 =
        AttributeDescription.valueOf(ad2, Schema.getEmptySchema());

    // Identity.
    Assert.assertTrue(attributeDescription1
        .equals(attributeDescription1));
    Assert.assertTrue(attributeDescription1
        .compareTo(attributeDescription1) == 0);
    Assert.assertTrue(attributeDescription1
        .isSubTypeOf(attributeDescription1));
    Assert.assertTrue(attributeDescription1
        .isSuperTypeOf(attributeDescription1));

    if (compare == 0)
    {
      Assert.assertTrue(attributeDescription1
          .equals(attributeDescription2));
      Assert.assertTrue(attributeDescription2
          .equals(attributeDescription1));
      Assert.assertTrue(attributeDescription1
          .compareTo(attributeDescription2) == 0);
      Assert.assertTrue(attributeDescription2
          .compareTo(attributeDescription1) == 0);

      Assert.assertTrue(attributeDescription1
          .isSubTypeOf(attributeDescription2));
      Assert.assertTrue(attributeDescription1
          .isSuperTypeOf(attributeDescription2));
      Assert.assertTrue(attributeDescription2
          .isSubTypeOf(attributeDescription1));
      Assert.assertTrue(attributeDescription2
          .isSuperTypeOf(attributeDescription1));
    }
    else
    {
      Assert.assertFalse(attributeDescription1
          .equals(attributeDescription2));
      Assert.assertFalse(attributeDescription2
          .equals(attributeDescription1));

      if (compare < 0)
      {
        Assert.assertTrue(attributeDescription1
            .compareTo(attributeDescription2) < 0);
        Assert.assertTrue(attributeDescription2
            .compareTo(attributeDescription1) > 0);
      }
      else
      {
        Assert.assertTrue(attributeDescription1
            .compareTo(attributeDescription2) > 0);
        Assert.assertTrue(attributeDescription2
            .compareTo(attributeDescription1) < 0);
      }

      Assert.assertEquals(attributeDescription1
          .isSubTypeOf(attributeDescription2), isSubType);

      Assert.assertEquals(attributeDescription1
          .isSuperTypeOf(attributeDescription2), isSuperType);
    }
    // Value, type, isObjectClass
    return new Object[][] { { "cn", "cn", false }, { "CN", "cn", false },
        { "commonName", "cn", false }, { "objectclass", "objectClass", true }, };
  }


@@ -245,113 +110,76 @@
  @DataProvider(name = "dataForValueOfInvalidAttributeDescriptions")
  public Object[][] dataForValueOfInvalidAttributeDescriptions()
  {
    return new Object[][] { { "" }, { " " }, { ";" }, { " ; " },
        { "0cn" }, { "cn." }, { "cn;foo+bar" }, { "cn;foo;foo+bar" },
        { ";foo" }, { "cn;" }, { "cn;;foo" }, { "cn; ;foo" },
        { "cn;foo;" }, { "cn;foo; " }, { "cn;foo;;bar" },
        { "cn;foo; ;bar" }, { "cn;foo;bar;;" }, { "1a" }, { "1.a" },
        { "1-" }, { "1.1a" }, { "1.1.a" }, };
    return new Object[][] { { "" }, { " " }, { ";" }, { " ; " }, { "0cn" },
        { "cn." }, { "cn;foo+bar" }, { "cn;foo;foo+bar" }, { ";foo" },
        { "cn;" }, { "cn;;foo" }, { "cn; ;foo" }, { "cn;foo;" },
        { "cn;foo; " }, { "cn;foo;;bar" }, { "cn;foo; ;bar" },
        { "cn;foo;bar;;" }, { "1a" }, { "1.a" }, { "1-" }, { "1.1a" },
        { "1.1.a" }, };
  }



  // FIXME: none of these pass! The valueOf method is far to lenient.
  @Test(dataProvider = "dataForValueOfInvalidAttributeDescriptions",
      expectedExceptions = LocalizedIllegalArgumentException.class)
  public void testValueOfInvalidAttributeDescriptions(String ad)
  @DataProvider(name = "dataForValueOfNoSchema")
  public Object[][] dataForValueOfNoSchema()
  {
    AttributeDescription.valueOf(ad, Schema.getEmptySchema());
  }



  @DataProvider(name = "dataForValueOfCoreSchema")
  public Object[][] dataForValueOfCoreSchema()
  {
    // Value, type, isObjectClass
    return new Object[][] { { "cn", "cn", false },
        { "CN", "cn", false }, { "commonName", "cn", false },
        { "objectclass", "objectClass", true }, };
  }



  @Test(dataProvider = "dataForValueOfCoreSchema")
  public void testValueOfCoreSchema(String ad, String at,
      boolean isObjectClass)
  {
    AttributeDescription attributeDescription =
        AttributeDescription.valueOf(ad, Schema.getCoreSchema());

    Assert.assertEquals(attributeDescription.toString(), ad);

    Assert.assertEquals(attributeDescription.getAttributeType()
        .getNameOrOID(), at);

    Assert.assertEquals(attributeDescription.isObjectClass(),
        isObjectClass);

    Assert.assertFalse(attributeDescription.hasOptions());
    Assert.assertFalse(attributeDescription.containsOption("dummy"));

    Iterator<String> iterator =
        attributeDescription.getOptions().iterator();
    Assert.assertFalse(iterator.hasNext());
  }



  @DataProvider(name = "dataForCompareCoreSchema")
  public Object[][] dataForCompareCoreSchema()
  {
    // AD1, AD2, compare result, isSubtype, isSuperType
    return new Object[][] { { "cn", "cn", 0, true, true },
        { "cn", "commonName", 0, true, true },
        { " cn", "commonName ", 0, true, true },
        { "commonName", "cn", 0, true, true },
        { "commonName", "commonName", 0, true, true },
        { "cn", "objectClass", 1, false, false },
        { "objectClass", "cn", -1, false, false },
        { "name", "cn", 1, false, true },
        { "cn", "name", -1, true, false },
        { "name;foo", "cn", 1, false, false },
        { "cn;foo", "name", -1, true, false },
        { "name", "cn;foo", 1, false, true },
        { "cn", "name;foo", -1, false, false }, };
    // Value, type, options, containsOptions("foo")
    return new Object[][] {
        { "cn", "cn", new String[0], false },
        { " cn ", "cn", new String[0], false },
        { "  cn  ", "cn", new String[0], false },
        { "CN", "CN", new String[0], false },
        { "1", "1", new String[0], false },
        { "1.2", "1.2", new String[0], false },
        { "1.2.3", "1.2.3", new String[0], false },
        { "111.222.333", "111.222.333", new String[0], false },
        { "objectClass", "objectClass", new String[0], false },
        { "cn;foo", "cn", new String[] { "foo" }, true },
        { "cn;FOO", "cn", new String[] { "FOO" }, true },
        { "cn;bar", "cn", new String[] { "bar" }, false },
        { "cn;BAR", "cn", new String[] { "BAR" }, false },
        { "cn;foo;bar", "cn", new String[] { "foo", "bar" }, true },
        { "cn;FOO;bar", "cn", new String[] { "FOO", "bar" }, true },
        { "cn;foo;BAR", "cn", new String[] { "foo", "BAR" }, true },
        { "cn;FOO;BAR", "cn", new String[] { "FOO", "BAR" }, true },
        { "cn;bar;FOO", "cn", new String[] { "bar", "FOO" }, true },
        { "cn;BAR;foo", "cn", new String[] { "BAR", "foo" }, true },
        { "cn;bar;FOO", "cn", new String[] { "bar", "FOO" }, true },
        { "cn;BAR;FOO", "cn", new String[] { "BAR", "FOO" }, true },
        { " cn;BAR;FOO ", "cn", new String[] { "BAR", "FOO" }, true },
        { "  cn;BAR;FOO  ", "cn", new String[] { "BAR", "FOO" }, true },
        { "cn;xxx;yyy;zzz", "cn", new String[] { "xxx", "yyy", "zzz" }, false },
        { "cn;zzz;YYY;xxx", "cn", new String[] { "zzz", "YYY", "xxx" }, false }, };
  }



  @Test(dataProvider = "dataForCompareCoreSchema")
  public void testCompareCoreSchema(String ad1, String ad2,
      int compare, boolean isSubType, boolean isSuperType)
  public void testCompareCoreSchema(final String ad1, final String ad2,
      final int compare, final boolean isSubType, final boolean isSuperType)
  {
    AttributeDescription attributeDescription1 =
        AttributeDescription.valueOf(ad1, Schema.getCoreSchema());
    final AttributeDescription attributeDescription1 = AttributeDescription
        .valueOf(ad1, Schema.getCoreSchema());

    AttributeDescription attributeDescription2 =
        AttributeDescription.valueOf(ad2, Schema.getCoreSchema());
    final AttributeDescription attributeDescription2 = AttributeDescription
        .valueOf(ad2, Schema.getCoreSchema());

    // Identity.
    Assert.assertTrue(attributeDescription1
        .equals(attributeDescription1));
    Assert.assertTrue(attributeDescription1
        .compareTo(attributeDescription1) == 0);
    Assert.assertTrue(attributeDescription1
        .isSubTypeOf(attributeDescription1));
    Assert.assertTrue(attributeDescription1.equals(attributeDescription1));
    Assert
        .assertTrue(attributeDescription1.compareTo(attributeDescription1) == 0);
    Assert.assertTrue(attributeDescription1.isSubTypeOf(attributeDescription1));
    Assert.assertTrue(attributeDescription1
        .isSuperTypeOf(attributeDescription1));

    if (compare == 0)
    {
      Assert.assertTrue(attributeDescription1
          .equals(attributeDescription2));
      Assert.assertTrue(attributeDescription2
          .equals(attributeDescription1));
      Assert.assertTrue(attributeDescription1
          .compareTo(attributeDescription2) == 0);
      Assert.assertTrue(attributeDescription2
          .compareTo(attributeDescription1) == 0);
      Assert.assertTrue(attributeDescription1.equals(attributeDescription2));
      Assert.assertTrue(attributeDescription2.equals(attributeDescription1));
      Assert
          .assertTrue(attributeDescription1.compareTo(attributeDescription2) == 0);
      Assert
          .assertTrue(attributeDescription2.compareTo(attributeDescription1) == 0);

      Assert.assertTrue(attributeDescription1
          .isSubTypeOf(attributeDescription2));
@@ -364,10 +192,8 @@
    }
    else
    {
      Assert.assertFalse(attributeDescription1
          .equals(attributeDescription2));
      Assert.assertFalse(attributeDescription2
          .equals(attributeDescription1));
      Assert.assertFalse(attributeDescription1.equals(attributeDescription2));
      Assert.assertFalse(attributeDescription2.equals(attributeDescription1));

      if (compare < 0)
      {
@@ -391,4 +217,157 @@
          .isSuperTypeOf(attributeDescription2), isSuperType);
    }
  }



  @Test(dataProvider = "dataForCompareNoSchema")
  public void testCompareNoSchema(final String ad1, final String ad2,
      final int compare, final boolean isSubType, final boolean isSuperType)
  {
    final AttributeDescription attributeDescription1 = AttributeDescription
        .valueOf(ad1, Schema.getEmptySchema());

    final AttributeDescription attributeDescription2 = AttributeDescription
        .valueOf(ad2, Schema.getEmptySchema());

    // Identity.
    Assert.assertTrue(attributeDescription1.equals(attributeDescription1));
    Assert
        .assertTrue(attributeDescription1.compareTo(attributeDescription1) == 0);
    Assert.assertTrue(attributeDescription1.isSubTypeOf(attributeDescription1));
    Assert.assertTrue(attributeDescription1
        .isSuperTypeOf(attributeDescription1));

    if (compare == 0)
    {
      Assert.assertTrue(attributeDescription1.equals(attributeDescription2));
      Assert.assertTrue(attributeDescription2.equals(attributeDescription1));
      Assert
          .assertTrue(attributeDescription1.compareTo(attributeDescription2) == 0);
      Assert
          .assertTrue(attributeDescription2.compareTo(attributeDescription1) == 0);

      Assert.assertTrue(attributeDescription1
          .isSubTypeOf(attributeDescription2));
      Assert.assertTrue(attributeDescription1
          .isSuperTypeOf(attributeDescription2));
      Assert.assertTrue(attributeDescription2
          .isSubTypeOf(attributeDescription1));
      Assert.assertTrue(attributeDescription2
          .isSuperTypeOf(attributeDescription1));
    }
    else
    {
      Assert.assertFalse(attributeDescription1.equals(attributeDescription2));
      Assert.assertFalse(attributeDescription2.equals(attributeDescription1));

      if (compare < 0)
      {
        Assert.assertTrue(attributeDescription1
            .compareTo(attributeDescription2) < 0);
        Assert.assertTrue(attributeDescription2
            .compareTo(attributeDescription1) > 0);
      }
      else
      {
        Assert.assertTrue(attributeDescription1
            .compareTo(attributeDescription2) > 0);
        Assert.assertTrue(attributeDescription2
            .compareTo(attributeDescription1) < 0);
      }

      Assert.assertEquals(attributeDescription1
          .isSubTypeOf(attributeDescription2), isSubType);

      Assert.assertEquals(attributeDescription1
          .isSuperTypeOf(attributeDescription2), isSuperType);
    }
  }



  @Test(dataProvider = "dataForValueOfCoreSchema")
  public void testValueOfCoreSchema(final String ad, final String at,
      final boolean isObjectClass)
  {
    final AttributeDescription attributeDescription = AttributeDescription
        .valueOf(ad, Schema.getCoreSchema());

    Assert.assertEquals(attributeDescription.toString(), ad);

    Assert.assertEquals(attributeDescription.getAttributeType().getNameOrOID(),
        at);

    Assert.assertEquals(attributeDescription.isObjectClass(), isObjectClass);

    Assert.assertFalse(attributeDescription.hasOptions());
    Assert.assertFalse(attributeDescription.containsOption("dummy"));

    final Iterator<String> iterator = attributeDescription.getOptions()
        .iterator();
    Assert.assertFalse(iterator.hasNext());
  }



  // FIXME: none of these pass! The valueOf method is far to lenient.
  @Test(dataProvider = "dataForValueOfInvalidAttributeDescriptions", expectedExceptions = LocalizedIllegalArgumentException.class)
  public void testValueOfInvalidAttributeDescriptions(final String ad)
  {
    AttributeDescription.valueOf(ad, Schema.getEmptySchema());
  }



  @Test(dataProvider = "dataForValueOfNoSchema")
  public void testValueOfNoSchema(final String ad, final String at,
      final String[] options, final boolean containsFoo)
  {
    final AttributeDescription attributeDescription = AttributeDescription
        .valueOf(ad, Schema.getEmptySchema());

    Assert.assertEquals(attributeDescription.toString(), ad);

    Assert.assertEquals(attributeDescription.getAttributeType().getNameOrOID(),
        at);

    Assert.assertFalse(attributeDescription.isObjectClass());

    if (options.length == 0)
    {
      Assert.assertFalse(attributeDescription.hasOptions());
    }
    else
    {
      Assert.assertTrue(attributeDescription.hasOptions());
    }

    Assert.assertFalse(attributeDescription.containsOption("dummy"));
    if (containsFoo)
    {
      Assert.assertTrue(attributeDescription.containsOption("foo"));
      Assert.assertTrue(attributeDescription.containsOption("FOO"));
      Assert.assertTrue(attributeDescription.containsOption("FoO"));
    }
    else
    {
      Assert.assertFalse(attributeDescription.containsOption("foo"));
      Assert.assertFalse(attributeDescription.containsOption("FOO"));
      Assert.assertFalse(attributeDescription.containsOption("FoO"));
    }

    for (final String option : options)
    {
      Assert.assertTrue(attributeDescription.containsOption(option));
    }

    final Iterator<String> iterator = attributeDescription.getOptions()
        .iterator();
    for (final String option : options)
    {
      Assert.assertTrue(iterator.hasNext());
      Assert.assertEquals(iterator.next(), option);
    }
    Assert.assertFalse(iterator.hasNext());
  }
}