Add Binding redirects tests

NuGet.Config

@@ -4,6 +4,7 @@
     <!--To inherit the global NuGet package sources remove the <clear/> line below -->
     <clear />
     <add key="cli-deps" value="https://dotnet.myget.org/F/cli-deps/api/v3/index.json" />
+    <add key="coreclr-xunit" value="https://www.myget.org/F/coreclr-xunit/api/v3/index.json" />
     <add key="api.nuget.org" value="https://api.nuget.org/v3/index.json" />
   </packageSources>
 </configuration>

TestAssets/DesktopTestProjects/BindingRedirectSample/AppWithRedirectsAndConfig/app.config

@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="utf-8"?>
+<configuration>  
+  <runtime>
+    <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
+      <dependentAssembly>
+        <assemblyIdentity name="Newtonsoft.Json" publicKeyToken="30ad4fe6b2a6aeed" culture="neutral" />
+        <bindingRedirect oldVersion="3.5.0.0" newVersion="8.0.0.0" />
+        <bindingRedirect oldVersion="4.5.0.0" newVersion="8.0.0.0" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="Some.Foo.Assembly" publicKeyToken="814f48568d36eed5" culture="neutral" />
+        <bindingRedirect oldVersion="3.0.0.0" newVersion="5.5.5.1" />
+      </dependentAssembly>
+    </assemblyBinding>
+  </runtime>
+  <appSettings>
+    <add key="Setting1" value="Hello"/>
+    <add key="Setting2" value="World"/>
+  </appSettings>
+</configuration>

TestAssets/DesktopTestProjects/BindingRedirectSample/AppWithRedirectsAndConfig/project.json

@@ -0,0 +1,18 @@
+{
+  "version": "1.0.0-*",
+  "compilationOptions": {
+    "emitEntryPoint": true
+  },
+  "compile": [
+    "../src/*.cs"
+  ],
+  "dependencies": {
+    "Newtonsoft.Json": "8.0.3",    
+    "Microsoft.AspNet.Mvc": "3.0.50813.1",
+    "Unity.Mvc": "3.0.1304",
+    "dotnet-desktop-binding-redirects": "1.0.0-*"
+  },
+  "frameworks": {
+    "net451": {}
+  }
+}

TestAssets/DesktopTestProjects/BindingRedirectSample/AppWithRedirectsNoConfig/project.json

@@ -0,0 +1,18 @@
+{
+  "version": "1.0.0-*",
+  "compilationOptions": {
+    "emitEntryPoint": true
+  },
+  "compile": [
+    "../src/*.cs"
+  ],
+  "dependencies": {
+    "Newtonsoft.Json": "8.0.3",    
+    "Microsoft.AspNet.Mvc": "3.0.50813.1",
+    "Unity.Mvc": "3.0.1304",
+    "dotnet-desktop-binding-redirects": "1.0.0-*"
+  },
+  "frameworks": {
+    "net451": {}
+  }
+}

TestAssets/DesktopTestProjects/BindingRedirectSample/src/Program.cs

@@ -0,0 +1,49 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Reflection;
+
+namespace BindingRedirects
+{
+    public class Program
+    {
+        private const string ExpectedNewtonSoftVersion = "8.0.0.0";
+
+        public static int Main(string[] args)
+        {
+            return VerifyJsonLoad();
+        }
+
+        private static int VerifyJsonLoad()
+        {
+            WriteLine("=======Verifying Redirected Newtonsoft.Json assembly load=======");
+
+            int result = 0;
+
+            try
+            {
+                var jsonAsm = typeof(Newtonsoft.Json.JsonConvert).Assembly;
+                var version = jsonAsm.GetName().Version.ToString();
+                if (version != ExpectedNewtonSoftVersion)
+                {
+                    WriteLine($"Failure - Newtonsoft.Json: ExpectedVersion - {ExpectedNewtonSoftVersion}, ActualVersion - {version}");
+                    result = -1;
+                }
+            }
+            catch (Exception ex)
+            {
+                WriteLine($"Failed to load type 'Newtonsoft.Json.JsonConvert'");
+                throw ex;
+            }
+
+            return result;
+        }
+
+        private static void WriteLine(string str)
+        {
+            var currentAssembly = Assembly.GetExecutingAssembly().GetName().Name;
+            Console.WriteLine($"{currentAssembly}: {str}");
+        }
+    }
+}

TestAssets/TestPackages/dotnet-desktop-binding-redirects/Program.cs

@@ -0,0 +1,49 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Reflection;
+
+namespace BindingRedirects
+{
+    public class Program
+    {
+        private const string ExpectedNewtonSoftVersion = "8.0.0.0";
+
+        public static int Main(string[] args)
+        {
+            return VerifyJsonLoad();
+        }
+
+        private static int VerifyJsonLoad()
+        {
+            WriteLine("=======Verifying Redirected Newtonsoft.Json assembly load=======");
+
+            int result = 0;
+
+            try
+            {
+                var jsonAsm = typeof(Newtonsoft.Json.JsonConvert).Assembly;
+                var version = jsonAsm.GetName().Version.ToString();
+                if (version != ExpectedNewtonSoftVersion)
+                {
+                    WriteLine($"Failure - Newtonsoft.Json: ExpectedVersion - {ExpectedNewtonSoftVersion}, ActualVersion - {version}");
+                    result = -1;
+                }
+            }
+            catch (Exception ex)
+            {
+                WriteLine($"Failed to load type 'Newtonsoft.Json.JsonConvert'");
+                throw ex;
+            }
+
+            return result;
+        }
+
+        private static void WriteLine(string str)
+        {
+            var currentAssembly = Assembly.GetExecutingAssembly().GetName().Name;
+            Console.WriteLine($"{currentAssembly}: {str}");
+        }
+    }
+}

TestAssets/TestPackages/dotnet-desktop-binding-redirects/dotnet-desktop-binding-redirects.xproj

@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <VisualStudioVersion Condition="'$(VisualStudioVersion)' == ''">14.0</VisualStudioVersion>
+    <VSToolsPath Condition="'$(VSToolsPath)' == ''">$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)</VSToolsPath>
+  </PropertyGroup>
+  <Import Project="$(VSToolsPath)\DNX\Microsoft.DNX.Props" Condition="'$(VSToolsPath)' != ''" />
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>281f1cdb-8627-47c7-9bb1-cde8d30d93d1</ProjectGuid>
+    <RootNamespace>dotnet-desktop-binding-redirects</RootNamespace>
+    <BaseIntermediateOutputPath Condition="'$(BaseIntermediateOutputPath)'=='' ">..\artifacts\obj\$(MSBuildProjectName)</BaseIntermediateOutputPath>
+    <OutputPath Condition="'$(OutputPath)'=='' ">..\artifacts\bin\$(MSBuildProjectName)\</OutputPath>
+  </PropertyGroup>
+
+  <PropertyGroup>
+    <SchemaVersion>2.0</SchemaVersion>
+  </PropertyGroup>
+  <Import Project="$(VSToolsPath)\DNX\Microsoft.DNX.targets" Condition="'$(VSToolsPath)' != ''" />
+</Project>

TestAssets/TestPackages/dotnet-desktop-binding-redirects/project.json

@@ -0,0 +1,18 @@
+{
+  "version": "1.0.0-*",
+  "compilationOptions": {
+    "emitEntryPoint": true
+  },
+  "dependencies": {
+    "Newtonsoft.Json": "5.0.0",
+    "NuGet.Protocol.Core.v3": "3.3.0"
+  },
+  "frameworks": {
+    "net451": {
+      "frameworkAssemblies": {
+        "System.Configuration": ""
+      }
+    }
+  }
+}
+

scripts/dotnet-cli-build/TestPackageProjects.cs

@@ -77,6 +77,16 @@ namespace Microsoft.DotNet.Cli.Build
                 Frameworks = new [] { "net451", "netcoreapp1.0" }
             },
             new TestPackageProject()
+            {
+                Name = "dotnet-desktop-binding-redirects",
+                IsTool = true,
+                Path = "TestAssets/TestPackages/dotnet-desktop-binding-redirects",
+                IsApplicable = CurrentPlatform.IsWindows,
+                VersionSuffix = s_testPackageBuildVersionSuffix,
+                Clean = true,
+                Frameworks = new [] { "net451" }
+            },
+            new TestPackageProject()
             {
                 Name = "dotnet-hello",
                 IsTool = true,

scripts/dotnet-cli-build/TestTargets.cs

@@ -39,6 +39,11 @@ namespace Microsoft.DotNet.Cli.Build
             "Microsoft.Extensions.DependencyModel.Tests"
         };
 
+        public static readonly string[] WindowsTestProjects = new[]
+        {
+            "binding-redirects.Tests"
+        };
+
         public static readonly dynamic[] ConditionalTestAssets = new[]
         {
             new { Path = "AppWithDirectDependencyDesktopAndPortable", Skip = new Func<bool>(() => !CurrentPlatform.IsWindows) }
@@ -276,7 +281,7 @@ namespace Microsoft.DotNet.Cli.Build
 
             var configuration = c.BuildContext.Get<string>("Configuration");
 
-            foreach (var testProject in TestProjects)
+            foreach (var testProject in GetTestProjects())
             {
                 c.Info($"Building tests: {testProject}");
                 dotnet.Build("--configuration", configuration)
@@ -307,7 +312,7 @@ namespace Microsoft.DotNet.Cli.Build
 
             // Run the tests and set the VS vars in the environment when running them
             var failingTests = new List<string>();
-            foreach (var project in TestProjects)
+            foreach (var project in GetTestProjects())
             {
                 c.Info($"Running tests in: {project}");
                 var result = dotnet.Test("--configuration", configuration, "-xml", $"{project}-testResults.xml", "-notrait", "category=failing")
@@ -354,6 +359,19 @@ namespace Microsoft.DotNet.Cli.Build
             return c.Success();
         }
 
+        private static IEnumerable<string> GetTestProjects()
+        {
+            List<string> testProjects = new List<string>();
+            testProjects.AddRange(testProjects);
+
+            if (CurrentPlatform.IsWindows)
+            {
+                testProjects.AddRange(WindowsTestProjects);
+            }
+
+            return testProjects;
+        }
+
         private static BuildTargetResult BuildTestAssets(BuildTargetContext c, string testAssetsRoot, DotNetCli dotnet, string framework)
         {
             CleanBinObj(c, testAssetsRoot);

src/Microsoft.DotNet.Cli.Utils/Constants.cs

@@ -12,6 +12,7 @@ namespace Microsoft.DotNet.Cli.Utils
 
         public static readonly string ProjectFileName = "project.json";
         public static readonly string ExeSuffix = CurrentPlatform == Platform.Windows ? ".exe" : string.Empty;
+        public static readonly string ConfigSuffix = ".config";
 
         // Priority order of runnable suffixes to look for and run
         public static readonly string[] RunnableSuffixes = CurrentPlatform == Platform.Windows

src/Microsoft.DotNet.Compiler.Common/BindingRedirectGenerator.cs

@@ -52,15 +52,7 @@ namespace Microsoft.DotNet.Cli.Compiler.Common
 
         internal static void GenerateBindingRedirects(string configFile, AssemblyRedirect[] bindingRedirects)
         {
-            XDocument configRoot = null;
+            XDocument configRoot = File.Exists(configFile) ? XDocument.Load(configFile) : new XDocument();
-
-            if (File.Exists(configFile))
-            {
-                configRoot = XDocument.Load(configFile);
-            }
-
-            configRoot = configRoot ?? new XDocument();
-
             var configuration = GetOrAddElement(configRoot, ConfigurationElementName);
             var runtime = GetOrAddElement(configuration, RuntimeElementName);
             var assemblyBindings = GetOrAddElement(runtime, AssemblyBindingElementName);
@@ -93,11 +85,16 @@ namespace Microsoft.DotNet.Cli.Compiler.Common
                 assemblyBindings.Add(dependencyElement);
             }
 
+            bool redirectExists = dependencyElement.Elements(BindingRedirectElementName).Any(element => IsSameRedirect(redirect, element));
+
+            if (!redirectExists)
+            {
                 dependencyElement.Add(new XElement(BindingRedirectElementName,
                         new XAttribute(OldVersionAttributeName, redirect.From.Version),
                         new XAttribute(NewVersionAttributeName, redirect.To.Version)
                         ));
             }
+        }
 
         private static bool IsSameAssembly(AssemblyRedirect redirect, XElement dependentAssemblyElement)
         {
@@ -111,6 +108,16 @@ namespace Microsoft.DotNet.Cli.Compiler.Common
                    (string)identity.Attribute(CultureAttributeName) == redirect.From.Culture;
         }
 
+        private static bool IsSameRedirect(AssemblyRedirect redirect, XElement bindingRedirectElement)
+        {
+            if (bindingRedirectElement == null)
+            {
+                return false;
+            }
+            return (string)bindingRedirectElement.Attribute(OldVersionAttributeName) == redirect.From.Version.ToString() &&
+                   (string)bindingRedirectElement.Attribute(NewVersionAttributeName) == redirect.To.Version.ToString();
+        }
+
         private static XElement GetOrAddElement(XContainer parent, XName elementName)
         {
             XElement element;

src/Microsoft.DotNet.Compiler.Common/Executable.cs

@@ -254,7 +254,7 @@ namespace Microsoft.DotNet.Cli.Compiler.Common
         public void GenerateBindingRedirects(LibraryExporter exporter)
         {
             var outputName = _outputPaths.RuntimeFiles.Assembly;
-            var configFile = outputName + ".config";
+            var configFile = outputName + Constants.ConfigSuffix;
 
             var existingConfig = new DirectoryInfo(_context.ProjectDirectory)
                 .EnumerateFiles()
@@ -271,12 +271,12 @@ namespace Microsoft.DotNet.Cli.Compiler.Common
             foreach (var export in exporter.GetDependencies())
             {
                 var dependencyExecutables = export.RuntimeAssemblyGroups.GetDefaultAssets()
-                                                .Where(asset => asset.FileName.ToLower().EndsWith(".exe"))
+                                                .Where(asset => asset.FileName.ToLower().EndsWith(FileNameSuffixes.DotNet.Exe))
                                                 .Select(asset => Path.Combine(_runtimeOutputPath, asset.FileName));
 
                 foreach (var executable in dependencyExecutables)
                 {
-                    configFile = executable + ".config";
+                    configFile = executable + Constants.ConfigSuffix;
                     configFiles.Add(configFile);
                 }
             }

src/Microsoft.DotNet.TestFramework/Microsoft.DotNet.TestFramework.TestAssetsManager.cs

@@ -93,7 +93,12 @@ namespace Microsoft.DotNet.TestFramework
                 throw new Exception($"Cannot find '{testProjectName}' at '{AssetsRoot}'");
             }
 
-            string testDestination = Path.Combine(AppContext.BaseDirectory, callingMethod + identifier, testProjectName);
+#if NET451
+            string baseDirectory = AppDomain.CurrentDomain.BaseDirectory;
+#else
+            string baseDirectory = AppContext.BaseDirectory;
+#endif
+            string testDestination = Path.Combine(baseDirectory, callingMethod + identifier, testProjectName);
             var testInstance = new TestInstance(testProjectDir, testDestination);
             return testInstance;
         }

src/Microsoft.DotNet.TestFramework/Microsoft.DotNet.TestFramework.TestInstance.cs

@@ -71,7 +71,6 @@ namespace Microsoft.DotNet.TestFramework
             {
                 string destFile = srcFile.Replace(_testAssetRoot, _testDestination);
                 File.Copy(srcFile, destFile, true);
-                FixTimeStamp(srcFile, destFile);
             }
         }
 
@@ -81,7 +80,6 @@ namespace Microsoft.DotNet.TestFramework
             {
                 string destinationLockFile = lockFile.Replace(_testAssetRoot, _testDestination);
                 File.Copy(lockFile, destinationLockFile, true);
-                FixTimeStamp(lockFile, destinationLockFile);
             }
 
             return this;
@@ -121,7 +119,6 @@ namespace Microsoft.DotNet.TestFramework
             {
                 string destFile = binFile.Replace(_testAssetRoot, _testDestination);
                 File.Copy(binFile, destFile, true);
-                FixTimeStamp(binFile, destFile);
             }
 
             return this;
@@ -131,15 +128,5 @@ namespace Microsoft.DotNet.TestFramework
         {
             get { return _testDestination; }
         }
-
-        private static void FixTimeStamp(string originalFile, string newFile)
-        {
-            // workaround for https://github.com/dotnet/corefx/issues/6083
-            if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
-            {
-                var originalTime = File.GetLastWriteTime(originalFile);
-                File.SetLastWriteTime(newFile, originalTime);
-            }
-        }
     }
 }

src/Microsoft.DotNet.TestFramework/project.json

@@ -4,6 +4,9 @@
   "tags": [
     ""
   ],
+  "compilationOptions": {
+    "keyFile": "../../tools/Key.snk"
+  },
   "projectUrl": "",
   "licenseUrl": "",
   "dependencies": {
@@ -14,6 +17,7 @@
       "imports": [
         "portable-net45+wp80+win8+wpa81+dnxcore50"
       ]
-    }
+    },
+    "net451": { }
   }
 }

test/Microsoft.DotNet.Tools.Tests.Utilities/Commands/BuildCommand.cs

@@ -266,7 +266,11 @@ namespace Microsoft.DotNet.Tools.Test.Utilities
 
         public string GetExecutableExtension()
         {
+#if NET451
+            return ".exe";
+#else
             return RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? ".exe" : "";
+#endif
         }
 
         private string BuildArgs()

test/Microsoft.DotNet.Tools.Tests.Utilities/Commands/PublishCommand.cs

@@ -104,7 +104,11 @@ namespace Microsoft.DotNet.Tools.Test.Utilities
 
         public string GetExecutableExtension()
         {
+#if NET451
+            return ".exe";
+#else
             return RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? ".exe" : "";
+#endif
         }
 
         private string BuildArgs()

test/Microsoft.DotNet.Tools.Tests.Utilities/Commands/TestCommand.cs

@@ -15,6 +15,8 @@ namespace Microsoft.DotNet.Tools.Test.Utilities
     {
         protected string _command;
         
+        private string _baseDirectory;
+
         public string WorkingDirectory { get; set; }
 
         public Process CurrentProcess { get; set; }
@@ -24,6 +26,11 @@ namespace Microsoft.DotNet.Tools.Test.Utilities
         public TestCommand(string command)
         {
             _command = command;
+#if NET451            
+            _baseDirectory = AppDomain.CurrentDomain.BaseDirectory;
+#else
+            _baseDirectory = AppContext.BaseDirectory;
+#endif 
         }
 
         public virtual CommandResult Execute(string args = "")
@@ -63,7 +70,7 @@ namespace Microsoft.DotNet.Tools.Test.Utilities
             var command = _command;
             ResolveCommand(ref command, ref args);
             var commandPath = Env.GetCommandPath(command, ".exe", ".cmd", "") ??
-                Env.GetCommandPathFromRootPath(AppContext.BaseDirectory, command, ".exe", ".cmd", "");
+                Env.GetCommandPathFromRootPath(_baseDirectory, command, ".exe", ".cmd", "");
 
             Console.WriteLine($"Executing (Captured Output) - {commandPath} {args}");
 
@@ -102,7 +109,7 @@ namespace Microsoft.DotNet.Tools.Test.Utilities
             if (!Path.IsPathRooted(executable))
             {
                 executable = Env.GetCommandPath(executable) ??
-                           Env.GetCommandPathFromRootPath(AppContext.BaseDirectory, executable);
+                           Env.GetCommandPathFromRootPath(_baseDirectory, executable);
             }
         }
 
@@ -153,12 +160,17 @@ namespace Microsoft.DotNet.Tools.Test.Utilities
                 Arguments = args,
                 RedirectStandardError = true,
                 RedirectStandardOutput = true,
-                RedirectStandardInput = true
+                RedirectStandardInput = true,
+                UseShellExecute = false
             };
 
             foreach (var item in Environment)
             {
+#if NET451
+                psi.EnvironmentVariables[item.Key] = item.Value;
+#else
                 psi.Environment[item.Key] = item.Value;
+#endif
             }
 
             if (!string.IsNullOrWhiteSpace(WorkingDirectory))

test/Microsoft.DotNet.Tools.Tests.Utilities/ProcessExtensions.cs

@@ -8,7 +8,11 @@ namespace Microsoft.DotNet.Tools.Test.Utilities
 {
     internal static class ProcessExtensions
     {
+#if NET451
+        private static readonly bool _isWindows = true;
+#else
         private static readonly bool _isWindows = RuntimeInformation.IsOSPlatform(OSPlatform.Windows);
+#endif
         private static readonly TimeSpan _defaultTimeout = TimeSpan.FromSeconds(30);
 
         public static void KillTree(this Process process)

test/Microsoft.DotNet.Tools.Tests.Utilities/TestBase.cs

@@ -33,7 +33,11 @@ namespace Microsoft.DotNet.Tools.Test.Utilities
                     return s_repoRoot;
                 }
 
+#if NET451
+            string directory = AppDomain.CurrentDomain.BaseDirectory;
+#else
             string directory = AppContext.BaseDirectory;
+#endif
 
                 while (!Directory.Exists(Path.Combine(directory, ".git")) && directory != null)
                 {

test/Microsoft.DotNet.Tools.Tests.Utilities/project.json

@@ -5,13 +5,6 @@
     "keyFile": "../../tools/Key.snk"
   },
   "dependencies": {
-    "Microsoft.NETCore.App": {
-      "type": "platform",
-      "version": "1.0.0-rc2-*"
-    },
-    "System.Runtime.Serialization.Primitives": "4.1.1-rc2-24022",
-    "System.Collections.Immutable": "1.2.0-rc2-24022",
-    "System.Net.NetworkInformation": "4.1.0-rc2-24022",
     "FluentAssertions": "4.0.0",
     "xunit": "2.1.0",
     "dotnet-test-xunit": "1.0.0-rc2-162081-13",
@@ -28,7 +21,21 @@
       "imports": [
         "dotnet5.4",
         "portable-net451+win8"      
-      ]
+      ],
+      "Microsoft.NETCore.App": {
+        "type": "platform",
+        "version": "1.0.0-rc2-*"
+      },
+      "System.Runtime.Serialization.Primitives": "4.1.1-rc2-24022",
+      "System.Collections.Immutable": "1.2.0-rc2-24022",
+      "System.Net.NetworkInformation": "4.1.0-rc2-24022"
+    },
+    "net451": {
+      "frameworkAssemblies": {
+        "System.Runtime": {
+          "type": "build"
+        }
+      }
     }
   }
 }

test/binding-redirects.Tests/BindingRedirectTests.cs

@@ -0,0 +1,287 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Collections.Generic;
+using System.Configuration;
+using System.IO;
+using System.Linq;
+using System.Runtime.InteropServices;
+using System.Xml.Linq;
+using Microsoft.DotNet.Cli.Utils;
+using Microsoft.DotNet.Tools.Test.Utilities;
+using Microsoft.DotNet.TestFramework;
+using Microsoft.Extensions.PlatformAbstractions;
+using Xunit;
+using FluentAssertions;
+
+namespace Microsoft.DotNet.Tests
+{
+    public class TestSetupFixture : TestBase
+    {
+        private const string Framework = "net451";
+        private const string Config = "Debug";
+        private const string AppWithConfig = "AppWithRedirectsAndConfig";
+        private const string AppWithoutConfig = "AppWithRedirectsNoConfig";
+
+        private string _Runtime = PlatformServices.Default.Runtime.GetLegacyRestoreRuntimeIdentifier();
+        private string _desktopProjectsRoot = Path.Combine(RepoRoot, "TestAssets", "DesktopTestProjects");
+        private string _buildRelativePath;
+        private string _appWithConfigBuildDir;
+        private string _appWithConfigPublishDir;
+        private string _appWithoutConfigBuildDir;
+        private string _appWithoutConfigPublishDir;
+        private TestInstance _testInstance;
+
+
+        public string AppWithConfigBuildOutput { get; }
+        public string AppWithConfigPublishOutput { get; }
+        public string AppWithoutConfigBuildOutput { get; }
+        public string AppWithoutConfigPublishOutput { get; }
+
+        public TestSetupFixture()
+        {
+            _buildRelativePath = Path.Combine("bin", Config, Framework, _Runtime);
+            var testAssetsMgr = new TestAssetsManager(_desktopProjectsRoot);
+            _testInstance = testAssetsMgr.CreateTestInstance("BindingRedirectSample")
+                                         .WithLockFiles();
+
+            Setup(AppWithConfig, ref _appWithConfigBuildDir, ref _appWithConfigPublishDir);
+            Setup(AppWithoutConfig, ref _appWithoutConfigBuildDir, ref _appWithoutConfigPublishDir);
+
+            AppWithConfigBuildOutput = Path.Combine(_appWithConfigBuildDir, AppWithConfig + ".exe");
+            AppWithConfigPublishOutput = Path.Combine(_appWithConfigPublishDir, AppWithConfig + ".exe");
+            AppWithoutConfigBuildOutput = Path.Combine(_appWithoutConfigBuildDir, AppWithoutConfig + ".exe");
+            AppWithoutConfigPublishOutput = Path.Combine(_appWithoutConfigPublishDir, AppWithoutConfig + ".exe");
+        }
+
+        private void Setup(string project, ref string buildDir, ref string publishDir)
+        {
+            string projectRoot = Path.Combine(_testInstance.TestRoot, project);
+            buildDir = Path.Combine(projectRoot, _buildRelativePath);
+            publishDir = Path.Combine(projectRoot, "publish");
+
+            var buildCommand = new BuildCommand(projectRoot, framework: Framework, runtime: _Runtime);
+            buildCommand.Execute().Should().Pass();
+
+            var publishCommand = new PublishCommand(projectRoot, output: publishDir, framework: Framework, runtime: _Runtime);
+            publishCommand.Execute().Should().Pass();
+        }
+    }
+
+    public class GivenAnAppWithRedirectsAndExecutableDependency : TestBase, IClassFixture<TestSetupFixture>
+    {
+        private const string ExecutableDependency = "dotnet-desktop-binding-redirects.exe";
+        private TestSetupFixture _testSetup;
+        private string _appWithConfigBuildOutput;
+        private string _appWithoutConfigBuildOutput;
+        private string _appWithConfigPublishOutput;
+        private string _appWithoutConfigPublishOutput;
+        private string _executableDependencyBuildOutput;
+        private string _executableDependencyPublishOutput;
+
+        public GivenAnAppWithRedirectsAndExecutableDependency(TestSetupFixture testSetup)
+        {
+            _testSetup = testSetup;
+            _appWithConfigBuildOutput = _testSetup.AppWithConfigBuildOutput;
+            _appWithConfigPublishOutput = _testSetup.AppWithConfigPublishOutput;
+            _appWithoutConfigBuildOutput = _testSetup.AppWithoutConfigBuildOutput;
+            _appWithoutConfigPublishOutput = _testSetup.AppWithoutConfigPublishOutput;
+            _executableDependencyBuildOutput = Path.Combine(Path.GetDirectoryName(_appWithConfigBuildOutput), ExecutableDependency);
+            _executableDependencyPublishOutput = Path.Combine(Path.GetDirectoryName(_appWithConfigPublishOutput), ExecutableDependency);
+        }
+
+        private static List<string> BindingsAppNoConfig
+        {
+            get
+            {
+                List<string> bindings = new List<string>()
+                {
+                    @"<dependentAssembly xmlns=""urn:schemas-microsoft-com:asm.v1"">
+                        <assemblyIdentity name=""Newtonsoft.Json"" publicKeyToken=""30ad4fe6b2a6aeed"" culture=""neutral"" />
+                        <bindingRedirect oldVersion=""4.5.0.0"" newVersion=""8.0.0.0"" />
+                        <bindingRedirect oldVersion=""6.0.0.0"" newVersion=""8.0.0.0"" />
+                      </dependentAssembly>",
+                    @"<dependentAssembly xmlns=""urn:schemas-microsoft-com:asm.v1"">
+                        <assemblyIdentity name=""System.Web.Mvc"" publicKeyToken=""31bf3856ad364e35"" culture=""neutral"" />
+                        <bindingRedirect oldVersion=""4.0.0.0"" newVersion=""3.0.0.1"" />
+                      </dependentAssembly>"
+                };
+
+                return bindings;
+            }
+        }
+
+        private static List<string> BindingsAppWithConfig
+        {
+            get
+            {
+                List<string> bindings = new List<string>()
+                {
+                    @"<dependentAssembly xmlns=""urn:schemas-microsoft-com:asm.v1"">
+                        <assemblyIdentity name=""Newtonsoft.Json"" publicKeyToken=""30ad4fe6b2a6aeed"" culture=""neutral"" />
+                        <bindingRedirect oldVersion=""3.5.0.0"" newVersion=""8.0.0.0"" />
+                        <bindingRedirect oldVersion=""4.5.0.0"" newVersion=""8.0.0.0"" />
+                        <bindingRedirect oldVersion=""6.0.0.0"" newVersion=""8.0.0.0"" />
+                      </dependentAssembly>",
+                    @"<dependentAssembly xmlns=""urn:schemas-microsoft-com:asm.v1"">
+                        <assemblyIdentity name=""Some.Foo.Assembly"" publicKeyToken=""814f48568d36eed5"" culture=""neutral"" />
+                        <bindingRedirect oldVersion=""3.0.0.0"" newVersion=""5.5.5.1"" />
+                      </dependentAssembly>",
+                    @"<dependentAssembly xmlns=""urn:schemas-microsoft-com:asm.v1"">
+                        <assemblyIdentity name=""System.Web.Mvc"" publicKeyToken=""31bf3856ad364e35"" culture=""neutral"" />
+                        <bindingRedirect oldVersion=""4.0.0.0"" newVersion=""3.0.0.1"" />
+                      </dependentAssembly>"
+                };
+
+                return bindings;
+            }
+        }
+
+        private static List<XElement> ExpectedBindingsAppNoConfig
+        {
+            get
+            {
+                List<XElement> bindingElements = new List<XElement>();
+
+                foreach (var binding in BindingsAppNoConfig)
+                {
+                    bindingElements.Add(XElement.Parse(binding));
+                }
+
+                return bindingElements;
+            }
+        }
+
+        private static List<XElement> ExpectedBindingsAppWithConfig
+        {
+            get
+            {
+                List<XElement> bindingElements = new List<XElement>();
+
+                foreach (var binding in BindingsAppWithConfig)
+                {
+                    bindingElements.Add(XElement.Parse(binding));
+                }
+
+                return bindingElements;
+            }
+        }
+
+        private static Dictionary<string, string> ExpectedAppSettings
+        {
+            get
+            {
+                Dictionary<string, string> appSettings = new Dictionary<string, string>()
+                {
+                    {"Setting1", "Hello"},
+                    {"Setting2", "World"}
+                };
+
+                return appSettings;
+            }
+        }
+
+        private IEnumerable<XElement> GetRedirects(string exePath)
+        {
+            var configFile = exePath + ".config";
+            File.Exists(configFile).Should().BeTrue($"Config file not found - {configFile}");
+            var config = ConfigurationManager.OpenExeConfiguration(exePath);
+            var runtimeSectionXml = config.Sections["runtime"].SectionInformation.GetRawXml();
+            var runtimeSectionElement = XElement.Parse(runtimeSectionXml);
+            var redirects = runtimeSectionElement.Elements()
+                                .Where(e => e.Name.LocalName == "assemblyBinding").Elements()
+                                .Where(e => e.Name.LocalName == "dependentAssembly");
+            return redirects;
+        }
+
+        private void VerifyRedirects(IEnumerable<XElement> redirects, IEnumerable<XElement> generatedBindings)
+        {
+            foreach (var binding in generatedBindings)
+            {
+                var redirect = redirects.SingleOrDefault(r => /*XNode.DeepEquals(r, binding)*/ r.ToString() == binding.ToString());
+
+                redirect.Should().NotBeNull($"Binding not found in runtime section : {Environment.NewLine}{binding}");
+            }
+        }
+
+        private void VerifyAppSettings(string exePath)
+        {
+            var configFile = ConfigurationManager.OpenExeConfiguration(exePath);
+            foreach (var appSetting in ExpectedAppSettings)
+            {
+                var value = configFile.AppSettings.Settings[appSetting.Key];
+                value.Should().NotBeNull($"AppSetting with key '{appSetting.Key}' not found in config file.");
+                value.Value.Should().Be(appSetting.Value, $"For AppSetting '{appSetting.Key}' - Expected Value '{appSetting.Value}', Actual '{ value.Value}'");
+            }
+        }
+
+        [WindowsOnlyFact]
+        public void Build_Generates_Redirects_For_App_Without_Config()
+        {
+            var redirects = GetRedirects(_appWithoutConfigBuildOutput);
+            VerifyRedirects(redirects, ExpectedBindingsAppNoConfig);
+
+            var commandResult = new TestCommand(_appWithoutConfigBuildOutput)
+                                    .Execute();
+            commandResult.Should().Pass();
+        }
+
+        [WindowsOnlyFact]
+        public void Publish_Generates_Redirects_For_App_Without_Config()
+        {
+            var redirects = GetRedirects(_appWithoutConfigPublishOutput);
+            VerifyRedirects(redirects, ExpectedBindingsAppNoConfig);
+
+            var commandResult = new TestCommand(_appWithoutConfigPublishOutput)
+                                    .Execute();
+            commandResult.Should().Pass();
+        }
+
+        [WindowsOnlyFact]
+        public void Build_Generates_Redirects_For_Executable_Dependency()
+        {
+            var redirects = GetRedirects(_executableDependencyBuildOutput);
+            VerifyRedirects(redirects, ExpectedBindingsAppNoConfig);
+
+            var commandResult = new TestCommand(_executableDependencyBuildOutput)
+                                    .Execute();
+            commandResult.Should().Pass();
+        }
+
+        //[WindowsOnlyFact]
+        public void Publish_Generates_Redirects_For_Executable_Dependency()
+        {
+            var redirects = GetRedirects(_executableDependencyPublishOutput);
+            VerifyRedirects(redirects, ExpectedBindingsAppNoConfig);
+
+            var commandResult = new TestCommand(_executableDependencyPublishOutput)
+                                    .Execute();
+            commandResult.Should().Pass();
+        }
+
+        [WindowsOnlyFact]
+        public void Build_Generates_Redirects_For_App_With_Config()
+        {
+            var redirects = GetRedirects(_appWithConfigBuildOutput);
+            VerifyRedirects(redirects, ExpectedBindingsAppWithConfig);
+            VerifyAppSettings(_appWithConfigBuildOutput);
+
+            var commandResult = new TestCommand(_appWithConfigBuildOutput)
+                                    .Execute();
+            commandResult.Should().Pass();
+        }
+
+        [WindowsOnlyFact]
+        public void Publish_Generates_Redirects_For_App_With_Config()
+        {
+            var redirects = GetRedirects(_appWithConfigPublishOutput);
+            VerifyRedirects(redirects, ExpectedBindingsAppWithConfig);
+            VerifyAppSettings(_appWithConfigPublishOutput);
+
+            var commandResult = new TestCommand(_appWithConfigPublishOutput)
+                                    .Execute();
+            commandResult.Should().Pass();
+        }
+    }
+}

test/binding-redirects.Tests/binding-redirects.Tests.xproj

@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="14.0.23107" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <VisualStudioVersion Condition="'$(VisualStudioVersion)' == ''">14.0.23107</VisualStudioVersion>
+    <VSToolsPath Condition="'$(VSToolsPath)' == ''">$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)</VSToolsPath>
+  </PropertyGroup>
+  <Import Project="$(VSToolsPath)\DNX\Microsoft.DNX.Props" Condition="'$(VSToolsPath)' != ''" />
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>27dbf851-f2e3-4fd5-bf4d-a73c81933283</ProjectGuid>
+    <RootNamespace>binding-redirects.Tests</RootNamespace>
+    <BaseIntermediateOutputPath Condition="'$(BaseIntermediateOutputPath)'=='' ">..\..\artifacts\obj\$(MSBuildProjectName)</BaseIntermediateOutputPath>
+    <OutputPath Condition="'$(OutputPath)'=='' ">..\..\artifacts\bin</OutputPath>
+  </PropertyGroup>
+  <PropertyGroup>
+    <SchemaVersion>2.0</SchemaVersion>
+  </PropertyGroup>
+  <ItemGroup>
+    <Service Include="{9b56c4a1-b027-48c1-8050-e344f0630b98}" />
+  </ItemGroup>
+  <Import Project="$(VSToolsPath)\DNX\Microsoft.DNX.targets" Condition="'$(VSToolsPath)' != ''" />
+</Project>

test/binding-redirects.Tests/project.json

@@ -0,0 +1,23 @@
+{
+  "version": "1.0.0-*",
+  "dependencies": {
+    "xunit": "2.1.0",
+    "dotnet-test-xunit": "1.0.0-rc2-157751-46",
+    "Microsoft.NETCore.Platforms": "1.0.1-*",
+    "Microsoft.DotNet.Tools.Tests.Utilities": {
+      "target": "project"
+    }
+  },
+  "frameworks": {
+    "net451": {
+       "frameworkAssemblies": {
+        "System.Configuration": ""
+      }
+     }
+  },
+  "runtimes": {
+    "win7-x64": {},
+    "win7-x86": {}   
+  },
+  "testRunner": "xunit"
+}