1use crate::golem_rpc_0_2_x::types::{NamedWitTypeNode, ResourceId};
2use crate::{NodeIndex, ResourceMode, Uri, WitNode, WitType, WitTypeNode, WitValue};
3use bincode::de::{BorrowDecoder, Decoder};
4use bincode::enc::Encoder;
5use bincode::error::{AllowedEnumVariants, DecodeError, EncodeError};
6use bincode::*;
7
8impl Encode for Uri {
9 fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
10 self.value.encode(encoder)
11 }
12}
13
14impl<Context> Decode<Context> for Uri {
15 fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
16 let value = String::decode(decoder)?;
17 Ok(Uri { value })
18 }
19}
20
21impl<'de, Context> BorrowDecode<'de, Context> for Uri {
22 fn borrow_decode<D: BorrowDecoder<'de, Context = Context>>(
23 decoder: &mut D,
24 ) -> Result<Self, DecodeError> {
25 let value = String::borrow_decode(decoder)?;
26 Ok(Uri { value })
27 }
28}
29
30impl Encode for WitValue {
31 fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
32 self.nodes.encode(encoder)
33 }
34}
35
36impl<Context> Decode<Context> for WitValue {
37 fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
38 let nodes = Vec::<WitNode>::decode(decoder)?;
39 Ok(WitValue { nodes })
40 }
41}
42
43impl<'de, Context> BorrowDecode<'de, Context> for WitValue {
44 fn borrow_decode<D: BorrowDecoder<'de, Context = Context>>(
45 decoder: &mut D,
46 ) -> Result<Self, DecodeError> {
47 let nodes = Vec::<WitNode>::borrow_decode(decoder)?;
48 Ok(WitValue { nodes })
49 }
50}
51
52impl Encode for WitNode {
53 fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
54 match self {
55 WitNode::RecordValue(field_indices) => {
56 0u8.encode(encoder)?;
57 field_indices.encode(encoder)
58 }
59 WitNode::VariantValue((cons_idx, value_idx)) => {
60 1u8.encode(encoder)?;
61 cons_idx.encode(encoder)?;
62 value_idx.encode(encoder)
63 }
64 WitNode::EnumValue(value) => {
65 2u8.encode(encoder)?;
66 value.encode(encoder)
67 }
68 WitNode::FlagsValue(values) => {
69 3u8.encode(encoder)?;
70 values.encode(encoder)
71 }
72 WitNode::TupleValue(value_indices) => {
73 4u8.encode(encoder)?;
74 value_indices.encode(encoder)
75 }
76 WitNode::ListValue(value_indices) => {
77 5u8.encode(encoder)?;
78 value_indices.encode(encoder)
79 }
80 WitNode::OptionValue(opt_idx) => {
81 6u8.encode(encoder)?;
82 opt_idx.encode(encoder)
83 }
84 WitNode::ResultValue(res_idx) => {
85 7u8.encode(encoder)?;
86 res_idx.encode(encoder)
87 }
88 WitNode::PrimU8(value) => {
89 8u8.encode(encoder)?;
90 value.encode(encoder)
91 }
92 WitNode::PrimU16(value) => {
93 9u8.encode(encoder)?;
94 value.encode(encoder)
95 }
96 WitNode::PrimU32(value) => {
97 10u8.encode(encoder)?;
98 value.encode(encoder)
99 }
100 WitNode::PrimU64(value) => {
101 11u8.encode(encoder)?;
102 value.encode(encoder)
103 }
104 WitNode::PrimS8(value) => {
105 12u8.encode(encoder)?;
106 value.encode(encoder)
107 }
108 WitNode::PrimS16(value) => {
109 13u8.encode(encoder)?;
110 value.encode(encoder)
111 }
112 WitNode::PrimS32(value) => {
113 14u8.encode(encoder)?;
114 value.encode(encoder)
115 }
116 WitNode::PrimS64(value) => {
117 15u8.encode(encoder)?;
118 value.encode(encoder)
119 }
120 WitNode::PrimFloat32(value) => {
121 16u8.encode(encoder)?;
122 value.encode(encoder)
123 }
124 WitNode::PrimFloat64(value) => {
125 17u8.encode(encoder)?;
126 value.encode(encoder)
127 }
128 WitNode::PrimChar(value) => {
129 18u8.encode(encoder)?;
130 value.encode(encoder)
131 }
132 WitNode::PrimBool(value) => {
133 19u8.encode(encoder)?;
134 value.encode(encoder)
135 }
136 WitNode::PrimString(value) => {
137 20u8.encode(encoder)?;
138 value.encode(encoder)
139 }
140 WitNode::Handle((uri, value)) => {
141 21u8.encode(encoder)?;
142 uri.value.encode(encoder)?;
143 value.encode(encoder)
144 }
145 }
146 }
147}
148
149impl<Context> Decode<Context> for WitNode {
150 fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
151 let tag: u8 = Decode::decode(decoder)?;
152 match tag {
153 0u8 => {
154 let field_indices = Vec::<i32>::decode(decoder)?;
155 Ok(WitNode::RecordValue(field_indices))
156 }
157 1u8 => {
158 let cons_idx = u32::decode(decoder)?;
159 let value_idx = Option::<i32>::decode(decoder)?;
160 Ok(WitNode::VariantValue((cons_idx, value_idx)))
161 }
162 2u8 => {
163 let value = u32::decode(decoder)?;
164 Ok(WitNode::EnumValue(value))
165 }
166 3u8 => {
167 let values = Vec::<bool>::decode(decoder)?;
168 Ok(WitNode::FlagsValue(values))
169 }
170 4u8 => {
171 let value_indices = Vec::<i32>::decode(decoder)?;
172 Ok(WitNode::TupleValue(value_indices))
173 }
174 5u8 => {
175 let value_indices = Vec::<i32>::decode(decoder)?;
176 Ok(WitNode::ListValue(value_indices))
177 }
178 6u8 => {
179 let opt_idx = Option::<i32>::decode(decoder)?;
180 Ok(WitNode::OptionValue(opt_idx))
181 }
182 7u8 => {
183 let res_idx = Result::<Option<i32>, Option<i32>>::decode(decoder)?;
184 Ok(WitNode::ResultValue(res_idx))
185 }
186 8u8 => {
187 let value = u8::decode(decoder)?;
188 Ok(WitNode::PrimU8(value))
189 }
190 9u8 => {
191 let value = u16::decode(decoder)?;
192 Ok(WitNode::PrimU16(value))
193 }
194 10u8 => {
195 let value = u32::decode(decoder)?;
196 Ok(WitNode::PrimU32(value))
197 }
198 11u8 => {
199 let value = u64::decode(decoder)?;
200 Ok(WitNode::PrimU64(value))
201 }
202 12u8 => {
203 let value = i8::decode(decoder)?;
204 Ok(WitNode::PrimS8(value))
205 }
206 13u8 => {
207 let value = i16::decode(decoder)?;
208 Ok(WitNode::PrimS16(value))
209 }
210 14u8 => {
211 let value = i32::decode(decoder)?;
212 Ok(WitNode::PrimS32(value))
213 }
214 15u8 => {
215 let value = i64::decode(decoder)?;
216 Ok(WitNode::PrimS64(value))
217 }
218 16u8 => {
219 let value = f32::decode(decoder)?;
220 Ok(WitNode::PrimFloat32(value))
221 }
222 17u8 => {
223 let value = f64::decode(decoder)?;
224 Ok(WitNode::PrimFloat64(value))
225 }
226 18u8 => {
227 let value = char::decode(decoder)?;
228 Ok(WitNode::PrimChar(value))
229 }
230 19u8 => {
231 let value = bool::decode(decoder)?;
232 Ok(WitNode::PrimBool(value))
233 }
234 20u8 => {
235 let value = String::decode(decoder)?;
236 Ok(WitNode::PrimString(value))
237 }
238 21u8 => {
239 let uri = String::decode(decoder)?;
240 let value = u64::decode(decoder)?;
241 Ok(WitNode::Handle((Uri { value: uri }, value)))
242 }
243 _ => Err(DecodeError::UnexpectedVariant {
244 found: tag as u32,
245 type_name: "WitNode",
246 allowed: &AllowedEnumVariants::Range { min: 0, max: 21 },
247 }),
248 }
249 }
250}
251
252impl<'de, Context> BorrowDecode<'de, Context> for WitNode {
253 fn borrow_decode<D: BorrowDecoder<'de, Context = Context>>(
254 decoder: &mut D,
255 ) -> Result<Self, DecodeError> {
256 let tag: u8 = BorrowDecode::borrow_decode(decoder)?;
257 match tag {
258 0u8 => {
259 let field_indices = Vec::<i32>::borrow_decode(decoder)?;
260 Ok(WitNode::RecordValue(field_indices))
261 }
262 1u8 => {
263 let cons_idx = u32::borrow_decode(decoder)?;
264 let value_idx = Option::<i32>::borrow_decode(decoder)?;
265 Ok(WitNode::VariantValue((cons_idx, value_idx)))
266 }
267 2u8 => {
268 let value = u32::borrow_decode(decoder)?;
269 Ok(WitNode::EnumValue(value))
270 }
271 3u8 => {
272 let values = Vec::<bool>::borrow_decode(decoder)?;
273 Ok(WitNode::FlagsValue(values))
274 }
275 4u8 => {
276 let value_indices = Vec::<i32>::borrow_decode(decoder)?;
277 Ok(WitNode::TupleValue(value_indices))
278 }
279 5u8 => {
280 let value_indices = Vec::<i32>::borrow_decode(decoder)?;
281 Ok(WitNode::ListValue(value_indices))
282 }
283 6u8 => {
284 let opt_idx = Option::<i32>::borrow_decode(decoder)?;
285 Ok(WitNode::OptionValue(opt_idx))
286 }
287 7u8 => {
288 let res_idx = Result::<Option<i32>, Option<i32>>::borrow_decode(decoder)?;
289 Ok(WitNode::ResultValue(res_idx))
290 }
291 8u8 => {
292 let value = u8::borrow_decode(decoder)?;
293 Ok(WitNode::PrimU8(value))
294 }
295 9u8 => {
296 let value = u16::borrow_decode(decoder)?;
297 Ok(WitNode::PrimU16(value))
298 }
299 10u8 => {
300 let value = u32::borrow_decode(decoder)?;
301 Ok(WitNode::PrimU32(value))
302 }
303 11u8 => {
304 let value = u64::borrow_decode(decoder)?;
305 Ok(WitNode::PrimU64(value))
306 }
307 12u8 => {
308 let value = i8::borrow_decode(decoder)?;
309 Ok(WitNode::PrimS8(value))
310 }
311 13u8 => {
312 let value = i16::borrow_decode(decoder)?;
313 Ok(WitNode::PrimS16(value))
314 }
315 14u8 => {
316 let value = i32::borrow_decode(decoder)?;
317 Ok(WitNode::PrimS32(value))
318 }
319 15u8 => {
320 let value = i64::borrow_decode(decoder)?;
321 Ok(WitNode::PrimS64(value))
322 }
323 16u8 => {
324 let value = f32::borrow_decode(decoder)?;
325 Ok(WitNode::PrimFloat32(value))
326 }
327 17u8 => {
328 let value = f64::borrow_decode(decoder)?;
329 Ok(WitNode::PrimFloat64(value))
330 }
331 18u8 => {
332 let value = char::borrow_decode(decoder)?;
333 Ok(WitNode::PrimChar(value))
334 }
335 19u8 => {
336 let value = bool::borrow_decode(decoder)?;
337 Ok(WitNode::PrimBool(value))
338 }
339 20u8 => {
340 let value = String::borrow_decode(decoder)?;
341 Ok(WitNode::PrimString(value))
342 }
343 21u8 => {
344 let uri = String::borrow_decode(decoder)?;
345 let value = u64::borrow_decode(decoder)?;
346 Ok(WitNode::Handle((Uri { value: uri }, value)))
347 }
348 _ => Err(DecodeError::UnexpectedVariant {
349 found: tag as u32,
350 type_name: "WitNode",
351 allowed: &AllowedEnumVariants::Range { min: 0, max: 21 },
352 }),
353 }
354 }
355}
356
357impl Encode for WitType {
358 fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
359 self.nodes.encode(encoder)
360 }
361}
362
363impl<Context> Decode<Context> for WitType {
364 fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
365 let nodes = Vec::<NamedWitTypeNode>::decode(decoder)?;
366 Ok(WitType { nodes })
367 }
368}
369
370impl<'de, Context> BorrowDecode<'de, Context> for WitType {
371 fn borrow_decode<D: BorrowDecoder<'de, Context = Context>>(
372 decoder: &mut D,
373 ) -> Result<Self, DecodeError> {
374 let nodes = Vec::<NamedWitTypeNode>::borrow_decode(decoder)?;
375 Ok(WitType { nodes })
376 }
377}
378
379impl Encode for ResourceMode {
380 fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
381 match self {
382 ResourceMode::Borrowed => 0u8.encode(encoder),
383 ResourceMode::Owned => 1u8.encode(encoder),
384 }
385 }
386}
387
388impl<Context> Decode<Context> for ResourceMode {
389 fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
390 let tag: u8 = Decode::decode(decoder)?;
391 match tag {
392 0u8 => Ok(ResourceMode::Borrowed),
393 1u8 => Ok(ResourceMode::Owned),
394 _ => Err(DecodeError::UnexpectedVariant {
395 found: tag as u32,
396 type_name: "ResourceMode",
397 allowed: &AllowedEnumVariants::Range { min: 0, max: 1 },
398 }),
399 }
400 }
401}
402
403impl<'de, Context> BorrowDecode<'de, Context> for ResourceMode {
404 fn borrow_decode<D: BorrowDecoder<'de, Context = Context>>(
405 decoder: &mut D,
406 ) -> Result<Self, DecodeError> {
407 let tag: u8 = BorrowDecode::borrow_decode(decoder)?;
408 match tag {
409 0u8 => Ok(ResourceMode::Borrowed),
410 1u8 => Ok(ResourceMode::Owned),
411 _ => Err(DecodeError::UnexpectedVariant {
412 found: tag as u32,
413 type_name: "ResourceMode",
414 allowed: &AllowedEnumVariants::Range { min: 0, max: 1 },
415 }),
416 }
417 }
418}
419
420impl Encode for NamedWitTypeNode {
421 fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
422 self.name.encode(encoder)?;
423 self.owner.encode(encoder)?;
424 self.type_.encode(encoder)
425 }
426}
427
428impl<Context> Decode<Context> for NamedWitTypeNode {
429 fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
430 let name = Option::<String>::decode(decoder)?;
431 let owner = Option::<String>::decode(decoder)?;
432 let type_ = WitTypeNode::decode(decoder)?;
433 Ok(NamedWitTypeNode { name, owner, type_ })
434 }
435}
436
437impl<'de, Context> BorrowDecode<'de, Context> for NamedWitTypeNode {
438 fn borrow_decode<D: BorrowDecoder<'de, Context = Context>>(
439 decoder: &mut D,
440 ) -> Result<Self, DecodeError> {
441 let name = Option::<String>::borrow_decode(decoder)?;
442 let owner = Option::<String>::borrow_decode(decoder)?;
443 let type_ = WitTypeNode::borrow_decode(decoder)?;
444 Ok(NamedWitTypeNode { name, owner, type_ })
445 }
446}
447
448impl Encode for WitTypeNode {
449 fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
450 match self {
451 WitTypeNode::RecordType(field_types) => {
452 0u8.encode(encoder)?;
453 field_types.encode(encoder)
454 }
455 WitTypeNode::VariantType(cons_types) => {
456 1u8.encode(encoder)?;
457 cons_types.encode(encoder)
458 }
459 WitTypeNode::EnumType(names) => {
460 2u8.encode(encoder)?;
461 names.encode(encoder)
462 }
463 WitTypeNode::FlagsType(names) => {
464 3u8.encode(encoder)?;
465 names.encode(encoder)
466 }
467 WitTypeNode::TupleType(field_types) => {
468 4u8.encode(encoder)?;
469 field_types.encode(encoder)
470 }
471 WitTypeNode::ListType(elem_type) => {
472 5u8.encode(encoder)?;
473 elem_type.encode(encoder)
474 }
475 WitTypeNode::OptionType(inner_type) => {
476 6u8.encode(encoder)?;
477 inner_type.encode(encoder)
478 }
479 WitTypeNode::ResultType((ok_type, err_type)) => {
480 7u8.encode(encoder)?;
481 ok_type.encode(encoder)?;
482 err_type.encode(encoder)
483 }
484 WitTypeNode::HandleType((id, mode)) => {
485 8u8.encode(encoder)?;
486 id.encode(encoder)?;
487 mode.encode(encoder)
488 }
489 WitTypeNode::PrimU8Type => 9u8.encode(encoder),
490 WitTypeNode::PrimU16Type => 10u8.encode(encoder),
491 WitTypeNode::PrimU32Type => 11u8.encode(encoder),
492 WitTypeNode::PrimU64Type => 12u8.encode(encoder),
493 WitTypeNode::PrimS8Type => 13u8.encode(encoder),
494 WitTypeNode::PrimS16Type => 14u8.encode(encoder),
495 WitTypeNode::PrimS32Type => 15u8.encode(encoder),
496 WitTypeNode::PrimS64Type => 16u8.encode(encoder),
497 WitTypeNode::PrimF32Type => 17u8.encode(encoder),
498 WitTypeNode::PrimF64Type => 18u8.encode(encoder),
499 WitTypeNode::PrimCharType => 19u8.encode(encoder),
500 WitTypeNode::PrimBoolType => 20u8.encode(encoder),
501 WitTypeNode::PrimStringType => 21u8.encode(encoder),
502 }
503 }
504}
505
506impl<Context> Decode<Context> for WitTypeNode {
507 fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
508 let tag: u8 = Decode::decode(decoder)?;
509 match tag {
510 0u8 => {
511 let field_types = Vec::<(String, NodeIndex)>::decode(decoder)?;
512 Ok(WitTypeNode::RecordType(field_types))
513 }
514 1u8 => {
515 let cons_types = Vec::<(String, Option<NodeIndex>)>::decode(decoder)?;
516 Ok(WitTypeNode::VariantType(cons_types))
517 }
518 2u8 => {
519 let names = Vec::<String>::decode(decoder)?;
520 Ok(WitTypeNode::EnumType(names))
521 }
522 3u8 => {
523 let names = Vec::<String>::decode(decoder)?;
524 Ok(WitTypeNode::FlagsType(names))
525 }
526 4u8 => {
527 let field_types = Vec::<NodeIndex>::decode(decoder)?;
528 Ok(WitTypeNode::TupleType(field_types))
529 }
530 5u8 => {
531 let elem_type = NodeIndex::decode(decoder)?;
532 Ok(WitTypeNode::ListType(elem_type))
533 }
534 6u8 => {
535 let inner_type = NodeIndex::decode(decoder)?;
536 Ok(WitTypeNode::OptionType(inner_type))
537 }
538 7u8 => {
539 let ok_type = Option::<NodeIndex>::decode(decoder)?;
540 let err_type = Option::<NodeIndex>::decode(decoder)?;
541 Ok(WitTypeNode::ResultType((ok_type, err_type)))
542 }
543 8u8 => {
544 let resource_id = ResourceId::decode(decoder)?;
545 let resource_mode = ResourceMode::decode(decoder)?;
546 Ok(WitTypeNode::HandleType((resource_id, resource_mode)))
547 }
548 9u8 => Ok(WitTypeNode::PrimU8Type),
549 10u8 => Ok(WitTypeNode::PrimU16Type),
550 11u8 => Ok(WitTypeNode::PrimU32Type),
551 12u8 => Ok(WitTypeNode::PrimU64Type),
552 13u8 => Ok(WitTypeNode::PrimS8Type),
553 14u8 => Ok(WitTypeNode::PrimS16Type),
554 15u8 => Ok(WitTypeNode::PrimS32Type),
555 16u8 => Ok(WitTypeNode::PrimS64Type),
556 17u8 => Ok(WitTypeNode::PrimF32Type),
557 18u8 => Ok(WitTypeNode::PrimF64Type),
558 19u8 => Ok(WitTypeNode::PrimCharType),
559 20u8 => Ok(WitTypeNode::PrimBoolType),
560 21u8 => Ok(WitTypeNode::PrimStringType),
561 _ => Err(DecodeError::UnexpectedVariant {
562 found: tag as u32,
563 type_name: "WitTypeNode",
564 allowed: &AllowedEnumVariants::Range { min: 0, max: 9 },
565 }),
566 }
567 }
568}
569
570impl<'de, Context> BorrowDecode<'de, Context> for WitTypeNode {
571 fn borrow_decode<D: BorrowDecoder<'de, Context = Context>>(
572 decoder: &mut D,
573 ) -> Result<Self, DecodeError> {
574 let tag: u8 = BorrowDecode::borrow_decode(decoder)?;
575 match tag {
576 0u8 => {
577 let field_types = Vec::<(String, NodeIndex)>::borrow_decode(decoder)?;
578 Ok(WitTypeNode::RecordType(field_types))
579 }
580 1u8 => {
581 let cons_types = Vec::<(String, Option<NodeIndex>)>::borrow_decode(decoder)?;
582 Ok(WitTypeNode::VariantType(cons_types))
583 }
584 2u8 => {
585 let names = Vec::<String>::borrow_decode(decoder)?;
586 Ok(WitTypeNode::EnumType(names))
587 }
588 3u8 => {
589 let names = Vec::<String>::borrow_decode(decoder)?;
590 Ok(WitTypeNode::FlagsType(names))
591 }
592 4u8 => {
593 let field_types = Vec::<NodeIndex>::borrow_decode(decoder)?;
594 Ok(WitTypeNode::TupleType(field_types))
595 }
596 5u8 => {
597 let elem_type = NodeIndex::borrow_decode(decoder)?;
598 Ok(WitTypeNode::ListType(elem_type))
599 }
600 6u8 => {
601 let inner_type = NodeIndex::borrow_decode(decoder)?;
602 Ok(WitTypeNode::OptionType(inner_type))
603 }
604 7u8 => {
605 let ok_type = Option::<NodeIndex>::borrow_decode(decoder)?;
606 let err_type = Option::<NodeIndex>::borrow_decode(decoder)?;
607 Ok(WitTypeNode::ResultType((ok_type, err_type)))
608 }
609 8u8 => {
610 let resource_id = ResourceId::borrow_decode(decoder)?;
611 let resource_mode = ResourceMode::borrow_decode(decoder)?;
612 Ok(WitTypeNode::HandleType((resource_id, resource_mode)))
613 }
614 9u8 => Ok(WitTypeNode::PrimU8Type),
615 10u8 => Ok(WitTypeNode::PrimU16Type),
616 11u8 => Ok(WitTypeNode::PrimU32Type),
617 12u8 => Ok(WitTypeNode::PrimU64Type),
618 13u8 => Ok(WitTypeNode::PrimS8Type),
619 14u8 => Ok(WitTypeNode::PrimS16Type),
620 15u8 => Ok(WitTypeNode::PrimS32Type),
621 16u8 => Ok(WitTypeNode::PrimS64Type),
622 17u8 => Ok(WitTypeNode::PrimF32Type),
623 18u8 => Ok(WitTypeNode::PrimF64Type),
624 19u8 => Ok(WitTypeNode::PrimCharType),
625 20u8 => Ok(WitTypeNode::PrimBoolType),
626 21u8 => Ok(WitTypeNode::PrimStringType),
627 _ => Err(DecodeError::UnexpectedVariant {
628 found: tag as u32,
629 type_name: "WitTypeNode",
630 allowed: &AllowedEnumVariants::Range { min: 0, max: 9 },
631 }),
632 }
633 }
634}
635
636#[cfg(test)]
637mod tests {
638 use test_r::test;
639
640 use crate::{Value, WitValue};
641 use proptest::prelude::*;
642 use proptest_arbitrary_interop::arb_sized;
643
644 const CASES: u32 = 10000;
645 const SIZE: usize = 4096;
646
647 proptest! {
648
649 #![proptest_config(ProptestConfig {
650 cases: CASES, .. ProptestConfig::default()
651 })]
652 #[test]
653 fn round_trip_wit_value(value in arb_sized::<Value>(SIZE).prop_filter("Value must be equal to itself", |v| v.eq(v))) {
654 let wit_value: WitValue = value.clone().into();
655 let encoded = bincode::encode_to_vec(wit_value, bincode::config::standard()).unwrap();
656 let (decoded, _): (WitValue, usize) = bincode::decode_from_slice(&encoded, bincode::config::standard()).unwrap();
657 let round_trip_value: Value = decoded.into();
658 prop_assert_eq!(value, round_trip_value);
659 }
660
661 #[test]
662 fn round_trip_value(value in arb_sized::<Value>(SIZE).prop_filter("Value must be equal to itself", |v| v.eq(v))) {
663 let encoded = bincode::encode_to_vec(value.clone(), bincode::config::standard()).unwrap();
664 let (decoded, _): (Value, usize) = bincode::decode_from_slice(&encoded, bincode::config::standard()).unwrap();
665 prop_assert_eq!(value, decoded);
666 }
667 }
668}