Enum lcov::record::Record

pub enum Record {
    TestName {
        name: String,
    },
    SourceFile {
        path: PathBuf,
    },
    FunctionName {
        name: String,
        start_line: u32,
    },
    FunctionData {
        name: String,
        count: u64,
    },
    FunctionsFound {
        found: u32,
    },
    FunctionsHit {
        hit: u32,
    },
    BranchData {
        line: u32,
        block: u32,
        branch: u32,
        taken: Option<u64>,
    },
    BranchesFound {
        found: u32,
    },
    BranchesHit {
        hit: u32,
    },
    LineData {
        line: u32,
        count: u64,
        checksum: Option<String>,
    },
    LinesFound {
        found: u32,
    },
    LinesHit {
        hit: u32,
    },
    EndOfRecord,
}

Represents all kinds of LCOV records.

This struct can be created by parsing an LCOV record string by parse method (provided by the FromStr trait). This struct can be converted into an LCOV record string by to_string method (provided by the ToString trait).

See those documentation for more.

Variants

TestName

Represents a TN record.

Examples

use lcov::Record;
assert_eq!("TN:test_name".parse(), Ok(Record::TestName { name: "test_name".into() }));

Fields of TestName

name: String

test name

SourceFile

Represents a SF record.

Examples

use lcov::Record;
assert_eq!("SF:/usr/include/stdio.h".parse(),
           Ok(Record::SourceFile { path: "/usr/include/stdio.h".into() }));

Fields of SourceFile

path: PathBuf

Absolute path to the source file.

FunctionName

Represents a FN record.

Examples

use lcov::Record;
assert_eq!("FN:10,main".parse(),
           Ok(Record::FunctionName { name: "main".into(), start_line: 10 }));

Fields of FunctionName

name: String

Function name.

start_line: u32

Line number of function start.

FunctionData

Represents a FNDA record.

Examples

use lcov::Record;
assert_eq!("FNDA:1,main".parse(),
           Ok(Record::FunctionData { name: "main".into(), count: 1 }));

Fields of FunctionData

name: String

Function name.

count: u64

Execution count.

FunctionsFound

Represents a FNF record.

Examples

use lcov::Record;
assert_eq!("FNF:10".parse(), Ok(Record::FunctionsFound { found: 10 }));

Fields of FunctionsFound

found: u32

Number of functions found.

FunctionsHit

Represents a FNH record.

Examples

use lcov::Record;
assert_eq!("FNH:7".parse(), Ok(Record::FunctionsHit { hit: 7 }));

Fields of FunctionsHit

hit: u32

Number of functions hit.

BranchData

Represents a BRDA record.

block and branch are gcc internal IDs for the branch.

Examples

use lcov::Record;
assert_eq!("BRDA:10,30,40,-".parse(),
           Ok(Record::BranchData { line: 10, block: 30, branch: 40, taken: None }));
assert_eq!("BRDA:10,30,40,3".parse(),
           Ok(Record::BranchData { line: 10, block: 30, branch: 40, taken: Some(3) }));

Fields of BranchData

line: u32

Line number.

block: u32

Block number.

branch: u32

Branch number.

taken: Option<u64>

A number indicating how often that branch was taken.

BranchesFound

Represents a BRF record.

Examples

use lcov::Record;
assert_eq!("BRF:40".parse(), Ok(Record::BranchesFound { found: 40 }));

Fields of BranchesFound

found: u32

Number of branches found.

BranchesHit

Represents a BRH record.

Examples

use lcov::Record;
assert_eq!("BRH:20".parse(), Ok(Record::BranchesHit { hit: 20 }));

Fields of BranchesHit

hit: u32

Number of branches hit.

LineData

Represents a DA record.

Examples

use lcov::Record;
assert_eq!("DA:8,30".parse(), Ok(Record::LineData { line: 8, count: 30, checksum: None }));
assert_eq!("DA:8,30,asdfasdf".parse(),
           Ok(Record::LineData { line: 8, count: 30, checksum: Some("asdfasdf".into()) }));

Fields of LineData

line: u32

Line number.

count: u64

Execution count.

checksum: Option<String>

Checksum for each instrumented line.

LinesFound

Represents a LF record.

Examples

use lcov::Record;
assert_eq!("LF:123".parse(), Ok(Record::LinesFound { found: 123 }));

Fields of LinesFound

found: u32

Number of instrumented line.

LinesHit

Represents a LH record.

Examples

use lcov::Record;
assert_eq!("LH:45".parse(), Ok(Record::LinesHit { hit: 45 }));

Fields of LinesHit

hit: u32

Number of lines with a non-zero execution count.

EndOfRecord

Represents a end_of_record record.

Examples

use lcov::Record;
assert_eq!("end_of_record".parse(), Ok(Record::EndOfRecord));

Implementations

impl Record

pub fn kind(&self) -> RecordKind

Returns the corresponding RecordKind for this record.

Examples

use lcov::{Record, RecordKind};
let rec = Record::LinesHit { hit: 32 };
assert_eq!(rec.kind(), RecordKind::LinesHit);

Trait Implementations

impl Clone for Record

fn clone(&self) -> Record

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Record

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

Formats the value using the given formatter.

impl Display for Record

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

Formats the value using the given formatter.

impl Eq for Record

impl FromStr for Record

type Err = ParseRecordError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Ord for Record

fn cmp(&self, other: &Record) -> Ordering

This method returns an [Ordering] between self and other.

#[must_use]fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]fn clamp(self, min: Self, max: Self) -> Self

🔬 This is a nightly-only experimental API. (clamp)

Restrict a value to a certain interval.

impl PartialEq<Record> for Record

fn eq(&self, other: &Record) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Record) -> bool

This method tests for !=.

impl PartialOrd<Record> for Record

fn partial_cmp(&self, other: &Record) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Record) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Record) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Record) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Record) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl StructuralEq for Record

impl StructuralPartialEq for Record