private static void CompareComponents(Components expectedComponents, Components actualComponents) { if (TestCompareUtilities.BothNotNullAndEmpty(expectedComponents.Coloring, actualComponents.Coloring, "Viewpoint.Components.Coloring")) { Assert.Equal(expectedComponents.Coloring.Count, actualComponents.Coloring.Count); foreach (var expectedColoring in expectedComponents.Coloring) { var actualColoring = actualComponents.Coloring.FirstOrDefault(c => c.Color == expectedColoring.Color); Assert.NotNull(actualColoring); CompareComponentsList(expectedColoring.Component, actualColoring.Component); } var allActualColorsAreExpected = actualComponents.Coloring.All(c => expectedComponents.Coloring.Any(ec => ec.Color == c.Color)); Assert.True(allActualColorsAreExpected); } CompareComponentsList(expectedComponents.Selection, actualComponents.Selection); if (TestCompareUtilities.BothNotNullAndEmpty(expectedComponents.ViewSetupHints, actualComponents.ViewSetupHints, "Viewpoint.Components.ViewSetupHints")) { var expectedViewSetupHints = expectedComponents.ViewSetupHints; var actualViewSetupHints = actualComponents.ViewSetupHints; Assert.Equal(expectedViewSetupHints.OpeningsVisible, actualViewSetupHints.OpeningsVisible); Assert.Equal(expectedViewSetupHints.SpaceBoundariesVisible, actualViewSetupHints.SpaceBoundariesVisible); Assert.Equal(expectedViewSetupHints.SpacesVisible, actualViewSetupHints.SpacesVisible); } if (TestCompareUtilities.BothNotNullAndEmpty(expectedComponents.Visibility, actualComponents.Visibility, "Viewpoint.Components.Visibility")) { var expectedVisibility = expectedComponents.Visibility; var actualVisibility = actualComponents.Visibility; Assert.Equal(expectedVisibility.DefaultVisibility, actualVisibility.DefaultVisibility); CompareComponentsList(expectedVisibility.Exceptions, actualVisibility.Exceptions); } }
public static void CompareMarkup(Markup expectedMarkup, Markup actualMarkup, ZipArchive expectedArchive, ZipArchive actualArchive) { // Compare Header Section if (TestCompareUtilities.BothNotNullAndEmpty(expectedMarkup.Header, actualMarkup.Header, "Markup.Header")) { foreach (var currentHeaderEntry in expectedMarkup.Header) { var foundExactlyOneMatchignEntryInActual = actualMarkup.Header .Where(h => h.Date == currentHeaderEntry.Date) .Where(h => h.Filename == currentHeaderEntry.Filename) .Where(h => h.IfcProject == currentHeaderEntry.IfcProject) .Where(h => h.IfcSpatialStructureElement == currentHeaderEntry.IfcSpatialStructureElement) .Where(h => h.isExternal == currentHeaderEntry.isExternal) .Where(h => h.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.BothNotNullAndEmpty(expectedMarkup.Viewpoints, actualMarkup.Viewpoints, "Markup.Viewpoints")) { CompareViewpoints(expectedMarkup.Viewpoints, actualMarkup.Viewpoints, expectedArchive, actualArchive, expectedMarkup.Topic.Guid); } if (TestCompareUtilities.BothNotNullAndEmpty(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(BCFv21Container expectedContainer, BCFv21Container actualContainer) { // Compare project if (TestCompareUtilities.BothNotNullAndEmpty(expectedContainer.BcfProject, actualContainer.BcfProject, "BCFProject")) { if (TestCompareUtilities.BothNotNullAndEmpty(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.BothNotNullAndEmpty(expectedContainer.BcfVersionInfo, actualContainer.BcfVersionInfo, "BCFVersionInfo")) { if (expectedContainer.BcfVersionInfo.VersionId.Contains("2.1")) { Assert.Contains("2.1", actualContainer.BcfVersionInfo.VersionId); } else { Assert.True(false, "Unrecognized VersionId"); } } }
public static void CompareProjectExtensions(BCFv21Container expectedContainer, BCFv21Container actualContainer) { if (TestCompareUtilities.BothNotNullAndEmpty(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.BothNotNullAndEmpty(expectedViewpoint.Bitmap, actualViewpoint.Bitmap, "Viewpoint.Bitmaps")) { Assert.Equal(expectedViewpoint.Bitmap.Count, actualViewpoint.Bitmap.Count); foreach (var expectedBitmap in expectedViewpoint.Bitmap) { var actualBitmap = actualViewpoint.Bitmap .Where(b => b.Bitmap == expectedBitmap.Bitmap) .Where(b => b.Height == expectedBitmap.Height) .Where(b => b.Location.X == expectedBitmap.Location.X) .Where(b => b.Location.Y == expectedBitmap.Location.Y) .Where(b => b.Location.Z == expectedBitmap.Location.Z) .Where(b => b.Normal.X == expectedBitmap.Normal.X) .Where(b => b.Normal.Y == expectedBitmap.Normal.Y) .Where(b => b.Normal.Z == expectedBitmap.Normal.Z) .Where(b => b.Reference == expectedBitmap.Reference) .Where(b => b.Up.X == expectedBitmap.Up.X) .Where(b => b.Up.Y == expectedBitmap.Up.Y) .Where(b => b.Up.Z == expectedBitmap.Up.Z) .FirstOrDefault(); Assert.NotNull(actualViewpoint); } } // Compare Components if (TestCompareUtilities.BothNotNullAndEmpty(expectedViewpoint.Components, actualViewpoint.Components, "Viewpoint.Components")) { CompareComponents(expectedViewpoint.Components, actualViewpoint.Components); } // Compare Lines if (TestCompareUtilities.BothNotNullAndEmpty(expectedViewpoint.Lines, actualViewpoint.Lines, "Viewpoint.Lines")) { foreach (var expectedLine in expectedViewpoint.Lines) { var actualLine = actualViewpoint.Lines .Where(l => l.EndPoint.X == expectedLine.EndPoint.X) .Where(l => l.EndPoint.Y == expectedLine.EndPoint.Y) .Where(l => l.EndPoint.Z == expectedLine.EndPoint.Z) .Where(l => l.StartPoint.X == expectedLine.StartPoint.X) .Where(l => l.StartPoint.Y == expectedLine.StartPoint.Y) .Where(l => l.StartPoint.Z == expectedLine.StartPoint.Z) .FirstOrDefault(); Assert.NotNull(actualLine); } } // Compare Clipping planes if (TestCompareUtilities.BothNotNullAndEmpty(expectedViewpoint.ClippingPlanes, actualViewpoint.ClippingPlanes, "Viewpoint.ClippingPlanes")) { foreach (var expectedPlane in expectedViewpoint.ClippingPlanes) { var actualPlane = actualViewpoint.ClippingPlanes .Where(c => c.Direction.X == expectedPlane.Direction.X) .Where(c => c.Direction.Y == expectedPlane.Direction.Y) .Where(c => c.Direction.Z == expectedPlane.Direction.Z) .Where(c => c.Location.X == expectedPlane.Location.X) .Where(c => c.Location.Y == expectedPlane.Location.Y) .Where(c => c.Location.Z == expectedPlane.Location.Z) .FirstOrDefault(); Assert.NotNull(actualPlane); } } // Compare OrthogonalCamera if (TestCompareUtilities.BothNotNullAndEmpty(expectedViewpoint.OrthogonalCamera, actualViewpoint.OrthogonalCamera, "Viewpoint.OrthogonalCamera")) { CompareOrthogonalCameras(expectedViewpoint.OrthogonalCamera, actualViewpoint.OrthogonalCamera); } // Compare PerspectiveCamera if (TestCompareUtilities.BothNotNullAndEmpty(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.BothNotNullAndEmpty(expectedTopic.BimSnippet, actualTopic.BimSnippet, "Markup.BimSnippet")) { CompareBimSnippet(expectedTopic.BimSnippet, actualTopic.BimSnippet); } // Compare document references if (TestCompareUtilities.BothNotNullAndEmpty(expectedTopic.DocumentReference, actualTopic.DocumentReference, "Markup.DocumentReferences")) { Assert.Equal(expectedTopic.DocumentReference.Count, actualTopic.DocumentReference.Count); foreach (var expectedDocumentReference in expectedTopic.DocumentReference) { // Find the matching document reference in the actual topic var actualDocumentReference = actualTopic.DocumentReference .Where(d => d.Description == expectedDocumentReference.Description) .Where(d => d.Guid == expectedDocumentReference.Guid) .Where(d => d.isExternal == expectedDocumentReference.isExternal) .Where(d => d.ReferencedDocument == expectedDocumentReference.ReferencedDocument) .FirstOrDefault(); Assert.NotNull(actualDocumentReference); } } // Check labels if (TestCompareUtilities.BothNotNullAndEmpty(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.BothNotNullAndEmpty(expectedTopic.RelatedTopic, actualTopic.RelatedTopic, "Markup.RelatedTopics")) { Assert.Equal(expectedTopic.RelatedTopic.Count, actualTopic.RelatedTopic.Count); foreach (var expectedRelatedTopic in expectedTopic.RelatedTopic) { var actualRelatedTopic = actualTopic.RelatedTopic .Where(r => r.Guid == expectedRelatedTopic.Guid) .FirstOrDefault(); Assert.NotNull(actualRelatedTopic); } } Assert.Equal(expectedTopic.CreationAuthor, actualTopic.CreationAuthor); Assert.True((int)(expectedTopic.CreationDate - actualTopic.CreationDate).TotalSeconds < 5); Assert.True(expectedTopic.ShouldSerializeCreationDate()); Assert.True(actualTopic.ShouldSerializeCreationDate()); 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) { 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); }