1339 lines
40 KiB
Rust
1339 lines
40 KiB
Rust
use oa_core::{
|
|
data::*,
|
|
references,
|
|
transitions::*,
|
|
validation::{self, Severity},
|
|
*,
|
|
};
|
|
|
|
fn add(p: &mut Project, kind: Kind, name: &str, parent: Option<Id>) -> Id {
|
|
p.add_element(kind, Layer::Oa, name, parent).unwrap()
|
|
}
|
|
fn body(p: &mut Project, id: Id, body: SharedBody) {
|
|
*p.elements.get_mut(&id).unwrap().shared_mut().unwrap() = body;
|
|
}
|
|
fn make_record(p: &mut Project, name: &str, supertype: Option<Id>) -> Id {
|
|
let id = add(p, Kind::DataType, name, None);
|
|
body(
|
|
p,
|
|
id,
|
|
SharedBody::DataType {
|
|
definition: DataTypeDefinition::Record { supertype },
|
|
default: None,
|
|
unit: String::new(),
|
|
},
|
|
);
|
|
id
|
|
}
|
|
fn field(
|
|
p: &mut Project,
|
|
owner: Id,
|
|
name: &str,
|
|
type_ref: TypeRef,
|
|
direction: ParameterDirection,
|
|
) -> Id {
|
|
let id = add(p, Kind::DataField, name, Some(owner));
|
|
body(
|
|
p,
|
|
id,
|
|
SharedBody::DataField {
|
|
type_ref,
|
|
minimum: 1,
|
|
maximum: Some(1),
|
|
unit: String::new(),
|
|
direction,
|
|
storage: FieldStorage::Value,
|
|
default: None,
|
|
},
|
|
);
|
|
id
|
|
}
|
|
fn edited(p: &Project, id: Id, change: impl FnOnce(&mut SharedBody)) -> Command {
|
|
let mut e = p.elements[&id].clone();
|
|
change(e.shared_mut().unwrap());
|
|
Command::EditElement(id, e)
|
|
}
|
|
fn valid(p: &Project) {
|
|
let errors: Vec<_> = validation::validate(p)
|
|
.into_iter()
|
|
.filter(|i| i.severity == Severity::Error)
|
|
.collect();
|
|
assert!(errors.is_empty(), "{errors:?}");
|
|
}
|
|
fn code(p: &Project, code: &str, severity: Severity) -> bool {
|
|
validation::validate(p)
|
|
.iter()
|
|
.any(|i| i.code == code && i.severity == severity)
|
|
}
|
|
fn values(p: &Project, id: Id) -> &Vec<MessageValue> {
|
|
let Some(SharedBody::Occurrence {
|
|
body: OccurrenceBody::Exchange { values, .. },
|
|
..
|
|
}) = p.elements[&id].shared()
|
|
else {
|
|
panic!()
|
|
};
|
|
values
|
|
}
|
|
#[allow(clippy::too_many_arguments)]
|
|
fn message(
|
|
p: &mut Project,
|
|
scenario: Id,
|
|
exchange: Id,
|
|
kind: MessageKind,
|
|
reply_to: Option<Id>,
|
|
name: &str,
|
|
values: Vec<MessageValue>,
|
|
) -> Id {
|
|
let id = add(p, Kind::Occurrence, name, Some(scenario));
|
|
body(
|
|
p,
|
|
id,
|
|
SharedBody::Occurrence {
|
|
body: OccurrenceBody::Exchange {
|
|
exchange: Some(exchange),
|
|
sender: None,
|
|
receiver: None,
|
|
message_kind: kind,
|
|
reply_to,
|
|
values,
|
|
},
|
|
precondition: String::new(),
|
|
postcondition: String::new(),
|
|
},
|
|
);
|
|
p.elements
|
|
.get_mut(&scenario)
|
|
.unwrap()
|
|
.steps_mut()
|
|
.unwrap()
|
|
.push(id);
|
|
id
|
|
}
|
|
struct Payload {
|
|
p: Project,
|
|
item: Id,
|
|
record: Id,
|
|
leaf: Id,
|
|
origin: Id,
|
|
destination: Id,
|
|
exchange: Id,
|
|
call: Id,
|
|
reply: Id,
|
|
}
|
|
fn payload() -> Payload {
|
|
let mut p = Project::empty();
|
|
let item = add(&mut p, Kind::ExchangeItem, "Move", None);
|
|
body(
|
|
&mut p,
|
|
item,
|
|
SharedBody::ExchangeItem {
|
|
kind: ExchangeItemKind::Information,
|
|
mechanism: ExchangeMechanism::Operation,
|
|
supertype: None,
|
|
},
|
|
);
|
|
let record = make_record(&mut p, "Coordinate", None);
|
|
let leaf = field(
|
|
&mut p,
|
|
record,
|
|
"latitude",
|
|
TypeRef::Real,
|
|
ParameterDirection::Unspecified,
|
|
);
|
|
let origin = field(
|
|
&mut p,
|
|
item,
|
|
"origin",
|
|
TypeRef::Named(record),
|
|
ParameterDirection::In,
|
|
);
|
|
let destination = field(
|
|
&mut p,
|
|
item,
|
|
"destination",
|
|
TypeRef::Named(record),
|
|
ParameterDirection::Out,
|
|
);
|
|
let a = add(&mut p, Kind::Activity, "Request movement", None);
|
|
let b = add(&mut p, Kind::Activity, "Perform movement", None);
|
|
let exchange = p.relate(RelationKind::Interaction, "Movement invocation", a, b);
|
|
if let RelationBody::Interaction { items, .. } =
|
|
&mut p.relations.get_mut(&exchange).unwrap().body
|
|
{
|
|
items.push(item);
|
|
}
|
|
let scenario = add(&mut p, Kind::Scenario, "Movement conversation", None);
|
|
let call = message(
|
|
&mut p,
|
|
scenario,
|
|
exchange,
|
|
MessageKind::Call,
|
|
None,
|
|
"Call",
|
|
vec![MessageValue {
|
|
path: vec![origin],
|
|
field: leaf,
|
|
expression: "45.0".into(),
|
|
}],
|
|
);
|
|
let reply = message(
|
|
&mut p,
|
|
scenario,
|
|
exchange,
|
|
MessageKind::Reply,
|
|
Some(call),
|
|
"Reply",
|
|
vec![MessageValue {
|
|
path: vec![destination],
|
|
field: leaf,
|
|
expression: "46.0".into(),
|
|
}],
|
|
);
|
|
valid(&p);
|
|
Payload {
|
|
p,
|
|
item,
|
|
record,
|
|
leaf,
|
|
origin,
|
|
destination,
|
|
exchange,
|
|
call,
|
|
reply,
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn scalar_bounds_defaults_unicode_units_and_failed_batches_are_exact() {
|
|
let mut p = Project::empty();
|
|
let integer = add(&mut p, Kind::DataType, "Full precision integer", None);
|
|
body(
|
|
&mut p,
|
|
integer,
|
|
SharedBody::DataType {
|
|
definition: DataTypeDefinition::Integer {
|
|
minimum: Some(i64::MAX - 1),
|
|
maximum: Some(i64::MAX),
|
|
},
|
|
default: Some(DataValue::Integer(i64::MAX)),
|
|
unit: "count".into(),
|
|
},
|
|
);
|
|
let text = add(&mut p, Kind::DataType, "Two scalars", None);
|
|
body(
|
|
&mut p,
|
|
text,
|
|
SharedBody::DataType {
|
|
definition: DataTypeDefinition::String {
|
|
minimum_length: 2,
|
|
maximum_length: Some(2),
|
|
},
|
|
default: Some(DataValue::String("é🙂".into())),
|
|
unit: String::new(),
|
|
},
|
|
);
|
|
let real = add(&mut p, Kind::DataType, "Mass flow", None);
|
|
body(
|
|
&mut p,
|
|
real,
|
|
SharedBody::DataType {
|
|
definition: DataTypeDefinition::Real {
|
|
minimum: Some(0.0),
|
|
maximum: Some(25.0),
|
|
},
|
|
default: Some(DataValue::Real(1.0)),
|
|
unit: "kg/s".into(),
|
|
},
|
|
);
|
|
let item = add(&mut p, Kind::ExchangeItem, "Fuel", None);
|
|
body(
|
|
&mut p,
|
|
item,
|
|
SharedBody::ExchangeItem {
|
|
kind: ExchangeItemKind::Material,
|
|
mechanism: ExchangeMechanism::Flow,
|
|
supertype: None,
|
|
},
|
|
);
|
|
let amount = field(
|
|
&mut p,
|
|
item,
|
|
"amount",
|
|
TypeRef::Named(real),
|
|
ParameterDirection::Unspecified,
|
|
);
|
|
assert_eq!(effective_field_unit(&p, &p.elements[&amount]), Some("kg/s"));
|
|
assert_eq!(
|
|
effective_element_default(&p, &p.elements[&amount]),
|
|
Some(&DataValue::Real(1.0))
|
|
);
|
|
valid(&p);
|
|
assert!(
|
|
validate_data_value(
|
|
&p,
|
|
&TypeRef::Named(integer),
|
|
&DataValue::Integer(i64::MAX - 2)
|
|
)
|
|
.is_err()
|
|
);
|
|
assert!(validate_data_value(&p, &TypeRef::Named(real), &DataValue::Integer(1)).is_err());
|
|
assert!(validate_data_value(&p, &TypeRef::Real, &DataValue::Real(f64::INFINITY)).is_err());
|
|
assert!(
|
|
validate_data_value(&p, &TypeRef::Named(text), &DataValue::String("é".into())).is_err()
|
|
);
|
|
let mut session = Session::new(p.clone());
|
|
let invalid = edited(&p, integer, |s| {
|
|
if let SharedBody::DataType { default, .. } = s {
|
|
*default = Some(DataValue::Integer(i64::MIN));
|
|
}
|
|
});
|
|
assert!(
|
|
session
|
|
.execute(Command::Batch(vec![
|
|
Command::Rename(item, "Unsaved name".into()),
|
|
invalid
|
|
]))
|
|
.is_err()
|
|
);
|
|
assert_eq!(session.project(), &p);
|
|
assert_eq!(session.revision(), 0);
|
|
assert!(!session.can_undo());
|
|
let invalid = edited(&p, real, |s| {
|
|
if let SharedBody::DataType { definition, .. } = s {
|
|
*definition = DataTypeDefinition::Real {
|
|
minimum: Some(f64::NAN),
|
|
maximum: None,
|
|
};
|
|
}
|
|
});
|
|
assert!(session.execute(invalid).is_err());
|
|
let empty = edited(&p, amount, |s| {
|
|
if let SharedBody::DataField {
|
|
minimum, default, ..
|
|
} = s
|
|
{
|
|
*minimum = 0;
|
|
*default = Some(vec![]);
|
|
}
|
|
});
|
|
session.execute(empty).unwrap();
|
|
valid(session.project());
|
|
session.undo();
|
|
assert_eq!(session.project(), &p);
|
|
}
|
|
|
|
#[test]
|
|
fn enum_literal_edits_validate_type_and_field_defaults_in_one_candidate() {
|
|
let mut p = Project::empty();
|
|
let enumeration = add(&mut p, Kind::DataType, "Mode", None);
|
|
body(
|
|
&mut p,
|
|
enumeration,
|
|
SharedBody::DataType {
|
|
definition: DataTypeDefinition::Enumeration {
|
|
literals: vec!["Ready".into(), "Busy".into()],
|
|
},
|
|
default: Some(DataValue::Enumeration("Ready".into())),
|
|
unit: String::new(),
|
|
},
|
|
);
|
|
let item = add(&mut p, Kind::ExchangeItem, "Status", None);
|
|
let mode = field(
|
|
&mut p,
|
|
item,
|
|
"mode",
|
|
TypeRef::Named(enumeration),
|
|
ParameterDirection::Unspecified,
|
|
);
|
|
if let Some(SharedBody::DataField { default, .. }) =
|
|
p.elements.get_mut(&mode).unwrap().shared_mut()
|
|
{
|
|
*default = Some(vec![DataValue::Enumeration("Ready".into())]);
|
|
}
|
|
let mut session = Session::new(p.clone());
|
|
let change_type = edited(&p, enumeration, |s| {
|
|
if let SharedBody::DataType {
|
|
definition: DataTypeDefinition::Enumeration { literals },
|
|
default,
|
|
..
|
|
} = s
|
|
{
|
|
literals[0] = "Idle".into();
|
|
*default = Some(DataValue::Enumeration("Idle".into()));
|
|
}
|
|
});
|
|
assert!(session.execute(change_type.clone()).is_err());
|
|
assert_eq!(session.project(), &p);
|
|
let change_field = edited(&p, mode, |s| {
|
|
if let SharedBody::DataField { default, .. } = s {
|
|
*default = Some(vec![DataValue::Enumeration("Idle".into())]);
|
|
}
|
|
});
|
|
session
|
|
.execute(Command::Batch(vec![change_type, change_field]))
|
|
.unwrap();
|
|
valid(session.project());
|
|
session.undo();
|
|
assert_eq!(session.project(), &p);
|
|
}
|
|
|
|
#[test]
|
|
fn an_empty_enumeration_is_a_located_incomplete_draft() {
|
|
let mut p = Project::empty();
|
|
let enumeration = add(&mut p, Kind::DataType, "Pending values", None);
|
|
body(
|
|
&mut p,
|
|
enumeration,
|
|
SharedBody::DataType {
|
|
definition: DataTypeDefinition::Enumeration { literals: vec![] },
|
|
default: None,
|
|
unit: String::new(),
|
|
},
|
|
);
|
|
valid(&p);
|
|
assert!(
|
|
validation::validate(&p)
|
|
.iter()
|
|
.any(|issue| issue.code == "empty_enumeration"
|
|
&& issue.severity == Severity::Warning
|
|
&& issue.element == Some(enumeration)
|
|
&& issue.field.as_deref() == Some("literals"))
|
|
);
|
|
Session::try_new(p).unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn inherited_interfaces_and_item_specializations_satisfy_typed_port_contracts() {
|
|
let mut p = Project::empty();
|
|
let a = p
|
|
.add_element(Kind::Function, Layer::Sa, "Send", None)
|
|
.unwrap();
|
|
let b = p
|
|
.add_element(Kind::Function, Layer::Sa, "Receive", None)
|
|
.unwrap();
|
|
let ca = p
|
|
.add_element(Kind::System, Layer::Sa, "Client", None)
|
|
.unwrap();
|
|
let cb = p
|
|
.add_element(Kind::SystemActor, Layer::Sa, "Provider", None)
|
|
.unwrap();
|
|
p.relate(RelationKind::Allocation, "Client work", ca, a);
|
|
p.relate(RelationKind::Allocation, "Provider work", cb, b);
|
|
let item = p
|
|
.add_element(Kind::ExchangeItem, Layer::Sa, "Base item", None)
|
|
.unwrap();
|
|
let specialized = p
|
|
.add_element(Kind::ExchangeItem, Layer::Sa, "Specialized item", None)
|
|
.unwrap();
|
|
body(
|
|
&mut p,
|
|
specialized,
|
|
SharedBody::ExchangeItem {
|
|
kind: ExchangeItemKind::Information,
|
|
mechanism: ExchangeMechanism::Unspecified,
|
|
supertype: Some(item),
|
|
},
|
|
);
|
|
let fe = Id::new_v4();
|
|
let request = FunctionalExchangeRequest {
|
|
id: fe,
|
|
alias: "specialized_exchange".into(),
|
|
name: "Specialized exchange".into(),
|
|
description: String::new(),
|
|
source: a,
|
|
target: b,
|
|
source_port: PortChoice::Create,
|
|
target_port: PortChoice::Create,
|
|
items: vec![item],
|
|
};
|
|
p = execute_batch(&p, &plan_functional_exchange(&p, &request).unwrap()).unwrap();
|
|
let mut changed = p.relations[&fe].clone();
|
|
if let RelationBody::FunctionalExchange { items, .. } = &mut changed.body {
|
|
*items = vec![specialized];
|
|
}
|
|
p = execute_batch(&p, &[Command::EditRelation(fe, changed)]).unwrap();
|
|
let boundary = Id::new_v4();
|
|
let request = ComponentExchangeRequest {
|
|
functional_exchange: fe,
|
|
boundary: ComponentExchangeChoice::Create {
|
|
id: boundary,
|
|
alias: "service_boundary".into(),
|
|
name: "Service boundary".into(),
|
|
description: String::new(),
|
|
port_kind: ComponentPortKind::Standard,
|
|
oriented: false,
|
|
source_port: PortChoice::Create,
|
|
target_port: PortChoice::Create,
|
|
},
|
|
};
|
|
p = execute_batch(&p, &plan_component_exchange(&p, &request).unwrap()).unwrap();
|
|
let interface = p
|
|
.add_element(Kind::Interface, Layer::Sa, "Service", None)
|
|
.unwrap();
|
|
let extended = p
|
|
.add_element(Kind::Interface, Layer::Sa, "Extended service", None)
|
|
.unwrap();
|
|
body(
|
|
&mut p,
|
|
extended,
|
|
SharedBody::Interface {
|
|
supertype: Some(interface),
|
|
},
|
|
);
|
|
p.relate(
|
|
RelationKind::InterfaceItemAllocation,
|
|
"Service item",
|
|
interface,
|
|
item,
|
|
);
|
|
let (source, target) = p.relations[&boundary].body.endpoints();
|
|
p.relate(
|
|
RelationKind::InterfaceRequirement,
|
|
"Required service",
|
|
source,
|
|
interface,
|
|
);
|
|
let provider = p.relate(
|
|
RelationKind::InterfaceProvision,
|
|
"Provided service",
|
|
target,
|
|
extended,
|
|
);
|
|
valid(&p);
|
|
assert!(!code(
|
|
&p,
|
|
"unsatisfied_interface_requirement",
|
|
Severity::Warning
|
|
));
|
|
let unrelated = p
|
|
.add_element(Kind::Interface, Layer::Sa, "Unrelated service", None)
|
|
.unwrap();
|
|
p.relate(
|
|
RelationKind::InterfaceItemAllocation,
|
|
"Other item contract",
|
|
unrelated,
|
|
item,
|
|
);
|
|
p.relations
|
|
.get_mut(&provider)
|
|
.unwrap()
|
|
.body
|
|
.set_endpoints(target, unrelated);
|
|
valid(&p);
|
|
assert!(code(
|
|
&p,
|
|
"unsatisfied_interface_requirement",
|
|
Severity::Warning
|
|
));
|
|
}
|
|
|
|
#[test]
|
|
fn repeated_record_paths_enforce_call_reply_phase_and_survive_identity_changes() {
|
|
let Payload {
|
|
p,
|
|
item,
|
|
record,
|
|
leaf,
|
|
origin,
|
|
destination,
|
|
exchange,
|
|
call,
|
|
reply,
|
|
} = payload();
|
|
let paths = carried_field_paths(&p, &p.relations[&exchange]);
|
|
assert_eq!(paths.iter().filter(|f| f.field == leaf).count(), 2);
|
|
let mut session = Session::new(p.clone());
|
|
let wrong = edited(&p, call, |s| {
|
|
if let SharedBody::Occurrence {
|
|
body: OccurrenceBody::Exchange { values, .. },
|
|
..
|
|
} = s
|
|
{
|
|
values[0].path = vec![destination];
|
|
}
|
|
});
|
|
assert!(
|
|
session
|
|
.execute(wrong)
|
|
.unwrap_err()
|
|
.0
|
|
.contains("message_parameter_phase")
|
|
);
|
|
assert_eq!(session.project(), &p);
|
|
let new_origin = Id::new_v4();
|
|
let new_leaf = Id::new_v4();
|
|
session
|
|
.execute(Command::Batch(vec![
|
|
Command::Reidentify(origin, new_origin),
|
|
Command::Reidentify(leaf, new_leaf),
|
|
]))
|
|
.unwrap();
|
|
assert_eq!(values(session.project(), call)[0].path, vec![new_origin]);
|
|
assert_eq!(values(session.project(), call)[0].field, new_leaf);
|
|
assert_eq!(values(session.project(), reply)[0].field, new_leaf);
|
|
session.undo();
|
|
assert_eq!(session.project(), &p);
|
|
session.execute(Command::Delete(origin)).unwrap();
|
|
assert!(values(session.project(), call).is_empty());
|
|
assert_eq!(values(session.project(), reply).len(), 1);
|
|
assert!(session.project().elements.contains_key(&record));
|
|
assert!(session.project().elements.contains_key(&leaf));
|
|
session.undo();
|
|
assert_eq!(session.project(), &p);
|
|
let reference = edited(&p, origin, |s| {
|
|
if let SharedBody::DataField { storage, .. } = s {
|
|
*storage = FieldStorage::Reference;
|
|
}
|
|
});
|
|
assert!(
|
|
session
|
|
.execute(reference)
|
|
.unwrap_err()
|
|
.0
|
|
.contains("message_value_field")
|
|
);
|
|
let direction = edited(&p, origin, |s| {
|
|
if let SharedBody::DataField { direction, .. } = s {
|
|
*direction = ParameterDirection::Unspecified;
|
|
}
|
|
});
|
|
let generic = edited(&p, item, |s| {
|
|
if let SharedBody::ExchangeItem { mechanism, .. } = s {
|
|
*mechanism = ExchangeMechanism::Flow;
|
|
}
|
|
});
|
|
assert!(
|
|
session
|
|
.execute(Command::Batch(vec![direction, generic]))
|
|
.is_err()
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn ambiguous_legacy_annotations_warn_and_reference_fields_stop_payload_descent() {
|
|
let Payload {
|
|
mut p,
|
|
origin,
|
|
destination,
|
|
call,
|
|
reply,
|
|
leaf,
|
|
exchange,
|
|
..
|
|
} = payload();
|
|
for message in [call, reply] {
|
|
if let Some(SharedBody::Occurrence {
|
|
body: OccurrenceBody::Exchange { values, .. },
|
|
..
|
|
}) = p.elements.get_mut(&message).unwrap().shared_mut()
|
|
{
|
|
values[0].path.clear();
|
|
}
|
|
}
|
|
valid(&p);
|
|
assert!(code(&p, "message_value_ambiguous_path", Severity::Warning));
|
|
if let Some(SharedBody::DataField { storage, .. }) =
|
|
p.elements.get_mut(&origin).unwrap().shared_mut()
|
|
{
|
|
*storage = FieldStorage::Reference;
|
|
}
|
|
let paths = carried_field_paths(&p, &p.relations[&exchange]);
|
|
assert!(paths.iter().any(|f| f.field == origin && f.path.is_empty()));
|
|
assert_eq!(
|
|
paths
|
|
.iter()
|
|
.filter(|f| f.field == leaf)
|
|
.map(|f| &f.path)
|
|
.collect::<Vec<_>>(),
|
|
vec![&vec![destination]]
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn identified_allocations_keep_protocols_order_artifacts_and_inherited_identity() {
|
|
let mut p = Project::empty();
|
|
let item = add(&mut p, Kind::ExchangeItem, "Telemetry", None);
|
|
let other_item = add(&mut p, Kind::ExchangeItem, "Command", None);
|
|
let first = add(&mut p, Kind::Interface, "Primary", None);
|
|
let second = add(&mut p, Kind::Interface, "Secondary", None);
|
|
let derived = add(&mut p, Kind::Interface, "Specialized primary", None);
|
|
body(
|
|
&mut p,
|
|
derived,
|
|
SharedBody::Interface {
|
|
supertype: Some(first),
|
|
},
|
|
);
|
|
let a = p.relate(
|
|
RelationKind::InterfaceItemAllocation,
|
|
"Primary telemetry",
|
|
first,
|
|
item,
|
|
);
|
|
let b = p.relate(
|
|
RelationKind::InterfaceItemAllocation,
|
|
"Secondary telemetry",
|
|
second,
|
|
item,
|
|
);
|
|
if let RelationBody::InterfaceItemAllocation {
|
|
transmission,
|
|
acquisition,
|
|
..
|
|
} = &mut p.relations.get_mut(&a).unwrap().body
|
|
{
|
|
*transmission = TransmissionProtocol::Synchronous;
|
|
*acquisition = AcquisitionProtocol::Read;
|
|
}
|
|
if let RelationBody::InterfaceItemAllocation {
|
|
transmission,
|
|
order,
|
|
..
|
|
} = &mut p.relations.get_mut(&b).unwrap().body
|
|
{
|
|
*transmission = TransmissionProtocol::Broadcast;
|
|
*order = 4;
|
|
}
|
|
let local = p.relate(
|
|
RelationKind::InterfaceItemAllocation,
|
|
"Local command",
|
|
derived,
|
|
other_item,
|
|
);
|
|
assert_eq!(
|
|
effective_interface_allocations(&p, derived)
|
|
.iter()
|
|
.map(|r| r.id)
|
|
.collect::<Vec<_>>(),
|
|
vec![a, local]
|
|
);
|
|
assert!(interface_satisfies(&p, derived, first));
|
|
assert!(!interface_satisfies(&p, first, derived));
|
|
let artifact_id = Id::new_v4();
|
|
p.artifact_links.insert(
|
|
artifact_id,
|
|
ArtifactLink {
|
|
id: artifact_id,
|
|
alias: "allocation_spec".into(),
|
|
name: "Protocol specification".into(),
|
|
description: String::new(),
|
|
owner: a,
|
|
relation: ArtifactRelation::References,
|
|
uri: "https://example.org/protocol".into(),
|
|
revision: None,
|
|
fragment: None,
|
|
},
|
|
);
|
|
valid(&p);
|
|
let mut session = Session::new(p.clone());
|
|
let duplicate = Relation {
|
|
id: Id::new_v4(),
|
|
alias: "duplicate_allocation".into(),
|
|
name: "Duplicate inherited item".into(),
|
|
description: String::new(),
|
|
body: RelationBody::new(RelationKind::InterfaceItemAllocation, derived, item),
|
|
};
|
|
assert!(session.execute(Command::CreateRelation(duplicate)).is_err());
|
|
let impact = references::deletion_impact(&p, a);
|
|
assert!(impact.contains(&artifact_id));
|
|
assert!(!impact.contains(&item));
|
|
assert!(!impact.contains(&b));
|
|
session.execute(Command::Delete(a)).unwrap();
|
|
assert_eq!(
|
|
interface_items(session.project(), derived),
|
|
vec![other_item]
|
|
);
|
|
assert_eq!(session.project().relations[&b], p.relations[&b]);
|
|
assert!(session.project().elements.contains_key(&item));
|
|
session.undo();
|
|
assert_eq!(session.project(), &p);
|
|
let new_item = Id::new_v4();
|
|
session
|
|
.execute(Command::Reidentify(item, new_item))
|
|
.unwrap();
|
|
assert_eq!(session.project().relations[&a].target(), new_item);
|
|
assert_eq!(session.project().relations[&b].target(), new_item);
|
|
}
|
|
|
|
#[test]
|
|
fn specialization_preserves_fields_rejects_cycles_and_prunes_removed_inherited_paths() {
|
|
let Payload {
|
|
mut p,
|
|
item,
|
|
record,
|
|
leaf,
|
|
origin,
|
|
call,
|
|
reply,
|
|
..
|
|
} = payload();
|
|
let specialized = make_record(&mut p, "Refined coordinate", Some(record));
|
|
if let Some(SharedBody::DataField { type_ref, .. }) =
|
|
p.elements.get_mut(&origin).unwrap().shared_mut()
|
|
{
|
|
*type_ref = TypeRef::Named(specialized);
|
|
}
|
|
valid(&p);
|
|
assert_eq!(effective_fields(&p, specialized)[0].id, leaf);
|
|
assert_eq!(p.elements[&leaf].parent, Some(record));
|
|
let mut session = Session::new(p.clone());
|
|
let unbase = edited(&p, specialized, |s| {
|
|
if let SharedBody::DataType {
|
|
definition: DataTypeDefinition::Record { supertype },
|
|
..
|
|
} = s
|
|
{
|
|
*supertype = None;
|
|
}
|
|
});
|
|
let mut explicit = p.clone();
|
|
if let Command::EditElement(id, e) = &unbase {
|
|
explicit.elements.insert(*id, e.clone());
|
|
}
|
|
assert!(
|
|
session
|
|
.execute(Command::Replace(explicit))
|
|
.unwrap_err()
|
|
.0
|
|
.contains("message_value_field")
|
|
);
|
|
assert_eq!(session.project(), &p);
|
|
session.execute(unbase).unwrap();
|
|
assert!(values(session.project(), call).is_empty());
|
|
assert_eq!(values(session.project(), reply).len(), 1);
|
|
session.undo();
|
|
assert_eq!(session.project(), &p);
|
|
let cycle = edited(&p, record, |s| {
|
|
if let SharedBody::DataType {
|
|
definition: DataTypeDefinition::Record { supertype },
|
|
..
|
|
} = s
|
|
{
|
|
*supertype = Some(specialized);
|
|
}
|
|
});
|
|
assert!(
|
|
session
|
|
.execute(cycle)
|
|
.unwrap_err()
|
|
.0
|
|
.contains("data_inheritance_cycle")
|
|
);
|
|
let shadow = field(
|
|
&mut p,
|
|
specialized,
|
|
"latitude",
|
|
TypeRef::Real,
|
|
ParameterDirection::Unspecified,
|
|
);
|
|
assert!(code(&p, "inherited_field_shadow", Severity::Error));
|
|
p.elements.remove(&shadow);
|
|
let derived_item = add(&mut p, Kind::ExchangeItem, "Precise move", None);
|
|
body(
|
|
&mut p,
|
|
derived_item,
|
|
SharedBody::ExchangeItem {
|
|
kind: ExchangeItemKind::Information,
|
|
mechanism: ExchangeMechanism::Operation,
|
|
supertype: Some(item),
|
|
},
|
|
);
|
|
assert!(oa_core::item_satisfies(&p, derived_item, item));
|
|
assert!(!oa_core::item_satisfies(&p, item, derived_item));
|
|
let result = field(
|
|
&mut p,
|
|
item,
|
|
"result",
|
|
TypeRef::Boolean,
|
|
ParameterDirection::Return,
|
|
);
|
|
field(
|
|
&mut p,
|
|
derived_item,
|
|
"second result",
|
|
TypeRef::Boolean,
|
|
ParameterDirection::Return,
|
|
);
|
|
assert!(code(&p, "multiple_return_parameters", Severity::Error));
|
|
assert_eq!(p.elements[&result].parent, Some(item));
|
|
}
|
|
|
|
#[test]
|
|
fn removing_inheritance_prunes_legacy_annotations_only_when_every_reachable_path_disappears() {
|
|
let Payload {
|
|
mut p,
|
|
record,
|
|
origin,
|
|
destination,
|
|
call,
|
|
reply,
|
|
..
|
|
} = payload();
|
|
let derived = make_record(&mut p, "Inherited arguments", Some(record));
|
|
for id in [origin, destination] {
|
|
if let Some(SharedBody::DataField { type_ref, .. }) =
|
|
p.elements.get_mut(&id).unwrap().shared_mut()
|
|
{
|
|
*type_ref = TypeRef::Named(derived);
|
|
}
|
|
}
|
|
for id in [call, reply] {
|
|
if let Some(SharedBody::Occurrence {
|
|
body: OccurrenceBody::Exchange { values, .. },
|
|
..
|
|
}) = p.elements.get_mut(&id).unwrap().shared_mut()
|
|
{
|
|
values[0].path.clear();
|
|
}
|
|
}
|
|
valid(&p);
|
|
assert!(code(&p, "message_value_ambiguous_path", Severity::Warning));
|
|
let remove = edited(&p, derived, |s| {
|
|
if let SharedBody::DataType {
|
|
definition: DataTypeDefinition::Record { supertype },
|
|
..
|
|
} = s
|
|
{
|
|
*supertype = None;
|
|
}
|
|
});
|
|
let mut session = Session::new(p.clone());
|
|
session.execute(remove).unwrap();
|
|
assert!(values(session.project(), call).is_empty());
|
|
assert!(values(session.project(), reply).is_empty());
|
|
assert!(session.project().elements.contains_key(&record));
|
|
session.undo();
|
|
assert_eq!(session.project(), &p);
|
|
}
|
|
|
|
#[test]
|
|
fn recursive_value_types_warn_while_optional_reference_cycles_and_associations_are_distinct() {
|
|
let mut p = Project::empty();
|
|
let a = make_record(&mut p, "Node", None);
|
|
let b = make_record(&mut p, "Envelope", None);
|
|
let next = field(
|
|
&mut p,
|
|
a,
|
|
"next",
|
|
TypeRef::Named(a),
|
|
ParameterDirection::Unspecified,
|
|
);
|
|
field(
|
|
&mut p,
|
|
b,
|
|
"root",
|
|
TypeRef::Named(a),
|
|
ParameterDirection::Unspecified,
|
|
);
|
|
valid(&p);
|
|
assert!(code(&p, "record_no_finite_value", Severity::Warning));
|
|
if let Some(SharedBody::DataField { minimum, .. }) =
|
|
p.elements.get_mut(&next).unwrap().shared_mut()
|
|
{
|
|
*minimum = 0;
|
|
}
|
|
assert!(!code(&p, "record_no_finite_value", Severity::Warning));
|
|
if let Some(SharedBody::DataField {
|
|
minimum, storage, ..
|
|
}) = p.elements.get_mut(&next).unwrap().shared_mut()
|
|
{
|
|
*minimum = 1;
|
|
*storage = FieldStorage::Reference;
|
|
}
|
|
assert!(!code(&p, "record_no_finite_value", Severity::Warning));
|
|
let association = p.relate(RelationKind::DataAssociation, "Parent to children", a, a);
|
|
if let RelationBody::DataAssociation {
|
|
source_role,
|
|
target_role,
|
|
source_navigable,
|
|
target_navigable,
|
|
..
|
|
} = &mut p.relations.get_mut(&association).unwrap().body
|
|
{
|
|
*source_role = "parent".into();
|
|
*target_role = "children".into();
|
|
*source_navigable = true;
|
|
*target_navigable = true;
|
|
}
|
|
valid(&p);
|
|
let mut duplicate = p.relations[&association].clone();
|
|
duplicate.id = Id::new_v4();
|
|
duplicate.alias = "second_role_contract".into();
|
|
p.relations.insert(duplicate.id, duplicate);
|
|
valid(&p);
|
|
assert!(code(&p, "duplicate_association_roles", Severity::Warning));
|
|
let mut session = Session::new(p.clone());
|
|
let mut invalid = p.relations[&association].clone();
|
|
if let RelationBody::DataAssociation { target_role, .. } = &mut invalid.body {
|
|
*target_role = "parent".into();
|
|
}
|
|
assert!(
|
|
session
|
|
.execute(Command::EditRelation(association, invalid))
|
|
.is_err()
|
|
);
|
|
session.execute(Command::Delete(association)).unwrap();
|
|
assert!(session.project().elements.contains_key(&a));
|
|
assert!(session.project().elements.contains_key(&next));
|
|
}
|
|
|
|
#[test]
|
|
fn a_self_association_is_visible_with_neutral_connector_and_real_role_contracts() {
|
|
let mut p = Project::empty();
|
|
let record = make_record(&mut p, "Tree node", None);
|
|
let relation = p.relate(
|
|
RelationKind::DataAssociation,
|
|
"Parent-child reference",
|
|
record,
|
|
record,
|
|
);
|
|
if let RelationBody::DataAssociation {
|
|
source_role,
|
|
target_role,
|
|
source_maximum,
|
|
target_navigable,
|
|
..
|
|
} = &mut p.relations.get_mut(&relation).unwrap().body
|
|
{
|
|
*source_role = "parent".into();
|
|
*target_role = "children".into();
|
|
*source_maximum = Some(1);
|
|
*target_navigable = true;
|
|
}
|
|
let diagram = p.ensure_diagram(Layer::Oa);
|
|
p.place(diagram, record, Position { x: 100., y: 100. });
|
|
let item = add(
|
|
&mut p,
|
|
Kind::ExchangeItem,
|
|
"Nested allocation payload",
|
|
None,
|
|
);
|
|
let interface = add(&mut p, Kind::Interface, "Nested allocation owner", None);
|
|
let allocation = p.relate(
|
|
RelationKind::InterfaceItemAllocation,
|
|
"Nested contract row",
|
|
interface,
|
|
item,
|
|
);
|
|
p.place(diagram, item, Position { x: 600., y: 100. });
|
|
p.place(diagram, interface, Position { x: 600., y: 300. });
|
|
let view = oa_core::projection::project_view(&p, diagram);
|
|
assert!(!view.edges.iter().any(|e| e.id == allocation));
|
|
let projected = view.edges.iter().find(|e| e.id == relation).unwrap();
|
|
assert_eq!(projected.source, projected.target);
|
|
assert!(!projected.oriented);
|
|
let routed = oa_core::routing::route_diagram(&p, &p.diagrams[&diagram], &view);
|
|
let edge = &routed.edges[&relation];
|
|
assert!(edge.points.len() > 3);
|
|
assert_ne!(edge.points.first(), edge.points.last());
|
|
assert_eq!(edge.label.text, "Parent-child reference");
|
|
assert_eq!(
|
|
association_end_label(&p.relations[&relation], true).unwrap(),
|
|
"parent [0..1]"
|
|
);
|
|
assert_eq!(
|
|
association_end_label(&p.relations[&relation], false).unwrap(),
|
|
"children [0..*]"
|
|
);
|
|
let ends = oa_core::routing::association_end_geometry(&p.relations[&relation], edge);
|
|
assert_eq!(ends.len(), 2);
|
|
assert!(ends[0].source_end);
|
|
assert!(!ends[0].navigable);
|
|
assert!(ends[1].navigable);
|
|
assert_eq!(ends[0].tip, *edge.points.first().unwrap());
|
|
assert_eq!(ends[1].tip, *edge.points.last().unwrap());
|
|
assert_ne!(ends[0].label.center, ends[1].label.center);
|
|
for end in &ends {
|
|
let b = end.label.bounds;
|
|
assert!(
|
|
b.position.x >= routed.bounds.position.x && b.position.y >= routed.bounds.position.y
|
|
);
|
|
assert!(
|
|
b.position.x + b.size.width
|
|
<= routed.bounds.position.x + routed.bounds.size.width + 0.01
|
|
);
|
|
assert!(
|
|
b.position.y + b.size.height
|
|
<= routed.bounds.position.y + routed.bounds.size.height + 0.01
|
|
);
|
|
}
|
|
let mut changed = p.relations[&relation].clone();
|
|
if let RelationBody::DataAssociation {
|
|
source_navigable,
|
|
target_navigable,
|
|
..
|
|
} = &mut changed.body
|
|
{
|
|
*source_navigable = true;
|
|
*target_navigable = false;
|
|
}
|
|
let changed_ends = oa_core::routing::association_end_geometry(&changed, edge);
|
|
assert!(changed_ends[0].navigable);
|
|
assert!(!changed_ends[1].navigable);
|
|
assert_eq!(changed_ends[0].tip, ends[0].tip);
|
|
assert_eq!(changed_ends[1].tip, ends[1].tip);
|
|
for points in [
|
|
vec![Position { x: 0., y: 0. }, Position { x: 12., y: 0. }],
|
|
vec![
|
|
Position { x: 0., y: 0. },
|
|
Position { x: 18., y: 0. },
|
|
Position { x: 18., y: 5. },
|
|
Position { x: 0., y: 5. },
|
|
],
|
|
] {
|
|
let mut short = edge.clone();
|
|
short.points = points;
|
|
let labels = oa_core::routing::association_end_geometry(&changed, &short);
|
|
let a = labels[0].label.bounds;
|
|
let b = labels[1].label.bounds;
|
|
assert!(
|
|
a.position.x + a.size.width <= b.position.x
|
|
|| b.position.x + b.size.width <= a.position.x
|
|
|| a.position.y + a.size.height <= b.position.y
|
|
|| b.position.y + b.size.height <= a.position.y,
|
|
"End labels overlap on a short or self route: {labels:?}"
|
|
);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn empty_record_collections_are_supported_but_record_literals_and_reference_defaults_are_not() {
|
|
let mut p = Project::empty();
|
|
let record = make_record(&mut p, "Collection member", None);
|
|
let item = add(&mut p, Kind::ExchangeItem, "Collection", None);
|
|
let collection = field(
|
|
&mut p,
|
|
item,
|
|
"members",
|
|
TypeRef::Named(record),
|
|
ParameterDirection::Unspecified,
|
|
);
|
|
if let Some(SharedBody::DataField {
|
|
minimum,
|
|
maximum,
|
|
default,
|
|
..
|
|
}) = p.elements.get_mut(&collection).unwrap().shared_mut()
|
|
{
|
|
*minimum = 0;
|
|
*maximum = None;
|
|
*default = Some(vec![]);
|
|
}
|
|
valid(&p);
|
|
let mut session = Session::new(p.clone());
|
|
let reference = edited(&p, collection, |s| {
|
|
if let SharedBody::DataField { storage, .. } = s {
|
|
*storage = FieldStorage::Reference;
|
|
}
|
|
});
|
|
assert!(
|
|
session
|
|
.execute(reference)
|
|
.unwrap_err()
|
|
.0
|
|
.contains("reference_field_contract")
|
|
);
|
|
let literal = edited(&p, collection, |s| {
|
|
if let SharedBody::DataField { default, .. } = s {
|
|
*default = Some(vec![DataValue::String("{}".into())]);
|
|
}
|
|
});
|
|
assert!(session.execute(literal).is_err());
|
|
assert_eq!(session.project(), &p);
|
|
}
|
|
|
|
#[test]
|
|
fn exponential_payload_expansion_is_reported_and_recursive_finite_paths_remain_valid() {
|
|
let mut p = Project::empty();
|
|
let item = add(&mut p, Kind::ExchangeItem, "Bounded payload", None);
|
|
let mut owner = item;
|
|
for depth in 0..15 {
|
|
let next = make_record(&mut p, &format!("Level {depth}"), None);
|
|
field(
|
|
&mut p,
|
|
owner,
|
|
"left",
|
|
TypeRef::Named(next),
|
|
ParameterDirection::Unspecified,
|
|
);
|
|
field(
|
|
&mut p,
|
|
owner,
|
|
"right",
|
|
TypeRef::Named(next),
|
|
ParameterDirection::Unspecified,
|
|
);
|
|
owner = next;
|
|
}
|
|
let a = add(&mut p, Kind::Activity, "A", None);
|
|
let b = add(&mut p, Kind::Activity, "B", None);
|
|
let exchange = p.relate(RelationKind::Interaction, "Expanded exchange", a, b);
|
|
if let RelationBody::Interaction { items, .. } =
|
|
&mut p.relations.get_mut(&exchange).unwrap().body
|
|
{
|
|
items.push(item);
|
|
}
|
|
assert!(try_carried_field_paths(&p, &p.relations[&exchange]).is_err());
|
|
assert!(code(&p, "data_path_expansion_limit", Severity::Error));
|
|
let mut p = Project::empty();
|
|
let item = add(&mut p, Kind::ExchangeItem, "Recursive payload", None);
|
|
let record = make_record(&mut p, "Node", None);
|
|
let root = field(
|
|
&mut p,
|
|
item,
|
|
"root",
|
|
TypeRef::Named(record),
|
|
ParameterDirection::Unspecified,
|
|
);
|
|
let next = field(
|
|
&mut p,
|
|
record,
|
|
"next",
|
|
TypeRef::Named(record),
|
|
ParameterDirection::Unspecified,
|
|
);
|
|
if let Some(SharedBody::DataField { minimum, .. }) =
|
|
p.elements.get_mut(&next).unwrap().shared_mut()
|
|
{
|
|
*minimum = 0;
|
|
}
|
|
let a = add(&mut p, Kind::Activity, "A", None);
|
|
let b = add(&mut p, Kind::Activity, "B", None);
|
|
let exchange = p.relate(RelationKind::Interaction, "Recursive exchange", a, b);
|
|
if let RelationBody::Interaction { items, .. } =
|
|
&mut p.relations.get_mut(&exchange).unwrap().body
|
|
{
|
|
items.push(item);
|
|
}
|
|
valid(&p);
|
|
assert!(try_carried_field_paths(&p, &p.relations[&exchange]).is_ok());
|
|
assert!(carried_value_path(&p, &p.relations[&exchange], &[root, next, next], next).is_some());
|
|
assert_eq!(
|
|
resolve_legacy_field_path(&p, &p.relations[&exchange], next).unwrap(),
|
|
LegacyFieldPathResolution::Ambiguous
|
|
);
|
|
let scenario = add(&mut p, Kind::Scenario, "Recursive annotation", None);
|
|
message(
|
|
&mut p,
|
|
scenario,
|
|
exchange,
|
|
MessageKind::Asynchronous,
|
|
None,
|
|
"Legacy recursive value",
|
|
vec![MessageValue {
|
|
path: vec![],
|
|
field: next,
|
|
expression: "descriptive annotation".into(),
|
|
}],
|
|
);
|
|
valid(&p);
|
|
assert!(code(&p, "message_value_ambiguous_path", Severity::Warning));
|
|
}
|
|
|
|
#[test]
|
|
fn initial_transition_copies_qualified_paths_inheritance_allocations_and_associations() {
|
|
let Payload {
|
|
mut p,
|
|
item,
|
|
record,
|
|
origin,
|
|
leaf,
|
|
call,
|
|
..
|
|
} = payload();
|
|
let base = make_record(&mut p, "Reference base", None);
|
|
if let Some(SharedBody::DataType {
|
|
definition: DataTypeDefinition::Record { supertype },
|
|
..
|
|
}) = p.elements.get_mut(&record).unwrap().shared_mut()
|
|
{
|
|
*supertype = Some(base);
|
|
}
|
|
let interface = add(&mut p, Kind::Interface, "Movement service", None);
|
|
let allocation = p.relate(
|
|
RelationKind::InterfaceItemAllocation,
|
|
"Service operation",
|
|
interface,
|
|
item,
|
|
);
|
|
let association = p.relate(
|
|
RelationKind::DataAssociation,
|
|
"Coordinate relation",
|
|
record,
|
|
base,
|
|
);
|
|
let scenario = p.elements[&call].parent.unwrap();
|
|
let mut request =
|
|
TransitionRequest::new(TransitionDirection::OaToSa, vec![scenario, interface]);
|
|
request.scope = DependencyScope::Required;
|
|
let plan = plan_transition(&p, &request).unwrap();
|
|
assert!(plan.conflicts.is_empty(), "{:?}", plan.conflicts);
|
|
let candidate = apply_transition(&p, &plan).unwrap();
|
|
valid(&candidate);
|
|
let mapped = |id| plan.changes.iter().find(|c| c.source == id).unwrap().target;
|
|
assert_eq!(
|
|
values(&candidate, mapped(call))[0].path,
|
|
vec![mapped(origin)]
|
|
);
|
|
assert_eq!(values(&candidate, mapped(call))[0].field, mapped(leaf));
|
|
assert_eq!(
|
|
candidate.relations[&mapped(allocation)].source(),
|
|
mapped(interface)
|
|
);
|
|
assert_eq!(
|
|
candidate.relations[&mapped(association)].target(),
|
|
mapped(base)
|
|
);
|
|
assert_eq!(
|
|
supertype(&candidate.elements[&mapped(record)]),
|
|
Some(mapped(base))
|
|
);
|
|
assert_eq!(p.elements[&leaf].parent, Some(record));
|
|
}
|
|
|
|
#[test]
|
|
fn required_dictionary_closure_does_not_expand_through_incident_associations() {
|
|
let mut p = Project::empty();
|
|
let a = make_record(&mut p, "A", None);
|
|
let b = make_record(&mut p, "B", None);
|
|
let c = make_record(&mut p, "C", None);
|
|
let ab = p.relate(RelationKind::DataAssociation, "A to B", a, b);
|
|
let bc = p.relate(RelationKind::DataAssociation, "B to C", b, c);
|
|
for (sources, expected, omitted) in [
|
|
(vec![a], vec![a], vec![b, c, ab, bc]),
|
|
(vec![a, b], vec![a, b, ab], vec![c, bc]),
|
|
(vec![ab], vec![a, b, ab], vec![c, bc]),
|
|
] {
|
|
let mut request = TransitionRequest::new(TransitionDirection::OaToSa, sources);
|
|
request.scope = DependencyScope::Required;
|
|
let plan = plan_transition(&p, &request).unwrap();
|
|
assert!(plan.conflicts.is_empty(), "{:?}", plan.conflicts);
|
|
let mapped: std::collections::BTreeSet<_> =
|
|
plan.changes.iter().map(|change| change.source).collect();
|
|
assert_eq!(mapped, expected.into_iter().collect());
|
|
for id in omitted {
|
|
assert!(!mapped.contains(&id));
|
|
}
|
|
valid(&apply_transition(&p, &plan).unwrap());
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
#[ignore = "explicit inheritance scaling probe; run with --ignored --nocapture"]
|
|
fn inheritance_chain_validation_scaling_probe() {
|
|
for count in [250, 500, 1000] {
|
|
let mut p = Project::empty();
|
|
let mut base = None;
|
|
for index in 0..count {
|
|
base = Some(make_record(&mut p, &format!("Record {index}"), base));
|
|
}
|
|
let started = std::time::Instant::now();
|
|
valid(&p);
|
|
eprintln!(
|
|
"R6 inheritance validation {count} records: {:.3} ms",
|
|
started.elapsed().as_secs_f64() * 1000.0
|
|
);
|
|
}
|
|
}
|