private static string GetTestMethodName(StepsContainer scenario, string variantName, string exampleSetIdentifier)
{
var methodName = string.Format(GeneratorConstants.TEST_NAME_FORMAT, scenario.Name.ToIdentifier());
if (variantName == null)
{
return(methodName);
}
var variantNameIdentifier = variantName.ToIdentifier().TrimStart('_');
methodName = string.IsNullOrEmpty(exampleSetIdentifier)
? $"{methodName}_{variantNameIdentifier}"
: $"{methodName}_{exampleSetIdentifier}_{variantNameIdentifier}";
return(methodName);
}
StepsContainer TransformSteps(string currentDocumentSourceFilePath, StepsContainer hasLocation)
{
switch (hasLocation)
{
case Background background:
{
var backgroundDocument = GetBackgroundDocument(currentDocumentSourceFilePath, background.Name ?? "");
return(backgroundDocument ?? background);
}
case Scenario scenario:
{
var transformedSteps = scenario.Steps.SelectMany(step =>
{
var backgroundDocument = GetBackgroundDocument(currentDocumentSourceFilePath, step.Text ?? "");
return(backgroundDocument?.Steps ?? new[] { step });
});
if (scenario is ScenarioOutline scenarioOutline)
{
return(new ScenarioOutline(
scenarioOutline.Tags.ToArray(),
scenarioOutline.Location,
scenarioOutline.Keyword,
scenarioOutline.Name,
scenarioOutline.Description,
transformedSteps.ToArray(),
scenarioOutline.Examples.ToArray()
));
}
return(new Scenario(
scenario.Tags.ToArray(),
scenario.Location,
scenario.Keyword,
scenario.Name,
scenario.Description,
transformedSteps.ToArray(),
scenario.Examples.ToArray()
));
}
}
return(hasLocation);
}
private int GetScenarioDefinitionLastLine(StepsContainer stepsContainer)
{
if (stepsContainer is ScenarioOutline scenarioOutline)
{
var lastExamples = scenarioOutline.Examples.LastOrDefault();
if (lastExamples != null)
{
return(GetExamplesLastLine(lastExamples));
}
}
var lastStep = stepsContainer.Steps.LastOrDefault();
if (lastStep == null)
{
return(stepsContainer.Location.Line);
}
return(GetStepLastLine(lastStep));
}
private void SetupTestMethod(
TestClassGenerationContext generationContext,
CodeMemberMethod testMethod,
StepsContainer scenarioDefinition,
IEnumerable <Tag> additionalTags,
string variantName,
string exampleSetIdentifier,
bool rowTest = false)
{
testMethod.ReturnType = new CodeTypeReference(typeof(Task));
testMethod.Attributes = MemberAttributes.Public;
testMethod.Name = GetTestMethodName(scenarioDefinition, variantName, exampleSetIdentifier);
_unitTestGeneratorProvider.MarkCodeMemberMethodAsAsync(testMethod);
var friendlyTestName = scenarioDefinition.Name;
if (variantName != null)
{
friendlyTestName = $"{scenarioDefinition.Name}: {variantName}";
}
if (rowTest)
{
_unitTestGeneratorProvider.SetRowTest(generationContext, testMethod, friendlyTestName);
}
else
{
_unitTestGeneratorProvider.SetTestMethod(generationContext, testMethod, friendlyTestName);
}
_decoratorRegistry.DecorateTestMethod(generationContext, testMethod, ConcatTags(scenarioDefinition.GetTags(), additionalTags), out var scenarioCategories);
if (scenarioCategories.Any())
{
_unitTestGeneratorProvider.SetTestMethodCategories(generationContext, testMethod, scenarioCategories);
}
}
private void CreateUnitTest(SpecFlowFeature feature, TestClassGenerationContext generationContext, StepsContainer scenarioDefinition)
{
if (string.IsNullOrEmpty(scenarioDefinition.Name))
{
throw new TestGeneratorException("The scenario must have a title specified.");
}
if (scenarioDefinition is ScenarioOutline scenarioOutline)
{
GenerateScenarioOutlineTest(generationContext, scenarioOutline, feature);
}
else
{
GenerateTest(generationContext, (Scenario)scenarioDefinition, feature);
}
}
internal void GenerateScenarioInitializeCall(TestClassGenerationContext generationContext, StepsContainer scenario, CodeMemberMethod testMethod)
{
var statements = new List <CodeStatement>();
using (new SourceLineScope(_specFlowConfiguration, _codeDomHelper, statements, generationContext.Document.SourceFilePath, scenario.Location))
{
statements.Add(new CodeExpressionStatement(
new CodeMethodInvokeExpression(
new CodeThisReferenceExpression(),
generationContext.ScenarioInitializeMethod.Name,
new CodeVariableReferenceExpression("scenarioInfo"))));
}
testMethod.Statements.AddRange(statements.ToArray());
}
internal void GenerateTestMethodBody(TestClassGenerationContext generationContext, StepsContainer scenario, CodeMemberMethod testMethod, ParameterSubstitution paramToIdentifier, SpecFlowFeature feature)
{
var statementsWhenScenarioIsIgnored = new CodeStatement[] { new CodeExpressionStatement(CreateTestRunnerSkipScenarioCall()) };
var statementsWhenScenarioIsExecuted = new List <CodeStatement>
{
new CodeExpressionStatement(
new CodeMethodInvokeExpression(
new CodeThisReferenceExpression(),
generationContext.ScenarioStartMethod.Name))
};
if (generationContext.Feature.HasFeatureBackground())
{
using (new SourceLineScope(_specFlowConfiguration, _codeDomHelper, statementsWhenScenarioIsExecuted, generationContext.Document.SourceFilePath, generationContext.Feature.Background.Location))
{
statementsWhenScenarioIsExecuted.Add(new CodeExpressionStatement(
new CodeMethodInvokeExpression(
new CodeThisReferenceExpression(),
generationContext.FeatureBackgroundMethod.Name)));
}
}
foreach (var scenarioStep in scenario.Steps)
{
_scenarioPartHelper.GenerateStep(generationContext, statementsWhenScenarioIsExecuted, scenarioStep, paramToIdentifier);
}
var isScenarioIgnoredVariable = new CodeVariableDeclarationStatement(typeof(bool), "isScenarioIgnored", new CodeDefaultValueExpression(new CodeTypeReference(typeof(bool))));
var isFeatureIgnoredVariable = new CodeVariableDeclarationStatement(typeof(bool), "isFeatureIgnored", new CodeDefaultValueExpression(new CodeTypeReference(typeof(bool))));
testMethod.Statements.Add(isScenarioIgnoredVariable);
testMethod.Statements.Add(isFeatureIgnoredVariable);
var tagsOfScenarioVariableReferenceExpression = new CodeVariableReferenceExpression("tagsOfScenario");
var isScenarioIgnoredVariableReferenceExpression = new CodeVariableReferenceExpression("isScenarioIgnored");
var featureFileTagFieldReferenceExpression = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "_featureTags");
var isFeatureIgnoredVariableReferenceExpression = new CodeVariableReferenceExpression("isFeatureIgnored");
var ignoreLinqStatement = "Where(__entry => __entry != null).Where(__entry => String.Equals(__entry, \"ignore\", StringComparison.CurrentCultureIgnoreCase)).Any";
if (_codeDomHelper.TargetLanguage == CodeDomProviderLanguage.VB)
{
ignoreLinqStatement = "Where(Function(__entry) __entry IsNot Nothing).Where(Function(__entry) String.Equals(__entry, \"ignore\", StringComparison.CurrentCultureIgnoreCase)).Any";
}
var ifIsNullStatement = new CodeConditionStatement(CreateCheckForNullExpression(tagsOfScenarioVariableReferenceExpression), new CodeAssignStatement(isScenarioIgnoredVariableReferenceExpression,
new CodeMethodInvokeExpression(tagsOfScenarioVariableReferenceExpression, ignoreLinqStatement)));
var ifIsFeatureTagsNullStatement = new CodeConditionStatement(CreateCheckForNullExpression(featureFileTagFieldReferenceExpression), new CodeAssignStatement(isFeatureIgnoredVariableReferenceExpression,
new CodeMethodInvokeExpression(featureFileTagFieldReferenceExpression, ignoreLinqStatement)));
testMethod.Statements.Add(ifIsNullStatement);
testMethod.Statements.Add(ifIsFeatureTagsNullStatement);
var isScenarioOrFeatureIgnoredExpression = new CodeBinaryOperatorExpression(isScenarioIgnoredVariableReferenceExpression, CodeBinaryOperatorType.BooleanOr, isFeatureIgnoredVariableReferenceExpression);
var ifIsIgnoredStatement = new CodeConditionStatement(isScenarioOrFeatureIgnoredExpression, statementsWhenScenarioIsIgnored, statementsWhenScenarioIsExecuted.ToArray());
testMethod.Statements.Add(ifIsIgnoredStatement);
}
private void GenerateTestBody(
TestClassGenerationContext generationContext,
StepsContainer scenario,
CodeMemberMethod testMethod,
SpecFlowFeature feature,
CodeExpression additionalTagsExpression = null, ParameterSubstitution paramToIdentifier = null)
{
//call test setup
//ScenarioInfo scenarioInfo = new ScenarioInfo("xxxx", tags...);
CodeExpression tagsExpression;
if (additionalTagsExpression == null)
{
tagsExpression = _scenarioPartHelper.GetStringArrayExpression(scenario.GetTags());
}
else if (!scenario.HasTags())
{
tagsExpression = additionalTagsExpression;
}
else
{
// merge tags list
// var tags = tags1
// if (tags2 != null)
// tags = Enumerable.ToArray(Enumerable.Concat(tags1, tags1));
testMethod.Statements.Add(
new CodeVariableDeclarationStatement(typeof(string[]), "__tags", _scenarioPartHelper.GetStringArrayExpression(scenario.GetTags())));
tagsExpression = new CodeVariableReferenceExpression("__tags");
testMethod.Statements.Add(
new CodeConditionStatement(
new CodeBinaryOperatorExpression(
additionalTagsExpression,
CodeBinaryOperatorType.IdentityInequality,
new CodePrimitiveExpression(null)),
new CodeAssignStatement(
tagsExpression,
new CodeMethodInvokeExpression(
new CodeTypeReferenceExpression(typeof(Enumerable)),
"ToArray",
new CodeMethodInvokeExpression(
new CodeTypeReferenceExpression(typeof(Enumerable)),
"Concat",
tagsExpression,
additionalTagsExpression)))));
}
AddVariableForTags(testMethod, tagsExpression);
testMethod.Statements.Add(
new CodeVariableDeclarationStatement(typeof(ScenarioInfo), "scenarioInfo",
new CodeObjectCreateExpression(typeof(ScenarioInfo),
new CodePrimitiveExpression(scenario.Name),
new CodePrimitiveExpression(scenario.Description),
tagsExpression)));
GenerateScenarioInitializeCall(generationContext, scenario, testMethod);
GenerateTestMethodBody(generationContext, scenario, testMethod, paramToIdentifier, feature);
GenerateScenarioCleanupMethodCall(generationContext, testMethod);
}
private void SetupTestMethod(TestClassGenerationContext generationContext, CodeMemberMethod testMethod, StepsContainer scenarioDefinition, IEnumerable <Tag> additionalTags,
string variantName, string exampleSetIdentifier, bool rowTest = false)
{
testMethod.Attributes = MemberAttributes.Public;
testMethod.Name = GetTestMethodName(scenarioDefinition, variantName, exampleSetIdentifier);
var friendlyTestName = scenarioDefinition.Name;
if (variantName != null)
{
friendlyTestName = string.Format("{0}: {1}", scenarioDefinition.Name, variantName);
}
if (rowTest)
{
testGeneratorProvider.SetRowTest(generationContext, testMethod, friendlyTestName);
}
else
{
testGeneratorProvider.SetTestMethod(generationContext, testMethod, friendlyTestName);
}
List <string> scenarioCategories;
decoratorRegistry.DecorateTestMethod(generationContext, testMethod, ConcatTags(scenarioDefinition.GetTags(), additionalTags), out scenarioCategories);
if (scenarioCategories.Any())
{
testGeneratorProvider.SetTestMethodCategories(generationContext, testMethod, scenarioCategories);
}
}
private CodeMemberMethod CreateTestMethod(TestClassGenerationContext generationContext, StepsContainer scenario, IEnumerable <Tag> additionalTags, string variantName = null,
string exampleSetIdentifier = null)
{
CodeMemberMethod testMethod = CreateMethod(generationContext.TestClass);
SetupTestMethod(generationContext, testMethod, scenario, additionalTags, variantName, exampleSetIdentifier);
return(testMethod);
}
private void AddScenarioDefinitionBlockTag(ITextSnapshot fileSnapshot, ProjectBindingRegistry bindingRegistry,
StepsContainer scenarioDefinition, DeveroomTag parentTag)
{
var scenarioDefinitionTag = CreateDefinitionBlockTag(scenarioDefinition,
DeveroomTagTypes.ScenarioDefinitionBlock, fileSnapshot,
GetScenarioDefinitionLastLine(scenarioDefinition), parentTag);
foreach (var step in scenarioDefinition.Steps)
{
var stepTag = scenarioDefinitionTag.AddChild(new DeveroomTag(DeveroomTagTypes.StepBlock,
GetBlockSpan(fileSnapshot, step.Location, GetStepLastLine(step)), step));
stepTag.AddChild(
new DeveroomTag(DeveroomTagTypes.StepKeyword,
GetTextSpan(fileSnapshot, step.Location, step.Keyword),
step.Keyword));
if (step.Argument is DataTable dataTable)
{
var dataTableBlockTag = new DeveroomTag(DeveroomTagTypes.DataTable,
GetBlockSpan(fileSnapshot, dataTable.Rows.First().Location,
dataTable.Rows.Last().Location.Line),
dataTable);
stepTag.AddChild(dataTableBlockTag);
var dataTableHeader = dataTable.Rows.FirstOrDefault();
if (dataTableHeader != null)
{
TagRowCells(fileSnapshot, dataTableHeader, dataTableBlockTag, DeveroomTagTypes.DataTableHeader);
}
}
else if (step.Argument is DocString docString)
{
stepTag.AddChild(
new DeveroomTag(DeveroomTagTypes.DocString,
GetBlockSpan(fileSnapshot, docString.Location,
GetStepLastLine(step)),
docString));
}
if (scenarioDefinition is ScenarioOutline)
{
AddPlaceholderTags(fileSnapshot, stepTag, step);
}
var match = bindingRegistry?.MatchStep(step, scenarioDefinitionTag);
if (match != null)
{
if (match.HasDefined || match.HasAmbiguous)
{
stepTag.AddChild(new DeveroomTag(DeveroomTagTypes.DefinedStep,
GetTextSpan(fileSnapshot, step.Location, step.Text, offset: step.Keyword.Length),
match));
if (!(scenarioDefinition is ScenarioOutline) || !step.Text.Contains("<"))
{
var parameterMatch = match.Items.FirstOrDefault(m => m.ParameterMatch != null)
?.ParameterMatch;
AddParameterTags(fileSnapshot, parameterMatch, stepTag, step);
}
}
if (match.HasUndefined)
{
stepTag.AddChild(new DeveroomTag(DeveroomTagTypes.UndefinedStep,
GetTextSpan(fileSnapshot, step.Location, step.Text, offset: step.Keyword.Length),
match));
}
if (match.HasErrors)
{
stepTag.AddChild(new DeveroomTag(DeveroomTagTypes.BindingError,
GetTextSpan(fileSnapshot, step.Location, step.Text, offset: step.Keyword.Length),
match.GetErrorMessage()));
}
}
}
if (scenarioDefinition is ScenarioOutline scenarioOutline)
{
foreach (var scenarioOutlineExample in scenarioOutline.Examples)
{
var examplesBlockTag = CreateDefinitionBlockTag(scenarioOutlineExample,
DeveroomTagTypes.ExamplesBlock, fileSnapshot,
GetExamplesLastLine(scenarioOutlineExample), scenarioDefinitionTag);
if (scenarioOutlineExample.TableHeader != null)
{
TagRowCells(fileSnapshot, scenarioOutlineExample.TableHeader, examplesBlockTag,
DeveroomTagTypes.ScenarioOutlinePlaceholder);
}
}
}
}
internal void GenerateMethodBodyForNotSkippedScenarios(TestClassGenerationContext generationContext, StepsContainer scenario, CodeMemberMethod testMethod, ParameterSubstitution paramToIdentifier)
{
if (HasFeatureBackground(generationContext.Feature))
{
AddLineDirective(testMethod.Statements, generationContext.Feature.Background);
testMethod.Statements.Add(
new CodeMethodInvokeExpression(
new CodeThisReferenceExpression(),
generationContext.FeatureBackgroundMethod.Name));
}
foreach (var scenarioStep in scenario.Steps)
{
GenerateStep(testMethod, scenarioStep, paramToIdentifier);
}
}
internal void GenerateScenarioInitializeCall(TestClassGenerationContext generationContext, StepsContainer scenario, CodeMemberMethod testMethod)
{
AddLineDirective(testMethod.Statements, scenario);
testMethod.Statements.Add(
new CodeMethodInvokeExpression(
new CodeThisReferenceExpression(),
generationContext.ScenarioInitializeMethod.Name,
new CodeVariableReferenceExpression("scenarioInfo")));
}
internal bool IsIgnoredStepsContainer(StepsContainer stepsContainer)
{
return(stepsContainer.GetTags().Any(t => string.Equals(t.Name, IGNORE_TAG, StringComparison.InvariantCultureIgnoreCase)));
}
internal void GenerateTestMethodBody(TestClassGenerationContext generationContext, StepsContainer scenario, CodeMemberMethod testMethod, ParameterSubstitution paramToIdentifier, SpecFlowFeature feature)
{
if (IsIgnoredFeature(feature) || IsIgnoredStepsContainer(scenario))
{
GenerateMethodBodyForSkippedScenario(testMethod);
}
else
{
GenerateScenarioStartMethodCall(generationContext, testMethod);
GenerateMethodBodyForNotSkippedScenarios(generationContext, scenario, testMethod, paramToIdentifier);
}
}
public List <string> GetScenarioVariantTagValues(StepsContainer scenario) // CHANGED FOM ScenarioDefinition
{
return(scenario.GetTags()?.Where(a => a.Name.StartsWith($"@{VariantKey}"))?.Select(a => a.Name.Split(':')[1]).ToList());
}
public static void AddLineDirective(this CodeDomHelper codeDomHelper, StepsContainer scenarioDefinition, CodeStatementCollection statements, SpecFlowConfiguration specFlowConfiguration) // CHANGED FROM ScenarioDefinitio to StepsContainter
{
AddLineDirective(statements, scenarioDefinition.Location, specFlowConfiguration, codeDomHelper);
}
private void GenerateTestBody(TestClassGenerationContext generationContext, StepsContainer scenario, CodeMemberMethod testMethod, CodeExpression additionalTagsExpression = null,
ParameterSubstitution paramToIdentifier = null)
{
//call test setup
//ScenarioInfo scenarioInfo = new ScenarioInfo("xxxx", tags...);
CodeExpression tagsExpression;
if (additionalTagsExpression == null)
{
tagsExpression = GetStringArrayExpression(scenario.GetTags());
}
else if (!scenario.HasTags())
{
tagsExpression = additionalTagsExpression;
}
else
{
// merge tags list
// var tags = tags1
// if (tags2 != null)
// tags = Enumerable.ToArray(Enumerable.Concat(tags1, tags1));
testMethod.Statements.Add(
new CodeVariableDeclarationStatement(typeof(string[]), "__tags", GetStringArrayExpression(scenario.GetTags())));
tagsExpression = new CodeVariableReferenceExpression("__tags");
testMethod.Statements.Add(
new CodeConditionStatement(
new CodeBinaryOperatorExpression(
additionalTagsExpression,
CodeBinaryOperatorType.IdentityInequality,
new CodePrimitiveExpression(null)),
new CodeAssignStatement(
tagsExpression,
new CodeMethodInvokeExpression(
new CodeTypeReferenceExpression(typeof(Enumerable)),
"ToArray",
new CodeMethodInvokeExpression(
new CodeTypeReferenceExpression(typeof(Enumerable)),
"Concat",
tagsExpression,
additionalTagsExpression)))));
}
testMethod.Statements.Add(
new CodeVariableDeclarationStatement(typeof(ScenarioInfo), "scenarioInfo",
new CodeObjectCreateExpression(typeof(ScenarioInfo),
new CodePrimitiveExpression(scenario.Name),
new CodePrimitiveExpression(scenario.Description),
tagsExpression)));
AddLineDirective(testMethod.Statements, scenario);
testMethod.Statements.Add(
new CodeMethodInvokeExpression(
new CodeThisReferenceExpression(),
generationContext.ScenarioInitializeMethod.Name,
new CodeVariableReferenceExpression("scenarioInfo")));
testMethod.Statements.Add(
new CodeMethodInvokeExpression(
new CodeThisReferenceExpression(),
generationContext.ScenarioStartMethod.Name));
if (HasFeatureBackground(generationContext.Feature))
{
AddLineDirective(testMethod.Statements, generationContext.Feature.Background);
testMethod.Statements.Add(
new CodeMethodInvokeExpression(
new CodeThisReferenceExpression(),
generationContext.FeatureBackgroundMethod.Name));
}
foreach (var scenarioStep in scenario.Steps)
{
GenerateStep(testMethod, scenarioStep, paramToIdentifier);
}
AddLineDirectiveHidden(testMethod.Statements);
// call scenario cleanup
testMethod.Statements.Add(
new CodeMethodInvokeExpression(
new CodeThisReferenceExpression(),
generationContext.ScenarioCleanupMethod.Name));
}
private void GenerateTestBody(TestClassGenerationContext generationContext, StepsContainer scenario, CodeMemberMethod testMethod, CodeExpression additionalTagsExpression = null, ParameterSubstitution paramToIdentifier = null)
{
CodeExpression left;
if (additionalTagsExpression == null)
{
left = scenario.GetTags().GetStringArrayExpression();
}
else if (!scenario.HasTags())
{
left = additionalTagsExpression;
}
else
{
testMethod.Statements.Add(new CodeVariableDeclarationStatement(typeof(string[]), "__tags", scenario.GetTags().GetStringArrayExpression()));
left = new CodeVariableReferenceExpression("__tags");
testMethod.Statements.Add(new CodeConditionStatement(new CodeBinaryOperatorExpression(additionalTagsExpression, CodeBinaryOperatorType.IdentityInequality, new CodePrimitiveExpression(null)), new CodeStatement[1]
{
new CodeAssignStatement(left, new CodeMethodInvokeExpression(new CodeTypeReferenceExpression(typeof(Enumerable)), "ToArray", new CodeExpression[1]
{
new CodeMethodInvokeExpression(new CodeTypeReferenceExpression(typeof(Enumerable)), "Concat", new CodeExpression[2]
{
left,
additionalTagsExpression
})
}))
}));
}
testMethod.Statements.Add(new CodeVariableDeclarationStatement(typeof(ScenarioInfo), "scenarioInfo", new CodeObjectCreateExpression(typeof(ScenarioInfo), new CodeExpression[3]
{
new CodePrimitiveExpression(scenario.Name),
new CodePrimitiveExpression(scenario.Description),
left
})));
//_codeDomHelper.AddLineDirective(scenario, testMethod.Statements, _specFlowConfiguration);
testMethod.Statements.Add(new CodeMethodInvokeExpression(new CodeThisReferenceExpression(), generationContext.ScenarioInitializeMethod.Name, new CodeExpression[1]
{
new CodeVariableReferenceExpression("scenarioInfo")
}));
//// NEW CODE START
if (_setVariantToContextForOutlineTest)
{
testMethod.Statements.Add(new CodeMethodInvokeExpression(new CodeMethodReferenceExpression(new CodePropertyReferenceExpression(new CodeFieldReferenceExpression(null, generationContext.TestRunnerField.Name), "ScenarioContext"), "Add", null), new CodeExpression[2]
{
new CodePrimitiveExpression(_variantHelper.VariantKey),
new CodeVariableReferenceExpression(_variantHelper.VariantKey.ToLowerInvariant())
}));
if (!generationContext.GenerateRowTests)
{
testMethod.Parameters.Add(new CodeParameterDeclarationExpression("System.String", _variantHelper.VariantKey.ToLowerInvariant()));
}
}
else if (_setVariantToContextForTest)
{
testMethod.Statements.Add(new CodeMethodInvokeExpression(new CodeMethodReferenceExpression(new CodePropertyReferenceExpression(new CodeFieldReferenceExpression(null, generationContext.TestRunnerField.Name), "ScenarioContext"), "Add", null), new CodeExpression[2]
{
new CodePrimitiveExpression(_variantHelper.VariantKey),
new CodePrimitiveExpression(_variantValue)
}));
}
_setVariantToContextForOutlineTest = false;
_setVariantToContextForTest = false;
_variantValue = null;
//// NEW CODE END
testMethod.Statements.Add(new CodeMethodInvokeExpression(new CodeThisReferenceExpression(), generationContext.ScenarioStartMethod.Name, new CodeExpression[0]));
if (generationContext.Feature.HasFeatureBackground())
{
//_codeDomHelper.AddLineDirective(generationContext.Feature.Background, testMethod.Statements, _specFlowConfiguration);
testMethod.Statements.Add(new CodeMethodInvokeExpression(new CodeThisReferenceExpression(), generationContext.FeatureBackgroundMethod.Name, new CodeExpression[0]));
}
foreach (var step in scenario.Steps)
{
GenerateStep(testMethod, step, paramToIdentifier);
}
//_codeDomHelper.AddLineDirectiveHidden(testMethod.Statements, _specFlowConfiguration);
testMethod.Statements.Add(new CodeMethodInvokeExpression(new CodeThisReferenceExpression(), generationContext.ScenarioCleanupMethod.Name, new CodeExpression[0]));
}
private void AddLineDirective(CodeStatementCollection statements, StepsContainer scenarioDefinition)
{
AddLineDirective(statements, scenarioDefinition.Location);
}
private void SetupTestMethod(TestClassGenerationContext generationContext, CodeMemberMethod testMethod, StepsContainer scenarioDefinition, IEnumerable <Tag> additionalTags, string variantName, string exampleSetIdentifier, bool rowTest = false)
{
testMethod.Attributes = MemberAttributes.Public;
testMethod.Name = GetTestMethodName(scenarioDefinition, variantName, exampleSetIdentifier);
var str = scenarioDefinition.Name;
if (variantName != null)
{
if (variantName.IndexOf("_") == 0)
{
variantName = variantName.Remove(0, 1);
} //NEW CODE
str = $"{scenarioDefinition.Name}: {variantName}";
}
if (rowTest)
{
_testGeneratorProvider.SetRowTest(generationContext, testMethod, str);
}
else
{
_testGeneratorProvider.SetTestMethod(generationContext, testMethod, str);
}
_decoratorRegistry.DecorateTestMethod(generationContext, testMethod, scenarioDefinition.GetTags().ConcatTags(additionalTags).ConcatTags(_featureVariantTags), out List <string> unprocessedTags);
if (!unprocessedTags.Any())
{
return;
}
_testGeneratorProvider.SetTestMethodCategories(generationContext, testMethod, unprocessedTags);
}
