public MSOneStorePackage Parse(DataElementPackage dataElementPackage)
{
MSOneStorePackage package = new MSOneStorePackage();
storageIndexDataElements = dataElementPackage.DataElements.Where(d => d.DataElementType == DataElementType.StorageIndexDataElementData).ToArray();
storageManifestDataElements = dataElementPackage.DataElements.Where(d => d.DataElementType == DataElementType.StorageManifestDataElementData).ToArray();
cellManifestDataElements = dataElementPackage.DataElements.Where(d => d.DataElementType == DataElementType.CellManifestDataElementData).ToArray();
revisionManifestDataElements = dataElementPackage.DataElements.Where(d => d.DataElementType == DataElementType.RevisionManifestDataElementData).ToArray();
objectGroupDataElements = dataElementPackage.DataElements.Where(d => d.DataElementType == DataElementType.ObjectGroupDataElementData).ToArray();
objectBlOBElements = dataElementPackage.DataElements.Where(d => d.DataElementType == DataElementType.ObjectDataBLOBDataElementData).ToArray();
package.StorageIndex = storageIndexDataElements[0].Data as StorageIndexDataElementData;
package.StorageManifest = storageManifestDataElements[0].Data as StorageManifestDataElementData;
// Parse Header Cell
CellID headerCellID = package.StorageManifest.StorageManifestRootDeclareList[0].CellID;
StorageIndexCellMapping headerCellStorageIndexCellMapping = package.FindStorageIndexCellMapping(headerCellID);
storageIndexHashTab.Add(headerCellID);
if (headerCellStorageIndexCellMapping != null)
{
package.HeaderCellCellManifest = this.FindCellManifest(headerCellStorageIndexCellMapping.CellMappingExtendedGUID);
StorageIndexRevisionMapping headerCellRevisionManifestMapping =
package.FindStorageIndexRevisionMapping(package.HeaderCellCellManifest.CellManifestCurrentRevision.CellManifestCurrentRevisionExtendedGUID);
package.HeaderCellRevisionManifest = this.FindRevisionManifestDataElement(headerCellRevisionManifestMapping.RevisionMappingExtendedGUID);
package.HeaderCell = this.ParseHeaderCell(package.HeaderCellRevisionManifest);
// Parse Data root
CellID dataRootCellID = package.StorageManifest.StorageManifestRootDeclareList[1].CellID;
storageIndexHashTab.Add(dataRootCellID);
package.DataRoot = this.ParseObjectGroup(dataRootCellID, package);
// Parse other data
foreach (StorageIndexCellMapping storageIndexCellMapping in package.StorageIndex.StorageIndexCellMappingList)
{
if (storageIndexHashTab.Contains(storageIndexCellMapping.CellID) == false)
{
package.OtherFileNodeList.AddRange(this.ParseObjectGroup(storageIndexCellMapping.CellID, package));
storageIndexHashTab.Add(storageIndexCellMapping.CellID);
}
}
}
return(package);
}
private List <RevisionStoreObjectGroup> ParseObjectGroup(CellID objectGroupCellID, MSOneStorePackage package)
{
StorageIndexCellMapping storageIndexCellMapping = package.FindStorageIndexCellMapping(objectGroupCellID);
CellManifestDataElementData cellManifest = this.FindCellManifest(storageIndexCellMapping.CellMappingExtendedGUID);
List <RevisionStoreObjectGroup> objectGroups = new List <RevisionStoreObjectGroup>();
package.CellManifests.Add(cellManifest);
StorageIndexRevisionMapping revisionMapping =
package.FindStorageIndexRevisionMapping(cellManifest.CellManifestCurrentRevision.CellManifestCurrentRevisionExtendedGUID);
RevisionManifestDataElementData revisionManifest =
this.FindRevisionManifestDataElement(revisionMapping.RevisionMappingExtendedGUID);
package.RevisionManifests.Add(revisionManifest);
RevisionManifestRootDeclare encryptionKeyRoot = revisionManifest.RevisionManifestRootDeclareList.Where(r => r.RootExtendedGUID.Equals(new ExGuid(3, Guid.Parse("4A3717F8-1C14-49E7-9526-81D942DE1741")))).SingleOrDefault();
bool isEncryption = encryptionKeyRoot != null;
foreach (RevisionManifestObjectGroupReferences objRef in revisionManifest.RevisionManifestObjectGroupReferencesList)
{
ObjectGroupDataElementData dataObject = objectGroupDataElements.Where(d => d.DataElementExtendedGUID.Equals(
objRef.ObjectGroupExtendedGUID)).Single().Data as ObjectGroupDataElementData;
RevisionStoreObjectGroup objectGroup = RevisionStoreObjectGroup.CreateInstance(objRef.ObjectGroupExtendedGUID, dataObject, isEncryption);
objectGroups.Add(objectGroup);
}
return(objectGroups);
}
/// <summary>
/// This method is used to validate the sub response according to the current record sub request token and sub request type.
/// </summary>
/// <param name="rawResponse">Specify the raw XML string response returned by the protocol server.</param>
/// <param name="site">An object provides logging, assertions, and SUT adapters for test code onto its execution context.</param>
public void Validate(string rawResponse, ITestSite site)
{
// Extract the sub response whose token equals the SubToken value.
XmlDocument subResponseDocument = this.ExtractSubResponseNode(rawResponse);
// De-serialize the sub response to instance
object subResponse = this.SerializeSubResponse(subResponseDocument, site);
// Try to parse the MS-FSSHTTPB structure
if (subResponse is CellSubResponseType)
{
// If the sub request type is CellSubRequestType, then indicating that there is one MS-FSSHTTPB response embedded. Try parse this an capture all the related requirements.
CellSubResponseType cellSubResponse = subResponse as CellSubResponseType;
if (cellSubResponse.SubResponseData != null && cellSubResponse.SubResponseData.Text.Length == 1)
{
string subResponseBase64 = cellSubResponse.SubResponseData.Text[0];
byte[] subResponseBinary = Convert.FromBase64String(subResponseBase64);
FsshttpbResponse fsshttpbResponse = FsshttpbResponse.DeserializeResponseFromByteArray(subResponseBinary, 0);
if (fsshttpbResponse.DataElementPackage != null && fsshttpbResponse.DataElementPackage.DataElements != null)
{
// If the response data elements is complete, then try to verify the requirements related in the MS-FSSHTPD
foreach (DataElement storageIndex in fsshttpbResponse.DataElementPackage.DataElements.Where(dataElement => dataElement.DataElementType == DataElementType.StorageIndexDataElementData))
{
// Just build the root node to try to parse the signature related requirements, no need to restore the result.
new IntermediateNodeObject.RootNodeObjectBuilder().Build(
fsshttpbResponse.DataElementPackage.DataElements,
storageIndex.DataElementExtendedGUID);
}
if (SharedContext.Current.FileUrl.ToLowerInvariant().EndsWith(".one") ||
SharedContext.Current.FileUrl.ToLowerInvariant().EndsWith(".onetoc2"))
{
MSONESTOREParser onenoteParser = new MSONESTOREParser();
MSOneStorePackage package = onenoteParser.Parse(fsshttpbResponse.DataElementPackage);
// Capture the MS-ONESTORE related requirements
new MsonestoreCapture().Validate(package, site);
}
}
if (SharedContext.Current.IsMsFsshttpRequirementsCaptured)
{
new MsfsshttpbAdapterCapture().VerifyTransport(site);
// Capture the response related requirements
new MsfsshttpbAdapterCapture().VerifyFsshttpbResponse(fsshttpbResponse, site);
}
}
}
// Validating the fragment of the sub response
// Record the validation errors and warnings.
ValidationResult result = SchemaValidation.ValidateXml(subResponseDocument.OuterXml);
if (!SharedContext.Current.IsMsFsshttpRequirementsCaptured)
{
if (result != ValidationResult.Success)
{
// Add error log
site.Assert.Fail("Schema validation fails, the reason is " + SchemaValidation.GenerateValidationResult());
}
// No need to run the capture code, just return.
return;
}
if (result == ValidationResult.Success)
{
// Capture the requirement related to the sub response token.
MsfsshttpAdapterCapture.ValidateSubResponseToken(site);
// Call corresponding sub response capture code.
this.InvokeCaptureCode(subResponse, site);
}
else
{
// Add error log
site.Assert.Fail("Schema validation fails, the reason is " + SchemaValidation.GenerateValidationResult());
}
}
