mono/linux-packaging-mono
0
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Imported Upstream version 4.6.0.125

Browse Source 
Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4
This commit is contained in:
Xamarin Public Jenkins (auto-signing)
2016-08-03 10:59:49 +00:00
parent a569aebcfd
commit e79aa3c0ed
17047 changed files with 3137615 additions and 392334 deletions
Download Patch File Download Diff File Expand all files Collapse all files

35
external/nuget-buildtasks/src/Microsoft.NuGet.Build.Tasks.Tests/AnalyzerResolutionTests.cs vendored Normal file
View File

@@ -0,0 +1,35 @@
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
using System.Linq;
using Xunit;
namespace Microsoft.NuGet.Build.Tasks.Tests
{
public class AnalyzerResolutionTests
{
[Fact]
public static void TestAnalyzerResolutionCSharp()
{
var result = NuGetTestHelpers.ResolvePackagesWithJsonFileContents(
Json.Json.analyzers,
targetMoniker: ".NETCore,Version=v5.0",
runtimeIdentifier: "",
projectLanguage: "C#");
AssertHelpers.AssertCountOf(8, result.Analyzers);
}
[Fact]
public static void TestAnalyzerResolutionVisualBasic()
{
var result = NuGetTestHelpers.ResolvePackagesWithJsonFileContents(
Json.Json.analyzers,
targetMoniker: ".NETCore,Version=v5.0",
runtimeIdentifier: "",
projectLanguage: "vb");
AssertHelpers.AssertCountOf(8, result.Analyzers);
}
}
}

83
external/nuget-buildtasks/src/Microsoft.NuGet.Build.Tasks.Tests/AssertHelpers.cs vendored Normal file
View File

@@ -0,0 +1,83 @@
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Microsoft.Build.Framework;
using Xunit;
namespace Microsoft.NuGet.Build.Tasks.Tests
{
internal static class AssertHelpers
{
public static void AssertCountOf(int expectedCount, IEnumerable<ITaskItem> items)
{
Assert.True(items.Count() == expectedCount,
$"Expected {expectedCount} items, but actually got {items.Count()} items:" + Environment.NewLine + string.Join(Environment.NewLine, items.Select(i => i.ItemSpec)));
}
/// <summary>
/// Asserts that the expected path ends with our actual path. "Ends with" in this case is defined by path
/// components, so "Directory\File" doesn't end with "ile", to prevent any bugs where path components get mangled.
/// </summary>
public static void PathEndsWith(string expectedPath, string actualPath)
{
// We could implement this with a simple Assert.True(...EndsWithPath),
// but that results in less user-friendly output from the test than a smarter call to
// Assert.EndsWith
if (!actualPath.EndsWithPath(expectedPath))
{
Assert.EndsWith("\\" + expectedPath, actualPath);
// If we get out of sync with this function or EndsWithPath, that Assert might not
// fail. In that case, fail the test.
throw new Exception("The Assert.EndsWith in the previous line should have failed.");
}
}
/// <summary>
/// Returns that the expected path ends with our actual path. "Ends with" in this case is defined by path
/// components, so "Directory\File" doesn't end with "ile", to prevent any bugs where path components get mangled.
/// </summary>
public static bool EndsWithPath(this string path, string suffix)
{
return path == suffix || path.EndsWith("\\" + suffix);
}
public static void AssertNoTargetPaths(IEnumerable<ITaskItem> items)
{
foreach (var item in items)
{
Assert.Equal("", item.GetMetadata("DestinationSubDirectory"));
Assert.Equal("", item.GetMetadata("TargetPath"));
}
}
public static void AssertConsistentTargetPaths(IEnumerable<ITaskItem> items)
{
var mapToItem = new Dictionary<string, ITaskItem>(StringComparer.OrdinalIgnoreCase);
foreach (var item in items)
{
string effectiveTargetPath = item.GetMetadata("TargetPath");
if (string.IsNullOrEmpty(effectiveTargetPath))
{
effectiveTargetPath = Path.GetFileName(item.ItemSpec);
}
ITaskItem conflictingItem;
if (mapToItem.TryGetValue(effectiveTargetPath, out conflictingItem))
{
Assert.True(conflictingItem == null, $"Item {item.ItemSpec} and {conflictingItem.ItemSpec} have the same TargetPath.");
}
mapToItem.Add(effectiveTargetPath, item);
}
}
}
}

24
external/nuget-buildtasks/src/Microsoft.NuGet.Build.Tasks.Tests/Helpers/DisposableDirectory.cs vendored Normal file
View File

@@ -0,0 +1,24 @@
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
using System;
using System.IO;
namespace Microsoft.NuGet.Build.Tasks.Tests.Helpers
{
public sealed class DisposableDirectory : TempDirectory, IDisposable
{
public DisposableDirectory(TempRoot root)
: base(root)
{
}
public void Dispose()
{
if (Path != null && Directory.Exists(Path))
{
Directory.Delete(Path, recursive: true);
}
}
}
}

31
external/nuget-buildtasks/src/Microsoft.NuGet.Build.Tasks.Tests/Helpers/DisposableFile.cs vendored Normal file
View File

@@ -0,0 +1,31 @@
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
using System;
using System.IO;
using System.Runtime.InteropServices;
using Microsoft.Win32.SafeHandles;
namespace Microsoft.NuGet.Build.Tasks.Tests.Helpers
{
public sealed class DisposableFile : TempFile, IDisposable
{
public DisposableFile(string path)
: base(path)
{
}
public DisposableFile(TempRoot root, string prefix = null, string extension = null, string directory = null, string callerSourcePath = null, int callerLineNumber = 0)
: base(root, prefix, extension, directory, callerSourcePath, callerLineNumber)
{
}
public void Dispose()
{
if (Path != null && File.Exists(Path))
{
File.Delete(Path);
}
}
}
}

89
external/nuget-buildtasks/src/Microsoft.NuGet.Build.Tasks.Tests/Helpers/MockBuildEngine.cs vendored Normal file
View File

@@ -0,0 +1,89 @@
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using Microsoft.Build.Framework;
namespace Microsoft.NuGet.Build.Tasks.Tests.Helpers
{
public class MockBuildEngine : IBuildEngine, IBuildEngine2, IBuildEngine3, IBuildEngine4
{
public MockBuildEngine(TextWriter output)
{
this.Output = output;
}
private TextWriter Output { get; }
int IBuildEngine.ColumnNumberOfTaskNode => -1;
bool IBuildEngine.ContinueOnError => false;
int IBuildEngine.LineNumberOfTaskNode => -1;
string IBuildEngine.ProjectFileOfTaskNode => "this.xml";
bool IBuildEngine2.IsRunningMultipleNodes => false;
bool IBuildEngine.BuildProjectFile(string projectFileName, string[] targetNames, IDictionary globalProperties, IDictionary targetOutputs) => true;
void IBuildEngine.LogCustomEvent(CustomBuildEventArgs e)
{
this.Output.WriteLine($"Custom: {e.Message}");
}
void IBuildEngine.LogErrorEvent(BuildErrorEventArgs e)
{
this.Output.WriteLine($"Error: {e.Message}");
}
void IBuildEngine.LogMessageEvent(BuildMessageEventArgs e)
{
this.Output.WriteLine($"Message: {e.Message}");
}
void IBuildEngine.LogWarningEvent(BuildWarningEventArgs e)
{
this.Output.WriteLine($"Warning: {e.Message}");
}
private Dictionary<object, object> Tasks = new Dictionary<object, object>();
void IBuildEngine4.RegisterTaskObject(object key, object obj, RegisteredTaskObjectLifetime lifetime, bool allowEarlyCollection)
{
Tasks.Add(key, obj);
}
object IBuildEngine4.GetRegisteredTaskObject(object key, RegisteredTaskObjectLifetime lifetime)
{
return null;
}
object IBuildEngine4.UnregisterTaskObject(object key, RegisteredTaskObjectLifetime lifetime)
{
var obj = Tasks[key];
Tasks.Remove(key);
return obj;
}
BuildEngineResult IBuildEngine3.BuildProjectFilesInParallel(string[] projectFileNames, string[] targetNames, IDictionary[] globalProperties, IList<string>[] removeGlobalProperties, string[] toolsVersion, bool returnTargetOutputs)
{
throw new NotImplementedException();
}
void IBuildEngine3.Yield() { }
void IBuildEngine3.Reacquire() { }
bool IBuildEngine2.BuildProjectFile(string projectFileName, string[] targetNames, IDictionary globalProperties, IDictionary targetOutputs, string toolsVersion) => true;
bool IBuildEngine2.BuildProjectFilesInParallel(string[] projectFileNames, string[] targetNames, IDictionary[] globalProperties, IDictionary[] targetOutputsPerProject, string[] toolsVersion, bool useResultsCache, bool unloadProjectsOnCompletion) => true;
}
}

89
external/nuget-buildtasks/src/Microsoft.NuGet.Build.Tasks.Tests/Helpers/TempDirectory.cs vendored Normal file
View File

@@ -0,0 +1,89 @@
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
using System;
using System.Diagnostics;
using System.IO;
namespace Microsoft.NuGet.Build.Tasks.Tests.Helpers
{
public class TempDirectory
{
private readonly string _path;
private readonly TempRoot _root;
protected TempDirectory(TempRoot root)
: this(root.Root, root)
{
}
private TempDirectory(string path, TempRoot root)
{
Debug.Assert(path != null);
Debug.Assert(root != null);
_path = path;
_root = root;
}
private static string CreateUniqueDirectory(string basePath)
{
while (true)
{
string dir = System.IO.Path.Combine(basePath, Guid.NewGuid().ToString());
try
{
Directory.CreateDirectory(dir);
return dir;
}
catch (IOException)
{
// retry
}
}
}
public string Path
{
get { return _path; }
}
/// <summary>
/// Creates a file in this directory.
/// </summary>
/// <param name="name">File name.</param>
public TempFile CreateFile(string name)
{
string filePath = System.IO.Path.Combine(_path, name);
TempRoot.CreateStream(filePath);
return _root.AddFile(new DisposableFile(filePath));
}
/// <summary>
/// Creates a file in this directory that is a copy of the specified file.
/// </summary>
public TempFile CopyFile(string originalPath)
{
string name = System.IO.Path.GetFileName(originalPath);
string filePath = System.IO.Path.Combine(_path, name);
File.Copy(originalPath, filePath);
return _root.AddFile(new DisposableFile(filePath));
}
/// <summary>
/// Creates a subdirectory in this directory.
/// </summary>
/// <param name="name">Directory name or unrooted directory path.</param>
public TempDirectory CreateDirectory(string name)
{
string dirPath = System.IO.Path.Combine(_path, name);
Directory.CreateDirectory(dirPath);
return new TempDirectory(dirPath, _root);
}
public override string ToString()
{
return _path;
}
}
}

109
external/nuget-buildtasks/src/Microsoft.NuGet.Build.Tasks.Tests/Helpers/TempFile.cs vendored Normal file
View File

@@ -0,0 +1,109 @@
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
using System;
using System.IO;
using System.Text;
using System.Threading.Tasks;
namespace Microsoft.NuGet.Build.Tasks.Tests.Helpers
{
public class TempFile
{
private readonly string _path;
internal TempFile(string path)
{
_path = path;
}
internal TempFile(TempRoot root, string prefix, string extension, string directory, string callerSourcePath, int callerLineNumber)
{
while (true)
{
if (prefix == null)
{
prefix = System.IO.Path.GetFileName(callerSourcePath) + "_" + callerLineNumber.ToString() + "_";
}
_path = System.IO.Path.Combine(directory ?? root.Root, prefix + Guid.NewGuid() + (extension ?? ".tmp"));
try
{
TempRoot.CreateStream(_path);
break;
}
catch (PathTooLongException)
{
throw;
}
catch (DirectoryNotFoundException)
{
throw;
}
catch (IOException)
{
// retry
}
}
}
public FileStream Open(FileAccess access = FileAccess.ReadWrite)
{
return new FileStream(_path, FileMode.Open, access);
}
public string Path
{
get { return _path; }
}
public TempFile WriteAllText(string content, Encoding encoding)
{
File.WriteAllText(_path, content, encoding);
return this;
}
public TempFile WriteAllText(string content)
{
File.WriteAllText(_path, content);
return this;
}
public async Task<TempFile> WriteAllTextAsync(string content, Encoding encoding)
{
using (var sw = new StreamWriter(File.Create(_path), encoding))
{
await sw.WriteAsync(content).ConfigureAwait(false);
}
return this;
}
public Task<TempFile> WriteAllTextAsync(string content)
{
return WriteAllTextAsync(content, Encoding.UTF8);
}
public TempFile WriteAllBytes(byte[] content)
{
File.WriteAllBytes(_path, content);
return this;
}
public string ReadAllText()
{
return File.ReadAllText(_path);
}
public TempFile CopyContentFrom(string path)
{
return WriteAllBytes(File.ReadAllBytes(path));
}
public override string ToString()
{
return _path;
}
}
}

73
external/nuget-buildtasks/src/Microsoft.NuGet.Build.Tasks.Tests/Helpers/TempRoot.cs vendored Normal file
View File

@@ -0,0 +1,73 @@
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
using System;
using System.Collections.Generic;
using System.IO;
using System.Runtime.CompilerServices;
namespace Microsoft.NuGet.Build.Tasks.Tests.Helpers
{
public sealed class TempRoot : IDisposable
{
private readonly List<IDisposable> _temps = new List<IDisposable>();
public readonly string Root;
public TempRoot()
{
Root = Path.Combine(Path.GetTempPath(), "NuGetBuildTests", Guid.NewGuid().ToString());
Directory.CreateDirectory(Root);
}
public void Dispose()
{
if (_temps != null)
{
DisposeAll(_temps);
_temps.Clear();
}
}
private static void DisposeAll(IEnumerable<IDisposable> temps)
{
foreach (var temp in temps)
{
try
{
if (temp != null)
{
temp.Dispose();
}
}
catch
{
// ignore
}
}
}
public DisposableDirectory CreateDirectory()
{
var dir = new DisposableDirectory(this);
_temps.Add(dir);
return dir;
}
public TempFile CreateFile(TempRoot root, string prefix = null, string extension = null, string directory = null, [CallerFilePath]string callerSourcePath = null, [CallerLineNumber]int callerLineNumber = 0)
{
return AddFile(new DisposableFile(root, prefix, extension, directory, callerSourcePath, callerLineNumber));
}
public DisposableFile AddFile(DisposableFile file)
{
_temps.Add(file);
return file;
}
internal static void CreateStream(string fullPath)
{
using (var file = new FileStream(fullPath, FileMode.CreateNew)) { }
}
}
}

109
external/nuget-buildtasks/src/Microsoft.NuGet.Build.Tasks.Tests/Json/FluentAssertions.lock.json vendored Normal file
View File

@@ -0,0 +1,109 @@
{
"locked": false,
"version": 1,
"targets": {
".NETFramework,Version=v4.5.2": {
"FluentAssertions/3.4.1": {
"frameworkAssemblies": [
"System.Xml",
"System.Xml.Linq"
],
"compile": {
"lib/net45/FluentAssertions.Core.dll": {},
"lib/net45/FluentAssertions.dll": {}
},
"runtime": {
"lib/net45/FluentAssertions.Core.dll": {},
"lib/net45/FluentAssertions.dll": {}
}
}
}
},
"libraries": {
"FluentAssertions/3.4.1": {
"sha512": "GTyLzP7d57D3HLVOSFrTSVwod3rZNQRMC2DR13u1hNNyhsskLrbI4SW5XXqyEv8WP7v8IqWx9hdlDiwLY0G8YA==",
"type": "Package",
"files": [
"_rels/.rels",
"FluentAssertions.nuspec",
"lib/net40/FluentAssertions.Core.dll",
"lib/net40/FluentAssertions.Core.pdb",
"lib/net40/FluentAssertions.Core.xml",
"lib/net40/FluentAssertions.dll",
"lib/net40/FluentAssertions.pdb",
"lib/net40/FluentAssertions.xml",
"lib/net45/FluentAssertions.Core.dll",
"lib/net45/FluentAssertions.Core.pdb",
"lib/net45/FluentAssertions.Core.xml",
"lib/net45/FluentAssertions.dll",
"lib/net45/FluentAssertions.pdb",
"lib/net45/FluentAssertions.xml",
"lib/portable-monotouch+monoandroid+xamarin.ios/FluentAssertions.Core.dll",
"lib/portable-monotouch+monoandroid+xamarin.ios/FluentAssertions.Core.pdb",
"lib/portable-monotouch+monoandroid+xamarin.ios/FluentAssertions.Core.xml",
"lib/portable-net40+sl5+win8+wp8+wpa81/FluentAssertions.Core.dll",
"lib/portable-net40+sl5+win8+wp8+wpa81/FluentAssertions.Core.pdb",
"lib/portable-net40+sl5+win8+wp8+wpa81/FluentAssertions.Core.xml",
"lib/portable-net40+sl5+win8+wp8+wpa81/FluentAssertions.dll",
"lib/portable-net40+sl5+win8+wp8+wpa81/FluentAssertions.pdb",
"lib/portable-net40+sl5+win8+wp8+wpa81/FluentAssertions.XML",
"lib/portable-win81+wpa81/FluentAssertions.Core.dll",
"lib/portable-win81+wpa81/FluentAssertions.Core.pdb",
"lib/portable-win81+wpa81/FluentAssertions.Core.xml",
"lib/portable-win81+wpa81/FluentAssertions.dll",
"lib/portable-win81+wpa81/FluentAssertions.pdb",
"lib/portable-win81+wpa81/FluentAssertions.xml",
"lib/sl5/FluentAssertions.Core.dll",
"lib/sl5/FluentAssertions.Core.pdb",
"lib/sl5/FluentAssertions.Core.xml",
"lib/sl5/FluentAssertions.dll",
"lib/sl5/FluentAssertions.pdb",
"lib/sl5/FluentAssertions.xml",
"lib/sl5/Microsoft.CSharp.dll",
"lib/sl5/Microsoft.CSharp.xml",
"lib/sl5/Microsoft.VisualStudio.QualityTools.UnitTesting.Silverlight.dll",
"lib/sl5/Microsoft.VisualStudio.QualityTools.UnitTesting.Silverlight.xml",
"lib/sl5/System.Xml.Linq.dll",
"lib/sl5/System.Xml.Linq.xml",
"lib/sl5/de/Microsoft.CSharp.resources.dll",
"lib/sl5/de/System.Xml.Linq.resources.dll",
"lib/sl5/es/Microsoft.CSharp.resources.dll",
"lib/sl5/es/System.Xml.Linq.resources.dll",
"lib/sl5/fr/Microsoft.CSharp.resources.dll",
"lib/sl5/fr/System.Xml.Linq.resources.dll",
"lib/sl5/it/Microsoft.CSharp.resources.dll",
"lib/sl5/it/System.Xml.Linq.resources.dll",
"lib/sl5/ja/Microsoft.CSharp.resources.dll",
"lib/sl5/ja/System.Xml.Linq.resources.dll",
"lib/sl5/ko/Microsoft.CSharp.resources.dll",
"lib/sl5/ko/System.Xml.Linq.resources.dll",
"lib/sl5/ru/Microsoft.CSharp.resources.dll",
"lib/sl5/ru/System.Xml.Linq.resources.dll",
"lib/sl5/zh-Hans/Microsoft.CSharp.resources.dll",
"lib/sl5/zh-Hans/System.Xml.Linq.resources.dll",
"lib/sl5/zh-Hant/Microsoft.CSharp.resources.dll",
"lib/sl5/zh-Hant/System.Xml.Linq.resources.dll",
"lib/win8/FluentAssertions.Core.dll",
"lib/win8/FluentAssertions.Core.pdb",
"lib/win8/FluentAssertions.Core.xml",
"lib/win8/FluentAssertions.dll",
"lib/win8/FluentAssertions.pdb",
"lib/win8/FluentAssertions.XML",
"lib/wp8/FluentAssertions.Core.dll",
"lib/wp8/FluentAssertions.Core.pdb",
"lib/wp8/FluentAssertions.Core.xml",
"lib/wp8/FluentAssertions.dll",
"lib/wp8/FluentAssertions.pdb",
"lib/wp8/FluentAssertions.xml",
"package/services/metadata/core-properties/c21a09dd42de4a6295af89109b879195.psmdcp",
"[Content_Types].xml"
]
}
},
"projectFileDependencyGroups": {
"": [
"FluentAssertions >= 3.4.1"
],
".NETFramework,Version=v4.5.2": []
}
}

1
external/nuget-buildtasks/src/Microsoft.NuGet.Build.Tasks.Tests/Json/FluentAssertionsAndWin10.lock.json.REMOVED.git-id vendored Normal file
View File

@@ -0,0 +1 @@
30ff7f9f73dc43a40f6417da224d1a3056dafe90

273
external/nuget-buildtasks/src/Microsoft.NuGet.Build.Tasks.Tests/Json/Json.Designer.cs generated vendored Normal file
View File

@@ -0,0 +1,273 @@
//------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
// Runtime Version:4.0.30319.42000
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------
namespace Microsoft.NuGet.Build.Tasks.Tests.Json {
using System;
/// <summary>
/// A strongly-typed resource class, for looking up localized strings, etc.
/// </summary>
// This class was auto-generated by the StronglyTypedResourceBuilder
// class via a tool like ResGen or Visual Studio.
// To add or remove a member, edit your .ResX file then rerun ResGen
// with the /str option, or rebuild your VS project.
[global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
[global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
internal class Json {
private static global::System.Resources.ResourceManager resourceMan;
private static global::System.Globalization.CultureInfo resourceCulture;
[global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
internal Json() {
}
/// <summary>
/// Returns the cached ResourceManager instance used by this class.
/// </summary>
[global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
internal static global::System.Resources.ResourceManager ResourceManager {
get {
if (object.ReferenceEquals(resourceMan, null)) {
global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("Microsoft.NuGet.Build.Tasks.Tests.Json.Json", typeof(Json).Assembly);
resourceMan = temp;
}
return resourceMan;
}
}
/// <summary>
/// Overrides the current thread's CurrentUICulture property for all
/// resource lookups using this strongly typed resource class.
/// </summary>
[global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
internal static global::System.Globalization.CultureInfo Culture {
get {
return resourceCulture;
}
set {
resourceCulture = value;
}
}
/// <summary>
/// Looks up a localized string similar to {
/// &quot;locked&quot;: false,
/// &quot;version&quot;: -9996,
/// &quot;targets&quot;: {
/// &quot;.NETCore,Version=v5.0&quot;: {
/// &quot;Microsoft.AnalyzerPowerPack/1.0.0&quot;: {
/// &quot;frameworkAssemblies&quot;: [
/// &quot;System&quot;
/// ]
/// },
/// &quot;Microsoft.CodeAnalysis.Analyzers/1.0.0&quot;: {
/// &quot;frameworkAssemblies&quot;: [
/// &quot;System&quot;
/// ]
///},
/// &quot;System.Runtime.Analyzers/1.0.0&quot;: {
/// &quot;frameworkAssemblies&quot;: [
/// &quot;System&quot;
/// ]
/// },
/// &quot;System.Runtime.InteropServices.Analyzers/1.0.0&quot;: {
/// [rest of string was truncated]&quot;;.
/// </summary>
internal static string analyzers {
get {
return ResourceManager.GetString("analyzers", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to {
/// &quot;locked&quot;: false,
/// &quot;version&quot;: 1,
/// &quot;targets&quot;: {
/// &quot;.NETFramework,Version=v4.5.2&quot;: {
/// &quot;FluentAssertions/3.4.1&quot;: {
/// &quot;frameworkAssemblies&quot;: [
/// &quot;System.Xml&quot;,
/// &quot;System.Xml.Linq&quot;
/// ],
/// &quot;compile&quot;: {
/// &quot;lib/net45/FluentAssertions.Core.dll&quot;: {},
/// &quot;lib/net45/FluentAssertions.dll&quot;: {}
/// },
/// &quot;runtime&quot;: {
/// &quot;lib/net45/FluentAssertions.Core.dll&quot;: {},
/// &quot;lib/net45/FluentAssertions.dll&quot;: {}
/// }
/// }
/// [rest of string was truncated]&quot;;.
/// </summary>
internal static string FluentAssertions {
get {
return ResourceManager.GetString("FluentAssertions", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to {
/// &quot;locked&quot;: false,
/// &quot;version&quot;: 1,
/// &quot;targets&quot;: {
/// &quot;UAP,Version=v10.0&quot;: {
/// &quot;FluentAssertions/3.4.1&quot;: {
/// &quot;frameworkAssemblies&quot;: [
/// &quot;System.Xml&quot;,
/// &quot;System.Xml.Linq&quot;
/// ],
/// &quot;compile&quot;: {
/// &quot;lib/win8/FluentAssertions.Core.dll&quot;: {},
/// &quot;lib/win8/FluentAssertions.dll&quot;: {}
/// },
/// &quot;runtime&quot;: {
/// &quot;lib/win8/FluentAssertions.Core.dll&quot;: {},
/// &quot;lib/win8/FluentAssertions.dll&quot;: {}
/// }
/// },
/// &quot;Microsoft [rest of string was truncated]&quot;;.
/// </summary>
internal static string FluentAssertionsAndWin10 {
get {
return ResourceManager.GetString("FluentAssertionsAndWin10", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to {
/// &quot;locked&quot;: false,
/// &quot;version&quot;: 2,
/// &quot;targets&quot;: {
/// &quot;.NETFramework,Version=v4.5&quot;: {
/// &quot;Newtonsoft.Json/8.0.3&quot;: {
/// &quot;type&quot;: &quot;package&quot;,
/// &quot;compile&quot;: {
/// &quot;lib/net45/Newtonsoft.Json.dll&quot;: {}
/// },
/// &quot;runtime&quot;: {
/// &quot;lib/net45/Newtonsoft.Json.dll&quot;: {}
/// }
/// }
/// }
/// },
/// &quot;libraries&quot;: {
/// &quot;Newtonsoft.Json/8.0.3&quot;: {
/// &quot;sha512&quot;: &quot;KGsYQdS2zLH+H8x2cZaSI7e+YZ4SFIbyy1YJQYl6GYBWjf5o4H1A68nxyq+WTyVSOJQ4GqS/DiPE+UseUizgMg==&quot;,
/// &quot;type&quot;: &quot; [rest of string was truncated]&quot;;.
/// </summary>
internal static string LockFileWithWithSpecifiedPackageFolders {
get {
return ResourceManager.GetString("LockFileWithWithSpecifiedPackageFolders", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to {
/// &quot;locked&quot;: false,
/// &quot;version&quot;: 1,
/// &quot;targets&quot;: {
/// &quot;.NETCore,Version=v5.0&quot;: {
/// &quot;Microsoft.NETCore.Platforms/1.0.0&quot;: {},
/// &quot;Win2D/0.0.23-local&quot;: {
/// &quot;compile&quot;: {
/// &quot;lib/netcore50/Microsoft.Graphics.Canvas.winmd&quot;: {}
/// },
/// &quot;runtime&quot;: {
/// &quot;lib/netcore50/Microsoft.Graphics.Canvas.winmd&quot;: {}
/// }
/// }
/// },
/// &quot;.NETCore,Version=v5.0/win10-arm&quot;: {
/// &quot;Microsoft.NETCore.Platforms/1.0.0&quot;: {},
/// &quot;Win2D/0.0.23-local&quot;: {
/// &quot;compi [rest of string was truncated]&quot;;.
/// </summary>
internal static string nativeWinMD {
get {
return ResourceManager.GetString("nativeWinMD", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to {
/// &quot;locked&quot;: false,
/// &quot;version&quot;: -9996,
/// &quot;targets&quot;: {
/// &quot;.NETCore,Version=v5.0&quot;: {
/// &quot;Microsoft.ApplicationInsights/0.17.0&quot;: {
/// &quot;compile&quot;: {
/// &quot;lib/portable-win81+wpa81/Microsoft.ApplicationInsights.dll&quot;: {}
/// },
/// &quot;runtime&quot;: {
/// &quot;lib/portable-win81+wpa81/Microsoft.ApplicationInsights.dll&quot;: {}
/// }
/// },
/// &quot;Microsoft.ApplicationInsights.PersistenceChannel/0.17.0&quot;: {
/// &quot;dependencies&quot;: {
/// &quot;Microsoft.ApplicationInsights&quot;: &quot;0.1 [rest of string was truncated]&quot;;.
/// </summary>
internal static string Win10 {
get {
return ResourceManager.GetString("Win10", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to {
/// &quot;locked&quot;: false,
/// &quot;version&quot;: 1,
/// &quot;targets&quot;: {
/// &quot;.NETCore,Version=v5.0&quot;: {
/// &quot;Microsoft.ApplicationInsights/1.0.0&quot;: {
/// &quot;compile&quot;: {
/// &quot;lib/portable-win81+wpa81/Microsoft.ApplicationInsights.dll&quot;: {}
/// },
/// &quot;runtime&quot;: {
/// &quot;lib/portable-win81+wpa81/Microsoft.ApplicationInsights.dll&quot;: {}
/// }
/// },
/// &quot;Microsoft.ApplicationInsights.PersistenceChannel/1.0.0&quot;: {
/// &quot;dependencies&quot;: {
/// &quot;Microsoft.ApplicationInsights&quot;: &quot;[1.0.0, ) [rest of string was truncated]&quot;;.
/// </summary>
internal static string Win10_Edm {
get {
return ResourceManager.GetString("Win10_Edm", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to {
/// &quot;locked&quot;: false,
/// &quot;version&quot;: 1,
/// &quot;targets&quot;: {
/// &quot;.NETCore,Version=v5.0&quot;: {
/// &quot;Microsoft.CSharp/4.0.0-beta-23106&quot;: {
/// &quot;dependencies&quot;: {
/// &quot;System.Runtime&quot;: &quot;[4.0.20-beta-23106, )&quot;,
/// &quot;System.Runtime.InteropServices&quot;: &quot;[4.0.20-beta-23106, )&quot;,
/// &quot;System.Resources.ResourceManager&quot;: &quot;[4.0.0-beta-23106, )&quot;,
/// &quot;System.Dynamic.Runtime&quot;: &quot;[4.0.0-beta-23106, )&quot;,
/// &quot;System.Linq.Expressions&quot;: &quot;[4.0.0-beta-23106, )&quot;,
/// &quot;System.Linq&quot;: &quot;[4.0.0- [rest of string was truncated]&quot;;.
/// </summary>
internal static string Win10_xunit {
get {
return ResourceManager.GetString("Win10_xunit", resourceCulture);
}
}
}
}

145
external/nuget-buildtasks/src/Microsoft.NuGet.Build.Tasks.Tests/Json/Json.resx vendored Normal file
View File

@@ -0,0 +1,145 @@
<?xml version="1.0" encoding="utf-8"?>
<root>
<!--
Microsoft ResX Schema
Version 2.0
The primary goals of this format is to allow a simple XML format
that is mostly human readable. The generation and parsing of the
various data types are done through the TypeConverter classes
associated with the data types.
Example:
... ado.net/XML headers & schema ...
<resheader name="resmimetype">text/microsoft-resx</resheader>
<resheader name="version">2.0</resheader>
<resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
<resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
<data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
<data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
<data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
<value>[base64 mime encoded serialized .NET Framework object]</value>
</data>
<data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
<value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
<comment>This is a comment</comment>
</data>
There are any number of "resheader" rows that contain simple
name/value pairs.
Each data row contains a name, and value. The row also contains a
type or mimetype. Type corresponds to a .NET class that support
text/value conversion through the TypeConverter architecture.
Classes that don't support this are serialized and stored with the
mimetype set.
The mimetype is used for serialized objects, and tells the
ResXResourceReader how to depersist the object. This is currently not
extensible. For a given mimetype the value must be set accordingly:
Note - application/x-microsoft.net.object.binary.base64 is the format
that the ResXResourceWriter will generate, however the reader can
read any of the formats listed below.
mimetype: application/x-microsoft.net.object.binary.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.soap.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Soap.SoapFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.bytearray.base64
value : The object must be serialized into a byte array
: using a System.ComponentModel.TypeConverter
: and then encoded with base64 encoding.
-->
<xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
<xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
<xsd:element name="root" msdata:IsDataSet="true">
<xsd:complexType>
<xsd:choice maxOccurs="unbounded">
<xsd:element name="metadata">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" />
</xsd:sequence>
<xsd:attribute name="name" use="required" type="xsd:string" />
<xsd:attribute name="type" type="xsd:string" />
<xsd:attribute name="mimetype" type="xsd:string" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="assembly">
<xsd:complexType>
<xsd:attribute name="alias" type="xsd:string" />
<xsd:attribute name="name" type="xsd:string" />
</xsd:complexType>
</xsd:element>
<xsd:element name="data">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
<xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
<xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
<xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="resheader">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" />
</xsd:complexType>
</xsd:element>
</xsd:choice>
</xsd:complexType>
</xsd:element>
</xsd:schema>
<resheader name="resmimetype">
<value>text/microsoft-resx</value>
</resheader>
<resheader name="version">
<value>2.0</value>
</resheader>
<resheader name="reader">
<value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<resheader name="writer">
<value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<assembly alias="System.Windows.Forms" name="System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
<data name="analyzers" type="System.Resources.ResXFileRef, System.Windows.Forms">
<value>analyzers.json;System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089;utf-8</value>
</data>
<data name="Win10" type="System.Resources.ResXFileRef, System.Windows.Forms">
<value>Win10.json;System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089;utf-8</value>
</data>
<data name="FluentAssertions" type="System.Resources.ResXFileRef, System.Windows.Forms">
<value>FluentAssertions.lock.json;System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089;utf-8</value>
</data>
<data name="FluentAssertionsAndWin10" type="System.Resources.ResXFileRef, System.Windows.Forms">
<value>FluentAssertionsAndWin10.lock.json;System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089;utf-8</value>
</data>
<data name="Win10_Edm" type="System.Resources.ResXFileRef, System.Windows.Forms">
<value>Win10.Edm.json;System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089;utf-8</value>
</data>
<data name="Win10_xunit" type="System.Resources.ResXFileRef, System.Windows.Forms">
<value>Win10.xunit.json;System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089;utf-8</value>
</data>
<data name="nativeWinMD" type="System.Resources.ResXFileRef, System.Windows.Forms">
<value>nativeWinMD.json;System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089;utf-8</value>
</data>
<data name="LockFileWithWithSpecifiedPackageFolders" type="System.Resources.ResXFileRef, System.Windows.Forms">
<value>lockfilewithwithspecifiedpackagefolders.json;System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089;utf-8</value>
</data>
</root>

52
external/nuget-buildtasks/src/Microsoft.NuGet.Build.Tasks.Tests/Json/LockFileWithWithSpecifiedPackageFolders.json vendored Normal file
View File

@@ -0,0 +1,52 @@
{
"locked": false,
"version": 2,
"targets": {
".NETFramework,Version=v4.5": {
"Newtonsoft.Json/8.0.3": {
"type": "package",
"compile": {
"lib/net45/Newtonsoft.Json.dll": {}
},
"runtime": {
"lib/net45/Newtonsoft.Json.dll": {}
}
}
}
},
"libraries": {
"Newtonsoft.Json/8.0.3": {
"sha512": "KGsYQdS2zLH+H8x2cZaSI7e+YZ4SFIbyy1YJQYl6GYBWjf5o4H1A68nxyq+WTyVSOJQ4GqS/DiPE+UseUizgMg==",
"type": "package",
"path": "newtonsoft.json/8.0.3",
"files": [
"lib/net20/Newtonsoft.Json.dll",
"lib/net20/Newtonsoft.Json.xml",
"lib/net35/Newtonsoft.Json.dll",
"lib/net35/Newtonsoft.Json.xml",
"lib/net40/Newtonsoft.Json.dll",
"lib/net40/Newtonsoft.Json.xml",
"lib/net45/Newtonsoft.Json.dll",
"lib/net45/Newtonsoft.Json.xml",
"lib/portable-net40+sl5+wp80+win8+wpa81/Newtonsoft.Json.dll",
"lib/portable-net40+sl5+wp80+win8+wpa81/Newtonsoft.Json.xml",
"lib/portable-net45+wp80+win8+wpa81+dnxcore50/Newtonsoft.Json.dll",
"lib/portable-net45+wp80+win8+wpa81+dnxcore50/Newtonsoft.Json.xml",
"newtonsoft.json.8.0.3.nupkg.sha512",
"newtonsoft.json.nuspec",
"tools/install.ps1"
]
}
},
"projectFileDependencyGroups": {
"": [
"Newtonsoft.Json"
],
".NETFramework,Version=v4.5": []
},
"tools": {},
"projectFileToolGroups": {},
"packageFolders": {
"C:\\PackageFolder\\": {}
}
}

1
external/nuget-buildtasks/src/Microsoft.NuGet.Build.Tasks.Tests/Json/Win10.Edm.json.REMOVED.git-id vendored Normal file
View File

@@ -0,0 +1 @@
6dff4ab50a76d4b4404413a9392780ed747901fb

1
external/nuget-buildtasks/src/Microsoft.NuGet.Build.Tasks.Tests/Json/Win10.json.REMOVED.git-id vendored Normal file
View File

@@ -0,0 +1 @@
0d0c8c494652281c3e75874819d07547acc4d96c

1
external/nuget-buildtasks/src/Microsoft.NuGet.Build.Tasks.Tests/Json/Win10.xunit.json.REMOVED.git-id vendored Normal file
View File

@@ -0,0 +1 @@
25473e1ead70988311aa6c79b6ce2b98d2c721c5

201
external/nuget-buildtasks/src/Microsoft.NuGet.Build.Tasks.Tests/Json/analyzers.json vendored Normal file
View File

@@ -0,0 +1,201 @@
{
"locked": false,
"version": -9996,
"targets": {
".NETCore,Version=v5.0": {
"Microsoft.AnalyzerPowerPack/1.0.0": {
"frameworkAssemblies": [
"System"
]
},
"Microsoft.CodeAnalysis.Analyzers/1.0.0": {
"frameworkAssemblies": [
"System"
]
},
"System.Runtime.Analyzers/1.0.0": {
"frameworkAssemblies": [
"System"
]
},
"System.Runtime.InteropServices.Analyzers/1.0.0": {
"frameworkAssemblies": [
"System"
]
}
},
".NETCore,Version=v5.0/win10-x64": {
"Microsoft.AnalyzerPowerPack/1.0.0": {
"frameworkAssemblies": [
"System"
]
},
"Microsoft.CodeAnalysis.Analyzers/1.0.0": {
"frameworkAssemblies": [
"System"
]
},
"System.Runtime.Analyzers/1.0.0": {
"frameworkAssemblies": [
"System"
]
},
"System.Runtime.InteropServices.Analyzers/1.0.0": {
"frameworkAssemblies": [
"System"
]
}
},
".NETCore,Version=v5.0/win10-x64-aot": {
"Microsoft.AnalyzerPowerPack/1.0.0": {
"frameworkAssemblies": [
"System"
]
},
"Microsoft.CodeAnalysis.Analyzers/1.0.0": {
"frameworkAssemblies": [
"System"
]
},
"System.Runtime.Analyzers/1.0.0": {
"frameworkAssemblies": [
"System"
]
},
"System.Runtime.InteropServices.Analyzers/1.0.0": {
"frameworkAssemblies": [
"System"
]
}
},
".NETCore,Version=v5.0/win10-x86": {
"Microsoft.AnalyzerPowerPack/1.0.0": {
"frameworkAssemblies": [
"System"
]
},
"Microsoft.CodeAnalysis.Analyzers/1.0.0": {
"frameworkAssemblies": [
"System"
]
},
"System.Runtime.Analyzers/1.0.0": {
"frameworkAssemblies": [
"System"
]
},
"System.Runtime.InteropServices.Analyzers/1.0.0": {
"frameworkAssemblies": [
"System"
]
}
},
".NETCore,Version=v5.0/win10-x86-aot": {
"Microsoft.AnalyzerPowerPack/1.0.0": {
"frameworkAssemblies": [
"System"
]
},
"Microsoft.CodeAnalysis.Analyzers/1.0.0": {
"frameworkAssemblies": [
"System"
]
},
"System.Runtime.Analyzers/1.0.0": {
"frameworkAssemblies": [
"System"
]
},
"System.Runtime.InteropServices.Analyzers/1.0.0": {
"frameworkAssemblies": [
"System"
]
}
}
},
"libraries": {
"Microsoft.AnalyzerPowerPack/1.0.0": {
"sha512": "lpBEoZTUdDgs41plPw9X9pmbLCsdqchE0bY0+Nvxo07WxXR76O26MP6Buo46tkCiY1yX6vYEjN7PKX1sAnZ+1A==",
"files": [
"_rels/.rels",
"Microsoft.AnalyzerPowerPack.nuspec",
"analyzers/dotnet/cs/Microsoft.AnalyzerPowerPack.Common.dll",
"analyzers/dotnet/cs/Microsoft.AnalyzerPowerPack.CSharp.dll",
"analyzers/dotnet/vb/Microsoft.AnalyzerPowerPack.Common.dll",
"analyzers/dotnet/vb/Microsoft.AnalyzerPowerPack.VisualBasic.dll",
"build/AnalyzerPowerPack.props",
"build/AnalyzerPowerPack.Common.props",
"build/AnalyzerPowerPack.CSharp.props",
"build/AnalyzerPowerPack.VisualBasic.props",
"tools/install.ps1",
"tools/uninstall.ps1",
"ThirdPartyNotices.rtf",
"package/services/metadata/core-properties/5573a86c260446399d8bf7377b1ee14c.psmdcp",
"[Content_Types].xml"
]
},
"Microsoft.CodeAnalysis.Analyzers/1.0.0": {
"sha512": "Wr4wqjbnr4IWe1q11PQ2iUdvrBiasGt2XSiwHFdQJdl2TOfG5cKhGuQxr5s/wURRTCgNjIejlbRlGo7U+iB2zA==",
"files": [
"_rels/.rels",
"Microsoft.CodeAnalysis.Analyzers.nuspec",
"analyzers/dotnet/cs/Microsoft.CodeAnalysis.Analyzers.dll",
"analyzers/dotnet/cs/Microsoft.CodeAnalysis.CSharp.Analyzers.dll",
"analyzers/dotnet/vb/Microsoft.CodeAnalysis.Analyzers.dll",
"analyzers/dotnet/vb/Microsoft.CodeAnalysis.VisualBasic.Analyzers.dll",
"tools/install.ps1",
"tools/uninstall.ps1",
"ThirdPartyNotices.rtf",
"package/services/metadata/core-properties/13e529baccc44c33b03965c3db1bd9cc.psmdcp",
"[Content_Types].xml"
]
},
"System.Runtime.Analyzers/1.0.0": {
"sha512": "MnO/DOJigl4DUnaF3gJWmX6Xr2z7ejJRkdvllH7ljRSqcXj5091HVzyEiX/98HFYTbi1IRml+mu4kG4hygrP+A==",
"files": [
"_rels/.rels",
"System.Runtime.Analyzers.nuspec",
"analyzers/dotnet/cs/System.Runtime.Analyzers.dll",
"analyzers/dotnet/cs/System.Runtime.CSharp.Analyzers.dll",
"analyzers/dotnet/vb/System.Runtime.Analyzers.dll",
"analyzers/dotnet/vb/System.Runtime.VisualBasic.Analyzers.dll",
"build/System.Runtime.Analyzers.props",
"build/System.Runtime.Analyzers.Common.props",
"build/System.Runtime.CSharp.Analyzers.props",
"build/System.Runtime.VisualBasic.Analyzers.props",
"tools/install.ps1",
"tools/uninstall.ps1",
"ThirdPartyNotices.rtf",
"package/services/metadata/core-properties/26f8afd54b99434388056543bd1d55d0.psmdcp",
"[Content_Types].xml"
]
},
"System.Runtime.InteropServices.Analyzers/1.0.0": {
"sha512": "DUHZ0yl7qnI3i5e/wVODDO2aIezTnJ4EvdKZudJn9yNToN9gdMNNTZgjl3rOLcxHIVI8OWQW0WuoqUL7x5sKKg==",
"files": [
"_rels/.rels",
"System.Runtime.InteropServices.Analyzers.nuspec",
"analyzers/dotnet/cs/System.Runtime.InteropServices.Analyzers.dll",
"analyzers/dotnet/cs/System.Runtime.InteropServices.CSharp.Analyzers.dll",
"analyzers/dotnet/vb/System.Runtime.InteropServices.Analyzers.dll",
"analyzers/dotnet/vb/System.Runtime.InteropServices.VisualBasic.Analyzers.dll",
"build/System.Runtime.InteropServices.Analyzers.props",
"build/System.Runtime.InteropServices.Analyzers.Common.props",
"tools/install.ps1",
"tools/uninstall.ps1",
"ThirdPartyNotices.rtf",
"package/services/metadata/core-properties/70736d925f2649508a5ffd07c1fc71f5.psmdcp",
"[Content_Types].xml"
]
}
},
"projectFileDependencyGroups": {
"": [
"Microsoft.AnalyzerPowerPack [1.0.0, )",
"Microsoft.CodeAnalysis.Analyzers [1.0.0, )",
"System.Runtime.Analyzers [1.0.0, )",
"System.Runtime.InteropServices.Analyzers [1.0.0, )"
],
".NETCore,Version=v5.0": []
}
}

131
external/nuget-buildtasks/src/Microsoft.NuGet.Build.Tasks.Tests/Json/nativeWinMD.json vendored Normal file
View File

@@ -0,0 +1,131 @@
{
"locked": false,
"version": 1,
"targets": {
".NETCore,Version=v5.0": {
"Microsoft.NETCore.Platforms/1.0.0": {},
"Win2D/0.0.23-local": {
"compile": {
"lib/netcore50/Microsoft.Graphics.Canvas.winmd": {}
},
"runtime": {
"lib/netcore50/Microsoft.Graphics.Canvas.winmd": {}
}
}
},
".NETCore,Version=v5.0/win10-arm": {
"Microsoft.NETCore.Platforms/1.0.0": {},
"Win2D/0.0.23-local": {
"compile": {
"lib/netcore50/Microsoft.Graphics.Canvas.winmd": {}
},
"runtime": {
"lib/netcore50/Microsoft.Graphics.Canvas.winmd": {}
}
}
},
".NETCore,Version=v5.0/win10-arm-aot": {
"Microsoft.NETCore.Platforms/1.0.0": {},
"Win2D/0.0.23-local": {
"compile": {
"lib/netcore50/Microsoft.Graphics.Canvas.winmd": {}
},
"runtime": {
"lib/netcore50/Microsoft.Graphics.Canvas.winmd": {}
}
}
},
".NETCore,Version=v5.0/win10-x86": {
"Microsoft.NETCore.Platforms/1.0.0": {},
"Win2D/0.0.23-local": {
"compile": {
"lib/netcore50/Microsoft.Graphics.Canvas.winmd": {}
},
"runtime": {
"lib/netcore50/Microsoft.Graphics.Canvas.winmd": {}
},
"native": {
"runtimes/win10-x86/native/Microsoft.Graphics.Canvas.dll": {}
}
}
},
".NETCore,Version=v5.0/win10-x86-aot": {
"Microsoft.NETCore.Platforms/1.0.0": {},
"Win2D/0.0.23-local": {
"compile": {
"lib/netcore50/Microsoft.Graphics.Canvas.winmd": {}
},
"runtime": {
"lib/netcore50/Microsoft.Graphics.Canvas.winmd": {}
},
"native": {
"runtimes/win10-x86/native/Microsoft.Graphics.Canvas.dll": {}
}
}
},
".NETCore,Version=v5.0/win10-x64": {
"Microsoft.NETCore.Platforms/1.0.0": {},
"Win2D/0.0.23-local": {
"compile": {
"lib/netcore50/Microsoft.Graphics.Canvas.winmd": {}
},
"runtime": {
"lib/netcore50/Microsoft.Graphics.Canvas.winmd": {}
},
"native": {
"runtimes/win10-x64/native/Microsoft.Graphics.Canvas.dll": {}
}
}
},
".NETCore,Version=v5.0/win10-x64-aot": {
"Microsoft.NETCore.Platforms/1.0.0": {},
"Win2D/0.0.23-local": {
"compile": {
"lib/netcore50/Microsoft.Graphics.Canvas.winmd": {}
},
"runtime": {
"lib/netcore50/Microsoft.Graphics.Canvas.winmd": {}
},
"native": {
"runtimes/win10-x64/native/Microsoft.Graphics.Canvas.dll": {}
}
}
}
},
"libraries": {
"Microsoft.NETCore.Platforms/1.0.0": {
"sha512": "rzZy74xWhF7qnkM20rGRN6ZGfCi1uFni6t+5BApjYyLHHI6cwXGikzBhAZ54Vb1qbqETVt2NrTwTd/qDDvaK0A==",
"type": "Package",
"files": [
"_rels/.rels",
"Microsoft.NETCore.Platforms.nuspec",
"runtime.json",
"package/services/metadata/core-properties/cb27f3417ae44d86a32d013b3c57f71a.psmdcp",
"[Content_Types].xml"
]
},
"Win2D/0.0.23-local": {
"sha512": "+pedaGbgsnwa9Q2HwCTYOuXTckbXAO8yWXFrl+5mgB5wws4rez0UDSrYwSrsdaBqnXF7XtZVFjYZ2N2RG4fs8g==",
"type": "Package",
"files": [
"_rels/.rels",
"Win2D.nuspec",
"lib/netcore50/Microsoft.Graphics.Canvas.winmd",
"lib/netcore50/Microsoft.Graphics.Canvas.xml",
"runtimes/win10-x86/native/Microsoft.Graphics.Canvas.dll",
"runtimes/win10-x64/native/Microsoft.Graphics.Canvas.dll",
"runtimes/win10-ARM/native/Microsoft.Graphics.Canvas.dll",
"Win2D.githash.txt",
"package/services/metadata/core-properties/8250b4d691e54c2391ee3f5d91acd796.psmdcp",
"[Content_Types].xml"
]
}
},
"projectFileDependencyGroups": {
"": [
"Microsoft.NETCore.Platforms >= 1.0.0",
"Win2D >= 0.0.23-local"
],
".NETCore,Version=v5.0": []
}
}

112
external/nuget-buildtasks/src/Microsoft.NuGet.Build.Tasks.Tests/Microsoft.NuGet.Build.Tasks.Tests.csproj vendored Normal file
View File

@@ -0,0 +1,112 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProjectGuid>{61443D47-85B6-4519-96C1-2704BDF604BF}</ProjectGuid>
<OutputType>Library</OutputType>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>Microsoft.NuGet.Build.Tasks.Tests</RootNamespace>
<AssemblyName>Microsoft.NuGet.Build.Tasks.Tests</AssemblyName>
<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
<TargetFrameworkProfile />
<SignAssembly>true</SignAssembly>
<PublicSign>true</PublicSign>
<AssemblyOriginatorKeyFile>..\..\build\PublicKey.snk</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<OutputPath>bin\Debug\</OutputPath>
<DefineConstants>DEBUG;TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
<OutputPath>bin\Release\</OutputPath>
<DefineConstants>TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<ItemGroup>
<Reference Include="Microsoft.Build.Framework, Version=14.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
<Reference Include="Microsoft.Build.Utilities.Core, Version=14.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
<Reference Include="System" />
<Reference Include="System.Core" />
<Reference Include="Microsoft.CSharp" />
</ItemGroup>
<ItemGroup>
<Compile Include="AnalyzerResolutionTests.cs" />
<Compile Include="AssertHelpers.cs" />
<Compile Include="Helpers\DisposableDirectory.cs" />
<Compile Include="Helpers\DisposableFile.cs" />
<Compile Include="Helpers\MockBuildEngine.cs" />
<Compile Include="Helpers\TempDirectory.cs" />
<Compile Include="Helpers\TempFile.cs" />
<Compile Include="Helpers\TempRoot.cs" />
<Compile Include="Json\Json.Designer.cs">
<AutoGen>True</AutoGen>
<DesignTime>True</DesignTime>
<DependentUpon>Json.resx</DependentUpon>
</Compile>
<Compile Include="NuGetTestHelpers.cs" />
<Compile Include="PackageFolderTests.cs" />
<Compile Include="PreprocessorTests.cs" />
<Compile Include="ProjectReferences\ProjectReferenceTests.cs" />
<Compile Include="ProjectReferences\Resources.Designer.cs">
<AutoGen>True</AutoGen>
<DesignTime>True</DesignTime>
<DependentUpon>Resources.resx</DependentUpon>
</Compile>
<Compile Include="Properties\AssemblyInfo.cs" />
<Compile Include="ReferenceResolutionTests.cs" />
<Compile Include="ResolvePackagesResult.cs" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\Microsoft.NuGet.Build.Tasks\Microsoft.NuGet.Build.Tasks.csproj">
<Project>{55dc2bbf-42ae-4be8-a6e0-351eef51c0fc}</Project>
<Name>Microsoft.NuGet.Build.Tasks</Name>
</ProjectReference>
</ItemGroup>
<ItemGroup>
<None Include="app.config" />
<None Include="Json\analyzers.json" />
<None Include="Json\FluentAssertions.lock.json" />
<None Include="Json\FluentAssertionsAndWin10.lock.json" />
<None Include="Json\nativeWinMD.json" />
<None Include="Json\LockFileWithWithSpecifiedPackageFolders.json" />
<None Include="Json\Win10.Edm.json" />
<None Include="Json\Win10.json" />
<None Include="Json\Win10.xunit.json" />
<None Include="project.json" />
<None Include="ProjectReferences\LockFileMissingMSBuildProjectThatProvidesAssets.json" />
<None Include="ProjectReferences\LockFileWithXProjReference.json" />
<None Include="ProjectReferences\LockFileWithCSProjReference.json" />
</ItemGroup>
<ItemGroup>
<EmbeddedResource Include="Json\Json.resx">
<Generator>ResXFileCodeGenerator</Generator>
<LastGenOutput>Json.Designer.cs</LastGenOutput>
</EmbeddedResource>
<EmbeddedResource Include="ProjectReferences\Resources.resx">
<Generator>ResXFileCodeGenerator</Generator>
<LastGenOutput>Resources.Designer.cs</LastGenOutput>
</EmbeddedResource>
</ItemGroup>
<ItemGroup>
<Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
</ItemGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="AfterBuild">
</Target>
-->
</Project>

125
external/nuget-buildtasks/src/Microsoft.NuGet.Build.Tasks.Tests/NuGetTestHelpers.cs vendored Normal file
View File

@@ -0,0 +1,125 @@
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using Microsoft.Build.Framework;
using Microsoft.Build.Utilities;
using Microsoft.NuGet.Build.Tasks;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using Xunit;
using Microsoft.NuGet.Build.Tasks.Tests.Helpers;
namespace Microsoft.NuGet.Build.Tasks.Tests
{
internal static class NuGetTestHelpers
{
public static ResolvePackagesResult ResolvePackagesWithJsonFileContents(
string projectLockJsonFileContents,
string targetMoniker,
string runtimeIdentifier,
string projectLanguage = null,
bool allowFallbackOnTargetSelection = false,
TryGetRuntimeVersion tryGetRuntimeVersion = null,
bool includeFrameworkReferences = true,
string projectJsonFileContents = null,
IEnumerable<ITaskItem> projectReferencesCreatingPackages = null,
bool createTemporaryFolderForPackages = true)
{
var rootDirectory = new TempRoot();
using (rootDirectory)
{
var projectDirectory = rootDirectory.CreateDirectory();
var projectLockJsonFile = projectDirectory.CreateFile("project.lock.json");
projectLockJsonFile.WriteAllText(projectLockJsonFileContents);
if (projectJsonFileContents != null)
{
var projectJsonFile = projectDirectory.CreateFile("project.json");
projectJsonFile.WriteAllText(projectJsonFileContents);
}
var filesInPackages = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
DisposableDirectory packagesDirectory = null;
if (createTemporaryFolderForPackages)
{
packagesDirectory = rootDirectory.CreateDirectory();
foreach (var fileInPackage in GetFakeFileNamesFromPackages(projectLockJsonFileContents, packagesDirectory.Path))
{
filesInPackages.Add(fileInPackage);
}
}
else
{
// We will assume there is a location in the lock file we're using
var lockFile = JObject.Parse(projectLockJsonFileContents);
var firstLocation = ((JObject)lockFile["packageFolders"]).Properties().First().Name;
foreach (var fileInPackage in GetFakeFileNamesFromPackages(projectLockJsonFileContents, firstLocation))
{
filesInPackages.Add(fileInPackage);
}
}
// Don't require the packages be restored on the machine
ResolveNuGetPackageAssets task = null;
FileExists fileExists = path => filesInPackages.Contains(path) || File.Exists(path);
task = new ResolveNuGetPackageAssets(fileExists, tryGetRuntimeVersion);
var sw = new StringWriter();
task.BuildEngine = new MockBuildEngine(sw);
task.AllowFallbackOnTargetSelection = allowFallbackOnTargetSelection;
task.IncludeFrameworkReferences = includeFrameworkReferences;
task.NuGetPackagesDirectory = packagesDirectory?.Path;
task.RuntimeIdentifier = runtimeIdentifier;
task.ProjectReferencesCreatingPackages = (projectReferencesCreatingPackages ?? Enumerable.Empty<ITaskItem>()).ToArray();
task.ProjectLockFile = projectLockJsonFile.Path;
task.ProjectLanguage = projectLanguage;
task.TargetMonikers = new ITaskItem[] { new TaskItem(targetMoniker) };
// When we create the task for unit-testing purposes, the constructor sets an internal bit which should always
// cause task.Execute to throw.
Assert.True(task.Execute());
var analyzers = task.ResolvedAnalyzers;
var copyLocalItems = task.ResolvedCopyLocalItems;
var references = task.ResolvedReferences;
var referencedPackages = task.ReferencedPackages;
return new ResolvePackagesResult(analyzers, copyLocalItems, references, referencedPackages, rootDirectory.Root);
}
}
/// <summary>
/// Given the contents of a project.lock.json, figures out all the "fake" full paths that are in those packages as if
/// those packages are restored on disk.
/// </summary>
private static IEnumerable<string> GetFakeFileNamesFromPackages(string projectJsonContents, string packagesDirectory)
{
var lockFile = JObject.Parse(projectJsonContents);
foreach (JProperty library in lockFile["libraries"])
{
var files = library.Value["files"] as JArray;
if (files != null)
{
foreach (string file in files)
{
yield return Path.Combine(packagesDirectory, library.Name, file).Replace('/', '\\');
}
}
// Some earlier versions of NuGet didn't include the hash file in the file list, so fake that
// in here.
yield return Path.Combine(packagesDirectory, library.Name.Replace('/', '\\'), library.Name.Replace('/', '.') + ".nupkg.sha512");
}
}
}
}

Some files were not shown because too many files have changed in this diff Show More