Unstable and ScheduledForRemoval inspections tests refactoring: move to single module, move code to files.

GitOrigin-RevId: e4fb80e92b276952d608d0b721301471ac4e7cd7
This commit is contained in:
Sergey Patrikeev
2019-06-21 00:50:51 +03:00
committed by intellij-monorepo-bot
parent 27dc424f98
commit 856a375563
33 changed files with 369 additions and 522 deletions

View File

@@ -1,83 +0,0 @@
// Copyright 2000-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
import pkg.AnnotatedClass;
import static pkg.AnnotatedClass.NON_ANNOTATED_CONSTANT_IN_ANNOTATED_CLASS;
import static pkg.AnnotatedClass.staticNonAnnotatedMethodInAnnotatedClass;
import static pkg.AnnotatedClass.ANNOTATED_CONSTANT_IN_ANNOTATED_CLASS;
import static pkg.AnnotatedClass.staticAnnotatedMethodInAnnotatedClass;
import pkg.NonAnnotatedClass;
import static pkg.NonAnnotatedClass.NON_ANNOTATED_CONSTANT_IN_NON_ANNOTATED_CLASS;
import static pkg.NonAnnotatedClass.staticNonAnnotatedMethodInNonAnnotatedClass;
import static pkg.NonAnnotatedClass.ANNOTATED_CONSTANT_IN_NON_ANNOTATED_CLASS;
import static pkg.NonAnnotatedClass.staticAnnotatedMethodInNonAnnotatedClass;
import pkg.AnnotatedEnum;
import pkg.NonAnnotatedEnum;
import static pkg.AnnotatedEnum.NON_ANNOTATED_VALUE_IN_ANNOTATED_ENUM;
import static pkg.AnnotatedEnum.ANNOTATED_VALUE_IN_ANNOTATED_ENUM;
import static pkg.NonAnnotatedEnum.NON_ANNOTATED_VALUE_IN_NON_ANNOTATED_ENUM;
import static pkg.NonAnnotatedEnum.ANNOTATED_VALUE_IN_NON_ANNOTATED_ENUM;
import pkg.AnnotatedAnnotation;
import pkg.NonAnnotatedAnnotation;
import annotatedPkg.ClassInAnnotatedPkg;
public class ScheduledForRemovalElementsIgnoreImportsTest {
public void test() {
String s = <warning descr="'pkg.AnnotatedClass' is scheduled for removal in 123.456">AnnotatedClass</warning>.NON_ANNOTATED_CONSTANT_IN_ANNOTATED_CLASS;
<warning descr="'pkg.AnnotatedClass' is scheduled for removal in 123.456">AnnotatedClass</warning>.staticNonAnnotatedMethodInAnnotatedClass();
<warning descr="'pkg.AnnotatedClass' is scheduled for removal in 123.456">AnnotatedClass</warning> annotatedClassInstanceViaNonAnnotatedConstructor = new <warning descr="'pkg.AnnotatedClass' is scheduled for removal in 123.456">AnnotatedClass</warning>();
s = annotatedClassInstanceViaNonAnnotatedConstructor.nonAnnotatedFieldInAnnotatedClass;
annotatedClassInstanceViaNonAnnotatedConstructor.nonAnnotatedMethodInAnnotatedClass();
s = NON_ANNOTATED_CONSTANT_IN_ANNOTATED_CLASS;
staticNonAnnotatedMethodInAnnotatedClass();
s = <warning descr="'pkg.AnnotatedClass' is scheduled for removal in 123.456">AnnotatedClass</warning>.<warning descr="'ANNOTATED_CONSTANT_IN_ANNOTATED_CLASS' is scheduled for removal in 123.456">ANNOTATED_CONSTANT_IN_ANNOTATED_CLASS</warning>;
<warning descr="'pkg.AnnotatedClass' is scheduled for removal in 123.456">AnnotatedClass</warning>.<warning descr="'staticAnnotatedMethodInAnnotatedClass()' is scheduled for removal in 123.456">staticAnnotatedMethodInAnnotatedClass</warning>();
<warning descr="'pkg.AnnotatedClass' is scheduled for removal in 123.456">AnnotatedClass</warning> annotatedClassInstanceViaAnnotatedConstructor = new <warning descr="'AnnotatedClass(java.lang.String)' is scheduled for removal in 123.456"><warning descr="'pkg.AnnotatedClass' is scheduled for removal in 123.456">AnnotatedClass</warning></warning>("");
s = annotatedClassInstanceViaAnnotatedConstructor.<warning descr="'annotatedFieldInAnnotatedClass' is scheduled for removal in 123.456">annotatedFieldInAnnotatedClass</warning>;
annotatedClassInstanceViaAnnotatedConstructor.<warning descr="'annotatedMethodInAnnotatedClass()' is scheduled for removal in 123.456">annotatedMethodInAnnotatedClass</warning>();
s = <warning descr="'ANNOTATED_CONSTANT_IN_ANNOTATED_CLASS' is scheduled for removal in 123.456">ANNOTATED_CONSTANT_IN_ANNOTATED_CLASS</warning>;
<warning descr="'staticAnnotatedMethodInAnnotatedClass()' is scheduled for removal in 123.456">staticAnnotatedMethodInAnnotatedClass</warning>();
// ---------------------------------
s = NonAnnotatedClass.NON_ANNOTATED_CONSTANT_IN_NON_ANNOTATED_CLASS;
NonAnnotatedClass.staticNonAnnotatedMethodInNonAnnotatedClass();
NonAnnotatedClass nonAnnotatedClassInstanceViaNonAnnotatedConstructor = new NonAnnotatedClass();
s = nonAnnotatedClassInstanceViaNonAnnotatedConstructor.nonAnnotatedFieldInNonAnnotatedClass;
nonAnnotatedClassInstanceViaNonAnnotatedConstructor.nonAnnotatedMethodInNonAnnotatedClass();
s = NON_ANNOTATED_CONSTANT_IN_NON_ANNOTATED_CLASS;
staticNonAnnotatedMethodInNonAnnotatedClass();
s = NonAnnotatedClass.<warning descr="'ANNOTATED_CONSTANT_IN_NON_ANNOTATED_CLASS' is scheduled for removal in 123.456">ANNOTATED_CONSTANT_IN_NON_ANNOTATED_CLASS</warning>;
NonAnnotatedClass.<warning descr="'staticAnnotatedMethodInNonAnnotatedClass()' is scheduled for removal in 123.456">staticAnnotatedMethodInNonAnnotatedClass</warning>();
NonAnnotatedClass nonAnnotatedClassInstanceViaAnnotatedConstructor = new <warning descr="'NonAnnotatedClass(java.lang.String)' is scheduled for removal in 123.456">NonAnnotatedClass</warning>("");
s = nonAnnotatedClassInstanceViaAnnotatedConstructor.<warning descr="'annotatedFieldInNonAnnotatedClass' is scheduled for removal in 123.456">annotatedFieldInNonAnnotatedClass</warning>;
nonAnnotatedClassInstanceViaAnnotatedConstructor.<warning descr="'annotatedMethodInNonAnnotatedClass()' is scheduled for removal in 123.456">annotatedMethodInNonAnnotatedClass</warning>();
s = <warning descr="'ANNOTATED_CONSTANT_IN_NON_ANNOTATED_CLASS' is scheduled for removal in 123.456">ANNOTATED_CONSTANT_IN_NON_ANNOTATED_CLASS</warning>;
<warning descr="'staticAnnotatedMethodInNonAnnotatedClass()' is scheduled for removal in 123.456">staticAnnotatedMethodInNonAnnotatedClass</warning>();
// ---------------------------------
<warning descr="'pkg.AnnotatedEnum' is scheduled for removal in 123.456">AnnotatedEnum</warning> nonAnnotatedValueInAnnotatedEnum = <warning descr="'pkg.AnnotatedEnum' is scheduled for removal in 123.456">AnnotatedEnum</warning>.NON_ANNOTATED_VALUE_IN_ANNOTATED_ENUM;
nonAnnotatedValueInAnnotatedEnum = NON_ANNOTATED_VALUE_IN_ANNOTATED_ENUM;
<warning descr="'pkg.AnnotatedEnum' is scheduled for removal in 123.456">AnnotatedEnum</warning> annotatedValueInAnnotatedEnum = <warning descr="'pkg.AnnotatedEnum' is scheduled for removal in 123.456">AnnotatedEnum</warning>.<warning descr="'ANNOTATED_VALUE_IN_ANNOTATED_ENUM' is scheduled for removal in 123.456">ANNOTATED_VALUE_IN_ANNOTATED_ENUM</warning>;
annotatedValueInAnnotatedEnum = <warning descr="'ANNOTATED_VALUE_IN_ANNOTATED_ENUM' is scheduled for removal in 123.456">ANNOTATED_VALUE_IN_ANNOTATED_ENUM</warning>;
NonAnnotatedEnum nonAnnotatedValueInNonAnnotatedEnum = NonAnnotatedEnum.NON_ANNOTATED_VALUE_IN_NON_ANNOTATED_ENUM;
nonAnnotatedValueInNonAnnotatedEnum = NON_ANNOTATED_VALUE_IN_NON_ANNOTATED_ENUM;
NonAnnotatedEnum annotatedValueInNonAnnotatedEnum = NonAnnotatedEnum.<warning descr="'ANNOTATED_VALUE_IN_NON_ANNOTATED_ENUM' is scheduled for removal in 123.456">ANNOTATED_VALUE_IN_NON_ANNOTATED_ENUM</warning>;
annotatedValueInNonAnnotatedEnum = <warning descr="'ANNOTATED_VALUE_IN_NON_ANNOTATED_ENUM' is scheduled for removal in 123.456">ANNOTATED_VALUE_IN_NON_ANNOTATED_ENUM</warning>;
// ---------------------------------
@<warning descr="'pkg.AnnotatedAnnotation' is scheduled for removal in 123.456">AnnotatedAnnotation</warning> class C1 {}
@<warning descr="'pkg.AnnotatedAnnotation' is scheduled for removal in 123.456">AnnotatedAnnotation</warning>(nonAnnotatedAttributeInAnnotatedAnnotation = "123") class C2 {}
@<warning descr="'pkg.AnnotatedAnnotation' is scheduled for removal in 123.456">AnnotatedAnnotation</warning>(<warning descr="'annotatedAttributeInAnnotatedAnnotation' is scheduled for removal in 123.456">annotatedAttributeInAnnotatedAnnotation</warning> = "123") class C3 {}
@NonAnnotatedAnnotation class C4 {}
@NonAnnotatedAnnotation(nonAnnotatedAttributeInNonAnnotatedAnnotation = "123") class C5 {}
@NonAnnotatedAnnotation(<warning descr="'annotatedAttributeInNonAnnotatedAnnotation' is scheduled for removal in 123.456">annotatedAttributeInNonAnnotatedAnnotation</warning> = "123") class C6 {}
}
}

View File

@@ -1,83 +0,0 @@
// Copyright 2000-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
import pkg.AnnotatedClass;
import static pkg.AnnotatedClass.NON_ANNOTATED_CONSTANT_IN_ANNOTATED_CLASS;
import static pkg.AnnotatedClass.staticNonAnnotatedMethodInAnnotatedClass;
import static pkg.AnnotatedClass.ANNOTATED_CONSTANT_IN_ANNOTATED_CLASS;
import static pkg.AnnotatedClass.staticAnnotatedMethodInAnnotatedClass;
import pkg.NonAnnotatedClass;
import static pkg.NonAnnotatedClass.NON_ANNOTATED_CONSTANT_IN_NON_ANNOTATED_CLASS;
import static pkg.NonAnnotatedClass.staticNonAnnotatedMethodInNonAnnotatedClass;
import static pkg.NonAnnotatedClass.ANNOTATED_CONSTANT_IN_NON_ANNOTATED_CLASS;
import static pkg.NonAnnotatedClass.staticAnnotatedMethodInNonAnnotatedClass;
import pkg.AnnotatedEnum;
import pkg.NonAnnotatedEnum;
import static pkg.AnnotatedEnum.NON_ANNOTATED_VALUE_IN_ANNOTATED_ENUM;
import static pkg.AnnotatedEnum.ANNOTATED_VALUE_IN_ANNOTATED_ENUM;
import static pkg.NonAnnotatedEnum.NON_ANNOTATED_VALUE_IN_NON_ANNOTATED_ENUM;
import static pkg.NonAnnotatedEnum.ANNOTATED_VALUE_IN_NON_ANNOTATED_ENUM;
import pkg.AnnotatedAnnotation;
import pkg.NonAnnotatedAnnotation;
import annotatedPkg.ClassInAnnotatedPkg;
public class UnstableElementsIgnoreImportsTest {
public void test() {
String s = <warning descr="'pkg.AnnotatedClass' is marked unstable">AnnotatedClass</warning>.NON_ANNOTATED_CONSTANT_IN_ANNOTATED_CLASS;
<warning descr="'pkg.AnnotatedClass' is marked unstable">AnnotatedClass</warning>.staticNonAnnotatedMethodInAnnotatedClass();
<warning descr="'pkg.AnnotatedClass' is marked unstable">AnnotatedClass</warning> annotatedClassInstanceViaNonAnnotatedConstructor = new <warning descr="'pkg.AnnotatedClass' is marked unstable">AnnotatedClass</warning>();
s = annotatedClassInstanceViaNonAnnotatedConstructor.nonAnnotatedFieldInAnnotatedClass;
annotatedClassInstanceViaNonAnnotatedConstructor.nonAnnotatedMethodInAnnotatedClass();
s = NON_ANNOTATED_CONSTANT_IN_ANNOTATED_CLASS;
staticNonAnnotatedMethodInAnnotatedClass();
s = <warning descr="'pkg.AnnotatedClass' is marked unstable">AnnotatedClass</warning>.<warning descr="'ANNOTATED_CONSTANT_IN_ANNOTATED_CLASS' is marked unstable">ANNOTATED_CONSTANT_IN_ANNOTATED_CLASS</warning>;
<warning descr="'pkg.AnnotatedClass' is marked unstable">AnnotatedClass</warning>.<warning descr="'staticAnnotatedMethodInAnnotatedClass()' is marked unstable">staticAnnotatedMethodInAnnotatedClass</warning>();
<warning descr="'pkg.AnnotatedClass' is marked unstable">AnnotatedClass</warning> annotatedClassInstanceViaAnnotatedConstructor = new <warning descr="'AnnotatedClass(java.lang.String)' is marked unstable"><warning descr="'pkg.AnnotatedClass' is marked unstable">AnnotatedClass</warning></warning>("");
s = annotatedClassInstanceViaAnnotatedConstructor.<warning descr="'annotatedFieldInAnnotatedClass' is marked unstable">annotatedFieldInAnnotatedClass</warning>;
annotatedClassInstanceViaAnnotatedConstructor.<warning descr="'annotatedMethodInAnnotatedClass()' is marked unstable">annotatedMethodInAnnotatedClass</warning>();
s = <warning descr="'ANNOTATED_CONSTANT_IN_ANNOTATED_CLASS' is marked unstable">ANNOTATED_CONSTANT_IN_ANNOTATED_CLASS</warning>;
<warning descr="'staticAnnotatedMethodInAnnotatedClass()' is marked unstable">staticAnnotatedMethodInAnnotatedClass</warning>();
// ---------------------------------
s = NonAnnotatedClass.NON_ANNOTATED_CONSTANT_IN_NON_ANNOTATED_CLASS;
NonAnnotatedClass.staticNonAnnotatedMethodInNonAnnotatedClass();
NonAnnotatedClass nonAnnotatedClassInstanceViaNonAnnotatedConstructor = new NonAnnotatedClass();
s = nonAnnotatedClassInstanceViaNonAnnotatedConstructor.nonAnnotatedFieldInNonAnnotatedClass;
nonAnnotatedClassInstanceViaNonAnnotatedConstructor.nonAnnotatedMethodInNonAnnotatedClass();
s = NON_ANNOTATED_CONSTANT_IN_NON_ANNOTATED_CLASS;
staticNonAnnotatedMethodInNonAnnotatedClass();
s = NonAnnotatedClass.<warning descr="'ANNOTATED_CONSTANT_IN_NON_ANNOTATED_CLASS' is marked unstable">ANNOTATED_CONSTANT_IN_NON_ANNOTATED_CLASS</warning>;
NonAnnotatedClass.<warning descr="'staticAnnotatedMethodInNonAnnotatedClass()' is marked unstable">staticAnnotatedMethodInNonAnnotatedClass</warning>();
NonAnnotatedClass nonAnnotatedClassInstanceViaAnnotatedConstructor = new <warning descr="'NonAnnotatedClass(java.lang.String)' is marked unstable">NonAnnotatedClass</warning>("");
s = nonAnnotatedClassInstanceViaAnnotatedConstructor.<warning descr="'annotatedFieldInNonAnnotatedClass' is marked unstable">annotatedFieldInNonAnnotatedClass</warning>;
nonAnnotatedClassInstanceViaAnnotatedConstructor.<warning descr="'annotatedMethodInNonAnnotatedClass()' is marked unstable">annotatedMethodInNonAnnotatedClass</warning>();
s = <warning descr="'ANNOTATED_CONSTANT_IN_NON_ANNOTATED_CLASS' is marked unstable">ANNOTATED_CONSTANT_IN_NON_ANNOTATED_CLASS</warning>;
<warning descr="'staticAnnotatedMethodInNonAnnotatedClass()' is marked unstable">staticAnnotatedMethodInNonAnnotatedClass</warning>();
// ---------------------------------
<warning descr="'pkg.AnnotatedEnum' is marked unstable">AnnotatedEnum</warning> nonAnnotatedValueInAnnotatedEnum = <warning descr="'pkg.AnnotatedEnum' is marked unstable">AnnotatedEnum</warning>.NON_ANNOTATED_VALUE_IN_ANNOTATED_ENUM;
nonAnnotatedValueInAnnotatedEnum = NON_ANNOTATED_VALUE_IN_ANNOTATED_ENUM;
<warning descr="'pkg.AnnotatedEnum' is marked unstable">AnnotatedEnum</warning> annotatedValueInAnnotatedEnum = <warning descr="'pkg.AnnotatedEnum' is marked unstable">AnnotatedEnum</warning>.<warning descr="'ANNOTATED_VALUE_IN_ANNOTATED_ENUM' is marked unstable">ANNOTATED_VALUE_IN_ANNOTATED_ENUM</warning>;
annotatedValueInAnnotatedEnum = <warning descr="'ANNOTATED_VALUE_IN_ANNOTATED_ENUM' is marked unstable">ANNOTATED_VALUE_IN_ANNOTATED_ENUM</warning>;
NonAnnotatedEnum nonAnnotatedValueInNonAnnotatedEnum = NonAnnotatedEnum.NON_ANNOTATED_VALUE_IN_NON_ANNOTATED_ENUM;
nonAnnotatedValueInNonAnnotatedEnum = NON_ANNOTATED_VALUE_IN_NON_ANNOTATED_ENUM;
NonAnnotatedEnum annotatedValueInNonAnnotatedEnum = NonAnnotatedEnum.<warning descr="'ANNOTATED_VALUE_IN_NON_ANNOTATED_ENUM' is marked unstable">ANNOTATED_VALUE_IN_NON_ANNOTATED_ENUM</warning>;
annotatedValueInNonAnnotatedEnum = <warning descr="'ANNOTATED_VALUE_IN_NON_ANNOTATED_ENUM' is marked unstable">ANNOTATED_VALUE_IN_NON_ANNOTATED_ENUM</warning>;
// ---------------------------------
@<warning descr="'pkg.AnnotatedAnnotation' is marked unstable">AnnotatedAnnotation</warning> class C1 {}
@<warning descr="'pkg.AnnotatedAnnotation' is marked unstable">AnnotatedAnnotation</warning>(nonAnnotatedAttributeInAnnotatedAnnotation = "123") class C2 {}
@<warning descr="'pkg.AnnotatedAnnotation' is marked unstable">AnnotatedAnnotation</warning>(<warning descr="'annotatedAttributeInAnnotatedAnnotation' is marked unstable">annotatedAttributeInAnnotatedAnnotation</warning> = "123") class C3 {}
@NonAnnotatedAnnotation class C4 {}
@NonAnnotatedAnnotation(nonAnnotatedAttributeInNonAnnotatedAnnotation = "123") class C5 {}
@NonAnnotatedAnnotation(<warning descr="'annotatedAttributeInNonAnnotatedAnnotation' is marked unstable">annotatedAttributeInNonAnnotatedAnnotation</warning> = "123") class C6 {}
}
}

View File

@@ -1,22 +0,0 @@
package com.intellij.codeInspection.tests.java
import com.intellij.codeInspection.tests.ScheduledForRemovalInspectionTestBase
import com.intellij.jvm.analysis.JvmAnalysisTestsUtil.TEST_DATA_PROJECT_RELATIVE_BASE_PATH
import com.intellij.testFramework.TestDataPath
@TestDataPath("/testData/codeInspection/scheduledForRemoval")
class ScheduledForRemovalInspectionTest: ScheduledForRemovalInspectionTestBase() {
override fun getBasePath() = ""
override fun getTestDataPath() = "${TEST_DATA_PROJECT_RELATIVE_BASE_PATH}/codeInspection/scheduledForRemoval"
fun testInspection() {
getInspection().myIgnoreInsideImports = false
myFixture.testHighlighting(true, false, false, "ScheduledForRemovalElementsTest.java")
}
fun testIgnoreImports() {
getInspection().myIgnoreInsideImports = true
myFixture.testHighlighting(true, false, false, "ScheduledForRemovalElementsIgnoreImportsTest.java")
}
}

View File

@@ -1,23 +0,0 @@
// Copyright 2000-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
package com.intellij.codeInspection.tests.java
import com.intellij.codeInspection.tests.UnstableApiUsageInspectionTestBase
import com.intellij.jvm.analysis.JvmAnalysisTestsUtil.TEST_DATA_PROJECT_RELATIVE_BASE_PATH
import com.intellij.testFramework.TestDataPath
@TestDataPath("/testData/codeInspection/unstableApiUsage")
class UnstableApiUsageInspectionTest : UnstableApiUsageInspectionTestBase() {
override fun getBasePath() = ""
override fun getTestDataPath() = "${TEST_DATA_PROJECT_RELATIVE_BASE_PATH}/codeInspection/unstableApiUsage"
fun testInspection() {
getInspection().myIgnoreInsideImports = false
myFixture.testHighlighting(true, false, false, "UnstableElementsTest.java")
}
fun testIgnoreImports() {
getInspection().myIgnoreInsideImports = true
myFixture.testHighlighting(true, false, false, "UnstableElementsIgnoreImportsTest.java")
}
}

View File

@@ -0,0 +1,24 @@
// Copyright 2000-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
import pkg.AnnotatedClass;
import static pkg.AnnotatedClass.NON_ANNOTATED_CONSTANT_IN_ANNOTATED_CLASS;
import static pkg.AnnotatedClass.staticNonAnnotatedMethodInAnnotatedClass;
import static pkg.AnnotatedClass.ANNOTATED_CONSTANT_IN_ANNOTATED_CLASS;
import static pkg.AnnotatedClass.staticAnnotatedMethodInAnnotatedClass;
import pkg.NonAnnotatedClass;
import static pkg.NonAnnotatedClass.NON_ANNOTATED_CONSTANT_IN_NON_ANNOTATED_CLASS;
import static pkg.NonAnnotatedClass.staticNonAnnotatedMethodInNonAnnotatedClass;
import static pkg.NonAnnotatedClass.ANNOTATED_CONSTANT_IN_NON_ANNOTATED_CLASS;
import static pkg.NonAnnotatedClass.staticAnnotatedMethodInNonAnnotatedClass;
import pkg.AnnotatedEnum;
import pkg.NonAnnotatedEnum;
import static pkg.AnnotatedEnum.NON_ANNOTATED_VALUE_IN_ANNOTATED_ENUM;
import static pkg.AnnotatedEnum.ANNOTATED_VALUE_IN_ANNOTATED_ENUM;
import static pkg.NonAnnotatedEnum.NON_ANNOTATED_VALUE_IN_NON_ANNOTATED_ENUM;
import static pkg.NonAnnotatedEnum.ANNOTATED_VALUE_IN_NON_ANNOTATED_ENUM;
import pkg.AnnotatedAnnotation;
import pkg.NonAnnotatedAnnotation;
import annotatedPkg.ClassInAnnotatedPkg;

View File

@@ -20,64 +20,4 @@ import pkg.NonAnnotatedEnum.ANNOTATED_VALUE_IN_NON_ANNOTATED_ENUM
import pkg.AnnotatedAnnotation
import pkg.NonAnnotatedAnnotation
import annotatedPkg.ClassInAnnotatedPkg
@Suppress("ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE", "UNUSED_VALUE")
class ScheduledForRemovalElementsIgnoreImportsTest {
fun test() {
var s = <warning descr="'pkg.AnnotatedClass' is scheduled for removal in 123.456">AnnotatedClass</warning>.NON_ANNOTATED_CONSTANT_IN_ANNOTATED_CLASS
<warning descr="'pkg.AnnotatedClass' is scheduled for removal in 123.456">AnnotatedClass</warning>.staticNonAnnotatedMethodInAnnotatedClass()
val annotatedClassInstanceViaNonAnnotatedConstructor : <warning descr="'pkg.AnnotatedClass' is scheduled for removal in 123.456">AnnotatedClass</warning> = <warning descr="'pkg.AnnotatedClass' is scheduled for removal in 123.456">AnnotatedClass</warning>()
s = annotatedClassInstanceViaNonAnnotatedConstructor.nonAnnotatedFieldInAnnotatedClass
annotatedClassInstanceViaNonAnnotatedConstructor.nonAnnotatedMethodInAnnotatedClass()
s = NON_ANNOTATED_CONSTANT_IN_ANNOTATED_CLASS
staticNonAnnotatedMethodInAnnotatedClass()
s = <warning descr="'pkg.AnnotatedClass' is scheduled for removal in 123.456">AnnotatedClass</warning>.<warning descr="'ANNOTATED_CONSTANT_IN_ANNOTATED_CLASS' is scheduled for removal in 123.456">ANNOTATED_CONSTANT_IN_ANNOTATED_CLASS</warning>
<warning descr="'pkg.AnnotatedClass' is scheduled for removal in 123.456">AnnotatedClass</warning>.<warning descr="'staticAnnotatedMethodInAnnotatedClass()' is scheduled for removal in 123.456">staticAnnotatedMethodInAnnotatedClass</warning>()
val annotatedClassInstanceViaAnnotatedConstructor : <warning descr="'pkg.AnnotatedClass' is scheduled for removal in 123.456">AnnotatedClass</warning> = <warning descr="'AnnotatedClass(java.lang.String)' is scheduled for removal in 123.456"><warning descr="'pkg.AnnotatedClass' is scheduled for removal in 123.456">AnnotatedClass</warning></warning>("")
s = annotatedClassInstanceViaAnnotatedConstructor.<warning descr="'annotatedFieldInAnnotatedClass' is scheduled for removal in 123.456">annotatedFieldInAnnotatedClass</warning>
annotatedClassInstanceViaAnnotatedConstructor.<warning descr="'annotatedMethodInAnnotatedClass()' is scheduled for removal in 123.456">annotatedMethodInAnnotatedClass</warning>()
s = <warning descr="'ANNOTATED_CONSTANT_IN_ANNOTATED_CLASS' is scheduled for removal in 123.456">ANNOTATED_CONSTANT_IN_ANNOTATED_CLASS</warning>
<warning descr="'staticAnnotatedMethodInAnnotatedClass()' is scheduled for removal in 123.456">staticAnnotatedMethodInAnnotatedClass</warning>()
// ---------------------------------
s = NonAnnotatedClass.NON_ANNOTATED_CONSTANT_IN_NON_ANNOTATED_CLASS
NonAnnotatedClass.staticNonAnnotatedMethodInNonAnnotatedClass()
val nonAnnotatedClassInstanceViaNonAnnotatedConstructor = NonAnnotatedClass()
s = nonAnnotatedClassInstanceViaNonAnnotatedConstructor.nonAnnotatedFieldInNonAnnotatedClass
nonAnnotatedClassInstanceViaNonAnnotatedConstructor.nonAnnotatedMethodInNonAnnotatedClass()
s = NON_ANNOTATED_CONSTANT_IN_NON_ANNOTATED_CLASS
staticNonAnnotatedMethodInNonAnnotatedClass()
s = NonAnnotatedClass.<warning descr="'ANNOTATED_CONSTANT_IN_NON_ANNOTATED_CLASS' is scheduled for removal in 123.456">ANNOTATED_CONSTANT_IN_NON_ANNOTATED_CLASS</warning>
NonAnnotatedClass.<warning descr="'staticAnnotatedMethodInNonAnnotatedClass()' is scheduled for removal in 123.456">staticAnnotatedMethodInNonAnnotatedClass</warning>()
val nonAnnotatedClassInstanceViaAnnotatedConstructor = <warning descr="'NonAnnotatedClass(java.lang.String)' is scheduled for removal in 123.456">NonAnnotatedClass</warning>("")
s = nonAnnotatedClassInstanceViaAnnotatedConstructor.<warning descr="'annotatedFieldInNonAnnotatedClass' is scheduled for removal in 123.456">annotatedFieldInNonAnnotatedClass</warning>
nonAnnotatedClassInstanceViaAnnotatedConstructor.<warning descr="'annotatedMethodInNonAnnotatedClass()' is scheduled for removal in 123.456">annotatedMethodInNonAnnotatedClass</warning>()
s = <warning descr="'ANNOTATED_CONSTANT_IN_NON_ANNOTATED_CLASS' is scheduled for removal in 123.456">ANNOTATED_CONSTANT_IN_NON_ANNOTATED_CLASS</warning>
<warning descr="'staticAnnotatedMethodInNonAnnotatedClass()' is scheduled for removal in 123.456">staticAnnotatedMethodInNonAnnotatedClass</warning>()
// ---------------------------------
var nonAnnotatedValueInAnnotatedEnum : <warning descr="'pkg.AnnotatedEnum' is scheduled for removal in 123.456">AnnotatedEnum</warning> = <warning descr="'pkg.AnnotatedEnum' is scheduled for removal in 123.456">AnnotatedEnum</warning>.NON_ANNOTATED_VALUE_IN_ANNOTATED_ENUM
nonAnnotatedValueInAnnotatedEnum = NON_ANNOTATED_VALUE_IN_ANNOTATED_ENUM
var annotatedValueInAnnotatedEnum : <warning descr="'pkg.AnnotatedEnum' is scheduled for removal in 123.456">AnnotatedEnum</warning> = <warning descr="'pkg.AnnotatedEnum' is scheduled for removal in 123.456">AnnotatedEnum</warning>.<warning descr="'ANNOTATED_VALUE_IN_ANNOTATED_ENUM' is scheduled for removal in 123.456">ANNOTATED_VALUE_IN_ANNOTATED_ENUM</warning>
annotatedValueInAnnotatedEnum = <warning descr="'ANNOTATED_VALUE_IN_ANNOTATED_ENUM' is scheduled for removal in 123.456">ANNOTATED_VALUE_IN_ANNOTATED_ENUM</warning>
var nonAnnotatedValueInNonAnnotatedEnum = NonAnnotatedEnum.NON_ANNOTATED_VALUE_IN_NON_ANNOTATED_ENUM
nonAnnotatedValueInNonAnnotatedEnum = NON_ANNOTATED_VALUE_IN_NON_ANNOTATED_ENUM
var annotatedValueInNonAnnotatedEnum = NonAnnotatedEnum.<warning descr="'ANNOTATED_VALUE_IN_NON_ANNOTATED_ENUM' is scheduled for removal in 123.456">ANNOTATED_VALUE_IN_NON_ANNOTATED_ENUM</warning>
annotatedValueInNonAnnotatedEnum = <warning descr="'ANNOTATED_VALUE_IN_NON_ANNOTATED_ENUM' is scheduled for removal in 123.456">ANNOTATED_VALUE_IN_NON_ANNOTATED_ENUM</warning>
// ---------------------------------
@<warning descr="'pkg.AnnotatedAnnotation' is scheduled for removal in 123.456">AnnotatedAnnotation</warning> class C1
@<warning descr="'pkg.AnnotatedAnnotation' is scheduled for removal in 123.456">AnnotatedAnnotation</warning>(nonAnnotatedAttributeInAnnotatedAnnotation = "123") class C2
@<warning descr="'pkg.AnnotatedAnnotation' is scheduled for removal in 123.456">AnnotatedAnnotation</warning>(<warning descr="'annotatedAttributeInAnnotatedAnnotation' is scheduled for removal in 123.456">annotatedAttributeInAnnotatedAnnotation</warning> = "123") class C3
@NonAnnotatedAnnotation class C4
@NonAnnotatedAnnotation(nonAnnotatedAttributeInNonAnnotatedAnnotation = "123") class C5
@NonAnnotatedAnnotation(<warning descr="'annotatedAttributeInNonAnnotatedAnnotation' is scheduled for removal in 123.456">annotatedAttributeInNonAnnotatedAnnotation</warning> = "123") class C6
}
}
import annotatedPkg.ClassInAnnotatedPkg

View File

@@ -0,0 +1,4 @@
package annotatedPkg;
public class ClassInAnnotatedPkg {
}

View File

@@ -0,0 +1,2 @@
@org.jetbrains.annotations.ApiStatus.ScheduledForRemoval(inVersion = "123.456")
package annotatedPkg;

View File

@@ -0,0 +1,10 @@
package pkg;
import org.jetbrains.annotations.ApiStatus;
@ApiStatus.ScheduledForRemoval(inVersion = "123.456")
public @interface AnnotatedAnnotation {
String nonAnnotatedAttributeInAnnotatedAnnotation() default "";
@ApiStatus.ScheduledForRemoval(inVersion = "123.456") String annotatedAttributeInAnnotatedAnnotation() default "";
}

View File

@@ -0,0 +1,27 @@
package pkg;
import org.jetbrains.annotations.ApiStatus;
@ApiStatus.ScheduledForRemoval(inVersion = "123.456")
public class AnnotatedClass {
public static final String NON_ANNOTATED_CONSTANT_IN_ANNOTATED_CLASS = "";
public String nonAnnotatedFieldInAnnotatedClass = "";
public AnnotatedClass() {}
public static void staticNonAnnotatedMethodInAnnotatedClass() {}
public void nonAnnotatedMethodInAnnotatedClass() {}
@ApiStatus.ScheduledForRemoval(inVersion = "123.456") public static final String ANNOTATED_CONSTANT_IN_ANNOTATED_CLASS = "";
@ApiStatus.ScheduledForRemoval(inVersion = "123.456") public String annotatedFieldInAnnotatedClass = "";
@ApiStatus.ScheduledForRemoval(inVersion = "123.456")
public AnnotatedClass(String s) {}
@ApiStatus.ScheduledForRemoval(inVersion = "123.456")
public static void staticAnnotatedMethodInAnnotatedClass() {}
@ApiStatus.ScheduledForRemoval(inVersion = "123.456")
public void annotatedMethodInAnnotatedClass() {}
}

View File

@@ -0,0 +1,9 @@
package pkg;
import org.jetbrains.annotations.ApiStatus;
@ApiStatus.ScheduledForRemoval(inVersion = "123.456")
public enum AnnotatedEnum {
NON_ANNOTATED_VALUE_IN_ANNOTATED_ENUM,
@ApiStatus.ScheduledForRemoval(inVersion = "123.456") ANNOTATED_VALUE_IN_ANNOTATED_ENUM
}

View File

@@ -0,0 +1,9 @@
package pkg;
import org.jetbrains.annotations.ApiStatus;
public @interface NonAnnotatedAnnotation {
String nonAnnotatedAttributeInNonAnnotatedAnnotation() default "";
@ApiStatus.ScheduledForRemoval(inVersion = "123.456") String annotatedAttributeInNonAnnotatedAnnotation() default "";
}

View File

@@ -0,0 +1,26 @@
package pkg;
import org.jetbrains.annotations.ApiStatus;
public class NonAnnotatedClass {
public static final String NON_ANNOTATED_CONSTANT_IN_NON_ANNOTATED_CLASS = "";
public String nonAnnotatedFieldInNonAnnotatedClass = "";
public NonAnnotatedClass() {}
public static void staticNonAnnotatedMethodInNonAnnotatedClass() {}
public void nonAnnotatedMethodInNonAnnotatedClass() {}
@ApiStatus.ScheduledForRemoval(inVersion = "123.456") public static final String ANNOTATED_CONSTANT_IN_NON_ANNOTATED_CLASS = "";
@ApiStatus.ScheduledForRemoval(inVersion = "123.456") public String annotatedFieldInNonAnnotatedClass = "";
@ApiStatus.ScheduledForRemoval(inVersion = "123.456")
public NonAnnotatedClass(String s) {}
@ApiStatus.ScheduledForRemoval(inVersion = "123.456")
public static void staticAnnotatedMethodInNonAnnotatedClass() {}
@ApiStatus.ScheduledForRemoval(inVersion = "123.456")
public void annotatedMethodInNonAnnotatedClass() {}
}

View File

@@ -0,0 +1,8 @@
package pkg;
import org.jetbrains.annotations.ApiStatus;
public enum NonAnnotatedEnum {
NON_ANNOTATED_VALUE_IN_NON_ANNOTATED_ENUM,
@ApiStatus.ScheduledForRemoval(inVersion = "123.456") ANNOTATED_VALUE_IN_NON_ANNOTATED_ENUM
}

View File

@@ -0,0 +1,24 @@
// Copyright 2000-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
import pkg.AnnotatedClass;
import static pkg.AnnotatedClass.NON_ANNOTATED_CONSTANT_IN_ANNOTATED_CLASS;
import static pkg.AnnotatedClass.staticNonAnnotatedMethodInAnnotatedClass;
import static pkg.AnnotatedClass.ANNOTATED_CONSTANT_IN_ANNOTATED_CLASS;
import static pkg.AnnotatedClass.staticAnnotatedMethodInAnnotatedClass;
import pkg.NonAnnotatedClass;
import static pkg.NonAnnotatedClass.NON_ANNOTATED_CONSTANT_IN_NON_ANNOTATED_CLASS;
import static pkg.NonAnnotatedClass.staticNonAnnotatedMethodInNonAnnotatedClass;
import static pkg.NonAnnotatedClass.ANNOTATED_CONSTANT_IN_NON_ANNOTATED_CLASS;
import static pkg.NonAnnotatedClass.staticAnnotatedMethodInNonAnnotatedClass;
import pkg.AnnotatedEnum;
import pkg.NonAnnotatedEnum;
import static pkg.AnnotatedEnum.NON_ANNOTATED_VALUE_IN_ANNOTATED_ENUM;
import static pkg.AnnotatedEnum.ANNOTATED_VALUE_IN_ANNOTATED_ENUM;
import static pkg.NonAnnotatedEnum.NON_ANNOTATED_VALUE_IN_NON_ANNOTATED_ENUM;
import static pkg.NonAnnotatedEnum.ANNOTATED_VALUE_IN_NON_ANNOTATED_ENUM;
import pkg.AnnotatedAnnotation;
import pkg.NonAnnotatedAnnotation;
import annotatedPkg.ClassInAnnotatedPkg;

View File

@@ -20,64 +20,4 @@ import pkg.NonAnnotatedEnum.ANNOTATED_VALUE_IN_NON_ANNOTATED_ENUM
import pkg.AnnotatedAnnotation
import pkg.NonAnnotatedAnnotation
import annotatedPkg.ClassInAnnotatedPkg
@Suppress("ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE", "UNUSED_VALUE")
class UnstableElementsIgnoreImportsTest {
fun test() {
var s = <warning descr="'pkg.AnnotatedClass' is marked unstable">AnnotatedClass</warning>.NON_ANNOTATED_CONSTANT_IN_ANNOTATED_CLASS
<warning descr="'pkg.AnnotatedClass' is marked unstable">AnnotatedClass</warning>.staticNonAnnotatedMethodInAnnotatedClass()
val annotatedClassInstanceViaNonAnnotatedConstructor : <warning descr="'pkg.AnnotatedClass' is marked unstable">AnnotatedClass</warning> = <warning descr="'pkg.AnnotatedClass' is marked unstable">AnnotatedClass</warning>()
s = annotatedClassInstanceViaNonAnnotatedConstructor.nonAnnotatedFieldInAnnotatedClass
annotatedClassInstanceViaNonAnnotatedConstructor.nonAnnotatedMethodInAnnotatedClass()
s = NON_ANNOTATED_CONSTANT_IN_ANNOTATED_CLASS
staticNonAnnotatedMethodInAnnotatedClass()
s = <warning descr="'pkg.AnnotatedClass' is marked unstable">AnnotatedClass</warning>.<warning descr="'ANNOTATED_CONSTANT_IN_ANNOTATED_CLASS' is marked unstable">ANNOTATED_CONSTANT_IN_ANNOTATED_CLASS</warning>
<warning descr="'pkg.AnnotatedClass' is marked unstable">AnnotatedClass</warning>.<warning descr="'staticAnnotatedMethodInAnnotatedClass()' is marked unstable">staticAnnotatedMethodInAnnotatedClass</warning>()
val annotatedClassInstanceViaAnnotatedConstructor : <warning descr="'pkg.AnnotatedClass' is marked unstable">AnnotatedClass</warning> = <warning descr="'AnnotatedClass(java.lang.String)' is marked unstable"><warning descr="'pkg.AnnotatedClass' is marked unstable">AnnotatedClass</warning></warning>("")
s = annotatedClassInstanceViaAnnotatedConstructor.<warning descr="'annotatedFieldInAnnotatedClass' is marked unstable">annotatedFieldInAnnotatedClass</warning>
annotatedClassInstanceViaAnnotatedConstructor.<warning descr="'annotatedMethodInAnnotatedClass()' is marked unstable">annotatedMethodInAnnotatedClass</warning>()
s = <warning descr="'ANNOTATED_CONSTANT_IN_ANNOTATED_CLASS' is marked unstable">ANNOTATED_CONSTANT_IN_ANNOTATED_CLASS</warning>
<warning descr="'staticAnnotatedMethodInAnnotatedClass()' is marked unstable">staticAnnotatedMethodInAnnotatedClass</warning>()
// ---------------------------------
s = NonAnnotatedClass.NON_ANNOTATED_CONSTANT_IN_NON_ANNOTATED_CLASS
NonAnnotatedClass.staticNonAnnotatedMethodInNonAnnotatedClass()
val nonAnnotatedClassInstanceViaNonAnnotatedConstructor = NonAnnotatedClass()
s = nonAnnotatedClassInstanceViaNonAnnotatedConstructor.nonAnnotatedFieldInNonAnnotatedClass
nonAnnotatedClassInstanceViaNonAnnotatedConstructor.nonAnnotatedMethodInNonAnnotatedClass()
s = NON_ANNOTATED_CONSTANT_IN_NON_ANNOTATED_CLASS
staticNonAnnotatedMethodInNonAnnotatedClass()
s = NonAnnotatedClass.<warning descr="'ANNOTATED_CONSTANT_IN_NON_ANNOTATED_CLASS' is marked unstable">ANNOTATED_CONSTANT_IN_NON_ANNOTATED_CLASS</warning>
NonAnnotatedClass.<warning descr="'staticAnnotatedMethodInNonAnnotatedClass()' is marked unstable">staticAnnotatedMethodInNonAnnotatedClass</warning>()
val nonAnnotatedClassInstanceViaAnnotatedConstructor = <warning descr="'NonAnnotatedClass(java.lang.String)' is marked unstable">NonAnnotatedClass</warning>("")
s = nonAnnotatedClassInstanceViaAnnotatedConstructor.<warning descr="'annotatedFieldInNonAnnotatedClass' is marked unstable">annotatedFieldInNonAnnotatedClass</warning>
nonAnnotatedClassInstanceViaAnnotatedConstructor.<warning descr="'annotatedMethodInNonAnnotatedClass()' is marked unstable">annotatedMethodInNonAnnotatedClass</warning>()
s = <warning descr="'ANNOTATED_CONSTANT_IN_NON_ANNOTATED_CLASS' is marked unstable">ANNOTATED_CONSTANT_IN_NON_ANNOTATED_CLASS</warning>
<warning descr="'staticAnnotatedMethodInNonAnnotatedClass()' is marked unstable">staticAnnotatedMethodInNonAnnotatedClass</warning>()
// ---------------------------------
var nonAnnotatedValueInAnnotatedEnum : <warning descr="'pkg.AnnotatedEnum' is marked unstable">AnnotatedEnum</warning> = <warning descr="'pkg.AnnotatedEnum' is marked unstable">AnnotatedEnum</warning>.NON_ANNOTATED_VALUE_IN_ANNOTATED_ENUM
nonAnnotatedValueInAnnotatedEnum = NON_ANNOTATED_VALUE_IN_ANNOTATED_ENUM
var annotatedValueInAnnotatedEnum : <warning descr="'pkg.AnnotatedEnum' is marked unstable">AnnotatedEnum</warning> = <warning descr="'pkg.AnnotatedEnum' is marked unstable">AnnotatedEnum</warning>.<warning descr="'ANNOTATED_VALUE_IN_ANNOTATED_ENUM' is marked unstable">ANNOTATED_VALUE_IN_ANNOTATED_ENUM</warning>
annotatedValueInAnnotatedEnum = <warning descr="'ANNOTATED_VALUE_IN_ANNOTATED_ENUM' is marked unstable">ANNOTATED_VALUE_IN_ANNOTATED_ENUM</warning>
var nonAnnotatedValueInNonAnnotatedEnum = NonAnnotatedEnum.NON_ANNOTATED_VALUE_IN_NON_ANNOTATED_ENUM
nonAnnotatedValueInNonAnnotatedEnum = NON_ANNOTATED_VALUE_IN_NON_ANNOTATED_ENUM
var annotatedValueInNonAnnotatedEnum = NonAnnotatedEnum.<warning descr="'ANNOTATED_VALUE_IN_NON_ANNOTATED_ENUM' is marked unstable">ANNOTATED_VALUE_IN_NON_ANNOTATED_ENUM</warning>
annotatedValueInNonAnnotatedEnum = <warning descr="'ANNOTATED_VALUE_IN_NON_ANNOTATED_ENUM' is marked unstable">ANNOTATED_VALUE_IN_NON_ANNOTATED_ENUM</warning>
// ---------------------------------
@<warning descr="'pkg.AnnotatedAnnotation' is marked unstable">AnnotatedAnnotation</warning> class C1
@<warning descr="'pkg.AnnotatedAnnotation' is marked unstable">AnnotatedAnnotation</warning>(nonAnnotatedAttributeInAnnotatedAnnotation = "123") class C2
@<warning descr="'pkg.AnnotatedAnnotation' is marked unstable">AnnotatedAnnotation</warning>(<warning descr="'annotatedAttributeInAnnotatedAnnotation' is marked unstable">annotatedAttributeInAnnotatedAnnotation</warning> = "123") class C3
@NonAnnotatedAnnotation class C4
@NonAnnotatedAnnotation(nonAnnotatedAttributeInNonAnnotatedAnnotation = "123") class C5
@NonAnnotatedAnnotation(<warning descr="'annotatedAttributeInNonAnnotatedAnnotation' is marked unstable">annotatedAttributeInNonAnnotatedAnnotation</warning> = "123") class C6
}
}
import annotatedPkg.ClassInAnnotatedPkg

View File

@@ -0,0 +1,4 @@
package annotatedPkg;
public class ClassInAnnotatedPkg {
}

View File

@@ -0,0 +1,2 @@
@org.jetbrains.annotations.ApiStatus.Experimental
package annotatedPkg;

View File

@@ -0,0 +1,10 @@
package pkg;
import org.jetbrains.annotations.ApiStatus;
@ApiStatus.Experimental
public @interface AnnotatedAnnotation {
String nonAnnotatedAttributeInAnnotatedAnnotation() default "";
@ApiStatus.Experimental String annotatedAttributeInAnnotatedAnnotation() default "";
}

View File

@@ -0,0 +1,27 @@
package pkg;
import org.jetbrains.annotations.ApiStatus;
@ApiStatus.Experimental
public class AnnotatedClass {
public static final String NON_ANNOTATED_CONSTANT_IN_ANNOTATED_CLASS = "";
public String nonAnnotatedFieldInAnnotatedClass = "";
public AnnotatedClass() {}
public static void staticNonAnnotatedMethodInAnnotatedClass() {}
public void nonAnnotatedMethodInAnnotatedClass() {}
@ApiStatus.Experimental public static final String ANNOTATED_CONSTANT_IN_ANNOTATED_CLASS = "";
@ApiStatus.Experimental public String annotatedFieldInAnnotatedClass = "";
@ApiStatus.Experimental
public AnnotatedClass(String s) {}
@ApiStatus.Experimental
public static void staticAnnotatedMethodInAnnotatedClass() {}
@ApiStatus.Experimental
public void annotatedMethodInAnnotatedClass() {}
}

View File

@@ -0,0 +1,9 @@
package pkg;
import org.jetbrains.annotations.ApiStatus;
@ApiStatus.Experimental
public enum AnnotatedEnum {
NON_ANNOTATED_VALUE_IN_ANNOTATED_ENUM,
@ApiStatus.Experimental ANNOTATED_VALUE_IN_ANNOTATED_ENUM
}

View File

@@ -0,0 +1,9 @@
package pkg;
import org.jetbrains.annotations.ApiStatus;
public @interface NonAnnotatedAnnotation {
String nonAnnotatedAttributeInNonAnnotatedAnnotation() default "";
@ApiStatus.Experimental String annotatedAttributeInNonAnnotatedAnnotation() default "";
}

View File

@@ -0,0 +1,26 @@
package pkg;
import org.jetbrains.annotations.ApiStatus;
public class NonAnnotatedClass {
public static final String NON_ANNOTATED_CONSTANT_IN_NON_ANNOTATED_CLASS = "";
public String nonAnnotatedFieldInNonAnnotatedClass = "";
public NonAnnotatedClass() {}
public static void staticNonAnnotatedMethodInNonAnnotatedClass() {}
public void nonAnnotatedMethodInNonAnnotatedClass() {}
@ApiStatus.Experimental public static final String ANNOTATED_CONSTANT_IN_NON_ANNOTATED_CLASS = "";
@ApiStatus.Experimental public String annotatedFieldInNonAnnotatedClass = "";
@ApiStatus.Experimental
public NonAnnotatedClass(String s) {}
@ApiStatus.Experimental
public static void staticAnnotatedMethodInNonAnnotatedClass() {}
@ApiStatus.Experimental
public void annotatedMethodInNonAnnotatedClass() {}
}

View File

@@ -0,0 +1,8 @@
package pkg;
import org.jetbrains.annotations.ApiStatus;
public enum NonAnnotatedEnum {
NON_ANNOTATED_VALUE_IN_NON_ANNOTATED_ENUM,
@ApiStatus.Experimental ANNOTATED_VALUE_IN_NON_ANNOTATED_ENUM
}

View File

@@ -1,27 +0,0 @@
package com.intellij.codeInspection.tests.kotlin
import com.intellij.codeInspection.tests.ScheduledForRemovalInspectionTestBase
import com.intellij.jvm.analysis.JvmAnalysisKtTestsUtil.TEST_DATA_PROJECT_RELATIVE_BASE_PATH
import com.intellij.openapi.vfs.VirtualFileFilter
import com.intellij.testFramework.TestDataPath
import com.intellij.testFramework.fixtures.impl.CodeInsightTestFixtureImpl
@TestDataPath("/testData/codeInspection/scheduledForRemoval")
class KtScheduledForRemovalInspectionTest : ScheduledForRemovalInspectionTestBase() {
override fun getBasePath() = "${TEST_DATA_PROJECT_RELATIVE_BASE_PATH}/codeInspection/scheduledForRemoval"
override fun performAdditionalSetUp() {
// otherwise assertion in PsiFileImpl ("Access to tree elements not allowed") will not pass
(myFixture as CodeInsightTestFixtureImpl).setVirtualFileFilter(VirtualFileFilter.NONE)
}
fun testInspection() {
getInspection().myIgnoreInsideImports = false
myFixture.testHighlighting("ScheduledForRemovalElementsTest.kt")
}
fun testIgnoreImports() {
getInspection().myIgnoreInsideImports = true
myFixture.testHighlighting("ScheduledForRemovalElementsIgnoreImportsTest.kt")
}
}

View File

@@ -1,28 +0,0 @@
// Copyright 2000-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
package com.intellij.codeInspection.tests.kotlin
import com.intellij.codeInspection.tests.UnstableApiUsageInspectionTestBase
import com.intellij.jvm.analysis.JvmAnalysisKtTestsUtil.TEST_DATA_PROJECT_RELATIVE_BASE_PATH
import com.intellij.openapi.vfs.VirtualFileFilter
import com.intellij.testFramework.TestDataPath
import com.intellij.testFramework.fixtures.impl.CodeInsightTestFixtureImpl
@TestDataPath("/testData/codeInspection/unstableApiUsage")
class KtUnstableApiUsageInspectionTest : UnstableApiUsageInspectionTestBase() {
override fun getBasePath() = "${TEST_DATA_PROJECT_RELATIVE_BASE_PATH}/codeInspection/unstableApiUsage"
override fun performAdditionalSetUp() {
// otherwise assertion in PsiFileImpl ("Access to tree elements not allowed") will not pass
(myFixture as CodeInsightTestFixtureImpl).setVirtualFileFilter(VirtualFileFilter.NONE)
}
fun testInspection() {
getInspection().myIgnoreInsideImports = false
myFixture.testHighlighting("UnstableElementsTest.kt")
}
fun testIgnoreImports() {
getInspection().myIgnoreInsideImports = true
myFixture.testHighlighting("UnstableElementsIgnoreImportsTest.kt")
}
}

View File

@@ -0,0 +1,64 @@
package com.intellij.codeInspection.tests.kotlin
import com.intellij.codeInspection.ScheduledForRemovalInspection
import com.intellij.jvm.analysis.JvmAnalysisKtTestsUtil.TEST_DATA_PROJECT_RELATIVE_BASE_PATH
import com.intellij.openapi.vfs.VirtualFileFilter
import com.intellij.testFramework.TestDataPath
import com.intellij.testFramework.builders.JavaModuleFixtureBuilder
import com.intellij.testFramework.fixtures.JavaCodeInsightFixtureTestCase
import com.intellij.testFramework.fixtures.impl.CodeInsightTestFixtureImpl
import com.intellij.util.PathUtil
import org.jetbrains.annotations.ApiStatus
@TestDataPath("\$CONTENT_ROOT/testData/codeInspection/scheduledForRemoval")
class ScheduledForRemovalInspectionTest: JavaCodeInsightFixtureTestCase() {
private val inspection = ScheduledForRemovalInspection()
override fun getBasePath() = "${TEST_DATA_PROJECT_RELATIVE_BASE_PATH}/codeInspection/scheduledForRemoval"
override fun tuneFixture(moduleBuilder: JavaModuleFixtureBuilder<*>) {
moduleBuilder.addLibrary("util", PathUtil.getJarPathForClass(ApiStatus::class.java))
}
override fun setUp() {
super.setUp()
// otherwise assertion in PsiFileImpl ("Access to tree elements not allowed") will not pass
myFixture.enableInspections(inspection)
(myFixture as CodeInsightTestFixtureImpl).setVirtualFileFilter(VirtualFileFilter.NONE)
configureAnnotatedFiles()
}
private fun configureAnnotatedFiles() {
listOf(
"annotatedPkg/ClassInAnnotatedPkg.java",
"annotatedPkg/package-info.java",
"pkg/AnnotatedAnnotation.java",
"pkg/AnnotatedClass.java",
"pkg/AnnotatedEnum.java",
"pkg/NonAnnotatedAnnotation.java",
"pkg/NonAnnotatedClass.java",
"pkg/NonAnnotatedEnum.java"
).forEach { myFixture.copyFileToProject(it) }
}
fun testKotlinInspection() {
inspection.myIgnoreInsideImports = false
myFixture.testHighlighting("ScheduledForRemovalElementsTest.kt")
}
fun testKotlinIgnoreImports() {
inspection.myIgnoreInsideImports = true
myFixture.testHighlighting("ScheduledForRemovalElementsIgnoreImportsTest.kt")
}
fun testJavaInspection() {
inspection.myIgnoreInsideImports = false
myFixture.testHighlighting(true, false, false, "ScheduledForRemovalElementsTest.java")
}
fun testJavaIgnoreImports() {
inspection.myIgnoreInsideImports = true
myFixture.testHighlighting(true, false, false, "ScheduledForRemovalElementsIgnoreImportsTest.java")
}
}

View File

@@ -0,0 +1,65 @@
// Copyright 2000-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
package com.intellij.codeInspection.tests.kotlin
import com.intellij.codeInspection.UnstableApiUsageInspection
import com.intellij.jvm.analysis.JvmAnalysisKtTestsUtil
import com.intellij.openapi.vfs.VirtualFileFilter
import com.intellij.testFramework.TestDataPath
import com.intellij.testFramework.builders.JavaModuleFixtureBuilder
import com.intellij.testFramework.fixtures.JavaCodeInsightFixtureTestCase
import com.intellij.testFramework.fixtures.impl.CodeInsightTestFixtureImpl
import com.intellij.util.PathUtil
import org.jetbrains.annotations.ApiStatus
@TestDataPath("\$CONTENT_ROOT/testData/codeInspection/unstableApiUsage")
class UnstableApiUsageInspectionTest : JavaCodeInsightFixtureTestCase() {
private val inspection = UnstableApiUsageInspection()
override fun getBasePath() = "${JvmAnalysisKtTestsUtil.TEST_DATA_PROJECT_RELATIVE_BASE_PATH}/codeInspection/unstableApiUsage"
override fun tuneFixture(moduleBuilder: JavaModuleFixtureBuilder<*>) {
moduleBuilder.addLibrary("util", PathUtil.getJarPathForClass(ApiStatus::class.java))
}
override fun setUp() {
super.setUp()
myFixture.enableInspections(inspection)
// otherwise assertion in PsiFileImpl ("Access to tree elements not allowed") will not pass
(myFixture as CodeInsightTestFixtureImpl).setVirtualFileFilter(VirtualFileFilter.NONE)
configureAnnotatedFiles()
}
private fun configureAnnotatedFiles() {
listOf(
"annotatedPkg/ClassInAnnotatedPkg.java",
"annotatedPkg/package-info.java",
"pkg/AnnotatedAnnotation.java",
"pkg/AnnotatedClass.java",
"pkg/AnnotatedEnum.java",
"pkg/NonAnnotatedAnnotation.java",
"pkg/NonAnnotatedClass.java",
"pkg/NonAnnotatedEnum.java"
).forEach { myFixture.copyFileToProject(it) }
}
fun testJavaInspection() {
inspection.myIgnoreInsideImports = false
myFixture.testHighlighting(true, false, false, "UnstableElementsTest.java")
}
fun testJavaIgnoreImports() {
inspection.myIgnoreInsideImports = true
myFixture.testHighlighting(true, false, false, "UnstableElementsIgnoreImportsTest.java")
}
fun testKotlinInspection() {
inspection.myIgnoreInsideImports = false
myFixture.testHighlighting("UnstableElementsTest.kt")
}
fun testKotlinIgnoreImports() {
inspection.myIgnoreInsideImports = true
myFixture.testHighlighting("UnstableElementsIgnoreImportsTest.kt")
}
}

View File

@@ -1,99 +0,0 @@
package com.intellij.codeInspection.tests
import com.intellij.codeInspection.InspectionProfileEntry
import com.intellij.testFramework.fixtures.JavaCodeInsightFixtureTestCase
abstract class AnnotatedElementUsageInspectionTestBase : JavaCodeInsightFixtureTestCase() {
abstract override fun getBasePath(): String
abstract fun getInspection(): InspectionProfileEntry
abstract fun getAnnotationString(): String
open fun performAdditionalSetUp() {}
override fun setUp() {
super.setUp()
performAdditionalSetUp()
myFixture.enableInspections(getInspection())
addAnnotatedElementsToProject(getAnnotationString())
}
private fun addAnnotatedElementsToProject(annotation: String) {
myFixture.addFileToProject(
"pkg/AnnotatedAnnotation.java", """
package pkg;
${annotation} public @interface AnnotatedAnnotation {
String nonAnnotatedAttributeInAnnotatedAnnotation() default "";
${annotation} String annotatedAttributeInAnnotatedAnnotation() default "";
}"""
)
myFixture.addFileToProject(
"pkg/AnnotatedEnum.java", """
package pkg;
${annotation} public enum AnnotatedEnum {
NON_ANNOTATED_VALUE_IN_ANNOTATED_ENUM,
${annotation} ANNOTATED_VALUE_IN_ANNOTATED_ENUM
}"""
)
myFixture.addFileToProject(
"pkg/AnnotatedClass.java", """
package pkg;
${annotation} public class AnnotatedClass {
public static final String NON_ANNOTATED_CONSTANT_IN_ANNOTATED_CLASS = "";
public String nonAnnotatedFieldInAnnotatedClass = "";
public AnnotatedClass() {}
public static void staticNonAnnotatedMethodInAnnotatedClass() {}
public void nonAnnotatedMethodInAnnotatedClass() {}
${annotation} public static final String ANNOTATED_CONSTANT_IN_ANNOTATED_CLASS = "";
${annotation} public String annotatedFieldInAnnotatedClass = "";
${annotation} public AnnotatedClass(String s) {}
${annotation} public static void staticAnnotatedMethodInAnnotatedClass() {}
${annotation} public void annotatedMethodInAnnotatedClass() {}
}"""
)
myFixture.addFileToProject(
"pkg/NonAnnotatedAnnotation.java", """
package pkg;
public @interface NonAnnotatedAnnotation {
String nonAnnotatedAttributeInNonAnnotatedAnnotation() default "";
${annotation} String annotatedAttributeInNonAnnotatedAnnotation() default "";
}"""
)
myFixture.addFileToProject(
"pkg/NonAnnotatedEnum.java", """
package pkg;
public enum NonAnnotatedEnum {
NON_ANNOTATED_VALUE_IN_NON_ANNOTATED_ENUM,
${annotation} ANNOTATED_VALUE_IN_NON_ANNOTATED_ENUM
}"""
)
myFixture.addFileToProject(
"pkg/NonAnnotatedClass.java", """
package pkg;
public class NonAnnotatedClass {
public static final String NON_ANNOTATED_CONSTANT_IN_NON_ANNOTATED_CLASS = "";
public String nonAnnotatedFieldInNonAnnotatedClass = "";
public NonAnnotatedClass() {}
public static void staticNonAnnotatedMethodInNonAnnotatedClass() {}
public void nonAnnotatedMethodInNonAnnotatedClass() {}
${annotation} public static final String ANNOTATED_CONSTANT_IN_NON_ANNOTATED_CLASS = "";
${annotation} public String annotatedFieldInNonAnnotatedClass = "";
${annotation} public NonAnnotatedClass(String s) {}
${annotation} public static void staticAnnotatedMethodInNonAnnotatedClass() {}
${annotation} public void annotatedMethodInNonAnnotatedClass() {}
}"""
)
myFixture.addFileToProject("annotatedPkg/package-info.java",
"${annotation}\n" +
"package annotatedPkg;")
myFixture.addFileToProject("annotatedPkg/ClassInAnnotatedPkg.java",
"package annotatedPkg;\n" +
"public class ClassInAnnotatedPkg {}")
}
}

View File

@@ -1,17 +0,0 @@
package com.intellij.codeInspection.tests
import com.intellij.codeInspection.ScheduledForRemovalInspection
import com.intellij.testFramework.builders.JavaModuleFixtureBuilder
import com.intellij.util.PathUtil
import org.jetbrains.annotations.ApiStatus
abstract class ScheduledForRemovalInspectionTestBase: AnnotatedElementUsageInspectionTestBase() {
private val inspection = ScheduledForRemovalInspection()
override fun getInspection() = inspection
override fun getAnnotationString() = "@org.jetbrains.annotations.ApiStatus.ScheduledForRemoval(inVersion = \"123.456\")"
override fun tuneFixture(moduleBuilder: JavaModuleFixtureBuilder<*>) {
moduleBuilder.addLibrary("util", PathUtil.getJarPathForClass(ApiStatus::class.java))
}
}

View File

@@ -1,18 +0,0 @@
// Copyright 2000-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
package com.intellij.codeInspection.tests
import com.intellij.codeInspection.UnstableApiUsageInspection
import com.intellij.testFramework.builders.JavaModuleFixtureBuilder
import com.intellij.util.PathUtil
import org.jetbrains.annotations.ApiStatus
abstract class UnstableApiUsageInspectionTestBase : AnnotatedElementUsageInspectionTestBase() {
private val inspection = UnstableApiUsageInspection()
override fun getInspection() = inspection
override fun getAnnotationString(): String = "@org.jetbrains.annotations.ApiStatus.Experimental"
override fun tuneFixture(moduleBuilder: JavaModuleFixtureBuilder<*>) {
moduleBuilder.addLibrary("util", PathUtil.getJarPathForClass(ApiStatus::class.java))
}
}