public static void CompareMarkup(Markup expectedMarkup, Markup actualMarkup, ZipArchive expectedArchive, ZipArchive actualArchive) { // Compare Header Section if (TestCompareUtilities.BothNotNull(expectedMarkup.Header, actualMarkup.Header, "Markup.Header")) { foreach (var currentHeaderEntry in expectedMarkup.Header) { var foundExactlyOneMatchignEntryInActual = actualMarkup.Header .Where(curr => curr.Date == currentHeaderEntry.Date) .Where(curr => curr.Filename == currentHeaderEntry.Filename) .Where(curr => curr.IfcProject == currentHeaderEntry.IfcProject) .Where(curr => curr.IfcSpatialStructureElement == currentHeaderEntry.IfcSpatialStructureElement) .Where(curr => curr.isExternal == currentHeaderEntry.isExternal) .Where(curr => curr.Reference == currentHeaderEntry.Reference) .Count() == 1; Assert.True(foundExactlyOneMatchignEntryInActual, "Found not matching header entry in actual file."); } // Check that the both sections contain the same number of entries Assert.Equal(expectedMarkup.Header.Count, actualMarkup.Header.Count); } CompareComments(expectedMarkup.Comment, actualMarkup.Comment); if (TestCompareUtilities.BothNotNull(expectedMarkup.Viewpoints, actualMarkup.Viewpoints, "Markup.Viewpoints")) { CompareViewpoints(expectedMarkup.Viewpoints, actualMarkup.Viewpoints, expectedArchive, actualArchive, expectedMarkup.Topic.Guid); } if (TestCompareUtilities.BothNotNull(expectedMarkup.Topic, actualMarkup.Topic, "Markup.Topic")) { CompareTopic(expectedMarkup.Topic, actualMarkup.Topic); } }
/// <summary> /// Will compare the project and version descriptions within the file /// </summary> /// <param name="expectedContainer"></param> /// <param name="actualContainer"></param> public static void CompareProjectAndVersion(BCFv2Container expectedContainer, BCFv2Container actualContainer) { // Compare project if (TestCompareUtilities.BothNotNull(expectedContainer.BcfProject, actualContainer.BcfProject, "BCFProject")) { if (TestCompareUtilities.BothNotNull(expectedContainer.BcfProject.Project, actualContainer.BcfProject.Project, "BCFProject.Project")) { Assert.Equal(expectedContainer.BcfProject.Project.Name, actualContainer.BcfProject.Project.Name); Assert.Equal(expectedContainer.BcfProject.Project.ProjectId, actualContainer.BcfProject.Project.ProjectId); } Assert.Equal(expectedContainer.BcfProject.ExtensionSchema, actualContainer.BcfProject.ExtensionSchema); } // Compare version if (TestCompareUtilities.BothNotNull(expectedContainer.BcfVersionInfo, actualContainer.BcfVersionInfo, "BCFVersionInfo")) { if (expectedContainer.BcfVersionInfo.VersionId.Contains("2.0")) { Assert.Contains("2.0", actualContainer.BcfVersionInfo.VersionId); } else { Assert.True(false, "Unrecognized VersionId"); } } }
public static void CompareProjectExtensions(BCFv2Container expectedContainer, BCFv2Container actualContainer) { if (TestCompareUtilities.BothNotNull(expectedContainer.ProjectExtensions, actualContainer.ProjectExtensions, "ProjectExtensions")) { CompareStringList(expectedContainer.ProjectExtensions.SnippetType, actualContainer.ProjectExtensions.SnippetType, "SnippetType"); CompareStringList(expectedContainer.ProjectExtensions.Priority, actualContainer.ProjectExtensions.Priority, "Priority"); CompareStringList(expectedContainer.ProjectExtensions.TopicStatus, actualContainer.ProjectExtensions.TopicStatus, "TopicStatus"); CompareStringList(expectedContainer.ProjectExtensions.TopicType, actualContainer.ProjectExtensions.TopicType, "TopicType"); CompareStringList(expectedContainer.ProjectExtensions.UserIdType, actualContainer.ProjectExtensions.UserIdType, "UserIdType"); CompareStringList(expectedContainer.ProjectExtensions.TopicLabel, actualContainer.ProjectExtensions.TopicLabel, "TopicLabel"); } }
/// <summary> /// </summary> /// <param name="expectedViewpoint"></param> /// <param name="actualViewpoint"></param> /// <param name="originatesFromApiConversion">If true, Bitmaps are not compared since the API does not support them</param> public static void CompareSingleViewpoints(VisualizationInfo expectedViewpoint, VisualizationInfo actualViewpoint, bool originatesFromApiConversion) { Assert.Equal(expectedViewpoint.GUID, actualViewpoint.GUID); // Compare Bitmaps if (!originatesFromApiConversion && TestCompareUtilities.BothNotNull(expectedViewpoint.Bitmaps, actualViewpoint.Bitmaps, "Viewpoint.Bitmaps")) { Assert.Equal(expectedViewpoint.Bitmaps.Count, actualViewpoint.Bitmaps.Count); foreach (var expectedBitmap in expectedViewpoint.Bitmaps) { var actualBitmap = actualViewpoint.Bitmaps .Where(curr => curr.Bitmap == expectedBitmap.Bitmap) .Where(curr => curr.Height == expectedBitmap.Height) .Where(curr => curr.Location.X == expectedBitmap.Location.X) .Where(curr => curr.Location.Y == expectedBitmap.Location.Y) .Where(curr => curr.Location.Z == expectedBitmap.Location.Z) .Where(curr => curr.Normal.X == expectedBitmap.Normal.X) .Where(curr => curr.Normal.Y == expectedBitmap.Normal.Y) .Where(curr => curr.Normal.Z == expectedBitmap.Normal.Z) .Where(curr => curr.Reference == expectedBitmap.Reference) .Where(curr => curr.Up.X == expectedBitmap.Up.X) .Where(curr => curr.Up.Y == expectedBitmap.Up.Y) .Where(curr => curr.Up.Z == expectedBitmap.Up.Z) .FirstOrDefault(); Assert.NotNull(actualViewpoint); } } // Compare Components if (TestCompareUtilities.BothNotNull(expectedViewpoint.Components, actualViewpoint.Components, "Viewpoint.Components")) { if (expectedViewpoint.Components.Count == 1 && actualViewpoint.Components.Count == 1) { var expectedComponent = expectedViewpoint.Components.First(); var actualComponent = actualViewpoint.Components.First(); Assert.Equal(expectedComponent.AuthoringToolId, actualComponent.AuthoringToolId); Assert.True((expectedComponent.Color == null && actualComponent.Color == null) || expectedComponent.Color.SequenceEqual(actualComponent.Color), "Color"); Assert.Equal(expectedComponent.IfcGuid, actualComponent.IfcGuid); Assert.Equal(expectedComponent.OriginatingSystem, actualComponent.OriginatingSystem); Assert.Equal(expectedComponent.Selected, actualComponent.Selected); Assert.Equal(expectedComponent.Visible, actualComponent.Visible); } else { foreach (var currentComponent in expectedViewpoint.Components) { var actualComponent = actualViewpoint.Components .Where(curr => curr.AuthoringToolId == currentComponent.AuthoringToolId) .Where(curr => (curr.Color == null && currentComponent.Color == null) || curr.Color.SequenceEqual(currentComponent.Color)) .Where(curr => curr.IfcGuid == currentComponent.IfcGuid) .Where(curr => curr.OriginatingSystem == currentComponent.OriginatingSystem) .Where(curr => curr.Selected == currentComponent.Selected) .Where(curr => curr.Visible == currentComponent.Visible) .FirstOrDefault(); Assert.NotNull(actualComponent); } } } // Compare Lines if (TestCompareUtilities.BothNotNull(expectedViewpoint.Lines, actualViewpoint.Lines, "Viewpoint.Lines")) { foreach (var expectedLine in expectedViewpoint.Lines) { var actualLine = actualViewpoint.Lines .Where(curr => curr.EndPoint.X == expectedLine.EndPoint.X) .Where(curr => curr.EndPoint.Y == expectedLine.EndPoint.Y) .Where(curr => curr.EndPoint.Z == expectedLine.EndPoint.Z) .Where(curr => curr.StartPoint.X == expectedLine.StartPoint.X) .Where(curr => curr.StartPoint.Y == expectedLine.StartPoint.Y) .Where(curr => curr.StartPoint.Z == expectedLine.StartPoint.Z) .FirstOrDefault(); Assert.NotNull(actualLine); } } // Compare Clipping planes if (TestCompareUtilities.BothNotNull(expectedViewpoint.ClippingPlanes, actualViewpoint.ClippingPlanes, "Viewpoint.ClippingPlanes")) { foreach (var expectedPlane in expectedViewpoint.ClippingPlanes) { var actualPlane = actualViewpoint.ClippingPlanes .Where(curr => curr.Direction.X == expectedPlane.Direction.X) .Where(curr => curr.Direction.Y == expectedPlane.Direction.Y) .Where(curr => curr.Direction.Z == expectedPlane.Direction.Z) .Where(curr => curr.Location.X == expectedPlane.Location.X) .Where(curr => curr.Location.Y == expectedPlane.Location.Y) .Where(curr => curr.Location.Z == expectedPlane.Location.Z) .FirstOrDefault(); Assert.NotNull(actualPlane); } } // Compare OrthogonalCamera if (TestCompareUtilities.BothNotNull(expectedViewpoint.OrthogonalCamera, actualViewpoint.OrthogonalCamera, "Viewpoint.OrthogonalCamera")) { CompareOrthogonalCameras(expectedViewpoint.OrthogonalCamera, actualViewpoint.OrthogonalCamera); } // Compare PerspectiveCamera if (TestCompareUtilities.BothNotNull(expectedViewpoint.PerspectiveCamera, actualViewpoint.PerspectiveCamera, "Viewpoint.PerspectiveCamera")) { ComparePerspectiveCameras(expectedViewpoint.PerspectiveCamera, actualViewpoint.PerspectiveCamera); } }
public static void CompareTopic(Topic expectedTopic, Topic actualTopic) { Assert.Equal(expectedTopic.AssignedTo, actualTopic.AssignedTo); // Compare Snippet if (TestCompareUtilities.BothNotNull(expectedTopic.BimSnippet, actualTopic.BimSnippet, "Markup.BimSnippet")) { CompareBimSnippet(expectedTopic.BimSnippet, actualTopic.BimSnippet); } // Compare document references if (TestCompareUtilities.BothNotNull(expectedTopic.DocumentReferences, actualTopic.DocumentReferences, "Markup.DocumentReferences")) { Assert.Equal(expectedTopic.DocumentReferences.Count, actualTopic.DocumentReferences.Count); foreach (var expectedDocumentReference in expectedTopic.DocumentReferences) { // Find the matching document reference in the actual topic var actualDocumentReference = actualTopic.DocumentReferences .Where(curr => curr.Description == expectedDocumentReference.Description) .Where(curr => curr.Guid == expectedDocumentReference.Guid) .Where(curr => curr.isExternal == expectedDocumentReference.isExternal) .Where(curr => curr.ReferencedDocument == expectedDocumentReference.ReferencedDocument) .FirstOrDefault(); Assert.NotNull(actualDocumentReference); } } // Check labels if (TestCompareUtilities.BothNotNull(expectedTopic.Labels, actualTopic.Labels, "Markup.Labels")) { Assert.Equal(expectedTopic.Labels.Count, actualTopic.Labels.Count); foreach (var expectedLabel in expectedTopic.Labels) { Assert.Contains(expectedLabel, actualTopic.Labels); } } // Check related topics if (TestCompareUtilities.BothNotNull(expectedTopic.RelatedTopics, actualTopic.RelatedTopics, "Markup.RelatedTopics")) { Assert.Equal(expectedTopic.RelatedTopics.Count, actualTopic.RelatedTopics.Count); foreach (var expectedRelatedTopic in expectedTopic.RelatedTopics) { var actualRelatedTopic = actualTopic.RelatedTopics .Where(curr => curr.Guid == expectedRelatedTopic.Guid) .FirstOrDefault(); Assert.NotNull(actualRelatedTopic); } } Assert.Equal(expectedTopic.CreationAuthor, actualTopic.CreationAuthor); Assert.True((int)(expectedTopic.CreationDate - actualTopic.CreationDate).TotalSeconds < 5); Assert.Equal(expectedTopic.CreationDateSpecified, actualTopic.CreationDateSpecified); if (!(string.IsNullOrWhiteSpace(expectedTopic.Description) && string.IsNullOrWhiteSpace(actualTopic.Description))) { Assert.Equal(expectedTopic.Description, actualTopic.Description); } Assert.Equal(expectedTopic.Guid, actualTopic.Guid); if (expectedTopic.Index != actualTopic.Index) { if (!(expectedTopic.Index != null && expectedTopic.Index.Trim() == "0" && string.IsNullOrWhiteSpace(actualTopic.Index) || actualTopic.Index != null && actualTopic.Index.Trim() == "0" && string.IsNullOrWhiteSpace(expectedTopic.Index))) { Assert.True(false, "Index does not match"); } } Assert.Equal(expectedTopic.ModifiedAuthor, actualTopic.ModifiedAuthor); Assert.Equal(expectedTopic.ModifiedDate, actualTopic.ModifiedDate); Assert.Equal(expectedTopic.ModifiedDateSpecified, actualTopic.ModifiedDateSpecified); Assert.Equal(expectedTopic.Priority, actualTopic.Priority); Assert.Equal(expectedTopic.ReferenceLink, actualTopic.ReferenceLink); Assert.Equal(expectedTopic.Title, actualTopic.Title); Assert.Equal(expectedTopic.TopicStatus, actualTopic.TopicStatus); Assert.Equal(expectedTopic.TopicType, actualTopic.TopicType); }