Merge lp:~b-tfrje-j/nunit-vs-adapter/TFSAdaption into lp:nunit-vs-adapter

[Terje Sandstrom]

Added code to implement Test Case Filtering as defined by TFS Build Test Runner. See linked bug for details.
Implemented mapping between NUnit Category and TFS TestCategory term, and NUnit Priority and TFS Priority.
FullyQualifiedName should also work for filtering.
Code made independent on using RTM or Update 1 version.

[Charlie Poole (charlie.poole)]

This is a preliminary review based on reading the code. I have a few comments and questions and then I'll do an actual merge and check it out more closely.

1. You say you implemented mapping between "NUnit Priority" and TFS Priority. There is no NUnit Priority... can you explain?

2. Have you tested against RTM as well as Update 1?

3. The target framework for the adapter has been changed to .NET 4. I suspect this will prevent users from running tests targeting .NET 2.0 under 2.0. Have you tried this?

4. Some changes are hard to review in the diff because methods were moved to a new location and show up as entirely deleted and added. Nothing to do about it at this point, but something to remember.

5. Reading the code, it becomes obvious that we need to distinguish between NUnit and TFS filters by their name. I'll do some name changes when I merge it.

Charlie

review: Needs Information

[Charlie Poole (charlie.poole)]

I merged the changes into my working directory and built and ran it using VS2012 RTM. Found some issues:

1. TestFilterTests wouldn't compile because it uses the Traits property of TestCase and the Trait type. This needs to be done via reflection to maintain compatibility with RTM. See NavigationDataTests.cs for an example. I commented out the two tests affected in order to proceed further.

2. Discovery turns up 87 tests but no tests are run. An NullReferenceException is thrown in NUnitTestExecutor.AddTestCasesToMap() at line 148. Reversed order of two lines in the RunAssembly method as you suggested and got past that problem.

3. Now I have 15 failing tests in TestExecutionTests due to TestFixtureSetUp failure. It appears to occur when initializing the TFSFilter.

4. As a final test, I changed the target for the adapter project back to .NET 3.5. It won't compile. I assume that's why you changed it to target 4.0, but that won't do when running tests that target .NET 2.0 under 2.0. That was an early bug back when I had originally targeted .NET 4.5.

Charlie

review: Needs Fixing

[lp:~b-tfrje-j/nunit-vs-adapter/TFSAdaption]

41. By Terje Sandstrom on 2012-12-18

FIxed some issues

42. By Terje Sandstrom on 2012-12-18

Fixed minor issues

43. By Terje Sandstrom on 2012-12-19

Fixed reflection

[Terje Sandstrom (b-tfrje-j)]

I now pushed up version 43 with the issues below resolved.
The changed files you need to merge over is TFSTestFilter.cs and TestTFSBuild.cs

1. TestTFSBuild – changed use of Trait and TraitCollection to do this using reflection.
a. I have also added two more tests to cover the reflection code better.
2. TFSTestFilter.cs: Changed the methods TraitContains and PropertyValueProvider. The first now uses reflection, same way as you did, - I skipped the expression tree, it was just too much pain – and running on the build server I don’t think that performance overhead matters much. From the TFS log I can’t see anything significant there either. In a later update we can change this to use expression trees to gain some more speed.
a. The change in PropertyValueProvider is to allow for multiple traits with the same trait name. The spec says it should be allowed, and now it does. One of the new unit tests checks that it works.

I also switched the FW to 3.5 on the project and it compiled as it should. Also tested it on TFS build server Update 1

[lp:~b-tfrje-j/nunit-vs-adapter/TFSAdaption]

44. By Terje Sandstrom on 2012-12-20

Added check for RTM to tests

=== modified file 'NUnitTestAdapter.sln'
Binary files NUnitTestAdapter.sln	2012-02-15 18:56:30 +0000 and NUnitTestAdapter.sln	2012-12-20 20:51:21 +0000 differ
=== added file 'NUnitTestAdapter.vssscc'
--- NUnitTestAdapter.vssscc	1970-01-01 00:00:00 +0000
+++ NUnitTestAdapter.vssscc	2012-12-20 20:51:21 +0000
@@ -0,0 +1,10 @@
+""
+{
+"FILE_VERSION" = "9237"
+"ENLISTMENT_CHOICE" = "NEVER"
+"PROJECT_FILE_RELATIVE_PATH" = ""
+"NUMBER_OF_EXCLUDED_FILES" = "0"
+"ORIGINAL_PROJECT_FILE_PATH" = ""
+"NUMBER_OF_NESTED_PROJECTS" = "0"
+"SOURCE_CONTROL_SETTINGS_PROVIDER" = "PROJECT"
+}

=== modified file 'src/NUnitTestAdapter/NUnitTestAdapter.csproj'
--- src/NUnitTestAdapter/NUnitTestAdapter.csproj	2012-12-18 04:26:03 +0000
+++ src/NUnitTestAdapter/NUnitTestAdapter.csproj	2012-12-20 20:51:21 +0000
@@ -1,99 +1,97 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProductVersion>8.0.30703</ProductVersion>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{8A85E26A-C706-48B1-BC36-06EBDE3EFD25}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <RootNamespace>NUnit.VisualStudio.TestAdapter</RootNamespace>
-    <AssemblyName>NUnit.VisualStudio.TestAdapter</AssemblyName>
-    <TargetFrameworkVersion>v3.5</TargetFrameworkVersion>
-    <FileAlignment>512</FileAlignment>
-    <TargetFrameworkProfile />
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-    <DebugSymbols>true</DebugSymbols>
-    <DebugType>full</DebugType>
-    <Optimize>false</Optimize>
-    <OutputPath>bin\Debug\</OutputPath>
-    <DefineConstants>TRACE;DEBUG</DefineConstants>
-    <ErrorReport>prompt</ErrorReport>
-    <WarningLevel>4</WarningLevel>
-    <Prefer32Bit>false</Prefer32Bit>
-  </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>
-    <Prefer32Bit>false</Prefer32Bit>
-  </PropertyGroup>
-  <PropertyGroup>
-    <RunPostBuildEvent>OnOutputUpdated</RunPostBuildEvent>
-  </PropertyGroup>
-  <PropertyGroup>
-    <SignAssembly>true</SignAssembly>
-  </PropertyGroup>
-  <PropertyGroup>
-    <AssemblyOriginatorKeyFile>NUnitAdapter.snk</AssemblyOriginatorKeyFile>
-  </PropertyGroup>
-  <PropertyGroup>
-    <DelaySign>false</DelaySign>
-  </PropertyGroup>
-  <ItemGroup>
-    <Reference Include="Microsoft.VisualStudio.TestPlatform.ObjectModel">
-      <HintPath>C:\Program Files\Microsoft Visual Studio 11.0\Common7\IDE\CommonExtensions\Microsoft\TestWindow\Microsoft.VisualStudio.TestPlatform.ObjectModel.dll</HintPath>
-    </Reference>
-    <Reference Include="nunit.core, Version=2.6.2.12295, Culture=neutral, PublicKeyToken=96d09a1eb7f44a77, processorArchitecture=MSIL">
-      <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\..\lib\nunit.core.dll</HintPath>
-    </Reference>
-    <Reference Include="nunit.core.interfaces, Version=2.6.2.12295, Culture=neutral, PublicKeyToken=96d09a1eb7f44a77, processorArchitecture=MSIL">
-      <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\..\lib\nunit.core.interfaces.dll</HintPath>
-    </Reference>
-    <Reference Include="nunit.util, Version=2.6.2.12295, Culture=neutral, PublicKeyToken=96d09a1eb7f44a77, processorArchitecture=MSIL">
-      <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\..\lib\nunit.util.dll</HintPath>
-    </Reference>
-    <Reference Include="System" />
-    <Reference Include="System.Data" />
-    <Reference Include="System.Xml" />
-  </ItemGroup>
-  <ItemGroup>
-    <Compile Include="Internal\Stackframe.cs" />
-    <Compile Include="Internal\StackframeParser.cs" />
-    <Compile Include="Internal\Stacktrace.cs" />
-    <Compile Include="NUnitEventListener.cs" />
-    <Compile Include="NUnitTestAdapter.cs" />
-    <Compile Include="NUnitTestDiscoverer.cs" />
-    <Compile Include="NUnitTestExecutor.cs" />
-    <Compile Include="Properties\AssemblyInfo.cs" />
-    <Compile Include="StackTraceFilter.cs" />
-    <Compile Include="TestConverter.cs" />
-    <Compile Include="TestRunFilter.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <WCFMetadata Include="Service References\" />
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="NUnitAdapter.snk" />
-  </ItemGroup>
-  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
-  <PropertyGroup>
-    <PostBuildEvent>
-    </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.
-  <Target Name="BeforeBuild">
-  </Target>
-  <Target Name="AfterBuild">
-  </Target>
-  -->
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProductVersion>8.0.30703</ProductVersion>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>{8A85E26A-C706-48B1-BC36-06EBDE3EFD25}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>NUnit.VisualStudio.TestAdapter</RootNamespace>
+    <AssemblyName>NUnit.VisualStudio.TestAdapter</AssemblyName>
+    <TargetFrameworkVersion>v3.5</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+    <TargetFrameworkProfile />
+    <SccProjectName>SAK</SccProjectName>
+    <SccLocalPath>SAK</SccLocalPath>
+    <SccAuxPath>SAK</SccAuxPath>
+    <SccProvider>SAK</SccProvider>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>TRACE;DEBUG</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <Prefer32Bit>false</Prefer32Bit>
+  </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>
+    <Prefer32Bit>false</Prefer32Bit>
+  </PropertyGroup>
+  <PropertyGroup>
+    <RunPostBuildEvent>OnOutputUpdated</RunPostBuildEvent>
+  </PropertyGroup>
+  <PropertyGroup>
+    <SignAssembly>true</SignAssembly>
+  </PropertyGroup>
+  <PropertyGroup>
+    <AssemblyOriginatorKeyFile>NUnitAdapter.snk</AssemblyOriginatorKeyFile>
+  </PropertyGroup>
+  <PropertyGroup>
+    <DelaySign>false</DelaySign>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="Microsoft.VisualStudio.TestPlatform.ObjectModel">
+      <HintPath>..\..\..\..\..\..\..\Program Files (x86)\Microsoft Visual Studio 11.0\Common7\IDE\CommonExtensions\Microsoft\TestWindow\Microsoft.VisualStudio.TestPlatform.ObjectModel.dll</HintPath>
+    </Reference>
+    <Reference Include="nunit.core, Version=2.4.8.0, Culture=neutral, PublicKeyToken=96d09a1eb7f44a77, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\lib\nunit.core.dll</HintPath>
+    </Reference>
+    <Reference Include="nunit.core.interfaces, Version=2.4.8.0, Culture=neutral, PublicKeyToken=96d09a1eb7f44a77, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\lib\nunit.core.interfaces.dll</HintPath>
+    </Reference>
+    <Reference Include="nunit.util, Version=2.4.8.0, Culture=neutral, PublicKeyToken=96d09a1eb7f44a77, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\lib\nunit.util.dll</HintPath>
+    </Reference>
+    <Reference Include="System" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="Internal\Stackframe.cs" />
+    <Compile Include="Internal\StackframeParser.cs" />
+    <Compile Include="Internal\Stacktrace.cs" />
+    <Compile Include="NUnitEventListener.cs" />
+    <Compile Include="NUnitTestAdapter.cs" />
+    <Compile Include="NUnitTestDiscoverer.cs" />
+    <Compile Include="NUnitTestExecutor.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="StackTraceFilter.cs" />
+    <Compile Include="TestConverter.cs" />
+    <Compile Include="TestRunFilter.cs" />
+    <Compile Include="TFSTestFilter.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <WCFMetadata Include="Service References\" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="NUnitAdapter.snk" />
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <PropertyGroup>
+    <PostBuildEvent>
+    </PostBuildEvent>
+  </PropertyGroup>
 </Project>
\ No newline at end of file

=== added file 'src/NUnitTestAdapter/NUnitTestAdapter.csproj.vspscc'
--- src/NUnitTestAdapter/NUnitTestAdapter.csproj.vspscc	1970-01-01 00:00:00 +0000
+++ src/NUnitTestAdapter/NUnitTestAdapter.csproj.vspscc	2012-12-20 20:51:21 +0000
@@ -0,0 +1,10 @@
+""
+{
+"FILE_VERSION" = "9237"
+"ENLISTMENT_CHOICE" = "NEVER"
+"PROJECT_FILE_RELATIVE_PATH" = ""
+"NUMBER_OF_EXCLUDED_FILES" = "0"
+"ORIGINAL_PROJECT_FILE_PATH" = ""
+"NUMBER_OF_NESTED_PROJECTS" = "0"
+"SOURCE_CONTROL_SETTINGS_PROVIDER" = "PROVIDER"
+}

=== modified file 'src/NUnitTestAdapter/NUnitTestExecutor.cs'
--- src/NUnitTestAdapter/NUnitTestExecutor.cs	2012-11-04 19:16:15 +0000
+++ src/NUnitTestAdapter/NUnitTestExecutor.cs	2012-12-20 20:51:21 +0000
@@ -29,6 +29,7 @@
 
         #region ITestExecutor
 
+        private bool isCalledFromTfsBuild;
         /// <summary>
         /// Called by the test platform to run all tests.
         /// </summary>
@@ -39,64 +40,37 @@
         {
             // Ensure any channels registered by other adapters are unregistered
             CleanUpRegisteredChannels();
-
+            var tfsfilter = new TFSTestFilter(runContext);
+            isCalledFromTfsBuild = tfsfilter.TfsTestCaseFilterExpression != null;
             foreach (var source in sources)
-            {
-                RunAssembly(source, frameworkHandle, TestFilter.Empty);
-            }
-        }
-
-        /// <summary>
-        /// Called by the TestPlatform when selected tests are to be run.
-        /// </summary>
-        /// <param name="selectedTests">The tests to be run</param>
-        /// <param name="runContext">The RunContext</param>
-        /// <param name="frameworkHandle">The FrameworkHandle</param>
-        public void RunTests(IEnumerable<TestCase> selectedTests, IRunContext runContext, IFrameworkHandle frameworkHandle)
-        {
-            // Ensure any channels registered by other adapters are unregistered
-            CleanUpRegisteredChannels();
-
-            var assemblyGroups = selectedTests.GroupBy(tc => tc.Source);
-
-            foreach (var assemblyGroup in assemblyGroups)
-                RunAssembly(assemblyGroup.Key, frameworkHandle, MakeTestFilter(assemblyGroup));
-        }
-
-        void ITestExecutor.Cancel()
-        {
-            if (runner != null && runner.Running)
-                runner.CancelRun();
-        }
-
-        #endregion
-
-        #region Private Methods
-
-        /// <summary>
-        /// Runs the tests in an assembly under control of a filter
-        /// </summary>
-        /// <param name="assemblyName">The assembly file name and path</param>
-        /// <param name="testLog">The destination for all messages and events</param>
-        /// <param name="filter">A test filter controlling what tests are run</param>
-        private void RunAssembly(string assemblyName, ITestExecutionRecorder testLog, TestFilter filter)
-        {
-            // Set the logger to use for messages
+                RunAssembly(source, frameworkHandle, TestFilter.Empty, runContext);
+        }
+
+        private void RunAssembly(string assemblyName, ITestExecutionRecorder testLog, TestFilter filter, IRunContext runContext)
+        {
+
             SetLogger(testLog);
 
             try
             {
                 this.runner = new TestDomain();
-                TestPackage package = new TestPackage(assemblyName);
-
+                var package = new TestPackage(assemblyName);
+                var testDictionary = new Dictionary<string, TestNode>();
+                var converter = new TestConverter(assemblyName, testDictionary);
                 if (runner.Load(package))
                 {
-                    var testCaseMap = CreateTestCaseMap(runner.Test as TestNode);
 
+                    var testCaseMap = CreateTestCaseMap(runner.Test as TestNode, converter);
                     var listener = new NUnitEventListener(testLog, testCaseMap, assemblyName);
 
                     try
                     {
+                        if (isCalledFromTfsBuild)
+                        {
+                            var testfilter = new TFSTestFilter(runContext);
+                            var filteredTestCases = testfilter.CheckFilter(testCases);
+                            filter = MakeTestFilter(filteredTestCases);
+                        }
                         runner.Run(listener, filter, false, LoggingThreshold.Off);
                     }
                     catch (NullReferenceException)
@@ -125,28 +99,62 @@
             }
         }
 
-        private Dictionary<string, NUnit.Core.TestNode> CreateTestCaseMap(TestNode topLevelTest)
-        {
-            var map = new Dictionary<string, NUnit.Core.TestNode>();
-            AddTestCasesToMap(map, topLevelTest);
+
+        /// <summary>
+        /// Called by the TestPlatform when selected tests are to be run.
+        /// This method is called from Visual Studio when you select a group of tests to run.  It is never called from Tfs Build.
+        /// </summary>
+        /// <param name="selectedTests">The tests to be run</param>
+        /// <param name="runContext">The RunContext</param>
+        /// <param name="frameworkHandle">The FrameworkHandle</param>
+        public void RunTests(IEnumerable<TestCase> selectedTests, IRunContext runContext, IFrameworkHandle frameworkHandle)
+        {
+            // Ensure any channels registered by other adapters are unregistered
+            CleanUpRegisteredChannels();
+            isCalledFromTfsBuild = false;
+            var assemblyGroups = selectedTests.GroupBy(tc => tc.Source);
+
+            foreach (var assemblyGroup in assemblyGroups)
+                RunAssembly(assemblyGroup.Key, frameworkHandle, MakeTestFilter(assemblyGroup), runContext);
+        }
+
+        void ITestExecutor.Cancel()
+        {
+            if (runner != null && runner.Running)
+                runner.CancelRun();
+        }
+
+        #endregion
+
+        #region Private Methods
+
+        private Dictionary<string, NUnit.Core.TestNode> CreateTestCaseMap(TestNode topLevelTest, TestConverter converter)
+        {
+            var map = new Dictionary<string, NUnit.Core.TestNode>();
+            testCases = new List<TestCase>();
+            AddTestCasesToMap(map, topLevelTest, converter);
 
             return map;
         }
 
-        private void AddTestCasesToMap(Dictionary<string, NUnit.Core.TestNode> map, TestNode test)
+
+        private List<TestCase> testCases;
+        private void AddTestCasesToMap(Dictionary<string, NUnit.Core.TestNode> map, TestNode test, TestConverter converter)
         {
-            if (test.IsSuite)
-                foreach (TestNode child in test.Tests)
-                    AddTestCasesToMap(map, child);
+            if (test.IsSuite) 
+                foreach (TestNode child in test.Tests) AddTestCasesToMap(map, child, converter);
             else
+            {
+                testCases.Add(converter.ConvertTestCase(test));
                 map.Add(test.TestName.UniqueName, test);
+            }
         }
 
-        private TestFilter MakeTestFilter(IEnumerable<TestCase> testCases)
+        private TestFilter MakeTestFilter(IEnumerable<TestCase> ptestCases)
         {
             var filter = new NameFilter();
 
-            foreach (TestCase testCase in testCases)
+            foreach (TestCase testCase in ptestCases)
                 filter.Add(TestName.Parse(testCase.FullyQualifiedName));
 
             return filter;

=== added file 'src/NUnitTestAdapter/TFSTestFilter.cs'
--- src/NUnitTestAdapter/TFSTestFilter.cs	1970-01-01 00:00:00 +0000
+++ src/NUnitTestAdapter/TFSTestFilter.cs	2012-12-20 20:51:21 +0000
@@ -0,0 +1,200 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Text;
+using Microsoft.VisualStudio.TestPlatform.ObjectModel;
+using Microsoft.VisualStudio.TestPlatform.ObjectModel.Adapter;
+
+namespace NUnit.VisualStudio.TestAdapter
+{
+    using System.Collections;
+
+    public class TFSTestFilter
+    {
+        /// <summary>   
+        /// Supported properties for filtering
+
+        ///</summary>
+        private static readonly Dictionary<string, TestProperty> supportedPropertiesCache;
+        private static readonly Dictionary<string, NTrait> supportedTraitCache;
+        private static readonly Dictionary<NTrait, TestProperty> traitPropertyMap;
+        private static readonly List<string> supportedProperties;
+
+        static TFSTestFilter()
+        {
+            // Initialize the property cache
+            supportedPropertiesCache = new Dictionary<string, TestProperty>(StringComparer.OrdinalIgnoreCase);
+            supportedPropertiesCache["FullyQualifiedName"] = TestCaseProperties.FullyQualifiedName;
+            supportedPropertiesCache["Name"] = TestCaseProperties.DisplayName;
+            // Intialize the trait cache
+            var priorityTrait = new NTrait("Priority", "");
+            var categoryTrait = new NTrait("Category", "");
+            supportedTraitCache = new Dictionary<string, NTrait>(StringComparer.OrdinalIgnoreCase);
+            supportedTraitCache["Priority"] = priorityTrait;
+            supportedTraitCache["TestCategory"] = categoryTrait;
+            // Initalize the trait property map, since TFS doesnt know about traits
+            traitPropertyMap = new Dictionary<NTrait, TestProperty>(new NTraitNameComparer());
+            var priorityProperty = TestProperty.Find("Priority") ??
+                      TestProperty.Register("Priority", "Priority", typeof(string), typeof(TestCase));
+            traitPropertyMap[priorityTrait] = priorityProperty;
+            var categoryProperty = TestProperty.Find("TestCategory") ??
+                        TestProperty.Register("TestCategory", "TestCategory", typeof(string), typeof(TestCase));
+            traitPropertyMap[categoryTrait] = categoryProperty;
+            // Initialize a merged list of properties and traits to fool TFS Build to think traits is properties
+            supportedProperties = new List<string>();
+            supportedProperties.AddRange(supportedPropertiesCache.Keys);
+            supportedProperties.AddRange(supportedTraitCache.Keys);
+        }
+
+        private IRunContext runContext;
+        public TFSTestFilter(IRunContext runContext)
+        {
+            this.runContext = runContext;
+        }
+
+
+        private ITestCaseFilterExpression testCaseFilterExpression;
+        public ITestCaseFilterExpression TfsTestCaseFilterExpression
+        {
+            get
+            {
+                return testCaseFilterExpression ??
+                       (testCaseFilterExpression = runContext.GetTestCaseFilter(supportedProperties, PropertyProvider));
+            }
+        }
+        public IEnumerable<TestCase> CheckFilter(IEnumerable<TestCase> tests)
+        {
+
+            return TfsTestCaseFilterExpression == null ? tests : tests.Where(underTest => !TfsTestCaseFilterExpression.MatchTestCase(underTest, p => PropertyValueProvider(underTest, p)) == false).ToList();
+        }
+
+        /// <summary>    
+        /// Provides value of TestProperty corresponding to property name 'propertyName' as used in filter.    
+        /// /// Return value should be a string for single valued property or array of strings for multi valued property (e.g. TestCategory)   
+        /// /// </summary>     
+        public static object PropertyValueProvider(TestCase currentTest, string propertyName)
+        {
+
+            var testProperty = LocalPropertyProvider(propertyName);
+            if (testProperty != null)
+            {
+
+                // Test case might not have defined this property. In that case GetPropertyValue()             
+                // would return default value. For filtering, if property is not defined return null.           
+                if (currentTest.Properties.Contains(testProperty))
+                {
+                    return currentTest.GetPropertyValue(testProperty);
+                }
+            }
+            // Now it may be a trait, so we check the trait collection as well
+            var testTrait = TraitProvider(propertyName);
+            if (testTrait != null)
+            {
+                var val = traitContains(currentTest, testTrait.Name);
+                if (val.Length == 0) return null;
+                if (val.Length == 1) // Contains a single string
+                    return val[0];  // return that string
+                return val;  // otherwise return the whole array 
+            }
+            return null;
+        }
+
+        static readonly Func<TestCase, string, string[]> traitContains = TraitContains();
+
+        /// <summary>
+        /// TestCase:  To be checked
+        /// traitName: Name of trait to be checked against
+        /// </summary>
+        /// <returns>Value of trait</returns>
+        private static Func<TestCase, string, string[]> TraitContains()
+        {
+
+            return (testCase, traitName) =>
+            {
+                var testCaseType = typeof(TestCase);
+                var property = testCaseType.GetProperty("Traits");
+                if (property == null)
+                    return null;
+                var traits = property.GetValue(testCase, null) as IEnumerable;
+                var values = new List<string>();
+                foreach (var t in traits)
+                {
+                    var name = t.GetType().GetProperty("Name").GetValue(t, null) as string;
+                    if (name == traitName)
+                    {
+                        var value = t.GetType().GetProperty("Value").GetValue(t, null) as string;
+                        values.Add(value);
+                    }
+                }
+                return values.ToArray();
+            };
+        }
+
+        /// <summary>   
+        /// Provides TestProperty for property name 'propertyName' as used in filter.    
+        /// </summary>    
+        public static TestProperty LocalPropertyProvider(string propertyName)
+        {
+            TestProperty testProperty;
+            supportedPropertiesCache.TryGetValue(propertyName, out testProperty);
+            return testProperty;
+        }
+
+        public static TestProperty PropertyProvider(string propertyName)
+        {
+            var testProperty = LocalPropertyProvider(propertyName);
+            if (testProperty != null)
+            {
+                return testProperty;
+            }
+            var testTrait = TraitProvider(propertyName);
+            if (testTrait != null)
+            {
+                TestProperty tp;
+                if (traitPropertyMap.TryGetValue(testTrait, out tp))
+                {
+                    return tp;
+                }
+            }
+            return null;
+        }
+
+        public static NTrait TraitProvider(string traitName)
+        {
+            NTrait testTrait;
+            supportedTraitCache.TryGetValue(traitName, out testTrait);
+            return testTrait;
+        }
+
+
+
+    }
+
+    public class NTraitNameComparer : IEqualityComparer<NTrait>
+    {
+
+        public bool Equals(NTrait n, NTrait y)
+        {
+            return n.Name == y.Name;
+        }
+
+        public int GetHashCode(NTrait obj)
+        {
+            return obj.Name.GetHashCode();
+        }
+    }
+
+    public class NTrait
+    {
+        public string Name { get; private set; }
+        public string Value { get; private set; }
+
+        public NTrait(string name, string value)
+        {
+            Name = name;
+            Value = value;
+        }
+    }
+
+}

=== added file 'src/NUnitTestAdapterInstall/NUnitTestAdapterInstall.csproj.vspscc'
--- src/NUnitTestAdapterInstall/NUnitTestAdapterInstall.csproj.vspscc	1970-01-01 00:00:00 +0000
+++ src/NUnitTestAdapterInstall/NUnitTestAdapterInstall.csproj.vspscc	2012-12-20 20:51:21 +0000
@@ -0,0 +1,10 @@
+""
+{
+"FILE_VERSION" = "9237"
+"ENLISTMENT_CHOICE" = "NEVER"
+"PROJECT_FILE_RELATIVE_PATH" = ""
+"NUMBER_OF_EXCLUDED_FILES" = "0"
+"ORIGINAL_PROJECT_FILE_PATH" = ""
+"NUMBER_OF_NESTED_PROJECTS" = "0"
+"SOURCE_CONTROL_SETTINGS_PROVIDER" = "PROVIDER"
+}

=== modified file 'src/NUnitTestAdapterInstall/source.extension.vsixmanifest'
--- src/NUnitTestAdapterInstall/source.extension.vsixmanifest	2012-11-03 01:44:23 +0000
+++ src/NUnitTestAdapterInstall/source.extension.vsixmanifest	2012-12-20 20:51:21 +0000
@@ -3,7 +3,7 @@
 	<Identifier Id="NUnitTestAdapterInstall..7c53286e-ac4f-485f-915c-5ec5a4c47b0c">
 		<Name>NUnit Test Adapter (Beta 3-2)</Name>
 		<Author>Charlie Poole</Author>
-		<Version>0.93.2</Version>
+		<Version>0.93.29</Version>
 		<Description xml:space="preserve">NUnit adapter for integrated test execution under Visual Studio 2012. Compatible with NUnit 2.0 through 2.6.2</Description>
 		<Locale>1033</Locale>
 		<MoreInfoUrl>http://nunit.org/index.php?p=vsTestAdapter&amp;r=2.6.2</MoreInfoUrl>

=== modified file 'src/NUnitTestAdapterTests/Fakes/FakeRunContext.cs'
--- src/NUnitTestAdapterTests/Fakes/FakeRunContext.cs	2012-10-14 21:26:49 +0000
+++ src/NUnitTestAdapterTests/Fakes/FakeRunContext.cs	2012-12-20 20:51:21 +0000
@@ -1,57 +1,63 @@
-// ****************************************************************
-// Copyright (c) 2012 NUnit Software. All rights reserved.
-// ****************************************************************
-
-using System;
-using System.Collections.Generic;
-using Microsoft.VisualStudio.TestPlatform.ObjectModel;
-using Microsoft.VisualStudio.TestPlatform.ObjectModel.Adapter;
-
-namespace NUnit.VisualStudio.TestAdapter.Tests.Fakes
-{
-    class FakeRunContext : IRunContext
-    {
-        #region IRunContext Members
-
-        bool IRunContext.InIsolation
-        {
-            get { throw new NotImplementedException(); }
-        }
-
-        bool IRunContext.IsBeingDebugged
-        {
-            get { throw new NotImplementedException(); }
-        }
-
-        bool IRunContext.IsDataCollectionEnabled
-        {
-            get { throw new NotImplementedException(); }
-        }
-
-        bool IRunContext.KeepAlive
-        {
-            get { throw new NotImplementedException(); }
-        }
-
-        string IRunContext.TestRunDirectory
-        {
-            get { throw new NotImplementedException(); }
-        }
-
-        ITestCaseFilterExpression IRunContext.GetTestCaseFilter(IEnumerable<string> supportedProperties, Func<string, TestProperty> propertyProvider)
-        {
-            throw new NotImplementedException();
-        }
-
-        #endregion
-
-        #region IDiscoveryContextMembers
-
-        IRunSettings IDiscoveryContext.RunSettings
-        {
-            get { throw new NotImplementedException(); }
-        }
-
-        #endregion
-    }
-}
+// ****************************************************************
+// Copyright (c) 2012 NUnit Software. All rights reserved.
+// ****************************************************************
+
+using System;
+using System.Collections.Generic;
+using Microsoft.VisualStudio.TestPlatform.ObjectModel;
+using Microsoft.VisualStudio.TestPlatform.ObjectModel.Adapter;
+
+namespace NUnit.VisualStudio.TestAdapter.Tests.Fakes
+{
+    class FakeRunContext : IRunContext
+    {
+        #region IRunContext Members
+
+        bool IRunContext.InIsolation
+        {
+            get { throw new NotImplementedException(); }
+        }
+
+        bool IRunContext.IsBeingDebugged
+        {
+            get { throw new NotImplementedException(); }
+        }
+
+        bool IRunContext.IsDataCollectionEnabled
+        {
+            get { throw new NotImplementedException(); }
+        }
+
+        bool IRunContext.KeepAlive
+        {
+            get { throw new NotImplementedException(); }
+        }
+
+        string IRunContext.TestRunDirectory
+        {
+            get { throw new NotImplementedException(); }
+        }
+
+        ITestCaseFilterExpression IRunContext.GetTestCaseFilter(IEnumerable<string> supportedProperties, Func<string, TestProperty> propertyProvider)
+        {
+            return null;  // as if we don't have a TFS Build, equal to testing from VS 
+        }
+
+        #endregion
+
+        #region IDiscoveryContextMembers
+
+        IRunSettings IDiscoveryContext.RunSettings
+        {
+            get { throw new NotImplementedException(); }
+        }
+
+        #endregion
+
+
+        public string SolutionDirectory
+        {
+            get { throw new NotImplementedException(); }
+        }
+    }
+}

=== modified file 'src/NUnitTestAdapterTests/NUnitTestAdapterTests.csproj'
--- src/NUnitTestAdapterTests/NUnitTestAdapterTests.csproj	2012-12-18 04:44:45 +0000
+++ src/NUnitTestAdapterTests/NUnitTestAdapterTests.csproj	2012-12-20 20:51:21 +0000
@@ -1,92 +1,97 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProductVersion>8.0.30703</ProductVersion>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{D261700A-5950-46AB-BA3A-304ADBED0DE6}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <RootNamespace>NUnit.VisualStudio.TestAdapter.Tests</RootNamespace>
-    <AssemblyName>NUnit.VisualStudio.TestAdapter.Tests</AssemblyName>
-    <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
-    <FileAlignment>512</FileAlignment>
-    <TargetFrameworkProfile />
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-    <DebugSymbols>true</DebugSymbols>
-    <DebugType>full</DebugType>
-    <Optimize>false</Optimize>
-    <OutputPath>bin\Debug\</OutputPath>
-    <DefineConstants>TRACE;DEBUG</DefineConstants>
-    <ErrorReport>prompt</ErrorReport>
-    <WarningLevel>4</WarningLevel>
-    <Prefer32Bit>false</Prefer32Bit>
-  </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>
-    <Prefer32Bit>false</Prefer32Bit>
-  </PropertyGroup>
-  <ItemGroup>
-    <Reference Include="Microsoft.VisualStudio.TestPlatform.ObjectModel">
-      <HintPath>C:\Program Files\Microsoft Visual Studio 11.0\Common7\IDE\CommonExtensions\Microsoft\TestWindow\Microsoft.VisualStudio.TestPlatform.ObjectModel.dll</HintPath>
-    </Reference>
-    <Reference Include="mock-assembly, Version=2.6.2.12295, Culture=neutral, processorArchitecture=MSIL">
-      <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\..\lib\mock-assembly.dll</HintPath>
-    </Reference>
-    <Reference Include="nunit.core, Version=2.6.2.12295, Culture=neutral, PublicKeyToken=96d09a1eb7f44a77, processorArchitecture=MSIL">
-      <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\..\lib\nunit.core.dll</HintPath>
-    </Reference>
-    <Reference Include="nunit.core.interfaces, Version=2.6.2.12295, Culture=neutral, PublicKeyToken=96d09a1eb7f44a77, processorArchitecture=MSIL">
-      <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\..\lib\nunit.core.interfaces.dll</HintPath>
-    </Reference>
-    <Reference Include="nunit.framework, Version=2.6.2.12295, Culture=neutral, PublicKeyToken=96d09a1eb7f44a77, processorArchitecture=MSIL">
-      <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\..\lib\nunit.framework.dll</HintPath>
-    </Reference>
-    <Reference Include="System" />
-    <Reference Include="System.Core" />
-    <Reference Include="System.Xml.Linq" />
-    <Reference Include="System.Data.DataSetExtensions" />
-    <Reference Include="Microsoft.CSharp" />
-    <Reference Include="System.Data" />
-    <Reference Include="System.Xml" />
-  </ItemGroup>
-  <ItemGroup>
-    <Compile Include="AsyncTests.cs" />
-    <Compile Include="NavigationTestData.cs" />
-    <Compile Include="NavigationDataTests.cs" />
-    <Compile Include="Fakes\FakeFrameworkHandle.cs" />
-    <Compile Include="Fakes\FakeRunContext.cs" />
-    <Compile Include="Fakes\FakeRunSettings.cs" />
-    <Compile Include="TestConverterTests_StaticHelpers.cs" />
-    <Compile Include="TestConverterTests.cs" />
-    <Compile Include="TestDiscoveryTests.cs" />
-    <Compile Include="NUnitEventListenerTests.cs" />
-    <Compile Include="Properties\AssemblyInfo.cs" />
-    <Compile Include="TestExecutionTests.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="..\NUnitTestAdapter\NUnitTestAdapter.csproj">
-      <Project>{8A85E26A-C706-48B1-BC36-06EBDE3EFD25}</Project>
-      <Name>NUnitTestAdapter</Name>
-    </ProjectReference>
-  </ItemGroup>
-  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
-  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
-       Other similar extension points exist, see Microsoft.Common.targets.
-  <Target Name="BeforeBuild">
-  </Target>
-  <Target Name="AfterBuild">
-  </Target>
-  -->
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProductVersion>8.0.30703</ProductVersion>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>{D261700A-5950-46AB-BA3A-304ADBED0DE6}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>NUnit.VisualStudio.TestAdapter.Tests</RootNamespace>
+    <AssemblyName>NUnit.VisualStudio.TestAdapter.Tests</AssemblyName>
+    <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+    <TargetFrameworkProfile />
+    <SccProjectName>%24/BlogCode/TestAdapters/trunk/trunkadapter/src/NUnitTestAdapterTests</SccProjectName>
+    <SccLocalPath>.</SccLocalPath>
+    <SccAuxPath>https://terje.tfspreview.com/defaultcollection</SccAuxPath>
+    <SccProvider>{4CA58AB2-18FA-4F8D-95D4-32DDF27D184C}</SccProvider>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>TRACE;DEBUG</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <Prefer32Bit>false</Prefer32Bit>
+  </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>
+    <Prefer32Bit>false</Prefer32Bit>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="Microsoft.VisualStudio.TestPlatform.ObjectModel">
+      <HintPath>..\..\..\..\..\..\..\Program Files (x86)\Microsoft Visual Studio 11.0\Common7\IDE\CommonExtensions\Microsoft\TestWindow\Microsoft.VisualStudio.TestPlatform.ObjectModel.dll</HintPath>
+    </Reference>
+    <Reference Include="mock-assembly, Version=2.4.8.0, Culture=neutral, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\lib\mock-assembly.dll</HintPath>
+    </Reference>
+    <Reference Include="nunit.core, Version=2.4.8.0, Culture=neutral, PublicKeyToken=96d09a1eb7f44a77, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\lib\nunit.core.dll</HintPath>
+    </Reference>
+    <Reference Include="nunit.core.interfaces, Version=2.4.8.0, Culture=neutral, PublicKeyToken=96d09a1eb7f44a77, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\lib\nunit.core.interfaces.dll</HintPath>
+    </Reference>
+    <Reference Include="nunit.framework, Version=2.6.2.12295, Culture=neutral, PublicKeyToken=96d09a1eb7f44a77, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\lib\nunit.framework.dll</HintPath>
+    </Reference>
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Xml.Linq" />
+    <Reference Include="System.Data.DataSetExtensions" />
+    <Reference Include="Microsoft.CSharp" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="AsyncTests.cs" />
+    <Compile Include="NavigationTestData.cs" />
+    <Compile Include="NavigationDataTests.cs" />
+    <Compile Include="Fakes\FakeFrameworkHandle.cs" />
+    <Compile Include="Fakes\FakeRunContext.cs" />
+    <Compile Include="Fakes\FakeRunSettings.cs" />
+    <Compile Include="TestConverterTests_StaticHelpers.cs" />
+    <Compile Include="TestConverterTests.cs" />
+    <Compile Include="TestDiscoveryTests.cs" />
+    <Compile Include="NUnitEventListenerTests.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="TestExecutionTests.cs" />
+    <Compile Include="TestTFSBuild.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\NUnitTestAdapter\NUnitTestAdapter.csproj">
+      <Project>{8A85E26A-C706-48B1-BC36-06EBDE3EFD25}</Project>
+      <Name>NUnitTestAdapter</Name>
+    </ProjectReference>
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
 </Project>
\ No newline at end of file

=== added file 'src/NUnitTestAdapterTests/NUnitTestAdapterTests.csproj.vspscc'
--- src/NUnitTestAdapterTests/NUnitTestAdapterTests.csproj.vspscc	1970-01-01 00:00:00 +0000
+++ src/NUnitTestAdapterTests/NUnitTestAdapterTests.csproj.vspscc	2012-12-20 20:51:21 +0000
@@ -0,0 +1,10 @@
+""
+{
+"FILE_VERSION" = "9237"
+"ENLISTMENT_CHOICE" = "NEVER"
+"PROJECT_FILE_RELATIVE_PATH" = ""
+"NUMBER_OF_EXCLUDED_FILES" = "0"
+"ORIGINAL_PROJECT_FILE_PATH" = ""
+"NUMBER_OF_NESTED_PROJECTS" = "0"
+"SOURCE_CONTROL_SETTINGS_PROVIDER" = "PROVIDER"
+}

=== added file 'src/NUnitTestAdapterTests/TestTFSBuild.cs'
--- src/NUnitTestAdapterTests/TestTFSBuild.cs	1970-01-01 00:00:00 +0000
+++ src/NUnitTestAdapterTests/TestTFSBuild.cs	2012-12-20 20:51:21 +0000
@@ -0,0 +1,136 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using NUnit.Framework;
+
+namespace NUnit.VisualStudio.TestAdapter.Tests
+{
+    using System.Reflection;
+
+    using Microsoft.VisualStudio.TestPlatform.ObjectModel;
+
+
+    [TestFixture]
+    public class TestFilterTests
+    {
+        private MethodInfo traitsCollectionAdd;
+        private readonly PropertyInfo traitsProperty;
+
+        private readonly bool isRTM = false;
+
+        public TestFilterTests()
+        {
+            traitsProperty = typeof(TestCase).GetProperty("Traits");
+            if (traitsProperty != null)
+            {
+                var traitCollectionType = traitsProperty.PropertyType;
+                if (traitCollectionType != null)
+                    traitsCollectionAdd = traitCollectionType.GetMethod("Add", new Type[] { typeof(string), typeof(string) });
+            }
+            else
+                isRTM = true;
+        }
+
+        private void AddTrait(TestCase testCase, string traitname, string traitvalue)
+        {
+            object traitsCollection = traitsProperty.GetValue(testCase, new object[0]);
+            if (traitsCollection == null) return;
+            traitsCollectionAdd.Invoke(traitsCollection, new object[] { traitname, traitvalue });
+        }
+
+
+        [Test]
+        [Category("TFS")]
+        public void PropertyProvider()
+        {
+            var testfilter = new TFSTestFilter(null);
+            var prop = TFSTestFilter.PropertyProvider("Priority");
+            Assert.NotNull(prop);
+            prop = TFSTestFilter.PropertyProvider("TestCategory");
+            Assert.NotNull(prop);
+        }
+        [Test]
+        [Category("TFS")]
+        public void TraitProvider()
+        {
+            if (isRTM) return;
+            var testFilter = new TFSTestFilter(null);
+            var trait = TFSTestFilter.TraitProvider("TestCategory");
+            Assert.NotNull(trait);
+        }
+
+        [Test]
+        [Category("TFS")]
+        public void TraitProviderWithNoCategory()
+        {
+            var testFilter = new TFSTestFilter(null);
+            var trait = TFSTestFilter.TraitProvider("JustKidding");
+            Assert.Null(trait);
+        }
+
+        [Test]
+        [Category("TFS")]
+        public void PropertyValueProviderFqn()
+        {
+            if (isRTM) return;
+            var tc = new TestCase("Test1", new Uri("executor://NUnitTestExecutor"), "NUnit.VSIX");
+            var testFilter = new TFSTestFilter(null);
+            var obj = TFSTestFilter.PropertyValueProvider(tc, "FullyQualifiedName");
+            Assert.AreSame("Test1", obj);
+        }
+
+        [Test]
+        [Category("TFS")]
+        public void PropertyValueProviderCategoryWithOneCategory()
+        {
+            if (isRTM) return;
+            var tc = new TestCase("Test1", new Uri("executor://NUnitTestExecutor"), "NUnit.VSIX");
+            this.AddTrait(tc, "Category", "CI");
+            var testFilter = new TFSTestFilter(null);
+            var obj = TFSTestFilter.PropertyValueProvider(tc, "TestCategory");
+            Assert.AreSame("CI", obj);
+        }
+
+        [Test]
+        [Category("TFS")]
+        public void PropertyValueProviderCategoryWithNoTraits()
+        {
+            var tc = new TestCase("Test1", new Uri("executor://NUnitTestExecutor"), "NUnit.VSIX");
+            var testFilter = new TFSTestFilter(null);
+            var obj = TFSTestFilter.PropertyValueProvider(tc, "TestCategory");
+            Assert.IsNull(obj);
+        }
+
+        [Test]
+        [Category("TFS")]
+        public void PropertyValueProviderCategoryWithMultipleCategories()
+        {
+            if (isRTM) return;
+            var tc = new TestCase("Test1", new Uri("executor://NUnitTestExecutor"), "NUnit.VSIX");
+            this.AddTrait(tc, "Category", "CI");
+            this.AddTrait(tc, "Category", "MyOwn");
+            var testFilter = new TFSTestFilter(null);
+            var obj = TFSTestFilter.PropertyValueProvider(tc, "TestCategory") as string[];
+            Assert.IsNotNull(obj);
+            Assert.AreEqual(obj.Length, 2);
+            Assert.AreSame("CI", obj[0]);
+            Assert.AreSame("MyOwn", obj[1]);
+        }
+
+        [Test]
+        [Category("TFS")]
+        public void PropertyValueProviderCategoryFail()
+        {
+            if (isRTM) return;
+            var tc = new TestCase("Test1", new Uri("executor://NUnitTestExecutor"), "NUnit.VSIX");
+            this.AddTrait(tc, "Category", "CI");
+            var testFilter = new TFSTestFilter(null);
+            var obj = TFSTestFilter.PropertyValueProvider(tc, "Garbage");
+            Assert.Null(obj);
+        }
+
+
+    }
+}