public void HandlesTrailingSlashOnRootDirectory()
{
var sln = new Sln("sample")
{
ProjectsRootDirectory = "Fake/Example/"
};
var proj = new CsProj {
Path = "Fake/Example/ModuleA/ProjectA/ProjectA.csproj", Guid = Guid.NewGuid().ToString("B")
};
sln.AddProjects(proj);
Assert.That(sln.Folders.FirstOrDefault(f => f.FolderName == "ModuleA"), Is.Not.Null, "Folders");
}
public void SlnResultTest4()
{
using (var sln = new Sln(SlnItems.ProjectConfPlatforms, SlnSamplesResource.vsSolutionBuildEvent))
{
Assert.Equal(6, sln.Result.ProjectConfigs.Count());
var cfg0 = sln.Result.ProjectConfigs.ElementAt(0);
Assert.Equal(new ConfigItem("Release_net45", "x64"), (ConfigItem)cfg0);
Assert.False(cfg0.IncludeInBuild);
Assert.False(cfg0.IncludeInDeploy);
Assert.Equal("{A7BF1F9C-F18D-423E-9354-859DC3CFAFD4}", cfg0.PGuid);
Assert.Equal(new ConfigItem("CI_Debug_net45", "Any CPU"), cfg0.Sln);
var cfg1 = sln.Result.ProjectConfigs.ElementAt(1);
Assert.Equal(new ConfigItem("Release", "x64"), (ConfigItem)cfg1);
Assert.True(cfg1.IncludeInBuild);
Assert.False(cfg1.IncludeInDeploy);
Assert.Equal("{A7BF1F9C-F18D-423E-9354-859DC3CFAFD4}", cfg1.PGuid);
Assert.Equal(new ConfigItem("CI_Debug", "Any CPU"), cfg1.Sln);
var cfg2 = sln.Result.ProjectConfigs.ElementAt(2);
Assert.Equal(new ConfigItem("Release_net45", "Any CPU"), (ConfigItem)cfg2);
Assert.False(cfg2.IncludeInBuild);
Assert.False(cfg2.IncludeInDeploy);
Assert.Equal("{A7BF1F9C-F18D-423E-9354-859DC3CFAFD4}", cfg2.PGuid);
Assert.Equal(new ConfigItem("CI_Release_net45", "Any CPU"), cfg2.Sln);
var cfg3 = sln.Result.ProjectConfigs.ElementAt(3);
Assert.Equal(new ConfigItem("Release", "Any CPU"), (ConfigItem)cfg3);
Assert.True(cfg3.IncludeInBuild);
Assert.True(cfg3.IncludeInDeploy);
Assert.Equal("{A7BF1F9C-F18D-423E-9354-859DC3CFAFD4}", cfg3.PGuid);
Assert.Equal(new ConfigItem("CI_Release", "Any CPU"), cfg3.Sln);
var cfg4 = sln.Result.ProjectConfigs.ElementAt(4);
Assert.Equal(new ConfigItem("Debug", "x86"), (ConfigItem)cfg4);
Assert.True(cfg4.IncludeInBuild);
Assert.False(cfg4.IncludeInDeploy);
Assert.Equal("{32E44995-F621-4E77-B46A-8F65D64E7FEA}", cfg4.PGuid);
Assert.Equal(new ConfigItem("Debug", "Any CPU"), cfg4.Sln);
var cfg5 = sln.Result.ProjectConfigs.ElementAt(5);
Assert.Equal(new ConfigItem("Release", "Any CPU"), (ConfigItem)cfg5);
Assert.True(cfg5.IncludeInBuild);
Assert.False(cfg5.IncludeInDeploy);
Assert.Equal("{32E44995-F621-4E77-B46A-8F65D64E7FEA}", cfg5.PGuid);
Assert.Equal(new ConfigItem("Release", "Any CPU"), cfg5.Sln);
}
}
public void SlnResultTest6()
{
using (var sln = new Sln(SlnItems.ProjectConfPlatforms, SlnSamplesResource.ConfNamesDots))
{
Assert.Equal(6, sln.Result.ProjectConfigs.Count());
var cfg = sln.Result.ProjectConfigs.ElementAt(0);
Assert.Equal(new ConfigItem("Release.net45", "x64"), (ConfigItem)cfg);
Assert.False(cfg.IncludeInBuild);
Assert.False(cfg.IncludeInDeploy);
Assert.Equal("{A7BF1F9C-F18D-423E-9354-859DC3CFAFD4}", cfg.PGuid);
Assert.Equal(new ConfigItem("CI.Debug.net45", "Any.CPU.etc"), cfg.Sln);
cfg = sln.Result.ProjectConfigs.ElementAt(1);
Assert.Equal(new ConfigItem("Release", "x64"), (ConfigItem)cfg);
Assert.True(cfg.IncludeInBuild);
Assert.False(cfg.IncludeInDeploy);
Assert.Equal("{A7BF1F9C-F18D-423E-9354-859DC3CFAFD4}", cfg.PGuid);
Assert.Equal(new ConfigItem("CI.Debug", "Any.CPU.etc"), cfg.Sln);
cfg = sln.Result.ProjectConfigs.ElementAt(2);
Assert.Equal(new ConfigItem("Release.net45", "Any.CPU.etc"), (ConfigItem)cfg);
Assert.False(cfg.IncludeInBuild);
Assert.False(cfg.IncludeInDeploy);
Assert.Equal("{A7BF1F9C-F18D-423E-9354-859DC3CFAFD4}", cfg.PGuid);
Assert.Equal(new ConfigItem("CI.Release.net45", "Any.CPU.etc"), cfg.Sln);
cfg = sln.Result.ProjectConfigs.ElementAt(3);
Assert.Equal(new ConfigItem("Release", "Any.CPU.etc"), (ConfigItem)cfg);
Assert.True(cfg.IncludeInBuild);
Assert.True(cfg.IncludeInDeploy);
Assert.Equal("{A7BF1F9C-F18D-423E-9354-859DC3CFAFD4}", cfg.PGuid);
Assert.Equal(new ConfigItem("CI.Release", "Any.CPU.etc"), cfg.Sln);
cfg = sln.Result.ProjectConfigs.ElementAt(4);
Assert.Equal(new ConfigItem("Debug.x64.x86", "x86"), (ConfigItem)cfg);
Assert.True(cfg.IncludeInBuild);
Assert.False(cfg.IncludeInDeploy);
Assert.Equal("{32E44995-F621-4E77-B46A-8F65D64E7FEA}", cfg.PGuid);
Assert.Equal(new ConfigItem("Debug.x64.x86", "Any.CPU.etc"), cfg.Sln);
cfg = sln.Result.ProjectConfigs.ElementAt(5);
Assert.Equal(new ConfigItem("Release", "Any.CPU.etc"), (ConfigItem)cfg);
Assert.True(cfg.IncludeInBuild);
Assert.False(cfg.IncludeInDeploy);
Assert.Equal("{32E44995-F621-4E77-B46A-8F65D64E7FEA}", cfg.PGuid);
Assert.Equal(new ConfigItem("Release", "Any.CPU.etc"), cfg.Sln);
}
}
public void Execute(TemplatePlanContext context)
{
var solutionFile = context.Input.SolutionFlag;
var sln = new Sln(solutionFile);
_projGatherer
.GatherProjects(context.TempDir)
.Each(project =>
{
sln.AddProject(project);
sln.RegisterPostSolutionConfigurations(project.ProjectGuid, Configurations);
});
_solutionFileService.Save(sln);
}
public void SlnResultTest1()
{
using (var sln = new Sln(SlnItems.Projects, SlnSamplesResource.vsSolutionBuildEvent))
{
Assert.Equal("\\", sln.Result.SolutionDir);
Assert.Equal(SlnParser.MEM_FILE, sln.Result.Properties[PropertyNames.SLN_PATH]);
Assert.Equal(sln.Result.SolutionDir, sln.Result.Properties[PropertyNames.SLN_DIR]);
Assert.Equal(Path.GetExtension(SlnParser.MEM_FILE), sln.Result.Properties[PropertyNames.SLN_EXT]);
Assert.Equal(Path.GetFileName(SlnParser.MEM_FILE), sln.Result.Properties[PropertyNames.SLN_FNAME]);
Assert.Equal(Path.GetFileNameWithoutExtension(SlnParser.MEM_FILE), sln.Result.Properties[PropertyNames.SLN_NAME]);
Assert.Null(sln.Result.Properties[PropertyNames.CONFIG]);
Assert.Null(sln.Result.Properties[PropertyNames.PLATFORM]);
}
}
public void Execute(TemplatePlanContext context)
{
var solutionFile = context.Input.SolutionFlag;
var sln = new Sln(solutionFile);
_projGatherer
.GatherProjects(context.TempDir)
.Each(project =>
{
sln.AddProject(project);
sln.RegisterPostSolutionConfigurations(project.ProjectGuid, Configurations);
});
_solutionFileService.Save(sln);
}
public void SlnResultTest1()
{
using (var sln = new Sln(SlnItems.Projects, SlnSamplesResource.vsSolutionBuildEvent))
{
Assert.AreEqual("\\", sln.Result.SolutionDir);
Assert.AreEqual(SlnParser.MEM_FILE, sln.Result.Properties["SolutionPath"]);
Assert.AreEqual(sln.Result.SolutionDir, sln.Result.Properties["SolutionDir"]);
Assert.AreEqual(Path.GetExtension(SlnParser.MEM_FILE), sln.Result.Properties["SolutionExt"]);
Assert.AreEqual(Path.GetFileName(SlnParser.MEM_FILE), sln.Result.Properties["SolutionFileName"]);
Assert.AreEqual(Path.GetFileNameWithoutExtension(SlnParser.MEM_FILE), sln.Result.Properties["SolutionName"]);
Assert.AreEqual(null, sln.Result.Properties["Configuration"]);
Assert.AreEqual(null, sln.Result.Properties["Platform"]);
}
}
public void ValidationTest1()
{
using (var sln = new Sln(defaultSlnItems, SlnSamplesResource.vsSolutionBuildEvent))
{
var handlers = new Dictionary <Type, HandlerValue>()
{
[typeof(LProject)] = new HandlerValue(),
[typeof(LProjectDependencies)] = new HandlerValue(),
[typeof(LProjectConfigurationPlatforms)] = new HandlerValue(),
};
using (var stream = new StreamWriter(new MemoryStream())) {
(new SlnWriter(stream, handlers)).Write(sln.Result.Map);
}
}
}
public void CreatesNoSolutionFoldersForSimpleProjectStructure()
{
var sln = new Sln("sample", slnGuid)
{
ProjectsRootDirectory = "Fake/Example"
};
sln.AddProjects(new CsProj {
Path = "Fake/Example/ProjectA/ProjectA.csproj"
});
sln.AddProjects(new CsProj {
Path = "Fake/Example/ProjectB/ProjectB.csproj"
});
Assert.That(sln.Folders, Is.Null, "Folders");
}
public void ValidationTest2()
{
using (var sln = new Sln(defaultSlnItems, SlnSamplesResource.vsSolutionBuildEvent))
{
var handlers = new Dictionary <Type, HandlerValue>()
{
[typeof(LProjectDependencies)] = new HandlerValue(),
};
using (var stream = new StreamWriter(new MemoryStream()))
{
var writer = new SlnWriter(stream, handlers);
Assert.Throws <CoHandlerRuleException>(() => writer.Write(sln.Result.Map));
}
}
}
public void ConvertToProjectReferences(Sln solution)
{
var projectsByName = solution.Projects.ToDictionary(p => p.AssemblyName, p => p);
foreach (var project in solution.Projects)
{
var assemblyNamesInSolution = project.ReferencedAssemblyNames.Intersect(projectsByName.Keys).ToArray();
if (assemblyNamesInSolution.Length == 0)
{
continue;
}
ConvertToProjectReference(project, assemblyNamesInSolution.Select(a => projectsByName[a]));
}
}
public void SlnItemsTest1()
{
using (var sln = new Sln(SlnItems.None, SlnSamplesResource.vsSolutionBuildEvent))
{
Assert.Null(sln.Result.DefaultConfig);
Assert.Null(sln.Result.Env);
Assert.Null(sln.Result.ProjectConfigs);
Assert.Null(sln.Result.ProjectConfigurationPlatforms);
Assert.Null(sln.Result.ProjectDependencies);
Assert.Null(sln.Result.ProjectItems);
Assert.Null(sln.Result.ProjectItemsConfigs);
Assert.Null(sln.Result.SolutionConfigs);
Assert.NotNull(sln.Result.Properties);
Assert.Equal(SlnItems.None, sln.Result.ResultType);
}
}
public void ExtensibilityGlobalsTest2()
{
using (var sln = new Sln(SlnItems.ExtItems, SlnSamplesResource.ExtensibilityGlobals))
{
Assert.AreEqual(4, sln.Result.ExtItems.Count());
Assert.AreEqual(true, sln.Result.ExtItems.ContainsKey("SolutionGuid"));
Assert.AreEqual(true, sln.Result.ExtItems.ContainsKey("SomeOtherEmptyData"));
Assert.AreEqual(true, sln.Result.ExtItems.ContainsKey("SomeNullData"));
Assert.AreEqual(true, sln.Result.ExtItems.ContainsKey("EnterpriseLibraryConfigurationToolBinariesPath"));
Assert.AreEqual("{B3244B90-20DE-4D69-8692-EBC686503F90}", sln.Result.ExtItems["SolutionGuid"]);
Assert.AreEqual(String.Empty, sln.Result.ExtItems["SomeOtherEmptyData"]);
Assert.AreEqual(null, sln.Result.ExtItems["SomeNullData"]);
Assert.AreEqual(@"packages\Conari.1.3.0\lib\NET40;packages\vsSBE.CI.MSBuild\bin", sln.Result.ExtItems["EnterpriseLibraryConfigurationToolBinariesPath"]);
}
}
public void SlnItemsTest2()
{
using (var sln = new Sln(SlnItems.All & ~SlnItems.LoadDefaultData, SlnSamplesResource.vsSolutionBuildEvent))
{
Assert.AreNotEqual(null, sln.Result.DefaultConfig);
Assert.AreNotEqual(null, sln.Result.Env);
Assert.AreNotEqual(null, sln.Result.ProjectConfigs);
Assert.AreNotEqual(null, sln.Result.ProjectConfigurationPlatforms);
Assert.AreNotEqual(null, sln.Result.ProjectDependencies);
Assert.AreNotEqual(null, sln.Result.ProjectItems);
Assert.AreNotEqual(null, sln.Result.ProjectItemsConfigs);
Assert.AreNotEqual(null, sln.Result.SolutionConfigs);
Assert.AreNotEqual(null, sln.Result.Properties);
Assert.AreEqual(SlnItems.All & ~SlnItems.LoadDefaultData, sln.Result.ResultType);
}
}
public void SolutionFoldersAndProjectsTest3()
{
using (var sln = new Sln(SlnItems.SolutionItems | SlnItems.Projects, SlnSamplesResource.SolutionFoldersAndProjects))
{
Assert.AreEqual(null, sln.Result.SolutionFolders.ElementAt(0).header.parent.Value);
Assert.AreNotEqual(null, sln.Result.SolutionFolders.ElementAt(1).header.parent.Value);
Assert.AreEqual("{1571A74C-579F-4C91-8484-322B7D89B430}", sln.Result.SolutionFolders.ElementAt(1).header.parent.Value?.header.pGuid);
Assert.AreEqual("dir1", sln.Result.SolutionFolders.ElementAt(1).header.parent.Value?.header.name);
Assert.AreNotEqual(null, sln.Result.SolutionFolders.ElementAt(2).header.parent.Value);
Assert.AreEqual("{260202C1-F43A-43E9-A43B-E3E75406A985}", sln.Result.SolutionFolders.ElementAt(2).header.parent.Value?.header.pGuid);
Assert.AreEqual("subdir1", sln.Result.SolutionFolders.ElementAt(2).header.parent.Value?.header.name);
Assert.AreEqual(null, sln.Result.SolutionFolders.ElementAt(3).header.parent.Value);
}
}
public void CreatesNestedSolutionFolders()
{
var sln = new Sln("sample")
{
ProjectsRootDirectory = "Fake/Example"
};
var proj = new CsProj {
Path = "Fake/Example/Grouping1/ModuleA/ProjectA/ProjectA.csproj", Guid = Guid.NewGuid().ToString("B")
};
sln.AddProjects(proj);
var child = sln.Folders.First(f => f.FolderName == "ModuleA");
var parent = sln.Folders.First(f => f.FolderName == "Grouping1");
CollectionAssert.AreEqual(new[] { child.Guid }, parent.ContentGuids.ToArray());
CollectionAssert.AreEqual(new[] { proj.Guid }, child.ContentGuids.ToArray());
}
public string GenerateSolutionFile(SlnGenerationOptions options)
{
LogSummary(options);
List <CsProj> projects = ProjectRepository.LookupCsProjsFromDirectory(options);
Sln solution = SlnBuilder.GetSlnBuilder(projects).BuildSln(options);
if (options.ConvertReferences)
{
new ReferenceConverter().ConvertToProjectReferences(solution);
}
else if (options.RestoreReferences)
{
new ReferenceConverter().RestoreAssemblyReferences(solution);
}
return(SlnWriter.WriteSlnFile(solution, options.SlnOutputPath).FullName);
}
public void WriteNewSlnFile(Sln slnObject)
{
_sln = slnObject;
_slnFile = new SlnFile(); // or you can read sln file like below
using (SolutionFileReader reader = new SolutionFileReader(_sln.ObjectFullPath))
_slnFile = reader.ReadSolutionFile();
AddHeaders();
AddGlobalSections();
// add projects
List <SolutionNode> sns = _sln.GetAllSubItemsOf(typeof(SolutionFolder), typeof(ProjectNode));
foreach (SolutionNode sn in sns)
{
_slnFile.Projects.Add(CreateProject(sn));
}
using (SolutionFileWriter writer = new SolutionFileWriter(_sln.ObjectFullPath))
writer.WriteSolutionFile(_slnFile);
}
public void SolutionFoldersAndProjectsTest2()
{
using (var sln = new Sln(SlnItems.SolutionItems | SlnItems.Projects, SlnSamplesResource.SolutionFoldersAndProjects))
{
Assert.AreEqual(4, sln.Result.SolutionFolders.Count());
Assert.AreEqual(5, sln.Result.ProjectItems.Count());
Assert.AreEqual(0, sln.Result.SolutionFolders.ElementAt(0).items.Count());
Assert.AreEqual(2, sln.Result.SolutionFolders.ElementAt(1).items.Count());
Assert.AreEqual(1, sln.Result.SolutionFolders.ElementAt(2).items.Count());
Assert.AreEqual(0, sln.Result.SolutionFolders.ElementAt(3).items.Count());
Assert.AreEqual(".gitignore", sln.Result.SolutionFolders.ElementAt(1).items.ElementAt(0).data);
Assert.AreEqual("Readme.txt", sln.Result.SolutionFolders.ElementAt(1).items.ElementAt(1).data);
Assert.AreEqual(".gitattributes", sln.Result.SolutionFolders.ElementAt(2).items.ElementAt(0).data);
}
}
public void SlnResultTest3()
{
using (var sln = new Sln(SlnItems.SolutionConfPlatforms, SlnSamplesResource.vsSolutionBuildEvent))
{
Assert.AreEqual(new ConfigItem("Debug", "Any CPU"), sln.Result.DefaultConfig);
Assert.AreEqual(8, sln.Result.SolutionConfigs.Count());
Assert.AreEqual(new ConfigItem("CI_Debug_net45", "Any CPU"), sln.Result.SolutionConfigs.ElementAt(0));
Assert.AreEqual(new ConfigItem("CI_Debug", "Any CPU"), sln.Result.SolutionConfigs.ElementAt(1));
Assert.AreEqual(new ConfigItem("CI_Release_net45", "Any CPU"), sln.Result.SolutionConfigs.ElementAt(2));
Assert.AreEqual(new ConfigItem("CI_Release", "Any CPU"), sln.Result.SolutionConfigs.ElementAt(3));
Assert.AreEqual(new ConfigItem("Debug_net45", "Any CPU"), sln.Result.SolutionConfigs.ElementAt(4));
Assert.AreEqual(new ConfigItem("Debug", "Any CPU"), sln.Result.SolutionConfigs.ElementAt(5));
Assert.AreEqual(new ConfigItem("Release_net45", "Any CPU"), sln.Result.SolutionConfigs.ElementAt(6));
Assert.AreEqual(new ConfigItem("Release", "Any CPU"), sln.Result.SolutionConfigs.ElementAt(7));
}
}
public void CreatesSolutionFoldersForNestedProjectStructure()
{
var sln = new Sln("sample", slnGuid)
{
ProjectsRootDirectory = "Fake/Example"
};
sln.AddProjects(new CsProj {
Path = "Fake/Example/ModuleA/ProjectA/ProjectA.csproj"
});
sln.AddProjects(new CsProj {
Path = "Fake/Example/ModuleA/ProjectB/ProjectB.csproj"
});
var folder = sln.Folders.FirstOrDefault();
Assert.That(folder.FolderName, Is.EqualTo("ModuleA"));
Assert.That(folder.ContentGuids.Count, Is.EqualTo(2));
}
public void CreatesSolutionFoldersForNestedProjectStructure()
{
var sln = new Sln("sample")
{
ProjectsRootDirectory = "Fake/Example"
};
sln.AddProjects(new CsProj {
Path = "Fake/Example/ModuleA/ProjectA/ProjectA.csproj"
});
sln.AddProjects(new CsProj {
Path = "Fake/Example/ModuleA/ProjectB/ProjectB.csproj"
});
var folder = sln.Folders.FirstOrDefault();
StringAssert.Equals("ModuleA", folder.FolderName);
Assert.AreEqual(2, folder.ContentGuids.Count);
}
public void ActivationTheory1(string file, SlnItems items)
{
using (var sln = new Sln(file, items))
{
var dep = sln.Result.ProjectDependencies.Dependencies;
Assert.Equal(2, dep.Count);
Assert.Empty(dep["{64AD76CA-2C85-4039-B0B3-734CF02B2999}"]);
Assert.Empty(dep["{6CE57BB1-4A6D-4714-B775-74A3637EC992}"]);
if ((items & SlnItems.ProjectDependenciesXml) == SlnItems.ProjectDependenciesXml)
{
Assert.Empty(sln.Result.Env.Projects);
}
else
{
Assert.Null(sln.Result.Env);
}
}
}
public void ItemsTest1()
{
var projects = new Dictionary <string, RawText>()
{
["{12B25935-229F-4128-B66B-7561A77ABC54}"] = new RawText(PrjSamplesResource.snet)
};
using (var sln = new Sln(SlnItems.EnvWithProjects, new RawText(SlnSamplesResource.regXwild), projects))
{
IXProject project = sln.Result.Env.Projects.FirstOrDefault();
Assert.AreEqual(null, project.GetItem("Reference", "NOT_REAL_INC").evaluatedInclude);
Assert.AreEqual(true, project.AddItem("Reference", "MyInclude"));
Assert.AreEqual("MyInclude", project.GetItem("Reference", "MyInclude").evaluatedInclude);
Assert.AreEqual(false, project.RemoveItem("Reference", "NOT_REAL_INC"));
Assert.AreEqual(true, project.RemoveItem("Reference", "MyInclude"));
Assert.AreEqual(null, project.GetItem("Reference", "MyInclude").evaluatedInclude);
}
}
public void PropertiesTest1()
{
var projects = new Dictionary <string, RawText>()
{
["{12B25935-229F-4128-B66B-7561A77ABC54}"] = new RawText(PrjSamplesResource.snet)
};
using (var sln = new Sln(SlnItems.EnvWithProjects, new RawText(SlnSamplesResource.regXwild), projects))
{
IXProject project = sln.Result.Env.Projects.FirstOrDefault();
Assert.AreEqual(null, project.GetProperty("NOT_REAL_PROPERTY").name);
Assert.AreEqual("MyProperty1", project.SetProperty("MyProperty1", "Value1").name);
Assert.AreEqual("Value1", project.GetProperty("MyProperty1").evaluatedValue);
Assert.AreEqual(false, project.RemoveProperty("NOT_REAL_PROPERTY_2"));
Assert.AreEqual(true, project.RemoveProperty("MyProperty1"));
Assert.AreEqual(null, project.GetProperty("MyProperty1").name);
}
}
public void PropertiesTest3()
{
var projects = new Dictionary <string, RawText>()
{
["{12B25935-229F-4128-B66B-7561A77ABC54}"] = new RawText(PrjSamplesResource.snet)
};
using (var sln = new Sln(SlnItems.EnvWithProjects, new RawText(SlnSamplesResource.regXwild), projects))
{
IXProject project = sln.Result.Env.Projects.FirstOrDefault();
var prop = project.GetProperty("Platform", true);
Assert.Null(prop.name);
Assert.Null(prop.unevaluatedValue);
Assert.Null(prop.evaluatedValue);
Assert.Null(prop.parentProperty);
Assert.NotNull(prop.parentProject);
}
}
public void SolutionFoldersAndProjectsTest1()
{
using (var sln = new Sln(SlnItems.SolutionItems | SlnItems.Projects, SlnSamplesResource.SolutionFoldersAndProjects))
{
Assert.AreEqual(4, sln.Result.SolutionFolders.Count());
Assert.AreEqual(5, sln.Result.ProjectItems.Count());
Assert.AreEqual("dir1", sln.Result.SolutionFolders.ElementAt(0).header.name);
Assert.AreEqual("{1571A74C-579F-4C91-8484-322B7D89B430}", sln.Result.SolutionFolders.ElementAt(0).header.pGuid);
Assert.AreEqual("subdir1", sln.Result.SolutionFolders.ElementAt(1).header.name);
Assert.AreEqual("{260202C1-F43A-43E9-A43B-E3E75406A985}", sln.Result.SolutionFolders.ElementAt(1).header.pGuid);
Assert.AreEqual("dir3", sln.Result.SolutionFolders.ElementAt(2).header.name);
Assert.AreEqual("{49B0FC00-2D07-419C-86D4-FDEC8BF0F12C}", sln.Result.SolutionFolders.ElementAt(2).header.pGuid);
Assert.AreEqual("dir2", sln.Result.SolutionFolders.ElementAt(3).header.name);
Assert.AreEqual("{AB650B89-1B1B-43C6-B254-226B56ACB6EB}", sln.Result.SolutionFolders.ElementAt(3).header.pGuid);
}
}
public void ActivationTheory2(string file, SlnItems items)
{
const string _P1 = "{64AD76CA-2C85-4039-B0B3-734CF02B2999}";
const string _P2 = "{6CE57BB1-4A6D-4714-B775-74A3637EC992}";
using (var sln = new Sln(file, items))
{
Assert.NotNull(sln.Result.Env);
Assert.NotEmpty(sln.Result.Env.Projects);
Assert.Equal(sln.Result.ProjectDependencies.Projects.Count, sln.Result.ProjectDependencies.Dependencies.Count);
var dep = sln.Result.ProjectDependencies.Dependencies;
Assert.Equal(2, dep.Count);
Assert.Empty(dep[_P1]);
Assert.Single(dep[_P2]);
Assert.Equal(_P1, dep[_P2].First());
}
}
public void MapRefTest1()
{
using (var sln = new Sln(defaultSlnItems, SlnSamplesResource.vsSolutionBuildEvent))
{
int expectedCount = sln.Result.Map.Count;
var expectedMap = sln.Result.Map.Select(s => s.Clone()).ToArray();
var handlers = new Dictionary <Type, HandlerValue>()
{
[typeof(LProject)] = new HandlerValue(),
[typeof(LProjectConfigurationPlatforms)] = new HandlerValue(),
[typeof(LSolutionConfigurationPlatforms)] = new HandlerValue(),
};
using (var stream = new StreamWriter(new MemoryStream()))
{
(new SlnWriter(stream, handlers)).Write(sln.Result.Map);
Assert.AreEqual(expectedCount, sln.Result.Map.Count);
}
}
}
public void PropertiesTest4()
{
var projects = new Dictionary <string, RawText>()
{
["{12B25935-229F-4128-B66B-7561A77ABC54}"] = new RawText(PrjSamplesResource.snet)
};
using (var sln = new Sln(SlnItems.EnvWithProjects, new RawText(SlnSamplesResource.regXwild), projects))
{
IXProject project = sln.Result.Env.Projects.FirstOrDefault();
Assert.Throws <InvalidOperationException>(() =>
{
project.SetProperty("Platform", "x64");
});
Assert.Throws <InvalidOperationException>(() =>
{
project.SetProperty("Configuration", "Release");
});
}
}
public string GenerateSolutionFile(SlnGenerationOptions options)
{
LogSummary(options);
List <Proj> projects = ProjectRepository.LookupCsProjsFromDirectory(options);
Sln solution = SlnBuilder.GetSlnBuilder(projects).BuildSln(options);
if (options.FixHintPaths)
{
new HintPathConverter().ConvertHintPaths(solution, options);
}
if (options.ConvertReferences)
{
new ReferenceConverter().ConvertToProjectReferences(solution);
}
else if (options.RestoreReferences)
{
new ReferenceConverter().RestoreAssemblyReferences(solution);
}
if (options.RestoreHintPaths)
{
new HintPathConverter().RestoreHintPaths(solution, options);
}
WarnOnMissingNuGetTargets(projects, options);
if (options.UseRelativePaths)
{
foreach (var project in solution.Projects)
{
project.Path = GetRelativePath(options.BaseFolder, project.Path);
}
}
return(SlnWriter.WriteSlnFile(solution, options.SlnOutputPath).FullName);
}
protected TProp projectProperties(Sln.Project project, TProp properties)
{
Log.Debug($"-> sln['{properties["Configuration"]}'; '{properties["Platform"]}']");
if(!properties.ContainsKey("Configuration") || !properties.ContainsKey("Platform")) {
Log.Warn("Solution Configuration & Platform are not defined.");
return properties;
}
TProp ret = new TProp(properties);
var cfg = _sln
.projectConfigs
.Where(c =>
c.pGuid == project.pGuid
&& c.sln.configuration == properties["Configuration"]
&& platformName(c.sln.platform) == platformName(properties["Platform"])
)
.FirstOrDefault();
if(cfg.configuration == null || cfg.platform == null) {
Log.Warn($"Something went wrong with project configuration. `{cfg.configuration}|{cfg.platform}`");
Log.Warn($"Are you sure that it's correct for your sln: `{properties["Configuration"]}|{properties["Platform"]}`");
return properties;
//throw new MismatchException();
}
string platform = platformName(cfg.platform);
Log.Debug($"-> prj['{cfg.configuration}'; '{platform}']");
ret["Configuration"] = cfg.configuration;
ret["Platform"] = platform;
return ret;
}
