502 lines
20 KiB
Rust
502 lines
20 KiB
Rust
//! Generated Kaptan-dialect message translation.
|
|
|
|
use kaptan_config::{
|
|
ApplyPolicy, ConfigState, ConfigValue, FieldDescriptor, FieldId, Generation, ValidationRule,
|
|
ValueKind,
|
|
};
|
|
use kaptan_log::KaptanError;
|
|
use kaptan_mavlink::message::Message;
|
|
use kaptan_mavlink::message::kaptan::{
|
|
KAPTAN_CONFIG_DESCRIPTOR_DATA, KAPTAN_CONFIG_INFO_DATA, KAPTAN_CONFIG_RESULT_DATA,
|
|
KAPTAN_CONFIG_VALUE_DATA, KaptanConfigError, KaptanConfigOperation, KaptanConfigPolicy,
|
|
KaptanConfigResult, KaptanConfigState, KaptanConfigValueKind, KaptanConfigValueSource,
|
|
MavMessage,
|
|
};
|
|
|
|
use crate::{
|
|
ConfigCommand, ConfigReply, Operation, ProtocolError, ResultKind, Target, ValueSource,
|
|
service::{ConfigInfo, ValueResponse},
|
|
};
|
|
|
|
/// Rejects a generated message that is not a Kaptan configuration command.
|
|
#[derive(Clone, Copy, Debug, Eq, PartialEq, KaptanError)]
|
|
pub enum DecodeError {
|
|
/// The message belongs to a response, telemetry, or another service.
|
|
UnsupportedMessage,
|
|
/// A wire field identity used a reserved sentinel.
|
|
InvalidFieldId,
|
|
/// The message used an unknown value-source discriminator.
|
|
InvalidValueSource,
|
|
/// A boolean setter used a representation other than zero or one.
|
|
InvalidBoolean,
|
|
/// A configuration request used a broadcast/zero target endpoint.
|
|
InvalidTarget,
|
|
}
|
|
|
|
/// Converts one generated custom request into a transport-neutral command.
|
|
///
|
|
/// This only decodes a validated MAVLink payload. An authenticated ingress must
|
|
/// still wrap the result in [`crate::Authorized`] before dispatch.
|
|
pub fn decode_command(message: &MavMessage) -> Result<ConfigCommand, DecodeError> {
|
|
if matches!(message.target_system_id(), Some(0))
|
|
|| matches!(message.target_component_id(), Some(0))
|
|
{
|
|
return Err(DecodeError::InvalidTarget);
|
|
}
|
|
match message {
|
|
MavMessage::KAPTAN_CONFIG_INFO_REQUEST(data) => Ok(ConfigCommand::InfoRequest {
|
|
request_id: data.request_id,
|
|
target: Target::new(data.target_system, data.target_component),
|
|
}),
|
|
MavMessage::KAPTAN_CONFIG_DESCRIPTOR_REQUEST(data) => {
|
|
Ok(ConfigCommand::DescriptorRequest {
|
|
request_id: data.request_id,
|
|
first: data.first,
|
|
count: data.count,
|
|
target: Target::new(data.target_system, data.target_component),
|
|
})
|
|
}
|
|
MavMessage::KAPTAN_CONFIG_VALUE_REQUEST(data) => Ok(ConfigCommand::ValueRequest {
|
|
request_id: data.request_id,
|
|
session_id: data.session_id,
|
|
field: field_id(data.field_id)?,
|
|
source: value_source(data.source)?,
|
|
target: Target::new(data.target_system, data.target_component),
|
|
}),
|
|
MavMessage::KAPTAN_CONFIG_IMPORT_BEGIN(data) => Ok(ConfigCommand::ImportBegin {
|
|
request_id: data.request_id,
|
|
session_id: data.session_id,
|
|
expected_revision: data.expected_revision,
|
|
length: data.length,
|
|
schema_id: data.schema_id,
|
|
crc32c: data.crc32c,
|
|
target: Target::new(data.target_system, data.target_component),
|
|
}),
|
|
MavMessage::KAPTAN_CONFIG_IMPORT_CHUNK(data) => Ok(ConfigCommand::ImportChunk {
|
|
request_id: data.request_id,
|
|
session_id: data.session_id,
|
|
transfer_id: data.transfer_id,
|
|
offset: data.offset,
|
|
length: data.length,
|
|
data: data.data,
|
|
target: Target::new(data.target_system, data.target_component),
|
|
}),
|
|
MavMessage::KAPTAN_CONFIG_IMPORT_FINISH(data) => Ok(ConfigCommand::ImportFinish {
|
|
request_id: data.request_id,
|
|
session_id: data.session_id,
|
|
transfer_id: data.transfer_id,
|
|
expected_revision: data.expected_revision,
|
|
target: Target::new(data.target_system, data.target_component),
|
|
}),
|
|
MavMessage::KAPTAN_CONFIG_BEGIN(data) => Ok(ConfigCommand::Begin {
|
|
request_id: data.request_id,
|
|
expected_generation: data.expected_generation,
|
|
target: Target::new(data.target_system, data.target_component),
|
|
}),
|
|
MavMessage::KAPTAN_CONFIG_SET_F32(data) => Ok(ConfigCommand::Set {
|
|
request_id: data.request_id,
|
|
session_id: data.session_id,
|
|
expected_revision: data.expected_revision,
|
|
field: field_id(data.field_id)?,
|
|
value: ConfigValue::F32(data.value),
|
|
target: Target::new(data.target_system, data.target_component),
|
|
}),
|
|
MavMessage::KAPTAN_CONFIG_SET_BOOL(data) => Ok(ConfigCommand::Set {
|
|
request_id: data.request_id,
|
|
session_id: data.session_id,
|
|
expected_revision: data.expected_revision,
|
|
field: field_id(data.field_id)?,
|
|
value: ConfigValue::Bool(boolean(data.value)?),
|
|
target: Target::new(data.target_system, data.target_component),
|
|
}),
|
|
MavMessage::KAPTAN_CONFIG_SET_I32(data) => Ok(ConfigCommand::Set {
|
|
request_id: data.request_id,
|
|
session_id: data.session_id,
|
|
expected_revision: data.expected_revision,
|
|
field: field_id(data.field_id)?,
|
|
value: ConfigValue::I32(data.value),
|
|
target: Target::new(data.target_system, data.target_component),
|
|
}),
|
|
MavMessage::KAPTAN_CONFIG_SET_U32(data) => Ok(ConfigCommand::Set {
|
|
request_id: data.request_id,
|
|
session_id: data.session_id,
|
|
expected_revision: data.expected_revision,
|
|
field: field_id(data.field_id)?,
|
|
value: ConfigValue::U32(data.value),
|
|
target: Target::new(data.target_system, data.target_component),
|
|
}),
|
|
MavMessage::KAPTAN_CONFIG_SET_U64(data) => Ok(ConfigCommand::Set {
|
|
request_id: data.request_id,
|
|
session_id: data.session_id,
|
|
expected_revision: data.expected_revision,
|
|
field: field_id(data.field_id)?,
|
|
value: ConfigValue::U64(data.value),
|
|
target: Target::new(data.target_system, data.target_component),
|
|
}),
|
|
MavMessage::KAPTAN_CONFIG_SET_F64(data) => Ok(ConfigCommand::Set {
|
|
request_id: data.request_id,
|
|
session_id: data.session_id,
|
|
expected_revision: data.expected_revision,
|
|
field: field_id(data.field_id)?,
|
|
value: ConfigValue::F64(data.value),
|
|
target: Target::new(data.target_system, data.target_component),
|
|
}),
|
|
MavMessage::KAPTAN_CONFIG_VALIDATE(data) => Ok(ConfigCommand::Validate {
|
|
request_id: data.request_id,
|
|
session_id: data.session_id,
|
|
expected_revision: data.expected_revision,
|
|
target: Target::new(data.target_system, data.target_component),
|
|
}),
|
|
MavMessage::KAPTAN_CONFIG_COMMIT(data) => Ok(ConfigCommand::Commit {
|
|
request_id: data.request_id,
|
|
session_id: data.session_id,
|
|
expected_generation: data.expected_generation,
|
|
expected_revision: data.expected_revision,
|
|
target: Target::new(data.target_system, data.target_component),
|
|
}),
|
|
MavMessage::KAPTAN_CONFIG_ABORT(data) => Ok(ConfigCommand::Abort {
|
|
request_id: data.request_id,
|
|
session_id: data.session_id,
|
|
target: Target::new(data.target_system, data.target_component),
|
|
}),
|
|
_ => Err(DecodeError::UnsupportedMessage),
|
|
}
|
|
}
|
|
|
|
const fn field_id(value: u16) -> Result<FieldId, DecodeError> {
|
|
match FieldId::try_new(value) {
|
|
Some(value) => Ok(value),
|
|
None => Err(DecodeError::InvalidFieldId),
|
|
}
|
|
}
|
|
|
|
const fn value_source(value: KaptanConfigValueSource) -> Result<ValueSource, DecodeError> {
|
|
match value {
|
|
KaptanConfigValueSource::KAPTAN_CONFIG_VALUE_SOURCE_ACTIVE => Ok(ValueSource::Active),
|
|
KaptanConfigValueSource::KAPTAN_CONFIG_VALUE_SOURCE_COMMITTED => Ok(ValueSource::Committed),
|
|
KaptanConfigValueSource::KAPTAN_CONFIG_VALUE_SOURCE_TRANSACTION => {
|
|
Ok(ValueSource::Transaction)
|
|
}
|
|
}
|
|
}
|
|
|
|
const fn boolean(value: u8) -> Result<bool, DecodeError> {
|
|
match value {
|
|
0 => Ok(false),
|
|
1 => Ok(true),
|
|
_ => Err(DecodeError::InvalidBoolean),
|
|
}
|
|
}
|
|
|
|
/// Encodes one authoritative service completion.
|
|
pub fn encode_result(reply: ConfigReply) -> KAPTAN_CONFIG_RESULT_DATA {
|
|
KAPTAN_CONFIG_RESULT_DATA {
|
|
generation: reply.generation,
|
|
request_id: reply.request_id,
|
|
session_id: reply.session_id,
|
|
transfer_id: reply.transfer_id,
|
|
revision: reply.revision,
|
|
primary_field: reply.primary_field(),
|
|
related_field: reply.related_field(),
|
|
validation_rule: reply.validation_rule(),
|
|
operation: operation(reply.operation),
|
|
result: result(reply.result),
|
|
error: error(reply.error),
|
|
config_state: state(reply.state),
|
|
}
|
|
}
|
|
|
|
/// Encodes configuration protocol/schema status for a Kaptan control station.
|
|
pub fn encode_info(info: ConfigInfo) -> KAPTAN_CONFIG_INFO_DATA {
|
|
KAPTAN_CONFIG_INFO_DATA {
|
|
active_generation: info.active_generation.map_or(0, Generation::get),
|
|
committed_generation: info.committed_generation.map_or(0, Generation::get),
|
|
request_id: info.request_id,
|
|
schema_id: info.schema_id,
|
|
profile_format: info.profile_format,
|
|
field_count: info.field_count,
|
|
protocol_major: 1,
|
|
protocol_minor: 0,
|
|
config_state: state(info.state),
|
|
capability_flags: info.capability_flags,
|
|
}
|
|
}
|
|
|
|
/// Encodes self-describing metadata for one schema field.
|
|
pub fn encode_descriptor(
|
|
request_id: u32,
|
|
descriptor_index: u16,
|
|
descriptor: FieldDescriptor,
|
|
) -> KAPTAN_CONFIG_DESCRIPTOR_DATA {
|
|
KAPTAN_CONFIG_DESCRIPTOR_DATA {
|
|
minimum_bits: descriptor.minimum.map_or(0, ConfigValue::raw_bits),
|
|
maximum_bits: descriptor.maximum.map_or(0, ConfigValue::raw_bits),
|
|
default_bits: descriptor.default.raw_bits(),
|
|
request_id,
|
|
descriptor_index,
|
|
field_id: descriptor.id.get(),
|
|
display_key: descriptor.display_key.into(),
|
|
unit: descriptor.unit.into(),
|
|
value_kind: value_kind(descriptor.kind),
|
|
apply_policy: policy(descriptor.apply_policy),
|
|
flags: 0,
|
|
}
|
|
}
|
|
|
|
/// Encodes a typed scalar read response for the Kaptan control station.
|
|
pub fn encode_value(value: ValueResponse) -> KAPTAN_CONFIG_VALUE_DATA {
|
|
KAPTAN_CONFIG_VALUE_DATA {
|
|
value_bits: value.value.raw_bits(),
|
|
request_id: value.request_id,
|
|
session_id: value.session_id,
|
|
revision: value.revision,
|
|
field_id: value.field.get(),
|
|
value_kind: value_kind(value.value.kind()),
|
|
}
|
|
}
|
|
|
|
const fn value_kind(kind: ValueKind) -> KaptanConfigValueKind {
|
|
match kind {
|
|
ValueKind::Bool => KaptanConfigValueKind::KAPTAN_CONFIG_VALUE_KIND_BOOL,
|
|
ValueKind::I32 => KaptanConfigValueKind::KAPTAN_CONFIG_VALUE_KIND_I32,
|
|
ValueKind::U32 => KaptanConfigValueKind::KAPTAN_CONFIG_VALUE_KIND_U32,
|
|
ValueKind::U64 => KaptanConfigValueKind::KAPTAN_CONFIG_VALUE_KIND_U64,
|
|
ValueKind::F32 => KaptanConfigValueKind::KAPTAN_CONFIG_VALUE_KIND_F32,
|
|
ValueKind::F64 => KaptanConfigValueKind::KAPTAN_CONFIG_VALUE_KIND_F64,
|
|
}
|
|
}
|
|
|
|
const fn policy(policy: ApplyPolicy) -> KaptanConfigPolicy {
|
|
match policy {
|
|
ApplyPolicy::Live => KaptanConfigPolicy::KAPTAN_CONFIG_POLICY_LIVE,
|
|
ApplyPolicy::DisarmedReset => KaptanConfigPolicy::KAPTAN_CONFIG_POLICY_DISARMED_RESET,
|
|
ApplyPolicy::RestartRequired => KaptanConfigPolicy::KAPTAN_CONFIG_POLICY_RESTART_REQUIRED,
|
|
}
|
|
}
|
|
|
|
const fn operation(operation: Operation) -> KaptanConfigOperation {
|
|
match operation {
|
|
Operation::Query => KaptanConfigOperation::KAPTAN_CONFIG_OPERATION_QUERY,
|
|
Operation::Begin => KaptanConfigOperation::KAPTAN_CONFIG_OPERATION_BEGIN,
|
|
Operation::Set => KaptanConfigOperation::KAPTAN_CONFIG_OPERATION_SET,
|
|
Operation::Validate => KaptanConfigOperation::KAPTAN_CONFIG_OPERATION_VALIDATE,
|
|
Operation::Commit => KaptanConfigOperation::KAPTAN_CONFIG_OPERATION_COMMIT,
|
|
Operation::Abort => KaptanConfigOperation::KAPTAN_CONFIG_OPERATION_ABORT,
|
|
Operation::Import => KaptanConfigOperation::KAPTAN_CONFIG_OPERATION_IMPORT,
|
|
}
|
|
}
|
|
|
|
const fn result(result: ResultKind) -> KaptanConfigResult {
|
|
match result {
|
|
ResultKind::Accepted => KaptanConfigResult::KAPTAN_CONFIG_RESULT_ACCEPTED,
|
|
ResultKind::CommittedRestartRequired => {
|
|
KaptanConfigResult::KAPTAN_CONFIG_RESULT_COMMITTED_RESTART_REQUIRED
|
|
}
|
|
ResultKind::Rejected => KaptanConfigResult::KAPTAN_CONFIG_RESULT_REJECTED,
|
|
}
|
|
}
|
|
|
|
const fn state(state: ConfigState) -> KaptanConfigState {
|
|
match state {
|
|
ConfigState::Active => KaptanConfigState::KAPTAN_CONFIG_STATE_ACTIVE,
|
|
ConfigState::Editing => KaptanConfigState::KAPTAN_CONFIG_STATE_EDITING,
|
|
ConfigState::RestartRequired => KaptanConfigState::KAPTAN_CONFIG_STATE_RESTART_REQUIRED,
|
|
}
|
|
}
|
|
|
|
const fn error(error: Option<ProtocolError>) -> KaptanConfigError {
|
|
match error {
|
|
None => KaptanConfigError::KAPTAN_CONFIG_ERROR_NONE,
|
|
Some(ProtocolError::BadTarget) => KaptanConfigError::KAPTAN_CONFIG_ERROR_BAD_TARGET,
|
|
Some(ProtocolError::AuthorizationDenied) => {
|
|
KaptanConfigError::KAPTAN_CONFIG_ERROR_AUTHORIZATION_DENIED
|
|
}
|
|
Some(ProtocolError::GenerationConflict) => {
|
|
KaptanConfigError::KAPTAN_CONFIG_ERROR_GENERATION_CONFLICT
|
|
}
|
|
Some(ProtocolError::SessionBusy) => KaptanConfigError::KAPTAN_CONFIG_ERROR_SESSION_BUSY,
|
|
Some(ProtocolError::InvalidSession) => {
|
|
KaptanConfigError::KAPTAN_CONFIG_ERROR_INVALID_SESSION
|
|
}
|
|
Some(ProtocolError::RequestConflict) => {
|
|
KaptanConfigError::KAPTAN_CONFIG_ERROR_REQUEST_CONFLICT
|
|
}
|
|
Some(ProtocolError::StaleRevision) => KaptanConfigError::KAPTAN_CONFIG_ERROR_STALE_REVISION,
|
|
Some(ProtocolError::BadState) => KaptanConfigError::KAPTAN_CONFIG_ERROR_BAD_STATE,
|
|
Some(ProtocolError::UnknownField(_)) => {
|
|
KaptanConfigError::KAPTAN_CONFIG_ERROR_UNKNOWN_FIELD
|
|
}
|
|
Some(ProtocolError::TypeMismatch(_)) => {
|
|
KaptanConfigError::KAPTAN_CONFIG_ERROR_TYPE_MISMATCH
|
|
}
|
|
Some(ProtocolError::Violation(violation)) => match violation.rule() {
|
|
ValidationRule::NonFinite => KaptanConfigError::KAPTAN_CONFIG_ERROR_NON_FINITE,
|
|
ValidationRule::BelowMinimum | ValidationRule::Zero => {
|
|
KaptanConfigError::KAPTAN_CONFIG_ERROR_BELOW_MINIMUM
|
|
}
|
|
ValidationRule::AboveMaximum => KaptanConfigError::KAPTAN_CONFIG_ERROR_ABOVE_MAXIMUM,
|
|
ValidationRule::Inconsistent => KaptanConfigError::KAPTAN_CONFIG_ERROR_CROSS_FIELD,
|
|
ValidationRule::UnsupportedCapability => {
|
|
KaptanConfigError::KAPTAN_CONFIG_ERROR_UNSUPPORTED_CAPABILITY
|
|
}
|
|
ValidationRule::UnsupportedFormat => {
|
|
KaptanConfigError::KAPTAN_CONFIG_ERROR_UNSUPPORTED_FORMAT
|
|
}
|
|
},
|
|
Some(ProtocolError::StorageFailure) => {
|
|
KaptanConfigError::KAPTAN_CONFIG_ERROR_STORAGE_FAILURE
|
|
}
|
|
Some(ProtocolError::CborMalformed) => KaptanConfigError::KAPTAN_CONFIG_ERROR_CBOR_MALFORMED,
|
|
Some(ProtocolError::CborTooLarge) => KaptanConfigError::KAPTAN_CONFIG_ERROR_CBOR_TOO_LARGE,
|
|
Some(ProtocolError::BlobCrc) => KaptanConfigError::KAPTAN_CONFIG_ERROR_BLOB_CRC,
|
|
Some(ProtocolError::SchemaMismatch) => {
|
|
KaptanConfigError::KAPTAN_CONFIG_ERROR_SCHEMA_MISMATCH
|
|
}
|
|
Some(ProtocolError::ImportUnavailable) => {
|
|
KaptanConfigError::KAPTAN_CONFIG_ERROR_IMPORT_UNAVAILABLE
|
|
}
|
|
Some(ProtocolError::Internal) => KaptanConfigError::KAPTAN_CONFIG_ERROR_INTERNAL,
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use kaptan_config::{ConfigState, ConfigViolation, ValidationRule};
|
|
use kaptan_mavlink::message::kaptan::{
|
|
KAPTAN_CONFIG_INFO_REQUEST_DATA, KAPTAN_CONFIG_SET_F32_DATA, MavMessage,
|
|
};
|
|
|
|
use super::*;
|
|
use crate::CAPABILITY_CBOR_IMPORT;
|
|
|
|
#[test]
|
|
fn generated_set_message_preserves_typed_value_and_identifiers() {
|
|
let message = MavMessage::KAPTAN_CONFIG_SET_F32(KAPTAN_CONFIG_SET_F32_DATA {
|
|
request_id: 7,
|
|
session_id: 8,
|
|
expected_revision: 9,
|
|
field_id: 10,
|
|
value: 1.5,
|
|
target_system: 1,
|
|
target_component: 2,
|
|
});
|
|
assert_eq!(
|
|
decode_command(&message),
|
|
Ok(ConfigCommand::Set {
|
|
request_id: 7,
|
|
session_id: 8,
|
|
expected_revision: 9,
|
|
field: FieldId::new(10),
|
|
value: ConfigValue::F32(1.5),
|
|
target: Target::new(1, 2),
|
|
})
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn generated_info_request_is_correlated_and_exactly_targeted() {
|
|
let message = MavMessage::KAPTAN_CONFIG_INFO_REQUEST(KAPTAN_CONFIG_INFO_REQUEST_DATA {
|
|
request_id: 31,
|
|
target_system: 1,
|
|
target_component: 2,
|
|
});
|
|
assert_eq!(
|
|
decode_command(&message),
|
|
Ok(ConfigCommand::InfoRequest {
|
|
request_id: 31,
|
|
target: Target::new(1, 2),
|
|
})
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn generated_config_requests_reject_broadcast_targets() {
|
|
let zero_system = MavMessage::KAPTAN_CONFIG_SET_F32(KAPTAN_CONFIG_SET_F32_DATA {
|
|
request_id: 7,
|
|
session_id: 8,
|
|
expected_revision: 9,
|
|
field_id: 10,
|
|
value: 1.5,
|
|
target_system: 0,
|
|
target_component: 2,
|
|
});
|
|
let zero_component = MavMessage::KAPTAN_CONFIG_SET_F32(KAPTAN_CONFIG_SET_F32_DATA {
|
|
request_id: 7,
|
|
session_id: 8,
|
|
expected_revision: 9,
|
|
field_id: 10,
|
|
value: 1.5,
|
|
target_system: 1,
|
|
target_component: 0,
|
|
});
|
|
assert_eq!(
|
|
decode_command(&zero_system),
|
|
Err(DecodeError::InvalidTarget)
|
|
);
|
|
assert_eq!(
|
|
decode_command(&zero_component),
|
|
Err(DecodeError::InvalidTarget)
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn result_encodes_exact_validation_identity() {
|
|
let reply = ConfigReply {
|
|
request_id: 1,
|
|
session_id: 2,
|
|
transfer_id: 0,
|
|
revision: 3,
|
|
generation: 4,
|
|
operation: Operation::Set,
|
|
result: ResultKind::Rejected,
|
|
error: Some(ProtocolError::Violation(ConfigViolation::field(
|
|
FieldId::new(11),
|
|
ValidationRule::NonFinite,
|
|
))),
|
|
state: ConfigState::Editing,
|
|
};
|
|
let encoded = encode_result(reply);
|
|
assert_eq!(encoded.primary_field, 11);
|
|
assert_eq!(encoded.validation_rule, ValidationRule::NonFinite.code());
|
|
assert_eq!(
|
|
encoded.error,
|
|
KaptanConfigError::KAPTAN_CONFIG_ERROR_NON_FINITE
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn unavailable_import_has_its_own_structured_error_code() {
|
|
let reply = ConfigReply {
|
|
request_id: 1,
|
|
session_id: 0,
|
|
transfer_id: 0,
|
|
revision: 0,
|
|
generation: 0,
|
|
operation: Operation::Import,
|
|
result: ResultKind::Rejected,
|
|
error: Some(ProtocolError::ImportUnavailable),
|
|
state: ConfigState::Active,
|
|
};
|
|
assert_eq!(
|
|
encode_result(reply).error,
|
|
KaptanConfigError::KAPTAN_CONFIG_ERROR_IMPORT_UNAVAILABLE
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn info_preserves_service_capabilities() {
|
|
let info = encode_info(ConfigInfo {
|
|
request_id: 7,
|
|
active_generation: None,
|
|
committed_generation: None,
|
|
schema_id: [0; 16],
|
|
profile_format: 1,
|
|
field_count: 23,
|
|
state: ConfigState::Active,
|
|
capability_flags: CAPABILITY_CBOR_IMPORT,
|
|
});
|
|
assert_eq!(info.request_id, 7);
|
|
assert_eq!(info.capability_flags, CAPABILITY_CBOR_IMPORT);
|
|
}
|
|
}
|