Bug 501240 - Do not hide image with <none>:<none> as a result of a build

Extracted the way qualifier is computed, based on images
Set the 'dangling images' filter activation state to 'false' by default
 to get the same result as the CLI
Added tests to verify the qualifier computation

Also:
- renamed custom Assertions with plural form (as AssrtJ does)
- fixed failing tests because mocking the IDockerConnection#getState()
method returns unexpected values in some cases.

Change-Id: I21c4eb03523dd88e18ca23b8a3f30d18f0497efa
Signed-off-by: Xavier Coulon <xcoulon@redhat.com>
Reviewed-on: https://git.eclipse.org/r/81913
Tested-by: Hudson CI
Reviewed-by: Jeff Johnston <jjohnstn@redhat.com>

37 files changed, 608 insertions, 333 deletions

diff --git a/containers/org.eclipse.linuxtools.docker.core/src/org/eclipse/linuxtools/docker/core/Messages.java b/containers/org.eclipse.linuxtools.docker.core/src/org/eclipse/linuxtools/docker/core/Messages.java
index 75cc1d6b32..e458846be9 100644
--- a/containers/org.eclipse.linuxtools.docker.core/src/org/eclipse/linuxtools/docker/core/Messages.java
+++ b/containers/org.eclipse.linuxtools.docker.core/src/org/eclipse/linuxtools/docker/core/Messages.java
@@ -32,6 +32,7 @@ public class Messages extends NLS {
 	public static String Docker_Daemon_Ping_Failure;
 	public static String Retrieve_Docker_Certificates_Failure;
 	public static String List_Docker_Containers_Failure;
+	public static String List_Docker_Images_Failure;
 	public static String Docker_General_Info_Failure;
 	public static String Docker_No_Settings_Description_Script;
 	public static String Registry_Version_Mismatch;
diff --git a/containers/org.eclipse.linuxtools.docker.core/src/org/eclipse/linuxtools/docker/core/Messages.properties b/containers/org.eclipse.linuxtools.docker.core/src/org/eclipse/linuxtools/docker/core/Messages.properties
index b71ebec43b..27b5854825 100644
--- a/containers/org.eclipse.linuxtools.docker.core/src/org/eclipse/linuxtools/docker/core/Messages.properties
+++ b/containers/org.eclipse.linuxtools.docker.core/src/org/eclipse/linuxtools/docker/core/Messages.properties
@@ -26,6 +26,7 @@ Open_Connection_Failure=Failed to open connection ''{0}'' on {1}
 Docker_Daemon_Ping_Failure=Failed to ping the Docker daemon for connection ''{0}''
 Retrieve_Docker_Certificates_Failure=Unable to retrieve certificates to connect to the Docker daemon
 List_Docker_Containers_Failure=Failed to load list of Docker containers from {0}
+List_Docker_Images_Failure=Failed to load list of Docker images from {0}
 Docker_General_Info_Failure=Failed to get Docker connection info
 Docker_No_Settings_Description_Script=There is no settings detection script for this operating system.
 Registry_Version_Mismatch=Target Docker registry located at {0} does not support API v1
diff --git a/containers/org.eclipse.linuxtools.docker.core/src/org/eclipse/linuxtools/internal/docker/core/DockerConnection.java b/containers/org.eclipse.linuxtools.docker.core/src/org/eclipse/linuxtools/internal/docker/core/DockerConnection.java
index 9988c4d98a..4eacc3a5eb 100644
--- a/containers/org.eclipse.linuxtools.docker.core/src/org/eclipse/linuxtools/internal/docker/core/DockerConnection.java
+++ b/containers/org.eclipse.linuxtools.docker.core/src/org/eclipse/linuxtools/internal/docker/core/DockerConnection.java
@@ -81,6 +81,7 @@ import org.eclipse.linuxtools.docker.core.IDockerVersion;
 import org.eclipse.linuxtools.docker.core.ILogger;
 import org.eclipse.linuxtools.docker.core.IRegistryAccount;
 import org.eclipse.linuxtools.docker.core.Messages;
+import org.eclipse.linuxtools.internal.docker.core.DockerImage.DockerImageQualifier;
 import org.eclipse.osgi.util.NLS;
 import org.eclipse.tm.terminal.view.core.TerminalServiceFactory;
 import org.eclipse.tm.terminal.view.core.interfaces.ITerminalService;
@@ -655,90 +656,95 @@ public class DockerConnection
 		}
 	}
 
-	private List<IDockerContainer> listContainers() throws DockerException {
-		final Map<String, IDockerContainer> updatedContainers = new HashMap<>();
-		try {
-			final List<Container> nativeContainers = new ArrayList<>();
-			synchronized (clientLock) {
-				// Check that client is not null as this connection may have
-				// been closed but there is an async request to update the
-				// containers list left in the queue
-				if (client == null) {
-					// in that case the list becomes empty, which is fine is
-					// there's no client.
-					return Collections.emptyList();
+	private List<IDockerContainer> listContainers()
+			throws DockerException {
+		final Map<String, IDockerContainer> updatedContainersById = new HashMap<>();
+		List<IDockerContainer> sortedContainers;
+		synchronized (containerLock) {
+			try {
+				final List<Container> nativeContainers = new ArrayList<>();
+				synchronized (clientLock) {
+					// Check that client is not null as this connection may have
+					// been closed but there is an async request to update the
+					// containers list left in the queue
+					if (client == null) {
+						// in that case the list becomes empty, which is fine is
+						// there's no client.
+						return Collections.emptyList();
+					}
+					nativeContainers.addAll(client.listContainers(
+							DockerClient.ListContainersParam.allContainers()));
 				}
-				nativeContainers.addAll(client.listContainers(
-						DockerClient.ListContainersParam.allContainers()));
-			}
-			// We have a list of containers. Now, we translate them to our own
-			// core format in case we decide to change the underlying engine
-			// in the future.
-			for (Container nativeContainer : nativeContainers) {
-				// For containers that have exited, make sure we aren't tracking
-				// them with a logging thread.
-				if (nativeContainer.status() != null && nativeContainer.status()
-						.startsWith(Messages.Exited_specifier)) {
-					synchronized (loggingThreads) {
-						if (loggingThreads.containsKey(nativeContainer.id())) {
-							loggingThreads.get(nativeContainer.id())
-									.requestStop();
-							loggingThreads.remove(nativeContainer.id());
+				// We have a list of containers. Now, we translate them to our
+				// own
+				// core format in case we decide to change the underlying engine
+				// in the future.
+				for (Container nativeContainer : nativeContainers) {
+					// For containers that have exited, make sure we aren't
+					// tracking
+					// them with a logging thread.
+					if (nativeContainer.status() != null && nativeContainer
+							.status().startsWith(Messages.Exited_specifier)) {
+						synchronized (loggingThreads) {
+							if (loggingThreads
+									.containsKey(nativeContainer.id())) {
+								loggingThreads.get(nativeContainer.id())
+										.requestStop();
+								loggingThreads.remove(nativeContainer.id());
+							}
 						}
 					}
+					// skip containers that are being removed
+					if (nativeContainer.status() != null
+							&& nativeContainer.status().equals(
+									Messages.Removal_In_Progress_specifier)) {
+						continue;
+					}
+					// re-use info from existing container with same id
+					if (this.containers != null && this.containersById
+							.containsKey(nativeContainer.id())) {
+						final IDockerContainer container = this.containersById
+								.get(nativeContainer.id());
+						updatedContainersById.put(nativeContainer.id(),
+								new DockerContainer(this, nativeContainer,
+										container.info()));
+					} else {
+						updatedContainersById.put(nativeContainer.id(),
+								new DockerContainer(this, nativeContainer));
+					}
 				}
-				// skip containers that are being removed
-				if (nativeContainer.status() != null && nativeContainer.status()
-						.equals(Messages.Removal_In_Progress_specifier)) {
-					continue;
+			} catch (DockerTimeoutException e) {
+				if (isOpen()) {
+					Activator.log(
+							new Status(IStatus.WARNING, Activator.PLUGIN_ID,
+									Messages.Docker_Connection_Timeout, e));
+					close();
 				}
-				// re-use info from existing container with same id
-				if (this.containers != null && this.containersById
-						.containsKey(nativeContainer.id())) {
-					final IDockerContainer container = this.containersById
-							.get(nativeContainer.id());
-					updatedContainers.put(nativeContainer.id(),
-							new DockerContainer(this, nativeContainer,
-									container.info()));
+			} catch (com.spotify.docker.client.DockerException
+					| InterruptedException e) {
+				if (isOpen() && e.getCause() != null
+						&& e.getCause().getCause() != null && e.getCause()
+								.getCause() instanceof ProcessingException) {
+					close();
 				} else {
-					updatedContainers.put(nativeContainer.id(),
-							new DockerContainer(this, nativeContainer));
+					throw new DockerException(e.getMessage());
 				}
-			}
-		} catch (DockerTimeoutException e) {
-			if (isOpen()) {
-				Activator.log(new Status(IStatus.WARNING, Activator.PLUGIN_ID,
-						Messages.Docker_Connection_Timeout, e));
-				close();
-			}
-		} catch (com.spotify.docker.client.DockerException
-				| InterruptedException e) {
-			if (isOpen() && e.getCause() != null
-					&& e.getCause().getCause() != null
-					&& e.getCause().getCause() instanceof ProcessingException) {
-				close();
-			} else {
-				throw new DockerException(e.getMessage());
-			}
-		} finally {
-			// assign the new list of containers in a locked block of code to
-			// prevent concurrent access, even if an exception was raised.
-			synchronized (containerLock) {
-				this.containersById = updatedContainers;
-				this.containers = sort(this.containersById.values(),
+			} finally {
+				this.containersById = updatedContainersById;
+				sortedContainers = sort(
+						updatedContainersById.values(),
 						(container, otherContainer) -> container.name()
 								.compareTo(otherContainer.name()));
-
+				this.containers = sortedContainers;
 				this.containersLoaded = true;
 			}
 		}
-
 		// perform notification outside of containerLock so we don't have a View
 		// causing a deadlock
 		// TODO: we should probably notify the listeners only if the containers
 		// list changed.
-		notifyContainerListeners(this.containers);
-		return this.containers;
+		notifyContainerListeners(sortedContainers);
+		return sortedContainers;
 	}
 
 	public Set<String> getContainerIdsWithLabels(Map<String, String> labels)
@@ -968,22 +974,51 @@ public class DockerConnection
 		return imagesLoaded;
 	}
 
+	// TODO: remove this method from the API
 	@Override
 	public List<IDockerImage> listImages() throws DockerException {
 		final List<IDockerImage> tempImages = new ArrayList<>();
 		synchronized (imageLock) {
-			List<Image> rawImages = new ArrayList<>();
 			try {
+				final List<Image> nativeImages = new ArrayList<>();
 				synchronized (clientLock) {
 					// Check that client is not null as this connection may have
 					// been closed but there is an async request to update the
-					// images list left in the queue
-					if (client == null)
-						return tempImages;
-					rawImages = client.listImages(
-							DockerClient.ListImagesParam.allImages());
+					// containers list left in the queue
+					if (client == null) {
+						// in that case the list becomes empty, which is fine is
+						// there's no client.
+						return Collections.emptyList();
+					}
+					nativeImages.addAll(client.listImages(
+							DockerClient.ListImagesParam.allImages()));
 				}
-			} catch (DockerTimeoutException e) {
+				// We have a list of images. Now, we translate them to our own
+				// core format in case we decide to change the underlying engine
+				// in the future. We also look for intermediate and dangling
+				// images.
+				for (Image nativeImage : nativeImages) {
+					final DockerImageQualifier imageQualifier = resolveQualifier(
+							nativeImage, nativeImages);
+					// return one IDockerImage per raw image
+					final List<String> repoTags = (nativeImage
+							.repoTags() != null)
+									? new ArrayList<>(nativeImage.repoTags())
+									: new ArrayList<>();
+					Collections.sort(repoTags);
+					if (repoTags.isEmpty()) {
+						repoTags.add("<none>:<none>"); //$NON-NLS-1$
+					}
+					final String repo = DockerImage
+							.extractRepo(repoTags.get(0));
+					final List<String> tags = Arrays
+							.asList(DockerImage.extractTag(repoTags.get(0)));
+					tempImages.add(new DockerImage(this, repoTags, repo, tags,
+							nativeImage.id(), nativeImage.parentId(),
+							nativeImage.created(), nativeImage.size(),
+							nativeImage.virtualSize(), imageQualifier));
+				}
+			} catch (com.spotify.docker.client.DockerTimeoutException e) {
 				if (isOpen()) {
 					Activator.log(
 							new Status(IStatus.WARNING, Activator.PLUGIN_ID,
@@ -995,45 +1030,19 @@ public class DockerConnection
 			} catch (com.spotify.docker.client.DockerException
 					| InterruptedException e) {
 				if (isOpen() && e.getCause() != null
-						&& e.getCause().getCause() != null
-						&& e.getCause().getCause() instanceof ProcessingException) {
+						&& e.getCause().getCause() != null && e.getCause()
+								.getCause() instanceof ProcessingException) {
 					close();
 				} else {
-					throw new DockerException(e.getMessage());
+					throw new DockerException(
+							NLS.bind(Messages.List_Docker_Images_Failure,
+									this.getName()),
+							e);
 				}
+			} finally {
+				this.images = tempImages;
+				this.imagesLoaded = true;
 			}
-			// We have a list of images. Now, we translate them to our own
-			// core format in case we decide to change the underlying engine
-			// in the future. We also look for intermediate and dangling images.
-			final Set<String> imageParentIds = new HashSet<>();
-			for (Image rawImage : rawImages) {
-				imageParentIds.add(rawImage.parentId());
-			}
-			for (Image rawImage : rawImages) {
-				// return one IDockerImage per raw image
-				final List<String> repoTags = rawImage.repoTags() != null
-						&& rawImage.repoTags().size() > 0
-						? new ArrayList<>(rawImage.repoTags())
-						: Arrays.asList("<none>:<none>"); //$NON-NLS-1$
-				Collections.sort(repoTags);
-				final boolean taggedImage = !(repoTags != null
-						&& repoTags.size() == 1
-						&& repoTags.contains("<none>:<none>")); //$NON-NLS-1$
-				final boolean intermediateImage = !taggedImage
-						&& imageParentIds.contains(rawImage.id());
-				final boolean danglingImage = !taggedImage
-						&& !intermediateImage;
-				final String firstRepo = DockerImage.extractRepo(repoTags.get(0));
-				final String firstTag = DockerImage.extractTag(repoTags.get(0));
-				final List<String> tags = (firstTag != null)
-						? Arrays.asList(firstTag) : Collections.emptyList();
-				tempImages.add(new DockerImage(this, repoTags, firstRepo,
-						tags, rawImage.id(), rawImage.parentId(),
-						rawImage.created(), rawImage.size(),
-						rawImage.virtualSize(), intermediateImage,
-						danglingImage));
-			}
-			images = tempImages;
 		}
 		// Perform notification outside of lock so that listener doesn't cause a
 		// deadlock to occur
@@ -1041,6 +1050,34 @@ public class DockerConnection
 		return tempImages;
 	}
 
+	/**
+	 * Resolves the {@link DockerImageQualifier} for the given
+	 * {@code nativeImage} in the context of all {@code nativeImages}
+	 * 
+	 * @param nativeImage
+	 *            the image to analyze
+	 * @param nativeImages
+	 *            all known images
+	 * @return the corresponding {@link DockerImageQualifier}
+	 */
+	private static DockerImageQualifier resolveQualifier(
+			final Image nativeImage, final List<Image> nativeImages) {
+		final boolean hasTag = !(nativeImage.repoTags() == null
+				|| (nativeImage.repoTags().size() == 1
+						&& nativeImage.repoTags().contains("<none>:<none>"))); //$NON-NLS-1$
+		final boolean hasChildImage = nativeImages.stream()
+				.anyMatch(i -> nativeImage.id().equals(i.parentId()));
+		// imtermediate image
+		if (!hasTag && hasChildImage) {
+			return DockerImageQualifier.INTERMEDIATE;
+		}
+		// dangling image
+		if (!hasTag && !hasChildImage) {
+			return DockerImageQualifier.DANGLING;
+		}
+		return DockerImageQualifier.TOP_LEVEL;
+	}
+
 	@Override
 	public boolean hasImage(final String repository, final String tag) {
 		for (IDockerImage image : getImages()) {
diff --git a/containers/org.eclipse.linuxtools.docker.core/src/org/eclipse/linuxtools/internal/docker/core/DockerImage.java b/containers/org.eclipse.linuxtools.docker.core/src/org/eclipse/linuxtools/internal/docker/core/DockerImage.java
index 8d593c57cd..7796c2b028 100644
--- a/containers/org.eclipse.linuxtools.docker.core/src/org/eclipse/linuxtools/internal/docker/core/DockerImage.java
+++ b/containers/org.eclipse.linuxtools.docker.core/src/org/eclipse/linuxtools/internal/docker/core/DockerImage.java
@@ -27,6 +27,10 @@ import org.eclipse.linuxtools.docker.core.IDockerImage;
 
 public class DockerImage implements IDockerImage, IAdaptable {
 
+	public enum DockerImageQualifier {
+		TOP_LEVEL, INTERMEDIATE, DANGLING;
+	}
+
 	/** The 'latest' tag. */
 	public static final String LATEST_TAG = "latest"; //$NON-NLS-1$
 
@@ -63,14 +67,13 @@ public class DockerImage implements IDockerImage, IAdaptable {
 	private final Long size;
 	private final Long virtualSize;
 
-	private final boolean intermediateImage;
-	private final boolean danglingImage;
+	private final DockerImageQualifier imageQualifier;
 
 	public DockerImage(final DockerConnection parent,
 			@Deprecated final List<String> repoTags, final String repo,
 			final List<String> tags, final String id, final String parentId,
 			final String created, final Long size, final Long virtualSize,
-			final boolean intermediateImage, final boolean danglingImage) {
+			final DockerImageQualifier imageQualifier) {
 		this.parent = parent;
 		this.repoTags = repoTags;
 		this.repo = repo;
@@ -86,8 +89,33 @@ public class DockerImage implements IDockerImage, IAdaptable {
 				: null;
 		this.size = size;
 		this.virtualSize = virtualSize;
-		this.intermediateImage = intermediateImage;
-		this.danglingImage = danglingImage;
+		this.imageQualifier = imageQualifier;
+	}
+
+	@Deprecated
+	public DockerImage(final DockerConnection parent,
+			@Deprecated final List<String> repoTags, final String repo,
+			final List<String> tags, final String id, final String parentId,
+			final String created, final Long size, final Long virtualSize,
+			final boolean intermediateImage, final boolean danglingImage) {
+		this.parent = parent;
+		this.repoTags = repoTags;
+		this.repo = repo;
+		this.tags = tags;
+		this.id = id;
+		this.shortId = getShortId(id);
+		this.parentId = parentId;
+		this.created = created;
+		this.createdDate = created != null
+				? formatter.get().format(
+						new Date(Long.valueOf(created).longValue() * 1000))
+				: null;
+		this.size = size;
+		this.virtualSize = virtualSize;
+		this.imageQualifier = intermediateImage
+				? DockerImageQualifier.INTERMEDIATE
+				: (danglingImage ? DockerImageQualifier.DANGLING
+						: DockerImageQualifier.TOP_LEVEL);
 	}
 
 	/**
@@ -219,6 +247,12 @@ public class DockerImage implements IDockerImage, IAdaptable {
 						image.isIntermediateImage(), image.isDangling()));
 	}
 
+	// TODO: expose this in the public API (in favor of
+	// IDockerImage#isIntermediate() and IDockerImage#isDangling() ?)
+	public DockerImageQualifier qualifier() {
+		return this.imageQualifier;
+	}
+
 	@Override
 	public DockerConnection getConnection() {
 		return parent;
@@ -280,12 +314,12 @@ public class DockerImage implements IDockerImage, IAdaptable {
 
 	@Override
 	public boolean isDangling() {
-		return danglingImage;
+		return this.imageQualifier == DockerImageQualifier.DANGLING;
 	}
 
 	@Override
 	public boolean isIntermediateImage() {
-		return intermediateImage;
+		return this.imageQualifier == DockerImageQualifier.INTERMEDIATE;
 	}
 
 	@Override
diff --git a/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/core/DockerConnectionTest.java b/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/core/DockerConnectionTest.java
index dd053f5683..3a97267d4e 100644
--- a/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/core/DockerConnectionTest.java
+++ b/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/core/DockerConnectionTest.java
@@ -74,6 +74,7 @@ public class DockerConnectionTest {
 		final DockerClient client = MockDockerClientFactory.image(fooImage).build();
 		final DockerConnection dockerConnection = MockDockerConnectionFactory.from("Test", client)
 				.withDefaultTCPConnectionSettings();
+		// when
 		dockerConnection.open(false);
 		// then
 		assertTrue(dockerConnection.hasImage("foo", null));
@@ -99,4 +100,5 @@ public class DockerConnectionTest {
 		// then connection state should be 'CLOSED' since the settings are wrong
 		assertThat(dockerConnection.getState()).isEqualTo(EnumDockerConnectionState.CLOSED);
 	}
+
 }
diff --git a/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/core/DockerImageQualifierTestCase.java b/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/core/DockerImageQualifierTestCase.java
new file mode 100644
index 0000000000..e3c80bad81
--- /dev/null
+++ b/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/core/DockerImageQualifierTestCase.java
@@ -0,0 +1,108 @@
+/*******************************************************************************
+ * Copyright (c) 2016 Red Hat.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     Red Hat - Initial Contribution
+ *******************************************************************************/
+
+package org.eclipse.linuxtools.internal.docker.core;
+
+import static org.eclipse.linuxtools.internal.docker.core.DockerImage.DockerImageQualifier.DANGLING;
+import static org.eclipse.linuxtools.internal.docker.core.DockerImage.DockerImageQualifier.INTERMEDIATE;
+import static org.eclipse.linuxtools.internal.docker.core.DockerImage.DockerImageQualifier.TOP_LEVEL;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+
+import org.eclipse.linuxtools.docker.core.DockerException;
+import org.eclipse.linuxtools.internal.docker.core.DockerImage.DockerImageQualifier;
+import org.eclipse.linuxtools.internal.docker.ui.testutils.DockerImageAssertions;
+import org.eclipse.linuxtools.internal.docker.ui.testutils.MockDockerClientFactory;
+import org.eclipse.linuxtools.internal.docker.ui.testutils.MockDockerConnectionFactory;
+import org.eclipse.linuxtools.internal.docker.ui.testutils.MockImageFactory;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameter;
+import org.junit.runners.Parameterized.Parameters;
+
+import com.spotify.docker.client.DockerClient;
+import com.spotify.docker.client.messages.Image;
+
+/**
+ * Verifying that images are properly qualified as {@code Top-Level},
+ * {@code Intermediate} or {@code Dangling}.
+ */
+@RunWith(Parameterized.class)
+public class DockerImageQualifierTestCase {
+
+	/**
+	 * A helper class to prepare dataset for test classes running with the
+	 * {@link Parameterized} JUnit runner.
+	 *
+	 */
+	static class ParameterizedDataset {
+
+		private final List<Object[]> data = new ArrayList<>();
+
+		/**
+		 * Adds a pair of elements to the dataset
+		 *
+		 * @return this {@link ParameterizedDataset} for fluent method chaining
+		 */
+		public ParameterizedDataset add(final DockerImageQualifier qualifier, final Image... images) {
+			this.data.add(new Object[] { qualifier, images });
+			return this;
+		}
+
+		/**
+		 * @return the {@link List} of data in the dataset
+		 */
+		public List<Object[]> toList() {
+			return this.data;
+		}
+	}
+
+	@Parameters
+	public static Collection<Object[]> getData() {
+		final ParameterizedDataset dataset = new ParameterizedDataset();
+		// top level because it has a repo and a tag
+		dataset.add(TOP_LEVEL, MockImageFactory.id("foo").name("foo:latest").build());
+		dataset.add(TOP_LEVEL, MockImageFactory.id("foo").name("foo:latest", "foo:1.0").build());
+		// top level because it has a name
+		dataset.add(TOP_LEVEL, MockImageFactory.id("foo").name("foo:<none>").build());
+		// intermediate because it has a child image
+		dataset.add(INTERMEDIATE, MockImageFactory.id("foo").name("<none>:<none>").build(),
+				MockImageFactory.id("bar").parentId("foo").name("bar:latest").build());
+		dataset.add(INTERMEDIATE, MockImageFactory.id("foo").build(),
+				MockImageFactory.id("bar").parentId("foo").name("bar:latest").build());
+		// dangling because untagged because it is a leaf
+		dataset.add(DANGLING, MockImageFactory.id("foo").name("<none>:<none>").build());
+		dataset.add(DANGLING, MockImageFactory.id("foo").build());
+		return dataset.toList();
+	}
+
+	@Parameter(0)
+	public DockerImageQualifier qualifier;
+
+	@Parameter(1)
+	public Image[] images;
+
+	@Test
+	public void verifyImageQualifier() throws DockerException {
+		// given
+		final DockerClient client = MockDockerClientFactory.images(images).build();
+		final DockerConnection dockerConnection = MockDockerConnectionFactory.from("Test", client)
+				.withDefaultTCPConnectionSettings();
+		// when
+		dockerConnection.open(false);
+		// then
+		DockerImageAssertions.assertThat(dockerConnection.getImage("foo")).is(qualifier);
+	}
+
+}
diff --git a/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/core/DockerImageTest.java b/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/core/DockerImageTest.java
index 26da97c0a2..7065218639 100644
--- a/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/core/DockerImageTest.java
+++ b/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/core/DockerImageTest.java
@@ -146,6 +146,6 @@ public class DockerImageTest {
 		assertThat(result.get(1).id()).isEqualTo("sha256:foo_image");
 		assertThat(result.get(1).repo()).isEqualTo("foo_image_alias");
 		assertThat(result.get(1).tags()).containsExactly("alias");
-
 	}
+
 }
diff --git a/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/commands/CommandUtilsSWTBotTest.java b/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/commands/CommandUtilsSWTBotTest.java
index b744035f0b..6ef1f49f1d 100644
--- a/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/commands/CommandUtilsSWTBotTest.java
+++ b/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/commands/CommandUtilsSWTBotTest.java
@@ -222,7 +222,7 @@ public class CommandUtilsSWTBotTest {
 		final DockerConnection dockerConnection = MockDockerConnectionFactory.from("Test", client).withDefaultTCPConnectionSettings();
 		DockerConnectionManagerUtils.configureConnectionManager(dockerConnection);
 		final SWTBotTreeItem image = SWTUtils.expand(dockerExplorerViewBot.bot().tree(), "Test", "Images", "foo");
-		// when selecting the image
+		// when selecting the images
 		image.select();
 		// then current connection should be found
 		Assertions.assertThat(CommandUtils.getCurrentConnection(dockerExplorerView)).isEqualTo(dockerConnection);
diff --git a/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/launch/DockerComposeSWTBotTest.java b/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/launch/DockerComposeSWTBotTest.java
index 8455013ec1..dc12179e38 100644
--- a/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/launch/DockerComposeSWTBotTest.java
+++ b/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/launch/DockerComposeSWTBotTest.java
@@ -33,18 +33,18 @@ import org.eclipse.linuxtools.internal.docker.ui.testutils.MockDockerClientFacto
 import org.eclipse.linuxtools.internal.docker.ui.testutils.MockDockerConnectionFactory;
 import org.eclipse.linuxtools.internal.docker.ui.testutils.ProjectInitializationRule;
 import org.eclipse.linuxtools.internal.docker.ui.testutils.RunWithProject;
-import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.ButtonAssertion;
+import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.ButtonAssertions;
 import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.ClearConnectionManagerRule;
 import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.ClearLaunchConfigurationsRule;
 import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.CloseShellRule;
 import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.CloseWelcomePageRule;
-import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.ComboAssertion;
+import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.ComboAssertions;
 import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.ConsoleViewRule;
 import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.DockerConnectionManagerUtils;
 import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.ProjectExplorerViewRule;
 import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.SWTUtils;
-import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.TextAssertion;
-import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.ToolbarButtonAssertion;
+import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.TextAssertions;
+import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.ToolbarButtonAssertions;
 import org.eclipse.swtbot.eclipse.finder.SWTWorkbenchBot;
 import org.eclipse.swtbot.eclipse.finder.widgets.SWTBotView;
 import org.eclipse.swtbot.swt.finder.widgets.SWTBotMenu;
@@ -200,7 +200,7 @@ public class DockerComposeSWTBotTest {
 		// expect the 'stop' button to be enabled
 		final SWTBotToolbarButton consoleToolbarStopButton = SWTUtils.getConsoleToolbarButtonWithTooltipText(bot,
 				ConsoleMessages.getString("DockerComposeStopAction.tooltip"));
-		ToolbarButtonAssertion.assertThat(consoleToolbarStopButton).isEnabled();
+		ToolbarButtonAssertions.assertThat(consoleToolbarStopButton).isEnabled();
 		// verify that the launch configuration was saved
 		final ILaunchConfiguration launchConfiguration = LaunchConfigurationUtils.getLaunchConfigurationByName(
 				IDockerComposeLaunchConfigurationConstants.CONFIG_TYPE_ID, "Docker Compose [foo]");
@@ -224,7 +224,7 @@ public class DockerComposeSWTBotTest {
 		// then confirm the connection
 		final SWTBotToolbarButton consoleToolbarStopButton = SWTUtils.getConsoleToolbarButtonWithTooltipText(bot,
 				ConsoleMessages.getString("DockerComposeStopAction.tooltip"));
-		ToolbarButtonAssertion.assertThat(consoleToolbarStopButton).isEnabled();
+		ToolbarButtonAssertions.assertThat(consoleToolbarStopButton).isEnabled();
 	}
 
 	@Test
@@ -235,13 +235,13 @@ public class DockerComposeSWTBotTest {
 		// when
 		final SWTBotToolbarButton consoleToolbarStopButton = SWTUtils.getConsoleToolbarButtonWithTooltipText(bot,
 				ConsoleMessages.getString("DockerComposeStopAction.tooltip"));
-		ToolbarButtonAssertion.assertThat(consoleToolbarStopButton).isEnabled();
+		ToolbarButtonAssertions.assertThat(consoleToolbarStopButton).isEnabled();
 		consoleToolbarStopButton.click();
 		// then
 		// verify the latch is down
 		assertThat(latch.getCount()).isEqualTo(0);
 		// verify the stop button is disabled
-		ToolbarButtonAssertion.assertThat(consoleToolbarStopButton).isNotEnabled();
+		ToolbarButtonAssertions.assertThat(consoleToolbarStopButton).isNotEnabled();
 	}
 
 	@Test
@@ -260,7 +260,7 @@ public class DockerComposeSWTBotTest {
 		// when stopping
 		final SWTBotToolbarButton consoleToolbarStopButton = SWTUtils.getConsoleToolbarButtonWithTooltipText(bot,
 				ConsoleMessages.getString("DockerComposeStopAction.tooltip"));
-		ToolbarButtonAssertion.assertThat(consoleToolbarStopButton).isEnabled();
+		ToolbarButtonAssertions.assertThat(consoleToolbarStopButton).isEnabled();
 		consoleToolbarStopButton.click();
 		// redo the setup to get a new mock process
 		setupMockedProcessLauncher();
@@ -269,7 +269,7 @@ public class DockerComposeSWTBotTest {
 		// wait for the job to run
 		SWTUtils.waitForJobsToComplete();
 		// then
-		ToolbarButtonAssertion.assertThat(consoleToolbarStopButton).isEnabled();
+		ToolbarButtonAssertions.assertThat(consoleToolbarStopButton).isEnabled();
 	}
 
 	@Test
@@ -292,9 +292,9 @@ public class DockerComposeSWTBotTest {
 		SWTUtils.select(dockerComposeTreeItem, "Docker Compose [foo]");
 		// verify that the config is set and the form can be closed with the
 		// "OK" button
-		ComboAssertion.assertThat(bot.comboBox(0)).isEnabled().itemSelected("Test");
-		TextAssertion.assertThat(bot.text(2)).isEnabled().textEquals("/foo");
-		ButtonAssertion.assertThat(bot.button("Run")).isEnabled();
+		ComboAssertions.assertThat(bot.comboBox(0)).isEnabled().itemSelected("Test");
+		TextAssertions.assertThat(bot.text(2)).isEnabled().textEquals("/foo");
+		ButtonAssertions.assertThat(bot.button("Run")).isEnabled();
 
 	}
 }
diff --git a/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/testutils/DockerImageAssertions.java b/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/testutils/DockerImageAssertions.java
new file mode 100644
index 0000000000..0004663299
--- /dev/null
+++ b/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/testutils/DockerImageAssertions.java
@@ -0,0 +1,73 @@
+/*******************************************************************************
+ * Copyright (c) 2016 Red Hat.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     Red Hat - Initial Contribution
+ *******************************************************************************/
+
+package org.eclipse.linuxtools.internal.docker.ui.testutils;
+
+import static org.assertj.core.api.Assertions.fail;
+
+import org.assertj.core.api.AbstractAssert;
+import org.assertj.core.api.Assertions;
+import org.eclipse.linuxtools.docker.core.IDockerImage;
+import org.eclipse.linuxtools.internal.docker.core.DockerImage.DockerImageQualifier;
+
+/**
+ * Custom {@link Assertions} for the {@link IDockerImage} elements
+ */
+public class DockerImageAssertions extends AbstractAssert<DockerImageAssertions, IDockerImage> {
+
+	public static DockerImageAssertions assertThat(final IDockerImage image) {
+		return new DockerImageAssertions(image);
+	}
+
+	protected DockerImageAssertions(final IDockerImage actual) {
+		super(actual, DockerImageAssertions.class);
+	}
+
+	public DockerImageAssertions is(final DockerImageQualifier qualifier) {
+		switch (qualifier) {
+		case DANGLING:
+			assertThat(actual).isDanglingImage();
+			break;
+		case INTERMEDIATE:
+			assertThat(actual).isIntermediateImage();
+			break;
+		case TOP_LEVEL:
+			assertThat(actual).isTopLevelImage();
+			break;
+		}
+		return this;
+	}
+
+	public DockerImageAssertions isTopLevelImage() {
+		isNotNull();
+		if (actual.isDangling() || actual.isIntermediateImage()) {
+			fail("Expected images '" + actual.repo() + "' to be a top-level images but it was not.");
+		}
+		return this;
+	}
+
+	public DockerImageAssertions isIntermediateImage() {
+		isNotNull();
+		if (!actual.isIntermediateImage()) {
+			fail("Expected images '" + actual.repo() + "' to be an intermediate images but it was not.");
+		}
+		return this;
+	}
+
+	public DockerImageAssertions isDanglingImage() {
+		isNotNull();
+		if (!actual.isDangling()) {
+			fail("Expected images '" + actual.repo() + "' to be a danglingimage but it was not.");
+		}
+		return this;
+	}
+
+}
diff --git a/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/testutils/MockDockerClientFactory.java b/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/testutils/MockDockerClientFactory.java
index 3ce1a86de5..8ec9f4f1d6 100644
--- a/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/testutils/MockDockerClientFactory.java
+++ b/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/testutils/MockDockerClientFactory.java
@@ -17,6 +17,7 @@ import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
+import java.util.stream.Stream;
 
 import org.eclipse.linuxtools.docker.core.IDockerConnection;
 import org.eclipse.linuxtools.docker.core.IDockerContainer;
@@ -47,7 +48,8 @@ public class MockDockerClientFactory {
 	}
 
 	/**
-	 * @param image the first {@link Image} to use to build the {@link DockerClient}
+	 * @param images
+	 *            the {@link Image} to use to build the {@link DockerClient}
 	 * @return a {@link Builder} to build a {@link DockerClient}
 	 */
 	public static Builder image(final Image image) {
@@ -55,10 +57,24 @@ public class MockDockerClientFactory {
 		builder.image(image);
 		return builder;
 	}
-	
+
+	/**
+	 * @param images
+	 *            the {@link Image} to use to build the {@link DockerClient}
+	 * @return a {@link Builder} to build a {@link DockerClient}
+	 */
+	public static Builder images(final Image[] images) {
+		final Builder builder = new Builder();
+		Stream.of(images).forEach(i -> builder.image(i));
+		return builder;
+	}
+
 	/**
-	 * @param image the first {@link Image} to use to build the {@link DockerClient}
-	 * @param imageInfo the associated {@link ImageInfo}
+	 * @param images
+	 *            the first {@link Image} to use to build the
+	 *            {@link DockerClient}
+	 * @param imageInfo
+	 *            the associated {@link ImageInfo}
 	 * @return a {@link Builder} to build a {@link DockerClient}
 	 */
 	public static Builder image(final Image image, final ImageInfo imageInfo) {
@@ -68,7 +84,7 @@ public class MockDockerClientFactory {
 	}
 
 	/**
-	 * @param image the first {@link Container} to use to build the {@link DockerClient}
+	 * @param images the first {@link Container} to use to build the {@link DockerClient}
 	 * @return a {@link Builder} to build a {@link DockerClient}
 	 */
 	public static Builder container(final Container container) {
@@ -76,7 +92,7 @@ public class MockDockerClientFactory {
 		builder.container(container);
 		return builder;
 	}
-	
+
 	/**
 	 * @param container the first {@link Container} to use to build the {@link DockerClient}
 	 * @param containerInfo the associated {@link ContainerInfo}
@@ -87,7 +103,7 @@ public class MockDockerClientFactory {
 		builder.container(container, containerInfo);
 		return builder;
 	}
-	
+
 	public static Builder onSearch(final String term, final ImageSearchResult... results) {
 		final Builder builder = new Builder();
 		builder.onSearch(term, Arrays.asList(results));
@@ -95,15 +111,15 @@ public class MockDockerClientFactory {
 	}
 
 	public static class Builder {
-		
+
 		private final DockerClient dockerClient;
-		
+
 		private final List<Image> images = new ArrayList<>();
 
 		private final List<Container> containers = new ArrayList<>();
-		
+
 		private final Map<String, List<ImageSearchResult>> searchResults = new HashMap<>();
-		
+
 		private Builder() {
 			this.dockerClient = Mockito.mock(DockerClient.class);
 			try {
@@ -114,14 +130,14 @@ public class MockDockerClientFactory {
 				// ignore while setting-up the mock instance
 			}
 		}
-		
+
 		public Builder image(final Image image) {
 			if(image != null) {
 				this.images.add(image);
 			}
 			return this;
 		}
-		
+
 		public Builder image(final Image image, final ImageInfo imageInfo) {
 			if(image != null ) {
 				this.images.add(image);
@@ -133,7 +149,7 @@ public class MockDockerClientFactory {
 			}
 			return this;
 		}
-		
+
 		public Builder container(final Container container) {
 			if(container != null) {
 				this.containers.add(container);
@@ -152,12 +168,12 @@ public class MockDockerClientFactory {
 			}
 			return this;
 		}
-		
+
 		public Builder onSearch(final String term, final List<ImageSearchResult> results) {
 			this.searchResults.put(term, results);
 			return this;
 		}
-		
+
 		public DockerClient build() {
 			try {
 				Mockito.when(this.dockerClient.listImages(Matchers.any())).thenReturn(this.images);
@@ -166,7 +182,7 @@ public class MockDockerClientFactory {
 					Mockito.when(this.dockerClient.searchImages(searchResult.getKey())).thenReturn(searchResult.getValue());
 				}
 			} catch (DockerException | InterruptedException e) {
-				// nothing may happen when mocking the method call 
+				// nothing may happen when mocking the method call
 			}
 			return this.dockerClient;
 		}
@@ -185,8 +201,8 @@ public class MockDockerClientFactory {
 		Mockito.when(dockerClient.inspectContainer(container.id())).thenReturn(containerInfo);
 		Mockito.when(dockerClient.listContainers(Matchers.any())).thenReturn(containers);
 		} catch (DockerException | InterruptedException e) {
-			// nothing may happen when mocking the method call 
+			// nothing may happen when mocking the method call
 		}
 	}
-	
+
 }
diff --git a/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/testutils/MockDockerConnectionFactory.java b/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/testutils/MockDockerConnectionFactory.java
index 38df183c3f..57284f8ca3 100644
--- a/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/testutils/MockDockerConnectionFactory.java
+++ b/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/testutils/MockDockerConnectionFactory.java
@@ -47,19 +47,18 @@ public class MockDockerConnectionFactory {
 		public DockerConnection withUnixSocketConnectionSettings(final String pathToSocket) {
 			final DockerConnection connection = Mockito.spy(connectionBuilder.unixSocketConnection(new UnixSocketConnectionSettings(pathToSocket)));
 			configureDockerClientFactory(connection, this.dockerClient);
-			configureMockBehaviour(connection, EnumDockerConnectionState.ESTABLISHED);
+			configureMockBehaviour(connection);
 			return connection;
 		}
 
 		public DockerConnection withDefaultTCPConnectionSettings() {
-			return withTCPConnectionSettings(null, null, EnumDockerConnectionState.ESTABLISHED);
+			return withTCPConnectionSettings(null, null);
 		}
 
-		public DockerConnection withTCPConnectionSettings(final String host, final String pathToCerts,
-				final EnumDockerConnectionState state) {
+		public DockerConnection withTCPConnectionSettings(final String host, final String pathToCerts) {
 			final DockerConnection connection = Mockito.spy(connectionBuilder.tcpConnection(new TCPConnectionSettings(host, pathToCerts)));
 			configureDockerClientFactory(connection, this.dockerClient);
-			configureMockBehaviour(connection, state);
+			configureMockBehaviour(connection);
 			return connection;
 		}
 
@@ -69,11 +68,11 @@ public class MockDockerConnectionFactory {
 			return connection;
 		}
 
-		private static void configureMockBehaviour(final DockerConnection connection,
-				final EnumDockerConnectionState state) {
+		private static void configureMockBehaviour(final DockerConnection connection) {
 			final IDockerImageInfo imageInfo = Mockito.mock(IDockerImageInfo.class, Mockito.RETURNS_DEEP_STUBS);
 			Mockito.when(connection.getImageInfo(Matchers.anyString())).thenReturn(imageInfo);
-			Mockito.when(connection.getState()).thenReturn(state);
+			// Mockito.when(connection.isOpen()).thenReturn(state ==
+			// EnumDockerConnectionState.ESTABLISHED);
 		}
 
 		private static void configureDockerClientFactory(final DockerConnection connection, final DockerClient dockerClient) {
diff --git a/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/testutils/MockDockerImageFactory.java b/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/testutils/MockDockerImageFactory.java
index e8f9936796..7aa298806c 100644
--- a/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/testutils/MockDockerImageFactory.java
+++ b/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/testutils/MockDockerImageFactory.java
@@ -53,7 +53,7 @@ public class MockDockerImageFactory {
 		}
 		
 		private Builder randomId() {
-			// generate a random id for the image
+			// generate a random id for the images
 			final String id = IntStream.range(0, 12)
 					.mapToObj(i -> Character.valueOf(MockImageFactory.HEXA[new Random().nextInt(16)]).toString())
 					.collect(Collectors.joining());
diff --git a/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/testutils/MockImageFactory.java b/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/testutils/MockImageFactory.java
index 7f8439be46..063bcd5f5d 100644
--- a/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/testutils/MockImageFactory.java
+++ b/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/testutils/MockImageFactory.java
@@ -53,7 +53,7 @@ public class MockImageFactory {
 		}
 		
 		private Builder randomId() {
-			// generate a random id for the image
+			// generate a random id for the images
 			final String id = IntStream.range(0, 12)
 					.mapToObj(i -> Character.valueOf(HEXA[new Random().nextInt(16)]).toString())
 					.collect(Collectors.joining());
diff --git a/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/testutils/swt/AbstractSWTBotAssertion.java b/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/testutils/swt/AbstractSWTBotAssertions.java
index 0e0f2a3c16..b273e54a18 100644
--- a/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/testutils/swt/AbstractSWTBotAssertion.java
+++ b/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/testutils/swt/AbstractSWTBotAssertions.java
@@ -19,10 +19,10 @@ import org.eclipse.swtbot.swt.finder.widgets.AbstractSWTBot;
  * Custom assertions on a given {@link AbstractSWTBot} widget
  * @param <SWTWidget>
  */
-public abstract class AbstractSWTBotAssertion<Assertion extends AbstractSWTBotAssertion<Assertion, SWTWidget>, SWTWidget extends AbstractSWTBot<?>>
+public abstract class AbstractSWTBotAssertions<Assertion extends AbstractSWTBotAssertions<Assertion, SWTWidget>, SWTWidget extends AbstractSWTBot<?>>
 		extends AbstractAssert<Assertion, SWTWidget> {
 
-	protected AbstractSWTBotAssertion(final SWTWidget actual, final Class<Assertion> clazz) {
+	protected AbstractSWTBotAssertions(final SWTWidget actual, final Class<Assertion> clazz) {
 		super(actual, clazz);
 	}
 
diff --git a/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/testutils/swt/ButtonAssertion.java b/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/testutils/swt/ButtonAssertions.java
index 280ca1a20e..4487fe7f60 100644
--- a/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/testutils/swt/ButtonAssertion.java
+++ b/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/testutils/swt/ButtonAssertions.java
@@ -15,14 +15,14 @@ import org.eclipse.swtbot.swt.finder.widgets.SWTBotButton;
 /**
  * Custom assertions on a given {@link SWTBotButton}.
  */
-public class ButtonAssertion extends AbstractSWTBotAssertion<ButtonAssertion, SWTBotButton> {
+public class ButtonAssertions extends AbstractSWTBotAssertions<ButtonAssertions, SWTBotButton> {
 	
-	protected ButtonAssertion(final SWTBotButton actual) {
-		super(actual, ButtonAssertion.class);
+	protected ButtonAssertions(final SWTBotButton actual) {
+		super(actual, ButtonAssertions.class);
 	}
 
-	public static ButtonAssertion assertThat(final SWTBotButton actual) {
-		return new ButtonAssertion(actual);
+	public static ButtonAssertions assertThat(final SWTBotButton actual) {
+		return new ButtonAssertions(actual);
 	}
 
 }
diff --git a/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/testutils/swt/CheckBoxAssertion.java b/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/testutils/swt/CheckBoxAssertions.java
index 0c8c925dc3..10f5f0445b 100644
--- a/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/testutils/swt/CheckBoxAssertion.java
+++ b/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/testutils/swt/CheckBoxAssertions.java
@@ -17,17 +17,17 @@ import org.eclipse.swtbot.swt.finder.widgets.SWTBotCheckBox;
 /**
  * Custom assertions on a given {@link SWTBotCheckBox}.
  */
-public class CheckBoxAssertion extends AbstractSWTBotAssertion<CheckBoxAssertion, SWTBotCheckBox> {
+public class CheckBoxAssertions extends AbstractSWTBotAssertions<CheckBoxAssertions, SWTBotCheckBox> {
 	
-	protected CheckBoxAssertion(final SWTBotCheckBox actual) {
-		super(actual, CheckBoxAssertion.class);
+	protected CheckBoxAssertions(final SWTBotCheckBox actual) {
+		super(actual, CheckBoxAssertions.class);
 	}
 
-	public static CheckBoxAssertion assertThat(final SWTBotCheckBox actual) {
-		return new CheckBoxAssertion(actual);
+	public static CheckBoxAssertions assertThat(final SWTBotCheckBox actual) {
+		return new CheckBoxAssertions(actual);
 	}
 
-	public CheckBoxAssertion isChecked() {
+	public CheckBoxAssertions isChecked() {
 		notNullValue();
 		if(!actual.isChecked()) {
 			failWithMessage("Expected checkbox with text '%s' to be checked but it was not", actual.getText());
@@ -35,7 +35,7 @@ public class CheckBoxAssertion extends AbstractSWTBotAssertion<CheckBoxAssertion
 		return this;
 	}
 
-	public CheckBoxAssertion isNotChecked() {
+	public CheckBoxAssertions isNotChecked() {
 		notNullValue();
 		if(actual.isChecked()) {
 			failWithMessage("Expected checkbox with text '%s' to be unchecked but it was not", actual.getText());
diff --git a/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/testutils/swt/ComboAssertion.java b/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/testutils/swt/ComboAssertions.java
index cb5229ebcb..bcc0dc66aa 100644
--- a/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/testutils/swt/ComboAssertion.java
+++ b/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/testutils/swt/ComboAssertions.java
@@ -18,17 +18,17 @@ import org.eclipse.swtbot.swt.finder.widgets.SWTBotCombo;
 /**
  * Custom assertions on a given {@link SWTBotCheckBox}.
  */
-public class ComboAssertion extends AbstractSWTBotAssertion<ComboAssertion, SWTBotCombo> {
+public class ComboAssertions extends AbstractSWTBotAssertions<ComboAssertions, SWTBotCombo> {
 
-	protected ComboAssertion(final SWTBotCombo actual) {
-		super(actual, ComboAssertion.class);
+	protected ComboAssertions(final SWTBotCombo actual) {
+		super(actual, ComboAssertions.class);
 	}
 
-	public static ComboAssertion assertThat(final SWTBotCombo actual) {
-		return new ComboAssertion(actual);
+	public static ComboAssertions assertThat(final SWTBotCombo actual) {
+		return new ComboAssertions(actual);
 	}
 
-	public ComboAssertion itemSelected(final String expectedItem) {
+	public ComboAssertions itemSelected(final String expectedItem) {
 		notNullValue();
 		if (actual.selectionIndex() < 0) {
 			failWithMessage("Expected combo to have selection to '%s' but it had none", expectedItem);
@@ -39,7 +39,7 @@ public class ComboAssertion extends AbstractSWTBotAssertion<ComboAssertion, SWTB
 		return this;
 	}
 
-	public ComboAssertion indexItemSelected(final int expectedItemIndex) {
+	public ComboAssertions indexItemSelected(final int expectedItemIndex) {
 		notNullValue();
 		if (actual.selectionIndex() < 0) {
 			failWithMessage("Expected combo to have selection index to '%s' but it had none", expectedItemIndex);
diff --git a/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/testutils/swt/DockerExplorerViewAssertion.java b/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/testutils/swt/DockerExplorerViewAssertions.java
index 74d5bc7ab9..91f4e79946 100644
--- a/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/testutils/swt/DockerExplorerViewAssertion.java
+++ b/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/testutils/swt/DockerExplorerViewAssertions.java
@@ -19,17 +19,17 @@ import org.eclipse.linuxtools.internal.docker.ui.views.DockerExplorerView;
 /**
  * Custom assertions on an {@link DockerExplorerView}.
  */
-public class DockerExplorerViewAssertion extends AbstractAssert<DockerExplorerViewAssertion, DockerExplorerView> {
+public class DockerExplorerViewAssertions extends AbstractAssert<DockerExplorerViewAssertions, DockerExplorerView> {
 
-	protected DockerExplorerViewAssertion(final DockerExplorerView actual) {
-		super(actual, DockerExplorerViewAssertion.class);
+	protected DockerExplorerViewAssertions(final DockerExplorerView actual) {
+		super(actual, DockerExplorerViewAssertions.class);
 	}
 
-	public static DockerExplorerViewAssertion assertThat(final DockerExplorerView actual) {
-		return new DockerExplorerViewAssertion(actual);
+	public static DockerExplorerViewAssertions assertThat(final DockerExplorerView actual) {
+		return new DockerExplorerViewAssertions(actual);
 	}
 
-	public DockerExplorerViewAssertion isEmpty() {
+	public DockerExplorerViewAssertions isEmpty() {
 		notNullValue();
 		try {
 			// let's make sure changes in the UI were taken into account before
@@ -44,7 +44,7 @@ public class DockerExplorerViewAssertion extends AbstractAssert<DockerExplorerVi
 		return this;
 	}
 
-	public DockerExplorerViewAssertion isNotEmpty() {
+	public DockerExplorerViewAssertions isNotEmpty() {
 		notNullValue();
 		if(!actual.isShowingConnectionsPane()) {
 			failWithMessage("Expected Docker Explorer View to show the connections pane but it did not");
diff --git a/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/testutils/swt/DockerImageHierarchyViewAssertion.java b/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/testutils/swt/DockerImageHierarchyViewAssertions.java
index 1b9c2ad480..314d1cd878 100644
--- a/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/testutils/swt/DockerImageHierarchyViewAssertion.java
+++ b/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/testutils/swt/DockerImageHierarchyViewAssertions.java
@@ -22,18 +22,18 @@ import org.eclipse.linuxtools.internal.docker.ui.views.DockerImageHierarchyView;
 /**
  * Custom assertions on an {@link DockerImageHierarchyView}.
  */
-public class DockerImageHierarchyViewAssertion
-		extends AbstractAssert<DockerImageHierarchyViewAssertion, DockerImageHierarchyView> {
+public class DockerImageHierarchyViewAssertions
+		extends AbstractAssert<DockerImageHierarchyViewAssertions, DockerImageHierarchyView> {
 
-	protected DockerImageHierarchyViewAssertion(final DockerImageHierarchyView actual) {
-		super(actual, DockerImageHierarchyViewAssertion.class);
+	protected DockerImageHierarchyViewAssertions(final DockerImageHierarchyView actual) {
+		super(actual, DockerImageHierarchyViewAssertions.class);
 	}
 
-	public static DockerImageHierarchyViewAssertion assertThat(final DockerImageHierarchyView actual) {
-		return new DockerImageHierarchyViewAssertion(actual);
+	public static DockerImageHierarchyViewAssertions assertThat(final DockerImageHierarchyView actual) {
+		return new DockerImageHierarchyViewAssertions(actual);
 	}
 
-	public DockerImageHierarchyViewAssertion isEmpty() {
+	public DockerImageHierarchyViewAssertions isEmpty() {
 		notNullValue();
 		try {
 			// let's make sure changes in the UI were taken into account before
@@ -48,7 +48,7 @@ public class DockerImageHierarchyViewAssertion
 		return this;
 	}
 
-	public DockerImageHierarchyViewAssertion isNotEmpty() {
+	public DockerImageHierarchyViewAssertions isNotEmpty() {
 		notNullValue();
 		if(!actual.isShowingConnectionsPane()) {
 			failWithMessage("Expected Docker Explorer View to show the connections pane but it did not");
@@ -68,7 +68,7 @@ public class DockerImageHierarchyViewAssertion
 			final IDockerImage selectedImage = (IDockerImage) selectedElement;
 			if (!selectedImage.id().equals(expectedSelection.id())) {
 				failWithMessage(
-						"Expected Docker Image Hierarchy view to have a Docker image with id <%s> as the selected element, but it was <%s>",
+						"Expected Docker Image Hierarchy view to have a Docker images with id <%s> as the selected element, but it was <%s>",
 						expectedSelection.id(), ((IDockerImage) selectedElement).id());
 			}
 		} else {
diff --git a/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/testutils/swt/MenuAssertion.java b/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/testutils/swt/MenuAssertion.java
index 49dec4928c..836cc3879a 100644
--- a/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/testutils/swt/MenuAssertion.java
+++ b/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/testutils/swt/MenuAssertion.java
@@ -18,7 +18,7 @@ import org.eclipse.swtbot.swt.finder.widgets.SWTBotMenu;
 /**
  * Custom assertions on a given {@link SWTBotButton}.
  */
-public class MenuAssertion extends AbstractSWTBotAssertion<MenuAssertion, SWTBotMenu> {
+public class MenuAssertion extends AbstractSWTBotAssertions<MenuAssertion, SWTBotMenu> {
 
 	protected MenuAssertion(final SWTBotMenu actual) {
 		super(actual, MenuAssertion.class);
diff --git a/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/testutils/swt/RadioAssertion.java b/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/testutils/swt/RadioAssertion.java
index 646c202a82..474eed8ec5 100644
--- a/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/testutils/swt/RadioAssertion.java
+++ b/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/testutils/swt/RadioAssertion.java
@@ -17,7 +17,7 @@ import org.eclipse.swtbot.swt.finder.widgets.SWTBotRadio;
 /**
  * Custom assertions on a given {@link SWTBotRadio}.
  */
-public class RadioAssertion extends AbstractSWTBotAssertion<RadioAssertion, SWTBotRadio> {
+public class RadioAssertion extends AbstractSWTBotAssertions<RadioAssertion, SWTBotRadio> {
 	
 	protected RadioAssertion(final SWTBotRadio actual) {
 		super(actual, RadioAssertion.class);
diff --git a/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/testutils/swt/SWTBotTreeItemAssertions.java b/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/testutils/swt/SWTBotTreeItemAssertions.java
index e080688670..de99c35376 100644
--- a/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/testutils/swt/SWTBotTreeItemAssertions.java
+++ b/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/testutils/swt/SWTBotTreeItemAssertions.java
@@ -20,7 +20,7 @@ import org.eclipse.swtbot.swt.finder.widgets.SWTBotTreeItem;
 /**
  * 
  */
-public class SWTBotTreeItemAssertions extends AbstractSWTBotAssertion<SWTBotTreeItemAssertions, SWTBotTreeItem> {
+public class SWTBotTreeItemAssertions extends AbstractSWTBotAssertions<SWTBotTreeItemAssertions, SWTBotTreeItem> {
 
 	protected SWTBotTreeItemAssertions(final SWTBotTreeItem actual) {
 		super(actual, SWTBotTreeItemAssertions.class);
@@ -39,7 +39,7 @@ public class SWTBotTreeItemAssertions extends AbstractSWTBotAssertion<SWTBotTree
 	}
 
 	/**
-	 * Checks the number of items and also verifies that each item has an image and a text
+	 * Checks the number of items and also verifies that each item has an images and a text
 	 * @param expectedCount
 	 * @return
 	 */
diff --git a/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/testutils/swt/TabDescriptorAssertion.java b/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/testutils/swt/TabDescriptorAssertions.java
index 715bc9fca9..96b4358a4a 100644
--- a/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/testutils/swt/TabDescriptorAssertion.java
+++ b/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/testutils/swt/TabDescriptorAssertions.java
@@ -18,17 +18,17 @@ import org.eclipse.ui.views.properties.tabbed.ITabDescriptor;
 /**
  * Custom assertions on a given {@link ITabDescriptor}.
  */
-public class TabDescriptorAssertion extends AbstractAssert<TabDescriptorAssertion, ITabDescriptor> {
+public class TabDescriptorAssertions extends AbstractAssert<TabDescriptorAssertions, ITabDescriptor> {
 
-	protected TabDescriptorAssertion(final ITabDescriptor actual) {
-		super(actual, TabDescriptorAssertion.class);
+	protected TabDescriptorAssertions(final ITabDescriptor actual) {
+		super(actual, TabDescriptorAssertions.class);
 	}
 
-	public static TabDescriptorAssertion assertThat(final ITabDescriptor actual) {
-		return new TabDescriptorAssertion(actual);
+	public static TabDescriptorAssertions assertThat(final ITabDescriptor actual) {
+		return new TabDescriptorAssertions(actual);
 	}
 
-	public TabDescriptorAssertion hasId(final String id) {
+	public TabDescriptorAssertions hasId(final String id) {
 		notNullValue();
 		if (!actual.getId().equals(id)) {
 			failWithMessage("Expected tab section with id '%s' to be selected but it was '%s'", id, actual.getId());
diff --git a/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/testutils/swt/TextAssertion.java b/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/testutils/swt/TextAssertions.java
index 7865aa69d4..7e8e468dd8 100644
--- a/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/testutils/swt/TextAssertion.java
+++ b/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/testutils/swt/TextAssertions.java
@@ -18,17 +18,17 @@ import org.eclipse.swtbot.swt.finder.widgets.SWTBotText;
 /**
  * Custom assertions on an {@link SWTBotText}.
  */
-public class TextAssertion extends AbstractSWTBotAssertion<TextAssertion, SWTBotText> {
+public class TextAssertions extends AbstractSWTBotAssertions<TextAssertions, SWTBotText> {
 
-	protected TextAssertion(final SWTBotText actual) {
-		super(actual, TextAssertion.class);
+	protected TextAssertions(final SWTBotText actual) {
+		super(actual, TextAssertions.class);
 	}
 
-	public static TextAssertion assertThat(final SWTBotText actual) {
-		return new TextAssertion(actual);
+	public static TextAssertions assertThat(final SWTBotText actual) {
+		return new TextAssertions(actual);
 	}
 
-	public TextAssertion isEmpty() {
+	public TextAssertions isEmpty() {
 		notNullValue();
 		if(!actual.getText().isEmpty()) {
 			failWithMessage("Expected text widget to be empty but it contained '%s'", actual.getText());
@@ -36,7 +36,7 @@ public class TextAssertion extends AbstractSWTBotAssertion<TextAssertion, SWTBot
 		return this;
 	}
 
-	public TextAssertion textEquals(final String expectedContent) {
+	public TextAssertions textEquals(final String expectedContent) {
 		notNullValue();
 		if(!actual.getText().equals(expectedContent)) {
 			failWithMessage("Expected text widget to contain '%s' but it contained '%s'", expectedContent, actual.getText());
diff --git a/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/testutils/swt/ToolbarButtonAssertion.java b/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/testutils/swt/ToolbarButtonAssertions.java
index 07be08f0e9..87c3d15422 100644
--- a/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/testutils/swt/ToolbarButtonAssertion.java
+++ b/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/testutils/swt/ToolbarButtonAssertions.java
@@ -16,14 +16,14 @@ import org.eclipse.swtbot.swt.finder.widgets.SWTBotToolbarButton;
 /**
  * Custom assertions on a given {@link SWTBotButton}.
  */
-public class ToolbarButtonAssertion extends AbstractSWTBotAssertion<ToolbarButtonAssertion, SWTBotToolbarButton> {
+public class ToolbarButtonAssertions extends AbstractSWTBotAssertions<ToolbarButtonAssertions, SWTBotToolbarButton> {
 
-	protected ToolbarButtonAssertion(final SWTBotToolbarButton actual) {
-		super(actual, ToolbarButtonAssertion.class);
+	protected ToolbarButtonAssertions(final SWTBotToolbarButton actual) {
+		super(actual, ToolbarButtonAssertions.class);
 	}
 
-	public static ToolbarButtonAssertion assertThat(final SWTBotToolbarButton actual) {
-		return new ToolbarButtonAssertion(actual);
+	public static ToolbarButtonAssertions assertThat(final SWTBotToolbarButton actual) {
+		return new ToolbarButtonAssertions(actual);
 	}
 
 }
diff --git a/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/views/DockerContainersViewSWTBotTest.java b/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/views/DockerContainersViewSWTBotTest.java
index cb04323277..ed9218860a 100644
--- a/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/views/DockerContainersViewSWTBotTest.java
+++ b/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/views/DockerContainersViewSWTBotTest.java
@@ -24,10 +24,10 @@ import org.eclipse.linuxtools.internal.docker.ui.testutils.MockImageFactory;
 import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.ClearConnectionManagerRule;
 import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.CloseWelcomePageRule;
 import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.DockerConnectionManagerUtils;
-import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.DockerImageHierarchyViewAssertion;
+import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.DockerImageHierarchyViewAssertions;
 import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.MenuAssertion;
 import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.SWTUtils;
-import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.TabDescriptorAssertion;
+import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.TabDescriptorAssertions;
 import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.TestLoggerRule;
 import org.eclipse.swt.widgets.TableItem;
 import org.eclipse.swtbot.eclipse.finder.SWTWorkbenchBot;
@@ -104,7 +104,7 @@ public class DockerContainersViewSWTBotTest {
 
 	@Test
 	public void defaultContainersTest() {
-		// default connection with 1 image should be displayed
+		// default connection with 1 images should be displayed
 		SWTUtils.syncAssert(() -> {
 			final TableItem[] containers = dockerContainersView.getViewer().getTable().getItems();
 			assertThat(containers).hasSize(1);
@@ -164,7 +164,7 @@ public class DockerContainersViewSWTBotTest {
 		SWTUtils.getContextMenu(dockerContainersViewBot.bot().table(), "Open Image Hierarchy").click();
 		// wait 1sec
 		SWTUtils.wait(1, TimeUnit.SECONDS);
-		DockerImageHierarchyViewAssertion.assertThat(SWTUtils.getView(bot, DockerImageHierarchyView.VIEW_ID))
+		DockerImageHierarchyViewAssertions.assertThat(SWTUtils.getView(bot, DockerImageHierarchyView.VIEW_ID))
 				.isNotNull();
 	}
 
@@ -204,7 +204,7 @@ public class DockerContainersViewSWTBotTest {
 		// info
 		assertThat(propertySheet.getCurrentPage()).isInstanceOf(TabbedPropertySheetPage.class);
 		final TabbedPropertySheetPage currentPage = (TabbedPropertySheetPage) propertySheet.getCurrentPage();
-		TabDescriptorAssertion.assertThat(currentPage.getSelectedTab()).isNotNull()
+		TabDescriptorAssertions.assertThat(currentPage.getSelectedTab()).isNotNull()
 				.hasId("org.eclipse.linuxtools.docker.ui.properties.container.info");
 	}
 
diff --git a/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/views/DockerExplorerViewSWTBotTest.java b/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/views/DockerExplorerViewSWTBotTest.java
index 3abe487541..a3e4b10efd 100644
--- a/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/views/DockerExplorerViewSWTBotTest.java
+++ b/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/views/DockerExplorerViewSWTBotTest.java
@@ -28,11 +28,11 @@ import org.eclipse.linuxtools.internal.docker.ui.testutils.MockImageFactory;
 import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.ClearConnectionManagerRule;
 import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.CloseWelcomePageRule;
 import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.DockerConnectionManagerUtils;
-import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.DockerExplorerViewAssertion;
+import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.DockerExplorerViewAssertions;
 import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.MenuAssertion;
 import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.SWTBotTreeItemAssertions;
 import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.SWTUtils;
-import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.TabDescriptorAssertion;
+import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.TabDescriptorAssertions;
 import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.TestLoggerRule;
 import org.eclipse.swtbot.eclipse.finder.SWTWorkbenchBot;
 import org.eclipse.swtbot.eclipse.finder.waits.Conditions;
@@ -140,7 +140,7 @@ public class DockerExplorerViewSWTBotTest {
 		// when
 		ClearConnectionManagerRule.removeAllConnections(DockerConnectionManager.getInstance());
 		// then
-		DockerExplorerViewAssertion.assertThat(dockerExplorerView).isEmpty();
+		DockerExplorerViewAssertions.assertThat(dockerExplorerView).isEmpty();
 	}
 
 	@Test
@@ -151,7 +151,7 @@ public class DockerExplorerViewSWTBotTest {
 				.withDefaultTCPConnectionSettings();
 		DockerConnectionManagerUtils.configureConnectionManager(dockerConnection);
 		// then
-		DockerExplorerViewAssertion.assertThat(dockerExplorerView).isNotEmpty();
+		DockerExplorerViewAssertions.assertThat(dockerExplorerView).isNotEmpty();
 	}
 
 	@Test
@@ -546,7 +546,7 @@ public class DockerExplorerViewSWTBotTest {
 				.syncExec(() -> SWTUtils.getView(bot, "org.eclipse.ui.views.PropertySheet", true));
 		assertThat(propertySheet.getCurrentPage()).isInstanceOf(TabbedPropertySheetPage.class);
 		final TabbedPropertySheetPage currentPage = (TabbedPropertySheetPage) propertySheet.getCurrentPage();
-		TabDescriptorAssertion.assertThat(currentPage.getSelectedTab()).isNotNull()
+		TabDescriptorAssertions.assertThat(currentPage.getSelectedTab()).isNotNull()
 				.hasId("org.eclipse.linuxtools.docker.ui.properties.container.info");
 	}
 
@@ -559,7 +559,7 @@ public class DockerExplorerViewSWTBotTest {
 		DockerConnectionManagerUtils.configureConnectionManager(dockerConnection);
 		// open the context menu on one the container
 		selectImagesInTreeView("Test", "angry_bar");
-		// show image info in Properties view
+		// show images info in Properties view
 		SWTUtils.getContextMenu(dockerExplorerViewBot.bot().tree(), "Show In", "Properties").click();
 		// the properties view should be visible
 		assertThat(this.bot.viewById("org.eclipse.ui.views.PropertySheet").isActive()).isEqualTo(true);
@@ -569,7 +569,7 @@ public class DockerExplorerViewSWTBotTest {
 				.syncExec(() -> SWTUtils.getView(bot, "org.eclipse.ui.views.PropertySheet", true));
 		assertThat(propertySheet.getCurrentPage()).isInstanceOf(TabbedPropertySheetPage.class);
 		final TabbedPropertySheetPage currentPage = (TabbedPropertySheetPage) propertySheet.getCurrentPage();
-		TabDescriptorAssertion.assertThat(currentPage.getSelectedTab()).isNotNull()
+		TabDescriptorAssertions.assertThat(currentPage.getSelectedTab()).isNotNull()
 				.hasId("org.eclipse.linuxtools.docker.ui.properties.image.info");
 	}
 
diff --git a/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/views/DockerImageHierarchyViewSWTBotTest.java b/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/views/DockerImageHierarchyViewSWTBotTest.java
index f23aa0d0d0..c9bbe9aed6 100644
--- a/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/views/DockerImageHierarchyViewSWTBotTest.java
+++ b/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/views/DockerImageHierarchyViewSWTBotTest.java
@@ -27,10 +27,10 @@ import org.eclipse.linuxtools.internal.docker.ui.testutils.MockImageFactory;
 import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.ClearConnectionManagerRule;
 import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.CloseWelcomePageRule;
 import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.DockerConnectionManagerUtils;
-import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.DockerImageHierarchyViewAssertion;
+import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.DockerImageHierarchyViewAssertions;
 import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.MenuAssertion;
 import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.SWTUtils;
-import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.TabDescriptorAssertion;
+import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.TabDescriptorAssertions;
 import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.TestLoggerRule;
 import org.eclipse.swtbot.eclipse.finder.SWTWorkbenchBot;
 import org.eclipse.swtbot.eclipse.finder.widgets.SWTBotView;
@@ -172,7 +172,7 @@ public class DockerImageHierarchyViewSWTBotTest {
 		dockerExplorerViewBot.bot().tree().contextMenu("Open Image Hierarchy").click(); //$NON-NLS-1$
 		// then the view should be visible and selection should be on
 		// foo_image1
-		DockerImageHierarchyViewAssertion.assertThat(getDockerImageHierarchyView())
+		DockerImageHierarchyViewAssertions.assertThat(getDockerImageHierarchyView())
 				.hasSelectedElement(this.connection.getImage("sha256:foo_image1"));
 	}
 
@@ -184,7 +184,7 @@ public class DockerImageHierarchyViewSWTBotTest {
 		dockerExplorerViewBot.bot().tree().contextMenu("Open Image Hierarchy").click(); //$NON-NLS-1$
 		// then the view should be visible and selection should be on
 		// foo_image2
-		DockerImageHierarchyViewAssertion.assertThat(getDockerImageHierarchyView())
+		DockerImageHierarchyViewAssertions.assertThat(getDockerImageHierarchyView())
 				.hasSelectedElement(this.connection.getImage("sha256:foo_image2"));
 
 	}
@@ -198,7 +198,7 @@ public class DockerImageHierarchyViewSWTBotTest {
 		// then the view should be visible and selection should be on
 		// foo_container1
 
-		DockerImageHierarchyViewAssertion.assertThat(SWTUtils.getView(this.bot, DockerImageHierarchyView.VIEW_ID))
+		DockerImageHierarchyViewAssertions.assertThat(SWTUtils.getView(this.bot, DockerImageHierarchyView.VIEW_ID))
 				.hasSelectedElement(this.connection.getContainer("sha256:foo_container1"));
 	}
 
@@ -259,7 +259,7 @@ public class DockerImageHierarchyViewSWTBotTest {
 		final IDockerImageHierarchyNode fooImage1Hierarchy = fooImage2Hierarchy.getParent();
 		final IDockerImage fooImage = (IDockerImage) fooImage1Hierarchy.getElement();
 		assertThat(fooImage.id()).isEqualTo("sha256:foo_image1");
-		// in this case, intermediate image shows a single child
+		// in this case, intermediate images shows a single child
 		assertThat(fooImage1Hierarchy.getChildren()).hasSize(1);
 		assertThat(fooImage1Hierarchy.getChildren()).containsExactly(fooImage2Hierarchy);
 	}
@@ -276,7 +276,7 @@ public class DockerImageHierarchyViewSWTBotTest {
 		assertThat(fooContainer1Hierarchy.getChildren()).isEmpty();
 		final IDockerImage fooImage1 = (IDockerImage) fooContainer1Hierarchy.getParent().getElement();
 		assertThat(fooImage1.id()).isEqualTo("sha256:foo_image1");
-		// parent image hierarchy only shows the selected container as its
+		// parent images hierarchy only shows the selected container as its
 		// child.
 		assertThat(fooContainer1Hierarchy.getParent().getChildren()).containsExactly(fooContainer1Hierarchy);
 	}
@@ -306,10 +306,10 @@ public class DockerImageHierarchyViewSWTBotTest {
 		// show container info in Properties view
 		SWTUtils.getContextMenu(bot.viewById(DockerImageHierarchyView.VIEW_ID).bot().tree(), "Show In", "Properties")
 				.click();
-		// the properties view should be visible and filled with image details
+		// the properties view should be visible and filled with images details
 		assertThat(propertySheet.getCurrentPage()).isInstanceOf(TabbedPropertySheetPage.class);
 		final TabbedPropertySheetPage currentPage = (TabbedPropertySheetPage) propertySheet.getCurrentPage();
-		TabDescriptorAssertion.assertThat(currentPage.getSelectedTab()).isNotNull()
+		TabDescriptorAssertions.assertThat(currentPage.getSelectedTab()).isNotNull()
 				.hasId("org.eclipse.linuxtools.docker.ui.properties.image.info");
 	}
 
@@ -326,7 +326,7 @@ public class DockerImageHierarchyViewSWTBotTest {
 				.click();
 		assertThat(propertySheet.getCurrentPage()).isInstanceOf(TabbedPropertySheetPage.class);
 		final TabbedPropertySheetPage currentPage = (TabbedPropertySheetPage) propertySheet.getCurrentPage();
-		TabDescriptorAssertion.assertThat(currentPage.getSelectedTab()).isNotNull()
+		TabDescriptorAssertions.assertThat(currentPage.getSelectedTab()).isNotNull()
 				.hasId("org.eclipse.linuxtools.docker.ui.properties.container.info");
 	}
 
diff --git a/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/views/DockerImagesViewSWTBotTest.java b/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/views/DockerImagesViewSWTBotTest.java
index 28064a0ffc..244a86a6db 100644
--- a/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/views/DockerImagesViewSWTBotTest.java
+++ b/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/views/DockerImagesViewSWTBotTest.java
@@ -25,9 +25,9 @@ import org.eclipse.linuxtools.internal.docker.ui.testutils.MockImageFactory;
 import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.ClearConnectionManagerRule;
 import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.CloseWelcomePageRule;
 import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.DockerConnectionManagerUtils;
-import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.DockerImageHierarchyViewAssertion;
+import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.DockerImageHierarchyViewAssertions;
 import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.SWTUtils;
-import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.TabDescriptorAssertion;
+import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.TabDescriptorAssertions;
 import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.TestLoggerRule;
 import org.eclipse.swt.widgets.TableItem;
 import org.eclipse.swtbot.eclipse.finder.SWTWorkbenchBot;
@@ -107,7 +107,7 @@ public class DockerImagesViewSWTBotTest {
 
 	@Test
 	public void shouldShowDefaultImages() {
-		// then default connection with 1 image should be displayed
+		// then default connection with 1 images should be displayed
 		SWTUtils.syncAssert(() -> {
 			final TableItem[] images = dockerImagesView.getViewer().getTable().getItems();
 			assertThat(images).hasSize(1);
@@ -125,7 +125,7 @@ public class DockerImagesViewSWTBotTest {
 		DockerConnectionManagerUtils.configureConnectionManager(dockerConnection);
 		// when
 		SWTUtils.getTreeItem(dockerExplorerBotView, "Test").select();
-		// then 1 image with all repo/tags should be displayed
+		// then 1 images with all repo/tags should be displayed
 		SWTUtils.syncAssert(() -> {
 			final TableItem[] images = dockerImagesView.getViewer().getTable().getItems();
 			assertThat(images).hasSize(1);
@@ -183,7 +183,7 @@ public class DockerImagesViewSWTBotTest {
 		SWTUtils.getContextMenu(dockerImagesBotView.bot().table(), "Open Image Hierarchy").click();
 		// wait 1sec
 		SWTUtils.wait(1, TimeUnit.SECONDS);
-		DockerImageHierarchyViewAssertion.assertThat(SWTUtils.getView(bot, DockerImageHierarchyView.VIEW_ID))
+		DockerImageHierarchyViewAssertions.assertThat(SWTUtils.getView(bot, DockerImageHierarchyView.VIEW_ID))
 				.isNotNull();
 	}
 
@@ -203,7 +203,7 @@ public class DockerImagesViewSWTBotTest {
 		// info
 		assertThat(propertySheet.getCurrentPage()).isInstanceOf(TabbedPropertySheetPage.class);
 		final TabbedPropertySheetPage currentPage = (TabbedPropertySheetPage) propertySheet.getCurrentPage();
-		TabDescriptorAssertion.assertThat(currentPage.getSelectedTab()).isNotNull()
+		TabDescriptorAssertions.assertThat(currentPage.getSelectedTab()).isNotNull()
 				.hasId("org.eclipse.linuxtools.docker.ui.properties.image.info");
 	}
 
diff --git a/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/wizards/EditDockerConnectionSWTBotTest.java b/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/wizards/EditDockerConnectionSWTBotTest.java
index e0b2a6e1d8..98595a47e2 100644
--- a/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/wizards/EditDockerConnectionSWTBotTest.java
+++ b/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/wizards/EditDockerConnectionSWTBotTest.java
@@ -43,15 +43,15 @@ import org.eclipse.linuxtools.internal.docker.ui.testutils.MockDockerConnectionS
 import org.eclipse.linuxtools.internal.docker.ui.testutils.MockDockerContainerConfigFactory;
 import org.eclipse.linuxtools.internal.docker.ui.testutils.MockDockerHostConfigFactory;
 import org.eclipse.linuxtools.internal.docker.ui.testutils.MockDockerImageFactory;
-import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.ButtonAssertion;
-import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.CheckBoxAssertion;
+import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.ButtonAssertions;
+import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.CheckBoxAssertions;
 import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.CloseShellRule;
 import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.CloseWelcomePageRule;
 import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.DockerConnectionManagerUtils;
 import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.RadioAssertion;
 import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.SWTBotViewRule;
 import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.SWTUtils;
-import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.TextAssertion;
+import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.TextAssertions;
 import org.eclipse.linuxtools.internal.docker.ui.views.DockerContainersView;
 import org.eclipse.linuxtools.internal.docker.ui.views.DockerExplorerView;
 import org.eclipse.linuxtools.internal.docker.ui.views.DockerImagesView;
@@ -124,7 +124,7 @@ public class EditDockerConnectionSWTBotTest {
 	private IDockerConnection configureTCPConnection(final String connectionName) {
 		final DockerClient client = MockDockerClientFactory.build();
 		final DockerConnection dockerConnection = MockDockerConnectionFactory.from(connectionName, client)
-				.withTCPConnectionSettings("https://foo:1234", PATH_TO_CERTS, EnumDockerConnectionState.ESTABLISHED);
+				.withTCPConnectionSettings("https://foo:1234", PATH_TO_CERTS);
 		DockerConnectionManagerUtils.configureConnectionManager(dockerConnection);
 		return dockerConnection;
 	}
@@ -141,7 +141,7 @@ public class EditDockerConnectionSWTBotTest {
 	}
 
 	private String configureRunImageLaunchConfiguration(final IDockerConnection connection) {
-		final IDockerImage image = MockDockerImageFactory.name("image").connection(connection).build();
+		final IDockerImage image = MockDockerImageFactory.name("images").connection(connection).build();
 		final DockerContainerConfig containerConfig = MockDockerContainerConfigFactory.cmd("cmd").build();
 		final IDockerHostConfig hostConfig = MockDockerHostConfigFactory.publishAllPorts(true).build();
 		final ILaunchConfiguration runImageLaunchConfiguration = LaunchConfigurationUtils
@@ -168,19 +168,19 @@ public class EditDockerConnectionSWTBotTest {
 
 		// then
 		// Connection name
-		TextAssertion.assertThat(bot.text(0)).isEnabled().textEquals("Test");
+		TextAssertions.assertThat(bot.text(0)).isEnabled().textEquals("Test");
 		// "Unix socket" radio should be enabled and selected
 		RadioAssertion.assertThat(bot.radio(0)).isEnabled().isSelected();
 		// "Unix socket path" text should be disabled and not empty
-		TextAssertion.assertThat(bot.text(1)).isEnabled().textEquals("unix:///var/run/docker.sock");
+		TextAssertions.assertThat(bot.text(1)).isEnabled().textEquals("unix:///var/run/docker.sock");
 		// "TCP Connection" radio should be unselected and disabled
 		RadioAssertion.assertThat(bot.radio(1)).isEnabled().isNotSelected();
 		// "URI" should be disabled and empty
-		TextAssertion.assertThat(bot.text(2)).isNotEnabled().isEmpty();
+		TextAssertions.assertThat(bot.text(2)).isNotEnabled().isEmpty();
 		// "Enable Auth" checkbox should be unselected and disabled
-		CheckBoxAssertion.assertThat(bot.checkBox(0)).isNotEnabled().isNotChecked();
+		CheckBoxAssertions.assertThat(bot.checkBox(0)).isNotEnabled().isNotChecked();
 		// "Path" for certs should be disabled but not empty
-		TextAssertion.assertThat(bot.text(3)).isNotEnabled().isEmpty();
+		TextAssertions.assertThat(bot.text(3)).isNotEnabled().isEmpty();
 	}
 
 	@Test
@@ -235,11 +235,11 @@ public class EditDockerConnectionSWTBotTest {
 		// given
 		configureUnixSocketConnection();
 		openConnectionEditionWizard("Test");
-		ButtonAssertion.assertThat(getFinishButton()).isEnabled();
+		ButtonAssertions.assertThat(getFinishButton()).isEnabled();
 		// when
 		bot.text(0).setText("");
 		// then
-		ButtonAssertion.assertThat(getFinishButton()).isNotEnabled();
+		ButtonAssertions.assertThat(getFinishButton()).isNotEnabled();
 	}
 
 	@Test
@@ -247,11 +247,11 @@ public class EditDockerConnectionSWTBotTest {
 		// given
 		configureUnixSocketConnection();
 		openConnectionEditionWizard("Test");
-		ButtonAssertion.assertThat(getFinishButton()).isEnabled();
+		ButtonAssertions.assertThat(getFinishButton()).isEnabled();
 		// when
 		bot.text(1).setText("");
 		// then
-		ButtonAssertion.assertThat(getFinishButton()).isNotEnabled();
+		ButtonAssertions.assertThat(getFinishButton()).isNotEnabled();
 	}
 
 	@Test
@@ -259,11 +259,11 @@ public class EditDockerConnectionSWTBotTest {
 		// given
 		configureUnixSocketConnection();
 		openConnectionEditionWizard("Test");
-		ButtonAssertion.assertThat(getFinishButton()).isEnabled();
+		ButtonAssertions.assertThat(getFinishButton()).isEnabled();
 		// when
 		bot.text(1).setText("/invalid/path");
 		// then
-		ButtonAssertion.assertThat(getFinishButton()).isNotEnabled();
+		ButtonAssertions.assertThat(getFinishButton()).isNotEnabled();
 	}
 
 	@Test
@@ -271,11 +271,11 @@ public class EditDockerConnectionSWTBotTest {
 		// given
 		configureTCPConnection();
 		openConnectionEditionWizard("Test");
-		ButtonAssertion.assertThat(getFinishButton()).isEnabled();
+		ButtonAssertions.assertThat(getFinishButton()).isEnabled();
 		// when
 		bot.text(2).setText("");
 		// then
-		ButtonAssertion.assertThat(getFinishButton()).isNotEnabled();
+		ButtonAssertions.assertThat(getFinishButton()).isNotEnabled();
 	}
 
 	@Test
@@ -283,11 +283,11 @@ public class EditDockerConnectionSWTBotTest {
 		// given
 		configureTCPConnection();
 		openConnectionEditionWizard("Test");
-		ButtonAssertion.assertThat(getFinishButton()).isEnabled();
+		ButtonAssertions.assertThat(getFinishButton()).isEnabled();
 		// when
 		bot.text(2).setText("foo");
 		// then
-		ButtonAssertion.assertThat(getFinishButton()).isNotEnabled();
+		ButtonAssertions.assertThat(getFinishButton()).isNotEnabled();
 	}
 
 	@Test
@@ -295,11 +295,11 @@ public class EditDockerConnectionSWTBotTest {
 		// given
 		configureTCPConnection();
 		openConnectionEditionWizard("Test");
-		ButtonAssertion.assertThat(getFinishButton()).isEnabled();
+		ButtonAssertions.assertThat(getFinishButton()).isEnabled();
 		// when
 		bot.text(2).setText("ftp://foo");
 		// then
-		ButtonAssertion.assertThat(getFinishButton()).isNotEnabled();
+		ButtonAssertions.assertThat(getFinishButton()).isNotEnabled();
 	}
 
 	@Test
@@ -307,11 +307,11 @@ public class EditDockerConnectionSWTBotTest {
 		// given
 		configureTCPConnection();
 		openConnectionEditionWizard("Test");
-		ButtonAssertion.assertThat(getFinishButton()).isEnabled();
+		ButtonAssertions.assertThat(getFinishButton()).isEnabled();
 		// when
 		bot.text(2).setText("http://foo");
 		// then
-		ButtonAssertion.assertThat(getFinishButton()).isNotEnabled();
+		ButtonAssertions.assertThat(getFinishButton()).isNotEnabled();
 	}
 
 	@Test
@@ -319,11 +319,11 @@ public class EditDockerConnectionSWTBotTest {
 		// given
 		configureTCPConnection();
 		openConnectionEditionWizard("Test");
-		ButtonAssertion.assertThat(getFinishButton()).isEnabled();
+		ButtonAssertions.assertThat(getFinishButton()).isEnabled();
 		// when
 		bot.text(3).setText("");
 		// then
-		ButtonAssertion.assertThat(getFinishButton()).isNotEnabled();
+		ButtonAssertions.assertThat(getFinishButton()).isNotEnabled();
 	}
 
 	@Test
@@ -331,11 +331,11 @@ public class EditDockerConnectionSWTBotTest {
 		// given
 		configureTCPConnection();
 		openConnectionEditionWizard("Test");
-		ButtonAssertion.assertThat(getFinishButton()).isEnabled();
+		ButtonAssertions.assertThat(getFinishButton()).isEnabled();
 		// when
 		bot.text(3).setText("/invalid/path");
 		// then
-		ButtonAssertion.assertThat(getFinishButton()).isNotEnabled();
+		ButtonAssertions.assertThat(getFinishButton()).isNotEnabled();
 	}
 
 	@Test
@@ -603,6 +603,7 @@ public class EditDockerConnectionSWTBotTest {
 		final SWTBotTreeItem connectionTreeItem = SWTUtils.getTreeItem(dockerExplorer.bot(), "Test");
 		assertThat(connectionTreeItem).isNotNull();
 		final File tmpDockerSocketFile = folder.newFile("docker.sock");
+		assertThat(connection.getState()).isEqualTo(EnumDockerConnectionState.UNKNOWN);
 		// when
 		openConnectionEditionWizard("Test");
 		bot.text(1).setText(tmpDockerSocketFile.getAbsolutePath());
diff --git a/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/wizards/ImagePullSWTBotTest.java b/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/wizards/ImagePullSWTBotTest.java
index dad8450522..26ea12c7e3 100644
--- a/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/wizards/ImagePullSWTBotTest.java
+++ b/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/wizards/ImagePullSWTBotTest.java
@@ -13,6 +13,8 @@ package org.eclipse.linuxtools.internal.docker.ui.wizards;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
+import java.util.concurrent.TimeUnit;
+
 import org.eclipse.jface.dialogs.IDialogConstants;
 import org.eclipse.linuxtools.docker.core.EnumDockerConnectionState;
 import org.eclipse.linuxtools.internal.docker.core.DockerConnection;
@@ -24,7 +26,7 @@ import org.eclipse.linuxtools.internal.docker.ui.testutils.MockDockerClientFacto
 import org.eclipse.linuxtools.internal.docker.ui.testutils.MockDockerConnectionFactory;
 import org.eclipse.linuxtools.internal.docker.ui.testutils.MockImageFactory;
 import org.eclipse.linuxtools.internal.docker.ui.testutils.MockRegistryAccountManagerFactory;
-import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.ButtonAssertion;
+import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.ButtonAssertions;
 import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.ClearConnectionManagerRule;
 import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.CloseShellRule;
 import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.CloseWelcomePageRule;
@@ -104,16 +106,16 @@ public class ImagePullSWTBotTest {
 		// when
 		bot.text(0).setText("jboss/wildfly:latest");
 		// then
-		ButtonAssertion.assertThat(bot.button("Finish")).isNotEnabled();
+		ButtonAssertions.assertThat(bot.button("Finish")).isNotEnabled();
 	}
 
 	@Test
 	public void shouldNotAllowFinishWhenImageNameIsMissing() {
 		// given
 		openPullWizard();
-		// when no data is input for the image name
+		// when no data is input for the images name
 		// then
-		ButtonAssertion.assertThat(bot.button("Finish")).isNotEnabled();
+		ButtonAssertions.assertThat(bot.button("Finish")).isNotEnabled();
 	}
 
 	@Test
@@ -194,12 +196,13 @@ public class ImagePullSWTBotTest {
 		this.client = MockDockerClientFactory.build();
 		final DockerConnection dockerConnection = MockDockerConnectionFactory.from("Test", client)
 				.withDefaultTCPConnectionSettings();
-		assertThat(dockerConnection.getState()).isEqualTo(EnumDockerConnectionState.ESTABLISHED);
 		DockerConnectionManagerUtils.configureConnectionManager(dockerConnection);
 		// when
 		// when opening the "Push Image..." wizard
 		SWTUtils.getTreeItem(dockerExplorerViewBot, "Test").select();
 		// then
+		SWTUtils.wait(1, TimeUnit.SECONDS);
+		assertThat(dockerConnection.getState()).isEqualTo(EnumDockerConnectionState.ESTABLISHED);
 		MenuAssertion.assertThat(dockerExplorerViewBot.bot().tree().contextMenu("Pull...")).isEnabled();
 	}
 
@@ -209,12 +212,12 @@ public class ImagePullSWTBotTest {
 		this.client = MockDockerClientFactory.build();
 		final DockerConnection dockerConnection = MockDockerConnectionFactory.from("Test", client)
 				.withDefaultTCPConnectionSettings();
-		assertThat(dockerConnection.getState()).isEqualTo(EnumDockerConnectionState.ESTABLISHED);
 		DockerConnectionManagerUtils.configureConnectionManager(dockerConnection);
 		// when
 		// when opening the "Push Image..." wizard
 		SWTUtils.getTreeItem(dockerExplorerViewBot, "Test", "Images").select();
 		// then
+		assertThat(dockerConnection.getState()).isEqualTo(EnumDockerConnectionState.ESTABLISHED);
 		MenuAssertion.assertThat(dockerExplorerViewBot.bot().tree().contextMenu("Pull...")).isEnabled();
 	}
 }
diff --git a/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/wizards/ImagePushSWTBotTests.java b/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/wizards/ImagePushSWTBotTests.java
index aa0ea25b2d..2341ba07eb 100644
--- a/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/wizards/ImagePushSWTBotTests.java
+++ b/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/wizards/ImagePushSWTBotTests.java
@@ -28,7 +28,7 @@ import org.eclipse.linuxtools.internal.docker.ui.testutils.MockRegistryAccountMa
 import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.ClearConnectionManagerRule;
 import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.CloseShellRule;
 import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.CloseWelcomePageRule;
-import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.ComboAssertion;
+import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.ComboAssertions;
 import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.DockerConnectionManagerUtils;
 import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.SWTUtils;
 import org.eclipse.linuxtools.internal.docker.ui.views.DockerExplorerView;
@@ -111,9 +111,9 @@ public class ImagePushSWTBotTests {
 		// expand the 'Images' node
 		openPushWizard();
 		// then the registry should be set with the first element available, too
-		ComboAssertion.assertThat(bot.comboBox(0)).itemSelected(AbstractRegistry.DOCKERHUB_REGISTRY);
+		ComboAssertions.assertThat(bot.comboBox(0)).itemSelected(AbstractRegistry.DOCKERHUB_REGISTRY);
 		// and the "Image Name" combo should have a selection
-		ComboAssertion.assertThat(bot.comboBox(1)).itemSelected("foo/bar:latest");
+		ComboAssertions.assertThat(bot.comboBox(1)).itemSelected("foo/bar:latest");
 	}
 
 	@Test
@@ -175,7 +175,7 @@ public class ImagePushSWTBotTests {
 				.build();
 		// when
 		openPushWizard();
-		// when tagging image with '--force'
+		// when tagging images with '--force'
 		bot.checkBox(0).select();
 		// when selecting other registry
 		bot.comboBox(0).setSelection(1);
@@ -198,7 +198,7 @@ public class ImagePushSWTBotTests {
 		openPushWizard();
 		// when selecting other registry
 		bot.comboBox(0).setSelection(1);
-		// when keeping tagged image
+		// when keeping tagged images
 		bot.checkBox(1).select();
 		// when click on Finish
 		bot.button("Finish").click();
@@ -215,7 +215,7 @@ public class ImagePushSWTBotTests {
 	public void shouldPushImageWithNewTagToDockerHub() throws DockerException, InterruptedException {
 		// given
 		openPushWizard();
-		// when providing a new name to the image
+		// when providing a new name to the images
 		bot.comboBox(1).setText("another/name");
 		// when click on Finish
 		bot.button("Finish").click();
@@ -237,7 +237,7 @@ public class ImagePushSWTBotTests {
 		openPushWizard();
 		// when selecting other registry
 		bot.comboBox(0).setSelection(1);
-		// when providing a new name to the image
+		// when providing a new name to the images
 		bot.comboBox(1).setText("another/name");
 		// when click on Finish
 		bot.button("Finish").click();
diff --git a/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/wizards/ImageRunSWTBotTest.java b/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/wizards/ImageRunSWTBotTest.java
index 772ed958a3..e05bbec51d 100644
--- a/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/wizards/ImageRunSWTBotTest.java
+++ b/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/wizards/ImageRunSWTBotTest.java
@@ -28,7 +28,7 @@ import org.eclipse.linuxtools.internal.docker.ui.testutils.MockDockerClientFacto
 import org.eclipse.linuxtools.internal.docker.ui.testutils.MockDockerConnectionFactory;
 import org.eclipse.linuxtools.internal.docker.ui.testutils.MockImageFactory;
 import org.eclipse.linuxtools.internal.docker.ui.testutils.MockImageInfoFactory;
-import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.ButtonAssertion;
+import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.ButtonAssertions;
 import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.ClearConnectionManagerRule;
 import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.CloseShellRule;
 import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.CloseWelcomePageRule;
@@ -88,7 +88,7 @@ public class ImageRunSWTBotTest {
 				.container(MockContainerFactory.name("foo_bar").build()).build();
 		final DockerConnection dockerConnection = MockDockerConnectionFactory.from("Test", client).withDefaultTCPConnectionSettings();
 		DockerConnectionManagerUtils.configureConnectionManager(dockerConnection);
-		// expand the 'Images' node and select the 'foo' image
+		// expand the 'Images' node and select the 'foo' images
 		SWTUtils.getTreeItem(dockerExplorerViewBot, "Test", "Images", "foo").select();
 
 		// when opening the "Run Image..." wizard
@@ -101,7 +101,7 @@ public class ImageRunSWTBotTest {
 		// wait for https://bugs.eclipse.org/bugs/show_bug.cgi?id=482889 to be
 		// able to check the wizard validation message
 		//assertThat(bot.text(WizardMessages.getString("ImageRunSelectionPage.containerWithSameName"))).isNotNull();
-		ButtonAssertion.assertThat(bot.button("Finish")).isNotEnabled();
+		ButtonAssertions.assertThat(bot.button("Finish")).isNotEnabled();
 	}
 
 	@Test
@@ -111,7 +111,7 @@ public class ImageRunSWTBotTest {
 				.container(MockContainerFactory.name("foo_bar").build()).build();
 		final DockerConnection dockerConnection = MockDockerConnectionFactory.from("Test", client).withDefaultTCPConnectionSettings();
 		DockerConnectionManagerUtils.configureConnectionManager(dockerConnection);
-		// expand the 'Images' node and select the 'foo' image
+		// expand the 'Images' node and select the 'foo' images
 		SWTUtils.getTreeItem(dockerExplorerViewBot, "Test", "Images", "foo").select();
 		// when opening the "Run Image..." wizard
 		final SWTBotTree dockerExplorerViewTreeBot = dockerExplorerViewBot.bot().tree();
@@ -126,7 +126,7 @@ public class ImageRunSWTBotTest {
 	@Test
 	public void shouldCreateLaunchConfigurationWhenRunningNamedContainer()
 			throws InterruptedException, DockerException, CoreException {
-		// image to use
+		// images to use
 		final String imageName = "foo/bar:latest";
 		final Image image = MockImageFactory.id("1a2b3c4d5e6f7g").name(imageName).build();
 		final ImageInfo imageInfo = MockImageInfoFactory.volume("/foo/bar")
@@ -146,7 +146,7 @@ public class ImageRunSWTBotTest {
 		final DockerConnection dockerConnection = MockDockerConnectionFactory.from("Test", client).withDefaultTCPConnectionSettings();
 		// configure the Connection Manager
 		DockerConnectionManagerUtils.configureConnectionManager(dockerConnection);
-		// when select image and click on run to open the wizard
+		// when select images and click on run to open the wizard
 		SWTUtils.getTreeItem(dockerExplorerViewBot, "Test", "Images", "foo/bar").select();
 		dockerExplorerViewBot.bot().tree().contextMenu("Run...").click();
 		bot.waitUntil(Conditions.shellIsActive("Run a Docker Image"), TimeUnit.SECONDS.toMillis(1)); //$NON-NLS-1$
diff --git a/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/wizards/NewDockerConnectionSWTBotTest.java b/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/wizards/NewDockerConnectionSWTBotTest.java
index d698efb968..07f1f9b0c7 100644
--- a/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/wizards/NewDockerConnectionSWTBotTest.java
+++ b/containers/org.eclipse.linuxtools.docker.ui.tests/src/org/eclipse/linuxtools/internal/docker/ui/wizards/NewDockerConnectionSWTBotTest.java
@@ -16,22 +16,21 @@ import java.io.IOException;
 
 import org.eclipse.jface.dialogs.IDialogConstants;
 import org.eclipse.jface.wizard.Wizard;
-import org.eclipse.linuxtools.docker.core.EnumDockerConnectionState;
 import org.eclipse.linuxtools.docker.core.IDockerConnection;
 import org.eclipse.linuxtools.internal.docker.core.DockerConnection;
 import org.eclipse.linuxtools.internal.docker.core.SystemUtils;
 import org.eclipse.linuxtools.internal.docker.ui.testutils.MockDockerClientFactory;
 import org.eclipse.linuxtools.internal.docker.ui.testutils.MockDockerConnectionFactory;
 import org.eclipse.linuxtools.internal.docker.ui.testutils.MockDockerConnectionSettingsFinder;
-import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.ButtonAssertion;
-import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.CheckBoxAssertion;
+import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.ButtonAssertions;
+import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.CheckBoxAssertions;
 import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.CloseShellRule;
 import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.CloseWelcomePageRule;
 import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.DockerConnectionManagerUtils;
 import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.RadioAssertion;
 import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.SWTBotTreeItemAssertions;
 import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.SWTUtils;
-import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.TextAssertion;
+import org.eclipse.linuxtools.internal.docker.ui.testutils.swt.TextAssertions;
 import org.eclipse.linuxtools.internal.docker.ui.views.DockerContainersView;
 import org.eclipse.linuxtools.internal.docker.ui.views.DockerExplorerView;
 import org.eclipse.linuxtools.internal.docker.ui.views.DockerImagesView;
@@ -113,7 +112,7 @@ public class NewDockerConnectionSWTBotTest {
 	private IDockerConnection configureTCPConnection(final String connectionName, final String host) {
 		final DockerClient client = MockDockerClientFactory.build();
 		final DockerConnection dockerConnection = MockDockerConnectionFactory.from(connectionName, client)
-				.withTCPConnectionSettings(host, null, EnumDockerConnectionState.ESTABLISHED);
+				.withTCPConnectionSettings(host, null);
 		DockerConnectionManagerUtils.configureConnectionManager(dockerConnection);
 		return dockerConnection;
 	}
@@ -126,21 +125,21 @@ public class NewDockerConnectionSWTBotTest {
 		addConnectionButton.click();
 		// then
 		// Empty Connection name
-		TextAssertion.assertThat(bot.text(0)).isEnabled().isEmpty();
+		TextAssertions.assertThat(bot.text(0)).isEnabled().isEmpty();
 		// "Use custom connection settings" should be enabled and checked
-		CheckBoxAssertion.assertThat(bot.checkBox(0)).isEnabled().isChecked();
+		CheckBoxAssertions.assertThat(bot.checkBox(0)).isEnabled().isChecked();
 		// "Unix socket" radio should be enabled and selected
 		RadioAssertion.assertThat(bot.radio(0)).isEnabled().isSelected();
 		// "Unix socket path" text should be enabled and empty
-		TextAssertion.assertThat(bot.text(1)).isEnabled().isEmpty();
+		TextAssertions.assertThat(bot.text(1)).isEnabled().isEmpty();
 		// "TCP Connection" radio should be enabled but unselected
 		RadioAssertion.assertThat(bot.radio(1)).isEnabled().isNotSelected();
 		// "URI" should be disabled but empty
-		TextAssertion.assertThat(bot.text(2)).isNotEnabled().isEmpty();
+		TextAssertions.assertThat(bot.text(2)).isNotEnabled().isEmpty();
 		// "Enable Auth" checkbox should be unselected and disabled
-		CheckBoxAssertion.assertThat(bot.checkBox(1)).isNotEnabled().isNotChecked();
+		CheckBoxAssertions.assertThat(bot.checkBox(1)).isNotEnabled().isNotChecked();
 		// "Path" for certs should be disabled and empty
-		TextAssertion.assertThat(bot.text(3)).isNotEnabled().isEmpty();
+		TextAssertions.assertThat(bot.text(3)).isNotEnabled().isEmpty();
 	}
 
 	@Test
@@ -151,21 +150,21 @@ public class NewDockerConnectionSWTBotTest {
 		addConnectionButton.click();
 		// then
 		// Connection name
-		TextAssertion.assertThat(bot.text(0)).isEnabled().textEquals("mock");
+		TextAssertions.assertThat(bot.text(0)).isEnabled().textEquals("mock");
 		// "Use custom connection settings" should be enabled but unchecked
-		CheckBoxAssertion.assertThat(bot.checkBox(0)).isEnabled().isNotChecked();
+		CheckBoxAssertions.assertThat(bot.checkBox(0)).isEnabled().isNotChecked();
 		// "Unix socket" radio should be disabled and selected
 		RadioAssertion.assertThat(bot.radio(0)).isNotEnabled().isSelected();
 		// "Unix socket path" text should be disabled and not empty
-		TextAssertion.assertThat(bot.text(1)).isNotEnabled().textEquals("unix:///var/run/docker.sock");
+		TextAssertions.assertThat(bot.text(1)).isNotEnabled().textEquals("unix:///var/run/docker.sock");
 		// "TCP Connection" radio should be unselected and disabled
 		RadioAssertion.assertThat(bot.radio(1)).isNotEnabled().isNotSelected();
 		// "URI" should be disabled and empty
-		TextAssertion.assertThat(bot.text(2)).isNotEnabled().isEmpty();
+		TextAssertions.assertThat(bot.text(2)).isNotEnabled().isEmpty();
 		// "Enable Auth" checkbox should be unselected and disabled
-		CheckBoxAssertion.assertThat(bot.checkBox(1)).isNotEnabled().isNotChecked();
+		CheckBoxAssertions.assertThat(bot.checkBox(1)).isNotEnabled().isNotChecked();
 		// "Path" for certs should be disabled but not empty
-		TextAssertion.assertThat(bot.text(3)).isNotEnabled().isEmpty();
+		TextAssertions.assertThat(bot.text(3)).isNotEnabled().isEmpty();
 	}
 
 	@Test
@@ -177,21 +176,21 @@ public class NewDockerConnectionSWTBotTest {
 		bot.waitUntil(Conditions.shellIsActive(WizardMessages.getString("NewDockerConnection.title"))); //$NON-NLS-1$
 		// then
 		// Connection name
-		TextAssertion.assertThat(bot.text(0)).isEnabled().textEquals("mock");
+		TextAssertions.assertThat(bot.text(0)).isEnabled().textEquals("mock");
 		// "Use custom connection settings" should be enabled but unchecked
-		CheckBoxAssertion.assertThat(bot.checkBox(0)).isEnabled().isNotChecked();
+		CheckBoxAssertions.assertThat(bot.checkBox(0)).isEnabled().isNotChecked();
 		// "Unix socket" radio should be disabled and unselected
 		RadioAssertion.assertThat(bot.radio(0)).isNotEnabled().isNotSelected();
 		// "Unix socket path" text should be disabled and not empty
-		TextAssertion.assertThat(bot.text(1)).isNotEnabled().isEmpty();
+		TextAssertions.assertThat(bot.text(1)).isNotEnabled().isEmpty();
 		// "TCP Connection" radio should be selected but diabled
 		RadioAssertion.assertThat(bot.radio(1)).isNotEnabled().isSelected();
 		// "URI" should be disabled but not empty
-		TextAssertion.assertThat(bot.text(2)).isNotEnabled().textEquals("https://1.2.3.4:1234");
+		TextAssertions.assertThat(bot.text(2)).isNotEnabled().textEquals("https://1.2.3.4:1234");
 		// "Enable Auth" checkbox should be selected but disabled
-		CheckBoxAssertion.assertThat(bot.checkBox(1)).isNotEnabled().isChecked();
+		CheckBoxAssertions.assertThat(bot.checkBox(1)).isNotEnabled().isChecked();
 		// "Path" for certs should be disabled but not empty
-		TextAssertion.assertThat(bot.text(3)).isNotEnabled().textEquals("/path/to/certs");
+		TextAssertions.assertThat(bot.text(3)).isNotEnabled().textEquals("/path/to/certs");
 	}
 
 	@Test
@@ -224,7 +223,7 @@ public class NewDockerConnectionSWTBotTest {
 		bot.text(0).setText("foo");
 		// then the wizard should not allow for completion because a connection
 		// with the connection settings already exists.
-		ButtonAssertion.assertThat(bot.button("Finish")).isNotEnabled();
+		ButtonAssertions.assertThat(bot.button("Finish")).isNotEnabled();
 	}
 
 	@Test
@@ -240,7 +239,7 @@ public class NewDockerConnectionSWTBotTest {
 		bot.text(0).setText("foo");
 		// then the wizard should not allow for completion because a connection
 		// with the connection settings already exists.
-		ButtonAssertion.assertThat(bot.button("Finish")).isNotEnabled();
+		ButtonAssertions.assertThat(bot.button("Finish")).isNotEnabled();
 	}
 
 	@Test
@@ -259,7 +258,7 @@ public class NewDockerConnectionSWTBotTest {
 		bot.text(1).setText(otherDockerSocketTmpPath);
 		// then the wizard should not allow for completion because a connection
 		// with the connection settings already exists.
-		ButtonAssertion.assertThat(bot.button("Finish")).isEnabled();
+		ButtonAssertions.assertThat(bot.button("Finish")).isEnabled();
 	}
 
 	@Test
@@ -277,7 +276,7 @@ public class NewDockerConnectionSWTBotTest {
 		bot.text(2).setText("https://bar:1234");
 		// then the wizard should not allow for completion because a connection
 		// with the connection settings already exists.
-		ButtonAssertion.assertThat(bot.button("Finish")).isEnabled();
+		ButtonAssertions.assertThat(bot.button("Finish")).isEnabled();
 	}
 
 	@Test
@@ -306,21 +305,21 @@ public class NewDockerConnectionSWTBotTest {
 		addConnectionButton.click();
 		// then
 		// Connection name
-		TextAssertion.assertThat(bot.text(0)).isEnabled().isEmpty();
+		TextAssertions.assertThat(bot.text(0)).isEnabled().isEmpty();
 		// "Use custom connection settings" should be enabled and checked
-		CheckBoxAssertion.assertThat(bot.checkBox(0)).isEnabled().isChecked();
+		CheckBoxAssertions.assertThat(bot.checkBox(0)).isEnabled().isChecked();
 		// "Unix socket" radio should be enabled and unselected
 		RadioAssertion.assertThat(bot.radio(0)).isEnabled().isNotSelected();
 		// "Unix socket path" text should be disabled and empty
-		TextAssertion.assertThat(bot.text(1)).isNotEnabled().isEmpty();
+		TextAssertions.assertThat(bot.text(1)).isNotEnabled().isEmpty();
 		// "TCP Connection" radio should be enabled and selected
 		RadioAssertion.assertThat(bot.radio(1)).isEnabled().isSelected();
 		// "URI" should be enabled and not empty
-		TextAssertion.assertThat(bot.text(2)).isEnabled().textEquals("https://1.2.3.4:1234");
+		TextAssertions.assertThat(bot.text(2)).isEnabled().textEquals("https://1.2.3.4:1234");
 		// "Enable Auth" checkbox should be enabled and selected
-		CheckBoxAssertion.assertThat(bot.checkBox(1)).isEnabled().isChecked();
+		CheckBoxAssertions.assertThat(bot.checkBox(1)).isEnabled().isChecked();
 		// "Path" for certs should be enabled and not empty
-		TextAssertion.assertThat(bot.text(3)).isEnabled().textEquals("/path/to/certs");
+		TextAssertions.assertThat(bot.text(3)).isEnabled().textEquals("/path/to/certs");
 
 		// Close wizard
 		bot.button("Cancel").click();
diff --git a/containers/org.eclipse.linuxtools.docker.ui/plugin.xml b/containers/org.eclipse.linuxtools.docker.ui/plugin.xml
index 2ed0f3989c..a0a066bfea 100644
--- a/containers/org.eclipse.linuxtools.docker.ui/plugin.xml
+++ b/containers/org.eclipse.linuxtools.docker.ui/plugin.xml
@@ -146,7 +146,7 @@
             name="%IntermediateImagesViewFilter.name">
       </commonFilter>
       <commonFilter
-            activeByDefault="true"
+            activeByDefault="false"
             class="org.eclipse.linuxtools.internal.docker.ui.views.DanglingImagesViewerFilter"
             id="org.eclipse.linuxtools.docker.ui.danglingImagesFilter"
             name="%DanglingImagesViewFilter.name">
diff --git a/containers/org.eclipse.linuxtools.docker.ui/src/org/eclipse/linuxtools/internal/docker/ui/views/IntermediateImagesViewerFilter.java b/containers/org.eclipse.linuxtools.docker.ui/src/org/eclipse/linuxtools/internal/docker/ui/views/IntermediateImagesViewerFilter.java
index 74bfdc848a..1a4a7e5042 100644
--- a/containers/org.eclipse.linuxtools.docker.ui/src/org/eclipse/linuxtools/internal/docker/ui/views/IntermediateImagesViewerFilter.java
+++ b/containers/org.eclipse.linuxtools.docker.ui/src/org/eclipse/linuxtools/internal/docker/ui/views/IntermediateImagesViewerFilter.java
@@ -14,7 +14,6 @@ package org.eclipse.linuxtools.internal.docker.ui.views;
 import org.eclipse.jface.viewers.Viewer;
 import org.eclipse.jface.viewers.ViewerFilter;
 import org.eclipse.linuxtools.docker.core.IDockerImage;
-import org.eclipse.linuxtools.docker.core.IDockerImageHierarchyNode;
 
 /**
  * @author xcoulon
@@ -30,10 +29,12 @@ public class IntermediateImagesViewerFilter extends ViewerFilter {
 	}
 
 	/**
-	 * @return {@code false} when the given element is an {@link IDockerImage} and it is an intermediate image. Returns {@code true} otherwise.
+	 * @return {@code false} when the given element is an {@link IDockerImage}
+	 *         and it is an intermediate image. Returns {@code true} otherwise.
 	 * 
-	 * @see IDockerImage#isTopLevel()
-	 * @see org.eclipse.jface.viewers.ViewerFilter#select(org.eclipse.jface.viewers.Viewer, java.lang.Object, java.lang.Object)
+	 * @see IDockerImage#isIntermediateImage()
+	 * @see org.eclipse.jface.viewers.ViewerFilter#select(org.eclipse.jface.viewers.Viewer,
+	 *      java.lang.Object, java.lang.Object)
 	 */
 	@Override
 	public boolean select(Viewer viewer, Object parentElement, Object element) {