private void CompareWithExpectedResult(Feature feature, string expectedResultFileName)
        {
            string expected = TestFileHelper.ReadFile(expectedResultFileName).Replace("\r", "");
            string got = SerializeFeature(feature).Replace("\r", "");

            Assert.AreEqual(expected, got);
        }

        private object CompileAndCreateTest(string fileName, Feature feature)
        {
            string className = Path.GetFileNameWithoutExtension(fileName);
            const string targetNamespace = "Target.Namespace";
            // the row test generation has to be set to false, because our verifications support the old style test generation only
            SpecFlowUnitTestConverter converter = new SpecFlowUnitTestConverter(CreateUnitTestGeneratorProvider(), new CodeDomHelper(CodeDomProviderLanguage.CSharp), new GeneratorConfiguration { AllowRowTests = false, AllowDebugGeneratedFiles = true }); 
            var codeNamespace = converter.GenerateUnitTestFixture(feature, className, targetNamespace);
            var compileUnit = new CodeCompileUnit();
            compileUnit.Namespaces.Add(codeNamespace);

            Dictionary<string, string> providerOptions = new Dictionary<string, string>();
            providerOptions["CompilerVersion"] = "v3.5";

            CSharpCodeProvider codeProvider = new CSharpCodeProvider(providerOptions);

            CompilerParameters compilerParameters = new CompilerParameters();
            compilerParameters.GenerateInMemory = true;
            compilerParameters.TempFiles.KeepFiles = true;

            compilerParameters.ReferencedAssemblies.Add(
                TestFileHelper.GetAssemblyPath(typeof (GeneratedCodeAttribute))); //System
            compilerParameters.ReferencedAssemblies.Add(
                TestFileHelper.GetAssemblyPath(typeof (TestAttribute))); //NUnit
            compilerParameters.ReferencedAssemblies.Add(
                TestFileHelper.GetAssemblyPath(typeof (ITestRunner))); //TechTalk.SpecFlow

            var results = codeProvider.CompileAssemblyFromDom(compilerParameters, compileUnit);

            if (results.NativeCompilerReturnValue != 0)
                throw new InvalidOperationException("Test cannot be compiled: " + 
                                                    string.Join(Environment.NewLine, results.Errors.Cast<CompilerError>().Select(ce => ce.ToString()).ToArray()));

            Type testType = results.CompiledAssembly.GetType(targetNamespace + "." + className, true);
            return Activator.CreateInstance(testType);
        }

        private void CompareWithExpectedResult(Feature feature, string expectedResultFileName)
        {
            string expected = TestFileHelper.ReadFile(expectedResultFileName);
            string got = GenerateCodeFromFeature(feature);

            Assert.AreEqual(expected, got);
        }

        public static bool MatchPrefix(this ITagFilterMatcher tagFilterMatcher, string tagFilter, Feature feature)
        {
            if (feature.Tags == null)
                return false;

            return tagFilterMatcher.MatchPrefix(tagFilter, feature.Tags.Select(t => t.Name));
        }

 private void GenerateCodeFromFeature(Feature feature, string fileName)
 {
     using (var writer = new StreamWriter(fileName, false, Encoding.UTF8))
     {
         GenerateCodeFromFeature(feature, writer);
     }
 }

 private void SerializeFeature(Feature feature, string fileName)
 {
     using (var writer = new StreamWriter(fileName, false, Encoding.UTF8))
     {
         SerializeFeature(feature, writer);
     }
 }

        public void Should_UnitTestFeatureGeneratorProvider_create_UnitTestFeatureGenerator_instance()
        {
            var generatorProvider = CreateUnitTestFeatureGeneratorProvider();
            Feature anyFeature = new Feature();
            var generator = generatorProvider.CreateGenerator(anyFeature);

            generator.Should().BeOfType<UnitTestFeatureGenerator>();
        }

        public void Should_UnitTestFeatureGeneratorProvider_create_valid_instance()
        {
            var generatorProvider = CreateUnitTestFeatureGeneratorProvider();
            Feature anyFeature = new Feature();
            var generator = generatorProvider.CreateGenerator(anyFeature);

            generator.Should().NotBeNull();
        }

 private string SerializeFeature(Feature feature)
 {
     using (var writer = new Utf8StringWriter())
     {
         SerializeFeature(feature, writer);
         return writer.ToString();
     }
 }

        public ScenarioOutlineViewModel(Feature feature, ScenarioOutline scenarioOutline)
            : base(scenarioOutline, feature)
        {
            var bgSteps = feature.Background != null ? feature.Background.Steps.AsEnumerable() : Enumerable.Empty<ScenarioStep>();

            StepTemplates = bgSteps.Concat(scenarioOutline.Steps).Select(x => new StepTemplateViewModel(x)).ToList();

            Examples = scenarioOutline.Examples.ExampleSets.Select(x => new ScenarioOutlineExampleSetViewModel(this, x)).ToList();
        }

 protected override void ExecuteTests(object test, Feature feature)
 {
     NUnitTestExecutor.ExecuteNUnitTests(test,
         delegate(Exception exception)
         {
             Assert.IsInstanceOf(typeof(InconclusiveException), exception);
             return true;
         });
 }

        public void Should_create_UnitTestFeatureGenerator_with_default_setup()
        {
            var featureGeneratorRegistry = CreateFeatureGeneratorRegistry();

            Feature anyFeature = new Feature();
            var generator = featureGeneratorRegistry.CreateGenerator(anyFeature);

            generator.Should().BeOfType<UnitTestFeatureGenerator>();
        }

        private void GenerateCodeFromFeature(Feature feature, TextWriter writer)
        {
            SpecFlowUnitTestConverter converter = FactoryMethods.CreateUnitTestConverter(new NUnitTestConverter());
            var codeNamespace = converter.GenerateUnitTestFixture(feature, "TestClassName", "Target.Namespace");

            CSharpCodeProvider codeProvider = new CSharpCodeProvider();
            CodeGeneratorOptions options = new CodeGeneratorOptions();
            codeProvider.GenerateCodeFromNamespace(codeNamespace, writer, options);
        }

        public static bool GetTagValue(this ITagFilterMatcher tagFilterMatcher, string tagFilter, Feature feature, out string value)
        {
            if (feature.Tags == null)
            {
                value = null;
                return false;
            }

            return tagFilterMatcher.GetTagValue(tagFilter, feature.Tags.Select(t => t.Name), out value);
        }

        public FeatureViewModel(Feature feature)
        {
            FeatureNode = feature;
            if (feature.Background != null)
            {
                BackgroundSteps = feature.Background.Steps.Select(x => new StepViewModel(x)).ToList();
            }

            Scenarios = feature.Scenarios.Select(x => x is ScenarioOutline ? (ScenarioViewModelBase)new ScenarioOutlineViewModel(feature, (ScenarioOutline) x) : new ScenarioViewModel(feature, x)).ToList();
        }

 public Feature GetResult()
 {
     var feature = new Feature(
         title,
         tags,
         description,
         background == null ? null : background.GetResult(),
         scenarios.Select(sb => sb.GetResult()).ToArray());
     feature.SourceFile = sourceFilePath;
     return feature;
 }

		private void GenerateCodeFromFeature(Feature feature, TextWriter writer)
		{
		    CodeDomHelper codeDomHelper = new CodeDomHelper(CodeDomProviderLanguage.CSharp);
		    XUnitTestGeneratorProvider xUnitTestGeneratorProvider = new XUnitTestGeneratorProvider();
		    SpecFlowUnitTestConverter converter = FactoryMethods.CreateUnitTestConverter(xUnitTestGeneratorProvider);
			var codeNamespace = converter.GenerateUnitTestFixture(feature, "TestClassName", "Target.Namespace");

			CSharpCodeProvider codeProvider = new CSharpCodeProvider();
			CodeGeneratorOptions options = new CodeGeneratorOptions();
			codeProvider.GenerateCodeFromNamespace(codeNamespace, writer, options);
		}

        private static string GetPlainText(string fileName, Scenario scenario, Feature feature)
        {
            var lines = File.ReadAllLines(fileName);

            var nextScenario = feature.Scenarios.SkipWhile(s => s != scenario).Skip(1).FirstOrDefault();

            int startLine = scenario.FilePosition.Line;
            int endLine = nextScenario == null ? lines.Count() : nextScenario.FilePosition.Line - 1;

            return string.Join(Environment.NewLine, lines.Skip(startLine - 1).Take(endLine - startLine + 1)).Replace("\t", "  ");
        }

    /// <summary>
    /// Generates the unit test fixture.
    /// </summary>
    /// <param name="feature">The feature.</param>
    /// <param name="testClassName">Name of the test class.</param>
    /// <param name="targetNamespace">The target namespace.</param>
    /// <returns>Instance of CodeNamespace.</returns>
    public CodeNamespace GenerateUnitTestFixture(Feature feature, string testClassName, string targetNamespace)
    {
      CodeNamespace result = this.baseFeatureGenerator.GenerateUnitTestFixture(feature, testClassName, targetNamespace);

      if (this.IsLiveTest(feature))
      {
        this.DecorateStaticMethods(result);
        this.DecorateFixtureClasses(result);
      }

      return result;
    }

        public string GetFeatureText(Feature feature, CultureInfo defaultLanguage = null)
        {
            defaultLanguage = defaultLanguage ?? new CultureInfo("en-US");
            var dialectServices = new GherkinDialectServices(defaultLanguage);
            var dialect = dialectServices.GetGherkinDialect(feature);

            var result = new StringBuilder();

            AppendHeader(defaultLanguage, dialect, result);

            AppendTags(result, feature.Tags);
            AppendFeatureLine(feature, result);
            AppendLine(result);

            if (feature.Background != null)
            {
                AppendBackgroundLine(feature.Background, result);
                AppendSteps(feature.Background.Steps, result);
                AppendLine(result);
            }

            foreach (var scenario in feature.Scenarios)
            {
                var outline = scenario as ScenarioOutline;
                bool isOutline = outline != null;

                AppendTags(result, scenario.Tags);
                AppendScenarioLine(result, scenario, dialect, isOutline);

                AppendSteps(scenario.Steps, result);

                AppendLine(result);

                if (isOutline)
                {
                    foreach (var exampleSet in outline.Examples.ExampleSets)
                    {
                        AppendTags(result, exampleSet.Tags);
                        AppendExampleSetLine(result, dialect, exampleSet);
                        AppendTable(result, exampleSet.Table, indent);
                        AppendLine(result);
                    }
                }

                AppendLine(result);
            }

            return result.ToString();
        }