DefaultCrossfireServerConnectionTest.java

Go to the documentation of this file.

/*
 * This file is part of JXClient, the Fullscreen Java Crossfire Client.
 *
 * JXClient is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * JXClient is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with JXClient; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 * Copyright (C) 2005-2008 Yann Chachkoff.
 * Copyright (C) 2006-2011 Andreas Kirschbaum.
 */

package com.realtime.crossfire.jxclient.server.crossfire;

import java.io.EOFException;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.nio.charset.Charset;
import java.util.concurrent.Semaphore;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.junit.Assert;
import org.junit.Test;

public class DefaultCrossfireServerConnectionTest {

    @Nullable
    private Semaphore sem;

    @Test(timeout = 30000)
    public void testNegotiateNumLookObjects1() throws InterruptedException, IOException {
        sem = new Semaphore(0);
        final Model model = new Model();
        final DefaultCrossfireServerConnection connection = new DefaultCrossfireServerConnection(model, null, "version");
        final int port = startServer();
        connection.start();
        try {
            connection.connect("localhost", port);
            connection.setPreferredNumLookObjects(10);
            assert sem != null;
            sem.acquire();
            connection.waitForCurrentNumLookObjectsValid();
            Assert.assertEquals(10, connection.getCurrentNumLookObjects());
            connection.setPreferredNumLookObjects(11);
            connection.setPreferredNumLookObjects(12);
            connection.setPreferredNumLookObjects(13);
            connection.setPreferredNumLookObjects(14);
            connection.waitForCurrentNumLookObjectsValid();
            Assert.assertEquals(14, connection.getCurrentNumLookObjects());
        } finally {
            connection.stop();
        }
    }

    private int startServer() throws IOException {
        //noinspection SocketOpenedButNotSafelyClosed
        final ServerSocket server = new ServerSocket(0);
        final Thread thread = new Thread(new Runnable() {

            @NotNull
            private final Charset charset = Charset.forName("ISO-8859-1");

            @Override
            public void run() {
                try {
                    try (final Socket client = acceptClient(server)) {
                        final InputStream in = getInputStream(client);
                        final OutputStream out = getOutputStream(client);
                        while (true) {
                            final byte[] data = readPacket(in);
                            if (data == null) {
                                break;
                            }
                            int paramsIndex;
                            for (paramsIndex = 0; paramsIndex < data.length; paramsIndex++) {
                                if (data[paramsIndex] == (byte)' ') {
                                    break;
                                }
                            }
                            final String cmd = new String(data, 0, paramsIndex, charset);
                            if (paramsIndex < data.length && data[paramsIndex] == (byte)' ') {
                                paramsIndex++;
                            }
                            switch (cmd) {
                            case "version":
                                writeString(out, "version 1 1 info");
                                break;

                            case "setup":
                                processSetup(out, new String(data, paramsIndex, data.length-paramsIndex, charset));
                                break;

                            case "requestinfo":
                                processRequestinfo(out, new String(data, paramsIndex, data.length-paramsIndex, charset));
                                break;

                            case "toggleextendedtext":
                                // ignore
                                break;

                            case "addme":
                                processAddme(out);
                                break;

                            default:
                                Assert.fail("received unexpected command: "+cmd);
                                break;
                            }
                        }
                    }
                } catch (final IOException ex) {
                    Assert.fail(ex.getMessage());
                    throw new AssertionError(ex);
                }
            }

            @Nullable
            private byte[] readPacket(@NotNull final InputStream in) throws EOFException {
                final int tmp;
                try {
                    tmp = readByte(in);
                } catch (final EOFException ignored) {
                    return null;
                }
                final int packetLen = tmp*0x100+readByte(in);
                final byte[] data = new byte[packetLen];
                try {
                    int pos = 0;
                    while (pos < data.length) {
                        final int len = in.read(data, pos, data.length-pos);
                        if (len == -1) {
                            throw new EOFException("unexpected end of file reached");
                        }
                        pos += len;
                    }
                } catch (final IOException ex) {
                    Assert.fail(ex.getMessage());
                    throw new AssertionError(ex);
                }
                return data;
            }

            private void processSetup(@NotNull final OutputStream out, @NotNull final String params) throws IOException {
                final String[] params2 = params.split(" ", -1);
                Assert.assertEquals(0, params2.length%2);
                final StringBuilder sb = new StringBuilder("setup");
                for (int i = 0; i < params2.length; i += 2) {
                    final String key = params2[i];
                    final String value = params2[i+1];
                    if (key.equals("map2cmd") || key.equals("newmapcmd") || key.equals("facecache") || key.equals("extendedTextInfos") || key.equals("itemcmd") || key.equals("spellmon") || key.equals("tick") || key.equals("num_look_objects") || key.equals("mapsize")) {
                        sb.append(" ").append(key).append(" ").append(value);
                    } else {
                        sb.append(" ").append(key).append(" FALSE");
                    }
                }
                writeString(out, sb.toString());
            }

            private void processRequestinfo(@NotNull final OutputStream out, @NotNull final String params) throws IOException {
                if (params.equals("exp_table")) {
                    writeBytes(out, new byte[] {
                        'r',
                        'e',
                        'p',
                        'l',
                        'y',
                        'i',
                        'n',
                        'f',
                        'o',
                        ' ',
                        'e',
                        'x',
                        'p',
                        '_',
                        't',
                        'a',
                        'b',
                        'l',
                        'e',
                        ' ',
                        0,
                        1,
                    });
                } else {
                    // ignore
                }
            }

            private void processAddme(@NotNull final OutputStream out) throws IOException {
                writeString(out, "query 0 What is your name?");
                writeString(out, "addme_success");
                assert sem != null;
                sem.release();
            }

            private int readByte(@NotNull final InputStream in) throws EOFException {
                final int ch;
                try {
                    ch = in.read();
                } catch (final IOException ex) {
                    Assert.fail(ex.getMessage());
                    throw new AssertionError(ex);
                }
                if (ch == -1) {
                    throw new EOFException("EOF");
                }
                return ch;
            }

            private void writeString(@NotNull final OutputStream out, @NotNull final String s) throws IOException {
                writeBytes(out, s.getBytes(charset));
            }

            private void writeBytes(@NotNull final OutputStream out, @NotNull final byte[] b) throws IOException {
                final int len = b.length;
                out.write(len/0x100);
                out.write(len);
                out.write(b);
            }

        });
        thread.start();
        return server.getLocalPort();
    }

    @NotNull
    private static Socket acceptClient(@NotNull final ServerSocket server) {
        final Socket client;
        try {
            //noinspection SocketOpenedButNotSafelyClosed
            client = server.accept();
        } catch (final IOException ex) {
            Assert.fail(ex.getMessage());
            throw new AssertionError(ex);
        }
        return client;
    }

    @NotNull
    private static InputStream getInputStream(@NotNull final Socket socket) {
        final InputStream in;
        try {
            in = socket.getInputStream();
        } catch (final IOException ex) {
            Assert.fail(ex.getMessage());
            throw new AssertionError(ex);
        }
        return in;
    }

    @NotNull
    private static OutputStream getOutputStream(@NotNull final Socket socket) {
        final OutputStream out;
        try {
            out = socket.getOutputStream();
        } catch (final IOException ex) {
            Assert.fail(ex.getMessage());
            throw new AssertionError(ex);
        }
        return out;
    }

}