From 3fd40d39596087cf346958381d263879d6e11cb4 Mon Sep 17 00:00:00 2001 From: ilslv Date: Thu, 14 Oct 2021 15:59:10 +0300 Subject: [PATCH 01/25] Add before and after hooks without propagating errors --- src/cucumber.rs | 79 ++++++++--- src/runner/basic.rs | 333 +++++++++++++++++++++++++++++++++++++------- tests/wait.rs | 19 ++- 3 files changed, 364 insertions(+), 67 deletions(-) diff --git a/src/cucumber.rs b/src/cucumber.rs index c80163bd..c4e401d4 100644 --- a/src/cucumber.rs +++ b/src/cucumber.rs @@ -21,7 +21,7 @@ use std::{ }; use clap::Clap as _; -use futures::StreamExt as _; +use futures::{future::LocalBoxFuture, StreamExt as _}; use regex::Regex; use crate::{ @@ -774,22 +774,9 @@ where I: AsRef, { fn default() -> Self { - let which: runner::basic::WhichScenarioFn = |_, _, scenario| { - scenario - .tags - .iter() - .any(|tag| tag == "serial") - .then(|| ScenarioType::Serial) - .unwrap_or(ScenarioType::Concurrent) - }; - Cucumber::custom() .with_parser(parser::Basic::new()) - .with_runner( - runner::Basic::custom() - .which_scenario(which) - .max_concurrent_scenarios(64), - ) + .with_runner(runner::Basic::default()) .with_writer(writer::Basic::new().normalized().summarized()) } } @@ -840,7 +827,7 @@ impl Cucumber { } } -impl Cucumber, Wr> { +impl Cucumber, Wr> { /// If `max` is [`Some`] number of concurrently executed [`Scenario`]s will /// be limited. /// @@ -864,7 +851,7 @@ impl Cucumber, Wr> { pub fn which_scenario( self, func: Which, - ) -> Cucumber, Wr> + ) -> Cucumber, Wr> where Which: Fn( &gherkin::Feature, @@ -888,6 +875,64 @@ impl Cucumber, Wr> { } } + /// TODO + #[must_use] + pub fn before( + self, + func: Before, + ) -> Cucumber, Wr> + where + Before: for<'a> Fn( + &'a gherkin::Feature, + Option<&'a gherkin::Rule>, + &'a gherkin::Scenario, + &'a mut W, + ) -> LocalBoxFuture<'a, ()>, + { + let Self { + parser, + runner, + writer, + .. + } = self; + Cucumber { + parser, + runner: runner.before(func), + writer, + _world: PhantomData, + _parser_input: PhantomData, + } + } + + /// TODO + #[must_use] + pub fn after( + self, + func: After, + ) -> Cucumber, Wr> + where + After: for<'a> Fn( + &'a gherkin::Feature, + Option<&'a gherkin::Rule>, + &'a gherkin::Scenario, + &'a mut W, + ) -> LocalBoxFuture<'a, ()>, + { + let Self { + parser, + runner, + writer, + .. + } = self; + Cucumber { + parser, + runner: runner.after(func), + writer, + _world: PhantomData, + _parser_input: PhantomData, + } + } + /// Replaces [`Collection`] of [`Step`]s. /// /// [`Collection`]: step::Collection diff --git a/src/runner/basic.rs b/src/runner/basic.rs index 12bb1725..4ac4b11e 100644 --- a/src/runner/basic.rs +++ b/src/runner/basic.rs @@ -24,7 +24,7 @@ use std::{ use futures::{ channel::mpsc, - future::{self, Either}, + future::{self, Either, LocalBoxFuture}, lock::Mutex, pin_mut, stream::{self, LocalBoxStream}, @@ -66,7 +66,12 @@ pub enum ScenarioType { /// /// [1]: Runner#order-guarantees /// [`Scenario`]: gherkin::Scenario -pub struct Basic { +pub struct Basic< + World, + F = WhichScenarioFn, + Before = HookFn, + After = HookFn, +> { /// Optional number of concurrently executed [`Scenario`]s. /// /// [`Scenario`]: gherkin::Scenario @@ -84,6 +89,12 @@ pub struct Basic { /// [`Serial`]: ScenarioType::Serial /// [`Scenario`]: gherkin::Scenario which_scenario: F, + + /// TODO + before_hook: Option, + + /// TODO + after_hook: Option, } /// Alias for [`fn`] used to determine whether a [`Scenario`] is [`Concurrent`] @@ -98,6 +109,19 @@ pub type WhichScenarioFn = fn( &gherkin::Scenario, ) -> ScenarioType; +/// TODO +pub type HookFn = for<'a> fn( + &'a gherkin::Feature, + Option<&'a gherkin::Rule>, + &'a gherkin::Scenario, + &'a mut World, +) -> LocalBoxFuture<'a, ()>; + +enum Hook { + Before, + After, +} + // Implemented manually to omit redundant trait bounds on `World` and to omit // outputting `F`. impl fmt::Debug for Basic { @@ -117,11 +141,34 @@ impl Basic { max_concurrent_scenarios: None, steps: step::Collection::new(), which_scenario: (), + before_hook: None, + after_hook: None, + } + } +} + +impl Default for Basic { + fn default() -> Self { + let which: WhichScenarioFn = |_, _, scenario| { + scenario + .tags + .iter() + .any(|tag| tag == "serial") + .then(|| ScenarioType::Serial) + .unwrap_or(ScenarioType::Concurrent) + }; + + Self { + max_concurrent_scenarios: Some(64), + steps: step::Collection::new(), + which_scenario: which, + before_hook: None, + after_hook: None, } } } -impl Basic { +impl Basic { /// If `max` is [`Some`], then number of concurrently executed [`Scenario`]s /// will be limited. /// @@ -142,9 +189,9 @@ impl Basic { /// [`Serial`]: ScenarioType::Serial /// [`Scenario`]: gherkin::Scenario #[must_use] - pub fn which_scenario(self, func: Which) -> Basic + pub fn which_scenario(self, func: F) -> Basic where - Which: Fn( + F: Fn( &gherkin::Feature, Option<&gherkin::Rule>, &gherkin::Scenario, @@ -154,12 +201,70 @@ impl Basic { let Self { max_concurrent_scenarios, steps, + before_hook, + after_hook, .. } = self; Basic { max_concurrent_scenarios, steps, which_scenario: func, + before_hook, + after_hook, + } + } + + /// TODO + #[must_use] + pub fn before(self, func: Func) -> Basic + where + Func: for<'a> Fn( + &'a gherkin::Feature, + Option<&'a gherkin::Rule>, + &'a gherkin::Scenario, + &'a mut World, + ) -> LocalBoxFuture<'a, ()>, + { + let Self { + max_concurrent_scenarios, + steps, + which_scenario, + after_hook, + .. + } = self; + Basic { + max_concurrent_scenarios, + steps, + which_scenario, + before_hook: Some(func), + after_hook, + } + } + + /// TODO + #[must_use] + pub fn after(self, func: Func) -> Basic + where + Func: for<'a> Fn( + &'a gherkin::Feature, + Option<&'a gherkin::Rule>, + &'a gherkin::Scenario, + &'a mut World, + ) -> LocalBoxFuture<'a, ()>, + { + let Self { + max_concurrent_scenarios, + steps, + which_scenario, + before_hook, + .. + } = self; + Basic { + max_concurrent_scenarios, + steps, + which_scenario, + before_hook, + after_hook: Some(func), } } @@ -200,7 +305,7 @@ impl Basic { } } -impl Runner for Basic +impl Runner for Basic where W: World, Which: Fn( @@ -209,6 +314,20 @@ where &gherkin::Scenario, ) -> ScenarioType + 'static, + Before: 'static + + for<'a> Fn( + &'a gherkin::Feature, + Option<&'a gherkin::Rule>, + &'a gherkin::Scenario, + &'a mut W, + ) -> LocalBoxFuture<'a, ()>, + After: 'static + + for<'a> Fn( + &'a gherkin::Feature, + Option<&'a gherkin::Rule>, + &'a gherkin::Scenario, + &'a mut W, + ) -> LocalBoxFuture<'a, ()>, { type EventStream = LocalBoxStream<'static, parser::Result>>; @@ -221,6 +340,8 @@ where max_concurrent_scenarios, steps, which_scenario, + before_hook, + after_hook, } = self; let buffer = Features::default(); @@ -232,7 +353,14 @@ where which_scenario, sender.clone(), ); - let execute = execute(buffer, max_concurrent_scenarios, steps, sender); + let execute = execute( + buffer, + max_concurrent_scenarios, + steps, + sender, + before_hook, + after_hook, + ); stream::select( receiver.map(Either::Left), @@ -281,12 +409,30 @@ async fn insert_features( /// Retrieves [`Feature`]s and executes them. /// /// [`Feature`]: gherkin::Feature -async fn execute( +async fn execute( features: Features, max_concurrent_scenarios: Option, collection: step::Collection, sender: mpsc::UnboundedSender>>, -) { + before_hook: Option, + after_hook: Option, +) where + W: World, + Before: 'static + + for<'a> Fn( + &'a gherkin::Feature, + Option<&'a gherkin::Rule>, + &'a gherkin::Scenario, + &'a mut W, + ) -> LocalBoxFuture<'a, ()>, + After: 'static + + for<'a> Fn( + &'a gherkin::Feature, + Option<&'a gherkin::Rule>, + &'a gherkin::Scenario, + &'a mut W, + ) -> LocalBoxFuture<'a, ()>, +{ // Those panic hook shenanigans are done to avoid console messages like // "thread 'main' panicked at ..." // @@ -298,7 +444,8 @@ async fn execute( let hook = panic::take_hook(); panic::set_hook(Box::new(|_| {})); - let mut executor = Executor::new(collection, sender); + let mut executor = + Executor::new(collection, before_hook, after_hook, sender); executor.send(event::Cucumber::Started); @@ -334,7 +481,7 @@ async fn execute( /// completion. /// /// [`Feature`]: gherkin::Feature. -struct Executor { +struct Executor { /// Number of finished [`Scenario`]s of [`Feature`]. /// /// [`Feature`]: gherkin::Feature @@ -357,22 +504,48 @@ struct Executor { /// [`Step`]: step::Step collection: step::Collection, + /// TODO + before_hook: Option, + + /// TODO + after_hook: Option, + /// Sender for notifying state of [`Feature`]s completion. /// /// [`Feature`]: gherkin::Feature sender: mpsc::UnboundedSender>>, } -impl Executor { +impl Executor +where + Before: 'static + + for<'a> Fn( + &'a gherkin::Feature, + Option<&'a gherkin::Rule>, + &'a gherkin::Scenario, + &'a mut W, + ) -> LocalBoxFuture<'a, ()>, + After: 'static + + for<'a> Fn( + &'a gherkin::Feature, + Option<&'a gherkin::Rule>, + &'a gherkin::Scenario, + &'a mut W, + ) -> LocalBoxFuture<'a, ()>, +{ /// Creates a new [`Executor`]. fn new( collection: step::Collection, + before_hook: Option, + after_hook: Option, sender: mpsc::UnboundedSender>>, ) -> Self { Self { features_scenarios_count: HashMap::new(), rule_scenarios_count: HashMap::new(), collection, + before_hook, + after_hook, sender, } } @@ -390,29 +563,34 @@ impl Executor { /// [`Scenario`]: gherkin::Scenario async fn run_scenario( &self, - feature: Arc, - rule: Option>, - scenario: Arc, + f: Arc, + r: Option>, + s: Arc, ) { + use event::{ + Cucumber, + Scenario::{Finished, Started}, + }; + let ok = |e: fn(Arc) -> event::Scenario| { - let (f, r, s) = (&feature, &rule, &scenario); + let (f, r, s) = (&f, &r, &s); move |step| { let (f, r, s) = (f.clone(), r.clone(), s.clone()); - event::Cucumber::scenario(f, r, s, e(step)) + Cucumber::scenario(f, r, s, e(step)) } }; let ok_capt = |e: fn(Arc, _) -> event::Scenario| { - let (f, r, s) = (&feature, &rule, &scenario); + let (f, r, s) = (&f, &r, &s); move |step, captures| { let (f, r, s) = (f.clone(), r.clone(), s.clone()); - event::Cucumber::scenario(f, r, s, e(step, captures)) + Cucumber::scenario(f, r, s, e(step, captures)) } }; let err = |e: fn(Arc, _, _, _) -> event::Scenario| { - let (f, r, s) = (&feature, &rule, &scenario); + let (f, r, s) = (&f, &r, &s); move |step, captures, w, info| { let (f, r, s) = (f.clone(), r.clone(), s.clone()); - event::Cucumber::scenario(f, r, s, e(step, captures, w, info)) + Cucumber::scenario(f, r, s, e(step, captures, w, info)) } }; @@ -432,15 +610,14 @@ impl Executor { event::Scenario::step_failed, ); - self.send(event::Cucumber::scenario( - feature.clone(), - rule.clone(), - scenario.clone(), - event::Scenario::Started, - )); + self.send(Cucumber::scenario(f.clone(), r.clone(), s.clone(), Started)); let res = async { - let feature_background = feature + let before_hook = self + .run_hook(Hook::Before, None, &f, r.as_ref(), &s) + .await?; + + let feature_background = f .background .as_ref() .map(|b| b.steps.iter().map(|s| Arc::new(s.clone()))) @@ -449,12 +626,12 @@ impl Executor { let feature_background = stream::iter(feature_background) .map(Ok) - .try_fold(None, |world, bg_step| { + .try_fold(before_hook, |world, bg_step| { self.run_step(world, bg_step, into_bg_step_ev).map_ok(Some) }) .await?; - let rule_background = rule + let rule_background = r .as_ref() .map(|rule| { rule.background @@ -473,36 +650,96 @@ impl Executor { }) .await?; - stream::iter(scenario.steps.iter().map(|s| Arc::new(s.clone()))) - .map(Ok) - .try_fold(rule_background, |world, step| { - self.run_step(world, step, into_step_ev).map_ok(Some) - }) - .await + let steps = + stream::iter(s.steps.iter().map(|s| Arc::new(s.clone()))) + .map(Ok) + .try_fold(rule_background, |world, step| { + self.run_step(world, step, into_step_ev).map_ok(Some) + }) + .await?; + + self.run_hook(Hook::After, steps, &f, r.as_ref(), &s).await }; drop(res.await); - self.send(event::Cucumber::scenario( - feature.clone(), - rule.clone(), - scenario.clone(), - event::Scenario::Finished, + self.send(Cucumber::scenario( + f.clone(), + r.clone(), + s.clone(), + Finished, )); - if let Some(rule) = rule { - if let Some(finished) = - self.rule_scenario_finished(feature.clone(), rule) - { - self.send(finished); + if let Some(rule) = r { + if let Some(fin) = self.rule_scenario_finished(f.clone(), rule) { + self.send(fin); } } - if let Some(finished) = self.feature_scenario_finished(feature) { - self.send(finished); + if let Some(fin) = self.feature_scenario_finished(f) { + self.send(fin); } } + /// TODO + async fn run_hook( + &self, + which: Hook, + world: Option, + feature: &Arc, + rule: Option<&Arc>, + scenario: &Arc, + ) -> Result, ()> { + let init_world = async { + Ok(if let Some(w) = world { + w + } else { + let world_fut = async { + W::new().await.expect("failed to initialize World") + }; + match AssertUnwindSafe(world_fut).catch_unwind().await { + Ok(world) => world, + Err(_info) => return Err(()), + } + }) + }; + + match which { + Hook::Before => { + if let Some(hook) = self.before_hook.as_ref() { + let mut world = init_world.await?; + let fut = (hook)( + feature.as_ref(), + rule.as_ref().map(AsRef::as_ref), + scenario.as_ref(), + &mut world, + ); + match AssertUnwindSafe(fut).catch_unwind().await { + Ok(()) => return Ok(Some(world)), + Err(_info) => return Err(()), + } + } + } + Hook::After => { + if let Some(hook) = self.after_hook.as_ref() { + let mut world = init_world.await?; + let fut = (hook)( + feature.as_ref(), + rule.as_ref().map(AsRef::as_ref), + scenario.as_ref(), + &mut world, + ); + match AssertUnwindSafe(fut).catch_unwind().await { + Ok(()) => return Ok(Some(world)), + Err(_info) => return Err(()), + } + } + } + }; + + Ok(None) + } + /// Runs a [`Step`]. /// /// # Events diff --git a/tests/wait.rs b/tests/wait.rs index c947d7a0..0b697dbb 100644 --- a/tests/wait.rs +++ b/tests/wait.rs @@ -3,11 +3,26 @@ use std::{convert::Infallible, panic::AssertUnwindSafe, time::Duration}; use async_trait::async_trait; use cucumber::{given, then, when, WorldInit}; use futures::FutureExt as _; -use tokio::time; +use tokio::{time, time::sleep}; #[tokio::main] async fn main() { - let res = World::run("tests/features/wait"); + let res = World::cucumber() + .before(|_, _, _, w| { + async move { + w.0 = 0; + sleep(Duration::from_millis(10)).await; + } + .boxed_local() + }) + .after(|_, _, _, w| { + async move { + w.0 = 0; + sleep(Duration::from_millis(10)).await; + } + .boxed_local() + }) + .run_and_exit("tests/features/wait"); let err = AssertUnwindSafe(res) .catch_unwind() From 72ae55240f64c2b6f20642b40bd48d156cd486ef Mon Sep 17 00:00:00 2001 From: ilslv Date: Fri, 15 Oct 2021 12:19:29 +0300 Subject: [PATCH 02/25] Implement hook events --- src/cucumber.rs | 28 +++- src/event.rs | 85 +++++++++- src/runner/basic.rs | 288 +++++++++++++++++++++++----------- src/writer/basic.rs | 39 ++++- src/writer/fail_on_skipped.rs | 4 + src/writer/mod.rs | 4 + src/writer/normalized.rs | 4 + src/writer/repeat.rs | 8 +- src/writer/summarized.rs | 87 ++++++++-- tests/wait.rs | 5 +- 10 files changed, 443 insertions(+), 109 deletions(-) diff --git a/src/cucumber.rs b/src/cucumber.rs index c4e401d4..658ce34e 100644 --- a/src/cucumber.rs +++ b/src/cucumber.rs @@ -875,7 +875,12 @@ impl Cucumber, Wr> { } } - /// TODO + /// Sets hook, executed on every [`Scenario`] before any [`Step`]s, + /// including [`Background`] ones. + /// + /// [`Background`]: gherkin::Background + /// [`Scenario`]: gherkin::Scenario + /// [`Step`]: gherkin::Step #[must_use] pub fn before( self, @@ -904,7 +909,19 @@ impl Cucumber, Wr> { } } - /// TODO + /// Sets hook, executed on every [`Scenario`] after all [`Step`]s. + /// + /// Last `World` argument is supplied to the function, in case it + /// was initialized before by [`before`] hook or any non-failed [`Step`]. + /// In case last [`Scenario`]'s [`Step`] failed, we want to return event + /// with exact `World` state. Also we don't want to impose additional + /// [`Clone`] bounds on `World`, so the only option left is to pass [`None`] + /// to the function. + /// + /// + /// [`before`]: Self::before() + /// [`Scenario`]: gherkin::Scenario + /// [`Step`]: gherkin::Step #[must_use] pub fn after( self, @@ -915,7 +932,7 @@ impl Cucumber, Wr> { &'a gherkin::Feature, Option<&'a gherkin::Rule>, &'a gherkin::Scenario, - &'a mut W, + Option<&'a mut W>, ) -> LocalBoxFuture<'a, ()>, { let Self { @@ -1074,12 +1091,15 @@ where if writer.execution_has_failed() { let failed_steps = writer.failed_steps(); let parsing_errors = writer.parsing_errors(); + let hook_errors = writer.hook_errors(); panic!( - "{} step{} failed, {} parsing error{}", + "{} step{} failed, {} parsing error{}, {} hook error{}", failed_steps, (failed_steps != 1).then(|| "s").unwrap_or_default(), parsing_errors, (parsing_errors != 1).then(|| "s").unwrap_or_default(), + hook_errors, + (hook_errors != 1).then(|| "s").unwrap_or_default(), ); } } diff --git a/src/event.rs b/src/event.rs index 4c32e0e0..22b80530 100644 --- a/src/event.rs +++ b/src/event.rs @@ -19,7 +19,7 @@ //! [`Runner`]: crate::Runner //! [Cucumber]: https://cucumber.io -use std::{any::Any, sync::Arc}; +use std::{any::Any, fmt, sync::Arc}; /// Alias for a [`catch_unwind()`] error. /// @@ -224,6 +224,63 @@ impl Clone for Step { } } +/// Type of the hook, executed before or after all [`Scenario`]'s [`Step`]s. +/// +/// [`Scenario`]: gherkin::Scenario +/// [`Step`]: gherkin::Step +#[derive(Clone, Copy, Debug)] +pub enum HookTy { + /// Hook, executed on every [`Scenario`] before any [`Step`]s. + /// + /// [`Scenario`]: gherkin::Scenario + /// [`Step`]: gherkin::Step + Before, + + /// Hook, executed on every [`Scenario`] after all [`Step`]s. + /// + /// [`Scenario`]: gherkin::Scenario + /// [`Step`]: gherkin::Step + After, +} + +/// [`Before`] or [`After`] hook event. +/// +/// [`After`]: HookTy::After +/// [`Before`]: HookTy::Before +#[derive(Debug)] +pub enum Hook { + /// Hook execution being started. + Started, + + /// Hook passed. + Passed, + + /// Hook failed. + Failed(Option>, Info), +} + +impl fmt::Display for HookTy { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + let s = match self { + HookTy::Before => "Before", + HookTy::After => "After", + }; + write!(f, "{}", s) + } +} + +// Manual implementation is required to omit the redundant `World: Clone` trait +// bound imposed by `#[derive(Clone)]`. +impl Clone for Hook { + fn clone(&self) -> Self { + match self { + Hook::Started => Hook::Started, + Hook::Passed => Hook::Passed, + Hook::Failed(w, i) => Hook::Failed(w.clone(), i.clone()), + } + } +} + /// Event specific to a particular [Scenario]. /// /// [Scenario]: https://cucumber.io/docs/gherkin/reference/#example @@ -234,6 +291,9 @@ pub enum Scenario { /// [`Scenario`]: gherkin::Scenario Started, + /// [`Hook`] event. + Hook(HookTy, Hook), + /// [`Background`] [`Step`] event. /// /// [`Background`]: gherkin::Background @@ -254,6 +314,7 @@ impl Clone for Scenario { fn clone(&self) -> Self { match self { Self::Started => Self::Started, + Self::Hook(ty, ev) => Self::Hook(*ty, ev.clone()), Self::Background(bg, ev) => { Self::Background(bg.clone(), ev.clone()) } @@ -264,6 +325,28 @@ impl Clone for Scenario { } impl Scenario { + /// Constructs an event of a hook being started. + #[must_use] + pub fn hook_started(which: HookTy) -> Self { + Self::Hook(which, Hook::Started) + } + + /// Constructs an event of a passed hook. + #[must_use] + pub fn hook_passed(which: HookTy) -> Self { + Self::Hook(which, Hook::Passed) + } + + /// Constructs an event of a failed hook. + #[must_use] + pub fn hook_failed( + which: HookTy, + world: Option>, + info: Info, + ) -> Self { + Self::Hook(which, Hook::Failed(world, info)) + } + /// Constructs an event of a [`Step`] being started. /// /// [`Step`]: gherkin::Step diff --git a/src/runner/basic.rs b/src/runner/basic.rs index 4ac4b11e..6a372d17 100644 --- a/src/runner/basic.rs +++ b/src/runner/basic.rs @@ -35,7 +35,7 @@ use itertools::Itertools as _; use regex::{CaptureLocations, Regex}; use crate::{ - event::{self, Info}, + event::{self, HookTy, Info}, feature::Ext as _, parser, step, Runner, Step, World, }; @@ -69,8 +69,8 @@ pub enum ScenarioType { pub struct Basic< World, F = WhichScenarioFn, - Before = HookFn, - After = HookFn, + Before = BeforeHookFn, + After = AfterHookFn, > { /// Optional number of concurrently executed [`Scenario`]s. /// @@ -90,10 +90,19 @@ pub struct Basic< /// [`Scenario`]: gherkin::Scenario which_scenario: F, - /// TODO + /// Function, executed on every [`Scenario`] before any [`Step`]s, + /// including [`Background`] ones. + /// + /// [`Background`]: gherkin::Background + /// [`Scenario`]: gherkin::Scenario + /// [`Step`]: gherkin::Step before_hook: Option, - /// TODO + /// Function, executed on every [`Scenario`] after all [`Step`]s. + /// + /// [`Background`]: gherkin::Background + /// [`Scenario`]: gherkin::Scenario + /// [`Step`]: gherkin::Step after_hook: Option, } @@ -109,22 +118,31 @@ pub type WhichScenarioFn = fn( &gherkin::Scenario, ) -> ScenarioType; -/// TODO -pub type HookFn = for<'a> fn( +/// Alias for [`fn`] executed on every [`Scenario`] before any [`Step`]s. +/// +/// [`Scenario`]: gherkin::Scenario +/// [`Step`]: gherkin::Step +pub type BeforeHookFn = for<'a> fn( &'a gherkin::Feature, Option<&'a gherkin::Rule>, &'a gherkin::Scenario, &'a mut World, ) -> LocalBoxFuture<'a, ()>; -enum Hook { - Before, - After, -} +/// Alias for [`fn`] executed on every [`Scenario`] after all [`Step`]s. +/// +/// [`Scenario`]: gherkin::Scenario +/// [`Step`]: gherkin::Step +pub type AfterHookFn = for<'a> fn( + &'a gherkin::Feature, + Option<&'a gherkin::Rule>, + &'a gherkin::Scenario, + Option<&'a mut World>, +) -> LocalBoxFuture<'a, ()>; // Implemented manually to omit redundant trait bounds on `World` and to omit // outputting `F`. -impl fmt::Debug for Basic { +impl fmt::Debug for Basic { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { f.debug_struct("Basic") .field("max_concurrent_scenarios", &self.max_concurrent_scenarios) @@ -214,7 +232,12 @@ impl Basic { } } - /// TODO + /// Sets hook, executed on every [`Scenario`] before any [`Step`]s, + /// including [`Background`] ones. + /// + /// [`Background`]: gherkin::Background + /// [`Scenario`]: gherkin::Scenario + /// [`Step`]: gherkin::Step #[must_use] pub fn before(self, func: Func) -> Basic where @@ -241,7 +264,19 @@ impl Basic { } } - /// TODO + /// Sets hook, executed on every [`Scenario`] after all [`Step`]s. + /// + /// Last `World` argument is supplied to the function, in case it + /// was initialized before by [`before`] hook or any non-failed [`Step`]. + /// In case last [`Scenario`]'s [`Step`] failed, we want to return event + /// with exact `World` state. Also we don't want to impose additional + /// [`Clone`] bounds on `World`, so the only option left is to pass [`None`] + /// to the function. + /// + /// + /// [`before`]: Self::before() + /// [`Scenario`]: gherkin::Scenario + /// [`Step`]: gherkin::Step #[must_use] pub fn after(self, func: Func) -> Basic where @@ -249,7 +284,7 @@ impl Basic { &'a gherkin::Feature, Option<&'a gherkin::Rule>, &'a gherkin::Scenario, - &'a mut World, + Option<&'a mut World>, ) -> LocalBoxFuture<'a, ()>, { let Self { @@ -314,20 +349,20 @@ where &gherkin::Scenario, ) -> ScenarioType + 'static, - Before: 'static - + for<'a> Fn( + Before: for<'a> Fn( &'a gherkin::Feature, Option<&'a gherkin::Rule>, &'a gherkin::Scenario, &'a mut W, - ) -> LocalBoxFuture<'a, ()>, - After: 'static - + for<'a> Fn( + ) -> LocalBoxFuture<'a, ()> + + 'static, + After: for<'a> Fn( &'a gherkin::Feature, Option<&'a gherkin::Rule>, &'a gherkin::Scenario, - &'a mut W, - ) -> LocalBoxFuture<'a, ()>, + Option<&'a mut W>, + ) -> LocalBoxFuture<'a, ()> + + 'static, { type EventStream = LocalBoxStream<'static, parser::Result>>; @@ -430,7 +465,7 @@ async fn execute( &'a gherkin::Feature, Option<&'a gherkin::Rule>, &'a gherkin::Scenario, - &'a mut W, + Option<&'a mut W>, ) -> LocalBoxFuture<'a, ()>, { // Those panic hook shenanigans are done to avoid console messages like @@ -504,10 +539,19 @@ struct Executor { /// [`Step`]: step::Step collection: step::Collection, - /// TODO + /// Function, executed on every [`Scenario`] before any [`Step`]s, + /// including [`Background`] ones. + /// + /// [`Background`]: gherkin::Background + /// [`Scenario`]: gherkin::Scenario + /// [`Step`]: gherkin::Step before_hook: Option, - /// TODO + /// Function, executed on every [`Scenario`] after all [`Step`]s. + /// + /// [`Background`]: gherkin::Background + /// [`Scenario`]: gherkin::Scenario + /// [`Step`]: gherkin::Step after_hook: Option, /// Sender for notifying state of [`Feature`]s completion. @@ -530,7 +574,7 @@ where &'a gherkin::Feature, Option<&'a gherkin::Rule>, &'a gherkin::Scenario, - &'a mut W, + Option<&'a mut W>, ) -> LocalBoxFuture<'a, ()>, { /// Creates a new [`Executor`]. @@ -575,15 +619,13 @@ where let ok = |e: fn(Arc) -> event::Scenario| { let (f, r, s) = (&f, &r, &s); move |step| { - let (f, r, s) = (f.clone(), r.clone(), s.clone()); - Cucumber::scenario(f, r, s, e(step)) + Cucumber::scenario(f.clone(), r.clone(), s.clone(), e(step)) } }; let ok_capt = |e: fn(Arc, _) -> event::Scenario| { let (f, r, s) = (&f, &r, &s); - move |step, captures| { - let (f, r, s) = (f.clone(), r.clone(), s.clone()); - Cucumber::scenario(f, r, s, e(step, captures)) + move |st, cap| { + Cucumber::scenario(f.clone(), r.clone(), s.clone(), e(st, cap)) } }; let err = |e: fn(Arc, _, _, _) -> event::Scenario| { @@ -614,8 +656,9 @@ where let res = async { let before_hook = self - .run_hook(Hook::Before, None, &f, r.as_ref(), &s) - .await?; + .run_before_hook(&f, r.as_ref(), &s) + .await + .map_err(|_| None)?; let feature_background = f .background @@ -650,18 +693,19 @@ where }) .await?; - let steps = - stream::iter(s.steps.iter().map(|s| Arc::new(s.clone()))) - .map(Ok) - .try_fold(rule_background, |world, step| { - self.run_step(world, step, into_step_ev).map_ok(Some) - }) - .await?; + stream::iter(s.steps.iter().map(|s| Arc::new(s.clone()))) + .map(Ok) + .try_fold(rule_background, |world, step| { + self.run_step(world, step, into_step_ev).map_ok(Some) + }) + .await + }; - self.run_hook(Hook::After, steps, &f, r.as_ref(), &s).await + let world = match res.await { + Ok(world) | Err(world) => world, }; - drop(res.await); + drop(self.run_after_hook(world, &f, r.as_ref(), &s).await); self.send(Cucumber::scenario( f.clone(), @@ -681,61 +725,127 @@ where } } - /// TODO - async fn run_hook( + /// Executes [`HookTy::Before`], if present. + async fn run_before_hook( &self, - which: Hook, - world: Option, feature: &Arc, rule: Option<&Arc>, scenario: &Arc, ) -> Result, ()> { let init_world = async { - Ok(if let Some(w) = world { - w - } else { - let world_fut = async { - W::new().await.expect("failed to initialize World") + let world_fut = + async { W::new().await.expect("failed to initialize World") }; + + AssertUnwindSafe(world_fut) + .catch_unwind() + .await + .map_err(|info| (info, None)) + }; + + if let Some(hook) = self.before_hook.as_ref() { + self.send(event::Cucumber::scenario( + feature.clone(), + rule.map(Arc::clone), + scenario.clone(), + event::Scenario::hook_started(HookTy::Before), + )); + + let fut = init_world.and_then(|mut world| async { + let fut = (hook)( + feature.as_ref(), + rule.as_ref().map(AsRef::as_ref), + scenario.as_ref(), + &mut world, + ); + return match AssertUnwindSafe(fut).catch_unwind().await { + Ok(()) => Ok(world), + Err(info) => Err((info, Some(world))), }; - match AssertUnwindSafe(world_fut).catch_unwind().await { - Ok(world) => world, - Err(_info) => return Err(()), + }); + + return match fut.await { + Ok(world) => { + self.send(event::Cucumber::scenario( + feature.clone(), + rule.map(Arc::clone), + scenario.clone(), + event::Scenario::hook_passed(HookTy::Before), + )); + Ok(Some(world)) } - }) - }; + Err((info, world)) => { + self.send(event::Cucumber::scenario( + feature.clone(), + rule.map(Arc::clone), + scenario.clone(), + event::Scenario::hook_failed( + HookTy::Before, + world.map(Arc::new), + info.into(), + ), + )); + Err(()) + } + }; + } + + Ok(None) + } + + /// Executes [`HookTy::After`], if present. + async fn run_after_hook( + &self, + mut world: Option, + feature: &Arc, + rule: Option<&Arc>, + scenario: &Arc, + ) -> Result, ()> { + if let Some(hook) = self.after_hook.as_ref() { + self.send(event::Cucumber::scenario( + feature.clone(), + rule.map(Arc::clone), + scenario.clone(), + event::Scenario::hook_started(HookTy::After), + )); + + let fut = async { + let fut = (hook)( + feature.as_ref(), + rule.as_ref().map(AsRef::as_ref), + scenario.as_ref(), + world.as_mut(), + ); + return match AssertUnwindSafe(fut).catch_unwind().await { + Ok(()) => Ok(world), + Err(info) => Err((info, world)), + }; + }; - match which { - Hook::Before => { - if let Some(hook) = self.before_hook.as_ref() { - let mut world = init_world.await?; - let fut = (hook)( - feature.as_ref(), - rule.as_ref().map(AsRef::as_ref), - scenario.as_ref(), - &mut world, - ); - match AssertUnwindSafe(fut).catch_unwind().await { - Ok(()) => return Ok(Some(world)), - Err(_info) => return Err(()), - } + return match fut.await { + Ok(world) => { + self.send(event::Cucumber::scenario( + feature.clone(), + rule.map(Arc::clone), + scenario.clone(), + event::Scenario::hook_passed(HookTy::After), + )); + Ok(world) } - } - Hook::After => { - if let Some(hook) = self.after_hook.as_ref() { - let mut world = init_world.await?; - let fut = (hook)( - feature.as_ref(), - rule.as_ref().map(AsRef::as_ref), - scenario.as_ref(), - &mut world, - ); - match AssertUnwindSafe(fut).catch_unwind().await { - Ok(()) => return Ok(Some(world)), - Err(_info) => return Err(()), - } + Err((info, world)) => { + self.send(event::Cucumber::scenario( + feature.clone(), + rule.map(Arc::clone), + scenario.clone(), + event::Scenario::hook_failed( + HookTy::After, + world.map(Arc::new), + info.into(), + ), + )); + Err(()) } - } - }; + }; + } Ok(None) } @@ -752,7 +862,7 @@ where mut world: Option, step: Arc, (started, passed, skipped, failed): (St, Ps, Sk, F), - ) -> Result + ) -> Result> where St: FnOnce(Arc) -> event::Cucumber, Ps: FnOnce(Arc, CaptureLocations) -> event::Cucumber, @@ -798,7 +908,7 @@ where } Ok(None) => { self.send(skipped(step)); - Err(()) + Err(world) } Err((err, captures)) => { self.send(failed( @@ -807,7 +917,7 @@ where world.map(Arc::new), Arc::from(err), )); - Err(()) + Err(None) } } } diff --git a/src/writer/basic.rs b/src/writer/basic.rs index 1fd52150..8735e4e6 100644 --- a/src/writer/basic.rs +++ b/src/writer/basic.rs @@ -193,12 +193,22 @@ impl Basic { scenario: &gherkin::Scenario, ev: &event::Scenario, ) { - use event::Scenario; + use event::{Hook, Scenario}; match ev { Scenario::Started => { self.scenario_started(scenario); } + Scenario::Hook(_, Hook::Started) => { + self.indent += 4; + } + Scenario::Hook(which, Hook::Failed(world, info)) => { + self.hook_failed(feat, scenario, *which, world.as_ref(), info); + self.indent = self.indent.saturating_sub(4); + } + Scenario::Hook(_, Hook::Passed) => { + self.indent = self.indent.saturating_sub(4); + } Scenario::Background(bg, ev) => { self.background(feat, bg, ev); } @@ -209,6 +219,33 @@ impl Basic { } } + fn hook_failed( + &mut self, + feat: &gherkin::Feature, + sc: &gherkin::Scenario, + which: event::HookTy, + world: Option<&W>, + info: &Info, + ) { + self.clear_last_lines_if_term_present(); + + self.write_line(&self.styles.err(format!( + "{indent}\u{2718} {} hook failed {}:{}:{}\n\ + {indent} Captured output: {}{}", + which, + feat.path + .as_ref() + .and_then(|p| p.to_str()) + .unwrap_or(&feat.name), + sc.position.line, + sc.position.col, + coerce_error(info), + format_world(world, self.indent.saturating_sub(3) + 3), + indent = " ".repeat(self.indent.saturating_sub(3)), + ))) + .unwrap(); + } + /// Outputs [started] [`Scenario`] to STDOUT. /// /// [started]: event::Scenario::Started diff --git a/src/writer/fail_on_skipped.rs b/src/writer/fail_on_skipped.rs index 6bbcf402..3cbae312 100644 --- a/src/writer/fail_on_skipped.rs +++ b/src/writer/fail_on_skipped.rs @@ -120,6 +120,10 @@ where fn parsing_errors(&self) -> usize { self.writer.parsing_errors() } + + fn hook_errors(&self) -> usize { + self.writer.hook_errors() + } } impl From for FailOnSkipped { diff --git a/src/writer/mod.rs b/src/writer/mod.rs index 4626506a..02bc176d 100644 --- a/src/writer/mod.rs +++ b/src/writer/mod.rs @@ -83,6 +83,10 @@ pub trait Failure: Writer { /// Returns number of parsing errors. #[must_use] fn parsing_errors(&self) -> usize; + + /// Returns number of failed hooks. + #[must_use] + fn hook_errors(&self) -> usize; } /// Extension of [`Writer`] allowing its normalization and summarization. diff --git a/src/writer/normalized.rs b/src/writer/normalized.rs index 1a403245..a7434281 100644 --- a/src/writer/normalized.rs +++ b/src/writer/normalized.rs @@ -134,6 +134,10 @@ where fn parsing_errors(&self) -> usize { self.writer.parsing_errors() } + + fn hook_errors(&self) -> usize { + self.writer.hook_errors() + } } /// Normalization queue for incoming events. diff --git a/src/writer/repeat.rs b/src/writer/repeat.rs index 15e8d850..23b4916a 100644 --- a/src/writer/repeat.rs +++ b/src/writer/repeat.rs @@ -94,6 +94,10 @@ where fn parsing_errors(&self) -> usize { self.writer.parsing_errors() } + + fn hook_errors(&self) -> usize { + self.writer.hook_errors() + } } impl Repeat { @@ -151,7 +155,7 @@ impl Repeat { /// [`Parser`]: crate::Parser #[must_use] pub fn failed(writer: Wr) -> Self { - use event::{Cucumber, Feature, Rule, Scenario, Step}; + use event::{Cucumber, Feature, Hook, Rule, Scenario, Step}; Self { writer, @@ -166,11 +170,13 @@ impl Repeat { _, Scenario::Step(_, Step::Failed(..)) | Scenario::Background(_, Step::Failed(..)) + | Scenario::Hook(_, Hook::Failed(..)) ) ) | Feature::Scenario( _, Scenario::Step(_, Step::Failed(..)) | Scenario::Background(_, Step::Failed(..)) + | Scenario::Hook(_, Hook::Failed(..)) ) )) | Err(_) ) diff --git a/src/writer/summarized.rs b/src/writer/summarized.rs index 6f383610..9f1621e7 100644 --- a/src/writer/summarized.rs +++ b/src/writer/summarized.rs @@ -10,7 +10,7 @@ //! [`Writer`]-wrapper for collecting a summary of execution. -use std::{array, borrow::Cow, collections::HashSet, sync::Arc}; +use std::{array, borrow::Cow, collections::HashMap, sync::Arc}; use async_trait::async_trait; use derive_more::Deref; @@ -96,10 +96,13 @@ pub struct Summarized { /// [`Parser`]: crate::Parser pub parsing_errors: usize, + /// Number of failed hooks. + pub failed_hooks: usize, + /// Handled [`Scenario`]s to collect [`Stats`]. /// /// [`Scenario`]: gherkin::Scenario - handled_scenarios: HashSet>, + handled_scenarios: HashMap, FailedOrSkipped>, } /// Alias for [`fn`] used to determine should [`Skipped`] test considered as @@ -110,6 +113,26 @@ pub struct Summarized { pub type SkipFn = fn(&gherkin::Feature, Option<&gherkin::Rule>, &gherkin::Scenario) -> bool; +/// [`Failed`] or [`Skipped`] [`Scenario`]s. +/// +/// [`Failed`]: event::Step::Failed +/// [`Scenario`]: gherkin::Scenario +/// [`Skipped`]: event::Step::Skipped +#[derive(Clone, Copy, Debug)] +enum FailedOrSkipped { + /// [`Failed`] [`Scenario`]. + /// + /// [`Failed`]: event::Step::Failed + /// [`Scenario`]: gherkin::Scenario + Failed, + + /// [`Skipped`] [`Scenario`]. + /// + /// [`Scenario`]: gherkin::Scenario + /// [`Skipped`]: event::Step::Skipped + Skipped, +} + #[async_trait(?Send)] impl Writer for Summarized where @@ -173,6 +196,10 @@ where fn parsing_errors(&self) -> usize { self.parsing_errors } + + fn hook_errors(&self) -> usize { + self.failed_hooks + } } impl From for Summarized { @@ -192,7 +219,8 @@ impl From for Summarized { failed: 0, }, parsing_errors: 0, - handled_scenarios: HashSet::new(), + failed_hooks: 0, + handled_scenarios: HashMap::new(), } } } @@ -206,7 +234,10 @@ impl Summarized { scenario: &Arc, ev: &event::Step, ) { - use event::Step; + use self::{ + event::Step, + FailedOrSkipped::{Failed, Skipped}, + }; match ev { Step::Started => {} @@ -214,12 +245,13 @@ impl Summarized { Step::Skipped => { self.steps.skipped += 1; self.scenarios.skipped += 1; - let _ = self.handled_scenarios.insert(scenario.clone()); + let _ = + self.handled_scenarios.insert(scenario.clone(), Skipped); } Step::Failed(..) => { self.steps.failed += 1; self.scenarios.failed += 1; - let _ = self.handled_scenarios.insert(scenario.clone()); + let _ = self.handled_scenarios.insert(scenario.clone(), Failed); } } } @@ -232,15 +264,38 @@ impl Summarized { scenario: &Arc, ev: &event::Scenario, ) { - use event::Scenario; + use event::{Hook, Scenario}; match ev { - Scenario::Started => {} + Scenario::Started + | Scenario::Hook(_, Hook::Passed | Hook::Started) => {} + Scenario::Hook(_, Hook::Failed(..)) => { + // - If Scenario's last Step failed and then After Hook failed + // too, we don't need to track second failure; + // - If Scenario's last Step was skipped and then After Hook + // failed, we need to override skipped Scenario with failed; + // - If Scenario executed no Steps and then Hook failed, we + // track Scenario as failed. + match self.handled_scenarios.get(scenario) { + Some(FailedOrSkipped::Failed) => {} + Some(FailedOrSkipped::Skipped) => { + self.scenarios.skipped -= 1; + self.scenarios.failed += 1; + } + None => { + self.scenarios.failed += 1; + let _ = self + .handled_scenarios + .insert(scenario.clone(), FailedOrSkipped::Failed); + } + } + self.failed_hooks += 1; + } Scenario::Background(_, ev) | Scenario::Step(_, ev) => { self.handle_step(scenario, ev); } Scenario::Finished => { - if !self.handled_scenarios.remove(scenario) { + if self.handled_scenarios.remove(scenario).is_none() { self.scenarios.passed += 1; } } @@ -281,8 +336,18 @@ impl Styles { }) .unwrap_or_default(); + let hook_errors = (summary.failed_hooks > 0) + .then(|| { + self.err(self.maybe_plural("hook error", summary.failed_hooks)) + }) + .unwrap_or_default(); + + let comma = (!parsing_errors.is_empty() && !hook_errors.is_empty()) + .then(|| self.err(",")) + .unwrap_or_default(); + format!( - "{}\n{}\n{}{}{}\n{}{}\n{}", + "{}\n{}\n{}{}{}\n{}{}\n{}{} {}", self.bold(self.header("[Summary]")), features, rules, @@ -291,6 +356,8 @@ impl Styles { steps, steps_stats, parsing_errors, + comma, + hook_errors ) .trim_end_matches('\n') .to_string() diff --git a/tests/wait.rs b/tests/wait.rs index 0b697dbb..4a505cfb 100644 --- a/tests/wait.rs +++ b/tests/wait.rs @@ -15,9 +15,8 @@ async fn main() { } .boxed_local() }) - .after(|_, _, _, w| { + .after(|_, _, _, _| { async move { - w.0 = 0; sleep(Duration::from_millis(10)).await; } .boxed_local() @@ -30,7 +29,7 @@ async fn main() { .expect_err("should err"); let err = err.downcast_ref::().unwrap(); - assert_eq!(err, "2 steps failed, 1 parsing error"); + assert_eq!(err, "2 steps failed, 1 parsing error, 0 hook errors"); } #[given(regex = r"(\d+) secs?")] From b740341238885bc52b4551e0af19a3fbb942e6cd Mon Sep 17 00:00:00 2001 From: ilslv Date: Fri, 15 Oct 2021 13:03:51 +0300 Subject: [PATCH 03/25] Mention hooks in Features book chapter --- book/src/Features.md | 76 ++++++++++++++++++++++++++++++++++++++++++++ tests/wait.rs | 6 ++-- 2 files changed, 79 insertions(+), 3 deletions(-) diff --git a/book/src/Features.md b/book/src/Features.md index 8f6f5c9e..3b221dfe 100644 --- a/book/src/Features.md +++ b/book/src/Features.md @@ -41,6 +41,8 @@ Occasionally you’ll find yourself repeating the same `Given` steps in all the Since it's repeated in every scenario, this is an indication that those steps are not essential to describe the scenarios, so they are _incidental details_. You can literally move such `Given` steps to background, by grouping them under a `Background` section. +A `Background` allows you to add some context to the scenarios that follow it. It can contain one or more steps, which are run before each scenario, but after any [`Before` hooks](#before-hook). + ```gherkin Feature: Animal feature @@ -304,5 +306,79 @@ In case most of your `.feature` files aren't written in English and you want to +## Scenario hooks + +### Before hook + +`Before` hooks run before the first step of each scenario, even [Background](#background-keyword) ones. + +```rust +# use std::{convert::Infallible, time::Duration}; +# +# use async_trait::async_trait; +# use cucumber::WorldInit; +# use futures::FutureExt as _; +# use tokio::time::sleep; +# +# #[derive(Debug, WorldInit)] +# struct World; +# +# #[async_trait(?Send)] +# impl cucumber::World for World { +# type Error = Infallible; +# +# async fn new() -> Result { +# Ok(World) +# } +# } +# +# fn main() { +World::cucumber() + .before(|_feature, _rule, _scenario, _world| { + sleep(Duration::from_millis(10)).boxed_local() + }) + .run_and_exit("tests/features/book"); +# } +``` + +> #### Think twice before you use `Before` +> Whatever happens in a `Before` hook is invisible to people who only read the features. You should consider using a [Background](#background-keyword) as a more explicit alternative, especially if the setup should be readable by non-technical people. Only use a `Before` hook for low-level logic such as starting a browser or deleting data from a database. + +### After hook + +`After` hooks run after the last step of each scenario, even when the step result is `failed` or `skipped`. + +```rust +# use std::{convert::Infallible, time::Duration}; +# +# use async_trait::async_trait; +# use cucumber::WorldInit; +# use futures::FutureExt as _; +# use tokio::time::sleep; +# +# #[derive(Debug, WorldInit)] +# struct World; +# +# #[async_trait(?Send)] +# impl cucumber::World for World { +# type Error = Infallible; +# +# async fn new() -> Result { +# Ok(World) +# } +# } +# +# fn main() { +World::cucumber() + .after(|_feature, _rule, _scenario, _world| { + sleep(Duration::from_millis(10)).boxed_local() + }) + .run_and_exit("tests/features/book"); +# } +``` + + + + [Cucumber]: https://cucumber.io [Gherkin]: https://cucumber.io/docs/gherkin diff --git a/tests/wait.rs b/tests/wait.rs index 4a505cfb..113d9271 100644 --- a/tests/wait.rs +++ b/tests/wait.rs @@ -3,7 +3,7 @@ use std::{convert::Infallible, panic::AssertUnwindSafe, time::Duration}; use async_trait::async_trait; use cucumber::{given, then, when, WorldInit}; use futures::FutureExt as _; -use tokio::{time, time::sleep}; +use tokio::time; #[tokio::main] async fn main() { @@ -11,13 +11,13 @@ async fn main() { .before(|_, _, _, w| { async move { w.0 = 0; - sleep(Duration::from_millis(10)).await; + time::sleep(Duration::from_millis(10)).await; } .boxed_local() }) .after(|_, _, _, _| { async move { - sleep(Duration::from_millis(10)).await; + time::sleep(Duration::from_millis(10)).await; } .boxed_local() }) From c49280b4ce107f61130fda8356dac3fa7bd1b01e Mon Sep 17 00:00:00 2001 From: ilslv Date: Fri, 15 Oct 2021 13:41:11 +0300 Subject: [PATCH 04/25] Corrections --- src/cucumber.rs | 5 ++++- src/event.rs | 12 +++++++++--- src/runner/basic.rs | 5 ++++- src/writer/basic.rs | 2 +- src/writer/mod.rs | 4 +++- src/writer/summarized.rs | 4 +++- tests/wait.rs | 5 +---- 7 files changed, 25 insertions(+), 12 deletions(-) diff --git a/src/cucumber.rs b/src/cucumber.rs index 658ce34e..06d26ee7 100644 --- a/src/cucumber.rs +++ b/src/cucumber.rs @@ -909,7 +909,8 @@ impl Cucumber, Wr> { } } - /// Sets hook, executed on every [`Scenario`] after all [`Step`]s. + /// Sets hook, executed on every [`Scenario`] after all [`Step`]s even after + /// [`Skipped`] of [`Failed`] [`Step`]s. /// /// Last `World` argument is supplied to the function, in case it /// was initialized before by [`before`] hook or any non-failed [`Step`]. @@ -920,7 +921,9 @@ impl Cucumber, Wr> { /// /// /// [`before`]: Self::before() + /// [`Failed`]: event::Step::Failed /// [`Scenario`]: gherkin::Scenario + /// [`Skipped`]: event::Step::Skipped /// [`Step`]: gherkin::Step #[must_use] pub fn after( diff --git a/src/event.rs b/src/event.rs index 22b80530..40717e36 100644 --- a/src/event.rs +++ b/src/event.rs @@ -325,19 +325,25 @@ impl Clone for Scenario { } impl Scenario { - /// Constructs an event of a hook being started. + /// Constructs an event of a [`Scenario`] hook being started. + /// + /// [`Scenario`]: gherkin::Scenario #[must_use] pub fn hook_started(which: HookTy) -> Self { Self::Hook(which, Hook::Started) } - /// Constructs an event of a passed hook. + /// Constructs an event of a passed [`Scenario`] hook. + /// + /// [`Scenario`]: gherkin::Scenario #[must_use] pub fn hook_passed(which: HookTy) -> Self { Self::Hook(which, Hook::Passed) } - /// Constructs an event of a failed hook. + /// Constructs an event of a failed [`Scenario`] hook. + /// + /// [`Scenario`]: gherkin::Scenario #[must_use] pub fn hook_failed( which: HookTy, diff --git a/src/runner/basic.rs b/src/runner/basic.rs index 6a372d17..a9dc67d0 100644 --- a/src/runner/basic.rs +++ b/src/runner/basic.rs @@ -264,7 +264,8 @@ impl Basic { } } - /// Sets hook, executed on every [`Scenario`] after all [`Step`]s. + /// Sets hook, executed on every [`Scenario`] after all [`Step`]s even after + /// [`Skipped`] of [`Failed`] [`Step`]s. /// /// Last `World` argument is supplied to the function, in case it /// was initialized before by [`before`] hook or any non-failed [`Step`]. @@ -275,7 +276,9 @@ impl Basic { /// /// /// [`before`]: Self::before() + /// [`Failed`]: event::Step::Failed /// [`Scenario`]: gherkin::Scenario + /// [`Skipped`]: event::Step::Skipped /// [`Step`]: gherkin::Step #[must_use] pub fn after(self, func: Func) -> Basic diff --git a/src/writer/basic.rs b/src/writer/basic.rs index 8735e4e6..b44230ca 100644 --- a/src/writer/basic.rs +++ b/src/writer/basic.rs @@ -230,7 +230,7 @@ impl Basic { self.clear_last_lines_if_term_present(); self.write_line(&self.styles.err(format!( - "{indent}\u{2718} {} hook failed {}:{}:{}\n\ + "{indent}\u{2718} {} Scenario hook failed {}:{}:{}\n\ {indent} Captured output: {}{}", which, feat.path diff --git a/src/writer/mod.rs b/src/writer/mod.rs index 02bc176d..1b708cef 100644 --- a/src/writer/mod.rs +++ b/src/writer/mod.rs @@ -84,7 +84,9 @@ pub trait Failure: Writer { #[must_use] fn parsing_errors(&self) -> usize; - /// Returns number of failed hooks. + /// Returns number of failed [`Scenario`] hooks. + /// + /// [`Scenario`]: gherkin::Scenario #[must_use] fn hook_errors(&self) -> usize; } diff --git a/src/writer/summarized.rs b/src/writer/summarized.rs index 9f1621e7..77da0149 100644 --- a/src/writer/summarized.rs +++ b/src/writer/summarized.rs @@ -96,7 +96,9 @@ pub struct Summarized { /// [`Parser`]: crate::Parser pub parsing_errors: usize, - /// Number of failed hooks. + /// Number of failed [`Scenario`] hooks. + /// + /// [`Scenario`]: gherkin::Scenario pub failed_hooks: usize, /// Handled [`Scenario`]s to collect [`Stats`]. diff --git a/tests/wait.rs b/tests/wait.rs index 113d9271..08c6a79c 100644 --- a/tests/wait.rs +++ b/tests/wait.rs @@ -16,10 +16,7 @@ async fn main() { .boxed_local() }) .after(|_, _, _, _| { - async move { - time::sleep(Duration::from_millis(10)).await; - } - .boxed_local() + time::sleep(Duration::from_millis(10)).boxed_local() }) .run_and_exit("tests/features/wait"); From 192bace492b87e1aba96e6a901940afbedf15030 Mon Sep 17 00:00:00 2001 From: ilslv Date: Fri, 15 Oct 2021 14:49:25 +0300 Subject: [PATCH 05/25] CHANGELOG --- CHANGELOG.md | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 36c50d4c..e4f4313b 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -22,7 +22,7 @@ All user visible changes to `cucumber` crate will be documented in this file. Th - Made test callbacks first argument `&mut World` instead of `World`. ([#128]) - Made `#[step]` argument of step functions `Step` instead of `StepContext` again, while test callbacks still receive `StepContext` as a second parameter. ([#128]) - Deprecated `--nocapture` and `--debug` CLI options to be completely redesigned in `0.11` release. ([#137]) -- [Hooks](https://cucumber.io/docs/cucumber/api/#hooks) were removed, but are planned to be re-implemented with some changes in `0.11` release. ([#128]) +- [Hooks](https://cucumber.io/docs/cucumber/api/#hooks) now accept `&mut World` as a last parameter ([#142]) ### Added @@ -32,6 +32,7 @@ All user visible changes to `cucumber` crate will be documented in this file. Th [#128]: /../../pull/128 [#136]: /../../pull/136 [#137]: /../../pull/137 +[#142]: /../../pull/142 From 3582127b7c3e3cc8a1099884377553286a4caeb9 Mon Sep 17 00:00:00 2001 From: ilslv Date: Mon, 18 Oct 2021 09:20:39 +0300 Subject: [PATCH 06/25] WIP [skip ci] --- Cargo.toml | 4 +- codegen/src/attribute.rs | 6 + codegen/src/derive.rs | 13 +- src/cli.rs | 3 +- src/codegen.rs | 40 ++++-- src/cucumber.rs | 29 ++++- src/event.rs | 33 +++++ src/runner/basic.rs | 77 ++++++++--- src/step.rs | 123 ++++++++++++++---- src/writer/basic.rs | 42 ++++++ src/writer/summarized.rs | 2 +- tests/features/output/ambiguous_step.feature | 3 + .../output/ambiguous_step.feature.out | 8 ++ tests/output.rs | 3 + 14 files changed, 311 insertions(+), 75 deletions(-) create mode 100644 tests/features/output/ambiguous_step.feature create mode 100644 tests/features/output/ambiguous_step.feature.out diff --git a/Cargo.toml b/Cargo.toml index a1b6f681..0f7d8716 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -31,9 +31,9 @@ macros = ["cucumber-codegen", "inventory"] [dependencies] async-trait = "0.1.40" atty = "0.2.14" -clap = "3.0.0-beta.4" +clap = "=3.0.0-beta.5" console = "0.14.1" -derive_more = { version = "0.99.16", features = ["deref", "display", "error", "from"], default_features = false } +derive_more = { version = "0.99.16", features = ["deref", "deref_mut", "display", "error", "from"], default_features = false } either = "1.6" futures = "0.3.17" gherkin = { package = "gherkin_rust", version = "0.10" } diff --git a/codegen/src/attribute.rs b/codegen/src/attribute.rs index 397624b4..fd2889d6 100644 --- a/codegen/src/attribute.rs +++ b/codegen/src/attribute.rs @@ -101,6 +101,7 @@ impl Step { } /// Expands generated code of this [`Step`] definition. + #[allow(clippy::too_many_lines)] fn expand(self) -> syn::Result { let is_regex = matches!(self.attr_arg, AttributeArgument::Regex(_)); @@ -206,6 +207,11 @@ impl Step { ::cucumber::codegen::Regex::new(#step_matcher) .unwrap(), #step_caller, + Some(::cucumber::step::Location { + path: ::std::convert::From::from(::std::file!()), + line: ::std::line!(), + column: ::std::column!(), + }), ) } ); diff --git a/codegen/src/derive.rs b/codegen/src/derive.rs index b32e1281..f9f53c2c 100644 --- a/codegen/src/derive.rs +++ b/codegen/src/derive.rs @@ -65,6 +65,9 @@ fn generate_step_structs( #[doc(hidden)] pub func: ::cucumber::Step<#world>, + + #[doc(hidden)] + pub loc: ::std::option::Option<::cucumber::step::Location>, } #[automatically_derived] @@ -72,15 +75,21 @@ fn generate_step_structs( fn new ( regex: ::cucumber::codegen::Regex, func: ::cucumber::Step<#world>, + loc: ::std::option::Option<::cucumber::step::Location>, ) -> Self { - Self { regex, func } + Self { regex, func, loc } } fn inner(&self) -> ( ::cucumber::codegen::Regex, ::cucumber::Step<#world>, + ::std::option::Option<::cucumber::step::Location>, ) { - (self.regex.clone(), self.func.clone()) + ( + self.regex.clone(), + self.func.clone(), + self.loc.clone(), + ) } } diff --git a/src/cli.rs b/src/cli.rs index 5e604181..79640e04 100644 --- a/src/cli.rs +++ b/src/cli.rs @@ -10,7 +10,6 @@ //! CLI options. -use clap::Clap; use regex::Regex; /// Run the tests, pet a dog!. @@ -20,7 +19,7 @@ use regex::Regex; /// [cucumber-rs/cucumber#134][1]. /// /// [1]: https://github.com/cucumber-rs/cucumber/issues/134 -#[derive(Clap, Debug)] +#[derive(Debug, clap::Parser)] pub struct Opts { /// Regex to select scenarios from. #[clap(short = 'e', long = "expression", name = "regex")] diff --git a/src/codegen.rs b/src/codegen.rs index 3dcb78db..808abe39 100644 --- a/src/codegen.rs +++ b/src/codegen.rs @@ -41,18 +41,18 @@ where let mut out = step::Collection::new(); for given in Self::cucumber_given() { - let (regex, fun) = given.inner(); - out = out.given(regex, fun); + let (regex, fun, loc) = given.inner(); + out = out.given(regex, fun, loc); } for when in Self::cucumber_when() { - let (regex, fun) = when.inner(); - out = out.when(regex, fun); + let (regex, fun, loc) = when.inner(); + out = out.when(regex, fun, loc); } for then in Self::cucumber_then() { - let (regex, fun) = then.inner(); - out = out.then(regex, fun); + let (regex, fun, loc) = then.inner(); + out = out.then(regex, fun, loc); } out @@ -143,8 +143,12 @@ where /// /// [`given`]: crate::given /// [Given]: https://cucumber.io/docs/gherkin/reference/#given - fn new_given(regex: Regex, fun: Step) -> G { - G::new(regex, fun) + fn new_given( + regex: Regex, + fun: Step, + loc: Option, + ) -> G { + G::new(regex, fun, loc) } /// Returns an [`Iterator`] over items with [`when`] attribute. @@ -159,8 +163,12 @@ where /// /// [`when`]: crate::when /// [When]: https://cucumber.io/docs/gherkin/reference/#when - fn new_when(regex: Regex, fun: Step) -> W { - W::new(regex, fun) + fn new_when( + regex: Regex, + fun: Step, + loc: Option, + ) -> W { + W::new(regex, fun, loc) } /// Returns an [`Iterator`] over items with [`then`] attribute. @@ -175,8 +183,12 @@ where /// /// [`then`]: crate::then /// [Then]: https://cucumber.io/docs/gherkin/reference/#then - fn new_then(regex: Regex, fun: Step) -> T { - T::new(regex, fun) + fn new_then( + regex: Regex, + fun: Step, + loc: Option, + ) -> T { + T::new(regex, fun, loc) } } @@ -190,8 +202,8 @@ where pub trait StepConstructor { /// Creates a new [`Step`] with the corresponding [`Regex`]. #[must_use] - fn new(_: Regex, _: Step) -> Self; + fn new(_: Regex, _: Step, _: Option) -> Self; /// Returns an inner [`Step`] with the corresponding [`Regex`]. - fn inner(&self) -> (Regex, Step); + fn inner(&self) -> (Regex, Step, Option); } diff --git a/src/cucumber.rs b/src/cucumber.rs index 06d26ee7..fb98a30b 100644 --- a/src/cucumber.rs +++ b/src/cucumber.rs @@ -20,7 +20,7 @@ use std::{ path::Path, }; -use clap::Clap as _; +use clap::Parser as _; use futures::{future::LocalBoxFuture, StreamExt as _}; use regex::Regex; @@ -967,8 +967,13 @@ impl Cucumber, Wr> { /// /// [Given]: https://cucumber.io/docs/gherkin/reference/#given #[must_use] - pub fn given(mut self, regex: Regex, step: Step) -> Self { - self.runner = self.runner.given(regex, step); + pub fn given( + mut self, + regex: Regex, + step: Step, + loc: Option, + ) -> Self { + self.runner = self.runner.given(regex, step, loc); self } @@ -976,8 +981,13 @@ impl Cucumber, Wr> { /// /// [When]: https://cucumber.io/docs/gherkin/reference/#When #[must_use] - pub fn when(mut self, regex: Regex, step: Step) -> Self { - self.runner = self.runner.when(regex, step); + pub fn when( + mut self, + regex: Regex, + step: Step, + loc: Option, + ) -> Self { + self.runner = self.runner.when(regex, step, loc); self } @@ -985,8 +995,13 @@ impl Cucumber, Wr> { /// /// [Then]: https://cucumber.io/docs/gherkin/reference/#then #[must_use] - pub fn then(mut self, regex: Regex, step: Step) -> Self { - self.runner = self.runner.then(regex, step); + pub fn then( + mut self, + regex: Regex, + step: Step, + loc: Option, + ) -> Self { + self.runner = self.runner.then(regex, step, loc); self } } diff --git a/src/event.rs b/src/event.rs index 40717e36..31c20263 100644 --- a/src/event.rs +++ b/src/event.rs @@ -21,6 +21,8 @@ use std::{any::Any, fmt, sync::Arc}; +use crate::step; + /// Alias for a [`catch_unwind()`] error. /// /// [`catch_unwind()`]: std::panic::catch_unwind() @@ -188,6 +190,9 @@ pub enum Step { /// [`Step`]: gherkin::Step Started, + /// TODO + AmbiguousMatch(step::AmbiguousMatchError), + /// [`Step`] being skipped. /// /// That means there is no [`Regex`] matching [`Step`] in a @@ -215,6 +220,7 @@ impl Clone for Step { fn clone(&self) -> Self { match self { Self::Started => Self::Started, + Self::AmbiguousMatch(e) => Self::AmbiguousMatch(e.clone()), Self::Skipped => Self::Skipped, Self::Passed(captures) => Self::Passed(captures.clone()), Self::Failed(captures, w, info) => { @@ -361,6 +367,33 @@ impl Scenario { Self::Step(step, Step::Started) } + /// Constructs an event of a [`Step`] being matched to more than 1 + /// [`Regex`]. + /// + /// [`Regex`]: regex::Regex + /// [`Step`]: gherkin::Step + #[must_use] + pub fn ambiguous_step( + step: Arc, + err: step::AmbiguousMatchError, + ) -> Self { + Self::Step(step, Step::AmbiguousMatch(err)) + } + + /// Constructs an event of a [`Background`] [`Step`] being matched to more + /// than 1 [`Regex`]. + /// + /// [`Background`]: gherkin::Background + /// [`Regex`]: regex::Regex + /// [`Step`]: gherkin::Step + #[must_use] + pub fn background_ambiguous_step( + step: Arc, + err: step::AmbiguousMatchError, + ) -> Self { + Self::Background(step, Step::AmbiguousMatch(err)) + } + /// Constructs an event of a [`Background`] [`Step`] being started. /// /// [`Background`]: gherkin::Background diff --git a/src/runner/basic.rs b/src/runner/basic.rs index a9dc67d0..5dd3cd99 100644 --- a/src/runner/basic.rs +++ b/src/runner/basic.rs @@ -319,8 +319,13 @@ impl Basic { /// /// [Given]: https://cucumber.io/docs/gherkin/reference/#given #[must_use] - pub fn given(mut self, regex: Regex, step: Step) -> Self { - self.steps = mem::take(&mut self.steps).given(regex, step); + pub fn given( + mut self, + regex: Regex, + step: Step, + loc: Option, + ) -> Self { + self.steps = mem::take(&mut self.steps).given(regex, step, loc); self } @@ -328,8 +333,13 @@ impl Basic { /// /// [When]: https://cucumber.io/docs/gherkin/reference/#given #[must_use] - pub fn when(mut self, regex: Regex, step: Step) -> Self { - self.steps = mem::take(&mut self.steps).when(regex, step); + pub fn when( + mut self, + regex: Regex, + step: Step, + loc: Option, + ) -> Self { + self.steps = mem::take(&mut self.steps).when(regex, step, loc); self } @@ -337,8 +347,13 @@ impl Basic { /// /// [Then]: https://cucumber.io/docs/gherkin/reference/#then #[must_use] - pub fn then(mut self, regex: Regex, step: Step) -> Self { - self.steps = mem::take(&mut self.steps).then(regex, step); + pub fn then( + mut self, + regex: Regex, + step: Step, + loc: Option, + ) -> Self { + self.steps = mem::take(&mut self.steps).then(regex, step, loc); self } } @@ -631,28 +646,43 @@ where Cucumber::scenario(f.clone(), r.clone(), s.clone(), e(st, cap)) } }; - let err = |e: fn(Arc, _, _, _) -> event::Scenario| { + let panic_err = + |e: fn(Arc, _, _, _) -> event::Scenario| { + let (f, r, s) = (&f, &r, &s); + move |step, captures, w, info| { + let (f, r, s) = (f.clone(), r.clone(), s.clone()); + Cucumber::scenario(f, r, s, e(step, captures, w, info)) + } + }; + let amb_err = |e: fn(Arc, _) -> event::Scenario| { let (f, r, s) = (&f, &r, &s); - move |step, captures, w, info| { - let (f, r, s) = (f.clone(), r.clone(), s.clone()); - Cucumber::scenario(f, r, s, e(step, captures, w, info)) + move |st, err| { + Cucumber::scenario(f.clone(), r.clone(), s.clone(), e(st, err)) } }; - let compose = |started, passed, skipped, failed| { - (ok(started), ok_capt(passed), ok(skipped), err(failed)) + let compose = |started, passed, skipped, failed, amb| { + ( + ok(started), + ok_capt(passed), + ok(skipped), + panic_err(failed), + amb_err(amb), + ) }; let into_bg_step_ev = compose( event::Scenario::background_step_started, event::Scenario::background_step_passed, event::Scenario::background_step_skipped, event::Scenario::background_step_failed, + event::Scenario::background_ambiguous_step, ); let into_step_ev = compose( event::Scenario::step_started, event::Scenario::step_passed, event::Scenario::step_skipped, event::Scenario::step_failed, + event::Scenario::ambiguous_step, ); self.send(Cucumber::scenario(f.clone(), r.clone(), s.clone(), Started)); @@ -860,11 +890,11 @@ where /// - Emits all [`Step`] events. /// /// [`Step`]: gherkin::Step - async fn run_step( + async fn run_step( &self, mut world: Option, step: Arc, - (started, passed, skipped, failed): (St, Ps, Sk, F), + (started, passed, skipped, failed, ambiguous): (St, Ps, Sk, F, A), ) -> Result> where St: FnOnce(Arc) -> event::Cucumber, @@ -876,6 +906,10 @@ where Option>, Info, ) -> event::Cucumber, + A: FnOnce( + Arc, + step::AmbiguousMatchError, + ) -> event::Cucumber, { self.send(started(step.clone())); @@ -886,13 +920,17 @@ where }; world = match AssertUnwindSafe(w_fut).catch_unwind().await { Ok(w) => Some(w), - Err(e) => return Err((e, None)), + Err(e) => return Err(Some((e, None))), }; } let (step_fn, captures, ctx) = match self.collection.find(&step) { - Some(step_fn) => step_fn, - None => return Ok(None), + Ok(Some(step_fn)) => step_fn, + Ok(None) => return Ok(None), + Err(e) => { + self.send(ambiguous(step.clone(), e)); + return Err(None); + } }; match AssertUnwindSafe(step_fn(world.as_mut().unwrap(), ctx)) @@ -900,7 +938,7 @@ where .await { Ok(()) => Ok(Some(captures)), - Err(e) => Err((e, Some(captures))), + Err(e) => Err(Some((e, Some(captures)))), } }; @@ -913,7 +951,7 @@ where self.send(skipped(step)); Err(world) } - Err((err, captures)) => { + Err(Some((err, captures))) => { self.send(failed( step, captures, @@ -922,6 +960,7 @@ where )); Err(None) } + Err(None) => Err(None), } } diff --git a/src/step.rs b/src/step.rs index 9a8a7c8c..8a47de31 100644 --- a/src/step.rs +++ b/src/step.rs @@ -14,13 +14,15 @@ //! [`Step`]: gherkin::Step use std::{ - collections::HashMap, + cmp::Ordering, + collections::{BTreeMap, HashMap}, fmt, hash::{Hash, Hasher}, iter, - ops::Deref, + path::PathBuf, }; +use derive_more::{Deref, DerefMut}; use futures::future::LocalBoxFuture; use gherkin::StepType; use regex::Regex; @@ -29,15 +31,32 @@ use regex::Regex; pub type Step = for<'a> fn(&'a mut World, Context) -> LocalBoxFuture<'a, ()>; +/// TODO +pub type FindValue<'me, World> = + (&'me Step, regex::CaptureLocations, Context); + /// Collection of [`Step`]s. /// /// Every [`Step`] should be matched by exactly 1 [`Regex`]. Otherwise there are /// no guarantees that [`Step`]s will be matched deterministically from run to /// run. pub struct Collection { - given: HashMap>, - when: HashMap>, - then: HashMap>, + given: BTreeMap<(HashableRegex, Option), Step>, + when: BTreeMap<(HashableRegex, Option), Step>, + then: BTreeMap<(HashableRegex, Option), Step>, +} + +/// TODO +#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)] +pub struct Location { + /// TODO + pub path: PathBuf, + + /// TODO + pub line: u32, + + /// TODO + pub column: u32, } impl fmt::Debug for Collection { @@ -74,9 +93,9 @@ impl fmt::Debug for Collection { impl Default for Collection { fn default() -> Self { Self { - given: HashMap::new(), - when: HashMap::new(), - then: HashMap::new(), + given: BTreeMap::new(), + when: BTreeMap::new(), + then: BTreeMap::new(), } } } @@ -92,8 +111,13 @@ impl Collection { /// /// [Given]: https://cucumber.io/docs/gherkin/reference/#given #[must_use] - pub fn given(mut self, regex: Regex, step: Step) -> Self { - let _ = self.given.insert(regex.into(), step); + pub fn given( + mut self, + regex: Regex, + step: Step, + loc: Option, + ) -> Self { + let _ = self.given.insert((regex.into(), loc), step); self } @@ -101,8 +125,13 @@ impl Collection { /// /// [When]: https://cucumber.io/docs/gherkin/reference/#when #[must_use] - pub fn when(mut self, regex: Regex, step: Step) -> Self { - let _ = self.when.insert(regex.into(), step); + pub fn when( + mut self, + regex: Regex, + step: Step, + loc: Option, + ) -> Self { + let _ = self.when.insert((regex.into(), loc), step); self } @@ -110,30 +139,57 @@ impl Collection { /// /// [Then]: https://cucumber.io/docs/gherkin/reference/#then #[must_use] - pub fn then(mut self, regex: Regex, step: Step) -> Self { - let _ = self.then.insert(regex.into(), step); + pub fn then( + mut self, + regex: Regex, + step: Step, + loc: Option, + ) -> Self { + let _ = self.then.insert((regex.into(), loc), step); self } /// Returns a [`Step`] function matching the given [`gherkin::Step`], /// if any. - #[must_use] + /// + /// # Errors pub fn find( &self, step: &gherkin::Step, - ) -> Option<(&Step, regex::CaptureLocations, Context)> { + ) -> Result>, AmbiguousMatchError> { let collection = match step.ty { StepType::Given => &self.given, StepType::When => &self.when, StepType::Then => &self.then, }; - let (whole_match, captures, step_fn) = - collection.iter().find_map(|(re, step_fn)| { + let mut matches = collection + .iter() + .filter_map(|((re, loc), step_fn)| { let mut captures = re.capture_locations(); re.captures_read(&mut captures, &step.value) - .map(|m| (m, captures, step_fn)) - })?; + .map(|m| (re, loc, m, captures, step_fn)) + }) + .collect::>(); + + let (_, _, whole_match, captures, step_fn) = match matches.len() { + 0 => return Ok(None), + 1 => { + if let Some(m) = matches.pop() { + m + } else { + unreachable!() + } + } + _ => { + return Err(AmbiguousMatchError { + possible_matches: matches + .into_iter() + .map(|(re, pos, ..)| (re.clone(), pos.clone())) + .collect(), + }) + } + }; let matches = iter::once(whole_match.as_str().to_owned()) .chain((1..captures.len()).map(|group_id| { @@ -144,17 +200,24 @@ impl Collection { })) .collect(); - Some(( + Ok(Some(( step_fn, captures, Context { step: step.clone(), matches, }, - )) + ))) } } +/// TODO +#[derive(Clone, Debug)] +pub struct AmbiguousMatchError { + /// TODO + pub possible_matches: Vec<(HashableRegex, Option)>, +} + /// Context for a [`Step`] function execution. #[derive(Debug)] pub struct Context { @@ -170,8 +233,8 @@ pub struct Context { } /// [`Regex`] wrapper to store inside a [`LinkedHashMap`]. -#[derive(Clone, Debug)] -struct HashableRegex(Regex); +#[derive(Clone, Debug, Deref, DerefMut)] +pub struct HashableRegex(Regex); impl From for HashableRegex { fn from(re: Regex) -> Self { @@ -193,10 +256,14 @@ impl PartialEq for HashableRegex { impl Eq for HashableRegex {} -impl Deref for HashableRegex { - type Target = Regex; +impl PartialOrd for HashableRegex { + fn partial_cmp(&self, other: &Self) -> Option { + self.0.as_str().partial_cmp(other.0.as_str()) + } +} - fn deref(&self) -> &Regex { - &self.0 +impl Ord for HashableRegex { + fn cmp(&self, other: &Self) -> Ordering { + self.0.as_str().cmp(other.0.as_str()) } } diff --git a/src/writer/basic.rs b/src/writer/basic.rs index b44230ca..db9b80a1 100644 --- a/src/writer/basic.rs +++ b/src/writer/basic.rs @@ -25,6 +25,7 @@ use regex::CaptureLocations; use crate::{ event::{self, Info}, parser, + step::AmbiguousMatchError, writer::term::Styles, ArbitraryWriter, World, Writer, }; @@ -281,6 +282,10 @@ impl Basic { Step::Started => { self.step_started(step); } + Step::AmbiguousMatch(e) => { + self.step_ambiguous_match(feat, step, e); + self.indent = self.indent.saturating_sub(4); + } Step::Passed(captures) => { self.step_passed(step, captures); self.indent = self.indent.saturating_sub(4); @@ -443,6 +448,40 @@ impl Basic { .unwrap(); } + /// TODO + fn step_ambiguous_match( + &mut self, + feat: &gherkin::Feature, + step: &gherkin::Step, + err: &AmbiguousMatchError, + ) { + self.clear_last_lines_if_term_present(); + + self.write_line(&self.styles.err(format!( + "{indent}\u{2718} {} {}{}\n\ + {indent} Step match is ambiguous: {}:{}:{}\n\ + {indent} Possible matches: {:?}", + step.keyword, + step.value, + step.table + .as_ref() + .map(|t| format_table(t, self.indent)) + .unwrap_or_default(), + feat.path + .as_ref() + .and_then(|p| p.to_str()) + .unwrap_or(&feat.name), + step.position.line, + step.position.col, + err.possible_matches + .iter() + .map(|(re, loc)| (re.as_str(), loc)) + .collect::>(), + indent = " ".repeat(self.indent.saturating_sub(3)) + ))) + .unwrap(); + } + /// Outputs [`Background`] [`Step`] [started]/[passed]/[skipped]/[failed] /// event to STDOUT. /// @@ -464,6 +503,9 @@ impl Basic { Step::Started => { self.bg_step_started(bg); } + Step::AmbiguousMatch(_e) => { + // TODO + } Step::Passed(captures) => { self.bg_step_passed(bg, captures); self.indent = self.indent.saturating_sub(4); diff --git a/src/writer/summarized.rs b/src/writer/summarized.rs index 77da0149..205eea9a 100644 --- a/src/writer/summarized.rs +++ b/src/writer/summarized.rs @@ -250,7 +250,7 @@ impl Summarized { let _ = self.handled_scenarios.insert(scenario.clone(), Skipped); } - Step::Failed(..) => { + Step::Failed(..) | Step::AmbiguousMatch(..) => { self.steps.failed += 1; self.scenarios.failed += 1; let _ = self.handled_scenarios.insert(scenario.clone(), Failed); diff --git a/tests/features/output/ambiguous_step.feature b/tests/features/output/ambiguous_step.feature new file mode 100644 index 00000000..a1c674cd --- /dev/null +++ b/tests/features/output/ambiguous_step.feature @@ -0,0 +1,3 @@ +Feature: ambiguous + Scenario: ambiguous + Given foo is 0 ambiguous diff --git a/tests/features/output/ambiguous_step.feature.out b/tests/features/output/ambiguous_step.feature.out new file mode 100644 index 00000000..27bc5cec --- /dev/null +++ b/tests/features/output/ambiguous_step.feature.out @@ -0,0 +1,8 @@ +Started +Feature(Feature { keyword: "Feature", name: "ambiguous", description: None, background: None, scenarios: [Scenario { keyword: "Scenario", name: "ambiguous", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Started) +Feature(Feature { keyword: "Feature", name: "ambiguous", description: None, background: None, scenarios: [Scenario { keyword: "Scenario", name: "ambiguous", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Scenario(Scenario { keyword: "Scenario", name: "ambiguous", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }, Started)) +Feature(Feature { keyword: "Feature", name: "ambiguous", description: None, background: None, scenarios: [Scenario { keyword: "Scenario", name: "ambiguous", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Scenario(Scenario { keyword: "Scenario", name: "ambiguous", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }, Step(Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }, Started))) +Feature(Feature { keyword: "Feature", name: "ambiguous", description: None, background: None, scenarios: [Scenario { keyword: "Scenario", name: "ambiguous", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Scenario(Scenario { keyword: "Scenario", name: "ambiguous", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }, Step(Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }, AmbiguousMatch(AmbiguousMatchError { possible_matches: [(HashableRegex(foo is (\d+)), Some(Location { path: "tests/output.rs", line: 10, column: 1 })), (HashableRegex(foo is (\d+) ambiguous), Some(Location { path: "tests/output.rs", line: 18, column: 1 }))] })))) +Feature(Feature { keyword: "Feature", name: "ambiguous", description: None, background: None, scenarios: [Scenario { keyword: "Scenario", name: "ambiguous", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Scenario(Scenario { keyword: "Scenario", name: "ambiguous", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }, Finished)) +Feature(Feature { keyword: "Feature", name: "ambiguous", description: None, background: None, scenarios: [Scenario { keyword: "Scenario", name: "ambiguous", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Finished) +Finished diff --git a/tests/output.rs b/tests/output.rs index 65b8f11e..c43c2ebb 100644 --- a/tests/output.rs +++ b/tests/output.rs @@ -15,6 +15,9 @@ fn step(w: &mut World, num: usize) { w.0 += 1; } +#[given(regex = r"foo is (\d+) ambiguous")] +fn ambiguous(_w: &mut World) {} + #[async_trait(?Send)] impl cucumber::World for World { type Error = Infallible; From eff31e5a82939195a9afac5023c9824c9ae0a980 Mon Sep 17 00:00:00 2001 From: ilslv Date: Mon, 18 Oct 2021 10:50:42 +0300 Subject: [PATCH 07/25] Corrections --- CHANGELOG.md | 3 +- codegen/src/attribute.rs | 131 +++++++++++++++++++++------------------ codegen/src/derive.rs | 14 ++--- src/codegen.rs | 28 ++++----- src/cucumber.rs | 12 ++-- src/event.rs | 5 +- src/runner/basic.rs | 86 +++++++++++-------------- src/step.rs | 25 ++++---- src/writer/basic.rs | 72 +++++++++++++++++---- src/writer/summarized.rs | 2 - 10 files changed, 212 insertions(+), 166 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 36c50d4c..e4f4313b 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -22,7 +22,7 @@ All user visible changes to `cucumber` crate will be documented in this file. Th - Made test callbacks first argument `&mut World` instead of `World`. ([#128]) - Made `#[step]` argument of step functions `Step` instead of `StepContext` again, while test callbacks still receive `StepContext` as a second parameter. ([#128]) - Deprecated `--nocapture` and `--debug` CLI options to be completely redesigned in `0.11` release. ([#137]) -- [Hooks](https://cucumber.io/docs/cucumber/api/#hooks) were removed, but are planned to be re-implemented with some changes in `0.11` release. ([#128]) +- [Hooks](https://cucumber.io/docs/cucumber/api/#hooks) now accept `&mut World` as a last parameter ([#142]) ### Added @@ -32,6 +32,7 @@ All user visible changes to `cucumber` crate will be documented in this file. Th [#128]: /../../pull/128 [#136]: /../../pull/136 [#137]: /../../pull/137 +[#142]: /../../pull/142 diff --git a/codegen/src/attribute.rs b/codegen/src/attribute.rs index fd2889d6..c419034a 100644 --- a/codegen/src/attribute.rs +++ b/codegen/src/attribute.rs @@ -101,14 +101,74 @@ impl Step { } /// Expands generated code of this [`Step`] definition. - #[allow(clippy::too_many_lines)] fn expand(self) -> syn::Result { - let is_regex = matches!(self.attr_arg, AttributeArgument::Regex(_)); - let func = &self.func; let func_name = &func.sig.ident; - let (func_args, addon_parsing) = if is_regex { + let world = parse_world_from_args(&self.func.sig)?; + let constructor_method = self.constructor_method(); + let (func_args, addon_parsing) = + self.fn_arguments_and_addition_parsing()?; + + let step_matcher = self.attr_arg.regex_literal().value(); + let caller_name = + format_ident!("__cucumber_{}_{}", self.attr_name, func_name); + let awaiting = if func.sig.asyncness.is_some() { + quote! { .await } + } else { + quote! {} + }; + let step_caller = quote! { + { + #[automatically_derived] + fn #caller_name<'w>( + __cucumber_world: &'w mut #world, + __cucumber_ctx: ::cucumber::step::Context, + ) -> ::cucumber::codegen::LocalBoxFuture<'w, ()> { + let f = async move { + #addon_parsing + #func_name(__cucumber_world, #func_args)#awaiting; + }; + ::std::boxed::Box::pin(f) + } + + #caller_name + } + }; + + Ok(quote! { + #func + + #[automatically_derived] + ::cucumber::codegen::submit!( + #![crate = ::cucumber::codegen] { + <#world as ::cucumber::codegen::WorldInventory< + _, _, _, + >>::#constructor_method( + Some(::cucumber::step::Location { + path: ::std::convert::From::from(::std::file!()), + line: ::std::line!(), + column: ::std::column!(), + }), + ::cucumber::codegen::Regex::new(#step_matcher) + .unwrap(), + #step_caller, + ) + } + ); + }) + } + + /// Generates code that prepares function's arguments based on + /// [`AttributeArgument`] and additional parsing if it's + /// [`AttributeArgument::Regex`]. + fn fn_arguments_and_addition_parsing( + &self, + ) -> syn::Result<(TokenStream, Option)> { + let is_regex = matches!(self.attr_arg, AttributeArgument::Regex(_)); + let func = &self.func; + + if is_regex { if let Some(elem_ty) = find_first_slice(&func.sig) { let addon_parsing = Some(quote! { let __cucumber_matches = __cucumber_ctx @@ -132,7 +192,7 @@ impl Step { .map(|arg| self.borrow_step_or_slice(arg)) .collect::>()?; - (func_args, addon_parsing) + Ok((func_args, addon_parsing)) } else { #[allow(clippy::redundant_closure_for_method_calls)] let (idents, parsings): (Vec<_>, Vec<_>) = @@ -155,67 +215,16 @@ impl Step { #( #idents, )* }; - (func_args, addon_parsing) + Ok((func_args, addon_parsing)) } } else if self.step_arg_name.is_some() { - ( + Ok(( quote! { ::std::borrow::Borrow::borrow(&__cucumber_ctx.step), }, None, - ) - } else { - (TokenStream::default(), None) - }; - - let world = parse_world_from_args(&self.func.sig)?; - let constructor_method = self.constructor_method(); - - let step_matcher = self.attr_arg.regex_literal().value(); - let caller_name = - format_ident!("__cucumber_{}_{}", self.attr_name, func_name); - let awaiting = if func.sig.asyncness.is_some() { - quote! { .await } + )) } else { - quote! {} - }; - let step_caller = quote! { - { - #[automatically_derived] - fn #caller_name<'w>( - __cucumber_world: &'w mut #world, - __cucumber_ctx: ::cucumber::step::Context, - ) -> ::cucumber::codegen::LocalBoxFuture<'w, ()> { - let f = async move { - #addon_parsing - #func_name(__cucumber_world, #func_args)#awaiting; - }; - ::std::boxed::Box::pin(f) - } - - #caller_name - } - }; - - Ok(quote! { - #func - - #[automatically_derived] - ::cucumber::codegen::submit!( - #![crate = ::cucumber::codegen] { - <#world as ::cucumber::codegen::WorldInventory< - _, _, _, - >>::#constructor_method( - ::cucumber::codegen::Regex::new(#step_matcher) - .unwrap(), - #step_caller, - Some(::cucumber::step::Location { - path: ::std::convert::From::from(::std::file!()), - line: ::std::line!(), - column: ::std::column!(), - }), - ) - } - ); - }) + Ok((TokenStream::default(), None)) + } } /// Composes name of the [`WorldInventory`] method to wire this [`Step`] diff --git a/codegen/src/derive.rs b/codegen/src/derive.rs index f9f53c2c..f15300c7 100644 --- a/codegen/src/derive.rs +++ b/codegen/src/derive.rs @@ -61,34 +61,34 @@ fn generate_step_structs( #[doc(hidden)] #world_vis struct #ty { #[doc(hidden)] - pub regex: ::cucumber::codegen::Regex, + pub loc: ::std::option::Option<::cucumber::step::Location>, #[doc(hidden)] - pub func: ::cucumber::Step<#world>, + pub regex: ::cucumber::codegen::Regex, #[doc(hidden)] - pub loc: ::std::option::Option<::cucumber::step::Location>, + pub func: ::cucumber::Step<#world>, } #[automatically_derived] impl ::cucumber::codegen::StepConstructor<#world> for #ty { fn new ( + loc: ::std::option::Option<::cucumber::step::Location>, regex: ::cucumber::codegen::Regex, func: ::cucumber::Step<#world>, - loc: ::std::option::Option<::cucumber::step::Location>, ) -> Self { - Self { regex, func, loc } + Self { loc, regex, func } } fn inner(&self) -> ( + ::std::option::Option<::cucumber::step::Location>, ::cucumber::codegen::Regex, ::cucumber::Step<#world>, - ::std::option::Option<::cucumber::step::Location>, ) { ( + self.loc.clone(), self.regex.clone(), self.func.clone(), - self.loc.clone(), ) } } diff --git a/src/codegen.rs b/src/codegen.rs index 808abe39..716121b1 100644 --- a/src/codegen.rs +++ b/src/codegen.rs @@ -41,18 +41,18 @@ where let mut out = step::Collection::new(); for given in Self::cucumber_given() { - let (regex, fun, loc) = given.inner(); - out = out.given(regex, fun, loc); + let (loc, regex, fun) = given.inner(); + out = out.given(loc, regex, fun); } for when in Self::cucumber_when() { - let (regex, fun, loc) = when.inner(); - out = out.when(regex, fun, loc); + let (loc, regex, fun) = when.inner(); + out = out.when(loc, regex, fun); } for then in Self::cucumber_then() { - let (regex, fun, loc) = then.inner(); - out = out.then(regex, fun, loc); + let (loc, regex, fun) = then.inner(); + out = out.then(loc, regex, fun); } out @@ -144,11 +144,11 @@ where /// [`given`]: crate::given /// [Given]: https://cucumber.io/docs/gherkin/reference/#given fn new_given( + loc: Option, regex: Regex, fun: Step, - loc: Option, ) -> G { - G::new(regex, fun, loc) + G::new(loc, regex, fun) } /// Returns an [`Iterator`] over items with [`when`] attribute. @@ -164,11 +164,11 @@ where /// [`when`]: crate::when /// [When]: https://cucumber.io/docs/gherkin/reference/#when fn new_when( + loc: Option, regex: Regex, fun: Step, - loc: Option, ) -> W { - W::new(regex, fun, loc) + W::new(loc, regex, fun) } /// Returns an [`Iterator`] over items with [`then`] attribute. @@ -184,11 +184,11 @@ where /// [`then`]: crate::then /// [Then]: https://cucumber.io/docs/gherkin/reference/#then fn new_then( + loc: Option, regex: Regex, fun: Step, - loc: Option, ) -> T { - T::new(regex, fun, loc) + T::new(loc, regex, fun) } } @@ -202,8 +202,8 @@ where pub trait StepConstructor { /// Creates a new [`Step`] with the corresponding [`Regex`]. #[must_use] - fn new(_: Regex, _: Step, _: Option) -> Self; + fn new(_: Option, _: Regex, _: Step) -> Self; /// Returns an inner [`Step`] with the corresponding [`Regex`]. - fn inner(&self) -> (Regex, Step, Option); + fn inner(&self) -> (Option, Regex, Step); } diff --git a/src/cucumber.rs b/src/cucumber.rs index fb98a30b..fd6fa1d1 100644 --- a/src/cucumber.rs +++ b/src/cucumber.rs @@ -969,11 +969,11 @@ impl Cucumber, Wr> { #[must_use] pub fn given( mut self, + loc: Option, regex: Regex, step: Step, - loc: Option, ) -> Self { - self.runner = self.runner.given(regex, step, loc); + self.runner = self.runner.given(loc, regex, step); self } @@ -983,11 +983,11 @@ impl Cucumber, Wr> { #[must_use] pub fn when( mut self, + loc: Option, regex: Regex, step: Step, - loc: Option, ) -> Self { - self.runner = self.runner.when(regex, step, loc); + self.runner = self.runner.when(loc, regex, step); self } @@ -997,11 +997,11 @@ impl Cucumber, Wr> { #[must_use] pub fn then( mut self, + loc: Option, regex: Regex, step: Step, - loc: Option, ) -> Self { - self.runner = self.runner.then(regex, step, loc); + self.runner = self.runner.then(loc, regex, step); self } } diff --git a/src/event.rs b/src/event.rs index 31c20263..22e0cd5b 100644 --- a/src/event.rs +++ b/src/event.rs @@ -190,7 +190,10 @@ pub enum Step { /// [`Step`]: gherkin::Step Started, - /// TODO + /// [`Step`] matched by multiple [`Regex`]es. + /// + /// [`Regex`]: regex::Regex + /// [`Step`]: gherkin::Step AmbiguousMatch(step::AmbiguousMatchError), /// [`Step`] being skipped. diff --git a/src/runner/basic.rs b/src/runner/basic.rs index 5dd3cd99..5ce488c4 100644 --- a/src/runner/basic.rs +++ b/src/runner/basic.rs @@ -321,11 +321,11 @@ impl Basic { #[must_use] pub fn given( mut self, + loc: Option, regex: Regex, step: Step, - loc: Option, ) -> Self { - self.steps = mem::take(&mut self.steps).given(regex, step, loc); + self.steps = mem::take(&mut self.steps).given(loc, regex, step); self } @@ -335,11 +335,11 @@ impl Basic { #[must_use] pub fn when( mut self, + loc: Option, regex: Regex, step: Step, - loc: Option, ) -> Self { - self.steps = mem::take(&mut self.steps).when(regex, step, loc); + self.steps = mem::take(&mut self.steps).when(loc, regex, step); self } @@ -349,11 +349,11 @@ impl Basic { #[must_use] pub fn then( mut self, + loc: Option, regex: Regex, step: Step, - loc: Option, ) -> Self { - self.steps = mem::take(&mut self.steps).then(regex, step, loc); + self.steps = mem::take(&mut self.steps).then(loc, regex, step); self } } @@ -625,50 +625,40 @@ where /// [`Scenario`]: gherkin::Scenario async fn run_scenario( &self, - f: Arc, - r: Option>, - s: Arc, + feature: Arc, + rule: Option>, + scenario: Arc, ) { use event::{ Cucumber, Scenario::{Finished, Started}, }; + let (f, r, s) = (&feature, &rule, &scenario); let ok = |e: fn(Arc) -> event::Scenario| { - let (f, r, s) = (&f, &r, &s); move |step| { Cucumber::scenario(f.clone(), r.clone(), s.clone(), e(step)) } }; let ok_capt = |e: fn(Arc, _) -> event::Scenario| { - let (f, r, s) = (&f, &r, &s); move |st, cap| { Cucumber::scenario(f.clone(), r.clone(), s.clone(), e(st, cap)) } }; - let panic_err = - |e: fn(Arc, _, _, _) -> event::Scenario| { - let (f, r, s) = (&f, &r, &s); - move |step, captures, w, info| { - let (f, r, s) = (f.clone(), r.clone(), s.clone()); - Cucumber::scenario(f, r, s, e(step, captures, w, info)) - } - }; + let panic_err = |e: fn(_, _, _, _) -> event::Scenario| { + move |step, captures, w, info| { + let (f, r, s) = (f.clone(), r.clone(), s.clone()); + Cucumber::scenario(f, r, s, e(step, captures, w, info)) + } + }; let amb_err = |e: fn(Arc, _) -> event::Scenario| { - let (f, r, s) = (&f, &r, &s); move |st, err| { Cucumber::scenario(f.clone(), r.clone(), s.clone(), e(st, err)) } }; - let compose = |started, passed, skipped, failed, amb| { - ( - ok(started), - ok_capt(passed), - ok(skipped), - panic_err(failed), - amb_err(amb), - ) + let compose = |st, ps, sk, fl, amb| { + (ok(st), ok_capt(ps), ok(sk), panic_err(fl), amb_err(amb)) }; let into_bg_step_ev = compose( event::Scenario::background_step_started, @@ -685,48 +675,42 @@ where event::Scenario::ambiguous_step, ); + let flatten_bg = |bg: Option<&gherkin::Background>| { + bg.map(|b| b.steps.iter().map(|s| Arc::new(s.clone()))) + .into_iter() + .flatten() + .collect::>() + }; + self.send(Cucumber::scenario(f.clone(), r.clone(), s.clone(), Started)); let res = async { let before_hook = self - .run_before_hook(&f, r.as_ref(), &s) + .run_before_hook(f, r.as_ref(), s) .await .map_err(|_| None)?; - let feature_background = f - .background - .as_ref() - .map(|b| b.steps.iter().map(|s| Arc::new(s.clone()))) - .into_iter() - .flatten(); - - let feature_background = stream::iter(feature_background) + let feature_bg = stream::iter(flatten_bg(f.background.as_ref())) .map(Ok) .try_fold(before_hook, |world, bg_step| { self.run_step(world, bg_step, into_bg_step_ev).map_ok(Some) }) .await?; - let rule_background = r + let rule_bg = rule .as_ref() - .map(|rule| { - rule.background - .as_ref() - .map(|b| b.steps.iter().map(|s| Arc::new(s.clone()))) - .into_iter() - .flatten() - }) + .map(|rule| flatten_bg(rule.background.as_ref())) .into_iter() .flatten(); - let rule_background = stream::iter(rule_background) + let rule_background = stream::iter(rule_bg) .map(Ok) - .try_fold(feature_background, |world, bg_step| { + .try_fold(feature_bg, |world, bg_step| { self.run_step(world, bg_step, into_bg_step_ev).map_ok(Some) }) .await?; - stream::iter(s.steps.iter().map(|s| Arc::new(s.clone()))) + stream::iter(scenario.steps.iter().map(|s| Arc::new(s.clone()))) .map(Ok) .try_fold(rule_background, |world, step| { self.run_step(world, step, into_step_ev).map_ok(Some) @@ -738,7 +722,7 @@ where Ok(world) | Err(world) => world, }; - drop(self.run_after_hook(world, &f, r.as_ref(), &s).await); + drop(self.run_after_hook(world, f, r.as_ref(), s).await); self.send(Cucumber::scenario( f.clone(), @@ -747,13 +731,13 @@ where Finished, )); - if let Some(rule) = r { + if let Some(rule) = rule { if let Some(fin) = self.rule_scenario_finished(f.clone(), rule) { self.send(fin); } } - if let Some(fin) = self.feature_scenario_finished(f) { + if let Some(fin) = self.feature_scenario_finished(feature) { self.send(fin); } } diff --git a/src/step.rs b/src/step.rs index 8a47de31..44ad1de1 100644 --- a/src/step.rs +++ b/src/step.rs @@ -31,7 +31,7 @@ use regex::Regex; pub type Step = for<'a> fn(&'a mut World, Context) -> LocalBoxFuture<'a, ()>; -/// TODO +/// Alias for return value of [`Collection::find()`]. pub type FindValue<'me, World> = (&'me Step, regex::CaptureLocations, Context); @@ -46,16 +46,16 @@ pub struct Collection { then: BTreeMap<(HashableRegex, Option), Step>, } -/// TODO +/// Location of a [`Step`] [`fn`]. Automatically filled by proc macro. #[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)] pub struct Location { - /// TODO + /// Path to the file, where [`Step`] [`fn`] is located. pub path: PathBuf, - /// TODO + /// Line of the file, where [`Step`] [`fn`] is located. pub line: u32, - /// TODO + /// Column of the file, where [`Step`] [`fn`] is located. pub column: u32, } @@ -113,9 +113,9 @@ impl Collection { #[must_use] pub fn given( mut self, + loc: Option, regex: Regex, step: Step, - loc: Option, ) -> Self { let _ = self.given.insert((regex.into(), loc), step); self @@ -127,9 +127,9 @@ impl Collection { #[must_use] pub fn when( mut self, + loc: Option, regex: Regex, step: Step, - loc: Option, ) -> Self { let _ = self.when.insert((regex.into(), loc), step); self @@ -141,9 +141,9 @@ impl Collection { #[must_use] pub fn then( mut self, + loc: Option, regex: Regex, step: Step, - loc: Option, ) -> Self { let _ = self.then.insert((regex.into(), loc), step); self @@ -153,6 +153,8 @@ impl Collection { /// if any. /// /// # Errors + /// + /// If [`gherkin::Step`] is matched by multiple [`Regex`]es. pub fn find( &self, step: &gherkin::Step, @@ -211,10 +213,11 @@ impl Collection { } } -/// TODO +/// Error of a [`gherkin::Step`] being matched by multiple [`Step`] [`Regex`]es +/// inside a [`Collection`]. #[derive(Clone, Debug)] pub struct AmbiguousMatchError { - /// TODO + /// Possible [`Regex`]es that matched [`gherkin::Step`]. pub possible_matches: Vec<(HashableRegex, Option)>, } @@ -232,7 +235,7 @@ pub struct Context { pub matches: Vec, } -/// [`Regex`] wrapper to store inside a [`LinkedHashMap`]. +/// [`Regex`] wrapper that implements [`Eq`], [`Ord`] and [`Hash`]. #[derive(Clone, Debug, Deref, DerefMut)] pub struct HashableRegex(Regex); diff --git a/src/writer/basic.rs b/src/writer/basic.rs index db9b80a1..07a1d063 100644 --- a/src/writer/basic.rs +++ b/src/writer/basic.rs @@ -241,7 +241,7 @@ impl Basic { sc.position.line, sc.position.col, coerce_error(info), - format_world(world, self.indent.saturating_sub(3) + 3), + format_debug_with_indent(world, self.indent.saturating_sub(3) + 3), indent = " ".repeat(self.indent.saturating_sub(3)), ))) .unwrap(); @@ -437,7 +437,7 @@ impl Basic { step.position.line, step.position.col, coerce_error(info), - format_world(world, self.indent.saturating_sub(3) + 3), + format_debug_with_indent(world, self.indent.saturating_sub(3) + 3), indent = " ".repeat(self.indent.saturating_sub(3)) )); @@ -448,7 +448,10 @@ impl Basic { .unwrap(); } - /// TODO + /// Outputs [ambiguous] [`Step`] to STDOUT. + /// + /// [ambiguous]: event::Step::Ambiguous + /// [`Step`]: [`gherkin::Step`] fn step_ambiguous_match( &mut self, feat: &gherkin::Feature, @@ -460,7 +463,7 @@ impl Basic { self.write_line(&self.styles.err(format!( "{indent}\u{2718} {} {}{}\n\ {indent} Step match is ambiguous: {}:{}:{}\n\ - {indent} Possible matches: {:?}", + {indent} Possible matches: {}", step.keyword, step.value, step.table @@ -473,10 +476,10 @@ impl Basic { .unwrap_or(&feat.name), step.position.line, step.position.col, - err.possible_matches + format_debug_with_indent(&err.possible_matches .iter() .map(|(re, loc)| (re.as_str(), loc)) - .collect::>(), + .collect::>(), self.indent.saturating_sub(3) + 3), indent = " ".repeat(self.indent.saturating_sub(3)) ))) .unwrap(); @@ -503,8 +506,8 @@ impl Basic { Step::Started => { self.bg_step_started(bg); } - Step::AmbiguousMatch(_e) => { - // TODO + Step::AmbiguousMatch(e) => { + self.bg_step_ambiguous_match(feat, bg, e); } Step::Passed(captures) => { self.bg_step_passed(bg, captures); @@ -665,7 +668,7 @@ impl Basic { step.position.line, step.position.col, coerce_error(info), - format_world(world, self.indent.saturating_sub(3) + 3), + format_debug_with_indent(world, self.indent.saturating_sub(3) + 3), indent = " ".repeat(self.indent.saturating_sub(3)) )); @@ -675,6 +678,44 @@ impl Basic { )) .unwrap(); } + + /// Outputs [ambiguous] [`Background`] [`Step`] to STDOUT. + /// + /// [ambiguous]: event::Step::Ambiguous + /// [`Background`]: [`gherkin::Background`] + /// [`Step`]: [`gherkin::Step`] + fn bg_step_ambiguous_match( + &mut self, + feat: &gherkin::Feature, + step: &gherkin::Step, + err: &AmbiguousMatchError, + ) { + self.clear_last_lines_if_term_present(); + + self.write_line(&self.styles.err(format!( + "{indent}\u{2718} {} {}{}\n\ + {indent} Background Step match is ambiguous: {}:{}:{}\n\ + {indent} Possible matches: {}", + step.keyword, + step.value, + step.table + .as_ref() + .map(|t| format_table(t, self.indent)) + .unwrap_or_default(), + feat.path + .as_ref() + .and_then(|p| p.to_str()) + .unwrap_or(&feat.name), + step.position.line, + step.position.col, + format_debug_with_indent(&err.possible_matches + .iter() + .map(|(re, loc)| (re.as_str(), loc)) + .collect::>(), self.indent.saturating_sub(3) + 3), + indent = " ".repeat(self.indent.saturating_sub(3)) + ))) + .unwrap(); + } } /// Tries to coerce [`catch_unwind()`] output to [`String`]. @@ -691,10 +732,17 @@ fn coerce_error(err: &Info) -> String { } } -/// Formats the given [`World`] using [`Debug`], then adds `indent`s to each -/// line to prettify the output. -fn format_world(world: Option<&W>, indent: usize) -> String { +/// Formats the given [`Debug`] implementor, then adds `indent`s to each line to +/// prettify the output. +fn format_debug_with_indent<'w, O, W: 'w + Debug>( + world: O, + indent: usize, +) -> String +where + O: Into>, +{ let world = world + .into() .map(|world| format!("{:#?}", world)) .unwrap_or_default() .lines() diff --git a/src/writer/summarized.rs b/src/writer/summarized.rs index 205eea9a..75e38a27 100644 --- a/src/writer/summarized.rs +++ b/src/writer/summarized.rs @@ -337,13 +337,11 @@ impl Styles { ) }) .unwrap_or_default(); - let hook_errors = (summary.failed_hooks > 0) .then(|| { self.err(self.maybe_plural("hook error", summary.failed_hooks)) }) .unwrap_or_default(); - let comma = (!parsing_errors.is_empty() && !hook_errors.is_empty()) .then(|| self.err(",")) .unwrap_or_default(); From 7b797bbfd029177ebc93c4418abad00772a161e8 Mon Sep 17 00:00:00 2001 From: ilslv Date: Mon, 18 Oct 2021 11:03:48 +0300 Subject: [PATCH 08/25] CHANGELOG, Docs and Book --- CHANGELOG.md | 2 ++ book/src/Test_Modules_Organization.md | 2 ++ src/step.rs | 5 ++--- 3 files changed, 6 insertions(+), 3 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index e4f4313b..ff5541c6 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -23,6 +23,7 @@ All user visible changes to `cucumber` crate will be documented in this file. Th - Made `#[step]` argument of step functions `Step` instead of `StepContext` again, while test callbacks still receive `StepContext` as a second parameter. ([#128]) - Deprecated `--nocapture` and `--debug` CLI options to be completely redesigned in `0.11` release. ([#137]) - [Hooks](https://cucumber.io/docs/cucumber/api/#hooks) now accept `&mut World` as a last parameter ([#142]) +- Propagate `Step` being matched by multiple `Regex`es as `AmbiguousMatchError` ([#143]) ### Added @@ -33,6 +34,7 @@ All user visible changes to `cucumber` crate will be documented in this file. Th [#136]: /../../pull/136 [#137]: /../../pull/137 [#142]: /../../pull/142 +[#142]: /../../pull/143 diff --git a/book/src/Test_Modules_Organization.md b/book/src/Test_Modules_Organization.md index 0f2f6a6a..41189001 100644 --- a/book/src/Test_Modules_Organization.md +++ b/book/src/Test_Modules_Organization.md @@ -26,6 +26,8 @@ Avoid writing similar step definitions, as they can lead to clutter. While docum ## Managing growth +To help with non-intuitive and frustrating problems that can be encountered in case your `Step` is matched by multiple functions, annotated with `Step` attributes, we propagate that case as an [`AmbiguousMatchError`](https://docs.rs/cucumber/*cucumber/event/enum.Step.html#variant.AmbiguousMatch). + As your test suit grows, it may become harder to notice how minimal changes to `regex`es can lead to mismatched `Step`s. To avoid this, we recommend using [`Cucumber::fail_on_skipped()`](https://docs.rs/cucumber/*/cucumber/struct.Cucumber.html#method.fail_on_skipped) combining with `@allow_skipped` tag. This will allow you to mark out `Scenario`s which `Step`s are allowed to skip. And, as time goes on, total run time of all tests can become overwhelming when you only want to test small subset of `Scenario`s. At least until you discover [`Cucumber::filter_run_and_exit()`](https://docs.rs/cucumber/*/cucumber/struct.Cucumber.html#method.filter_run_and_exit), which will allow you run only `Scenario`s marked with custom [tags](https://cucumber.io/docs/cucumber/api/#tags). diff --git a/src/step.rs b/src/step.rs index 44ad1de1..3c1360cf 100644 --- a/src/step.rs +++ b/src/step.rs @@ -37,9 +37,8 @@ pub type FindValue<'me, World> = /// Collection of [`Step`]s. /// -/// Every [`Step`] should be matched by exactly 1 [`Regex`]. Otherwise there are -/// no guarantees that [`Step`]s will be matched deterministically from run to -/// run. +/// Every [`Step`] must be matched by exactly 1 [`Regex`]. Otherwise +/// [`AmbiguousMatchError`] will be returned. pub struct Collection { given: BTreeMap<(HashableRegex, Option), Step>, when: BTreeMap<(HashableRegex, Option), Step>, From e0075a8decc002f44497ed5e8d6d8ff86320973d Mon Sep 17 00:00:00 2001 From: ilslv Date: Mon, 18 Oct 2021 11:17:00 +0300 Subject: [PATCH 09/25] Fix Windows tests --- .../output/ambiguous_step.feature.out | 12 +++---- .../output/background_rule.feature.out | 28 ++++++++-------- .../background_rule_background.feature.out | 32 +++++++++---------- ...ground_rule_background_outline.feature.out | 32 +++++++++---------- .../background_rule_outline.feature.out | 28 ++++++++-------- .../output/background_scenario.feature.out | 24 +++++++------- .../background_scenario_outline.feature.out | 24 +++++++------- .../output/non_default_lang.feature.out | 20 ++++++------ tests/features/output/rule.feature.out | 24 +++++++------- .../output/rule_background.feature.out | 28 ++++++++-------- .../rule_background_outline.feature.out | 28 ++++++++-------- .../features/output/rule_outline.feature.out | 24 +++++++------- tests/features/output/scenario.feature.out | 20 ++++++------ .../output/scenario_outline.feature.out | 20 ++++++------ .../output/scenario_outline_table.feature.out | 28 ++++++++-------- tests/output.rs | 10 ++---- 16 files changed, 188 insertions(+), 194 deletions(-) diff --git a/tests/features/output/ambiguous_step.feature.out b/tests/features/output/ambiguous_step.feature.out index 27bc5cec..0ce8cd40 100644 --- a/tests/features/output/ambiguous_step.feature.out +++ b/tests/features/output/ambiguous_step.feature.out @@ -1,8 +1,8 @@ Started -Feature(Feature { keyword: "Feature", name: "ambiguous", description: None, background: None, scenarios: [Scenario { keyword: "Scenario", name: "ambiguous", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Started) -Feature(Feature { keyword: "Feature", name: "ambiguous", description: None, background: None, scenarios: [Scenario { keyword: "Scenario", name: "ambiguous", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Scenario(Scenario { keyword: "Scenario", name: "ambiguous", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }, Started)) -Feature(Feature { keyword: "Feature", name: "ambiguous", description: None, background: None, scenarios: [Scenario { keyword: "Scenario", name: "ambiguous", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Scenario(Scenario { keyword: "Scenario", name: "ambiguous", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }, Step(Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }, Started))) -Feature(Feature { keyword: "Feature", name: "ambiguous", description: None, background: None, scenarios: [Scenario { keyword: "Scenario", name: "ambiguous", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Scenario(Scenario { keyword: "Scenario", name: "ambiguous", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }, Step(Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }, AmbiguousMatch(AmbiguousMatchError { possible_matches: [(HashableRegex(foo is (\d+)), Some(Location { path: "tests/output.rs", line: 10, column: 1 })), (HashableRegex(foo is (\d+) ambiguous), Some(Location { path: "tests/output.rs", line: 18, column: 1 }))] })))) -Feature(Feature { keyword: "Feature", name: "ambiguous", description: None, background: None, scenarios: [Scenario { keyword: "Scenario", name: "ambiguous", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Scenario(Scenario { keyword: "Scenario", name: "ambiguous", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }, Finished)) -Feature(Feature { keyword: "Feature", name: "ambiguous", description: None, background: None, scenarios: [Scenario { keyword: "Scenario", name: "ambiguous", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Finished) +Feature(Feature { keyword: "Feature", name: "ambiguous", description: None, background: None, scenarios: [Scenario { keyword: "Scenario", name: "ambiguous", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Started) +Feature(Feature { keyword: "Feature", name: "ambiguous", description: None, background: None, scenarios: [Scenario { keyword: "Scenario", name: "ambiguous", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Scenario(Scenario { keyword: "Scenario", name: "ambiguous", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }, Started)) +Feature(Feature { keyword: "Feature", name: "ambiguous", description: None, background: None, scenarios: [Scenario { keyword: "Scenario", name: "ambiguous", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Scenario(Scenario { keyword: "Scenario", name: "ambiguous", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }, Step(Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }, Started))) +Feature(Feature { keyword: "Feature", name: "ambiguous", description: None, background: None, scenarios: [Scenario { keyword: "Scenario", name: "ambiguous", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Scenario(Scenario { keyword: "Scenario", name: "ambiguous", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }, Step(Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }, AmbiguousMatch(AmbiguousMatchError { possible_matches: [(HashableRegex(foo is (\d+)), Some(Location { line: 10, column: 1 })), (HashableRegex(foo is (\d+) ambiguous), Some(Location { line: 18, column: 1 }))] })))) +Feature(Feature { keyword: "Feature", name: "ambiguous", description: None, background: None, scenarios: [Scenario { keyword: "Scenario", name: "ambiguous", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Scenario(Scenario { keyword: "Scenario", name: "ambiguous", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }, Finished)) +Feature(Feature { keyword: "Feature", name: "ambiguous", description: None, background: None, scenarios: [Scenario { keyword: "Scenario", name: "ambiguous", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Finished) Finished diff --git a/tests/features/output/background_rule.feature.out b/tests/features/output/background_rule.feature.out index 25a70eaf..7c6a416c 100644 --- a/tests/features/output/background_rule.feature.out +++ b/tests/features/output/background_rule.feature.out @@ -1,16 +1,16 @@ Started -Feature(Feature { keyword: "Feature", name: "output", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Started) -Feature(Feature { keyword: "Feature", name: "output", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Started)) -Feature(Feature { keyword: "Feature", name: "output", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }, Started))) -Feature(Feature { keyword: "Feature", name: "output", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }, Background(Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Started)))) -Feature(Feature { keyword: "Feature", name: "output", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }, Background(Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)]))))))) -Feature(Feature { keyword: "Feature", name: "output", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }, Step(Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Started)))) -Feature(Feature { keyword: "Feature", name: "output", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }, Step(Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)]))))))) -Feature(Feature { keyword: "Feature", name: "output", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }, Step(Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Started)))) -Feature(Feature { keyword: "Feature", name: "output", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }, Step(Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)]))))))) -Feature(Feature { keyword: "Feature", name: "output", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }, Step(Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }, Started)))) -Feature(Feature { keyword: "Feature", name: "output", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }, Step(Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)]))))))) -Feature(Feature { keyword: "Feature", name: "output", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }, Finished))) -Feature(Feature { keyword: "Feature", name: "output", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Finished)) -Feature(Feature { keyword: "Feature", name: "output", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Finished) +Feature(Feature { keyword: "Feature", name: "output", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Started) +Feature(Feature { keyword: "Feature", name: "output", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Started)) +Feature(Feature { keyword: "Feature", name: "output", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }, Started))) +Feature(Feature { keyword: "Feature", name: "output", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }, Background(Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Started)))) +Feature(Feature { keyword: "Feature", name: "output", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }, Background(Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)]))))))) +Feature(Feature { keyword: "Feature", name: "output", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }, Step(Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Started)))) +Feature(Feature { keyword: "Feature", name: "output", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }, Step(Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)]))))))) +Feature(Feature { keyword: "Feature", name: "output", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }, Step(Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Started)))) +Feature(Feature { keyword: "Feature", name: "output", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }, Step(Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)]))))))) +Feature(Feature { keyword: "Feature", name: "output", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }, Step(Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }, Started)))) +Feature(Feature { keyword: "Feature", name: "output", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }, Step(Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)]))))))) +Feature(Feature { keyword: "Feature", name: "output", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }, Finished))) +Feature(Feature { keyword: "Feature", name: "output", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Finished)) +Feature(Feature { keyword: "Feature", name: "output", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Finished) Finished diff --git a/tests/features/output/background_rule_background.feature.out b/tests/features/output/background_rule_background.feature.out index 902f334b..ff983a85 100644 --- a/tests/features/output/background_rule_background.feature.out +++ b/tests/features/output/background_rule_background.feature.out @@ -1,18 +1,18 @@ Started -Feature(Feature { keyword: "Feature", name: "output", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: None, tags: [], position: LineCol { line: 11, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Started) -Feature(Feature { keyword: "Feature", name: "output", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: None, tags: [], position: LineCol { line: 11, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: None, tags: [], position: LineCol { line: 11, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Started)) -Feature(Feature { keyword: "Feature", name: "output", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: None, tags: [], position: LineCol { line: 11, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: None, tags: [], position: LineCol { line: 11, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: None, tags: [], position: LineCol { line: 11, col: 5 } }, Started))) -Feature(Feature { keyword: "Feature", name: "output", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: None, tags: [], position: LineCol { line: 11, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: None, tags: [], position: LineCol { line: 11, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: None, tags: [], position: LineCol { line: 11, col: 5 } }, Background(Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Started)))) -Feature(Feature { keyword: "Feature", name: "output", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: None, tags: [], position: LineCol { line: 11, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: None, tags: [], position: LineCol { line: 11, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: None, tags: [], position: LineCol { line: 11, col: 5 } }, Background(Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)]))))))) -Feature(Feature { keyword: "Feature", name: "output", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: None, tags: [], position: LineCol { line: 11, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: None, tags: [], position: LineCol { line: 11, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: None, tags: [], position: LineCol { line: 11, col: 5 } }, Background(Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Started)))) -Feature(Feature { keyword: "Feature", name: "output", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: None, tags: [], position: LineCol { line: 11, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: None, tags: [], position: LineCol { line: 11, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: None, tags: [], position: LineCol { line: 11, col: 5 } }, Background(Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)]))))))) -Feature(Feature { keyword: "Feature", name: "output", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: None, tags: [], position: LineCol { line: 11, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: None, tags: [], position: LineCol { line: 11, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: None, tags: [], position: LineCol { line: 11, col: 5 } }, Step(Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Started)))) -Feature(Feature { keyword: "Feature", name: "output", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: None, tags: [], position: LineCol { line: 11, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: None, tags: [], position: LineCol { line: 11, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: None, tags: [], position: LineCol { line: 11, col: 5 } }, Step(Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)]))))))) -Feature(Feature { keyword: "Feature", name: "output", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: None, tags: [], position: LineCol { line: 11, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: None, tags: [], position: LineCol { line: 11, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: None, tags: [], position: LineCol { line: 11, col: 5 } }, Step(Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Started)))) -Feature(Feature { keyword: "Feature", name: "output", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: None, tags: [], position: LineCol { line: 11, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: None, tags: [], position: LineCol { line: 11, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: None, tags: [], position: LineCol { line: 11, col: 5 } }, Step(Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)]))))))) -Feature(Feature { keyword: "Feature", name: "output", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: None, tags: [], position: LineCol { line: 11, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: None, tags: [], position: LineCol { line: 11, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: None, tags: [], position: LineCol { line: 11, col: 5 } }, Step(Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }, Started)))) -Feature(Feature { keyword: "Feature", name: "output", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: None, tags: [], position: LineCol { line: 11, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: None, tags: [], position: LineCol { line: 11, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: None, tags: [], position: LineCol { line: 11, col: 5 } }, Step(Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)]))))))) -Feature(Feature { keyword: "Feature", name: "output", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: None, tags: [], position: LineCol { line: 11, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: None, tags: [], position: LineCol { line: 11, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: None, tags: [], position: LineCol { line: 11, col: 5 } }, Finished))) -Feature(Feature { keyword: "Feature", name: "output", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: None, tags: [], position: LineCol { line: 11, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: None, tags: [], position: LineCol { line: 11, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Finished)) -Feature(Feature { keyword: "Feature", name: "output", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: None, tags: [], position: LineCol { line: 11, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Finished) +Feature(Feature { keyword: "Feature", name: "output", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: None, tags: [], position: LineCol { line: 11, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Started) +Feature(Feature { keyword: "Feature", name: "output", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: None, tags: [], position: LineCol { line: 11, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: None, tags: [], position: LineCol { line: 11, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Started)) +Feature(Feature { keyword: "Feature", name: "output", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: None, tags: [], position: LineCol { line: 11, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: None, tags: [], position: LineCol { line: 11, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: None, tags: [], position: LineCol { line: 11, col: 5 } }, Started))) +Feature(Feature { keyword: "Feature", name: "output", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: None, tags: [], position: LineCol { line: 11, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: None, tags: [], position: LineCol { line: 11, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: None, tags: [], position: LineCol { line: 11, col: 5 } }, Background(Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Started)))) +Feature(Feature { keyword: "Feature", name: "output", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: None, tags: [], position: LineCol { line: 11, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: None, tags: [], position: LineCol { line: 11, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: None, tags: [], position: LineCol { line: 11, col: 5 } }, Background(Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)]))))))) +Feature(Feature { keyword: "Feature", name: "output", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: None, tags: [], position: LineCol { line: 11, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: None, tags: [], position: LineCol { line: 11, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: None, tags: [], position: LineCol { line: 11, col: 5 } }, Background(Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Started)))) +Feature(Feature { keyword: "Feature", name: "output", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: None, tags: [], position: LineCol { line: 11, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: None, tags: [], position: LineCol { line: 11, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: None, tags: [], position: LineCol { line: 11, col: 5 } }, Background(Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)]))))))) +Feature(Feature { keyword: "Feature", name: "output", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: None, tags: [], position: LineCol { line: 11, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: None, tags: [], position: LineCol { line: 11, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: None, tags: [], position: LineCol { line: 11, col: 5 } }, Step(Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Started)))) +Feature(Feature { keyword: "Feature", name: "output", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: None, tags: [], position: LineCol { line: 11, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: None, tags: [], position: LineCol { line: 11, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: None, tags: [], position: LineCol { line: 11, col: 5 } }, Step(Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)]))))))) +Feature(Feature { keyword: "Feature", name: "output", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: None, tags: [], position: LineCol { line: 11, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: None, tags: [], position: LineCol { line: 11, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: None, tags: [], position: LineCol { line: 11, col: 5 } }, Step(Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Started)))) +Feature(Feature { keyword: "Feature", name: "output", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: None, tags: [], position: LineCol { line: 11, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: None, tags: [], position: LineCol { line: 11, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: None, tags: [], position: LineCol { line: 11, col: 5 } }, Step(Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)]))))))) +Feature(Feature { keyword: "Feature", name: "output", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: None, tags: [], position: LineCol { line: 11, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: None, tags: [], position: LineCol { line: 11, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: None, tags: [], position: LineCol { line: 11, col: 5 } }, Step(Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }, Started)))) +Feature(Feature { keyword: "Feature", name: "output", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: None, tags: [], position: LineCol { line: 11, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: None, tags: [], position: LineCol { line: 11, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: None, tags: [], position: LineCol { line: 11, col: 5 } }, Step(Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)]))))))) +Feature(Feature { keyword: "Feature", name: "output", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: None, tags: [], position: LineCol { line: 11, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: None, tags: [], position: LineCol { line: 11, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: None, tags: [], position: LineCol { line: 11, col: 5 } }, Finished))) +Feature(Feature { keyword: "Feature", name: "output", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: None, tags: [], position: LineCol { line: 11, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: None, tags: [], position: LineCol { line: 11, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Finished)) +Feature(Feature { keyword: "Feature", name: "output", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: None, tags: [], position: LineCol { line: 11, col: 5 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Finished) Finished diff --git a/tests/features/output/background_rule_background_outline.feature.out b/tests/features/output/background_rule_background_outline.feature.out index da55980b..506abdf2 100644 --- a/tests/features/output/background_rule_background_outline.feature.out +++ b/tests/features/output/background_rule_background_outline.feature.out @@ -1,18 +1,18 @@ Started -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["2", "3", "4"]], position: LineCol { line: 17, col: 9 } }, tags: [], position: LineCol { line: 16, col: 7 } }), tags: [], position: LineCol { line: 17, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Started) -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["2", "3", "4"]], position: LineCol { line: 17, col: 9 } }, tags: [], position: LineCol { line: 16, col: 7 } }), tags: [], position: LineCol { line: 17, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["2", "3", "4"]], position: LineCol { line: 17, col: 9 } }, tags: [], position: LineCol { line: 16, col: 7 } }), tags: [], position: LineCol { line: 17, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Started)) -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["2", "3", "4"]], position: LineCol { line: 17, col: 9 } }, tags: [], position: LineCol { line: 16, col: 7 } }), tags: [], position: LineCol { line: 17, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["2", "3", "4"]], position: LineCol { line: 17, col: 9 } }, tags: [], position: LineCol { line: 16, col: 7 } }), tags: [], position: LineCol { line: 17, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["2", "3", "4"]], position: LineCol { line: 17, col: 9 } }, tags: [], position: LineCol { line: 16, col: 7 } }), tags: [], position: LineCol { line: 17, col: 7 } }, Started))) -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["2", "3", "4"]], position: LineCol { line: 17, col: 9 } }, tags: [], position: LineCol { line: 16, col: 7 } }), tags: [], position: LineCol { line: 17, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["2", "3", "4"]], position: LineCol { line: 17, col: 9 } }, tags: [], position: LineCol { line: 16, col: 7 } }), tags: [], position: LineCol { line: 17, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["2", "3", "4"]], position: LineCol { line: 17, col: 9 } }, tags: [], position: LineCol { line: 16, col: 7 } }), tags: [], position: LineCol { line: 17, col: 7 } }, Background(Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Started)))) -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["2", "3", "4"]], position: LineCol { line: 17, col: 9 } }, tags: [], position: LineCol { line: 16, col: 7 } }), tags: [], position: LineCol { line: 17, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["2", "3", "4"]], position: LineCol { line: 17, col: 9 } }, tags: [], position: LineCol { line: 16, col: 7 } }), tags: [], position: LineCol { line: 17, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["2", "3", "4"]], position: LineCol { line: 17, col: 9 } }, tags: [], position: LineCol { line: 16, col: 7 } }), tags: [], position: LineCol { line: 17, col: 7 } }, Background(Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)]))))))) -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["2", "3", "4"]], position: LineCol { line: 17, col: 9 } }, tags: [], position: LineCol { line: 16, col: 7 } }), tags: [], position: LineCol { line: 17, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["2", "3", "4"]], position: LineCol { line: 17, col: 9 } }, tags: [], position: LineCol { line: 16, col: 7 } }), tags: [], position: LineCol { line: 17, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["2", "3", "4"]], position: LineCol { line: 17, col: 9 } }, tags: [], position: LineCol { line: 16, col: 7 } }), tags: [], position: LineCol { line: 17, col: 7 } }, Background(Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Started)))) -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["2", "3", "4"]], position: LineCol { line: 17, col: 9 } }, tags: [], position: LineCol { line: 16, col: 7 } }), tags: [], position: LineCol { line: 17, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["2", "3", "4"]], position: LineCol { line: 17, col: 9 } }, tags: [], position: LineCol { line: 16, col: 7 } }), tags: [], position: LineCol { line: 17, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["2", "3", "4"]], position: LineCol { line: 17, col: 9 } }, tags: [], position: LineCol { line: 16, col: 7 } }), tags: [], position: LineCol { line: 17, col: 7 } }, Background(Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)]))))))) -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["2", "3", "4"]], position: LineCol { line: 17, col: 9 } }, tags: [], position: LineCol { line: 16, col: 7 } }), tags: [], position: LineCol { line: 17, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["2", "3", "4"]], position: LineCol { line: 17, col: 9 } }, tags: [], position: LineCol { line: 16, col: 7 } }), tags: [], position: LineCol { line: 17, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["2", "3", "4"]], position: LineCol { line: 17, col: 9 } }, tags: [], position: LineCol { line: 16, col: 7 } }), tags: [], position: LineCol { line: 17, col: 7 } }, Step(Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Started)))) -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["2", "3", "4"]], position: LineCol { line: 17, col: 9 } }, tags: [], position: LineCol { line: 16, col: 7 } }), tags: [], position: LineCol { line: 17, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["2", "3", "4"]], position: LineCol { line: 17, col: 9 } }, tags: [], position: LineCol { line: 16, col: 7 } }), tags: [], position: LineCol { line: 17, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["2", "3", "4"]], position: LineCol { line: 17, col: 9 } }, tags: [], position: LineCol { line: 16, col: 7 } }), tags: [], position: LineCol { line: 17, col: 7 } }, Step(Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)]))))))) -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["2", "3", "4"]], position: LineCol { line: 17, col: 9 } }, tags: [], position: LineCol { line: 16, col: 7 } }), tags: [], position: LineCol { line: 17, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["2", "3", "4"]], position: LineCol { line: 17, col: 9 } }, tags: [], position: LineCol { line: 16, col: 7 } }), tags: [], position: LineCol { line: 17, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["2", "3", "4"]], position: LineCol { line: 17, col: 9 } }, tags: [], position: LineCol { line: 16, col: 7 } }), tags: [], position: LineCol { line: 17, col: 7 } }, Step(Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Started)))) -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["2", "3", "4"]], position: LineCol { line: 17, col: 9 } }, tags: [], position: LineCol { line: 16, col: 7 } }), tags: [], position: LineCol { line: 17, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["2", "3", "4"]], position: LineCol { line: 17, col: 9 } }, tags: [], position: LineCol { line: 16, col: 7 } }), tags: [], position: LineCol { line: 17, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["2", "3", "4"]], position: LineCol { line: 17, col: 9 } }, tags: [], position: LineCol { line: 16, col: 7 } }), tags: [], position: LineCol { line: 17, col: 7 } }, Step(Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)]))))))) -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["2", "3", "4"]], position: LineCol { line: 17, col: 9 } }, tags: [], position: LineCol { line: 16, col: 7 } }), tags: [], position: LineCol { line: 17, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["2", "3", "4"]], position: LineCol { line: 17, col: 9 } }, tags: [], position: LineCol { line: 16, col: 7 } }), tags: [], position: LineCol { line: 17, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["2", "3", "4"]], position: LineCol { line: 17, col: 9 } }, tags: [], position: LineCol { line: 16, col: 7 } }), tags: [], position: LineCol { line: 17, col: 7 } }, Step(Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }, Started)))) -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["2", "3", "4"]], position: LineCol { line: 17, col: 9 } }, tags: [], position: LineCol { line: 16, col: 7 } }), tags: [], position: LineCol { line: 17, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["2", "3", "4"]], position: LineCol { line: 17, col: 9 } }, tags: [], position: LineCol { line: 16, col: 7 } }), tags: [], position: LineCol { line: 17, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["2", "3", "4"]], position: LineCol { line: 17, col: 9 } }, tags: [], position: LineCol { line: 16, col: 7 } }), tags: [], position: LineCol { line: 17, col: 7 } }, Step(Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)]))))))) -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["2", "3", "4"]], position: LineCol { line: 17, col: 9 } }, tags: [], position: LineCol { line: 16, col: 7 } }), tags: [], position: LineCol { line: 17, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["2", "3", "4"]], position: LineCol { line: 17, col: 9 } }, tags: [], position: LineCol { line: 16, col: 7 } }), tags: [], position: LineCol { line: 17, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["2", "3", "4"]], position: LineCol { line: 17, col: 9 } }, tags: [], position: LineCol { line: 16, col: 7 } }), tags: [], position: LineCol { line: 17, col: 7 } }, Finished))) -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["2", "3", "4"]], position: LineCol { line: 17, col: 9 } }, tags: [], position: LineCol { line: 16, col: 7 } }), tags: [], position: LineCol { line: 17, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["2", "3", "4"]], position: LineCol { line: 17, col: 9 } }, tags: [], position: LineCol { line: 16, col: 7 } }), tags: [], position: LineCol { line: 17, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Finished)) -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["2", "3", "4"]], position: LineCol { line: 17, col: 9 } }, tags: [], position: LineCol { line: 16, col: 7 } }), tags: [], position: LineCol { line: 17, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Finished) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["2", "3", "4"]], position: LineCol { line: 17, col: 9 } }, tags: [], position: LineCol { line: 16, col: 7 } }), tags: [], position: LineCol { line: 17, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Started) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["2", "3", "4"]], position: LineCol { line: 17, col: 9 } }, tags: [], position: LineCol { line: 16, col: 7 } }), tags: [], position: LineCol { line: 17, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["2", "3", "4"]], position: LineCol { line: 17, col: 9 } }, tags: [], position: LineCol { line: 16, col: 7 } }), tags: [], position: LineCol { line: 17, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Started)) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["2", "3", "4"]], position: LineCol { line: 17, col: 9 } }, tags: [], position: LineCol { line: 16, col: 7 } }), tags: [], position: LineCol { line: 17, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["2", "3", "4"]], position: LineCol { line: 17, col: 9 } }, tags: [], position: LineCol { line: 16, col: 7 } }), tags: [], position: LineCol { line: 17, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["2", "3", "4"]], position: LineCol { line: 17, col: 9 } }, tags: [], position: LineCol { line: 16, col: 7 } }), tags: [], position: LineCol { line: 17, col: 7 } }, Started))) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["2", "3", "4"]], position: LineCol { line: 17, col: 9 } }, tags: [], position: LineCol { line: 16, col: 7 } }), tags: [], position: LineCol { line: 17, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["2", "3", "4"]], position: LineCol { line: 17, col: 9 } }, tags: [], position: LineCol { line: 16, col: 7 } }), tags: [], position: LineCol { line: 17, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["2", "3", "4"]], position: LineCol { line: 17, col: 9 } }, tags: [], position: LineCol { line: 16, col: 7 } }), tags: [], position: LineCol { line: 17, col: 7 } }, Background(Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Started)))) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["2", "3", "4"]], position: LineCol { line: 17, col: 9 } }, tags: [], position: LineCol { line: 16, col: 7 } }), tags: [], position: LineCol { line: 17, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["2", "3", "4"]], position: LineCol { line: 17, col: 9 } }, tags: [], position: LineCol { line: 16, col: 7 } }), tags: [], position: LineCol { line: 17, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["2", "3", "4"]], position: LineCol { line: 17, col: 9 } }, tags: [], position: LineCol { line: 16, col: 7 } }), tags: [], position: LineCol { line: 17, col: 7 } }, Background(Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)]))))))) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["2", "3", "4"]], position: LineCol { line: 17, col: 9 } }, tags: [], position: LineCol { line: 16, col: 7 } }), tags: [], position: LineCol { line: 17, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["2", "3", "4"]], position: LineCol { line: 17, col: 9 } }, tags: [], position: LineCol { line: 16, col: 7 } }), tags: [], position: LineCol { line: 17, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["2", "3", "4"]], position: LineCol { line: 17, col: 9 } }, tags: [], position: LineCol { line: 16, col: 7 } }), tags: [], position: LineCol { line: 17, col: 7 } }, Background(Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Started)))) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["2", "3", "4"]], position: LineCol { line: 17, col: 9 } }, tags: [], position: LineCol { line: 16, col: 7 } }), tags: [], position: LineCol { line: 17, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["2", "3", "4"]], position: LineCol { line: 17, col: 9 } }, tags: [], position: LineCol { line: 16, col: 7 } }), tags: [], position: LineCol { line: 17, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["2", "3", "4"]], position: LineCol { line: 17, col: 9 } }, tags: [], position: LineCol { line: 16, col: 7 } }), tags: [], position: LineCol { line: 17, col: 7 } }, Background(Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)]))))))) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["2", "3", "4"]], position: LineCol { line: 17, col: 9 } }, tags: [], position: LineCol { line: 16, col: 7 } }), tags: [], position: LineCol { line: 17, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["2", "3", "4"]], position: LineCol { line: 17, col: 9 } }, tags: [], position: LineCol { line: 16, col: 7 } }), tags: [], position: LineCol { line: 17, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["2", "3", "4"]], position: LineCol { line: 17, col: 9 } }, tags: [], position: LineCol { line: 16, col: 7 } }), tags: [], position: LineCol { line: 17, col: 7 } }, Step(Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Started)))) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["2", "3", "4"]], position: LineCol { line: 17, col: 9 } }, tags: [], position: LineCol { line: 16, col: 7 } }), tags: [], position: LineCol { line: 17, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["2", "3", "4"]], position: LineCol { line: 17, col: 9 } }, tags: [], position: LineCol { line: 16, col: 7 } }), tags: [], position: LineCol { line: 17, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["2", "3", "4"]], position: LineCol { line: 17, col: 9 } }, tags: [], position: LineCol { line: 16, col: 7 } }), tags: [], position: LineCol { line: 17, col: 7 } }, Step(Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)]))))))) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["2", "3", "4"]], position: LineCol { line: 17, col: 9 } }, tags: [], position: LineCol { line: 16, col: 7 } }), tags: [], position: LineCol { line: 17, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["2", "3", "4"]], position: LineCol { line: 17, col: 9 } }, tags: [], position: LineCol { line: 16, col: 7 } }), tags: [], position: LineCol { line: 17, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["2", "3", "4"]], position: LineCol { line: 17, col: 9 } }, tags: [], position: LineCol { line: 16, col: 7 } }), tags: [], position: LineCol { line: 17, col: 7 } }, Step(Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Started)))) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["2", "3", "4"]], position: LineCol { line: 17, col: 9 } }, tags: [], position: LineCol { line: 16, col: 7 } }), tags: [], position: LineCol { line: 17, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["2", "3", "4"]], position: LineCol { line: 17, col: 9 } }, tags: [], position: LineCol { line: 16, col: 7 } }), tags: [], position: LineCol { line: 17, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["2", "3", "4"]], position: LineCol { line: 17, col: 9 } }, tags: [], position: LineCol { line: 16, col: 7 } }), tags: [], position: LineCol { line: 17, col: 7 } }, Step(Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)]))))))) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["2", "3", "4"]], position: LineCol { line: 17, col: 9 } }, tags: [], position: LineCol { line: 16, col: 7 } }), tags: [], position: LineCol { line: 17, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["2", "3", "4"]], position: LineCol { line: 17, col: 9 } }, tags: [], position: LineCol { line: 16, col: 7 } }), tags: [], position: LineCol { line: 17, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["2", "3", "4"]], position: LineCol { line: 17, col: 9 } }, tags: [], position: LineCol { line: 16, col: 7 } }), tags: [], position: LineCol { line: 17, col: 7 } }, Step(Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }, Started)))) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["2", "3", "4"]], position: LineCol { line: 17, col: 9 } }, tags: [], position: LineCol { line: 16, col: 7 } }), tags: [], position: LineCol { line: 17, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["2", "3", "4"]], position: LineCol { line: 17, col: 9 } }, tags: [], position: LineCol { line: 16, col: 7 } }), tags: [], position: LineCol { line: 17, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["2", "3", "4"]], position: LineCol { line: 17, col: 9 } }, tags: [], position: LineCol { line: 16, col: 7 } }), tags: [], position: LineCol { line: 17, col: 7 } }, Step(Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)]))))))) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["2", "3", "4"]], position: LineCol { line: 17, col: 9 } }, tags: [], position: LineCol { line: 16, col: 7 } }), tags: [], position: LineCol { line: 17, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["2", "3", "4"]], position: LineCol { line: 17, col: 9 } }, tags: [], position: LineCol { line: 16, col: 7 } }), tags: [], position: LineCol { line: 17, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["2", "3", "4"]], position: LineCol { line: 17, col: 9 } }, tags: [], position: LineCol { line: 16, col: 7 } }), tags: [], position: LineCol { line: 17, col: 7 } }, Finished))) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["2", "3", "4"]], position: LineCol { line: 17, col: 9 } }, tags: [], position: LineCol { line: 16, col: 7 } }), tags: [], position: LineCol { line: 17, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["2", "3", "4"]], position: LineCol { line: 17, col: 9 } }, tags: [], position: LineCol { line: 16, col: 7 } }), tags: [], position: LineCol { line: 17, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Finished)) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], position: LineCol { line: 8, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 12, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 13, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 14, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["2", "3", "4"]], position: LineCol { line: 17, col: 9 } }, tags: [], position: LineCol { line: 16, col: 7 } }), tags: [], position: LineCol { line: 17, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Finished) Finished diff --git a/tests/features/output/background_rule_outline.feature.out b/tests/features/output/background_rule_outline.feature.out index 6907ee06..8b95177c 100644 --- a/tests/features/output/background_rule_outline.feature.out +++ b/tests/features/output/background_rule_outline.feature.out @@ -1,16 +1,16 @@ Started -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "outline", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 14, col: 9 } }, tags: [], position: LineCol { line: 13, col: 7 } }), tags: [], position: LineCol { line: 14, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Started) -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "outline", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 14, col: 9 } }, tags: [], position: LineCol { line: 13, col: 7 } }), tags: [], position: LineCol { line: 14, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "outline", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 14, col: 9 } }, tags: [], position: LineCol { line: 13, col: 7 } }), tags: [], position: LineCol { line: 14, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Started)) -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "outline", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 14, col: 9 } }, tags: [], position: LineCol { line: 13, col: 7 } }), tags: [], position: LineCol { line: 14, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "outline", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 14, col: 9 } }, tags: [], position: LineCol { line: 13, col: 7 } }), tags: [], position: LineCol { line: 14, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 14, col: 9 } }, tags: [], position: LineCol { line: 13, col: 7 } }), tags: [], position: LineCol { line: 14, col: 7 } }, Started))) -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "outline", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 14, col: 9 } }, tags: [], position: LineCol { line: 13, col: 7 } }), tags: [], position: LineCol { line: 14, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "outline", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 14, col: 9 } }, tags: [], position: LineCol { line: 13, col: 7 } }), tags: [], position: LineCol { line: 14, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 14, col: 9 } }, tags: [], position: LineCol { line: 13, col: 7 } }), tags: [], position: LineCol { line: 14, col: 7 } }, Background(Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Started)))) -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "outline", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 14, col: 9 } }, tags: [], position: LineCol { line: 13, col: 7 } }), tags: [], position: LineCol { line: 14, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "outline", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 14, col: 9 } }, tags: [], position: LineCol { line: 13, col: 7 } }), tags: [], position: LineCol { line: 14, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 14, col: 9 } }, tags: [], position: LineCol { line: 13, col: 7 } }), tags: [], position: LineCol { line: 14, col: 7 } }, Background(Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)]))))))) -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "outline", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 14, col: 9 } }, tags: [], position: LineCol { line: 13, col: 7 } }), tags: [], position: LineCol { line: 14, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "outline", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 14, col: 9 } }, tags: [], position: LineCol { line: 13, col: 7 } }), tags: [], position: LineCol { line: 14, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 14, col: 9 } }, tags: [], position: LineCol { line: 13, col: 7 } }), tags: [], position: LineCol { line: 14, col: 7 } }, Step(Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Started)))) -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "outline", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 14, col: 9 } }, tags: [], position: LineCol { line: 13, col: 7 } }), tags: [], position: LineCol { line: 14, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "outline", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 14, col: 9 } }, tags: [], position: LineCol { line: 13, col: 7 } }), tags: [], position: LineCol { line: 14, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 14, col: 9 } }, tags: [], position: LineCol { line: 13, col: 7 } }), tags: [], position: LineCol { line: 14, col: 7 } }, Step(Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)]))))))) -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "outline", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 14, col: 9 } }, tags: [], position: LineCol { line: 13, col: 7 } }), tags: [], position: LineCol { line: 14, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "outline", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 14, col: 9 } }, tags: [], position: LineCol { line: 13, col: 7 } }), tags: [], position: LineCol { line: 14, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 14, col: 9 } }, tags: [], position: LineCol { line: 13, col: 7 } }), tags: [], position: LineCol { line: 14, col: 7 } }, Step(Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Started)))) -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "outline", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 14, col: 9 } }, tags: [], position: LineCol { line: 13, col: 7 } }), tags: [], position: LineCol { line: 14, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "outline", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 14, col: 9 } }, tags: [], position: LineCol { line: 13, col: 7 } }), tags: [], position: LineCol { line: 14, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 14, col: 9 } }, tags: [], position: LineCol { line: 13, col: 7 } }), tags: [], position: LineCol { line: 14, col: 7 } }, Step(Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)]))))))) -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "outline", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 14, col: 9 } }, tags: [], position: LineCol { line: 13, col: 7 } }), tags: [], position: LineCol { line: 14, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "outline", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 14, col: 9 } }, tags: [], position: LineCol { line: 13, col: 7 } }), tags: [], position: LineCol { line: 14, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 14, col: 9 } }, tags: [], position: LineCol { line: 13, col: 7 } }), tags: [], position: LineCol { line: 14, col: 7 } }, Step(Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }, Started)))) -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "outline", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 14, col: 9 } }, tags: [], position: LineCol { line: 13, col: 7 } }), tags: [], position: LineCol { line: 14, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "outline", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 14, col: 9 } }, tags: [], position: LineCol { line: 13, col: 7 } }), tags: [], position: LineCol { line: 14, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 14, col: 9 } }, tags: [], position: LineCol { line: 13, col: 7 } }), tags: [], position: LineCol { line: 14, col: 7 } }, Step(Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)]))))))) -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "outline", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 14, col: 9 } }, tags: [], position: LineCol { line: 13, col: 7 } }), tags: [], position: LineCol { line: 14, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "outline", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 14, col: 9 } }, tags: [], position: LineCol { line: 13, col: 7 } }), tags: [], position: LineCol { line: 14, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 14, col: 9 } }, tags: [], position: LineCol { line: 13, col: 7 } }), tags: [], position: LineCol { line: 14, col: 7 } }, Finished))) -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "outline", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 14, col: 9 } }, tags: [], position: LineCol { line: 13, col: 7 } }), tags: [], position: LineCol { line: 14, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "outline", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 14, col: 9 } }, tags: [], position: LineCol { line: 13, col: 7 } }), tags: [], position: LineCol { line: 14, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Finished)) -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "outline", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 14, col: 9 } }, tags: [], position: LineCol { line: 13, col: 7 } }), tags: [], position: LineCol { line: 14, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Finished) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "outline", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 14, col: 9 } }, tags: [], position: LineCol { line: 13, col: 7 } }), tags: [], position: LineCol { line: 14, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Started) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "outline", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 14, col: 9 } }, tags: [], position: LineCol { line: 13, col: 7 } }), tags: [], position: LineCol { line: 14, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "outline", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 14, col: 9 } }, tags: [], position: LineCol { line: 13, col: 7 } }), tags: [], position: LineCol { line: 14, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Started)) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "outline", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 14, col: 9 } }, tags: [], position: LineCol { line: 13, col: 7 } }), tags: [], position: LineCol { line: 14, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "outline", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 14, col: 9 } }, tags: [], position: LineCol { line: 13, col: 7 } }), tags: [], position: LineCol { line: 14, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 14, col: 9 } }, tags: [], position: LineCol { line: 13, col: 7 } }), tags: [], position: LineCol { line: 14, col: 7 } }, Started))) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "outline", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 14, col: 9 } }, tags: [], position: LineCol { line: 13, col: 7 } }), tags: [], position: LineCol { line: 14, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "outline", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 14, col: 9 } }, tags: [], position: LineCol { line: 13, col: 7 } }), tags: [], position: LineCol { line: 14, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 14, col: 9 } }, tags: [], position: LineCol { line: 13, col: 7 } }), tags: [], position: LineCol { line: 14, col: 7 } }, Background(Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Started)))) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "outline", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 14, col: 9 } }, tags: [], position: LineCol { line: 13, col: 7 } }), tags: [], position: LineCol { line: 14, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "outline", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 14, col: 9 } }, tags: [], position: LineCol { line: 13, col: 7 } }), tags: [], position: LineCol { line: 14, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 14, col: 9 } }, tags: [], position: LineCol { line: 13, col: 7 } }), tags: [], position: LineCol { line: 14, col: 7 } }, Background(Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)]))))))) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "outline", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 14, col: 9 } }, tags: [], position: LineCol { line: 13, col: 7 } }), tags: [], position: LineCol { line: 14, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "outline", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 14, col: 9 } }, tags: [], position: LineCol { line: 13, col: 7 } }), tags: [], position: LineCol { line: 14, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 14, col: 9 } }, tags: [], position: LineCol { line: 13, col: 7 } }), tags: [], position: LineCol { line: 14, col: 7 } }, Step(Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Started)))) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "outline", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 14, col: 9 } }, tags: [], position: LineCol { line: 13, col: 7 } }), tags: [], position: LineCol { line: 14, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "outline", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 14, col: 9 } }, tags: [], position: LineCol { line: 13, col: 7 } }), tags: [], position: LineCol { line: 14, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 14, col: 9 } }, tags: [], position: LineCol { line: 13, col: 7 } }), tags: [], position: LineCol { line: 14, col: 7 } }, Step(Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)]))))))) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "outline", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 14, col: 9 } }, tags: [], position: LineCol { line: 13, col: 7 } }), tags: [], position: LineCol { line: 14, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "outline", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 14, col: 9 } }, tags: [], position: LineCol { line: 13, col: 7 } }), tags: [], position: LineCol { line: 14, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 14, col: 9 } }, tags: [], position: LineCol { line: 13, col: 7 } }), tags: [], position: LineCol { line: 14, col: 7 } }, Step(Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Started)))) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "outline", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 14, col: 9 } }, tags: [], position: LineCol { line: 13, col: 7 } }), tags: [], position: LineCol { line: 14, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "outline", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 14, col: 9 } }, tags: [], position: LineCol { line: 13, col: 7 } }), tags: [], position: LineCol { line: 14, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 14, col: 9 } }, tags: [], position: LineCol { line: 13, col: 7 } }), tags: [], position: LineCol { line: 14, col: 7 } }, Step(Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)]))))))) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "outline", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 14, col: 9 } }, tags: [], position: LineCol { line: 13, col: 7 } }), tags: [], position: LineCol { line: 14, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "outline", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 14, col: 9 } }, tags: [], position: LineCol { line: 13, col: 7 } }), tags: [], position: LineCol { line: 14, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 14, col: 9 } }, tags: [], position: LineCol { line: 13, col: 7 } }), tags: [], position: LineCol { line: 14, col: 7 } }, Step(Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }, Started)))) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "outline", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 14, col: 9 } }, tags: [], position: LineCol { line: 13, col: 7 } }), tags: [], position: LineCol { line: 14, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "outline", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 14, col: 9 } }, tags: [], position: LineCol { line: 13, col: 7 } }), tags: [], position: LineCol { line: 14, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 14, col: 9 } }, tags: [], position: LineCol { line: 13, col: 7 } }), tags: [], position: LineCol { line: 14, col: 7 } }, Step(Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)]))))))) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "outline", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 14, col: 9 } }, tags: [], position: LineCol { line: 13, col: 7 } }), tags: [], position: LineCol { line: 14, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "outline", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 14, col: 9 } }, tags: [], position: LineCol { line: 13, col: 7 } }), tags: [], position: LineCol { line: 14, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 14, col: 9 } }, tags: [], position: LineCol { line: 13, col: 7 } }), tags: [], position: LineCol { line: 14, col: 7 } }, Finished))) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "outline", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 14, col: 9 } }, tags: [], position: LineCol { line: 13, col: 7 } }), tags: [], position: LineCol { line: 14, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "outline", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 14, col: 9 } }, tags: [], position: LineCol { line: 13, col: 7 } }), tags: [], position: LineCol { line: 14, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }, Finished)) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [], rules: [Rule { keyword: "Rule", name: "outline", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 14, col: 9 } }, tags: [], position: LineCol { line: 13, col: 7 } }), tags: [], position: LineCol { line: 14, col: 7 } }], tags: [], position: LineCol { line: 6, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Finished) Finished diff --git a/tests/features/output/background_scenario.feature.out b/tests/features/output/background_scenario.feature.out index b1b2ce86..b8d48a3f 100644 --- a/tests/features/output/background_scenario.feature.out +++ b/tests/features/output/background_scenario.feature.out @@ -1,14 +1,14 @@ Started -Feature(Feature { keyword: "Feature", name: "output", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], examples: None, tags: [], position: LineCol { line: 6, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Started) -Feature(Feature { keyword: "Feature", name: "output", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], examples: None, tags: [], position: LineCol { line: 6, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], examples: None, tags: [], position: LineCol { line: 6, col: 5 } }, Started)) -Feature(Feature { keyword: "Feature", name: "output", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], examples: None, tags: [], position: LineCol { line: 6, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], examples: None, tags: [], position: LineCol { line: 6, col: 5 } }, Background(Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Started))) -Feature(Feature { keyword: "Feature", name: "output", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], examples: None, tags: [], position: LineCol { line: 6, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], examples: None, tags: [], position: LineCol { line: 6, col: 5 } }, Background(Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)])))))) -Feature(Feature { keyword: "Feature", name: "output", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], examples: None, tags: [], position: LineCol { line: 6, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], examples: None, tags: [], position: LineCol { line: 6, col: 5 } }, Step(Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 7 } }, Started))) -Feature(Feature { keyword: "Feature", name: "output", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], examples: None, tags: [], position: LineCol { line: 6, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], examples: None, tags: [], position: LineCol { line: 6, col: 5 } }, Step(Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 7 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)])))))) -Feature(Feature { keyword: "Feature", name: "output", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], examples: None, tags: [], position: LineCol { line: 6, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], examples: None, tags: [], position: LineCol { line: 6, col: 5 } }, Step(Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Started))) -Feature(Feature { keyword: "Feature", name: "output", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], examples: None, tags: [], position: LineCol { line: 6, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], examples: None, tags: [], position: LineCol { line: 6, col: 5 } }, Step(Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)])))))) -Feature(Feature { keyword: "Feature", name: "output", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], examples: None, tags: [], position: LineCol { line: 6, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], examples: None, tags: [], position: LineCol { line: 6, col: 5 } }, Step(Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Started))) -Feature(Feature { keyword: "Feature", name: "output", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], examples: None, tags: [], position: LineCol { line: 6, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], examples: None, tags: [], position: LineCol { line: 6, col: 5 } }, Step(Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)])))))) -Feature(Feature { keyword: "Feature", name: "output", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], examples: None, tags: [], position: LineCol { line: 6, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], examples: None, tags: [], position: LineCol { line: 6, col: 5 } }, Finished)) -Feature(Feature { keyword: "Feature", name: "output", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], examples: None, tags: [], position: LineCol { line: 6, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Finished) +Feature(Feature { keyword: "Feature", name: "output", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], examples: None, tags: [], position: LineCol { line: 6, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Started) +Feature(Feature { keyword: "Feature", name: "output", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], examples: None, tags: [], position: LineCol { line: 6, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], examples: None, tags: [], position: LineCol { line: 6, col: 5 } }, Started)) +Feature(Feature { keyword: "Feature", name: "output", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], examples: None, tags: [], position: LineCol { line: 6, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], examples: None, tags: [], position: LineCol { line: 6, col: 5 } }, Background(Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Started))) +Feature(Feature { keyword: "Feature", name: "output", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], examples: None, tags: [], position: LineCol { line: 6, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], examples: None, tags: [], position: LineCol { line: 6, col: 5 } }, Background(Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)])))))) +Feature(Feature { keyword: "Feature", name: "output", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], examples: None, tags: [], position: LineCol { line: 6, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], examples: None, tags: [], position: LineCol { line: 6, col: 5 } }, Step(Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 7 } }, Started))) +Feature(Feature { keyword: "Feature", name: "output", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], examples: None, tags: [], position: LineCol { line: 6, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], examples: None, tags: [], position: LineCol { line: 6, col: 5 } }, Step(Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 7 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)])))))) +Feature(Feature { keyword: "Feature", name: "output", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], examples: None, tags: [], position: LineCol { line: 6, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], examples: None, tags: [], position: LineCol { line: 6, col: 5 } }, Step(Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Started))) +Feature(Feature { keyword: "Feature", name: "output", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], examples: None, tags: [], position: LineCol { line: 6, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], examples: None, tags: [], position: LineCol { line: 6, col: 5 } }, Step(Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)])))))) +Feature(Feature { keyword: "Feature", name: "output", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], examples: None, tags: [], position: LineCol { line: 6, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], examples: None, tags: [], position: LineCol { line: 6, col: 5 } }, Step(Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Started))) +Feature(Feature { keyword: "Feature", name: "output", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], examples: None, tags: [], position: LineCol { line: 6, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], examples: None, tags: [], position: LineCol { line: 6, col: 5 } }, Step(Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)])))))) +Feature(Feature { keyword: "Feature", name: "output", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], examples: None, tags: [], position: LineCol { line: 6, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], examples: None, tags: [], position: LineCol { line: 6, col: 5 } }, Finished)) +Feature(Feature { keyword: "Feature", name: "output", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }], examples: None, tags: [], position: LineCol { line: 6, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Finished) Finished diff --git a/tests/features/output/background_scenario_outline.feature.out b/tests/features/output/background_scenario_outline.feature.out index b3bd01c5..50c32db5 100644 --- a/tests/features/output/background_scenario_outline.feature.out +++ b/tests/features/output/background_scenario_outline.feature.out @@ -1,14 +1,14 @@ Started -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Started) -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }, Started)) -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }, Background(Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Started))) -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }, Background(Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)])))))) -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }, Step(Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 5 } }, Started))) -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }, Step(Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 5 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)])))))) -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }, Step(Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Started))) -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }, Step(Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)])))))) -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }, Step(Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }, Started))) -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }, Step(Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)])))))) -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }, Finished)) -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Finished) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Started) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }, Started)) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }, Background(Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Started))) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }, Background(Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)])))))) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }, Step(Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 5 } }, Started))) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }, Step(Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 5 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)])))))) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }, Step(Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Started))) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }, Step(Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)])))))) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }, Step(Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }, Started))) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }, Step(Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)])))))) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }, Finished)) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }], position: LineCol { line: 3, col: 3 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 7, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Finished) Finished diff --git a/tests/features/output/non_default_lang.feature.out b/tests/features/output/non_default_lang.feature.out index bb3c7800..c904682b 100644 --- a/tests/features/output/non_default_lang.feature.out +++ b/tests/features/output/non_default_lang.feature.out @@ -1,12 +1,12 @@ Started -Feature(Feature { keyword: "Egenskap", name: "output", description: None, background: None, scenarios: [Scenario { keyword: "Eksempel", name: "output", steps: [Step { keyword: "Gitt", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "Når", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }, Step { keyword: "Så", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 5 } }], examples: None, tags: [], position: LineCol { line: 3, col: 3 } }], rules: [], tags: [], position: LineCol { line: 2, col: 1 }, path: None }, Started) -Feature(Feature { keyword: "Egenskap", name: "output", description: None, background: None, scenarios: [Scenario { keyword: "Eksempel", name: "output", steps: [Step { keyword: "Gitt", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "Når", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }, Step { keyword: "Så", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 5 } }], examples: None, tags: [], position: LineCol { line: 3, col: 3 } }], rules: [], tags: [], position: LineCol { line: 2, col: 1 }, path: None }, Scenario(Scenario { keyword: "Eksempel", name: "output", steps: [Step { keyword: "Gitt", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "Når", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }, Step { keyword: "Så", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 5 } }], examples: None, tags: [], position: LineCol { line: 3, col: 3 } }, Started)) -Feature(Feature { keyword: "Egenskap", name: "output", description: None, background: None, scenarios: [Scenario { keyword: "Eksempel", name: "output", steps: [Step { keyword: "Gitt", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "Når", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }, Step { keyword: "Så", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 5 } }], examples: None, tags: [], position: LineCol { line: 3, col: 3 } }], rules: [], tags: [], position: LineCol { line: 2, col: 1 }, path: None }, Scenario(Scenario { keyword: "Eksempel", name: "output", steps: [Step { keyword: "Gitt", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "Når", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }, Step { keyword: "Så", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 5 } }], examples: None, tags: [], position: LineCol { line: 3, col: 3 } }, Step(Step { keyword: "Gitt", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Started))) -Feature(Feature { keyword: "Egenskap", name: "output", description: None, background: None, scenarios: [Scenario { keyword: "Eksempel", name: "output", steps: [Step { keyword: "Gitt", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "Når", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }, Step { keyword: "Så", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 5 } }], examples: None, tags: [], position: LineCol { line: 3, col: 3 } }], rules: [], tags: [], position: LineCol { line: 2, col: 1 }, path: None }, Scenario(Scenario { keyword: "Eksempel", name: "output", steps: [Step { keyword: "Gitt", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "Når", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }, Step { keyword: "Så", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 5 } }], examples: None, tags: [], position: LineCol { line: 3, col: 3 } }, Step(Step { keyword: "Gitt", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)])))))) -Feature(Feature { keyword: "Egenskap", name: "output", description: None, background: None, scenarios: [Scenario { keyword: "Eksempel", name: "output", steps: [Step { keyword: "Gitt", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "Når", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }, Step { keyword: "Så", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 5 } }], examples: None, tags: [], position: LineCol { line: 3, col: 3 } }], rules: [], tags: [], position: LineCol { line: 2, col: 1 }, path: None }, Scenario(Scenario { keyword: "Eksempel", name: "output", steps: [Step { keyword: "Gitt", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "Når", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }, Step { keyword: "Så", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 5 } }], examples: None, tags: [], position: LineCol { line: 3, col: 3 } }, Step(Step { keyword: "Når", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }, Started))) -Feature(Feature { keyword: "Egenskap", name: "output", description: None, background: None, scenarios: [Scenario { keyword: "Eksempel", name: "output", steps: [Step { keyword: "Gitt", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "Når", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }, Step { keyword: "Så", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 5 } }], examples: None, tags: [], position: LineCol { line: 3, col: 3 } }], rules: [], tags: [], position: LineCol { line: 2, col: 1 }, path: None }, Scenario(Scenario { keyword: "Eksempel", name: "output", steps: [Step { keyword: "Gitt", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "Når", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }, Step { keyword: "Så", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 5 } }], examples: None, tags: [], position: LineCol { line: 3, col: 3 } }, Step(Step { keyword: "Når", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)])))))) -Feature(Feature { keyword: "Egenskap", name: "output", description: None, background: None, scenarios: [Scenario { keyword: "Eksempel", name: "output", steps: [Step { keyword: "Gitt", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "Når", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }, Step { keyword: "Så", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 5 } }], examples: None, tags: [], position: LineCol { line: 3, col: 3 } }], rules: [], tags: [], position: LineCol { line: 2, col: 1 }, path: None }, Scenario(Scenario { keyword: "Eksempel", name: "output", steps: [Step { keyword: "Gitt", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "Når", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }, Step { keyword: "Så", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 5 } }], examples: None, tags: [], position: LineCol { line: 3, col: 3 } }, Step(Step { keyword: "Så", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 5 } }, Started))) -Feature(Feature { keyword: "Egenskap", name: "output", description: None, background: None, scenarios: [Scenario { keyword: "Eksempel", name: "output", steps: [Step { keyword: "Gitt", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "Når", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }, Step { keyword: "Så", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 5 } }], examples: None, tags: [], position: LineCol { line: 3, col: 3 } }], rules: [], tags: [], position: LineCol { line: 2, col: 1 }, path: None }, Scenario(Scenario { keyword: "Eksempel", name: "output", steps: [Step { keyword: "Gitt", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "Når", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }, Step { keyword: "Så", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 5 } }], examples: None, tags: [], position: LineCol { line: 3, col: 3 } }, Step(Step { keyword: "Så", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 5 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)])))))) -Feature(Feature { keyword: "Egenskap", name: "output", description: None, background: None, scenarios: [Scenario { keyword: "Eksempel", name: "output", steps: [Step { keyword: "Gitt", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "Når", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }, Step { keyword: "Så", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 5 } }], examples: None, tags: [], position: LineCol { line: 3, col: 3 } }], rules: [], tags: [], position: LineCol { line: 2, col: 1 }, path: None }, Scenario(Scenario { keyword: "Eksempel", name: "output", steps: [Step { keyword: "Gitt", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "Når", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }, Step { keyword: "Så", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 5 } }], examples: None, tags: [], position: LineCol { line: 3, col: 3 } }, Finished)) -Feature(Feature { keyword: "Egenskap", name: "output", description: None, background: None, scenarios: [Scenario { keyword: "Eksempel", name: "output", steps: [Step { keyword: "Gitt", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "Når", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }, Step { keyword: "Så", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 5 } }], examples: None, tags: [], position: LineCol { line: 3, col: 3 } }], rules: [], tags: [], position: LineCol { line: 2, col: 1 }, path: None }, Finished) +Feature(Feature { keyword: "Egenskap", name: "output", description: None, background: None, scenarios: [Scenario { keyword: "Eksempel", name: "output", steps: [Step { keyword: "Gitt", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "Når", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }, Step { keyword: "Så", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 5 } }], examples: None, tags: [], position: LineCol { line: 3, col: 3 } }], rules: [], tags: [], position: LineCol { line: 2, col: 1 }, }, Started) +Feature(Feature { keyword: "Egenskap", name: "output", description: None, background: None, scenarios: [Scenario { keyword: "Eksempel", name: "output", steps: [Step { keyword: "Gitt", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "Når", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }, Step { keyword: "Så", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 5 } }], examples: None, tags: [], position: LineCol { line: 3, col: 3 } }], rules: [], tags: [], position: LineCol { line: 2, col: 1 }, }, Scenario(Scenario { keyword: "Eksempel", name: "output", steps: [Step { keyword: "Gitt", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "Når", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }, Step { keyword: "Så", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 5 } }], examples: None, tags: [], position: LineCol { line: 3, col: 3 } }, Started)) +Feature(Feature { keyword: "Egenskap", name: "output", description: None, background: None, scenarios: [Scenario { keyword: "Eksempel", name: "output", steps: [Step { keyword: "Gitt", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "Når", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }, Step { keyword: "Så", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 5 } }], examples: None, tags: [], position: LineCol { line: 3, col: 3 } }], rules: [], tags: [], position: LineCol { line: 2, col: 1 }, }, Scenario(Scenario { keyword: "Eksempel", name: "output", steps: [Step { keyword: "Gitt", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "Når", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }, Step { keyword: "Så", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 5 } }], examples: None, tags: [], position: LineCol { line: 3, col: 3 } }, Step(Step { keyword: "Gitt", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Started))) +Feature(Feature { keyword: "Egenskap", name: "output", description: None, background: None, scenarios: [Scenario { keyword: "Eksempel", name: "output", steps: [Step { keyword: "Gitt", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "Når", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }, Step { keyword: "Så", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 5 } }], examples: None, tags: [], position: LineCol { line: 3, col: 3 } }], rules: [], tags: [], position: LineCol { line: 2, col: 1 }, }, Scenario(Scenario { keyword: "Eksempel", name: "output", steps: [Step { keyword: "Gitt", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "Når", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }, Step { keyword: "Så", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 5 } }], examples: None, tags: [], position: LineCol { line: 3, col: 3 } }, Step(Step { keyword: "Gitt", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)])))))) +Feature(Feature { keyword: "Egenskap", name: "output", description: None, background: None, scenarios: [Scenario { keyword: "Eksempel", name: "output", steps: [Step { keyword: "Gitt", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "Når", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }, Step { keyword: "Så", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 5 } }], examples: None, tags: [], position: LineCol { line: 3, col: 3 } }], rules: [], tags: [], position: LineCol { line: 2, col: 1 }, }, Scenario(Scenario { keyword: "Eksempel", name: "output", steps: [Step { keyword: "Gitt", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "Når", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }, Step { keyword: "Så", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 5 } }], examples: None, tags: [], position: LineCol { line: 3, col: 3 } }, Step(Step { keyword: "Når", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }, Started))) +Feature(Feature { keyword: "Egenskap", name: "output", description: None, background: None, scenarios: [Scenario { keyword: "Eksempel", name: "output", steps: [Step { keyword: "Gitt", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "Når", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }, Step { keyword: "Så", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 5 } }], examples: None, tags: [], position: LineCol { line: 3, col: 3 } }], rules: [], tags: [], position: LineCol { line: 2, col: 1 }, }, Scenario(Scenario { keyword: "Eksempel", name: "output", steps: [Step { keyword: "Gitt", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "Når", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }, Step { keyword: "Så", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 5 } }], examples: None, tags: [], position: LineCol { line: 3, col: 3 } }, Step(Step { keyword: "Når", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)])))))) +Feature(Feature { keyword: "Egenskap", name: "output", description: None, background: None, scenarios: [Scenario { keyword: "Eksempel", name: "output", steps: [Step { keyword: "Gitt", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "Når", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }, Step { keyword: "Så", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 5 } }], examples: None, tags: [], position: LineCol { line: 3, col: 3 } }], rules: [], tags: [], position: LineCol { line: 2, col: 1 }, }, Scenario(Scenario { keyword: "Eksempel", name: "output", steps: [Step { keyword: "Gitt", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "Når", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }, Step { keyword: "Så", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 5 } }], examples: None, tags: [], position: LineCol { line: 3, col: 3 } }, Step(Step { keyword: "Så", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 5 } }, Started))) +Feature(Feature { keyword: "Egenskap", name: "output", description: None, background: None, scenarios: [Scenario { keyword: "Eksempel", name: "output", steps: [Step { keyword: "Gitt", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "Når", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }, Step { keyword: "Så", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 5 } }], examples: None, tags: [], position: LineCol { line: 3, col: 3 } }], rules: [], tags: [], position: LineCol { line: 2, col: 1 }, }, Scenario(Scenario { keyword: "Eksempel", name: "output", steps: [Step { keyword: "Gitt", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "Når", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }, Step { keyword: "Så", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 5 } }], examples: None, tags: [], position: LineCol { line: 3, col: 3 } }, Step(Step { keyword: "Så", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 5 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)])))))) +Feature(Feature { keyword: "Egenskap", name: "output", description: None, background: None, scenarios: [Scenario { keyword: "Eksempel", name: "output", steps: [Step { keyword: "Gitt", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "Når", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }, Step { keyword: "Så", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 5 } }], examples: None, tags: [], position: LineCol { line: 3, col: 3 } }], rules: [], tags: [], position: LineCol { line: 2, col: 1 }, }, Scenario(Scenario { keyword: "Eksempel", name: "output", steps: [Step { keyword: "Gitt", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "Når", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }, Step { keyword: "Så", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 5 } }], examples: None, tags: [], position: LineCol { line: 3, col: 3 } }, Finished)) +Feature(Feature { keyword: "Egenskap", name: "output", description: None, background: None, scenarios: [Scenario { keyword: "Eksempel", name: "output", steps: [Step { keyword: "Gitt", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "Når", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }, Step { keyword: "Så", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 5 } }], examples: None, tags: [], position: LineCol { line: 3, col: 3 } }], rules: [], tags: [], position: LineCol { line: 2, col: 1 }, }, Finished) Finished diff --git a/tests/features/output/rule.feature.out b/tests/features/output/rule.feature.out index a2caba3e..ab3791b6 100644 --- a/tests/features/output/rule.feature.out +++ b/tests/features/output/rule.feature.out @@ -1,14 +1,14 @@ Started -Feature(Feature { keyword: "Feature", name: "output", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: None, tags: [], position: LineCol { line: 3, col: 5 } }], tags: [], position: LineCol { line: 2, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Started) -Feature(Feature { keyword: "Feature", name: "output", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: None, tags: [], position: LineCol { line: 3, col: 5 } }], tags: [], position: LineCol { line: 2, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: None, tags: [], position: LineCol { line: 3, col: 5 } }], tags: [], position: LineCol { line: 2, col: 3 } }, Started)) -Feature(Feature { keyword: "Feature", name: "output", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: None, tags: [], position: LineCol { line: 3, col: 5 } }], tags: [], position: LineCol { line: 2, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: None, tags: [], position: LineCol { line: 3, col: 5 } }], tags: [], position: LineCol { line: 2, col: 3 } }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: None, tags: [], position: LineCol { line: 3, col: 5 } }, Started))) -Feature(Feature { keyword: "Feature", name: "output", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: None, tags: [], position: LineCol { line: 3, col: 5 } }], tags: [], position: LineCol { line: 2, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: None, tags: [], position: LineCol { line: 3, col: 5 } }], tags: [], position: LineCol { line: 2, col: 3 } }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: None, tags: [], position: LineCol { line: 3, col: 5 } }, Step(Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Started)))) -Feature(Feature { keyword: "Feature", name: "output", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: None, tags: [], position: LineCol { line: 3, col: 5 } }], tags: [], position: LineCol { line: 2, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: None, tags: [], position: LineCol { line: 3, col: 5 } }], tags: [], position: LineCol { line: 2, col: 3 } }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: None, tags: [], position: LineCol { line: 3, col: 5 } }, Step(Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)]))))))) -Feature(Feature { keyword: "Feature", name: "output", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: None, tags: [], position: LineCol { line: 3, col: 5 } }], tags: [], position: LineCol { line: 2, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: None, tags: [], position: LineCol { line: 3, col: 5 } }], tags: [], position: LineCol { line: 2, col: 3 } }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: None, tags: [], position: LineCol { line: 3, col: 5 } }, Step(Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Started)))) -Feature(Feature { keyword: "Feature", name: "output", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: None, tags: [], position: LineCol { line: 3, col: 5 } }], tags: [], position: LineCol { line: 2, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: None, tags: [], position: LineCol { line: 3, col: 5 } }], tags: [], position: LineCol { line: 2, col: 3 } }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: None, tags: [], position: LineCol { line: 3, col: 5 } }, Step(Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)]))))))) -Feature(Feature { keyword: "Feature", name: "output", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: None, tags: [], position: LineCol { line: 3, col: 5 } }], tags: [], position: LineCol { line: 2, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: None, tags: [], position: LineCol { line: 3, col: 5 } }], tags: [], position: LineCol { line: 2, col: 3 } }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: None, tags: [], position: LineCol { line: 3, col: 5 } }, Step(Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }, Started)))) -Feature(Feature { keyword: "Feature", name: "output", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: None, tags: [], position: LineCol { line: 3, col: 5 } }], tags: [], position: LineCol { line: 2, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: None, tags: [], position: LineCol { line: 3, col: 5 } }], tags: [], position: LineCol { line: 2, col: 3 } }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: None, tags: [], position: LineCol { line: 3, col: 5 } }, Step(Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)]))))))) -Feature(Feature { keyword: "Feature", name: "output", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: None, tags: [], position: LineCol { line: 3, col: 5 } }], tags: [], position: LineCol { line: 2, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: None, tags: [], position: LineCol { line: 3, col: 5 } }], tags: [], position: LineCol { line: 2, col: 3 } }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: None, tags: [], position: LineCol { line: 3, col: 5 } }, Finished))) -Feature(Feature { keyword: "Feature", name: "output", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: None, tags: [], position: LineCol { line: 3, col: 5 } }], tags: [], position: LineCol { line: 2, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: None, tags: [], position: LineCol { line: 3, col: 5 } }], tags: [], position: LineCol { line: 2, col: 3 } }, Finished)) -Feature(Feature { keyword: "Feature", name: "output", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: None, tags: [], position: LineCol { line: 3, col: 5 } }], tags: [], position: LineCol { line: 2, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Finished) +Feature(Feature { keyword: "Feature", name: "output", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: None, tags: [], position: LineCol { line: 3, col: 5 } }], tags: [], position: LineCol { line: 2, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Started) +Feature(Feature { keyword: "Feature", name: "output", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: None, tags: [], position: LineCol { line: 3, col: 5 } }], tags: [], position: LineCol { line: 2, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: None, tags: [], position: LineCol { line: 3, col: 5 } }], tags: [], position: LineCol { line: 2, col: 3 } }, Started)) +Feature(Feature { keyword: "Feature", name: "output", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: None, tags: [], position: LineCol { line: 3, col: 5 } }], tags: [], position: LineCol { line: 2, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: None, tags: [], position: LineCol { line: 3, col: 5 } }], tags: [], position: LineCol { line: 2, col: 3 } }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: None, tags: [], position: LineCol { line: 3, col: 5 } }, Started))) +Feature(Feature { keyword: "Feature", name: "output", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: None, tags: [], position: LineCol { line: 3, col: 5 } }], tags: [], position: LineCol { line: 2, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: None, tags: [], position: LineCol { line: 3, col: 5 } }], tags: [], position: LineCol { line: 2, col: 3 } }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: None, tags: [], position: LineCol { line: 3, col: 5 } }, Step(Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Started)))) +Feature(Feature { keyword: "Feature", name: "output", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: None, tags: [], position: LineCol { line: 3, col: 5 } }], tags: [], position: LineCol { line: 2, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: None, tags: [], position: LineCol { line: 3, col: 5 } }], tags: [], position: LineCol { line: 2, col: 3 } }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: None, tags: [], position: LineCol { line: 3, col: 5 } }, Step(Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)]))))))) +Feature(Feature { keyword: "Feature", name: "output", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: None, tags: [], position: LineCol { line: 3, col: 5 } }], tags: [], position: LineCol { line: 2, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: None, tags: [], position: LineCol { line: 3, col: 5 } }], tags: [], position: LineCol { line: 2, col: 3 } }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: None, tags: [], position: LineCol { line: 3, col: 5 } }, Step(Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Started)))) +Feature(Feature { keyword: "Feature", name: "output", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: None, tags: [], position: LineCol { line: 3, col: 5 } }], tags: [], position: LineCol { line: 2, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: None, tags: [], position: LineCol { line: 3, col: 5 } }], tags: [], position: LineCol { line: 2, col: 3 } }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: None, tags: [], position: LineCol { line: 3, col: 5 } }, Step(Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)]))))))) +Feature(Feature { keyword: "Feature", name: "output", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: None, tags: [], position: LineCol { line: 3, col: 5 } }], tags: [], position: LineCol { line: 2, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: None, tags: [], position: LineCol { line: 3, col: 5 } }], tags: [], position: LineCol { line: 2, col: 3 } }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: None, tags: [], position: LineCol { line: 3, col: 5 } }, Step(Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }, Started)))) +Feature(Feature { keyword: "Feature", name: "output", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: None, tags: [], position: LineCol { line: 3, col: 5 } }], tags: [], position: LineCol { line: 2, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: None, tags: [], position: LineCol { line: 3, col: 5 } }], tags: [], position: LineCol { line: 2, col: 3 } }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: None, tags: [], position: LineCol { line: 3, col: 5 } }, Step(Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)]))))))) +Feature(Feature { keyword: "Feature", name: "output", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: None, tags: [], position: LineCol { line: 3, col: 5 } }], tags: [], position: LineCol { line: 2, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: None, tags: [], position: LineCol { line: 3, col: 5 } }], tags: [], position: LineCol { line: 2, col: 3 } }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: None, tags: [], position: LineCol { line: 3, col: 5 } }, Finished))) +Feature(Feature { keyword: "Feature", name: "output", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: None, tags: [], position: LineCol { line: 3, col: 5 } }], tags: [], position: LineCol { line: 2, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: None, tags: [], position: LineCol { line: 3, col: 5 } }], tags: [], position: LineCol { line: 2, col: 3 } }, Finished)) +Feature(Feature { keyword: "Feature", name: "output", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: None, tags: [], position: LineCol { line: 3, col: 5 } }], tags: [], position: LineCol { line: 2, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Finished) Finished diff --git a/tests/features/output/rule_background.feature.out b/tests/features/output/rule_background.feature.out index 7e4c5260..5c6f7117 100644 --- a/tests/features/output/rule_background.feature.out +++ b/tests/features/output/rule_background.feature.out @@ -1,16 +1,16 @@ Started -Feature(Feature { keyword: "Feature", name: "output", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], position: LineCol { line: 5, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 3, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Started) -Feature(Feature { keyword: "Feature", name: "output", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], position: LineCol { line: 5, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 3, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], position: LineCol { line: 5, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 3, col: 3 } }, Started)) -Feature(Feature { keyword: "Feature", name: "output", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], position: LineCol { line: 5, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 3, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], position: LineCol { line: 5, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 3, col: 3 } }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }, Started))) -Feature(Feature { keyword: "Feature", name: "output", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], position: LineCol { line: 5, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 3, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], position: LineCol { line: 5, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 3, col: 3 } }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }, Background(Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }, Started)))) -Feature(Feature { keyword: "Feature", name: "output", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], position: LineCol { line: 5, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 3, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], position: LineCol { line: 5, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 3, col: 3 } }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }, Background(Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)]))))))) -Feature(Feature { keyword: "Feature", name: "output", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], position: LineCol { line: 5, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 3, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], position: LineCol { line: 5, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 3, col: 3 } }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }, Step(Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Started)))) -Feature(Feature { keyword: "Feature", name: "output", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], position: LineCol { line: 5, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 3, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], position: LineCol { line: 5, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 3, col: 3 } }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }, Step(Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)]))))))) -Feature(Feature { keyword: "Feature", name: "output", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], position: LineCol { line: 5, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 3, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], position: LineCol { line: 5, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 3, col: 3 } }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }, Step(Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Started)))) -Feature(Feature { keyword: "Feature", name: "output", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], position: LineCol { line: 5, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 3, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], position: LineCol { line: 5, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 3, col: 3 } }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }, Step(Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)]))))))) -Feature(Feature { keyword: "Feature", name: "output", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], position: LineCol { line: 5, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 3, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], position: LineCol { line: 5, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 3, col: 3 } }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }, Step(Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }, Started)))) -Feature(Feature { keyword: "Feature", name: "output", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], position: LineCol { line: 5, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 3, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], position: LineCol { line: 5, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 3, col: 3 } }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }, Step(Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)]))))))) -Feature(Feature { keyword: "Feature", name: "output", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], position: LineCol { line: 5, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 3, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], position: LineCol { line: 5, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 3, col: 3 } }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }, Finished))) -Feature(Feature { keyword: "Feature", name: "output", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], position: LineCol { line: 5, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 3, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], position: LineCol { line: 5, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 3, col: 3 } }, Finished)) -Feature(Feature { keyword: "Feature", name: "output", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], position: LineCol { line: 5, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 3, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Finished) +Feature(Feature { keyword: "Feature", name: "output", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], position: LineCol { line: 5, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 3, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Started) +Feature(Feature { keyword: "Feature", name: "output", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], position: LineCol { line: 5, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 3, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], position: LineCol { line: 5, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 3, col: 3 } }, Started)) +Feature(Feature { keyword: "Feature", name: "output", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], position: LineCol { line: 5, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 3, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], position: LineCol { line: 5, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 3, col: 3 } }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }, Started))) +Feature(Feature { keyword: "Feature", name: "output", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], position: LineCol { line: 5, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 3, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], position: LineCol { line: 5, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 3, col: 3 } }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }, Background(Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }, Started)))) +Feature(Feature { keyword: "Feature", name: "output", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], position: LineCol { line: 5, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 3, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], position: LineCol { line: 5, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 3, col: 3 } }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }, Background(Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)]))))))) +Feature(Feature { keyword: "Feature", name: "output", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], position: LineCol { line: 5, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 3, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], position: LineCol { line: 5, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 3, col: 3 } }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }, Step(Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Started)))) +Feature(Feature { keyword: "Feature", name: "output", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], position: LineCol { line: 5, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 3, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], position: LineCol { line: 5, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 3, col: 3 } }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }, Step(Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)]))))))) +Feature(Feature { keyword: "Feature", name: "output", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], position: LineCol { line: 5, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 3, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], position: LineCol { line: 5, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 3, col: 3 } }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }, Step(Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Started)))) +Feature(Feature { keyword: "Feature", name: "output", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], position: LineCol { line: 5, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 3, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], position: LineCol { line: 5, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 3, col: 3 } }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }, Step(Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)]))))))) +Feature(Feature { keyword: "Feature", name: "output", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], position: LineCol { line: 5, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 3, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], position: LineCol { line: 5, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 3, col: 3 } }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }, Step(Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }, Started)))) +Feature(Feature { keyword: "Feature", name: "output", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], position: LineCol { line: 5, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 3, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], position: LineCol { line: 5, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 3, col: 3 } }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }, Step(Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)]))))))) +Feature(Feature { keyword: "Feature", name: "output", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], position: LineCol { line: 5, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 3, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], position: LineCol { line: 5, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 3, col: 3 } }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }, Finished))) +Feature(Feature { keyword: "Feature", name: "output", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], position: LineCol { line: 5, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 3, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], position: LineCol { line: 5, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 3, col: 3 } }, Finished)) +Feature(Feature { keyword: "Feature", name: "output", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "output", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], position: LineCol { line: 5, col: 5 } }), scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 11, col: 7 } }], examples: None, tags: [], position: LineCol { line: 8, col: 5 } }], tags: [], position: LineCol { line: 3, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Finished) Finished diff --git a/tests/features/output/rule_background_outline.feature.out b/tests/features/output/rule_background_outline.feature.out index b9601096..163fedfd 100644 --- a/tests/features/output/rule_background_outline.feature.out +++ b/tests/features/output/rule_background_outline.feature.out @@ -1,16 +1,16 @@ Started -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }], position: LineCol { line: 4, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 13, col: 9 } }, tags: [], position: LineCol { line: 12, col: 7 } }), tags: [], position: LineCol { line: 13, col: 7 } }], tags: [], position: LineCol { line: 3, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Started) -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }], position: LineCol { line: 4, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 13, col: 9 } }, tags: [], position: LineCol { line: 12, col: 7 } }), tags: [], position: LineCol { line: 13, col: 7 } }], tags: [], position: LineCol { line: 3, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }], position: LineCol { line: 4, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 13, col: 9 } }, tags: [], position: LineCol { line: 12, col: 7 } }), tags: [], position: LineCol { line: 13, col: 7 } }], tags: [], position: LineCol { line: 3, col: 3 } }, Started)) -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }], position: LineCol { line: 4, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 13, col: 9 } }, tags: [], position: LineCol { line: 12, col: 7 } }), tags: [], position: LineCol { line: 13, col: 7 } }], tags: [], position: LineCol { line: 3, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }], position: LineCol { line: 4, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 13, col: 9 } }, tags: [], position: LineCol { line: 12, col: 7 } }), tags: [], position: LineCol { line: 13, col: 7 } }], tags: [], position: LineCol { line: 3, col: 3 } }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 13, col: 9 } }, tags: [], position: LineCol { line: 12, col: 7 } }), tags: [], position: LineCol { line: 13, col: 7 } }, Started))) -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }], position: LineCol { line: 4, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 13, col: 9 } }, tags: [], position: LineCol { line: 12, col: 7 } }), tags: [], position: LineCol { line: 13, col: 7 } }], tags: [], position: LineCol { line: 3, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }], position: LineCol { line: 4, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 13, col: 9 } }, tags: [], position: LineCol { line: 12, col: 7 } }), tags: [], position: LineCol { line: 13, col: 7 } }], tags: [], position: LineCol { line: 3, col: 3 } }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 13, col: 9 } }, tags: [], position: LineCol { line: 12, col: 7 } }), tags: [], position: LineCol { line: 13, col: 7 } }, Background(Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Started)))) -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }], position: LineCol { line: 4, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 13, col: 9 } }, tags: [], position: LineCol { line: 12, col: 7 } }), tags: [], position: LineCol { line: 13, col: 7 } }], tags: [], position: LineCol { line: 3, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }], position: LineCol { line: 4, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 13, col: 9 } }, tags: [], position: LineCol { line: 12, col: 7 } }), tags: [], position: LineCol { line: 13, col: 7 } }], tags: [], position: LineCol { line: 3, col: 3 } }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 13, col: 9 } }, tags: [], position: LineCol { line: 12, col: 7 } }), tags: [], position: LineCol { line: 13, col: 7 } }, Background(Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)]))))))) -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }], position: LineCol { line: 4, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 13, col: 9 } }, tags: [], position: LineCol { line: 12, col: 7 } }), tags: [], position: LineCol { line: 13, col: 7 } }], tags: [], position: LineCol { line: 3, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }], position: LineCol { line: 4, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 13, col: 9 } }, tags: [], position: LineCol { line: 12, col: 7 } }), tags: [], position: LineCol { line: 13, col: 7 } }], tags: [], position: LineCol { line: 3, col: 3 } }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 13, col: 9 } }, tags: [], position: LineCol { line: 12, col: 7 } }), tags: [], position: LineCol { line: 13, col: 7 } }, Step(Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Started)))) -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }], position: LineCol { line: 4, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 13, col: 9 } }, tags: [], position: LineCol { line: 12, col: 7 } }), tags: [], position: LineCol { line: 13, col: 7 } }], tags: [], position: LineCol { line: 3, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }], position: LineCol { line: 4, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 13, col: 9 } }, tags: [], position: LineCol { line: 12, col: 7 } }), tags: [], position: LineCol { line: 13, col: 7 } }], tags: [], position: LineCol { line: 3, col: 3 } }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 13, col: 9 } }, tags: [], position: LineCol { line: 12, col: 7 } }), tags: [], position: LineCol { line: 13, col: 7 } }, Step(Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)]))))))) -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }], position: LineCol { line: 4, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 13, col: 9 } }, tags: [], position: LineCol { line: 12, col: 7 } }), tags: [], position: LineCol { line: 13, col: 7 } }], tags: [], position: LineCol { line: 3, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }], position: LineCol { line: 4, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 13, col: 9 } }, tags: [], position: LineCol { line: 12, col: 7 } }), tags: [], position: LineCol { line: 13, col: 7 } }], tags: [], position: LineCol { line: 3, col: 3 } }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 13, col: 9 } }, tags: [], position: LineCol { line: 12, col: 7 } }), tags: [], position: LineCol { line: 13, col: 7 } }, Step(Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Started)))) -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }], position: LineCol { line: 4, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 13, col: 9 } }, tags: [], position: LineCol { line: 12, col: 7 } }), tags: [], position: LineCol { line: 13, col: 7 } }], tags: [], position: LineCol { line: 3, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }], position: LineCol { line: 4, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 13, col: 9 } }, tags: [], position: LineCol { line: 12, col: 7 } }), tags: [], position: LineCol { line: 13, col: 7 } }], tags: [], position: LineCol { line: 3, col: 3 } }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 13, col: 9 } }, tags: [], position: LineCol { line: 12, col: 7 } }), tags: [], position: LineCol { line: 13, col: 7 } }, Step(Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)]))))))) -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }], position: LineCol { line: 4, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 13, col: 9 } }, tags: [], position: LineCol { line: 12, col: 7 } }), tags: [], position: LineCol { line: 13, col: 7 } }], tags: [], position: LineCol { line: 3, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }], position: LineCol { line: 4, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 13, col: 9 } }, tags: [], position: LineCol { line: 12, col: 7 } }), tags: [], position: LineCol { line: 13, col: 7 } }], tags: [], position: LineCol { line: 3, col: 3 } }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 13, col: 9 } }, tags: [], position: LineCol { line: 12, col: 7 } }), tags: [], position: LineCol { line: 13, col: 7 } }, Step(Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Started)))) -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }], position: LineCol { line: 4, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 13, col: 9 } }, tags: [], position: LineCol { line: 12, col: 7 } }), tags: [], position: LineCol { line: 13, col: 7 } }], tags: [], position: LineCol { line: 3, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }], position: LineCol { line: 4, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 13, col: 9 } }, tags: [], position: LineCol { line: 12, col: 7 } }), tags: [], position: LineCol { line: 13, col: 7 } }], tags: [], position: LineCol { line: 3, col: 3 } }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 13, col: 9 } }, tags: [], position: LineCol { line: 12, col: 7 } }), tags: [], position: LineCol { line: 13, col: 7 } }, Step(Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)]))))))) -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }], position: LineCol { line: 4, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 13, col: 9 } }, tags: [], position: LineCol { line: 12, col: 7 } }), tags: [], position: LineCol { line: 13, col: 7 } }], tags: [], position: LineCol { line: 3, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }], position: LineCol { line: 4, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 13, col: 9 } }, tags: [], position: LineCol { line: 12, col: 7 } }), tags: [], position: LineCol { line: 13, col: 7 } }], tags: [], position: LineCol { line: 3, col: 3 } }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 13, col: 9 } }, tags: [], position: LineCol { line: 12, col: 7 } }), tags: [], position: LineCol { line: 13, col: 7 } }, Finished))) -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }], position: LineCol { line: 4, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 13, col: 9 } }, tags: [], position: LineCol { line: 12, col: 7 } }), tags: [], position: LineCol { line: 13, col: 7 } }], tags: [], position: LineCol { line: 3, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }], position: LineCol { line: 4, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 13, col: 9 } }, tags: [], position: LineCol { line: 12, col: 7 } }), tags: [], position: LineCol { line: 13, col: 7 } }], tags: [], position: LineCol { line: 3, col: 3 } }, Finished)) -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }], position: LineCol { line: 4, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 13, col: 9 } }, tags: [], position: LineCol { line: 12, col: 7 } }), tags: [], position: LineCol { line: 13, col: 7 } }], tags: [], position: LineCol { line: 3, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Finished) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }], position: LineCol { line: 4, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 13, col: 9 } }, tags: [], position: LineCol { line: 12, col: 7 } }), tags: [], position: LineCol { line: 13, col: 7 } }], tags: [], position: LineCol { line: 3, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Started) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }], position: LineCol { line: 4, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 13, col: 9 } }, tags: [], position: LineCol { line: 12, col: 7 } }), tags: [], position: LineCol { line: 13, col: 7 } }], tags: [], position: LineCol { line: 3, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }], position: LineCol { line: 4, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 13, col: 9 } }, tags: [], position: LineCol { line: 12, col: 7 } }), tags: [], position: LineCol { line: 13, col: 7 } }], tags: [], position: LineCol { line: 3, col: 3 } }, Started)) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }], position: LineCol { line: 4, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 13, col: 9 } }, tags: [], position: LineCol { line: 12, col: 7 } }), tags: [], position: LineCol { line: 13, col: 7 } }], tags: [], position: LineCol { line: 3, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }], position: LineCol { line: 4, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 13, col: 9 } }, tags: [], position: LineCol { line: 12, col: 7 } }), tags: [], position: LineCol { line: 13, col: 7 } }], tags: [], position: LineCol { line: 3, col: 3 } }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 13, col: 9 } }, tags: [], position: LineCol { line: 12, col: 7 } }), tags: [], position: LineCol { line: 13, col: 7 } }, Started))) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }], position: LineCol { line: 4, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 13, col: 9 } }, tags: [], position: LineCol { line: 12, col: 7 } }), tags: [], position: LineCol { line: 13, col: 7 } }], tags: [], position: LineCol { line: 3, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }], position: LineCol { line: 4, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 13, col: 9 } }, tags: [], position: LineCol { line: 12, col: 7 } }), tags: [], position: LineCol { line: 13, col: 7 } }], tags: [], position: LineCol { line: 3, col: 3 } }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 13, col: 9 } }, tags: [], position: LineCol { line: 12, col: 7 } }), tags: [], position: LineCol { line: 13, col: 7 } }, Background(Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Started)))) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }], position: LineCol { line: 4, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 13, col: 9 } }, tags: [], position: LineCol { line: 12, col: 7 } }), tags: [], position: LineCol { line: 13, col: 7 } }], tags: [], position: LineCol { line: 3, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }], position: LineCol { line: 4, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 13, col: 9 } }, tags: [], position: LineCol { line: 12, col: 7 } }), tags: [], position: LineCol { line: 13, col: 7 } }], tags: [], position: LineCol { line: 3, col: 3 } }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 13, col: 9 } }, tags: [], position: LineCol { line: 12, col: 7 } }), tags: [], position: LineCol { line: 13, col: 7 } }, Background(Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)]))))))) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }], position: LineCol { line: 4, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 13, col: 9 } }, tags: [], position: LineCol { line: 12, col: 7 } }), tags: [], position: LineCol { line: 13, col: 7 } }], tags: [], position: LineCol { line: 3, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }], position: LineCol { line: 4, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 13, col: 9 } }, tags: [], position: LineCol { line: 12, col: 7 } }), tags: [], position: LineCol { line: 13, col: 7 } }], tags: [], position: LineCol { line: 3, col: 3 } }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 13, col: 9 } }, tags: [], position: LineCol { line: 12, col: 7 } }), tags: [], position: LineCol { line: 13, col: 7 } }, Step(Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Started)))) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }], position: LineCol { line: 4, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 13, col: 9 } }, tags: [], position: LineCol { line: 12, col: 7 } }), tags: [], position: LineCol { line: 13, col: 7 } }], tags: [], position: LineCol { line: 3, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }], position: LineCol { line: 4, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 13, col: 9 } }, tags: [], position: LineCol { line: 12, col: 7 } }), tags: [], position: LineCol { line: 13, col: 7 } }], tags: [], position: LineCol { line: 3, col: 3 } }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 13, col: 9 } }, tags: [], position: LineCol { line: 12, col: 7 } }), tags: [], position: LineCol { line: 13, col: 7 } }, Step(Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)]))))))) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }], position: LineCol { line: 4, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 13, col: 9 } }, tags: [], position: LineCol { line: 12, col: 7 } }), tags: [], position: LineCol { line: 13, col: 7 } }], tags: [], position: LineCol { line: 3, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }], position: LineCol { line: 4, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 13, col: 9 } }, tags: [], position: LineCol { line: 12, col: 7 } }), tags: [], position: LineCol { line: 13, col: 7 } }], tags: [], position: LineCol { line: 3, col: 3 } }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 13, col: 9 } }, tags: [], position: LineCol { line: 12, col: 7 } }), tags: [], position: LineCol { line: 13, col: 7 } }, Step(Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Started)))) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }], position: LineCol { line: 4, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 13, col: 9 } }, tags: [], position: LineCol { line: 12, col: 7 } }), tags: [], position: LineCol { line: 13, col: 7 } }], tags: [], position: LineCol { line: 3, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }], position: LineCol { line: 4, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 13, col: 9 } }, tags: [], position: LineCol { line: 12, col: 7 } }), tags: [], position: LineCol { line: 13, col: 7 } }], tags: [], position: LineCol { line: 3, col: 3 } }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 13, col: 9 } }, tags: [], position: LineCol { line: 12, col: 7 } }), tags: [], position: LineCol { line: 13, col: 7 } }, Step(Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)]))))))) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }], position: LineCol { line: 4, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 13, col: 9 } }, tags: [], position: LineCol { line: 12, col: 7 } }), tags: [], position: LineCol { line: 13, col: 7 } }], tags: [], position: LineCol { line: 3, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }], position: LineCol { line: 4, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 13, col: 9 } }, tags: [], position: LineCol { line: 12, col: 7 } }), tags: [], position: LineCol { line: 13, col: 7 } }], tags: [], position: LineCol { line: 3, col: 3 } }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 13, col: 9 } }, tags: [], position: LineCol { line: 12, col: 7 } }), tags: [], position: LineCol { line: 13, col: 7 } }, Step(Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Started)))) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }], position: LineCol { line: 4, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 13, col: 9 } }, tags: [], position: LineCol { line: 12, col: 7 } }), tags: [], position: LineCol { line: 13, col: 7 } }], tags: [], position: LineCol { line: 3, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }], position: LineCol { line: 4, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 13, col: 9 } }, tags: [], position: LineCol { line: 12, col: 7 } }), tags: [], position: LineCol { line: 13, col: 7 } }], tags: [], position: LineCol { line: 3, col: 3 } }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 13, col: 9 } }, tags: [], position: LineCol { line: 12, col: 7 } }), tags: [], position: LineCol { line: 13, col: 7 } }, Step(Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)]))))))) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }], position: LineCol { line: 4, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 13, col: 9 } }, tags: [], position: LineCol { line: 12, col: 7 } }), tags: [], position: LineCol { line: 13, col: 7 } }], tags: [], position: LineCol { line: 3, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }], position: LineCol { line: 4, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 13, col: 9 } }, tags: [], position: LineCol { line: 12, col: 7 } }), tags: [], position: LineCol { line: 13, col: 7 } }], tags: [], position: LineCol { line: 3, col: 3 } }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 13, col: 9 } }, tags: [], position: LineCol { line: 12, col: 7 } }), tags: [], position: LineCol { line: 13, col: 7 } }, Finished))) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }], position: LineCol { line: 4, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 13, col: 9 } }, tags: [], position: LineCol { line: 12, col: 7 } }), tags: [], position: LineCol { line: 13, col: 7 } }], tags: [], position: LineCol { line: 3, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }], position: LineCol { line: 4, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 13, col: 9 } }, tags: [], position: LineCol { line: 12, col: 7 } }), tags: [], position: LineCol { line: 13, col: 7 } }], tags: [], position: LineCol { line: 3, col: 3 } }, Finished)) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "outline", background: Some(Background { keyword: "Background", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }], position: LineCol { line: 4, col: 5 } }), scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 3", docstring: None, table: None, position: LineCol { line: 10, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["1", "2", "3"]], position: LineCol { line: 13, col: 9 } }, tags: [], position: LineCol { line: 12, col: 7 } }), tags: [], position: LineCol { line: 13, col: 7 } }], tags: [], position: LineCol { line: 3, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Finished) Finished diff --git a/tests/features/output/rule_outline.feature.out b/tests/features/output/rule_outline.feature.out index 8b48a398..000671ab 100644 --- a/tests/features/output/rule_outline.feature.out +++ b/tests/features/output/rule_outline.feature.out @@ -1,14 +1,14 @@ Started -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "them all", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 9 } }, tags: [], position: LineCol { line: 8, col: 7 } }), tags: [], position: LineCol { line: 9, col: 7 } }], tags: [], position: LineCol { line: 2, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Started) -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "them all", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 9 } }, tags: [], position: LineCol { line: 8, col: 7 } }), tags: [], position: LineCol { line: 9, col: 7 } }], tags: [], position: LineCol { line: 2, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "them all", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 9 } }, tags: [], position: LineCol { line: 8, col: 7 } }), tags: [], position: LineCol { line: 9, col: 7 } }], tags: [], position: LineCol { line: 2, col: 3 } }, Started)) -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "them all", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 9 } }, tags: [], position: LineCol { line: 8, col: 7 } }), tags: [], position: LineCol { line: 9, col: 7 } }], tags: [], position: LineCol { line: 2, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "them all", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 9 } }, tags: [], position: LineCol { line: 8, col: 7 } }), tags: [], position: LineCol { line: 9, col: 7 } }], tags: [], position: LineCol { line: 2, col: 3 } }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 9 } }, tags: [], position: LineCol { line: 8, col: 7 } }), tags: [], position: LineCol { line: 9, col: 7 } }, Started))) -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "them all", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 9 } }, tags: [], position: LineCol { line: 8, col: 7 } }), tags: [], position: LineCol { line: 9, col: 7 } }], tags: [], position: LineCol { line: 2, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "them all", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 9 } }, tags: [], position: LineCol { line: 8, col: 7 } }), tags: [], position: LineCol { line: 9, col: 7 } }], tags: [], position: LineCol { line: 2, col: 3 } }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 9 } }, tags: [], position: LineCol { line: 8, col: 7 } }), tags: [], position: LineCol { line: 9, col: 7 } }, Step(Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Started)))) -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "them all", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 9 } }, tags: [], position: LineCol { line: 8, col: 7 } }), tags: [], position: LineCol { line: 9, col: 7 } }], tags: [], position: LineCol { line: 2, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "them all", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 9 } }, tags: [], position: LineCol { line: 8, col: 7 } }), tags: [], position: LineCol { line: 9, col: 7 } }], tags: [], position: LineCol { line: 2, col: 3 } }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 9 } }, tags: [], position: LineCol { line: 8, col: 7 } }), tags: [], position: LineCol { line: 9, col: 7 } }, Step(Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)]))))))) -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "them all", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 9 } }, tags: [], position: LineCol { line: 8, col: 7 } }), tags: [], position: LineCol { line: 9, col: 7 } }], tags: [], position: LineCol { line: 2, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "them all", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 9 } }, tags: [], position: LineCol { line: 8, col: 7 } }), tags: [], position: LineCol { line: 9, col: 7 } }], tags: [], position: LineCol { line: 2, col: 3 } }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 9 } }, tags: [], position: LineCol { line: 8, col: 7 } }), tags: [], position: LineCol { line: 9, col: 7 } }, Step(Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Started)))) -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "them all", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 9 } }, tags: [], position: LineCol { line: 8, col: 7 } }), tags: [], position: LineCol { line: 9, col: 7 } }], tags: [], position: LineCol { line: 2, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "them all", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 9 } }, tags: [], position: LineCol { line: 8, col: 7 } }), tags: [], position: LineCol { line: 9, col: 7 } }], tags: [], position: LineCol { line: 2, col: 3 } }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 9 } }, tags: [], position: LineCol { line: 8, col: 7 } }), tags: [], position: LineCol { line: 9, col: 7 } }, Step(Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)]))))))) -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "them all", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 9 } }, tags: [], position: LineCol { line: 8, col: 7 } }), tags: [], position: LineCol { line: 9, col: 7 } }], tags: [], position: LineCol { line: 2, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "them all", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 9 } }, tags: [], position: LineCol { line: 8, col: 7 } }), tags: [], position: LineCol { line: 9, col: 7 } }], tags: [], position: LineCol { line: 2, col: 3 } }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 9 } }, tags: [], position: LineCol { line: 8, col: 7 } }), tags: [], position: LineCol { line: 9, col: 7 } }, Step(Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }, Started)))) -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "them all", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 9 } }, tags: [], position: LineCol { line: 8, col: 7 } }), tags: [], position: LineCol { line: 9, col: 7 } }], tags: [], position: LineCol { line: 2, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "them all", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 9 } }, tags: [], position: LineCol { line: 8, col: 7 } }), tags: [], position: LineCol { line: 9, col: 7 } }], tags: [], position: LineCol { line: 2, col: 3 } }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 9 } }, tags: [], position: LineCol { line: 8, col: 7 } }), tags: [], position: LineCol { line: 9, col: 7 } }, Step(Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)]))))))) -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "them all", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 9 } }, tags: [], position: LineCol { line: 8, col: 7 } }), tags: [], position: LineCol { line: 9, col: 7 } }], tags: [], position: LineCol { line: 2, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "them all", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 9 } }, tags: [], position: LineCol { line: 8, col: 7 } }), tags: [], position: LineCol { line: 9, col: 7 } }], tags: [], position: LineCol { line: 2, col: 3 } }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 9 } }, tags: [], position: LineCol { line: 8, col: 7 } }), tags: [], position: LineCol { line: 9, col: 7 } }, Finished))) -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "them all", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 9 } }, tags: [], position: LineCol { line: 8, col: 7 } }), tags: [], position: LineCol { line: 9, col: 7 } }], tags: [], position: LineCol { line: 2, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Rule(Rule { keyword: "Rule", name: "them all", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 9 } }, tags: [], position: LineCol { line: 8, col: 7 } }), tags: [], position: LineCol { line: 9, col: 7 } }], tags: [], position: LineCol { line: 2, col: 3 } }, Finished)) -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "them all", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 9 } }, tags: [], position: LineCol { line: 8, col: 7 } }), tags: [], position: LineCol { line: 9, col: 7 } }], tags: [], position: LineCol { line: 2, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Finished) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "them all", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 9 } }, tags: [], position: LineCol { line: 8, col: 7 } }), tags: [], position: LineCol { line: 9, col: 7 } }], tags: [], position: LineCol { line: 2, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Started) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "them all", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 9 } }, tags: [], position: LineCol { line: 8, col: 7 } }), tags: [], position: LineCol { line: 9, col: 7 } }], tags: [], position: LineCol { line: 2, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "them all", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 9 } }, tags: [], position: LineCol { line: 8, col: 7 } }), tags: [], position: LineCol { line: 9, col: 7 } }], tags: [], position: LineCol { line: 2, col: 3 } }, Started)) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "them all", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 9 } }, tags: [], position: LineCol { line: 8, col: 7 } }), tags: [], position: LineCol { line: 9, col: 7 } }], tags: [], position: LineCol { line: 2, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "them all", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 9 } }, tags: [], position: LineCol { line: 8, col: 7 } }), tags: [], position: LineCol { line: 9, col: 7 } }], tags: [], position: LineCol { line: 2, col: 3 } }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 9 } }, tags: [], position: LineCol { line: 8, col: 7 } }), tags: [], position: LineCol { line: 9, col: 7 } }, Started))) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "them all", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 9 } }, tags: [], position: LineCol { line: 8, col: 7 } }), tags: [], position: LineCol { line: 9, col: 7 } }], tags: [], position: LineCol { line: 2, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "them all", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 9 } }, tags: [], position: LineCol { line: 8, col: 7 } }), tags: [], position: LineCol { line: 9, col: 7 } }], tags: [], position: LineCol { line: 2, col: 3 } }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 9 } }, tags: [], position: LineCol { line: 8, col: 7 } }), tags: [], position: LineCol { line: 9, col: 7 } }, Step(Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Started)))) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "them all", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 9 } }, tags: [], position: LineCol { line: 8, col: 7 } }), tags: [], position: LineCol { line: 9, col: 7 } }], tags: [], position: LineCol { line: 2, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "them all", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 9 } }, tags: [], position: LineCol { line: 8, col: 7 } }), tags: [], position: LineCol { line: 9, col: 7 } }], tags: [], position: LineCol { line: 2, col: 3 } }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 9 } }, tags: [], position: LineCol { line: 8, col: 7 } }), tags: [], position: LineCol { line: 9, col: 7 } }, Step(Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)]))))))) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "them all", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 9 } }, tags: [], position: LineCol { line: 8, col: 7 } }), tags: [], position: LineCol { line: 9, col: 7 } }], tags: [], position: LineCol { line: 2, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "them all", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 9 } }, tags: [], position: LineCol { line: 8, col: 7 } }), tags: [], position: LineCol { line: 9, col: 7 } }], tags: [], position: LineCol { line: 2, col: 3 } }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 9 } }, tags: [], position: LineCol { line: 8, col: 7 } }), tags: [], position: LineCol { line: 9, col: 7 } }, Step(Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Started)))) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "them all", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 9 } }, tags: [], position: LineCol { line: 8, col: 7 } }), tags: [], position: LineCol { line: 9, col: 7 } }], tags: [], position: LineCol { line: 2, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "them all", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 9 } }, tags: [], position: LineCol { line: 8, col: 7 } }), tags: [], position: LineCol { line: 9, col: 7 } }], tags: [], position: LineCol { line: 2, col: 3 } }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 9 } }, tags: [], position: LineCol { line: 8, col: 7 } }), tags: [], position: LineCol { line: 9, col: 7 } }, Step(Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)]))))))) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "them all", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 9 } }, tags: [], position: LineCol { line: 8, col: 7 } }), tags: [], position: LineCol { line: 9, col: 7 } }], tags: [], position: LineCol { line: 2, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "them all", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 9 } }, tags: [], position: LineCol { line: 8, col: 7 } }), tags: [], position: LineCol { line: 9, col: 7 } }], tags: [], position: LineCol { line: 2, col: 3 } }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 9 } }, tags: [], position: LineCol { line: 8, col: 7 } }), tags: [], position: LineCol { line: 9, col: 7 } }, Step(Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }, Started)))) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "them all", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 9 } }, tags: [], position: LineCol { line: 8, col: 7 } }), tags: [], position: LineCol { line: 9, col: 7 } }], tags: [], position: LineCol { line: 2, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "them all", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 9 } }, tags: [], position: LineCol { line: 8, col: 7 } }), tags: [], position: LineCol { line: 9, col: 7 } }], tags: [], position: LineCol { line: 2, col: 3 } }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 9 } }, tags: [], position: LineCol { line: 8, col: 7 } }), tags: [], position: LineCol { line: 9, col: 7 } }, Step(Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)]))))))) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "them all", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 9 } }, tags: [], position: LineCol { line: 8, col: 7 } }), tags: [], position: LineCol { line: 9, col: 7 } }], tags: [], position: LineCol { line: 2, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "them all", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 9 } }, tags: [], position: LineCol { line: 8, col: 7 } }), tags: [], position: LineCol { line: 9, col: 7 } }], tags: [], position: LineCol { line: 2, col: 3 } }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 9 } }, tags: [], position: LineCol { line: 8, col: 7 } }), tags: [], position: LineCol { line: 9, col: 7 } }, Finished))) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "them all", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 9 } }, tags: [], position: LineCol { line: 8, col: 7 } }), tags: [], position: LineCol { line: 9, col: 7 } }], tags: [], position: LineCol { line: 2, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Rule(Rule { keyword: "Rule", name: "them all", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 9 } }, tags: [], position: LineCol { line: 8, col: 7 } }), tags: [], position: LineCol { line: 9, col: 7 } }], tags: [], position: LineCol { line: 2, col: 3 } }, Finished)) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [], rules: [Rule { keyword: "Rule", name: "them all", background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 7 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 7 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 7 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 9 } }, tags: [], position: LineCol { line: 8, col: 7 } }), tags: [], position: LineCol { line: 9, col: 7 } }], tags: [], position: LineCol { line: 2, col: 3 } }], tags: [], position: LineCol { line: 1, col: 1 }, }, Finished) Finished diff --git a/tests/features/output/scenario.feature.out b/tests/features/output/scenario.feature.out index c731c546..e3999fa2 100644 --- a/tests/features/output/scenario.feature.out +++ b/tests/features/output/scenario.feature.out @@ -1,12 +1,12 @@ Started -Feature(Feature { keyword: "Feature", name: "output", description: None, background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Started) -Feature(Feature { keyword: "Feature", name: "output", description: None, background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }, Started)) -Feature(Feature { keyword: "Feature", name: "output", description: None, background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }, Step(Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }, Started))) -Feature(Feature { keyword: "Feature", name: "output", description: None, background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }, Step(Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)])))))) -Feature(Feature { keyword: "Feature", name: "output", description: None, background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }, Step(Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Started))) -Feature(Feature { keyword: "Feature", name: "output", description: None, background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }, Step(Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)])))))) -Feature(Feature { keyword: "Feature", name: "output", description: None, background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }, Step(Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }, Started))) -Feature(Feature { keyword: "Feature", name: "output", description: None, background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }, Step(Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)])))))) -Feature(Feature { keyword: "Feature", name: "output", description: None, background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }, Finished)) -Feature(Feature { keyword: "Feature", name: "output", description: None, background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Finished) +Feature(Feature { keyword: "Feature", name: "output", description: None, background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Started) +Feature(Feature { keyword: "Feature", name: "output", description: None, background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }, Started)) +Feature(Feature { keyword: "Feature", name: "output", description: None, background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }, Step(Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }, Started))) +Feature(Feature { keyword: "Feature", name: "output", description: None, background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }, Step(Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)])))))) +Feature(Feature { keyword: "Feature", name: "output", description: None, background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }, Step(Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Started))) +Feature(Feature { keyword: "Feature", name: "output", description: None, background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }, Step(Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)])))))) +Feature(Feature { keyword: "Feature", name: "output", description: None, background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }, Step(Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }, Started))) +Feature(Feature { keyword: "Feature", name: "output", description: None, background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }, Step(Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)])))))) +Feature(Feature { keyword: "Feature", name: "output", description: None, background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Scenario(Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }, Finished)) +Feature(Feature { keyword: "Feature", name: "output", description: None, background: None, scenarios: [Scenario { keyword: "Scenario", name: "output", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Finished) Finished diff --git a/tests/features/output/scenario_outline.feature.out b/tests/features/output/scenario_outline.feature.out index 1108558d..c16e45a6 100644 --- a/tests/features/output/scenario_outline.feature.out +++ b/tests/features/output/scenario_outline.feature.out @@ -1,12 +1,12 @@ Started -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 7 } }, tags: [], position: LineCol { line: 8, col: 5 } }), tags: [], position: LineCol { line: 9, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Started) -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 7 } }, tags: [], position: LineCol { line: 8, col: 5 } }), tags: [], position: LineCol { line: 9, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 7 } }, tags: [], position: LineCol { line: 8, col: 5 } }), tags: [], position: LineCol { line: 9, col: 5 } }, Started)) -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 7 } }, tags: [], position: LineCol { line: 8, col: 5 } }), tags: [], position: LineCol { line: 9, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 7 } }, tags: [], position: LineCol { line: 8, col: 5 } }), tags: [], position: LineCol { line: 9, col: 5 } }, Step(Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Started))) -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 7 } }, tags: [], position: LineCol { line: 8, col: 5 } }), tags: [], position: LineCol { line: 9, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 7 } }, tags: [], position: LineCol { line: 8, col: 5 } }), tags: [], position: LineCol { line: 9, col: 5 } }, Step(Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)])))))) -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 7 } }, tags: [], position: LineCol { line: 8, col: 5 } }), tags: [], position: LineCol { line: 9, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 7 } }, tags: [], position: LineCol { line: 8, col: 5 } }), tags: [], position: LineCol { line: 9, col: 5 } }, Step(Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }, Started))) -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 7 } }, tags: [], position: LineCol { line: 8, col: 5 } }), tags: [], position: LineCol { line: 9, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 7 } }, tags: [], position: LineCol { line: 8, col: 5 } }), tags: [], position: LineCol { line: 9, col: 5 } }, Step(Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)])))))) -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 7 } }, tags: [], position: LineCol { line: 8, col: 5 } }), tags: [], position: LineCol { line: 9, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 7 } }, tags: [], position: LineCol { line: 8, col: 5 } }), tags: [], position: LineCol { line: 9, col: 5 } }, Step(Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 5 } }, Started))) -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 7 } }, tags: [], position: LineCol { line: 8, col: 5 } }), tags: [], position: LineCol { line: 9, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 7 } }, tags: [], position: LineCol { line: 8, col: 5 } }), tags: [], position: LineCol { line: 9, col: 5 } }, Step(Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 5 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)])))))) -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 7 } }, tags: [], position: LineCol { line: 8, col: 5 } }), tags: [], position: LineCol { line: 9, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 7 } }, tags: [], position: LineCol { line: 8, col: 5 } }), tags: [], position: LineCol { line: 9, col: 5 } }, Finished)) -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 7 } }, tags: [], position: LineCol { line: 8, col: 5 } }), tags: [], position: LineCol { line: 9, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Finished) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 7 } }, tags: [], position: LineCol { line: 8, col: 5 } }), tags: [], position: LineCol { line: 9, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Started) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 7 } }, tags: [], position: LineCol { line: 8, col: 5 } }), tags: [], position: LineCol { line: 9, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 7 } }, tags: [], position: LineCol { line: 8, col: 5 } }), tags: [], position: LineCol { line: 9, col: 5 } }, Started)) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 7 } }, tags: [], position: LineCol { line: 8, col: 5 } }), tags: [], position: LineCol { line: 9, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 7 } }, tags: [], position: LineCol { line: 8, col: 5 } }), tags: [], position: LineCol { line: 9, col: 5 } }, Step(Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Started))) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 7 } }, tags: [], position: LineCol { line: 8, col: 5 } }), tags: [], position: LineCol { line: 9, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 7 } }, tags: [], position: LineCol { line: 8, col: 5 } }), tags: [], position: LineCol { line: 9, col: 5 } }, Step(Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)])))))) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 7 } }, tags: [], position: LineCol { line: 8, col: 5 } }), tags: [], position: LineCol { line: 9, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 7 } }, tags: [], position: LineCol { line: 8, col: 5 } }), tags: [], position: LineCol { line: 9, col: 5 } }, Step(Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }, Started))) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 7 } }, tags: [], position: LineCol { line: 8, col: 5 } }), tags: [], position: LineCol { line: 9, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 7 } }, tags: [], position: LineCol { line: 8, col: 5 } }), tags: [], position: LineCol { line: 9, col: 5 } }, Step(Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)])))))) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 7 } }, tags: [], position: LineCol { line: 8, col: 5 } }), tags: [], position: LineCol { line: 9, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 7 } }, tags: [], position: LineCol { line: 8, col: 5 } }), tags: [], position: LineCol { line: 9, col: 5 } }, Step(Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 5 } }, Started))) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 7 } }, tags: [], position: LineCol { line: 8, col: 5 } }), tags: [], position: LineCol { line: 9, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 7 } }, tags: [], position: LineCol { line: 8, col: 5 } }), tags: [], position: LineCol { line: 9, col: 5 } }, Step(Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 5 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)])))))) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 7 } }, tags: [], position: LineCol { line: 8, col: 5 } }), tags: [], position: LineCol { line: 9, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 7 } }, tags: [], position: LineCol { line: 8, col: 5 } }), tags: [], position: LineCol { line: 9, col: 5 } }, Finished)) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: None, position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 5, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 6, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"]], position: LineCol { line: 9, col: 7 } }, tags: [], position: LineCol { line: 8, col: 5 } }), tags: [], position: LineCol { line: 9, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Finished) Finished diff --git a/tests/features/output/scenario_outline_table.feature.out b/tests/features/output/scenario_outline_table.feature.out index 1447db64..4c60437e 100644 --- a/tests/features/output/scenario_outline_table.feature.out +++ b/tests/features/output/scenario_outline_table.feature.out @@ -1,16 +1,16 @@ Started -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "0"], ["2", "1"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }, Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 3", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "3"], ["2", "4"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 5", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 13, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Started) -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "0"], ["2", "1"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }, Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 3", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "3"], ["2", "4"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 5", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 13, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "0"], ["2", "1"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }, Started)) -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "0"], ["2", "1"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }, Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 3", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "3"], ["2", "4"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 5", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 13, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "0"], ["2", "1"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }, Step(Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "0"], ["2", "1"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Started))) -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "0"], ["2", "1"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }, Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 3", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "3"], ["2", "4"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 5", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 13, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "0"], ["2", "1"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }, Step(Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "0"], ["2", "1"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)])))))) -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "0"], ["2", "1"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }, Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 3", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "3"], ["2", "4"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 5", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 13, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "0"], ["2", "1"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }, Step(Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Started))) -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "0"], ["2", "1"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }, Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 3", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "3"], ["2", "4"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 5", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 13, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "0"], ["2", "1"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }, Step(Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)])))))) -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "0"], ["2", "1"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }, Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 3", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "3"], ["2", "4"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 5", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 13, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "0"], ["2", "1"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }, Step(Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }, Started))) -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "0"], ["2", "1"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }, Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 3", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "3"], ["2", "4"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 5", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 13, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "0"], ["2", "1"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }, Step(Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)])))))) -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "0"], ["2", "1"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }, Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 3", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "3"], ["2", "4"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 5", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 13, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "0"], ["2", "1"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }, Finished)) -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "0"], ["2", "1"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }, Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 3", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "3"], ["2", "4"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 5", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 13, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 3", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "3"], ["2", "4"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 5", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 13, col: 5 } }, Started)) -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "0"], ["2", "1"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }, Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 3", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "3"], ["2", "4"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 5", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 13, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 3", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "3"], ["2", "4"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 5", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 13, col: 5 } }, Step(Step { keyword: "Given", ty: Given, value: "foo is 3", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "3"], ["2", "4"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Started))) -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "0"], ["2", "1"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }, Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 3", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "3"], ["2", "4"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 5", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 13, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 3", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "3"], ["2", "4"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 5", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 13, col: 5 } }, Step(Step { keyword: "Given", ty: Given, value: "foo is 3", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "3"], ["2", "4"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Failed(Some(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)]))), Some(World(0)), Any { .. })))) -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "0"], ["2", "1"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }, Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 3", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "3"], ["2", "4"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 5", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 13, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 3", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "3"], ["2", "4"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 5", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 13, col: 5 } }, Finished)) -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "0"], ["2", "1"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }, Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 3", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "3"], ["2", "4"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 5", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 13, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, path: None }, Finished) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "0"], ["2", "1"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }, Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 3", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "3"], ["2", "4"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 5", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 13, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Started) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "0"], ["2", "1"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }, Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 3", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "3"], ["2", "4"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 5", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 13, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "0"], ["2", "1"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }, Started)) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "0"], ["2", "1"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }, Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 3", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "3"], ["2", "4"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 5", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 13, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "0"], ["2", "1"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }, Step(Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "0"], ["2", "1"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Started))) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "0"], ["2", "1"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }, Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 3", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "3"], ["2", "4"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 5", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 13, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "0"], ["2", "1"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }, Step(Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "0"], ["2", "1"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)])))))) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "0"], ["2", "1"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }, Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 3", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "3"], ["2", "4"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 5", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 13, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "0"], ["2", "1"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }, Step(Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Started))) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "0"], ["2", "1"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }, Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 3", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "3"], ["2", "4"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 5", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 13, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "0"], ["2", "1"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }, Step(Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)])))))) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "0"], ["2", "1"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }, Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 3", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "3"], ["2", "4"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 5", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 13, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "0"], ["2", "1"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }, Step(Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }, Started))) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "0"], ["2", "1"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }, Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 3", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "3"], ["2", "4"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 5", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 13, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "0"], ["2", "1"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }, Step(Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }, Passed(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)])))))) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "0"], ["2", "1"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }, Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 3", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "3"], ["2", "4"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 5", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 13, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "0"], ["2", "1"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }, Finished)) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "0"], ["2", "1"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }, Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 3", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "3"], ["2", "4"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 5", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 13, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 3", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "3"], ["2", "4"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 5", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 13, col: 5 } }, Started)) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "0"], ["2", "1"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }, Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 3", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "3"], ["2", "4"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 5", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 13, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 3", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "3"], ["2", "4"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 5", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 13, col: 5 } }, Step(Step { keyword: "Given", ty: Given, value: "foo is 3", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "3"], ["2", "4"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Started))) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "0"], ["2", "1"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }, Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 3", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "3"], ["2", "4"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 5", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 13, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 3", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "3"], ["2", "4"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 5", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 13, col: 5 } }, Step(Step { keyword: "Given", ty: Given, value: "foo is 3", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "3"], ["2", "4"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Failed(Some(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)]))), Some(World(0)), Any { .. })))) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "0"], ["2", "1"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }, Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 3", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "3"], ["2", "4"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 5", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 13, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 3", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "3"], ["2", "4"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 5", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 13, col: 5 } }, Finished)) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "0"], ["2", "1"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }, Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 3", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "3"], ["2", "4"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 5", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 13, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Finished) Finished diff --git a/tests/output.rs b/tests/output.rs index c43c2ebb..8a1c5b19 100644 --- a/tests/output.rs +++ b/tests/output.rs @@ -1,4 +1,4 @@ -use std::{borrow::Cow, convert::Infallible, fmt::Debug, sync::Arc}; +use std::{borrow::Cow, convert::Infallible, fmt::Debug}; use async_trait::async_trait; use cucumber::{event, given, parser, then, when, WorldInit, Writer}; @@ -38,17 +38,11 @@ impl Writer for DebugWriter { ) { let ev: Cow<_> = match ev { Err(_) => "ParsingError".into(), - Ok(event::Cucumber::Feature(f, ev)) => { - let mut f = f.as_ref().clone(); - f.path = None; - format!("{:?}", event::Cucumber::Feature(Arc::new(f), ev)) - .into() - } Ok(ev) => format!("{:?}", ev).into(), }; let re = - Regex::new(r" span: Span \{ start: (\d+), end: (\d+) },").unwrap(); + Regex::new(r#"( span: Span \{ start: (\d+), end: (\d+) },| path: (None|(Some\()?"[^"]*")\)?,?)"#).unwrap(); let without_span = re.replace_all(ev.as_ref(), ""); self.0.push_str(without_span.as_ref()); From b484f8c25c3b9a99cbb57e6f94a9d9d023f02487 Mon Sep 17 00:00:00 2001 From: ilslv Date: Mon, 18 Oct 2021 11:26:55 +0300 Subject: [PATCH 10/25] Fix Windows tests --- tests/features/output/ambiguous_step.feature.out | 2 +- tests/output.rs | 14 +++++++++++--- 2 files changed, 12 insertions(+), 4 deletions(-) diff --git a/tests/features/output/ambiguous_step.feature.out b/tests/features/output/ambiguous_step.feature.out index 0ce8cd40..c837013b 100644 --- a/tests/features/output/ambiguous_step.feature.out +++ b/tests/features/output/ambiguous_step.feature.out @@ -2,7 +2,7 @@ Started Feature(Feature { keyword: "Feature", name: "ambiguous", description: None, background: None, scenarios: [Scenario { keyword: "Scenario", name: "ambiguous", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Started) Feature(Feature { keyword: "Feature", name: "ambiguous", description: None, background: None, scenarios: [Scenario { keyword: "Scenario", name: "ambiguous", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Scenario(Scenario { keyword: "Scenario", name: "ambiguous", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }, Started)) Feature(Feature { keyword: "Feature", name: "ambiguous", description: None, background: None, scenarios: [Scenario { keyword: "Scenario", name: "ambiguous", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Scenario(Scenario { keyword: "Scenario", name: "ambiguous", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }, Step(Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }, Started))) -Feature(Feature { keyword: "Feature", name: "ambiguous", description: None, background: None, scenarios: [Scenario { keyword: "Scenario", name: "ambiguous", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Scenario(Scenario { keyword: "Scenario", name: "ambiguous", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }, Step(Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }, AmbiguousMatch(AmbiguousMatchError { possible_matches: [(HashableRegex(foo is (\d+)), Some(Location { line: 10, column: 1 })), (HashableRegex(foo is (\d+) ambiguous), Some(Location { line: 18, column: 1 }))] })))) +Feature(Feature { keyword: "Feature", name: "ambiguous", description: None, background: None, scenarios: [Scenario { keyword: "Scenario", name: "ambiguous", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Scenario(Scenario { keyword: "Scenario", name: "ambiguous", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }, Step(Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }, AmbiguousMatch(AmbiguousMatchError { possible_matches: [(HashableRegex(foo is (\d+)), Some(Location { line: 11, column: 1 })), (HashableRegex(foo is (\d+) ambiguous), Some(Location { line: 19, column: 1 }))] })))) Feature(Feature { keyword: "Feature", name: "ambiguous", description: None, background: None, scenarios: [Scenario { keyword: "Scenario", name: "ambiguous", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Scenario(Scenario { keyword: "Scenario", name: "ambiguous", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }, Finished)) Feature(Feature { keyword: "Feature", name: "ambiguous", description: None, background: None, scenarios: [Scenario { keyword: "Scenario", name: "ambiguous", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Finished) Finished diff --git a/tests/output.rs b/tests/output.rs index 8a1c5b19..562eb2dc 100644 --- a/tests/output.rs +++ b/tests/output.rs @@ -2,6 +2,7 @@ use std::{borrow::Cow, convert::Infallible, fmt::Debug}; use async_trait::async_trait; use cucumber::{event, given, parser, then, when, WorldInit, Writer}; +use once_cell::sync::Lazy; use regex::Regex; #[derive(Debug, Default, WorldInit)] @@ -30,6 +31,15 @@ impl cucumber::World for World { #[derive(Default)] struct DebugWriter(String); +// This regex exists to make tests work on Windows, Linux and macOS. +static SPAN_AND_PATH_RE: Lazy = Lazy::new(|| { + Regex::new( + "( span: Span \\{ start: (\\d+), end: (\\d+) },\ + | path: (None|(Some\\()?\"[^\"]*\")\\)?,?)", + ) + .unwrap() +}); + #[async_trait(?Send)] impl Writer for DebugWriter { async fn handle_event( @@ -41,9 +51,7 @@ impl Writer for DebugWriter { Ok(ev) => format!("{:?}", ev).into(), }; - let re = - Regex::new(r#"( span: Span \{ start: (\d+), end: (\d+) },| path: (None|(Some\()?"[^"]*")\)?,?)"#).unwrap(); - let without_span = re.replace_all(ev.as_ref(), ""); + let without_span = SPAN_AND_PATH_RE.replace_all(ev.as_ref(), ""); self.0.push_str(without_span.as_ref()); } From 2d16c86b345b02914c84bc184e9eb5ad8f5c6e71 Mon Sep 17 00:00:00 2001 From: tyranron Date: Mon, 18 Oct 2021 13:51:42 +0300 Subject: [PATCH 11/25] Corrections --- CHANGELOG.md | 2 +- book/src/Features.md | 24 +++-- src/cucumber.rs | 56 ++++++---- src/event.rs | 44 ++++---- src/runner/basic.rs | 227 ++++++++++++++++++++------------------- src/writer/basic.rs | 45 ++++---- src/writer/summarized.rs | 70 ++++++------ tests/wait.rs | 2 +- 8 files changed, 246 insertions(+), 224 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index e4f4313b..6e2506db 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -22,7 +22,7 @@ All user visible changes to `cucumber` crate will be documented in this file. Th - Made test callbacks first argument `&mut World` instead of `World`. ([#128]) - Made `#[step]` argument of step functions `Step` instead of `StepContext` again, while test callbacks still receive `StepContext` as a second parameter. ([#128]) - Deprecated `--nocapture` and `--debug` CLI options to be completely redesigned in `0.11` release. ([#137]) -- [Hooks](https://cucumber.io/docs/cucumber/api/#hooks) now accept `&mut World` as a last parameter ([#142]) +- [Hooks](https://cucumber.io/docs/cucumber/api/#hooks) now accept optional `&mut World` as their last parameter. ([#142]) ### Added diff --git a/book/src/Features.md b/book/src/Features.md index 3b221dfe..84092ce2 100644 --- a/book/src/Features.md +++ b/book/src/Features.md @@ -41,7 +41,7 @@ Occasionally you’ll find yourself repeating the same `Given` steps in all the Since it's repeated in every scenario, this is an indication that those steps are not essential to describe the scenarios, so they are _incidental details_. You can literally move such `Given` steps to background, by grouping them under a `Background` section. -A `Background` allows you to add some context to the scenarios that follow it. It can contain one or more steps, which are run before each scenario, but after any [`Before` hooks](#before-hook). +`Background` allows you to add some context to the `Scenario`s following it. It can contain one or more steps, which are run before each scenario (but after any [`Before` hooks](#before-hook)). ```gherkin Feature: Animal feature @@ -308,9 +308,10 @@ In case most of your `.feature` files aren't written in English and you want to ## Scenario hooks -### Before hook -`Before` hooks run before the first step of each scenario, even [Background](#background-keyword) ones. +### `Before` hook + +`Before` hook runs before the first step of each scenario, even before [`Background` ones](#background-keyword). ```rust # use std::{convert::Infallible, time::Duration}; @@ -318,7 +319,7 @@ In case most of your `.feature` files aren't written in English and you want to # use async_trait::async_trait; # use cucumber::WorldInit; # use futures::FutureExt as _; -# use tokio::time::sleep; +# use tokio::time; # # #[derive(Debug, WorldInit)] # struct World; @@ -335,18 +336,19 @@ In case most of your `.feature` files aren't written in English and you want to # fn main() { World::cucumber() .before(|_feature, _rule, _scenario, _world| { - sleep(Duration::from_millis(10)).boxed_local() + time::sleep(Duration::from_millis(10)).boxed_local() }) .run_and_exit("tests/features/book"); # } ``` -> #### Think twice before you use `Before` -> Whatever happens in a `Before` hook is invisible to people who only read the features. You should consider using a [Background](#background-keyword) as a more explicit alternative, especially if the setup should be readable by non-technical people. Only use a `Before` hook for low-level logic such as starting a browser or deleting data from a database. +> ⚠️ __Think twice before using `Before` hook!__ +> Whatever happens in a `Before` hook is invisible to people reading `.feature`s. You should consider using a [`Background`](#background-keyword) as a more explicit alternative, especially if the setup should be readable by non-technical people. Only use a `Before` hook for low-level logic such as starting a browser or deleting data from a database. -### After hook -`After` hooks run after the last step of each scenario, even when the step result is `failed` or `skipped`. +### `After` hook + +`After` hook runs after the last step of each `Scenario`, even when that step fails or is skipped. ```rust # use std::{convert::Infallible, time::Duration}; @@ -354,7 +356,7 @@ World::cucumber() # use async_trait::async_trait; # use cucumber::WorldInit; # use futures::FutureExt as _; -# use tokio::time::sleep; +# use tokio::time; # # #[derive(Debug, WorldInit)] # struct World; @@ -371,7 +373,7 @@ World::cucumber() # fn main() { World::cucumber() .after(|_feature, _rule, _scenario, _world| { - sleep(Duration::from_millis(10)).boxed_local() + time::sleep(Duration::from_millis(10)).boxed_local() }) .run_and_exit("tests/features/book"); # } diff --git a/src/cucumber.rs b/src/cucumber.rs index 06d26ee7..0087c0e1 100644 --- a/src/cucumber.rs +++ b/src/cucumber.rs @@ -875,8 +875,8 @@ impl Cucumber, Wr> { } } - /// Sets hook, executed on every [`Scenario`] before any [`Step`]s, - /// including [`Background`] ones. + /// Sets a hook, executed on each [`Scenario`] before running all its + /// [`Step`]s, including [`Background`] ones. /// /// [`Background`]: gherkin::Background /// [`Scenario`]: gherkin::Scenario @@ -909,15 +909,15 @@ impl Cucumber, Wr> { } } - /// Sets hook, executed on every [`Scenario`] after all [`Step`]s even after - /// [`Skipped`] of [`Failed`] [`Step`]s. + /// Sets a hook, executed on each [`Scenario`] after running all its + /// [`Step`]s, even after [`Skipped`] of [`Failed`] [`Step`]s. /// - /// Last `World` argument is supplied to the function, in case it - /// was initialized before by [`before`] hook or any non-failed [`Step`]. - /// In case last [`Scenario`]'s [`Step`] failed, we want to return event - /// with exact `World` state. Also we don't want to impose additional - /// [`Clone`] bounds on `World`, so the only option left is to pass [`None`] - /// to the function. + /// Last `World` argument is supplied to the function, in case it was + /// initialized before by running [`before`] hook or any non-failed + /// [`Step`]. In case the last [`Scenario`]'s [`Step`] failed, we want to + /// return event with an exact `World` state. Also, we don't want to impose + /// additional [`Clone`] bounds on `World`, so the only option left is to + /// pass [`None`] to the function. /// /// /// [`before`]: Self::before() @@ -1092,18 +1092,36 @@ where { let writer = self.filter_run(input, filter).await; if writer.execution_has_failed() { + let mut msg = Vec::with_capacity(3); + let failed_steps = writer.failed_steps(); + if failed_steps > 0 { + msg.push(format!( + "{} step{} failed", + failed_steps, + (failed_steps > 1).then(|| "s").unwrap_or_default(), + )); + } + let parsing_errors = writer.parsing_errors(); + if parsing_errors > 0 { + msg.push(format!( + "{} parsing error{}", + parsing_errors, + (parsing_errors > 1).then(|| "s").unwrap_or_default(), + )); + } + let hook_errors = writer.hook_errors(); - panic!( - "{} step{} failed, {} parsing error{}, {} hook error{}", - failed_steps, - (failed_steps != 1).then(|| "s").unwrap_or_default(), - parsing_errors, - (parsing_errors != 1).then(|| "s").unwrap_or_default(), - hook_errors, - (hook_errors != 1).then(|| "s").unwrap_or_default(), - ); + if hook_errors > 0 { + msg.push(format!( + "{} hook error{}", + hook_errors, + (hook_errors > 1).then(|| "s").unwrap_or_default(), + )); + } + + panic!("{}", msg.join(", ")); } } } diff --git a/src/event.rs b/src/event.rs index 40717e36..23d57439 100644 --- a/src/event.rs +++ b/src/event.rs @@ -224,29 +224,35 @@ impl Clone for Step { } } -/// Type of the hook, executed before or after all [`Scenario`]'s [`Step`]s. +/// Type of a hook executed before or after all [`Scenario`]'s [`Step`]s. /// /// [`Scenario`]: gherkin::Scenario /// [`Step`]: gherkin::Step #[derive(Clone, Copy, Debug)] -pub enum HookTy { - /// Hook, executed on every [`Scenario`] before any [`Step`]s. +pub enum HookType { + /// Executing on each [`Scenario`] before running all [`Step`]s. /// /// [`Scenario`]: gherkin::Scenario /// [`Step`]: gherkin::Step Before, - /// Hook, executed on every [`Scenario`] after all [`Step`]s. + /// Executing on each [`Scenario`] after running all [`Step`]s. /// /// [`Scenario`]: gherkin::Scenario /// [`Step`]: gherkin::Step After, } -/// [`Before`] or [`After`] hook event. +impl fmt::Display for HookType { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(f, "{:?}", self) + } +} + +/// Event of running [`Before`] or [`After`] hook. /// -/// [`After`]: HookTy::After -/// [`Before`]: HookTy::Before +/// [`After`]: HookType::After +/// [`Before`]: HookType::Before #[derive(Debug)] pub enum Hook { /// Hook execution being started. @@ -259,24 +265,14 @@ pub enum Hook { Failed(Option>, Info), } -impl fmt::Display for HookTy { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - let s = match self { - HookTy::Before => "Before", - HookTy::After => "After", - }; - write!(f, "{}", s) - } -} - // Manual implementation is required to omit the redundant `World: Clone` trait // bound imposed by `#[derive(Clone)]`. impl Clone for Hook { fn clone(&self) -> Self { match self { - Hook::Started => Hook::Started, - Hook::Passed => Hook::Passed, - Hook::Failed(w, i) => Hook::Failed(w.clone(), i.clone()), + Self::Started => Self::Started, + Self::Passed => Self::Passed, + Self::Failed(w, i) => Self::Failed(w.clone(), i.clone()), } } } @@ -292,7 +288,7 @@ pub enum Scenario { Started, /// [`Hook`] event. - Hook(HookTy, Hook), + Hook(HookType, Hook), /// [`Background`] [`Step`] event. /// @@ -329,7 +325,7 @@ impl Scenario { /// /// [`Scenario`]: gherkin::Scenario #[must_use] - pub fn hook_started(which: HookTy) -> Self { + pub fn hook_started(which: HookType) -> Self { Self::Hook(which, Hook::Started) } @@ -337,7 +333,7 @@ impl Scenario { /// /// [`Scenario`]: gherkin::Scenario #[must_use] - pub fn hook_passed(which: HookTy) -> Self { + pub fn hook_passed(which: HookType) -> Self { Self::Hook(which, Hook::Passed) } @@ -346,7 +342,7 @@ impl Scenario { /// [`Scenario`]: gherkin::Scenario #[must_use] pub fn hook_failed( - which: HookTy, + which: HookType, world: Option>, info: Info, ) -> Self { diff --git a/src/runner/basic.rs b/src/runner/basic.rs index a9dc67d0..ef119ddb 100644 --- a/src/runner/basic.rs +++ b/src/runner/basic.rs @@ -13,6 +13,7 @@ use std::{ cmp, collections::HashMap, + convert::identity, fmt, mem, panic::{self, AssertUnwindSafe}, path::PathBuf, @@ -35,7 +36,7 @@ use itertools::Itertools as _; use regex::{CaptureLocations, Regex}; use crate::{ - event::{self, HookTy, Info}, + event::{self, HookType, Info}, feature::Ext as _, parser, step, Runner, Step, World, }; @@ -57,6 +58,40 @@ pub enum ScenarioType { Concurrent, } +/// Alias for [`fn`] used to determine whether a [`Scenario`] is [`Concurrent`] +/// or a [`Serial`] one. +/// +/// [`Concurrent`]: ScenarioType::Concurrent +/// [`Serial`]: ScenarioType::Serial +/// [`Scenario`]: gherkin::Scenario +pub type WhichScenarioFn = fn( + &gherkin::Feature, + Option<&gherkin::Rule>, + &gherkin::Scenario, +) -> ScenarioType; + +/// Alias for [`fn`] executed on each [`Scenario`] before running all [`Step`]s. +/// +/// [`Scenario`]: gherkin::Scenario +/// [`Step`]: gherkin::Step +pub type BeforeHookFn = for<'a> fn( + &'a gherkin::Feature, + Option<&'a gherkin::Rule>, + &'a gherkin::Scenario, + &'a mut World, +) -> LocalBoxFuture<'a, ()>; + +/// Alias for [`fn`] executed on each [`Scenario`] after running all [`Step`]s. +/// +/// [`Scenario`]: gherkin::Scenario +/// [`Step`]: gherkin::Step +pub type AfterHookFn = for<'a> fn( + &'a gherkin::Feature, + Option<&'a gherkin::Rule>, + &'a gherkin::Scenario, + Option<&'a mut World>, +) -> LocalBoxFuture<'a, ()>; + /// Default [`Runner`] implementation which follows [_order guarantees_][1] from /// the [`Runner`] trait docs. /// @@ -90,7 +125,7 @@ pub struct Basic< /// [`Scenario`]: gherkin::Scenario which_scenario: F, - /// Function, executed on every [`Scenario`] before any [`Step`]s, + /// Function, executed on each [`Scenario`] before running all [`Step`]s, /// including [`Background`] ones. /// /// [`Background`]: gherkin::Background @@ -98,7 +133,7 @@ pub struct Basic< /// [`Step`]: gherkin::Step before_hook: Option, - /// Function, executed on every [`Scenario`] after all [`Step`]s. + /// Function, executed on each [`Scenario`] after running all [`Step`]s. /// /// [`Background`]: gherkin::Background /// [`Scenario`]: gherkin::Scenario @@ -106,40 +141,6 @@ pub struct Basic< after_hook: Option, } -/// Alias for [`fn`] used to determine whether a [`Scenario`] is [`Concurrent`] -/// or a [`Serial`] one. -/// -/// [`Concurrent`]: ScenarioType::Concurrent -/// [`Serial`]: ScenarioType::Serial -/// [`Scenario`]: gherkin::Scenario -pub type WhichScenarioFn = fn( - &gherkin::Feature, - Option<&gherkin::Rule>, - &gherkin::Scenario, -) -> ScenarioType; - -/// Alias for [`fn`] executed on every [`Scenario`] before any [`Step`]s. -/// -/// [`Scenario`]: gherkin::Scenario -/// [`Step`]: gherkin::Step -pub type BeforeHookFn = for<'a> fn( - &'a gherkin::Feature, - Option<&'a gherkin::Rule>, - &'a gherkin::Scenario, - &'a mut World, -) -> LocalBoxFuture<'a, ()>; - -/// Alias for [`fn`] executed on every [`Scenario`] after all [`Step`]s. -/// -/// [`Scenario`]: gherkin::Scenario -/// [`Step`]: gherkin::Step -pub type AfterHookFn = for<'a> fn( - &'a gherkin::Feature, - Option<&'a gherkin::Rule>, - &'a gherkin::Scenario, - Option<&'a mut World>, -) -> LocalBoxFuture<'a, ()>; - // Implemented manually to omit redundant trait bounds on `World` and to omit // outputting `F`. impl fmt::Debug for Basic { @@ -167,7 +168,7 @@ impl Basic { impl Default for Basic { fn default() -> Self { - let which: WhichScenarioFn = |_, _, scenario| { + let which_scenario: WhichScenarioFn = |_, _, scenario| { scenario .tags .iter() @@ -179,7 +180,7 @@ impl Default for Basic { Self { max_concurrent_scenarios: Some(64), steps: step::Collection::new(), - which_scenario: which, + which_scenario, before_hook: None, after_hook: None, } @@ -232,8 +233,8 @@ impl Basic { } } - /// Sets hook, executed on every [`Scenario`] before any [`Step`]s, - /// including [`Background`] ones. + /// Sets a hook, executed on each [`Scenario`] before running all its + /// [`Step`]s, including [`Background`] ones. /// /// [`Background`]: gherkin::Background /// [`Scenario`]: gherkin::Scenario @@ -264,16 +265,15 @@ impl Basic { } } - /// Sets hook, executed on every [`Scenario`] after all [`Step`]s even after - /// [`Skipped`] of [`Failed`] [`Step`]s. - /// - /// Last `World` argument is supplied to the function, in case it - /// was initialized before by [`before`] hook or any non-failed [`Step`]. - /// In case last [`Scenario`]'s [`Step`] failed, we want to return event - /// with exact `World` state. Also we don't want to impose additional - /// [`Clone`] bounds on `World`, so the only option left is to pass [`None`] - /// to the function. + /// Sets hook, executed on each [`Scenario`] after running all its + /// [`Step`]s, even after [`Skipped`] of [`Failed`] ones. /// + /// Last `World` argument is supplied to the function, in case it was + /// initialized before by running [`before`] hook or any non-failed + /// [`Step`]. In case the last [`Scenario`]'s [`Step`] failed, we want to + /// return event with an exact `World` state. Also, we don't want to impose + /// additional [`Clone`] bounds on `World`, so the only option left is to + /// pass [`None`] to the function. /// /// [`before`]: Self::before() /// [`Failed`]: event::Step::Failed @@ -542,7 +542,7 @@ struct Executor { /// [`Step`]: step::Step collection: step::Collection, - /// Function, executed on every [`Scenario`] before any [`Step`]s, + /// Function, executed on each [`Scenario`] before running all [`Step`]s, /// including [`Background`] ones. /// /// [`Background`]: gherkin::Background @@ -550,9 +550,8 @@ struct Executor { /// [`Step`]: gherkin::Step before_hook: Option, - /// Function, executed on every [`Scenario`] after all [`Step`]s. + /// Function, executed on each [`Scenario`] after running all [`Step`]s. /// - /// [`Background`]: gherkin::Background /// [`Scenario`]: gherkin::Scenario /// [`Step`]: gherkin::Step after_hook: Option, @@ -608,34 +607,32 @@ where /// [`Feature`]: gherkin::Feature /// [`Rule`]: gherkin::Rule /// [`Scenario`]: gherkin::Scenario + #[allow(clippy::too_many_lines)] async fn run_scenario( &self, - f: Arc, - r: Option>, - s: Arc, + feature: Arc, + rule: Option>, + scenario: Arc, ) { - use event::{ - Cucumber, - Scenario::{Finished, Started}, - }; - let ok = |e: fn(Arc) -> event::Scenario| { - let (f, r, s) = (&f, &r, &s); + let (f, r, s) = (&feature, &rule, &scenario); move |step| { - Cucumber::scenario(f.clone(), r.clone(), s.clone(), e(step)) + let (f, r, s) = (f.clone(), r.clone(), s.clone()); + event::Cucumber::scenario(f, r, s, e(step)) } }; let ok_capt = |e: fn(Arc, _) -> event::Scenario| { - let (f, r, s) = (&f, &r, &s); - move |st, cap| { - Cucumber::scenario(f.clone(), r.clone(), s.clone(), e(st, cap)) + let (f, r, s) = (&feature, &rule, &scenario); + move |step, captures| { + let (f, r, s) = (f.clone(), r.clone(), s.clone()); + event::Cucumber::scenario(f, r, s, e(step, captures)) } }; let err = |e: fn(Arc, _, _, _) -> event::Scenario| { - let (f, r, s) = (&f, &r, &s); + let (f, r, s) = (&feature, &rule, &scenario); move |step, captures, w, info| { let (f, r, s) = (f.clone(), r.clone(), s.clone()); - Cucumber::scenario(f, r, s, e(step, captures, w, info)) + event::Cucumber::scenario(f, r, s, e(step, captures, w, info)) } }; @@ -655,15 +652,20 @@ where event::Scenario::step_failed, ); - self.send(Cucumber::scenario(f.clone(), r.clone(), s.clone(), Started)); + self.send(event::Cucumber::scenario( + feature.clone(), + rule.clone(), + scenario.clone(), + event::Scenario::Started, + )); - let res = async { + let world = async { let before_hook = self - .run_before_hook(&f, r.as_ref(), &s) + .run_before_hook(&feature, rule.as_ref(), &scenario) .await .map_err(|_| None)?; - let feature_background = f + let feature_background = feature .background .as_ref() .map(|b| b.steps.iter().map(|s| Arc::new(s.clone()))) @@ -677,7 +679,7 @@ where }) .await?; - let rule_background = r + let rule_background = rule .as_ref() .map(|rule| { rule.background @@ -696,39 +698,39 @@ where }) .await?; - stream::iter(s.steps.iter().map(|s| Arc::new(s.clone()))) + stream::iter(scenario.steps.iter().map(|s| Arc::new(s.clone()))) .map(Ok) .try_fold(rule_background, |world, step| { self.run_step(world, step, into_step_ev).map_ok(Some) }) .await - }; - - let world = match res.await { - Ok(world) | Err(world) => world, - }; - - drop(self.run_after_hook(world, &f, r.as_ref(), &s).await); - - self.send(Cucumber::scenario( - f.clone(), - r.clone(), - s.clone(), - Finished, + } + .await + .unwrap_or_else(identity); + + self.run_after_hook(world, &feature, rule.as_ref(), &scenario) + .await + .map_or((), drop); + + self.send(event::Cucumber::scenario( + feature.clone(), + rule.clone(), + scenario.clone(), + event::Scenario::Finished, )); - if let Some(rule) = r { - if let Some(fin) = self.rule_scenario_finished(f.clone(), rule) { - self.send(fin); + if let Some(r) = rule { + if let Some(f) = self.rule_scenario_finished(feature.clone(), r) { + self.send(f); } } - if let Some(fin) = self.feature_scenario_finished(f) { - self.send(fin); + if let Some(f) = self.feature_scenario_finished(feature) { + self.send(f); } } - /// Executes [`HookTy::Before`], if present. + /// Executes [`HookType::Before`], if present. async fn run_before_hook( &self, feature: &Arc, @@ -738,7 +740,6 @@ where let init_world = async { let world_fut = async { W::new().await.expect("failed to initialize World") }; - AssertUnwindSafe(world_fut) .catch_unwind() .await @@ -750,7 +751,7 @@ where feature.clone(), rule.map(Arc::clone), scenario.clone(), - event::Scenario::hook_started(HookTy::Before), + event::Scenario::hook_started(HookType::Before), )); let fut = init_world.and_then(|mut world| async { @@ -760,19 +761,19 @@ where scenario.as_ref(), &mut world, ); - return match AssertUnwindSafe(fut).catch_unwind().await { + match AssertUnwindSafe(fut).catch_unwind().await { Ok(()) => Ok(world), Err(info) => Err((info, Some(world))), - }; + } }); - return match fut.await { + match fut.await { Ok(world) => { self.send(event::Cucumber::scenario( feature.clone(), rule.map(Arc::clone), scenario.clone(), - event::Scenario::hook_passed(HookTy::Before), + event::Scenario::hook_passed(HookType::Before), )); Ok(Some(world)) } @@ -782,20 +783,20 @@ where rule.map(Arc::clone), scenario.clone(), event::Scenario::hook_failed( - HookTy::Before, + HookType::Before, world.map(Arc::new), info.into(), ), )); Err(()) } - }; + } + } else { + Ok(None) } - - Ok(None) } - /// Executes [`HookTy::After`], if present. + /// Executes [`HookType::After`], if present. async fn run_after_hook( &self, mut world: Option, @@ -808,7 +809,7 @@ where feature.clone(), rule.map(Arc::clone), scenario.clone(), - event::Scenario::hook_started(HookTy::After), + event::Scenario::hook_started(HookType::After), )); let fut = async { @@ -818,19 +819,19 @@ where scenario.as_ref(), world.as_mut(), ); - return match AssertUnwindSafe(fut).catch_unwind().await { + match AssertUnwindSafe(fut).catch_unwind().await { Ok(()) => Ok(world), Err(info) => Err((info, world)), - }; + } }; - return match fut.await { + match fut.await { Ok(world) => { self.send(event::Cucumber::scenario( feature.clone(), rule.map(Arc::clone), scenario.clone(), - event::Scenario::hook_passed(HookTy::After), + event::Scenario::hook_passed(HookType::After), )); Ok(world) } @@ -840,17 +841,17 @@ where rule.map(Arc::clone), scenario.clone(), event::Scenario::hook_failed( - HookTy::After, + HookType::After, world.map(Arc::new), info.into(), ), )); Err(()) } - }; + } + } else { + Ok(None) } - - Ok(None) } /// Runs a [`Step`]. diff --git a/src/writer/basic.rs b/src/writer/basic.rs index b44230ca..6246c89b 100644 --- a/src/writer/basic.rs +++ b/src/writer/basic.rs @@ -129,7 +129,7 @@ impl Basic { /// Outputs [started] [`Feature`] to STDOUT. /// /// [started]: event::Feature::Started - /// [`Feature`]: [`gherkin::Feature`] + /// [`Feature`]: gherkin::Feature fn feature_started(&mut self, feature: &gherkin::Feature) { self.lines_to_clear = 1; self.write_line( @@ -169,7 +169,7 @@ impl Basic { /// Outputs [started] [`Rule`] to STDOUT. /// /// [started]: event::Rule::Started - /// [`Rule`]: [`gherkin::Rule`] + /// [`Rule`]: gherkin::Rule fn rule_started(&mut self, rule: &gherkin::Rule) { self.lines_to_clear = 1; self.indent += 2; @@ -187,6 +187,7 @@ impl Basic { /// [background]: event::Background /// [started]: event::Scenario::Started /// [step]: event::Step + /// [`Scenario`]: gherkin::Scenario fn scenario( &mut self, feat: &gherkin::Feature, @@ -219,18 +220,22 @@ impl Basic { } } + /// Outputs [failed] [`Scenario`]'s hook to STDOUT. + /// + /// [failed]: event::Hook::Failed + /// [`Scenario`]: gherkin::Scenario fn hook_failed( &mut self, feat: &gherkin::Feature, sc: &gherkin::Scenario, - which: event::HookTy, + which: event::HookType, world: Option<&W>, info: &Info, ) { self.clear_last_lines_if_term_present(); self.write_line(&self.styles.err(format!( - "{indent}\u{2718} {} Scenario hook failed {}:{}:{}\n\ + "{indent}\u{2718} Scenario's {} hook failed {}:{}:{}\n\ {indent} Captured output: {}{}", which, feat.path @@ -249,7 +254,7 @@ impl Basic { /// Outputs [started] [`Scenario`] to STDOUT. /// /// [started]: event::Scenario::Started - /// [`Scenario`]: [`gherkin::Scenario`] + /// [`Scenario`]: gherkin::Scenario fn scenario_started(&mut self, scenario: &gherkin::Scenario) { self.lines_to_clear = 1; self.indent += 2; @@ -268,7 +273,7 @@ impl Basic { /// [passed]: event::Step::Passed /// [skipped]: event::Step::Skipped /// [started]: event::Step::Started - /// [`Step`]: [`gherkin::Step`] + /// [`Step`]: gherkin::Step fn step( &mut self, feat: &gherkin::Feature, @@ -305,7 +310,7 @@ impl Basic { /// [passed]: event::Step::Passed /// [skipped]: event::Step::Skipped /// [started]: event::Step::Started - /// [`Step`]: [`gherkin::Step`] + /// [`Step`]: gherkin::Step fn step_started(&mut self, step: &gherkin::Step) { self.indent += 4; if self.styles.is_present { @@ -327,7 +332,7 @@ impl Basic { /// Outputs [passed] [`Step`] to STDOUT. /// /// [passed]: event::Step::Passed - /// [`Step`]: [`gherkin::Step`] + /// [`Step`]: gherkin::Step fn step_passed( &mut self, step: &gherkin::Step, @@ -362,7 +367,7 @@ impl Basic { /// Outputs [skipped] [`Step`] to STDOUT. /// /// [skipped]: event::Step::Skipped - /// [`Step`]: [`gherkin::Step`] + /// [`Step`]: gherkin::Step fn step_skipped(&mut self, feat: &gherkin::Feature, step: &gherkin::Step) { self.clear_last_lines_if_term_present(); self.write_line(&self.styles.skipped(format!( @@ -388,7 +393,7 @@ impl Basic { /// Outputs [failed] [`Step`] to STDOUT. /// /// [failed]: event::Step::Failed - /// [`Step`]: [`gherkin::Step`] + /// [`Step`]: gherkin::Step fn step_failed( &mut self, feat: &gherkin::Feature, @@ -450,8 +455,8 @@ impl Basic { /// [passed]: event::Step::Passed /// [skipped]: event::Step::Skipped /// [started]: event::Step::Started - /// [`Background`]: [`gherkin::Background`] - /// [`Step`]: [`gherkin::Step`] + /// [`Background`]: gherkin::Background + /// [`Step`]: gherkin::Step fn background( &mut self, feat: &gherkin::Feature, @@ -488,8 +493,8 @@ impl Basic { /// [passed]: event::Step::Passed /// [skipped]: event::Step::Skipped /// [started]: event::Step::Started - /// [`Background`]: [`gherkin::Background`] - /// [`Step`]: [`gherkin::Step`] + /// [`Background`]: gherkin::Background + /// [`Step`]: gherkin::Step fn bg_step_started(&mut self, step: &gherkin::Step) { self.indent += 4; if self.styles.is_present { @@ -511,8 +516,8 @@ impl Basic { /// Outputs [passed] [`Background`] [`Step`] to STDOUT. /// /// [passed]: event::Step::Passed - /// [`Background`]: [`gherkin::Background`] - /// [`Step`]: [`gherkin::Step`] + /// [`Background`]: gherkin::Background + /// [`Step`]: gherkin::Step fn bg_step_passed( &mut self, step: &gherkin::Step, @@ -547,8 +552,8 @@ impl Basic { /// Outputs [skipped] [`Background`] [`Step`] to STDOUT. /// /// [skipped]: event::Step::Skipped - /// [`Background`]: [`gherkin::Background`] - /// [`Step`]: [`gherkin::Step`] + /// [`Background`]: gherkin::Background + /// [`Step`]: gherkin::Step fn bg_step_skipped( &mut self, feat: &gherkin::Feature, @@ -578,8 +583,8 @@ impl Basic { /// Outputs [failed] [`Background`] [`Step`] to STDOUT. /// /// [failed]: event::Step::Failed - /// [`Background`]: [`gherkin::Background`] - /// [`Step`]: [`gherkin::Step`] + /// [`Background`]: gherkin::Background + /// [`Step`]: gherkin::Step fn bg_step_failed( &mut self, feat: &gherkin::Feature, diff --git a/src/writer/summarized.rs b/src/writer/summarized.rs index 77da0149..d886f7b2 100644 --- a/src/writer/summarized.rs +++ b/src/writer/summarized.rs @@ -57,6 +57,34 @@ impl Stats { } } +/// Alias for [`fn`] used to determine should [`Skipped`] test considered as +/// [`Failed`] or not. +/// +/// [`Failed`]: event::Step::Failed +/// [`Skipped`]: event::Step::Skipped +pub type SkipFn = + fn(&gherkin::Feature, Option<&gherkin::Rule>, &gherkin::Scenario) -> bool; + +/// Indicator of a [`Failed`] or [`Skipped`] [`Scenario`]. +/// +/// [`Failed`]: event::Step::Failed +/// [`Scenario`]: gherkin::Scenario +/// [`Skipped`]: event::Step::Skipped +#[derive(Clone, Copy, Debug)] +enum Indicator { + /// [`Failed`] [`Scenario`]. + /// + /// [`Failed`]: event::Step::Failed + /// [`Scenario`]: gherkin::Scenario + Failed, + + /// [`Skipped`] [`Scenario`]. + /// + /// [`Scenario`]: gherkin::Scenario + /// [`Skipped`]: event::Step::Skipped + Skipped, +} + /// Wrapper for a [`Writer`] for outputting an execution summary (number of /// executed features, scenarios, steps and parsing errors). /// @@ -104,35 +132,7 @@ pub struct Summarized { /// Handled [`Scenario`]s to collect [`Stats`]. /// /// [`Scenario`]: gherkin::Scenario - handled_scenarios: HashMap, FailedOrSkipped>, -} - -/// Alias for [`fn`] used to determine should [`Skipped`] test considered as -/// [`Failed`] or not. -/// -/// [`Failed`]: event::Step::Failed -/// [`Skipped`]: event::Step::Skipped -pub type SkipFn = - fn(&gherkin::Feature, Option<&gherkin::Rule>, &gherkin::Scenario) -> bool; - -/// [`Failed`] or [`Skipped`] [`Scenario`]s. -/// -/// [`Failed`]: event::Step::Failed -/// [`Scenario`]: gherkin::Scenario -/// [`Skipped`]: event::Step::Skipped -#[derive(Clone, Copy, Debug)] -enum FailedOrSkipped { - /// [`Failed`] [`Scenario`]. - /// - /// [`Failed`]: event::Step::Failed - /// [`Scenario`]: gherkin::Scenario - Failed, - - /// [`Skipped`] [`Scenario`]. - /// - /// [`Scenario`]: gherkin::Scenario - /// [`Skipped`]: event::Step::Skipped - Skipped, + handled_scenarios: HashMap, Indicator>, } #[async_trait(?Send)] @@ -238,7 +238,7 @@ impl Summarized { ) { use self::{ event::Step, - FailedOrSkipped::{Failed, Skipped}, + Indicator::{Failed, Skipped}, }; match ev { @@ -279,8 +279,8 @@ impl Summarized { // - If Scenario executed no Steps and then Hook failed, we // track Scenario as failed. match self.handled_scenarios.get(scenario) { - Some(FailedOrSkipped::Failed) => {} - Some(FailedOrSkipped::Skipped) => { + Some(Indicator::Failed) => {} + Some(Indicator::Skipped) => { self.scenarios.skipped -= 1; self.scenarios.failed += 1; } @@ -288,7 +288,7 @@ impl Summarized { self.scenarios.failed += 1; let _ = self .handled_scenarios - .insert(scenario.clone(), FailedOrSkipped::Failed); + .insert(scenario.clone(), Indicator::Failed); } } self.failed_hooks += 1; @@ -345,11 +345,11 @@ impl Styles { .unwrap_or_default(); let comma = (!parsing_errors.is_empty() && !hook_errors.is_empty()) - .then(|| self.err(",")) + .then(|| self.err(", ")) .unwrap_or_default(); format!( - "{}\n{}\n{}{}{}\n{}{}\n{}{} {}", + "{}\n{}\n{}{}{}\n{}{}\n{}{}{}", self.bold(self.header("[Summary]")), features, rules, diff --git a/tests/wait.rs b/tests/wait.rs index 08c6a79c..ec87e380 100644 --- a/tests/wait.rs +++ b/tests/wait.rs @@ -26,7 +26,7 @@ async fn main() { .expect_err("should err"); let err = err.downcast_ref::().unwrap(); - assert_eq!(err, "2 steps failed, 1 parsing error, 0 hook errors"); + assert_eq!(err, "2 steps failed, 1 parsing error"); } #[given(regex = r"(\d+) secs?")] From 609c29d78600e1a86f7a662d6ef54eb93c009886 Mon Sep 17 00:00:00 2001 From: ilslv Date: Mon, 18 Oct 2021 14:01:38 +0300 Subject: [PATCH 12/25] Fix clap at beta.5 to prevent updating it with breaking changes --- Cargo.toml | 2 +- src/cli.rs | 3 +-- src/cucumber.rs | 2 +- 3 files changed, 3 insertions(+), 4 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index a1b6f681..aa8f9fe4 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -31,7 +31,7 @@ macros = ["cucumber-codegen", "inventory"] [dependencies] async-trait = "0.1.40" atty = "0.2.14" -clap = "3.0.0-beta.4" +clap = "=3.0.0-beta.5" console = "0.14.1" derive_more = { version = "0.99.16", features = ["deref", "display", "error", "from"], default_features = false } either = "1.6" diff --git a/src/cli.rs b/src/cli.rs index 5e604181..79640e04 100644 --- a/src/cli.rs +++ b/src/cli.rs @@ -10,7 +10,6 @@ //! CLI options. -use clap::Clap; use regex::Regex; /// Run the tests, pet a dog!. @@ -20,7 +19,7 @@ use regex::Regex; /// [cucumber-rs/cucumber#134][1]. /// /// [1]: https://github.com/cucumber-rs/cucumber/issues/134 -#[derive(Clap, Debug)] +#[derive(Debug, clap::Parser)] pub struct Opts { /// Regex to select scenarios from. #[clap(short = 'e', long = "expression", name = "regex")] diff --git a/src/cucumber.rs b/src/cucumber.rs index 0087c0e1..f0451049 100644 --- a/src/cucumber.rs +++ b/src/cucumber.rs @@ -20,7 +20,7 @@ use std::{ path::Path, }; -use clap::Clap as _; +use clap::Parser as _; use futures::{future::LocalBoxFuture, StreamExt as _}; use regex::Regex; From 54b714e90d5c77825f22adc84d2653f69c2709e3 Mon Sep 17 00:00:00 2001 From: tyranron Date: Mon, 18 Oct 2021 13:59:53 +0300 Subject: [PATCH 13/25] Fix `clap` to `3.0.0-beta.5` version --- Cargo.toml | 2 +- src/cli.rs | 2 +- src/cucumber.rs | 134 +++++++++--------------------------------------- 3 files changed, 26 insertions(+), 112 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index aa8f9fe4..139555d7 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -31,7 +31,7 @@ macros = ["cucumber-codegen", "inventory"] [dependencies] async-trait = "0.1.40" atty = "0.2.14" -clap = "=3.0.0-beta.5" +clap = { version = "=3.0.0-beta.5", features = ["derive"] } console = "0.14.1" derive_more = { version = "0.99.16", features = ["deref", "display", "error", "from"], default_features = false } either = "1.6" diff --git a/src/cli.rs b/src/cli.rs index 79640e04..0106fb09 100644 --- a/src/cli.rs +++ b/src/cli.rs @@ -19,7 +19,7 @@ use regex::Regex; /// [cucumber-rs/cucumber#134][1]. /// /// [1]: https://github.com/cucumber-rs/cucumber/issues/134 -#[derive(Debug, clap::Parser)] +#[derive(clap::Parser, Debug)] pub struct Opts { /// Regex to select scenarios from. #[clap(short = 'e', long = "expression", name = "regex")] diff --git a/src/cucumber.rs b/src/cucumber.rs index f0451049..db5cfe53 100644 --- a/src/cucumber.rs +++ b/src/cucumber.rs @@ -21,7 +21,7 @@ use std::{ }; use clap::Parser as _; -use futures::{future::LocalBoxFuture, StreamExt as _}; +use futures::StreamExt as _; use regex::Regex; use crate::{ @@ -774,9 +774,22 @@ where I: AsRef, { fn default() -> Self { + let which: runner::basic::WhichScenarioFn = |_, _, scenario| { + scenario + .tags + .iter() + .any(|tag| tag == "serial") + .then(|| ScenarioType::Serial) + .unwrap_or(ScenarioType::Concurrent) + }; + Cucumber::custom() .with_parser(parser::Basic::new()) - .with_runner(runner::Basic::default()) + .with_runner( + runner::Basic::custom() + .which_scenario(which) + .max_concurrent_scenarios(64), + ) .with_writer(writer::Basic::new().normalized().summarized()) } } @@ -827,7 +840,7 @@ impl Cucumber { } } -impl Cucumber, Wr> { +impl Cucumber, Wr> { /// If `max` is [`Some`] number of concurrently executed [`Scenario`]s will /// be limited. /// @@ -851,7 +864,7 @@ impl Cucumber, Wr> { pub fn which_scenario( self, func: Which, - ) -> Cucumber, Wr> + ) -> Cucumber, Wr> where Which: Fn( &gherkin::Feature, @@ -875,84 +888,6 @@ impl Cucumber, Wr> { } } - /// Sets a hook, executed on each [`Scenario`] before running all its - /// [`Step`]s, including [`Background`] ones. - /// - /// [`Background`]: gherkin::Background - /// [`Scenario`]: gherkin::Scenario - /// [`Step`]: gherkin::Step - #[must_use] - pub fn before( - self, - func: Before, - ) -> Cucumber, Wr> - where - Before: for<'a> Fn( - &'a gherkin::Feature, - Option<&'a gherkin::Rule>, - &'a gherkin::Scenario, - &'a mut W, - ) -> LocalBoxFuture<'a, ()>, - { - let Self { - parser, - runner, - writer, - .. - } = self; - Cucumber { - parser, - runner: runner.before(func), - writer, - _world: PhantomData, - _parser_input: PhantomData, - } - } - - /// Sets a hook, executed on each [`Scenario`] after running all its - /// [`Step`]s, even after [`Skipped`] of [`Failed`] [`Step`]s. - /// - /// Last `World` argument is supplied to the function, in case it was - /// initialized before by running [`before`] hook or any non-failed - /// [`Step`]. In case the last [`Scenario`]'s [`Step`] failed, we want to - /// return event with an exact `World` state. Also, we don't want to impose - /// additional [`Clone`] bounds on `World`, so the only option left is to - /// pass [`None`] to the function. - /// - /// - /// [`before`]: Self::before() - /// [`Failed`]: event::Step::Failed - /// [`Scenario`]: gherkin::Scenario - /// [`Skipped`]: event::Step::Skipped - /// [`Step`]: gherkin::Step - #[must_use] - pub fn after( - self, - func: After, - ) -> Cucumber, Wr> - where - After: for<'a> Fn( - &'a gherkin::Feature, - Option<&'a gherkin::Rule>, - &'a gherkin::Scenario, - Option<&'a mut W>, - ) -> LocalBoxFuture<'a, ()>, - { - let Self { - parser, - runner, - writer, - .. - } = self; - Cucumber { - parser, - runner: runner.after(func), - writer, - _world: PhantomData, - _parser_input: PhantomData, - } - } - /// Replaces [`Collection`] of [`Step`]s. /// /// [`Collection`]: step::Collection @@ -1092,36 +1027,15 @@ where { let writer = self.filter_run(input, filter).await; if writer.execution_has_failed() { - let mut msg = Vec::with_capacity(3); - let failed_steps = writer.failed_steps(); - if failed_steps > 0 { - msg.push(format!( - "{} step{} failed", - failed_steps, - (failed_steps > 1).then(|| "s").unwrap_or_default(), - )); - } - let parsing_errors = writer.parsing_errors(); - if parsing_errors > 0 { - msg.push(format!( - "{} parsing error{}", - parsing_errors, - (parsing_errors > 1).then(|| "s").unwrap_or_default(), - )); - } - - let hook_errors = writer.hook_errors(); - if hook_errors > 0 { - msg.push(format!( - "{} hook error{}", - hook_errors, - (hook_errors > 1).then(|| "s").unwrap_or_default(), - )); - } - - panic!("{}", msg.join(", ")); + panic!( + "{} step{} failed, {} parsing error{}", + failed_steps, + (failed_steps != 1).then(|| "s").unwrap_or_default(), + parsing_errors, + (parsing_errors != 1).then(|| "s").unwrap_or_default(), + ); } } } From 558a9a4e382fa18b682140b209dc8e18973fb74d Mon Sep 17 00:00:00 2001 From: tyranron Date: Mon, 18 Oct 2021 14:24:44 +0300 Subject: [PATCH 14/25] Restore bad merge --- book/tests/Cargo.toml | 2 +- src/cucumber.rs | 134 ++++++++++++++++++++++++++++++++++-------- 2 files changed, 111 insertions(+), 25 deletions(-) diff --git a/book/tests/Cargo.toml b/book/tests/Cargo.toml index e01a6c3c..cc74553e 100644 --- a/book/tests/Cargo.toml +++ b/book/tests/Cargo.toml @@ -12,7 +12,7 @@ publish = false [dependencies] async-trait = "0.1" -cucumber = { path = "../.." } +cucumber = { version = "0.10", path = "../.." } futures = "0.3" skeptic = "0.13" tokio = { version = "1", features = ["macros", "rt-multi-thread", "time"] } diff --git a/src/cucumber.rs b/src/cucumber.rs index db5cfe53..f0451049 100644 --- a/src/cucumber.rs +++ b/src/cucumber.rs @@ -21,7 +21,7 @@ use std::{ }; use clap::Parser as _; -use futures::StreamExt as _; +use futures::{future::LocalBoxFuture, StreamExt as _}; use regex::Regex; use crate::{ @@ -774,22 +774,9 @@ where I: AsRef, { fn default() -> Self { - let which: runner::basic::WhichScenarioFn = |_, _, scenario| { - scenario - .tags - .iter() - .any(|tag| tag == "serial") - .then(|| ScenarioType::Serial) - .unwrap_or(ScenarioType::Concurrent) - }; - Cucumber::custom() .with_parser(parser::Basic::new()) - .with_runner( - runner::Basic::custom() - .which_scenario(which) - .max_concurrent_scenarios(64), - ) + .with_runner(runner::Basic::default()) .with_writer(writer::Basic::new().normalized().summarized()) } } @@ -840,7 +827,7 @@ impl Cucumber { } } -impl Cucumber, Wr> { +impl Cucumber, Wr> { /// If `max` is [`Some`] number of concurrently executed [`Scenario`]s will /// be limited. /// @@ -864,7 +851,7 @@ impl Cucumber, Wr> { pub fn which_scenario( self, func: Which, - ) -> Cucumber, Wr> + ) -> Cucumber, Wr> where Which: Fn( &gherkin::Feature, @@ -888,6 +875,84 @@ impl Cucumber, Wr> { } } + /// Sets a hook, executed on each [`Scenario`] before running all its + /// [`Step`]s, including [`Background`] ones. + /// + /// [`Background`]: gherkin::Background + /// [`Scenario`]: gherkin::Scenario + /// [`Step`]: gherkin::Step + #[must_use] + pub fn before( + self, + func: Before, + ) -> Cucumber, Wr> + where + Before: for<'a> Fn( + &'a gherkin::Feature, + Option<&'a gherkin::Rule>, + &'a gherkin::Scenario, + &'a mut W, + ) -> LocalBoxFuture<'a, ()>, + { + let Self { + parser, + runner, + writer, + .. + } = self; + Cucumber { + parser, + runner: runner.before(func), + writer, + _world: PhantomData, + _parser_input: PhantomData, + } + } + + /// Sets a hook, executed on each [`Scenario`] after running all its + /// [`Step`]s, even after [`Skipped`] of [`Failed`] [`Step`]s. + /// + /// Last `World` argument is supplied to the function, in case it was + /// initialized before by running [`before`] hook or any non-failed + /// [`Step`]. In case the last [`Scenario`]'s [`Step`] failed, we want to + /// return event with an exact `World` state. Also, we don't want to impose + /// additional [`Clone`] bounds on `World`, so the only option left is to + /// pass [`None`] to the function. + /// + /// + /// [`before`]: Self::before() + /// [`Failed`]: event::Step::Failed + /// [`Scenario`]: gherkin::Scenario + /// [`Skipped`]: event::Step::Skipped + /// [`Step`]: gherkin::Step + #[must_use] + pub fn after( + self, + func: After, + ) -> Cucumber, Wr> + where + After: for<'a> Fn( + &'a gherkin::Feature, + Option<&'a gherkin::Rule>, + &'a gherkin::Scenario, + Option<&'a mut W>, + ) -> LocalBoxFuture<'a, ()>, + { + let Self { + parser, + runner, + writer, + .. + } = self; + Cucumber { + parser, + runner: runner.after(func), + writer, + _world: PhantomData, + _parser_input: PhantomData, + } + } + /// Replaces [`Collection`] of [`Step`]s. /// /// [`Collection`]: step::Collection @@ -1027,15 +1092,36 @@ where { let writer = self.filter_run(input, filter).await; if writer.execution_has_failed() { + let mut msg = Vec::with_capacity(3); + let failed_steps = writer.failed_steps(); + if failed_steps > 0 { + msg.push(format!( + "{} step{} failed", + failed_steps, + (failed_steps > 1).then(|| "s").unwrap_or_default(), + )); + } + let parsing_errors = writer.parsing_errors(); - panic!( - "{} step{} failed, {} parsing error{}", - failed_steps, - (failed_steps != 1).then(|| "s").unwrap_or_default(), - parsing_errors, - (parsing_errors != 1).then(|| "s").unwrap_or_default(), - ); + if parsing_errors > 0 { + msg.push(format!( + "{} parsing error{}", + parsing_errors, + (parsing_errors > 1).then(|| "s").unwrap_or_default(), + )); + } + + let hook_errors = writer.hook_errors(); + if hook_errors > 0 { + msg.push(format!( + "{} hook error{}", + hook_errors, + (hook_errors > 1).then(|| "s").unwrap_or_default(), + )); + } + + panic!("{}", msg.join(", ")); } } } From c8919bd617c605b1e52ea77eb6e14327f188a20f Mon Sep 17 00:00:00 2001 From: ilslv Date: Mon, 18 Oct 2021 14:56:41 +0300 Subject: [PATCH 15/25] Corrections --- src/runner/basic.rs | 32 ++++++++++++++++---------------- src/writer/summarized.rs | 2 ++ 2 files changed, 18 insertions(+), 16 deletions(-) diff --git a/src/runner/basic.rs b/src/runner/basic.rs index ecb63068..1a7c6b64 100644 --- a/src/runner/basic.rs +++ b/src/runner/basic.rs @@ -643,20 +643,14 @@ where event::Cucumber::scenario(f, r, s, e(step, captures)) } }; - let panic_err = - |e: fn(Arc, _, _, _) -> event::Scenario| { - let (f, r, s) = (&feature, &rule, &scenario); - move |step, captures, w, info| { - let (f, r, s) = (f.clone(), r.clone(), s.clone()); - event::Cucumber::scenario( - f, - r, - s, - e(step, captures, w, info), - ) - } - }; - let amb_err = |e: fn(Arc, _) -> event::Scenario| { + let panic_err = |e: fn(_, _, _, _) -> event::Scenario| { + let (f, r, s) = (&feature, &rule, &scenario); + move |step, captures, w, info| { + let (f, r, s) = (f.clone(), r.clone(), s.clone()); + event::Cucumber::scenario(f, r, s, e(step, captures, w, info)) + } + }; + let ambiguous_err = |e: fn(_, _) -> event::Scenario| { let (f, r, s) = (&feature, &rule, &scenario); move |st, err| { event::Cucumber::scenario( @@ -668,8 +662,14 @@ where } }; - let compose = |st, ps, sk, fl, amb| { - (ok(st), ok_capt(ps), ok(sk), panic_err(fl), amb_err(amb)) + let compose = |started, passed, skipped, failed, ambiguous| { + ( + ok(started), + ok_capt(passed), + ok(skipped), + panic_err(failed), + ambiguous_err(ambiguous), + ) }; let into_bg_step_ev = compose( event::Scenario::background_step_started, diff --git a/src/writer/summarized.rs b/src/writer/summarized.rs index 9f5a93f4..41464cf1 100644 --- a/src/writer/summarized.rs +++ b/src/writer/summarized.rs @@ -337,11 +337,13 @@ impl Styles { ) }) .unwrap_or_default(); + let hook_errors = (summary.failed_hooks > 0) .then(|| { self.err(self.maybe_plural("hook error", summary.failed_hooks)) }) .unwrap_or_default(); + let comma = (!parsing_errors.is_empty() && !hook_errors.is_empty()) .then(|| self.err(", ")) .unwrap_or_default(); From e88e14e817251051e9614c136fb3922717911ff1 Mon Sep 17 00:00:00 2001 From: ilslv Date: Mon, 18 Oct 2021 15:17:20 +0300 Subject: [PATCH 16/25] Corrections --- src/step.rs | 2 +- src/writer/basic.rs | 10 ++++------ 2 files changed, 5 insertions(+), 7 deletions(-) diff --git a/src/step.rs b/src/step.rs index 3c1360cf..c455ad3a 100644 --- a/src/step.rs +++ b/src/step.rs @@ -186,7 +186,7 @@ impl Collection { return Err(AmbiguousMatchError { possible_matches: matches .into_iter() - .map(|(re, pos, ..)| (re.clone(), pos.clone())) + .map(|(re, loc, ..)| (re.clone(), loc.clone())) .collect(), }) } diff --git a/src/writer/basic.rs b/src/writer/basic.rs index 43782754..532cffbf 100644 --- a/src/writer/basic.rs +++ b/src/writer/basic.rs @@ -739,14 +739,12 @@ fn coerce_error(err: &Info) -> String { /// Formats the given [`Debug`] implementor, then adds `indent`s to each line to /// prettify the output. -fn format_debug_with_indent<'w, O, W: 'w + Debug>( - world: O, - indent: usize, -) -> String +fn format_debug_with_indent<'d, D, I>(debug: I, indent: usize) -> String where - O: Into>, + D: Debug + 'd, + I: Into>, { - let world = world + let world = debug .into() .map(|world| format!("{:#?}", world)) .unwrap_or_default() From c8833f73af219c538712457ee14be7cdb1c6328e Mon Sep 17 00:00:00 2001 From: ilslv Date: Mon, 18 Oct 2021 15:39:08 +0300 Subject: [PATCH 17/25] Corrections --- book/src/Test_Modules_Organization.md | 2 +- src/runner/basic.rs | 4 ++-- src/step.rs | 12 +++++++----- src/writer/basic.rs | 11 +++++------ tests/output.rs | 7 ++++--- 5 files changed, 19 insertions(+), 17 deletions(-) diff --git a/book/src/Test_Modules_Organization.md b/book/src/Test_Modules_Organization.md index 41189001..8d271253 100644 --- a/book/src/Test_Modules_Organization.md +++ b/book/src/Test_Modules_Organization.md @@ -26,7 +26,7 @@ Avoid writing similar step definitions, as they can lead to clutter. While docum ## Managing growth -To help with non-intuitive and frustrating problems that can be encountered in case your `Step` is matched by multiple functions, annotated with `Step` attributes, we propagate that case as an [`AmbiguousMatchError`](https://docs.rs/cucumber/*cucumber/event/enum.Step.html#variant.AmbiguousMatch). +To help with non-intuitive and frustrating problems that can be encountered in case your `Step` is matched by multiple functions, annotated with `Step` attributes, we propagate that case as an [`AmbiguousMatchError`](https://docs.rs/cucumber/*/cucumber/event/enum.Step.html#variant.AmbiguousMatch). As your test suit grows, it may become harder to notice how minimal changes to `regex`es can lead to mismatched `Step`s. To avoid this, we recommend using [`Cucumber::fail_on_skipped()`](https://docs.rs/cucumber/*/cucumber/struct.Cucumber.html#method.fail_on_skipped) combining with `@allow_skipped` tag. This will allow you to mark out `Scenario`s which `Step`s are allowed to skip. diff --git a/src/runner/basic.rs b/src/runner/basic.rs index 10b1b779..f7434d34 100644 --- a/src/runner/basic.rs +++ b/src/runner/basic.rs @@ -629,14 +629,14 @@ where rule: Option>, scenario: Arc, ) { - let ok = |e: fn(Arc) -> event::Scenario| { + let ok = |e: fn(_) -> event::Scenario| { let (f, r, s) = (&feature, &rule, &scenario); move |step| { let (f, r, s) = (f.clone(), r.clone(), s.clone()); event::Cucumber::scenario(f, r, s, e(step)) } }; - let ok_capt = |e: fn(Arc, _) -> event::Scenario| { + let ok_capt = |e: fn(_, _) -> event::Scenario| { let (f, r, s) = (&feature, &rule, &scenario); move |step, captures| { let (f, r, s) = (f.clone(), r.clone(), s.clone()); diff --git a/src/step.rs b/src/step.rs index c455ad3a..6455e716 100644 --- a/src/step.rs +++ b/src/step.rs @@ -31,14 +31,16 @@ use regex::Regex; pub type Step = for<'a> fn(&'a mut World, Context) -> LocalBoxFuture<'a, ()>; -/// Alias for return value of [`Collection::find()`]. -pub type FindValue<'me, World> = +/// Alias for [`Step`] with [`CaptureLocations`] and [`Context`] returned by +/// [`Collection::find()`]. +/// +/// [`CaptureLocations`]: regex::CaptureLocations +pub type WithContext<'me, World> = (&'me Step, regex::CaptureLocations, Context); /// Collection of [`Step`]s. /// -/// Every [`Step`] must be matched by exactly 1 [`Regex`]. Otherwise -/// [`AmbiguousMatchError`] will be returned. +/// Every [`Step`] must be matched by exactly 1 [`Regex`]. pub struct Collection { given: BTreeMap<(HashableRegex, Option), Step>, when: BTreeMap<(HashableRegex, Option), Step>, @@ -157,7 +159,7 @@ impl Collection { pub fn find( &self, step: &gherkin::Step, - ) -> Result>, AmbiguousMatchError> { + ) -> Result>, AmbiguousMatchError> { let collection = match step.ty { StepType::Given => &self.given, StepType::When => &self.when, diff --git a/src/writer/basic.rs b/src/writer/basic.rs index f6587a3a..8a015fcc 100644 --- a/src/writer/basic.rs +++ b/src/writer/basic.rs @@ -24,8 +24,7 @@ use regex::CaptureLocations; use crate::{ event::{self, Info}, - parser, - step::AmbiguousMatchError, + parser, step, writer::term::Styles, ArbitraryWriter, World, Writer, }; @@ -457,13 +456,13 @@ impl Basic { /// Outputs [ambiguous] [`Step`] to STDOUT. /// - /// [ambiguous]: event::Step::Ambiguous + /// [ambiguous]: event::Step::AmbiguousMatch /// [`Step`]: [`gherkin::Step`] fn step_ambiguous_match( &mut self, feat: &gherkin::Feature, step: &gherkin::Step, - err: &AmbiguousMatchError, + err: &step::AmbiguousMatchError, ) { self.clear_last_lines_if_term_present(); @@ -688,14 +687,14 @@ impl Basic { /// Outputs [ambiguous] [`Background`] [`Step`] to STDOUT. /// - /// [ambiguous]: event::Step::Ambiguous + /// [ambiguous]: event::Step::AmbiguousMatch /// [`Background`]: [`gherkin::Background`] /// [`Step`]: [`gherkin::Step`] fn bg_step_ambiguous_match( &mut self, feat: &gherkin::Feature, step: &gherkin::Step, - err: &AmbiguousMatchError, + err: &step::AmbiguousMatchError, ) { self.clear_last_lines_if_term_present(); diff --git a/tests/output.rs b/tests/output.rs index 562eb2dc..3b242b0f 100644 --- a/tests/output.rs +++ b/tests/output.rs @@ -31,8 +31,9 @@ impl cucumber::World for World { #[derive(Default)] struct DebugWriter(String); -// This regex exists to make tests work on Windows, Linux and macOS. -static SPAN_AND_PATH_RE: Lazy = Lazy::new(|| { +// This regex exists to make tests work on Windows, Linux and macOS by +// replacing `Span { .. }` and `path: ..`. +static SPAN_OR_PATH_RE: Lazy = Lazy::new(|| { Regex::new( "( span: Span \\{ start: (\\d+), end: (\\d+) },\ | path: (None|(Some\\()?\"[^\"]*\")\\)?,?)", @@ -51,7 +52,7 @@ impl Writer for DebugWriter { Ok(ev) => format!("{:?}", ev).into(), }; - let without_span = SPAN_AND_PATH_RE.replace_all(ev.as_ref(), ""); + let without_span = SPAN_OR_PATH_RE.replace_all(ev.as_ref(), ""); self.0.push_str(without_span.as_ref()); } From 5b7ecc28988ea80c335f89d947f4fa4fbeeb2233 Mon Sep 17 00:00:00 2001 From: ilslv Date: Mon, 18 Oct 2021 15:41:37 +0300 Subject: [PATCH 18/25] Fmt --- src/step.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/step.rs b/src/step.rs index 6455e716..1149b04b 100644 --- a/src/step.rs +++ b/src/step.rs @@ -31,9 +31,9 @@ use regex::Regex; pub type Step = for<'a> fn(&'a mut World, Context) -> LocalBoxFuture<'a, ()>; -/// Alias for [`Step`] with [`CaptureLocations`] and [`Context`] returned by +/// Alias for [`Step`] with [`CaptureLocations`] and [`Context`] returned by /// [`Collection::find()`]. -/// +/// /// [`CaptureLocations`]: regex::CaptureLocations pub type WithContext<'me, World> = (&'me Step, regex::CaptureLocations, Context); From 97d7b25f3e7c4f8fe31be55e1d8436a9faf12d73 Mon Sep 17 00:00:00 2001 From: tyranron Date: Mon, 18 Oct 2021 19:53:40 +0300 Subject: [PATCH 19/25] Some corrections [skip ci] --- codegen/src/attribute.rs | 8 ++--- src/event.rs | 9 +++--- src/runner/basic.rs | 8 ++--- src/step.rs | 66 ++++++++++++++++++---------------------- tests/output.rs | 20 ++++++------ 5 files changed, 49 insertions(+), 62 deletions(-) diff --git a/codegen/src/attribute.rs b/codegen/src/attribute.rs index 449747a8..57492bd5 100644 --- a/codegen/src/attribute.rs +++ b/codegen/src/attribute.rs @@ -108,7 +108,7 @@ impl Step { let world = parse_world_from_args(&self.func.sig)?; let constructor_method = self.constructor_method(); let (func_args, addon_parsing) = - self.fn_arguments_and_addition_parsing()?; + self.fn_arguments_and_additional_parsing()?; let step_matcher = self.attr_arg.regex_literal().value(); let caller_name = @@ -159,10 +159,10 @@ impl Step { }) } - /// Generates code that prepares function's arguments based on - /// [`AttributeArgument`] and additional parsing if it's + /// Generates code that prepares function's arguments basing on + /// [`AttributeArgument`] and additional parsing if it's an /// [`AttributeArgument::Regex`]. - fn fn_arguments_and_addition_parsing( + fn fn_arguments_and_additional_parsing( &self, ) -> syn::Result<(TokenStream, Option)> { let is_regex = matches!(self.attr_arg, AttributeArgument::Regex(_)); diff --git a/src/event.rs b/src/event.rs index f09ec0e9..06614bda 100644 --- a/src/event.rs +++ b/src/event.rs @@ -190,7 +190,7 @@ pub enum Step { /// [`Step`]: gherkin::Step Started, - /// [`Step`] matched by multiple [`Regex`]es. + /// [`Step`] matches multiple [`Regex`]es. /// /// [`Regex`]: regex::Regex /// [`Step`]: gherkin::Step @@ -366,8 +366,7 @@ impl Scenario { Self::Step(step, Step::Started) } - /// Constructs an event of a [`Step`] being matched to more than 1 - /// [`Regex`]. + /// Constructs an event of a [`Step`] matching multiple [`Regex`]es. /// /// [`Regex`]: regex::Regex /// [`Step`]: gherkin::Step @@ -379,8 +378,8 @@ impl Scenario { Self::Step(step, Step::AmbiguousMatch(err)) } - /// Constructs an event of a [`Background`] [`Step`] being matched to more - /// than 1 [`Regex`]. + /// Constructs an event of a [`Background`] [`Step`] matching multiple + /// [`Regex`]es. /// /// [`Background`]: gherkin::Background /// [`Regex`]: regex::Regex diff --git a/src/runner/basic.rs b/src/runner/basic.rs index f7434d34..4d3eebd6 100644 --- a/src/runner/basic.rs +++ b/src/runner/basic.rs @@ -653,12 +653,8 @@ where let ambiguous_err = |e: fn(_, _) -> event::Scenario| { let (f, r, s) = (&feature, &rule, &scenario); move |st, err| { - event::Cucumber::scenario( - f.clone(), - r.clone(), - s.clone(), - e(st, err), - ) + let (f, r, s) = (f.clone(), r.clone(), s.clone()); + event::Cucumber::scenario(f, r, s, e(st, err)) } }; diff --git a/src/step.rs b/src/step.rs index 1149b04b..ca7324fa 100644 --- a/src/step.rs +++ b/src/step.rs @@ -31,35 +31,20 @@ use regex::Regex; pub type Step = for<'a> fn(&'a mut World, Context) -> LocalBoxFuture<'a, ()>; -/// Alias for [`Step`] with [`CaptureLocations`] and [`Context`] returned by -/// [`Collection::find()`]. -/// -/// [`CaptureLocations`]: regex::CaptureLocations +/// Alias for a [`Step`] with [`regex::CaptureLocations`] and [`Context`] +/// returned by [`Collection::find()`]. pub type WithContext<'me, World> = (&'me Step, regex::CaptureLocations, Context); /// Collection of [`Step`]s. /// -/// Every [`Step`] must be matched by exactly 1 [`Regex`]. +/// Every [`Step`] has to be matched by exactly 1 [`Regex`]. pub struct Collection { given: BTreeMap<(HashableRegex, Option), Step>, when: BTreeMap<(HashableRegex, Option), Step>, then: BTreeMap<(HashableRegex, Option), Step>, } -/// Location of a [`Step`] [`fn`]. Automatically filled by proc macro. -#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)] -pub struct Location { - /// Path to the file, where [`Step`] [`fn`] is located. - pub path: PathBuf, - - /// Line of the file, where [`Step`] [`fn`] is located. - pub line: u32, - - /// Column of the file, where [`Step`] [`fn`] is located. - pub column: u32, -} - impl fmt::Debug for Collection { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { f.debug_struct("Collection") @@ -150,12 +135,12 @@ impl Collection { self } - /// Returns a [`Step`] function matching the given [`gherkin::Step`], - /// if any. + /// Returns a [`Step`] function matching the given [`gherkin::Step`], if + /// any. /// /// # Errors /// - /// If [`gherkin::Step`] is matched by multiple [`Regex`]es. + /// If the given [`gherkin::Step`] matches multiple [`Regex`]es. pub fn find( &self, step: &gherkin::Step, @@ -177,13 +162,7 @@ impl Collection { let (_, _, whole_match, captures, step_fn) = match matches.len() { 0 => return Ok(None), - 1 => { - if let Some(m) = matches.pop() { - m - } else { - unreachable!() - } - } + 1 => matches.pop().unwrap(), _ => { return Err(AmbiguousMatchError { possible_matches: matches @@ -214,14 +193,6 @@ impl Collection { } } -/// Error of a [`gherkin::Step`] being matched by multiple [`Step`] [`Regex`]es -/// inside a [`Collection`]. -#[derive(Clone, Debug)] -pub struct AmbiguousMatchError { - /// Possible [`Regex`]es that matched [`gherkin::Step`]. - pub possible_matches: Vec<(HashableRegex, Option)>, -} - /// Context for a [`Step`] function execution. #[derive(Debug)] pub struct Context { @@ -236,7 +207,28 @@ pub struct Context { pub matches: Vec, } -/// [`Regex`] wrapper that implements [`Eq`], [`Ord`] and [`Hash`]. +/// Error of a [`gherkin::Step`] matching multiple [`Step`] [`Regex`]es inside a +/// [`Collection`]. +#[derive(Clone, Debug)] +pub struct AmbiguousMatchError { + /// Possible [`Regex`]es the [`gherkin::Step`] matches. + pub possible_matches: Vec<(HashableRegex, Option)>, +} + +/// Location of a [`Step`] [`fn`] automatically filled by a proc macro. +#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)] +pub struct Location { + /// Path to the file where [`Step`] [`fn`] is located. + pub path: PathBuf, + + /// Line of the file where [`Step`] [`fn`] is located. + pub line: u32, + + /// Column of the file where [`Step`] [`fn`] is located. + pub column: u32, +} + +/// [`Regex`] wrapper implementing [`Eq`], [`Ord`] and [`Hash`]. #[derive(Clone, Debug, Deref, DerefMut)] pub struct HashableRegex(Regex); diff --git a/tests/output.rs b/tests/output.rs index 3b242b0f..0957840b 100644 --- a/tests/output.rs +++ b/tests/output.rs @@ -31,16 +31,6 @@ impl cucumber::World for World { #[derive(Default)] struct DebugWriter(String); -// This regex exists to make tests work on Windows, Linux and macOS by -// replacing `Span { .. }` and `path: ..`. -static SPAN_OR_PATH_RE: Lazy = Lazy::new(|| { - Regex::new( - "( span: Span \\{ start: (\\d+), end: (\\d+) },\ - | path: (None|(Some\\()?\"[^\"]*\")\\)?,?)", - ) - .unwrap() -}); - #[async_trait(?Send)] impl Writer for DebugWriter { async fn handle_event( @@ -58,6 +48,16 @@ impl Writer for DebugWriter { } } +/// [`Regex`] to unify spans and file paths on Windows, Linux and macOS for +/// tests. +static SPAN_OR_PATH_RE: Lazy = Lazy::new(|| { + Regex::new( + "( span: Span \\{ start: (\\d+), end: (\\d+) },\ + | path: (None|(Some\\()?\"[^\"]*\")\\)?,?)", + ) + .unwrap() +}); + #[cfg(test)] mod spec { use std::fs; From aee364573c059ed48cf8a4deb6962102d8a414cb Mon Sep 17 00:00:00 2001 From: ilslv Date: Tue, 19 Oct 2021 08:12:59 +0300 Subject: [PATCH 20/25] Correction --- codegen/src/attribute.rs | 4 ++-- codegen/src/derive.rs | 6 +++--- src/codegen.rs | 28 ++++++++-------------------- src/step.rs | 10 +++++++++- 4 files changed, 22 insertions(+), 26 deletions(-) diff --git a/codegen/src/attribute.rs b/codegen/src/attribute.rs index 57492bd5..ddff81a1 100644 --- a/codegen/src/attribute.rs +++ b/codegen/src/attribute.rs @@ -145,11 +145,11 @@ impl Step { <#world as ::cucumber::codegen::WorldInventory< _, _, _, >>::#constructor_method( - Some(::cucumber::step::Location { + ::cucumber::step::Location { path: ::std::convert::From::from(::std::file!()), line: ::std::line!(), column: ::std::column!(), - }), + }, ::cucumber::codegen::Regex::new(#step_matcher) .unwrap(), #step_caller, diff --git a/codegen/src/derive.rs b/codegen/src/derive.rs index 57b06372..9895de9a 100644 --- a/codegen/src/derive.rs +++ b/codegen/src/derive.rs @@ -63,7 +63,7 @@ fn generate_step_structs( #[doc(hidden)] #world_vis struct #ty { #[doc(hidden)] - pub loc: ::std::option::Option<::cucumber::step::Location>, + pub loc: ::cucumber::step::Location, #[doc(hidden)] pub regex: ::cucumber::codegen::Regex, @@ -75,7 +75,7 @@ fn generate_step_structs( #[automatically_derived] impl ::cucumber::codegen::StepConstructor<#world> for #ty { fn new ( - loc: ::std::option::Option<::cucumber::step::Location>, + loc: ::cucumber::step::Location, regex: ::cucumber::codegen::Regex, func: ::cucumber::Step<#world>, ) -> Self { @@ -83,7 +83,7 @@ fn generate_step_structs( } fn inner(&self) -> ( - ::std::option::Option<::cucumber::step::Location>, + ::cucumber::step::Location, ::cucumber::codegen::Regex, ::cucumber::Step<#world>, ) { diff --git a/src/codegen.rs b/src/codegen.rs index 716121b1..cafda329 100644 --- a/src/codegen.rs +++ b/src/codegen.rs @@ -42,17 +42,17 @@ where for given in Self::cucumber_given() { let (loc, regex, fun) = given.inner(); - out = out.given(loc, regex, fun); + out = out.given(Some(loc), regex, fun); } for when in Self::cucumber_when() { let (loc, regex, fun) = when.inner(); - out = out.when(loc, regex, fun); + out = out.when(Some(loc), regex, fun); } for then in Self::cucumber_then() { let (loc, regex, fun) = then.inner(); - out = out.then(loc, regex, fun); + out = out.then(Some(loc), regex, fun); } out @@ -143,11 +143,7 @@ where /// /// [`given`]: crate::given /// [Given]: https://cucumber.io/docs/gherkin/reference/#given - fn new_given( - loc: Option, - regex: Regex, - fun: Step, - ) -> G { + fn new_given(loc: step::Location, regex: Regex, fun: Step) -> G { G::new(loc, regex, fun) } @@ -163,11 +159,7 @@ where /// /// [`when`]: crate::when /// [When]: https://cucumber.io/docs/gherkin/reference/#when - fn new_when( - loc: Option, - regex: Regex, - fun: Step, - ) -> W { + fn new_when(loc: step::Location, regex: Regex, fun: Step) -> W { W::new(loc, regex, fun) } @@ -183,11 +175,7 @@ where /// /// [`then`]: crate::then /// [Then]: https://cucumber.io/docs/gherkin/reference/#then - fn new_then( - loc: Option, - regex: Regex, - fun: Step, - ) -> T { + fn new_then(loc: step::Location, regex: Regex, fun: Step) -> T { T::new(loc, regex, fun) } } @@ -202,8 +190,8 @@ where pub trait StepConstructor { /// Creates a new [`Step`] with the corresponding [`Regex`]. #[must_use] - fn new(_: Option, _: Regex, _: Step) -> Self; + fn new(_: step::Location, _: Regex, _: Step) -> Self; /// Returns an inner [`Step`] with the corresponding [`Regex`]. - fn inner(&self) -> (Option, Regex, Step); + fn inner(&self) -> (step::Location, Regex, Step); } diff --git a/src/step.rs b/src/step.rs index ca7324fa..253563e9 100644 --- a/src/step.rs +++ b/src/step.rs @@ -162,7 +162,15 @@ impl Collection { let (_, _, whole_match, captures, step_fn) = match matches.len() { 0 => return Ok(None), - 1 => matches.pop().unwrap(), + 1 => { + if let Some(m) = matches.pop() { + m + } else { + // Instead of `.unwrap()` to avoid documenting `# Panics` + // section. + unreachable!() + } + } _ => { return Err(AmbiguousMatchError { possible_matches: matches From a8b9a9ee93d1162b3de2c49cbfd6519e10961709 Mon Sep 17 00:00:00 2001 From: ilslv Date: Tue, 19 Oct 2021 09:46:07 +0300 Subject: [PATCH 21/25] Refactor Step::AmbiguousMatch into Step::Failed and StepError --- src/event.rs | 66 +++++----- src/runner/basic.rs | 55 +++----- src/step.rs | 5 +- src/writer/basic.rs | 121 +++++------------- src/writer/fail_on_skipped.rs | 21 +-- src/writer/summarized.rs | 2 +- .../output/ambiguous_step.feature.out | 2 +- .../output/scenario_outline_table.feature.out | 2 +- 8 files changed, 92 insertions(+), 182 deletions(-) diff --git a/src/event.rs b/src/event.rs index 06614bda..1881b7f1 100644 --- a/src/event.rs +++ b/src/event.rs @@ -21,7 +21,9 @@ use std::{any::Any, fmt, sync::Arc}; -use crate::step; +use derive_more::{Display, Error, From}; + +use crate::{step, writer::basic::coerce_error}; /// Alias for a [`catch_unwind()`] error. /// @@ -190,12 +192,6 @@ pub enum Step { /// [`Step`]: gherkin::Step Started, - /// [`Step`] matches multiple [`Regex`]es. - /// - /// [`Regex`]: regex::Regex - /// [`Step`]: gherkin::Step - AmbiguousMatch(step::AmbiguousMatchError), - /// [`Step`] being skipped. /// /// That means there is no [`Regex`] matching [`Step`] in a @@ -214,7 +210,30 @@ pub enum Step { /// [`Step`] failed. /// /// [`Step`]: gherkin::Step - Failed(Option, Option>, Info), + Failed( + Option, + Option>, + StepError, + ), +} + +/// [`Step`] error. +/// +/// [`Step`]: gherkin::Step +#[derive(Clone, Debug, Display, Error, From)] +pub enum StepError { + /// [`Step`] matches multiple [`Regex`]es. + /// + /// [`Regex`]: regex::Regex + /// [`Step`]: gherkin::Step + #[display(fmt = "Step match is ambiguous: {}", _0)] + AmbiguousMatch(step::AmbiguousMatchError), + + /// [`Step`] panicked. + /// + /// [`Step`]: gherkin::Step + #[display(fmt = "Step panicked. Captured output: {}", "coerce_error(_0)")] + Panic(#[error(not(source))] Info), } // Manual implementation is required to omit the redundant `World: Clone` trait @@ -223,7 +242,6 @@ impl Clone for Step { fn clone(&self) -> Self { match self { Self::Started => Self::Started, - Self::AmbiguousMatch(e) => Self::AmbiguousMatch(e.clone()), Self::Skipped => Self::Skipped, Self::Passed(captures) => Self::Passed(captures.clone()), Self::Failed(captures, w, info) => { @@ -366,32 +384,6 @@ impl Scenario { Self::Step(step, Step::Started) } - /// Constructs an event of a [`Step`] matching multiple [`Regex`]es. - /// - /// [`Regex`]: regex::Regex - /// [`Step`]: gherkin::Step - #[must_use] - pub fn ambiguous_step( - step: Arc, - err: step::AmbiguousMatchError, - ) -> Self { - Self::Step(step, Step::AmbiguousMatch(err)) - } - - /// Constructs an event of a [`Background`] [`Step`] matching multiple - /// [`Regex`]es. - /// - /// [`Background`]: gherkin::Background - /// [`Regex`]: regex::Regex - /// [`Step`]: gherkin::Step - #[must_use] - pub fn background_ambiguous_step( - step: Arc, - err: step::AmbiguousMatchError, - ) -> Self { - Self::Background(step, Step::AmbiguousMatch(err)) - } - /// Constructs an event of a [`Background`] [`Step`] being started. /// /// [`Background`]: gherkin::Background @@ -448,7 +440,7 @@ impl Scenario { step: Arc, captures: Option, world: Option>, - info: Info, + info: StepError, ) -> Self { Self::Step(step, Step::Failed(captures, world, info)) } @@ -462,7 +454,7 @@ impl Scenario { step: Arc, captures: Option, world: Option>, - info: Info, + info: StepError, ) -> Self { Self::Background(step, Step::Failed(captures, world, info)) } diff --git a/src/runner/basic.rs b/src/runner/basic.rs index 4d3eebd6..0db4bcb8 100644 --- a/src/runner/basic.rs +++ b/src/runner/basic.rs @@ -36,7 +36,7 @@ use itertools::Itertools as _; use regex::{CaptureLocations, Regex}; use crate::{ - event::{self, HookType, Info}, + event::{self, HookType}, feature::Ext as _, parser, step, Runner, Step, World, }; @@ -643,43 +643,27 @@ where event::Cucumber::scenario(f, r, s, e(step, captures)) } }; - let panic_err = |e: fn(_, _, _, _) -> event::Scenario| { + let err = |e: fn(_, _, _, _) -> event::Scenario| { let (f, r, s) = (&feature, &rule, &scenario); move |step, captures, w, info| { let (f, r, s) = (f.clone(), r.clone(), s.clone()); event::Cucumber::scenario(f, r, s, e(step, captures, w, info)) } }; - let ambiguous_err = |e: fn(_, _) -> event::Scenario| { - let (f, r, s) = (&feature, &rule, &scenario); - move |st, err| { - let (f, r, s) = (f.clone(), r.clone(), s.clone()); - event::Cucumber::scenario(f, r, s, e(st, err)) - } - }; - - let compose = |started, passed, skipped, failed, ambiguous| { - ( - ok(started), - ok_capt(passed), - ok(skipped), - panic_err(failed), - ambiguous_err(ambiguous), - ) + let compose = |started, passed, skipped, failed| { + (ok(started), ok_capt(passed), ok(skipped), err(failed)) }; let into_bg_step_ev = compose( event::Scenario::background_step_started, event::Scenario::background_step_passed, event::Scenario::background_step_skipped, event::Scenario::background_step_failed, - event::Scenario::background_ambiguous_step, ); let into_step_ev = compose( event::Scenario::step_started, event::Scenario::step_passed, event::Scenario::step_skipped, event::Scenario::step_failed, - event::Scenario::ambiguous_step, ); self.send(event::Cucumber::scenario( @@ -891,11 +875,11 @@ where /// - Emits all [`Step`] events. /// /// [`Step`]: gherkin::Step - async fn run_step( + async fn run_step( &self, mut world: Option, step: Arc, - (started, passed, skipped, failed, ambiguous): (St, Ps, Sk, F, A), + (started, passed, skipped, failed): (St, Ps, Sk, F), ) -> Result> where St: FnOnce(Arc) -> event::Cucumber, @@ -905,11 +889,7 @@ where Arc, Option, Option>, - Info, - ) -> event::Cucumber, - A: FnOnce( - Arc, - step::AmbiguousMatchError, + event::StepError, ) -> event::Cucumber, { self.send(started(step.clone())); @@ -921,7 +901,9 @@ where }; world = match AssertUnwindSafe(w_fut).catch_unwind().await { Ok(w) => Some(w), - Err(e) => return Err(Some((e, None))), + Err(e) => { + return Err((event::StepError::Panic(e.into()), None)) + } }; } @@ -929,8 +911,7 @@ where Ok(Some(step_fn)) => step_fn, Ok(None) => return Ok(None), Err(e) => { - self.send(ambiguous(step.clone(), e)); - return Err(None); + return Err((event::StepError::AmbiguousMatch(e), None)); } }; @@ -939,7 +920,9 @@ where .await { Ok(()) => Ok(Some(captures)), - Err(e) => Err(Some((e, Some(captures)))), + Err(e) => { + Err((event::StepError::Panic(e.into()), Some(captures))) + } } }; @@ -952,16 +935,10 @@ where self.send(skipped(step)); Err(world) } - Err(Some((err, captures))) => { - self.send(failed( - step, - captures, - world.map(Arc::new), - Arc::from(err), - )); + Err((err, captures)) => { + self.send(failed(step, captures, world.map(Arc::new), err)); Err(None) } - Err(None) => Err(None), } } diff --git a/src/step.rs b/src/step.rs index 253563e9..0b70aac0 100644 --- a/src/step.rs +++ b/src/step.rs @@ -22,7 +22,7 @@ use std::{ path::PathBuf, }; -use derive_more::{Deref, DerefMut}; +use derive_more::{Deref, DerefMut, Display, Error}; use futures::future::LocalBoxFuture; use gherkin::StepType; use regex::Regex; @@ -217,7 +217,8 @@ pub struct Context { /// Error of a [`gherkin::Step`] matching multiple [`Step`] [`Regex`]es inside a /// [`Collection`]. -#[derive(Clone, Debug)] +#[derive(Clone, Debug, Display, Error)] +#[display(fmt = "Possible matches: {:#?}", possible_matches)] pub struct AmbiguousMatchError { /// Possible [`Regex`]es the [`gherkin::Step`] matches. pub possible_matches: Vec<(HashableRegex, Option)>, diff --git a/src/writer/basic.rs b/src/writer/basic.rs index 8a015fcc..e4eae4f0 100644 --- a/src/writer/basic.rs +++ b/src/writer/basic.rs @@ -24,7 +24,7 @@ use regex::CaptureLocations; use crate::{ event::{self, Info}, - parser, step, + parser, writer::term::Styles, ArbitraryWriter, World, Writer, }; @@ -288,10 +288,6 @@ impl Basic { Step::Started => { self.step_started(step); } - Step::AmbiguousMatch(e) => { - self.step_ambiguous_match(feat, step, e); - self.indent = self.indent.saturating_sub(4); - } Step::Passed(captures) => { self.step_passed(step, captures); self.indent = self.indent.saturating_sub(4); @@ -406,7 +402,7 @@ impl Basic { step: &gherkin::Step, captures: Option<&CaptureLocations>, world: Option<&W>, - info: &Info, + err: &event::StepError, ) { self.clear_last_lines_if_term_present(); @@ -442,7 +438,7 @@ impl Basic { .unwrap_or(&feat.name), step.position.line, step.position.col, - coerce_error(info), + format_display_with_indent(err, self.indent.saturating_sub(3) + 3), format_debug_with_indent(world, self.indent.saturating_sub(3) + 3), indent = " ".repeat(self.indent.saturating_sub(3)) )); @@ -454,43 +450,6 @@ impl Basic { .unwrap(); } - /// Outputs [ambiguous] [`Step`] to STDOUT. - /// - /// [ambiguous]: event::Step::AmbiguousMatch - /// [`Step`]: [`gherkin::Step`] - fn step_ambiguous_match( - &mut self, - feat: &gherkin::Feature, - step: &gherkin::Step, - err: &step::AmbiguousMatchError, - ) { - self.clear_last_lines_if_term_present(); - - self.write_line(&self.styles.err(format!( - "{indent}\u{2718} {} {}{}\n\ - {indent} Step match is ambiguous: {}:{}:{}\n\ - {indent} Possible matches: {}", - step.keyword, - step.value, - step.table - .as_ref() - .map(|t| format_table(t, self.indent)) - .unwrap_or_default(), - feat.path - .as_ref() - .and_then(|p| p.to_str()) - .unwrap_or(&feat.name), - step.position.line, - step.position.col, - format_debug_with_indent(&err.possible_matches - .iter() - .map(|(re, loc)| (re.as_str(), loc)) - .collect::>(), self.indent.saturating_sub(3) + 3), - indent = " ".repeat(self.indent.saturating_sub(3)) - ))) - .unwrap(); - } - /// Outputs [`Background`] [`Step`] [started]/[passed]/[skipped]/[failed] /// event to STDOUT. /// @@ -512,9 +471,6 @@ impl Basic { Step::Started => { self.bg_step_started(bg); } - Step::AmbiguousMatch(e) => { - self.bg_step_ambiguous_match(feat, bg, e); - } Step::Passed(captures) => { self.bg_step_passed(bg, captures); self.indent = self.indent.saturating_sub(4); @@ -637,7 +593,7 @@ impl Basic { step: &gherkin::Step, captures: Option<&CaptureLocations>, world: Option<&W>, - info: &Info, + err: &event::StepError, ) { self.clear_last_lines_if_term_present(); @@ -673,7 +629,7 @@ impl Basic { .unwrap_or(&feat.name), step.position.line, step.position.col, - coerce_error(info), + format_display_with_indent(err, self.indent.saturating_sub(3) + 3), format_debug_with_indent(world, self.indent.saturating_sub(3) + 3), indent = " ".repeat(self.indent.saturating_sub(3)) )); @@ -684,51 +640,13 @@ impl Basic { )) .unwrap(); } - - /// Outputs [ambiguous] [`Background`] [`Step`] to STDOUT. - /// - /// [ambiguous]: event::Step::AmbiguousMatch - /// [`Background`]: [`gherkin::Background`] - /// [`Step`]: [`gherkin::Step`] - fn bg_step_ambiguous_match( - &mut self, - feat: &gherkin::Feature, - step: &gherkin::Step, - err: &step::AmbiguousMatchError, - ) { - self.clear_last_lines_if_term_present(); - - self.write_line(&self.styles.err(format!( - "{indent}\u{2718} {} {}{}\n\ - {indent} Background Step match is ambiguous: {}:{}:{}\n\ - {indent} Possible matches: {}", - step.keyword, - step.value, - step.table - .as_ref() - .map(|t| format_table(t, self.indent)) - .unwrap_or_default(), - feat.path - .as_ref() - .and_then(|p| p.to_str()) - .unwrap_or(&feat.name), - step.position.line, - step.position.col, - format_debug_with_indent(&err.possible_matches - .iter() - .map(|(re, loc)| (re.as_str(), loc)) - .collect::>(), self.indent.saturating_sub(3) + 3), - indent = " ".repeat(self.indent.saturating_sub(3)) - ))) - .unwrap(); - } } /// Tries to coerce [`catch_unwind()`] output to [`String`]. /// /// [`catch_unwind()`]: std::panic::catch_unwind() #[must_use] -fn coerce_error(err: &Info) -> String { +pub(crate) fn coerce_error(err: &Info) -> String { if let Some(string) = err.downcast_ref::() { string.clone() } else if let Some(&string) = err.downcast_ref::<&str>() { @@ -745,15 +663,34 @@ where D: Debug + 'd, I: Into>, { - let world = debug + let debug = debug + .into() + .map(|debug| format!("{:#?}", debug)) + .unwrap_or_default() + .lines() + .map(|line| format!("{}{}", " ".repeat(indent), line)) + .join("\n"); + (!debug.is_empty()) + .then(|| format!("\n{}", debug)) + .unwrap_or_default() +} + +/// Formats the given [`Display`] implementor, then adds `indent`s to each line +/// to prettify the output. +fn format_display_with_indent<'d, D, I>(display: I, indent: usize) -> String +where + D: Display + 'd, + I: Into>, +{ + let display = display .into() - .map(|world| format!("{:#?}", world)) + .map(|display| format!("{}", display)) .unwrap_or_default() .lines() .map(|line| format!("{}{}", " ".repeat(indent), line)) .join("\n"); - (!world.is_empty()) - .then(|| format!("\n{}", world)) + (!display.is_empty()) + .then(|| format!("\n{}", display)) .unwrap_or_default() } diff --git a/src/writer/fail_on_skipped.rs b/src/writer/fail_on_skipped.rs index 3cbae312..8dfc8467 100644 --- a/src/writer/fail_on_skipped.rs +++ b/src/writer/fail_on_skipped.rs @@ -62,17 +62,20 @@ where async fn handle_event(&mut self, ev: parser::Result>) { use event::{Cucumber, Feature, Rule, Scenario, Step}; - let map_failed = - |f: Arc<_>, r: Option>, sc: Arc<_>, st: Arc<_>| { - let event = if (self.should_fail)(&f, r.as_deref(), &sc) { - Step::Failed(None, None, Arc::new("not allowed to skip")) - } else { - Step::Skipped - }; - - Ok(Cucumber::scenario(f, r, sc, Scenario::Step(st, event))) + let map_failed = |f: Arc<_>, r: Option>, sc: Arc<_>, st: _| { + let event = if (self.should_fail)(&f, r.as_deref(), &sc) { + Step::Failed( + None, + None, + event::StepError::Panic(Arc::new("not allowed to skip")), + ) + } else { + Step::Skipped }; + Ok(Cucumber::scenario(f, r, sc, Scenario::Step(st, event))) + }; + let ev = match ev { Ok(Cucumber::Feature( f, diff --git a/src/writer/summarized.rs b/src/writer/summarized.rs index 41464cf1..d886f7b2 100644 --- a/src/writer/summarized.rs +++ b/src/writer/summarized.rs @@ -250,7 +250,7 @@ impl Summarized { let _ = self.handled_scenarios.insert(scenario.clone(), Skipped); } - Step::Failed(..) | Step::AmbiguousMatch(..) => { + Step::Failed(..) => { self.steps.failed += 1; self.scenarios.failed += 1; let _ = self.handled_scenarios.insert(scenario.clone(), Failed); diff --git a/tests/features/output/ambiguous_step.feature.out b/tests/features/output/ambiguous_step.feature.out index c837013b..46158277 100644 --- a/tests/features/output/ambiguous_step.feature.out +++ b/tests/features/output/ambiguous_step.feature.out @@ -2,7 +2,7 @@ Started Feature(Feature { keyword: "Feature", name: "ambiguous", description: None, background: None, scenarios: [Scenario { keyword: "Scenario", name: "ambiguous", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Started) Feature(Feature { keyword: "Feature", name: "ambiguous", description: None, background: None, scenarios: [Scenario { keyword: "Scenario", name: "ambiguous", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Scenario(Scenario { keyword: "Scenario", name: "ambiguous", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }, Started)) Feature(Feature { keyword: "Feature", name: "ambiguous", description: None, background: None, scenarios: [Scenario { keyword: "Scenario", name: "ambiguous", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Scenario(Scenario { keyword: "Scenario", name: "ambiguous", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }, Step(Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }, Started))) -Feature(Feature { keyword: "Feature", name: "ambiguous", description: None, background: None, scenarios: [Scenario { keyword: "Scenario", name: "ambiguous", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Scenario(Scenario { keyword: "Scenario", name: "ambiguous", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }, Step(Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }, AmbiguousMatch(AmbiguousMatchError { possible_matches: [(HashableRegex(foo is (\d+)), Some(Location { line: 11, column: 1 })), (HashableRegex(foo is (\d+) ambiguous), Some(Location { line: 19, column: 1 }))] })))) +Feature(Feature { keyword: "Feature", name: "ambiguous", description: None, background: None, scenarios: [Scenario { keyword: "Scenario", name: "ambiguous", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Scenario(Scenario { keyword: "Scenario", name: "ambiguous", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }, Step(Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }, Failed(None, Some(World(0)), AmbiguousMatch(AmbiguousMatchError { possible_matches: [(HashableRegex(foo is (\d+)), Some(Location { line: 11, column: 1 })), (HashableRegex(foo is (\d+) ambiguous), Some(Location { line: 19, column: 1 }))] }))))) Feature(Feature { keyword: "Feature", name: "ambiguous", description: None, background: None, scenarios: [Scenario { keyword: "Scenario", name: "ambiguous", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Scenario(Scenario { keyword: "Scenario", name: "ambiguous", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }, Finished)) Feature(Feature { keyword: "Feature", name: "ambiguous", description: None, background: None, scenarios: [Scenario { keyword: "Scenario", name: "ambiguous", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Finished) Finished diff --git a/tests/features/output/scenario_outline_table.feature.out b/tests/features/output/scenario_outline_table.feature.out index 4c60437e..6b54be49 100644 --- a/tests/features/output/scenario_outline_table.feature.out +++ b/tests/features/output/scenario_outline_table.feature.out @@ -10,7 +10,7 @@ Feature(Feature { keyword: "Feature", name: "Outline", description: None, backgr Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "0"], ["2", "1"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }, Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 3", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "3"], ["2", "4"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 5", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 13, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "0"], ["2", "1"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }, Finished)) Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "0"], ["2", "1"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }, Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 3", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "3"], ["2", "4"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 5", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 13, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 3", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "3"], ["2", "4"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 5", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 13, col: 5 } }, Started)) Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "0"], ["2", "1"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }, Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 3", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "3"], ["2", "4"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 5", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 13, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 3", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "3"], ["2", "4"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 5", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 13, col: 5 } }, Step(Step { keyword: "Given", ty: Given, value: "foo is 3", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "3"], ["2", "4"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Started))) -Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "0"], ["2", "1"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }, Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 3", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "3"], ["2", "4"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 5", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 13, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 3", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "3"], ["2", "4"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 5", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 13, col: 5 } }, Step(Step { keyword: "Given", ty: Given, value: "foo is 3", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "3"], ["2", "4"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Failed(Some(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)]))), Some(World(0)), Any { .. })))) +Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "0"], ["2", "1"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }, Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 3", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "3"], ["2", "4"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 5", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 13, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 3", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "3"], ["2", "4"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 5", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 13, col: 5 } }, Step(Step { keyword: "Given", ty: Given, value: "foo is 3", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "3"], ["2", "4"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Failed(Some(CaptureLocations(Locations([Some(0), Some(8), Some(7), Some(8)]))), Some(World(0)), Panic(Any { .. }))))) Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "0"], ["2", "1"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }, Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 3", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "3"], ["2", "4"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 5", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 13, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Scenario(Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 3", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "3"], ["2", "4"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 5", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 13, col: 5 } }, Finished)) Feature(Feature { keyword: "Feature", name: "Outline", description: None, background: None, scenarios: [Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "0"], ["2", "1"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 1", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 2", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 12, col: 5 } }, Scenario { keyword: "Scenario Outline", name: "foo", steps: [Step { keyword: "Given", ty: Given, value: "foo is 3", docstring: None, table: Some(Table { rows: [["key", "value"], ["1", "3"], ["2", "4"]], position: LineCol { line: 5, col: 7 } }), position: LineCol { line: 4, col: 5 } }, Step { keyword: "When", ty: When, value: "foo is 4", docstring: None, table: None, position: LineCol { line: 8, col: 5 } }, Step { keyword: "Then", ty: Then, value: "foo is 5", docstring: None, table: None, position: LineCol { line: 9, col: 5 } }], examples: Some(Examples { keyword: "Examples", table: Table { rows: [["bar1", "bar2", "bar3"], ["0", "1", "2"], ["3", "4", "5"]], position: LineCol { line: 12, col: 7 } }, tags: [], position: LineCol { line: 11, col: 5 } }), tags: [], position: LineCol { line: 13, col: 5 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Finished) Finished From 3ff9036487bf21c00d0aecd935df4e5d6fd388fb Mon Sep 17 00:00:00 2001 From: ilslv Date: Tue, 19 Oct 2021 10:00:00 +0300 Subject: [PATCH 22/25] Corrections --- book/src/Test_Modules_Organization.md | 2 +- src/runner/basic.rs | 17 +++++++++-------- src/writer/fail_on_skipped.rs | 10 ++++------ 3 files changed, 14 insertions(+), 15 deletions(-) diff --git a/book/src/Test_Modules_Organization.md b/book/src/Test_Modules_Organization.md index 8d271253..396ee3e5 100644 --- a/book/src/Test_Modules_Organization.md +++ b/book/src/Test_Modules_Organization.md @@ -26,7 +26,7 @@ Avoid writing similar step definitions, as they can lead to clutter. While docum ## Managing growth -To help with non-intuitive and frustrating problems that can be encountered in case your `Step` is matched by multiple functions, annotated with `Step` attributes, we propagate that case as an [`AmbiguousMatchError`](https://docs.rs/cucumber/*/cucumber/event/enum.Step.html#variant.AmbiguousMatch). +To help with non-intuitive and frustrating problems that can be encountered in case your `Step` is matched by multiple functions, annotated with `Step` attributes, we propagate that case as an [`AmbiguousMatchError`](https://docs.rs/cucumber/*/cucumber/event/enum.StepError.html#variant.AmbiguousMatch). As your test suit grows, it may become harder to notice how minimal changes to `regex`es can lead to mismatched `Step`s. To avoid this, we recommend using [`Cucumber::fail_on_skipped()`](https://docs.rs/cucumber/*/cucumber/struct.Cucumber.html#method.fail_on_skipped) combining with `@allow_skipped` tag. This will allow you to mark out `Scenario`s which `Step`s are allowed to skip. diff --git a/src/runner/basic.rs b/src/runner/basic.rs index 0db4bcb8..d08a360d 100644 --- a/src/runner/basic.rs +++ b/src/runner/basic.rs @@ -650,6 +650,7 @@ where event::Cucumber::scenario(f, r, s, e(step, captures, w, info)) } }; + let compose = |started, passed, skipped, failed| { (ok(started), ok_capt(passed), ok(skipped), err(failed)) }; @@ -895,6 +896,14 @@ where self.send(started(step.clone())); let run = async { + let (step_fn, captures, ctx) = match self.collection.find(&step) { + Ok(Some(step_fn)) => step_fn, + Ok(None) => return Ok(None), + Err(e) => { + return Err((event::StepError::AmbiguousMatch(e), None)); + } + }; + if world.is_none() { let w_fut = async { W::new().await.expect("failed to initialize World") @@ -907,14 +916,6 @@ where }; } - let (step_fn, captures, ctx) = match self.collection.find(&step) { - Ok(Some(step_fn)) => step_fn, - Ok(None) => return Ok(None), - Err(e) => { - return Err((event::StepError::AmbiguousMatch(e), None)); - } - }; - match AssertUnwindSafe(step_fn(world.as_mut().unwrap(), ctx)) .catch_unwind() .await diff --git a/src/writer/fail_on_skipped.rs b/src/writer/fail_on_skipped.rs index 8dfc8467..23ccc4d0 100644 --- a/src/writer/fail_on_skipped.rs +++ b/src/writer/fail_on_skipped.rs @@ -60,15 +60,13 @@ where Wr: for<'val> ArbitraryWriter<'val, W, String>, { async fn handle_event(&mut self, ev: parser::Result>) { - use event::{Cucumber, Feature, Rule, Scenario, Step}; + use event::{ + Cucumber, Feature, Rule, Scenario, Step, StepError::Panic, + }; let map_failed = |f: Arc<_>, r: Option>, sc: Arc<_>, st: _| { let event = if (self.should_fail)(&f, r.as_deref(), &sc) { - Step::Failed( - None, - None, - event::StepError::Panic(Arc::new("not allowed to skip")), - ) + Step::Failed(None, None, Panic(Arc::new("not allowed to skip"))) } else { Step::Skipped }; From e54fa5bb4dcaeffa6c9d39de0b683d324282aa9c Mon Sep 17 00:00:00 2001 From: ilslv Date: Tue, 19 Oct 2021 10:12:30 +0300 Subject: [PATCH 23/25] Corrections --- src/writer/basic.rs | 8 ++++---- tests/features/output/ambiguous_step.feature.out | 2 +- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/src/writer/basic.rs b/src/writer/basic.rs index e4eae4f0..dc247bec 100644 --- a/src/writer/basic.rs +++ b/src/writer/basic.rs @@ -646,13 +646,13 @@ impl Basic { /// /// [`catch_unwind()`]: std::panic::catch_unwind() #[must_use] -pub(crate) fn coerce_error(err: &Info) -> String { +pub(crate) fn coerce_error(err: &Info) -> Cow<'static, str> { if let Some(string) = err.downcast_ref::() { - string.clone() + string.clone().into() } else if let Some(&string) = err.downcast_ref::<&str>() { - string.to_owned() + string.to_owned().into() } else { - "(Could not resolve panic payload)".to_owned() + "(Could not resolve panic payload)".into() } } diff --git a/tests/features/output/ambiguous_step.feature.out b/tests/features/output/ambiguous_step.feature.out index 46158277..514f7b82 100644 --- a/tests/features/output/ambiguous_step.feature.out +++ b/tests/features/output/ambiguous_step.feature.out @@ -2,7 +2,7 @@ Started Feature(Feature { keyword: "Feature", name: "ambiguous", description: None, background: None, scenarios: [Scenario { keyword: "Scenario", name: "ambiguous", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Started) Feature(Feature { keyword: "Feature", name: "ambiguous", description: None, background: None, scenarios: [Scenario { keyword: "Scenario", name: "ambiguous", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Scenario(Scenario { keyword: "Scenario", name: "ambiguous", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }, Started)) Feature(Feature { keyword: "Feature", name: "ambiguous", description: None, background: None, scenarios: [Scenario { keyword: "Scenario", name: "ambiguous", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Scenario(Scenario { keyword: "Scenario", name: "ambiguous", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }, Step(Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }, Started))) -Feature(Feature { keyword: "Feature", name: "ambiguous", description: None, background: None, scenarios: [Scenario { keyword: "Scenario", name: "ambiguous", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Scenario(Scenario { keyword: "Scenario", name: "ambiguous", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }, Step(Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }, Failed(None, Some(World(0)), AmbiguousMatch(AmbiguousMatchError { possible_matches: [(HashableRegex(foo is (\d+)), Some(Location { line: 11, column: 1 })), (HashableRegex(foo is (\d+) ambiguous), Some(Location { line: 19, column: 1 }))] }))))) +Feature(Feature { keyword: "Feature", name: "ambiguous", description: None, background: None, scenarios: [Scenario { keyword: "Scenario", name: "ambiguous", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Scenario(Scenario { keyword: "Scenario", name: "ambiguous", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }, Step(Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }, Failed(None, None, AmbiguousMatch(AmbiguousMatchError { possible_matches: [(HashableRegex(foo is (\d+)), Some(Location { line: 11, column: 1 })), (HashableRegex(foo is (\d+) ambiguous), Some(Location { line: 19, column: 1 }))] }))))) Feature(Feature { keyword: "Feature", name: "ambiguous", description: None, background: None, scenarios: [Scenario { keyword: "Scenario", name: "ambiguous", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Scenario(Scenario { keyword: "Scenario", name: "ambiguous", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }, Finished)) Feature(Feature { keyword: "Feature", name: "ambiguous", description: None, background: None, scenarios: [Scenario { keyword: "Scenario", name: "ambiguous", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Finished) Finished From 96db994a1ea83a5965cb2c595e90478b6b388f1c Mon Sep 17 00:00:00 2001 From: ilslv Date: Tue, 19 Oct 2021 13:25:03 +0300 Subject: [PATCH 24/25] Corrections --- src/step.rs | 16 ++-- .../output/ambiguous_step.feature.out | 2 +- tests/output.rs | 85 ++++++++++++++++++- 3 files changed, 92 insertions(+), 11 deletions(-) diff --git a/src/step.rs b/src/step.rs index 0b70aac0..fa8d8a4e 100644 --- a/src/step.rs +++ b/src/step.rs @@ -15,7 +15,7 @@ use std::{ cmp::Ordering, - collections::{BTreeMap, HashMap}, + collections::HashMap, fmt, hash::{Hash, Hasher}, iter, @@ -38,11 +38,11 @@ pub type WithContext<'me, World> = /// Collection of [`Step`]s. /// -/// Every [`Step`] has to be matched by exactly 1 [`Regex`]. +/// Every [`Step`] has to match with exactly 1 [`Regex`]. pub struct Collection { - given: BTreeMap<(HashableRegex, Option), Step>, - when: BTreeMap<(HashableRegex, Option), Step>, - then: BTreeMap<(HashableRegex, Option), Step>, + given: HashMap<(HashableRegex, Option), Step>, + when: HashMap<(HashableRegex, Option), Step>, + then: HashMap<(HashableRegex, Option), Step>, } impl fmt::Debug for Collection { @@ -79,9 +79,9 @@ impl fmt::Debug for Collection { impl Default for Collection { fn default() -> Self { Self { - given: BTreeMap::new(), - when: BTreeMap::new(), - then: BTreeMap::new(), + given: HashMap::new(), + when: HashMap::new(), + then: HashMap::new(), } } } diff --git a/tests/features/output/ambiguous_step.feature.out b/tests/features/output/ambiguous_step.feature.out index 514f7b82..e3727a3f 100644 --- a/tests/features/output/ambiguous_step.feature.out +++ b/tests/features/output/ambiguous_step.feature.out @@ -2,7 +2,7 @@ Started Feature(Feature { keyword: "Feature", name: "ambiguous", description: None, background: None, scenarios: [Scenario { keyword: "Scenario", name: "ambiguous", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Started) Feature(Feature { keyword: "Feature", name: "ambiguous", description: None, background: None, scenarios: [Scenario { keyword: "Scenario", name: "ambiguous", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Scenario(Scenario { keyword: "Scenario", name: "ambiguous", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }, Started)) Feature(Feature { keyword: "Feature", name: "ambiguous", description: None, background: None, scenarios: [Scenario { keyword: "Scenario", name: "ambiguous", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Scenario(Scenario { keyword: "Scenario", name: "ambiguous", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }, Step(Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }, Started))) -Feature(Feature { keyword: "Feature", name: "ambiguous", description: None, background: None, scenarios: [Scenario { keyword: "Scenario", name: "ambiguous", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Scenario(Scenario { keyword: "Scenario", name: "ambiguous", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }, Step(Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }, Failed(None, None, AmbiguousMatch(AmbiguousMatchError { possible_matches: [(HashableRegex(foo is (\d+)), Some(Location { line: 11, column: 1 })), (HashableRegex(foo is (\d+) ambiguous), Some(Location { line: 19, column: 1 }))] }))))) +Feature(Feature { keyword: "Feature", name: "ambiguous", description: None, background: None, scenarios: [Scenario { keyword: "Scenario", name: "ambiguous", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Scenario(Scenario { keyword: "Scenario", name: "ambiguous", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }, Step(Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }, Failed(None, None, AmbiguousMatch(AmbiguousMatchError { possible_matches: [(HashableRegex(foo is (\d+)), Some(Location { line: 12, column: 1 })), (HashableRegex(foo is (\d+) ambiguous), Some(Location { line: 20, column: 1 }))] }))))) Feature(Feature { keyword: "Feature", name: "ambiguous", description: None, background: None, scenarios: [Scenario { keyword: "Scenario", name: "ambiguous", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Scenario(Scenario { keyword: "Scenario", name: "ambiguous", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }, Finished)) Feature(Feature { keyword: "Feature", name: "ambiguous", description: None, background: None, scenarios: [Scenario { keyword: "Scenario", name: "ambiguous", steps: [Step { keyword: "Given", ty: Given, value: "foo is 0 ambiguous", docstring: None, table: None, position: LineCol { line: 3, col: 5 } }], examples: None, tags: [], position: LineCol { line: 2, col: 3 } }], rules: [], tags: [], position: LineCol { line: 1, col: 1 }, }, Finished) Finished diff --git a/tests/output.rs b/tests/output.rs index 0957840b..9736c477 100644 --- a/tests/output.rs +++ b/tests/output.rs @@ -1,7 +1,8 @@ -use std::{borrow::Cow, convert::Infallible, fmt::Debug}; +use std::{borrow::Cow, cmp::Ordering, convert::Infallible, fmt::Debug}; use async_trait::async_trait; -use cucumber::{event, given, parser, then, when, WorldInit, Writer}; +use cucumber::{event, given, parser, step, then, when, WorldInit, Writer}; +use itertools::Itertools as _; use once_cell::sync::Lazy; use regex::Regex; @@ -37,8 +38,88 @@ impl Writer for DebugWriter { &mut self, ev: parser::Result>, ) { + use event::{Cucumber, Feature, Rule, Scenario, Step, StepError}; + + // This function is used to have deterministic ordering of + // `possible_matches`. + let sort_matches = |mut e: step::AmbiguousMatchError| { + e.possible_matches = e + .possible_matches + .into_iter() + .sorted_by(|(re_l, loc_l), (re_r, loc_r)| { + let re_ord = Ord::cmp(re_l, re_r); + if re_ord == Ordering::Equal { + loc_l + .as_ref() + .and_then(|l| { + loc_r.as_ref().map(|r| Ord::cmp(l, r)) + }) + .unwrap_or(Ordering::Equal) + } else { + re_ord + } + }) + .collect(); + e + }; + let ev: Cow<_> = match ev { Err(_) => "ParsingError".into(), + Ok(Cucumber::Feature( + feat, + Feature::Rule( + rule, + Rule::Scenario( + sc, + Scenario::Step( + st, + Step::Failed(cap, w, StepError::AmbiguousMatch(e)), + ), + ), + ), + )) => { + let ev = Cucumber::scenario( + feat, + Some(rule), + sc, + Scenario::Step( + st, + Step::Failed( + cap, + w, + StepError::AmbiguousMatch(sort_matches(e)), + ), + ), + ); + + format!("{:?}", ev).into() + } + Ok(Cucumber::Feature( + feat, + Feature::Scenario( + sc, + Scenario::Step( + st, + Step::Failed(cap, w, StepError::AmbiguousMatch(e)), + ), + ), + )) => { + let ev = Cucumber::scenario( + feat, + None, + sc, + Scenario::Step( + st, + Step::Failed( + cap, + w, + StepError::AmbiguousMatch(sort_matches(e)), + ), + ), + ); + + format!("{:?}", ev).into() + } Ok(ev) => format!("{:?}", ev).into(), }; From 837758e5d618c0a1ed9d75609baa1e88d4f7ac16 Mon Sep 17 00:00:00 2001 From: tyranron Date: Tue, 19 Oct 2021 19:03:57 +0300 Subject: [PATCH 25/25] Corrections --- CHANGELOG.md | 4 +-- book/src/Test_Modules_Organization.md | 2 -- src/cucumber.rs | 27 ++++-------------- src/event.rs | 40 +++++++++++++-------------- src/runner/basic.rs | 29 +++++-------------- src/step.rs | 11 ++------ tests/output.rs | 17 +++++------- 7 files changed, 44 insertions(+), 86 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 4bca30d6..ac6ecb96 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -23,18 +23,18 @@ All user visible changes to `cucumber` crate will be documented in this file. Th - Made `#[step]` argument of step functions `Step` instead of `StepContext` again, while test callbacks still receive `StepContext` as a second parameter. ([#128]) - Deprecated `--nocapture` and `--debug` CLI options to be completely redesigned in `0.11` release. ([#137]) - [Hooks](https://cucumber.io/docs/cucumber/api/#hooks) now accept optional `&mut World` as their last parameter. ([#142]) -- Propagate `Step` being matched by multiple `Regex`es as `AmbiguousMatchError` ([#143]) ### Added - Ability to run `Scenario`s concurrently. ([#128]) - Highlighting of regex capture groups in terminal output with __bold__ style. ([#136]) +- Error on a step matching multiple step functions ([#143]). [#128]: /../../pull/128 [#136]: /../../pull/136 [#137]: /../../pull/137 [#142]: /../../pull/142 -[#142]: /../../pull/143 +[#143]: /../../pull/143 diff --git a/book/src/Test_Modules_Organization.md b/book/src/Test_Modules_Organization.md index 396ee3e5..0f2f6a6a 100644 --- a/book/src/Test_Modules_Organization.md +++ b/book/src/Test_Modules_Organization.md @@ -26,8 +26,6 @@ Avoid writing similar step definitions, as they can lead to clutter. While docum ## Managing growth -To help with non-intuitive and frustrating problems that can be encountered in case your `Step` is matched by multiple functions, annotated with `Step` attributes, we propagate that case as an [`AmbiguousMatchError`](https://docs.rs/cucumber/*/cucumber/event/enum.StepError.html#variant.AmbiguousMatch). - As your test suit grows, it may become harder to notice how minimal changes to `regex`es can lead to mismatched `Step`s. To avoid this, we recommend using [`Cucumber::fail_on_skipped()`](https://docs.rs/cucumber/*/cucumber/struct.Cucumber.html#method.fail_on_skipped) combining with `@allow_skipped` tag. This will allow you to mark out `Scenario`s which `Step`s are allowed to skip. And, as time goes on, total run time of all tests can become overwhelming when you only want to test small subset of `Scenario`s. At least until you discover [`Cucumber::filter_run_and_exit()`](https://docs.rs/cucumber/*/cucumber/struct.Cucumber.html#method.filter_run_and_exit), which will allow you run only `Scenario`s marked with custom [tags](https://cucumber.io/docs/cucumber/api/#tags). diff --git a/src/cucumber.rs b/src/cucumber.rs index b89f6306..f0451049 100644 --- a/src/cucumber.rs +++ b/src/cucumber.rs @@ -967,13 +967,8 @@ impl Cucumber, Wr> { /// /// [Given]: https://cucumber.io/docs/gherkin/reference/#given #[must_use] - pub fn given( - mut self, - loc: Option, - regex: Regex, - step: Step, - ) -> Self { - self.runner = self.runner.given(loc, regex, step); + pub fn given(mut self, regex: Regex, step: Step) -> Self { + self.runner = self.runner.given(regex, step); self } @@ -981,13 +976,8 @@ impl Cucumber, Wr> { /// /// [When]: https://cucumber.io/docs/gherkin/reference/#When #[must_use] - pub fn when( - mut self, - loc: Option, - regex: Regex, - step: Step, - ) -> Self { - self.runner = self.runner.when(loc, regex, step); + pub fn when(mut self, regex: Regex, step: Step) -> Self { + self.runner = self.runner.when(regex, step); self } @@ -995,13 +985,8 @@ impl Cucumber, Wr> { /// /// [Then]: https://cucumber.io/docs/gherkin/reference/#then #[must_use] - pub fn then( - mut self, - loc: Option, - regex: Regex, - step: Step, - ) -> Self { - self.runner = self.runner.then(loc, regex, step); + pub fn then(mut self, regex: Regex, step: Step) -> Self { + self.runner = self.runner.then(regex, step); self } } diff --git a/src/event.rs b/src/event.rs index 1881b7f1..d3569861 100644 --- a/src/event.rs +++ b/src/event.rs @@ -217,7 +217,22 @@ pub enum Step { ), } -/// [`Step`] error. +// Manual implementation is required to omit the redundant `World: Clone` trait +// bound imposed by `#[derive(Clone)]`. +impl Clone for Step { + fn clone(&self) -> Self { + match self { + Self::Started => Self::Started, + Self::Skipped => Self::Skipped, + Self::Passed(captures) => Self::Passed(captures.clone()), + Self::Failed(captures, w, info) => { + Self::Failed(captures.clone(), w.clone(), info.clone()) + } + } + } +} + +/// Error of executing a [`Step`]. /// /// [`Step`]: gherkin::Step #[derive(Clone, Debug, Display, Error, From)] @@ -236,21 +251,6 @@ pub enum StepError { Panic(#[error(not(source))] Info), } -// Manual implementation is required to omit the redundant `World: Clone` trait -// bound imposed by `#[derive(Clone)]`. -impl Clone for Step { - fn clone(&self) -> Self { - match self { - Self::Started => Self::Started, - Self::Skipped => Self::Skipped, - Self::Passed(captures) => Self::Passed(captures.clone()), - Self::Failed(captures, w, info) => { - Self::Failed(captures.clone(), w.clone(), info.clone()) - } - } - } -} - /// Type of a hook executed before or after all [`Scenario`]'s [`Step`]s. /// /// [`Scenario`]: gherkin::Scenario @@ -440,9 +440,9 @@ impl Scenario { step: Arc, captures: Option, world: Option>, - info: StepError, + info: impl Into, ) -> Self { - Self::Step(step, Step::Failed(captures, world, info)) + Self::Step(step, Step::Failed(captures, world, info.into())) } /// Constructs an event of a failed [`Background`] [`Step`]. @@ -454,8 +454,8 @@ impl Scenario { step: Arc, captures: Option, world: Option>, - info: StepError, + info: impl Into, ) -> Self { - Self::Background(step, Step::Failed(captures, world, info)) + Self::Background(step, Step::Failed(captures, world, info.into())) } } diff --git a/src/runner/basic.rs b/src/runner/basic.rs index d08a360d..f3bb5645 100644 --- a/src/runner/basic.rs +++ b/src/runner/basic.rs @@ -319,13 +319,8 @@ impl Basic { /// /// [Given]: https://cucumber.io/docs/gherkin/reference/#given #[must_use] - pub fn given( - mut self, - loc: Option, - regex: Regex, - step: Step, - ) -> Self { - self.steps = mem::take(&mut self.steps).given(loc, regex, step); + pub fn given(mut self, regex: Regex, step: Step) -> Self { + self.steps = mem::take(&mut self.steps).given(None, regex, step); self } @@ -333,13 +328,8 @@ impl Basic { /// /// [When]: https://cucumber.io/docs/gherkin/reference/#given #[must_use] - pub fn when( - mut self, - loc: Option, - regex: Regex, - step: Step, - ) -> Self { - self.steps = mem::take(&mut self.steps).when(loc, regex, step); + pub fn when(mut self, regex: Regex, step: Step) -> Self { + self.steps = mem::take(&mut self.steps).when(None, regex, step); self } @@ -347,13 +337,8 @@ impl Basic { /// /// [Then]: https://cucumber.io/docs/gherkin/reference/#then #[must_use] - pub fn then( - mut self, - loc: Option, - regex: Regex, - step: Step, - ) -> Self { - self.steps = mem::take(&mut self.steps).then(loc, regex, step); + pub fn then(mut self, regex: Regex, step: Step) -> Self { + self.steps = mem::take(&mut self.steps).then(None, regex, step); self } } @@ -897,7 +882,7 @@ where let run = async { let (step_fn, captures, ctx) = match self.collection.find(&step) { - Ok(Some(step_fn)) => step_fn, + Ok(Some(f)) => f, Ok(None) => return Ok(None), Err(e) => { return Err((event::StepError::AmbiguousMatch(e), None)); diff --git a/src/step.rs b/src/step.rs index fa8d8a4e..421321d0 100644 --- a/src/step.rs +++ b/src/step.rs @@ -162,15 +162,8 @@ impl Collection { let (_, _, whole_match, captures, step_fn) = match matches.len() { 0 => return Ok(None), - 1 => { - if let Some(m) = matches.pop() { - m - } else { - // Instead of `.unwrap()` to avoid documenting `# Panics` - // section. - unreachable!() - } - } + // Instead of `.unwrap()` to avoid documenting `# Panics` section. + 1 => matches.pop().unwrap_or_else(|| unreachable!()), _ => { return Err(AmbiguousMatchError { possible_matches: matches diff --git a/tests/output.rs b/tests/output.rs index 9736c477..4a3a7c06 100644 --- a/tests/output.rs +++ b/tests/output.rs @@ -40,7 +40,7 @@ impl Writer for DebugWriter { ) { use event::{Cucumber, Feature, Rule, Scenario, Step, StepError}; - // This function is used to have deterministic ordering of + // This function is used to provide a deterministic ordering of // `possible_matches`. let sort_matches = |mut e: step::AmbiguousMatchError| { e.possible_matches = e @@ -48,16 +48,13 @@ impl Writer for DebugWriter { .into_iter() .sorted_by(|(re_l, loc_l), (re_r, loc_r)| { let re_ord = Ord::cmp(re_l, re_r); - if re_ord == Ordering::Equal { - loc_l - .as_ref() - .and_then(|l| { - loc_r.as_ref().map(|r| Ord::cmp(l, r)) - }) - .unwrap_or(Ordering::Equal) - } else { - re_ord + if re_ord != Ordering::Equal { + return re_ord; } + loc_l + .as_ref() + .and_then(|l| loc_r.as_ref().map(|r| Ord::cmp(l, r))) + .unwrap_or(Ordering::Equal) }) .collect(); e