diff: convert to kotlin
authorAleksey Pivovarov <AMPivovarov@gmail.com>
Mon, 24 Aug 2015 14:08:13 +0000 (17:08 +0300)
committerAleksey Pivovarov <AMPivovarov@gmail.com>
Mon, 24 Aug 2015 14:33:43 +0000 (17:33 +0300)
12 files changed:
platform/diff-impl/tests/com/intellij/diff/comparison/AutoTestCase.kt
platform/diff-impl/tests/com/intellij/diff/comparison/CharComparisonUtilTest.kt
platform/diff-impl/tests/com/intellij/diff/comparison/ComparisonUtilAutoTest.kt
platform/diff-impl/tests/com/intellij/diff/comparison/ComparisonUtilTest.kt
platform/diff-impl/tests/com/intellij/diff/comparison/ComparisonUtilTestBase.kt
platform/diff-impl/tests/com/intellij/diff/comparison/LineComparisonUtilTest.kt
platform/diff-impl/tests/com/intellij/diff/comparison/SplitComparisonUtilTest.kt
platform/diff-impl/tests/com/intellij/diff/comparison/WordComparisonUtilTest.kt
platform/diff-impl/tests/com/intellij/diff/tools/fragmented/LineNumberConvertorCorrectorTest.kt
platform/diff-impl/tests/com/intellij/diff/tools/fragmented/LineNumberConvertorTest.kt
platform/diff-impl/tests/com/intellij/diff/tools/fragmented/UnifiedFragmentBuilderAutoTest.kt
platform/diff-impl/tests/com/intellij/diff/tools/fragmented/UnifiedFragmentBuilderTest.kt

index ac78afb98444d1e0d19ce8921135648d4f10b1d4..eb3704f7ec7f57d17f83d826c18ce45f700702f0 100644 (file)
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package com.intellij.diff.comparison;
+package com.intellij.diff.comparison
 
-import com.intellij.openapi.editor.Document;
-import com.intellij.openapi.util.text.StringUtil;
-import com.intellij.testFramework.UsefulTestCase;
-import com.intellij.util.text.CharSequenceSubSequence;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
+import com.intellij.openapi.util.text.StringUtil
+import com.intellij.testFramework.UsefulTestCase
+import com.intellij.util.text.CharSequenceSubSequence
+import java.util.Random
+import java.util.concurrent.atomic.AtomicLong
+import kotlin.test.assertTrue
 
-import java.lang.reflect.Field;
-import java.util.Map;
-import java.util.Random;
-import java.util.concurrent.atomic.AtomicLong;
+public abstract class AutoTestCase : UsefulTestCase() {
+  protected val RNG: Random = Random()
 
-public abstract class AutoTestCase extends UsefulTestCase {
-  protected final Random myRng = new Random();
-  private long myLastSeed = -1;
-  private boolean myGotSeedException = false;
+  private var gotSeedException = false
 
-  @NotNull
-  protected String generateText(int maxLength, int charCount, @NotNull Map<Integer, Character> chars) {
-    int length = myRng.nextInt(maxLength + 1);
-    StringBuilder builder = new StringBuilder(length);
+  protected fun generateText(maxLength: Int, charCount: Int, predefinedChars: Map<Int, Char>): String {
+    val length = RNG.nextInt(maxLength + 1)
+    val builder = StringBuilder(length)
 
-    for (int i = 0; i < length; i++) {
-      int rnd = myRng.nextInt(charCount);
-      if (chars.containsKey(rnd)) {
-        builder.append(chars.get(rnd));
-      }
-      else {
-        builder.append((char)(rnd + 97));
-      }
+    for (i in 1..length) {
+      val rnd = RNG.nextInt(charCount)
+      val char = predefinedChars.get(rnd) ?: (rnd + 97).toChar();
+      builder.append(char)
     }
-
-    return builder.toString();
-  }
-
-  protected void rememberSeed() {
-    myLastSeed = getCurrentSeed();
+    return builder.toString()
   }
 
-  protected long getLastSeed() {
-    return myLastSeed;
-  }
-
-  protected long getCurrentSeed() {
-    if (myGotSeedException) return -1;
+  protected fun getCurrentSeed(): Long {
+    if (gotSeedException) return -1
     try {
-      Field seedField = myRng.getClass().getDeclaredField("seed");
-      seedField.setAccessible(true);
-      AtomicLong seedFieldValue = (AtomicLong)seedField.get(myRng);
-      return seedFieldValue.get() ^ 0x5DEECE66DL;
+      val seedField = RNG.javaClass.getDeclaredField("seed")
+      seedField.setAccessible(true)
+      val seedFieldValue = seedField.get(RNG) as AtomicLong
+      return seedFieldValue.get() xor 0x5DEECE66DL
     }
-    catch (Exception e) {
-      myGotSeedException = true;
-      System.err.println("Can't get random seed: " + e.getMessage());
-      return -1;
+    catch (e: Exception) {
+      gotSeedException = true
+      System.err.println("Can't get random seed: " + e.getMessage())
+      return -1
     }
   }
 
-  @NotNull
-  public static String textToReadableFormat(@Nullable Document text) {
-    if (text == null) return "null";
-    return "'" + text.getCharsSequence().toString().replace('\n', '*').replace('\t', '+') + "'";
+  public fun textToReadableFormat(text: CharSequence?): String {
+    if (text == null) return "null"
+    return "'" + text.toString().replace('\n', '*').replace('\t', '+') + "'"
   }
 
-  public static void assertEqualsCharSequences(@NotNull CharSequence chunk1, @NotNull CharSequence chunk2,
-                                               boolean ignoreSpaces, boolean skipLastNewline) {
+  public fun assertEqualsCharSequences(chunk1: CharSequence, chunk2: CharSequence, ignoreSpaces: Boolean, skipLastNewline: Boolean) {
     if (ignoreSpaces) {
-      assertTrue(StringUtil.equalsIgnoreWhitespaces(chunk1, chunk2));
+      assertTrue(StringUtil.equalsIgnoreWhitespaces(chunk1, chunk2))
     }
     else {
       if (skipLastNewline) {
-        CharSequence chunk12 = StringUtil.endsWithChar(chunk1, '\n') ? trimLastChar(chunk1) : null;
-        CharSequence chunk22 = StringUtil.endsWithChar(chunk2, '\n') ? trimLastChar(chunk2) : null;
-
-        if (StringUtil.equals(chunk1, chunk2)) return;
-        if (StringUtil.equals(chunk12, chunk2)) return;
-        if (StringUtil.equals(chunk1, chunk22)) return;
-
-        assertTrue(false);
+        if (StringUtil.equals(chunk1, chunk2)) return
+        if (StringUtil.equals(stripNewline(chunk1), chunk2)) return
+        if (StringUtil.equals(chunk1, stripNewline(chunk2))) return
+        assertTrue(false)
       }
       else {
-        assertTrue(StringUtil.equals(chunk1, chunk2));
+        assertTrue(StringUtil.equals(chunk1, chunk2))
       }
     }
   }
 
-  @NotNull
-  private static CharSequence trimLastChar(@NotNull CharSequence text) {
-    return new CharSequenceSubSequence(text, 0, text.length() - 1);
+  private fun stripNewline(text: CharSequence): CharSequence? {
+    return when (StringUtil.endsWithChar(text, '\n') ) {
+      true -> CharSequenceSubSequence(text, 0, text.length() - 1)
+      false -> null
+    }
   }
+
+  protected fun Int.until(a: Int): IntRange = this..a - 1
 }
index 24f6ae30d94eb182c2708d589fde60ca0d9495b1..57e8614b379b1dfc0c55f69d83e603945f5377b4 100644 (file)
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package com.intellij.diff.comparison;
-
-public class CharComparisonUtilTest extends ComparisonUtilTestBase {
-  public void testEqualStrings() {
-    TestData.chars("", "")
-      ._______Def_("", "")
-      .all();
-
-    TestData.chars("x", "x")
-      ._______Def_(" ", " ")
-      .all();
-
-    TestData.chars("x_y_z_", "x_y_z_")
-      ._______Def_("      ", "      ")
-      .all();
-
-    TestData.chars("_", "_")
-      ._______Def_(" ", " ")
-      .all();
-
-    TestData.chars("xxx", "xxx")
-      ._______Def_("   ", "   ")
-      .all();
-
-    TestData.chars("xyz", "xyz")
-      ._______Def_("   ", "   ")
-      .all();
-
-    TestData.chars(".x!", ".x!")
-      ._______Def_("   ", "   ")
-      .all();
+package com.intellij.diff.comparison
+
+public class CharComparisonUtilTest : ComparisonUtilTestBase() {
+  public fun testEqualStrings() {
+    chars {
+      ("" - "")
+      ("" - "").default()
+      testAll()
+    }
+
+    chars {
+      ("x" - "x")
+      (" " - " ").default()
+      testAll()
+    }
+
+    chars {
+      ("x_y_z_" - "x_y_z_")
+      ("      " - "      ").default()
+      testAll()
+    }
+
+    chars {
+      ("_" - "_")
+      (" " - " ").default()
+      testAll()
+    }
+
+    chars {
+      ("xxx" - "xxx")
+      ("   " - "   ").default()
+      testAll()
+    }
+
+    chars {
+      ("xyz" - "xyz")
+      ("   " - "   ").default()
+      testAll()
+    }
+
+    chars {
+      (".x!" - ".x!")
+      ("   " - "   ").default()
+      testAll()
+    }
   }
 
-  public void testTrivialCases() {
-    TestData.chars("x", "")
-      ._______Def_("-", "")
-      .all();
-
-    TestData.chars("", "x")
-      ._______Def_("", "-")
-      .all();
-
-    TestData.chars("x", "y")
-      ._______Def_("-", "-")
-      .all();
-
-    TestData.chars("x_", "")
-      ._______Def_("--", "")
-      .____Ignore_("- ", "")
-      .all();
-
-    TestData.chars("", "x_")
-      ._______Def_("", "--")
-      .____Ignore_("", "- ")
-      .all();
-
-    TestData.chars("x_", "y_")
-      ._______Def_("- ", "- ")
-      .all();
-
-    TestData.chars("_x", "_y")
-      ._______Def_(" -", " -")
-      .all();
+  public fun testTrivialCases() {
+    chars {
+      ("x" - "")
+      ("-" - "").default()
+      testAll()
+    }
+
+    chars {
+      ("" - "x")
+      ("" - "-").default()
+      testAll()
+    }
+
+    chars {
+      ("x" - "y")
+      ("-" - "-").default()
+      testAll()
+    }
+
+    chars {
+      ("x_" - "")
+      ("--" - "").default()
+      ("- " - "").ignore()
+      testAll()
+    }
+
+    chars {
+      ("" - "x_")
+      ("" - "--").default()
+      ("" - "- ").ignore()
+      testAll()
+    }
+
+    chars {
+      ("x_" - "y_")
+      ("- " - "- ").default()
+      testAll()
+    }
+
+    chars {
+      ("_x" - "_y")
+      (" -" - " -").default()
+      testAll()
+    }
   }
 
-  public void testSimpleCases() {
-    TestData.chars("xyx", "xxx")
-      ._______Def_(" - ", " - ")
-      .all();
-
-    TestData.chars("xyyx", "xmx")
-      ._______Def_(" -- ", " - ")
-      .all();
-
-    TestData.chars("xyy", "yyx")
-      ._______Def_("-  ", "  -")
-      .all();
-
-    TestData.chars("x!!", "!!x")
-      ._______Def_("-  ", "  -")
-      .all();
-
-    TestData.chars("xyx", "xx")
-      ._______Def_(" - ", "  ")
-      .all();
-
-    TestData.chars("xx", "xyx")
-      ._______Def_("  ", " - ")
-      .all();
-
-    TestData.chars("!...", "...!")
-      ._______Def_("-   ", "   -")
-      .all();
+  public fun testSimpleCases() {
+    chars {
+      ("xyx" - "xxx")
+      (" - " - " - ").default()
+      testAll()
+    }
+
+    chars {
+      ("xyyx" - "xmx")
+      (" -- " - " - ").default()
+      testAll()
+    }
+
+    chars {
+      ("xyy" - "yyx")
+      ("-  " - "  -").default()
+      testAll()
+    }
+
+    chars {
+      ("x!!" - "!!x")
+      ("-  " - "  -").default()
+      testAll()
+    }
+
+    chars {
+      ("xyx" - "xx")
+      (" - " - "  ").default()
+      testAll()
+    }
+
+    chars {
+      ("xx" - "xyx")
+      ("  " - " - ").default()
+      testAll()
+    }
+
+    chars {
+      ("!..." - "...!")
+      ("-   " - "   -").default()
+      testAll()
+    }
   }
 
-  public void testWhitespaceChangesOnly() {
-    TestData.chars(" x y z ", "xyz")
-      ._______Def_("- - - -", "   ")
-      .____Ignore_("       ", "   ")
-      .all();
-
-    TestData.chars("xyz", " x y z ")
-      ._______Def_("   ", "- - - -")
-      .____Ignore_("   ", "       ")
-      .all();
-
-    TestData.chars("x ", "x")
-      ._______Def_(" -", " ")
-      .____Ignore_("  ", " ")
-      .all();
-
-    TestData.chars("x", " x")
-      ._______Def_(" ", "- ")
-      .____Ignore_(" ", "  ")
-      .all();
-
-    TestData.chars(" x ", "x")
-      ._______Def_("- -", " ")
-      .____Ignore_("   ", " ")
-      .all();
-
-    TestData.chars("x", " x ")
-      ._______Def_(" ", "- -")
-      .____Ignore_(" ", "   ")
-      .all();
+  public fun testWhitespaceChangesOnly() {
+    chars {
+      (" x y z " - "xyz")
+      ("- - - -" - "   ").default()
+      ("       " - "   ").ignore()
+      testAll()
+    }
+
+    chars {
+      ("xyz" - " x y z ")
+      ("   " - "- - - -").default()
+      ("   " - "       ").ignore()
+      testAll()
+    }
+
+    chars {
+      ("x " - "x")
+      (" -" - " ").default()
+      ("  " - " ").ignore()
+      testAll()
+    }
+
+    chars {
+      ("x" - " x")
+      (" " - "- ").default()
+      (" " - "  ").ignore()
+      testAll()
+    }
+
+    chars {
+      (" x " - "x")
+      ("- -" - " ").default()
+      ("   " - " ").ignore()
+      testAll()
+    }
+
+    chars {
+      ("x" - " x ")
+      (" " - "- -").default()
+      (" " - "   ").ignore()
+      testAll()
+    }
   }
 
-  public void testWhitespaceChanges() {
-    TestData.chars(" x ", "z")
-      ._______Def_("---", "-")
-      .____Ignore_(" - ", "-")
-      .all();
-
-    TestData.chars("x", " z ")
-      ._______Def_("-", "---")
-      .____Ignore_("-", " - ")
-      .all();
-
-    TestData.chars(" x", "z\t")
-      ._______Def_("--", "--")
-      .____Ignore_(" -", "- ")
-      .all();
-
-    TestData.chars("x ", "\tz")
-      ._______Def_("--", "--")
-      .____Ignore_("- ", " -")
-      .all();
+  public fun testWhitespaceChanges() {
+    chars {
+      (" x " - "z")
+      ("---" - "-").default()
+      (" - " - "-").ignore()
+      testAll()
+    }
+
+    chars {
+      ("x" - " z ")
+      ("-" - "---").default()
+      ("-" - " - ").ignore()
+      testAll()
+    }
+
+    chars {
+      (" x" - "z\t")
+      ("--" - "--").default()
+      (" -" - "- ").ignore()
+      testAll()
+    }
+
+    chars {
+      ("x " - "\tz")
+      ("--" - "--").default()
+      ("- " - " -").ignore()
+      testAll()
+    }
   }
 
-  public void testIgnoreInnerWhitespaces() {
-    TestData.chars("x z y", "xmn")
-      ._______Def_(" ----", " --")
-      .____Ignore_("  ---", " --")
-      .all();
-
-    TestData.chars("x y z ", "x y m ")
-      ._______Def_("    - ", "    - ")
-      .all();
-
-    TestData.chars("x y z", "x y m ")
-      ._______Def_("    -", "    --")
-      .____Ignore_("    -", "    - ")
-      .all();
-
-    TestData.chars(" x y z", " m y z")
-      ._______Def_(" -    ", " -    ")
-      .all();
-
-    TestData.chars("x y z", " m y z")
-      ._______Def_("-    ", "--    ")
-      .____Ignore_("-    ", " -    ")
-      .all();
-
-    TestData.chars("x y z", "x m z")
-      ._______Def_("  -  ", "  -  ")
-      .all();
-
-    TestData.chars("x y z", "x  z")
-      ._______Def_("  -  ", "    ")
-      .all();
-
-    TestData.chars("x  z", "x m z")
-      ._______Def_("    ", "  -  ")
-      .all();
-
-    TestData.chars("x  z", "x n m z")
-      ._______Def_("    ", "  ---  ")
-      .all();
+  public fun testIgnoreInnerWhitespaces() {
+    chars {
+      ("x z y" - "xmn")
+      (" ----" - " --").default()
+      ("  ---" - " --").ignore()
+      testAll()
+    }
+
+    chars {
+      ("x y z " - "x y m ")
+      ("    - " - "    - ").default()
+      testAll()
+    }
+
+    chars {
+      ("x y z" - "x y m ")
+      ("    -" - "    --").default()
+      ("    -" - "    - ").ignore()
+      testAll()
+    }
+
+    chars {
+      (" x y z" - " m y z")
+      (" -    " - " -    ").default()
+      testAll()
+    }
+
+    chars {
+      ("x y z" - " m y z")
+      ("-    " - "--    ").default()
+      ("-    " - " -    ").ignore()
+      testAll()
+    }
+
+    chars {
+      ("x y z" - "x m z")
+      ("  -  " - "  -  ").default()
+      testAll()
+    }
+
+    chars {
+      ("x y z" - "x  z")
+      ("  -  " - "    ").default()
+      testAll()
+    }
+
+    chars {
+      ("x  z" - "x m z")
+      ("    " - "  -  ").default()
+      testAll()
+    }
+
+    chars {
+      ("x  z" - "x n m z")
+      ("    " - "  ---  ").default()
+      testAll()
+    }
   }
 
-  public void testEmptyRangePositions() {
-    TestData.chars("x y", "x zy")
-      ._Def_(ins(2, 2, 1))
-      .all();
-
-    TestData.chars("x y", "xz y")
-      ._Def_(ins(1, 1, 1))
-      .all();
-
-    TestData.chars("x y z", "x  z")
-      ._Def_(del(2, 2, 1))
-      .all();
-
-    TestData.chars("x  z", "x m z")
-      ._Def_(ins(2, 2, 1))
-      .all();
-
-    TestData.chars("xyx", "xx")
-      ._Def_(del(1, 1, 1))
-      .all();
-
-    TestData.chars("xx", "xyx")
-      ._Def_(ins(1, 1, 1))
-      .all();
-
-    TestData.chars("xy", "x")
-      ._Def_(del(1, 1, 1))
-      .all();
-
-    TestData.chars("x", "xy")
-      ._Def_(ins(1, 1, 1))
-      .all();
+  public fun testEmptyRangePositions() {
+    chars {
+      ("x y" - "x zy")
+      default(ins(2, 2, 1))
+      testAll()
+    }
+
+    chars {
+      ("x y" - "xz y")
+      default(ins(1, 1, 1))
+      testAll()
+    }
+
+    chars {
+      ("x y z" - "x  z")
+      default(del(2, 2, 1))
+      testAll()
+    }
+
+    chars {
+      ("x  z" - "x m z")
+      default(ins(2, 2, 1))
+      testAll()
+    }
+
+    chars {
+      ("xyx" - "xx")
+      default(del(1, 1, 1))
+      testAll()
+    }
+
+    chars {
+      ("xx" - "xyx")
+      default(ins(1, 1, 1))
+      testAll()
+    }
+
+    chars {
+      ("xy" - "x")
+      default(del(1, 1, 1))
+      testAll()
+    }
+
+    chars {
+      ("x" - "xy")
+      default(ins(1, 1, 1))
+      testAll()
+    }
   }
 
-  public void testAlgorithmSpecific() {
+  public fun testAlgorithmSpecific() {
     // This is a strange example: "ignore whitespace" produces lesser matching, than "Default".
     // This is fine, as the main goal of "ignore whitespaces" is to reduce 'noise' of diff, and 1 change is better than 3 changes
     // So we actually "ignore" whitespaces during comparison, rather than "mark all whitespaces as matched".
-    TestData.chars("x   y   z", "xX      Zz")
-      ._______Def_("    -    ", " -      - ")
-      .____Ignore_("    -    ", " -------- ")
-      .all();
+    chars {
+      ("x   y   z" - "xX      Zz")
+      ("    -    " - " -      - ").default()
+      ("    -    " - " -------- ").ignore()
+      testAll()
+    }
   }
 
-  public void testNonDeterministicCases() {
-    TestData.chars("x", "  ")
-      ._Def_(del(0, 0, 1))
-      .ignore();
-
-    TestData.chars("  ", "x")
-      ._Def_(ins(0, 0, 1))
-      ._Ignore_();
-
-    TestData.chars("x .. z", "x y .. z")
-      ._______Def_("      ", "  --    ")
-      .____Ignore_("      ", "  -     ")
-      ._Def_(ins(2, 2, 2))
-      ._Ignore_(ins(2, 2, 1))
-      .all();
-
-    TestData.chars(" x _ y _ z ", "x z")
-      ._______Def_("-  ------ -", "   ")
-      .____Ignore_("     -     ", "   ")
-      ._Def_(del(0, 0, 1), del(3, 2, 6), del(10, 3, 1))
-      ._Ignore_(del(5, 2, 1))
-      .all();
-
-    TestData.chars("x z", " x _ y _ z ")
-      ._______Def_("   ", "-  ------ -")
-      .____Ignore_("   ", "     -     ")
-      ._Def_(ins(0, 0, 1), ins(2, 3, 6), ins(3, 10, 1))
-      ._Ignore_(ins(2, 5, 1))
-      .all();
+  public fun testNonDeterministicCases() {
+    chars {
+      ("x" - "  ")
+      ignore(del(0, 0, 1))
+      testIgnore()
+    }
+
+    chars {
+      ("  " - "x")
+      ignore(ins(0, 0, 1))
+      testIgnore()
+    }
+
+    chars {
+      ("x .. z" - "x y .. z")
+      ("      " - "  --    ").default()
+      ("      " - "  -     ").ignore()
+      default(ins(2, 2, 2))
+      ignore(ins(2, 2, 1))
+      testAll()
+    }
+
+    chars {
+      (" x _ y _ z " - "x z")
+      ("-  ------ -" - "   ").default()
+      ("     -     " - "   ").ignore()
+      default(del(0, 0, 1), del(3, 2, 6), del(10, 3, 1))
+      ignore(del(5, 2, 1))
+      testAll()
+    }
+
+    chars {
+      ("x z" - " x _ y _ z ")
+      ("   " - "-  ------ -").default()
+      ("   " - "     -     ").ignore()
+      default(ins(0, 0, 1), ins(2, 3, 6), ins(3, 10, 1))
+      ignore(ins(2, 5, 1))
+      testAll()
+    }
   }
 }
index ea4f6297288fa7be225f7b5da458ccc1251024f2..429160191acdddbcb0d94c25b0539304c1837861 100644 (file)
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package com.intellij.diff.comparison;
-
-import com.intellij.diff.fragments.DiffFragment;
-import com.intellij.diff.fragments.LineFragment;
-import com.intellij.diff.util.DiffUtil;
-import com.intellij.openapi.editor.Document;
-import com.intellij.openapi.editor.impl.DocumentImpl;
-import com.intellij.openapi.progress.DumbProgressIndicator;
-import com.intellij.openapi.util.Couple;
-import com.intellij.openapi.util.Ref;
-import com.intellij.openapi.util.TextRange;
-import com.intellij.openapi.util.registry.Registry;
-import com.intellij.openapi.util.text.StringUtil;
-import com.intellij.util.containers.HashMap;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Map;
-
-@SuppressWarnings({"InstanceofCatchParameter"})
-public class ComparisonUtilAutoTest extends AutoTestCase {
-  private static DumbProgressIndicator INDICATOR = DumbProgressIndicator.INSTANCE;
-  private static ComparisonManager myComparisonManager = new ComparisonManagerImpl();
-
-  private static final int CHAR_COUNT = 12;
-  private static final Map<Integer, Character> CHAR_TABLE = initCharMap();
-
-  private boolean myOldRegistryValue;
-
-  @Override
-  public void setUp() throws Exception {
-    super.setUp();
-    myOldRegistryValue = Registry.get("diff.verify.iterable").asBoolean();
-    Registry.get("diff.verify.iterable").setValue(true);
+package com.intellij.diff.comparison
+
+import com.intellij.diff.fragments.DiffFragment
+import com.intellij.diff.fragments.LineFragment
+import com.intellij.diff.util.DiffUtil
+import com.intellij.openapi.editor.Document
+import com.intellij.openapi.editor.impl.DocumentImpl
+import com.intellij.openapi.progress.DumbProgressIndicator
+import com.intellij.openapi.util.Couple
+import com.intellij.openapi.util.Ref
+import com.intellij.openapi.util.registry.Registry
+import com.intellij.openapi.util.text.StringUtil
+import com.intellij.util.containers.HashMap
+import kotlin.test.assertEquals
+import kotlin.test.assertFalse
+import kotlin.test.assertTrue
+
+public class ComparisonUtilAutoTest : AutoTestCase() {
+  private var oldRegistryValue: Boolean = false
+
+  override fun setUp() {
+    super.setUp()
+    oldRegistryValue = REGISTRY.asBoolean()
+    REGISTRY.setValue(true)
   }
 
-  @Override
-  protected void tearDown() throws Exception {
-    Registry.get("diff.verify.iterable").setValue(myOldRegistryValue);
-    super.tearDown();
+  override fun tearDown() {
+    REGISTRY.setValue(oldRegistryValue)
+    super.tearDown()
   }
 
-  public void testChar() throws Exception {
-    doTestChar(System.currentTimeMillis(), 30, 30);
+  public fun testChar() {
+    doTestChar(System.currentTimeMillis(), 30, 30)
   }
 
-  public void testWord() throws Exception {
-    doTestWord(System.currentTimeMillis(), 30, 300);
+  public fun testWord() {
+    doTestWord(System.currentTimeMillis(), 30, 300)
   }
 
-  public void testLine() throws Exception {
-    doTestLine(System.currentTimeMillis(), 30, 300);
+  public fun testLine() {
+    doTestLine(System.currentTimeMillis(), 30, 300)
   }
 
-  public void testLineSquashed() throws Exception {
-    doTestLineSquashed(System.currentTimeMillis(), 30, 300);
+  public fun testLineSquashed() {
+    doTestLineSquashed(System.currentTimeMillis(), 30, 300)
   }
 
-  public void testLineTrimSquashed() throws Exception {
-    doTestLineTrimSquashed(System.currentTimeMillis(), 30, 300);
+  public fun testLineTrimSquashed() {
+    doTestLineTrimSquashed(System.currentTimeMillis(), 30, 300)
   }
 
-  private void doTestLine(long seed, int runs, int maxLength) throws Exception {
-    ComparisonPolicy[] policies = {ComparisonPolicy.DEFAULT, ComparisonPolicy.TRIM_WHITESPACES, ComparisonPolicy.IGNORE_WHITESPACES};
+  private fun doTestLine(seed: Long, runs: Int, maxLength: Int) {
+    val policies = listOf(ComparisonPolicy.DEFAULT, ComparisonPolicy.TRIM_WHITESPACES, ComparisonPolicy.IGNORE_WHITESPACES)
 
-    doTest(seed, runs, maxLength, policies, new TestTask() {
-      @Override
-      public void run(@NotNull Document text1, @NotNull Document text2, @NotNull ComparisonPolicy policy, @NotNull Ref<Object> debugData) {
-        CharSequence sequence1 = text1.getCharsSequence();
-        CharSequence sequence2 = text2.getCharsSequence();
+    doTest(seed, runs, maxLength, policies) { text1, text2, policy, debugData ->
+      val sequence1 = text1.getCharsSequence()
+      val sequence2 = text2.getCharsSequence()
 
-        List<LineFragment> fragments = myComparisonManager.compareLinesInner(sequence1, sequence2, policy, INDICATOR);
-        debugData.set(fragments);
+      val fragments = MANAGER.compareLinesInner(sequence1, sequence2, policy, INDICATOR)
+      debugData.set(fragments)
 
-        checkResultLine(text1, text2, fragments, policy, true);
-      }
-    });
+      checkResultLine(text1, text2, fragments, policy, true)
+    }
   }
 
-  private void doTestLineSquashed(long seed, int runs, int maxLength) throws Exception {
-    ComparisonPolicy[] policies = {ComparisonPolicy.DEFAULT, ComparisonPolicy.TRIM_WHITESPACES, ComparisonPolicy.IGNORE_WHITESPACES};
+  private fun doTestLineSquashed(seed: Long, runs: Int, maxLength: Int) {
+    val policies = listOf(ComparisonPolicy.DEFAULT, ComparisonPolicy.TRIM_WHITESPACES, ComparisonPolicy.IGNORE_WHITESPACES)
 
-    doTest(seed, runs, maxLength, policies, new TestTask() {
-      @Override
-      public void run(@NotNull Document text1, @NotNull Document text2, @NotNull ComparisonPolicy policy, @NotNull Ref<Object> debugData) {
-        CharSequence sequence1 = text1.getCharsSequence();
-        CharSequence sequence2 = text2.getCharsSequence();
+    doTest(seed, runs, maxLength, policies) { text1, text2, policy, debugData ->
+      val sequence1 = text1.getCharsSequence()
+      val sequence2 = text2.getCharsSequence()
 
-        List<LineFragment> fragments = myComparisonManager.compareLinesInner(sequence1, sequence2, policy, INDICATOR);
-        debugData.set(fragments);
+      val fragments = MANAGER.compareLinesInner(sequence1, sequence2, policy, INDICATOR)
+      debugData.set(fragments)
 
-        List<LineFragment> squashedFragments = myComparisonManager.squash(fragments);
-        debugData.set(new Object[]{fragments, squashedFragments});
+      val squashedFragments = MANAGER.squash(fragments)
+      debugData.set(listOf(fragments, squashedFragments))
 
-        checkResultLine(text1, text2, squashedFragments, policy, false);
-      }
-    });
+      checkResultLine(text1, text2, squashedFragments, policy, false)
+    }
   }
 
-  private void doTestLineTrimSquashed(long seed, int runs, int maxLength) throws Exception {
-    ComparisonPolicy[] policies = {ComparisonPolicy.DEFAULT, ComparisonPolicy.TRIM_WHITESPACES, ComparisonPolicy.IGNORE_WHITESPACES};
+  private fun doTestLineTrimSquashed(seed: Long, runs: Int, maxLength: Int) {
+    val policies = listOf(ComparisonPolicy.DEFAULT, ComparisonPolicy.TRIM_WHITESPACES, ComparisonPolicy.IGNORE_WHITESPACES)
 
-    doTest(seed, runs, maxLength, policies, new TestTask() {
-      @Override
-      public void run(@NotNull Document text1, @NotNull Document text2, @NotNull ComparisonPolicy policy, @NotNull Ref<Object> debugData) {
-        CharSequence sequence1 = text1.getCharsSequence();
-        CharSequence sequence2 = text2.getCharsSequence();
+    doTest(seed, runs, maxLength, policies) { text1, text2, policy, debugData ->
+      val sequence1 = text1.getCharsSequence()
+      val sequence2 = text2.getCharsSequence()
 
-        List<LineFragment> fragments = myComparisonManager.compareLinesInner(sequence1, sequence2, policy, INDICATOR);
-        debugData.set(fragments);
+      val fragments = MANAGER.compareLinesInner(sequence1, sequence2, policy, INDICATOR)
+      debugData.set(fragments)
 
-        List<LineFragment> processed = myComparisonManager.processBlocks(fragments, sequence1, sequence2, policy, true, true);
-        debugData.set(new Object[]{fragments, processed});
+      val processed = MANAGER.processBlocks(fragments, sequence1, sequence2, policy, true, true)
+      debugData.set(listOf(fragments, processed))
 
-        checkResultLine(text1, text2, processed, policy, false);
-      }
-    });
+      checkResultLine(text1, text2, processed, policy, false)
+    }
   }
 
-  private void doTestChar(long seed, int runs, int maxLength) throws Exception {
-    ComparisonPolicy[] policies = {ComparisonPolicy.DEFAULT, ComparisonPolicy.IGNORE_WHITESPACES};
+  private fun doTestChar(seed: Long, runs: Int, maxLength: Int) {
+    val policies = listOf(ComparisonPolicy.DEFAULT, ComparisonPolicy.IGNORE_WHITESPACES)
 
-    doTest(seed, runs, maxLength, policies, new TestTask() {
-      @Override
-      public void run(@NotNull Document text1, @NotNull Document text2, @NotNull ComparisonPolicy policy, @NotNull Ref<Object> debugData) {
-        CharSequence sequence1 = text1.getCharsSequence();
-        CharSequence sequence2 = text2.getCharsSequence();
+    doTest(seed, runs, maxLength, policies) { text1, text2, policy, debugData ->
+      val sequence1 = text1.getCharsSequence()
+      val sequence2 = text2.getCharsSequence()
 
-        List<DiffFragment> fragments = myComparisonManager.compareChars(sequence1, sequence2, policy, INDICATOR);
-        debugData.set(fragments);
+      val fragments = MANAGER.compareChars(sequence1, sequence2, policy, INDICATOR)
+      debugData.set(fragments)
 
-        checkResultChar(sequence1, sequence2, fragments, policy);
-      }
-    });
+      checkResultChar(sequence1, sequence2, fragments, policy)
+    }
   }
 
-  private void doTestWord(long seed, int runs, int maxLength) throws Exception {
-    ComparisonPolicy[] policies = {ComparisonPolicy.DEFAULT, ComparisonPolicy.TRIM_WHITESPACES, ComparisonPolicy.IGNORE_WHITESPACES};
+  private fun doTestWord(seed: Long, runs: Int, maxLength: Int) {
+    val policies = listOf(ComparisonPolicy.DEFAULT, ComparisonPolicy.TRIM_WHITESPACES, ComparisonPolicy.IGNORE_WHITESPACES)
 
-    doTest(seed, runs, maxLength, policies, new TestTask() {
-      @Override
-      public void run(@NotNull Document text1, @NotNull Document text2, @NotNull ComparisonPolicy policy, @NotNull Ref<Object> debugData) {
-        CharSequence sequence1 = text1.getCharsSequence();
-        CharSequence sequence2 = text2.getCharsSequence();
+    doTest(seed, runs, maxLength, policies) { text1, text2, policy, debugData ->
+      val sequence1 = text1.getCharsSequence()
+      val sequence2 = text2.getCharsSequence()
 
-        List<DiffFragment> fragments = myComparisonManager.compareWords(sequence1, sequence2, policy, INDICATOR);
-        debugData.set(fragments);
+      val fragments = MANAGER.compareWords(sequence1, sequence2, policy, INDICATOR)
+      debugData.set(fragments)
 
-        checkResultWord(sequence1, sequence2, fragments, policy);
-      }
-    });
+      checkResultWord(sequence1, sequence2, fragments, policy)
+    }
   }
 
-  private void doTest(long seed, int runs, int maxLength, @NotNull ComparisonPolicy[] policies, @NotNull TestTask test) throws Exception {
-    myRng.setSeed(seed);
+  private fun doTest(seed: Long, runs: Int, maxLength: Int, policies: List<ComparisonPolicy>,
+                     test: (Document, Document, ComparisonPolicy, Ref<Any>) -> Unit) {
+    RNG.setSeed(seed)
 
-    ComparisonPolicy policy = null;
-    Ref<Object> debugData = new Ref<Object>();
+    var policy: ComparisonPolicy? = null
+    var lastSeed: Long = -1;
+    val debugData = Ref<Any>()
 
-    for (int i = 1; i <= runs; i++) {
-      if (i % 1000 == 0) System.out.println(i);
-      Document text1 = null;
-      Document text2 = null;
+    for (i in 1..runs) {
+      if (i % 1000 == 0) println(i)
+      var text1: Document? = null
+      var text2: Document? = null
       try {
-        rememberSeed();
+        lastSeed = getCurrentSeed()
 
-        text1 = generateText(maxLength);
-        text2 = generateText(maxLength);
+        text1 = generateText(maxLength)
+        text2 = generateText(maxLength)
 
-        for (ComparisonPolicy comparisonPolicy : policies) {
-          policy = comparisonPolicy;
-          test.run(text1, text2, comparisonPolicy, debugData);
+        for (comparisonPolicy in policies) {
+          policy = comparisonPolicy
+          test(text1, text2, comparisonPolicy, debugData)
         }
       }
-      catch (Throwable e) {
-        System.out.println("Seed: " + seed);
-        System.out.println("Runs: " + runs);
-        System.out.println("MaxLength: " + maxLength);
-        System.out.println("Policy: " + policy);
-        System.out.println("I: " + i);
-        System.out.println("Current seed: " + getLastSeed());
-        System.out.println("Text1: " + textToReadableFormat(text1));
-        System.out.println("Text2: " + textToReadableFormat(text2));
-        System.out.println("Debug Data: " + debugData.get());
-        if (e instanceof Error) throw (Error)e;
-        if (e instanceof Exception) throw (Exception)e;
-        throw new Exception(e);
+      catch (e: Throwable) {
+        println("Seed: " + seed)
+        println("Runs: " + runs)
+        println("MaxLength: " + maxLength)
+        println("Policy: " + policy!!)
+        println("I: " + i)
+        println("Current seed: " + lastSeed)
+        println("Text1: " + textToReadableFormat(text1?.getCharsSequence()))
+        println("Text2: " + textToReadableFormat(text2?.getCharsSequence()))
+        println("Debug Data: " + debugData.get())
+        throw e
       }
     }
   }
 
-  private static void checkResultLine(@NotNull Document text1, @NotNull Document text2,
-                                      @NotNull List<LineFragment> fragments,
-                                      @NotNull ComparisonPolicy policy,
-                                      boolean allowNonSquashed) {
-    checkLineConsistency(text1, text2, fragments, allowNonSquashed);
+  private fun generateText(maxLength: Int): Document {
+    return DocumentImpl(generateText(maxLength, CHAR_COUNT, CHAR_TABLE))
+  }
+
+  private fun checkResultLine(text1: Document, text2: Document, fragments: List<LineFragment>, policy: ComparisonPolicy, allowNonSquashed: Boolean) {
+    checkLineConsistency(text1, text2, fragments, allowNonSquashed)
 
-    for (LineFragment fragment : fragments) {
+    for (fragment in fragments) {
       if (fragment.getInnerFragments() != null) {
-        CharSequence sequence1 = subsequence(text1, fragment.getStartOffset1(), fragment.getEndOffset1());
-        CharSequence sequence2 = subsequence(text2, fragment.getStartOffset2(), fragment.getEndOffset2());
+        val sequence1 = text1.subsequence(fragment.getStartOffset1(), fragment.getEndOffset1())
+        val sequence2 = text2.subsequence(fragment.getStartOffset2(), fragment.getEndOffset2())
 
-        checkResultWord(sequence1, sequence2, fragment.getInnerFragments(), policy);
+        checkResultWord(sequence1, sequence2, fragment.getInnerFragments(), policy)
       }
     }
 
-    checkUnchanged(text1.getCharsSequence(), text2.getCharsSequence(), fragments, policy, true);
-    checkCantTrimLines(text1, text2, fragments, policy, allowNonSquashed);
+    checkUnchanged(text1.getCharsSequence(), text2.getCharsSequence(), fragments, policy, true)
+    checkCantTrimLines(text1, text2, fragments, policy, allowNonSquashed)
   }
 
-  private static void checkResultWord(@NotNull CharSequence text1, @NotNull CharSequence text2,
-                                      @NotNull List<DiffFragment> fragments,
-                                      @NotNull ComparisonPolicy policy) {
-    checkDiffConsistency(fragments);
+  private fun checkResultWord(text1: CharSequence, text2: CharSequence, fragments: List<DiffFragment>, policy: ComparisonPolicy) {
+    checkDiffConsistency(fragments)
 
-    checkUnchanged(text1, text2, fragments, policy, false);
+    checkUnchanged(text1, text2, fragments, policy, false)
   }
 
-  private static void checkResultChar(@NotNull CharSequence text1, @NotNull CharSequence text2,
-                                      @NotNull List<DiffFragment> fragments,
-                                      @NotNull ComparisonPolicy policy) {
-    checkDiffConsistency(fragments);
+  private fun checkResultChar(text1: CharSequence, text2: CharSequence, fragments: List<DiffFragment>, policy: ComparisonPolicy) {
+    checkDiffConsistency(fragments)
 
-    checkUnchanged(text1, text2, fragments, policy, false);
+    checkUnchanged(text1, text2, fragments, policy, false)
   }
 
-  private static void checkLineConsistency(@NotNull Document text1, @NotNull Document text2,
-                                           @NotNull List<LineFragment> fragments,
-                                           boolean allowNonSquashed) {
-    int last1 = -1;
-    int last2 = -1;
+  private fun checkLineConsistency(text1: Document, text2: Document, fragments: List<LineFragment>, allowNonSquashed: Boolean) {
+    var last1 = -1
+    var last2 = -1
 
-    for (LineFragment fragment : fragments) {
-      int startOffset1 = fragment.getStartOffset1();
-      int startOffset2 = fragment.getStartOffset2();
-      int endOffset1 = fragment.getEndOffset1();
-      int endOffset2 = fragment.getEndOffset2();
+    for (fragment in fragments) {
+      val startOffset1 = fragment.getStartOffset1()
+      val startOffset2 = fragment.getStartOffset2()
+      val endOffset1 = fragment.getEndOffset1()
+      val endOffset2 = fragment.getEndOffset2()
 
-      int start1 = fragment.getStartLine1();
-      int start2 = fragment.getStartLine2();
-      int end1 = fragment.getEndLine1();
-      int end2 = fragment.getEndLine2();
+      val start1 = fragment.getStartLine1()
+      val start2 = fragment.getStartLine2()
+      val end1 = fragment.getEndLine1()
+      val end2 = fragment.getEndLine2()
 
-      assertTrue(startOffset1 >= 0);
-      assertTrue(startOffset2 >= 0);
-      assertTrue(endOffset1 <= text1.getTextLength());
-      assertTrue(endOffset2 <= text2.getTextLength());
+      assertTrue(startOffset1 >= 0)
+      assertTrue(startOffset2 >= 0)
+      assertTrue(endOffset1 <= text1.getTextLength())
+      assertTrue(endOffset2 <= text2.getTextLength())
 
-      assertTrue(start1 >= 0);
-      assertTrue(start2 >= 0);
-      assertTrue(end1 <= getLineCount(text1));
-      assertTrue(end2 <= getLineCount(text2));
+      assertTrue(start1 >= 0)
+      assertTrue(start2 >= 0)
+      assertTrue(end1 <= getLineCount(text1))
+      assertTrue(end2 <= getLineCount(text2))
 
-      assertTrue(startOffset1 <= endOffset1);
-      assertTrue(startOffset2 <= endOffset2);
+      assertTrue(startOffset1 <= endOffset1)
+      assertTrue(startOffset2 <= endOffset2)
 
-      assertTrue(start1 <= end1);
-      assertTrue(start2 <= end2);
-      assertTrue(start1 != end1 || start2 != end2);
+      assertTrue(start1 <= end1)
+      assertTrue(start2 <= end2)
+      assertTrue(start1 != end1 || start2 != end2)
 
-      assertTrue(allowNonSquashed || start1 != last1 || start2 != last2);
+      assertTrue(allowNonSquashed || start1 != last1 || start2 != last2)
 
-      checkLineOffsets(fragment, text1, text2);
+      checkLineOffsets(fragment, text1, text2)
 
-      last1 = end1;
-      last2 = end2;
+      last1 = end1
+      last2 = end2
     }
   }
 
-  private static void checkDiffConsistency(@NotNull List<? extends DiffFragment> fragments) {
-    int last1 = -1;
-    int last2 = -1;
+  private fun checkDiffConsistency(fragments: List<DiffFragment>) {
+    var last1 = -1
+    var last2 = -1
 
-    for (DiffFragment diffFragment : fragments) {
-      int start1 = diffFragment.getStartOffset1();
-      int start2 = diffFragment.getStartOffset2();
-      int end1 = diffFragment.getEndOffset1();
-      int end2 = diffFragment.getEndOffset2();
+    for (diffFragment in fragments) {
+      val start1 = diffFragment.getStartOffset1()
+      val start2 = diffFragment.getStartOffset2()
+      val end1 = diffFragment.getEndOffset1()
+      val end2 = diffFragment.getEndOffset2()
 
-      assertTrue(start1 <= end1);
-      assertTrue(start2 <= end2);
-      assertTrue(start1 != end1 || start2 != end2);
+      assertTrue(start1 <= end1)
+      assertTrue(start2 <= end2)
+      assertTrue(start1 != end1 || start2 != end2)
 
-      assertTrue(start1 != last1 || start2 != last2);
+      assertTrue(start1 != last1 || start2 != last2)
 
-      last1 = end1;
-      last2 = end2;
+      last1 = end1
+      last2 = end2
     }
   }
 
-  private static void checkLineOffsets(@NotNull LineFragment fragment, @NotNull Document before, @NotNull Document after) {
-    checkLineOffsets(before, fragment.getStartLine1(), fragment.getEndLine1(),
-                     fragment.getStartOffset1(), fragment.getEndOffset1());
+  private fun checkLineOffsets(fragment: LineFragment, before: Document, after: Document) {
+    checkLineOffsets(before, fragment.getStartLine1(), fragment.getEndLine1(), fragment.getStartOffset1(), fragment.getEndOffset1())
 
-    checkLineOffsets(after, fragment.getStartLine2(), fragment.getEndLine2(),
-                     fragment.getStartOffset2(), fragment.getEndOffset2());
+    checkLineOffsets(after, fragment.getStartLine2(), fragment.getEndLine2(), fragment.getStartOffset2(), fragment.getEndOffset2())
   }
 
-  private static void checkLineOffsets(@NotNull Document document,
-                                       int startLine, int endLine,
-                                       int startOffset, int endOffset) {
+  private fun checkLineOffsets(document: Document, startLine: Int, endLine: Int, startOffset: Int, endOffset: Int) {
     if (startLine != endLine) {
-      assertEquals(document.getLineStartOffset(startLine), startOffset);
-      int offset = document.getLineEndOffset(endLine - 1);
-      if (offset < document.getTextLength()) offset++;
-      assertEquals(offset, endOffset);
+      assertEquals(document.getLineStartOffset(startLine), startOffset)
+      var offset = document.getLineEndOffset(endLine - 1)
+      if (offset < document.getTextLength()) offset++
+      assertEquals(offset, endOffset)
     }
     else {
-      int offset = startLine == getLineCount(document)
-                   ? document.getTextLength()
-                   : document.getLineStartOffset(startLine);
-      assertEquals(offset, startOffset);
-      assertEquals(offset, endOffset);
+      val offset = if (startLine == getLineCount(document))
+        document.getTextLength()
+      else
+        document.getLineStartOffset(startLine)
+      assertEquals(offset, startOffset)
+      assertEquals(offset, endOffset)
     }
   }
 
-  private static void checkUnchanged(@NotNull CharSequence text1, @NotNull CharSequence text2,
-                                     @NotNull List<? extends DiffFragment> fragments,
-                                     @NotNull ComparisonPolicy policy,
-                                     boolean skipNewline) {
+  private fun checkUnchanged(text1: CharSequence, text2: CharSequence, fragments: List<DiffFragment>, policy: ComparisonPolicy, skipNewline: Boolean) {
     // TODO: better check for Trim spaces case ?
-    boolean ignoreSpaces = policy != ComparisonPolicy.DEFAULT;
+    val ignoreSpaces = policy !== ComparisonPolicy.DEFAULT
 
-    int last1 = 0;
-    int last2 = 0;
-    for (DiffFragment fragment : fragments) {
-      CharSequence chunk1 = text1.subSequence(last1, fragment.getStartOffset1());
-      CharSequence chunk2 = text2.subSequence(last2, fragment.getStartOffset2());
+    var last1 = 0
+    var last2 = 0
+    for (fragment in fragments) {
+      val chunk1 = text1.subSequence(last1, fragment.getStartOffset1())
+      val chunk2 = text2.subSequence(last2, fragment.getStartOffset2())
 
-      assertEqualsCharSequences(chunk1, chunk2, ignoreSpaces, skipNewline);
+      assertEqualsCharSequences(chunk1, chunk2, ignoreSpaces, skipNewline)
 
-      last1 = fragment.getEndOffset1();
-      last2 = fragment.getEndOffset2();
+      last1 = fragment.getEndOffset1()
+      last2 = fragment.getEndOffset2()
     }
-    CharSequence chunk1 = text1.subSequence(last1, text1.length());
-    CharSequence chunk2 = text2.subSequence(last2, text2.length());
-    assertEqualsCharSequences(chunk1, chunk2, ignoreSpaces, skipNewline);
+    val chunk1 = text1.subSequence(last1, text1.length())
+    val chunk2 = text2.subSequence(last2, text2.length())
+    assertEqualsCharSequences(chunk1, chunk2, ignoreSpaces, skipNewline)
   }
 
-  private static void checkCantTrimLines(@NotNull Document text1, @NotNull Document text2,
-                                         @NotNull List<? extends LineFragment> fragments,
-                                         @NotNull ComparisonPolicy policy, boolean allowNonSquashed) {
-    for (LineFragment fragment : fragments) {
-      Couple<CharSequence> sequence1 = getFirstLastLines(text1, fragment.getStartLine1(), fragment.getEndLine1());
-      Couple<CharSequence> sequence2 = getFirstLastLines(text2, fragment.getStartLine2(), fragment.getEndLine2());
-      if (sequence1 == null || sequence2 == null) continue;
+  private fun checkCantTrimLines(text1: Document, text2: Document, fragments: List<LineFragment>, policy: ComparisonPolicy, allowNonSquashed: Boolean) {
+    for (fragment in fragments) {
+      val sequence1 = getFirstLastLines(text1, fragment.getStartLine1(), fragment.getEndLine1())
+      val sequence2 = getFirstLastLines(text2, fragment.getStartLine2(), fragment.getEndLine2())
+      if (sequence1 == null || sequence2 == null) continue
 
-      checkNonEqualsIfLongEnough(sequence1.first, sequence2.first, policy, allowNonSquashed);
-      checkNonEqualsIfLongEnough(sequence1.second, sequence2.second, policy, allowNonSquashed);
+      checkNonEqualsIfLongEnough(sequence1.first, sequence2.first, policy, allowNonSquashed)
+      checkNonEqualsIfLongEnough(sequence1.second, sequence2.second, policy, allowNonSquashed)
     }
   }
 
-  private static void checkNonEqualsIfLongEnough(@NotNull CharSequence line1, @NotNull CharSequence line2,
-                                                 @NotNull ComparisonPolicy policy, boolean allowNonSquashed) {
+  private fun checkNonEqualsIfLongEnough(line1: CharSequence, line2: CharSequence, policy: ComparisonPolicy, allowNonSquashed: Boolean) {
     // in non-squashed blocks non-trimmed elements are possible, if it's 'unimportant' lines
-    if (allowNonSquashed && countNonWhitespaceCharacters(line1) <= Registry.get("diff.unimportant.line.char.count").asInteger()) return;
-    if (allowNonSquashed && countNonWhitespaceCharacters(line2) <= Registry.get("diff.unimportant.line.char.count").asInteger()) return;
+    if (allowNonSquashed && countNonWhitespaceCharacters(line1) <= Registry.get("diff.unimportant.line.char.count").asInteger()) return
+    if (allowNonSquashed && countNonWhitespaceCharacters(line2) <= Registry.get("diff.unimportant.line.char.count").asInteger()) return
 
-    assertFalse(myComparisonManager.isEquals(line1, line2, policy));
+    assertFalse(MANAGER.isEquals(line1, line2, policy))
   }
 
-  private static int countNonWhitespaceCharacters(@NotNull CharSequence line) {
-    int count = 0;
-    for (int i = 0; i < line.length(); i++) {
-      if (!StringUtil.isWhiteSpace(line.charAt(i))) count++;
+  private fun countNonWhitespaceCharacters(line: CharSequence): Int {
+    var count = 0
+    for (i in 0 until line.length()) {
+      if (!StringUtil.isWhiteSpace(line.charAt(i))) count++
     }
-    return count;
+    return count
   }
 
-  @Nullable
-  private static Couple<CharSequence> getFirstLastLines(@NotNull Document text, int start, int end) {
-    if (start == end) return null;
+  private fun getFirstLastLines(text: Document, start: Int, end: Int): Couple<CharSequence>? {
+    if (start == end) return null
 
-    TextRange firstLineRange = DiffUtil.getLinesRange(text, start, start + 1);
-    TextRange lastLineRange = DiffUtil.getLinesRange(text, end - 1, end);
+    val firstLineRange = DiffUtil.getLinesRange(text, start, start + 1)
+    val lastLineRange = DiffUtil.getLinesRange(text, end - 1, end)
 
-    CharSequence firstLine = firstLineRange.subSequence(text.getCharsSequence());
-    CharSequence lastLine = lastLineRange.subSequence(text.getCharsSequence());
+    val firstLine = firstLineRange.subSequence(text.getCharsSequence())
+    val lastLine = lastLineRange.subSequence(text.getCharsSequence())
 
-    return Couple.of(firstLine, lastLine);
+    return Couple.of(firstLine, lastLine)
   }
 
-  @NotNull
-  private Document generateText(int maxLength) {
-    return new DocumentImpl(generateText(maxLength, CHAR_COUNT, CHAR_TABLE));
+  private fun Document.subsequence(start: Int, end: Int): CharSequence {
+    return this.getCharsSequence().subSequence(start, end)
   }
 
-  @NotNull
-  private static Map<Integer, Character> initCharMap() {
-    Map<Integer, Character> map = new HashMap<Integer, Character>();
-
-    List<Character> characters = new ArrayList<Character>();
-    characters.add('\n');
-    characters.add('\n');
-    characters.add('\t');
-    characters.add(' ');
-    characters.add(' ');
-    characters.add('.');
-    characters.add('<');
-    characters.add('!');
-
-    for (int i = 0; i < characters.size(); i++) {
-      map.put(i, characters.get(i));
-    }
-
-    return map;
+  private fun getLineCount(document: Document): Int {
+    return Math.max(1, document.getLineCount())
   }
 
-  @NotNull
-  private static CharSequence subsequence(@NotNull Document document, int start, int end) {
-    return document.getCharsSequence().subSequence(start, end);
-  }
+  companion object {
+    private val REGISTRY = Registry.get("diff.verify.iterable");
 
-  private static int getLineCount(@NotNull Document document) {
-    return Math.max(1, document.getLineCount());
-  }
+    private val INDICATOR = DumbProgressIndicator.INSTANCE
+    private val MANAGER = ComparisonManagerImpl()
 
-  private interface TestTask {
-    void run(@NotNull Document text1, @NotNull Document text2, @NotNull ComparisonPolicy policy, @NotNull Ref<Object> debugData);
+    private val CHAR_COUNT = 12
+    private val CHAR_TABLE: Map<Int, Char> = {
+      val map = HashMap<Int, Char>()
+      listOf('\n', '\n', '\t', ' ', ' ', '.', '<', '!').forEachIndexed { i, c -> map.put(i, c) }
+      map
+    }()
   }
 }
index fe71a6b26b1ec6285032684c6d878d1cec5b7092..2ae19f30b3fe14a1c84310926ab932fd4bcc37b8 100644 (file)
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package com.intellij.diff.comparison;
-
-import com.intellij.testFramework.UsefulTestCase;
-
-public class ComparisonUtilTest extends UsefulTestCase {
-  private static final ComparisonManager manager = new ComparisonManagerImpl();
-
-  public void testTrimEquals() {
-    assertTrue(manager.isEquals("", "", ComparisonPolicy.TRIM_WHITESPACES));
-    assertTrue(manager.isEquals("", "   ", ComparisonPolicy.TRIM_WHITESPACES));
-    assertTrue(manager.isEquals("   ", "   ", ComparisonPolicy.TRIM_WHITESPACES));
-    assertTrue(manager.isEquals("\n   ", "  \n", ComparisonPolicy.TRIM_WHITESPACES));
-    assertTrue(manager.isEquals("asd ", "asd  ", ComparisonPolicy.TRIM_WHITESPACES));
-    assertTrue(manager.isEquals("    asd", "asd", ComparisonPolicy.TRIM_WHITESPACES));
-    assertTrue(manager.isEquals("\n\n\n", "\n\n\n", ComparisonPolicy.TRIM_WHITESPACES));
-    assertTrue(manager.isEquals("\n  \n  \n ", "  \n \n\n  ", ComparisonPolicy.TRIM_WHITESPACES));
-    assertFalse(manager.isEquals("\n\n", "\n\n\n", ComparisonPolicy.TRIM_WHITESPACES));
-
-    assertFalse(manager.isEquals("\nasd ", "asd\n  ", ComparisonPolicy.TRIM_WHITESPACES));
-    assertTrue(manager.isEquals("\nasd \n", "\n asd\n  ", ComparisonPolicy.TRIM_WHITESPACES));
-    assertFalse(manager.isEquals("x", "y", ComparisonPolicy.TRIM_WHITESPACES));
-    assertFalse(manager.isEquals("\n", " ", ComparisonPolicy.TRIM_WHITESPACES));
-
-    assertTrue(manager.isEquals("\t ", "", ComparisonPolicy.TRIM_WHITESPACES));
-    assertFalse(manager.isEquals("", "\t\n \n\t", ComparisonPolicy.TRIM_WHITESPACES));
-    assertFalse(manager.isEquals("\t", "\n", ComparisonPolicy.TRIM_WHITESPACES));
-
-    assertTrue(manager.isEquals("x", " x", ComparisonPolicy.TRIM_WHITESPACES));
-    assertTrue(manager.isEquals("x", "x ", ComparisonPolicy.TRIM_WHITESPACES));
-    assertFalse(manager.isEquals("x\n", "x", ComparisonPolicy.TRIM_WHITESPACES));
-
-    assertFalse(manager.isEquals("abc", "a\nb\nc\n", ComparisonPolicy.TRIM_WHITESPACES));
-    assertTrue(manager.isEquals("\nx y x\n", "\nx y x\n", ComparisonPolicy.TRIM_WHITESPACES));
-    assertFalse(manager.isEquals("\nxyx\n", "\nx y x\n", ComparisonPolicy.TRIM_WHITESPACES));
-    assertTrue(manager.isEquals("\nx y x", "\nx y x", ComparisonPolicy.TRIM_WHITESPACES));
-    assertFalse(manager.isEquals("\nxyx", "\nx y x", ComparisonPolicy.TRIM_WHITESPACES));
-    assertTrue(manager.isEquals("x y x", "x y x", ComparisonPolicy.TRIM_WHITESPACES));
-    assertFalse(manager.isEquals("xyx", "x y x", ComparisonPolicy.TRIM_WHITESPACES));
-    assertTrue(manager.isEquals("  x y x  ", "x y x", ComparisonPolicy.TRIM_WHITESPACES));
-
-    assertFalse(manager.isEquals("x", "\t\n ", ComparisonPolicy.TRIM_WHITESPACES));
-    assertFalse(manager.isEquals("", " x ", ComparisonPolicy.TRIM_WHITESPACES));
-    assertFalse(manager.isEquals("", "x ", ComparisonPolicy.TRIM_WHITESPACES));
-    assertFalse(manager.isEquals("", " x", ComparisonPolicy.TRIM_WHITESPACES));
-    assertFalse(manager.isEquals("xyx", "xxx", ComparisonPolicy.TRIM_WHITESPACES));
-    assertFalse(manager.isEquals("xyx", "xYx", ComparisonPolicy.TRIM_WHITESPACES));
+package com.intellij.diff.comparison
+
+import com.intellij.testFramework.UsefulTestCase
+import junit.framework.TestCase
+
+public class ComparisonUtilTest : UsefulTestCase() {
+  public fun testTrimEquals() {
+    doTestTrim(true, "", "")
+    doTestTrim(true, "", "   ")
+    doTestTrim(true, "   ", "   ")
+    doTestTrim(true, "\n   ", "  \n")
+    doTestTrim(true, "asd ", "asd  ")
+    doTestTrim(true, "    asd", "asd")
+    doTestTrim(true, "\n\n\n", "\n\n\n")
+    doTestTrim(true, "\n  \n  \n ", "  \n \n\n  ")
+    doTestTrim(false, "\n\n", "\n\n\n")
+
+    doTestTrim(false, "\nasd ", "asd\n  ")
+    doTestTrim(true, "\nasd \n", "\n asd\n  ")
+    doTestTrim(false, "x", "y")
+    doTestTrim(false, "\n", " ")
+
+    doTestTrim(true, "\t ", "")
+    doTestTrim(false, "", "\t\n \n\t")
+    doTestTrim(false, "\t", "\n")
+
+    doTestTrim(true, "x", " x")
+    doTestTrim(true, "x", "x ")
+    doTestTrim(false, "x\n", "x")
+
+    doTestTrim(false, "abc", "a\nb\nc\n")
+    doTestTrim(true, "\nx y x\n", "\nx y x\n")
+    doTestTrim(false, "\nxyx\n", "\nx y x\n")
+    doTestTrim(true, "\nx y x", "\nx y x")
+    doTestTrim(false, "\nxyx", "\nx y x")
+    doTestTrim(true, "x y x", "x y x")
+    doTestTrim(false, "xyx", "x y x")
+    doTestTrim(true, "  x y x  ", "x y x")
+
+    doTestTrim(false, "x", "\t\n ")
+    doTestTrim(false, "", " x ")
+    doTestTrim(false, "", "x ")
+    doTestTrim(false, "", " x")
+    doTestTrim(false, "xyx", "xxx")
+    doTestTrim(false, "xyx", "xYx")
+  }
+
+  private fun doTestTrim(expected: Boolean, string1: String, string2: String) {
+    doTest(expected, string1, string2, ComparisonPolicy.TRIM_WHITESPACES);
+  }
+
+  private fun doTest(expected: Boolean, string1: String, string2: String, policy: ComparisonPolicy) {
+    val result = MANAGER.isEquals(string1, string2, policy);
+    TestCase.assertEquals("---\n" + string1 + "\n---\n" + string2 + "\n---", expected, result);
+  }
+
+  companion object {
+    private val MANAGER = ComparisonManagerImpl()
   }
 }
index 0503bac8b70224ba453b6ffc989a7a1470161a26..b4b7127de1ab07317bca01f1e7debd0c8eae239b 100644 (file)
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package com.intellij.diff.comparison;
-
-import com.intellij.diff.fragments.DiffFragment;
-import com.intellij.diff.fragments.LineFragment;
-import com.intellij.openapi.editor.Document;
-import com.intellij.openapi.editor.impl.DocumentImpl;
-import com.intellij.openapi.progress.DumbProgressIndicator;
-import com.intellij.openapi.util.Couple;
-import com.intellij.openapi.util.registry.Registry;
-import com.intellij.testFramework.UsefulTestCase;
-import com.intellij.util.Function;
-import com.intellij.util.containers.ContainerUtil;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-import java.util.BitSet;
-import java.util.List;
-
-public abstract class ComparisonUtilTestBase extends UsefulTestCase {
-  private static DumbProgressIndicator INDICATOR = DumbProgressIndicator.INSTANCE;
-  private static ComparisonManager myComparisonManager = new ComparisonManagerImpl();
-
-  private boolean myOldRegistryValue;
-
-  @Override
-  public void setUp() throws Exception {
-    super.setUp();
-    myOldRegistryValue = Registry.get("diff.verify.iterable").asBoolean();
-    Registry.get("diff.verify.iterable").setValue(true);
+package com.intellij.diff.comparison
+
+import com.intellij.diff.fragments.DiffFragment
+import com.intellij.diff.fragments.LineFragment
+import com.intellij.openapi.editor.Document
+import com.intellij.openapi.editor.impl.DocumentImpl
+import com.intellij.openapi.progress.DumbProgressIndicator
+import com.intellij.openapi.util.Couple
+import com.intellij.openapi.util.registry.Registry
+import com.intellij.testFramework.UsefulTestCase
+import com.intellij.util.containers.ContainerUtil
+import java.util.BitSet
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+
+public abstract class ComparisonUtilTestBase : UsefulTestCase() {
+  private var oldRegistryValue: Boolean = false
+
+  override fun setUp() {
+    super.setUp()
+    oldRegistryValue = REGISTRY.asBoolean()
+    REGISTRY.setValue(true)
   }
 
-  @Override
-  protected void tearDown() throws Exception {
-    Registry.get("diff.verify.iterable").setValue(myOldRegistryValue);
-    super.tearDown();
+  override fun tearDown() {
+    REGISTRY.setValue(oldRegistryValue)
+    super.tearDown()
   }
 
   //
   // Impl
   //
 
-  private static void doLineTest(@NotNull Document before,
-                                 @NotNull Document after,
-                                 @Nullable Couple<BitSet> matchings,
-                                 @Nullable List<Change> expected,
-                                 @NotNull ComparisonPolicy policy) {
-    CharSequence sequence1 = before.getCharsSequence();
-    CharSequence sequence2 = after.getCharsSequence();
-    List<LineFragment> fragments = myComparisonManager.compareLines(sequence1, sequence2, policy, INDICATOR);
-    checkConsistency(fragments, before, after, policy);
-    if (matchings != null) checkLineMatching(fragments, before, after, matchings, policy);
-    if (expected != null) checkLineChanges(fragments, before, after, expected, policy);
+  private fun doLineTest(before: Document, after: Document, matchings: Couple<BitSet>?, expected: List<Change>?, policy: ComparisonPolicy) {
+    val fragments = MANAGER.compareLines(before.getCharsSequence(), after.getCharsSequence(), policy, INDICATOR)
+    checkConsistency(fragments, before, after)
+    if (matchings != null) checkLineMatching(fragments, matchings)
+    if (expected != null) checkLineChanges(fragments, expected)
   }
 
-  private static void doWordTest(@NotNull Document before,
-                                 @NotNull Document after,
-                                 @Nullable Couple<BitSet> matchings,
-                                 @Nullable List<Change> expected,
-                                 @NotNull ComparisonPolicy policy) {
-    CharSequence sequence1 = before.getCharsSequence();
-    CharSequence sequence2 = after.getCharsSequence();
-    List<LineFragment> rawFragments = myComparisonManager.compareLinesInner(sequence1, sequence2, policy, INDICATOR);
-    List<LineFragment> fragments = myComparisonManager.squash(rawFragments);
+  private fun doWordTest(before: Document, after: Document, matchings: Couple<BitSet>?, expected: List<Change>?, policy: ComparisonPolicy) {
+    val rawFragments = MANAGER.compareLinesInner(before.getCharsSequence(), after.getCharsSequence(), policy, INDICATOR)
+    val fragments = MANAGER.squash(rawFragments)
+    checkConsistencyWord(fragments, before, after)
 
-    checkConsistencyWord(fragments, before, after, policy);
-
-    List<DiffFragment> diffFragments = fragments.get(0).getInnerFragments();
-    assert diffFragments != null;
-
-    if (matchings != null) checkDiffMatching(diffFragments, before, after, matchings, policy);
-    if (expected != null) checkDiffChanges(diffFragments, before, after, expected, policy);
+    val diffFragments = fragments.get(0).getInnerFragments()!!
+    if (matchings != null) checkDiffMatching(diffFragments, matchings)
+    if (expected != null) checkDiffChanges(diffFragments, expected)
   }
 
-  private static void doCharTest(@NotNull Document before,
-                                 @NotNull Document after,
-                                 @Nullable Couple<BitSet> matchings,
-                                 @Nullable List<Change> expected,
-                                 @NotNull ComparisonPolicy policy) {
-    CharSequence sequence1 = before.getCharsSequence();
-    CharSequence sequence2 = after.getCharsSequence();
-    List<DiffFragment> fragments = myComparisonManager.compareChars(sequence1, sequence2, policy, INDICATOR);
-    checkConsistency(fragments, before, after, policy);
-    if (matchings != null) checkDiffMatching(fragments, before, after, matchings, policy);
-    if (expected != null) checkDiffChanges(fragments, before, after, expected, policy);
+  private fun doCharTest(before: Document, after: Document, matchings: Couple<BitSet>?, expected: List<Change>?, policy: ComparisonPolicy) {
+    val fragments = MANAGER.compareChars(before.getCharsSequence(), after.getCharsSequence(), policy, INDICATOR)
+    checkConsistency(fragments, before, after)
+    if (matchings != null) checkDiffMatching(fragments, matchings)
+    if (expected != null) checkDiffChanges(fragments, expected)
   }
 
-  private static void doSplitterTest(@NotNull Document before,
-                                     @NotNull Document after,
-                                     @Nullable Couple<BitSet> matchings,
-                                     @Nullable List<Change> expected,
-                                     @NotNull ComparisonPolicy policy) {
-    CharSequence sequence1 = before.getCharsSequence();
-    CharSequence sequence2 = after.getCharsSequence();
-    List<LineFragment> fragments = myComparisonManager.compareLinesInner(sequence1, sequence2, policy, INDICATOR);
-    checkConsistency(fragments, before, after, policy);
-    if (matchings != null) checkLineMatching(fragments, before, after, matchings, policy);
-    if (expected != null) checkLineChanges(fragments, before, after, expected, policy);
+  private fun doSplitterTest(before: Document, after: Document, matchings: Couple<BitSet>?, expected: List<Change>?, policy: ComparisonPolicy) {
+    val fragments = MANAGER.compareLinesInner(before.getCharsSequence(), after.getCharsSequence(), policy, INDICATOR)
+    checkConsistency(fragments, before, after)
+    if (matchings != null) checkLineMatching(fragments, matchings)
+    if (expected != null) checkLineChanges(fragments, expected)
   }
 
-  private static void checkConsistencyWord(@NotNull List<LineFragment> fragments,
-                                           @NotNull Document before,
-                                           @NotNull Document after,
-                                           @NotNull ComparisonPolicy policy) {
-    assertTrue(fragments.size() == 1);
-    LineFragment fragment = fragments.get(0);
-    List<DiffFragment> diffFragments = fragment.getInnerFragments();
-    assertNotNull(diffFragments); // It could be null if there are no common words. We do not test such cases here.
-
-    assertTrue(fragment.getStartOffset1() == 0 &&
-               fragment.getStartOffset2() == 0 &&
-               fragment.getEndOffset1() == before.getTextLength() &&
-               fragment.getEndOffset2() == after.getTextLength());
-
-    checkConsistency(diffFragments, before, after, policy);
+  private fun checkConsistencyWord(fragments: List<LineFragment>, before: Document, after: Document) {
+    assertTrue(fragments.size() == 1)
+    val fragment = fragments.get(0)
+
+    assertTrue(fragment.getStartOffset1() == 0)
+    assertTrue(fragment.getStartOffset2() == 0)
+    assertTrue(fragment.getEndOffset1() == before.getTextLength())
+    assertTrue(fragment.getEndOffset2() == after.getTextLength())
+
+    // It could be null if there are no common words. We do not test such cases here.
+    checkConsistency(fragment.getInnerFragments()!!, before, after)
   }
 
-  private static void checkConsistency(@NotNull List<? extends DiffFragment> fragments,
-                                       @NotNull Document before,
-                                       @NotNull Document after,
-                                       @NotNull ComparisonPolicy policy) {
-    for (DiffFragment fragment : fragments) {
-      assertTrue(fragment.getStartOffset1() <= fragment.getEndOffset1());
-      assertTrue(fragment.getStartOffset2() <= fragment.getEndOffset2());
+  private fun checkConsistency(fragments: List<DiffFragment>, before: Document, after: Document) {
+    for (fragment in fragments) {
+      assertTrue(fragment.getStartOffset1() <= fragment.getEndOffset1())
+      assertTrue(fragment.getStartOffset2() <= fragment.getEndOffset2())
 
-      if (fragment instanceof LineFragment) {
-        LineFragment lineFragment = (LineFragment)fragment;
-        assertTrue(lineFragment.getStartLine1() <= lineFragment.getEndLine1());
-        assertTrue(lineFragment.getStartLine2() <= lineFragment.getEndLine2());
+      if (fragment is LineFragment) {
+        assertTrue(fragment.getStartLine1() <= fragment.getEndLine1())
+        assertTrue(fragment.getStartLine2() <= fragment.getEndLine2())
 
-        assertTrue(lineFragment.getStartLine1() != lineFragment.getEndLine1() || lineFragment.getStartLine2() != lineFragment.getEndLine2());
+        assertTrue(fragment.getStartLine1() != fragment.getEndLine1() || fragment.getStartLine2() != fragment.getEndLine2())
 
-        assertTrue(lineFragment.getStartLine1() >= 0);
-        assertTrue(lineFragment.getStartLine2() >= 0);
-        assertTrue(lineFragment.getEndLine1() <= getLineCount(before));
-        assertTrue(lineFragment.getEndLine2() <= getLineCount(after));
+        assertTrue(fragment.getStartLine1() >= 0)
+        assertTrue(fragment.getStartLine2() >= 0)
+        assertTrue(fragment.getEndLine1() <= getLineCount(before))
+        assertTrue(fragment.getEndLine2() <= getLineCount(after))
 
-        checkLineOffsets(lineFragment, before, after, policy);
+        checkLineOffsets(fragment, before, after)
 
-        if (lineFragment.getInnerFragments() != null) checkConsistency(lineFragment.getInnerFragments(), before, after, policy);
-      } else {
-        assertTrue(fragment.getStartOffset1() != fragment.getEndOffset1() || fragment.getStartOffset2() != fragment.getEndOffset2());
+        val innerFragments = fragment.getInnerFragments()
+        innerFragments?.let { checkConsistency(innerFragments!!, before, after) }
+      }
+      else {
+        assertTrue(fragment.getStartOffset1() != fragment.getEndOffset1() || fragment.getStartOffset2() != fragment.getEndOffset2())
       }
     }
   }
 
-  private static void checkLineChanges(@NotNull List<? extends LineFragment> fragments,
-                                       @NotNull Document before,
-                                       @NotNull Document after,
-                                       @NotNull List<Change> expected,
-                                       @NotNull ComparisonPolicy policy) {
-    List<Change> changes = convertLineFragments(fragments);
-    assertOrderedEquals(policy.name(), changes, expected);
+  private fun checkLineChanges(fragments: List<LineFragment>, expected: List<Change>) {
+    val changes = convertLineFragments(fragments)
+    UsefulTestCase.assertOrderedEquals(changes, expected)
   }
 
-  private static void checkDiffChanges(@NotNull List<? extends DiffFragment> fragments,
-                                           @NotNull Document before,
-                                           @NotNull Document after,
-                                           @NotNull List<Change> expected,
-                                           @NotNull ComparisonPolicy policy) {
-    List<Change> changes = convertDiffFragments(fragments);
-    assertOrderedEquals(policy.name(), changes, expected);
+  private fun checkDiffChanges(fragments: List<DiffFragment>, expected: List<Change>) {
+    val changes = convertDiffFragments(fragments)
+    UsefulTestCase.assertOrderedEquals(changes, expected)
   }
 
-  private static void checkLineMatching(@NotNull List<? extends LineFragment> fragments,
-                                        @NotNull Document before,
-                                        @NotNull Document after,
-                                        @NotNull Couple<BitSet> matchings,
-                                        @NotNull ComparisonPolicy policy) {
-    BitSet set1 = new BitSet();
-    BitSet set2 = new BitSet();
-    for (LineFragment fragment : fragments) {
-      set1.set(fragment.getStartLine1(), fragment.getEndLine1());
-      set2.set(fragment.getStartLine2(), fragment.getEndLine2());
+  private fun checkLineMatching(fragments: List<LineFragment>, matchings: Couple<BitSet>) {
+    val set1 = BitSet()
+    val set2 = BitSet()
+    for (fragment in fragments) {
+      set1.set(fragment.getStartLine1(), fragment.getEndLine1())
+      set2.set(fragment.getStartLine2(), fragment.getEndLine2())
     }
 
-    assertEquals(policy.name(), matchings.first, set1);
-    assertEquals(policy.name(), matchings.second, set2);
+    assertEquals(matchings.first, set1)
+    assertEquals(matchings.second, set2)
   }
 
-  private static void checkDiffMatching(@NotNull List<? extends DiffFragment> fragments,
-                                        @NotNull Document before,
-                                        @NotNull Document after,
-                                        @NotNull Couple<BitSet> matchings,
-                                        @NotNull ComparisonPolicy policy) {
-    BitSet set1 = new BitSet();
-    BitSet set2 = new BitSet();
-    for (DiffFragment fragment : fragments) {
-      set1.set(fragment.getStartOffset1(), fragment.getEndOffset1());
-      set2.set(fragment.getStartOffset2(), fragment.getEndOffset2());
+  private fun checkDiffMatching(fragments: List<DiffFragment>, matchings: Couple<BitSet>) {
+    val set1 = BitSet()
+    val set2 = BitSet()
+    for (fragment in fragments) {
+      set1.set(fragment.getStartOffset1(), fragment.getEndOffset1())
+      set2.set(fragment.getStartOffset2(), fragment.getEndOffset2())
     }
 
-    assertEquals(policy.name(), matchings.first, set1);
-    assertEquals(policy.name(), matchings.second, set2);
+    assertEquals(matchings.first, set1)
+    assertEquals(matchings.second, set2)
   }
 
-  @NotNull
-  private static List<Change> convertDiffFragments(@NotNull List<? extends DiffFragment> fragments) {
-    return ContainerUtil.map(fragments, new Function<DiffFragment, Change>() {
-      @Override
-      public Change fun(DiffFragment fragment) {
-        return new Change(fragment.getStartOffset1(), fragment.getEndOffset1(), fragment.getStartOffset2(), fragment.getEndOffset2());
-      }
-    });
+  private fun convertDiffFragments(fragments: List<DiffFragment>): List<Change> {
+    return fragments.map { Change(it.getStartOffset1(), it.getEndOffset1(), it.getStartOffset2(), it.getEndOffset2()) }
   }
 
-  @NotNull
-  private static List<Change> convertLineFragments(@NotNull List<? extends LineFragment> fragments) {
-    return ContainerUtil.map(fragments, new Function<LineFragment, Change>() {
-      @Override
-      public Change fun(LineFragment fragment) {
-        return new Change(fragment.getStartLine1(), fragment.getEndLine1(), fragment.getStartLine2(), fragment.getEndLine2());
-      }
-    });
+  private fun convertLineFragments(fragments: List<LineFragment>): List<Change> {
+    return fragments.map { Change(it.getStartLine1(), it.getEndLine1(), it.getStartLine2(), it.getEndLine2()) }
   }
 
-  private static void checkLineOffsets(@NotNull LineFragment fragment,
-                                       @NotNull Document before,
-                                       @NotNull Document after,
-                                       @NotNull ComparisonPolicy policy) {
-    checkLineOffsets(before, fragment.getStartLine1(), fragment.getEndLine1(),
-                     fragment.getStartOffset1(), fragment.getEndOffset1(), policy);
+  private fun checkLineOffsets(fragment: LineFragment, before: Document, after: Document) {
+    checkLineOffsets(before, fragment.getStartLine1(), fragment.getEndLine1(), fragment.getStartOffset1(), fragment.getEndOffset1())
 
-    checkLineOffsets(after, fragment.getStartLine2(), fragment.getEndLine2(),
-                     fragment.getStartOffset2(), fragment.getEndOffset2(), policy);
+    checkLineOffsets(after, fragment.getStartLine2(), fragment.getEndLine2(), fragment.getStartOffset2(), fragment.getEndOffset2())
   }
 
-  private static void checkLineOffsets(@NotNull Document document,
-                                       int startLine,
-                                       int endLine,
-                                       int startOffset,
-                                       int endOffset,
-                                       @NotNull ComparisonPolicy policy) {
+  private fun checkLineOffsets(document: Document, startLine: Int, endLine: Int, startOffset: Int, endOffset: Int) {
     if (startLine != endLine) {
-      assertEquals(policy.name(), document.getLineStartOffset(startLine), startOffset);
-      int offset = document.getLineEndOffset(endLine - 1);
-      if (offset < document.getTextLength()) offset++;
-      assertEquals(policy.name(), offset, endOffset);
+      assertEquals(document.getLineStartOffset(startLine), startOffset)
+      var offset = document.getLineEndOffset(endLine - 1)
+      if (offset < document.getTextLength()) offset++
+      assertEquals(offset, endOffset)
     }
     else {
-      int offset = startLine == getLineCount(document)
-                   ? document.getTextLength()
-                   : document.getLineStartOffset(startLine);
-      assertEquals(policy.name(), offset, startOffset);
-      assertEquals(policy.name(), offset, endOffset);
+      val offset = if (startLine == getLineCount(document)) document.getTextLength() else document.getLineStartOffset(startLine)
+      assertEquals(offset, startOffset)
+      assertEquals(offset, endOffset)
     }
   }
 
+  private fun getLineCount(document: Document): Int {
+    return Math.max(1, document.getLineCount())
+  }
+
   //
   // Test Builder
   //
 
-  public static class TestData {
-    enum TestType {LINE, WORD, CHAR, SPLITTER}
-
-    @NotNull private final TestType myType;
-    @NotNull private final String myBefore;
-    @NotNull private final String myAfter;
-
-    @Nullable private List<Change> myDefaultChanges;
-    @Nullable private List<Change> myTrimChanges;
-    @Nullable private List<Change> myIgnoreChanges;
+  private enum class TestType {
+    LINE, WORD, CHAR, SPLITTER
+  }
 
-    @Nullable private Couple<BitSet> myDefaultMatching;
-    @Nullable private Couple<BitSet> myTrimMatching;
-    @Nullable private Couple<BitSet> myIgnoreMatching;
+  public inner class TestBuilder(private val type: TestType) {
+    private var isExecuted: Boolean = false;
 
-    private boolean mySkipDefault;
-    private boolean mySkipTrim;
-    private boolean mySkipIgnore;
+    private var before: Document? = null
+    private var after: Document? = null
 
-    public TestData(@NotNull TestType type, @NotNull String before, @NotNull String after) {
-      myType = type;
-      myBefore = before;
-      myAfter = after;
-    }
+    private var defaultChanges: List<Change>? = null
+    private var trimChanges: List<Change>? = null
+    private var ignoreChanges: List<Change>? = null
 
-    @NotNull
-    public static TestData lines(@NotNull String before, @NotNull String after) {
-      return new TestData(TestType.LINE, before, after);
-    }
+    private var defaultMatching: Couple<BitSet>? = null
+    private var trimMatching: Couple<BitSet>? = null
+    private var ignoreMatching: Couple<BitSet>? = null
 
-    @NotNull
-    public static TestData words(@NotNull String before, @NotNull String after) {
-      return new TestData(TestType.WORD, before, after);
+    private fun changes(policy: ComparisonPolicy): List<Change>? = when (policy) {
+      ComparisonPolicy.IGNORE_WHITESPACES -> ignoreChanges ?: trimChanges ?: defaultChanges;
+      ComparisonPolicy.TRIM_WHITESPACES -> trimChanges ?: defaultChanges;
+      ComparisonPolicy.DEFAULT -> defaultChanges
     }
 
-    @NotNull
-    public static TestData chars(@NotNull String before, @NotNull String after) {
-      TestData data = new TestData(TestType.CHAR, before, after);
-      data.mySkipTrim = true; // Not supported
-      return data;
+    private fun matchings(policy: ComparisonPolicy): Couple<BitSet>? = when (policy) {
+      ComparisonPolicy.IGNORE_WHITESPACES -> ignoreMatching ?: trimMatching ?: defaultMatching;
+      ComparisonPolicy.TRIM_WHITESPACES -> trimMatching ?: defaultMatching;
+      ComparisonPolicy.DEFAULT -> defaultMatching
     }
 
-    @NotNull
-    public static TestData split(@NotNull String before, @NotNull String after) {
-      return new TestData(TestType.SPLITTER, before, after);
+    public fun assertExecuted() {
+      assertTrue(isExecuted)
     }
 
-    @NotNull
-    public TestData _______Def_(@NotNull String before, @NotNull String after) {
-      assert myBefore.length() == before.length();
-      assert myAfter.length() == after.length();
-      myDefaultMatching = parseMatching(before, after);
-      return this;
-    }
+    private fun run(policy: ComparisonPolicy) {
+      try {
+        isExecuted = true;
 
-    @NotNull
-    public TestData ______Trim_(@NotNull String before, @NotNull String after) {
-      assert myType != TestType.CHAR;
-      assert myBefore.length() == before.length();
-      assert myAfter.length() == after.length();
-      myTrimMatching = parseMatching(before, after);
-      return this;
-    }
+        val change = changes(policy)
+        val matchings = matchings(policy)
+        assertTrue(change != null || matchings != null)
 
-    @NotNull
-    public TestData ____Ignore_(@NotNull String before, @NotNull String after) {
-      assert myBefore.length() == before.length();
-      assert myAfter.length() == after.length();
-      myIgnoreMatching = parseMatching(before, after);
-      return this;
-    }
-
-    @NotNull
-    public TestData _Def_(Change... expected) {
-      myDefaultChanges = ContainerUtil.list(expected);
-      return this;
+        when (type) {
+          TestType.LINE -> doLineTest(before!!, after!!, matchings, change, policy)
+          TestType.WORD -> doWordTest(before!!, after!!, matchings, change, policy)
+          TestType.CHAR -> doCharTest(before!!, after!!, matchings, change, policy)
+          TestType.SPLITTER -> doSplitterTest(before!!, after!!, matchings, change, policy)
+        }
+      }
+      catch (e: Throwable) {
+        println("Policy: " + policy.name())
+        throw e;
+      }
     }
 
-    @NotNull
-    public TestData _Trim_(Change... expected) {
-      myTrimChanges = ContainerUtil.list(expected);
-      return this;
-    }
+    private fun parseSource(string: String): Document = DocumentImpl(string.replace('_', '\n'))
 
-    @NotNull
-    public TestData _Ignore_(Change... expected) {
-      myIgnoreChanges = ContainerUtil.list(expected);
-      return this;
+    private fun parseMatching(before: String, after: String): Couple<BitSet> {
+      return Couple.of(parseMatching(before), parseMatching(after))
     }
 
-    public void all() {
-      run();
+    private fun parseMatching(matching: String): BitSet {
+      val set = BitSet()
+      matching.forEachIndexed { i, c -> if (c != ' ') set.set(i) }
+      return set
     }
 
-    public void skipDef() {
-      mySkipDefault = true;
-      run();
-    }
 
-    public void skipTrim() {
-      mySkipTrim = true;
-      run();
+    public fun testAll() {
+      testDefault()
+      testTrim()
+      testIgnore()
     }
 
-    public void skipIgnore() {
-      mySkipIgnore = true;
-      run();
+    public fun testDefault() {
+      run(ComparisonPolicy.DEFAULT)
     }
 
-    public void def() {
-      mySkipTrim = true;
-      mySkipIgnore = true;
-      run();
+    public fun testTrim() {
+      if (type == TestType.CHAR) return // not supported
+      run(ComparisonPolicy.TRIM_WHITESPACES)
     }
 
-    public void trim() {
-      mySkipDefault = true;
-      mySkipIgnore = true;
-      run();
+    public fun testIgnore() {
+      run(ComparisonPolicy.IGNORE_WHITESPACES)
     }
 
-    public void ignore() {
-      mySkipDefault = true;
-      mySkipTrim = true;
-      run();
-    }
 
-    @NotNull
-    public Document getBefore() {
-      return new DocumentImpl(myBefore.replace('_', '\n'));
+    public fun String.minus(v: String): Helper {
+      return Helper(this, v)
     }
 
-    @NotNull
-    public Document getAfter() {
-      return new DocumentImpl(myAfter.replace('_', '\n'));
-    }
+    public inner class Helper(val before: String, val after: String) {
+      init {
+        val builder = this@TestBuilder
+        if (builder.before == null && builder.after == null) {
+          builder.before = parseSource(before)
+          builder.after = parseSource(after)
+        }
+      }
 
-    @Nullable
-    List<Change> getChange(@NotNull ComparisonPolicy policy) {
-      switch (policy) {
-        case IGNORE_WHITESPACES:
-          if (myIgnoreChanges != null) return myIgnoreChanges;
-        case TRIM_WHITESPACES:
-          if (myTrimChanges != null) return myTrimChanges;
-        case DEFAULT:
-          if (myDefaultChanges != null) return myDefaultChanges;
+      public fun default() {
+        defaultMatching = parseMatching(before, after)
       }
-      return null;
-    }
 
-    @Nullable
-    Couple<BitSet> getMatchings(@NotNull ComparisonPolicy policy) {
-      switch (policy) {
-        case IGNORE_WHITESPACES:
-          if (myIgnoreMatching != null) return myIgnoreMatching;
-        case TRIM_WHITESPACES:
-          if (myTrimMatching != null) return myTrimMatching;
-        case DEFAULT:
-          if (myDefaultMatching != null) return myDefaultMatching;
+      public fun trim() {
+        trimMatching = parseMatching(before, after)
       }
-      return null;
-    }
 
-    private void run(@NotNull ComparisonPolicy policy) {
-      List<Change> change = getChange(policy);
-      Couple<BitSet> matchings = getMatchings(policy);
-
-      switch (myType) {
-        case LINE:
-          doLineTest(getBefore(), getAfter(), matchings, change, policy);
-          break;
-        case WORD:
-          doWordTest(getBefore(), getAfter(), matchings, change, policy);
-          break;
-        case CHAR:
-          doCharTest(getBefore(), getAfter(), matchings, change, policy);
-          break;
-        case SPLITTER:
-          doSplitterTest(getBefore(), getAfter(), matchings, change, policy);
-          break;
+      public fun ignore() {
+        ignoreMatching = parseMatching(before, after)
       }
     }
 
-    private void run() {
-      if (!mySkipDefault) run(ComparisonPolicy.DEFAULT);
-      if (!mySkipTrim) run(ComparisonPolicy.TRIM_WHITESPACES);
-      if (!mySkipIgnore) run(ComparisonPolicy.IGNORE_WHITESPACES);
+
+    public fun default(vararg expected: Change): Unit {
+      defaultChanges = ContainerUtil.list(*expected)
     }
-  }
 
-  @NotNull
-  public static Couple<BitSet> parseMatching(@NotNull String before, @NotNull String after) {
-    return Couple.of(parseMatching(before), parseMatching(after));
-  }
+    public fun trim(vararg expected: Change): Unit {
+      trimChanges = ContainerUtil.list(*expected)
+    }
 
-  @NotNull
-  public static BitSet parseMatching(@NotNull String matching) {
-    BitSet set = new BitSet();
-    for (int i = 0; i < matching.length(); i++) {
-      if (matching.charAt(i) != ' ') set.set(i);
+    public fun ignore(vararg expected: Change): Unit {
+      ignoreChanges = ContainerUtil.list(*expected)
     }
-    return set;
-  }
 
-  public static Change mod(int line1, int line2, int count1, int count2) {
-    assert count1 != 0;
-    assert count2 != 0;
-    return new Change(line1, line1 + count1, line2, line2 + count2);
-  }
+    public fun mod(line1: Int, line2: Int, count1: Int, count2: Int): Change {
+      assert(count1 != 0)
+      assert(count2 != 0)
+      return Change(line1, line1 + count1, line2, line2 + count2)
+    }
 
-  public static Change del(int line1, int line2, int count1) {
-    assert count1 != 0;
-    return new Change(line1, line1 + count1, line2, line2);
-  }
+    public fun del(line1: Int, line2: Int, count1: Int): Change {
+      assert(count1 != 0)
+      return Change(line1, line1 + count1, line2, line2)
+    }
 
-  public static Change ins(int line1, int line2, int count2) {
-    assert count2 != 0;
-    return new Change(line1, line1, line2, line2 + count2);
+    public fun ins(line1: Int, line2: Int, count2: Int): Change {
+      assert(count2 != 0)
+      return Change(line1, line1, line2, line2 + count2)
+    }
   }
 
-  public static class Change {
-    public int start1;
-    public int end1;
-    public int start2;
-    public int end2;
-
-    public Change(int start1, int end1, int start2, int end2) {
-      this.start1 = start1;
-      this.end1 = end1;
-      this.start2 = start2;
-      this.end2 = end2;
-    }
+  public fun lines(f: TestBuilder.() -> Unit): Unit = doTest(TestType.LINE, f)
 
-    @Override
-    public boolean equals(Object o) {
-      if (this == o) return true;
-      if (o == null || getClass() != o.getClass()) return false;
+  public fun words(f: TestBuilder.() -> Unit): Unit = doTest(TestType.WORD, f)
 
-      Change change = (Change)o;
+  public fun chars(f: TestBuilder.() -> Unit): Unit = doTest(TestType.CHAR, f)
 
-      if (end1 != change.end1) return false;
-      if (end2 != change.end2) return false;
-      if (start1 != change.start1) return false;
-      if (start2 != change.start2) return false;
+  public fun split(f: TestBuilder.() -> Unit): Unit = doTest(TestType.SPLITTER, f)
 
-      return true;
-    }
+  private fun doTest(type: TestType, f: TestBuilder.() -> Unit) {
+    val builder = TestBuilder(type)
+    builder.f()
+    builder.assertExecuted()
+  }
 
-    @Override
-    public int hashCode() {
-      int result = start1;
-      result = 31 * result + end1;
-      result = 31 * result + start2;
-      result = 31 * result + end2;
-      return result;
-    }
+  //
+  // Helpers
+  //
 
-    @Override
-    public String toString() {
-      return "(" + start1 + ", " + end1 + ") - (" + start2 + ", " + end2 + ")";
+  public data class Change(val start1: Int, val end1: Int, val start2: Int, val end2: Int) {
+    override fun toString(): String {
+      return "(" + start1 + ", " + end1 + ") - (" + start2 + ", " + end2 + ")"
     }
   }
 
-  private static int getLineCount(@NotNull Document document) {
-    return Math.max(1, document.getLineCount());
+  companion object {
+    private val REGISTRY = Registry.get("diff.verify.iterable");
+
+    private val INDICATOR = DumbProgressIndicator.INSTANCE
+    private val MANAGER = ComparisonManagerImpl()
   }
 }
index 2c09a701886c721c54c7c260cdeca3e577ec14c9..1e696196249e7adab90763cca816c4661f72cf8b 100644 (file)
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package com.intellij.diff.comparison;
-
-public class LineComparisonUtilTest extends ComparisonUtilTestBase {
-  public void testEqualStrings() {
-    TestData.lines("", "")
-      ._Def_()
-      .all();
-
-    TestData.lines("x", "x")
-      ._Def_()
-      .all();
-
-    TestData.lines("x_y_z_", "x_y_z_")
-      ._Def_()
-      .all();
-
-    TestData.lines("_", "_")
-      ._Def_()
-      .all();
-
-    TestData.lines(" x_y ", " x_y ")
-      ._Def_()
-      .all();
+package com.intellij.diff.comparison
+
+public class LineComparisonUtilTest : ComparisonUtilTestBase() {
+  public fun testEqualStrings() {
+    lines {
+      ("" - "")
+      default()
+      testAll()
+    }
+
+    lines {
+      ("x" - "x")
+      default()
+      testAll()
+    }
+
+    lines {
+      ("x_y_z_" - "x_y_z_")
+      default()
+      testAll()
+    }
+
+    lines {
+      ("_" - "_")
+      default()
+      testAll()
+    }
+
+    lines {
+      (" x_y " - " x_y ")
+      default()
+      testAll()
+    }
   }
 
-  public void testTrivialCases() {
-    TestData.lines("x_", "y_")
-      ._Def_(mod(0, 0, 1, 1))
-      .all();
-
-    TestData.lines("x", "")
-      ._Def_(mod(0, 0, 1, 1))
-      .all();
-
-    TestData.lines("", "x")
-      ._Def_(mod(0, 0, 1, 1))
-      .all();
-
-    TestData.lines("x", "y")
-      ._Def_(mod(0, 0, 1, 1))
-      .all();
-
-    TestData.lines("x_z", "y_z")
-      ._Def_(mod(0, 0, 1, 1))
-      .all();
-
-    TestData.lines("z_x", "z_y")
-      ._Def_(mod(1, 1, 1, 1))
-      .all();
-
-    TestData.lines("x", "x_")
-      ._Def_(ins(1, 1, 1))
-      .all();
-
-    TestData.lines("x_", "x")
-      ._Def_(del(1, 1, 1))
-      .all();
+  public fun testTrivialCases() {
+    lines {
+      ("x_" - "y_")
+      default(mod(0, 0, 1, 1))
+      testAll()
+    }
+
+    lines {
+      ("x" - "")
+      default(mod(0, 0, 1, 1))
+      testAll()
+    }
+
+    lines {
+      ("" - "x")
+      default(mod(0, 0, 1, 1))
+      testAll()
+    }
+
+    lines {
+      ("x" - "y")
+      default(mod(0, 0, 1, 1))
+      testAll()
+    }
+
+    lines {
+      ("x_z" - "y_z")
+      default(mod(0, 0, 1, 1))
+      testAll()
+    }
+
+    lines {
+      ("z_x" - "z_y")
+      default(mod(1, 1, 1, 1))
+      testAll()
+    }
+
+    lines {
+      ("x" - "x_")
+      default(ins(1, 1, 1))
+      testAll()
+    }
+
+    lines {
+      ("x_" - "x")
+      default(del(1, 1, 1))
+      testAll()
+    }
   }
 
-  public void testSimpleCases() {
-    TestData.lines("x_z", "y_z")
-      ._Def_(mod(0, 0, 1, 1))
-      .all();
-
-    TestData.lines("x_", "x_z")
-      ._Def_(mod(1, 1, 1, 1))
-      .all();
-
-    TestData.lines("x_y", "n_m")
-      ._Def_(mod(0, 0, 2, 2))
-      .all();
-
-    TestData.lines("x_y_z", "n_y_m")
-      ._Def_(mod(0, 0, 1, 1), mod(2, 2, 1, 1))
-      .all();
-
-    TestData.lines("x_y_z", "n_k_y")
-      ._Def_(mod(0, 0, 1, 2), del(2, 3, 1))
-      .all();
-
-    TestData.lines("x_y_z", "y")
-      ._Def_(del(0, 0, 1), del(2, 1, 1))
-      .all();
-
-    TestData.lines("a_b_x", "x_m_n")
-      ._Def_(del(0, 0, 2), ins(3, 1, 2))
-      .all();
+  public fun testSimpleCases() {
+    lines {
+      ("x_z" - "y_z")
+      default(mod(0, 0, 1, 1))
+      testAll()
+    }
+
+    lines {
+      ("x_" - "x_z")
+      default(mod(1, 1, 1, 1))
+      testAll()
+    }
+
+    lines {
+      ("x_y" - "n_m")
+      default(mod(0, 0, 2, 2))
+      testAll()
+    }
+
+    lines {
+      ("x_y_z" - "n_y_m")
+      default(mod(0, 0, 1, 1), mod(2, 2, 1, 1))
+      testAll()
+    }
+
+    lines {
+      ("x_y_z" - "n_k_y")
+      default(mod(0, 0, 1, 2), del(2, 3, 1))
+      testAll()
+    }
+
+    lines {
+      ("x_y_z" - "y")
+      default(del(0, 0, 1), del(2, 1, 1))
+      testAll()
+    }
+
+    lines {
+      ("a_b_x" - "x_m_n")
+      default(del(0, 0, 2), ins(3, 1, 2))
+      testAll()
+    }
   }
 
-  public void testEmptyLastLine() {
-    TestData.lines("x_", "")
-      ._Def_(del(0, 0, 1))
-      .all();
-
-    TestData.lines("", "x_")
-      ._Def_(ins(0, 0, 1))
-      .all();
-
-    TestData.lines("x_", "x")
-      ._Def_(del(1, 1, 1))
-      .all();
-
-    TestData.lines("x_", "x_z ")
-      ._Def_(mod(1, 1, 1, 1))
-      .all();
+  public fun testEmptyLastLine() {
+    lines {
+      ("x_" - "")
+      default(del(0, 0, 1))
+      testAll()
+    }
+
+    lines {
+      ("" - "x_")
+      default(ins(0, 0, 1))
+      testAll()
+    }
+
+    lines {
+      ("x_" - "x")
+      default(del(1, 1, 1))
+      testAll()
+    }
+
+    lines {
+      ("x_" - "x_z ")
+      default(mod(1, 1, 1, 1))
+      testAll()
+    }
   }
 
-  public void testWhitespaceOnlyChanges() {
-    TestData.lines("x ", " x")
-      ._Def_(mod(0, 0, 1, 1))
-      ._Trim_()
-      .all();
-
-    TestData.lines("x \t", "\t x")
-      ._Def_(mod(0, 0, 1, 1))
-      ._Trim_()
-      .all();
-
-    TestData.lines("x_", "x ")
-      ._Def_(mod(0, 0, 2, 1))
-      ._Trim_(del(1, 1, 1))
-      .all();
-
-    TestData.lines(" x_y ", "x _ y")
-      ._Def_(mod(0, 0, 2, 2))
-      ._Trim_()
-      .all();
-
-    TestData.lines("x y ", "x  y")
-      ._Def_(mod(0, 0, 1, 1))
-      ._Ignore_()
-      .all();
-
-    TestData.lines("x y_x y_x y", "  x y  _x y  _x   y")
-      ._Def_(mod(0, 0, 3, 3))
-      ._Trim_(mod(2, 2, 1, 1))
-      ._Ignore_()
-      .all();
+  public fun testWhitespaceOnlyChanges() {
+    lines {
+      ("x " - " x")
+      default(mod(0, 0, 1, 1))
+      trim()
+      testAll()
+    }
+
+    lines {
+      ("x \t" - "\t x")
+      default(mod(0, 0, 1, 1))
+      trim()
+      testAll()
+    }
+
+    lines {
+      ("x_" - "x ")
+      default(mod(0, 0, 2, 1))
+      trim(del(1, 1, 1))
+      testAll()
+    }
+
+    lines {
+      (" x_y " - "x _ y")
+      default(mod(0, 0, 2, 2))
+      trim()
+      testAll()
+    }
+
+    lines {
+      ("x y " - "x  y")
+      default(mod(0, 0, 1, 1))
+      ignore()
+      testAll()
+    }
+
+    lines {
+      ("x y_x y_x y" - "  x y  _x y  _x   y")
+      default(mod(0, 0, 3, 3))
+      trim(mod(2, 2, 1, 1))
+      ignore()
+      testAll()
+    }
   }
 
-  public void testAlgorithmSpecific() {
-    TestData.lines("x_y_z_AAAAA", "AAAAA_x_y_z")
-      ._Def_(del(0, 0, 3), ins(4, 1, 3))
-      .all();
-
-    TestData.lines("x_y_z", " y_ m_ n")
-      ._Def_(mod(0, 0, 3, 3))
-      ._Trim_(del(0, 0, 1), mod(2, 1, 1, 2))
-      .all();
-
-    TestData.lines("}_ }", " }")
-      ._Def_(del(0, 0, 1))
-      .def();
-
-    TestData.lines("{_}", "{_ {_ }_}_x")
-      ._Def_(ins(1, 1, 2), ins(2, 4, 1))
-      .def();
+  public fun testAlgorithmSpecific() {
+    lines {
+      ("x_y_z_AAAAA" - "AAAAA_x_y_z")
+      default(del(0, 0, 3), ins(4, 1, 3))
+      testAll()
+    }
+
+    lines {
+      ("x_y_z" - " y_ m_ n")
+      default(mod(0, 0, 3, 3))
+      trim(del(0, 0, 1), mod(2, 1, 1, 2))
+      testAll()
+    }
+
+    lines {
+      ("}_ }" - " }")
+      default(del(0, 0, 1))
+      testDefault()
+    }
+
+    lines {
+      ("{_}" - "{_ {_ }_}_x")
+      default(ins(1, 1, 2), ins(2, 4, 1))
+      testDefault()
+    }
   }
 
-  public void testNonDeterministicCases() {
-    TestData.lines("", "__")
-      ._Def_(ins(1, 1, 2))
-      .all();
-
-    TestData.lines("__", "")
-      ._Def_(del(1, 1, 2))
-      .all();
+  public fun testNonDeterministicCases() {
+    lines {
+      ("" - "__")
+      default(ins(1, 1, 2))
+      testAll()
+    }
+
+    lines {
+      ("__" - "")
+      default(del(1, 1, 2))
+      testAll()
+    }
   }
 
-  public void testBigBlockShiftRegression() {
-    TestData.lines(" X_  X", "  X_   X")
-      ._Def_(mod(0, 0, 2, 2))
-      .def();
+  public fun testBigBlockShiftRegression() {
+    lines {
+      (" X_  X" - "  X_   X")
+      default(mod(0, 0, 2, 2))
+      testDefault()
+    }
   }
 
-  public void testTwoStepCanTrimRegression() {
-    TestData.lines("q__7_ 6_ 7", "_7")
-      ._Def_(del(0, 0, 1), del(3, 2, 2))
-      .def();
+  public fun testTwoStepCanTrimRegression() {
+    lines {
+      ("q__7_ 6_ 7" - "_7")
+      default(del(0, 0, 1), del(3, 2, 2))
+      testDefault()
+    }
   }
 }
index 4328545ecc55e5f6e298e0243090c4b553437be4..c14adf8bd921c5ac332da269648adb94c65a5be5 100644 (file)
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package com.intellij.diff.comparison;
+package com.intellij.diff.comparison
 
 // TODO
-public class SplitComparisonUtilTest extends ComparisonUtilTestBase {
-  public void testSplitter() {
-    TestData.split("x", "z")._Def_(mod(0, 0, 1, 1)).all();
-    TestData.split("x_y", "a_b")._Def_(mod(0, 0, 2, 2)).all();
-    TestData.split("x_y", "a_b y")._Def_(mod(0, 0, 1, 1), mod(1, 1, 1, 1)).all();
+public class SplitComparisonUtilTest : ComparisonUtilTestBase() {
+  public fun testSplitter() {
+    split {
+      ("x" - "z")
+      default(mod(0, 0, 1, 1))
+      testAll()
+    }
+    split {
+      ("x_y" - "a_b")
+      default(mod(0, 0, 2, 2))
+      testAll()
+    }
+    split {
+      ("x_y" - "a_b y")
+      default(mod(0, 0, 1, 1), mod(1, 1, 1, 1))
+      testAll()
+    }
 
-    TestData.split("a_x_b_", " x_")._Def_(del(0, 0, 1), mod(1, 0, 1, 1), del(2, 1, 1)).def();
-    TestData.split("a_x_b_", "!x_")._Def_(del(0, 0, 1), mod(1, 0, 1, 1), del(2, 1, 1)).all();
+    split {
+      ("a_x_b_" - " x_")
+      default(del(0, 0, 1), mod(1, 0, 1, 1), del(2, 1, 1))
+      testDefault()
+    }
+    split {
+      ("a_x_b_" - "!x_")
+      default(del(0, 0, 1), mod(1, 0, 1, 1), del(2, 1, 1))
+      testAll()
+    }
   }
 }
index d53fc34147c24d19ebbb26370001d0c9ae323826..f05103ed97582f17239f7d245309e5041f94eb8e 100644 (file)
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package com.intellij.diff.comparison;
-
-public class WordComparisonUtilTest extends ComparisonUtilTestBase {
-  public void testSimpleCases() {
-    TestData.words("x z", "y z")
-      ._______Def_("-  ", "-  ")
-      .all();
-
-    TestData.words(" x z", "y z")
-      ._______Def_("--  ", "-  ")
-      .______Trim_(" -  ", "-  ")
-      .all();
-
-    TestData.words("x z ", "y z")
-      ._______Def_("-  -", "-  ")
-      .______Trim_("-   ", "-  ")
-      .all();
-
-    TestData.words("x z ", "y z")
-      ._______Def_("-  -", "-  ")
-      .______Trim_("-   ", "-  ")
-      .all();
-
-    TestData.words("x z", " y z ")
-      ._______Def_("-  ", "--  -")
-      .______Trim_("-  ", " -   ")
-      .all();
-
-    TestData.words("x y", "x z ")
-      ._______Def_("  -", "  --")
-      .______Trim_("  -", "  - ")
-      .all();
-
-    TestData.words("x,y", "x")
-      ._______Def_(" --", " ")
-      .all();
-
-    TestData.words("x,y", "y")
-      ._______Def_("-- ", " ")
-      .all();
-
-    TestData.words(".x=", ".!=")
-      ._______Def_(" - ", " - ")
-      .all();
+package com.intellij.diff.comparison
+
+public class WordComparisonUtilTest : ComparisonUtilTestBase() {
+  public fun testSimpleCases() {
+    words {
+      ("x z" - "y z")
+      ("-  " - "-  ").default()
+      testAll()
+    }
+
+    words {
+      ("x z" - "y z")
+      ("-  " - "-  ").default()
+      testAll()
+    }
+
+    words {
+      (" x z" - "y z")
+      ("--  " - "-  ").default()
+      (" -  " - "-  ").trim()
+      testAll()
+    }
+
+    words {
+      ("x z " - "y z")
+      ("-  -" - "-  ").default()
+      ("-   " - "-  ").trim()
+      testAll()
+    }
+
+    words {
+      ("x z " - "y z")
+      ("-  -" - "-  ").default()
+      ("-   " - "-  ").trim()
+      testAll()
+    }
+
+    words {
+      ("x z" - " y z ")
+      ("-  " - "--  -").default()
+      ("-  " - " -   ").trim()
+      testAll()
+    }
+
+    words {
+      ("x y" - "x z ")
+      ("  -" - "  --").default()
+      ("  -" - "  - ").trim()
+      testAll()
+    }
+
+    words {
+      ("x,y" - "x")
+      (" --" - " ").default()
+      testAll()
+    }
+
+    words {
+      ("x,y" - "y")
+      ("-- " - " ").default()
+      testAll()
+    }
+
+    words {
+      (".x=" - ".!=")
+      (" - " - " - ").default()
+      testAll()
+    }
   }
 
-  public void testPunctuation() {
-    TestData.words(" x.z.x ", "x..x")
-      ._______Def_("-  -  -", "    ")
-      .______Trim_("   -   ", "    ")
-      .all();
-
-    TestData.words("x..x", " x.z.x ")
-      ._______Def_("    ", "-  -  -")
-      .______Trim_("    ", "   -   ")
-      .all();
-
-    TestData.words("x ... z", "y ... z")
-      ._______Def_("-      ", "-      ")
-      .all();
-
-    TestData.words("x ... z", "x ... y")
-      ._______Def_("      -", "      -")
-      .all();
-
-    TestData.words("x ,... z", "x ... y")
-      ._______Def_("  -    -", "      -")
-      .all();
-
-    TestData.words("x . , .. z", "x ... y")
-      ._______Def_("   ---   -", "      -")
-      .____Ignore_("    -    -", "      -")
-      .all();
-
-    TestData.words("x==y==z", "x====z")
-      ._______Def_("   -   ", "      ")
-      .all();
-
-    TestData.words("x====z", "x==t==z")
-      ._______Def_("      ", "   -   ")
-      .all();
+  public fun testPunctuation() {
+    words {
+      (" x.z.x " - "x..x")
+      ("-  -  -" - "    ").default()
+      ("   -   " - "    ").trim()
+      testAll()
+    }
+
+    words {
+      ("x..x" - " x.z.x ")
+      ("    " - "-  -  -").default()
+      ("    " - "   -   ").trim()
+      testAll()
+    }
+
+    words {
+      ("x ... z" - "y ... z")
+      ("-      " - "-      ").default()
+      testAll()
+    }
+
+    words {
+      ("x ... z" - "x ... y")
+      ("      -" - "      -").default()
+      testAll()
+    }
+
+    words {
+      ("x ,... z" - "x ... y")
+      ("  -    -" - "      -").default()
+      testAll()
+    }
+
+    words {
+      ("x . , .. z" - "x ... y")
+      ("   ---   -" - "      -").default()
+      ("    -    -" - "      -").ignore()
+      testAll()
+    }
+
+    words {
+      ("x==y==z" - "x====z")
+      ("   -   " - "      ").default()
+      testAll()
+    }
+
+    words {
+      ("x====z" - "x==t==z")
+      ("      " - "   -   ").default()
+      testAll()
+    }
   }
 
-  public void testOldDiffBug() {
-    TestData.words("x'y'>", "x'>")
-      ._______Def_("  -- ", "   ")
-      .all();
-
-    TestData.words("x'>", "x'y'>")
-      ._______Def_("   ", "  -- ")
-      .all();
+  public fun testOldDiffBug() {
+    words {
+      ("x'y'>" - "x'>")
+      ("  -- " - "   ").default()
+      testAll()
+    }
+
+    words {
+      ("x'>" - "x'y'>")
+      ("   " - "  -- ").default()
+      testAll()
+    }
   }
 
-  public void testWhitespaceOnlyChanges() {
-    TestData.words("x  =z", "x=  z")
-      ._______Def_(" --  ", "  -- ")
-      .skipIgnore();
-
-    TestData.words("x  =", "x=  z")
-      ._______Def_(" -- ", "  ---")
-      .____Ignore_("    ", "    -")
-      .all();
+  public fun testWhitespaceOnlyChanges() {
+    words {
+      ("x  =z" - "x=  z")
+      (" --  " - "  -- ").default()
+      testDefault()
+      testTrim()
+    }
+
+    words {
+      ("x  =" - "x=  z")
+      (" -- " - "  ---").default()
+      ("    " - "    -").ignore()
+      testAll()
+    }
   }
 
-  public void testNewlines() {
-    TestData.words(" x _ y _ z ", "x z")
-      ._______Def_("- ------  -", "   ")
-      .______Trim_("     -     ", "   ")
-      .____Ignore_("     -     ", "   ")
-      .all();
-
-    TestData.words("x z", " x _ y _ z ")
-      ._______Def_("   ", "- ------  -")
-      .______Trim_("   ", "     -     ")
-      .____Ignore_("   ", "     -     ")
-      .all();
+  public fun testNewlines() {
+    words {
+      (" x _ y _ z " - "x z")
+      ("- ------  -" - "   ").default()
+      ("     -     " - "   ").trim()
+      ("     -     " - "   ").ignore()
+      testAll()
+    }
+
+    words {
+      ("x z" - " x _ y _ z ")
+      ("   " - "- ------  -").default()
+      ("   " - "     -     ").trim()
+      ("   " - "     -     ").ignore()
+      testAll()
+    }
   }
 
-  public void testFixedBugs() {
-    TestData.words(".! ", ".  y!")
-      ._______Def_("  -", " --- ")
-      .______Trim_("   ", " --- ")
-      .____Ignore_("   ", "   - ")
-      .all();
-
-    TestData.words(" x n", " y_  x m")
-      ._______Def_("   -", "----   -")
-      .______Trim_("   -", " -     -")
-      .____Ignore_("   -", " -     -")
-      .all();
-
-    TestData.words("x_", "x!  ")
-      ._______Def_(" -", " ---")
-      .______Trim_("  ", " -  ")
-      .____Ignore_("  ", " -  ")
-      .all();
+  public fun testFixedBugs() {
+    words {
+      (".! " - ".  y!")
+      ("  -" - " --- ").default()
+      ("   " - " --- ").trim()
+      ("   " - "   - ").ignore()
+      testAll()
+    }
+
+    words {
+      (" x n" - " y_  x m")
+      ("   -" - "----   -").default()
+      ("   -" - " -     -").trim()
+      ("   -" - " -     -").ignore()
+      testAll()
+    }
+
+    words {
+      ("x_" - "x!  ")
+      (" -" - " ---").default()
+      ("  " - " -  ").trim()
+      ("  " - " -  ").ignore()
+      testAll()
+    }
   }
 
-  public void testInnerWhitespaces() {
-    TestData.words("<< x >>", "<.<>.>")
-      ._______Def_("  ---  ", " -  - ")
-      .____Ignore_("   -   ", " -  - ")
-      .all();
-
-    TestData.words("<< x >>", "y<<x>>y")
-      ._______Def_("  - -  ", "-     -")
-      .____Ignore_("       ", "-     -")
-      .all();
-
-    TestData.words("x .. z", "x y .. z")
-      ._______Def_("      ", " --     ") // TODO: looks wrong
-      .____Ignore_("      ", "  -     ")
-      .all();
-
-    TestData.words("  x..z", "x..y  ")
-      ._______Def_("--   -", "   ---")
-      .______Trim_("     -", "   -  ")
-      .all();
-
-    TestData.words(" x y x _ x z x ", "x x_x x")
-      ._______Def_("- --  - - --  -", "       ")
-      .______Trim_("  --      --   ", "       ")
-      .____Ignore_("   -       -   ", "       ")
-      .all();
+  public fun testInnerWhitespaces() {
+    words {
+      ("<< x >>" - "<.<>.>")
+      ("  ---  " - " -  - ").default()
+      ("   -   " - " -  - ").ignore()
+      testAll()
+    }
+
+    words {
+      ("<< x >>" - "y<<x>>y")
+      ("  - -  " - "-     -").default()
+      ("       " - "-     -").ignore()
+      testAll()
+    }
+
+    words {
+      ("x .. z" - "x y .. z")
+      ("      " - " --     ").default() // TODO: looks wrong.default()
+      ("      " - "  -     ").ignore()
+      testAll()
+    }
+
+    words {
+      ("  x..z" - "x..y  ")
+      ("--   -" - "   ---").default()
+      ("     -" - "   -  ").trim()
+      testAll()
+    }
+
+    words {
+      (" x y x _ x z x " - "x x_x x")
+      ("- --  - - --  -" - "       ").default()
+      ("  --      --   " - "       ").trim()
+      ("   -       -   " - "       ").ignore()
+      testAll()
+    }
   }
 
-  public void testEmptyRangePositions() {
+  public fun testEmptyRangePositions() {
     // TODO
   }
 
-  public void testAlgorithmSpecific() {
+  public fun testAlgorithmSpecific() {
     // prefer words over punctuation
-    TestData.words("...x", "x...")
-      ._______Def_("--- ", " ---")
-      .all();
+    words {
+      ("...x" - "x...")
+      ("--- " - " ---").default()
+      testAll()
+    }
 
     // prefer longer words sequences
-    TestData.words("x x y", "x y")
-      ._______Def_("--   ", "   ")
-      .____Ignore_("-    ", "   ")
-      .all();
-
-    TestData.words("y x x", "y x")
-      ._______Def_("   --", "   ")
-      .____Ignore_("    -", "   ")
-      .all();
-
-    TestData.words("A X A B", "A B")
-      ._______Def_("----   ", "   ")
-      .____Ignore_("---    ", "   ")
-      .all();
+    words {
+      ("x x y" - "x y")
+      ("--   " - "   ").default()
+      ("-    " - "   ").ignore()
+      testAll()
+    }
+
+    words {
+      ("y x x" - "y x")
+      ("   --" - "   ").default()
+      ("    -" - "   ").ignore()
+      testAll()
+    }
+
+    words {
+      ("A X A B" - "A B")
+      ("----   " - "   ").default()
+      ("---    " - "   ").ignore()
+      testAll()
+    }
 
     // prefer less modified 'sentences'
-    TestData.words("A.X A.Z", "A.X A.Y A.Z")
-      ._______Def_("       ", "   ----    ")
-      .____Ignore_("       ", "    ---    ")
-      .all();
-
-    TestData.words("X.A Z.A", "X.A Y.A Z.A")
-      ._______Def_("       ", "   ----    ")
-      .____Ignore_("       ", "    ---    ")
-      .all();
+    words {
+      ("A.X A.Z" - "A.X A.Y A.Z")
+      ("       " - "   ----    ").default()
+      ("       " - "    ---    ").ignore()
+      testAll()
+    }
+
+    words {
+      ("X.A Z.A" - "X.A Y.A Z.A")
+      ("       " - "   ----    ").default()
+      ("       " - "    ---    ").ignore()
+      testAll()
+    }
 
     // prefer punctuation over whitespaces
-    TestData.words(".   ", "   .")
-      ._______Def_(" ---", "--- ")
-      .def();
+    words {
+      (".   " - "   .")
+      (" ---" - "--- ").default()
+      testDefault()
+    }
   }
-}
+}
\ No newline at end of file
index 9f66d755e3d2cae5fd23833d435a4689bc2522e8..1f252993a096c6d6030e39851a829c30b0467f11 100644 (file)
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package com.intellij.diff.tools.fragmented;
-
-import com.intellij.diff.util.Side;
-import com.intellij.testFramework.UsefulTestCase;
-import org.jetbrains.annotations.NotNull;
-
-public class LineNumberConvertorCorrectorTest extends UsefulTestCase {
-  public void testUnmodified() {
-    Test test = new Test();
-    test.equal(0, 0, 10, Side.LEFT);
-    test.equal(0, 0, 12, Side.RIGHT);
-    test.finish();
-
-    test.checkStrictSymmetrical();
-    test.ensureMatchedCount(10, 12);
+package com.intellij.diff.tools.fragmented
+
+import com.intellij.diff.util.Side
+import com.intellij.testFramework.UsefulTestCase
+import kotlin.test.assertEquals
+
+public class LineNumberConvertorCorrectorTest : UsefulTestCase() {
+  public fun testUnmodified() {
+    doTest(
+        {
+          equal(0, 0, 10, Side.LEFT)
+          equal(0, 0, 12, Side.RIGHT)
+        },
+        {
+          checkStrictSymmetrical()
+          ensureMatchedCount(10, 12)
+        }
+    )
   }
 
-  public void testEqual1() {
-    Test test = new Test();
-    test.equal(0, 0, 10, Side.LEFT);
-    test.equal(0, 0, 10, Side.RIGHT);
-    test.finish();
-
-    test.change(4, 3, 5, Side.LEFT);
-
-    test.checkStrictSymmetrical();
-    test.ensureMatchedCount(12, 7);
+  public fun testEqual1() {
+    doTest(
+        {
+          equal(0, 0, 10, Side.LEFT)
+          equal(0, 0, 10, Side.RIGHT)
+        },
+        {
+          change(4, 3, 5, Side.LEFT)
+
+          checkStrictSymmetrical()
+          ensureMatchedCount(12, 7)
+        }
+    )
   }
 
-  public void testEqual2() {
-    Test test = new Test();
-    test.equal(0, 0, 10, Side.LEFT);
-    test.equal(0, 0, 10, Side.RIGHT);
-    test.finish();
-
-    test.change(4, 5, 3, Side.RIGHT);
-
-    test.checkStrictSymmetrical();
-    test.ensureMatchedCount(5, 8);
+  public fun testEqual2() {
+    doTest(
+        {
+          equal(0, 0, 10, Side.LEFT)
+          equal(0, 0, 10, Side.RIGHT)
+        },
+        {
+          change(4, 5, 3, Side.RIGHT)
+
+          checkStrictSymmetrical()
+          ensureMatchedCount(5, 8)
+        }
+    )
   }
 
-  public void testEqual3() {
-    Test test = new Test();
-    test.equal(0, 0, 10, Side.LEFT);
-    test.equal(0, 0, 10, Side.RIGHT);
-    test.finish();
-
-    test.change(4, 3, 3, Side.LEFT);
-
-    test.checkStrictSymmetrical();
-    test.ensureMatchedCount(10, 7);
+  public fun testEqual3() {
+    doTest(
+        {
+          equal(0, 0, 10, Side.LEFT)
+          equal(0, 0, 10, Side.RIGHT)
+        },
+        {
+          change(4, 3, 3, Side.LEFT)
+
+          checkStrictSymmetrical()
+          ensureMatchedCount(10, 7)
+        }
+    )
   }
 
-  public void testEqual4() {
-    Test test = new Test();
-    test.equal(0, 0, 15, Side.LEFT);
-    test.equal(0, 0, 15, Side.RIGHT);
-    test.finish();
-
-    test.change(4, 3, 5, Side.LEFT);
-    test.checkStrictSymmetrical();
-    test.change(1, 2, 1, Side.RIGHT);
-    test.checkStrictSymmetrical();
-    test.change(12, 3, 1, Side.LEFT);
-    test.checkStrictSymmetrical();
+  public fun testEqual4() {
+    doTest(
+        {
+          equal(0, 0, 15, Side.LEFT)
+          equal(0, 0, 15, Side.RIGHT)
+        },
+        {
+          change(4, 3, 5, Side.LEFT)
+          checkStrictSymmetrical()
+          change(1, 2, 1, Side.RIGHT)
+          checkStrictSymmetrical()
+          change(12, 3, 1, Side.LEFT)
+          checkStrictSymmetrical()
+
+          ensureMatchedCount(13, 8)
+        }
+    )
+  }
 
-    test.ensureMatchedCount(13, 8);
+  public fun testInsideModifiedRange() {
+    doTest(
+        {
+          equal(0, 0, 15, Side.LEFT)
+          equal(0, 0, 15, Side.RIGHT)
+        },
+        {
+          change(0, 10, 15, Side.LEFT)
+          checkStrictSymmetrical()
+          change(0, 8, 6, Side.LEFT)
+          checkStrictSymmetrical()
+          change(2, 4, 2, Side.LEFT)
+          checkStrictSymmetrical()
+        }
+    )
   }
 
-  public void testInsideModifiedRange() {
-    Test test = new Test();
-    test.equal(0, 0, 15, Side.LEFT);
-    test.equal(0, 0, 15, Side.RIGHT);
-    test.finish();
-
-    test.change(0, 10, 15, Side.LEFT);
-    test.checkStrictSymmetrical();
-    test.change(0, 8, 6, Side.LEFT);
-    test.checkStrictSymmetrical();
-    test.change(2, 4, 2, Side.LEFT);
-    test.checkStrictSymmetrical();
+  //
+  // Impl
+  //
+
+  private fun doTest(prepare: TestBuilder.() -> Unit, check: Test.() -> Unit) {
+    val builder = TestBuilder()
+    builder.prepare()
+    val test = builder.finish()
+    test.check()
   }
 
-  private static class Test {
-    private final LineNumberConvertor.Builder myBuilder = new LineNumberConvertor.Builder();
-    private LineNumberConvertor myConvertor;
-    private int myLength = 0; // search for strict matchings in this boundaries (*2 - just in case)
+  private class TestBuilder {
+    private val builder = LineNumberConvertor.Builder()
+    private var maxLength = 0 // search for strict matchings in this boundaries (*2 - just in case)
 
-    public void equal(int onesideStart, int twosideStart, int length, @NotNull Side side) {
+    public fun equal(onesideStart: Int, twosideStart: Int, length: Int, side: Side) {
       if (side.isLeft()) {
-        myBuilder.put1(onesideStart, twosideStart, length);
+        builder.put1(onesideStart, twosideStart, length)
       }
       else {
-        myBuilder.put2(onesideStart, twosideStart, length);
+        builder.put2(onesideStart, twosideStart, length)
       }
-      myLength = Math.max(myLength, onesideStart + length);
-      myLength = Math.max(myLength, twosideStart + length);
+      maxLength = Math.max(maxLength, onesideStart + length)
+      maxLength = Math.max(maxLength, twosideStart + length)
     }
 
-    public void finish() {
-      myConvertor = myBuilder.build();
-    }
+    public fun finish(): Test = Test(builder.build(), maxLength)
+  }
 
-    public void change(int onesideLine, int oldLength, int newLength, @NotNull Side side) {
-      myConvertor.handleOnesideChange(onesideLine, onesideLine + oldLength, newLength - oldLength, side);
-      myLength = Math.max(myLength, myLength + newLength - oldLength);
+  private class Test(val convertor: LineNumberConvertor, var length: Int) {
+    public fun change(onesideLine: Int, oldLength: Int, newLength: Int, side: Side) {
+      convertor.handleOnesideChange(onesideLine, onesideLine + oldLength, newLength - oldLength, side)
+      length = Math.max(length, length + newLength - oldLength)
     }
 
-    public void checkStrictSymmetrical() {
-      for (int i = 0; i < myLength * 2; i++) {
-        int value1 = myConvertor.convertInv1(i);
-        if (value1 != -1) assertEquals(i, myConvertor.convert1(value1));
+    public fun checkStrictSymmetrical() {
+      for (i in 0..length * 2) {
+        val value1 = convertor.convertInv1(i)
+        if (value1 != -1) assertEquals(i, convertor.convert1(value1))
 
-        int value2 = myConvertor.convertInv2(i);
-        if (value2 != -1) assertEquals(i, myConvertor.convert2(value2));
+        val value2 = convertor.convertInv2(i)
+        if (value2 != -1) assertEquals(i, convertor.convert2(value2))
 
-        int value3 = myConvertor.convert1(i);
-        if (value3 != -1) assertEquals(i, myConvertor.convertInv1(value3));
+        val value3 = convertor.convert1(i)
+        if (value3 != -1) assertEquals(i, convertor.convertInv1(value3))
 
-        int value4 = myConvertor.convert2(i);
-        if (value4 != -1) assertEquals(i, myConvertor.convertInv2(value4));
+        val value4 = convertor.convert2(i)
+        if (value4 != -1) assertEquals(i, convertor.convertInv2(value4))
       }
     }
 
-    public void ensureMatchedCount(int minimumMatched1, int minimumMatched2) {
-      int counter1 = 0;
-      int counter2 = 0;
-      for (int i = 0; i < myLength * 2; i++) {
-        if (myConvertor.convert1(i) != -1) counter1++;
-        if (myConvertor.convert2(i) != -1) counter2++;
+    public fun ensureMatchedCount(minimumMatched1: Int, minimumMatched2: Int) {
+      var counter1 = 0
+      var counter2 = 0
+      for (i in 0..length * 2) {
+        if (convertor.convert1(i) != -1) counter1++
+        if (convertor.convert2(i) != -1) counter2++
       }
-      assertEquals(minimumMatched1, counter1);
-      assertEquals(minimumMatched2, counter2);
+      assertEquals(minimumMatched1, counter1)
+      assertEquals(minimumMatched2, counter2)
     }
 
-    public void printMatchings() {
-      for (int i = 0; i < myLength * 2; i++) {
-        int value = myConvertor.convert1(i);
-        if (value != -1) System.out.println("L: " + i + " - " + value);
+    public fun printMatchings() {
+      for (i in 0..length * 2 - 1) {
+        val value = convertor.convert1(i)
+        if (value != -1) println("L: " + i + " - " + value)
       }
 
-      for (int i = 0; i < myLength * 2; i++) {
-        int value = myConvertor.convert2(i);
-        if (value != -1) System.out.println("R: " + i + " - " + value);
+      for (i in 0..length * 2 - 1) {
+        val value = convertor.convert2(i)
+        if (value != -1) println("R: " + i + " - " + value)
       }
     }
   }
index 95fbf0e6de4350a16e998fdf5772cfe10cf5c4bf..957614e4e3e384d394fff59b7fe4506829f6d6c4 100644 (file)
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package com.intellij.diff.tools.fragmented;
-
-import com.intellij.testFramework.UsefulTestCase;
-
-public class LineNumberConvertorTest extends UsefulTestCase {
-  public void testEmpty() {
-    Test test = new Test();
-    test.finish();
-
-    test.checkEmpty(-5, 20);
-
-    test.checkEmptyInv(-5, 20);
+package com.intellij.diff.tools.fragmented
+
+import com.intellij.testFramework.UsefulTestCase
+import kotlin.test.assertEquals
+
+public class LineNumberConvertorTest : UsefulTestCase() {
+  public fun testEmpty() {
+    doTest(
+        {
+        },
+        {
+          checkEmpty(-5, 20)
+          checkEmptyInv(-5, 20)
+        }
+    )
   }
 
-  public void testSingleRange() {
-    Test test = new Test();
-    test.put(2, 3, 2);
-    test.finish();
-
-    test.checkMatch(2, 3, 2);
-
-    test.checkEmpty(-5, 1);
-    test.checkEmpty(4, 10);
-
-    test.checkEmptyInv(-5, 2);
-    test.checkEmptyInv(5, 10);
+  public fun testSingleRange() {
+    doTest(
+        {
+          put(2, 3, 2)
+        },
+        {
+          checkMatch(2, 3, 2)
+
+          checkEmpty(-5, 1)
+          checkEmpty(4, 10)
+
+          checkEmptyInv(-5, 2)
+          checkEmptyInv(5, 10)
+        }
+    )
   }
 
-  public void testTwoRanges() {
-    Test test = new Test();
-    test.put(2, 3, 2);
-    test.put(10, 7, 1);
-    test.finish();
-
-    test.checkMatch(2, 3, 2);
-    test.checkMatch(10, 7, 1);
-
-    test.checkEmpty(-5, 1);
-    test.checkEmpty(4, 9);
-    test.checkEmpty(11, 15);
-
-    test.checkEmptyInv(-5, 2);
-    test.checkEmptyInv(5, 6);
-    test.checkEmptyInv(8, 12);
+  public fun testTwoRanges() {
+    doTest(
+        {
+          put(2, 3, 2)
+          put(10, 7, 1)
+        },
+        {
+          checkMatch(2, 3, 2)
+          checkMatch(10, 7, 1)
+
+          checkEmpty(-5, 1)
+          checkEmpty(4, 9)
+          checkEmpty(11, 15)
+
+          checkEmptyInv(-5, 2)
+          checkEmptyInv(5, 6)
+          checkEmptyInv(8, 12)
+        }
+    )
   }
 
-  public void testAdjustmentRanges() {
-    Test test = new Test();
-    test.put(2, 3, 2);
-    test.put(4, 5, 3);
-    test.finish();
-
-    test.checkMatch(2, 3, 5);
-
-    test.checkEmpty(-5, 1);
-    test.checkEmpty(7, 10);
-
-    test.checkEmptyInv(-5, 2);
-    test.checkEmptyInv(8, 10);
+  public fun testAdjustmentRanges() {
+    doTest(
+        {
+          put(2, 3, 2)
+          put(4, 5, 3)
+        },
+        {
+          checkMatch(2, 3, 5)
+
+          checkEmpty(-5, 1)
+          checkEmpty(7, 10)
+
+          checkEmptyInv(-5, 2)
+          checkEmptyInv(8, 10)
+        }
+    )
   }
 
-  public void testPartiallyAdjustmentRanges() {
-    Test test = new Test();
-    test.put(2, 3, 2);
-    test.put(4, 10, 3);
-    test.finish();
-
-    test.checkMatch(2, 3, 2);
-    test.checkMatch(4, 10, 3);
-
-    test.checkEmpty(-5, 1);
-    test.checkEmpty(7, 10);
+  public fun testPartiallyAdjustmentRanges() {
+    doTest(
+        {
+          put(2, 3, 2)
+          put(4, 10, 3)
+        },
+        {
+          checkMatch(2, 3, 2)
+          checkMatch(4, 10, 3)
+
+          checkEmpty(-5, 1)
+          checkEmpty(7, 10)
+
+          checkEmptyInv(-5, 2)
+          checkEmptyInv(5, 9)
+          checkEmptyInv(13, 15)
+        }
+    )
+  }
 
-    test.checkEmptyInv(-5, 2);
-    test.checkEmptyInv(5, 9);
-    test.checkEmptyInv(13, 15);
+  public fun testTwoRangesApproximate() {
+    doTest(
+        {
+          put(1, 2, 1)
+          put(6, 5, 2)
+        },
+        {
+          assertEquals(0, convertor.convertApproximate1(0))
+          assertEquals(2, convertor.convertApproximate1(1))
+          assertEquals(3, convertor.convertApproximate1(2))
+          assertEquals(3, convertor.convertApproximate1(3))
+          assertEquals(3, convertor.convertApproximate1(4))
+          assertEquals(3, convertor.convertApproximate1(5))
+          assertEquals(5, convertor.convertApproximate1(6))
+          assertEquals(6, convertor.convertApproximate1(7))
+          assertEquals(7, convertor.convertApproximate1(8))
+          assertEquals(7, convertor.convertApproximate1(9))
+        }
+    )
   }
 
-  public void testTwoRangesApproximate() {
-    Test test = new Test();
-    test.put(1, 2, 1);
-    test.put(6, 5, 2);
-    test.finish();
-
-    assertEquals(0, test.myConvertor.convertApproximate1(0));
-    assertEquals(2, test.myConvertor.convertApproximate1(1));
-    assertEquals(3, test.myConvertor.convertApproximate1(2));
-    assertEquals(3, test.myConvertor.convertApproximate1(3));
-    assertEquals(3, test.myConvertor.convertApproximate1(4));
-    assertEquals(3, test.myConvertor.convertApproximate1(5));
-    assertEquals(5, test.myConvertor.convertApproximate1(6));
-    assertEquals(6, test.myConvertor.convertApproximate1(7));
-    assertEquals(7, test.myConvertor.convertApproximate1(8));
-    assertEquals(7, test.myConvertor.convertApproximate1(9));
+  //
+  // Impl
+  //
+
+  private fun doTest(prepare: TestBuilder.() -> Unit, check: Test.() -> Unit) {
+    val builder = TestBuilder()
+    builder.prepare()
+    val test = builder.finish()
+    test.check()
   }
 
-  private static class Test {
-    private final LineNumberConvertor.Builder myBuilder = new LineNumberConvertor.Builder();
-    private LineNumberConvertor myConvertor;
+  private class TestBuilder {
+    private val builder = LineNumberConvertor.Builder()
 
-    public void put(int left, int right, int length) {
-      myBuilder.put1(left, right, length);
+    public fun put(left: Int, right: Int, length: Int) {
+      builder.put1(left, right, length)
     }
 
-    public void finish() {
-      myConvertor = myBuilder.build();
-    }
+    public fun finish(): Test = Test(builder.build())
+  }
 
-    public void checkMatch(int left, int right, int length) {
-      for (int i = 0; i < length; i++) {
-        assertEquals(right + i, myConvertor.convert1(left + i));
-        assertEquals(left + i, myConvertor.convertInv1(right + i));
+  private class Test(val convertor: LineNumberConvertor) {
+    public fun checkMatch(left: Int, right: Int, length: Int) {
+      for (i in 0..length - 1) {
+        assertEquals(right + i, convertor.convert1(left + i))
+        assertEquals(left + i, convertor.convertInv1(right + i))
       }
     }
 
-    public void checkEmpty(int start, int end) {
-      for (int i = start; i <= end; i++) {
-        assertEquals(-1, myConvertor.convert1(i));
+    public fun checkEmpty(start: Int, end: Int) {
+      for (i in start..end) {
+        assertEquals(-1, convertor.convert1(i))
       }
     }
 
-    public void checkEmptyInv(int start, int end) {
-      for (int i = start; i <= end; i++) {
-        assertEquals(-1, myConvertor.convertInv1(i));
+    public fun checkEmptyInv(start: Int, end: Int) {
+      for (i in start..end) {
+        assertEquals(-1, convertor.convertInv1(i))
       }
     }
   }
index 6d3b4c18232104f1cd5438b8164a1c1f6db442b5..c7baa1c1a1fb3caa6347e2b5ccedb6f14d26c185 100644 (file)
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package com.intellij.diff.tools.fragmented;
-
-import com.intellij.diff.comparison.AutoTestCase;
-import com.intellij.diff.comparison.ComparisonManager;
-import com.intellij.diff.comparison.ComparisonManagerImpl;
-import com.intellij.diff.comparison.ComparisonPolicy;
-import com.intellij.diff.fragments.LineFragment;
-import com.intellij.diff.util.LineRange;
-import com.intellij.diff.util.Side;
-import com.intellij.openapi.editor.Document;
-import com.intellij.openapi.editor.impl.DocumentImpl;
-import com.intellij.openapi.progress.DumbProgressIndicator;
-import com.intellij.openapi.util.text.StringUtil;
-import com.intellij.util.containers.HashMap;
-import org.jetbrains.annotations.NotNull;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Map;
-
-public class UnifiedFragmentBuilderAutoTest extends AutoTestCase {
-  private static ComparisonManager myComparisonManager = new ComparisonManagerImpl();
-
-  private static final int CHAR_COUNT = 12;
-  private static final Map<Integer, Character> CHAR_TABLE = initCharMap();
-
-  public void test() throws Exception {
-    doTest(System.currentTimeMillis(), 30, 30);
+package com.intellij.diff.tools.fragmented
+
+import com.intellij.diff.comparison.AutoTestCase
+import com.intellij.diff.comparison.ComparisonManagerImpl
+import com.intellij.diff.comparison.ComparisonPolicy
+import com.intellij.diff.util.LineRange
+import com.intellij.diff.util.Side
+import com.intellij.openapi.editor.Document
+import com.intellij.openapi.editor.impl.DocumentImpl
+import com.intellij.openapi.progress.DumbProgressIndicator
+import com.intellij.openapi.util.text.StringUtil
+import com.intellij.util.containers.HashMap
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+
+public class UnifiedFragmentBuilderAutoTest : AutoTestCase() {
+  public fun test() {
+    doTest(System.currentTimeMillis(), 30, 30)
   }
 
-  public void doTest(long seed, int runs, int maxLength) throws Exception {
-    myRng.setSeed(seed);
+  public fun doTest(seed: Long, runs: Int, maxLength: Int) {
+    RNG.setSeed(seed)
 
-    ComparisonPolicy policy = null;
-    Side masterSide = null;
+    var policy: ComparisonPolicy? = null
+    var masterSide: Side? = null
+    var lastSeed: Long = -1;
 
-    for (int i = 0; i < runs; i++) {
-      if (i % 1000 == 0) System.out.println(i);
-      Document text1 = null;
-      Document text2 = null;
+    for (i in 1..runs) {
+      if (i % 1000 == 0) println(i)
+      var text1: Document? = null
+      var text2: Document? = null
       try {
-        rememberSeed();
+        lastSeed = getCurrentSeed()
 
-        text1 = generateText(maxLength);
-        text2 = generateText(maxLength);
+        text1 = generateText(maxLength)
+        text2 = generateText(maxLength)
 
-        for (Side side : Side.values()) {
-          for (ComparisonPolicy comparisonPolicy : ComparisonPolicy.values()) {
-            policy = comparisonPolicy;
-            masterSide = side;
-            doTest(text1, text2, policy, masterSide);
+        for (side in Side.values()) {
+          for (comparisonPolicy in ComparisonPolicy.values()) {
+            policy = comparisonPolicy
+            masterSide = side
+            doTest(text1, text2, policy, masterSide)
           }
         }
       }
-      catch (Throwable e) {
-        System.out.println("Seed: " + seed);
-        System.out.println("Runs: " + runs);
-        System.out.println("MaxLength: " + maxLength);
-        System.out.println("Policy: " + policy);
-        System.out.println("Current side: " + masterSide);
-        System.out.println("I: " + i);
-        System.out.println("Current seed: " + getLastSeed());
-        System.out.println("Text1: " + textToReadableFormat(text1));
-        System.out.println("Text2: " + textToReadableFormat(text2));
-        if (e instanceof Error) throw (Error)e;
-        if (e instanceof Exception) throw (Exception)e;
-        throw new Exception(e);
+      catch (e: Throwable) {
+        println("Seed: " + seed)
+        println("Runs: " + runs)
+        println("MaxLength: " + maxLength)
+        println("Policy: " + policy!!)
+        println("Current side: " + masterSide!!)
+        println("I: " + i)
+        println("Current seed: " + lastSeed)
+        println("Text1: " + textToReadableFormat(text1?.getCharsSequence()))
+        println("Text2: " + textToReadableFormat(text2?.getCharsSequence()))
+        throw e
       }
     }
   }
 
-  public void doTest(@NotNull Document document1, @NotNull Document document2, @NotNull ComparisonPolicy policy, @NotNull Side masterSide) {
-    CharSequence sequence1 = document1.getCharsSequence();
-    CharSequence sequence2 = document2.getCharsSequence();
+  public fun doTest(document1: Document, document2: Document, policy: ComparisonPolicy, masterSide: Side) {
+    val sequence1 = document1.getCharsSequence()
+    val sequence2 = document2.getCharsSequence()
 
-    List<LineFragment> fragments = myComparisonManager.compareLinesInner(sequence1, sequence2,
-                                                                         policy, DumbProgressIndicator.INSTANCE);
+    val fragments = MANAGER.compareLinesInner(sequence1, sequence2, policy, DumbProgressIndicator.INSTANCE)
 
-    UnifiedFragmentBuilder builder = new UnifiedFragmentBuilder(fragments, document1, document2, masterSide);
-    builder.exec();
+    val builder = UnifiedFragmentBuilder(fragments, document1, document2, masterSide)
+    builder.exec()
 
-    boolean ignoreWhitespaces = policy != ComparisonPolicy.DEFAULT;
-    CharSequence text = builder.getText();
-    List<ChangedBlock> blocks = builder.getBlocks();
-    LineNumberConvertor convertor = builder.getConvertor();
-    List<LineRange> changedLines = builder.getChangedLines();
-    List<HighlightRange> ranges = builder.getRanges();
+    val ignoreWhitespaces = policy !== ComparisonPolicy.DEFAULT
+    val text = builder.getText()
+    val blocks = builder.getBlocks()
+    val convertor = builder.getConvertor()
+    val changedLines = builder.getChangedLines()
+    val ranges = builder.getRanges()
 
     // both documents - before and after - should be subsequence of result text.
-    assertTrue(isSubsequence(text, sequence1, ignoreWhitespaces));
-    assertTrue(isSubsequence(text, sequence2, ignoreWhitespaces));
+    assertTrue(isSubsequence(text, sequence1, ignoreWhitespaces))
+    assertTrue(isSubsequence(text, sequence2, ignoreWhitespaces))
 
     // all changes should be inside ChangedLines
-    for (LineFragment fragment : fragments) {
-      int startLine1 = fragment.getStartLine1();
-      int endLine1 = fragment.getEndLine1();
-      int startLine2 = fragment.getStartLine2();
-      int endLine2 = fragment.getEndLine2();
-
-      for (int i = startLine1; i < endLine1; i++) {
-        int targetLine = convertor.convertInv1(i);
-        assertTrue(targetLine != -1);
-        assertTrue(isLineChanged(targetLine, changedLines));
+    for (fragment in fragments) {
+      val startLine1 = fragment.getStartLine1()
+      val endLine1 = fragment.getEndLine1()
+      val startLine2 = fragment.getStartLine2()
+      val endLine2 = fragment.getEndLine2()
+
+      for (i in startLine1 until endLine1) {
+        val targetLine = convertor.convertInv1(i)
+        assertTrue(targetLine != -1)
+        assertTrue(isLineChanged(targetLine, changedLines))
       }
-      for (int i = startLine2; i < endLine2; i++) {
-        int targetLine = convertor.convertInv2(i);
-        assertTrue(targetLine != -1);
-        assertTrue(isLineChanged(targetLine, changedLines));
+      for (i in startLine2 until endLine2) {
+        val targetLine = convertor.convertInv2(i)
+        assertTrue(targetLine != -1)
+        assertTrue(isLineChanged(targetLine, changedLines))
       }
     }
 
     // changed fragments and changed blocks should have same content
-    assertEquals(blocks.size(), fragments.size());
-    for (int i = 0; i < fragments.size(); i++) {
-      LineFragment fragment = fragments.get(i);
-      ChangedBlock block = blocks.get(i);
+    assertEquals(blocks.size(), fragments.size())
+    for (i in fragments.indices) {
+      val fragment = fragments.get(i)
+      val block = blocks.get(i)
 
-      CharSequence fragment1 = sequence1.subSequence(fragment.getStartOffset1(), fragment.getEndOffset1());
-      CharSequence fragment2 = sequence2.subSequence(fragment.getStartOffset2(), fragment.getEndOffset2());
+      val fragment1 = sequence1.subSequence(fragment.getStartOffset1(), fragment.getEndOffset1())
+      val fragment2 = sequence2.subSequence(fragment.getStartOffset2(), fragment.getEndOffset2())
 
-      CharSequence block1 = text.subSequence(block.getStartOffset1(), block.getEndOffset1());
-      CharSequence block2 = text.subSequence(block.getStartOffset2(), block.getEndOffset2());
+      val block1 = text.subSequence(block.getStartOffset1(), block.getEndOffset1())
+      val block2 = text.subSequence(block.getStartOffset2(), block.getEndOffset2())
 
-      assertEqualsCharSequences(fragment1, block1, ignoreWhitespaces, true);
-      assertEqualsCharSequences(fragment2, block2, ignoreWhitespaces, true);
+      assertEqualsCharSequences(fragment1, block1, ignoreWhitespaces, true)
+      assertEqualsCharSequences(fragment2, block2, ignoreWhitespaces, true)
     }
 
     // ranges should have exact same content
-    for (HighlightRange range : ranges) {
-      CharSequence sideSequence = range.getSide().select(sequence1, sequence2);
-      CharSequence baseRange = text.subSequence(range.getBase().getStartOffset(), range.getBase().getEndOffset());
-      CharSequence sideRange = sideSequence.subSequence(range.getChanged().getStartOffset(), range.getChanged().getEndOffset());
-      assertTrue(StringUtil.equals(baseRange, sideRange));
+    for (range in ranges) {
+      val sideSequence = range.getSide().select(sequence1, sequence2)
+      val baseRange = text.subSequence(range.getBase().getStartOffset(), range.getBase().getEndOffset())
+      val sideRange = sideSequence.subSequence(range.getChanged().getStartOffset(), range.getChanged().getEndOffset())
+      assertTrue(StringUtil.equals(baseRange, sideRange))
     }
   }
 
-  private static boolean isSubsequence(@NotNull CharSequence text, @NotNull CharSequence sequence, boolean ignoreWhitespaces) {
-    int index1 = 0;
-    int index2 = 0;
+  private fun isSubsequence(text: CharSequence, sequence: CharSequence, ignoreWhitespaces: Boolean): Boolean {
+    var index1 = 0
+    var index2 = 0
 
     while (index2 < sequence.length()) {
-      char c2 = sequence.charAt(index2);
-      if (c2 == '\n' ||
-          StringUtil.isWhiteSpace(c2) && ignoreWhitespaces) {
-        index2++;
-        continue;
+      val c2 = sequence.charAt(index2)
+      if (c2 == '\n' || (StringUtil.isWhiteSpace(c2) && ignoreWhitespaces)) {
+        index2++
+        continue
       }
 
-      assertTrue(index1 < text.length());
-      char c1 = text.charAt(index1);
-      if (c1 == '\n' ||
-          StringUtil.isWhiteSpace(c1) && ignoreWhitespaces) {
-        index1++;
-        continue;
+      assertTrue(index1 < text.length())
+      val c1 = text.charAt(index1)
+      if (c1 == '\n' || (StringUtil.isWhiteSpace(c1) && ignoreWhitespaces)) {
+        index1++
+        continue
       }
 
       if (c1 == c2) {
-        index1++;
-        index2++;
+        index1++
+        index2++
       }
       else {
-        index1++;
+        index1++
       }
     }
 
-    return true;
+    return true
   }
 
-  private static boolean isLineChanged(int line, @NotNull List<LineRange> changedLines) {
-    for (LineRange changedLine : changedLines) {
-      if (changedLine.start <= line && changedLine.end > line) return true;
+  private fun isLineChanged(line: Int, changedLines: List<LineRange>): Boolean {
+    for (changedLine in changedLines) {
+      if (changedLine.start <= line && changedLine.end > line) return true
     }
-    return false;
+    return false
   }
 
-  @NotNull
-  private Document generateText(int maxLength) {
-    return new DocumentImpl(generateText(maxLength, CHAR_COUNT, CHAR_TABLE));
+  private fun generateText(maxLength: Int): Document {
+    return DocumentImpl(generateText(maxLength, CHAR_COUNT, CHAR_TABLE))
   }
 
-  @NotNull
-  private static Map<Integer, Character> initCharMap() {
-    Map<Integer, Character> map = new HashMap<Integer, Character>();
-
-    List<Character> characters = new ArrayList<Character>();
-    characters.add('\n');
-    characters.add('\n');
-    characters.add('\t');
-    characters.add(' ');
-    characters.add(' ');
-    characters.add('.');
-    characters.add('<');
-    characters.add('!');
-
-    for (int i = 0; i < characters.size(); i++) {
-      map.put(i, characters.get(i));
-    }
+  companion object {
+    private val MANAGER = ComparisonManagerImpl()
 
-    return map;
+    private val CHAR_COUNT = 12
+    private val CHAR_TABLE: Map<Int, Char> = {
+      val map = HashMap<Int, Char>()
+      listOf('\n', '\n', '\t', ' ', ' ', '.', '<', '!').forEachIndexed { i, c -> map.put(i, c) }
+      map
+    }()
   }
 }
index dadb6a9e6e30be94f84bc3cea55199395ec0572f..ef08a714af7cc551802295911894aeea59ae24f2 100644 (file)
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package com.intellij.diff.tools.fragmented;
+package com.intellij.diff.tools.fragmented
 
-import com.intellij.diff.comparison.ComparisonManager;
-import com.intellij.diff.comparison.ComparisonManagerImpl;
-import com.intellij.diff.comparison.ComparisonPolicy;
-import com.intellij.diff.fragments.LineFragment;
-import com.intellij.diff.util.LineRange;
-import com.intellij.diff.util.Side;
-import com.intellij.openapi.editor.Document;
-import com.intellij.openapi.editor.impl.DocumentImpl;
-import com.intellij.openapi.progress.DumbProgressIndicator;
-import com.intellij.testFramework.UsefulTestCase;
+import com.intellij.diff.comparison.ComparisonManagerImpl
+import com.intellij.diff.comparison.ComparisonPolicy
+import com.intellij.diff.util.LineRange
+import com.intellij.diff.util.Side
+import com.intellij.openapi.editor.impl.DocumentImpl
+import com.intellij.openapi.progress.DumbProgressIndicator
+import com.intellij.testFramework.UsefulTestCase
+import kotlin.test.assertEquals
+import kotlin.test.assertFalse
+import kotlin.test.assertTrue
 
-import java.util.Collections;
-import java.util.List;
+public class UnifiedFragmentBuilderTest : UsefulTestCase() {
+  public fun testEquals() {
+    val document1 = DocumentImpl("A\nB\nC")
+    val document2 = DocumentImpl("A\nB\nC")
 
-public class UnifiedFragmentBuilderTest extends UsefulTestCase {
-  private static ComparisonManager myComparisonManager = new ComparisonManagerImpl();
+    val fragments = MANAGER.compareLinesInner(document1.getCharsSequence(), document2.getCharsSequence(), ComparisonPolicy.DEFAULT, DumbProgressIndicator.INSTANCE)
 
-  public void testEquals() {
-    Document document1 = new DocumentImpl("A\nB\nC");
-    Document document2 = new DocumentImpl("A\nB\nC");
+    val builder = UnifiedFragmentBuilder(fragments, document1, document2, Side.LEFT)
+    builder.exec()
 
-    List<LineFragment> fragments = myComparisonManager.compareLinesInner(document1.getCharsSequence(), document2.getCharsSequence(),
-                                                                         ComparisonPolicy.DEFAULT, DumbProgressIndicator.INSTANCE);
-
-    UnifiedFragmentBuilder builder = new UnifiedFragmentBuilder(fragments, document1, document2, Side.LEFT);
-    builder.exec();
-
-    assertTrue(builder.isEqual());
-    assertEquals(builder.getText().toString(), "A\nB\nC\n");
-    assertEmpty(builder.getChangedLines());
-    assertEmpty(builder.getBlocks());
+    assertTrue(builder.isEqual())
+    assertEquals(builder.getText().toString(), "A\nB\nC\n")
+    UsefulTestCase.assertEmpty(builder.getChangedLines())
+    UsefulTestCase.assertEmpty(builder.getBlocks())
   }
 
-  public void testWrongEndLineTypoBug() {
-    Document document1 = new DocumentImpl("A\nB\nC\nD");
-    Document document2 = new DocumentImpl("A\nD");
+  public fun testWrongEndLineTypoBug() {
+    val document1 = DocumentImpl("A\nB\nC\nD")
+    val document2 = DocumentImpl("A\nD")
 
-    List<LineFragment> fragments = myComparisonManager.compareLinesInner(document1.getCharsSequence(), document2.getCharsSequence(),
-                                                                         ComparisonPolicy.DEFAULT, DumbProgressIndicator.INSTANCE);
+    val fragments = MANAGER.compareLinesInner(document1.getCharsSequence(), document2.getCharsSequence(), ComparisonPolicy.DEFAULT, DumbProgressIndicator.INSTANCE)
 
-    UnifiedFragmentBuilder builder = new UnifiedFragmentBuilder(fragments, document1, document2, Side.RIGHT);
-    builder.exec();
+    val builder = UnifiedFragmentBuilder(fragments, document1, document2, Side.RIGHT)
+    builder.exec()
 
-    assertFalse(builder.isEqual());
-    assertEquals(builder.getText().toString(), "A\nB\nC\nD\n");
-    assertEquals(builder.getChangedLines(), Collections.singletonList(new LineRange(1, 3)));
+    assertFalse(builder.isEqual())
+    assertEquals(builder.getText().toString(), "A\nB\nC\nD\n")
+    assertEquals(builder.getChangedLines(), listOf(LineRange(1, 3)))
+
+    assertEquals(builder.getBlocks().size(), 1)
+    val block = builder.getBlocks().get(0)
+    assertEquals(block.getLine1(), 1)
+    assertEquals(block.getLine2(), 3)
+    assertEquals(block.getStartOffset1(), 2)
+    assertEquals(block.getEndOffset1(), 6)
+    assertEquals(block.getStartOffset2(), 6)
+    assertEquals(block.getEndOffset2(), 6)
+  }
 
-    assertEquals(builder.getBlocks().size(), 1);
-    ChangedBlock block = builder.getBlocks().get(0);
-    assertEquals(block.getLine1(), 1);
-    assertEquals(block.getLine2(), 3);
-    assertEquals(block.getStartOffset1(), 2);
-    assertEquals(block.getEndOffset1(), 6);
-    assertEquals(block.getStartOffset2(), 6);
-    assertEquals(block.getEndOffset2(), 6);
+  companion object {
+    private val MANAGER = ComparisonManagerImpl()
   }
 }