// Path: src/main/java/com/github/liblevenshtein/distance/IDistance.java
// public interface IDistance<Term> extends Serializable {
// 
//   /**
//    * Finds the distance between two terms, {@code v} and {@code w}. The distance
//    * between two terms is complemented by their similarity, which is determined
//    * by subtracting their distance from the maximum distance they may be apart.
//    * @param v Term to compare with {@code w}
//    * @param w Term to compare with {@code v}
//    * @return Distance between {@code v} and {@code w}
//    */
//   int between(Term v, Term w);
// }
// 
// Path: src/main/java/com/github/liblevenshtein/transducer/Algorithm.java
// public enum Algorithm {
// 
//   /**
//    * This is the standard, textbook version of Levenshtein distance. It includes
//    * support for the elementary operations of insertion, deletion and
//    * substitution.
//    */
//   STANDARD,
// 
//   /**
//    * Sometimes known as Damerau–Levenshtein distance, this includes the
//    * elementary operations described by the standard algorithm, as well as the
//    * elementary operation, transposition, which would incur a penalty of two
//    * units of error in the standard algorithm (whether it be an insertion and
//    * deletion, a deletion and insertion, or two substitutions). This algorithm
//    * is particularly useful in typed spelling-correction, where most spelling
//    * errors occur when a user transposes two characters.
//    */
//   TRANSPOSITION,
// 
//   /**
//    * This algorithm includes the elementary operations described by the basic
//    * algorithm, as well as the elementary operations, merge and split.  A merge
//    * occurs when two characters are joined together, and a split occurs when a
//    * single character is exploded into two characters. This algorithm is
//    * particularly useful in OCR applications, where one may read a "cl" when one
//    * should have read a "d" (i.e. merge), or when one may have read a "d" when
//    * one should have read a "cl" (i.e. split).
//    */
//   MERGE_AND_SPLIT;
// }
// 
// Path: src/test/java/com/github/liblevenshtein/assertion/DistanceAssertions.java
// public static <Type> DistanceAssertions<Type> assertThat(
//     final IDistance<Type> actual) {
//   return new DistanceAssertions<>(actual);
// }


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.DataProvider;
import org.testng.annotations.Test;
import com.github.liblevenshtein.distance.IDistance;
import com.github.liblevenshtein.transducer.Algorithm;
import static com.github.liblevenshtein.assertion.DistanceAssertions.assertThat;
      }

      this.terms = termsList;
      this.factory = new MemoizedDistanceFactory();
    }
  }

  @DataProvider(name = "equalSelfSimilarityData")
  public Iterator<Object[]> equalSelfSimilarityData() {
    return new EqualSelfSimilarityDataIterator(factory, terms);
  }

  @DataProvider(name = "minimalityData")
  public Iterator<Object[]> minimalityData() {
    return new MinimalityDataIterator(factory, terms);
  }

  @DataProvider(name = "symmetryData")
  public Iterator<Object[]> symmetryData() {
    return new SymmetryDataIterator(factory, terms);
  }

  @DataProvider(name = "triangleInequalityData")
  public Iterator<Object[]> triangleInequalityData() {
    return new TriangleInequalityDataIterator(factory, terms);
  }

  @DataProvider(name = "penaltyData")
  public Object[][] penaltyData() {
    return new Object[][] {
// Path: src/main/java/com/github/liblevenshtein/distance/IDistance.java
// public interface IDistance<Term> extends Serializable {
// 
//   /**
//    * Finds the distance between two terms, {@code v} and {@code w}. The distance
//    * between two terms is complemented by their similarity, which is determined
//    * by subtracting their distance from the maximum distance they may be apart.
//    * @param v Term to compare with {@code w}
//    * @param w Term to compare with {@code v}
//    * @return Distance between {@code v} and {@code w}
//    */
//   int between(Term v, Term w);
// }
// 
// Path: src/main/java/com/github/liblevenshtein/transducer/Algorithm.java
// public enum Algorithm {
// 
//   /**
//    * This is the standard, textbook version of Levenshtein distance. It includes
//    * support for the elementary operations of insertion, deletion and
//    * substitution.
//    */
//   STANDARD,
// 
//   /**
//    * Sometimes known as Damerau–Levenshtein distance, this includes the
//    * elementary operations described by the standard algorithm, as well as the
//    * elementary operation, transposition, which would incur a penalty of two
//    * units of error in the standard algorithm (whether it be an insertion and
//    * deletion, a deletion and insertion, or two substitutions). This algorithm
//    * is particularly useful in typed spelling-correction, where most spelling
//    * errors occur when a user transposes two characters.
//    */
//   TRANSPOSITION,
// 
//   /**
//    * This algorithm includes the elementary operations described by the basic
//    * algorithm, as well as the elementary operations, merge and split.  A merge
//    * occurs when two characters are joined together, and a split occurs when a
//    * single character is exploded into two characters. This algorithm is
//    * particularly useful in OCR applications, where one may read a "cl" when one
//    * should have read a "d" (i.e. merge), or when one may have read a "d" when
//    * one should have read a "cl" (i.e. split).
//    */
//   MERGE_AND_SPLIT;
// }
// 
// Path: src/test/java/com/github/liblevenshtein/assertion/DistanceAssertions.java
// public static <Type> DistanceAssertions<Type> assertThat(
//     final IDistance<Type> actual) {
//   return new DistanceAssertions<>(actual);
// }


// Path: src/test/java/com/github/liblevenshtein/distance/factory/MemoizedDistanceFactoryTest.java
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.DataProvider;
import org.testng.annotations.Test;
import com.github.liblevenshtein.distance.IDistance;
import com.github.liblevenshtein.transducer.Algorithm;
import static com.github.liblevenshtein.assertion.DistanceAssertions.assertThat;

      }

      this.terms = termsList;
      this.factory = new MemoizedDistanceFactory();
    }
  }

  @DataProvider(name = "equalSelfSimilarityData")
  public Iterator<Object[]> equalSelfSimilarityData() {
    return new EqualSelfSimilarityDataIterator(factory, terms);
  }

  @DataProvider(name = "minimalityData")
  public Iterator<Object[]> minimalityData() {
    return new MinimalityDataIterator(factory, terms);
  }

  @DataProvider(name = "symmetryData")
  public Iterator<Object[]> symmetryData() {
    return new SymmetryDataIterator(factory, terms);
  }

  @DataProvider(name = "triangleInequalityData")
  public Iterator<Object[]> triangleInequalityData() {
    return new TriangleInequalityDataIterator(factory, terms);
  }

  @DataProvider(name = "penaltyData")
  public Object[][] penaltyData() {
    return new Object[][] {
      {Algorithm.STANDARD, factory.build(Algorithm.STANDARD), 2, 2, 2},