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);
}
