diff --git a/bundles/org.eclipse.equinox.common.tests/.settings/org.eclipse.jdt.core.prefs b/bundles/org.eclipse.equinox.common.tests/.settings/org.eclipse.jdt.core.prefs
index f891093..0a99804 100644
--- a/bundles/org.eclipse.equinox.common.tests/.settings/org.eclipse.jdt.core.prefs
+++ b/bundles/org.eclipse.equinox.common.tests/.settings/org.eclipse.jdt.core.prefs
@@ -119,8 +119,12 @@
 org.eclipse.jdt.core.compiler.problem.unusedWarningToken=warning
 org.eclipse.jdt.core.compiler.problem.varargsArgumentNeedCast=warning
 org.eclipse.jdt.core.compiler.source=1.8
+org.eclipse.jdt.core.formatter.align_assignment_statements_on_columns=false
 org.eclipse.jdt.core.formatter.align_fields_grouping_blank_lines=2147483647
 org.eclipse.jdt.core.formatter.align_type_members_on_columns=false
+org.eclipse.jdt.core.formatter.align_variable_declarations_on_columns=false
+org.eclipse.jdt.core.formatter.align_with_spaces=false
+org.eclipse.jdt.core.formatter.alignment_for_additive_operator=16
 org.eclipse.jdt.core.formatter.alignment_for_arguments_in_allocation_expression=16
 org.eclipse.jdt.core.formatter.alignment_for_arguments_in_annotation=0
 org.eclipse.jdt.core.formatter.alignment_for_arguments_in_enum_constant=16
@@ -129,19 +133,27 @@
 org.eclipse.jdt.core.formatter.alignment_for_arguments_in_qualified_allocation_expression=16
 org.eclipse.jdt.core.formatter.alignment_for_assignment=0
 org.eclipse.jdt.core.formatter.alignment_for_binary_expression=16
+org.eclipse.jdt.core.formatter.alignment_for_bitwise_operator=16
 org.eclipse.jdt.core.formatter.alignment_for_compact_if=16
+org.eclipse.jdt.core.formatter.alignment_for_compact_loops=16
 org.eclipse.jdt.core.formatter.alignment_for_conditional_expression=80
+org.eclipse.jdt.core.formatter.alignment_for_conditional_expression_chain=0
 org.eclipse.jdt.core.formatter.alignment_for_enum_constants=16
 org.eclipse.jdt.core.formatter.alignment_for_expressions_in_array_initializer=16
 org.eclipse.jdt.core.formatter.alignment_for_expressions_in_for_loop_header=0
+org.eclipse.jdt.core.formatter.alignment_for_logical_operator=16
 org.eclipse.jdt.core.formatter.alignment_for_method_declaration=0
 org.eclipse.jdt.core.formatter.alignment_for_module_statements=16
 org.eclipse.jdt.core.formatter.alignment_for_multiple_fields=16
+org.eclipse.jdt.core.formatter.alignment_for_multiplicative_operator=16
 org.eclipse.jdt.core.formatter.alignment_for_parameterized_type_references=0
 org.eclipse.jdt.core.formatter.alignment_for_parameters_in_constructor_declaration=16
 org.eclipse.jdt.core.formatter.alignment_for_parameters_in_method_declaration=16
+org.eclipse.jdt.core.formatter.alignment_for_relational_operator=0
 org.eclipse.jdt.core.formatter.alignment_for_resources_in_try=80
 org.eclipse.jdt.core.formatter.alignment_for_selector_in_method_invocation=16
+org.eclipse.jdt.core.formatter.alignment_for_shift_operator=0
+org.eclipse.jdt.core.formatter.alignment_for_string_concatenation=16
 org.eclipse.jdt.core.formatter.alignment_for_superclass_in_type_declaration=16
 org.eclipse.jdt.core.formatter.alignment_for_superinterfaces_in_enum_declaration=16
 org.eclipse.jdt.core.formatter.alignment_for_superinterfaces_in_type_declaration=16
@@ -151,7 +163,9 @@
 org.eclipse.jdt.core.formatter.alignment_for_type_parameters=0
 org.eclipse.jdt.core.formatter.alignment_for_union_type_in_multicatch=16
 org.eclipse.jdt.core.formatter.blank_lines_after_imports=1
+org.eclipse.jdt.core.formatter.blank_lines_after_last_class_body_declaration=0
 org.eclipse.jdt.core.formatter.blank_lines_after_package=1
+org.eclipse.jdt.core.formatter.blank_lines_before_abstract_method=1
 org.eclipse.jdt.core.formatter.blank_lines_before_field=0
 org.eclipse.jdt.core.formatter.blank_lines_before_first_class_body_declaration=0
 org.eclipse.jdt.core.formatter.blank_lines_before_imports=1
@@ -160,6 +174,7 @@
 org.eclipse.jdt.core.formatter.blank_lines_before_new_chunk=1
 org.eclipse.jdt.core.formatter.blank_lines_before_package=0
 org.eclipse.jdt.core.formatter.blank_lines_between_import_groups=1
+org.eclipse.jdt.core.formatter.blank_lines_between_statement_group_in_switch=0
 org.eclipse.jdt.core.formatter.blank_lines_between_type_declarations=1
 org.eclipse.jdt.core.formatter.brace_position_for_annotation_type_declaration=end_of_line
 org.eclipse.jdt.core.formatter.brace_position_for_anonymous_type_declaration=end_of_line
@@ -188,7 +203,9 @@
 org.eclipse.jdt.core.formatter.comment.format_source_code=true
 org.eclipse.jdt.core.formatter.comment.indent_parameter_description=false
 org.eclipse.jdt.core.formatter.comment.indent_root_tags=false
+org.eclipse.jdt.core.formatter.comment.indent_tag_description=false
 org.eclipse.jdt.core.formatter.comment.insert_new_line_before_root_tags=insert
+org.eclipse.jdt.core.formatter.comment.insert_new_line_between_different_tags=do not insert
 org.eclipse.jdt.core.formatter.comment.insert_new_line_for_parameter=do not insert
 org.eclipse.jdt.core.formatter.comment.line_length=80
 org.eclipse.jdt.core.formatter.comment.new_lines_at_block_boundaries=true
@@ -235,11 +252,15 @@
 org.eclipse.jdt.core.formatter.insert_new_line_in_empty_enum_declaration=insert
 org.eclipse.jdt.core.formatter.insert_new_line_in_empty_method_body=insert
 org.eclipse.jdt.core.formatter.insert_new_line_in_empty_type_declaration=insert
+org.eclipse.jdt.core.formatter.insert_space_after_additive_operator=insert
 org.eclipse.jdt.core.formatter.insert_space_after_and_in_type_parameter=insert
+org.eclipse.jdt.core.formatter.insert_space_after_arrow_in_switch_case=insert
+org.eclipse.jdt.core.formatter.insert_space_after_arrow_in_switch_default=insert
 org.eclipse.jdt.core.formatter.insert_space_after_assignment_operator=insert
 org.eclipse.jdt.core.formatter.insert_space_after_at_in_annotation=do not insert
 org.eclipse.jdt.core.formatter.insert_space_after_at_in_annotation_type_declaration=do not insert
 org.eclipse.jdt.core.formatter.insert_space_after_binary_operator=insert
+org.eclipse.jdt.core.formatter.insert_space_after_bitwise_operator=insert
 org.eclipse.jdt.core.formatter.insert_space_after_closing_angle_bracket_in_type_arguments=do not insert
 org.eclipse.jdt.core.formatter.insert_space_after_closing_angle_bracket_in_type_parameters=insert
 org.eclipse.jdt.core.formatter.insert_space_after_closing_brace_in_block=insert
@@ -266,10 +287,14 @@
 org.eclipse.jdt.core.formatter.insert_space_after_comma_in_multiple_local_declarations=insert
 org.eclipse.jdt.core.formatter.insert_space_after_comma_in_parameterized_type_reference=insert
 org.eclipse.jdt.core.formatter.insert_space_after_comma_in_superinterfaces=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_switch_case_expressions=insert
 org.eclipse.jdt.core.formatter.insert_space_after_comma_in_type_arguments=insert
 org.eclipse.jdt.core.formatter.insert_space_after_comma_in_type_parameters=insert
 org.eclipse.jdt.core.formatter.insert_space_after_ellipsis=insert
 org.eclipse.jdt.core.formatter.insert_space_after_lambda_arrow=insert
+org.eclipse.jdt.core.formatter.insert_space_after_logical_operator=insert
+org.eclipse.jdt.core.formatter.insert_space_after_multiplicative_operator=insert
+org.eclipse.jdt.core.formatter.insert_space_after_not_operator=do not insert
 org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_parameterized_type_reference=do not insert
 org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_type_arguments=do not insert
 org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_type_parameters=do not insert
@@ -294,13 +319,20 @@
 org.eclipse.jdt.core.formatter.insert_space_after_prefix_operator=do not insert
 org.eclipse.jdt.core.formatter.insert_space_after_question_in_conditional=insert
 org.eclipse.jdt.core.formatter.insert_space_after_question_in_wildcard=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_relational_operator=insert
 org.eclipse.jdt.core.formatter.insert_space_after_semicolon_in_for=insert
 org.eclipse.jdt.core.formatter.insert_space_after_semicolon_in_try_resources=insert
+org.eclipse.jdt.core.formatter.insert_space_after_shift_operator=insert
+org.eclipse.jdt.core.formatter.insert_space_after_string_concatenation=insert
 org.eclipse.jdt.core.formatter.insert_space_after_unary_operator=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_additive_operator=insert
 org.eclipse.jdt.core.formatter.insert_space_before_and_in_type_parameter=insert
+org.eclipse.jdt.core.formatter.insert_space_before_arrow_in_switch_case=insert
+org.eclipse.jdt.core.formatter.insert_space_before_arrow_in_switch_default=insert
 org.eclipse.jdt.core.formatter.insert_space_before_assignment_operator=insert
 org.eclipse.jdt.core.formatter.insert_space_before_at_in_annotation_type_declaration=insert
 org.eclipse.jdt.core.formatter.insert_space_before_binary_operator=insert
+org.eclipse.jdt.core.formatter.insert_space_before_bitwise_operator=insert
 org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_parameterized_type_reference=do not insert
 org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_type_arguments=do not insert
 org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_type_parameters=do not insert
@@ -344,10 +376,13 @@
 org.eclipse.jdt.core.formatter.insert_space_before_comma_in_multiple_local_declarations=do not insert
 org.eclipse.jdt.core.formatter.insert_space_before_comma_in_parameterized_type_reference=do not insert
 org.eclipse.jdt.core.formatter.insert_space_before_comma_in_superinterfaces=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_switch_case_expressions=do not insert
 org.eclipse.jdt.core.formatter.insert_space_before_comma_in_type_arguments=do not insert
 org.eclipse.jdt.core.formatter.insert_space_before_comma_in_type_parameters=do not insert
 org.eclipse.jdt.core.formatter.insert_space_before_ellipsis=do not insert
 org.eclipse.jdt.core.formatter.insert_space_before_lambda_arrow=insert
+org.eclipse.jdt.core.formatter.insert_space_before_logical_operator=insert
+org.eclipse.jdt.core.formatter.insert_space_before_multiplicative_operator=insert
 org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_parameterized_type_reference=do not insert
 org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_type_arguments=do not insert
 org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_type_parameters=do not insert
@@ -384,9 +419,12 @@
 org.eclipse.jdt.core.formatter.insert_space_before_prefix_operator=do not insert
 org.eclipse.jdt.core.formatter.insert_space_before_question_in_conditional=insert
 org.eclipse.jdt.core.formatter.insert_space_before_question_in_wildcard=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_relational_operator=insert
 org.eclipse.jdt.core.formatter.insert_space_before_semicolon=do not insert
 org.eclipse.jdt.core.formatter.insert_space_before_semicolon_in_for=do not insert
 org.eclipse.jdt.core.formatter.insert_space_before_semicolon_in_try_resources=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_shift_operator=insert
+org.eclipse.jdt.core.formatter.insert_space_before_string_concatenation=insert
 org.eclipse.jdt.core.formatter.insert_space_before_unary_operator=do not insert
 org.eclipse.jdt.core.formatter.insert_space_between_brackets_in_array_type_reference=do not insert
 org.eclipse.jdt.core.formatter.insert_space_between_empty_braces_in_array_initializer=do not insert
@@ -398,14 +436,33 @@
 org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_method_invocation=do not insert
 org.eclipse.jdt.core.formatter.join_lines_in_comments=true
 org.eclipse.jdt.core.formatter.join_wrapped_lines=true
+org.eclipse.jdt.core.formatter.keep_annotation_declaration_on_one_line=one_line_never
+org.eclipse.jdt.core.formatter.keep_anonymous_type_declaration_on_one_line=one_line_never
+org.eclipse.jdt.core.formatter.keep_code_block_on_one_line=one_line_never
 org.eclipse.jdt.core.formatter.keep_else_statement_on_same_line=false
 org.eclipse.jdt.core.formatter.keep_empty_array_initializer_on_one_line=false
+org.eclipse.jdt.core.formatter.keep_enum_constant_declaration_on_one_line=one_line_never
+org.eclipse.jdt.core.formatter.keep_enum_declaration_on_one_line=one_line_never
+org.eclipse.jdt.core.formatter.keep_if_then_body_block_on_one_line=one_line_never
 org.eclipse.jdt.core.formatter.keep_imple_if_on_one_line=false
+org.eclipse.jdt.core.formatter.keep_lambda_body_block_on_one_line=one_line_never
+org.eclipse.jdt.core.formatter.keep_loop_body_block_on_one_line=one_line_never
+org.eclipse.jdt.core.formatter.keep_method_body_on_one_line=one_line_never
+org.eclipse.jdt.core.formatter.keep_simple_do_while_body_on_same_line=false
+org.eclipse.jdt.core.formatter.keep_simple_for_body_on_same_line=false
+org.eclipse.jdt.core.formatter.keep_simple_getter_setter_on_one_line=false
+org.eclipse.jdt.core.formatter.keep_simple_while_body_on_same_line=false
 org.eclipse.jdt.core.formatter.keep_then_statement_on_same_line=false
+org.eclipse.jdt.core.formatter.keep_type_declaration_on_one_line=one_line_never
 org.eclipse.jdt.core.formatter.lineSplit=120
 org.eclipse.jdt.core.formatter.never_indent_block_comments_on_first_column=false
 org.eclipse.jdt.core.formatter.never_indent_line_comments_on_first_column=false
+org.eclipse.jdt.core.formatter.number_of_blank_lines_after_code_block=0
+org.eclipse.jdt.core.formatter.number_of_blank_lines_at_beginning_of_code_block=0
 org.eclipse.jdt.core.formatter.number_of_blank_lines_at_beginning_of_method_body=0
+org.eclipse.jdt.core.formatter.number_of_blank_lines_at_end_of_code_block=0
+org.eclipse.jdt.core.formatter.number_of_blank_lines_at_end_of_method_body=0
+org.eclipse.jdt.core.formatter.number_of_blank_lines_before_code_block=0
 org.eclipse.jdt.core.formatter.number_of_empty_lines_to_preserve=1
 org.eclipse.jdt.core.formatter.parentheses_positions_in_annotation=common_lines
 org.eclipse.jdt.core.formatter.parentheses_positions_in_catch_clause=common_lines
@@ -420,12 +477,20 @@
 org.eclipse.jdt.core.formatter.put_empty_statement_on_new_line=true
 org.eclipse.jdt.core.formatter.tabulation.char=tab
 org.eclipse.jdt.core.formatter.tabulation.size=4
+org.eclipse.jdt.core.formatter.text_block_indentation=0
 org.eclipse.jdt.core.formatter.use_on_off_tags=false
 org.eclipse.jdt.core.formatter.use_tabs_only_for_leading_indentations=false
+org.eclipse.jdt.core.formatter.wrap_before_additive_operator=true
 org.eclipse.jdt.core.formatter.wrap_before_assignment_operator=false
 org.eclipse.jdt.core.formatter.wrap_before_binary_operator=true
+org.eclipse.jdt.core.formatter.wrap_before_bitwise_operator=true
 org.eclipse.jdt.core.formatter.wrap_before_conditional_operator=true
+org.eclipse.jdt.core.formatter.wrap_before_logical_operator=true
+org.eclipse.jdt.core.formatter.wrap_before_multiplicative_operator=true
 org.eclipse.jdt.core.formatter.wrap_before_or_operator_multicatch=true
+org.eclipse.jdt.core.formatter.wrap_before_relational_operator=true
+org.eclipse.jdt.core.formatter.wrap_before_shift_operator=true
+org.eclipse.jdt.core.formatter.wrap_before_string_concatenation=true
 org.eclipse.jdt.core.formatter.wrap_outer_expressions_when_nested=true
 org.eclipse.jdt.core.incompatibleJDKLevel=ignore
 org.eclipse.jdt.core.incompleteClasspath=error
diff --git a/bundles/org.eclipse.equinox.common.tests/.settings/org.eclipse.jdt.ui.prefs b/bundles/org.eclipse.equinox.common.tests/.settings/org.eclipse.jdt.ui.prefs
new file mode 100644
index 0000000..777af58
--- /dev/null
+++ b/bundles/org.eclipse.equinox.common.tests/.settings/org.eclipse.jdt.ui.prefs
@@ -0,0 +1,70 @@
+eclipse.preferences.version=1
+editor_save_participant_org.eclipse.jdt.ui.postsavelistener.cleanup=true
+formatter_profile=org.eclipse.jdt.ui.default.eclipse_profile
+formatter_settings_version=18
+sp_cleanup.add_default_serial_version_id=true
+sp_cleanup.add_generated_serial_version_id=false
+sp_cleanup.add_missing_annotations=true
+sp_cleanup.add_missing_deprecated_annotations=true
+sp_cleanup.add_missing_methods=false
+sp_cleanup.add_missing_nls_tags=false
+sp_cleanup.add_missing_override_annotations=true
+sp_cleanup.add_missing_override_annotations_interface_methods=true
+sp_cleanup.add_serial_version_id=false
+sp_cleanup.always_use_blocks=true
+sp_cleanup.always_use_parentheses_in_expressions=false
+sp_cleanup.always_use_this_for_non_static_field_access=false
+sp_cleanup.always_use_this_for_non_static_method_access=false
+sp_cleanup.convert_functional_interfaces=true
+sp_cleanup.convert_to_enhanced_for_loop=true
+sp_cleanup.correct_indentation=false
+sp_cleanup.format_source_code=true
+sp_cleanup.format_source_code_changes_only=true
+sp_cleanup.insert_inferred_type_arguments=false
+sp_cleanup.make_local_variable_final=true
+sp_cleanup.make_parameters_final=false
+sp_cleanup.make_private_fields_final=true
+sp_cleanup.make_type_abstract_if_missing_method=false
+sp_cleanup.make_variable_declarations_final=false
+sp_cleanup.never_use_blocks=false
+sp_cleanup.never_use_parentheses_in_expressions=true
+sp_cleanup.number_suffix=false
+sp_cleanup.on_save_use_additional_actions=true
+sp_cleanup.organize_imports=true
+sp_cleanup.push_down_negation=false
+sp_cleanup.qualify_static_field_accesses_with_declaring_class=false
+sp_cleanup.qualify_static_member_accesses_through_instances_with_declaring_class=true
+sp_cleanup.qualify_static_member_accesses_through_subtypes_with_declaring_class=true
+sp_cleanup.qualify_static_member_accesses_with_declaring_class=false
+sp_cleanup.qualify_static_method_accesses_with_declaring_class=false
+sp_cleanup.remove_private_constructors=true
+sp_cleanup.remove_redundant_modifiers=true
+sp_cleanup.remove_redundant_semicolons=true
+sp_cleanup.remove_redundant_type_arguments=true
+sp_cleanup.remove_trailing_whitespaces=true
+sp_cleanup.remove_trailing_whitespaces_all=true
+sp_cleanup.remove_trailing_whitespaces_ignore_empty=false
+sp_cleanup.remove_unnecessary_array_creation=true
+sp_cleanup.remove_unnecessary_casts=true
+sp_cleanup.remove_unnecessary_nls_tags=false
+sp_cleanup.remove_unused_imports=false
+sp_cleanup.remove_unused_local_variables=false
+sp_cleanup.remove_unused_private_fields=true
+sp_cleanup.remove_unused_private_members=false
+sp_cleanup.remove_unused_private_methods=true
+sp_cleanup.remove_unused_private_types=true
+sp_cleanup.simplify_lambda_expression_and_method_ref=false
+sp_cleanup.sort_members=false
+sp_cleanup.sort_members_all=false
+sp_cleanup.use_anonymous_class_creation=false
+sp_cleanup.use_autoboxing=false
+sp_cleanup.use_blocks=false
+sp_cleanup.use_blocks_only_for_return_and_throw=false
+sp_cleanup.use_directly_map_method=false
+sp_cleanup.use_lambda=true
+sp_cleanup.use_parentheses_in_expressions=false
+sp_cleanup.use_this_for_non_static_field_access=false
+sp_cleanup.use_this_for_non_static_field_access_only_if_necessary=true
+sp_cleanup.use_this_for_non_static_method_access=false
+sp_cleanup.use_this_for_non_static_method_access_only_if_necessary=true
+sp_cleanup.use_unboxing=false
diff --git a/bundles/org.eclipse.equinox.common.tests/src/org/eclipse/equinox/common/tests/PathTest.java b/bundles/org.eclipse.equinox.common.tests/src/org/eclipse/equinox/common/tests/PathTest.java
index f206258..a94d01d 100644
--- a/bundles/org.eclipse.equinox.common.tests/src/org/eclipse/equinox/common/tests/PathTest.java
+++ b/bundles/org.eclipse.equinox.common.tests/src/org/eclipse/equinox/common/tests/PathTest.java
@@ -15,6 +15,7 @@
 package org.eclipse.equinox.common.tests;
 
 import java.util.ArrayList;
+
 import org.eclipse.core.runtime.IPath;
 import org.eclipse.core.runtime.Path;
 import org.eclipse.core.tests.harness.CoreTest;
@@ -81,9 +82,9 @@
 		assertEquals("1.0", combo, fore.append(aft));
 		assertEquals("1.1", combo, fore.removeTrailingSeparator().append(aft));
 		assertEquals("1.2", combo, Path.ROOT.append(fore).append(aft));
-		assertTrue("1.3", !fore.append(aft).hasTrailingSeparator());
-		assertTrue("1.4", !Path.ROOT.append(fore).append(aft).hasTrailingSeparator());
-		assertTrue("1.5", !fore.removeTrailingSeparator().append(aft).hasTrailingSeparator());
+		assertFalse("1.3", fore.append(aft).hasTrailingSeparator());
+		assertFalse("1.4", Path.ROOT.append(fore).append(aft).hasTrailingSeparator());
+		assertFalse("1.5", fore.removeTrailingSeparator().append(aft).hasTrailingSeparator());
 		// append empty and root path together
 		assertEquals("1.6", Path.EMPTY, Path.EMPTY.append(Path.EMPTY));
 		assertEquals("1.7", Path.EMPTY, Path.EMPTY.append(Path.ROOT));
diff --git a/bundles/org.eclipse.equinox.common.tests/src/org/eclipse/equinox/common/tests/SubMonitorSmallTicksTest.java b/bundles/org.eclipse.equinox.common.tests/src/org/eclipse/equinox/common/tests/SubMonitorSmallTicksTest.java
index 535fe1e..05a834b 100644
--- a/bundles/org.eclipse.equinox.common.tests/src/org/eclipse/equinox/common/tests/SubMonitorSmallTicksTest.java
+++ b/bundles/org.eclipse.equinox.common.tests/src/org/eclipse/equinox/common/tests/SubMonitorSmallTicksTest.java
@@ -13,29 +13,29 @@
  *******************************************************************************/
 package org.eclipse.equinox.common.tests;
 
-import junit.framework.TestCase;
 import org.eclipse.core.runtime.SubMonitor;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
 
 /**
  * Ensures that creating a SubMonitor with a small number of
  * ticks will not prevent it from reporting accurate progress.
  */
-public class SubMonitorSmallTicksTest extends TestCase {
+public class SubMonitorSmallTicksTest {
 
 	private TestProgressMonitor topmostMonitor;
 	private SubMonitor smallTicksChild;
-	private long startTime;
 
 	private static int TOTAL_WORK = 1000;
 
-	@Override
-	protected void setUp() throws Exception {
+	@Before
+	public void setUp() throws Exception {
 		topmostMonitor = new TestProgressMonitor();
 		smallTicksChild = SubMonitor.convert(topmostMonitor, 10);
-		super.setUp();
-		startTime = System.currentTimeMillis();
 	}
 
+	@Test
 	public void testWorked() {
 		SubMonitor bigTicksChild = smallTicksChild.newChild(10).setWorkRemaining(TOTAL_WORK);
 		for (int i = 0; i < TOTAL_WORK; i++) {
@@ -44,6 +44,7 @@
 		bigTicksChild.done();
 	}
 
+	@Test
 	public void testInternalWorked() {
 		double delta = 10.0d / TOTAL_WORK;
 
@@ -52,6 +53,7 @@
 		}
 	}
 
+	@Test
 	public void testSplit() {
 		SubMonitor bigTicksChild = smallTicksChild.newChild(10).setWorkRemaining(TOTAL_WORK);
 		for (int i = 0; i < TOTAL_WORK; i++) {
@@ -60,14 +62,11 @@
 		bigTicksChild.done();
 	}
 
-	@Override
-	protected void tearDown() throws Exception {
+	@After
+	public void tearDown() throws Exception {
 		smallTicksChild.done();
 		topmostMonitor.done();
-		long endTime = System.currentTimeMillis();
-		SubMonitorTest.reportPerformance(getClass().getName(), getName(), startTime, endTime);
 		topmostMonitor.assertOptimal();
-		super.tearDown();
 	}
 
 }
diff --git a/bundles/org.eclipse.equinox.common.tests/src/org/eclipse/equinox/common/tests/SubMonitorTest.java b/bundles/org.eclipse.equinox.common.tests/src/org/eclipse/equinox/common/tests/SubMonitorTest.java
index d1da645..9e6a8bd 100644
--- a/bundles/org.eclipse.equinox.common.tests/src/org/eclipse/equinox/common/tests/SubMonitorTest.java
+++ b/bundles/org.eclipse.equinox.common.tests/src/org/eclipse/equinox/common/tests/SubMonitorTest.java
@@ -18,63 +18,61 @@
  *******************************************************************************/
 package org.eclipse.equinox.common.tests;
 
-import java.util.*;
-import junit.framework.TestCase;
-import org.eclipse.core.runtime.*;
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertThrows;
+import static org.junit.Assert.assertTrue;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Map;
+
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.core.runtime.NullProgressMonitor;
+import org.eclipse.core.runtime.OperationCanceledException;
+import org.eclipse.core.runtime.SubMonitor;
 import org.junit.Assert;
+import org.junit.Test;
 
-/**
- *
- */
-public class SubMonitorTest extends TestCase {
+public class SubMonitorTest {
 
-	private long startTime;
 	/**
-	 * <p>Number of calls to worked() within each test. This was chosen to be significantly larger
-	 * than 1000 to test how well the monitor can optimize unnecessary resolution
-	 * in reported progress, but small enough that the test completes in a reasonable
-	 * amount of time.</p>
+	 * <p>
+	 * Number of calls to worked() within each test. This was chosen to be
+	 * significantly larger than 1000 to test how well the monitor can optimize
+	 * unnecessary resolution in reported progress, but small enough that the test
+	 * completes in a reasonable amount of time.
+	 * </p>
 	 *
-	 * <p>Note: changing this constant will invalidate comparisons with old performance data.</p>
+	 * <p>
+	 * Note: changing this constant will invalidate comparisons with old performance
+	 * data.
+	 * </p>
 	 */
 	public static final int PROGRESS_SIZE = SubProgressTest.PROGRESS_SIZE;
 	/**
-	 * <p>Depth of the chain chain of progress monitors. In all of the tests, we create
+	 * <p>
+	 * Depth of the chain chain of progress monitors. In all of the tests, we create
 	 * a nested chain of progress monitors rather than a single monitor, to test its
 	 * scalability under recursion. We pick a number representing a moderately deep
-	 * recursion, but is still small enough that it could correspond to a real call stack
-	 * without causing overflow.</p>
+	 * recursion, but is still small enough that it could correspond to a real call
+	 * stack without causing overflow.
+	 * </p>
 	 *
-	 * <p>Note: changing this constant will invalidate comparisons with old performance data.</p>
+	 * <p>
+	 * Note: changing this constant will invalidate comparisons with old performance
+	 * data.
+	 * </p>
 	 */
 	public static final int CHAIN_DEPTH = SubProgressTest.CHAIN_DEPTH;
 
-	public SubMonitorTest() {
-		super();
-	}
-
-	public SubMonitorTest(String name) {
-		super(name);
-	}
-
-	@Override
-	protected void setUp() throws Exception {
-		startTime = System.currentTimeMillis();
-		super.setUp();
-	}
-
-	@Override
-	protected void tearDown() throws Exception {
-		long endTime = System.currentTimeMillis();
-		reportPerformance(getClass().getName(), getName(), startTime, endTime);
-		super.tearDown();
-	}
-
 	/**
-	 * Reports progress by iterating over a loop of the given size, reporting 1 progress
-	 * at each iteration. Simulates the progress of worked(int) in loops.
+	 * Reports progress by iterating over a loop of the given size, reporting 1
+	 * progress at each iteration. Simulates the progress of worked(int) in loops.
 	 *
-	 * @param monitor progress monitor (callers are responsible for calling done() if necessary)
+	 * @param monitor  progress monitor (callers are responsible for calling done()
+	 *                 if necessary)
 	 * @param loopSize size of the loop
 	 */
 	private static void reportWorkInLoop(IProgressMonitor monitor, int loopSize) {
@@ -85,10 +83,12 @@
 	}
 
 	/**
-	 * Reports progress by iterating over a loop of the given size, reporting 1 progress
-	 * at each iteration. Simulates the progress of internalWorked(double) in loops.
+	 * Reports progress by iterating over a loop of the given size, reporting 1
+	 * progress at each iteration. Simulates the progress of internalWorked(double)
+	 * in loops.
 	 *
-	 * @param monitor progress monitor (callers are responsible for calling done() if necessary)
+	 * @param monitor  progress monitor (callers are responsible for calling done()
+	 *                 if necessary)
 	 * @param loopSize size of the loop
 	 */
 	private static void reportFloatingPointWorkInLoop(IProgressMonitor monitor, int loopSize) {
@@ -99,9 +99,9 @@
 	}
 
 	/**
-	 * Runs an "infinite progress" loop. Each iteration will consume 1/ratio
-	 * of the remaining work, and will run for the given number of iterations.
-	 * Retuns the number of ticks reported (out of 1000).
+	 * Runs an "infinite progress" loop. Each iteration will consume 1/ratio of the
+	 * remaining work, and will run for the given number of iterations. Retuns the
+	 * number of ticks reported (out of 1000).
 	 *
 	 * @param ratio
 	 * @return the number of ticks reported
@@ -118,8 +118,10 @@
 		return monitor.getTotalWork();
 	}
 
+	@Test
 	public void testInfiniteProgress() {
-		// In theory when reporting "infinite" progress, the actual progress reported after
+		// In theory when reporting "infinite" progress, the actual progress reported
+		// after
 		// n iterations should be f(n) = T(1-(1-R)^n)
 		//
 		// where T is the total ticks allocated on the root (T=1000) and R is the ratio
@@ -129,15 +131,18 @@
 		double test1 = runInfiniteProgress(100, 500);
 		assertEquals(993.4, test1, 1.0);
 
-		// Reporting 0.1% per iteration, we should be at 950.2 ticks after 3000 iterations
+		// Reporting 0.1% per iteration, we should be at 950.2 ticks after 3000
+		// iterations
 		double test2 = runInfiniteProgress(1000, 3000);
 		assertEquals(950.2, test2, 1.0);
 
-		// Reporting 0.01% per iteration, we should be at 393.5 ticks after 5000 iterations
+		// Reporting 0.01% per iteration, we should be at 393.5 ticks after 5000
+		// iterations
 		double test3 = runInfiniteProgress(10000, 5000);
 		assertEquals(393.5, test3, 1.0);
 
-		// Reporting 0.01% per iteration, we should be at 864.7 ticks after 20000 iterations
+		// Reporting 0.01% per iteration, we should be at 864.7 ticks after 20000
+		// iterations
 		double test4 = runInfiniteProgress(10000, 20000);
 		assertEquals(864.7, test4, 1.0);
 
@@ -152,6 +157,7 @@
 	/**
 	 * Ensures that we don't lose any progress when calling setWorkRemaining
 	 */
+	@Test
 	public void testSetWorkRemaining() {
 		TestProgressMonitor monitor = new TestProgressMonitor();
 		SubMonitor mon = SubMonitor.convert(monitor, 0);
@@ -171,9 +177,10 @@
 	}
 
 	/**
-	 * Tests that SubMonitor.done() will clean up after an unconsumed child
-	 * that was created with the explicit constructor
+	 * Tests that SubMonitor.done() will clean up after an unconsumed child that was
+	 * created with the explicit constructor
 	 */
+	@Test
 	public void testCleanupConstructedChildren() {
 		TestProgressMonitor top = new TestProgressMonitor();
 
@@ -185,7 +192,8 @@
 
 		child2.done();
 
-		Assert.assertEquals("Ensure that done() reports unconsumed progress, even if beginTask wasn't called", 600.0, top.getTotalWork(), 0.01d);
+		assertEquals("Ensure that done() reports unconsumed progress, even if beginTask wasn't called", 600.0,
+				top.getTotalWork(), 0.01d);
 
 		SubMonitor child3 = monitor.newChild(100);
 
@@ -194,18 +202,20 @@
 
 		monitor.done();
 
-		Assert.assertEquals("Ensure that done() cleans up after unconsumed children that were created by their constructor", 1000.0, top.getTotalWork(), 0.01d);
+		assertEquals("Ensure that done() cleans up after unconsumed children that were created by their constructor",
+				1000.0, top.getTotalWork(), 0.01d);
 
 		child3.worked(100);
 
-		Assert.assertEquals("Ensure that children can't report any progress if their parent has completed", 1000.0, top.getTotalWork(), 0.01d);
+		assertEquals("Ensure that children can't report any progress if their parent has completed", 1000.0,
+				top.getTotalWork(), 0.01d);
 	}
 
 	/**
-	 * Tests SubMonitor under typical usage. This is the same
-	 * as the performance test as the same name, but it verifies correctness
-	 * rather than performance.
+	 * Tests SubMonitor under typical usage. This is the same as the performance
+	 * test as the same name, but it verifies correctness rather than performance.
 	 */
+	@Test
 	public void testTypicalUsage() {
 		TestProgressMonitor monitor = new TestProgressMonitor();
 		SubMonitorTest.runTestTypicalUsage(monitor);
@@ -213,10 +223,10 @@
 	}
 
 	/**
-	 * Tests creating a tree of SubMonitors. This is the same
-	 * as the performance test as the same name, but it verifies correctness
-	 * rather than performance.
+	 * Tests creating a tree of SubMonitors. This is the same as the performance
+	 * test as the same name, but it verifies correctness rather than performance.
 	 */
+	@Test
 	public void testCreateTree() {
 		TestProgressMonitor monitor = new TestProgressMonitor();
 		SubMonitorTest.runTestCreateTree(monitor);
@@ -226,6 +236,7 @@
 	/**
 	 * Tests claimed problem reported in bug 2100394.
 	 */
+	@Test
 	public void testBug210394() {
 		TestProgressMonitor testMonitor = new TestProgressMonitor();
 		SubMonitor monitor = SubMonitor.convert(testMonitor);
@@ -252,24 +263,25 @@
 	}
 
 	/**
-	 * Ensures that SubMonitor won't report more than 100% progress
-	 * when a child is created with more than the amount of available progress.
+	 * Ensures that SubMonitor won't report more than 100% progress when a child is
+	 * created with more than the amount of available progress.
 	 */
+	@Test
 	public void testChildOverflow() {
 		TestProgressMonitor top = new TestProgressMonitor();
 
 		SubMonitor mon1 = SubMonitor.convert(top, 1000);
-		Assert.assertEquals(0.0, top.getTotalWork(), 0.1d);
+		assertEquals(0.0, top.getTotalWork(), 0.1d);
 
 		SubMonitor child2 = mon1.newChild(700);
 		child2.done();
 
-		Assert.assertEquals(700.0, top.getTotalWork(), 0.1d);
+		assertEquals(700.0, top.getTotalWork(), 0.1d);
 
 		SubMonitor child3 = mon1.newChild(700);
 		child3.done();
 
-		Assert.assertEquals("The reported work should not exceed 1000", 1000.0, top.getTotalWork(), 0.1d);
+		assertEquals("The reported work should not exceed 1000", 1000.0, top.getTotalWork(), 0.1d);
 
 		mon1.done();
 
@@ -279,45 +291,48 @@
 	/**
 	 * Tests the 1-argument convert(...) method
 	 */
+	@Test
 	public void testConvert() {
 		TestProgressMonitor top = new TestProgressMonitor();
 		SubMonitor mon1 = SubMonitor.convert(top);
-		Assert.assertEquals(0.0, top.getTotalWork(), 0.1d);
+		assertEquals(0.0, top.getTotalWork(), 0.1d);
 		mon1.worked(10);
-		Assert.assertEquals(0.0, top.getTotalWork(), 0.1d);
+		assertEquals(0.0, top.getTotalWork(), 0.1d);
 		mon1.setWorkRemaining(100);
 		mon1.worked(50);
-		Assert.assertEquals(500.0, top.getTotalWork(), 0.1d);
+		assertEquals(500.0, top.getTotalWork(), 0.1d);
 		mon1.done();
-		Assert.assertEquals(1000.0, top.getTotalWork(), 0.1d);
+		assertEquals(1000.0, top.getTotalWork(), 0.1d);
 		top.done();
 	}
 
 	/**
 	 * Tests the function of the SUPPRESS_* flags
 	 */
+	@Test
 	public void testFlags() {
 		TestProgressMonitor top = new TestProgressMonitor();
 
 		SubMonitor mon1 = SubMonitor.convert(top, "initial", 100);
 
 		// Ensure that we've called begintask on the root with the correct argument
-		Assert.assertEquals(top.getBeginTaskCalls(), 1);
-		Assert.assertEquals(top.getBeginTaskName(), "initial");
+		assertEquals(top.getBeginTaskCalls(), 1);
+		assertEquals(top.getBeginTaskName(), "initial");
 
 		mon1.beginTask("beginTask", 1000);
 
-		// Ensure that beginTask on the child does NOT result in more than 1 call to beginTask on the root
-		Assert.assertEquals(top.getBeginTaskCalls(), 1);
+		// Ensure that beginTask on the child does NOT result in more than 1 call to
+		// beginTask on the root
+		assertEquals(top.getBeginTaskCalls(), 1);
 
 		// Ensure that the task name was propogated correctly
-		Assert.assertEquals(top.getTaskName(), "beginTask");
+		assertEquals(top.getTaskName(), "beginTask");
 
 		mon1.setTaskName("setTaskName");
-		Assert.assertEquals(top.getTaskName(), "setTaskName");
+		assertEquals(top.getTaskName(), "setTaskName");
 
 		mon1.subTask("subTask");
-		Assert.assertEquals(top.getSubTaskName(), "subTask");
+		assertEquals(top.getSubTaskName(), "subTask");
 
 		// Create a child monitor that permits calls to beginTask
 		{
@@ -325,13 +340,13 @@
 
 			// Ensure that everything is propogated
 			mon2.beginTask("mon2.beginTask", 100);
-			Assert.assertEquals(top.getTaskName(), "mon2.beginTask");
+			assertEquals(top.getTaskName(), "mon2.beginTask");
 
 			mon2.setTaskName("mon2.setTaskName");
-			Assert.assertEquals(top.getTaskName(), "mon2.setTaskName");
+			assertEquals(top.getTaskName(), "mon2.setTaskName");
 
 			mon2.subTask("mon2.subTask");
-			Assert.assertEquals(top.getSubTaskName(), "mon2.subTask");
+			assertEquals(top.getSubTaskName(), "mon2.subTask");
 		}
 	}
 
@@ -346,17 +361,15 @@
 		return results.toArray(new String[results.size()]);
 	}
 
+	@Test
 	public void testSplitPerformsAutoCancel() {
 		NullProgressMonitor npm = new NullProgressMonitor();
 		npm.setCanceled(true);
 		SubMonitor subMonitor = SubMonitor.convert(npm, 1000);
-		try {
-			subMonitor.split(500);
-			fail("split should have thrown an exception");
-		} catch (OperationCanceledException exception) {
-		}
+		assertThrows(OperationCanceledException.class, () -> subMonitor.split(500));
 	}
 
+	@Test
 	public void testNewChildDoesNotAutoCancel() {
 		NullProgressMonitor npm = new NullProgressMonitor();
 		npm.setCanceled(true);
@@ -364,12 +377,14 @@
 		subMonitor.newChild(500);
 	}
 
+	@Test
 	public void testSplitDoesNotThrowExceptionIfParentNotCanceled() {
 		NullProgressMonitor npm = new NullProgressMonitor();
 		SubMonitor subMonitor = SubMonitor.convert(npm, 1000);
 		subMonitor.split(500);
 	}
 
+	@Test
 	public void testAutoCancelDoesNothingForTrivialConversions() {
 		NullProgressMonitor npm = new NullProgressMonitor();
 		npm.setCanceled(true);
@@ -377,6 +392,7 @@
 		subMonitor.split(1000);
 	}
 
+	@Test
 	public void testAutoCancelDoesNothingForSingleTrivialOperation() {
 		NullProgressMonitor npm = new NullProgressMonitor();
 		npm.setCanceled(true);
@@ -384,57 +400,57 @@
 		subMonitor.split(0);
 	}
 
+	@Test
 	public void testAutoCancelThrowsExceptionEventuallyForManyTrivialOperations() {
 		NullProgressMonitor npm = new NullProgressMonitor();
 		npm.setCanceled(true);
 		SubMonitor subMonitor = SubMonitor.convert(npm, 1000);
-		try {
+		assertThrows(OperationCanceledException.class, () -> {
 			for (int counter = 0; counter < 1000; counter++) {
 				subMonitor.split(0);
 			}
-			fail("split should have thrown an exception");
-		} catch (OperationCanceledException exception) {
-		}
+		});
 	}
 
+	@Test
 	public void testConsumingEndOfMonitorNotTreatedAsTrivial() {
 		NullProgressMonitor npm = new NullProgressMonitor();
 		SubMonitor subMonitor = SubMonitor.convert(npm, 1000);
 		subMonitor.newChild(500);
-		try {
-			npm.setCanceled(true);
-			subMonitor.split(500);
-			fail("split should have thrown an exception");
-		} catch (OperationCanceledException exception) {
-		}
+		npm.setCanceled(true);
+		assertThrows(OperationCanceledException.class, () -> subMonitor.split(500));
 	}
 
+	@Test
 	public void testIsCanceled() {
 		NullProgressMonitor npm = new NullProgressMonitor();
 		SubMonitor subMonitor = SubMonitor.convert(npm);
-		assertTrue("subMonitor should not be canceled", !subMonitor.isCanceled());
+		assertFalse("subMonitor should not be canceled", subMonitor.isCanceled());
 		npm.setCanceled(true);
 		assertTrue("subMonitor should be canceled", subMonitor.isCanceled());
 	}
 
+	@Test
 	public void testSuppressIsCanceled() {
 		NullProgressMonitor npm = new NullProgressMonitor();
 		SubMonitor subMonitor = SubMonitor.convert(npm).newChild(0, SubMonitor.SUPPRESS_ISCANCELED);
 
-		assertTrue("subMonitor should not be canceled", !subMonitor.isCanceled());
+		assertFalse("subMonitor should not be canceled", subMonitor.isCanceled());
 		npm.setCanceled(true);
-		assertTrue("subMonitor should not be canceled", !subMonitor.isCanceled());
+		assertFalse("subMonitor should not be canceled", subMonitor.isCanceled());
 	}
 
+	@Test
 	public void testSuppressIsCanceledFlagIsInherited() {
 		NullProgressMonitor npm = new NullProgressMonitor();
 		SubMonitor subMonitor = SubMonitor.convert(npm).newChild(0, SubMonitor.SUPPRESS_ISCANCELED).newChild(0);
 
-		assertTrue("subMonitor should not be canceled", !subMonitor.isCanceled());
+		assertFalse("subMonitor should not be canceled", subMonitor.isCanceled());
 		npm.setCanceled(true);
-		assertTrue("subMonitor should not be canceled", !subMonitor.isCanceled());
+		assertFalse("subMonitor should not be canceled", subMonitor.isCanceled());
 	}
 
+	@Test
 	public void testSuppressIsCanceledAffectsSplit() {
 		NullProgressMonitor npm = new NullProgressMonitor();
 		SubMonitor subMonitor = SubMonitor.convert(npm, 100).newChild(100, SubMonitor.SUPPRESS_ISCANCELED);
@@ -446,83 +462,88 @@
 	/**
 	 * Tests the style bits in SubProgressMonitor
 	 */
+	@Test
 	public void testStyles() {
 
-		int[] styles = new int[] {SubMonitor.SUPPRESS_NONE, SubMonitor.SUPPRESS_BEGINTASK, SubMonitor.SUPPRESS_SETTASKNAME, SubMonitor.SUPPRESS_SUBTASK, SubMonitor.SUPPRESS_BEGINTASK | SubMonitor.SUPPRESS_SETTASKNAME, SubMonitor.SUPPRESS_BEGINTASK | SubMonitor.SUPPRESS_SUBTASK, SubMonitor.SUPPRESS_SETTASKNAME | SubMonitor.SUPPRESS_SUBTASK, SubMonitor.SUPPRESS_ALL_LABELS};
+		int[] styles = new int[] { SubMonitor.SUPPRESS_NONE, SubMonitor.SUPPRESS_BEGINTASK,
+				SubMonitor.SUPPRESS_SETTASKNAME, SubMonitor.SUPPRESS_SUBTASK,
+				SubMonitor.SUPPRESS_BEGINTASK | SubMonitor.SUPPRESS_SETTASKNAME,
+				SubMonitor.SUPPRESS_BEGINTASK | SubMonitor.SUPPRESS_SUBTASK,
+				SubMonitor.SUPPRESS_SETTASKNAME | SubMonitor.SUPPRESS_SUBTASK, SubMonitor.SUPPRESS_ALL_LABELS };
 
 		HashMap<String, String[]> expected = new HashMap<>();
-		expected.put("style 5 below style 7", new String[] {"", "", ""});
-		expected.put("style 7 below style 5", new String[] {"beginTask0", "", "beginTask0"});
-		expected.put("style 7 below style 4", new String[] {"beginTask0", "subTask0", "beginTask0"});
-		expected.put("style 5 below style 6", new String[] {"", "subTask0", ""});
-		expected.put("style 3 below style 7", new String[] {"", "", ""});
-		expected.put("style 5 below style 5", new String[] {"beginTask0", "", "beginTask0"});
-		expected.put("style 7 below style 3", new String[] {"setTaskName0", "", "setTaskName0"});
-		expected.put("style 7 below style 2", new String[] {"setTaskName0", "subTask0", "setTaskName0"});
-		expected.put("style 5 below style 4", new String[] {"beginTask0", "subTask0", "beginTask0"});
-		expected.put("style 3 below style 6", new String[] {"", "subTask0", ""});
-		expected.put("style 1 below style 7", new String[] {"", "", ""});
-		expected.put("style 3 below style 5", new String[] {"beginTask0", "", "beginTask0"});
-		expected.put("style 5 below style 3", new String[] {"beginTask1", "", "beginTask1"});
-		expected.put("style 7 below style 1", new String[] {"setTaskName0", "", "setTaskName0"});
-		expected.put("style 3 below style 4", new String[] {"beginTask0", "subTask0", "beginTask0"});
-		expected.put("style 5 below style 2", new String[] {"beginTask1", "subTask0", "beginTask1"});
-		expected.put("style 7 below style 0", new String[] {"setTaskName0", "subTask0", "setTaskName0"});
-		expected.put("style 1 below style 6", new String[] {"", "subTask0", ""});
-		expected.put("style 1 below style 5", new String[] {"beginTask0", "", "beginTask0"});
-		expected.put("style 3 below style 3", new String[] {"setTaskName0", "", "setTaskName1"});
-		expected.put("style 5 below style 1", new String[] {"beginTask1", "", "beginTask1"});
-		expected.put("style 1 below style 4", new String[] {"beginTask0", "subTask0", "beginTask0"});
-		expected.put("style 3 below style 2", new String[] {"setTaskName0", "subTask0", "setTaskName1"});
-		expected.put("style 5 below style 0", new String[] {"beginTask1", "subTask0", "beginTask1"});
-		expected.put("style 1 below style 3", new String[] {"beginTask1", "", "setTaskName1"});
-		expected.put("style 3 below style 1", new String[] {"setTaskName0", "", "setTaskName1"});
-		expected.put("style 1 below style 2", new String[] {"beginTask1", "subTask0", "setTaskName1"});
-		expected.put("style 3 below style 0", new String[] {"setTaskName0", "subTask0", "setTaskName1"});
-		expected.put("style 1 below style 1", new String[] {"beginTask1", "", "setTaskName1"});
-		expected.put("style 1 below style 0", new String[] {"beginTask1", "subTask0", "setTaskName1"});
-		expected.put("style 3 as top-level monitor", new String[] {"", "", "setTaskName0"});
-		expected.put("style 7 as top-level monitor", new String[] {"", "", ""});
-		expected.put("style 2 as top-level monitor", new String[] {"", "subTask0", "setTaskName0"});
-		expected.put("style 6 as top-level monitor", new String[] {"", "subTask0", ""});
-		expected.put("style 6 below style 7", new String[] {"", "", ""});
-		expected.put("style 6 below style 6", new String[] {"", "subTask1", ""});
-		expected.put("style 4 below style 7", new String[] {"", "", ""});
-		expected.put("style 6 below style 5", new String[] {"beginTask0", "", "beginTask0"});
-		expected.put("style 6 below style 4", new String[] {"beginTask0", "subTask1", "beginTask0"});
-		expected.put("style 4 below style 6", new String[] {"", "subTask1", ""});
-		expected.put("style 2 below style 7", new String[] {"", "", ""});
-		expected.put("style 4 below style 5", new String[] {"beginTask0", "", "beginTask0"});
-		expected.put("style 6 below style 3", new String[] {"setTaskName0", "", "setTaskName0"});
-		expected.put("style 4 below style 4", new String[] {"beginTask0", "subTask1", "beginTask0"});
-		expected.put("style 6 below style 2", new String[] {"setTaskName0", "subTask1", "setTaskName0"});
-		expected.put("style 2 below style 6", new String[] {"", "subTask1", ""});
-		expected.put("style 0 below style 7", new String[] {"", "", ""});
-		expected.put("style 2 below style 5", new String[] {"beginTask0", "", "beginTask0"});
-		expected.put("style 6 below style 1", new String[] {"setTaskName0", "", "setTaskName0"});
-		expected.put("style 4 below style 3", new String[] {"beginTask1", "", "beginTask1"});
-		expected.put("style 2 below style 4", new String[] {"beginTask0", "subTask1", "beginTask0"});
-		expected.put("style 6 below style 0", new String[] {"setTaskName0", "subTask1", "setTaskName0"});
-		expected.put("style 4 below style 2", new String[] {"beginTask1", "subTask1", "beginTask1"});
-		expected.put("style 0 below style 6", new String[] {"", "subTask1", ""});
-		expected.put("style 0 below style 5", new String[] {"beginTask0", "", "beginTask0"});
-		expected.put("style 4 below style 1", new String[] {"beginTask1", "", "beginTask1"});
-		expected.put("style 2 below style 3", new String[] {"setTaskName0", "", "setTaskName1"});
-		expected.put("style 0 below style 4", new String[] {"beginTask0", "subTask1", "beginTask0"});
-		expected.put("style 4 below style 0", new String[] {"beginTask1", "subTask1", "beginTask1"});
-		expected.put("style 2 below style 2", new String[] {"setTaskName0", "subTask1", "setTaskName1"});
-		expected.put("style 1 as top-level monitor", new String[] {"beginTask0", "", "setTaskName0"});
-		expected.put("style 2 below style 1", new String[] {"setTaskName0", "", "setTaskName1"});
-		expected.put("style 0 below style 3", new String[] {"beginTask1", "", "setTaskName1"});
-		expected.put("style 2 below style 0", new String[] {"setTaskName0", "subTask1", "setTaskName1"});
-		expected.put("style 0 below style 2", new String[] {"beginTask1", "subTask1", "setTaskName1"});
-		expected.put("style 0 below style 1", new String[] {"beginTask1", "", "setTaskName1"});
-		expected.put("style 0 below style 0", new String[] {"beginTask1", "subTask1", "setTaskName1"});
-		expected.put("style 5 as top-level monitor", new String[] {"beginTask0", "", "beginTask0"});
-		expected.put("style 0 as top-level monitor", new String[] {"beginTask0", "subTask0", "setTaskName0"});
-		expected.put("style 4 as top-level monitor", new String[] {"beginTask0", "subTask0", "beginTask0"});
-		expected.put("style 7 below style 7", new String[] {"", "", ""});
-		expected.put("style 7 below style 6", new String[] {"", "subTask0", ""});
+		expected.put("style 5 below style 7", new String[] { "", "", "" });
+		expected.put("style 7 below style 5", new String[] { "beginTask0", "", "beginTask0" });
+		expected.put("style 7 below style 4", new String[] { "beginTask0", "subTask0", "beginTask0" });
+		expected.put("style 5 below style 6", new String[] { "", "subTask0", "" });
+		expected.put("style 3 below style 7", new String[] { "", "", "" });
+		expected.put("style 5 below style 5", new String[] { "beginTask0", "", "beginTask0" });
+		expected.put("style 7 below style 3", new String[] { "setTaskName0", "", "setTaskName0" });
+		expected.put("style 7 below style 2", new String[] { "setTaskName0", "subTask0", "setTaskName0" });
+		expected.put("style 5 below style 4", new String[] { "beginTask0", "subTask0", "beginTask0" });
+		expected.put("style 3 below style 6", new String[] { "", "subTask0", "" });
+		expected.put("style 1 below style 7", new String[] { "", "", "" });
+		expected.put("style 3 below style 5", new String[] { "beginTask0", "", "beginTask0" });
+		expected.put("style 5 below style 3", new String[] { "beginTask1", "", "beginTask1" });
+		expected.put("style 7 below style 1", new String[] { "setTaskName0", "", "setTaskName0" });
+		expected.put("style 3 below style 4", new String[] { "beginTask0", "subTask0", "beginTask0" });
+		expected.put("style 5 below style 2", new String[] { "beginTask1", "subTask0", "beginTask1" });
+		expected.put("style 7 below style 0", new String[] { "setTaskName0", "subTask0", "setTaskName0" });
+		expected.put("style 1 below style 6", new String[] { "", "subTask0", "" });
+		expected.put("style 1 below style 5", new String[] { "beginTask0", "", "beginTask0" });
+		expected.put("style 3 below style 3", new String[] { "setTaskName0", "", "setTaskName1" });
+		expected.put("style 5 below style 1", new String[] { "beginTask1", "", "beginTask1" });
+		expected.put("style 1 below style 4", new String[] { "beginTask0", "subTask0", "beginTask0" });
+		expected.put("style 3 below style 2", new String[] { "setTaskName0", "subTask0", "setTaskName1" });
+		expected.put("style 5 below style 0", new String[] { "beginTask1", "subTask0", "beginTask1" });
+		expected.put("style 1 below style 3", new String[] { "beginTask1", "", "setTaskName1" });
+		expected.put("style 3 below style 1", new String[] { "setTaskName0", "", "setTaskName1" });
+		expected.put("style 1 below style 2", new String[] { "beginTask1", "subTask0", "setTaskName1" });
+		expected.put("style 3 below style 0", new String[] { "setTaskName0", "subTask0", "setTaskName1" });
+		expected.put("style 1 below style 1", new String[] { "beginTask1", "", "setTaskName1" });
+		expected.put("style 1 below style 0", new String[] { "beginTask1", "subTask0", "setTaskName1" });
+		expected.put("style 3 as top-level monitor", new String[] { "", "", "setTaskName0" });
+		expected.put("style 7 as top-level monitor", new String[] { "", "", "" });
+		expected.put("style 2 as top-level monitor", new String[] { "", "subTask0", "setTaskName0" });
+		expected.put("style 6 as top-level monitor", new String[] { "", "subTask0", "" });
+		expected.put("style 6 below style 7", new String[] { "", "", "" });
+		expected.put("style 6 below style 6", new String[] { "", "subTask1", "" });
+		expected.put("style 4 below style 7", new String[] { "", "", "" });
+		expected.put("style 6 below style 5", new String[] { "beginTask0", "", "beginTask0" });
+		expected.put("style 6 below style 4", new String[] { "beginTask0", "subTask1", "beginTask0" });
+		expected.put("style 4 below style 6", new String[] { "", "subTask1", "" });
+		expected.put("style 2 below style 7", new String[] { "", "", "" });
+		expected.put("style 4 below style 5", new String[] { "beginTask0", "", "beginTask0" });
+		expected.put("style 6 below style 3", new String[] { "setTaskName0", "", "setTaskName0" });
+		expected.put("style 4 below style 4", new String[] { "beginTask0", "subTask1", "beginTask0" });
+		expected.put("style 6 below style 2", new String[] { "setTaskName0", "subTask1", "setTaskName0" });
+		expected.put("style 2 below style 6", new String[] { "", "subTask1", "" });
+		expected.put("style 0 below style 7", new String[] { "", "", "" });
+		expected.put("style 2 below style 5", new String[] { "beginTask0", "", "beginTask0" });
+		expected.put("style 6 below style 1", new String[] { "setTaskName0", "", "setTaskName0" });
+		expected.put("style 4 below style 3", new String[] { "beginTask1", "", "beginTask1" });
+		expected.put("style 2 below style 4", new String[] { "beginTask0", "subTask1", "beginTask0" });
+		expected.put("style 6 below style 0", new String[] { "setTaskName0", "subTask1", "setTaskName0" });
+		expected.put("style 4 below style 2", new String[] { "beginTask1", "subTask1", "beginTask1" });
+		expected.put("style 0 below style 6", new String[] { "", "subTask1", "" });
+		expected.put("style 0 below style 5", new String[] { "beginTask0", "", "beginTask0" });
+		expected.put("style 4 below style 1", new String[] { "beginTask1", "", "beginTask1" });
+		expected.put("style 2 below style 3", new String[] { "setTaskName0", "", "setTaskName1" });
+		expected.put("style 0 below style 4", new String[] { "beginTask0", "subTask1", "beginTask0" });
+		expected.put("style 4 below style 0", new String[] { "beginTask1", "subTask1", "beginTask1" });
+		expected.put("style 2 below style 2", new String[] { "setTaskName0", "subTask1", "setTaskName1" });
+		expected.put("style 1 as top-level monitor", new String[] { "beginTask0", "", "setTaskName0" });
+		expected.put("style 2 below style 1", new String[] { "setTaskName0", "", "setTaskName1" });
+		expected.put("style 0 below style 3", new String[] { "beginTask1", "", "setTaskName1" });
+		expected.put("style 2 below style 0", new String[] { "setTaskName0", "subTask1", "setTaskName1" });
+		expected.put("style 0 below style 2", new String[] { "beginTask1", "subTask1", "setTaskName1" });
+		expected.put("style 0 below style 1", new String[] { "beginTask1", "", "setTaskName1" });
+		expected.put("style 0 below style 0", new String[] { "beginTask1", "subTask1", "setTaskName1" });
+		expected.put("style 5 as top-level monitor", new String[] { "beginTask0", "", "beginTask0" });
+		expected.put("style 0 as top-level monitor", new String[] { "beginTask0", "subTask0", "setTaskName0" });
+		expected.put("style 4 as top-level monitor", new String[] { "beginTask0", "subTask0", "beginTask0" });
+		expected.put("style 7 below style 7", new String[] { "", "", "" });
+		expected.put("style 7 below style 6", new String[] { "", "subTask0", "" });
 		HashMap<String, String[]> results = new HashMap<>();
 
 		for (int style : styles) {
@@ -554,8 +575,8 @@
 			}
 		}
 
-		String failure = null;
-		// Output the code for the observed results, in case one of them has changed intentionally
+		// Output the code for the observed results, in case one of them has changed
+		// intentionally
 		for (Map.Entry<String, String[]> entry : results.entrySet()) {
 			String[] expectedResult = expected.get(entry.getKey());
 			if (expectedResult == null) {
@@ -563,59 +584,14 @@
 			}
 
 			String[] value = entry.getValue();
-			if (compareArray(value, expectedResult)) {
-				continue;
-			}
-
-			System.out.print("expected.put(\"" + entry.getKey() + "\", new String[] {");
-			failure = entry.getKey();
-			String list = concatArray(value);
-			System.out.println(list + "});");
+			assertArrayEquals(value, expectedResult);
 		}
-
-		if (failure != null) {
-			Assert.assertEquals(failure, concatArray(expected.get(failure)), concatArray(results.get(failure)));
-		}
-	}
-
-	private boolean compareArray(String[] value, String[] expectedResult) {
-		if (value == null || expectedResult == null) {
-			return value == null && expectedResult == null;
-		}
-
-		if (value.length != expectedResult.length) {
-			return false;
-		}
-		for (int i = 0; i < expectedResult.length; i++) {
-			String next = expectedResult[i];
-			if (!next.equals(value[i])) {
-				return false;
-			}
-		}
-		return true;
-	}
-
-	private String concatArray(String[] value) {
-		if (value == null) {
-			return "";
-		}
-
-		StringBuilder buf = new StringBuilder();
-		boolean isFirst = true;
-		for (String nextValue : value) {
-			if (!isFirst) {
-				buf.append(", ");
-			}
-			isFirst = false;
-			buf.append("\"" + nextValue + "\"");
-		}
-		String list = buf.toString();
-		return list;
 	}
 
 	/**
 	 * Ensures that SubMonitor doesn't propogate redundant progress to its parent.
 	 */
+	@Test
 	public void testRedundantWork() {
 		TestProgressMonitor top = new TestProgressMonitor();
 
@@ -634,6 +610,7 @@
 		top.assertOptimal();
 	}
 
+	@Test
 	public void testCancellation() {
 		TestProgressMonitor root = new TestProgressMonitor();
 
@@ -641,13 +618,13 @@
 
 		// Test that changes at the root propogate to the child
 		root.setCanceled(true);
-		Assert.assertTrue(spm.isCanceled());
+		assertTrue(spm.isCanceled());
 		root.setCanceled(false);
 		Assert.assertFalse(spm.isCanceled());
 
 		// Test that changes to the child propogate to the root
 		spm.setCanceled(true);
-		Assert.assertTrue(root.isCanceled());
+		assertTrue(root.isCanceled());
 		spm.setCanceled(false);
 		Assert.assertFalse(root.isCanceled());
 
@@ -657,17 +634,18 @@
 
 		// Test that changes at the root propogate to the child
 		root.setCanceled(true);
-		Assert.assertTrue(spm2.isCanceled());
+		assertTrue(spm2.isCanceled());
 		root.setCanceled(false);
 		Assert.assertFalse(spm2.isCanceled());
 
 		// Test that changes to the child propogate to the root
 		spm2.setCanceled(true);
-		Assert.assertTrue(root.isCanceled());
+		assertTrue(root.isCanceled());
 		spm2.setCanceled(false);
 		Assert.assertFalse(root.isCanceled());
 	}
 
+	@Test
 	public void testNullParent() {
 		// Touch everything in the public API to ensure we don't throw an NPE
 		SubMonitor mon = SubMonitor.convert(null, 1000);
@@ -678,57 +656,63 @@
 		mon.internalWorked(50.0);
 		Assert.assertFalse(mon.isCanceled());
 		mon.setCanceled(true);
-		Assert.assertTrue(mon.isCanceled());
+		assertTrue(mon.isCanceled());
 		mon.subTask("subtask");
 		mon.setTaskName("taskname");
 		mon.done();
 	}
 
 	/**
-	 * Tests the automatic cleanup when progress monitors are created via their constructor
+	 * Tests the automatic cleanup when progress monitors are created via their
+	 * constructor
 	 */
+	@Test
 	public void testNewChild() {
 		TestProgressMonitor top = new TestProgressMonitor();
 		SubMonitor mon = SubMonitor.convert(top, 1000);
 
-		Assert.assertEquals("Ensure no work has been reported yet", 0.0, top.getTotalWork(), 0.01d);
+		assertEquals("Ensure no work has been reported yet", 0.0, top.getTotalWork(), 0.01d);
 
 		mon.newChild(100);
 
-		Assert.assertEquals("Ensure no work has been reported yet", 0.0, top.getTotalWork(), 0.01d);
+		assertEquals("Ensure no work has been reported yet", 0.0, top.getTotalWork(), 0.01d);
 
 		mon.newChild(200);
 
-		Assert.assertEquals("Ensure monitor1 was collected", 100.0, top.getTotalWork(), 0.01d);
+		assertEquals("Ensure monitor1 was collected", 100.0, top.getTotalWork(), 0.01d);
 
-		// The following behavior is necessary to make it possible to pass multiple progress monitors as
+		// The following behavior is necessary to make it possible to pass multiple
+		// progress monitors as
 		// arguments to the same method.
-		Assert.assertEquals("Monitor2 should not have been collected yet (when the public constructor is used, collection should happen when beginTask() or setWorkRemaining() is called.", 100.0, top.getTotalWork(), 0.01d);
+		assertEquals(
+				"Monitor2 should not have been collected yet (when the public constructor is used, collection should happen when beginTask() or setWorkRemaining() is called.",
+				100.0, top.getTotalWork(), 0.01d);
 
 		SubMonitor monitor4 = mon.newChild(300);
 
-		Assert.assertEquals("Now monitor2 should be collected", 300.0, top.getTotalWork(), 0.01d);
+		assertEquals("Now monitor2 should be collected", 300.0, top.getTotalWork(), 0.01d);
 
 		monitor4.done();
 
-		Assert.assertEquals("Now monitor4 should be collected", 600.0, top.getTotalWork(), 0.01d);
+		assertEquals("Now monitor4 should be collected", 600.0, top.getTotalWork(), 0.01d);
 
 		mon.newChild(10);
 
-		Assert.assertEquals("Creating a child when there are no active children should not report any work", 600.0, top.getTotalWork(), 0.01d);
+		assertEquals("Creating a child when there are no active children should not report any work", 600.0,
+				top.getTotalWork(), 0.01d);
 
 		mon.worked(20);
 
 		// Test for bug 210394
-		Assert.assertEquals("Reporting work should cause the active child to be destroyed", 630.0, top.getTotalWork(), 0.01d);
+		assertEquals("Reporting work should cause the active child to be destroyed", 630.0, top.getTotalWork(), 0.01d);
 
 		mon.newChild(10);
 
-		Assert.assertEquals("monitor5 should have been cleaned up", 630.0, top.getTotalWork(), 0.01d);
+		assertEquals("monitor5 should have been cleaned up", 630.0, top.getTotalWork(), 0.01d);
 
 		mon.internalWorked(60);
 
-		Assert.assertEquals("Calling internalWorked should clean up active children", 700.0, top.getTotalWork(), 0.01d);
+		assertEquals("Calling internalWorked should clean up active children", 700.0, top.getTotalWork(), 0.01d);
 
 		// Now create a chain of undisposed children
 		SubMonitor monitor7 = mon.newChild(100);
@@ -739,29 +723,32 @@
 
 		mon.done();
 
-		Assert.assertEquals("Calling done should clean up unused work", 1000.0, top.getTotalWork(), 0.01d);
+		assertEquals("Calling done should clean up unused work", 1000.0, top.getTotalWork(), 0.01d);
 	}
 
 	/**
-	 * Tests creating progress monitors under a custom progress monitor
-	 * parent. This is the same as the performance test as the same name,
-	 * but it verifies correctness rather than performance.
+	 * Tests creating progress monitors under a custom progress monitor parent. This
+	 * is the same as the performance test as the same name, but it verifies
+	 * correctness rather than performance.
 	 */
+	@Test
 	public void testCreateChildrenUnderCustomParent() {
 		TestProgressMonitor monitor = new TestProgressMonitor();
 		createChildrenUnderParent(monitor, SubMonitorTest.PROGRESS_SIZE);
 
-		// We don't actually expect the progress to be optimal in this case since the progress monitor wouldn't
-		// know what it was rooted under and would have had to report more progress than necessary... but we
+		// We don't actually expect the progress to be optimal in this case since the
+		// progress monitor wouldn't
+		// know what it was rooted under and would have had to report more progress than
+		// necessary... but we
 		// should be able to check that there was no redundancy.
 
-		Assert.assertTrue(monitor.getRedundantWorkCalls() == 0);
-		Assert.assertTrue(monitor.getWorkCalls() >= 100);
+		assertEquals(0, monitor.getRedundantWorkCalls());
+		assertTrue(monitor.getWorkCalls() >= 100);
 	}
 
 	/**
-	 * Creates a chain of n nested progress monitors. Calls beginTask on all monitors
-	 * except for the innermost one.
+	 * Creates a chain of n nested progress monitors. Calls beginTask on all
+	 * monitors except for the innermost one.
 	 *
 	 * @param parent
 	 * @param depth
@@ -780,11 +767,12 @@
 	}
 
 	/**
-	 * Creates a balanced binary tree of progress monitors, without calling worked. Tests
-	 * progress monitor creation and cleanup time, and ensures that excess progress is
-	 * being collected when IProgressMonitor.done() is called.
+	 * Creates a balanced binary tree of progress monitors, without calling worked.
+	 * Tests progress monitor creation and cleanup time, and ensures that excess
+	 * progress is being collected when IProgressMonitor.done() is called.
 	 *
-	 * @param monitor progress monitor (callers are responsible for calling done() if necessary)
+	 * @param monitor  progress monitor (callers are responsible for calling done()
+	 *                 if necessary)
 	 * @param loopSize total size of the recursion tree
 	 */
 	public static void createBalancedTree(IProgressMonitor parent, int loopSize) {
@@ -802,13 +790,22 @@
 	}
 
 	/**
-	 * <p>The innermost loop for the create tree test. We make this a static method so
-	 * that it can be used both in this performance test and in the correctness test.</p>
+	 * <p>
+	 * The innermost loop for the create tree test. We make this a static method so
+	 * that it can be used both in this performance test and in the correctness
+	 * test.
+	 * </p>
 	 *
-	 * <p>The performance test ensures that it is fast to create a lot of progress monitors.</p>
+	 * <p>
+	 * The performance test ensures that it is fast to create a lot of progress
+	 * monitors.
+	 * </p>
 	 *
-	 * <p>The correctness test ensures that creating and destroying SubMonitors
-	 * is enough to report progress, even if worked(int) and worked(double) are never called</p>
+	 * <p>
+	 * The correctness test ensures that creating and destroying SubMonitors is
+	 * enough to report progress, even if worked(int) and worked(double) are never
+	 * called
+	 * </p>
 	 */
 	public static void runTestCreateTree(IProgressMonitor monitor) {
 		SubMonitor progress = SubMonitor.convert(monitor, 100);
@@ -821,12 +818,14 @@
 	}
 
 	/**
-	 * Reports progress by creating a balanced binary tree of progress monitors. Simulates
-	 * mixed usage of IProgressMonitor in a typical usage. Calls isCanceled once each time work
-	 * is reported. Half of the work is reported using internalWorked and half is reported using worked,
-	 * to simulate mixed usage of the progress monitor.
+	 * Reports progress by creating a balanced binary tree of progress monitors.
+	 * Simulates mixed usage of IProgressMonitor in a typical usage. Calls
+	 * isCanceled once each time work is reported. Half of the work is reported
+	 * using internalWorked and half is reported using worked, to simulate mixed
+	 * usage of the progress monitor.
 	 *
-	 * @param monitor progress monitor (callers are responsible for calling done() if necessary)
+	 * @param monitor  progress monitor (callers are responsible for calling done()
+	 *                 if necessary)
 	 * @param loopSize total size of the recursion tree
 	 */
 	public static void reportWorkInBalancedTree(IProgressMonitor parent, int loopSize) {
@@ -853,7 +852,8 @@
 
 	/**
 	 * The innermost loop for the recursion test. We make this a static method so
-	 * that it can be used both in this performance test and in the correctness test.
+	 * that it can be used both in this performance test and in the correctness
+	 * test.
 	 */
 	public static void runTestTypicalUsage(IProgressMonitor monitor) {
 		SubMonitor progress = SubMonitor.convert(monitor, 100);
@@ -866,10 +866,10 @@
 	}
 
 	/**
-	 * Tests SubMonitor.worked. This is the same
-	 * as the performance test as the same name, but it verifies correctness
-	 * rather than performance.
+	 * Tests SubMonitor.worked. This is the same as the performance test as the same
+	 * name, but it verifies correctness rather than performance.
 	 */
+	@Test
 	public void testWorked() {
 		TestProgressMonitor monitor = new TestProgressMonitor();
 		SubMonitor progress = SubMonitor.convert(monitor, 100);
@@ -884,10 +884,10 @@
 	}
 
 	/**
-	 * Tests SubMonitor.worked. This is the same
-	 * as the performance test as the same name, but it verifies correctness
-	 * rather than performance.
+	 * Tests SubMonitor.worked. This is the same as the performance test as the same
+	 * name, but it verifies correctness rather than performance.
 	 */
+	@Test
 	public void testInternalWorked() {
 		TestProgressMonitor monitor = new TestProgressMonitor();
 		SubMonitor progress = SubMonitor.convert(monitor, 100);
@@ -906,6 +906,7 @@
 	 * {@link SubMonitor#split(int, int)} when passing in the
 	 * {@link SubMonitor#SUPPRESS_ISCANCELED} flag.
 	 */
+	@Test
 	public void testSplitDoesNotCancelWhenCancellationSuppressed() {
 		TestProgressMonitor monitor = new TestProgressMonitor();
 		monitor.setCanceled(true);
@@ -919,10 +920,11 @@
 	}
 
 	/**
-	 * Creates and destroys the given number of child progress monitors under the given parent.
+	 * Creates and destroys the given number of child progress monitors under the
+	 * given parent.
 	 *
-	 * @param parent monitor to create children under. The caller must call done on this monitor
-	 * if necessary.
+	 * @param parent       monitor to create children under. The caller must call
+	 *                     done on this monitor if necessary.
 	 * @param progressSize total number of children to create.
 	 */
 	private static void createChildrenUnderParent(IProgressMonitor parent, int progressSize) {
@@ -934,9 +936,4 @@
 		}
 	}
 
-	static public void reportPerformance(String className, String methodName, long startTime, long endTime) {
-		// enable to see performance results for the progress monitors
-		//			System.out.println(className + "#" + methodName + " elapsed time: " + (endTime - startTime) / 1000.0d + "s");
-	}
-
 }
diff --git a/bundles/org.eclipse.equinox.common.tests/src/org/eclipse/equinox/common/tests/SubProgressTest.java b/bundles/org.eclipse.equinox.common.tests/src/org/eclipse/equinox/common/tests/SubProgressTest.java
index 5949452..64f905c 100644
--- a/bundles/org.eclipse.equinox.common.tests/src/org/eclipse/equinox/common/tests/SubProgressTest.java
+++ b/bundles/org.eclipse.equinox.common.tests/src/org/eclipse/equinox/common/tests/SubProgressTest.java
@@ -14,19 +14,25 @@
  *******************************************************************************/
 package org.eclipse.equinox.common.tests;
 
-import java.util.*;
-import junit.framework.TestCase;
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Map;
+
 import org.eclipse.core.runtime.IProgressMonitor;
 import org.eclipse.core.runtime.SubProgressMonitor;
 import org.junit.Assert;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TestName;
 
-/**
- *
- */
 @SuppressWarnings("deprecation")
-public class SubProgressTest extends TestCase {
+public class SubProgressTest {
 
-	private long startTime;
 	/**
 	 * <p>Depth of the chain chain of progress monitors. In all of the tests, we create
 	 * a nested chain of progress monitors rathar than a single monitor, to test its
@@ -47,54 +53,15 @@
 	 */
 	public static final int PROGRESS_SIZE = 100000;
 
-	public SubProgressTest() {
-		super();
-	}
-
-	public SubProgressTest(String name) {
-		super(name);
-	}
-
-	@Override
-	protected void setUp() throws Exception {
-		startTime = System.currentTimeMillis();
-		super.setUp();
-	}
-
-	@Override
-	protected void tearDown() throws Exception {
-		long endTime = System.currentTimeMillis();
-		SubMonitorTest.reportPerformance(getClass().getName(), getName(), startTime, endTime);
-		super.tearDown();
-	}
-
-	/**
-	 * Calls done on the given progress monitor and all of its parents, to a maximum
-	 * of the given depth.
-	 *
-	 * @deprecated to suppress deprecation warnings
-	 *
-	 * @param monitor
-	 * @param depth
-	 */
-	@Deprecated
-	public static void callDoneOnChain(IProgressMonitor monitor, int depth) {
-		IProgressMonitor current = monitor;
-		for (int count = 0; count < depth; count++) {
-			current.done();
-			if (!(current instanceof SubProgressMonitor)) {
-				return;
-			}
-			SubProgressMonitor cur = (SubProgressMonitor) current;
-			current = cur.getWrappedProgressMonitor();
-		}
-	}
+	@Rule
+	public TestName name = new TestName();
 
 	/**
 	 * Tests the style bits in SubProgressMonitor
 	 * @deprecated to suppress deprecation warnings
 	 */
 	@Deprecated
+	@Test
 	public void testStyles() {
 
 		int[] styles = new int[] {0, SubProgressMonitor.PREPEND_MAIN_LABEL_TO_SUBTASK, SubProgressMonitor.SUPPRESS_SUBTASK_LABEL, SubProgressMonitor.PREPEND_MAIN_LABEL_TO_SUBTASK | SubProgressMonitor.SUPPRESS_SUBTASK_LABEL};
@@ -139,51 +106,13 @@
 			child.done();
 		}
 
-		String failure = null;
 		// Output the code for the observed results, in case one of them has changed intentionally
 		for (Map.Entry<String, String[]> entry : results.entrySet()) {
 			String[] expectedResult = expected.get(entry.getKey());
 			String[] value = entry.getValue();
-			if (compareArray(value, expectedResult)) {
-				continue;
-			}
-
-			System.out.print("expected.put(\"" + entry.getKey() + "\", new String[] {");
-			failure = entry.getKey();
-			String list = concatArray(value);
-			System.out.println(list + "});");
+			assertArrayEquals(value, expectedResult);
 		}
 
-		if (failure != null) {
-			Assert.assertEquals(failure, concatArray(expected.get(failure)), concatArray(results.get(failure)));
-		}
-	}
-
-	private boolean compareArray(String[] value, String[] expectedResult) {
-		if (value.length != expectedResult.length) {
-			return false;
-		}
-		for (int i = 0; i < expectedResult.length; i++) {
-			String next = expectedResult[i];
-			if (!next.equals(value[i])) {
-				return false;
-			}
-		}
-		return true;
-	}
-
-	private String concatArray(String[] value) {
-		StringBuilder buf = new StringBuilder();
-		boolean isFirst = true;
-		for (String nextValue : value) {
-			if (!isFirst) {
-				buf.append(", ");
-			}
-			isFirst = false;
-			buf.append("\"" + nextValue + "\"");
-		}
-		String list = buf.toString();
-		return list;
 	}
 
 	private String[] runChildTest(int depth, TestProgressMonitor root, IProgressMonitor child, int ticks) {
@@ -203,6 +132,7 @@
 	 * @deprecated to suppress deprecation warnings
 	 */
 	@Deprecated
+	@Test
 	public void testConstructorNestingFP() {
 		TestProgressMonitor top = new TestProgressMonitor();
 		top.beginTask("", 2000);
@@ -213,7 +143,7 @@
 		fpMonitor.internalWorked(50.0);
 		fpMonitor.internalWorked(-10.0); // should have no effect
 
-		Assert.assertEquals(500.0, top.getTotalWork(), 0.01d);
+		assertEquals(500.0, top.getTotalWork(), 0.01d);
 
 		// Create a child monitor, and ensure that it grabs the correct amount of work
 		// from the parent.
@@ -222,7 +152,7 @@
 		childMonitor.worked(100);
 		childMonitor.done();
 
-		Assert.assertEquals(700.0, top.getTotalWork(), 0.01d);
+		assertEquals(700.0, top.getTotalWork(), 0.01d);
 
 		// Create a child monitor, and ensure that it grabs the correct amount of work
 		// from the parent.
@@ -231,7 +161,7 @@
 		childMonitor2.worked(100);
 		childMonitor2.done();
 
-		Assert.assertEquals(1000.0, top.getTotalWork(), 0.01d);
+		assertEquals(1000.0, top.getTotalWork(), 0.01d);
 
 		// Ensure that creating another child will have no effect
 		SubProgressMonitor childMonitor3 = new SubProgressMonitor(fpMonitor, 10);
@@ -239,11 +169,11 @@
 		childMonitor3.worked(100);
 		childMonitor3.done();
 
-		Assert.assertEquals(1000.0, top.getTotalWork(), 0.01d);
+		assertEquals(1000.0, top.getTotalWork(), 0.01d);
 		fpMonitor.worked(100);
-		Assert.assertEquals(1000.0, top.getTotalWork(), 0.01d);
+		assertEquals(1000.0, top.getTotalWork(), 0.01d);
 		fpMonitor.done();
-		Assert.assertEquals(1000.0, top.getTotalWork(), 0.01d);
+		assertEquals(1000.0, top.getTotalWork(), 0.01d);
 	}
 
 	/**
@@ -252,6 +182,7 @@
 	 * @deprecated to suppress deprecation warnings
 	 */
 	@Deprecated
+	@Test
 	public void testConstructorNestingInt() {
 		TestProgressMonitor top = new TestProgressMonitor();
 		top.beginTask("", 2000);
@@ -261,7 +192,7 @@
 		fpMonitor.beginTask("", 100);
 		fpMonitor.worked(50);
 
-		Assert.assertEquals(500.0, top.getTotalWork(), 0.01d);
+		assertEquals(500.0, top.getTotalWork(), 0.01d);
 
 		// Create a child monitor, and ensure that it grabs the correct amount of work
 		// from the parent.
@@ -270,7 +201,7 @@
 		childMonitor.worked(100);
 		childMonitor.done();
 
-		Assert.assertEquals(700.0, top.getTotalWork(), 0.01d);
+		assertEquals(700.0, top.getTotalWork(), 0.01d);
 
 		// Create a child monitor, and ensure that it grabs the correct amount of work
 		// from the parent.
@@ -279,7 +210,7 @@
 		childMonitor2.worked(100);
 		childMonitor2.done();
 
-		Assert.assertEquals(1000.0, top.getTotalWork(), 0.01d);
+		assertEquals(1000.0, top.getTotalWork(), 0.01d);
 
 		// Ensure that creating another child will have no effect
 		SubProgressMonitor childMonitor3 = new SubProgressMonitor(fpMonitor, 10);
@@ -287,11 +218,11 @@
 		childMonitor3.worked(100);
 		childMonitor3.done();
 
-		Assert.assertEquals(1000.0, top.getTotalWork(), 0.01d);
+		assertEquals(1000.0, top.getTotalWork(), 0.01d);
 		fpMonitor.worked(100);
-		Assert.assertEquals(1000.0, top.getTotalWork(), 0.01d);
+		assertEquals(1000.0, top.getTotalWork(), 0.01d);
 		fpMonitor.done();
-		Assert.assertEquals(1000.0, top.getTotalWork(), 0.01d);
+		assertEquals(1000.0, top.getTotalWork(), 0.01d);
 	}
 
 	/**
@@ -299,6 +230,7 @@
 	 * @deprecated to suppress deprecation warnings
 	 */
 	@Deprecated
+	@Test
 	public void testParallelChildren() {
 		TestProgressMonitor top = new TestProgressMonitor();
 		top.beginTask("", 1000);
@@ -308,35 +240,36 @@
 		SubProgressMonitor monitor1 = new SubProgressMonitor(mon, 200);
 		SubProgressMonitor monitor2 = new SubProgressMonitor(mon, 200);
 
-		Assert.assertEquals("Ensure no work has been reported yet", 0.0, top.getTotalWork(), 0.01d);
+		assertEquals("Ensure no work has been reported yet", 0.0, top.getTotalWork(), 0.01d);
 		monitor1.beginTask("", 1000);
-		Assert.assertEquals("Ensure no work has been reported yet", 0.0, top.getTotalWork(), 0.01d);
+		assertEquals("Ensure no work has been reported yet", 0.0, top.getTotalWork(), 0.01d);
 		monitor2.beginTask("", 1000);
-		Assert.assertEquals("Should not have cleaned up monitor 1", 0.0, top.getTotalWork(), 0.01d);
+		assertEquals("Should not have cleaned up monitor 1", 0.0, top.getTotalWork(), 0.01d);
 		monitor1.done();
 
-		Assert.assertEquals("Should have cleaned up monitor 1", 200.0, top.getTotalWork(), 0.01d);
+		assertEquals("Should have cleaned up monitor 1", 200.0, top.getTotalWork(), 0.01d);
 		monitor1.worked(1000);
-		Assert.assertEquals("Monitor1 shouldn't report work once it's complete", 200.0, top.getTotalWork(), 0.01d);
+		assertEquals("Monitor1 shouldn't report work once it's complete", 200.0, top.getTotalWork(), 0.01d);
 		monitor2.worked(500);
-		Assert.assertEquals(300.0, top.getTotalWork(), 0.01d);
+		assertEquals(300.0, top.getTotalWork(), 0.01d);
 
 		// Create a monitor that will leak - monitors won't be auto-completed until their done methods are
 		// called
 		SubProgressMonitor monitor3 = new SubProgressMonitor(mon, 300);
-		Assert.assertEquals("Monitor2 should not have been cleaned up yet", 300.0, top.getTotalWork(), 0.01d);
+		assertEquals("Monitor2 should not have been cleaned up yet", 300.0, top.getTotalWork(), 0.01d);
 		SubProgressMonitor monitor4 = new SubProgressMonitor(mon, 300);
 		monitor4.beginTask("", 100);
 		mon.done();
 		Assert.assertNotNull(monitor3);
 
-		Assert.assertEquals("All leaked work should have been collected", 1000.0, top.getTotalWork(), 0.01d);
+		assertEquals("All leaked work should have been collected", 1000.0, top.getTotalWork(), 0.01d);
 	}
 
 	/**
 	 * @deprecated to suppress deprecation warnings
 	 */
 	@Deprecated
+	@Test
 	public void testCancellation() {
 		TestProgressMonitor root = new TestProgressMonitor();
 		root.beginTask("", 1000);
@@ -345,15 +278,15 @@
 
 		// Test that changes at the root propogate to the child
 		root.setCanceled(true);
-		Assert.assertTrue(spm.isCanceled());
+		assertTrue(spm.isCanceled());
 		root.setCanceled(false);
-		Assert.assertFalse(spm.isCanceled());
+		assertFalse(spm.isCanceled());
 
 		// Test that changes to the child propogate to the root
 		spm.setCanceled(true);
-		Assert.assertTrue(root.isCanceled());
+		assertTrue(root.isCanceled());
 		spm.setCanceled(false);
-		Assert.assertFalse(root.isCanceled());
+		assertFalse(root.isCanceled());
 
 		// Test a chain of depth 2
 		spm.beginTask("", 1000);
@@ -361,22 +294,23 @@
 
 		// Test that changes at the root propogate to the child
 		root.setCanceled(true);
-		Assert.assertTrue(spm2.isCanceled());
+		assertTrue(spm2.isCanceled());
 		root.setCanceled(false);
-		Assert.assertFalse(spm2.isCanceled());
+		assertFalse(spm2.isCanceled());
 
 		// Test that changes to the child propogate to the root
 		spm2.setCanceled(true);
-		Assert.assertTrue(root.isCanceled());
+		assertTrue(root.isCanceled());
 		spm2.setCanceled(false);
-		Assert.assertFalse(root.isCanceled());
+		assertFalse(root.isCanceled());
 	}
 
 	/**
-	 * Tests creating progress monitors under a custom progress monitor
-	 * parent. This is the same as the performance test as the same name,
-	 * but it verifies correctness rather than performance.
+	 * Tests creating progress monitors under a custom progress monitor parent. This
+	 * is the same as the performance test as the same name, but it verifies
+	 * correctness rather than performance.
 	 */
+	@Test
 	public void testCreateChildrenUnderCustomParent() {
 		TestProgressMonitor monitor = new TestProgressMonitor();
 		createChildrenUnderParent(monitor, SubProgressTest.PROGRESS_SIZE);
@@ -385,182 +319,8 @@
 		// know what it was rooted under and would have had to report more progress than necessary... but we
 		// should be able to check that there was no redundancy.
 
-		Assert.assertTrue(monitor.getRedundantWorkCalls() == 0);
-		Assert.assertTrue(monitor.getWorkCalls() >= 100);
-	}
-
-	/**
-	 * Creates a chain of n nested progress monitors. Calls beginTask on all monitors
-	 * except for the innermost one.
-	 *
-	 * @deprecated to suppress deprecation warnings
-	 *
-	 * @param parent
-	 * @param depth
-	 * @return the innermost SubProgressMonitor
-	 */
-	@Deprecated
-	private static SubProgressMonitor createSubProgressChain(IProgressMonitor parent, int depth) {
-		SubProgressMonitor current;
-		do {
-			parent.beginTask("", 100);
-			current = new SubProgressMonitor(parent, 100);
-			parent = current;
-			depth--;
-		} while (depth > 0);
-		return current;
-	}
-
-	/**
-	 * Reports progress by iterating over a loop of the given size, reporting 1 progress
-	 * at each iteration. Simulates the progress of worked(int) in loops.
-	 *
-	 * @param monitor progress monitor (callers are responsible for calling done() if necessary)
-	 * @param loopSize size of the loop
-	 */
-	private static void reportWorkInLoop(IProgressMonitor monitor, int loopSize) {
-		monitor.beginTask("", loopSize);
-		for (int i = 0; i < loopSize; i++) {
-			monitor.worked(1);
-		}
-	}
-
-	/**
-	 * Reports progress by iterating over a loop of the given size, reporting 1 progress
-	 * at each iteration. Simulates the progress of internalWorked(double) in loops.
-	 *
-	 * @param monitor progress monitor (callers are responsible for calling done() if necessary)
-	 * @param loopSize size of the loop
-	 */
-	private static void reportFloatingPointWorkInLoop(IProgressMonitor monitor, int loopSize) {
-		monitor.beginTask("", loopSize);
-		for (int i = 0; i < loopSize; i++) {
-			monitor.internalWorked(1.0d);
-		}
-	}
-
-	/**
-	 * Reports progress by creating a balanced binary tree of progress monitors. Simulates
-	 * mixed usage of IProgressMonitor in a typical usage. Calls isCanceled once each time work
-	 * is reported. Half of the work is reported using internalWorked and half is reported using worked,
-	 * to simulate mixed usage of the progress monitor.
-	 *
-	 * @deprecated to suppress deprecation warnings
-	 *
-	 * @param monitor progress monitor (callers are responsible for calling done() if necessary)
-	 * @param loopSize total size of the recursion tree
-	 */
-	@Deprecated
-	public static void reportWorkInBalancedTree(IProgressMonitor monitor, int loopSize) {
-		monitor.beginTask("", 100);
-		int leftBranch = loopSize / 2;
-		int rightBranch = loopSize - leftBranch;
-
-		if (leftBranch > 1) {
-			SubProgressMonitor leftProgress = new SubProgressMonitor(monitor, 50);
-			reportWorkInBalancedTree(leftProgress, leftBranch);
-			leftProgress.done();
-		} else {
-			monitor.worked(25);
-			monitor.internalWorked(25.0);
-			monitor.isCanceled();
-		}
-
-		if (rightBranch > 1) {
-			SubProgressMonitor rightProgress = new SubProgressMonitor(monitor, 50);
-			reportWorkInBalancedTree(rightProgress, rightBranch);
-			rightProgress.done();
-		} else {
-			monitor.worked(25);
-			monitor.internalWorked(25.0);
-			monitor.isCanceled();
-		}
-	}
-
-	/**
-	 * Creates a balanced binary tree of progress monitors, without calling worked. Tests
-	 * progress monitor creation and cleanup time, and ensures that excess progress is
-	 * being collected when IProgressMonitor.done() is called.
-	 *
-	 * @deprecated to suppress deprecation warnings
-	 *
-	 * @param monitor progress monitor (callers are responsible for calling done() if necessary)
-	 * @param loopSize total size of the recursion tree
-	 */
-	@Deprecated
-	public static void createBalancedTree(IProgressMonitor monitor, int loopSize) {
-		monitor.beginTask("", 100);
-		int leftBranch = loopSize / 2;
-		int rightBranch = loopSize - leftBranch;
-
-		if (leftBranch > 1) {
-			SubProgressMonitor leftProgress = new SubProgressMonitor(monitor, 50);
-			createBalancedTree(leftProgress, leftBranch);
-			leftProgress.done();
-		}
-
-		if (rightBranch > 1) {
-			SubProgressMonitor rightProgress = new SubProgressMonitor(monitor, 50);
-			createBalancedTree(rightProgress, rightBranch);
-			rightProgress.done();
-		}
-	}
-
-	/**
-	 * The innermost loop for the looping test. We make this a static method so
-	 * that it can be used both in this performance test and in the correctness test.
-	 *
-	 * @deprecated to suppress deprecation warnings
-	 */
-	@Deprecated
-	public static void runTestWorked(IProgressMonitor monitor) {
-		SubProgressMonitor nestedMonitor = createSubProgressChain(monitor, SubProgressTest.CHAIN_DEPTH);
-		reportWorkInLoop(nestedMonitor, SubProgressTest.PROGRESS_SIZE);
-		callDoneOnChain(nestedMonitor, SubProgressTest.CHAIN_DEPTH + 1);
-	}
-
-	/**
-	 * The innermost loop for the looping test. We make this a static method so
-	 * that it can be used both in this performance test and in the correctness test.
-	 *
-	 * @deprecated to suppress deprecation warnings
-	 */
-	@Deprecated
-	public static void runTestInternalWorked(IProgressMonitor monitor) {
-		SubProgressMonitor nestedMonitor = createSubProgressChain(monitor, SubProgressTest.CHAIN_DEPTH);
-		reportFloatingPointWorkInLoop(nestedMonitor, SubProgressTest.PROGRESS_SIZE);
-		callDoneOnChain(nestedMonitor, SubProgressTest.CHAIN_DEPTH + 1);
-	}
-
-	/**
-	 * The innermost loop for the recursion test. We make this a static method so
-	 * that it can be used both in this performance test and in the correctness test.
-	 *
-	 * @deprecated to suppress deprecation warnings
-	 */
-	@Deprecated
-	public static void runTestTypicalUsage(IProgressMonitor monitor) {
-		SubProgressMonitor nestedMonitor = createSubProgressChain(monitor, SubProgressTest.CHAIN_DEPTH);
-		reportWorkInBalancedTree(nestedMonitor, SubProgressTest.PROGRESS_SIZE);
-		callDoneOnChain(nestedMonitor, SubProgressTest.CHAIN_DEPTH + 1);
-	}
-
-	/**
-	 * <p>The innermost loop for the create tree test. We make this a static method so
-	 * that it can be used both in this performance test and in the correctness test.</p>
-	 *
-	 * <p>The performance test ensures that it is fast to create a lot of progress monitors.</p>
-	 *
-	 * <p>The correctness test ensures that creating and destroying SubProgressMonitors
-	 * is enough to report progress, even if worked(int) and worked(double) are never called</p>
-	 *
-	 * @deprecated to suppress deprecation warnings
-	 */
-	@Deprecated
-	public static void runTestCreateTree(IProgressMonitor monitor) {
-		SubProgressMonitor nestedMonitor = createSubProgressChain(monitor, SubProgressTest.CHAIN_DEPTH);
-		createBalancedTree(nestedMonitor, SubProgressTest.PROGRESS_SIZE);
-		callDoneOnChain(nestedMonitor, SubProgressTest.CHAIN_DEPTH + 1);
+		assertEquals(0, monitor.getRedundantWorkCalls());
+		assertTrue(monitor.getWorkCalls() >= 100);
 	}
 
 	/**
@@ -586,6 +346,7 @@
 	/**
 	 * Test SubProgressMonitor's created with negative a work value.
 	 */
+	@Test
 	public void testNegativeWorkValues() {
 		TestProgressMonitor top = new TestProgressMonitor();
 		top.beginTask("", 10);
@@ -593,9 +354,9 @@
 		SubProgressMonitor childMonitor = new SubProgressMonitor(top, IProgressMonitor.UNKNOWN); // -1
 		childMonitor.beginTask("", 10);
 		childMonitor.worked(5);
-		Assert.assertEquals(0.0, top.getTotalWork(), 0.01d);
+		assertEquals(0.0, top.getTotalWork(), 0.01d);
 		childMonitor.done();
-		Assert.assertEquals(0.0, top.getTotalWork(), 0.01d);
+		assertEquals(0.0, top.getTotalWork(), 0.01d);
 
 		top.done();
 	}
diff --git a/bundles/org.eclipse.equinox.common.tests/src/org/eclipse/equinox/common/tests/adaptable/AdapterManagerDynamicTest.java b/bundles/org.eclipse.equinox.common.tests/src/org/eclipse/equinox/common/tests/adaptable/AdapterManagerDynamicTest.java
index 2a24ba4..b34a59f 100644
--- a/bundles/org.eclipse.equinox.common.tests/src/org/eclipse/equinox/common/tests/adaptable/AdapterManagerDynamicTest.java
+++ b/bundles/org.eclipse.equinox.common.tests/src/org/eclipse/equinox/common/tests/adaptable/AdapterManagerDynamicTest.java
@@ -13,13 +13,19 @@
  *******************************************************************************/
 package org.eclipse.equinox.common.tests.adaptable;
 
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
 import java.io.IOException;
-import junit.framework.TestCase;
 
 import org.eclipse.core.internal.runtime.AdapterManager;
 import org.eclipse.core.runtime.IAdapterManager;
 import org.eclipse.core.tests.harness.BundleTestingHelper;
 import org.eclipse.equinox.common.tests.registry.WaitingRegistryListener;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
 import org.osgi.framework.Bundle;
 import org.osgi.framework.BundleContext;
 import org.osgi.framework.BundleException;
@@ -29,7 +35,7 @@
  * Tests reaction of AdapterManager on addition and removal of adapters from
  * the extension registry.
  */
-public class AdapterManagerDynamicTest extends TestCase {
+public class AdapterManagerDynamicTest {
 
 	final private static int MAX_TIME_PER_BUNDLE = 10000; // maximum time to wait for bundle event in milliseconds
 
@@ -45,30 +51,21 @@
 
 	private IAdapterManager manager;
 
-	public AdapterManagerDynamicTest(String name) {
-		super(name);
-	}
-
-	public AdapterManagerDynamicTest() {
-		super("");
-	}
-
-	@Override
-	protected void setUp() throws Exception {
-		super.setUp();
+	@Before
+	public void setUp() throws Exception {
 		manager = AdapterManager.getDefault();
 	}
 
-	@Override
-	protected void tearDown() throws Exception {
+	@After
+	public void tearDown() throws Exception {
 		manager = null;
-		super.tearDown();
 	}
 
 	/**
 	 * This test uses waiting listener for synchronization (events from bundle being
 	 * installed or un-installed are not propagated right away).
 	 */
+	@Test
 	public void testDynamicBundles() throws IOException, BundleException {
 
 		// check that adapters not available
@@ -89,7 +86,7 @@
 			BundleTestingHelper.refreshPackages(bundleContext, new Bundle[] {bundle01, bundle02});
 
 			// synchronization: listener should receive 2 groups of events
-			assertTrue(listener.waitFor(2, 2 * MAX_TIME_PER_BUNDLE) == 2);
+			assertEquals(2, listener.waitFor(2, 2 * MAX_TIME_PER_BUNDLE));
 
 			// now has to have all 4 adapters
 			assertTrue(manager.hasAdapter(adaptable, BUNDLE1_TYPE_ID));
@@ -102,7 +99,7 @@
 			bundle02 = null;
 
 			// synchronization: listener should receive 1 group of events
-			assertTrue(listener.waitFor(1, MAX_TIME_PER_BUNDLE) == 1);
+			assertEquals(1, listener.waitFor(1, MAX_TIME_PER_BUNDLE));
 
 			// now 2 installed; 2 not
 			assertTrue(manager.hasAdapter(adaptable, BUNDLE1_TYPE_ID));
@@ -115,7 +112,7 @@
 			bundle01 = null;
 
 			// synchronization: listener should receive 1 group of events
-			assertTrue(listener.waitFor(1, MAX_TIME_PER_BUNDLE) == 1);
+			assertEquals(1, listener.waitFor(1, MAX_TIME_PER_BUNDLE));
 
 			// and all should be uninstalled again
 			assertFalse(manager.hasAdapter(adaptable, BUNDLE1_TYPE_ID));
diff --git a/bundles/org.eclipse.equinox.common.tests/src/org/eclipse/equinox/common/tests/adaptable/IAdapterManagerServiceTest.java b/bundles/org.eclipse.equinox.common.tests/src/org/eclipse/equinox/common/tests/adaptable/IAdapterManagerServiceTest.java
index 950330a..aae64bf 100644
--- a/bundles/org.eclipse.equinox.common.tests/src/org/eclipse/equinox/common/tests/adaptable/IAdapterManagerServiceTest.java
+++ b/bundles/org.eclipse.equinox.common.tests/src/org/eclipse/equinox/common/tests/adaptable/IAdapterManagerServiceTest.java
@@ -14,9 +14,14 @@
  *******************************************************************************/
 package org.eclipse.equinox.common.tests.adaptable;
 
-import junit.framework.TestCase;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
 import org.eclipse.core.runtime.IAdapterFactory;
 import org.eclipse.core.runtime.IAdapterManager;
+import org.junit.BeforeClass;
+import org.junit.Test;
 import org.osgi.framework.BundleContext;
 import org.osgi.framework.FrameworkUtil;
 import org.osgi.util.tracker.ServiceTracker;
@@ -27,58 +32,41 @@
  * This class is a copy of IAdapterManagerTest modified to use an OSGi service
  * instead of the Platform API.
  */
-public class IAdapterManagerServiceTest extends TestCase {
+public class IAdapterManagerServiceTest {
 	private static final String NON_EXISTING = "com.does.not.Exist";
 	private static final String TEST_ADAPTER = "org.eclipse.equinox.common.tests.adaptable.TestAdapter";
 
-	private ServiceTracker<IAdapterManager, IAdapterManager> adapterManagerTracker;
-
-	public IAdapterManagerServiceTest(String name) {
-		super(name);
-	}
-
-	public IAdapterManagerServiceTest() {
-		super("");
-	}
+	private static IAdapterManager manager;
 
 	/*
 	 * Return the framework log service, if available.
 	 */
-	public IAdapterManager getAdapterManager() {
-		if (adapterManagerTracker == null) {
-			BundleContext context = FrameworkUtil.getBundle(getClass()).getBundleContext();
-			adapterManagerTracker = new ServiceTracker<>(context, IAdapterManager.class, null);
-			adapterManagerTracker.open();
-		}
-		return adapterManagerTracker.getService();
-	}
-
-	@Override
-	protected void tearDown() throws Exception {
-		if (adapterManagerTracker != null) {
-			adapterManagerTracker.close();
-			adapterManagerTracker = null;
-		}
-		super.tearDown();
+	@BeforeClass
+	public static void getAdapterManager() {
+		BundleContext context = FrameworkUtil.getBundle(IAdapterManagerServiceTest.class).getBundleContext();
+		ServiceTracker<IAdapterManager, IAdapterManager> adapterManagerTracker = new ServiceTracker<>(context,
+				IAdapterManager.class, null);
+		adapterManagerTracker.open();
+		manager = adapterManagerTracker.getService();
+		adapterManagerTracker.close();
 	}
 
 	/**
 	 * Tests API method IAdapterManager.hasAdapter.
 	 */
+	@Test
 	public void testHasAdapter() {
-		IAdapterManager manager = getAdapterManager();
-
 		TestAdaptable adaptable = new TestAdaptable();
-		//request non-existing adaptable
-		assertTrue("1.0", !manager.hasAdapter("", NON_EXISTING));
+		// request non-existing adaptable
+		assertFalse("1.0", manager.hasAdapter("", NON_EXISTING));
 
-		//request adapter that is in XML but has no registered factory
+		// request adapter that is in XML but has no registered factory
 		assertTrue("1.1", manager.hasAdapter(adaptable, TEST_ADAPTER));
 
-		//request adapter that is not in XML
-		assertTrue("1.2", !manager.hasAdapter(adaptable, "java.lang.String"));
+		// request adapter that is not in XML
+		assertFalse("1.2", manager.hasAdapter(adaptable, "java.lang.String"));
 
-		//register an adapter factory that maps adaptables to strings
+		// register an adapter factory that maps adaptables to strings
 		IAdapterFactory fac = new IAdapterFactory() {
 			@Override
 			public <T> T getAdapter(Object adaptableObject, Class<T> adapterType) {
@@ -90,39 +78,38 @@
 
 			@Override
 			public Class<?>[] getAdapterList() {
-				return new Class[] {String.class};
+				return new Class[] { String.class };
 			}
 		};
 		manager.registerAdapters(fac, TestAdaptable.class);
 		try {
-			//request adapter for factory that we've just added
+			// request adapter for factory that we've just added
 			assertTrue("1.3", manager.hasAdapter(adaptable, "java.lang.String"));
 		} finally {
 			manager.unregisterAdapters(fac, TestAdaptable.class);
 		}
 
-		//request adapter that was unloaded
-		assertTrue("1.4", !manager.hasAdapter(adaptable, "java.lang.String"));
+		// request adapter that was unloaded
+		assertFalse("1.4", manager.hasAdapter(adaptable, "java.lang.String"));
 	}
 
 	/**
 	 * Tests API method IAdapterManager.getAdapter.
 	 */
+	@Test
 	public void testGetAdapter() {
-		IAdapterManager manager = getAdapterManager();
-
 		TestAdaptable adaptable = new TestAdaptable();
-		//request non-existing adaptable
+		// request non-existing adaptable
 		assertNull("1.0", manager.getAdapter("", NON_EXISTING));
 
-		//request adapter that is in XML but has no registered factory
+		// request adapter that is in XML but has no registered factory
 		Object result = manager.getAdapter(adaptable, TEST_ADAPTER);
 		assertTrue("1.1", result instanceof TestAdapter);
 
-		//request adapter that is not in XML
+		// request adapter that is not in XML
 		assertNull("1.2", manager.getAdapter(adaptable, "java.lang.String"));
 
-		//register an adapter factory that maps adaptables to strings
+		// register an adapter factory that maps adaptables to strings
 		IAdapterFactory fac = new IAdapterFactory() {
 			@Override
 			public <T> T getAdapter(Object adaptableObject, Class<T> adapterType) {
@@ -134,39 +121,38 @@
 
 			@Override
 			public Class<?>[] getAdapterList() {
-				return new Class[] {String.class};
+				return new Class[] { String.class };
 			}
 		};
 		manager.registerAdapters(fac, TestAdaptable.class);
 		try {
-			//request adapter for factory that we've just added
+			// request adapter for factory that we've just added
 			result = manager.getAdapter(adaptable, "java.lang.String");
 			assertTrue("1.3", result instanceof String);
 		} finally {
 			manager.unregisterAdapters(fac, TestAdaptable.class);
 		}
-		//request adapter that was unloaded
+		// request adapter that was unloaded
 		assertNull("1.4", manager.getAdapter(adaptable, "java.lang.String"));
 	}
 
 	/**
 	 * Tests API method IAdapterManager.loadAdapter.
 	 */
+	@Test
 	public void testLoadAdapter() {
-		IAdapterManager manager = getAdapterManager();
-
 		TestAdaptable adaptable = new TestAdaptable();
-		//request non-existing adaptable
+		// request non-existing adaptable
 		assertNull("1.0", manager.loadAdapter("", NON_EXISTING));
 
-		//request adapter that is in XML but has no registered factory
+		// request adapter that is in XML but has no registered factory
 		Object result = manager.loadAdapter(adaptable, TEST_ADAPTER);
 		assertTrue("1.1", result instanceof TestAdapter);
 
-		//request adapter that is not in XML
+		// request adapter that is not in XML
 		assertNull("1.2", manager.loadAdapter(adaptable, "java.lang.String"));
 
-		//register an adapter factory that maps adaptables to strings
+		// register an adapter factory that maps adaptables to strings
 		IAdapterFactory fac = new IAdapterFactory() {
 			@Override
 			public <T> T getAdapter(Object adaptableObject, Class<T> adapterType) {
@@ -178,18 +164,18 @@
 
 			@Override
 			public Class<?>[] getAdapterList() {
-				return new Class[] {String.class};
+				return new Class[] { String.class };
 			}
 		};
 		manager.registerAdapters(fac, TestAdaptable.class);
 		try {
-			//request adapter for factory that we've just added
+			// request adapter for factory that we've just added
 			result = manager.loadAdapter(adaptable, "java.lang.String");
 			assertTrue("1.3", result instanceof String);
 		} finally {
 			manager.unregisterAdapters(fac, TestAdaptable.class);
 		}
-		//request adapter that was unloaded
+		// request adapter that was unloaded
 		assertNull("1.4", manager.loadAdapter(adaptable, "java.lang.String"));
 	}
 }
diff --git a/bundles/org.eclipse.equinox.common.tests/src/org/eclipse/equinox/common/tests/adaptable/IAdapterManagerTest.java b/bundles/org.eclipse.equinox.common.tests/src/org/eclipse/equinox/common/tests/adaptable/IAdapterManagerTest.java
index 07697e2..191ce0d 100644
--- a/bundles/org.eclipse.equinox.common.tests/src/org/eclipse/equinox/common/tests/adaptable/IAdapterManagerTest.java
+++ b/bundles/org.eclipse.equinox.common.tests/src/org/eclipse/equinox/common/tests/adaptable/IAdapterManagerTest.java
@@ -13,13 +13,23 @@
  *******************************************************************************/
 package org.eclipse.equinox.common.tests.adaptable;
 
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertThrows;
+import static org.junit.Assert.assertTrue;
+
 import java.io.IOException;
 import java.net.MalformedURLException;
-import junit.framework.TestCase;
 
 import org.eclipse.core.internal.runtime.AdapterManager;
-import org.eclipse.core.runtime.*;
+import org.eclipse.core.runtime.AssertionFailedException;
+import org.eclipse.core.runtime.IAdapterFactory;
+import org.eclipse.core.runtime.IAdapterManager;
 import org.eclipse.core.tests.harness.BundleTestingHelper;
+import org.junit.Before;
+import org.junit.Test;
 import org.osgi.framework.Bundle;
 import org.osgi.framework.BundleContext;
 import org.osgi.framework.BundleException;
@@ -28,21 +38,21 @@
 /**
  * Tests API on the IAdapterManager class.
  */
-public class IAdapterManagerTest extends TestCase {
-	//following classes are for testComputeClassOrder
-	static interface C {
+public class IAdapterManagerTest {
+	// following classes are for testComputeClassOrder
+	interface C {
 	}
 
-	static interface D {
+	interface D {
 	}
 
-	static interface M {
+	interface M {
 	}
 
-	static interface N {
+	interface N {
 	}
 
-	static interface O {
+	interface O {
 	}
 
 	interface A extends M, N {
@@ -62,34 +72,27 @@
 	private static final String TEST_ADAPTER_CL = "testAdapter.testUnknown";
 	private IAdapterManager manager;
 
-	public IAdapterManagerTest(String name) {
-		super(name);
-	}
-
-	public IAdapterManagerTest() {
-		super("");
-	}
-
-	@Override
-	protected void setUp() throws Exception {
+	@Before
+	public void setUp() throws Exception {
 		manager = AdapterManager.getDefault();
 	}
 
 	/**
 	 * Tests API method IAdapterManager.hasAdapter.
 	 */
+	@Test
 	public void testHasAdapter() {
 		TestAdaptable adaptable = new TestAdaptable();
-		//request non-existing adaptable
-		assertTrue("1.0", !manager.hasAdapter("", NON_EXISTING));
+		// request non-existing adaptable
+		assertFalse("1.0", manager.hasAdapter("", NON_EXISTING));
 
-		//request adapter that is in XML but has no registered factory
+		// request adapter that is in XML but has no registered factory
 		assertTrue("1.1", manager.hasAdapter(adaptable, TEST_ADAPTER));
 
-		//request adapter that is not in XML
-		assertTrue("1.2", !manager.hasAdapter(adaptable, "java.lang.String"));
+		// request adapter that is not in XML
+		assertFalse("1.2", manager.hasAdapter(adaptable, "java.lang.String"));
 
-		//register an adapter factory that maps adaptables to strings
+		// register an adapter factory that maps adaptables to strings
 		IAdapterFactory fac = new IAdapterFactory() {
 			@Override
 			public <T> T getAdapter(Object adaptableObject, Class<T> adapterType) {
@@ -101,37 +104,38 @@
 
 			@Override
 			public Class<?>[] getAdapterList() {
-				return new Class[] {String.class};
+				return new Class[] { String.class };
 			}
 		};
 		manager.registerAdapters(fac, TestAdaptable.class);
 		try {
-			//request adapter for factory that we've just added
+			// request adapter for factory that we've just added
 			assertTrue("1.3", manager.hasAdapter(adaptable, "java.lang.String"));
 		} finally {
 			manager.unregisterAdapters(fac, TestAdaptable.class);
 		}
 
-		//request adapter that was unloaded
-		assertTrue("1.4", !manager.hasAdapter(adaptable, "java.lang.String"));
+		// request adapter that was unloaded
+		assertFalse("1.4", manager.hasAdapter(adaptable, "java.lang.String"));
 	}
 
 	/**
 	 * Tests API method IAdapterManager.getAdapter.
 	 */
+	@Test
 	public void testGetAdapter() {
 		TestAdaptable adaptable = new TestAdaptable();
-		//request non-existing adaptable
+		// request non-existing adaptable
 		assertNull("1.0", manager.getAdapter("", NON_EXISTING));
 
-		//request adapter that is in XML but has no registered factory
+		// request adapter that is in XML but has no registered factory
 		Object result = manager.getAdapter(adaptable, TEST_ADAPTER);
 		assertTrue("1.1", result instanceof TestAdapter);
 
-		//request adapter that is not in XML
+		// request adapter that is not in XML
 		assertNull("1.2", manager.getAdapter(adaptable, "java.lang.String"));
 
-		//register an adapter factory that maps adaptables to strings
+		// register an adapter factory that maps adaptables to strings
 		IAdapterFactory fac = new IAdapterFactory() {
 			@Override
 			public <T> T getAdapter(Object adaptableObject, Class<T> adapterType) {
@@ -143,54 +147,45 @@
 
 			@Override
 			public Class<?>[] getAdapterList() {
-				return new Class[] {String.class};
+				return new Class[] { String.class };
 			}
 		};
 		manager.registerAdapters(fac, TestAdaptable.class);
 		try {
-			//request adapter for factory that we've just added
+			// request adapter for factory that we've just added
 			result = manager.getAdapter(adaptable, "java.lang.String");
 			assertTrue("1.3", result instanceof String);
 		} finally {
 			manager.unregisterAdapters(fac, TestAdaptable.class);
 		}
-		//request adapter that was unloaded
+		// request adapter that was unloaded
 		assertNull("1.4", manager.getAdapter(adaptable, "java.lang.String"));
 	}
 
+	@Test
 	public void testGetAdapterNullArgs() {
 		TestAdaptable adaptable = new TestAdaptable();
-		try {
-			manager.getAdapter(adaptable, (Class<?>) null);
-			fail("1.0");
-		} catch (RuntimeException e) {
-			//expected
-		}
-		try {
-			manager.getAdapter(null, NON_EXISTING);
-			fail("1.0");
-		} catch (RuntimeException e) {
-			//expected
-		}
-
+		assertThrows(RuntimeException.class, () -> manager.getAdapter(adaptable, (Class<?>) null));
+		assertThrows(RuntimeException.class, () -> manager.getAdapter(null, NON_EXISTING));
 	}
 
 	/**
 	 * Tests API method IAdapterManager.loadAdapter.
 	 */
+	@Test
 	public void testLoadAdapter() {
 		TestAdaptable adaptable = new TestAdaptable();
-		//request non-existing adaptable
+		// request non-existing adaptable
 		assertNull("1.0", manager.loadAdapter("", NON_EXISTING));
 
-		//request adapter that is in XML but has no registered factory
+		// request adapter that is in XML but has no registered factory
 		Object result = manager.loadAdapter(adaptable, TEST_ADAPTER);
 		assertTrue("1.1", result instanceof TestAdapter);
 
-		//request adapter that is not in XML
+		// request adapter that is not in XML
 		assertNull("1.2", manager.loadAdapter(adaptable, "java.lang.String"));
 
-		//register an adapter factory that maps adaptables to strings
+		// register an adapter factory that maps adaptables to strings
 		IAdapterFactory fac = new IAdapterFactory() {
 			@Override
 			public <T> T getAdapter(Object adaptableObject, Class<T> adapterType) {
@@ -202,27 +197,27 @@
 
 			@Override
 			public Class<?>[] getAdapterList() {
-				return new Class[] {String.class};
+				return new Class[] { String.class };
 			}
 		};
 		manager.registerAdapters(fac, TestAdaptable.class);
 		try {
-			//request adapter for factory that we've just added
+			// request adapter for factory that we've just added
 			result = manager.loadAdapter(adaptable, "java.lang.String");
 			assertTrue("1.3", result instanceof String);
 		} finally {
 			manager.unregisterAdapters(fac, TestAdaptable.class);
 		}
-		//request adapter that was unloaded
+		// request adapter that was unloaded
 		assertNull("1.4", manager.loadAdapter(adaptable, "java.lang.String"));
 	}
 
 	/**
 	 * Test adapting to classes not reachable by the default bundle class loader
-	 * (bug 200068).
-	 * NOTE: This test uses .class file compiled with 1.4 JRE. As a result,
-	 * the test can not be run on pre-1.4 JRE.
+	 * (bug 200068). NOTE: This test uses .class file compiled with 1.4 JRE. As a
+	 * result, the test can not be run on pre-1.4 JRE.
 	 */
+	@Test
 	public void testAdapterClassLoader() throws MalformedURLException, BundleException, IOException {
 		TestAdaptable adaptable = new TestAdaptable();
 		assertTrue(manager.hasAdapter(adaptable, TEST_ADAPTER_CL));
@@ -230,8 +225,9 @@
 		Bundle bundle = null;
 		try {
 			BundleContext bundleContext = FrameworkUtil.getBundle(getClass()).getBundleContext();
-			bundle = BundleTestingHelper.installBundle("0.1", bundleContext, "Plugin_Testing/adapters/testAdapter_1.0.0");
-			BundleTestingHelper.refreshPackages(bundleContext, new Bundle[] {bundle});
+			bundle = BundleTestingHelper.installBundle("0.1", bundleContext,
+					"Plugin_Testing/adapters/testAdapter_1.0.0");
+			BundleTestingHelper.refreshPackages(bundleContext, new Bundle[] { bundle });
 
 			assertTrue(manager.hasAdapter(adaptable, TEST_ADAPTER_CL));
 			Object result = manager.loadAdapter(adaptable, TEST_ADAPTER_CL);
@@ -247,6 +243,7 @@
 	/**
 	 * Tests for {@link IAdapterManager#computeClassOrder(Class)}.
 	 */
+	@Test
 	public void testComputeClassOrder() {
 		Class<?>[] expected = new Class[] { X.class, Y.class, Object.class, A.class, B.class, M.class, N.class, O.class,
 				C.class, D.class };
@@ -257,6 +254,7 @@
 		}
 	}
 
+	@Test
 	public void testFactoryViolatingContract() {
 		class Private {
 		}
@@ -279,14 +277,12 @@
 		};
 		try {
 			manager.registerAdapters(fac, Private.class);
-			try {
-				manager.getAdapter(new Private(), Private.class);
-				fail("Should throw AssertionFailedException!");
-			} catch (AssertionFailedException e) {
-				assertTrue(e.getMessage().contains(fac.getClass().getName()));
-				assertTrue(e.getMessage().contains(Boolean.class.getName()));
-				assertTrue(e.getMessage().contains(Private.class.getName()));
-			}
+			AssertionFailedException e = assertThrows(
+					AssertionFailedException.class,
+					() -> manager.getAdapter(new Private(), Private.class));
+			assertTrue(e.getMessage().contains(fac.getClass().getName()));
+			assertTrue(e.getMessage().contains(Boolean.class.getName()));
+			assertTrue(e.getMessage().contains(Private.class.getName()));
 		} finally {
 			manager.unregisterAdapters(fac, Private.class);
 		}
diff --git a/bundles/org.eclipse.equinox.common.tests/src/org/eclipse/equinox/common/tests/registry/ContributorsTest.java b/bundles/org.eclipse.equinox.common.tests/src/org/eclipse/equinox/common/tests/registry/ContributorsTest.java
index 46132e3..53924c0 100644
--- a/bundles/org.eclipse.equinox.common.tests/src/org/eclipse/equinox/common/tests/registry/ContributorsTest.java
+++ b/bundles/org.eclipse.equinox.common.tests/src/org/eclipse/equinox/common/tests/registry/ContributorsTest.java
@@ -13,6 +13,7 @@
  *******************************************************************************/
 package org.eclipse.equinox.common.tests.registry;
 
+import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertTrue;
@@ -20,7 +21,14 @@
 import java.io.IOException;
 import java.io.InputStream;
 import java.net.URL;
-import org.eclipse.core.runtime.*;
+
+import org.eclipse.core.runtime.ContributorFactoryOSGi;
+import org.eclipse.core.runtime.ContributorFactorySimple;
+import org.eclipse.core.runtime.IContributor;
+import org.eclipse.core.runtime.IExtension;
+import org.eclipse.core.runtime.IExtensionPoint;
+import org.eclipse.core.runtime.IExtensionRegistry;
+import org.eclipse.core.runtime.RegistryFactory;
 import org.eclipse.core.runtime.spi.IDynamicExtensionRegistry;
 import org.eclipse.core.tests.harness.BundleTestingHelper;
 import org.junit.Test;
@@ -43,8 +51,9 @@
 		try {
 			BundleContext bundleContext = FrameworkUtil.getBundle(getClass()).getBundleContext();
 			bundle = BundleTestingHelper.installBundle("0.1", bundleContext, "Plugin_Testing/registry/contributors/A");
-			fragment = BundleTestingHelper.installBundle("0.2", bundleContext, "Plugin_Testing/registry/contributors/B");
-			BundleTestingHelper.refreshPackages(bundleContext, new Bundle[] {bundle, fragment});
+			fragment = BundleTestingHelper.installBundle("0.2", bundleContext,
+					"Plugin_Testing/registry/contributors/B");
+			BundleTestingHelper.refreshPackages(bundleContext, new Bundle[] { bundle, fragment });
 
 			IExtensionRegistry registry = RegistryFactory.getRegistry();
 			IExtensionPoint bundleExtPoint = registry.getExtensionPoint("testContributors.xptContibutorsA");
@@ -69,9 +78,9 @@
 	}
 
 	/**
-	 * bundleA, bundleB, and fragment on bundleA all use the same namespace. Verify that getting
-	 * elements by contributor returns all elements from the contributor and only from that
-	 * contributor.
+	 * bundleA, bundleB, and fragment on bundleA all use the same namespace. Verify
+	 * that getting elements by contributor returns all elements from the
+	 * contributor and only from that contributor.
 	 *
 	 * @throws IOException
 	 * @throws BundleException
@@ -83,10 +92,13 @@
 		Bundle fragment = null;
 		try {
 			BundleContext bundleContext = FrameworkUtil.getBundle(getClass()).getBundleContext();
-			bundleA = BundleTestingHelper.installBundle("0.1", bundleContext, "Plugin_Testing/registry/elementsByContributor/A");
-			bundleB = BundleTestingHelper.installBundle("0.2", bundleContext, "Plugin_Testing/registry/elementsByContributor/B");
-			fragment = BundleTestingHelper.installBundle("0.2", bundleContext, "Plugin_Testing/registry/elementsByContributor/Afragment");
-			BundleTestingHelper.refreshPackages(bundleContext, new Bundle[] {bundleA, bundleB, fragment});
+			bundleA = BundleTestingHelper.installBundle("0.1", bundleContext,
+					"Plugin_Testing/registry/elementsByContributor/A");
+			bundleB = BundleTestingHelper.installBundle("0.2", bundleContext,
+					"Plugin_Testing/registry/elementsByContributor/B");
+			fragment = BundleTestingHelper.installBundle("0.2", bundleContext,
+					"Plugin_Testing/registry/elementsByContributor/Afragment");
+			BundleTestingHelper.refreshPackages(bundleContext, new Bundle[] { bundleA, bundleB, fragment });
 
 			IExtensionRegistry registry = RegistryFactory.getRegistry();
 
@@ -95,24 +107,25 @@
 
 			IExtensionPoint[] extPointsA = registry.getExtensionPoints(contributorA);
 			assertNotNull(extPointsA);
-			assertTrue(extPointsA.length == 1);
+			assertEquals(1, extPointsA.length);
 			assertTrue(extPointsA[0].getUniqueIdentifier().equals("org.eclipse.test.registryByContrib.PointA"));
 
 			IExtension[] extsA = registry.getExtensions(contributorA);
 			assertNotNull(extsA);
-			assertTrue(extsA.length == 1);
+			assertEquals(1, extsA.length);
 			assertTrue(extsA[0].getUniqueIdentifier().equals("org.eclipse.test.registryByContrib.ExtensionA"));
 
 			// verify fragment
 			IContributor contributorAF = ContributorFactoryOSGi.createContributor(fragment);
 			IExtensionPoint[] extPointsFragmentA = registry.getExtensionPoints(contributorAF);
 			assertNotNull(extPointsFragmentA);
-			assertTrue(extPointsFragmentA.length == 1);
-			assertTrue(extPointsFragmentA[0].getUniqueIdentifier().equals("org.eclipse.test.registryByContrib.PointFA"));
+			assertEquals(1, extPointsFragmentA.length);
+			assertTrue(
+					extPointsFragmentA[0].getUniqueIdentifier().equals("org.eclipse.test.registryByContrib.PointFA"));
 
 			IExtension[] extsFragmentA = registry.getExtensions(contributorAF);
 			assertNotNull(extsFragmentA);
-			assertTrue(extsFragmentA.length == 1);
+			assertEquals(1, extsFragmentA.length);
 			assertTrue(extsFragmentA[0].getUniqueIdentifier().equals("org.eclipse.test.registryByContrib.ExtensionFA"));
 
 		} finally {
@@ -129,8 +142,10 @@
 	}
 
 	/**
-	 * Checks {@link IDynamicExtensionRegistry#removeContributor(IContributor, Object)}. A separate
-	 * registry is created as removal functionality is not allowed by the default Eclipse registry.
+	 * Checks
+	 * {@link IDynamicExtensionRegistry#removeContributor(IContributor, Object)}. A
+	 * separate registry is created as removal functionality is not allowed by the
+	 * default Eclipse registry.
 	 *
 	 * @throws IOException
 	 * @throws BundleException
@@ -148,7 +163,7 @@
 
 		IContributor[] contributors = ((IDynamicExtensionRegistry) registry).getAllContributors();
 		assertNotNull(contributors);
-		assertTrue(contributors.length == 2);
+		assertEquals(2, contributors.length);
 		IContributor contributorB = null;
 		for (IContributor contributor : contributors) {
 			if ("B".equals(contributor.getName())) {
@@ -168,7 +183,8 @@
 		String fullPath = "Plugin_Testing/registry/elementsByContributor/" + fileName + "/plugin.xml";
 		URL urlA = FrameworkUtil.getBundle(getClass()).getEntry(fullPath);
 		if (urlA == null) {
-			throw new IOException("No entry to '"+fullPath+"' could be found or caller does not have the appropriate permissions.");//$NON-NLS-1$ //$NON-NLS-2$
+			throw new IOException("No entry to '" + fullPath //$NON-NLS-1$
+					+ "' could be found or caller does not have the appropriate permissions.");//$NON-NLS-1$
 		}
 		InputStream is = urlA.openStream();
 		IContributor nonBundleContributor = ContributorFactorySimple.createContributor(fileName);
diff --git a/bundles/org.eclipse.equinox.common.tests/src/org/eclipse/equinox/common/tests/registry/InputErrorTest.java b/bundles/org.eclipse.equinox.common.tests/src/org/eclipse/equinox/common/tests/registry/InputErrorTest.java
index 89ca84a..47efa40 100644
--- a/bundles/org.eclipse.equinox.common.tests/src/org/eclipse/equinox/common/tests/registry/InputErrorTest.java
+++ b/bundles/org.eclipse.equinox.common.tests/src/org/eclipse/equinox/common/tests/registry/InputErrorTest.java
@@ -13,6 +13,7 @@
  *******************************************************************************/
 package org.eclipse.equinox.common.tests.registry;
 
+import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertNull;
@@ -151,7 +152,7 @@
 		IExtension extensionA = registry.getExtension(extID);
 		assertNotNull(extensionA);
 		IConfigurationElement[] configElements = extensionA.getConfigurationElements();
-		assertTrue(configElements.length == 1);
+		assertEquals(1, configElements.length);
 		String value = configElements[0].getAttribute("testAttr");
 		assertTrue(expectedValue.equals(value));
 	}
diff --git a/bundles/org.eclipse.equinox.common.tests/src/org/eclipse/equinox/common/tests/registry/NamespaceTest.java b/bundles/org.eclipse.equinox.common.tests/src/org/eclipse/equinox/common/tests/registry/NamespaceTest.java
index b647791..78ab0c4 100644
--- a/bundles/org.eclipse.equinox.common.tests/src/org/eclipse/equinox/common/tests/registry/NamespaceTest.java
+++ b/bundles/org.eclipse.equinox.common.tests/src/org/eclipse/equinox/common/tests/registry/NamespaceTest.java
@@ -13,12 +13,16 @@
  *******************************************************************************/
 package org.eclipse.equinox.common.tests.registry;
 
+import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertTrue;
 
 import java.io.IOException;
-import org.eclipse.core.runtime.*;
+
+import org.eclipse.core.runtime.IExtension;
+import org.eclipse.core.runtime.IExtensionPoint;
+import org.eclipse.core.runtime.RegistryFactory;
 import org.eclipse.core.tests.harness.BundleTestingHelper;
 import org.junit.FixMethodOrder;
 import org.junit.Test;
@@ -56,22 +60,22 @@
 		// Check linkage extension <-> extension point
 		assertTrue(ext.getExtensionPointUniqueIdentifier().equals(extpt.getUniqueIdentifier()));
 		IExtension[] extensions = extpt.getExtensions();
-		assertTrue(extensions.length == 1);
+		assertEquals(1, extensions.length);
 		assertTrue(extensions[0].equals(ext));
 
 		// Exactly one extension and one extension point in the "org.abc" namespace
 		IExtensionPoint[] namespaceExtensionPoints = RegistryFactory.getRegistry().getExtensionPoints("org.abc");
-		assertTrue(namespaceExtensionPoints.length == 1);
+		assertEquals(1, namespaceExtensionPoints.length);
 		assertTrue(namespaceExtensionPoints[0].equals(extpt));
 		IExtension[] namespaceExtensions = RegistryFactory.getRegistry().getExtensions("org.abc");
-		assertTrue(namespaceExtensions.length == 1);
+		assertEquals(1, namespaceExtensions.length);
 		assertTrue(namespaceExtensions[0].equals(ext));
 
 		// There should not be extension points or extensions in the default namespace
 		IExtensionPoint[] defaultExtensionPoints = RegistryFactory.getRegistry().getExtensionPoints("testNamespace1");
-		assertTrue(defaultExtensionPoints.length == 0);
+		assertEquals(0, defaultExtensionPoints.length);
 		IExtension[] defaultExtensions = RegistryFactory.getRegistry().getExtensions("testNamespace1");
-		assertTrue(defaultExtensions.length == 0);
+		assertEquals(0, defaultExtensions.length);
 
 		// remove the first bundle
 		bundle01.uninstall();
@@ -100,10 +104,10 @@
 
 		// Exactly one extension and one extension point in the "org.abc" namespace
 		IExtensionPoint[] namespaceExtensionPoints2 = RegistryFactory.getRegistry().getExtensionPoints("org.abc");
-		assertTrue(namespaceExtensionPoints2.length == 1);
+		assertEquals(1, namespaceExtensionPoints2.length);
 		assertTrue(namespaceExtensionPoints2[0].equals(extpt2));
 		IExtension[] namespaceExtensions2 = RegistryFactory.getRegistry().getExtensions("org.abc");
-		assertTrue(namespaceExtensions2.length == 1);
+		assertEquals(1, namespaceExtensions2.length);
 		assertTrue(namespaceExtensions2[0].equals(ext2));
 
 		// remove the second bundle
diff --git a/bundles/org.eclipse.equinox.common.tests/src/org/eclipse/equinox/common/tests/registry/RegistryListenerTest.java b/bundles/org.eclipse.equinox.common.tests/src/org/eclipse/equinox/common/tests/registry/RegistryListenerTest.java
index a3253f4..ab532a5 100644
--- a/bundles/org.eclipse.equinox.common.tests/src/org/eclipse/equinox/common/tests/registry/RegistryListenerTest.java
+++ b/bundles/org.eclipse.equinox.common.tests/src/org/eclipse/equinox/common/tests/registry/RegistryListenerTest.java
@@ -13,6 +13,8 @@
  *******************************************************************************/
 package org.eclipse.equinox.common.tests.registry;
 
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertTrue;
@@ -37,7 +39,7 @@
 	final private static int MAX_TIME_PER_BUNDLE = 10000; // maximum time to wait for bundle event in milliseconds
 
 	private static BundleContext fBundleContext;
-	
+
 	@BeforeClass
 	public static void setUp() throws Exception {
 		fBundleContext = FrameworkUtil.getBundle(RegistryListenerTest.class).getBundleContext();
@@ -64,11 +66,11 @@
 			assertTrue(listener.isAdded());
 
 			assertNotNull(extPointIDs);
-			assertTrue(extPointIDs.length == 1);
+			assertEquals(1, extPointIDs.length);
 			assertTrue("bundle01.xp1".equals(extPointIDs[0]));
 
 			assertNotNull(extensionsReceived);
-			assertTrue(extensionsReceived.length == 1);
+			assertEquals(1, extensionsReceived.length);
 			assertTrue("bundle02.ext1".equals(extensionsReceived[0]));
 
 			listener.reset();
@@ -84,11 +86,11 @@
 			assertTrue(listener.isRemoved());
 
 			assertNotNull(extPointIDs);
-			assertTrue(extPointIDs.length == 1);
+			assertEquals(1, extPointIDs.length);
 			assertTrue("bundle01.xp1".equals(extPointIDs[0]));
 
 			assertNotNull(extensionsReceived);
-			assertTrue(extensionsReceived.length == 1);
+			assertEquals(1, extensionsReceived.length);
 			assertTrue("bundle02.ext1".equals(extensionsReceived[0]));
 
 		} finally {
@@ -123,11 +125,11 @@
 			assertTrue(listener.isAdded());
 
 			assertNotNull(extPointIDs);
-			assertTrue(extPointIDs.length == 1);
+			assertEquals(1, extPointIDs.length);
 			assertTrue("bundle01.xp1".equals(extPointIDs[0]));
 
 			assertNotNull(extensionsReceived);
-			assertTrue(extensionsReceived.length == 1);
+			assertEquals(1, extensionsReceived.length);
 			assertTrue("bundle02.ext1".equals(extensionsReceived[0]));
 
 			listener.reset();
@@ -143,11 +145,11 @@
 			assertTrue(listener.isRemoved());
 
 			assertNotNull(extPointIDs);
-			assertTrue(extPointIDs.length == 1);
+			assertEquals(1, extPointIDs.length);
 			assertTrue("bundle01.xp1".equals(extPointIDs[0]));
 
 			assertNotNull(extensionsReceived);
-			assertTrue(extensionsReceived.length == 1);
+			assertEquals(1, extensionsReceived.length);
 			assertTrue("bundle02.ext1".equals(extensionsReceived[0]));
 
 		} finally {
@@ -184,21 +186,21 @@
 			String[] extPointIDs = listenerGlobal.extPointsReceived(MAX_TIME_PER_BUNDLE);
 			String[] extensionsReceived = listenerGlobal.extensionsReceived(MAX_TIME_PER_BUNDLE);
 			assertTrue(listenerGlobal.isAdded());
-			checkIDs(extPointIDs, new String[] {"bundleMultiple.xp1", "bundleMultiple.xp2"});
-			checkIDs(extensionsReceived, new String[] {"bundleMultiple.ext11", "bundleMultiple.ext12"});
+			assertArrayEquals(extPointIDs, new String[] { "bundleMultiple.xp1", "bundleMultiple.xp2" });
+			assertArrayEquals(extensionsReceived, new String[] { "bundleMultiple.ext11", "bundleMultiple.ext12" });
 
 			// test additions on listener on extension point with extensions
 			String[] extPointIDs1 = listener1.extPointsReceived(20000);
 			String[] extensionsReceived1 = listener1.extensionsReceived(20000);
 			assertTrue(listener1.isAdded());
-			checkIDs(extPointIDs1, new String[] {"bundleMultiple.xp1"});
-			checkIDs(extensionsReceived1, new String[] {"bundleMultiple.ext11", "bundleMultiple.ext12"});
+			assertArrayEquals(extPointIDs1, new String[] { "bundleMultiple.xp1" });
+			assertArrayEquals(extensionsReceived1, new String[] { "bundleMultiple.ext11", "bundleMultiple.ext12" });
 
 			// test additions on listener on extension point with no extensions
 			String[] extPointIDs2 = listener2.extPointsReceived(MAX_TIME_PER_BUNDLE);
 			String[] extensionsReceived2 = listener2.extensionsReceived(50);
 			assertTrue(listener2.isAdded());
-			checkIDs(extPointIDs2, new String[] {"bundleMultiple.xp2"});
+			assertArrayEquals(extPointIDs2, new String[] { "bundleMultiple.xp2" });
 			assertNull(extensionsReceived2);
 
 			// removal
@@ -213,21 +215,21 @@
 			extPointIDs = listenerGlobal.extPointsReceived(MAX_TIME_PER_BUNDLE);
 			extensionsReceived = listenerGlobal.extensionsReceived(MAX_TIME_PER_BUNDLE);
 			assertTrue(listenerGlobal.isRemoved());
-			checkIDs(extPointIDs, new String[] {"bundleMultiple.xp1", "bundleMultiple.xp2"});
-			checkIDs(extensionsReceived, new String[] {"bundleMultiple.ext11", "bundleMultiple.ext12"});
+			assertArrayEquals(extPointIDs, new String[] { "bundleMultiple.xp1", "bundleMultiple.xp2" });
+			assertArrayEquals(extensionsReceived, new String[] { "bundleMultiple.ext11", "bundleMultiple.ext12" });
 
 			// test removals on listener on extension point with extensions
 			extPointIDs1 = listener1.extPointsReceived(MAX_TIME_PER_BUNDLE);
 			extensionsReceived1 = listener1.extensionsReceived(MAX_TIME_PER_BUNDLE);
 			assertTrue(listener1.isRemoved());
-			checkIDs(extPointIDs1, new String[] {"bundleMultiple.xp1"});
-			checkIDs(extensionsReceived1, new String[] {"bundleMultiple.ext11", "bundleMultiple.ext12"});
+			assertArrayEquals(extPointIDs1, new String[] { "bundleMultiple.xp1" });
+			assertArrayEquals(extensionsReceived1, new String[] { "bundleMultiple.ext11", "bundleMultiple.ext12" });
 
 			// test removals on listener on extension point with no extensions
 			extPointIDs2 = listener2.extPointsReceived(MAX_TIME_PER_BUNDLE);
 			extensionsReceived2 = listener2.extensionsReceived(50);
 			assertTrue(listener2.isRemoved());
-			checkIDs(extPointIDs2, new String[] {"bundleMultiple.xp2"});
+			assertArrayEquals(extPointIDs2, new String[] { "bundleMultiple.xp2" });
 			assertNull(extensionsReceived2);
 
 		} finally {
@@ -258,14 +260,14 @@
 			// 1st registration: extension point; extension		=> 2 callbacks
 			// 2nd registration should be ignored: extension	=> 0 callbacks
 			// total: 2 callbacks
-			assertTrue(listener.waitFor(2, MAX_TIME_PER_BUNDLE) == 2);
+			assertEquals(2, listener.waitFor(2, MAX_TIME_PER_BUNDLE));
 
 			// test additions on listener on extension point with extensions
 			String[] extPointIDs = listener.extPointsReceived(50);
 			String[] extensionsReceived = listener.extensionsReceived(50);
 			assertTrue(listener.isAdded());
-			checkIDs(extPointIDs, new String[] {"bundleMultiple.xp1"});
-			checkIDs(extensionsReceived, new String[] {"bundleMultiple.ext11", "bundleMultiple.ext12"});
+			assertArrayEquals(extPointIDs, new String[] { "bundleMultiple.xp1" });
+			assertArrayEquals(extensionsReceived, new String[] { "bundleMultiple.ext11", "bundleMultiple.ext12" });
 
 			// removal: unregistering listener once should remove both registrations
 			listener.reset();
@@ -275,7 +277,7 @@
 			BundleTestingHelper.refreshPackages(fBundleContext, testBundles);
 
 			// test removals on listener on extension point with extensions
-			assertTrue(listener.waitFor(3, 200) == 0);
+			assertEquals(0, listener.waitFor(3, 200));
 			extPointIDs = listener.extPointsReceived(50);
 			extensionsReceived = listener.extensionsReceived(50);
 			assertNull(extPointIDs);
@@ -289,20 +291,4 @@
 		}
 	}
 
-	// For simplicity, this method does not expect duplicate IDs in either array
-	private void checkIDs(String[] receivedIDs, String[] expectedIDs) {
-		assertNotNull(receivedIDs);
-		assertNotNull(expectedIDs);
-		assertTrue(receivedIDs.length == expectedIDs.length);
-		for (String expected : expectedIDs) {
-			boolean found = false;
-			for (String receivedID : receivedIDs) {
-				if (expected.equals(receivedID)) {
-					found = true;
-					break;
-				}
-			}
-			assertTrue(found);
-		}
-	}
 }
diff --git a/bundles/org.eclipse.equinox.common.tests/src/org/eclipse/equinox/common/tests/registry/StaleObjects.java b/bundles/org.eclipse.equinox.common.tests/src/org/eclipse/equinox/common/tests/registry/StaleObjects.java
index 99510e8..80ffd58 100644
--- a/bundles/org.eclipse.equinox.common.tests/src/org/eclipse/equinox/common/tests/registry/StaleObjects.java
+++ b/bundles/org.eclipse.equinox.common.tests/src/org/eclipse/equinox/common/tests/registry/StaleObjects.java
@@ -14,16 +14,26 @@
  *******************************************************************************/
 package org.eclipse.equinox.common.tests.registry;
 
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertThrows;
+
 import java.io.IOException;
-import junit.framework.TestCase;
-import org.eclipse.core.runtime.*;
+
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IConfigurationElement;
+import org.eclipse.core.runtime.IExtension;
+import org.eclipse.core.runtime.IRegistryChangeEvent;
+import org.eclipse.core.runtime.IRegistryChangeListener;
+import org.eclipse.core.runtime.InvalidRegistryObjectException;
+import org.eclipse.core.runtime.RegistryFactory;
 import org.eclipse.core.tests.harness.BundleTestingHelper;
+import org.junit.Test;
 import org.osgi.framework.Bundle;
 import org.osgi.framework.BundleContext;
 import org.osgi.framework.BundleException;
 import org.osgi.framework.FrameworkUtil;
 
-public class StaleObjects extends TestCase {
+public class StaleObjects {
 	private class HandleCatcher implements IRegistryChangeListener {
 		private IExtension extensionFromTheListener;
 
@@ -33,14 +43,8 @@
 
 		@Override
 		public void registryChanged(IRegistryChangeEvent event) {
-			boolean gotException = false;
-			try {
-				extensionFromTheListener = event.getExtensionDeltas()[0].getExtension();
-				extensionFromTheListener.getSimpleIdentifier();
-			} catch (InvalidRegistryObjectException e) {
-				gotException = true;
-			}
-			assertEquals(false, gotException);
+			extensionFromTheListener = event.getExtensionDeltas()[0].getExtension();
+			assertThrows(InvalidRegistryObjectException.class, () -> extensionFromTheListener.getSimpleIdentifier());
 		}
 
 		public IExtension getAcquiredHandle() {
@@ -48,89 +52,71 @@
 		}
 	}
 
+	@Test
 	public synchronized void testA() throws IOException, BundleException {
 		HandleCatcher listener = new HandleCatcher();
 		BundleContext bundleContext = FrameworkUtil.getBundle(getClass()).getBundleContext();
 		Bundle bundle01 = BundleTestingHelper.installBundle("", bundleContext, "Plugin_Testing/registry/testStale1");
-		BundleTestingHelper.refreshPackages(bundleContext, new Bundle[] {bundle01});
+		BundleTestingHelper.refreshPackages(bundleContext, new Bundle[] { bundle01 });
 
 		IExtension willBeStale = RegistryFactory.getRegistry().getExtension("testStale.ext1");
 
-		//Test that handles obtained from deltas are working.
+		// Test that handles obtained from deltas are working.
 
-		//Test that handles obtained from an addition deltas are working even after the delta is done being broadcasted.
-		boolean gotException = false;
-		try {
-			IExtension result = null;
-			while ((result = listener.getAcquiredHandle()) == null) {
-				try {
-					wait(200);
-				} catch (InterruptedException e) {
-					//ignore.
-				}
+		// Test that handles obtained from an addition deltas are working even after the
+		// delta is done being broadcasted.
+		IExtension result = null;
+		while ((result = listener.getAcquiredHandle()) == null) {
+			try {
+				wait(200);
+			} catch (InterruptedException e) {
+				// ignore.
 			}
-			result.getSimpleIdentifier();
-		} catch (InvalidRegistryObjectException e) {
-			gotException = true;
 		}
-		assertEquals(false, gotException);
+		result.getSimpleIdentifier();
 
-		//Add a listener capturing a handle removal. Inside the handle catcher the handle is valid
+		// Add a listener capturing a handle removal. Inside the handle catcher the
+		// handle is valid
 		HandleCatcher listener2 = new HandleCatcher();
 		try {
-			wait(500); //Wait for the listeners to be done
+			wait(500); // Wait for the listeners to be done
 		} catch (InterruptedException e) {
-			//ignore.
+			// ignore.
 		}
 
 		bundle01.uninstall();
-		BundleTestingHelper.refreshPackages(bundleContext, new Bundle[] {bundle01});
+		BundleTestingHelper.refreshPackages(bundleContext, new Bundle[] { bundle01 });
 
-		//Outside of the event notification the handle from a removed object should be invalid
-		gotException = false;
-		try {
-			while (listener2.getAcquiredHandle() == null) {
-				try {
-					wait(200);
-				} catch (InterruptedException e) {
-					//ignore.
-				}
+		// Outside of the event notification the handle from a removed object should be
+		// invalid
+		while (listener2.getAcquiredHandle() == null) {
+			try {
+				wait(200);
+			} catch (InterruptedException e) {
+				// ignore.
 			}
-			listener2.getAcquiredHandle().getSimpleIdentifier();
-		} catch (InvalidRegistryObjectException e) {
-			gotException = true;
 		}
-		assertEquals(true, gotException);
+		assertThrows(InvalidRegistryObjectException.class, () -> listener2.getAcquiredHandle().getSimpleIdentifier());
 
-		//Check that the initial handles are stale as well
-		gotException = false;
-		try {
-			willBeStale.getSimpleIdentifier();
-		} catch (InvalidRegistryObjectException e) {
-			gotException = true;
-		}
-		assertEquals(true, gotException);
+		// Check that the initial handles are stale as well
+		assertThrows(InvalidRegistryObjectException.class, () -> willBeStale.getSimpleIdentifier());
 		RegistryFactory.getRegistry().removeRegistryChangeListener(listener2);
 		RegistryFactory.getRegistry().removeRegistryChangeListener(listener);
 	}
 
+	@Test
 	public void testStaleConfigurationElement() throws IOException, BundleException {
 		BundleContext bundleContext = FrameworkUtil.getBundle(getClass()).getBundleContext();
 		Bundle bundle01 = BundleTestingHelper.installBundle("", bundleContext, "Plugin_Testing/registry/testStale2");
-		BundleTestingHelper.refreshPackages(bundleContext, new Bundle[] {bundle01});
+		BundleTestingHelper.refreshPackages(bundleContext, new Bundle[] { bundle01 });
 
-		IConfigurationElement ce = RegistryFactory.getRegistry().getExtension("testStale2.ext1").getConfigurationElements()[0];
+		IConfigurationElement ce = RegistryFactory.getRegistry().getExtension("testStale2.ext1")
+				.getConfigurationElements()[0];
 		assertNotNull(ce);
 
 		bundle01.uninstall();
-		BundleTestingHelper.refreshPackages(bundleContext, new Bundle[] {bundle01});
+		BundleTestingHelper.refreshPackages(bundleContext, new Bundle[] { bundle01 });
 
-		boolean gotException = false;
-		try {
-			ce.createExecutableExtension("name");
-		} catch (CoreException c) {
-			gotException = true;
-		}
-		assertEquals(true, gotException);
+		assertThrows(CoreException.class, () -> ce.createExecutableExtension("name"));
 	}
 }
diff --git a/bundles/org.eclipse.equinox.common.tests/src/org/eclipse/equinox/common/tests/registry/simple/BaseExtensionRegistryRun.java b/bundles/org.eclipse.equinox.common.tests/src/org/eclipse/equinox/common/tests/registry/simple/BaseExtensionRegistryRun.java
index da7c864..47c6331 100644
--- a/bundles/org.eclipse.equinox.common.tests/src/org/eclipse/equinox/common/tests/registry/simple/BaseExtensionRegistryRun.java
+++ b/bundles/org.eclipse.equinox.common.tests/src/org/eclipse/equinox/common/tests/registry/simple/BaseExtensionRegistryRun.java
@@ -13,16 +13,24 @@
  *******************************************************************************/
 package org.eclipse.equinox.common.tests.registry.simple;
 
-import java.io.*;
+import static org.junit.Assert.assertNotNull;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
 import java.net.URL;
-import junit.framework.TestCase;
 
 import org.eclipse.core.internal.runtime.MetaDataKeeper;
-import org.eclipse.core.runtime.*;
+import org.eclipse.core.runtime.IContributor;
+import org.eclipse.core.runtime.IExtensionRegistry;
+import org.eclipse.core.runtime.IPath;
+import org.eclipse.core.runtime.RegistryFactory;
 import org.eclipse.core.runtime.spi.RegistryStrategy;
+import org.junit.After;
+import org.junit.Before;
 import org.osgi.framework.FrameworkUtil;
 
-public class BaseExtensionRegistryRun extends TestCase {
+public class BaseExtensionRegistryRun {
 
 	// The imaging device registry
 	protected IExtensionRegistry simpleRegistry;
@@ -32,14 +40,6 @@
 	// Path to the XML files
 	private final static String xmlPath = "Plugin_Testing/registry/testSimple/"; //$NON-NLS-1$
 
-	public BaseExtensionRegistryRun() {
-		super();
-	}
-
-	public BaseExtensionRegistryRun(String name) {
-		super(name);
-	}
-
 	protected URL getXML(String fileName) {
 		return FrameworkUtil.getBundle(getClass()).getEntry(xmlPath + fileName);
 	}
@@ -47,8 +47,8 @@
 	/**
 	 * Create the "imaging device" registry
 	 */
-	@Override
-	protected void setUp() throws Exception {
+	@Before
+	public void setUp() throws Exception {
 		// create the imaging device registry
 		simpleRegistry = startRegistry();
 	}
@@ -56,8 +56,8 @@
 	/**
 	 * Properly dispose of the extension registry
 	 */
-	@Override
-	protected void tearDown() throws Exception {
+	@After
+	public void tearDown() throws Exception {
 		stopRegistry();
 	}
 
@@ -90,24 +90,20 @@
 		simpleRegistry.stop(masterToken);
 	}
 
-	protected void processXMLContribution(IContributor nonBundleContributor, URL url) {
+	protected void processXMLContribution(IContributor nonBundleContributor, URL url) throws IOException {
 		processXMLContribution(nonBundleContributor, url, false);
 	}
 
-	protected void processXMLContribution(IContributor nonBundleContributor, URL url, boolean persist) {
-		try {
+	protected void processXMLContribution(IContributor nonBundleContributor, URL url, boolean persist)
+			throws IOException {
 			InputStream is = url.openStream();
 			simpleRegistry.addContribution(is, nonBundleContributor, persist, url.getFile(), null, persist ? masterToken : userToken);
-		} catch (IOException eFile) {
-			fail(eFile.getMessage());
-			return;
-		}
 	}
 
 	protected String qualifiedName(String namespace, String simpleName) {
 		return namespace + "." + simpleName; //$NON-NLS-1$
 	}
-	
+
 	protected IPath getStateLocation() {
 		IPath stateLocation = MetaDataKeeper.getMetaArea().getStateLocation(FrameworkUtil.getBundle(getClass()));
 		stateLocation.toFile().mkdirs();
diff --git a/bundles/org.eclipse.equinox.common.tests/src/org/eclipse/equinox/common/tests/registry/simple/DirectExtensionCreateTest.java b/bundles/org.eclipse.equinox.common.tests/src/org/eclipse/equinox/common/tests/registry/simple/DirectExtensionCreateTest.java
index 2c317b8..0523ddf 100644
--- a/bundles/org.eclipse.equinox.common.tests/src/org/eclipse/equinox/common/tests/registry/simple/DirectExtensionCreateTest.java
+++ b/bundles/org.eclipse.equinox.common.tests/src/org/eclipse/equinox/common/tests/registry/simple/DirectExtensionCreateTest.java
@@ -13,10 +13,19 @@
  *******************************************************************************/
 package org.eclipse.equinox.common.tests.registry.simple;
 
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
 import org.eclipse.core.internal.registry.ExtensionRegistry;
 import org.eclipse.core.internal.registry.spi.ConfigurationElementAttribute;
 import org.eclipse.core.internal.registry.spi.ConfigurationElementDescription;
-import org.eclipse.core.runtime.*;
+import org.eclipse.core.runtime.ContributorFactorySimple;
+import org.eclipse.core.runtime.IConfigurationElement;
+import org.eclipse.core.runtime.IContributor;
+import org.eclipse.core.runtime.IExtension;
+import org.eclipse.core.runtime.IExtensionPoint;
+import org.junit.Test;
 
 /**
  * Tests programmatic creation of extension and extension point by using direct
@@ -29,14 +38,7 @@
  */
 public class DirectExtensionCreateTest extends BaseExtensionRegistryRun {
 
-	public DirectExtensionCreateTest() {
-		super();
-	}
-
-	public DirectExtensionCreateTest(String name) {
-		super(name);
-	}
-
+	@Test
 	public void testExtensionPointAddition() {
 		IContributor contributor = ContributorFactorySimple.createContributor("1"); //$NON-NLS-1$
 		String extensionPointId = "DirectExtPoint"; //$NON-NLS-1$
@@ -108,10 +110,10 @@
 
 		IExtension[] namespaceExtensions = simpleRegistry.getExtensions(namespace);
 		assertNotNull(namespaceExtensions);
-		assertTrue(namespaceExtensions.length == 1);
+		assertEquals(1, namespaceExtensions.length);
 		IExtension[] extensions = extensionPoint.getExtensions();
 		assertNotNull(extensions);
-		assertTrue(extensions.length == 1);
+		assertEquals(1, extensions.length);
 		for (IExtension extension : extensions) {
 			String storedExtensionId = extension.getUniqueIdentifier();
 			assertTrue(storedExtensionId.equals(qualifiedName(namespace, extensionId)));
@@ -127,9 +129,9 @@
 				String configElementValue = configElement.getValue();
 				assertTrue(configElementValue.equals(extensionValue));
 				String[] attributeNames = configElement.getAttributeNames();
-				assertTrue(attributeNames.length == 2);
+				assertEquals(2, attributeNames.length);
 				IConfigurationElement[] configElementChildren = configElement.getChildren();
-				assertTrue(configElementChildren.length == 2);
+				assertEquals(2, configElementChildren.length);
 			}
 		}
 	}
diff --git a/bundles/org.eclipse.equinox.common.tests/src/org/eclipse/equinox/common/tests/registry/simple/DirectExtensionCreateTwoRegistriesTest.java b/bundles/org.eclipse.equinox.common.tests/src/org/eclipse/equinox/common/tests/registry/simple/DirectExtensionCreateTwoRegistriesTest.java
index 0287fa5..342cad8 100644
--- a/bundles/org.eclipse.equinox.common.tests/src/org/eclipse/equinox/common/tests/registry/simple/DirectExtensionCreateTwoRegistriesTest.java
+++ b/bundles/org.eclipse.equinox.common.tests/src/org/eclipse/equinox/common/tests/registry/simple/DirectExtensionCreateTwoRegistriesTest.java
@@ -13,8 +13,18 @@
  *******************************************************************************/
 package org.eclipse.equinox.common.tests.registry.simple;
 
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
 import org.eclipse.core.internal.registry.ExtensionRegistry;
-import org.eclipse.core.runtime.*;
+import org.eclipse.core.runtime.ContributorFactorySimple;
+import org.eclipse.core.runtime.IContributor;
+import org.eclipse.core.runtime.IExtensionPoint;
+import org.eclipse.core.runtime.IExtensionRegistry;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
 
 /**
  * Test simultaneous work of two extension registries.
@@ -29,21 +39,16 @@
 	private IExtensionRegistry theDeviceRegistryA;
 	private IExtensionRegistry theDeviceRegistryB;
 
-	public DirectExtensionCreateTwoRegistriesTest() {
-		super();
-	}
-
-	public DirectExtensionCreateTwoRegistriesTest(String name) {
-		super(name);
-	}
 
 	@Override
-	protected void setUp() throws Exception {
+	@Before
+	public void setUp() throws Exception {
 		startRegistries();
 	}
 
 	@Override
-	protected void tearDown() throws Exception {
+	@After
+	public void tearDown() throws Exception {
 		stopRegistries();
 	}
 
@@ -60,6 +65,7 @@
 		theDeviceRegistryB.stop(masterToken);
 	}
 
+	@Test
 	public void testExtensionPointAddition() {
 		// Test with non-bundle contributor
 		IContributor nonBundleContributor = ContributorFactorySimple.createContributor("ABC"); //$NON-NLS-1$
diff --git a/bundles/org.eclipse.equinox.common.tests/src/org/eclipse/equinox/common/tests/registry/simple/DirectExtensionRemoveTest.java b/bundles/org.eclipse.equinox.common.tests/src/org/eclipse/equinox/common/tests/registry/simple/DirectExtensionRemoveTest.java
index b05d837..4321dcf 100644
--- a/bundles/org.eclipse.equinox.common.tests/src/org/eclipse/equinox/common/tests/registry/simple/DirectExtensionRemoveTest.java
+++ b/bundles/org.eclipse.equinox.common.tests/src/org/eclipse/equinox/common/tests/registry/simple/DirectExtensionRemoveTest.java
@@ -13,8 +13,25 @@
  *******************************************************************************/
 package org.eclipse.equinox.common.tests.registry.simple;
 
-import org.eclipse.core.runtime.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertThrows;
+import static org.junit.Assert.assertTrue;
+
+import java.io.IOException;
+
+import org.eclipse.core.runtime.ContributorFactorySimple;
+import org.eclipse.core.runtime.IConfigurationElement;
+import org.eclipse.core.runtime.IContributor;
+import org.eclipse.core.runtime.IExtension;
+import org.eclipse.core.runtime.IExtensionDelta;
+import org.eclipse.core.runtime.IExtensionPoint;
+import org.eclipse.core.runtime.IRegistryChangeEvent;
+import org.eclipse.core.runtime.IRegistryChangeListener;
+import org.eclipse.core.runtime.InvalidRegistryObjectException;
 import org.eclipse.equinox.common.tests.registry.simple.utils.SimpleRegistryListener;
+import org.junit.Test;
 
 /**
  * Tests removal APIs using a simple registry.
@@ -28,16 +45,10 @@
 	private final static String extensionA1 = "TestExtensionA1"; //$NON-NLS-1$
 	private final static String extensionA2 = "TestExtensionA2"; //$NON-NLS-1$
 
-	public DirectExtensionRemoveTest() {
-		super();
-	}
-
-	public DirectExtensionRemoveTest(String name) {
-		super(name);
-	}
 
 	// Fill the registry; remove half; check listener; check what's left
-	public void testExtensionPointAddition() {
+	@Test
+	public void testExtensionPointAddition() throws IOException {
 		IContributor nonBundleContributor = ContributorFactorySimple.createContributor("DirectRemoveProvider"); //$NON-NLS-1$
 		String namespace = nonBundleContributor.getName();
 		fillRegistry(nonBundleContributor);
@@ -53,10 +64,13 @@
 	}
 
 	/**
-	 * Tests that configuration elements associated with the removed extension
-	 * are removed.
+	 * Tests that configuration elements associated with the removed extension are
+	 * removed.
+	 *
+	 * @throws IOException
 	 */
-	public void testAssociatedConfigElements() {
+	@Test
+	public void testAssociatedConfigElements() throws IOException {
 		IContributor nonBundleContributor = ContributorFactorySimple.createContributor("CETest"); //$NON-NLS-1$
 		String namespace = nonBundleContributor.getName();
 		processXMLContribution(nonBundleContributor, getXML("CERemovalTest.xml")); //$NON-NLS-1$
@@ -64,7 +78,7 @@
 		IExtensionPoint extensionPointA = simpleRegistry.getExtensionPoint(qualifiedName(namespace, "PointA")); //$NON-NLS-1$
 		assertNotNull(extensionPointA);
 		IExtension[] extensionsA = extensionPointA.getExtensions();
-		assertTrue(extensionsA.length == 2);
+		assertEquals(2, extensionsA.length);
 
 		// check first extension
 		IExtension ext1 = extensionPointA.getExtension(qualifiedName(namespace, "TestExtensionA1")); //$NON-NLS-1$
@@ -98,9 +112,9 @@
 		// listener to verify that valid CEs are included in the notification
 		IRegistryChangeListener listener = event -> {
 			IExtensionDelta[] deltas = event.getExtensionDeltas();
-			assertTrue(deltas.length == 1);
+			assertEquals(1, deltas.length);
 			for (IExtensionDelta delta : deltas) {
-				assertTrue(delta.getKind() == IExtensionDelta.REMOVED);
+				assertEquals(IExtensionDelta.REMOVED, delta.getKind());
 				IExtension extension = delta.getExtension();
 				assertNotNull(extension);
 
@@ -131,25 +145,12 @@
 
 		// basic checks
 		IExtension[] extensionsRemoved = extensionPointA.getExtensions();
-		assertTrue(extensionsRemoved.length == 1);
+		assertEquals(1, extensionsRemoved.length);
 
 		// re-check configuration elements
-		boolean exceptionFound = false;
-		try {
-			ces11[0].getAttributeNames(); // should produce an exception
-		} catch (InvalidRegistryObjectException e) {
-			exceptionFound = true;
-		}
-		assertTrue(exceptionFound);
+		assertThrows(InvalidRegistryObjectException.class, () -> ces11[0].getAttributeNames()); // should produce an
 
-		exceptionFound = false;
-		try {
-			ces12[0].getAttributeNames(); // should produce an exception
-		} catch (InvalidRegistryObjectException e) {
-			exceptionFound = true;
-		}
-
-		assertTrue(exceptionFound);
+		assertThrows(InvalidRegistryObjectException.class, () -> ces12[0].getAttributeNames()); // should produce an
 		// the non-removed extension CEs should still be valid
 		String[] attrs22removed = ces22[0].getAttributeNames();
 		assertNotNull(attrs22removed);
@@ -157,7 +158,7 @@
 		assertEquals("value", attrs22removed[0]); //$NON-NLS-1$
 	}
 
-	private void fillRegistry(IContributor contributor) {
+	private void fillRegistry(IContributor contributor) throws IOException {
 		processXMLContribution(contributor, getXML("RemovalTest.xml")); //$NON-NLS-1$
 	}
 
@@ -167,9 +168,9 @@
 		IExtensionPoint extensionPointB = simpleRegistry.getExtensionPoint(qualifiedName(namespace, pointB));
 		assertNotNull(extensionPointB);
 		IExtension[] extensionsA = extensionPointA.getExtensions();
-		assertTrue(extensionsA.length == 2);
+		assertEquals(2, extensionsA.length);
 		IExtension[] extensionsB = extensionPointB.getExtensions();
-		assertTrue(extensionsB.length == 2);
+		assertEquals(2, extensionsB.length);
 	}
 
 	private void remove(String namespace) {
@@ -186,7 +187,7 @@
 		IExtensionPoint extensionPointB = simpleRegistry.getExtensionPoint(qualifiedName(namespace, pointB));
 		assertNull(extensionPointB);
 		IExtension[] extensionsA = extensionPointA.getExtensions();
-		assertTrue(extensionsA.length == 1);
+		assertEquals(1, extensionsA.length);
 		String Id = extensionsA[0].getUniqueIdentifier();
 		assertTrue(qualifiedName(namespace, extensionA2).equals(Id));
 	}
@@ -194,9 +195,9 @@
 	private void checkListener(SimpleRegistryListener listener) {
 		IRegistryChangeEvent event = listener.getEvent(5000);
 		IExtensionDelta[] deltas = event.getExtensionDeltas();
-		assertTrue(deltas.length == 2);
+		assertEquals(2, deltas.length);
 		for (IExtensionDelta delta : deltas) {
-			assertTrue(delta.getKind() == IExtensionDelta.REMOVED);
+			assertEquals(IExtensionDelta.REMOVED, delta.getKind());
 			assertNotNull(delta.getExtension());
 			assertNotNull(delta.getExtensionPoint());
 		}
diff --git a/bundles/org.eclipse.equinox.common.tests/src/org/eclipse/equinox/common/tests/registry/simple/DuplicatePointsTest.java b/bundles/org.eclipse.equinox.common.tests/src/org/eclipse/equinox/common/tests/registry/simple/DuplicatePointsTest.java
index 7e42064..43bb3b2 100644
--- a/bundles/org.eclipse.equinox.common.tests/src/org/eclipse/equinox/common/tests/registry/simple/DuplicatePointsTest.java
+++ b/bundles/org.eclipse.equinox.common.tests/src/org/eclipse/equinox/common/tests/registry/simple/DuplicatePointsTest.java
@@ -13,10 +13,23 @@
  *******************************************************************************/
 package org.eclipse.equinox.common.tests.registry.simple;
 
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
 import java.io.File;
-import org.eclipse.core.runtime.*;
+import java.io.IOException;
+
+import org.eclipse.core.runtime.ContributorFactorySimple;
+import org.eclipse.core.runtime.IContributor;
+import org.eclipse.core.runtime.IExtension;
+import org.eclipse.core.runtime.IExtensionPoint;
+import org.eclipse.core.runtime.IExtensionRegistry;
+import org.eclipse.core.runtime.IPath;
+import org.eclipse.core.runtime.RegistryFactory;
 import org.eclipse.core.runtime.spi.RegistryStrategy;
 import org.eclipse.equinox.common.tests.registry.simple.utils.HiddenLogRegistryStrategy;
+import org.junit.Test;
 
 /**
  * Tests addition of extensions and extension points with duplicate IDs.
@@ -31,14 +44,6 @@
 	private final static String errMsg1 = "Error:  Ignored duplicate extension point \"testDuplicates.duplicateExtensionPoint\" supplied by \"2\"." + "Warning:  Extensions supplied by \"2\" and \"1\" have the same Id: \"testDuplicates.duplicateExtension\".";
 	private final static String errMsg2 = "Error:  Ignored duplicate extension point \"testSame.duplicateExtensionPointSame\" supplied by \"3\"." + "Warning:  Extensions supplied by \"3\" and \"3\" have the same Id: \"testSame.duplicateExtensionSame\".";
 
-	public DuplicatePointsTest() {
-		super();
-	}
-
-	public DuplicatePointsTest(String name) {
-		super(name);
-	}
-
 	/**
 	 * Use registry strategy with modified logging
 	 * @return - open extension registry
@@ -53,7 +58,8 @@
 		return RegistryFactory.createRegistry(registryStrategy, masterToken, userToken);
 	}
 
-	public void testDuplicates() {
+	@Test
+	public void testDuplicates() throws IOException {
 		HiddenLogRegistryStrategy.output = ""; //$NON-NLS-1$
 		IContributor contributor1 = ContributorFactorySimple.createContributor("1"); //$NON-NLS-1$
 		processXMLContribution(contributor1, getXML("DuplicatePoints1.xml")); //$NON-NLS-1$
@@ -74,10 +80,10 @@
 		assertTrue(errMsg1.equals(HiddenLogRegistryStrategy.output));
 
 		IExtensionPoint[] extensionPoints = simpleRegistry.getExtensionPoints(namespace);
-		assertTrue(extensionPoints.length == 2);
+		assertEquals(2, extensionPoints.length);
 
 		IExtension[] extensions = simpleRegistry.getExtensions(namespace);
-		assertTrue(extensions.length == 3);
+		assertEquals(3, extensions.length);
 
 		IExtension extension = simpleRegistry.getExtension(qualifiedName(namespace, "nonDuplicateExtension")); //$NON-NLS-1$
 		assertNotNull(extension);
@@ -87,9 +93,9 @@
 		assertTrue(errMsg2.equals(HiddenLogRegistryStrategy.output));
 
 		IExtensionPoint[] extensionPoints = simpleRegistry.getExtensionPoints(namespace);
-		assertTrue(extensionPoints.length == 1);
+		assertEquals(1, extensionPoints.length);
 
 		IExtension[] extensions = simpleRegistry.getExtensions(namespace);
-		assertTrue(extensions.length == 2);
+		assertEquals(2, extensions.length);
 	}
 }
diff --git a/bundles/org.eclipse.equinox.common.tests/src/org/eclipse/equinox/common/tests/registry/simple/MergeContributionTest.java b/bundles/org.eclipse.equinox.common.tests/src/org/eclipse/equinox/common/tests/registry/simple/MergeContributionTest.java
index eb86624..b3642ba 100644
--- a/bundles/org.eclipse.equinox.common.tests/src/org/eclipse/equinox/common/tests/registry/simple/MergeContributionTest.java
+++ b/bundles/org.eclipse.equinox.common.tests/src/org/eclipse/equinox/common/tests/registry/simple/MergeContributionTest.java
@@ -13,7 +13,16 @@
  *******************************************************************************/
 package org.eclipse.equinox.common.tests.registry.simple;
 
-import org.eclipse.core.runtime.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+import java.io.IOException;
+
+import org.eclipse.core.runtime.ContributorFactorySimple;
+import org.eclipse.core.runtime.IContributor;
+import org.eclipse.core.runtime.IExtension;
+import org.eclipse.core.runtime.IExtensionPoint;
+import org.junit.Test;
 
 /**
  * Tests merging static and dynamic contributions.
@@ -21,16 +30,8 @@
  * @since 3.2
  */
 public class MergeContributionTest extends BaseExtensionRegistryRun {
-
-	public MergeContributionTest() {
-		super();
-	}
-
-	public MergeContributionTest(String name) {
-		super(name);
-	}
-
-	public void testMergeStaticDynamic() {
+	@Test
+	public void testMergeStaticDynamic() throws IOException {
 		// Test with non-bundle contributor
 		IContributor nonBundleContributor = ContributorFactorySimple.createContributor("ABC"); //$NON-NLS-1$
 		String namespace = nonBundleContributor.getName();
@@ -48,11 +49,11 @@
 		checkRegistry(namespace, 6);
 	}
 
-	private void fillRegistryStatic(IContributor contributor) {
+	private void fillRegistryStatic(IContributor contributor) throws IOException {
 		processXMLContribution(contributor, getXML("MergeStatic.xml"), true); //$NON-NLS-1$
 	}
 
-	private void fillRegistryDynamic(IContributor contributor) {
+	private void fillRegistryDynamic(IContributor contributor) throws IOException {
 		processXMLContribution(contributor, getXML("MergeDynamic.xml"), false); //$NON-NLS-1$
 	}
 
diff --git a/bundles/org.eclipse.equinox.common.tests/src/org/eclipse/equinox/common/tests/registry/simple/TokenAccessTest.java b/bundles/org.eclipse.equinox.common.tests/src/org/eclipse/equinox/common/tests/registry/simple/TokenAccessTest.java
index 14bbd70..297bbbb 100644
--- a/bundles/org.eclipse.equinox.common.tests/src/org/eclipse/equinox/common/tests/registry/simple/TokenAccessTest.java
+++ b/bundles/org.eclipse.equinox.common.tests/src/org/eclipse/equinox/common/tests/registry/simple/TokenAccessTest.java
@@ -13,27 +13,24 @@
  *******************************************************************************/
 package org.eclipse.equinox.common.tests.registry.simple;
 
-import junit.framework.TestCase;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertThrows;
+
 import org.eclipse.core.runtime.IExtensionRegistry;
 import org.eclipse.core.runtime.RegistryFactory;
+import org.junit.Test;
 
 /**
  * Tests registry token-based access rules.
+ *
  * @since 3.2
  */
-public class TokenAccessTest extends TestCase {
-
-	public TokenAccessTest() {
-		super();
-	}
-
-	public TokenAccessTest(String name) {
-		super(name);
-	}
+public class TokenAccessTest {
 
 	/**
 	 * Tests token access to sensetive registry methods
 	 */
+	@Test
 	public void testControlledAccess() {
 		Object tokenGood = new Object();
 		Object tokenBad = new Object();
@@ -56,17 +53,12 @@
 		// and stopped with a good token - should be no exception
 		registry.stop(tokenGood);
 
-		// registry created with a good token
-		registry = RegistryFactory.createRegistry(null, tokenGood, null);
-		assertNotNull(registry);
+
 		// and stopped with a bad token - should be an exception
-		boolean bException = false;
-		try {
-			registry.stop(tokenBad);
-		} catch (IllegalArgumentException e) {
-			// this is good; this is expected
-			bException = true;
-		}
-		assertTrue(bException);
+		assertThrows(IllegalArgumentException.class, () -> {// registry created with a good token
+			IExtensionRegistry registry1 = RegistryFactory.createRegistry(null, tokenGood, null);
+			assertNotNull(registry1);
+			registry1.stop(tokenBad);
+		});
 	}
 }
diff --git a/bundles/org.eclipse.equinox.common.tests/src/org/eclipse/equinox/common/tests/registry/simple/XMLExecutableExtensionTest.java b/bundles/org.eclipse.equinox.common.tests/src/org/eclipse/equinox/common/tests/registry/simple/XMLExecutableExtensionTest.java
index 990f58c..c31889a 100644
--- a/bundles/org.eclipse.equinox.common.tests/src/org/eclipse/equinox/common/tests/registry/simple/XMLExecutableExtensionTest.java
+++ b/bundles/org.eclipse.equinox.common.tests/src/org/eclipse/equinox/common/tests/registry/simple/XMLExecutableExtensionTest.java
@@ -13,42 +13,51 @@
  *******************************************************************************/
 package org.eclipse.equinox.common.tests.registry.simple;
 
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
 import java.io.File;
-import org.eclipse.core.runtime.*;
+import java.io.IOException;
+
+import org.eclipse.core.runtime.ContributorFactorySimple;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IConfigurationElement;
+import org.eclipse.core.runtime.IContributor;
+import org.eclipse.core.runtime.IExtensionRegistry;
+import org.eclipse.core.runtime.IPath;
+import org.eclipse.core.runtime.RegistryFactory;
 import org.eclipse.core.runtime.spi.RegistryStrategy;
 import org.eclipse.equinox.common.tests.registry.simple.utils.ExeExtensionStrategy;
 import org.eclipse.equinox.common.tests.registry.simple.utils.ExecutableRegistryObject;
+import org.junit.Test;
 
 /**
- * Tests that executable extensions present in the simple registry actually
- * gets processed.
+ * Tests that executable extensions present in the simple registry actually gets
+ * processed.
+ *
  * @since 3.2
  */
 public class XMLExecutableExtensionTest extends BaseExtensionRegistryRun {
 
-	public XMLExecutableExtensionTest() {
-		super();
-	}
-
-	public XMLExecutableExtensionTest(String name) {
-		super(name);
-	}
-
 	/**
 	 * Provide own class loader to the registry executable element strategry
+	 *
 	 * @return - open extension registry
 	 */
 	@Override
 	protected IExtensionRegistry startRegistry() {
 		// use plugin's metadata directory to save cache data
 		IPath userDataPath = getStateLocation();
-		File[] registryLocations = new File[] {new File(userDataPath.toOSString())};
-		boolean[] readOnly = new boolean[] {false};
+		File[] registryLocations = new File[] { new File(userDataPath.toOSString()) };
+		boolean[] readOnly = new boolean[] { false };
 		RegistryStrategy registryStrategy = new ExeExtensionStrategy(registryLocations, readOnly);
 		return RegistryFactory.createRegistry(registryStrategy, masterToken, userToken);
 	}
 
-	public void testExecutableExtensionCreation() {
+	@Test
+	public void testExecutableExtensionCreation() throws IOException, CoreException {
 		// Test with non-bundle contributor
 		IContributor nonBundleContributor = ContributorFactorySimple.createContributor("ABC"); //$NON-NLS-1$
 		assertFalse(ExecutableRegistryObject.createCalled);
@@ -60,21 +69,17 @@
 		assertTrue(ExecutableRegistryObject.createCalled);
 	}
 
-	private void fillRegistry(IContributor contributor) {
+	private void fillRegistry(IContributor contributor) throws IOException {
 		processXMLContribution(contributor, getXML("ExecutableExtension.xml")); //$NON-NLS-1$
 	}
 
-	private void checkRegistry(String namespace) {
-		IConfigurationElement[] elements = simpleRegistry.getConfigurationElementsFor(qualifiedName(namespace, "XMLExecutableExtPoint")); //$NON-NLS-1$
-		assertTrue(elements.length == 1);
+	private void checkRegistry(String namespace) throws CoreException {
+		IConfigurationElement[] elements = simpleRegistry
+				.getConfigurationElementsFor(qualifiedName(namespace, "XMLExecutableExtPoint")); //$NON-NLS-1$
+		assertEquals(1, elements.length);
 		for (IConfigurationElement element : elements) {
-			try {
-				Object object = element.createExecutableExtension("class"); //$NON-NLS-1$
-				assertNotNull(object);
-			} catch (CoreException e) {
-				assertTrue(false);
-				e.printStackTrace();
-			}
+			Object object = element.createExecutableExtension("class"); //$NON-NLS-1$
+			assertNotNull(object);
 		}
 	}
 }
diff --git a/bundles/org.eclipse.equinox.common.tests/src/org/eclipse/equinox/common/tests/registry/simple/XMLExtensionCreateEclipseTest.java b/bundles/org.eclipse.equinox.common.tests/src/org/eclipse/equinox/common/tests/registry/simple/XMLExtensionCreateEclipseTest.java
index 38f2845..659e04d 100644
--- a/bundles/org.eclipse.equinox.common.tests/src/org/eclipse/equinox/common/tests/registry/simple/XMLExtensionCreateEclipseTest.java
+++ b/bundles/org.eclipse.equinox.common.tests/src/org/eclipse/equinox/common/tests/registry/simple/XMLExtensionCreateEclipseTest.java
@@ -13,10 +13,21 @@
  *******************************************************************************/
 package org.eclipse.equinox.common.tests.registry.simple;
 
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
 import java.io.IOException;
 import java.net.URL;
+
 import org.eclipse.core.internal.registry.ExtensionRegistry;
-import org.eclipse.core.runtime.*;
+import org.eclipse.core.runtime.ContributorFactoryOSGi;
+import org.eclipse.core.runtime.IConfigurationElement;
+import org.eclipse.core.runtime.IContributor;
+import org.eclipse.core.runtime.IExtensionPoint;
+import org.eclipse.core.runtime.IExtensionRegistry;
+import org.eclipse.core.runtime.RegistryFactory;
+import org.junit.Test;
 import org.osgi.framework.Bundle;
 import org.osgi.framework.FrameworkUtil;
 
@@ -25,8 +36,8 @@
  * @since 3.2
  */
 public class XMLExtensionCreateEclipseTest extends BaseExtensionRegistryRun {
-
-	public void testDynamicContribution() {
+	@Test
+	public void testDynamicContribution() throws IllegalArgumentException, IOException {
 		// specify this bundle as a contributor
 		Bundle thisBundle = FrameworkUtil.getBundle(getClass());
 		IContributor thisContributor = ContributorFactoryOSGi.createContributor(thisBundle);
@@ -34,15 +45,10 @@
 		checkRegistry(thisContributor.getName());
 	}
 
-	private void fillRegistry(IContributor contributor) {
-		try {
+	private void fillRegistry(IContributor contributor) throws IllegalArgumentException, IOException {
 			Object userKey = ((ExtensionRegistry) RegistryFactory.getRegistry()).getTemporaryUserToken();
 			URL xmlURL = getXML("DynamicExtension.xml"); //$NON-NLS-1$
 			RegistryFactory.getRegistry().addContribution(xmlURL.openStream(), contributor, false, xmlURL.getFile(), null, userKey);
-		} catch (IOException eFile) {
-			fail(eFile.getMessage());
-			return;
-		}
 	}
 
 	private void checkRegistry(String namespace) {
@@ -51,7 +57,7 @@
 		IExtensionPoint dynamicExtensionPoint = eclipseRegistry.getExtensionPoint(uniqueId);
 		assertNotNull(dynamicExtensionPoint);
 		IConfigurationElement[] elements = eclipseRegistry.getConfigurationElementsFor(uniqueId);
-		assertTrue(elements.length == 1);
+		assertEquals(1, elements.length);
 		for (IConfigurationElement element : elements) {
 			assertTrue("org.eclipse.equinox.common.tests.registry.simple.utils.ExecutableRegistryObject".equals(element.getAttribute("class")));
 		}
diff --git a/bundles/org.eclipse.equinox.common.tests/src/org/eclipse/equinox/common/tests/registry/simple/XMLExtensionCreateTest.java b/bundles/org.eclipse.equinox.common.tests/src/org/eclipse/equinox/common/tests/registry/simple/XMLExtensionCreateTest.java
index 94d1e76..81d14e1 100644
--- a/bundles/org.eclipse.equinox.common.tests/src/org/eclipse/equinox/common/tests/registry/simple/XMLExtensionCreateTest.java
+++ b/bundles/org.eclipse.equinox.common.tests/src/org/eclipse/equinox/common/tests/registry/simple/XMLExtensionCreateTest.java
@@ -13,8 +13,21 @@
  *******************************************************************************/
 package org.eclipse.equinox.common.tests.registry.simple;
 
-import org.eclipse.core.runtime.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+import java.io.IOException;
+
+import org.eclipse.core.runtime.ContributorFactorySimple;
+import org.eclipse.core.runtime.IConfigurationElement;
+import org.eclipse.core.runtime.IContributor;
+import org.eclipse.core.runtime.IExtension;
+import org.eclipse.core.runtime.IExtensionDelta;
+import org.eclipse.core.runtime.IExtensionPoint;
+import org.eclipse.core.runtime.IRegistryChangeEvent;
 import org.eclipse.equinox.common.tests.registry.simple.utils.SimpleRegistryListener;
+import org.junit.Test;
 
 /**
  * Tests addition of extension point and the extension to the registry via
@@ -25,15 +38,8 @@
  */
 public class XMLExtensionCreateTest extends BaseExtensionRegistryRun {
 
-	public XMLExtensionCreateTest() {
-		super();
-	}
-
-	public XMLExtensionCreateTest(String name) {
-		super(name);
-	}
-
-	public void testExtensionPointAddition() {
+	@Test
+	public void testExtensionPointAddition() throws IOException {
 		SimpleRegistryListener listener = new SimpleRegistryListener();
 		listener.register(simpleRegistry);
 
@@ -53,7 +59,7 @@
 		checkRegistry(nonBundleContributor.getName());
 	}
 
-	private void fillRegistry(IContributor contributor) {
+	private void fillRegistry(IContributor contributor) throws IOException {
 		// Add extension point
 		processXMLContribution(contributor, getXML("ExtensionPoint.xml")); //$NON-NLS-1$
 		// Add extension
@@ -65,10 +71,10 @@
 		assertNotNull(extensionPoint);
 		IExtension[] namespaceExtensions = simpleRegistry.getExtensions(namespace);
 		assertNotNull(namespaceExtensions);
-		assertTrue(namespaceExtensions.length == 1);
+		assertEquals(1, namespaceExtensions.length);
 		IExtension[] extensions = extensionPoint.getExtensions();
 		assertNotNull(extensions);
-		assertTrue(extensions.length == 1);
+		assertEquals(1, extensions.length);
 		for (IExtension extension : extensions) {
 			String extensionId = extension.getUniqueIdentifier();
 			assertTrue(extensionId.equals(qualifiedName(namespace, "XMLDirectExtensionID"))); //$NON-NLS-1$
@@ -82,9 +88,9 @@
 				String configElementName = configElement.getName();
 				assertTrue(configElementName.equals("StorageDevice")); //$NON-NLS-1$
 				String[] attributeNames = configElement.getAttributeNames();
-				assertTrue(attributeNames.length == 1);
+				assertEquals(1, attributeNames.length);
 				IConfigurationElement[] configElementChildren = configElement.getChildren();
-				assertTrue(configElementChildren.length == 2);
+				assertEquals(2, configElementChildren.length);
 			}
 		}
 	}
@@ -92,9 +98,9 @@
 	private void checkListener(String namespace, SimpleRegistryListener listener) {
 		IRegistryChangeEvent event = listener.getEvent(5000);
 		IExtensionDelta[] deltas = event.getExtensionDeltas();
-		assertTrue(deltas.length == 1); // only one notification
+		assertEquals(1, deltas.length); // only one notification
 		for (IExtensionDelta delta : deltas) {
-			assertTrue(delta.getKind() == IExtensionDelta.ADDED);
+			assertEquals(delta.getKind(), IExtensionDelta.ADDED);
 			IExtensionPoint theExtensionPoint = delta.getExtensionPoint();
 			IExtension theExtension = delta.getExtension();
 			String Id1 = theExtension.getExtensionPointUniqueIdentifier();