diff --git a/org.eclipse.jdt.debug.tests/console tests/org/eclipse/jdt/debug/tests/console/JavaStackTraceConsoleTest.java b/org.eclipse.jdt.debug.tests/console tests/org/eclipse/jdt/debug/tests/console/JavaStackTraceConsoleTest.java
index d11b319..924dcda 100644
--- a/org.eclipse.jdt.debug.tests/console tests/org/eclipse/jdt/debug/tests/console/JavaStackTraceConsoleTest.java
+++ b/org.eclipse.jdt.debug.tests/console tests/org/eclipse/jdt/debug/tests/console/JavaStackTraceConsoleTest.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2014, 2019 SAP SE and others.
+ * Copyright (c) 2014, 2020 SAP SE and others.
  *
  * This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License 2.0
@@ -12,10 +12,12 @@
  *     SAP SE - initial API and implementation
  *     Paul Pazderski - Bug 546900: Tests to check initial console content and content persistence
  *     Paul Pazderski - Bug 343023: Tests for 'clear initial content on first edit'
+ *     Paul Pazderski - Bug 304219: Tests for formatting
  *******************************************************************************/
 package org.eclipse.jdt.debug.tests.console;
 
 import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertNotEquals;
 
 import java.io.IOException;
 import java.nio.file.Files;
@@ -24,6 +26,8 @@
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
 
 import org.eclipse.core.runtime.jobs.Job;
 import org.eclipse.jdt.debug.tests.AbstractDebugTest;
@@ -35,6 +39,7 @@
 import org.eclipse.jface.text.BadLocationException;
 import org.eclipse.jface.text.BadPositionCategoryException;
 import org.eclipse.jface.text.IDocument;
+import org.eclipse.jface.text.IRegion;
 import org.eclipse.jface.text.Position;
 import org.eclipse.swt.SWT;
 import org.eclipse.swt.custom.ST;
@@ -57,6 +62,9 @@
  */
 public class JavaStackTraceConsoleTest extends AbstractDebugTest {
 
+	private final static Pattern LEFT_INDENT = Pattern.compile("^[ \\t]*");
+	private final static Pattern RIGHT_INDENT = Pattern.compile("\\s+$");
+
 	private final JavaStackTraceConsoleFactory fConsoleFactory = new JavaStackTraceConsoleFactory();
 	private JavaStackTraceConsole fConsole;
 
@@ -269,6 +277,223 @@
 		});
 	}
 
+	/** Test formatting of a plain simple stack trace. */
+	public void testFormatSimple() {
+		IDocument doc = consoleDocumentFormatted("java.lang.AssertionError: expected:5 but was:7\n\n"
+				+ "at org.junit.Ass\nert.fail(Assert.java:88) \n" + "at\norg.junit.   \nAssert.failNotEquals(Assert.java:834)\n"
+				+ "at org.junit.Assert.assertEquals(Assert.java:118)\n" + "at \norg.junit.Assert.assertEquals\n(Assert.java:144)");
+		assertEquals("java.lang.AssertionError: expected:5 but was:7", getLine(doc, 0));
+		assertEquals("at org.junit.Assert.fail(Assert.java:88)", getLine(doc, 1).trim());
+		assertEquals("at org.junit.Assert.failNotEquals(Assert.java:834)", getLine(doc, 2).trim());
+		assertEquals("at org.junit.Assert.assertEquals(Assert.java:118)", getLine(doc, 3).trim());
+		assertEquals("at org.junit.Assert.assertEquals(Assert.java:144)", getLine(doc, 4).trim());
+		checkIndentationConsistency(doc, 0);
+	}
+
+	/** Test formatting of a stack trace including thread name. */
+	public void testFormatThreadName() {
+		IDocument doc = consoleDocumentFormatted("Exception in thread \"ma\nin\" java.lang.NullPointerException\n"
+				+ "at \nStacktrace.main(Stacktrace.java:4)");
+		assertEquals("Exception in thread \"main\" java.lang.NullPointerException", getLine(doc, 0));
+		assertEquals("at Stacktrace.main(Stacktrace.java:4)", getLine(doc, 1).trim());
+		checkIndentationConsistency(doc, 0);
+	}
+
+	/** Test formatting with some less common method names. */
+	public void testFormatUncommonMethods() {
+		IDocument doc = consoleDocumentFormatted("Stack Trace\n" + "  at org.eclipse.core.runtime.SafeRunner.run\n(SafeRunner.java:43)\n"
+				+ "      at org.eclipse.ui.internal.JFaceUtil.lambda$0(JFaceUtil.java:47)\n"
+				+ "    at org.eclipse.ui.internal.JFaceUtil$$Lambda$107/0x00000   \n008013c5c40.run(Unknown Source)\n"
+				+ "\tat org.eclipse.jface.util.SafeRunnable.run(SafeRunnable.java:174)\n"
+				+ "         at java.base@12/java.lang.reflect.Method.invoke(Method.java:567)\n"
+				+ " \n at app/\n/org.eclipse.equinox.launcher.Main.main(Main.java:1438)");
+		assertEquals("Stack Trace", getLine(doc, 0));
+		assertEquals("at org.eclipse.core.runtime.SafeRunner.run(SafeRunner.java:43)", getLine(doc, 1).trim());
+		assertEquals("at org.eclipse.ui.internal.JFaceUtil.lambda$0(JFaceUtil.java:47)", getLine(doc, 2).trim());
+		assertEquals("at org.eclipse.ui.internal.JFaceUtil$$Lambda$107/0x00000008013c5c40.run(Unknown Source)", getLine(doc, 3).trim());
+		assertEquals("at org.eclipse.jface.util.SafeRunnable.run(SafeRunnable.java:174)", getLine(doc, 4).trim());
+		assertEquals("at java.base@12/java.lang.reflect.Method.invoke(Method.java:567)", getLine(doc, 5).trim());
+		assertEquals("at app//org.eclipse.equinox.launcher.Main.main(Main.java:1438)", getLine(doc, 6).trim());
+		checkIndentationConsistency(doc, 0);
+	}
+
+	/** Test formatting with a 'locked' entry. */
+	public void testFormatLocked() {
+		IDocument doc = consoleDocumentFormatted("java.lang.Thread.State: RUNNABLE\n"
+				+ " at java.net.PlainSocketImpl.socketAccept(Native Method)\n\n\n"
+				+ "at java.net.PlainSocketImpl\n.accept(PlainSocketImpl.java:408)\n" + "\t - locked <0x911d3c30>   (a java.net.SocksSocketImpl)\n"
+				+ "    at java.net.ServerSocket.implAccept(ServerSocket.java:462)\n" + "at java.net.ServerSocket.accept(ServerSocket.java:430)");
+		assertEquals("java.lang.Thread.State: RUNNABLE", getLine(doc, 0));
+		assertEquals("at java.net.PlainSocketImpl.socketAccept(Native Method)", getLine(doc, 1).trim());
+		assertEquals("at java.net.PlainSocketImpl.accept(PlainSocketImpl.java:408)", getLine(doc, 2).trim());
+		assertEquals("- locked <0x911d3c30> (a java.net.SocksSocketImpl)", getLine(doc, 3).trim());
+		assertEquals("at java.net.ServerSocket.implAccept(ServerSocket.java:462)", getLine(doc, 4).trim());
+		assertEquals("at java.net.ServerSocket.accept(ServerSocket.java:430)", getLine(doc, 5).trim());
+		checkIndentationConsistency(doc, 0);
+	}
+
+	/** Test formatting with a ... more entry. */
+	public void testFormatMore() {
+		// additional this one is missing the 'header' line and starting with an 'at' line
+		IDocument doc = consoleDocumentFormatted(" at org.springframework.orm.jpa.persistenceunit.DefaultPersistenceUnitManager.preparePersistenceUnitInfos(DefaultPersistenceUnitManager.java:470)\n"
+				+ "    at org.springframework.orm.jpa.persistenceunit.DefaultPersistenceUnitManager.afterPropertiesSet(DefaultPersistenceUnitManager.java:424)\n"
+				+ "at org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean.createNativeEntityManagerFactory(LocalContainerEntityManagerFactoryBean.java:310)\n"
+				+ "          at org.springframework.orm.jpa.AbstractEntityManagerFactoryBean.afterPropertiesSet(AbstractEntityManagerFactoryBean.java:318)\n\n"
+				+ "  \t\t    at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.invokeInitMethods(AbstractAutowireCapableBeanFactory.java:1633)\n"
+				+ "   \t \tat org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.initializeBean(AbstractAutowireCapableBeanFactory.java:1570)\n"
+				+ "  ... 53 more\n" + "");
+		assertEquals("at org.springframework.orm.jpa.persistenceunit.DefaultPersistenceUnitManager.preparePersistenceUnitInfos(DefaultPersistenceUnitManager.java:470)", getLine(doc, 1).trim());
+		assertEquals("at org.springframework.orm.jpa.persistenceunit.DefaultPersistenceUnitManager.afterPropertiesSet(DefaultPersistenceUnitManager.java:424)", getLine(doc, 2).trim());
+		assertEquals("at org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean.createNativeEntityManagerFactory(LocalContainerEntityManagerFactoryBean.java:310)", getLine(doc, 3).trim());
+		assertEquals("at org.springframework.orm.jpa.AbstractEntityManagerFactoryBean.afterPropertiesSet(AbstractEntityManagerFactoryBean.java:318)", getLine(doc, 4).trim());
+		assertEquals("at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.invokeInitMethods(AbstractAutowireCapableBeanFactory.java:1633)", getLine(doc, 5).trim());
+		assertEquals("at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.initializeBean(AbstractAutowireCapableBeanFactory.java:1570)", getLine(doc, 6).trim());
+		assertEquals("... 53 more", getLine(doc, 7).trim());
+		checkIndentationConsistency(doc, 0);
+	}
+
+	/** Test formatting stack trace with cause. */
+	public void testFormatCause() {
+		IDocument doc = consoleDocumentFormatted("HighLevelException:\n LowLevelException\n" + "\tat Junk.a(Junk.java:13)\n"
+				+ "         at Junk.main(Junk.java:4)\n" + "     Caused by: LowLevelException\n" + " at Junk.e(Junk.java:30)\n"
+				+ "    at Junk.d\n(Junk.java:27)\n" + "at Junk.c(Junk.java:21)");
+		assertEquals("HighLevelException: LowLevelException", getLine(doc, 0));
+		assertEquals("at Junk.a(Junk.java:13)", getLine(doc, 1).trim());
+		assertEquals("at Junk.main(Junk.java:4)", getLine(doc, 2).trim());
+		assertEquals("Caused by: LowLevelException", getLine(doc, 3));
+		assertEquals("at Junk.e(Junk.java:30)", getLine(doc, 4).trim());
+		assertEquals("at Junk.d(Junk.java:27)", getLine(doc, 5).trim());
+		assertEquals("at Junk.c(Junk.java:21)", getLine(doc, 6).trim());
+		checkIndentationConsistency(doc, 0);
+
+		// nested causes
+		doc = consoleDocumentFormatted("HighLevelException:\t MidLevelException:\n LowLevelException\n" + "\tat Junk.a(Junk.java:13)\n"
+				+ "    at Junk.main(Junk.java:4)\n" + " Caused by: MidLevelException: LowLevelException\n" + "    at Junk.c(Junk.java:23)\n"
+				+ "      at Junk.b(Junk.java:17)\n" + "      at Junk.a(Junk.java:11)\n" + "... 1 more\n" + " Caused by: LowLevelException\n"
+				+ "     at Junk.e(Junk.java:30)\n" + "at Junk.d(Junk.java:27)\n" + "   at Junk.c(Junk.java:21)\n" + "         ... 3 more\n");
+		assertEquals("HighLevelException: MidLevelException: LowLevelException", getLine(doc, 0));
+		assertEquals("at Junk.a(Junk.java:13)", getLine(doc, 1).trim());
+		assertEquals("at Junk.main(Junk.java:4)", getLine(doc, 2).trim());
+		assertEquals("Caused by: MidLevelException: LowLevelException", getLine(doc, 3));
+		assertEquals("at Junk.c(Junk.java:23)", getLine(doc, 4).trim());
+		assertEquals("at Junk.b(Junk.java:17)", getLine(doc, 5).trim());
+		assertEquals("at Junk.a(Junk.java:11)", getLine(doc, 6).trim());
+		assertEquals("... 1 more", getLine(doc, 7).trim());
+		assertEquals("Caused by: LowLevelException", getLine(doc, 8));
+		assertEquals("at Junk.e(Junk.java:30)", getLine(doc, 9).trim());
+		assertEquals("at Junk.d(Junk.java:27)", getLine(doc, 10).trim());
+		assertEquals("at Junk.c(Junk.java:21)", getLine(doc, 11).trim());
+		assertEquals("... 3 more", getLine(doc, 12).trim());
+		checkIndentationConsistency(doc, 0);
+	}
+
+	/** Test formatting stack trace with suppressed exceptions. */
+	public void testFormatSuppressed() {
+		IDocument doc = consoleDocumentFormatted("Exception in thread \"main\" java.lang.Exception: Something happened\n" + "at Foo.bar(Native)\n"
+				+ "  at Foo.main(Foo.java:5)\n" + "  Suppressed: Resource$CloseFailException: Resource ID = 0\n"
+				+ "    at Resource.close(Resource\n.java:26)\n" + "      at Foo.bar(Foo.java)\n" + "         ... 1 more\n" + "");
+		assertEquals("Exception in thread \"main\" java.lang.Exception: Something happened", getLine(doc, 0));
+		assertEquals("at Foo.bar(Native)", getLine(doc, 1).trim());
+		assertEquals("at Foo.main(Foo.java:5)", getLine(doc, 2).trim());
+		assertEquals("Suppressed: Resource$CloseFailException: Resource ID = 0", getLine(doc, 3).trim());
+		assertEquals("at Resource.close(Resource.java:26)", getLine(doc, 4).trim());
+		assertEquals("at Foo.bar(Foo.java)", getLine(doc, 5).trim());
+		assertEquals("... 1 more", getLine(doc, 6).trim());
+		checkIndentationConsistency(doc, 0);
+
+		// multiple suppressed
+		doc = consoleDocumentFormatted("Exception in thread \"main\" java.lang.Exception: Main block\n" + "  at Foo3.main(Foo3.java:7)\n"
+				+ "     Suppressed: Resource$CloseFailException: Resource ID = 2\n" + "      at Resource.close(Resource.java:26)\n"
+				+ "   \t\tat Foo3.main(Foo3.java:5)\n" + "Suppressed: Resource$CloseFailException: Resource ID = 1\n"
+				+ "      at Resource.close(Resource.java:26)\n" + "                at Foo3.main(Foo3.java:5)\n" + "");
+		assertEquals("Exception in thread \"main\" java.lang.Exception: Main block", getLine(doc, 0));
+		assertEquals("at Foo3.main(Foo3.java:7)", getLine(doc, 1).trim());
+		assertEquals("Suppressed: Resource$CloseFailException: Resource ID = 2", getLine(doc, 2).trim());
+		assertEquals("at Resource.close(Resource.java:26)", getLine(doc, 3).trim());
+		assertEquals("at Foo3.main(Foo3.java:5)", getLine(doc, 4).trim());
+		assertEquals("Suppressed: Resource$CloseFailException: Resource ID = 1", getLine(doc, 5).trim());
+		assertEquals("at Resource.close(Resource.java:26)", getLine(doc, 6).trim());
+		assertEquals("at Foo3.main(Foo3.java:5)", getLine(doc, 7).trim());
+		checkIndentationConsistency(doc, 0);
+	}
+
+	/** Test formatting stack trace with mixture of cause and suppressed. */
+	public void testFormatSuppressedWithCause() {
+		// exception with suppressed and cause
+		IDocument doc = consoleDocumentFormatted("Exception in thread \"main\" java.lang.Exception: Main block\n" + "  at Foo3.main(Foo3.java:7)\n"
+				+ "  Suppressed: Resource$CloseFailException: Resource ID = 1\n" + "          at Resource.close(Resource.java:26)\n"
+				+ "          at Foo3.main(Foo3.java:5)\n" + "Caused by: java.lang.Exception: I did it\n" + "  at Foo3.main(Foo3.java:8)\n");
+		assertEquals("Exception in thread \"main\" java.lang.Exception: Main block", getLine(doc, 0));
+		assertEquals("at Foo3.main(Foo3.java:7)", getLine(doc, 1).trim());
+		assertEquals("Suppressed: Resource$CloseFailException: Resource ID = 1", getLine(doc, 2).trim());
+		assertEquals("at Resource.close(Resource.java:26)", getLine(doc, 3).trim());
+		assertEquals("at Foo3.main(Foo3.java:5)", getLine(doc, 4).trim());
+		assertEquals("Caused by: java.lang.Exception: I did it", getLine(doc, 5).trim());
+		assertEquals("at Foo3.main(Foo3.java:8)", getLine(doc, 6).trim());
+		checkIndentationConsistency(doc, 0);
+		// Additional indentation check. Since cause is linked to primary exception it must be less indented as suppressed stuff.
+		assertEquals(getLineIndentation(getLine(doc, 0)), getLineIndentation(getLine(doc, 5)));
+		assertEquals(getLineIndentation(getLine(doc, 1)), getLineIndentation(getLine(doc, 6)));
+		assertTrue(getLineIndentation(getLine(doc, 3)) > getLineIndentation(getLine(doc, 5)));
+		assertTrue(getLineIndentation(getLine(doc, 3)) > getLineIndentation(getLine(doc, 6)));
+
+		// exception with suppressed and cause for the suppressed
+		doc = consoleDocumentFormatted("Exception in thread \"main\" java.lang.Exception: Main block\n" + "  at Foo4.main(Foo4.java:6)\n"
+				+ "  Suppressed: Resource2$CloseFailException: Resource ID = 1\n" + "          at Resource2.close(Resource2.java:20)\n"
+				+ "          at Foo4.main(Foo4.java:5)\n" + "  Caused by: java.lang.Exception: Rats, you caught me\n"
+				+ "          at Resource2$CloseFailException.<init>(Resource2.java:45)\n" + "          ... 2 more\n");
+		assertEquals("Exception in thread \"main\" java.lang.Exception: Main block", getLine(doc, 0));
+		assertEquals("at Foo4.main(Foo4.java:6)", getLine(doc, 1).trim());
+		assertEquals("Suppressed: Resource2$CloseFailException: Resource ID = 1", getLine(doc, 2).trim());
+		assertEquals("at Resource2.close(Resource2.java:20)", getLine(doc, 3).trim());
+		assertEquals("at Foo4.main(Foo4.java:5)", getLine(doc, 4).trim());
+		assertEquals("Caused by: java.lang.Exception: Rats, you caught me", getLine(doc, 5).trim());
+		assertEquals("at Resource2$CloseFailException.<init>(Resource2.java:45)", getLine(doc, 6).trim());
+		assertEquals("... 2 more", getLine(doc, 7).trim());
+		checkIndentationConsistency(doc, 0);
+		// Additional indentation check. Since cause is linked to suppressed exception it must be greater indented as primary exception stuff.
+		assertNotEquals(getLineIndentation(getLine(doc, 0)), getLineIndentation(getLine(doc, 5)));
+		assertEquals(getLineIndentation(getLine(doc, 2)), getLineIndentation(getLine(doc, 5)));
+		assertNotEquals(getLineIndentation(getLine(doc, 1)), getLineIndentation(getLine(doc, 6)));
+		assertEquals(getLineIndentation(getLine(doc, 3)), getLineIndentation(getLine(doc, 6)));
+		assertEquals(getLineIndentation(getLine(doc, 4)), getLineIndentation(getLine(doc, 7)));
+		assertTrue(getLineIndentation(getLine(doc, 5)) > getLineIndentation(getLine(doc, 0)));
+		assertTrue(getLineIndentation(getLine(doc, 6)) > getLineIndentation(getLine(doc, 1)));
+	}
+
+	/** Test formatting the rare [CIRCULAR REFERENCE:...] entry. */
+	public void testFormatCircular() {
+		IDocument doc = consoleDocumentFormatted("Exception in thread \"main\" Stacktrace$BadException\n"
+				+ "at Stacktrace.main\n(Stacktrace.java:4)\n" + " Caused by: Stacktrace$BadExceptionCompanion: Stacktrace$BadException\n"
+				+ "   at Stacktrace$BadException.<init>(Stacktrace.java:10)\n" + "    ... 1 more\n"
+				+ "  [CIRCULAR REFERENCE:Stacktrace$BadException]");
+		assertEquals("Exception in thread \"main\" Stacktrace$BadException", getLine(doc, 0));
+		assertEquals("at Stacktrace.main(Stacktrace.java:4)", getLine(doc, 1).trim());
+		assertEquals("Caused by: Stacktrace$BadExceptionCompanion: Stacktrace$BadException", getLine(doc, 2));
+		assertEquals("at Stacktrace$BadException.<init>(Stacktrace.java:10)", getLine(doc, 3).trim());
+		assertEquals("... 1 more", getLine(doc, 4).trim());
+		assertEquals("[CIRCULAR REFERENCE:Stacktrace$BadException]", getLine(doc, 5).trim());
+		checkIndentationConsistency(doc, 0);
+	}
+
+	/** Test formatting stack trace from an ant execution. (output mixed with ant prefixes) */
+	public void testFormatAnt() {
+		IDocument doc = consoleDocumentFormatted("[java] !ENTRY org.eclipse.debug.core 4 120 2005-01-11 03:02:30.321\n"
+				+ "     [java] !MESSAGE An exception occurred while dispatching debug events.\n" + "     [java] !STACK 0\n"
+				+ "     [java] java.lang.NullPointerException\n" + "     [java] 	at \n"
+				+ "org.eclipse.debug.internal.ui.views.console.ProcessConsole.closeStreams\n" + "(ProcessConsole.java:364)\n" + "     [java] 	at \n"
+				+ "org.eclipse.debug.internal.ui.views.console.ProcessConsole.handleDebugEvents\n" + "(ProcessConsole.java:438)\n"
+				+ "     [java] 	at org.eclipse.debug.core.DebugPlugin$EventNotifier.run\n" + "(DebugPlugin.java:1043)");
+		assertEquals("[java] !ENTRY org.eclipse.debug.core 4 120 2005-01-11 03:02:30.321", getLine(doc, 0));
+		assertEquals("[java] !MESSAGE An exception occurred while dispatching debug events.", getLine(doc, 1));
+		assertEquals("[java] !STACK 0", getLine(doc, 2));
+		assertEquals("[java] java.lang.NullPointerException", getLine(doc, 3));
+		assertEquals("at org.eclipse.debug.internal.ui.views.console.ProcessConsole.closeStreams(ProcessConsole.java:364)", getLine(doc, 4).replace("[java]", "").trim());
+		assertEquals("at org.eclipse.debug.internal.ui.views.console.ProcessConsole.handleDebugEvents(ProcessConsole.java:438)", getLine(doc, 5).replace("[java]", "").trim());
+		assertEquals("at org.eclipse.debug.core.DebugPlugin$EventNotifier.run(DebugPlugin.java:1043)", getLine(doc, 6).replace("[java]", "").trim());
+		checkIndentationConsistency(doc, 3);
+	}
+
 	private IDocument consoleDocumentWithText(String text) throws InterruptedException {
 		IDocument document = fConsole.getDocument();
 		document.set(text);
@@ -277,6 +502,90 @@
 		return document;
 	}
 
+	private String getLine(IDocument doc, int line) {
+		IRegion lineInfo;
+		try {
+			lineInfo = doc.getLineInformation(line);
+			return doc.get(lineInfo.getOffset(), lineInfo.getLength());
+		} catch (BadLocationException ex) {
+			return null;
+		}
+	}
+
+	/**
+	 * Do some tests on the stack trace indentation. No hardcoded valued just some general assumptions.
+	 *
+	 * @param doc
+	 *            document to test
+	 * @param startLine
+	 *            first line to check
+	 */
+	private void checkIndentationConsistency(IDocument doc, int startLine) {
+		boolean firstSuppress = true;
+		int lastIndent = -1;
+		// Remember how the next line's indentation can differ from the previous.
+		// -1 -> less indented
+		// 0 -> equal
+		// 1 -> more indented
+		int allowedIndentChange = 1;
+		for (int i = startLine, lineCount = doc.getNumberOfLines(); i < lineCount; i++) {
+			String line = getLine(doc, i);
+			line = line.replaceFirst("^\\[[^\\s\\]]+\\] ", ""); // remove and prefix if any
+			if (i != 0) { // first line can be empty
+				assertNotEquals("Empty line " + i, "", line);
+			}
+			assertFalse("Trailing whitespace in line " + i, RIGHT_INDENT.matcher(line).find());
+
+			boolean causedBy = line.trim().startsWith("Caused by: ");
+			boolean suppressed = line.trim().startsWith("Suppressed: ");
+			if (causedBy || (suppressed && !firstSuppress)) {
+				allowedIndentChange = -1;
+			}
+
+			int lineIndent = getLineIndentation(line);
+			if (allowedIndentChange < 0) {
+				assertTrue("Wrong indented line " + i + ": " + lastIndent + " > " + lineIndent, lastIndent > lineIndent);
+			} else if (allowedIndentChange == 0) {
+				assertEquals("Mixed indentation in line " + i, lastIndent, lineIndent);
+			} else if (allowedIndentChange > 0) {
+				assertTrue("Wrong indented line " + i + ": " + lastIndent + " < " + lineIndent, lastIndent < lineIndent);
+			}
+			lastIndent = lineIndent;
+			allowedIndentChange = 0;
+			if (causedBy || suppressed || i == startLine) {
+				allowedIndentChange = 1;
+			}
+			firstSuppress &= !suppressed;
+		}
+	}
+
+	private int getLineIndentation(String line) {
+		int tabSize = 4;
+		String indent = "";
+		Matcher m = LEFT_INDENT.matcher(line);
+		if (m.find()) {
+			indent = m.group();
+		}
+		int tabCount = indent.length() - indent.replace("\t", "").length();
+		return indent.length() + (tabSize - 1) * tabCount;
+	}
+
+	/**
+	 * Set given text, invoke formatting and wait until finished.
+	 *
+	 * @param text
+	 *            new console text
+	 * @return the consoles document
+	 */
+	private IDocument consoleDocumentFormatted(String text) {
+		IDocument document = fConsole.getDocument();
+		document.set(text);
+		fConsole.format();
+		// wait for document being formatted
+		TestUtil.waitForJobs(getName(), 30, 1000);
+		return document;
+	}
+
 	private String[] linkTextsAtPositions(int... offsets) throws BadLocationException {
 		IDocument document = fConsole.getDocument();
 
diff --git a/org.eclipse.jdt.debug.ui/ui/org/eclipse/jdt/internal/debug/ui/console/JavaStackTraceConsole.java b/org.eclipse.jdt.debug.ui/ui/org/eclipse/jdt/internal/debug/ui/console/JavaStackTraceConsole.java
index 6ab52b4..5b80944 100644
--- a/org.eclipse.jdt.debug.ui/ui/org/eclipse/jdt/internal/debug/ui/console/JavaStackTraceConsole.java
+++ b/org.eclipse.jdt.debug.ui/ui/org/eclipse/jdt/internal/debug/ui/console/JavaStackTraceConsole.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2000, 2019 IBM Corporation and others.
+ * Copyright (c) 2000, 2020 IBM Corporation and others.
  *
  * This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License 2.0
@@ -12,6 +12,7 @@
  *     IBM Corporation - initial API and implementation
  *     Paul Pazderski - Bug 546900: Fix IO handling in JavaStacktraceConsole
  *     Paul Pazderski - Bug 343023: Clear the initial stack trace console message on first edit
+ *     Paul Pazderski - Bug 304219: Recognize more typical stack trace keywords for formatting
  *******************************************************************************/
 package org.eclipse.jdt.internal.debug.ui.console;
 
@@ -21,6 +22,8 @@
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
+import java.util.HashMap;
+import java.util.Map;
 import java.util.StringTokenizer;
 
 import org.eclipse.core.runtime.IProgressMonitor;
@@ -80,6 +83,10 @@
     public final static String CONSOLE_TYPE = "javaStackTraceConsole"; //$NON-NLS-1$
     public final static String FILE_NAME = JDIDebugUIPlugin.getDefault().getStateLocation().toOSString() + File.separator + "stackTraceConsole.txt"; //$NON-NLS-1$
 
+	private static final String NL = "\n"; //$NON-NLS-1$
+	private static final String INDENT_STR = "    "; //$NON-NLS-1$
+	private static final int INDENT_WIDTH = 4;
+
     private JavaStackTraceConsolePartitioner partitioner = new JavaStackTraceConsolePartitioner();
     private IPropertyChangeListener propertyListener = new IPropertyChangeListener() {
         @Override
@@ -234,98 +241,136 @@
 
     }
 
-    /**
-     * Underlying format operation
-     * @param trace the stack trace to format
-     * @return the formatted stack trace for this console
-     */
-    private String format(String trace) {
-        StringTokenizer tokenizer = new StringTokenizer(trace, " \t\n\r\f", true); //$NON-NLS-1$
-        StringBuilder formattedTrace = new StringBuilder();
+	/**
+	 * Underlying format operation
+	 *
+	 * @param trace
+	 *            the stack trace to format
+	 * @return the formatted stack trace for this console
+	 */
+	private String format(String trace) {
+		StringTokenizer tokenizer = new StringTokenizer(trace, " \t\n\r\f", true); //$NON-NLS-1$
+		StringBuilder formattedTrace = new StringBuilder(trace.length());
 
-        boolean insideAt = false;
-        boolean newLine = true;
-        int pendingSpaces = 0;
-        boolean antTrace = false;
+		boolean insideAt = false;
+		boolean newLine = true;
+		int pendingSpaces = 0;
+		boolean antTrace = false;
+		int depth = 1;
+		// Block depth map is used to find the most likely indentation for a Caused.
+		// In combination with Suppressed the correct indentation can be ambiguous.
+		// Map has indentation in number of spaces of a previous block as key and formated
+		// indentation depth used for this block as value.
+		Map<Integer, Integer> blockDepth = new HashMap<>(3);
 
-        while (tokenizer.hasMoreTokens()) {
-            String token = tokenizer.nextToken();
-            if (token.length() == 0)
-			 {
+		while (tokenizer.hasMoreTokens()) {
+			String token = tokenizer.nextToken();
+			if (token.isEmpty()) {
 				continue; // paranoid
 			}
-            char c = token.charAt(0);
-            // handle delimiters
-            switch (c) {
-            case ' ':
-                if (newLine) {
-                    pendingSpaces++;
-                } else {
-                    pendingSpaces = 1;
-                }
-                continue;
-            case '\t':
-                if (newLine) {
-                    pendingSpaces += 4;
-                } else {
-                    pendingSpaces = 1;
-                }
-                continue;
-            case '\n':
-            case '\r':
-            case '\f':
-                if (insideAt) {
-                    pendingSpaces = 1;
-                } else {
-                    pendingSpaces = 0;
-                    newLine = true;
-                }
-                continue;
-            }
-            // consider newlines only before token starting with char '\"' or
-            // token "at" or "-".
-            if (newLine || antTrace) {
-                if (c == '\"') { // leading thread name, e.g. "Worker-124"
-                                    // prio=5
-                    formattedTrace.append("\n\n"); //$NON-NLS-1$  print 2 lines to break between threads
-                } else if ("-".equals(token)) { //$NON-NLS-1$ - locked ...
-                    formattedTrace.append("\n"); //$NON-NLS-1$
-                    formattedTrace.append("    "); //$NON-NLS-1$
-                    formattedTrace.append(token);
-                    pendingSpaces = 0;
-                    continue;
-                } else if ("at".equals(token)) { //$NON-NLS-1$  at ...
-                    if (!antTrace) {
-                        formattedTrace.append("\n"); //$NON-NLS-1$
-                        formattedTrace.append("    "); //$NON-NLS-1$
-                    } else {
-                        formattedTrace.append(' ');
-                    }
-                    insideAt = true;
-                    formattedTrace.append(token);
-                    pendingSpaces = 0;
-                    continue;
-                } else if (c == '[') {
-                    if(antTrace) {
-                        formattedTrace.append("\n"); //$NON-NLS-1$
-                    }
-                    formattedTrace.append(token);
-                    pendingSpaces = 0;
-                    newLine = false;
-                    antTrace = true;
-                    continue;
-                }
-                newLine = false;
-            }
-            if (pendingSpaces > 0) {
-                for (int i = 0; i < pendingSpaces; i++) {
-                    formattedTrace.append(' ');
-                }
-                pendingSpaces = 0;
-            }
-            formattedTrace.append(token);
-            insideAt = false;
-        }
-        return formattedTrace.toString();
-    }
+			char c = token.charAt(0);
+			// handle delimiters
+			switch (c) {
+				case ' ':
+					if (newLine) {
+						pendingSpaces++;
+					} else {
+						pendingSpaces = 1;
+					}
+					continue;
+				case '\t':
+					if (newLine) {
+						pendingSpaces += INDENT_WIDTH;
+					} else {
+						pendingSpaces = 1;
+					}
+					continue;
+				case '\n':
+				case '\r':
+				case '\f':
+					if (insideAt) {
+						pendingSpaces = 1;
+					} else {
+						pendingSpaces = 0;
+						newLine = true;
+					}
+					continue;
+			}
+			// consider newlines only before token starting with char '\"' or
+			// token "at", "-", "...", "Caused by:", "Suppressed:" and "[CIRCULAR".
+			if (newLine) {
+				if (c == '\"') { // leading thread name, e.g. "Worker-124" prio=5
+					formattedTrace.append(NL + NL); // print 2 lines to break between threads
+				} else if (c == '-' // - locked <address>
+						|| "...".equals(token)) { //$NON-NLS-1$ ... xx more
+					applyIndentedToken(formattedTrace, depth, token, antTrace);
+					pendingSpaces = 0;
+					continue;
+				} else if ("at".equals(token)) { //$NON-NLS-1$ at method
+					insideAt = true;
+					applyIndentedToken(formattedTrace, depth, token, antTrace);
+					pendingSpaces = 0;
+					continue;
+				} else if (c == '[') {
+					if ("[CIRCULAR".equals(token)) { //$NON-NLS-1$ [CIRCULAR REFERENCE:toString()]
+						applyIndentedToken(formattedTrace, depth, token, antTrace);
+						pendingSpaces = 0;
+					} else {
+						if (antTrace) {
+							formattedTrace.append(NL);
+						}
+						formattedTrace.append(token);
+						pendingSpaces = 0;
+						antTrace = true;
+					}
+					continue;
+				} else if ("Caused".equals(token)) { //$NON-NLS-1$ Caused by: reason
+					// Guess depth for Cause block. This can be interpreted as if the Caused
+					// block is moved to the left until it aligns with a previous Suppressed
+					// block or hit the line begin.
+					depth = 0;
+					for (Map.Entry<Integer, Integer> block : blockDepth.entrySet()) {
+						if (block.getKey() <= pendingSpaces && block.getValue() > depth) {
+							depth = block.getValue();
+						}
+					}
+					applyIndentedToken(formattedTrace, depth, token, antTrace);
+					depth++;
+					pendingSpaces = 0;
+					continue;
+				} else if ("Suppressed:".equals(token)) { //$NON-NLS-1$ Suppressed: reason
+					if (depth >= 2) {
+						depth--;
+					}
+					blockDepth.put(pendingSpaces, depth);
+					applyIndentedToken(formattedTrace, depth, token, antTrace);
+					depth = 2;
+					pendingSpaces = 0;
+					continue;
+				}
+				newLine = false;
+			}
+			if (pendingSpaces > 0) {
+				for (int i = 0; i < pendingSpaces; i++) {
+					formattedTrace.append(' ');
+				}
+				pendingSpaces = 0;
+			}
+			formattedTrace.append(token);
+			insideAt = false;
+		}
+		return formattedTrace.toString();
+	}
+
+	private void applyIndentedToken(StringBuilder formattedTrace, int depth, String token, boolean antTrace) {
+		if (antTrace) {
+			formattedTrace.append(' ');
+		} else {
+			formattedTrace.append(NL);
+		}
+		for (int i = 0; i < depth; i++) {
+			formattedTrace.append(INDENT_STR);
+		}
+		formattedTrace.append(token);
+	}
 }