diagnostics_assertions/
lib.rs

1// Copyright 2020 The Fuchsia Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5//! Utilities to assert the structure of a DiagnosticsHierarchy.
6//!
7//! Pretty much the useful [`assert_data_tree`][assert_data_tree] macro
8//! plus some utilities for it.
9
10use anyhow::{bail, format_err, Error};
11use diagnostics_hierarchy::{
12    ArrayContent, ArrayFormat, ExponentialHistogram, ExponentialHistogramParams, LinearHistogram,
13    LinearHistogramParams, Property, EXPONENTIAL_HISTOGRAM_EXTRA_SLOTS,
14    LINEAR_HISTOGRAM_EXTRA_SLOTS,
15};
16use difference::{Changeset, Difference};
17use num_traits::One;
18use regex::Regex;
19use std::collections::BTreeSet;
20use std::fmt::{Debug, Display, Formatter, Result as FmtResult};
21use std::ops::{Add, AddAssign, MulAssign};
22
23pub use diagnostics_hierarchy::{hierarchy, DiagnosticsHierarchy, DiagnosticsHierarchyGetter};
24
25pub trait JsonGetter<K: Clone + AsRef<str>>: DiagnosticsHierarchyGetter<K> {
26    fn get_pretty_json(&self) -> String {
27        let mut tree = self.get_diagnostics_hierarchy();
28        tree.to_mut().sort();
29        serde_json::to_string_pretty(&tree).expect("pretty json string")
30    }
31
32    fn get_json(&self) -> String {
33        let mut tree = self.get_diagnostics_hierarchy();
34        tree.to_mut().sort();
35        serde_json::to_string(&tree).expect("json string")
36    }
37}
38
39impl<K: Clone + AsRef<str>, T: DiagnosticsHierarchyGetter<K>> JsonGetter<K> for T {}
40
41/// Macro to simplify creating `TreeAssertion`s. Commonly used indirectly through the second
42/// parameter of `assert_data_tree!`. See `assert_data_tree!` for more usage examples.
43///
44/// Each leaf value must be a type that implements either `PropertyAssertion` or `TreeAssertion`.
45///
46/// Example:
47/// ```
48/// // Manual creation of `TreeAssertion`.
49/// let mut root = TreeAssertion::new("root", true);
50/// root.add_property_assertion("a-string-property", Box::new("expected-string-value"));
51/// let mut child = TreeAssertion::new("child", true);
52/// child.add_property_assertion("any-property", Box::new(AnyProperty));
53/// root.add_child_assertion(child);
54/// root.add_child_assertion(opaque_child);
55///
56/// // Creation with `tree_assertion!`.
57/// let root = tree_assertion!(
58///     root: {
59///         "a-string-property": "expected-string-value",
60///         child: {
61///             "any-property": AnyProperty,
62///         },
63///         opaque_child, // required trailing comma for `TreeAssertion` expressions
64///     }
65/// );
66/// ```
67///
68/// Note that `TreeAssertion`s given directly to the macro must always be followed by `,`.
69#[macro_export]
70macro_rules! tree_assertion {
71    (@build $tree_assertion:expr,) => {};
72
73    // Exact match of tree
74    (@build $tree_assertion:expr, var $key:ident: { $($sub:tt)* }) => {{
75        #[allow(unused_mut)]
76        let mut child_tree_assertion = TreeAssertion::new($key, true);
77        $crate::tree_assertion!(@build child_tree_assertion, $($sub)*);
78        $tree_assertion.add_child_assertion(child_tree_assertion);
79    }};
80    (@build $tree_assertion:expr, var $key:ident: { $($sub:tt)* }, $($rest:tt)*) => {{
81        $crate::tree_assertion!(@build $tree_assertion, var $key: { $($sub)* });
82        $crate::tree_assertion!(@build $tree_assertion, $($rest)*);
83    }};
84
85    // Partial match of tree
86    (@build $tree_assertion:expr, var $key:ident: contains { $($sub:tt)* }) => {{
87        #[allow(unused_mut)]
88        let mut child_tree_assertion = TreeAssertion::new($key, false);
89        $crate::tree_assertion!(@build child_tree_assertion, $($sub)*);
90        $tree_assertion.add_child_assertion(child_tree_assertion);
91    }};
92    (@build $tree_assertion:expr, var $key:ident: contains { $($sub:tt)* }, $($rest:tt)*) => {{
93        $crate::tree_assertion!(@build $tree_assertion, var $key: contains { $($sub)* });
94        $crate::tree_assertion!(@build $tree_assertion, $($rest)*);
95    }};
96
97    // Matching properties of a tree
98    (@build $tree_assertion:expr, var $key:ident: $assertion:expr) => {{
99        $tree_assertion.add_property_assertion($key, Box::new($assertion))
100    }};
101    (@build $tree_assertion:expr, var $key:ident: $assertion:expr, $($rest:tt)*) => {{
102        $crate::tree_assertion!(@build $tree_assertion, var $key: $assertion);
103        $crate::tree_assertion!(@build $tree_assertion, $($rest)*);
104    }};
105
106    // Key identifier format
107    // Unquoted, e.g.: `foo: ... `
108    (@build $tree_assertion:expr, $key:ident: $($rest:tt)+) => {{
109        let key = stringify!($key);
110        $crate::tree_assertion!(@build $tree_assertion, var key: $($rest)+);
111    }};
112    // Key identifier as a constant.
113    // e.g.: `ref some::crate::CONSTANT: ...`
114    //
115    // Note, this works ONLY if it's a full path. For unquoted literals,
116    // such as `foo`, see the production above.
117    (@build $tree_assertion:expr, ref $key:path: $($rest:tt)+) => {{
118        let key: &str = $key.as_ref(); // Accept only AsRef<str>
119        $crate::tree_assertion!(@build $tree_assertion, var key: $($rest)+);
120    }};
121    // Allows string literal for key
122    (@build $tree_assertion:expr, $key:tt: $($rest:tt)+) => {{
123        let key: &'static str = $key;
124        $crate::tree_assertion!(@build $tree_assertion, var key: $($rest)+);
125    }};
126    // Allows an expression that resolves into a String for key
127    (@build $tree_assertion:expr, $key:expr => $($rest:tt)+) => {{
128        let key_string : String = $key;
129        let key = &key_string;
130        $crate::tree_assertion!(@build $tree_assertion, var key: $($rest)+);
131    }};
132    // Allows an expression that resolves into a TreeAssertion
133    (@build $tree_assertion:expr, $child_assertion:expr, $($rest:tt)*) => {{
134        $tree_assertion.add_child_assertion($child_assertion);
135        $crate::tree_assertion!(@build $tree_assertion, $($rest)*);
136    }};
137
138    // Entry points
139    (var $key:ident: { $($sub:tt)* }) => {{
140        use $crate::TreeAssertion;
141        #[allow(unused_mut)]
142        let mut tree_assertion = TreeAssertion::new($key, true);
143        $crate::tree_assertion!(@build tree_assertion, $($sub)*);
144        tree_assertion
145    }};
146    (var $key:ident: contains { $($sub:tt)* }) => {{
147        use $crate::TreeAssertion;
148        #[allow(unused_mut)]
149        let mut tree_assertion = TreeAssertion::new($key, false);
150        $crate::tree_assertion!(@build tree_assertion, $($sub)*);
151        tree_assertion
152    }};
153    ($key:ident: $($rest:tt)+) => {{
154        let key = stringify!($key);
155        $crate::tree_assertion!(var key: $($rest)+)
156    }};
157    ($key:tt: $($rest:tt)+) => {{
158        let key: &'static str = $key;
159        $crate::tree_assertion!(var key: $($rest)+)
160    }};
161}
162
163/// Macro to simplify tree matching in tests. The first argument is the actual tree passed as a
164/// `DiagnosticsHierarchyGetter` (e.g. a `DiagnosticsHierarchy` or an `Inspector`). The second argument is given
165/// to `tree_assertion!` which creates a `TreeAssertion` to validate the tree.
166///
167/// Each leaf value must be a type that implements either `PropertyAssertion` or `TreeAssertion`.
168///
169/// Example:
170/// ```
171/// // Actual tree
172/// let diagnostics_hierarchy = DiagnosticsHierarchy {
173///     name: "key".to_string(),
174///     properties: vec![
175///         Property::String("sub".to_string(), "sub_value".to_string()),
176///         Property::String("sub2".to_string(), "sub2_value".to_string()),
177///     ],
178///     children: vec![
179///        DiagnosticsHierarchy {
180///            name: "child1".to_string(),
181///            properties: vec![
182///                Property::Int("child1_sub".to_string(), 10i64),
183///            ],
184///            children: vec![],
185///        },
186///        DiagnosticsHierarchy {
187///            name: "child2".to_string(),
188///            properties: vec![
189///                Property::Uint("child2_sub".to_string(), 20u64),
190///            ],
191///            children: vec![],
192///        },
193///    ],
194/// };
195///
196/// assert_data_tree!(
197///     diagnostics_hierarchy,
198///     key: {
199///         sub: AnyProperty,   // only verify that `sub` is a property of `key`
200///         sub2: "sub2_value",
201///         child1: {
202///             child1_sub: 10,
203///         },
204///         child2: {
205///             child2_sub: 20,
206///         },
207///     }
208/// );
209/// ```
210///
211/// In order to do a partial match on a tree, use the `contains` keyword:
212/// ```
213/// assert_data_tree!(diagnostics_hierarchy, key: contains {
214///     sub: "sub_value",
215///     child1: contains {},
216/// });
217/// ```
218///
219/// In order to do a match on a tree where the keys need to be computed (they are some
220/// expression), you'll need to use `=>` instead of `:`:
221///
222/// ```
223/// assert_data_tree!(diagnostics_hierarchy, key: {
224///     key_fn() => "value",
225/// })
226/// ```
227/// Note that `key_fn` has to return a `String`.
228///
229/// The first argument can be an `Inspector`, in which case the whole tree is read from the
230/// `Inspector` and matched against:
231/// ```
232/// let inspector = Inspector::default();
233/// assert_data_tree!(inspector, root: {});
234/// ```
235///
236/// `TreeAssertion`s made elsewhere can be included bodily in the macro, but must always be followed
237/// by a trailing comma:
238/// assert_data_tree!(
239///     diagnostics_hierarchy,
240///     key: {
241///         make_child_tree_assertion(), // required trailing comma
242///     }
243/// );
244///
245/// A tree may contain multiple properties or children with the same name. This macro does *not*
246/// support matching against them, and will throw an error if it detects duplicates. This is
247/// to provide warning for users who accidentally log the same name multiple times, as the
248/// behavior for reading properties or children with duplicate names is not well defined.
249#[macro_export]
250macro_rules! assert_data_tree {
251    ($diagnostics_hierarchy:expr, $($rest:tt)+) => {{
252        use $crate::DiagnosticsHierarchyGetter as _;
253        let tree_assertion = $crate::tree_assertion!($($rest)+);
254
255        if let Err(e) = tree_assertion.run($diagnostics_hierarchy.get_diagnostics_hierarchy().as_ref()) {
256            panic!("tree assertion fails: {}", e);
257        }
258    }};
259}
260
261/// Macro to check a hierarchy with a nice JSON diff.
262/// The syntax of the `expected` value is the same as that of `hierarchy!`, and
263/// essentially the same as `assert_data_tree!`, except that partial tree matching
264/// is not supported (i.e. the keyword `contains`).
265#[macro_export]
266macro_rules! assert_json_diff {
267    ($diagnostics_hierarchy:expr, $($rest:tt)+) => {{
268        use $crate::JsonGetter as _;
269        let expected = $diagnostics_hierarchy.get_pretty_json();
270        let actual_hierarchy: $crate::DiagnosticsHierarchy = $crate::hierarchy!{$($rest)+};
271        let actual = actual_hierarchy.get_pretty_json();
272
273        if actual != expected {
274            panic!("{}", $crate::Diff::from_text(&expected, &actual));
275        }
276    }}
277}
278
279/// A difference between expected and actual output.
280pub struct Diff(Changeset);
281
282impl Diff {
283    fn new(expected: &dyn Debug, actual: &dyn Debug) -> Self {
284        let expected = format!("{:#?}", expected);
285        let actual = format!("{:#?}", actual);
286        Self::from_text(&expected, &actual)
287    }
288
289    #[doc(hidden)]
290    pub fn from_text(expected: &str, actual: &str) -> Self {
291        Diff(Changeset::new(expected, actual, "\n"))
292    }
293}
294
295impl Display for Diff {
296    fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
297        writeln!(f, "(-) Expected vs. (+) Actual:")?;
298        for diff in &self.0.diffs {
299            let (prefix, contents) = match diff {
300                Difference::Same(same) => ("  ", same),
301                Difference::Add(added) => ("+ ", added),
302                Difference::Rem(removed) => ("- ", removed),
303            };
304            for line in contents.split("\n") {
305                writeln!(f, "{}{}", prefix, line)?;
306            }
307        }
308        Ok(())
309    }
310}
311
312macro_rules! eq_or_bail {
313    ($expected:expr, $actual:expr) => {{
314        if $expected != $actual {
315            let changes = Diff::new(&$expected, &$actual);
316            return Err(format_err!("\n {}", changes));
317        }
318    }};
319    ($expected:expr, $actual:expr, $($args:tt)+) => {{
320        if $expected != $actual {
321            let changes = Diff::new(&$expected, &$actual);
322            return Err(format_err!("{}:\n {}", format!($($args)+), changes));
323        }
324    }}
325}
326
327/// Struct for matching against a Data tree (DiagnosticsHierarchy).
328pub struct TreeAssertion<K = String> {
329    /// Expected name of the node being compared against
330    name: String,
331    /// Friendly name that includes path from ancestors. Mainly used to indicate which node fails
332    /// in error message
333    path: String,
334    /// Expected property names and assertions to match the actual properties against
335    properties: Vec<(String, Box<dyn PropertyAssertion<K>>)>,
336    /// Assertions to match against child trees
337    children: Vec<TreeAssertion<K>>,
338    /// Whether all properties and children of the tree should be checked
339    exact_match: bool,
340}
341
342impl<K> TreeAssertion<K>
343where
344    K: AsRef<str>,
345{
346    /// Create a new `TreeAssertion`. The |name| argument is the expected name of the tree to be
347    /// compared against. Set |exact_match| to true to specify that all properties and children of
348    /// the tree should be checked. To perform partial matching of the tree, set it to false.
349    pub fn new(name: &str, exact_match: bool) -> Self {
350        Self {
351            name: name.to_string(),
352            path: name.to_string(),
353            properties: vec![],
354            children: vec![],
355            exact_match,
356        }
357    }
358
359    /// Adds a property assertion to this tree assertion.
360    pub fn add_property_assertion(&mut self, key: &str, assertion: Box<dyn PropertyAssertion<K>>) {
361        self.properties.push((key.to_owned(), assertion));
362    }
363
364    /// Adds a tree assertion as a child of this tree assertion.
365    pub fn add_child_assertion(&mut self, mut assertion: TreeAssertion<K>) {
366        assertion.path = format!("{}.{}", self.path, assertion.name);
367        self.children.push(assertion);
368    }
369
370    /// Check whether |actual| tree satisfies criteria defined by `TreeAssertion`. Return `Ok` if
371    /// assertion passes and `Error` if assertion fails.
372    pub fn run(&self, actual: &DiagnosticsHierarchy<K>) -> Result<(), Error> {
373        eq_or_bail!(self.name, actual.name, "node `{}` - expected node name != actual", self.path);
374
375        if self.exact_match {
376            let properties_names = self.properties.iter().map(|p| p.0.to_string());
377            let children_names = self.children.iter().map(|c| c.name.to_string());
378            let keys: BTreeSet<String> = properties_names.chain(children_names).collect();
379
380            let actual_props = actual.properties.iter().map(|p| p.name().to_string());
381            let actual_children = actual.children.iter().map(|c| c.name.to_string());
382            let actual_keys: BTreeSet<String> = actual_props.chain(actual_children).collect();
383            eq_or_bail!(keys, actual_keys, "node `{}` - expected keys != actual", self.path);
384        }
385
386        for (name, assertion) in self.properties.iter() {
387            let mut matched = actual.properties.iter().filter(|p| p.key().as_ref() == name);
388            let first_match = matched.next();
389            if let Some(_second_match) = matched.next() {
390                bail!("node `{}` - multiple properties found with name `{}`", self.path, name);
391            }
392            match first_match {
393                Some(property) => {
394                    if let Err(e) = assertion.run(property) {
395                        bail!(
396                            "node `{}` - assertion fails for property `{}`. Reason: {}",
397                            self.path,
398                            name,
399                            e
400                        );
401                    }
402                }
403                None => bail!("node `{}` - no property named `{}`", self.path, name),
404            }
405        }
406        for assertion in self.children.iter() {
407            let mut matched = actual.children.iter().filter(|c| c.name == assertion.name);
408            let first_match = matched.next();
409            if let Some(_second_match) = matched.next() {
410                bail!(
411                    "node `{}` - multiple children found with name `{}`",
412                    self.path,
413                    assertion.name
414                );
415            }
416            match first_match {
417                Some(child) => assertion.run(child)?,
418                None => bail!("node `{}` - no child named `{}`", self.path, assertion.name),
419            }
420        }
421        Ok(())
422    }
423}
424
425/// Trait implemented by types that can act as properies for assertion.
426pub trait PropertyAssertion<K = String> {
427    /// Check whether |actual| property satisfies criteria. Return `Ok` if assertion passes and
428    /// `Error` if assertion fails.
429    fn run(&self, actual: &Property<K>) -> Result<(), Error>;
430}
431
432macro_rules! impl_property_assertion {
433    ($prop_variant:ident, $($ty:ty),+) => {
434        $(
435            impl<K> PropertyAssertion<K> for $ty {
436                fn run(&self, actual: &Property<K>) -> Result<(), Error> {
437                    if let Property::$prop_variant(_key, value, ..) = actual {
438                        eq_or_bail!(self, value);
439                    } else {
440                        return Err(format_err!("expected {}, found {}",
441                            stringify!($prop_variant), actual.discriminant_name()));
442                    }
443                    Ok(())
444                }
445            }
446        )+
447    };
448
449    ($prop_variant:ident, $cast:ty; $($ty:ty),+) => {
450        $(
451            impl<K> PropertyAssertion<K> for $ty {
452                fn run(&self, actual: &Property<K>) -> Result<(), Error> {
453                    if let Property::$prop_variant(_key, value, ..) = actual {
454                        eq_or_bail!(*self as $cast, *value);
455                    } else {
456                        return Err(format_err!("expected {}, found {}",
457                            stringify!($prop_variant), actual.discriminant_name()));
458                    }
459                    Ok(())
460                }
461            }
462        )+
463    }
464}
465
466macro_rules! impl_array_properties_assertion {
467    ($prop_variant:ident, $($ty:ty),+) => {
468        $(
469            /// Asserts plain numeric arrays
470            impl<K> PropertyAssertion<K> for Vec<$ty> {
471                fn run(&self, actual: &Property<K>) -> Result<(), Error> {
472                    if let Property::$prop_variant(_key, value, ..) = actual {
473                        match &value {
474                            ArrayContent::Values(values) => eq_or_bail!(self, values),
475                            _ => {
476                                return Err(format_err!(
477                                    "expected a plain {} array, got a {}",
478                                    stringify!($prop_variant),
479                                    actual.discriminant_name()
480                                ));
481                            }
482                        }
483                    } else {
484                        return Err(format_err!("expected {}, found {}",
485                            stringify!($prop_variant), actual.discriminant_name()));
486                    }
487                    Ok(())
488                }
489            }
490
491            impl<K> PropertyAssertion<K> for LinearHistogram<$ty> {
492                fn run(&self, actual: &Property<K>) -> Result<(), Error> {
493                    if let Property::$prop_variant(_key, value, ..) = actual {
494                        match &value {
495                            ArrayContent::LinearHistogram(histogram) => {
496                                eq_or_bail!(self, histogram)
497                            }
498                            _ => {
499                                return Err(format_err!(
500                                    "expected a linear {} histogram, got a {}",
501                                    stringify!($prop_variant),
502                                    actual.discriminant_name()
503                                ));
504                            }
505                        }
506                    } else {
507                        return Err(format_err!("expected {}, found {}",
508                            stringify!($prop_variant), actual.discriminant_name()));
509                    }
510                    Ok(())
511                }
512            }
513
514            impl<K> PropertyAssertion<K> for ExponentialHistogram<$ty> {
515                fn run(&self, actual: &Property<K>) -> Result<(), Error> {
516                    if let Property::$prop_variant(_key, value, ..) = actual {
517                        match &value {
518                            ArrayContent::ExponentialHistogram(histogram) => {
519                                eq_or_bail!(self, histogram)
520                            }
521                            _ => {
522                                return Err(format_err!(
523                                    "expected an exponential {} histogram, got a {}",
524                                    stringify!($prop_variant),
525                                    actual.discriminant_name()
526                                ));
527                            }
528                        }
529                    } else {
530                        return Err(format_err!("expected {}, found {}",
531                            stringify!($prop_variant), actual.discriminant_name()));
532                    }
533                    Ok(())
534                }
535            }
536
537            /// Asserts a histogram.
538            impl<K> PropertyAssertion<K> for HistogramAssertion<$ty> {
539                fn run(&self, actual: &Property<K>) -> Result<(), Error> {
540                    if let Property::$prop_variant(_key, value, ..) = actual {
541                        let expected_content =
542                            ArrayContent::new(self.values.clone(), self.format.clone()).map_err(
543                                |e| {
544                                    format_err!(
545                                        "failed to load array content for expected assertion {}: {:?}",
546                                        stringify!($prop_variant),
547                                        e
548                                    )
549                                },
550                            )?;
551                        eq_or_bail!(&expected_content, value);
552                    } else {
553                        return Err(format_err!(
554                            "expected {}, found {}",
555                            stringify!($prop_variant),
556                            actual.discriminant_name(),
557                        ));
558                    }
559                    Ok(())
560                }
561            }
562        )+
563    }
564}
565
566impl_property_assertion!(String, &str, String);
567impl_property_assertion!(Bytes, Vec<u8>);
568impl_property_assertion!(Uint, u64; u64, u32, u16, u8);
569impl_property_assertion!(Int, i64; i64, i32, i16, i8);
570impl_property_assertion!(Double, f64; f64, f32);
571impl_property_assertion!(Bool, bool);
572impl_array_properties_assertion!(DoubleArray, f64);
573impl_array_properties_assertion!(IntArray, i64);
574impl_array_properties_assertion!(UintArray, u64);
575
576/// A PropertyAssertion that always passes
577pub struct AnyProperty;
578
579impl<K> PropertyAssertion<K> for AnyProperty {
580    fn run(&self, _actual: &Property<K>) -> Result<(), Error> {
581        Ok(())
582    }
583}
584
585/// A PropertyAssertion that passes for any String.
586pub struct AnyStringProperty;
587
588impl<K> PropertyAssertion<K> for AnyStringProperty {
589    fn run(&self, actual: &Property<K>) -> Result<(), Error> {
590        match actual {
591            Property::String(..) => Ok(()),
592            _ => Err(format_err!("expected String, found {}", actual.discriminant_name())),
593        }
594    }
595}
596
597/// A PropertyAssertion that passes for any String containing
598/// a matching for the given regular expression.
599impl<K> PropertyAssertion<K> for Regex {
600    fn run(&self, actual: &Property<K>) -> Result<(), Error> {
601        (&self).run(actual)
602    }
603}
604
605impl<K> PropertyAssertion<K> for &Regex {
606    fn run(&self, actual: &Property<K>) -> Result<(), Error> {
607        if let Property::String(_, ref v) = actual {
608            if self.is_match(v) {
609                return Ok(());
610            } else {
611                return Err(format_err!(
612                    "expected String matching \"{}\", found \"{}\"",
613                    self.as_str(),
614                    v
615                ));
616            }
617        }
618        Err(format_err!(
619            "expected String matching \"{}\", found {}",
620            self.as_str(),
621            actual.discriminant_name()
622        ))
623    }
624}
625
626/// A PropertyAssertion that passes for any Bytes.
627pub struct AnyBytesProperty;
628
629impl<K> PropertyAssertion<K> for AnyBytesProperty {
630    fn run(&self, actual: &Property<K>) -> Result<(), Error> {
631        match actual {
632            Property::Bytes(..) => Ok(()),
633            _ => Err(format_err!("expected bytes, found {}", actual.discriminant_name())),
634        }
635    }
636}
637
638/// A PropertyAssertion that passes for any Uint.
639pub struct AnyUintProperty;
640
641impl<K> PropertyAssertion<K> for AnyUintProperty {
642    fn run(&self, actual: &Property<K>) -> Result<(), Error> {
643        match actual {
644            Property::Uint(..) => Ok(()),
645            _ => Err(format_err!("expected Uint, found {}", actual.discriminant_name())),
646        }
647    }
648}
649
650/// A PropertyAssertion that passes for non-zero, unsigned integers.
651///
652/// TODO(https://fxbug.dev/42140843): generalize this to use the >= operator.
653pub struct NonZeroUintProperty;
654
655impl<K> PropertyAssertion<K> for NonZeroUintProperty {
656    fn run(&self, actual: &Property<K>) -> Result<(), Error> {
657        match actual {
658            Property::Uint(_, v) if *v != 0 => Ok(()),
659            Property::Uint(_, v) if *v == 0 => {
660                Err(format_err!("expected non-zero integer, found 0"))
661            }
662            _ => {
663                Err(format_err!("expected non-zero integer, found {}", actual.discriminant_name()))
664            }
665        }
666    }
667}
668
669/// A PropertyAssertion that passes for non-zero, signed integers.
670///
671/// TODO(https://fxbug.dev/42140843): generalize this to use the >= operator.
672pub struct NonZeroIntProperty;
673
674impl<K> PropertyAssertion<K> for NonZeroIntProperty {
675    fn run(&self, actual: &Property<K>) -> Result<(), Error> {
676        match actual {
677            Property::Int(_, v) if *v != 0 => Ok(()),
678            Property::Int(_, v) if *v == 0 => {
679                Err(format_err!("expected non-zero signed integer, found 0"))
680            }
681            _ => Err(format_err!(
682                "expected non-zero signed integer, found {}",
683                actual.discriminant_name()
684            )),
685        }
686    }
687}
688
689/// A PropertyAssertion that passes for any Int.
690pub struct AnyIntProperty;
691
692impl<K> PropertyAssertion<K> for AnyIntProperty {
693    fn run(&self, actual: &Property<K>) -> Result<(), Error> {
694        match actual {
695            Property::Int(..) => Ok(()),
696            _ => Err(format_err!("expected Int, found {}", actual.discriminant_name())),
697        }
698    }
699}
700
701/// A PropertyAssertion that passes for any Double.
702pub struct AnyDoubleProperty;
703
704impl<K> PropertyAssertion<K> for AnyDoubleProperty {
705    fn run(&self, actual: &Property<K>) -> Result<(), Error> {
706        match actual {
707            Property::Double(..) => Ok(()),
708            _ => Err(format_err!("expected Double, found {}", actual.discriminant_name())),
709        }
710    }
711}
712
713/// A PropertyAssertion that passes for any Int, Uint, or Double.
714pub struct AnyNumericProperty;
715
716impl<K> PropertyAssertion<K> for AnyNumericProperty {
717    fn run(&self, actual: &Property<K>) -> Result<(), Error> {
718        match actual {
719            Property::Int(..) | Property::Uint(..) | Property::Double(..) => Ok(()),
720            _ => Err(format_err!(
721                "expected an Int, Uint or Double. found {}",
722                actual.discriminant_name()
723            )),
724        }
725    }
726}
727
728/// A PropertyAssertion that passes for any Boolean.
729pub struct AnyBoolProperty;
730
731impl<K> PropertyAssertion<K> for AnyBoolProperty {
732    fn run(&self, actual: &Property<K>) -> Result<(), Error> {
733        match actual {
734            Property::Bool(..) => Ok(()),
735            _ => Err(format_err!("expected Bool, found {}", actual.discriminant_name())),
736        }
737    }
738}
739
740impl<K> PropertyAssertion<K> for Vec<String> {
741    fn run(&self, actual: &Property<K>) -> Result<(), Error> {
742        let this = self.iter().map(|s| s.as_ref()).collect::<Vec<&str>>();
743        this.run(actual)
744    }
745}
746
747impl<K> PropertyAssertion<K> for Vec<&str> {
748    fn run(&self, actual: &Property<K>) -> Result<(), Error> {
749        match actual {
750            Property::StringList(_key, value) => {
751                eq_or_bail!(self, value);
752                Ok(())
753            }
754            _ => Err(format_err!("expected StringList, found {}", actual.discriminant_name())),
755        }
756    }
757}
758
759/// An assertion for a histogram property.
760#[derive(Clone)]
761pub struct HistogramAssertion<T> {
762    format: ArrayFormat,
763    values: Vec<T>,
764}
765
766impl<T: MulAssign + AddAssign + PartialOrd + Add<Output = T> + Copy + Default + One>
767    HistogramAssertion<T>
768{
769    /// Creates a new histogram assertion for a linear histogram with the given parameters.
770    pub fn linear(params: LinearHistogramParams<T>) -> Self {
771        let mut values = vec![T::default(); params.buckets + LINEAR_HISTOGRAM_EXTRA_SLOTS];
772        values[0] = params.floor;
773        values[1] = params.step_size;
774        Self { format: ArrayFormat::LinearHistogram, values }
775    }
776
777    /// Creates a new histogram assertion for an exponential histogram with the given parameters.
778    pub fn exponential(params: ExponentialHistogramParams<T>) -> Self {
779        let mut values = vec![T::default(); params.buckets + EXPONENTIAL_HISTOGRAM_EXTRA_SLOTS];
780        values[0] = params.floor;
781        values[1] = params.initial_step;
782        values[2] = params.step_multiplier;
783        Self { format: ArrayFormat::ExponentialHistogram, values }
784    }
785
786    /// Inserts the list of values to the histogram for asserting them.
787    pub fn insert_values(&mut self, values: impl IntoIterator<Item = T>) {
788        match self.format {
789            ArrayFormat::ExponentialHistogram => {
790                for value in values {
791                    self.insert_exp(value);
792                }
793            }
794            ArrayFormat::LinearHistogram => {
795                for value in values {
796                    self.insert_linear(value);
797                }
798            }
799            ArrayFormat::Default => {
800                unreachable!("can't construct a histogram assertion for arrays");
801            }
802        }
803    }
804
805    fn insert_linear(&mut self, value: T) {
806        let value_index = {
807            let mut current_floor = self.values[0];
808            let step_size = self.values[1];
809            // Start in the underflow index.
810            let mut index = LINEAR_HISTOGRAM_EXTRA_SLOTS - 2;
811            while value >= current_floor && index < self.values.len() - 1 {
812                current_floor += step_size;
813                index += 1;
814            }
815            index
816        };
817        self.values[value_index] += T::one();
818    }
819
820    fn insert_exp(&mut self, value: T) {
821        let value_index = {
822            let floor = self.values[0];
823            let mut current_floor = self.values[0];
824            let mut offset = self.values[1];
825            let step_multiplier = self.values[2];
826            // Start in the underflow index.
827            let mut index = EXPONENTIAL_HISTOGRAM_EXTRA_SLOTS - 2;
828            while value >= current_floor && index < self.values.len() - 1 {
829                current_floor = floor + offset;
830                offset *= step_multiplier;
831                index += 1;
832            }
833            index
834        };
835        self.values[value_index] += T::one();
836    }
837}
838
839#[cfg(test)]
840mod tests {
841    use super::*;
842    use crate::Difference::{Add, Rem, Same};
843    use diagnostics_hierarchy::testing::CondensableOnDemand;
844    use std::sync::LazyLock;
845
846    static TEST_REGEX: LazyLock<Regex> = LazyLock::new(|| Regex::new("a").unwrap());
847
848    #[fuchsia::test]
849    fn test_assert_json_diff() {
850        assert_json_diff!(
851            simple_tree(),
852             key: {
853                sub: "sub_value",
854                sub2: "sub2_value",
855            }
856        );
857
858        let diagnostics_hierarchy = complex_tree();
859        assert_json_diff!(diagnostics_hierarchy, key: {
860            sub: "sub_value",
861            sub2: "sub2_value",
862            child1: {
863                child1_sub: 10,
864            },
865            child2: {
866                child2_sub: 20,
867            },
868        });
869    }
870
871    #[fuchsia::test]
872    #[should_panic]
873    fn test_panicking_assert_json_diff() {
874        assert_json_diff!(
875            simple_tree(),
876             key: {
877                sub: "sub_value",
878                sb2: "sub2_value",
879            }
880        );
881
882        let diagnostics_hierarchy = complex_tree();
883        assert_json_diff!(diagnostics_hierarchy, key: {
884            sb: "sub_value",
885            sub2: "sub2_value",
886            child: {
887                child1_sub: 10,
888            },
889            child3: {
890                child2_sub: 20,
891            },
892        });
893    }
894
895    #[fuchsia::test]
896    fn test_exact_match_simple() {
897        let diagnostics_hierarchy = simple_tree();
898        assert_data_tree!(diagnostics_hierarchy, key: {
899            sub: "sub_value",
900            sub2: "sub2_value",
901        });
902    }
903
904    #[fuchsia::test]
905    fn test_exact_match_complex() {
906        let diagnostics_hierarchy = complex_tree();
907        assert_data_tree!(diagnostics_hierarchy, key: {
908            sub: "sub_value",
909            sub2: "sub2_value",
910            child1: {
911                child1_sub: 10,
912            },
913            child2: {
914                child2_sub: 20u64,
915            },
916        });
917    }
918
919    #[fuchsia::test]
920    #[should_panic]
921    fn test_exact_match_mismatched_property_name() {
922        let diagnostics_hierarchy = simple_tree();
923        assert_data_tree!(diagnostics_hierarchy, key: {
924            sub: "sub_value",
925            sub3: "sub2_value",
926        });
927    }
928
929    #[fuchsia::test]
930    #[should_panic]
931    fn test_exact_match_mismatched_child_name() {
932        let diagnostics_hierarchy = complex_tree();
933        assert_data_tree!(diagnostics_hierarchy, key: {
934            sub: "sub_value",
935            sub2: "sub2_value",
936            child1: {
937                child1_sub: 10,
938            },
939            child3: {
940                child2_sub: 20,
941            },
942        });
943    }
944
945    #[fuchsia::test]
946    #[should_panic]
947    fn test_exact_match_mismatched_property_name_in_child() {
948        let diagnostics_hierarchy = complex_tree();
949        assert_data_tree!(diagnostics_hierarchy, key: {
950            sub: "sub_value",
951            sub2: "sub2_value",
952            child1: {
953                child2_sub: 10,
954            },
955            child2: {
956                child2_sub: 20,
957            },
958        });
959    }
960
961    #[fuchsia::test]
962    #[should_panic]
963    fn test_exact_match_mismatched_property_value() {
964        let diagnostics_hierarchy = simple_tree();
965        assert_data_tree!(diagnostics_hierarchy, key: {
966            sub: "sub2_value",
967            sub2: "sub2_value",
968        });
969    }
970
971    #[fuchsia::test]
972    #[should_panic]
973    fn test_exact_match_missing_property() {
974        let diagnostics_hierarchy = simple_tree();
975        assert_data_tree!(diagnostics_hierarchy, key: {
976            sub: "sub_value",
977        });
978    }
979
980    #[fuchsia::test]
981    #[should_panic]
982    fn test_exact_match_missing_child() {
983        let diagnostics_hierarchy = complex_tree();
984        assert_data_tree!(diagnostics_hierarchy, key: {
985            sub: "sub_value",
986            sub2: "sub2_value",
987            child1: {
988                child1_sub: 10,
989            },
990        });
991    }
992
993    #[fuchsia::test]
994    fn test_partial_match_success() {
995        let diagnostics_hierarchy = complex_tree();
996
997        // only verify the top tree name
998        assert_data_tree!(diagnostics_hierarchy, key: contains {});
999
1000        // verify parts of the tree
1001        assert_data_tree!(diagnostics_hierarchy, key: contains {
1002            sub: "sub_value",
1003            child1: contains {},
1004        });
1005    }
1006
1007    #[fuchsia::test]
1008    #[should_panic]
1009    fn test_partial_match_nonexistent_property() {
1010        let diagnostics_hierarchy = simple_tree();
1011        assert_data_tree!(diagnostics_hierarchy, key: contains {
1012            sub3: AnyProperty,
1013        });
1014    }
1015
1016    #[fuchsia::test]
1017    fn test_ignore_property_value() {
1018        let diagnostics_hierarchy = simple_tree();
1019        assert_data_tree!(diagnostics_hierarchy, key: {
1020            sub: AnyProperty,
1021            sub2: "sub2_value",
1022        });
1023    }
1024
1025    #[fuchsia::test]
1026    #[should_panic]
1027    fn test_ignore_property_value_property_name_is_still_checked() {
1028        let diagnostics_hierarchy = simple_tree();
1029        assert_data_tree!(diagnostics_hierarchy, key: {
1030            sub1: AnyProperty,
1031            sub2: "sub2_value",
1032        })
1033    }
1034
1035    #[fuchsia::test]
1036    fn test_expr_key_syntax() {
1037        let diagnostics_hierarchy = DiagnosticsHierarchy::new(
1038            "key",
1039            vec![Property::String("@time".to_string(), "1.000".to_string())],
1040            vec![],
1041        );
1042        assert_data_tree!(diagnostics_hierarchy, key: {
1043            "@time": "1.000"
1044        });
1045    }
1046
1047    #[fuchsia::test]
1048    fn test_var_key_syntax() {
1049        let diagnostics_hierarchy = DiagnosticsHierarchy::new(
1050            "key",
1051            vec![Property::String("@time".to_string(), "1.000".to_string())],
1052            vec![],
1053        );
1054        let time_key = "@time";
1055        assert_data_tree!(diagnostics_hierarchy, key: {
1056            var time_key: "1.000"
1057        });
1058    }
1059
1060    const KEY_AS_STR: &str = "@time";
1061
1062    // Similar to above, except the key is stored in a constant.
1063    #[fuchsia::test]
1064    fn test_path_key_syntax() {
1065        let diagnostics_hierarchy = DiagnosticsHierarchy::new(
1066            "key",
1067            vec![Property::String("@time".to_string(), "1.000".to_string())],
1068            vec![],
1069        );
1070        assert_data_tree!(diagnostics_hierarchy, key: {
1071            // This is a fully qualified path on purpose.
1072            ref crate::tests::KEY_AS_STR: "1.000"
1073        });
1074    }
1075
1076    #[fuchsia::test]
1077    fn test_arrays() {
1078        let diagnostics_hierarchy = DiagnosticsHierarchy::new(
1079            "key",
1080            vec![
1081                Property::UintArray("@uints".to_string(), ArrayContent::Values(vec![1, 2, 3])),
1082                Property::IntArray("@ints".to_string(), ArrayContent::Values(vec![-2, -4, 0])),
1083                Property::DoubleArray(
1084                    "@doubles".to_string(),
1085                    ArrayContent::Values(vec![1.3, 2.5, -3.6]),
1086                ),
1087            ],
1088            vec![],
1089        );
1090        assert_data_tree!(diagnostics_hierarchy, key: {
1091            "@uints": vec![1u64, 2, 3],
1092            "@ints": vec![-2i64, -4, 0],
1093            "@doubles": vec![1.3, 2.5, -3.6]
1094        });
1095    }
1096
1097    #[fuchsia::test]
1098    fn test_histograms() {
1099        let mut condensed_int_histogram =
1100            ArrayContent::new(vec![6, 7, 0, 9, 0], ArrayFormat::LinearHistogram).unwrap();
1101        condensed_int_histogram.condense_histogram();
1102        let diagnostics_hierarchy = DiagnosticsHierarchy::new(
1103            "key",
1104            vec![
1105                Property::UintArray(
1106                    "@linear-uints".to_string(),
1107                    ArrayContent::new(vec![1, 2, 3, 4, 5], ArrayFormat::LinearHistogram).unwrap(),
1108                ),
1109                Property::IntArray(
1110                    "@linear-ints".to_string(),
1111                    ArrayContent::new(vec![6, 7, 8, 9, 10], ArrayFormat::LinearHistogram).unwrap(),
1112                ),
1113                Property::IntArray("@linear-sparse-ints".to_string(), condensed_int_histogram),
1114                Property::DoubleArray(
1115                    "@linear-doubles".to_string(),
1116                    ArrayContent::new(vec![1.0, 2.0, 4.0, 5.0, 6.0], ArrayFormat::LinearHistogram)
1117                        .unwrap(),
1118                ),
1119                Property::UintArray(
1120                    "@exp-uints".to_string(),
1121                    ArrayContent::new(vec![2, 4, 6, 8, 10, 12], ArrayFormat::ExponentialHistogram)
1122                        .unwrap(),
1123                ),
1124                Property::IntArray(
1125                    "@exp-ints".to_string(),
1126                    ArrayContent::new(vec![1, 3, 5, 7, 9, 11], ArrayFormat::ExponentialHistogram)
1127                        .unwrap(),
1128                ),
1129                Property::DoubleArray(
1130                    "@exp-doubles".to_string(),
1131                    ArrayContent::new(
1132                        vec![1.0, 2.0, 3.0, 4.0, 5.0, 6.0],
1133                        ArrayFormat::ExponentialHistogram,
1134                    )
1135                    .unwrap(),
1136                ),
1137            ],
1138            vec![],
1139        );
1140        let mut linear_uint_assertion = HistogramAssertion::linear(LinearHistogramParams {
1141            floor: 1u64,
1142            step_size: 2,
1143            buckets: 1,
1144        });
1145        linear_uint_assertion.insert_values(vec![0, 0, 0, 2, 2, 2, 2, 4, 4, 4, 4, 4]);
1146        let mut exponential_double_assertion =
1147            HistogramAssertion::exponential(ExponentialHistogramParams {
1148                floor: 1.0,
1149                initial_step: 2.0,
1150                step_multiplier: 3.0,
1151                buckets: 1,
1152            });
1153        exponential_double_assertion.insert_values(vec![
1154            -3.1, -2.2, -1.3, 0.0, 1.1, 1.2, 2.5, 2.8, 2.0, 3.1, 4.2, 5.3, 6.4, 7.5, 8.6,
1155        ]);
1156        assert_data_tree!(diagnostics_hierarchy, key: {
1157            "@linear-uints": linear_uint_assertion,
1158            "@linear-ints": LinearHistogram {
1159                floor: 6i64,
1160                step: 7,
1161                counts: vec![8, 9, 10],
1162                indexes: None,
1163                size: 3
1164            },
1165            "@linear-sparse-ints": LinearHistogram {
1166                floor: 6i64,
1167                step: 7,
1168                counts: vec![9],
1169                indexes: Some(vec![1]),
1170                size: 3
1171            },
1172            "@linear-doubles": LinearHistogram {
1173                floor: 1.0,
1174                step: 2.0,
1175                counts: vec![4.0, 5.0, 6.0],
1176                indexes: None,
1177                size: 3
1178            },
1179            "@exp-uints": ExponentialHistogram {
1180                floor: 2u64,
1181                initial_step: 4,
1182                step_multiplier: 6,
1183                counts: vec![8, 10, 12],
1184                indexes: None,
1185                size: 3
1186            },
1187            "@exp-ints": ExponentialHistogram {
1188                floor: 1i64,
1189                initial_step: 3,
1190                step_multiplier: 5,
1191                counts: vec![7,9,11],
1192                indexes: None,
1193                size: 3
1194            },
1195            "@exp-doubles": exponential_double_assertion,
1196        });
1197    }
1198
1199    #[fuchsia::test]
1200    fn test_matching_tree_assertion_expression() {
1201        let diagnostics_hierarchy = complex_tree();
1202        let child1 = tree_assertion!(
1203            child1: {
1204                child1_sub: 10,
1205            }
1206        );
1207        assert_data_tree!(diagnostics_hierarchy, key: {
1208            sub: "sub_value",
1209            sub2: "sub2_value",
1210            child1,
1211            tree_assertion!(
1212                child2: {
1213                    child2_sub: 20u64,
1214                }
1215            ),
1216        });
1217    }
1218
1219    #[fuchsia::test]
1220    #[should_panic]
1221    fn test_matching_non_unique_property_fails() {
1222        let diagnostics_hierarchy = non_unique_prop_tree();
1223        assert_data_tree!(diagnostics_hierarchy, key: { prop: "prop_value#0" });
1224    }
1225
1226    #[fuchsia::test]
1227    #[should_panic]
1228    fn test_matching_non_unique_property_fails_2() {
1229        let diagnostics_hierarchy = non_unique_prop_tree();
1230        assert_data_tree!(diagnostics_hierarchy, key: { prop: "prop_value#1" });
1231    }
1232
1233    #[fuchsia::test]
1234    #[should_panic]
1235    fn test_matching_non_unique_property_fails_3() {
1236        let diagnostics_hierarchy = non_unique_prop_tree();
1237        assert_data_tree!(diagnostics_hierarchy, key: {
1238            prop: "prop_value#0",
1239            prop: "prop_value#1",
1240        });
1241    }
1242
1243    #[fuchsia::test]
1244    #[should_panic]
1245    fn test_matching_non_unique_child_fails() {
1246        let diagnostics_hierarchy = non_unique_child_tree();
1247        assert_data_tree!(diagnostics_hierarchy, key: {
1248            child: {
1249                prop: 10
1250            }
1251        });
1252    }
1253
1254    #[fuchsia::test]
1255    #[should_panic]
1256    fn test_matching_non_unique_child_fails_2() {
1257        let diagnostics_hierarchy = non_unique_child_tree();
1258        assert_data_tree!(diagnostics_hierarchy, key: {
1259            child: {
1260                prop: 20
1261            }
1262        });
1263    }
1264
1265    #[fuchsia::test]
1266    #[should_panic]
1267    fn test_matching_non_unique_child_fails_3() {
1268        let diagnostics_hierarchy = non_unique_child_tree();
1269        assert_data_tree!(diagnostics_hierarchy, key: {
1270            child: {
1271                prop: 10,
1272            },
1273            child: {
1274                prop: 20,
1275            },
1276        });
1277    }
1278
1279    #[fuchsia::test]
1280    fn test_any_string_property_passes() {
1281        let diagnostics_hierarchy = DiagnosticsHierarchy::new(
1282            "key",
1283            vec![
1284                Property::String("value1".to_string(), "a".to_string()),
1285                Property::String("value2".to_string(), "b".to_string()),
1286            ],
1287            vec![],
1288        );
1289        assert_data_tree!(diagnostics_hierarchy, key: {
1290            value1: AnyStringProperty,
1291            value2: AnyStringProperty,
1292        });
1293    }
1294
1295    #[fuchsia::test]
1296    #[should_panic]
1297    fn test_any_string_property_fails() {
1298        let diagnostics_hierarchy = DiagnosticsHierarchy::new(
1299            "key",
1300            vec![Property::Int("value1".to_string(), 10i64)],
1301            vec![],
1302        );
1303        assert_data_tree!(diagnostics_hierarchy, key: {
1304            value1: AnyStringProperty,
1305        });
1306    }
1307
1308    #[fuchsia::test]
1309    fn test_string_property_regex_passes() {
1310        let diagnostics_hierarchy = DiagnosticsHierarchy::new(
1311            "key",
1312            vec![Property::String("value1".to_string(), "aaaabbbb".to_string())],
1313            vec![],
1314        );
1315        assert_data_tree!(diagnostics_hierarchy, key: {
1316            value1: &*TEST_REGEX,
1317        });
1318        assert_data_tree!(diagnostics_hierarchy, key: {
1319            value1: Regex::new("a{4}b{4}").unwrap(),
1320        });
1321        assert_data_tree!(diagnostics_hierarchy, key: {
1322            value1: Regex::new("a{4}").unwrap(),
1323        });
1324        assert_data_tree!(diagnostics_hierarchy, key: {
1325            value1: Regex::new("a{2}b{2}").unwrap(),
1326        });
1327        assert_data_tree!(diagnostics_hierarchy, key: {
1328            value1: Regex::new("b{4}").unwrap(),
1329        });
1330    }
1331
1332    #[fuchsia::test]
1333    #[should_panic]
1334    fn test_string_property_regex_no_match() {
1335        let diagnostics_hierarchy = DiagnosticsHierarchy::new(
1336            "key",
1337            vec![Property::String("value1".to_string(), "bbbbcccc".to_string())],
1338            vec![],
1339        );
1340        assert_data_tree!(diagnostics_hierarchy, key: {
1341                value: Regex::new("b{2}d{2}").unwrap(),
1342        });
1343    }
1344
1345    #[fuchsia::test]
1346    #[should_panic]
1347    fn test_string_property_regex_wrong_type() {
1348        let diagnostics_hierarchy = DiagnosticsHierarchy::new(
1349            "key",
1350            vec![Property::Int("value1".to_string(), 10i64)],
1351            vec![],
1352        );
1353        assert_data_tree!(diagnostics_hierarchy, key: {
1354            value1: Regex::new("a{4}").unwrap(),
1355        });
1356    }
1357
1358    #[fuchsia::test]
1359    fn test_any_bytes_property_passes() {
1360        let diagnostics_hierarchy = DiagnosticsHierarchy::new(
1361            "key",
1362            vec![
1363                Property::Bytes("value1".to_string(), vec![1, 2, 3]),
1364                Property::Bytes("value2".to_string(), vec![4, 5, 6]),
1365            ],
1366            vec![],
1367        );
1368        assert_data_tree!(diagnostics_hierarchy, key: {
1369            value1: AnyBytesProperty,
1370            value2: AnyBytesProperty,
1371        });
1372    }
1373
1374    #[fuchsia::test]
1375    #[should_panic]
1376    fn test_any_bytes_property_fails() {
1377        let diagnostics_hierarchy = DiagnosticsHierarchy::new(
1378            "key",
1379            vec![Property::Int("value1".to_string(), 10i64)],
1380            vec![],
1381        );
1382        assert_data_tree!(diagnostics_hierarchy, key: {
1383            value1: AnyBytesProperty,
1384        });
1385    }
1386
1387    #[fuchsia::test]
1388    fn test_nonzero_uint_property_passes() {
1389        let diagnostics_hierarchy = DiagnosticsHierarchy::new(
1390            "key",
1391            vec![
1392                Property::Uint("value1".to_string(), 10u64),
1393                Property::Uint("value2".to_string(), 20u64),
1394            ],
1395            vec![],
1396        );
1397        assert_data_tree!(diagnostics_hierarchy, key: {
1398            value1: NonZeroUintProperty,
1399            value2: NonZeroUintProperty,
1400        });
1401    }
1402
1403    #[fuchsia::test]
1404    #[should_panic]
1405    fn test_nonzero_uint_property_fails_on_zero() {
1406        let diagnostics_hierarchy = DiagnosticsHierarchy::new(
1407            "key",
1408            vec![Property::Uint("value1".to_string(), 0u64)],
1409            vec![],
1410        );
1411        assert_data_tree!(diagnostics_hierarchy, key: {
1412            value1: NonZeroUintProperty,
1413        });
1414    }
1415
1416    #[fuchsia::test]
1417    #[should_panic]
1418    fn test_nonzero_uint_property_fails() {
1419        let diagnostics_hierarchy = DiagnosticsHierarchy::new(
1420            "key",
1421            vec![Property::Int("value1".to_string(), 10i64)],
1422            vec![],
1423        );
1424        assert_data_tree!(diagnostics_hierarchy, key: {
1425            value1: NonZeroUintProperty,
1426        });
1427    }
1428
1429    #[fuchsia::test]
1430    fn test_nonzero_int_property_passes() {
1431        let diagnostics_hierarchy = DiagnosticsHierarchy::new(
1432            "key",
1433            vec![Property::Int("value1".to_string(), 10), Property::Int("value2".to_string(), 20)],
1434            vec![],
1435        );
1436        assert_data_tree!(diagnostics_hierarchy, key: {
1437            value1: NonZeroIntProperty,
1438            value2: NonZeroIntProperty,
1439        });
1440    }
1441
1442    #[fuchsia::test]
1443    #[should_panic]
1444    fn test_nonzero_int_property_fails_on_zero() {
1445        let diagnostics_hierarchy =
1446            DiagnosticsHierarchy::new("key", vec![Property::Int("value1".to_string(), 0)], vec![]);
1447        assert_data_tree!(diagnostics_hierarchy, key: {
1448            value1: NonZeroIntProperty,
1449        });
1450    }
1451
1452    #[fuchsia::test]
1453    #[should_panic]
1454    fn test_nonzero_int_property_fails() {
1455        let diagnostics_hierarchy = DiagnosticsHierarchy::new(
1456            "key",
1457            vec![Property::Uint("value1".to_string(), 10u64)],
1458            vec![],
1459        );
1460        assert_data_tree!(diagnostics_hierarchy, key: {
1461            value1: NonZeroIntProperty,
1462        });
1463    }
1464
1465    #[fuchsia::test]
1466    fn test_uint_property_passes() {
1467        let diagnostics_hierarchy = DiagnosticsHierarchy::new(
1468            "key",
1469            vec![
1470                Property::Uint("value1".to_string(), 10u64),
1471                Property::Uint("value2".to_string(), 20u64),
1472            ],
1473            vec![],
1474        );
1475        assert_data_tree!(diagnostics_hierarchy, key: {
1476            value1: AnyUintProperty,
1477            value2: AnyUintProperty,
1478        });
1479    }
1480
1481    #[fuchsia::test]
1482    #[should_panic]
1483    fn test_uint_property_fails() {
1484        let diagnostics_hierarchy = DiagnosticsHierarchy::new(
1485            "key",
1486            vec![Property::Int("value1".to_string(), 10i64)],
1487            vec![],
1488        );
1489        assert_data_tree!(diagnostics_hierarchy, key: {
1490            value1: AnyUintProperty,
1491        });
1492    }
1493
1494    #[fuchsia::test]
1495    fn test_int_property_passes() {
1496        let diagnostics_hierarchy = DiagnosticsHierarchy::new(
1497            "key",
1498            vec![
1499                Property::Int("value1".to_string(), 10i64),
1500                Property::Int("value2".to_string(), 20i64),
1501            ],
1502            vec![],
1503        );
1504        assert_data_tree!(diagnostics_hierarchy, key: {
1505            value1: AnyIntProperty,
1506            value2: AnyIntProperty,
1507        });
1508    }
1509
1510    #[fuchsia::test]
1511    #[should_panic]
1512    fn test_int_property_fails() {
1513        let diagnostics_hierarchy = DiagnosticsHierarchy::new(
1514            "key",
1515            vec![Property::Uint("value1".to_string(), 0u64)],
1516            vec![],
1517        );
1518        assert_data_tree!(diagnostics_hierarchy, key: {
1519            value1: AnyIntProperty,
1520        });
1521    }
1522
1523    #[fuchsia::test]
1524    fn test_double_property_passes() {
1525        let diagnostics_hierarchy = DiagnosticsHierarchy::new(
1526            "key",
1527            vec![
1528                Property::Double("value1".to_string(), std::f64::consts::PI),
1529                Property::Double("value2".to_string(), std::f64::consts::E),
1530            ],
1531            vec![],
1532        );
1533        assert_data_tree!(diagnostics_hierarchy, key: {
1534            value1: AnyDoubleProperty,
1535            value2: AnyDoubleProperty,
1536        });
1537    }
1538
1539    #[fuchsia::test]
1540    #[should_panic]
1541    fn test_double_property_fails() {
1542        let diagnostics_hierarchy = DiagnosticsHierarchy::new(
1543            "key",
1544            vec![Property::Uint("value1".to_string(), 0u64)],
1545            vec![],
1546        );
1547        assert_data_tree!(diagnostics_hierarchy, key: {
1548            value1: AnyDoubleProperty,
1549        });
1550    }
1551
1552    #[fuchsia::test]
1553    fn test_numeric_property_passes() {
1554        let diagnostics_hierarchy = DiagnosticsHierarchy::new(
1555            "key",
1556            vec![
1557                Property::Int("value1".to_string(), 10i64),
1558                Property::Uint("value2".to_string(), 20u64),
1559                Property::Double("value3".to_string(), std::f64::consts::PI),
1560            ],
1561            vec![],
1562        );
1563        assert_data_tree!(diagnostics_hierarchy, key: {
1564            value1: AnyNumericProperty,
1565            value2: AnyNumericProperty,
1566            value3: AnyNumericProperty,
1567        });
1568    }
1569
1570    #[fuchsia::test]
1571    #[should_panic]
1572    fn test_numeric_property_fails() {
1573        let diagnostics_hierarchy = DiagnosticsHierarchy::new(
1574            "key",
1575            vec![Property::String("value1".to_string(), "a".to_string())],
1576            vec![],
1577        );
1578        assert_data_tree!(diagnostics_hierarchy, key: {
1579            value1: AnyNumericProperty,
1580        });
1581    }
1582
1583    #[fuchsia::test]
1584    fn test_bool_property_passes() {
1585        let diagnostics_hierarchy = DiagnosticsHierarchy::new(
1586            "key",
1587            vec![
1588                Property::Bool("value1".to_string(), true),
1589                Property::Bool("value2".to_string(), false),
1590            ],
1591            vec![],
1592        );
1593        assert_data_tree!(diagnostics_hierarchy, key: {
1594            value1: AnyBoolProperty,
1595            value2: AnyBoolProperty,
1596        });
1597    }
1598
1599    #[fuchsia::test]
1600    #[should_panic]
1601    fn test_bool_property_fails() {
1602        let diagnostics_hierarchy = DiagnosticsHierarchy::new(
1603            "key",
1604            vec![Property::Uint("value1".to_string(), 0u64)],
1605            vec![],
1606        );
1607        assert_data_tree!(diagnostics_hierarchy, key: {
1608            value1: AnyBoolProperty,
1609        });
1610    }
1611
1612    #[fuchsia::test]
1613    fn test_string_list() {
1614        let diagnostics_hierarchy = DiagnosticsHierarchy::new(
1615            "key",
1616            vec![
1617                Property::StringList("value1".to_string(), vec!["a".to_string(), "b".to_string()]),
1618                Property::StringList("value2".to_string(), vec!["c".to_string(), "d".to_string()]),
1619            ],
1620            vec![],
1621        );
1622        assert_data_tree!(diagnostics_hierarchy, key: {
1623            value1: vec!["a", "b"],
1624            value2: vec!["c".to_string(), "d".to_string()],
1625        });
1626    }
1627
1628    #[fuchsia::test]
1629    #[should_panic]
1630    fn test_string_list_failure() {
1631        let diagnostics_hierarchy = DiagnosticsHierarchy::new(
1632            "key",
1633            vec![Property::StringList(
1634                "value1".to_string(),
1635                vec!["a".to_string(), "b".to_string()],
1636            )],
1637            vec![],
1638        );
1639        assert_data_tree!(diagnostics_hierarchy, key: {
1640            value1: vec![1i64, 2],
1641        });
1642    }
1643
1644    #[test]
1645    fn test_diff_from_text() {
1646        let original = "foo\nbar\nbaz";
1647        let update = "foo\nbaz\nqux";
1648
1649        let changeset = Diff::from_text(original, update);
1650        assert_eq!(
1651            changeset.0.diffs,
1652            vec![
1653                Same("foo".to_string()),
1654                Rem("bar".to_string()),
1655                Same("baz".to_string()),
1656                Add("qux".to_string())
1657            ]
1658        )
1659    }
1660
1661    fn simple_tree() -> DiagnosticsHierarchy {
1662        DiagnosticsHierarchy::new(
1663            "key",
1664            vec![
1665                Property::String("sub".to_string(), "sub_value".to_string()),
1666                Property::String("sub2".to_string(), "sub2_value".to_string()),
1667            ],
1668            vec![],
1669        )
1670    }
1671
1672    fn complex_tree() -> DiagnosticsHierarchy {
1673        DiagnosticsHierarchy::new(
1674            "key",
1675            vec![
1676                Property::String("sub".to_string(), "sub_value".to_string()),
1677                Property::String("sub2".to_string(), "sub2_value".to_string()),
1678            ],
1679            vec![
1680                DiagnosticsHierarchy::new(
1681                    "child1",
1682                    vec![Property::Int("child1_sub".to_string(), 10i64)],
1683                    vec![],
1684                ),
1685                DiagnosticsHierarchy::new(
1686                    "child2",
1687                    vec![Property::Uint("child2_sub".to_string(), 20u64)],
1688                    vec![],
1689                ),
1690            ],
1691        )
1692    }
1693
1694    fn non_unique_prop_tree() -> DiagnosticsHierarchy {
1695        DiagnosticsHierarchy::new(
1696            "key",
1697            vec![
1698                Property::String("prop".to_string(), "prop_value#0".to_string()),
1699                Property::String("prop".to_string(), "prop_value#1".to_string()),
1700            ],
1701            vec![],
1702        )
1703    }
1704
1705    fn non_unique_child_tree() -> DiagnosticsHierarchy {
1706        DiagnosticsHierarchy::new(
1707            "key",
1708            vec![],
1709            vec![
1710                DiagnosticsHierarchy::new(
1711                    "child",
1712                    vec![Property::Int("prop".to_string(), 10i64)],
1713                    vec![],
1714                ),
1715                DiagnosticsHierarchy::new(
1716                    "child",
1717                    vec![Property::Int("prop".to_string(), 20i64)],
1718                    vec![],
1719                ),
1720            ],
1721        )
1722    }
1723}
diagnostics_assertions/lib.rs

diagnostics_assertions/
lib.rs
