diff --git a/RSyntaxTextArea/src/main/java/org/fife/ui/rsyntaxtextarea/AbstractJFlexCTokenMaker.java b/RSyntaxTextArea/src/main/java/org/fife/ui/rsyntaxtextarea/AbstractJFlexCTokenMaker.java
index 9879d0c09..1ebf5052a 100755
--- a/RSyntaxTextArea/src/main/java/org/fife/ui/rsyntaxtextarea/AbstractJFlexCTokenMaker.java
+++ b/RSyntaxTextArea/src/main/java/org/fife/ui/rsyntaxtextarea/AbstractJFlexCTokenMaker.java
@@ -176,7 +176,7 @@ private boolean appearsNested(RSyntaxTextArea textArea,
 
 			while (line<textArea.getLineCount()) {
 				Token t = textArea.getTokenListForLine(line);
-				int i = 0;
+				int i;
 				// If examining the first line, start at offs.
 				if (line++==firstLine) {
 					t = RSyntaxUtilities.getTokenAtOffset(t, offs);
@@ -265,7 +265,7 @@ private void insertBreakInMLC(ActionEvent e, RSyntaxTextArea textArea,
 				textArea.replaceSelection("\n" + header);
 				if (nested) {
 					dot = textArea.getCaretPosition(); // Has changed
-					textArea.insert("\n" + leadingWS + " */", dot);
+					textArea.insert("\n" + leadingWS + (firstMlcLine ? " " : "") + "*/", dot);
 					textArea.setCaretPosition(dot);
 				}
 
diff --git a/RSyntaxTextArea/src/main/java/org/fife/ui/rsyntaxtextarea/RSyntaxTextAreaEditorKit.java b/RSyntaxTextArea/src/main/java/org/fife/ui/rsyntaxtextarea/RSyntaxTextAreaEditorKit.java
index d93aa5356..bcf503ce1 100755
--- a/RSyntaxTextArea/src/main/java/org/fife/ui/rsyntaxtextarea/RSyntaxTextAreaEditorKit.java
+++ b/RSyntaxTextArea/src/main/java/org/fife/ui/rsyntaxtextarea/RSyntaxTextAreaEditorKit.java
@@ -1533,77 +1533,71 @@ else if (ch=='}') {
 		 */
 		protected void handleInsertBreak(RSyntaxTextArea textArea,
 										boolean noSelection) {
-			// If we're auto-indenting...
-			if (noSelection && textArea.isAutoIndentEnabled()) {
-				insertNewlineWithAutoIndent(textArea);
+
+			if (noSelection) {
+				try {
+					handleInsertBreakWithoutSelection(textArea);
+				} catch (BadLocationException ble) { // Never happens
+					textArea.replaceSelection("\n");
+					ble.printStackTrace();
+				}
 			}
 			else {
 				textArea.replaceSelection("\n");
-				if (noSelection) {
-					possiblyCloseCurlyBrace(textArea, null);
-				}
 			}
 		}
 
-		private void insertNewlineWithAutoIndent(RSyntaxTextArea sta) {
-
-			try {
+		private void handleInsertBreakWithoutSelection(RSyntaxTextArea textArea)
+				throws BadLocationException {
 
-				int caretPos = sta.getCaretPosition();
-				Document doc = sta.getDocument();
-				Element map = doc.getDefaultRootElement();
-				int lineNum = map.getElementIndex(caretPos);
-				Element line = map.getElement(lineNum);
-				int start = line.getStartOffset();
-				int end = line.getEndOffset()-1; // Why always "-1"?
-				int len = end-start;
-				String s = doc.getText(start, len);
-
-				// endWS is the end of the leading whitespace of the
-				// current line.
-				String leadingWS = RSyntaxUtilities.getLeadingWhitespace(s);
-				StringBuilder sb = new StringBuilder("\n");
+			int caretPos = textArea.getCaretPosition();
+			Document doc = textArea.getDocument();
+			Element map = doc.getDefaultRootElement();
+			int lineNum = map.getElementIndex(caretPos);
+			Element line = map.getElement(lineNum);
+			int start = line.getStartOffset();
+			int end = line.getEndOffset()-1; // Why always "-1"?
+			int len = end-start;
+			String s = doc.getText(start, len);
+			int caretOffsInLine = caretPos - start;
+
+			StringBuilder sb = new StringBuilder("\n");
+			String leadingWS = null;
+			if (textArea.isAutoIndentEnabled()) {
+				leadingWS = RSyntaxUtilities.getLeadingWhitespace(s, caretOffsInLine);
 				sb.append(leadingWS);
+			}
 
-				// If there is only whitespace between the caret and
-				// the EOL, pressing Enter auto-indents the new line to
-				// the same place as the previous line.
-				int nonWhitespacePos = atEndOfLine(caretPos-start, s, len);
-				if (nonWhitespacePos==-1) {
-					if (leadingWS.length()==len &&
-							sta.isClearWhitespaceLinesEnabled()) {
-						// If the line was nothing but whitespace, select it
-						// so its contents get removed.
-						sta.setSelectionStart(start);
-						sta.setSelectionEnd(end);
-					}
-					sta.replaceSelection(sb.toString());
-				}
+			// If the text remaining on the line would be all whitespace,
+			// remove it if necessary
+			if (textArea.isClearWhitespaceLinesEnabled() && isAllWhitespace(s, 0, caretOffsInLine)) {
+				// Select all text on the line before the caret so it gets removed
+				textArea.setCaretPosition(start);
+			}
 
-				// If there is non-whitespace between the caret and the
-				// EOL, pressing Enter takes that text to the next line
-				// and auto-indents it to the same place as the last
-				// line.
-				else {
-					sb.append(s.substring(nonWhitespacePos));
-					sta.replaceRange(sb.toString(), caretPos, end);
-					sta.setCaretPosition(caretPos + leadingWS.length()+1);
-				}
+			// Find any non-whitespace text after the caret. If there is any, it gets put
+			// onto the next line. Whitespace between the caret and that text gets removed.
+			int nonWhitespacePos = atEndOfLine(caretPos-start, s, len);
+			textArea.moveCaretPosition(nonWhitespacePos > -1 ? nonWhitespacePos : end);
+			textArea.replaceSelection(sb.toString());
 
-				// Must do it after everything else, as the "smart indent"
-				// calculation depends on the previous line's state
-				// AFTER the Enter press (stuff may have been moved down).
-				if (sta.getShouldIndentNextLine(lineNum)) {
-					sta.replaceSelection("\t");
-				}
+			// Must do it after everything else, as the "smart indent"
+			// calculation depends on the previous line's state
+			// AFTER the Enter press (stuff may have been moved down).
+			if (textArea.getShouldIndentNextLine(lineNum)) {
+				textArea.replaceSelection("\t");
+			}
 
-				possiblyCloseCurlyBrace(sta, leadingWS);
+			possiblyCloseCurlyBrace(textArea, leadingWS);
+		}
 
-			} catch (BadLocationException ble) { // Never happens
-				sta.replaceSelection("\n");
-				ble.printStackTrace();
+		private static boolean isAllWhitespace(String str, int from, int to) {
+			for (int i = from; i < to; i++) {
+				if (!Character.isWhitespace(str.charAt(i))) {
+					return false;
+				}
 			}
-
+			return true;
 		}
 
 		private void possiblyCloseCurlyBrace(RSyntaxTextArea textArea,
diff --git a/RSyntaxTextArea/src/main/java/org/fife/ui/rsyntaxtextarea/RSyntaxUtilities.java b/RSyntaxTextArea/src/main/java/org/fife/ui/rsyntaxtextarea/RSyntaxUtilities.java
index 4e0f3e992..56bb7c483 100755
--- a/RSyntaxTextArea/src/main/java/org/fife/ui/rsyntaxtextarea/RSyntaxUtilities.java
+++ b/RSyntaxTextArea/src/main/java/org/fife/ui/rsyntaxtextarea/RSyntaxUtilities.java
@@ -251,11 +251,25 @@ public static Color getHyperlinkForeground() {
 	 *
 	 * @param text The String to check.
 	 * @return The leading whitespace.
+	 * @see #getLeadingWhitespace(String, int)
 	 * @see #getLeadingWhitespace(Document, int)
 	 */
 	public static String getLeadingWhitespace(String text) {
+		return getLeadingWhitespace(text, Integer.MAX_VALUE);
+	}
+
+
+	/**
+	 * Returns the leading whitespace of a string.
+	 *
+	 * @param text The String to check.
+	 * @param upTo Stops checking at the specified offset.
+	 * @return The leading whitespace.
+	 * @see #getLeadingWhitespace(String)
+	 */
+	public static String getLeadingWhitespace(String text, int upTo) {
 		int count = 0;
-		int len = text.length();
+		int len = Math.min(text.length(), upTo);
 		while (count<len && RSyntaxUtilities.isWhitespace(text.charAt(count))) {
 			count++;
 		}
diff --git a/RSyntaxTextArea/src/test/java/org/fife/ui/rsyntaxtextarea/RSyntaxTextAreaEditorKitInsertBreakActionTest.java b/RSyntaxTextArea/src/test/java/org/fife/ui/rsyntaxtextarea/RSyntaxTextAreaEditorKitInsertBreakActionTest.java
index 45a3585df..d7c6d73da 100644
--- a/RSyntaxTextArea/src/test/java/org/fife/ui/rsyntaxtextarea/RSyntaxTextAreaEditorKitInsertBreakActionTest.java
+++ b/RSyntaxTextArea/src/test/java/org/fife/ui/rsyntaxtextarea/RSyntaxTextAreaEditorKitInsertBreakActionTest.java
@@ -8,7 +8,6 @@
 
 import org.fife.ui.SwingRunnerExtension;
 import org.fife.ui.rtextarea.RTextArea;
-import org.fife.ui.rtextarea.RTextAreaEditorKit;
 import org.fife.ui.rtextarea.RecordableTextAction;
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
@@ -27,7 +26,7 @@
 class RSyntaxTextAreaEditorKitInsertBreakActionTest extends AbstractRSyntaxTextAreaTest {
 
 	@Test
-	void testActionPerformedImpl_notEditable() {
+	void test_notEditable() {
 
 		RTextArea textArea = new RTextArea("hello world");
 		textArea.setCaretPosition(textArea.getText().indexOf(' '));
@@ -40,7 +39,7 @@ void testActionPerformedImpl_notEditable() {
 	}
 
 	@Test
-	void testActionPerformedImpl_notEnabled() {
+	void test_notEnabled() {
 
 		RTextArea textArea = new RTextArea("hello world");
 		textArea.setCaretPosition(textArea.getText().indexOf(' '));
@@ -53,10 +52,77 @@ void testActionPerformedImpl_notEnabled() {
 	}
 
 	@Test
-	void testActionPerformedImpl_closingCurlyBraceAdded() {
+	void test_noSelection_defaults_caretAtEnd_withCurly_closingCurlyBraceAdded_tabs() {
 
-		String origContent = "public void foo() {";
+		String origContent = "  public void foo() {";
+		RSyntaxTextArea textArea = createTextArea(SyntaxConstants.SYNTAX_STYLE_JAVA, origContent);
+		textArea.setAutoIndentEnabled(true); // default
+		textArea.setClearWhitespaceLinesEnabled(true); // default
+
+		textArea.setCaretPosition(origContent.length());
+
+		RecordableTextAction a = new RSyntaxTextAreaEditorKit.InsertBreakAction();
+		ActionEvent e = createActionEvent(textArea, RSyntaxTextAreaEditorKit.insertBreakAction);
+		a.actionPerformedImpl(e, textArea);
+
+		// Both the new line and the closing curly's line are indented the same amount as
+		// the opening curly's line. Also the caret's line has an extra indentation (defaults
+		// to tab)
+		String expectedResultContent = origContent + "\n  \t\n  }\n";
+		Assertions.assertEquals(expectedResultContent, textArea.getText());
+		Assertions.assertEquals(origContent.length() + "\n  \t".length(), textArea.getCaretPosition());
+	}
+
+	@Test
+	void test_noSelection_defaults_caretAtEnd_withCurly_closingCurlyBraceAdded_spaces() {
+
+		String origContent = "  public void foo() {";
+		RSyntaxTextArea textArea = createTextArea(SyntaxConstants.SYNTAX_STYLE_JAVA, origContent);
+		textArea.setAutoIndentEnabled(true); // default
+		textArea.setClearWhitespaceLinesEnabled(true); // default
+		textArea.setTabsEmulated(true);
+		textArea.setTabSize(4);
+
+		textArea.setCaretPosition(origContent.length());
+
+		RecordableTextAction a = new RSyntaxTextAreaEditorKit.InsertBreakAction();
+		ActionEvent e = createActionEvent(textArea, RSyntaxTextAreaEditorKit.insertBreakAction);
+		a.actionPerformedImpl(e, textArea);
+
+		// The new line with the caret is indented to the next "real" indentation offset, in this case, 4.
+		// The closing curly is indented to match the indentation of the opening curly's line
+		String expectedResultContent = origContent + "\n    \n  }\n";
+		Assertions.assertEquals(expectedResultContent, textArea.getText());
+		Assertions.assertEquals(origContent.length() + "\n    ".length(), textArea.getCaretPosition());
+	}
+
+	@Test
+	void test_noSelection_defaults_caretAtEnd_withCurlyPair_indentPreserved() {
+
+		String origContent = "  public void foo() { doSomething(); }";
+		RSyntaxTextArea textArea = createTextArea(SyntaxConstants.SYNTAX_STYLE_JAVA, origContent);
+		textArea.setAutoIndentEnabled(true); // default
+		textArea.setClearWhitespaceLinesEnabled(true); // default
+
+		textArea.setCaretPosition(origContent.length());
+
+		RecordableTextAction a = new RSyntaxTextAreaEditorKit.InsertBreakAction();
+		ActionEvent e = createActionEvent(textArea, RSyntaxTextAreaEditorKit.insertBreakAction);
+		a.actionPerformedImpl(e, textArea);
+
+		// Since the opening curly was paired on the same line, we just indent to the same level
+		String expectedResultContent = origContent + "\n  ";
+		Assertions.assertEquals(expectedResultContent, textArea.getText());
+		Assertions.assertEquals(origContent.length() + "\n  ".length(), textArea.getCaretPosition());
+	}
+
+	@Test
+	void test_noSelection_defaults_caretAtEnd_withCurlyPairsButOneUnclosed_nextLineIndented() {
+
+		String origContent = "  public void foo() { doSomething(); } {";
 		RSyntaxTextArea textArea = createTextArea(SyntaxConstants.SYNTAX_STYLE_JAVA, origContent);
+		textArea.setAutoIndentEnabled(true); // default
+		textArea.setClearWhitespaceLinesEnabled(true); // default
 
 		textArea.setCaretPosition(origContent.length());
 
@@ -64,15 +130,20 @@ void testActionPerformedImpl_closingCurlyBraceAdded() {
 		ActionEvent e = createActionEvent(textArea, RSyntaxTextAreaEditorKit.insertBreakAction);
 		a.actionPerformedImpl(e, textArea);
 
-		String expectedResultContent = origContent + "\n\t\n}\n";
+		// Since there was an unpaired opening curly, the next line is indented and a closing curly
+		// is added on another new line
+		String expectedResultContent = origContent + "\n  \t\n  }\n";
 		Assertions.assertEquals(expectedResultContent, textArea.getText());
+		Assertions.assertEquals(origContent.length() + "\n  \t".length(), textArea.getCaretPosition());
 	}
 
 	@Test
-	void testActionPerformedImpl_allWhiteSpaceLineCleared() {
+	void test_noSelection_defaults_allWSLine_caretAtEnd_allWSLineCleared() {
 
 		String origContent = "public void foo() {\n\t";
 		RSyntaxTextArea textArea = createTextArea(SyntaxConstants.SYNTAX_STYLE_JAVA, origContent);
+		textArea.setAutoIndentEnabled(true); // default
+		textArea.setClearWhitespaceLinesEnabled(true); // default
 
 		textArea.setCaretPosition(origContent.length());
 
@@ -80,16 +151,253 @@ void testActionPerformedImpl_allWhiteSpaceLineCleared() {
 		ActionEvent e = createActionEvent(textArea, RSyntaxTextAreaEditorKit.insertBreakAction);
 		a.actionPerformedImpl(e, textArea);
 
+		// The line the caret was on loses the '\t' character to become blank, and the new line
+		// is indented
+		String expectedResultContent = "public void foo() {\n\n\t";
+		Assertions.assertEquals(expectedResultContent, textArea.getText());
+		Assertions.assertEquals(expectedResultContent.length(), textArea.getCaretPosition());
+	}
+
+	@Test
+	void test_noSelection_defaults_allWSLine_caretInMiddle_wsLineClearedAndWSAfterCaretRemoved() {
+
+		String origContent = "public void foo() {\n\t   ";
+		RSyntaxTextArea textArea = createTextArea(SyntaxConstants.SYNTAX_STYLE_JAVA, origContent);
+		textArea.setAutoIndentEnabled(true); // default
+		textArea.setClearWhitespaceLinesEnabled(true); // default
+
+		// Caret is after the '\t' character in the "\t   " line - whitespace before and after it
+		textArea.setCaretPosition(origContent.length() - 3);
+
+		RecordableTextAction a = new RSyntaxTextAreaEditorKit.InsertBreakAction();
+		ActionEvent e = createActionEvent(textArea, RSyntaxTextAreaEditorKit.insertBreakAction);
+		a.actionPerformedImpl(e, textArea);
+
+		// All the whitespace on that line is cleared and the "   " after the caret is effectively removed
+		// (or replaced with '\t' because of auto-indent, depending on how you look at it).
 		String expectedResultContent = "public void foo() {\n\n\t";
 		Assertions.assertEquals(expectedResultContent, textArea.getText());
+		Assertions.assertEquals(expectedResultContent.length(), textArea.getCaretPosition());
+	}
+
+	@Test
+	void test_noSelection_defaults_wsAndTextAfterCaret_emulatedTabs() {
+
+		String origContent = "  we are";
+		RSyntaxTextArea textArea = createTextArea(SyntaxConstants.SYNTAX_STYLE_JAVA, origContent);
+		textArea.setAutoIndentEnabled(true); // default
+		textArea.setClearWhitespaceLinesEnabled(true); // default
+		textArea.setTabsEmulated(true);
+
+		// Caret is before " are", but the leading " " char is removed when the newline is inserted
+		textArea.setCaretPosition(origContent.length() - " are".length());
+
+		RecordableTextAction a = new RSyntaxTextAreaEditorKit.InsertBreakAction();
+		ActionEvent e = createActionEvent(textArea, RSyntaxTextAreaEditorKit.insertBreakAction);
+		a.actionPerformedImpl(e, textArea);
+
+		// "are" is moved to the next line and indented to match the indentation of "we".
+		// The preceding " " character does not affect the new line's indentation
+		String expectedResultContent = "  we\n  are";
+		Assertions.assertEquals(expectedResultContent, textArea.getText());
+		Assertions.assertEquals(expectedResultContent.length() - "are".length(), textArea.getCaretPosition());
+	}
+
+	@Test
+	void test_noSelection_defaults_textAfterCaret_emulatedTabs() {
+
+		String origContent = "    weare";
+		RSyntaxTextArea textArea = createTextArea(SyntaxConstants.SYNTAX_STYLE_JAVA, origContent);
+		textArea.setAutoIndentEnabled(true); // default
+		textArea.setClearWhitespaceLinesEnabled(true); // default
+		textArea.setTabsEmulated(true);
+
+		textArea.setCaretPosition(origContent.length() - "are".length());
+
+		RecordableTextAction a = new RSyntaxTextAreaEditorKit.InsertBreakAction();
+		ActionEvent e = createActionEvent(textArea, RSyntaxTextAreaEditorKit.insertBreakAction);
+		a.actionPerformedImpl(e, textArea);
+
+		// Text that was moved to a new line is indented to match the previous line
+		String expectedResultContent = "    we\n    are";
+		Assertions.assertEquals(expectedResultContent, textArea.getText());
+		Assertions.assertEquals(expectedResultContent.length() - "are".length(), textArea.getCaretPosition());
+	}
+
+	@Test
+	void test_noSelection_defaults_textAfterCaret_noEmulatedTabs() {
+
+		String origContent = "    weare";
+		RSyntaxTextArea textArea = createTextArea(SyntaxConstants.SYNTAX_STYLE_JAVA, origContent);
+		textArea.setAutoIndentEnabled(true); // default
+		textArea.setClearWhitespaceLinesEnabled(true); // default
+		textArea.setTabsEmulated(false); // default
+
+		textArea.setCaretPosition(origContent.length() - "are".length());
+
+		RecordableTextAction a = new RSyntaxTextAreaEditorKit.InsertBreakAction();
+		ActionEvent e = createActionEvent(textArea, RSyntaxTextAreaEditorKit.insertBreakAction);
+		a.actionPerformedImpl(e, textArea);
+
+		// Text that was moved to a new line is indented to match the previous line.
+		// Note the prior indentation is preserved - spaces - even though tabs are enabled
+		String expectedResultContent = "    we\n    are";
+		Assertions.assertEquals(expectedResultContent, textArea.getText());
+		Assertions.assertEquals(expectedResultContent.length() - "are".length(), textArea.getCaretPosition());
+	}
+
+	@Test
+	void test_noSelection_autoIndentDisabled_caretAtEnd_withCurly_closingCurlyBraceAdded() {
+
+		String origContent = "public void foo() {";
+		RSyntaxTextArea textArea = createTextArea(SyntaxConstants.SYNTAX_STYLE_JAVA, origContent);
+		textArea.setAutoIndentEnabled(false);
+		textArea.setClearWhitespaceLinesEnabled(true); // default
+
+		textArea.setCaretPosition(origContent.length());
+
+		RecordableTextAction a = new RSyntaxTextAreaEditorKit.InsertBreakAction();
+		ActionEvent e = createActionEvent(textArea, RSyntaxTextAreaEditorKit.insertBreakAction);
+		a.actionPerformedImpl(e, textArea);
+
+		// Caret is on a new, empty line, and the line after that is an unindented closing curly
+		String expectedResultContent = "public void foo() {\n\n}\n";
+		Assertions.assertEquals(expectedResultContent, textArea.getText());
+		Assertions.assertEquals(origContent.length() + 1, textArea.getCaretPosition());
+	}
+
+	@Test
+	void test_noSelection_autoIndentDisabled_caretAtEnd_withCurlyPair() {
+
+		String origContent = "  public void foo() { doSomething(); }";
+		RSyntaxTextArea textArea = createTextArea(SyntaxConstants.SYNTAX_STYLE_JAVA, origContent);
+		textArea.setAutoIndentEnabled(false);
+		textArea.setClearWhitespaceLinesEnabled(true); // default
+
+		textArea.setCaretPosition(origContent.length());
+
+		RecordableTextAction a = new RSyntaxTextAreaEditorKit.InsertBreakAction();
+		ActionEvent e = createActionEvent(textArea, RSyntaxTextAreaEditorKit.insertBreakAction);
+		a.actionPerformedImpl(e, textArea);
+
+		// Since the opening curly was paired on the same line, no matching closing curly is added
+		String expectedResultContent = origContent + "\n";
+		Assertions.assertEquals(expectedResultContent, textArea.getText());
+		Assertions.assertEquals(origContent.length() + "\n".length(), textArea.getCaretPosition());
+	}
+
+	@Test
+	void test_noSelection_autoIndentDisabled_allWSLine_caretAtEnd_allWSLineCleared() {
+
+		String origContent = "public void foo() {\n\t";
+		RSyntaxTextArea textArea = createTextArea(SyntaxConstants.SYNTAX_STYLE_JAVA, origContent);
+		textArea.setAutoIndentEnabled(false);
+		textArea.setClearWhitespaceLinesEnabled(true); // default
+
+		textArea.setCaretPosition(origContent.length());
+
+		RecordableTextAction a = new RSyntaxTextAreaEditorKit.InsertBreakAction();
+		ActionEvent e = createActionEvent(textArea, RSyntaxTextAreaEditorKit.insertBreakAction);
+		a.actionPerformedImpl(e, textArea);
+
+		// The line the caret was on is cleared and the caret is on a new line with no whitespace
+		String expectedResultContent = "public void foo() {\n\n";
+		Assertions.assertEquals(expectedResultContent, textArea.getText());
+		Assertions.assertEquals(expectedResultContent.length(), textArea.getCaretPosition());
+	}
+
+	@Test
+	void test_noSelection_autoIndentDisabled_allWSLine_caretInMiddle_wsLineClearedAndWSAfterCaretRemoved() {
+
+		String origContent = "public void foo() {\n\t\t";
+		RSyntaxTextArea textArea = createTextArea(SyntaxConstants.SYNTAX_STYLE_JAVA, origContent);
+		textArea.setAutoIndentEnabled(false);
+		textArea.setClearWhitespaceLinesEnabled(true); // default
+
+		textArea.setCaretPosition(origContent.length() - 1); // tab before and after
+
+		RecordableTextAction a = new RSyntaxTextAreaEditorKit.InsertBreakAction();
+		ActionEvent e = createActionEvent(textArea, RSyntaxTextAreaEditorKit.insertBreakAction);
+		a.actionPerformedImpl(e, textArea);
+
+		// The line the caret was on is cleared and the caret is on a new line with no whitespace
+		String expectedResultContent = "public void foo() {\n\n";
+		Assertions.assertEquals(expectedResultContent, textArea.getText());
+		Assertions.assertEquals(expectedResultContent.length(), textArea.getCaretPosition());
+	}
+
+	@Test
+	void test_noSelection_autoIndentDisabled_wsAndTextAfterCaret_emulatedTabs() {
+
+		String origContent = "  we are";
+		RSyntaxTextArea textArea = createTextArea(SyntaxConstants.SYNTAX_STYLE_JAVA, origContent);
+		textArea.setAutoIndentEnabled(false); // default
+		textArea.setClearWhitespaceLinesEnabled(true); // default
+		textArea.setTabsEmulated(true);
+
+		// Caret is before " are", but the leading " " char is removed when the newline is inserted
+		textArea.setCaretPosition(origContent.length() - " are".length());
+
+		RecordableTextAction a = new RSyntaxTextAreaEditorKit.InsertBreakAction();
+		ActionEvent e = createActionEvent(textArea, RSyntaxTextAreaEditorKit.insertBreakAction);
+		a.actionPerformedImpl(e, textArea);
+
+		// "are" is moved to the next line not indented.
+		// The preceding " " character does not affect the new line's indentation
+		String expectedResultContent = "  we\nare";
+		Assertions.assertEquals(expectedResultContent, textArea.getText());
+		Assertions.assertEquals(expectedResultContent.length() - "are".length(), textArea.getCaretPosition());
+	}
+
+	@Test
+	void test_noSelection_autoIndentDisabled_textAfterCaret_emulatedTabs() {
+
+		String origContent = "    weare";
+		RSyntaxTextArea textArea = createTextArea(SyntaxConstants.SYNTAX_STYLE_JAVA, origContent);
+		textArea.setAutoIndentEnabled(false);
+		textArea.setClearWhitespaceLinesEnabled(true); // default
+		textArea.setTabsEmulated(true);
+
+		textArea.setCaretPosition(origContent.length() - "are".length());
+
+		RecordableTextAction a = new RSyntaxTextAreaEditorKit.InsertBreakAction();
+		ActionEvent e = createActionEvent(textArea, RSyntaxTextAreaEditorKit.insertBreakAction);
+		a.actionPerformedImpl(e, textArea);
+
+		// Text that was moved to a new line not indented.
+		String expectedResultContent = "    we\nare";
+		Assertions.assertEquals(expectedResultContent, textArea.getText());
+		Assertions.assertEquals(expectedResultContent.length() - "are".length(), textArea.getCaretPosition());
+	}
+
+	@Test
+	void test_noSelection_autoIndentDisabled_textAfterCaret_noEmulatedTabs() {
+
+		String origContent = "    weare";
+		RSyntaxTextArea textArea = createTextArea(SyntaxConstants.SYNTAX_STYLE_JAVA, origContent);
+		textArea.setAutoIndentEnabled(false);
+		textArea.setClearWhitespaceLinesEnabled(true); // default
+		textArea.setTabsEmulated(false); // default
+
+		textArea.setCaretPosition(origContent.length() - "are".length());
+
+		RecordableTextAction a = new RSyntaxTextAreaEditorKit.InsertBreakAction();
+		ActionEvent e = createActionEvent(textArea, RSyntaxTextAreaEditorKit.insertBreakAction);
+		a.actionPerformedImpl(e, textArea);
+
+		// Text that was moved to a new line not indented.
+		String expectedResultContent = "    we\nare";
+		Assertions.assertEquals(expectedResultContent, textArea.getText());
+		Assertions.assertEquals(expectedResultContent.length() - "are".length(), textArea.getCaretPosition());
 	}
 
 	@Test
-	void testActionPerformedImpl_autoIndentNotEnabled() {
+	void test_noSelection_autoIndentDisabled_clearWSLinesDisabled_caretAtEnd_withCurly_closingCurlyBraceAdded() {
 
 		String origContent = "public void foo() {";
 		RSyntaxTextArea textArea = createTextArea(SyntaxConstants.SYNTAX_STYLE_JAVA, origContent);
 		textArea.setAutoIndentEnabled(false);
+		textArea.setClearWhitespaceLinesEnabled(false);
 
 		textArea.setCaretPosition(origContent.length());
 
@@ -97,8 +405,170 @@ void testActionPerformedImpl_autoIndentNotEnabled() {
 		ActionEvent e = createActionEvent(textArea, RSyntaxTextAreaEditorKit.insertBreakAction);
 		a.actionPerformedImpl(e, textArea);
 
+		// Caret is on a new, empty line, and the line after that is an unindented closing curly
 		String expectedResultContent = "public void foo() {\n\n}\n";
 		Assertions.assertEquals(expectedResultContent, textArea.getText());
+		Assertions.assertEquals(origContent.length() + 1, textArea.getCaretPosition());
+	}
+
+	@Test
+	void test_noSelection_autoIndentDisabled_clearWSLinesDisabled_caretAtEnd_withCurlyPair() {
+
+		String origContent = "  public void foo() { doSomething(); }";
+		RSyntaxTextArea textArea = createTextArea(SyntaxConstants.SYNTAX_STYLE_JAVA, origContent);
+		textArea.setAutoIndentEnabled(false);
+		textArea.setClearWhitespaceLinesEnabled(false);
+
+		textArea.setCaretPosition(origContent.length());
+
+		RecordableTextAction a = new RSyntaxTextAreaEditorKit.InsertBreakAction();
+		ActionEvent e = createActionEvent(textArea, RSyntaxTextAreaEditorKit.insertBreakAction);
+		a.actionPerformedImpl(e, textArea);
+
+		// Since the opening curly was paired on the same line, no matching closing curly is added
+		String expectedResultContent = origContent + "\n";
+		Assertions.assertEquals(expectedResultContent, textArea.getText());
+		Assertions.assertEquals(origContent.length() + "\n".length(), textArea.getCaretPosition());
+	}
+
+	@Test
+	void test_noSelection_autoIndentDisabled_clearWSLinesDisabled_allWSLine_caretAtEnd_allWSLineCleared() {
+
+		String origContent = "public void foo() {\n\t";
+		RSyntaxTextArea textArea = createTextArea(SyntaxConstants.SYNTAX_STYLE_JAVA, origContent);
+		textArea.setAutoIndentEnabled(false);
+		textArea.setClearWhitespaceLinesEnabled(false);
+
+		textArea.setCaretPosition(origContent.length());
+
+		RecordableTextAction a = new RSyntaxTextAreaEditorKit.InsertBreakAction();
+		ActionEvent e = createActionEvent(textArea, RSyntaxTextAreaEditorKit.insertBreakAction);
+		a.actionPerformedImpl(e, textArea);
+
+		// The line the caret was on is not cleared and the caret is on a new line with no whitespace
+		String expectedResultContent = "public void foo() {\n\t\n";
+		Assertions.assertEquals(expectedResultContent, textArea.getText());
+		Assertions.assertEquals(expectedResultContent.length(), textArea.getCaretPosition());
+	}
+
+	@Test
+	void test_noSelection_autoIndentDisabled_clearWSLinesDisabled_allWSLine_caretInMiddle_wsLineClearedAndWSAfterCaretRemoved() {
+
+		String origContent = "public void foo() {\n\t\t";
+		RSyntaxTextArea textArea = createTextArea(SyntaxConstants.SYNTAX_STYLE_JAVA, origContent);
+		textArea.setAutoIndentEnabled(false);
+		textArea.setClearWhitespaceLinesEnabled(false);
+
+		textArea.setCaretPosition(origContent.length() - 1); // tab before and after
+
+		RecordableTextAction a = new RSyntaxTextAreaEditorKit.InsertBreakAction();
+		ActionEvent e = createActionEvent(textArea, RSyntaxTextAreaEditorKit.insertBreakAction);
+		a.actionPerformedImpl(e, textArea);
+
+		// The line the caret was on keeps the '\t' that was before the caret,
+		// and the caret is on a new line with no whitespace
+		String expectedResultContent = "public void foo() {\n\t\n";
+		Assertions.assertEquals(expectedResultContent, textArea.getText());
+		Assertions.assertEquals(expectedResultContent.length(), textArea.getCaretPosition());
+	}
+
+	@Test
+	void test_noSelection_autoIndentDisabled_clearWSLinesDisabled_wsAndTextAfterCaret_emulatedTabs() {
+
+		String origContent = "  we are";
+		RSyntaxTextArea textArea = createTextArea(SyntaxConstants.SYNTAX_STYLE_JAVA, origContent);
+		textArea.setAutoIndentEnabled(false);
+		textArea.setClearWhitespaceLinesEnabled(false);
+		textArea.setTabsEmulated(true);
+
+		// Caret is before " are", but the leading " " char is removed when the newline is inserted
+		textArea.setCaretPosition(origContent.length() - " are".length());
+
+		RecordableTextAction a = new RSyntaxTextAreaEditorKit.InsertBreakAction();
+		ActionEvent e = createActionEvent(textArea, RSyntaxTextAreaEditorKit.insertBreakAction);
+		a.actionPerformedImpl(e, textArea);
+
+		// "are" is moved to the next line not indented.
+		// The preceding " " character does not affect the new line's indentation
+		String expectedResultContent = "  we\nare";
+		Assertions.assertEquals(expectedResultContent, textArea.getText());
+		Assertions.assertEquals(expectedResultContent.length() - "are".length(), textArea.getCaretPosition());
+	}
+
+	@Test
+	void test_noSelection_autoIndentDisabled_clearWSLinesDisabled_textAfterCaret_emulatedTabs() {
+
+		String origContent = "    weare";
+		RSyntaxTextArea textArea = createTextArea(SyntaxConstants.SYNTAX_STYLE_JAVA, origContent);
+		textArea.setAutoIndentEnabled(false);
+		textArea.setClearWhitespaceLinesEnabled(false);
+		textArea.setTabsEmulated(true);
+
+		textArea.setCaretPosition(origContent.length() - "are".length());
+
+		RecordableTextAction a = new RSyntaxTextAreaEditorKit.InsertBreakAction();
+		ActionEvent e = createActionEvent(textArea, RSyntaxTextAreaEditorKit.insertBreakAction);
+		a.actionPerformedImpl(e, textArea);
+
+		// Text that was moved to a new line not indented.
+		String expectedResultContent = "    we\nare";
+		Assertions.assertEquals(expectedResultContent, textArea.getText());
+		Assertions.assertEquals(expectedResultContent.length() - "are".length(), textArea.getCaretPosition());
+	}
+
+	@Test
+	void test_noSelection_autoIndentDisabled_clearWSLinesDisabled_textAfterCaret_noEmulatedTabs() {
+
+		String origContent = "    weare";
+		RSyntaxTextArea textArea = createTextArea(SyntaxConstants.SYNTAX_STYLE_JAVA, origContent);
+		textArea.setAutoIndentEnabled(false);
+		textArea.setClearWhitespaceLinesEnabled(false);
+		textArea.setTabsEmulated(false); // default
+
+		textArea.setCaretPosition(origContent.length() - "are".length());
+
+		RecordableTextAction a = new RSyntaxTextAreaEditorKit.InsertBreakAction();
+		ActionEvent e = createActionEvent(textArea, RSyntaxTextAreaEditorKit.insertBreakAction);
+		a.actionPerformedImpl(e, textArea);
+
+		// Text that was moved to a new line not indented.
+		String expectedResultContent = "    we\nare";
+		Assertions.assertEquals(expectedResultContent, textArea.getText());
+		Assertions.assertEquals(expectedResultContent.length() - "are".length(), textArea.getCaretPosition());
+	}
+
+	@Test
+	void test_selection_multipleLines() {
+		String origContent = "something\nspecial";
+		RSyntaxTextArea textArea = createTextArea(SyntaxConstants.SYNTAX_STYLE_JAVA, origContent);
+
+		textArea.setCaretPosition(origContent.indexOf("thing"));
+		textArea.moveCaretPosition(origContent.indexOf('c'));
+
+		RecordableTextAction a = new RSyntaxTextAreaEditorKit.InsertBreakAction();
+		ActionEvent e = createActionEvent(textArea, RSyntaxTextAreaEditorKit.insertBreakAction);
+		a.actionPerformedImpl(e, textArea);
+
+		String expectedResultContent = "some\ncial";
+		Assertions.assertEquals(expectedResultContent, textArea.getText());
+		Assertions.assertEquals(expectedResultContent.indexOf('\n') + 1, textArea.getCaretPosition());
+	}
+
+	@Test
+	void test_selection_singleLine() {
+		String origContent = "somethingspecial";
+		RSyntaxTextArea textArea = createTextArea(SyntaxConstants.SYNTAX_STYLE_JAVA, origContent);
+
+		textArea.setCaretPosition("something".length());
+		textArea.moveCaretPosition(origContent.indexOf('c'));
+
+		RecordableTextAction a = new RSyntaxTextAreaEditorKit.InsertBreakAction();
+		ActionEvent e = createActionEvent(textArea, RSyntaxTextAreaEditorKit.insertBreakAction);
+		a.actionPerformedImpl(e, textArea);
+
+		String expectedResultContent = "something\ncial";
+		Assertions.assertEquals(expectedResultContent, textArea.getText());
+		Assertions.assertEquals(expectedResultContent.indexOf('\n') + 1, textArea.getCaretPosition());
 	}
 
 	@Test
diff --git a/RSyntaxTextArea/src/test/java/org/fife/ui/rsyntaxtextarea/modes/AbstractJFlexCTokenMakerCStyleInsertBreakActionTest.java b/RSyntaxTextArea/src/test/java/org/fife/ui/rsyntaxtextarea/modes/AbstractJFlexCTokenMakerCStyleInsertBreakActionTest.java
new file mode 100644
index 000000000..5cb123a3d
--- /dev/null
+++ b/RSyntaxTextArea/src/test/java/org/fife/ui/rsyntaxtextarea/modes/AbstractJFlexCTokenMakerCStyleInsertBreakActionTest.java
@@ -0,0 +1,251 @@
+/*
+ * This library is distributed under a modified BSD license.  See the included
+ * LICENSE file for details.
+ */
+package org.fife.ui.rsyntaxtextarea.modes;
+
+import org.fife.ui.SwingRunnerExtension;
+import org.fife.ui.rsyntaxtextarea.AbstractRSyntaxTextAreaTest;
+import org.fife.ui.rsyntaxtextarea.RSyntaxTextArea;
+import org.fife.ui.rsyntaxtextarea.SyntaxConstants;
+import org.fife.ui.rtextarea.RTextArea;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+
+import javax.swing.*;
+import java.awt.event.ActionEvent;
+
+
+/**
+ * Unit tests for the {@code AbstractJFlexCTokenMaker.CStyleInsertBreakAction} class.
+ *
+ * @author Robert Futrell
+ * @version 1.0
+ */
+@ExtendWith(SwingRunnerExtension.class)
+class AbstractJFlexCTokenMakerCStyleInsertBreakActionTest extends AbstractRSyntaxTextAreaTest {
+
+	private Action insertBreakAction;
+
+	@BeforeEach
+	void setUp() {
+		insertBreakAction = new JavaTokenMaker().getInsertBreakAction();
+	}
+
+	@Test
+	void test_notEditable() {
+
+		RTextArea textArea = new RTextArea("hello world");
+		textArea.setCaretPosition(textArea.getText().indexOf(' '));
+		textArea.setEditable(false);
+
+		ActionEvent e = new ActionEvent(textArea, 0, "command");
+		insertBreakAction.actionPerformed(e);
+
+		Assertions.assertEquals("hello world", textArea.getText());
+	}
+
+	@Test
+	void test_notEnabled() {
+
+		RTextArea textArea = new RTextArea("hello world");
+		textArea.setCaretPosition(textArea.getText().indexOf(' '));
+		textArea.setEnabled(false);
+
+		ActionEvent e = new ActionEvent(textArea, 0, "command");
+		insertBreakAction.actionPerformed(e);
+
+		Assertions.assertEquals("hello world", textArea.getText());
+	}
+
+	@Test
+	void test_notinDocComment_inCode_defaultIndentingBehavior() {
+
+		String origContent = "  public void foo() {";
+		RSyntaxTextArea textArea = createTextArea(SyntaxConstants.SYNTAX_STYLE_JAVA, origContent);
+		textArea.setAutoIndentEnabled(true); // default
+		textArea.setClearWhitespaceLinesEnabled(true); // default
+
+		textArea.setCaretPosition(origContent.length());
+
+		ActionEvent e = new ActionEvent(textArea, 0, "command");
+		insertBreakAction.actionPerformed(e);
+
+		// Both the new line and the closing curly's line are indented the same amount as
+		// the opening curly's line. Also the caret's line has an extra indentation (defaults
+		// to tab)
+		String expectedResultContent = origContent + "\n  \t\n  }\n";
+		Assertions.assertEquals(expectedResultContent, textArea.getText());
+		Assertions.assertEquals(origContent.length() + "\n  \t".length(), textArea.getCaretPosition());
+	}
+
+	@Test
+	void test_notinDocComment_inWhitespaceBeforeMlcStart() {
+
+		String code = "  /**";
+		RSyntaxTextArea textArea = createTextArea(SyntaxConstants.SYNTAX_STYLE_JAVA, code);
+		textArea.setCaretPosition(1);
+
+		ActionEvent e = new ActionEvent(textArea, 0, "command");
+		insertBreakAction.actionPerformed(e);
+
+		Assertions.assertEquals("\n /**", textArea.getText());
+		Assertions.assertEquals(2, textArea.getCaretPosition());
+	}
+
+	@Test
+	void test_inMLC_unclosed_firstLine() {
+
+		String code = "/*";
+		RSyntaxTextArea textArea = createTextArea(SyntaxConstants.SYNTAX_STYLE_JAVA, code);
+		textArea.setCaretPosition(code.length());
+
+		ActionEvent e = new ActionEvent(textArea, 0, "command");
+		insertBreakAction.actionPerformed(e);
+
+		// New empty line, indented properly, added for the caret and another line closing the MLC also added
+		Assertions.assertEquals("/*\n * \n */", textArea.getText());
+		Assertions.assertEquals("/*\n * ".length(), textArea.getCaretPosition());
+	}
+
+	@Test
+	void test_inDocComment_unclosed_firstLine() {
+
+		String code = "/**";
+		RSyntaxTextArea textArea = createTextArea(SyntaxConstants.SYNTAX_STYLE_JAVA, code);
+		textArea.setCaretPosition(code.length());
+
+		ActionEvent e = new ActionEvent(textArea, 0, "command");
+		insertBreakAction.actionPerformed(e);
+
+		// New empty line, indented properly, added for the caret and another line closing the MLC also added
+		Assertions.assertEquals("/**\n * \n */", textArea.getText());
+		Assertions.assertEquals("/**\n * ".length(), textArea.getCaretPosition());
+	}
+
+	@Test
+	void test_inDocComment_unclosed_firstLine_contentAfterStart() {
+
+		String code = "/** This is an MLC";
+		RSyntaxTextArea textArea = createTextArea(SyntaxConstants.SYNTAX_STYLE_JAVA, code);
+		textArea.setCaretPosition(code.length());
+
+		ActionEvent e = new ActionEvent(textArea, 0, "command");
+		insertBreakAction.actionPerformed(e);
+
+		// New empty line, indented properly, added for the caret and another line closing the MLC also added.
+		// Note indentation for new text (caret position) matches starting offset of the text
+		// on the first line.
+		Assertions.assertEquals("/** This is an MLC\n *  \n */", textArea.getText());
+		Assertions.assertEquals("/** This is an MLC\n *  ".length(), textArea.getCaretPosition());
+	}
+
+	@Test
+	void test_inDocComment_unclosed_secondLine() {
+
+		String code = "/**\n * ";
+		RSyntaxTextArea textArea = createTextArea(SyntaxConstants.SYNTAX_STYLE_JAVA, code);
+		textArea.setCaretPosition(code.length());
+
+		ActionEvent e = new ActionEvent(textArea, 0, "command");
+		insertBreakAction.actionPerformed(e);
+
+		// New empty line, indented properly, added for the caret and another line closing the MLC also added
+		Assertions.assertEquals("/**\n * \n * \n */", textArea.getText());
+		Assertions.assertEquals("/**\n * \n * ".length(), textArea.getCaretPosition());
+	}
+
+	@Test
+	void test_inDocComment_unclosed_secondLine_contentAfterStar() {
+
+		String code = "/**\n * Comment line 1";
+		RSyntaxTextArea textArea = createTextArea(SyntaxConstants.SYNTAX_STYLE_JAVA, code);
+		textArea.setCaretPosition(code.length());
+
+		ActionEvent e = new ActionEvent(textArea, 0, "command");
+		insertBreakAction.actionPerformed(e);
+
+		// New empty line, indented properly, added for the caret and another line closing the MLC also added
+		Assertions.assertEquals("/**\n * Comment line 1\n * \n */", textArea.getText());
+		Assertions.assertEquals("/**\n * Comment line 1\n * ".length(), textArea.getCaretPosition());
+	}
+
+	@Test
+	void test_inDocComment_closed_firstLine() {
+
+		String code = "/**\n */";
+		RSyntaxTextArea textArea = createTextArea(SyntaxConstants.SYNTAX_STYLE_JAVA, code);
+		textArea.setCaretPosition(code.indexOf('\n'));
+
+		ActionEvent e = new ActionEvent(textArea, 0, "command");
+		insertBreakAction.actionPerformed(e);
+
+		// New line with a single asterisk is added and indented properly
+		Assertions.assertEquals("/**\n * \n */", textArea.getText());
+		Assertions.assertEquals("/**\n * ".length(), textArea.getCaretPosition());
+	}
+
+	@Test
+	void test_inDocComment_closed_firstLine_contentAfterStar() {
+
+		String code = "/** Some text\n */";
+		RSyntaxTextArea textArea = createTextArea(SyntaxConstants.SYNTAX_STYLE_JAVA, code);
+		textArea.setCaretPosition(code.indexOf('\n'));
+
+		ActionEvent e = new ActionEvent(textArea, 0, "command");
+		insertBreakAction.actionPerformed(e);
+
+		// New line with a single asterisk is added and indented properly.
+		// Note indentation for new text (caret position) matches starting offset of the text
+		// on the first line.
+		Assertions.assertEquals("/** Some text\n *  \n */", textArea.getText());
+		Assertions.assertEquals("/** Some text\n *  ".length(), textArea.getCaretPosition());
+	}
+
+	@Test
+	void test_inDocComment_closed_secondLine() {
+
+		String code = "/**\n * \n */";
+		RSyntaxTextArea textArea = createTextArea(SyntaxConstants.SYNTAX_STYLE_JAVA, code);
+		textArea.setCaretPosition(code.lastIndexOf('\n'));
+
+		ActionEvent e = new ActionEvent(textArea, 0, "command");
+		insertBreakAction.actionPerformed(e);
+
+		// New line with a single asterisk is added and indented properly
+		Assertions.assertEquals("/**\n * \n * \n */", textArea.getText());
+		Assertions.assertEquals("/**\n * \n * ".length(), textArea.getCaretPosition());
+	}
+
+	@Test
+	void test_inDocComment_closed_secondLine_contentAfterStar() {
+
+		String code = "/**\n * Comment line 1\n */";
+		RSyntaxTextArea textArea = createTextArea(SyntaxConstants.SYNTAX_STYLE_JAVA, code);
+		textArea.setCaretPosition(code.lastIndexOf('\n'));
+
+		ActionEvent e = new ActionEvent(textArea, 0, "command");
+		insertBreakAction.actionPerformed(e);
+
+		// New line with a single asterisk is added and indented properly
+		Assertions.assertEquals("/**\n * Comment line 1\n * \n */", textArea.getText());
+		Assertions.assertEquals("/**\n * Comment line 1\n * ".length(), textArea.getCaretPosition());
+	}
+
+	@Test
+	void test_inDocComment_closed_secondLine_caretBeforeLeadingWhitespaceAndStar() {
+
+		String code = "/**\n * \n */";
+		RSyntaxTextArea textArea = createTextArea(SyntaxConstants.SYNTAX_STYLE_JAVA, code);
+		textArea.setCaretPosition(code.indexOf('\n') + 1);
+
+		ActionEvent e = new ActionEvent(textArea, 0, "command");
+		insertBreakAction.actionPerformed(e);
+
+		// New line with a single asterisk is added and indented properly
+		Assertions.assertEquals("/**\n * \n * \n */", textArea.getText());
+		Assertions.assertEquals("/**\n * \n * ".length(), textArea.getCaretPosition());
+	}
+}