public Gherkin Parse(string input)
{
input = input.Replace("\t", string.Empty);
var lines = input.Split(new[] {Environment.NewLine}, StringSplitOptions.RemoveEmptyEntries).Select(ca => ca.ToString()).ToList();
var linesAndTypes = new Dictionary<string, GherkinLineType>();
foreach (var line in lines)
{
var lineType = Gherkin.GetLineType(line);
linesAndTypes.Add(line, lineType);
}
var gherkin = new Gherkin();
var previousType = GherkinLineType.None;
foreach (var lineAndType in linesAndTypes)
{
var currentLine = lineAndType.Key;
var currentType = lineAndType.Value;
if (!(currentType == previousType || currentType == GherkinLineType.None))
{
gherkin.StartNewElement(currentType);
}
gherkin.WriteToCurrentElement(currentLine);
previousType = lineAndType.Value;
}
return gherkin;
}
public void WhenALocalMethodIsCalledWithinTheEntrypoint()
{
Gherkin gherkin = new Gherkin();
// The OnWater will make a local call without the "this." identifier
gherkin.OnWater(new WaterEventArgs());
}
public void TestFluentGherkinMinimalistic()
{
Gherkin
.Given(3)
.When(givenValue => givenValue * 3)
.And(whenResult => whenResult * 3.000)
.Then(stepResult => stepResult == 27.000);
}
public void TestFluentGherkinDouble()
{
Gherkin
.Given("We have 3", 3) //input is Integer
.When("we multiply it by 3", givenValue => givenValue * 3)
.And("we multiply the result by 3", whenResult => whenResult * 3.000)
.Then("the result is 27", stepResult => stepResult == 27.000); //result is Double
}
[InlineData(5, 25)] //expected to fail
public void TestFluentGherkinTheory(int inputValue, int expectedResult)
{
Gherkin
.Given(string.Format("We have {0}", inputValue), inputValue)
.When("we multiply it by 3", givenValue => givenValue * 3)
.And("we multiply the result by 3", whenResult => whenResult * 3)
.Then(string.Format("the result is {0}", expectedResult), stepResult => stepResult == expectedResult);
}
public void TestFluentGherkinSimple()
{
Gherkin
.Given("We have 3", 3)
.When("we multiply it by 3", givenValue => givenValue * 3)
.And("we multiply the result by 3", whenResult => whenResult * 3)
.Then("the result is 27", stepResult => stepResult == 27);
}
public void Passing_through_states_of_a_basic_feature_file_throws_no_exception()
{
var gherkin = new Gherkin();
gherkin.StartNewElement(GherkinLineType.FeatureHeader); // Feature: Example feature
gherkin.StartNewElement(GherkinLineType.None); // As a role
gherkin.StartNewElement(GherkinLineType.None); // I want to do something
gherkin.StartNewElement(GherkinLineType.None); // So that I get some benefit
gherkin.StartNewElement(GherkinLineType.ScenarioHeader); // Scenario: Example 1
gherkin.StartNewElement(GherkinLineType.Given); // Given some precondition
gherkin.StartNewElement(GherkinLineType.When); // When I perform some action
gherkin.StartNewElement(GherkinLineType.Then); // Then I expect some result
}
public void TestBehindTheMagicOfFluency()
{
GherkinStep <int> givenStep = Gherkin.Given("We have 3", 3);
GherkinStep <int> whenStep = givenStep.When("we multiply it by 3", value => value * 3);
GherkinStep <double> andStep = whenStep.And("we multiply the result by 3", value => value * 3.000);
try {
andStep.Then("the result is 27", stepResult => stepResult == 27.000); //result is Double
}
catch (Exception ex) {
throw new Exception("Then condition failed:" + ex.Message);
}
}
public void After_a_feature_header_everything_except_a_scenario_header_or_typeless_line_is_not_valid()
{
var typeBitmask = GherkinLineType.ScenarioHeader | GherkinLineType.None;
var typesToTest = _allLineTypes.Where(type => !typeBitmask.HasFlag(type));
foreach (var type in typesToTest)
{
var gherkin = new Gherkin();
gherkin.StartNewElement(GherkinLineType.FeatureHeader);
TestStartingNewElement(gherkin, type, expectedValid: false);
}
}
public void After_a_Given_element_When_or_Then_or_But_or_a_typeless_line_are_valid()
{
var typeBitmask = GherkinLineType.When | GherkinLineType.Then | GherkinLineType.But | GherkinLineType.None;
var typesToTest = _allLineTypes.Where(type => typeBitmask.HasFlag(type));
foreach (var type in typesToTest)
{
var gherkin = new Gherkin();
gherkin.StartNewElement(GherkinLineType.FeatureHeader);
gherkin.StartNewElement(GherkinLineType.ScenarioHeader);
gherkin.StartNewElement(GherkinLineType.Given);
TestStartingNewElement(gherkin, type, expectedValid: true);
}
}
public void TestFluentGherkinWithMutationalFailure()
{
Random rnd = new Random();
int deviation = rnd.Next(0, 2);
Gherkin
.Given("We have 3", () => 9 - 6)
.And(string.Format("inpuit value was mutated into a deviation of {0} is added", deviation), givenValue => givenValue + deviation)
.When("we multiply it by 3", stepResult => stepResult * 3)
.And("we multiply the result by 3", whenResult => { //multiline step implementation with local variables
int z = whenResult * 3;
return(z);
})
.Then("the result is 27", stepResult => stepResult == 27);
}
public void After_a_scenario_header_everything_except_Given_When_and_Then_are_not_valid()
{
var typeBitmask = GherkinLineType.Given | GherkinLineType.When | GherkinLineType.Then;
var typesToTest = _allLineTypes.Where(type => !typeBitmask.HasFlag(type));
foreach (var type in typesToTest)
{
var gherkin = new Gherkin();
gherkin.StartNewElement(GherkinLineType.FeatureHeader);
gherkin.StartNewElement(GherkinLineType.ScenarioHeader);
TestStartingNewElement(gherkin, type, expectedValid: false);
}
}
private void TestStartingNewElement(Gherkin gherkin, GherkinLineType type, bool expectedValid)
{
try
{
gherkin.StartNewElement(type);
Assert.That(expectedValid, Is.EqualTo(true),
String.Format("No exceptions thrown for state transition to {0} - expected the state transition to be not valid.", type));
}
catch (Exception ex)
{
Assert.That(expectedValid, Is.EqualTo(false),
string.Format("Exception thrown on state transition to {0} - {1}", type, ex.StackTrace));
}
}
public void To_start_a_feature_file_everything_except_a_feature_header_is_not_valid()
{
foreach (var type in _allLineTypes.Where(type => type != GherkinLineType.FeatureHeader))
{
var gherkin = new Gherkin();
TestStartingNewElement(gherkin, type, expectedValid: false);
}
}
private static void CutTheVine(Gherkin gherkin)
{
gherkin.CutVine();
}
private Gherkin.Ast.TableRow Clone(Gherkin.Ast.TableRow row, Func<TableCell, string> getValue = null)
{
var valueExpr = getValue ?? ((c) => c.Value);
return new Gherkin.Ast.TableRow(row.Location, row.Cells.Select(c => new TableCell(c.Location, valueExpr(c))).ToArray());
}
public void WhenALocalMethodIsCalledWithinTheEntrypointExplicitlyOnThis()
{
Gherkin gherkin = new Gherkin();
gherkin.OnPlant(new PlantEventArgs());
}
public static void Harvest(this Gherkin gherkin)
{
new Gardener().HarvestGherkin(gherkin);
}
private static Scenario ConvertToCompatibleScenario(Gherkin.Ast.ScenarioDefinition sd)
{
var convertToCompatibleTags = ConvertToCompatibleTags(sd.GetTags());
var result = sd is global::Gherkin.Ast.ScenarioOutline
? new ScenarioOutline(sd.Keyword, sd.Name, sd.Description, convertToCompatibleTags, ConvertToCompatibleSteps(sd.Steps), ConvertToCompatibleExamples(((global::Gherkin.Ast.ScenarioOutline)sd).Examples))
: new Scenario(sd.Keyword, sd.Name, sd.Description, convertToCompatibleTags, ConvertToCompatibleSteps(sd.Steps));
result.FilePosition = ConvertToCompatibleFilePosition(sd.Location);
return result;
}
private static void PrepareAndCutVine(Gherkin gherkin)
{
CutTheVine(gherkin);
}
