padded_cell 0.1.0 → 0.2.0

data/ext/padded_cell_native/core/src/chart/results.rs

@@ -0,0 +1,379 @@
+use std::io::{self, Write};
+
+use super::json::Json;
+use super::stats::{Criterion, Stats, Totals};
+use super::thresholds::{CRITERIA, Scope, Violation};
+use super::{Branch, FileReport, Line, chomp, floor2};
+
+#[cfg(test)]
+mod tests;
+
+const SCHEMA: &str = concat!(
+    "https://raw.githubusercontent.com/simplecov-ruby/simplecov/main/",
+    "schemas/coverage-v1.3.schema.json",
+);
+const COMMAND: &str = "padded_cell";
+
+/// About the run.
+#[derive(Debug, Clone, Default, PartialEq)]
+pub struct Meta {
+    /// The project root, absolute.
+    pub root: String,
+    /// ISO 8601, with milliseconds.
+    pub timestamp: String,
+    /// The same moment, in seconds since the epoch.
+    pub created_at: f64,
+    /// The root's git HEAD.
+    pub commit: Option<String>,
+    pub project_name: String,
+    /// What wrote the report: `padded_cell 0.1.0`.
+    pub generator: String,
+}
+
+/// Everything a report says about a run.
+#[derive(Debug)]
+pub struct Summary<'a> {
+    pub files: &'a [FileReport<'a>],
+    pub measured: Vec<Criterion>,
+    pub totals: Totals,
+    /// Name, indices into `files`, and their totals.
+    pub groups: Vec<(String, Vec<usize>, Totals)>,
+    pub violations: Vec<Violation>,
+    pub meta: Meta,
+}
+
+impl Summary<'_> {
+    /// `criterion` was measured.
+    #[must_use]
+    pub fn measures(&self, criterion: Criterion) -> bool {
+        self.measured.contains(&criterion)
+    }
+}
+
+/// `coverage.json`.
+///
+/// # Errors
+///
+/// What writing to `out` returns.
+pub fn write_coverage_json(summary: &Summary<'_>, out: &mut impl Write) -> io::Result<()> {
+    Json::pretty(out).object(|json| {
+        json.key("$schema")?.str(SCHEMA)?;
+        json.key("meta")?.object(|json| meta(json, summary))?;
+        json.key("total")?.object(|json| statistics(json, summary, &summary.totals))?;
+        json.key("coverage")?.object(|json| {
+            summary.files.iter().try_for_each(|file| {
+                json.key(&file.file.name)?.object(|json| source_file(json, summary, file))
+            })
+        })?;
+        json.key("groups")?.object(|json| {
+            summary.groups.iter().try_for_each(|(name, members, totals)| {
+                json.key(name)?.object(|json| {
+                    statistics(json, summary, totals)?;
+                    json.key("files")?.array(|json| {
+                        let names = members.iter().filter_map(|&index| summary.files.get(index));
+                        names.into_iter().try_for_each(|file| json.item()?.str(&file.file.name))
+                    })
+                })
+            })
+        })?;
+        json.key("errors")?.object(|json| errors(json, &summary.violations))
+    })
+}
+
+/// `.resultset.json`: Ruby's Coverage result, keyed by absolute path, under
+/// the command name.
+///
+/// # Errors
+///
+/// What writing to `out` returns.
+pub fn write_resultset(summary: &Summary<'_>, out: &mut impl Write) -> io::Result<()> {
+    Json::compact(out).object(|json| {
+        json.key(COMMAND)?.object(|json| {
+            json.key("coverage")?.object(|json| {
+                let methods = summary.measures(Criterion::Method);
+                summary.files.iter().try_for_each(|file| {
+                    let path = file.file.path.to_string_lossy();
+                    json.key(&path)?.object(|json| resultset_file(json, file, methods))
+                })
+            })?;
+            json.key("timestamp")?.float(summary.meta.created_at)
+        })
+    })?;
+    out.write_all(b"\n")
+}
+
+/// `.last_run.json`: the run's percents, floored, which the next run's
+/// `maximum_drop` compares with.
+///
+/// # Errors
+///
+/// What writing to `out` returns.
+pub fn write_last_run(summary: &Summary<'_>, out: &mut impl Write) -> io::Result<()> {
+    Json::pretty(out).object(|json| {
+        json.key("result")?.object(|json| {
+            summary.measured.iter().try_for_each(|&criterion| {
+                json.key(criterion.singular())?
+                    .float(floor2(summary.totals.get(criterion).percent()))
+            })
+        })
+    })?;
+    out.write_all(b"\n")
+}
+
+fn meta<W: Write>(json: &mut Json<'_, W>, summary: &Summary<'_>) -> io::Result<()> {
+    let meta = &summary.meta;
+    json.key("schema_version")?.str("1.3")?;
+    json.key("simplecov_version")?.str(&meta.generator)?;
+    json.key("command_name")?.str(COMMAND)?;
+    json.key("command_names")?.array(|json| json.item()?.str(COMMAND))?;
+    json.key("project_name")?.str(&meta.project_name)?;
+    json.key("timestamp")?.str(&meta.timestamp)?;
+    json.key("root")?.str(&meta.root)?;
+    match &meta.commit {
+        Some(commit) => json.key("commit")?.str(commit)?,
+        None => json.key("commit")?.null()?,
+    }
+    json.key("primary_coverage")?.str("line")?;
+    for criterion in CRITERIA {
+        let key = format!("{}_coverage", criterion.singular());
+        json.key(&key)?.bool(summary.measures(criterion))?;
+    }
+    Ok(())
+}
+
+fn statistics<W: Write>(
+    json: &mut Json<'_, W>,
+    summary: &Summary<'_>,
+    totals: &Totals,
+) -> io::Result<()> {
+    summary.measured.iter().try_for_each(|&criterion| {
+        let stats = totals.get(criterion);
+        json.key(criterion.plural())?
+            .object(|json| statistic(json, criterion, &stats, stats.percent()))
+    })
+}
+
+fn statistic<W: Write>(
+    json: &mut Json<'_, W>,
+    criterion: Criterion,
+    stats: &Stats,
+    percent: f64,
+) -> io::Result<()> {
+    json.key("covered")?.uint(stats.covered)?;
+    json.key("missed")?.uint(stats.missed)?;
+    if criterion == Criterion::Line {
+        json.key("omitted")?.uint(stats.omitted)?;
+    }
+    json.key("total")?.uint(stats.total())?;
+    json.key("percent")?.float(percent)?;
+    json.key("strength")?.float(stats.strength())
+}
+
+fn source_file<W: Write>(
+    json: &mut Json<'_, W>,
+    summary: &Summary<'_>,
+    file: &FileReport<'_>,
+) -> io::Result<()> {
+    json.key("source")?.array(|json| {
+        file.lines()
+            .try_for_each(|line| json.item()?.str(&String::from_utf8_lossy(chomp(line.text))))
+    })?;
+    let stats = &file.stats;
+    json.key("lines")?.array(|json| file.lines().try_for_each(|line| hits(json.item()?, &line)))?;
+    json.key("lines_covered_percent")?.float(stats.percent(Criterion::Line))?;
+    json.key("covered_lines")?.uint(stats.counts.line.covered)?;
+    json.key("missed_lines")?.uint(stats.counts.line.missed)?;
+    json.key("omitted_lines")?.uint(stats.counts.line.omitted)?;
+    json.key("total_lines")?.uint(stats.counts.line.total())?;
+    if summary.measures(Criterion::Branch) {
+        json.key("branches")?
+            .array(|json| file.branches().try_for_each(|b| branch(json.item()?, &b)))?;
+        counts(json, "branches", stats.percent(Criterion::Branch), &stats.counts.branch)?;
+    }
+    if summary.measures(Criterion::Method) {
+        json.key("methods")?.array(|json| {
+            file.methods().try_for_each(|method| {
+                json.item()?.object(|json| {
+                    let name = format!("{}#{}", method.method.owner, method.method.name);
+                    json.key("name")?.str(&name)?;
+                    json.key("start_line")?.uint(method.method.span.start_line.into())?;
+                    json.key("end_line")?.uint(method.method.span.end_line.into())?;
+                    let coverage = json.key("coverage")?;
+                    if method.skipped {
+                        coverage.str("ignored")
+                    } else {
+                        coverage.uint(method.method.hits)
+                    }
+                })
+            })
+        })?;
+        counts(json, "methods", stats.percent(Criterion::Method), &stats.counts.method)?;
+    }
+    Ok(())
+}
+
+fn counts<W: Write>(
+    json: &mut Json<'_, W>,
+    name: &str,
+    percent: f64,
+    stats: &Stats,
+) -> io::Result<()> {
+    json.key(&format!("{name}_covered_percent"))?.float(percent)?;
+    json.key(&format!("covered_{name}"))?.uint(stats.covered)?;
+    json.key(&format!("missed_{name}"))?.uint(stats.missed)?;
+    json.key(&format!("total_{name}"))?.uint(stats.total())
+}
+
+/// Hits, `null` for no code, `"ignored"` for a skipped line.
+fn hits<W: Write>(json: &mut Json<'_, W>, line: &Line<'_>) -> io::Result<()> {
+    match line.hits {
+        _ if line.skipped => json.str("ignored"),
+        Some(hits) => json.uint(hits),
+        None => json.null(),
+    }
+}
+
+fn branch<W: Write>(json: &mut Json<'_, W>, branch: &Branch<'_>) -> io::Result<()> {
+    json.object(|json| {
+        json.key("type")?.str(branch.kind)?;
+        json.key("start_line")?.uint(branch.start_line.into())?;
+        json.key("end_line")?.uint(branch.end_line.into())?;
+        let coverage = json.key("coverage")?;
+        if branch.skipped {
+            coverage.str("ignored")?;
+        } else {
+            coverage.uint(branch.hits)?;
+        }
+        json.key("inline")?.bool(branch.inline)?;
+        json.key("report_line")?.uint(branch.report_line().into())
+    })
+}
+
+/// The violations, by kind.
+fn errors<W: Write>(json: &mut Json<'_, W>, violations: &[Violation]) -> io::Result<()> {
+    let total: Vec<&Violation> = violations.iter().filter(|v| v.scope == Scope::Total).collect();
+    section(json, "minimum_coverage", "expected", &total)?;
+    named(json, "minimum_coverage_by_file", violations, |v| match &v.scope {
+        Scope::File(name) => Some(name),
+        _ => None,
+    })?;
+    named(json, "minimum_coverage_by_group", violations, |v| match &v.scope {
+        Scope::Group(name) => Some(name),
+        _ => None,
+    })?;
+    let drops: Vec<&Violation> = violations.iter().filter(|v| v.scope == Scope::Drop).collect();
+    section(json, "maximum_coverage_drop", "maximum", &drops)
+}
+
+fn section<W: Write>(
+    json: &mut Json<'_, W>,
+    key: &str,
+    limit: &str,
+    found: &[&Violation],
+) -> io::Result<()> {
+    if found.is_empty() {
+        return Ok(());
+    }
+    json.key(key)?.object(|json| found.iter().try_for_each(|v| violation(json, limit, v)))
+}
+
+/// Violations by file or group name; a name's violations come together.
+fn named<W: Write>(
+    json: &mut Json<'_, W>,
+    key: &str,
+    violations: &[Violation],
+    name: impl Fn(&Violation) -> Option<&String>,
+) -> io::Result<()> {
+    let mut names: Vec<&String> = violations.iter().filter_map(&name).collect();
+    names.dedup();
+    if names.is_empty() {
+        return Ok(());
+    }
+    json.key(key)?.object(|json| {
+        names.iter().try_for_each(|&scope| {
+            let found: Vec<&Violation> =
+                violations.iter().filter(|v| name(v) == Some(scope)).collect();
+            json.key(scope)?
+                .object(|json| found.iter().try_for_each(|v| violation(json, "expected", v)))
+        })
+    })
+}
+
+fn violation<W: Write>(
+    json: &mut Json<'_, W>,
+    limit: &str,
+    violation: &Violation,
+) -> io::Result<()> {
+    json.key(violation.criterion.plural())?.object(|json| {
+        json.key(limit)?.float(violation.limit)?;
+        json.key("actual")?.float(violation.actual)
+    })
+}
+
+fn resultset_file<W: Write>(
+    json: &mut Json<'_, W>,
+    file: &FileReport<'_>,
+    methods: bool,
+) -> io::Result<()> {
+    json.key("lines")?.array(|json| {
+        file.raw_lines().iter().try_for_each(|hits| match hits {
+            Some(hits) => json.item()?.uint(*hits),
+            None => json.item()?.null(),
+        })
+    })?;
+    if let Some(conditions) = &file.file.branches {
+        // Ruby numbers conditions and arms in the order it compiled them.
+        let mut id = 0_u64;
+        json.key("branches")?.object(|json| {
+            conditions.iter().try_for_each(|condition| {
+                json.key(&ruby_tuple(&condition.kind, &mut id, &condition.span))?.object(|json| {
+                    condition.arms.iter().try_for_each(|arm| {
+                        json.key(&ruby_tuple(&arm.kind, &mut id, &arm.span))?.uint(arm.hits)
+                    })
+                })
+            })
+        })?;
+    }
+    if methods {
+        json.key("methods")?.object(|json| {
+            file.methods().try_for_each(|method| {
+                let span = &method.method.span;
+                let key = format!(
+                    "[{}, {}, {}, {}, {}, {}]",
+                    method.method.owner,
+                    ruby_symbol(&method.method.name),
+                    span.start_line,
+                    span.start_column,
+                    span.end_line,
+                    span.end_column
+                );
+                json.key(&key)?.uint(method.method.hits)
+            })
+        })?;
+    }
+    Ok(())
+}
+
+/// `[:if, 0, 2, 4, 6, 7]`, as Ruby's `Array#to_s` writes a branch key.
+fn ruby_tuple(kind: &str, id: &mut u64, span: &super::Span) -> String {
+    let tuple = format!(
+        "[{}, {id}, {}, {}, {}, {}]",
+        ruby_symbol(kind),
+        span.start_line,
+        span.start_column,
+        span.end_line,
+        span.end_column
+    );
+    *id = id.strict_add(1);
+    tuple
+}
+
+/// `:if`, or `:"&."` for a symbol that needs quoting.
+fn ruby_symbol(name: &str) -> String {
+    let plain = name
+        .bytes()
+        .all(|byte| byte.is_ascii_alphanumeric() || b"_?!=[]+-*/%<>~^&|".contains(&byte))
+        && !name.is_empty()
+        && name != "&.";
+    if plain { format!(":{name}") } else { format!(":{name:?}") }
+}

data/ext/padded_cell_native/core/src/chart/source/tests.rs

@@ -0,0 +1,64 @@
+use super::*;
+
+fn source(text: &str) -> Source {
+    Source::new(text.as_bytes().to_vec())
+}
+
+#[test]
+fn lines_split_as_ruby_readlines() {
+    const CASES: &[(&str, &[&str])] = &[
+        ("", &[]),
+        ("a", &["a"]),
+        ("a\nb", &["a\n", "b"]),
+        ("a\nb\n", &["a\n", "b\n"]),
+        ("\n\n", &["\n", "\n"]),
+        ("a\r\nb", &["a\r\n", "b"]),
+    ];
+    for (text, expected) in CASES {
+        let source = source(text);
+        let lines: Vec<&[u8]> = source.lines().collect();
+        let expected: Vec<&[u8]> = expected.iter().map(|line| line.as_bytes()).collect();
+        assert_eq!(lines, expected, "text: {text:?}");
+        assert_eq!(source.len(), expected.len(), "text: {text:?}");
+    }
+}
+
+#[test]
+fn blank_and_comment_lines() {
+    const CASES: &[(&str, bool)] = &[
+        ("", true),
+        ("\n", true),
+        ("  \t\r\n", true),
+        ("# comment\n", true),
+        ("   # indented\n", true),
+        ("\x0b\x0c#\n", true),
+        ("code\n", false),
+        ("x = 1 # comment\n", false),
+        ("  end", false),
+    ];
+    for (line, expected) in CASES {
+        assert_eq!(blank_or_comment(line.as_bytes()), *expected, "line: {line:?}");
+    }
+}
+
+#[test]
+fn nocov_blocks_run_from_marker_to_marker() {
+    let text = "a\n# :nocov:\nb\n  #   :nocov: done\nc\nd # :nocov:\n#:nocov:\ne\n";
+    assert_eq!(source(text).nocov("nocov"), [2..=4, 7..=8]);
+    assert_eq!(source(text).nocov("skip"), []);
+    assert_eq!(source("a\n# :skip:\nb\n").nocov("skip"), [RangeInclusive::new(2, 3)]);
+    // A marker needs both colons: `# :nocov` is a comment.
+    assert_eq!(source("# :nocov\n# nocov:\n").nocov("nocov"), []);
+}
+
+#[test]
+fn unloaded_files_keep_only_their_code() {
+    let source = source("# frozen\n\nclass A\n  # :nocov:\n  def b; end\n  # :nocov:\nend\n");
+    let stub = [Some(0), Some(0), Some(0), Some(0), Some(0), Some(0), Some(0), Some(0)];
+    let skipped = source.nocov("nocov");
+    assert_eq!(
+        source.relevant(&stub, &skipped),
+        [None, None, Some(0), None, None, None, Some(0), None],
+        "comments, blank lines, blocks, and lines past the source are not code"
+    );
+}

data/ext/padded_cell_native/core/src/chart/source.rs

@@ -0,0 +1,153 @@
+use std::ops::RangeInclusive;
+use std::path::Path;
+
+use crate::FileError;
+
+#[cfg(test)]
+mod tests;
+
+/// A source file split into lines the way Ruby's `readlines` splits it:
+/// after each newline, and a last line without one.
+#[derive(Debug, Clone, Default, PartialEq, Eq)]
+pub struct Source {
+    bytes: Vec<u8>,
+    /// Where each line ends, its newline included.
+    ends: Vec<usize>,
+}
+
+impl Source {
+    /// # Errors
+    ///
+    /// [`FileError`] when the file cannot be read.
+    pub fn read(path: &Path) -> Result<Self, FileError> {
+        Ok(Self::new(FileError::read(path)?))
+    }
+
+    #[must_use]
+    pub fn new(bytes: Vec<u8>) -> Self {
+        let mut ends: Vec<usize> = newline_ends(&bytes);
+        if bytes.last().is_some_and(|&last| last != b'\n') {
+            ends.push(bytes.len());
+        }
+        Self { bytes, ends }
+    }
+
+    /// The number of lines.
+    #[must_use]
+    pub const fn len(&self) -> usize {
+        self.ends.len()
+    }
+
+    #[must_use]
+    pub const fn is_empty(&self) -> bool {
+        self.ends.is_empty()
+    }
+
+    #[must_use]
+    pub fn bytes(&self) -> &[u8] {
+        &self.bytes
+    }
+
+    /// The 1-based line and the 0-based byte column of `offset`.
+    #[must_use]
+    pub fn position(&self, offset: usize) -> (u32, u32) {
+        let line = self.ends.partition_point(|&end| end <= offset);
+        let number = |value: usize| u32::try_from(value).unwrap_or(u32::MAX);
+        (number(line.strict_add(1)), number(offset.strict_sub(self.line_start(offset))))
+    }
+
+    /// Where the line holding `offset` starts.
+    #[must_use]
+    pub fn line_start(&self, offset: usize) -> usize {
+        let line = self.ends.partition_point(|&end| end <= offset);
+        line.checked_sub(1).map_or(0, |previous| self.ends[previous])
+    }
+
+    /// Each line, its newline included.
+    pub fn lines(&self) -> impl Iterator<Item = &[u8]> {
+        let starts = std::iter::once(0).chain(self.ends.iter().copied());
+        starts.zip(&self.ends).map(|(start, &end)| &self.bytes[start..end])
+    }
+
+    /// The `# :token:` blocks: from a marker comment to the next, both
+    /// included. A block left open runs to the last line.
+    #[must_use]
+    pub fn nocov(&self, token: &str) -> Vec<RangeInclusive<u32>> {
+        let mut markers: Vec<u32> = self
+            .lines()
+            .zip(1..)
+            .filter(|(line, _)| nocov_marker(line, token))
+            .map(|(_, n)| n)
+            .collect();
+        if markers.len() % 2 == 1 {
+            markers.push(u32::try_from(self.len()).unwrap_or(u32::MAX));
+        }
+        markers.as_chunks::<2>().0.iter().map(|&[start, end]| start..=end).collect()
+    }
+
+    /// The lines of a file that never loaded, from `Coverage.line_stub`:
+    /// blank and comment lines, and lines in `skipped` blocks, are not code.
+    #[must_use]
+    pub fn relevant(
+        &self,
+        stub: &[Option<u64>],
+        skipped: &[RangeInclusive<u32>],
+    ) -> Vec<Option<u64>> {
+        let mut lines = self.lines();
+        stub.iter()
+            .zip(1..)
+            .map(|(&hits, number)| {
+                let text = lines.next()?;
+                let code =
+                    !blank_or_comment(text) && !skipped.iter().any(|block| block.contains(&number));
+                if code { hits } else { None }
+            })
+            .collect()
+    }
+}
+
+/// Without its line ending, as Ruby's `chomp`.
+#[must_use]
+pub fn chomp(line: &[u8]) -> &[u8] {
+    let line = line.strip_suffix(b"\n").unwrap_or(line);
+    line.strip_suffix(b"\r").unwrap_or(line)
+}
+
+/// Offsets just past each newline.
+fn newline_ends(bytes: &[u8]) -> Vec<usize> {
+    bytes
+        .iter()
+        .enumerate()
+        .filter(|&(_, &byte)| byte == b'\n')
+        .map(|(index, _)| index.strict_add(1))
+        .collect()
+}
+
+/// Ruby's `\s`: ASCII whitespace only.
+pub const fn ruby_space(byte: u8) -> bool {
+    matches!(byte, b' ' | b'\t' | b'\n' | b'\x0b' | b'\x0c' | b'\r')
+}
+
+/// Without its leading `\s`.
+pub fn trim_start(line: &[u8]) -> &[u8] {
+    let start = line.iter().position(|&byte| !ruby_space(byte)).unwrap_or(line.len());
+    &line[start..]
+}
+
+/// `/^\s*$/` or `/^\s*#/`.
+#[must_use]
+pub fn blank_or_comment(line: &[u8]) -> bool {
+    matches!(trim_start(line).first(), None | Some(b'#'))
+}
+
+/// `/^(\s*)#(\s*)(:token:)/`.
+fn nocov_marker(line: &[u8], token: &str) -> bool {
+    let Some(comment) = trim_start(line).strip_prefix(b"#") else {
+        return false;
+    };
+    let marker = trim_start(comment);
+    marker
+        .strip_prefix(b":")
+        .and_then(|rest| rest.strip_prefix(token.as_bytes()))
+        .is_some_and(|rest| rest.starts_with(b":"))
+}

data/ext/padded_cell_native/core/src/chart/stats/tests.rs

@@ -0,0 +1,52 @@
+use super::*;
+
+const fn stats(covered: u64, missed: u64, hits: u64) -> Stats {
+    Stats { covered, missed, omitted: 0, hits }
+}
+
+#[test]
+fn percent_and_strength() {
+    const CASES: &[(Stats, f64, f64)] = &[
+        (stats(0, 0, 0), 100.0, 0.0),
+        (stats(3, 0, 6), 100.0, 2.0),
+        (stats(0, 4, 0), 0.0, 0.0),
+        (stats(2, 1, 9), 200.0 / 3.0, 3.0),
+    ];
+    for (stats, percent, strength) in CASES {
+        assert_eq!(stats.percent().to_bits(), percent.to_bits(), "{stats:?}");
+        assert_eq!(stats.strength().to_bits(), strength.to_bits(), "{stats:?}");
+    }
+}
+
+#[test]
+fn stats_sum() {
+    let total: Stats = [stats(1, 2, 3), stats(4, 5, 6)].into_iter().sum();
+    assert_eq!(total, stats(5, 7, 9));
+    assert_eq!(total.total(), 12);
+}
+
+/// Values from Ruby's `Float#floor(2)`.
+#[test]
+fn floor2_is_rubys_float_floor() {
+    const CASES: &[(f64, f64)] = &[
+        (0.29, 0.29),
+        (89.999, 89.99),
+        (100.0, 100.0),
+        (0.0, 0.0),
+        (200.0 / 3.0, 66.66),
+        (0.001, 0.0),
+        (57.142_857_142_857_14, 57.14),
+    ];
+    for (number, expected) in CASES {
+        assert_eq!(floor2(*number).to_bits(), expected.to_bits(), "number: {number}");
+    }
+}
+
+#[test]
+fn unmeasured_files_are_at_zero_until_covered() {
+    let mut file = FileStats { unmeasured_branches: true, ..FileStats::default() };
+    assert_eq!(file.percent(Criterion::Branch).to_bits(), 0.0_f64.to_bits());
+    assert_eq!(file.percent(Criterion::Line).to_bits(), 100.0_f64.to_bits());
+    file.unmeasured_branches = false;
+    assert_eq!(file.percent(Criterion::Branch).to_bits(), 100.0_f64.to_bits());
+}