[maven-release-plugin] prepare release swt-1.1.6

[maven-release-plugin] prepare for next development iteration
[maven-release-plugin] prepare release socket-1.1.13
2018-10-27 16:39:10 -04:00 · 2018-10-27 15:58:12 -04:00 · 2018-10-27 15:58:09 -04:00 · 2018-10-27 14:54:06 -04:00 · 2018-10-27 14:54:03 -04:00 · 2018-10-27 14:42:49 -04:00
53 changed files with 2151 additions and 692 deletions
--- a/65
+++ b/65
@@ -0,0 +1,65 @@
+pipeline {
+  agent any
+  stages {
+    stage('Site GCLC') {
+      when {
+        tag "gclc-*"
+      }
+      steps {
+        dir('gclc') {
+          sh 'mvn site:site'
+          sh 'mkdir -p /home/maven-sites/net/bigeon/gclc'
+          sh 'cp -r target/site /home/maven-sites/net/bigeon/gclc/gclc'
+        }
+      }
+    }
+    stage('Site GCLC-Socket') {
+      when {
+        tag "socket-*"
+      }
+      steps {
+        dir('gclc-socket') {
+          sh 'mvn site:site'
+          sh 'mkdir -p /home/maven-sites/net/bigeon/gclc'
+          sh 'cp -r target/site /home/maven-sites/net/bigeon/gclc/gclc-socket'
+        }
+      }
+    }
+    stage('Site GCLC-Swt') {
+      when {
+        tag "swt-*"
+      }
+      steps {
+        dir('gclc-swt') {
+          sh 'mvn site:site'
+          sh 'mkdir -p /home/maven-sites/net/bigeon/gclc'
+          sh 'cp -r target/site /home/maven-sites/net/bigeon/gclc/gclc-swt'
+        }
+      }
+    }
+    stage('Site GCLC-Processes') {
+      when {
+        tag "process-*"
+      }
+      steps {
+        dir('gclc-process') {
+          sh 'mvn site:site'
+          sh 'mkdir -p /home/maven-sites/net/bigeon/gclc'
+          sh 'cp -r target/site /home/maven-sites/net/bigeon/gclc/gclc-process'
+        }
+      }
+    }
+    stage('Site GCLC-System') {
+      when {
+        tag "system-*"
+      }
+      steps {
+        dir('gclc.system') {
+          sh 'mvn site:site'
+          sh 'mkdir -p /home/maven-sites/net/bigeon/gclc'
+          sh 'cp -r target/site /home/maven-sites/net/bigeon/gclc/gclc-system'
+        }
+      }
+    }
+  }
+}
--- a/gclc-process/pom.xml
+++ b/gclc-process/pom.xml
@@ -1,64 +1,23 @@
-
-<!-- process, Distribution repositories and basic setup for Emmanuel Bigeon projects                                   -->
-<!-- Copyright (C) 2014-2018 E. Bigeon                      -->
-<!-- mailto:emmanuel@bigeon.fr                                                           -->
-<!--                                                                           -->
-<!-- This software is governed by the CeCILL license under French law and      -->
-<!-- abiding by the rules of distribution of free software.  You can  use,     -->
-<!-- modify and/or redistribute the software under the terms of the CeCILL     -->
-<!-- license as circulated by CEA, CNRS and INRIA at the following URL         -->
-<!-- "http://www.cecill.info".                                                 -->
-<!--                                                                           -->
-<!-- As a counterpart to the access to the source code and  rights to copy,    -->
-<!-- modify and redistribute granted by the license, users are provided only   -->
-<!-- with a limited warranty  and the software's author,  the holder of the    -->
-<!-- economic rights,  and the successive licensors  have only  limited        -->
-<!-- liability.                                                                -->
-<!--                                                                           -->
-<!-- In this respect, the user's attention is drawn to the risks associated    -->
-<!-- with loading,  using,  modifying and/or developing or reproducing the     -->
-<!-- software by the user in light of its specific status of free software,    -->
-<!-- that may mean  that it is complicated to manipulate,  and  that  also     -->
-<!-- therefore means  that it is reserved for developers  and  experienced     -->
-<!-- professionals having in-depth computer knowledge. Users are therefore     -->
-<!-- encouraged to load and test the software's suitability as regards their   -->
-<!-- requirements in conditions enabling the security of their systems and/or  -->
-<!-- data to be ensured and,  more generally, to use and operate it in the     -->
-<!-- same conditions as regards security.                                      -->
-<!--                                                                           -->
-<!-- The fact that you are presently reading this means that you have had      -->
-<!-- knowledge of the CeCILL license and that you accept its terms.            -->
-
 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
-  <modelVersion>4.0.0</modelVersion>
+	<modelVersion>4.0.0</modelVersion>
+	<parent>
+		<groupId>net.bigeon.config</groupId>
+		<artifactId>ebigeon-config</artifactId>
+		<version>1.8.21</version>
+	</parent>

-  <groupId>net.bigeon.gclc</groupId>
-  <artifactId>process</artifactId>
-  <version>0.0.4-SNAPSHOT</version>
-  <packaging>jar</packaging>
-
-  <name>process</name>
-  <url>http://maven.apache.org</url>
-
-  <properties>
-    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
-    <copyright.email>emmanuel@bigeon.fr</copyright.email>
-    <license.licenseName>cecill_2.1</license.licenseName>
-  </properties>
-
-  <parent>
-    <groupId>net.bigeon.config</groupId>
-    <artifactId>ebigeon-config</artifactId>
-    <version>1.8.12</version>
-  </parent>
-  <dependencies>
-    <dependency>
-      <groupId>net.bigeon</groupId>
-      <artifactId>gclc</artifactId>
-      <version>2.0.9</version>
-    </dependency>
-  </dependencies>
+	<groupId>net.bigeon.gclc</groupId>
+	<artifactId>process</artifactId>
+	<version>0.0.5-SNAPSHOT</version>
+	<packaging>jar</packaging>

+	<name>process</name>
+	<description>A library to handle processes in a generic console application.</description><url>https://bigeon.net/projects/gclc.html</url>
+	<inceptionYear>2017</inceptionYear>
+	<organization>
+		<name>Bigeon</name>
+		<url>https://bigeon.net</url>
+	</organization>
 	<licenses>
 		<license>
 			<distribution>manual</distribution>
@@ -66,15 +25,7 @@
 			<url>https://cecill.info/licences/Licence_CeCILL_V2.1-en.html</url>
 		</license>
 	</licenses>
-	<reporting>
-		<plugins>
-			<plugin>
-				<groupId>com.github.sevntu-checkstyle</groupId>
-				<artifactId>dsm-maven-plugin</artifactId>
-				<version>2.2.0</version>
-			</plugin>
-		</plugins>
-	</reporting>
+
 	<developers>
 		<developer>
 			<email>emmanuel@bigeon.fr</email>
@@ -85,9 +36,35 @@
 			</roles>
 		</developer>
 	</developers>
-
-  <scm>
-    <tag>HEAD</tag>
-    <developerConnection>scm:git:gogs@git.code.bigeon.net:emmanuel/gclc.git</developerConnection>
-  </scm>
+	<scm>
+		<tag>HEAD</tag>
+		<developerConnection>scm:git:gogs@git.code.bigeon.net:emmanuel/gclc.git</developerConnection>
+	</scm>
+	<properties>
+		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+		<copyright.email>emmanuel@bigeon.fr</copyright.email>
+		<license.licenseName>cecill_2.1</license.licenseName>
+	</properties>
+	<dependencies>
+		<dependency>
+			<groupId>net.bigeon</groupId>
+			<artifactId>gclc</artifactId>
+			<version>2.0.11</version>
+		</dependency>
+	</dependencies>
+	<reporting>
+		<plugins>
+			<plugin>
+				<groupId>org.apache.maven.plugins</groupId>
+				<artifactId>maven-javadoc-plugin</artifactId>
+				<version>2.10.3</version>
+			</plugin>
+			<plugin>
+				<groupId>com.github.sevntu-checkstyle</groupId>
+				<artifactId>dsm-maven-plugin</artifactId>
+				<version>2.2.0</version>
+			</plugin>
+		</plugins>
+	</reporting>
+	
 </project>
--- a/gclc-process/src/main/java/net/bigeon/gclc/process/CommandForeground.java
+++ b/gclc-process/src/main/java/net/bigeon/gclc/process/CommandForeground.java
@@ -69,6 +69,8 @@ package net.bigeon.gclc.process;
 * #L%
 */
 import java.util.List;
+import java.util.logging.Level;
+import java.util.logging.Logger;

 import net.bigeon.gclc.command.CommandParameters;
 import net.bigeon.gclc.command.ParametrizedCommand;
@@ -92,28 +94,33 @@ import net.bigeon.gclc.manager.ConsoleOutput;
 * @author Emmanuel Bigeon */
 public class CommandForeground extends ParametrizedCommand {

+    /** Number of milliseconds in a second. */
+    private static final int    MILLIS_IN_A_SEC = 1000;
+    /** The class logger. */
+    private static final Logger LOGGER          = Logger
+            .getLogger(CommandForeground.class.getName());
+
+    /** The task pool to fetch task from. */
    private final TaskPool pool;

    /** Add the fork command.
     *
     * @param name the command name
     * @param pool The pool to get joinable tasks from */
-    public CommandForeground(final String name, TaskPool pool) {
+    public CommandForeground(final String name, final TaskPool pool) {
        super(name, false);
        this.pool = pool;
        addParameters();
    }

-    /**
-     *
-     */
+    /** Add the parameters of the command. */
    private void addParameters() {
        try {
            addStringParameter("pid", false);
            addStringParameter("delai", false);
        } catch (final InvalidParameterException e) {
-            // TODO Auto-generated catch block
-            e.printStackTrace();
+            // Cannot be reached unless GCLC base framework has an error
+            LOGGER.log(Level.SEVERE, "unexpected parameter error!", e);
        }
    }

@@ -125,26 +132,34 @@ public class CommandForeground extends ParametrizedCommand {
    protected void doExecute(final ConsoleOutput out, final ConsoleInput in,
            final CommandParameters parameters) throws CommandRunException {
        String string = parameters.get("pid");
-        final List<String> additionals = parameters.getAdditionals();
-        if (string == null && !additionals.isEmpty()) {
+        if (string == null) {
+            final List<String> additionals = parameters.getAdditionals();
+            if (additionals.isEmpty()) {
+                throw new CommandRunException(CommandRunExceptionType.USAGE,
+                        "Missing process id");
+            }
            string = additionals.get(0);
        }
-        if (string == null) {
+        Integer pid;
+        try {
+            pid = Integer.valueOf(string);
+        } catch (final NumberFormatException e) {
            throw new CommandRunException(CommandRunExceptionType.USAGE,
-                    "Missing process id");
+                    "PID should be an integer");
        }
        // Join the command.
-        final Task cmd = pool.get(string);
+        final Task cmd = pool.get(pid);
        if (!(cmd instanceof ForkTask)) {
            throw new CommandRunException("No such forked process");
        }
        long delai = 0;
        final String delaiOpt = parameters.get("delai");
        if (delaiOpt != null) {
-            delai = Long.parseLong(delaiOpt) * 1000;
+            delai = Long.parseLong(delaiOpt) * MILLIS_IN_A_SEC;
        }
        if (delai < 0) {
-            throw new CommandRunException("Join delai cannot be negative");
+            throw new CommandRunException(CommandRunExceptionType.USAGE,
+                    "Join delai cannot be negative");
        }
        ((ForkTask) cmd).join(out, in, delai);
    }
--- a/gclc-process/src/main/java/net/bigeon/gclc/process/CommandFork.java
+++ b/gclc-process/src/main/java/net/bigeon/gclc/process/CommandFork.java
@@ -1,40 +1,10 @@
-/*
- * process, Distribution repositories and basic setup for Emmanuel Bigeon projects
- * Copyright (C) 2014-2018 E. Bigeon
- * mailto:emmanuel@bigeon.fr
- *
- * This software is governed by the CeCILL license under French law and
- * abiding by the rules of distribution of free software.  You can  use,
- * modify and/or redistribute the software under the terms of the CeCILL
- * license as circulated by CEA, CNRS and INRIA at the following URL
- * "http://www.cecill.info".
- *
- * As a counterpart to the access to the source code and  rights to copy,
- * modify and redistribute granted by the license, users are provided only
- * with a limited warranty  and the software's author,  the holder of the
- * economic rights,  and the successive licensors  have only  limited
- * liability.
- *
- * In this respect, the user's attention is drawn to the risks associated
- * with loading,  using,  modifying and/or developing or reproducing the
- * software by the user in light of its specific status of free software,
- * that may mean  that it is complicated to manipulate,  and  that  also
- * therefore means  that it is reserved for developers  and  experienced
- * professionals having in-depth computer knowledge. Users are therefore
- * encouraged to load and test the software's suitability as regards their
- * requirements in conditions enabling the security of their systems and/or
- * data to be ensured and,  more generally, to use and operate it in the
- * same conditions as regards security.
- *
- * The fact that you are presently reading this means that you have had
- * knowledge of the CeCILL license and that you accept its terms.
- */
 /**
 * gclc-process:net.bigeon.gclc.process.CommandFork.java
 * Created on: Nov 13, 2017
 */
 package net.bigeon.gclc.process;

+import java.text.MessageFormat;
 /*-
 * #%L
 * process
@@ -74,6 +44,7 @@ import net.bigeon.gclc.command.Command;
 import net.bigeon.gclc.command.ICommand;
 import net.bigeon.gclc.command.ICommandProvider;
 import net.bigeon.gclc.exception.CommandRunException;
+import net.bigeon.gclc.exception.CommandRunExceptionType;
 import net.bigeon.gclc.manager.ConsoleInput;
 import net.bigeon.gclc.manager.ConsoleOutput;

@@ -91,15 +62,19 @@ import net.bigeon.gclc.manager.ConsoleOutput;
 * @author Emmanuel Bigeon */
 public class CommandFork extends Command {

+    /** The task pool containing the tasks. */
    private final TaskPool         pool;
+    /** The command provider. */
    private final ICommandProvider provider;
+    /** The number of lines stored in the commands. */
    private final int              lines;

    /** Add the fork command.
     *
     * @param name the command name
     * @param provider the allowed command collection */
-    public CommandFork(final String name, ICommandProvider provider, TaskPool pool) {
+    public CommandFork(final String name, final ICommandProvider provider,
+                       final TaskPool pool) {
        this(name, provider, pool, -1);
    }

@@ -107,24 +82,33 @@ public class CommandFork extends Command {
     *
     * @param name the command name
     * @param provider the allowed command collection */
-    public CommandFork(final String name, ICommandProvider provider, TaskPool pool,
-                       int lines) {
+    public CommandFork(final String name, final ICommandProvider provider,
+                       final TaskPool pool, final int lines) {
        super(name);
        this.provider = provider;
        this.pool = pool;
        this.lines = lines;
    }

+    /* (non-Javadoc)
+     * @see net.bigeon.gclc.command.ICommand#execute(net.bigeon.gclc.manager.
+     * ConsoleOutput, net.bigeon.gclc.manager.ConsoleInput, java.lang.String[]) */
    @Override
-    public void execute(final ConsoleOutput out, final ConsoleInput in, String... args)
-            throws CommandRunException {
+    public void execute(final ConsoleOutput out, final ConsoleInput in,
+            final String... args) throws CommandRunException {
        if (args.length < 1) {
-            throw new CommandRunException("No command to fork");
+            throw new CommandRunException(CommandRunExceptionType.USAGE,
+                    "No command to fork");
+        }
+        final String string = args[0];
+        final ICommand cmd = provider.get(string);
+        if (cmd == null) {
+            throw new CommandRunException(CommandRunExceptionType.USAGE,
+                    MessageFormat.format("No such command {0}", string));
        }
-        final ICommand cmd = provider.get(args[0]);
        final String[] inner = Arrays.copyOfRange(args, 1, args.length);
        final ForkTask task = new ForkCommandTask(cmd, inner, lines);
-        final Thread th = new Thread(task);
+        final Thread th = new Thread(task, MessageFormat.format("fork [{0}]", string));
        pool.add(task);
        th.start();
    }
--- a/gclc-process/src/main/java/net/bigeon/gclc/process/ForkTask.java
+++ b/gclc-process/src/main/java/net/bigeon/gclc/process/ForkTask.java
@@ -77,23 +77,30 @@ import net.bigeon.gclc.manager.ConsoleOutput;
 import net.bigeon.gclc.process.io.ConnectingConsoleInput;
 import net.bigeon.gclc.process.io.ConnectingConsoleOutput;

-/**
- * <p>
- * TODO
+/** A task that is made to run into a thread.
 *
 * @author Emmanuel Bigeon */
 public abstract class ForkTask implements Task {

+    /** THe listeners. */
    private final Set<InterruptionListener> listeners = new HashSet<>();
-    private boolean                         running   = false;
-
-    protected final ConnectingConsoleInput  in      = new ConnectingConsoleInput();
+    /** The running state. */
+    private boolean                         running   = true;
+    /** The running state. */
+    private boolean                         started   = false;
+    /** The connecting input for this task */
+    protected final ConnectingConsoleInput  in        = new ConnectingConsoleInput();
+    /** The connecting output for this task */
    protected final ConnectingConsoleOutput out;
+    /** The exception of the run. */
    private CommandRunException             exception;
-    private final Object                    runLock = new Object();
+    /** The synchronization lock. */
+    private final Object                    runLock   = new Object();

-    /** @param lines the number of print to store in the output */
-    public ForkTask(int lines) {
+    /** Create the task.
+     * 
+     * @param lines the number of print to store in the output */
+    public ForkTask(final int lines) {
        out = new ConnectingConsoleOutput(ConnectingConsoleOutput.PERSIST, lines);
    }

@@ -128,10 +135,13 @@ public abstract class ForkTask implements Task {
        }
    }

-    /** @param out the console output
+    /** Join the task.
+     * 
+     * @param out the console output
     * @param in the console input
-     * @param timeout the maximal wait (0 for ever) */
-    public final void join(final ConsoleOutput out, final ConsoleInput in, long timeout) {
+     * @param timeout the maximal time to join for (0 for ever) */
+    public final void join(final ConsoleOutput out, final ConsoleInput in,
+            final long timeout) {
        synchronized (runLock) {
            this.out.connect(out);
            this.in.connect(in);
@@ -140,7 +150,6 @@ public abstract class ForkTask implements Task {
                    runLock.wait(timeout);
                }
            } catch (final InterruptedException e) {
-                // TODO log.
                Thread.currentThread().interrupt();
            }
            this.out.disconnect();
@@ -162,7 +171,7 @@ public abstract class ForkTask implements Task {
    @Override
    public final void run() {
        synchronized (runLock) {
-            running = true;
+            started = true;
        }
        try {
            doRun();
@@ -185,4 +194,11 @@ public abstract class ForkTask implements Task {
            runLock.notifyAll();
        }
    }
+
+    /** @return the started */
+    public boolean isStarted() {
+        synchronized (runLock) {
+            return started;
+        }
+    }
 }
--- a/gclc-process/src/main/java/net/bigeon/gclc/process/InterruptionListener.java
+++ b/gclc-process/src/main/java/net/bigeon/gclc/process/InterruptionListener.java
@@ -68,9 +68,10 @@ package net.bigeon.gclc.process;
 * knowledge of the CeCILL license and that you accept its terms.
 * #L%
 */
-/** A listener for interruption
+/** A listener for interruption.
 *
 * @author Emmanuel Bigeon */
+@FunctionalInterface
 public interface InterruptionListener {
    /** Notification of an interuption of a listened object */
    void interrupted();
--- a/gclc-process/src/main/java/net/bigeon/gclc/process/ProcessClear.java
+++ b/gclc-process/src/main/java/net/bigeon/gclc/process/ProcessClear.java
@@ -69,7 +69,6 @@ package net.bigeon.gclc.process;
 * #L%
 */
 import net.bigeon.gclc.command.Command;
-import net.bigeon.gclc.exception.CommandRunException;
 import net.bigeon.gclc.manager.ConsoleInput;
 import net.bigeon.gclc.manager.ConsoleOutput;

@@ -92,28 +91,27 @@ public final class ProcessClear extends Command {
     * ConsoleOutput, fr.bigeon.gclc.manager.ConsoleInput, java.lang.String[]) */
    @Override
    public void execute(final ConsoleOutput out, final ConsoleInput in,
-            final String... args) throws CommandRunException {
-        for (final String id : pool.getPIDs()) {
+            final String... args) {
+        for (final Integer id : pool.getPIDs()) {
            if (!pool.get(id).isRunning()) {
                pool.remove(id);
            }
        }
-        return;
    }

    /* (non-Javadoc)
     * @see fr.bigeon.gclc.command.ICommand#tip() */
-    @SuppressWarnings("nls")
    @Override
    public String tip() {
-        return "Request a process to stop (softly)";
+        return "Remove non running processes from pool";
    }

    /* (non-Javadoc)
     * @see fr.bigeon.gclc.command.Command#usageDetail() */
    @Override
    protected String usageDetail() {
-        return null;
+        return "  All processes in the pool have their running status checked and the "
+                + "non running ones are removed from the list of tasks.";
    }

 }
--- a/gclc-process/src/main/java/net/bigeon/gclc/process/ProcessKill.java
+++ b/gclc-process/src/main/java/net/bigeon/gclc/process/ProcessKill.java
@@ -70,6 +70,7 @@ package net.bigeon.gclc.process;
 */
 import net.bigeon.gclc.command.Command;
 import net.bigeon.gclc.exception.CommandRunException;
+import net.bigeon.gclc.exception.CommandRunExceptionType;
 import net.bigeon.gclc.manager.ConsoleInput;
 import net.bigeon.gclc.manager.ConsoleOutput;

@@ -93,12 +94,15 @@ public final class ProcessKill extends Command {
    @Override
    public void execute(final ConsoleOutput out, final ConsoleInput in,
            final String... args) throws CommandRunException {
-        pool.get(args[0]).setRunning(false);
+        if (args.length < 1) {
+            throw new CommandRunException(CommandRunExceptionType.USAGE,
+                    "A pid should be specified.");
+        }
+        pool.get(Integer.parseInt(args[0])).setRunning(false);
    }

    /* (non-Javadoc)
     * @see fr.bigeon.gclc.command.ICommand#tip() */
-    @SuppressWarnings("nls")
    @Override
    public String tip() {
        return "Request a process to stop (softly)";
@@ -108,7 +112,13 @@ public final class ProcessKill extends Command {
     * @see fr.bigeon.gclc.command.Command#usageDetail() */
    @Override
    protected String usageDetail() {
-        return null;
+        return "  <pid> is the identification of the process to request the stop to in the pool";
    }

+    /* (non-Javadoc)
+     * @see net.bigeon.gclc.command.Command#usagePattern() */
+    @Override
+    protected String usagePattern() {
+        return super.usagePattern() + " <pid>";
+    }
 }
--- a/gclc-process/src/main/java/net/bigeon/gclc/process/ProcessList.java
+++ b/gclc-process/src/main/java/net/bigeon/gclc/process/ProcessList.java
@@ -99,9 +99,9 @@ public final class ProcessList extends Command {
    @Override
    public void execute(final ConsoleOutput out, final ConsoleInput in,
            final String... args) throws CommandRunException {
-        final ArrayList<String> pids = new ArrayList<>(pool.getPIDs());
+        final ArrayList<Integer> pids = new ArrayList<>(pool.getPIDs());
        Collections.sort(pids);
-        for (final String string : pids) {
+        for (final Integer string : pids) {
            try {
                out.println(MessageFormat.format("{0}\t{1}", string, //$NON-NLS-1$
                        pool.get(string).getName()));
@@ -115,7 +115,6 @@ public final class ProcessList extends Command {

    /* (non-Javadoc)
     * @see fr.bigeon.gclc.command.ICommand#tip() */
-    @SuppressWarnings("nls")
    @Override
    public String tip() {
        return "List all processes";
@@ -125,7 +124,7 @@ public final class ProcessList extends Command {
     * @see fr.bigeon.gclc.command.Command#usageDetail() */
    @Override
    protected String usageDetail() {
-        return null;
+        return "  No argument is considered by this command";
    }

 }
--- a/gclc-process/src/main/java/net/bigeon/gclc/process/TaskPool.java
+++ b/gclc-process/src/main/java/net/bigeon/gclc/process/TaskPool.java
@@ -78,7 +78,7 @@ import java.util.Map;
 * @author Emmanuel Bigeon */
 public final class TaskPool {
    /** The running processes. */
-    private final Map<String, Task> running = new HashMap<>();
+    private final Map<Integer, Task> running = new HashMap<>();
    /** The count for process id. */
    private int                     count   = 0;
    /** The lock for pid attribution synchronization. */
@@ -91,7 +91,7 @@ public final class TaskPool {
    }

    /** Default constructor. */
-    public TaskPool(boolean autoClear) {
+    public TaskPool(final boolean autoClear) {
        this.autoClear = autoClear;
    }

@@ -99,23 +99,20 @@ public final class TaskPool {
     *
     * @param cmd the process
     * @return the pid */
-    public String add(final Task cmd) {
+    public int add(final Task cmd) {
        if (cmd == null) {
            throw new IllegalArgumentException("Task cannot be null"); //$NON-NLS-1$
        }
-        final String pid;
+        final int pid;
        synchronized (lock) {
            pid = getPID();
            running.put(pid, cmd);
        }
        if (autoClear) {
            cmd.addInterruptionListener(new InterruptionListener() {
-                @SuppressWarnings("synthetic-access")
                @Override
                public void interrupted() {
-                    synchronized (lock) {
-                        remove(pid);
-                    }
+                    remove(pid);
                    cmd.rmInterruptionListener(this);
                }
            });
@@ -127,21 +124,21 @@ public final class TaskPool {
     *
     * @param pid the task id
     * @return the task, if any, associated to this id */
-    public Task get(final String pid) {
+    public Task get(final int pid) {
        synchronized (lock) {
-            return running.get(pid);
+            return running.get(Integer.valueOf(pid));
        }
    }

    /** Get the next process id.
     *
     * @return the process id */
-    private String getPID() {
+    private int getPID() {
        synchronized (lock) {
-            String pid;
+            int pid;
            do {
-                pid = Integer.toString(count++);
-            } while (running.containsKey(pid));
+                pid = count++;
+            } while (running.containsKey(Integer.valueOf(pid)));
            return pid;
        }
    }
@@ -149,7 +146,7 @@ public final class TaskPool {
    /** Get the running processes' identifiers.
     *
     * @return the pids */
-    public Collection<String> getPIDs() {
+    public Collection<Integer> getPIDs() {
        return new HashSet<>(running.keySet());
    }

@@ -161,10 +158,10 @@ public final class TaskPool {
    /** Remove a task from the pool
     *
     * @param pid the task id */
-    public void remove(String pid) {
+    public void remove(final int pid) {
        synchronized (lock) {
-            running.remove(pid);
-            count = Math.min(count, Integer.parseInt(pid));
+            running.remove(Integer.valueOf(pid));
+            count = Math.min(count, (pid));
        }
    }

--- a/gclc-process/src/main/java/net/bigeon/gclc/process/TaskSpawner.java
+++ b/gclc-process/src/main/java/net/bigeon/gclc/process/TaskSpawner.java
@@ -86,7 +86,7 @@ public abstract class TaskSpawner extends Command {
    /** @param name the command name
     * @param pool the pool */
    public TaskSpawner(final String name, final TaskPool pool,
-                       ExecutorService threadPool) {
+                       final ExecutorService threadPool) {
        super(name);
        this.pool = pool;
        this.threadPool = threadPool;
@@ -107,8 +107,7 @@ public abstract class TaskSpawner extends Command {
    public final void execute(final ConsoleOutput out, final ConsoleInput in,
            final String... args) throws CommandRunException {
        final Task task = createTask(out, in, args);
-        final Thread th = new Thread(task);
        pool.add(task);
-        threadPool.execute(th);
+        threadPool.execute(task);
    }
 }
--- a/gclc-process/src/main/java/net/bigeon/gclc/process/io/ConnectingConsoleInput.java
+++ b/gclc-process/src/main/java/net/bigeon/gclc/process/io/ConnectingConsoleInput.java
@@ -72,29 +72,52 @@ import java.util.logging.Level;
 import java.util.logging.Logger;

 import net.bigeon.gclc.manager.ConsoleInput;
+import net.bigeon.gclc.tools.ConstantString;
 import net.bigeon.gclc.tools.StringProvider;

-/** @author Emmanuel Bigeon */
+/** A console input that can be connected to and diconnected from.
+ * 
+ * @author Emmanuel Bigeon */
 public final class ConnectingConsoleInput implements ConsoleInput {

-    private static final Logger LOGGER         = Logger
+    /** The empty string provider. */
+    private static final ConstantString EMPTY_STRING = new ConstantString("");
+    /** The logger. */
+    private static final Logger         LOGGER       = Logger
            .getLogger(ConnectingConsoleInput.class.getName());
-    private boolean             close          = false;
-    private StringProvider      prompt;
-    private boolean             prompting;
-    private final Object        promptLock     = new Object();
-    private final Object        connectionLock = new Object();
-    private ConsoleInput        connected;
-    private boolean             disconnection;
+
+    /** If the input is closed. */
+    private boolean        close          = false;
+    /** The prompt string. */
+    private StringProvider prompt         = EMPTY_STRING;
+    /** If the input is currently in prompting state.
+     * <p>
+     * To change it you should be in a promptLock. */
+    private boolean        prompting      = false;
+    /** The synchronization lock for the prompting status. */
+    private final Object   promptLock     = new Object();
+    /** The synchronization lock for the connection status. */
+    private final Object   connectionLock = new Object();
+    /** The connected console input.
+     * <p>
+     * To use it, you should be in a promptLock and connectionLock. */
+    private ConsoleInput   connected      = null;
+    /** The connection state.
+     * <p>
+     * To read or modify it, you should be in a connectionLock synchronize block. */
+    private boolean        disconnection  = false;

    /* (non-Javadoc)
     * @see fr.bigeon.gclc.manager.ConsoleInput#close() */
    @Override
-    public void close() throws IOException {
+    public void close() {
        close = true;
    }

-    public void connect(ConsoleInput input) {
+    /** Connect an input.
+     * 
+     * @param input the input to connect */
+    public void connect(final ConsoleInput input) {
        disconnect();
        synchronized (promptLock) {
            connected = input;
@@ -102,14 +125,15 @@ public final class ConnectingConsoleInput implements ConsoleInput {
        }
    }

+    /** Disconnect the current input. */
    public void disconnect() {
-        synchronized (connectionLock) {
-            if (connected != null) {
-                disconnection = true;
-                synchronized (promptLock) {
+        synchronized (promptLock) {
+            synchronized (connectionLock) {
+                if (connected != null) {
+                    disconnection = true;
                    connected.interruptPrompt();
+                    connected = null;
                }
-                connected = null;
            }
        }
    }
@@ -151,20 +175,27 @@ public final class ConnectingConsoleInput implements ConsoleInput {
    /* (non-Javadoc)
     * @see fr.bigeon.gclc.manager.ConsoleInput#prompt(long) */
    @Override
-    public String prompt(long timeout) throws IOException {
+    public String prompt(final long timeout) throws IOException {
        return prompt(prompt.apply(), timeout);
    }

    /* (non-Javadoc)
     * @see fr.bigeon.gclc.manager.ConsoleInput#prompt(java.lang.String) */
    @Override
-    public String prompt(String message) throws IOException {
+    public String prompt(final String message) throws IOException {
        synchronized (promptLock) {
            prompting = true;
        }
-        while (prompting) {
+        while (true) {
            synchronized (promptLock) {
-                if (connected == null) {
+                if (!prompting) {
+                    return null;
+                }
+                boolean connect;
+                synchronized (connectionLock) {
+                    connect = connected != null;
+                }
+                if (!connect) {
                    try {
                        promptLock.wait();
                    } catch (final InterruptedException e) {
@@ -172,24 +203,25 @@ public final class ConnectingConsoleInput implements ConsoleInput {
                        Thread.currentThread().interrupt();
                    }
                } else {
-                    final String res = connected.prompt(message);
                    synchronized (connectionLock) {
+                        final String res = connected.prompt(message);
                        if (disconnection) {
                            disconnection = false;
                        } else if (prompting) {
                            return res;
+                        } else {
+                            // prompt interrupted, lose the result.
                        }
                    }
                }
            }
        }
-        return null;
    }

    /* (non-Javadoc)
     * @see fr.bigeon.gclc.manager.ConsoleInput#prompt(java.lang.String, long) */
    @Override
-    public String prompt(String message, long timeout) throws IOException {
+    public String prompt(final String message, final long timeout) throws IOException {
        if (timeout <= 0) {
            return prompt(message);
        }
@@ -197,28 +229,37 @@ public final class ConnectingConsoleInput implements ConsoleInput {
        synchronized (promptLock) {
            prompting = true;
        }
-        while (prompting) {
+        do {
            synchronized (promptLock) {
-                if (connected == null) {
+                if (!prompting) {
+                    return null;
+                }
+                boolean connect;
+                synchronized (connectionLock) {
+                    connect = connected != null;
+                }
+                if (!connect) {
                    try {
-                        promptLock.wait();
+                        promptLock.wait(timeout);
                    } catch (final InterruptedException e) {
                        LOGGER.log(Level.WARNING, "Inerruption of console thread", e);
                        Thread.currentThread().interrupt();
                    }
                } else {
-                    final String res = connected.prompt(message,
-                            end - System.currentTimeMillis());
                    synchronized (connectionLock) {
+                        final String res = connected.prompt(message,
+                                end - System.currentTimeMillis());
                        if (disconnection) {
                            disconnection = false;
                        } else if (prompting) {
                            return res;
+                        } else {
+                            // prompt interrupted, lose the result.
                        }
                    }
                }
            }
-        }
+        } while (System.currentTimeMillis() < end);
        return null;
    }

@@ -226,19 +267,14 @@ public final class ConnectingConsoleInput implements ConsoleInput {
     * @see fr.bigeon.gclc.manager.ConsoleInput#setPrompt(java.lang.String) */
    @Override
    public void setPrompt(final String prompt) {
-        this.prompt = new StringProvider() {
-            @Override
-            public String apply() {
-                return prompt;
-            }
-        };
+        this.prompt = new ConstantString(prompt);
    }

    /* (non-Javadoc)
     * @see fr.bigeon.gclc.manager.ConsoleInput#setPrompt(fr.bigeon.gclc.tools.
     * StringProvider) */
    @Override
-    public void setPrompt(StringProvider string) {
+    public void setPrompt(final StringProvider string) {
        prompt = string;
    }
 }
--- a/gclc-process/src/main/java/net/bigeon/gclc/process/io/ConnectingConsoleOutput.java
+++ b/gclc-process/src/main/java/net/bigeon/gclc/process/io/ConnectingConsoleOutput.java
@@ -75,26 +75,37 @@ import java.util.logging.Logger;

 import net.bigeon.gclc.manager.ConsoleOutput;

-/** @author Emmanuel Bigeon */
+/** A console output that can be connected and disconnected from.
+ * 
+ * @author Emmanuel Bigeon */
 public class ConnectingConsoleOutput implements ConsoleOutput {

+    /** The logger. */
    private static final Logger LOGGER  = Logger
            .getLogger(ConnectingConsoleOutput.class.getName());
-    /** If the undelivered message should be stored. */
+    /** The flag indicating that the un-delivered message should be stored. */
    public static final int     QUEUE   = 1;
-    /** If the messages should be stored in all cases. */
+    /** The flag indicating that the messages should be stored in all cases. */
    public static final int     PERSIST = 1 << 1;
+    /** The connected output console */
    private ConsoleOutput       output;
+    /** If the console is closed */
    private boolean             close   = false;

+    /** If the messages should be stored. */
    private final boolean       persistent;
+    /** If the message should be stored until delivery. */
    private final boolean       queued;
+    /** The messages. */
    private final Deque<String> messages;
+    /** The number of stored messages. */
    private final int           lines;

-    /** @param style the type of redirected output
+    /** Create the console output.
+     * 
+     * @param style the type of redirected output
     * @param lines the number of lines to store */
-    public ConnectingConsoleOutput(int style, int lines) {
+    public ConnectingConsoleOutput(final int style, final int lines) {
        super();
        this.lines = lines;
        queued = (style & QUEUE) != 0;
@@ -106,7 +117,10 @@ public class ConnectingConsoleOutput implements ConsoleOutput {
        }
    }

-    private synchronized void addMessage(String text) {
+    /** Add a message.
+     * 
+     * @param text the message */
+    private synchronized void addMessage(final String text) {
        if (persistent || queued && output == null) {
            if (messages.size() == lines) {
                messages.poll();
@@ -130,7 +144,10 @@ public class ConnectingConsoleOutput implements ConsoleOutput {
        close = true;
    }

-    public synchronized void connect(ConsoleOutput output) {
+    /** Connect an output.
+     * 
+     * @param output the output */
+    public synchronized void connect(final ConsoleOutput output) {
        this.output = output;
        for (final String string : messages) {
            try {
@@ -145,6 +162,7 @@ public class ConnectingConsoleOutput implements ConsoleOutput {
        }
    }

+    /** Disconnect the currently connected output. */
    public synchronized void disconnect() {
        output = null;
    }
@@ -159,7 +177,7 @@ public class ConnectingConsoleOutput implements ConsoleOutput {
    /* (non-Javadoc)
     * @see fr.bigeon.gclc.manager.ConsoleOutput#print(java.lang.String) */
    @Override
-    public void print(String text) {
+    public void print(final String text) {
        addMessage(text);
    }

@@ -173,7 +191,7 @@ public class ConnectingConsoleOutput implements ConsoleOutput {
    /* (non-Javadoc)
     * @see fr.bigeon.gclc.manager.ConsoleOutput#println(java.lang.String) */
    @Override
-    public void println(String message) {
+    public void println(final String message) {
        addMessage(message + System.lineSeparator());
    }
 }
--- a/gclc-process/src/main/java/net/bigeon/gclc/process/io/package-info.java
+++ b/gclc-process/src/main/java/net/bigeon/gclc/process/io/package-info.java
@@ -0,0 +1,42 @@
+/** Connecting Input and Output related classes.
+ * <p>
+ * This package groups the Connecting classes that are used to be able to put
+ * the tasks in background and foreground and reattach the actual console input
+ * and outputs to the tasks' ones.
+ * 
+ * @author Emmanuel Bigeon */
+package net.bigeon.gclc.process.io;
+
+/*-
+ * #%L
+ * process
+ * %%
+ * Copyright (C) 2014 - 2018 Bigeon
+ * %%
+ * This software is governed by the CeCILL  license under French law and
+ * abiding by the rules of distribution of free software.  You can  use,
+ * modify and/ or redistribute the software under the terms of the CeCILL
+ * license as circulated by CEA, CNRS and INRIA at the following URL
+ * "http://www.cecill.info".
+ * 
+ * As a counterpart to the access to the source code and  rights to copy,
+ * modify and redistribute granted by the license, users are provided only
+ * with a limited warranty  and the software's author,  the holder of the
+ * economic rights,  and the successive licensors  have only  limited
+ * liability.
+ * 
+ * In this respect, the user's attention is drawn to the risks associated
+ * with loading,  using,  modifying and/or developing or reproducing the
+ * software by the user in light of its specific status of free software,
+ * that may mean  that it is complicated to manipulate,  and  that  also
+ * therefore means  that it is reserved for developers  and  experienced
+ * professionals having in-depth computer knowledge. Users are therefore
+ * encouraged to load and test the software's suitability as regards their
+ * requirements in conditions enabling the security of their systems and/or
+ * data to be ensured and,  more generally, to use and operate it in the
+ * same conditions as regards security.
+ * 
+ * The fact that you are presently reading this means that you have had
+ * knowledge of the CeCILL license and that you accept its terms.
+ * #L%
+ */
--- a/gclc-process/src/main/java/net/bigeon/gclc/process/package-info.java
+++ b/gclc-process/src/main/java/net/bigeon/gclc/process/package-info.java
@@ -0,0 +1,48 @@
+/** This package defines elements for processes inside a console application.
+ * <p>
+ * Processes are tasks that are run in background of the application. One may
+ * want to temporarily connect to such a task (through
+ * {@link net.bigeon.gclc.process.CommandForeground}), or verify it's actual
+ * running status (through {@link net.bigeon.gclc.process.ProcessList}. One may
+ * also want to start such a process (through
+ * {@link net.bigeon.gclc.process.ForkCommandTask}) or close it (through
+ * {@link net.bigeon.gclc.process.ProcessKill}).
+ * <p>
+ * The task list can be managed by several commands to list or clear it.
+ * 
+ * @author Emmanuel Bigeon */
+package net.bigeon.gclc.process;
+
+/*-
+ * #%L
+ * process
+ * %%
+ * Copyright (C) 2014 - 2018 Bigeon
+ * %%
+ * This software is governed by the CeCILL  license under French law and
+ * abiding by the rules of distribution of free software.  You can  use,
+ * modify and/ or redistribute the software under the terms of the CeCILL
+ * license as circulated by CEA, CNRS and INRIA at the following URL
+ * "http://www.cecill.info".
+ * 
+ * As a counterpart to the access to the source code and  rights to copy,
+ * modify and redistribute granted by the license, users are provided only
+ * with a limited warranty  and the software's author,  the holder of the
+ * economic rights,  and the successive licensors  have only  limited
+ * liability.
+ * 
+ * In this respect, the user's attention is drawn to the risks associated
+ * with loading,  using,  modifying and/or developing or reproducing the
+ * software by the user in light of its specific status of free software,
+ * that may mean  that it is complicated to manipulate,  and  that  also
+ * therefore means  that it is reserved for developers  and  experienced
+ * professionals having in-depth computer knowledge. Users are therefore
+ * encouraged to load and test the software's suitability as regards their
+ * requirements in conditions enabling the security of their systems and/or
+ * data to be ensured and,  more generally, to use and operate it in the
+ * same conditions as regards security.
+ * 
+ * The fact that you are presently reading this means that you have had
+ * knowledge of the CeCILL license and that you accept its terms.
+ * #L%
+ */
--- a/gclc-process/src/test/java/net/bigeon/gclc/process/CommandForegroundTest.java
+++ b/gclc-process/src/test/java/net/bigeon/gclc/process/CommandForegroundTest.java
@@ -0,0 +1,90 @@
+/**
+ * 
+ */
+package net.bigeon.gclc.process;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.fail;
+
+import org.junit.Test;
+
+import net.bigeon.gclc.exception.CommandRunException;
+import net.bigeon.gclc.exception.CommandRunExceptionType;
+import net.bigeon.gclc.process.mocks.ForkTaskMock;
+
+/**
+ * @author Emmanuel Bigeon
+ *
+ */
+public class CommandForegroundTest {
+
+    /**
+     * Test method for {@link net.bigeon.gclc.process.CommandForeground#CommandForeground(java.lang.String, net.bigeon.gclc.process.TaskPool)}.
+     */
+    @Test
+    public void testCommandForeground() {
+        final CommandForeground pl = new CommandForeground("fg", new TaskPool());
+        assertEquals("Command name should be kept as specified", "fg",
+                pl.getCommandName());
+    }
+
+    /** Test method for
+     * {@link net.bigeon.gclc.process.CommandForeground#doExecute(net.bigeon.gclc.manager.ConsoleOutput, net.bigeon.gclc.manager.ConsoleInput, net.bigeon.gclc.command.CommandParameters)}.
+     * 
+     * @throws CommandRunException if a valid command failed */
+    @Test
+    public void testDoExecuteConsoleOutputConsoleInputCommandParameters()
+            throws CommandRunException {
+        final TaskPool pool = new TaskPool(false);
+        final CommandForeground pl = new CommandForeground("fg", pool);
+
+        try {
+            pl.execute(null, null, "-delai", "1");
+            fail("PID should be mandatory");
+        } catch (final CommandRunException e) {
+            assertEquals("No pid specified is a usage error",
+                    CommandRunExceptionType.USAGE, e.getType());
+        }
+        try {
+            pl.execute(null, null, "-pid", "invalid", "-delai", "1");
+            fail("PID should be a number");
+        } catch (final CommandRunException e) {
+            assertEquals("Invalid pid specified is a usage error",
+                    CommandRunExceptionType.USAGE, e.getType());
+        }
+        try {
+            pl.execute(null, null, "-pid", "2", "-delai", "1");
+            fail("PID should exist");
+        } catch (final CommandRunException e) {
+            assertEquals("Inexistent pid specified is a run error",
+                    CommandRunExceptionType.EXECUTION, e.getType());
+        }
+
+        final ForkTaskMock cmd = new ForkTaskMock();
+        final int id = pool.add(cmd);
+        pl.execute(null, null, "-pid", Integer.toString(id), "-delai", "1");
+
+        try {
+            pl.execute(null, null, "-pid", Integer.toString(id), "-delai", "-1");
+            fail("delai should be a posistive number");
+        } catch (final CommandRunException e) {
+            assertEquals("Negative delai specified is a usage error",
+                    CommandRunExceptionType.USAGE, e.getType());
+        }
+
+        assert cmd.getRunCall() == 0;
+    }
+
+    /**
+     * Test method for {@link net.bigeon.gclc.process.CommandForeground#tip()}.
+     */
+    @Test
+    public void testTip() {
+        final CommandForeground pl = new CommandForeground("fg", new TaskPool());
+        assertNotNull("Command tip should be defined", pl.tip());
+        assertNotNull("Command usage should be defined", pl.usagePattern());
+        assertNotNull("Command usage should be defined", pl.usageDetail());
+    }
+
+}
--- a/gclc-process/src/test/java/net/bigeon/gclc/process/CommandForkTest.java
+++ b/gclc-process/src/test/java/net/bigeon/gclc/process/CommandForkTest.java
@@ -0,0 +1,86 @@
+/**
+ * 
+ */
+package net.bigeon.gclc.process;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.fail;
+
+import org.junit.Test;
+
+import net.bigeon.gclc.command.ICommandProvider;
+import net.bigeon.gclc.command.SubedCommand;
+import net.bigeon.gclc.exception.CommandRunException;
+import net.bigeon.gclc.exception.CommandRunExceptionType;
+import net.bigeon.gclc.exception.InvalidCommandName;
+import net.bigeon.gclc.process.mocks.CommandMock;
+
+/**
+ * @author Emmanuel Bigeon
+ *
+ */
+public class CommandForkTest {
+
+    /**
+     * Test method for {@link net.bigeon.gclc.process.CommandFork#CommandFork(java.lang.String, net.bigeon.gclc.command.ICommandProvider, net.bigeon.gclc.process.TaskPool)}.
+     */
+    @Test
+    public void testCommandForkStringICommandProviderTaskPool() {
+        final TaskPool pool = new TaskPool();
+        final ICommandProvider provider = new SubedCommand("test");
+        final CommandFork pl = new CommandFork("fork", provider, pool);
+        assertEquals("Command name should be preserved", "fork", pl.getCommandName());
+    }
+
+    /** Test method for
+     * {@link net.bigeon.gclc.process.CommandFork#execute(net.bigeon.gclc.manager.ConsoleOutput, net.bigeon.gclc.manager.ConsoleInput, java.lang.String[])}.
+     * 
+     * @throws InvalidCommandName if the test init failed
+     * @throws CommandRunException */
+    @Test
+    public void testExecute() throws InvalidCommandName, CommandRunException {
+        final TaskPool pool = new TaskPool(false);
+        final ICommandProvider provider = new SubedCommand("test");
+        final CommandFork pl = new CommandFork("fork", provider, pool);
+
+        try {
+            pl.execute(null, null);
+            fail("No command specified should through an exception");
+        } catch (final CommandRunException e) {
+            assertEquals("No command specified is a usage error",
+                    CommandRunExceptionType.USAGE, e.getType());
+        }
+        try {
+            pl.execute(null, null, "invalid");
+            fail("Invalid command specified should through an exception");
+        } catch (final CommandRunException e) {
+            assertEquals("Invalid command specified is a usage error",
+                    CommandRunExceptionType.USAGE, e.getType());
+        }
+
+        final CommandMock mock = new CommandMock();
+        provider.add(mock);
+
+        pl.execute(null, null, mock.getCommandName());
+
+        final ForkTask task = (ForkTask) pool.get(pool.getPIDs().iterator().next());
+        task.join(null, null, 1000);
+
+        assertEquals("Command should be executed when forked", 1, mock.getExecuteCall());
+    }
+
+    /**
+     * Test method for {@link net.bigeon.gclc.process.CommandFork#tip()}.
+     */
+    @Test
+    public void testTip() {
+        final TaskPool pool = new TaskPool();
+        final ICommandProvider provider = new SubedCommand("test");
+        final CommandFork pl = new CommandFork("fork", provider, pool);
+        assertNotNull("Command tip should be defined", pl.tip());
+        assertNotNull("Command usage should be defined", pl.usagePattern());
+        assertNotNull("Command usage should be defined", pl.usageDetail());
+    }
+
+}
--- a/gclc-process/src/test/java/net/bigeon/gclc/process/ForkCommandTaskTest.java
+++ b/gclc-process/src/test/java/net/bigeon/gclc/process/ForkCommandTaskTest.java
@@ -0,0 +1,35 @@
+/**
+ * 
+ */
+package net.bigeon.gclc.process;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Test;
+
+import net.bigeon.gclc.process.mocks.CommandMock;
+
+/**
+ * @author Emmanuel Bigeon
+ *
+ */
+public class ForkCommandTaskTest {
+
+    /** Test method for
+     * {@link net.bigeon.gclc.process.ForkCommandTask#ForkCommandTask(net.bigeon.gclc.command.ICommand, java.lang.String[], int)}.
+     * 
+     * @throws InterruptedException if there is an error in the thread join */
+    @Test
+    public void testForkCommandTask() throws InterruptedException {
+        final CommandMock cmd = new CommandMock();
+        final ForkCommandTask task = new ForkCommandTask(cmd, new String[0], 1);
+
+        final Thread th = new Thread(task);
+        th.start();
+        th.join();
+
+        assertEquals("Task should be executed once", 1, cmd.getExecuteCall());
+        assertEquals("Names should be consistent between task and command",
+                cmd.getCommandName(), task.getName());
+    }
+}
--- a/gclc-process/src/test/java/net/bigeon/gclc/process/ForkTaskTest.java
+++ b/gclc-process/src/test/java/net/bigeon/gclc/process/ForkTaskTest.java
@@ -0,0 +1,62 @@
+/**
+ * 
+ */
+package net.bigeon.gclc.process;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+
+import java.io.IOException;
+
+import org.junit.Test;
+
+import net.bigeon.gclc.exception.CommandRunException;
+import net.bigeon.gclc.exception.CommandRunExceptionType;
+import net.bigeon.gclc.utils.PipedConsoleInput;
+import net.bigeon.gclc.utils.PipedConsoleOutput;
+
+/** @author Emmanuel Bigeon */
+public class ForkTaskTest {
+
+    @Test
+    public void testGenericForkTask() throws IOException {
+        final ForkTask task = new ForkTask(5) {
+
+            @Override
+            public String getName() {
+                return "name";
+            }
+
+            @Override
+            protected void doRun() throws CommandRunException {
+                String msg;
+                try {
+                    msg = in.prompt();
+                } catch (final IOException e) {
+                    throw new CommandRunException(CommandRunExceptionType.INTERACTION,
+                            "Unable to prompt user");
+                }
+                if ("ok".equals(msg)) {
+                    out.println("Message");
+                } else {
+                    out.println("fail");
+                }
+            }
+        };
+
+        final Thread execThread = new Thread(task);
+        execThread.start();
+
+        try (PipedConsoleOutput pco = new PipedConsoleOutput();
+                PipedConsoleInput pci = new PipedConsoleInput(null)) {
+            pci.type("ok");
+            while (!pco.available()) {
+                task.join(pco, pci, 1000);
+            }
+            assertEquals("Execution should work", "Message", pco.readNextLine());
+        }
+        assertFalse("Running state should be updated by task on its completion",
+                task.isRunning());
+    }
+
+}
--- a/gclc-process/src/test/java/net/bigeon/gclc/process/ProcessClearTest.java
+++ b/gclc-process/src/test/java/net/bigeon/gclc/process/ProcessClearTest.java
@@ -0,0 +1,53 @@
+/**
+ * 
+ */
+package net.bigeon.gclc.process;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+
+import net.bigeon.gclc.process.mocks.TaskMock;
+
+/**
+ * @author Emmanuel Bigeon
+ *
+ */
+public class ProcessClearTest {
+
+    /**
+     * Test method for {@link net.bigeon.gclc.process.ProcessClear#ProcessClear(java.lang.String, net.bigeon.gclc.process.TaskPool)}.
+     */
+    @Test
+    public void testProcessClear() {
+        final ProcessClear pl = new ProcessClear("clear", new TaskPool());
+        assertEquals("Command name should be kept as specified", "clear",
+                pl.getCommandName());
+    }
+
+    /**
+     * Test method for {@link net.bigeon.gclc.process.ProcessClear#execute(net.bigeon.gclc.manager.ConsoleOutput, net.bigeon.gclc.manager.ConsoleInput, java.lang.String[])}.
+     */
+    @Test
+    public void testExecute() {
+        final TaskPool pool = new TaskPool();
+        final TaskMock task = new TaskMock();
+        pool.add(task);
+        final ProcessClear pl = new ProcessClear("clear", pool);
+        pl.execute(null, null);
+        assertTrue("cleared pool should be empty", pool.getPIDs().isEmpty());
+    }
+
+    /**
+     * Test method for {@link net.bigeon.gclc.process.ProcessClear#tip()}.
+     */
+    @Test
+    public void testTip() {
+        final ProcessClear pl = new ProcessClear("clear", new TaskPool());
+        assertNotNull("Command tip should be defined", pl.tip());
+        assertNotNull("Command usage should be defined", pl.usageDetail());
+    }
+
+}
--- a/gclc-process/src/test/java/net/bigeon/gclc/process/ProcessKillTest.java
+++ b/gclc-process/src/test/java/net/bigeon/gclc/process/ProcessKillTest.java
@@ -0,0 +1,65 @@
+/**
+ * 
+ */
+package net.bigeon.gclc.process;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.fail;
+
+import java.io.IOException;
+
+import org.junit.Test;
+
+import net.bigeon.gclc.exception.CommandRunException;
+import net.bigeon.gclc.exception.CommandRunExceptionType;
+import net.bigeon.gclc.process.mocks.TaskMock;
+
+/** @author Emmanuel Bigeon */
+public class ProcessKillTest {
+
+    /** Test method for
+     * {@link net.bigeon.gclc.process.ProcessKill#ProcessKill(java.lang.String, net.bigeon.gclc.process.TaskPool)}. */
+    @Test
+    public void testProcessKill() {
+        final ProcessList pl = new ProcessList("kill", new TaskPool());
+        assertEquals("Command name should be kept as specified", "kill",
+                pl.getCommandName());
+    }
+
+    /** Test method for
+     * {@link net.bigeon.gclc.process.ProcessKill#execute(net.bigeon.gclc.manager.ConsoleOutput, net.bigeon.gclc.manager.ConsoleInput, java.lang.String[])}.
+     * 
+     * @throws CommandRunException if an error occured in test
+     * @throws IOException if an error occured with the console output */
+    @Test
+    public void testExecute() throws CommandRunException {
+        final TaskPool pool = new TaskPool();
+        final TaskMock task = new TaskMock();
+        final int id = pool.add(task);
+        final ProcessKill pl = new ProcessKill("kill", pool);
+        task.reset();
+        try {
+            pl.execute(null, null);
+            fail("Execution with no pid should raise exception");
+        } catch (final CommandRunException e) {
+            assertEquals("Usage exception expected", CommandRunExceptionType.USAGE,
+                    e.getType());
+        }
+        pl.execute(null, null, Integer.toString(id));
+        assertEquals("Task should be shutdown", 1, task.getNumberSetRunning());
+        task.reset();
+        pl.execute(null, null, Integer.toString(id));
+        assertEquals("Task should be shutdown", 1, task.getNumberSetRunning());
+    }
+
+    /** Test method for {@link net.bigeon.gclc.process.ProcessKill#tip()}. */
+    @Test
+    public void testTip() {
+        final ProcessKill pl = new ProcessKill("kill", new TaskPool());
+        assertNotNull("Command tip should be defined", pl.tip());
+        assertNotNull("Command usage should be defined", pl.usagePattern());
+        assertNotNull("Command usage should be defined", pl.usageDetail());
+    }
+
+}
--- a/gclc-process/src/test/java/net/bigeon/gclc/process/ProcessListTest.java
+++ b/gclc-process/src/test/java/net/bigeon/gclc/process/ProcessListTest.java
@@ -0,0 +1,67 @@
+/**
+ * 
+ */
+package net.bigeon.gclc.process;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import java.io.IOException;
+
+import org.junit.Test;
+
+import net.bigeon.gclc.exception.CommandRunException;
+import net.bigeon.gclc.exception.CommandRunExceptionType;
+import net.bigeon.gclc.process.mocks.TaskMock;
+import net.bigeon.gclc.utils.PipedConsoleOutput;
+
+/** @author Emmanuel Bigeon */
+public class ProcessListTest {
+
+    /** Test method for
+     * {@link net.bigeon.gclc.process.ProcessList#ProcessList(java.lang.String, net.bigeon.gclc.process.TaskPool)}. */
+    @Test
+    public void testProcessList() {
+        final ProcessList pl = new ProcessList("list", new TaskPool());
+        assertEquals("Command name should be kept as specified", "list",
+                pl.getCommandName());
+    }
+
+    /** Test method for
+     * {@link net.bigeon.gclc.process.ProcessList#execute(net.bigeon.gclc.manager.ConsoleOutput, net.bigeon.gclc.manager.ConsoleInput, java.lang.String[])}.
+     * 
+     * @throws CommandRunException if an error occured
+     * @throws IOException if an error in initialization of console occured */
+    @Test
+    public void testExecute() throws CommandRunException, IOException {
+        final TaskPool pool = new TaskPool();
+        final TaskMock task = new TaskMock();
+        pool.add(task);
+        final ProcessList pl = new ProcessList("list", pool);
+        final PipedConsoleOutput out = new PipedConsoleOutput();
+        pl.execute(out, null);
+
+        assertTrue("Task should be contained in list",
+                out.readNextLine().contains(task.getName()));
+
+        out.close();
+
+        try {
+            pl.execute(out, null);
+            fail("Printing element to closed console should raise interaction exception");
+        } catch (final CommandRunException e) {
+            assertEquals("Console printing error should be an interaction error",
+                    CommandRunExceptionType.INTERACTION, e.getType());
+        }
+    }
+
+    /** Test method for {@link net.bigeon.gclc.process.ProcessList#tip()}. */
+    @Test
+    public void testTip() {
+        final ProcessList pl = new ProcessList("list", new TaskPool());
+        assertNotNull("Command tip should be defined", pl.tip());
+        assertNotNull("Command usage should be defined", pl.usageDetail());
+    }
+}
--- a/gclc-process/src/test/java/net/bigeon/gclc/process/TaskPoolTest.java
+++ b/gclc-process/src/test/java/net/bigeon/gclc/process/TaskPoolTest.java
@@ -0,0 +1,77 @@
+package net.bigeon.gclc.process;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+
+import net.bigeon.gclc.process.mocks.TaskMock;
+
+public class TaskPoolTest {
+
+    public TaskMock task = new TaskMock();
+    public TaskPool pool = new TaskPool(false);
+
+    @Test
+    public void testTaskPool() {
+        assertFalse("task pool should not auto clear if specified",
+                pool.isAutoClearing());
+        pool = new TaskPool();
+        assertTrue("Default task pool should not auto clear", pool.isAutoClearing());
+    }
+
+    @Test
+    public void testAdd() {
+        final int id = pool.add(task);
+        assertTrue("Added task pid should be in pool", pool.getPIDs().contains(id));
+        assertEquals("Added task should be in pool", task, pool.get(id));
+    }
+
+    @Test
+    public void testGet() {
+        assertNull("Inexistent task id should provide null as task in pool",
+                pool.get(60));
+        final int id = pool.add(task);
+        assertEquals("Added task should be in pool at its id", task, pool.get(id));
+        assertNull("Added task should be in pool at its id", pool.get(id + 1));
+    }
+
+    @Test
+    public void testGetPIDs() {
+        assertTrue("new pool should be empty", pool.getPIDs().isEmpty());
+        final int id = pool.add(task);
+        assertNull("Added task should be in pool at its id", pool.get(id + 1));
+        assertEquals(
+                "Pool task addition should change the pid collection size accordingly", 1,
+                pool.getPIDs().size());
+    }
+
+    @Test
+    public void testRemove() {
+        assertTrue("new pool should be empty", pool.getPIDs().isEmpty());
+        pool.remove(60);
+        assertTrue("removal of inexistent task should be NOP", pool.getPIDs().isEmpty());
+        final int id = pool.add(task);
+        assertEquals(
+                "Pool task addition should change the pid collection size accordingly", 1,
+                pool.getPIDs().size());
+        pool.remove(id + 1);
+        assertEquals("removal of inexistent task should be NOP", 1,
+                pool.getPIDs().size());
+        pool.remove(id);
+        assertTrue("removal of task should reduce the number of tasks",
+                pool.getPIDs().isEmpty());
+    }
+
+    @Test
+    public void testShutdown() {
+        final int id = pool.add(task);
+        task.reset();
+        pool.shutdown();
+        assertEquals("Shutdown should request shut down of tasks, only once", 1,
+                task.getNumberSetRunning());
+    }
+
+}
--- a/gclc-process/src/test/java/net/bigeon/gclc/process/io/ConnectingConsoleInputTest.java
+++ b/gclc-process/src/test/java/net/bigeon/gclc/process/io/ConnectingConsoleInputTest.java
@@ -0,0 +1,65 @@
+package net.bigeon.gclc.process.io;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
+import java.io.IOException;
+
+import org.junit.Test;
+
+import net.bigeon.gclc.tools.ConstantString;
+import net.bigeon.gclc.utils.PipedConsoleInput;
+
+public class ConnectingConsoleInputTest {
+
+    @Test
+    public void testConnect() throws IOException {
+        final ConnectingConsoleInput in = new ConnectingConsoleInput();
+        final PipedConsoleInput pci = new PipedConsoleInput(null);
+        assertNull("Inputs should not transmit before connection", in.prompt(1000));
+        in.connect(pci);
+        pci.type("Some message");
+        assertEquals("Messages should be buffered", "Some message", in.prompt());
+    }
+
+    @Test
+    public void testDisconnect() throws IOException {
+        final ConnectingConsoleInput in = new ConnectingConsoleInput();
+        final PipedConsoleInput pci = new PipedConsoleInput(null);
+        assertNull("Inputs should not transmit before connection", in.prompt(1000));
+        in.connect(pci);
+        pci.type("Some message");
+        assertEquals("Messages should be buffered", "Some message", in.prompt());
+        in.disconnect();
+        assertNull("Disconnected inputs should not transmit anymore", in.prompt(1000));
+    }
+
+    @Test
+    public void testIsClosed() throws IOException {
+        final ConnectingConsoleInput in = new ConnectingConsoleInput();
+        assertFalse("New input should not be closed", in.isClosed());
+        final PipedConsoleInput pci = new PipedConsoleInput(null);
+        in.connect(pci);
+        pci.close();
+        assertFalse("Connected input closing should not close connecting", in.isClosed());
+        final PipedConsoleInput pci2 = new PipedConsoleInput(null);
+        in.connect(pci2);
+        in.close();
+        assertTrue("Input should close on request", in.isClosed());
+        assertFalse("Connected input should not be closed by connecting closure",
+                pci2.isClosed());
+    }
+
+    @Test
+    public void testCoveragePrompt() {
+        final ConnectingConsoleInput in = new ConnectingConsoleInput();
+        in.setPrompt("test");
+        assertEquals("Prompt should be set correctly", "test",
+                ((ConstantString) in.getPrompt()).apply());
+        final ConstantString prompt = new ConstantString("other");
+        in.setPrompt(prompt);
+        assertEquals("Prompt should be set correctly", prompt, in.getPrompt());
+    }
+}
--- a/gclc-process/src/test/java/net/bigeon/gclc/process/io/ConnectingConsoleOutputTest.java
+++ b/gclc-process/src/test/java/net/bigeon/gclc/process/io/ConnectingConsoleOutputTest.java
@@ -0,0 +1,88 @@
+package net.bigeon.gclc.process.io;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import java.io.IOException;
+
+import org.junit.Test;
+
+import net.bigeon.gclc.utils.PipedConsoleOutput;
+
+public class ConnectingConsoleOutputTest {
+
+    @Test
+    public void testConnect() throws IOException {
+        final ConnectingConsoleOutput out = new ConnectingConsoleOutput(
+                ConnectingConsoleOutput.QUEUE, 10);
+        final PipedConsoleOutput output = new PipedConsoleOutput();
+        out.println("Some message");
+        assertFalse("Message should not be transmitted", output.available());
+        // Connect
+        out.connect(output);
+
+        // Connected outputs should receive data
+        final String res = output.readNextLine();
+        assertEquals("Message should be correctly transmitted", "Some message", res);
+    }
+
+    @Test
+    public void testDisconnect() throws IOException {
+        final ConnectingConsoleOutput out = new ConnectingConsoleOutput(
+                ConnectingConsoleOutput.QUEUE, 10);
+        final PipedConsoleOutput output = new PipedConsoleOutput();
+        // NOP disconnection when no connection
+        out.disconnect();
+        // Connect
+        out.connect(output);
+
+        // Connected outputs should receive data
+        out.println("Some message");
+        final String res = output.readNextLine();
+        assertEquals("Message should be correctly transmitted", "Some message", res);
+        out.disconnect();
+        out.println("Some message");
+        assertFalse("Message should not be transmitted", output.available());
+    }
+
+    @Test
+    public void testIsClosed() throws IOException {
+        final ConnectingConsoleOutput out = new ConnectingConsoleOutput(
+                ConnectingConsoleOutput.QUEUE, 10);
+        final PipedConsoleOutput output = new PipedConsoleOutput();
+        assertFalse("New output should not be closed", out.isClosed());
+        // Connect
+        out.connect(output);
+
+        output.close();
+
+        assertFalse("Output should not close when connected outputs do", out.isClosed());
+        final PipedConsoleOutput output2 = new PipedConsoleOutput();
+        out.connect(output2);
+        out.close();
+        assertTrue("Output should close on request", out.isClosed());
+        assertFalse("Output should not close connected output when they do",
+                output2.isClosed());
+    }
+
+    @Test
+    public void testPrint() throws IOException {
+        final ConnectingConsoleOutput out = new ConnectingConsoleOutput(
+                ConnectingConsoleOutput.PERSIST, 10);
+
+        out.print("Some text");
+        out.println();
+        final PipedConsoleOutput output = new PipedConsoleOutput();
+        out.connect(output);
+        String res = output.readNextLine();
+        assertEquals("Message should be correctly transmitted", "Some text", res);
+        out.disconnect();
+
+        // Persist should be reprinted on any connect
+        out.connect(output);
+        res = output.readNextLine();
+        assertEquals("Message should be correctly transmitted", "Some text", res);
+        out.disconnect();
+    }
+}
--- a/gclc-process/src/test/java/net/bigeon/gclc/process/mocks/CommandMock.java
+++ b/gclc-process/src/test/java/net/bigeon/gclc/process/mocks/CommandMock.java
@@ -0,0 +1,60 @@
+/**
+ * 
+ */
+package net.bigeon.gclc.process.mocks;
+
+import java.io.IOException;
+
+import net.bigeon.gclc.command.ICommand;
+import net.bigeon.gclc.exception.CommandRunException;
+import net.bigeon.gclc.manager.ConsoleInput;
+import net.bigeon.gclc.manager.ConsoleOutput;
+
+/** @author Emmanuel Bigeon */
+public class CommandMock implements ICommand {
+
+    private int executeCall     = 0;
+    private int tipCall         = 0;
+    private int helpCall        = 0;
+    private int commandNameCall = 0;
+
+    /* (non-Javadoc)
+     * @see net.bigeon.gclc.command.ICommand#execute(net.bigeon.gclc.manager.
+     * ConsoleOutput, net.bigeon.gclc.manager.ConsoleInput, java.lang.String[]) */
+    @Override
+    public void execute(final ConsoleOutput out, final ConsoleInput in,
+            final String... args) throws CommandRunException {
+        executeCall++;
+    }
+
+    /* (non-Javadoc)
+     * @see net.bigeon.gclc.command.ICommand#getCommandName() */
+    @Override
+    public String getCommandName() {
+        commandNameCall++;
+        return "name";
+    }
+
+    /* (non-Javadoc)
+     * @see
+     * net.bigeon.gclc.command.ICommand#help(net.bigeon.gclc.manager.ConsoleOutput,
+     * java.lang.String[]) */
+    @Override
+    public void help(final ConsoleOutput output, final String... args)
+            throws IOException {
+        helpCall++;
+    }
+
+    /* (non-Javadoc)
+     * @see net.bigeon.gclc.command.ICommand#tip() */
+    @Override
+    public String tip() {
+        tipCall++;
+        return "tip";
+    }
+
+    /** @return the executeCall */
+    public int getExecuteCall() {
+        return executeCall;
+    }
+}
--- a/gclc-process/src/test/java/net/bigeon/gclc/process/mocks/ForkTaskMock.java
+++ b/gclc-process/src/test/java/net/bigeon/gclc/process/mocks/ForkTaskMock.java
@@ -0,0 +1,43 @@
+/**
+ * 
+ */
+package net.bigeon.gclc.process.mocks;
+
+import net.bigeon.gclc.exception.CommandRunException;
+import net.bigeon.gclc.process.ForkTask;
+import net.bigeon.gclc.process.Task;
+
+/**
+ * @author Emmanuel Bigeon
+ *
+ */
+public class ForkTaskMock extends ForkTask implements Task {
+
+    private int runCall = 0;
+
+    /** @param lines */
+    public ForkTaskMock() {
+        super(10);
+    }
+
+    /* (non-Javadoc)
+     * @see net.bigeon.gclc.process.Task#getName()
+     */
+    @Override
+    public String getName() {
+        return "name";
+    }
+
+    /* (non-Javadoc)
+     * @see net.bigeon.gclc.process.ForkTask#doRun()
+     */
+    @Override
+    protected void doRun() throws CommandRunException {
+        runCall++;
+    }
+
+    /** @return the runCall */
+    public int getRunCall() {
+        return runCall;
+    }
+}
--- a/gclc-process/src/test/java/net/bigeon/gclc/process/mocks/TaskMock.java
+++ b/gclc-process/src/test/java/net/bigeon/gclc/process/mocks/TaskMock.java
@@ -0,0 +1,57 @@
+package net.bigeon.gclc.process.mocks;
+
+import net.bigeon.gclc.process.InterruptionListener;
+import net.bigeon.gclc.process.Task;
+
+public class TaskMock implements Task {
+
+    private int runCall        = 0;
+    private int setRunningCall = 0;
+
+    @Override
+    public void run() {
+        runCall++;
+    }
+
+    @Override
+    public void addInterruptionListener(final InterruptionListener listener) {
+        // TODO Auto-generated method stub
+
+    }
+
+    @Override
+    public String getName() {
+        return "name";
+    }
+
+    @Override
+    public boolean isRunning() {
+        // TODO Auto-generated method stub
+        return false;
+    }
+
+    @Override
+    public void rmInterruptionListener(final InterruptionListener listener) {
+        // TODO Auto-generated method stub
+
+    }
+
+    @Override
+    public void setRunning(final boolean running) {
+        setRunningCall++;
+    }
+
+    /**
+     * 
+     */
+    public void reset() {
+        runCall = 0;
+        setRunningCall = 0;
+    }
+
+    /** @return */
+    public Object getNumberSetRunning() {
+        return setRunningCall;
+    }
+
+}
--- a/gclc-process/src/test/java/net/bigeon/gclc/process/mocks/package-info.java
+++ b/gclc-process/src/test/java/net/bigeon/gclc/process/mocks/package-info.java
@@ -0,0 +1,4 @@
+/** Mock definitions for testing.
+ * 
+ * @author Emmanuel Bigeon */
+package net.bigeon.gclc.process.mocks;
--- a/gclc-socket/pom.xml
+++ b/gclc-socket/pom.xml
@@ -1,64 +1,22 @@
-
-<!-- GCLC Socket, Socket implementation of GCLC -->
-<!-- Copyright (C) 2014-2017 E. Bigeon -->
-<!-- mailto:emmanuel@bigeon.fr -->
-<!-- -->
-<!-- This software is governed by the CeCILL license under French law and -->
-<!-- abiding by the rules of distribution of free software. You can use, -->
-<!-- modify and/or redistribute the software under the terms of the CeCILL -->
-<!-- license as circulated by CEA, CNRS and INRIA at the following URL -->
-<!-- "http://www.cecill.info". -->
-<!-- -->
-<!-- As a counterpart to the access to the source code and rights to copy, -->
-<!-- modify and redistribute granted by the license, users are provided only -->
-<!-- with a limited warranty and the software's author, the holder of the -->
-<!-- economic rights, and the successive licensors have only limited -->
-<!-- liability. -->
-<!-- -->
-<!-- In this respect, the user's attention is drawn to the risks associated -->
-<!-- with loading, using, modifying and/or developing or reproducing the -->
-<!-- software by the user in light of its specific status of free software, -->
-<!-- that may mean that it is complicated to manipulate, and that also -->
-<!-- therefore means that it is reserved for developers and experienced -->
-<!-- professionals having in-depth computer knowledge. Users are therefore -->
-<!-- encouraged to load and test the software's suitability as regards their -->
-<!-- requirements in conditions enabling the security of their systems and/or -->
-<!-- data to be ensured and, more generally, to use and operate it in the -->
-<!-- same conditions as regards security. -->
-<!-- -->
-<!-- The fact that you are presently reading this means that you have had -->
-<!-- knowledge of the CeCILL license and that you accept its terms. -->
-
-
 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
 	<modelVersion>4.0.0</modelVersion>
-	<artifactId>gclc-socket</artifactId>
-	<version>1.1.11</version>
-	<packaging>jar</packaging>
-	<url>http://www.bigeon.net</url>
-	<properties>
-		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
-		<project.scm.id>git.code.bigeon.net</project.scm.id>
-		<license.licenseName>cecill_2.1</license.licenseName>
-		<copyright.email>emmanuel@bigeon.fr</copyright.email>
-	</properties>
-	<dependencies>
-		<dependency>
-			<groupId>net.bigeon</groupId>
-			<artifactId>gclc</artifactId>
-			<version>2.0.9</version>
-		</dependency>
-		<dependency>
-			<groupId>net.bigeon</groupId>
-			<artifactId>smu</artifactId>
-			<version>1.0.5</version>
-		</dependency>
-	</dependencies>
 	<parent>
 		<groupId>net.bigeon.config</groupId>
 		<artifactId>ebigeon-config</artifactId>
-		<version>1.8.12</version>
+		<version>1.8.21</version>
 	</parent>
+	<groupId>net.bigeon.gclc</groupId>
+	<artifactId>socket</artifactId>
+	<version>1.1.14-SNAPSHOT</version>
+	<packaging>jar</packaging>
+	<name>GCLC Socket</name>
+	<description>Socket implementation of GCLC</description>
+	<url>https://bigeon.net/projects/gclc.html</url>
+	<inceptionYear>2016</inceptionYear>
+	<organization>
+		<name>Bigeon</name>
+		<url>https://bigeon.net/</url>
+	</organization>
 	<licenses>
 		<license>
 			<distribution>manual</distribution>
@@ -66,15 +24,6 @@
 			<url>https://cecill.info/licences/Licence_CeCILL_V2.1-en.html</url>
 		</license>
 	</licenses>
-	<reporting>
-		<plugins>
-			<plugin>
-				<groupId>com.github.sevntu-checkstyle</groupId>
-				<artifactId>dsm-maven-plugin</artifactId>
-				<version>2.2.0</version>
-			</plugin>
-		</plugins>
-	</reporting>
 	<developers>
 		<developer>
 			<email>emmanuel@bigeon.fr</email>
@@ -85,12 +34,45 @@
 			</roles>
 		</developer>
 	</developers>
-	<name>GCLC Socket</name>
-	<description>Socket implementation of GCLC</description>
 	<scm>
 		<developerConnection>scm:git:gogs@git.code.bigeon.net:emmanuel/gclc.git</developerConnection>
-		<tag>gclc-socket-1.1.11</tag>
+		<tag>HEAD</tag>
 	</scm>
-	<groupId>net.bigeon.gclc</groupId>
-	<inceptionYear>2016</inceptionYear>
+	<properties>
+		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+		<project.scm.id>git.code.bigeon.net</project.scm.id>
+		<license.licenseName>cecill_2.1</license.licenseName>
+	</properties>
+	<dependencies>
+		<dependency>
+			<groupId>net.bigeon</groupId>
+			<artifactId>gclc</artifactId>
+			<version>2.0.11</version>
+		</dependency>
+		<dependency>
+			<groupId>net.bigeon</groupId>
+			<artifactId>smu</artifactId>
+			<version>1.0.6</version>
+		</dependency>
+		<dependency>
+			<groupId>net.bigeon.test</groupId>
+			<artifactId>junitmt</artifactId>
+			<version>1.0.0</version>
+			<scope>test</scope>
+		</dependency>
+	</dependencies>
+	<reporting>
+		<plugins>
+			<plugin>
+				<groupId>org.apache.maven.plugins</groupId>
+				<artifactId>maven-javadoc-plugin</artifactId>
+				<version>2.10.3</version>
+			</plugin>
+			<plugin>
+				<groupId>com.github.sevntu-checkstyle</groupId>
+				<artifactId>dsm-maven-plugin</artifactId>
+				<version>2.2.0</version>
+			</plugin>
+		</plugins>
+	</reporting>
 </project>
--- a/gclc-socket/src/main/java/net/bigeon/gclc/socket/DConnexionManager.java
+++ b/gclc-socket/src/main/java/net/bigeon/gclc/socket/DConnexionManager.java
@@ -143,7 +143,8 @@ public final class DConnexionManager<T> implements ConnexionManager<T> {
     *
     * @return a new ID */
    private String newID() {
-        return "Client " + count++; //$NON-NLS-1$
+        final int c = count++;
+        return "Client " + c; //$NON-NLS-1$
    }

    /* (non-Javadoc)
--- a/gclc-socket/src/main/java/net/bigeon/gclc/socket/PluggableConsoleInput.java
+++ b/gclc-socket/src/main/java/net/bigeon/gclc/socket/PluggableConsoleInput.java
@@ -54,9 +54,12 @@ import net.bigeon.gclc.utils.ReadingRunnable;
 /** A console input where the stream can be plugged.
 * <p>
 * This pluggable console input accepts an input and output to be connected to
- * it. The connexion cannot be concurrent, which mean that any connected stream
+ * it. The connection cannot be concurrent, which mean that any connected stream
 * must be disconnected before a new call to
 * {@link #connect(InputStream, PrintStream)} is done.
+ * <p>
+ * On connection, if the prompt is in wait, this console input will provide the
+ * prompting message.
 *
 * @author Emmanuel Bigeon */
 public final class PluggableConsoleInput implements ConsoleInput {
@@ -109,15 +112,15 @@ public final class PluggableConsoleInput implements ConsoleInput {
            throws IOException {
        synchronized (connexionLock) {
            if (connected) {
+                // Cannot be connected to several sources
                throw new IOException("Input already connected to an input stream"); //$NON-NLS-1$
            }
-
            output = out;
            if (prompting) {
+                // print the hint, to indicate we are waiting for a user input.
                out.print(hint);
                out.flush();
            }
-
            final InputStreamReader streamReader = new InputStreamReader(stream,
                    StandardCharsets.UTF_8);
            final BufferedReader reader = new BufferedReader(streamReader);
@@ -189,19 +192,11 @@ public final class PluggableConsoleInput implements ConsoleInput {
        if (closed) {
            throw new IOException();
        }
-        prompting = true;
-        hint = message;
-        synchronized (connexionLock) {
-            hint = message;
-            if (connected) {
-                output.print(message);
-                output.flush();
-            }
-        }
-
+        preparePrompt(message);
        String res = null;
        while (res == null && !interrupted) {
            try {
+                // Wait for a message or a connection with message
                res = waitMessageOrConnexion(TIMEOUT, TIMEOUT / TENTH);
            } catch (final InterruptedException e) {
                LOGGER.log(Level.FINE, "Interruption of thread", e); //$NON-NLS-1$
@@ -215,6 +210,22 @@ public final class PluggableConsoleInput implements ConsoleInput {
        return res;
    }

+    /** Prepare the new prompt.
+     * 
+     * @param message the message to indicate request of prompt. */
+    private void preparePrompt(final String message) {
+        prompting = true;
+        // hold the message
+        synchronized (connexionLock) {
+            hint = message;
+            if (connected) {
+                // print the message
+                output.print(message);
+                output.flush();
+            }
+        }
+    }
+
    /* (non-Javadoc)
     * @see fr.bigeon.gclc.manager.ConsoleInput#prompt(java.lang.String, long) */
    @Override
@@ -222,15 +233,7 @@ public final class PluggableConsoleInput implements ConsoleInput {
        if (closed) {
            throw new IOException();
        }
-        prompting = true;
-        synchronized (connexionLock) {
-            hint = message;
-            if (connected) {
-                output.print(message);
-                output.flush();
-            }
-        }
-
+        preparePrompt(message);
        String res = null;
        final long tic = System.currentTimeMillis();
        long time = System.currentTimeMillis() - tic;
@@ -250,11 +253,16 @@ public final class PluggableConsoleInput implements ConsoleInput {
        return res;
    }

+    /* (non-Javadoc)
+     * @see net.bigeon.gclc.manager.ConsoleInput#setPrompt(java.lang.String) */
    @Override
-    public void setPrompt(String prompt) {
+    public void setPrompt(final String prompt) {
        setPrompt(new ConstantString(prompt));
    }

+    /* (non-Javadoc)
+     * @see net.bigeon.gclc.manager.ConsoleInput#setPrompt(net.bigeon.gclc.tools.
+     * StringProvider) */
    @Override
    public void setPrompt(final StringProvider prompt) {
        this.prompt = prompt;
--- a/gclc-socket/src/main/java/net/bigeon/gclc/socket/RemoteDisconnectCommand.java
+++ b/gclc-socket/src/main/java/net/bigeon/gclc/socket/RemoteDisconnectCommand.java
@@ -123,8 +123,7 @@ public final class RemoteDisconnectCommand<T> extends Command {
    @Override
    protected String usageDetail() {
        return MessageFormat.format(
-                "  If arguments are provided the corresponding connexions are closed, "
-                        + "otherwise{0}{1} are.",
-                System.lineSeparator(), all ? "all connexions" : "none");
+                "  If arguments are provided the corresponding connexions are closed, otherwise\n{0} are.",
+                all ? "all connexions" : "none");
    }
 }
--- a/gclc-socket/src/test/java/net/bigeon/gclc/socket/TestServer.java
+++ b/gclc-socket/src/test/java/net/bigeon/gclc/socket/TestServer.java
@@ -46,6 +46,7 @@ import net.bigeon.gclc.ConsoleApplication;
@SuppressWarnings({ "javadoc", "nls" })
 public class TestServer {

+    public static final int                      PORT = 3300;
    private static SocketConsoleApplicationShell SHELL;
    private static ConnexionManager<Socket>      manager;

@@ -75,7 +76,7 @@ public class TestServer {
            input.setPrompt("> \n");
            output = new PluggableConsoleOutput();
            manager = new DConnexionManager<>();
-            SHELL = new SocketConsoleApplicationShell(3300,
+            SHELL = new SocketConsoleApplicationShell(PORT,
                    InetAddress.getByName("127.0.0.1"));
            final ConsoleApplication app = ConsoleTestApplication.create(output, input,
                    manager);
@@ -91,13 +92,13 @@ public class TestServer {
            });
            th.start();
            try {
-                Object waiting = new Object();
+                final Object waiting = new Object();
                synchronized (waiting) {
                    while (!input.isPrompting()) {
                        waiting.wait(50);
                    }
                }
-            } catch (InterruptedException e) {
+            } catch (final InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
--- a/gclc-swt/pom.xml
+++ b/gclc-swt/pom.xml
@@ -1,69 +1,22 @@
-
-<!-- GCLC swt, provide a swt window for console applications                                   -->
-<!-- Copyright (C) 2015-2017 E. Bigeon                      -->
-<!-- mailto:emmanuel@bigeon.fr                                                           -->
-<!--                                                                           -->
-<!-- This software is governed by the CeCILL license under French law and      -->
-<!-- abiding by the rules of distribution of free software.  You can  use,     -->
-<!-- modify and/or redistribute the software under the terms of the CeCILL     -->
-<!-- license as circulated by CEA, CNRS and INRIA at the following URL         -->
-<!-- "http://www.cecill.info".                                                 -->
-<!--                                                                           -->
-<!-- As a counterpart to the access to the source code and  rights to copy,    -->
-<!-- modify and redistribute granted by the license, users are provided only   -->
-<!-- with a limited warranty  and the software's author,  the holder of the    -->
-<!-- economic rights,  and the successive licensors  have only  limited        -->
-<!-- liability.                                                                -->
-<!--                                                                           -->
-<!-- In this respect, the user's attention is drawn to the risks associated    -->
-<!-- with loading,  using,  modifying and/or developing or reproducing the     -->
-<!-- software by the user in light of its specific status of free software,    -->
-<!-- that may mean  that it is complicated to manipulate,  and  that  also     -->
-<!-- therefore means  that it is reserved for developers  and  experienced     -->
-<!-- professionals having in-depth computer knowledge. Users are therefore     -->
-<!-- encouraged to load and test the software's suitability as regards their   -->
-<!-- requirements in conditions enabling the security of their systems and/or  -->
-<!-- data to be ensured and,  more generally, to use and operate it in the     -->
-<!-- same conditions as regards security.                                      -->
-<!--                                                                           -->
-<!-- The fact that you are presently reading this means that you have had      -->
-<!-- knowledge of the CeCILL license and that you accept its terms.            -->
-
 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
-  <modelVersion>4.0.0</modelVersion>
-  <groupId>net.bigeon.gclc</groupId>
-  <artifactId>gclc-swt</artifactId>
-  <version>1.1.6-SNAPSHOT</version>
-  <packaging>jar</packaging>
-  <inceptionYear>2015</inceptionYear>
-  <name>GCLC swt</name>
-  <description>A swt window for console applications</description>
-
-  <parent>
-    <groupId>net.bigeon.config</groupId>
-    <artifactId>swt-config</artifactId>
-    <version>1.8.9</version>
-  </parent>
-
-  <properties>
-    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
-    <copyright.email>emmanuel@bigeon.fr</copyright.email>
-    <license.licenseName>cecill_2.1</license.licenseName>
-  </properties>
-
-  <dependencies>
-    <dependency>
-      <groupId>net.bigeon</groupId>
-      <artifactId>gclc</artifactId>
-      <version>2.0.9</version>
-    </dependency>
-    <dependency>
-      <groupId>net.bigeon</groupId>
-      <artifactId>collections</artifactId>
-      <version>1.1.1</version>
-    </dependency>
-  </dependencies>
-
+	<modelVersion>4.0.0</modelVersion>
+	<parent>
+		<groupId>net.bigeon.config</groupId>
+		<artifactId>swt-config</artifactId>
+		<version>1.8.11</version>
+	</parent>
+	<groupId>net.bigeon.gclc</groupId>
+	<artifactId>swt</artifactId>
+	<version>1.1.6</version>
+	<packaging>jar</packaging>
+	<name>GCLC swt</name>
+	<description>A swt window for console applications</description>
+	<url>https://bigeon.net/projects/gclc.html</url>
+	<inceptionYear>2015</inceptionYear>
+	<organization>
+		<name>Bigeon</name>
+		<url>https://bigeon.net/</url>
+	</organization>
 	<licenses>
 		<license>
 			<distribution>manual</distribution>
@@ -71,15 +24,6 @@
 			<url>https://cecill.info/licences/Licence_CeCILL_V2.1-en.html</url>
 		</license>
 	</licenses>
-	<reporting>
-		<plugins>
-			<plugin>
-				<groupId>com.github.sevntu-checkstyle</groupId>
-				<artifactId>dsm-maven-plugin</artifactId>
-				<version>2.2.0</version>
-			</plugin>
-		</plugins>
-	</reporting>
 	<developers>
 		<developer>
 			<email>emmanuel@bigeon.fr</email>
@@ -90,9 +34,41 @@
 			</roles>
 		</developer>
 	</developers>
+	<scm>
+		<developerConnection>scm:git:gogs@git.code.bigeon.net:emmanuel/gclc.git</developerConnection>
+		<tag>swt-1.1.6</tag>
+	</scm>
+	<properties>
+		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+		<copyright.email>emmanuel@bigeon.fr</copyright.email>
+		<license.licenseName>cecill_2.1</license.licenseName>
+	</properties>

-  <scm>
-    <developerConnection>scm:git:gogs@git.code.bigeon.net:emmanuel/gclc.git</developerConnection>
-    <tag>HEAD</tag>
-  </scm>
+	<dependencies>
+		<dependency>
+			<groupId>net.bigeon</groupId>
+			<artifactId>gclc</artifactId>
+			<version>2.0.11</version>
+		</dependency>
+		<dependency>
+			<groupId>net.bigeon</groupId>
+			<artifactId>collections</artifactId>
+			<version>1.1.6</version>
+		</dependency>
+	</dependencies>
+
+	<reporting>
+		<plugins>
+			<plugin>
+				<groupId>org.apache.maven.plugins</groupId>
+				<artifactId>maven-javadoc-plugin</artifactId>
+				<version>2.10.3</version>
+			</plugin>
+			<plugin>
+				<groupId>com.github.sevntu-checkstyle</groupId>
+				<artifactId>dsm-maven-plugin</artifactId>
+				<version>2.2.0</version>
+			</plugin>
+		</plugins>
+	</reporting>
 </project>
--- a/gclc-swt/src/main/java/net/bigeon/gclc/swt/HistoryTextKeyListener.java
+++ b/gclc-swt/src/main/java/net/bigeon/gclc/swt/HistoryTextKeyListener.java
@@ -131,11 +131,14 @@ public final class HistoryTextKeyListener extends KeyAdapter {

        // Lower arrow retrieves next commands
        if (keyCode == SWT.ARROW_DOWN) {
-            if (currentIndex == 0) {
+            if (currentIndex <= 0) {
+                if (currentIndex == 0) {
+                    console.setInput(EMPTY);
+                }
+                currentIndex = -1;
+            } else {
                currentIndex--;
-                console.setInput(EMPTY);
-            } else if (currentIndex > 0) {
-                final String cmd = commands.get(commands.size() - (--currentIndex) - 1);
+                final String cmd = commands.get(commands.size() - currentIndex - 1);
                console.setInput(cmd);
            }
        }
--- a/gclc-swt/src/main/java/net/bigeon/gclc/swt/SWTConsole.java
+++ b/gclc-swt/src/main/java/net/bigeon/gclc/swt/SWTConsole.java
@@ -92,29 +92,32 @@ import net.bigeon.gclc.tools.StringProvider;
 * @author Emmanuel Bigeon */
 public final class SWTConsole extends Composite
        implements ConsoleDelayIO, ConsoleInput, ConsoleOutput {
+    private static final int    TWO                  = 2;
+    private static final String ERROR_SYNCHRO_PROMPT = "Error in synchronization of prompting";
    /** The number of columns of the layout. */
-    private static final int    LAYOUT_NB_COLUMNS = 2;
+    private static final int    LAYOUT_NB_COLUMNS    = 2;
    /** The cmd prefix in the output console. */
-    private static final String CMD_PREFIX        = "[CMD] ";                 //$NON-NLS-1$
+    private static final String CMD_PREFIX           = "[CMD] ";                               //$NON-NLS-1$
    /** The class logger. */
-    private static final Logger LOGGER            = Logger
+    private static final Logger LOGGER               = Logger
            .getLogger(SWTConsole.class.getName());
    /** The empty string constant. */
-    private static final String EMPTY             = "";                       //$NON-NLS-1$
+    private static final String EMPTY                = "";                                     //$NON-NLS-1$
+
    /** The console output text field. */
-    private final Text          consoleOutput;
+    private final Text     consoleOutput;
    /** The console input text field. */
-    private final Text          consoleInput;
+    private final Text     consoleInput;
    /** The prompt label. */
-    private final Label         lblPromptlabel;
+    private final Label    lblPromptlabel;
    /** The prompt text. */
-    private StringProvider      prompt            = new ConstantString("> "); //$NON-NLS-1$
+    private StringProvider prompt     = new ConstantString("> "); //$NON-NLS-1$
    /** The command entered by the user. */
-    private String              command           = null;
+    private String         command    = null;
    /** If the prompt should be active. */
-    private boolean             prompting         = false;
+    private boolean        prompting  = false;
    /** The object for thread synchronization with the prompt. */
-    private final Object        promptLock        = new Object();
+    private final Object   promptLock = new Object();

    /** Create the composite.
     *
@@ -140,6 +143,8 @@ public final class SWTConsole extends Composite

    }

+    /* (non-Javadoc)
+     * @see org.eclipse.swt.widgets.Composite#checkSubclass() */
    @Override
    protected void checkSubclass() {
        // Disable the check that prevents subclassing of SWT components
@@ -250,29 +255,14 @@ public final class SWTConsole extends Composite
    @Override
    public String prompt() throws IOException {
        synchronized (promptLock) {
-            if (isDisposed()) {
-                throw new IOException();
-            }
+            initPrompt(prompt.apply());
+            promptLock.notifyAll();
            try {
-                Display.getDefault().syncExec(new Runnable() {
-                    @Override
-                    public void run() {
-                        if (!consoleInput.isDisposed()) {
-                            consoleInput.setEnabled(true);
-                            lblPromptlabel.setText(prompt.apply());
-                            // relayout
-                            SWTConsole.this.layout();
-                            consoleInput.setFocus();
-                        }
-                    }
-                });
-                prompting = true;
-                promptLock.notifyAll();
                while (prompting) {
                    promptLock.wait();
                }
            } catch (final InterruptedException e) {
-                LOGGER.log(Level.WARNING, "Error in synchronization of prompting", e); //$NON-NLS-1$
+                LOGGER.log(Level.WARNING, ERROR_SYNCHRO_PROMPT, e);
                command = null;
                Thread.currentThread().interrupt();
            }
@@ -283,45 +273,46 @@ public final class SWTConsole extends Composite
        return command;
    }

+    /** Initialize the prompting.
+     * 
+     * @param message the prompt message
+     * @throws IOException if the console is disposed */
+    private void initPrompt(final String message) throws IOException {
+        if (isDisposed()) {
+            throw new IOException();
+        }
+        Display.getDefault().syncExec(new Runnable() {
+            @SuppressWarnings("synthetic-access")
+            @Override
+            public void run() {
+                if (!consoleOutput.isDisposed()) {
+                    lblPromptlabel.setText(message);
+                    // relayout
+                    SWTConsole.this.layout();
+                    consoleInput.setEnabled(true);
+                    consoleInput.setFocus();
+                }
+            }
+        });
+        prompting = true;
+        command = null;
+    }
+
    /* (non-Javadoc)
     * @see fr.bigeon.gclc.manager.ConsoleInput#prompt(long) */
    @Override
    public String prompt(final long timeout) throws IOException {
        synchronized (promptLock) {
-            if (isDisposed()) {
-                throw new IOException();
-            }
+            initPrompt(prompt.apply());
+            promptLock.notifyAll();
            try {
-                Display.getDefault().syncExec(new Runnable() {
-                    @Override
-                    public void run() {
-                        if (!consoleInput.isDisposed()) {
-                            consoleInput.setEnabled(true);
-                            lblPromptlabel.setText(prompt.apply());
-                            // relayout
-                            SWTConsole.this.layout();
-                            consoleInput.setFocus();
-                        }
-                    }
-                });
-                prompting = true;
-                command = null;
-                promptLock.notifyAll();
-                final long start = System.currentTimeMillis();
-                long cur = start;
-                while (prompting && start + timeout > cur) {
-                    promptLock.wait((cur - start - timeout) / 2);
-                    cur = System.currentTimeMillis();
-                }
+                waitPromptResolution(timeout);
            } catch (final InterruptedException e) {
-                LOGGER.log(Level.WARNING, "Error in synchronization of prompting", e); //$NON-NLS-1$
+                LOGGER.log(Level.WARNING, ERROR_SYNCHRO_PROMPT, e);
                command = null;
                Thread.currentThread().interrupt();
            }
        }
-        if (isDisposed()) {
-            throw new IOException("Input closed"); //$NON-NLS-1$
-        }
        return command;
    }

@@ -330,44 +321,21 @@ public final class SWTConsole extends Composite
    @Override
    public String prompt(final String message) throws IOException {
        synchronized (promptLock) {
-            if (isDisposed()) {
-                throw new IOException();
-            }
+            initPrompt(message);
+            promptLock.notifyAll();
            try {
-                Display.getDefault().syncExec(new Runnable() {
-                    @SuppressWarnings("synthetic-access")
-                    @Override
-                    public void run() {
-                        if (!consoleOutput.isDisposed()) {
-                            lblPromptlabel.setText(message);
-                            // relayout
-                            SWTConsole.this.layout();
-                            consoleInput.setEnabled(true);
-                            consoleInput.setFocus();
-                        }
-                    }
-                });
-                prompting = true;
-                promptLock.wait();
+                while (prompting) {
+                    promptLock.wait();
+                }
                if (isDisposed()) {
                    throw new IOException();
                }
            } catch (final InterruptedException e) {
-                LOGGER.log(Level.WARNING, "Error in synchronization of prompting", e); //$NON-NLS-1$
+                LOGGER.log(Level.WARNING, ERROR_SYNCHRO_PROMPT, e);
                command = null;
                Thread.currentThread().interrupt();
            } finally {
-                Display.getDefault().syncExec(new Runnable() {
-                    @SuppressWarnings("synthetic-access")
-                    @Override
-                    public void run() {
-                        if (!consoleOutput.isDisposed()) {
-                            lblPromptlabel.setText(prompt.apply());
-                            // relayout
-                            SWTConsole.this.layout();
-                        }
-                    }
-                });
+                resetPrompt();
            }
        }
        return command;
@@ -377,9 +345,53 @@ public final class SWTConsole extends Composite
     * @see fr.bigeon.gclc.manager.ConsoleInput#prompt(java.lang.String, long) */
    @Override
    public String prompt(final String message, final long timeout) throws IOException {
-        // TODO Auto-generated method stub
-        // return null;
-        throw new RuntimeException("Not implemented yet");
+        synchronized (promptLock) {
+            initPrompt(message);
+            promptLock.notifyAll();
+            try {
+                waitPromptResolution(timeout);
+            } catch (final InterruptedException e) {
+                LOGGER.log(Level.WARNING, ERROR_SYNCHRO_PROMPT, e);
+                command = null;
+                Thread.currentThread().interrupt();
+            } finally {
+                resetPrompt();
+            }
+        }
+        return command;
+    }
+
+    /** Wait the prompt resolution by user.
+     * 
+     * @param timeout the timeout for the wait
+     * @throws InterruptedException if the thread is interrupted
+     * @throws IOException if the console is disposed. */
+    private void waitPromptResolution(final long timeout)
+            throws InterruptedException, IOException {
+        final long start = System.currentTimeMillis();
+        long cur = start;
+        while (prompting && start + timeout > cur) {
+            promptLock.wait((cur - start - timeout) / TWO);
+            cur = System.currentTimeMillis();
+        }
+        if (isDisposed()) {
+            throw new IOException();
+        }
+    }
+
+    /** Reset the prompt message. */
+    private void resetPrompt() {
+        Display.getDefault().syncExec(new Runnable() {
+            @SuppressWarnings("synthetic-access")
+            @Override
+            public void run() {
+                if (!consoleOutput.isDisposed()) {
+                    lblPromptlabel.setText(prompt.apply());
+                    // relayout
+                    SWTConsole.this.layout();
+                }
+            }
+        });
    }

    /* (non-Javadoc)
@@ -397,8 +409,10 @@ public final class SWTConsole extends Composite
        consoleInput.setSelection(input.length());
    }

+    /* (non-Javadoc)
+     * @see net.bigeon.gclc.manager.ConsoleInput#setPrompt(java.lang.String) */
    @Override
-    public void setPrompt(String prompt) {
+    public void setPrompt(final String prompt) {
        setPrompt(new ConstantString(prompt));
    }

@@ -420,21 +434,15 @@ public final class SWTConsole extends Composite
        });
    }

-    /** @param string the text */
+    /** Set the input text.
+     * 
+     * @param string the text */
    public void setText(final String string) {
        consoleInput.setText(string);
    }

-    /**
-     *
-     */
-    public void validateCommand() {
-        validateInput();
-    }
-
-    /**
-     *
-     */
+    /* (non-Javadoc)
+     * @see net.bigeon.gclc.swt.ConsoleDelayIO#validateInput() */
    @Override
    public void validateInput() {
        Display.getDefault().syncExec(new Runnable() {
@@ -450,6 +458,7 @@ public final class SWTConsole extends Composite
                    promptLock.wait();
                } catch (final InterruptedException e) {
                    LOGGER.log(Level.SEVERE, "Interruption while waiting prompt", e); //$NON-NLS-1$
+                    Thread.currentThread().interrupt();
                }
            }
            Display.getDefault().syncExec(new Runnable() {
--- a/gclc-swt/src/main/java/net/bigeon/gclc/swt/SWTConsoleShell.java
+++ b/gclc-swt/src/main/java/net/bigeon/gclc/swt/SWTConsoleShell.java
@@ -85,8 +85,8 @@ public final class SWTConsoleShell extends Shell {
    /** Create the shell.
     *
     * @param display the display */
-    public SWTConsoleShell(final Display display) {
-        super(display, SWT.SHELL_TRIM);
+    public SWTConsoleShell(final Display display, final int style) {
+        super(display, style);
        setLayout(new FillLayout(SWT.HORIZONTAL));

        createContents();
@@ -98,7 +98,7 @@ public final class SWTConsoleShell extends Shell {
    }

    /** Create contents of the shell. */
-    protected void createContents() {
+    private void createContents() {
        console = new SWTConsole(this, SWT.NONE);
        setText("Console Application"); //$NON-NLS-1$
    }
--- a/gclc-swt/src/main/java/net/bigeon/gclc/swt/SWTConsoleView.java
+++ b/gclc-swt/src/main/java/net/bigeon/gclc/swt/SWTConsoleView.java
@@ -103,7 +103,7 @@ public final class SWTConsoleView extends Composite implements ConsoleDelayIO {

        @Override
        protected void forwardLine(final String m) {
-            appendConsoleOutput(m);
+            appendConsoleOutput(System.lineSeparator() + m);
        }

        @Override
@@ -149,12 +149,12 @@ public final class SWTConsoleView extends Composite implements ConsoleDelayIO {
    }

    /** @param next the next message */
-    protected void appendConsoleOutput(final String next) {
+    public void appendConsoleOutput(final String next) {
        Display.getDefault().syncExec(new Runnable() {
            @SuppressWarnings("synthetic-access")
            @Override
            public void run() {
-                consoleOutput.append(System.lineSeparator() + next);
+                consoleOutput.append(next);
            }
        });
    }
--- a/gclc-swt/src/test/java/net/bigeon/gclc/swt/SWTConsoleShellTest.java
+++ b/gclc-swt/src/test/java/net/bigeon/gclc/swt/SWTConsoleShellTest.java
@@ -75,6 +75,7 @@ import static org.junit.Assert.fail;

 import java.io.IOException;

+import org.eclipse.swt.SWT;
 import org.eclipse.swt.widgets.Display;
 import org.junit.Test;

@@ -98,8 +99,8 @@ public class SWTConsoleShellTest {
    private static final Display DISPLAY     = Display.getDefault();

    @Test
-    public void test() {
-        final SWTConsoleShell shell = new SWTConsoleShell(DISPLAY);
+    public void testGeneric() {
+        final SWTConsoleShell shell = new SWTConsoleShell(DISPLAY, SWT.SHELL_TRIM);
        final SWTConsole swtConsole = shell.getManager();
        try {
            final ConsoleApplication appl = new ConsoleApplication(swtConsole, swtConsole,
@@ -138,6 +139,7 @@ public class SWTConsoleShellTest {
            });
 // shell.pack();
            shell.open();
+            shell.setVisible(false);
            final Thread applThread = new Thread(new Runnable() {

                @Override
@@ -159,7 +161,7 @@ public class SWTConsoleShellTest {
                        @Override
                        public void run() {
                            swtConsole.setText("test"); //$NON-NLS-1$
-                            swtConsole.validateCommand();
+                            swtConsole.validateInput();
                        }
                    });
                    try {
@@ -198,7 +200,7 @@ public class SWTConsoleShellTest {

    @Test
    public void testConsoleClose() {
-        final SWTConsoleShell shell = new SWTConsoleShell(DISPLAY);
+        final SWTConsoleShell shell = new SWTConsoleShell(DISPLAY, SWT.SHELL_TRIM);
        final SWTConsole swtConsole = shell.getManager();
        swtConsole.close();
        swtConsole.setPrompt(":");
@@ -267,6 +269,7 @@ public class SWTConsoleShellTest {
            });
 // shell.pack();
            shell.open();
+            shell.setVisible(false);
            final Thread applThread = new Thread(new Runnable() {

                @Override
@@ -288,7 +291,7 @@ public class SWTConsoleShellTest {
                        @Override
                        public void run() {
                            swtConsole.setText("test"); //$NON-NLS-1$
-                            swtConsole.validateCommand();
+                            swtConsole.validateInput();
                        }
                    });
                    Display.getDefault().syncExec(new Runnable() {
@@ -297,28 +300,28 @@ public class SWTConsoleShellTest {
                            swtConsole.setText("ok"); //$NON-NLS-1$
                        }
                    });
-                    swtConsole.validateCommand();
+                    swtConsole.validateInput();
                    Display.getDefault().syncExec(new Runnable() {
                        @Override
                        public void run() {
                            swtConsole.setText("long"); //$NON-NLS-1$
                        }
                    });
-                    swtConsole.validateCommand();
+                    swtConsole.validateInput();
                    Display.getDefault().syncExec(new Runnable() {
                        @Override
                        public void run() {
                            swtConsole.setText("test"); //$NON-NLS-1$
                        }
                    });
-                    swtConsole.validateCommand();
+                    swtConsole.validateInput();
                    Display.getDefault().syncExec(new Runnable() {
                        @Override
                        public void run() {
                            swtConsole.setText("test"); //$NON-NLS-1$
                        }
                    });
-                    swtConsole.validateCommand();
+                    swtConsole.validateInput();
                    try {
                        Thread.sleep(TWO_SECONDS);
                    } catch (final InterruptedException e) {
--- a/gclc-swt/src/test/java/net/bigeon/gclc/swt/SWTConsoleViewTest.java
+++ b/gclc-swt/src/test/java/net/bigeon/gclc/swt/SWTConsoleViewTest.java
@@ -99,7 +99,7 @@ public class SWTConsoleViewTest {
    private static final Display DISPLAY     = Display.getDefault();

    @Test
-    public void test() {
+    public void testGeneric() {
        final Shell shell = new Shell(DISPLAY);
        final SWTConsoleView swtConsole = new SWTConsoleView(shell, SWT.NONE);
        try (PipedConsoleOutput manager = new PipedConsoleOutput();
@@ -147,6 +147,7 @@ public class SWTConsoleViewTest {
            });
 // shell.pack();
            shell.open();
+            shell.setVisible(false);
            final Thread applThread = new Thread(new Runnable() {

                @Override
--- a/gclc.system/pom.xml
+++ b/gclc.system/pom.xml
@@ -1,30 +1,22 @@
 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
-  <modelVersion>4.0.0</modelVersion>
-  <groupId>net.bigeon.gclc</groupId>
-  <artifactId>system</artifactId>
-  <version>0.0.2-SNAPSHOT</version>
-  <packaging>jar</packaging>
-  <url>http://www.bigeon.net</url>
-  <properties>
-    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
-    <copyright.email>emmanuel@bigeon.fr</copyright.email>
-    <license.licenseName>cecill_2.1</license.licenseName>
-  </properties>
-  <build>
-    <plugins>
-    </plugins>
-  </build>
-  <dependencies>
-    <dependency>
-      <groupId>net.bigeon</groupId>
-      <artifactId>gclc</artifactId>
-      <version>2.0.9</version>
-    </dependency>
-  </dependencies>
-  <name>GCLC system command</name>
-  <description>Provide an exec command to execute system commands</description>
-  <inceptionYear>2016</inceptionYear>
-  
+	<modelVersion>4.0.0</modelVersion>
+	<parent>
+		<groupId>net.bigeon.config</groupId>
+		<artifactId>ebigeon-config</artifactId>
+		<version>1.8.21</version>
+	</parent>
+	<groupId>net.bigeon.gclc</groupId>
+	<artifactId>system</artifactId>
+	<version>0.0.3-SNAPSHOT</version>
+	<packaging>jar</packaging>
+	<name>GCLC system command</name>
+	<description>Provide an exec command to execute system commands</description>
+	<url>https://bigeon.net/projects/gclc.html</url>
+	<inceptionYear>2016</inceptionYear>
+	<organization>
+		<name>Bigeon</name>
+		<url>https://bigeon.net</url>
+	</organization>
 	<licenses>
 		<license>
 			<distribution>manual</distribution>
@@ -32,15 +24,6 @@
 			<url>https://cecill.info/licences/Licence_CeCILL_V2.1-en.html</url>
 		</license>
 	</licenses>
-	<reporting>
-		<plugins>
-			<plugin>
-				<groupId>com.github.sevntu-checkstyle</groupId>
-				<artifactId>dsm-maven-plugin</artifactId>
-				<version>2.2.0</version>
-			</plugin>
-		</plugins>
-	</reporting>
 	<developers>
 		<developer>
 			<email>emmanuel@bigeon.fr</email>
@@ -51,14 +34,40 @@
 			</roles>
 		</developer>
 	</developers>
+	<scm>
+		<developerConnection>scm:git:gogs@git.code.bigeon.net:emmanuel/gclc.git</developerConnection>
+		<tag>HEAD</tag>
+	</scm>
+	<properties>
+		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+		<copyright.email>emmanuel@bigeon.fr</copyright.email>
+		<license.licenseName>cecill_2.1</license.licenseName>
+	</properties>

-  <scm>
-    <developerConnection>scm:git:gogs@git.code.bigeon.net:emmanuel/gclc.git</developerConnection>
-    <tag>HEAD</tag>
-  </scm>
-  <parent>
-    <groupId>net.bigeon.config</groupId>
-    <artifactId>ebigeon-config</artifactId>
-    <version>1.8.12</version>
-  </parent>
+	<dependencies>
+		<dependency>
+			<groupId>net.bigeon</groupId>
+			<artifactId>gclc</artifactId>
+			<version>2.0.11</version>
+		</dependency>
+	</dependencies>
+
+	<build>
+		<plugins>
+		</plugins>
+	</build>
+	<reporting>
+		<plugins>
+			<plugin>
+				<groupId>org.apache.maven.plugins</groupId>
+				<artifactId>maven-javadoc-plugin</artifactId>
+				<version>2.10.3</version>
+			</plugin>
+			<plugin>
+				<groupId>com.github.sevntu-checkstyle</groupId>
+				<artifactId>dsm-maven-plugin</artifactId>
+				<version>2.2.0</version>
+			</plugin>
+		</plugins>
+	</reporting>
 </project>
--- a/gclc.system/src/main/java/net/bigeon/gclc/system/ExecSystemCommand.java
+++ b/gclc.system/src/main/java/net/bigeon/gclc/system/ExecSystemCommand.java
@@ -39,11 +39,8 @@ package net.bigeon.gclc.system;
 */
 import java.io.BufferedWriter;
 import java.io.IOException;
-import java.io.InputStream;
 import java.io.OutputStream;
 import java.io.OutputStreamWriter;
-import java.util.logging.Level;
-import java.util.logging.Logger;

 import net.bigeon.gclc.command.Command;
 import net.bigeon.gclc.exception.CommandRunException;
@@ -51,7 +48,11 @@ import net.bigeon.gclc.exception.CommandRunExceptionType;
 import net.bigeon.gclc.manager.ConsoleInput;
 import net.bigeon.gclc.manager.ConsoleOutput;

-/** A command that will execute a system command.
+/** A command that will execute system commands.
+ * <p>
+ * Note that this class may induce security issues in the code as it can execute
+ * arbitrary system commands. It is recommended that it be used only in private
+ * applications or application used by aware parties.
 *
 * @author Emmanuel Bigeon */
 public class ExecSystemCommand extends Command {
@@ -62,9 +63,6 @@ public class ExecSystemCommand extends Command {
    private static final String COMMAND_DEFAULT_NAME = "exec";                //$NON-NLS-1$
    /** The end of line separator */
    private static final String EOL                  = System.lineSeparator();
-    /** The class logger */
-    private static final Logger LOGGER               = Logger
-            .getLogger(ExecSystemCommand.class.getName());

    /** Create the command with the name 'exec'. */
    public ExecSystemCommand() {
@@ -89,32 +87,24 @@ public class ExecSystemCommand extends Command {
        try {
            proc = Runtime.getRuntime().exec(args);
        } catch (final IOException e2) {
-            LOGGER.log(Level.SEVERE, "Unable to run process", e2); //$NON-NLS-1$
-            return;
+            throw new CommandRunException("Unable to run process", e2);
        }
-
-        final InputStream is = proc.getInputStream();
-        final Thread th = new Thread(new Runnable() {
-
-            @Override
-            public void run() {
-                try {
-                    readToEnd(out, is);
-                    is.close();
-                } catch (final CommandRunException e) {
-                    LOGGER.log(Level.WARNING, "Manager was closed in the meantime...", e); //$NON-NLS-1$
-                } catch (final IOException e) {
-                    LOGGER.log(Level.WARNING, "Input stream was closed...", e); //$NON-NLS-1$
-                }
-            }
-        });
-        th.start();
+        // Stream forwarding to the application's console
+        // This is started in a parallel thread.
+        final Thread th = ForwardingRunnable.connect(proc.getInputStream(), out,
+                "Command output");
+        // Set the empty prompt for the processes promptings.
        in.setPrompt(""); //$NON-NLS-1$
+        // Forward console input to the process, whether the process is waiting or not
+        // for input.
        final OutputStream os = proc.getOutputStream();
        try (BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(os))) {
            while (th.isAlive()) {
-                String user = in.prompt();
-                writer.write(user + EOL);
+                final String user = in.prompt();
+                // Avoid interruption being sent to process.
+                if (!user.isEmpty()) {
+                    writer.write(user + EOL);
+                }
            }
        } catch (final IOException e1) {
            throw new CommandRunException(CommandRunExceptionType.INTERACTION,
@@ -122,36 +112,6 @@ public class ExecSystemCommand extends Command {
        }
    }

-    /** @param is the input stream
-     * @throws CommandRunException if the manager was closed while writing the
-     *         stream */
-    protected void readToEnd(final ConsoleOutput out, final InputStream is)
-            throws CommandRunException {
-        int c;
-        try {
-            while ((c = is.read()) != -1) {
-                printCharacter(out, (char) c);
-            }
-        } catch (final IOException e) {
-            LOGGER.log(Level.INFO, "input stream reading failed", e); //$NON-NLS-1$
-        }
-    }
-
-    /** Print a character on the console.
-     * 
-     * @param out the console
-     * @param c the character
-     * @throws CommandRunException if the console failed to print the character. */
-    private void printCharacter(final ConsoleOutput out, char c)
-            throws CommandRunException {
-        try {
-            out.print(Character.toString(c));
-        } catch (final IOException e) {
-            throw new CommandRunException(CommandRunExceptionType.INTERACTION,
-                    MANAGER_WAS_CLOSED, e); // $NON-NLS-1$
-        }
-    }
-
    /* (non-Javadoc)
     * @see fr.bigeon.gclc.command.ICommand#tip() */
    @Override
@@ -166,7 +126,7 @@ public class ExecSystemCommand extends Command {
        return "  The system command is a system dependend command like sh on linux or" + //$NON-NLS-1$
                System.lineSeparator() + "powershell on windows." + //$NON-NLS-1$
                System.lineSeparator() + System.lineSeparator()
-                + "  As an example if you give \"cat /etc/hostname\" as argument, on a linux" //$NON-NLS-1$
+                + "  As an example if you give \"cat\", \"/etc/hostname\" as arguments, on a linux" //$NON-NLS-1$
                + System.lineSeparator() + "system, you would get the computer name." + //$NON-NLS-1$
                System.lineSeparator();
    }
@@ -177,5 +137,4 @@ public class ExecSystemCommand extends Command {
    protected String usagePattern() {
        return "  CMD <system command>"; //$NON-NLS-1$
    }
-
 }
--- a/gclc.system/src/main/java/net/bigeon/gclc/system/ForwardingRunnable.java
+++ b/gclc.system/src/main/java/net/bigeon/gclc/system/ForwardingRunnable.java
@@ -0,0 +1,144 @@
+package net.bigeon.gclc.system;
+
+/*-
+ * #%L
+ * GCLC system command
+ * %%
+ * Copyright (C) 2016 - 2018 Bigeon
+ * %%
+ * This software is governed by the CeCILL  license under French law and
+ * abiding by the rules of distribution of free software.  You can  use,
+ * modify and/ or redistribute the software under the terms of the CeCILL
+ * license as circulated by CEA, CNRS and INRIA at the following URL
+ * "http://www.cecill.info".
+ * 
+ * As a counterpart to the access to the source code and  rights to copy,
+ * modify and redistribute granted by the license, users are provided only
+ * with a limited warranty  and the software's author,  the holder of the
+ * economic rights,  and the successive licensors  have only  limited
+ * liability.
+ * 
+ * In this respect, the user's attention is drawn to the risks associated
+ * with loading,  using,  modifying and/or developing or reproducing the
+ * software by the user in light of its specific status of free software,
+ * that may mean  that it is complicated to manipulate,  and  that  also
+ * therefore means  that it is reserved for developers  and  experienced
+ * professionals having in-depth computer knowledge. Users are therefore
+ * encouraged to load and test the software's suitability as regards their
+ * requirements in conditions enabling the security of their systems and/or
+ * data to be ensured and,  more generally, to use and operate it in the
+ * same conditions as regards security.
+ * 
+ * The fact that you are presently reading this means that you have had
+ * knowledge of the CeCILL license and that you accept its terms.
+ * #L%
+ */
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import net.bigeon.gclc.exception.CommandRunException;
+import net.bigeon.gclc.exception.CommandRunExceptionType;
+import net.bigeon.gclc.manager.ConsoleOutput;
+
+/** A class forwarding the content of a stream into a console output.
+ * <p>
+ * This class is useful for processes that run in a different environment than
+ * the application but return an output. Such processes include command
+ * processes and socket communications for example.
+ * <p>
+ * In the current library is is used to retrieve a system command output.
+ * 
+ * @author Emmanuel Bigeon */
+public final class ForwardingRunnable implements Runnable {
+    /** Error message for the manager closed. */
+    private static final String MANAGER_WAS_CLOSED = "manager was closed";
+    /** The class logger */
+    private static final Logger LOGGER             = Logger
+            .getLogger(ForwardingRunnable.class.getName());
+
+    /** The console output. */
+    private final ConsoleOutput out;
+    /** The input stream. */
+    private final InputStream   is;
+
+    /** Create the runnable.
+     * 
+     * @param out the output console
+     * @param is the input stream */
+    public ForwardingRunnable(final ConsoleOutput out, final InputStream is) {
+        this.out = out;
+        this.is = is;
+    }
+
+    /* (non-Javadoc)
+     * @see java.lang.Runnable#run() */
+    @Override
+    public void run() {
+        try {
+            readToEnd(out, is);
+            is.close();
+        } catch (final CommandRunException e) {
+            LOGGER.log(Level.WARNING, "Manager was closed in the meantime...", e); //$NON-NLS-1$
+        } catch (final IOException e) {
+            LOGGER.log(Level.WARNING, "Input stream was closed...", e); //$NON-NLS-1$
+        }
+    }
+
+    /** Read the input until its end.
+     * 
+     * @param is the input stream
+     * @throws CommandRunException if the manager was closed while writing the
+     *         stream */
+    private static void readToEnd(final ConsoleOutput out, final InputStream is)
+            throws CommandRunException {
+        int c;
+        try {
+            while ((c = is.read()) >= 0) {
+                // Print the character in the output
+                printCharacter(out, (char) c);
+            }
+        } catch (final IOException e) {
+            LOGGER.log(Level.INFO, "input stream reading failed", e); //$NON-NLS-1$
+        }
+    }
+
+    /** Print a character on the console.
+     * 
+     * @param out the console
+     * @param c the character
+     * @throws CommandRunException if the console failed to print the character. */
+    private static void printCharacter(final ConsoleOutput out, final char c)
+            throws CommandRunException {
+        try {
+            out.print(Character.toString(c));
+        } catch (final IOException e) {
+            throw new CommandRunException(CommandRunExceptionType.INTERACTION,
+                    MANAGER_WAS_CLOSED, e); // $NON-NLS-1$
+        }
+    }
+
+    /** Tool method to connect an input stream to a console output.
+     * 
+     * @param stream the stream
+     * @param output the output
+     * @param name the identification of the thread
+     * @return the thread the forwarding runnable runs into. */
+    public static Thread connect(final InputStream stream, final ConsoleOutput output,
+            final String name) {
+        final Thread th = new Thread(new ForwardingRunnable(output, stream), name);
+        th.start();
+        return th;
+    }
+
+    /** Tool method to connect an input stream to a console output.
+     * 
+     * @param stream the stream
+     * @param output the output
+     * @return the thread the forwarding runnable runs into. */
+    public static Thread connect(final InputStream stream, final ConsoleOutput output) {
+        return connect(stream, output, "Forwarding");
+    }
+}
--- a/gclc.system/src/main/java/net/bigeon/gclc/system/package-info.java
+++ b/gclc.system/src/main/java/net/bigeon/gclc/system/package-info.java
@@ -6,3 +6,37 @@
 * 
 * @author Emmanuel Bigeon */
 package net.bigeon.gclc.system;
+
+/*-
+ * #%L
+ * GCLC system command
+ * %%
+ * Copyright (C) 2016 - 2018 Bigeon
+ * %%
+ * This software is governed by the CeCILL  license under French law and
+ * abiding by the rules of distribution of free software.  You can  use,
+ * modify and/ or redistribute the software under the terms of the CeCILL
+ * license as circulated by CEA, CNRS and INRIA at the following URL
+ * "http://www.cecill.info".
+ * 
+ * As a counterpart to the access to the source code and  rights to copy,
+ * modify and redistribute granted by the license, users are provided only
+ * with a limited warranty  and the software's author,  the holder of the
+ * economic rights,  and the successive licensors  have only  limited
+ * liability.
+ * 
+ * In this respect, the user's attention is drawn to the risks associated
+ * with loading,  using,  modifying and/or developing or reproducing the
+ * software by the user in light of its specific status of free software,
+ * that may mean  that it is complicated to manipulate,  and  that  also
+ * therefore means  that it is reserved for developers  and  experienced
+ * professionals having in-depth computer knowledge. Users are therefore
+ * encouraged to load and test the software's suitability as regards their
+ * requirements in conditions enabling the security of their systems and/or
+ * data to be ensured and,  more generally, to use and operate it in the
+ * same conditions as regards security.
+ * 
+ * The fact that you are presently reading this means that you have had
+ * knowledge of the CeCILL license and that you accept its terms.
+ * #L%
+ */
--- a/gclc.system/src/test/java/net/bigeon/gclc/system/ExecSystemCommandTest.java
+++ b/gclc.system/src/test/java/net/bigeon/gclc/system/ExecSystemCommandTest.java
@@ -0,0 +1,82 @@
+package net.bigeon.gclc.system;
+
+/*-
+ * #%L
+ * GCLC system command
+ * %%
+ * Copyright (C) 2016 - 2018 Bigeon
+ * %%
+ * This software is governed by the CeCILL  license under French law and
+ * abiding by the rules of distribution of free software.  You can  use,
+ * modify and/ or redistribute the software under the terms of the CeCILL
+ * license as circulated by CEA, CNRS and INRIA at the following URL
+ * "http://www.cecill.info".
+ * 
+ * As a counterpart to the access to the source code and  rights to copy,
+ * modify and redistribute granted by the license, users are provided only
+ * with a limited warranty  and the software's author,  the holder of the
+ * economic rights,  and the successive licensors  have only  limited
+ * liability.
+ * 
+ * In this respect, the user's attention is drawn to the risks associated
+ * with loading,  using,  modifying and/or developing or reproducing the
+ * software by the user in light of its specific status of free software,
+ * that may mean  that it is complicated to manipulate,  and  that  also
+ * therefore means  that it is reserved for developers  and  experienced
+ * professionals having in-depth computer knowledge. Users are therefore
+ * encouraged to load and test the software's suitability as regards their
+ * requirements in conditions enabling the security of their systems and/or
+ * data to be ensured and,  more generally, to use and operate it in the
+ * same conditions as regards security.
+ * 
+ * The fact that you are presently reading this means that you have had
+ * knowledge of the CeCILL license and that you accept its terms.
+ * #L%
+ */
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.fail;
+
+import org.junit.Test;
+
+import net.bigeon.gclc.exception.CommandRunException;
+import net.bigeon.gclc.manager.ConsoleInput;
+import net.bigeon.gclc.manager.ConsoleOutput;
+import net.bigeon.gclc.utils.EmptyInput;
+import net.bigeon.gclc.utils.SinkOutput;
+
+public class ExecSystemCommandTest {
+
+    /** Test the help methods of the command. */
+    @Test
+    public void testExecSystemCommand() {
+        final ExecSystemCommand cmd = new ExecSystemCommand("test");
+        assertEquals("Name should be preserved", "test", cmd.getCommandName());
+        assertNotNull("tip should be defined", cmd.tip());
+        assertNotNull("usage should be defined", cmd.usagePattern());
+        assertNotNull("usage should be defined", cmd.usageDetail());
+    }
+
+    /** Test the execution of the command.
+     * 
+     * @throws CommandRunException */
+    @Test
+    public void testExecute() throws CommandRunException {
+        final ConsoleOutput out = SinkOutput.INSTANCE;
+        final ConsoleInput in = EmptyInput.INSTANCE;
+
+        final ExecSystemCommand cmd = new ExecSystemCommand();
+        if (System.getProperty("os.name").contains("indows")) {
+            cmd.execute(out, in, "cmd", "/C", "dir");
+        } else if (System.getProperty("os.name").contains("inux")) {
+            cmd.execute(out, in, "ls");
+        }
+        try {
+            cmd.execute(out, in, "inexistent");
+            fail("Able to execute inexistent command in system");
+        } catch (final CommandRunException e) {
+            // ok
+        }
+    }
+
+}
--- a/gclc/pom.xml
+++ b/gclc/pom.xml
@@ -1,10 +1,44 @@

 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
 	<modelVersion>4.0.0</modelVersion>
+	<parent>
+		<groupId>net.bigeon.config</groupId>
+		<artifactId>ebigeon-config</artifactId>
+		<version>1.8.21</version>
+	</parent>
+	<groupId>net.bigeon</groupId>
 	<artifactId>gclc</artifactId>
-	<version>2.0.10-SNAPSHOT</version>
+	<version>2.0.12-SNAPSHOT</version>
 	<packaging>jar</packaging>
-	<url>http://bigeon.net</url>
+	<name>Generic Command Ligne console</name>
+	<description>A generic framework for console applications, with customized command input and output streams.</description>
+	<url>https://bigeon.net/projects/gclc.html</url>
+	<inceptionYear>2014</inceptionYear>
+	<organization>
+		<name>Bigeon</name>
+		<url>https://bigeon.net/</url>
+	</organization>
+	<licenses>
+		<license>
+			<distribution>manual</distribution>
+			<name>CeCILL 2.1</name>
+			<url>https://cecill.info/licences/Licence_CeCILL_V2.1-en.html</url>
+		</license>
+	</licenses>
+	<developers>
+		<developer>
+			<email>emmanuel@bigeon.fr</email>
+			<name>Emmanuel Bigeon</name>
+			<url>bigeon.net</url>
+			<roles>
+				<role>PM</role>
+			</roles>
+		</developer>
+	</developers>
+	<scm>
+		<developerConnection>scm:git:gogs@git.code.bigeon.net:emmanuel/gclc.git</developerConnection>
+		<tag>HEAD</tag>
+	</scm>
 	<properties>
 		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
 		<project.scm.id>git.code.bigeon.net</project.scm.id>
@@ -13,17 +47,12 @@
 	</properties>
 	<dependencies>
 		<dependency>
-			<groupId>junit</groupId>
-			<artifactId>junit</artifactId>
-			<version>4.11</version>
+			<groupId>net.bigeon.test</groupId>
+			<artifactId>junitmt</artifactId>
+			<version>1.0.0</version>
 			<scope>test</scope>
 		</dependency>
 	</dependencies>
-	<parent>
-		<groupId>net.bigeon.config</groupId>
-		<artifactId>ebigeon-config</artifactId>
-		<version>1.8.12</version>
-	</parent>
 	<build>
 		<plugins>
 			<plugin>
@@ -38,13 +67,6 @@
 			</plugin>
 		</plugins>
 	</build>
-	<licenses>
-		<license>
-			<distribution>manual</distribution>
-			<name>CeCILL 2.1</name>
-			<url>https://cecill.info/licences/Licence_CeCILL_V2.1-en.html</url>
-		</license>
-	</licenses>
 	<reporting>
 		<plugins>
 			<plugin>
@@ -59,22 +81,4 @@
 			</plugin>
 		</plugins>
 	</reporting>
-	<developers>
-		<developer>
-			<email>emmanuel@bigeon.fr</email>
-			<name>Emmanuel Bigeon</name>
-			<url>bigeon.net</url>
-			<roles>
-				<role>PM</role>
-			</roles>
-		</developer>
-	</developers>
-	<inceptionYear>2014</inceptionYear>
-	<name>Generic Command Ligne console</name>
-	<description>A generic framework for console applications, with customized command input and output streams.</description>
-	<scm>
-		<developerConnection>scm:git:gogs@git.code.bigeon.net:emmanuel/gclc.git</developerConnection>
-		<tag>HEAD</tag>
-	</scm>
-	<groupId>net.bigeon</groupId>
 </project>
--- a/gclc/src/main/java/net/bigeon/gclc/command/base/EchoCommand.java
+++ b/gclc/src/main/java/net/bigeon/gclc/command/base/EchoCommand.java
@@ -0,0 +1,100 @@
+/*
+ * ralph.runner, Runs RALPH (belongs to IREQ) in sequence for several days
+ * Copyright (C) 2016-2018 E. Bigeon
+ * mailto:emmanuel@bigeon.fr
+ *
+ * This software is governed by the CeCILL license under French law and
+ * abiding by the rules of distribution of free software.  You can  use,
+ * modify and/or redistribute the software under the terms of the CeCILL
+ * license as circulated by CEA, CNRS and INRIA at the following URL
+ * "http://www.cecill.info".
+ *
+ * As a counterpart to the access to the source code and  rights to copy,
+ * modify and redistribute granted by the license, users are provided only
+ * with a limited warranty  and the software's author,  the holder of the
+ * economic rights,  and the successive licensors  have only  limited
+ * liability.
+ *
+ * In this respect, the user's attention is drawn to the risks associated
+ * with loading,  using,  modifying and/or developing or reproducing the
+ * software by the user in light of its specific status of free software,
+ * that may mean  that it is complicated to manipulate,  and  that  also
+ * therefore means  that it is reserved for developers  and  experienced
+ * professionals having in-depth computer knowledge. Users are therefore
+ * encouraged to load and test the software's suitability as regards their
+ * requirements in conditions enabling the security of their systems and/or
+ * data to be ensured and,  more generally, to use and operate it in the
+ * same conditions as regards security.
+ *
+ * The fact that you are presently reading this means that you have had
+ * knowledge of the CeCILL license and that you accept its terms.
+ */
+/**
+ * 
+ */
+package net.bigeon.gclc.command.base;
+
+import java.io.IOException;
+import java.text.MessageFormat;
+import java.util.Arrays;
+
+import net.bigeon.gclc.command.Command;
+import net.bigeon.gclc.exception.CommandRunException;
+import net.bigeon.gclc.manager.ConsoleInput;
+import net.bigeon.gclc.manager.ConsoleOutput;
+
+/** A command printing test to the console.
+ * <p>
+ * This command mimics the effect of the echo command in linux system. The
+ * difference is this command accepts java like formatting.
+ * 
+ * <pre>
+ * echo.execute(out, in, "My Formatted {0}, with {1}", "message", "short arguments");
+ * </pre>
+ * 
+ * @author Emmanuel Bigeon */
+public class EchoCommand extends Command {
+
+    /** Create the command.
+     * 
+     * @param name the command name */
+    public EchoCommand(final String name) {
+        super(name);
+    }
+
+    /* (non-Javadoc)
+     * @see
+     * fr.bigeon.gclc.command.ICommand#execute(fr.bigeon.gclc.manager.ConsoleOutput,
+     * fr.bigeon.gclc.manager.ConsoleInput, java.lang.String[]) */
+    @Override
+    public void execute(final ConsoleOutput out, final ConsoleInput in,
+            final String... args) throws CommandRunException {
+        try {
+            if (args.length == 1) {
+                out.print(args[0]);
+            }
+            if (args.length > 1) {
+                out.print(MessageFormat.format(args[0],
+                        (Object[]) Arrays.copyOfRange(args, 1, args.length)));
+            }
+            out.println();
+        } catch (final IOException e) {
+            throw new CommandRunException("Printing failed", e);
+        }
+    }
+
+    /* (non-Javadoc)
+     * @see fr.bigeon.gclc.command.ICommand#tip() */
+    @Override
+    public String tip() {
+        return "Print the message";
+    }
+
+    /* (non-Javadoc)
+     * @see fr.bigeon.gclc.command.Command#usageDetail() */
+    @Override
+    protected String usageDetail() {
+        return "A formatted message can be used";
+    }
+
+}
--- a/gclc/src/main/java/net/bigeon/gclc/tools/ConstantString.java
+++ b/gclc/src/main/java/net/bigeon/gclc/tools/ConstantString.java
@@ -77,7 +77,7 @@ public class ConstantString implements StringProvider {
    /** Create a provider for a string.
     *
     * @param string the string */
-    public ConstantString(String string) {
+    public ConstantString(final String string) {
        this.string = string;
    }

@@ -87,4 +87,38 @@ public class ConstantString implements StringProvider {
    public String apply() {
        return string;
    }
+
+    /* (non-Javadoc)
+     * @see java.lang.Object#hashCode() */
+    @Override
+    public int hashCode() {
+        final int prime = 31;
+        int result = 1;
+        result = prime * result + ((string == null) ? 0 : string.hashCode());
+        return result;
+    }
+
+    /* (non-Javadoc)
+     * @see java.lang.Object#equals(java.lang.Object) */
+    @Override
+    public boolean equals(final Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (obj == null) {
+            return false;
+        }
+        if (getClass() != obj.getClass()) {
+            return false;
+        }
+        final ConstantString other = (ConstantString) obj;
+        if (string == null) {
+            if (other.string != null) {
+                return false;
+            }
+        } else if (!string.equals(other.string)) {
+            return false;
+        }
+        return true;
+    }
 }
--- a/gclc/src/main/java/net/bigeon/gclc/utils/ReadingRunnable.java
+++ b/gclc/src/main/java/net/bigeon/gclc/utils/ReadingRunnable.java
@@ -177,7 +177,7 @@ public final class ReadingRunnable implements Runnable {
        }
    }
    
-    public void waitForDelivery(String message) throws InterruptedException {
+    public void waitForDelivery(final String message) throws InterruptedException {
        Object mLock;
        synchronized (messageBlockerLock) {
            if (!messageBlocker.containsKey(message)) {
@@ -196,10 +196,11 @@ public final class ReadingRunnable implements Runnable {
     * @throws IOException if the pipe is closed */
    public boolean hasMessage() throws IOException {
        synchronized (lock) {
-            if (!running) {
+            final boolean empty = messages.isEmpty();
+            if (!running && empty) {
                throw new IOException(CLOSED_PIPE);
            }
-            return !messages.isEmpty();
+            return !empty;
        }
    }

--- a/gclc/src/test/java/net/bigeon/gclc/command/ParametrizedCommandTest.java
+++ b/gclc/src/test/java/net/bigeon/gclc/command/ParametrizedCommandTest.java
@@ -93,6 +93,8 @@ import net.bigeon.gclc.manager.ConsoleInput;
 import net.bigeon.gclc.manager.ConsoleOutput;
 import net.bigeon.gclc.utils.PipedConsoleInput;
 import net.bigeon.gclc.utils.PipedConsoleOutput;
+import net.bigeon.test.junitmt.ATestRunnable;
+import net.bigeon.test.junitmt.ThreadTest;

 /**
 * <p>
@@ -509,10 +511,10 @@ public class ParametrizedCommandTest {
            cmd.execute(out, in, "-" + str1, str2, "-" + addParam);
            cmd.execute(out, in, "-" + str1, str2, "-" + addParam, addParam);

-            final Thread th = new Thread(new Runnable() {
+            final ATestRunnable testConsole = new ATestRunnable() {

                @Override
-                public void run() {
+                protected void testRun() {
                    try {
                        assertEquals("value of " + str1 + "? ", buf.readLine());
                        in.type("");
@@ -523,15 +525,17 @@ public class ParametrizedCommandTest {
                                buf.readLine());
                        in.type(str2);
                    } catch (final IOException e) {
-                        assertNull(e);
+                        fail("IO exception in test");
                    }
                }
-            });
+            };
+
+            final Thread th = new Thread(testConsole);
            th.start();

            cmd.execute(out, in);

-            th.join();
+            ThreadTest.assertRuns(th, testConsole);
        }
        try (PipedConsoleOutput out = new PipedConsoleOutput();
                PipedOutputStream pout = new PipedOutputStream();
@@ -540,23 +544,25 @@ public class ParametrizedCommandTest {
                        new InputStreamReader(pis, StandardCharsets.UTF_8));
                PipedConsoleInput in = new PipedConsoleInput(new PrintStream(pout))) {

-            final Thread th = new Thread(new Runnable() {
+            final ATestRunnable testConsole = new ATestRunnable() {

                @Override
-                public void run() {
+                protected void testRun() {
                    try {
                        assertEquals("value of " + str1 + "? ", buf.readLine());
                        in.type(str2);
                    } catch (final IOException e) {
-                        assertNull(e);
+                        fail("IO exception in test");
                    }
                }
-            });
+            };
+
+            final Thread th = new Thread(testConsole);
            th.start();

            cmd.execute(out, in, "-" + addParam);

-            th.join();
+            ThreadTest.assertRuns(th, testConsole);
        }
        try {
            final PipedConsoleOutput out = new PipedConsoleOutput();
--- a/gclc/src/test/java/net/bigeon/gclc/command/base/EchoCommandTest.java
+++ b/gclc/src/test/java/net/bigeon/gclc/command/base/EchoCommandTest.java
@@ -0,0 +1,44 @@
+package net.bigeon.gclc.command.base;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.fail;
+
+import java.io.IOException;
+
+import org.junit.Test;
+
+import net.bigeon.gclc.exception.CommandRunException;
+import net.bigeon.gclc.utils.PipedConsoleOutput;
+
+public class EchoCommandTest {
+
+    @Test
+    public void testExecute() throws IOException, CommandRunException {
+        final EchoCommand echo = new EchoCommand("echo");
+        assertNotNull("Help tip should be specified", echo.tip());
+        assertNotNull("Usage should be specified", echo.usageDetail());
+
+        try (PipedConsoleOutput out = new PipedConsoleOutput()) {
+            echo.execute(out, null);
+            assertEquals("Echo should print a line", "", out.readNextLine());
+
+            echo.execute(out, null, "Message");
+            assertEquals("Echo should print argument", "Message", out.readNextLine());
+
+            echo.execute(out, null, "Message {0}", "with parameter");
+            assertEquals("Echo should format string and print", "Message with parameter",
+                    out.readNextLine());
+        }
+
+        final PipedConsoleOutput out = new PipedConsoleOutput();
+        out.close();
+        try {
+            echo.execute(out, null);
+            fail("Should not be able to print in closed outputs");
+        } catch (final CommandRunException e) {
+            // expected
+        }
+    }
+
+}
--- a/gclc/src/test/java/net/bigeon/gclc/prompt/CLIPrompterTest.java
+++ b/gclc/src/test/java/net/bigeon/gclc/prompt/CLIPrompterTest.java
@@ -94,6 +94,8 @@ import org.junit.Test;

 import net.bigeon.gclc.utils.PipedConsoleInput;
 import net.bigeon.gclc.utils.PipedConsoleOutput;
+import net.bigeon.test.junitmt.ATestRunnable;
+import net.bigeon.test.junitmt.ThreadTest;

 /**
 * <p>
@@ -115,19 +117,21 @@ public class CLIPrompterTest {
    }

    /** Test method for
-     * {@link net.bigeon.gclc.prompt.CLIPrompter#promptBoolean(net.bigeon.gclc.manager.ConsoleOutput, net.bigeon.gclc.manager.ConsoleInput, String)}. */
+     * {@link net.bigeon.gclc.prompt.CLIPrompter#promptBoolean(net.bigeon.gclc.manager.ConsoleOutput, net.bigeon.gclc.manager.ConsoleInput, String)}.
+     * 
+     * @throws IOException if an io occurs */
    @Test
-    public final void testPromptBoolean() {
+    public final void testPromptBoolean() throws IOException {
        try (final PipedConsoleOutput out = new PipedConsoleOutput();
                PipedOutputStream pout = new PipedOutputStream();
                PipedInputStream pis = new PipedInputStream(pout);
                BufferedReader buf = new BufferedReader(
                        new InputStreamReader(pis, StandardCharsets.UTF_8));
                PipedConsoleInput in = new PipedConsoleInput(new PrintStream(pout))) {
-            final Thread th = new Thread(new Runnable() {
+            final ATestRunnable target = new ATestRunnable() {

                @Override
-                public void run() {
+                public void testRun() {
                    try {
                        assertTrue(CLIPrompter.promptBoolean(out, in, "My message")); //$NON-NLS-1$
                        assertTrue(CLIPrompter.promptBoolean(out, in, "My message")); //$NON-NLS-1$
@@ -135,10 +139,10 @@ public class CLIPrompterTest {
                        assertFalse(CLIPrompter.promptBoolean(out, in, "My message")); //$NON-NLS-1$
                    } catch (final IOException e) {
                        fail("Unexpected io excpetion"); //$NON-NLS-1$
-                        e.printStackTrace();
                    }
                }
-            });
+            };
+            final Thread th = new Thread(target);
            th.start();
            assertTrue(buf.readLine().startsWith("My message")); //$NON-NLS-1$
            in.type(""); //$NON-NLS-1$
@@ -151,10 +155,7 @@ public class CLIPrompterTest {
            in.type("N"); //$NON-NLS-1$
            assertTrue(buf.readLine().startsWith("My message")); //$NON-NLS-1$
            in.type("nO"); //$NON-NLS-1$
-            th.join();
-        } catch (IOException | InterruptedException e) {
-            fail("Unexpected excpetion"); //$NON-NLS-1$
-            e.printStackTrace();
+            ThreadTest.assertRuns(th, target);
        }

    }
@@ -1080,10 +1081,10 @@ public class CLIPrompterTest {
            choices.put(keys.get(1), "The actual other"); //$NON-NLS-1$
            final String message = "My message"; //$NON-NLS-1$

-            final Thread th = new Thread(new Runnable() {
+            final ATestRunnable target = new ATestRunnable() {

                @Override
-                public void run() {
+                public void testRun() {
                    try {
                        assertTrue("Asserted provided value to be retrieved", CLIPrompter
                                .promptMultiChoice(out, in, keys, choices, message)
@@ -1102,7 +1103,8 @@ public class CLIPrompterTest {
                        e.printStackTrace();
                    }
                }
-            });
+            };
+            final Thread th = new Thread(target);
            th.start();
            assertTrue(out.readNextLine().startsWith(message));
            final String readNextLine = out.readNextLine();
@@ -1135,8 +1137,8 @@ public class CLIPrompterTest {
            assertTrue(out.readNextLine().contains(keys.get(0).toString()));
            assertTrue(out.readNextLine().contains(keys.get(1).toString()));
            in.type("0 1"); //$NON-NLS-1$
-            th.join();
-        } catch (IOException | InterruptedException e) {
+            ThreadTest.assertRuns(th, target);
+        } catch (final IOException e) {
            fail("Unexpected excpetion, the other thread probably failed"); //$NON-NLS-1$
            e.printStackTrace();
        }
@@ -1152,28 +1154,28 @@ public class CLIPrompterTest {
                        new InputStreamReader(pis, StandardCharsets.UTF_8));
                PipedConsoleInput in = new PipedConsoleInput(new PrintStream(pout))) {
            final String res = "some content"; //$NON-NLS-1$
-            final Thread th = new Thread(new Runnable() {
+            final ATestRunnable target = new ATestRunnable() {

                @Override
-                public void run() {
+                public void testRun() {
                    try {
                        assertEquals("Expected provided message to be returned", res,
                                CLIPrompter.promptNonEmpty(in, "My message", //$NON-NLS-1$
                                        "my reprompt")); //$NON-NLS-1$
                    } catch (final IOException e) {
                        fail("Unexpected io excpetion"); //$NON-NLS-1$
-                        e.printStackTrace();
                    }
                }
-            });
+            };
+            final Thread th = new Thread(target);
            th.start();
            assertTrue(buf.readLine().startsWith("My message")); //$NON-NLS-1$
            in.type(""); //$NON-NLS-1$
            assertTrue(buf.readLine().startsWith("my reprompt")); //$NON-NLS-1$
            in.type(res);
-            th.join();
+            ThreadTest.assertRuns(th, target);

-        } catch (IOException | InterruptedException e) {
+        } catch (final IOException e) {
            fail("Unexpected excpetion"); //$NON-NLS-1$
            e.printStackTrace();
        }
Author	SHA1	Message	Date
Emmanuel Bigeon	e1d030c6c5	[maven-release-plugin] prepare release swt-1.1.6	2018-10-27 16:39:10 -04:00
Emmanuel Bigeon	8bc2b13a92	[maven-release-plugin] prepare for next development iteration	2018-10-27 15:58:12 -04:00
Emmanuel Bigeon	c1050b1b4f	[maven-release-plugin] prepare release socket-1.1.13	2018-10-27 15:58:09 -04:00
Emmanuel Bigeon	a3e4758d1b	[maven-release-plugin] prepare for next development iteration	2018-10-27 14:54:06 -04:00
Emmanuel Bigeon	c436b5af2f	[maven-release-plugin] prepare release process-0.0.4	2018-10-27 14:54:03 -04:00
Emmanuel Bigeon	3272261be1	[maven-release-plugin] prepare for next development iteration	2018-10-27 14:42:49 -04:00
Emmanuel Bigeon	f82f0b9f16	[maven-release-plugin] prepare release system-0.0.2	2018-10-27 14:42:41 -04:00
Emmanuel Bigeon	1fa9ca213e	Fix process forwarding of Signed-off-by: Emmanuel Bigeon <emmanuel@bigeon.fr>	2018-10-27 14:42:22 -04:00
Emmanuel Bigeon	265f90526a	Update dependency versions Signed-off-by: Emmanuel Bigeon <emmanuel@bigeon.fr>	2018-10-27 14:38:07 -04:00
Emmanuel Bigeon	71b325508f	[maven-release-plugin] prepare for next development iteration	2018-10-27 14:27:47 -04:00
Emmanuel Bigeon	98857e425a	[maven-release-plugin] prepare release gclc-2.0.11	2018-10-27 14:27:44 -04:00
Emmanuel Bigeon	8c6b1d8884	minor conventions Signed-off-by: Emmanuel Bigeon <emmanuel@bigeon.fr>	2018-10-27 14:18:32 -04:00
Emmanuel Bigeon	2972e82f4a	fix interlocks Signed-off-by: Emmanuel Bigeon <emmanuel@bigeon.fr>	2018-10-27 14:17:19 -04:00
Emmanuel Bigeon	0ab39b24f6	Fix available message test Signed-off-by: Emmanuel Bigeon <emmanuel@bigeon.fr>	2018-10-27 14:02:31 -04:00
Emmanuel Bigeon	171f79518d	Made port public constant Signed-off-by: Emmanuel Bigeon <emmanuel@bigeon.fr>	2018-10-27 14:02:21 -04:00
Emmanuel Bigeon	0e422a81ce	Added equals Signed-off-by: Emmanuel Bigeon <emmanuel@bigeon.fr>	2018-10-27 14:01:53 -04:00
Emmanuel Bigeon	ea4164fbfb	Added tests Signed-off-by: Emmanuel Bigeon <emmanuel@bigeon.fr>	2018-10-27 14:01:42 -04:00
Emmanuel Bigeon	e2f45c77d9	Comment Signed-off-by: Emmanuel Bigeon <emmanuel@bigeon.fr>	2018-10-27 09:56:07 -04:00
Emmanuel Bigeon	55bb54ca43	Added tool methods for most common uses Signed-off-by: Emmanuel Bigeon <emmanuel@bigeon.fr>	2018-10-27 09:50:28 -04:00
Emmanuel Bigeon	cf29eb37cc	Move test thread in test runnable Signed-off-by: Emmanuel Bigeon <emmanuel@bigeon.fr>	2018-10-27 09:40:56 -04:00
Emmanuel Bigeon	579e85dcb3	Update pom Signed-off-by: Emmanuel Bigeon <emmanuel@bigeon.fr>	2018-10-27 09:40:42 -04:00
Emmanuel Bigeon	7e36a378c4	documentation Signed-off-by: Emmanuel Bigeon <emmanuel@bigeon.fr>	2018-10-26 16:09:04 -04:00
Emmanuel Bigeon	80242c79e8	Added test of command on linux system Signed-off-by: Emmanuel Bigeon <emmanuel@bigeon.fr>	2018-10-26 15:39:54 -04:00
Emmanuel Bigeon	ab9a4c474b	Made method static Signed-off-by: Emmanuel Bigeon <emmanuel@bigeon.fr>	2018-10-26 15:37:25 -04:00
Emmanuel Bigeon	b8e5ea0b78	Fix pom order Signed-off-by: Emmanuel Bigeon <emmanuel@bigeon.fr>	2018-10-26 11:27:09 -04:00
Emmanuel Bigeon	2637d99bce	Update pom Signed-off-by: Emmanuel Bigeon <emmanuel@bigeon.fr>	2018-10-26 11:14:54 -04:00
Emmanuel Bigeon	cfd3450afe	[maven-release-plugin] prepare for next development iteration	2018-10-26 11:12:48 -04:00
Emmanuel Bigeon	20d5a84269	[maven-release-plugin] prepare release socket-1.1.12	2018-10-26 11:12:46 -04:00
Emmanuel Bigeon	637cfb8f43	increment in separate statement. string construction Signed-off-by: Emmanuel Bigeon <emmanuel@bigeon.fr>	2018-10-26 11:11:24 -04:00
Emmanuel Bigeon	d7fbdfb66b	Fix pom order Signed-off-by: Emmanuel Bigeon <emmanuel@bigeon.fr>	2018-10-26 11:10:17 -04:00
Emmanuel Bigeon	22741104f5	update depencies Signed-off-by: Emmanuel Bigeon <emmanuel@bigeon.fr>	2018-10-26 10:16:38 -04:00
Emmanuel Bigeon	45c5375118	[maven-release-plugin] prepare for next development iteration	2018-10-26 10:11:30 -04:00
Emmanuel Bigeon	d01b1608f3	[maven-release-plugin] prepare release gclc-2.0.10	2018-10-26 10:11:27 -04:00
Emmanuel Bigeon	674333a42c	Added comment and test Signed-off-by: Emmanuel Bigeon <emmanuel@bigeon.fr>	2018-10-26 10:09:33 -04:00
Emmanuel Bigeon	af0c8e91f8	Order pom elements Signed-off-by: Emmanuel Bigeon <emmanuel@bigeon.fr>	2018-10-26 09:31:01 -04:00
Emmanuel Bigeon	461dec8894	Update poms Signed-off-by: Emmanuel Bigeon <emmanuel@bigeon.fr>	2018-10-26 09:15:43 -04:00
Emmanuel Bigeon	f590542b3f	Add jenkins file Signed-off-by: Emmanuel Bigeon <emmanuel@bigeon.fr>	2018-10-26 09:07:08 -04:00
Emmanuel Bigeon	c21517a53d	license fix Signed-off-by: Emmanuel Bigeon <emmanuel@bigeon.fr>	2018-10-26 09:06:49 -04:00
Emmanuel Bigeon	7e3b727024	Add echo command Signed-off-by: Emmanuel Bigeon <emmanuel@bigeon.fr>	2018-10-26 09:06:28 -04:00
Emmanuel Bigeon	bd5b67c312	Move runnable to external class definition Signed-off-by: Emmanuel Bigeon <emmanuel@bigeon.fr>	2018-10-26 09:05:40 -04:00
Emmanuel Bigeon	216cd41dc8	format and commands Signed-off-by: Emmanuel Bigeon <emmanuel@bigeon.fr>	2018-10-16 19:07:33 -04:00
Emmanuel Bigeon	1df33afdbe	Name convention Signed-off-by: Emmanuel Bigeon <emmanuel@bigeon.fr>	2018-10-15 12:22:47 -04:00
Emmanuel Bigeon	8d51733590	Made shell invisible in tests. added shell style access Signed-off-by: Emmanuel Bigeon <emmanuel@bigeon.fr>	2018-10-15 12:19:23 -04:00
Emmanuel Bigeon	d49a2474e0	Format Signed-off-by: Emmanuel Bigeon <emmanuel@bigeon.fr>	2018-10-15 12:19:09 -04:00
Emmanuel Bigeon	d7ecd75678	Clean up Signed-off-by: Emmanuel Bigeon <emmanuel@bigeon.fr>	2018-10-15 12:01:10 -04:00
Emmanuel Bigeon	31ad72567a	Javadoc Signed-off-by: Emmanuel Bigeon <emmanuel@bigeon.fr>	2018-10-15 11:42:40 -04:00
Emmanuel Bigeon	99134c1831	Update config Signed-off-by: Emmanuel Bigeon <emmanuel@bigeon.fr>	2018-10-15 11:42:32 -04:00
Emmanuel Bigeon	dc988a07ac	Clean up. Signed-off-by: Emmanuel Bigeon <emmanuel@bigeon.fr>	2018-10-15 10:57:47 -04:00
Emmanuel Bigeon	4d31bbacbf	Removed unecessary throw declarations Signed-off-by: Emmanuel Bigeon <emmanuel@bigeon.fr>	2018-10-15 10:57:22 -04:00
Emmanuel Bigeon	2145473706	Added test for command Signed-off-by: Emmanuel Bigeon <emmanuel@bigeon.fr>	2018-10-15 10:19:39 -04:00
Emmanuel Bigeon	3f8cee20e1	move protected to private Signed-off-by: Emmanuel Bigeon <emmanuel@bigeon.fr>	2018-10-15 09:48:39 -04:00
Emmanuel Bigeon	977c9a8ec8	Method factoring Signed-off-by: Emmanuel Bigeon <emmanuel@bigeon.fr>	2018-10-15 09:48:10 -04:00
Emmanuel Bigeon	889433d800	[maven-release-plugin] prepare for next development iteration	2018-10-15 09:36:03 -04:00