IDEA-164144 Intention offers change to comparingInt for long fields

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/comparatorCombinators/afterByte.java

@@ -0,0 +1,18 @@
+// "Replace with Comparator.comparingInt" "true"
+
+import java.util.*;
+
+public class Main {
+  static class Data {
+    short s;
+    byte b;
+    char c;
+    int i;
+    long l;
+    double d;
+  }
+
+  void sort(List<Data> data) {
+    data.sort(Comparator.comparingInt(d -> d.b));
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/comparatorCombinators/afterByteDiff.java

@@ -0,0 +1,18 @@
+// "Replace with Comparator.comparingInt" "true"
+
+import java.util.*;
+
+public class Main {
+  static class Data {
+    short s;
+    byte b;
+    char c;
+    int i;
+    long l;
+    double d;
+  }
+
+  void sort(List<Data> data) {
+    data.sort(Comparator.comparingInt(d -> d.b));
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/comparatorCombinators/afterCharDiff.java

@@ -0,0 +1,18 @@
+// "Replace with Comparator.comparingInt" "true"
+
+import java.util.*;
+
+public class Main {
+  static class Data {
+    short s;
+    byte b;
+    char c;
+    int i;
+    long l;
+    double d;
+  }
+
+  void sort(List<Data> data) {
+    data.sort(Comparator.comparingInt(d -> d.c));
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/comparatorCombinators/afterCharacterDiff.java

@@ -0,0 +1,18 @@
+// "Replace with Comparator.comparingInt" "true"
+
+import java.util.*;
+
+public class Main {
+  static class Data {
+    Short s;
+    Byte b;
+    Character c;
+    Integer i;
+    Long l;
+    Double d;
+  }
+
+  void sort(List<Data> data) {
+    data.sort(Comparator.comparingInt(d -> d.c));
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/comparatorCombinators/afterDoubleDiff.java

@@ -0,0 +1,18 @@
+// "Replace with Comparator.comparingDouble" "true"
+
+import java.util.*;
+
+public class Main {
+  static class Data {
+    short s;
+    byte b;
+    char c;
+    int i;
+    long l;
+    double d;
+  }
+
+  void sort(List<Data> data) {
+    data.sort(Comparator.comparingDouble(d -> d.d));
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/comparatorCombinators/afterLongDiff.java

@@ -0,0 +1,18 @@
+// "Replace with Comparator.comparingLong" "true"
+
+import java.util.*;
+
+public class Main {
+  static class Data {
+    short s;
+    byte b;
+    char c;
+    int i;
+    long l;
+    double d;
+  }
+
+  void sort(List<Data> data) {
+    data.sort(Comparator.comparingLong(d -> d.l));
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/comparatorCombinators/beforeByte.java

@@ -0,0 +1,18 @@
+// "Replace with Comparator.comparingInt" "true"
+
+import java.util.*;
+
+public class Main {
+  static class Data {
+    short s;
+    byte b;
+    char c;
+    int i;
+    long l;
+    double d;
+  }
+
+  void sort(List<Data> data) {
+    data.sort((d1, d2) -> Byte.comp<caret>are(d1.b, d2.b));
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/comparatorCombinators/beforeByteDiff.java

@@ -0,0 +1,18 @@
+// "Replace with Comparator.comparingInt" "true"
+
+import java.util.*;
+
+public class Main {
+  static class Data {
+    short s;
+    byte b;
+    char c;
+    int i;
+    long l;
+    double d;
+  }
+
+  void sort(List<Data> data) {
+    data.sort((d1, d2) -> d1.b - d2.<caret>b);
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/comparatorCombinators/beforeCharDiff.java

@@ -0,0 +1,18 @@
+// "Replace with Comparator.comparingInt" "true"
+
+import java.util.*;
+
+public class Main {
+  static class Data {
+    short s;
+    byte b;
+    char c;
+    int i;
+    long l;
+    double d;
+  }
+
+  void sort(List<Data> data) {
+    data.sort((d1, d2) -> d1.c - d2.<caret>c);
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/comparatorCombinators/beforeCharacterDiff.java

@@ -0,0 +1,18 @@
+// "Replace with Comparator.comparingInt" "true"
+
+import java.util.*;
+
+public class Main {
+  static class Data {
+    Short s;
+    Byte b;
+    Character c;
+    Integer i;
+    Long l;
+    Double d;
+  }
+
+  void sort(List<Data> data) {
+    data.sort((d1, d2) -> d1.<caret>c - d2.c);
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/comparatorCombinators/beforeDoubleDiff.java

@@ -0,0 +1,18 @@
+// "Replace with Comparator.comparingDouble" "true"
+
+import java.util.*;
+
+public class Main {
+  static class Data {
+    short s;
+    byte b;
+    char c;
+    int i;
+    long l;
+    double d;
+  }
+
+  void sort(List<Data> data) {
+    data.sort((d1, d2) -> d1.d - d2.<caret>d);
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/comparatorCombinators/beforeLongDiff.java

@@ -0,0 +1,18 @@
+// "Replace with Comparator.comparingLong" "true"
+
+import java.util.*;
+
+public class Main {
+  static class Data {
+    short s;
+    byte b;
+    char c;
+    int i;
+    long l;
+    double d;
+  }
+
+  void sort(List<Data> data) {
+    data.sort((d1, d2) -> d1.l - d2.<caret>l);
+  }
+}