@Test
  public void candidatesCountNoDuplicatesTest() {
    for (int parameters : new int[] {1, 2, 5}) {
      for (int choices : new int[] {1, 2, 5}) {
        for (int candidatesCount : new int[] {1, 10, 100}) {
          for (int steps : new int[] {0, 1, 10, 100}) {
            try {
              List<List<String>> input = GeneratorTestUtils.prepareInput(parameters, choices);
              AdaptiveRandomAlgorithm<String> algorithm =
                  new AdaptiveRandomAlgorithm<String>(0, candidatesCount, Integer.MAX_VALUE, false);
              algorithm.initialize(input, EMPTY_CONSTRAINTS);
              for (int i = 0; i < steps; i++) {
                algorithm.getNext();
              }

              List<List<String>> candidates = algorithm.getCandidates();
              assertTrue(candidates.size() <= candidatesCount);
            } catch (GeneratorException e) {
              fail("Unexpected GeneratorException: " + e.getMessage());
            }
          }
        }
      }
    }
  }
  @Test
  public void candidatesCountDuplicatesTest() {
    for (int parameters : new int[] {1, 2, 5}) {
      for (int choices : new int[] {1, 2, 5}) {
        for (int candidatesCount : new int[] {10, 100}) {
          for (int steps : new int[] {0, 1, 10, 100}) {
            try {
              //				System.out.println("parameters: " + parameters + ", choices: " + choices + ",
              // candidatesCount: " + candidatesCount + ", steps: " + steps);
              List<List<String>> input = GeneratorTestUtils.prepareInput(parameters, choices);
              AdaptiveRandomAlgorithm<String> algorithm =
                  new AdaptiveRandomAlgorithm<String>(0, candidatesCount, Integer.MAX_VALUE, true);
              algorithm.initialize(input, EMPTY_CONSTRAINTS);
              for (int i = 0; i < steps; i++) {
                algorithm.getNext();
              }

              List<List<String>> candidates = algorithm.getCandidates();
              assertEquals(Math.min(candidatesCount, productSize(input)), candidates.size());
            } catch (GeneratorException e) {
              fail("Unexpected GeneratorException: " + e.getMessage());
            }
          }
        }
      }
    }
  }
  @Test
  public void candidatesNoDuplicatesTest() {
    for (int parameters : new int[] {1, 2, 5}) {
      for (int choices : new int[] {1, 2, 5}) {
        for (int candidatesCount : new int[] {1, 10, 100, 1000}) {
          try {
            List<List<String>> input = GeneratorTestUtils.prepareInput(parameters, choices);
            AdaptiveRandomAlgorithm<String> algorithm =
                new AdaptiveRandomAlgorithm<String>(0, candidatesCount, Integer.MAX_VALUE, false);
            algorithm.initialize(input, EMPTY_CONSTRAINTS);

            List<List<String>> candidates = algorithm.getCandidates();
            Map<List<String>, Integer> histogram = createHistogram(candidates);
            for (int value : histogram.values()) {
              assertEquals(1, value);
            }

            for (List<String> candidate : candidates) {
              assertFalse(algorithm.getHistory().contains(candidate));
            }
          } catch (GeneratorException e) {
            fail("Unexpected GeneratorException: " + e.getMessage());
          }
        }
      }
    }
  }
  @Test
  public void optimalCandidateTest() {
    for (int historySize : new int[] {0, 1, 5, Integer.MAX_VALUE}) {
      for (int candidatesSize : new int[] {1, 10, 100}) {
        for (int length : new int[] {10000}) {
          for (boolean duplicates : new boolean[] {true, false}) {
            for (int parameters : new int[] {1, 2, 5}) {
              for (int choices : new int[] {1, 2, 5}) {
                try {
                  AdaptiveRandomAlgorithm<String> algorithm =
                      new AdaptiveRandomAlgorithm<String>(
                          historySize, candidatesSize, length, duplicates);
                  algorithm.initialize(
                      GeneratorTestUtils.prepareInput(parameters, choices), EMPTY_CONSTRAINTS);

                  List<List<String>> candidates = algorithm.getCandidates();
                  List<List<String>> history = algorithm.getCandidates();
                  List<String> optimalCandidate =
                      algorithm.getOptimalCandidate(candidates, history);

                  int optimalCandidateDistance = Integer.MAX_VALUE;
                  for (List<String> event : history) {
                    optimalCandidateDistance =
                        Math.min(
                            algorithm.distance(event, optimalCandidate), optimalCandidateDistance);
                  }
                  for (List<String> candidate : candidates) {
                    int candidateDistance = Integer.MAX_VALUE;
                    for (List<String> event : history) {
                      int eventDistance = algorithm.distance(candidate, event);
                      candidateDistance = Math.min(candidateDistance, eventDistance);
                    }
                    assertTrue(candidateDistance <= optimalCandidateDistance);
                  }
                } catch (GeneratorException e) {
                  fail("Unexpected GeneratorException: " + e.getMessage());
                }
              }
            }
          }
        }
      }
    }
  }
  @Test
  public void candidatesDuplicatesTest() {
    for (int parameters : new int[] {1, 2, 5}) {
      for (int choices : new int[] {1, 2, 5}) {
        for (int candidatesCount : new int[] {1, 10, 100, 1000}) {
          try {
            List<List<String>> input = GeneratorTestUtils.prepareInput(parameters, choices);
            AdaptiveRandomAlgorithm<String> algorithm =
                new AdaptiveRandomAlgorithm<String>(0, candidatesCount, Integer.MAX_VALUE, true);
            algorithm.initialize(input, EMPTY_CONSTRAINTS);

            List<List<String>> candidates = algorithm.getCandidates();
            assertEquals(candidates.size(), Math.min(candidatesCount, productSize(input)));
          } catch (GeneratorException e) {
            fail("Unexpected GeneratorException: " + e.getMessage());
          }
        }
      }
    }
  }
  @Test
  public void candidatesUniformityTest() {
    for (int parameters : new int[] {1, 2, 5}) {
      for (int choices : new int[] {1, 2, 5}) {
        for (int candidatesCount : new int[] {1, 10, 100}) {
          for (int steps : new int[] {0, 1, 10, 100, 1000}) {
            try {
              List<List<String>> input = GeneratorTestUtils.prepareInput(parameters, choices);
              AdaptiveRandomAlgorithm<String> algorithm =
                  new AdaptiveRandomAlgorithm<String>(0, candidatesCount, Integer.MAX_VALUE, true);
              algorithm.initialize(input, EMPTY_CONSTRAINTS);
              for (int i = 0; i < steps; i++) {
                algorithm.getNext();
              }

              List<List<String>> candidates = algorithm.getCandidates();
              if (sampleUniform(candidates, input) == false) {
                fail(
                    "Failed uniformity test for:\n"
                        + " parameters = "
                        + parameters
                        + "\nchoices = "
                        + choices
                        + "\ncandidatesCount = "
                        + candidatesCount
                        + "\nsteps = "
                        + steps);
              }
            } catch (GeneratorException e) {
              fail("Unexpected GeneratorException: " + e.getMessage());
            }
          }
        }
      }
    }
  }