public static void Verify(Project view, Project real, ValidationContext context = null) { if (view == null && real == null) { return; } var pair = new ProjectPair(view, real); Verify(pair, context); }
public void ProjectPropertyModify() { var pcLocal = this.StdGroup.Local; var pcRemote = this.StdGroup.Remote[0]; var proj1Path = this.StdGroup.StdProjectFiles[0]; var realProj = pcRemote.LoadProject(proj1Path); pcLocal.Importing = true; var viewProj = pcLocal.Collection.GetLoadedProjects(proj1Path).FirstOrDefault(); ProjectPair pair = new ProjectPair(viewProj, realProj); ViewValidation.Verify(pair); pair.ValidatePropertyValue("fooProp", string.Empty); var fooView = pair.SetPropertyWithVerify(ObjectType.View, "fooProp", "fooValue$(xxx)"); var fooReal = pair.Real.GetProperty("fooProp"); Assert.Equal("fooValue", fooView.EvaluatedValue); pair.Real.SetGlobalProperty("xxx", "XXX"); Assert.Equal("fooValue", fooView.EvaluatedValue); pair.Real.ReevaluateIfNecessary(); // note msbuild create a new property objects on reevaluation. Assert.Equal("fooValue", fooView.EvaluatedValue); Assert.Equal("fooValue", fooReal.EvaluatedValue); var fooRealNew = pair.Real.GetProperty("fooProp"); var fooViewNew = pair.View.GetProperty("fooProp"); Assert.NotSame(fooReal, fooRealNew); Assert.NotSame(fooView, fooViewNew); Assert.Equal("fooValueXXX", fooViewNew.EvaluatedValue); fooViewNew.UnevaluatedValue = "fooValueChanged$(xxx)"; Assert.Equal("fooValueChanged$(xxx)", fooRealNew.UnevaluatedValue); // but when changing the Unevaluate via ProjectProp element it does update the live object. Assert.Equal("fooValueChangedXXX", fooViewNew.EvaluatedValue); Assert.Equal("fooValueChangedXXX", fooRealNew.EvaluatedValue); ViewValidation.Verify(pair); // note this should work even though the fooView is recycled. Assert.True(pair.View.RemoveProperty(fooView)); Assert.Null(pair.View.GetProperty("fooProp")); }
public void ResetBeforeTests() { this.Clear(); this.Local.Importing = true; { var targetView = this.Local.GetLoadedProjects(this.TargetBigPath).FirstOrDefault(); Assert.NotNull(targetView); var targetPair = new ProjectPair(targetView, this.TargetBig); this.TargetXmlPair = new ProjectXmlPair(targetPair); } { var guestView = this.Local.GetLoadedProjects(this.GuestBigPath).FirstOrDefault(); Assert.NotNull(guestView); var guestPair = new ProjectPair(guestView, this.GuestBig); this.GuestXmlPair = new ProjectXmlPair(guestPair); } }
public void ProjectGlobalPropertyModify() { var pcLocal = this.StdGroup.Local; var pcRemote = this.StdGroup.Remote[0]; var proj1Path = this.StdGroup.StdProjectFiles[0]; var realProj = pcRemote.LoadProject(proj1Path); pcLocal.Importing = true; var viewProj = pcLocal.Collection.GetLoadedProjects(proj1Path).FirstOrDefault(); ProjectPair pair = new ProjectPair(viewProj, realProj); ViewValidation.Verify(pair); Assert.False(pair.View.GlobalProperties.ContainsKey("gp1")); Assert.False(pair.View.GlobalProperties.ContainsKey("Configuration")); // at this point Configuration is not set and gp1 is not set. pair.ValidatePropertyValue("gpt1", "NotFoo"); pair.View.SetGlobalProperty("gp1", "GP1V"); Assert.True(pair.View.GlobalProperties.ContainsKey("gp1")); Assert.True(pair.Real.GlobalProperties.ContainsKey("gp1")); // not evaluated yet. pair.ValidatePropertyValue("gpt1", "NotFoo"); pair.View.ReevaluateIfNecessary(); pair.ValidatePropertyValue("gpt1", "NotFooGP1V"); pair.Real.SetGlobalProperty("Configuration", "Foo"); Assert.True(pair.View.GlobalProperties.ContainsKey("Configuration")); pair.ValidatePropertyValue("gpt1", "NotFooGP1V"); pair.View.ReevaluateIfNecessary(); pair.ValidatePropertyValue("gpt1", "FooGP1V"); }
public static void Verify(ProjectPair pair, ValidationContext context = null) { if (pair == null) { return; } var real = pair.Real; var view = pair.View; context ??= new ValidationContext(); context.Pair = pair; Verify(view.Xml, real.Xml); Verify(view.ItemsIgnoringCondition, real.ItemsIgnoringCondition, Verify, context); Verify(view.Items, real.Items, Verify, context); Verify(view.ItemDefinitions, real.ItemDefinitions, Verify, context); Verify(view.ConditionedProperties, real.ConditionedProperties, Verify, context); Verify(view.Properties, real.Properties, Verify, context); Verify(view.GlobalProperties, real.GlobalProperties, (a, b, p) => Assert.Equal(b, a), context); Verify(view.Imports, real.Imports, Verify, context); Verify(view.ItemTypes, real.ItemTypes, (a, b, p) => Assert.Equal(b, a), context); // this can only be used if project is loaded with ProjectLoadSettings.RecordDuplicateButNotCircularImports // or it throws otherwise. Slightly odd and inconvenient API design, but thats how it is. bool isImportsIncludingDuplicatesAvailable = false; try { var testLoadSettings = real.ImportsIncludingDuplicates; isImportsIncludingDuplicatesAvailable = true; } catch { } if (isImportsIncludingDuplicatesAvailable) { Verify(view.ImportsIncludingDuplicates, real.ImportsIncludingDuplicates, Verify, context); } Verify(view.AllEvaluatedProperties, real.AllEvaluatedProperties, Verify, context); Verify(view.AllEvaluatedItemDefinitionMetadata, real.AllEvaluatedItemDefinitionMetadata, Verify, context); Verify(view.AllEvaluatedItems, real.AllEvaluatedItems, Verify, context); Assert.NotSame(view.ProjectCollection, real.ProjectCollection); Assert.Equal(real.ToolsVersion, view.ToolsVersion); Assert.Equal(real.SubToolsetVersion, view.SubToolsetVersion); Assert.Equal(real.DirectoryPath, view.DirectoryPath); Assert.Equal(real.FullPath, view.FullPath); Assert.Equal(real.SkipEvaluation, view.SkipEvaluation); Assert.Equal(real.ThrowInsteadOfSplittingItemElement, view.ThrowInsteadOfSplittingItemElement); Assert.Equal(real.IsDirty, view.IsDirty); Assert.Equal(real.DisableMarkDirty, view.DisableMarkDirty); Assert.Equal(real.IsBuildEnabled, view.IsBuildEnabled); VerifySameLocation(real.ProjectFileLocation, view.ProjectFileLocation, context); // we currently dont support "Execution" remoting. // Verify(view.Targets, real.Targets, Verify, view, real); Assert.Equal(real.EvaluationCounter, view.EvaluationCounter); Assert.Equal(real.LastEvaluationId, view.LastEvaluationId); }
public ValidationContext(ProjectPair pair) { this.Pair = pair; }
public void ProjectItemModify() { var pcLocal = this.StdGroup.Local; var pcRemote = this.StdGroup.Remote[0]; var proj1Path = this.StdGroup.StdProjectFiles[0]; var realProj = pcRemote.LoadProject(proj1Path); pcLocal.Importing = true; var viewProj = pcLocal.Collection.GetLoadedProjects(proj1Path).FirstOrDefault(); ProjectPair pair = new ProjectPair(viewProj, realProj); ViewValidation.Verify(pair); List <KeyValuePair <string, string> > testMedatada = new List <KeyValuePair <string, string> >() { new KeyValuePair <string, string>("a", "aValue"), new KeyValuePair <string, string>("b", "bValue"), }; /// test AddItems // add a new files in the view, ensure it is added correctly and also the real object will immediately reflect that add as well Assert.Null(pair.GetSingleItemWithVerify(ObjectType.View, "foo.cpp")); var fooView = pair.AddSingleItemWithVerify(ObjectType.View, "cpp", "foo.cpp"); Assert.Null(pair.GetSingleItemWithVerify(ObjectType.View, "fooFast.cpp")); var fooViewFast = pair.AddSingleItemFastWithVerify(ObjectType.View, "cpp", "fooFast.cpp"); Assert.Null(pair.GetSingleItemWithVerify(ObjectType.View, "fooWithMetadata.cpp")); var fooWithMetadataView = pair.AddSingleItemWithVerify(ObjectType.View, "cpp", "fooWithMetadata.cpp", testMedatada); Assert.Null(pair.GetSingleItemWithVerify(ObjectType.View, "fooWithMetadataFast.cpp")); var fooWithMetadataViewFast = pair.AddSingleItemWithVerify(ObjectType.View, "cpp", "fooWithMetadataFast.cpp", testMedatada); // add a new files in the real, ensure it is added correctly and also the view object will immediately reflect that add as well Assert.Null(pair.GetSingleItemWithVerify(ObjectType.Real, "bar.cpp")); var barReal = pair.AddSingleItemWithVerify(ObjectType.Real, "cpp", "bar.cpp"); Assert.Null(pair.GetSingleItemWithVerify(ObjectType.Real, "barFast.cpp")); var barRealFast = pair.AddSingleItemFastWithVerify(ObjectType.Real, "cpp", "barFast.cpp"); Assert.Null(pair.GetSingleItemWithVerify(ObjectType.Real, "barWithMetadata.cpp")); var barWithMetadataReal = pair.AddSingleItemWithVerify(ObjectType.Real, "cpp", "barWithMetadata.cpp", testMedatada); Assert.Null(pair.GetSingleItemWithVerify(ObjectType.Real, "barWithMetadataFast.cpp")); var barWithMetadataRealFast = pair.AddSingleItemWithVerify(ObjectType.Real, "cpp", "barWithMetadataFast.cpp", testMedatada); ViewValidation.Verify(pair); // Test remove items. var validationContext = new ValidationContext(pair); // remove single from view { Assert.NotNull(pair.GetSingleItemWithVerify(ObjectType.View, "barWithMetadataFast.cpp")); var barWithMetadataViewFast = pair.GetSingleItemWithVerify(ObjectType.View, "barWithMetadataFast.cpp"); Assert.NotNull(barWithMetadataViewFast); ViewValidation.Verify(barWithMetadataViewFast, barWithMetadataRealFast, validationContext); Assert.Throws <ArgumentException>(() => { pair.Real.RemoveItem(barWithMetadataViewFast); }); pair.View.RemoveItem(barWithMetadataViewFast); Assert.Null(pair.GetSingleItemWithVerify(ObjectType.View, "barWithMetadataFast.cpp")); } // remove multiple from view { Assert.NotNull(pair.GetSingleItemWithVerify(ObjectType.View, "fooWithMetadata.cpp")); var barWithMetadataView = pair.GetSingleItemWithVerify(ObjectType.View, "barWithMetadata.cpp"); Assert.NotNull(barWithMetadataView); ViewValidation.Verify(barWithMetadataView, barWithMetadataReal, validationContext); var toRemoveView = new List <ProjectItem>() { barWithMetadataView, fooWithMetadataView }; Assert.Throws <ArgumentException>(() => { pair.Real.RemoveItems(toRemoveView); }); pair.View.RemoveItems(toRemoveView); Assert.Null(pair.GetSingleItemWithVerify(ObjectType.View, "fooWithMetadata.cpp")); Assert.Null(pair.GetSingleItemWithVerify(ObjectType.View, "barWithMetadata.cpp")); } // remove single from real { Assert.NotNull(pair.GetSingleItemWithVerify(ObjectType.Real, "fooWithMetadataFast.cpp")); var fooWithMetadataRealFast = pair.GetSingleItemWithVerify(ObjectType.Real, "fooWithMetadataFast.cpp"); Assert.NotNull(fooWithMetadataRealFast); ViewValidation.Verify(fooWithMetadataViewFast, fooWithMetadataRealFast, validationContext); // Note in reality we do not guarantee that the Export provider will re-throw exactly the same exception. // (some exception can be hard to marshal) Current mock does in fact forward exact exception.) Assert.Throws <ArgumentException>(() => { pair.View.RemoveItem(fooWithMetadataRealFast); }); pair.Real.RemoveItem(fooWithMetadataRealFast); Assert.Null(pair.GetSingleItemWithVerify(ObjectType.Real, "fooWithMetadataFast.cpp")); } // remove multiple from real { Assert.NotNull(pair.GetSingleItemWithVerify(ObjectType.Real, "barFast.cpp")); var fooRealFast = pair.GetSingleItemWithVerify(ObjectType.Real, "fooFast.cpp"); Assert.NotNull(fooRealFast); ViewValidation.Verify(fooViewFast, fooRealFast, validationContext); var toRemoveReal = new List <ProjectItem>() { fooRealFast, barRealFast }; Assert.Throws <ArgumentException>(() => { pair.View.RemoveItems(toRemoveReal); }); pair.Real.RemoveItems(toRemoveReal); Assert.Null(pair.GetSingleItemWithVerify(ObjectType.Real, "fooFast.cpp")); Assert.Null(pair.GetSingleItemWithVerify(ObjectType.Real, "barFast.cpp")); } // Check metadata modify var fooReal = pair.GetSingleItemWithVerify(ObjectType.Real, "foo.cpp"); ViewValidation.Verify(fooView, fooReal, validationContext); Assert.False(fooView.HasMetadata("xx")); fooView.SetMetadataValue("xx", "xxValue"); Assert.True(fooView.HasMetadata("xx")); Assert.Equal("xxValue", fooView.GetMetadataValue("xx")); ViewValidation.Verify(fooView, fooReal, validationContext); Assert.False(fooView.RemoveMetadata("xxNone")); Assert.True(fooView.RemoveMetadata("xx")); Assert.False(fooView.HasMetadata("xx")); ViewValidation.Verify(fooView, fooReal, validationContext); // now check metadata modify via real also affect view. Assert.False(fooView.HasMetadata("xxReal")); fooReal.SetMetadataValue("xxReal", "xxRealValue"); Assert.True(fooView.HasMetadata("xxReal")); Assert.Equal("xxRealValue", fooView.GetMetadataValue("xxReal")); ViewValidation.Verify(fooView, fooReal, validationContext); Assert.True(fooReal.RemoveMetadata("xxReal")); Assert.False(fooView.HasMetadata("xxReal")); ViewValidation.Verify(fooView, fooReal, validationContext); // TODO: test the boolean form (low value for linking really). // ItemType set. Assert.Equal("cpp", fooView.ItemType); fooView.ItemType = "cpp2"; Assert.Equal("cpp2", fooView.ItemType); Assert.Equal("cpp2", fooReal.ItemType); fooReal.ItemType = "cpp3"; Assert.Equal("cpp3", fooView.ItemType); Assert.Equal("cpp3", fooReal.ItemType); ViewValidation.Verify(fooView, fooReal, validationContext); // UnevaluatedInclude set Assert.Equal("foo.cpp", fooView.UnevaluatedInclude); fooView.UnevaluatedInclude = "fooRenamed.cpp"; Assert.Equal("fooRenamed.cpp", fooView.UnevaluatedInclude); Assert.Equal("fooRenamed.cpp", fooReal.UnevaluatedInclude); fooReal.UnevaluatedInclude = "fooRenamedAgain.cpp"; Assert.Equal("fooRenamedAgain.cpp", fooView.UnevaluatedInclude); Assert.Equal("fooRenamedAgain.cpp", fooReal.UnevaluatedInclude); ViewValidation.Verify(fooView, fooReal, validationContext); // Rename. fooView.Rename("fooRenamedOnceMore.cpp"); Assert.Equal("fooRenamedOnceMore.cpp", fooView.UnevaluatedInclude); Assert.Equal("fooRenamedOnceMore.cpp", fooReal.UnevaluatedInclude); fooReal.Rename("fooRenamedLastTimeForSure.cpp"); Assert.Equal("fooRenamedLastTimeForSure.cpp", fooView.UnevaluatedInclude); Assert.Equal("fooRenamedLastTimeForSure.cpp", fooReal.UnevaluatedInclude); ViewValidation.Verify(fooView, fooReal, validationContext); // and finally again verify the two projects are equivalent as a whole. ViewValidation.Verify(pair); }
public ProjectXmlPair(ProjectPair pair) : base(null, pair.View.Xml, pair.Real.Xml) { this.Project = pair; this.PRE = this; }