Merge lp:~ialastairhunter/nunitlite/categoryfilter into lp:nunitlite

[Tyrel Alastair Hunter]

Hello Charlie I would like you to review this code before I merge it into the main branch of nunitlite. This will give me some chance to learn how to complete a merge request before you leave on your trip. This branch contains all the functionality for simplified category expressions that we discussed

[lp:~ialastairhunter/nunitlite/categoryfilter]

144. By Tyrel Alastair Hunter on 2013-05-02

Added RandomGenerator to TestContext
RandomGenerator provides a repeatable method for obtaining random numbers during a tests execution
Added the seed for the random generator to ITest and Test so that the seed can be serialized to the results

145. By Tyrel Alastair Hunter on 2013-05-03

Merging Latest Changes from lp:nunitlite
tested category include and exlude options on netcf2, netcf3.5 net2, net3.5, net4, and net4.5

feature not supported on silverlight at this time
Fixed issue with RandomGenerator feature that caused for a compile Error when compiling NETC

[Charlie Poole (charlie.poole)]

Just a few procedural comments before I actually review this...

1. It's generally best to use a separate branch per feature. This merge request actually fixes two unrelated bugs. Having them together means we have to either accept or postpone both of them, whereas it's very common to have different fixes follow different life cycles as new ideas come up, questions get asked, etc.

2. Something to do with end of line settings is messing us up here, making it look as if you have deleted and re-inserted very large selections of code. We should try to avoid this in the future. When the diff makes it clear what has changed, it's often possible to just look at the code to do the review. In this case, I'll have to merge your changes into a working directory and use some tools that will give a more meaningful diff. That takes longer.

With our current plan to do a release on the weekend, I'll just work with this merge as it is. The above is just info for the future. I'll be back later with the actual review.

[Tyrel Alastair Hunter (ialastairhunter)]

Thanks Charlie I believe what happened was the code I was given from the team was auto formatted by vs. normally I would try to only change the proper lines. In the future I will make seperate branches

—
Sent from Mailbox for iPhone

On Fri, May 3, 2013 at 5:52 PM, Charlie Poole <email address hidden> wrote:

> Just a few procedural comments before I actually review this...
> 1. It's generally best to use a separate branch per feature. This merge request actually fixes two unrelated bugs. Having them together means we have to either accept or postpone both of them, whereas it's very common to have different fixes follow different life cycles as new ideas come up, questions get asked, etc.
> 2. Something to do with end of line settings is messing us up here, making it look as if you have deleted and re-inserted very large selections of code. We should try to avoid this in the future. When the diff makes it clear what has changed, it's often possible to just look at the code to do the review. In this case, I'll have to merge your changes into a working directory and use some tools that will give a more meaningful diff. That takes longer.
> With our current plan to do a release on the weekend, I'll just work with this merge as it is. The above is just info for the future. I'll be back later with the actual review.
> --
> https://code.launchpad.net/~ialastairhunter/nunitlite/categoryfilter/+merge/161767
> You are the owner of lp:~ialastairhunter/nunitlite/categoryfilter.

[Charlie Poole (charlie.poole)]

Random Generator Change:

ITest has an unneeded (and undesirable) reference to the Internal namespace. Public APIs should avoid such references.

I see you use the Randomizer for the test method, which is used to generate random arguments, to create the seed for the user-side RandomGenerator. This will work well as far as guaranteeing a unique seed but introduces a dependency: adding or removing other tests will change the random seed used for any subsequently detected tests. Additionally, it defeats the lazy initialization of randomizers, forcing creation of a randomizer for every test method. I suggest we put it in this way but try to find a better approach that preserves lazy initialization of Randomizers and avoids test interactions.

Please add some comments that distinguish the purpose of RandomGenerator from Randomizer, now that we have both of them.

RandomGenerator won't compile under .NET 1.1 as it is. The GetEnums methods should all be controlled by #if CLR_2_0.

The portability logic for enums in RandomGenerator duplicates what's already in TypeHelper. See if you can use the TypeHelper enum methods - or add what's needed there.

I'm not seeing any tests for the new feature. It should be easy to copy and edit RandomizerTests.cs for this purpose. Harder to test repeatability, so maybe we should worry about that later.

Category Change:

Code looks good but I'm not seeing any tests here either. Should be easy to add to CommandLineOptionTests.cs.

Overall... It needs some fixes but you can go ahead and merge when you have done them.

review: Needs Fixing (code review)

[Tyrel Alastair Hunter (ialastairhunter)]

Random Generator Change:

ITest has an unneeded (and undesirable) reference to the Internal namespace. Public APIs should avoid such references.

I have removed this reference

I see you use the Randomizer for the test method, which is used to generate random arguments, to create the seed for the user-side RandomGenerator. This will work well as far as guaranteeing a unique seed but introduces a dependency: adding or removing other tests will change the random seed used for any subsequently detected tests. Additionally, it defeats the lazy initialization of randomizers, forcing creation of a randomizer for every test method. I suggest we put it in this way but try to find a better approach that preserves lazy initialization of Randomizers and avoids test interactions.

I am not sure i completely understand what you are saying here can we disuss this while we are doing the release at 2:00 EST

Please add some comments that distinguish the purpose of RandomGenerator from Randomizer, now that we have both of them.

Added comments to RandomGenerator and Randomizer

RandomGenerator won't compile under .NET 1.1 as it is. The GetEnums methods should all be controlled by #if CLR_2_0.

I believe that I fixed this however I will have you check it while we are doing the release at 2:00 EST

The portability logic for enums in RandomGenerator duplicates what's already in TypeHelper. See if you can use the TypeHelper enum methods - or add what's needed there.

Modified the code to use the TypeHelper instead

I'm not seeing any tests for the new feature. It should be easy to copy and edit RandomizerTests.cs for this purpose. Harder to test repeatability, so maybe we should worry about that later.

I have added tests for most of the functionality we can add more tests in a later release. Tests left out are for repeatability, and for the Random enum function

Category Change:

Code looks good but I'm not seeing any tests here either. Should be easy to add to CommandLineOptionTests.cs.

Overall... It needs some fixes but you can go ahead and merge when you have done them.

I have added tests to test that CommandLine Options works as expected. There is no test to ensure the options function correctly but the test ensure that the options are recognized.

we can add a test later that ensures that the options are used to modify the way nunit executes the tests.

[Charlie Poole (charlie.poole)]

Hi Tyrel,

This all sounds good to me. I'm actually ready to start whenever you are.

Charlie

On Sat, May 4, 2013 at 10:02 AM, Tyrel Alastair Hunter <
<email address hidden>> wrote:

> Random Generator Change:
>
> ITest has an unneeded (and undesirable) reference to the Internal
> namespace. Public APIs should avoid such references.
>
> I have removed this reference
>
> I see you use the Randomizer for the test method, which is used to
> generate random arguments, to create the seed for the user-side
> RandomGenerator. This will work well as far as guaranteeing a unique seed
> but introduces a dependency: adding or removing other tests will change the
> random seed used for any subsequently detected tests. Additionally, it
> defeats the lazy initialization of randomizers, forcing creation of a
> randomizer for every test method. I suggest we put it in this way but try
> to find a better approach that preserves lazy initialization of Randomizers
> and avoids test interactions.
>
> I am not sure i completely understand what you are saying here can we
> disuss this while we are doing the release at 2:00 EST
>
> Please add some comments that distinguish the purpose of RandomGenerator
> from Randomizer, now that we have both of them.
>
> Added comments to RandomGenerator and Randomizer
>
> RandomGenerator won't compile under .NET 1.1 as it is. The GetEnums
> methods should all be controlled by #if CLR_2_0.
>
> I believe that I fixed this however I will have you check it while we are
> doing the release at 2:00 EST
>
> The portability logic for enums in RandomGenerator duplicates what's
> already in TypeHelper. See if you can use the TypeHelper enum methods - or
> add what's needed there.
>
> Modified the code to use the TypeHelper instead
>
> I'm not seeing any tests for the new feature. It should be easy to copy
> and edit RandomizerTests.cs for this purpose. Harder to test repeatability,
> so maybe we should worry about that later.
>
> I have added tests for most of the functionality we can add more tests in
> a later release. Tests left out are for repeatability, and for the Random
> enum function
>
> Category Change:
>
> Code looks good but I'm not seeing any tests here either. Should be easy
> to add to CommandLineOptionTests.cs.
>
> Overall... It needs some fixes but you can go ahead and merge when you
> have done them.
>
> I have added tests to test that CommandLine Options works as expected.
> There is no test to ensure the options function correctly but the test
> ensure that the options are recognized.
>
> we can add a test later that ensures that the options are used to modify
> the way nunit executes the tests.
> --
>
> https://code.launchpad.net/~ialastairhunter/nunitlite/categoryfilter/+merge/161767
> You are reviewing the proposed merge of
> lp:~ialastairhunter/nunitlite/categoryfilter into lp:nunitlite.
>

[Tyrel Alastair Hunter (ialastairhunter)]

I am on skype
—
Sent from Mailbox for iPhone

On Sat, May 4, 2013 at 1:43 PM, Charlie Poole <email address hidden> wrote:

> Hi Tyrel,
> This all sounds good to me. I'm actually ready to start whenever you are.
> Charlie
> On Sat, May 4, 2013 at 10:02 AM, Tyrel Alastair Hunter <
> <email address hidden>> wrote:
>> Random Generator Change:
>>
>> ITest has an unneeded (and undesirable) reference to the Internal
>> namespace. Public APIs should avoid such references.
>>
>> I have removed this reference
>>
>> I see you use the Randomizer for the test method, which is used to
>> generate random arguments, to create the seed for the user-side
>> RandomGenerator. This will work well as far as guaranteeing a unique seed
>> but introduces a dependency: adding or removing other tests will change the
>> random seed used for any subsequently detected tests. Additionally, it
>> defeats the lazy initialization of randomizers, forcing creation of a
>> randomizer for every test method. I suggest we put it in this way but try
>> to find a better approach that preserves lazy initialization of Randomizers
>> and avoids test interactions.
>>
>> I am not sure i completely understand what you are saying here can we
>> disuss this while we are doing the release at 2:00 EST
>>
>> Please add some comments that distinguish the purpose of RandomGenerator
>> from Randomizer, now that we have both of them.
>>
>> Added comments to RandomGenerator and Randomizer
>>
>> RandomGenerator won't compile under .NET 1.1 as it is. The GetEnums
>> methods should all be controlled by #if CLR_2_0.
>>
>> I believe that I fixed this however I will have you check it while we are
>> doing the release at 2:00 EST
>>
>> The portability logic for enums in RandomGenerator duplicates what's
>> already in TypeHelper. See if you can use the TypeHelper enum methods - or
>> add what's needed there.
>>
>> Modified the code to use the TypeHelper instead
>>
>> I'm not seeing any tests for the new feature. It should be easy to copy
>> and edit RandomizerTests.cs for this purpose. Harder to test repeatability,
>> so maybe we should worry about that later.
>>
>> I have added tests for most of the functionality we can add more tests in
>> a later release. Tests left out are for repeatability, and for the Random
>> enum function
>>
>> Category Change:
>>
>> Code looks good but I'm not seeing any tests here either. Should be easy
>> to add to CommandLineOptionTests.cs.
>>
>> Overall... It needs some fixes but you can go ahead and merge when you
>> have done them.
>>
>> I have added tests to test that CommandLine Options works as expected.
>> There is no test to ensure the options function correctly but the test
>> ensure that the options are recognized.
>>
>> we can add a test later that ensures that the options are used to modify
>> the way nunit executes the tests.
>> --
>>
>> https://code.launchpad.net/~ialastairhunter/nunitlite/categoryfilter/+merge/161767
>> You are reviewing the proposed merge of
>> lp:~ialastairhunter/nunitlite/categoryfilter into lp:nunitlite.
>>
> --
> https://code.launchpad.net/~ialastairhunter/nunitlite/categoryfilter/+merge/161767
> You are the owner of lp:~ialastairhunter/nun...

=== modified file 'src/framework/Api/ITest.cs'
--- src/framework/Api/ITest.cs	2012-05-04 18:26:00 +0000
+++ src/framework/Api/ITest.cs	2013-05-03 03:03:44 +0000
@@ -1,96 +1,103 @@
-// ***********************************************************************
-// Copyright (c) 2007 Charlie Poole
-//
-// Permission is hereby granted, free of charge, to any person obtaining
-// a copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to
-// permit persons to whom the Software is furnished to do so, subject to
-// the following conditions:
-// 
-// The above copyright notice and this permission notice shall be
-// included in all copies or substantial portions of the Software.
-// 
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-// ***********************************************************************
-
-using System;
-
-namespace NUnit.Framework.Api
-{
-	/// <summary>
-	/// Common interface supported by all representations
-	/// of a test. Only includes informational fields.
-	/// The Run method is specifically excluded to allow
-	/// for data-only representations of a test.
-	/// </summary>
-	public interface ITest : IXmlNodeBuilder
-    {
-        /// <summary>
-        /// Gets or sets the id of the test
-        /// </summary>
-        int Id { get; set; }
-
-        /// <summary>
-        /// Gets the name of the test
-        /// </summary>
-        string Name { get; }
-
-        /// <summary>
-        /// Gets the fully qualified name of the test
-        /// </summary>
-        string FullName { get; }
-
-        /// <summary>
-        /// Gets the Type of the test fixture, if applicable, or
-        /// null if no fixture type is associated with this test.
-        /// </summary>
-        Type FixtureType { get; }
-
-        /// <summary>
-        /// Indicates whether the test can be run using
-        /// the RunState enum.
-        /// </summary>
-		RunState RunState { get; set; }
-
-        /// <summary>
-        /// Count of the test cases ( 1 if this is a test case )
-        /// </summary>
-		int TestCaseCount { get; }
-
-		/// <summary>
-		/// Gets the properties of the test
-		/// </summary>
-		IPropertyBag Properties { get; }
-
-        /// <summary>
-        /// Gets the parent test, if any.
-        /// </summary>
-        /// <value>The parent test or null if none exists.</value>
-        ITest Parent { get; }
-
-        /// <summary>
-        /// Gets a bool indicating whether the current test
-        /// has any descendant tests.
-        /// </summary>
-        bool HasChildren { get; }
-
-        /// <summary>
-        /// Gets this test's child tests
-        /// </summary>
-        /// <value>A list of child tests</value>
-#if CLR_2_0 || CLR_4_0
-        System.Collections.Generic.IList<ITest> Tests { get; }
-#else
-        System.Collections.IList Tests { get; }
-#endif
-    }
-}
-
+// ***********************************************************************
+// Copyright (c) 2007 Charlie Poole
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+// 
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+// ***********************************************************************
+
+using System;
+using NUnit.Framework.Internal;
+
+namespace NUnit.Framework.Api
+{
+	/// <summary>
+	/// Common interface supported by all representations
+	/// of a test. Only includes informational fields.
+	/// The Run method is specifically excluded to allow
+	/// for data-only representations of a test.
+	/// </summary>
+	public interface ITest : IXmlNodeBuilder
+    {
+        /// <summary>
+        /// Gets or sets the id of the test
+        /// </summary>
+        int Id { get; set; }
+
+        /// <summary>
+        /// Gets the name of the test
+        /// </summary>
+        string Name { get; }
+
+        /// <summary>
+        /// Gets the fully qualified name of the test
+        /// </summary>
+        string FullName { get; }
+
+        /// <summary>
+        /// Gets the Type of the test fixture, if applicable, or
+        /// null if no fixture type is associated with this test.
+        /// </summary>
+        Type FixtureType { get; }
+
+        /// <summary>
+        /// Indicates whether the test can be run using
+        /// the RunState enum.
+        /// </summary>
+		RunState RunState { get; set; }
+
+        /// <summary>
+        /// Count of the test cases ( 1 if this is a test case )
+        /// </summary>
+		int TestCaseCount { get; }
+
+		/// <summary>
+		/// Gets the properties of the test
+		/// </summary>
+		IPropertyBag Properties { get; }
+
+        /// <summary>
+        /// Gets the parent test, if any.
+        /// </summary>
+        /// <value>The parent test or null if none exists.</value>
+        ITest Parent { get; }
+
+        /// <summary>
+        /// Gets a bool indicating whether the current test
+        /// has any descendant tests.
+        /// </summary>
+        bool HasChildren { get; }
+
+        /// <summary>
+        /// Gets the Int value representing the seed for the RandomGenerator
+        /// </summary>
+        /// <value></value>
+        int Seed { get; }
+
+        /// <summary>
+        /// Gets this test's child tests
+        /// </summary>
+        /// <value>A list of child tests</value>
+#if CLR_2_0 || CLR_4_0
+        System.Collections.Generic.IList<ITest> Tests { get; }
+#else
+        System.Collections.IList Tests { get; }
+#endif
+    }
+}
+

=== modified file 'src/framework/Api/ITestFilter.cs'
--- src/framework/Api/ITestFilter.cs	2012-08-27 21:02:47 +0000
+++ src/framework/Api/ITestFilter.cs	2013-05-03 03:03:44 +0000
@@ -31,7 +31,12 @@
 	/// loaded, since this is the only time an ITest exists.
 	/// </summary>
 	public interface ITestFilter
-	{
+	{
+        /// <summary>
+        /// Indicates whether this is the EmptyFilter
+        /// </summary>
+        bool IsEmpty { get; }
+
 		/// <summary>
 		/// Determine if a particular test passes the filter criteria. Pass
 		/// may examine the parents and/or descendants of a test, depending

=== modified file 'src/framework/Internal/Builders/NUnitTestCaseBuilder.cs'
--- src/framework/Internal/Builders/NUnitTestCaseBuilder.cs	2012-10-08 22:37:39 +0000
+++ src/framework/Internal/Builders/NUnitTestCaseBuilder.cs	2013-05-03 03:03:44 +0000
@@ -1,400 +1,406 @@
-// ***********************************************************************
-// Copyright (c) 2008-2012 Charlie Poole
-//
-// Permission is hereby granted, free of charge, to any person obtaining
-// a copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to
-// permit persons to whom the Software is furnished to do so, subject to
-// the following conditions:
-// 
-// The above copyright notice and this permission notice shall be
-// included in all copies or substantial portions of the Software.
-// 
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-// ***********************************************************************
-
-using System;
-using System.Reflection;
-using NUnit.Framework.Api;
-using NUnit.Framework.Internal;
-using NUnit.Framework.Extensibility;
-using NUnit.Framework.Internal.Commands;
-
-#if NET_4_5
-using System.Threading.Tasks;
-#endif
-
-namespace NUnit.Framework.Builders
-{
-    /// <summary>
-    /// Class to build ether a parameterized or a normal NUnitTestMethod.
-    /// There are four cases that the builder must deal with:
-    ///   1. The method needs no params and none are provided
-    ///   2. The method needs params and they are provided
-    ///   3. The method needs no params but they are provided in error
-    ///   4. The method needs params but they are not provided
-    /// This could have been done using two different builders, but it
-    /// turned out to be simpler to have just one. The BuildFrom method
-    /// takes a different branch depending on whether any parameters are
-    /// provided, but all four cases are dealt with in lower-level methods
-    /// </summary>
-    public class NUnitTestCaseBuilder : ITestCaseBuilder2
-	{
-#if NUNITLITE
-        private ITestCaseProvider testCaseProvider = new TestCaseProviders();
-#else
-        private ITestCaseProvider testCaseProvider = CoreExtensions.Host.TestCaseProviders;
-#endif
-
-        #region ITestCaseBuilder Methods
-        /// <summary>
-        /// Determines if the method can be used to build an NUnit test
-        /// test method of some kind. The method must normally be marked
-        /// with an identifying attriute for this to be true.
-        /// 
-        /// Note that this method does not check that the signature
-        /// of the method for validity. If we did that here, any
-        /// test methods with invalid signatures would be passed
-        /// over in silence in the test run. Since we want such
-        /// methods to be reported, the check for validity is made
-        /// in BuildFrom rather than here.
-        /// </summary>
-        /// <param name="method">A MethodInfo for the method being used as a test method</param>
-        /// <returns>True if the builder can create a test case from this method</returns>
-        public bool CanBuildFrom(MethodInfo method)
-        {
-            return method.IsDefined(typeof(TestAttribute), false)
-                || method.IsDefined(typeof(ITestCaseSource), false)
-                || method.IsDefined(typeof(TheoryAttribute), false);
-        }
-
-        /// <summary>
-        /// Build a Test from the provided MethodInfo. Depending on
-        /// whether the method takes arguments and on the availability
-        /// of test case data, this method may return a single test
-        /// or a group of tests contained in a ParameterizedMethodSuite.
-        /// </summary>
-        /// <param name="method">The MethodInfo for which a test is to be built</param>
-        /// <returns>A Test representing one or more method invocations</returns>
-        public Test BuildFrom(MethodInfo method)
-		{
-            return BuildFrom(method, null);
-        }
-
-        #endregion
-
-        #region ITestCaseBuilder2 Members
-
-        /// <summary>
-        /// Determines if the method can be used to build an NUnit test
-        /// test method of some kind. The method must normally be marked
-        /// with an identifying attriute for this to be true.
-        /// 
-        /// Note that this method does not check that the signature
-        /// of the method for validity. If we did that here, any
-        /// test methods with invalid signatures would be passed
-        /// over in silence in the test run. Since we want such
-        /// methods to be reported, the check for validity is made
-        /// in BuildFrom rather than here.
-        /// </summary>
-        /// <param name="method">A MethodInfo for the method being used as a test method</param>
-        /// <param name="parentSuite">The test suite being built, to which the new test would be added</param>
-        /// <returns>True if the builder can create a test case from this method</returns>
-        public bool CanBuildFrom(MethodInfo method, Test parentSuite)
-        {
-            return CanBuildFrom(method);
-        }
-
-        /// <summary>
-        /// Build a Test from the provided MethodInfo. Depending on
-        /// whether the method takes arguments and on the availability
-        /// of test case data, this method may return a single test
-        /// or a group of tests contained in a ParameterizedMethodSuite.
-        /// </summary>
-        /// <param name="method">The MethodInfo for which a test is to be built</param>
-        /// <param name="parentSuite">The test fixture being populated, or null</param>
-        /// <returns>A Test representing one or more method invocations</returns>
-        public Test BuildFrom(MethodInfo method, Test parentSuite)
-        {
-            return testCaseProvider.HasTestCasesFor(method)
-                ? BuildParameterizedMethodSuite(method, parentSuite)
-                : BuildSingleTestMethod(method, parentSuite, null);
-        }
-
-        #endregion
-
-        #region Implementation
-
-        /// <summary>
-        /// Builds a ParameterizedMetodSuite containing individual
-        /// test cases for each set of parameters provided for
-        /// this method.
-        /// </summary>
-        /// <param name="method">The MethodInfo for which a test is to be built</param>
-        /// <param name="parentSuite">The test suite for which the method is being built</param>
-        /// <returns>A ParameterizedMethodSuite populated with test cases</returns>
-        public Test BuildParameterizedMethodSuite(MethodInfo method, Test parentSuite)
-        {
-            ParameterizedMethodSuite methodSuite = new ParameterizedMethodSuite(method);
-            methodSuite.ApplyAttributesToTest(method);
-
-            foreach (ITestCaseData testcase in testCaseProvider.GetTestCasesFor(method))
-            {
-                ParameterSet parms = testcase as ParameterSet;
-                if (parms == null)
-                    parms = new ParameterSet(testcase);
-
-                TestMethod test = BuildSingleTestMethod(method, parentSuite, parms);
-
-                methodSuite.Add(test);
-            }
-
-            return methodSuite;
-        }
-
-        /// <summary>
-        /// Builds a single NUnitTestMethod, either as a child of the fixture 
-        /// or as one of a set of test cases under a ParameterizedTestMethodSuite.
-        /// </summary>
-        /// <param name="method">The MethodInfo from which to construct the TestMethod</param>
-        /// <param name="parentSuite">The suite or fixture to which the new test will be added</param>
-        /// <param name="parms">The ParameterSet to be used, or null</param>
-        /// <returns></returns>
-        public static TestMethod BuildSingleTestMethod(MethodInfo method, Test parentSuite, ParameterSet parms)
-        {
-            TestMethod testMethod = new TestMethod(method, parentSuite);
-
-            string prefix = method.ReflectedType.FullName;
-
-            // Needed to give proper fullname to test in a parameterized fixture.
-            // Without this, the arguments to the fixture are not included.
-            if (parentSuite != null)
-            {
-                prefix = parentSuite.FullName;
-                //testMethod.FullName = prefix + "." + testMethod.Name;
-            }
-
-            if (CheckTestMethodSignature(testMethod, parms))
-            {
-                if (parms == null)
-                    testMethod.ApplyAttributesToTest(method);
-
-                foreach (ICommandDecorator decorator in method.GetCustomAttributes(typeof(ICommandDecorator), true))
-                    testMethod.CustomDecorators.Add(decorator);
-
-                ExpectedExceptionAttribute[] attributes =
-                    (ExpectedExceptionAttribute[])method.GetCustomAttributes(typeof(ExpectedExceptionAttribute), false);
-
-                if (attributes.Length > 0)
-                {
-                    ExpectedExceptionAttribute attr = attributes[0];
-                    string handlerName = attr.Handler;
-                    if (handlerName != null && GetExceptionHandler(testMethod.FixtureType, handlerName) == null)
-                        MarkAsNotRunnable(
-                            testMethod, 
-                            string.Format("The specified exception handler {0} was not found", handlerName));
-
-                    testMethod.CustomDecorators.Add(new ExpectedExceptionDecorator(attr.ExceptionData));
-                }
-            }
-
-            if (parms != null)
-            {
-                // NOTE: After the call to CheckTestMethodSignature, the Method
-                // property of testMethod may no longer be the same as the
-                // original MethodInfo, so we reassign it here.
-                method = testMethod.Method;
-
-                if (parms.TestName != null)
-                {
-                    testMethod.Name = parms.TestName;
-                    testMethod.FullName = prefix + "." + parms.TestName;
-                }
-                else if (parms.OriginalArguments != null)
-                {
-                    string name = MethodHelper.GetDisplayName(method, parms.OriginalArguments);
-                    testMethod.Name = name;
-                    testMethod.FullName = prefix + "." + name;
-                }
-
-                parms.ApplyToTest(testMethod);
-            }
-
-            return testMethod;
-        }
-
-		#endregion
-
-        #region Helper Methods
-
-        /// <summary>
-        /// Helper method that checks the signature of a TestMethod and
-        /// any supplied parameters to determine if the test is valid.
-        /// 
-        /// Currently, NUnitTestMethods are required to be public, 
-        /// non-abstract methods, either static or instance,
-        /// returning void. They may take arguments but the values must
-        /// be provided or the TestMethod is not considered runnable.
-        /// 
-        /// Methods not meeting these criteria will be marked as
-        /// non-runnable and the method will return false in that case.
-        /// </summary>
-        /// <param name="testMethod">The TestMethod to be checked. If it
-        /// is found to be non-runnable, it will be modified.</param>
-        /// <param name="parms">Parameters to be used for this test, or null</param>
-        /// <returns>True if the method signature is valid, false if not</returns>
-        private static bool CheckTestMethodSignature(TestMethod testMethod, ParameterSet parms)
-		{
-            if (testMethod.Method.IsAbstract)
-            {
-                return MarkAsNotRunnable(testMethod, "Method is abstract");
-            }
-
-            if (!testMethod.Method.IsPublic)
-            {
-                return MarkAsNotRunnable(testMethod, "Method is not public");
-            }
-
-#if NETCF
-            // TODO: Get this to work
-            if (testMethod.Method.IsGenericMethodDefinition)
-            {
-                return MarkAsNotRunnable(testMethod, "Generic test methods are not yet supported under .NET CF");
-            }
-#endif
-
-            ParameterInfo[] parameters = testMethod.Method.GetParameters();
-            int argsNeeded = parameters.Length;
-
-            object[] arglist = null;
-            int argsProvided = 0;
-
-            if (parms != null)
-            {
-                testMethod.parms = parms;
-                testMethod.RunState = parms.RunState;
-
-                arglist = parms.Arguments;
-
-                if (arglist != null)
-                    argsProvided = arglist.Length;
-
-                if (testMethod.RunState != RunState.Runnable)
-                    return false;
-            }
-
-            Type returnType = testMethod.Method.ReturnType;
-            if (returnType.Equals(typeof(void)))
-            {
-                if (parms != null && parms.HasExpectedResult)
-                    return MarkAsNotRunnable(testMethod, "Method returning void cannot have an expected result");
-            }
-            else
-            {
-#if NET_4_5
-                if (MethodHelper.IsAsyncMethod(testMethod.Method))
-                {
-                    bool returnsGenericTask = returnType.IsGenericType && returnType.GetGenericTypeDefinition() == typeof(Task<>);
-                    if (returnsGenericTask && (parms == null|| !parms.HasExpectedResult && !parms.ExceptionExpected))
-                        return MarkAsNotRunnable(testMethod, "Async test method must have Task or void return type when no result is expected");
-                    else if (!returnsGenericTask && parms != null && parms.HasExpectedResult)
-                        return MarkAsNotRunnable(testMethod, "Async test method must have Task<T> return type when a result is expected");
-                }
-                else 
-#endif
-                if (parms == null || !parms.HasExpectedResult && !parms.ExceptionExpected)
-                    return MarkAsNotRunnable(testMethod, "Method has non-void return value, but no result is expected");
-            }
-
-            if (argsProvided > 0 && argsNeeded == 0)
-            {
-                return MarkAsNotRunnable(testMethod, "Arguments provided for method not taking any");
-            }
-
-            if (argsProvided == 0 && argsNeeded > 0)
-            {
-                return MarkAsNotRunnable(testMethod, "No arguments were provided");
-            }
-
-            if (argsProvided != argsNeeded)
-            {
-                return MarkAsNotRunnable(testMethod, "Wrong number of arguments provided");
-            }
-
-#if CLR_2_0 || CLR_4_0
-#if !NETCF
-            if (testMethod.Method.IsGenericMethodDefinition)
-            {
-                Type[] typeArguments = GetTypeArgumentsForMethod(testMethod.Method, arglist);
-                foreach (object o in typeArguments)
-                    if (o == null)
-                    {
-                        return MarkAsNotRunnable(testMethod, "Unable to determine type arguments for method");
-                    }
-
-                testMethod.method = testMethod.Method.MakeGenericMethod(typeArguments);
-                parameters = testMethod.Method.GetParameters();
-           }
-#endif
-#endif
-
-           if (arglist != null && parameters != null)
-               TypeHelper.ConvertArgumentList(arglist, parameters);
-
-            return true;
-        }
-
-#if CLR_2_0 || CLR_4_0
-#if !NETCF
-        private static Type[] GetTypeArgumentsForMethod(MethodInfo method, object[] arglist)
-        {
-            Type[] typeParameters = method.GetGenericArguments();
-            Type[] typeArguments = new Type[typeParameters.Length];
-            ParameterInfo[] parameters = method.GetParameters();
-
-            for (int typeIndex = 0; typeIndex < typeArguments.Length; typeIndex++)
-            {
-                Type typeParameter = typeParameters[typeIndex];
-
-                for (int argIndex = 0; argIndex < parameters.Length; argIndex++)
-                {
-                    if (parameters[argIndex].ParameterType.Equals(typeParameter))
-                        typeArguments[typeIndex] = TypeHelper.BestCommonType(
-                            typeArguments[typeIndex],
-                            arglist[argIndex].GetType());
-                }
-            }
-
-            return typeArguments;
-        }
-#endif
-#endif
-
-        private static MethodInfo GetExceptionHandler(Type fixtureType, string name)
-        {
-            return fixtureType.GetMethod(
-                name,
-                BindingFlags.Static | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic,
-                null,
-                new Type[] { typeof(System.Exception) },
-                null);
-        }
-
-        private static bool MarkAsNotRunnable(TestMethod testMethod, string reason)
-        {
-            testMethod.RunState = RunState.NotRunnable;
-            testMethod.Properties.Set(PropertyNames.SkipReason, reason);
-            return false;
-        }
-
-        #endregion
-    }
-}
+// ***********************************************************************
+// Copyright (c) 2008-2012 Charlie Poole
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+// 
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+// ***********************************************************************
+
+using System;
+using System.Reflection;
+using NUnit.Framework.Api;
+using NUnit.Framework.Internal;
+using NUnit.Framework.Extensibility;
+using NUnit.Framework.Internal.Commands;
+
+#if NET_4_5
+using System.Threading.Tasks;
+#endif
+
+namespace NUnit.Framework.Builders
+{
+    /// <summary>
+    /// Class to build ether a parameterized or a normal NUnitTestMethod.
+    /// There are four cases that the builder must deal with:
+    ///   1. The method needs no params and none are provided
+    ///   2. The method needs params and they are provided
+    ///   3. The method needs no params but they are provided in error
+    ///   4. The method needs params but they are not provided
+    /// This could have been done using two different builders, but it
+    /// turned out to be simpler to have just one. The BuildFrom method
+    /// takes a different branch depending on whether any parameters are
+    /// provided, but all four cases are dealt with in lower-level methods
+    /// </summary>
+    public class NUnitTestCaseBuilder : ITestCaseBuilder2
+	{
+#if NUNITLITE
+        private ITestCaseProvider testCaseProvider = new TestCaseProviders();
+#else
+        private ITestCaseProvider testCaseProvider = CoreExtensions.Host.TestCaseProviders;
+#endif
+
+        #region ITestCaseBuilder Methods
+        /// <summary>
+        /// Determines if the method can be used to build an NUnit test
+        /// test method of some kind. The method must normally be marked
+        /// with an identifying attriute for this to be true.
+        /// 
+        /// Note that this method does not check that the signature
+        /// of the method for validity. If we did that here, any
+        /// test methods with invalid signatures would be passed
+        /// over in silence in the test run. Since we want such
+        /// methods to be reported, the check for validity is made
+        /// in BuildFrom rather than here.
+        /// </summary>
+        /// <param name="method">A MethodInfo for the method being used as a test method</param>
+        /// <returns>True if the builder can create a test case from this method</returns>
+        public bool CanBuildFrom(MethodInfo method)
+        {
+            return method.IsDefined(typeof(TestAttribute), false)
+                || method.IsDefined(typeof(ITestCaseSource), false)
+                || method.IsDefined(typeof(TheoryAttribute), false);
+        }
+
+        /// <summary>
+        /// Build a Test from the provided MethodInfo. Depending on
+        /// whether the method takes arguments and on the availability
+        /// of test case data, this method may return a single test
+        /// or a group of tests contained in a ParameterizedMethodSuite.
+        /// </summary>
+        /// <param name="method">The MethodInfo for which a test is to be built</param>
+        /// <returns>A Test representing one or more method invocations</returns>
+        public Test BuildFrom(MethodInfo method)
+		{
+            return BuildFrom(method, null);
+        }
+
+        #endregion
+
+        #region ITestCaseBuilder2 Members
+
+        /// <summary>
+        /// Determines if the method can be used to build an NUnit test
+        /// test method of some kind. The method must normally be marked
+        /// with an identifying attriute for this to be true.
+        /// 
+        /// Note that this method does not check that the signature
+        /// of the method for validity. If we did that here, any
+        /// test methods with invalid signatures would be passed
+        /// over in silence in the test run. Since we want such
+        /// methods to be reported, the check for validity is made
+        /// in BuildFrom rather than here.
+        /// </summary>
+        /// <param name="method">A MethodInfo for the method being used as a test method</param>
+        /// <param name="parentSuite">The test suite being built, to which the new test would be added</param>
+        /// <returns>True if the builder can create a test case from this method</returns>
+        public bool CanBuildFrom(MethodInfo method, Test parentSuite)
+        {
+            return CanBuildFrom(method);
+        }
+
+        /// <summary>
+        /// Build a Test from the provided MethodInfo. Depending on
+        /// whether the method takes arguments and on the availability
+        /// of test case data, this method may return a single test
+        /// or a group of tests contained in a ParameterizedMethodSuite.
+        /// </summary>
+        /// <param name="method">The MethodInfo for which a test is to be built</param>
+        /// <param name="parentSuite">The test fixture being populated, or null</param>
+        /// <returns>A Test representing one or more method invocations</returns>
+        public Test BuildFrom(MethodInfo method, Test parentSuite)
+        {
+            return testCaseProvider.HasTestCasesFor(method)
+                ? BuildParameterizedMethodSuite(method, parentSuite)
+                : BuildSingleTestMethod(method, parentSuite, null);
+        }
+
+        #endregion
+
+        #region Implementation
+
+        /// <summary>
+        /// Builds a ParameterizedMetodSuite containing individual
+        /// test cases for each set of parameters provided for
+        /// this method.
+        /// </summary>
+        /// <param name="method">The MethodInfo for which a test is to be built</param>
+        /// <param name="parentSuite">The test suite for which the method is being built</param>
+        /// <returns>A ParameterizedMethodSuite populated with test cases</returns>
+        public Test BuildParameterizedMethodSuite(MethodInfo method, Test parentSuite)
+        {
+            ParameterizedMethodSuite methodSuite = new ParameterizedMethodSuite(method);
+            methodSuite.ApplyAttributesToTest(method);
+
+            foreach (ITestCaseData testcase in testCaseProvider.GetTestCasesFor(method))
+            {
+                ParameterSet parms = testcase as ParameterSet;
+                if (parms == null)
+                    parms = new ParameterSet(testcase);
+
+                TestMethod test = BuildSingleTestMethod(method, parentSuite, parms);
+
+                methodSuite.Add(test);
+            }
+
+            return methodSuite;
+        }
+
+        /// <summary>
+        /// Builds a single NUnitTestMethod, either as a child of the fixture 
+        /// or as one of a set of test cases under a ParameterizedTestMethodSuite.
+        /// </summary>
+        /// <param name="method">The MethodInfo from which to construct the TestMethod</param>
+        /// <param name="parentSuite">The suite or fixture to which the new test will be added</param>
+        /// <param name="parms">The ParameterSet to be used, or null</param>
+        /// <returns></returns>
+        public static TestMethod BuildSingleTestMethod(MethodInfo method, Test parentSuite, ParameterSet parms)
+        {
+            TestMethod testMethod = new TestMethod(method, parentSuite);
+#if !NETCF
+            Randomizer randomizer = Randomizer.GetRandomizer(MethodBase.GetCurrentMethod());
+#else
+            Randomizer randomizer = Randomizer.GetRandomizer(typeof(NUnitTestCaseBuilder).GetMethod("BuildSingleTestMethod"));
+#endif
+            testMethod.Seed = randomizer.Next();
+
+            string prefix = method.ReflectedType.FullName;
+
+            // Needed to give proper fullname to test in a parameterized fixture.
+            // Without this, the arguments to the fixture are not included.
+            if (parentSuite != null)
+            {
+                prefix = parentSuite.FullName;
+                //testMethod.FullName = prefix + "." + testMethod.Name;
+            }
+
+            if (CheckTestMethodSignature(testMethod, parms))
+            {
+                if (parms == null)
+                    testMethod.ApplyAttributesToTest(method);
+
+                foreach (ICommandDecorator decorator in method.GetCustomAttributes(typeof(ICommandDecorator), true))
+                    testMethod.CustomDecorators.Add(decorator);
+
+                ExpectedExceptionAttribute[] attributes =
+                    (ExpectedExceptionAttribute[])method.GetCustomAttributes(typeof(ExpectedExceptionAttribute), false);
+
+                if (attributes.Length > 0)
+                {
+                    ExpectedExceptionAttribute attr = attributes[0];
+                    string handlerName = attr.Handler;
+                    if (handlerName != null && GetExceptionHandler(testMethod.FixtureType, handlerName) == null)
+                        MarkAsNotRunnable(
+                            testMethod, 
+                            string.Format("The specified exception handler {0} was not found", handlerName));
+
+                    testMethod.CustomDecorators.Add(new ExpectedExceptionDecorator(attr.ExceptionData));
+                }
+            }
+
+            if (parms != null)
+            {
+                // NOTE: After the call to CheckTestMethodSignature, the Method
+                // property of testMethod may no longer be the same as the
+                // original MethodInfo, so we reassign it here.
+                method = testMethod.Method;
+
+                if (parms.TestName != null)
+                {
+                    testMethod.Name = parms.TestName;
+                    testMethod.FullName = prefix + "." + parms.TestName;
+                }
+                else if (parms.OriginalArguments != null)
+                {
+                    string name = MethodHelper.GetDisplayName(method, parms.OriginalArguments);
+                    testMethod.Name = name;
+                    testMethod.FullName = prefix + "." + name;
+                }
+
+                parms.ApplyToTest(testMethod);
+            }
+
+            return testMethod;
+        }
+
+		#endregion
+
+        #region Helper Methods
+
+        /// <summary>
+        /// Helper method that checks the signature of a TestMethod and
+        /// any supplied parameters to determine if the test is valid.
+        /// 
+        /// Currently, NUnitTestMethods are required to be public, 
+        /// non-abstract methods, either static or instance,
+        /// returning void. They may take arguments but the values must
+        /// be provided or the TestMethod is not considered runnable.
+        /// 
+        /// Methods not meeting these criteria will be marked as
+        /// non-runnable and the method will return false in that case.
+        /// </summary>
+        /// <param name="testMethod">The TestMethod to be checked. If it
+        /// is found to be non-runnable, it will be modified.</param>
+        /// <param name="parms">Parameters to be used for this test, or null</param>
+        /// <returns>True if the method signature is valid, false if not</returns>
+        private static bool CheckTestMethodSignature(TestMethod testMethod, ParameterSet parms)
+		{
+            if (testMethod.Method.IsAbstract)
+            {
+                return MarkAsNotRunnable(testMethod, "Method is abstract");
+            }
+
+            if (!testMethod.Method.IsPublic)
+            {
+                return MarkAsNotRunnable(testMethod, "Method is not public");
+            }
+
+#if NETCF
+            // TODO: Get this to work
+            if (testMethod.Method.IsGenericMethodDefinition)
+            {
+                return MarkAsNotRunnable(testMethod, "Generic test methods are not yet supported under .NET CF");
+            }
+#endif
+
+            ParameterInfo[] parameters = testMethod.Method.GetParameters();
+            int argsNeeded = parameters.Length;
+
+            object[] arglist = null;
+            int argsProvided = 0;
+
+            if (parms != null)
+            {
+                testMethod.parms = parms;
+                testMethod.RunState = parms.RunState;
+
+                arglist = parms.Arguments;
+
+                if (arglist != null)
+                    argsProvided = arglist.Length;
+
+                if (testMethod.RunState != RunState.Runnable)
+                    return false;
+            }
+
+            Type returnType = testMethod.Method.ReturnType;
+            if (returnType.Equals(typeof(void)))
+            {
+                if (parms != null && parms.HasExpectedResult)
+                    return MarkAsNotRunnable(testMethod, "Method returning void cannot have an expected result");
+            }
+            else
+            {
+#if NET_4_5
+                if (MethodHelper.IsAsyncMethod(testMethod.Method))
+                {
+                    bool returnsGenericTask = returnType.IsGenericType && returnType.GetGenericTypeDefinition() == typeof(Task<>);
+                    if (returnsGenericTask && (parms == null|| !parms.HasExpectedResult && !parms.ExceptionExpected))
+                        return MarkAsNotRunnable(testMethod, "Async test method must have Task or void return type when no result is expected");
+                    else if (!returnsGenericTask && parms != null && parms.HasExpectedResult)
+                        return MarkAsNotRunnable(testMethod, "Async test method must have Task<T> return type when a result is expected");
+                }
+                else 
+#endif
+                if (parms == null || !parms.HasExpectedResult && !parms.ExceptionExpected)
+                    return MarkAsNotRunnable(testMethod, "Method has non-void return value, but no result is expected");
+            }
+
+            if (argsProvided > 0 && argsNeeded == 0)
+            {
+                return MarkAsNotRunnable(testMethod, "Arguments provided for method not taking any");
+            }
+
+            if (argsProvided == 0 && argsNeeded > 0)
+            {
+                return MarkAsNotRunnable(testMethod, "No arguments were provided");
+            }
+
+            if (argsProvided != argsNeeded)
+            {
+                return MarkAsNotRunnable(testMethod, "Wrong number of arguments provided");
+            }
+
+#if CLR_2_0 || CLR_4_0
+#if !NETCF
+            if (testMethod.Method.IsGenericMethodDefinition)
+            {
+                Type[] typeArguments = GetTypeArgumentsForMethod(testMethod.Method, arglist);
+                foreach (object o in typeArguments)
+                    if (o == null)
+                    {
+                        return MarkAsNotRunnable(testMethod, "Unable to determine type arguments for method");
+                    }
+
+                testMethod.method = testMethod.Method.MakeGenericMethod(typeArguments);
+                parameters = testMethod.Method.GetParameters();
+           }
+#endif
+#endif
+
+           if (arglist != null && parameters != null)
+               TypeHelper.ConvertArgumentList(arglist, parameters);
+
+            return true;
+        }
+
+#if CLR_2_0 || CLR_4_0
+#if !NETCF
+        private static Type[] GetTypeArgumentsForMethod(MethodInfo method, object[] arglist)
+        {
+            Type[] typeParameters = method.GetGenericArguments();
+            Type[] typeArguments = new Type[typeParameters.Length];
+            ParameterInfo[] parameters = method.GetParameters();
+
+            for (int typeIndex = 0; typeIndex < typeArguments.Length; typeIndex++)
+            {
+                Type typeParameter = typeParameters[typeIndex];
+
+                for (int argIndex = 0; argIndex < parameters.Length; argIndex++)
+                {
+                    if (parameters[argIndex].ParameterType.Equals(typeParameter))
+                        typeArguments[typeIndex] = TypeHelper.BestCommonType(
+                            typeArguments[typeIndex],
+                            arglist[argIndex].GetType());
+                }
+            }
+
+            return typeArguments;
+        }
+#endif
+#endif
+
+        private static MethodInfo GetExceptionHandler(Type fixtureType, string name)
+        {
+            return fixtureType.GetMethod(
+                name,
+                BindingFlags.Static | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic,
+                null,
+                new Type[] { typeof(System.Exception) },
+                null);
+        }
+
+        private static bool MarkAsNotRunnable(TestMethod testMethod, string reason)
+        {
+            testMethod.RunState = RunState.NotRunnable;
+            testMethod.Properties.Set(PropertyNames.SkipReason, reason);
+            return false;
+        }
+
+        #endregion
+    }
+}

=== added file 'src/framework/Internal/Filters/SimpleCategoryExpression.cs'
--- src/framework/Internal/Filters/SimpleCategoryExpression.cs	1970-01-01 00:00:00 +0000
+++ src/framework/Internal/Filters/SimpleCategoryExpression.cs	2013-05-03 03:03:44 +0000
@@ -0,0 +1,49 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using NUnit.Framework.Internal;
+using NUnit.Framework.Internal.Filters;
+
+namespace NUnit.Framework.Internal.Filters
+{
+    /// <summary>
+    /// SimpleCategoryFilter parses a basic string representing a
+    /// single category or a list of categories separated by commas
+    /// </summary>
+    public class SimpleCategoryExpression
+    {
+        private string text;
+
+        private TestFilter filter;
+
+        /// <summary>
+        /// Construct category filter from a text string
+        /// </summary>
+        /// <param name="text">A list of categories to parse</param>
+        public SimpleCategoryExpression(string text)
+        {
+            this.text = text;
+        }
+
+        /// <summary>
+        /// Gets the TestFilter represented by the expression
+        /// </summary>
+        public TestFilter Filter
+        {
+            get
+            {
+                if (filter == null)
+                {
+                    filter = GetCategories(); 
+                }
+                return filter;
+            }
+        }
+
+        private TestFilter GetCategories()
+        {
+            string[] categories = text.Split(',');
+            return new CategoryFilter(categories);
+        }
+    }
+}

=== added file 'src/framework/Internal/RandomGenerator.cs'
--- src/framework/Internal/RandomGenerator.cs	1970-01-01 00:00:00 +0000
+++ src/framework/Internal/RandomGenerator.cs	2013-05-03 03:03:44 +0000
@@ -0,0 +1,184 @@
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+
+namespace NUnit.Framework.Internal
+{
+    /// <summary>
+    /// This is a wrapper class for Random. 
+    ///     Additionaly functionality is built into this class to handle the following:
+    ///	        Random Int
+    ///	        Random Short
+    ///	        Random Bool
+    ///     	Random Float
+    ///	        Random Double
+    ///	        Random Enum
+    /// </summary>
+    public class RandomGenerator
+    {
+        #region Members & Constructor
+        /// <summary>
+        /// Seed for the wrapped Random
+        /// </summary>
+        public readonly int seed;
+
+        private Random random;
+
+        /// <summary>
+        /// Lazy-loaded Random built on the readonly Seed
+        /// </summary>
+        private Random Rand
+        {
+            get
+            {
+                random = random == null ? new Random(seed) : random;
+                return random;
+            }
+        }
+
+        /// <summary>
+        /// Constructor requires Seed value in order to store it for use in Random creation
+        /// </summary>
+        /// <param name="seed"></param>
+        public RandomGenerator(int seed)
+        {
+            this.seed = seed;
+        }
+        #endregion
+
+        #region Ints
+        /// <summary>
+        /// Get Next Integer from Random 
+        /// </summary>
+        /// <returns> int </returns>
+        public int GetInt()
+        {
+            return Rand.Next();
+        }
+        /// <summary>
+        /// Get Next Integer within the specified min & max from Random 
+        /// </summary>
+        /// <param name="min"></param>
+        /// <param name="max"></param>
+        /// <returns> int </returns>
+        public int GetInt(int min, int max)
+        {
+            return Rand.Next(min, max);
+        }
+        #endregion
+
+        #region Shorts
+        /// <summary>
+        /// Get Next Short from Random
+        /// </summary>
+        /// <returns> short </returns>
+        public short GetShort()
+        {
+            return (short)Rand.Next(short.MinValue, short.MaxValue);
+        }
+        /// <summary>
+        /// Get Next Short within the specified min & max from Random 
+        /// </summary>
+        /// <param name="min"></param>
+        /// <param name="max"></param>
+        /// <returns> short </returns>
+        public short GetShort(short min, short max)
+        {
+            return (short)Rand.Next(min, max);
+        }
+        #endregion
+
+        #region Bytes
+        /// <summary>
+        /// Get Next Byte from Random
+        /// </summary>
+        /// <returns> byte </returns>
+        public byte GetByte()
+        {
+            return (byte)Rand.Next(Byte.MinValue, Byte.MaxValue);
+        }
+        /// <summary>
+        /// Get Next Byte within the specified min & max from Random
+        /// </summary>
+        /// <param name="min"></param>
+        /// <param name="max"></param>
+        /// <returns> byte </returns>
+        public byte GetByte(byte min, byte max)
+        {
+            return (byte)Rand.Next(min, max);
+        }
+        #endregion
+
+        #region Bools
+        /// <summary>
+        /// Get Random Boolean value
+        /// </summary>
+        /// <returns> bool </returns>
+        public bool GetBool()
+        {
+            return Rand.Next(0, 1) == 0;
+        }
+        /// <summary>
+        /// Get Random Boolean value based on the probability of that value being true
+        /// </summary>
+        /// <param name="probability"></param>
+        /// <returns> bool </returns>
+        public bool GetBool(double probability)
+        {
+            return Rand.NextDouble() < Math.Abs(probability % 1.0);
+        }
+        #endregion
+
+        #region Double & Float
+        /// <summary>
+        /// Get Next Double from Random
+        /// </summary>
+        /// <returns></returns>
+        public double GetDouble()
+        {
+            return Rand.NextDouble();
+        }
+        /// <summary>
+        /// Get Next Float from Random
+        /// </summary>
+        /// <returns></returns>
+        public float GetFloat()
+        {
+            return (float)Rand.NextDouble();
+        }
+        #endregion
+
+        #region Enums
+#if SILVERLIGHT || NETCF
+        /// <summary>
+        /// Return a random enum value from the specified type
+        /// </summary>
+        /// <param name="enumType"></param>
+        /// <returns> object </returns>
+        public object GetEnum(Type enumType)
+        {
+            List<string> enumNames = new List<string>();
+            foreach (FieldInfo fi in enumType.GetType().GetFields(BindingFlags.Static | BindingFlags.Public)){
+                enumNames.Add(fi.Name);
+            }
+            string enumeration = enumNames[Rand.Next(0, enumNames.Count)];
+            return Enum.Parse(enumType, enumeration, true);
+        }
+
+#else
+        /// <summary>
+        /// Return a random enum value representation of the specified Type
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <returns> T </returns>
+        public T GetEnum<T>()
+        {
+            string[] items = Enum.GetNames(typeof(T));
+            string enumeration = items[Rand.Next(0, items.Length)];
+            return (T)Enum.Parse(typeof(T), enumeration, true);
+        }
+#endif
+        #endregion
+
+    }
+}

=== modified file 'src/framework/Internal/TestExecutionContext.cs'
--- src/framework/Internal/TestExecutionContext.cs	2012-12-25 00:26:29 +0000
+++ src/framework/Internal/TestExecutionContext.cs	2013-05-03 03:03:44 +0000
@@ -1,608 +1,625 @@
-// ***********************************************************************
-// Copyright (c) 2011 Charlie Poole
-//
-// Permission is hereby granted, free of charge, to any person obtaining
-// a copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to
-// permit persons to whom the Software is furnished to do so, subject to
-// the following conditions:
-// 
-// The above copyright notice and this permission notice shall be
-// included in all copies or substantial portions of the Software.
-// 
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-// ***********************************************************************
-
-using System;
-using System.Collections;
-using System.Collections.Specialized;
-using System.IO;
-using System.Diagnostics;
-using System.Globalization;
-using System.Threading;
-
-#if !NUNITLITE
-using System.Security.Principal;
-#endif
-
-using NUnit.Framework.Api;
-#if !NETCF
-using System.Runtime.Remoting.Messaging;
-#endif
-
-namespace NUnit.Framework.Internal
-{
-	/// <summary>
-	/// Helper class used to save and restore certain static or
-	/// singleton settings in the environment that affect tests 
-	/// or which might be changed by the user tests.
-	/// 
-	/// An internal class is used to hold settings and a stack
-	/// of these objects is pushed and popped as Save and Restore
-	/// are called.
-	/// 
-	/// Static methods for each setting forward to the internal 
-	/// object on the top of the stack.
-	/// </summary>
-	public class TestExecutionContext
-#if !SILVERLIGHT && !NETCF
-        : ILogicalThreadAffinative
-#endif
-	{
-        #region Instance Fields
-
-        /// <summary>
-        /// Link to a prior saved context
-        /// </summary>
-        public TestExecutionContext prior;
-
-        /// <summary>
-        /// The currently executing test
-        /// </summary>
-        private Test currentTest;
-
-        /// <summary>
-        /// The time the test began execution
-        /// </summary>
-        private DateTime startTime;
-
-        /// <summary>
-        /// The active TestResult for the current test
-        /// </summary>
-        private TestResult currentResult;
-		
-		/// <summary>
-		/// The work directory to receive test output
-		/// </summary>
-		private string workDirectory;
-		
-        /// <summary>
-        /// The object on which tests are currently being executed - i.e. the user fixture object
-        /// </summary>
-        private object testObject;
-
-        /// <summary>
-        /// The event listener currently receiving notifications
-        /// </summary>
-        private ITestListener listener = TestListener.NULL;
-
-        /// <summary>
-        /// The number of assertions for the current test
-        /// </summary>
-        private int assertCount;
-
-        /// <summary>
-        /// Indicates whether execution should terminate after the first error
-        /// </summary>
-        private bool stopOnError;
-
-        /// <summary>
-        /// Default timeout for test cases
-        /// </summary>
-        private int testCaseTimeout;
-
-#if !NETCF
-        /// <summary>
-        /// The current culture
-        /// </summary>
-        private CultureInfo currentCulture;
-
-        /// <summary>
-        /// The current UI culture
-        /// </summary>
-        private CultureInfo currentUICulture;
-#endif
-
-#if !NETCF && !SILVERLIGHT
-        /// <summary>
-        /// Destination for standard output
-        /// </summary>
-        private TextWriter outWriter;
-
-        /// <summary>
-        /// Destination for standard error
-        /// </summary>
-        private TextWriter errorWriter;
-
-        /// <summary>
-		/// Indicates whether trace is enabled
-		/// </summary>
-		private bool tracing;
-
-        /// <summary>
-        /// Destination for Trace output
-        /// </summary>
-        private TextWriter traceWriter;
-#endif
-
-#if !NUNITLITE
-        /// <summary>
-        /// Indicates whether logging is enabled
-        /// </summary>
-        private bool logging;
-
-		/// <summary>
-		/// The current working directory
-		/// </summary>
-		private string currentDirectory;
-
-		private Log4NetCapture logCapture;
-
-        /// <summary>
-        /// The current Principal.
-        /// </summary>
-		private IPrincipal currentPrincipal;
-#endif
-
-        #endregion
-
-        #region Constructors
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="TestExecutionContext"/> class.
-        /// </summary>
-        public TestExecutionContext()
-		{
-			this.prior = null;
-            this.testCaseTimeout = 0;
-
-#if !NETCF
-            this.currentCulture = CultureInfo.CurrentCulture;
-            this.currentUICulture = CultureInfo.CurrentUICulture;
-#endif
-
-#if !NETCF && !SILVERLIGHT
-			this.outWriter = Console.Out;
-			this.errorWriter = Console.Error;
-            this.traceWriter = null;
-            this.tracing = false;
-#endif
-
-#if !NUNITLITE
-			this.logging = false;
-			this.currentDirectory = Environment.CurrentDirectory;
-            this.logCapture = new Log4NetCapture();
-            this.currentPrincipal = Thread.CurrentPrincipal;
-#endif
-        }
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="TestExecutionContext"/> class.
-        /// </summary>
-        /// <param name="other">An existing instance of TestExecutionContext.</param>
-		public TestExecutionContext( TestExecutionContext other )
-		{
-			this.prior = other;
-
-            this.currentTest = other.currentTest;
-            this.currentResult = other.currentResult;
-            this.testObject = other.testObject;
-			this.workDirectory = other.workDirectory;
-            this.listener = other.listener;
-            this.stopOnError = other.stopOnError;
-            this.testCaseTimeout = other.testCaseTimeout;
-
-#if !NETCF
-            this.currentCulture = CultureInfo.CurrentCulture;
-            this.currentUICulture = CultureInfo.CurrentUICulture;
-#endif
-
-#if !NETCF && !SILVERLIGHT
-			this.outWriter = other.outWriter;
-			this.errorWriter = other.errorWriter;
-            this.traceWriter = other.traceWriter;
-            this.tracing = other.tracing;
-#endif
-
-#if !NUNITLITE
-			this.logging = other.logging;
-			this.currentDirectory = Environment.CurrentDirectory;
-            this.logCapture = other.logCapture;
-            this.currentPrincipal = Thread.CurrentPrincipal;
-#endif
-        }
-
-        #endregion
-
-        #region Static Singleton Instance
-
-        /// <summary>
-        /// The current context, head of the list of saved contexts.
-        /// </summary>
-#if SILVERLIGHT || NETCF
-#if (CLR_2_0 || CLR_4_0) && !NETCF
-        [ThreadStatic]
-#endif
-        private static TestExecutionContext current;
-#endif
-
-        /// <summary>
-        /// Gets the current context.
-        /// </summary>
-        /// <value>The current context.</value>
-        public static TestExecutionContext CurrentContext
-        {
-            get 
-            {
-#if SILVERLIGHT || NETCF
-                if (current == null)
-                    current = new TestExecutionContext();
-
-                return current; 
-#else
-                return CallContext.GetData("NUnit.Framework.TestContext") as TestExecutionContext;
-#endif
-            }
-        }
-
-        #endregion
-
-        #region Static Methods
-
-        internal static void SetCurrentContext(TestExecutionContext ec)
-        {
-#if SILVERLIGHT || NETCF
-            current = ec;
-#else
-            CallContext.SetData("NUnit.Framework.TestContext", ec);
-#endif
-        }
-
-        #endregion
-
-        #region Properties
-
-        /// <summary>
-        /// Gets or sets the current test
-        /// </summary>
-        public Test CurrentTest
-        {
-            get { return currentTest; }
-            set { currentTest = value; }
-        }
-
-        /// <summary>
-        /// The time the current test started execution
-        /// </summary>
-        public DateTime StartTime
-        {
-            get { return startTime; }
-            set { startTime = value; }
-        }
-
-        /// <summary>
-        /// Gets or sets the current test result
-        /// </summary>
-        public TestResult CurrentResult
-        {
-            get { return currentResult; }
-            set { currentResult = value; }
-        }
-
-        /// <summary>
-        /// The current test object - that is the user fixture
-        /// object on which tests are being executed.
-        /// </summary>
-        public object TestObject
-        {
-            get { return testObject; }
-            set { testObject = value; }
-        }
-		
-        /// <summary>
-        /// Get or set the working directory
-        /// </summary>
-		public string WorkDirectory
-		{
-			get { return workDirectory; }
-			set { workDirectory = value; }
-		}
-
-        /// <summary>
-        /// Get or set indicator that run should stop on the first error
-        /// </summary>
-        public bool StopOnError
-        {
-            get { return stopOnError; }
-            set { stopOnError = value; }
-        }
-		
-        /// <summary>
-        /// The current test event listener
-        /// </summary>
-        internal ITestListener Listener
-        {
-            get { return listener; }
-            set { listener = value; }
-        }
-
-        /// <summary>
-        /// Gets the assert count.
-        /// </summary>
-        /// <value>The assert count.</value>
-        internal int AssertCount
-        {
-            get { return assertCount; }
-            set { assertCount = value; }
-        }
-
-        /// <summary>
-        /// Gets or sets the test case timeout vaue
-        /// </summary>
-        public int TestCaseTimeout
-        {
-            get { return testCaseTimeout; }
-            set { testCaseTimeout = value; }
-        }
-
-#if !NETCF
-        /// <summary>
-        /// Saves or restores the CurrentCulture
-        /// </summary>
-        public CultureInfo CurrentCulture
-        {
-            get { return currentCulture; }
-            set
-            {
-                currentCulture = value;
-                Thread.CurrentThread.CurrentCulture = currentCulture;
-            }
-        }
-
-        /// <summary>
-        /// Saves or restores the CurrentUICulture
-        /// </summary>
-        public CultureInfo CurrentUICulture
-        {
-            get { return currentUICulture; }
-            set
-            {
-                currentUICulture = value;
-                Thread.CurrentThread.CurrentUICulture = currentUICulture;
-            }
-        }
-#endif
-
-#if !NETCF && !SILVERLIGHT
-        /// <summary>
-		/// Controls where Console.Out is directed
-		/// </summary>
-		internal TextWriter Out
-		{
-			get { return outWriter; }
-			set 
-			{
-				if ( outWriter != value )
-				{
-					outWriter = value; 
-					Console.Out.Flush();
-					Console.SetOut( outWriter );
-				}
-			}
-		}
-
-		/// <summary>
-		/// Controls where Console.Error is directed
-		/// </summary>
-		internal TextWriter Error
-		{
-			get { return errorWriter; }
-			set 
-			{
-				if ( errorWriter != value )
-				{
-					errorWriter = value; 
-					Console.Error.Flush();
-					Console.SetError( errorWriter );
-				}
-			}
-		}
-
-        /// <summary>
-        /// Controls whether trace and debug output are written
-        /// to the standard output.
-        /// </summary>
-        internal bool Tracing
-        {
-            get { return tracing; }
-            set
-            {
-                if (tracing != value)
+// ***********************************************************************
+// Copyright (c) 2011 Charlie Poole
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+// 
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+// ***********************************************************************
+
+using System;
+using System.Collections;
+using System.Collections.Specialized;
+using System.IO;
+using System.Diagnostics;
+using System.Globalization;
+using System.Threading;
+
+#if !NUNITLITE
+using System.Security.Principal;
+#endif
+
+using NUnit.Framework.Api;
+#if !NETCF
+using System.Runtime.Remoting.Messaging;
+#endif
+
+namespace NUnit.Framework.Internal
+{
+	/// <summary>
+	/// Helper class used to save and restore certain static or
+	/// singleton settings in the environment that affect tests 
+	/// or which might be changed by the user tests.
+	/// 
+	/// An internal class is used to hold settings and a stack
+	/// of these objects is pushed and popped as Save and Restore
+	/// are called.
+	/// 
+	/// Static methods for each setting forward to the internal 
+	/// object on the top of the stack.
+	/// </summary>
+	public class TestExecutionContext
+#if !SILVERLIGHT && !NETCF
+        : ILogicalThreadAffinative
+#endif
+	{
+        #region Instance Fields
+
+        /// <summary>
+        /// Link to a prior saved context
+        /// </summary>
+        public TestExecutionContext prior;
+
+        /// <summary>
+        /// The currently executing test
+        /// </summary>
+        private Test currentTest;
+
+        /// <summary>
+        /// The time the test began execution
+        /// </summary>
+        private DateTime startTime;
+
+        /// <summary>
+        /// The active TestResult for the current test
+        /// </summary>
+        private TestResult currentResult;
+		
+		/// <summary>
+		/// The work directory to receive test output
+		/// </summary>
+		private string workDirectory;
+		
+        /// <summary>
+        /// The object on which tests are currently being executed - i.e. the user fixture object
+        /// </summary>
+        private object testObject;
+
+        /// <summary>
+        /// The event listener currently receiving notifications
+        /// </summary>
+        private ITestListener listener = TestListener.NULL;
+
+        /// <summary>
+        /// The number of assertions for the current test
+        /// </summary>
+        private int assertCount;
+
+        /// <summary>
+        /// Indicates whether execution should terminate after the first error
+        /// </summary>
+        private bool stopOnError;
+
+        /// <summary>
+        /// Default timeout for test cases
+        /// </summary>
+        private int testCaseTimeout;
+
+        private RandomGenerator random;
+
+#if !NETCF
+        /// <summary>
+        /// The current culture
+        /// </summary>
+        private CultureInfo currentCulture;
+
+        /// <summary>
+        /// The current UI culture
+        /// </summary>
+        private CultureInfo currentUICulture;
+#endif
+
+#if !NETCF && !SILVERLIGHT
+        /// <summary>
+        /// Destination for standard output
+        /// </summary>
+        private TextWriter outWriter;
+
+        /// <summary>
+        /// Destination for standard error
+        /// </summary>
+        private TextWriter errorWriter;
+
+        /// <summary>
+		/// Indicates whether trace is enabled
+		/// </summary>
+		private bool tracing;
+
+        /// <summary>
+        /// Destination for Trace output
+        /// </summary>
+        private TextWriter traceWriter;
+#endif
+
+#if !NUNITLITE
+        /// <summary>
+        /// Indicates whether logging is enabled
+        /// </summary>
+        private bool logging;
+
+		/// <summary>
+		/// The current working directory
+		/// </summary>
+		private string currentDirectory;
+
+		private Log4NetCapture logCapture;
+
+        /// <summary>
+        /// The current Principal.
+        /// </summary>
+		private IPrincipal currentPrincipal;
+#endif
+
+        #endregion
+
+        #region Constructors
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="TestExecutionContext"/> class.
+        /// </summary>
+        public TestExecutionContext()
+		{
+			this.prior = null;
+            this.testCaseTimeout = 0;
+
+#if !NETCF
+            this.currentCulture = CultureInfo.CurrentCulture;
+            this.currentUICulture = CultureInfo.CurrentUICulture;
+#endif
+
+#if !NETCF && !SILVERLIGHT
+			this.outWriter = Console.Out;
+			this.errorWriter = Console.Error;
+            this.traceWriter = null;
+            this.tracing = false;
+#endif
+
+#if !NUNITLITE
+			this.logging = false;
+			this.currentDirectory = Environment.CurrentDirectory;
+            this.logCapture = new Log4NetCapture();
+            this.currentPrincipal = Thread.CurrentPrincipal;
+#endif
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="TestExecutionContext"/> class.
+        /// </summary>
+        /// <param name="other">An existing instance of TestExecutionContext.</param>
+		public TestExecutionContext( TestExecutionContext other )
+		{
+			this.prior = other;
+
+            this.currentTest = other.currentTest;
+            this.currentResult = other.currentResult;
+            this.testObject = other.testObject;
+			this.workDirectory = other.workDirectory;
+            this.listener = other.listener;
+            this.stopOnError = other.stopOnError;
+            this.testCaseTimeout = other.testCaseTimeout;
+
+#if !NETCF
+            this.currentCulture = CultureInfo.CurrentCulture;
+            this.currentUICulture = CultureInfo.CurrentUICulture;
+#endif
+
+#if !NETCF && !SILVERLIGHT
+			this.outWriter = other.outWriter;
+			this.errorWriter = other.errorWriter;
+            this.traceWriter = other.traceWriter;
+            this.tracing = other.tracing;
+#endif
+
+#if !NUNITLITE
+			this.logging = other.logging;
+			this.currentDirectory = Environment.CurrentDirectory;
+            this.logCapture = other.logCapture;
+            this.currentPrincipal = Thread.CurrentPrincipal;
+#endif
+        }
+
+        #endregion
+
+        #region Static Singleton Instance
+
+        /// <summary>
+        /// The current context, head of the list of saved contexts.
+        /// </summary>
+#if SILVERLIGHT || NETCF
+#if (CLR_2_0 || CLR_4_0) && !NETCF
+        [ThreadStatic]
+#endif
+        private static TestExecutionContext current;
+#endif
+
+        /// <summary>
+        /// Gets the current context.
+        /// </summary>
+        /// <value>The current context.</value>
+        public static TestExecutionContext CurrentContext
+        {
+            get 
+            {
+#if SILVERLIGHT || NETCF
+                if (current == null)
+                    current = new TestExecutionContext();
+
+                return current; 
+#else
+                return CallContext.GetData("NUnit.Framework.TestContext") as TestExecutionContext;
+#endif
+            }
+        }
+
+        #endregion
+
+        #region Static Methods
+
+        internal static void SetCurrentContext(TestExecutionContext ec)
+        {
+#if SILVERLIGHT || NETCF
+            current = ec;
+#else
+            CallContext.SetData("NUnit.Framework.TestContext", ec);
+#endif
+        }
+
+        #endregion
+
+        #region Properties
+
+        /// <summary>
+        /// Gets or sets the current test
+        /// </summary>
+        public Test CurrentTest
+        {
+            get { return currentTest; }
+            set { currentTest = value; }
+        }
+
+        /// <summary>
+        /// The time the current test started execution
+        /// </summary>
+        public DateTime StartTime
+        {
+            get { return startTime; }
+            set { startTime = value; }
+        }
+
+        /// <summary>
+        /// Gets or sets the current test result
+        /// </summary>
+        public TestResult CurrentResult
+        {
+            get { return currentResult; }
+            set { currentResult = value; }
+        }
+
+        /// <summary>
+        /// The current test object - that is the user fixture
+        /// object on which tests are being executed.
+        /// </summary>
+        public object TestObject
+        {
+            get { return testObject; }
+            set { testObject = value; }
+        }
+		
+        /// <summary>
+        /// Get or set the working directory
+        /// </summary>
+		public string WorkDirectory
+		{
+			get { return workDirectory; }
+			set { workDirectory = value; }
+		}
+
+        /// <summary>
+        /// Get or set indicator that run should stop on the first error
+        /// </summary>
+        public bool StopOnError
+        {
+            get { return stopOnError; }
+            set { stopOnError = value; }
+        }
+		
+        /// <summary>
+        /// The current test event listener
+        /// </summary>
+        internal ITestListener Listener
+        {
+            get { return listener; }
+            set { listener = value; }
+        }
+
+        /// <summary>
+        /// Gets the RandomGenerator specific to this Test
+        /// </summary>
+        public RandomGenerator Random
+        {
+            get
+            {
+                if (random == null)
                 {
-                    if (traceWriter != null && tracing)
-                        StopTracing();
-
-                    tracing = value;
-
-                    if (traceWriter != null && tracing)
-                        StartTracing();
+                    random = new RandomGenerator(currentTest.Seed);
                 }
-            }
-        }
-
-        /// <summary>
-        /// Controls where Trace output is directed
-        /// </summary>
-		internal TextWriter TraceWriter
-		{
-			get { return traceWriter; }
-			set
-			{
-				if ( traceWriter != value )
-				{
-					if ( traceWriter != null  && tracing )
-						StopTracing();
-
-					traceWriter = value;
-
-					if ( traceWriter != null && tracing )
-						StartTracing();
-				}
-			}
-		}
-
-		private void StopTracing()
-		{
-			traceWriter.Close();
-			System.Diagnostics.Trace.Listeners.Remove( "NUnit" );
-		}
-
-		private void StartTracing()
-		{
-			System.Diagnostics.Trace.Listeners.Add( new TextWriterTraceListener( traceWriter, "NUnit" ) );
-		}
-#endif
-
-#if !NUNITLITE
-        /// <summary>
-        /// Controls whether log output is captured
-        /// </summary>
-        public bool Logging
-        {
-            get { return logCapture.Enabled; }
-            set { logCapture.Enabled = value; }
-        }
-
-        /// <summary>
-        ///  Gets or sets the Log writer, which is actually held by a log4net 
-        ///  TextWriterAppender. When first set, the appender will be created
-        ///  and will thereafter send any log events to the writer.
-        ///  
-        ///  In normal operation, LogWriter is set to an EventListenerTextWriter
-        ///  connected to the EventQueue in the test domain. The events are
-        ///  subsequently captured in the Gui an the output displayed in
-        ///  the Log tab. The application under test does not need to define
-        ///  any additional appenders.
-        /// </summary>
-        public TextWriter LogWriter
-        {
-            get { return logCapture.Writer; }
-            set { logCapture.Writer = value; }
-        }
-        
-        /// <summary>
-        /// Saves and restores the CurrentDirectory
-        /// </summary>
-		public string CurrentDirectory
-		{
-			get { return currentDirectory; }
-			set
-			{
-				currentDirectory = value;
-				Environment.CurrentDirectory = currentDirectory;
-			}
-		}
-
-        /// <summary>
-        /// Gets or sets the current <see cref="IPrincipal"/> for the Thread.
-        /// </summary>
-		public IPrincipal CurrentPrincipal
-		{
-		    get { return this.currentPrincipal; }
-            set
-            {
-                this.currentPrincipal = value;
-                Thread.CurrentPrincipal = this.currentPrincipal;
-            }
-		}
-#endif
-
-        #endregion
-
-        #region Instance Methods
-
-        /// <summary>
-        /// Saves the old context and returns a fresh one 
-        /// with the same settings.
-        /// </summary>
-        public TestExecutionContext Save()
-        {
-            return new TestExecutionContext(this);
-        }
-
-        /// <summary>
-        /// Restores the last saved context and puts
-        /// any saved settings back into effect.
-        /// </summary>
-        public TestExecutionContext Restore()
-        {
-            if (prior == null)
-                throw new InvalidOperationException("TestContext: too many Restores");
-
-            this.TestCaseTimeout = prior.TestCaseTimeout;
-
-#if !NETCF
-            this.CurrentCulture = prior.CurrentCulture;
-            this.CurrentUICulture = prior.CurrentUICulture;
-#endif
-
-#if !NETCF && !SILVERLIGHT
-            this.Out = prior.Out;
-            this.Error = prior.Error;
-            this.Tracing = prior.Tracing;
-#endif
-
-#if !NUNITLITE
-            this.CurrentDirectory = prior.CurrentDirectory;
-			this.CurrentPrincipal = prior.CurrentPrincipal;
-#endif
-
-            return prior;
-        }
-
-        /// <summary>
-        /// Record any changes in the environment made by
-        /// the test code in the execution context so it
-        /// will be passed on to lower level tests.
-        /// </summary>
-        public void UpdateContext()
-        {
-#if !NETCF
-            this.currentCulture = CultureInfo.CurrentCulture;
-            this.currentUICulture = CultureInfo.CurrentUICulture;
-#endif
-#if !NUNITLITE
-            this.currentDirectory = Environment.CurrentDirectory;
-            this.currentPrincipal = System.Threading.Thread.CurrentPrincipal;
-#endif
-        }
-
-        /// <summary>
-        /// Increments the assert count.
-        /// </summary>
-        public void IncrementAssertCount()
-        {
-            System.Threading.Interlocked.Increment(ref assertCount);
-        }
-
-        #endregion
+                return random;
+            }
+        }
+
+        /// <summary>
+        /// Gets the assert count.
+        /// </summary>
+        /// <value>The assert count.</value>
+        internal int AssertCount
+        {
+            get { return assertCount; }
+            set { assertCount = value; }
+        }
+
+        /// <summary>
+        /// Gets or sets the test case timeout vaue
+        /// </summary>
+        public int TestCaseTimeout
+        {
+            get { return testCaseTimeout; }
+            set { testCaseTimeout = value; }
+        }
+
+#if !NETCF
+        /// <summary>
+        /// Saves or restores the CurrentCulture
+        /// </summary>
+        public CultureInfo CurrentCulture
+        {
+            get { return currentCulture; }
+            set
+            {
+                currentCulture = value;
+                Thread.CurrentThread.CurrentCulture = currentCulture;
+            }
+        }
+
+        /// <summary>
+        /// Saves or restores the CurrentUICulture
+        /// </summary>
+        public CultureInfo CurrentUICulture
+        {
+            get { return currentUICulture; }
+            set
+            {
+                currentUICulture = value;
+                Thread.CurrentThread.CurrentUICulture = currentUICulture;
+            }
+        }
+#endif
+
+#if !NETCF && !SILVERLIGHT
+        /// <summary>
+		/// Controls where Console.Out is directed
+		/// </summary>
+		internal TextWriter Out
+		{
+			get { return outWriter; }
+			set 
+			{
+				if ( outWriter != value )
+				{
+					outWriter = value; 
+					Console.Out.Flush();
+					Console.SetOut( outWriter );
+				}
+			}
+		}
+
+		/// <summary>
+		/// Controls where Console.Error is directed
+		/// </summary>
+		internal TextWriter Error
+		{
+			get { return errorWriter; }
+			set 
+			{
+				if ( errorWriter != value )
+				{
+					errorWriter = value; 
+					Console.Error.Flush();
+					Console.SetError( errorWriter );
+				}
+			}
+		}
+
+        /// <summary>
+        /// Controls whether trace and debug output are written
+        /// to the standard output.
+        /// </summary>
+        internal bool Tracing
+        {
+            get { return tracing; }
+            set
+            {
+                if (tracing != value)
+                {
+                    if (traceWriter != null && tracing)
+                        StopTracing();
+
+                    tracing = value;
+
+                    if (traceWriter != null && tracing)
+                        StartTracing();
+                }
+            }
+        }
+
+        /// <summary>
+        /// Controls where Trace output is directed
+        /// </summary>
+		internal TextWriter TraceWriter
+		{
+			get { return traceWriter; }
+			set
+			{
+				if ( traceWriter != value )
+				{
+					if ( traceWriter != null  && tracing )
+						StopTracing();
+
+					traceWriter = value;
+
+					if ( traceWriter != null && tracing )
+						StartTracing();
+				}
+			}
+		}
+
+		private void StopTracing()
+		{
+			traceWriter.Close();
+			System.Diagnostics.Trace.Listeners.Remove( "NUnit" );
+		}
+
+		private void StartTracing()
+		{
+			System.Diagnostics.Trace.Listeners.Add( new TextWriterTraceListener( traceWriter, "NUnit" ) );
+		}
+#endif
+
+#if !NUNITLITE
+        /// <summary>
+        /// Controls whether log output is captured
+        /// </summary>
+        public bool Logging
+        {
+            get { return logCapture.Enabled; }
+            set { logCapture.Enabled = value; }
+        }
+
+        /// <summary>
+        ///  Gets or sets the Log writer, which is actually held by a log4net 
+        ///  TextWriterAppender. When first set, the appender will be created
+        ///  and will thereafter send any log events to the writer.
+        ///  
+        ///  In normal operation, LogWriter is set to an EventListenerTextWriter
+        ///  connected to the EventQueue in the test domain. The events are
+        ///  subsequently captured in the Gui an the output displayed in
+        ///  the Log tab. The application under test does not need to define
+        ///  any additional appenders.
+        /// </summary>
+        public TextWriter LogWriter
+        {
+            get { return logCapture.Writer; }
+            set { logCapture.Writer = value; }
+        }
+        
+        /// <summary>
+        /// Saves and restores the CurrentDirectory
+        /// </summary>
+		public string CurrentDirectory
+		{
+			get { return currentDirectory; }
+			set
+			{
+				currentDirectory = value;
+				Environment.CurrentDirectory = currentDirectory;
+			}
+		}
+
+        /// <summary>
+        /// Gets or sets the current <see cref="IPrincipal"/> for the Thread.
+        /// </summary>
+		public IPrincipal CurrentPrincipal
+		{
+		    get { return this.currentPrincipal; }
+            set
+            {
+                this.currentPrincipal = value;
+                Thread.CurrentPrincipal = this.currentPrincipal;
+            }
+		}
+#endif
+
+        #endregion
+
+        #region Instance Methods
+
+        /// <summary>
+        /// Saves the old context and returns a fresh one 
+        /// with the same settings.
+        /// </summary>
+        public TestExecutionContext Save()
+        {
+            return new TestExecutionContext(this);
+        }
+
+        /// <summary>
+        /// Restores the last saved context and puts
+        /// any saved settings back into effect.
+        /// </summary>
+        public TestExecutionContext Restore()
+        {
+            if (prior == null)
+                throw new InvalidOperationException("TestContext: too many Restores");
+
+            this.TestCaseTimeout = prior.TestCaseTimeout;
+
+#if !NETCF
+            this.CurrentCulture = prior.CurrentCulture;
+            this.CurrentUICulture = prior.CurrentUICulture;
+#endif
+
+#if !NETCF && !SILVERLIGHT
+            this.Out = prior.Out;
+            this.Error = prior.Error;
+            this.Tracing = prior.Tracing;
+#endif
+
+#if !NUNITLITE
+            this.CurrentDirectory = prior.CurrentDirectory;
+			this.CurrentPrincipal = prior.CurrentPrincipal;
+#endif
+
+            return prior;
+        }
+
+        /// <summary>
+        /// Record any changes in the environment made by
+        /// the test code in the execution context so it
+        /// will be passed on to lower level tests.
+        /// </summary>
+        public void UpdateContext()
+        {
+#if !NETCF
+            this.currentCulture = CultureInfo.CurrentCulture;
+            this.currentUICulture = CultureInfo.CurrentUICulture;
+#endif
+#if !NUNITLITE
+            this.currentDirectory = Environment.CurrentDirectory;
+            this.currentPrincipal = System.Threading.Thread.CurrentPrincipal;
+#endif
+        }
+
+        /// <summary>
+        /// Increments the assert count.
+        /// </summary>
+        public void IncrementAssertCount()
+        {
+            System.Threading.Interlocked.Increment(ref assertCount);
+        }
+
+        #endregion
 	}
-}
+}

=== modified file 'src/framework/Internal/TestFilter.cs'
--- src/framework/Internal/TestFilter.cs	2012-09-15 18:55:04 +0000
+++ src/framework/Internal/TestFilter.cs	2013-05-03 03:03:44 +0000
@@ -37,7 +37,15 @@
 		/// <summary>
 		/// Unique Empty filter.
 		/// </summary>
-        public static TestFilter Empty = new EmptyFilter();
+        public static TestFilter Empty = new EmptyFilter();
+
+        /// <summary>
+        /// Indicates whether this is the EmptyFilter
+        /// </summary>
+        public bool IsEmpty
+        {
+            get { return this is TestFilter.EmptyFilter; }
+        }
 
 		/// <summary>
 		/// Determine if a particular test passes the filter criteria. The default 

=== modified file 'src/framework/Internal/Tests/Test.cs'
--- src/framework/Internal/Tests/Test.cs	2012-10-31 18:06:35 +0000
+++ src/framework/Internal/Tests/Test.cs	2013-05-03 03:03:44 +0000
@@ -1,404 +1,415 @@
-// ***********************************************************************
-// Copyright (c) 2012 Charlie Poole
-//
-// Permission is hereby granted, free of charge, to any person obtaining
-// a copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to
-// permit persons to whom the Software is furnished to do so, subject to
-// the following conditions:
-// 
-// The above copyright notice and this permission notice shall be
-// included in all copies or substantial portions of the Software.
-// 
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-// ***********************************************************************
-
-using System;
-using System.Reflection;
-using NUnit.Framework.Api;
-using NUnit.Framework.Internal.Commands;
-using NUnit.Framework.Internal.WorkItems;
-
-namespace NUnit.Framework.Internal
-{
-	/// <summary>
-	/// The Test abstract class represents a test within the framework.
-	/// </summary>
-	public abstract class Test : ITest, IComparable
-    {
-        #region Fields
-
-        /// <summary>
-        /// Static value to seed ids. It's started at 1000 so any
-        /// uninitialized ids will stand out.
-        /// </summary>
-        private static int nextID = 1000;
-
-        private int id;
-        private string name;
-        private string fullName;
-
-        /// <summary>
-		/// Indicates whether the test should be executed
-		/// </summary>
-		private RunState runState;
-
-		/// <summary>
-		/// Test suite containing this test, or null
-		/// </summary>
-		private ITest parent;
-		
-		/// <summary>
-		/// A dictionary of properties, used to add information
-		/// to tests without requiring the class to change.
-		/// </summary>
-		private PropertyBag properties;
-
-        /// <summary>
-        /// The System.Type of the fixture for this test, if there is one
-        /// </summary>
-        private Type fixtureType;
-
-        /// <summary>
-        /// The fixture object, if it has been created
-        /// </summary>
-        private object fixture;
-
-        /// <summary>
-        /// The SetUp methods.
-        /// </summary>
-        protected MethodInfo[] setUpMethods;
-
-        /// <summary>
-        /// The teardown methods
-        /// </summary>
-        protected MethodInfo[] tearDownMethods;
-
-        #endregion
-
-        #region Construction
-
-        /// <summary>
-		/// Constructs a test given its name
-		/// </summary>
-		/// <param name="name">The name of the test</param>
-		protected Test( string name )
-		{
-			this.fullName = name;
-			this.name = name;
-            this.id = unchecked(nextID++);
-
-            this.runState = RunState.Runnable;
-		}
-
-		/// <summary>
-		/// Constructs a test given the path through the
-		/// test hierarchy to its parent and a name.
-		/// </summary>
-		/// <param name="pathName">The parent tests full name</param>
-		/// <param name="name">The name of the test</param>
-		protected Test( string pathName, string name ) 
-		{ 
-			this.fullName = pathName == null || pathName == string.Empty 
-				? name : pathName + "." + name;
-			this.name = name;
-            this.id = unchecked(nextID++);
-
-            this.runState = RunState.Runnable;
-		}
-
-        /// <summary>
-        ///  TODO: Documentation needed for constructor
-        /// </summary>
-        /// <param name="fixtureType"></param>
-        protected Test(Type fixtureType) : this(fixtureType.FullName)
-        {
-            this.fixtureType = fixtureType;
-        }
-
-		#endregion
-
-		#region ITest Members
-
-        /// <summary>
-        /// Gets or sets the id of the test
-        /// </summary>
-        /// <value></value>
-        public int Id
-        {
-            get { return id; }
-            set { id = value; }
-        }
-
-        /// <summary>
-        /// Gets or sets the name of the test
-        /// </summary>
-        public string Name
-        {
-            get { return name; }
-            set { name = value; }
-        }
-
-        /// <summary>
-        /// Gets or sets the fully qualified name of the test
-        /// </summary>
-        /// <value></value>
-        public string FullName
-        {
-            get { return fullName; }
-            set { fullName = value; }
-        }
-
-        /// <summary>
-        /// Gets the Type of the fixture used in running this test
-        /// or null if no fixture type is associated with it.
-        /// </summary>
-        public Type FixtureType
-        {
-            get { return fixtureType; }
-        }
-
-        /// <summary>
-		/// Whether or not the test should be run
-		/// </summary>
-        public RunState RunState
-        {
-            get { return runState; }
-            set { runState = value; }
-        }
-
-        /// <summary>
-        /// Gets the name used for the top-level element in the
-        /// XML representation of this test
-        /// </summary>
-        public abstract string XmlElementName
-        {
-            get;
-        }
-
-        /// <summary>
-        /// Gets a string representing the type of test. Used as an attribute
-        /// value in the XML representation of a test and has no other
-        /// function in the framework.
-        /// </summary>
-        public virtual string TestType
-        {
-            get { return this.GetType().Name; }
-        }
-
-        /// <summary>
-		/// Gets a count of test cases represented by
-		/// or contained under this test.
-		/// </summary>
-		public virtual int TestCaseCount 
-		{ 
-			get { return 1; } 
-		}
-
-		/// <summary>
-		/// Gets the properties for this test
-		/// </summary>
-		public IPropertyBag Properties
-		{
-			get 
-			{
-				if ( properties == null )
-					properties = new PropertyBag();
-
-				return properties; 
-			}
-		}
-
-        /// <summary>
-        /// Gets a bool indicating whether the current test
-        /// has any descendant tests.
-        /// </summary>
-        public abstract bool HasChildren { get; }
-
-        /// <summary>
-        /// Gets the parent as a Test object.
-        /// Used by the core to set the parent.
-        /// </summary>
-        public ITest Parent
-        {
-            get { return parent; }
-            set { parent = value; }
-        }
-
-        /// <summary>
-        /// Gets this test's child tests
-        /// </summary>
-        /// <value>A list of child tests</value>
-        
-#if CLR_2_0 || CLR_4_0
-        public abstract System.Collections.Generic.IList<ITest> Tests { get; }
-#else
-        public abstract System.Collections.IList Tests { get; }
-#endif
-
-        #endregion
-
-        #region IXmlNodeBuilder Members
-
-        /// <summary>
-        /// Returns the Xml representation of the test
-        /// </summary>
-        /// <param name="recursive">If true, include child tests recursively</param>
-        /// <returns></returns>
-        public XmlNode ToXml(bool recursive)
-        {
-            XmlNode topNode = XmlNode.CreateTopLevelElement("dummy");
-
-            XmlNode thisNode = AddToXml(topNode, recursive);
-
-            return thisNode;
-        }
-
-        /// <summary>
-        /// Returns an XmlNode representing the current result after
-        /// adding it as a child of the supplied parent node.
-        /// </summary>
-        /// <param name="parentNode">The parent node.</param>
-        /// <param name="recursive">If true, descendant results are included</param>
-        /// <returns></returns>
-        public abstract XmlNode AddToXml(XmlNode parentNode, bool recursive);
-
-        #endregion
-
-        #region IComparable Members
-
-        /// <summary>
-        /// Compares this test to another test for sorting purposes
-        /// </summary>
-        /// <param name="obj">The other test</param>
-        /// <returns>Value of -1, 0 or +1 depending on whether the current test is less than, equal to or greater than the other test</returns>
-        public int CompareTo(object obj)
-        {
-            Test other = obj as Test;
-
-            if (other == null)
-                return -1;
-
-            return this.FullName.CompareTo(other.FullName);
-        }
-
-        #endregion
-
-        #region Other Public Methods
-
-        /// <summary>
-        /// Creates a TestResult for this test.
-        /// </summary>
-        /// <returns>A TestResult suitable for this type of test.</returns>
-        public abstract TestResult MakeTestResult();
-
-        ///// <summary>
-        ///// Gets a count of test cases that would be run using
-        ///// the specified filter.
-        ///// </summary>
-        ///// <param name="filter"></param>
-        ///// <returns></returns>
-        //public virtual int CountTestCases(TestFilter filter)
-        //{
-        //    if (filter.Pass(this))
-        //        return 1;
-
-        //    return 0;
-        //}
-
-        /// <summary>
-        /// Modify a newly constructed test by applying any of NUnit's common
-        /// attributes, based on a supplied ICustomAttributeProvider, which is
-        /// usually the reflection element from which the test was constructed,
-        /// but may not be in some instances. The attributes retrieved are 
-        /// saved for use in subsequent operations.
-        /// </summary>
-        /// <param name="provider">An object implementing ICustomAttributeProvider</param>
-        public void ApplyAttributesToTest(ICustomAttributeProvider provider)
-        {
-            foreach (IApplyToTest iApply in provider.GetCustomAttributes(typeof(IApplyToTest), true))
-                iApply.ApplyToTest(this);
-        }
-
-        #endregion
-
-        #region Protected Methods
-
-        /// <summary>
-        /// Add standard attributes and members to a test node.
-        /// </summary>
-        /// <param name="thisNode"></param>
-        /// <param name="recursive"></param>
-        protected void PopulateTestNode(XmlNode thisNode, bool recursive)
-        {
-            thisNode.AddAttribute("id", this.Id.ToString());
-            thisNode.AddAttribute("name", this.Name);
-            thisNode.AddAttribute("fullname", this.FullName);
-
-            if (Properties.Count > 0)
-                Properties.AddToXml(thisNode, recursive);
-        }
-
-        #endregion
-
-        #region Internal Properties
-
-        /// <summary>
-        /// Gets or sets a fixture object for running this test.
-        /// Provided for use by LegacySuiteBuilder.
-        /// </summary>
-        internal object Fixture
-        {
-            get { return fixture; }
-            set { fixture = value; }
-        }
-
-        /// <summary>
-        /// Gets the set up methods.
-        /// </summary>
-        /// <returns></returns>
-        internal virtual MethodInfo[] SetUpMethods
-        {
-            get
-            {
-                if (setUpMethods == null && this.Parent != null)
-                {
-                    TestSuite suite = this.Parent as TestSuite;
-                    if (suite != null)
-                        setUpMethods = suite.SetUpMethods;
-                }
-
-                return setUpMethods;
-            }
-        }
-
-        /// <summary>
-        /// Gets the tear down methods.
-        /// </summary>
-        /// <returns></returns>
-        internal virtual MethodInfo[] TearDownMethods
-        {
-            get
-            {
-                if (tearDownMethods == null && this.Parent != null)
-                {
-                    TestSuite suite = this.Parent as TestSuite;
-                    if (suite != null)
-                        tearDownMethods = suite.TearDownMethods;
-                }
-
-                return tearDownMethods;
-            }
-        }
-
-        #endregion
-    }
-}
+// ***********************************************************************
+// Copyright (c) 2012 Charlie Poole
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+// 
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+// ***********************************************************************
+
+using System;
+using System.Reflection;
+using NUnit.Framework.Api;
+using NUnit.Framework.Internal.Commands;
+using NUnit.Framework.Internal.WorkItems;
+
+namespace NUnit.Framework.Internal
+{
+	/// <summary>
+	/// The Test abstract class represents a test within the framework.
+	/// </summary>
+	public abstract class Test : ITest, IComparable
+    {
+        #region Fields
+
+        /// <summary>
+        /// Static value to seed ids. It's started at 1000 so any
+        /// uninitialized ids will stand out.
+        /// </summary>
+        private static int nextID = 1000;
+
+        private int id;
+        private string name;
+        private string fullName;
+        private int seed;
+
+        /// <summary>
+		/// Indicates whether the test should be executed
+		/// </summary>
+		private RunState runState;
+
+		/// <summary>
+		/// Test suite containing this test, or null
+		/// </summary>
+		private ITest parent;
+		
+		/// <summary>
+		/// A dictionary of properties, used to add information
+		/// to tests without requiring the class to change.
+		/// </summary>
+		private PropertyBag properties;
+
+        /// <summary>
+        /// The System.Type of the fixture for this test, if there is one
+        /// </summary>
+        private Type fixtureType;
+
+        /// <summary>
+        /// The fixture object, if it has been created
+        /// </summary>
+        private object fixture;
+
+        /// <summary>
+        /// The SetUp methods.
+        /// </summary>
+        protected MethodInfo[] setUpMethods;
+
+        /// <summary>
+        /// The teardown methods
+        /// </summary>
+        protected MethodInfo[] tearDownMethods;
+
+        #endregion
+
+        #region Construction
+
+        /// <summary>
+		/// Constructs a test given its name
+		/// </summary>
+		/// <param name="name">The name of the test</param>
+		protected Test( string name )
+		{
+			this.fullName = name;
+			this.name = name;
+            this.id = unchecked(nextID++);
+
+            this.runState = RunState.Runnable;
+		}
+
+		/// <summary>
+		/// Constructs a test given the path through the
+		/// test hierarchy to its parent and a name.
+		/// </summary>
+		/// <param name="pathName">The parent tests full name</param>
+		/// <param name="name">The name of the test</param>
+		protected Test( string pathName, string name ) 
+		{ 
+			this.fullName = pathName == null || pathName == string.Empty 
+				? name : pathName + "." + name;
+			this.name = name;
+            this.id = unchecked(nextID++);
+
+            this.runState = RunState.Runnable;
+		}
+
+        /// <summary>
+        ///  TODO: Documentation needed for constructor
+        /// </summary>
+        /// <param name="fixtureType"></param>
+        protected Test(Type fixtureType) : this(fixtureType.FullName)
+        {
+            this.fixtureType = fixtureType;
+        }
+
+		#endregion
+
+		#region ITest Members
+
+        /// <summary>
+        /// Gets or sets the id of the test
+        /// </summary>
+        /// <value></value>
+        public int Id
+        {
+            get { return id; }
+            set { id = value; }
+        }
+
+        /// <summary>
+        /// Gets or sets the name of the test
+        /// </summary>
+        public string Name
+        {
+            get { return name; }
+            set { name = value; }
+        }
+
+        /// <summary>
+        /// Gets or sets the fully qualified name of the test
+        /// </summary>
+        /// <value></value>
+        public string FullName
+        {
+            get { return fullName; }
+            set { fullName = value; }
+        }
+
+        /// <summary>
+        /// Gets the Type of the fixture used in running this test
+        /// or null if no fixture type is associated with it.
+        /// </summary>
+        public Type FixtureType
+        {
+            get { return fixtureType; }
+        }
+
+        /// <summary>
+		/// Whether or not the test should be run
+		/// </summary>
+        public RunState RunState
+        {
+            get { return runState; }
+            set { runState = value; }
+        }
+
+        /// <summary>
+        /// Gets the name used for the top-level element in the
+        /// XML representation of this test
+        /// </summary>
+        public abstract string XmlElementName
+        {
+            get;
+        }
+
+        /// <summary>
+        /// Gets a string representing the type of test. Used as an attribute
+        /// value in the XML representation of a test and has no other
+        /// function in the framework.
+        /// </summary>
+        public virtual string TestType
+        {
+            get { return this.GetType().Name; }
+        }
+
+        /// <summary>
+		/// Gets a count of test cases represented by
+		/// or contained under this test.
+		/// </summary>
+		public virtual int TestCaseCount 
+		{ 
+			get { return 1; } 
+		}
+
+		/// <summary>
+		/// Gets the properties for this test
+		/// </summary>
+		public IPropertyBag Properties
+		{
+			get 
+			{
+				if ( properties == null )
+					properties = new PropertyBag();
+
+				return properties; 
+			}
+		}
+
+        /// <summary>
+        /// Gets a bool indicating whether the current test
+        /// has any descendant tests.
+        /// </summary>
+        public abstract bool HasChildren { get; }
+
+        /// <summary>
+        /// Gets the parent as a Test object.
+        /// Used by the core to set the parent.
+        /// </summary>
+        public ITest Parent
+        {
+            get { return parent; }
+            set { parent = value; }
+        }
+
+        /// <summary>
+        /// Gets or Sets the Int value representing the seed for the RandomGenerator
+        /// </summary>
+        /// <value></value>
+        public int Seed
+        {
+            get { return seed; }
+            set { seed = value; }
+        }
+
+        /// <summary>
+        /// Gets this test's child tests
+        /// </summary>
+        /// <value>A list of child tests</value>
+        
+#if CLR_2_0 || CLR_4_0
+        public abstract System.Collections.Generic.IList<ITest> Tests { get; }
+#else
+        public abstract System.Collections.IList Tests { get; }
+#endif
+
+        #endregion
+
+        #region IXmlNodeBuilder Members
+
+        /// <summary>
+        /// Returns the Xml representation of the test
+        /// </summary>
+        /// <param name="recursive">If true, include child tests recursively</param>
+        /// <returns></returns>
+        public XmlNode ToXml(bool recursive)
+        {
+            XmlNode topNode = XmlNode.CreateTopLevelElement("dummy");
+
+            XmlNode thisNode = AddToXml(topNode, recursive);
+
+            return thisNode;
+        }
+
+        /// <summary>
+        /// Returns an XmlNode representing the current result after
+        /// adding it as a child of the supplied parent node.
+        /// </summary>
+        /// <param name="parentNode">The parent node.</param>
+        /// <param name="recursive">If true, descendant results are included</param>
+        /// <returns></returns>
+        public abstract XmlNode AddToXml(XmlNode parentNode, bool recursive);
+
+        #endregion
+
+        #region IComparable Members
+
+        /// <summary>
+        /// Compares this test to another test for sorting purposes
+        /// </summary>
+        /// <param name="obj">The other test</param>
+        /// <returns>Value of -1, 0 or +1 depending on whether the current test is less than, equal to or greater than the other test</returns>
+        public int CompareTo(object obj)
+        {
+            Test other = obj as Test;
+
+            if (other == null)
+                return -1;
+
+            return this.FullName.CompareTo(other.FullName);
+        }
+
+        #endregion
+
+        #region Other Public Methods
+
+        /// <summary>
+        /// Creates a TestResult for this test.
+        /// </summary>
+        /// <returns>A TestResult suitable for this type of test.</returns>
+        public abstract TestResult MakeTestResult();
+
+        ///// <summary>
+        ///// Gets a count of test cases that would be run using
+        ///// the specified filter.
+        ///// </summary>
+        ///// <param name="filter"></param>
+        ///// <returns></returns>
+        //public virtual int CountTestCases(TestFilter filter)
+        //{
+        //    if (filter.Pass(this))
+        //        return 1;
+
+        //    return 0;
+        //}
+
+        /// <summary>
+        /// Modify a newly constructed test by applying any of NUnit's common
+        /// attributes, based on a supplied ICustomAttributeProvider, which is
+        /// usually the reflection element from which the test was constructed,
+        /// but may not be in some instances. The attributes retrieved are 
+        /// saved for use in subsequent operations.
+        /// </summary>
+        /// <param name="provider">An object implementing ICustomAttributeProvider</param>
+        public void ApplyAttributesToTest(ICustomAttributeProvider provider)
+        {
+            foreach (IApplyToTest iApply in provider.GetCustomAttributes(typeof(IApplyToTest), true))
+                iApply.ApplyToTest(this);
+        }
+
+        #endregion
+
+        #region Protected Methods
+
+        /// <summary>
+        /// Add standard attributes and members to a test node.
+        /// </summary>
+        /// <param name="thisNode"></param>
+        /// <param name="recursive"></param>
+        protected void PopulateTestNode(XmlNode thisNode, bool recursive)
+        {
+            thisNode.AddAttribute("id", this.Id.ToString());
+            thisNode.AddAttribute("name", this.Name);
+            thisNode.AddAttribute("fullname", this.FullName);
+
+            if (Properties.Count > 0)
+                Properties.AddToXml(thisNode, recursive);
+        }
+
+        #endregion
+
+        #region Internal Properties
+
+        /// <summary>
+        /// Gets or sets a fixture object for running this test.
+        /// Provided for use by LegacySuiteBuilder.
+        /// </summary>
+        internal object Fixture
+        {
+            get { return fixture; }
+            set { fixture = value; }
+        }
+
+        /// <summary>
+        /// Gets the set up methods.
+        /// </summary>
+        /// <returns></returns>
+        internal virtual MethodInfo[] SetUpMethods
+        {
+            get
+            {
+                if (setUpMethods == null && this.Parent != null)
+                {
+                    TestSuite suite = this.Parent as TestSuite;
+                    if (suite != null)
+                        setUpMethods = suite.SetUpMethods;
+                }
+
+                return setUpMethods;
+            }
+        }
+
+        /// <summary>
+        /// Gets the tear down methods.
+        /// </summary>
+        /// <returns></returns>
+        internal virtual MethodInfo[] TearDownMethods
+        {
+            get
+            {
+                if (tearDownMethods == null && this.Parent != null)
+                {
+                    TestSuite suite = this.Parent as TestSuite;
+                    if (suite != null)
+                        tearDownMethods = suite.TearDownMethods;
+                }
+
+                return tearDownMethods;
+            }
+        }
+
+        #endregion
+    }
+}

=== modified file 'src/framework/Runner/CommandLineOptions.cs'
--- src/framework/Runner/CommandLineOptions.cs	2012-09-15 18:55:04 +0000
+++ src/framework/Runner/CommandLineOptions.cs	2013-05-03 03:03:44 +0000
@@ -50,7 +50,9 @@
         private string exploreFile;
         private string resultFile;
         private string resultFormat;
-        private string outFile;
+        private string outFile;
+        private string includeCategory;
+        private string excludeCategory;
 
         private bool error = false;
 
@@ -142,6 +144,28 @@
             {
                 return ExpandToFullPath(outFile);
             }
+        }
+
+        /// <summary>
+        /// Gets the list of categories to include
+        /// </summary>
+        public string Include
+        {
+            get
+            {
+                return includeCategory;
+            }
+        }
+
+        /// <summary>
+        /// Gets the list of categories to exclude
+        /// </summary>
+        public string Exclude
+        {
+            get
+            {
+                return excludeCategory;
+            }
         }
 
         /// <summary>
@@ -260,7 +284,13 @@
                     outFile = val;
                     break;
                 case "labels":
-                    labelTestsInOutput = true;
+                    labelTestsInOutput = true;
+                    break;
+                case "include":
+                    includeCategory = val;
+                    break;
+                case "exclude":
+                    excludeCategory = val;
                     break;
                 default:
                     error = true;

=== modified file 'src/framework/Runner/TextUI.cs'
--- src/framework/Runner/TextUI.cs	2013-01-24 01:32:48 +0000
+++ src/framework/Runner/TextUI.cs	2013-05-03 03:03:44 +0000
@@ -1,76 +1,76 @@
-// ***********************************************************************
-// Copyright (c) 2007 Charlie Poole
-//
-// Permission is hereby granted, free of charge, to any person obtaining
-// a copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to
-// permit persons to whom the Software is furnished to do so, subject to
-// the following conditions:
-// 
-// The above copyright notice and this permission notice shall be
-// included in all copies or substantial portions of the Software.
-// 
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-// ***********************************************************************
-
-using System;
-using System.IO;
-using System.Collections;
-using System.Reflection;
-using NUnit.Framework.Api;
-using NUnit.Framework.Internal;
-using NUnit.Framework.Internal.Filters;
-using System.Diagnostics;
-
-namespace NUnitLite.Runner
-{
-    /// <summary>
-    /// TextUI is a general purpose class that runs tests and
-    /// outputs to a TextWriter.
-    /// 
-    /// Call it from your Main like this:
-    ///   new TextUI(textWriter).Execute(args);
-    ///     OR
-    ///   new TextUI().Execute(args);
-    /// The provided TextWriter is used by default, unless the
-    /// arguments to Execute override it using -out. The second
-    /// form uses the Console, provided it exists on the platform.
-    /// 
-    /// NOTE: When running on a platform without a Console, such
-    /// as Windows Phone, the results will simply not appear if
-    /// you fail to specify a file in the call itself or as an option.
-    /// </summary>
-    public class TextUI : ITestListener
-    {
-        private CommandLineOptions commandLineOptions;
-
-        private NUnit.ObjectList assemblies = new NUnit.ObjectList();
-
-        private TextWriter writer;
-
+// ***********************************************************************
+// Copyright (c) 2007 Charlie Poole
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+// 
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+// ***********************************************************************
+
+using System;
+using System.IO;
+using System.Collections;
+using System.Reflection;
+using NUnit.Framework.Api;
+using NUnit.Framework.Internal;
+using NUnit.Framework.Internal.Filters;
+using System.Diagnostics;
+
+namespace NUnitLite.Runner
+{
+    /// <summary>
+    /// TextUI is a general purpose class that runs tests and
+    /// outputs to a TextWriter.
+    /// 
+    /// Call it from your Main like this:
+    ///   new TextUI(textWriter).Execute(args);
+    ///     OR
+    ///   new TextUI().Execute(args);
+    /// The provided TextWriter is used by default, unless the
+    /// arguments to Execute override it using -out. The second
+    /// form uses the Console, provided it exists on the platform.
+    /// 
+    /// NOTE: When running on a platform without a Console, such
+    /// as Windows Phone, the results will simply not appear if
+    /// you fail to specify a file in the call itself or as an option.
+    /// </summary>
+    public class TextUI : ITestListener
+    {
+        private CommandLineOptions commandLineOptions;
+
+        private NUnit.ObjectList assemblies = new NUnit.ObjectList();
+
+        private TextWriter writer;
+
         private ITestListener listener;
 
-        private ITestAssemblyRunner runner;
-
-        #region Constructors
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="TextUI"/> class.
-        /// </summary>
+        private ITestAssemblyRunner runner;
+
+        #region Constructors
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="TextUI"/> class.
+        /// </summary>
         public TextUI() : this(ConsoleWriter.Out, TestListener.NULL) { }
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="TextUI"/> class.
-        /// </summary>
-        /// <param name="writer">The TextWriter to use.</param>
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="TextUI"/> class.
+        /// </summary>
+        /// <param name="writer">The TextWriter to use.</param>
         public TextUI(TextWriter writer) : this(writer, TestListener.NULL) { }
 
         /// <summary>
@@ -79,116 +79,139 @@
         /// <param name="writer">The TextWriter to use.</param>
         /// <param name="listener">The Test listener to use.</param>
         public TextUI(TextWriter writer, ITestListener listener)
-        {
-            // Set the default writer - may be overridden by the args specified
-            this.writer = writer;
-            this.runner = new NUnitLiteTestAssemblyRunner(new NUnitLiteTestAssemblyBuilder());
+        {
+            // Set the default writer - may be overridden by the args specified
+            this.writer = writer;
+            this.runner = new NUnitLiteTestAssemblyRunner(new NUnitLiteTestAssemblyBuilder());
             this.listener = listener;
-        }
-
-        #endregion
-
-        #region Public Methods
-
-        /// <summary>
-        /// Execute a test run based on the aruments passed
-        /// from Main.
-        /// </summary>
-        /// <param name="args">An array of arguments</param>
-        public void Execute(string[] args)
-        {
-            // NOTE: Execute must be directly called from the
-            // test assembly in order for the mechanism to work.
-            Assembly callingAssembly = Assembly.GetCallingAssembly();
-
-            this.commandLineOptions = new CommandLineOptions();
-            commandLineOptions.Parse(args);
-
-            if (commandLineOptions.OutFile != null)
-                this.writer = new StreamWriter(commandLineOptions.OutFile);
-
-            if (!commandLineOptions.NoHeader)
+        }
+
+        #endregion
+
+        #region Public Methods
+
+        /// <summary>
+        /// Execute a test run based on the aruments passed
+        /// from Main.
+        /// </summary>
+        /// <param name="args">An array of arguments</param>
+        public void Execute(string[] args)
+        {
+            // NOTE: Execute must be directly called from the
+            // test assembly in order for the mechanism to work.
+            Assembly callingAssembly = Assembly.GetCallingAssembly();
+
+            this.commandLineOptions = new CommandLineOptions();
+            commandLineOptions.Parse(args);
+
+            if (commandLineOptions.OutFile != null)
+                this.writer = new StreamWriter(commandLineOptions.OutFile);
+
+            if (!commandLineOptions.NoHeader)
                 WriteHeader(this.writer);
-
-            if (commandLineOptions.ShowHelp)
-                writer.Write(commandLineOptions.HelpText);
-            else if (commandLineOptions.Error)
-            {
-                writer.WriteLine(commandLineOptions.ErrorMessage);
-                writer.WriteLine(commandLineOptions.HelpText);
-            }
-            else
-            {
+
+            if (commandLineOptions.ShowHelp)
+                writer.Write(commandLineOptions.HelpText);
+            else if (commandLineOptions.Error)
+            {
+                writer.WriteLine(commandLineOptions.ErrorMessage);
+                writer.WriteLine(commandLineOptions.HelpText);
+            }
+            else
+            {
                 WriteRuntimeEnvironment(this.writer);
-
-                if (commandLineOptions.Wait && commandLineOptions.OutFile != null)
-                    writer.WriteLine("Ignoring /wait option - only valid for Console");
-
+
+                if (commandLineOptions.Wait && commandLineOptions.OutFile != null)
+                    writer.WriteLine("Ignoring /wait option - only valid for Console");
+
 #if SILVERLIGHT
                 IDictionary loadOptions = new System.Collections.Generic.Dictionary<string, string>();
 #else
-                IDictionary loadOptions = new Hashtable();
+                IDictionary loadOptions = new Hashtable();
 #endif
-                //if (options.Load.Count > 0)
-                //    loadOptions["LOAD"] = options.Load;
-
-                //IDictionary runOptions = new Hashtable();
-                //if (commandLineOptions.TestCount > 0)
-                //    runOptions["RUN"] = commandLineOptions.Tests;
-
-                ITestFilter filter = commandLineOptions.TestCount > 0
-                    ? new SimpleNameFilter(commandLineOptions.Tests)
-                    : TestFilter.Empty;
-
-                try
-                {
-                    foreach (string name in commandLineOptions.Parameters)
-                        assemblies.Add(Assembly.Load(name));
-
-                    if (assemblies.Count == 0)
-                        assemblies.Add(callingAssembly);
-
-                    // TODO: For now, ignore all but first assembly
-                    Assembly assembly = assemblies[0] as Assembly;
-
-                    if (!runner.Load(assembly, loadOptions))
-                    {
+                //if (options.Load.Count > 0)
+                //    loadOptions["LOAD"] = options.Load;
+
+                //IDictionary runOptions = new Hashtable();
+                //if (commandLineOptions.TestCount > 0)
+                //    runOptions["RUN"] = commandLineOptions.Tests;
+
+                ITestFilter filter = commandLineOptions.TestCount > 0
+                    ? new SimpleNameFilter(commandLineOptions.Tests)
+                    : TestFilter.Empty;
+
+                try
+                {
+                    foreach (string name in commandLineOptions.Parameters)
+                        assemblies.Add(Assembly.Load(name));
+
+                    if (assemblies.Count == 0)
+                        assemblies.Add(callingAssembly);
+
+                    // TODO: For now, ignore all but first assembly
+                    Assembly assembly = assemblies[0] as Assembly;
+
+                    if (!runner.Load(assembly, loadOptions))
+                    {
                         AssemblyName assemblyName = AssemblyHelper.GetAssemblyName(assembly);
                         Console.WriteLine("No tests found in assembly {0}", assemblyName.Name);
-                        return;
-                    }
-
-                    if (commandLineOptions.Explore)
-                        ExploreTests();
-                    else
-                        RunTests(filter);
-                }
-                catch (FileNotFoundException ex)
-                {
-                    writer.WriteLine(ex.Message);
-                }
-                catch (Exception ex)
-                {
-                    writer.WriteLine(ex.ToString());
-                }
-                finally
-                {
-                    if (commandLineOptions.OutFile == null)
-                    {
-                        if (commandLineOptions.Wait)
-                        {
-                            Console.WriteLine("Press Enter key to continue . . .");
-                            Console.ReadLine();
-                        }
-                    }
-                    else
-                    {
-                        writer.Close();
-                    }
-                }
-            }
-        }
-
+                        return;
+                    }
+
+                    if (commandLineOptions.Explore)
+                        ExploreTests();
+                    else
+                    {
+                        if (commandLineOptions.Include != null && commandLineOptions.Include != string.Empty)
+                        {
+                            TestFilter includeFilter = new SimpleCategoryExpression(commandLineOptions.Include).Filter;
+
+                            if (filter.IsEmpty)
+                                filter = includeFilter;
+                            else
+                                filter = new AndFilter(filter, includeFilter);
+                        }
+
+                        if (commandLineOptions.Exclude != null && commandLineOptions.Exclude != string.Empty)
+                        {
+                            TestFilter excludeFilter = new NotFilter(new SimpleCategoryExpression(commandLineOptions.Exclude).Filter);
+
+                            if (filter.IsEmpty)
+                                filter = excludeFilter;
+                            else if (filter is AndFilter)
+                                ((AndFilter)filter).Add(excludeFilter);
+                            else
+                                filter = new AndFilter(filter, excludeFilter);
+                        }
+                        RunTests(filter);
+                    }
+                }
+                catch (FileNotFoundException ex)
+                {
+                    writer.WriteLine(ex.Message);
+                }
+                catch (Exception ex)
+                {
+                    writer.WriteLine(ex.ToString());
+                }
+                finally
+                {
+                    if (commandLineOptions.OutFile == null)
+                    {
+                        if (commandLineOptions.Wait)
+                        {
+                            Console.WriteLine("Press Enter key to continue . . .");
+                            Console.ReadLine();
+                        }
+                    }
+                    else
+                    {
+                        writer.Close();
+                    }
+                }
+            }
+        }
+
         /// <summary>
         /// Write the standard header information to a TextWriter.
         /// </summary>
@@ -247,37 +270,37 @@
             writer.WriteLine();
         }
 
-        #endregion
-
-        #region Helper Methods
-
-        private void RunTests(ITestFilter filter)
-        {
-            ITestResult result = runner.Run(this, filter);
+        #endregion
+
+        #region Helper Methods
+
+        private void RunTests(ITestFilter filter)
+        {
+            ITestResult result = runner.Run(this, filter);
             new ResultReporter(result, writer).ReportResults();
-            string resultFile = commandLineOptions.ResultFile;
-            string resultFormat = commandLineOptions.ResultFormat;
-                    
-            if (resultFile != null || commandLineOptions.ResultFormat != null)
-            {
-                if (resultFile == null)
-                    resultFile = "TestResult.xml";
-
-                if (resultFormat == "nunit2")
-                    new NUnit2XmlOutputWriter().WriteResultFile(result, resultFile);
-                else
-                    new NUnit3XmlOutputWriter().WriteResultFile(result, resultFile);
-
-                Console.WriteLine();
-                Console.WriteLine("Results saved as {0}.", resultFile);
-            }
-        }
-
-        private void ExploreTests()
-        {
-            XmlNode testNode = runner.LoadedTest.ToXml(true);
-
-            string listFile = commandLineOptions.ExploreFile;
+            string resultFile = commandLineOptions.ResultFile;
+            string resultFormat = commandLineOptions.ResultFormat;
+                    
+            if (resultFile != null || commandLineOptions.ResultFormat != null)
+            {
+                if (resultFile == null)
+                    resultFile = "TestResult.xml";
+
+                if (resultFormat == "nunit2")
+                    new NUnit2XmlOutputWriter().WriteResultFile(result, resultFile);
+                else
+                    new NUnit3XmlOutputWriter().WriteResultFile(result, resultFile);
+
+                Console.WriteLine();
+                Console.WriteLine("Results saved as {0}.", resultFile);
+            }
+        }
+
+        private void ExploreTests()
+        {
+            XmlNode testNode = runner.LoadedTest.ToXml(true);
+
+            string listFile = commandLineOptions.ExploreFile;
             TextWriter textWriter = listFile != null && listFile.Length > 0
                 ? new StreamWriter(listFile)
                 : Console.Out;
@@ -292,43 +315,43 @@
             testWriter.Formatting = System.Xml.Formatting.Indented;
 #endif
 
-            testNode.WriteTo(testWriter);
-            testWriter.Close();
-
-            Console.WriteLine();
-            Console.WriteLine("Test info saved as {0}.", listFile);
-        }
-
-        #endregion
-
-        #region ITestListener Members
-
+            testNode.WriteTo(testWriter);
+            testWriter.Close();
+
+            Console.WriteLine();
+            Console.WriteLine("Test info saved as {0}.", listFile);
+        }
+
+        #endregion
+
+        #region ITestListener Members
+
         /// <summary>
         /// A test has just started
         /// </summary>
         /// <param name="test">The test</param>
-        public void TestStarted(ITest test)
-        {
-            if (commandLineOptions.LabelTestsInOutput)
-                writer.WriteLine("***** {0}", test.Name);
-        }
-
-        /// <summary>
-        /// A test has just finished
-        /// </summary>
-        /// <param name="result">The result of the test</param>
-        public void TestFinished(ITestResult result)
-        {
-        }
-
-        /// <summary>
-        /// A test has produced some text output
-        /// </summary>
-        /// <param name="testOutput">A TestOutput object holding the text that was written</param>
-        public void TestOutput(TestOutput testOutput)
-        {
-        }
-
-        #endregion
-    }
-}
+        public void TestStarted(ITest test)
+        {
+            if (commandLineOptions.LabelTestsInOutput)
+                writer.WriteLine("***** {0}", test.Name);
+        }
+
+        /// <summary>
+        /// A test has just finished
+        /// </summary>
+        /// <param name="result">The result of the test</param>
+        public void TestFinished(ITestResult result)
+        {
+        }
+
+        /// <summary>
+        /// A test has produced some text output
+        /// </summary>
+        /// <param name="testOutput">A TestOutput object holding the text that was written</param>
+        public void TestOutput(TestOutput testOutput)
+        {
+        }
+
+        #endregion
+    }
+}

=== modified file 'src/framework/TestContext.cs'
--- src/framework/TestContext.cs	2012-09-01 18:18:44 +0000
+++ src/framework/TestContext.cs	2013-05-03 03:03:44 +0000
@@ -1,249 +1,257 @@
-// ***********************************************************************
-// Copyright (c) 2011 Charlie Poole
-//
-// Permission is hereby granted, free of charge, to any person obtaining
-// a copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to
-// permit persons to whom the Software is furnished to do so, subject to
-// the following conditions:
-// 
-// The above copyright notice and this permission notice shall be
-// included in all copies or substantial portions of the Software.
-// 
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-// ***********************************************************************
-
-using System;
-using System.Collections;
-using NUnit.Framework.Api;
-using NUnit.Framework.Internal;
-
-namespace NUnit.Framework
-{
-    /// <summary>
-    /// Provide the context information of the current test.
-    /// This is an adapter for the internal ExecutionContext
-    /// class, hiding the internals from the user test.
-    /// </summary>
-    public class TestContext
-    {
-        private TestExecutionContext ec;
-        private TestAdapter test;
-        private ResultAdapter result;
-
-        #region Constructor
-
-        /// <summary>
-        /// Construct a TestContext for an ExecutionContext
-        /// </summary>
-        /// <param name="ec">The ExecutionContext to adapt</param>
-        public TestContext(TestExecutionContext ec)
-        {
-            this.ec = ec;
-        }
-
-        #endregion
-
-        #region Properties
-
-        /// <summary>
-        /// Get the current test context. This is created
-        /// as needed. The user may save the context for
-        /// use within a test, but it should not be used
-        /// outside the test for which it is created.
-        /// </summary>
-        public static TestContext CurrentContext
-        {
-            get { return new TestContext(TestExecutionContext.CurrentContext); }
-        }
-
-        /// <summary>
-        /// Get a representation of the current test.
-        /// </summary>
-        public TestAdapter Test
-        {
-            get
-            {
-                if (test == null)
-                    test = new TestAdapter(ec.CurrentTest);
-
-                return test;
-            }
-        }
-
-        /// <summary>
-        /// Gets a Representation of the TestResult for the current test. 
-        /// </summary>
-        public ResultAdapter Result
-        {
-            get
-            {
-                if (result == null)
-                    result = new ResultAdapter(ec.CurrentResult);
-
-                return result;
-            }
-        }
-
-#if !NETCF
-        /// <summary>
-        /// Gets the directory containing the current test assembly.
-        /// </summary>
-        public string TestDirectory
-        {
-            get
-            {
-                return AssemblyHelper.GetDirectoryName(ec.CurrentTest.FixtureType.Assembly);
-            }
-        }
-#endif
-
-        /// <summary>
-        /// Gets the directory to be used for outputing files created
-        /// by this test run.
-        /// </summary>
-        public string WorkDirectory
-        {
-            get
-            {
-				return ec.WorkDirectory;
-        	}
-        }
-
-        #endregion
-
-        #region Nested TestAdapter Class
-
-        /// <summary>
-        /// TestAdapter adapts a Test for consumption by
-        /// the user test code.
-        /// </summary>
-        public class TestAdapter
-        {
-            private Test test;
-
-            #region Constructor
-
-            /// <summary>
-            /// Construct a TestAdapter for a Test
-            /// </summary>
-            /// <param name="test">The Test to be adapted</param>
-            public TestAdapter(Test test)
-            {
-                this.test = test;
-            }
-
-            #endregion
-
-            #region Properties
-
-            /// <summary>
-            /// Gets the unique Id of a test
-            /// </summary>
-            public int ID
-            {
-                get { return test.Id; }
-            }
-
-            /// <summary>
-            /// The name of the test, which may or may not be 
-            /// the same as the method name.
-            /// </summary>
-            public string Name
-            {
-                get
-                {
-                    return test.Name;
-                }
-            }
-			
-            /// <summary>
-            /// The name of the method representing the test.
-            /// </summary>
-			public string MethodName
-			{
-				get
-				{
-					return test is TestMethod
-						? ((TestMethod)test).Method.Name
-						: null;
-				}
-			}
-
-            /// <summary>
-            /// The FullName of the test
-            /// </summary>
-            public string FullName
-            {
-                get
-                {
-                    return test.FullName;
-                }
-            }
-
-            /// <summary>
-            /// The properties of the test.
-            /// </summary>
-            public IPropertyBag Properties
-            {
-                get
-                {
-                    return test.Properties;
-                }
-            }
-
-            #endregion
-        }
-
-        #endregion
-
-        #region Nested ResultAdapter Class
-
-        /// <summary>
-        /// ResultAdapter adapts a TestResult for consumption by
-        /// the user test code.
-        /// </summary>
-        public class ResultAdapter
-        {
-            private TestResult result;
-
-            #region Constructor
-
-            /// <summary>
-            /// Construct a ResultAdapter for a TestResult
-            /// </summary>
-            /// <param name="result">The TestResult to be adapted</param>
-            public ResultAdapter(TestResult result)
-            {
-                this.result = result;
-            }
-
-            #endregion
-
-            #region Properties
-
-            /// <summary>
-            /// Gets a ResultState representing the outcome of the test.
-            /// </summary>
-            public ResultState Outcome
-            {
-                get
-                {
-                    return result.ResultState;
-                }
-            }
-
-            #endregion
-        }
-        
-        #endregion
-    }
-}
+// ***********************************************************************
+// Copyright (c) 2011 Charlie Poole
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+// 
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+// ***********************************************************************
+
+using System;
+using System.Collections;
+using NUnit.Framework.Api;
+using NUnit.Framework.Internal;
+
+namespace NUnit.Framework
+{
+    /// <summary>
+    /// Provide the context information of the current test.
+    /// This is an adapter for the internal ExecutionContext
+    /// class, hiding the internals from the user test.
+    /// </summary>
+    public class TestContext
+    {
+        private TestExecutionContext ec;
+        private TestAdapter test;
+        private ResultAdapter result;
+
+        #region Constructor
+
+        /// <summary>
+        /// Construct a TestContext for an ExecutionContext
+        /// </summary>
+        /// <param name="ec">The ExecutionContext to adapt</param>
+        public TestContext(TestExecutionContext ec)
+        {
+            this.ec = ec;
+        }
+
+        #endregion
+
+        #region Properties
+
+        /// <summary>
+        /// Get the current test context. This is created
+        /// as needed. The user may save the context for
+        /// use within a test, but it should not be used
+        /// outside the test for which it is created.
+        /// </summary>
+        public static TestContext CurrentContext
+        {
+            get { return new TestContext(TestExecutionContext.CurrentContext); }
+        }
+
+        /// <summary>
+        /// Get a representation of the current test.
+        /// </summary>
+        public TestAdapter Test
+        {
+            get
+            {
+                if (test == null)
+                    test = new TestAdapter(ec.CurrentTest);
+
+                return test;
+            }
+        }
+
+        /// <summary>
+        /// Gets a Representation of the TestResult for the current test. 
+        /// </summary>
+        public ResultAdapter Result
+        {
+            get
+            {
+                if (result == null)
+                    result = new ResultAdapter(ec.CurrentResult);
+
+                return result;
+            }
+        }
+
+#if !NETCF
+        /// <summary>
+        /// Gets the directory containing the current test assembly.
+        /// </summary>
+        public string TestDirectory
+        {
+            get
+            {
+                return AssemblyHelper.GetDirectoryName(ec.CurrentTest.FixtureType.Assembly);
+            }
+        }
+#endif
+
+        /// <summary>
+        /// Gets the directory to be used for outputing files created
+        /// by this test run.
+        /// </summary>
+        public string WorkDirectory
+        {
+            get
+            {
+				return ec.WorkDirectory;
+        	}
+        }
+
+        public RandomGenerator Random
+        {
+            get
+            {
+                return ec.Random;
+            }
+        }
+
+        #endregion
+
+        #region Nested TestAdapter Class
+
+        /// <summary>
+        /// TestAdapter adapts a Test for consumption by
+        /// the user test code.
+        /// </summary>
+        public class TestAdapter
+        {
+            private Test test;
+
+            #region Constructor
+
+            /// <summary>
+            /// Construct a TestAdapter for a Test
+            /// </summary>
+            /// <param name="test">The Test to be adapted</param>
+            public TestAdapter(Test test)
+            {
+                this.test = test;
+            }
+
+            #endregion
+
+            #region Properties
+
+            /// <summary>
+            /// Gets the unique Id of a test
+            /// </summary>
+            public int ID
+            {
+                get { return test.Id; }
+            }
+
+            /// <summary>
+            /// The name of the test, which may or may not be 
+            /// the same as the method name.
+            /// </summary>
+            public string Name
+            {
+                get
+                {
+                    return test.Name;
+                }
+            }
+			
+            /// <summary>
+            /// The name of the method representing the test.
+            /// </summary>
+			public string MethodName
+			{
+				get
+				{
+					return test is TestMethod
+						? ((TestMethod)test).Method.Name
+						: null;
+				}
+			}
+
+            /// <summary>
+            /// The FullName of the test
+            /// </summary>
+            public string FullName
+            {
+                get
+                {
+                    return test.FullName;
+                }
+            }
+
+            /// <summary>
+            /// The properties of the test.
+            /// </summary>
+            public IPropertyBag Properties
+            {
+                get
+                {
+                    return test.Properties;
+                }
+            }
+
+            #endregion
+        }
+
+        #endregion
+
+        #region Nested ResultAdapter Class
+
+        /// <summary>
+        /// ResultAdapter adapts a TestResult for consumption by
+        /// the user test code.
+        /// </summary>
+        public class ResultAdapter
+        {
+            private TestResult result;
+
+            #region Constructor
+
+            /// <summary>
+            /// Construct a ResultAdapter for a TestResult
+            /// </summary>
+            /// <param name="result">The TestResult to be adapted</param>
+            public ResultAdapter(TestResult result)
+            {
+                this.result = result;
+            }
+
+            #endregion
+
+            #region Properties
+
+            /// <summary>
+            /// Gets a ResultState representing the outcome of the test.
+            /// </summary>
+            public ResultState Outcome
+            {
+                get
+                {
+                    return result.ResultState;
+                }
+            }
+
+            #endregion
+        }
+        
+        #endregion
+    }
+}

=== modified file 'src/framework/nunitlite-2.0.csproj'
--- src/framework/nunitlite-2.0.csproj	2013-05-02 22:06:03 +0000
+++ src/framework/nunitlite-2.0.csproj	2013-05-03 03:03:44 +0000
@@ -82,6 +82,7 @@
       <SubType>Code</SubType>
     </Compile>
     <Compile Include="Internal\Commands\TheoryResultCommand.cs" />
+    <Compile Include="Internal\Filters\SimpleCategoryExpression.cs" />
     <Compile Include="Internal\IApplyToContext.cs" />
     <Compile Include="Internal\IApplyToTest.cs" />
     <Compile Include="Api\IParameterDataSource.cs" />
@@ -304,6 +305,7 @@
       <SubType>Code</SubType>
     </Compile>
     <Compile Include="Internal\PropertyNames.cs" />
+    <Compile Include="Internal\RandomGenerator.cs" />
     <Compile Include="Internal\Randomizer.cs" />
     <Compile Include="Internal\Reflect.cs" />
     <Compile Include="Internal\Results\TestCaseResult.cs" />
@@ -375,11 +377,11 @@
     <None Include="nunit.snk" />
   </ItemGroup>
   <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>
+  <!-- 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

=== modified file 'src/framework/nunitlite-3.5.csproj'
--- src/framework/nunitlite-3.5.csproj	2013-05-02 22:06:03 +0000
+++ src/framework/nunitlite-3.5.csproj	2013-05-03 03:03:44 +0000
@@ -274,6 +274,7 @@
     <Compile Include="Internal\Filters\CategoryFilter.cs" />
     <Compile Include="Internal\Filters\NotFilter.cs" />
     <Compile Include="Internal\Filters\OrFilter.cs" />
+    <Compile Include="Internal\Filters\SimpleCategoryExpression.cs" />
     <Compile Include="Internal\Filters\SimpleNameFilter.cs" />
     <Compile Include="Internal\IApplyToContext.cs" />
     <Compile Include="Internal\IApplyToTest.cs" />
@@ -287,6 +288,7 @@
     <Compile Include="Internal\PlatformHelper.cs" />
     <Compile Include="Internal\PropertyBag.cs" />
     <Compile Include="Internal\PropertyNames.cs" />
+    <Compile Include="Internal\RandomGenerator.cs" />
     <Compile Include="Internal\Randomizer.cs" />
     <Compile Include="Internal\Reflect.cs" />
     <Compile Include="Internal\Results\TestCaseResult.cs" />
@@ -358,11 +360,11 @@
     <None Include="nunit.snk" />
   </ItemGroup>
   <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>
+  <!-- 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

=== modified file 'src/framework/nunitlite-4.0.csproj'
--- src/framework/nunitlite-4.0.csproj	2013-05-02 22:06:03 +0000
+++ src/framework/nunitlite-4.0.csproj	2013-05-03 03:03:44 +0000
@@ -274,6 +274,7 @@
     <Compile Include="Internal\Filters\CategoryFilter.cs" />
     <Compile Include="Internal\Filters\NotFilter.cs" />
     <Compile Include="Internal\Filters\OrFilter.cs" />
+    <Compile Include="Internal\Filters\SimpleCategoryExpression.cs" />
     <Compile Include="Internal\Filters\SimpleNameFilter.cs" />
     <Compile Include="Internal\IApplyToContext.cs" />
     <Compile Include="Internal\IApplyToTest.cs" />
@@ -287,6 +288,7 @@
     <Compile Include="Internal\PlatformHelper.cs" />
     <Compile Include="Internal\PropertyBag.cs" />
     <Compile Include="Internal\PropertyNames.cs" />
+    <Compile Include="Internal\RandomGenerator.cs" />
     <Compile Include="Internal\Randomizer.cs" />
     <Compile Include="Internal\Reflect.cs" />
     <Compile Include="Internal\Results\TestCaseResult.cs" />
@@ -357,11 +359,11 @@
     <None Include="nunit.snk" />
   </ItemGroup>
   <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>
+  <!-- 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

=== modified file 'src/framework/nunitlite-4.5.csproj'
--- src/framework/nunitlite-4.5.csproj	2012-12-31 04:29:18 +0000
+++ src/framework/nunitlite-4.5.csproj	2013-05-03 03:03:44 +0000
@@ -1,371 +1,373 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="4.0">
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProductVersion>9.0.30729</ProductVersion>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{D12F0F7B-8DE3-43EC-BA49-41052D065A9B}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <RootNamespace>NUnitLite</RootNamespace>
-    <AssemblyName>nunitlite</AssemblyName>
-    <FileUpgradeFlags>
-    </FileUpgradeFlags>
-    <OldToolsVersion>3.5</OldToolsVersion>
-    <UpgradeBackupLocation>
-    </UpgradeBackupLocation>
-    <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
-    <PublishUrl>publish\</PublishUrl>
-    <Install>true</Install>
-    <InstallFrom>Disk</InstallFrom>
-    <UpdateEnabled>false</UpdateEnabled>
-    <UpdateMode>Foreground</UpdateMode>
-    <UpdateInterval>7</UpdateInterval>
-    <UpdateIntervalUnits>Days</UpdateIntervalUnits>
-    <UpdatePeriodically>false</UpdatePeriodically>
-    <UpdateRequired>false</UpdateRequired>
-    <MapFileExtensions>true</MapFileExtensions>
-    <ApplicationRevision>0</ApplicationRevision>
-    <ApplicationVersion>1.0.0.%2a</ApplicationVersion>
-    <IsWebBootstrapper>false</IsWebBootstrapper>
-    <UseApplicationTrust>false</UseApplicationTrust>
-    <BootstrapperEnabled>true</BootstrapperEnabled>
-    <TargetFrameworkProfile />
-    <IntermediateOutputPath>obj\$(Configuration)\net-4.5\</IntermediateOutputPath>
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-    <DebugSymbols>true</DebugSymbols>
-    <DebugType>full</DebugType>
-    <Optimize>false</Optimize>
-    <OutputPath>..\..\bin\Debug\net-4.5\</OutputPath>
-    <DefineConstants>TRACE;DEBUG;NET_4_5, CLR_4_0,NUNITLITE</DefineConstants>
-    <ErrorReport>prompt</ErrorReport>
-    <WarningLevel>4</WarningLevel>
-    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
-    <DocumentationFile>..\..\bin\Debug\net-4.5\nunitlite.xml</DocumentationFile>
-    <Prefer32Bit>false</Prefer32Bit>
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-    <DebugType>pdbonly</DebugType>
-    <Optimize>true</Optimize>
-    <OutputPath>..\..\bin\Release\net-4.5\</OutputPath>
-    <DefineConstants>TRACE;NET_4_5, CLR_4_0,NUNITLITE</DefineConstants>
-    <ErrorReport>prompt</ErrorReport>
-    <WarningLevel>4</WarningLevel>
-    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
-    <DocumentationFile>..\..\bin\Release\net-4.5\nunitlite.xml</DocumentationFile>
-    <Prefer32Bit>false</Prefer32Bit>
-  </PropertyGroup>
-  <PropertyGroup>
-    <SignAssembly>true</SignAssembly>
-  </PropertyGroup>
-  <PropertyGroup>
-    <AssemblyOriginatorKeyFile>nunit.snk</AssemblyOriginatorKeyFile>
-  </PropertyGroup>
-  <ItemGroup>
-    <Reference Include="System" />
-    <Reference Include="System.Xml" />
-  </ItemGroup>
-  <ItemGroup>
-    <Compile Include="Api\ExpectedExceptionData.cs" />
-    <Compile Include="Api\FailureSite.cs" />
-    <Compile Include="Api\IParameterDataSource.cs" />
-    <Compile Include="Api\IPropertyBag.cs" />
-    <Compile Include="Api\ITest.cs" />
-    <Compile Include="Api\ITestAssemblyBuilder.cs" />
-    <Compile Include="Api\ITestAssemblyRunner.cs" />
-    <Compile Include="Api\ITestCaseData.cs" />
-    <Compile Include="Api\ITestCaseSource.cs" />
-    <Compile Include="Api\ITestFilter.cs" />
-    <Compile Include="Api\ITestListener.cs" />
-    <Compile Include="Api\ITestResult.cs" />
-    <Compile Include="Api\IXmlNodeBuilder.cs" />
-    <Compile Include="Api\PropertyEntry.cs" />
-    <Compile Include="Api\ResultState.cs" />
-    <Compile Include="Api\RunState.cs" />
-    <Compile Include="Api\TestOutput.cs" />
-    <Compile Include="Api\TestStatus.cs" />
-    <Compile Include="Api\XmlNode.cs" />
-    <Compile Include="AssemblyInfo.cs" />
-    <Compile Include="Assert.cs" />
-    <Compile Include="AssertionHelper.cs" />
-    <Compile Include="Assume.cs" />
-    <Compile Include="Attributes\CategoryAttribute.cs" />
-    <Compile Include="Attributes\CombinatorialAttribute.cs" />
-    <Compile Include="Attributes\CultureAttribute.cs" />
-    <Compile Include="Attributes\DataAttribute.cs" />
-    <Compile Include="Attributes\DatapointAttribute.cs" />
-    <Compile Include="Attributes\DatapointsAttribute.cs" />
-    <Compile Include="Attributes\DatapointSourceAttribute.cs" />
-    <Compile Include="Attributes\DescriptionAttribute.cs" />
-    <Compile Include="Attributes\ExpectedExceptionAttribute.cs" />
-    <Compile Include="Attributes\ExplicitAttribute.cs" />
-    <Compile Include="Attributes\IgnoreAttribute.cs" />
-    <Compile Include="Attributes\IncludeExcludeAttribute.cs" />
-    <Compile Include="Attributes\MaxTimeAttribute.cs" />
-    <Compile Include="Attributes\NUnitAttribute.cs" />
-    <Compile Include="Attributes\PairwiseAttribute.cs" />
-    <Compile Include="Attributes\PlatformAttribute.cs" />
-    <Compile Include="Attributes\PropertyAttribute.cs" />
-    <Compile Include="Attributes\RandomAttribute.cs" />
-    <Compile Include="Attributes\RangeAttribute.cs" />
-    <Compile Include="Attributes\RepeatAttribute.cs" />
-    <Compile Include="Attributes\SequentialAttribute.cs" />
-    <Compile Include="Attributes\SetCultureAttribute.cs" />
-    <Compile Include="Attributes\SetUICultureAttribute.cs" />
-    <Compile Include="Attributes\SetUpAttribute.cs" />
-    <Compile Include="Attributes\TearDownAttribute.cs" />
-    <Compile Include="Attributes\TestAttribute.cs" />
-    <Compile Include="Attributes\TestCaseAttribute.cs" />
-    <Compile Include="Attributes\TestCaseSourceAttribute.cs" />
-    <Compile Include="Attributes\TestFixtureAttribute.cs" />
-    <Compile Include="Attributes\TestFixtureSetUpAttribute.cs" />
-    <Compile Include="Attributes\TestFixtureTearDownAttribute.cs" />
-    <Compile Include="Attributes\TheoryAttribute.cs" />
-    <Compile Include="Attributes\TimeoutAttribute.cs" />
-    <Compile Include="Attributes\ValuesAttribute.cs" />
-    <Compile Include="Attributes\ValueSourceAttribute.cs" />
-    <Compile Include="Constraints\AllItemsConstraint.cs" />
-    <Compile Include="Constraints\AndConstraint.cs" />
-    <Compile Include="Constraints\AssignableFromConstraint.cs" />
-    <Compile Include="Constraints\AssignableToConstraint.cs" />
-    <Compile Include="Constraints\AttributeConstraint.cs" />
-    <Compile Include="Constraints\AttributeExistsConstraint.cs" />
-    <Compile Include="Constraints\BasicConstraint.cs" />
-    <Compile Include="Constraints\BinaryConstraint.cs" />
-    <Compile Include="Constraints\BinarySerializableConstraint.cs" />
-    <Compile Include="Constraints\CollectionConstraint.cs" />
-    <Compile Include="Constraints\CollectionContainsConstraint.cs" />
-    <Compile Include="Constraints\CollectionEquivalentConstraint.cs" />
-    <Compile Include="Constraints\CollectionItemsEqualConstraint.cs" />
-    <Compile Include="Constraints\CollectionOrderedConstraint.cs" />
-    <Compile Include="Constraints\CollectionSubsetConstraint.cs" />
-    <Compile Include="Constraints\CollectionTally.cs" />
-    <Compile Include="Constraints\ComparisonAdapter.cs" />
-    <Compile Include="Constraints\ComparisonConstraint.cs" />
-    <Compile Include="Constraints\Constraint.cs" />
-    <Compile Include="Constraints\ConstraintBuilder.cs" />
-    <Compile Include="Constraints\ConstraintExpression.cs" />
-    <Compile Include="Constraints\ConstraintExpressionBase.cs" />
-    <Compile Include="Constraints\ConstraintFactory.cs" />
-    <Compile Include="Constraints\ContainsConstraint.cs" />
-    <Compile Include="Constraints\DelayedConstraint.cs" />
-    <Compile Include="Constraints\EmptyCollectionConstraint.cs" />
-    <Compile Include="Constraints\EmptyConstraint.cs" />
-    <Compile Include="Constraints\EmptyDirectoryConstraint.cs" />
-    <Compile Include="Constraints\EmptyStringConstraint.cs" />
-    <Compile Include="Constraints\EndsWithConstraint.cs" />
-    <Compile Include="Constraints\EqualConstraint.cs" />
-    <Compile Include="Constraints\EqualityAdapter.cs" />
-    <Compile Include="Constraints\ExactCountConstraint.cs" />
-    <Compile Include="Constraints\ExactTypeConstraint.cs" />
-    <Compile Include="Constraints\ExceptionTypeConstraint.cs" />
-    <Compile Include="Constraints\FailurePoint.cs" />
-    <Compile Include="Constraints\FalseConstraint.cs" />
-    <Compile Include="Constraints\FloatingPointNumerics.cs" />
-    <Compile Include="Constraints\GreaterThanConstraint.cs" />
-    <Compile Include="Constraints\GreaterThanOrEqualConstraint.cs" />
-    <Compile Include="Constraints\InstanceOfTypeConstraint.cs" />
-    <Compile Include="Constraints\IResolveConstraint.cs" />
-    <Compile Include="Constraints\LessThanConstraint.cs" />
-    <Compile Include="Constraints\LessThanOrEqualConstraint.cs" />
-    <Compile Include="Constraints\MessageWriter.cs" />
-    <Compile Include="Constraints\MsgUtils.cs" />
-    <Compile Include="Constraints\NaNConstraint.cs" />
-    <Compile Include="Constraints\NoItemConstraint.cs" />
-    <Compile Include="Constraints\NotConstraint.cs" />
-    <Compile Include="Constraints\NullConstraint.cs" />
-    <Compile Include="Constraints\NullOrEmptyStringConstraint.cs" />
-    <Compile Include="Constraints\Numerics.cs" />
-    <Compile Include="Constraints\NUnitComparer.cs" />
-    <Compile Include="Constraints\NUnitEqualityComparer.cs" />
-    <Compile Include="Constraints\Operators\AllOperator.cs" />
-    <Compile Include="Constraints\Operators\AndOperator.cs" />
-    <Compile Include="Constraints\Operators\AttributeOperator.cs" />
-    <Compile Include="Constraints\Operators\BinaryOperator.cs" />
-    <Compile Include="Constraints\Operators\CollectionOperator.cs" />
-    <Compile Include="Constraints\Operators\ConstraintOperator.cs" />
-    <Compile Include="Constraints\Operators\ExactCountOperator.cs" />
-    <Compile Include="Constraints\Operators\NoneOperator.cs" />
-    <Compile Include="Constraints\Operators\NotOperator.cs" />
-    <Compile Include="Constraints\Operators\OrOperator.cs" />
-    <Compile Include="Constraints\Operators\PrefixOperator.cs" />
-    <Compile Include="Constraints\Operators\PropOperator.cs" />
-    <Compile Include="Constraints\Operators\SelfResolvingOperator.cs" />
-    <Compile Include="Constraints\Operators\SomeOperator.cs" />
-    <Compile Include="Constraints\Operators\ThrowsOperator.cs" />
-    <Compile Include="Constraints\Operators\WithOperator.cs" />
-    <Compile Include="Constraints\OrConstraint.cs" />
-    <Compile Include="Constraints\PathConstraint.cs" />
-    <Compile Include="Constraints\PredicateConstraint.cs" />
-    <Compile Include="Constraints\PrefixConstraint.cs" />
-    <Compile Include="Constraints\PropertyConstraint.cs" />
-    <Compile Include="Constraints\PropertyExistsConstraint.cs" />
-    <Compile Include="Constraints\RangeConstraint.cs" />
-    <Compile Include="Constraints\RegexConstraint.cs" />
-    <Compile Include="Constraints\ResolvableConstraintExpression.cs" />
-    <Compile Include="Constraints\ReusableConstraint.cs" />
-    <Compile Include="Constraints\SameAsConstraint.cs" />
-    <Compile Include="Constraints\SamePathConstraint.cs" />
-    <Compile Include="Constraints\SamePathOrUnderConstraint.cs" />
-    <Compile Include="Constraints\SomeItemsConstraint.cs" />
-    <Compile Include="Constraints\StartsWithConstraint.cs" />
-    <Compile Include="Constraints\StringConstraint.cs" />
-    <Compile Include="Constraints\SubPathConstraint.cs" />
-    <Compile Include="Constraints\SubstringConstraint.cs" />
-    <Compile Include="Constraints\ThrowsConstraint.cs" />
-    <Compile Include="Constraints\ThrowsNothingConstraint.cs" />
-    <Compile Include="Constraints\Tolerance.cs" />
-    <Compile Include="Constraints\ToleranceMode.cs" />
-    <Compile Include="Constraints\TrueConstraint.cs" />
-    <Compile Include="Constraints\TypeConstraint.cs" />
-    <Compile Include="Constraints\UniqueItemsConstraint.cs" />
-    <Compile Include="Constraints\XmlSerializableConstraint.cs" />
-    <Compile Include="Contains.cs" />
-    <Compile Include="Env.cs" />
-    <Compile Include="Exceptions\AssertionException.cs" />
-    <Compile Include="Exceptions\IgnoreException.cs" />
-    <Compile Include="Exceptions\InconclusiveException.cs" />
-    <Compile Include="Exceptions\SuccessException.cs" />
-    <Compile Include="Extensibility\IParameterDataProvider.cs" />
-    <Compile Include="Extensibility\ISuiteBuilder.cs" />
-    <Compile Include="Extensibility\ITestCaseBuilder.cs" />
-    <Compile Include="Extensibility\ITestCaseProvider.cs" />
-    <Compile Include="GlobalSettings.cs" />
-    <Compile Include="Guard.cs" />
-    <Compile Include="Has.cs" />
-    <Compile Include="IExpectException.cs" />
-    <Compile Include="Internal\AssemblyHelper.cs" />
-    <Compile Include="Internal\Builders\CombinatorialStrategy.cs" />
-    <Compile Include="Internal\Builders\CombinatorialTestCaseProvider.cs">
-      <SubType>Code</SubType>
-    </Compile>
-    <Compile Include="Internal\Builders\CombiningStrategy.cs" />
-    <Compile Include="Internal\Builders\DataAttributeTestCaseProvider.cs">
-      <SubType>Code</SubType>
-    </Compile>
-    <Compile Include="Internal\Builders\DatapointProvider.cs" />
-    <Compile Include="Internal\Builders\NUnitTestCaseBuilder.cs" />
-    <Compile Include="Internal\Builders\NUnitTestFixtureBuilder.cs" />
-    <Compile Include="Internal\Builders\PairwiseStrategy.cs" />
-    <Compile Include="Internal\Builders\ParameterDataProvider.cs" />
-    <Compile Include="Internal\Builders\ProviderCache.cs" />
-    <Compile Include="Internal\Builders\SequentialStrategy.cs" />
-    <Compile Include="Internal\Commands\ApplyChangesToContextCommand.cs" />
-    <Compile Include="Internal\AsyncInvocationRegion.cs" />
-    <Compile Include="Internal\AsyncSynchronizationContext.cs" />
-    <Compile Include="Internal\Commands\CommandDecoratorList.cs" />
-    <Compile Include="Internal\Commands\CommandStage.cs" />
-    <Compile Include="Internal\Commands\DelegatingTestCommand.cs" />
-    <Compile Include="Internal\Commands\ExpectedExceptionCommand.cs" />
-    <Compile Include="Internal\Commands\ICommandDecorator.cs" />
-    <Compile Include="Internal\Commands\MaxTimeCommand.cs" />
-    <Compile Include="Internal\Commands\OneTimeSetUpCommand.cs" />
-    <Compile Include="Internal\Commands\OneTimeTearDownCommand.cs" />
-    <Compile Include="Internal\Commands\RepeatedTestCommand.cs" />
-    <Compile Include="Internal\Commands\SetUpTearDownCommand.cs" />
-    <Compile Include="Internal\Commands\SkipCommand.cs" />
-    <Compile Include="Internal\Commands\TestCommand.cs" />
-    <Compile Include="Internal\Commands\TestMethodCommand.cs" />
-    <Compile Include="Internal\Commands\TheoryResultCommand.cs" />
-    <Compile Include="Internal\CultureDetector.cs" />
-    <Compile Include="Internal\ExceptionHelper.cs" />
-    <Compile Include="Internal\Extensibility\ParameterDataProviders.cs" />
-    <Compile Include="Internal\Extensibility\TestCaseProviders.cs" />
-    <Compile Include="Internal\Filters\AndFilter.cs" />
-    <Compile Include="Internal\Filters\CategoryExpression.cs" />
-    <Compile Include="Internal\Filters\CategoryFilter.cs" />
-    <Compile Include="Internal\Filters\NotFilter.cs" />
-    <Compile Include="Internal\Filters\OrFilter.cs" />
-    <Compile Include="Internal\Filters\SimpleNameFilter.cs" />
-    <Compile Include="Internal\IApplyToContext.cs" />
-    <Compile Include="Internal\IApplyToTest.cs" />
-    <Compile Include="Internal\InvalidTestFixtureException.cs" />
-    <Compile Include="Internal\MethodHelper.cs" />
-    <Compile Include="Internal\NUnitException.cs" />
-    <Compile Include="Internal\NUnitLiteTestAssemblyBuilder.cs" />
-    <Compile Include="Internal\NUnitLiteTestAssemblyRunner.cs" />
-    <Compile Include="Internal\OSPlatform.cs" />
-    <Compile Include="Internal\ParameterSet.cs" />
-    <Compile Include="Internal\PlatformHelper.cs" />
-    <Compile Include="Internal\PropertyBag.cs" />
-    <Compile Include="Internal\PropertyNames.cs" />
-    <Compile Include="Internal\Randomizer.cs" />
-    <Compile Include="Internal\Reflect.cs" />
-    <Compile Include="Internal\Results\TestCaseResult.cs" />
-    <Compile Include="Internal\Results\TestResult.cs" />
-    <Compile Include="Internal\Results\TestSuiteResult.cs" />
-    <Compile Include="Internal\RuntimeFramework.cs" />
-    <Compile Include="Internal\StackFilter.cs" />
-    <Compile Include="Internal\StringUtil.cs" />
-    <Compile Include="Internal\TestExecutionContext.cs" />
-    <Compile Include="Internal\TestFilter.cs" />
-    <Compile Include="Internal\TestFixtureBuilder.cs" />
-    <Compile Include="Internal\TestListener.cs" />
-    <Compile Include="Internal\Tests\ParameterizedFixtureSuite.cs" />
-    <Compile Include="Internal\Tests\ParameterizedMethodSuite.cs" />
-    <Compile Include="Internal\Tests\Test.cs" />
-    <Compile Include="Internal\Tests\TestAssembly.cs" />
-    <Compile Include="Internal\Tests\TestFixture.cs" />
-    <Compile Include="Internal\Tests\TestMethod.cs" />
-    <Compile Include="Internal\Tests\TestSuite.cs" />
-    <Compile Include="Internal\TextMessageWriter.cs" />
-    <Compile Include="Internal\ThreadUtility.cs" />
-    <Compile Include="Internal\TypeHelper.cs" />
-    <Compile Include="Internal\WorkItems\CompositeWorkItem.cs" />
-    <Compile Include="Internal\WorkItems\SimpleWorkItem.cs" />
-    <Compile Include="Internal\WorkItems\WorkItem.cs" />
-    <Compile Include="Internal\WorkItems\WorkItemState.cs" />
-    <Compile Include="Is.cs" />
-    <Compile Include="Iz.cs" />
-    <Compile Include="ListMapper.cs" />
-    <Compile Include="MessageMatch.cs" />
-    <Compile Include="ObjectList.cs" />
-    <Compile Include="Runner\CommandLineOptions.cs" />
-    <Compile Include="Runner\ConsoleWriter.cs" />
-    <Compile Include="Runner\DebugWriter.cs" />
-    <Compile Include="Runner\OutputWriters\NUnit2XmlOutputWriter.cs" />
-    <Compile Include="Runner\OutputWriters\NUnit3XmlOutputWriter.cs" />
-    <Compile Include="Runner\OutputWriters\OutputWriter.cs" />
-    <Compile Include="Runner\ResultReporter.cs" />
-    <Compile Include="Runner\ResultSummary.cs" />
-    <Compile Include="Runner\TcpWriter.cs" />
-    <Compile Include="Runner\TextUI.cs" />
-    <Compile Include="SpecialValue.cs" />
-    <Compile Include="TestCaseData.cs" />
-    <Compile Include="TestContext.cs" />
-    <Compile Include="Throws.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Folder Include="Properties\" />
-  </ItemGroup>
-  <ItemGroup>
-    <BootstrapperPackage Include="Microsoft.Net.Client.3.5">
-      <Visible>False</Visible>
-      <ProductName>.NET Framework 3.5 SP1 Client Profile</ProductName>
-      <Install>false</Install>
-    </BootstrapperPackage>
-    <BootstrapperPackage Include="Microsoft.Net.Framework.3.5.SP1">
-      <Visible>False</Visible>
-      <ProductName>.NET Framework 3.5 SP1</ProductName>
-      <Install>true</Install>
-    </BootstrapperPackage>
-    <BootstrapperPackage Include="Microsoft.Windows.Installer.3.1">
-      <Visible>False</Visible>
-      <ProductName>Windows Installer 3.1</ProductName>
-      <Install>true</Install>
-    </BootstrapperPackage>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="nunit.snk" />
-  </ItemGroup>
-  <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="4.0">
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProductVersion>9.0.30729</ProductVersion>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>{D12F0F7B-8DE3-43EC-BA49-41052D065A9B}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>NUnitLite</RootNamespace>
+    <AssemblyName>nunitlite</AssemblyName>
+    <FileUpgradeFlags>
+    </FileUpgradeFlags>
+    <OldToolsVersion>3.5</OldToolsVersion>
+    <UpgradeBackupLocation>
+    </UpgradeBackupLocation>
+    <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
+    <PublishUrl>publish\</PublishUrl>
+    <Install>true</Install>
+    <InstallFrom>Disk</InstallFrom>
+    <UpdateEnabled>false</UpdateEnabled>
+    <UpdateMode>Foreground</UpdateMode>
+    <UpdateInterval>7</UpdateInterval>
+    <UpdateIntervalUnits>Days</UpdateIntervalUnits>
+    <UpdatePeriodically>false</UpdatePeriodically>
+    <UpdateRequired>false</UpdateRequired>
+    <MapFileExtensions>true</MapFileExtensions>
+    <ApplicationRevision>0</ApplicationRevision>
+    <ApplicationVersion>1.0.0.%2a</ApplicationVersion>
+    <IsWebBootstrapper>false</IsWebBootstrapper>
+    <UseApplicationTrust>false</UseApplicationTrust>
+    <BootstrapperEnabled>true</BootstrapperEnabled>
+    <TargetFrameworkProfile />
+    <IntermediateOutputPath>obj\$(Configuration)\net-4.5\</IntermediateOutputPath>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>..\..\bin\Debug\net-4.5\</OutputPath>
+    <DefineConstants>TRACE;DEBUG;NET_4_5, CLR_4_0,NUNITLITE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+    <DocumentationFile>..\..\bin\Debug\net-4.5\nunitlite.xml</DocumentationFile>
+    <Prefer32Bit>false</Prefer32Bit>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>