@Test
  public void testSpellPossibilityIterator() throws Exception {
    Map<Token, LinkedHashMap<String, Integer>> suggestions =
        new LinkedHashMap<Token, LinkedHashMap<String, Integer>>();
    suggestions.put(TOKEN_AYE, AYE);
    suggestions.put(TOKEN_BEE, BEE);
    suggestions.put(TOKEN_CEE, CEE);

    PossibilityIterator iter = new PossibilityIterator(suggestions, 1000, 10000, false);
    int count = 0;
    while (iter.hasNext()) {

      PossibilityIterator.RankedSpellPossibility rsp = iter.next();
      if (count == 0) {
        assertTrue("I".equals(rsp.corrections.get(0).getCorrection()));
        assertTrue("alpha".equals(rsp.corrections.get(1).getCorrection()));
        assertTrue("one".equals(rsp.corrections.get(2).getCorrection()));
      }
      count++;
    }
    assertTrue(
        ("Three maps (8*9*10) should return 720 iterations but instead returned " + count),
        count == 720);

    suggestions.remove(TOKEN_CEE);
    iter = new PossibilityIterator(suggestions, 100, 10000, false);
    count = 0;
    while (iter.hasNext()) {
      iter.next();
      count++;
    }
    assertTrue(
        ("Two maps (8*9) should return 72 iterations but instead returned " + count), count == 72);

    suggestions.remove(TOKEN_BEE);
    iter = new PossibilityIterator(suggestions, 5, 10000, false);
    count = 0;
    while (iter.hasNext()) {
      iter.next();
      count++;
    }
    assertTrue(("We requested 5 suggestions but got " + count), count == 5);

    suggestions.remove(TOKEN_AYE);
    iter = new PossibilityIterator(suggestions, Integer.MAX_VALUE, 10000, false);
    count = 0;
    while (iter.hasNext()) {
      iter.next();
      count++;
    }
    assertTrue(("No maps should return 0 iterations but instead returned " + count), count == 0);
  }
  @Test
  public void testOverlappingTokens() throws Exception {
    Map<Token, LinkedHashMap<String, Integer>> overlappingSuggestions =
        new LinkedHashMap<Token, LinkedHashMap<String, Integer>>();
    overlappingSuggestions.put(TOKEN_AYE, AYE);
    overlappingSuggestions.put(TOKEN_BEE, BEE);
    overlappingSuggestions.put(TOKEN_AYE_BEE, AYE_BEE);
    overlappingSuggestions.put(TOKEN_CEE, CEE);

    PossibilityIterator iter =
        new PossibilityIterator(overlappingSuggestions, Integer.MAX_VALUE, Integer.MAX_VALUE, true);
    int aCount = 0;
    int abCount = 0;
    Set<PossibilityIterator.RankedSpellPossibility> dupChecker =
        new HashSet<PossibilityIterator.RankedSpellPossibility>();
    while (iter.hasNext()) {
      PossibilityIterator.RankedSpellPossibility rsp = iter.next();
      Token a = null;
      Token b = null;
      Token ab = null;
      Token c = null;
      for (SpellCheckCorrection scc : rsp.corrections) {
        if (scc.getOriginal().equals(TOKEN_AYE)) {
          a = scc.getOriginal();
        } else if (scc.getOriginal().equals(TOKEN_BEE)) {
          b = scc.getOriginal();
        } else if (scc.getOriginal().equals(TOKEN_AYE_BEE)) {
          ab = scc.getOriginal();
        } else if (scc.getOriginal().equals(TOKEN_CEE)) {
          c = scc.getOriginal();
        }
        if (ab != null) {
          abCount++;
        } else {
          aCount++;
        }
      }
      assertTrue(c != null);
      assertTrue(ab != null || (a != null && b != null));
      assertTrue(ab == null || (a == null && b == null));
      assertTrue(dupChecker.add(rsp));
    }
    assertTrue(aCount == 2160);
    assertTrue(abCount == 180);
  }
  @Test
  public void testScalability() throws Exception {
    Map<Token, LinkedHashMap<String, Integer>> lotsaSuggestions =
        new LinkedHashMap<Token, LinkedHashMap<String, Integer>>();
    lotsaSuggestions.put(TOKEN_AYE, AYE);
    lotsaSuggestions.put(TOKEN_BEE, BEE);
    lotsaSuggestions.put(TOKEN_CEE, CEE);

    lotsaSuggestions.put(new Token("AYE1", 0, 3), AYE);
    lotsaSuggestions.put(new Token("BEE1", 4, 7), BEE);
    lotsaSuggestions.put(new Token("CEE1", 8, 11), CEE);

    lotsaSuggestions.put(new Token("AYE2", 0, 3), AYE);
    lotsaSuggestions.put(new Token("BEE2", 4, 7), BEE);
    lotsaSuggestions.put(new Token("CEE2", 8, 11), CEE);

    lotsaSuggestions.put(new Token("AYE3", 0, 3), AYE);
    lotsaSuggestions.put(new Token("BEE3", 4, 7), BEE);
    lotsaSuggestions.put(new Token("CEE3", 8, 11), CEE);

    lotsaSuggestions.put(new Token("AYE4", 0, 3), AYE);
    lotsaSuggestions.put(new Token("BEE4", 4, 7), BEE);
    lotsaSuggestions.put(new Token("CEE4", 8, 11), CEE);

    PossibilityIterator iter = new PossibilityIterator(lotsaSuggestions, 1000, 10000, false);
    int count = 0;
    while (iter.hasNext()) {
      PossibilityIterator.RankedSpellPossibility rsp = iter.next();
      count++;
    }
    assertTrue(count == 1000);

    lotsaSuggestions.put(new Token("AYE_BEE1", 0, 7), AYE_BEE);
    lotsaSuggestions.put(new Token("AYE_BEE2", 0, 7), AYE_BEE);
    lotsaSuggestions.put(new Token("AYE_BEE3", 0, 7), AYE_BEE);
    lotsaSuggestions.put(new Token("AYE_BEE4", 0, 7), AYE_BEE);
    iter = new PossibilityIterator(lotsaSuggestions, 1000, 10000, true);
    count = 0;
    while (iter.hasNext()) {
      PossibilityIterator.RankedSpellPossibility rsp = iter.next();
      count++;
    }
    assertTrue(count < 100);
  }