public MethodTokenExpression(IMethodInfo method)
		{
			this.method = method;
#if !MONO
			declaringType = method.DeclaringType;
#endif
		}

        protected override IEnumerable<ITestCommand> EnumerateTestCommands(IMethodInfo method)
        {
            if (method == null)
            {
                return new[] { new ExceptionCommand(new MethodCall(method), new ArgumentNullException("method")) };
            }

            IEnumerable<ITestCommand> backgroundCommands;
            IEnumerable<ICommand> scenarioCommands;

            // NOTE: any exception must be wrapped in a command, otherwise the test runner will retry this method infinitely
            try
            {
                backgroundCommands = this.EnumerateBackgroundCommands(method).ToArray();
                scenarioCommands = this.EnumerateScenarioCommands(method).ToArray();
            }
            catch (Exception ex)
            {
                return new[] { new ExceptionCommand(new MethodCall(method), ex) };
            }

            // NOTE: this is not in the try catch since we are yielding internally
            // TODO: address this - see http://stackoverflow.com/a/346772/49241
            return scenarioCommands.SelectMany(
                scenarioCommand => CurrentScenario.ExtractCommands(scenarioCommand.MethodCall, backgroundCommands.Concat(new[] { scenarioCommand })));
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="TestMethod"/> class.
 /// </summary>
 /// <param name="method">The method to be used as a test.</param>
 /// <param name="parentSuite">The suite or fixture to which the new test will be added</param>
 public TestMethod(IMethodInfo method, Test parentSuite) : base(method ) 
 {
     // Needed to give proper fullname to test in a parameterized fixture.
     // Without this, the arguments to the fixture are not included.
     if (parentSuite != null)
         FullName = parentSuite.FullName + "." + Name;
 }

 public IEnumerable<ITestCommand> CreateTestCommands(IMethodInfo testMethod, IFixtureSet fixtureSet)
 {
     foreach (var command in MethodUtility.GetTestCommands(testMethod))
     {
         yield return new ParadigmTestCommand(testMethod, fixtureSet.ApplyFixturesToCommand(command), GetNameFor(command), new ConstructorInvokingObjectFactory(_testClassType.Type, _parameters.Select(x => x.Value).ToArray()));
     }
 }

 /// <inheritdoc />
 protected override void DecorateContainingScope(IPatternScope containingScope, IMethodInfo methodInfo)
 {
     Type formattableType = methodInfo.Parameters[0].Resolve(true).ParameterType;
     var extensionPoints = (IExtensionPoints)RuntimeAccessor.ServiceLocator.ResolveByComponentId("Gallio.ExtensionPoints");
     CustomTestEnvironment.SetUpThreadChain.Before(() => extensionPoints.CustomFormatters.Register(formattableType, x => (string)methodInfo.Resolve(true).Invoke(this, new[] { x })));
     CustomTestEnvironment.TeardownThreadChain.After(() => extensionPoints.CustomFormatters.Unregister(formattableType));
 }

 public IEnumerable<ITestCommand> EnumerateTestCommands(IMethodInfo testMethod)
 {
     var commands = command.EnumerateTestCommands(testMethod).ToList();
     if (!commands.Any())
         commands.Add(new FactCommand(testMethod));
     return commands;
 }

 public FailedResult(IMethodInfo method, Exception exception, string displayName)
     : base(method, displayName)
 {
     ExceptionType = exception.GetType().FullName;
     Message = ExceptionUtility.GetMessage(exception);
     StackTrace = ExceptionUtility.GetStackTrace(exception);
 }

        /// <summary>
        /// Construct one or more TestMethods from a given MethodInfo,
        /// using available parameter data.
        /// </summary>
        /// <param name="method">The MethodInfo for which tests are to be constructed.</param>
        /// <param name="suite">The suite to which the tests will be added.</param>
        /// <returns>One or more TestMethods</returns>
        public IEnumerable<TestMethod> BuildFrom(IMethodInfo method, Test suite)
        {
            List<TestMethod> tests = new List<TestMethod>();
            
            IParameterInfo[] parameters = method.GetParameters();

            if (parameters.Length > 0)
            {
                IEnumerable[] sources = new IEnumerable[parameters.Length];

                try
                {
                    for (int i = 0; i < parameters.Length; i++)
                        sources[i] = _dataProvider.GetDataFor(parameters[i]);
                }
                catch (InvalidDataSourceException ex)
                {
                    var parms = new TestCaseParameters();
                    parms.RunState = RunState.NotRunnable;
                    parms.Properties.Set(PropertyNames.SkipReason, ex.Message);
                    tests.Add(_builder.BuildTestMethod(method, suite, parms));
                    return tests;
                }

                foreach (var parms in _strategy.GetTestCases(sources))
                    tests.Add(_builder.BuildTestMethod(method, suite, (TestCaseParameters)parms));
            }

            return tests;
        }

 public RepositoryTheoryCommand(IMethodInfo method, RepositoryProvider provider)
     :base(method)
 {
     _provider = provider;
     DisplayName = string.Format(
             "{0} - DatabaseProvider: {1}", DisplayName, _provider);
 }

        internal UnresolvedMethodInfo(IMethodInfo adapter)
        {
            if (adapter == null)
                throw new ArgumentNullException("adapter");

            this.adapter = adapter;
        }

        /// <summary>
        /// Finds the tests on a test method.
        /// </summary>
        /// <param name="testCollection">The test collection that the test method belongs to.</param>
        /// <param name="type">The test class that the test method belongs to.</param>
        /// <param name="method">The test method.</param>
        /// <param name="includeSourceInformation">Set to <c>true</c> to indicate that source information should be included.</param>
        /// <param name="messageBus">The message bus to report discovery messages to.</param>
        /// <returns>Return <c>true</c> to continue test discovery, <c>false</c>, otherwise.</returns>
        protected virtual bool FindTestsForMethod(ITestCollection testCollection, ITypeInfo type, IMethodInfo method, bool includeSourceInformation, IMessageBus messageBus)
        {
            var factAttribute = method.GetCustomAttributes(typeof(FactAttribute)).FirstOrDefault();
            if (factAttribute == null)
                return true;

            var testCaseDiscovererAttribute = factAttribute.GetCustomAttributes(typeof(XunitTestCaseDiscovererAttribute)).FirstOrDefault();
            if (testCaseDiscovererAttribute == null)
                return true;

            var args = testCaseDiscovererAttribute.GetConstructorArguments().Cast<string>().ToList();
            var discovererType = Reflector.GetType(args[1], args[0]);
            if (discovererType == null)
                return true;

            var discoverer = GetDiscoverer(discovererType);
            if (discoverer == null)
                return true;

            foreach (var testCase in discoverer.Discover(testCollection, AssemblyInfo, type, method, factAttribute))
                if (!ReportDiscoveredTestCase(testCase, includeSourceInformation, messageBus))
                    return false;

            return true;
        }

    public IEnumerable<ITestCommand> EnumerateTestCommands(IMethodInfo testMethod)
    {
        EnumerateTestCommands__Called = true;
        EnumerateTestCommands_TestMethod = testMethod;

        return EnumerateTestCommands__Result ?? testClassCommand.EnumerateTestCommands(testMethod);
    }

 protected MethodResult(IMethodInfo method, string displayName)
     : this(method.Name,
            method.TypeName,
            displayName,
            MethodUtility.GetTraits(method))
 {
 }

        protected override IEnumerable<ITestCommand> EnumerateTestCommands(IMethodInfo method)
        {
            var commands = base.EnumerateTestCommands(method);
            var attrs = method.MethodInfo.GetCustomAttributes(typeof(DataAttribute), false);

            if (commands.Count() != attrs.Count())
            {
                throw new InvalidOperationException("Some data attribute doesn't generate test command");
            }

            var filteredCommands = new List<ITestCommand>();
            int index = 0;

            foreach (var command in commands)
            {
                var theoryCmd = command as TheoryCommand;
                var skippableData = attrs.ElementAt(index++) as ISkippable;
                if (skippableData != null &&
                    !string.IsNullOrEmpty(skippableData.SkipReason))
                {
                    SkipCommand cmd = new SkipCommand(method, theoryCmd.DisplayName, skippableData.SkipReason);
                    filteredCommands.Add(cmd);
                }
                else
                {
                    filteredCommands.Add(command);
                }
            }

            return filteredCommands;
        }

		protected override IEnumerable<ITestCommand> EnumerateTestCommands(IMethodInfo method)
		{
			if (DateTime.Today < SkipUntil)
				return Enumerable.Empty<ITestCommand>();
			throw new InvalidOperationException("Time bombed fact expired");
			//return base.EnumerateTestCommands(method);
		}

        /// <summary>
        /// Creates a new instance of <see cref="TheoryCommand"/> based on a generic theory.
        /// </summary>
        /// <param name="testMethod">The method under test</param>
        /// <param name="parameters">The parameters to be passed to the test method</param>
        /// <param name="genericTypes">The generic types that were used to resolved the generic method.</param>
        public TheoryCommand(IMethodInfo testMethod, object[] parameters, Type[] genericTypes)
            : base(testMethod, MethodUtility.GetDisplayName(testMethod), MethodUtility.GetTimeoutParameter(testMethod))
        {
            Guard.ArgumentNotNull("testMethod", testMethod);

            int idx;

            Parameters = parameters ?? new object[0];

            if (genericTypes != null && genericTypes.Length > 0)
            {
                string[] typeNames = new string[genericTypes.Length];
                for (idx = 0; idx < genericTypes.Length; idx++)
                    typeNames[idx] = ConvertToSimpleTypeName(genericTypes[idx]);

                DisplayName = String.Format(CultureInfo.CurrentCulture, "{0}<{1}>", DisplayName, string.Join(", ", typeNames));
            }

            ParameterInfo[] parameterInfos = testMethod.MethodInfo.GetParameters();
            string[] displayValues = new string[Math.Max(Parameters.Length, parameterInfos.Length)];

            for (idx = 0; idx < Parameters.Length; idx++)
                displayValues[idx] = ParameterToDisplayValue(GetParameterName(parameterInfos, idx), Parameters[idx]);

            for (; idx < parameterInfos.Length; idx++)  // Fill-in any missing parameters with "???"
                displayValues[idx] = parameterInfos[idx].Name + ": ???";

            DisplayName = String.Format(CultureInfo.CurrentCulture, "{0}({1})", DisplayName, string.Join(", ", displayValues));
        }

 /// <summary>
 /// Creates a new instance of the <see cref="TestMethodCommand"/> class.
 /// </summary>
 /// <param name="method">The <see cref="IMethodInfo"/> describing the test case method.</param>
 public TestMethodCommand(IMethodInfo method)
     : base(method)
 {
     this.Namespace = method.Class.Type.Namespace;
     this.Class = method.Class.Type.Name;
     this.Method = method.Name;
 }

        public CulturedXunitTestCase(ITestCollection testCollection, IAssemblyInfo assembly, ITypeInfo type, IMethodInfo method, IAttributeInfo factAttribute, string culture)
            : base(testCollection, assembly, type, method, factAttribute)
        {
            this.culture = culture;

            Traits.Add("Culture", culture);
        }

 protected override IEnumerable<ITestCommand> EnumerateTestCommands(IMethodInfo method)
 {
     foreach (ITestCommand command in EnumerateTestCommandsInternal(method))
     {
         yield return new ObservationCommand(command);
     }
 }

        /// <inheritdoc />
        protected override void Validate(IPatternScope containingScope, IMethodInfo method)
        {
            base.Validate(containingScope, method);

            if (method.Parameters.Count != 0)
                ThrowUsageErrorException("A fixture set-up method must not have any parameters.");
        }