ConditionResultTestCase.java: Made checkstyle happy + fixed the tests faili...

Jean-Noel Rouvignac

14.28.2014 92c409112fc17e9dbd3908b5d0810d38a4edcc96

ConditionResultTestCase.java:
Made checkstyle happy + fixed the tests failing when run with Maven.

 opendj-core/src/test/java/org/forgerock/opendj/ldap/ConditionResultTestCase.java

@@ -26,7 +26,11 @@
 */
package org.forgerock.opendj.ldap;

import java.util.*;
import java.util.Arrays;
import java.util.ArrayList;
import java.util.EnumSet;
import java.util.Iterator;
import java.util.List;

import org.testng.annotations.DataProvider;
import org.testng.annotations.Test;
@@ -38,37 +42,31 @@
 * A set of test cases for the ConditionResult class.
 */
@SuppressWarnings("javadoc")
public class ConditionResultTestCase extends SdkTestCase
{
public class ConditionResultTestCase extends SdkTestCase {

  @DataProvider
  public Iterator<ConditionResult[]> allPermutationsUpTo4Operands()
  {
    public Iterator<Object[]> allPermutationsUpTo4Operands() {
    final ConditionResult[] values = ConditionResult.values();

    final List<ConditionResult[]> results = new ArrayList<ConditionResult[]>();
    results.add(new ConditionResult[0]);
    for (int arrayLength = 1; arrayLength <= 4; arrayLength++)
    {
        final List<Object[]> results = new ArrayList<Object[]>();
        results.add(new Object[] { new ConditionResult[0] });
        for (int arrayLength = 1; arrayLength <= 4; arrayLength++) {
      final ConditionResult[] template = new ConditionResult[arrayLength];
      allSubPermutations(values, results, template, 0, arrayLength);
    }
    return results.iterator();
  }

  private void allSubPermutations(final ConditionResult[] values,
      final List<ConditionResult[]> results, final ConditionResult[] template,
      int currentIndex, int endIndex)
  {
    if (currentIndex < endIndex)
    {
      for (ConditionResult r : values)
      {
    private void allSubPermutations(ConditionResult[] values, final List<Object[]> results,
            final ConditionResult[] template, int currentIndex, int endIndex) {
        if (currentIndex < endIndex) {
            for (ConditionResult r : values) {
        template[currentIndex] = r;
        allSubPermutations(values, results, template, currentIndex + 1, endIndex);
        if (currentIndex + 1 == endIndex)
        {
          results.add(Arrays.copyOf(template, template.length));
                if (currentIndex + 1 == endIndex) {
                    results.add(new Object[] {
                          Arrays.copyOf(template, template.length, ConditionResult[].class)
                    });
        }
      }
    }
@@ -78,25 +76,22 @@
   * Tests some basic assumptions of the enumeration.
   */
  @Test
  public void testBasic()
  {
    assertTrue(3 == values().length);
    public void testBasic() {
        assertEquals(values().length, 3);
    assertNotSame(TRUE, FALSE);
    assertNotSame(FALSE, UNDEFINED);
    assertNotSame(UNDEFINED, TRUE);
  }

  @Test
  public void testNot()
  {
    public void testNot() {
    assertEquals(not(FALSE), TRUE);
    assertEquals(not(TRUE), FALSE);
    assertEquals(not(UNDEFINED), UNDEFINED);
  }

  @Test
  public void testAnd()
  {
    public void testAnd() {
    assertEquals(and(), TRUE);

    assertEquals(and(TRUE), TRUE);
@@ -112,40 +107,31 @@
    assertAndIsCommutative(FALSE, UNDEFINED, FALSE);
  }

  private void assertAndIsCommutative(ConditionResult operand1,
      ConditionResult operand2, ConditionResult expectedResult)
  {
    private void assertAndIsCommutative(ConditionResult operand1, ConditionResult operand2,
            ConditionResult expectedResult) {
    assertEquals(and(operand1, operand2), expectedResult);
    assertEquals(and(operand2, operand1), expectedResult);
  }

  @Test(dataProvider = "allPermutationsUpTo4Operands")
  public void testVarargsAndIsCommutative(ConditionResult... operands)
  {
    if (operands.length == 0)
    {
    public void testVarargsAndIsCommutative(ConditionResult[] operands) {
        if (operands.length == 0) {
      assertEquals(and(operands), and());
      return;
    }

    final EnumSet<ConditionResult> ops = EnumSet.copyOf(Arrays.asList(operands));
    if (ops.contains(FALSE))
    {
        if (ops.contains(FALSE)) {
      assertEquals(and(operands), FALSE);
    }
    else if (ops.contains(UNDEFINED))
    {
        } else if (ops.contains(UNDEFINED)) {
      assertEquals(and(operands), UNDEFINED);
    }
    else
    {
        } else {
      assertEquals(and(operands), TRUE);
    }
  }

  @Test
  public void testOr()
  {
    public void testOr() {
    assertEquals(or(), FALSE);

    assertEquals(or(TRUE), TRUE);
@@ -161,47 +147,37 @@
    assertOrIsCommutative(FALSE, UNDEFINED, UNDEFINED);
  }

  private void assertOrIsCommutative(ConditionResult operand1,
      ConditionResult operand2, ConditionResult expectedResult)
  {
    private void assertOrIsCommutative(ConditionResult operand1, ConditionResult operand2,
            ConditionResult expectedResult) {
    assertEquals(or(operand1, operand2), expectedResult);
    assertEquals(or(operand2, operand1), expectedResult);
  }

  @Test(dataProvider = "allPermutationsUpTo4Operands")
  public void testVarargsOrIsCommutative(ConditionResult... operands)
  {
    if (operands.length == 0)
    {
    public void testVarargsOrIsCommutative(ConditionResult[] operands) {
        if (operands.length == 0) {
      assertEquals(or(operands), or());
      return;
    }

    final EnumSet<ConditionResult> ops = EnumSet.copyOf(Arrays.asList(operands));
    if (ops.contains(TRUE))
    {
        if (ops.contains(TRUE)) {
      assertEquals(or(operands), TRUE);
    }
    else if (ops.contains(UNDEFINED))
    {
        } else if (ops.contains(UNDEFINED)) {
      assertEquals(or(operands), UNDEFINED);
    }
    else
    {
        } else {
      assertEquals(or(operands), FALSE);
    }
  }

  @Test
  public void testValueOf()
  {
    public void testValueOf() {
    assertEquals(valueOf(true), TRUE);
    assertEquals(valueOf(false), FALSE);
  }

  @Test
  public void testToBoolean()
  {
    public void testToBoolean() {
    assertEquals(TRUE.toBoolean(), true);
    assertEquals(FALSE.toBoolean(), false);
    assertEquals(UNDEFINED.toBoolean(), false);