Attachment #59412 for bug #131379

This Bugzilla instance is a read-only archive of historic NetBeans bug reports. To report a bug in NetBeans please follow the project's instructions for reporting issues.

View | Details | Raw Unified | Return to bug 131379
Collapse All | Expand All




     *  the given token.
     */
    public TokenItem findStatementStart(TokenItem token) {
        TokenItem t = findStatementStart(token, false);
        // preprocessor tokens are not important (bug#22570)
        while (t != null && isPreprocessorLine(t)) {
            TokenItem current = t.getPrevious();
            if (current == null) {
                return null;
            }
            t = findStatementStart(current, false);
        }
        return t;
    }

                            }
                        }
                        if (indent < 0) {
                            indent = computeStatementIndent(t);
                        }
                        break;


                            indent = getTokenIndent(t);
                            break;
                        }
                        indent = computeStatementIndent(t);
                        break;
                        
                    case CCTokenContext.COMMA_ID:

                        indent = computeStatementIndent(t);
                        break;
                    default:
                        indent = computeStatementIndent(t);
                        break;
                }


Lines 121-127 public class CCFormatter extends ExtForm Link Here

(-)a/cnd.editor/src/org/netbeans/modules/cnd/editor/cplusplus/CCFormatter.java (-1 / +1 lines)
121	typedText.length() == 1 && Character.isLetter(typedText.charAt(0))) {	121	typedText.length() == 1 && Character.isLetter(typedText.charAt(0))) {
122	try {	122	try {
123	int fnw = Utilities.getRowFirstNonWhite(doc, dotPos);	123	int fnw = Utilities.getRowFirstNonWhite(doc, dotPos);
124	if (checkCase(doc, fnw, typedText+"\n")) { // NOI18N	124	if (checkCase(doc, fnw, typedText+"\n") \|\| dotPos == doc.getLength()) { // NOI18N
125	ret = new int[]{fnw, fnw + 1};	125	ret = new int[]{fnw, fnw + 1};
126	}	126	}
127	} catch (BadLocationException e) {	127	} catch (BadLocationException e) {





package org.netbeans.modules.cnd.editor.reformat;

import java.util.ArrayList;
import java.util.LinkedList;
import org.netbeans.api.lexer.Token;
import org.netbeans.api.lexer.TokenSequence;

                    case LPAREN:
                        paren--;
                        if (paren==0 && hasParen){
                            ArrayList<Integer> nlList = new ArrayList<Integer>();
                            Token<CppTokenId> function = ts.lookPreviousImportant();
                            if (function != null && function.id()==IDENTIFIER) {
                                int startName = -1;
                                boolean isPrevID = false;
                                while (ts.movePrevious()) {
                                    switch(ts.token().id()){
                                        case COMMA:
                                        case COLON:
                                            return;
                                        case NEW_LINE:
                                            nlList.add(ts.index());
                                            break;
                                        case BLOCK_COMMENT:
                                        case WHITESPACE:
                                            break;
                                        case IDENTIFIER:
                                        case SCOPE:
                                        case TILDE:
                                            startName = ts.index();
                                            isPrevID = true;
                                            break;
                                        case SCOPE:
                                            startName = ts.index();
                                            isPrevID = false;
                                            break;
                                        case IDENTIFIER:
                                            if (!isPrevID) {
                                                startName = ts.index();
                                                isPrevID = true;
                                                break;
                                            }
                                            // nobreak
                                        default:
                                            ts.moveIndex(startName);
                                            ts.moveNext();
                                            newLineBefore(braces.getIndent());
                                            for(int i = 0; i < nlList.size(); i++){
                                                int nl = nlList.get(i);
                                                if (startName < nl) {
                                                    ts.moveIndex(nl);
                                                    ts.moveNext();
                                                    ts.moveNext();
                                                    removeLineBefore(false);
                                                }
                                            }
                                            return;
                                    }
                                }

        } else {
            spaces = getIndent();
        }
        newLineBefore(spaces);
    }

    private void newLineBefore(int spaces) {
        if (!ts.isFirstLineToken()) {
            Token<CppTokenId> previous = ts.lookPrevious();
            if (previous != null) {




    // ------- Tests for completion of right parenthesis ')' -------------
    
    public void testRightParenSimpleMethodCall() {
        setDefaultsOptions();
        setLoadDocumentText("m()|)");
        assertTrue(isSkipRightParen());
    }
    
    public void testRightParenSwingInvokeLaterRunnable() {
        setDefaultsOptions();
        setLoadDocumentText("SwingUtilities.invokeLater(new Runnable()|))");
        assertTrue(isSkipRightParen());
    }

    public void testRightParenSwingInvokeLaterRunnableRun() {
        setDefaultsOptions();
        setLoadDocumentText(
            "SwingUtilities.invokeLater(new Runnable() {\n"
          + "    public void run()|)\n"

    }
    
    public void testRightParenIfMethodCall() {
        setDefaultsOptions();
        setLoadDocumentText(
            " if (a()|) + 5 > 6) {\n"
          + " }"

    }

    public void testRightParenNoSkipNonBracketChar() {
        setDefaultsOptions();
        setLoadDocumentText("m()| ");
        assertFalse(isSkipRightParen());
    }

    public void testRightParenNoSkipDocEnd() {
        setDefaultsOptions();
        setLoadDocumentText("m()|");
        assertFalse(isSkipRightParen());
    }

    // ------- Tests for completion of right brace '}' -------------
    
    public void testAddRightBraceIfLeftBrace() {
        setDefaultsOptions();
        setLoadDocumentText("if (true) {|");
        assertTrue(isAddRightBrace());
    }

    public void testAddRightBraceIfLeftBraceWhiteSpace() {
        setDefaultsOptions();
        setLoadDocumentText("if (true) { \t|\n");
        assertTrue(isAddRightBrace());
    }
    
    public void testAddRightBraceIfLeftBraceLineComment() {
        setDefaultsOptions();
        setLoadDocumentText("if (true) { // line-comment|\n");
        assertTrue(isAddRightBrace());
    }

    public void testAddRightBraceIfLeftBraceBlockComment() {
        setDefaultsOptions();
        setLoadDocumentText("if (true) { /* block-comment */|\n");
        assertTrue(isAddRightBrace());
    }

    public void testAddRightBraceIfLeftBraceAlreadyPresent() {
        setDefaultsOptions();
        setLoadDocumentText(
            "if (true) {|\n"
          + "}"

    }

    public void testAddRightBraceCaretInComment() {
        setDefaultsOptions();
        setLoadDocumentText(
            "if (true) { /* in-block-comment |\n"
        );

    }
    
    public void testSimpleAdditionOfOpeningParenthesisAfterWhile () throws Exception {
        setDefaultsOptions();
        setLoadDocumentText (
            "while |"
        );

    
    // ------- Tests for completion of quote (") -------------    
    public void testSimpleQuoteInEmptyDoc () throws Exception {
        setDefaultsOptions();
        setLoadDocumentText (
            "|"
        );

    }

    public void testSimpleQuoteAtBeginingOfDoc () throws Exception {
        setDefaultsOptions();
        setLoadDocumentText (
            "|  "
        );

    }

    public void testSimpleQuoteAtEndOfDoc () throws Exception {
        setDefaultsOptions();
        setLoadDocumentText (
            "  |"
        );

    }
    
    public void testSimpleQuoteInWhiteSpaceArea () throws Exception {
        setDefaultsOptions();
        setLoadDocumentText (
            "  |  "
        );

    }
    
    public void testQuoteAtEOL () throws Exception {
        setDefaultsOptions();
        setLoadDocumentText (
            "  |\n"
        );

    }
    
    public void testQuoteWithUnterminatedStringLiteral () throws Exception {
        setDefaultsOptions();
        setLoadDocumentText (
            "  \"unterminated string| \n"
        );

    }
    
    public void testQuoteAtEOLWithUnterminatedStringLiteral () throws Exception {
        setDefaultsOptions();
        setLoadDocumentText (
            "  \"unterminated string |\n"
        );

    }

    public void testQuoteInsideStringLiteral () throws Exception {
        setDefaultsOptions();
        setLoadDocumentText (
            "  \"stri|ng literal\" "
        );

    }

    public void testQuoteInsideEmptyParentheses () throws Exception {
        setDefaultsOptions();
        setLoadDocumentText (
            " printf(|) "
        );

    }

    public void testQuoteInsideNonEmptyParentheses () throws Exception {
        setDefaultsOptions();
        setLoadDocumentText (
            " printf(|some text) "
        );

    }
    
    public void testQuoteInsideNonEmptyParenthesesBeforeClosingParentheses () throws Exception {
        setDefaultsOptions();
        setLoadDocumentText (
            " printf(i+|) "
        );

    }
    
    public void testQuoteInsideNonEmptyParenthesesBeforeClosingParenthesesAndUnterminatedStringLiteral () throws Exception {
        setDefaultsOptions();
        setLoadDocumentText (
            " printf(\"unterminated string literal |); "
        );

    }

    public void testQuoteBeforePlus () throws Exception {
        setDefaultsOptions();
        setLoadDocumentText (
            " printf(|+\"string literal\"); "
        );

    }

    public void testQuoteBeforeComma () throws Exception {
        setDefaultsOptions();
        setLoadDocumentText (
            "String s[] = new String[]{|,\"two\"};"
        );

    }

    public void testQuoteBeforeBrace () throws Exception {
        setDefaultsOptions();
        setLoadDocumentText (
            "String s[] = new String[]{\"one\",|};"
        );

    }

    public void testQuoteBeforeSemicolon() throws Exception {
        setDefaultsOptions();
        setLoadDocumentText (
            "String s = \"\" + |;"
        );

    }

    public void testQuoteBeforeSemicolonWithWhitespace() throws Exception {
        setDefaultsOptions();
        setLoadDocumentText (
            "String s = \"\" +| ;"
        );

    }

    public void testQuoteAfterEscapeSequence() throws Exception {
        setDefaultsOptions();
        setLoadDocumentText (
            "\\|"
        );

    
    /** issue #69524 */
    public void testQuoteEaten() throws Exception {
        setDefaultsOptions();
        setLoadDocumentText (
            "|"
        );


    /** issue #69935 */
    public void testQuoteInsideComments() throws Exception {
        setDefaultsOptions();
        setLoadDocumentText (
            "/** |\n */"
        );

    
    /** issue #71880 */
    public void testQuoteAtTheEndOfLineCommentLine() throws Exception {
        setDefaultsOptions();
        setLoadDocumentText (
            "// test line comment |\n"
        );

    // ------- Tests for completion of single quote (') -------------        
    
    public void testSingleQuoteInEmptyDoc () throws Exception {
        setDefaultsOptions();
        setLoadDocumentText (
            "|"
        );

    }

    public void testSingleQuoteAtBeginingOfDoc () throws Exception {
        setDefaultsOptions();
        setLoadDocumentText (
            "|  "
        );

    }

    public void testSingleQuoteAtEndOfDoc () throws Exception {
        setDefaultsOptions();
        setLoadDocumentText (
            "  |"
        );

    }
    
    public void testSingleQuoteInWhiteSpaceArea () throws Exception {
        setDefaultsOptions();
        setLoadDocumentText (
            "  |  "
        );

    }
    
    public void testSingleQuoteAtEOL () throws Exception {
        setDefaultsOptions();
        setLoadDocumentText (
            "  |\n"
        );

    }
    
    public void testSingleQuoteWithUnterminatedCharLiteral () throws Exception {
        setDefaultsOptions();
        setLoadDocumentText (
            "  '| \n"
        );

    }
    
    public void testSingleQuoteAtEOLWithUnterminatedCharLiteral () throws Exception {
        setDefaultsOptions();
        setLoadDocumentText (
            "  ' |\n"
        );

    }

    public void testSingleQuoteInsideCharLiteral () throws Exception {
        setDefaultsOptions();
        setLoadDocumentText (
            "  '| ' "
        );

    }

    public void testSingleQuoteInsideEmptyParentheses () throws Exception {
        setDefaultsOptions();
        setLoadDocumentText (
            " printf(|) "
        );

    }

    public void testSingleQuoteInsideNonEmptyParentheses () throws Exception {
        setDefaultsOptions();
        setLoadDocumentText (
            " printf(|some text) "
        );

    }
    
    public void testSingleQuoteInsideNonEmptyParenthesesBeforeClosingParentheses () throws Exception {
        setDefaultsOptions();
        setLoadDocumentText (
            " printf(i+|) "
        );

    }
    
    public void testSingleQuoteInsideNonEmptyParenthesesBeforeClosingParenthesesAndUnterminatedCharLiteral () throws Exception {
        setDefaultsOptions();
        setLoadDocumentText (
            " printf(' |); "
        );

    }

    public void testSingleQuoteBeforePlus () throws Exception {
        setDefaultsOptions();
        setLoadDocumentText (
            " printf(|+\"string literal\"); "
        );

    }

    public void testSingleQuoteBeforeComma () throws Exception {
        setDefaultsOptions();
        setLoadDocumentText (
            "String s[] = new String[]{|,\"two\"};"
        );

    }

    public void testSingleQuoteBeforeBrace () throws Exception {
        setDefaultsOptions();
        setLoadDocumentText (
            "String s[] = new String[]{\"one\",|};"
        );

    }

    public void testSingleQuoteBeforeSemicolon() throws Exception {
        setDefaultsOptions();
        setLoadDocumentText (
            "String s = \"\" + |;"
        );

    }

    public void testsingleQuoteBeforeSemicolonWithWhitespace() throws Exception {
        setDefaultsOptions();
        setLoadDocumentText (
            "String s = \"\" +| ;"
        );

    }

    public void testSingleQuoteAfterEscapeSequence() throws Exception {
        setDefaultsOptions();
        setLoadDocumentText (
            "\\|"
        );

    
    /** issue #69524 */
    public void testSingleQuoteEaten() throws Exception {
        setDefaultsOptions();
        setLoadDocumentText (
            "|"
        );

    
    /** issue #69935 */
    public void testSingleQuoteInsideComments() throws Exception {
        setDefaultsOptions();
        setLoadDocumentText (
            "/* |\n */"
        );


    /** issue #71880 */
    public void testSingleQuoteAtTheEndOfLineCommentLine() throws Exception {
        setDefaultsOptions();
        setLoadDocumentText (
            "// test line comment |\n"
        );

    }    

    public void testSystemInclude() throws Exception {
        setDefaultsOptions();
        setLoadDocumentText (
            "#include |\n"
        );

    }

    public void testUserInclude() throws Exception {
        setDefaultsOptions();
        setLoadDocumentText (
            "#include |\n"
        );

    }

    public void testArray() throws Exception {
        setDefaultsOptions();
        setLoadDocumentText (
            "int a|\n"
        );

    }
    
    public void testRightBracePreprocessor() {
        setDefaultsOptions();
        setLoadDocumentText(
            "void foo(){\n" +
            "#if A\n" +

    }

    public void testRightBracePreprocessor2() {
        setDefaultsOptions();
        setLoadDocumentText(
            "void foo(){\n" +
            "#if A\n" +

    }

    public void testRightBracePreprocessor3() {
        setDefaultsOptions();
        setLoadDocumentText(
            "void foo(){\n" +
            "#if A\n" +

    }

    public void testRightBracePreprocessor4() {
        setDefaultsOptions();
        setLoadDocumentText(
            "void foo(){\n" +
            "#if A\n" +

    }

    public void testRightBracePreprocessor5() {
        setDefaultsOptions();
        setLoadDocumentText(
            "void foo(){\n" +
            "#define PAREN {\n" +

    }
    
    public void testIZ102091() throws Exception {
        setDefaultsOptions();
        EditorOptions.getPreferences(CodeStyle.getDefault(CodeStyle.Language.CPP)).
                put(EditorOptions.newLineBeforeBrace, 
                CodeStyle.BracePlacement.NEW_LINE.name());
        setLoadDocumentText (
            "if(i)\n"+
            "    |"
        );
        typeChar('{', true);
        assertDocumentTextAndCaret ("IZ102091\n", 
            "if(i)\n"+
            "{|"
        );
            );
        } finally {
            EditorOptions.getPreferences(CodeStyle.getDefault(CodeStyle.Language.CPP)).
                    put(EditorOptions.newLineBeforeBrace, 
                    CodeStyle.BracePlacement.SAME_LINE.name());
        }
    }
    
    public void testColonAfterPublic() throws Exception {
        setDefaultsOptions();
        setLoadDocumentText (
            "class A{\n" +
            "    public|\n" +
            "}\n"
        );
        typeChar(':', true);
        assertDocumentText("Colon After Public", 
            "class A{\n" +
            "public:\n" +
            "}\n"
        );
    }
    
    public void testIdentFunctionName()  throws Exception {
        setDefaultsOptions("GNU");
        setLoadDocumentText(
            "tree\n" +
            "        |"
            );
        typeChar('d',true);
        assertDocumentTextAndCaret("Incorrect identing of main",
            "tree\n" +
            "d|"
            );
    }

    // ------- Private methods -------------
    




    // indent new line tests
    
    public void testJavadocEnterNothingAfterCaret() {
        setDefaultsOptions();
        setLoadDocumentText(
                "/**\n"
                + " * text|\n"

    }
    
    public void testJavadocEnterTextAfterCaret() {
        setDefaultsOptions();
        setLoadDocumentText(
                "/**\n"
                + " * break|text\n"

    }
    
    public void testJavadocEnterStarAfterCaret() {
        setDefaultsOptions();
        setLoadDocumentText(
                "/**\n"
                + " * text|*/\n"

    }
    
    public void testEnterInMultiLineSystemOutPrintln() {
        setDefaultsOptions();
        setLoadDocumentText(
                "void m() {\n"
                + "    printf(|\n"

    }
    
    public void testEnterInMultiLineSystemOutPrintlnLineThree() {
        setDefaultsOptions();
        setLoadDocumentText(
                "void m() {\n"
                + "    printf(\n"

    }
    
    public void testEnterInMultiLineSystemOutPrintlnAfterSemiColon() {
        setDefaultsOptions();
        setLoadDocumentText(
                "void m() {\n"
                + "    printf(\n"

//    }
    
    public void testEnterAfterIf() {
        setDefaultsOptions();
        setLoadDocumentText(
                "if (true)|\n"
                );

    }

    public void testEnterAfterIfHalf() {
        setDefaultsOptions();
        EditorOptions.getPreferences(CodeStyle.getDefault(CodeStyle.Language.CPP)).
                put(EditorOptions.newLineBeforeBrace, 
                CodeStyle.BracePlacement.NEW_LINE_HALF_INDENTED.name());
        try {
        setLoadDocumentText(
                "if (true)|\n"
                );

                "if (true)\n"
                + "  |\n"
                );
        } finally{
            setDefaultsOptions();
        }
    }

    public void testEnterAfterIfBraceHalf() {
        setDefaultsOptions();
        EditorOptions.getPreferences(CodeStyle.getDefault(CodeStyle.Language.CPP)).
                put(EditorOptions.newLineBeforeBrace, 
                CodeStyle.BracePlacement.NEW_LINE_HALF_INDENTED.name());
        try {
        setLoadDocumentText(
                "if (true)\n" +
                "  {|\n" +

                "    |\n" +
                "  }\n" 
                );
        } finally{
            setDefaultsOptions();
        }
    }

    public void testEnterAfterIfBraceHalf2() {
        setDefaultsOptions();
        EditorOptions.getPreferences(CodeStyle.getDefault(CodeStyle.Language.CPP)).
                put(EditorOptions.newLineBeforeBraceDeclaration, 
                CodeStyle.BracePlacement.NEW_LINE_HALF_INDENTED.name());
        EditorOptions.getPreferences(CodeStyle.getDefault(CodeStyle.Language.CPP)).
                put(EditorOptions.newLineBeforeBrace, 
                CodeStyle.BracePlacement.NEW_LINE_HALF_INDENTED.name());
        try {
        setLoadDocumentText(
                "int foo()\n" +
                "{\n" +

                "    }\n" +
                "}\n"
                );
        } finally{
            setDefaultsOptions();
        }
    }
    
    public void testEnterAfterFor() {
        setDefaultsOptions();
        setLoadDocumentText(
                "for (int i = 0; i < 10; i++)|\n"
                );

    }

    public void testEnterAfterForHalf() {
        setDefaultsOptions();
        EditorOptions.getPreferences(CodeStyle.getDefault(CodeStyle.Language.CPP)).
                put(EditorOptions.newLineBeforeBrace, 
                CodeStyle.BracePlacement.NEW_LINE_HALF_INDENTED.name());
        try {
        setLoadDocumentText(
                "for (int i = 0; i < 10; i++)|\n"
                );

                "for (int i = 0; i < 10; i++)\n"
                + "  |\n"
                );
        } finally{
            setDefaultsOptions();
        }
    }
    
    public void testEnterAfterWhile() {
        setDefaultsOptions();
        setLoadDocumentText(
                "while (true)|\n"
                );

    }

    public void testEnterAfterWhileHalf() {
        setDefaultsOptions();
        EditorOptions.getPreferences(CodeStyle.getDefault(CodeStyle.Language.CPP)).
                put(EditorOptions.newLineBeforeBrace, 
                CodeStyle.BracePlacement.NEW_LINE_HALF_INDENTED.name());
        try {
        setLoadDocumentText(
                "while (true)|\n"
                );

                "while (true)\n" +
                "  |\n"
                );
        } finally{
            setDefaultsOptions();
        }
    }

    public void testEnterAfterDo() {
        setDefaultsOptions();
        setLoadDocumentText(
                "do|\n"
                );

    }
    
    public void testEnterAfterDoHalf() {
        setDefaultsOptions();
        EditorOptions.getPreferences(CodeStyle.getDefault(CodeStyle.Language.CPP)).
                put(EditorOptions.newLineBeforeBrace, 
                CodeStyle.BracePlacement.NEW_LINE_HALF_INDENTED.name());
        setLoadDocumentText(
                "do|\n"
                );
        indentNewLine();
        assertDocumentTextAndCaret("Incorrect new-line indent",
                "do\n" +
                "  |\n"
                );
                    );
        } finally{
            setDefaultsOptions();
        }
    }

    public void testEnterAfterIfStmt() {
        setDefaultsOptions();
        setLoadDocumentText(
                "if (true)\n"
                + "    stmt;|\n"

    }
    
    public void testEnterAfterIfStmtHalf() {
        setDefaultsOptions();
        EditorOptions.getPreferences(CodeStyle.getDefault(CodeStyle.Language.CPP)).
                put(EditorOptions.newLineBeforeBrace, 
                CodeStyle.BracePlacement.NEW_LINE_HALF_INDENTED.name());
        try {
        setLoadDocumentText(
                "if (true)\n"
                + "  stmt;|\n"

                + "  stmt;\n"
                + "|\n"
                );
        } finally{
            setDefaultsOptions();
        }
    }

    public void testEnterAfterIfElse() {
        setDefaultsOptions();
        setLoadDocumentText(
                "if (true)\n"
                + "    stmt;\n"

    }

    public void testEnterAfterIfElseHalf() {
        setDefaultsOptions();
        EditorOptions.getPreferences(CodeStyle.getDefault(CodeStyle.Language.CPP)).
                put(EditorOptions.newLineBeforeBrace, 
                CodeStyle.BracePlacement.NEW_LINE_HALF_INDENTED.name());
        try {
        setLoadDocumentText(
                "if (true)\n"
                + "  stmt;\n"

                + "else\n"
                + "  |\n"
                );
        } finally{
            setDefaultsOptions();
        }
    }
    
    public void testEnterAfterIfElseStmt() {
        setDefaultsOptions();
        setLoadDocumentText(
                "if (true)\n"
                + "    stmt;\n"

    }
    
    public void testEnterAfterIfMultiLine() {
        setDefaultsOptions();
        setLoadDocumentText(
                "if (1 < 5|\n"
                );

    }
    
    public void testEnterAfterIfMultiLine2() {
        setDefaultsOptions();
        setLoadDocumentText(
                "if (1 < 5|)\n"
                );

     * @see http://www.netbeans.org/issues/show_bug.cgi?id=91561
     */
    public void testIdentUnbalancedBraces() {
        setDefaultsOptions();
        setLoadDocumentText(
            "void foo() {\n" +
            "#if A\n" +

     * @see http://www.netbeans.org/issues/show_bug.cgi?id=91561
     */
    public void testIdentUnbalancedBraces2() {
        setDefaultsOptions();
        setLoadDocumentText(
            "void foo() {\n" +
            "#if A\n" +

    
    public void testIdentMain() {
        setCppEditorKit(false);
        setDefaultsOptions();
        setLoadDocumentText(
            "int main() {|\n");
        indentNewLine();

    }

    public void testIdentMainHalf() {
        setCppEditorKit(false);
        setDefaultsOptions();
        EditorOptions.getPreferences(CodeStyle.getDefault(CodeStyle.Language.C)).
                put(EditorOptions.newLineBeforeBraceDeclaration, 
                CodeStyle.BracePlacement.NEW_LINE_HALF_INDENTED.name());
        try {
        setCppEditorKit(false);
        setLoadDocumentText(
            "int main() {|\n");
        indentNewLine();
        assertDocumentText("Incorrect identing of main",
            "int main() {\n" +
            "  \n");
        } finally{
            setDefaultsOptions();
        }
    }

    public void testIdentMainHalf2() {
        setCppEditorKit(false);
        setDefaultsOptions();
        EditorOptions.getPreferences(CodeStyle.getDefault(CodeStyle.Language.C)).
                put(EditorOptions.newLineBeforeBraceDeclaration, 
                CodeStyle.BracePlacement.NEW_LINE_HALF_INDENTED.name());
        try {
        setCppEditorKit(false);
        setLoadDocumentText(
            "int main()|\n");
        indentNewLine();
        assertDocumentText("Incorrect identing of main",
            "int main()\n" +
            "\n");
        } finally{
            setDefaultsOptions();
        }
    }

    public void testIdentMainHalf3() {
        setCppEditorKit(false);
        setDefaultsOptions();
        EditorOptions.getPreferences(CodeStyle.getDefault(CodeStyle.Language.C)).
                put(EditorOptions.newLineBeforeBraceDeclaration, 
                CodeStyle.BracePlacement.NEW_LINE_HALF_INDENTED.name());
        try {
        setCppEditorKit(false);
        setLoadDocumentText(
            "int main()\n"+
            "{|\n");

            "int main()\n" +
            "{\n" +
            "  \n");
        } finally{
            setDefaultsOptions();
        }
    }

    public void testIZ101099() {
        setDefaultsOptions();
        setLoadDocumentText(
                "template <class T>|\n"
                );

    }

    public void testIZ122489() {
        setDefaultsOptions();
        setLoadDocumentText(
                "Cpu::Cpu(int units) :\n"+
                "   Module(units) {\n"+

     */
    public void testIdentMethodParameters() {
        setCppEditorKit(false);
        setDefaultsOptions();
        setLoadDocumentText(
            "int longmain(int a,|\n");
        indentNewLine();

     * test parameter aligning
     */
    public void testIdentMethodParameters2() {
        setCppEditorKit(false);
        setDefaultsOptions();
        EditorOptions.getPreferences(CodeStyle.getDefault(CodeStyle.Language.C)).
                putBoolean(EditorOptions.alignMultilineMethodParams, true);
        setLoadDocumentText(
            "int longmain(int a,|\n");
        indentNewLine();
        assertDocumentText("Incorrect identing of main",
            "int longmain(int a,\n" +
            "             \n");
                "int longmain(int a,\n" +
                "             \n");
        } finally{
        EditorOptions.getPreferences(CodeStyle.getDefault(CodeStyle.Language.C)).
                putBoolean(EditorOptions.alignMultilineMethodParams, false);
        }
    }

    /**

     */
    public void testIdentCallParameters() {
        setCppEditorKit(false);
        setDefaultsOptions();
        setLoadDocumentText(
            "a = longmain(a,|\n");
        indentNewLine();

     * test parameter aligning
     */
    public void testIdentCallParameters2() {
        setDefaultsOptions();
        EditorOptions.getPreferences(CodeStyle.getDefault(CodeStyle.Language.CPP)).
                putBoolean(EditorOptions.alignMultilineCallArgs, true);
        setLoadDocumentText(
            "a = longmain(a,|\n");
        indentNewLine();
        assertDocumentText("Incorrect identing of main",
            "a = longmain(a,\n" +
            "             \n");
    }

    public void testIdentNewLineLocalDeclararion() throws Exception {
        setDefaultsOptions("GNU");
        setLoadDocumentText(
            "tree\n" +
            "disp(int i){\n" +
            "  int i = |\n" +
            "}"
            );
        indentNewLine();
        assertDocumentTextAndCaret("Incorrect identing of New Line Local Declararion",
            "tree\n" +
            "disp(int i){\n" +
            "  int i = \n" +
            "  |\n" +
            "}"
            );
    }

    public void testIdentNewLineLocalStatement() throws Exception {
        setDefaultsOptions("GNU");
        setLoadDocumentText(
            "tree\n" +
            "disp(int i){\n" +
            "  i = |\n" +
            "}"
            );
        indentNewLine();
        assertDocumentTextAndCaret("Incorrect identing of New Line Local Statement",
            "tree\n" +
            "disp(int i){\n" +
            "  i = \n" +
            "          |\n" +
            "}"
            );
    }

    public void testIdentNewLineLocalStatement2() throws Exception {
        setDefaultsOptions("GNU");
        setLoadDocumentText(
            "tree\n" +
            "disp(int i){\n" +
            "  i = f(i,|)\n" +
            "}"
            );
        indentNewLine();
        assertDocumentTextAndCaret("Incorrect identing of New Line Local Statement",
            "tree\n" +
            "disp(int i){\n" +
            "  i = f(i,\n" +
            "        |)\n" +
            "}"
            );
    }

    public void testIdentNewLineLocalStatement3() throws Exception {
        setDefaultsOptions("GNU");
        setLoadDocumentText(
            "tree\n" +
            "disp(int i){\n" +
            "  i = f(i,\n" +
            "        i+|)\n" +
            "}"
            );
        indentNewLine();
        assertDocumentTextAndCaret("Incorrect identing of New Line Local Statement",
            "tree\n" +
            "disp(int i){\n" +
            "  i = f(i,\n" +
            "        i+\n" +
            "          |)\n" +
            "}"
            );
    }

    public void testIdentNewLineLocalStatement4() throws Exception {
        setDefaultsOptions("GNU");
        setLoadDocumentText(
            "tree\n" +
            "disp(int i){\n" +
            "  i = f(i,\n" +
            "        i+foo(a,|))\n" +
            "}"
            );
        indentNewLine();
        assertDocumentTextAndCaret("Incorrect identing of New Line Local Statement",
            "tree\n" +
            "disp(int i){\n" +
            "  i = f(i,\n" +
            "        i+foo(a,\n" +
            "              |))\n" +
            "}"
            );
    }
}




        super(testMethodName);
    }

    public void testEnterAfterIfBraceHalf() {
        EditorOptions.getPreferences(CodeStyle.getDefault(CodeStyle.Language.CPP)).
                put(EditorOptions.newLineBeforeBrace, 
                CodeStyle.BracePlacement.NEW_LINE_HALF_INDENTED.name());
        try {
        setLoadDocumentText(
                "if (true)\n" +
                "  {|\n" +
                "  }\n"
                );
        indentNewLine();
        assertDocumentTextAndCaret("Incorrect new-line indent",
                "if (true)\n" +
                "  {\n" +
                "    |\n" +
                "  }\n" 
                );
        } finally{
            setDefaultsOptions();
        }
    }

    public void testEnterAfterIfBraceHalf2() {
        EditorOptions.getPreferences(CodeStyle.getDefault(CodeStyle.Language.CPP)).
                put(EditorOptions.newLineBeforeBraceDeclaration, 
                CodeStyle.BracePlacement.NEW_LINE_HALF_INDENTED.name());
        EditorOptions.getPreferences(CodeStyle.getDefault(CodeStyle.Language.CPP)).
                put(EditorOptions.newLineBeforeBrace, 
                CodeStyle.BracePlacement.NEW_LINE_HALF_INDENTED.name());
        try {
        setLoadDocumentText(
                "int foo()\n" +
                "{\n" +
                "  if (true)\n" +
                "    {|\n" +
                "    }\n" +
                "}\n"
                );
        indentNewLine();
        assertDocumentTextAndCaret("Incorrect new-line indent",
                "int foo()\n" +
                "{\n" +
                "  if (true)\n" +
                "    {\n" +
                "      |\n" +
                "    }\n" +
                "}\n"
                );
        } finally{
            setDefaultsOptions();
        }
    }
}




                ", env_ (env) { }\n" 
                );
    }

    public void testGnuStuleNewLineName5() {
        setDefaultsOptions("GNU");
        setLoadDocumentText(
                "tree decl_shadowed_for_var_lookup (tree from)\n" +
                "{\n" +
                "  return NULL_TREE;\n" +
                "}\n"
                );
        reformat();
        assertDocumentText("Incorrect formatting GNU new line name",
                "tree\n" +
                "decl_shadowed_for_var_lookup (tree from)\n" +
                "{\n" +
                "  return NULL_TREE;\n" +
                "}\n"
                );
    }

    public void testGnuStuleNewLineName6() {
        setDefaultsOptions("GNU");
        setLoadDocumentText(
                "B::tree A::\n" +
                "decl_shadowed_for_var_lookup (tree from)\n" +
                "{\n" +
                "  return NULL_TREE;\n" +
                "}\n"
                );
        reformat();
        assertDocumentText("Incorrect formatting GNU new line name",
                "B::tree\n" +
                "A::decl_shadowed_for_var_lookup (tree from)\n" +
                "{\n" +
                "  return NULL_TREE;\n" +
                "}\n"
                );
    }
    
    //IZ#131158:"Spaces Within Parenthesis|Braces" checkbox works wrongly
    public void testSpaceWithinBraces() {
        setDefaultsOptions();

Return to bug 131379

Lines 504-517 public class CCFormatSupport extends Ext Link Here

(-)a/cnd.editor/src/org/netbeans/modules/cnd/editor/cplusplus/CCFormatSupport.java (-5 / +5 lines)
504	* the given token.	504	* the given token.
505	*/	505	*/
506	public TokenItem findStatementStart(TokenItem token) {	506	public TokenItem findStatementStart(TokenItem token) {
507	TokenItem t = findStatementStart(token, true);	507	TokenItem t = findStatementStart(token, false);
508	// preprocessor tokens are not important (bug#22570)	508	// preprocessor tokens are not important (bug#22570)
509	while (t != null && isPreprocessorLine(t)) {	509	while (t != null && isPreprocessorLine(t)) {
510	TokenItem current = t.getPrevious();	510	TokenItem current = t.getPrevious();
511	if (current == null) {	511	if (current == null) {
512	return null;	512	return null;
513	}	513	}
514	t = findStatementStart(current, true);	514	t = findStatementStart(current, false);
515	}	515	}
516	return t;	516	return t;
517	}	517	}
Lines 968-974 public class CCFormatSupport extends Ext Link Here
968	}	968	}
969	}	969	}
970	if (indent < 0) {	970	if (indent < 0) {
971	indent = computeStatementIndent(token);	971	indent = computeStatementIndent(t);
972	}	972	}
973	break;	973	break;
974		974
Lines 977-983 public class CCFormatSupport extends Ext Link Here
977	indent = getTokenIndent(t);	977	indent = getTokenIndent(t);
978	break;	978	break;
979	}	979	}
980	indent = computeStatementIndent(token);	980	indent = computeStatementIndent(t);
981	break;	981	break;
982		982
983	case CCTokenContext.COMMA_ID:	983	case CCTokenContext.COMMA_ID:
Lines 988-994 public class CCFormatSupport extends Ext Link Here
988	indent = computeStatementIndent(t);	988	indent = computeStatementIndent(t);
989	break;	989	break;
990	default:	990	default:
991	indent = computeStatementIndent(token);	991	indent = computeStatementIndent(t);
992	break;	992	break;
993	}	993	}
994		994

Lines 39-44 Link Here

(-)a/cnd.editor/src/org/netbeans/modules/cnd/editor/reformat/ReformatterImpl.java (-3 / +33 lines)
39		39
40	package org.netbeans.modules.cnd.editor.reformat;	40	package org.netbeans.modules.cnd.editor.reformat;
41		41
		42	import java.util.ArrayList;
42	import java.util.LinkedList;	43	import java.util.LinkedList;
43	import org.netbeans.api.lexer.Token;	44	import org.netbeans.api.lexer.Token;
44	import org.netbeans.api.lexer.TokenSequence;	45	import org.netbeans.api.lexer.TokenSequence;
Lines 1069-1093 public class ReformatterImpl { Link Here
1069	case LPAREN:	1070	case LPAREN:
1070	paren--;	1071	paren--;
1071	if (paren==0 && hasParen){	1072	if (paren==0 && hasParen){
		1073	ArrayList<Integer> nlList = new ArrayList<Integer>();
1072	Token<CppTokenId> function = ts.lookPreviousImportant();	1074	Token<CppTokenId> function = ts.lookPreviousImportant();
1073	if (function != null && function.id()==IDENTIFIER) {	1075	if (function != null && function.id()==IDENTIFIER) {
1074	int startName = -1;	1076	int startName = -1;
		1077	boolean isPrevID = false;
1075	while (ts.movePrevious()) {	1078	while (ts.movePrevious()) {
1076	switch(ts.token().id()){	1079	switch(ts.token().id()){
1077	case COMMA:	1080	case COMMA:
1078	case COLON:	1081	case COLON:
1079	return;	1082	return;
		1083	case NEW_LINE:
		1084	nlList.add(ts.index());
		1085	break;
		1086	case BLOCK_COMMENT:
1080	case WHITESPACE:	1087	case WHITESPACE:
1081	break;	1088	break;
1082	case IDENTIFIER:
1083	case SCOPE:
1084	case TILDE:	1089	case TILDE:
1085	startName = ts.index();	1090	startName = ts.index();
		1091	isPrevID = true;
1086	break;	1092	break;
		1093	case SCOPE:
		1094	startName = ts.index();
		1095	isPrevID = false;
		1096	break;
		1097	case IDENTIFIER:
		1098	if (!isPrevID) {
		1099	startName = ts.index();
		1100	isPrevID = true;
		1101	break;
		1102	}
		1103	// nobreak
1087	default:	1104	default:
1088	ts.moveIndex(startName);	1105	ts.moveIndex(startName);
1089	ts.moveNext();	1106	ts.moveNext();
1090	newLineBefore(false);	1107	newLineBefore(braces.getIndent());
		1108	for(int i = 0; i < nlList.size(); i++){
		1109	int nl = nlList.get(i);
		1110	if (startName < nl) {
		1111	ts.moveIndex(nl);
		1112	ts.moveNext();
		1113	ts.moveNext();
		1114	removeLineBefore(false);
		1115	}
		1116	}
1091	return;	1117	return;
1092	}	1118	}
1093	}	1119	}
Lines 1640-1645 public class ReformatterImpl { Link Here
1640	} else {	1666	} else {
1641	spaces = getIndent();	1667	spaces = getIndent();
1642	}	1668	}
		1669	newLineBefore(spaces);
		1670	}
		1671
		1672	private void newLineBefore(int spaces) {
1643	if (!ts.isFirstLineToken()) {	1673	if (!ts.isFirstLineToken()) {
1644	Token<CppTokenId> previous = ts.lookPrevious();	1674	Token<CppTokenId> previous = ts.lookPrevious();
1645	if (previous != null) {	1675	if (previous != null) {

Lines 4177-4182 public class CCNewFormatterUnitTestCase Link Here

(-)a/cnd.editor/test/unit/src/org/netbeans/modules/cnd/editor/cplusplus/CCNewFormatterUnitTestCase.java (+38 lines)
4177	", env_ (env) { }\n"	4177	", env_ (env) { }\n"
4178	);	4178	);
4179	}	4179	}
		4180
		4181	public void testGnuStuleNewLineName5() {
		4182	setDefaultsOptions("GNU");
		4183	setLoadDocumentText(
		4184	"tree decl_shadowed_for_var_lookup (tree from)\n" +
		4185	"{\n" +
		4186	" return NULL_TREE;\n" +
		4187	"}\n"
		4188	);
		4189	reformat();
		4190	assertDocumentText("Incorrect formatting GNU new line name",
		4191	"tree\n" +
		4192	"decl_shadowed_for_var_lookup (tree from)\n" +
		4193	"{\n" +
		4194	" return NULL_TREE;\n" +
		4195	"}\n"
		4196	);
		4197	}
		4198
		4199	public void testGnuStuleNewLineName6() {
		4200	setDefaultsOptions("GNU");
		4201	setLoadDocumentText(
		4202	"B::tree A::\n" +
		4203	"decl_shadowed_for_var_lookup (tree from)\n" +
		4204	"{\n" +
		4205	" return NULL_TREE;\n" +
		4206	"}\n"
		4207	);
		4208	reformat();
		4209	assertDocumentText("Incorrect formatting GNU new line name",
		4210	"B::tree\n" +
		4211	"A::decl_shadowed_for_var_lookup (tree from)\n" +
		4212	"{\n" +
		4213	" return NULL_TREE;\n" +
		4214	"}\n"
		4215	);
		4216	}
		4217
4180	//IZ#131158:"Spaces Within Parenthesis\|Braces" checkbox works wrongly	4218	//IZ#131158:"Spaces Within Parenthesis\|Braces" checkbox works wrongly
4181	public void testSpaceWithinBraces() {	4219	public void testSpaceWithinBraces() {
4182	setDefaultsOptions();	4220	setDefaultsOptions();

Lines 44-99 public class CCIndentUnitTestCaseSingleT Link Here

(-)a/cnd.editor/test/unit/src/org/netbeans/modules/cnd/editor/cplusplus/CCIndentUnitTestCaseSingleTestCase.java (-52 lines)
44	super(testMethodName);	44	super(testMethodName);
45	}	45	}
46		46
47	public void testEnterAfterIfBraceHalf() {
48	EditorOptions.getPreferences(CodeStyle.getDefault(CodeStyle.Language.CPP)).
49	put(EditorOptions.newLineBeforeBrace,
50	CodeStyle.BracePlacement.NEW_LINE_HALF_INDENTED.name());
51	try {
52	setLoadDocumentText(
53	"if (true)\n" +
54	" {\|\n" +
55	" }\n"
56	);
57	indentNewLine();
58	assertDocumentTextAndCaret("Incorrect new-line indent",
59	"if (true)\n" +
60	" {\n" +
61	" \|\n" +
62	" }\n"
63	);
64	} finally{
65	setDefaultsOptions();
66	}
67	}
68
69	public void testEnterAfterIfBraceHalf2() {
70	EditorOptions.getPreferences(CodeStyle.getDefault(CodeStyle.Language.CPP)).
71	put(EditorOptions.newLineBeforeBraceDeclaration,
72	CodeStyle.BracePlacement.NEW_LINE_HALF_INDENTED.name());
73	EditorOptions.getPreferences(CodeStyle.getDefault(CodeStyle.Language.CPP)).
74	put(EditorOptions.newLineBeforeBrace,
75	CodeStyle.BracePlacement.NEW_LINE_HALF_INDENTED.name());
76	try {
77	setLoadDocumentText(
78	"int foo()\n" +
79	"{\n" +
80	" if (true)\n" +
81	" {\|\n" +
82	" }\n" +
83	"}\n"
84	);
85	indentNewLine();
86	assertDocumentTextAndCaret("Incorrect new-line indent",
87	"int foo()\n" +
88	"{\n" +
89	" if (true)\n" +
90	" {\n" +
91	" \|\n" +
92	" }\n" +
93	"}\n"
94	);
95	} finally{
96	setDefaultsOptions();
97	}
98	}
99	}	47	}