diff options
Diffstat (limited to 'java/java-tests/testData')
111 files changed, 1143 insertions, 60 deletions
diff --git a/java/java-tests/testData/codeInsight/completion/javadoc/QualifyClassReferenceInPackageStatement.java b/java/java-tests/testData/codeInsight/completion/javadoc/QualifyClassReferenceInPackageStatement.java new file mode 100644 index 000000000000..e92cc86cc8eb --- /dev/null +++ b/java/java-tests/testData/codeInsight/completion/javadoc/QualifyClassReferenceInPackageStatement.java @@ -0,0 +1,8 @@ +/** + * @see XHell<caret> + */ +package foo.bar; + +class XHello { + +}
\ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/completion/javadoc/QualifyClassReferenceInPackageStatement_after.java b/java/java-tests/testData/codeInsight/completion/javadoc/QualifyClassReferenceInPackageStatement_after.java new file mode 100644 index 000000000000..8cbb31c1688f --- /dev/null +++ b/java/java-tests/testData/codeInsight/completion/javadoc/QualifyClassReferenceInPackageStatement_after.java @@ -0,0 +1,8 @@ +/** + * @see foo.bar.XHello<caret> + */ +package foo.bar; + +class XHello { + +}
\ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/completion/keywords/arrayClass.java b/java/java-tests/testData/codeInsight/completion/keywords/arrayClass.java new file mode 100644 index 000000000000..80690075bcea --- /dev/null +++ b/java/java-tests/testData/codeInsight/completion/keywords/arrayClass.java @@ -0,0 +1,5 @@ +public class Util { + int goo() { + String[].<caret>x + } +} diff --git a/java/java-tests/testData/codeInsight/completion/keywords/finalAfterCase.java b/java/java-tests/testData/codeInsight/completion/keywords/finalAfterCase.java new file mode 100644 index 000000000000..0d201763da54 --- /dev/null +++ b/java/java-tests/testData/codeInsight/completion/keywords/finalAfterCase.java @@ -0,0 +1,8 @@ +public class StructuredConfigKey { + { + switch (x) { + case 2: + <caret> + } + } +} diff --git a/java/java-tests/testData/codeInsight/completion/normal/ImplementViaCompletion.java b/java/java-tests/testData/codeInsight/completion/normal/ImplementViaCompletion.java new file mode 100644 index 000000000000..85d7845803d8 --- /dev/null +++ b/java/java-tests/testData/codeInsight/completion/normal/ImplementViaCompletion.java @@ -0,0 +1,7 @@ +interface Foo<T> { + void run(T t, int myInt); +} + +public class A implements Foo<String> { + p<caret> +} diff --git a/java/java-tests/testData/codeInsight/completion/normal/ImplementViaCompletion_after.java b/java/java-tests/testData/codeInsight/completion/normal/ImplementViaCompletion_after.java new file mode 100644 index 000000000000..a13b20e89807 --- /dev/null +++ b/java/java-tests/testData/codeInsight/completion/normal/ImplementViaCompletion_after.java @@ -0,0 +1,10 @@ +interface Foo<T> { + void run(T t, int myInt); +} + +public class A implements Foo<String> { + @Override + public void run(String s, int myInt) { + <selection>//To change body of implemented methods use File | Settings | File Templates.</selection> + } +} diff --git a/java/java-tests/testData/codeInsight/completion/normal/TypeParameterItemPresentation.java b/java/java-tests/testData/codeInsight/completion/normal/TypeParameterItemPresentation.java new file mode 100644 index 000000000000..c56297de58d7 --- /dev/null +++ b/java/java-tests/testData/codeInsight/completion/normal/TypeParameterItemPresentation.java @@ -0,0 +1,5 @@ +public class Foo<Param> { + <Param2> int goo() { + Pa<caret> + } +} diff --git a/java/java-tests/testData/codeInsight/completion/normalSorting/AlphaSortingStartMatchesFirst.java b/java/java-tests/testData/codeInsight/completion/normalSorting/AlphaSortingStartMatchesFirst.java new file mode 100644 index 000000000000..87423fdc5cfb --- /dev/null +++ b/java/java-tests/testData/codeInsight/completion/normalSorting/AlphaSortingStartMatchesFirst.java @@ -0,0 +1,12 @@ +class Goo { + { + int xxfoo; + int fooxx; + int xxgoo; + int gooxx; + int xxbar; + int barxx; + xx<caret> + } + +}
\ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/completion/normalSorting/LocalVarsOverStats.java b/java/java-tests/testData/codeInsight/completion/normalSorting/LocalVarsOverStats.java new file mode 100644 index 000000000000..ec010fe2ac72 --- /dev/null +++ b/java/java-tests/testData/codeInsight/completion/normalSorting/LocalVarsOverStats.java @@ -0,0 +1,8 @@ +public class Foo { + + void foo(PsiElement psiElement) { + psiEl<caret> + } +} + +class PsiElement {}
\ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/completion/smartType/ArrayInitializerBeforeVarargs-out.java b/java/java-tests/testData/codeInsight/completion/smartType/ArrayInitializerBeforeVarargs-out.java index bec60ac2de6b..49ce3eb54d4b 100644 --- a/java/java-tests/testData/codeInsight/completion/smartType/ArrayInitializerBeforeVarargs-out.java +++ b/java/java-tests/testData/codeInsight/completion/smartType/ArrayInitializerBeforeVarargs-out.java @@ -1,5 +1,5 @@ class Super { void foo(String[] params, int... indices) { - foo(new String[]{<caret>}, 0); + foo(new String[<caret>], 0); } }
\ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/completion/smartType/IgnoreDefaultMethods-out.java b/java/java-tests/testData/codeInsight/completion/smartType/IgnoreDefaultMethods-out.java new file mode 100644 index 000000000000..f6b90f287be6 --- /dev/null +++ b/java/java-tests/testData/codeInsight/completion/smartType/IgnoreDefaultMethods-out.java @@ -0,0 +1,18 @@ +interface Predicate<T> { + public boolean test(T t); + public default Predicate<T> and(Predicate<? super T> p) { + return null; + } +} + + +public class Test1 { + { + Predicate p = new Predicate() { + @Override + public boolean test(Object o) { + <selection>return false; //To change body of implemented methods use File | Settings | File Templates.</selection> + } + }; + } +} diff --git a/java/java-tests/testData/codeInsight/completion/smartType/IgnoreDefaultMethods.java b/java/java-tests/testData/codeInsight/completion/smartType/IgnoreDefaultMethods.java new file mode 100644 index 000000000000..ea35c5cb45c5 --- /dev/null +++ b/java/java-tests/testData/codeInsight/completion/smartType/IgnoreDefaultMethods.java @@ -0,0 +1,13 @@ +interface Predicate<T> { + public boolean test(T t); + public default Predicate<T> and(Predicate<? super T> p) { + return null; + } +} + + +public class Test1 { + { + Predicate p = new Predic<caret> + } +} diff --git a/java/java-tests/testData/codeInsight/completion/smartType/SemicolonInCodeBlocBodyInLocalVariable.java b/java/java-tests/testData/codeInsight/completion/smartType/SemicolonInCodeBlocBodyInLocalVariable.java index fa6f209bf19b..e98107784592 100644 --- a/java/java-tests/testData/codeInsight/completion/smartType/SemicolonInCodeBlocBodyInLocalVariable.java +++ b/java/java-tests/testData/codeInsight/completion/smartType/SemicolonInCodeBlocBodyInLocalVariable.java @@ -1,5 +1,5 @@ class Test { public void foo() { - Runnable r = () -> {<caret>}; + Runnable r = () -> {n<caret>}; } } diff --git a/java/java-tests/testData/codeInsight/completion/smartType/SemicolonInExpressionBodyInExpressionList.java b/java/java-tests/testData/codeInsight/completion/smartType/SemicolonInExpressionBodyInExpressionList.java index 7b403c035879..a9a9766a2724 100644 --- a/java/java-tests/testData/codeInsight/completion/smartType/SemicolonInExpressionBodyInExpressionList.java +++ b/java/java-tests/testData/codeInsight/completion/smartType/SemicolonInExpressionBodyInExpressionList.java @@ -1,5 +1,5 @@ class Test { public void foo() { - new Thread(() -> <caret>); + new Thread(() -> n<caret>); } } diff --git a/java/java-tests/testData/codeInsight/completion/smartType/SemicolonInExpressionBodyInLocalVariable.java b/java/java-tests/testData/codeInsight/completion/smartType/SemicolonInExpressionBodyInLocalVariable.java index e41c2a19a0d3..b0dee48e23d7 100644 --- a/java/java-tests/testData/codeInsight/completion/smartType/SemicolonInExpressionBodyInLocalVariable.java +++ b/java/java-tests/testData/codeInsight/completion/smartType/SemicolonInExpressionBodyInLocalVariable.java @@ -1,5 +1,5 @@ class Test { public void foo() { - Runnable r = () -> <caret> + Runnable r = () -> n<caret> } } diff --git a/java/java-tests/testData/codeInsight/completion/smartType/ThrowExceptionConstructor-out.java b/java/java-tests/testData/codeInsight/completion/smartType/ThrowExceptionConstructor-out.java index 7d740e51351c..d105afd9a5d7 100644 --- a/java/java-tests/testData/codeInsight/completion/smartType/ThrowExceptionConstructor-out.java +++ b/java/java-tests/testData/codeInsight/completion/smartType/ThrowExceptionConstructor-out.java @@ -4,6 +4,6 @@ class MyException extends RuntimeException { class XXX { { - throw new MyException(new String[]{<caret>}); + throw new MyException(new String[<caret>]); } }
\ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting/InnerClassConstantReference.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting/InnerClassConstantReference.java new file mode 100644 index 000000000000..ba341f1b7489 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting/InnerClassConstantReference.java @@ -0,0 +1,11 @@ +class Test { + public Test() { + this(Const.CONST); + } + + public Test(int l) {} + + private class Const { + private static final int CONST = 42; + } +}
\ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting/InnerClassesShadowing.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting/InnerClassesShadowing.java index e87c5db28998..647df2b9e7b0 100644 --- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting/InnerClassesShadowing.java +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting/InnerClassesShadowing.java @@ -95,4 +95,18 @@ class WithFileInputStream { private FileInputStream(String str) { } } -}
\ No newline at end of file +} + +class ContainingKlass { + public static class Inner { + } + + private static class OuterInner { + private static final class Inner { + private Inner s() { + return this; + } + } + } +} + diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting/NumericLiterals.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting/NumericLiterals.java index becdda581a2a..45f728d465f8 100644 --- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting/NumericLiterals.java +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting/NumericLiterals.java @@ -1,24 +1,4 @@ -/* - * Copyright 2000-2012 JetBrains s.r.o. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -/// assignment compatible types -import java.io.*; -import java.net.*; - -public class a { +public class NumericLiterals { final int FI = 2; final int FIBIG = 200000000; @@ -38,7 +18,8 @@ public class a { int i13 = <error descr="Integer number too large">040000000000</error>; int i14 = 020000000000; int i15 = <error descr="Integer number too large">0xf044332211</error>; - int octale = 017777777777; // negative + int oi1 = 017777777777; + int oi2 = <error descr="Integer number too large">08</error>; int bi1 = <error descr="Binary literals are not supported at this language level">0b0010</error>; int bi2 = <error descr="Binary literals are not supported at this language level">0B0010</error>; int bi3 = <error descr="Underscores in literals are not supported at this language level">1_2</error>; @@ -53,8 +34,8 @@ public class a { long l8 = 0xffffffffffffffffL; long l9 = <error descr="Long number too large">0xffffffffffffffff9L</error>; long l10 = 0x8000000000000000L; - long octalValue = 01777777777777777777600L; - long octalValua = 01777777777777777777777L; + long ol1 = 01777777777777777777600L; + long ol2 = 01777777777777777777777L; long bl1 = <error descr="Binary literals are not supported at this language level">0b0010l</error>; long bl2 = <error descr="Binary literals are not supported at this language level">0B0010L</error>; long bl3 = <error descr="Underscores in literals are not supported at this language level">10_24L</error>; @@ -63,7 +44,8 @@ public class a { float f2 = <error descr="Floating point number too large">1e39f</error>; float f3 = 0E1F; float f4 = <error descr="Hexadecimal floating point literals are not supported at this language level">0xabc.defP2f</error>; - float bf1 = <error descr="Underscores in literals are not supported at this language level">3.141_592f</error>; + float f5 = <error descr="Underscores in literals are not supported at this language level">3.141_592f</error>; + float f6 = .0f; double dd1 = <error descr="Floating point number too small">1e-324</error>; double dd2 = <error descr="Floating point number too large">1e309</error>; @@ -81,5 +63,6 @@ public class a { double d10 = <error descr="Malformed floating point literal">1e-F</error>; double d11 = <error descr="Malformed floating point literal">1e-f</error>; double d12 = <error descr="Underscores in literals are not supported at this language level">3.141_592_653_589_793d</error>; + double d13 = <error descr="Malformed floating point literal">.0e</error>; } } diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting/importDefaultPackage/Test.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting/importDefaultPackage/Test.java index 64f17b3299c0..6402fa536bbc 100644 --- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting/importDefaultPackage/Test.java +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting/importDefaultPackage/Test.java @@ -1,4 +1,5 @@ public class Test { public Test(int i) { + new x(); } } diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting/importDefaultPackage/x.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting/importDefaultPackage/x.java new file mode 100644 index 000000000000..88b90d97d842 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting/importDefaultPackage/x.java @@ -0,0 +1 @@ +class x { } diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting/lang.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting/lang.java new file mode 100644 index 000000000000..39f8b0f7f30c --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting/lang.java @@ -0,0 +1,3 @@ +package java; + +<error descr="Class 'java.lang' clashes with package of same name">class lang</error> { } diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting/packageClassClash1/pkg/sub.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting/packageClassClash1/pkg/sub.java new file mode 100644 index 000000000000..3b442d2610ac --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting/packageClassClash1/pkg/sub.java @@ -0,0 +1,3 @@ +package pkg; + +<error descr="Class 'pkg.sub' clashes with package of same name">public class sub</error> { }
\ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting/packageClassClash1/pkg/sub/Test.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting/packageClassClash1/pkg/sub/Test.java new file mode 100644 index 000000000000..f2dbcbd38b91 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting/packageClassClash1/pkg/sub/Test.java @@ -0,0 +1,3 @@ +package <error descr="Package 'pkg.sub' clashes with class of same name">pkg.sub</error>; + +public class Test { }
\ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting/packageClassClash2/pkg/Sub.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting/packageClassClash2/pkg/Sub.java new file mode 100644 index 000000000000..bea47a75e0e3 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting/packageClassClash2/pkg/Sub.java @@ -0,0 +1,3 @@ +package pkg; + +public class Sub { }
\ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting/packageClassClash2/pkg/sub/Test.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting/packageClassClash2/pkg/sub/Test.java new file mode 100644 index 000000000000..bf2f203764d6 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting/packageClassClash2/pkg/sub/Test.java @@ -0,0 +1,3 @@ +package pkg.sub; + +public class Test { }
\ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting/packageObscuring/main/Main.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting/packageObscuring/main/Main.java new file mode 100644 index 000000000000..ec7d7e6611ae --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting/packageObscuring/main/Main.java @@ -0,0 +1,12 @@ +package main; + +public class Main { + public static void main(String[] args) { + pkg.sub.Test obj = new pkg.sub.Test(); + obj.m1(); + obj.<error descr="Cannot resolve method 'm2()'">m2</error>(); + + pkg.sub.Test.s1(); + pkg.sub.Test.<error descr="Cannot resolve method 's2()'">s2</error>(); + } +} diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting/packageObscuring/pkg/sub.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting/packageObscuring/pkg/sub.java new file mode 100644 index 000000000000..21764febddbc --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting/packageObscuring/pkg/sub.java @@ -0,0 +1,9 @@ +package pkg; + +class sub { + public static class Test { + public void m2() { } + + public static void s2() { } + } +} diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting/packageObscuring/pkg/sub/Test.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting/packageObscuring/pkg/sub/Test.java new file mode 100644 index 000000000000..90c5d6ebfb13 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting/packageObscuring/pkg/sub/Test.java @@ -0,0 +1,7 @@ +package pkg.sub; + +public class Test { + public void m1() { } + + public static void s1() { } +} diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting7/JavacQuirks.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting6/JavacQuirks.java index e95529cd16c1..e95529cd16c1 100644 --- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting7/JavacQuirks.java +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting6/JavacQuirks.java diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting7/AmbiguousMethodCallIDEA100314.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting7/AmbiguousMethodCallIDEA100314.java new file mode 100644 index 000000000000..2c155443365c --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting7/AmbiguousMethodCallIDEA100314.java @@ -0,0 +1,13 @@ +class Intellij { + + public static <T> T getProperty(final String str, final Class<T> cls) { + return null; + } + + public static <T> T getProperty(final String str, final T defaultValue) { + return null; + } + + String[] ids = Intellij.getProperty(" ", String[].class); + +}
\ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting7/NumericLiterals.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting7/NumericLiterals.java index bf9f96ff1e96..cb59ded58cc6 100644 --- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting7/NumericLiterals.java +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting7/NumericLiterals.java @@ -7,6 +7,11 @@ public class NumericLiterals { int i5 = 0b0001_0010_0100_1000; int i6 = <error descr="Binary numbers must contain at least one binary digit">0b</error>; int i7 = <error descr="Integer number too large">0b1_1111_1111_1111_1111_1111_1111_1111_1111</error>; + int i8 = <error descr="Illegal underscore">0_</error>; + int i9 = <error descr="Integer number too large">0_8</error>; + int i10 = <error descr="Illegal underscore">0x_f</error>; + int i11 = <error descr="Illegal underscore">0b_1</error>; + int i12 = <error descr="Integer number too large">0B2</error>; long l1 = 1_2L; long l2 = 012__34l; @@ -41,5 +46,7 @@ public class NumericLiterals { double d10 = 0x.a_bcP1___23d; double d11 = <error descr="Floating point number too small">1e-3_2_4</error>; double d12 = <error descr="Floating point number too large">0xa_bc.de_fP1_234D</error>; + double d13 = <error descr="Illegal underscore">0x1.0_p-1</error>; + double d14 = <error descr="Illegal underscore">1.0e_1022</error>; } } diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting7/UncheckedWarningIDEA99357.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting7/UncheckedWarningIDEA99357.java new file mode 100644 index 000000000000..e6635ac196f4 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting7/UncheckedWarningIDEA99357.java @@ -0,0 +1,12 @@ +class Test { + public static void main(String[] args) { + Foo f = new Foo(); + System.out.println(f.get()); + } +} + +class Foo<<warning descr="Type parameter 'T' is never used">T</warning>> { + public <T1> T1 get() { + return null; + } +}
\ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting7/UncheckedWarningIDEA99536.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting7/UncheckedWarningIDEA99536.java new file mode 100644 index 000000000000..7cab4aff7f31 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting7/UncheckedWarningIDEA99536.java @@ -0,0 +1,29 @@ +import java.util.*; +class A<<warning descr="Type parameter 'T' is never used">T</warning>> { +} + +class B<<warning descr="Type parameter 'S' is never used">S</warning>> extends A { +} + +class C extends A<String> { +} + + +class D extends A { +} + + +public class Main { + public static void test(Collection<? extends A> <warning descr="Parameter 'c' is never used">c</warning>) {} + + public static void main(String[] args) { + Collection<B> bs = new ArrayList<B>(); + test(bs); + + Collection<C> cs = new ArrayList<C>(); + test(cs); + + Collection<D> ds = new ArrayList<D>(); + test(ds); + } +}
\ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/genericsHighlighting/IDEA86875.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/genericsHighlighting/IDEA86875.java new file mode 100644 index 000000000000..c5a65df099ab --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/genericsHighlighting/IDEA86875.java @@ -0,0 +1,11 @@ +interface Base<E> {} +interface Base2<E> {} + +class A<E extends Cloneable> { + <P, K extends Base<E>&Base2<P>> void m(K k, P p) { + E e = null; + m(k, e); + } + + void m(Base<E> k, E e) {} +} diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/genericsHighlighting/IDEA99061.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/genericsHighlighting/IDEA99061.java new file mode 100644 index 000000000000..b6e8f3cfa619 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/genericsHighlighting/IDEA99061.java @@ -0,0 +1,11 @@ +class Test { + { + String a = cast("str"); + Integer[] b = cast(new Integer[0]); + Object[] c = cast(new Object[0]); + } + + private <T> T cast(Object obj) { + return (T)obj; + } +}
\ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/genericsHighlighting/IDEA99347.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/genericsHighlighting/IDEA99347.java new file mode 100644 index 000000000000..9c4922400b7d --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/genericsHighlighting/IDEA99347.java @@ -0,0 +1,12 @@ +interface Errors { + java.util.Collection<java.lang.String> getErrorMessages(); + +} + +class Test extends AbstrClass implements Errors { +} + + +abstract class AbstrClass { + public java.util.Collection getErrorMessages() {return null;} +} diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/graphInference/ChainedInference.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/graphInference/ChainedInference.java new file mode 100644 index 000000000000..49c813e2a878 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/graphInference/ChainedInference.java @@ -0,0 +1,26 @@ +import java.util.*; + +class Main { + + void foo(List<Integer> list) { + bar(list, i -> i.intValue(), i -> i.<error descr="Cannot resolve method 'unknown()'">unknown</error>()); + bar1(list, i -> i.intValue(), i -> i.<error descr="Cannot resolve method 'unknown()'">unknown</error>()); + } + + <U, S_IN, S_OUT, R> R bar(List<S_IN> list, + Fun<S_IN, S_OUT> f1, + Fun<S_OUT, R> f2) { + return null; + } + + <R, S_IN, S_OUT> R bar1(List<S_IN> list, + Fun<S_IN, S_OUT> f1, + Fun<S_OUT, R> f2) { + return null; + } + + + public interface Fun<T, R> { + public R _(T t); + } +} diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/graphInference/ChainedInference1.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/graphInference/ChainedInference1.java new file mode 100644 index 000000000000..3033b3971428 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/graphInference/ChainedInference1.java @@ -0,0 +1,14 @@ +class Main { + + <R> void bar(Fun<Integer, R> collector) { } + + <T, D> Fun<T, Integer> foo(D d) { return null; } + + public void test() { + bar(foo("")); + } + + interface Fun<T, R> { + R _(T t); + } +}
\ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/graphInference/InferenceFromSiblings.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/graphInference/InferenceFromSiblings.java new file mode 100644 index 000000000000..1cad86808b98 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/graphInference/InferenceFromSiblings.java @@ -0,0 +1,24 @@ +import java.util.*; + +class Main { + + void test(List<Integer> li) { + Fun<Stream<Integer>, Stream<Integer>> f = s -> s.substr(0); + foo(li, f, Collections.emptyList()); + + foo(li, s -> s.substr(0), Collections.emptyList()); + } + + <T, U, S_OUT extends Stream<U>, It extends Iterable<U>> Collection<U> + foo(Collection<T> coll, Fun<Stream<T>, S_OUT> f, It it) { + return null; + } + + interface Stream<T> { + Stream<T> substr(long startingOffset); + } + + interface Fun<T, R> { + R _(T t); + } +}
\ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/graphInference/NestedCalls.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/graphInference/NestedCalls.java new file mode 100644 index 000000000000..0c91d21fdbfd --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/graphInference/NestedCalls.java @@ -0,0 +1,15 @@ +import java.util.*; +public class Main { + public static <T> T foo() {return null;} + + public static <B> List<B> bar(B b) {return null;} + static { + List<String> s = bar(foo()); + } + + + public static <B> B bar1(B b) {return null;} + static { + String s1 = bar1(foo()); + } +} diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/graphInference/NestedCallsSameMethod.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/graphInference/NestedCallsSameMethod.java new file mode 100644 index 000000000000..e4d33d38747f --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/graphInference/NestedCallsSameMethod.java @@ -0,0 +1,9 @@ +class Main { + static <T> T foo(T t) { return null; } + + static { + long l1 = foo(foo(1)); + Integer i = 1; + long l2 = foo(foo(i)); + } +}
\ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/graphInference/ReturnStmt.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/graphInference/ReturnStmt.java new file mode 100644 index 000000000000..dae02b68773f --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/graphInference/ReturnStmt.java @@ -0,0 +1,27 @@ +import java.util.*; +class Main { + + <T, R> Collector<T, R> m(Supplier<? extends R> supplier, BiConsumer<R, T> accumulator) { + return null; + } + + <T, C extends Collection<T>> Collector<T, C> test1(Supplier<C> collectionFactory) { + return m(collectionFactory, Collection::add); + } + + Collector<String, StringBuilder> test2(Supplier<StringBuilder> sb) { + return m(sb, StringBuilder::append); + } + + interface Supplier<T> { + public T get(); + } + + interface Collector<T, R> { + } + + interface BiConsumer<T, U> { + void accept(T t, U u); + } + +}
\ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/AmbiguityReturnValueResolution.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/AmbiguityReturnValueResolution.java new file mode 100644 index 000000000000..43c4ba966b7b --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/AmbiguityReturnValueResolution.java @@ -0,0 +1,26 @@ +public interface IDEA99969 { + default IntStream distinct(Stream s) { + return s.map(i -> (int) i); + } +} +interface Stream<T> { + <R> Stream<R> map(Function<? super T, ? extends R> mapper); + IntStream map(IntFunction<? super T> mapper); + LongStream map(LongFunction<? super T> mapper); +} + +interface Function<T, R> { + public R apply(T t); +} + +interface IntFunction<T> { + public int applyAsInt(T t); +} + +interface LongFunction<T> { + public long applyAsLong(T t); +} + + +interface IntStream {} +interface LongStream {} diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/AmbiguitySpecificReturn.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/AmbiguitySpecificReturn.java new file mode 100644 index 000000000000..c0908783911c --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/AmbiguitySpecificReturn.java @@ -0,0 +1,30 @@ +class IntStream { + private void foo(IntStream s) { + s.map(i -> 1 << i); + s.map(i -> 1); + s.map(i -> i); + } + + public static void main(String[] args) { + new IntStream().foo(null); + } + + private IntStream map(IntUnaryOperator mapper) { + System.out.println(mapper); + return null; + } + + private <T> IntStream <warning descr="Private method 'map(ObjIntFunction<T>)' is never used">map</warning>(ObjIntFunction<T> mapper) { + System.out.println(mapper); + return null; + } +} + +interface IntUnaryOperator { + public int applyAsInt(int operand); +} + +interface ObjIntFunction<T> { + public T apply(int i); +} + diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/FunctionalInterfaceAnnotation.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/FunctionalInterfaceAnnotation.java new file mode 100644 index 000000000000..05b2585c8405 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/FunctionalInterfaceAnnotation.java @@ -0,0 +1,5 @@ +<error descr="Multiple non-overriding abstract methods found">@FunctionalInterface</error> +interface Test { + void foo(); + void bar(); +}
\ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/IncompleteSubst.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/IncompleteSubst.java index 9085c69489d3..366bea30534d 100644 --- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/IncompleteSubst.java +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/IncompleteSubst.java @@ -48,7 +48,7 @@ class LambdaTest2<TypeParam> { U map(T t); } - public <U> LambdaTest<U> map(final Mapper<? super TypeParam, ? extends U> mapper) { + public <U> LambdaTest2<U> map(final Mapper<? super TypeParam, ? extends U> mapper) { return null; } diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/IntersectionTypeInCast.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/IntersectionTypeInCast.java new file mode 100644 index 000000000000..49a261c8b8de --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/IntersectionTypeInCast.java @@ -0,0 +1,8 @@ +import java.io.Serializable; +import java.util.*; + +class Test { + public static <K extends Comparable<? super K>, V> Comparator<Map.Entry<K, V>> foo() { + return (Comparator<Map.Entry<K, V>> & Serializable)(c1, c2) -> c1.getKey().compareTo(c2.getKey()); + } +} diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/UnhandledExceptions.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/UnhandledExceptions.java new file mode 100644 index 000000000000..077940408e56 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/UnhandledExceptions.java @@ -0,0 +1,19 @@ +public class ExTest { + public static void maybeThrow(String data) throws Ex { + throw new Ex(data); + } + + { + Block<String> b = (t) -> <error descr="Unhandled exception: ExTest.Ex">ExTest.maybeThrow(t)</error>; + } + + + private static class Ex extends Throwable { + public Ex(String s) { + } + } +} + +interface Block<T> { + public void accept(T t); +}
\ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting7/DefaultMethodVisibility.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/interfaceMethods/DefaultMethodVisibility.java index 4a2c0eeb4801..4a2c0eeb4801 100644 --- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting7/DefaultMethodVisibility.java +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/interfaceMethods/DefaultMethodVisibility.java diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting7/ExtensionMethodSyntax.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/interfaceMethods/ExtensionMethodSyntax.java index a5e0917301b6..a5e0917301b6 100644 --- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting7/ExtensionMethodSyntax.java +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/interfaceMethods/ExtensionMethodSyntax.java diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting7/ExtensionMethods.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/interfaceMethods/ExtensionMethods.java index a7fcb99947c1..44a2a1aaf39f 100644 --- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting7/ExtensionMethods.java +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/interfaceMethods/ExtensionMethods.java @@ -50,7 +50,7 @@ class D { } interface IllegalMods { - <error descr="Illegal combination of modifiers: 'static' and 'abstract'">static</error> void m1(); + <error descr="Static methods in interfaces should have a body">static void m1()</error>; <error descr="Illegal combination of modifiers: 'static' and 'default'">static</error> void m2() default { } <error descr="Illegal combination of modifiers: 'static' and 'default'">static</error> <error descr="Illegal combination of modifiers: 'default' and 'static'">default</error> void m3() { } diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/interfaceMethods/InheritUnrelatedDefaults.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/interfaceMethods/InheritUnrelatedDefaults.java new file mode 100644 index 000000000000..bbcf8b47d745 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/interfaceMethods/InheritUnrelatedDefaults.java @@ -0,0 +1,3 @@ +interface B { default void foo() {} } +interface C { default void foo() {} } +class <error descr="D inherits unrelated defaults for foo() from types B and C">D</error> implements B, C {} diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/interfaceMethods/NotInheritFromUnrelatedDefault.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/interfaceMethods/NotInheritFromUnrelatedDefault.java new file mode 100644 index 000000000000..cfc1ee7abec4 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/interfaceMethods/NotInheritFromUnrelatedDefault.java @@ -0,0 +1,15 @@ +interface FirstParent { + + default int doSomething() { + return 1; + } +} + +interface SecondParent { + + int doSomething(); +} + +class <error descr="Class 'SecondParent' must either be declared abstract or implement abstract method 'doSomething()' in 'SecondParent'">FirstSon</error> implements FirstParent, SecondParent {} + +<error descr="Class 'SecondSon' must either be declared abstract or implement abstract method 'doSomething()' in 'SecondParent'">class SecondSon implements SecondParent, FirstParent</error> {}
\ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/interfaceMethods/staticMethod.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/interfaceMethods/staticMethod.java new file mode 100644 index 000000000000..d1a1f41c7bc0 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/interfaceMethods/staticMethod.java @@ -0,0 +1,4 @@ +interface Foo { + public static void bar1() {} + public <error descr="Illegal combination of modifiers: 'abstract' and 'static'">abstract</error> static void bar2() {} +}
\ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/CapturedWildcards.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/CapturedWildcards.java new file mode 100644 index 000000000000..269b075c4d84 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/CapturedWildcards.java @@ -0,0 +1,14 @@ +public class Main { + public static <T> void make(final Consumer<? super T> consumer) { + Sink<T> accept = (Sink<T>) consumer::accept; + Consumer<T> accept1 = (Consumer<T>)consumer::accept; + } +} + +interface Sink<T> extends Consumer<T> { + +} + +interface Consumer<T> { + public void accept(T t); +} diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/ConstructorNonAbstractAbstractExpected.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/ConstructorNonAbstractAbstractExpected.java new file mode 100644 index 000000000000..86d8bea66f7d --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/ConstructorNonAbstractAbstractExpected.java @@ -0,0 +1,23 @@ +import java.util.ArrayList; +import java.util.List; + +public class IDEA99970 { + public static <T, C> Collector<T, C> toCollection(Supplier<C> collectionFactory) { + return null; + } + + public static <T> Collector<T, List<T>> toList() { + return toCollection(ArrayList<T>::new); + } + + public static <T> Collector<T, List<T>> toList1() { + return toCollection(ArrayList<T>::new); + } + +} + +interface Supplier<T> { + public T get(); +} + +interface Collector<T, R> {}
\ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/IntersectionTypeInCast.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/IntersectionTypeInCast.java new file mode 100644 index 000000000000..f3c5e504f1e0 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/IntersectionTypeInCast.java @@ -0,0 +1,6 @@ +import java.io.Serializable; +class Test { + { + Runnable r = (Runnable & Serializable)Test::new; + } +} diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/UnhandledExceptions.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/UnhandledExceptions.java new file mode 100644 index 000000000000..a03154d9ecf4 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/UnhandledExceptions.java @@ -0,0 +1,19 @@ +public class ExTest { + public static void maybeThrow(String data) throws Ex { + throw new Ex(data); + } + + { + Block<String> b = <error descr="Unhandled exception: ExTest.Ex">ExTest::maybeThrow</error>; + } + + + private static class Ex extends Throwable { + public Ex(String s) { + } + } +} + +interface Block<T> { + public void accept(T t); +}
\ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/params/FormalParamsWithWildcards.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/params/FormalParamsWithWildcards.java new file mode 100644 index 000000000000..0bbcdd54dd92 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/params/FormalParamsWithWildcards.java @@ -0,0 +1,9 @@ +class Test { + public interface I<K, V> { + public V put(K k); + } + + { + final I<? super Long, CharSequence> i = (Number n) -> n.toString(); + } +}
\ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/params/Raw.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/params/Raw.java index e99747fa6169..eeaa80410bb6 100644 --- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/params/Raw.java +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/params/Raw.java @@ -1,7 +1,7 @@ class Test { { - <error descr="Incompatible types. Found: '<lambda expression>', required: 'java.lang.Comparable'">Comparable c = (String o)->{ + Comparable c = (<error descr="Incompatible parameter types in lambda expression">String o</error>)->{ return 0; - };</error> + }; } }
\ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/createClassFromNew/beforeQualifiedNew.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/createClassFromNew/beforeQualifiedNew.java new file mode 100644 index 000000000000..516a79faae83 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/createClassFromNew/beforeQualifiedNew.java @@ -0,0 +1,6 @@ +// "Create Class 'ArrayList'" "false" +public class Test { + public static void main() { + q.new <caret>ArrayList(); + } +}
\ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/createInnerClassFromNew/beforeQualifiedNew1.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/createInnerClassFromNew/beforeQualifiedNew1.java new file mode 100644 index 000000000000..ce4542d9e4f9 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/createInnerClassFromNew/beforeQualifiedNew1.java @@ -0,0 +1,6 @@ +// "Create Inner Class 'ArrayList'" "false" +public class Test { + public static void main() { + q.new <caret>ArrayList(); + } +}
\ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/createInnerClassFromNew/beforeQualifiedNew2.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/createInnerClassFromNew/beforeQualifiedNew2.java new file mode 100644 index 000000000000..6fa79f02d8d9 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/createInnerClassFromNew/beforeQualifiedNew2.java @@ -0,0 +1,9 @@ +// "Create Inner Class 'ArrayList'" "false" +public class Test { + public static void main() { + Inner q = new Inner(); + q.new <caret>ArrayList(); + } + + static class Inner { } +}
\ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/createLocalVarFromInstanceof/afterInSimpleMethod.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/createLocalVarFromInstanceof/afterInSimpleMethod.java new file mode 100644 index 000000000000..f4477b22bed5 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/createLocalVarFromInstanceof/afterInSimpleMethod.java @@ -0,0 +1,11 @@ +// "Insert '(NodeInfo)parent' declaration" "true" +public abstract class A { + public void getNodeElements(Object parent) { + if (!(parent instanceof NodeInfo)) return; + NodeInfo nodeInfo = (NodeInfo) parent; + <caret> + } + + private static class NodeInfo { + } +} diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/createLocalVarFromInstanceof/beforeInSimpleMethod.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/createLocalVarFromInstanceof/beforeInSimpleMethod.java new file mode 100644 index 000000000000..8a78a53124e2 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/createLocalVarFromInstanceof/beforeInSimpleMethod.java @@ -0,0 +1,9 @@ +// "Insert '(NodeInfo)parent' declaration" "true" +public abstract class A { + public void getNodeElements(Object parent) { + if (!(parent instanceof <caret>NodeInfo)) return; + } + + private static class NodeInfo { + } +} diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/lambda2methodReference/afterAmbiguosResult.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/lambda2methodReference/afterAmbiguosResult.java new file mode 100644 index 000000000000..c6614e06a7fb --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/lambda2methodReference/afterAmbiguosResult.java @@ -0,0 +1,21 @@ +// "Replace lambda with method reference" "true" +import java.util.*; +class IDEA100385 { + void foo(N<Double> n, List<Double> l){ + n.forEach((DoubleConsumer) l::add); + } + static interface N<E> { + default void forEach(DoubleConsumer consumer) { + } + void forEach(Consumer<? super E> consumer); + } + + interface DoubleConsumer { + void _(double d); + } + + interface Consumer<T> { + public void accept(T t); + } + +} diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/lambda2methodReference/afterLocalClass.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/lambda2methodReference/afterLocalClass.java new file mode 100644 index 000000000000..27a9470f21dd --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/lambda2methodReference/afterLocalClass.java @@ -0,0 +1,37 @@ +// "Replace lambda with method reference" "true" +public class IDEA100452 { + public static <T> MatchOp<T> match(MatchOp.MatchKind matchKind) { + class MatchSink extends BooleanTerminalSink<T> { + + private MatchSink() { + super(matchKind); + } + + @Override + public void accept(T t) { + } + } + + Supplier<BooleanTerminalSink<T>> s = MatchSink::new; + return new MatchOp<>(1, matchKind, s); + } + + static abstract class BooleanTerminalSink<T> { + public BooleanTerminalSink(MatchOp.MatchKind matchKind) { + + } + + public abstract void accept(T t); + } + static interface Supplier<T> { + public T get(); + } + + static class MatchOp<H> { + public MatchOp(int i, MatchKind matchKind, Supplier<BooleanTerminalSink<H>> s) { + //To change body of created methods use File | Settings | File Templates. + } + + static enum MatchKind {} + } +} diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/lambda2methodReference/beforeAmbiguosResult.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/lambda2methodReference/beforeAmbiguosResult.java new file mode 100644 index 000000000000..077b9e6c91f2 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/lambda2methodReference/beforeAmbiguosResult.java @@ -0,0 +1,23 @@ +// "Replace lambda with method reference" "true" +import java.util.*; +class IDEA100385 { + void foo(N<Double> n, List<Double> l){ + n.forEach((double e) -> { + l.ad<caret>d(e); + }); + } + static interface N<E> { + default void forEach(DoubleConsumer consumer) { + } + void forEach(Consumer<? super E> consumer); + } + + interface DoubleConsumer { + void _(double d); + } + + interface Consumer<T> { + public void accept(T t); + } + +} diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/lambda2methodReference/beforeLocalClass.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/lambda2methodReference/beforeLocalClass.java new file mode 100644 index 000000000000..9dfd3b42f1b3 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/lambda2methodReference/beforeLocalClass.java @@ -0,0 +1,37 @@ +// "Replace lambda with method reference" "true" +public class IDEA100452 { + public static <T> MatchOp<T> match(MatchOp.MatchKind matchKind) { + class MatchSink extends BooleanTerminalSink<T> { + + private MatchSink() { + super(matchKind); + } + + @Override + public void accept(T t) { + } + } + + Supplier<BooleanTerminalSink<T>> s = () -> new Match<caret>Sink(); + return new MatchOp<>(1, matchKind, s); + } + + static abstract class BooleanTerminalSink<T> { + public BooleanTerminalSink(MatchOp.MatchKind matchKind) { + + } + + public abstract void accept(T t); + } + static interface Supplier<T> { + public T get(); + } + + static class MatchOp<H> { + public MatchOp(int i, MatchKind matchKind, Supplier<BooleanTerminalSink<H>> s) { + //To change body of created methods use File | Settings | File Templates. + } + + static enum MatchKind {} + } +} diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/replaceWithTernaryOperator/afterChain.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/replaceWithTernaryOperator/afterChain.java new file mode 100644 index 000000000000..7d3370d33743 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/replaceWithTernaryOperator/afterChain.java @@ -0,0 +1,10 @@ +// "Replace with 'integer != null ?:'" "true" + +import java.lang.Integer; + +class A{ + void test(){ + Integer integer = null; + int i = integer != null ? integer.toString().length() : <selection>0</selection>; + } +}
\ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/replaceWithTernaryOperator/beforeChain.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/replaceWithTernaryOperator/beforeChain.java new file mode 100644 index 000000000000..4728847e397b --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/replaceWithTernaryOperator/beforeChain.java @@ -0,0 +1,10 @@ +// "Replace with 'integer != null ?:'" "true" + +import java.lang.Integer; + +class A{ + void test(){ + Integer integer = null; + int i = in<caret>teger.toString().length(); + } +}
\ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/surroundWithTry/afterLambdaCodeBlock.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/surroundWithTry/afterLambdaCodeBlock.java new file mode 100644 index 000000000000..67eeb7469d52 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/surroundWithTry/afterLambdaCodeBlock.java @@ -0,0 +1,26 @@ +// "Surround with try/catch" "true" +public class ExTest { + public static void maybeThrow(String data) throws Ex { + throw new Ex(data); + } + + { + Block<String> b = (t) -> { + try { + return ExTest.maybeThrow(t); + } catch (Ex ex) { + <selection>ex.printStackTrace(); //To change body of catch statement use File | Settings | File Templates.</selection> + } + }; + } + + + private static class Ex extends Throwable { + public Ex(String s) { + } + } +} + +interface Block<T> { + public void accept(T t); +}
\ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/surroundWithTry/beforeLambdaCodeBlock.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/surroundWithTry/beforeLambdaCodeBlock.java new file mode 100644 index 000000000000..1b296d021490 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/surroundWithTry/beforeLambdaCodeBlock.java @@ -0,0 +1,20 @@ +// "Surround with try/catch" "true" +public class ExTest { + public static void maybeThrow(String data) throws Ex { + throw new Ex(data); + } + + { + Block<String> b = (t) -> { return ExTest.may<caret>beThrow(t);}; + } + + + private static class Ex extends Throwable { + public Ex(String s) { + } + } +} + +interface Block<T> { + public void accept(T t); +}
\ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/surroundWithTry/beforeLambdaExpr.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/surroundWithTry/beforeLambdaExpr.java new file mode 100644 index 000000000000..2cb6adb41d38 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/surroundWithTry/beforeLambdaExpr.java @@ -0,0 +1,20 @@ +// "Surround with try/catch" "false" +public class ExTest { + public static void maybeThrow(String data) throws Ex { + throw new Ex(data); + } + + { + Block<String> b = (t) -> ExTest.may<caret>beThrow(t); + } + + + private static class Ex extends Throwable { + public Ex(String s) { + } + } +} + +interface Block<T> { + public void accept(T t); +}
\ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/surroundWithTry/beforeMethodRef.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/surroundWithTry/beforeMethodRef.java new file mode 100644 index 000000000000..80cc540bed71 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/surroundWithTry/beforeMethodRef.java @@ -0,0 +1,20 @@ +// "Surround with try/catch" "false" +public class ExTest { + public static void maybeThrow(String data) throws Ex { + throw new Ex(data); + } + + { + Block<String> b = ExTest::may<caret>beThrow(t); + } + + + private static class Ex extends Throwable { + public Ex(String s) { + } + } +} + +interface Block<T> { + public void accept(T t); +}
\ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/documentation/inherit.gif b/java/java-tests/testData/codeInsight/documentation/inherit.gif Binary files differnew file mode 100644 index 000000000000..c814867a13de --- /dev/null +++ b/java/java-tests/testData/codeInsight/documentation/inherit.gif diff --git a/java/java-tests/testData/codeInsight/invertIfCondition/afterParenthesis1.java b/java/java-tests/testData/codeInsight/invertIfCondition/afterParenthesis1.java new file mode 100644 index 000000000000..4584077665e2 --- /dev/null +++ b/java/java-tests/testData/codeInsight/invertIfCondition/afterParenthesis1.java @@ -0,0 +1,11 @@ +// "Invert If Condition" "true" +class Inversion { + public void context(boolean a, boolean b, boolean c) { + if ((!a || !b) && !c) { + System.out.println(1); + } + else { + System.out.println(0); + } + } +}
\ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/invertIfCondition/afterParenthesis2.java b/java/java-tests/testData/codeInsight/invertIfCondition/afterParenthesis2.java new file mode 100644 index 000000000000..fd19babc6d64 --- /dev/null +++ b/java/java-tests/testData/codeInsight/invertIfCondition/afterParenthesis2.java @@ -0,0 +1,11 @@ +// "Invert If Condition" "true" +class Inversion { + public void context(boolean a, boolean b, boolean c) { + if (!a || !b || !c) { + System.out.println(1); + } + else { + System.out.println(0); + } + } +}
\ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/invertIfCondition/afterParenthesis3.java b/java/java-tests/testData/codeInsight/invertIfCondition/afterParenthesis3.java new file mode 100644 index 000000000000..ca8ef27512f5 --- /dev/null +++ b/java/java-tests/testData/codeInsight/invertIfCondition/afterParenthesis3.java @@ -0,0 +1,11 @@ +// "Invert If Condition" "true" +class Inversion { + public void context(boolean a, boolean b, boolean c) { + if ((!a && !b) || !c) { + System.out.println(1); + } + else { + System.out.println(0); + } + } +}
\ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/invertIfCondition/beforeParenthesis1.java b/java/java-tests/testData/codeInsight/invertIfCondition/beforeParenthesis1.java new file mode 100644 index 000000000000..910ff076934f --- /dev/null +++ b/java/java-tests/testData/codeInsight/invertIfCondition/beforeParenthesis1.java @@ -0,0 +1,10 @@ +// "Invert If Condition" "true" +class Inversion { + public void context(boolean a, boolean b, boolean c) { + if (a &<caret>& b || c) { + System.out.println(0); + } else { + System.out.println(1); + } + } +}
\ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/invertIfCondition/beforeParenthesis2.java b/java/java-tests/testData/codeInsight/invertIfCondition/beforeParenthesis2.java new file mode 100644 index 000000000000..4aab06463a17 --- /dev/null +++ b/java/java-tests/testData/codeInsight/invertIfCondition/beforeParenthesis2.java @@ -0,0 +1,10 @@ +// "Invert If Condition" "true" +class Inversion { + public void context(boolean a, boolean b, boolean c) { + if (a &<caret>& b && c) { + System.out.println(0); + } else { + System.out.println(1); + } + } +}
\ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/invertIfCondition/beforeParenthesis3.java b/java/java-tests/testData/codeInsight/invertIfCondition/beforeParenthesis3.java new file mode 100644 index 000000000000..256ef0b2efc3 --- /dev/null +++ b/java/java-tests/testData/codeInsight/invertIfCondition/beforeParenthesis3.java @@ -0,0 +1,10 @@ +// "Invert If Condition" "true" +class Inversion { + public void context(boolean a, boolean b, boolean c) { + if ((a |<caret>| b) && c) { + System.out.println(0); + } else { + System.out.println(1); + } + } +}
\ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/javadocIG/initializerWithReference.html b/java/java-tests/testData/codeInsight/javadocIG/initializerWithReference.html new file mode 100644 index 000000000000..f4ba3cbff9d1 --- /dev/null +++ b/java/java-tests/testData/codeInsight/javadocIG/initializerWithReference.html @@ -0,0 +1 @@ +<html><head> <style type="text/css"> #error { background-color: #eeeeee; margin-bottom: 10px; } p { margin: 5px 0; } </style></head><body><small><b><a href="psi_element://Test"><code>Test</code></a></b></small><PRE>public int <b>field = anotherField</b></PRE></body></html>
\ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/javadocIG/initializerWithReference.java b/java/java-tests/testData/codeInsight/javadocIG/initializerWithReference.java new file mode 100644 index 000000000000..39a7384fdbb1 --- /dev/null +++ b/java/java-tests/testData/codeInsight/javadocIG/initializerWithReference.java @@ -0,0 +1,4 @@ +class Test { + public int field = anotherField; + public static int anotherField = 1; +}
\ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/splitIfAction/afterWithoutSpaces.java b/java/java-tests/testData/codeInsight/splitIfAction/afterWithoutSpaces.java new file mode 100644 index 000000000000..f776d7d19b7d --- /dev/null +++ b/java/java-tests/testData/codeInsight/splitIfAction/afterWithoutSpaces.java @@ -0,0 +1,8 @@ +public class SplitCondition { + private static void appendString(StringBuilder builder, boolean condition) { + if (condition) { + if (builder.length() > 0) { + } + } + } +} diff --git a/java/java-tests/testData/codeInsight/splitIfAction/beforeWithoutSpaces.java b/java/java-tests/testData/codeInsight/splitIfAction/beforeWithoutSpaces.java new file mode 100644 index 000000000000..b573566020ce --- /dev/null +++ b/java/java-tests/testData/codeInsight/splitIfAction/beforeWithoutSpaces.java @@ -0,0 +1,6 @@ +public class SplitCondition { + private static void appendString(StringBuilder builder, boolean condition) { + if (condition&<caret>&builder.length() > 0) { + } + } +} diff --git a/java/java-tests/testData/compileServer/incremental/common/addDuplicateClass.log b/java/java-tests/testData/compileServer/incremental/common/addDuplicateClass.log new file mode 100644 index 000000000000..39635f36edb8 --- /dev/null +++ b/java/java-tests/testData/compileServer/incremental/common/addDuplicateClass.log @@ -0,0 +1,10 @@ +Compiling files: +src2/pkg/Constants.java +End of files +Cleaning output files: +out/production/addDuplicateClass/pkg/Constants.class +End of files +Compiling files: +src/pkg/Constants.java +src2/pkg/Constants.java +End of files diff --git a/java/java-tests/testData/compileServer/incremental/common/addDuplicateClass/.idea/misc.xml b/java/java-tests/testData/compileServer/incremental/common/addDuplicateClass/.idea/misc.xml new file mode 100644 index 000000000000..9a249d2930c5 --- /dev/null +++ b/java/java-tests/testData/compileServer/incremental/common/addDuplicateClass/.idea/misc.xml @@ -0,0 +1,13 @@ +<?xml version="1.0" encoding="UTF-8"?> +<project version="4"> + <component name="EntryPointsManager"> + <entry_points version="2.0" /> + </component> + <component name="ProjectResources"> + <default-html-doctype>http://www.w3.org/1999/xhtml</default-html-doctype> + </component> + <component name="ProjectRootManager" version="2" languageLevel="JDK_1_6" assert-keyword="true" jdk-15="true" project-jdk-name="IDEA jdk" project-jdk-type="JavaSDK"> + <output url="file://$PROJECT_DIR$/out" /> + </component> +</project> + diff --git a/java/java-tests/testData/compileServer/incremental/common/addDuplicateClass/.idea/modules.xml b/java/java-tests/testData/compileServer/incremental/common/addDuplicateClass/.idea/modules.xml new file mode 100644 index 000000000000..6c4ca79986a8 --- /dev/null +++ b/java/java-tests/testData/compileServer/incremental/common/addDuplicateClass/.idea/modules.xml @@ -0,0 +1,9 @@ +<?xml version="1.0" encoding="UTF-8"?> +<project version="4"> + <component name="ProjectModuleManager"> + <modules> + <module fileurl="file://$PROJECT_DIR$/addDuplicateClass.iml" filepath="$PROJECT_DIR$/addDuplicateClass.iml" /> + </modules> + </component> +</project> + diff --git a/java/java-tests/testData/compileServer/incremental/common/addDuplicateClass/addDuplicateClass.iml b/java/java-tests/testData/compileServer/incremental/common/addDuplicateClass/addDuplicateClass.iml new file mode 100644 index 000000000000..119c6ef0a879 --- /dev/null +++ b/java/java-tests/testData/compileServer/incremental/common/addDuplicateClass/addDuplicateClass.iml @@ -0,0 +1,14 @@ +<?xml version="1.0" encoding="UTF-8"?> +<module type="JAVA_MODULE" version="4"> + <component name="NewModuleRootManager" inherit-compiler-output="true"> + <exclude-output /> + <content url="file://$MODULE_DIR$"> + <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" /> + <sourceFolder url="file://$MODULE_DIR$/src2" isTestSource="false" /> + </content> + <orderEntry type="jdk" jdkName="IDEA jdk" jdkType="JavaSDK" /> + <orderEntry type="sourceFolder" forTests="false" /> + <orderEntry type="module" module-name="common" /> + </component> +</module> + diff --git a/java/java-tests/testData/compileServer/incremental/common/addDuplicateClass/src/pkg/Client.java b/java/java-tests/testData/compileServer/incremental/common/addDuplicateClass/src/pkg/Client.java new file mode 100644 index 000000000000..8d9b52bd6ff2 --- /dev/null +++ b/java/java-tests/testData/compileServer/incremental/common/addDuplicateClass/src/pkg/Client.java @@ -0,0 +1,6 @@ +package pkg; +public class Client { + public static void main(String[] args) { + System.out.println(Constants.NUMBER); + } +} diff --git a/java/java-tests/testData/compileServer/incremental/common/addDuplicateClass/src/pkg/Constants.java b/java/java-tests/testData/compileServer/incremental/common/addDuplicateClass/src/pkg/Constants.java new file mode 100644 index 000000000000..edc79841dffe --- /dev/null +++ b/java/java-tests/testData/compileServer/incremental/common/addDuplicateClass/src/pkg/Constants.java @@ -0,0 +1,4 @@ +package pkg; +public class Constants { + public static final Integer NUMBER = new Integer(10); +} diff --git a/java/java-tests/testData/compileServer/incremental/common/addDuplicateClass/src2/pkg/Constants.java.new b/java/java-tests/testData/compileServer/incremental/common/addDuplicateClass/src2/pkg/Constants.java.new new file mode 100644 index 000000000000..0f9f6ffd7960 --- /dev/null +++ b/java/java-tests/testData/compileServer/incremental/common/addDuplicateClass/src2/pkg/Constants.java.new @@ -0,0 +1,3 @@ +package pkg; +public class Constants { +} diff --git a/java/java-tests/testData/compileServer/incremental/membersChange/removeMoreAccessibleMethod.log b/java/java-tests/testData/compileServer/incremental/membersChange/removeMoreAccessibleMethod.log new file mode 100644 index 000000000000..ea3129552780 --- /dev/null +++ b/java/java-tests/testData/compileServer/incremental/membersChange/removeMoreAccessibleMethod.log @@ -0,0 +1,12 @@ +Cleaning output files: +out/production/RemoveMoreAccessibleMethod/x/Concrete.class +End of files +Compiling files: +src/x/Concrete.java +End of files +Cleaning output files: +out/production/RemoveMoreAccessibleMethod/x/y/Client.class +End of files +Compiling files: +src/x/y/Client.java +End of files diff --git a/java/java-tests/testData/compileServer/incremental/membersChange/removeMoreAccessibleMethod/src/x/Abstract.java b/java/java-tests/testData/compileServer/incremental/membersChange/removeMoreAccessibleMethod/src/x/Abstract.java new file mode 100644 index 000000000000..ab43a5b2ae00 --- /dev/null +++ b/java/java-tests/testData/compileServer/incremental/membersChange/removeMoreAccessibleMethod/src/x/Abstract.java @@ -0,0 +1,6 @@ +package x; + +public class Abstract { + protected void method(int a) { + } +} diff --git a/java/java-tests/testData/compileServer/incremental/membersChange/removeMoreAccessibleMethod/src/x/Concrete.java b/java/java-tests/testData/compileServer/incremental/membersChange/removeMoreAccessibleMethod/src/x/Concrete.java new file mode 100644 index 000000000000..8a992bb4ca8d --- /dev/null +++ b/java/java-tests/testData/compileServer/incremental/membersChange/removeMoreAccessibleMethod/src/x/Concrete.java @@ -0,0 +1,7 @@ +package x; + +public class Concrete extends Abstract{ + @Override + public void method(int a) { + } +} diff --git a/java/java-tests/testData/compileServer/incremental/membersChange/removeMoreAccessibleMethod/src/x/Concrete.java.new b/java/java-tests/testData/compileServer/incremental/membersChange/removeMoreAccessibleMethod/src/x/Concrete.java.new new file mode 100644 index 000000000000..1502b7ddf13b --- /dev/null +++ b/java/java-tests/testData/compileServer/incremental/membersChange/removeMoreAccessibleMethod/src/x/Concrete.java.new @@ -0,0 +1,4 @@ +package x; + +public class Concrete extends Abstract{ +} diff --git a/java/java-tests/testData/compileServer/incremental/membersChange/removeMoreAccessibleMethod/src/x/y/Client.java b/java/java-tests/testData/compileServer/incremental/membersChange/removeMoreAccessibleMethod/src/x/y/Client.java new file mode 100644 index 000000000000..6a759deba6bc --- /dev/null +++ b/java/java-tests/testData/compileServer/incremental/membersChange/removeMoreAccessibleMethod/src/x/y/Client.java @@ -0,0 +1,11 @@ +package x.y; + +import x.*; + +public class Client { + private static Concrete concrete; + + public static void main(String[] args) { + concrete.method(10); + } +} diff --git a/java/java-tests/testData/inspection/dataFlow/fixture/ChainedFinalFieldAccessorsDfa.java b/java/java-tests/testData/inspection/dataFlow/fixture/ChainedFinalFieldAccessorsDfa.java index 8cf8bbdd8c2f..12c6fb1ad9bf 100644 --- a/java/java-tests/testData/inspection/dataFlow/fixture/ChainedFinalFieldAccessorsDfa.java +++ b/java/java-tests/testData/inspection/dataFlow/fixture/ChainedFinalFieldAccessorsDfa.java @@ -12,28 +12,28 @@ public class BrokenAlignment { data = new Data(null, <warning descr="Passing 'null' argument to non annotated parameter">null</warning>); System.out.println(<warning descr="Method invocation 'data.getText().hashCode()' may produce 'java.lang.NullPointerException'">data.getText().hashCode()</warning>); - if (data.inner() != null) { - System.out.println(data.inner().hashCode()); - System.out.println(<warning descr="Method invocation 'data.inner().getText().hashCode()' may produce 'java.lang.NullPointerException'">data.inner().getText().hashCode()</warning>); - if (data.inner() != null) { - System.out.println(data.inner().hashCode()); + if (data.getInner() != null) { + System.out.println(data.getInner().hashCode()); + System.out.println(<warning descr="Method invocation 'data.getInner().getText().hashCode()' may produce 'java.lang.NullPointerException'">data.getInner().getText().hashCode()</warning>); + if (data.getInner() != null) { + System.out.println(data.getInner().hashCode()); } data = new Data(null, <warning descr="Passing 'null' argument to non annotated parameter">null</warning>); - System.out.println(<warning descr="Method invocation 'data.inner().hashCode()' may produce 'java.lang.NullPointerException'">data.inner().hashCode()</warning>); + System.out.println(<warning descr="Method invocation 'data.getInner().hashCode()' may produce 'java.lang.NullPointerException'">data.getInner().hashCode()</warning>); } } void main2(Data data) { - if (data.inner() != null && data.inner().getText() != null) { - System.out.println(data.inner().hashCode()); - System.out.println(data.inner().getText().hashCode()); + if (data.getInner() != null && data.getInner().getText() != null) { + System.out.println(data.getInner().hashCode()); + System.out.println(data.getInner().getText().hashCode()); } } void main3(Data data) { - if (data.innerOverridden() != null) { - System.out.println(data.innerOverridden().hashCode()); + if (data.getInnerOverridden() != null) { + System.out.println(data.getInnerOverridden().hashCode()); } if (data.something() != null) { System.out.println(<warning descr="Method invocation 'data.something().hashCode()' may produce 'java.lang.NullPointerException'">data.something().hashCode()</warning>); @@ -55,12 +55,12 @@ public class BrokenAlignment { } @Nullable - public Data inner() { + public Data getInner() { return inner; } @Nullable - public Data innerOverridden() { + public Data getInnerOverridden() { return inner; } @@ -77,8 +77,8 @@ public class BrokenAlignment { @Nullable @Override - public Data innerOverridden() { - return super.innerOverridden(); + public Data getInnerOverridden() { + return super.getInnerOverridden(); } } }
\ No newline at end of file diff --git a/java/java-tests/testData/inspection/dataFlow/fixture/EffectivelyUnqualified.java b/java/java-tests/testData/inspection/dataFlow/fixture/EffectivelyUnqualified.java new file mode 100644 index 000000000000..86ed56676e26 --- /dev/null +++ b/java/java-tests/testData/inspection/dataFlow/fixture/EffectivelyUnqualified.java @@ -0,0 +1,12 @@ +abstract class Foo { + protected String bar; +} + +class FF extends Foo { + class FFI extends Foo { + void f() { + if (this.bar == FF.this.bar); + if (<warning descr="Condition 'this.bar == FFI.this.bar' is always 'true'">this.bar == FFI.this.bar</warning>); + } + } +}
\ No newline at end of file diff --git a/java/java-tests/testData/inspection/dataFlow/fixture/EqualsHasNoSideEffects.java b/java/java-tests/testData/inspection/dataFlow/fixture/EqualsHasNoSideEffects.java new file mode 100644 index 000000000000..20d33e187598 --- /dev/null +++ b/java/java-tests/testData/inspection/dataFlow/fixture/EqualsHasNoSideEffects.java @@ -0,0 +1,22 @@ +class DefaultObjectIdentifier { + String user; + String requestorClass; + public boolean equals(Object otherObject) { + if (otherObject == null || !(otherObject instanceof DefaultObjectIdentifier)) + return false; + else { + DefaultObjectIdentifier identifier = (DefaultObjectIdentifier) otherObject; + if (user == null && identifier.user != null) + return false; + else if (requestorClass == null && identifier.requestorClass != null) + return false; + else if (((user == null && <warning descr="Condition 'identifier.user == null' is always 'true' when reached">identifier.user == null</warning>) + || (this.user.equals(identifier.user))) + && + ((requestorClass == null && <warning descr="Condition 'identifier.requestorClass == null' is always 'true' when reached">identifier.requestorClass == null</warning>) + || this.requestorClass.equals(identifier.requestorClass))) + return true; + else + return false; + } + }}
\ No newline at end of file diff --git a/java/java-tests/testData/inspection/dataFlow/fixture/MutableNotAnnotatedFieldsTreatment.java b/java/java-tests/testData/inspection/dataFlow/fixture/MutableNotAnnotatedFieldsTreatment.java index a7c67e05861f..c542ba8fc158 100644 --- a/java/java-tests/testData/inspection/dataFlow/fixture/MutableNotAnnotatedFieldsTreatment.java +++ b/java/java-tests/testData/inspection/dataFlow/fixture/MutableNotAnnotatedFieldsTreatment.java @@ -32,11 +32,11 @@ class Foo { System.out.println(data.hashCode()); } - void dontWarnWhenDoubleChecked(Foo f) { + void warnWhenDoubleChecked(Foo f) { if (f.data == null) { return; } - if (f.data == null) { + if (<warning descr="Condition 'f.data == null' is always 'false'">f.data == null</warning>) { return; } System.out.println(f.data.hashCode()); @@ -53,13 +53,13 @@ class Foo { } System.out.println(data.hashCode()); } - - void dontWarnWhenDoubleChecked_This_WithMethodCall() { + + void warnWhenDoubleChecked_This_WithMethodCall() { if (data == null) { return; } System.out.println(data.hashCode()); - if (data == null) { + if (<warning descr="Condition 'data == null' is always 'false'">data == null</warning>) { return; } System.out.println(data.hashCode()); diff --git a/java/java-tests/testData/inspection/dataFlow/fixture/MutableNullableFieldsTreatment.java b/java/java-tests/testData/inspection/dataFlow/fixture/MutableNullableFieldsTreatment.java index ee2b1813b4d2..107d11f2bd75 100644 --- a/java/java-tests/testData/inspection/dataFlow/fixture/MutableNullableFieldsTreatment.java +++ b/java/java-tests/testData/inspection/dataFlow/fixture/MutableNullableFieldsTreatment.java @@ -34,11 +34,11 @@ class Foo { System.out.println(data.hashCode()); } - void dontWarnWhenDoubleChecked(Foo f) { + void warnWhenDoubleChecked(Foo f) { if (f.data == null) { return; } - if (f.data == null) { + if (<warning descr="Condition 'f.data == null' is always 'false'">f.data == null</warning>) { return; } System.out.println(f.data.hashCode()); @@ -56,12 +56,12 @@ class Foo { System.out.println(data.hashCode()); } - void dontWarnWhenDoubleChecked_This_WithMethodCall() { + void warnWhenDoubleChecked_This_WithMethodCall() { if (data == null) { return; } System.out.println(data.hashCode()); - if (data == null) { + if (<warning descr="Condition 'data == null' is always 'false'">data == null</warning>) { return; } System.out.println(data.hashCode()); diff --git a/java/java-tests/testData/inspection/dataFlow/fixture/OmnipresentExceptions.java b/java/java-tests/testData/inspection/dataFlow/fixture/OmnipresentExceptions.java new file mode 100644 index 000000000000..185c8ef269b1 --- /dev/null +++ b/java/java-tests/testData/inspection/dataFlow/fixture/OmnipresentExceptions.java @@ -0,0 +1,30 @@ +class Test { + Object m1(String[] args) throws Exception { + try { + return <warning descr="'null' is returned by the method which isn't declared as @Nullable">null</warning>; + } + catch (Throwable t) { + if (t instanceof Error) { + System.err.println("1"); + } + if (!(t instanceof RuntimeException)) { + System.err.println("2"); + } + return null; + } + } + + void m2(String[] args) throws Exception { + try { + System.out.println(); + } + catch (Throwable t) { + if (t instanceof Error) { + System.err.println("1"); + } + if (!(t instanceof RuntimeException)) { + System.err.println("2"); + } + } + } +} diff --git a/java/java-tests/testData/inspection/dataFlow/TryWithResourcesInstanceOf.java b/java/java-tests/testData/inspection/dataFlow/fixture/TryWithResourcesInstanceOf.java index f2ac4a8f3ba4..f2ac4a8f3ba4 100644 --- a/java/java-tests/testData/inspection/dataFlow/TryWithResourcesInstanceOf.java +++ b/java/java-tests/testData/inspection/dataFlow/fixture/TryWithResourcesInstanceOf.java diff --git a/java/java-tests/testData/inspection/dataFlow/TryWithResourcesNullability.java b/java/java-tests/testData/inspection/dataFlow/fixture/TryWithResourcesNullability.java index 80435df3b452..80435df3b452 100644 --- a/java/java-tests/testData/inspection/dataFlow/TryWithResourcesNullability.java +++ b/java/java-tests/testData/inspection/dataFlow/fixture/TryWithResourcesNullability.java diff --git a/java/java-tests/testData/inspection/sillyAssignment/multiple/src/Test.java b/java/java-tests/testData/inspection/sillyAssignment/multiple/src/Test.java index 0b3feb5b6203..2ddf2b6d6d10 100644 --- a/java/java-tests/testData/inspection/sillyAssignment/multiple/src/Test.java +++ b/java/java-tests/testData/inspection/sillyAssignment/multiple/src/Test.java @@ -20,5 +20,18 @@ public class Test extends Super { } class Super { int h; + int bar; } + +class Outer extends Super { + class Inner extends Super { + void f() { + this.bar = Outer.this.bar; + bar = Outer.this.bar; + this.bar = Outer.super.bar; + bar = Outer.super.bar; + super.bar = Outer.super.bar; + } + } +}
\ No newline at end of file diff --git a/java/java-tests/testData/refactoring/introduceVariable/genericWithTwoParameters/after/Client.java b/java/java-tests/testData/refactoring/introduceVariable/genericWithTwoParameters/after/Client.java index 4760e5ef0e09..38d94b3a880b 100644 --- a/java/java-tests/testData/refactoring/introduceVariable/genericWithTwoParameters/after/Client.java +++ b/java/java-tests/testData/refactoring/introduceVariable/genericWithTwoParameters/after/Client.java @@ -2,6 +2,6 @@ import util.Pair; class Client { void method() { - Pair<String,Pair<Integer,Boolean>> p = PairProvider.getPair(); + Pair<String, Pair<Integer,Boolean>> p = PairProvider.getPair(); } }
\ No newline at end of file diff --git a/java/java-tests/testData/refactoring/renameLocal/RenameToFieldNameInStaticContext.java b/java/java-tests/testData/refactoring/renameLocal/RenameToFieldNameInStaticContext.java new file mode 100644 index 000000000000..7fc1574ce187 --- /dev/null +++ b/java/java-tests/testData/refactoring/renameLocal/RenameToFieldNameInStaticContext.java @@ -0,0 +1,7 @@ +class Test { + String myFoo; + static { + String f<caret>oo = ""; + System.out.println(myFoo); + } +}
\ No newline at end of file diff --git a/java/java-tests/testData/refactoring/renameLocal/RenameToFieldNameInStaticContext_after.java b/java/java-tests/testData/refactoring/renameLocal/RenameToFieldNameInStaticContext_after.java new file mode 100644 index 000000000000..6d3f3b994262 --- /dev/null +++ b/java/java-tests/testData/refactoring/renameLocal/RenameToFieldNameInStaticContext_after.java @@ -0,0 +1,7 @@ +class Test { + String myFoo; + static { + String myFoo = ""; + System.out.println(myFoo); + } +}
\ No newline at end of file |
