Enum Statement 

pub enum Statement<'a> {
    Anything(&'a str),
    BailOut(BailOut<'a>),
    Pragma(Pragma<'a>),
    Subtest(Subtest<'a>),
    Test(Test<'a>),
}

An enumeration of all possible TAP constructs that can be part of a Body.

Variants

Anything(&'a str)

Any text not captured by another Statement variant.

BailOut(BailOut<'a>)

A BailOut statement.

Pragma(Pragma<'a>)

A Pragma statement.

Subtest(Subtest<'a>)

A Subtest statement.

Test(Test<'a>)

A Test statement.

Implementations

impl<'a> Statement<'a>

pub fn parse(pair: Pair<'a, Rule>) -> Result<Self>

pub fn parse_from_str(content: &'a str) -> Result<Self>

Parse Statement from a &str.

Examples

Parsing a TAP statement may look like this:

use tapconsooomer::Statement;

let test = "ok 1 - foo::bar()";
let stmt = Statement::parse_from_str(test).expect("Parser error");
assert!(matches!(stmt, Statement::Test(..)));

let anything = "hello world";
let stmt = Statement::parse_from_str(anything).expect("Parser error");
assert!(matches!(stmt, Statement::Anything(..)));

let bail_out = "Bail Out!";
let stmt = Statement::parse_from_str(bail_out).expect("Parser error");
assert!(matches!(stmt, Statement::BailOut(..)));

let pragma = "pragma -strict";
let stmt = Statement::parse_from_str(pragma).expect("Parser error");
assert!(matches!(stmt, Statement::Pragma(..)));

let subtest = concat!(
    "# Subtest: foo\n",
    "    1..0 # skipped\n",
);
let stmt = Statement::parse_from_str(subtest).expect("Parser error");
assert!(matches!(stmt, Statement::Subtest(..)));

Trait Implementations

impl<'a> Debug for Statement<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a> Serialize for Statement<'a>

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.