Grcov report - geometries.rs

1

//! Tests for the data files from https://github.com/horizon-eda/horizon/

2

//!

3

//! Horizon is an app Electronic Design Automation.  It has SVG templates with specially

4

//! named elements; the app extracts their geometries and renders GUI widgets instead of

5

//! those elements.  So, it is critical that the geometries get computed accurately.

6

//!

7

//! Horizon's build system pre-computes the geometries of the SVG templates' elements, and

8

//! stores them in JSON files.  You can see the SVGs and the .subs JSON files in the

9

//! tests/fixtures/horizon in the librsvg source tree.

10

//!

11

//! This test file has machinery to load the SVG templates, and the JSON files with the

12

//! expected geometries.  The tests check that librsvg computes the same geometries every

13

//! time.

14

15

use anyhow::{Context, Result};

16

use rsvg::tests_only::Rect;

17

use rsvg::{CairoRenderer, LengthUnit, Loader};

18

use serde::Deserialize;

19

use std::collections::BTreeMap;

20

use std::fs;

21

use std::path::Path;

22

23

// Copy of cairo::Rectangle

24

//

25

// Somehow I can't make serde's "remote" work here, in combination with the BTreeMap below...

26

737

#[derive(Copy, Clone, Deserialize, Debug, PartialEq)]

27

struct Rectangle {

28

    x: f64,

29

    y: f64,

30

    width: f64,

31

    height: f64,

32

33

34

impl From<Rectangle> for Rect {

35

54

    fn from(r: Rectangle) -> Rect {

36

54

        Rect {

37

54

            x0: r.x,

38

54

            y0: r.y,

39

54

            x1: r.x + r.width,

40

54

            y1: r.y + r.height,

41

42

54

43

44

45

8

#[derive(Deserialize)]

46

struct Geometries(BTreeMap<String, Rectangle>);

47

48

4

fn read_geometries(path: &Path) -> Result<Geometries> {

49

4

    let contents = fs::read_to_string(path).context(format!("could not read {:?}", path))?;

50

4

    serde_json::from_str(&contents).context(format!("could not parse JSON from {:?}", path))

51

4

52

53

// We create a struct with the id and geometry so that

54

// assert_eq!() in the tests will print out the element name for failures.

55

#[derive(Debug, PartialEq)]

56

struct Element {

57

    id: String,

58

    geom: Rect,

59

60

61

macro_rules! assert_rectangles_approx_eq {

62

    ($id:expr, $expected:expr, $computed:expr) => {

63

        if !$expected.approx_eq(&$computed) {

64

            eprintln!(

65

                "assertion failed: rectangles are not approximately equal for id={}",

66

$id

67

);

68

            eprintln!("  expected: {:?}", $expected);

69

            eprintln!("  computed: {:?}", $computed);

70

            panic!();

71

72

};

73

74

75

4

fn test(svg_filename: &str) {

76

4

    let mut geometries_filename = String::from(svg_filename);

77

4

    geometries_filename.push_str(".subs");

78

79

    let geometries =

80

4

        read_geometries(Path::new(&geometries_filename)).expect("reading geometries JSON");

81

82

112

    let handle = Loader::new()

83

        .read_path(svg_filename)

84

        .expect("reading geometries SVG");

85

112

    let renderer = CairoRenderer::new(&handle);

86

112

    let dimensions = renderer.intrinsic_dimensions();

87

4

    let (svg_width, svg_height) = renderer

88

        .intrinsic_size_in_pixels()

89

        .expect("intrinsic size in pixels");

90

91

4

    assert!(matches!(dimensions.width.unit, LengthUnit::Px));

92

4

    assert!(matches!(dimensions.height.unit, LengthUnit::Px));

93

4

    assert_eq!(dimensions.width.length, svg_width);

94

4

    assert_eq!(dimensions.height.length, svg_height);

95

96

4

    for (id, expected) in geometries.0.iter() {

97

54

        println!("id: {}", id);

98

54

        let expected = Element {

99

54

            id: String::from(id),

100

54

            geom: Rect::from(*expected),

101

};

102

103

54

        let viewport = cairo::Rectangle::new(0.0, 0.0, svg_width, svg_height);

104

105

54

        let (geometry, _) = renderer

106

54

            .geometry_for_layer(Some(id), &viewport)

107

54

            .unwrap_or_else(|_| panic!("getting geometry for {}", id));

108

109

54

        let computed = Element {

110

54

            id: String::from(id),

111

54

            geom: geometry.into(),

112

};

113

114

54

        assert_rectangles_approx_eq!(id, expected.geom, computed.geom);

115

54

116

4

117

118

#[test]

119

2

fn dual() {

120

1

    test("tests/fixtures/geometries/dual.svg");

121

2

122

123

#[test]

124

2

fn grid() {

125

1

    test("tests/fixtures/geometries/grid.svg");

126

2

127

128

#[test]

129

2

fn quad() {

130

1

    test("tests/fixtures/geometries/quad.svg");

131

2

132

133

#[test]

134

2

fn single() {

135

1

    test("tests/fixtures/geometries/single.svg");

136

2