CONTRIBUTING

-Contributing to JDT - Java development tools
-============================================
+# Contributing to Eclipse Java development tools
 
 Thanks for your interest in this project.
 
-Project description:
---------------------
+## Project description
 
-The JDT project provides the tool plug-ins that implement a Java IDE supporting the development of any Java application, including Eclipse plug-ins. It adds a Java project nature and Java perspective to the Eclipse Workbench as well as a number of views, editors, wizards, builders, and code merging and refactoring tools. The JDT project allows Eclipse to be a development environment for itself.
+The JDT project provides the tool plug-ins that implement a Java IDE supporting
+the development of any Java application, including Eclipse plug-ins. It adds a
+Java project nature and Java perspective to the Eclipse Workbench as well as a
+number of views, editors, wizards, builders, and code merging and refactoring
+tools. The JDT project allows Eclipse to be a development environment for
+itself.
 
-- https://projects.eclipse.org/projects/eclipse.jdt
+* https://projects.eclipse.org/projects/eclipse.jdt
 
-Developer resources:
---------------------
+## Developer resources
 
-Information regarding source code management, builds, coding standards, and more.
+Information regarding source code management, builds, coding standards, and
+more.
 
-- https://projects.eclipse.org/projects/eclipse.jdt/developer
+* https://projects.eclipse.org/projects/eclipse.jdt/developer
 
-Contributor License Agreement:
-------------------------------
+The project maintains the following source code repositories
 
-Before your contribution can be accepted by the project, you need to create and electronically sign the Eclipse Foundation Contributor License Agreement (ECA).
+* http://git.eclipse.org/c/jdt/eclipse.jdt.core.binaries.git
+* http://git.eclipse.org/c/jdt/eclipse.jdt.core.git
+* http://git.eclipse.org/c/jdt/eclipse.jdt.debug.git
+* http://git.eclipse.org/c/jdt/eclipse.jdt.git
+* http://git.eclipse.org/c/jdt/eclipse.jdt.ui.git
 
-- http://www.eclipse.org/legal/ECA.php
+This project uses Bugzilla to track ongoing development and issues.
 
-Contact:
---------
+* Search for issues: https://eclipse.org/bugs/buglist.cgi?product=JDT
+* Create a new report: https://eclipse.org/bugs/enter_bug.cgi?product=JDT
 
-Contact the project developers via the project's "dev" list.
+Be sure to search for existing bugs before you create another one. Remember that
+contributions are always welcome!
 
-- https://dev.eclipse.org/mailman/listinfo/jdt-dev
+## Eclipse Contributor Agreement
 
-Search for bugs:
-----------------
+Before your contribution can be accepted by the project team contributors must
+electronically sign the Eclipse Contributor Agreement (ECA).
 
-This project uses Bugzilla to track ongoing development and issues.
+* http://www.eclipse.org/legal/ECA.php
 
-- https://bugs.eclipse.org/bugs/buglist.cgi?product=JDT
+Commits that are provided by non-committers must have a Signed-off-by field in
+the footer indicating that the author is aware of the terms by which the
+contribution has been provided to the project. The non-committer must
+additionally have an Eclipse Foundation account and must have a signed Eclipse
+Contributor Agreement (ECA) on file.
 
-Create a new bug:
------------------
+For more information, please see the Eclipse Committer Handbook:
+https://www.eclipse.org/projects/handbook/#resources-commit
 
-Be sure to search for existing bugs before you create another one. Remember that contributions are always welcome!
+## Contact
+
+Contact the project developers via the project's "dev" list.
 
-- https://bugs.eclipse.org/bugs/enter_bug.cgi?product=JDT
+* https://dev.eclipse.org/mailman/listinfo/jdt-dev
\ No newline at end of file

LICENSE

+Eclipse Public License - v 2.0
+
+    THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE
+    PUBLIC LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR DISTRIBUTION
+    OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS AGREEMENT.
+
+1. DEFINITIONS
+
+"Contribution" means:
+
+  a) in the case of the initial Contributor, the initial content
+     Distributed under this Agreement, and
+
+  b) in the case of each subsequent Contributor:
+     i) changes to the Program, and
+     ii) additions to the Program;
+  where such changes and/or additions to the Program originate from
+  and are Distributed by that particular Contributor. A Contribution
+  "originates" from a Contributor if it was added to the Program by
+  such Contributor itself or anyone acting on such Contributor's behalf.
+  Contributions do not include changes or additions to the Program that
+  are not Modified Works.
+
+"Contributor" means any person or entity that Distributes the Program.
+
+"Licensed Patents" mean patent claims licensable by a Contributor which
+are necessarily infringed by the use or sale of its Contribution alone
+or when combined with the Program.
+
+"Program" means the Contributions Distributed in accordance with this
+Agreement.
+
+"Recipient" means anyone who receives the Program under this Agreement
+or any Secondary License (as applicable), including Contributors.
+
+"Derivative Works" shall mean any work, whether in Source Code or other
+form, that is based on (or derived from) the Program and for which the
+editorial revisions, annotations, elaborations, or other modifications
+represent, as a whole, an original work of authorship.
+
+"Modified Works" shall mean any work in Source Code or other form that
+results from an addition to, deletion from, or modification of the
+contents of the Program, including, for purposes of clarity any new file
+in Source Code form that contains any contents of the Program. Modified
+Works shall not include works that contain only declarations,
+interfaces, types, classes, structures, or files of the Program solely
+in each case in order to link to, bind by name, or subclass the Program
+or Modified Works thereof.
+
+"Distribute" means the acts of a) distributing or b) making available
+in any manner that enables the transfer of a copy.
+
+"Source Code" means the form of a Program preferred for making
+modifications, including but not limited to software source code,
+documentation source, and configuration files.
+
+"Secondary License" means either the GNU General Public License,
+Version 2.0, or any later versions of that license, including any
+exceptions or additional permissions as identified by the initial
+Contributor.
+
+2. GRANT OF RIGHTS
+
+  a) Subject to the terms of this Agreement, each Contributor hereby
+  grants Recipient a non-exclusive, worldwide, royalty-free copyright
+  license to reproduce, prepare Derivative Works of, publicly display,
+  publicly perform, Distribute and sublicense the Contribution of such
+  Contributor, if any, and such Derivative Works.
+
+  b) Subject to the terms of this Agreement, each Contributor hereby
+  grants Recipient a non-exclusive, worldwide, royalty-free patent
+  license under Licensed Patents to make, use, sell, offer to sell,
+  import and otherwise transfer the Contribution of such Contributor,
+  if any, in Source Code or other form. This patent license shall
+  apply to the combination of the Contribution and the Program if, at
+  the time the Contribution is added by the Contributor, such addition
+  of the Contribution causes such combination to be covered by the
+  Licensed Patents. The patent license shall not apply to any other
+  combinations which include the Contribution. No hardware per se is
+  licensed hereunder.
+
+  c) Recipient understands that although each Contributor grants the
+  licenses to its Contributions set forth herein, no assurances are
+  provided by any Contributor that the Program does not infringe the
+  patent or other intellectual property rights of any other entity.
+  Each Contributor disclaims any liability to Recipient for claims
+  brought by any other entity based on infringement of intellectual
+  property rights or otherwise. As a condition to exercising the
+  rights and licenses granted hereunder, each Recipient hereby
+  assumes sole responsibility to secure any other intellectual
+  property rights needed, if any. For example, if a third party
+  patent license is required to allow Recipient to Distribute the
+  Program, it is Recipient's responsibility to acquire that license
+  before distributing the Program.
+
+  d) Each Contributor represents that to its knowledge it has
+  sufficient copyright rights in its Contribution, if any, to grant
+  the copyright license set forth in this Agreement.
+
+  e) Notwithstanding the terms of any Secondary License, no
+  Contributor makes additional grants to any Recipient (other than
+  those set forth in this Agreement) as a result of such Recipient's
+  receipt of the Program under the terms of a Secondary License
+  (if permitted under the terms of Section 3).
+
+3. REQUIREMENTS
+
+3.1 If a Contributor Distributes the Program in any form, then:
+
+  a) the Program must also be made available as Source Code, in
+  accordance with section 3.2, and the Contributor must accompany
+  the Program with a statement that the Source Code for the Program
+  is available under this Agreement, and informs Recipients how to
+  obtain it in a reasonable manner on or through a medium customarily
+  used for software exchange; and
+
+  b) the Contributor may Distribute the Program under a license
+  different than this Agreement, provided that such license:
+     i) effectively disclaims on behalf of all other Contributors all
+     warranties and conditions, express and implied, including
+     warranties or conditions of title and non-infringement, and
+     implied warranties or conditions of merchantability and fitness
+     for a particular purpose;
+
+     ii) effectively excludes on behalf of all other Contributors all
+     liability for damages, including direct, indirect, special,
+     incidental and consequential damages, such as lost profits;
+
+     iii) does not attempt to limit or alter the recipients' rights
+     in the Source Code under section 3.2; and
+
+     iv) requires any subsequent distribution of the Program by any
+     party to be under a license that satisfies the requirements
+     of this section 3.
+
+3.2 When the Program is Distributed as Source Code:
+
+  a) it must be made available under this Agreement, or if the
+  Program (i) is combined with other material in a separate file or
+  files made available under a Secondary License, and (ii) the initial
+  Contributor attached to the Source Code the notice described in
+  Exhibit A of this Agreement, then the Program may be made available
+  under the terms of such Secondary Licenses, and
+
+  b) a copy of this Agreement must be included with each copy of
+  the Program.
+
+3.3 Contributors may not remove or alter any copyright, patent,
+trademark, attribution notices, disclaimers of warranty, or limitations
+of liability ("notices") contained within the Program from any copy of
+the Program which they Distribute, provided that Contributors may add
+their own appropriate notices.
+
+4. COMMERCIAL DISTRIBUTION
+
+Commercial distributors of software may accept certain responsibilities
+with respect to end users, business partners and the like. While this
+license is intended to facilitate the commercial use of the Program,
+the Contributor who includes the Program in a commercial product
+offering should do so in a manner which does not create potential
+liability for other Contributors. Therefore, if a Contributor includes
+the Program in a commercial product offering, such Contributor
+("Commercial Contributor") hereby agrees to defend and indemnify every
+other Contributor ("Indemnified Contributor") against any losses,
+damages and costs (collectively "Losses") arising from claims, lawsuits
+and other legal actions brought by a third party against the Indemnified
+Contributor to the extent caused by the acts or omissions of such
+Commercial Contributor in connection with its distribution of the Program
+in a commercial product offering. The obligations in this section do not
+apply to any claims or Losses relating to any actual or alleged
+intellectual property infringement. In order to qualify, an Indemnified
+Contributor must: a) promptly notify the Commercial Contributor in
+writing of such claim, and b) allow the Commercial Contributor to control,
+and cooperate with the Commercial Contributor in, the defense and any
+related settlement negotiations. The Indemnified Contributor may
+participate in any such claim at its own expense.
+
+For example, a Contributor might include the Program in a commercial
+product offering, Product X. That Contributor is then a Commercial
+Contributor. If that Commercial Contributor then makes performance
+claims, or offers warranties related to Product X, those performance
+claims and warranties are such Commercial Contributor's responsibility
+alone. Under this section, the Commercial Contributor would have to
+defend claims against the other Contributors related to those performance
+claims and warranties, and if a court requires any other Contributor to
+pay any damages as a result, the Commercial Contributor must pay
+those damages.
+
+5. NO WARRANTY
+
+EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT
+PERMITTED BY APPLICABLE LAW, THE PROGRAM IS PROVIDED ON AN "AS IS"
+BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR
+IMPLIED INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF
+TITLE, NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR
+PURPOSE. Each Recipient is solely responsible for determining the
+appropriateness of using and distributing the Program and assumes all
+risks associated with its exercise of rights under this Agreement,
+including but not limited to the risks and costs of program errors,
+compliance with applicable laws, damage to or loss of data, programs
+or equipment, and unavailability or interruption of operations.
+
+6. DISCLAIMER OF LIABILITY
+
+EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT
+PERMITTED BY APPLICABLE LAW, NEITHER RECIPIENT NOR ANY CONTRIBUTORS
+SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST
+PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE
+EXERCISE OF ANY RIGHTS GRANTED HEREUNDER, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+7. GENERAL
+
+If any provision of this Agreement is invalid or unenforceable under
+applicable law, it shall not affect the validity or enforceability of
+the remainder of the terms of this Agreement, and without further
+action by the parties hereto, such provision shall be reformed to the
+minimum extent necessary to make such provision valid and enforceable.
+
+If Recipient institutes patent litigation against any entity
+(including a cross-claim or counterclaim in a lawsuit) alleging that the
+Program itself (excluding combinations of the Program with other software
+or hardware) infringes such Recipient's patent(s), then such Recipient's
+rights granted under Section 2(b) shall terminate as of the date such
+litigation is filed.
+
+All Recipient's rights under this Agreement shall terminate if it
+fails to comply with any of the material terms or conditions of this
+Agreement and does not cure such failure in a reasonable period of
+time after becoming aware of such noncompliance. If all Recipient's
+rights under this Agreement terminate, Recipient agrees to cease use
+and distribution of the Program as soon as reasonably practicable.
+However, Recipient's obligations under this Agreement and any licenses
+granted by Recipient relating to the Program shall continue and survive.
+
+Everyone is permitted to copy and distribute copies of this Agreement,
+but in order to avoid inconsistency the Agreement is copyrighted and
+may only be modified in the following manner. The Agreement Steward
+reserves the right to publish new versions (including revisions) of
+this Agreement from time to time. No one other than the Agreement
+Steward has the right to modify this Agreement. The Eclipse Foundation
+is the initial Agreement Steward. The Eclipse Foundation may assign the
+responsibility to serve as the Agreement Steward to a suitable separate
+entity. Each new version of the Agreement will be given a distinguishing
+version number. The Program (including Contributions) may always be
+Distributed subject to the version of the Agreement under which it was
+received. In addition, after a new version of the Agreement is published,
+Contributor may elect to Distribute the Program (including its
+Contributions) under the new version.
+
+Except as expressly stated in Sections 2(a) and 2(b) above, Recipient
+receives no rights or licenses to the intellectual property of any
+Contributor under this Agreement, whether expressly, by implication,
+estoppel or otherwise. All rights in the Program not expressly granted
+under this Agreement are reserved. Nothing in this Agreement is intended
+to be enforceable by any entity that is not a Contributor or Recipient.
+No third-party beneficiary rights are created under this Agreement.
+
+Exhibit A - Form of Secondary Licenses Notice
+
+"This Source Code may also be made available under the following 
+Secondary Licenses when the conditions for such availability set forth 
+in the Eclipse Public License, v. 2.0 are satisfied: {name license(s),
+version(s), and exceptions or additional permissions here}."
+
+  Simply including a copy of this Agreement, including this Exhibit A
+  is not sufficient to license the Source Code under Secondary Licenses.
+
+  If it is not possible or desirable to put the notice in a particular
+  file, then You may include the notice in a location (such as a LICENSE
+  file in a relevant directory) where a recipient would be likely to
+  look for such a notice.
+
+  You may add additional accurate notices of copyright ownership.
\ No newline at end of file

NOTICE

+# Notices for Eclipse Java development tools
+
+This content is produced and maintained by the Eclipse Java development tools
+project.
+
+* Project home: https://projects.eclipse.org/projects/eclipse.jdt
+
+## Trademarks
+
+Eclipse Java development tools, Java development tools, Eclipse JDT, and JDT are
+trademarks of the Eclipse Foundation.
+
+## Copyright
+
+All content is the property of the respective authors or their employers. For
+more information regarding authorship of content, please consult the listed
+source code repository logs.
+
+## Declared Project Licenses
+
+This program and the accompanying materials are made available under the terms
+of the Eclipse Public License v. 2.0 which is available at
+http://www.eclipse.org/legal/epl-2.0.
+
+SPDX-License-Identifier: EPL-2.0
+
+## Source Code
+
+The project maintains the following source code repositories:
+
+* http://git.eclipse.org/c/jdt/eclipse.jdt.core.binaries.git
+* http://git.eclipse.org/c/jdt/eclipse.jdt.core.git
+* http://git.eclipse.org/c/jdt/eclipse.jdt.debug.git
+* http://git.eclipse.org/c/jdt/eclipse.jdt.git
+* http://git.eclipse.org/c/jdt/eclipse.jdt.ui.git
\ No newline at end of file

debian/changelog

+eclipse-jdt-debug (4.10-1) unstable; urgency=medium
+
+  * New upstream release
+    - Depend on libeclipse-jdt-core-java (>= 3.15)
+    - Depend on libeclipse-jdt-ui-java (>= 3.15.100)
+  * Standards-Version updated to 4.3.0
+
+ -- Emmanuel Bourg <ebourg@apache.org>  Sat, 29 Dec 2018 00:03:35 +0100
+
 eclipse-jdt-debug (4.9-1) unstable; urgency=medium
 
   * New upstream release

debian/control

@@ -17,9 +17,9 @@ Build-Depends:
  libeclipse-core-variables-java,
  libeclipse-debug-core-java (>= 3.13),
  libeclipse-debug-ui-java (>= 3.13.100),
- libeclipse-jdt-core-java (>= 3.14),
+ libeclipse-jdt-core-java (>= 3.15),
  libeclipse-jdt-core-manipulation-java,
- libeclipse-jdt-ui-java (>= 3.15),
+ libeclipse-jdt-ui-java (>= 3.15.100),
  libeclipse-jface-java,
  libeclipse-jface-text-java,
  libeclipse-ltk-core-refactoring-java,
@@ -36,7 +36,7 @@ Build-Depends:
  libequinox-registry-java,
  libicu4j-java,
  libswt-gtk-4-java
-Standards-Version: 4.2.1
+Standards-Version: 4.3.0
 Vcs-Git: https://salsa.debian.org/java-team/eclipse-jdt-debug.git
 Vcs-Browser: https://salsa.debian.org/java-team/eclipse-jdt-debug
 Homepage: https://projects.eclipse.org/projects/eclipse.jdt.debug
@@ -73,11 +73,11 @@ Depends:
  libeclipse-core-resources-java,
  libeclipse-core-runtime-java,
  libeclipse-core-variables-java,
- libeclipse-debug-core-java (>= 3.12),
+ libeclipse-debug-core-java (>= 3.15),
  libeclipse-debug-ui-java (>= 3.13.100),
  libeclipse-jdt-core-java,
  libeclipse-jdt-core-manipulation-java,
- libeclipse-jdt-ui-java (>= 3.15),
+ libeclipse-jdt-ui-java (>= 3.15.100),
  libeclipse-jface-java,
  libeclipse-jface-text-java,
  libeclipse-ltk-core-refactoring-java,
@@ -112,7 +112,7 @@ Depends:
  libeclipse-core-runtime-java,
  libeclipse-core-variables-java,
  libeclipse-debug-core-java (>= 3.13),
- libeclipse-jdt-core-java (>= 3.14),
+ libeclipse-jdt-core-java (>= 3.15),
  libequinox-common-java,
  libequinox-preferences-java,
  libequinox-registry-java,

org.eclipse.jdt.debug.jdi.tests/.classpath

 <?xml version="1.0" encoding="UTF-8"?>
 <classpath>
-	<classpathentry kind="src" path="tests"/>
+	<classpathentry kind="src" path="tests">
+		<attributes>
+			<attribute name="test" value="true"/>
+		</attributes>
+	</classpathentry>
 	<classpathentry kind="src" path="/org.eclipse.jdt.debug"/>
 	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>
 	<classpathentry kind="con" path="org.eclipse.jdt.junit.JUNIT_CONTAINER/3"/>

org.eclipse.jdt.debug.tests/.classpath

@@ -2,8 +2,20 @@
 <classpath>
 	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>
 	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
-	<classpathentry kind="src" path="test plugin"/>
-	<classpathentry kind="src" path="tests"/>
-	<classpathentry kind="src" path="console tests"/>
+	<classpathentry kind="src" path="test plugin">
+		<attributes>
+			<attribute name="test" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="src" path="tests">
+		<attributes>
+			<attribute name="test" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="src" path="console tests">
+		<attributes>
+			<attribute name="test" value="true"/>
+		</attributes>
+	</classpathentry>
 	<classpathentry kind="output" path="bin"/>
 </classpath>

org.eclipse.jdt.debug.tests/META-INF/MANIFEST.MF

@@ -2,7 +2,7 @@ Manifest-Version: 1.0
 Bundle-ManifestVersion: 2
 Bundle-Name: %pluginName
 Bundle-SymbolicName: org.eclipse.jdt.debug.tests; singleton:=true
-Bundle-Version: 3.11.200.qualifier
+Bundle-Version: 3.11.300.qualifier
 Bundle-ClassPath: javadebugtests.jar
 Bundle-Activator: org.eclipse.jdt.debug.testplugin.JavaTestPlugin
 Bundle-Vendor: %providerName

org.eclipse.jdt.debug.tests/java8/Bug541110.java

+/*******************************************************************************
+ * Copyright (c) 2018 Simeon Andreev and others.
+ *
+ * This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License 2.0
+ * which accompanies this distribution, and is available at
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ *     Simeon Andreev - initial API and implementation
+ *******************************************************************************/
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class Bug541110 {
+
+	public final Map<String, String> map = new HashMap<>();
+	public void breakpointMethod(final String key, final String value) {
+		map.compute(key, (k, v) -> value);
+	}
+
+	public static void main(String[] args) {
+		Bug541110 delta = new Bug541110();
+		delta.breakpointMethod("someKey", "someValue");
+	}
+}

org.eclipse.jdt.debug.tests/plugin.properties

@@ -48,6 +48,7 @@ environment.description.1 = Java 2 Platform, Test Edition 1.5.x
 environment.description.2 = Test default system package access rules
 view.name = Java Debug Context View 1
 view.name.0 = Java Debug Context View 2
+view.name.1 = Java Debug Context View 3
 shortcut.description = General Description
 shortcut.label = Test Shortcut
 description.description = Run Description

org.eclipse.jdt.debug.tests/plugin.xml

@@ -283,6 +283,10 @@
             class="org.eclipse.jdt.debug.testplugin.ContextView"
             id="org.eclipse.jdt.debug.tests.context.view.two"
             name="%view.name.0"/>
+      <view
+            class="org.eclipse.jdt.debug.testplugin.ContextView"
+            id="org.eclipse.jdt.debug.tests.context.view.three"
+            name="%view.name.1"/>
    </extension>
   <extension
         point="org.eclipse.debug.ui.contextViewBindings">

org.eclipse.jdt.debug.tests/pom.xml

@@ -14,11 +14,11 @@
   <parent>
     <artifactId>eclipse.jdt.debug</artifactId>
     <groupId>eclipse.jdt.debug</groupId>
-    <version>4.9.0-SNAPSHOT</version>
+    <version>4.10.0-SNAPSHOT</version>
   </parent>
   <groupId>org.eclipse.jdt</groupId>
   <artifactId>org.eclipse.jdt.debug.tests</artifactId>
-  <version>3.11.200-SNAPSHOT</version>
+  <version>3.11.300-SNAPSHOT</version>
   <packaging>eclipse-test-plugin</packaging>
   <properties>
     <code.ignoredWarnings>${tests.ignoredWarnings}</code.ignoredWarnings>

org.eclipse.jdt.debug.tests/testprograms/Bug538303.java

+/*******************************************************************************
+ * Copyright (c) 2018 Simeon Andreev and others.
+ *
+ * This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License 2.0
+ * which accompanies this distribution, and is available at
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ *     Simeon Andreev - initial API and implementation
+ *******************************************************************************/
+
+public class Bug538303 {
+
+	public static void main(String[] args) throws InterruptedException {
+		Thread t = new Thread(new Runnable() {
+			public void run() {
+				for (int i = 0; i < 2; ++i) {
+					sleep(250);
+					breakpointMethod();
+				}
+			}
+		});
+		t.start();
+		t.join();
+	}
+
+	static void sleep(long ms) {
+		try {
+			Thread.sleep(ms);
+		} catch (InterruptedException e) {
+			// ignore
+		}
+	}
+
+	public static void breakpointMethod() {
+		System.out.println("set a breakpoint here");
+	}
+}

org.eclipse.jdt.debug.tests/tests/org/eclipse/jdt/debug/tests/AbstractDebugTest.java

@@ -20,6 +20,9 @@ import java.io.File;
 import java.io.PrintWriter;
 import java.io.StringWriter;
 import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
@@ -29,9 +32,11 @@ import java.util.stream.Collectors;
 
 import org.eclipse.core.resources.IFile;
 import org.eclipse.core.resources.IFolder;
+import org.eclipse.core.resources.IMarker;
 import org.eclipse.core.resources.IMarkerDelta;
 import org.eclipse.core.resources.IProject;
 import org.eclipse.core.resources.IResource;
+import org.eclipse.core.resources.IWorkspaceRoot;
 import org.eclipse.core.resources.IncrementalProjectBuilder;
 import org.eclipse.core.resources.ResourcesPlugin;
 import org.eclipse.core.runtime.CoreException;
@@ -202,7 +207,7 @@ public abstract class AbstractDebugTest extends TestCase implements  IEvaluation
 			"org.eclipse.debug.tests.targets.HcrClass5", "org.eclipse.debug.tests.targets.HcrClass6", "org.eclipse.debug.tests.targets.HcrClass7", "org.eclipse.debug.tests.targets.HcrClass8",
 			"org.eclipse.debug.tests.targets.HcrClass9", "TestContributedStepFilterClass", "TerminateAll_01", "TerminateAll_02", "StepResult1",
 			"StepResult2", "StepResult3", "StepUncaught", "TriggerPoint_01", "BulkThreadCreationTest", "MethodExitAndException",
-			"Bug534319earlyStart", "Bug534319lateStart", "Bug534319singleThread", "Bug534319startBetwen", "MethodCall" };
+			"Bug534319earlyStart", "Bug534319lateStart", "Bug534319singleThread", "Bug534319startBetwen", "MethodCall", "Bug538303" };
 
 	/**
 	 * the default timeout
@@ -464,6 +469,7 @@ public abstract class AbstractDebugTest extends TestCase implements  IEvaluation
 	    		cfgs.add(createLaunchConfiguration(jp, "EvalTestIntf18"));
 				cfgs.add(createLaunchConfiguration(jp, "EvalIntfSuperDefault"));
 				cfgs.add(createLaunchConfiguration(jp, "DebugHoverTest18"));
+				cfgs.add(createLaunchConfiguration(jp, "Bug541110"));
 	    		loaded18 = true;
 	    		waitForBuild();
 	        }
@@ -745,7 +751,7 @@ public abstract class AbstractDebugTest extends TestCase implements  IEvaluation
 	}
 
 	/**
-	 * Returns the 'OneSeven' project.
+	 * Returns the 'OneEight' project.
 	 *
 	 * @return the test project
 	 */
@@ -2113,6 +2119,8 @@ public abstract class AbstractDebugTest extends TestCase implements  IEvaluation
 			} catch (CoreException e) {
 			}
 		}
+		TestUtil.waitForJobs(getName(), 100, 10000);
+		TestUtil.runEventLoop();
 		getLaunchManager().removeLaunch(launch);
         // ensure event queue is flushed
         DebugEventWaiter waiter = new DebugElementEventWaiter(DebugEvent.MODEL_SPECIFIC, this);
@@ -2819,4 +2827,32 @@ public abstract class AbstractDebugTest extends TestCase implements  IEvaluation
 		return false;
 	}
 
+	protected void assertNoErrorMarkersExist() throws Exception {
+		IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot();
+		IProject[] projects = root.getProjects();
+		for (IProject project : projects) {
+			assertNoErrorMarkersExist(project);
+		}
+	}
+
+	protected void assertNoErrorMarkersExist(IProject project) throws Exception {
+		if (project.isAccessible()) {
+			IMarker[] projectMarkers = project.findMarkers(null, false, IResource.DEPTH_INFINITE);
+			List<IMarker> errorMarkers = Arrays.stream(projectMarkers).filter(marker -> isErrorMarker(marker)).collect(Collectors.toList());
+			String projectErrors = toString(errorMarkers);
+			assertEquals("found errors on project " + project + ":" + System.lineSeparator() + projectErrors, Collections.EMPTY_LIST, errorMarkers);
+		}
+	}
+
+	private static boolean isErrorMarker(IMarker marker) {
+		return marker.getAttribute(IMarker.SEVERITY, -1) == IMarker.SEVERITY_ERROR;
+	}
+
+	private static String toString(Collection<IMarker> markers) {
+		StringBuilder markersInfo = new StringBuilder();
+		for (IMarker marker : markers) {
+			markersInfo.append(marker);
+		}
+		return markersInfo.toString();
+	}
 }

org.eclipse.jdt.debug.tests/tests/org/eclipse/jdt/debug/tests/breakpoints/LambdaBreakpointsTests.java

+/*******************************************************************************
+ * Copyright (c) 2018 Simeon Andreev and others.
+ *
+ * This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License 2.0
+ * which accompanies this distribution, and is available at
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ *     Simeon Andreev - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.jdt.debug.tests.breakpoints;
+
+import java.util.Arrays;
+import java.util.List;
+
+import org.eclipse.debug.core.DebugEvent;
+import org.eclipse.debug.core.DebugPlugin;
+import org.eclipse.debug.core.ILaunch;
+import org.eclipse.debug.core.ILaunchConfiguration;
+import org.eclipse.debug.core.ILaunchManager;
+import org.eclipse.debug.core.model.IDebugTarget;
+import org.eclipse.debug.internal.ui.views.console.ProcessConsole;
+import org.eclipse.jdt.core.IJavaProject;
+import org.eclipse.jdt.debug.core.IJavaDebugTarget;
+import org.eclipse.jdt.debug.testplugin.DebugEventWaiter;
+import org.eclipse.jdt.debug.tests.AbstractDebugTest;
+import org.eclipse.jdt.debug.tests.TestUtil;
+
+/**
+ * Tests conditional breakpoints.
+ */
+public class LambdaBreakpointsTests extends AbstractDebugTest {
+
+	/**
+	 * Constructor
+	 * @param name
+	 */
+	public LambdaBreakpointsTests(String name) {
+		super(name);
+	}
+
+	@Override
+	protected IJavaProject getProjectContext() {
+		return get18Project();
+	}
+
+
+	/**
+	 * Test for Bug 541110 - ClassCastException in Instruction.popValue and a zombie EventDispatcher$1 job afterwards
+	 *
+	 * We check that a specific conditional breakpoint on a line with a lambda expression does not cause a {@link ClassCastException}.
+	 */
+	public void testBug541110() throws Exception {
+		assertNoErrorMarkersExist();
+
+		String typeName = "Bug541110";
+		createConditionalLineBreakpoint(22, typeName, "map.get(key) != null", true);
+
+		try {
+			// The class cast exception causes a job which runs forever. So we will timeout when waiting for debug events, if the exception occurs.
+			ILaunchConfiguration config = getLaunchConfiguration(typeName);
+			DebugEventWaiter waiter = new DebugEventWaiter(DebugEvent.TERMINATE);
+			launchAndWait(config, waiter);
+			// Join running jobs in case the launch did go through, but we have the endless job.
+			TestUtil.waitForJobs(getName(), 1_000, 30_000, ProcessConsole.class);
+		} finally {
+			terminateAndRemoveJavaLaunches();
+			removeAllBreakpoints();
+		}
+	}
+
+	private void terminateAndRemoveJavaLaunches() {
+		ILaunchManager launchManager = DebugPlugin.getDefault().getLaunchManager();
+		List<ILaunch> launches = Arrays.asList(launchManager.getLaunches());
+		for (ILaunch launch : launches) {
+			IDebugTarget debugTarget = launch.getDebugTarget();
+			if (debugTarget instanceof IJavaDebugTarget) {
+				terminateAndRemove((IJavaDebugTarget) debugTarget);
+			}
+		}
+	}
+}

org.eclipse.jdt.debug.tests/tests/org/eclipse/jdt/debug/tests/core/AlternateStratumTests.java

 /*******************************************************************************
- * Copyright (c) 2000, 2005 IBM Corporation and others.
+ * Copyright (c) 2000, 2018 IBM Corporation and others.
  *
  * This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License 2.0

org.eclipse.jdt.debug.tests/tests/org/eclipse/jdt/debug/tests/core/LineTrackerTests.java

 /*******************************************************************************
- * Copyright (c) 2000, 2015 IBM Corporation and others.
+ * Copyright (c) 2000, 2018 IBM Corporation and others.
  *
  * This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License 2.0
@@ -96,6 +96,10 @@ public class LineTrackerTests extends AbstractDebugTest implements IConsoleLineT
 			assertTrue("Never received 'start' notification", fStarted);
 			assertTrue("Never received 'stopped' notification", fStopped);
 			// there are 10 lines and one "empty line" (i.e. the last "new line")
+			String firstLine = fLinesRead.get(0);
+			if (firstLine.contains("advanced source lookup disabled")) {
+				fLinesRead.remove(0);
+			}
 			assertEquals("Wrong number of lines output", 11, fLinesRead.size());
 			for (int i = 0; i < 10; i++) {
 				assertEquals("Line " + i + " not equal", fLines[i], fLinesRead.get(i));
@@ -124,6 +128,10 @@ public class LineTrackerTests extends AbstractDebugTest implements IConsoleLineT
 			dumpOnError(10);
 			assertTrue("Never received 'start' notification", fStarted);
 			assertTrue("Did not receive 'stopped' notification", fStopped);
+			String firstLine = fLinesRead.get(0);
+			if (firstLine.contains("advanced source lookup disabled")) {
+				fLinesRead.remove(0);
+			}
 			assertEquals("Wrong number of lines", 10, fLinesRead.size());
 			for (int i = 0; i < 10; i++) {
 				assertEquals("Line " + i + " not equal", fLines[i], fLinesRead.get(i));
@@ -272,6 +280,10 @@ public class LineTrackerTests extends AbstractDebugTest implements IConsoleLineT
 	        dumpOnError(2);
 	        assertTrue("Never received 'start' notification", fStarted);
 			assertTrue("Never received 'stopped' notification", fStopped);
+			String firstLine = fLinesRead.get(0);
+			if (firstLine.contains("advanced source lookup disabled")) {
+				fLinesRead.remove(0);
+			}
 			assertEquals("Wrong number of lines output", 2, fLinesRead.size());
 			assertEquals("Wrong output", "var = foo", fLinesRead.get(0));
 	    } finally {
@@ -296,6 +308,10 @@ public class LineTrackerTests extends AbstractDebugTest implements IConsoleLineT
 	        dumpOnError(2);
 	        assertTrue("Never received 'start' notification", fStarted);
 			assertTrue("Never received 'stopped' notification", fStopped);
+			String firstLine = fLinesRead.get(0);
+			if (firstLine.contains("advanced source lookup disabled")) {
+				fLinesRead.remove(0);
+			}
 			assertEquals("Wrong number of lines output", 2, fLinesRead.size());
 			assertEquals("Wrong output", "var = 35", fLinesRead.get(0));
 	    } finally {

org.eclipse.jdt.debug.tests/tests/org/eclipse/jdt/debug/tests/core/StratumTests.java

 /*******************************************************************************
- * Copyright (c) 2000, 2005 IBM Corporation and others.
+ * Copyright (c) 2000, 2018 IBM Corporation and others.
  *
  * This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License 2.0
@@ -15,6 +15,7 @@ package org.eclipse.jdt.debug.tests.core;
 
 import java.util.Arrays;
 
+import org.eclipse.jdt.core.JavaCore;
 import org.eclipse.jdt.debug.core.IJavaDebugTarget;
 import org.eclipse.jdt.debug.core.IJavaReferenceType;
 import org.eclipse.jdt.debug.core.IJavaStackFrame;
@@ -47,9 +48,17 @@ public class StratumTests extends AbstractDebugTest {
 			IJavaReferenceType type = ((IJavaStackFrame)thread.getTopStackFrame()).getReferenceType();
 			String[] strata = type.getAvailableStrata();
 			Arrays.sort(strata);
+			String version = ((IJavaDebugTarget)thread.getDebugTarget()).getVersion();
+			// TODO ideally need to check "if NN or newer"
+			if (!JavaCore.isSupportedJavaVersion(version)) {
+				// as of 2018-11-15 java 12 was not supported by the sourcelookup agent
+				assertEquals("Wrong number of available strata", 1, strata.length);
+				assertEquals("Wrong strata", "Java", strata[0]);
+			} else {
 				assertEquals("Wrong number of available strata", 2, strata.length);
 				assertEquals("Wrong strata", "Java", strata[0]);
 				assertEquals("Wrong strata", JDIHelpers.STRATA_ID, strata[1]);
+			}
 		} finally {
 			terminateAndRemove(thread);
 			removeAllBreakpoints();

org.eclipse.jdt.debug.tests/tests/org/eclipse/jdt/debug/tests/ui/AbstractDebugViewTests.java

+/*******************************************************************************
+ *  Copyright (c) 2018 Simeon Andreev and others.
+ *  All rights reserved. This program and the accompanying materials
+ *  are made available under the terms of the Eclipse Public License v1.0
+ *  which accompanies this distribution, and is available at
+ *  http://www.eclipse.org/legal/epl-v10.html
+ *
+ *  Contributors:
+ *     Simeon Andreev - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.jdt.debug.tests.ui;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Objects;
+
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IStatus;
+import org.eclipse.core.runtime.Platform;
+import org.eclipse.debug.core.DebugEvent;
+import org.eclipse.debug.core.ILaunch;
+import org.eclipse.debug.core.ILaunchConfiguration;
+import org.eclipse.debug.core.model.IBreakpoint;
+import org.eclipse.debug.core.model.IDebugTarget;
+import org.eclipse.debug.core.model.IStackFrame;
+import org.eclipse.debug.core.model.IThread;
+import org.eclipse.debug.internal.ui.views.console.ProcessConsole;
+import org.eclipse.debug.internal.ui.views.launch.LaunchView;
+import org.eclipse.debug.ui.IDebugUIConstants;
+import org.eclipse.jdt.debug.core.IJavaBreakpoint;
+import org.eclipse.jdt.debug.core.IJavaMethodBreakpoint;
+import org.eclipse.jdt.debug.core.IJavaStackFrame;
+import org.eclipse.jdt.debug.core.IJavaThread;
+import org.eclipse.jdt.debug.testplugin.DebugElementKindEventDetailWaiter;
+import org.eclipse.jdt.debug.testplugin.DebugEventWaiter;
+import org.eclipse.jdt.debug.tests.TestAgainException;
+import org.eclipse.jdt.debug.tests.TestUtil;
+import org.eclipse.jdt.debug.ui.IJavaDebugUIConstants;
+import org.eclipse.jdt.internal.debug.core.model.JDIStackFrame;
+import org.eclipse.jdt.internal.debug.ui.JDIDebugUIPlugin;
+import org.eclipse.jface.preference.IPreferenceStore;
+import org.eclipse.jface.viewers.ISelection;
+import org.eclipse.jface.viewers.TreePath;
+import org.eclipse.jface.viewers.TreeSelection;
+import org.eclipse.jface.viewers.TreeViewer;
+import org.eclipse.swt.widgets.Tree;
+import org.eclipse.swt.widgets.TreeItem;
+
+public abstract class AbstractDebugViewTests extends AbstractDebugUiTests {
+
+	public AbstractDebugViewTests(String name) {
+		super(name);
+	}
+
+	private LaunchView debugView;
+	private boolean showMonitorsOriginal;
+
+	@Override
+	protected void setUp() throws Exception {
+		super.setUp();
+		IPreferenceStore jdiUIPreferences = JDIDebugUIPlugin.getDefault().getPreferenceStore();
+		showMonitorsOriginal = jdiUIPreferences.getBoolean(IJavaDebugUIConstants.PREF_SHOW_MONITOR_THREAD_INFO);
+		jdiUIPreferences.setValue(IJavaDebugUIConstants.PREF_SHOW_MONITOR_THREAD_INFO, true);
+		resetPerspective(DebugViewPerspectiveFactory.ID);
+		debugView = sync(() -> (LaunchView) getActivePage().showView(IDebugUIConstants.ID_DEBUG_VIEW));
+		processUiEvents(100);
+	}
+
+	@Override
+	protected void tearDown() throws Exception {
+		IPreferenceStore jdiUIPreferences = JDIDebugUIPlugin.getDefault().getPreferenceStore();
+		jdiUIPreferences.setValue(IJavaDebugUIConstants.PREF_SHOW_MONITOR_THREAD_INFO, showMonitorsOriginal);
+		sync(() -> getActivePage().closeAllEditors(false));
+		processUiEvents(100);
+		super.tearDown();
+	}
+
+	/**
+	 * Debugs the specified snippet a number of times, with a breakpoint at the specified method. Fails if the {@code Debug View} does not have a
+	 * stack frame selected upon reaching the breakpoint.
+	 *
+	 * @param iterations
+	 *            the number of iterations to run, high enough to detect sporadic issues
+	 * @param typeName
+	 *            the type name of the snippet, found under {@code testprogram/} in this test plug-in
+	 * @param breakpointMethodName
+	 *            the name of the method in which to set a breakpoint
+	 */
+	protected void doTestWrongSelection(int iterations, String typeName, String breakpointMethodName) throws Exception {
+		doTestWrongSelection(iterations, typeName, breakpointMethodName, 1);
+	}
+
+	/**
+	 * Debugs the specified snippet a number of times, with a breakpoint at the specified method. Fails if the {@code Debug View} does not have a
+	 * stack frame selected upon reaching the breakpoint.
+	 *
+	 * @param iterations
+	 *            the number of iterations to run, high enough to detect sporadic issues
+	 * @param typeName
+	 *            the type name of the snippet, found under {@code testprogram/} in this test plug-in
+	 * @param breakpointMethodName
+	 *            the name of the method in which to set a breakpoint
+	 * @param expectedBreakpointHitsCount
+	 *            the number of times that the breakpoint is expected to be hit
+	 */
+	protected void doTestWrongSelection(int iterations, String typeName, String breakpointMethodName, int expectedBreakpointHitsCount) throws Exception {
+		waitForNonConsoleJobs();
+		assertNoErrorMarkersExist();
+		setPreferenceToShowSystemThreads();
+
+		// Collect failures to have a better idea of what broke and how many times it broke
+		List<AssertionError> failedAssertions = new ArrayList<>();
+		for (int i = 0; i < iterations; ++i) {
+
+			IJavaThread thread = null;
+			try {
+				thread = launchToBreakpoint(typeName, breakpointMethodName, expectedBreakpointHitsCount);
+
+				assertStackFrameIsSelected(breakpointMethodName);
+			} catch (AssertionError assertionError) {
+				failedAssertions.add(assertionError);
+			} finally {
+				terminateAndCleanUp(thread);
+			}
+		}
+
+		assertEquals("expected no assertions to fail during test", Collections.emptyList(), failedAssertions);
+	}
+
+	protected void setPreferenceToShowSystemThreads() {
+		IPreferenceStore preferenceStore = JDIDebugUIPlugin.getDefault().getPreferenceStore();
+		preferenceStore.setValue(IJavaDebugUIConstants.PREF_SHOW_SYSTEM_THREADS, true);
+	}
+
+	protected IJavaThread launchToBreakpoint(String typeName, String breakpointMethodName, int expectedBreakpointHitsCount) throws Exception, CoreException {
+		createMethodBreakpoint(typeName, breakpointMethodName);
+		IJavaThread thread = launchToBreakpoint(typeName, expectedBreakpointHitsCount);
+
+		// Let now all pending jobs proceed, ignore console jobs
+		waitForNonConsoleJobs();
+
+		return thread;
+	}
+
+	protected void assertStackFrameIsSelected(String breakpointMethodName) throws Exception {
+		// Get and check the selection form the tree, we expect only one method selected
+		TreeItem[] selected = getSelectedItemsFromDebugView(true);
+		Object[] selectedText = selectedText(selected);
+		if (selected.length != 1) {
+			if (Platform.getOS().equals(Platform.OS_MACOSX)) {
+				// skip this test on Mac - see bug 516024
+				return;
+			}
+			throw new TestAgainException("Unexpected selection: " + Arrays.toString(selectedText));
+		}
+		assertEquals("Unexpected selection: " + Arrays.toString(selectedText), 1, selected.length);
+		IJavaStackFrame selectedFrame = selectedFrame(selected);
+
+		assertEquals("\"breakpointMethod\" should be selected after reaching breakpoint", selectedFrame.getMethodName(), breakpointMethodName);
+
+	}
+
+	@Override
+	protected boolean enableUIEventLoopProcessingInWaiter() {
+		// After fixes for bug 535686 and 534319 we do not depend on proper event processing in the UI
+		// so we can allow UI thread to be blocked while waiting.
+		// Note: if this test start to fail, we still have some issues with event dispatching in debug UI.
+		return false;
+	}
+
+	protected void createMethodBreakpoint(final String typeName, final String breakpointMethodName) throws Exception, CoreException {
+		IJavaBreakpoint bp = createMethodBreakpoint(typeName, breakpointMethodName, "()V", true, false);
+		bp.setSuspendPolicy(IJavaBreakpoint.SUSPEND_THREAD);
+	}
+
+	protected IJavaThread launchToBreakpoint(String typeName, int expectedBreakpointHitsCount) throws Exception {
+		ILaunchConfiguration config = getLaunchConfiguration(getProjectContext(), typeName);
+		assertNotNull("Could not locate launch configuration for " + typeName, config); //$NON-NLS-1$
+
+		DebugEventWaiter waiter = new BreakpointWaiter(expectedBreakpointHitsCount);
+		waiter.setTimeout(DEFAULT_TIMEOUT);
+		waiter.setEnableUIEventLoopProcessing(enableUIEventLoopProcessingInWaiter());
+
+		boolean registerLaunch = true;
+		Object suspendee = launchAndWait(config, waiter, registerLaunch);
+		IJavaThread thread = (IJavaThread) suspendee;
+		processUiEvents(100);
+
+		// Prepare breakpoint and check everything below UI is OK
+		assertSuspendedInJavaMethod(thread);
+		return thread;
+	}
+
+	protected void assertSuspendedInJavaMethod(IJavaThread thread) {
+		IBreakpoint hit = getBreakpoint(thread);
+		assertNotNull("Suspended, but not by breakpoint", hit);
+		assertTrue("Breakpoint was not a method breakpoint", hit instanceof IJavaMethodBreakpoint);
+	}
+
+	protected void waitForNonConsoleJobs() throws Exception {
+		sync(() -> TestUtil.waitForJobs(getName(), 1_000, 30_000, ProcessConsole.class));
+		processUiEvents(100);
+	}
+
+	protected Object[] selectedText(TreeItem[] selected) throws Exception {
+		Object[] selectedText = sync(() -> Arrays.stream(selected).map(x -> x.getText()).toArray());
+		return selectedText;
+	}
+
+	protected IJavaStackFrame selectedFrame(TreeItem[] selected) throws Exception {
+		TreeItem selectedTreeItem = selected[selected.length - 1];
+		IJavaStackFrame selectedFrame = (IJavaStackFrame) sync(() -> {
+			Object data = selectedTreeItem.getData();
+			assertNotNull("No data for selected frame in the tree?", data);
+			assertEquals("Wrong object selected: " + data, JDIStackFrame.class, data.getClass());
+			return data;
+		});
+		return selectedFrame;
+	}
+
+	protected void terminateAndCleanUp(IJavaThread thread) throws Exception {
+		terminateAndRemove(thread);
+		removeAllBreakpoints();
+		waitForNonConsoleJobs();
+	}
+
+	protected String dumpFrames(Object[] childrenData) {
+		return Arrays.toString(Arrays.stream(childrenData).map(x -> Objects.toString(x)).toArray());
+	}
+
+	protected TreeItem[] getSelectedItemsFromDebugView(boolean wait) throws Exception {
+		return sync(() -> {
+			Tree tree = (Tree) debugView.getViewer().getControl();
+			TreeItem[] selected = tree.getSelection();
+			if (!wait) {
+				return selected;
+			}
+			long start = System.currentTimeMillis();
+
+			// At least on GTK3 it takes some time until we see the viewer selection propagated to the SWT tree
+			while (selected.length != 1 && System.currentTimeMillis() - start < 10000) {
+				TreeViewer treeViewer = (TreeViewer) debugView.getViewer();
+				treeViewer.refresh(true);
+				processUiEvents(500);
+				TestUtil.log(IStatus.INFO, getName(), "Waiting for selection, current size: " + selected.length);
+				selected = tree.getSelection();
+			}
+			return selected;
+		});
+	}
+
+	protected ISelection getDebugViewSelection() throws Exception {
+		return debugView.getViewer().getSelection();
+	}
+
+	protected void setDebugViewSelection(IThread thread) throws Exception {
+		IStackFrame frame = thread.getTopStackFrame();
+		IDebugTarget debugTarget = thread.getDebugTarget();
+		ILaunch launch = debugTarget.getLaunch();
+
+		Object[] segments = new Object[] { launch, debugTarget, thread, frame };
+		TreePath newPath = new TreePath(segments);
+		TreeSelection newSelection = new TreeSelection(newPath);
+		debugView.getViewer().setSelection(newSelection);
+
+		waitForNonConsoleJobs();
+	}
+
+	protected void activateDebugView() throws Exception {
+		sync(() -> getActivePage().activate(debugView));
+	}
+
+	protected void assertDebugViewIsActive() throws Exception {
+		assertEquals("expected Debug View to activate after resuming thread", debugView, sync(() -> getActivePage().getActivePart()));
+	}
+
+	protected static class BreakpointWaiter extends DebugElementKindEventDetailWaiter {
+
+		private final int expectedHitCount;
+		private int hitCount;
+
+		public BreakpointWaiter(int expectedHitCount) {
+			super(DebugEvent.SUSPEND, IJavaThread.class, DebugEvent.BREAKPOINT);
+			this.expectedHitCount = expectedHitCount;
+			assertTrue("expected hit count should be positive, instead is: " + expectedHitCount, expectedHitCount > 0);
+			hitCount = 0;
+		}
+
+		@Override
+		public boolean accept(DebugEvent event) {
+			if (super.accept(event)) {
+				hitCount++;
+			}
+			return hitCount == expectedHitCount;
+		}
+	}
+}
\ No newline at end of file

org.eclipse.jdt.debug.tests/tests/org/eclipse/jdt/debug/tests/ui/DebugViewPerspectiveFactory.java

@@ -31,6 +31,7 @@ public class DebugViewPerspectiveFactory implements IPerspectiveFactory {
 	public void createInitialLayout(IPageLayout layout) {
 		IFolderLayout rightFolder = layout.createFolder(IInternalDebugUIConstants.ID_TOOLS_FOLDER_VIEW, IPageLayout.LEFT, (float) 0.50, layout.getEditorArea());
 		rightFolder.addView(IDebugUIConstants.ID_DEBUG_VIEW);
+		rightFolder.addPlaceholder(ViewManagementTests.VIEW_THREE);
 
 		IFolderLayout consoleFolder = layout.createFolder(IInternalDebugUIConstants.ID_CONSOLE_FOLDER_VIEW, IPageLayout.BOTTOM, (float) 0.65, layout.getEditorArea());
 		consoleFolder.addView(IPageLayout.ID_PROJECT_EXPLORER);