C# SocketPair.TearDown方法代码示例

        public MFTestResults SocketsEnums8_SocketFlags_Peek()
        {
            /// <summary>
            /// 1. Sends TCP data using the Peek flag 
            /// 2. Verifies that the correct exception is thrown
            /// Further testing would require harness alteration
            /// </summary>
            ///
            bool isAnyCatch = false;
            try
            {
                try
                {
                    SocketPair testSockets = new SocketPair(ProtocolType.Tcp, SocketType.Stream);
                    testSockets.Startup(0, 0);
                    testSockets.socketServer.Listen(1);
                    testSockets.socketClient.Connect(testSockets.epServer);

                    int cBytes = testSockets.socketClient.Send(testSockets.bufSend);

                    using (Socket sock = testSockets.socketServer.Accept())
                    {
                        cBytes = sock.Receive(testSockets.bufReceive, SocketFlags.Peek);
                        Log.Comment("Checking Peek data");
                        testSockets.AssertDataReceived(cBytes);
                        int cBytesAgain = sock.Receive(testSockets.bufReceive);

                        if(cBytesAgain < cBytes)
                            throw new Exception( 
                                "Peek returns more bytes than the successive read" );
                    }
                    testSockets.AssertDataReceived(cBytes);
                    testSockets.TearDown();
                    testSockets = null;
                }
                catch (SocketException)
                {
                    isAnyCatch = true;
                }
            }
            catch (System.Exception e)
            {
                isAnyCatch = true;
                Log.Comment("Incorrect exception caught: " + e.Message);
            }
            if (!isAnyCatch)
            {
                Log.Comment("No exception caught");
            }
            return (isAnyCatch ? MFTestResults.Fail : MFTestResults.Pass);
        }

 public MFTestResults SocketsEnums11_SocketOptionName_MulticastLoopback_UDP()
 {
     SocketPair testSockets = new SocketPair(ProtocolType.Udp, SocketType.Dgram);
     Log.Comment("Testing MulticastLoopback with UDP");
     bool testResult = TestSocketOption(testSockets, SocketOptionLevel.IP, 
         SocketOptionName.MulticastLoopback, boolData, true);
     testSockets.TearDown();
     return (testResult ? MFTestResults.Pass : MFTestResults.Fail);
 }

        public MFTestResults SocketTest5_BasicRAW()
        {
            /// <summary>
            /// 1. Starts a server socket listening for Raw
            /// 2. Starts a client socket connected to the server
            /// 3. Verifies that data can be correctly sent and recieved
            /// </summary>
            ///
            bool testResult = true;
            SocketPair testSockets = null;
            try
            {
                testSockets = new SocketPair(ProtocolType.Raw, SocketType.Raw);
                testSockets.Startup(0, 0);
                testSockets.socketServer.Listen(1);
                testSockets.socketClient.Connect(testSockets.epServer);
                int cBytes = testSockets.socketClient.Send(testSockets.bufSend);

                if (cBytes != testSockets.bufSend.Length)
                    throw new Exception("Send failed, wrong length");

                using (Socket sock = testSockets.socketServer.Accept())
                {
                    if (sock.LocalEndPoint == null)
                        throw new Exception("LocalEndPoint is null");
                    //Fix?
                    if (testSockets.socketServer.LocalEndPoint.ToString() !=
                        sock.LocalEndPoint.ToString())
                        throw new Exception("LocalEndPoint is incorrect");

                    if (sock.RemoteEndPoint == null)
                        throw new Exception("RemoteEndPoint is null");
                    if (testSockets.socketClient.LocalEndPoint.ToString() !=
                        sock.RemoteEndPoint.ToString())
                        throw new Exception("RemoteEndPoint is incorrect");

                    cBytes = sock.Available;

                    if (cBytes != testSockets.bufSend.Length)
                        throw new Exception("Send failed, wrong length");

                    cBytes = sock.Receive(testSockets.bufReceive);
                }

                testSockets.AssertDataReceived(cBytes);
            }
            catch (SocketException e)
            {
                Log.Comment("Caught exception: " + e.Message);
                Log.Comment("ErrorCode: " + ((SocketException)e).ErrorCode);
            }
            catch (Exception e)
            {
                Log.Comment("Caught exception: " + e.Message);
                if (e.GetType() == Type.GetType("System.Net.Sockets.SocketException"))
                    Log.Comment("ErrorCode: " + ((SocketException)e).ErrorCode);
                testResult = false;
            }
            finally
            {
                if (testSockets != null)
                {
                    testSockets.TearDown();
                    testSockets = null;
                }
            }

            return (testResult ? MFTestResults.Pass : MFTestResults.Fail);
        }

        public MFTestResults SocketTest2_BasicUDP()
        {
            /// <summary>
            /// 1. Starts a server socket listening for UDP
            /// 2. Starts a client socket sending UDP packets
            /// 3. Verifies that data can be correctly sent and recieved
            /// </summary>
            ///
            bool testResult = true;
            SocketPair testSockets = null;
            try
            {
                testSockets = new SocketPair(ProtocolType.Udp, SocketType.Dgram);
                Log.Comment("Testing with port 0");
                testSockets.Startup(0, 0);

                int cBytes = testSockets.socketClient.SendTo(
                        testSockets.bufSend, testSockets.epServer);

                if (cBytes != testSockets.bufSend.Length)
                    throw new Exception("Send failed, wrong length");

                EndPoint epFrom = new IPEndPoint(IPAddress.Any, 0);
                cBytes = testSockets.socketServer.ReceiveFrom(testSockets.bufReceive, ref epFrom);

                if (testSockets.epClient.Address.ToString() != ((IPEndPoint)epFrom).Address.ToString())
                    throw new Exception("Bad address");
            }
            catch (SocketException e)
            {
                if (e.ErrorCode == 10047)
                {
                    Log.Comment("Address family not supported by protocol family.");
                    Log.Comment("This exception is thrown by the device driver that doesnt' implement Loopback for UDP");
                }
                else
                {
                    testResult = false;
                    Log.Comment("Fail for any other error codes that we don't know about");
                }
            }
            catch (Exception e)
            {
                Log.Comment("Caught exception: " + e.Message);
                if (e.GetType() == Type.GetType("System.Net.Sockets.SocketException"))
                    Log.Comment("ErrorCode: " + ((SocketException)e).ErrorCode);
                testResult = false;
            }
            finally
            {
                if (testSockets != null)
                {
                    testSockets.TearDown();
                    testSockets = null;
                }
            }
            return (testResult ? MFTestResults.Pass : MFTestResults.Fail);
        }

//.........这里部分代码省略.........
                    byte[] local = localAddress.GetAddressBytes();

                    byte[] multicastOpt = new byte[] {     224,      100,        1,        1,
                                                          local[0], local[1], local[2], local[3]};

                    testSockets.socketClient.SetSocketOption(SocketOptionLevel.IP,
                        SocketOptionName.DropMembership, multicastOpt);
                }
                catch (SocketException se)
                {
                    if (se.ErrorCode != (int)SocketError.ProtocolOption)
                    {
                        Log.Comment("Caught exception: " + se.Message);
                        if (se.GetType() == Type.GetType("System.Net.Sockets.SocketException"))
                            Log.Comment("ErrorCode: " + se.ErrorCode);
                        testResult = false;
                    }
                }
                catch (Exception e)
                {
                    Log.Comment("Caught exception: " + e.Message);
                    if (e.GetType() == Type.GetType("System.Net.Sockets.SocketException"))
                        Log.Comment("ErrorCode: " + ((SocketException)e).ErrorCode);
                    testResult = false;
                }
                try
                {
                    testSockets.socketClient.SetSocketOption(SocketOptionLevel.Socket,
                        SocketOptionName.ReuseAddress, true);
                }
                catch (SocketException se)
                {
                    if (se.ErrorCode != (int)SocketError.ProtocolOption)
                    {
                        Log.Comment("Caught exception: " + se.Message);
                        if (se.GetType() == Type.GetType("System.Net.Sockets.SocketException"))
                            Log.Comment("ErrorCode: " + se.ErrorCode);
                        testResult = false;
                    }
                }
                catch (Exception e)
                {
                    Log.Comment("Caught exception: " + e.Message);
                    if (e.GetType() == Type.GetType("System.Net.Sockets.SocketException"))
                        Log.Comment("ErrorCode: " + ((SocketException)e).ErrorCode);
                    testResult = false;
                }
                try
                {
                    testSockets.socketClient.SetSocketOption(SocketOptionLevel.Socket,
                        SocketOptionName.ReceiveBuffer, 0x1024);
                }
                catch (SocketException se)
                {
                    if (se.ErrorCode != (int)SocketError.ProtocolOption)
                    {
                        Log.Comment("Caught exception: " + se.Message);
                        if (se.GetType() == Type.GetType("System.Net.Sockets.SocketException"))
                            Log.Comment("ErrorCode: " + se.ErrorCode);
                        testResult = false;
                    }
                }
                catch (Exception e)
                {
                    Log.Comment("Caught exception: " + e.Message);
                    if (e.GetType() == Type.GetType("System.Net.Sockets.SocketException"))
                        Log.Comment("ErrorCode: " + ((SocketException)e).ErrorCode);
                    testResult = false;
                }

                Log.Comment("Testing with port 0");
                testSockets.Startup(0, 0);

                int cBytes = testSockets.socketClient.SendTo(testSockets.bufSend,
                    testSockets.epServer);

                if (cBytes != testSockets.bufSend.Length)
                    throw new Exception("Send failed, wrong length");


                EndPoint epFrom = new IPEndPoint(IPAddress.Any, 0);
                cBytes = testSockets.socketServer.ReceiveFrom(
                    testSockets.bufReceive, ref epFrom);

                if (testSockets.epClient.Address.ToString() !=
                    ((IPEndPoint)epFrom).Address.ToString())
                    throw new Exception("Bad address");

                testSockets.TearDown();
                testSockets = null;
            }
            catch (Exception e)
            {
                Log.Comment("Caught exception: " + e.Message);
                if (e.GetType() == Type.GetType("System.Net.Sockets.SocketException"))
                    Log.Comment("ErrorCode: " + ((SocketException)e).ErrorCode);
                testResult = false;
            }
            return (testResult ? MFTestResults.Pass : MFTestResults.Fail);
        }

        public MFTestResults SocketTest10_TCPPoll()
        {
            /// <summary>
            /// 1. Starts a server socket listening for TCP
            /// 2. Starts a client socket connected to the server
            /// 3. Transfers some data
            /// 4. Verifies that Poll returns correct results after each individual
            /// function is called.
            /// </summary>
            ///
            bool testResult = true;

            try
            {
                SocketPair testSockets = new SocketPair(ProtocolType.Tcp, SocketType.Stream);
                Log.Comment("Testing with port 0");
                testSockets.Startup(0, 0);

                testSockets.socketServer.Listen(1);
                Log.Comment("Listen called");
                
                testSockets.socketClient.Connect(testSockets.epServer);
                Log.Comment("Connect called");

                int cBytes = testSockets.socketClient.Send(testSockets.bufSend);
                Log.Comment("Send called");
                testResult = (testSockets.socketClient.Poll(1000, SelectMode.SelectWrite) == true);
                testResult = (testSockets.socketServer.Poll(1000, SelectMode.SelectRead) == true);

                using (Socket sock = testSockets.socketServer.Accept())
                {
                    Log.Comment("Accept called");
                    testResult = (testSockets.socketClient.Poll(1000, SelectMode.SelectWrite) == true);

                    cBytes = sock.Available;
                    Log.Comment("Available bytes assigned");
                    testResult = (testSockets.socketClient.Poll(1000, SelectMode.SelectWrite) == true);

                    cBytes = sock.Receive(testSockets.bufReceive);
                    Log.Comment("Recieve called");
                    testResult = (testSockets.socketClient.Poll(1000, SelectMode.SelectWrite) == true);
                }

                testSockets.AssertDataReceived(cBytes);
                testSockets.TearDown();
                testSockets = null;
            }
            catch (Exception e)
            {
                Log.Comment("Caught exception: " + e.Message);
                if (e.GetType() == Type.GetType("System.Net.Sockets.SocketException"))
                    Log.Comment("ErrorCode: " +
                        ((SocketException)e).ErrorCode); testResult = false;
            }

            return (testResult ? MFTestResults.Pass : MFTestResults.Fail);
        }

        public MFTestResults SocketsEnums11_SocketOptionName_Debug_UDP()
        {
            //don't run this on emulator since its not supported.
            if (Microsoft.SPOT.Hardware.SystemInfo.SystemID.SKU == 3)
                return MFTestResults.Skip;

            SocketPair testSockets = new SocketPair(ProtocolType.Udp, SocketType.Dgram);
            Log.Comment("Testing Debug with UDP");
            bool testResult = TestSocketOption(testSockets, SocketOptionLevel.Socket, 
                SocketOptionName.Debug, boolData, false);
            testSockets.TearDown();
            return (testResult ? MFTestResults.Pass : MFTestResults.Fail);
        }

        public MFTestResults SocketsEnums11_SocketOptionName_AddSourceMembership_UDP()
        {
            //don't run this on emulator since its not supported.
            if (Microsoft.SPOT.Hardware.SystemInfo.SystemID.SKU == 3)
                return MFTestResults.Skip;

            NetworkInterface[] inter = NetworkInterface.GetAllNetworkInterfaces();
            IPAddress localAddress = SocketTools.ParseAddress(inter[0].IPAddress);
            byte[] local = localAddress.GetAddressBytes();
            byte[] multicastOpt = new byte[] {    224,      100,        1,        1,
                                                          local[0], local[1], local[2], local[3]};

            SocketPair testSockets = new SocketPair(ProtocolType.Udp, SocketType.Dgram);
            Log.Comment("Testing AddSourceMembership with UDP");
            bool testResult = TestSocketOption(testSockets, SocketOptionLevel.IP, 
                SocketOptionName.AddSourceMembership, multicastOpt, false);
            testSockets.TearDown();
            return (testResult ? MFTestResults.Pass : MFTestResults.Fail);
        }

        public MFTestResults SocketsEnums11_SocketOptionName_DropSourceMembership_TCP()
        {
            NetworkInterface[] inter = NetworkInterface.GetAllNetworkInterfaces();
            IPAddress localAddress = SocketTools.ParseAddress(inter[0].IPAddress);
            byte[] local = localAddress.GetAddressBytes();
            byte[] multicastOpt = new byte[] {    224,      100,        1,        1,
                                                          local[0], local[1], local[2], local[3]};

            SocketPair testSockets = new SocketPair(ProtocolType.Tcp, SocketType.Stream);
            Log.Comment("Testing DropSourceMembership with TCP");
            bool testResult = TestSocketOption(testSockets, SocketOptionLevel.IP, 
                SocketOptionName.DropSourceMembership, multicastOpt, false);
            testSockets.TearDown();
            return (testResult ? MFTestResults.Pass : MFTestResults.Fail);
        }

 public MFTestResults SocketsEnums11_SocketOptionName_DontFragment_TCP()
 {
     SocketPair testSockets = new SocketPair(ProtocolType.Tcp, SocketType.Stream);
     Log.Comment("Testing DontFragment with TCP");
     bool testResult = TestSocketOption(testSockets, SocketOptionLevel.IP, 
         SocketOptionName.DontFragment, boolData, true);
     testSockets.TearDown();
     return (testResult ? MFTestResults.Pass : MFTestResults.Fail);
 }

        public MFTestResults SocketsEnums15_SON_SendBuffer()
        {
            /// <summary>
            /// 1. Sends a message of size SendBuffer
            /// 2. Verifies that it transferred correctly
            /// 1. Sends a message of size SendBuffer+1
            /// 2. Verifies that the correct exception is thrown
            /// </summary>
            ///
            bool testResult = true;
            byte[] buf = new byte[4];
            int number;
            try
            {
                int sendBufferValue1 = 1024;
                int sendBufferValue2 = 512;

                SocketPair testSockets = new SocketPair(ProtocolType.Tcp, SocketType.Stream);
                testSockets.socketClient.SetSocketOption(
                    SocketOptionLevel.Socket, SocketOptionName.SendBuffer, sendBufferValue1);
                testSockets.socketClient.GetSocketOption(
                    SocketOptionLevel.Socket, SocketOptionName.SendBuffer, buf);
                number = (int)buf[0] + (int)(buf[1]<<8) + (int)(buf[2]<<16) + (int)(buf[3]<<24);
                
                if(number != sendBufferValue1)
                        throw new System.Exception("ReceiveBuffer option was not set correctly");

                testSockets.socketClient.SetSocketOption(
                    SocketOptionLevel.Socket, SocketOptionName.SendBuffer, sendBufferValue2);
                testSockets.socketClient.GetSocketOption(
                    SocketOptionLevel.Socket, SocketOptionName.SendBuffer, buf);
                number = (int)buf[0] + (int)(buf[1]<<8) + (int)(buf[2]<<16) + (int)(buf[3]<<24);
                
                if(number != sendBufferValue2)
                        throw new System.Exception("ReceiveBuffer option was not set correctly");

                Log.Comment("ReceiveBuffer " + number.ToString() );
                   
                testSockets.Startup(0, 0);

                testSockets.bufSend    = new byte[number];
                testSockets.bufReceive = new byte[number];

                testSockets.socketServer.Listen(1);
                testSockets.socketClient.Connect(testSockets.epServer);
                int cBytes = testSockets.socketClient.Send(testSockets.bufSend);
                if (cBytes != testSockets.bufSend.Length)
                    throw new System.Exception("Send failed, wrong length");

                using (Socket sock = testSockets.socketServer.Accept())
                {
                    if (sock.LocalEndPoint == null)
                        throw new System.Exception("LocalEndPoint is null");

                    if (testSockets.socketServer.LocalEndPoint.ToString() != 
                        sock.LocalEndPoint.ToString())
                        throw new System.Exception("LocalEndPoint is incorrect");

                    if (sock.RemoteEndPoint == null)
                        throw new System.Exception("RemoteEndPoint is null");
                    if (testSockets.socketClient.LocalEndPoint.ToString() != 
                        sock.RemoteEndPoint.ToString())
                        throw new System.Exception("RemoteEndPoint is incorrect");

                    //wait a second to ensure the socket is available
                    System.Threading.Thread.Sleep(1000);  

                    cBytes = sock.Available;
                    if (cBytes != testSockets.bufSend.Length)
                        throw new System.Exception("Send failed, wrong length");

                    cBytes = sock.Receive(testSockets.bufReceive);
                }
                testSockets.AssertDataReceived(cBytes);
                testSockets.TearDown();
                testSockets = null;
            }
            catch (System.Exception e)
            {
                Log.Comment("Caught exception: " + e.Message);
                if (e.GetType() == Type.GetType("System.Net.Sockets.SocketException"))
                    Log.Comment("ErrorCode: " + ((SocketException)e).ErrorCode); 
                
                testResult = false;
            }
            return (testResult ? MFTestResults.Pass : MFTestResults.Fail);
        }

        public MFTestResults SocketsEnums13_SON_Broadcast()
        {
            /// <summary>
            /// 1. Starts a UDP client broadcasting 
            /// 2. Verifies that Broadcast is correct before and after
            /// </summary>
            ///
            bool testResult = false;
            try
            {
                SocketPair testSockets1 = new SocketPair(ProtocolType.Udp, SocketType.Dgram);
                int clientPort1 = SocketTools.nextPort;
                int serverPort1 = SocketTools.nextPort;
                int tempPort1 = SocketTools.nextPort;
                IPEndPoint epBroadcast1 = new IPEndPoint(
                    SocketTools.DottedDecimalToIp(
                    (byte)255, (byte)255, (byte)255, (byte)255), tempPort1);

                Log.Comment("SetSocketOption socket, broadcast, false");
                testSockets1.socketClient.SetSocketOption(
                    SocketOptionLevel.Socket, SocketOptionName.Broadcast, false);

                try
                {
                    Log.Comment("SendTo epBroadcast1");
                    testSockets1.socketClient.SendTo(
                        new byte[] { 0x01, 0x02, 0x03 }, epBroadcast1);
                    Log.Comment("Error, this should never get displayed.  An exception should have been thrown.");
                }
                catch (SocketException e)
                {
                    Log.Comment("Error code: " + e.ErrorCode);
                    Log.Comment("Correctly threw exception trying to broadcast from socket that has had broadcast turned off.");
                    testResult = true;
                }
                catch (Exception e)
                {
                    Log.Comment("Incorrect exception thrown: " + e.Message);
                }
                finally
                {
                    Log.Comment("Tear down the socket");
                    testSockets1.TearDown();
                }
                //--//

                SocketPair testSockets2 = new SocketPair(ProtocolType.Udp, SocketType.Dgram);
                int clientPort2 = SocketTools.nextPort;
                int serverPort2 = SocketTools.nextPort;
                int tempPort2 = SocketTools.nextPort;
                IPEndPoint epBroadcast2 = new IPEndPoint(
                    SocketTools.DottedDecimalToIp(
                    (byte)255, (byte)255, (byte)255, (byte)255), tempPort2);

                Log.Comment("SetSocketOption socket, broadcast, true");
                testSockets2.socketClient.SetSocketOption(
                    SocketOptionLevel.Socket,SocketOptionName.Broadcast, true);

                try
                {
                    Log.Comment("SendTo epBroadcast1");
                    testSockets2.socketClient.SendTo(
                        new byte[] { 0x01, 0x02, 0x03 }, epBroadcast2);
                }
                catch (SocketException e)
                {
                    Log.Comment("Error code: " + e.ErrorCode);
                    if (e.ErrorCode == 10047)
                    {
                        Log.Comment("Some drivers do not like this option being set.  Allow them to throw this exception");
                        testResult &= true;
                    }
                    else
                    {
                        Log.Comment("Incorrectly threw exception trying to broadcast from socket that has had broadcast turned on.");
                        testResult = false;
                    }
                }
                catch (Exception e)
                {
                    Log.Comment("Incorrect exception thrown: " + e.Message);
                }
                finally
                {
                    Log.Comment("Tear down the socket");
                    testSockets2.TearDown();
                }
            }
            catch (SocketException e)
            {
                Log.Comment("SocketException ErrorCode: " + e.ErrorCode);
                if (e.ErrorCode == 10047)
                {
                    Log.Comment("Address family not supported by protocol family.");
                    Log.Comment("This exception is thrown by the device driver that doesnt' implement Loopback for UDP");
                }
                else
                {
                    Log.Comment("Fail for any other error codes that we don't know about");
                    testResult = false;
//.........这里部分代码省略.........

        public MFTestResults SocketsEnums12_SON_AcceptConnection()
        {
            /// <summary>
            /// 1. Starts a server socket listening for TCP
            /// 2. Verifies that AcceptConnection is correct before and after
            /// </summary>
            ///
            bool testResult = true;
            try
            {
                byte[] buf = new byte[4];
                int number;

                SocketPair testSockets = new SocketPair(ProtocolType.Tcp, SocketType.Stream);
                testSockets.Startup(0, 0);
                testSockets.socketServer.GetSocketOption(
                    SocketOptionLevel.Socket, SocketOptionName.AcceptConnection, buf );
                number = (int)buf[0] + (int)(buf[1]<<8) + (int)(buf[2]<<16) + (int)(buf[3]<<24);
                testResult &= (number == 0);
                testSockets.socketServer.Listen(1);
                
                testSockets.socketServer.GetSocketOption(
                    SocketOptionLevel.Socket, SocketOptionName.AcceptConnection, buf );
                number = (int)buf[0] + (int)(buf[1]<<8) + (int)(buf[2]<<16) + (int)(buf[3]<<24);
                
                testResult &= (number != 0);
                testSockets.TearDown();
                testSockets = null;

            }
            catch (System.Exception e)
            {
                Log.Comment("Caught exception: " + e.Message);
                if (e.GetType() == Type.GetType("System.Net.Sockets.SocketException"))
                    Log.Comment("ErrorCode: " + ((SocketException)e).ErrorCode);
                testResult = false;
            }
            return (testResult ? MFTestResults.Pass : MFTestResults.Fail);
        }

 public MFTestResults SocketsEnums11_SocketOptionName_SendLowWater_UDP()
 {
     SocketPair testSockets = new SocketPair(ProtocolType.Udp, SocketType.Dgram);
     Log.Comment("Testing SendLowWater with UDP");
     bool testResult = TestSocketOption(testSockets, SocketOptionLevel.Socket, 
         SocketOptionName.SendLowWater, intData, false);
     testSockets.TearDown();
     return (testResult ? MFTestResults.Pass : MFTestResults.Fail);
 }

 public MFTestResults SocketsEnums11_SocketOptionName_UseLoopback_TCP()
 {
     SocketPair testSockets = new SocketPair(ProtocolType.Tcp, SocketType.Stream);
     Log.Comment("Testing UseLoopback with TCP");
     bool testResult = TestSocketOption(testSockets, SocketOptionLevel.IP, 
         SocketOptionName.UseLoopback, boolData, false);
     testSockets.TearDown();
     return (testResult ? MFTestResults.Pass : MFTestResults.Fail);
 }