| /* |
| * Copyright 2000-2014 JetBrains s.r.o. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| package com.intellij.psi.codeStyle.arrangement |
| |
| import static com.intellij.psi.codeStyle.arrangement.std.StdArrangementTokens.Modifier.PRIVATE |
| import static com.intellij.psi.codeStyle.arrangement.std.StdArrangementTokens.Modifier.PUBLIC |
| import static com.intellij.psi.codeStyle.arrangement.std.StdArrangementTokens.EntryType.FIELD |
| import static com.intellij.psi.codeStyle.arrangement.std.StdArrangementTokens.EntryType.METHOD |
| import static com.intellij.psi.codeStyle.arrangement.std.StdArrangementTokens.EntryType.CLASS |
| import static com.intellij.psi.codeStyle.arrangement.std.StdArrangementTokens.EntryType.INTERFACE |
| import static com.intellij.psi.codeStyle.arrangement.std.StdArrangementTokens.EntryType.ENUM |
| |
| class JavaRearrangerSectionsTest extends AbstractJavaRearrangerTest { |
| |
| void "test single section"() { |
| doTest( |
| initial: ''' |
| class MyClass |
| { |
| // --- Public Methods --- |
| |
| public void test() {} |
| |
| // --- End Public Methods --- |
| |
| private int number; |
| }''', |
| expected: ''' |
| class MyClass |
| { |
| private int number; |
| |
| // --- Public Methods --- |
| public void test() {} |
| // --- End Public Methods --- |
| }''', |
| rules: [ |
| rule(FIELD), |
| section("// --- Public Methods ---", "// --- End Public Methods ---", rule(METHOD))] |
| ) |
| } |
| |
| void "test multi section"() { |
| doTest( |
| initial: ''' |
| class MyClass |
| { |
| // --- Private Methods --- |
| |
| private void foo() {} |
| |
| // --- End Private Methods --- |
| |
| // --- Public Methods --- |
| |
| public void test() {} |
| |
| // --- End Public Methods --- |
| |
| public int p; |
| }''', |
| expected: ''' |
| class MyClass |
| { |
| public int p; |
| |
| // --- Public Methods --- |
| public void test() {} |
| // --- End Public Methods --- |
| |
| // --- Private Methods --- |
| private void foo() {} |
| // --- End Private Methods --- |
| }''', |
| rules: [ |
| section(rule(FIELD)), |
| section("// --- Public Methods ---", "// --- End Public Methods ---", rule(PUBLIC, METHOD)), |
| section("// --- Private Methods ---", "// --- End Private Methods ---", rule(PRIVATE, METHOD)) |
| ] |
| ) |
| } |
| |
| |
| void "test multi region"() { |
| doTest( |
| initial: ''' |
| class MyClass |
| { |
| //region Private Methods |
| |
| private void foo() {} |
| |
| //endregion private |
| |
| //region Public Methods |
| |
| public void test() {} |
| |
| //endregion public |
| |
| public int p; |
| }''', |
| expected: ''' |
| class MyClass |
| { |
| public int p; |
| |
| //region Public Methods |
| public void test() {} |
| //endregion public |
| |
| //region Private Methods |
| private void foo() {} |
| //endregion private |
| }''', |
| rules: [ |
| section(rule(FIELD)), |
| section("//region Public Methods", "//endregion public", rule(PUBLIC, METHOD)), |
| section("//region Private Methods", "//endregion private", rule(PRIVATE, METHOD))] |
| ) |
| } |
| |
| |
| void "test new single section"() { |
| doTest( |
| initial: ''' |
| class MyClass |
| { |
| public void test() {} |
| |
| public int p; |
| }''', |
| expected: ''' |
| class MyClass |
| { |
| public int p; |
| |
| // --- Public Methods --- |
| public void test() {} |
| // --- End Public Methods --- |
| }''', |
| rules: [ |
| section(rule(FIELD)), |
| section("// --- Public Methods ---", "// --- End Public Methods ---", rule(METHOD))] |
| ) |
| } |
| |
| |
| void "test all new multi section without comments"() { |
| doTest( |
| initial: ''' |
| class MyClass |
| { |
| public void test() {} |
| |
| public int p; |
| }''', |
| expected: ''' |
| class MyClass |
| { |
| public int p; |
| |
| // --- Public Methods --- |
| public void test() {} |
| // --- End Public Methods --- |
| }''', |
| rules: [ |
| section(rule(FIELD)), |
| section("// --- Public Methods ---", "// --- End Public Methods ---", rule(METHOD)) |
| ] |
| ) |
| } |
| |
| |
| void "test new multi section"() { |
| doTest( |
| initial: ''' |
| class MyClass |
| { |
| public int p; |
| |
| public void test() {} |
| }''', |
| expected: ''' |
| class MyClass |
| { |
| // --- Fields --- |
| public int p; |
| // --- Fields --- |
| |
| // --- Public Methods --- |
| public void test() {} |
| // --- End Public Methods --- |
| }''', |
| rules: [ |
| section("// --- Fields ---", "// --- Fields ---", rule(FIELD)), |
| section("// --- Public Methods ---", "// --- End Public Methods ---", rule(METHOD))] |
| ) |
| } |
| |
| |
| void "test new not arranged multi section"() { |
| doTest( |
| initial: ''' |
| class MyClass |
| { |
| public void test() {} |
| |
| public int p; |
| }''', |
| expected: ''' |
| class MyClass |
| { |
| // --- Fields --- |
| public int p; |
| // --- Fields --- |
| |
| // --- Public Methods --- |
| public void test() {} |
| // --- End Public Methods --- |
| }''', |
| rules: [ |
| section("// --- Fields ---", "// --- Fields ---", rule(FIELD)), |
| section("// --- Public Methods ---", "// --- End Public Methods ---", rule(METHOD)) |
| ] |
| ) |
| } |
| |
| void "test blank lines"() { |
| doTest( |
| initial: ''' |
| class MyClass |
| { |
| // --- Public Methods --- |
| public void test() {} |
| // --- End Public Methods --- |
| |
| public int p; |
| }''', |
| expected: ''' |
| class MyClass |
| { |
| public int p; |
| |
| // --- Public Methods --- |
| public void test() {} |
| // --- End Public Methods --- |
| }''', |
| rules: [ |
| rule(FIELD), |
| section("// --- Public Methods ---", "// --- End Public Methods ---", rule(METHOD))] |
| ) |
| } |
| |
| void "test multi rules in section"() { |
| doTest( |
| initial: ''' |
| class MyClass |
| { |
| private void foo() { |
| System.out.println("Hellow!"); |
| } |
| |
| // --- Methods --- |
| public void test() {} |
| // --- End Methods --- |
| |
| public int p; |
| }''', |
| expected: ''' |
| class MyClass |
| { |
| public int p; |
| |
| // --- Methods --- |
| public void test() {} |
| |
| private void foo() { |
| System.out.println("Hellow!"); |
| } |
| // --- End Methods --- |
| }''', |
| rules: [ |
| rule(FIELD), |
| section("// --- Methods ---", "// --- End Methods ---", rule(PUBLIC, METHOD), rule(PRIVATE, METHOD))] |
| ) |
| } |
| |
| void "test multi rules in new section"() { |
| doTest( |
| initial: ''' |
| class MyClass |
| { |
| private int i; |
| |
| private void foo() { |
| System.out.println("Hellow!"); |
| } |
| |
| // --- Methods --- |
| public void test() {} |
| // --- End Methods --- |
| |
| public int p; |
| }''', |
| expected: ''' |
| class MyClass |
| { |
| // --- Properties --- |
| public int p; |
| private int i; |
| // --- End Properties --- |
| |
| // --- Methods --- |
| public void test() {} |
| |
| private void foo() { |
| System.out.println("Hellow!"); |
| } |
| // --- End Methods --- |
| }''', |
| rules: [ |
| section("// --- Properties ---", "// --- End Properties ---", rule(PUBLIC, FIELD), rule(PRIVATE, FIELD)), |
| section("// --- Methods ---", "// --- End Methods ---", rule(PUBLIC, METHOD), rule(PRIVATE, METHOD))] |
| ) |
| } |
| |
| |
| void "test section without close comment"() { |
| doTest( |
| initial: ''' |
| class MyClass |
| { |
| private void foo() { |
| System.out.println("Hellow!"); |
| } |
| |
| // --- Methods --- |
| public void test() {} |
| |
| public int p; |
| }''', |
| expected: ''' |
| class MyClass |
| { |
| public int p; |
| |
| // --- Methods --- |
| public void test() {} |
| |
| private void foo() { |
| System.out.println("Hellow!"); |
| } |
| }''', |
| rules: [ |
| section(rule(FIELD)), |
| section("// --- Methods ---", null, rule(PUBLIC, METHOD), rule(PRIVATE, METHOD)) |
| ] |
| ) |
| } |
| |
| void "test new section without close comment"() { |
| doTest( |
| initial: ''' |
| class MyClass |
| { |
| private void foo() { |
| System.out.println("Hellow!"); |
| } |
| |
| // --- Methods --- |
| public void test() {} |
| |
| public int p; |
| }''', |
| expected: ''' |
| class MyClass |
| { |
| // --- Properties --- |
| public int p; |
| |
| // --- Methods --- |
| public void test() {} |
| |
| private void foo() { |
| System.out.println("Hellow!"); |
| } |
| }''', |
| rules: [ |
| section("// --- Properties ---", null, rule(FIELD)), |
| section("// --- Methods ---", null, rule(PUBLIC, METHOD), rule(PRIVATE, METHOD)) |
| ] |
| ) |
| } |
| |
| void "test new section in hierarchy"() { |
| doTest( |
| initial: ''' |
| class MyClass |
| { |
| private void foo() { |
| System.out.println("Hellow!"); |
| } |
| public void test() {} |
| }''', |
| expected: ''' |
| //region --- Class --- |
| class MyClass |
| { |
| //region --- Methods --- |
| public void test() {} |
| |
| private void foo() { |
| System.out.println("Hellow!"); |
| } |
| //endregion methods |
| } |
| //endregion class''', |
| rules: [ |
| section("//region --- Class ---", "//endregion class", rule(CLASS)), |
| section("//region --- Methods ---", "//endregion methods", rule(PUBLIC, METHOD), rule(PRIVATE, METHOD)) |
| ] |
| ) |
| } |
| |
| void "test new sections in hierarchy"() { |
| doTest( |
| initial: ''' |
| interface MyI { |
| } |
| |
| class MyClass |
| { |
| private void foo() { |
| System.out.println("Hellow!"); |
| } |
| public void test() {} |
| }''', |
| expected: ''' |
| //region --- Class --- |
| class MyClass |
| { |
| //region --- Methods --- |
| public void test() {} |
| |
| private void foo() { |
| System.out.println("Hellow!"); |
| } |
| //endregion methods |
| } |
| |
| interface MyI { |
| } |
| //endregion class''', |
| rules: [ |
| section("//region --- Class ---", "//endregion class", rule(CLASS), rule(INTERFACE)), |
| section("//region --- Methods ---", "//endregion methods", rule(PUBLIC, METHOD), rule(PRIVATE, METHOD))] |
| ) |
| } |
| |
| void "test two methods section comments in a row"() { |
| doTest( |
| initial:''' |
| public class SuperTest { |
| //publicS |
| public void test() { |
| } |
| //publicE |
| //privateS |
| private void testPrivate() { |
| } |
| //privateE |
| |
| public int t; |
| } |
| ''', |
| expected:''' |
| public class SuperTest { |
| public int t; |
| |
| //publicS |
| public void test() { |
| } |
| //publicE |
| |
| //privateS |
| private void testPrivate() { |
| } |
| //privateE |
| } |
| ''', |
| rules: [ |
| rule(FIELD), |
| section("//publicS", "//publicE", rule(PUBLIC, METHOD)), |
| section("//privateS", "//privateE", rule(PRIVATE, METHOD)) |
| ] |
| ); |
| } |
| |
| void "test two fields section comments in a row"() { |
| doTest( |
| initial:''' |
| public class SuperTest { |
| public void test() {} |
| |
| //publicFieldStart |
| public int test = 2; |
| //publicFieldEnd |
| //privateFieldStart |
| private int pr = 1; |
| //privateFieldEnd |
| } |
| ''', |
| expected:''' |
| public class SuperTest { |
| //publicFieldStart |
| public int test = 2; |
| //publicFieldEnd |
| //privateFieldStart |
| private int pr = 1; |
| //privateFieldEnd |
| |
| public void test() {} |
| } |
| ''', |
| rules: [ |
| section("//publicFieldStart", "//publicFieldEnd", rule(PUBLIC, FIELD)), |
| section("//privateFieldStart", "//privateFieldEnd", rule(PRIVATE, FIELD)), |
| rule(METHOD) |
| ] |
| ); |
| } |
| |
| void "test no additional sections added"() { |
| doTest( |
| initial: ''' |
| //sectionClassStart |
| public class Test { |
| } |
| //sectionClassEnd |
| ''', |
| expected: ''' |
| //sectionClassStart |
| public class Test { |
| } |
| //sectionClassEnd |
| ''', |
| rules: [ |
| section("//sectionClassStart", "//sectionClassEnd", rule(CLASS)) |
| ] |
| ) |
| } |
| |
| void "test inner classes sections"() { |
| doTest( |
| initial: ''' |
| //sectionClassStart |
| public class Test { |
| |
| interface Testable { |
| } |
| |
| } |
| //sectionClassEnd |
| class Double { |
| } |
| ''', |
| expected: ''' |
| //sectionClassStart |
| public class Test { |
| |
| //sectionInterfaceStart |
| interface Testable { |
| } |
| //sectionInterfaceEnd |
| |
| } |
| |
| class Double { |
| } |
| //sectionClassEnd |
| ''', |
| rules: [ |
| section("//sectionClassStart", "//sectionClassEnd", rule(CLASS)), |
| section("//sectionInterfaceStart", "//sectionInterfaceEnd", rule(INTERFACE)) |
| ] |
| ) |
| } |
| |
| void "test a lot of sections"() { |
| def rules = [ |
| section("//sectionInterfaceStart", "//sectionInterfaceEnd", rule(INTERFACE)), |
| section("//sectionEnumStart", "//sectionEnumEnd", rule(ENUM)), |
| section("//sectionClassStart", "//sectionClassEnd", rule(CLASS)), |
| section("//sectionPublicFieldStart", "//sectionPublicFieldEnd", rule(FIELD, PUBLIC)), |
| section("//sectionPrivateFieldStart", "//sectionPrivateFieldEnd", rule(FIELD, PRIVATE)), |
| section("//sectionPubicMethodStart", "//sectionPublicMethodEnd", rule(METHOD, PUBLIC)), |
| section("//sectionPrivateMethodStart", "//sectionPrivateMethodEnd", rule(METHOD, PRIVATE)), |
| ] |
| |
| doTest( |
| initial: ''' |
| public class SuperTest { |
| |
| class T {} |
| |
| class R {} |
| |
| interface I {} |
| |
| enum Q {} |
| |
| public void test() {} |
| |
| private void teste2() {} |
| |
| public void testtt() {} |
| |
| public int a; |
| |
| private int b; |
| } |
| |
| class Test {} |
| ''', |
| expected: ''' |
| //sectionClassStart |
| public class SuperTest { |
| |
| //sectionInterfaceStart |
| interface I {} |
| //sectionInterfaceEnd |
| |
| //sectionEnumStart |
| enum Q {} |
| //sectionEnumEnd |
| |
| //sectionClassStart |
| class T {} |
| |
| class R {} |
| //sectionClassEnd |
| //sectionPublicFieldStart |
| public int a; |
| //sectionPublicFieldEnd |
| //sectionPrivateFieldStart |
| private int b; |
| //sectionPrivateFieldEnd |
| |
| //sectionPubicMethodStart |
| public void test() {} |
| |
| public void testtt() {} |
| //sectionPublicMethodEnd |
| |
| //sectionPrivateMethodStart |
| private void teste2() {} |
| //sectionPrivateMethodEnd |
| } |
| |
| class Test {} |
| //sectionClassEnd |
| ''', |
| rules: rules |
| ) |
| |
| doTest( |
| initial: ''' |
| //sectionClassStart |
| public class SuperTest { |
| |
| //sectionInterfaceStart |
| interface I {} |
| //sectionInterfaceEnd |
| |
| //sectionEnumStart |
| enum Q {} |
| //sectionEnumEnd |
| |
| //sectionClassStart |
| class T {} |
| |
| class R {} |
| //sectionClassEnd |
| |
| //sectionPublicFieldStart |
| public int a; |
| //sectionPublicFieldEnd |
| |
| //sectionPrivateFieldStart |
| private int b; |
| //sectionPrivateFieldEnd |
| |
| //sectionPubicMethodStart |
| public void test() {} |
| |
| public void testtt() {} |
| //sectionPublicMethodEnd |
| |
| //sectionPrivateMethodStart |
| private void teste2() {} |
| //sectionPrivateMethodEnd |
| |
| private void newPrivateTest() {} |
| |
| class NewClass {} |
| |
| interface NewInterface {} |
| } |
| |
| class Test {} |
| //sectionClassEnd |
| |
| class NewOuterClass {} |
| ''', |
| expected: ''' |
| //sectionClassStart |
| public class SuperTest { |
| |
| //sectionInterfaceStart |
| interface I {} |
| interface NewInterface {} |
| //sectionInterfaceEnd |
| //sectionEnumStart |
| enum Q {} |
| //sectionEnumEnd |
| |
| //sectionClassStart |
| class T {} |
| |
| class R {} |
| |
| class NewClass {} |
| //sectionClassEnd |
| //sectionPublicFieldStart |
| public int a; |
| //sectionPublicFieldEnd |
| //sectionPrivateFieldStart |
| private int b; |
| //sectionPrivateFieldEnd |
| |
| //sectionPubicMethodStart |
| public void test() {} |
| |
| public void testtt() {} |
| //sectionPublicMethodEnd |
| |
| //sectionPrivateMethodStart |
| private void teste2() {} |
| |
| private void newPrivateTest() {} |
| //sectionPrivateMethodEnd |
| } |
| |
| class Test {} |
| |
| class NewOuterClass {} |
| //sectionClassEnd |
| ''', |
| rules: rules |
| ) |
| } |
| |
| void "test range rearrangement"() { |
| doTest( |
| initial: ''' |
| public class Test { |
| //pubMS |
| <range> public void test1() {} |
| private void test2() {} |
| public void test3() {}</range> |
| //pubME |
| |
| //privMS |
| private void test4() {} |
| //privME |
| } |
| ''', |
| expected: ''' |
| public class Test { |
| //pubMS |
| public void test1() {} |
| |
| public void test3() {} |
| //pubME |
| |
| //privMS |
| private void test2() {} |
| private void test4() {} |
| //privME |
| } |
| ''', |
| rules: [ |
| section("//pubMS", "//pubME", rule(PUBLIC, METHOD)), |
| section("//privMS", "//privME", rule(PRIVATE, METHOD)) |
| ] |
| ) |
| } |
| |
| void "test on range with nested sections"() { |
| doTest( |
| initial: ''' |
| //classStart |
| public class Test { |
| |
| //classStart |
| <range> class R {} |
| class T {} |
| public void test() {}</range> |
| //classEnd |
| |
| //publicMethodStart |
| public void tester() {} |
| //publicMethodEnd |
| } |
| |
| class NewOne { |
| } |
| //classEnd |
| ''', |
| expected: ''' |
| //classStart |
| public class Test { |
| |
| //classStart |
| class R {} |
| class T {} |
| //classEnd |
| |
| //publicMethodStart |
| public void test() {} |
| public void tester() {} |
| //publicMethodEnd |
| } |
| |
| class NewOne { |
| } |
| //classEnd |
| ''', |
| rules: [ |
| section("//classStart", "//classEnd", rule(CLASS)), |
| section("//publicMethodStart", "//publicMethodEnd", rule(PUBLIC, METHOD)) |
| ] |
| ) |
| } |
| |
| //Now comes failing tests - to fix in future |
| |
| //TODO look at upper one - it succeeds this is not!!! |
| void "do not test on range with three inner sections"() { |
| doTest( |
| initial: ''' |
| //classStart |
| public class Test { |
| |
| //classStart |
| <range> class R {} |
| class T {} |
| public void test() {}</range> |
| //classEnd |
| |
| //fieldStart |
| public int i = 1; |
| //fieldEnd |
| |
| //publicMethodStart |
| public void tester() {} |
| //publicMethodEnd |
| } |
| |
| class NewOne { |
| } |
| //classEnd |
| ''', |
| expected: ''' |
| //classStart |
| public class Test { |
| |
| //classStart |
| class R {} |
| class T {} |
| //classEnd |
| |
| //fieldStart |
| public int i = 1; |
| //fieldEnd |
| |
| //publicMethodStart |
| public void test() {} |
| public void tester() {} |
| //publicMethodEnd |
| } |
| |
| class NewOne { |
| } |
| //classEnd |
| ''', |
| rules: [ |
| section("//classStart", "//classEnd", rule(CLASS)), |
| section("//fieldStart", "//fieldEnd", rule(FIELD)), |
| section("//publicMethodStart", "//publicMethodEnd", rule(PUBLIC, METHOD)) |
| ] |
| ) |
| } |
| |
| void "do not test field has not only section comments"() { |
| doTest( |
| initial: '''\ |
| class Test { |
| |
| //method start |
| //field1 |
| public int field1 = 1; |
| |
| //method end |
| |
| public void method test() {} |
| |
| } |
| ''', |
| expected: '''\ |
| class Test { |
| |
| //field1 |
| public int field1 = 1; |
| |
| //method start |
| public void method test() {} |
| //method end |
| |
| } |
| ''', |
| rules: [ |
| rule(FIELD), |
| section("//method start", "//method end", rule(METHOD)) |
| ] |
| ) |
| } |
| |
| |
| void "do not test class has not only section comments"() { |
| doTest( |
| initial: '''\ |
| //class start |
| //main class |
| public class Test { |
| } |
| //class end |
| |
| interface I { |
| } |
| |
| class A { |
| } |
| |
| class B { |
| } |
| ''', |
| expected: '''\ |
| interface I { |
| } |
| |
| //class start |
| //main class |
| public class Test { |
| } |
| |
| class A { |
| } |
| |
| class B { |
| } |
| //class end |
| ''', |
| rules: [ |
| rule(INTERFACE), |
| section("//class start", "//class end", rule(CLASS)) |
| ] |
| ) |
| } |
| |
| void "do not test method has not only section comments"() { |
| doTest( |
| initial: '''\ |
| class Test { |
| |
| //methods start |
| //first |
| public void test() {} |
| |
| private void t() {} |
| //method end |
| } |
| ''', |
| expected: '''\ |
| class Test { |
| |
| //methods start |
| private void t() {} |
| |
| //first |
| public void test() {} |
| //method end |
| |
| } |
| ''', |
| rules: [ |
| section("//methods start", "//method end", rule(PRIVATE, METHOD), rule(PUBLIC, METHOD)) |
| ] |
| ) |
| } |
| |
| } |