removed IAnd... interfaces & cleaned up the implementation a bit

MehdiK · MehdiK · commit 0404fc18703a · 2014-03-31T17:44:32.000+04:30
diff --git a/TestStack.BDDfy/Scanners/StepScanners/Fluent/FluentScanner.cs b/TestStack.BDDfy/Scanners/StepScanners/Fluent/FluentScanner.cs
@@ -34,7 +34,7 @@ namespace TestStack.BDDfy
     /// }
     /// </code>
     /// </example>
-    internal class FluentScanner<TScenario> : IInitialStep<TScenario>, IAndGiven<TScenario>, IAndWhen<TScenario>, IAndThen<TScenario>
+    internal class FluentScanner<TScenario> : IInitialStep<TScenario>, IGiven<TScenario>, IWhen<TScenario>, IThen<TScenario>
         where TScenario : class
     {
         private readonly List<Step> _steps = new List<Step>();
@@ -85,19 +85,19 @@ IThen<TScenario> IThenSteps<TScenario>.Then(Expression<Func<TScenario, Task>> th
             return this;
         }
 
-        IAndThen<TScenario> IThen<TScenario>.And(Expression<Func<TScenario, Task>> andThenStep, string stepTextTemplate)
+        IThen<TScenario> IThen<TScenario>.And(Expression<Func<TScenario, Task>> andThenStep, string stepTextTemplate)
         {
             AddStep(andThenStep, stepTextTemplate, true, ExecutionOrder.ConsecutiveAssertion);
             return this;
         }
 
-        IAndThen<TScenario> IThen<TScenario>.And(Expression<Func<TScenario, Task>> andThenStep, bool includeInputsInStepTitle)
+        IThen<TScenario> IThen<TScenario>.And(Expression<Func<TScenario, Task>> andThenStep, bool includeInputsInStepTitle)
         {
             AddStep(andThenStep, null, true, ExecutionOrder.ConsecutiveAssertion, includeInputsInStepTitle: includeInputsInStepTitle);
             return this;
         }
 
-        IAndWhen<TScenario> IWhen<TScenario>.And(Expression<Func<TScenario, Task>> andWhenStep, bool includeInputsInStepTitle)
+        IWhen<TScenario> IWhen<TScenario>.And(Expression<Func<TScenario, Task>> andWhenStep, bool includeInputsInStepTitle)
         {
             AddStep(andWhenStep, null, false, ExecutionOrder.ConsecutiveTransition, includeInputsInStepTitle: includeInputsInStepTitle);
             return this;
@@ -109,19 +109,19 @@ IThen<TScenario> IThenSteps<TScenario>.Then(Expression<Func<TScenario, Task>> th
             return this;
         }
 
-        IAndGiven<TScenario> IGiven<TScenario>.And(Expression<Func<TScenario, Task>> andGivenStep, bool includeInputsInStepTitle)
+        IGiven<TScenario> IGiven<TScenario>.And(Expression<Func<TScenario, Task>> andGivenStep, bool includeInputsInStepTitle)
         {
             AddStep(andGivenStep, null, false, ExecutionOrder.ConsecutiveSetupState, includeInputsInStepTitle: includeInputsInStepTitle);
             return this;
         }
 
-        IAndGiven<TScenario> IGiven<TScenario>.And(Expression<Func<TScenario, Task>> andGivenStep, string stepTextTemplate)
+        IGiven<TScenario> IGiven<TScenario>.And(Expression<Func<TScenario, Task>> andGivenStep, string stepTextTemplate)
         {
             AddStep(andGivenStep, stepTextTemplate, false, ExecutionOrder.ConsecutiveSetupState);
             return this;
         }
 
-        IAndWhen<TScenario> IWhen<TScenario>.And(Expression<Func<TScenario, Task>> andWhenStep, string stepTextTemplate)
+        IWhen<TScenario> IWhen<TScenario>.And(Expression<Func<TScenario, Task>> andWhenStep, string stepTextTemplate)
         {
             AddStep(andWhenStep, stepTextTemplate, false, ExecutionOrder.ConsecutiveTransition);
             return this;
@@ -242,7 +242,7 @@ IWhen<TScenario> IWhenSteps<TScenario>.When(Expression<Action<TScenario>> whenSt
             return this;
         }
 
-        IAndGiven<TScenario> IGiven<TScenario>.And(Expression<Action<TScenario>> andGivenStep, bool includeInputsInStepTitle)
+        IGiven<TScenario> IGiven<TScenario>.And(Expression<Action<TScenario>> andGivenStep, bool includeInputsInStepTitle)
         {
             AddStep(andGivenStep, null, false, ExecutionOrder.ConsecutiveSetupState, includeInputsInStepTitle: includeInputsInStepTitle);
             return this;
@@ -254,31 +254,31 @@ IThen<TScenario> IThenSteps<TScenario>.Then(Expression<Action<TScenario>> thenSt
             return this;
         }
 
-        IAndWhen<TScenario> IWhen<TScenario>.And(Expression<Action<TScenario>> andWhenStep, bool includeInputsInStepTitle)
+        IWhen<TScenario> IWhen<TScenario>.And(Expression<Action<TScenario>> andWhenStep, bool includeInputsInStepTitle)
         {
             AddStep(andWhenStep, null, false, ExecutionOrder.ConsecutiveTransition, includeInputsInStepTitle: includeInputsInStepTitle);
             return this;
         }
 
-        IAndGiven<TScenario> IGiven<TScenario>.And(Expression<Action<TScenario>> andGivenStep, string stepTextTemplate)
+        IGiven<TScenario> IGiven<TScenario>.And(Expression<Action<TScenario>> andGivenStep, string stepTextTemplate)
         {
             AddStep(andGivenStep, stepTextTemplate, false, ExecutionOrder.ConsecutiveSetupState);
             return this;
         }
 
-        IAndGiven<TScenario> IGiven<TScenario>.And(Action andGivenStep, string title)
+        IGiven<TScenario> IGiven<TScenario>.And(Action andGivenStep, string title)
         {
             AddStep(andGivenStep, title, false, ExecutionOrder.ConsecutiveSetupState);
             return this;
         }
 
-        IAndGiven<TScenario> IGiven<TScenario>.And(string title)
+        IGiven<TScenario> IGiven<TScenario>.And(string title)
         {
             AddStep(() => {}, title, false, ExecutionOrder.ConsecutiveSetupState);
             return this;
         }
 
-        IAndThen<TScenario> IThen<TScenario>.And(Expression<Action<TScenario>> andThenStep, bool includeInputsInStepTitle)
+        IThen<TScenario> IThen<TScenario>.And(Expression<Action<TScenario>> andThenStep, bool includeInputsInStepTitle)
         {
             AddStep(andThenStep, null, true, ExecutionOrder.ConsecutiveAssertion, includeInputsInStepTitle: includeInputsInStepTitle);
             return this;
@@ -302,37 +302,37 @@ IThen<TScenario> IThenSteps<TScenario>.Then(string title)
             return this;
         }
 
-        IAndWhen<TScenario> IWhen<TScenario>.And(Expression<Action<TScenario>> andWhenStep, string stepTextTemplate)
+        IWhen<TScenario> IWhen<TScenario>.And(Expression<Action<TScenario>> andWhenStep, string stepTextTemplate)
         {
             AddStep(andWhenStep, stepTextTemplate, false, ExecutionOrder.ConsecutiveTransition);
             return this;
         }
 
-        IAndThen<TScenario> IThen<TScenario>.And(Expression<Action<TScenario>> andThenStep, string stepTextTemplate)
+        IThen<TScenario> IThen<TScenario>.And(Expression<Action<TScenario>> andThenStep, string stepTextTemplate)
         {
             AddStep(andThenStep, stepTextTemplate, true, ExecutionOrder.ConsecutiveAssertion);
             return this;
         }
 
-        IAndWhen<TScenario> IWhen<TScenario>.And(Action andWhenStep, string title)
+        IWhen<TScenario> IWhen<TScenario>.And(Action andWhenStep, string title)
         {
             AddStep(andWhenStep, title, false, ExecutionOrder.ConsecutiveTransition);
             return this;
         }
 
-        IAndWhen<TScenario> IWhen<TScenario>.And(string title)
+        IWhen<TScenario> IWhen<TScenario>.And(string title)
         {
             AddStep(() => { }, title, false, ExecutionOrder.ConsecutiveTransition);
             return this;
         }
 
-        IAndThen<TScenario> IThen<TScenario>.And(Action andThenStep, string title)
+        IThen<TScenario> IThen<TScenario>.And(Action andThenStep, string title)
         {
             AddStep(andThenStep, title, true, ExecutionOrder.ConsecutiveAssertion);
             return this;
         }
 
-        IAndThen<TScenario> IThen<TScenario>.And(string title)
+        IThen<TScenario> IThen<TScenario>.And(string title)
         {
             AddStep(() => { }, title, true, ExecutionOrder.ConsecutiveAssertion);
             return this;
diff --git a/TestStack.BDDfy/Scanners/StepScanners/Fluent/IAndGiven.cs b/TestStack.BDDfy/Scanners/StepScanners/Fluent/IAndGiven.cs
diff --git a/TestStack.BDDfy/Scanners/StepScanners/Fluent/IAndThen.cs b/TestStack.BDDfy/Scanners/StepScanners/Fluent/IAndThen.cs
diff --git a/TestStack.BDDfy/Scanners/StepScanners/Fluent/IAndWhen.cs b/TestStack.BDDfy/Scanners/StepScanners/Fluent/IAndWhen.cs
diff --git a/TestStack.BDDfy/Scanners/StepScanners/Fluent/IGiven.cs b/TestStack.BDDfy/Scanners/StepScanners/Fluent/IGiven.cs
@@ -6,11 +6,11 @@ namespace TestStack.BDDfy
 {
     public interface IGiven<TScenario> : IWhenSteps<TScenario>, IThenSteps<TScenario>
     {
-        IAndGiven<TScenario> And(Expression<Action<TScenario>> andGivenStep, bool includeInputsInStepTitle);
-        IAndGiven<TScenario> And(Action andGivenStep, string title);
-        IAndGiven<TScenario> And(string title);
-        IAndGiven<TScenario> And(Expression<Action<TScenario>> andGivenStep, string stepTextTemplate = null);
-        IAndGiven<TScenario> And(Expression<Func<TScenario, Task>> andGivenStep, string stepTextTemplate = null);
-        IAndGiven<TScenario> And(Expression<Func<TScenario, Task>> andGivenStep, bool includeInputsInStepTitle);
+        IGiven<TScenario> And(Expression<Action<TScenario>> andGivenStep, string stepTextTemplate = null);
+        IGiven<TScenario> And(Expression<Action<TScenario>> andGivenStep, bool includeInputsInStepTitle);
+        IGiven<TScenario> And(Expression<Func<TScenario, Task>> andGivenStep, string stepTextTemplate = null);
+        IGiven<TScenario> And(Expression<Func<TScenario, Task>> andGivenStep, bool includeInputsInStepTitle);
+        IGiven<TScenario> And(Action andGivenStep, string title);
+        IGiven<TScenario> And(string title);
     }
 }
diff --git a/TestStack.BDDfy/Scanners/StepScanners/Fluent/IThen.cs b/TestStack.BDDfy/Scanners/StepScanners/Fluent/IThen.cs
@@ -6,11 +6,11 @@ namespace TestStack.BDDfy
 {
     public interface IThen<TScenario> : IStepsBase<TScenario>
     {
-        IAndThen<TScenario> And(Expression<Action<TScenario>> andThenStep, bool includeInputsInStepTitle);
-        IAndThen<TScenario> And(Expression<Action<TScenario>> andThenStep, string stepTextTemplate = null);
-        IAndThen<TScenario> And(Expression<Func<TScenario, Task>> andThenStep, bool includeInputsInStepTitle);
-        IAndThen<TScenario> And(Expression<Func<TScenario, Task>> andThenStep, string stepTextTemplate = null);
-        IAndThen<TScenario> And(Action andThenStep, string title);
-        IAndThen<TScenario> And(string title);
+        IThen<TScenario> And(Expression<Action<TScenario>> andThenStep, string stepTextTemplate = null);
+        IThen<TScenario> And(Expression<Action<TScenario>> andThenStep, bool includeInputsInStepTitle);
+        IThen<TScenario> And(Expression<Func<TScenario, Task>> andThenStep, string stepTextTemplate = null);
+        IThen<TScenario> And(Expression<Func<TScenario, Task>> andThenStep, bool includeInputsInStepTitle);
+        IThen<TScenario> And(Action andThenStep, string title);
+        IThen<TScenario> And(string title);
     }
 }
diff --git a/TestStack.BDDfy/Scanners/StepScanners/Fluent/IThenSteps.cs b/TestStack.BDDfy/Scanners/StepScanners/Fluent/IThenSteps.cs
@@ -6,10 +6,10 @@ namespace TestStack.BDDfy
 {
     public interface IThenSteps<TScenario>
     {
-        IThen<TScenario> Then(Expression<Action<TScenario>> thenStep, bool includeInputsInStepTitle);
         IThen<TScenario> Then(Expression<Action<TScenario>> thenStep, string stepTextTemplate = null);
-        IThen<TScenario> Then(Expression<Func<TScenario, Task>> thenStep, bool includeInputsInStepTitle);
+        IThen<TScenario> Then(Expression<Action<TScenario>> thenStep, bool includeInputsInStepTitle);
         IThen<TScenario> Then(Expression<Func<TScenario, Task>> thenStep, string stepTextTemplate = null);
+        IThen<TScenario> Then(Expression<Func<TScenario, Task>> thenStep, bool includeInputsInStepTitle);
         IThen<TScenario> Then(Action thenStep, string title);
         IThen<TScenario> Then(string title);
     }
diff --git a/TestStack.BDDfy/Scanners/StepScanners/Fluent/IWhen.cs b/TestStack.BDDfy/Scanners/StepScanners/Fluent/IWhen.cs
@@ -6,11 +6,11 @@ namespace TestStack.BDDfy
 {
     public interface IWhen<TScenario> : IStepsBase<TScenario>, IThenSteps<TScenario>
     {
-        IAndWhen<TScenario> And(Expression<Action<TScenario>> andWhenStep, bool includeInputsInStepTitle);
-        IAndWhen<TScenario> And(Expression<Action<TScenario>> andWhenStep, string stepTextTemplate = null);
-        IAndWhen<TScenario> And(Expression<Func<TScenario, Task>> andWhenStep, bool includeInputsInStepTitle);
-        IAndWhen<TScenario> And(Expression<Func<TScenario, Task>> andWhenStep, string stepTextTemplate = null);
-        IAndWhen<TScenario> And(Action andWhenStep, string title);
-        IAndWhen<TScenario> And(string title);
+        IWhen<TScenario> And(Expression<Action<TScenario>> andWhenStep, string stepTextTemplate = null);
+        IWhen<TScenario> And(Expression<Action<TScenario>> andWhenStep, bool includeInputsInStepTitle);
+        IWhen<TScenario> And(Expression<Func<TScenario, Task>> andWhenStep, string stepTextTemplate = null);
+        IWhen<TScenario> And(Expression<Func<TScenario, Task>> andWhenStep, bool includeInputsInStepTitle);
+        IWhen<TScenario> And(Action andWhenStep, string title);
+        IWhen<TScenario> And(string title);
     }
 }
diff --git a/TestStack.BDDfy/TestStack.BDDfy.csproj b/TestStack.BDDfy/TestStack.BDDfy.csproj
@@ -141,9 +141,6 @@
     <Compile Include="Scanners\StepScanners\Fluent\FluentScanner.cs" />
     <Compile Include="Scanners\StepScanners\Fluent\FluentScannerExtensions.cs" />
     <Compile Include="Scanners\ScenarioScanners\FluentScenarioScanner.cs" />
-    <Compile Include="Scanners\StepScanners\Fluent\IAndGiven.cs" />
-    <Compile Include="Scanners\StepScanners\Fluent\IAndThen.cs" />
-    <Compile Include="Scanners\StepScanners\Fluent\IAndWhen.cs" />
     <Compile Include="Scanners\StepScanners\Fluent\IStepsBase.cs" />
     <Compile Include="Scanners\StepScanners\Fluent\IGiven.cs" />
     <Compile Include="Scanners\StepScanners\Fluent\IInitialStep.cs" />

Original file line number	Diff line number	Diff line change
`@@ -34,7 +34,7 @@ namespace TestStack.BDDfy`
`34`	`34`	`/// }`
`35`	`35`	`/// </code>`
`36`	`36`	`/// </example>`
`37`		`- internal class FluentScanner<TScenario> : IInitialStep<TScenario>, IAndGiven<TScenario>, IAndWhen<TScenario>, IAndThen<TScenario>`
	`37`	`+ internal class FluentScanner<TScenario> : IInitialStep<TScenario>, IGiven<TScenario>, IWhen<TScenario>, IThen<TScenario>`
`38`	`38`	`where TScenario : class`
`39`	`39`	`{`
`40`	`40`	`private readonly List<Step> _steps = new List<Step>();`
`@@ -85,19 +85,19 @@ IThen<TScenario> IThenSteps<TScenario>.Then(Expression<Func<TScenario, Task>> th`
`85`	`85`	`return this;`
`86`	`86`	`}`
`87`	`87`
`88`		`- IAndThen<TScenario> IThen<TScenario>.And(Expression<Func<TScenario, Task>> andThenStep, string stepTextTemplate)`
	`88`	`+ IThen<TScenario> IThen<TScenario>.And(Expression<Func<TScenario, Task>> andThenStep, string stepTextTemplate)`
`89`	`89`	`{`
`90`	`90`	`AddStep(andThenStep, stepTextTemplate, true, ExecutionOrder.ConsecutiveAssertion);`
`91`	`91`	`return this;`
`92`	`92`	`}`
`93`	`93`
`94`		`- IAndThen<TScenario> IThen<TScenario>.And(Expression<Func<TScenario, Task>> andThenStep, bool includeInputsInStepTitle)`
	`94`	`+ IThen<TScenario> IThen<TScenario>.And(Expression<Func<TScenario, Task>> andThenStep, bool includeInputsInStepTitle)`
`95`	`95`	`{`
`96`	`96`	`AddStep(andThenStep, null, true, ExecutionOrder.ConsecutiveAssertion, includeInputsInStepTitle: includeInputsInStepTitle);`
`97`	`97`	`return this;`
`98`	`98`	`}`
`99`	`99`
`100`		`- IAndWhen<TScenario> IWhen<TScenario>.And(Expression<Func<TScenario, Task>> andWhenStep, bool includeInputsInStepTitle)`
	`100`	`+ IWhen<TScenario> IWhen<TScenario>.And(Expression<Func<TScenario, Task>> andWhenStep, bool includeInputsInStepTitle)`
`101`	`101`	`{`
`102`	`102`	`AddStep(andWhenStep, null, false, ExecutionOrder.ConsecutiveTransition, includeInputsInStepTitle: includeInputsInStepTitle);`
`103`	`103`	`return this;`
`@@ -109,19 +109,19 @@ IThen<TScenario> IThenSteps<TScenario>.Then(Expression<Func<TScenario, Task>> th`
`109`	`109`	`return this;`
`110`	`110`	`}`
`111`	`111`
`112`		`- IAndGiven<TScenario> IGiven<TScenario>.And(Expression<Func<TScenario, Task>> andGivenStep, bool includeInputsInStepTitle)`
	`112`	`+ IGiven<TScenario> IGiven<TScenario>.And(Expression<Func<TScenario, Task>> andGivenStep, bool includeInputsInStepTitle)`
`113`	`113`	`{`
`114`	`114`	`AddStep(andGivenStep, null, false, ExecutionOrder.ConsecutiveSetupState, includeInputsInStepTitle: includeInputsInStepTitle);`
`115`	`115`	`return this;`
`116`	`116`	`}`
`117`	`117`
`118`		`- IAndGiven<TScenario> IGiven<TScenario>.And(Expression<Func<TScenario, Task>> andGivenStep, string stepTextTemplate)`
	`118`	`+ IGiven<TScenario> IGiven<TScenario>.And(Expression<Func<TScenario, Task>> andGivenStep, string stepTextTemplate)`
`119`	`119`	`{`
`120`	`120`	`AddStep(andGivenStep, stepTextTemplate, false, ExecutionOrder.ConsecutiveSetupState);`
`121`	`121`	`return this;`
`122`	`122`	`}`
`123`	`123`
`124`		`- IAndWhen<TScenario> IWhen<TScenario>.And(Expression<Func<TScenario, Task>> andWhenStep, string stepTextTemplate)`
	`124`	`+ IWhen<TScenario> IWhen<TScenario>.And(Expression<Func<TScenario, Task>> andWhenStep, string stepTextTemplate)`
`125`	`125`	`{`
`126`	`126`	`AddStep(andWhenStep, stepTextTemplate, false, ExecutionOrder.ConsecutiveTransition);`
`127`	`127`	`return this;`
`@@ -242,7 +242,7 @@ IWhen<TScenario> IWhenSteps<TScenario>.When(Expression<Action<TScenario>> whenSt`
`242`	`242`	`return this;`
`243`	`243`	`}`
`244`	`244`
`245`		`- IAndGiven<TScenario> IGiven<TScenario>.And(Expression<Action<TScenario>> andGivenStep, bool includeInputsInStepTitle)`
	`245`	`+ IGiven<TScenario> IGiven<TScenario>.And(Expression<Action<TScenario>> andGivenStep, bool includeInputsInStepTitle)`
`246`	`246`	`{`
`247`	`247`	`AddStep(andGivenStep, null, false, ExecutionOrder.ConsecutiveSetupState, includeInputsInStepTitle: includeInputsInStepTitle);`
`248`	`248`	`return this;`
`@@ -254,31 +254,31 @@ IThen<TScenario> IThenSteps<TScenario>.Then(Expression<Action<TScenario>> thenSt`
`254`	`254`	`return this;`
`255`	`255`	`}`
`256`	`256`
`257`		`- IAndWhen<TScenario> IWhen<TScenario>.And(Expression<Action<TScenario>> andWhenStep, bool includeInputsInStepTitle)`
	`257`	`+ IWhen<TScenario> IWhen<TScenario>.And(Expression<Action<TScenario>> andWhenStep, bool includeInputsInStepTitle)`
`258`	`258`	`{`
`259`	`259`	`AddStep(andWhenStep, null, false, ExecutionOrder.ConsecutiveTransition, includeInputsInStepTitle: includeInputsInStepTitle);`
`260`	`260`	`return this;`
`261`	`261`	`}`
`262`	`262`
`263`		`- IAndGiven<TScenario> IGiven<TScenario>.And(Expression<Action<TScenario>> andGivenStep, string stepTextTemplate)`
	`263`	`+ IGiven<TScenario> IGiven<TScenario>.And(Expression<Action<TScenario>> andGivenStep, string stepTextTemplate)`
`264`	`264`	`{`
`265`	`265`	`AddStep(andGivenStep, stepTextTemplate, false, ExecutionOrder.ConsecutiveSetupState);`
`266`	`266`	`return this;`
`267`	`267`	`}`
`268`	`268`
`269`		`- IAndGiven<TScenario> IGiven<TScenario>.And(Action andGivenStep, string title)`
	`269`	`+ IGiven<TScenario> IGiven<TScenario>.And(Action andGivenStep, string title)`
`270`	`270`	`{`
`271`	`271`	`AddStep(andGivenStep, title, false, ExecutionOrder.ConsecutiveSetupState);`
`272`	`272`	`return this;`
`273`	`273`	`}`
`274`	`274`
`275`		`- IAndGiven<TScenario> IGiven<TScenario>.And(string title)`
	`275`	`+ IGiven<TScenario> IGiven<TScenario>.And(string title)`
`276`	`276`	`{`
`277`	`277`	`AddStep(() => {}, title, false, ExecutionOrder.ConsecutiveSetupState);`
`278`	`278`	`return this;`
`279`	`279`	`}`
`280`	`280`
`281`		`- IAndThen<TScenario> IThen<TScenario>.And(Expression<Action<TScenario>> andThenStep, bool includeInputsInStepTitle)`
	`281`	`+ IThen<TScenario> IThen<TScenario>.And(Expression<Action<TScenario>> andThenStep, bool includeInputsInStepTitle)`
`282`	`282`	`{`
`283`	`283`	`AddStep(andThenStep, null, true, ExecutionOrder.ConsecutiveAssertion, includeInputsInStepTitle: includeInputsInStepTitle);`
`284`	`284`	`return this;`
`@@ -302,37 +302,37 @@ IThen<TScenario> IThenSteps<TScenario>.Then(string title)`
`302`	`302`	`return this;`
`303`	`303`	`}`
`304`	`304`
`305`		`- IAndWhen<TScenario> IWhen<TScenario>.And(Expression<Action<TScenario>> andWhenStep, string stepTextTemplate)`
	`305`	`+ IWhen<TScenario> IWhen<TScenario>.And(Expression<Action<TScenario>> andWhenStep, string stepTextTemplate)`
`306`	`306`	`{`
`307`	`307`	`AddStep(andWhenStep, stepTextTemplate, false, ExecutionOrder.ConsecutiveTransition);`
`308`	`308`	`return this;`
`309`	`309`	`}`
`310`	`310`
`311`		`- IAndThen<TScenario> IThen<TScenario>.And(Expression<Action<TScenario>> andThenStep, string stepTextTemplate)`
	`311`	`+ IThen<TScenario> IThen<TScenario>.And(Expression<Action<TScenario>> andThenStep, string stepTextTemplate)`
`312`	`312`	`{`
`313`	`313`	`AddStep(andThenStep, stepTextTemplate, true, ExecutionOrder.ConsecutiveAssertion);`
`314`	`314`	`return this;`
`315`	`315`	`}`
`316`	`316`
`317`		`- IAndWhen<TScenario> IWhen<TScenario>.And(Action andWhenStep, string title)`
	`317`	`+ IWhen<TScenario> IWhen<TScenario>.And(Action andWhenStep, string title)`
`318`	`318`	`{`
`319`	`319`	`AddStep(andWhenStep, title, false, ExecutionOrder.ConsecutiveTransition);`
`320`	`320`	`return this;`
`321`	`321`	`}`
`322`	`322`
`323`		`- IAndWhen<TScenario> IWhen<TScenario>.And(string title)`
	`323`	`+ IWhen<TScenario> IWhen<TScenario>.And(string title)`
`324`	`324`	`{`
`325`	`325`	`AddStep(() => { }, title, false, ExecutionOrder.ConsecutiveTransition);`
`326`	`326`	`return this;`
`327`	`327`	`}`
`328`	`328`
`329`		`- IAndThen<TScenario> IThen<TScenario>.And(Action andThenStep, string title)`
	`329`	`+ IThen<TScenario> IThen<TScenario>.And(Action andThenStep, string title)`
`330`	`330`	`{`
`331`	`331`	`AddStep(andThenStep, title, true, ExecutionOrder.ConsecutiveAssertion);`
`332`	`332`	`return this;`
`333`	`333`	`}`
`334`	`334`
`335`		`- IAndThen<TScenario> IThen<TScenario>.And(string title)`
	`335`	`+ IThen<TScenario> IThen<TScenario>.And(string title)`
`336`	`336`	`{`
`337`	`337`	`AddStep(() => { }, title, true, ExecutionOrder.ConsecutiveAssertion);`
`338`	`338`	`return this;`
Original file line number	Diff line number	Diff line change
`@@ -6,11 +6,11 @@ namespace TestStack.BDDfy`
`6`	`6`	`{`
`7`	`7`	`public interface IGiven<TScenario> : IWhenSteps<TScenario>, IThenSteps<TScenario>`
`8`	`8`	`{`
`9`		`- IAndGiven<TScenario> And(Expression<Action<TScenario>> andGivenStep, bool includeInputsInStepTitle);`
`10`		`- IAndGiven<TScenario> And(Action andGivenStep, string title);`
`11`		`- IAndGiven<TScenario> And(string title);`
`12`		`- IAndGiven<TScenario> And(Expression<Action<TScenario>> andGivenStep, string stepTextTemplate = null);`
`13`		`- IAndGiven<TScenario> And(Expression<Func<TScenario, Task>> andGivenStep, string stepTextTemplate = null);`
`14`		`- IAndGiven<TScenario> And(Expression<Func<TScenario, Task>> andGivenStep, bool includeInputsInStepTitle);`
	`9`	`+ IGiven<TScenario> And(Expression<Action<TScenario>> andGivenStep, string stepTextTemplate = null);`
	`10`	`+ IGiven<TScenario> And(Expression<Action<TScenario>> andGivenStep, bool includeInputsInStepTitle);`
	`11`	`+ IGiven<TScenario> And(Expression<Func<TScenario, Task>> andGivenStep, string stepTextTemplate = null);`
	`12`	`+ IGiven<TScenario> And(Expression<Func<TScenario, Task>> andGivenStep, bool includeInputsInStepTitle);`
	`13`	`+ IGiven<TScenario> And(Action andGivenStep, string title);`
	`14`	`+ IGiven<TScenario> And(string title);`
`15`	`15`	`}`
`16`	`16`	`}`
Original file line number	Diff line number	Diff line change
`@@ -6,11 +6,11 @@ namespace TestStack.BDDfy`
`6`	`6`	`{`
`7`	`7`	`public interface IThen<TScenario> : IStepsBase<TScenario>`
`8`	`8`	`{`
`9`		`- IAndThen<TScenario> And(Expression<Action<TScenario>> andThenStep, bool includeInputsInStepTitle);`
`10`		`- IAndThen<TScenario> And(Expression<Action<TScenario>> andThenStep, string stepTextTemplate = null);`
`11`		`- IAndThen<TScenario> And(Expression<Func<TScenario, Task>> andThenStep, bool includeInputsInStepTitle);`
`12`		`- IAndThen<TScenario> And(Expression<Func<TScenario, Task>> andThenStep, string stepTextTemplate = null);`
`13`		`- IAndThen<TScenario> And(Action andThenStep, string title);`
`14`		`- IAndThen<TScenario> And(string title);`
	`9`	`+ IThen<TScenario> And(Expression<Action<TScenario>> andThenStep, string stepTextTemplate = null);`
	`10`	`+ IThen<TScenario> And(Expression<Action<TScenario>> andThenStep, bool includeInputsInStepTitle);`
	`11`	`+ IThen<TScenario> And(Expression<Func<TScenario, Task>> andThenStep, string stepTextTemplate = null);`
	`12`	`+ IThen<TScenario> And(Expression<Func<TScenario, Task>> andThenStep, bool includeInputsInStepTitle);`
	`13`	`+ IThen<TScenario> And(Action andThenStep, string title);`
	`14`	`+ IThen<TScenario> And(string title);`
`15`	`15`	`}`
`16`	`16`	`}`
Original file line number	Diff line number	Diff line change
`@@ -6,10 +6,10 @@ namespace TestStack.BDDfy`
`6`	`6`	`{`
`7`	`7`	`public interface IThenSteps<TScenario>`
`8`	`8`	`{`
`9`		`- IThen<TScenario> Then(Expression<Action<TScenario>> thenStep, bool includeInputsInStepTitle);`
`10`	`9`	`IThen<TScenario> Then(Expression<Action<TScenario>> thenStep, string stepTextTemplate = null);`
`11`		`- IThen<TScenario> Then(Expression<Func<TScenario, Task>> thenStep, bool includeInputsInStepTitle);`
	`10`	`+ IThen<TScenario> Then(Expression<Action<TScenario>> thenStep, bool includeInputsInStepTitle);`
`12`	`11`	`IThen<TScenario> Then(Expression<Func<TScenario, Task>> thenStep, string stepTextTemplate = null);`
	`12`	`+ IThen<TScenario> Then(Expression<Func<TScenario, Task>> thenStep, bool includeInputsInStepTitle);`
`13`	`13`	`IThen<TScenario> Then(Action thenStep, string title);`
`14`	`14`	`IThen<TScenario> Then(string title);`
`15`	`15`	`}`
Original file line number	Diff line number	Diff line change
`@@ -6,11 +6,11 @@ namespace TestStack.BDDfy`
`6`	`6`	`{`
`7`	`7`	`public interface IWhen<TScenario> : IStepsBase<TScenario>, IThenSteps<TScenario>`
`8`	`8`	`{`
`9`		`- IAndWhen<TScenario> And(Expression<Action<TScenario>> andWhenStep, bool includeInputsInStepTitle);`
`10`		`- IAndWhen<TScenario> And(Expression<Action<TScenario>> andWhenStep, string stepTextTemplate = null);`
`11`		`- IAndWhen<TScenario> And(Expression<Func<TScenario, Task>> andWhenStep, bool includeInputsInStepTitle);`
`12`		`- IAndWhen<TScenario> And(Expression<Func<TScenario, Task>> andWhenStep, string stepTextTemplate = null);`
`13`		`- IAndWhen<TScenario> And(Action andWhenStep, string title);`
`14`		`- IAndWhen<TScenario> And(string title);`
	`9`	`+ IWhen<TScenario> And(Expression<Action<TScenario>> andWhenStep, string stepTextTemplate = null);`
	`10`	`+ IWhen<TScenario> And(Expression<Action<TScenario>> andWhenStep, bool includeInputsInStepTitle);`
	`11`	`+ IWhen<TScenario> And(Expression<Func<TScenario, Task>> andWhenStep, string stepTextTemplate = null);`
	`12`	`+ IWhen<TScenario> And(Expression<Func<TScenario, Task>> andWhenStep, bool includeInputsInStepTitle);`
	`13`	`+ IWhen<TScenario> And(Action andWhenStep, string title);`
	`14`	`+ IWhen<TScenario> And(string title);`
`15`	`15`	`}`
`16`	`16`	`}`