| // Copyright 2019 The Fuchsia Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| use super::validate::{self, Action, Number, NumberType, ROOT_ID}; |
| |
| pub enum Step { |
| Actions(Vec<validate::Action>), |
| LazyActions(Vec<validate::LazyAction>), |
| WithMetrics(Vec<validate::Action>, String), |
| } |
| |
| pub struct Trial { |
| pub name: String, |
| pub steps: Vec<Step>, |
| } |
| |
| pub fn real_trials() -> Vec<Trial> { |
| vec![ |
| basic_node(), |
| basic_int(), |
| basic_uint(), |
| basic_double(), |
| basic_string(), |
| basic_bytes(), |
| basic_bool(), |
| basic_int_array(), |
| basic_uint_array(), |
| basic_double_array(), |
| int_histogram_ops_trial(), |
| uint_histogram_ops_trial(), |
| double_histogram_ops_trial(), |
| deletions_trial(), |
| lazy_nodes_trial(), |
| repeated_names(), |
| ] |
| } |
| |
| #[macro_export] |
| macro_rules! create_node { |
| (parent: $parent:expr, id: $id:expr, name: $name:expr) => { |
| validate::Action::CreateNode(validate::CreateNode { |
| parent: $parent, |
| id: $id, |
| name: $name.into(), |
| }) |
| }; |
| } |
| |
| #[macro_export] |
| macro_rules! delete_node { |
| (id: $id:expr) => { |
| validate::Action::DeleteNode(validate::DeleteNode { id: $id }) |
| }; |
| } |
| |
| #[macro_export] |
| macro_rules! create_numeric_property { |
| (parent: $parent:expr, id: $id:expr, name: $name:expr, value: $value:expr) => { |
| validate::Action::CreateNumericProperty(validate::CreateNumericProperty { |
| parent: $parent, |
| id: $id, |
| name: $name.into(), |
| value: $value, |
| }) |
| }; |
| } |
| |
| #[macro_export] |
| macro_rules! create_bytes_property { |
| (parent: $parent:expr, id: $id:expr, name: $name:expr, value: $value:expr) => { |
| validate::Action::CreateBytesProperty(validate::CreateBytesProperty { |
| parent: $parent, |
| id: $id, |
| name: $name.into(), |
| value: $value.into(), |
| }) |
| }; |
| } |
| |
| #[macro_export] |
| macro_rules! create_string_property { |
| (parent: $parent:expr, id: $id:expr, name: $name:expr, value: $value:expr) => { |
| validate::Action::CreateStringProperty(validate::CreateStringProperty { |
| parent: $parent, |
| id: $id, |
| name: $name.into(), |
| value: $value.into(), |
| }) |
| }; |
| } |
| |
| #[macro_export] |
| macro_rules! create_bool_property { |
| (parent: $parent:expr, id: $id:expr, name: $name:expr, value: $value:expr) => { |
| validate::Action::CreateBoolProperty(validate::CreateBoolProperty { |
| parent: $parent, |
| id: $id, |
| name: $name.into(), |
| value: $value.into(), |
| }) |
| }; |
| } |
| |
| #[macro_export] |
| macro_rules! set_string { |
| (id: $id:expr, value: $value:expr) => { |
| validate::Action::SetString(validate::SetString { id: $id, value: $value.into() }) |
| }; |
| } |
| |
| #[macro_export] |
| macro_rules! set_bytes { |
| (id: $id:expr, value: $value:expr) => { |
| validate::Action::SetBytes(validate::SetBytes { id: $id, value: $value.into() }) |
| }; |
| } |
| |
| #[macro_export] |
| macro_rules! set_number { |
| (id: $id:expr, value: $value:expr) => { |
| validate::Action::SetNumber(validate::SetNumber { id: $id, value: $value }) |
| }; |
| } |
| |
| #[macro_export] |
| macro_rules! set_bool { |
| (id: $id:expr, value: $value:expr) => { |
| validate::Action::SetBool(validate::SetBool { id: $id, value: $value.into() }) |
| }; |
| } |
| |
| #[macro_export] |
| macro_rules! add_number { |
| (id: $id:expr, value: $value:expr) => { |
| validate::Action::AddNumber(validate::AddNumber { id: $id, value: $value }) |
| }; |
| } |
| |
| #[macro_export] |
| macro_rules! subtract_number { |
| (id: $id:expr, value: $value:expr) => { |
| validate::Action::SubtractNumber(validate::SubtractNumber { id: $id, value: $value }) |
| }; |
| } |
| |
| #[macro_export] |
| macro_rules! delete_property { |
| (id: $id:expr) => { |
| validate::Action::DeleteProperty(validate::DeleteProperty { id: $id }) |
| }; |
| } |
| |
| #[macro_export] |
| macro_rules! create_array_property { |
| (parent: $parent:expr, id: $id:expr, name: $name:expr, slots: $slots:expr, type: $type:expr) => { |
| validate::Action::CreateArrayProperty(validate::CreateArrayProperty { |
| parent: $parent, |
| id: $id, |
| name: $name.into(), |
| slots: $slots, |
| number_type: $type, |
| }) |
| }; |
| } |
| |
| #[macro_export] |
| macro_rules! array_set { |
| (id: $id:expr, index: $index:expr, value: $value:expr) => { |
| validate::Action::ArraySet(validate::ArraySet { id: $id, index: $index, value: $value }) |
| }; |
| } |
| |
| #[macro_export] |
| macro_rules! array_add { |
| (id: $id:expr, index: $index:expr, value: $value:expr) => { |
| validate::Action::ArrayAdd(validate::ArrayAdd { id: $id, index: $index, value: $value }) |
| }; |
| } |
| |
| #[macro_export] |
| macro_rules! array_subtract { |
| (id: $id:expr, index: $index:expr, value: $value:expr) => { |
| validate::Action::ArraySubtract(validate::ArraySubtract { |
| id: $id, |
| index: $index, |
| value: $value, |
| }) |
| }; |
| } |
| |
| #[macro_export] |
| macro_rules! create_linear_histogram { |
| (parent: $parent:expr, id: $id:expr, name: $name:expr, floor: $floor:expr, |
| step_size: $step_size:expr, buckets: $buckets:expr, type: $type:ident) => { |
| validate::Action::CreateLinearHistogram(validate::CreateLinearHistogram { |
| parent: $parent, |
| id: $id, |
| name: $name.into(), |
| floor: Number::$type($floor), |
| step_size: Number::$type($step_size), |
| buckets: $buckets, |
| }) |
| }; |
| } |
| |
| #[macro_export] |
| macro_rules! create_exponential_histogram { |
| (parent: $parent:expr, id: $id:expr, name: $name:expr, floor: $floor:expr, |
| initial_step: $initial_step:expr, step_multiplier: $step_multiplier:expr, |
| buckets: $buckets:expr, type: $type:ident) => { |
| validate::Action::CreateExponentialHistogram(validate::CreateExponentialHistogram { |
| parent: $parent, |
| id: $id, |
| name: $name.into(), |
| floor: Number::$type($floor), |
| initial_step: Number::$type($initial_step), |
| step_multiplier: Number::$type($step_multiplier), |
| buckets: $buckets, |
| }) |
| }; |
| } |
| |
| #[macro_export] |
| macro_rules! insert { |
| (id: $id:expr, value: $value:expr) => { |
| validate::Action::Insert(validate::Insert { id: $id, value: $value }) |
| }; |
| } |
| |
| #[macro_export] |
| macro_rules! insert_multiple { |
| (id: $id:expr, value: $value:expr, count: $count:expr) => { |
| validate::Action::InsertMultiple(validate::InsertMultiple { |
| id: $id, |
| value: $value, |
| count: $count, |
| }) |
| }; |
| } |
| |
| #[macro_export] |
| macro_rules! create_lazy_node { |
| (parent: $parent:expr, id: $id:expr, name: $name:expr, disposition: $disposition:expr, actions: $actions:expr) => { |
| validate::LazyAction::CreateLazyNode(validate::CreateLazyNode { |
| parent: $parent, |
| id: $id, |
| name: $name.into(), |
| disposition: $disposition, |
| actions: $actions, |
| }) |
| }; |
| } |
| |
| #[macro_export] |
| macro_rules! delete_lazy_node { |
| (id: $id:expr) => { |
| validate::LazyAction::DeleteLazyNode(validate::DeleteLazyNode { id: $id }) |
| }; |
| } |
| |
| fn basic_node() -> Trial { |
| Trial { |
| name: "Basic Node".into(), |
| steps: vec![Step::Actions(vec![ |
| create_node!(parent: ROOT_ID, id: 1, name: "child"), |
| create_node!(parent: 1, id: 2, name: "grandchild"), |
| delete_node!( id: 2), |
| delete_node!( id: 1 ), |
| // Verify they can be deleted in either order. |
| create_node!(parent: ROOT_ID, id: 1, name: "child"), |
| create_node!(parent: 1, id: 2, name: "grandchild"), |
| delete_node!( id: 1), |
| delete_node!( id: 2 ), |
| ])], |
| } |
| } |
| |
| fn basic_string() -> Trial { |
| Trial { |
| name: "Basic String".into(), |
| steps: vec![Step::Actions(vec![ |
| create_string_property!(parent: ROOT_ID, id:1, name: "str", value: "foo"), |
| set_string!(id: 1, value: "bar"), |
| set_string!(id: 1, value: "This Is A Longer String"), |
| set_string!(id: 1, value: "."), |
| // Make sure it can hold a string bigger than the biggest block (3000 chars > 2040) |
| set_string!(id: 1, value: ["1234567890"; 300].to_vec().join("")), |
| delete_property!(id: 1), |
| ])], |
| } |
| } |
| |
| fn basic_bytes() -> Trial { |
| Trial { |
| name: "Basic bytes".into(), |
| steps: vec![Step::Actions(vec![ |
| create_bytes_property!(parent: ROOT_ID, id: 8, name: "bytes", value: vec![1u8, 2u8]), |
| set_bytes!(id: 8, value: vec![3u8, 4, 5, 6, 7]), |
| set_bytes!(id: 8, value: vec![8u8]), |
| delete_property!(id: 8), |
| ])], |
| } |
| } |
| |
| fn basic_bool() -> Trial { |
| Trial { |
| name: "Basic Bool".into(), |
| steps: vec![Step::Actions(vec![ |
| create_bool_property!(parent: ROOT_ID, id: 1, name: "bool", value: true), |
| set_bool!(id: 1, value: false), |
| set_bool!(id: 1, value: true), |
| delete_property!(id: 1), |
| ])], |
| } |
| } |
| |
| fn basic_int() -> Trial { |
| Trial { |
| name: "Basic Int".into(), |
| steps: vec![Step::Actions(vec![ |
| create_numeric_property!(parent: ROOT_ID, id: 5, name: "int", value: Number::IntT(10)), |
| set_number!(id: 5, value: Number::IntT(std::i64::MAX)), |
| subtract_number!(id: 5, value: Number::IntT(3)), |
| set_number!(id: 5, value: Number::IntT(std::i64::MIN)), |
| add_number!(id: 5, value: Number::IntT(2)), |
| delete_property!(id: 5), |
| ])], |
| } |
| } |
| |
| fn basic_uint() -> Trial { |
| Trial { |
| name: "Basic Uint".into(), |
| steps: vec![Step::Actions(vec![ |
| create_numeric_property!(parent: ROOT_ID, id: 5, name: "uint", value: Number::UintT(1)), |
| set_number!(id: 5, value: Number::UintT(std::u64::MAX)), |
| subtract_number!(id: 5, value: Number::UintT(3)), |
| set_number!(id: 5, value: Number::UintT(0)), |
| add_number!(id: 5, value: Number::UintT(2)), |
| delete_property!(id: 5), |
| ])], |
| } |
| } |
| |
| fn basic_double() -> Trial { |
| Trial { |
| name: "Basic Double".into(), |
| steps: vec![Step::Actions(vec![ |
| create_numeric_property!(parent: ROOT_ID, id: 5, name: "double", |
| value: Number::DoubleT(1.0)), |
| set_number!(id: 5, value: Number::DoubleT(std::f64::MAX)), |
| subtract_number!(id: 5, value: Number::DoubleT(std::f64::MAX/10_f64)), |
| set_number!(id: 5, value: Number::DoubleT(std::f64::MIN)), |
| add_number!(id: 5, value: Number::DoubleT(std::f64::MAX / 10_f64)), |
| delete_property!(id: 5), |
| ])], |
| } |
| } |
| |
| fn repeated_names() -> Trial { |
| let mut actions = vec![create_node!(parent: ROOT_ID, id: 1, name: "measurements")]; |
| |
| for i in 100..120 { |
| actions.push(create_node!(parent: 1, id: i, name: format!("{}", i))); |
| actions.push(create_numeric_property!(parent: i, id: i + 1000, name: "count", value: Number::UintT(i as u64 * 2))); |
| actions.push(create_numeric_property!(parent: i, id: i + 2000, name: "time_spent", value: Number::UintT(i as u64 * 1000 + 10))); |
| } |
| |
| Trial { |
| name: "Many repeated names".into(), |
| steps: vec![Step::WithMetrics(actions, "Many repeated names".into())], |
| } |
| } |
| |
| fn array_indexes_to_test() -> Vec<u64> { |
| let mut ret: Vec<u64> = (0..10).collect(); |
| ret.push(1000); |
| ret.push(10000); |
| ret.push(std::u64::MAX); |
| ret |
| } |
| |
| fn basic_int_array() -> Trial { |
| let mut actions = vec![create_array_property!(parent: ROOT_ID, id: 5, name: "int", slots: 5, |
| type: NumberType::Int)]; |
| for index in array_indexes_to_test().iter() { |
| actions.push(array_add!(id: 5, index: *index, value: Number::IntT(7))); |
| actions.push(array_subtract!(id: 5, index: *index, value: Number::IntT(3))); |
| actions.push(array_set!(id: 5, index: *index, value: Number::IntT(19))); |
| } |
| actions.push(delete_property!(id: 5)); |
| Trial { name: "Int Array Ops".into(), steps: vec![Step::Actions(actions)] } |
| } |
| |
| fn basic_uint_array() -> Trial { |
| let mut actions = vec![create_array_property!(parent: ROOT_ID, id: 6, name: "uint", slots: 5, |
| type: NumberType::Uint)]; |
| for index in array_indexes_to_test().iter() { |
| actions.push(array_add!(id: 6, index: *index, value: Number::UintT(11))); |
| actions.push(array_subtract!(id: 6, index: *index, value: Number::UintT(3))); |
| actions.push(array_set!(id: 6, index: *index, value: Number::UintT(19))); |
| } |
| actions.push(delete_property!(id: 6)); |
| Trial { name: "Unt Array Ops".into(), steps: vec![Step::Actions(actions)] } |
| } |
| |
| fn basic_double_array() -> Trial { |
| let mut actions = vec![create_array_property!(parent: ROOT_ID, id: 4, name: "float", slots: 5, |
| type: NumberType::Double)]; |
| for index in array_indexes_to_test().iter() { |
| actions.push(array_add!(id: 4, index: *index, value: Number::DoubleT(2.0))); |
| actions.push(array_subtract!(id: 4, index: *index, value: Number::DoubleT(3.5))); |
| actions.push(array_set!(id: 4, index: *index, value: Number::DoubleT(19.0))); |
| } |
| actions.push(delete_property!(id: 4)); |
| Trial { name: "Int Array Ops".into(), steps: vec![Step::Actions(actions)] } |
| } |
| |
| fn int_histogram_ops_trial() -> Trial { |
| fn push_ops(actions: &mut Vec<validate::Action>, value: i64) { |
| actions.push(insert!(id: 4, value: Number::IntT(value))); |
| actions.push(insert_multiple!(id: 4, value: Number::IntT(value), count: 3)); |
| actions.push(insert!(id: 5, value: Number::IntT(value))); |
| actions.push(insert_multiple!(id: 5, value: Number::IntT(value), count: 3)); |
| } |
| let mut actions = vec![ |
| create_linear_histogram!(parent: ROOT_ID, id: 4, name: "Lhist", floor: -5, |
| step_size: 3, buckets: 3, type: IntT), |
| create_exponential_histogram!(parent: ROOT_ID, id: 5, name: "Ehist", floor: -5, |
| initial_step: 2, step_multiplier: 4, |
| buckets: 3, type: IntT), |
| ]; |
| for value in &[std::i64::MIN, std::i64::MAX, 0] { |
| push_ops(&mut actions, *value); |
| } |
| for value in vec![-10_i64, -5_i64, 0_i64, 3_i64, 100_i64] { |
| push_ops(&mut actions, value); |
| } |
| actions.push(delete_property!(id: 4)); |
| actions.push(delete_property!(id: 5)); |
| Trial { name: "Int Histogram Ops".into(), steps: vec![Step::Actions(actions)] } |
| } |
| |
| fn uint_histogram_ops_trial() -> Trial { |
| fn push_ops(actions: &mut Vec<validate::Action>, value: u64) { |
| actions.push(insert!(id: 4, value: Number::UintT(value))); |
| actions.push(insert_multiple!(id: 4, value: Number::UintT(value), count: 3)); |
| actions.push(insert!(id: 5, value: Number::UintT(value))); |
| actions.push(insert_multiple!(id: 5, value: Number::UintT(value), count: 3)); |
| } |
| let mut actions = vec![ |
| create_linear_histogram!(parent: ROOT_ID, id: 4, name: "Lhist", floor: 5, |
| step_size: 3, buckets: 3, type: UintT), |
| create_exponential_histogram!(parent: ROOT_ID, id: 5, name: "Ehist", floor: 5, |
| initial_step: 2, step_multiplier: 4, |
| buckets: 3, type: UintT), |
| ]; |
| for value in &[std::u64::MAX, 0] { |
| push_ops(&mut actions, *value); |
| } |
| for value in vec![0_u64, 5_u64, 8_u64, 20u64, 200_u64] { |
| push_ops(&mut actions, value); |
| } |
| actions.push(delete_property!(id: 4)); |
| actions.push(delete_property!(id: 5)); |
| Trial { name: "Uint Histogram Ops".into(), steps: vec![Step::Actions(actions)] } |
| } |
| |
| fn double_histogram_ops_trial() -> Trial { |
| fn push_ops(actions: &mut Vec<validate::Action>, value: f64) { |
| actions.push(insert!(id: 4, value: Number::DoubleT(value))); |
| actions.push(insert_multiple!(id: 4, value: Number::DoubleT(value), count: 3)); |
| actions.push(insert!(id: 5, value: Number::DoubleT(value))); |
| actions.push(insert_multiple!(id: 5, value: Number::DoubleT(value), count: 3)); |
| } |
| let mut actions = vec![ |
| // Create exponential first in this test, so that if histograms aren't supported, both |
| // linear and exponential will be reported as unsupported. |
| create_exponential_histogram!(parent: ROOT_ID, id: 5, name: "Ehist", |
| floor: std::f64::consts::PI, initial_step: 2.0, |
| step_multiplier: 4.0, buckets: 3, type: DoubleT), |
| create_linear_histogram!(parent: ROOT_ID, id: 4, name: "Lhist", floor: 5.0, |
| step_size: 3.0, buckets: 3, type: DoubleT), |
| ]; |
| for value in &[std::f64::MIN, std::f64::MAX, std::f64::MIN_POSITIVE, 0.0] { |
| push_ops(&mut actions, *value); |
| } |
| for value in vec![3.0, 3.15, 5.0, 10.0] { |
| push_ops(&mut actions, value as f64); |
| } |
| actions.push(delete_property!(id: 4)); |
| actions.push(delete_property!(id: 5)); |
| Trial { name: "Double Histogram Ops".into(), steps: vec![Step::Actions(actions)] } |
| } |
| |
| fn deletions_trial() -> Trial { |
| // Action, being a FIDL struct, doesn't implement Clone, so we have to build a new |
| // Action each time we want to invoke it. |
| fn n1() -> Action { |
| create_node!(parent: ROOT_ID, id: 1, name: "root_child") |
| } |
| fn n2() -> Action { |
| create_node!(parent: 1, id: 2, name: "parent") |
| } |
| fn n3() -> Action { |
| create_node!(parent: 2, id: 3, name: "child") |
| } |
| fn p1() -> Action { |
| create_numeric_property!(parent: 1, id: 4, name: "root_int", value: Number::IntT(1)) |
| } |
| fn p2() -> Action { |
| create_numeric_property!(parent: 2, id: 5, name: "parent_int", value: Number::IntT(2)) |
| } |
| fn p3() -> Action { |
| create_numeric_property!(parent: 3, id: 6, name: "child_int", value: Number::IntT(3)) |
| } |
| fn create() -> Vec<Action> { |
| vec![n1(), n2(), n3(), p1(), p2(), p3()] |
| } |
| fn create2() -> Vec<Action> { |
| vec![n1(), p1(), n2(), p2(), n3(), p3()] |
| } |
| fn d1() -> Action { |
| delete_node!(id: 1) |
| } |
| fn d2() -> Action { |
| delete_node!(id: 2) |
| } |
| fn d3() -> Action { |
| delete_node!(id: 3) |
| } |
| fn x1() -> Action { |
| delete_property!(id: 4) |
| } |
| fn x2() -> Action { |
| delete_property!(id: 5) |
| } |
| fn x3() -> Action { |
| delete_property!(id: 6) |
| } |
| let mut steps = Vec::new(); |
| steps.push(Step::Actions(create())); |
| steps.push(Step::Actions(vec![d3(), d2(), d1(), x3(), x2(), x1()])); |
| steps.push(Step::Actions(create2())); |
| steps.push(Step::WithMetrics(vec![d1(), d2()], "Delete Except Grandchild".into())); |
| steps.push(Step::WithMetrics(vec![d3(), x3(), x2(), x1()], "Deleted Grandchild".into())); |
| // This list tests all 6 sequences of node deletion. |
| // TODO(fxbug.dev/40843): Get the permutohedron crate and test all 720 sequences. |
| steps.push(Step::Actions(create())); |
| steps.push(Step::Actions(vec![d1(), d2(), d3(), x3(), x2(), x1()])); |
| steps.push(Step::Actions(create2())); |
| steps.push(Step::Actions(vec![d1(), x3(), d2(), x1(), d3(), x2()])); |
| steps.push(Step::Actions(create())); |
| steps.push(Step::Actions(vec![d1(), x2(), d3(), x3(), d2(), x1()])); |
| steps.push(Step::Actions(create2())); |
| steps.push(Step::Actions(vec![x1(), x3(), d2(), d1(), d3(), x2()])); |
| steps.push(Step::Actions(create())); |
| steps.push(Step::Actions(vec![d2(), x3(), x2(), x1(), d3(), d1()])); |
| steps.push(Step::Actions(create2())); |
| steps.push(Step::Actions(vec![d3(), x3(), d2(), x1(), d1(), x2()])); |
| steps.push(Step::Actions(create2())); |
| steps.push(Step::Actions(vec![x3(), d3(), d1(), x1(), d2(), x2()])); |
| steps.push(Step::WithMetrics(vec![], "Everything should be gone".into())); |
| Trial { name: "Delete With Metrics".into(), steps } |
| } |
| |
| fn lazy_nodes_trial() -> Trial { |
| Trial { |
| name: "Lazy Nodes".into(), |
| steps: vec![Step::LazyActions(vec![ |
| // Create sibling node with same name and same content |
| create_lazy_node!( |
| parent: ROOT_ID, |
| id: 1, |
| name: "child", |
| disposition: validate::LinkDisposition::Child, |
| actions: vec![create_bytes_property!(parent: ROOT_ID, id: 1, name: "child_bytes",value: vec!(3u8, 4u8))] |
| ), |
| create_lazy_node!( |
| parent: ROOT_ID, |
| id: 2, |
| name: "child", |
| disposition: validate::LinkDisposition::Child, |
| actions: vec![create_bytes_property!(parent: ROOT_ID, id: 1, name: "child_bytes",value: vec!(3u8, 4u8))] |
| ), |
| delete_lazy_node!(id: 1), |
| delete_lazy_node!(id: 2), |
| // Recreate child node with new values |
| create_lazy_node!( |
| parent: ROOT_ID, |
| id: 1, |
| name: "child", |
| disposition: validate::LinkDisposition::Child, |
| actions: vec![create_bytes_property!(parent: ROOT_ID, id: 1, name: "child_bytes_new",value: vec!(1u8, 2u8))] |
| ), |
| delete_lazy_node!(id: 1), |
| // Create child node with inline disposition |
| create_lazy_node!( |
| parent: ROOT_ID, |
| id: 1, |
| name: "inline_child", |
| disposition: validate::LinkDisposition::Inline, |
| actions: vec![create_bytes_property!(parent: ROOT_ID, id: 1, name: "inline_child",value: vec!(1u8, 2u8))] |
| ), |
| delete_lazy_node!(id: 1), |
| ])], |
| } |
| } |
| |
| #[cfg(test)] |
| pub(crate) mod tests { |
| use {super::*, fidl_test_inspect_validate::*}; |
| |
| pub fn trial_with_action(name: &str, action: Action) -> Trial { |
| Trial { name: name.into(), steps: vec![Step::Actions(vec![action])] } |
| } |
| } |
