[maven-release-plugin] prepare release process-0.0.2

Signed-off-by: Emmanuel Bigeon <emmanuel@bigeon.fr>

gclc-process/pom.xml

@@ -1,60 +1,95 @@
-
+
-<!-- process, Distribution repositories and basic setup for Emmanuel Bigeon projects                                   -->
+<!-- process, Distribution repositories and basic setup for Emmanuel Bigeon projects                                   -->
-<!-- Copyright (C) 2014-2017 E. Bigeon                      -->
+<!-- Copyright (C) 2014-2018 E. Bigeon                      -->
-<!-- mailto:emmanuel@bigeon.fr                                                           -->
+<!-- mailto:emmanuel@bigeon.fr                                                           -->
-<!--                                                                           -->
+<!--                                                                           -->
-<!-- This software is governed by the CeCILL license under French law and      -->
+<!-- This software is governed by the CeCILL license under French law and      -->
-<!-- abiding by the rules of distribution of free software.  You can  use,     -->
+<!-- abiding by the rules of distribution of free software.  You can  use,     -->
-<!-- modify and/or redistribute the software under the terms of the CeCILL     -->
+<!-- modify and/or redistribute the software under the terms of the CeCILL     -->
-<!-- license as circulated by CEA, CNRS and INRIA at the following URL         -->
+<!-- license as circulated by CEA, CNRS and INRIA at the following URL         -->
-<!-- "http://www.cecill.info".                                                 -->
+<!-- "http://www.cecill.info".                                                 -->
-<!--                                                                           -->
+<!--                                                                           -->
-<!-- As a counterpart to the access to the source code and  rights to copy,    -->
+<!-- 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   -->
+<!-- modify and redistribute granted by the license, users are provided only   -->
-<!-- with a limited warranty  and the software's author,  the holder of the    -->
+<!-- with a limited warranty  and the software's author,  the holder of the    -->
-<!-- economic rights,  and the successive licensors  have only  limited        -->
+<!-- economic rights,  and the successive licensors  have only  limited        -->
-<!-- liability.                                                                -->
+<!-- liability.                                                                -->
-<!--                                                                           -->
+<!--                                                                           -->
-<!-- In this respect, the user's attention is drawn to the risks associated    -->
+<!-- In this respect, the user's attention is drawn to the risks associated    -->
-<!-- with loading,  using,  modifying and/or developing or reproducing the     -->
+<!-- with loading,  using,  modifying and/or developing or reproducing the     -->
-<!-- software by the user in light of its specific status of free software,    -->
+<!-- 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     -->
+<!-- that may mean  that it is complicated to manipulate,  and  that  also     -->
-<!-- therefore means  that it is reserved for developers  and  experienced     -->
+<!-- therefore means  that it is reserved for developers  and  experienced     -->
-<!-- professionals having in-depth computer knowledge. Users are therefore     -->
+<!-- professionals having in-depth computer knowledge. Users are therefore     -->
-<!-- encouraged to load and test the software's suitability as regards their   -->
+<!-- encouraged to load and test the software's suitability as regards their   -->
-<!-- requirements in conditions enabling the security of their systems and/or  -->
+<!-- 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     -->
+<!-- data to be ensured and,  more generally, to use and operate it in the     -->
-<!-- same conditions as regards security.                                      -->
+<!-- same conditions as regards security.                                      -->
-<!--                                                                           -->
+<!--                                                                           -->
-<!-- The fact that you are presently reading this means that you have had      -->
+<!-- The fact that you are presently reading this means that you have had      -->
-<!-- knowledge of the CeCILL license and that you accept its terms.            -->
+<!-- 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">
+<!-- process, Distribution repositories and basic setup for Emmanuel Bigeon projects                                   -->
-  <modelVersion>4.0.0</modelVersion>
+<!-- Copyright (C) 2014-2017 E. Bigeon                      -->
-
+<!-- mailto:emmanuel@bigeon.fr                                                           -->
-  <groupId>fr.bigeon.gclc</groupId>
+<!--                                                                           -->
-  <artifactId>process</artifactId>
+<!-- This software is governed by the CeCILL license under French law and      -->
-  <version>0.0.1-SNAPSHOT</version>
+<!-- abiding by the rules of distribution of free software.  You can  use,     -->
-  <packaging>jar</packaging>
+<!-- modify and/or redistribute the software under the terms of the CeCILL     -->
-
+<!-- license as circulated by CEA, CNRS and INRIA at the following URL         -->
-  <name>process</name>
+<!-- "http://www.cecill.info".                                                 -->
-  <url>http://maven.apache.org</url>
+<!--                                                                           -->
-
+<!-- As a counterpart to the access to the source code and  rights to copy,    -->
-  <properties>
+<!-- modify and redistribute granted by the license, users are provided only   -->
-    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+<!-- with a limited warranty  and the software's author,  the holder of the    -->
-  </properties>
+<!-- economic rights,  and the successive licensors  have only  limited        -->
-
+<!-- liability.                                                                -->
-  <parent>
+<!--                                                                           -->
-    <groupId>fr.bigeon</groupId>
+<!-- In this respect, the user's attention is drawn to the risks associated    -->
-    <artifactId>ebigeon-config</artifactId>
+<!-- with loading,  using,  modifying and/or developing or reproducing the     -->
-    <version>1.8.0</version>
+<!-- software by the user in light of its specific status of free software,    -->
-  </parent>
+<!-- that may mean  that it is complicated to manipulate,  and  that  also     -->
-  <dependencies>
+<!-- therefore means  that it is reserved for developers  and  experienced     -->
-    <dependency>
+<!-- professionals having in-depth computer knowledge. Users are therefore     -->
-      <groupId>fr.bigeon</groupId>
+<!-- encouraged to load and test the software's suitability as regards their   -->
-      <artifactId>gclc</artifactId>
+<!-- requirements in conditions enabling the security of their systems and/or  -->
-      <version>2.0.0</version>
+<!-- data to be ensured and,  more generally, to use and operate it in the     -->
-    </dependency>
+<!-- same conditions as regards security.                                      -->
-  </dependencies>
+<!--                                                                           -->
-</project>
+<!-- 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>
+
+  <groupId>fr.bigeon.gclc</groupId>
+  <artifactId>process</artifactId>
+  <version>0.0.2</version>
+  <packaging>jar</packaging>
+
+  <name>process</name>
+  <url>http://maven.apache.org</url>
+
+  <properties>
+    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+  </properties>
+
+  <parent>
+    <groupId>fr.bigeon.config</groupId>
+    <artifactId>ebigeon-config</artifactId>
+    <version>1.8.2</version>
+  </parent>
+  <dependencies>
+    <dependency>
+      <groupId>fr.bigeon</groupId>
+      <artifactId>gclc</artifactId>
+      <version>2.0.5</version>
+    </dependency>
+  </dependencies>
+
+  <scm>
+    <tag>process-0.0.2</tag>
+    <developerConnection>scm:git:gogs@git.code.bigeon.net:emmanuel/gclc.git</developerConnection>
+  </scm>
+</project>

gclc-process/src/main/java/fr/bigeon/gclc/process/CommandForeground.java

@@ -0,0 +1,139 @@
+/*
+ * 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:fr.bigeon.gclc.process.CommandFork.java
+ * Created on: Nov 13, 2017
+ */
+package fr.bigeon.gclc.process;
+
+import java.util.List;
+
+import fr.bigeon.gclc.command.CommandParameters;
+import fr.bigeon.gclc.command.ParametrizedCommand;
+import fr.bigeon.gclc.exception.CommandRunException;
+import fr.bigeon.gclc.exception.CommandRunExceptionType;
+import fr.bigeon.gclc.exception.InvalidParameterException;
+import fr.bigeon.gclc.manager.ConsoleInput;
+import fr.bigeon.gclc.manager.ConsoleOutput;
+
+/** A command that is launched inside an internal terminal.
+ * <p>
+ * Several things are to be considered before adding this command to an
+ * application:
+ * <ul>
+ * <li>The commands will be able to run in parallel.
+ * <li>The managing of the commands will be handled through piped systems and
+ * buffered in so switching to a forked command will actually print again all
+ * the command history to the output console.
+ * </ul>
+ *
+ * @author Emmanuel Bigeon */
+public class CommandForeground extends ParametrizedCommand {
+
+    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) {
+        super(name, false);
+        this.pool = pool;
+        addParameters();
+    }
+
+    /**
+     *
+     */
+    private void addParameters() {
+        try {
+            addStringParameter("pid", false);
+            addStringParameter("delai", false);
+        } catch (final InvalidParameterException e) {
+            // TODO Auto-generated catch block
+            e.printStackTrace();
+        }
+    }
+
+    /* (non-Javadoc)
+     * @see fr.bigeon.gclc.command.ParametrizedCommand#doExecute(fr.bigeon.gclc.
+     * manager.ConsoleOutput, fr.bigeon.gclc.manager.ConsoleInput,
+     * fr.bigeon.gclc.command.CommandParameters) */
+    @Override
+    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()) {
+            string = additionals.get(0);
+        }
+        if (string == null) {
+            throw new CommandRunException(CommandRunExceptionType.USAGE,
+                    "Missing process id", this);
+        }
+        // Join the command.
+        final Task cmd = pool.get(string);
+        if (!(cmd instanceof ForkTask)) {
+            throw new CommandRunException("No such forked process", this);
+        }
+        long delai = 0;
+        final String delaiOpt = parameters.get("delai");
+        if (delaiOpt != null) {
+            delai = Long.parseLong(delaiOpt) * 1000;
+        }
+        if (delai < 0) {
+            throw new CommandRunException("Join delai cannot be negative", this);
+        }
+        ((ForkTask) cmd).join(out, in, delai);
+    }
+
+    /* (non-Javadoc)
+     * @see fr.bigeon.gclc.command.ICommand#tip() */
+    @Override
+    public String tip() {
+        return "Join the execution of a command, for a given amount of time";
+    }
+
+    /* (non-Javadoc)
+     * @see fr.bigeon.gclc.command.Command#usageDetail() */
+    @Override
+    protected String usageDetail() {
+        return "";
+    }
+
+    /* (non-Javadoc)
+     * @see fr.bigeon.gclc.command.Command#usagePattern() */
+    @Override
+    protected String usagePattern() {
+        return super.usagePattern() + " [(-pid) <id>] ([-delai <delai>])";
+    }
+}

gclc-process/src/main/java/fr/bigeon/gclc/process/CommandFork.java

@@ -1,6 +1,6 @@
 /*
  * process, Distribution repositories and basic setup for Emmanuel Bigeon projects
- * Copyright (C) 2014-2017 E. Bigeon
+ * Copyright (C) 2014-2018 E. Bigeon
  * mailto:emmanuel@bigeon.fr
  *
  * This software is governed by the CeCILL license under French law and
@@ -35,17 +35,12 @@
  */
 package fr.bigeon.gclc.process;
 
-import java.io.IOException;
 import java.util.Arrays;
-import java.util.List;
 
-import fr.bigeon.gclc.command.CommandParameters;
+import fr.bigeon.gclc.command.Command;
 import fr.bigeon.gclc.command.ICommand;
 import fr.bigeon.gclc.command.ICommandProvider;
-import fr.bigeon.gclc.command.ParametrizedCommand;
 import fr.bigeon.gclc.exception.CommandRunException;
-import fr.bigeon.gclc.exception.CommandRunExceptionType;
-import fr.bigeon.gclc.exception.InvalidParameterException;
 import fr.bigeon.gclc.manager.ConsoleInput;
 import fr.bigeon.gclc.manager.ConsoleOutput;
 
@@ -56,72 +51,46 @@ import fr.bigeon.gclc.manager.ConsoleOutput;
  * <ul>
  * <li>The commands will be able to run in parallel.
  * <li>The managing of the commands will be handled through piped systems and
- * buffered in so switching to a forled command will actually print again all
+ * buffered in so switching to a forked command will actually print again all
  * the command history to the output console.
  * </ul>
  *
  * @author Emmanuel Bigeon */
-public class CommandFork extends ParametrizedCommand {
+public class CommandFork extends Command {
 
-    private final TaskPool pool = new TaskPool();
+    private final TaskPool         pool;
-    private ICommandProvider provider;
+    private final ICommandProvider provider;
+    private final int              lines;
 
     /** Add the fork command.
      *
-     * @param name the command name */
+     * @param name the command name
-    public CommandFork(final String name) {
+     * @param provider the allowed command collection */
-        super(name);
+    public CommandFork(final String name, ICommandProvider provider, TaskPool pool) {
-        addParameters();
+        this(name, provider, pool, -1);
     }
 
-    /**
+    /** Add the fork command.
      *
-     */
+     * @param name the command name
-    private void addParameters() {
+     * @param provider the allowed command collection */
-        try {
+    public CommandFork(final String name, ICommandProvider provider, TaskPool pool,
-            addStringParameter("join", false);
+                       int lines) {
-            addBooleanParameter("list");
+        super(name);
-        } catch (final InvalidParameterException e) {
+        this.provider = provider;
-            // TODO Auto-generated catch block
+        this.pool = pool;
-            e.printStackTrace();
+        this.lines = lines;
-        }
     }
 
-    /* (non-Javadoc)
-     * @see fr.bigeon.gclc.command.ParametrizedCommand#doExecute(fr.bigeon.gclc.
-     * manager.ConsoleOutput, fr.bigeon.gclc.manager.ConsoleInput,
-     * fr.bigeon.gclc.command.CommandParameters) */
     @Override
-    protected void doExecute(final ConsoleOutput out, final ConsoleInput in,
+    public void execute(final ConsoleOutput out, final ConsoleInput in, String... args)
-                             final CommandParameters parameters) throws CommandRunException {
+            throws CommandRunException {
-        if (parameters.getBool("list")) {
+        if (args.length < 1) {
-            for (final String id : pool.getPIDs()) {
+            throw new CommandRunException("No command to fork", this);
-                try {
-                    out.println(id + "\t" + pool.get(id).getName());
-                } catch (final IOException e) {
-                    throw new CommandRunException(
-                            CommandRunExceptionType.INTERACTION,
-                            "Failed to write to console", e, this);
-                }
-            }
         }
-
+        final ICommand cmd = provider.get(args[0]);
-        final String string = parameters.get("join");
+        final String[] inner = Arrays.copyOfRange(args, 1, args.length);
-        if (string != null) {
+        final ForkTask task = new ForkCommandTask(cmd, inner, lines);
-            // Join the command.
-            final ForkTask cmd = (ForkTask) pool.get(string);
-            if (cmd == null) {
-                throw new CommandRunException("No such fork process", this);
-            }
-            cmd.join(out, in);
-            return;
-        }
-
-        final List<String> strings = parameters.getAdditionals();
-        final ICommand cmd = provider.get(strings.get(0));
-        final String[] args = Arrays.copyOfRange(strings.toArray(new String[0]),
-                1, strings.size());
-        final ForkTask task = new ForkTask(cmd, args);
         final Thread th = new Thread(task);
         pool.add(task);
         th.start();
@@ -131,18 +100,20 @@ public class CommandFork extends ParametrizedCommand {
      * @see fr.bigeon.gclc.command.ICommand#tip() */
     @Override
     public String tip() {
-        // TODO Auto-generated method stub
+        return "Command background launch";
-        // return null;
-        throw new RuntimeException("Not implemented yet");
     }
 
     /* (non-Javadoc)
      * @see fr.bigeon.gclc.command.Command#usageDetail() */
     @Override
     protected String usageDetail() {
-        // TODO Auto-generated method stub
+        return "";
-        // return null;
-        throw new RuntimeException("Not implemented yet");
     }
 
+    /* (non-Javadoc)
+     * @see fr.bigeon.gclc.command.Command#usagePattern() */
+    @Override
+    protected String usagePattern() {
+        return super.usagePattern() + " <command>";
+    }
 }

gclc-process/src/main/java/fr/bigeon/gclc/process/ForkCommandTask.java

@@ -0,0 +1,73 @@
+/*
+ * 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.
+ */
+/**
+ * 
+ */
+package fr.bigeon.gclc.process;
+
+import java.util.Arrays;
+
+import fr.bigeon.gclc.command.ICommand;
+import fr.bigeon.gclc.exception.CommandRunException;
+
+/**
+ * @author Emmanuel Bigeon
+ *
+ */
+public class ForkCommandTask extends ForkTask {
+    private final ICommand      command;
+    private final String[]      args;
+
+    /** @param cmd the command
+     * @param args the arguements
+     * @param lines the number of print to store in the output */
+    public ForkCommandTask(final ICommand cmd, final String[] args, int lines) {
+        super(lines);
+        command = cmd;
+        this.args = Arrays.copyOf(args, args.length);
+    }
+
+    /* (non-Javadoc)
+     * @see fr.bigeon.gclc.process.Task#getName() */
+    @Override
+    public String getName() {
+        return command.getCommandName();
+    }
+
+    /* (non-Javadoc)
+     * @see fr.bigeon.gclc.process.ForkTask#doRun() */
+    @Override
+    protected void doRun() throws CommandRunException {
+        command.execute(out, in, args);
+    }
+
+}

gclc-process/src/main/java/fr/bigeon/gclc/process/ForkTask.java

@@ -1,6 +1,6 @@
 /*
  * process, Distribution repositories and basic setup for Emmanuel Bigeon projects
- * Copyright (C) 2014-2017 E. Bigeon
+ * Copyright (C) 2014-2018 E. Bigeon
  * mailto:emmanuel@bigeon.fr
  *
  * This software is governed by the CeCILL license under French law and
@@ -35,63 +35,70 @@
  */
 package fr.bigeon.gclc.process;
 
-import java.util.Arrays;
 import java.util.HashSet;
 import java.util.Set;
 
-import fr.bigeon.gclc.command.ICommand;
+import fr.bigeon.gclc.exception.CommandRunException;
 import fr.bigeon.gclc.manager.ConsoleInput;
 import fr.bigeon.gclc.manager.ConsoleOutput;
+import fr.bigeon.gclc.process.io.ConnectingConsoleInput;
+import fr.bigeon.gclc.process.io.ConnectingConsoleOutput;
 
 /**
  * <p>
  * TODO
  *
- * @author Emmanuel Bigeon
+ * @author Emmanuel Bigeon */
- *
+public abstract class ForkTask implements Task {
- */
-public class ForkTask implements Task {
 
-    private final ICommand command;
-    private final String[] args;
     private final Set<InterruptionListener> listeners = new HashSet<>();
-    private boolean running = false;
+    private boolean                         running   = false;
 
-    /** @param cmd the command
+    protected final ConnectingConsoleInput  in      = new ConnectingConsoleInput();
-     * @param args the arguements */
+    protected final ConnectingConsoleOutput out;
-    public ForkTask(final ICommand cmd, final String[] args) {
+    private CommandRunException           exception;
-        command = cmd;
+    private final Object                  runLock = new Object();
-        this.args = Arrays.copyOf(args, args.length);
+
+    /** @param lines the number of print to store in the output */
+    public ForkTask(int lines) {
+        out = new ConnectingConsoleOutput(ConnectingConsoleOutput.PERSIST, lines);
     }
 
     /* (non-Javadoc)
      * @see fr.bigeon.gclc.process.Task#addInterruptionListener(fr.bigeon.gclc.
      * process.InterruptionListener) */
     @Override
-    public void addInterruptionListener(final InterruptionListener listener) {
+    public final void addInterruptionListener(final InterruptionListener listener) {
         listeners.add(listener);
     }
 
-    /* (non-Javadoc)
-     * @see fr.bigeon.gclc.process.Task#getName() */
-    @Override
-    public String getName() {
-        return command.getCommandName();
-    }
-
     /* (non-Javadoc)
      * @see fr.bigeon.gclc.process.Task#isRunning() */
     @Override
-    public boolean isRunning() {
+    public final boolean isRunning() {
-        return running;
+        synchronized (runLock) {
+            return running;
+        }
     }
 
     /** @param out the console output
-     * @param in the console input */
+     * @param in the console input
-    public void join(final ConsoleOutput out, final ConsoleInput in) {
+     * @param timeout the maximal wait (0 for ever) */
-        // TODO Auto-generated method stub
+    public final void join(final ConsoleOutput out, final ConsoleInput in, long timeout) {
-        //
+        synchronized (runLock) {
-        throw new RuntimeException("Not implemented yet");
+            this.out.connect(out);
+            this.in.connect(in);
+            try {
+                if (running) {
+                    runLock.wait(timeout);
+                }
+            } catch (final InterruptedException e) {
+                // TODO log.
+                Thread.currentThread().interrupt();
+            }
+            this.out.disconnect();
+            this.in.disconnect();
+        }
     }
 
     /* (non-Javadoc)
@@ -99,29 +106,50 @@ public class ForkTask implements Task {
      * fr.bigeon.gclc.process.Task#rmInterruptionListener(fr.bigeon.gclc.process
      * .InterruptionListener) */
     @Override
-    public void rmInterruptionListener(final InterruptionListener listener) {
+    public final void rmInterruptionListener(final InterruptionListener listener) {
         listeners.remove(listener);
     }
 
     /* (non-Javadoc)
      * @see java.lang.Runnable#run() */
     @Override
-    public void run() {
+    public final void run() {
-        running = true;
+        synchronized (runLock) {
-        try {
+            running = true;
-            // TODO Auto-generated method stub
-            //
-            throw new RuntimeException("Not implemented yet");
-        } finally {
-            running = false;
         }
+        try {
+            doRun();
+        } catch (final CommandRunException e) {
+            exception = e;
+        } finally {
+            setRunning(false);
+        }
+        for (final InterruptionListener interruptionListener : listeners) {
+            interruptionListener.interrupted();
+        }
+    }
+
+    /** Actually run the fork. */
+    protected abstract void doRun() throws CommandRunException;
+
+    /** Get the excepion that caused a failure.
+     * 
+     * @return the exception */
+    public final CommandRunException getException() {
+        return exception;
     }
 
     /* (non-Javadoc)
      * @see fr.bigeon.gclc.process.Task#setRunning(boolean) */
     @Override
-    public void setRunning(final boolean running) {
+    public final void setRunning(final boolean running) {
-        this.running = running;
+        synchronized (runLock) {
+            this.running = running;
+            runLock.notifyAll();
+        }
     }
 
+    protected final Object getRunningLock() {
+        return runLock;
+    }
 }

gclc-process/src/main/java/fr/bigeon/gclc/process/InterruptionListener.java

@@ -1,6 +1,6 @@
 /*
  * process, Distribution repositories and basic setup for Emmanuel Bigeon projects
- * Copyright (C) 2014-2017 E. Bigeon
+ * Copyright (C) 2014-2018 E. Bigeon
  * mailto:emmanuel@bigeon.fr
  *
  * This software is governed by the CeCILL license under French law and

gclc-process/src/main/java/fr/bigeon/gclc/process/ProcessAttachement.java

@@ -0,0 +1,64 @@
+/*
+ * 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.
+ */
+/**
+ * 
+ */
+package fr.bigeon.gclc.process;
+
+import fr.bigeon.gclc.ApplicationAttachement;
+import fr.bigeon.gclc.command.ICommandProvider;
+import fr.bigeon.gclc.exception.InvalidCommandName;
+
+/**
+ * @author Emmanuel Bigeon
+ *
+ */
+public class ProcessAttachement implements ApplicationAttachement {
+
+    private final TaskPool pool;
+
+    /** @param pool the task pool to manage */
+    public ProcessAttachement(TaskPool pool) {
+        super();
+        this.pool = pool;
+    }
+
+    /* (non-Javadoc)
+     * @see fr.bigeon.gclc.ApplicationAttachement#attach(fr.bigeon.gclc.ConsoleApplication)
+     */
+    @Override
+    public void attach(ICommandProvider application) throws InvalidCommandName {
+        application.add(new ProcessKill("kill", pool));
+        application.add(new ProcessList("list", pool));
+    }
+
+}

gclc-process/src/main/java/fr/bigeon/gclc/process/ProcessClear.java

@@ -0,0 +1,87 @@
+/*
+ * 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:fr.bigeon.gclc.proc.ProcessList.java
+ * Created on: May 10, 2017
+ */
+package fr.bigeon.gclc.process;
+
+import fr.bigeon.gclc.command.Command;
+import fr.bigeon.gclc.exception.CommandRunException;
+import fr.bigeon.gclc.manager.ConsoleInput;
+import fr.bigeon.gclc.manager.ConsoleOutput;
+
+/** A command that will flag a task to stop
+ *
+ * @author Emmanuel Bigeon */
+public final class ProcessClear extends Command {
+    /** The taskpool */
+    private final TaskPool pool;
+
+    /** @param name the command name
+     * @param pool the pool */
+    public ProcessClear(final String name, final TaskPool pool) {
+        super(name);
+        this.pool = pool;
+    }
+
+    /* (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 {
+        for (final String 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)";
+    }
+
+    /* (non-Javadoc)
+     * @see fr.bigeon.gclc.command.Command#usageDetail() */
+    @Override
+    protected String usageDetail() {
+        return null;
+    }
+
+}

gclc-process/src/main/java/fr/bigeon/gclc/process/ProcessKill.java

@@ -1,6 +1,6 @@
 /*
  * process, Distribution repositories and basic setup for Emmanuel Bigeon projects
- * Copyright (C) 2014-2017 E. Bigeon
+ * Copyright (C) 2014-2018 E. Bigeon
  * mailto:emmanuel@bigeon.fr
  *
  * This software is governed by the CeCILL license under French law and

gclc-process/src/main/java/fr/bigeon/gclc/process/ProcessList.java

@@ -1,6 +1,6 @@
 /*
  * process, Distribution repositories and basic setup for Emmanuel Bigeon projects
- * Copyright (C) 2014-2017 E. Bigeon
+ * Copyright (C) 2014-2018 E. Bigeon
  * mailto:emmanuel@bigeon.fr
  *
  * This software is governed by the CeCILL license under French law and

gclc-process/src/main/java/fr/bigeon/gclc/process/ScreenAttachement.java

@@ -0,0 +1,65 @@
+/*
+ * 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.
+ */
+/**
+ * 
+ */
+package fr.bigeon.gclc.process;
+
+import fr.bigeon.gclc.ApplicationAttachement;
+import fr.bigeon.gclc.command.ICommandProvider;
+import fr.bigeon.gclc.exception.InvalidCommandName;
+
+/** @author Emmanuel Bigeon */
+public class ScreenAttachement implements ApplicationAttachement {
+
+    private final TaskPool pool;
+    private final int      lines;
+
+    /** @param pool the task pool to manage */
+    public ScreenAttachement(TaskPool pool, int lines) {
+        super();
+        this.pool = pool;
+        this.lines = lines;
+    }
+
+    /* (non-Javadoc)
+     * @see fr.bigeon.gclc.ApplicationAttachement#attach(fr.bigeon.gclc.
+     * ConsoleApplication) */
+    @Override
+    public void attach(ICommandProvider application) throws InvalidCommandName {
+        application.add(new ProcessKill("terminate", pool));
+        application.add(new ProcessList("list", pool));
+        application.add(new ProcessClear("clear", pool));
+        application.add(new CommandForeground("fg", pool));
+        application.add(new CommandFork("fork", application, pool, lines));
+    }
+}

gclc-process/src/main/java/fr/bigeon/gclc/process/Task.java

@@ -1,6 +1,6 @@
 /*
  * process, Distribution repositories and basic setup for Emmanuel Bigeon projects
- * Copyright (C) 2014-2017 E. Bigeon
+ * Copyright (C) 2014-2018 E. Bigeon
  * mailto:emmanuel@bigeon.fr
  *
  * This software is governed by the CeCILL license under French law and

gclc-process/src/main/java/fr/bigeon/gclc/process/TaskPool.java

@@ -1,6 +1,6 @@
 /*
  * process, Distribution repositories and basic setup for Emmanuel Bigeon projects
- * Copyright (C) 2014-2017 E. Bigeon
+ * Copyright (C) 2014-2018 E. Bigeon
  * mailto:emmanuel@bigeon.fr
  *
  * This software is governed by the CeCILL license under French law and
@@ -47,13 +47,29 @@ public final class TaskPool {
     /** The running processes. */
     private final Map<String, Task> running = new HashMap<>();
     /** The count for process id. */
-    private int count = 0;
+    private int                     count   = 0;
     /** The lock for pid attribution synchronization. */
-    private final Object lock = new Object();
+    private final Object            lock    = new Object();
+    private final boolean           autoClear;
 
     /** Default constructor. */
     public TaskPool() {
-        //
+        this(true);
+    }
+
+    /** Default constructor. */
+    public TaskPool(boolean autoClear) {
+        this.autoClear = autoClear;
+    }
+
+    /** Remove a task from the pool
+     * 
+     * @param pid the task id */
+    public void remove(String pid) {
+        synchronized (lock) {
+            running.remove(pid);
+            count = Math.min(count, Integer.parseInt(pid));
+        }
     }
 
     /** Add a process in the pool.
@@ -64,22 +80,23 @@ public final class TaskPool {
         if (cmd == null) {
             throw new IllegalArgumentException("Task cannot be null"); //$NON-NLS-1$
         }
-        final String pid = getPID();
+        final String pid;
         synchronized (lock) {
+            pid = getPID();
             running.put(pid, cmd);
         }
-        cmd.addInterruptionListener(new InterruptionListener() {
+        if (autoClear) {
-
+            cmd.addInterruptionListener(new InterruptionListener() {
-            @SuppressWarnings("synthetic-access")
+                @SuppressWarnings("synthetic-access")
-            @Override
+                @Override
-            public void interrupted() {
+                public void interrupted() {
-                synchronized (lock) {
+                    synchronized (lock) {
-                    running.remove(pid);
+                        remove(pid);
-                    count = Math.min(count, Integer.parseInt(pid));
+                    }
+                    cmd.rmInterruptionListener(this);
                 }
-                cmd.rmInterruptionListener(this);
+            });
-            }
+        }
-        });
         return pid;
     }
 
@@ -112,4 +129,21 @@ public final class TaskPool {
     public Collection<String> getPIDs() {
         return new HashSet<>(running.keySet());
     }
+
+    /** @return if the clearing of ended task is automatic */
+    public boolean isAutoClearing() {
+        return autoClear;
+    }
+
+    /** Request all task to stop running.
+     * <p>
+     * This call does not guaranty end of execution, it is up to the task
+     * implementation to actually take into account the termination request. */
+    public void shutdown() {
+        synchronized (lock) {
+            for (final Task task : running.values()) {
+                task.setRunning(false);
+            }
+        }
+    }
 }

gclc-process/src/main/java/fr/bigeon/gclc/process/TaskSpawner.java

@@ -1,6 +1,6 @@
 /*
  * process, Distribution repositories and basic setup for Emmanuel Bigeon projects
- * Copyright (C) 2014-2017 E. Bigeon
+ * Copyright (C) 2014-2018 E. Bigeon
  * mailto:emmanuel@bigeon.fr
  *
  * This software is governed by the CeCILL license under French law and
@@ -35,6 +35,8 @@
  */
 package fr.bigeon.gclc.process;
 
+import java.util.concurrent.ExecutorService;
+
 import fr.bigeon.gclc.command.Command;
 import fr.bigeon.gclc.exception.CommandRunException;
 import fr.bigeon.gclc.manager.ConsoleInput;
@@ -46,31 +48,35 @@ import fr.bigeon.gclc.manager.ConsoleOutput;
 public abstract class TaskSpawner extends Command {
     /** The process pool */
     private final TaskPool pool;
+    private final ExecutorService threadPool;
 
     /** @param name the command name
      * @param pool the pool */
-    public TaskSpawner(final String name, final TaskPool pool) {
+    public TaskSpawner(final String name, final TaskPool pool,
+                       ExecutorService threadPool) {
         super(name);
         this.pool = pool;
+        this.threadPool = threadPool;
     }
 
     /** @param in the input
      * @param out the output
      * @param args the arguments
-     * @return the process to start and add to the pool */
+     * @return the process to start and add to the pool
+     * @throws CommandRunException if the task creation failed */
     protected abstract Task createTask(ConsoleOutput out, ConsoleInput in,
-                                       String... args);
+            String... args) throws CommandRunException;
 
     /* (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,
+    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);
-        th.start();
+        threadPool.execute(th);
     }
 }

gclc-process/src/main/java/fr/bigeon/gclc/process/io/ConnectingConsoleInput.java

@@ -0,0 +1,211 @@
+/*
+ * 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.
+ */
+/**
+ * 
+ */
+package fr.bigeon.gclc.process.io;
+
+import java.io.IOException;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import fr.bigeon.gclc.manager.ConsoleInput;
+import fr.bigeon.gclc.tools.StringProvider;
+
+/** @author Emmanuel Bigeon */
+public final class ConnectingConsoleInput implements ConsoleInput {
+
+    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;
+
+    /* (non-Javadoc)
+     * @see fr.bigeon.gclc.manager.ConsoleInput#close() */
+    @Override
+    public void close() throws IOException {
+        close = true;
+    }
+
+    /* (non-Javadoc)
+     * @see fr.bigeon.gclc.manager.ConsoleInput#getPrompt() */
+    @Override
+    public StringProvider getPrompt() {
+        return prompt;
+    }
+
+    /* (non-Javadoc)
+     * @see fr.bigeon.gclc.manager.ConsoleInput#interruptPrompt() */
+    @Override
+    public void interruptPrompt() {
+        synchronized (promptLock) {
+            prompting = false;
+            if (connected != null) {
+                connected.interruptPrompt();
+            }
+            promptLock.notifyAll();
+        }
+    }
+
+    /* (non-Javadoc)
+     * @see fr.bigeon.gclc.manager.ConsoleInput#isClosed() */
+    @Override
+    public boolean isClosed() {
+        return close;
+    }
+
+    /* (non-Javadoc)
+     * @see fr.bigeon.gclc.manager.ConsoleInput#prompt() */
+    @Override
+    public String prompt() throws IOException {
+        return prompt(prompt.apply());
+    }
+
+    /* (non-Javadoc)
+     * @see fr.bigeon.gclc.manager.ConsoleInput#setPrompt(fr.bigeon.gclc.tools.
+     * StringProvider) */
+    @Override
+    public void setPrompt(StringProvider string) {
+        prompt = string;
+    }
+
+    /* (non-Javadoc)
+     * @see fr.bigeon.gclc.manager.ConsoleInput#prompt(long) */
+    @Override
+    public String prompt(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 {
+        synchronized (promptLock) {
+            prompting = true;
+        }
+        while (prompting) {
+            synchronized (promptLock) {
+                if (connected == null) {
+                    try {
+                        promptLock.wait();
+                    } catch (final InterruptedException e) {
+                        LOGGER.log(Level.WARNING, "Inerruption of console thread", e);
+                        Thread.currentThread().interrupt();
+                    }
+                } else {
+                    final String res = connected.prompt(message);
+                    synchronized (connectionLock) {
+                        if (disconnection) {
+                            disconnection = false;
+                        } else if (prompting) {
+                            return res;
+                        }
+                    }
+                }
+            }
+        }
+        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 {
+        if (timeout <= 0) {
+            return prompt(message);
+        }
+        final long end = System.currentTimeMillis() + timeout;
+        synchronized (promptLock) {
+            prompting = true;
+        }
+        while (prompting) {
+            synchronized (promptLock) {
+                if (connected == null) {
+                    try {
+                        promptLock.wait();
+                    } 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) {
+                        if (disconnection) {
+                            disconnection = false;
+                        } else if (prompting) {
+                            return res;
+                        }
+                    }
+                }
+            }
+        }
+        return null;
+    }
+
+    /* (non-Javadoc)
+     * @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;
+            }
+        };
+    }
+
+    public void connect(ConsoleInput input) {
+        disconnect();
+        synchronized (promptLock) {
+            connected = input;
+            promptLock.notifyAll();
+        }
+    }
+
+    public void disconnect() {
+        synchronized (connectionLock) {
+            if (connected != null) {
+                disconnection = true;
+                synchronized (promptLock) {
+                    connected.interruptPrompt();
+                }
+                connected = null;
+            }
+        }
+    }
+}

gclc-process/src/main/java/fr/bigeon/gclc/process/io/ConnectingConsoleOutput.java

@@ -0,0 +1,146 @@
+/*
+ * 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.
+ */
+/**
+ * 
+ */
+package fr.bigeon.gclc.process.io;
+
+import java.io.IOException;
+import java.util.ArrayDeque;
+import java.util.Deque;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import fr.bigeon.gclc.manager.ConsoleOutput;
+
+/** @author Emmanuel Bigeon */
+public class ConnectingConsoleOutput implements ConsoleOutput {
+
+    private static final Logger LOGGER  = Logger
+            .getLogger(ConnectingConsoleOutput.class.getName());
+    /** If the undelivered message should be stored. */
+    public static final int     QUEUE   = 1;
+    /** If the messages should be stored in all cases. */
+    public static final int     PERSIST = 1 << 1;
+    private ConsoleOutput       output;
+    private boolean             close   = false;
+
+    private final boolean       persistent;
+    private final boolean       queued;
+    private final Deque<String> messages;
+    private final int           lines;
+
+    /** @param style the type of redirected output
+     * @param lines the number of lines to store */
+    public ConnectingConsoleOutput(int style, int lines) {
+        super();
+        this.lines = lines;
+        queued = (style & QUEUE) != 0;
+        persistent = (style & PERSIST) != 0;
+        if (lines > 0) {
+            messages = new ArrayDeque<>(lines);
+        } else {
+            messages = new ArrayDeque<>();
+        }
+    }
+
+    private synchronized void addMessage(String text) {
+        if (persistent || queued && output == null) {
+            if (messages.size() == lines) {
+                messages.poll();
+            }
+            messages.offer(text);
+        }
+        if (output != null) {
+            try {
+                output.print(text);
+            } catch (final IOException e) {
+                LOGGER.severe("nable to print to connecting console");
+                LOGGER.log(Level.FINE, "Console error", e);
+            }
+        }
+    }
+
+    /* (non-Javadoc)
+     * @see java.lang.AutoCloseable#close() */
+    @Override
+    public void close() {
+        close = true;
+    }
+
+    /* (non-Javadoc)
+     * @see fr.bigeon.gclc.manager.ConsoleOutput#isClosed() */
+    @Override
+    public boolean isClosed() {
+        return close;
+    }
+
+    /* (non-Javadoc)
+     * @see fr.bigeon.gclc.manager.ConsoleOutput#print(java.lang.String) */
+    @Override
+    public void print(String text) {
+        addMessage(text);
+    }
+
+    /* (non-Javadoc)
+     * @see fr.bigeon.gclc.manager.ConsoleOutput#println() */
+    @Override
+    public void println() {
+        addMessage(System.lineSeparator());
+    }
+
+    /* (non-Javadoc)
+     * @see fr.bigeon.gclc.manager.ConsoleOutput#println(java.lang.String) */
+    @Override
+    public void println(String message) {
+        addMessage(message + System.lineSeparator());
+    }
+
+    public synchronized void connect(ConsoleOutput output) {
+        this.output = output;
+        for (final String string : messages) {
+            try {
+                output.print(string);
+            } catch (final IOException e) {
+                LOGGER.severe("nable to print to connecting console");
+                LOGGER.log(Level.FINE, "Console error", e);
+            }
+        }
+        if (!persistent) {
+            messages.clear();
+        }
+    }
+
+    public synchronized void disconnect() {
+        output = null;
+    }
+}

gclc-socket/pom.xml

@@ -101,7 +101,7 @@ of Emmanuel Bigeon.                                                   -->
 <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.9</version>
+  <version>1.1.10-SNAPSHOT</version>
   <packaging>jar</packaging>
   <url>http://www.bigeon.fr/emmanuel</url>
   <properties>
@@ -112,23 +112,24 @@ of Emmanuel Bigeon.                                                   -->
     <dependency>
     	<groupId>fr.bigeon</groupId>
     	<artifactId>gclc</artifactId>
-    	<version>2.0.1</version>
+    	<version>2.0.5</version>
     </dependency>
     <dependency>
     	<groupId>fr.bigeon</groupId>
     	<artifactId>smu</artifactId>
-    	<version>0.0.7</version>
+    	<version>0.0.9</version>
     </dependency>
   </dependencies>
   <parent>
-  	<groupId>fr.bigeon</groupId>
+  	<groupId>fr.bigeon.config</groupId>
   	<artifactId>ebigeon-config</artifactId>
-  	<version>1.7.1</version>
+  	<version>1.8.2</version>
   </parent>
   <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.9</tag>
+    <tag>HEAD</tag>
   </scm>
+  <groupId>fr.bigeon.gclc</groupId>
 </project>

gclc-socket/src/main/java/fr/bigeon/gclc/socket/PluggableConsoleInput.java

@@ -46,6 +46,8 @@ import java.util.logging.Logger;
 
 import fr.bigeon.gclc.manager.ConsoleInput;
 import fr.bigeon.gclc.manager.ReadingRunnable;
+import fr.bigeon.gclc.tools.ConstantString;
+import fr.bigeon.gclc.tools.StringProvider;
 
 /** A console input where the stream can be plugged.
  * <p>
@@ -68,7 +70,7 @@ public final class PluggableConsoleInput implements ConsoleInput {
     /** If the element is closed. */
     private boolean closed = false;
     /** The default prompt. */
-    private String prompt = "> "; //$NON-NLS-1$
+    private StringProvider prompt = new ConstantString("> "); //$NON-NLS-1$
     /** If the input is plugged or buffering. */
     private boolean connected = false;
     /** The current connexion (if any). */
@@ -141,7 +143,7 @@ public final class PluggableConsoleInput implements ConsoleInput {
     /* (non-Javadoc)
      * @see fr.bigeon.gclc.manager.ConsoleInput#getPrompt() */
     @Override
-    public String getPrompt() {
+    public StringProvider getPrompt() {
         return prompt;
     }
 
@@ -170,14 +172,14 @@ public final class PluggableConsoleInput implements ConsoleInput {
      * @see fr.bigeon.gclc.manager.ConsoleInput#prompt() */
     @Override
     public String prompt() throws IOException {
-        return prompt(prompt);
+        return prompt(prompt.apply());
     }
 
     /* (non-Javadoc)
      * @see fr.bigeon.gclc.manager.ConsoleInput#prompt(long) */
     @Override
     public String prompt(final long timeout) throws IOException {
-        return prompt(prompt, timeout);
+        return prompt(prompt.apply(), timeout);
     }
 
     /* (non-Javadoc)
@@ -251,12 +253,15 @@ public final class PluggableConsoleInput implements ConsoleInput {
         return res;
     }
 
-    /* (non-Javadoc)
-     * @see fr.bigeon.gclc.manager.ConsoleInput#setPrompt(java.lang.String) */
     @Override
-    public void setPrompt(final String prompt) {
+    public void setPrompt(final StringProvider prompt) {
         this.prompt = prompt;
     }
+    
+    @Override
+    public void setPrompt(String prompt) {
+    	setPrompt(new ConstantString(prompt));
+    }
 
     /** Wait for a hint or connexion.
      *

gclc-swt/pom.xml

@@ -1,4 +1,35 @@
 
+<!-- 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.            -->
+
+
 <!-- Copyright E. Bigeon (2015)                             -->
 <!--                                                                           -->
 <!-- emmanuel@bigeon.fr                                                                  -->
@@ -35,7 +66,7 @@
 <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-swt</artifactId>
-  <version>1.1.4-SNAPSHOT</version>
+  <version>1.1.5-SNAPSHOT</version>
   <packaging>jar</packaging>
   <url>http://www.bigeon.fr/emmanuel</url>
   <properties>
@@ -43,15 +74,15 @@
     <project.scm.id>git.bigeon.net</project.scm.id>
   </properties>
   <parent>
-    <groupId>fr.bigeon</groupId>
+    <groupId>fr.bigeon.config</groupId>
     <artifactId>ebigeon-config</artifactId>
-    <version>1.7.1</version>
+    <version>1.8.2</version>
   </parent>
   <dependencies>
     <dependency>
       <groupId>fr.bigeon</groupId>
       <artifactId>gclc</artifactId>
-      <version>2.0.0</version>
+      <version>2.0.5</version>
     </dependency>
     <dependency>
       <groupId>fr.bigeon</groupId>
@@ -98,4 +129,5 @@
       </dependencies>
     </profile>
   </profiles>
+  <groupId>fr.bigeon.gclc</groupId>
 </project>

gclc-swt/src/main/java/fr/bigeon/gclc/swt/ConsoleDelayIO.java

@@ -1,10 +1,7 @@
 /*
- * Copyright E. Bigeon (2015)
+ * GCLC swt, provide a swt window for console applications
- *
+ * Copyright (C) 2015-2017 E. Bigeon
- * emmanuel@bigeon.fr
+ * mailto:emmanuel@bigeon.fr
- *
- * This software is a computer program whose purpose is to
- * provide a swt window for console applications.
  *
  * This software is governed by the CeCILL license under French law and
  * abiding by the rules of distribution of free software.  You can  use,
@@ -46,12 +43,15 @@ package fr.bigeon.gclc.swt;
  *
  * @author Emmanuel Bigeon */
 public interface ConsoleDelayIO {
-    /** Actually send the input as the prompt next input. */
+    /** Get the input text.
-    void validateInput();
+     * @return the non validated input */
+    String getInput();
 
-    /** @param input the input to set */
+    /** Set the input text.
+     * 
+     * @param input the input to set */
     void setInput(String input);
 
-    /** @return the non validated input */
+    /** Actually send the input as the prompt next input. */
-    String getInput();
+    void validateInput();
 }

gclc-swt/src/main/java/fr/bigeon/gclc/swt/HistoryTextKeyListener.java

@@ -1,10 +1,7 @@
 /*
- * Copyright E. Bigeon (2015)
+ * GCLC swt, provide a swt window for console applications
- *
+ * Copyright (C) 2015-2017 E. Bigeon
- * emmanuel@bigeon.fr
+ * mailto:emmanuel@bigeon.fr
- *
- * This software is a computer program whose purpose is to
- * provide a swt window for console applications.
  *
  * This software is governed by the CeCILL license under French law and
  * abiding by the rules of distribution of free software.  You can  use,
@@ -45,40 +42,46 @@ import org.eclipse.swt.events.KeyEvent;
 import fr.bigeon.collections.ArrayRibbon;
 import fr.bigeon.collections.Ribbon;
 
-/** A key listener to validate commands and manage the history of commands
+/** A key listener to validate commands and manage the history of commands.
  *
  * @author Emmanuel Bigeon */
 public final class HistoryTextKeyListener extends KeyAdapter {
 
-    /** The size of commands history */
+    /** The size of commands history. */
     private static final int DEFAULT_HISTORY_SIZE = 10;
-    /** The empty string constant */
+    /** The empty string constant. */
     private static final String EMPTY = ""; //$NON-NLS-1$
-    /** The history ribbon */
+    /** The history ribbon. */
     private final Ribbon<String> commands;
-    /** The current index in history search */
+    /** The current index in history search. */
     private int currentIndex = 0;
-    /** The console to notify of command validation */
+    /** The console to notify of command validation. */
     private final ConsoleDelayIO console;
 
-    /** @param console the console delayed */
+    /** Create the key listener that cycle the history.
-    public HistoryTextKeyListener(ConsoleDelayIO console) {
+     *
+     * @param console the console delayed */
+    public HistoryTextKeyListener(final ConsoleDelayIO console) {
         super();
         this.console = console;
-        this.commands = new ArrayRibbon<>(DEFAULT_HISTORY_SIZE);
+        commands = new ArrayRibbon<>(DEFAULT_HISTORY_SIZE);
     }
 
+    /* (non-Javadoc)
+     * @see org.eclipse.swt.events.KeyAdapter#keyPressed(org.eclipse.swt.events.
+     * KeyEvent) */
     @Override
-    public void keyPressed(KeyEvent e) {
+    public void keyPressed(final KeyEvent e) {
-
         pressedKeyCode(e.keyCode);
     }
 
-    /** @param keyCode the pressed key code */
+    /** Indicate a pressed key combination.
-    public void pressedKeyCode(int keyCode) {
+     *
+     * @param keyCode the pressed key code */
+    public void pressedKeyCode(final int keyCode) {
         // Enter validates the command if prompting
         if (keyCode == '\r') {
-            String input = console.getInput();
+            final String input = console.getInput();
             if (!input.isEmpty()) {
                 commands.add(input);
             }
@@ -90,7 +93,7 @@ public final class HistoryTextKeyListener extends KeyAdapter {
         if (keyCode == SWT.ARROW_UP &&
             currentIndex < commands.size() - 1) {
             currentIndex++;
-            String cmd = commands.get(commands.size() - currentIndex - 1);
+            final String cmd = commands.get(commands.size() - currentIndex - 1);
             console.setInput(cmd);
         }
 
@@ -100,7 +103,7 @@ public final class HistoryTextKeyListener extends KeyAdapter {
                 currentIndex--;
                 console.setInput(EMPTY);
             } else if (currentIndex > 0) {
-                String cmd = commands
+                final String cmd = commands
                         .get(commands.size() - (--currentIndex) - 1);
                 console.setInput(cmd);
             }

gclc-swt/src/main/java/fr/bigeon/gclc/swt/SWTConsole.java

@@ -1,10 +1,7 @@
 /*
- * Copyright E. Bigeon (2015)
+ * GCLC swt, provide a swt window for console applications
- *
+ * Copyright (C) 2015-2017 E. Bigeon
- * emmanuel@bigeon.fr
+ * mailto:emmanuel@bigeon.fr
- *
- * This software is a computer program whose purpose is to
- * provide a swt window for console applications.
  *
  * This software is governed by the CeCILL license under French law and
  * abiding by the rules of distribution of free software.  You can  use,
@@ -53,38 +50,38 @@ import org.eclipse.swt.widgets.Text;
 import fr.bigeon.gclc.ConsoleApplication;
 import fr.bigeon.gclc.manager.ConsoleInput;
 import fr.bigeon.gclc.manager.ConsoleOutput;
+import fr.bigeon.gclc.tools.ConstantString;
+import fr.bigeon.gclc.tools.StringProvider;
 
-/** A SWT component to connect to gclc {@link ConsoleApplication}
+/** A SWT component to connect to gclc {@link ConsoleApplication}.
  * <p>
  *
  * @author Emmanuel Bigeon */
-public class SWTConsole extends Composite
+public final class SWTConsole extends Composite
         implements ConsoleDelayIO, ConsoleInput, ConsoleOutput {
-    /**
+    /** The number of columns of the layout. */
-     *
+    private static final int    LAYOUT_NB_COLUMNS = 2;
-     */
+    /** The cmd prefix in the output console. */
-    private static final int LAYOUT_NB_COLUMNS = 2;
+    private static final String CMD_PREFIX        = "[CMD] ";                 //$NON-NLS-1$
-    /** The cmd prefix in the output console */
+    /** The class logger. */
-    private static final String CMD_PREFIX = "[CMD] "; //$NON-NLS-1$
+    private static final Logger LOGGER            = Logger
-    /** The class logger */
-    private static final Logger LOGGER = Logger
             .getLogger(SWTConsole.class.getName());
-    /** The empty string constant */
+    /** 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 */
+    /** The console output text field. */
-    private final Text consoleOutput;
+    private final Text          consoleOutput;
-    /** The console input text field */
+    /** The console input text field. */
-    private final Text consoleInput;
+    private final Text          consoleInput;
-    /** The prompt label */
+    /** The prompt label. */
-    private final Label lblPromptlabel;
+    private final Label         lblPromptlabel;
-    /** The prompt text */
+    /** The prompt text. */
-    private String prompt = ">"; //$NON-NLS-1$
+    private StringProvider      prompt            = new ConstantString("> "); //$NON-NLS-1$
-    /** The command entered by the user */
+    /** The command entered by the user. */
-    private String command = null;
+    private String              command           = null;
-    /** If the prompt should be active */
+    /** If the prompt should be active. */
-    private boolean prompting = false;
+    private boolean             prompting         = false;
-    /** The object for thread synchronization with the prompt */
+    /** The object for thread synchronization with the prompt. */
-    private final Object promptLock = new Object();
+    private final Object        promptLock        = new Object();
 
     /** Create the composite.
      *
@@ -95,18 +92,17 @@ public class SWTConsole extends Composite
 
         setLayout(new GridLayout(LAYOUT_NB_COLUMNS, false));
 
-        consoleOutput = new Text(this, SWT.BORDER | SWT.READ_ONLY | SWT.WRAP |
+        consoleOutput = new Text(this,
-                                       SWT.V_SCROLL | SWT.MULTI);
+                SWT.BORDER | SWT.READ_ONLY | SWT.WRAP | SWT.V_SCROLL | SWT.MULTI);
-        consoleOutput.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true,
+        consoleOutput.setLayoutData(
-                LAYOUT_NB_COLUMNS, 1));
+                new GridData(SWT.FILL, SWT.FILL, true, true, LAYOUT_NB_COLUMNS, 1));
         consoleOutput.setRedraw(true);
 
         lblPromptlabel = new Label(this, SWT.NONE);
-        lblPromptlabel.setText(prompt);
+        lblPromptlabel.setText(prompt.apply());
 
         consoleInput = new Text(this, SWT.BORDER);
-        consoleInput.setLayoutData(
+        consoleInput.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false, 1, 1));
-                new GridData(SWT.FILL, SWT.CENTER, true, false, 1, 1));
         consoleInput.addKeyListener(new HistoryTextKeyListener(this));
 
     }
@@ -121,7 +117,7 @@ public class SWTConsole extends Composite
     @Override
     public void close() {
         synchronized (promptLock) {
-            promptLock.notify();
+            promptLock.notifyAll();
         }
         if (consoleInput.isDisposed()) {
             return;
@@ -140,7 +136,7 @@ public class SWTConsole extends Composite
     /* (non-Javadoc)
      * @see fr.bigeon.gclc.ConsoleManager#getPrompt() */
     @Override
-    public String getPrompt() {
+    public StringProvider getPrompt() {
         return prompt;
     }
 
@@ -149,7 +145,7 @@ public class SWTConsole extends Composite
     @Override
     public void interruptPrompt() {
         synchronized (promptLock) {
-            promptLock.notify();
+            promptLock.notifyAll();
         }
     }
 
@@ -216,22 +212,26 @@ public class SWTConsole extends Composite
             }
             try {
                 Display.getDefault().syncExec(new Runnable() {
-                    @SuppressWarnings("synthetic-access")
                     @Override
                     public void run() {
                         if (!consoleInput.isDisposed()) {
                             consoleInput.setEnabled(true);
+                            lblPromptlabel.setText(prompt.apply());
+                            // relayout
+                            SWTConsole.this.layout();
                             consoleInput.setFocus();
                         }
                     }
                 });
                 prompting = true;
                 promptLock.notifyAll();
-                promptLock.wait();
+                while (prompting) {
+                    promptLock.wait();
+                }
             } catch (final InterruptedException e) {
-                LOGGER.log(Level.WARNING,
+                LOGGER.log(Level.WARNING, "Error in synchronization of prompting", e); //$NON-NLS-1$
-                        "Error in synchronization of prompting", e); //$NON-NLS-1$
                 command = null;
+                Thread.currentThread().interrupt();
             }
         }
         if (isDisposed()) {
@@ -241,13 +241,45 @@ public class SWTConsole extends Composite
     }
 
     /* (non-Javadoc)
-     * @see fr.bigeon.gclc.manager.ConsoleInput#prompt(long)
+     * @see fr.bigeon.gclc.manager.ConsoleInput#prompt(long) */
-     */
     @Override
     public String prompt(final long timeout) throws IOException {
-        // TODO Auto-generated method stub
+        synchronized (promptLock) {
-        // return null;
+            if (isDisposed()) {
-        throw new RuntimeException("Not implemented yet");
+                throw new IOException();
+            }
+            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();
+                long start = System.currentTimeMillis();
+                long cur = start;
+                while (prompting && start + timeout>cur) {
+                    promptLock.wait((cur-start-timeout)/2);
+                    cur = System.currentTimeMillis();
+                }
+            } catch (final InterruptedException e) {
+                LOGGER.log(Level.WARNING, "Error in synchronization of prompting", e); //$NON-NLS-1$
+                command = null;
+                Thread.currentThread().interrupt();
+            }
+        }
+        if (isDisposed()) {
+            throw new IOException("Input closed"); //$NON-NLS-1$
+        }
+        return command;
     }
 
     /* (non-Javadoc)
@@ -278,16 +310,16 @@ public class SWTConsole extends Composite
                     throw new IOException();
                 }
             } catch (final InterruptedException e) {
-                LOGGER.log(Level.WARNING,
+                LOGGER.log(Level.WARNING, "Error in synchronization of prompting", e); //$NON-NLS-1$
-                        "Error in synchronization of prompting", e); //$NON-NLS-1$
                 command = null;
+                Thread.currentThread().interrupt();
             } finally {
                 Display.getDefault().syncExec(new Runnable() {
                     @SuppressWarnings("synthetic-access")
                     @Override
                     public void run() {
                         if (!consoleOutput.isDisposed()) {
-                            lblPromptlabel.setText(prompt);
+                            lblPromptlabel.setText(prompt.apply());
                             // relayout
                             SWTConsole.this.layout();
                         }
@@ -299,8 +331,7 @@ public class SWTConsole extends Composite
     }
 
     /* (non-Javadoc)
-     * @see fr.bigeon.gclc.manager.ConsoleInput#prompt(java.lang.String, long)
+     * @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
@@ -326,14 +357,14 @@ public class SWTConsole extends Composite
     /* (non-Javadoc)
      * @see fr.bigeon.gclc.ConsoleManager#setPrompt(java.lang.String) */
     @Override
-    public void setPrompt(final String prompt) {
+    public void setPrompt(final StringProvider prompt) {
         this.prompt = prompt;
         Display.getDefault().syncExec(new Runnable() {
             @SuppressWarnings("synthetic-access")
             @Override
             public void run() {
                 if (!consoleOutput.isDisposed()) {
-                    lblPromptlabel.setText(prompt);
+                    lblPromptlabel.setText(prompt.apply());
                     // relayout
                     SWTConsole.this.layout();
                 }
@@ -341,6 +372,11 @@ public class SWTConsole extends Composite
         });
     }
 
+    @Override
+    public void setPrompt(String prompt) {
+        setPrompt(new ConstantString(prompt));
+    }
+
     /** @param string the text */
     public void setText(final String string) {
         consoleInput.setText(string);
@@ -370,8 +406,7 @@ public class SWTConsole extends Composite
                 try {
                     promptLock.wait();
                 } catch (final InterruptedException e) {
-                    LOGGER.log(Level.SEVERE,
+                    LOGGER.log(Level.SEVERE, "Interruption while waiting prompt", e); //$NON-NLS-1$
-                            "Interruption while waiting prompt", e); //$NON-NLS-1$
                 }
             }
             Display.getDefault().syncExec(new Runnable() {
@@ -381,8 +416,7 @@ public class SWTConsole extends Composite
                     command = consoleInput.getText();
                     prompting = false;
                     consoleInput.setText(EMPTY);
-                    consoleOutput.append(
+                    consoleOutput.append(CMD_PREFIX + command + System.lineSeparator());
-                            CMD_PREFIX + command + System.lineSeparator());
                 }
             });
             promptLock.notifyAll();

gclc-swt/src/main/java/fr/bigeon/gclc/swt/SWTConsoleShell.java

@@ -1,10 +1,7 @@
 /*
- * Copyright E. Bigeon (2015)
+ * GCLC swt, provide a swt window for console applications
- *
+ * Copyright (C) 2015-2017 E. Bigeon
- * emmanuel@bigeon.fr
+ * mailto:emmanuel@bigeon.fr
- *
- * This software is a computer program whose purpose is to
- * provide a swt window for console applications.
  *
  * This software is governed by the CeCILL license under French law and
  * abiding by the rules of distribution of free software.  You can  use,
@@ -47,7 +44,7 @@ import org.eclipse.swt.widgets.Shell;
  * <p>
  *
  * @author Emmanuel Bigeon */
-public class SWTConsoleShell extends Shell {
+public final class SWTConsoleShell extends Shell {
 
     /** The console component */
     private SWTConsole console;

gclc-swt/src/main/java/fr/bigeon/gclc/swt/SWTConsoleView.java

@@ -1,10 +1,7 @@
 /*
- * Copyright E. Bigeon (2015)
+ * GCLC swt, provide a swt window for console applications
- *
+ * Copyright (C) 2015-2017 E. Bigeon
- * emmanuel@bigeon.fr
+ * mailto:emmanuel@bigeon.fr
- *
- * This software is a computer program whose purpose is to
- * provide a swt window for console applications.
  *
  * This software is governed by the CeCILL license under French law and
  * abiding by the rules of distribution of free software.  You can  use,
@@ -58,7 +55,7 @@ import fr.bigeon.gclc.tools.AOutputForwardRunnable;
  * <p>
  *
  * @author Emmanuel Bigeon */
-public class SWTConsoleView extends Composite implements ConsoleDelayIO {
+public final class SWTConsoleView extends Composite implements ConsoleDelayIO {
     /** The local implementation of the forwarding runnable
      *
      * @author Emmanuel Bigeon */
@@ -95,8 +92,7 @@ public class SWTConsoleView extends Composite implements ConsoleDelayIO {
     private final Text consoleOutput;
     /** The console input text field */
     private final Text consoleInput;
-    /** The actual manager */
+    /** The input. */
-    private PipedConsoleOutput manager;
     private PipedConsoleInput input;
     /** The forwarding runnable */
     private ToSWTConsoleForwardRunnable forward;
@@ -160,10 +156,12 @@ public class SWTConsoleView extends Composite implements ConsoleDelayIO {
         consoleInput.setSelection(input.length());
     }
 
-    /** @param manager the manager to set */
+    /** Set the input and output.
+     * 
+     * @param manager the output to set
+     * @param input the input */
     public void setManager(final PipedConsoleOutput manager,
                            final PipedConsoleInput input) {
-        this.manager = manager;
         this.input = input;
         if (forward != null) {
             forward.setRunning(false);

gclc-swt/src/main/java/fr/bigeon/gclc/swt/package-info.java

@@ -0,0 +1,39 @@
+/*
+ * 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.
+ */
+/**
+ * gclc-swt:fr.bigeon.gclc.swt.package-info.java
+ * Created on: Nov 18, 2017
+ */
+/** SWT components for a frontend of GCLC applications.
+ *
+ * @author Emmanuel Bigeon */
+package fr.bigeon.gclc.swt;

gclc-swt/src/test/java/fr/bigeon/gclc/swt/HistoryTextKeyListenerTest.java

@@ -1,10 +1,7 @@
 /*
- * Copyright E. Bigeon (2015)
+ * GCLC swt, provide a swt window for console applications
- *
+ * Copyright (C) 2015-2017 E. Bigeon
- * emmanuel@bigeon.fr
+ * mailto:emmanuel@bigeon.fr
- *
- * This software is a computer program whose purpose is to
- * provide a swt window for console applications.
  *
  * This software is governed by the CeCILL license under French law and
  * abiding by the rules of distribution of free software.  You can  use,

gclc-swt/src/test/java/fr/bigeon/gclc/swt/SWTConsoleShellTest.java

@@ -1,10 +1,7 @@
 /*
- * Copyright E. Bigeon (2015)
+ * GCLC swt, provide a swt window for console applications
- *
+ * Copyright (C) 2015-2017 E. Bigeon
- * emmanuel@bigeon.fr
+ * mailto:emmanuel@bigeon.fr
- *
- * This software is a computer program whose purpose is to
- * provide a swt window for console applications.
  *
  * This software is governed by the CeCILL license under French law and
  * abiding by the rules of distribution of free software.  You can  use,

gclc-swt/src/test/java/fr/bigeon/gclc/swt/SWTConsoleViewTest.java

@@ -1,10 +1,7 @@
 /*
- * Copyright E. Bigeon (2015)
+ * GCLC swt, provide a swt window for console applications
- *
+ * Copyright (C) 2015-2017 E. Bigeon
- * emmanuel@bigeon.fr
+ * mailto:emmanuel@bigeon.fr
- *
- * This software is a computer program whose purpose is to
- * provide a swt window for console applications.
  *
  * This software is governed by the CeCILL license under French law and
  * abiding by the rules of distribution of free software.  You can  use,
@@ -72,13 +69,13 @@ public class SWTConsoleViewTest {
         final Shell shell = new Shell(DISPLAY);
         final SWTConsoleView swtConsole = new SWTConsoleView(shell, SWT.NONE);
         try (PipedConsoleOutput manager = new PipedConsoleOutput();
-             PipedConsoleInput input = new PipedConsoleInput()) {
+             PipedConsoleInput input = new PipedConsoleInput(System.out)) {
             swtConsole.setManager(manager, input);
         } catch (final IOException e2) {
             assertNull(e2);
         }
         try (PipedConsoleOutput manager = new PipedConsoleOutput();
-             PipedConsoleInput input = new PipedConsoleInput()) {
+             PipedConsoleInput input = new PipedConsoleInput(System.out)) {
             swtConsole.setManager(manager, input);
             final ConsoleApplication appl = new ConsoleApplication(manager,
                     input,

gclc/pom.xml

@@ -35,7 +35,7 @@
 <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</artifactId>
-	<version>2.0.2-SNAPSHOT</version>
+	<version>2.0.6-SNAPSHOT</version>
 	<packaging>jar</packaging>
 	<url>http://www.bigeon.fr/emmanuel</url>
 	<properties>

gclc/src/main/java/fr/bigeon/gclc/ApplicationAttachement.java

@@ -38,6 +38,7 @@
  */
 package fr.bigeon.gclc;
 
+import fr.bigeon.gclc.command.ICommandProvider;
 import fr.bigeon.gclc.exception.InvalidCommandName;
 
 /** Represent a functionnality set that can be added to a console application.
@@ -54,5 +55,5 @@ public interface ApplicationAttachement {
      * @param application the application
      * @throws InvalidCommandName if a command name is invalid for the
      *             application. */
-    void attach(ConsoleApplication application) throws InvalidCommandName;
+    void attach(ICommandProvider application) throws InvalidCommandName;
 }

gclc/src/main/java/fr/bigeon/gclc/command/CommandParameters.java

@@ -137,7 +137,11 @@ public final class CommandParameters {
      * @return the number of element read */
     private int parseArg(final String arg, final String next) {
         if (!arg.startsWith("-")) { //$NON-NLS-1$
-            return strict ? 0 : 1;
+            if (strict) {
+                return 0;
+            }
+            additional.add(arg);
+            return 1;
         }
         final String name = arg.substring(1);
         if (booleanArguments.containsKey(name)) {

gclc/src/main/java/fr/bigeon/gclc/command/ParametrizedCommand.java

@@ -39,23 +39,12 @@
 package fr.bigeon.gclc.command;
 
 import java.io.IOException;
-import java.text.MessageFormat;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Map.Entry;
 import java.util.Set;
 
-import fr.bigeon.gclc.exception.CommandParsingException;
 import fr.bigeon.gclc.exception.CommandRunException;
-import fr.bigeon.gclc.exception.CommandRunExceptionType;
 import fr.bigeon.gclc.exception.InvalidParameterException;
 import fr.bigeon.gclc.manager.ConsoleInput;
 import fr.bigeon.gclc.manager.ConsoleOutput;
-import fr.bigeon.gclc.manager.EmptyInput;
 
 /** A command relying on the {@link CommandParameters} to store parameters
  * values.
@@ -63,15 +52,7 @@ import fr.bigeon.gclc.manager.EmptyInput;
  * @author Emmanuel BIGEON */
 public abstract class ParametrizedCommand extends Command {
 
-    /** The boolean parameters mandatory status. */
+    private final ParametrizedCommandData data;
-    private final Set<String> boolParams = new HashSet<>();
-    /** The string parameters mandatory status. */
-    private final Map<String, Boolean> stringParams = new HashMap<>();
-    /** The parameters mandatory status. */
-    private final Map<String, Boolean> params = new HashMap<>();
-    /** The restriction of provided parameters on execution to declared
-     * paramters in the status maps. */
-    private final boolean strict;
 
     /** Create a parametrized command.
      * <p>
@@ -96,7 +77,7 @@ public abstract class ParametrizedCommand extends Command {
      * @param strict if the arguments are restricted to the declared ones */
     public ParametrizedCommand(final String name, final boolean strict) {
         super(name);
-        this.strict = strict;
+        data = new ParametrizedCommandData(strict);
     }
 
     /** Add a boolean parameter to defined parmaters.
@@ -105,12 +86,7 @@ public abstract class ParametrizedCommand extends Command {
      * @throws InvalidParameterException if the parameter is already defined as
      *             a string parameter */
     protected final void addBooleanParameter(final String flag) throws InvalidParameterException {
-        if (params.containsKey(flag) && stringParams.containsKey(flag)) {
+        data.addBooleanParameter(flag);
-            throw new InvalidParameterException(
-                    "Parameter is already defined as string"); //$NON-NLS-1$
-        }
-        boolParams.add(flag);
-        params.put(flag, Boolean.FALSE);
     }
 
     /** Add a string parameter to defined parmaters.
@@ -121,30 +97,7 @@ public abstract class ParametrizedCommand extends Command {
      *             a boolean parameter */
     protected final void addStringParameter(final String flag,
                                             final boolean needed) throws InvalidParameterException {
-        if (params.containsKey(flag)) {
+        data.addStringParameter(flag, needed);
-            checkParam(flag, needed);
-            return;
-        }
-        stringParams.put(flag, Boolean.valueOf(needed));
-        params.put(flag, Boolean.valueOf(needed));
-    }
-
-    /** Check a parameter.
-     *
-     * @param param the string parameter
-     * @param needed if the parameter is needed
-     * @throws InvalidParameterException if the new definition is invalid */
-    private void checkParam(final String param,
-                            final boolean needed) throws InvalidParameterException {
-        if (stringParams.containsKey(param)) {
-            final Boolean need = Boolean
-                    .valueOf(needed || stringParams.get(param).booleanValue());
-            stringParams.put(param, need);
-            params.put(param, need);
-            return;
-        }
-        throw new InvalidParameterException(
-                "Parameter is already defined as boolean"); //$NON-NLS-1$
     }
 
     /** Actually performs the execution after parsing the parameters.
@@ -162,59 +115,10 @@ public abstract class ParametrizedCommand extends Command {
     public final void execute(final ConsoleOutput output,
                               final ConsoleInput input,
                               final String... args) throws CommandRunException {
-        final CommandParameters parameters = new CommandParameters(boolParams,
-                stringParams.keySet(), strict);
         try {
-            parameters.parseArgs(args);
+            doExecute(output, input, data.getParameters(input, args));
-        } catch (final CommandParsingException e) {
+        } catch (final IOException e) {
-            throw new CommandRunException(CommandRunExceptionType.USAGE,
+            throw new CommandRunException("Unable to get parameters", e, this);
-                    "Unable to read arguments", e, this); //$NON-NLS-1$
-        }
-        final List<String> toProvide = new ArrayList<>();
-        for (final Entry<String, Boolean> string : params.entrySet()) {
-            if (string.getValue().booleanValue() &&
-                parameters.get(string.getKey()) == null) {
-                if (input == null || input == EmptyInput.INSTANCE) {
-                    throw new CommandRunException(
-                            CommandRunExceptionType.INTERACTION,
-                            "Missing required parameter " + string.getKey(), //$NON-NLS-1$
-                            this);
-                }
-                toProvide.add(string.getKey());
-            }
-        }
-        // for each needed parameters that is missing, prompt the user.
-        fillParameters(input, toProvide, parameters);
-        doExecute(output, input, parameters);
-    }
-
-    /** Fill the undefined parameters.
-     * <p>
-     * This method prompts the user to fill the needed parameters.
-     *
-     * @param input the input to prompt through
-     * @param parameters the parameter list to complete
-     * @param toProvide the parameters to ask for
-     * @throws CommandRunException if the manager was closed */
-    private final void fillParameters(final ConsoleInput input,
-                                      final List<String> toProvide,
-                                      final CommandParameters parameters) throws CommandRunException {
-        for (final String string : toProvide) {
-            String value;
-            try {
-                value = input
-                        .prompt(MessageFormat.format("value of {0}? ", string)); //$NON-NLS-1$
-                while (value.isEmpty()) {
-                    value = input.prompt(MessageFormat.format(
-                            "value of {0}? (cannot be empty) ", //$NON-NLS-1$
-                            string));
-                }
-            } catch (final IOException e) {
-                throw new CommandRunException(
-                        CommandRunExceptionType.INTERACTION,
-                        "Interactive command but manager closed...", e, this); //$NON-NLS-1$
-            }
-            parameters.set(string, value);
         }
     }
 
@@ -222,21 +126,21 @@ public abstract class ParametrizedCommand extends Command {
      *
      * @return the set of boolean parameters */
     public final Set<String> getBooleanParameters() {
-        return Collections.unmodifiableSet(boolParams);
+        return data.getBooleanParameters();
     }
 
     /** Retrieve the parameter names.
      *
      * @return the stringParams */
     public final Set<String> getParameters() {
-        return params.keySet();
+        return data.getParameters();
     }
 
     /** Get the string parameters names.
      *
      * @return the stringParams */
     public final Set<String> getStringParameters() {
-        return stringParams.keySet();
+        return data.getStringParameters();
     }
 
     /** Test if a parameter is needed.
@@ -244,13 +148,13 @@ public abstract class ParametrizedCommand extends Command {
      * @param param the parameter name
      * @return if the parameter is needed */
     public final boolean isNeeded(final String param) {
-        return params.containsKey(param) && params.get(param).booleanValue();
+        return data.isNeeded(param);
     }
 
     /** If the command refuse unrecognized parameters.
      *
      * @return the strict */
     public final boolean isStrict() {
-        return strict;
+        return data.isStrict();
     }
 }

gclc/src/main/java/fr/bigeon/gclc/command/ParametrizedCommandData.java

@@ -0,0 +1,210 @@
+/*
+ * Copyright Bigeon Emmanuel (2014)
+ *
+ * emmanuel@bigeon.fr
+ *
+ * This software is a computer program whose purpose is to
+ * provide a generic framework for console applications.
+ *
+ * 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:fr.bigeon.gclc.command.ParametrizedCommand.java
+ * Created on: Dec 24, 2014
+ */
+package fr.bigeon.gclc.command;
+
+import java.io.IOException;
+import java.text.MessageFormat;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+
+import fr.bigeon.gclc.exception.CommandParsingException;
+import fr.bigeon.gclc.exception.InvalidParameterException;
+import fr.bigeon.gclc.manager.ConsoleInput;
+import fr.bigeon.gclc.manager.EmptyInput;
+
+/** An object to handle standardized command parameters.
+ *
+ * @author Emmanuel BIGEON */
+public final class ParametrizedCommandData {
+
+    /** The boolean parameters mandatory status. */
+    private final Set<String>          boolParams   = new HashSet<>();
+    /** The string parameters mandatory status. */
+    private final Map<String, Boolean> stringParams = new HashMap<>();
+    /** The parameters mandatory status. */
+    private final Map<String, Boolean> params       = new HashMap<>();
+    /** The restriction of provided parameters on execution to declared paramters in
+     * the status maps. */
+    private final boolean              strict;
+
+    public ParametrizedCommandData() {
+        this(true);
+    }
+
+    public ParametrizedCommandData(final boolean strict) {
+        this.strict = strict;
+    }
+
+    /** Add a boolean parameter to defined parmaters.
+     *
+     * @param flag the boolean flag
+     * @throws InvalidParameterException if the parameter is already defined as a
+     *         string parameter */
+    public final void addBooleanParameter(final String flag)
+            throws InvalidParameterException {
+        if (params.containsKey(flag) && stringParams.containsKey(flag)) {
+            throw new InvalidParameterException("Parameter is already defined as string"); //$NON-NLS-1$
+        }
+        boolParams.add(flag);
+        params.put(flag, Boolean.FALSE);
+    }
+
+    /** Add a string parameter to defined parmaters.
+     *
+     * @param flag the parameter flag
+     * @param needed if the parameter's absence should cause an exception
+     * @throws InvalidParameterException if the parameter is already defined as a
+     *         boolean parameter */
+    public final void addStringParameter(final String flag, final boolean needed)
+            throws InvalidParameterException {
+        if (params.containsKey(flag)) {
+            checkParam(flag, needed);
+            return;
+        }
+        stringParams.put(flag, Boolean.valueOf(needed));
+        params.put(flag, Boolean.valueOf(needed));
+    }
+
+    /** Check a parameter.
+     *
+     * @param param the string parameter
+     * @param needed if the parameter is needed
+     * @throws InvalidParameterException if the new definition is invalid */
+    private void checkParam(final String param, final boolean needed)
+            throws InvalidParameterException {
+        if (stringParams.containsKey(param)) {
+            final Boolean need = Boolean
+                    .valueOf(needed || stringParams.get(param).booleanValue());
+            stringParams.put(param, need);
+            params.put(param, need);
+            return;
+        }
+        throw new InvalidParameterException("Parameter is already defined as boolean"); //$NON-NLS-1$
+    }
+
+    public final CommandParameters getParameters(final ConsoleInput input,
+            final String... args)
+            throws IOException {
+        final CommandParameters parameters = new CommandParameters(boolParams,
+                stringParams.keySet(), strict);
+        try {
+            parameters.parseArgs(args);
+        } catch (final CommandParsingException e) {
+            throw new IOException(e);
+        }
+        final List<String> toProvide = new ArrayList<>();
+        for (final Entry<String, Boolean> string : params.entrySet()) {
+            if (string.getValue().booleanValue()
+                    && parameters.get(string.getKey()) == null) {
+                if (input == null || input == EmptyInput.INSTANCE) {
+                    throw new IOException();
+                }
+                toProvide.add(string.getKey());
+            }
+        }
+        // for each needed parameters that is missing, prompt the user.
+        fillParameters(input, toProvide, parameters);
+        return parameters;
+    }
+
+    /** Fill the undefined parameters.
+     * <p>
+     * This method prompts the user to fill the needed parameters.
+     *
+     * @param input the input to prompt through
+     * @param parameters the parameter list to complete
+     * @param toProvide the parameters to ask for
+     * @throws IOException if the manager was closed */
+    private final static void fillParameters(final ConsoleInput input,
+            final List<String> toProvide, final CommandParameters parameters)
+            throws IOException {
+        for (final String string : toProvide) {
+            String value;
+            value = input.prompt(MessageFormat.format("value of {0}? ", string)); //$NON-NLS-1$
+            while (value.isEmpty()) {
+                value = input
+                        .prompt(MessageFormat.format("value of {0}? (cannot be empty) ", //$NON-NLS-1$
+                                string));
+            }
+            parameters.set(string, value);
+        }
+    }
+
+    /** Retrieve the boolean parameters (aka flags).
+     *
+     * @return the set of boolean parameters */
+    public final Set<String> getBooleanParameters() {
+        return Collections.unmodifiableSet(boolParams);
+    }
+
+    /** Retrieve the parameter names.
+     *
+     * @return the stringParams */
+    public final Set<String> getParameters() {
+        return params.keySet();
+    }
+
+    /** Get the string parameters names.
+     *
+     * @return the stringParams */
+    public final Set<String> getStringParameters() {
+        return stringParams.keySet();
+    }
+
+    /** Test if a parameter is needed.
+     *
+     * @param param the parameter name
+     * @return if the parameter is needed */
+    public final boolean isNeeded(final String param) {
+        return params.containsKey(param) && params.get(param).booleanValue();
+    }
+
+    /** If the command refuse unrecognized parameters.
+     *
+     * @return the strict */
+    public final boolean isStrict() {
+        return strict;
+    }
+}

gclc/src/main/java/fr/bigeon/gclc/command/SubedCommand.java

@@ -153,6 +153,8 @@ public final class SubedCommand extends CommandProvider implements ICommand {
             final ICommand c = get(args[0]);
             if (c != null) {
                 c.help(manager, Arrays.copyOfRange(args, 1, args.length));
+            } else {
+              manager.println("No command "+Arrays.toString(args));
             }
         } else {
             // Generic

gclc/src/main/java/fr/bigeon/gclc/manager/ConsoleInput.java

@@ -41,6 +41,8 @@ package fr.bigeon.gclc.manager;
 import java.io.IOException;
 import java.io.InterruptedIOException;
 
+import fr.bigeon.gclc.tools.StringProvider;
+
 /** A console application input.
  *
  * @author Emmanuel Bigeon */
@@ -55,7 +57,7 @@ public interface ConsoleInput extends AutoCloseable {
     /** Get the prompt string.
      *
      * @return the prompt prefix */
-    String getPrompt();
+    StringProvider getPrompt();
 
     /** Indicate to the input that is should interrompt the prompting, if
      * possible.
@@ -111,4 +113,6 @@ public interface ConsoleInput extends AutoCloseable {
      *
      * @param prompt the prompt */
     void setPrompt(String prompt);
+    
+    void setPrompt(StringProvider string);
 }

gclc/src/main/java/fr/bigeon/gclc/manager/EmptyInput.java

@@ -38,6 +38,9 @@
  */
 package fr.bigeon.gclc.manager;
 
+import fr.bigeon.gclc.tools.ConstantString;
+import fr.bigeon.gclc.tools.StringProvider;
+
 /** A console input that return empty to all prompting.
  *
  * @author Emmanuel Bigeon */
@@ -59,8 +62,8 @@ public final class EmptyInput implements ConsoleInput {
     /* (non-Javadoc)
      * @see fr.bigeon.gclc.manager.ConsoleInput#getPrompt() */
     @Override
-    public String getPrompt() {
+    public StringProvider getPrompt() {
-        return ""; //$NON-NLS-1$
+        return new ConstantString(""); //$NON-NLS-1$
     }
 
     /* (non-Javadoc)
@@ -114,4 +117,8 @@ public final class EmptyInput implements ConsoleInput {
         //
     }
 
+    @Override
+    public void setPrompt(StringProvider string) {
+    	//
+    }
 }

gclc/src/main/java/fr/bigeon/gclc/manager/PipedConsoleInput.java

@@ -44,6 +44,8 @@ import java.io.PipedOutputStream;
 import java.io.PrintStream;
 import java.nio.charset.StandardCharsets;
 
+import fr.bigeon.gclc.tools.StringProvider;
+
 /** This console input allows to enter commands and retrieve the output as an
  * input.
  * <p>
@@ -87,7 +89,7 @@ public final class PipedConsoleInput
     }
 
     @Override
-    public String getPrompt() {
+    public StringProvider getPrompt() {
         return innerManager.getPrompt();
     }
 
@@ -141,6 +143,11 @@ public final class PipedConsoleInput
     public void setPrompt(final String prompt) {
         innerManager.setPrompt(prompt);
     }
+    
+    @Override
+    public void setPrompt(StringProvider string) {
+    	innerManager.setPrompt(string);
+    }
 
     /** Type a message in the input.
      *

gclc/src/main/java/fr/bigeon/gclc/manager/StreamConsoleInput.java

@@ -45,6 +45,9 @@ import java.io.InputStreamReader;
 import java.io.PrintStream;
 import java.nio.charset.Charset;
 
+import fr.bigeon.gclc.tools.ConstantString;
+import fr.bigeon.gclc.tools.StringProvider;
+
 /** A console using the input stream and print stream.
  * <p>
  * The default constructor will use the system standart input and output.
@@ -53,10 +56,10 @@ import java.nio.charset.Charset;
 public final class StreamConsoleInput implements ConsoleInput {
 
     /** The default prompt. */
-    public static final String DEFAULT_PROMPT = "> "; //$NON-NLS-1$
+    public static final StringProvider DEFAULT_PROMPT = new ConstantString("> "); //$NON-NLS-1$
 
     /** The command prompt. It can be changed. */
-    private String prompt = DEFAULT_PROMPT;
+    private StringProvider prompt = DEFAULT_PROMPT;
 
     /** The print stream. */
     private final PrintStream out;
@@ -110,13 +113,12 @@ public final class StreamConsoleInput implements ConsoleInput {
         closed = true;
         reading.setRunning(false);
         promptThread.interrupt();
-        in.close();
     }
 
     /* (non-Javadoc)
      * @see fr.bigeon.gclc.manager.ConsoleInput#getPrompt() */
     @Override
-    public String getPrompt() {
+    public StringProvider getPrompt() {
         return prompt;
     }
 
@@ -139,14 +141,14 @@ public final class StreamConsoleInput implements ConsoleInput {
      * @see fr.bigeon.gclc.ConsoleManager#prompt() */
     @Override
     public String prompt() throws IOException {
-        return prompt(prompt);
+        return prompt(prompt.apply());
     }
 
     /* (non-Javadoc)
      * @see fr.bigeon.gclc.manager.ConsoleManager#prompt(long) */
     @Override
     public String prompt(final long timeout) throws IOException {
-        return prompt(prompt, timeout);
+        return prompt(prompt.apply(), timeout);
     }
 
     /* (non-Javadoc)
@@ -178,7 +180,11 @@ public final class StreamConsoleInput implements ConsoleInput {
      * @see fr.bigeon.gclc.manager.ConsoleInput#setPrompt(java.lang.String) */
     @Override
     public void setPrompt(final String prompt) {
-        this.prompt = prompt;
+        this.prompt = new ConstantString(prompt);
     }
 
+    @Override
+    public void setPrompt(StringProvider string) {
+    	this.prompt = string;
+    }
 }

gclc/src/main/java/fr/bigeon/gclc/tools/ConstantString.java

@@ -0,0 +1,50 @@
+/*
+ * Copyright Bigeon Emmanuel (2014)
+ *
+ * emmanuel@bigeon.fr
+ *
+ * This software is a computer program whose purpose is to
+ * provide a generic framework for console applications.
+ *
+ * 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 fr.bigeon.gclc.tools;
+
+public class ConstantString implements StringProvider {
+	private String string;
+	
+	
+	
+	@Override
+	public String apply() {
+		return string;
+	}
+
+
+	public ConstantString(String string) {
+		this.string = string;
+	}

gclc/src/main/java/fr/bigeon/gclc/tools/StringProvider.java

@@ -0,0 +1,49 @@
+/*
+ * Copyright Bigeon Emmanuel (2014)
+ *
+ * emmanuel@bigeon.fr
+ *
+ * This software is a computer program whose purpose is to
+ * provide a generic framework for console applications.
+ *
+ * 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 fr.bigeon.gclc.tools;
+
+/**
+ * A string providing object.
+ * <p>
+ * Implementations of this interface will provide a string, this internal state
+ * of the object may be so that successive calls to the apply method return
+ * different results.
+ * 
+ * @author Emmanuel
+ *
+ */
+public interface StringProvider {
+	String apply();
+}

gclc/src/test/java/fr/bigeon/gclc/CommandTestingApplication.java

@@ -99,8 +99,7 @@ public class CommandTestingApplication implements AutoCloseable {
     }
 
     /** @return the next written line, null if it is the prompt
-     * @throws IOException if the reading failed
+     * @throws IOException if the reading failed */
-     * @see fr.bigeon.gclc.manager.PipedConsoleManager#readNextLine() */
     public String readNextLine() throws IOException {
         final String ret = out.readNextLine();
         return ret;

gclc/src/test/java/fr/bigeon/gclc/ConsoleTestApplication.java

@@ -39,6 +39,7 @@ import java.io.IOException;
 import fr.bigeon.gclc.command.Command;
 import fr.bigeon.gclc.command.ExitCommand;
 import fr.bigeon.gclc.command.HelpExecutor;
+import fr.bigeon.gclc.command.ICommandProvider;
 import fr.bigeon.gclc.exception.CommandRunException;
 import fr.bigeon.gclc.exception.InvalidCommandName;
 import fr.bigeon.gclc.manager.ConsoleInput;
@@ -54,14 +55,14 @@ public class ConsoleTestApplication implements ApplicationAttachement {
     /** Two seconds in milliseconds */
     protected static final long TWO_SECONDS = 2000;
 
-    /** @param manager the manager */
+    /***/
     @Override
     @SuppressWarnings("nls")
-    public void attach(final ConsoleApplication application) {
+    public void attach(final ICommandProvider application) {
         try {
-            application.add(new ExitCommand(EXIT, application));
+            application.add(new ExitCommand(EXIT, (ConsoleApplication) application));
             application.add(new HelpExecutor("help",
-                    application.root));
+                    ((ConsoleApplication) application).root));
             application.add(new Command("test") {
 
                 /* (non-Javadoc)

gclc/src/test/java/fr/bigeon/gclc/command/CommandParametersTest.java

@@ -151,7 +151,7 @@ public class CommandParametersTest {
         parameters.parseArgs("-boolFlag");
         assertTrue(parameters.getAdditionals().isEmpty());
 
-        parameters.parseArgs("-ungiven");
+        parameters.parseArgs("ungiven");
         assertTrue(parameters.getAdditionals().contains("ungiven"));
         assertEquals(1, parameters.getAdditionals().size());
     }
@@ -159,7 +159,7 @@ public class CommandParametersTest {
     /** Test method for
      * {@link fr.bigeon.gclc.command.CommandParameters#getBool(java.lang.String)}.
      *
-     * @throws CommandParsingException */
+     * @throws CommandParsingException if a command parsing failed */
     @Test
     public final void testGetBool() throws CommandParsingException {
         final Set<String> strings = new HashSet<>();
@@ -212,7 +212,7 @@ public class CommandParametersTest {
     /** Test method for
      * {@link fr.bigeon.gclc.command.CommandParameters#parseArgs(java.lang.String[])}.
      *
-     * @throws CommandParsingException */
+     * @throws CommandParsingException if a command parsing failed */
     @Test
     public final void testParseArgs() throws CommandParsingException {
         final Set<String> strings = new HashSet<>();

gclc/src/test/java/fr/bigeon/gclc/command/CommandProviderTest.java

@@ -54,7 +54,7 @@ public class CommandProviderTest {
     /** Test method for
      * {@link fr.bigeon.gclc.command.CommandProvider#add(fr.bigeon.gclc.command.ICommand)}.
      *
-     * @throws InvalidCommandName */
+     * @throws InvalidCommandName if the test failed */
     @Test
     public final void testAdd() throws InvalidCommandName {
         final CommandProvider provider = new CommandProvider();

gclc/src/test/java/fr/bigeon/gclc/command/HelpExecutorTest.java

@@ -58,10 +58,10 @@ import fr.bigeon.gclc.manager.PipedConsoleOutput;
 public class HelpExecutorTest {
 
     /** Test method for
-     * {@link fr.bigeon.gclc.command.HelpExecutor#execute(java.lang.String[])}.
+     * {@link fr.bigeon.gclc.command.HelpExecutor#execute(ConsoleOutput, ConsoleInput, String...)}.
      *
-     * @throws CommandRunException
+     * @throws CommandRunException if the test failed
-     * @throws IOException */
+     * @throws IOException if the test failed */
     @Test
     public final void testExecute() throws CommandRunException, IOException {
         final PipedConsoleOutput test = new PipedConsoleOutput();
@@ -98,7 +98,7 @@ public class HelpExecutorTest {
 
     /** Test method for {@link fr.bigeon.gclc.command.HelpExecutor#tip()}.
      *
-     * @throws IOException */
+     * @throws IOException if the test failed */
     @Test
     public final void testTip() throws IOException {
         try (PipedConsoleOutput test = new PipedConsoleOutput()) {

gclc/src/test/java/fr/bigeon/gclc/command/ParametrizedCommandTest.java

@@ -69,9 +69,9 @@ import fr.bigeon.gclc.manager.PipedConsoleOutput;
 public class ParametrizedCommandTest {
 
     /** Test method for
-     * {@link fr.bigeon.gclc.command.ParametrizedCommand#addParameter(java.lang.String, boolean, boolean)}.
+     * {@link fr.bigeon.gclc.command.ParametrizedCommand#addStringParameter(String, boolean)}.
      *
-     * @throws InvalidParameterException */
+     * @throws InvalidParameterException if the test failed */
     @Test
     public final void testAddParameter() throws InvalidParameterException {
         ParametrizedCommand cmd = new ParametrizedCommand("name") {
@@ -138,11 +138,11 @@ public class ParametrizedCommandTest {
     }
 
     /** Test method for
-     * {@link fr.bigeon.gclc.command.ParametrizedCommand#execute(java.lang.String[])}.
+     * {@link fr.bigeon.gclc.command.ParametrizedCommand#execute(ConsoleOutput, ConsoleInput, String...)}.
      *
-     * @throws CommandRunException
+     * @throws CommandRunException if the test failed
-     * @throws InterruptedException
+     * @throws InterruptedException if the test failed
-     * @throws IOException */
+     * @throws IOException if the test failed */
     @Test
     public final void testExecute() throws CommandRunException,
                                     InterruptedException, IOException {
@@ -183,9 +183,7 @@ public class ParametrizedCommandTest {
             }
         };
         cmd.execute(null, null);
-        cmd.execute(null, null, "-" + addParam);
         cmd.execute(null, null, addParam);
-        cmd.execute(null, null, "-" + addParam, addParam);
         cmd = new ParametrizedCommand("name", false) {
             private int call = 0;
             {
@@ -555,7 +553,7 @@ public class ParametrizedCommandTest {
     }
 
     /** Test method for
-     * {@link fr.bigeon.gclc.command.ParametrizedCommand#ParametrizedCommand(fr.bigeon.gclc.manager.ConsoleManager, java.lang.String)}. */
+     * {@link fr.bigeon.gclc.command.ParametrizedCommand#ParametrizedCommand(String)}. */
     @Test
     public final void testParametrizedCommandConsoleManagerString() {
         ParametrizedCommand cmd = new ParametrizedCommand("name") {
@@ -619,7 +617,7 @@ public class ParametrizedCommandTest {
     }
 
     /** Test method for
-     * {@link fr.bigeon.gclc.command.ParametrizedCommand#ParametrizedCommand(fr.bigeon.gclc.manager.ConsoleManager, java.lang.String, boolean)}. */
+     * {@link fr.bigeon.gclc.command.ParametrizedCommand#ParametrizedCommand(java.lang.String, boolean)}. */
     @Test
     public final void testParametrizedCommandConsoleManagerStringBoolean() {
         ParametrizedCommand cmd = new ParametrizedCommand("name", false) {

gclc/src/test/java/fr/bigeon/gclc/command/ScriptExecutionTest.java

@@ -61,9 +61,8 @@ import fr.bigeon.gclc.manager.PipedConsoleOutput;
 @SuppressWarnings("static-method")
 public class ScriptExecutionTest {
 
-    /**
+    /** Test method for
-     * Test method for {@link fr.bigeon.gclc.command.ScriptExecution#execute(java.lang.String[])}.
+     * {@link fr.bigeon.gclc.command.ScriptExecution#execute(fr.bigeon.gclc.manager.ConsoleOutput, fr.bigeon.gclc.manager.ConsoleInput, String...)}. */
-     */
     @Test
     public void testExecute() {
         PipedConsoleOutput test;
@@ -158,7 +157,7 @@ public class ScriptExecutionTest {
     }
 
     /** Test method for
-     * {@link fr.bigeon.gclc.command.ScriptExecution#help(fr.bigeon.gclc.manager.ConsoleManager, String...)}. */
+     * {@link fr.bigeon.gclc.command.ScriptExecution#help(fr.bigeon.gclc.manager.ConsoleOutput, String...)}. */
     @Test
     public void testHelp() {
         final ScriptExecution exec = new ScriptExecution("script", null, "#", //$NON-NLS-1$ //$NON-NLS-2$

gclc/src/test/java/fr/bigeon/gclc/command/SubedCommandTest.java

@@ -88,7 +88,7 @@ public class SubedCommandTest {
     }
 
     /** Test method for
-     * {@link fr.bigeon.gclc.command.SubedCommand#execute(java.lang.String[])}. */
+     * {@link fr.bigeon.gclc.command.SubedCommand#execute(ConsoleOutput, ConsoleInput, String...)}. */
     @Test
     public final void testExecute() {
         SubedCommand cmd = new SubedCommand("name");
@@ -190,7 +190,7 @@ public class SubedCommandTest {
     }
 
     /** Test method for
-     * {@link fr.bigeon.gclc.command.SubedCommand#executeSub(java.lang.String, java.lang.String[])}. */
+     * {@link fr.bigeon.gclc.command.SubedCommand#executeSub(ConsoleOutput, ConsoleInput, String, String...)}. */
     @Test
     public final void testExecuteSub() {
         final SubedCommand cmd = new SubedCommand("name");
@@ -272,7 +272,7 @@ public class SubedCommandTest {
     }
 
     /** Test method for
-     * {@link fr.bigeon.gclc.command.SubedCommand#help(fr.bigeon.gclc.manager.ConsoleManager, java.lang.String[])}. */
+     * {@link fr.bigeon.gclc.command.SubedCommand#help(ConsoleOutput, String...)}. */
     @Test
     public final void testHelp() {
         SubedCommand cmd = new SubedCommand("name");

gclc/src/test/java/fr/bigeon/gclc/manager/ReadingRunnableTest.java

@@ -84,8 +84,8 @@ public class ReadingRunnableTest {
     /** Test method for
      * {@link fr.bigeon.gclc.manager.ReadingRunnable#getWaitForDelivery(java.lang.String)}.
      *
-     * @throws InterruptedException
+     * @throws InterruptedException if the test failed
-     * @throws IOException */
+     * @throws IOException if the test failed */
     @Test
     public final void testGetWaitForDelivery() throws InterruptedException,
                                                IOException {

gclc/src/test/java/fr/bigeon/gclc/manager/SystemConsoleManagerTest.java

@@ -59,11 +59,10 @@ import org.junit.Test;
  * @author Emmanuel Bigeon */
 public class SystemConsoleManagerTest {
 
-    /** Test method for
+    /** Test method for {@link fr.bigeon.gclc.manager.ConsoleInput#isClosed()}.
-     * {@link fr.bigeon.gclc.manager.SystemConsoleManager#isClosed()}.
      *
-     * @throws IOException
+     * @throws IOException if the test failed
-     * @throws InterruptedException */
+     * @throws InterruptedException if the test failed */
     @Test
     public final void testIsClosed() throws IOException, InterruptedException {
         final PipedOutputStream outStream = new PipedOutputStream();
@@ -96,11 +95,10 @@ public class SystemConsoleManagerTest {
         th.join();
     }
 
-    /** Test method for
+    /** Test method for {@link fr.bigeon.gclc.manager.ConsoleInput#prompt()}.
-     * {@link fr.bigeon.gclc.manager.SystemConsoleManager#prompt()}.
      * 
-     * @throws IOException
+     * @throws IOException if the test failed
-     * @throws InterruptedException */
+     * @throws InterruptedException if the test failed */
     @Test
     public final void testPrompt() throws IOException, InterruptedException {
 
@@ -128,9 +126,9 @@ public class SystemConsoleManagerTest {
     }
 
     /** Test method for
-     * {@link fr.bigeon.gclc.manager.SystemConsoleManager#setPrompt(java.lang.String)}.
+     * {@link fr.bigeon.gclc.manager.ConsoleInput#setPrompt(java.lang.String)}.
      * 
-     * @throws IOException */
+     * @throws IOException if the test failed */
     @Test
     public final void testSetPrompt() throws IOException {
         try (PipedOutputStream outStream = new PipedOutputStream();
@@ -141,7 +139,7 @@ public class SystemConsoleManagerTest {
 
             final String prt = "++";
             manager.setPrompt(prt);
-            assertEquals(prt, manager.getPrompt());
+            assertEquals(prt, manager.getPrompt().apply());
         }
     }
 

gclc/src/test/java/fr/bigeon/gclc/prompt/CLIPrompterTest.java

@@ -82,7 +82,7 @@ public class CLIPrompterTest {
     }
 
     /** Test method for
-     * {@link fr.bigeon.gclc.prompt.CLIPrompter#promptBoolean(fr.bigeon.gclc.manager.ConsoleManager, java.lang.String)}. */
+     * {@link fr.bigeon.gclc.prompt.CLIPrompter#promptBoolean(fr.bigeon.gclc.manager.ConsoleOutput, fr.bigeon.gclc.manager.ConsoleInput, String)}. */
     @Test
     public final void testPromptBoolean() {
         try (final PipedConsoleOutput out = new PipedConsoleOutput();
@@ -132,7 +132,7 @@ public class CLIPrompterTest {
     }
 
     /** Test method for
-     * {@link fr.bigeon.gclc.prompt.CLIPrompter#promptChoice(fr.bigeon.gclc.manager.ConsoleManager, java.util.List, java.util.List, java.lang.String, java.lang.String)}. */
+     * {@link fr.bigeon.gclc.prompt.CLIPrompter#promptChoice(fr.bigeon.gclc.manager.ConsoleOutput, fr.bigeon.gclc.manager.ConsoleInput, List, List, String, String)}. */
     @Test
     public final void testPromptChoiceConsoleManagerListOfStringListOfUStringString() {
         try (final PipedConsoleOutput out = new PipedConsoleOutput();
@@ -416,7 +416,7 @@ public class CLIPrompterTest {
     }
 
     /** Test method for
-     * {@link fr.bigeon.gclc.prompt.CLIPrompter#promptChoice(fr.bigeon.gclc.manager.ConsoleManager, java.util.Map, java.lang.String, java.lang.String)}. */
+     * {@link fr.bigeon.gclc.prompt.CLIPrompter#promptChoice(fr.bigeon.gclc.manager.ConsoleOutput, fr.bigeon.gclc.manager.ConsoleInput, Map, String, String)}. */
     @Test
     public final void testPromptChoiceConsoleManagerMapOfUTStringString() {
         try (final PipedConsoleOutput out = new PipedConsoleOutput();
@@ -513,7 +513,7 @@ public class CLIPrompterTest {
     }
 
     /** Test method for
-     * {@link fr.bigeon.gclc.prompt.CLIPrompter#promptInteger(fr.bigeon.gclc.manager.ConsoleManager, java.lang.String)}. */
+     * {@link fr.bigeon.gclc.prompt.CLIPrompter#promptInteger(fr.bigeon.gclc.manager.ConsoleInput, String)}. */
     @Test
     public final void testPromptInteger() {
         try (PipedOutputStream pout = new PipedOutputStream();
@@ -557,7 +557,7 @@ public class CLIPrompterTest {
     }
 
     /** Test method for
-     * {@link fr.bigeon.gclc.prompt.CLIPrompter#promptList(fr.bigeon.gclc.manager.ConsoleManager, java.lang.String)}. */
+     * {@link fr.bigeon.gclc.prompt.CLIPrompter#promptList(fr.bigeon.gclc.manager.ConsoleOutput, fr.bigeon.gclc.manager.ConsoleInput, String)}. */
     @Test
     public final void testPromptListConsoleManagerString() {
         try (final PipedConsoleOutput out = new PipedConsoleOutput();
@@ -621,7 +621,7 @@ public class CLIPrompterTest {
     }
 
     /** Test method for
-     * {@link fr.bigeon.gclc.prompt.CLIPrompter#promptList(fr.bigeon.gclc.manager.ConsoleManager, java.lang.String, java.lang.String)}. */
+     * {@link fr.bigeon.gclc.prompt.CLIPrompter#promptList(fr.bigeon.gclc.manager.ConsoleOutput, fr.bigeon.gclc.manager.ConsoleInput, String, String)}. */
     @Test
     public final void testPromptListConsoleManagerStringString() {
         try (final PipedConsoleOutput out = new PipedConsoleOutput();
@@ -683,7 +683,7 @@ public class CLIPrompterTest {
     }
 
     /** Test method for
-     * {@link fr.bigeon.gclc.prompt.CLIPrompter#promptLongText(fr.bigeon.gclc.manager.ConsoleManager, java.lang.String)}. */
+     * {@link fr.bigeon.gclc.prompt.CLIPrompter#promptLongText(fr.bigeon.gclc.manager.ConsoleOutput, fr.bigeon.gclc.manager.ConsoleInput, String)}. */
     @Test
     public final void testPromptLongTextConsoleManagerString() {
         try (final PipedConsoleOutput out = new PipedConsoleOutput();
@@ -751,7 +751,7 @@ public class CLIPrompterTest {
     }
 
     /** Test method for
-     * {@link fr.bigeon.gclc.prompt.CLIPrompter#promptLongText(fr.bigeon.gclc.manager.ConsoleManager, java.lang.String, java.lang.String)}. */
+     * {@link fr.bigeon.gclc.prompt.CLIPrompter#promptLongText(fr.bigeon.gclc.manager.ConsoleOutput, fr.bigeon.gclc.manager.ConsoleInput, String, String)}. */
     @Test
     public final void testPromptLongTextConsoleManagerStringString() {
         try (final PipedConsoleOutput out = new PipedConsoleOutput();
@@ -815,7 +815,7 @@ public class CLIPrompterTest {
     }
 
     /** Test method for
-     * {@link fr.bigeon.gclc.prompt.CLIPrompter#promptMultiChoice(fr.bigeon.gclc.manager.ConsoleManager, java.util.List, java.util.List, java.lang.String)}. */
+     * {@link fr.bigeon.gclc.prompt.CLIPrompter#promptMultiChoice(fr.bigeon.gclc.manager.ConsoleOutput, fr.bigeon.gclc.manager.ConsoleInput, List, List, String)}. */
     @Test
     public final void testPromptMultiChoiceConsoleManagerListOfStringListOfUString() {
         try (final PipedConsoleOutput out = new PipedConsoleOutput();
@@ -907,7 +907,7 @@ public class CLIPrompterTest {
     }
 
     /** Test method for
-     * {@link fr.bigeon.gclc.prompt.CLIPrompter#promptMultiChoice(fr.bigeon.gclc.manager.ConsoleManager, java.util.List, java.util.Map, java.lang.String)}. */
+     * {@link fr.bigeon.gclc.prompt.CLIPrompter#promptMultiChoice(fr.bigeon.gclc.manager.ConsoleOutput, fr.bigeon.gclc.manager.ConsoleInput, List, Map, String)}. */
     @Test
     public final void testPromptMultiChoiceConsoleManagerListOfUMapOfUTString() {
         try (final PipedConsoleOutput out = new PipedConsoleOutput();
@@ -999,7 +999,7 @@ public class CLIPrompterTest {
     }
 
     /** Test method for
-     * {@link fr.bigeon.gclc.prompt.CLIPrompter#promptMultiChoice(fr.bigeon.gclc.manager.ConsoleManager, java.util.List, java.lang.String)}. */
+     * {@link fr.bigeon.gclc.prompt.CLIPrompter#promptMultiChoice(fr.bigeon.gclc.manager.ConsoleOutput, fr.bigeon.gclc.manager.ConsoleInput, List, String)}. */
     @Test
     public final void testPromptMultiChoiceConsoleManagerListOfUString() {
         try (final PipedConsoleOutput out = new PipedConsoleOutput();
@@ -1088,7 +1088,7 @@ public class CLIPrompterTest {
     }
 
     /** Test method for
-     * {@link fr.bigeon.gclc.prompt.CLIPrompter#promptMultiChoice(fr.bigeon.gclc.manager.ConsoleManager, java.util.Map, java.lang.String)}. */
+     * {@link fr.bigeon.gclc.prompt.CLIPrompter#promptMultiChoice(fr.bigeon.gclc.manager.ConsoleOutput, fr.bigeon.gclc.manager.ConsoleInput, Map, String)}. */
     @Test
     public final void testPromptMultiChoiceConsoleManagerMapOfUTString() {
         try (final PipedConsoleOutput out = new PipedConsoleOutput();
@@ -1172,7 +1172,7 @@ public class CLIPrompterTest {
     }
 
     /** Test method for
-     * {@link fr.bigeon.gclc.prompt.CLIPrompter#promptNonEmpty(fr.bigeon.gclc.manager.ConsoleManager, java.lang.String, java.lang.String)}. */
+     * {@link fr.bigeon.gclc.prompt.CLIPrompter#promptNonEmpty(fr.bigeon.gclc.manager.ConsoleInput, String, String)}. */
     @Test
     public final void testPromptNonEmpty() {
         try (PipedOutputStream pout = new PipedOutputStream();

gclc/src/test/java/fr/bigeon/gclc/tools/AOutputForwardRunnableTest.java

@@ -61,7 +61,6 @@ public class AOutputForwardRunnableTest {
         private int count = 2;
         private String message;
 
-        /** @param manager */
         private AOutputForwardTestRunnable(final PipedConsoleOutput manager) {
             super(manager);
         }