C# StringSocket.Close方法代码示例

            public void TestWordCommand5()
            {
                // Assert that an illegal word with more than 3 characters decrements the players
                // score.

                // This will coordinate communication between the threads of the test cases
                mre1 = new ManualResetEvent(false);
                mre2 = new ManualResetEvent(false);

                // Create a two clients to connect with the Boggle Server.
                TcpClient TestClient1 = new TcpClient("localhost", 2000);
                TcpClient TestClient2 = new TcpClient("localhost", 2000);

                // Create a client socket and then a client StringSocket.
                Socket ClientSocket1 = TestClient1.Client;
                Socket ClientSocket2 = TestClient2.Client;
                StringSocket ClientSS1 = new StringSocket(ClientSocket1, new UTF8Encoding());
                StringSocket ClientSS2 = new StringSocket(ClientSocket2, new UTF8Encoding());

                try
                {
                    // Connect two clients together to play Boggle.
                    ClientSS1.BeginSend("PLAY Client1\n", (e, o) => { }, null);
                    ClientSS2.BeginSend("PLAY Client2\n", (e, o) => { }, null);

                    ClientSS1.BeginReceive(CompletedReceive1, 1);
                    ClientSS2.BeginReceive(CompletedReceive2, 3);
                    Assert.AreEqual(true, mre1.WaitOne(timeout), "Timed out waiting 1");
                    Assert.AreEqual(true, mre2.WaitOne(timeout), "Timed out waiting 2");

                    // Get all of the Illegal words from the gameboard for these two players.
                    HashSet<string> IlegalWords = FindIllegalWords(GameboardString);

                    // One player plays an illegal word. Assert that the score changes for each
                    // player appropriately.
                    ClientSS1.BeginSend("WORD xxxxxx\n", (e, o) => { }, null);

                    mre1 = new ManualResetEvent(false);
                    mre2 = new ManualResetEvent(false);
                    ClientSS1.BeginReceive(CompletedReceive1, 2);
                    ClientSS2.BeginReceive(CompletedReceive2, 3);

                    Assert.AreEqual(true, mre1.WaitOne(timeout), "Timed out waiting 1");
                    Assert.AreEqual("SCORE -1 0", s1);

                    Assert.AreEqual(true, mre2.WaitOne(timeout), "Timed out waiting 2");
                    Assert.AreEqual("SCORE 0 -1", s2);
                }
                finally
                {
                    ClientSS1.Close();
                    ClientSS2.Close();
                }
            }

 /// <summary>
 /// Closes Sockets after WebPage has fully loaded.
 /// </summary>
 private void CloseSocketCallback(StringSocket ss)
 {
     if (ss != null)
     {
         ss.Close();
     }
 }

            public void TestWordCommand6()
            {
                // Test the case in which a the two clients play the same word.

                // This will coordinate communication between the threads of the test cases
                mre3 = new ManualResetEvent(false);
                mre4 = new ManualResetEvent(false);
                mre5 = new ManualResetEvent(false);
                mre6 = new ManualResetEvent(false);

                // Create a two clients to connect with the Boggle Server.
                TcpClient TestClient1 = new TcpClient("localhost", 2000);
                TcpClient TestClient2 = new TcpClient("localhost", 2000);

                // Create a client socket and then a client StringSocket.
                Socket ClientSocket1 = TestClient1.Client;
                Socket ClientSocket2 = TestClient2.Client;
                StringSocket ClientSS1 = new StringSocket(ClientSocket1, new UTF8Encoding());
                StringSocket ClientSS2 = new StringSocket(ClientSocket2, new UTF8Encoding());

                try
                {
                    // Connect two clients together to play Boggle.
                    ClientSS1.BeginSend("PLAY Client1\n", (e, o) => { }, null);
                    ClientSS2.BeginSend("PLAY Client2\n", (e, o) => { }, null);

                    ClientSS1.BeginReceive(CompletedReceive1, 1);
                    ClientSS2.BeginReceive(CompletedReceive2, 2);
                    Assert.AreEqual(true, mre1.WaitOne(timeout), "Timed out waiting 1");
                    Assert.AreEqual(true, mre2.WaitOne(timeout), "Timed out waiting 2");

                    // Get all of the legal words from the gameboard for these two players.
                    HashSet<string> LegalWords = FindLegalWords(GameboardString);

                    // One player plays a legal word. Assert that the score changes for each
                    // player appropriately.
                    ClientSS2.BeginSend("WORD " + LegalWords.ElementAt(0) + "\n", (e, o) => { }, null);

                    ClientSS1.BeginReceive(CompletedReceive3, 3);
                    ClientSS2.BeginReceive(CompletedReceive4, 4);

                    Assert.AreEqual(true, mre3.WaitOne(timeout), "Timed out waiting 3");
                    Assert.AreEqual("SCORE 0 1", s3);

                    Assert.AreEqual(true, mre4.WaitOne(timeout), "Timed out waiting 4");
                    Assert.AreEqual("SCORE 1 0", s4);

                    ClientSS1.BeginSend("WORD " + LegalWords.ElementAt(0) + "\n", (e, o) => { }, null);

                    ClientSS1.BeginReceive(CompletedReceive5, 5);
                    ClientSS2.BeginReceive(CompletedReceive6, 6);

                    Assert.AreEqual(true, mre5.WaitOne(timeout), "Timed out waiting 5");
                    Assert.AreEqual("SCORE 0 0", s5);

                    Assert.AreEqual(true, mre6.WaitOne(timeout), "Timed out waiting 6");
                    Assert.AreEqual("SCORE 0 0", s6);
                }
                finally
                {
                    ClientSS1.Close();
                    ClientSS2.Close();
                }
            }

            /// <summary>
            /// Test to determine if two clients send the proper START commands initially. 
            /// If they don't then the server will reply with an IGNORING command.
            /// </summary>
            public void IllegalClientProtocol()
            {
                // This will coordinate communication between the threads of the test cases
                mre1 = new ManualResetEvent(false);
                mre2 = new ManualResetEvent(false);

                // Create a two clients to connect with the Boggle Server.
                TcpClient TestClient1 = new TcpClient("localhost", 2000);
                TcpClient TestClient2 = new TcpClient("localhost", 2000);

                // Create a client socket and then a client string socket.
                Socket ClientSocket1 = TestClient1.Client;
                Socket ClientSocket2 = TestClient2.Client;
                StringSocket ClientSS1 = new StringSocket(ClientSocket1, new UTF8Encoding());
                StringSocket ClientSS2 = new StringSocket(ClientSocket2, new UTF8Encoding());

                try
                {
                    // Case 1: The user doesn't begin with the PLAY command.
                    ClientSS1.BeginSend("Illegal Client1\n", PlayCallback1, 1);
                    ClientSS2.BeginSend("Illegal Client2\n", PlayCallback2, 2);

                    // When the connection between the server and clients is established,
                    // the server expects the command PLAY @. But in this case we didn't
                    // send that command, so we should expect an IGNORING reply from the
                    // server.
                    ClientSS1.BeginReceive(CompletedReceive1, 1);
                    ClientSS2.BeginReceive(CompletedReceive2, 2);

                    // Assert that the server sent back the correct commands after the two clients
                    // connected.
                    Assert.AreEqual(true, mre1.WaitOne(timeout), "Timed out waiting 1");
                    Assert.AreEqual("IGNORING Illegal Client1", s1);
                    Assert.AreEqual(1, p1);
                    Assert.AreEqual(true, mre2.WaitOne(timeout), "Timed out waiting 2");
                    Assert.AreEqual("IGNORING Illegal Client2", s2);
                    Assert.AreEqual(2, p2);
                }
                finally
                {
                    ClientSS1.Close();
                    ClientSS2.Close();
                }
            }

            /// <summary>
            /// 
            /// </summary>
            public void TestClientDisconnect1()
            {
                // If at any point during a game a client disconnects or becomes inaccessible, the
                // game ends. The server should send the command "TERMINATED" to the surviving client
                // and then close the socket.

                //First test: disconnection while in a game
                // This will coordinate communication between the threads of the test cases
                mre1 = new ManualResetEvent(false);
                mre2 = new ManualResetEvent(false);
                mre3 = new ManualResetEvent(false);
                mre4 = new ManualResetEvent(false);

                // Create a two clients to connect with the Boggle Server.
                TcpClient TestClient1 = new TcpClient("localhost", 2000);
                TcpClient TestClient2 = new TcpClient("localhost", 2000);

                // Create a client socket and then a client string socket.
                Socket ClientSocket1 = TestClient1.Client;
                Socket ClientSocket2 = TestClient2.Client;
                StringSocket ClientSS1 = new StringSocket(ClientSocket1, new UTF8Encoding());
                StringSocket ClientSS2 = new StringSocket(ClientSocket2, new UTF8Encoding());

                try
                {
                    // Now our client needs to send the command PLAY @ and the server will receive it.
                    ClientSS1.BeginSend("PLAY Client1\n", PlayCallback1, 1);
                    ClientSS2.BeginSend("PLAY Client2\n", PlayCallback2, 2);

                    // When a connection has been established, the client sends a command to
                    // the server. The command is "PLAY @", where @ is the name of the player.
                    // Assert that the server receives the command PLAY @
                    ClientSS1.BeginReceive(CompletedReceive1, 1);
                    ClientSS2.BeginReceive(CompletedReceive2, 2);

                    // Assert that the server sent back the correct commands after the two clients
                    // connected.
                    string ExpectedExpression = @"^(START) [a-zA-Z]{16} \d+ [a-zA-Z1-9]+";
                    Assert.AreEqual(true, mre1.WaitOne(timeout), "Timed out waiting 1");
                    Assert.IsTrue(Regex.IsMatch(s1, ExpectedExpression));
                    Assert.AreEqual(true, mre2.WaitOne(timeout), "Timed out waiting 2");
                    Assert.IsTrue(Regex.IsMatch(s2, ExpectedExpression));

                    // Now that the game has started, we need to assert that we are receiving the
                    // Command when one client disconnects.
                    ClientSS1.BeginReceive(CompletedReceive3, 3);
                    ClientSS1.BeginReceive(CompletedReceive4, 4);
                    ClientSS2.Close();

                    Assert.AreEqual(true, mre3.WaitOne(timeout), "Timed out waiting 3");
                    Assert.AreEqual("TERMINATED", s3);
                    Assert.AreEqual(3, p3);

                    Assert.AreEqual(true, mre4.WaitOne(timeout), "Timed out waiting 4");
                    Assert.AreEqual(null, s4);
                    Assert.AreEqual(4, p4);
                }
                finally
                {
                    ClientSS1.Close();
                    ClientSS2.Close();
                }
            }

            public void TestWordCommand2()
            {
                // Test for words that are played that are less than 3 characters in
                // length. Assert that the scores didn't change.

                // This will coordinate communication between the threads of the test cases
                mre1 = new ManualResetEvent(false);
                mre2 = new ManualResetEvent(false);

                // Create a two clients to connect with the Boggle Server.
                TcpClient TestClient1 = new TcpClient("localhost", 2000);
                TcpClient TestClient2 = new TcpClient("localhost", 2000);

                // Create a client socket and then a client StringSocket.
                Socket ClientSocket1 = TestClient1.Client;
                Socket ClientSocket2 = TestClient2.Client;
                StringSocket ClientSS1 = new StringSocket(ClientSocket1, new UTF8Encoding());
                StringSocket ClientSS2 = new StringSocket(ClientSocket2, new UTF8Encoding());

                try
                {
                    // Connect two clients together to play Boggle.
                    ClientSS1.BeginSend("PLAY Client1\n", (e, o) => { }, null);
                    ClientSS2.BeginSend("PLAY Client2\n", (e, o) => { }, null);

                    ClientSS1.BeginReceive(CompletedReceive1, 1);
                    ClientSS2.BeginReceive(CompletedReceive2, 3);
                    Assert.AreEqual(true, mre1.WaitOne(timeout), "Timed out waiting 1");
                    Assert.AreEqual(true, mre2.WaitOne(timeout), "Timed out waiting 2");

                    // Get all of the legal words from the gameboard for these two players.
                    HashSet<string> LegalWords = FindXLetterWords(GameboardString, 3);

                    // Send a legal word and a word with less than 3 characters. The score
                    // shouldn't change.
                    ClientSS1.BeginSend("WORD " + LegalWords.ElementAt(0) + "\n", (e, o) => { }, null);
                    ClientSS1.BeginSend("WORD xx\n", (e, o) => { }, null);
                    ClientSS1.BeginSend("WORD " + LegalWords.ElementAt(1) + "\n", (e, o) => { }, null);

                    mre1 = new ManualResetEvent(false);
                    mre2 = new ManualResetEvent(false);

                    ClientSS1.BeginReceive(CompletedReceive1, 2);
                    ClientSS1.BeginReceive(CompletedReceive2, 2);

                    Assert.AreEqual(true, mre1.WaitOne(timeout), "Timed out waiting 1");
                    Assert.AreEqual("SCORE 1 0", s1);
                    Assert.AreEqual(true, mre2.WaitOne(timeout), "Timed out waiting 3");
                    Assert.AreEqual("SCORE 2 0", s2);

                    mre1 = new ManualResetEvent(false);
                    mre2 = new ManualResetEvent(false);

                    ClientSS2.BeginReceive(CompletedReceive1, 3);
                    ClientSS2.BeginReceive(CompletedReceive2, 3);

                    Assert.AreEqual(true, mre1.WaitOne(timeout), "Timed out waiting 1");
                    Assert.AreEqual("SCORE 0 1", s1);
                    Assert.AreEqual(true, mre2.WaitOne(timeout), "Timed out waiting 3");
                    Assert.AreEqual("SCORE 0 2", s2);
                }
                finally
                {
                    ClientSS1.Close();
                    ClientSS2.Close();
                }
            }

            public void TestWordCommand1()
            {
                // Test a single legal word played by one of the two Boggle players and
                // assert that the score incremented appropriately.

                // This will coordinate communication between the threads of the test cases
                mre1 = new ManualResetEvent(false);
                mre2 = new ManualResetEvent(false);

                // Create a two clients to connect with the Boggle Server.
                TcpClient TestClient1 = new TcpClient("localhost", 2000);
                TcpClient TestClient2 = new TcpClient("localhost", 2000);

                // Create a client socket and then a client StringSocket.
                Socket ClientSocket1 = TestClient1.Client;
                Socket ClientSocket2 = TestClient2.Client;
                StringSocket ClientSS1 = new StringSocket(ClientSocket1, new UTF8Encoding());
                StringSocket ClientSS2 = new StringSocket(ClientSocket2, new UTF8Encoding());

                try
                {
                    // Connect two clients together to play Boggle.
                    ClientSS1.BeginSend("PLAY Client1\n", (e, o) => { }, null);
                    ClientSS2.BeginSend("PLAY Client2\n", (e, o) => { }, null);

                    ClientSS1.BeginReceive(CompletedReceive1, 1);
                    ClientSS2.BeginReceive(CompletedReceive2, 3);
                    Assert.AreEqual(true, mre1.WaitOne(timeout), "Timed out waiting 1");
                    Assert.AreEqual(true, mre2.WaitOne(timeout), "Timed out waiting 2");

                    // Get all of the legal words from the gameboard for these two players.
                    HashSet<string> LegalWords = FindLegalWords(GameboardString);

                    ClientSS1.BeginSend("WORD " + LegalWords.ElementAt(0) + "\n", (e, o) => { }, null);
                    mre1 = new ManualResetEvent(false);
                    mre2 = new ManualResetEvent(false);

                    ClientSS1.BeginReceive(CompletedReceive1, 2);
                    ClientSS2.BeginReceive(CompletedReceive2, 3);

                    Assert.AreEqual(true, mre1.WaitOne(timeout), "Timed out waiting 1");
                    Assert.AreEqual("SCORE 1 0", s1);
                    Assert.AreEqual(true, mre2.WaitOne(timeout), "Timed out waiting 2");
                    Assert.AreEqual("SCORE 0 1", s2);
                }
                finally
                {
                    ClientSS1.Close();
                    ClientSS2.Close();
                }
            }

            /// <summary>
            /// Test used to determine if two Boggle clients are being paired together properly. 
            /// Two clients are paired together properly if they receive the command START $ # @, 
            /// where $ are the characters that make up the board, # is the game time, and @ is 
            /// the opponents name.
            /// </summary>
            public void PairClients()
            {
                // This will coordinate communication between the threads of the test cases
                mre1 = new ManualResetEvent(false);
                mre2 = new ManualResetEvent(false);

                // Create a two clients to connect with the Boggle Server.
                TcpClient TestClient1 = new TcpClient("localhost", 2000);
                TcpClient TestClient2 = new TcpClient("localhost", 2000);

                // Create a client socket and then a client string socket.
                Socket ClientSocket1 = TestClient1.Client;
                Socket ClientSocket2 = TestClient2.Client;
                StringSocket ClientSS1 = new StringSocket(ClientSocket1, new UTF8Encoding());
                StringSocket ClientSS2 = new StringSocket(ClientSocket2, new UTF8Encoding());

                try
                {
                    // Now our client needs to send the command PLAY @ and the server will receive it.
                    ClientSS1.BeginSend("PLAY Client1\n", PlayCallback1, 1);
                    ClientSS2.BeginSend("PLAY Client2\n", PlayCallback2, 2);

                    // When a connection has been established, the client sends a command to
                    // the server. The command is "PLAY @", where @ is the name of the player.
                    // Assert that the server receives the command PLAY @
                    ClientSS1.BeginReceive(CompletedReceive1, 1);
                    ClientSS2.BeginReceive(CompletedReceive2, 2);

                    // Assert that the server sent back the correct commands after the two clients
                    // connected.
                    string ExpectedExpression = @"^(START) [a-zA-Z]{16} \d+ [a-zA-Z1-9]+";
                    Assert.AreEqual(true, mre1.WaitOne(timeout), "Timed out waiting 1");
                    Assert.IsTrue(Regex.IsMatch(s1, ExpectedExpression));
                    Assert.AreEqual(true, mre2.WaitOne(timeout), "Timed out waiting 2");
                    Assert.IsTrue(Regex.IsMatch(s2, ExpectedExpression));
                }
                finally
                {
                    ClientSS1.Close();
                    ClientSS2.Close();
                }
            }

        /// <summary>
        /// Registers userName in server. Guarantees client username registration. Used if register fails.
        /// </summary>
        /// <param name="userName"></param>
        /// <param name="port"></param>
        /// <param name="serverIP"></param>
        /// <param name="e"></param>
        public static void registerUserAsAdmin(string userName, string spreadsheet, int port, IPAddress serverIP, Encoding e)
        {
            //Connecting client to server and establishing a socket
            TcpClient client = new TcpClient();
            client.Connect(serverIP, port);
            StringSocket socket = new StringSocket(client.Client, e);

            //Register userName using sysadmin workaround
            socket.BeginSend("connect sysadmin " + spreadsheet + "\n", (ee, pp) => { }, null);
            socket.BeginSend("register " + userName + "\n", (ee, pp) => { }, null);
            socket.Close();
            socket = null;
        }