diff --git a/README.md b/README.md
index db83dd867..e8b2e06de 100644
--- a/README.md
+++ b/README.md
@@ -7,9 +7,13 @@ The latest releases can be downloaded from [releases](https://github.com/opencov
 [![Nuget](https://img.shields.io/nuget/vpre/opencover.svg)](http://nuget.org/packages/opencover)
 
 ### Master 
-
 The primary repo for the project is [on GitHub](https://github.com/opencover/opencover/) and is also where the [wiki](https://github.com/OpenCover/opencover/wiki) and [issues](https://github.com/OpenCover/opencover/wiki) are managed from.
 
+### Team communication
+[![Join the chat at https://gitter.im/OpenCover/opencover](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/OpenCover/opencover?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+
+Team communications can also be done via [slack](http://slack.com), raise an issue to request access (include your email - obfuscated if you wish) and we will send you an invite then just visit the [team page](https://opencover.slack.com/) to sign up and join the conversation.
+
 ### Licence
 All Original Software is licensed under the [MIT Licence](https://github.com/opencover/opencover/blob/master/License.md) and does not apply to any other 3rd party tools, utilities or code which may be used to develop this application.
 
diff --git a/ReleaseNotes.tmp b/ReleaseNotes.tmp
index 22d7048bd..fe3939606 100644
--- a/ReleaseNotes.tmp
+++ b/ReleaseNotes.tmp
@@ -1,4 +1,5 @@
 Version [[version]]
+#244 support ApplicationUnderTest.Launch to propagate required OPENCOVER environment variables
 #256 support Microsoft Fakes (feature) - beta support until we bed feature in
 #248 address issue with Mono.Cecil and latest PDB (.NET 4.6) version
 #252 use AppVeyor for building code and pull requests (prj-mgmt)
diff --git a/appveyor.yml b/appveyor.yml
index 8b3f815e8..a262cf58a 100644
--- a/appveyor.yml
+++ b/appveyor.yml
@@ -37,5 +37,11 @@ deploy:
   artifact: NugetCandidate
   on:
     branch: rc
+notifications:
+- provider: Webhook
+  url: https://webhooks.gitter.im/e/737fbf46970811e6bfa7
+  on_build_success: true
+  on_build_failure: true
+  on_build_status_changed: true
 on_success:
-- build dogfood-release
\ No newline at end of file
+- build dogfood-release
diff --git a/main/.nuget/NuGet.targets b/main/.nuget/NuGet.targets
index 2d11ba558..4f2439166 100644
--- a/main/.nuget/NuGet.targets
+++ b/main/.nuget/NuGet.targets
@@ -41,7 +41,7 @@
     
     <PropertyGroup>
         <!-- NuGet command -->
-        <NuGetExePath Condition=" '$(NuGetExePath)' == '' ">$(NuGetToolsPath)\nuget.exe</NuGetExePath>
+        <NuGetExePath Condition=" '$(NuGetExePath)' == '' ">$(NuGetToolsPath)\NuGet.exe</NuGetExePath>
         <PackageSources Condition=" $(PackageSources) == '' ">@(PackageSource)</PackageSources>
         
         <NuGetCommand Condition=" '$(OS)' == 'Windows_NT'">"$(NuGetExePath)"</NuGetCommand>
diff --git a/main/OpenCover.Console/OpenCover.Console.csproj b/main/OpenCover.Console/OpenCover.Console.csproj
index 655432015..c62fc381b 100644
--- a/main/OpenCover.Console/OpenCover.Console.csproj
+++ b/main/OpenCover.Console/OpenCover.Console.csproj
@@ -139,7 +139,7 @@
     </EmbeddedResource>
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
-  <Import Project="$(SolutionDir)\.nuget\nuget.targets" />
+  <Import Project="$(SolutionDir)\.nuget\NuGet.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">
diff --git a/main/OpenCover.Extensions/OpenCover.Extensions.csproj b/main/OpenCover.Extensions/OpenCover.Extensions.csproj
index ff07356ca..9c53b30ff 100644
--- a/main/OpenCover.Extensions/OpenCover.Extensions.csproj
+++ b/main/OpenCover.Extensions/OpenCover.Extensions.csproj
@@ -90,7 +90,7 @@
     <None Include="packages.config" />
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
-  <Import Project="$(SolutionDir)\.nuget\nuget.targets" />
+  <Import Project="$(SolutionDir)\.nuget\NuGet.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">
diff --git a/main/OpenCover.FakesSupport/FakesDomainHelper.cs b/main/OpenCover.FakesSupport/FakesDomainHelper.cs
deleted file mode 100644
index 4a43c8864..000000000
--- a/main/OpenCover.FakesSupport/FakesDomainHelper.cs
+++ /dev/null
@@ -1,13 +0,0 @@
-using System;
-
-namespace OpenCover.FakesSupport
-{
-    public class FakesDomainHelper : IFakesDomainHelper
-    {
-        public void AddResolveEventHandler()
-        {
-            AppDomain.CurrentDomain.AssemblyResolve +=
-                (sender, args) => args.Name.StartsWith("OpenCover.FakesSupport, Version=1.0.0.0") ? System.Reflection.Assembly.GetExecutingAssembly() : null;
-        }
-    }
-}
\ No newline at end of file
diff --git a/main/OpenCover.Framework/Communication/CommunicationManager.cs b/main/OpenCover.Framework/Communication/CommunicationManager.cs
index 45a046abe..7ae0cb4af 100644
--- a/main/OpenCover.Framework/Communication/CommunicationManager.cs
+++ b/main/OpenCover.Framework/Communication/CommunicationManager.cs
@@ -64,7 +64,7 @@ private static void SendChunkAndWaitForConfirmation(int writeSize, IManagedCommu
             mcb.StreamAccessorComms.Seek(0, SeekOrigin.Begin);
             mcb.StreamAccessorComms.Write(mcb.DataCommunication, 0, writeSize);
 
-            WaitHandle.SignalAndWait(mcb.InformationReadyForProfiler, mcb.InformationReadByProfiler);
+            WaitHandle.SignalAndWait(mcb.InformationReadyForProfiler, mcb.InformationReadByProfiler, 10000, false);
             mcb.InformationReadByProfiler.Reset();
         }
 
diff --git a/main/OpenCover.Framework/Filter.cs b/main/OpenCover.Framework/Filter.cs
index 53c5f47dc..92c183296 100644
--- a/main/OpenCover.Framework/Filter.cs
+++ b/main/OpenCover.Framework/Filter.cs
@@ -5,168 +5,55 @@
 //
 using System;
 using System.Collections.Generic;
-using System.IO;
 using System.Linq;
 using System.Runtime.CompilerServices;
 using System.Text.RegularExpressions;
 using Mono.Cecil;
+using OpenCover.Framework.Filtering;
 
 namespace OpenCover.Framework
 {
-    /// <summary>
-    /// A filter that is used to decide whether an assembly/class pair is instrumented
-    /// </summary>
-    public interface IFilter
-    {
-        /// <summary>
-        /// Add a filter
-        /// </summary>
-        /// <param name="assemblyClassName">A filter is of the format (+ or -)[assemblyName]className, wildcards are allowed. <br/>
-        /// i.e. -[mscorlib], -[System.*]*, +[App.*]*, +[*]*
-        /// </param>
-        void AddFilter(string assemblyClassName);
-
-        /// <summary>
-        /// Decides whether an assembly should be included in the instrumentation
-        /// </summary>
-        /// <param name="assemblyName">the name of the assembly under profile</param>
-        /// <remarks>All assemblies matching either the inclusion or exclusion filter should be included 
-        /// as it is the class that is being filtered within these unless the class filter is *</remarks>
-        bool UseAssembly(string assemblyName);
-
-        /// <summary>
-        /// Decides whether an assembly should be analysed for test methods
-        /// </summary>
-        /// <param name="assemblyName">the name of the assembly under profile</param>
-        /// <returns>true - if the assembly matches the test assembly filter</returns>
-        bool UseTestAssembly(string assemblyName);
-
-        /// <summary>
-        /// Add file exclusion filters
-        /// </summary>
-        /// <param name="exclusionFilters"></param>
-        void AddFileExclusionFilters(string[] exclusionFilters);
-
-        /// <summary>
-        /// Determine if an [assemblyname]classname pair matches the current Exclusion or Inclusion filters  
-        /// </summary>
-        /// <param name="assemblyName">the name of the assembly under profile</param>
-        /// <param name="className">the name of the class under profile</param>
-        /// <returns>false - if pair matches the exclusion filter or matches no filters, true - if pair matches in the inclusion filter</returns>
-        bool InstrumentClass(string assemblyName, string className);
-
-        /// <summary>
-        /// Add attribute exclusion filters
-        /// </summary>
-        /// <param name="exclusionFilters">An array of filters that are used to wildcard match an attribute</param>
-        void AddAttributeExclusionFilters(string[] exclusionFilters);
-
-        /// <summary>
-        /// Is this entity excluded due to an attributeFilter
-        /// </summary>
-        /// <param name="entity">The entity to test</param>
-        /// <returns></returns>
-        bool ExcludeByAttribute(IMemberDefinition entity);
-
-        /// <summary>
-        /// Is this file excluded
-        /// </summary>
-        /// <param name="fileName">The name of the file to test</param>
-        /// <returns></returns>
-        bool ExcludeByFile(string fileName);
-
-        /// <summary>
-        /// Add test file filters
-        /// </summary>
-        /// <param name="testFilters"></param>
-        void AddTestFileFilters(string[] testFilters);
-
-        /// <summary>
-        /// Is the method an auto-implemented property get/set
-        /// </summary>
-        /// <param name="method"></param>
-        /// <returns></returns>
-        bool IsAutoImplementedProperty(MethodDefinition method);
-
-        /// <summary>
-        /// filters should be treated as regular expressions rather than wildcard
-        /// </summary>
-        bool RegExFilters { get; }
-    }  
-
-    internal static class FilterHelper
-    {
-        internal static string WrapWithAnchors(this string data)
-        {
-            return String.Format("^({0})$", data);
-        }
-
-        internal static string ValidateAndEscape(this string match, string notAllowed = @"\[]")
-        {
-            if (match.IndexOfAny(notAllowed.ToCharArray()) >= 0) throw new InvalidOperationException(String.Format("The string is invalid for an filter name {0}", match));
-            match = match.Replace(@"\", @"\\");
-            match = match.Replace(@".", @"\.");
-            match = match.Replace(@"*", @".*");
-            return match;
-        }
-    }
-
-    /// <summary>
-    /// The type of filter, an exclusion filter takes precedence over inclusion filter
-    /// </summary>
-    public enum FilterType
-    {
-        /// <summary>
-        /// The filter is an inclusion type, i.e. if a assembly/class pair 
-        /// matches the filter then it is included for instrumentation
-        /// </summary>
-        Inclusion,
-
-        /// <summary>
-        /// The filter is an exclusion type, i.e. if a assembly/class pair 
-        /// matches the filter then it is excluded for instrumentation
-        /// </summary>
-        Exclusion
-    }
-    
     /// <summary>
     ///  A filter that is used to decide whether an assembly/class pair is instrumented
     /// </summary>
     public class Filter : IFilter
     {
-        internal IList<KeyValuePair<string, string>> InclusionFilter { get; set; }
-        internal IList<KeyValuePair<string, string>> ExclusionFilter { get; set; }
-        internal IList<Lazy<Regex>> ExcludedAttributes { get; set; }
-        internal IList<Lazy<Regex>> ExcludedFiles { get; set; }
-        internal IList<Lazy<Regex>> TestFiles { get; set; }
+        internal IList<AssemblyAndClassFilter> InclusionFilters { get; private set; }
+        internal IList<AssemblyAndClassFilter> ExclusionFilters { get; private set; }
+        internal IList<RegexFilter> ExcludedAttributes { get; private set; }
+        internal IList<RegexFilter> ExcludedFiles { get; private set; }
+        internal IList<RegexFilter> TestFiles { get; private set; }
         public bool RegExFilters { get; private set; }
 
         /// <summary>
         /// Standard constructor
         /// </summary>
+        /// <param name="useRegexFilters">Indicates if the input strings for this class are already Regular Expressions</param>
         public Filter(bool useRegexFilters = false)
         {
-            InclusionFilter = new List<KeyValuePair<string, string>>();
-            ExclusionFilter = new List<KeyValuePair<string, string>>();
-            ExcludedAttributes = new List<Lazy<Regex>>();
-            ExcludedFiles = new List<Lazy<Regex>>();
-            TestFiles = new List<Lazy<Regex>>();
+            InclusionFilters = new List<AssemblyAndClassFilter>();
+            ExclusionFilters = new List<AssemblyAndClassFilter>();
+            ExcludedAttributes = new List<RegexFilter>();
+            ExcludedFiles = new List<RegexFilter>();
+            TestFiles = new List<RegexFilter>();
             RegExFilters = useRegexFilters;
         }
-        
+
         public bool UseAssembly(string assemblyName)
         {
-            if (ExclusionFilter.Any(keyValuePair => Regex.Match(assemblyName, keyValuePair.Key.WrapWithAnchors()).Success && keyValuePair.Value == ".*"))
+            var matchingExclusionFilters = ExclusionFilters.GetMatchingFiltersForAssemblyName(assemblyName);
+            if (matchingExclusionFilters.Any(exclusionFilter => exclusionFilter.ClassName == ".*"))
             {
                 return false;
             }
 
-            if (ExclusionFilter.Any(keyValuePair => Regex.Match(assemblyName, keyValuePair.Key.WrapWithAnchors()).Success && keyValuePair.Value != ".*"))
+            if (matchingExclusionFilters.Any(exclusionFilter => exclusionFilter.ClassName != ".*"))
             {
                 return true;
             }
 
-            if (InclusionFilter.Any(keyValuePair => Regex.Match(assemblyName, keyValuePair.Key.WrapWithAnchors()).Success))
+            var matchingInclusionFilters = InclusionFilters.GetMatchingFiltersForAssemblyName(assemblyName);
+            if (matchingInclusionFilters.Any())
             {
                 return true;
             }
@@ -181,22 +68,21 @@ public bool InstrumentClass(string assemblyName, string className)
                 return false;
             }
 
-            if (ExclusionFilter
-                .Any(keyValuePair => Regex.Match(assemblyName, keyValuePair.Key.WrapWithAnchors()).Success && keyValuePair.Value == ".*"))
+            var matchingExclusionFilters = ExclusionFilters.GetMatchingFiltersForAssemblyName(assemblyName);
+            if (matchingExclusionFilters.Any(exclusionFilter => exclusionFilter.ClassName == ".*"))
             {
                 return false;
             }
 
-            if (ExclusionFilter
-                .Where(keyValuePair => Regex.Match(assemblyName, keyValuePair.Key.WrapWithAnchors()).Success && keyValuePair.Value != ".*")
-                .Any(keyValuePair => Regex.Match(className, keyValuePair.Value.WrapWithAnchors()).Success))
+            if (matchingExclusionFilters
+                .Where(exclusionFilter => exclusionFilter.ClassName != ".*")
+                .Any(exclusionFilter => exclusionFilter.IsMatchingClassName(className)))
             {
                 return false;
             }
 
-            if (InclusionFilter
-                .Where(keyValuePair => Regex.Match(assemblyName, keyValuePair.Key.WrapWithAnchors()).Success)
-                .Any(keyValuePair => Regex.Match(className, keyValuePair.Value.WrapWithAnchors()).Success))
+            var matchingInclusionFilters = InclusionFilters.GetMatchingFiltersForAssemblyName(assemblyName);
+            if (matchingInclusionFilters.Any(inclusionFilter => inclusionFilter.IsMatchingClassName(className)))
             {
                 return true;
             }
@@ -217,11 +103,12 @@ public void AddFilter(string assemblyClassName)
                 className = className.ValidateAndEscape();
             }
 
-            if (filterType == FilterType.Inclusion) 
-                InclusionFilter.Add(new KeyValuePair<string, string>(assemblyName, className));
+            var filter = new AssemblyAndClassFilter(assemblyName, className);
+            if (filterType == FilterType.Inclusion)
+                InclusionFilters.Add(filter);
 
-            if (filterType == FilterType.Exclusion) 
-                ExclusionFilter.Add(new KeyValuePair<string, string>(assemblyName, className));
+            if (filterType == FilterType.Exclusion)
+                ExclusionFilters.Add(filter);
         }
 
         private static void GetAssemblyClassName(string assemblyClassName, bool useRegEx, out FilterType filterType, out string assemblyName, out string className)
@@ -235,37 +122,29 @@ private static void GetAssemblyClassName(string assemblyClassName, bool useRegEx
             var match = regEx.Match(assemblyClassName);
             if (match.Success)
             {
-                filterType = match.Groups["type"].Value == "+" ? FilterType.Inclusion : FilterType.Exclusion;
+                filterType = match.Groups["type"].Value.ParseFilterType();
                 assemblyName = match.Groups["assembly"].Value;
                 className = match.Groups["class"].Value;
 
                 if (string.IsNullOrWhiteSpace(assemblyName))
-                    throw new InvalidOperationException(string.Format("The supplied filter '{0}' does not meet the required format for a filter +-[assemblyname]classname", assemblyClassName));
+                    throw InvalidFilterFormatException(assemblyClassName);
             }
             else
             {
-                throw new InvalidOperationException(string.Format("The supplied filter '{0}' does not meet the required format for a filter +-[assemblyname]classname", assemblyClassName));
+                throw InvalidFilterFormatException(assemblyClassName);
             }
         }
 
+        private static InvalidOperationException InvalidFilterFormatException(string assemblyClassName)
+        {
+            return new InvalidOperationException(string.Format("The supplied filter '{0}' does not meet the required format for a filter +-[assemblyname]classname", assemblyClassName));
+        }
+
         public void AddAttributeExclusionFilters(string[] exclusionFilters)
         {
-            if (exclusionFilters == null) 
-                return;
-            foreach (var exlusionFilter in exclusionFilters.Where(x => x != null))
-            {
-                var filter = exlusionFilter;
-                if (!RegExFilters) 
-                    filter = filter.ValidateAndEscape().WrapWithAnchors();
-                ExcludedAttributes.Add(new Lazy<Regex>(() => new Regex(filter)));
-            }
+            ExcludedAttributes.AddFilters(exclusionFilters, RegExFilters);
         }
 
-        /// <summary>
-        /// 
-        /// </summary>
-        /// <param name="entity"></param>
-        /// <returns></returns>
         public bool ExcludeByAttribute(IMemberDefinition entity)
         {
             while (true)
@@ -273,15 +152,15 @@ public bool ExcludeByAttribute(IMemberDefinition entity)
                 if (ExcludedAttributes.Count == 0)
                     return false;
 
-                if (entity ==null || !entity.HasCustomAttributes)
+                if (entity == null || !entity.HasCustomAttributes)
                     return false;
 
-                if ((from excludeAttribute in ExcludedAttributes from customAttribute in entity.CustomAttributes where excludeAttribute.Value.Match(customAttribute.AttributeType.FullName).Success select excludeAttribute).Any())
+                if ((from excludeAttribute in ExcludedAttributes from customAttribute in entity.CustomAttributes where excludeAttribute.IsMatchingExpression(customAttribute.AttributeType.FullName) select excludeAttribute).Any())
                 {
                     return true;
                 }
 
-                if (entity.DeclaringType == null || !entity.Name.StartsWith("<")) 
+                if (entity.DeclaringType == null || !entity.Name.StartsWith("<"))
                     return false;
 
                 var match = Regex.Match(entity.Name, @"\<(?<name>.+)\>.+");
@@ -310,22 +189,12 @@ public bool ExcludeByFile(string fileName)
             if (ExcludedFiles.Count == 0 || string.IsNullOrWhiteSpace(fileName))
                 return false;
 
-            return ExcludedFiles.Any(excludeFile => excludeFile.Value.Match(fileName).Success);
+            return ExcludedFiles.Any(excludeFile => excludeFile.IsMatchingExpression(fileName));
         }
 
         public void AddFileExclusionFilters(string[] exclusionFilters)
         {
-            if (exclusionFilters == null)
-                return;
-
-            foreach (var exlusionFilter in exclusionFilters.Where(x => x != null))
-            {
-                var filter = exlusionFilter;
-                if (!RegExFilters) 
-                    filter = filter.ValidateAndEscape(@"[]").WrapWithAnchors();
-                
-                ExcludedFiles.Add(new Lazy<Regex>(() => new Regex(filter)));
-            }
+            ExcludedFiles.AddFilters(exclusionFilters, RegExFilters);
         }
 
         public bool UseTestAssembly(string assemblyName)
@@ -333,22 +202,12 @@ public bool UseTestAssembly(string assemblyName)
             if (TestFiles.Count == 0 || string.IsNullOrWhiteSpace(assemblyName))
                 return false;
 
-            return TestFiles.Any(file => file.Value.Match(assemblyName).Success);
+            return TestFiles.Any(file => file.IsMatchingExpression(assemblyName));
         }
 
         public void AddTestFileFilters(string[] testFilters)
         {
-            if (testFilters == null)
-                return;
-
-            foreach (var testFilter in testFilters.Where(x => x != null))
-            {
-                var filter = testFilter;
-                if (!RegExFilters)
-                    filter = filter.ValidateAndEscape(@"[]").WrapWithAnchors(); 
-                
-                TestFiles.Add(new Lazy<Regex>(() => new Regex(filter)));
-            }
+            TestFiles.AddFilters(testFilters, RegExFilters);
         }
 
         public bool IsAutoImplementedProperty(MethodDefinition method)
diff --git a/main/OpenCover.Framework/Filtering/AssemblyAndClassFilter.cs b/main/OpenCover.Framework/Filtering/AssemblyAndClassFilter.cs
new file mode 100644
index 000000000..f4e6dbf85
--- /dev/null
+++ b/main/OpenCover.Framework/Filtering/AssemblyAndClassFilter.cs
@@ -0,0 +1,35 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace OpenCover.Framework.Filtering
+{
+    internal class AssemblyAndClassFilter
+    {
+        private readonly RegexFilter assemblyNameFilter;
+
+        private readonly RegexFilter classNameFilter;
+
+        internal string AssemblyName { get { return assemblyNameFilter.FilterExpression; } }
+
+        internal string ClassName { get { return classNameFilter.FilterExpression; } }
+
+        internal AssemblyAndClassFilter(string assemblyName, string className)
+        {
+            assemblyNameFilter = new RegexFilter(assemblyName);
+            classNameFilter = new RegexFilter(className);
+        }
+
+        internal bool IsMatchingAssemblyName(string assemblyName)
+        {
+            return assemblyNameFilter.IsMatchingExpression(assemblyName);
+        }
+
+        internal bool IsMatchingClassName(string className)
+        {
+            return classNameFilter.IsMatchingExpression(className);
+        }
+    }
+
+}
diff --git a/main/OpenCover.Framework/Filtering/FilterHelper.cs b/main/OpenCover.Framework/Filtering/FilterHelper.cs
new file mode 100644
index 000000000..b2ad0b24a
--- /dev/null
+++ b/main/OpenCover.Framework/Filtering/FilterHelper.cs
@@ -0,0 +1,51 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace OpenCover.Framework.Filtering
+{
+    internal static class FilterHelper
+    {
+        internal static string WrapWithAnchors(this string data)
+        {
+            return String.Format("^({0})$", data);
+        }
+
+        internal static string ValidateAndEscape(this string match, string notAllowed = @"\[]")
+        {
+            if (match.IndexOfAny(notAllowed.ToCharArray()) >= 0) throw new InvalidOperationException(String.Format("The string is invalid for an filter name {0}", match));
+            match = match.Replace(@"\", @"\\");
+            match = match.Replace(@".", @"\.");
+            match = match.Replace(@"*", @".*");
+            return match;
+        }
+
+        internal static IList<AssemblyAndClassFilter> GetMatchingFiltersForAssemblyName(this IEnumerable<AssemblyAndClassFilter> filters, string assemblyName)
+        {
+            var matchingFilters =
+                filters.Where(filter => filter.IsMatchingAssemblyName(assemblyName)).ToList();
+            return matchingFilters;
+        }
+
+        internal static void AddFilters(this ICollection<RegexFilter> target, IEnumerable<string> filters, bool isRegexFilter)
+        {
+            if (filters == null)
+                return;
+
+            foreach (var filter in filters.Where(x => x != null))
+            {
+                RegexFilter regexFilter;
+                if (isRegexFilter)
+                {
+                    regexFilter = new RegexFilter(filter, false);
+                }
+                else
+                {
+                    regexFilter = new RegexFilter(filter.ValidateAndEscape(@"[]"));
+                }
+
+                target.Add(regexFilter);
+            }
+        }
+    }
+}
diff --git a/main/OpenCover.Framework/Filtering/FilterType.cs b/main/OpenCover.Framework/Filtering/FilterType.cs
new file mode 100644
index 000000000..b8d0e1176
--- /dev/null
+++ b/main/OpenCover.Framework/Filtering/FilterType.cs
@@ -0,0 +1,38 @@
+using System;
+
+namespace OpenCover.Framework.Filtering
+{
+    /// <summary>
+    /// The type of filter, an exclusion filter takes precedence over inclusion filter
+    /// </summary>
+    public enum FilterType
+    {
+        /// <summary>
+        /// The filter is an inclusion type, i.e. if a assembly/class pair 
+        /// matches the filter then it is included for instrumentation
+        /// </summary>
+        Inclusion,
+
+        /// <summary>
+        /// The filter is an exclusion type, i.e. if a assembly/class pair 
+        /// matches the filter then it is excluded for instrumentation
+        /// </summary>
+        Exclusion
+    }
+
+    internal static class FilterTypeExtensions
+    {
+        public static FilterType ParseFilterType(this string type)
+        {
+            switch (type)
+            {
+                case "+":
+                    return FilterType.Inclusion;
+                case "-":
+                    return FilterType.Exclusion;
+                default:
+                    throw new ArgumentException("unhandled FilterType: " + type);
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/main/OpenCover.Framework/Filtering/RegexFilter.cs b/main/OpenCover.Framework/Filtering/RegexFilter.cs
new file mode 100644
index 000000000..ee1f01d91
--- /dev/null
+++ b/main/OpenCover.Framework/Filtering/RegexFilter.cs
@@ -0,0 +1,28 @@
+using System;
+using System.Text.RegularExpressions;
+
+namespace OpenCover.Framework.Filtering
+{
+    internal class RegexFilter
+    {
+        private readonly Lazy<Regex> regex;
+
+        internal string FilterExpression { get; private set; }
+
+        public RegexFilter(string filterExpression, bool shouldWrapExpression = true)
+        {
+            FilterExpression = filterExpression;
+            if (shouldWrapExpression)
+            {
+                filterExpression = filterExpression.WrapWithAnchors();
+            }
+
+            regex = new Lazy<Regex>(() => new Regex(filterExpression));
+        }
+
+        public bool IsMatchingExpression(string input)
+        {
+            return regex.Value.IsMatch(input);
+        }
+    }
+}
diff --git a/main/OpenCover.Framework/IFilter.cs b/main/OpenCover.Framework/IFilter.cs
new file mode 100644
index 000000000..f6ef322ee
--- /dev/null
+++ b/main/OpenCover.Framework/IFilter.cs
@@ -0,0 +1,86 @@
+using Mono.Cecil;
+
+namespace OpenCover.Framework
+{
+    /// <summary>
+    /// A filter that is used to decide whether an assembly/class pair is instrumented
+    /// </summary>
+    public interface IFilter
+    {
+        /// <summary>
+        /// Add a filter
+        /// </summary>
+        /// <param name="assemblyClassName">A filter is of the format (+ or -)[assemblyName]className, wildcards are allowed. <br/>
+        /// i.e. -[mscorlib], -[System.*]*, +[App.*]*, +[*]*
+        /// </param>
+        void AddFilter(string assemblyClassName);
+
+        /// <summary>
+        /// Decides whether an assembly should be included in the instrumentation
+        /// </summary>
+        /// <param name="assemblyName">the name of the assembly under profile</param>
+        /// <remarks>All assemblies matching either the inclusion or exclusion filter should be included 
+        /// as it is the class that is being filtered within these unless the class filter is *</remarks>
+        bool UseAssembly(string assemblyName);
+
+        /// <summary>
+        /// Decides whether an assembly should be analysed for test methods
+        /// </summary>
+        /// <param name="assemblyName">the name of the assembly under profile</param>
+        /// <returns>true - if the assembly matches the test assembly filter</returns>
+        bool UseTestAssembly(string assemblyName);
+
+        /// <summary>
+        /// Add file exclusion filters
+        /// </summary>
+        /// <param name="exclusionFilters"></param>
+        void AddFileExclusionFilters(string[] exclusionFilters);
+
+        /// <summary>
+        /// Determine if an [assemblyname]classname pair matches the current Exclusion or Inclusion filters  
+        /// </summary>
+        /// <param name="assemblyName">the name of the assembly under profile</param>
+        /// <param name="className">the name of the class under profile</param>
+        /// <returns>false - if pair matches the exclusion filter or matches no filters, true - if pair matches in the inclusion filter</returns>
+        bool InstrumentClass(string assemblyName, string className);
+
+        /// <summary>
+        /// Add attribute exclusion filters
+        /// </summary>
+        /// <param name="exclusionFilters">An array of filters that are used to wildcard match an attribute</param>
+        void AddAttributeExclusionFilters(string[] exclusionFilters);
+
+        /// <summary>
+        /// Is this entity excluded due to an attributeFilter
+        /// </summary>
+        /// <param name="entity">The entity to test</param>
+        /// <returns></returns>
+        bool ExcludeByAttribute(IMemberDefinition entity);
+
+        /// <summary>
+        /// Is this file excluded
+        /// </summary>
+        /// <param name="fileName">The name of the file to test</param>
+        /// <returns></returns>
+        bool ExcludeByFile(string fileName);
+
+        /// <summary>
+        /// Add test file filters
+        /// </summary>
+        /// <param name="testFilters"></param>
+        void AddTestFileFilters(string[] testFilters);
+
+        /// <summary>
+        /// Is the method an auto-implemented property get/set
+        /// </summary>
+        /// <param name="method"></param>
+        /// <returns></returns>
+        bool IsAutoImplementedProperty(MethodDefinition method);
+
+        /// <summary>
+        /// filters should be treated as regular expressions rather than wildcard
+        /// </summary>
+        bool RegExFilters { get; }
+    }
+
+}
diff --git a/main/OpenCover.Framework/OpenCover.Framework.csproj b/main/OpenCover.Framework/OpenCover.Framework.csproj
index 261685fa1..dc85c0bd5 100644
--- a/main/OpenCover.Framework/OpenCover.Framework.csproj
+++ b/main/OpenCover.Framework/OpenCover.Framework.csproj
@@ -85,11 +85,16 @@
       <Link>Properties\Version.cs</Link>
     </Compile>
     <Compile Include="Bootstrapper.cs" />
+    <Compile Include="Filtering\AssemblyAndClassFilter.cs" />
+    <Compile Include="Filtering\FilterHelper.cs" />
+    <Compile Include="Filtering\FilterType.cs" />
+    <Compile Include="Filtering\RegexFilter.cs" />
     <Compile Include="HelperExtensions.cs" />
     <Compile Include="CommandLineParser.cs" />
     <Compile Include="CommandLineParserBase.cs" />
     <Compile Include="Communication\MarshalWapper.cs" />
     <Compile Include="Communication\CommunicationManager.cs" />
+    <Compile Include="IFilter.cs" />
     <Compile Include="Manager\IManagedCommunicationBlock.cs" />
     <Compile Include="Manager\IManagedMemoryBlock.cs" />
     <Compile Include="Manager\IMemoryManager.cs" />
@@ -148,7 +153,7 @@
     <None Include="packages.config" />
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
-  <Import Project="$(SolutionDir)\.nuget\nuget.targets" />
+  <Import Project="$(SolutionDir)\.nuget\NuGet.targets" />
   <PropertyGroup>
     <PreBuildEvent>
     </PreBuildEvent>
diff --git a/main/OpenCover.Framework/Persistance/BasePersistance.cs b/main/OpenCover.Framework/Persistance/BasePersistance.cs
index f17be55a3..10d7101d3 100644
--- a/main/OpenCover.Framework/Persistance/BasePersistance.cs
+++ b/main/OpenCover.Framework/Persistance/BasePersistance.cs
@@ -393,7 +393,7 @@ from method in @class.Methods.Where(x => !x.ShouldSerializeSkippedDueTo())
 
         private static void MapFileReferences(IEnumerable<IDocumentReference> points, IDictionary<string, uint> filesDictionary)
         {
-            foreach (var pt in points)
+            foreach (var pt in points.Where(p => p.FileId == 0))
             {
                 uint fileid;
                 filesDictionary.TryGetValue(pt.Document ?? "", out fileid);
diff --git a/main/OpenCover.Gendarme.Signer/OpenCover.Gendarme.Signer.csproj b/main/OpenCover.Gendarme.Signer/OpenCover.Gendarme.Signer.csproj
index 47d214d05..c8fa3f5f2 100644
--- a/main/OpenCover.Gendarme.Signer/OpenCover.Gendarme.Signer.csproj
+++ b/main/OpenCover.Gendarme.Signer/OpenCover.Gendarme.Signer.csproj
@@ -14,6 +14,8 @@
     <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\</SolutionDir>
     <RestorePackages>true</RestorePackages>
     <TargetFrameworkProfile />
+    <ProductVersion>12.0.0</ProductVersion>
+    <SchemaVersion>2.0</SchemaVersion>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
     <PlatformTarget>AnyCPU</PlatformTarget>
@@ -67,10 +69,11 @@
     <None Include="packages.config" />
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
-  <Import Project="$(SolutionDir)\.nuget\nuget.targets" />
+  <Import Project="$(SolutionDir)\.nuget\NuGet.targets" />
   <PropertyGroup>
-    <PostBuildEvent>cd $(SolutionDir)OpenCover.Gendarme.Signer\bin\$(ConfigurationName)
+    <PostBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">cd $(SolutionDir)OpenCover.Gendarme.Signer\bin\$(ConfigurationName)
 $(SolutionDir)OpenCover.Gendarme.Signer\bin\$(ConfigurationName)\OpenCover.Gendarme.Signer.exe</PostBuildEvent>
+    <PostBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">mono OpenCover.Gendarme.Signer.exe</PostBuildEvent>
   </PropertyGroup>
   <!-- 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.
@@ -79,4 +82,4 @@ $(SolutionDir)OpenCover.Gendarme.Signer\bin\$(ConfigurationName)\OpenCover.Genda
   <Target Name="AfterBuild">
   </Target>
   -->
-</Project>
\ No newline at end of file
+</Project>
diff --git a/main/OpenCover.Gendarme.Signer/Program.cs b/main/OpenCover.Gendarme.Signer/Program.cs
index b4b2996ae..8ae24e077 100644
--- a/main/OpenCover.Gendarme.Signer/Program.cs
+++ b/main/OpenCover.Gendarme.Signer/Program.cs
@@ -11,18 +11,23 @@ namespace OpenCover.Gendarme.Signer
 {
     class Program
     {
-        private const string TargetFolder = @"..\tools\GendarmeSigned";
-        private const string SourceFolder = @"packages\Mono.Gendarme.2.11.0.20121120\tools";
-        private const string StrongNameKey = @"..\build\Version\opencover.gendarme.snk";
+		private const string GendarmeVersion = "2.11.0.20121120";
 
-        static void Main(string[] args)
-        {
+		private static readonly string GendarmeAssemblyName = string.Format("Mono.Gendarme.{0}", GendarmeVersion);
 
+        private static readonly string TargetFolder = Path.Combine("..", "tools", "GendarmeSigned");
+        private static readonly string SourceFolder = Path.Combine("packages", GendarmeAssemblyName, "tools");
+        private static readonly string StrongNameKey = Path.Combine("..", "build", "Version", "opencover.gendarme.snk");
 
-            var baseFolder = Path.Combine(Assembly.GetAssembly(typeof(Program)).Location, @"..\..\..\..");
+        static void Main(string[] args)
+        {
+			var assemblyLocation = Assembly.GetAssembly (typeof(Program)).Location;
+			var assemblyFolder = Path.GetDirectoryName(assemblyLocation);
+            var baseFolder = Path.Combine(assemblyFolder, "..", "..", "..");
 
-            if (!Directory.Exists(Path.Combine(baseFolder, TargetFolder))) 
-                Directory.CreateDirectory(Path.Combine(baseFolder, TargetFolder));
+			var targetDirectory = Path.Combine (baseFolder, TargetFolder);
+            if (!Directory.Exists(targetDirectory)) 
+				Directory.CreateDirectory (targetDirectory);
 
             if (AlreadySigned(baseFolder))
             {
@@ -39,7 +44,7 @@ static void Main(string[] args)
 
         private static bool AlreadySigned(string baseFolder)
         {
-            var frameworkAssembly = Path.Combine(baseFolder, TargetFolder + @"\Gendarme.Framework.dll");
+            var frameworkAssembly = Path.Combine(baseFolder, TargetFolder, "Gendarme.Framework.dll");
             if (File.Exists(frameworkAssembly))
             {
                 try
@@ -56,13 +61,13 @@ private static bool AlreadySigned(string baseFolder)
 
         private static void SignGendarmeRulesMaintainability(string baseFolder)
         {
-            var frameworkAssembly = Path.Combine(baseFolder, TargetFolder + @"\Gendarme.Framework.dll");
+            var frameworkAssembly = Path.Combine(baseFolder, TargetFolder, "Gendarme.Framework.dll");
             var frameworkDefinition = AssemblyDefinition.ReadAssembly(frameworkAssembly);
             var frameworkAssemblyRef = AssemblyNameReference.Parse(frameworkDefinition.Name.ToString());
 
             var key = Path.Combine(baseFolder, StrongNameKey);
-            var assembly = Path.Combine(baseFolder, SourceFolder + @"\Gendarme.Rules.Maintainability.dll");
-            var newAssembly = Path.Combine(baseFolder, TargetFolder + @"\Gendarme.Rules.Maintainability.dll");
+            var assembly = Path.Combine(baseFolder, SourceFolder, "Gendarme.Rules.Maintainability.dll");
+            var newAssembly = Path.Combine(baseFolder, TargetFolder, "Gendarme.Rules.Maintainability.dll");
 
             assembly = Path.GetFullPath(assembly);
             newAssembly = Path.GetFullPath(newAssembly);
@@ -95,8 +100,8 @@ private static void SignGendarmeRulesMaintainability(string baseFolder)
         private static void SignGendarmeFramework(string baseFolder)
         {
             var key = Path.Combine(baseFolder, StrongNameKey);
-            var assembly = Path.Combine(baseFolder, SourceFolder + @"\Gendarme.Framework.dll");
-            var newAssembly = Path.Combine(baseFolder, TargetFolder + @"\Gendarme.Framework.dll");
+            var assembly = Path.Combine(baseFolder, SourceFolder, "Gendarme.Framework.dll");
+            var newAssembly = Path.Combine(baseFolder, TargetFolder, "Gendarme.Framework.dll");
 
             assembly = Path.GetFullPath(assembly);
             newAssembly = Path.GetFullPath(newAssembly);
diff --git a/main/OpenCover.Gendarme.Signer/packages.config b/main/OpenCover.Gendarme.Signer/packages.config
index 30c70da32..afb074f2a 100644
--- a/main/OpenCover.Gendarme.Signer/packages.config
+++ b/main/OpenCover.Gendarme.Signer/packages.config
@@ -1,4 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
 <packages>
   <package id="Mono.Cecil" version="0.9.5.4" targetFramework="net45" />
-</packages>
\ No newline at end of file
+  <package id="Mono.Gendarme" version="2.11.0.20121120" targetFramework="net40" />
+</packages>
diff --git a/main/OpenCover.Integration.Test/OpenCover.Integration.Test.csproj b/main/OpenCover.Integration.Test/OpenCover.Integration.Test.csproj
index e6453b5b1..301a0d47e 100644
--- a/main/OpenCover.Integration.Test/OpenCover.Integration.Test.csproj
+++ b/main/OpenCover.Integration.Test/OpenCover.Integration.Test.csproj
@@ -69,7 +69,7 @@
     <None Include="packages.config" />
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
-  <Import Project="$(SolutionDir)\.nuget\nuget.targets" />
+  <Import Project="$(SolutionDir)\.nuget\NuGet.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">
diff --git a/main/OpenCover.Profiler/CodeCoverage.cpp b/main/OpenCover.Profiler/CodeCoverage.cpp
index 289d5dd99..d20258c90 100644
--- a/main/OpenCover.Profiler/CodeCoverage.cpp
+++ b/main/OpenCover.Profiler/CodeCoverage.cpp
@@ -10,8 +10,6 @@
 #include "NativeCallback.h"
 #include "dllmain.h"
 
-
-
 CCodeCoverage* CCodeCoverage::g_pProfiler = NULL;
 // CCodeCoverage
 
@@ -100,10 +98,10 @@ HRESULT CCodeCoverage::OpenCoverInitialise(IUnknown *pICorProfilerInfoUnk){
         return E_FAIL;
     }
 
-	FakesInitialize(pICorProfilerInfoUnk);
+    OpenCoverSupportInitialize(pICorProfilerInfoUnk);
 
 	if (m_chainedProfiler == NULL){
-		DWORD dwMask = AppendProfilerEventMask(0);
+		DWORD dwMask = AppendProfilerEventMask(0); 
 
 		COM_FAIL_MSG_RETURN_ERROR(m_profilerInfo2->SetEventMask(dwMask),
 			_T("    ::Initialize(...) => SetEventMask => 0x%X"));
@@ -206,8 +204,6 @@ HRESULT STDMETHODCALLTYPE CCodeCoverage::ModuleAttachedToAssembly(
 	if (m_chainedProfiler != NULL)
 		m_chainedProfiler->ModuleAttachedToAssembly(moduleId, assemblyId);
 
-	FakesModulesAttachedToAssembly(moduleId, assemblyId);
-
     std::wstring modulePath = GetModulePath(moduleId);
     std::wstring assemblyName = GetAssemblyName(assemblyId);
     /*ATLTRACE(_T("::ModuleAttachedToAssembly(...) => (%X => %s, %X => %s)"), 
@@ -232,7 +228,8 @@ HRESULT STDMETHODCALLTYPE CCodeCoverage::JITCompilationStarted(
 
     if (GetTokenAndModule(functionId, functionToken, moduleId, modulePath, &assemblyId))
     {
-        FakesSupportCompilation(functionId, functionToken, moduleId, assemblyId, modulePath);
+        if (OpenCoverSupportRequired(assemblyId, functionId))
+            OpenCoverSupportCompilation(functionId, functionToken, moduleId, assemblyId, modulePath);
 
         CuckooSupportCompilation(assemblyId, functionToken, moduleId);
 
@@ -270,6 +267,7 @@ HRESULT STDMETHODCALLTYPE CCodeCoverage::JITCompilationStarted(
                     CComPtr<IMethodMalloc> methodMalloc;
                     COM_FAIL_MSG_RETURN_ERROR(m_profilerInfo2->GetILFunctionBodyAllocator(moduleId, &methodMalloc),
                         _T("    ::JITCompilationStarted(...) => GetILFunctionBodyAllocator=> 0x%X"));
+
                     IMAGE_COR_ILMETHOD* pNewMethod = (IMAGE_COR_ILMETHOD*)methodMalloc->Alloc(instumentedMethod.GetMethodSize());
                     instumentedMethod.WriteMethod(pNewMethod);
                     COM_FAIL_MSG_RETURN_ERROR(m_profilerInfo2->SetILFunctionBody(moduleId, functionToken, (LPCBYTE)pNewMethod),
diff --git a/main/OpenCover.Profiler/CodeCoverage.h b/main/OpenCover.Profiler/CodeCoverage.h
index 268f51ee1..7954f2b6d 100644
--- a/main/OpenCover.Profiler/CodeCoverage.h
+++ b/main/OpenCover.Profiler/CodeCoverage.h
@@ -154,20 +154,25 @@ END_COM_MAP()
 		ModuleID moduleId);
 
 private:
-	HRESULT FakesInitialize(IUnknown *pICorProfilerInfoUnk);
-	CComPtr<ICorProfilerCallback4> m_chainedProfiler;
-	CComObject<CProfilerInfo> *m_infoHook;
-	HRESULT FakesModulesAttachedToAssembly(ModuleID moduleId, AssemblyID assemblyId);
-	mdMemberRef m_targetLoadOpenCoverProfilerInsteadRef;
-	mdMemberRef m_targetPretendWeLoadedFakesProfilerRef;
-	HRESULT GetFakesSupportRef(ModuleID moduleId, mdModuleRef &fakesSupportRef);
-	mdTypeRef m_objectTypeRef;
-	mdMethodDef m_pinvokeAttach;
-	mdMethodDef CreatePInvokeHook(IMetaDataEmit* pMetaDataEmit);
-	HRESULT FakesSupportCompilation(FunctionID functionId, mdToken functionToken, ModuleID moduleId, AssemblyID assemblyId, std::wstring &modulePath);
+    CComPtr<ICorProfilerCallback4> m_chainedProfiler;
+    CComObject<CProfilerInfo> *m_infoHook;
+
+    HRESULT OpenCoverSupportInitialize(IUnknown *pICorProfilerInfoUnk);
+    HRESULT GetOpenCoverSupportRef(ModuleID moduleId, mdModuleRef &supportRef);
+    mdMethodDef CreatePInvokeHook(ModuleID moduleId);
+    HRESULT OpenCoverSupportCompilation(FunctionID functionId, mdToken functionToken, ModuleID moduleId, AssemblyID assemblyId, std::wstring &modulePath);
 	mdMethodDef Get_CurrentDomainMethod(ModuleID moduleID);
 	HRESULT InstrumentMethodWith(ModuleID moduleId, mdToken functionToken, InstructionList &instructions);
 
+    bool OpenCoverSupportRequired(AssemblyID assemblyId, FunctionID functionId);
+
+    mdMethodDef GetFakesHelperMethodRef(TCHAR* methodName, ModuleID moduleId);
+    void InstrumentTestPlatformUtilities(FunctionID functionId, mdToken functionToken, ModuleID moduleId, AssemblyID assemblyId);
+    void InstrumentTestPlatformTestExecutor(FunctionID functionId, mdToken functionToken, ModuleID moduleId, AssemblyID assemblyId);
+
+    mdMethodDef GetUITestingHelperMethodRef(TCHAR* methodName, ModuleID moduleId);
+    void InstrumentTestToolsUITesting(FunctionID functionId, mdToken functionToken, ModuleID moduleId, AssemblyID assemblyId);
+
 	friend class CProfilerInfo;
 
 public:
diff --git a/main/OpenCover.Profiler/CodeCoverage_Cuckoo.cpp b/main/OpenCover.Profiler/CodeCoverage_Cuckoo.cpp
index 7498dab43..438eda007 100644
--- a/main/OpenCover.Profiler/CodeCoverage_Cuckoo.cpp
+++ b/main/OpenCover.Profiler/CodeCoverage_Cuckoo.cpp
@@ -213,7 +213,11 @@ HRESULT CCodeCoverage::CuckooSupportCompilation(
 	mdToken functionToken,
 	ModuleID moduleId)
 {
-	// add the bodies for our cuckoo methods when required
+    // early escape if token is not one we want
+    if ((m_cuckooCriticalToken != functionToken) && (m_cuckooSafeToken != functionToken))
+        return S_OK;
+
+	// check that we have the right module
 	if (MSCORLIB_NAME == GetAssemblyName(assemblyId))
 	{
 		if (m_cuckooCriticalToken == functionToken)
diff --git a/main/OpenCover.Profiler/CodeCoverage_FakesSupport.cpp b/main/OpenCover.Profiler/CodeCoverage_FakesSupport.cpp
deleted file mode 100644
index 6b3b8aec9..000000000
--- a/main/OpenCover.Profiler/CodeCoverage_FakesSupport.cpp
+++ /dev/null
@@ -1,407 +0,0 @@
-#include "stdafx.h"
-#include "CodeCoverage.h"
-
-#include "dllmain.h"
-
-#include "Method.h"
-#include "ProfilerInfo.h"
-
-#define TESTPLATFORM_UTILITIES_ASSEMBLY L"Microsoft.VisualStudio.TestPlatform.Utilities"
-#define DEFAULTTESTEXECUTOR_LAUNCHPROCESS L"Microsoft.VisualStudio.TestPlatform.Utilities.DefaultTestExecutorLauncher::LaunchProcess"
-#define DEFAULTTESTEXECUTOR_CTOR L"Microsoft.VisualStudio.TestPlatform.Utilities.DefaultTestExecutorLauncher::.ctor"
-
-#define TESTPLATFORM_TESTEXECUTOR_CORE_ASSEMBLY L"Microsoft.VisualStudio.TestPlatform.TestExecutor.Core"
-#define TESTEXECUTORMAIN_RUN L"Microsoft.VisualStudio.TestPlatform.TestExecutor.TestExecutorMain::Run"
-#define TESTEXECUTORMAIN_CTOR L"Microsoft.VisualStudio.TestPlatform.TestExecutor.TestExecutorMain::.ctor"
-
-#import <mscorlib.tlb> raw_interfaces_only
-using namespace mscorlib;
-
-extern COpenCoverProfilerModule _AtlModule;
-
-namespace {
-	struct __declspec(uuid("2180EC45-CF11-456E-9A76-389A4521A4BE"))
-	IFakesDomainHelper : IUnknown
-	{
-		virtual HRESULT __stdcall AddResolveEventHandler() = 0;
-	};
-}
-
-LPSAFEARRAY GetInjectedDllAsSafeArray()
-{
-	HINSTANCE hInst = _AtlModule.m_hModule;
-	HRSRC hClrHookDllRes = FindResource(hInst, MAKEINTRESOURCE(IDR_FAKESSUPPORT), L"ASSEMBLY");
-	ATLASSERT(hClrHookDllRes != NULL);
-
-	HGLOBAL hClrHookDllHGlb = LoadResource(hInst, hClrHookDllRes);
-	ATLASSERT(hClrHookDllHGlb != NULL);
-
-	DWORD dllMemorySize = SizeofResource(hInst, hClrHookDllRes);
-
-	LPBYTE lpDllData = (LPBYTE)LockResource(hClrHookDllHGlb);
-	ATLASSERT(lpDllData != NULL);
-
-	SAFEARRAYBOUND bound = { 0 };
-	bound.cElements = dllMemorySize;
-	bound.lLbound = 0;
-
-	LPBYTE lpArrayData;
-	LPSAFEARRAY lpAsmblyData = SafeArrayCreate(VT_UI1, 1, &bound);
-	ATLASSERT(lpAsmblyData != NULL);
-
-	SafeArrayAccessData(lpAsmblyData, (void**)&lpArrayData);
-	memcpy(lpArrayData, lpDllData, dllMemorySize);
-	SafeArrayUnaccessData(lpAsmblyData);
-
-	return lpAsmblyData;
-}
-
-EXTERN_C HRESULT STDAPICALLTYPE LoadFakesSupportAssembly(IUnknown *pUnk)
-{
-	ATLTRACE(_T("****LoadInjectorAssembly - Start****"));
-
-	CComPtr<_AppDomain> pAppDomain;
-	HRESULT hr = pUnk->QueryInterface(__uuidof(_AppDomain), (void**)&pAppDomain);
-	ATLASSERT(hr == S_OK);
-	LPSAFEARRAY lpAsmblyData = GetInjectedDllAsSafeArray();
-	ATLASSERT(lpAsmblyData != NULL);
-
-	CComPtr<_Assembly> pAssembly;
-	hr = pAppDomain->Load_3(lpAsmblyData, &pAssembly);
-	ATLASSERT(hr == S_OK);
-
-	SafeArrayDestroy(lpAsmblyData);
-
-	CComVariant variant;
-	hr = pAssembly->CreateInstance(W2BSTR(L"OpenCover.FakesSupport.FakesDomainHelper"), &variant);
-	ATLASSERT(hr == S_OK);
-
-	CComPtr<IFakesDomainHelper> pFakesDomainHelper;
-	hr = variant.punkVal->QueryInterface(__uuidof(IFakesDomainHelper), (void**)&pFakesDomainHelper);
-	ATLASSERT(hr == S_OK);
-
-	hr = pFakesDomainHelper->AddResolveEventHandler();
-	ATLASSERT(hr == S_OK);
-	ATLTRACE(_T("****LoadInjectorAssembly - End****"));
-
-	return S_OK;
-}
-
-HRESULT CCodeCoverage::FakesInitialize(
-	/* [in] */ IUnknown *pICorProfilerInfoUnk)
-{
-	TCHAR ext[1024] = { 0 };
-	::GetEnvironmentVariable(_T("CHAIN_EXTERNAL_PROFILER"), ext, 1024);
-	if (ext[0] != 0)
-	{
-		ATLTRACE(_T("::FakesInitialize"));
-
-		ATLTRACE(_T("    ::Initialize(...) => ext = %s"), ext);
-
-		TCHAR loc[1024] = { 0 };
-		::GetEnvironmentVariable(_T("CHAIN_EXTERNAL_PROFILER_LOCATION"), loc, 1024);
-		ATLTRACE(_T("    ::Initialize(...) => loc = %s"), loc);
-
-		CLSID clsid;
-		HRESULT hr = CLSIDFromString(T2OLE(ext), &clsid);
-		ATLASSERT(hr == S_OK);
-
-		HMODULE hmodule = LoadLibrary(loc);
-		ATLASSERT(hmodule != NULL);
-
-		BOOL(WINAPI*DllGetClassObject)(REFCLSID, REFIID, LPVOID) =
-			(BOOL(WINAPI*)(REFCLSID, REFIID, LPVOID))GetProcAddress(hmodule, "DllGetClassObject");
-		ATLASSERT(DllGetClassObject != NULL);
-
-		CComPtr<IClassFactory> pClassFactory;
-		hr = DllGetClassObject(clsid, IID_IClassFactory, &pClassFactory);
-		ATLASSERT(hr == S_OK);
-
-
-		hr = pClassFactory->CreateInstance(NULL, __uuidof(ICorProfilerCallback4), (void**)&m_chainedProfiler);
-		ATLASSERT(hr == S_OK);
-
-		HRESULT hr2 = CComObject<CProfilerInfo>::CreateInstance(&m_infoHook);
-		ULONG count = m_infoHook->AddRef();
-
-		m_infoHook->m_pProfilerHook = this;
-
-		m_infoHook->SetProfilerInfo(pICorProfilerInfoUnk);
-
-		hr = m_chainedProfiler->Initialize(m_infoHook);
-
-		ATLTRACE(_T("  ::Initialize => fakes = 0x%X"), hr);
-	}
-	
-	return S_OK;
-}
-
-HRESULT CCodeCoverage::GetFakesSupportRef(ModuleID moduleId, mdModuleRef &fakesSupportRef)
-{
-	// get interfaces
-	CComPtr<IMetaDataEmit2> metaDataEmit;
-	HRESULT hr = m_profilerInfo->GetModuleMetaData(moduleId,
-		ofRead | ofWrite, IID_IMetaDataEmit2, (IUnknown**)&metaDataEmit);
-	ATLASSERT(hr == S_OK);
-
-	CComPtr<IMetaDataAssemblyEmit> metaDataAssemblyEmit;
-	hr = metaDataEmit->QueryInterface(
-		IID_IMetaDataAssemblyEmit, (void**)&metaDataAssemblyEmit);
-	ATLASSERT(hr == S_OK);
-
-	// find injected
-	ASSEMBLYMETADATA assembly;
-	ZeroMemory(&assembly, sizeof(assembly));
-	assembly.usMajorVersion = 1;
-	assembly.usMinorVersion = 0;
-	assembly.usBuildNumber = 0;
-	assembly.usRevisionNumber = 0;
-	const BYTE pubToken[] = { 0xe1, 0x91, 0x8c, 0xac, 0x69, 0xeb, 0x73, 0xf4 };
-	hr = metaDataAssemblyEmit->DefineAssemblyRef(pubToken,
-		sizeof(pubToken), L"OpenCover.FakesSupport", &assembly, NULL, 0, 0,
-		&fakesSupportRef);
-	ATLASSERT(hr == S_OK);
-	return hr;
-}
-
-HRESULT CCodeCoverage::FakesModulesAttachedToAssembly(
-	/* [in] */ ModuleID moduleId,
-	/* [in] */ AssemblyID assemblyId)
-{
-
-	std::wstring assemblyName = GetAssemblyName(assemblyId);
-
-	if (TESTPLATFORM_UTILITIES_ASSEMBLY == GetAssemblyName(assemblyId))
-	{
-		std::wstring modulePath = GetModulePath(moduleId);
-		ATLTRACE(_T("::ModuleAttachedToAssembly(...) => (%X => %s, %X => %s)"),
-			moduleId, W2CT(modulePath.c_str()),
-			assemblyId, W2CT(assemblyName.c_str()));
-
-		m_targetLoadOpenCoverProfilerInsteadRef = 0;
-		// get reference to injected
-		mdModuleRef injectedRef;
-		HRESULT hr = GetFakesSupportRef(moduleId, injectedRef);
-		ATLASSERT(hr == S_OK);
-
-		// get interfaces
-		CComPtr<IMetaDataEmit> metaDataEmit;
-		hr = m_profilerInfo->GetModuleMetaData(moduleId,
-			ofRead | ofWrite, IID_IMetaDataEmit, (IUnknown**)&metaDataEmit);
-		ATLASSERT(hr == S_OK);
-
-		static COR_SIGNATURE methodCallSignature[] =
-		{
-			IMAGE_CEE_CS_CALLCONV_DEFAULT,
-			0x01,
-			ELEMENT_TYPE_VOID,
-			ELEMENT_TYPE_OBJECT
-		};
-
-		// get method to call
-		mdTypeRef classTypeRef;
-		hr = metaDataEmit->DefineTypeRefByName(injectedRef,
-			L"OpenCover.FakesSupport.FakesHelper", &classTypeRef);
-		ATLASSERT(hr == S_OK);
-
-		hr = metaDataEmit->DefineMemberRef(classTypeRef,
-			L"LoadOpenCoverProfilerInstead", methodCallSignature,
-			sizeof(methodCallSignature), &m_targetLoadOpenCoverProfilerInsteadRef);
-		ATLASSERT(hr == S_OK);
-
-		// get object ref
-		mdModuleRef mscorlibRef;
-		hr = GetModuleRef(moduleId, MSCORLIB_NAME, mscorlibRef);
-		ATLASSERT(hr == S_OK);
-
-		hr = metaDataEmit->DefineTypeRefByName(mscorlibRef,
-			L"System.Object", &m_objectTypeRef);
-		ATLASSERT(hr == S_OK);
-
-		m_pinvokeAttach = CreatePInvokeHook(metaDataEmit);
-	}
-
-	if (TESTPLATFORM_TESTEXECUTOR_CORE_ASSEMBLY == GetAssemblyName(assemblyId))
-	{
-		std::wstring modulePath = GetModulePath(moduleId);
-		ATLTRACE(_T("::ModuleAttachedToAssembly(...) => (%X => %s, %X => %s)"),
-			moduleId, W2CT(modulePath.c_str()),
-			assemblyId, W2CT(assemblyName.c_str()));
-
-		m_targetPretendWeLoadedFakesProfilerRef = 0;
-		// get reference to injected
-		mdModuleRef injectedRef;
-		HRESULT hr = GetFakesSupportRef(moduleId, injectedRef);
-		ATLASSERT(hr == S_OK);
-
-		// get interfaces
-		CComPtr<IMetaDataEmit> metaDataEmit;
-		hr = m_profilerInfo->GetModuleMetaData(moduleId,
-			ofRead | ofWrite, IID_IMetaDataEmit, (IUnknown**)&metaDataEmit);
-		ATLASSERT(hr == S_OK);
-
-		static COR_SIGNATURE methodCallSignature[] =
-		{
-			IMAGE_CEE_CS_CALLCONV_DEFAULT,
-			0x01,
-			ELEMENT_TYPE_VOID,
-			ELEMENT_TYPE_OBJECT
-		};
-
-		// get method to call
-		mdTypeRef classTypeRef;
-		hr = metaDataEmit->DefineTypeRefByName(injectedRef,
-			L"OpenCover.FakesSupport.FakesHelper", &classTypeRef);
-		ATLASSERT(hr == S_OK);
-
-		hr = metaDataEmit->DefineMemberRef(classTypeRef,
-			L"PretendWeLoadedFakesProfiler", methodCallSignature,
-			sizeof(methodCallSignature), &m_targetPretendWeLoadedFakesProfilerRef);
-		ATLASSERT(hr == S_OK);
-
-		// get object ref
-		mdModuleRef mscorlibRef;
-		hr = GetModuleRef(moduleId, MSCORLIB_NAME, mscorlibRef);
-		ATLASSERT(hr == S_OK);
-
-		hr = metaDataEmit->DefineTypeRefByName(mscorlibRef,
-			L"System.Object", &m_objectTypeRef);
-		ATLASSERT(hr == S_OK);
-
-		m_pinvokeAttach = CreatePInvokeHook(metaDataEmit);
-
-	}
-
-	return S_OK;
-}
-
-mdMethodDef CCodeCoverage::CreatePInvokeHook(IMetaDataEmit* pMetaDataEmit){
-
-	mdTypeDef	tkInjClass;
-
-	HRESULT hr = pMetaDataEmit->DefineTypeDef(L"__ClrProbeInjection_", tdAbstract | tdSealed, m_objectTypeRef, NULL, &tkInjClass);
-	ATLASSERT(hr == S_OK);
-
-	static BYTE sg_sigPLoadInjectorAssembly[] = {
-		0, // IMAGE_CEE_CS_CALLCONV_DEFAULT
-		1, // argument count
-		ELEMENT_TYPE_VOID, // ret = ELEMENT_TYPE_VOID
-		ELEMENT_TYPE_OBJECT
-	};
-
-	mdModuleRef	tkRefClrProbe;
-	hr = pMetaDataEmit->DefineModuleRef(L"OPENCOVER.PROFILER.DLL", &tkRefClrProbe);
-	ATLASSERT(hr == S_OK);
-
-	mdMethodDef	tkAttachDomain;
-	pMetaDataEmit->DefineMethod(tkInjClass, L"LoadFakesSupportAssembly",
-		mdStatic | mdPinvokeImpl,
-		sg_sigPLoadInjectorAssembly, sizeof(sg_sigPLoadInjectorAssembly),
-		0, 0, &tkAttachDomain
-		);
-	ATLASSERT(hr == S_OK);
-
-	BYTE tiunk = NATIVE_TYPE_IUNKNOWN;
-	mdParamDef paramDef;
-	hr = pMetaDataEmit->DefinePinvokeMap(tkAttachDomain, 0, L"LoadFakesSupportAssembly", tkRefClrProbe);
-	ATLASSERT(hr == S_OK);
-
-	hr = pMetaDataEmit->DefineParam(tkAttachDomain, 1, L"appDomain",
-		pdIn | pdHasFieldMarshal, 0, NULL, 0, &paramDef);
-	ATLASSERT(hr == S_OK);
-
-	hr = pMetaDataEmit->SetFieldMarshal(paramDef, &tiunk, 1);
-	ATLASSERT(hr == S_OK);
-
-	return tkAttachDomain;
-}
-
-HRESULT CCodeCoverage::FakesSupportCompilation(FunctionID functionId, mdToken functionToken, ModuleID moduleId, AssemblyID assemblyId, std::wstring &modulePath)
-{
-	if (TESTPLATFORM_UTILITIES_ASSEMBLY == GetAssemblyName(assemblyId))
-	{
-		std::wstring typeMethodName = GetTypeAndMethodName(functionId);
-
-		if (DEFAULTTESTEXECUTOR_CTOR == typeMethodName)
-		{
-			ATLTRACE(_T("::JITCompilationStarted(%X, ...) => %d, %X => %s"), functionId, functionToken, moduleId, W2CT(typeMethodName.c_str()));
-
-			InstructionList instructions; 
-
-			mdMethodDef getCurrentDomain = Get_CurrentDomainMethod(moduleId);
-			instructions.push_back(new Instruction(CEE_CALL, getCurrentDomain));
-			instructions.push_back(new Instruction(CEE_CALL, m_pinvokeAttach));
-
-			InstrumentMethodWith(moduleId, functionToken, instructions);
-		}
-
-		if (DEFAULTTESTEXECUTOR_LAUNCHPROCESS == typeMethodName)
-		{
-			ATLTRACE(_T("::JITCompilationStarted(%X, ...) => %d, %X => %s"), functionId, functionToken, moduleId, W2CT(typeMethodName.c_str()));
-
-			InstructionList instructions; 
-
-			instructions.push_back(new Instruction(CEE_LDARG_S, 4));
-			instructions.push_back(new Instruction(CEE_CALL, m_targetLoadOpenCoverProfilerInsteadRef));
-
-			InstrumentMethodWith(moduleId, functionToken, instructions);
-		}
-
-		return S_OK;
-	}
-
-	if (TESTPLATFORM_TESTEXECUTOR_CORE_ASSEMBLY == GetAssemblyName(assemblyId))
-	{
-		std::wstring typeMethodName = GetTypeAndMethodName(functionId);
-
-		if (TESTEXECUTORMAIN_CTOR == typeMethodName)
-		{
-			ATLTRACE(_T("::JITCompilationStarted(%X, ...) => %d, %X => %s"), functionId, functionToken, moduleId, W2CT(typeMethodName.c_str()));
-
-			InstructionList instructions;
-
-			mdMethodDef getCurrentDomain = Get_CurrentDomainMethod(moduleId);
-			instructions.push_back(new Instruction(CEE_CALL, getCurrentDomain));
-			instructions.push_back(new Instruction(CEE_CALL, m_pinvokeAttach));
-
-			InstrumentMethodWith(moduleId, functionToken, instructions);
-		}
-
-		if (TESTEXECUTORMAIN_RUN == typeMethodName)
-		{
-			ATLTRACE(_T("::JITCompilationStarted(%X, ...) => %d, %X => %s"), functionId, functionToken, moduleId, W2CT(typeMethodName.c_str()));
-
-			InstructionList instructions; // NOTE: this IL will be different for an instance method or if the local vars signature is different
-
-			instructions.push_back(new Instruction(CEE_LDARG, 0));
-			instructions.push_back(new Instruction(CEE_CALL, m_targetPretendWeLoadedFakesProfilerRef));
-
-			InstrumentMethodWith(moduleId, functionToken, instructions);
-		}
-	}
-}
-
-mdMethodDef CCodeCoverage::Get_CurrentDomainMethod(ModuleID moduleID)
-{
-	CComPtr<IMetaDataEmit> metaDataEmit;
-	COM_FAIL_MSG_RETURN_OTHER(m_profilerInfo->GetModuleMetaData(moduleID, ofWrite, IID_IMetaDataEmit, (IUnknown**)&metaDataEmit), 0,
-		_T("    ::Get_CurrentDomainMethod(ModuleID) => GetModuleMetaData => 0x%X"));
-
-	mdModuleRef mscorlibRef;
-	HRESULT hr = GetModuleRef(moduleID, MSCORLIB_NAME, mscorlibRef);
-	ATLASSERT(hr == S_OK);
-
-	mdMethodDef getCurrentDomain;
-	mdTypeDef tkAppDomain;
-	hr = metaDataEmit->DefineTypeRefByName(mscorlibRef, L"System.AppDomain", &tkAppDomain);
-	ATLASSERT(hr == S_OK);
-
-	BYTE importSig[] = { IMAGE_CEE_CS_CALLCONV_DEFAULT, 0 /*<no args*/, 0x12 /*< ret class*/, 0, 0, 0, 0, 0 };
-	ULONG l = CorSigCompressToken(tkAppDomain, importSig + 3);	//< Add the System.AppDomain token ref
-	hr = metaDataEmit->DefineMemberRef(tkAppDomain, L"get_CurrentDomain", importSig, 3 + l, &getCurrentDomain);
-	ATLASSERT(hr == S_OK);
-	return getCurrentDomain;
-}
-
-
-
diff --git a/main/OpenCover.Profiler/CodeCoverage_Support.cpp b/main/OpenCover.Profiler/CodeCoverage_Support.cpp
new file mode 100644
index 000000000..10abe8cd2
--- /dev/null
+++ b/main/OpenCover.Profiler/CodeCoverage_Support.cpp
@@ -0,0 +1,463 @@
+#include "stdafx.h"
+#include "CodeCoverage.h"
+
+#include "dllmain.h"
+
+#include "Method.h"
+#include "ProfilerInfo.h"
+
+#define TESTPLATFORM_UTILITIES_ASSEMBLY L"Microsoft.VisualStudio.TestPlatform.Utilities"
+#define DEFAULTTESTEXECUTOR_LAUNCHPROCESS L"Microsoft.VisualStudio.TestPlatform.Utilities.DefaultTestExecutorLauncher::LaunchProcess"
+#define DEFAULTTESTEXECUTOR_CTOR L"Microsoft.VisualStudio.TestPlatform.Utilities.DefaultTestExecutorLauncher::.ctor"
+
+#define TESTPLATFORM_TESTEXECUTOR_CORE_ASSEMBLY L"Microsoft.VisualStudio.TestPlatform.TestExecutor.Core"
+#define TESTEXECUTORMAIN_RUN L"Microsoft.VisualStudio.TestPlatform.TestExecutor.TestExecutorMain::Run"
+#define TESTEXECUTORMAIN_CTOR L"Microsoft.VisualStudio.TestPlatform.TestExecutor.TestExecutorMain::.ctor"
+
+#define TESTTOOLS_UITESTING_ASSEMBLY L"Microsoft.VisualStudio.TestTools.UITesting"
+#define APPLICATIONUNDERTEST_START L"Microsoft.VisualStudio.TestTools.UITesting.ApplicationUnderTest::Start"
+#define APPLICATIONUNDERTEST_CCTOR L"Microsoft.VisualStudio.TestTools.UITesting.ApplicationUnderTest::.cctor"
+
+#import <mscorlib.tlb> raw_interfaces_only
+using namespace mscorlib;
+
+extern COpenCoverProfilerModule _AtlModule;
+
+namespace {
+	struct __declspec(uuid("2180EC45-CF11-456E-9A76-389A4521A4BE"))
+	IDomainHelper : IUnknown
+	{
+		virtual HRESULT __stdcall AddResolveEventHandler() = 0;
+	};
+}
+
+LPSAFEARRAY GetInjectedDllAsSafeArray()
+{
+	HINSTANCE hInst = _AtlModule.m_hModule;
+	HRSRC hClrHookDllRes = FindResource(hInst, MAKEINTRESOURCE(IDR_SUPPORT), L"ASSEMBLY");
+	ATLASSERT(hClrHookDllRes != NULL);
+
+	HGLOBAL hClrHookDllHGlb = LoadResource(hInst, hClrHookDllRes);
+	ATLASSERT(hClrHookDllHGlb != NULL);
+
+	DWORD dllMemorySize = SizeofResource(hInst, hClrHookDllRes);
+
+	LPBYTE lpDllData = (LPBYTE)LockResource(hClrHookDllHGlb);
+	ATLASSERT(lpDllData != NULL);
+
+	SAFEARRAYBOUND bound = { 0 };
+	bound.cElements = dllMemorySize;
+	bound.lLbound = 0;
+
+	LPBYTE lpArrayData;
+	LPSAFEARRAY lpAsmblyData = SafeArrayCreate(VT_UI1, 1, &bound);
+	ATLASSERT(lpAsmblyData != NULL);
+
+	SafeArrayAccessData(lpAsmblyData, (void**)&lpArrayData);
+	memcpy(lpArrayData, lpDllData, dllMemorySize);
+	SafeArrayUnaccessData(lpAsmblyData);
+
+	return lpAsmblyData;
+}
+
+EXTERN_C HRESULT STDAPICALLTYPE LoadOpenCoverSupportAssembly(IUnknown *pUnk)
+{
+	ATLTRACE(_T("****LoadInjectorAssembly - Start****"));
+
+	CComPtr<_AppDomain> pAppDomain;
+	HRESULT hr = pUnk->QueryInterface(__uuidof(_AppDomain), (void**)&pAppDomain);
+	ATLASSERT(hr == S_OK);
+	LPSAFEARRAY lpAsmblyData = GetInjectedDllAsSafeArray();
+	ATLASSERT(lpAsmblyData != NULL);
+
+	CComPtr<_Assembly> pAssembly;
+	hr = pAppDomain->Load_3(lpAsmblyData, &pAssembly);
+	ATLASSERT(hr == S_OK);
+
+	SafeArrayDestroy(lpAsmblyData);
+
+	CComVariant variant;
+	hr = pAssembly->CreateInstance(W2BSTR(L"OpenCover.Support.DomainHelper"), &variant);
+	ATLASSERT(hr == S_OK);
+
+	CComPtr<IDomainHelper> pDomainHelper;
+    hr = variant.punkVal->QueryInterface(__uuidof(IDomainHelper), (void**)&pDomainHelper);
+	ATLASSERT(hr == S_OK);
+
+    hr = pDomainHelper->AddResolveEventHandler();
+	ATLASSERT(hr == S_OK);
+	ATLTRACE(_T("****LoadInjectorAssembly - End****"));
+
+	return S_OK;
+}
+
+HRESULT CCodeCoverage::OpenCoverSupportInitialize(
+	/* [in] */ IUnknown *pICorProfilerInfoUnk)
+{
+	TCHAR ext[1024] = { 0 };
+	::GetEnvironmentVariable(_T("CHAIN_EXTERNAL_PROFILER"), ext, 1024);
+	if (ext[0] != 0)
+	{
+		ATLTRACE(_T("::OpenCoverSupportInitialize"));
+
+		ATLTRACE(_T("    ::Initialize(...) => ext = %s"), ext);
+
+		TCHAR loc[1024] = { 0 };
+		::GetEnvironmentVariable(_T("CHAIN_EXTERNAL_PROFILER_LOCATION"), loc, 1024);
+		ATLTRACE(_T("    ::Initialize(...) => loc = %s"), loc);
+
+		CLSID clsid;
+		HRESULT hr = CLSIDFromString(T2OLE(ext), &clsid);
+		ATLASSERT(hr == S_OK);
+
+		HMODULE hmodule = LoadLibrary(loc);
+		ATLASSERT(hmodule != NULL);
+
+		BOOL(WINAPI*DllGetClassObject)(REFCLSID, REFIID, LPVOID) =
+			(BOOL(WINAPI*)(REFCLSID, REFIID, LPVOID))GetProcAddress(hmodule, "DllGetClassObject");
+		ATLASSERT(DllGetClassObject != NULL);
+
+		CComPtr<IClassFactory> pClassFactory;
+		hr = DllGetClassObject(clsid, IID_IClassFactory, &pClassFactory);
+		ATLASSERT(hr == S_OK);
+
+
+		hr = pClassFactory->CreateInstance(NULL, __uuidof(ICorProfilerCallback4), (void**)&m_chainedProfiler);
+		ATLASSERT(hr == S_OK);
+
+		HRESULT hr2 = CComObject<CProfilerInfo>::CreateInstance(&m_infoHook);
+		ULONG count = m_infoHook->AddRef();
+
+		m_infoHook->m_pProfilerHook = this;
+
+		m_infoHook->SetProfilerInfo(pICorProfilerInfoUnk);
+
+		hr = m_chainedProfiler->Initialize(m_infoHook);
+
+		ATLTRACE(_T("  ::OpenCoverSupportInitialize => fakes = 0x%X"), hr);
+	}
+	
+	return S_OK;
+}
+
+mdMethodDef CCodeCoverage::CreatePInvokeHook(ModuleID moduleId){
+
+    mdTypeDef	tkInjClass;
+
+    CComPtr<IMetaDataEmit> metaDataEmit;
+    HRESULT hr = m_profilerInfo->GetModuleMetaData(moduleId,
+        ofRead | ofWrite, IID_IMetaDataEmit, (IUnknown**)&metaDataEmit);
+    ATLASSERT(hr == S_OK);
+
+    mdModuleRef mscorlibRef;
+    hr = GetModuleRef(moduleId, MSCORLIB_NAME, mscorlibRef);
+    COM_FAIL_MSG_RETURN_ERROR(hr, _T("    ::CreatePInvokeHook(...) => GetModuleRef => 0x%X"));
+
+    mdTypeRef objectTypeRef;
+    hr = metaDataEmit->DefineTypeRefByName(mscorlibRef,
+        L"System.Object", &objectTypeRef);
+    COM_FAIL_MSG_RETURN_ERROR(hr, _T("    ::CreatePInvokeHook(...) => DefineTypeRefByName => 0x%X"));
+
+    hr = metaDataEmit->DefineTypeDef(L"__OpenCoverSupportInjection__", tdAbstract | tdSealed, objectTypeRef, NULL, &tkInjClass);
+    ATLASSERT(hr == S_OK);
+
+    static BYTE sg_sigPLoadInjectorAssembly[] = {
+        0, // IMAGE_CEE_CS_CALLCONV_DEFAULT
+        1, // argument count
+        ELEMENT_TYPE_VOID, // ret = ELEMENT_TYPE_VOID
+        ELEMENT_TYPE_OBJECT
+    };
+
+    mdModuleRef	tkRefClrProbe;
+    hr = metaDataEmit->DefineModuleRef(L"OPENCOVER.PROFILER.DLL", &tkRefClrProbe);
+    ATLASSERT(hr == S_OK);
+
+    mdMethodDef	tkAttachDomain;
+    metaDataEmit->DefineMethod(tkInjClass, L"LoadOpenCoverSupportAssembly",
+        mdStatic | mdPinvokeImpl,
+        sg_sigPLoadInjectorAssembly, sizeof(sg_sigPLoadInjectorAssembly),
+        0, 0, &tkAttachDomain
+        );
+    ATLASSERT(hr == S_OK);
+
+    BYTE tiunk = NATIVE_TYPE_IUNKNOWN;
+    mdParamDef paramDef;
+    hr = metaDataEmit->DefinePinvokeMap(tkAttachDomain, 0, L"LoadOpenCoverSupportAssembly", tkRefClrProbe);
+    ATLASSERT(hr == S_OK);
+
+    hr = metaDataEmit->DefineParam(tkAttachDomain, 1, L"appDomain",
+        pdIn | pdHasFieldMarshal, 0, NULL, 0, &paramDef);
+    ATLASSERT(hr == S_OK);
+
+    hr = metaDataEmit->SetFieldMarshal(paramDef, &tiunk, 1);
+    ATLASSERT(hr == S_OK);
+
+    return tkAttachDomain;
+}
+
+mdMethodDef CCodeCoverage::Get_CurrentDomainMethod(ModuleID moduleID)
+{
+    CComPtr<IMetaDataEmit> metaDataEmit;
+    COM_FAIL_MSG_RETURN_OTHER(m_profilerInfo->GetModuleMetaData(moduleID, ofWrite, IID_IMetaDataEmit, (IUnknown**)&metaDataEmit), 0,
+        _T("    ::Get_CurrentDomainMethod(ModuleID) => GetModuleMetaData => 0x%X"));
+
+    mdModuleRef mscorlibRef;
+    HRESULT hr = GetModuleRef(moduleID, MSCORLIB_NAME, mscorlibRef);
+    ATLASSERT(hr == S_OK);
+
+    mdMethodDef getCurrentDomain;
+    mdTypeDef tkAppDomain;
+    hr = metaDataEmit->DefineTypeRefByName(mscorlibRef, L"System.AppDomain", &tkAppDomain);
+    ATLASSERT(hr == S_OK);
+
+    BYTE importSig[] = { IMAGE_CEE_CS_CALLCONV_DEFAULT, 0 /*<no args*/, 0x12 /*< ret class*/, 0, 0, 0, 0, 0 };
+    ULONG l = CorSigCompressToken(tkAppDomain, importSig + 3);	//< Add the System.AppDomain token ref
+    hr = metaDataEmit->DefineMemberRef(tkAppDomain, L"get_CurrentDomain", importSig, 3 + l, &getCurrentDomain);
+    ATLASSERT(hr == S_OK);
+    return getCurrentDomain;
+}
+
+HRESULT CCodeCoverage::GetOpenCoverSupportRef(ModuleID moduleId, mdModuleRef &supportRef)
+{
+	// get interfaces
+	CComPtr<IMetaDataEmit2> metaDataEmit;
+	HRESULT hr = m_profilerInfo->GetModuleMetaData(moduleId,
+		ofRead | ofWrite, IID_IMetaDataEmit2, (IUnknown**)&metaDataEmit);
+	ATLASSERT(hr == S_OK);
+
+	CComPtr<IMetaDataAssemblyEmit> metaDataAssemblyEmit;
+	hr = metaDataEmit->QueryInterface(
+		IID_IMetaDataAssemblyEmit, (void**)&metaDataAssemblyEmit);
+	ATLASSERT(hr == S_OK);
+
+	// find injected
+	ASSEMBLYMETADATA assembly;
+	ZeroMemory(&assembly, sizeof(assembly));
+	assembly.usMajorVersion = 1;
+	assembly.usMinorVersion = 0;
+	assembly.usBuildNumber = 0;
+	assembly.usRevisionNumber = 0;
+	const BYTE pubToken[] = { 0xe1, 0x91, 0x8c, 0xac, 0x69, 0xeb, 0x73, 0xf4 };
+	hr = metaDataAssemblyEmit->DefineAssemblyRef(pubToken,
+		sizeof(pubToken), L"OpenCover.Support", &assembly, NULL, 0, 0,
+		&supportRef);
+	ATLASSERT(hr == S_OK);
+	return hr;
+}
+
+HRESULT CCodeCoverage::OpenCoverSupportCompilation(FunctionID functionId, mdToken functionToken, ModuleID moduleId, AssemblyID assemblyId, std::wstring &modulePath)
+{
+    InstrumentTestPlatformUtilities(functionId, functionToken, moduleId, assemblyId);
+    InstrumentTestPlatformTestExecutor(functionId, functionToken, moduleId, assemblyId);
+    InstrumentTestToolsUITesting(functionId, functionToken, moduleId, assemblyId);
+
+    return S_OK;
+}
+
+bool CCodeCoverage::OpenCoverSupportRequired(AssemblyID assemblyId, FunctionID functionId)
+{
+    std::wstring assemblyName = GetAssemblyName(assemblyId);
+    if ((TESTPLATFORM_UTILITIES_ASSEMBLY != assemblyName) &&
+        (TESTPLATFORM_TESTEXECUTOR_CORE_ASSEMBLY != assemblyName) &&
+        (TESTTOOLS_UITESTING_ASSEMBLY != assemblyName))
+        return false;
+
+    std::wstring typeMethodName = GetTypeAndMethodName(functionId);
+    if ((TESTPLATFORM_UTILITIES_ASSEMBLY == assemblyName) &&
+        (DEFAULTTESTEXECUTOR_CTOR != typeMethodName) &&
+        (DEFAULTTESTEXECUTOR_LAUNCHPROCESS != typeMethodName))
+        return false;
+
+    if ((TESTPLATFORM_TESTEXECUTOR_CORE_ASSEMBLY == assemblyName) &&
+        (TESTEXECUTORMAIN_CTOR != typeMethodName) &&
+        (TESTEXECUTORMAIN_RUN != typeMethodName))
+        return false;
+
+    if ((TESTTOOLS_UITESTING_ASSEMBLY == assemblyName) &&
+        (APPLICATIONUNDERTEST_CCTOR != typeMethodName) &&
+        (APPLICATIONUNDERTEST_START != typeMethodName))
+        return false;
+
+    return true;
+}
+
+mdMethodDef CCodeCoverage::GetFakesHelperMethodRef(TCHAR* methodName, ModuleID moduleId){
+    // get reference to injected
+    mdModuleRef injectedRef;
+    HRESULT hr = GetOpenCoverSupportRef(moduleId, injectedRef);
+    ATLASSERT(hr == S_OK);
+
+    // get interfaces
+    CComPtr<IMetaDataEmit> metaDataEmit;
+    hr = m_profilerInfo->GetModuleMetaData(moduleId,
+        ofRead | ofWrite, IID_IMetaDataEmit, (IUnknown**)&metaDataEmit);
+    ATLASSERT(hr == S_OK);
+
+    static COR_SIGNATURE methodCallSignature[] =
+    {
+        IMAGE_CEE_CS_CALLCONV_DEFAULT,
+        0x01,
+        ELEMENT_TYPE_VOID,
+        ELEMENT_TYPE_OBJECT
+    };
+
+    // get method to call
+    mdTypeRef classTypeRef;
+    hr = metaDataEmit->DefineTypeRefByName(injectedRef,
+        L"OpenCover.Support.Fakes.FakesHelper", &classTypeRef);
+    ATLASSERT(hr == S_OK);
+
+    // L"LoadOpenCoverProfilerInstead"
+    mdMemberRef memberRef;
+    hr = metaDataEmit->DefineMemberRef(classTypeRef,
+        T2W(methodName), methodCallSignature,
+        sizeof(methodCallSignature), &memberRef);
+    ATLASSERT(hr == S_OK);
+
+    return memberRef;
+}
+
+mdMethodDef CCodeCoverage::GetUITestingHelperMethodRef(TCHAR* methodName, ModuleID moduleId){
+    // get reference to injected
+    mdModuleRef injectedRef;
+    HRESULT hr = GetOpenCoverSupportRef(moduleId, injectedRef);
+    ATLASSERT(hr == S_OK);
+
+    // get interfaces
+    CComPtr<IMetaDataEmit> metaDataEmit;
+    hr = m_profilerInfo->GetModuleMetaData(moduleId,
+        ofRead | ofWrite, IID_IMetaDataEmit, (IUnknown**)&metaDataEmit);
+    ATLASSERT(hr == S_OK);
+
+    static COR_SIGNATURE methodCallSignature[] =
+    {
+        IMAGE_CEE_CS_CALLCONV_DEFAULT,
+        0x01,
+        ELEMENT_TYPE_VOID,
+        ELEMENT_TYPE_OBJECT
+    };
+
+    // get method to call
+    mdTypeRef classTypeRef;
+    hr = metaDataEmit->DefineTypeRefByName(injectedRef,
+        L"OpenCover.Support.UITesting.UITestingHelper", &classTypeRef);
+    ATLASSERT(hr == S_OK);
+
+    mdMemberRef memberRef;
+    hr = metaDataEmit->DefineMemberRef(classTypeRef,
+        T2W(methodName), methodCallSignature,
+        sizeof(methodCallSignature), &memberRef);
+    ATLASSERT(hr == S_OK);
+
+    return memberRef;
+}
+
+void CCodeCoverage::InstrumentTestToolsUITesting(FunctionID functionId, mdToken functionToken, ModuleID moduleId, AssemblyID assemblyId)
+{
+    if (TESTTOOLS_UITESTING_ASSEMBLY == GetAssemblyName(assemblyId))
+    {
+        std::wstring typeMethodName = GetTypeAndMethodName(functionId);
+
+        if (APPLICATIONUNDERTEST_CCTOR == typeMethodName)
+        {
+            ATLTRACE(_T("::InstrumentTestToolsUITesting(%X, ...) => %d, %X => %s"), functionId, functionToken, moduleId, W2CT(typeMethodName.c_str()));
+
+            mdMethodDef invokeAttach = CreatePInvokeHook(moduleId);
+            InstructionList instructions;
+
+            mdMethodDef getCurrentDomain = Get_CurrentDomainMethod(moduleId);
+            instructions.push_back(new Instruction(CEE_CALL, getCurrentDomain));
+            instructions.push_back(new Instruction(CEE_CALL, invokeAttach));
+
+            InstrumentMethodWith(moduleId, functionToken, instructions);
+        }
+
+        if (APPLICATIONUNDERTEST_START == typeMethodName)
+        {
+            ATLTRACE(_T("::InstrumentTestToolsUITesting(%X, ...) => %d, %X => %s"), functionId, functionToken, moduleId, W2CT(typeMethodName.c_str()));
+
+            mdMemberRef memberRef = GetUITestingHelperMethodRef(_T("PropagateRequiredEnvironmentVariables"), moduleId);
+            InstructionList instructions;
+
+            instructions.push_back(new Instruction(CEE_LDARG, 1));
+            instructions.push_back(new Instruction(CEE_CALL, memberRef));
+
+            InstrumentMethodWith(moduleId, functionToken, instructions);
+        }
+    }
+}
+
+void CCodeCoverage::InstrumentTestPlatformUtilities(FunctionID functionId, mdToken functionToken, ModuleID moduleId, AssemblyID assemblyId)
+{
+    if (TESTPLATFORM_UTILITIES_ASSEMBLY == GetAssemblyName(assemblyId))
+    {
+        std::wstring typeMethodName = GetTypeAndMethodName(functionId);
+
+        if (DEFAULTTESTEXECUTOR_CTOR == typeMethodName)
+        {
+            ATLTRACE(_T("::InstrumentTestPlatformUtilities(%X, ...) => %d, %X => %s"), functionId, functionToken, moduleId, W2CT(typeMethodName.c_str()));
+
+            mdMethodDef invokeAttach = CreatePInvokeHook(moduleId);
+            InstructionList instructions;
+
+            mdMethodDef getCurrentDomain = Get_CurrentDomainMethod(moduleId);
+            instructions.push_back(new Instruction(CEE_CALL, getCurrentDomain));
+            instructions.push_back(new Instruction(CEE_CALL, invokeAttach));
+
+            InstrumentMethodWith(moduleId, functionToken, instructions);
+        }
+
+        if (DEFAULTTESTEXECUTOR_LAUNCHPROCESS == typeMethodName)
+        {
+            ATLTRACE(_T("::InstrumentTestPlatformUtilities(%X, ...) => %d, %X => %s"), functionId, functionToken, moduleId, W2CT(typeMethodName.c_str()));
+
+            mdMemberRef memberRef = GetFakesHelperMethodRef(_T("LoadOpenCoverProfilerInstead"), moduleId);
+            InstructionList instructions;
+
+            instructions.push_back(new Instruction(CEE_LDARG_S, 4));
+            instructions.push_back(new Instruction(CEE_CALL, memberRef));
+
+            InstrumentMethodWith(moduleId, functionToken, instructions);
+        }
+    }
+}
+
+void CCodeCoverage::InstrumentTestPlatformTestExecutor(FunctionID functionId, mdToken functionToken, ModuleID moduleId, AssemblyID assemblyId)
+{
+    if (TESTPLATFORM_TESTEXECUTOR_CORE_ASSEMBLY == GetAssemblyName(assemblyId))
+    {
+        std::wstring typeMethodName = GetTypeAndMethodName(functionId);
+
+        if (TESTEXECUTORMAIN_CTOR == typeMethodName)
+        {
+            ATLTRACE(_T("::InstrumentTestPlatformTestExecutor(%X, ...) => %d, %X => %s"), functionId, functionToken, moduleId, W2CT(typeMethodName.c_str()));
+
+            mdMethodDef invokeAttach = CreatePInvokeHook(moduleId);
+
+            InstructionList instructions;
+
+            mdMethodDef getCurrentDomain = Get_CurrentDomainMethod(moduleId);
+            instructions.push_back(new Instruction(CEE_CALL, getCurrentDomain));
+            instructions.push_back(new Instruction(CEE_CALL, invokeAttach));
+
+            InstrumentMethodWith(moduleId, functionToken, instructions);
+        }
+
+        if (TESTEXECUTORMAIN_RUN == typeMethodName)
+        {
+            ATLTRACE(_T("::InstrumentTestPlatformTestExecutor(%X, ...) => %d, %X => %s"), functionId, functionToken, moduleId, W2CT(typeMethodName.c_str()));
+
+            mdMemberRef memberRef = GetFakesHelperMethodRef(_T("PretendWeLoadedFakesProfiler"), moduleId);
+            InstructionList instructions;
+
+            instructions.push_back(new Instruction(CEE_LDARG, 0));
+            instructions.push_back(new Instruction(CEE_CALL, memberRef));
+
+            InstrumentMethodWith(moduleId, functionToken, instructions);
+        }
+    }
+}
+
+
+
+
diff --git a/main/OpenCover.Profiler/OpenCover.Profiler.def b/main/OpenCover.Profiler/OpenCover.Profiler.def
index 4d4c144bd..bd72a2b6b 100644
--- a/main/OpenCover.Profiler/OpenCover.Profiler.def
+++ b/main/OpenCover.Profiler/OpenCover.Profiler.def
@@ -9,4 +9,4 @@ EXPORTS
 	DllUnregisterServer	PRIVATE
 	DllInstall		PRIVATE
 
-	LoadFakesSupportAssembly					@10
+	LoadOpenCoverSupportAssembly					@10
diff --git a/main/OpenCover.Profiler/OpenCover.Profiler.rc b/main/OpenCover.Profiler/OpenCover.Profiler.rc
index a3ae169bb..25ece99d5 100644
Binary files a/main/OpenCover.Profiler/OpenCover.Profiler.rc and b/main/OpenCover.Profiler/OpenCover.Profiler.rc differ
diff --git a/main/OpenCover.Profiler/OpenCover.Profiler.vcxproj b/main/OpenCover.Profiler/OpenCover.Profiler.vcxproj
index 4e6be3836..aae9a7147 100644
--- a/main/OpenCover.Profiler/OpenCover.Profiler.vcxproj
+++ b/main/OpenCover.Profiler/OpenCover.Profiler.vcxproj
@@ -245,8 +245,8 @@
     <ClCompile Include="CodeCoverage.cpp" />
     <ClCompile Include="CodeCoverage_Callback.cpp" />
     <ClCompile Include="CodeCoverage_Cuckoo.cpp" />
-    <ClCompile Include="CodeCoverage_FakesSupport.cpp" />
     <ClCompile Include="CodeCoverage_ProfilerInfo.cpp" />
+    <ClCompile Include="CodeCoverage_Support.cpp" />
     <ClCompile Include="CoverageInstrumentation.cpp" />
     <ClCompile Include="dllmain.cpp">
       <CompileAsManaged Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">false</CompileAsManaged>
@@ -334,7 +334,7 @@
     <ResourceCompile Include="OpenCover.Profiler.rc" />
   </ItemGroup>
   <ItemGroup>
-    <None Include="..\bin\Common\OpenCover.FakesSupport.dll" />
+    <None Include="..\bin\Common\OpenCover.Support.dll" />
     <None Include="CodeCoverage.rgs" />
     <None Include="OpenCover.Profiler.def" />
     <None Include="OpenCover.Profiler.rgs" />
diff --git a/main/OpenCover.Profiler/OpenCover.Profiler.vcxproj.filters b/main/OpenCover.Profiler/OpenCover.Profiler.vcxproj.filters
index 8cdc8a5d9..4eef43a2a 100644
--- a/main/OpenCover.Profiler/OpenCover.Profiler.vcxproj.filters
+++ b/main/OpenCover.Profiler/OpenCover.Profiler.vcxproj.filters
@@ -73,10 +73,10 @@
     <ClCompile Include="ProfilerInfo.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="CodeCoverage_FakesSupport.cpp">
+    <ClCompile Include="CodeCoverage_Cuckoo.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="CodeCoverage_Cuckoo.cpp">
+    <ClCompile Include="CodeCoverage_Support.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
   </ItemGroup>
@@ -163,7 +163,7 @@
     <None Include="CodeCoverage.rgs">
       <Filter>Resource Files</Filter>
     </None>
-    <None Include="..\bin\Common\OpenCover.FakesSupport.dll" />
+    <None Include="..\bin\Common\OpenCover.Support.dll" />
   </ItemGroup>
   <ItemGroup>
     <Midl Include="OpenCoverProfiler.idl">
diff --git a/main/OpenCover.Profiler/Resource.h b/main/OpenCover.Profiler/Resource.h
index ae9113f57..251fd8209 100644
Binary files a/main/OpenCover.Profiler/Resource.h and b/main/OpenCover.Profiler/Resource.h differ
diff --git a/main/OpenCover.Specs/OpenCover.Specs.csproj b/main/OpenCover.Specs/OpenCover.Specs.csproj
index 51bf285af..8fbbdd75a 100644
--- a/main/OpenCover.Specs/OpenCover.Specs.csproj
+++ b/main/OpenCover.Specs/OpenCover.Specs.csproj
@@ -68,7 +68,7 @@
     </None>
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
-  <Import Project="$(SolutionDir)\.nuget\nuget.targets" />
+  <Import Project="$(SolutionDir)\.nuget\NuGet.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">
diff --git a/main/OpenCover.Specs/Steps/PackagingSteps.cs b/main/OpenCover.Specs/Steps/PackagingSteps.cs
index d3596dbf7..927cd0f1d 100644
--- a/main/OpenCover.Specs/Steps/PackagingSteps.cs
+++ b/main/OpenCover.Specs/Steps/PackagingSteps.cs
@@ -29,7 +29,7 @@ public void DeleteMsiFolder()
 
         private static dynamic GetTargetPackage(string folder, string ext)
         {
-            var files = Directory.EnumerateFiles(Path.Combine(Environment.CurrentDirectory, @"..\..\..\bin", folder), string.Format("*.{0}", ext));
+            var files = Directory.EnumerateFiles(Path.Combine(Environment.CurrentDirectory, "..", "..", "..", "bin", folder), string.Format("*.{0}", ext));
 
             var target = files.Select(f => Regex.Match(f, string.Format(@".*\.(?<version>\d+\.\d+\.\d+)(-rc(?<revision>\d+))?\.{0}", ext)))
                  .Select(m => new { File = m.Value, Version = m.Groups["version"].Value, Revision = m.Groups["revision"].Value })
diff --git a/main/OpenCover.Support/DomainHelper.cs b/main/OpenCover.Support/DomainHelper.cs
new file mode 100644
index 000000000..2eb6c62aa
--- /dev/null
+++ b/main/OpenCover.Support/DomainHelper.cs
@@ -0,0 +1,19 @@
+using System;
+using System.Reflection;
+
+namespace OpenCover.Support
+{
+    public class DomainHelper : IDomainHelper
+    {
+        public void AddResolveEventHandler()
+        {
+            AppDomain.CurrentDomain.AssemblyResolve -= CurrentDomain_AssemblyResolve;
+            AppDomain.CurrentDomain.AssemblyResolve += CurrentDomain_AssemblyResolve;
+        }
+
+        static Assembly CurrentDomain_AssemblyResolve(object sender, ResolveEventArgs args)
+        {
+            return args.Name.StartsWith("OpenCover.Support, Version=1.0.0.0") ? Assembly.GetExecutingAssembly() : null;
+        }
+    }
+}
\ No newline at end of file
diff --git a/main/OpenCover.FakesSupport/FakesHelper.cs b/main/OpenCover.Support/Fakes/FakesHelper.cs
similarity index 68%
rename from main/OpenCover.FakesSupport/FakesHelper.cs
rename to main/OpenCover.Support/Fakes/FakesHelper.cs
index 5ca9438c1..bc8506f8b 100644
--- a/main/OpenCover.FakesSupport/FakesHelper.cs
+++ b/main/OpenCover.Support/Fakes/FakesHelper.cs
@@ -2,7 +2,7 @@
 using System.Collections.Generic;
 using Microsoft.Win32;
 
-namespace OpenCover.FakesSupport
+namespace OpenCover.Support.Fakes
 {
     public class FakesHelper
     {
@@ -10,6 +10,7 @@ public class FakesHelper
         private const string CorProfiler = "COR_PROFILER";
         private const string ChainExternalProfiler = "CHAIN_EXTERNAL_PROFILER";
         private const string ChainExternalProfilerLocation = "CHAIN_EXTERNAL_PROFILER_LOCATION";
+        private const string OpenCoverProfilerGuid = "{1542C21D-80C3-45E6-A56C-A9C1E4BEB7B8}";
 
         public static void LoadOpenCoverProfilerInstead(object data)
         {
@@ -20,6 +21,9 @@ public static void LoadOpenCoverProfilerInstead(object data)
             if (!dict.ContainsKey(CorEnableProfiling) || dict[CorEnableProfiling] != "1") 
                 return;
 
+            if (!dict.ContainsKey(CorProfiler) || dict[CorProfiler] == OpenCoverProfilerGuid)
+                return;
+
             var currentProfiler = dict[CorProfiler];
             var key = Registry.ClassesRoot.OpenSubKey(string.Format("CLSID\\{0}\\InprocServer32", currentProfiler));
             if (key == null)
@@ -29,21 +33,17 @@ public static void LoadOpenCoverProfilerInstead(object data)
             dict[ChainExternalProfilerLocation] = location;
 
             dict[ChainExternalProfiler] = currentProfiler;
-            dict[CorProfiler] = "{1542C21D-80C3-45E6-A56C-A9C1E4BEB7B8}";
+            dict[CorProfiler] = OpenCoverProfilerGuid;
         }
 
         public static void PretendWeLoadedFakesProfiler(object data)
         {
-            //var args = data as string[];
-            //foreach (var arg in args ?? new string[0])
-            //{
-            //    Console.WriteLine(arg);
-            //}
-
             var enabled = Environment.GetEnvironmentVariable(CorEnableProfiling);
-            if (enabled == "1")
+            var profiler = Environment.GetEnvironmentVariable(CorEnableProfiling) ?? string.Empty;
+            var external = Environment.GetEnvironmentVariable(ChainExternalProfiler);
+            if (enabled == "1" && !string.IsNullOrEmpty(external) && 
+                !profiler.Equals(OpenCoverProfilerGuid, StringComparison.InvariantCultureIgnoreCase))
             {
-                var external = Environment.GetEnvironmentVariable(ChainExternalProfiler);
                 Environment.SetEnvironmentVariable(CorProfiler, external);
             }
         }
diff --git a/main/OpenCover.FakesSupport/IFakesDomainHelper.cs b/main/OpenCover.Support/IDomainHelper.cs
similarity index 77%
rename from main/OpenCover.FakesSupport/IFakesDomainHelper.cs
rename to main/OpenCover.Support/IDomainHelper.cs
index c2c710e29..72983c9df 100644
--- a/main/OpenCover.FakesSupport/IFakesDomainHelper.cs
+++ b/main/OpenCover.Support/IDomainHelper.cs
@@ -1,11 +1,11 @@
 using System.Runtime.InteropServices;
 
-namespace OpenCover.FakesSupport
+namespace OpenCover.Support
 {
     [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
     [Guid("2180EC45-CF11-456E-9A76-389A4521A4BE")]
     [ComVisible(true)]
-    public interface IFakesDomainHelper
+    public interface IDomainHelper
     {
         [ComVisible(true)]
         void AddResolveEventHandler();
diff --git a/main/OpenCover.FakesSupport/OpenCover.FakesSupport.csproj b/main/OpenCover.Support/OpenCover.Support.csproj
similarity index 82%
rename from main/OpenCover.FakesSupport/OpenCover.FakesSupport.csproj
rename to main/OpenCover.Support/OpenCover.Support.csproj
index f9005a274..985a6cc11 100644
--- a/main/OpenCover.FakesSupport/OpenCover.FakesSupport.csproj
+++ b/main/OpenCover.Support/OpenCover.Support.csproj
@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+<Project ToolsVersion="4.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>
@@ -7,8 +7,8 @@
     <ProjectGuid>{31B0FAA6-A63F-46FC-96EE-697235DA2BB0}</ProjectGuid>
     <OutputType>Library</OutputType>
     <AppDesignerFolder>Properties</AppDesignerFolder>
-    <RootNamespace>OpenCover.FakesSupport</RootNamespace>
-    <AssemblyName>OpenCover.FakesSupport</AssemblyName>
+    <RootNamespace>OpenCover.Support</RootNamespace>
+    <AssemblyName>OpenCover.Support</AssemblyName>
     <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
     <FileAlignment>512</FileAlignment>
     <TargetFrameworkProfile />
@@ -34,7 +34,7 @@
     <SignAssembly>true</SignAssembly>
   </PropertyGroup>
   <PropertyGroup>
-    <AssemblyOriginatorKeyFile>OpenCover.FakesSupport.snk</AssemblyOriginatorKeyFile>
+    <AssemblyOriginatorKeyFile>OpenCover.Support.snk</AssemblyOriginatorKeyFile>
   </PropertyGroup>
   <ItemGroup>
     <Reference Include="System" />
@@ -49,13 +49,14 @@
     <Compile Include="..\..\build\Version\GlobalAssemblyInfo.cs">
       <Link>Properties\GlobalAssemblyInfo.cs</Link>
     </Compile>
-    <Compile Include="FakesHelper.cs" />
-    <Compile Include="FakesDomainHelper.cs" />
-    <Compile Include="IFakesDomainHelper.cs" />
+    <Compile Include="DomainHelper.cs" />
+    <Compile Include="Fakes\FakesHelper.cs" />
+    <Compile Include="IDomainHelper.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="UITesting\UITestingHelper.cs" />
   </ItemGroup>
   <ItemGroup>
-    <None Include="OpenCover.FakesSupport.snk" />
+    <None Include="OpenCover.Support.snk" />
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
diff --git a/main/OpenCover.FakesSupport/OpenCover.FakesSupport.snk b/main/OpenCover.Support/OpenCover.Support.snk
similarity index 100%
rename from main/OpenCover.FakesSupport/OpenCover.FakesSupport.snk
rename to main/OpenCover.Support/OpenCover.Support.snk
diff --git a/main/OpenCover.FakesSupport/Properties/AssemblyInfo.cs b/main/OpenCover.Support/Properties/AssemblyInfo.cs
similarity index 100%
rename from main/OpenCover.FakesSupport/Properties/AssemblyInfo.cs
rename to main/OpenCover.Support/Properties/AssemblyInfo.cs
diff --git a/main/OpenCover.Support/UITesting/UITestingHelper.cs b/main/OpenCover.Support/UITesting/UITestingHelper.cs
new file mode 100644
index 000000000..19fe3f99d
--- /dev/null
+++ b/main/OpenCover.Support/UITesting/UITestingHelper.cs
@@ -0,0 +1,29 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Text;
+
+namespace OpenCover.Support.UITesting
+{
+// ReSharper disable once InconsistentNaming
+    public class UITestingHelper
+    {
+        public static void PropagateRequiredEnvironmentVariables(object data)
+        {
+            var pi = data as ProcessStartInfo;
+            if (pi == null) return;
+            foreach (var ev in from DictionaryEntry ev in Environment.GetEnvironmentVariables()
+                where (ev.Key.ToString().StartsWith("COR", StringComparison.InvariantCultureIgnoreCase) ||
+                      ev.Key.ToString().StartsWith("OPEN", StringComparison.InvariantCultureIgnoreCase) ||
+                      ev.Key.ToString().StartsWith("CHAIN", StringComparison.InvariantCultureIgnoreCase))
+                where !pi.EnvironmentVariables.Cast<DictionaryEntry>()
+                    .Any(e => e.Key.ToString().Equals(ev.Key.ToString(), StringComparison.InvariantCultureIgnoreCase))
+                select ev)
+            {
+                pi.EnvironmentVariables[ev.Key.ToString()] = ev.Value.ToString();
+            }
+        }
+    }
+}
diff --git a/main/OpenCover.Test/Filtering/FilterTypeTest.cs b/main/OpenCover.Test/Filtering/FilterTypeTest.cs
new file mode 100644
index 000000000..10407faa8
--- /dev/null
+++ b/main/OpenCover.Test/Filtering/FilterTypeTest.cs
@@ -0,0 +1,28 @@
+using System;
+using NUnit.Framework;
+using OpenCover.Framework.Filtering;
+
+namespace OpenCover.Test.Filtering
+{
+    [TestFixture]
+    public class FilterTypeTest
+    {
+        [Test]
+        public void ParseFilterType_Plus_Is_Inclusion()
+        {
+            Assert.That("+".ParseFilterType(), Is.EqualTo(FilterType.Inclusion));
+        }
+
+        [Test]
+        public void ParseFilterType_Minus_Is_Exclusion()
+        {
+            Assert.That("-".ParseFilterType(), Is.EqualTo(FilterType.Exclusion));
+        }
+
+        [Test]
+        public void ParseFilterType_Unknown_Throws()
+        {
+            Assert.Throws(typeof(ArgumentException), () => "/".ParseFilterType());
+        }
+    }
+}
diff --git a/main/OpenCover.Test/Framework/FilterTests.cs b/main/OpenCover.Test/Framework/FilterTests.cs
index 85d353a87..6c474f6b2 100644
--- a/main/OpenCover.Test/Framework/FilterTests.cs
+++ b/main/OpenCover.Test/Framework/FilterTests.cs
@@ -1,10 +1,12 @@
 using System;
+using System.Collections.Generic;
 using System.Linq;
 using Mono.Cecil;
 using Mono.Collections.Generic;
 using Moq;
 using NUnit.Framework;
 using OpenCover.Framework;
+using OpenCover.Framework.Filtering;
 
 namespace OpenCover.Test.Framework
 {
@@ -70,7 +72,7 @@ public class AssemblyClassData
                                                                           FilterTypeResult = FilterType.Exclusion, 
                                                                       }
                                                               };
-#pragma warning restore 169   
+#pragma warning restore 169
         #endregion
 
         [Test]
@@ -81,8 +83,8 @@ public void AddFilter_ThrowsException_WhenInvalid_AssemblyClassPair(
             var filter = new Filter();
 
             // act/assert
-            Assert.Catch<InvalidOperationException>(() => filter.AddFilter(assemblyClassPair), 
-                "'{0}' should be invalid", assemblyClassPair);     
+            Assert.Catch<InvalidOperationException>(() => filter.AddFilter(assemblyClassPair),
+                "'{0}' should be invalid", assemblyClassPair);
         }
 
         [Test]
@@ -96,21 +98,21 @@ public void AddFilter_Adds_ValidAssemblyClassPair(
             filter.AddFilter(assemblyClassPair.AssemblyClass);
 
             // assert
-            Assert.AreEqual(1, assemblyClassPair.FilterTypeResult == FilterType.Inclusion ? 
-                filter.InclusionFilter.Count : filter.ExclusionFilter.Count);
+            Assert.AreEqual(1, assemblyClassPair.FilterTypeResult == FilterType.Inclusion ?
+                filter.InclusionFilters.Count : filter.ExclusionFilters.Count);
 
             Assert.AreEqual(assemblyClassPair.AssemblyResult, assemblyClassPair.FilterTypeResult == FilterType.Inclusion ?
-                filter.InclusionFilter[0].Key : filter.ExclusionFilter[0].Key);
+                filter.InclusionFilters[0].AssemblyName : filter.ExclusionFilters[0].AssemblyName);
 
             Assert.AreEqual(assemblyClassPair.ClassResult, assemblyClassPair.FilterTypeResult == FilterType.Inclusion ?
-                filter.InclusionFilter[0].Value : filter.ExclusionFilter[0].Value);
+                filter.InclusionFilters[0].ClassName : filter.ExclusionFilters[0].ClassName);
         }
 
-        #region Test Data or UseAssembly tests
+        #region Test Data for UseAssembly tests
 
         public class UseAssemblyData
         {
-            public string[] Filters { get; set; }
+            public List<string> Filters { get; set; }
             public string Assembly { get; set; }
             public bool ExpectedResult { get; set; }
         }
@@ -119,43 +121,43 @@ public class UseAssemblyData
                                                          {
                                                              new UseAssemblyData
                                                                  {
-                                                                     Filters = new string[0],
+                                                                     Filters = new List<string>(0),
                                                                      Assembly = "System.Debug",
                                                                      ExpectedResult = false
                                                                  },
                                                                  new UseAssemblyData
                                                                  {
-                                                                     Filters = new [] {"-[System.*]R*"},
+                                                                     Filters = new List<string> {"-[System.*]R*"},
                                                                      Assembly = "System.Debug",
                                                                      ExpectedResult = true
                                                                  },
                                                                  new UseAssemblyData
                                                                  {
-                                                                     Filters = new [] {"-[System.*]*"},
+                                                                     Filters = new List<string> {"-[System.*]*"},
                                                                      Assembly = "System.Debug",
                                                                      ExpectedResult = false
                                                                  },
                                                                  new UseAssemblyData
                                                                  {
-                                                                     Filters = new [] {"+[System.*]*"},
+                                                                     Filters = new List<string> {"+[System.*]*"},
                                                                      Assembly = "System.Debug",
                                                                      ExpectedResult = true
                                                                  },
                                                                  new UseAssemblyData
                                                                  {
-                                                                     Filters = new [] {"-[mscorlib]*", "-[System.*]*", "+[*]*"},
+                                                                     Filters = new List<string> {"-[mscorlib]*", "-[System.*]*", "+[*]*"},
                                                                      Assembly = "mscorlib",
                                                                      ExpectedResult = false
                                                                  },
                                                                  new UseAssemblyData
                                                                  {
-                                                                     Filters = new [] {"+[XYZ]*"},
+                                                                     Filters = new List<string> {"+[XYZ]*"},
                                                                      Assembly = "XYZ",
                                                                      ExpectedResult = true
                                                                  },
                                                                  new UseAssemblyData
                                                                  {
-                                                                     Filters = new [] {"+[XYZ]*"},
+                                                                     Filters = new List<string> {"+[XYZ]*"},
                                                                      Assembly = "XYZA",
                                                                      ExpectedResult = false
                                                                  }
@@ -168,14 +170,14 @@ public void UseAssembly_Tests(
         {
             // arrange
             var filter = new Filter();
-            data.Filters.ToList().ForEach(filter.AddFilter);
+            data.Filters.ForEach(filter.AddFilter);
 
             // act
             var result = filter.UseAssembly(data.Assembly);
 
             // result
-            Assert.AreEqual(data.ExpectedResult, result, 
-                "Filter: '{0}' Assembly: {1} => Expected: {2}", 
+            Assert.AreEqual(data.ExpectedResult, result,
+                "Filter: '{0}' Assembly: {1} => Expected: {2}",
                 string.Join(",", data.Filters), data.Assembly, data.ExpectedResult);
         }
 
@@ -183,7 +185,7 @@ public void UseAssembly_Tests(
 
         public class InstrumentClassData
         {
-            public string[] Filters { get; set; }
+            public List<string> Filters { get; set; }
             public string Assembly { get; set; }
             public string Class { get; set; }
             public bool ExpectedResult { get; set; }
@@ -193,105 +195,105 @@ public class InstrumentClassData
                                                                  {
                                                                      new InstrumentClassData
                                                                          {
-                                                                             Filters = new[] {"+[XYZ]*"},
+                                                                             Filters = new List<string> {"+[XYZ]*"},
                                                                              Assembly = "XYZ",
                                                                              Class = "Namespace.Class",
                                                                              ExpectedResult = true
                                                                          },
                                                                      new InstrumentClassData
                                                                          {
-                                                                             Filters = new[] {"+[XYZ]A*"},
+                                                                             Filters = new List<string> {"+[XYZ]A*"},
                                                                              Assembly = "XYZ",
                                                                              Class = "Namespace.Class",
                                                                              ExpectedResult = false
                                                                          },
                                                                      new InstrumentClassData
                                                                          {
-                                                                             Filters = new[] {"+[XYZ*]A*"},
+                                                                             Filters = new List<string> {"+[XYZ*]A*"},
                                                                              Assembly = "XYZA",
                                                                              Class = "Namespace.Class",
                                                                              ExpectedResult = false
                                                                          },
                                                                      new InstrumentClassData
                                                                          {
-                                                                             Filters = new[] {"+[XYZ]A*"},
+                                                                             Filters = new List<string> {"+[XYZ]A*"},
                                                                              Assembly = "XYZA",
                                                                              Class = "Namespace.Class",
                                                                              ExpectedResult = false
                                                                          },
                                                                      new InstrumentClassData
                                                                          {
-                                                                             Filters = new[] {"+[XYZ]*Class"},
+                                                                             Filters = new List<string> {"+[XYZ]*Class"},
                                                                              Assembly = "XYZ",
                                                                              Class = "Namespace.Class",
                                                                              ExpectedResult = true
                                                                          },
                                                                      new InstrumentClassData
                                                                          {
-                                                                             Filters = new[] {"+[XYZ]*Name"},
+                                                                             Filters = new List<string> {"+[XYZ]*Name"},
                                                                              Assembly = "XYZ",
                                                                              Class = "Namespace.Class",
                                                                              ExpectedResult = false
                                                                          },
                                                                      new InstrumentClassData
                                                                          {
-                                                                             Filters = new[] {"+[XYZ]*space.C*"},
+                                                                             Filters = new List<string> {"+[XYZ]*space.C*"},
                                                                              Assembly = "XYZ",
                                                                              Class = "Namespace.Class",
                                                                              ExpectedResult = true
                                                                          },
                                                                      new InstrumentClassData
                                                                          {
-                                                                             Filters = new[] {"-[XYZ*]*"},
+                                                                             Filters = new List<string> {"-[XYZ*]*"},
                                                                              Assembly = "XYZA",
                                                                              Class = "Namespace.Class",
                                                                              ExpectedResult = false
                                                                          },
                                                                      new InstrumentClassData
                                                                          {
-                                                                             Filters = new[] {"-[XYZ]*"},
+                                                                             Filters = new List<string> {"-[XYZ]*"},
                                                                              Assembly = "XYZ",
                                                                              Class = "Namespace.Class",
                                                                              ExpectedResult = false
                                                                          },
                                                                      new InstrumentClassData
                                                                          {
-                                                                             Filters = new[] {"-[*]*"},
+                                                                             Filters = new List<string> {"-[*]*"},
                                                                              Assembly = "XYZ",
                                                                              Class = "Namespace.Class",
                                                                              ExpectedResult = false
                                                                          },
                                                                      new InstrumentClassData
                                                                          {
-                                                                             Filters = new[] {"-[X*Z]*"},
+                                                                             Filters = new List<string> {"-[X*Z]*"},
                                                                              Assembly = "XYZ",
                                                                              Class = "Namespace.Class",
                                                                              ExpectedResult = false
                                                                          },
                                                                      new InstrumentClassData
                                                                          {
-                                                                             Filters = new[] {"-[XYZ]*Class"},
+                                                                             Filters = new List<string> {"-[XYZ]*Class"},
                                                                              Assembly = "XYZ",
                                                                              Class = "Namespace.Class",
                                                                              ExpectedResult = false
                                                                          },
                                                                      new InstrumentClassData
                                                                          {
-                                                                             Filters = new[] {"-[XYZ]*Unknown"},
+                                                                             Filters = new List<string> {"-[XYZ]*Unknown"},
                                                                              Assembly = "XYZ",
                                                                              Class = "Namespace.Class",
                                                                              ExpectedResult = false
                                                                          },
                                                                      new InstrumentClassData
                                                                          {
-                                                                             Filters = new[] {"+[*]*"},
+                                                                             Filters = new List<string> {"+[*]*"},
                                                                              Assembly = "",
                                                                              Class = "Namespace.Class",
                                                                              ExpectedResult = false
                                                                          },
                                                                      new InstrumentClassData
                                                                          {
-                                                                             Filters = new[] {"+[*]*"},
+                                                                             Filters = new List<string> {"+[*]*"},
                                                                              Assembly = "XYZ",
                                                                              Class = "",
                                                                              ExpectedResult = false
@@ -306,14 +308,14 @@ public void InstrumentClass_Tests(
         {
             //// arrange
             var filter = new Filter();
-            data.Filters.ToList().ForEach(filter.AddFilter);
+            data.Filters.ForEach(filter.AddFilter);
 
             // act
             var result = filter.InstrumentClass(data.Assembly, data.Class);
 
             // result
             Assert.AreEqual(data.ExpectedResult, result,
-               "Filter: '{0}' Assembly: {1} Class: {2} => Expected: {3}", 
+               "Filter: '{0}' Assembly: {1} Class: {2} => Expected: {3}",
                string.Join(",", data.Filters), data.Assembly, data.Class, data.ExpectedResult);
         }
 
@@ -332,7 +334,7 @@ public void AddAttributeExclusionFilters_Handles_Null_Elements()
         {
             var filter = new Filter();
 
-            filter.AddAttributeExclusionFilters(new []{ null, "" });
+            filter.AddAttributeExclusionFilters(new[] { null, "" });
 
             Assert.AreEqual(1, filter.ExcludedAttributes.Count);
         }
@@ -344,7 +346,7 @@ public void AddAttributeExclusionFilters_Escapes_Elements_And_Matches()
 
             filter.AddAttributeExclusionFilters(new[] { ".*" });
 
-            Assert.IsTrue(filter.ExcludedAttributes[0].Value.Match(".ABC").Success);
+            Assert.IsTrue(filter.ExcludedAttributes[0].IsMatchingExpression(".ABC"));
         }
 
         [Test]
@@ -383,7 +385,7 @@ public void AddFileExclusionFilters_Escapes_Elements_And_Matches()
 
             filter.AddFileExclusionFilters(new[] { ".*" });
 
-            Assert.IsTrue(filter.ExcludedFiles[0].Value.Match(".ABC").Success);
+            Assert.IsTrue(filter.ExcludedFiles[0].IsMatchingExpression(".ABC"));
         }
 
         [Test]
@@ -401,7 +403,7 @@ public void AssemblyIsIncludedForTestMethodGatheringWhenFilterMatches()
         {
             var filter = new Filter();
 
-            filter.AddTestFileFilters(new []{"A*"});
+            filter.AddTestFileFilters(new[] { "A*" });
 
             Assert.IsTrue(filter.UseTestAssembly("ABC.dll"));
             Assert.IsFalse(filter.UseTestAssembly("XYZ.dll"));
@@ -425,7 +427,44 @@ public void AddTestFileFilters_Escapes_Elements_And_Matches()
 
             filter.AddTestFileFilters(new[] { ".*" });
 
-            Assert.IsTrue(filter.TestFiles[0].Value.Match(".ABC").Success);
+            Assert.IsTrue(filter.TestFiles[0].IsMatchingExpression(".ABC"));
+        }
+
+
+        [Test]
+        public void AddAttributeExclustionFilters_DoesNotWrap_ForRegexFilters()
+        {
+            var filter = new Filter(true);
+            const string stringToMatch = "some string on the line before EXPRESSION some string after the expression";
+
+            filter.AddAttributeExclusionFilters(new[] { "EXPRESSION" });
+
+            var excludedAttributeRegexFilter = filter.ExcludedAttributes[0];
+            Assert.IsTrue(excludedAttributeRegexFilter.IsMatchingExpression(stringToMatch));
+        }
+
+        [Test]
+        public void AddFileExclustionFilters_DoesNotWrap_ForRegexFilters()
+        {
+            var filter = new Filter(true);
+            const string stringToMatch = "some string on the line before EXPRESSION some string after the expression";
+
+            filter.AddFileExclusionFilters(new[] { "EXPRESSION" });
+
+            var excludedFileRegexFilter = filter.ExcludedFiles[0];
+            Assert.IsTrue(excludedFileRegexFilter.IsMatchingExpression(stringToMatch));
+        }
+
+        [Test]
+        public void AddTestFileFilters_DoesNotWrap_ForRegexFilters()
+        {
+            var filter = new Filter(true);
+            const string stringToMatch = "some string on the line before EXPRESSION some string after the expression";
+
+            filter.AddTestFileFilters(new[] { "EXPRESSION" });
+
+            var excludedTestFileRegex = filter.TestFiles[0];
+            Assert.IsTrue(excludedTestFileRegex.IsMatchingExpression(stringToMatch));
         }
 
         [Test]
@@ -448,7 +487,7 @@ public void File_Is_Not_Excluded_If_No_File_Not_Supplied()
         public void File_Is_Not_Excluded_If_Does_Not_Match_Filter()
         {
             var filter = new Filter();
-            filter.AddFileExclusionFilters(new[]{"XXX.*"});
+            filter.AddFileExclusionFilters(new[] { "XXX.*" });
 
             Assert.IsFalse(filter.ExcludeByFile("YYY.cs"));
         }
@@ -467,7 +506,7 @@ public void Can_Identify_Excluded_Methods()
         {
             var sourceAssembly = AssemblyDefinition.ReadAssembly(typeof(Samples.Concrete).Assembly.Location);
 
-            var type = sourceAssembly.MainModule.Types.First(x => x.FullName == typeof (Samples.Concrete).FullName);
+            var type = sourceAssembly.MainModule.Types.First(x => x.FullName == typeof(Samples.Concrete).FullName);
 
             var filter = new Filter();
             filter.AddAttributeExclusionFilters(new[] { "*ExcludeMethodAttribute" });
@@ -475,7 +514,7 @@ public void Can_Identify_Excluded_Methods()
             foreach (var methodDefinition in type.Methods)
             {
                 if (methodDefinition.IsSetter || methodDefinition.IsGetter) continue;
-                Assert.True(filter.ExcludeByAttribute(methodDefinition));                
+                Assert.True(filter.ExcludeByAttribute(methodDefinition));
             }
 
         }
@@ -506,7 +545,7 @@ public void Can_Identify_Excluded_Anonymous_Issue99()
             var filter = new Filter();
             filter.AddAttributeExclusionFilters(new[] { "*ExcludeMethodAttribute" });
 
-            foreach (var methodDefinition in type.Methods.Where(x=>x.Name.Contains("EXCLUDE")))
+            foreach (var methodDefinition in type.Methods.Where(x => x.Name.Contains("EXCLUDE")))
             {
                 if (methodDefinition.IsSetter || methodDefinition.IsGetter || methodDefinition.IsConstructor) continue;
                 Assert.True(filter.ExcludeByAttribute(methodDefinition), "failed to execlude {0}", methodDefinition.Name);
@@ -541,7 +580,7 @@ public void Handles_Issue117()
             mockDefinition.SetupGet(x => x.HasCustomAttributes).Returns(true);
             mockDefinition.SetupGet(x => x.CustomAttributes).Returns(new Collection<CustomAttribute>());
             mockDefinition.SetupGet(x => x.Name).Returns("<>f_ddd");
-            mockDefinition.SetupGet(x => x.DeclaringType).Returns(new TypeDefinition("","f_ddd", TypeAttributes.Public));
+            mockDefinition.SetupGet(x => x.DeclaringType).Returns(new TypeDefinition("", "f_ddd", TypeAttributes.Public));
 
             Assert.DoesNotThrow(() => filter.ExcludeByAttribute(mockDefinition.Object));
         }
diff --git a/main/OpenCover.Test/OpenCover.Test.csproj b/main/OpenCover.Test/OpenCover.Test.csproj
index d21f4e560..c10b2ef36 100644
--- a/main/OpenCover.Test/OpenCover.Test.csproj
+++ b/main/OpenCover.Test/OpenCover.Test.csproj
@@ -131,6 +131,7 @@
       <Link>MoqFramework\UnityAutoMockContainer.cs</Link>
     </Compile>
     <Compile Include="Extensions\RegisterStrategiesModuleTests.cs" />
+    <Compile Include="Filtering\FilterTypeTest.cs" />
     <Compile Include="Framework\Communication\CommunicationManagerTests.cs" />
     <Compile Include="Framework\Communication\MessageHandlerTests.cs" />
     <Compile Include="Framework\BootstrapperTests.cs" />
@@ -163,6 +164,8 @@
     <Compile Include="Samples\Samples.cs" />
     <Compile Include="Samples\SimpleMsTest.cs" />
     <Compile Include="Samples\SimpleXUnit.cs" />
+    <Compile Include="Support\FakesHelperTests.cs" />
+    <Compile Include="Support\UITestingHelperTests.cs" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\OpenCover.Extensions\OpenCover.Extensions.csproj">
@@ -173,6 +176,10 @@
       <Project>{C6F40A34-101B-4BAF-A2F4-6EA28A264F57}</Project>
       <Name>OpenCover.Framework</Name>
     </ProjectReference>
+    <ProjectReference Include="..\OpenCover.Support\OpenCover.Support.csproj">
+      <Project>{31B0FAA6-A63F-46FC-96EE-697235DA2BB0}</Project>
+      <Name>OpenCover.Support</Name>
+    </ProjectReference>
   </ItemGroup>
   <ItemGroup>
     <Folder Include="Console\" />
@@ -281,8 +288,11 @@
     <None Include="App.config" />
     <None Include="packages.config" />
   </ItemGroup>
+  <ItemGroup>
+    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
+  </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
-  <Import Project="$(SolutionDir)\.nuget\nuget.targets" />
+  <Import Project="$(SolutionDir)\.nuget\NuGet.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">
diff --git a/main/OpenCover.Test/Support/FakesHelperTests.cs b/main/OpenCover.Test/Support/FakesHelperTests.cs
new file mode 100644
index 000000000..dc4ac3038
--- /dev/null
+++ b/main/OpenCover.Test/Support/FakesHelperTests.cs
@@ -0,0 +1,126 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.Specialized;
+using NUnit.Framework;
+using OpenCover.Support.Fakes;
+using OpenCover.Support.UITesting;
+
+namespace OpenCover.Test.Support
+{
+    [TestFixture]
+    public class FakesHelperTests
+    {
+        [Test]
+        [TestCase(typeof(object))]
+        [TestCase(typeof(StringDictionary))]
+        [TestCase(typeof(FakesHelperTests))]
+        public void LoadOpenCoverProfilerInstead_IgnoresUnexpectedTypes(Type type)
+        {
+            // arrange
+            var instance = Activator.CreateInstance(type); // type must have a paramterless constructor
+
+            // act/assert
+            Assert.DoesNotThrow(() => FakesHelper.LoadOpenCoverProfilerInstead(instance));
+        }
+
+        [Test]
+        public void LoadOpenCoverProfilerInstead_SwapsOutOriginalProfilerForOpenCover()
+        {
+            // arrange
+            var dict = new Dictionary<string, string>()
+            {
+                {"COR_ENABLE_PROFILING", "1"},
+                {"COR_PROFILER", "{0000002F-0000-0000-C000-000000000046}"} // not a real profiler just a COM object that should exist on every box
+            };
+
+            // act
+            Assert.DoesNotThrow(() => FakesHelper.LoadOpenCoverProfilerInstead(dict));
+
+            // assert
+            Assert.AreEqual("{1542C21D-80C3-45E6-A56C-A9C1E4BEB7B8}", dict["COR_PROFILER"]);
+            Assert.AreEqual("{0000002F-0000-0000-C000-000000000046}", dict["CHAIN_EXTERNAL_PROFILER"]);
+            Assert.IsTrue(dict["CHAIN_EXTERNAL_PROFILER_LOCATION"].EndsWith("oleaut32.dll", StringComparison.InvariantCultureIgnoreCase));
+        }
+
+        [Test]
+        public void LoadOpenCoverProfilerInstead_DoesNotAlterProfilerIfNotEnabled()
+        {
+            // arrange
+            var dict = new Dictionary<string, string>()
+            {
+                {"COR_ENABLE_PROFILING", "0"},
+                {"COR_PROFILER", "{0000002F-0000-0000-C000-000000000046}"} // not a real profiler just a COM object that should exist on every box
+            };
+
+            // act
+            Assert.DoesNotThrow(() => FakesHelper.LoadOpenCoverProfilerInstead(dict));
+
+            // assert
+            Assert.AreEqual("{0000002F-0000-0000-C000-000000000046}", dict["COR_PROFILER"]);
+        }
+
+        [Test]
+        public void LoadOpenCoverProfilerInstead_DoesNotAlterProfilerIfCurrentProfilerIsOpenCover()
+        {
+            // arrange
+            var dict = new Dictionary<string, string>()
+            {
+                {"COR_ENABLE_PROFILING", "1"},
+                {"COR_PROFILER", "{1542C21D-80C3-45E6-A56C-A9C1E4BEB7B8}"} // not a real profiler just a COM object that should exist on every box
+            };
+
+            // act
+            Assert.DoesNotThrow(() => FakesHelper.LoadOpenCoverProfilerInstead(dict));
+
+            // assert
+            Assert.AreEqual("{1542C21D-80C3-45E6-A56C-A9C1E4BEB7B8}", dict["COR_PROFILER"]);
+            Assert.IsFalse(dict.ContainsKey("CHAIN_EXTERNAL_PROFILER"));
+            Assert.IsFalse(dict.ContainsKey("CHAIN_EXTERNAL_PROFILER_LOCATION"));
+        }
+
+        [Test]
+        public void PretendWeLoadedFakesProfiler_ChangesEnvironmentVariables()
+        {
+            // arrange
+            Environment.SetEnvironmentVariable("COR_ENABLE_PROFILING", "1");
+            Environment.SetEnvironmentVariable("COR_PROFILER", "{1542C21D-80C3-45E6-A56C-A9C1E4BEB7B8}");
+            Environment.SetEnvironmentVariable("CHAIN_EXTERNAL_PROFILER", "{0000002F-0000-0000-C000-000000000046}");
+
+            // act
+            Assert.DoesNotThrow(() => FakesHelper.PretendWeLoadedFakesProfiler(null));
+
+            // assert
+            Assert.AreEqual("{0000002F-0000-0000-C000-000000000046}", Environment.GetEnvironmentVariable("COR_PROFILER"));
+        }
+
+        [Test]
+        public void PretendWeLoadedFakesProfiler_DoesNotChangesEnvironmentVariablesIfNotEnables()
+        {
+            // arrange
+            Environment.SetEnvironmentVariable("COR_ENABLE_PROFILING", "0");
+            Environment.SetEnvironmentVariable("COR_PROFILER", "{1542C21D-80C3-45E6-A56C-A9C1E4BEB7B8}");
+            Environment.SetEnvironmentVariable("CHAIN_EXTERNAL_PROFILER", "{0000002F-0000-0000-C000-000000000046}");
+
+            // act
+            Assert.DoesNotThrow(() => FakesHelper.PretendWeLoadedFakesProfiler(null));
+
+            // assert
+            Assert.AreEqual("{1542C21D-80C3-45E6-A56C-A9C1E4BEB7B8}", Environment.GetEnvironmentVariable("COR_PROFILER"));
+        }
+
+        [Test]
+        public void PretendWeLoadedFakesProfiler_DoesNotChangesEnvironmentVariablesIfNotOpenCover()
+        {
+            // arrange
+            Environment.SetEnvironmentVariable("COR_ENABLE_PROFILING", "1");
+            Environment.SetEnvironmentVariable("COR_PROFILER", Guid.NewGuid().ToString());
+            Environment.SetEnvironmentVariable("CHAIN_EXTERNAL_PROFILER", "{0000002F-0000-0000-C000-000000000046}");
+
+            // act
+            Assert.DoesNotThrow(() => FakesHelper.PretendWeLoadedFakesProfiler(null));
+
+            // assert
+            Assert.AreNotEqual("{1542C21D-80C3-45E6-A56C-A9C1E4BEB7B8}", Environment.GetEnvironmentVariable("COR_PROFILER"));
+        }
+    }
+}
\ No newline at end of file
diff --git a/main/OpenCover.Test/Support/UITestingHelperTests.cs b/main/OpenCover.Test/Support/UITestingHelperTests.cs
new file mode 100644
index 000000000..6520377e8
--- /dev/null
+++ b/main/OpenCover.Test/Support/UITestingHelperTests.cs
@@ -0,0 +1,86 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using NUnit.Framework;
+using OpenCover.Support.UITesting;
+
+namespace OpenCover.Test.Support
+{
+    [TestFixture]
+    // ReSharper disable once InconsistentNaming
+    public class UITestingHelperTests
+    {
+        [Test]
+        [TestCase(typeof(object))]
+        [TestCase(typeof(UITestingHelperTests))]
+        public void PropagateRequiredEnvironmentVariables_IgnoresUnexpectedTypes(Type type)
+        {
+            // arrange
+            var instance = Activator.CreateInstance(type); // type must have a paramterless constructor
+
+            // act/assert
+            Assert.DoesNotThrow(() => UITestingHelper.PropagateRequiredEnvironmentVariables(instance));
+        }
+
+        [Test]
+        [TestCase("COR_PROFILER_EX")]
+        [TestCase("CHAIN_EXTERNAL_PROFILER_EX")]
+        [TestCase("OPENCOVER_PROFILER_KEY_EX")]
+        public void PropagateRequiredEnvironmentVariables_AddsMissingEnvironmentVariables(string env)
+        {
+            // arrange
+            var pi = new ProcessStartInfo();
+            Assert.IsFalse(pi.EnvironmentVariables.ContainsKey(env));
+
+            Environment.SetEnvironmentVariable(env, "random");
+
+            // act
+            UITestingHelper.PropagateRequiredEnvironmentVariables(pi);
+
+            // assert
+            Assert.AreEqual("random", pi.EnvironmentVariables[env]);
+        }
+
+        [Test]
+        [TestCase("COR_PROFILER_EX")]
+        [TestCase("CHAIN_EXTERNAL_PROFILER_EX")]
+        [TestCase("OPENCOVER_PROFILER_KEY_EX")]
+        public void PropagateRequiredEnvironmentVariables_DoesNotAlterCurrentEnvironmentVariables(string env)
+        {
+            // arrange
+            var pi = new ProcessStartInfo();
+            Environment.SetEnvironmentVariable(env, "random");
+            Assert.AreEqual("random", pi.EnvironmentVariables[env]);
+
+            Environment.SetEnvironmentVariable(env, "new random");
+
+            // act
+            UITestingHelper.PropagateRequiredEnvironmentVariables(pi);
+
+            // assert
+            Assert.AreEqual("random", pi.EnvironmentVariables[env]);
+        }
+
+        [Test]
+        [TestCase("WIBBLE")]
+        [TestCase("OOPSY")]
+        [TestCase("STUFF")]
+        public void PropagateRequiredEnvironmentVariables_DoesNotAddOtherEnvironmentVariables(string env)
+        {
+            // arrange
+            var pi = new ProcessStartInfo();
+            Assert.IsFalse(pi.EnvironmentVariables.ContainsKey(env));
+
+            Environment.SetEnvironmentVariable(env, "random");
+
+            // act
+            UITestingHelper.PropagateRequiredEnvironmentVariables(pi);
+
+            // assert
+            Assert.IsFalse(pi.EnvironmentVariables.ContainsKey(env));
+        }
+    }
+}
diff --git a/main/OpenCover.UITest/LaunchSimpleTest.cs b/main/OpenCover.UITest/LaunchSimpleTest.cs
new file mode 100644
index 000000000..c133d37b5
--- /dev/null
+++ b/main/OpenCover.UITest/LaunchSimpleTest.cs
@@ -0,0 +1,72 @@
+using System.Diagnostics;
+using System.IO;
+using Microsoft.VisualStudio.TestTools.UITesting;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+
+namespace OpenCover.UITest
+{
+    /// <summary>
+    /// Summary description for CodedUITest1
+    /// </summary>
+    [CodedUITest]
+    public class LaunchSimpleTest
+    {
+        public LaunchSimpleTest()
+        {
+        }
+
+        [TestMethod]
+        [DeploymentItem(@".\exe\OpenCover.Simple.Target.exe", "exe")]
+        [DeploymentItem(@".\exe\OpenCover.Simple.Target.pdb", "exe")]
+        public void RunApp()
+        {
+            var c = Directory.GetCurrentDirectory();
+            var path = Path.Combine(c, @".\exe\OpenCover.Simple.Target.exe");
+            // To generate code for this test, select "Generate Code for Coded UI Test" from the shortcut menu and select one of the menu items.
+            var pi = new ProcessStartInfo(path);
+            pi.EnvironmentVariables["Stuff"] = "1";
+            pi.UseShellExecute = false;
+            //pi.LoadUserProfile = true;
+            var application = ApplicationUnderTest.Launch(pi);
+            application.Process.WaitForExit(10000);
+        }
+
+        #region Additional test attributes
+
+        // You can use the following additional attributes as you write your tests:
+
+        ////Use TestInitialize to run code before running each test 
+        //[TestInitialize()]
+        //public void MyTestInitialize()
+        //{        
+        //    // To generate code for this test, select "Generate Code for Coded UI Test" from the shortcut menu and select one of the menu items.
+        //}
+
+        ////Use TestCleanup to run code after each test has run
+        //[TestCleanup()]
+        //public void MyTestCleanup()
+        //{        
+        //    // To generate code for this test, select "Generate Code for Coded UI Test" from the shortcut menu and select one of the menu items.
+        //}
+
+        #endregion
+
+        /// <summary>
+        ///Gets or sets the test context which provides
+        ///information about and functionality for the current test run.
+        ///</summary>
+        public TestContext TestContext
+        {
+            get
+            {
+                return testContextInstance;
+            }
+            set
+            {
+                testContextInstance = value;
+            }
+        }
+        private TestContext testContextInstance;
+    }
+}
diff --git a/main/OpenCover.UITest/OpenCover.UITest.csproj b/main/OpenCover.UITest/OpenCover.UITest.csproj
new file mode 100644
index 000000000..03e020367
--- /dev/null
+++ b/main/OpenCover.UITest/OpenCover.UITest.csproj
@@ -0,0 +1,106 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProductVersion>
+    </ProductVersion>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>{E8513153-6298-411D-9BD9-0DB0CC708D34}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>OpenCover.UITest</RootNamespace>
+    <AssemblyName>OpenCover.UITest</AssemblyName>
+    <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+    <ProjectTypeGuids>{3AC096D0-A1C2-E12C-1390-A8335801FDAB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
+    <VisualStudioVersion Condition="'$(VisualStudioVersion)' == ''">10.0</VisualStudioVersion>
+    <VSToolsPath Condition="'$(VSToolsPath)' == ''">$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)</VSToolsPath>
+    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\$(VisualStudioVersion)\UITestExtensionPackages</ReferencePath>
+    <IsCodedUITest>True</IsCodedUITest>
+    <TestProjectType>CodedUITest</TestProjectType>
+  </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.VisualStudio.QualityTools.UnitTestFramework, Version=10.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL" />
+    <Reference Include="System" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Drawing" />
+    <Reference Include="System.Windows.Forms" />
+    <Reference Include="WindowsBase" />
+  </ItemGroup>
+  <ItemGroup>
+    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
+      <Visible>False</Visible>
+    </CodeAnalysisDependentAssemblyPaths>
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="LaunchSimpleTest.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+  </ItemGroup>
+  <ItemGroup />
+  <ItemGroup>
+    <None Include="..\bin\Debug\x86\OpenCover.Simple.Target.exe">
+      <Link>exe\OpenCover.Simple.Target.exe</Link>
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </None>
+    <None Include="..\bin\Debug\x86\OpenCover.Simple.Target.pdb">
+      <Link>exe\OpenCover.Simple.Target.pdb</Link>
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </None>
+    <None Include="..\cmdline\uitest.opencover.cmd">
+      <Link>uitest.opencover.cmd</Link>
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </None>
+  </ItemGroup>
+  <Choose>
+    <When Condition="'$(VisualStudioVersion)' == '10.0' And '$(IsCodedUITest)' == 'True'">
+      <ItemGroup>
+        <Reference Include="Microsoft.VisualStudio.QualityTools.CodedUITestFramework, Version=10.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
+          <Private>False</Private>
+        </Reference>
+        <Reference Include="Microsoft.VisualStudio.TestTools.UITest.Common, Version=10.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
+          <Private>False</Private>
+        </Reference>
+        <Reference Include="Microsoft.VisualStudio.TestTools.UITest.Extension, Version=10.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
+          <Private>False</Private>
+        </Reference>
+        <Reference Include="Microsoft.VisualStudio.TestTools.UITesting, Version=10.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
+          <Private>False</Private>
+        </Reference>
+      </ItemGroup>
+    </When>
+  </Choose>
+  <Choose>
+    <When Condition="('$(VisualStudioVersion)' == '10.0' Or '$(VisualStudioVersion)' == '11.0') And '$(IsCodedUITest)' == 'True'">
+      <ItemGroup>
+        <Reference Include="UIAutomationTypes" />
+      </ItemGroup>
+    </When>
+  </Choose>
+  <Import Project="$(VSToolsPath)\TeamTest\Microsoft.TestTools.targets" Condition="Exists('$(VSToolsPath)\TeamTest\Microsoft.TestTools.targets')" />
+  <Import Project="$(MSBuildBinPath)\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>
\ No newline at end of file
diff --git a/main/OpenCover.UITest/Properties/AssemblyInfo.cs b/main/OpenCover.UITest/Properties/AssemblyInfo.cs
new file mode 100644
index 000000000..4907084c8
--- /dev/null
+++ b/main/OpenCover.UITest/Properties/AssemblyInfo.cs
@@ -0,0 +1,35 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("OpenCover.UITest")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("OpenCover.UITest")]
+[assembly: AssemblyCopyright("Copyright ©  2015")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("8a862535-25cd-4b54-9611-6c290ba8c23e")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers 
+// by using the '*' as shown below:
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]
diff --git a/main/OpenCover.sln b/main/OpenCover.sln
index f011382b4..f2282eca8 100644
--- a/main/OpenCover.sln
+++ b/main/OpenCover.sln
@@ -1,6 +1,8 @@
 
 Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio 2012
+# Visual Studio 2013
+VisualStudioVersion = 12.0.31101.0
+MinimumVisualStudioVersion = 10.0.40219.1
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "OpenCover.Profiler", "OpenCover.Profiler\OpenCover.Profiler.vcxproj", "{B2CE418E-A5C8-4C46-9513-771414B3CA4C}"
 	ProjectSection(ProjectDependencies) = postProject
 		{31B0FAA6-A63F-46FC-96EE-697235DA2BB0} = {31B0FAA6-A63F-46FC-96EE-697235DA2BB0}
@@ -62,7 +64,12 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "OpenCover.Specs", "OpenCove
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "OpenCover.Extensions", "OpenCover.Extensions\OpenCover.Extensions.csproj", "{EE9B358A-335C-43E9-BC35-853807C5E776}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "OpenCover.FakesSupport", "OpenCover.FakesSupport\OpenCover.FakesSupport.csproj", "{31B0FAA6-A63F-46FC-96EE-697235DA2BB0}"
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "OpenCover.Support", "OpenCover.Support\OpenCover.Support.csproj", "{31B0FAA6-A63F-46FC-96EE-697235DA2BB0}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "OpenCover.UITest", "OpenCover.UITest\OpenCover.UITest.csproj", "{E8513153-6298-411D-9BD9-0DB0CC708D34}"
+	ProjectSection(ProjectDependencies) = postProject
+		{27AD5F08-0625-4093-8782-F7936737FAB7} = {27AD5F08-0625-4093-8782-F7936737FAB7}
+	EndProjectSection
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
@@ -171,6 +178,11 @@ Global
 		{31B0FAA6-A63F-46FC-96EE-697235DA2BB0}.Release|x64.Build.0 = Release|Any CPU
 		{31B0FAA6-A63F-46FC-96EE-697235DA2BB0}.Release|x86.ActiveCfg = Release|Any CPU
 		{31B0FAA6-A63F-46FC-96EE-697235DA2BB0}.Release|x86.Build.0 = Release|Any CPU
+		{E8513153-6298-411D-9BD9-0DB0CC708D34}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{E8513153-6298-411D-9BD9-0DB0CC708D34}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{E8513153-6298-411D-9BD9-0DB0CC708D34}.Debug|x86.Build.0 = Debug|Any CPU
+		{E8513153-6298-411D-9BD9-0DB0CC708D34}.Release|x64.ActiveCfg = Release|Any CPU
+		{E8513153-6298-411D-9BD9-0DB0CC708D34}.Release|x86.ActiveCfg = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
diff --git a/main/cmdline/uitest.opencover.cmd b/main/cmdline/uitest.opencover.cmd
new file mode 100644
index 000000000..332541c8c
--- /dev/null
+++ b/main/cmdline/uitest.opencover.cmd
@@ -0,0 +1 @@
+OpenCover.Console.exe -register:user -target:"C:\Program Files (x86)\Microsoft Visual Studio 12.0\Common7\IDE\CommonExtensions\Microsoft\TestWindow\vstest.console.exe" -targetargs:"OpenCover.UITest.dll" -filter:"+[Open*]* -[OpenCover.UIT*]*" -output:opencovertests.xml -mergebyhash