1 // Copyright 2022 Google LLC
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 // http://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14
15 #![allow(clippy::unwrap_used)]
16
17 extern crate std;
18
19 use crate::legacy::{
20 data_elements::de_type::DataElementType, data_elements::*, serialize::*, PacketFlavorEnum,
21 };
22
23 mod error_conditions;
24 mod happy_path;
25 pub(in crate::legacy) mod helpers;
26
serialize<F: PacketFlavor, D: SerializeDataElement<F>>( de: &D, ) -> SerializedDataElement27 pub(crate) fn serialize<F: PacketFlavor, D: SerializeDataElement<F>>(
28 de: &D,
29 ) -> SerializedDataElement {
30 serialize_de(de, NP_MAX_ADV_CONTENT_LEN).unwrap()
31 }
32
supports_flavor(t: DataElementType, flavor: PacketFlavorEnum) -> bool33 pub(in crate::legacy) fn supports_flavor(t: DataElementType, flavor: PacketFlavorEnum) -> bool {
34 match t {
35 DataElementType::Actions => match flavor {
36 PacketFlavorEnum::Plaintext => true,
37 PacketFlavorEnum::Ciphertext => true,
38 },
39 DataElementType::TxPower => match flavor {
40 PacketFlavorEnum::Plaintext => true,
41 PacketFlavorEnum::Ciphertext => true,
42 },
43 }
44 }
45
46 mod coverage_gaming {
47 use crate::credential::v0::V0BroadcastCredential;
48 use crate::legacy::serialize::{
49 AddDataElementError, AdvBuilder, LdtEncodeError, LdtEncoder, UnencryptedEncodeError,
50 UnencryptedEncoder,
51 };
52 use alloc::format;
53 use crypto_provider_default::CryptoProviderImpl;
54 use ldt_np_adv::{V0IdentityToken, V0Salt};
55
56 #[test]
unencrypted_encoder()57 fn unencrypted_encoder() {
58 let _ = format!("{:?}", UnencryptedEncoder);
59 }
60
61 #[test]
unencrypted_encoder_error()62 fn unencrypted_encoder_error() {
63 let _ = format!("{:?}", UnencryptedEncodeError::InvalidLength);
64 }
65
66 #[test]
ldt_encoder_display()67 fn ldt_encoder_display() {
68 let identity_token = V0IdentityToken::from([0x33; 14]);
69 let salt = V0Salt::from([0x01, 0x02]);
70 let key_seed = [0xFE; 32];
71 let broadcast_cred = V0BroadcastCredential::new(key_seed, identity_token);
72 let ldt_encoder = LdtEncoder::<CryptoProviderImpl>::new(salt, &broadcast_cred);
73
74 // doesn't leak crypto material
75 assert_eq!("LdtEncoder { salt: V0Salt { bytes: [1, 2] } }", format!("{:?}", ldt_encoder));
76 }
77
78 #[test]
ldt_encoder_error()79 fn ldt_encoder_error() {
80 // debug, clone
81 let _ = format!("{:?}", LdtEncodeError::InvalidLength.clone());
82 }
83
84 #[test]
add_data_element_error()85 fn add_data_element_error() {
86 // debug
87 let _ = format!("{:?}", AddDataElementError::InsufficientAdvSpace);
88 }
89
90 #[test]
adv_builder()91 fn adv_builder() {
92 // debug
93 let _ = format!("{:?}", AdvBuilder::new(UnencryptedEncoder));
94 }
95 }
96