Struct Subtest 

pub struct Subtest<'a> {
    pub name: Option<&'a str>,
    pub plan: Plan<'a>,
    pub body: Vec<Statement<'a>>,
}

Subtests provide a way to nest one TAP14 stream inside another. This may be used in a variety of ways, depending on the test harness.

Fields

name: Option<&'a str>

Name of the subtest, declared by a comment at the start of the Subtest.

plan: Plan<'a>

The Plan of the Subtest.

body: Vec<Statement<'a>>

Main Body of the Subtest.

Implementations

impl<'a> Subtest<'a>

pub fn parse(pairs: Pairs<'a, Rule>) -> Result<Self>

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

Parse Subtest from a &str.

Examples

Parsing a TAP subtest may look like this:

use tapconsooomer::Subtest;

let content = concat!(
    "# Subtest: foo\n",
    "  1..2\n",
    "  ok 1 - bar\n",
    "  ok 2 - tuna\n",
);
let subtest = Subtest::parse_from_str(content).expect("Parser error");
assert_eq!(subtest.name, Some("foo"));
assert_eq!(subtest.plan.first, 1);
assert_eq!(subtest.plan.last, 2);
assert_eq!(subtest.body.len(), 2);

Note, the comment declaring Subtest::name is optional:

use tapconsooomer::Subtest;

let content = concat!(
    "  1..4\n",
    "  ok 1 - foo\n",
    "  ok 2 - bar\n",
    "  ok 3 - foobar\n",
    "  ok 4 - catfood\n",
);
let subtest = Subtest::parse_from_str(content).expect("Parser error");
assert_eq!(subtest.name.is_none(), true);
assert_eq!(subtest.plan.first, 1);
assert_eq!(subtest.plan.last, 4);
assert_eq!(subtest.body.len(), 4);

So is the order in which Plan and Body are declared:

use tapconsooomer::Subtest;

let content = concat!(
    "  ok 1 - hello world\n",
    "  1..1\n",
);
let subtest = Subtest::parse_from_str(content).expect("Parser error");
assert_eq!(subtest.name.is_none(), true);
assert_eq!(subtest.plan.first, 1);
assert_eq!(subtest.plan.last, 1);
assert_eq!(subtest.body.len(), 1);

Trait Implementations

impl<'a> Debug for Subtest<'a>

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

Formats the value using the given formatter.

impl<'a> Serialize for Subtest<'a>

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

where __S: Serializer,

Serialize this value into the given Serde serializer.