Fatal编程技术网
  • java/
  • 打开客户端服务器-Java时出错

打开客户端服务器-Java时出错

java server

打开客户端服务器-Java时出错,java,client-server,client,server,Java,Client Server,Client,Server,我正在编写一个服务器程序，试图猜测客户机拥有的数字。服务器从客户端接收到一个低和高的数字（相隔300），并使用二进制搜索算法最多9次来尝试确定该数字。我在一些测试用例“错误打开客户机服务器”中遇到错误。当单独运行时，大多数测试用例都通过了，但按顺序运行它们却没有通过。我相信正确地打开和关闭套接字和服务器会有问题，但似乎无法解决。这是我的密码： import java.io.IOException; import java.io.PrintWriter; import java.net.Serve

我正在编写一个服务器程序，试图猜测客户机拥有的数字。服务器从客户端接收到一个低和高的数字（相隔300），并使用二进制搜索算法最多9次来尝试确定该数字。我在一些测试用例“错误打开客户机服务器”中遇到错误。当单独运行时，大多数测试用例都通过了，但按顺序运行它们却没有通过。我相信正确地打开和关闭套接字和服务器会有问题，但似乎无法解决。这是我的密码：

import java.io.IOException;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Random;
import java.util.Scanner;

public class GuessingServer {
    public static void main(String[] args)
    {
        try{
            ServerSocket server;

            server = new ServerSocket( 5150 );
            System.out.println("awaiting client...");
            Socket client = server.accept();
            System.out.println("client connected");
            Scanner in  = new Scanner    ( client.getInputStream() );
            PrintWriter  out = new PrintWriter( client.getOutputStream(), true );
            String first = in.next();
            int high = in.nextInt();
            int low = Integer.parseInt(first);

            boolean serverRun = true;

            while(serverRun == true)
            {
                    if(!first.equals("SHUT DOWN"))
                    {
                        System.out.println(low);
                        System.out.println(high);

                            int bNum = ((high - low) / 2) + low;
                            out.println(bNum);
                            System.out.println(bNum);
                            String temp = in.next();

                            if(temp.equals("high"))
                            {
                                high = bNum;
                                System.out.println(temp + ": ");
                                System.out.println(high);

                                i++;
                            }
                            else if(temp.equals("low"))
                            {
                                low = bNum;
                                System.out.println(temp + ": ");
                                System.out.println(low);
                                i++;
                            }
                            else if(temp.equals("won"))
                            {
                                System.out.println(temp);
                                serverRun = false;
                            }
                            else if(temp.equals("lost"))
                            {

                                System.out.println(temp);
                                serverRun = false;
                            }
                    }
                    else
                    {
                        serverRun = false;
                    }
                }
            client.close();
            in.close();
            out.close();
            server.close();
        }
        catch(IOException e)
        {
        }
    }
}
以下是JUnit测试：

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;

import java.io.IOException;
import java.io.PrintWriter;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.net.Socket;
import java.util.NoSuchElementException;
import java.util.Random;
import java.util.Scanner;

import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.FixMethodOrder;
import org.junit.Test;
import org.junit.runners.MethodSorters;

@FixMethodOrder(MethodSorters.NAME_ASCENDING)
public class GuessingServerTest {
    @Test
    public void testReflection() {
        Class<?> iClass  = GuessingServer.class;
        Field[]  iFields = iClass.getDeclaredFields();

        for (Field f : iFields) {
            if (!f.isSynthetic()) {
                assertTrue ( "Field \""+f.getName()+"\" should be private", Modifier.isPrivate( f.getModifiers() ));
                assertFalse( "Field \""+f.getName()+"\" can't be static",   Modifier.isStatic ( f.getModifiers() ));
            }
        }
    }

    @BeforeClass
    public static void startServer() {
        // run server
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                GuessingServer.main( new String[]{ } );
            }
        });
        thread.start();
    }
    @Before
    public void waitTwoSecondsBetweenTests() {
        try {
            Thread.sleep( 2000 );
        } 
        catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    @Test(timeout=3000)
    public void testA_WinningAfter1Try() {
        try {
            // run client
            Socket      socket  = new Socket( "localhost", 5150 );
            Scanner     scanner = new Scanner    ( socket.getInputStream() );
            PrintWriter writer  = new PrintWriter( socket.getOutputStream(), true );

            writer.println( "101 401" );
            // try 1
            int actual = scanner.nextInt();
            assertEquals( "Incorrect result", 251, actual );

            writer.println( "won" );

            socket .close();
            scanner.close();
        }
        catch (IOException e) {
            e.printStackTrace();
            fail( "Error opening client socket" );
        }
        catch (NoSuchElementException e) {
            e.printStackTrace();
            fail( "The server didn't return a value" );
        }
    }

    @Test(timeout=3000)
    public void testB_WinningAfter2Tries() {
        try {
            // run client
            Socket      socket  = new Socket( "localhost", 5150 );
            Scanner     scanner = new Scanner    ( socket.getInputStream() );
            PrintWriter writer  = new PrintWriter( socket.getOutputStream(), true );

            writer.println( "37 337" );
            // try 1
            int actual = scanner.nextInt();
            assertEquals( "Incorrect result", 187, actual );
            writer.println( "low" );
            // try 2
            actual = scanner.nextInt();
            assertEquals( "Incorrect result", 262, actual );
            writer.println( "high" );
            // try 3
            actual = scanner.nextInt();
            assertEquals( "Incorrect result", 224, actual );
            writer.println( "high" );
            // try 4
            actual = scanner.nextInt();
            assertEquals( "Incorrect result", 205, actual );
            writer.println( "low" );
            // try 5
            actual = scanner.nextInt();
            assertEquals( "Incorrect result", 214, actual );
            writer.println( "high" );
            // try 6
            actual = scanner.nextInt();
            assertEquals( "Incorrect result", 209, actual );
            writer.println( "high" );
            // try 7
            actual = scanner.nextInt();
            assertEquals( "Incorrect result", 207, actual );
            writer.println( "high" );
            // try 8
            actual = scanner.nextInt();
            assertEquals( "Incorrect result", 206, actual );
            writer.println( "won" );

            socket .close();
            scanner.close();
        }
        catch (IOException e) {
            e.printStackTrace();
            fail( "Error opening client socket" );
        }
        catch (NoSuchElementException e) {
            e.printStackTrace();
            fail( "The server didn't return a value" );
        }
    }

    @Test(timeout=3000)
    public void testC_PlayingARandomGame() throws IOException {
        final int    UPPER  = 200;
        final int    RANGE  = 300;
        final int    TRIES  =   9;

        final Random random = new Random();
        try {
            // run client
            Socket      socket  = new Socket( "localhost", 5150 );
            Scanner     scanner = new Scanner    ( socket.getInputStream() );
            PrintWriter writer  = new PrintWriter( socket.getOutputStream(), true );

            int low    = random.nextInt( UPPER );
            int hi     = low + RANGE;
            int number = low + random.nextInt( RANGE );

            writer.println( low + " " + hi );

            int     tries    = 0;
            boolean gameOver = false;

            while (!gameOver) {
                int guess = scanner.nextInt();
                if (guess == number) {
                    writer.println( "won" );
                    gameOver = true;
                }
                else {
                    if (++tries > TRIES) {
                        writer.println( "lose" );
                        gameOver = true;
                    }
                    else {
                        if (guess < number) {
                            writer.println( "low" );
                        }
                        else {
                            writer.println( "high" );
                        }
                    }
                }
            }
            socket .close();
            scanner.close();
        }
        catch (IOException e) {
            e.printStackTrace();
            fail( "Error opening client socket" );
        }
        catch (NoSuchElementException e) {
            e.printStackTrace();
            fail( "The server didn't return a value" );
        }
    }

    @Test(expected = IOException.class)
    public void testD_RunsLast_ServerShutsDown() throws IOException {
        try {
            // running client #1...shuts down server
            Socket      socket  = new Socket( "localhost", 5150 );
            PrintWriter writer  = new PrintWriter( socket.getOutputStream(), true );

            writer.println( "SHUT DOWN" );

            socket.close();
        }
        catch (IOException e) {
            e.printStackTrace();
            fail( "Error opening client socket" );
        }
        waitTwoSecondsBetweenTests();

        // running client #2...should throw exception (server should have stopped)
        new Socket( "localhost", 5150 ).close();
        fail( "Socket should not connect after server was shut down" );
    }
}

导入静态org.junit.Assert.assertEquals；
导入静态org.junit.Assert.assertFalse；
导入静态org.junit.Assert.assertTrue；
导入静态org.junit.Assert.fail；
导入java.io.IOException；
导入java.io.PrintWriter；
导入java.lang.reflect.Field；
导入java.lang.reflect.Modifier；
导入java.net.Socket；
导入java.util.NoSuchElementException；
导入java.util.Random；
导入java.util.Scanner；
导入org.junit.Before；
导入org.junit.BeforeClass；
导入org.junit.FixMethodOrder；
导入org.junit.Test；
导入org.junit.runners.MethodSorters；
@FixMethodOrder（MethodSorters.NAME\u升序）
公共类猜测服务器测试{
@试验
公共void testReflection（）{
类iClass=GuessingServer.Class；
字段[]iFields=iClass.getDeclaredFields（）；
用于（字段f:iFields）{
如果（！f.isSynthetic（））{
assertTrue（“字段\”“+f.getName（）+”\“应该是私有的”，Modifier.isPrivate（f.getModifiers（））；
assertFalse（“字段\”“+f.getName（）+”\“不能是静态的”，Modifier.isStatic（f.getModifiers（））；
}
}
}
@课前
公共静态void startServer（）{
//运行服务器
Thread Thread=新线程（new Runnable（）{
@凌驾
公开募捐{
main（新字符串[]{}）；
}
});
thread.start（）；
}
@以前
public void waitTwoSecondsBetween测试（）之间{
试一试{
《睡眠》（2000年）；
} 
捕捉（中断异常e）{
e、 printStackTrace（）；
}
}
@测试（超时=3000）
公共无效测试1日后赢取（）{
试一试{
//运行客户端
套接字=新套接字（“localhost”，5150）；
Scanner Scanner=新的扫描仪（socket.getInputStream（））；
PrintWriter writer=新的PrintWriter（socket.getOutputStream（），true）；
writer.println（“101 401”）；
//试试1
int实际值=scanner.nextInt（）；
资产质量（“结果不正确”，251，实际）；
writer.println（“韩元”）；
socket.close（）；
scanner.close（）；
}
捕获（IOE异常）{
e、 printStackTrace（）；
失败（“打开客户端套接字时出错”）；
}
捕获（无接触元素例外e）{
e、 printStackTrace（）；
失败（“服务器没有返回值”）；
}
}
@测试（超时=3000）
公共无效测试B_WinningAfterries（）{
试一试{
//运行客户端
套接字=新套接字（“localhost”，5150）；
Scanner Scanner=新的扫描仪（socket.getInputStream（））；
PrintWriter writer=新的PrintWriter（socket.getOutputStream（），true）；
writer.println（“37337”）；
//试试1
int实际值=scanner.nextInt（）；
资产质量（“结果不正确”，187，实际）；
writer.println（“低”）；
//试试2
实际值=scanner.nextInt（）；
资产质量（“结果不正确”，262，实际）；
writer.println（“高”）；
//试试3
实际值=scanner.nextInt（）；
资产质量（“结果不正确”，224，实际）；
writer.println（“高”）；
//试试4
实际值=scanner.nextInt（）；
资产质量（“结果不正确”，205，实际）；
writer.println（“低”）；
//试试5
实际值=scanner.nextInt（）；
资产质量（“结果不正确”，214，实际）；
writer.println（“高”）；
//试试6
实际值=scanner.nextInt（）；
资产质量（“结果不正确”，209，实际）；
writer.println（“高”）；
//试试7
实际值=scanner.nextInt（）；
assertEquals（“结果不正确”，207，实际）；
writer.println（“高”）；
//试试8
实际值=scanner.nextInt（）；
资产质量（“结果不正确”，206，实际）；
writer.println（“韩元”）；
socket.close（）；
scanner.close（）；
}
捕获（IOE异常）{
e、 printStackTrace（）；
失败（“打开客户端套接字时出错”）；
}
捕获（无接触元素例外e）{
e、 printStackTrace（）；
失败（“服务器没有返回值”）；
}
}
@测试（超时=3000）
public void testC_playingrandomGame（）引发IOException{
最终整数上限=200；
最终整数范围=300；
最终积分=9；
最终随机数=新随机数（）；
试一试{
//运行客户端
套接字=新套接字（“localhost”，5150）；
Scanner Scanner=新的扫描仪（socket.getInputStream（））；
PrintWriter writer=新的PrintWriter（socket.getOutputStream（），true）；
int-low=随机的nextInt（上）；
int hi=低+范围；
整数=低+随机.nextInt（范围）；
writer.println（低+“”+hi）；
int=0；
布尔gameOver=false；
而（！gameOver）{
int guess=scanner.nextInt（）；
如果（猜测）=