Struct origen::prog_gen::Test

pub struct Test {
    pub id: usize,
    pub name: String,
    pub indirect: bool,
    pub params: IndexMap<String, ParamType>,
    pub values: IndexMap<String, ParamValue>,
    pub aliases: IndexMap<String, String>,
    pub constraints: IndexMap<String, Vec<Constraint>>,
    pub tester: SupportedTester,
    pub class_name: Option<String>,
    pub test_id: Option<usize>,
    // some fields omitted
}

This is an abstract data object which is used to model test instances on Teradyne platforms and both test methods and test suites on Advantest platforms. A test template is modelled as a Test where indirect = true, which means that it will never be rendered directly to a test program output file, however it can be referenced as a parent by direct tests which are to be rendered. Child tests can add additional prameters/aliases/defaults and/or inherit or override those from parent tests.

Fields

id: usize

name: String

indirect: bool

params: IndexMap<String, ParamType>

Defines the names of parameters and their types. Child class can override the type of a parameter inherited from a parent by adding a parameter of the same name to their params map. Then can also add additional parameters via the same mechanism. It is not possible to delete a parameter inherited from a parent Test.

values: IndexMap<String, ParamValue>

aliases: IndexMap<String, String>

constraints: IndexMap<String, Vec<Constraint>>

tester: SupportedTester

class_name: Option<String>

test_id: Option<usize>

Implementations

impl Test

pub fn new(name: &str, id: usize, tester: SupportedTester) -> Test

pub fn sorted_params(&self) -> SortedParams<'_>

pub fn import_test_template(
    &mut self,
    test_template: &TestTemplate
) -> Result<()>

Applies the values read from a test template file (e.g. JSON) to the current test object

pub fn set(
    &mut self,
    param_name_or_alias: &str,
    value: ParamValue,
    allow_mising: bool
) -> Result<()>

Set the value of the given parameter to the given value, returns an error if the parameter is not found (unless allow_missing = true), if its type does match the type of the given value or if any constraints placed on the possible values is violated

pub fn get(&self, param_name_or_alias: &str) -> Result<Option<&ParamValue>>

Get the value of the given attribute

pub fn get_type(&self, param_name_or_alias: &str) -> Result<&ParamType>

Returns the type of the given parameter name (or alias), returns an error if the parameter is not found

pub fn add_param(
    &mut self,
    name: &str,
    kind: ParamType,
    default_value: Option<ParamValue>,
    aliases: Option<Vec<&str>>,
    constraints: Option<Vec<Constraint>>
) -> Result<()>

pub fn add_alias(&mut self, alias: &str, param_name: &str) -> Result<()>

Define a simple alias for an existing parameter, returns an error if the parameter is not found

pub fn has_param(&self, param_name: &str) -> bool

Returns true if the test has the given parameter name or alias

pub fn to_param_name<'a>(&'a self, name: &'a str) -> Result<&'a str>

Resolves the given param or alias name to a param name

Trait Implementations

impl Clone for Test

fn clone(&self) -> Test

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Test

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

Formats the value using the given formatter.

impl Serialize for Test

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.