public void SmtpResponse()
        {
            SmtpResponse smtpResponse = new SmtpResponse(StandardSmtpResponseCode.ExceededStorageAllocation, "Blah");
            SmtpServerException e = new SmtpServerException(smtpResponse);

            Assert.Same(smtpResponse, e.SmtpResponse);
        }

        public void Clone_should_deep_copy_Additional()
        {
            var response = new SmtpResponse(250, "", new[] { "additional" });

            var cloned = response.Clone();
            Assert.NotSame(response.AdditionalLines, cloned.AdditionalLines);
            Assert.Equal(response.AdditionalLines, cloned.AdditionalLines);
        }

        public void Equals_is_false_ResponseCode_doesnt_match()
        {
            var response1 = new SmtpResponse(250, "");
            var response2 = new SmtpResponse(251, "");

            Assert.False(response1.Equals(response2));
            Assert.False(response1.Equals((object)response2));
            Assert.NotEqual(response1.GetHashCode(), response2.GetHashCode());
        }

 public void ToString_MultiLineMessage()
 {
     SmtpResponse r = new SmtpResponse(200, "Multi line message line 1\r\n" +
     "Multi line message line 2\r\n" +
     "Multi line message line 3");
     Assert.Equal("200-Multi line message line 1\r\n" +
     "200-Multi line message line 2\r\n" +
     "200 Multi line message line 3\r\n", r.ToString());
 }

        public void CloneAndChange_with_ResponseText_should_change_response_text()
        {
            var response = new SmtpResponse(250, "old text", new[] { "additional" });
            var cloned = response.CloneAndChange("new text");

            Assert.Equal("new text", cloned.ResponseText);
            
            var clonedBack = cloned.CloneAndChange("old text");
            Assert.Equal(response, clonedBack);
        }

        private SmtpResponse VerifyEhlo()
        {
            var smtpCapabilities = _getSmtpCapabilities.GetCapabilities().ToList();

            if (!smtpCapabilities.Any())
                return SmtpResponses.OK;

            var additionalLines = smtpCapabilities.Skip(1).Select(capability => "250-" + capability).ToList();

            var response = new SmtpResponse(250, smtpCapabilities.First().ToString(), additionalLines);
            return response;
        }

        public void RunCommand(string command, SmtpResponse expectedSmtpResponse)
        {
            _writer.WriteLine(command);

            var line = _reader.ReadLine();

            if (line == null)
                throw new InvalidOperationException("Stream has unexpectedly closed");

            if (line != expectedSmtpResponse.ToString())
                throw new InvalidOperationException(String.Format("After command '{0}' received '{1}' but expected '{2}'", command, line, expectedSmtpResponse));
        }

        public void Equals_is_false_Additional_missing_in_other_response()
        {
            var response1 = new SmtpResponse(250, "", new[] { "line" });
            var response2 = new SmtpResponse(250, "");

            Assert.False(response1.Equals(response2));
            Assert.False(response1.Equals((object)response2));
        }

        private static async Task SendResponseAsync(SmtpConnection connection, SmtpResponse response)
        {
            LogResponse(response);

            foreach (var additional in response.AdditionalLines)
                await connection.WriteLineAsyncAndFireEvents(additional);

            await connection.WriteLineAsyncAndFireEvents(response.ResponseCode + " " + response.ResponseText);
        }

		/// <summary> 
		/// Execute the SMTP request returning a response. This method models the state transition table for the SMTP server.
		/// </summary>
		/// <returns>Reponse to the request</returns>
		public virtual SmtpResponse Execute()
		{
			SmtpResponse response = null;
			if (action.Stateless)
			{
				if (SmtpActionType.EXPN == action || SmtpActionType.VRFY == action)
				{
					response = new SmtpResponse(252, "Not supported", this.state);
				}
				else if (SmtpActionType.HELP == action)
				{
					response = new SmtpResponse(211, "No help available", this.state);
				}
				else if (SmtpActionType.NOOP == action)
				{
					response = new SmtpResponse(250, "OK", this.state);
				}
				else if (SmtpActionType.VRFY == action)
				{
					response = new SmtpResponse(252, "Not supported", this.state);
				}
				else if (SmtpActionType.RSET == action)
				{
					response = new SmtpResponse(250, "OK", SmtpState.GREET);
				}
				else
				{
					response = new SmtpResponse(500, "Command not recognized", this.state);
				}
			}
			else
			{
				// Stateful commands
				if (SmtpActionType.CONNECT == action)
				{
					if (SmtpState.CONNECT == state)
					{
						response = new SmtpResponse(220, "localhost nDumbster SMTP service ready", SmtpState.GREET);
					}
					else
					{
						response = new SmtpResponse(503, "Bad sequence of commands: " + action, this.state);
					}
				}
				else if (SmtpActionType.EHLO == action)
				{
					if (SmtpState.GREET == state)
					{
						response = new SmtpResponse(250, "OK", SmtpState.MAIL);
					}
					else
					{
						response = new SmtpResponse(503, "Bad sequence of commands: " + action, this.state);
					}
				}
				else if (SmtpActionType.MAIL == action)
				{
					if (SmtpState.MAIL == state || SmtpState.QUIT == state)
					{
						response = new SmtpResponse(250, "OK", SmtpState.RCPT);
					}
					else
					{
						response = new SmtpResponse(503, "Bad sequence of commands: " + action, this.state);
					}
				}
				else if (SmtpActionType.RCPT == action)
				{
					if (SmtpState.RCPT == state)
					{
						response = new SmtpResponse(250, "OK", this.state);
					}
					else
					{
						response = new SmtpResponse(503, "Bad sequence of commands: " + action, this.state);
					}
				}
				else if (SmtpActionType.DATA == action)
				{
					if (SmtpState.RCPT == state)
					{
						response = new SmtpResponse(354, "Start mail input; end with <CRLF>.<CRLF>", SmtpState.DATA_HDR);
					}
					else
					{
						response = new SmtpResponse(503, "Bad sequence of commands: " + action, this.state);
					}
				}
				else if (SmtpActionType.UNRECOG == action)
				{
					if (SmtpState.DATA_HDR == state || SmtpState.DATA_BODY == state)
					{
						response = new SmtpResponse(-1, "", this.state);
					}
					else
					{
//.........这里部分代码省略.........

        // I was seeing my SMTP server hang waiting for a response to the QUIT, so I added
        // this timeout. Pass -1 to wait forever. Timeout is in milliseconds.
        private bool Check_Response(Socket s, SmtpResponse response_expected, int timeout)
        {
            string sResponse;
            int response;
            byte[] bytes = new byte[1024];

            int start = Environment.TickCount;
            while (s.Available == 0)
            {
                System.Threading.Thread.Sleep(101);

                if (timeout != -1)
                {
                    if ((Environment.TickCount - start) > timeout)
                    {
                        // We timed out
                        return false;
                    }
                }
            }

            s.Receive(bytes, 0, s.Available, SocketFlags.None);
            sResponse = Encoding.ASCII.GetString(bytes);
            if (sw != null)
                sw.WriteLine(">>{0}", sResponse);
            response = Convert.ToInt32(sResponse.Substring(0, 3));
            if (response != (int)response_expected)
                return false;
            return true;
        }

        private static SmtpSessionInfoResponder CreateParseResponderWithMockedIRespondToSmtpIdentification(SmtpResponse testResponse)
        {
            var respondToSmtpIdentification = MockIRespondToSmtpIdentificationToReturnResponse(testResponse);

            var factory = new DefaultSmtpResponderFactory<ISmtpServerConfiguration>(new SmtpServerConfiguration()) { IdentificationResponder = respondToSmtpIdentification };
            var parseResponder = DefaultResponder(factory);
            return parseResponder;
        }

        private static async Task SendResponseAsync(SmtpConnection connection, SmtpResponse response)
        {
            LogResponse(response);

            try
            {
                foreach (var additional in response.AdditionalLines)
                    await connection.WriteLineAsyncAndFireEvents(additional);

                await connection.WriteLineAsyncAndFireEvents(response.ResponseCode + " " + response.ResponseText);

            } catch(Exception ex)
            {
                MailServerLogger.Instance.Error(ex);
            }
        }

			public static SmtpResponse Parse (string line) {
				SmtpResponse response = new SmtpResponse ();

				if (line.Length < 4)
					throw new SmtpException ("Response is to short " +
								 line.Length + ".");

				if ((line [3] != ' ') && (line [3] != '-'))
					throw new SmtpException ("Response format is wrong.(" +
								 line + ")");

				// parse the response code
				response.StatusCode = (SmtpStatusCode) Int32.Parse (line.Substring (0, 3));

				// set the raw response
				response.Description = line;

				return response;
			}

 private bool ProcessRawLineHasResponse(string line, out SmtpResponse smtpResponse)
 {
     smtpResponse = ProcessRawLine(line);
     return (smtpResponse != SmtpResponses.None);
 }

 private static IRespondToSmtpVerify MockIRespondToVerifyToReturnResponse(SmtpResponse testResponse)
 {
     var mockedInterface = new Mock<IRespondToSmtpVerify>();
     mockedInterface
         .Setup(x => x.Verify(It.IsAny<SmtpSessionInfo>(), It.IsAny<string>()))
         .Returns<SmtpSessionInfo, string>((sessionInfo, args) => testResponse);
     return mockedInterface.Object;
 }

		void CheckStatus (SmtpResponse status, int i)
		{
			if (((int) status.StatusCode) != i)
				throw new SmtpException (status.StatusCode, status.Description);
		}

        private static SmtpSessionInfoResponder CreateParseResponderWithMockedIRespondToVerify(SmtpResponse testResponse)
        {
            var respondToVerify = MockIRespondToVerifyToReturnResponse(testResponse);

            var factory = new DefaultSmtpResponderFactory<ISmtpServerConfiguration>(new SmtpServerConfiguration()) { VerifyResponder = respondToVerify };
            var parseResponder = MailFromIdentifiedParseResponder(factory);
            return parseResponder;
        }

 private static IRespondToSmtpRecipientTo MockIRespondToRecipientToToReturnResponse(SmtpResponse testResponse)
 {
     var mockedInterface = new Mock<IRespondToSmtpRecipientTo>();
     mockedInterface
         .Setup(x => x.VerifyRecipientTo(It.IsAny<SmtpSessionInfo>(), It.IsAny<MailAddressWithParameters>()))
         .Returns<SmtpSessionInfo, MailAddressWithParameters>((sessionInfo, mailAddressWithParameters) => testResponse);
     return mockedInterface.Object;
 }

 private static IRespondToSmtpIdentification MockIRespondToSmtpIdentificationToReturnResponse(SmtpResponse testResponse)
 {
     var mockedInterface = new Mock<IRespondToSmtpIdentification>();
     mockedInterface
         .Setup(x => x.VerifyIdentification(It.IsAny<SmtpSessionInfo>(), It.IsAny<SmtpIdentification>()))
         .Returns<SmtpSessionInfo, SmtpIdentification>((sessionInfo, identification) => testResponse);
     return mockedInterface.Object;
 }