internal static List <string> GetValuesFromTestLibrary(
ITestOutputHelper log,
TestAssetsManager testAssetsManager,
string itemTypeOrPropertyName,
Action <GetValuesCommand> setup = null,
string[] msbuildArgs = null,
GetValuesCommand.ValueType valueType = GetValuesCommand.ValueType.Item,
[CallerMemberName] string callingMethod = "",
Action <XDocument> projectChanges = null)
{
msbuildArgs = msbuildArgs ?? Array.Empty <string>();
string targetFramework = "netstandard1.6";
var testAsset = testAssetsManager
.CopyTestAsset("AppWithLibraryFS", callingMethod)
.WithSource();
if (projectChanges != null)
{
testAsset.WithProjectChanges(projectChanges);
}
var libraryProjectDirectory = Path.Combine(testAsset.TestRoot, "TestLibrary");
var getValuesCommand = new GetValuesCommand(log, libraryProjectDirectory,
targetFramework, itemTypeOrPropertyName, valueType);
if (setup != null)
{
setup(getValuesCommand);
}
getValuesCommand
.Execute(msbuildArgs)
.Should()
.Pass();
var itemValues = getValuesCommand.GetValues();
return(itemValues);
}
public void TheMaximumVersionsAreSupported(string targetFrameworkIdentifier)
{
var project = new TestProject
{
Name = "packagethatwillgomissing",
TargetFrameworks = targetFrameworkIdentifier == ".NETCoreApp" ? "netcoreapp3.0" : "netstandard2.1",
IsSdkProject = true,
};
TestAsset asset = _testAssetsManager
.CreateTestProject(project, identifier: targetFrameworkIdentifier);
string testDirectory = Path.Combine(asset.TestRoot, project.Name);
var getMaximumVersion = new GetValuesCommand(
Log,
testDirectory,
project.TargetFrameworks,
targetFrameworkIdentifier.Substring(1) + "MaximumVersion",
GetValuesCommand.ValueType.Property);
var getSupportedFrameworks = new GetValuesCommand(
Log,
testDirectory,
project.TargetFrameworks,
"SupportedTargetFramework",
GetValuesCommand.ValueType.Item);
getMaximumVersion.DependsOnTargets = "";
getMaximumVersion.Execute().Should().Pass();
getSupportedFrameworks.DependsOnTargets = "";
getSupportedFrameworks.Execute().Should().Pass();
string maximumVersion = getMaximumVersion.GetValues().Single();
List <string> supportedFrameworks = getSupportedFrameworks.GetValues();
string expectedTFM = $"{targetFrameworkIdentifier},Version=v{maximumVersion}";
supportedFrameworks.Should().Contain(expectedTFM,
because: $"Microsoft.NET.SupportedTargetFrameworks.props should include an entry for {expectedTFM}");
}
public void It_always_accepts_user_defined_WarningLevel(int?warningLevel, int expectedWarningLevel)
{
var testProject = new TestProject
{
Name = "HelloWorld",
TargetFrameworks = ToolsetInfo.CurrentTargetFramework,
IsExe = true,
SourceFiles =
{
["Program.cs"] = @"
using System;
namespace ConsoleCore
{
class Program
{
static void Main()
{
}
}
}
",
}
};
testProject.AdditionalProperties.Add("WarningLevel", warningLevel?.ToString());
var testAsset = _testAssetsManager
.CreateTestProject(testProject, identifier: "customWarningLevelConsoleApp", targetExtension: ".csproj");
var buildCommand = new GetValuesCommand(
Log,
Path.Combine(testAsset.TestRoot, testProject.Name),
ToolsetInfo.CurrentTargetFramework, "WarningLevel")
{
DependsOnTargets = "Build"
};
var buildResult = buildCommand.Execute();
var computedWarningLevel = buildCommand.GetValues()[0];
buildResult.StdErr.Should().Be(string.Empty);
computedWarningLevel.Should().Be(expectedWarningLevel.ToString());
}
public void It_resolves_multitargeted_analyzers()
{
var testProject = new TestProject()
{
TargetFrameworks = "net6.0;net472"
};
// Disable analyzers built in to the SDK so we can more easily test the ones coming from NuGet packages
testProject.AdditionalProperties["EnableNETAnalyzers"] = "false";
testProject.ProjectChanges.Add(project =>
{
var ns = project.Root.Name.Namespace;
var itemGroup = XElement.Parse(@"
<ItemGroup>
<PackageReference Include=""System.Text.Json"" Version=""4.7.0"" Condition="" '$(TargetFramework)' == 'net472' "" />
<PackageReference Include=""System.Text.Json"" Version=""6.0.0-preview.4.21253.7"" Condition="" '$(TargetFramework)' == 'net6.0' "" />
</ItemGroup>");
project.Root.Add(itemGroup);
});
var testAsset = _testAssetsManager.CreateTestProject(testProject);
List <(string package, string version, string path)> GetAnalyzersForTargetFramework(string targetFramework)
{
var getValuesCommand = new GetValuesCommand(testAsset,
valueName: "Analyzer",
GetValuesCommand.ValueType.Item,
targetFramework);
getValuesCommand.DependsOnTargets = "ResolveLockFileAnalyzers";
getValuesCommand.Execute("-p:TargetFramework=" + targetFramework).Should().Pass();
return(getValuesCommand.GetValues().Select(x => GetPackageAndPath(x)).ToList());
}
GetAnalyzersForTargetFramework("net6.0").Should().BeEquivalentTo(("system.text.json", "6.0.0-preview.4.21253.7", "analyzers/dotnet/cs/System.Text.Json.SourceGeneration.dll"));
GetAnalyzersForTargetFramework("net472").Should().BeEmpty();
}
public void It_defaults_WarningLevel_To_The_Current_TFM_When_Net(string tfm, string warningLevel)
{
int parsedWarningLevel = (int)double.Parse(warningLevel);
var testProject = new TestProject
{
Name = "HelloWorld",
TargetFrameworks = tfm,
IsExe = true,
SourceFiles =
{
["Program.cs"] = @"
using System;
namespace ConsoleCore
{
class Program
{
static void Main()
{
}
}
}
",
}
};
var testAsset = _testAssetsManager
.CreateTestProject(testProject, identifier: "warningLevelConsoleApp" + tfm, targetExtension: ".csproj");
var buildCommand = new GetValuesCommand(
Log,
Path.Combine(testAsset.TestRoot, testProject.Name),
tfm, "WarningLevel")
{
DependsOnTargets = "Build"
};
var buildResult = buildCommand.Execute();
var computedWarningLevel = buildCommand.GetValues()[0];
buildResult.StdErr.Should().Be(string.Empty);
computedWarningLevel.Should().Be(parsedWarningLevel.ToString());
}
private void AssertDefinedConstantsOutput(TestAsset testAsset, string targetFramework, string[] expectedDefines)
{
var libraryProjectDirectory = Path.Combine(testAsset.TestRoot, "TestLibrary");
var getValuesCommand = new GetValuesCommand(Log, libraryProjectDirectory,
targetFramework, "DefineConstants")
{
ShouldCompile = false,
TargetName = "CoreCompile" // Overwrite core compile with our target to get DefineConstants
};
getValuesCommand
.Execute()
.Should()
.Pass();
var definedConstants = getValuesCommand.GetValues();
definedConstants.Should().BeEquivalentTo(new[] { "DEBUG", "TRACE" }.Concat(expectedDefines).ToArray());
}
public void It_respects_explicit_platform_target()
{
var testAsset = _testAssetsManager
.CopyTestAsset("DesktopMinusRid")
.WithSource()
.Restore(Log, "", $"/p:RuntimeIdentifier=win7-x86");
var getValuesCommand = new GetValuesCommand(Log, testAsset.TestRoot,
"net46", "PlatformTarget", GetValuesCommand.ValueType.Property);
getValuesCommand
.Execute($"/p:RuntimeIdentifier=win7-x86", "/p:PlatformTarget=x64")
.Should()
.Pass();
getValuesCommand
.GetValues()
.Should()
.BeEquivalentTo("x64");
}
public void It_builds_with_inferred_platform_target(string runtimeIdentifier, string expectedPlatformTarget)
{
var testAsset = _testAssetsManager
.CopyTestAsset("DesktopMinusRid", identifier: Path.DirectorySeparatorChar + runtimeIdentifier)
.WithSource()
.Restore(Log, "", $"/p:RuntimeIdentifier={runtimeIdentifier}");
var getValuesCommand = new GetValuesCommand(Log, testAsset.TestRoot,
"net46", "PlatformTarget", GetValuesCommand.ValueType.Property);
getValuesCommand
.Execute($"/p:RuntimeIdentifier={runtimeIdentifier}")
.Should()
.Pass();
getValuesCommand
.GetValues()
.Should()
.BeEquivalentTo(expectedPlatformTarget);
}
private void GetReferences(TestProject testProject, bool expectConflicts, out List <string> references, out List <string> referenceCopyLocalPaths)
{
string targetFramework = testProject.TargetFrameworks;
TestAsset tempTestAsset = _testAssetsManager.CreateTestProject(testProject)
.Restore(Log, testProject.Name);
string projectFolder = Path.Combine(tempTestAsset.TestRoot, testProject.Name);
var getReferenceCommand = new GetValuesCommand(
Log,
projectFolder,
targetFramework,
"Reference",
GetValuesCommand.ValueType.Item);
getReferenceCommand.DependsOnTargets = "Build";
var result = getReferenceCommand.Execute("/v:normal").Should().Pass();
if (expectConflicts)
{
result.And.HaveStdOutMatching("Encountered conflict", RegexOptions.CultureInvariant | RegexOptions.IgnoreCase);
}
else
{
result.And.NotHaveStdOutMatching("Encountered conflict", RegexOptions.CultureInvariant | RegexOptions.IgnoreCase);
}
references = getReferenceCommand.GetValues();
var getReferenceCopyLocalPathsCommand = new GetValuesCommand(
Log,
projectFolder,
targetFramework,
"ReferenceCopyLocalPaths",
GetValuesCommand.ValueType.Item);
getReferenceCopyLocalPathsCommand.DependsOnTargets = "Build";
getReferenceCopyLocalPathsCommand.Execute().Should().Pass();
referenceCopyLocalPaths = getReferenceCopyLocalPathsCommand.GetValues();
}
string GetRollForwardNetCoreAppVersion()
{
var testProject = new TestProject()
{
Name = nameof(GetRollForwardNetCoreAppVersion),
TargetFrameworks = "netcoreapp2.1",
IsSdkProject = true,
IsExe = true
};
var testAsset = _testAssetsManager.CreateTestProject(testProject)
.Restore(Log, testProject.Name);
var getValuesCommand = new GetValuesCommand(Log, Path.Combine(testAsset.TestRoot, testProject.Name),
testProject.TargetFrameworks, "RuntimeFrameworkVersion")
{
ShouldCompile = false
};
getValuesCommand.Execute().Should().Pass();
return(getValuesCommand.GetValues().Single());
}
public void It_defines_target_platform_from_target_framework_with_explicit_version()
{
var targetPlatformVersion = "10.0.19041.0";
var targetFramework = "net5.0-windows";
var testProj = new TestProject()
{
Name = "TargetPlatformTests",
TargetFrameworks = targetFramework
};
testProj.AdditionalProperties["TargetPlatformVersion"] = targetPlatformVersion;
var testAsset = _testAssetsManager.CreateTestProject(testProj);
var getValuesCommand = new GetValuesCommand(Log, Path.Combine(testAsset.Path, testProj.Name), targetFramework, "TargetPlatformIdentifier");
getValuesCommand
.Execute()
.Should()
.Pass();
getValuesCommand.GetValues().ShouldBeEquivalentTo(new[] { "Windows" });
}
public void It_defines_windows_version_default_correctly(string targetFramework)
{
TestProject testProject = new TestProject()
{
Name = "WindowsVersionDefault",
ProjectSdk = "Microsoft.NET.Sdk.WindowsDesktop",
TargetFrameworks = targetFramework
};
testProject.AdditionalProperties["TargetPlatformIdentifier"] = "windows";
var testAsset = _testAssetsManager.CreateTestProject(testProject);
var getValuesCommand = new GetValuesCommand(Log, Path.Combine(testAsset.TestRoot, testProject.Name), targetFramework, "TargetPlatformVersion");
getValuesCommand
.Execute()
.Should()
.Pass();
getValuesCommand.GetValues().ShouldBeEquivalentTo(new[] { "7.0" });
}
public void It_combines_inner_rids_for_restore(
string identifier,
string outerRid,
string outerRids,
string firstFrameworkRid,
string firstFrameworkRids,
string secondFrameworkRid,
string secondFrameworkRids,
string expectedCombination)
{
var testAsset = _testAssetsManager
.CopyTestAsset(Path.Combine("CrossTargeting", "NetStandardAndNetCoreApp"), identifier: identifier)
.WithSource()
.WithProjectChanges(project =>
{
var ns = project.Root.Name.Namespace;
var propertyGroup = project.Root.Elements(ns + "PropertyGroup").First();
propertyGroup.Add(
new XElement(ns + "RuntimeIdentifier", outerRid),
new XElement(ns + "RuntimeIdentifiers", outerRids));
propertyGroup.AddAfterSelf(
new XElement(ns + "PropertyGroup",
new XAttribute(ns + "Condition", "'$(TargetFramework)' == 'netstandard1.5'"),
new XElement(ns + "RuntimeIdentifier", firstFrameworkRid),
new XElement(ns + "RuntimeIdentifiers", firstFrameworkRids)),
new XElement(ns + "PropertyGroup",
new XAttribute(ns + "Condition", "'$(TargetFramework)' == 'netcoreapp1.1'"),
new XElement(ns + "RuntimeIdentifier", secondFrameworkRid),
new XElement(ns + "RuntimeIdentifiers", secondFrameworkRids)));
});
var command = new GetValuesCommand(Stage0MSBuild, testAsset.TestRoot, "", valueName: "RuntimeIdentifiers");
command.DependsOnTargets = "GetAllRuntimeIdentifiers";
command.Execute().Should().Pass();
command.GetValues().Should().BeEquivalentTo(expectedCombination.Split(';'));
}
public void It_includes_source_revision_id_if_available__version_with_plus()
{
TestProject testProject = new TestProject()
{
Name = "ProjectWithSourceRevisionId",
IsSdkProject = true,
TargetFrameworks = "netcoreapp2.0",
};
var testAsset = _testAssetsManager.CreateTestProject(testProject)
.WithProjectChanges((path, project) =>
{
var ns = project.Root.Name.Namespace;
project.Root.Add(
new XElement(ns + "Target",
new XAttribute("Name", "_SetSourceRevisionId"),
new XAttribute("BeforeTargets", "InitializeSourceControlInformation"),
new XElement(ns + "PropertyGroup",
new XElement("SourceRevisionId", "xyz"))));
project.Root.Add(
new XElement(ns + "Target",
new XAttribute("Name", "InitializeSourceControlInformation")));
project.Root.Add(
new XElement(ns + "PropertyGroup",
new XElement("SourceControlInformationFeatureSupported", "true"),
new XElement("InformationalVersion", "1.2.3+abc")));
});
testAsset.Restore(Log, testProject.Name);
var command = new GetValuesCommand(Log, Path.Combine(testAsset.TestRoot, testProject.Name), testProject.TargetFrameworks, valueName: "InformationalVersion");
command.Execute().Should().Pass();
command.GetValues().ShouldBeEquivalentTo(new[] { "1.2.3+abc.xyz" });
}
public void It_restores_only_ridless_tfm()
{
var testAsset = _testAssetsManager
.CopyTestAsset("HelloWorld")
.WithSource()
.Restore(Log);
var getValuesCommand = new GetValuesCommand(Log, testAsset.TestRoot,
"netcoreapp1.1", "TargetDefinitions", GetValuesCommand.ValueType.Item);
getValuesCommand
.Execute()
.Should()
.Pass();
// When RuntimeIdentifier is not specified, the assets file
// should only contain one target with no RIDs
var targetDefs = getValuesCommand.GetValues();
targetDefs.Count.Should().Be(1);
targetDefs.Should().Contain(".NETCoreApp,Version=v1.1");
}
public void It_implicitly_defines_compilation_constants_for_the_configuration(string configuration, string expectedDefine)
{
var testAsset = _testAssetsManager
.CopyTestAsset("AppWithLibraryFS", "ImplicitConfigurationConstantsFS", configuration)
.WithSource();
var libraryProjectDirectory = Path.Combine(testAsset.TestRoot, "TestLibrary");
var getValuesCommand = new GetValuesCommand(Log, libraryProjectDirectory,
"netstandard1.6", "DefineConstants");
getValuesCommand.ShouldCompile = true;
getValuesCommand.Configuration = configuration;
getValuesCommand
.Execute("/p:Configuration=" + configuration)
.Should()
.Pass();
var definedConstants = getValuesCommand.GetValues();
definedConstants.Should().BeEquivalentTo(new[] { expectedDefine, "TRACE", "NETSTANDARD", "NETSTANDARD1_6" });
}
public void It_implicitly_defines_compilation_constants_for_the_configuration(string configuration, string[] expectedDefines)
{
var testAsset = _testAssetsManager
.CopyTestAsset("AppWithLibraryVB", "ImplicitConfigurationConstantsVB", configuration)
.WithSource();
var libraryProjectDirectory = Path.Combine(testAsset.TestRoot, "TestLibrary");
var getValuesCommand = new GetValuesCommand(Log, libraryProjectDirectory,
"netstandard1.5", "FinalDefineConstants");
getValuesCommand.ShouldCompile = true;
getValuesCommand.Configuration = configuration;
getValuesCommand
.Execute("/p:Configuration=" + configuration)
.Should()
.Pass();
var definedConstants = ExpandSequence(getValuesCommand.GetValues()).ToList();
definedConstants.Should().BeEquivalentTo(expectedDefines.Concat(new[] { "PLATFORM=\"AnyCPU\"", "NETSTANDARD=-1", "NETSTANDARD1_5=-1" }));
}
public void It_does_not_contain_apphost_exe(bool multiTarget)
{
var extension = RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? ".exe" : "";
_targetFrameworkOrFrameworks = "netcoreapp3.0";
var nugetPackage = SetupNuGetPackage(multiTarget);
using (var nupkgReader = new PackageArchiveReader(nugetPackage))
{
IEnumerable <NuGet.Frameworks.NuGetFramework> supportedFrameworks = nupkgReader.GetSupportedFrameworks();
supportedFrameworks.Should().NotBeEmpty();
foreach (NuGet.Frameworks.NuGetFramework framework in supportedFrameworks)
{
var allItems = nupkgReader.GetToolItems().SelectMany(i => i.Items).ToList();
allItems.Should().NotContain($"tools/{framework.GetShortFolderName()}/any/consoledemo{extension}");
}
}
var getValuesCommand = new GetValuesCommand(
Log,
_testRoot,
_targetFrameworkOrFrameworks,
"RunCommand",
GetValuesCommand.ValueType.Property);
if (!RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
{
getValuesCommand.Execute();
string runCommandPath = getValuesCommand.GetValues().Single();
Path.GetExtension(runCommandPath)
.Should().Be(extension);
File.Exists(runCommandPath).Should()
.BeTrue("run command should be apphost executable (for WinExe) to debug. But it will not be packed");
}
}
public void It_should_import_AutoImports_for_installed_workloads()
{
var testProject = new TestProject()
{
Name = "WorkloadTest",
TargetFrameworks = "net5.0"
};
var testAsset = _testAssetsManager.CreateTestProject(testProject);
var expectedProperty = RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? "WinTestWorkloadAutoImportPropsImported" : "UnixTestWorkloadAutoImportPropsImported";
var getValuesCommand = new GetValuesCommand(testAsset, expectedProperty);
getValuesCommand
.Execute()
.Should()
.Pass();
getValuesCommand
.GetValues()
.Should()
.BeEquivalentTo("true");
}
public void It_defines_target_platform_from_target_framework(string targetFramework, string expectedTargetFrameworkIdentifier, string expectedTargetFrameworkVersion, string expectedTargetPlatformIdentifier, string expectedTargetPlatformVersion)
{
var testProj = new TestProject()
{
Name = "TargetPlatformTests",
IsSdkProject = true,
TargetFrameworks = targetFramework
};
var testAsset = _testAssetsManager.CreateTestProject(testProj);
Action <string, string> assertValue = (string valueName, string expected) =>
{
var getValuesCommand = new GetValuesCommand(Log, Path.Combine(testAsset.Path, testProj.Name), targetFramework, valueName);
getValuesCommand
.Execute()
.Should()
.Pass();
if (expected.Trim().Equals(string.Empty))
{
getValuesCommand.GetValues().Count.Should().Be(0, $"expect '{valueName}' to be '{expected}'. But get {string.Join(";", getValuesCommand.GetValues())}");
}
else
{
getValuesCommand.GetValues().ShouldBeEquivalentTo(new[] { expected }, $"Asserting \"{valueName}\"'s value");
}
};
assertValue("TargetFrameworkIdentifier", expectedTargetFrameworkIdentifier);
assertValue("TargetFrameworkVersion", expectedTargetFrameworkVersion);
assertValue("TargetPlatformIdentifier", expectedTargetPlatformIdentifier);
assertValue("TargetPlatformIdentifier", expectedTargetPlatformIdentifier);
assertValue("TargetPlatformVersion", expectedTargetPlatformVersion);
assertValue("TargetPlatformMoniker", expectedTargetPlatformIdentifier.Equals(string.Empty) && expectedTargetPlatformVersion.Equals(string.Empty) ?
string.Empty : $"{expectedTargetPlatformIdentifier},Version={expectedTargetPlatformVersion}");
assertValue("TargetPlatformDisplayName", $"{expectedTargetPlatformIdentifier} {expectedTargetPlatformVersion}");
}
public void It_solves_conflicts_between_package_and_implicit_references()
{
// Test case from https://github.com/dotnet/sdk/issues/3904.
// This dll is included in both the explicit package reference and Microsoft.NET.Build.Extensions. We prevent a double write in
// _ComputeResolvedCopyLocalPublishAssets by removing dlls duplicated between package references and implicitly expanded .NET references.
var reference = "System.Runtime.InteropServices.RuntimeInformation";
var targetFramework = "net461";
var testProject = new TestProject()
{
Name = "ConflictingFilePublish",
IsSdkProject = true,
TargetFrameworks = targetFramework
};
testProject.PackageReferences.Add(new TestPackageReference(reference, "4.3.0"));
testProject.PackageReferences.Add(new TestPackageReference("Microsoft.AspNetCore", "2.1.4"));
var testAsset = _testAssetsManager.CreateTestProject(testProject, testProject.Name);
var getValuesCommand = new GetValuesCommand(Log, Path.Combine(testAsset.TestRoot, testProject.Name), targetFramework, "ResolvedFileToPublish", GetValuesCommand.ValueType.Item)
{
DependsOnTargets = "Publish"
};
getValuesCommand
.Execute()
.Should()
.Pass();
var files = getValuesCommand.GetValues()
.Where(file => file.Contains(reference));
files.Count().Should().Be(1);
// We should choose the system.runtime.interopservices.runtimeinformation file from Microsoft.NET.Build.Extensions as it has a higher AssemblyVersion (4.0.2.0 compared to 4.0.1.0)
files.FirstOrDefault().Contains(@"Microsoft.NET.Build.Extensions\net461\lib\System.Runtime.InteropServices.RuntimeInformation.dll").Should().BeTrue();
}
public void Net50TargetFrameworkParsesAsNetCoreAppTargetFrameworkIdentifier()
{
var testProject = new TestProject()
{
Name = "Net5Test",
TargetFrameworks = "net5.0",
};
var testAsset = _testAssetsManager.CreateTestProject(testProject, testProject.Name);
var buildCommand = new BuildCommand(testAsset);
buildCommand.Execute()
.Should()
.Pass();
var getValuesCommand = new GetValuesCommand(Log, Path.Combine(testAsset.TestRoot, testProject.Name), testProject.TargetFrameworks, "TargetFrameworkIdentifier");
getValuesCommand.Execute()
.Should()
.Pass();
getValuesCommand.GetValues().Should().BeEquivalentTo(".NETCoreApp");
}
public void RuntimePackWithLabelIsSelected()
{
var testProject = new TestProject()
{
TargetFrameworks = "net5.0",
IsSdkProject = true,
IsExe = true,
RuntimeIdentifier = EnvironmentInfo.GetCompatibleRid()
};
var testAsset = _testAssetsManager.CreateTestProject(testProject);
var knownRuntimePack = CreateTestKnownRuntimePack();
AddItem(testAsset, knownRuntimePack);
var frameworkReferenceUpdate = new XElement("FrameworkReference",
new XAttribute("Update", "Microsoft.NETCore.App"),
new XAttribute("RuntimePackLabels", "Mono"));
AddItem(testAsset, frameworkReferenceUpdate);
var getValuesCommand = new GetValuesCommand(testAsset, "RuntimePack", GetValuesCommand.ValueType.Item)
{
DependsOnTargets = "ProcessFrameworkReferences",
ShouldRestore = false
};
getValuesCommand
.Execute()
.Should()
.Pass();
// StartsWith instead of exact match because current RID is likely to be more specific than the runtime pack RID
getValuesCommand.GetValues().Should().Contain(rp => rp.StartsWith("Microsoft.NETCore.App.Runtime.Mono."));
}
public void It_Has_Unescaped_PackageConflictPreferredPackages_Values()
{
string targetFramework = ToolsetInfo.CurrentTargetFramework;
var testAsset = _testAssetsManager
.CopyTestAsset("AppWithLibrary", identifier: targetFramework)
.WithSource()
.WithTargetFramework(targetFramework, "TestLibrary");
var getValuesCommand = new GetValuesCommand(Log, Path.Combine(testAsset.TestRoot, "TestLibrary"), targetFramework, "PackageConflictPreferredPackages");
getValuesCommand
.Execute()
.Should()
.Pass();
List <string> preferredPackages = getValuesCommand.GetValues();
preferredPackages.Should().NotBeEmpty();
preferredPackages.Count.Should().BeGreaterThan(1);
preferredPackages.Should().NotContain(packageName => packageName.Contains(';'),
because: "No package name should have a semicolon in it--PackageConflictPreferredPackages should be a semicolon delimited list of package names");
}
public void It_uses_hintpath_when_replacing_simple_name_references(bool useFacades)
{
TestProject project = new TestProject()
{
Name = "NETFrameworkLibrary",
TargetFrameworks = "net462",
IsSdkProject = true
};
if (useFacades)
{
var netStandard2Project = new TestProject()
{
Name = "NETStandard20Project",
TargetFrameworks = "netstandard2.0",
IsSdkProject = true
};
project.ReferencedProjects.Add(netStandard2Project);
}
var testAsset = _testAssetsManager.CreateTestProject(project, "SimpleNamesWithHintPaths", identifier: useFacades ? "_useFacades" : "")
.WithProjectChanges((path, p) =>
{
if (Path.GetFileNameWithoutExtension(path) == project.Name)
{
var ns = p.Root.Name.Namespace;
var itemGroup = new XElement(ns + "ItemGroup");
p.Root.Add(itemGroup);
if (!useFacades)
{
itemGroup.Add(new XElement(ns + "PackageReference",
new XAttribute("Include", "System.Net.Http"),
new XAttribute("Version", "4.3.2")));
}
itemGroup.Add(new XElement(ns + "Reference",
new XAttribute("Include", "System.Net.Http")));
}
});
string projectFolder = Path.Combine(testAsset.Path, project.Name);
var getValuesCommand = new GetValuesCommand(Log, projectFolder, project.TargetFrameworks, "Reference", GetValuesCommand.ValueType.Item);
getValuesCommand.MetadataNames.Add("HintPath");
getValuesCommand
.Execute()
.Should()
.Pass();
string correctHttpReference;
if (useFacades)
{
string microsoftNETBuildExtensionsPath = TestContext.Current.ToolsetUnderTest.GetMicrosoftNETBuildExtensionsPath();
correctHttpReference = Path.Combine(microsoftNETBuildExtensionsPath, @"net461\lib\System.Net.Http.dll");
}
else
{
correctHttpReference = Path.Combine(TestContext.Current.NuGetCachePath, "system.net.http", "4.3.2", "ref", "net46", "System.Net.Http.dll");
}
var valuesWithMetadata = getValuesCommand.GetValuesWithMetadata();
// There shouldn't be a Reference item where the ItemSpec is the path to the System.Net.Http.dll from a NuGet package
valuesWithMetadata.Should().NotContain(v => v.value == correctHttpReference);
// There should be a Reference item where the ItemSpec is the simple name System.Net.Http
valuesWithMetadata.Should().ContainSingle(v => v.value == "System.Net.Http");
// The Reference item with the simple name should have a HintPath to the DLL in the NuGet package
valuesWithMetadata.Single(v => v.value == "System.Net.Http")
.metadata["HintPath"]
.Should().Be(correctHttpReference);
}
public void When_TargetPlatformVersion_is_set_higher_than_10_It_can_reference_cswinrt_api()
{
const string ProjectName = "WindowsDesktopSdkTest_without_ProjectSdk_set";
const string tfm = "net5.0";
var testProject = new TestProject()
{
Name = ProjectName,
TargetFrameworks = tfm,
IsWinExe = true,
};
testProject.SourceFiles.Add("Program.cs", _useCsWinrtApi);
testProject.AdditionalProperties.Add("TargetPlatformIdentifier", "Windows");
testProject.AdditionalProperties.Add("TargetPlatformVersion", "10.0.17763");
var asset = _testAssetsManager.CreateTestProject(testProject);
var buildCommand = new BuildCommand(Log, Path.Combine(asset.Path, ProjectName));
buildCommand.Execute()
.Should()
.Pass();
void Assert(DirectoryInfo outputDir)
{
outputDir.File("Microsoft.Windows.SDK.NET.dll").Exists.Should().BeTrue("The output has cswinrt dll");
outputDir.File("WinRT.Runtime.dll").Exists.Should().BeTrue("The output has cswinrt dll");
var runtimeconfigjson = File.ReadAllText(outputDir.File(ProjectName + ".runtimeconfig.json").FullName);
runtimeconfigjson.Contains(@"""name"": ""Microsoft.NETCore.App""").Should().BeTrue("runtimeconfig.json only reference Microsoft.NETCore.App");
runtimeconfigjson.Contains("Microsoft.Windows.SDK.NET").Should().BeFalse("runtimeconfig.json does not reference windows SDK");
}
Assert(buildCommand.GetOutputDirectory(tfm));
var publishCommand = new PublishCommand(asset);
var runtimeIdentifier = "win-x64";
publishCommand.Execute("-p:SelfContained=true", $"-p:RuntimeIdentifier={runtimeIdentifier}")
.Should()
.Pass();
Assert(publishCommand.GetOutputDirectory(tfm, runtimeIdentifier: runtimeIdentifier));
var command = new GetValuesCommand(
Log,
Path.Combine(asset.Path, testProject.Name),
testProject.TargetFrameworks,
"FilesCopiedToPublishDir",
GetValuesCommand.ValueType.Item)
{
DependsOnTargets = "ComputeFilesCopiedToPublishDir",
MetadataNames = { "RelativePath" },
};
command.Execute().Should().Pass();
var items = from item in command.GetValuesWithMetadata()
select new
{
Identity = item.value,
RelativePath = item.metadata["RelativePath"]
};
items
.Should().Contain(i => i.RelativePath == "Microsoft.Windows.SDK.NET.dll" && Path.GetFileName(i.Identity) == "Microsoft.Windows.SDK.NET.dll",
because: "wapproj should copy cswinrt dlls");
items
.Should()
.Contain(i => i.RelativePath == "WinRT.Runtime.dll" && Path.GetFileName(i.Identity) == "WinRT.Runtime.dll",
because: "wapproj should copy cswinrt dlls");
// ready to run is supported
publishCommand.Execute("-p:SelfContained=true", $"-p:RuntimeIdentifier={runtimeIdentifier}", $"-p:PublishReadyToRun=true")
.Should()
.Pass();
// PublishSingleFile is supported
publishCommand.Execute("-p:SelfContained=true", $"-p:RuntimeIdentifier={runtimeIdentifier}", $"-p:PublishSingleFile=true")
.Should()
.Pass();
}
public void It_builds_a_simple_vb_project(string targetFramework, bool isExe)
{
var(expectedVBRuntime, expectedOutputFiles) = GetExpectedOutputs(targetFramework, isExe);
var testProject = new TestProject
{
Name = "HelloWorld",
IsSdkProject = true,
TargetFrameworks = targetFramework,
IsExe = isExe,
SourceFiles =
{
["Program.vb"] = @"
Imports System
Module Program
#If NETFRAMEWORK Or NETCOREAPP3_0
' https://github.com/dotnet/sdk/issues/2793
Private Const TabChar As Char = Chr(9)
#End If
Function MyComputerName() As String
#If NETFRAMEWORK
Return My.Computer.Name
#End If
#If NETFRAMEWORK Or NETCOREAPP_3_0
' https://github.com/dotnet/sdk/issues/3379
End
#End If
End Function
Sub Main(args As String())
Console.WriteLine(""Hello World from "" & MyComputerName())
End Sub
End Module
",
}
};
var testAsset = _testAssetsManager
.CreateTestProject(testProject, identifier: targetFramework + isExe, targetExtension: ".vbproj");
var buildCommand = new GetValuesCommand(
Log,
Path.Combine(testAsset.TestRoot, testProject.Name),
targetFramework,
"VBRuntime")
{
DependsOnTargets = "Build"
};
buildCommand
.Execute()
.Should()
.Pass();
var outputDirectory = buildCommand.GetOutputDirectory(targetFramework);
var actualVBRuntime = GetVBRuntime(buildCommand.GetValues().FirstOrDefault());
File.Delete(outputDirectory.File("VBRuntimeValues.txt").FullName);
outputDirectory.Should().OnlyHaveFiles(expectedOutputFiles);
actualVBRuntime.Should().Be(expectedVBRuntime);
}
public void It_builds_a_simple_project(string targetFramework)
{
if (targetFramework == "net45" && !TestProject.ReferenceAssembliesAreInstalled("v4.5"))
{
// skip net45 when we do not have .NET Framework 4.5 reference assemblies
// due to https://github.com/dotnet/core-sdk/issues/3228
return;
}
var(expectedVBRuntime, expectedOutputFiles) = GetExpectedOutputs(targetFramework);
var testProject = new TestProject
{
Name = "HelloWorld",
IsSdkProject = true,
TargetFrameworks = targetFramework,
IsExe = targetFramework != "netstandard2.0",
AdditionalProperties =
{
["MyType"] = "Console",
},
SourceFiles =
{
["Program.vb"] = @"
Imports System
Module Program
Function MyComputerName() As String
#If NETFRAMEWORK Or NETCOREAPP3_0 Then
Return My.Computer.Name
#End If
End Function
Sub Main(args As String())
Console.WriteLine(""Hello World from "" & MyComputerName())
End Sub
End Module
",
}
};
var testAsset = _testAssetsManager
.CreateTestProject(testProject, identifier: targetFramework, targetExtension: ".vbproj")
.Restore(Log, testProject.Name);
var buildCommand = new GetValuesCommand(
Log,
Path.Combine(testAsset.TestRoot, testProject.Name),
targetFramework,
"VBRuntime")
{
DependsOnTargets = "Build"
};
buildCommand
.Execute()
.Should()
.Pass();
var outputDirectory = buildCommand.GetOutputDirectory(targetFramework);
var actualVBRuntime = GetVBRuntime(buildCommand.GetValues().FirstOrDefault());
File.Delete(outputDirectory.File("VBRuntimeValues.txt").FullName);
outputDirectory.Should().OnlyHaveFiles(expectedOutputFiles);
actualVBRuntime.Should().Be(expectedVBRuntime);
}
public void It_provides_runtime_configuration_and_shadow_copy_files_via_outputgroup(string targetFramework)
{
var projectRef = new TestProject
{
Name = "ReferencedProject",
TargetFrameworks = targetFramework,
IsSdkProject = true,
};
var project = new TestProject
{
Name = "DesignerTest",
IsExe = true,
TargetFrameworks = targetFramework,
IsSdkProject = true,
PackageReferences = { new TestPackageReference("NewtonSoft.Json", "12.0.1") },
ReferencedProjects = { projectRef }
};
var asset = _testAssetsManager
.CreateTestProject(project, identifier: targetFramework)
.Restore(Log, project.Name);
var command = new GetValuesCommand(
Log,
Path.Combine(asset.Path, project.Name),
targetFramework,
"DesignerRuntimeImplementationProjectOutputGroupOutput",
GetValuesCommand.ValueType.Item)
{
DependsOnTargets = "DesignerRuntimeImplementationProjectOutputGroup",
MetadataNames = { "TargetPath" },
};
command.Execute().Should().Pass();
var items =
from item in command.GetValuesWithMetadata()
select new
{
Identity = item.value,
TargetPath = item.metadata["TargetPath"]
};
string depsFile = null;
string runtimeConfig = null;
var otherFiles = new List <string>();
foreach (var item in items)
{
Path.IsPathFullyQualified(item.Identity).Should().BeTrue();
Path.GetFileName(item.Identity).Should().Be(item.TargetPath);
switch (item.TargetPath)
{
case "DesignerTest.designer.deps.json":
depsFile = item.Identity;
break;
case "DesignerTest.designer.runtimeconfig.json":
runtimeConfig = item.Identity;
break;
default:
otherFiles.Add(item.TargetPath);
break;
}
}
switch (targetFramework)
{
case "netcoreapp3.0":
var depsFileLibraries = GetRuntimeLibraryFileNames(depsFile);
depsFileLibraries.Should().BeEquivalentTo(new[] { "Newtonsoft.Json.dll" });
var options = GetRuntimeOptions(runtimeConfig);
options["configProperties"]["Microsoft.NETCore.DotNetHostPolicy.SetAppPaths"].Value <bool>().Should().BeTrue();
options["tfm"].Value <string>().Should().Be(targetFramework);
options["additionalProbingPaths"].Value <JArray>().Should().NotBeEmpty();
otherFiles.Should().BeEquivalentTo(new[] { "ReferencedProject.dll", "ReferencedProject.pdb" });
break;
case "net46":
depsFile.Should().BeNull();
runtimeConfig.Should().BeNull();
otherFiles.Should().BeEquivalentTo(new[] { "Newtonsoft.Json.dll", "ReferencedProject.dll", "ReferencedProject.pdb" });
break;
}
}
//[Theory]
//[InlineData(".NETStandard,Version=v1.0", new[] { "NETSTANDARD1_0" }, false)]
//[InlineData("netstandard1.3", new[] { "NETSTANDARD1_3" }, false)]
//[InlineData("netstandard1.6", new[] { "NETSTANDARD1_6" }, false)]
//[InlineData("net45", new[] { "NET45" }, true)]
//[InlineData("net461", new[] { "NET461" }, true)]
//[InlineData("netcoreapp1.0", new[] { "NETCOREAPP1_0" }, false)]
//[InlineData(".NETPortable,Version=v4.5,Profile=Profile78", new string[] { }, false)]
//[InlineData(".NETFramework,Version=v4.0,Profile=Client", new string[] { "NET40" }, false)]
//[InlineData("Xamarin.iOS,Version=v1.0", new string[] { "XAMARINIOS1_0" }, false)]
//[InlineData("UnknownFramework,Version=v3.14", new string[] { "UNKNOWNFRAMEWORK3_14" }, false)]
public void It_implicitly_defines_compilation_constants_for_the_target_framework(string targetFramework, string[] expectedDefines, bool buildOnlyOnWindows)
{
bool shouldCompile = true;
var testAsset = _testAssetsManager
.CopyTestAsset("AppWithLibrary", "ImplicitFrameworkConstants", targetFramework)
.WithSource()
.WithProjectChanges(project =>
{
// Update target framework in project
var ns = project.Root.Name.Namespace;
var targetFrameworkProperties = project.Root
.Elements(ns + "PropertyGroup")
.Elements(ns + "TargetFramework")
.ToList();
targetFrameworkProperties.Count.Should().Be(1);
if (targetFramework.Contains(",Version="))
{
// We use the full TFM for frameworks we don't have built-in support for targeting, so we don't want to run the Compile target
shouldCompile = false;
var frameworkName = new FrameworkName(targetFramework);
var targetFrameworkProperty = targetFrameworkProperties.Single();
targetFrameworkProperty.AddBeforeSelf(new XElement(ns + "TargetFrameworkIdentifier", frameworkName.Identifier));
targetFrameworkProperty.AddBeforeSelf(new XElement(ns + "TargetFrameworkVersion", "v" + frameworkName.Version.ToString()));
if (!string.IsNullOrEmpty(frameworkName.Profile))
{
targetFrameworkProperty.AddBeforeSelf(new XElement(ns + "TargetFrameworkProfile", frameworkName.Profile));
}
// For the NuGet restore task to work with package references, it needs the TargetFramework property to be set.
// Otherwise we would just remove the property.
targetFrameworkProperty.SetValue(targetFramework);
}
else
{
shouldCompile = true;
targetFrameworkProperties.Single().SetValue(targetFramework);
}
})
.Restore(relativePath: "TestLibrary");
if (buildOnlyOnWindows && !RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
shouldCompile = false;
}
var libraryProjectDirectory = Path.Combine(testAsset.TestRoot, "TestLibrary");
var getValuesCommand = new GetValuesCommand(Stage0MSBuild, libraryProjectDirectory,
targetFramework, "DefineConstants")
{
ShouldCompile = shouldCompile
};
getValuesCommand
.Execute()
.Should()
.Pass();
var definedConstants = getValuesCommand.GetValues();
definedConstants.Should().BeEquivalentTo(new[] { "DEBUG", "TRACE" }.Concat(expectedDefines).ToArray());
}