ReplaceOutputStream replace = new ReplaceOutputStream(out, //
new String[] { "\\", "\n" }, //
new String[] { "\\\\", "\\n" });
+
try {
SerialUtils.write(replace, "custom^");
SerialUtils.write(replace, getType());
if (in == null) {
throw new NullPointerException("InputStream is null");
}
- if (stream.eof()) {
- throw new NullPointerException("InputStream is empty");
- }
+ boolean first = true;
while (stream.next()) {
+ if (stream.eof()) {
+ if (first) {
+ throw new NullPointerException(
+ "InputStream empty, normal termination");
+ }
+ return this;
+ }
+ first = false;
+
boolean zip = stream.startsWiths("ZIP:");
boolean b64 = stream.startsWiths("B64:");
// TODO use the stream, Luke
String line = IOUtils.readSmallStream(in);
+ if (line.isEmpty()) {
+ return false;
+ }
+
if (line.equals("{")) { // START: new child if needed
if (link != null) {
child = new Importer(map);
} else {
if (line.endsWith(":")) {
// construct
- me = SerialUtils.createObject(type);
+ try {
+ me = SerialUtils.createObject(type);
+ } catch (NoSuchMethodException e) {
+ System.out.println("LINE: <" + line + ">");
+ throw e;
+ }
} else {
// direct value
int pos = line.indexOf(":");
type = type.substring(0, type.length() - 2); // remove the []
write(out, type);
- write(out, "\r");
try {
for (int i = 0; true; i++) {
Object item = Array.get(value, i);
+
// encode it normally if direct value
+ write(out, "\r");
if (!SerialUtils.encode(out, item)) {
try {
// TODO: bad escaping?
.getMessage());
}
}
- write(out, "\r");
}
} catch (ArrayIndexOutOfBoundsException e) {
// Done.
// setAccessible)
}
}
- write(out, "\n}");
}
/**
package be.nikiroo.utils.serial.server;
-import java.io.BufferedReader;
import java.io.IOException;
-import java.io.InputStream;
-import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.Socket;
import javax.net.ssl.SSLException;
import be.nikiroo.utils.CryptUtils;
-import be.nikiroo.utils.Version;
+import be.nikiroo.utils.IOUtils;
import be.nikiroo.utils.serial.Exporter;
import be.nikiroo.utils.serial.Importer;
+import be.nikiroo.utils.streams.NextableInputStream;
+import be.nikiroo.utils.streams.NextableInputStreamStep;
/**
* Base class used for the client/server basic handling.
abstract class ConnectAction {
private Socket s;
private boolean server;
- private Version version;
- private Version clientVersion;
private CryptUtils crypt;
private Object lock = new Object();
- private InputStream in;
+ private NextableInputStream in;
private OutputStream out;
private boolean contentToSend;
* Method that will be called when an action is performed on either the
* client or server this {@link ConnectAction} represent.
*
- * @param version
- * the counter part version
- *
* @throws Exception
* in case of I/O error
*/
- abstract protected void action(Version version) throws Exception;
-
- /**
- * Method called when we negotiate the version with the client.
- * <p>
- * Thus, it is only called on the server.
- * <p>
- * Will return the actual server version by default.
- *
- * @param clientVersion
- * the client version
- *
- * @return the version to send to the client
- */
- abstract protected Version negotiateVersion(Version clientVersion);
+ abstract protected void action() throws Exception;
/**
* Handler called when an unexpected error occurs in the code.
* @param key
* an optional key to encrypt all the communications (if NULL,
* everything will be sent in clear text)
- * @param version
- * the version of this client-or-server
*/
- protected ConnectAction(Socket s, boolean server, String key,
- Version version) {
+ protected ConnectAction(Socket s, boolean server, String key) {
this.s = s;
this.server = server;
if (key != null) {
crypt = new CryptUtils(key);
}
-
- if (version == null) {
- this.version = new Version();
- } else {
- this.version = version;
- }
-
- clientVersion = new Version();
- }
-
- /**
- * The version of this client-or-server.
- *
- * @return the version
- */
- public Version getVersion() {
- return version;
}
/**
*/
public void connect() {
try {
- in = s.getInputStream();
+ in = new NextableInputStream(s.getInputStream(),
+ new NextableInputStreamStep('\b'));
+
try {
out = s.getOutputStream();
try {
- if (server) {
- String line;
- try {
- line = readLine(in);
- } catch (SSLException e) {
- out.write("Unauthorized\n".getBytes());
- throw e;
- }
-
- if (line != null && line.startsWith("VERSION ")) {
- // "VERSION client-version" (VERSION 1.0.0)
- Version clientVersion = new Version(
- line.substring("VERSION ".length()));
- this.clientVersion = clientVersion;
- Version v = negotiateVersion(clientVersion);
- if (v == null) {
- v = new Version();
- }
-
- sendString("VERSION " + v.toString());
- }
-
- action(clientVersion);
- } else {
- String v = sendString("VERSION " + version.toString());
- if (v != null && v.startsWith("VERSION ")) {
- v = v.substring("VERSION ".length());
- }
-
- action(new Version(v));
- }
+ action();
} finally {
out.close();
out = null;
synchronized (lock) {
new Exporter(out).append(data);
+ out.write('\b');
if (server) {
out.flush();
out.flush();
contentToSend = false;
}
-
- return new Importer().read(in).getValue();
+
+ if (in.next()) {
+ return new Importer().read(in).getValue();
+ }
+
+ throw new NullPointerException();
}
return null;
* @throws SSLException
* in case of crypt error
*/
- private String readLine(InputStream in) throws IOException {
- if (inReader == null) {
- inReader = new BufferedReader(new InputStreamReader(in));
+ private String readLine(NextableInputStream in) throws IOException {
+ String line = null;
+ if (in.next()) {
+ line = IOUtils.readSmallStream(in);
}
- String line = inReader.readLine();
+
if (line != null) {
bytesReceived += line.length();
if (crypt != null) {
return line;
}
- private BufferedReader inReader;
-
/**
* Write a line, possible encrypted.
*
out.write(b64.getBytes("UTF-8"));
bytesSent += b64.length();
}
- out.write("\n".getBytes("UTF-8"));
+ out.write('\b');
bytesSent++;
}
}
\ No newline at end of file
import java.net.Socket;
import java.net.UnknownHostException;
-import be.nikiroo.utils.Version;
-
/**
* Base class used for the client basic handling.
* <p>
protected ConnectAction action;
/**
- * Create a new {@link ConnectActionClient} with the current application
- * version (see {@link Version#getCurrentVersion()}) as the client version.
- *
- * @param s
- * the socket to bind to
- * @param key
- * an optional key to encrypt all the communications (if NULL,
- * everything will be sent in clear text)
- */
- public ConnectActionClient(Socket s, String key) {
- this(s, key, Version.getCurrentVersion());
- }
-
- /**
- * Create a new {@link ConnectActionClient} with the current application
- * version (see {@link Version#getCurrentVersion()}) as the client version.
+ * Create a new {@link ConnectActionClient}.
*
* @param host
* the host to bind to
*/
public ConnectActionClient(String host, int port, String key)
throws IOException {
- this(new Socket(host, port), key, Version.getCurrentVersion());
- }
-
- /**
- * Create a new {@link ConnectActionClient}.
- *
- * @param host
- * the host to bind to
- * @param port
- * the port to bind to
- * @param key
- * an optional key to encrypt all the communications (if NULL,
- * everything will be sent in clear text)
- * @param version
- * the client version
- *
- * @throws IOException
- * in case of I/O error
- * @throws UnknownHostException
- * if the host is not known
- * @throws IllegalArgumentException
- * if the port parameter is outside the specified range of valid
- * port values, which is between 0 and 65535, inclusive
- */
- public ConnectActionClient(String host, int port, String key,
- Version version) throws IOException {
- this(new Socket(host, port), key, version);
+ this(new Socket(host, port), key);
}
/**
* @param key
* an optional key to encrypt all the communications (if NULL,
* everything will be sent in clear text)
- * @param version
- * the client version
*/
- public ConnectActionClient(Socket s, String key, Version version) {
- action = new ConnectAction(s, false, key, version) {
+ public ConnectActionClient(Socket s, String key) {
+ action = new ConnectAction(s, false, key) {
@Override
- protected void action(Version serverVersion) throws Exception {
- ConnectActionClient.this.action(serverVersion);
+ protected void action() throws Exception {
+ ConnectActionClient.this.action();
}
@Override
protected void onError(Exception e) {
ConnectActionClient.this.onError(e);
}
-
- @Override
- protected Version negotiateVersion(Version clientVersion) {
- new Exception("Should never be called on a client")
- .printStackTrace();
- return null;
- }
};
}
/**
* Method that will be called when an action is performed on the client.
*
- * @param serverVersion
- * the server version
- *
* @throws Exception
* in case of I/O error
*/
@SuppressWarnings("unused")
- public void action(Version serverVersion) throws Exception {
+ public void action() throws Exception {
}
/**
super(host, port, key);
}
- /**
- * Create a new {@link ConnectActionClientObject}.
- *
- * @param host
- * the host to bind to
- * @param port
- * the port to bind to
- * @param key
- * an optional key to encrypt all the communications (if NULL,
- * everything will be sent in clear text)
- * @param version
- * the client version
- *
- * @throws IOException
- * in case of I/O error
- * @throws UnknownHostException
- * if the IP address of the host could not be determined
- * @throws IllegalArgumentException
- * if the port parameter is outside the specified range of valid
- * port values, which is between 0 and 65535, inclusive
- */
- public ConnectActionClientObject(String host, int port, String key,
- Version version) throws IOException {
- super(host, port, key, version);
- }
-
- /**
- * Create a new {@link ConnectActionClientObject}.
- *
- * @param s
- * the socket to bind to
- * @param version
- * the client version
- * @param key
- * an optional key to encrypt all the communications (if NULL,
- * everything will be sent in clear text)
- */
- public ConnectActionClientObject(Socket s, String key, Version version) {
- super(s, key, version);
- }
-
/**
* Serialise and send the given object to the server (and return the
* deserialised answer).
super(host, port, key);
}
- /**
- * Create a new {@link ConnectActionClientString}.
- *
- * @param host
- * the host to bind to
- * @param port
- * the port to bind to
- * @param key
- * an optional key to encrypt all the communications (if NULL,
- * everything will be sent in clear text)
- * @param version
- * the client version
- *
- * @throws IOException
- * in case of I/O error
- * @throws UnknownHostException
- * if the IP address of the host could not be determined
- * @throws IllegalArgumentException
- * if the port parameter is outside the specified range of valid
- * port values, which is between 0 and 65535, inclusive
- */
- public ConnectActionClientString(String host, int port, String key,
- Version version) throws IOException {
- super(host, port, key, version);
- }
-
- /**
- * Create a new {@link ConnectActionClientString}.
- *
- * @param s
- * the socket to bind to
- * @param key
- * an optional key to encrypt all the communications (if NULL,
- * everything will be sent in clear text)
- * @param version
- * the client version
- */
- public ConnectActionClientString(Socket s, String key, Version version) {
- super(s, key, version);
- }
-
/**
* Send the given object to the server (and return the answer).
*
import java.net.Socket;
-import be.nikiroo.utils.Version;
-
/**
* Base class used for the server basic handling.
* <p>
*/
protected ConnectAction action;
- /**
- * Create a new {@link ConnectActionServer} with the current application
- * version (see {@link Version#getCurrentVersion()}) as the server version.
- *
- * @param s
- * the socket to bind to
- * @param key
- * an optional key to encrypt all the communications (if NULL,
- * everything will be sent in clear text)
- */
- public ConnectActionServer(Socket s, String key) {
- this(s, key, Version.getCurrentVersion());
- }
-
/**
* Create a new {@link ConnectActionServer}.
*
* @param key
* an optional key to encrypt all the communications (if NULL,
* everything will be sent in clear text)
- * @param version
- * the server version
*/
- public ConnectActionServer(Socket s, String key, Version version) {
- action = new ConnectAction(s, true, key, version) {
+ public ConnectActionServer(Socket s, String key) {
+ action = new ConnectAction(s, true, key) {
@Override
- protected void action(Version clientVersion) throws Exception {
- ConnectActionServer.this.action(clientVersion);
+ protected void action() throws Exception {
+ ConnectActionServer.this.action();
}
@Override
protected void onError(Exception e) {
ConnectActionServer.this.onError(e);
}
-
- @Override
- protected Version negotiateVersion(Version clientVersion) {
- return ConnectActionServer.this.negotiateVersion(clientVersion);
- }
};
}
/**
* Method that will be called when an action is performed on the server.
*
- * @param clientVersion
- * the client version
- *
* @throws Exception
* in case of I/O error
*/
@SuppressWarnings("unused")
- public void action(Version clientVersion) throws Exception {
+ public void action() throws Exception {
}
/**
*/
protected void onError(@SuppressWarnings("unused") Exception e) {
}
-
- /**
- * Method called when we negotiate the version with the client.
- * <p>
- * Will return the actual server version by default.
- *
- * @param clientVersion
- * the client version
- *
- * @return the version to send to the client
- */
- protected Version negotiateVersion(
- @SuppressWarnings("unused") Version clientVersion) {
- return action.getVersion();
- }
}
\ No newline at end of file
super(s, key);
}
- /**
- * Create a new {@link ConnectActionServerObject}.
- *
- * @param s
- * the socket to bind to
- * @param key
- * an optional key to encrypt all the communications (if NULL,
- * everything will be sent in clear text)
- * @param version
- * the server version
- */
- public ConnectActionServerObject(Socket s, String key, Version version) {
- super(s, key, version);
- }
-
/**
* Serialise and send the given object to the client.
*
super(s, key);
}
- /**
- * Create a new {@link ConnectActionServerString}.
- *
- * @param s
- * the socket to bind to
- * @param key
- * an optional key to encrypt all the communications (if NULL,
- * everything will be sent in clear text)
- * @param version
- * the server version
- */
- public ConnectActionServerString(Socket s, String key, Version version) {
- super(s, key, version);
- }
-
/**
* Serialise and send the given object to the client.
*
import be.nikiroo.utils.StringUtils;
import be.nikiroo.utils.TraceHandler;
-import be.nikiroo.utils.Version;
import be.nikiroo.utils.serial.Importer;
/**
// Bad impl, not up to date (should work, but not efficient)
return new ConnectActionServerString(s, key) {
@Override
- public void action(final Version clientVersion) throws Exception {
- onClientContact(clientVersion);
+ public void action() throws Exception {
+ onClientContact();
final ConnectActionServerString bridge = this;
try {
new ConnectActionClientString(forwardToHost, forwardToPort,
- forwardToKey, clientVersion) {
+ forwardToKey) {
@Override
- public void action(final Version serverVersion)
- throws Exception {
- onServerContact(serverVersion);
+ public void action() throws Exception {
+ onServerContact();
for (String fromClient = bridge.rec(); fromClient != null; fromClient = bridge
.rec()) {
- onRec(clientVersion, fromClient);
+ onRec(fromClient);
String fromServer = send(fromClient);
- onSend(serverVersion, fromServer);
+ onSend(fromServer);
bridge.send(fromServer);
}
/**
* This is the method that is called each time a client contact us.
- *
- * @param clientVersion
- * the client version
*/
- protected void onClientContact(Version clientVersion) {
- getTraceHandler().trace(">>> CLIENT " + clientVersion);
+ protected void onClientContact() {
+ getTraceHandler().trace(">>> CLIENT ");
}
/**
* This is the method that is called each time a client contact us.
- *
- * @param serverVersion
- * the server version
*/
- protected void onServerContact(Version serverVersion) {
- getTraceHandler().trace("<<< SERVER " + serverVersion);
+ protected void onServerContact() {
+ getTraceHandler().trace("<<< SERVER");
getTraceHandler().trace("");
}
/**
* This is the method that is called each time a client contact us.
*
- * @param clientVersion
- * the client version
* @param data
* the data sent by the client
*/
- protected void onRec(Version clientVersion, String data) {
- trace(">>> CLIENT (" + clientVersion + ")", data);
+ protected void onRec(String data) {
+ trace(">>> CLIENT", data);
}
/**
* This is the method that is called each time the forwarded server contact
* us.
*
- * @param serverVersion
- * the client version
* @param data
* the data sent by the client
*/
- protected void onSend(Version serverVersion, String data) {
- trace("<<< SERVER (" + serverVersion + ")", data);
+ protected void onSend(String data) {
+ trace("<<< SERVER", data);
}
@Override
import java.net.Socket;
import java.net.UnknownHostException;
-import be.nikiroo.utils.Version;
-
/**
* This class implements a simple server that can listen for connections and
* send/receive objects.
protected ConnectActionServer createConnectActionServer(Socket s) {
return new ConnectActionServerObject(s, key) {
@Override
- public void action(Version clientVersion) throws Exception {
+ public void action() throws Exception {
try {
for (Object data = rec(); true; data = rec()) {
Object rep = null;
try {
- rep = onRequest(this, clientVersion, data);
+ rep = onRequest(this, data);
if (isClosing()) {
return;
}
*
* @param action
* the client action
- * @param clientVersion
- * the client version
* @param data
* the data sent by the client (which can be NULL)
*
* in case of an exception, the error will only be logged
*/
abstract protected Object onRequest(ConnectActionServerObject action,
- Version clientVersion, Object data) throws Exception;
+ Object data) throws Exception;
}
import java.net.Socket;
import java.net.UnknownHostException;
-import be.nikiroo.utils.Version;
-
/**
* This class implements a simple server that can listen for connections and
* send/receive Strings.
protected ConnectActionServer createConnectActionServer(Socket s) {
return new ConnectActionServerString(s, key) {
@Override
- public void action(Version clientVersion) throws Exception {
+ public void action() throws Exception {
for (String data = rec(); data != null; data = rec()) {
String rep = null;
try {
- rep = onRequest(this, clientVersion, data);
+ rep = onRequest(this, data);
if (isClosing()) {
return;
}
*
* @param action
* the client action
- * @param clientVersion
- * the client version
* @param data
* the data sent by the client
*
* in case of an exception, the error will only be logged
*/
abstract protected String onRequest(ConnectActionServerString action,
- Version clientVersion, String data) throws Exception;
+ String data) throws Exception;
}
import java.net.URL;
-import be.nikiroo.utils.Version;
import be.nikiroo.utils.serial.server.ConnectActionClientObject;
import be.nikiroo.utils.serial.server.ConnectActionClientString;
import be.nikiroo.utils.serial.server.ConnectActionServerObject;
public SerialServerTest(String[] args) {
super("SerialServer test", args);
- for (String key : new String[] { null, "",
- "some real key with a few bytes in it" }) {
- for (boolean bridge : new Boolean[] { false, true }) {
+ for (String key : new String[] { null,
+ "some super secret encryption key" }) {
+ // TODO: re-add bridge
+ for (boolean bridge : new Boolean[] { false }) {
final String skey = (key != null ? "(encrypted)"
: "(plain text)");
final String sbridge = (bridge ? " with bridge" : "");
addSeries(new SerialServerTest(args, key, skey, bridge,
sbridge, "ServerString"));
- addSeries(new SerialServerTest(args, key, skey, bridge,
- sbridge, new Object() {
- @Override
- public String toString() {
- return "ServerObject";
- }
- }));
+ // addSeries(new SerialServerTest(args, key, skey, bridge,
+ // sbridge, new Object() {
+ // @Override
+ // public String toString() {
+ // return "ServerObject";
+ // }
+ // }));
}
}
}
ServerString server = new ServerString(this.getName(), 0, key) {
@Override
protected String onRequest(
- ConnectActionServerString action,
- Version clientVersion, String data)
+ ConnectActionServerString action, String data)
throws Exception {
return null;
}
try {
new ConnectActionClientObject(null, port, key) {
@Override
- public void action(Version serverVersion)
- throws Exception {
+ public void action() throws Exception {
rec[0] = "ok";
}
}.connect();
ServerString server = new ServerString(this.getName(), 0, key) {
@Override
protected String onRequest(
- ConnectActionServerString action,
- Version clientVersion, String data)
+ ConnectActionServerString action, String data)
throws Exception {
sent[0] = data;
return "pong";
try {
new ConnectActionClientString(null, port, key) {
@Override
- public void action(Version serverVersion)
- throws Exception {
+ public void action() throws Exception {
recd[0] = send("ping");
}
}.connect();
}
if (err[0] != null) {
- fail("An exception was thrown: " + err[0].getMessage());
+ fail("An exception was thrown: " + err[0].getMessage(),
+ err[0]);
}
assertEquals("ping", sent[0]);
ServerString server = new ServerString(this.getName(), 0, key) {
@Override
protected String onRequest(
- ConnectActionServerString action,
- Version clientVersion, String data)
+ ConnectActionServerString action, String data)
throws Exception {
sent[0] = data;
action.send("pong");
try {
new ConnectActionClientString(null, port, key) {
@Override
- public void action(Version serverVersion)
- throws Exception {
+ public void action() throws Exception {
recd[0] = send("ping");
recd[1] = send("ping2");
}
}
if (err[0] != null) {
- fail("An exception was thrown: " + err[0].getMessage());
+ fail("An exception was thrown: " + err[0].getMessage(),
+ err[0]);
}
assertEquals("ping", sent[0]);
ServerString server = new ServerString(this.getName(), 0, key) {
@Override
protected String onRequest(
- ConnectActionServerString action,
- Version clientVersion, String data)
+ ConnectActionServerString action, String data)
throws Exception {
sent[Integer.parseInt(data)] = data;
return "" + (Integer.parseInt(data) * 2);
try {
new ConnectActionClientString(null, port, key) {
@Override
- public void action(Version serverVersion)
- throws Exception {
+ public void action() throws Exception {
for (int i = 0; i < 3; i++) {
recd[i] = send("" + i);
}
}
if (err[0] != null) {
- fail("An exception was thrown: " + err[0].getMessage());
+ fail("An exception was thrown: " + err[0].getMessage(),
+ err[0]);
}
assertEquals("0", sent[0]);
ServerObject server = new ServerObject(this.getName(), 0, key) {
@Override
protected Object onRequest(
- ConnectActionServerObject action,
- Version clientVersion, Object data)
+ ConnectActionServerObject action, Object data)
throws Exception {
return null;
}
try {
new ConnectActionClientObject(null, port, key) {
@Override
- public void action(Version serverVersion)
- throws Exception {
+ public void action() throws Exception {
rec[0] = true;
}
ServerObject server = new ServerObject(this.getName(), 0, key) {
@Override
protected Object onRequest(
- ConnectActionServerObject action,
- Version clientVersion, Object data)
+ ConnectActionServerObject action, Object data)
throws Exception {
sent[0] = data;
return "pong";
try {
new ConnectActionClientObject(null, port, key) {
@Override
- public void action(Version serverVersion)
- throws Exception {
+ public void action() throws Exception {
recd[0] = send("ping");
}
}.connect();
}
if (err[0] != null) {
- fail("An exception was thrown: " + err[0].getMessage());
+ fail("An exception was thrown: " + err[0].getMessage(),
+ err[0]);
}
assertEquals("ping", sent[0]);
ServerObject server = new ServerObject(this.getName(), 0, key) {
@Override
protected Object onRequest(
- ConnectActionServerObject action,
- Version clientVersion, Object data)
+ ConnectActionServerObject action, Object data)
throws Exception {
sent[0] = data;
action.send("pong");
try {
new ConnectActionClientObject(null, port, key) {
@Override
- public void action(Version serverVersion)
- throws Exception {
+ public void action() throws Exception {
recd[0] = send("ping");
recd[1] = send("ping2");
}
}
if (err[0] != null) {
- fail("An exception was thrown: " + err[0].getMessage());
+ fail("An exception was thrown: " + err[0].getMessage(),
+ err[0]);
}
assertEquals("ping", sent[0]);
ServerObject server = new ServerObject(this.getName(), 0, key) {
@Override
protected Object onRequest(
- ConnectActionServerObject action,
- Version clientVersion, Object data)
+ ConnectActionServerObject action, Object data)
throws Exception {
sent[0] = data;
return new Object[] { "ACK" };
try {
new ConnectActionClientObject(null, port, key) {
@Override
- public void action(Version serverVersion)
- throws Exception {
+ public void action() throws Exception {
recd[0] = send(new Object[] {
"key",
new URL(
}
if (err[0] != null) {
- fail("An exception was thrown: " + err[0].getMessage());
+ fail("An exception was thrown: " + err[0].getMessage(),
+ err[0]);
}
Object[] sento = (Object[]) (sent[0]);
ServerObject server = new ServerObject(this.getName(), 0, key) {
@Override
protected Object onRequest(
- ConnectActionServerObject action,
- Version clientVersion, Object data)
+ ConnectActionServerObject action, Object data)
throws Exception {
sent[(Integer) data] = data;
return ((Integer) data) * 2;
try {
new ConnectActionClientObject(null, port, key) {
@Override
- public void action(Version serverVersion)
- throws Exception {
+ public void action() throws Exception {
for (int i = 0; i < 3; i++) {
recd[i] = send(i);
}
}
if (err[0] != null) {
- fail("An exception was thrown: " + err[0].getMessage());
+ fail("An exception was thrown: " + err[0].getMessage(),
+ err[0]);
}
assertEquals(0, sent[0]);
git://git.nikiroo.be / nikiroo-utils.git / commitdiff