public static void Verify(ProjectTargetElement viewXml, ProjectTargetElement realXml, ValidationContext context = null) { if (viewXml == null && realXml == null) { return; } VerifyProjectElement(viewXml, realXml, context); Assert.Equal(realXml.Name, viewXml.Name); ViewValidation.VerifySameLocation(realXml.NameLocation, viewXml.NameLocation, context); Assert.Equal(realXml.Inputs, viewXml.Inputs); ViewValidation.VerifySameLocation(realXml.InputsLocation, viewXml.InputsLocation, context); Assert.Equal(realXml.Outputs, viewXml.Outputs); ViewValidation.VerifySameLocation(realXml.OutputsLocation, viewXml.OutputsLocation, context); Assert.Equal(realXml.KeepDuplicateOutputs, viewXml.KeepDuplicateOutputs); ViewValidation.VerifySameLocation(realXml.KeepDuplicateOutputsLocation, viewXml.KeepDuplicateOutputsLocation, context); Assert.Equal(realXml.DependsOnTargets, viewXml.DependsOnTargets); ViewValidation.VerifySameLocation(realXml.DependsOnTargetsLocation, viewXml.DependsOnTargetsLocation, context); Assert.Equal(realXml.BeforeTargets, viewXml.BeforeTargets); ViewValidation.VerifySameLocation(realXml.BeforeTargetsLocation, viewXml.BeforeTargetsLocation, context); Assert.Equal(realXml.AfterTargets, viewXml.AfterTargets); ViewValidation.VerifySameLocation(realXml.AfterTargetsLocation, viewXml.AfterTargetsLocation, context); Assert.Equal(realXml.Returns, viewXml.Returns); ViewValidation.VerifySameLocation(realXml.ReturnsLocation, viewXml.ReturnsLocation, context); ViewValidation.Verify(viewXml.ItemGroups, realXml.ItemGroups, ViewValidation.Verify, context); ViewValidation.Verify(viewXml.PropertyGroups, realXml.PropertyGroups, ViewValidation.Verify, context); ViewValidation.Verify(viewXml.OnErrors, realXml.OnErrors, ViewValidation.Verify, context); ViewValidation.Verify(viewXml.Tasks, realXml.Tasks, ViewValidation.Verify, context); }
public void ProjectRootElemetReadOnly() { var preReal = this.StdGroup.RealXml; var preView = this.StdGroup.ViewXml; ViewValidation.Verify(preView, preReal); }
public static void Verify(ProjectUsingTaskElement viewXml, ProjectUsingTaskElement realXml, ValidationContext context = null) { if (viewXml == null && realXml == null) { return; } VerifyProjectElement(viewXml, realXml, context); Assert.Equal(realXml.AssemblyFile, viewXml.AssemblyFile); ViewValidation.VerifySameLocation(realXml.AssemblyFileLocation, viewXml.AssemblyFileLocation, context); Assert.Equal(realXml.AssemblyName, viewXml.AssemblyName); ViewValidation.VerifySameLocation(realXml.AssemblyNameLocation, viewXml.AssemblyNameLocation, context); Assert.Equal(realXml.TaskName, viewXml.TaskName); ViewValidation.VerifySameLocation(realXml.TaskNameLocation, viewXml.TaskNameLocation, context); Assert.Equal(realXml.TaskFactory, viewXml.TaskFactory); ViewValidation.VerifySameLocation(realXml.TaskFactoryLocation, viewXml.TaskFactoryLocation, context); Assert.Equal(realXml.Runtime, viewXml.Runtime); ViewValidation.VerifySameLocation(realXml.RuntimeLocation, viewXml.RuntimeLocation, context); Assert.Equal(realXml.Architecture, viewXml.Architecture); ViewValidation.VerifySameLocation(realXml.ArchitectureLocation, viewXml.ArchitectureLocation, context); ViewValidation.Verify(viewXml.TaskBody, realXml.TaskBody, context); ViewValidation.Verify(viewXml.ParameterGroup, realXml.ParameterGroup, context); }
public void ProjectPropertiesReadOnly_Tests() { var viewProperties = this.StdGroup.View.Properties; var realProperties = this.StdGroup.Real.Properties; Assert.NotEmpty(viewProperties); ViewValidation.Verify(viewProperties, realProperties); }
public void ProjectMetadataReadOnly_Tests() { var viewMetadata = this.StdGroup.View.AllEvaluatedItemDefinitionMetadata; var realMetadata = this.StdGroup.Real.AllEvaluatedItemDefinitionMetadata; Assert.NotEmpty(viewMetadata); ViewValidation.Verify(viewMetadata, realMetadata); }
public void ProjectItemReadOnly_Tests() { var viewItems = this.StdGroup.View.AllEvaluatedItems; var realItems = this.StdGroup.Real.AllEvaluatedItems; Assert.NotEmpty(viewItems); ViewValidation.Verify(viewItems, realItems); }
public void ProjectItemDefinitionReadOnly_Tests() { var viewItemDefinitions = this.StdGroup.View.ItemDefinitions; var realItemDefinitions = this.StdGroup.Real.ItemDefinitions; Assert.NotEmpty(viewItemDefinitions); ViewValidation.Verify(viewItemDefinitions, realItemDefinitions, ViewValidation.Verify); }
public void ProjectChooseElementReadOnly() { var preReal = this.StdGroup.RealXml; var preView = this.StdGroup.ViewXml; Assert.NotEmpty(preReal.ChooseElements); ViewValidation.Verify(preView.ChooseElements, preReal.ChooseElements, ViewValidation.Verify); }
public static void Verify(ProjectItemDefinitionGroupElement viewXml, ProjectItemDefinitionGroupElement realXml, ValidationContext context = null) { if (viewXml == null && realXml == null) { return; } VerifyProjectElement(viewXml, realXml, context); ViewValidation.Verify(viewXml.ItemDefinitions, realXml.ItemDefinitions, ViewValidation.Verify, context); }
public void ProjectPropertyGroupElementReadOnly() { var preReal = this.StdGroup.RealXml; var preView = this.StdGroup.ViewXml; var realPropertieGroups = preReal.PropertyGroups.ToList(); var viewPropertieGroups = preView.PropertyGroups.ToList(); Assert.NotEmpty(realPropertieGroups); ViewValidation.Verify(viewPropertieGroups, realPropertieGroups, ViewValidation.Verify); }
public static void Verify(ProjectItemDefinitionElement viewXml, ProjectItemDefinitionElement realXml, ValidationContext context = null) { if (viewXml == null && realXml == null) { return; } VerifyProjectElement(viewXml, realXml, context); Assert.Equal(realXml.ItemType, viewXml.ItemType); ViewValidation.Verify(viewXml.Metadata, realXml.Metadata, ViewValidation.Verify, context); }
public void ProjectOutputElementReadOnly() { var preReal = this.StdGroup.RealXml; var preView = this.StdGroup.ViewXml; var realCollection = preReal.AllChildren.OfType <ProjectOutputElement>().ToList(); var viewCollection = preView.AllChildren.OfType <ProjectOutputElement>().ToList(); Assert.NotEmpty(realCollection); ViewValidation.Verify(viewCollection, realCollection, ViewValidation.Verify); }
public void ProjectUsingTaskElementReadOnly() { var preReal = this.StdGroup.RealXml; var preView = this.StdGroup.ViewXml; var realCollection = preReal.AllChildren.OfType <ProjectUsingTaskElement>().ToList(); var viewCollection = preView.AllChildren.OfType <ProjectUsingTaskElement>().ToList(); Assert.NotEmpty(realCollection); // to ensure we actually have some elements in test project ViewValidation.Verify(viewCollection, realCollection, ViewValidation.Verify); }
public void ProjectTargetElementReadOnly() { var preReal = this.StdGroup.RealXml; var preView = this.StdGroup.ViewXml; var realCollection = preReal.Targets.ToList(); var viewCollection = preView.Targets.ToList(); Assert.NotEmpty(realCollection); // to ensure we actually have some elements in test project ViewValidation.Verify(viewCollection, realCollection, ViewValidation.Verify); }
public void ProjectItemElementReadOnly() { var preReal = this.StdGroup.RealXml; var preView = this.StdGroup.ViewXml; var realItems = preReal.Items.ToList(); var viewlItems = preView.Items.ToList(); Assert.NotEmpty(realItems); ViewValidation.Verify(viewlItems, realItems, ViewValidation.Verify); }
private ProjectPair GetNewInMemoryProject(string path) { var tempPath = this.StdGroup.Disk.GetAbsolutePath(path); var newReal = this.StdGroup.Target.LoadInMemoryWithSettings(TestCollectionGroup.SampleProjectFile); newReal.Xml.FullPath = tempPath; var newView = this.StdGroup.Local.GetLoadedProjects(tempPath).FirstOrDefault(); Assert.NotNull(newView); ViewValidation.Verify(newView, newReal); return new ProjectPair(newView, newReal); }
public ProjectItem GetSingleItemWithVerify(ObjectType which, string evaluatedInclude) { var realItems = this.Real.GetItemsByEvaluatedInclude(evaluatedInclude); var viewItems = this.View.GetItemsByEvaluatedInclude(evaluatedInclude); ViewValidation.Verify(viewItems, realItems, ViewValidation.Verify, new ValidationContext(this)); if (viewItems == null || viewItems.Count == 0) { return(null); } Assert.Equal(1, viewItems.Count); return(which == ObjectType.View ? viewItems.First() : realItems.First()); }
private ProjectPair GetNewInMemoryProject(string path, string content = null) { content ??= TestCollectionGroup.SampleProjectFile; var tempPath = this.StdGroup.Disk.GetAbsolutePath(path); var newReal = this.StdGroup.Target.LoadInMemoryWithSettings(content, ProjectLoadSettings.IgnoreMissingImports); newReal.Xml.FullPath = tempPath; var newView = this.StdGroup.Local.GetLoadedProjects(tempPath).FirstOrDefault(); Assert.NotNull(newView); ViewValidation.Verify(newView, newReal); return(new ProjectPair(newView, newReal)); }
public ProjectProperty SetPropertyWithVerify(ObjectType where, string name, string unevaluatedValue) { var toAdd = this.Get(where); var added = toAdd.SetProperty(name, unevaluatedValue); Assert.NotNull(added); Assert.Same(added, toAdd.GetProperty(name)); Assert.Equal(unevaluatedValue, added.UnevaluatedValue); var view = this.View.GetProperty(name); var real = this.Real.GetProperty(name); ViewValidation.Verify(view, real, new ValidationContext(this)); return(added); }
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 static void Verify(ProjectRootElement viewXml, ProjectRootElement realXml, ValidationContext context = null) { if (viewXml == null && realXml == null) { return; } VerifyProjectElement(viewXml, realXml, context); Assert.Equal(realXml.FullPath, viewXml.FullPath); Assert.Equal(realXml.DirectoryPath, viewXml.DirectoryPath); Assert.Equal(realXml.Encoding, viewXml.Encoding); Assert.Equal(realXml.DefaultTargets, viewXml.DefaultTargets); Assert.Equal(realXml.InitialTargets, viewXml.InitialTargets); Assert.Equal(realXml.Sdk, viewXml.Sdk); Assert.Equal(realXml.TreatAsLocalProperty, viewXml.TreatAsLocalProperty); Assert.Equal(realXml.ToolsVersion, viewXml.ToolsVersion); Assert.Equal(realXml.HasUnsavedChanges, viewXml.HasUnsavedChanges); Assert.Equal(realXml.PreserveFormatting, viewXml.PreserveFormatting); Assert.Equal(realXml.Version, viewXml.Version); Assert.Equal(realXml.TimeLastChanged, viewXml.TimeLastChanged); Assert.Equal(realXml.LastWriteTimeWhenRead, viewXml.LastWriteTimeWhenRead); ViewValidation.VerifySameLocation(realXml.ProjectFileLocation, viewXml.ProjectFileLocation, context); ViewValidation.VerifySameLocation(realXml.ToolsVersionLocation, viewXml.ToolsVersionLocation, context); ViewValidation.VerifySameLocation(realXml.DefaultTargetsLocation, viewXml.DefaultTargetsLocation, context); ViewValidation.VerifySameLocation(realXml.InitialTargetsLocation, viewXml.InitialTargetsLocation, context); ViewValidation.VerifySameLocation(realXml.SdkLocation, viewXml.SdkLocation, context); ViewValidation.VerifySameLocation(realXml.TreatAsLocalPropertyLocation, viewXml.TreatAsLocalPropertyLocation, context); ViewValidation.Verify(viewXml.ChooseElements, realXml.ChooseElements, Verify, context); ViewValidation.Verify(viewXml.ItemDefinitionGroups, realXml.ItemDefinitionGroups, Verify, context); ViewValidation.Verify(viewXml.ItemDefinitions, realXml.ItemDefinitions, Verify, context); ViewValidation.Verify(viewXml.ItemGroups, realXml.ItemGroups, Verify, context); ViewValidation.Verify(viewXml.Items, realXml.Items, Verify, context); ViewValidation.Verify(viewXml.ImportGroups, realXml.ImportGroups, Verify, context); ViewValidation.Verify(viewXml.Imports, realXml.Imports, Verify, context); ViewValidation.Verify(viewXml.PropertyGroups, realXml.PropertyGroups, Verify, context); ViewValidation.Verify(viewXml.Properties, realXml.Properties, Verify, context); ViewValidation.Verify(viewXml.Targets, realXml.Targets, Verify, context); ViewValidation.Verify(viewXml.UsingTasks, realXml.UsingTasks, Verify, context); ViewValidation.Verify(viewXml.ItemGroupsReversed, realXml.ItemGroupsReversed, Verify, context); ViewValidation.Verify(viewXml.ItemDefinitionGroupsReversed, realXml.ItemDefinitionGroupsReversed, Verify, context); ViewValidation.Verify(viewXml.ImportGroupsReversed, realXml.ImportGroupsReversed, Verify, context); ViewValidation.Verify(viewXml.PropertyGroupsReversed, realXml.PropertyGroupsReversed, Verify, context); }
public void ProjectExtensionsElementReadOnly() { var preReal = this.StdGroup.RealXml; var preView = this.StdGroup.ViewXml; var realExtensionsList = preReal.ChildrenReversed.OfType <ProjectExtensionsElement>().ToList(); var viewExtensionsList = preView.ChildrenReversed.OfType <ProjectExtensionsElement>().ToList(); Assert.NotEmpty(realExtensionsList); ViewValidation.Verify(viewExtensionsList, realExtensionsList, ViewValidation.Verify); var realXml = realExtensionsList.FirstOrDefault(); var viewXml = viewExtensionsList.FirstOrDefault(); Assert.Equal(realXml["a"], viewXml["a"]); Assert.Equal(realXml["b"], viewXml["b"]); Assert.Equal("x", viewXml["a"]); Assert.Equal("y", viewXml["b"]); }
public ICollection <ElementLinkPair <CT> > QueryChildrenWithValidation <CT>(Func <T, IEnumerable> getter, Func <CT, bool> matcher) where CT : ProjectElement { var viewResult = new List <CT>(); var realResult = new List <CT>(); var finalResult = new List <ElementLinkPair <CT> >(); foreach (var v in getter(this.View)) { if (v is CT vt) { if (matcher(vt)) { viewResult.Add(vt); } } } foreach (var r in getter(this.Real)) { if (r is CT rt) { if (matcher(rt)) { realResult.Add(rt); } } } // slow form view VerifyFindType, since we dont know the T. ViewValidation.Verify(viewResult, realResult); for (int i = 0; i < viewResult.Count; i++) { finalResult.Add(new ElementLinkPair <CT>(this.PRE, viewResult[i], realResult[i])); } return(finalResult); }
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(ProjectTaskElement viewXml, ProjectTaskElement realXml, ValidationContext context = null) { if (viewXml == null && realXml == null) { return; } VerifyProjectElement(viewXml, realXml, context); Assert.Equal(realXml.Name, viewXml.Name); Assert.Equal(realXml.ContinueOnError, viewXml.ContinueOnError); ViewValidation.VerifySameLocation(realXml.ContinueOnErrorLocation, viewXml.ContinueOnErrorLocation, context); Assert.Equal(realXml.MSBuildRuntime, viewXml.MSBuildRuntime); ViewValidation.VerifySameLocation(realXml.MSBuildRuntimeLocation, viewXml.MSBuildRuntimeLocation, context); Assert.Equal(realXml.MSBuildArchitecture, viewXml.MSBuildArchitecture); ViewValidation.VerifySameLocation(realXml.MSBuildArchitectureLocation, viewXml.MSBuildArchitectureLocation, context); ViewValidation.Verify(viewXml.Outputs, realXml.Outputs, ViewValidation.Verify, context); var realParams = realXml.Parameters; var viewParams = viewXml.Parameters; if (realParams == null) { Assert.Null(viewParams); } else { Assert.NotNull(viewParams); Assert.Equal(realParams.Count, viewParams.Count); foreach (var k in realParams.Keys) { Assert.True(viewParams.ContainsKey(k)); Assert.Equal(realParams[k], viewParams[k]); } } var realParamsLoc = realXml.ParameterLocations; var viewParamsLoc = viewXml.ParameterLocations; if (realParamsLoc == null) { Assert.Null(viewParamsLoc); } else { Assert.NotNull(viewParamsLoc); var realPLocList = realParamsLoc.ToList(); var viewPLocList = viewParamsLoc.ToList(); Assert.Equal(realPLocList.Count, viewPLocList.Count); for (int li = 0; li < realPLocList.Count; li++) { var rkvp = realPLocList[li]; var vkvp = viewPLocList[li]; Assert.Equal(rkvp.Key, vkvp.Key); ViewValidation.VerifySameLocation(rkvp.Value, vkvp.Value, context); } } }
public void ProjectModifyRenameAndSafeAs() { 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(); ViewValidation.Verify(viewProj, realProj); var savedPath = this.StdGroup.Disk.GetAbsolutePath("Saved.proj"); Assert.NotEqual(proj1Path, savedPath); Assert.Equal(proj1Path, viewProj.FullPath); Assert.True(File.Exists(proj1Path)); Assert.False(File.Exists(savedPath)); var lwtBefore = new FileInfo(proj1Path).LastWriteTimeUtc; Assert.False(realProj.IsDirty); Assert.False(viewProj.IsDirty); viewProj.FullPath = savedPath; Assert.Equal(savedPath, realProj.FullPath); Assert.True(realProj.IsDirty); Assert.True(viewProj.IsDirty); viewProj.Save(); Assert.True(realProj.IsDirty); Assert.True(viewProj.IsDirty); // it should still be dirty since it is not reevaluated. Assert.True(File.Exists(savedPath)); var lwtAfter = new FileInfo(proj1Path).LastWriteTimeUtc; Assert.Equal(lwtBefore, lwtAfter); viewProj.ReevaluateIfNecessary(); // now it should be not dirty anymore. Assert.False(realProj.IsDirty); Assert.False(viewProj.IsDirty); realProj.IsBuildEnabled = false; Assert.False(viewProj.IsBuildEnabled); Assert.False(realProj.IsBuildEnabled); viewProj.IsBuildEnabled = true; Assert.True(viewProj.IsBuildEnabled); Assert.True(realProj.IsBuildEnabled); realProj.SkipEvaluation = false; Assert.False(viewProj.SkipEvaluation); Assert.False(realProj.SkipEvaluation); viewProj.SkipEvaluation = true; Assert.True(viewProj.SkipEvaluation); Assert.True(realProj.SkipEvaluation); realProj.ThrowInsteadOfSplittingItemElement = false; Assert.False(viewProj.ThrowInsteadOfSplittingItemElement); Assert.False(realProj.ThrowInsteadOfSplittingItemElement); viewProj.ThrowInsteadOfSplittingItemElement = true; Assert.True(viewProj.ThrowInsteadOfSplittingItemElement); Assert.True(realProj.ThrowInsteadOfSplittingItemElement); // and finally just ensure that all is identical ViewValidation.Verify(viewProj, realProj); }
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); }
private void CopyFromInternal(ProjectRootElement sourceProject) { // quite a few complexity in the ExternalProjectProvider implementation is because of // ProjectElement.CopyFrom and ProjectElementContainer.DeepCopyFrom.... bool externalSource = sourceProject != null; var projectPair = GetNewInMemoryProject("CopyFrom", TestCollectionGroup.BigProjectFile); var xmlPair = new ProjectXmlPair(projectPair); Assert.True(xmlPair.View.HasUnsavedChanges); xmlPair.View.Save(); Assert.False(xmlPair.View.HasUnsavedChanges); sourceProject ??= xmlPair.View; var existingItemGroupList = sourceProject.AllChildren.OfType <ProjectItemGroupElement>().Where((ig) => ig.Label == "Group1").ToList(); Assert.Single(existingItemGroupList); var existingItemGroup = existingItemGroupList[0]; Assert.NotNull(existingItemGroup); var realExistingItemGroup = ViewValidation.GetRealObject(existingItemGroup); var ourGroup1 = xmlPair.QuerySingleChildrenWithValidation <ProjectItemGroupElement>((ig) => ig.Label == "Group1"); var newCopyFrom = xmlPair.AddNewLabeledChaildWithVerify <ProjectItemGroupElement>(ObjectType.View, "newGrop", (p, l) => p.AddItemGroup()); newCopyFrom.View.CopyFrom(existingItemGroup); xmlPair.QueryChildrenWithValidation <ProjectItemGroupElement>((ig) => ig.Label == "Group1", 2); newCopyFrom.View.Label = "CopyFrom"; newCopyFrom.VerifySame(xmlPair.QuerySingleChildrenWithValidation <ProjectItemGroupElement>((ig) => ig.Label == "CopyFrom")); ourGroup1.VerifySame(xmlPair.QuerySingleChildrenWithValidation <ProjectItemGroupElement>((ig) => ig.Label == "Group1")); // children are not copied. Assert.Empty(newCopyFrom.View.Items); // but attributes are (even non standard) // Assert.Equal("2", ProjectElementLink.GetAttributeValue(existingItemGroup, "FunnyAttribute", true)); // Assert.Equal("2", ProjectElementLink.GetAttributeValue(newCopyFrom.View, "FunnyAttribute", true)); newCopyFrom.VerifyNotSame(ourGroup1); Assert.True(xmlPair.View.HasUnsavedChanges); Assert.False(externalSource && sourceProject.HasUnsavedChanges); var newDeepCopy = xmlPair.AddNewLabeledChaildWithVerify <ProjectItemGroupElement>(ObjectType.View, "newGrop", (p, l) => p.AddItemGroup()); newDeepCopy.View.DeepCopyFrom(existingItemGroup); xmlPair.QueryChildrenWithValidation <ProjectItemGroupElement>((ig) => ig.Label == "Group1", 2); // slightly cheting but we know that the large groups should be the same, even though there are not the same object // note do that before changing the label. Assert.NotSame(realExistingItemGroup, newDeepCopy.Real); // TODO XmlLocation is (correctly) different for the items, need to find a way to bypass it. var context = new ValidationContext(); context.ValidateLocation = delegate(ElementLocation a, ElementLocation e) { return; }; ViewValidation.Verify(newDeepCopy.View, realExistingItemGroup, context); newDeepCopy.View.Label = "DeepCopyFrom"; newDeepCopy.VerifySame(xmlPair.QuerySingleChildrenWithValidation <ProjectItemGroupElement>((ig) => ig.Label == "DeepCopyFrom")); ourGroup1.VerifySame(xmlPair.QuerySingleChildrenWithValidation <ProjectItemGroupElement>((ig) => ig.Label == "Group1")); newDeepCopy.VerifyNotSame(ourGroup1); Assert.False(externalSource && sourceProject.HasUnsavedChanges); }
public void ProjectReadOnly_Tests() { // this is actually very elaborate and caught quite a few issues. ViewValidation.Verify(this.StdGroup.View, this.StdGroup.Real); }