|
public SendSegmentInfoMessage ( |
||
| segmentInfoMessage | The SEGMENT_INFO_MESSAGE message. | |
| return | ||
public void HostedCacheServer_PchcServer_SegmentInfo_HashAlgoInvalid()
{
CheckApplicability();
var contentInformation = contentInformationUtility.CreateContentInformationV1();
using (var pccrrServer = new PccrrServer(testConfig.ClientContentRetrievalListenPort))
{
pccrrServer.StartListening();
pccrrServer.MessageArrived += new MessageArrivedEventArgs(delegate(IPEndPoint sender, PccrrPacket pccrrPacket)
{
BaseTestSite.Assert.Fail("Hosted cache server should not retrieve content information with invalid hash algorithm");
});
PCHCClient pchcClient = new PCHCClient(
TransferProtocol.HTTPS,
testConfig.HostedCacheServerComputerName,
testConfig.HostedCacheServerHTTPSListenPort,
PchcConsts.HttpsUrl,
testConfig.DomainName,
testConfig.UserName,
testConfig.UserPassword);
var segmentInfo = pchcClient.CreateSegmentInfoMessage(
testConfig.ClientContentRetrievalListenPort,
contentInformation,
0);
segmentInfo.SegmentInfo.dwHashAlgo = (dwHashAlgo_Values)0xFEFE;
var segmentInfoResponse = pchcClient.SendSegmentInfoMessage(segmentInfo);
BaseTestSite.Assert.AreEqual(
RESPONSE_CODE.OK,
segmentInfoResponse.ResponseCode,
"Hosted cache server should return OK to segment info message");
Thread.Sleep(testConfig.NegativeTestTimeout);
}
}
public void HostedCacheServer_PchcServer_GetBlocks_SizeOfBlockNotMatch()
{
CheckApplicability();
var contentInformation = contentInformationUtility.CreateContentInformationV1();
using (var pccrrServer = new PccrrServer(testConfig.ClientContentRetrievalListenPort))
{
bool blockRetrieved = false;
pccrrServer.MessageArrived += new MessageArrivedEventArgs(delegate(IPEndPoint sender, PccrrPacket pccrrPacket)
{
var pccrrGetBlkRequest = (PccrrGETBLKSRequestPacket)pccrrPacket;
if (pccrrGetBlkRequest != null)
{
BaseTestSite.Log.Add(
LogEntryKind.Debug,
"PCCRR GetBlks request received from hosted cache server. Send malformed Blks response");
var pccrrBlocksResponse = pccrrServer.CreateMsgBlkResponse(
pccrrGetBlkRequest.MsgGetBLKS.SegmentID,
TestUtility.GenerateRandomArray(ContentInformationUtility.DefaultBlockSize),
CryptoAlgoId_Values.AES_128,
MsgType_Values.MSG_BLK,
TestUtility.GenerateRandomArray(16),
0,
0);
var blk = pccrrBlocksResponse.MsgBLK;
blk.SizeOfBlock = 0;
pccrrBlocksResponse.MsgBLK = blk;
pccrrServer.SendPacket(pccrrBlocksResponse);
blockRetrieved = true;
}
});
pccrrServer.StartListening();
PCHCClient pchcClient = new PCHCClient(
TransferProtocol.HTTPS,
testConfig.HostedCacheServerComputerName,
testConfig.HostedCacheServerHTTPSListenPort,
PchcConsts.HttpsUrl,
testConfig.DomainName,
testConfig.UserName,
testConfig.UserPassword);
BaseTestSite.Log.Add(
LogEntryKind.Debug,
"Offer block to hosted cache server");
SEGMENT_INFO_MESSAGE segmentInfoMessage = pchcClient.CreateSegmentInfoMessage(
testConfig.ClientContentRetrievalListenPort,
contentInformation,
0);
pchcClient.SendSegmentInfoMessage(segmentInfoMessage);
TestUtility.DoUntilSucceed(() =>
{
return blockRetrieved;
}, testConfig.Timeout, testConfig.RetryInterval);
}
BaseTestSite.Log.Add(
LogEntryKind.Debug,
"Try to retrieve the block from hosted cache server");
PccrrClient pccrrClient = new PccrrClient(
testConfig.HostedCacheServerComputerName,
testConfig.HostedCacheServerHTTPListenPort);
PccrrGETBLKSRequestPacket pccrrBlkRequest = pccrrClient.CreateMsgGetBlksRequest(
contentInformation.GetSegmentId(0),
CryptoAlgoId_Values.AES_128,
MsgType_Values.MSG_GETBLKS,
0,
1);
pccrrClient.SendPacket(
pccrrBlkRequest,
testConfig.Timeout);
PccrrBLKResponsePacket pccrrBlkResponse
= (PccrrBLKResponsePacket)pccrrClient.ExpectPacket();
BaseTestSite.Assert.AreEqual<uint>(
0,
pccrrBlkResponse.MsgBLK.SizeOfBlock,
"The server MUST set the SizeOfBlock field to zero if blocks data is not available.");
}
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.");
}
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.");
}
}
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.");
}
public void HostedCacheServer_PccrrServer_MessageHeader_CryptoAlgoId(CryptoAlgoId_Values algoId)
{
CheckApplicability();
EventQueue eventQueue = new EventQueue(BaseTestSite);
eventQueue.Timeout = testConfig.Timeout;
byte[] content = TestUtility.GenerateRandomArray(ContentInformationUtility.DefaultBlockSize);
Content_Information_Data_Structure contentInformation = contentInformationUtility.CreateContentInformationV1();
BaseTestSite.Log.Add(
LogEntryKind.Debug,
"Start PCCRR server to be ready to serve content to hosted cache server");
using (PccrrTestServerV1 pccrrTestServer = new PccrrTestServerV1())
{
pccrrTestServer.Start(
testConfig.ClientContentRetrievalListenPort,
algoId,
new ProtoVersion { MajorVersion = 1, MinorVersion = 0 },
contentInformation,
content,
eventQueue);
PCHCClient pchcClient = new PCHCClient(
TransferProtocol.HTTPS,
testConfig.HostedCacheServerComputerName,
testConfig.HostedCacheServerHTTPSListenPort,
PchcConsts.HttpsUrl,
testConfig.DomainName,
testConfig.UserName,
testConfig.UserPassword);
BaseTestSite.Log.Add(
LogEntryKind.Debug,
"Directly Supply segment info to hosted cache server");
SEGMENT_INFO_MESSAGE segmentInfoMessage = pchcClient.CreateSegmentInfoMessage(
testConfig.ClientContentRetrievalListenPort,
contentInformation,
0);
pchcClient.SendSegmentInfoMessage(segmentInfoMessage);
BaseTestSite.Log.Add(
LogEntryKind.Debug,
"Make sure block 0 in segment 0 is 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 == 1;
}, 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);
}
PccrrClient pccrrClient = new PccrrClient(testConfig.HostedCacheServerComputerName, testConfig.HostedCacheServerHTTPListenPort);
Aes aes = PccrrUtitlity.CreateAes(algoId);
BaseTestSite.Log.Add(
LogEntryKind.Debug,
"Retrieve block 0 in segment 0 from hosted cache server");
PccrrGETBLKSRequestPacket pccrrBlkRequest = pccrrClient.CreateMsgGetBlksRequest(
contentInformation.GetSegmentId(0),
algoId,
MsgType_Values.MSG_GETBLKS,
(uint)0,
1);
pccrrClient.SendPacket(
pccrrBlkRequest,
testConfig.Timeout);
PccrrBLKResponsePacket pccrrBlkResponse
= (PccrrBLKResponsePacket)pccrrClient.ExpectPacket();
byte[] block = pccrrBlkResponse.MsgBLK.Block;
if (algoId != CryptoAlgoId_Values.NoEncryption)
block = PccrrUtitlity.Decrypt(aes, block, contentInformation.segments[0].SegmentSecret, pccrrBlkResponse.MsgBLK.IVBlock);
BaseTestSite.Assert.IsTrue(
Enumerable.SequenceEqual(content, block),
"The retrieved cached data should be the same as server data.");
}
public void HostedCacheServer_PccrrClient_MessageHeader_TypeInvalid()
{
CheckApplicability();
EventQueue eventQueue = new EventQueue(BaseTestSite);
eventQueue.Timeout = testConfig.Timeout;
Content_Information_Data_Structure contentInformation = contentInformationUtility.CreateContentInformationV1();
CryptoAlgoId_Values cryptoAlgoId = CryptoAlgoId_Values.AES_128;
ProtoVersion protoVersion = new ProtoVersion { MajorVersion = 1, MinorVersion = 0 };
BaseTestSite.Log.Add(
LogEntryKind.Debug,
"Start PCCRR server to be ready to serve content to hosted cache server");
using (PccrrTestInvalidMsgTypeServer pccrrTestServer = new PccrrTestInvalidMsgTypeServer())
{
pccrrTestServer.Start(
testConfig.ClientContentRetrievalListenPort,
cryptoAlgoId,
protoVersion,
contentInformation,
new byte[0],
eventQueue);
PCHCClient pchcClient = new PCHCClient(
TransferProtocol.HTTPS,
testConfig.HostedCacheServerComputerName,
testConfig.HostedCacheServerHTTPSListenPort,
PchcConsts.HttpsUrl,
testConfig.DomainName,
testConfig.UserName,
testConfig.UserPassword);
SEGMENT_INFO_MESSAGE segmentInfoMessage = pchcClient.CreateSegmentInfoMessage(
testConfig.ClientContentRetrievalListenPort,
contentInformation,
0);
pchcClient.SendSegmentInfoMessage(segmentInfoMessage);
BaseTestSite.Log.Add(
LogEntryKind.Debug,
"Offer PccrrBLKSResponse with invalid message type to 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 == 1;
}, TimeSpan.MaxValue, TimeSpan.Zero);
TestUtility.DoUntilSucceed(() => sutControlAdapter.IsLocalCacheExisted(testConfig.HostedCacheServerComputerFQDNOrNetBiosName), testConfig.NegativeTestTimeout, testConfig.RetryInterval);
}
}
