1use crate::decoder::{OffsetSizeBytes, VariantBasicType, VariantPrimitiveType};
6use crate::{
7 ShortString, Variant, VariantDecimal4, VariantDecimal8, VariantDecimal16, VariantList,
8 VariantMetadata, VariantObject,
9};
10use arrow_schema::ArrowError;
11use chrono::Timelike;
12use uuid::Uuid;
13
14mod list;
15mod metadata;
16mod object;
17
18pub use list::*;
19pub use metadata::*;
20pub use object::*;
21
22pub(crate) const BASIC_TYPE_BITS: u8 = 2;
23pub(crate) const UNIX_EPOCH_DATE: chrono::NaiveDate =
24 chrono::NaiveDate::from_ymd_opt(1970, 1, 1).unwrap();
25
26fn primitive_header(primitive_type: VariantPrimitiveType) -> u8 {
27 ((primitive_type as u8) << 2) | VariantBasicType::Primitive as u8
28}
29
30fn short_string_header(len: usize) -> u8 {
31 ((len as u8) << 2) | VariantBasicType::ShortString as u8
32}
33
34pub(crate) fn int_size(v: usize) -> OffsetSizeBytes {
35 match v {
36 0..=0xFF => OffsetSizeBytes::One,
37 0x100..=0xFFFF => OffsetSizeBytes::Two,
38 0x10000..=0xFFFFFF => OffsetSizeBytes::Three,
39 _ => OffsetSizeBytes::Four,
40 }
41}
42
43const ONE_TOP_LEVEL_VALUE_MSG: &str =
44 "VariantBuilder already contains a top-level variant value; only one is allowed";
45const EMPTY_BUILDER_MSG: &str =
46 "VariantBuilder is empty; append a top-level value before calling finish()";
47
48#[cold]
51#[inline(never)]
52fn top_level_value_panic() -> ! {
53 panic!("{ONE_TOP_LEVEL_VALUE_MSG}");
54}
55
56#[cold]
57#[inline(never)]
58fn top_level_value_error() -> ArrowError {
59 ArrowError::InvalidArgumentError(ONE_TOP_LEVEL_VALUE_MSG.into())
60}
61
62#[cold]
63#[inline(never)]
64fn empty_builder_error() -> ArrowError {
65 ArrowError::InvalidArgumentError(EMPTY_BUILDER_MSG.into())
66}
67
68#[derive(Debug, Default)]
76pub struct ValueBuilder(Vec<u8>);
77
78impl ValueBuilder {
79 pub fn new() -> Self {
81 Default::default()
82 }
83}
84
85macro_rules! variant_append_value {
88 ($builder:expr, $value:expr, $object_pat:pat => $object_arm:expr, $list_pat:pat => $list_arm:expr) => {
89 match $value {
90 Variant::Null => $builder.append_null(),
91 Variant::BooleanTrue => $builder.append_bool(true),
92 Variant::BooleanFalse => $builder.append_bool(false),
93 Variant::Int8(v) => $builder.append_int8(v),
94 Variant::Int16(v) => $builder.append_int16(v),
95 Variant::Int32(v) => $builder.append_int32(v),
96 Variant::Int64(v) => $builder.append_int64(v),
97 Variant::Date(v) => $builder.append_date(v),
98 Variant::Time(v) => $builder.append_time_micros(v),
99 Variant::TimestampMicros(v) => $builder.append_timestamp_micros(v),
100 Variant::TimestampNtzMicros(v) => $builder.append_timestamp_ntz_micros(v),
101 Variant::TimestampNanos(v) => $builder.append_timestamp_nanos(v),
102 Variant::TimestampNtzNanos(v) => $builder.append_timestamp_ntz_nanos(v),
103 Variant::Decimal4(decimal4) => $builder.append_decimal4(decimal4),
104 Variant::Decimal8(decimal8) => $builder.append_decimal8(decimal8),
105 Variant::Decimal16(decimal16) => $builder.append_decimal16(decimal16),
106 Variant::Float(v) => $builder.append_float(v),
107 Variant::Double(v) => $builder.append_double(v),
108 Variant::Binary(v) => $builder.append_binary(v),
109 Variant::String(s) => $builder.append_string(s),
110 Variant::ShortString(s) => $builder.append_short_string(s),
111 Variant::Uuid(v) => $builder.append_uuid(v),
112 $object_pat => $object_arm,
113 $list_pat => $list_arm,
114 }
115 };
116}
117
118impl ValueBuilder {
119 fn append_u8(&mut self, term: u8) {
120 self.0.push(term);
121 }
122
123 fn append_slice(&mut self, other: &[u8]) {
124 self.0.extend_from_slice(other);
125 }
126
127 fn append_primitive_header(&mut self, primitive_type: VariantPrimitiveType) {
128 self.0.push(primitive_header(primitive_type));
129 }
130
131 pub fn into_inner(self) -> Vec<u8> {
133 self.0
134 }
135
136 pub(crate) fn inner_mut(&mut self) -> &mut Vec<u8> {
137 &mut self.0
138 }
139
140 fn append_null(&mut self) {
143 self.append_primitive_header(VariantPrimitiveType::Null);
144 }
145
146 fn append_bool(&mut self, value: bool) {
147 let primitive_type = if value {
148 VariantPrimitiveType::BooleanTrue
149 } else {
150 VariantPrimitiveType::BooleanFalse
151 };
152 self.append_primitive_header(primitive_type);
153 }
154
155 fn append_int8(&mut self, value: i8) {
156 self.append_primitive_header(VariantPrimitiveType::Int8);
157 self.append_u8(value as u8);
158 }
159
160 fn append_int16(&mut self, value: i16) {
161 self.append_primitive_header(VariantPrimitiveType::Int16);
162 self.append_slice(&value.to_le_bytes());
163 }
164
165 fn append_int32(&mut self, value: i32) {
166 self.append_primitive_header(VariantPrimitiveType::Int32);
167 self.append_slice(&value.to_le_bytes());
168 }
169
170 fn append_int64(&mut self, value: i64) {
171 self.append_primitive_header(VariantPrimitiveType::Int64);
172 self.append_slice(&value.to_le_bytes());
173 }
174
175 fn append_float(&mut self, value: f32) {
176 self.append_primitive_header(VariantPrimitiveType::Float);
177 self.append_slice(&value.to_le_bytes());
178 }
179
180 fn append_double(&mut self, value: f64) {
181 self.append_primitive_header(VariantPrimitiveType::Double);
182 self.append_slice(&value.to_le_bytes());
183 }
184
185 fn append_date(&mut self, value: chrono::NaiveDate) {
186 self.append_primitive_header(VariantPrimitiveType::Date);
187 let days_since_epoch = value.signed_duration_since(UNIX_EPOCH_DATE).num_days() as i32;
188 self.append_slice(&days_since_epoch.to_le_bytes());
189 }
190
191 fn append_timestamp_micros(&mut self, value: chrono::DateTime<chrono::Utc>) {
192 self.append_primitive_header(VariantPrimitiveType::TimestampMicros);
193 let micros = value.timestamp_micros();
194 self.append_slice(µs.to_le_bytes());
195 }
196
197 fn append_timestamp_ntz_micros(&mut self, value: chrono::NaiveDateTime) {
198 self.append_primitive_header(VariantPrimitiveType::TimestampNtzMicros);
199 let micros = value.and_utc().timestamp_micros();
200 self.append_slice(µs.to_le_bytes());
201 }
202
203 fn append_time_micros(&mut self, value: chrono::NaiveTime) {
204 self.append_primitive_header(VariantPrimitiveType::Time);
205 let micros_from_midnight = value.num_seconds_from_midnight() as u64 * 1_000_000
206 + value.nanosecond() as u64 / 1_000;
207 self.append_slice(µs_from_midnight.to_le_bytes());
208 }
209
210 fn append_timestamp_nanos(&mut self, value: chrono::DateTime<chrono::Utc>) {
211 self.append_primitive_header(VariantPrimitiveType::TimestampNanos);
212 let nanos = value.timestamp_nanos_opt().unwrap();
213 self.append_slice(&nanos.to_le_bytes());
214 }
215
216 fn append_timestamp_ntz_nanos(&mut self, value: chrono::NaiveDateTime) {
217 self.append_primitive_header(VariantPrimitiveType::TimestampNtzNanos);
218 let nanos = value.and_utc().timestamp_nanos_opt().unwrap();
219 self.append_slice(&nanos.to_le_bytes());
220 }
221
222 fn append_uuid(&mut self, value: Uuid) {
223 self.append_primitive_header(VariantPrimitiveType::Uuid);
224 self.append_slice(&value.into_bytes());
225 }
226
227 fn append_decimal4(&mut self, decimal4: VariantDecimal4) {
228 self.append_primitive_header(VariantPrimitiveType::Decimal4);
229 self.append_u8(decimal4.scale());
230 self.append_slice(&decimal4.integer().to_le_bytes());
231 }
232
233 fn append_decimal8(&mut self, decimal8: VariantDecimal8) {
234 self.append_primitive_header(VariantPrimitiveType::Decimal8);
235 self.append_u8(decimal8.scale());
236 self.append_slice(&decimal8.integer().to_le_bytes());
237 }
238
239 fn append_decimal16(&mut self, decimal16: VariantDecimal16) {
240 self.append_primitive_header(VariantPrimitiveType::Decimal16);
241 self.append_u8(decimal16.scale());
242 self.append_slice(&decimal16.integer().to_le_bytes());
243 }
244
245 fn append_binary(&mut self, value: &[u8]) {
246 self.append_primitive_header(VariantPrimitiveType::Binary);
247 self.append_slice(&(value.len() as u32).to_le_bytes());
248 self.append_slice(value);
249 }
250
251 fn append_short_string(&mut self, value: ShortString) {
252 let inner = value.0;
253 self.append_u8(short_string_header(inner.len()));
254 self.append_slice(inner.as_bytes());
255 }
256
257 fn append_string(&mut self, value: &str) {
258 self.append_primitive_header(VariantPrimitiveType::String);
259 self.append_slice(&(value.len() as u32).to_le_bytes());
260 self.append_slice(value.as_bytes());
261 }
262
263 fn append_object<S: BuilderSpecificState>(state: ParentState<'_, S>, obj: VariantObject) {
264 let mut object_builder = ObjectBuilder::new(state, false);
265 object_builder.extend(obj.iter());
266 object_builder.finish();
267 }
268
269 fn try_append_object<S: BuilderSpecificState>(
270 state: ParentState<'_, S>,
271 obj: VariantObject,
272 ) -> Result<(), ArrowError> {
273 let mut object_builder = ObjectBuilder::new(state, false);
274
275 for res in obj.iter_try() {
276 let (field_name, value) = res?;
277 object_builder.try_insert(field_name, value)?;
278 }
279
280 object_builder.finish();
281 Ok(())
282 }
283
284 fn append_list<S: BuilderSpecificState>(state: ParentState<'_, S>, list: VariantList) {
285 let mut list_builder = ListBuilder::new(state, false);
286 list_builder.extend(list.iter());
287 list_builder.finish();
288 }
289
290 fn try_append_list<S: BuilderSpecificState>(
291 state: ParentState<'_, S>,
292 list: VariantList,
293 ) -> Result<(), ArrowError> {
294 let mut list_builder = ListBuilder::new(state, false);
295 for res in list.iter_try() {
296 let value = res?;
297 list_builder.try_append_value(value)?;
298 }
299
300 list_builder.finish();
301
302 Ok(())
303 }
304
305 pub fn offset(&self) -> usize {
307 self.0.len()
308 }
309
310 pub fn append_variant<S: BuilderSpecificState>(
317 mut state: ParentState<'_, S>,
318 variant: Variant<'_, '_>,
319 ) {
320 variant_append_value!(
321 state.value_builder(),
322 variant,
323 Variant::Object(obj) => return Self::append_object(state, obj),
324 Variant::List(list) => return Self::append_list(state, list)
325 );
326 state.finish();
327 }
328
329 pub fn try_append_variant<S: BuilderSpecificState>(
334 mut state: ParentState<'_, S>,
335 variant: Variant<'_, '_>,
336 ) -> Result<(), ArrowError> {
337 variant_append_value!(
338 state.value_builder(),
339 variant,
340 Variant::Object(obj) => return Self::try_append_object(state, obj),
341 Variant::List(list) => return Self::try_append_list(state, list)
342 );
343 state.finish();
344 Ok(())
345 }
346
347 pub fn append_variant_bytes<S: BuilderSpecificState>(
356 mut state: ParentState<'_, S>,
357 variant: Variant<'_, '_>,
358 ) {
359 let builder = state.value_builder();
360 variant_append_value!(
361 builder,
362 variant,
363 Variant::Object(obj) => builder.append_slice(obj.value),
364 Variant::List(list) => builder.append_slice(list.value)
365 );
366 state.finish();
367 }
368}
369
370pub trait BuilderSpecificState: std::fmt::Debug {
372 fn finish(
380 &mut self,
381 _metadata_builder: &mut dyn MetadataBuilder,
382 _value_builder: &mut ValueBuilder,
383 ) {
384 }
385
386 fn rollback(&mut self) {}
394}
395
396impl BuilderSpecificState for () {}
398
399#[derive(Debug)]
411pub struct ParentState<'a, S: BuilderSpecificState> {
412 pub(crate) value_builder: &'a mut ValueBuilder,
413 pub(crate) saved_value_builder_offset: usize,
414 pub(crate) metadata_builder: &'a mut dyn MetadataBuilder,
415 pub(crate) saved_metadata_builder_dict_size: usize,
416 pub(crate) builder_state: S,
417 pub(crate) finished: bool,
418}
419
420impl<'a, S: BuilderSpecificState> ParentState<'a, S> {
421 pub fn new(
425 value_builder: &'a mut ValueBuilder,
426 metadata_builder: &'a mut dyn MetadataBuilder,
427 builder_state: S,
428 ) -> Self {
429 Self {
430 saved_value_builder_offset: value_builder.offset(),
431 value_builder,
432 saved_metadata_builder_dict_size: metadata_builder.num_field_names(),
433 metadata_builder,
434 builder_state,
435 finished: false,
436 }
437 }
438
439 pub fn finish(&mut self) {
442 self.builder_state
443 .finish(self.metadata_builder, self.value_builder);
444 self.finished = true
445 }
446
447 fn rollback(&mut self) {
449 if self.finished {
450 return;
451 }
452
453 self.value_builder
454 .inner_mut()
455 .truncate(self.saved_value_builder_offset);
456 self.metadata_builder
457 .truncate_field_names(self.saved_metadata_builder_dict_size);
458 self.builder_state.rollback();
459 }
460
461 pub(crate) fn value_builder(&mut self) -> &mut ValueBuilder {
463 self.value_builder
464 }
465
466 pub(crate) fn metadata_builder(&mut self) -> &mut dyn MetadataBuilder {
468 self.metadata_builder
469 }
470}
471
472impl<'a> ParentState<'a, ()> {
473 pub fn variant(
477 value_builder: &'a mut ValueBuilder,
478 metadata_builder: &'a mut dyn MetadataBuilder,
479 ) -> Self {
480 Self::new(value_builder, metadata_builder, ())
481 }
482}
483
484impl<S: BuilderSpecificState> Drop for ParentState<'_, S> {
486 fn drop(&mut self) {
487 self.rollback()
488 }
489}
490
491#[derive(Default, Debug)]
734pub struct VariantBuilder {
735 value_builder: ValueBuilder,
736 metadata_builder: WritableMetadataBuilder,
737 validate_unique_fields: bool,
738}
739
740impl VariantBuilder {
741 pub fn new() -> Self {
743 Self {
744 value_builder: ValueBuilder::new(),
745 metadata_builder: WritableMetadataBuilder::default(),
746 validate_unique_fields: false,
747 }
748 }
749
750 pub fn with_metadata(mut self, metadata: VariantMetadata) -> Self {
752 self.metadata_builder.extend(metadata.iter());
753
754 self
755 }
756
757 pub fn with_validate_unique_fields(mut self, validate_unique_fields: bool) -> Self {
763 self.validate_unique_fields = validate_unique_fields;
764 self
765 }
766
767 pub fn with_field_names<'a>(mut self, field_names: impl IntoIterator<Item = &'a str>) -> Self {
774 self.metadata_builder.extend(field_names);
775
776 self
777 }
778
779 pub fn with_value<'m, 'd, T: Into<Variant<'m, 'd>>>(mut self, value: T) -> Self {
786 self.append_value(value);
787 self
788 }
789
790 pub fn try_with_value<'m, 'd, T: Into<Variant<'m, 'd>>>(
794 mut self,
795 value: T,
796 ) -> Result<Self, ArrowError> {
797 self.try_append_value(value)?;
798 Ok(self)
799 }
800
801 pub fn reserve(&mut self, capacity: usize) {
805 self.metadata_builder.field_names.reserve(capacity);
806 }
807
808 pub fn add_field_name(&mut self, field_name: &str) {
812 self.metadata_builder.upsert_field_name(field_name);
813 }
814
815 #[inline]
821 fn has_top_level_value(&self) -> bool {
822 self.value_builder.offset() != 0
823 }
824
825 #[inline]
826 fn ensure_no_top_level_value(&self) {
827 if self.has_top_level_value() {
828 top_level_value_panic();
829 }
830 }
831
832 #[inline]
833 fn check_no_top_level_value(&self) -> Result<(), ArrowError> {
834 if self.has_top_level_value() {
835 return Err(top_level_value_error());
836 }
837 Ok(())
838 }
839
840 pub fn new_list(&mut self) -> ListBuilder<'_, ()> {
849 self.try_new_list().unwrap()
850 }
851
852 pub fn try_new_list(&mut self) -> Result<ListBuilder<'_, ()>, ArrowError> {
856 self.check_no_top_level_value()?;
857 let parent_state =
858 ParentState::variant(&mut self.value_builder, &mut self.metadata_builder);
859 Ok(ListBuilder::new(parent_state, self.validate_unique_fields))
860 }
861
862 pub fn new_object(&mut self) -> ObjectBuilder<'_, ()> {
871 self.try_new_object().unwrap()
872 }
873
874 pub fn try_new_object(&mut self) -> Result<ObjectBuilder<'_, ()>, ArrowError> {
878 self.check_no_top_level_value()?;
879 let parent_state =
880 ParentState::variant(&mut self.value_builder, &mut self.metadata_builder);
881 Ok(ObjectBuilder::new(
882 parent_state,
883 self.validate_unique_fields,
884 ))
885 }
886
887 pub fn append_value<'m, 'd, T: Into<Variant<'m, 'd>>>(&mut self, value: T) {
903 self.ensure_no_top_level_value();
904 let state = ParentState::variant(&mut self.value_builder, &mut self.metadata_builder);
905 ValueBuilder::append_variant(state, value.into())
906 }
907
908 pub fn try_append_value<'m, 'd, T: Into<Variant<'m, 'd>>>(
912 &mut self,
913 value: T,
914 ) -> Result<(), ArrowError> {
915 self.check_no_top_level_value()?;
916 let state = ParentState::variant(&mut self.value_builder, &mut self.metadata_builder);
917 ValueBuilder::try_append_variant(state, value.into())
918 }
919
920 pub fn append_value_bytes<'m, 'd>(&mut self, value: impl Into<Variant<'m, 'd>>) {
934 self.try_append_value_bytes(value).unwrap()
935 }
936
937 pub fn try_append_value_bytes<'m, 'd>(
942 &mut self,
943 value: impl Into<Variant<'m, 'd>>,
944 ) -> Result<(), ArrowError> {
945 self.check_no_top_level_value()?;
946 let state = ParentState::variant(&mut self.value_builder, &mut self.metadata_builder);
947 ValueBuilder::append_variant_bytes(state, value.into());
948 Ok(())
949 }
950
951 pub fn finish(self) -> (Vec<u8>, Vec<u8>) {
958 self.try_finish().expect(EMPTY_BUILDER_MSG)
959 }
960
961 pub fn try_finish(mut self) -> Result<(Vec<u8>, Vec<u8>), ArrowError> {
965 if !self.has_top_level_value() {
966 return Err(empty_builder_error());
967 }
968 self.metadata_builder.finish();
969 Ok((
970 self.metadata_builder.into_inner(),
971 self.value_builder.into_inner(),
972 ))
973 }
974}
975
976pub trait VariantBuilderExt {
981 type State<'a>: BuilderSpecificState + 'a
983 where
984 Self: 'a;
985
986 fn append_null(&mut self);
989
990 fn append_value<'m, 'v>(&mut self, value: impl Into<Variant<'m, 'v>>);
992
993 fn new_list(&mut self) -> ListBuilder<'_, Self::State<'_>> {
996 self.try_new_list().unwrap()
997 }
998
999 fn new_object(&mut self) -> ObjectBuilder<'_, Self::State<'_>> {
1002 self.try_new_object().unwrap()
1003 }
1004
1005 fn try_new_list(&mut self) -> Result<ListBuilder<'_, Self::State<'_>>, ArrowError>;
1008
1009 fn try_new_object(&mut self) -> Result<ObjectBuilder<'_, Self::State<'_>>, ArrowError>;
1012}
1013
1014impl VariantBuilderExt for VariantBuilder {
1015 type State<'a>
1016 = ()
1017 where
1018 Self: 'a;
1019
1020 fn append_null(&mut self) {
1023 self.append_value(Variant::Null);
1024 }
1025 fn append_value<'m, 'v>(&mut self, value: impl Into<Variant<'m, 'v>>) {
1026 self.append_value(value);
1027 }
1028
1029 fn try_new_list(&mut self) -> Result<ListBuilder<'_, Self::State<'_>>, ArrowError> {
1030 self.try_new_list()
1031 }
1032
1033 fn try_new_object(&mut self) -> Result<ObjectBuilder<'_, Self::State<'_>>, ArrowError> {
1034 self.try_new_object()
1035 }
1036}
1037
1038#[cfg(test)]
1039mod tests {
1040 use crate::{VariantMetadata, builder::metadata::ReadOnlyMetadataBuilder};
1041
1042 use super::*;
1043 #[test]
1044 fn test_simple_usage() {
1045 test_variant_roundtrip((), Variant::Null);
1046 test_variant_roundtrip(true, Variant::BooleanTrue);
1047 test_variant_roundtrip(false, Variant::BooleanFalse);
1048 test_variant_roundtrip(42i8, Variant::Int8(42));
1049 test_variant_roundtrip(1234i16, Variant::Int16(1234));
1050 test_variant_roundtrip(123456i32, Variant::Int32(123456));
1051 test_variant_roundtrip(123456789i64, Variant::Int64(123456789));
1052 test_variant_roundtrip(1.5f32, Variant::Float(1.5));
1053 test_variant_roundtrip(2.5f64, Variant::Double(2.5));
1054 test_variant_roundtrip("hello", Variant::ShortString(ShortString("hello")));
1055
1056 let long_string = "This is a very long string that exceeds the short string limit of 63 bytes and should be encoded as a regular string type instead of a short string";
1058 test_variant_roundtrip(long_string, Variant::String(long_string));
1059
1060 let binary_data = b"binary data";
1062 test_variant_roundtrip(
1063 binary_data.as_slice(),
1064 Variant::Binary(binary_data.as_slice()),
1065 );
1066 }
1067
1068 fn test_variant_roundtrip<'m, 'd, T: Into<Variant<'m, 'd>>>(input: T, expected: Variant) {
1070 let mut builder = VariantBuilder::new();
1071 builder.append_value(input);
1072 let (metadata, value) = builder.finish();
1073 let variant = Variant::try_new(&metadata, &value).unwrap_or_else(|_| {
1074 panic!("Failed to create variant from metadata and value: {metadata:?}, {value:?}")
1075 });
1076 assert_eq!(variant, expected);
1077 }
1078
1079 #[test]
1080 fn test_try_finish_empty_builder_errors() {
1081 let builder = VariantBuilder::new();
1082 let err = builder.try_finish().unwrap_err();
1083 assert!(err.to_string().contains("empty"), "unexpected error: {err}");
1084 }
1085
1086 #[test]
1087 #[should_panic(expected = "empty")]
1088 fn test_finish_empty_builder_panics() {
1089 let builder = VariantBuilder::new();
1090 let _ = builder.finish();
1091 }
1092
1093 #[test]
1094 fn test_try_append_value_after_value_errors() {
1095 let mut builder = VariantBuilder::new();
1096 builder.append_value(1i32);
1097 let err = builder.try_append_value(2i32).unwrap_err();
1098 assert!(
1099 err.to_string().contains("only one is allowed"),
1100 "unexpected error: {err}"
1101 );
1102 }
1103
1104 #[test]
1105 fn test_try_append_value_bytes_after_value_errors() {
1106 let mut builder = VariantBuilder::new();
1107 builder.append_value(1i32);
1108 let err = builder.try_append_value_bytes(2i32).unwrap_err();
1109 assert!(
1110 err.to_string().contains("only one is allowed"),
1111 "unexpected error: {err}"
1112 );
1113 }
1114
1115 #[test]
1116 fn test_try_new_list_after_value_errors() {
1117 let mut builder = VariantBuilder::new();
1118 builder.append_value(1i32);
1119 let err = builder.try_new_list().expect_err("expected error");
1120 assert!(
1121 err.to_string().contains("only one is allowed"),
1122 "unexpected error: {err}"
1123 );
1124 }
1125
1126 #[test]
1127 fn test_try_new_object_after_value_errors() {
1128 let mut builder = VariantBuilder::new();
1129 builder.append_value(1i32);
1130 let err = builder.try_new_object().expect_err("expected error");
1131 assert!(
1132 err.to_string().contains("only one is allowed"),
1133 "unexpected error: {err}"
1134 );
1135 }
1136
1137 #[test]
1138 #[should_panic(expected = "only one is allowed")]
1139 fn test_append_value_after_value_panics() {
1140 let mut builder = VariantBuilder::new();
1141 builder.append_value(1i32);
1142 builder.append_value(2i32);
1143 }
1144
1145 #[test]
1146 #[should_panic(expected = "only one is allowed")]
1147 fn test_append_value_bytes_after_value_panics() {
1148 let mut builder = VariantBuilder::new();
1149 builder.append_value(1i32);
1150 builder.append_value_bytes(2i32);
1151 }
1152
1153 #[test]
1154 #[should_panic(expected = "only one is allowed")]
1155 fn test_new_list_after_value_panics() {
1156 let mut builder = VariantBuilder::new();
1157 builder.append_value(1i32);
1158 let _ = builder.new_list();
1159 }
1160
1161 #[test]
1162 #[should_panic(expected = "only one is allowed")]
1163 fn test_new_object_after_value_panics() {
1164 let mut builder = VariantBuilder::new();
1165 builder.append_value(1i32);
1166 let _ = builder.new_object();
1167 }
1168
1169 #[test]
1170 fn test_nested_object_with_lists() {
1171 let mut builder = VariantBuilder::new();
1181 {
1182 let mut outer_object_builder = builder.new_object();
1183 {
1184 let mut inner_object_builder = outer_object_builder.new_object("door 1");
1185
1186 inner_object_builder
1188 .new_list("items")
1189 .with_value("apple")
1190 .with_value(false)
1191 .finish();
1192
1193 inner_object_builder.finish();
1194 }
1195
1196 outer_object_builder.finish();
1197 }
1198
1199 let (metadata, value) = builder.finish();
1200 let variant = Variant::try_new(&metadata, &value).unwrap();
1201 let outer_object = variant.as_object().unwrap();
1202
1203 assert_eq!(outer_object.len(), 1);
1204 assert_eq!(outer_object.field_name(0).unwrap(), "door 1");
1205
1206 let inner_object_variant = outer_object.field(0).unwrap();
1207 let inner_object = inner_object_variant.as_object().unwrap();
1208
1209 assert_eq!(inner_object.len(), 1);
1210 assert_eq!(inner_object.field_name(0).unwrap(), "items");
1211
1212 let items_variant = inner_object.field(0).unwrap();
1213 let items_list = items_variant.as_list().unwrap();
1214
1215 assert_eq!(items_list.len(), 2);
1216 assert_eq!(items_list.get(0).unwrap(), Variant::from("apple"));
1217 assert_eq!(items_list.get(1).unwrap(), Variant::from(false));
1218 }
1219
1220 #[test]
1221 fn test_sorted_dictionary() {
1222 let mut variant1 = VariantBuilder::new().with_field_names(["b", "c", "d"]);
1224
1225 let mut variant2 = {
1226 let mut builder = VariantBuilder::new();
1227
1228 builder.add_field_name("b");
1229 builder.add_field_name("c");
1230 builder.add_field_name("d");
1231
1232 builder
1233 };
1234
1235 assert_eq!(
1236 variant1.metadata_builder.field_names,
1237 variant2.metadata_builder.field_names
1238 );
1239
1240 assert!(variant1.metadata_builder.is_sorted);
1242 assert!(variant2.metadata_builder.is_sorted);
1243
1244 {
1245 variant2.add_field_name("a");
1247 assert!(!variant2.metadata_builder.is_sorted);
1248
1249 let err = variant2.try_finish().unwrap_err();
1251 assert!(err.to_string().contains("empty"), "unexpected error: {err}");
1252 }
1253
1254 variant1.append_value(false);
1256
1257 let (m, v) = variant1.finish();
1258 let res = Variant::try_new(&m, &v);
1259 assert!(res.is_ok());
1260
1261 let header = VariantMetadata::try_new(&m).unwrap();
1262 assert!(header.is_sorted());
1263 }
1264
1265 #[test]
1266 fn test_object_sorted_dictionary() {
1267 let mut variant1 = VariantBuilder::new().with_field_names(["a", "b", "c"]);
1269 let mut obj = variant1.new_object();
1270
1271 obj.insert("c", true);
1272 obj.insert("a", false);
1273 obj.insert("b", ());
1274
1275 let field_ids_by_insert_order = obj.fields.iter().map(|(&id, _)| id).collect::<Vec<_>>();
1277 assert_eq!(field_ids_by_insert_order, vec![2, 0, 1]);
1278
1279 obj.insert("d", 2);
1281 obj.finish();
1282
1283 let (metadata, value) = variant1.finish();
1284 let variant = Variant::try_new(&metadata, &value).unwrap();
1285
1286 let metadata = VariantMetadata::try_new(&metadata).unwrap();
1287 assert!(metadata.is_sorted());
1288
1289 let object = variant.as_object().unwrap();
1291 let field_names = object
1292 .iter()
1293 .map(|(field_name, _)| field_name)
1294 .collect::<Vec<_>>();
1295
1296 assert_eq!(field_names, vec!["a", "b", "c", "d"]);
1297 }
1298
1299 #[test]
1300 fn test_object_not_sorted_dictionary() {
1301 let mut variant1 = VariantBuilder::new().with_field_names(["b", "c", "d"]);
1303 let mut obj = variant1.new_object();
1304
1305 obj.insert("c", true);
1306 obj.insert("d", false);
1307 obj.insert("b", ());
1308
1309 let field_ids_by_insert_order = obj.fields.iter().map(|(&id, _)| id).collect::<Vec<_>>();
1311 assert_eq!(field_ids_by_insert_order, vec![1, 2, 0]);
1312
1313 obj.insert("a", 2);
1315 obj.finish();
1316
1317 let (metadata, value) = variant1.finish();
1318 let variant = Variant::try_new(&metadata, &value).unwrap();
1319
1320 let metadata = VariantMetadata::try_new(&metadata).unwrap();
1321 assert!(!metadata.is_sorted());
1322
1323 let object = variant.as_object().unwrap();
1325 let field_names = object
1326 .iter()
1327 .map(|(field_name, _)| field_name)
1328 .collect::<Vec<_>>();
1329
1330 assert_eq!(field_names, vec!["a", "b", "c", "d"]);
1331 }
1332
1333 #[test]
1334 fn test_building_sorted_dictionary() {
1335 let mut builder = VariantBuilder::new();
1336 assert!(!builder.metadata_builder.is_sorted);
1337 assert_eq!(builder.metadata_builder.num_field_names(), 0);
1338
1339 builder.add_field_name("a");
1340
1341 assert!(builder.metadata_builder.is_sorted);
1342 assert_eq!(builder.metadata_builder.num_field_names(), 1);
1343
1344 let builder = builder.with_field_names(["b", "c", "d"]);
1345
1346 assert!(builder.metadata_builder.is_sorted);
1347 assert_eq!(builder.metadata_builder.num_field_names(), 4);
1348
1349 let builder = builder.with_field_names(["z", "y"]);
1350 assert!(!builder.metadata_builder.is_sorted);
1351 assert_eq!(builder.metadata_builder.num_field_names(), 6);
1352 }
1353
1354 #[test]
1355 fn test_variant_builder_to_list_builder_no_finish() {
1356 let mut builder = VariantBuilder::new();
1358 let mut list_builder = builder.new_list();
1359 list_builder.append_value("hi");
1360 drop(list_builder);
1361
1362 builder.append_value(42i8);
1363
1364 let (metadata, value) = builder.finish();
1366 let metadata = VariantMetadata::try_new(&metadata).unwrap();
1367 assert!(metadata.is_empty());
1368
1369 let variant = Variant::try_new_with_metadata(metadata, &value).unwrap();
1370 assert_eq!(variant, Variant::Int8(42));
1371 }
1372
1373 #[test]
1374 fn test_variant_builder_to_object_builder_no_finish() {
1375 let mut builder = VariantBuilder::new();
1377 let mut object_builder = builder.new_object();
1378 object_builder.insert("name", "unknown");
1379 drop(object_builder);
1380
1381 builder.append_value(42i8);
1382
1383 let (metadata, value) = builder.finish();
1385 let metadata = VariantMetadata::try_new(&metadata).unwrap();
1386 assert!(metadata.is_empty()); let variant = Variant::try_new_with_metadata(metadata, &value).unwrap();
1389 assert_eq!(variant, Variant::Int8(42));
1390 }
1391
1392 #[test]
1393 fn test_list_builder_to_list_builder_inner_no_finish() {
1394 let mut builder = VariantBuilder::new();
1395 let mut list_builder = builder.new_list();
1396 list_builder.append_value(1i8);
1397
1398 let mut nested_list_builder = list_builder.new_list();
1400 nested_list_builder.append_value("hi");
1401 drop(nested_list_builder);
1402
1403 list_builder.append_value(2i8);
1404
1405 list_builder.finish();
1407 let (metadata, value) = builder.finish();
1408 let metadata = VariantMetadata::try_new(&metadata).unwrap();
1409 assert!(metadata.is_empty());
1410
1411 let variant = Variant::try_new_with_metadata(metadata, &value).unwrap();
1412 let list = variant.as_list().unwrap();
1413 assert_eq!(list.len(), 2);
1414 assert_eq!(list.get(0).unwrap(), Variant::Int8(1));
1415 assert_eq!(list.get(1).unwrap(), Variant::Int8(2));
1416 }
1417
1418 #[test]
1419 fn test_list_builder_to_list_builder_outer_no_finish() {
1420 let mut builder = VariantBuilder::new();
1421 let mut list_builder = builder.new_list();
1422 list_builder.append_value(1i8);
1423
1424 let mut nested_list_builder = list_builder.new_list();
1426 nested_list_builder.append_value("hi");
1427 nested_list_builder.finish();
1428
1429 drop(list_builder);
1431
1432 builder.append_value(2i8);
1433
1434 let (metadata, value) = builder.finish();
1436 let metadata = VariantMetadata::try_new(&metadata).unwrap();
1437 assert!(metadata.is_empty());
1438
1439 let variant = Variant::try_new_with_metadata(metadata, &value).unwrap();
1440 assert_eq!(variant, Variant::Int8(2));
1441 }
1442
1443 #[test]
1444 fn test_list_builder_to_object_builder_inner_no_finish() {
1445 let mut builder = VariantBuilder::new();
1446 let mut list_builder = builder.new_list();
1447 list_builder.append_value(1i8);
1448
1449 let mut nested_object_builder = list_builder.new_object();
1451 nested_object_builder.insert("name", "unknown");
1452 drop(nested_object_builder);
1453
1454 list_builder.append_value(2i8);
1455
1456 list_builder.finish();
1458 let (metadata, value) = builder.finish();
1459 let metadata = VariantMetadata::try_new(&metadata).unwrap();
1460 assert!(metadata.is_empty());
1461
1462 let variant = Variant::try_new_with_metadata(metadata, &value).unwrap();
1463 let list = variant.as_list().unwrap();
1464 assert_eq!(list.len(), 2);
1465 assert_eq!(list.get(0).unwrap(), Variant::Int8(1));
1466 assert_eq!(list.get(1).unwrap(), Variant::Int8(2));
1467 }
1468
1469 #[test]
1470 fn test_list_builder_to_object_builder_outer_no_finish() {
1471 let mut builder = VariantBuilder::new();
1472 let mut list_builder = builder.new_list();
1473 list_builder.append_value(1i8);
1474
1475 let mut nested_object_builder = list_builder.new_object();
1477 nested_object_builder.insert("name", "unknown");
1478 nested_object_builder.finish();
1479
1480 drop(list_builder);
1482
1483 builder.append_value(2i8);
1484
1485 let (metadata, value) = builder.finish();
1487 let metadata = VariantMetadata::try_new(&metadata).unwrap();
1488 assert!(metadata.is_empty()); let variant = Variant::try_new_with_metadata(metadata, &value).unwrap();
1491 assert_eq!(variant, Variant::Int8(2));
1492 }
1493
1494 #[test]
1495 fn test_object_builder_to_list_builder_inner_no_finish() {
1496 let mut builder = VariantBuilder::new();
1497 let mut object_builder = builder.new_object();
1498 object_builder.insert("first", 1i8);
1499
1500 let mut nested_list_builder = object_builder.new_list("nested");
1502 nested_list_builder.append_value("hi");
1503 drop(nested_list_builder);
1504
1505 object_builder.insert("second", 2i8);
1506
1507 object_builder.finish();
1509 let (metadata, value) = builder.finish();
1510
1511 let metadata = VariantMetadata::try_new(&metadata).unwrap();
1512 assert_eq!(metadata.len(), 2);
1513 assert_eq!(&metadata[0], "first");
1514 assert_eq!(&metadata[1], "second");
1515
1516 let variant = Variant::try_new_with_metadata(metadata, &value).unwrap();
1517 let obj = variant.as_object().unwrap();
1518 assert_eq!(obj.len(), 2);
1519 assert_eq!(obj.get("first"), Some(Variant::Int8(1)));
1520 assert_eq!(obj.get("second"), Some(Variant::Int8(2)));
1521 }
1522
1523 #[test]
1524 fn test_object_builder_to_list_builder_outer_no_finish() {
1525 let mut builder = VariantBuilder::new();
1526 let mut object_builder = builder.new_object();
1527 object_builder.insert("first", 1i8);
1528
1529 let mut nested_list_builder = object_builder.new_list("nested");
1531 nested_list_builder.append_value("hi");
1532 nested_list_builder.finish();
1533
1534 drop(object_builder);
1536
1537 builder.append_value(2i8);
1538
1539 let (metadata, value) = builder.finish();
1541 let metadata = VariantMetadata::try_new(&metadata).unwrap();
1542 assert!(metadata.is_empty()); let variant = Variant::try_new_with_metadata(metadata, &value).unwrap();
1545 assert_eq!(variant, Variant::Int8(2));
1546 }
1547
1548 #[test]
1549 fn test_object_builder_to_object_builder_inner_no_finish() {
1550 let mut builder = VariantBuilder::new();
1551 let mut object_builder = builder.new_object();
1552 object_builder.insert("first", 1i8);
1553
1554 let mut nested_object_builder = object_builder.new_object("nested");
1556 nested_object_builder.insert("name", "unknown");
1557 drop(nested_object_builder);
1558
1559 object_builder.insert("second", 2i8);
1560
1561 object_builder.finish();
1563 let (metadata, value) = builder.finish();
1564
1565 let metadata = VariantMetadata::try_new(&metadata).unwrap();
1566 assert_eq!(metadata.len(), 2); assert_eq!(&metadata[0], "first");
1568 assert_eq!(&metadata[1], "second");
1569
1570 let variant = Variant::try_new_with_metadata(metadata, &value).unwrap();
1571 let obj = variant.as_object().unwrap();
1572 assert_eq!(obj.len(), 2);
1573 assert_eq!(obj.get("first"), Some(Variant::Int8(1)));
1574 assert_eq!(obj.get("second"), Some(Variant::Int8(2)));
1575 }
1576
1577 #[test]
1578 fn test_object_builder_to_object_builder_outer_no_finish() {
1579 let mut builder = VariantBuilder::new();
1580 let mut object_builder = builder.new_object();
1581 object_builder.insert("first", 1i8);
1582
1583 let mut nested_object_builder = object_builder.new_object("nested");
1585 nested_object_builder.insert("name", "unknown");
1586 nested_object_builder.finish();
1587
1588 drop(object_builder);
1590
1591 builder.append_value(2i8);
1592
1593 let (metadata, value) = builder.finish();
1595 let metadata = VariantMetadata::try_new(&metadata).unwrap();
1596 assert_eq!(metadata.len(), 0); let variant = Variant::try_new_with_metadata(metadata, &value).unwrap();
1599 assert_eq!(variant, Variant::Int8(2));
1600 }
1601
1602 #[test]
1605 fn test_append_list_object_list_object() {
1606 let mut counter = 0..;
1608 let mut take = move |i| (&mut counter).take(i).collect::<Vec<_>>();
1609 let mut builder = VariantBuilder::new();
1610 let skip = 5;
1611 {
1612 let mut list = builder.new_list();
1613 for i in take(4) {
1614 let mut object = list.new_object();
1615 for i in take(4) {
1616 let field_name = format!("field{i}");
1617 let mut list = object.new_list(&field_name);
1618 for i in take(3) {
1619 let mut object = list.new_object();
1620 for i in take(3) {
1621 if i % skip != 0 {
1622 object.insert(&format!("field{i}"), i);
1623 }
1624 }
1625 if i % skip != 0 {
1626 object.finish();
1627 }
1628 }
1629 if i % skip != 0 {
1630 list.finish();
1631 }
1632 }
1633 if i % skip != 0 {
1634 object.finish();
1635 }
1636 }
1637 list.finish();
1638 }
1639 let (metadata, value) = builder.finish();
1640 let v1 = Variant::try_new(&metadata, &value).unwrap();
1641
1642 let (metadata, value) = VariantBuilder::new().with_value(v1.clone()).finish();
1643 let v2 = Variant::try_new(&metadata, &value).unwrap();
1644
1645 assert_eq!(format!("{v1:?}"), format!("{v2:?}"));
1646 }
1647
1648 #[test]
1649 fn test_append_variant_bytes_round_trip() {
1650 let mut builder = VariantBuilder::new();
1652 {
1653 let mut obj = builder.new_object();
1654 obj.insert("name", "Alice");
1655 obj.insert("age", 30i32);
1656 {
1657 let mut scores_list = obj.new_list("scores");
1658 scores_list.append_value(95i32);
1659 scores_list.append_value(87i32);
1660 scores_list.append_value(92i32);
1661 scores_list.finish();
1662 }
1663 {
1664 let mut address = obj.new_object("address");
1665 address.insert("street", "123 Main St");
1666 address.insert("city", "Anytown");
1667 address.finish();
1668 }
1669 obj.finish();
1670 }
1671 let (metadata, value1) = builder.finish();
1672 let variant1 = Variant::try_new(&metadata, &value1).unwrap();
1673
1674 let metadata = VariantMetadata::new(&metadata);
1676 let mut metadata = ReadOnlyMetadataBuilder::new(&metadata);
1677 let mut builder2 = ValueBuilder::new();
1678 let state = ParentState::variant(&mut builder2, &mut metadata);
1679 ValueBuilder::append_variant_bytes(state, variant1);
1680 let value2 = builder2.into_inner();
1681
1682 assert_eq!(value1, value2);
1684 }
1685
1686 #[test]
1687 fn test_object_insert_bytes_subset() {
1688 let mut builder = VariantBuilder::new().with_field_names(["new_field", "another_field"]);
1690 {
1691 let mut obj = builder.new_object();
1692 obj.insert("field1", "value1");
1693 obj.insert("field2", 42i32);
1694 obj.insert("field3", true);
1695 obj.insert("field4", "value4");
1696 obj.finish();
1697 }
1698 let (metadata1, value1) = builder.finish();
1699 let original_variant = Variant::try_new(&metadata1, &value1).unwrap();
1700 let original_obj = original_variant.as_object().unwrap();
1701
1702 let metadata2 = VariantMetadata::new(&metadata1);
1704 let mut metadata2 = ReadOnlyMetadataBuilder::new(&metadata2);
1705 let mut builder2 = ValueBuilder::new();
1706 let state = ParentState::variant(&mut builder2, &mut metadata2);
1707 {
1708 let mut obj = ObjectBuilder::new(state, true);
1709
1710 obj.insert_bytes("field1", original_obj.get("field1").unwrap());
1712
1713 obj.insert("new_field", "new_value");
1715
1716 obj.insert_bytes("field3", original_obj.get("field3").unwrap());
1718
1719 obj.insert("another_field", 99i32);
1721
1722 obj.insert_bytes("field2", original_obj.get("field2").unwrap());
1724
1725 obj.finish();
1726 }
1727 let value2 = builder2.into_inner();
1728 let result_variant = Variant::try_new(&metadata1, &value2).unwrap();
1729 let result_obj = result_variant.as_object().unwrap();
1730
1731 assert_eq!(result_obj.len(), 5);
1733 assert_eq!(
1734 result_obj.get("field1").unwrap().as_string().unwrap(),
1735 "value1"
1736 );
1737 assert_eq!(result_obj.get("field2").unwrap().as_int32().unwrap(), 42);
1738 assert!(result_obj.get("field3").unwrap().as_boolean().unwrap());
1739 assert_eq!(
1740 result_obj.get("new_field").unwrap().as_string().unwrap(),
1741 "new_value"
1742 );
1743 assert_eq!(
1744 result_obj.get("another_field").unwrap().as_int32().unwrap(),
1745 99
1746 );
1747 }
1748
1749 #[test]
1750 fn test_complex_nested_filtering_injection() {
1751 let mut builder = VariantBuilder::new().with_field_names([
1754 "active_count",
1755 "active_users",
1756 "computed_score",
1757 "processed_at",
1758 "status",
1759 ]);
1760
1761 {
1762 let mut root_obj = builder.new_object();
1763 root_obj.insert("metadata", "original");
1764
1765 {
1766 let mut users_list = root_obj.new_list("users");
1767
1768 {
1770 let mut user1 = users_list.new_object();
1771 user1.insert("id", 1i32);
1772 user1.insert("name", "Alice");
1773 user1.insert("active", true);
1774 user1.finish();
1775 }
1776
1777 {
1779 let mut user2 = users_list.new_object();
1780 user2.insert("id", 2i32);
1781 user2.insert("name", "Bob");
1782 user2.insert("active", false);
1783 user2.finish();
1784 }
1785
1786 {
1788 let mut user3 = users_list.new_object();
1789 user3.insert("id", 3i32);
1790 user3.insert("name", "Charlie");
1791 user3.insert("active", true);
1792 user3.finish();
1793 }
1794
1795 users_list.finish();
1796 }
1797
1798 root_obj.insert("total_count", 3i32);
1799 root_obj.finish();
1800 }
1801 let (metadata1, value1) = builder.finish();
1802 let original_variant = Variant::try_new(&metadata1, &value1).unwrap();
1803 let original_obj = original_variant.as_object().unwrap();
1804 let original_users = original_obj.get("users").unwrap();
1805 let original_users = original_users.as_list().unwrap();
1806
1807 let metadata2 = VariantMetadata::new(&metadata1);
1809 let mut metadata2 = ReadOnlyMetadataBuilder::new(&metadata2);
1810 let mut builder2 = ValueBuilder::new();
1811 let state = ParentState::variant(&mut builder2, &mut metadata2);
1812 {
1813 let mut root_obj = ObjectBuilder::new(state, true);
1814
1815 root_obj.insert_bytes("metadata", original_obj.get("metadata").unwrap());
1817
1818 root_obj.insert("processed_at", "2024-01-01T00:00:00Z");
1820
1821 {
1822 let mut filtered_users = root_obj.new_list("active_users");
1823
1824 for i in 0..original_users.len() {
1826 let user = original_users.get(i).unwrap();
1827 let user = user.as_object().unwrap();
1828 if user.get("active").unwrap().as_boolean().unwrap() {
1829 {
1830 let mut new_user = filtered_users.new_object();
1831
1832 new_user.insert_bytes("id", user.get("id").unwrap());
1834 new_user.insert_bytes("name", user.get("name").unwrap());
1835
1836 let user_id = user.get("id").unwrap().as_int32().unwrap();
1838 new_user.insert("computed_score", user_id * 10);
1839
1840 new_user.insert("status", "verified");
1842
1843 new_user.finish();
1844 }
1845 }
1846 }
1847
1848 {
1850 let mut new_user = filtered_users.new_object();
1851 new_user.insert("id", 999i32);
1852 new_user.insert("name", "System User");
1853 new_user.insert("computed_score", 0i32);
1854 new_user.insert("status", "system");
1855 new_user.finish();
1856 }
1857
1858 filtered_users.finish();
1859 }
1860
1861 root_obj.insert("active_count", 3i32); root_obj.finish();
1865 }
1866 let value2 = builder2.into_inner();
1867 let result_variant = Variant::try_new(&metadata1, &value2).unwrap();
1868 let result_obj = result_variant.as_object().unwrap();
1869
1870 assert_eq!(
1872 result_obj.get("metadata").unwrap().as_string().unwrap(),
1873 "original"
1874 );
1875 assert_eq!(
1876 result_obj.get("processed_at").unwrap().as_string().unwrap(),
1877 "2024-01-01T00:00:00Z"
1878 );
1879 assert_eq!(
1880 result_obj.get("active_count").unwrap().as_int32().unwrap(),
1881 3
1882 );
1883
1884 let active_users = result_obj.get("active_users").unwrap();
1885 let active_users = active_users.as_list().unwrap();
1886 assert_eq!(active_users.len(), 3);
1887
1888 let alice = active_users.get(0).unwrap();
1890 let alice = alice.as_object().unwrap();
1891 assert_eq!(alice.get("id").unwrap().as_int32().unwrap(), 1);
1892 assert_eq!(alice.get("name").unwrap().as_string().unwrap(), "Alice");
1893 assert_eq!(alice.get("computed_score").unwrap().as_int32().unwrap(), 10);
1894 assert_eq!(
1895 alice.get("status").unwrap().as_string().unwrap(),
1896 "verified"
1897 );
1898 assert!(alice.get("active").is_none()); let charlie = active_users.get(1).unwrap();
1902 let charlie = charlie.as_object().unwrap();
1903 assert_eq!(charlie.get("id").unwrap().as_int32().unwrap(), 3);
1904 assert_eq!(charlie.get("name").unwrap().as_string().unwrap(), "Charlie");
1905 assert_eq!(
1906 charlie.get("computed_score").unwrap().as_int32().unwrap(),
1907 30
1908 );
1909 assert_eq!(
1910 charlie.get("status").unwrap().as_string().unwrap(),
1911 "verified"
1912 );
1913
1914 let system_user = active_users.get(2).unwrap();
1916 let system_user = system_user.as_object().unwrap();
1917 assert_eq!(system_user.get("id").unwrap().as_int32().unwrap(), 999);
1918 assert_eq!(
1919 system_user.get("name").unwrap().as_string().unwrap(),
1920 "System User"
1921 );
1922 assert_eq!(
1923 system_user
1924 .get("computed_score")
1925 .unwrap()
1926 .as_int32()
1927 .unwrap(),
1928 0
1929 );
1930 assert_eq!(
1931 system_user.get("status").unwrap().as_string().unwrap(),
1932 "system"
1933 );
1934 }
1935}