From 6accbf6284172f15eb518c636e039222a0db5d1a Mon Sep 17 00:00:00 2001 From: "anastasiia.spaseeva" Date: Wed, 4 Dec 2019 16:58:18 +0300 Subject: [PATCH] [Spec tests] Add prefix increment expression codegen tests --- .../p-1/pos/1.1.kt | 30 +++ .../p-1/pos/1.2.kt | 31 ++++ .../p-4/pos/1.1.kt | 34 ++++ .../p-4/pos/1.2.kt | 35 ++++ .../p-5/pos/1.1.kt | 39 ++++ .../p-6/pos/1.1.kt | 31 ++++ .../p-6/pos/1.2.kt | 34 ++++ .../prefix-increment-expression/testsMap.json | 96 ++++++++++ .../statements/assignments/testsMap.json | 24 +++ .../abstract-classes/testsMap.json | 2 +- .../p-4/neg/1.1.kt | 44 +++++ .../p-5/neg/2.1.kt | 47 +++++ .../prefix-increment-expression/testsMap.json | 26 +++ .../inheritance/overriding/testsMap.json | 15 ++ .../statements/assignments/testsMap.json | 15 ++ .../DiagnosticsTestSpecGenerated.java | 92 +++++++++- .../BlackBoxCodegenTestSpecGenerated.java | 171 +++++++++++++++++- 17 files changed, 760 insertions(+), 6 deletions(-) create mode 100644 compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-increment-expression/p-1/pos/1.1.kt create mode 100644 compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-increment-expression/p-1/pos/1.2.kt create mode 100644 compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-increment-expression/p-4/pos/1.1.kt create mode 100644 compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-increment-expression/p-4/pos/1.2.kt create mode 100644 compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-increment-expression/p-5/pos/1.1.kt create mode 100644 compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-increment-expression/p-6/pos/1.1.kt create mode 100644 compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-increment-expression/p-6/pos/1.2.kt create mode 100644 compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-increment-expression/testsMap.json create mode 100644 compiler/tests-spec/testData/codegen/box/linked/statements/assignments/testsMap.json create mode 100644 compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-increment-expression/p-4/neg/1.1.kt create mode 100644 compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-increment-expression/p-5/neg/2.1.kt create mode 100644 compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-increment-expression/testsMap.json create mode 100644 compiler/tests-spec/testData/diagnostics/linked/inheritance/overriding/testsMap.json create mode 100644 compiler/tests-spec/testData/diagnostics/linked/statements/assignments/testsMap.json diff --git a/compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-increment-expression/p-1/pos/1.1.kt b/compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-increment-expression/p-1/pos/1.1.kt new file mode 100644 index 00000000000..0975b6f5409 --- /dev/null +++ b/compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-increment-expression/p-1/pos/1.1.kt @@ -0,0 +1,30 @@ +// WITH_RUNTIME + +/* + * KOTLIN CODEGEN BOX SPEC TEST (POSITIVE) + * + * SPEC VERSION: 0.1-213 + * PLACE: expressions, prefix-expressions, prefix-increment-expression -> paragraph 1 -> sentence 1 + * RELEVANT PLACES: expressions, prefix-expressions, prefix-increment-expression -> paragraph 5 -> sentence 1 + * overloadable-operators -> paragraph 4 -> sentence 1 + * statements, assignments -> paragraph 3 -> sentence 1 + * NUMBER: 1 + * DESCRIPTION: + */ + +fun box(): String { + var a = A() + val res: A = ++a + return if (a.i == 1) "OK" + else "NOK" +} + +class A() { + var i = 0 + + operator fun inc(): A { + this.i++ + return this + } + +} \ No newline at end of file diff --git a/compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-increment-expression/p-1/pos/1.2.kt b/compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-increment-expression/p-1/pos/1.2.kt new file mode 100644 index 00000000000..7c1f17c6d29 --- /dev/null +++ b/compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-increment-expression/p-1/pos/1.2.kt @@ -0,0 +1,31 @@ +// WITH_RUNTIME + +/* + * KOTLIN CODEGEN BOX SPEC TEST (POSITIVE) + * + * SPEC VERSION: 0.1-213 + * PLACE: expressions, prefix-expressions, prefix-increment-expression -> paragraph 1 -> sentence 1 + * RELEVANT PLACES: expressions, prefix-expressions, prefix-increment-expression -> paragraph 5 -> sentence 1 + * overloadable-operators -> paragraph 4 -> sentence 1 + * statements, assignments -> paragraph 3 -> sentence 1 + * NUMBER: 2 + * DESCRIPTION: + */ + + +fun box(): String { + var a = A() + val res = (++a).i + return if (res == 1 && a.i == 1) + "OK" + else "NOK" +} + +open class A() { + var i = 0 + + open operator fun inc(): A { + this.i++ + return this + } +} diff --git a/compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-increment-expression/p-4/pos/1.1.kt b/compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-increment-expression/p-4/pos/1.1.kt new file mode 100644 index 00000000000..90a06605ee1 --- /dev/null +++ b/compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-increment-expression/p-4/pos/1.1.kt @@ -0,0 +1,34 @@ +// WITH_RUNTIME + +/* + * KOTLIN CODEGEN BOX SPEC TEST (POSITIVE) + * + * SPEC VERSION: 0.1-213 + * PLACE: expressions, prefix-expressions, prefix-increment-expression -> paragraph 4 -> sentence 1 + * RELEVANT PLACES: statements, assignments -> paragraph 3 -> sentence 3 + * NUMBER: 1 + * DESCRIPTION: check for a prefix increment expression ++A expression A must be an assignable expression (an indexing expression) + */ + + +fun box(): String { + val arr = arrayOf(A(), A(), A()) + + val a = ++arr[0] + val b = (++arr[2]).i + + return if (arr[0].i == 1 && a.i == 1 && arr[1].i == 0 && arr[2].i == 1 && b == 1) + "OK" + else "NOK" +} + + +class A() { + var i = 0 + + operator fun inc(): A { + this.i++ + return this + } + +} \ No newline at end of file diff --git a/compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-increment-expression/p-4/pos/1.2.kt b/compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-increment-expression/p-4/pos/1.2.kt new file mode 100644 index 00000000000..062a26aec72 --- /dev/null +++ b/compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-increment-expression/p-4/pos/1.2.kt @@ -0,0 +1,35 @@ +// WITH_RUNTIME + +/* + * KOTLIN CODEGEN BOX SPEC TEST (POSITIVE) + * + * SPEC VERSION: 0.1-213 + * PLACE: expressions, prefix-expressions, prefix-increment-expression -> paragraph 4 -> sentence 1 + * RELEVANT PLACES: statements, assignments -> paragraph 3 -> sentence 2 + * NUMBER: 2 + * DESCRIPTION: check for a prefix increment expression ++A expression A must be an assignable expression (a navigation expression referring to a mutable property) + */ + + +fun box(): String { + var b = B() + ++b.a + return if (b.a.i == 1) + "OK" + else "NOK" +} + + +class A() { + var i = 0 + + operator fun inc(): A { + this.i++ + return this + } + +} + +class B() { + var a: A = A() +} \ No newline at end of file diff --git a/compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-increment-expression/p-5/pos/1.1.kt b/compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-increment-expression/p-5/pos/1.1.kt new file mode 100644 index 00000000000..990f8d53be7 --- /dev/null +++ b/compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-increment-expression/p-5/pos/1.1.kt @@ -0,0 +1,39 @@ +// WITH_RUNTIME + +/* + * KOTLIN CODEGEN BOX SPEC TEST (POSITIVE) + * + * SPEC VERSION: 0.1-213 + * PLACE: expressions, prefix-expressions, prefix-increment-expression -> paragraph 5 -> sentence 1 + * NUMBER: 1 + * DESCRIPTION: check the result of inc() is assigned to A, the return type of inc must be a subtype of A. + */ + +fun box(): String { + var res = BIncrement(1) + val res1: Any = ++res + + return if (res1 is BIncrement && res.i == 1 && res.j == 2 && res1.i == 1 && res1.j == 2) { + val res2: Any? = ++res + if (res2 is BIncrement && res.i == 2 && res.j == 3 && res2.i == 2 && res2.j == 3) + "OK" + else "NOK" + } else + "NOK" +} + +data class BIncrement(var j: Int) : AIncrement() { + override operator fun inc(): BIncrement { + super.inc() + this.j += 1 + return this + } +} + +open class AIncrement() { + var i = 0 + open operator fun inc(): AIncrement { + this.i += 1 + return this + } +} \ No newline at end of file diff --git a/compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-increment-expression/p-6/pos/1.1.kt b/compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-increment-expression/p-6/pos/1.1.kt new file mode 100644 index 00000000000..0a597cd2ec5 --- /dev/null +++ b/compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-increment-expression/p-6/pos/1.1.kt @@ -0,0 +1,31 @@ +// WITH_RUNTIME + +/* + * KOTLIN CODEGEN BOX SPEC TEST (POSITIVE) + * + * SPEC VERSION: 0.1-213 + * PLACE: expressions, prefix-expressions, prefix-increment-expression -> paragraph 6 -> sentence 1 + * RELEVANT PLACES: expressions, prefix-expressions, prefix-increment-expression -> paragraph 5 -> sentence 1 + * overloadable-operators -> paragraph 4 -> sentence 1 + * statements, assignments -> paragraph 3 -> sentence 1 + * NUMBER: 1 + * DESCRIPTION: + */ + +fun box(): String { + var a = A() + val res: Any? = ++a + + return if (res is A) "OK" + else "NOK" +} + +class A() { + var i = 0 + + operator fun inc(): A { + this.i++ + return this + } + +} \ No newline at end of file diff --git a/compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-increment-expression/p-6/pos/1.2.kt b/compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-increment-expression/p-6/pos/1.2.kt new file mode 100644 index 00000000000..65dc8224228 --- /dev/null +++ b/compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-increment-expression/p-6/pos/1.2.kt @@ -0,0 +1,34 @@ +// WITH_RUNTIME + +/* + * KOTLIN CODEGEN BOX SPEC TEST (POSITIVE) + * + * SPEC VERSION: 0.1-213 + * PLACE: expressions, prefix-expressions, prefix-increment-expression -> paragraph 6 -> sentence 1 + * RELEVANT PLACES: expressions, prefix-expressions, prefix-increment-expression -> paragraph 5 -> sentence 1 + * overloadable-operators -> paragraph 4 -> sentence 1 + * NUMBER: 2 + * DESCRIPTION: + */ + + +fun box(): String { + var a = A() + val res: Any? = ++a + return if (res is B) "OK" + else "NOK" +} + +open class A() { + var i = 0 + + open operator fun inc(): B { + var b = B() + b.i = this.i + b.i++ + return b + } + +} + +class B() : A() {} diff --git a/compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-increment-expression/testsMap.json b/compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-increment-expression/testsMap.json new file mode 100644 index 00000000000..d7fc0cb5cb0 --- /dev/null +++ b/compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-increment-expression/testsMap.json @@ -0,0 +1,96 @@ +{ + "6": { + "pos": { + "1": [ + { + "specVersion": "0.1-213", + "casesNumber": 0, + "description": "", + "unexpectedBehaviour": false + }, + { + "specVersion": "0.1-213", + "casesNumber": 0, + "description": "", + "unexpectedBehaviour": false + } + ] + } + }, + "5": { + "pos": { + "1": [ + { + "specVersion": "0.1-213", + "casesNumber": 0, + "description": "", + "path": "compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-increment-expression/p-6/pos/1.2.kt", + "unexpectedBehaviour": false + }, + { + "specVersion": "0.1-213", + "casesNumber": 0, + "description": "", + "path": "compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-increment-expression/p-6/pos/1.1.kt", + "unexpectedBehaviour": false + }, + { + "specVersion": "0.1-213", + "casesNumber": 0, + "description": "", + "path": "compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-increment-expression/p-1/pos/1.2.kt", + "unexpectedBehaviour": false + }, + { + "specVersion": "0.1-213", + "casesNumber": 0, + "description": "", + "path": "compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-increment-expression/p-1/pos/1.1.kt", + "unexpectedBehaviour": false + }, + { + "specVersion": "0.1-213", + "casesNumber": 0, + "description": "check the result of inc() is assigned to A, the return type of inc must be a subtype of A.", + "unexpectedBehaviour": false + } + ] + } + }, + "1": { + "pos": { + "1": [ + { + "specVersion": "0.1-213", + "casesNumber": 0, + "description": "", + "unexpectedBehaviour": false + }, + { + "specVersion": "0.1-213", + "casesNumber": 0, + "description": "", + "unexpectedBehaviour": false + } + ] + } + }, + "4": { + "pos": { + "1": [ + { + "specVersion": "0.1-213", + "casesNumber": 0, + "description": "check for a prefix increment expression ++A expression A must be an assignable expression (a navigation expression referring to a mutable property)", + "unexpectedBehaviour": false + }, + { + "specVersion": "0.1-213", + "casesNumber": 0, + "description": "check for a prefix increment expression ++A expression A must be an assignable expression (an indexing expression)", + "unexpectedBehaviour": false + } + ] + } + } +} \ No newline at end of file diff --git a/compiler/tests-spec/testData/codegen/box/linked/statements/assignments/testsMap.json b/compiler/tests-spec/testData/codegen/box/linked/statements/assignments/testsMap.json new file mode 100644 index 00000000000..831ba9fab31 --- /dev/null +++ b/compiler/tests-spec/testData/codegen/box/linked/statements/assignments/testsMap.json @@ -0,0 +1,24 @@ +{ + "3": { + "pos": { + "2": [ + { + "specVersion": "0.1-213", + "casesNumber": 0, + "description": "check for a prefix increment expression ++A expression A must be an assignable expression (a navigation expression referring to a mutable property)", + "path": "compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-increment-expression/p-4/pos/1.2.kt", + "unexpectedBehaviour": false + } + ], + "3": [ + { + "specVersion": "0.1-213", + "casesNumber": 0, + "description": "check for a prefix increment expression ++A expression A must be an assignable expression (an indexing expression)", + "path": "compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-increment-expression/p-4/pos/1.1.kt", + "unexpectedBehaviour": false + } + ] + } + } +} \ No newline at end of file diff --git a/compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/testsMap.json b/compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/testsMap.json index 765aad8bb22..15bd2a7cd4d 100644 --- a/compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/testsMap.json +++ b/compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/testsMap.json @@ -72,7 +72,7 @@ }, { "specVersion": "0.1-213", - "casesNumber": 1, + "casesNumber": 2, "description": "Abstract classes may contain one or more abstract members, which should be implemented in a subtype of this abstract class", "unexpectedBehaviour": false }, diff --git a/compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-increment-expression/p-4/neg/1.1.kt b/compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-increment-expression/p-4/neg/1.1.kt new file mode 100644 index 00000000000..de49e817a67 --- /dev/null +++ b/compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-increment-expression/p-4/neg/1.1.kt @@ -0,0 +1,44 @@ +// !LANGUAGE: +NewInference +// !DIAGNOSTICS: -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION +// SKIP_TXT + +/* + * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE) + * + * SPEC VERSION: 0.1-213 + * PLACE: expressions, prefix-expressions, prefix-increment-expression -> paragraph 4 -> sentence 1 + * RELEVANT PLACES: statements, assignments -> paragraph 3 -> sentence 2 + * NUMBER:1 + * DESCRIPTION: check unsafe prefix increment expression call for an assignable expression + */ +class A() { + var i = 0 + + operator fun inc(): A { + this.i++ + return this + } +} + +// TESTCASE NUMBER: 1 + +fun case1() { + var b: Case1? = Case1() + ++b?.a +} + + +class Case1() { + var a: A = A() +} + +// TESTCASE NUMBER: 2 + +fun case2() { + var b= Case2() + ++b.a +} + +class Case2() { + val a = A() +} \ No newline at end of file diff --git a/compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-increment-expression/p-5/neg/2.1.kt b/compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-increment-expression/p-5/neg/2.1.kt new file mode 100644 index 00000000000..9d028b6ce2d --- /dev/null +++ b/compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-increment-expression/p-5/neg/2.1.kt @@ -0,0 +1,47 @@ +// !LANGUAGE: +NewInference +// !DIAGNOSTICS: -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION +// SKIP_TXT + +/* + * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE) + * + * SPEC VERSION: 0.1-213 + * PLACE: expressions, prefix-expressions, prefix-increment-expression -> paragraph 5 -> sentence 2 + * NUMBER: 1 + * DESCRIPTION: check as the result of inc is assigned to A, the return type of inc must be a subtype of A. + */ + +// TESTCASE NUMBER: 1 + +fun case1() { + var a = Case1() + val res: Any? = ++a +} + + +class Case1() { + + operator fun inc(): B { + TODO() + } +} + +class B() {} + +// TESTCASE NUMBER: 2 + +fun case2() { + var a = Case2() + val res: Any? = ++a +} + +class Case2() : C() { + var i = 0 + + operator fun inc(): C { + TODO() + } + +} + +open class C() {} diff --git a/compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-increment-expression/testsMap.json b/compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-increment-expression/testsMap.json new file mode 100644 index 00000000000..25204d6dd4d --- /dev/null +++ b/compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-increment-expression/testsMap.json @@ -0,0 +1,26 @@ +{ + "4": { + "neg": { + "1": [ + { + "specVersion": "0.1-213", + "casesNumber": 2, + "description": "check unsafe prefix increment expression call for an assignable expression", + "unexpectedBehaviour": false + } + ] + } + }, + "5": { + "neg": { + "2": [ + { + "specVersion": "0.1-213", + "casesNumber": 2, + "description": "check as the result of inc is assigned to A, the return type of inc must be a subtype of A.", + "unexpectedBehaviour": false + } + ] + } + } +} \ No newline at end of file diff --git a/compiler/tests-spec/testData/diagnostics/linked/inheritance/overriding/testsMap.json b/compiler/tests-spec/testData/diagnostics/linked/inheritance/overriding/testsMap.json new file mode 100644 index 00000000000..e12fde2b5ba --- /dev/null +++ b/compiler/tests-spec/testData/diagnostics/linked/inheritance/overriding/testsMap.json @@ -0,0 +1,15 @@ +{ + "7": { + "neg": { + "1": [ + { + "specVersion": "0.1-213", + "casesNumber": 2, + "description": "Abstract classes may contain one or more abstract members, which should be implemented in a subtype of this abstract class", + "path": "compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-2/neg/1.8.kt", + "unexpectedBehaviour": false + } + ] + } + } +} \ No newline at end of file diff --git a/compiler/tests-spec/testData/diagnostics/linked/statements/assignments/testsMap.json b/compiler/tests-spec/testData/diagnostics/linked/statements/assignments/testsMap.json new file mode 100644 index 00000000000..e01f847a83c --- /dev/null +++ b/compiler/tests-spec/testData/diagnostics/linked/statements/assignments/testsMap.json @@ -0,0 +1,15 @@ +{ + "3": { + "neg": { + "2": [ + { + "specVersion": "0.1-213", + "casesNumber": 2, + "description": "check unsafe prefix increment expression call for an assignable expression", + "path": "compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-increment-expression/p-4/neg/1.1.kt", + "unexpectedBehaviour": false + } + ] + } + } +} \ No newline at end of file diff --git a/compiler/tests-spec/tests/org/jetbrains/kotlin/spec/checkers/DiagnosticsTestSpecGenerated.java b/compiler/tests-spec/tests/org/jetbrains/kotlin/spec/checkers/DiagnosticsTestSpecGenerated.java index a550a8c1edc..4dd77d238e3 100644 --- a/compiler/tests-spec/tests/org/jetbrains/kotlin/spec/checkers/DiagnosticsTestSpecGenerated.java +++ b/compiler/tests-spec/tests/org/jetbrains/kotlin/spec/checkers/DiagnosticsTestSpecGenerated.java @@ -25,7 +25,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInDiagnostics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/diagnostics"), Pattern.compile("^(.+)\\.kt$"), true, "helpers", "linked/type-inference", "linked/type-system/type-kinds/type-parameters", "linked/type-system/subtyping", "linked/declarations/classifier-declaration/classifier-initialization", "linked/declarations/function-declaration", "linked/annotations", "linked/expressions/function-literals", "linked/expressions/conditional-expression", "linked/expressions/built-in-types-and-their-semantics/kotlin.nothing-1/p-1/neg", "linked/overload-resolution", "linked/control--and-data-flow-analysis"); + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/diagnostics"), Pattern.compile("^(.+)\\.kt$"), true, "helpers", "linked/type-inference", "linked/type-system/type-kinds/type-parameters", "linked/type-system/subtyping", "linked/declarations/classifier-declaration/classifier-initialization", "linked/declarations/function-declaration", "linked/annotations", "linked/statements", "linked/inheritance", "linked/expressions/function-literals", "linked/expressions/conditional-expression", "linked/expressions/built-in-types-and-their-semantics/kotlin.nothing-1/p-1/neg", "linked/overload-resolution", "linked/control--and-data-flow-analysis"); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked") @@ -37,7 +37,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInLinked() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked"), Pattern.compile("^(.+)\\.kt$"), true, "type-inference", "type-system/type-kinds/type-parameters", "type-system/subtyping", "declarations/classifier-declaration/classifier-initialization", "declarations/function-declaration", "annotations", "expressions/function-literals", "expressions/conditional-expression", "expressions/built-in-types-and-their-semantics/kotlin.nothing-1/p-1/neg", "overload-resolution", "control--and-data-flow-analysis"); + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked"), Pattern.compile("^(.+)\\.kt$"), true, "type-inference", "type-system/type-kinds/type-parameters", "type-system/subtyping", "declarations/classifier-declaration/classifier-initialization", "declarations/function-declaration", "annotations", "statements", "inheritance", "expressions/function-literals", "expressions/conditional-expression", "expressions/built-in-types-and-their-semantics/kotlin.nothing-1/p-1/neg", "overload-resolution", "control--and-data-flow-analysis"); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/declarations") @@ -1164,6 +1164,94 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } } + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Prefix_expressions extends AbstractDiagnosticsTestSpec { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); + } + + public void testAllFilesPresentInPrefix_expressions() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions"), Pattern.compile("^(.+)\\.kt$"), true); + } + + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-increment-expression") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Prefix_increment_expression extends AbstractDiagnosticsTestSpec { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); + } + + public void testAllFilesPresentInPrefix_increment_expression() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-increment-expression"), Pattern.compile("^(.+)\\.kt$"), true); + } + + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-increment-expression/p-4") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class P_4 extends AbstractDiagnosticsTestSpec { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); + } + + public void testAllFilesPresentInP_4() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-increment-expression/p-4"), Pattern.compile("^(.+)\\.kt$"), true); + } + + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-increment-expression/p-4/neg") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Neg extends AbstractDiagnosticsTestSpec { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); + } + + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-increment-expression/p-4/neg/1.1.kt"); + } + + public void testAllFilesPresentInNeg() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-increment-expression/p-4/neg"), Pattern.compile("^(.+)\\.kt$"), true); + } + } + } + + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-increment-expression/p-5") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class P_5 extends AbstractDiagnosticsTestSpec { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); + } + + public void testAllFilesPresentInP_5() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-increment-expression/p-5"), Pattern.compile("^(.+)\\.kt$"), true); + } + + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-increment-expression/p-5/neg") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Neg extends AbstractDiagnosticsTestSpec { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); + } + + @TestMetadata("2.1.kt") + public void test2_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-increment-expression/p-5/neg/2.1.kt"); + } + + public void testAllFilesPresentInNeg() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-increment-expression/p-5/neg"), Pattern.compile("^(.+)\\.kt$"), true); + } + } + } + } + } + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression") @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class) diff --git a/compiler/tests-spec/tests/org/jetbrains/kotlin/spec/codegen/BlackBoxCodegenTestSpecGenerated.java b/compiler/tests-spec/tests/org/jetbrains/kotlin/spec/codegen/BlackBoxCodegenTestSpecGenerated.java index e9f571174f3..6d969a36df3 100644 --- a/compiler/tests-spec/tests/org/jetbrains/kotlin/spec/codegen/BlackBoxCodegenTestSpecGenerated.java +++ b/compiler/tests-spec/tests/org/jetbrains/kotlin/spec/codegen/BlackBoxCodegenTestSpecGenerated.java @@ -25,7 +25,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInBox() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box"), Pattern.compile("^(.+)\\.kt$"), true, "helpers", "templates", "linked/expressions/equality-expressions/reference-equality-expressions/p-1/neg", "linked/expressions/built-in-types-and-their-semantics/kotlin.unit/p-1/neg"); + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box"), Pattern.compile("^(.+)\\.kt$"), true, "helpers", "templates", "linked/statements", "linked/expressions/equality-expressions/reference-equality-expressions/p-1/neg", "linked/expressions/built-in-types-and-their-semantics/kotlin.unit/p-1/neg", "linked/expressions/prefix-expressions/prefix-increment-expression/p-1/neg"); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked") @@ -37,7 +37,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInLinked() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked"), Pattern.compile("^(.+)\\.kt$"), true, "expressions/equality-expressions/reference-equality-expressions/p-1/neg", "expressions/built-in-types-and-their-semantics/kotlin.unit/p-1/neg"); + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked"), Pattern.compile("^(.+)\\.kt$"), true, "statements", "expressions/equality-expressions/reference-equality-expressions/p-1/neg", "expressions/built-in-types-and-their-semantics/kotlin.unit/p-1/neg", "expressions/prefix-expressions/prefix-increment-expression/p-1/neg"); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions") @@ -49,7 +49,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInExpressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions"), Pattern.compile("^(.+)\\.kt$"), true, "equality-expressions/reference-equality-expressions/p-1/neg", "built-in-types-and-their-semantics/kotlin.unit/p-1/neg"); + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions"), Pattern.compile("^(.+)\\.kt$"), true, "equality-expressions/reference-equality-expressions/p-1/neg", "built-in-types-and-their-semantics/kotlin.unit/p-1/neg", "prefix-expressions/prefix-increment-expression/p-1/neg"); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/built-in-types-and-their-semantics") @@ -917,6 +917,171 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } } + @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Prefix_expressions extends AbstractBlackBoxCodegenTestSpec { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); + } + + public void testAllFilesPresentInPrefix_expressions() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions"), Pattern.compile("^(.+)\\.kt$"), true, "prefix-increment-expression/p-1/neg"); + } + + @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-increment-expression") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Prefix_increment_expression extends AbstractBlackBoxCodegenTestSpec { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); + } + + public void testAllFilesPresentInPrefix_increment_expression() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-increment-expression"), Pattern.compile("^(.+)\\.kt$"), true, "p-1/neg"); + } + + @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-increment-expression/p-1") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class P_1 extends AbstractBlackBoxCodegenTestSpec { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); + } + + public void testAllFilesPresentInP_1() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-increment-expression/p-1"), Pattern.compile("^(.+)\\.kt$"), true, "neg"); + } + + @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-increment-expression/p-1/pos") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Pos extends AbstractBlackBoxCodegenTestSpec { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); + } + + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-increment-expression/p-1/pos/1.1.kt"); + } + + @TestMetadata("1.2.kt") + public void test1_2() throws Exception { + runTest("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-increment-expression/p-1/pos/1.2.kt"); + } + + public void testAllFilesPresentInPos() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-increment-expression/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), true); + } + } + } + + @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-increment-expression/p-4") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class P_4 extends AbstractBlackBoxCodegenTestSpec { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); + } + + public void testAllFilesPresentInP_4() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-increment-expression/p-4"), Pattern.compile("^(.+)\\.kt$"), true); + } + + @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-increment-expression/p-4/pos") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Pos extends AbstractBlackBoxCodegenTestSpec { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); + } + + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-increment-expression/p-4/pos/1.1.kt"); + } + + @TestMetadata("1.2.kt") + public void test1_2() throws Exception { + runTest("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-increment-expression/p-4/pos/1.2.kt"); + } + + public void testAllFilesPresentInPos() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-increment-expression/p-4/pos"), Pattern.compile("^(.+)\\.kt$"), true); + } + } + } + + @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-increment-expression/p-5") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class P_5 extends AbstractBlackBoxCodegenTestSpec { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); + } + + public void testAllFilesPresentInP_5() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-increment-expression/p-5"), Pattern.compile("^(.+)\\.kt$"), true); + } + + @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-increment-expression/p-5/pos") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Pos extends AbstractBlackBoxCodegenTestSpec { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); + } + + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-increment-expression/p-5/pos/1.1.kt"); + } + + public void testAllFilesPresentInPos() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-increment-expression/p-5/pos"), Pattern.compile("^(.+)\\.kt$"), true); + } + } + } + + @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-increment-expression/p-6") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class P_6 extends AbstractBlackBoxCodegenTestSpec { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); + } + + public void testAllFilesPresentInP_6() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-increment-expression/p-6"), Pattern.compile("^(.+)\\.kt$"), true); + } + + @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-increment-expression/p-6/pos") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Pos extends AbstractBlackBoxCodegenTestSpec { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); + } + + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-increment-expression/p-6/pos/1.1.kt"); + } + + @TestMetadata("1.2.kt") + public void test1_2() throws Exception { + runTest("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-increment-expression/p-6/pos/1.2.kt"); + } + + public void testAllFilesPresentInPos() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-increment-expression/p-6/pos"), Pattern.compile("^(.+)\\.kt$"), true); + } + } + } + } + } + @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/type-checking-and-containment-checking-expressions") @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class)