Synchronize SDK on java.net with internal repository.

matthew_swift

28.47.2010 f2160f4bd1c8ac67e5a86a6710d431e8932877f9

 sdk/tests/unit-tests-testng/src/org/opends/sdk/schema/SubstringMatchingRuleTest.java

@@ -33,66 +33,24 @@
import java.util.ArrayList;
import java.util.List;

import org.opends.sdk.ByteSequence;
import org.opends.sdk.ByteString;
import org.opends.sdk.ConditionResult;
import org.opends.sdk.DecodeException;
import org.testng.annotations.DataProvider;
import org.testng.annotations.Test;

import org.opends.sdk.ByteSequence;
import org.opends.sdk.ByteString;



/**
 * Abstract class for building test for the substring matching rules.
 * This class is intended to be extended by one class for each substring
 * matching rules.
 * Abstract class for building test for the substring matching rules. This class
 * is intended to be extended by one class for each substring matching rules.
 */
public abstract class SubstringMatchingRuleTest extends SchemaTestCase
{
  /**
   * Generate data for the test of the middle string match.
   * 
   * @return the data for the test of the middle string match.
   */
  @DataProvider(name = "substringMiddleMatchData")
  public abstract Object[][] createSubstringMiddleMatchData();



  /**
   * Generate data for the test of the initial string match.
   * 
   * @return the data for the test of the initial string match.
   */
  @DataProvider(name = "substringInitialMatchData")
  public abstract Object[][] createSubstringInitialMatchData();



  /**
   * Generate data for the test of the final string match.
   * 
   * @return the data for the test of the final string match.
   */
  @DataProvider(name = "substringInitialMatchData")
  public abstract Object[][] createSubstringFinalMatchData();



  /**
   * Generate invalid attribute values for the Matching Rule test.
   * 
   * @return the data for the EqualityMatchingRulesInvalidValuestest.
   */
  @DataProvider(name = "substringInvalidAttributeValues")
  public abstract Object[][] createMatchingRuleInvalidAttributeValues();



  /**
   * Generate invalid assertion values for the Matching Rule test.
   * 
   *
   * @return the data for the EqualityMatchingRulesInvalidValuestest.
   */
  @DataProvider(name = "substringInvalidAssertionValues")
@@ -101,46 +59,66 @@


  /**
   * Get an instance of the matching rule.
   * 
   * @return An instance of the matching rule to test.
   * Generate invalid attribute values for the Matching Rule test.
   *
   * @return the data for the EqualityMatchingRulesInvalidValuestest.
   */
  protected abstract MatchingRule getRule();
  @DataProvider(name = "substringInvalidAttributeValues")
  public abstract Object[][] createMatchingRuleInvalidAttributeValues();



  /**
   * Test the normalization and the middle substring match.
   * Generate data for the test of the final string match.
   *
   * @return the data for the test of the final string match.
   */
  @Test(dataProvider = "substringMiddleMatchData")
  public void middleMatchingRules(String value, String[] middleSubs,
      ConditionResult result) throws Exception
  @DataProvider(name = "substringInitialMatchData")
  public abstract Object[][] createSubstringFinalMatchData();



  /**
   * Generate data for the test of the initial string match.
   *
   * @return the data for the test of the initial string match.
   */
  @DataProvider(name = "substringInitialMatchData")
  public abstract Object[][] createSubstringInitialMatchData();



  /**
   * Generate data for the test of the middle string match.
   *
   * @return the data for the test of the middle string match.
   */
  @DataProvider(name = "substringMiddleMatchData")
  public abstract Object[][] createSubstringMiddleMatchData();



  /**
   * Test the normalization and the final substring match.
   */
  @Test(dataProvider = "substringFinalMatchData")
  public void finalMatchingRules(final String value, final String finalValue,
      final ConditionResult result) throws Exception
  {
    MatchingRule rule = getRule();
    final MatchingRule rule = getRule();

    // normalize the 2 provided values and check that they are equals
    ByteString normalizedValue =
        rule.normalizeAttributeValue(ByteString.valueOf(value));
    final ByteString normalizedValue = rule.normalizeAttributeValue(ByteString
        .valueOf(value));

    StringBuilder printableMiddleSubs = new StringBuilder();
    List<ByteSequence> middleList =
        new ArrayList<ByteSequence>(middleSubs.length);
    printableMiddleSubs.append("*");
    for (String middleSub : middleSubs)
    {
      printableMiddleSubs.append(middleSub);
      printableMiddleSubs.append("*");
      middleList.add(ByteString.valueOf(middleSub));
    }

    if (rule.getAssertion(null, middleList, null).matches(
    if (rule.getAssertion(null, null, ByteString.valueOf(finalValue)).matches(
        normalizedValue) != result
        || rule.getAssertion(ByteString.valueOf(printableMiddleSubs))
            .matches(normalizedValue) != result)
        || rule.getAssertion(ByteString.valueOf("*" + finalValue)).matches(
            normalizedValue) != result)
    {
      fail("middle substring matching rule " + rule
          + " does not give expected result (" + result
          + ") for values : " + value + " and " + printableMiddleSubs);
      fail("final substring matching rule " + rule
          + " does not give expected result (" + result + ") for values : "
          + value + " and " + finalValue);
    }
  }

@@ -150,88 +128,46 @@
   * Test the normalization and the initial substring match.
   */
  @Test(dataProvider = "substringInitialMatchData")
  public void initialMatchingRules(String value, String initial,
      ConditionResult result) throws Exception
  public void initialMatchingRules(final String value, final String initial,
      final ConditionResult result) throws Exception
  {
    MatchingRule rule = getRule();
    final MatchingRule rule = getRule();

    // normalize the 2 provided values and check that they are equals
    ByteString normalizedValue =
        rule.normalizeAttributeValue(ByteString.valueOf(value));
    final ByteString normalizedValue = rule.normalizeAttributeValue(ByteString
        .valueOf(value));

    if (rule.getAssertion(ByteString.valueOf(initial), null, null)
        .matches(normalizedValue) != result
        || rule.getAssertion(ByteString.valueOf(initial + "*"))
            .matches(normalizedValue) != result)
    if (rule.getAssertion(ByteString.valueOf(initial), null, null).matches(
        normalizedValue) != result
        || rule.getAssertion(ByteString.valueOf(initial + "*")).matches(
            normalizedValue) != result)
    {
      fail("initial substring matching rule " + rule
          + " does not give expected result (" + result
          + ") for values : " + value + " and " + initial);
          + " does not give expected result (" + result + ") for values : "
          + value + " and " + initial);
    }
  }



  /**
   * Test the normalization and the final substring match.
   */
  @Test(dataProvider = "substringFinalMatchData")
  public void finalMatchingRules(String value, String finalValue,
      ConditionResult result) throws Exception
  {
    MatchingRule rule = getRule();

    // normalize the 2 provided values and check that they are equals
    ByteString normalizedValue =
        rule.normalizeAttributeValue(ByteString.valueOf(value));

    if (rule.getAssertion(null, null, ByteString.valueOf(finalValue))
        .matches(normalizedValue) != result
        || rule.getAssertion(ByteString.valueOf("*" + finalValue))
            .matches(normalizedValue) != result)
    {
      fail("final substring matching rule " + rule
          + " does not give expected result (" + result
          + ") for values : " + value + " and " + finalValue);
    }
  }



  /**
   * Test that invalid values are rejected.
   */
  @Test(expectedExceptions = DecodeException.class, dataProvider = "substringInvalidAttributeValues")
  public void substringInvalidAttributeValues(String value)
      throws Exception
  {
    // Get the instance of the rule to be tested.
    MatchingRule rule = getRule();

    rule.normalizeAttributeValue(ByteString.valueOf(value));
  }



  /**
   * Test that invalid values are rejected.
   */
  @Test(expectedExceptions = DecodeException.class, dataProvider = "substringInvalidAssertionValues")
  public void matchingRulesInvalidAssertionValues(String subInitial,
      String[] anys, String subFinal) throws Exception
  public void matchingRulesInvalidAssertionValues(final String subInitial,
      final String[] anys, final String subFinal) throws Exception
  {
    // Get the instance of the rule to be tested.
    MatchingRule rule = getRule();
    final MatchingRule rule = getRule();

    List<ByteSequence> anyList =
        new ArrayList<ByteSequence>(anys.length);
    for (String middleSub : anys)
    final List<ByteSequence> anyList = new ArrayList<ByteSequence>(anys.length);
    for (final String middleSub : anys)
    {
      anyList.add(ByteString.valueOf(middleSub));
    }
    rule.getAssertion(subInitial == null ? null : ByteString
        .valueOf(subInitial), anyList, subFinal == null ? null
        : ByteString.valueOf(subFinal));
        .valueOf(subInitial), anyList, subFinal == null ? null : ByteString
        .valueOf(subFinal));
  }


@@ -241,19 +177,19 @@
   */
  @Test(expectedExceptions = DecodeException.class, dataProvider = "substringInvalidAssertionValues")
  public void matchingRulesInvalidAssertionValuesString(
      String subInitial, String[] anys, String subFinal)
      final String subInitial, final String[] anys, final String subFinal)
      throws Exception
  {
    // Get the instance of the rule to be tested.
    MatchingRule rule = getRule();
    final MatchingRule rule = getRule();

    StringBuilder assertionString = new StringBuilder();
    final StringBuilder assertionString = new StringBuilder();
    if (subInitial != null)
    {
      assertionString.append(subInitial);
    }
    assertionString.append("*");
    for (String middleSub : anys)
    for (final String middleSub : anys)
    {
      assertionString.append(middleSub);
      assertionString.append("*");
@@ -264,4 +200,64 @@
    }
    rule.getAssertion(ByteString.valueOf(assertionString.toString()));
  }



  /**
   * Test the normalization and the middle substring match.
   */
  @Test(dataProvider = "substringMiddleMatchData")
  public void middleMatchingRules(final String value,
      final String[] middleSubs, final ConditionResult result) throws Exception
  {
    final MatchingRule rule = getRule();

    // normalize the 2 provided values and check that they are equals
    final ByteString normalizedValue = rule.normalizeAttributeValue(ByteString
        .valueOf(value));

    final StringBuilder printableMiddleSubs = new StringBuilder();
    final List<ByteSequence> middleList = new ArrayList<ByteSequence>(
        middleSubs.length);
    printableMiddleSubs.append("*");
    for (final String middleSub : middleSubs)
    {
      printableMiddleSubs.append(middleSub);
      printableMiddleSubs.append("*");
      middleList.add(ByteString.valueOf(middleSub));
    }

    if (rule.getAssertion(null, middleList, null).matches(normalizedValue) != result
        || rule.getAssertion(ByteString.valueOf(printableMiddleSubs)).matches(
            normalizedValue) != result)
    {
      fail("middle substring matching rule " + rule
          + " does not give expected result (" + result + ") for values : "
          + value + " and " + printableMiddleSubs);
    }
  }



  /**
   * Test that invalid values are rejected.
   */
  @Test(expectedExceptions = DecodeException.class, dataProvider = "substringInvalidAttributeValues")
  public void substringInvalidAttributeValues(final String value)
      throws Exception
  {
    // Get the instance of the rule to be tested.
    final MatchingRule rule = getRule();

    rule.normalizeAttributeValue(ByteString.valueOf(value));
  }



  /**
   * Get an instance of the matching rule.
   *
   * @return An instance of the matching rule to test.
   */
  protected abstract MatchingRule getRule();
}