Response message are sent in response to the request message: INITIAL_OFFER_MESSAGE, SEGMENT_INFO_MESSAGE.
 /// <summary>
 /// Transform the RESPONSE_MESSAGE to a byte array
 /// </summary>
 /// <param name="responseMessage">The RESPONSE_MESSAGE message</param>
 /// <returns>The result array</returns>
 public static byte[] EncodeResponseMessage(RESPONSE_MESSAGE responseMessage)
 {
     List<byte> list = new List<byte>();
     list.AddRange(GetBytesFromUint32(responseMessage.TransportHeader.Size, false));
     list.Add((byte)responseMessage.ResponseCode);
     return list.ToArray();
 }
        /// <summary>
        /// Transform the RESPONSE_MESSAGE to a byte array
        /// </summary>
        /// <param name="responseMessage">The RESPONSE_MESSAGE message</param>
        /// <returns>The result array</returns>
        public static byte[] EncodeResponseMessage(RESPONSE_MESSAGE responseMessage)
        {
            List <byte> list = new List <byte>();

            list.AddRange(GetBytesFromUint32(responseMessage.TransportHeader.Size, false));
            list.Add((byte)responseMessage.ResponseCode);
            return(list.ToArray());
        }
        /// <summary>
        /// Convert the responsemessage struct defined in adapter to stack
        /// </summary>
        /// <param name="responseMessageStack">The response message of send initialInfoMeaage or segmentInfoMessage</param>
        /// <returns>Return the ResponseMessage type defined in adapter</returns>
        public static ResponseMessage ConvertFromStackForResponseMsg(RESPONSE_MESSAGE responseMessageStack)
        {
            ResponseMessage responseMessage;
            responseMessage.ResponseCode = ConvertFromStackForResponseCode(responseMessageStack.ResponseCode);
            responseMessage.TransportHeader = ConvertFromStackForTransHeader(responseMessageStack.TransportHeader);

            return responseMessage;
        }
示例#4
0
        /// <summary>
        /// Send Reponse Message to the client.
        /// </summary>
        /// <param name="responseMessage">The response message.</param>
        public void SendPackage(RESPONSE_MESSAGE responseMessage)
        {
            this.SendByte(EncodeMessage.EncodeResponseMessage(responseMessage));

            if (this.logger != null)
            {
                this.logger.AddDebug("Pchc response message is sent successfully.");
            }
        }
        /// <summary>
        /// Send the BATCHED_OFFER_MESSAGE request.
        /// </summary>
        /// <param name="batchedOfferMessage">The BATCHED_OFFER_MESSAGE message.</param>
        /// <returns>The repsonse message RESPONSE_MESSAGE from the hosted cache.</returns>
        public RESPONSE_MESSAGE SendBatchedOfferMessage(BATCHED_OFFER_MESSAGE batchedOfferMessage)
        {
            List <byte> buffer = new List <byte>();

            buffer.AddRange(TypeMarshal.ToBytes(batchedOfferMessage.MessageHeader));
            buffer.AddRange(TypeMarshal.ToBytes(batchedOfferMessage.ConnectionInfo));
            for (int i = 0; i < batchedOfferMessage.SegmentDescriptors.Length; i++)
            {
                buffer.AddRange(TypeMarshal.ToBytes(batchedOfferMessage.SegmentDescriptors[i]));
            }
            return(this.responseMessage = this.SendByte(buffer.ToArray()));
        }
        /// <summary>
        /// Send the byte array of PCHC message using https transport .
        /// </summary>
        /// <param name="httpRequestPayload">The http request payload.</param>
        /// <returns>The pchc response message.</returns>
        private RESPONSE_MESSAGE SendByte(byte[] httpRequestPayload)
        {
            // Set the timeout of http.
            int timeout = 20000;

            byte[]          payloadBuffer = null;
            HttpWebResponse httpWebResponse;

            this.httpClientTransport.Send(HttpVersion.Version10, null, httpRequestPayload, HttpMethod.POST, timeout);

            try
            {
                httpWebResponse = this.httpClientTransport.Receive(ref payloadBuffer);
            }
            catch (WebException e)
            {
                if (e.Message.Contains(HttpStatusCode.Unauthorized.ToString()))
                {
                    throw new HttpStatusCode401Exception();
                }
                else if (e.Message.ToLower().Contains("timed out".ToLower()))
                {
                    throw new NoRESPONSEMESSAGEException();
                }
                else
                {
                    // Un expected exception is received.
                    throw;
                }
            }

            this.httpResponseMethod = httpWebResponse.Method;

            this.httpResponseUri = httpWebResponse.ResponseUri;

            if (payloadBuffer == null)
            {
                throw new NoRESPONSEMESSAGEException();
            }

            try
            {
                this.responseMessage = DecodeMessage.DecodeResponseMessage(payloadBuffer);
            }
            catch (ArgumentOutOfRangeException e)
            {
                throw new NoRESPONSEMESSAGEException(e.Message);
            }

            return(this.responseMessage);
        }
        public void HostedCacheServer_PchcServer_InitialOffer_SegmentInfoRetrieved()
        {
            CheckApplicability();

            Content_Information_Data_Structure contentInformation = contentInformationUtility.CreateContentInformationV1();

            PCHCClient pchcClient = new PCHCClient(
                TransferProtocol.HTTPS,
                testConfig.HostedCacheServerComputerName,
                testConfig.HostedCacheServerHTTPSListenPort,
                PchcConsts.HttpsUrl,
                testConfig.DomainName,
                testConfig.UserName,
                testConfig.UserPassword);

            BaseTestSite.Log.Add(
                LogEntryKind.Debug,
                "Send initial offer message to hosted cache server");

            INITIAL_OFFER_MESSAGE initialOfferMessage = pchcClient.CreateInitialOfferMessage(
                testConfig.ClientContentRetrievalListenPort,
                contentInformation.GetSegmentId(0));

            pchcClient.SendInitialOfferMessage(initialOfferMessage);

            BaseTestSite.Log.Add(
                LogEntryKind.Debug,
                "Supply segment info to hosted cache server");

            SEGMENT_INFO_MESSAGE segmentInfoMessage = pchcClient.CreateSegmentInfoMessage(
                testConfig.ClientContentRetrievalListenPort,
                contentInformation,
                0);

            pchcClient.SendSegmentInfoMessage(segmentInfoMessage);

            Microsoft.Protocols.TestTools.StackSdk.BranchCache.Pchc.RESPONSE_MESSAGE responseMessage2 = pchcClient.SendInitialOfferMessage(initialOfferMessage);

            TestClassBase.BaseTestSite.Assert.AreEqual <RESPONSE_CODE>(
                RESPONSE_CODE.INTERESTED,
                responseMessage2.ResponseCode,
                @"The hosted cache MUST specify a response code of 0 
                        if it already has block hash.");
        }
示例#8
0
        public void HostedCacheServer_BVT_CacheOfferingRetrieval_V1()
        {
            CheckApplicability();

            EventQueue eventQueue = new EventQueue(BaseTestSite);

            eventQueue.Timeout = testConfig.Timeout;

            BaseTestSite.Log.Add(
                LogEntryKind.Debug,
                "Trigger hash generation on content server");

            byte[] content = contentInformationUtility.RetrieveContentData();

            Content_Information_Data_Structure contentInformation =
                PccrcUtility.ParseContentInformation(contentInformationUtility.RetrieveContentInformation(BranchCacheVersion.V1));

            CryptoAlgoId_Values cryptoAlgoId = CryptoAlgoId_Values.AES_128;

            PccrrClient pccrrClient = new PccrrClient(testConfig.HostedCacheServerComputerName, testConfig.HostedCacheServerHTTPListenPort);

            for (int i = 0; i < contentInformation.cSegments; ++i)
            {
                var pccrrBlkListRequest = pccrrClient.CreateMsgGetBlkListRequest(
                    contentInformation.GetSegmentId(i),
                    new BLOCK_RANGE[] { new BLOCK_RANGE {
                                            Index = 0, Count = contentInformation.segments[i].BlockCount
                                        } },
                    cryptoAlgoId,
                    MsgType_Values.MSG_GETBLKLIST);
                pccrrClient.SendPacket(
                    pccrrBlkListRequest,
                    testConfig.Timeout);
                var pccrrBlkListResponse
                    = (PccrrBLKLISTResponsePacket)pccrrClient.ExpectPacket();

                BaseTestSite.Assert.AreEqual <uint>(
                    0,
                    pccrrBlkListResponse.MsgBLKLIST.BlockRangeCount,
                    "The server MUST set the BlockRangeCount field to zero if it doesn't have the requested blocks data.");
            }

            BaseTestSite.Log.Add(
                LogEntryKind.Debug,
                "Retrieve content information from content server");

            using (PccrrTestServerV1 pccrrTestServer = new PccrrTestServerV1())
            {
                BaseTestSite.Log.Add(
                    LogEntryKind.Debug,
                    "Start PCCRR server to be ready to serve content to hosted cache server");

                pccrrTestServer.Start(
                    testConfig.ClientContentRetrievalListenPort,
                    cryptoAlgoId,
                    contentInformation,
                    content,
                    eventQueue);

                PCHCClient pchcClient = new PCHCClient(
                    TransferProtocol.HTTPS,
                    testConfig.HostedCacheServerComputerName,
                    testConfig.HostedCacheServerHTTPSListenPort,
                    PchcConsts.HttpsUrl,
                    testConfig.DomainName,
                    testConfig.UserName,
                    testConfig.UserPassword);

                for (int i = 0; i < contentInformation.cSegments; i++)
                {
                    BaseTestSite.Log.Add(
                        LogEntryKind.Debug,
                        "Offer content segment {0} to hosted cache server",
                        i);

                    INITIAL_OFFER_MESSAGE initialOfferMessage = pchcClient.CreateInitialOfferMessage(
                        testConfig.ClientContentRetrievalListenPort,
                        contentInformation.GetSegmentId(i));
                    Microsoft.Protocols.TestTools.StackSdk.BranchCache.Pchc.RESPONSE_MESSAGE responseMessage
                        = pchcClient.SendInitialOfferMessage(initialOfferMessage);

                    TestClassBase.BaseTestSite.Assert.AreEqual <RESPONSE_CODE>(
                        RESPONSE_CODE.INTERESTED,
                        responseMessage.ResponseCode,
                        @"The hosted cache MUST specify a response code of 1 
                        if its list of block hashes associated with the segment is incomplete.");

                    BaseTestSite.Log.Add(
                        LogEntryKind.Debug,
                        "Supply segment info to hosted cache server");

                    SEGMENT_INFO_MESSAGE segmentInfoMessage = pchcClient.CreateSegmentInfoMessage(
                        testConfig.ClientContentRetrievalListenPort,
                        contentInformation,
                        i);
                    responseMessage = pchcClient.SendSegmentInfoMessage(segmentInfoMessage);

                    TestClassBase.BaseTestSite.Assert.AreEqual <RESPONSE_CODE>(
                        RESPONSE_CODE.OK,
                        responseMessage.ResponseCode,
                        @"The hosted cache MUST send a response code of 0 when SEGMENT_INFO_MESSAGE request received");

                    BaseTestSite.Log.Add(
                        LogEntryKind.Debug,
                        "Make sure all blocks in segment {0} are retrieved by hosted cache server",
                        i);

                    int blockCount = 0;
                    TestUtility.DoUntilSucceed(delegate()
                    {
                        eventQueue.Expect <MessageArrivedEventArgs>(typeof(PccrrServer).GetEvent("MessageArrived"), delegate(System.Net.IPEndPoint sender, PccrrPacket pccrrPacket)
                        {
                            var pccrrGetBlksRequest = pccrrPacket as PccrrGETBLKSRequestPacket;

                            if (pccrrGetBlksRequest != null)
                            {
                                blockCount++;
                            }
                        });
                        return(blockCount == contentInformation.segments[i].BlockCount);
                    }, TimeSpan.MaxValue, TimeSpan.Zero);
                }

                BaseTestSite.Log.Add(
                    LogEntryKind.Debug,
                    "Wait until cache is available on hosted cache server");

                TestUtility.DoUntilSucceed(() => sutControlAdapter.IsLocalCacheExisted(testConfig.HostedCacheServerComputerFQDNOrNetBiosName), testConfig.Timeout, testConfig.RetryInterval);
            }

            List <byte> retrievedContent = new List <byte>();

            BaseTestSite.Log.Add(
                LogEntryKind.Debug,
                "Negotiate PCCRR version");

            var pccrrNegotiateRequest = pccrrClient.CreateMsgNegoRequest(
                new ProtoVersion {
                MajorVersion = 1, MinorVersion = 0
            },
                new ProtoVersion {
                MajorVersion = 1, MinorVersion = ushort.MaxValue
            },
                cryptoAlgoId,
                MsgType_Values.MSG_NEGO_REQ);

            pccrrClient.SendPacket(
                pccrrNegotiateRequest,
                testConfig.Timeout);
            var pccrrNegotiateResponse
                = (PccrrNegoResponsePacket)pccrrClient.ExpectPacket();

            if (testConfig.SupportBranchCacheV1)
            {
                BaseTestSite.Assert.IsTrue(
                    pccrrNegotiateResponse.MsgNegoResp.MinSupporteProtocolVersion.MajorVersion <= 1 &&
                    pccrrNegotiateResponse.MsgNegoResp.MaxSupporteProtocolVersion.MajorVersion >= 1,
                    "SupportedProtocolVersion doesn't match configuration");
            }

            if (testConfig.SupportBranchCacheV2)
            {
                BaseTestSite.Assert.IsTrue(
                    pccrrNegotiateResponse.MsgNegoResp.MinSupporteProtocolVersion.MajorVersion <= 2 &&
                    pccrrNegotiateResponse.MsgNegoResp.MaxSupporteProtocolVersion.MajorVersion >= 2,
                    "SupportedProtocolVersion doesn't match configuration");
            }

            Aes aes = PccrrUtitlity.CreateAes(cryptoAlgoId);

            for (int i = 0; i < contentInformation.cSegments; i++)
            {
                BaseTestSite.Log.Add(
                    LogEntryKind.Debug,
                    "Retrieve block list for segment {0}",
                    i);

                var pccrrBlkListRequest = pccrrClient.CreateMsgGetBlkListRequest(
                    contentInformation.GetSegmentId(i),
                    new BLOCK_RANGE[] { new BLOCK_RANGE {
                                            Index = 0, Count = contentInformation.segments[i].BlockCount
                                        } },
                    cryptoAlgoId,
                    MsgType_Values.MSG_GETBLKLIST);
                pccrrClient.SendPacket(
                    pccrrBlkListRequest,
                    testConfig.Timeout);
                var pccrrBlkListResponse
                    = (PccrrBLKLISTResponsePacket)pccrrClient.ExpectPacket();

                BaseTestSite.Assert.AreNotEqual <uint>(
                    0,
                    pccrrBlkListResponse.MsgBLKLIST.BlockRangeCount,
                    "The server MUST set the BlockRangeCount field to a value greater than zero if it has the requested blocks data.");

                for (int j = 0; j < contentInformation.segments[i].BlockCount; j++)
                {
                    BaseTestSite.Log.Add(
                        LogEntryKind.Debug,
                        "Retrieve block {0} for segment {1}",
                        j,
                        i);

                    PccrrGETBLKSRequestPacket pccrrBlkRequest = pccrrClient.CreateMsgGetBlksRequest(
                        contentInformation.GetSegmentId(i),
                        cryptoAlgoId,
                        MsgType_Values.MSG_GETBLKS,
                        (uint)j,
                        1);
                    pccrrClient.SendPacket(
                        pccrrBlkRequest,
                        testConfig.Timeout);
                    PccrrBLKResponsePacket pccrrBlkResponse
                        = (PccrrBLKResponsePacket)pccrrClient.ExpectPacket();

                    BaseTestSite.Assert.AreNotEqual <uint>(
                        0,
                        pccrrBlkResponse.MsgBLK.SizeOfBlock,
                        "The server MUST set the SizeOfBlock field to a value greater than zero if it has the requested blocks data.");

                    byte[] block = pccrrBlkResponse.MsgBLK.Block;

                    if (cryptoAlgoId != CryptoAlgoId_Values.NoEncryption)
                    {
                        block = PccrrUtitlity.Decrypt(aes, block, contentInformation.segments[i].SegmentSecret, pccrrBlkResponse.MsgBLK.IVBlock);
                    }

                    retrievedContent.AddRange(block);
                }
            }

            BaseTestSite.Assert.IsTrue(
                Enumerable.SequenceEqual(content, retrievedContent),
                "The retrieved cached data should be the same as server data.");
        }
        /// <summary>
        /// Send Reponse Message to the client.
        /// </summary>
        /// <param name="responseMessage">The response message.</param>
        public void SendPackage(RESPONSE_MESSAGE responseMessage)
        {
            this.SendByte(EncodeMessage.EncodeResponseMessage(responseMessage));

            if (this.logger != null)
            {
                this.logger.AddDebug("Pchc response message is sent successfully.");
            }
        }
        /// <summary>
        /// Send the byte array of PCHC message using https transport .
        /// </summary>
        /// <param name="httpRequestPayload">The http request payload.</param>
        /// <returns>The pchc response message.</returns>
        private RESPONSE_MESSAGE SendByte(byte[] httpRequestPayload)
        {
            // Set the timeout of http.
            int timeout = 20000;
            byte[] payloadBuffer = null;
            HttpWebResponse httpWebResponse;

            this.httpClientTransport.Send(HttpVersion.Version10, null, httpRequestPayload, HttpMethod.POST, timeout);

            try
            {
                httpWebResponse = this.httpClientTransport.Receive(ref payloadBuffer);
            }
            catch (WebException e)
            {
                if (e.Message.Contains(HttpStatusCode.Unauthorized.ToString()))
                {
                    throw new HttpStatusCode401Exception();
                }
                else if (e.Message.ToLower().Contains("timed out".ToLower()))
                {
                    throw new NoRESPONSEMESSAGEException();
                }
                else
                {
                    // Un expected exception is received.
                    throw;
                }
            }

            this.httpResponseMethod = httpWebResponse.Method;

            this.httpResponseUri = httpWebResponse.ResponseUri;

            if (payloadBuffer == null)
            {
                throw new NoRESPONSEMESSAGEException();
            }

            try
            {
                this.responseMessage = DecodeMessage.DecodeResponseMessage(payloadBuffer);
            }
            catch (ArgumentOutOfRangeException e)
            {
                throw new NoRESPONSEMESSAGEException(e.Message);
            }

            return this.responseMessage;
        }
 /// <summary>
 /// Send the SEGMENT_INFO_MESSAGE request.
 /// </summary>
 /// <param name="segmentInfoMessage">The SEGMENT_INFO_MESSAGE message.</param>
 /// <returns>The repsonse message RESPONSE_MESSAGE from the hosted cache.</returns>
 public RESPONSE_MESSAGE SendSegmentInfoMessage(SEGMENT_INFO_MESSAGE segmentInfoMessage)
 {
     return this.responseMessage = this.SendByte(EncodeMessage.EncodeSegmentInfoMessage(segmentInfoMessage));
 }
 /// <summary>
 /// Send the INITIAL_OFFER_MESSAGE request.
 /// </summary>
 /// <param name="initialOfferMessage">The INITIAL_OFFER_MESSAGE message.</param>
 /// <returns>The repsonse message RESPONSE_MESSAGE from the hosted cache.</returns>
 public RESPONSE_MESSAGE SendInitialOfferMessage(INITIAL_OFFER_MESSAGE initialOfferMessage)
 {
     return this.responseMessage = this.SendByte(EncodeMessage.EncodeInitialOfferMessage(initialOfferMessage));
 }
 /// <summary>
 /// Send the BATCHED_OFFER_MESSAGE request.
 /// </summary>
 /// <param name="batchedOfferMessage">The BATCHED_OFFER_MESSAGE message.</param>
 /// <returns>The repsonse message RESPONSE_MESSAGE from the hosted cache.</returns>
 public RESPONSE_MESSAGE SendBatchedOfferMessage(BATCHED_OFFER_MESSAGE batchedOfferMessage)
 {
     List<byte> buffer = new List<byte>();
     buffer.AddRange(TypeMarshal.ToBytes(batchedOfferMessage.MessageHeader));
     buffer.AddRange(TypeMarshal.ToBytes(batchedOfferMessage.ConnectionInfo));
     for (int i = 0; i < batchedOfferMessage.SegmentDescriptors.Length; i++)
     {
         buffer.AddRange(TypeMarshal.ToBytes(batchedOfferMessage.SegmentDescriptors[i]));
     }
     return this.responseMessage = this.SendByte(buffer.ToArray());
 }
 /// <summary>
 /// Send the SEGMENT_INFO_MESSAGE request.
 /// </summary>
 /// <param name="segmentInfoMessage">The SEGMENT_INFO_MESSAGE message.</param>
 /// <returns>The repsonse message RESPONSE_MESSAGE from the hosted cache.</returns>
 public RESPONSE_MESSAGE SendSegmentInfoMessage(SEGMENT_INFO_MESSAGE segmentInfoMessage)
 {
     return(this.responseMessage = this.SendByte(EncodeMessage.EncodeSegmentInfoMessage(segmentInfoMessage)));
 }
 /// <summary>
 /// Send the INITIAL_OFFER_MESSAGE request.
 /// </summary>
 /// <param name="initialOfferMessage">The INITIAL_OFFER_MESSAGE message.</param>
 /// <returns>The repsonse message RESPONSE_MESSAGE from the hosted cache.</returns>
 public RESPONSE_MESSAGE SendInitialOfferMessage(INITIAL_OFFER_MESSAGE initialOfferMessage)
 {
     return(this.responseMessage = this.SendByte(EncodeMessage.EncodeInitialOfferMessage(initialOfferMessage)));
 }
        public void HostedCacheServer_PchcServer_InitialOffer_ContentRereieved()
        {
            CheckApplicability();

            EventQueue eventQueue = new EventQueue(BaseTestSite);

            eventQueue.Timeout = testConfig.Timeout;

            Content_Information_Data_Structure contentInformation = contentInformationUtility.CreateContentInformationV1();

            CryptoAlgoId_Values cryptoAlgoId = CryptoAlgoId_Values.AES_128;

            using (PccrrTestServerV1 pccrrTestServer = new PccrrTestServerV1())
            {
                BaseTestSite.Log.Add(
                    LogEntryKind.Debug,
                    "Start PCCRR server to be ready to serve content to hosted cache server");

                pccrrTestServer.Start(
                    testConfig.ClientContentRetrievalListenPort,
                    cryptoAlgoId,
                    new ProtoVersion {
                    MajorVersion = 1, MinorVersion = 0
                },
                    contentInformation,
                    TestUtility.GenerateRandomArray(ContentInformationUtility.DefaultBlockSize),
                    eventQueue);

                PCHCClient pchcClient = new PCHCClient(
                    TransferProtocol.HTTPS,
                    testConfig.HostedCacheServerComputerName,
                    testConfig.HostedCacheServerHTTPSListenPort,
                    PchcConsts.HttpsUrl,
                    testConfig.DomainName,
                    testConfig.UserName,
                    testConfig.UserPassword);

                BaseTestSite.Log.Add(
                    LogEntryKind.Debug,
                    "Send initial offer message to hosted cache server");

                SEGMENT_INFO_MESSAGE segmentInfoMessage = pchcClient.CreateSegmentInfoMessage(
                    testConfig.ClientContentRetrievalListenPort,
                    contentInformation,
                    0);
                pchcClient.SendSegmentInfoMessage(segmentInfoMessage);

                BaseTestSite.Log.Add(
                    LogEntryKind.Debug,
                    "Make sure all blocks in segment 0 are retrieved by hosted cache server");

                int blockCount = 0;
                TestUtility.DoUntilSucceed(delegate()
                {
                    eventQueue.Expect <MessageArrivedEventArgs>(typeof(PccrrServer).GetEvent("MessageArrived"), delegate(System.Net.IPEndPoint sender, PccrrPacket pccrrPacket)
                    {
                        var pccrrGetBlksRequest = pccrrPacket as PccrrGETBLKSRequestPacket;

                        if (pccrrGetBlksRequest != null)
                        {
                            blockCount++;
                        }
                    });
                    return(blockCount == contentInformation.segments[0].BlockCount);
                }, TimeSpan.MaxValue, TimeSpan.Zero);

                BaseTestSite.Log.Add(
                    LogEntryKind.Debug,
                    "Wait until cache is available on hosted cache server");

                TestUtility.DoUntilSucceed(() => sutControlAdapter.IsLocalCacheExisted(testConfig.HostedCacheServerComputerFQDNOrNetBiosName), testConfig.Timeout, testConfig.RetryInterval);

                INITIAL_OFFER_MESSAGE initialOfferMessage = pchcClient.CreateInitialOfferMessage(
                    testConfig.ClientContentRetrievalListenPort,
                    contentInformation.GetSegmentId(0));
                Microsoft.Protocols.TestTools.StackSdk.BranchCache.Pchc.RESPONSE_MESSAGE responseMessage2
                    = pchcClient.SendInitialOfferMessage(initialOfferMessage);

                TestClassBase.BaseTestSite.Assert.AreEqual <RESPONSE_CODE>(
                    RESPONSE_CODE.INTERESTED,
                    responseMessage2.ResponseCode,
                    @"The hosted cache MUST specify a response code of 0 
                        if it already has block data and block hash.");
            }
        }