diff --git a/bundles/org.eclipse.core.filesystem/src/org/eclipse/core/internal/filesystem/InternalFileSystemCore.java b/bundles/org.eclipse.core.filesystem/src/org/eclipse/core/internal/filesystem/InternalFileSystemCore.java
index e23d393..1c1a4e5 100644
--- a/bundles/org.eclipse.core.filesystem/src/org/eclipse/core/internal/filesystem/InternalFileSystemCore.java
+++ b/bundles/org.eclipse.core.filesystem/src/org/eclipse/core/internal/filesystem/InternalFileSystemCore.java
@@ -28,7 +28,7 @@
 	private static final InternalFileSystemCore INSTANCE = new InternalFileSystemCore();
 
 	/**
-	 * A map (String -> (IConfigurationElement or IFileSystem)) mapping URI
+	 * A map (String -&gt; (IConfigurationElement or IFileSystem)) mapping URI
 	 * scheme to the file system for that scheme.  If the corresponding file
 	 * system has never been accessed, then the map contains the configuration
 	 * element for the extension.  Once the file system has been created, the
diff --git a/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/dtree/AbstractDataTree.java b/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/dtree/AbstractDataTree.java
index d46d602..c565d5b 100644
--- a/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/dtree/AbstractDataTree.java
+++ b/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/dtree/AbstractDataTree.java
@@ -20,7 +20,7 @@
 
 /**
  * Data trees can be viewed as generic multi-leaf trees.  The tree points to a single
- * rootNode, and each node can contain an arbitrary number of children.<p>
+ * rootNode, and each node can contain an arbitrary number of children.
  *
  * <p>Internally, data trees can be either complete trees (DataTree class), or delta
  * trees (<code>DeltaDataTree</code> class).  A DataTree is a stand-alone tree
diff --git a/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/dtree/DeltaDataTree.java b/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/dtree/DeltaDataTree.java
index a0387fa..68b20fd 100644
--- a/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/dtree/DeltaDataTree.java
+++ b/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/dtree/DeltaDataTree.java
@@ -82,8 +82,8 @@
 	 * Returns the tree as a backward delta.  If the delta is applied to the tree it
 	 * will produce its parent. The receiver must have a forward
 	 * delta representation. I.e.:  Call the receiver's parent A,
-	 * and the receiver B.  The receiver's representation is A->B.
-	 * Returns the delta A<-B.  The result is equivalent to A, but has B as its parent.
+	 * and the receiver B.  The receiver's representation is A-&gt;B.
+	 * Returns the delta A&lt;-B.  The result is equivalent to A, but has B as its parent.
 	 */
 	DeltaDataTree asBackwardDelta() {
 		if (getParent() == null)
diff --git a/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/events/BuildCommand.java b/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/events/BuildCommand.java
index d44b152..a20f463 100644
--- a/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/events/BuildCommand.java
+++ b/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/events/BuildCommand.java
@@ -151,7 +151,7 @@
 	}
 
 	/**
-	 * @return A copy of the internal map {@link IBuildConfiguration} -> {@link IncrementalProjectBuilder} if
+	 * @return A copy of the internal map {@link IBuildConfiguration} -&gt; {@link IncrementalProjectBuilder} if
 	 * this build command supports multiple configurations. Otherwise return the {@link IncrementalProjectBuilder}
 	 * associated with this build command.
 	 */
diff --git a/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/events/ResourceDeltaInfo.java b/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/events/ResourceDeltaInfo.java
index 034478a..6a167f3 100644
--- a/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/events/ResourceDeltaInfo.java
+++ b/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/events/ResourceDeltaInfo.java
@@ -37,7 +37,7 @@
 	}
 
 	/**
-	 * Table of all marker deltas, IPath -> MarkerSet
+	 * Table of all marker deltas, IPath -&gt; MarkerSet
 	 */
 	public Map<IPath, MarkerSet> getMarkerDeltas() {
 		return allMarkerDeltas;
diff --git a/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/localstore/Bucket.java b/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/localstore/Bucket.java
index 72c8ac0..8ff451a 100644
--- a/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/localstore/Bucket.java
+++ b/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/localstore/Bucket.java
@@ -146,7 +146,7 @@
 	static final String INDEXES_DIR_NAME = ".indexes"; //$NON-NLS-1$
 
 	/**
-	 * Map of the history entries in this bucket. Maps (String -> byte[][] or String[][]),
+	 * Map of the history entries in this bucket. Maps (String -&gt; byte[][] or String[][]),
 	 * where the key is the path of the object we are storing history for, and
 	 * the value is the history entry data (UUID,timestamp) pairs.
 	 */
diff --git a/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/localstore/HistoryBucket.java b/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/localstore/HistoryBucket.java
index ba40044..14eb02c 100644
--- a/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/localstore/HistoryBucket.java
+++ b/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/localstore/HistoryBucket.java
@@ -224,6 +224,7 @@
 	 * Version number for the current implementation file's format.
 	 * <p>
 	 * Version 2 (3.1 M5):
+	 * </p>
 	 * <pre>
 	 * FILE ::= VERSION_ID ENTRY+
 	 * ENTRY ::= PATH STATE_COUNT STATE+
@@ -233,9 +234,9 @@
 	 * UUID	 ::= byte[16]
 	 * LAST_MODIFIED ::= byte[8]
 	 * </pre>
-	 * </p>
 	 * <p>
 	 * Version 1 (3.1 M4):
+	 * </p>
 	 * <pre>
 	 * FILE ::= VERSION_ID ENTRY+
 	 * ENTRY ::= PATH STATE_COUNT STATE+
@@ -245,7 +246,6 @@
 	 * UUID	 ::= byte[16]
 	 * LAST_MODIFIED ::= byte[8]
 	 * </pre>
-	 * </p>
 	 */
 	public final static byte VERSION = 2;
 
diff --git a/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/localstore/PrefixPool.java b/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/localstore/PrefixPool.java
index 248b8f4..11cb5f1 100644
--- a/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/localstore/PrefixPool.java
+++ b/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/localstore/PrefixPool.java
@@ -22,6 +22,7 @@
  * <p>
  * Allows to enter a list of Strings, and then perform the
  * following checks:
+ * </p>
  * <ul>
  *   <li>{@link #containsAsPrefix(String)} - check whether a given
  *       String s is a prefix of any String in the pool.</li>
@@ -41,7 +42,7 @@
  * </ul>
  * The PrefixPool grows as needed when adding Strings. Typically,
  * it is used for prefix checks on absolute paths of a tree.
- * </p><p>
+ * <p>
  * This class is not thread-safe: no two threads may add or
  * check items at the same time.
  *
diff --git a/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/properties/IPropertyManager.java b/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/properties/IPropertyManager.java
index 1e9fa0a..fe0ac84 100644
--- a/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/properties/IPropertyManager.java
+++ b/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/properties/IPropertyManager.java
@@ -70,9 +70,9 @@
 	void setProperty(IResource target, QualifiedName name, String value) throws CoreException;
 
 	/**
-	 * Returns a map (<propertyKey: QualifiedName -> value: String>) containing
-	 * all properties defined for the given resource. In case no properties can
-	 * be found, returns an empty map.
+	 * Returns a map {@literal (<propertyKey: QualifiedName -> value: String>)}
+	 * containing all properties defined for the given resource. In case no
+	 * properties can be found, returns an empty map.
 	 */
 	Map<QualifiedName, String> getProperties(IResource resource) throws CoreException;
 }
diff --git a/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/properties/PropertyBucket.java b/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/properties/PropertyBucket.java
index 28fe742..1ff6d97 100644
--- a/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/properties/PropertyBucket.java
+++ b/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/properties/PropertyBucket.java
@@ -201,7 +201,8 @@
 	/** Version number for the current implementation file's format.
 	 * <p>
 	 * Version 1:
-	 * <pre>
+	 * </p>
+	 * <pre> {@code
 	 * FILE ::= VERSION_ID ENTRY+
 	 * ENTRY ::= PATH PROPERTY_COUNT PROPERTY+
 	 * PATH ::= string (does not contain project name)
@@ -212,8 +213,7 @@
 	 * QNAME -> byte string
 	 * UUID ::= byte[16]
 	 * LAST_MODIFIED ::= byte[8]
-	 * </pre>
-	 * </p>
+	 * }</pre>
 	 */
 	private static final byte VERSION = 1;
 
diff --git a/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/resources/AliasManager.java b/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/resources/AliasManager.java
index c7e2054..25a3edf 100644
--- a/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/resources/AliasManager.java
+++ b/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/resources/AliasManager.java
@@ -121,12 +121,12 @@
 	}
 
 	/**
-	 * Maintains a mapping of FileStore->IResource, such that multiple resources
+	 * Maintains a mapping of FileStore-&gt;IResource, such that multiple resources
 	 * mapped from the same location are tolerated.
 	 */
 	class LocationMap {
 		/**
-		 * Map of FileStore->IResource OR FileStore->ArrayList of (IResource)
+		 * Map of FileStore-&gt;IResource OR FileStore-&gt;ArrayList of (IResource)
 		 */
 		private final SortedMap<IFileStore, Object> map = new TreeMap<>(getComparator());
 
@@ -316,7 +316,7 @@
 	private final FindAliasesDoit findAliases = new FindAliasesDoit();
 
 	/**
-	 * This maps IFileStore ->IResource, associating a file system location
+	 * This maps IFileStore -&gt; IResource, associating a file system location
 	 * with the projects and/or linked resources that are rooted at that location.
 	 */
 	protected final LocationMap locationsMap = new LocationMap();
@@ -489,7 +489,7 @@
 	 * is based on segments, so that paths with the most segments in common will
 	 * always be adjacent.  This is equivalent to the natural order on the path
 	 * strings, with the extra condition that the path separator is ordered
-	 * before all other characters. (Ex: "/foo" < "/foo/zzz" < "/fooaaa").
+	 * before all other characters. (Ex: "/foo" &lt; "/foo/zzz" &lt; "/fooaaa").
 	 */
 	Comparator<IFileStore> getComparator() {
 		return new Comparator<IFileStore>() {
diff --git a/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/resources/ComputeProjectOrder.java b/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/resources/ComputeProjectOrder.java
index 6c18cd0..a23f537 100644
--- a/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/resources/ComputeProjectOrder.java
+++ b/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/resources/ComputeProjectOrder.java
@@ -45,7 +45,7 @@
 	 * defined, the graph can be queried for the depth-first finish time of each
 	 * vertex.
 	 * <p>
-	 * Ref: Cormen, Leiserson, and Rivest <it>Introduction to Algorithms</it>,
+	 * Ref: Cormen, Leiserson, and Rivest <i>Introduction to Algorithms</i>,
 	 * McGraw-Hill, 1990. The depth-first search algorithm is in section 23.3.
 	 * </p>
 	 */
@@ -548,8 +548,8 @@
 	 * If there are no constraints on the order of the vertexes, they are returned
 	 * in the reverse order of how they are supplied.
 	 * </p>
-	 * <p> Ref: Cormen, Leiserson, and Rivest <it>Introduction to
-	 * Algorithms</it>, McGraw-Hill, 1990. The strongly-connected-components
+	 * <p> Ref: Cormen, Leiserson, and Rivest <i>Introduction to
+	 * Algorithms</i>, McGraw-Hill, 1990. The strongly-connected-components
 	 * algorithm is in section 23.5.
 	 * </p>
 	 *
@@ -674,8 +674,8 @@
 	}
 
 	/**
-	 * Builds a digraph excluding the nodes that do not match filter, but keeps transitive edges. Ie if A->B->C and B is removed,
-	 * result would be A->C.
+	 * Builds a digraph excluding the nodes that do not match filter, but keeps transitive edges. Ie if A-&gt;B-&gt;C and B is removed,
+	 * result would be A-&gt;C.
 	 *
 	 * Complexity is O(#edge + #vertex). It implements a dynamic recursive deep-first graph traversing algorithm to compute
 	 * resutling edges.
diff --git a/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/resources/MarkerDelta.java b/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/resources/MarkerDelta.java
index 6da24df..c603e15 100644
--- a/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/resources/MarkerDelta.java
+++ b/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/resources/MarkerDelta.java
@@ -105,8 +105,8 @@
 	}
 
 	/**
-	 * Merge two Maps of (IPath->MarkerSet) representing changes.  Use the old
-	 * map to store the result so we don't have to build a new map to return.
+	 * Merge two Maps of (IPath-&gt;MarkerSet) representing changes. Use the old map
+	 * to store the result so we don't have to build a new map to return.
 	 */
 	public static Map<IPath, MarkerSet> merge(Map<IPath, MarkerSet> oldChanges, Map<IPath, MarkerSet> newChanges) {
 		if (oldChanges == null)
@@ -130,6 +130,7 @@
 	 * Merge two sets of marker changes.  Both sets must be on the same resource. Use the original set
 	 * of changes to store the result so we don't have to build a completely different set to return.
 	 *
+	 * <pre>
 	 * add + add = N/A
 	 * add + remove = nothing (no delta)
 	 * add + change = add
@@ -139,6 +140,7 @@
 	 * change + add = N/A
 	 * change + change = change  (note: info held onto by the marker delta should be that of the oldest change, and not replaced when composed)
 	 * change + remove = remove (note: info held onto by the marker delta should be that of the oldest change, and not replaced when changed to a remove)
+	 * </pre>
 	 */
 	protected static MarkerSet merge(MarkerSet oldChanges, IMarkerSetElement[] newChanges) {
 		if (oldChanges == null) {
diff --git a/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/resources/MarkerReader_1.java b/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/resources/MarkerReader_1.java
index b6a38ee..55c5ae9 100644
--- a/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/resources/MarkerReader_1.java
+++ b/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/resources/MarkerReader_1.java
@@ -43,6 +43,7 @@
 	}
 
 	/**
+	 * <pre> {@code
 	 * SAVE_FILE -> VERSION_ID RESOURCE+
 	 * VERSION_ID ->
 	 * RESOURCE -> RESOURCE_PATH MARKERS_SIZE MARKER*
@@ -61,6 +62,7 @@
 	 * BOOLEAN_VALUE -> int boolean
 	 * STRING_VALUE -> int String
 	 * NULL_VALUE -> int
+	 * }</pre>
 	 */
 	@Override
 	public void read(DataInputStream input, boolean generateDeltas) throws IOException, CoreException {
diff --git a/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/resources/MarkerReader_2.java b/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/resources/MarkerReader_2.java
index e4db157..3d7e1d5 100644
--- a/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/resources/MarkerReader_2.java
+++ b/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/resources/MarkerReader_2.java
@@ -44,6 +44,7 @@
 	}
 
 	/**
+	 * <pre> {@code
 	 * SAVE_FILE -> VERSION_ID RESOURCE+
 	 * VERSION_ID -> int
 	 * RESOURCE -> RESOURCE_PATH MARKERS_SIZE MARKER+
@@ -62,6 +63,7 @@
 	 * BOOLEAN_VALUE -> byte boolean
 	 * STRING_VALUE -> byte String
 	 * NULL_VALUE -> byte
+	 * }</pre>
 	 */
 	@Override
 	public void read(DataInputStream input, boolean generateDeltas) throws IOException, CoreException {
diff --git a/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/resources/MarkerReader_3.java b/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/resources/MarkerReader_3.java
index 5afbce4..1fe6c0f 100644
--- a/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/resources/MarkerReader_3.java
+++ b/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/resources/MarkerReader_3.java
@@ -44,6 +44,7 @@
 	}
 
 	/**
+	 * <pre> {@code
 	 * SAVE_FILE -> VERSION_ID RESOURCE+
 	 * VERSION_ID -> int
 	 * RESOURCE -> RESOURCE_PATH MARKERS_SIZE MARKER+
@@ -63,6 +64,7 @@
 	 * STRING_VALUE -> byte String
 	 * NULL_VALUE -> byte
 	 * CREATION_TIME -> long
+	 * }</pre>
 	 */
 	@Override
 	public void read(DataInputStream input, boolean generateDeltas) throws IOException, CoreException {
diff --git a/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/resources/MarkerSnapshotReader_1.java b/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/resources/MarkerSnapshotReader_1.java
index dfc9a1b..7bd9c85 100644
--- a/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/resources/MarkerSnapshotReader_1.java
+++ b/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/resources/MarkerSnapshotReader_1.java
@@ -44,6 +44,7 @@
 	}
 
 	/**
+	 * <pre> {@code
 	 * SNAP_FILE -> [VERSION_ID RESOURCE]*
 	 * VERSION_ID -> int (used for backwards compatibiliy)
 	 * RESOURCE -> RESOURCE_PATH MARKER_SIZE MARKER+
@@ -62,6 +63,7 @@
 	 * INTEGER_VALUE -> byte int
 	 * STRING_VALUE -> byte String
 	 * NULL_VALUE -> byte
+	 * }</pre>
 	 */
 	@Override
 	public void read(DataInputStream input) throws IOException, CoreException {
diff --git a/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/resources/MarkerSnapshotReader_2.java b/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/resources/MarkerSnapshotReader_2.java
index 7d48c9f..6707f7f 100644
--- a/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/resources/MarkerSnapshotReader_2.java
+++ b/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/resources/MarkerSnapshotReader_2.java
@@ -44,6 +44,7 @@
 	}
 
 	/**
+	 * <pre> {@code
 	 * SNAP_FILE -> [VERSION_ID RESOURCE]*
 	 * VERSION_ID -> int (used for backwards compatibiliy)
 	 * RESOURCE -> RESOURCE_PATH MARKER_SIZE MARKER+
@@ -63,6 +64,7 @@
 	 * STRING_VALUE -> byte String
 	 * NULL_VALUE -> byte
 	 * CREATION_TIME -> long
+	 * }</pre>
 	 */
 	@Override
 	public void read(DataInputStream input) throws IOException, CoreException {
diff --git a/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/resources/MarkerTypeDefinitionCache.java b/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/resources/MarkerTypeDefinitionCache.java
index 5a1cdc4..489d4ef 100644
--- a/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/resources/MarkerTypeDefinitionCache.java
+++ b/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/resources/MarkerTypeDefinitionCache.java
@@ -58,7 +58,7 @@
 	}
 
 	/**
-	 * The marker type definitions.  Maps String (markerId) -> MarkerTypeDefinition
+	 * The marker type definitions.  Maps String (markerId) -&gt; MarkerTypeDefinition
 	 */
 	protected HashMap<String, MarkerTypeDefinition> definitions;
 
diff --git a/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/resources/MarkerWriter.java b/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/resources/MarkerWriter.java
index cbaf2dd..9ae305a 100644
--- a/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/resources/MarkerWriter.java
+++ b/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/resources/MarkerWriter.java
@@ -67,6 +67,7 @@
 	}
 
 	/**
+	 * <pre> {@code
 	 * SAVE_FILE -> VERSION_ID RESOURCE+
 	 * VERSION_ID -> int
 	 * RESOURCE -> RESOURCE_PATH MARKERS_SIZE MARKER+
@@ -86,7 +87,7 @@
 	 * STRING_VALUE -> byte String
 	 * NULL_VALUE -> byte
 	 * CREATION_TIME -> long
-	 *
+	 * }</pre>
 	 */
 	public void save(ResourceInfo info, IPathRequestor requestor, DataOutputStream output, List<String> writtenTypes) throws IOException {
 		// phantom resources don't have markers
@@ -116,6 +117,7 @@
 	/**
 	 * Snapshot the markers for the specified resource to the given output stream.
 	 *
+	 * <pre> {@code
 	 * SNAP_FILE -> [VERSION_ID RESOURCE]*
 	 * VERSION_ID -> int (used for backwards compatibiliy)
 	 * RESOURCE -> RESOURCE_PATH MARKER_SIZE MARKER+
@@ -135,6 +137,7 @@
 	 * STRING_VALUE -> byte String
 	 * NULL_VALUE -> byte
 	 * CREATION_TIME -> long
+	 * }</pre>
 	 */
 	public void snap(ResourceInfo info, IPathRequestor requestor, DataOutputStream output) throws IOException {
 		// phantom resources don't have markers
diff --git a/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/resources/PathVariableManager.java b/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/resources/PathVariableManager.java
index dcd0e9d..2f2e0d6 100644
--- a/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/resources/PathVariableManager.java
+++ b/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/resources/PathVariableManager.java
@@ -46,8 +46,7 @@
 	}
 
 	/**
-	 * @see org.eclipse.core.resources.
-	 * IPathVariableManager#addChangeListener(IPathVariableChangeListener)
+	 * @see org.eclipse.core.resources.IPathVariableManager#addChangeListener(IPathVariableChangeListener)
 	 */
 	@Override
 	public void addChangeListener(IPathVariableChangeListener listener) {
@@ -187,8 +186,7 @@
 	}
 
 	/**
-	 * @see org.eclipse.core.resources.
-	 * IPathVariableManager#removeChangeListener(IPathVariableChangeListener)
+	 * @see org.eclipse.core.resources.IPathVariableManager#removeChangeListener(IPathVariableChangeListener)
 	 */
 	@Override
 	public void removeChangeListener(IPathVariableChangeListener listener) {
diff --git a/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/resources/PlatformURLResourceConnection.java b/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/resources/PlatformURLResourceConnection.java
index 31a3c8b..734d438 100644
--- a/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/resources/PlatformURLResourceConnection.java
+++ b/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/resources/PlatformURLResourceConnection.java
@@ -24,8 +24,8 @@
 import org.eclipse.osgi.util.NLS;
 
 /**
- * Platform URL support
- * platform:/resource/<path>/<resource>  maps to resource in current workspace
+ * Platform URL support {@literal platform:/resource/<path>/<resource>} maps to
+ * resource in current workspace
  */
 public class PlatformURLResourceConnection extends PlatformURLConnection {
 
diff --git a/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/resources/ProjectDescription.java b/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/resources/ProjectDescription.java
index a4eb872..74689e7 100644
--- a/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/resources/ProjectDescription.java
+++ b/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/resources/ProjectDescription.java
@@ -57,7 +57,7 @@
 	// Static + Dynamic project level references
 	protected IProject[] staticRefs = EMPTY_PROJECT_ARRAY;
 	protected IProject[] dynamicRefs = EMPTY_PROJECT_ARRAY;
-	/** Map from config name in this project -> build configurations in other projects */
+	/** Map from config name in this project -&gt; build configurations in other projects */
 	protected HashMap<String, IBuildConfiguration[]> dynamicConfigRefs = new HashMap<>(1);
 
 	// Cache of the build configurations
@@ -81,19 +81,19 @@
 	protected final Object cachedRefsMutex = new Object();
 
 	/**
-	 * Map of (IPath -> LinkDescription) pairs for each linked resource
+	 * Map of (IPath -&gt; LinkDescription) pairs for each linked resource
 	 * in this project, where IPath is the project relative path of the resource.
 	 */
 	protected HashMap<IPath, LinkDescription> linkDescriptions = null;
 
 	/**
-	 * Map of (IPath -> LinkedList<FilterDescription>) pairs for each filtered resource
+	 * Map of {@literal (IPath -> LinkedList<FilterDescription>)} pairs for each filtered resource
 	 * in this project, where IPath is the project relative path of the resource.
 	 */
 	protected HashMap<IPath, LinkedList<FilterDescription>> filterDescriptions = null;
 
 	/**
-	 * Map of (String -> VariableDescription) pairs for each variable in this
+	 * Map of (String -&gt; VariableDescription) pairs for each variable in this
 	 * project, where String is the name of the variable.
 	 */
 	protected HashMap<String, VariableDescription> variableDescriptions = null;
@@ -187,7 +187,7 @@
 	/**
 	 * Helper to fetch projects from an array of build configuration references
 	 * @param refs
-	 * @return List<IProject>
+	 * @return {@literal List<IProject>}
 	 */
 	private Collection<IProject> getProjectsFromBuildConfigRefs(IBuildConfiguration[] refs) {
 		LinkedHashSet<IProject> projects = new LinkedHashSet<>(refs.length);
@@ -380,7 +380,7 @@
 	}
 
 	/**
-	 * Returns the map of link descriptions (IPath (project relative path) -> LinkDescription).
+	 * Returns the map of link descriptions (IPath (project relative path) -&gt; LinkDescription).
 	 * Since this method is only used internally, it never creates a copy.
 	 * Returns null if the project does not have any linked resources.
 	 */
@@ -389,16 +389,17 @@
 	}
 
 	/**
-	 * Returns the map of filter descriptions (IPath (project relative path) -> LinkedList<FilterDescription>).
-	 * Since this method is only used internally, it never creates a copy.
-	 * Returns null if the project does not have any filtered resources.
+	 * Returns the map of filter descriptions (IPath (project relative path) -&gt;
+	 * {@literal LinkedList<FilterDescription>}). Since this method is only used
+	 * internally, it never creates a copy. Returns null if the project does not
+	 * have any filtered resources.
 	 */
 	public HashMap<IPath, LinkedList<FilterDescription>> getFilters() {
 		return filterDescriptions;
 	}
 
 	/**
-	 * Returns the map of variable descriptions (String (variable name) ->
+	 * Returns the map of variable descriptions (String (variable name) -&gt;
 	 * VariableDescription). Since this method is only used internally, it never
 	 * creates a copy. Returns null if the project does not have any variables.
 	 */
@@ -474,7 +475,7 @@
 	}
 
 	/**
-	 * Helper method to compare two maps of Configuration Name -> IBuildConfigurationReference[]
+	 * Helper method to compare two maps of Configuration Name -&gt; IBuildConfigurationReference[]
 	 * @return boolean indicating if there are differences between the two maps
 	 */
 	private static boolean configRefsHaveChanges(Map<String, IBuildConfiguration[]> m1, Map<String, IBuildConfiguration[]> m2) {
@@ -663,7 +664,7 @@
 	}
 
 	/**
-	 * Sets the map of link descriptions (String name -> LinkDescription).
+	 * Sets the map of link descriptions (String name -&gt; LinkDescription).
 	 * Since this method is only used internally, it never creates a copy. May
 	 * pass null if this project does not have any linked resources
 	 */
@@ -672,7 +673,7 @@
 	}
 
 	/**
-	 * Sets the map of filter descriptions (String name -> LinkedList<LinkDescription>).
+	 * Sets the map of filter descriptions {@literal (String name -> LinkedList<LinkDescription>)}.
 	 * Since this method is only used internally, it never creates a copy. May
 	 * pass null if this project does not have any filtered resources
 	 */
@@ -681,7 +682,7 @@
 	}
 
 	/**
-	 * Sets the map of variable descriptions (String name ->
+	 * Sets the map of variable descriptions (String name -&gt;
 	 * VariableDescription). Since this method is only used internally, it never
 	 * creates a copy. May pass null if this project does not have any variables
 	 */
diff --git a/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/resources/SaveManager.java b/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/resources/SaveManager.java
index 1b4c08d..5ad0765 100644
--- a/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/resources/SaveManager.java
+++ b/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/resources/SaveManager.java
@@ -107,7 +107,7 @@
 	protected long persistSyncInfo = 0l;
 
 	/**
-	 * In-memory representation of plugins saved state. Maps String (plugin id)-> SavedState.
+	 * In-memory representation of plugins saved state. Maps String (plugin id)-&gt; SavedState.
 	 * This map is accessed from API that is not synchronized, so it requires
 	 * independent synchronization. This is accomplished using a synchronized
 	 * wrapper map.
@@ -115,7 +115,7 @@
 	protected Map<String, SavedState> savedStates;
 
 	/**
-	 * Ids of plugins that participate on a workspace save. Maps String (plugin id)-> ISaveParticipant.
+	 * Ids of plugins that participate on a workspace save. Maps String (plugin id)-&gt; ISaveParticipant.
 	 * This map is accessed from API that is not synchronized, so it requires
 	 * independent synchronization. This is accomplished using a synchronized
 	 * wrapper map.
@@ -353,7 +353,7 @@
 	/**
 	 * Returns a table mapping having the plug-in id as the key and the old tree
 	 * as the value.
-	 * This table is based on the union of the current savedStates</code>
+	 * This table is based on the union of the current <code>savedStates</code>
 	 * and the given table of contexts.  The specified tree is used as the tree for
 	 * any newly created saved states.  This method is used to compute the set of
 	 * saved states to be written out.
@@ -740,7 +740,7 @@
 	/**
 	 * Restores the contents of this project.  Throw
 	 * an exception if the project could not be restored.
-	 * @return <code><code>true</code> if the project data was restored successfully,
+	 * @return <code>true</code> if the project data was restored successfully,
 	 * and <code>false</code> if non-critical problems occurred while restoring.
 	 * @exception CoreException if the project could not be restored.
 	 */
@@ -773,7 +773,7 @@
 	 * Restores the contents of this project from a refresh snapshot, if possible.
 	 * Throws an exception if the snapshot is found but an error occurs when reading
 	 * the file.
-	 * @return <code><code>true</code> if the project data was restored successfully,
+	 * @return <code>true</code> if the project data was restored successfully,
 	 * and <code>false</code> if the refresh snapshot was not found or could not be opened.
 	 * @exception CoreException if an error occurred reading the snapshot file.
 	 */
diff --git a/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/resources/SyncInfoReader_2.java b/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/resources/SyncInfoReader_2.java
index d72060b..cf6206e 100644
--- a/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/resources/SyncInfoReader_2.java
+++ b/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/resources/SyncInfoReader_2.java
@@ -39,6 +39,7 @@
 	}
 
 	/**
+	 * <pre> {@code
 	 * SAVE_FILE -> VERSION_ID RESOURCE*
 	 * VERSION_ID -> int
 	 * RESOURCE -> RESOURCE_PATH SIZE SYNCINFO*
@@ -49,7 +50,7 @@
 	 * INDEX -> int int
 	 * QNAME -> int String
 	 * BYTES -> byte[]
-	 *
+	 * }</pre>
 	 */
 	@Override
 	public void readSyncInfo(DataInputStream input) throws IOException, CoreException {
diff --git a/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/resources/SyncInfoReader_3.java b/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/resources/SyncInfoReader_3.java
index b547535..a5ef11c 100644
--- a/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/resources/SyncInfoReader_3.java
+++ b/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/resources/SyncInfoReader_3.java
@@ -39,6 +39,7 @@
 	}
 
 	/**
+	 * <pre> {@code
 	 * SAVE_FILE -> VERSION_ID RESOURCE+
 	 * VERSION_ID -> int
 	 * RESOURCE -> RESOURCE_PATH SIZE SYNCINFO*
@@ -49,7 +50,7 @@
 	 * INDEX -> byte int
 	 * QNAME -> byte String
 	 * BYTES -> byte[]
-	 *
+	 * }</pre>
 	 */
 	@Override
 	public void readSyncInfo(DataInputStream input) throws IOException, CoreException {
diff --git a/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/resources/SyncInfoSnapReader_3.java b/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/resources/SyncInfoSnapReader_3.java
index c7cd8d2..c88d05a 100644
--- a/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/resources/SyncInfoSnapReader_3.java
+++ b/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/resources/SyncInfoSnapReader_3.java
@@ -45,6 +45,7 @@
 	}
 
 	/**
+	 * <pre> {@code
 	 * SNAP_FILE -> [VERSION_ID RESOURCE]*
 	 * VERSION_ID -> int
 	 * RESOURCE -> RESOURCE_PATH SIZE SYNCINFO*
@@ -53,6 +54,7 @@
 	 * SYNCINFO -> QNAME BYTES
 	 * QNAME -> String String
 	 * BYTES -> byte[]
+	 * }</pre>
 	 */
 	@Override
 	public void readSyncInfo(DataInputStream input) throws IOException {
diff --git a/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/resources/SyncInfoWriter.java b/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/resources/SyncInfoWriter.java
index 656e910..a1cdc13 100644
--- a/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/resources/SyncInfoWriter.java
+++ b/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/resources/SyncInfoWriter.java
@@ -48,6 +48,7 @@
 	}
 
 	/**
+	 * <pre> {@code
 	 * SAVE_FILE -> VERSION_ID RESOURCE+
 	 * VERSION_ID -> int
 	 * RESOURCE -> RESOURCE_PATH SIZE SYNCINFO*
@@ -58,6 +59,7 @@
 	 * INDEX -> byte int
 	 * QNAME -> byte String
 	 * BYTES -> byte[]
+	 * }</pre>
 	 */
 	public void saveSyncInfo(ResourceInfo info, IPathRequestor requestor, DataOutputStream output, List<QualifiedName> writtenPartners) throws IOException {
 		Map<QualifiedName, Object> table = info.getSyncInfo(false);
@@ -91,6 +93,7 @@
 	}
 
 	/**
+	 * <pre> {@code
 	 * SNAP_FILE -> [VERSION_ID RESOURCE]*
 	 * VERSION_ID -> int
 	 * RESOURCE -> RESOURCE_PATH SIZE SYNCINFO*
@@ -99,6 +102,7 @@
 	 * SYNCINFO -> QNAME BYTES
 	 * QNAME -> String String
 	 * BYTES -> byte[]
+	 * }</pre>
 	 */
 	public void snapSyncInfo(ResourceInfo info, IPathRequestor requestor, DataOutputStream output) throws IOException {
 		if (!info.isSet(ICoreConstants.M_SYNCINFO_SNAP_DIRTY))
diff --git a/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/resources/Workspace.java b/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/resources/Workspace.java
index bbb35c6..b17924c 100644
--- a/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/resources/Workspace.java
+++ b/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/resources/Workspace.java
@@ -48,7 +48,6 @@
 /**
  * The workspace class is the monolithic nerve center of the resources plugin.
  * All interesting functionality stems from this class.
- * </p>
  * <p>
  * The lifecycle of the resources plugin is encapsulated by the {@link #open(IProgressMonitor)}
  * and {@link #close(IProgressMonitor)} methods.  A closed workspace is completely
@@ -58,6 +57,7 @@
  * <p>
  * All modifications to the workspace occur within the context of a workspace operation.
  * A workspace operation is implemented using the following sequence:
+ * </p>
  * <pre>
  * 	try {
  *		prepareOperation(...);
@@ -71,6 +71,7 @@
  * Workspace operations can be nested arbitrarily. A "top level" workspace operation
  * is an operation that is not nested within another workspace operation in the current
  * thread.
+ * <p>
  * See the javadoc of {@link #prepareOperation(ISchedulingRule, IProgressMonitor)},
  * {@link #beginOperation(boolean)}, and {@link #endOperation(ISchedulingRule, boolean)}
  * for more details.
diff --git a/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/resources/WorkspacePreferences.java b/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/resources/WorkspacePreferences.java
index 58c605f..d5cb26b 100644
--- a/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/resources/WorkspacePreferences.java
+++ b/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/resources/WorkspacePreferences.java
@@ -134,8 +134,7 @@
 	}
 
 	/**
-	 * @see org.eclipse.core.internal.resources.
-	 * WorkspaceDescription#getBuildOrder(boolean)
+	 * @see org.eclipse.core.internal.resources.WorkspaceDescription#getBuildOrder(boolean)
 	 */
 	@Override
 	public String[] getBuildOrder(boolean makeCopy) {
diff --git a/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/watson/ElementTreeIterator.java b/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/watson/ElementTreeIterator.java
index 192437e..d537daf 100644
--- a/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/watson/ElementTreeIterator.java
+++ b/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/watson/ElementTreeIterator.java
@@ -29,18 +29,18 @@
  * that node, and a callback for requesting the full path of that node.
  * <p>
  * <b>Example:</b>
- <code><pre>
- // printing a crude representation of the poster child
- IElementContentVisitor visitor=
-     new IElementContentVisitor() {
-   public boolean visitElement(ElementTree tree, IPathRequestor requestor, Object elementContents) {
-     System.out.println(requestor.requestPath() + " -> " + elementContents);
-     return true;
-   }
- });
- ElementTreeIterator iterator = new ElementTreeIterator(tree, Path.ROOT);
- iterator.iterate(visitor);
- </pre></code>
+ * <pre><code>
+ * // printing a crude representation of the poster child
+ * IElementContentVisitor visitor=
+ *     new IElementContentVisitor() {
+ *   public boolean visitElement(ElementTree tree, IPathRequestor requestor, Object elementContents) {
+ *     System.out.println(requestor.requestPath() + " -&gt; " + elementContents);
+ *     return true;
+ *   }
+ * });
+ * ElementTreeIterator iterator = new ElementTreeIterator(tree, Path.ROOT);
+ * iterator.iterate(visitor);
+ * </code></pre>
  */
 public class ElementTreeIterator implements IPathRequestor {
 	//for path requestor
diff --git a/bundles/org.eclipse.core.resources/src_ant/org/eclipse/core/resources/ant/ConvertPath.java b/bundles/org.eclipse.core.resources/src_ant/org/eclipse/core/resources/ant/ConvertPath.java
index 8b9a9cb..50b97b0 100644
--- a/bundles/org.eclipse.core.resources/src_ant/org/eclipse/core/resources/ant/ConvertPath.java
+++ b/bundles/org.eclipse.core.resources/src_ant/org/eclipse/core/resources/ant/ConvertPath.java
@@ -27,7 +27,7 @@
  * resource does not exist, the property is set to <code>false</code>.
  * <p>
  * The attribute "property" must be specified, as well as only one of "fileSystemPath" or "resourcePath".
- * <p><p>
+ * <p>
  * Example:<p>
  *	&lt;eclipse.convertPath fileSystemPath="D:\MyWork\MyProject" property="myProject.resourcePath"/&gt;
  */
diff --git a/bundles/org.eclipse.core.resources/src_ant/org/eclipse/core/resources/ant/IncrementalBuild.java b/bundles/org.eclipse.core.resources/src_ant/org/eclipse/core/resources/ant/IncrementalBuild.java
index 8b544ed..276b8e3 100644
--- a/bundles/org.eclipse.core.resources/src_ant/org/eclipse/core/resources/ant/IncrementalBuild.java
+++ b/bundles/org.eclipse.core.resources/src_ant/org/eclipse/core/resources/ant/IncrementalBuild.java
@@ -99,8 +99,8 @@
 	}
 
 	/**
-	 * Sets the receiver's kind> attribute.  This value must be one
-	 * of: <code>IncrementalBuild.KIND_FULL</code>,
+	 * Sets the receiver's kind attribute. This value must be one of:
+	 * <code>IncrementalBuild.KIND_FULL</code>,
 	 * <code>IncrementalBuild.KIND_AUTO</code>,
 	 * <code>IncrementalBuild.KIND_INCREMENTAL</code>,
 	 * <code>IncrementalBuild.KIND_CLEAN</code>.
diff --git a/bundles/org.eclipse.core.tools.resources/src/org/eclipse/core/tools/resources/ProjectContentProvider.java b/bundles/org.eclipse.core.tools.resources/src/org/eclipse/core/tools/resources/ProjectContentProvider.java
index 598b236..68d1260 100644
--- a/bundles/org.eclipse.core.tools.resources/src/org/eclipse/core/tools/resources/ProjectContentProvider.java
+++ b/bundles/org.eclipse.core.tools.resources/src/org/eclipse/core/tools/resources/ProjectContentProvider.java
@@ -34,7 +34,7 @@
  *   <li>the builders associated to this project. For each builder it shows:<ul>
  *       <li>the builder's name;</li>        
  *       <li>the arguments;</li>
- *       <li>persistent info (interesting projects &amp; last built tree);</li> * 
+ *       <li>persistent info (interesting projects &amp; last built tree);</li>
  *   </ul></li> 
  
  *   <li>the natures associated to this project. For each nature it shows:<ul>
diff --git a/bundles/org.eclipse.core.tools.resources/src/org/eclipse/core/tools/resources/metadata/MarkersDumpingStrategy_1.java b/bundles/org.eclipse.core.tools.resources/src/org/eclipse/core/tools/resources/metadata/MarkersDumpingStrategy_1.java
index f14111a..e4355fb 100644
--- a/bundles/org.eclipse.core.tools.resources/src/org/eclipse/core/tools/resources/metadata/MarkersDumpingStrategy_1.java
+++ b/bundles/org.eclipse.core.tools.resources/src/org/eclipse/core/tools/resources/metadata/MarkersDumpingStrategy_1.java
@@ -21,7 +21,7 @@
 
 /**
  * A strategy for reading .markers files version 1. Layout:
- * <pre>
+ * <pre> {@code
  * SAVE_FILE -> VERSION_ID RESOURCE+
  * VERSION_ID -> 
  * RESOURCE -> RESOURCE_PATH MARKERS_SIZE MARKER*
@@ -40,7 +40,7 @@
  * BOOLEAN_VALUE -> int boolean
  * STRING_VALUE -> int String
  * NULL_VALUE -> int
- * </pre>
+ * }</pre>
  */
 public class MarkersDumpingStrategy_1 implements IStringDumpingStrategy {
 	@Override
diff --git a/bundles/org.eclipse.core.tools.resources/src/org/eclipse/core/tools/resources/metadata/MarkersDumpingStrategy_2.java b/bundles/org.eclipse.core.tools.resources/src/org/eclipse/core/tools/resources/metadata/MarkersDumpingStrategy_2.java
index 6a3704f..e45e9fd 100644
--- a/bundles/org.eclipse.core.tools.resources/src/org/eclipse/core/tools/resources/metadata/MarkersDumpingStrategy_2.java
+++ b/bundles/org.eclipse.core.tools.resources/src/org/eclipse/core/tools/resources/metadata/MarkersDumpingStrategy_2.java
@@ -21,7 +21,7 @@
 
 /**
  * A strategy for reading .markers files version 2. Layout:
- * <pre>
+ * <pre> {@code
  * SAVE_FILE -> VERSION_ID RESOURCE+
  * VERSION_ID -> int
  * RESOURCE -> RESOURCE_PATH MARKERS_SIZE MARKER+
@@ -40,7 +40,7 @@
  * BOOLEAN_VALUE -> byte boolean
  * STRING_VALUE -> byte String
  * NULL_VALUE -> byte
- * </pre> 
+ * }</pre> 
  */
 public class MarkersDumpingStrategy_2 implements IStringDumpingStrategy {
 	@Override
diff --git a/bundles/org.eclipse.core.tools.resources/src/org/eclipse/core/tools/resources/metadata/MarkersDumpingStrategy_3.java b/bundles/org.eclipse.core.tools.resources/src/org/eclipse/core/tools/resources/metadata/MarkersDumpingStrategy_3.java
index 5a11611..90b3b62 100644
--- a/bundles/org.eclipse.core.tools.resources/src/org/eclipse/core/tools/resources/metadata/MarkersDumpingStrategy_3.java
+++ b/bundles/org.eclipse.core.tools.resources/src/org/eclipse/core/tools/resources/metadata/MarkersDumpingStrategy_3.java
@@ -21,7 +21,7 @@
 
 /**
  * A strategy for reading .markers files version 3. Layout:
- * <pre>
+ * <pre> {@code
  * SAVE_FILE -> VERSION_ID RESOURCE+
  * VERSION_ID -> int
  * RESOURCE -> RESOURCE_PATH MARKERS_SIZE MARKER+
@@ -41,7 +41,7 @@
  * STRING_VALUE -> byte String
  * NULL_VALUE -> byte
  * CREATION_TIME -> long
- * </pre> 
+ * }</pre> 
  */
 
 public class MarkersDumpingStrategy_3 implements IStringDumpingStrategy {
diff --git a/bundles/org.eclipse.core.tools.resources/src/org/eclipse/core/tools/resources/metadata/MarkersSnapshotDumpingStrategy_1.java b/bundles/org.eclipse.core.tools.resources/src/org/eclipse/core/tools/resources/metadata/MarkersSnapshotDumpingStrategy_1.java
index 6d9b1b5..5a71890 100644
--- a/bundles/org.eclipse.core.tools.resources/src/org/eclipse/core/tools/resources/metadata/MarkersSnapshotDumpingStrategy_1.java
+++ b/bundles/org.eclipse.core.tools.resources/src/org/eclipse/core/tools/resources/metadata/MarkersSnapshotDumpingStrategy_1.java
@@ -21,8 +21,7 @@
 
 /**
  * A strategy for reading .markers.snap files version 1. Layout:
- * <pre>
-
+ * <pre> {@code
  * SNAP_FILE -> [VERSION_ID RESOURCE]*
  * VERSION_ID -> int (used for backwards compatibiliy)
  * RESOURCE -> RESOURCE_PATH MARKER_SIZE MARKER+
@@ -41,7 +40,7 @@
  * INTEGER_VALUE -> byte int
  * STRING_VALUE -> byte String
  * NULL_VALUE -> byte
- * </pre>
+ * }</pre>
  */
 class MarkersSnapshotDumpingStrategy_1 implements IStringDumpingStrategy {
 	@Override
diff --git a/bundles/org.eclipse.core.tools.resources/src/org/eclipse/core/tools/resources/metadata/MarkersSnapshotDumpingStrategy_2.java b/bundles/org.eclipse.core.tools.resources/src/org/eclipse/core/tools/resources/metadata/MarkersSnapshotDumpingStrategy_2.java
index 3ec6fec..6d40241 100644
--- a/bundles/org.eclipse.core.tools.resources/src/org/eclipse/core/tools/resources/metadata/MarkersSnapshotDumpingStrategy_2.java
+++ b/bundles/org.eclipse.core.tools.resources/src/org/eclipse/core/tools/resources/metadata/MarkersSnapshotDumpingStrategy_2.java
@@ -21,8 +21,7 @@
 
 /**
  * A strategy for reading .markers.snap files version 2. Layout:
- * <pre>
-
+ * <pre> {@code
  * SNAP_FILE -> [VERSION_ID RESOURCE]*
  * VERSION_ID -> int (used for backwards compatibiliy)
  * RESOURCE -> RESOURCE_PATH MARKER_SIZE MARKER+
@@ -42,7 +41,7 @@
  * STRING_VALUE -> byte String
  * NULL_VALUE -> byte
  * CREATION_TIME -> long
- * </pre>
+ * }</pre>
  */
 class MarkersSnapshotDumpingStrategy_2 implements IStringDumpingStrategy {
 	@Override
diff --git a/bundles/org.eclipse.core.tools.resources/src/org/eclipse/core/tools/resources/metadata/SyncInfoDumpingStrategy_2.java b/bundles/org.eclipse.core.tools.resources/src/org/eclipse/core/tools/resources/metadata/SyncInfoDumpingStrategy_2.java
index 29786cf..d30e41c 100644
--- a/bundles/org.eclipse.core.tools.resources/src/org/eclipse/core/tools/resources/metadata/SyncInfoDumpingStrategy_2.java
+++ b/bundles/org.eclipse.core.tools.resources/src/org/eclipse/core/tools/resources/metadata/SyncInfoDumpingStrategy_2.java
@@ -22,7 +22,7 @@
 
 /**
  * A strategy for reading .syncinfo files version 2. Layout:
- * <pre>
+ * <pre> {@code
  * SAVE_FILE -> VERSION_ID RESOURCE*
  * VERSION_ID -> int
  * RESOURCE -> RESOURCE_PATH SIZE SYNCINFO*
@@ -33,7 +33,7 @@
  * INDEX -> int int
  * QNAME -> int String
  * BYTES -> byte[] 
- * </pre>
+ * }</pre>
  */
 class SyncInfoDumpingStrategy_2 implements IStringDumpingStrategy {
 	@Override
diff --git a/bundles/org.eclipse.core.tools.resources/src/org/eclipse/core/tools/resources/metadata/SyncInfoDumpingStrategy_3.java b/bundles/org.eclipse.core.tools.resources/src/org/eclipse/core/tools/resources/metadata/SyncInfoDumpingStrategy_3.java
index 67164e4..481cd65 100644
--- a/bundles/org.eclipse.core.tools.resources/src/org/eclipse/core/tools/resources/metadata/SyncInfoDumpingStrategy_3.java
+++ b/bundles/org.eclipse.core.tools.resources/src/org/eclipse/core/tools/resources/metadata/SyncInfoDumpingStrategy_3.java
@@ -22,7 +22,7 @@
 
 /**
  * A strategy for reading .syncinfo files version 3. Layout:
- * <pre>
+ * <pre> {@code
  * SAVE_FILE -> VERSION_ID RESOURCE+
  * VERSION_ID -> int
  * RESOURCE -> RESOURCE_PATH SIZE SYNCINFO*
@@ -33,7 +33,7 @@
  * INDEX -> byte int
  * QNAME -> byte String
  * BYTES -> byte[]
- * </pre>
+ * }</pre>
  */
 class SyncInfoDumpingStrategy_3 implements IStringDumpingStrategy {
 	@Override
diff --git a/bundles/org.eclipse.core.tools.resources/src/org/eclipse/core/tools/resources/metadata/SyncInfoSnapshotDumpingStrategy_3.java b/bundles/org.eclipse.core.tools.resources/src/org/eclipse/core/tools/resources/metadata/SyncInfoSnapshotDumpingStrategy_3.java
index e6a5283..b274d39 100644
--- a/bundles/org.eclipse.core.tools.resources/src/org/eclipse/core/tools/resources/metadata/SyncInfoSnapshotDumpingStrategy_3.java
+++ b/bundles/org.eclipse.core.tools.resources/src/org/eclipse/core/tools/resources/metadata/SyncInfoSnapshotDumpingStrategy_3.java
@@ -20,7 +20,7 @@
 
 /**
  * A strategy for reading .syncinfo.snap files version 3. Layout:
- * <pre>
+ * <pre> {@code
  * SNAP_FILE -> [VERSION_ID RESOURCE]*
  * VERSION_ID -> int
  * RESOURCE -> RESOURCE_PATH SIZE SYNCINFO*
@@ -29,7 +29,7 @@
  * SYNCINFO -> QNAME BYTES
  * QNAME -> String String
  * BYTES -> byte[]
- * </pre>
+ * }</pre>
  */
 class SyncInfoSnapshotDumpingStrategy_3 implements IStringDumpingStrategy {
 	@Override
diff --git a/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/filesystem/URIUtilTest.java b/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/filesystem/URIUtilTest.java
index 8612ddb..7e19afd 100644
--- a/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/filesystem/URIUtilTest.java
+++ b/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/filesystem/URIUtilTest.java
@@ -99,7 +99,7 @@
 
 	/**
 	 * Test API methods {@link org.eclipse.core.filesystem.URIUtil#toURI(IPath)},
-	 * {@link org.eclipse.core.filesystem.URIUtil#toURI(String)))} results equality
+	 * {@link org.eclipse.core.filesystem.URIUtil#toURI(String)} results equality
 	 */
 	public void testToURIAbsolute() {
 		String pathString = null;
@@ -116,7 +116,7 @@
 
 	/**
 	 * Test API methods {@link org.eclipse.core.filesystem.URIUtil#toURI(IPath)},
-	 * {@link org.eclipse.core.filesystem.URIUtil#toURI(String)))} results equality
+	 * {@link org.eclipse.core.filesystem.URIUtil#toURI(String)} results equality
 	 */
 	public void testToURIRelative() {
 		String pathString = "test/path with/spaces to_file.txt";
@@ -129,7 +129,7 @@
 	}
 
 	/**
-	 * Test API methods {@link org.eclipse.core.filesystem.URIUtil#toURI(org.eclipse.core.runtime.IPath))}.
+	 * Test API methods {@link org.eclipse.core.filesystem.URIUtil#toURI(org.eclipse.core.runtime.IPath)}.
 	 * {@link org.eclipse.core.filesystem.URIUtil#toPath(URI)} transformation with relative and absolute paths
 	 */
 	public void testFromPathToURI() {
diff --git a/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/internal/builders/BuildContextTest.java b/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/internal/builders/BuildContextTest.java
index 31ef4e0..a916c22 100644
--- a/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/internal/builders/BuildContextTest.java
+++ b/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/internal/builders/BuildContextTest.java
@@ -104,7 +104,7 @@
 	}
 
 	/**
-	 * p0 --> p1 --> p2
+	 * p0 --&gt; p1 --&gt; p2
 	 * @throws CoreException
 	 */
 	private void setupSimpleReferences() throws CoreException {
diff --git a/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/internal/builders/ConfigurationBuilder.java b/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/internal/builders/ConfigurationBuilder.java
index 69bbc25..e23974b 100644
--- a/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/internal/builders/ConfigurationBuilder.java
+++ b/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/internal/builders/ConfigurationBuilder.java
@@ -25,7 +25,7 @@
 public class ConfigurationBuilder extends TestBuilder {
 	public static final String BUILDER_NAME = "org.eclipse.core.tests.resources.configbuilder";
 
-	/** Stores IBuildConfiguration -> ConfigurationBuilder */
+	/** Stores IBuildConfiguration -&gt; ConfigurationBuilder */
 	private static HashMap<IBuildConfiguration, ConfigurationBuilder> builders = new HashMap<>();
 	/** Order in which builders have been run */
 	static List<IBuildConfiguration> buildOrder = new ArrayList<>();
diff --git a/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/internal/builders/ContextBuilder.java b/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/internal/builders/ContextBuilder.java
index f5fee07..42cbe2e 100644
--- a/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/internal/builders/ContextBuilder.java
+++ b/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/internal/builders/ContextBuilder.java
@@ -26,7 +26,7 @@
 public class ContextBuilder extends TestBuilder {
 	public static final String BUILDER_NAME = "org.eclipse.core.tests.resources.contextbuilder";
 
-	/** Stores IBuildConfiguration -> ContextBuilder */
+	/** Stores IBuildConfiguration -&gt; ContextBuilder */
 	private static HashMap<IBuildConfiguration, ContextBuilder> builders = new HashMap<>();
 	/** The context information for the last run of this builder */
 	IBuildContext contextForLastBuild = null;
diff --git a/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/internal/builders/TestBuilder.java b/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/internal/builders/TestBuilder.java
index df5e597..e9df0bf 100644
--- a/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/internal/builders/TestBuilder.java
+++ b/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/internal/builders/TestBuilder.java
@@ -26,7 +26,7 @@
 public abstract class TestBuilder extends IncrementalProjectBuilder {
 
 	/**
-	 * A test specific call-back which can be ticked on #getRule(...) & #build(...)
+	 * A test specific call-back which can be ticked on #getRule(...) &amp; #build(...)
 	 */
 	public static class BuilderRuleCallback {
 		IncrementalProjectBuilder builder;
diff --git a/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/internal/dtree/DataTreeTest.java b/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/internal/dtree/DataTreeTest.java
index 15492ec..75da67a 100644
--- a/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/internal/dtree/DataTreeTest.java
+++ b/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/internal/dtree/DataTreeTest.java
@@ -255,8 +255,8 @@
 	 * Answer the key of the child with the given index of the
 	 * specified node.<p>
 	 *
-	 * @param: NodeKey, int
-	 * @return: NodeKey
+	 * @param NodeKey, int
+	 * @return NodeKey
 	 *
 	 * @exception ObjectNotFoundException
 	 * 	parentKey does not exist in the receiver
diff --git a/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/internal/dtree/DeltaDataTreeTest.java b/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/internal/dtree/DeltaDataTreeTest.java
index dcc8cac..879aefd 100644
--- a/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/internal/dtree/DeltaDataTreeTest.java
+++ b/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/internal/dtree/DeltaDataTreeTest.java
@@ -526,8 +526,8 @@
 	 * Answer the key of the child with the given index of the
 	 * specified node.<p>
 	 *
-	 * @param: NodeKey, int
-	 * @return: NodeKey
+	 * @param NodeKey, int
+	 * @return NodeKey
 	 *
 	 * @exception ObjectNotFoundException
 	 * 	parentKey does not exist in the receiver
diff --git a/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/internal/events/BuildProjectFromMultipleJobsTest.java b/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/internal/events/BuildProjectFromMultipleJobsTest.java
index 5faeae5..ad26521 100644
--- a/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/internal/events/BuildProjectFromMultipleJobsTest.java
+++ b/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/internal/events/BuildProjectFromMultipleJobsTest.java
@@ -30,7 +30,7 @@
  * Tests that triggering a project build from multiple jobs does not cause assertion failures,
  * e.g. due to adding builders to the {@link BuildCommand} in parallel.
  *
- * @see <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=517411">Eclipse bug 517411<a/>
+ * @see <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=517411">Eclipse bug 517411</a>
  */
 public class BuildProjectFromMultipleJobsTest extends ResourceTest {
 
@@ -82,7 +82,7 @@
 	 *
 	 * Repeats this several times, to ensure that no exceptions are thrown due to the build from parallel threads.
 	 *
-	 * @see <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=517411">Eclipse bug 517411<a/>
+	 * @see <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=517411">Eclipse bug 517411</a>
 	 */
 	public void test10IterationsWithBuildsFrom8Jobs() throws Exception {
 		IProgressMonitor monitor = new NullProgressMonitor();
diff --git a/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/internal/localstore/SymlinkResourceTest.java b/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/internal/localstore/SymlinkResourceTest.java
index 55655a5..3581885 100644
--- a/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/internal/localstore/SymlinkResourceTest.java
+++ b/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/internal/localstore/SymlinkResourceTest.java
@@ -73,11 +73,11 @@
 
 	/**
 	 * Test a very specific case of mutually recursive symbolic links:
-	 * <pre>
+	 * <pre> {@code
 	 *   a/link  -> ../b
 	 *   b/link1 -> ../a, b/link2 -> ../c
 	 *   c/link  -> ../b
-	 * </pre>
+	 * }</pre>
 	 * In the specific bug, the two links in b were followed in an alternated
 	 * fashion while walking down the tree. A correct implementation should
 	 * stop following symbolic links as soon as a node is reached that has
diff --git a/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/internal/resources/ProjectDynamicReferencesTest.java b/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/internal/resources/ProjectDynamicReferencesTest.java
index dfe915d..a4738e6 100644
--- a/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/internal/resources/ProjectDynamicReferencesTest.java
+++ b/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/internal/resources/ProjectDynamicReferencesTest.java
@@ -24,7 +24,7 @@
 
 /**
  * Test project dynamic references provided by extension point
- * <code>org.eclipse.core.resources.builders<code> and dynamicReference
+ * <code>org.eclipse.core.resources.builders</code> and dynamicReference
  * {@link IDynamicReferenceProvider}
  */
 public class ProjectDynamicReferencesTest extends ResourceTest {
@@ -124,12 +124,12 @@
 				project1.getReferencedBuildConfigs(IBuildConfiguration.DEFAULT_CONFIG_NAME, false));
 		assertEquals("Project2 must not have referenced projects", EMPTY_BUILD_CONFIGURATIONS,
 				project2.getReferencedBuildConfigs(IBuildConfiguration.DEFAULT_CONFIG_NAME, false));
-	
+
 		DynamicReferenceProvider.addReference(project0, project1);
 		DynamicReferenceProvider.addReference(project1, project2);
 		DynamicReferenceProvider.addReference(project0, project2);
 		clearCache();
-	
+
 		IBuildConfiguration buildConfigProject1 = project1.getBuildConfig(IBuildConfiguration.DEFAULT_CONFIG_NAME);
 		IBuildConfiguration buildConfigProject2 = project2.getBuildConfig(IBuildConfiguration.DEFAULT_CONFIG_NAME);
 		assertEquals("Build configuration of Project0 must reference build configuration of project1 and project2",
diff --git a/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/internal/watson/AllTests.java b/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/internal/watson/AllTests.java
index bc895b0..a05037a 100644
--- a/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/internal/watson/AllTests.java
+++ b/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/internal/watson/AllTests.java
@@ -18,7 +18,6 @@
 public class AllTests extends TestCase {
 	/**
 	 * AllTests constructor comment.
-	 * @param name java.lang.String
 	 */
 	public AllTests() {
 		super(null);
diff --git a/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/internal/watson/TestUtil.java b/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/internal/watson/TestUtil.java
index c2a0dbf..2ba1b0f 100644
--- a/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/internal/watson/TestUtil.java
+++ b/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/internal/watson/TestUtil.java
@@ -84,7 +84,7 @@
 	/**
 	 * Asserts that two trees are equal. If they are not
 	 * an AssertionFailedError is thrown.
-	 * @param message the detail message for this assertion
+	 * @param msg	 the detail message for this assertion
 	 * @param expected the expected value of a tree
 	 * @param actual the actual value of a tree
 	 * @param depth The depth to compare to.
diff --git a/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/resources/FilteredResourceTest.java b/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/resources/FilteredResourceTest.java
index cbe8c5e..6a8641f 100644
--- a/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/resources/FilteredResourceTest.java
+++ b/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/resources/FilteredResourceTest.java
@@ -661,8 +661,8 @@
 	 * Main tree:
 	 * existingProject/existingFolderInExsitingProject/existingFolderInExistingFolder
 	 * Links:
-	 * otherExistingProject/nonExistingFolderInOtherExistingProject => existingProject/existingFolderInExsitingProject  (filter * of type folder)
-	 * otherExistingProject/nonExistingFolder2InOtherExistingProject => existingProject/existingFolderInExsitingProject/existingFolderInExistingFolder
+	 * otherExistingProject/nonExistingFolderInOtherExistingProject =&gt; existingProject/existingFolderInExsitingProject  (filter * of type folder)
+	 * otherExistingProject/nonExistingFolder2InOtherExistingProject =&gt; existingProject/existingFolderInExsitingProject/existingFolderInExistingFolder
 	 * This is a regression test for Bug 268518.
 	 */
 	public void testCreateFilterOnLinkedFolderWithAlias() {
@@ -806,8 +806,8 @@
 	 * Main tree:
 	 * existingProject/existingFolderInExsitingProject/existingFolderInExistingFolder
 	 * Links:
-	 * otherExistingProject/nonExistingFolderInOtherExistingProject => existingProject/existingFolderInExsitingProject  (filter * of type folder)
-	 * otherExistingProject/nonExistingFolder2InOtherExistingProject => existingProject/existingFolderInExsitingProject/existingFolderInExistingFolder
+	 * otherExistingProject/nonExistingFolderInOtherExistingProject =&gt; existingProject/existingFolderInExsitingProject  (filter * of type folder)
+	 * otherExistingProject/nonExistingFolder2InOtherExistingProject =&gt; existingProject/existingFolderInExsitingProject/existingFolderInExistingFolder
 	 * This is a regression test for Bug 268518.
 	 */
 	public void testCreateFilterOnLinkedFolderWithAlias2() {
diff --git a/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/resources/HiddenResourceTest.java b/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/resources/HiddenResourceTest.java
index 616b9a9..ac9571e 100644
--- a/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/resources/HiddenResourceTest.java
+++ b/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/resources/HiddenResourceTest.java
@@ -746,7 +746,7 @@
 	/**
 	 * Tests whether {@link IFile#create(java.io.InputStream, int, IProgressMonitor)},
 	 * {@link IFolder#create(int, boolean, IProgressMonitor)}
-	 * and {@link IProject#create(IProjectDescription, int, IProgressMonitor)
+	 * and {@link IProject#create(IProjectDescription, int, IProgressMonitor)}
 	 * handles {@link IResource#HIDDEN} flag properly.
 	 */
 	public void testCreateHiddenResources() {
diff --git a/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/resources/LinkedResourceTest.java b/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/resources/LinkedResourceTest.java
index 8ab7429..91affd8 100644
--- a/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/resources/LinkedResourceTest.java
+++ b/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/resources/LinkedResourceTest.java
@@ -1993,7 +1993,7 @@
 	}
 
 	/**
-	 * Create a project with a linked resource at depth > 2, and refresh it.
+	 * Create a project with a linked resource at depth &gt; 2, and refresh it.
 	 */
 	public void testRefreshDeepLink() {
 		IFolder link = nonExistingFolderInExistingFolder;
diff --git a/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/resources/OldCorePerformanceTest.java b/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/resources/OldCorePerformanceTest.java
index 35301f7..525fab2 100644
--- a/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/resources/OldCorePerformanceTest.java
+++ b/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/resources/OldCorePerformanceTest.java
@@ -32,15 +32,15 @@
  * For benchmarking operations that should be instantaneous, use the
  * startBench(), stopBench() methods.  Here is an example:
  *
- *	<code>
+ *	<pre><code>
  * 	String benchName = "myOperation";
  * 	int repeat = 500;
  *	startBench();
- *	for (int i = 0; i < repeat; i++) {
+ *	for (int i = 0; i &lt; repeat; i++) {
  *		//run the operation to be tested here
  *	}
  *	stopBench(benchName, repeat);
- *	</code>
+ *	</code></pre>
  * Note that only one operation can be tested at a time with this mechanism.
  *
  * If an instance of this class is run using a LoggingPerformanceTestResult,
diff --git a/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/resources/ProjectSnapshotPerfManualTest.java b/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/resources/ProjectSnapshotPerfManualTest.java
index 8bc9baa..156b3ad 100644
--- a/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/resources/ProjectSnapshotPerfManualTest.java
+++ b/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/resources/ProjectSnapshotPerfManualTest.java
@@ -29,7 +29,7 @@
  * This test is meant to be run manually, and not integrated into the
  * automated test suite. Requires large project data (thousands of folders)
  * to be available on a slow file system (bigSiteLocation). Modify
- * bigSiteLocation to suit your needs, then run-as > JUnit Plug-in Test.
+ * bigSiteLocation to suit your needs, then run-as &gt; JUnit Plug-in Test.
  */
 public class ProjectSnapshotPerfManualTest extends ResourceTest {
 	/** big site default volume (windows) */
diff --git a/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/resources/ResourceDeltaVerifier.java b/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/resources/ResourceDeltaVerifier.java
index 96a5793..492a99e 100644
--- a/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/resources/ResourceDeltaVerifier.java
+++ b/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/resources/ResourceDeltaVerifier.java
@@ -95,7 +95,7 @@
 	}
 
 	/**
-	 * Table of IPath -> ExpectedChange
+	 * Table of IPath -&gt; ExpectedChange
 	 */
 	private Hashtable<IPath, ExpectedChange> fExpectedChanges = new Hashtable<>();
 	boolean fIsDeltaValid = true;
diff --git a/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/resources/ResourceTest.java b/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/resources/ResourceTest.java
index 991c1ea..68198db 100644
--- a/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/resources/ResourceTest.java
+++ b/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/resources/ResourceTest.java
@@ -233,7 +233,7 @@
 	/**
 	 * Assert whether or not the given resource exists in the local
 	 * store. Use the resource manager to ensure that we have a
-	 * correct Path -> File mapping.
+	 * correct Path -&gt; File mapping.
 	 */
 	public void assertExistsInFileSystem(IResource resource) {
 		assertExistsInFileSystem("", resource); //$NON-NLS-1$
@@ -249,7 +249,7 @@
 	/**
 	 * Assert whether or not the given resource exists in the local
 	 * store. Use the resource manager to ensure that we have a
-	 * correct Path -> File mapping.
+	 * correct Path -&gt; File mapping.
 	 */
 	public void assertExistsInFileSystem(String message, IResource resource) {
 		if (!existsInFileSystem(resource)) {
@@ -519,7 +519,7 @@
 
 	/**
 	 * Delete the given resource from the local store. Use the resource
-	 * manager to ensure that we have a correct Path -> File mapping.
+	 * manager to ensure that we have a correct Path -&gt; File mapping.
 	 */
 	public void ensureDoesNotExistInFileSystem(IResource resource) {
 		IPath path = resource.getLocation();
@@ -569,7 +569,7 @@
 
 	/**
 	 * Create the given file in the local store. Use the resource manager
-	 * to ensure that we have a correct Path -> File mapping.
+	 * to ensure that we have a correct Path -&gt; File mapping.
 	 */
 	public void ensureExistsInFileSystem(IFile file) {
 		createFileInFileSystem(((Resource) file).getStore());
@@ -577,7 +577,7 @@
 
 	/**
 	 * Create the given folder in the local store. Use the resource
-	 * manager to ensure that we have a correct Path -> File mapping.
+	 * manager to ensure that we have a correct Path -&gt; File mapping.
 	 */
 	public void ensureExistsInFileSystem(IResource resource) {
 		if (resource instanceof IFile) {
diff --git a/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/resources/regression/AllTests.java b/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/resources/regression/AllTests.java
index 1dad556..c20fa9b 100644
--- a/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/resources/regression/AllTests.java
+++ b/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/resources/regression/AllTests.java
@@ -22,7 +22,6 @@
 public class AllTests extends TestCase {
 	/**
 	 * AllTests constructor comment.
-	 * @param name java.lang.String
 	 */
 	public AllTests() {
 		super(null);
diff --git a/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/resources/regression/Bug_185247_recursiveLinks.java b/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/resources/regression/Bug_185247_recursiveLinks.java
index b7444aa..b9c6bda 100644
--- a/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/resources/regression/Bug_185247_recursiveLinks.java
+++ b/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/resources/regression/Bug_185247_recursiveLinks.java
@@ -60,7 +60,7 @@
 	 *   |
 	 *   |-- directory
 	 *         |
-	 *         |-- link_current -> ./ (links "directory")
+	 *         |-- link_current -&gt; ./ (links "directory")
 	 * </pre>
 	 */
 	public void test1_linkCurrentDirectory() throws Exception {
@@ -79,7 +79,7 @@
 	 *   |
 	 *   |-- directory
 	 *         |
-	 *         |-- link_parent -> ../ (links "project root")
+	 *         |-- link_parent -&gt; ../ (links "project root")
 	 * </pre>
 	 */
 	public void test2_linkParentDirectory() throws Exception {
@@ -100,7 +100,7 @@
 	 *         |
 	 *         |-- subdirectory
 	 *              |
-	 *              |-- link_grandparent -> ../../ (links "project root")
+	 *              |-- link_grandparent -&gt; ../../ (links "project root")
 	 * </pre>
 	 */
 	public void test3_linkGrandparentDirectory() throws Exception {
@@ -123,11 +123,11 @@
 	 *         |
 	 *         |-- subdirectory1
 	 *         |    |
-	 *         |    |-- link_parent -> ../ (links directory)
+	 *         |    |-- link_parent -&gt; ../ (links directory)
 	 *         |
 	 *         |-- subdirectory2
 	 *              |
-	 *              |-- link_parent -> ../ (links directory)
+	 *              |-- link_parent -&gt; ../ (links directory)
 	 * </pre>
 	 */
 	public void test4_linkParentDirectoryTwice() throws Exception {
@@ -153,11 +153,11 @@
 	 *         |
 	 *         |-- subdirectory1
 	 *         |    |
-	 *         |    |-- link_parent -> /tmp/<random string>/bug185247recursive/test5_linkParentDirectoyTwiceWithAbsolutePath/directory
+	 *         |    |-- link_parent -&gt; /tmp/&lt;random string&gt;/bug185247recursive/test5_linkParentDirectoyTwiceWithAbsolutePath/directory
 	 *         |
 	 *         |-- subdirectory2
 	 *              |
-	 *              |-- link_parent -> /tmp/<random string>/bug185247recursive/test5_linkParentDirectoyTwiceWithAbsolutePath/directory
+	 *              |-- link_parent -&gt; /tmp/&lt;random string&gt;/bug185247recursive/test5_linkParentDirectoyTwiceWithAbsolutePath/directory
 	 * </pre>
 	 */
 	public void test5_linkParentDirectoyTwiceWithAbsolutePath() throws Exception {
diff --git a/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/resources/usecase/IFileTest.java b/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/resources/usecase/IFileTest.java
index a38a33b..f4e55c4 100644
--- a/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/resources/usecase/IFileTest.java
+++ b/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/resources/usecase/IFileTest.java
@@ -70,8 +70,8 @@
 
 	/**
 	 * Create a folder in an open project.
-	 * Contruct a file handle "in" the folder & check its initial state.
-	 * Create the file & check its state further.
+	 * Contruct a file handle "in" the folder &amp; check its initial state.
+	 * Create the file &amp; check its state further.
 	 * Delete the file.
 	 *
 	 * TBD:
diff --git a/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/resources/usecase/IFolderTest.java b/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/resources/usecase/IFolderTest.java
index f69bed0..190e76f 100644
--- a/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/resources/usecase/IFolderTest.java
+++ b/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/resources/usecase/IFolderTest.java
@@ -61,12 +61,12 @@
 
 	/**
 	 * Create a project in an open solution. Don't open the project.
-	 * Contruct a folder handle & check its initial state.
+	 * Contruct a folder handle &amp; check its initial state.
 	 * Try creating the folder in the unopened project.
 	 * Open the project.
-	 * Create the folder & check its state further.
-	 * Construct a nested folder handle & check its initial state.
-	 * Create the nested folder & check its further.
+	 * Create the folder &amp; check its state further.
+	 * Construct a nested folder handle &amp; check its initial state.
+	 * Create the nested folder &amp; check its further.
 	 * Delete the nested folder.
 	 * Delete the parent folder.
 	 * Close the workspace.
diff --git a/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/resources/usecase/IProjectTest.java b/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/resources/usecase/IProjectTest.java
index 65bb82b..cceddd4 100644
--- a/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/resources/usecase/IProjectTest.java
+++ b/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/resources/usecase/IProjectTest.java
@@ -100,11 +100,11 @@
 
 	/**
 	 * Create a solution in an open workspace. Don't open the solution.
-	 * Construct a project handle & check its initial state.
+	 * Construct a project handle &amp; check its initial state.
 	 * Try creating the project in the unopened solution.
-	 * Set/get comment & owner after creating the project but before opening. Is this proper?
+	 * Set/get comment &amp; owner after creating the project but before opening. Is this proper?
 	 * Open the solution.
-	 * Create the project & check its state further.
+	 * Create the project &amp; check its state further.
 	 * Delete the project.
 	 * Close the workspace.
 	 *
diff --git a/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/resources/usecase/SignaledBuilder.java b/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/resources/usecase/SignaledBuilder.java
index 0242d5b..e7e5671 100644
--- a/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/resources/usecase/SignaledBuilder.java
+++ b/tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/resources/usecase/SignaledBuilder.java
@@ -26,7 +26,7 @@
 	public static final String BUILDER_ID = "org.eclipse.core.tests.resources.sigbuilder";
 
 	/**
-	 * associate IProject->SignaledBuilder
+	 * associate IProject-&gt;SignaledBuilder
 	 */
 	private static HashMap<IProject, SignaledBuilder> instances = new HashMap<>(10);
 	protected boolean wasExecuted;
