move package name

src/test/java/io/socket/emitter/EmitterTest.java

@@ -0,0 +1,228 @@
+package io.socket.emitter;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+
+@RunWith(JUnit4.class)
+public class EmitterTest {
+
+    @Test
+    public void on() {
+        Emitter emitter = new Emitter();
+        final List<Object> calls = new ArrayList<Object>();
+
+        emitter.on("foo", new Emitter.Listener() {
+            @Override
+            public void call(Object... args) {
+                calls.add("one");
+                calls.add(args[0]);
+            }
+        });
+
+        emitter.on("foo", new Emitter.Listener() {
+            @Override
+            public void call(Object... args) {
+                calls.add("two");
+                calls.add(args[0]);
+            }
+        });
+
+        emitter.emit("foo", 1);
+        emitter.emit("bar", 1);
+        emitter.emit("foo", 2);
+
+        assertThat(calls.toArray(), is(new Object[] {"one", 1, "two", 1, "one", 2, "two", 2}));
+    }
+
+    @Test
+    public void once() {
+        Emitter emitter = new Emitter();
+        final List<Object> calls = new ArrayList<Object>();
+
+        emitter.once("foo", new Emitter.Listener() {
+            @Override
+            public void call(Object... args) {
+                calls.add("one");
+                calls.add(args[0]);
+            }
+        });
+
+        emitter.emit("foo", 1);
+        emitter.emit("foo", 2);
+        emitter.emit("foo", 3);
+        emitter.emit("bar", 1);
+
+        assertThat(calls.toArray(), is(new Object[] {"one", 1}));
+    }
+
+    @Test
+    public void off() {
+        Emitter emitter = new Emitter();
+        final List<Object> calls = new ArrayList<Object>();
+
+        Emitter.Listener one = new Emitter.Listener() {
+            @Override
+            public void call(Object... args) {
+                calls.add("one");
+            }
+        };
+        Emitter.Listener two = new Emitter.Listener() {
+            @Override
+            public void call(Object... args) {
+                calls.add("two");
+            }
+        };
+
+        emitter.on("foo", one);
+        emitter.on("foo", two);
+        emitter.off("foo", two);
+
+        emitter.emit("foo");
+
+        assertThat(calls.toArray(), is(new Object[] {"one"}));
+    }
+
+    @Test
+    public void offWithOnce() {
+        Emitter emitter = new Emitter();
+        final List<Object> calls = new ArrayList<Object>();
+
+        Emitter.Listener one = new Emitter.Listener() {
+            @Override
+            public void call(Object... args) {
+                calls.add("one");
+            }
+        };
+
+        emitter.once("foo", one);
+        emitter.off("foo", one);
+
+        emitter.emit("foo");
+
+        assertThat(calls.toArray(), is(new Object[] {}));
+    }
+
+    @Test
+    public void offWhenCalledfromEvent() {
+        final Emitter emitter = new Emitter();
+        final boolean[] called = new boolean[] {false};
+        final Emitter.Listener b = new Emitter.Listener() {
+            @Override
+            public void call(Object... args) {
+                called[0] = true;
+            }
+        };
+        emitter.on("tobi", new Emitter.Listener() {
+            @Override
+            public void call(Object... args) {
+                emitter.off("tobi", b);
+            }
+        });
+        emitter.once("tobi", b);
+        emitter.emit("tobi");
+        assertThat(called[0], is(true));
+        called[0] = false;
+        emitter.emit("tobi");
+        assertThat(called[0], is(false));
+    }
+
+    @Test
+    public void offEvent() {
+        Emitter emitter = new Emitter();
+        final List<Object> calls = new ArrayList<Object>();
+
+        Emitter.Listener one = new Emitter.Listener() {
+            @Override
+            public void call(Object... args) {
+                calls.add("one");
+            }
+        };
+        Emitter.Listener two = new Emitter.Listener() {
+            @Override
+            public void call(Object... args) {
+                calls.add("two");
+            }
+        };
+
+        emitter.on("foo", one);
+        emitter.on("foo", two);
+        emitter.off("foo");
+
+        emitter.emit("foo");
+        emitter.emit("foo");
+
+        assertThat(calls.toArray(), is(new Object[] {}));
+    }
+
+    @Test
+    public void offAll() {
+        Emitter emitter = new Emitter();
+        final List<Object> calls = new ArrayList<Object>();
+
+        Emitter.Listener one = new Emitter.Listener() {
+            @Override
+            public void call(Object... args) {
+                calls.add("one");
+            }
+        };
+        Emitter.Listener two = new Emitter.Listener() {
+            @Override
+            public void call(Object... args) {
+                calls.add("two");
+            }
+        };
+
+        emitter.on("foo", one);
+        emitter.on("bar", two);
+
+        emitter.emit("foo");
+        emitter.emit("bar");
+
+        emitter.off();
+
+        emitter.emit("foo");
+        emitter.emit("bar");
+
+        assertThat(calls.toArray(), is(new Object[]{"one", "two"}));
+    }
+
+    @Test
+    public void listeners() {
+        Emitter emitter = new Emitter();
+        Emitter.Listener foo = new Emitter.Listener() {
+            @Override
+            public void call(Object... args) {}
+        };
+        emitter.on("foo", foo);
+        assertThat(emitter.listeners("foo").toArray(), is(new Object[] {foo}));
+    }
+
+    @Test
+    public void listenersWithoutHandlers() {
+        Emitter emitter = new Emitter();
+        assertThat(emitter.listeners("foo").toArray(), is(new Object[] {}));
+    }
+
+    @Test
+    public void hasListeners() {
+        Emitter emitter = new Emitter();
+        emitter.on("foo", new Emitter.Listener() {
+            @Override
+            public void call(Object... args) {}
+        });
+        assertThat(emitter.hasListeners("foo"), is(true));
+    }
+
+    @Test
+    public void hasListenersWithoutHandlers() {
+        Emitter emitter = new Emitter();
+        assertThat(emitter.hasListeners("foo"), is(false));
+    }
+}

src/test/java/io/socket/engineio/client/BinaryPollingTest.java

@@ -0,0 +1,89 @@
+package io.socket.engineio.client;
+
+import io.socket.emitter.Emitter;
+import io.socket.engineio.client.transports.Polling;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.LinkedBlockingQueue;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+
+@RunWith(JUnit4.class)
+public class BinaryPollingTest extends Connection {
+
+    private Socket socket;
+
+    @Test(timeout = TIMEOUT)
+    public void receiveBinaryData() throws InterruptedException {
+        final BlockingQueue<Object> values = new LinkedBlockingQueue<Object>();
+
+        final byte[] binaryData = new byte[5];
+        for (int i = 0; i < binaryData.length; i++) {
+            binaryData[i] = (byte)i;
+        }
+        Socket.Options opts = new Socket.Options();
+        opts.port = PORT;
+        opts.transports = new String[] {Polling.NAME};
+
+        socket = new Socket(opts);
+        socket.on(Socket.EVENT_OPEN, new Emitter.Listener() {
+            @Override
+            public void call(Object... args) {
+                socket.send(binaryData);
+                socket.on(Socket.EVENT_MESSAGE, new Emitter.Listener() {
+                    @Override
+                    public void call(Object... args) {
+                        if ("hi".equals(args[0])) return;
+
+                        values.offer(args[0]);
+                    }
+                });
+            }
+        });
+        socket.open();
+
+        assertThat((byte[])values.take(), is(binaryData));
+        socket.close();
+    }
+
+    @Test(timeout = TIMEOUT)
+    public void receiveBinaryDataAndMultibyteUTF8String() throws InterruptedException {
+        final BlockingQueue<Object> values = new LinkedBlockingQueue<Object>();
+
+        final byte[] binaryData = new byte[5];
+        for (int i = 0; i < binaryData.length; i++) {
+            binaryData[i] = (byte)i;
+        }
+
+        final int[] msg = new int[] {0};
+        Socket.Options opts = new Socket.Options();
+        opts.port = PORT;
+        opts.transports = new String[] {Polling.NAME};
+        socket = new Socket(opts);
+        socket.on(Socket.EVENT_OPEN, new Emitter.Listener() {
+            @Override
+            public void call(Object... args) {
+                socket.send(binaryData);
+                socket.send("cash money €€€");
+                socket.on(Socket.EVENT_MESSAGE, new Emitter.Listener() {
+                    @Override
+                    public void call(Object... args) {
+                        if ("hi".equals(args[0])) return;
+
+                        values.offer(args[0]);
+                        msg[0]++;
+                    }
+                });
+            }
+        });
+        socket.open();
+
+        assertThat((byte[])values.take(), is(binaryData));
+        assertThat((String)values.take(), is("cash money €€€"));
+        socket.close();
+    }
+}

src/test/java/io/socket/engineio/client/BinaryWSTest.java

@@ -0,0 +1,94 @@
+package io.socket.engineio.client;
+
+import io.socket.emitter.Emitter;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.LinkedBlockingQueue;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+
+@RunWith(JUnit4.class)
+public class BinaryWSTest extends Connection {
+
+    private Socket socket;
+
+    @Test(timeout = TIMEOUT)
+    public void receiveBinaryData() throws InterruptedException {
+        final BlockingQueue<Object> values = new LinkedBlockingQueue<Object>();
+
+        final byte[] binaryData = new byte[5];
+        for (int i = 0; i < binaryData.length; i++) {
+            binaryData[i] = (byte)i;
+        }
+        Socket.Options opts = new Socket.Options();
+        opts.port = PORT;
+        socket = new Socket(opts);
+        socket.on(Socket.EVENT_OPEN, new Emitter.Listener() {
+            @Override
+            public void call(Object... args) {
+                socket.on(Socket.EVENT_UPGRADE, new Emitter.Listener() {
+                    @Override
+                    public void call(Object... args) {
+                        socket.send(binaryData);
+                        socket.on(Socket.EVENT_MESSAGE, new Emitter.Listener() {
+                            @Override
+                            public void call(Object... args) {
+                                if (args[0] instanceof String) return;
+                                values.offer(args[0]);
+                            }
+                        });
+                    }
+                });
+            }
+        });
+        socket.open();
+
+        assertThat((byte[])values.take(), is(binaryData));
+        socket.close();
+    }
+
+    @Test(timeout = TIMEOUT)
+    public void receiveBinaryDataAndMultibyteUTF8String() throws InterruptedException {
+        final BlockingQueue<Object> values = new LinkedBlockingQueue<Object>();
+
+        final byte[] binaryData = new byte[5];
+        for (int i = 0; i < binaryData.length; i++) {
+            binaryData[i] = (byte)i;
+        }
+
+        final int[] msg = new int[] {0};
+        Socket.Options opts = new Socket.Options();
+        opts.port = PORT;
+        socket = new Socket(opts);
+        socket.on(Socket.EVENT_OPEN, new Emitter.Listener() {
+            @Override
+            public void call(Object... args) {
+                socket.on(Socket.EVENT_UPGRADE, new Emitter.Listener() {
+                    @Override
+                    public void call(Object... args) {
+                        socket.send(binaryData);
+                        socket.send("cash money €€€");
+                        socket.on(Socket.EVENT_MESSAGE, new Emitter.Listener() {
+                            @Override
+                            public void call(Object... args) {
+                                if ("hi".equals(args[0])) return;
+
+                                values.offer(args[0]);
+                                msg[0]++;
+                            }
+                        });
+                    }
+                });
+            }
+        });
+        socket.open();
+
+        assertThat((byte[])values.take(), is(binaryData));
+        assertThat((String)values.take(), is("cash money €€€"));
+        socket.close();
+    }
+}

src/test/java/io/socket/engineio/client/Connection.java

@@ -0,0 +1,97 @@
+package io.socket.engineio.client;
+
+import org.junit.After;
+import org.junit.Before;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.*;
+import java.util.logging.Logger;
+
+public abstract class Connection {
+
+    private static final Logger logger = Logger.getLogger(Socket.class.getName());
+
+    final static int TIMEOUT = 10000;
+    final static int PORT = 3000;
+
+    private Process serverProcess;
+    private ExecutorService serverService;
+    private Future serverOutout;
+    private Future serverError;
+
+    @Before
+    public void startServer() throws IOException, InterruptedException {
+        logger.fine("Starting server ...");
+
+        final CountDownLatch latch = new CountDownLatch(1);
+        serverProcess = Runtime.getRuntime().exec(
+                "node src/test/resources/server.js", createEnv());
+        serverService = Executors.newCachedThreadPool();
+        serverOutout = serverService.submit(new Runnable() {
+            @Override
+            public void run() {
+                BufferedReader reader = new BufferedReader(
+                        new InputStreamReader(serverProcess.getInputStream()));
+                String line;
+                try {
+                    line = reader.readLine();
+                    latch.countDown();
+                    do {
+                        logger.fine("SERVER OUT: " + line);
+                    } while ((line = reader.readLine()) != null);
+                } catch (IOException e) {
+                    logger.warning(e.getMessage());
+                }
+            }
+        });
+        serverError = serverService.submit(new Runnable() {
+            @Override
+            public void run() {
+                BufferedReader reader = new BufferedReader(
+                        new InputStreamReader(serverProcess.getErrorStream()));
+                String line;
+                try {
+                    while ((line = reader.readLine()) != null) {
+                        logger.fine("SERVER ERR: " + line);
+                    }
+                } catch (IOException e) {
+                    logger.warning(e.getMessage());
+                }
+            }
+        });
+        latch.await(3000, TimeUnit.MILLISECONDS);
+    }
+
+    @After
+    public void stopServer() throws InterruptedException {
+        logger.fine("Stopping server ...");
+        serverProcess.destroy();
+        serverOutout.cancel(false);
+        serverError.cancel(false);
+        serverService.shutdown();
+        serverService.awaitTermination(3000, TimeUnit.MILLISECONDS);
+    }
+
+    Socket.Options createOptions() {
+        Socket.Options opts = new Socket.Options();
+        opts.port = PORT;
+        return opts;
+    }
+
+    String[] createEnv() {
+        Map<String, String> env = new HashMap<String, String>(System.getenv());
+        env.put("DEBUG", "engine*");
+        env.put("PORT", String.valueOf(PORT));
+        String[] _env = new String[env.size()];
+        int i = 0;
+        for (String key : env.keySet()) {
+            _env[i] = key + "=" + env.get(key);
+            i++;
+        }
+        return _env;
+    }
+}

src/test/java/io/socket/engineio/client/ConnectionTest.java

@@ -0,0 +1,245 @@
+package io.socket.engineio.client;
+
+import io.socket.emitter.Emitter;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.util.Timer;
+import java.util.TimerTask;
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.LinkedBlockingQueue;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+
+@RunWith(JUnit4.class)
+public class ConnectionTest extends Connection {
+
+    private Socket socket;
+
+    @Test(timeout = TIMEOUT)
+    public void connectToLocalhost() throws InterruptedException {
+        final BlockingQueue<Object> values = new LinkedBlockingQueue<Object>();
+
+        socket = new Socket(createOptions());
+        socket.on(Socket.EVENT_OPEN, new Emitter.Listener() {
+            @Override
+            public void call(Object... args) {
+                socket.on(Socket.EVENT_MESSAGE, new Emitter.Listener() {
+                    @Override
+                    public void call(Object... args) {
+                        values.offer(args[0]);
+                        socket.close();
+                    }
+                });
+            }
+        });
+        socket.open();
+
+        assertThat((String)values.take(), is("hi"));
+    }
+
+    @Test(timeout = TIMEOUT)
+    public void receiveMultibyteUTF8StringsWithPolling() throws InterruptedException {
+        final BlockingQueue<Object> values = new LinkedBlockingQueue<Object>();
+
+        socket = new Socket(createOptions());
+        socket.on(Socket.EVENT_OPEN, new Emitter.Listener() {
+            @Override
+            public void call(Object... args) {
+                socket.send("cash money €€€");
+                socket.on(Socket.EVENT_MESSAGE, new Emitter.Listener() {
+                    @Override
+                    public void call(Object... args) {
+                        if ("hi".equals(args[0])) return;
+                        values.offer(args[0]);
+                        socket.close();
+                    }
+                });
+            }
+        });
+        socket.open();
+
+        assertThat((String)values.take(), is("cash money €€€"));
+    }
+
+    @Test(timeout = TIMEOUT)
+    public void receiveEmoji() throws InterruptedException {
+        final BlockingQueue<Object> values = new LinkedBlockingQueue<Object>();
+
+        socket = new Socket(createOptions());
+        socket.on(Socket.EVENT_OPEN, new Emitter.Listener() {
+            @Override
+            public void call(Object... args) {
+                socket.send("\uD800-\uDB7F\uDB80-\uDBFF\uDC00-\uDFFF\uE000-\uF8FF");
+                socket.on(Socket.EVENT_MESSAGE, new Emitter.Listener() {
+                    @Override
+                    public void call(Object... args) {
+                        if ("hi".equals(args[0])) return;
+                        values.offer(args[0]);
+                        socket.close();
+                    }
+                });
+            }
+        });
+        socket.open();
+
+        assertThat((String)values.take(), is("\uD800-\uDB7F\uDB80-\uDBFF\uDC00-\uDFFF\uE000-\uF8FF"));
+    }
+
+    @Test(timeout = TIMEOUT)
+    public void notSendPacketsIfSocketCloses() throws InterruptedException {
+        final BlockingQueue<Object> values = new LinkedBlockingQueue<Object>();
+
+        socket = new Socket(createOptions());
+        socket.on(Socket.EVENT_OPEN, new Emitter.Listener() {
+            @Override
+            public void call(Object... args) {
+                final boolean[] noPacket = new boolean[] {true};
+                socket.on(Socket.EVENT_PACKET_CREATE, new Emitter.Listener() {
+                    @Override
+                    public void call(Object... args) {
+                        noPacket[0] = false;
+                    }
+                });
+                socket.close();
+                socket.send("hi");
+                Timer timer = new Timer();
+                timer.schedule(new TimerTask() {
+                    @Override
+                    public void run() {
+                        values.offer(noPacket[0]);
+                    }
+                }, 1200);
+
+            }
+        });
+        socket.open();
+        assertThat((Boolean)values.take(), is(true));
+    }
+
+    @Test(timeout = TIMEOUT)
+    public void deferCloseWhenUpgrading() throws InterruptedException {
+        final BlockingQueue<Object> values = new LinkedBlockingQueue<Object>();
+
+        socket = new Socket(createOptions());
+        socket.on(Socket.EVENT_OPEN, new Emitter.Listener() {
+            @Override
+            public void call(Object... args) {
+                final boolean[] upgraded = new boolean[] {false};
+                socket.on(Socket.EVENT_UPGRADE, new Emitter.Listener() {
+                    @Override
+                    public void call(Object... args) {
+                        upgraded[0] = true;
+                    }
+                }).on(Socket.EVENT_UPGRADING, new Emitter.Listener() {
+                    @Override
+                    public void call(Object... args) {
+                        socket.on(Socket.EVENT_CLOSE, new Emitter.Listener() {
+                            @Override
+                            public void call(Object... args) {
+                                values.offer(upgraded[0]);
+                            }
+                        });
+                        socket.close();
+                    }
+                });
+            }
+        });
+        socket.open();
+        assertThat((Boolean)values.take(), is(true));
+    }
+
+    @Test(timeout = TIMEOUT)
+    public void closeOnUpgradeErrorIfClosingIsDeferred() throws InterruptedException {
+        final BlockingQueue<Object> values = new LinkedBlockingQueue<Object>();
+
+        socket = new Socket(createOptions());
+        socket.on(Socket.EVENT_OPEN, new Emitter.Listener() {
+            @Override
+            public void call(Object... args) {
+                final boolean[] upgradError = new boolean[] {false};
+                socket.on(Socket.EVENT_UPGRADE_ERROR, new Emitter.Listener() {
+                    @Override
+                    public void call(Object... args) {
+                        upgradError[0] = true;
+                    }
+                }).on(Socket.EVENT_UPGRADING, new Emitter.Listener() {
+                    @Override
+                    public void call(Object... args) {
+                        socket.on(Socket.EVENT_CLOSE, new Emitter.Listener() {
+                            @Override
+                            public void call(Object... args) {
+                                values.offer(upgradError[0]);
+                            }
+                        });
+                        socket.close();
+                        socket.transport.onError("upgrade error", new Exception());
+                    }
+                });
+            }
+        });
+        socket.open();
+        assertThat((Boolean) values.take(), is(true));
+    }
+
+    public void notSendPacketsIfClosingIsDeferred() throws InterruptedException {
+        final BlockingQueue<Object> values = new LinkedBlockingQueue<Object>();
+
+        socket = new Socket(createOptions());
+        socket.on(Socket.EVENT_OPEN, new Emitter.Listener() {
+            @Override
+            public void call(Object... args) {
+                final boolean[] noPacket = new boolean[] {true};
+                socket.on(Socket.EVENT_UPGRADING, new Emitter.Listener() {
+                    @Override
+                    public void call(Object... args) {
+                        socket.on(Socket.EVENT_PACKET_CREATE, new Emitter.Listener() {
+                            @Override
+                            public void call(Object... args) {
+                                noPacket[0] = false;
+                            }
+                        });
+                        socket.close();
+                        socket.send("hi");
+                    }
+                });
+                new Timer().schedule(new TimerTask() {
+                    @Override
+                    public void run() {
+                        values.offer(noPacket[0]);
+                    }
+                }, 1200);
+            }
+        });
+        socket.open();
+        assertThat((Boolean) values.take(), is(true));
+    }
+
+    @Test(timeout = TIMEOUT)
+    public void sendAllBufferedPacketsIfClosingIsDeferred() throws InterruptedException {
+        final BlockingQueue<Object> values = new LinkedBlockingQueue<Object>();
+
+        socket = new Socket(createOptions());
+        socket.on(Socket.EVENT_OPEN, new Emitter.Listener() {
+            @Override
+            public void call(Object... args) {
+                socket.on(Socket.EVENT_UPGRADING, new Emitter.Listener() {
+                    @Override
+                    public void call(Object... args) {
+                        socket.send("hi");
+                        socket.close();
+                    }
+                }).on(Socket.EVENT_CLOSE, new Emitter.Listener() {
+                    @Override
+                    public void call(Object... args) {
+                        values.offer(socket.writeBuffer.size());
+                    }
+                });
+            }
+        });
+        socket.open();
+        assertThat((Integer) values.take(), is(0));
+    }
+}

src/test/java/io/socket/engineio/client/ExecutionTest.java

@@ -0,0 +1,49 @@
+package io.socket.engineio.client;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.logging.Logger;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+
+@RunWith(JUnit4.class)
+public class ExecutionTest extends Connection {
+
+    private static final Logger logger = Logger.getLogger(Socket.class.getName());
+
+    final static int TIMEOUT = 30 * 1000;
+
+    @Test(timeout = TIMEOUT)
+    public void execConnection() throws InterruptedException, IOException {
+        exec("io.socket.engineio.client.executions.Connection");
+    }
+
+    @Test(timeout = TIMEOUT)
+    public void execConnectionFailure() throws InterruptedException, IOException {
+        exec("io.socket.engineio.client.executions.ConnectionFailure");
+    }
+
+    @Test(timeout = TIMEOUT)
+    public void execImmediateClose() throws InterruptedException, IOException {
+        exec("io.socket.engineio.client.executions.ImmediateClose");
+    }
+
+    private void exec(String mainClass) throws InterruptedException, IOException {
+        Process process = Runtime.getRuntime().exec(String.format("mvn --quiet exec:java" +
+                " -Dexec.mainClass=%s -Dexec.classpathScope=test", mainClass), createEnv());
+        BufferedReader input = new BufferedReader(
+                new InputStreamReader(process.getInputStream()));
+        String line;
+        while ((line = input.readLine()) != null) {
+            logger.fine("EXEC OUT: " + line);
+        }
+        process.waitFor();
+        assertThat(process.exitValue(), is(0));
+    }
+}

src/test/java/io/socket/engineio/client/SSLConnectionTest.java

@@ -0,0 +1,147 @@
+package io.socket.engineio.client;
+
+import io.socket.emitter.Emitter;
+import org.junit.After;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import javax.net.ssl.HostnameVerifier;
+import javax.net.ssl.KeyManagerFactory;
+import javax.net.ssl.SSLContext;
+import javax.net.ssl.TrustManagerFactory;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.security.GeneralSecurityException;
+import java.security.KeyStore;
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.LinkedBlockingQueue;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+
+@RunWith(JUnit4.class)
+public class SSLConnectionTest extends Connection {
+
+    static HostnameVerifier hostnameVerifier = new javax.net.ssl.HostnameVerifier(){
+        public boolean verify(String hostname, javax.net.ssl.SSLSession sslSession) {
+            return hostname.equals("localhost");
+        }
+    };
+
+    private Socket socket;
+
+    @After
+    public void tearDown() {
+        Socket.setDefaultSSLContext(null);
+    }
+
+    @Override
+    Socket.Options createOptions() {
+        Socket.Options opts = super.createOptions();
+        opts.secure = true;
+        return opts;
+    }
+
+    @Override
+    String[] createEnv() {
+        return new String[] {"DEBUG=engine*", "PORT=" + PORT, "SSL=1"};
+    }
+
+    SSLContext createSSLContext() throws GeneralSecurityException, IOException {
+        KeyStore ks = KeyStore.getInstance("JKS");
+        File file = new File("src/test/resources/keystore.jks");
+        ks.load(new FileInputStream(file), "password".toCharArray());
+
+        KeyManagerFactory kmf = KeyManagerFactory.getInstance("SunX509");
+        kmf.init(ks, "password".toCharArray());
+
+        TrustManagerFactory tmf = TrustManagerFactory.getInstance("SunX509");
+        tmf.init(ks);
+
+        SSLContext sslContext = SSLContext.getInstance("TLS");
+        sslContext.init(kmf.getKeyManagers(), tmf.getTrustManagers(), null);
+        return sslContext;
+    }
+
+    @Test(timeout = TIMEOUT)
+    public void connect() throws Exception {
+        final BlockingQueue<Object> values = new LinkedBlockingQueue<Object>();
+
+        Socket.Options opts = createOptions();
+        opts.sslContext = createSSLContext();
+        opts.hostnameVerifier = SSLConnectionTest.hostnameVerifier;
+        socket = new Socket(opts);
+        socket.on(Socket.EVENT_OPEN, new Emitter.Listener() {
+            @Override
+            public void call(Object... args) {
+                socket.on(Socket.EVENT_MESSAGE, new Emitter.Listener() {
+                    @Override
+                    public void call(Object... args) {
+                        values.offer(args[0]);
+                    }
+                });
+            }
+        });
+        socket.open();
+
+        assertThat((String)values.take(), is("hi"));
+        socket.close();
+    }
+
+    @Test(timeout = TIMEOUT)
+    public void upgrade() throws Exception {
+        final BlockingQueue<Object> values = new LinkedBlockingQueue<Object>();
+
+        Socket.Options opts = createOptions();
+        opts.sslContext = createSSLContext();
+        opts.hostnameVerifier = SSLConnectionTest.hostnameVerifier;
+        socket = new Socket(opts);
+        socket.on(Socket.EVENT_OPEN, new Emitter.Listener() {
+            @Override
+            public void call(Object... args) {
+                socket.on(Socket.EVENT_UPGRADE, new Emitter.Listener() {
+                    @Override
+                    public void call(Object... args) {
+                        socket.send("hi");
+                        socket.on(Socket.EVENT_MESSAGE, new Emitter.Listener() {
+                            @Override
+                            public void call(Object... args) {
+                                values.offer(args[0]);
+                            }
+                        });
+                    }
+                });
+            }
+        });
+        socket.open();
+
+        assertThat((String)values.take(), is("hi"));
+        socket.close();
+    }
+
+    @Test(timeout = TIMEOUT)
+    public void defaultSSLContext() throws Exception {
+        final BlockingQueue<Object> values = new LinkedBlockingQueue<Object>();
+
+        Socket.setDefaultSSLContext(createSSLContext());
+        Socket.setDefaultHostnameVerifier(SSLConnectionTest.hostnameVerifier);
+        socket = new Socket(createOptions());
+        socket.on(Socket.EVENT_OPEN, new Emitter.Listener() {
+            @Override
+            public void call(Object... args) {
+                socket.on(Socket.EVENT_MESSAGE, new Emitter.Listener() {
+                    @Override
+                    public void call(Object... args) {
+                        values.offer(args[0]);
+                    }
+                });
+            }
+        });
+        socket.open();
+
+        assertThat((String)values.take(), is("hi"));
+        socket.close();
+    }
+}

src/test/java/io/socket/engineio/client/ServerConnectionTest.java

@@ -0,0 +1,278 @@
+package io.socket.engineio.client;
+
+import io.socket.emitter.Emitter;
+import io.socket.engineio.client.transports.Polling;
+import io.socket.engineio.client.transports.WebSocket;
+import io.socket.thread.EventThread;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.net.URISyntaxException;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.LinkedBlockingQueue;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.CoreMatchers.not;
+import static org.hamcrest.CoreMatchers.notNullValue;
+import static org.hamcrest.Matchers.*;
+import static org.hamcrest.Matchers.instanceOf;
+import static org.junit.Assert.assertThat;
+
+@RunWith(JUnit4.class)
+public class ServerConnectionTest extends Connection {
+
+    private Socket socket;
+
+    @Test(timeout = TIMEOUT)
+    public void openAndClose() throws URISyntaxException, InterruptedException {
+        final BlockingQueue<String> events = new LinkedBlockingQueue<String>();
+
+        socket = new Socket(createOptions());
+        socket.on(Socket.EVENT_OPEN, new Emitter.Listener() {
+            @Override
+            public void call(Object... args) {
+                events.offer("onopen");
+            }
+        }).on(Socket.EVENT_CLOSE, new Emitter.Listener() {
+            @Override
+            public void call(Object... args) {
+                events.offer("onclose");
+            }
+        });
+        socket.open();
+
+        assertThat(events.take(), is("onopen"));
+        socket.close();
+        assertThat(events.take(), is("onclose"));
+    }
+
+    @Test(timeout = TIMEOUT)
+    public void messages() throws URISyntaxException, InterruptedException {
+        final BlockingQueue<String> events = new LinkedBlockingQueue<String>();
+
+        socket = new Socket(createOptions());
+        socket.on(Socket.EVENT_OPEN, new Emitter.Listener() {
+            @Override
+            public void call(Object... args) {
+                socket.send("hello");
+            }
+        }).on(Socket.EVENT_MESSAGE, new Emitter.Listener() {
+            @Override
+            public void call(Object... args) {
+                events.offer((String) args[0]);
+            }
+        });
+        socket.open();
+
+        assertThat(events.take(), is("hi"));
+        assertThat(events.take(), is("hello"));
+        socket.close();
+    }
+
+    @Test(timeout = TIMEOUT)
+    public void handshake() throws URISyntaxException, InterruptedException {
+        final BlockingQueue<Object> values = new LinkedBlockingQueue<Object>();
+
+        socket = new Socket(createOptions());
+        socket.on(Socket.EVENT_HANDSHAKE, new Emitter.Listener() {
+            @Override
+            public void call(Object... args) {
+                values.offer(args);
+            }
+        });
+        socket.open();
+
+        Object[] args = (Object[])values.take();
+        assertThat(args.length, is(1));
+        HandshakeData data = (HandshakeData)args[0];
+        assertThat(data.sid, is(notNullValue()));
+        assertThat(data.upgrades, is(not(emptyArray())));
+        assertThat(data.pingTimeout, is(greaterThan((long) 0)));
+        assertThat(data.pingInterval, is(greaterThan((long) 0)));
+        socket.close();
+    }
+
+    @Test(timeout = TIMEOUT)
+    public void upgrade() throws URISyntaxException, InterruptedException {
+        final BlockingQueue<Object[]> events = new LinkedBlockingQueue<Object[]>();
+
+        socket = new Socket(createOptions());
+        socket.on(Socket.EVENT_UPGRADING, new Emitter.Listener() {
+            @Override
+            public void call(Object... args) {
+                events.offer(args);
+            }
+        });
+        socket.on(Socket.EVENT_UPGRADE, new Emitter.Listener() {
+            @Override
+            public void call(Object... args) {
+                events.offer(args);
+            }
+        });
+        socket.open();
+
+        Object[] args1 = events.take();
+        assertThat(args1.length, is(1));
+        assertThat(args1[0], is(instanceOf(Transport.class)));
+        Transport transport1 = (Transport)args1[0];
+        assertThat(transport1, is(notNullValue()));
+
+        Object[] args2 = events.take();
+        assertThat(args2.length, is(1));
+        assertThat(args2[0], is(instanceOf(Transport.class)));
+        Transport transport2 = (Transport)args2[0];
+        assertThat(transport2, is(notNullValue()));
+
+        socket.close();
+    }
+
+    @Test(timeout = TIMEOUT)
+    public void pollingHeaders() throws URISyntaxException, InterruptedException {
+        final BlockingQueue<String> messages = new LinkedBlockingQueue<String>();
+
+        Socket.Options opts = createOptions();
+        opts.transports = new String[] {Polling.NAME};
+
+        socket = new Socket(opts);
+        socket.on(Socket.EVENT_TRANSPORT, new Emitter.Listener() {
+            @Override
+            public void call(Object... args) {
+                Transport transport = (Transport)args[0];
+                transport.on(Transport.EVENT_REQUEST_HEADERS, new Emitter.Listener() {
+                    @Override
+                    public void call(Object... args) {
+                        @SuppressWarnings("unchecked")
+                        Map<String, List<String>> headers = (Map<String, List<String>>)args[0];
+                        headers.put("X-EngineIO", Arrays.asList("foo"));
+                    }
+                }).on(Transport.EVENT_RESPONSE_HEADERS, new Emitter.Listener() {
+                    @Override
+                    public void call(Object... args) {
+                        @SuppressWarnings("unchecked")
+                        Map<String, List<String>> headers = (Map<String, List<String>>)args[0];
+                        List<String> values = headers.get("X-EngineIO");
+                        messages.offer(values.get(0));
+                        messages.offer(values.get(1));
+                    }
+                });
+            }
+        });
+        socket.open();
+
+        assertThat(messages.take(), is("foo"));
+        assertThat(messages.take(), is("hi"));
+        socket.close();
+    }
+
+    @Test(timeout = TIMEOUT)
+    public void websocketHandshakeHeaders() throws URISyntaxException, InterruptedException {
+        final BlockingQueue<String> messages = new LinkedBlockingQueue<String>();
+
+        Socket.Options opts = createOptions();
+        opts.transports = new String[] {WebSocket.NAME};
+
+        socket = new Socket(opts);
+        socket.on(Socket.EVENT_TRANSPORT, new Emitter.Listener() {
+            @Override
+            public void call(Object... args) {
+                Transport transport = (Transport)args[0];
+                transport.on(Transport.EVENT_REQUEST_HEADERS, new Emitter.Listener() {
+                    @Override
+                    public void call(Object... args) {
+                        @SuppressWarnings("unchecked")
+                        Map<String, List<String>> headers = (Map<String, List<String>>)args[0];
+                        headers.put("X-EngineIO", Arrays.asList("foo"));
+                    }
+                }).on(Transport.EVENT_RESPONSE_HEADERS, new Emitter.Listener() {
+                    @Override
+                    public void call(Object... args) {
+                        @SuppressWarnings("unchecked")
+                        Map<String, List<String>> headers = (Map<String, List<String>>)args[0];
+                        List<String> values = headers.get("X-EngineIO");
+                        messages.offer(values.get(0));
+                        messages.offer(values.get(1));
+                    }
+                });
+            }
+        });
+        socket.open();
+
+        assertThat(messages.take(), is("hi"));
+        assertThat(messages.take(), is("foo"));
+        socket.close();
+    }
+
+    @Test(timeout = TIMEOUT)
+    public void rememberWebsocket() throws InterruptedException {
+        final BlockingQueue<Object> values = new LinkedBlockingQueue<Object>();
+
+        EventThread.exec(new Runnable() {
+            @Override
+            public void run() {
+                final Socket socket = new Socket(createOptions());
+
+                socket.on(Socket.EVENT_UPGRADE, new Emitter.Listener() {
+                    @Override
+                    public void call(Object... args) {
+                        Transport transport = (Transport) args[0];
+                        socket.close();
+                        if (WebSocket.NAME.equals(transport.name)) {
+                            Socket.Options opts = new Socket.Options();
+                            opts.port = PORT;
+                            opts.rememberUpgrade = true;
+
+                            Socket socket2 = new Socket(opts);
+                            socket2.open();
+                            values.offer(socket2.transport.name);
+                            socket2.close();
+                        }
+                    }
+                });
+                socket.open();
+                values.offer(socket.transport.name);
+            }
+        });
+
+        assertThat((String)values.take(), is(Polling.NAME));
+        assertThat((String)values.take(), is(WebSocket.NAME));
+    }
+
+    @Test(timeout = TIMEOUT)
+    public void notRememberWebsocket() throws InterruptedException {
+        final BlockingQueue<Object> values = new LinkedBlockingQueue<Object>();
+
+        EventThread.exec(new Runnable() {
+            @Override
+            public void run() {
+                final Socket socket = new Socket(createOptions());
+
+                socket.on(Socket.EVENT_UPGRADE, new Emitter.Listener() {
+                    @Override
+                    public void call(Object... args) {
+                        Transport transport = (Transport)args[0];
+                        socket.close();
+                        if (WebSocket.NAME.equals(transport.name)) {
+                            Socket.Options opts = new Socket.Options();
+                            opts.port = PORT;
+                            opts.rememberUpgrade = false;
+
+                            final Socket socket2 = new Socket(opts);
+                            socket2.open();
+                            values.offer(socket2.transport.name);
+                            socket2.close();
+                        }
+                    }
+                });
+                socket.open();
+                values.offer(socket.transport.name);
+            }
+        });
+
+        assertThat((String) values.take(), is(Polling.NAME));
+        assertThat((String)values.take(), is(not(WebSocket.NAME)));
+    }
+}

src/test/java/io/socket/engineio/client/SocketTest.java

@@ -0,0 +1,51 @@
+package io.socket.engineio.client;
+
+import io.socket.engineio.client.transports.Polling;
+import io.socket.engineio.client.transports.WebSocket;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.net.URISyntaxException;
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+
+@RunWith(JUnit4.class)
+public class SocketTest {
+
+    @Test
+    public void filterUpgrades() {
+        Socket.Options opts = new Socket.Options();
+        opts.transports = new String[] {Polling.NAME};
+        Socket socket = new Socket(opts);
+        List<String> upgrades = new ArrayList<String>() {{
+            add(Polling.NAME);
+            add(WebSocket.NAME);
+        }};
+        List<String> expected = new ArrayList<String>() {{add(Polling.NAME);}};
+        assertThat(socket.filterUpgrades(upgrades), is(expected));
+    }
+
+    public void properlyParseHttpUriWithoutPort() throws URISyntaxException {
+        Socket client = new Socket("http://localhost");
+        assertThat(client.port, is(80));
+    }
+
+    public void properlyParseHttpsUriWithoutPort() throws URISyntaxException {
+        Socket client = new Socket("http://localhost");
+        assertThat(client.port, is(443));
+    }
+
+    public void properlyParseWssUriWithoutPort() throws URISyntaxException {
+        Socket client = new Socket("http://localhost");
+        assertThat(client.port, is(443));
+    }
+
+    public void properlyParseWssUriWithPort() throws URISyntaxException {
+        Socket client = new Socket("http://localhost:2020");
+        assertThat(client.port, is(2020));
+    }
+}

src/test/java/io/socket/engineio/client/TransportTest.java

@@ -0,0 +1,147 @@
+package io.socket.engineio.client;
+
+import io.socket.engineio.client.transports.PollingXHR;
+import io.socket.engineio.client.transports.WebSocket;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.util.HashMap;
+
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+
+@RunWith(JUnit4.class)
+public class TransportTest {
+
+    // NOTE: tests for the rememberUpgrade option are on ServerConnectionTest.
+
+    @Test
+    public void uri() {
+        Transport.Options opt = new Transport.Options();
+        opt.path = "/engine.io";
+        opt.hostname = "localhost";
+        opt.secure = false;
+        opt.query = new HashMap<String, String>() {{
+            put("sid", "test");
+        }};
+        opt.timestampRequests = false;
+        Polling polling = new Polling(opt);
+        assertThat(polling.uri(), containsString("http://localhost/engine.io?sid=test"));
+    }
+
+    @Test
+    public void uriWithDefaultPort() {
+        Transport.Options opt = new Transport.Options();
+        opt.path ="/engine.io";
+        opt.hostname = "localhost";
+        opt.secure = false;
+        opt.query = new HashMap<String, String>() {{
+            put("sid", "test");
+        }};
+        opt.port = 80;
+        opt.timestampRequests = false;
+        Polling polling = new Polling(opt);
+        assertThat(polling.uri(), containsString("http://localhost/engine.io?sid=test"));
+    }
+
+    @Test
+    public void uriWithPort() {
+        Transport.Options opt = new Transport.Options();
+        opt.path ="/engine.io";
+        opt.hostname = "localhost";
+        opt.secure = false;
+        opt.query = new HashMap<String, String>() {{
+            put("sid", "test");
+        }};
+        opt.port = 3000;
+        opt.timestampRequests = false;
+        Polling polling = new Polling(opt);
+        assertThat(polling.uri(), containsString("http://localhost:3000/engine.io?sid=test"));
+    }
+
+    @Test
+    public void httpsUriWithDefaultPort() {
+        Transport.Options opt = new Transport.Options();
+        opt.path ="/engine.io";
+        opt.hostname = "localhost";
+        opt.secure = true;
+        opt.query = new HashMap<String, String>() {{
+            put("sid", "test");
+        }};
+        opt.port = 443;
+        opt.timestampRequests = false;
+        Polling polling = new Polling(opt);
+        assertThat(polling.uri(), containsString("https://localhost/engine.io?sid=test"));
+    }
+
+    @Test
+    public void timestampedUri() {
+        Transport.Options opt = new Transport.Options();
+        opt.path ="/engine.io";
+        opt.hostname = "localhost";
+        opt.timestampParam = "t";
+        opt.timestampRequests = true;
+        Polling polling = new Polling(opt);
+        assertThat(polling.uri().matches("http://localhost/engine.io\\?(j=[0-9]+&)?t=[0-9]+-[0-9]+"), is(true));
+    }
+
+    @Test
+    public void wsUri() {
+        Transport.Options opt = new Transport.Options();
+        opt.path ="/engine.io";
+        opt.hostname = "test";
+        opt.secure = false;
+        opt.query = new HashMap<String, String>() {{
+            put("transport", "websocket");
+        }};
+        opt.timestampRequests = false;
+        WS ws = new WS(opt);
+        assertThat(ws.uri(), is("ws://test/engine.io?transport=websocket"));
+    }
+
+    @Test
+    public void wssUri() {
+        Transport.Options opt = new Transport.Options();
+        opt.path = "/engine.io";
+        opt.hostname = "test";
+        opt.secure = true;
+        opt.timestampRequests = false;
+        WS ws = new WS(opt);
+        assertThat(ws.uri(), is("wss://test/engine.io"));
+    }
+
+    @Test
+    public void wsTimestampedUri() {
+        Transport.Options opt = new Transport.Options();
+        opt.path = "/engine.io";
+        opt.hostname = "localhost";
+        opt.timestampParam = "woot";
+        opt.timestampRequests = true;
+        WS ws = new WS(opt);
+        assertThat(ws.uri().matches("ws://localhost/engine.io\\?woot=[0-9]+"), is(true));
+    }
+
+    class Polling extends PollingXHR {
+
+        public Polling(Options opts) {
+            super(opts);
+        }
+
+        public String uri() {
+            return super.uri();
+        }
+    }
+
+    class WS extends WebSocket {
+
+        public WS(Transport.Options opts) {
+            super(opts);
+        }
+
+        public String uri() {
+            return super.uri();
+        }
+    }
+}

src/test/java/io/socket/engineio/client/executions/Connection.java

@@ -0,0 +1,21 @@
+package io.socket.engineio.client.executions;
+
+import io.socket.emitter.Emitter;
+import io.socket.engineio.client.Socket;
+
+import java.net.URISyntaxException;
+
+public class Connection {
+
+    public static void main(String[] args) throws URISyntaxException {
+        final Socket socket = new Socket("http://localhost:" + System.getenv("PORT"));
+        socket.on(Socket.EVENT_OPEN, new Emitter.Listener() {
+            @Override
+            public void call(Object... args) {
+                System.out.println("open");
+                socket.close();
+            }
+        });
+        socket.open();
+    }
+}

src/test/java/io/socket/engineio/client/executions/ConnectionFailure.java

@@ -0,0 +1,27 @@
+package io.socket.engineio.client.executions;
+
+import io.socket.emitter.Emitter;
+import io.socket.engineio.client.Socket;
+
+import java.net.URISyntaxException;
+
+public class ConnectionFailure {
+
+    public static void main(String[] args) throws URISyntaxException {
+        int port = Integer.parseInt(System.getenv("PORT"));
+        port++;
+        final Socket socket = new Socket("http://localhost:" + port);
+        socket.on(Socket.EVENT_CLOSE, new Emitter.Listener() {
+            @Override
+            public void call(Object... args) {
+                System.out.println("close");
+            }
+        }).on(Socket.EVENT_ERROR, new Emitter.Listener() {
+            @Override
+            public void call(Object... args) {
+                System.out.println("error");
+            }
+        });
+        socket.open();
+    }
+}

src/test/java/io/socket/engineio/client/executions/ImmediateClose.java

@@ -0,0 +1,26 @@
+package io.socket.engineio.client.executions;
+
+import io.socket.emitter.Emitter;
+import io.socket.engineio.client.Socket;
+
+import java.net.URISyntaxException;
+
+public class ImmediateClose {
+
+    public static void main(String[] args) throws URISyntaxException {
+        final Socket socket = new Socket("http://localhost:" + System.getenv("PORT"));
+        socket.on(Socket.EVENT_OPEN, new Emitter.Listener() {
+            @Override
+            public void call(Object... args) {
+                System.out.println("open");
+            }
+        }).on(Socket.EVENT_CLOSE, new Emitter.Listener() {
+            @Override
+            public void call(Object... args) {
+                System.out.println("close");
+            }
+        });
+        socket.open();
+        socket.close();
+    }
+}

src/test/java/io/socket/engineio/parser/ParserTest.java

@@ -0,0 +1,418 @@
+package io.socket.engineio.parser;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import static io.socket.engineio.parser.Parser.*;
+import static org.hamcrest.CoreMatchers.*;
+import static org.junit.Assert.assertThat;
+
+@RunWith(JUnit4.class)
+public class ParserTest {
+
+    static final String ERROR_DATA = "parser error";
+
+    @Test
+    public void encodeAsString() {
+        encodePacket(new Packet<String>(Packet.MESSAGE, "test"), new EncodeCallback<String>() {
+            @Override
+            public void call(String data) {
+                assertThat(data, isA(String.class));
+            }
+        });
+    }
+
+    @Test
+    public void decodeAsPacket() {
+        encodePacket(new Packet<String>(Packet.MESSAGE, "test"), new EncodeCallback<String>() {
+            @Override
+            public void call(String data) {
+                assertThat(decodePacket(data), isA(Packet.class));
+            }
+        });
+    }
+
+    @Test
+    public void noData() {
+        encodePacket(new Packet(Packet.MESSAGE), new EncodeCallback<String>() {
+            @Override
+            public void call(String data) {
+                Packet p = decodePacket(data);
+                assertThat(p.type, is(Packet.MESSAGE));
+                assertThat(p.data, is(nullValue()));
+            }
+        });
+    }
+
+    @Test
+    public void encodeOpenPacket() {
+        encodePacket(new Packet<String>(Packet.OPEN, "{\"some\":\"json\"}"), new EncodeCallback<String>() {
+            @Override
+            public void call(String data) {
+                Packet<String> p = decodePacket(data);
+                assertThat(p.type, is(Packet.OPEN));
+                assertThat(p.data, is("{\"some\":\"json\"}"));
+            }
+        });
+    }
+
+    @Test
+    public void encodeClosePacket() {
+        encodePacket(new Packet<String>(Packet.CLOSE), new EncodeCallback<String>() {
+            @Override
+            public void call(String data) {
+                Packet p = decodePacket(data);
+                assertThat(p.type, is(Packet.CLOSE));
+            }
+        });
+    }
+
+    @Test
+    public void encodePingPacket() {
+        encodePacket(new Packet<String>(Packet.PING, "1"), new EncodeCallback<String>() {
+            @Override
+            public void call(String data) {
+                Packet<String> p = decodePacket(data);
+                assertThat(p.type, is(Packet.PING));
+                assertThat(p.data, is("1"));
+            }
+        });
+    }
+
+    @Test
+    public void encodePongPacket() {
+        encodePacket(new Packet<String>(Packet.PONG, "1"), new EncodeCallback<String>() {
+            @Override
+            public void call(String data) {
+                Packet<String> p = decodePacket(data);
+                assertThat(p.type, is(Packet.PONG));
+                assertThat(p.data, is("1"));
+            }
+        });
+    }
+
+    @Test
+    public void encodeMessagePacket() {
+        encodePacket(new Packet<String>(Packet.MESSAGE, "aaa"), new EncodeCallback<String>() {
+            @Override
+            public void call(String data) {
+                Packet<String> p = decodePacket(data);
+                assertThat(p.type, is(Packet.MESSAGE));
+                assertThat(p.data, is("aaa"));
+            }
+        });
+    }
+
+    @Test
+    public void encodeUTF8SpecialCharsMessagePacket() {
+        encodePacket(new Packet<String>(Packet.MESSAGE, "utf8 — string"), new EncodeCallback<String>() {
+            @Override
+            public void call(String data) {
+                Packet<String> p = decodePacket(data);
+                assertThat(p.type, is(Packet.MESSAGE));
+                assertThat(p.data, is("utf8 — string"));
+            }
+        });
+    }
+
+    @Test
+    public void encodeMessagePacketCoercingToString() {
+        encodePacket(new Packet<Integer>(Packet.MESSAGE, 1), new EncodeCallback<String>() {
+            @Override
+            public void call(String data) {
+                Packet<String> p = decodePacket(data);
+                assertThat(p.type, is(Packet.MESSAGE));
+                assertThat(p.data, is("1"));
+            }
+        });
+    }
+
+    @Test
+    public void encodeUpgradePacket() {
+        encodePacket(new Packet<String>(Packet.UPGRADE), new EncodeCallback<String>() {
+            @Override
+            public void call(String data) {
+                Packet p = decodePacket(data);
+                assertThat(p.type, is(Packet.UPGRADE));
+            }
+        });
+    }
+
+    @Test
+    public void encodingFormat() {
+        encodePacket(new Packet<String>(Packet.MESSAGE, "test"), new EncodeCallback<String>() {
+            @Override
+            public void call(String data) {
+                assertThat(data.matches("[0-9].*"), is(true));
+            }
+        });
+        encodePacket(new Packet<String>(Packet.MESSAGE), new EncodeCallback<String>() {
+            @Override
+            public void call(String data) {
+                assertThat(data.matches("[0-9]"), is(true));
+            }
+        });
+    }
+
+    @Test
+    public void decodeBadFormat() {
+        Packet<String> p = decodePacket(":::");
+        assertThat(p.type, is(Packet.ERROR));
+        assertThat(p.data, is(ERROR_DATA));
+    }
+
+    @Test
+    public void decodeInexistentTypes() {
+        Packet<String> p = decodePacket("94103");
+        assertThat(p.type, is(Packet.ERROR));
+        assertThat(p.data, is(ERROR_DATA));
+    }
+
+    @Test
+    public void decodeInvalidUTF8() {
+        Packet<String> p = decodePacket("4\uffff", true);
+        assertThat(p.type, is(Packet.ERROR));
+        assertThat(p.data, is(ERROR_DATA));
+    }
+
+    @Test
+    public void encodePayloads() {
+        encodePayload(new Packet[]{new Packet(Packet.PING), new Packet(Packet.PONG)}, new EncodeCallback<byte[]>() {
+            @Override
+            public void call(byte[] data) {
+                assertThat(data, isA(byte[].class));
+            }
+        });
+    }
+
+    @Test
+    public void encodeAndDecodePayloads() {
+        encodePayload(new Packet[] {new Packet<String>(Packet.MESSAGE, "a")}, new EncodeCallback<byte[]>() {
+            @Override
+            public void call(byte[] data) {
+                decodePayload(data, new DecodePayloadCallback() {
+                    @Override
+                    public boolean call(Packet packet, int index, int total) {
+                        boolean isLast = index + 1 == total;
+                        assertThat(isLast, is(true));
+                        return true;
+                    }
+                });
+            }
+        });
+        encodePayload(new Packet[]{new Packet<String>(Packet.MESSAGE, "a"), new Packet(Packet.PING)}, new EncodeCallback<byte[]>() {
+            @Override
+            public void call(byte[] data) {
+                decodePayload(data, new DecodePayloadCallback() {
+                    @Override
+                    public boolean call(Packet packet, int index, int total) {
+                        boolean isLast = index + 1 == total;
+                        if (!isLast) {
+                            assertThat(packet.type, is(Packet.MESSAGE));
+                        } else {
+                            assertThat(packet.type, is(Packet.PING));
+                        }
+                        return true;
+                    }
+                });
+            }
+        });
+    }
+
+    @Test
+    public void encodeAndDecodeEmptyPayloads() {
+        encodePayload(new Packet[] {}, new EncodeCallback<byte[]>() {
+            @Override
+            public void call(byte[] data) {
+                decodePayload(data, new DecodePayloadCallback() {
+                    @Override
+                    public boolean call(Packet packet, int index, int total) {
+                        assertThat(packet.type, is(Packet.OPEN));
+                        boolean isLast = index + 1 == total;
+                        assertThat(isLast, is(true));
+                        return true;
+                    }
+                });
+            }
+        });
+    }
+
+    @Test
+    public void decodePayloadBadFormat() {
+        decodePayload("1!", new DecodePayloadCallback<String>() {
+            @Override
+            public boolean call(Packet<String> packet, int index, int total) {
+                boolean isLast = index + 1 == total;
+                assertThat(packet.type, is(Packet.ERROR));
+                assertThat(packet.data, is(ERROR_DATA));
+                assertThat(isLast, is(true));
+                return true;
+            }
+        });
+        decodePayload("", new DecodePayloadCallback<String>() {
+            @Override
+            public boolean call(Packet<String> packet, int index, int total) {
+                boolean isLast = index + 1 == total;
+                assertThat(packet.type, is(Packet.ERROR));
+                assertThat(packet.data, is(ERROR_DATA));
+                assertThat(isLast, is(true));
+                return true;
+            }
+        });
+        decodePayload("))", new DecodePayloadCallback<String>() {
+            @Override
+            public boolean call(Packet<String> packet, int index, int total) {
+                boolean isLast = index + 1 == total;
+                assertThat(packet.type, is(Packet.ERROR));
+                assertThat(packet.data, is(ERROR_DATA));
+                assertThat(isLast, is(true));
+                return true;
+            }
+        });
+    }
+
+    @Test
+    public void decodePayloadBadLength() {
+        decodePayload("1:", new DecodePayloadCallback<String>() {
+            @Override
+            public boolean call(Packet<String> packet, int index, int total) {
+                boolean isLast = index + 1 == total;
+                assertThat(packet.type, is(Packet.ERROR));
+                assertThat(packet.data, is(ERROR_DATA));
+                assertThat(isLast, is(true));
+                return true;
+            }
+        });
+    }
+
+    @Test
+    public void decodePayloadBadPacketFormat() {
+        decodePayload("3:99:", new DecodePayloadCallback<String>() {
+            @Override
+            public boolean call(Packet<String> packet, int index, int total) {
+                boolean isLast = index + 1 == total;
+                assertThat(packet.type, is(Packet.ERROR));
+                assertThat(packet.data, is(ERROR_DATA));
+                assertThat(isLast, is(true));
+                return true;
+            }
+        });
+        decodePayload("1:aa", new DecodePayloadCallback<String>() {
+            @Override
+            public boolean call(Packet<String> packet, int index, int total) {
+                boolean isLast = index + 1 == total;
+                assertThat(packet.type, is(Packet.ERROR));
+                assertThat(packet.data, is(ERROR_DATA));
+                assertThat(isLast, is(true));
+                return true;
+            }
+        });
+        decodePayload("1:a2:b", new DecodePayloadCallback<String>() {
+            @Override
+            public boolean call(Packet<String> packet, int index, int total) {
+                boolean isLast = index + 1 == total;
+                assertThat(packet.type, is(Packet.ERROR));
+                assertThat(packet.data, is(ERROR_DATA));
+                assertThat(isLast, is(true));
+                return true;
+            }
+        });
+    }
+
+    @Test
+    public void decodePayloadInvalidUTF8() {
+        decodePayload("2:4\uffff", new DecodePayloadCallback<String>() {
+            @Override
+            public boolean call(Packet<String> packet, int index, int total) {
+                boolean isLast = index + 1 == total;
+                assertThat(packet.type, is(Packet.ERROR));
+                assertThat(packet.data, is(ERROR_DATA));
+                assertThat(isLast, is(true));
+                return true;
+            }
+        });
+    }
+
+    @Test
+    public void encodeBinaryMessage() {
+        final byte[] data = new byte[5];
+        for (int i = 0; i < data.length; i++) {
+            data[0] = (byte)i;
+        }
+        encodePacket(new Packet<byte[]>(Packet.MESSAGE, data), new EncodeCallback<byte[]>() {
+            @Override
+            public void call(byte[] encoded) {
+                Packet<byte[]> p = decodePacket(encoded);
+                assertThat(p.type, is(Packet.MESSAGE));
+                assertThat(p.data, is(data));
+            }
+        });
+    }
+
+    @Test
+    public void encodeBinaryContents() {
+        final byte[] firstBuffer = new byte[5];
+        for (int i = 0 ; i < firstBuffer.length; i++) {
+            firstBuffer[0] = (byte)i;
+        }
+        final byte[] secondBuffer = new byte[4];
+        for (int i = 0 ; i < secondBuffer.length; i++) {
+            secondBuffer[0] = (byte)(firstBuffer.length + i);
+        }
+
+        encodePayload(new Packet[]{
+            new Packet<byte[]>(Packet.MESSAGE, firstBuffer),
+            new Packet<byte[]>(Packet.MESSAGE, secondBuffer),
+        }, new EncodeCallback<byte[]>() {
+            @Override
+            public void call(byte[] data) {
+                decodePayload(data, new DecodePayloadCallback() {
+                    @Override
+                    public boolean call(Packet packet, int index, int total) {
+                        boolean isLast = index + 1 == total;
+                        assertThat(packet.type, is(Packet.MESSAGE));
+                        if (!isLast) {
+                            assertThat((byte[])packet.data, is(firstBuffer));
+                        } else {
+                            assertThat((byte[])packet.data, is(secondBuffer));
+                        }
+                        return true;
+                    }
+                });
+            }
+        });
+    }
+
+    @Test
+    public void encodeMixedBinaryAndStringContents() {
+        final byte[] firstBuffer = new byte[123];
+        for (int i = 0 ; i < firstBuffer.length; i++) {
+            firstBuffer[0] = (byte)i;
+        }
+        encodePayload(new Packet[]{
+            new Packet<byte[]>(Packet.MESSAGE, firstBuffer),
+            new Packet<String>(Packet.MESSAGE, "hello"),
+            new Packet<String>(Packet.CLOSE),
+        }, new EncodeCallback<byte[]>() {
+            @Override
+            public void call(byte[] encoded) {
+                decodePayload(encoded, new DecodePayloadCallback() {
+                    @Override
+                    public boolean call(Packet packet, int index, int total) {
+                        if (index == 0) {
+                            assertThat(packet.type, is(Packet.MESSAGE));
+                            assertThat((byte[])packet.data, is(firstBuffer));
+                        } else if (index == 1) {
+                            assertThat(packet.type, is(Packet.MESSAGE));
+                            assertThat((String)packet.data, is("hello"));
+                        } else {
+                            assertThat(packet.type, is(Packet.CLOSE));
+                        }
+                        return true;
+                    }
+                });
+            }
+        });
+    }
+}

src/test/java/io/socket/global/GlobalTest.java

@@ -0,0 +1,24 @@
+package io.socket.global;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+
+@RunWith(JUnit4.class)
+public class GlobalTest {
+
+    @Test
+    public void encodeURIComponent() {
+        assertThat(Global.encodeURIComponent(" ~'()! "), is("%20~'()!%20"));
+        assertThat(Global.encodeURIComponent("+:;"), is("%2B%3A%3B"));
+    }
+
+    @Test
+    public void decodeURIComponent() {
+        assertThat(Global.decodeURIComponent("%20%7E%27%28%29%21%20"), is(" ~'()! "));
+        assertThat(Global.decodeURIComponent("%2B%3A%3B"), is("+:;"));
+    }
+}

src/test/java/io/socket/parseqs/ParseQSTest.java

@@ -0,0 +1,57 @@
+package io.socket.parseqs;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+
+@RunWith(JUnit4.class)
+public class ParseQSTest {
+
+    @Test
+    public void decode() {
+        Map<String, String> queryObject = ParseQS.decode("foo=bar");
+        assertThat(queryObject.get("foo"), is("bar"));
+
+        queryObject = ParseQS.decode("france=paris&germany=berlin");
+        assertThat(queryObject.get("france"), is("paris"));
+        assertThat(queryObject.get("germany"), is("berlin"));
+
+        queryObject = ParseQS.decode("india=new%20delhi");
+        assertThat(queryObject.get("india"), is("new delhi"));
+
+        queryObject = ParseQS.decode("woot=");
+        assertThat(queryObject.get("woot"), is(""));
+
+        queryObject = ParseQS.decode("woot");
+        assertThat(queryObject.get("woot"), is(""));
+    }
+
+    @Test
+    public void encode() {
+        Map<String, String> obj;
+
+        obj = new HashMap<String, String>() {{
+            put("a", "b");
+        }};
+        assertThat(ParseQS.encode(obj), is("a=b"));
+
+        obj = new LinkedHashMap<String, String>() {{
+            put("a", "b");
+            put("c", "d");
+        }};
+        assertThat(ParseQS.encode(obj), is("a=b&c=d"));
+
+        obj = new LinkedHashMap<String, String>() {{
+            put("a", "b");
+            put("c", "tobi rocks");
+        }};
+        assertThat(ParseQS.encode(obj), is("a=b&c=tobi%20rocks"));
+    }
+}

src/test/java/io/socket/thread/EventThreadTest.java

@@ -0,0 +1,92 @@
+package io.socket.thread;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.util.HashSet;
+import java.util.Set;
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.LinkedBlockingQueue;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+
+@RunWith(JUnit4.class)
+public class EventThreadTest {
+
+    @Test
+    public void isCurrent() throws InterruptedException {
+        final BlockingQueue<Boolean> queue = new LinkedBlockingQueue<Boolean>();
+
+        queue.offer(EventThread.isCurrent());
+
+        EventThread.exec(new Runnable() {
+            @Override
+            public void run() {
+                queue.offer(EventThread.isCurrent());
+            }
+        });
+
+        assertThat(queue.take(), is(false));
+        assertThat(queue.take(), is(true));
+    }
+
+    @Test
+    public void exec() throws InterruptedException {
+        final BlockingQueue<Integer> queue = new LinkedBlockingQueue<Integer>();
+
+        EventThread.exec(new Runnable() {
+            @Override
+            public void run() {
+                queue.offer(0);
+                EventThread.exec(new Runnable() {
+                    @Override
+                    public void run() {
+                        queue.offer(1);
+                    }
+                });
+                queue.offer(2);
+            }
+        });
+
+        EventThread.exec(new Runnable() {
+            @Override
+            public void run() {
+                queue.offer(3);
+            }
+        });
+
+        for (int i = 0; i < 4; i++) {
+            assertThat(queue.take(), is(i));
+        }
+    }
+
+    @Test
+    public void nextTick() throws InterruptedException {
+        final BlockingQueue<Integer> queue = new LinkedBlockingQueue<Integer>();
+        final Set<Thread> threads = new HashSet<Thread>();
+
+        EventThread.exec(new Runnable() {
+            @Override
+            public void run() {
+                threads.add(Thread.currentThread());
+
+                queue.offer(0);
+                EventThread.nextTick(new Runnable() {
+                    @Override
+                    public void run() {
+                        threads.add(Thread.currentThread());
+                        queue.offer(2);
+                    }
+                });
+                queue.offer(1);
+            }
+        });
+
+        for (int i = 0; i < 3; i++) {
+            assertThat(queue.take(), is(i));
+        }
+        assertThat(threads.size(), is(1));
+    }
+}

src/test/java/io/socket/utf8/UTF8Test.java

@@ -0,0 +1,96 @@
+package io.socket.utf8;
+
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+
+@RunWith(JUnit4.class)
+public class UTF8Test {
+    private static final Data[] DATA = new Data[] {
+        // 1-byte
+        new Data(0x0000, "\u0000", "\u0000"),
+        new Data(0x005c, "\u005C\u005C", "\u005C\u005C"), // = backslash
+        new Data(0x007f, "\u007F", "\u007F"),
+        // 2-byte
+        new Data(0x0080, "\u0080", "\u00C2\u0080"),
+        new Data(0x05CA, "\u05CA", "\u00D7\u008A"),
+        new Data(0x07FF, "\u07FF", "\u00DF\u00BF"),
+        // 3-byte
+        new Data(0x0800, "\u0800", "\u00E0\u00A0\u0080"),
+        new Data(0x2C3C, "\u2C3C", "\u00E2\u00B0\u00BC"),
+        new Data(0x07FF, "\uFFFF", "\u00EF\u00BF\u00BF"),
+        // unmatched surrogate halves
+        // high surrogates: 0xD800 to 0xDBFF
+        new Data(0xD800, "\uD800", "\u00ED\u00A0\u0080"),
+        new Data("High surrogate followed by another high surrogate",
+                "\uD800\uD800", "\u00ED\u00A0\u0080\u00ED\u00A0\u0080"),
+        new Data("High surrogate followed by a symbol that is not a surrogate",
+                "\uD800A", "\u00ED\u00A0\u0080A"),
+        new Data("Unmatched high surrogate, followed by a surrogate pair, followed by an unmatched high surrogate",
+                "\uD800\uD834\uDF06\uD800", "\u00ED\u00A0\u0080\u00F0\u009D\u008C\u0086\u00ED\u00A0\u0080"),
+        new Data(0xD9AF, "\uD9AF", "\u00ED\u00A6\u00AF"),
+        new Data(0xDBFF, "\uDBFF", "\u00ED\u00AF\u00BF"),
+        // low surrogates: 0xDC00 to 0xDFFF
+        new Data(0xDC00, "\uDC00", "\u00ED\u00B0\u0080"),
+        new Data("Low surrogate followed by another low surrogate",
+                "\uDC00\uDC00", "\u00ED\u00B0\u0080\u00ED\u00B0\u0080"),
+        new Data("Low surrogate followed by a symbol that is not a surrogate",
+                "\uDC00A", "\u00ED\u00B0\u0080A"),
+        new Data("Unmatched low surrogate, followed by a surrogate pair, followed by an unmatched low surrogate",
+                "\uDC00\uD834\uDF06\uDC00", "\u00ED\u00B0\u0080\u00F0\u009D\u008C\u0086\u00ED\u00B0\u0080"),
+        new Data(0xDEEE, "\uDEEE", "\u00ED\u00BB\u00AE"),
+        new Data(0xDFFF, "\uDFFF", "\u00ED\u00BF\u00BF"),
+        // 4-byte
+        new Data(0x010000, "\uD800\uDC00", "\u00F0\u0090\u0080\u0080"),
+        new Data(0x01D306, "\uD834\uDF06", "\u00F0\u009D\u008C\u0086"),
+        new Data(0x010FFF, "\uDBFF\uDFFF", "\u00F4\u008F\u00BF\u00BF"),
+    };
+
+    @Rule
+    public ExpectedException exception = ExpectedException.none();
+
+    @Test
+    public void encodeAndDecode() throws UTF8Exception {
+        for (Data data : DATA) {
+            String reason = data.description != null? data.description : "U+" + Integer.toHexString(data.codePoint).toUpperCase();
+            assertThat("Encoding: " + reason, data.encoded, is(UTF8.encode(data.decoded)));
+            assertThat("Decoding: " + reason, data.decoded, is(UTF8.decode(data.encoded)));
+        }
+
+        exception.expect(UTF8Exception.class);
+        UTF8.decode("\uFFFF");
+
+        exception.expect(UTF8Exception.class);
+        UTF8.decode("\u00E9\u0000\u0000");
+
+        exception.expect(UTF8Exception.class);
+        UTF8.decode("\u00C2\uFFFF");
+
+        exception.expect(UTF8Exception.class);
+        UTF8.decode("\u00F0\u009D");
+    }
+
+    private static class Data {
+        public int codePoint = -1;
+        public String description;
+        public String decoded;
+        public String encoded;
+
+        public Data(int codePoint, String decoded, String encoded) {
+            this.codePoint = codePoint;
+            this.decoded = decoded;
+            this.encoded = encoded;
+        }
+
+        public Data(String description, String decoded, String encoded) {
+            this.description = description;
+            this.decoded = decoded;
+            this.encoded = encoded;
+        }
+    }
+}