Attachment #111293 for bug #234583




	formatUnit("bugs.b230944", "X01.java");
}
public void testBug230944b() throws JavaModelException {
	this.formatterPrefs.comment_line_length = 40;
	formatUnit("bugs.b230944", "X02.java");
}


	formatUnit("bugs.b231263", "BadFormattingSample.java");
}
public void testBug231263a() throws JavaModelException {
	this.formatterPrefs.comment_line_length = 40;
	formatUnit("bugs.b231263", "X.java");
}


 * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=231297"
 */
public void testBug231297() throws JavaModelException {
	this.formatterPrefs.comment_line_length = 40;
	formatUnit("bugs.b231297", "X.java");
}
public void testBug231297a() throws JavaModelException {
	this.formatterPrefs.comment_line_length = 30;
	formatUnit("bugs.b231297", "X01.java");
}
public void testBug231297b() throws JavaModelException {
	// Difference with old formatter:
	// 1) fixed non formatted inline tag description
	this.formatterPrefs.comment_line_length = 40;
	formatUnit("bugs.b231297", "X02.java");
}
public void testBug231297c() throws JavaModelException {
	// Difference with old formatter:
	// 1) fixed non formatted inline tag description
	this.formatterPrefs.comment_line_length = 40;
	formatUnit("bugs.b231297", "X03.java");
}
public void testBug231297d() throws JavaModelException {
	// Difference with old formatter:
	// 1) fixed non formatted inline tag description
	this.formatterPrefs.comment_line_length = 40;
	formatUnit("bugs.b231297", "X03b.java");
}


 * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=232285"
 */
public void testBug232285a() throws JavaModelException {
	this.formatterPrefs.comment_line_length = 40;
	formatUnit("bugs.b232285", "X01.java");
}
public void testBug232285b() throws JavaModelException {
	this.formatterPrefs.comment_line_length = 40;
	formatUnit("bugs.b232285", "X01b.java");
}
public void testBug232285c() throws JavaModelException {
	this.formatterPrefs.comment_line_length = 40;
	formatUnit("bugs.b232285", "X01c.java");
}
public void testBug232285d() throws JavaModelException {
	this.formatterPrefs.comment_line_length = 40;
	formatUnit("bugs.b232285", "X01d.java");
}
public void testBug232285e() throws JavaModelException {
	this.formatterPrefs.comment_line_length = 40;
	formatUnit("bugs.b232285", "X01e.java");
}
public void testBug232285f() throws JavaModelException {
	this.formatterPrefs.comment_line_length = 40;
	formatUnit("bugs.b232285", "X01f.java");
}
public void testBug232285g() throws JavaModelException {
	this.formatterPrefs.comment_line_length = 40;
	formatUnit("bugs.b232285", "X02.java");
}
public void testBug232285h() throws JavaModelException {
	this.formatterPrefs.comment_line_length = 40;
	formatUnit("bugs.b232285", "X03.java");
}
public void testBug232285i() throws JavaModelException {
	this.formatterPrefs.comment_line_length = 40;
	formatUnit("bugs.b232285", "X04.java");
}
public void testBug232285j() throws JavaModelException {
	this.formatterPrefs.comment_line_length = 40;
	formatUnit("bugs.b232285", "X04b.java");
}


 * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=232488"
 */
public void testBug232488() throws JavaModelException {
	this.formatterPrefs.comment_line_length = 40;
	formatUnit("bugs.b232488", "X01.java");
}


 * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=232466"
 */
public void testBug232466a() throws JavaModelException {
	this.formatterPrefs.comment_line_length = 40;
	formatUnit("bugs.b232466", "X01.java");
}
public void testBug232466b() throws JavaModelException {
	this.formatterPrefs.comment_line_length = 40;
	formatUnit("bugs.b232466", "X02.java");
}


			"\r\n#]" +
			"}\r\n" +
			"";
	// TODO fix the incorrect indentation before the javadoc comment (also in 3.3 and 3.4M6)
	formatSource(source,
		"public class A {\n" +
		"\n" +
		"	/*\n" +
		"	 * A block comment on two lines\n" +
		"	 */\n" +
		"\n" +

		"	public void foo() {\n" +
		"	}\n" +
		"\n" +
		"        /*\r\n" +
		"         * A block comment \n" +
		"         * on two lines\n" +
		"         */\n" +

		"#]\n" +
		"\n" +
		"}";
	// TODO fix the incorrect indentation before the javadoc comment (also in 3.3 and 3.4M6)
	formatSource(source,
		"public class C {\n" +
		"	\n" +
		"	/**\n" +
		"	 * a b c d .\n" +
		"	 */\n" +
		"	void m1() {\n" +
		"\n" +
		"	}\n" +
		"\n" +
		"\n" +
		"}"
	);

		"	 * a b c d .\n" +
		"	 */\n" +
		"	void m1() {\n" +
		"\n" +
		"        }     \n" +
		"\n" +
		"\n" +

		"\n" +
		"\n" +
		"}";
	// TODO fix the incorrect indentation before the javadoc comment (also in 3.3 and 3.4M6)
	formatSource(source,
		"public class C {\n" +
		"\n" +
		"	/**\n" +
		"	 * a b c d .\n" +
		"	 */\n" +
		"        void		m1  (   )   {\n" +

		"#]\n" +
		"\n" +
		"}";
	// TODO fix the incorrect indentation before the block comment (also in 3.3 and 3.4M6)
	formatSource(source,
		"public class D {\n" +
		"	\n" +
		"	/*\n" +
		"	 * a b c d .\n" +
		"	 */\n" +
		"	void m2() {\n" +
		"\n" +
		"	}\n" +
		"\n" +
		"\n" +
		"}"
	);

		"	 * a b c d .\n" +
		"	 */\n" +
		"	void m2() {\n" +
		"\n" +
		"        }     \n" +
		"\n" +
		"\n" +

		"\n" +
		"\n" +
		"}";
	// TODO fix the incorrect indentation before the block comment (also in 3.3 and 3.4M6)
	formatSource(source,
		"public class D {\n" +
		"\n" +
		"	/*\n" +
		"	 * a b c d .\n" +
		"	 */\n" +
		"        void		m2  (   )   {\n" +

		"        }\n" +
		"#]   \n" +
		"}";
	// TODO fix the incorrect indentation before the method declaration (also in 3.3 and 3.4M6)
	// Note that the line comment wasn't formatted using 3.3 and 3.4 M6
	formatSource(source,
		"public class E {\n" +
		"	\n" +
		"\n" +
		"	void m3() { // this is a bug\n" +
		"\n" +
		"	}\n" +
		"   \n" +

		"public class E {\n" +
		"	\n" +
		"\n" +
		"        void            m3()         { // this        is a bug\n" +
		"\n" +
		"	}\n" +
		"\n" +

		"public class E {       \n" +
		"	\n" +
		"\n" +
		"	void m3() { // this      is        a    bug\n" +
		"\n" +
		"        }\n" +
		"   \n" +

		"public class E {       \n" +
		"	\n" +
		"\n" +
		"        void            m3()         { // this        is        a    bug\n" +
		"\n" +
		"        }\n" +
		"   \n" +

		"	\n" +
		"\n" +
		"        void            m3()         {     \n" +
		"		// this is a bug\n" +
		"\n" +
		"        }\n" +
		"   \n" +

 * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=232788"
 */
public void testBug232788_Tabs01() throws JavaModelException {
	this.formatterPrefs.comment_line_length = 40;
	this.formatterPrefs.tab_size = 1;
	this.formatterPrefs.indentation_size = 1;
	formatUnit("bugs.b232788", "X01_tabs.java");
}
public void testBug232788_Spaces01() throws JavaModelException {
	this.formatterPrefs.comment_line_length = 40;
	this.formatterPrefs.tab_char = DefaultCodeFormatterOptions.SPACE;
	this.formatterPrefs.tab_size = 1;
	this.formatterPrefs.indentation_size = 1;
	formatUnit("bugs.b232788", "X01_spaces.java");
}
public void testBug232788_Mixed01() throws JavaModelException {
	this.formatterPrefs.comment_line_length = 40;
	this.formatterPrefs.tab_char = DefaultCodeFormatterOptions.MIXED;
	this.formatterPrefs.tab_size = 1;
	this.formatterPrefs.indentation_size = 1;
	formatUnit("bugs.b232788", "X01_mixed.java");
}
public void testBug232788_Tabs02() throws JavaModelException {
	this.formatterPrefs.comment_line_length = 40;
	this.formatterPrefs.tab_size = 0;
	this.formatterPrefs.indentation_size = 0;
	formatUnit("bugs.b232788", "X02_tabs.java");
}
public void testBug232788_Spaces02() throws JavaModelException {
	this.formatterPrefs.comment_line_length = 40;
	this.formatterPrefs.tab_char = DefaultCodeFormatterOptions.SPACE;
	this.formatterPrefs.tab_size = 0;
	this.formatterPrefs.indentation_size = 0;
	formatUnit("bugs.b232788", "X02_spaces.java");
}
public void testBug232788_Mixed02() throws JavaModelException {
	this.formatterPrefs.comment_line_length = 40;
	this.formatterPrefs.tab_char = DefaultCodeFormatterOptions.MIXED;
	this.formatterPrefs.tab_size = 0;
	this.formatterPrefs.indentation_size = 0;
	formatUnit("bugs.b232788", "X02_mixed.java");
}
public void testBug232788_Tabs03() throws JavaModelException {
	this.formatterPrefs.comment_line_length = 40;
	this.formatterPrefs.tab_size = 1;
	this.formatterPrefs.indentation_size = 1;
	formatUnit("bugs.b232788", "X03_tabs.java");
}
public void testBug232788_Spaces03() throws JavaModelException {
	this.formatterPrefs.comment_line_length = 40;
	this.formatterPrefs.tab_char = DefaultCodeFormatterOptions.SPACE;
	this.formatterPrefs.tab_size = 1;
	this.formatterPrefs.indentation_size = 1;
	formatUnit("bugs.b232788", "X03_spaces.java");
}
public void testBug232788_Mixed03() throws JavaModelException {
	this.formatterPrefs.comment_line_length = 40;
	this.formatterPrefs.tab_char = DefaultCodeFormatterOptions.MIXED;
	this.formatterPrefs.tab_size = 1;
	this.formatterPrefs.indentation_size = 1;
	formatUnit("bugs.b232788", "X03_mixed.java");
}


		"         * block           [# #]            \n" +
		"         * comment\n" +
		"         */\n" +
		"        // [#single                       line#] comment\n" +
		"}";
	formatSource(source,
		"\n" +

		"	/**\n" +
		"	 * Javadoc comment\n" +
		"	 */\n" +
		"        /*\n" +
		"	 * block comment\n" +
		"	 */\n" +
		"        // single line comment\n" +
		"}"
	);
}

 * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=233224"
 */
public void testBug233224() throws JavaModelException {
	this.formatterPrefs.comment_line_length = 40;
	formatUnit("bugs.b233224", "X01.java");
}


 * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=233259"
 */
public void testBug233259a() throws JavaModelException {
	this.formatterPrefs.comment_line_length = 40;
	String source =
		"public class X {\n" +
		"        /**\n" +

	);
}
public void testBug233259b() throws JavaModelException {
	this.formatterPrefs.comment_line_length = 40;
	// difference with 3.3 formatter:
	// split html reference as this allow not to go over the max line width
	String source =

	);
}
public void testBug233259c() throws JavaModelException {
	this.formatterPrefs.comment_line_length = 40;
	String source =
		"public class X {\n" +
		"        /**\n" +

	);
}
public void testBug233259d() throws JavaModelException {
	this.formatterPrefs.comment_line_length = 40;
	String source =
		"public class X {\n" +
		"        /**\n" +

 * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=237942"
 */
public void testBug237942a() throws JavaModelException {
	this.formatterPrefs.comment_line_length = 40;
	String source =
		"public class X {\n" +
		"        /**\n" +

	);
}
public void testBug237942b() throws JavaModelException {
	this.formatterPrefs.comment_line_length = 40;
	// difference with 3.3 formatter:
	// do not split string reference as this can lead to javadoc syntax error
	String source =

	);
}
public void testBug237942c() throws JavaModelException {
	this.formatterPrefs.comment_line_length = 40;
	// difference with 3.3 formatter:
	// do not split string reference as this can lead to javadoc syntax error
	String source =

	);
}
public void testBug237942d() throws JavaModelException {
	this.formatterPrefs.comment_line_length = 40;
	// difference with 3.3 formatter:
	// do not split string reference as this can lead to javadoc syntax error
	String source =

	);
}

//static { TESTS_PREFIX = "testBug234583"; }
/**
 * @bug 234583: [formatter] Code formatter should adapt edits instead of regions
 * @test Ensure that selected region(s) are correctly formatted
 * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=234583"
 */
public void testBug234583a() throws JavaModelException {
	String source = 
		"public class X {\n" + 
		"[#                        int i= 1;               #]\n" + 
		"}\n";
	formatSource(source,
		"public class X {\n" + 
		"	int i = 1;\n" + 
		"}\n"
	);
}
public void testBug234583b() throws JavaModelException {
	String source = 
		"public class X {      \n" + 
		"\n" + 
		"\n" + 
		"\n" + 
		"[#                        int i= 1;               #]\n" + 
		"\n" + 
		"\n" + 
		"\n" + 
		"\n" + 
		"     }\n";
	formatSource(source,
		"public class X {      \n" + 
		"\n" + 
		"\n" + 
		"\n" + 
		"	int i = 1;\n" + 
		"\n" + 
		"\n" + 
		"\n" + 
		"\n" + 
		"     }\n"
	);
}
public void testBug234583c() throws JavaModelException {
	String source = 
		"public class X {      \n" + 
		"\n" + 
		"\n" + 
		"\n" + 
		"[#                        int i= 1;               \n" + 
		"#]\n" + 
		"\n" + 
		"\n" + 
		"\n" + 
		"     }\n";
	formatSource(source,
		"public class X {      \n" + 
		"\n" + 
		"\n" + 
		"\n" + 
		"	int i = 1;\n" + 
		"\n" + 
		"\n" + 
		"\n" + 
		"     }\n"
	);
}
public void testBug234583d() throws JavaModelException {
	String source = 
		"public class X {      \n" + 
		"\n" + 
		"\n" + 
		"[#\n" + 
		"                        int i= 1;               \n" + 
		"\n" + 
		"#]\n" + 
		"\n" + 
		"\n" + 
		"     }\n";
	formatSource(source,
		"public class X {      \n" + 
		"\n" + 
		"\n" + 
		"	int i = 1;\n" + 
		"\n" + 
		"\n" + 
		"     }\n"
	);
}
public void testBug234583e() throws JavaModelException {
	String source = 
		"public class X {      \n" + 
		"\n" + 
		"[#\n" + 
		"\n" + 
		"                        int i= 1;               \n" + 
		"\n" + 
		"\n" + 
		"#]\n" + 
		"\n" + 
		"     }\n";
	formatSource(source,
		"public class X {      \n" + 
		"\n" + 
		"	int i = 1;\n" + 
		"\n" + 
		"     }\n"
	);
}
public void testBug234583f() throws JavaModelException {
	String source = 
		"public class X {      \n" + 
		"[#\n" + 
		"\n" + 
		"\n" + 
		"                        int i= 1;               \n" + 
		"\n" + 
		"\n" + 
		"\n" + 
		"#]\n" + 
		"     }\n";
	formatSource(source,
		"public class X {      \n" + 
		"\n" + 
		"	int i = 1;\n" + 
		"\n" + 
		"     }\n"
	);
}
public void testBug234583g() throws JavaModelException {
	String source = 
		"public class X {      [#\n" + 
		"\n" + 
		"\n" + 
		"\n" + 
		"                        int i= 1;               \n" + 
		"\n" + 
		"\n" + 
		"\n" + 
		"\n" + 
		"#]     }\n";
	formatSource(source,
		"public class X {      \n" + 
		"\n" + 
		"	int i = 1;\n" + 
		"\n" + 
		"     }\n"
	);
}
public void testBug234583h() throws JavaModelException {
	String source = 
		"public class X {   [#   \n" + 
		"\n" + 
		"\n" + 
		"\n" + 
		"                        int i= 1;               \n" + 
		"\n" + 
		"\n" + 
		"\n" + 
		"\n" + 
		"   #]  }\n";
	formatSource(source,
		"public class X {   \n" + 
		"\n" + 
		"	int i = 1;\n" + 
		"\n" + 
		"  }\n"
	);
}
public void testBug234583i() throws JavaModelException {
	String source = 
		"public class X {[#      \n" + 
		"\n" + 
		"\n" + 
		"\n" + 
		"                        int i= 1;               \n" + 
		"\n" + 
		"\n" + 
		"\n" + 
		"\n" + 
		"     #]}\n";
	formatSource(source,
		"public class X {\n" + 
		"\n" + 
		"	int i = 1;\n" + 
		"\n" + 
		"}\n"
	);
}
// duplicate https://bugs.eclipse.org/bugs/show_bug.cgi?id=239447
public void testBug234583_Bug239447() throws JavaModelException {
	String source = 
		"public class Bug239447 {\n" + 
		"	private static final String CONTENT = \"test.ObjectB {\\n\"\n" + 
		"[#			     + \"     multiEle = { name=\\\"Foo\\\" }\\n\"#]\n" + 
		"			+ \"     multiEle = :x { name=\\\"Bar\\\" }\\n\" + \"   singleEle = x;\\n\"\n" + 
		"			+ \"}\";\n" + 
		"\n" + 
		"}\n";
	formatSource(source,
		"public class Bug239447 {\n" + 
		"	private static final String CONTENT = \"test.ObjectB {\\n\"\n" + 
		"			+ \"     multiEle = { name=\\\"Foo\\\" }\\n\"\n" + 
		"			+ \"     multiEle = :x { name=\\\"Bar\\\" }\\n\" + \"   singleEle = x;\\n\"\n" + 
		"			+ \"}\";\n" + 
		"\n" + 
		"}\n"
	);
}
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=237453
public void testBug234583_Bug237453a() throws JavaModelException {
	String source = 
		"package test1;\n" + 
		"\n" + 
		"public class E1 {\n" + 
		" 	void foo() {\n" + 
		"	}\n" + 
		" 	[#\n" + 
		"	#]\n" + 
		" 	void bar() {\n" + 
		"	}\n" + 
		"}";
	formatSource(source,
		"package test1;\n" + 
		"\n" + 
		"public class E1 {\n" + 
		" 	void foo() {\n" + 
		"	}\n" + 
		" 	\n" + 
		" 	void bar() {\n" + 
		"	}\n" + 
		"}"
	);
}
public void testBug234583_Bug237453b() throws JavaModelException {
	String source = 
		"package test1;\n" + 
		"\n" + 
		"public class E1 {\n" + 
		" 	void foo() {\n" + 
		"	}\n" + 
		" 	\n" + 
		"[#	#]\n" + 
		" 	void bar() {\n" + 
		"	}\n" + 
		"}";
	formatSource(source,
		"package test1;\n" + 
		"\n" + 
		"public class E1 {\n" + 
		" 	void foo() {\n" + 
		"	}\n" + 
		" 	\n" + 
		"	\n" + 
		" 	void bar() {\n" + 
		"	}\n" + 
		"}"
	);
}
// duplicate https://bugs.eclipse.org/bugs/show_bug.cgi?id=237592
public void testBug234583_Bug237592() throws JavaModelException {
	String source = 
		"package test;\n" + 
		"\n" + 
		"public class Test {\n" + 
		"\n" + 
		"	void foo() {\n" + 
		"	}\n" + 
		"\n" + 
		"[#	  #]\n" + 
		"	\n" + 
		"	\n" + 
		"	\n" + 
		"	\n" + 
		"	\n" + 
		"[#	 #]\n" + 
		"	\n" + 
		"	\n" + 
		"	\n" + 
		"	\n" + 
		"	\n" + 
		"	void bar() {\n" + 
		"	}\n" + 
		"\n" + 
		"}\n";
	formatSource(source,
		"package test;\n" + 
		"\n" + 
		"public class Test {\n" + 
		"\n" + 
		"	void foo() {\n" + 
		"	}\n" + 
		"\n" + 
		"	\n" + 
		"	\n" + 
		"	\n" + 
		"	\n" + 
		"	\n" + 
		"	\n" + 
		"	 \n" + 
		"	\n" + 
		"	\n" + 
		"	\n" + 
		"	\n" + 
		"	\n" + 
		"	void bar() {\n" + 
		"	}\n" + 
		"\n" + 
		"}\n"
	);
}

/**
 * @bug 236230: [formatter] SIOOBE while formatting a compilation unit.
 * @test Ensure that no exception occurs while formatting

	);
}
public void testBug236230c() throws JavaModelException {
	this.formatterPrefs.comment_format_header = true;
	String source =
		"/**\n" +
		" * Need a javadoc comment before to get the exception.\n" +

 * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=238090"
 */
public void testBug238090() throws JavaModelException {
	this.formatterPrefs.comment_line_length = 40;
	String source =
		"package test.bugs;\n" +
		"public class LongNameClass {\n" +

 * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=241345"
 */
public void testBug241345() throws JavaModelException {
	this.formatterPrefs.comment_format_html = false;
	String source = 
		"/**\n" + 
		" * <p>Should not format HTML paragraph</p>\n" + 

Lines 54-59 Link Here

(-)src/org/eclipse/jdt/core/tests/formatter/FormatterRegressionTests.java (+324 lines)
54	private static final String LINE_SEPARATOR = System.getProperty("line.separator");	54	private static final String LINE_SEPARATOR = System.getProperty("line.separator");
55	private long time;	55	private long time;
56		56
		57	DefaultCodeFormatterOptions formatterPrefs;
		58
57	static {	59	static {
58	// TESTS_NUMBERS = new int[] { 715 };	60	// TESTS_NUMBERS = new int[] { 715 };
59	// TESTS_RANGE = new int[] { 715, -1 };	61	// TESTS_RANGE = new int[] { 715, -1 };
Lines 147-152 Link Here
147		149
148	return org.eclipse.jdt.internal.core.util.Util.editedString(source, edit);	150	return org.eclipse.jdt.internal.core.util.Util.editedString(source, edit);
149	}	151	}
		152
		153	/**
		154	* Init formatter preferences with Eclipse default settings.
		155	*/
		156	protected void setUp() throws Exception {
		157	super.setUp();
		158	this.formatterPrefs = DefaultCodeFormatterOptions.getEclipseDefaultSettings();
		159	}
150		160
151	/**	161	/**
152	* Create project and set the jar placeholder.	162	* Create project and set the jar placeholder.
Lines 203-208 Link Here
203	assertSourceEquals("Different number of length", Util.convertToIndependantLineDelimiter(expectedContents), actualContents);	213	assertSourceEquals("Different number of length", Util.convertToIndependantLineDelimiter(expectedContents), actualContents);
204	}	214	}
205		215
		216	DefaultCodeFormatter codeFormatter() {
		217	DefaultCodeFormatter codeFormatter = new DefaultCodeFormatter(this.formatterPrefs, JAVA_PROJECT.getOptions(true));
		218	return codeFormatter;
		219	}
		220
		221	void assertLineEquals(String actualContents, String originalSource, String expectedContents) {
		222	String outputSource = expectedContents == null ? originalSource : expectedContents;
		223	assertLineEquals(actualContents, originalSource, outputSource, false /* do not check null */);
		224	}
		225
		226	void formatSource(String source, String formattedOutput) {
		227	formatSource(source, formattedOutput, CodeFormatter.K_COMPILATION_UNIT \| CodeFormatter.F_INCLUDE_COMMENTS, 0, true /repeat formatting twice/);
		228	}
		229
		230	void formatSource(String source, String formattedOutput, boolean repeat) {
		231	formatSource(source, formattedOutput, CodeFormatter.K_COMPILATION_UNIT \| CodeFormatter.F_INCLUDE_COMMENTS, 0, repeat);
		232	}
		233
		234	void formatSource(String source, String formattedOutput, int kind, int indentationLevel, boolean repeat) {
		235	int regionStart = source.indexOf("[#");
		236	if (regionStart != -1) {
		237	IRegion[] regions = new Region[10];
		238	int idx = 0;
		239	int start = 0;
		240	int delta = 0;
		241	StringBuffer buffer = new StringBuffer();
		242	while (regionStart != -1) {
		243	buffer.append(source.substring(start, regionStart));
		244	int regionEnd = source.indexOf("#]", regionStart+2);
		245	buffer.append(source.substring(regionStart+2, regionEnd));
		246	regions[idx++] = new Region(regionStart-delta, regionEnd-(regionStart+2));
		247	delta += 4;
		248	start = regionEnd + 2;
		249	regionStart = source.indexOf("[#", start);
		250	}
		251	buffer.append(source.substring(start, source.length()));
		252	String newSource = buffer.toString();
		253	String result;
		254	if (idx == 1) {
		255	// Use offset and length until bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=233967 is fixed
		256	result = runFormatter(codeFormatter(), newSource, kind, indentationLevel, regions[0].getOffset(), regions[0].getLength(), LINE_SEPARATOR, repeat);
		257	} else {
		258	System.arraycopy(regions, 0, regions = new Region[idx], 0, idx);
		259	result = runFormatter(codeFormatter(), newSource, kind, indentationLevel, regions, LINE_SEPARATOR);
		260	}
		261	assertLineEquals(result, newSource, formattedOutput);
		262	} else {
		263	formatSource(source, formattedOutput, kind, indentationLevel, false, 0, -1, null, repeat);
		264	}
		265	}
		266
		267	void formatSource(String source, String formattedOutput, int kind, int indentationLevel, boolean checkNull, int offset, int length, String lineSeparator, boolean repeat) {
		268	DefaultCodeFormatter codeFormatter = codeFormatter();
		269	String result;
		270	if (length == -1) {
		271	result = runFormatter(codeFormatter, source, kind, indentationLevel, offset, source.length(), lineSeparator, repeat);
		272	} else {
		273	result = runFormatter(codeFormatter, source, kind, indentationLevel, offset, length, lineSeparator, repeat);
		274	}
		275	assertLineEquals(result, source, formattedOutput);
		276	}
		277
		278
206	private void runTest(String packageName, String compilationUnitName) {	279	private void runTest(String packageName, String compilationUnitName) {
207	DefaultCodeFormatterOptions preferences = new DefaultCodeFormatterOptions(DefaultCodeFormatterConstants.getEclipse21Settings());	280	DefaultCodeFormatterOptions preferences = new DefaultCodeFormatterOptions(DefaultCodeFormatterConstants.getEclipse21Settings());
208	preferences.number_of_empty_lines_to_preserve = 0;	281	preferences.number_of_empty_lines_to_preserve = 0;
Lines 9456-9461 Link Here
9456		9529
9457	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=203304	9530	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=203304
9458	public void test671() {	9531	public void test671() {
		9532	/* old version
9459	final Map options = DefaultCodeFormatterConstants.getEclipseDefaultSettings();	9533	final Map options = DefaultCodeFormatterConstants.getEclipseDefaultSettings();
9460	DefaultCodeFormatterOptions preferences = new DefaultCodeFormatterOptions(options);	9534	DefaultCodeFormatterOptions preferences = new DefaultCodeFormatterOptions(options);
9461	DefaultCodeFormatter codeFormatter = new DefaultCodeFormatter(preferences);	9535	DefaultCodeFormatter codeFormatter = new DefaultCodeFormatter(preferences);
Lines 9464-9469 Link Here
9464	new Region(101, 20)	9538	new Region(101, 20)
9465	};	9539	};
9466	runTest(codeFormatter, "test671", "A.java", CodeFormatter.K_COMPILATION_UNIT, 0, false, regions, "\n");//$NON-NLS-1$ //$NON-NLS-2$	9540	runTest(codeFormatter, "test671", "A.java", CodeFormatter.K_COMPILATION_UNIT, 0, false, regions, "\n");//$NON-NLS-1$ //$NON-NLS-2$
		9541	*/
		9542	String source =
		9543	"public class A {\n" +
		9544	" public static void main(String[] args) {\n" +
		9545	"[# int a = 1;#]\n" +
		9546	" int b = 2;\n" +
		9547	"[# int c = 3;#]\n" +
		9548	" }\n" +
		9549	"}\n";
		9550	formatSource(source,
		9551	"public class A {\n" +
		9552	" public static void main(String[] args) {\n" +
		9553	" int a = 1;\n" +
		9554	" int b = 2;\n" +
		9555	" int c = 3;\n" +
		9556	" }\n" +
		9557	"}\n",
		9558	CodeFormatter.K_COMPILATION_UNIT,
		9559	0 /no indentation/,
		9560	true /repeat formatting twice/
		9561	);
9467	}	9562	}
9468		9563
9469	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=203304	9564	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=203304
Lines 9492-9497 Link Here
9492		9587
9493	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=203304	9588	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=203304
9494	public void test674() {	9589	public void test674() {
		9590	/* old version
9495	final Map options = DefaultCodeFormatterConstants.getEclipseDefaultSettings();	9591	final Map options = DefaultCodeFormatterConstants.getEclipseDefaultSettings();
9496	DefaultCodeFormatterOptions preferences = new DefaultCodeFormatterOptions(options);	9592	DefaultCodeFormatterOptions preferences = new DefaultCodeFormatterOptions(options);
9497	DefaultCodeFormatter codeFormatter = new DefaultCodeFormatter(preferences);	9593	DefaultCodeFormatter codeFormatter = new DefaultCodeFormatter(preferences);
Lines 9500-9505 Link Here
9500	new Region(276, 54)	9596	new Region(276, 54)
9501	};	9597	};
9502	runTest(codeFormatter, "test674", "A.java", CodeFormatter.K_CLASS_BODY_DECLARATIONS, 0, false, regions, "\n");//$NON-NLS-1$ //$NON-NLS-2$	9598	runTest(codeFormatter, "test674", "A.java", CodeFormatter.K_CLASS_BODY_DECLARATIONS, 0, false, regions, "\n");//$NON-NLS-1$ //$NON-NLS-2$
		9599	*/
		9600	String source =
		9601	"public class A {\n" +
		9602	" \n" +
		9603	" \n" +
		9604	" private class Inner1 {[#\n" +
		9605	" \n" +
		9606	" \n" +
		9607	" void bar () { }\n" +
		9608	" \n" +
		9609	" void i()\n" +
		9610	" {\n" +
		9611	" \n" +
		9612	" }\n" +
		9613	" #]}\n" +
		9614	" \n" +
		9615	" \n" +
		9616	" private class Inner2 {\n" +
		9617	" void xy() {\n" +
		9618	" \n" +
		9619	" }\n" +
		9620	" }\n" +
		9621	"}\n" +
		9622	"class B {[#\n" +
		9623	" private void foo() {\n" +
		9624	" \n" +
		9625	" }\n" +
		9626	"#]}\n";
		9627	formatSource(source,
		9628	"public class A {\n" +
		9629	" \n" +
		9630	" \n" +
		9631	" private class Inner1 {\n" +
		9632	"\n" +
		9633	" void bar() {\n" +
		9634	" }\n" +
		9635	"\n" +
		9636	" void i() {\n" +
		9637	"\n" +
		9638	" }\n" +
		9639	" }\n" +
		9640	" \n" +
		9641	" \n" +
		9642	" private class Inner2 {\n" +
		9643	" void xy() {\n" +
		9644	" \n" +
		9645	" }\n" +
		9646	" }\n" +
		9647	"}\n" +
		9648	"class B {\n" +
		9649	" private void foo() {\n" +
		9650	"\n" +
		9651	" }\n" +
		9652	"}\n",
		9653	CodeFormatter.K_CLASS_BODY_DECLARATIONS,
		9654	0 /no indentation/,
		9655	true /repeat formatting twice/
		9656	);
9503	}	9657	}
9504		9658
9505	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=203304	9659	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=203304
Lines 9631-9636 Link Here
9631		9785
9632	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=208541	9786	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=208541
9633	public void test685() {	9787	public void test685() {
		9788	/* old version
9634	final Map options = DefaultCodeFormatterConstants.getEclipseDefaultSettings();	9789	final Map options = DefaultCodeFormatterConstants.getEclipseDefaultSettings();
9635	DefaultCodeFormatterOptions preferences = new DefaultCodeFormatterOptions(options);	9790	DefaultCodeFormatterOptions preferences = new DefaultCodeFormatterOptions(options);
9636	DefaultCodeFormatter codeFormatter = new DefaultCodeFormatter(preferences);	9791	DefaultCodeFormatter codeFormatter = new DefaultCodeFormatter(preferences);
Lines 9638-9643 Link Here
9638	new Region(18, 35)	9793	new Region(18, 35)
9639	};	9794	};
9640	runTest(codeFormatter, "test685", "A.java", CodeFormatter.K_UNKNOWN, 0, false, regions, "\n");//$NON-NLS-1$ //$NON-NLS-2$	9795	runTest(codeFormatter, "test685", "A.java", CodeFormatter.K_UNKNOWN, 0, false, regions, "\n");//$NON-NLS-1$ //$NON-NLS-2$
		9796	*/
		9797	String source =
		9798	"public class A {\n" +
		9799	" [# int i=1; #] \n" +
		9800	"}\n";
		9801	// Note that whitespaces outside the region are kept after the formatting
		9802	// This is intentional since fix for bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=234583
		9803	// The formatter should not touch code outside the given region(s)...
		9804	formatSource(source,
		9805	"public class A {\n" +
		9806	" int i = 1; \n" +
		9807	"}\n",
		9808	CodeFormatter.K_UNKNOWN,
		9809	0 /no indentation/,
		9810	true /repeat formatting twice/
		9811	);
9641	}	9812	}
9642		9813
9643	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=208541	9814	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=208541
Lines 9661-9666 Link Here
9661		9832
9662	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=208541	9833	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=208541
9663	public void test688a() {	9834	public void test688a() {
		9835	/* old version
9664	final Map options = DefaultCodeFormatterConstants.getEclipseDefaultSettings();	9836	final Map options = DefaultCodeFormatterConstants.getEclipseDefaultSettings();
9665	DefaultCodeFormatterOptions preferences = new DefaultCodeFormatterOptions(options);	9837	DefaultCodeFormatterOptions preferences = new DefaultCodeFormatterOptions(options);
9666	DefaultCodeFormatter codeFormatter = new DefaultCodeFormatter(preferences);	9838	DefaultCodeFormatter codeFormatter = new DefaultCodeFormatter(preferences);
Lines 9668-9676 Link Here
9668	new Region(18, 48)	9840	new Region(18, 48)
9669	};	9841	};
9670	runTest(codeFormatter, "test688", "A.java", CodeFormatter.K_UNKNOWN, 0, false, regions, "\n");//$NON-NLS-1$ //$NON-NLS-2$	9842	runTest(codeFormatter, "test688", "A.java", CodeFormatter.K_UNKNOWN, 0, false, regions, "\n");//$NON-NLS-1$ //$NON-NLS-2$
		9843	*/
		9844	String source =
		9845	"public class A {\n" +
		9846	" [# int i=1; \n" +
		9847	"}#]\n";
		9848	// Note that whitespaces outside the region are kept after the formatting
		9849	// This is intentional since fix for bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=234583
		9850	// The formatter should not touch code outside the given region(s)...
		9851	formatSource(source,
		9852	"public class A {\n" +
		9853	" int i = 1;\n" +
		9854	"}\n",
		9855	CodeFormatter.K_UNKNOWN,
		9856	0 /no indentation/,
		9857	true /repeat formatting twice/
		9858	);
9671	}	9859	}
9672		9860
9673	public void test688b() {	9861	public void test688b() {
		9862	/* old version
9674	final Map options = DefaultCodeFormatterConstants.getEclipseDefaultSettings();	9863	final Map options = DefaultCodeFormatterConstants.getEclipseDefaultSettings();
9675	DefaultCodeFormatterOptions preferences = new DefaultCodeFormatterOptions(options);	9864	DefaultCodeFormatterOptions preferences = new DefaultCodeFormatterOptions(options);
9676	DefaultCodeFormatter codeFormatter = new DefaultCodeFormatter(preferences);	9865	DefaultCodeFormatter codeFormatter = new DefaultCodeFormatter(preferences);
Lines 9678-9683 Link Here
9678	new Region(18, 49)	9867	new Region(18, 49)
9679	};	9868	};
9680	runTest(codeFormatter, "test688", "A.java", CodeFormatter.K_UNKNOWN, 0, false, regions, "\n");//$NON-NLS-1$ //$NON-NLS-2$	9869	runTest(codeFormatter, "test688", "A.java", CodeFormatter.K_UNKNOWN, 0, false, regions, "\n");//$NON-NLS-1$ //$NON-NLS-2$
		9870	*/
		9871	String source =
		9872	"public class A {\n" +
		9873	" [# int i=1; \n" +
		9874	"}\n#]";
		9875	// Note that whitespaces outside the region are kept after the formatting
		9876	// This is intentional since fix for bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=234583
		9877	// The formatter should not touch code outside the given region(s)...
		9878	formatSource(source,
		9879	"public class A {\n" +
		9880	" int i = 1;\n" +
		9881	"}\n"
		9882	);
9681	}	9883	}
9682		9884
9683	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=208541	9885	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=208541
Lines 9694-9699 Link Here
9694		9896
9695	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=208541	9897	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=208541
9696	public void test690() {	9898	public void test690() {
		9899	/* old version
9697	final Map options = DefaultCodeFormatterConstants.getEclipseDefaultSettings();	9900	final Map options = DefaultCodeFormatterConstants.getEclipseDefaultSettings();
9698	DefaultCodeFormatterOptions preferences = new DefaultCodeFormatterOptions(options);	9901	DefaultCodeFormatterOptions preferences = new DefaultCodeFormatterOptions(options);
9699	preferences.line_separator = "\r";//$NON-NLS-1$	9902	preferences.line_separator = "\r";//$NON-NLS-1$
Lines 9702-9711 Link Here
9702	new Region(31, 23)	9905	new Region(31, 23)
9703	};	9906	};
9704	runTest(codeFormatter, "test689", "A.java", CodeFormatter.K_UNKNOWN, 0, false, regions, "\r");//$NON-NLS-1$ //$NON-NLS-2$	9907	runTest(codeFormatter, "test689", "A.java", CodeFormatter.K_UNKNOWN, 0, false, regions, "\r");//$NON-NLS-1$ //$NON-NLS-2$
		9908	*/
		9909	this.formatterPrefs.line_separator = "\r";//$NON-NLS-1$
		9910	String source =
		9911	"package pkg1;\n" +
		9912	"public class A {\n" +
		9913	"[# int i = 1; #]\n" +
		9914	"\n" +
		9915	"}\n";
		9916	// Note that whitespaces outside the region are kept after the formatting
		9917	// This is intentional since fix for bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=234583
		9918	// The formatter should not touch code outside the given region(s)...
		9919	formatSource(source,
		9920	"package pkg1;\n" +
		9921	"public class A {\n" +
		9922	" int i = 1;\n" +
		9923	"\n" +
		9924	"}\n",
		9925	CodeFormatter.K_UNKNOWN,
		9926	0 /no indentation/,
		9927	true /repeat formatting twice/
		9928	);
9705	}	9929	}
9706		9930
9707	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=208541	9931	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=208541
9708	public void test691() {	9932	public void test691() {
		9933	/* old version
9709	final Map options = DefaultCodeFormatterConstants.getEclipseDefaultSettings();	9934	final Map options = DefaultCodeFormatterConstants.getEclipseDefaultSettings();
9710	DefaultCodeFormatterOptions preferences = new DefaultCodeFormatterOptions(options);	9935	DefaultCodeFormatterOptions preferences = new DefaultCodeFormatterOptions(options);
9711	preferences.line_separator = "\r\n";//$NON-NLS-1$	9936	preferences.line_separator = "\r\n";//$NON-NLS-1$
Lines 9714-9719 Link Here
9714	new Region(31, 22)	9939	new Region(31, 22)
9715	};	9940	};
9716	runTest(codeFormatter, "test689", "A.java", CodeFormatter.K_UNKNOWN, 0, false, regions, "\r\n");//$NON-NLS-1$ //$NON-NLS-2$	9941	runTest(codeFormatter, "test689", "A.java", CodeFormatter.K_UNKNOWN, 0, false, regions, "\r\n");//$NON-NLS-1$ //$NON-NLS-2$
		9942	*/
		9943	this.formatterPrefs.line_separator = "\r\n";//$NON-NLS-1$
		9944	String source =
		9945	"package pkg1;\n" +
		9946	"public class A {\n" +
		9947	"[# int i = 1; #] \n" +
		9948	"\n" +
		9949	"}\n";
		9950	// Note that whitespaces outside the region are kept after the formatting
		9951	// This is intentional since fix for bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=234583
		9952	// The formatter should not touch code outside the given region(s)...
		9953	formatSource(source,
		9954	"package pkg1;\n" +
		9955	"public class A {\n" +
		9956	" int i = 1; \n" +
		9957	"\n" +
		9958	"}\n",
		9959	CodeFormatter.K_UNKNOWN,
		9960	0 /no indentation/,
		9961	true /repeat formatting twice/
		9962	);
9717	}	9963	}
9718		9964
9719	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=208541	9965	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=208541
Lines 9810-9815 Link Here
9810		10056
9811	// variation on bugs 208541, 213283, 213284	10057	// variation on bugs 208541, 213283, 213284
9812	public void test697a() {	10058	public void test697a() {
		10059	/* old version
9813	final Map options = DefaultCodeFormatterConstants.getEclipseDefaultSettings();	10060	final Map options = DefaultCodeFormatterConstants.getEclipseDefaultSettings();
9814	DefaultCodeFormatterOptions preferences = new DefaultCodeFormatterOptions(options);	10061	DefaultCodeFormatterOptions preferences = new DefaultCodeFormatterOptions(options);
9815	preferences.line_separator = "\n";//$NON-NLS-1$	10062	preferences.line_separator = "\n";//$NON-NLS-1$
Lines 9818-9827 Link Here
9818	new Region(17, 55) // end of line selection	10065	new Region(17, 55) // end of line selection
9819	};	10066	};
9820	runTest(codeFormatter, "test697", "A.java", CodeFormatter.K_UNKNOWN, 0, false, regions, "\n");//$NON-NLS-1$ //$NON-NLS-2$	10067	runTest(codeFormatter, "test697", "A.java", CodeFormatter.K_UNKNOWN, 0, false, regions, "\n");//$NON-NLS-1$ //$NON-NLS-2$
		10068	*/
		10069	String source =
		10070	"public class A {\n" +
		10071	"[# \n" +
		10072	" \n" +
		10073	" \n" +
		10074	" int i = 1; #]\n" +
		10075	"\n" +
		10076	"\n" +
		10077	"\n" +
		10078	"}\n" +
		10079	"";
		10080	// Note that whitespaces outside the region are kept after the formatting
		10081	// This is intentional since fix for bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=234583
		10082	// The formatter should not touch code outside the given region(s)...
		10083	formatSource(source,
		10084	"public class A {\n" +
		10085	"\n" +
		10086	" int i = 1;\n" +
		10087	"\n" +
		10088	"\n" +
		10089	"\n" +
		10090	"}\n",
		10091	CodeFormatter.K_UNKNOWN,
		10092	0 /no indentation/,
		10093	true /repeat formatting twice/
		10094	);
9821	}	10095	}
9822		10096
9823	// variation on bugs 208541, 213283, 213284	10097	// variation on bugs 208541, 213283, 213284
9824	public void test697b() {	10098	public void test697b() {
		10099	/* old version
9825	final Map options = DefaultCodeFormatterConstants.getEclipseDefaultSettings();	10100	final Map options = DefaultCodeFormatterConstants.getEclipseDefaultSettings();
9826	DefaultCodeFormatterOptions preferences = new DefaultCodeFormatterOptions(options);	10101	DefaultCodeFormatterOptions preferences = new DefaultCodeFormatterOptions(options);
9827	preferences.line_separator = "\n";//$NON-NLS-1$	10102	preferences.line_separator = "\n";//$NON-NLS-1$
Lines 9830-9835 Link Here
9830	new Region(17, 56) // end of line selection + 1	10105	new Region(17, 56) // end of line selection + 1
9831	};	10106	};
9832	runTest(codeFormatter, "test697", "A.java", CodeFormatter.K_UNKNOWN, 0, false, regions, "\n");//$NON-NLS-1$ //$NON-NLS-2$	10107	runTest(codeFormatter, "test697", "A.java", CodeFormatter.K_UNKNOWN, 0, false, regions, "\n");//$NON-NLS-1$ //$NON-NLS-2$
		10108	*/
		10109	String source =
		10110	"public class A {\n" +
		10111	"[# \n" +
		10112	" \n" +
		10113	" \n" +
		10114	" int i = 1; \n" +
		10115	"#]\n" +
		10116	"\n" +
		10117	"\n" +
		10118	"}\n" +
		10119	"";
		10120	// Note that whitespaces outside the region are kept after the formatting
		10121	// This is intentional since fix for bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=234583
		10122	// The formatter should not touch code outside the given region(s)...
		10123	formatSource(source,
		10124	"public class A {\n" +
		10125	"\n" +
		10126	" int i = 1;\n" +
		10127	"\n" +
		10128	"\n" +
		10129	"}\n",
		10130	CodeFormatter.K_UNKNOWN,
		10131	0 /no indentation/,
		10132	true /repeat formatting twice/
		10133	);
9833	}	10134	}
9834		10135
9835	// variation on bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=208541	10136	// variation on bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=208541
Lines 10128-10136 Link Here
10128	String resourcePath = getResource("test713", "formatter.xml");	10429	String resourcePath = getResource("test713", "formatter.xml");
10129	Map options = DecodeCodeFormatterPreferences.decodeCodeFormatterOptions(resourcePath, "Dani");	10430	Map options = DecodeCodeFormatterPreferences.decodeCodeFormatterOptions(resourcePath, "Dani");
10130	assertNotNull("No preferences", options);	10431	assertNotNull("No preferences", options);
		10432	/* old version
10131	DefaultCodeFormatterOptions preferences = new DefaultCodeFormatterOptions(options);	10433	DefaultCodeFormatterOptions preferences = new DefaultCodeFormatterOptions(options);
10132	DefaultCodeFormatter codeFormatter = new DefaultCodeFormatter(preferences);	10434	DefaultCodeFormatter codeFormatter = new DefaultCodeFormatter(preferences);
10133	runTest(codeFormatter, "test713", "A.java", CodeFormatter.K_COMPILATION_UNIT, 0, false, 76, 27);//$NON-NLS-1$ //$NON-NLS-2$	10435	runTest(codeFormatter, "test713", "A.java", CodeFormatter.K_COMPILATION_UNIT, 0, false, 76, 27);//$NON-NLS-1$ //$NON-NLS-2$
		10436	*/
		10437	this.formatterPrefs = new DefaultCodeFormatterOptions(options);
		10438	String source =
		10439	"package pack;\n" +
		10440	"\n" +
		10441	"public class A {\n" +
		10442	" /**\n" +
		10443	" * @see A.Inner\n" +
		10444	" */\n" +
		10445	"[# public class Inner { }\n" +
		10446	"#]}";
		10447	formatSource(source,
		10448	"package pack;\n" +
		10449	"\n" +
		10450	"public class A {\n" +
		10451	" /**\n" +
		10452	" * @see A.Inner\n" +
		10453	" */\n" +
		10454	" public class Inner {\n" +
		10455	" }\n" +
		10456	"}"
		10457	);
10134	}	10458	}
10135		10459
10136	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=102780	10460	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=102780

Lines 51-60 Link Here

(-)src/org/eclipse/jdt/core/tests/formatter/FormatterCommentsClearBlankLinesTests.java (-4 / +4 lines)
51	}	51	}
52		52
53	DefaultCodeFormatter codeFormatter() {	53	DefaultCodeFormatter codeFormatter() {
54	this.preferences.comment_clear_blank_lines_in_block_comment = true;	54	this.formatterPrefs.comment_clear_blank_lines_in_block_comment = true;
55	this.preferences.comment_clear_blank_lines_in_javadoc_comment = true;	55	this.formatterPrefs.comment_clear_blank_lines_in_javadoc_comment = true;
56	this.preferences.comment_format_header = true;	56	this.formatterPrefs.comment_format_header = true;
57	DefaultCodeFormatter codeFormatter = new DefaultCodeFormatter(this.preferences);	57	DefaultCodeFormatter codeFormatter = new DefaultCodeFormatter(this.formatterPrefs);
58	return codeFormatter;	58	return codeFormatter;
59	}	59	}
60		60

Lines 50-57 Link Here

(-)src/org/eclipse/jdt/core/tests/formatter/FormatterJavadocDontIndentTagsTests.java (-2 / +2 lines)
50	}	50	}
51		51
52	DefaultCodeFormatter codeFormatter() {	52	DefaultCodeFormatter codeFormatter() {
53	this.preferences.comment_indent_root_tags = false; // Eclipse default is true	53	this.formatterPrefs.comment_indent_root_tags = false; // Eclipse default is true
54	DefaultCodeFormatter codeFormatter = new DefaultCodeFormatter(this.preferences);	54	DefaultCodeFormatter codeFormatter = new DefaultCodeFormatter(this.formatterPrefs);
55	return codeFormatter;	55	return codeFormatter;
56	}	56	}
57		57




import org.eclipse.jdt.internal.core.util.CodeSnippetParsingUtil;
import org.eclipse.jdt.internal.core.util.SimpleDocument;
import org.eclipse.jdt.internal.formatter.DefaultCodeFormatter;
import org.eclipse.jdt.internal.formatter.DefaultCodeFormatterOptions;
import org.eclipse.jface.text.IRegion;
import org.eclipse.jface.text.Region;

/**
 * Javadoc formatter test suite using the Eclipse default settings.


	public static List ALL_TEST_SUITES = null;

	DefaultCodeFormatterOptions preferences;

public static Test suite() {
	return buildModelTestSuite(FormatterCommentsTests.class);
}

public FormatterCommentsTests(String name) {
	super(name);
}
protected void setUp() throws Exception {
    super.setUp();
	this.preferences = DefaultCodeFormatterOptions.getEclipseDefaultSettings();
}

/**
 * Create project and set the jar placeholder.

	}
}

DefaultCodeFormatter codeFormatter() {
	DefaultCodeFormatter codeFormatter = new DefaultCodeFormatter(this.preferences, JAVA_PROJECT.getOptions(true));
	return codeFormatter;
}

/* (non-Javadoc)
 * @see org.eclipse.jdt.core.tests.formatter.FormatterRegressionTests#assertLineEquals(java.lang.String, java.lang.String, java.lang.String, boolean)
 */
void assertLineEquals(String actualContents, String originalSource, String expectedContents, boolean checkNull) {
	String outputSource = expectedContents == null ? originalSource : expectedContents;
	super.assertLineEquals(actualContents, originalSource, outputSource, checkNull);
}

void formatSource(String source, String formattedOutput) {
	formatSource(source, formattedOutput, CodeFormatter.K_COMPILATION_UNIT | CodeFormatter.F_INCLUDE_COMMENTS, 0, true /*repeat formatting twice*/);
}

void formatSource(String source, String formattedOutput, boolean repeat) {
	formatSource(source, formattedOutput, CodeFormatter.K_COMPILATION_UNIT | CodeFormatter.F_INCLUDE_COMMENTS, 0, repeat);
}

void formatSource(String source, String formattedOutput, int kind, int indentationLevel, boolean repeat) {
	int regionStart = source.indexOf("[#");
	if (regionStart != -1) {
		IRegion[] regions =  new Region[10];
		int idx = 0;
		int start = 0;
		int delta = 0;
		StringBuffer buffer = new StringBuffer();
		while (regionStart != -1) {
			buffer.append(source.substring(start, regionStart));
			int regionEnd = source.indexOf("#]", regionStart+2);
			buffer.append(source.substring(regionStart+2, regionEnd));
			regions[idx++] = new Region(regionStart-delta, regionEnd-(regionStart+2));
			delta += 4;
			start = regionEnd + 2;
			regionStart = source.indexOf("[#", start);
		}
		buffer.append(source.substring(start, source.length()));
		String newSource = buffer.toString();
		String result;
		if (idx == 1) {
			// Use offset and length until bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=233967 is fixed
			result = runFormatter(codeFormatter(), newSource, kind, indentationLevel, regions[0].getOffset(), regions[0].getLength(), Util.LINE_SEPARATOR, repeat);
		} else {
			System.arraycopy(regions, 0, regions = new Region[idx], 0, idx);
			result = runFormatter(codeFormatter(), newSource, kind, indentationLevel, regions, Util.LINE_SEPARATOR);
		}
		assertLineEquals(result, newSource, formattedOutput, false);
	} else {
		formatSource(source, formattedOutput, kind, indentationLevel, false, 0, -1, null, repeat);
	}
}

void formatSource(String source, String formattedOutput, int kind, int indentationLevel, boolean checkNull, int offset, int length, String lineSeparator, boolean repeat) {
	DefaultCodeFormatter codeFormatter = codeFormatter();
	String result;
	if (length == -1) {
		result = runFormatter(codeFormatter, source, kind, indentationLevel, offset, source.length(), lineSeparator, repeat);
	} else {
		result = runFormatter(codeFormatter, source, kind, indentationLevel, offset, length, lineSeparator, repeat);
	}
	assertLineEquals(result, source, formattedOutput, checkNull);
}

void compareFormattedSource(ICompilationUnit compilationUnit) throws JavaModelException {
	DefaultCodeFormatter codeFormatter = codeFormatter();
	String source = compilationUnit.getSource();

}
// TODO Pass this test
public void _testLineComments11() throws JavaModelException {
	this.formatterPrefs.comment_line_length = 40;
	formatUnit("comments.line", "X11.java");
}


Lines 50-57 Link Here

(-)src/org/eclipse/jdt/core/tests/formatter/FormatterJavadocDontIndentTagsDescriptionTests.java (-2 / +2 lines)
50	}	50	}
51		51
52	DefaultCodeFormatter codeFormatter() {	52	DefaultCodeFormatter codeFormatter() {
53	this.preferences.comment_indent_parameter_description = false; // Eclipse default is true	53	this.formatterPrefs.comment_indent_parameter_description = false; // Eclipse default is true
54	DefaultCodeFormatter codeFormatter = new DefaultCodeFormatter(this.preferences);	54	DefaultCodeFormatter codeFormatter = new DefaultCodeFormatter(this.formatterPrefs);
55	return codeFormatter;	55	return codeFormatter;
56	}	56	}
57		57




			if (index >= 0) {
				// the offset of the region is inside a comment => restart the region from the comment start
				adaptedOffset = this.commentPositions[index][0];
				if (adaptedOffset >= 0) {
					// adapt only javadoc or block commments. Since fix for bug
					// https://bugs.eclipse.org/bugs/show_bug.cgi?id=238210
					// edits in line comments only concerns whitespaces hence can be
					// treated as edits in code
					adaptedLength = length + offset - adaptedOffset;
					commentIndex = index;
					// include also the indentation edit just before the comment if any
					for (int j=0; j<this.editsIndex; j++) {
						int editOffset = this.edits[j].offset;
						int editEnd = editOffset + this.edits[j].length;
						if (editEnd == adaptedOffset) {
							if (j > 0 && this.edits[j].replacement.trim().length() == 0) {
								adaptedLength += adaptedOffset - this.edits[j].offset;
								adaptedOffset = editOffset;
								break;
							}
						} else if (editEnd > adaptedOffset) {
							break;
						}
					} else if (editEnd > adaptedOffset) {
						break;
					}
				}
			}
			index = getCommentIndex(commentIndex, offset+length-1);
			if (index >= 0 && this.commentPositions[index][0] >= 0) { // only javadoc or block comment
				// the region end is inside a comment => set the region end at the comment end
				int commentEnd = this.commentPositions[index][1];
				if (commentEnd < 0) commentEnd = -commentEnd;

			if (adaptedLength != length) {
				// adapt the region and jump to next one
				this.adaptedRegions[i] = new Region(adaptedOffset, adaptedLength);
			} else {
				this.adaptedRegions[i] = aRegion;
			}
		}
	}

	/*
	 * Adapt edits to regions.
	 * 
	 * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=234583"
	 * 	for more details
	 */
	private void adaptEdits() {

		// See if adapting edits is really necessary
		int max = this.regions.length;
		if (max == 1) {
			if (this.regions[0].getOffset() == 0 && this.regions[0].getLength() == this.scannerEndPosition) {
				// No need to adapt as the regions covers the whole source
				return;
			}
		}

		// Sort edits
		OptimizedReplaceEdit[] sortedEdits = new OptimizedReplaceEdit[this.editsIndex];
		System.arraycopy(this.edits, 0, sortedEdits, 0, this.editsIndex);
		Arrays.sort(sortedEdits, new Comparator() {
			public int compare(Object o1, Object o2) {
		    	OptimizedReplaceEdit edit1 = (OptimizedReplaceEdit) o1;
		    	OptimizedReplaceEdit edit2 = (OptimizedReplaceEdit) o2;
				return edit1.offset - edit2.offset;
            }
		});

		// Adapt overlapping edits
		int currentEdit = -1;
		for (int i = 0; i < max; i++) {
			IRegion region = this.adaptedRegions[i];
			int offset = region.getOffset();
			int length = region.getLength();

			// modify overlapping edits on the region (if any)
			int index = adaptEdit(sortedEdits, currentEdit, offset, offset+length);
			if (index != -1) {
				currentEdit = index;
			}
		}
	}

	/*
     * Search whether a region overlap edit(s) at its start and/or at its end.
     * If so, modify the concerned edits to keep only the modifications which are
     * inside the given region.
     * 
     * The edit modification is done as follow:
     * 1) start it from the region start if it overlaps the region's start
     * 2) end it at the region end if it overlaps the region's end
     * 3) remove from the replacement string the number of lines which are outside
     * the region: before when overlapping region's start and after when overlapping
     * region's end. Note that the trailing indentation of the replacement string is not
     * kept when the region's end is overlapped because it's always outside the
     * region.
     */
    private int adaptEdit(OptimizedReplaceEdit[] sortedEdits, int start, int regionStart, int regionEnd) {
    	int bottom = start==-1?0:start, top = sortedEdits.length - 1;
    	int topEnd = top;
    	int i = 0;
    	OptimizedReplaceEdit edit = null;
    	int overlapIndex = -1;
        int linesOutside= -1;
    	
    	// Look for an edit overlapping the region start 
    	while (bottom <= top) {
    		i = bottom + (top - bottom) /2;
    		edit = sortedEdits[i];
    		int editStart = edit.offset;
   			int editEnd = editStart + edit.length;
    		if (regionStart < editStart) {  // the edit starts after the region's start => no possible overlap of region's start
    			top = i-1;
    			if (regionEnd < editStart) { // the edit starts after the region's end => no possible overlap of region's end
    				topEnd = top;
    			}
    		} else {
    			if (regionStart >= editEnd) { // the edit ends before the region's start => no possible overlap of region's start
	    			bottom = i+1;
				} else {
					// Count the lines of the edit which are outside the region
					linesOutside = 0;
					this.scanner.resetTo(editStart, editEnd-1);
					while (!this.scanner.atEnd()) {
						boolean before = this.scanner.currentPosition < regionStart;
	                    char ch = (char) this.scanner.getNextChar();
                    	if (ch == '\n' ) {
                    		if (before) linesOutside++;
                    	}
                    }
					
					// Restart the edit at the beginning of the line where the region start
					edit.offset = regionStart;
					edit.length -= edit.offset - editStart;

					// Cut replacement string if necessary
					int length = edit.replacement.length();
					if (length > 0) {

						// Count the lines in replacement string
						int linesReplaced = 0;
						for (int idx=0; idx < length; idx++) {
							if (edit.replacement.charAt(idx) == '\n') linesReplaced++;
						}

						// As the edit starts outside the region, remove first lines from edit string if any
						if (linesReplaced > 0) {
					    	int linesCount = linesOutside >= linesReplaced ? linesReplaced : linesOutside;
					    	if (linesCount > 0) {
					    		int idx=0;
					    		while (idx < length) {
					    			char ch = edit.replacement.charAt(idx);
					    			if (ch == '\n') {
					    				linesCount--;
					    				if (linesCount == 0) {
					    					idx++;
					    					break;
					    				}
					    			}
					    			else if (ch != '\r') {
					    				break;
					    			}
					    			idx++;
					    		}
					    		if (idx >= length) {
					    			edit.replacement = ""; //$NON-NLS-1$
					    		} else {
					    			edit.replacement = edit.replacement.substring(idx);
					    		}
					    	}
						}
					}
					overlapIndex = i;
					break;
				}
			}
    	}
    	
    	// Look for an edit overlapping the region end 
    	if (overlapIndex != -1) bottom = overlapIndex;
    	while (bottom <= topEnd) {
    		i = bottom + (topEnd - bottom) /2;
    		edit = sortedEdits[i];
    		int editStart = edit.offset;
   			int editEnd = editStart + edit.length;
    		if (regionEnd < editStart) {	// the edit starts after the region's end => no possible overlap of region's end
    			topEnd = i-1;
    		} else {
    			if (regionEnd >= editEnd) {	// the edit ends before the region's end => no possible overlap of region's end
	    			bottom = i+1;
				} else {
					// Count the lines of the edit which are outside the region
					linesOutside = 0;
					this.scanner.resetTo(editStart, editEnd-1);
					while (!this.scanner.atEnd()) {
						boolean after = this.scanner.currentPosition >= regionEnd;
	                    char ch = (char) this.scanner.getNextChar();
                    	if (ch == '\n' ) {
                    		if (after) linesOutside++;
                    	}
                    }

					// Cut replacement string if necessary
					int length = edit.replacement.length();
					if (length > 0) {

						// Count the lines in replacement string
						int linesReplaced = 0;
						for (int idx=0; idx < length; idx++) {
							if (edit.replacement.charAt(idx) == '\n') linesReplaced++;
						}

						// Set the replacement string to the number of missing new lines
						// As the end of the edit is out of the region, the possible trailing
						// indentation should not be added...
						if (linesReplaced > 0) {
							int linesCount = linesReplaced > linesOutside ? linesReplaced - linesOutside : 0;
							if (linesCount == 0) {
				    			edit.replacement = ""; //$NON-NLS-1$
							} else {
								StringBuffer buffer = new StringBuffer();
								for (int j=0; j<linesCount; j++) {
									buffer.append(this.lineSeparator);
								if (this.scannerEndPosition == regionEnd) {
									lowerBound = this.scannerEndPosition - 1;
									break;
								}
								edit.replacement = buffer.toString();
							}
						}
					}
					edit.length -= editEnd - regionEnd;
					return i;
							this.adaptedRegions[i] = new Region(upperBound,
									lowerBound - upperBound);
						}
						// keep other unadaptable region
					} else {
						this.adaptedRegions[i] = this.regions[i];
					}
				} else {
					this.adaptedRegions[i] = this.regions[i];
				}
			} else {
				this.adaptedRegions[i] = this.regions[i];
			}
    	}
    	return overlapIndex;
    }

	private final void addDeleteEdit(int start, int end) {
		if (this.edits.length == this.editsIndex) {

	public TextEdit getRootEdit() {
		// https://bugs.eclipse.org/bugs/show_bug.cgi?id=208541
		adaptRegions();
		// https://bugs.eclipse.org/bugs/show_bug.cgi?id=234583
		adaptEdits();

		MultiTextEdit edit = null;
		int regionsLength = this.adaptedRegions.length;

		this.formatterCommentParser.parseHtmlTags = this.formatter.preferences.comment_format_html;
	}

	/**
	 * Returns whether the given region should be adpated of not.
	 * A region should be adapted only if:
	 * - region does not exceed the page width
	 * - on a single line when more than one line in CU
	 * @param offset the offset of the region to consider
	 * @param length the length of the region to consider
	 * @return boolean true if line should be adapted, false otherwhise
	 */
	private boolean isAdaptableRegion(int offset, int length) {
		int regionEnd = offset + length;

		// first check region width
		if (regionEnd > this.pageWidth) {
			return false;
		}

		int numberOfLineEnds = this.lineEnds != null && this.lineEnds.length > 0 ? this.lineEnds.length : 0;
		if (this.line == numberOfLineEnds + 1) {
			// https://bugs.eclipse.org/bugs/show_bug.cgi?id=213283
			return true; // last line of the CU
		}

		if (this.line > 1 && numberOfLineEnds > 0) { // CU has more than one line
			// https://bugs.eclipse.org/bugs/show_bug.cgi?id=222182
			// take the max number of line ends as right bound when searching for line number
			int lineNumber = Util.getLineNumber(offset, this.lineEnds, 0, numberOfLineEnds);
			int lineEnd = getLineEnd(lineNumber);
			if (regionEnd > lineEnd) {
				// if more than one line selected, check whether selection is at line end
				for (int i = lineNumber + 1 ; i <=  numberOfLineEnds ; i++) {
					int nextLineEnd = getLineEnd(i);
					// accept both line ends and line starts
					if (regionEnd == nextLineEnd) {
						return length > 1; // except when formatting a single character
					} else if (regionEnd == lineEnd + 1 || regionEnd == nextLineEnd + 1) {
						return true;
					}
				}
				return false; // more than one line selected, no need to adapt region
			} else {
				if (this.scannerEndPosition - 1 == lineEnd) { // EOF reached?
					return false;
				}
				return true; // a single line was selected
			}
		}
		return false;
	}

	private boolean isOnFirstColumn(int start) {
		if (this.lineEnds == null) return start == 0;
		int index = Arrays.binarySearch(this.lineEnds, start);

Return to bug 234583

Lines 38-46 Link Here

(-)src/org/eclipse/jdt/core/tests/formatter/FormatterCommentsTests.java (-75 / +1 lines)
38	import org.eclipse.jdt.internal.core.util.CodeSnippetParsingUtil;	38	import org.eclipse.jdt.internal.core.util.CodeSnippetParsingUtil;
39	import org.eclipse.jdt.internal.core.util.SimpleDocument;	39	import org.eclipse.jdt.internal.core.util.SimpleDocument;
40	import org.eclipse.jdt.internal.formatter.DefaultCodeFormatter;	40	import org.eclipse.jdt.internal.formatter.DefaultCodeFormatter;
41	import org.eclipse.jdt.internal.formatter.DefaultCodeFormatterOptions;
42	import org.eclipse.jface.text.IRegion;
43	import org.eclipse.jface.text.Region;
44		41
45	/**	42	/**
46	* Javadoc formatter test suite using the Eclipse default settings.	43	* Javadoc formatter test suite using the Eclipse default settings.
Lines 59-66 Link Here
59		56
60	public static List ALL_TEST_SUITES = null;	57	public static List ALL_TEST_SUITES = null;
61		58
62	DefaultCodeFormatterOptions preferences;
63
64	public static Test suite() {	59	public static Test suite() {
65	return buildModelTestSuite(FormatterCommentsTests.class);	60	return buildModelTestSuite(FormatterCommentsTests.class);
66	}	61	}
Lines 68-77 Link Here
68	public FormatterCommentsTests(String name) {	63	public FormatterCommentsTests(String name) {
69	super(name);	64	super(name);
70	}	65	}
71	protected void setUp() throws Exception {
72	super.setUp();
73	this.preferences = DefaultCodeFormatterOptions.getEclipseDefaultSettings();
74	}
75		66
76	/**	67	/**
77	* Create project and set the jar placeholder.	68	* Create project and set the jar placeholder.
Lines 97-167 Link Here
97	}	88	}
98	}	89	}
99		90
100	DefaultCodeFormatter codeFormatter() {
101	DefaultCodeFormatter codeFormatter = new DefaultCodeFormatter(this.preferences, JAVA_PROJECT.getOptions(true));
102	return codeFormatter;
103	}
104
105	/* (non-Javadoc)
106	* @see org.eclipse.jdt.core.tests.formatter.FormatterRegressionTests#assertLineEquals(java.lang.String, java.lang.String, java.lang.String, boolean)
107	*/
108	void assertLineEquals(String actualContents, String originalSource, String expectedContents, boolean checkNull) {
109	String outputSource = expectedContents == null ? originalSource : expectedContents;
110	super.assertLineEquals(actualContents, originalSource, outputSource, checkNull);
111	}
112
113	void formatSource(String source, String formattedOutput) {
114	formatSource(source, formattedOutput, CodeFormatter.K_COMPILATION_UNIT \| CodeFormatter.F_INCLUDE_COMMENTS, 0, true /repeat formatting twice/);
115	}
116
117	void formatSource(String source, String formattedOutput, boolean repeat) {
118	formatSource(source, formattedOutput, CodeFormatter.K_COMPILATION_UNIT \| CodeFormatter.F_INCLUDE_COMMENTS, 0, repeat);
119	}
120
121	void formatSource(String source, String formattedOutput, int kind, int indentationLevel, boolean repeat) {
122	int regionStart = source.indexOf("[#");
123	if (regionStart != -1) {
124	IRegion[] regions = new Region[10];
125	int idx = 0;
126	int start = 0;
127	int delta = 0;
128	StringBuffer buffer = new StringBuffer();
129	while (regionStart != -1) {
130	buffer.append(source.substring(start, regionStart));
131	int regionEnd = source.indexOf("#]", regionStart+2);
132	buffer.append(source.substring(regionStart+2, regionEnd));
133	regions[idx++] = new Region(regionStart-delta, regionEnd-(regionStart+2));
134	delta += 4;
135	start = regionEnd + 2;
136	regionStart = source.indexOf("[#", start);
137	}
138	buffer.append(source.substring(start, source.length()));
139	String newSource = buffer.toString();
140	String result;
141	if (idx == 1) {
142	// Use offset and length until bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=233967 is fixed
143	result = runFormatter(codeFormatter(), newSource, kind, indentationLevel, regions[0].getOffset(), regions[0].getLength(), Util.LINE_SEPARATOR, repeat);
144	} else {
145	System.arraycopy(regions, 0, regions = new Region[idx], 0, idx);
146	result = runFormatter(codeFormatter(), newSource, kind, indentationLevel, regions, Util.LINE_SEPARATOR);
147	}
148	assertLineEquals(result, newSource, formattedOutput, false);
149	} else {
150	formatSource(source, formattedOutput, kind, indentationLevel, false, 0, -1, null, repeat);
151	}
152	}
153
154	void formatSource(String source, String formattedOutput, int kind, int indentationLevel, boolean checkNull, int offset, int length, String lineSeparator, boolean repeat) {
155	DefaultCodeFormatter codeFormatter = codeFormatter();
156	String result;
157	if (length == -1) {
158	result = runFormatter(codeFormatter, source, kind, indentationLevel, offset, source.length(), lineSeparator, repeat);
159	} else {
160	result = runFormatter(codeFormatter, source, kind, indentationLevel, offset, length, lineSeparator, repeat);
161	}
162	assertLineEquals(result, source, formattedOutput, checkNull);
163	}
164
165	void compareFormattedSource(ICompilationUnit compilationUnit) throws JavaModelException {	91	void compareFormattedSource(ICompilationUnit compilationUnit) throws JavaModelException {
166	DefaultCodeFormatter codeFormatter = codeFormatter();	92	DefaultCodeFormatter codeFormatter = codeFormatter();
167	String source = compilationUnit.getSource();	93	String source = compilationUnit.getSource();
Lines 849-855 Link Here
849	}	775	}
850	// TODO Pass this test	776	// TODO Pass this test
851	public void _testLineComments11() throws JavaModelException {	777	public void _testLineComments11() throws JavaModelException {
852	this.preferences.comment_line_length = 40;	778	this.formatterPrefs.comment_line_length = 40;
853	formatUnit("comments.line", "X11.java");	779	formatUnit("comments.line", "X11.java");
854	}	780	}
855		781

Lines 165-190 Link Here

(-)formatter/org/eclipse/jdt/internal/formatter/Scribe.java (-117 / +213 lines)
165	if (index >= 0) {	165	if (index >= 0) {
166	// the offset of the region is inside a comment => restart the region from the comment start	166	// the offset of the region is inside a comment => restart the region from the comment start
167	adaptedOffset = this.commentPositions[index][0];	167	adaptedOffset = this.commentPositions[index][0];
168	if (adaptedOffset < 0) adaptedOffset = -adaptedOffset;	168	if (adaptedOffset >= 0) {
169	adaptedLength = length + offset - adaptedOffset;	169	// adapt only javadoc or block commments. Since fix for bug
170	commentIndex = index;	170	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=238210
171	// include also the indentation edit just before the comment if any	171	// edits in line comments only concerns whitespaces hence can be
172	for (int j=0; j<this.editsIndex; j++) {	172	// treated as edits in code
173	int editOffset = this.edits[j].offset;	173	adaptedLength = length + offset - adaptedOffset;
174	int editEnd = editOffset + this.edits[j].length;	174	commentIndex = index;
175	if (editEnd == adaptedOffset) {	175	// include also the indentation edit just before the comment if any
176	if (j > 0 && this.edits[j].replacement.trim().length() == 0) {	176	for (int j=0; j<this.editsIndex; j++) {
177	adaptedLength += adaptedOffset - this.edits[j].offset;	177	int editOffset = this.edits[j].offset;
178	adaptedOffset = editOffset;	178	int editEnd = editOffset + this.edits[j].length;
		179	if (editEnd == adaptedOffset) {
		180	if (j > 0 && this.edits[j].replacement.trim().length() == 0) {
		181	adaptedLength += adaptedOffset - this.edits[j].offset;
		182	adaptedOffset = editOffset;
		183	break;
		184	}
		185	} else if (editEnd > adaptedOffset) {
179	break;	186	break;
180	}	187	}
181	} else if (editEnd > adaptedOffset) {
182	break;
183	}	188	}
184	}	189	}
185	}	190	}
186	index = getCommentIndex(commentIndex, offset+length-1);	191	index = getCommentIndex(commentIndex, offset+length-1);
187	if (index >= 0) {	192	if (index >= 0 && this.commentPositions[index][0] >= 0) { // only javadoc or block comment
188	// the region end is inside a comment => set the region end at the comment end	193	// the region end is inside a comment => set the region end at the comment end
189	int commentEnd = this.commentPositions[index][1];	194	int commentEnd = this.commentPositions[index][1];
190	if (commentEnd < 0) commentEnd = -commentEnd;	195	if (commentEnd < 0) commentEnd = -commentEnd;
Lines 194-261 Link Here
194	if (adaptedLength != length) {	199	if (adaptedLength != length) {
195	// adapt the region and jump to next one	200	// adapt the region and jump to next one
196	this.adaptedRegions[i] = new Region(adaptedOffset, adaptedLength);	201	this.adaptedRegions[i] = new Region(adaptedOffset, adaptedLength);
197	continue;	202	} else {
		203	this.adaptedRegions[i] = aRegion;
198	}	204	}
		205	}
		206	}
199		207
200	if (offset > 0) {	208	/*
201	if (isAdaptableRegion(offset, length)) {	209	* Adapt edits to regions.
202	// if we have a selection, search for overlapping edits	210	*
203	int upperBound = offset;	211	* @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=234583"
204	int lowerBound = 0;	212	* for more details
205	boolean upperFound = false;	213	*/
206	int regionEnd = offset + length;	214	private void adaptEdits() {
207	for (int j = 0, max2 = this.editsIndex - 1; j <= max2; j++) {	215
208	// search for lower bound	216	// See if adapting edits is really necessary
209	int editOffset = this.edits[j].offset;	217	int max = this.regions.length;
210	if (upperFound && lowerBound == 0) {	218	if (max == 1) {
211	int editLength = this.edits[j].length;	219	if (this.regions[0].getOffset() == 0 && this.regions[0].getLength() == this.scannerEndPosition) {
212	if (editOffset == regionEnd) { // matching edit found	220	// No need to adapt as the regions covers the whole source
213	lowerBound = regionEnd;	221	return;
214	break;	222	}
215	} else if (editOffset + editLength < regionEnd) {	223	}
216	continue;	224
217	} else {	225	// Sort edits
218	lowerBound = editOffset + editLength; // upper and lower bounds found	226	OptimizedReplaceEdit[] sortedEdits = new OptimizedReplaceEdit[this.editsIndex];
219	break;	227	System.arraycopy(this.edits, 0, sortedEdits, 0, this.editsIndex);
220	}	228	Arrays.sort(sortedEdits, new Comparator() {
221	// search for upper bound	229	public int compare(Object o1, Object o2) {
222	} else {	230	OptimizedReplaceEdit edit1 = (OptimizedReplaceEdit) o1;
223	int next = j+1;	231	OptimizedReplaceEdit edit2 = (OptimizedReplaceEdit) o2;
224	if (next == max2) {	232	return edit1.offset - edit2.offset;
225	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=213284	233	}
226	// checked all edits, no upper bound found: leave the loop	234	});
227	break;	235
228	}	236	// Adapt overlapping edits
229	if (this.edits[next].offset < offset) {	237	int currentEdit = -1;
230	continue;	238	for (int i = 0; i < max; i++) {
		239	IRegion region = this.adaptedRegions[i];
		240	int offset = region.getOffset();
		241	int length = region.getLength();
		242
		243	// modify overlapping edits on the region (if any)
		244	int index = adaptEdit(sortedEdits, currentEdit, offset, offset+length);
		245	if (index != -1) {
		246	currentEdit = index;
		247	}
		248	}
		249	}
		250
		251	/*
		252	* Search whether a region overlap edit(s) at its start and/or at its end.
		253	* If so, modify the concerned edits to keep only the modifications which are
		254	* inside the given region.
		255	*
		256	* The edit modification is done as follow:
		257	* 1) start it from the region start if it overlaps the region's start
		258	* 2) end it at the region end if it overlaps the region's end
		259	* 3) remove from the replacement string the number of lines which are outside
		260	* the region: before when overlapping region's start and after when overlapping
		261	* region's end. Note that the trailing indentation of the replacement string is not
		262	* kept when the region's end is overlapped because it's always outside the
		263	* region.
		264	*/
		265	private int adaptEdit(OptimizedReplaceEdit[] sortedEdits, int start, int regionStart, int regionEnd) {
		266	int bottom = start==-1?0:start, top = sortedEdits.length - 1;
		267	int topEnd = top;
		268	int i = 0;
		269	OptimizedReplaceEdit edit = null;
		270	int overlapIndex = -1;
		271	int linesOutside= -1;
		272
		273	// Look for an edit overlapping the region start
		274	while (bottom <= top) {
		275	i = bottom + (top - bottom) /2;
		276	edit = sortedEdits[i];
		277	int editStart = edit.offset;
		278	int editEnd = editStart + edit.length;
		279	if (regionStart < editStart) { // the edit starts after the region's start => no possible overlap of region's start
		280	top = i-1;
		281	if (regionEnd < editStart) { // the edit starts after the region's end => no possible overlap of region's end
		282	topEnd = top;
		283	}
		284	} else {
		285	if (regionStart >= editEnd) { // the edit ends before the region's start => no possible overlap of region's start
		286	bottom = i+1;
		287	} else {
		288	// Count the lines of the edit which are outside the region
		289	linesOutside = 0;
		290	this.scanner.resetTo(editStart, editEnd-1);
		291	while (!this.scanner.atEnd()) {
		292	boolean before = this.scanner.currentPosition < regionStart;
		293	char ch = (char) this.scanner.getNextChar();
		294	if (ch == '\n' ) {
		295	if (before) linesOutside++;
		296	}
		297	}
		298
		299	// Restart the edit at the beginning of the line where the region start
		300	edit.offset = regionStart;
		301	edit.length -= edit.offset - editStart;
		302
303	// Cut replacement string if necessary
304	int length = edit.replacement.length();
305	if (length > 0) {
306
307	// Count the lines in replacement string
308	int linesReplaced = 0;
309	for (int idx=0; idx < length; idx++) {
310	if (edit.replacement.charAt(idx) == '\n') linesReplaced++;
311	}
312
313	// As the edit starts outside the region, remove first lines from edit string if any
314	if (linesReplaced > 0) {
315	int linesCount = linesOutside >= linesReplaced ? linesReplaced : linesOutside;
316	if (linesCount > 0) {
317	int idx=0;
318	while (idx < length) {
319	char ch = edit.replacement.charAt(idx);
320	if (ch == '\n') {
321	linesCount--;
322	if (linesCount == 0) {
323	idx++;
324	break;
325	}
326	}
327	else if (ch != '\r') {
328	break;
329	}
330	idx++;
331	}
332	if (idx >= length) {
333	edit.replacement = ""; //$NON-NLS-1$
334	} else {
335	edit.replacement = edit.replacement.substring(idx);
336	}
337	}
338	}
339	}
340	overlapIndex = i;
341	break;
342	}
343	}
344	}
345
346	// Look for an edit overlapping the region end
347	if (overlapIndex != -1) bottom = overlapIndex;
348	while (bottom <= topEnd) {
349	i = bottom + (topEnd - bottom) /2;
350	edit = sortedEdits[i];
351	int editStart = edit.offset;
352	int editEnd = editStart + edit.length;
353	if (regionEnd < editStart) { // the edit starts after the region's end => no possible overlap of region's end
354	topEnd = i-1;
355	} else {
356	if (regionEnd >= editEnd) { // the edit ends before the region's end => no possible overlap of region's end
357	bottom = i+1;
358	} else {
359	// Count the lines of the edit which are outside the region
360	linesOutside = 0;
361	this.scanner.resetTo(editStart, editEnd-1);
362	while (!this.scanner.atEnd()) {
363	boolean after = this.scanner.currentPosition >= regionEnd;
364	char ch = (char) this.scanner.getNextChar();
365	if (ch == '\n' ) {
366	if (after) linesOutside++;
367	}
368	}
369
370	// Cut replacement string if necessary
371	int length = edit.replacement.length();
372	if (length > 0) {
373
374	// Count the lines in replacement string
375	int linesReplaced = 0;
376	for (int idx=0; idx < length; idx++) {
377	if (edit.replacement.charAt(idx) == '\n') linesReplaced++;
378	}
379
380	// Set the replacement string to the number of missing new lines
381	// As the end of the edit is out of the region, the possible trailing
382	// indentation should not be added...
383	if (linesReplaced > 0) {
384	int linesCount = linesReplaced > linesOutside ? linesReplaced - linesOutside : 0;
385	if (linesCount == 0) {
386	edit.replacement = ""; //$NON-NLS-1$
231	} else {	387	} else {
232	upperBound = editOffset;	388	StringBuffer buffer = new StringBuffer();
233	upperFound = true;	389	for (int j=0; j<linesCount; j++) {
234	// verify if region end is at EOF	390	buffer.append(this.lineSeparator);
235	if (this.scannerEndPosition == regionEnd) {
236	lowerBound = this.scannerEndPosition - 1;
237	break;
238	}	391	}
		392	edit.replacement = buffer.toString();
239	}	393	}
240	}	394	}
241	}	395	}
242	if (lowerBound != 0) {	396	edit.length -= editEnd - regionEnd;
243	if (offset != upperBound \|\| regionEnd != lowerBound) { // ensure we found a different region	397	return i;
244	this.adaptedRegions[i] = new Region(upperBound,
245	lowerBound - upperBound);
246	}
247	// keep other unadaptable region
248	} else {
249	this.adaptedRegions[i] = this.regions[i];
250	}
251	} else {
252	this.adaptedRegions[i] = this.regions[i];
253	}	398	}
254	} else {
255	this.adaptedRegions[i] = this.regions[i];
256	}	399	}
257	}	400	}
258	}	401	return overlapIndex;
		402	}
259		403
260	private final void addDeleteEdit(int start, int end) {	404	private final void addDeleteEdit(int start, int end) {
261	if (this.edits.length == this.editsIndex) {	405	if (this.edits.length == this.editsIndex) {
Lines 805-810 Link Here
805	public TextEdit getRootEdit() {	949	public TextEdit getRootEdit() {
806	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=208541	950	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=208541
807	adaptRegions();	951	adaptRegions();
		952	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=234583
		953	adaptEdits();
808		954
809	MultiTextEdit edit = null;	955	MultiTextEdit edit = null;
810	int regionsLength = this.adaptedRegions.length;	956	int regionsLength = this.adaptedRegions.length;
Lines 952-1007 Link Here
952	this.formatterCommentParser.parseHtmlTags = this.formatter.preferences.comment_format_html;	1098	this.formatterCommentParser.parseHtmlTags = this.formatter.preferences.comment_format_html;
953	}	1099	}
954		1100
955	/**
956	* Returns whether the given region should be adpated of not.
957	* A region should be adapted only if:
958	* - region does not exceed the page width
959	* - on a single line when more than one line in CU
960	* @param offset the offset of the region to consider
961	* @param length the length of the region to consider
962	* @return boolean true if line should be adapted, false otherwhise
963	*/
964	private boolean isAdaptableRegion(int offset, int length) {
965	int regionEnd = offset + length;
966
967	// first check region width
968	if (regionEnd > this.pageWidth) {
969	return false;
970	}
971
972	int numberOfLineEnds = this.lineEnds != null && this.lineEnds.length > 0 ? this.lineEnds.length : 0;
973	if (this.line == numberOfLineEnds + 1) {
974	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=213283
975	return true; // last line of the CU
976	}
977
978	if (this.line > 1 && numberOfLineEnds > 0) { // CU has more than one line
979	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=222182
980	// take the max number of line ends as right bound when searching for line number
981	int lineNumber = Util.getLineNumber(offset, this.lineEnds, 0, numberOfLineEnds);
982	int lineEnd = getLineEnd(lineNumber);
983	if (regionEnd > lineEnd) {
984	// if more than one line selected, check whether selection is at line end
985	for (int i = lineNumber + 1 ; i <= numberOfLineEnds ; i++) {
986	int nextLineEnd = getLineEnd(i);
987	// accept both line ends and line starts
988	if (regionEnd == nextLineEnd) {
989	return length > 1; // except when formatting a single character
990	} else if (regionEnd == lineEnd + 1 \|\| regionEnd == nextLineEnd + 1) {
991	return true;
992	}
993	}
994	return false; // more than one line selected, no need to adapt region
995	} else {
996	if (this.scannerEndPosition - 1 == lineEnd) { // EOF reached?
997	return false;
998	}
999	return true; // a single line was selected
1000	}
1001	}
1002	return false;
1003	}
1004
1005	private boolean isOnFirstColumn(int start) {	1101	private boolean isOnFirstColumn(int start) {
1006	if (this.lineEnds == null) return start == 0;	1102	if (this.lineEnds == null) return start == 0;
1007	int index = Arrays.binarySearch(this.lineEnds, start);	1103	int index = Arrays.binarySearch(this.lineEnds, start);