public StepBinding GetBestMatchingBinding(StepInstance stepInstance, out IEnumerable <StepBinding> candidatingBindings)
{
candidatingBindings = Enumerable.Empty <StepBinding>();
var matches = GetCandidatingBindings(stepInstance, useParamMatching: true).ToList();
if (matches.Count == 0)
{
//HACK: since out param matching does not support agrument converters yet, we rather show more results than "no match"
matches = GetCandidatingBindings(stepInstance, useParamMatching: false).ToList();
}
if (matches.Count > 1)
{
// if there are both scoped and non-scoped matches, we take the ones with the higher degree of scope matches
int maxScopeMatches = matches.Max(m => m.ScopeMatches);
matches.RemoveAll(m => m.ScopeMatches < maxScopeMatches);
}
if (matches.Count == 0)
{
return(null);
}
if (matches.Count > 1)
{
candidatingBindings = matches.Select(m => m.StepBinding);
return(null);
}
return(matches[0].StepBinding);
}
public GenerateStepDefinitionSkeletonForm(string featureTitle, StepInstance[] steps, Project specFlowProject, StepDefinitionSkeletonStyle stepDefinitionSkeletonStyle, ProgrammingLanguage defaultLanguage, DTE dte)
{
this.dte = dte;
InitializeComponent();
stepsList.BeginUpdate();
stepsList.Items.Clear();
foreach (var step in steps)
{
stepsList.Items.Add(new ListItem(step), true);
}
stepsList.EndUpdate();
classNameTextBox.Text = string.Format("{0} Steps", featureTitle).ToIdentifier();
styleComboBox.BeginUpdate();
var styles = Enum.GetValues(typeof (StepDefinitionSkeletonStyle)).Cast<StepDefinitionSkeletonStyle>()
.Where(value => value != StepDefinitionSkeletonStyle.MethodNameRegex || defaultLanguage == ProgrammingLanguage.FSharp)
.ToArray();
styleComboBox.Items.Clear();
styleComboBox.Items.AddRange(styles.Select(s => new StyleItem(s)).ToArray<object>());
int selectedIndex = Array.IndexOf(styles, stepDefinitionSkeletonStyle);
styleComboBox.SelectedIndex = selectedIndex < 0 ? 0 : selectedIndex;
styleComboBox.EndUpdate();
defaultFolder = Path.Combine(VsxHelper.GetProjectFolder(specFlowProject), "StepDefinitions");
if (!Directory.Exists(defaultFolder))
defaultFolder = VsxHelper.GetProjectFolder(specFlowProject);
}
public override string GetStepDefinitionSkeleton(StepInstance stepInstance)
{
List<string> extraArgs = new List<string>();
if (stepInstance.MultilineTextArgument != null)
extraArgs.Add("ByVal multilineText As String");
if (stepInstance.TableArgument != null)
extraArgs.Add("ByVal table As Table");
StringBuilder result = new StringBuilder();
// in VB "When" and "Then" are language keywords - use the fully qualified namespace
string namespaceAddition = "TechTalk.SpecFlow.";
if (stepInstance.StepDefinitionType == StepDefinitionType.Given)
{
namespaceAddition = "";
}
result.AppendFormat(@"<{4}{0}(""{1}"")> _
Public Sub {2}({3})
ScenarioContext.Current.Pending()
End Sub",
stepInstance.StepDefinitionType,
EscapeRegex(stepInstance.Text),
GetStepText(stepInstance).ToIdentifier(),
string.Join(", ", extraArgs.ToArray()),
namespaceAddition
);
result.AppendLine();
return result.ToString();
}
private IEnumerable<BindingMatchNew> GetCandidatingBindings(StepInstance stepInstance, bool useParamMatching = true)
{
var matches = bindingRegistry.GetConsideredBindings(stepInstance.Text).Select(b => Match(b, stepInstance, useParamMatching: useParamMatching)).Where(b => b.Success);
// we remove duplicate maches for the same method (take the highest scope matches from each)
matches = matches.GroupBy(m => m.StepBinding.Method, (methodInfo, methodMatches) => methodMatches.OrderByDescending(m => m.ScopeMatches).First(), BindingMethodComparer.Instance);
return matches;
}
public StepBindingNew GetBestMatchingBinding(StepInstance stepInstance, out IEnumerable<StepBindingNew> candidatingBindings)
{
candidatingBindings = Enumerable.Empty<StepBindingNew>();
var matches = GetCandidatingBindings(stepInstance, useParamMatching: true).ToList();
if (matches.Count == 0)
{
//HACK: since out param matching does not support agrument converters yet, we rather show more results than "no match"
matches = GetCandidatingBindings(stepInstance, useParamMatching: false).ToList();
}
if (matches.Count > 1)
{
// if there are both scoped and non-scoped matches, we take the ones with the higher degree of scope matches
int maxScopeMatches = matches.Max(m => m.ScopeMatches);
matches.RemoveAll(m => m.ScopeMatches < maxScopeMatches);
}
if (matches.Count == 0)
{
return null;
}
if (matches.Count > 1)
{
candidatingBindings = matches.Select(m => m.StepBinding);
return null;
}
return matches[0].StepBinding;
}
public BindingMatchNew Match(StepBindingNew stepBinding, StepInstance stepInstance, bool useRegexMatching = true, bool useParamMatching = true, bool useScopeMatching = true)
{
if (useParamMatching)
useRegexMatching = true;
Match match = null;
if (useRegexMatching && stepBinding.Regex != null && !(match = stepBinding.Regex.Match(stepInstance.Text)).Success)
return BindingMatchNew.NonMatching;
if (stepBinding.BindingType != stepInstance.BindingType)
return BindingMatchNew.NonMatching;
int scopeMatches = 0;
if (useScopeMatching && stepBinding.IsScoped && stepInstance.StepScope != null && !stepBinding.BindingScope.Match(stepInstance.StepScope, out scopeMatches))
return BindingMatchNew.NonMatching;
if (useParamMatching)
{
Debug.Assert(match != null);
var regexArgs = match.Groups.Cast<Group>().Skip(1).Select(g => g.Value);
var arguments = regexArgs.Cast<object>().AppendIfNotNull(stepInstance.MultilineTextArgument).AppendIfNotNull(stepInstance.TableArgument).ToArray();
// check if the regex + extra arguments match to the binding method parameters
if (arguments.Count() != stepBinding.Method.Parameters.Count())
return BindingMatchNew.NonMatching;
// Check if regex & extra arguments can be converted to the method parameters
if (arguments.Zip(stepBinding.Method.Parameters, (arg, parameter) => CanConvertArg(arg, parameter.Type)).Any(canConvert => !canConvert))
return BindingMatchNew.NonMatching;
}
return new BindingMatchNew(stepBinding, scopeMatches);
}
public void TraceNoMatchingStepDefinition(StepInstance stepInstance, ProgrammingLanguage targetLanguage, List<BindingMatch> matchesWithoutScopeCheck)
{
// string stepDescription = stepFormatter.GetStepDescription(stepArgs);
// return new BindingException(
// string.Format("Multiple step definitions found, but none of them have matching scope for step '{0}': {1}",
// stepDescription,
// string.Join(", ", matches.Select(m => GetMethodText(m.StepBinding.MethodInfo)).ToArray())));
IStepDefinitionSkeletonProvider stepDefinitionSkeletonProvider = stepDefinitionSkeletonProviders[targetLanguage];
StringBuilder message = new StringBuilder();
if (matchesWithoutScopeCheck == null || matchesWithoutScopeCheck.Count == 0)
message.AppendLine("No matching step definition found for the step. Use the following code to create one:");
else
{
string preMessage = string.Format("No matching step definition found for the step. There are matching step definitions, but none of them have matching scope for this step: {0}.",
string.Join(", ", matchesWithoutScopeCheck.Select(m => stepFormatter.GetMatchText(m, null)).ToArray()));
traceListener.WriteToolOutput(preMessage);
message.AppendLine("Change the scope or use the following code to create a new step definition:");
}
message.Append(
stepDefinitionSkeletonProvider.GetBindingClassSkeleton(
stepDefinitionSkeletonProvider.GetStepDefinitionSkeleton(stepInstance))
.Indent(StepDefinitionSkeletonProviderBase.CODEINDENT));
traceListener.WriteToolOutput(message.ToString());
}
public string GetStepText(StepInstance stepInstance)
{
StringBuilder result = new StringBuilder();
if (stepInstance.Keyword != null)
result.Append(stepInstance.Keyword);
else
{
result.Append(LanguageHelper.GetDefaultKeyword(stepInstance.StepContext.Language, stepInstance.StepDefinitionKeyword));
result.Append(" ");
}
result.AppendLine(stepInstance.Text);
if (stepInstance.MultilineTextArgument != null)
{
result.AppendLine("--- multiline step argument ---".Indent(INDENT));
result.AppendLine(stepInstance.MultilineTextArgument.Indent(INDENT));
}
if (stepInstance.TableArgument != null)
{
result.AppendLine("--- table step argument ---".Indent(INDENT));
result.AppendLine(stepInstance.TableArgument.ToString().Indent(INDENT));
}
return result.ToString();
}
public BindingMatch Match(IStepDefinitionBinding stepDefinitionBinding, StepInstance stepInstance, CultureInfo bindingCulture, bool useRegexMatching = true, bool useParamMatching = true, bool useScopeMatching = true)
{
if (useParamMatching)
useRegexMatching = true;
if (stepDefinitionBinding.StepDefinitionType != stepInstance.StepDefinitionType)
return BindingMatch.NonMatching;
Match match = null;
if (useRegexMatching && stepDefinitionBinding.Regex != null && !(match = stepDefinitionBinding.Regex.Match(stepInstance.Text)).Success)
return BindingMatch.NonMatching;
int scopeMatches = 0;
if (useScopeMatching && stepDefinitionBinding.IsScoped && stepInstance.StepContext != null && !stepDefinitionBinding.BindingScope.Match(stepInstance.StepContext, out scopeMatches))
return BindingMatch.NonMatching;
var arguments = match == null ? new object[0] : CalculateArguments(match, stepInstance);
if (useParamMatching)
{
Debug.Assert(match != null); // useParamMatching -> useRegexMatching
var bindingParameters = stepDefinitionBinding.Method.Parameters.ToArray();
// check if the regex + extra arguments match to the binding method parameters
if (arguments.Length != bindingParameters.Length)
return BindingMatch.NonMatching;
// Check if regex & extra arguments can be converted to the method parameters
//if (arguments.Zip(bindingParameters, (arg, parameter) => CanConvertArg(arg, parameter.Type)).Any(canConvert => !canConvert))
if (arguments.Where((arg, argIndex) => !CanConvertArg(arg, bindingParameters[argIndex].Type, bindingCulture)).Any())
return BindingMatch.NonMatching;
}
return new BindingMatch(stepDefinitionBinding, scopeMatches, arguments, stepInstance.StepContext);
}
public override string GetStepDefinitionSkeleton(StepInstance stepArgs)
{
List<string> extraArgs = new List<string>();
if (stepArgs.MultilineTextArgument != null)
extraArgs.Add("string multilineText");
if (stepArgs.TableArgument != null)
extraArgs.Add("Table table");
string stepText = EscapeRegexOutsideQuotes(stepArgs.Text);
string methodName = Regex.Replace(EscapeRegex(stepArgs.Text), QuotesRegex, "").ToIdentifier();
extraArgs.AddRange(ParseArgsFromQuotes(ref stepText)); //Adds values passed in via quotes to the args for the method
StringBuilder result = new StringBuilder();
result.AppendFormat(
@"[{0}(@""{1}"")]
public void {0}{2}({3})
{{
ScenarioContext.Current.Pending();
}}",
stepArgs.BindingType,
stepText,
methodName,
string.Join(", ", extraArgs.ToArray()));
result.AppendLine();
return result.ToString();
}
private static IEnumerable<StepInstance> GetOrderedSteps(StepInstance[] stepInstances)
{
return stepInstances
.Select((si, index) => new { Step = si, Index = index})
.OrderBy(item => item.Step.StepDefinitionType)
.ThenBy(item => item.Index)
.Select(item => item.Step);
}
public Exception GetAmbiguousBecauseParamCheckMatchError(List<BindingMatch> matches, StepInstance stepInstance)
{
string stepDescription = stepFormatter.GetStepDescription(stepInstance);
return new BindingException(
string.Format("Multiple step definitions found, but none of them have matching parameter count and type for step '{0}': {1}",
stepDescription,
string.Join(", ", matches.Select(m => GetMethodText(m.StepBinding.Method)).ToArray())));
}
public Exception GetAmbiguousMatchError(List<BindingMatch> matches, StepInstance stepInstance)
{
string stepDescription = stepFormatter.GetStepDescription(stepInstance);
return new BindingException(
string.Format("Ambiguous step definitions found for step '{0}': {1}",
stepDescription,
string.Join(", ", matches.Select(m => GetMethodText(m.StepBinding.Method)).ToArray())));
}
private IEnumerable <BindingMatch> GetCandidatingBindings(StepInstance stepInstance, bool useParamMatching = true)
{
var matches = bindingRegistry.GetConsideredBindings(stepInstance.Text).Select(b => Match(b, stepInstance, useParamMatching: useParamMatching)).Where(b => b.Success);
// we remove duplicate maches for the same method (take the highest scope matches from each)
matches = matches.GroupBy(m => m.StepBinding.Method, (methodInfo, methodMatches) => methodMatches.OrderByDescending(m => m.ScopeMatches).First(), BindingMethodComparer.Instance);
return(matches);
}
public Exception GetNoMatchBecauseOfScopeFilterError(List<BindingMatch> matches, StepInstance stepInstance)
{
string stepDescription = stepFormatter.GetStepDescription(stepInstance);
return new BindingException(
string.Format("Multiple step definitions found, but none of them have matching scope for step '{0}': {1}",
stepDescription,
string.Join(", ", matches.Select(m => GetMethodText(m.StepBinding.Method)).ToArray())));
}
public AnalyzedStepText Analyze(StepInstance stepInstance, CultureInfo bindingCulture)
{
var result = stepTextAnalyzer.Analyze(stepInstance.Text, bindingCulture);
if (stepInstance.MultilineTextArgument != null)
result.Parameters.Add(new AnalyzedStepParameter("String", "multilineText"));
if (stepInstance.TableArgument != null)
result.Parameters.Add(new AnalyzedStepParameter("Table", "table"));
return result;
}
private object[] CalculateArguments(Match match, StepInstance stepInstance)
{
var regexArgs = match.Groups.Cast<Group>().Skip(1).Select(g => g.Value);
var arguments = regexArgs.Cast<object>().ToList();
if (stepInstance.MultilineTextArgument != null)
arguments.Add(stepInstance.MultilineTextArgument);
if (stepInstance.TableArgument != null)
arguments.Add(stepInstance.TableArgument);
return arguments.ToArray();
}
public override string GetStepDefinitionSkeleton(ProgrammingLanguage language, StepInstance stepInstance, StepDefinitionSkeletonStyle style, CultureInfo bindingCulture)
{
if (getSkeleton != null)
return getSkeleton(stepInstance);
if (usageIndex < stepDefinitionSkeletons.Length)
{
return stepDefinitionSkeletons[usageIndex++];
}
return stepDefinitionSkeletons[stepDefinitionSkeletons.Length - 1];
}
public string GetBindingClassSkeleton(ProgrammingLanguage language, StepInstance[] stepInstances, string namespaceName, string className, StepDefinitionSkeletonStyle style, CultureInfo bindingCulture)
{
var template = templateProvider.GetStepDefinitionClassTemplate(language);
var bindings = string.Join(Environment.NewLine, GetOrderedSteps(stepInstances)
.Select(si => GetStepDefinitionSkeleton(language, si, style, bindingCulture)).Distinct().ToArray()).TrimEnd();
if (bindings.Length > 0)
bindings = bindings.Indent(METHOD_INDENT);
//{namespace}/{className}/{bindings}
return ApplyTemplate(template, new { @namespace = namespaceName, className, bindings});
}
protected string GetStepText(StepInstance stepInstance)
{
string keyword;
if (stepInstance.StepDefinitionKeyword == StepDefinitionKeyword.Given ||
stepInstance.StepDefinitionKeyword == StepDefinitionKeyword.When ||
stepInstance.StepDefinitionKeyword == StepDefinitionKeyword.Then)
keyword = stepInstance.Keyword;
else
keyword = gherkinDialect.GetStepKeywords((StepKeyword) stepInstance.BindingType).FirstOrDefault(k => !k.StartsWith("*")) ?? "";
return keyword + stepInstance.Text;
}
public virtual string GetStepDefinitionSkeleton(ProgrammingLanguage language, StepInstance stepInstance, StepDefinitionSkeletonStyle style, CultureInfo bindingCulture)
{
var withRegex = style == StepDefinitionSkeletonStyle.RegexAttribute;
var template = templateProvider.GetStepDefinitionTemplate(language, withRegex);
var analyzedStepText = Analyze(stepInstance, bindingCulture);
//{attribute}/{regex}/{methodName}/{parameters}
return ApplyTemplate(template, new
{
attribute = stepInstance.StepDefinitionType,
regex = withRegex ? GetRegex(analyzedStepText) : "",
methodName = GetMethodName(stepInstance, analyzedStepText, style, language),
parameters = string.Join(", ", analyzedStepText.Parameters.Select(p => ToDeclaration(language, p)).ToArray())
});
}
private object[] CalculateRecursiveArguments(Match match, StepInstance stepInstance)
{
var regexArgs = match.Groups.Cast<Group>().Skip<Group>(1)
.SelectMany<Group, string>(g =>
g.Captures.Cast<Capture>()
.Select<Capture, string>(c => c.Value)
.ToArray<string>())
.ToArray<string>();
var arguments = regexArgs.Cast<object>().ToList();
if (stepInstance.MultilineTextArgument != null)
arguments.Add(stepInstance.MultilineTextArgument);
if (stepInstance.TableArgument != null)
arguments.Add(stepInstance.TableArgument);
return arguments.ToArray();
}
public void Produces_CSharp_Method_Skeleton_With_Parsed_Doubles()
{
var expected = new StringBuilder();
expected.Append(
@"[Then(@""I can parse a double """"(.*)"""" and another double """"(.*)"""""")]
public void ThenICanParseADoubleAndAnotherDouble(double double1, double double2)
{
ScenarioContext.Current.Pending();
}
");
var stepScope = new StepScopeNew("TestFeature", "TestScenario", null);
var stepInstance = new StepInstance(BindingType.Then, StepDefinitionKeyword.Then, "Then",
"I can parse a double \"3.4\" and another double \"902.302\"", stepScope);
string result = skeletonProviderCS.GetStepDefinitionSkeleton(stepInstance);
Assert.AreEqual(expected.ToString(), result);
}
public BindingMatch Match(StepBinding stepBinding, StepInstance stepInstance, bool useRegexMatching = true, bool useParamMatching = true, bool useScopeMatching = true)
{
if (useParamMatching)
{
useRegexMatching = true;
}
Match match = null;
if (useRegexMatching && stepBinding.Regex != null && !(match = stepBinding.Regex.Match(stepInstance.Text)).Success)
{
return(BindingMatch.NonMatching);
}
if (stepBinding.BindingType != stepInstance.BindingType)
{
return(BindingMatch.NonMatching);
}
int scopeMatches = 0;
if (useScopeMatching && stepBinding.IsScoped && stepInstance.StepScope != null && !stepBinding.BindingScope.Match(stepInstance.StepScope, out scopeMatches))
{
return(BindingMatch.NonMatching);
}
if (useParamMatching)
{
Debug.Assert(match != null);
var regexArgs = match.Groups.Cast <Group>().Skip(1).Select(g => g.Value);
var arguments = regexArgs.Cast <object>().AppendIfNotNull(stepInstance.MultilineTextArgument).AppendIfNotNull(stepInstance.TableArgument).ToArray();
// check if the regex + extra arguments match to the binding method parameters
if (arguments.Count() != stepBinding.Method.Parameters.Count())
{
return(BindingMatch.NonMatching);
}
// Check if regex & extra arguments can be converted to the method parameters
if (arguments.Zip(stepBinding.Method.Parameters, (arg, parameter) => CanConvertArg(arg, parameter.Type)).Any(canConvert => !canConvert))
{
return(BindingMatch.NonMatching);
}
}
return(new BindingMatch(stepBinding, scopeMatches));
}
public void Produces_CSharp_Method_Skeleton()
{
StringBuilder expected = new StringBuilder();
expected.Append(
@"[Given(@""I have a new step"")]
public void GivenIHaveANewStep()
{
ScenarioContext.Current.Pending();
}
");
var stepScope = new StepScopeNew("TestFeature", "TestScenario", null);
StepInstance stepInstance = new StepInstance(BindingType.Given, StepDefinitionKeyword.Given, "Given",
"I have a new step", stepScope);
string result = skeletonProviderCS.GetStepDefinitionSkeleton(stepInstance);
Assert.AreEqual(expected.ToString(), result);
}
public void Produces_CSharp_Method_Skeleton_With_Parsed_Dates()
{
var expected = new StringBuilder();
expected.Append(
@"[When(@""I can parse dates such as """"(.*)"""", """"(.*)"""" and """"(.*)"""""")]
public void WhenICanParseDatesSuchAsAnd(DateTime dateTime1, DateTime dateTime2, DateTime dateTime3)
{
ScenarioContext.Current.Pending();
}
");
var stepScope = new StepScopeNew("TestFeature", "TestScenario", null);
var stepInstance = new StepInstance(BindingType.When, StepDefinitionKeyword.When, "When",
"I can parse dates such as \"20/10/02\", \"12:00\" and \"20.12.09\"", stepScope);
string result = skeletonProviderCS.GetStepDefinitionSkeleton(stepInstance);
Assert.AreEqual(expected.ToString(), result);
}
public void TraceNoMatchingStepDefinition(StepInstance stepInstance, ProgrammingLanguage targetLanguage, CultureInfo bindingCulture, List<BindingMatch> matchesWithoutScopeCheck)
{
StringBuilder message = new StringBuilder();
if (matchesWithoutScopeCheck == null || matchesWithoutScopeCheck.Count == 0)
message.AppendLine("No matching step definition found for the step. Use the following code to create one:");
else
{
string preMessage = string.Format("No matching step definition found for the step. There are matching step definitions, but none of them have matching scope for this step: {0}.",
string.Join(", ", matchesWithoutScopeCheck.Select(m => stepFormatter.GetMatchText(m, null)).ToArray()));
traceListener.WriteToolOutput(preMessage);
message.AppendLine("Change the scope or use the following code to create a new step definition:");
}
message.Append(
stepDefinitionSkeletonProvider.GetStepDefinitionSkeleton(targetLanguage, stepInstance, runtimeConfiguration.StepDefinitionSkeletonStyle, bindingCulture)
.Indent(StepDefinitionSkeletonProvider.METHOD_INDENT));
traceListener.WriteToolOutput(message.ToString());
}
private string GetMethodName(StepInstance stepInstance, AnalyzedStepText analyzedStepText, StepDefinitionSkeletonStyle style, ProgrammingLanguage language)
{
var keyword = LanguageHelper.GetDefaultKeyword(stepInstance.StepContext.Language, stepInstance.StepDefinitionType);
switch (style)
{
case StepDefinitionSkeletonStyle.RegexAttribute:
return keyword.ToIdentifier() + string.Concat(analyzedStepText.TextParts.ToArray()).ToIdentifier();
case StepDefinitionSkeletonStyle.MethodNameUnderscores:
return GetMatchingMethodName(keyword, analyzedStepText, stepInstance.StepContext.Language, AppendWordsUnderscored, "_{0}");
case StepDefinitionSkeletonStyle.MethodNamePascalCase:
return GetMatchingMethodName(keyword, analyzedStepText, stepInstance.StepContext.Language, AppendWordsPascalCase, "_{0}_");
case StepDefinitionSkeletonStyle.MethodNameRegex:
if (language != ProgrammingLanguage.FSharp)
goto case StepDefinitionSkeletonStyle.MethodNameUnderscores;
return "``" + GetRegex(analyzedStepText) + "``";
default:
throw new NotSupportedException();
}
}
public override string GetStepDefinitionSkeleton(StepInstance stepInfo)
{
List<string> extraArgs = new List<string>();
if (stepInfo.MultilineTextArgument != null)
extraArgs.Add("ByVal multilineText As String");
if (stepInfo.TableArgument != null)
extraArgs.Add("ByVal table As Table");
string stepText = EscapeRegexOutsideQuotes(stepInfo.Text);
extraArgs.AddRange(ParseArgsFromQuotes(ref stepText));
//Adds parameters passed in via quotes to the args for the method
string methodName = Regex.Replace(EscapeRegex(stepInfo.Text), QuotesRegex, "").ToIdentifier();
StringBuilder result = new StringBuilder();
// in VB "When" and "Then" are language keywords - use the fully qualified namespace
string namespaceAddition = "TechTalk.SpecFlow.";
if (stepInfo.BindingType == BindingType.Given)
{
namespaceAddition = "";
}
result.AppendFormat(
@"<{4}{0}(""{1}"")> _
Public Sub {0}{2}({3})
{5}ScenarioContext.Current.Pending()
End Sub",
stepInfo.BindingType,
stepText,
methodName,
string.Join(", ", extraArgs.ToArray()),
namespaceAddition,
CODEINDENT
);
result.AppendLine();
return result.ToString();
}
public override string GetStepDefinitionSkeleton(StepInstance stepInstance)
{
List<string> extraArgs = new List<string>();
if (stepInstance.MultilineTextArgument != null)
extraArgs.Add("string multilineText");
if (stepInstance.TableArgument != null)
extraArgs.Add("Table table");
StringBuilder result = new StringBuilder();
result.AppendFormat(@"[{0}(@""{1}"")]
public void {2}({3})
{{
ScenarioContext.Current.Pending();
}}",
stepInstance.BindingType,
EscapeRegex(stepInstance.Text),
GetStepText(stepInstance).ToIdentifier(),
string.Join(", ", extraArgs.ToArray())
);
result.AppendLine();
return result.ToString();
}
public abstract string GetStepDefinitionSkeleton(StepInstance steps);
protected override IEnumerable<BindingMatch> GetCandidatingBindingsForBestMatch(StepInstance stepInstance, CultureInfo bindingCulture)
{
var normalResult = base.GetCandidatingBindingsForBestMatch(stepInstance, bindingCulture).ToList();
if (normalResult.Count > 0)
return normalResult;
return GetCandidatingBindings(stepInstance, bindingCulture, useParamMatching: false); // we disable param checking
}
public string GetStepDescription(StepInstance stepInstance)
{
return string.Format("{0} {1}", stepInstance.StepDefinitionType, stepInstance.Text);
}