This is an automated email from the ASF dual-hosted git repository.
kriskras99 pushed a commit to branch feat/full_enum_support
in repository https://gitbox.apache.org/repos/asf/avro-rs.git
The following commit(s) were added to refs/heads/feat/full_enum_support by this
push:
new c91fa4c wip
c91fa4c is described below
commit c91fa4c236d33c346f6578beb4464a74b3b13aa2
Author: default <[email protected]>
AuthorDate: Thu Mar 19 15:38:08 2026 +0000
wip
---
avro/src/bigdecimal.rs | 25 ++++---
avro/src/duration.rs | 2 +
avro/src/lib.rs | 1 +
avro/src/serde/de.rs | 2 +
avro/src/serde/deser_schema/mod.rs | 2 +-
avro/src/serde/mod.rs | 2 +
avro/src/serde/ser.rs | 2 +
avro/src/serde/ser_schema/mod.rs | 27 +++++++-
avro/src/serde/ser_schema/record/mod.rs | 89 +++++++++++++++++++------
avro/src/serde/with.rs | 4 ++
avro/src/types.rs | 4 ++
avro/tests/avro-rs-226.rs | 22 +++---
avro/tests/avro-rs-285-bytes_deserialization.rs | 17 ++---
avro/tests/schema.rs | 13 ++--
avro/tests/union_schema.rs | 81 ++++++++++------------
15 files changed, 182 insertions(+), 111 deletions(-)
diff --git a/avro/src/bigdecimal.rs b/avro/src/bigdecimal.rs
index ee26ee1..28eeb51 100644
--- a/avro/src/bigdecimal.rs
+++ b/avro/src/bigdecimal.rs
@@ -70,13 +70,16 @@ pub(crate) fn deserialize_big_decimal(mut bytes: &[u8]) ->
AvroResult<BigDecimal
#[cfg(test)]
mod tests {
use super::*;
- use crate::{Codec, Reader, Schema, Writer, error::Error, from_value,
types::Record};
+ use crate::{
+ Codec, Reader, Schema, Writer, error::Error,
reader::datum::GenericDatumReader,
+ types::Record, writer::datum::GenericDatumWriter,
+ };
use apache_avro_test_helper::TestResult;
use bigdecimal::{One, Zero};
use pretty_assertions::assert_eq;
use std::{
fs::File,
- io::BufReader,
+ io::{BufReader, Cursor},
ops::{Div, Mul},
str::FromStr,
};
@@ -206,18 +209,14 @@ mod tests {
let test = Test::default();
- // write a record
- let mut writer = Writer::new(&schema, Vec::new())?;
- writer.append_ser(test.clone())?;
-
- let wrote_data = writer.into_inner()?;
-
- // read record
- let mut reader = Reader::new(&wrote_data[..])?;
-
- let value = reader.next().unwrap()?;
+ let serialized = GenericDatumWriter::builder(&schema)
+ .build()?
+ .write_ser_to_vec(&test)?;
+ let value: Test = GenericDatumReader::builder(&schema)
+ .build()?
+ .read_deser(&mut Cursor::new(serialized))?;
- assert_eq!(test, from_value::<Test>(&value)?);
+ assert_eq!(value, test);
Ok(())
}
diff --git a/avro/src/duration.rs b/avro/src/duration.rs
index eecfca1..41a2e43 100644
--- a/avro/src/duration.rs
+++ b/avro/src/duration.rs
@@ -209,6 +209,7 @@ mod tests {
use crate::types::Value;
use apache_avro_test_helper::TestResult;
+ #[expect(deprecated)]
#[test]
fn avro_rs_382_duration_from_value() -> TestResult {
let val = Value::Duration(Duration::new(Months::new(7), Days::new(4),
Millis::new(45)));
@@ -219,6 +220,7 @@ mod tests {
Ok(())
}
+ #[expect(deprecated)]
#[test]
fn avro_rs_382_duration_to_value() -> TestResult {
let duration = Duration::new(Months::new(7), Days::new(4),
Millis::new(45));
diff --git a/avro/src/lib.rs b/avro/src/lib.rs
index 314d596..0b6ca0f 100644
--- a/avro/src/lib.rs
+++ b/avro/src/lib.rs
@@ -101,6 +101,7 @@ pub use reader::{
single_object::{GenericSingleObjectReader, SpecificSingleObjectReader},
};
pub use schema::Schema;
+#[expect(deprecated)]
pub use serde::{AvroSchema, AvroSchemaComponent, from_value, to_value};
pub use uuid::Uuid;
#[expect(
diff --git a/avro/src/serde/de.rs b/avro/src/serde/de.rs
index 82d40d5..0fb6199 100644
--- a/avro/src/serde/de.rs
+++ b/avro/src/serde/de.rs
@@ -938,11 +938,13 @@ impl<'de> de::Deserializer<'de> for StringDeserializer {
///
/// This conversion can fail if the structure of the `Value` does not match the
/// structure expected by `D`.
+#[deprecated(since = "0.22.0")]
pub fn from_value<'de, D: Deserialize<'de>>(value: &'de Value) -> Result<D,
Error> {
let de = Deserializer::new(value);
D::deserialize(de)
}
+#[expect(deprecated)]
#[cfg(test)]
mod tests {
use num_bigint::BigInt;
diff --git a/avro/src/serde/deser_schema/mod.rs
b/avro/src/serde/deser_schema/mod.rs
index f7c8dc6..1d1b4df 100644
--- a/avro/src/serde/deser_schema/mod.rs
+++ b/avro/src/serde/deser_schema/mod.rs
@@ -1570,7 +1570,7 @@ mod tests {
assert_roundtrip(uuid, &schema, Vec::new())?;
let buf = GenericDatumWriter::builder(&alt_schema)
- // .human_readable(true)
+ .human_readable(true)
.build()?
.write_ser_to_vec(&uuid)?;
diff --git a/avro/src/serde/mod.rs b/avro/src/serde/mod.rs
index 3b1718b..8900d45 100644
--- a/avro/src/serde/mod.rs
+++ b/avro/src/serde/mod.rs
@@ -115,8 +115,10 @@ pub(crate) mod ser_schema;
mod util;
mod with;
+#[expect(deprecated)]
pub use de::from_value;
pub use derive::{AvroSchema, AvroSchemaComponent};
+#[expect(deprecated)]
pub use ser::to_value;
pub use with::{
array, array_opt, bigdecimal, bigdecimal_opt, bytes, bytes_opt, fixed,
fixed_opt, slice,
diff --git a/avro/src/serde/ser.rs b/avro/src/serde/ser.rs
index efd6fe8..d102ac1 100644
--- a/avro/src/serde/ser.rs
+++ b/avro/src/serde/ser.rs
@@ -482,10 +482,12 @@ impl ser::SerializeStructVariant for
StructVariantSerializer {
/// attribute. Please use [`Writer::append_ser`] if that's the case.
///
/// [`Writer::append_ser`]: crate::Writer::append_ser
+#[deprecated(since = "0.22.0")]
pub fn to_value<S: Serialize>(value: S) -> Result<Value, Error> {
value.serialize(Serializer)
}
+#[expect(deprecated)]
#[cfg(test)]
mod tests {
use super::*;
diff --git a/avro/src/serde/ser_schema/mod.rs b/avro/src/serde/ser_schema/mod.rs
index c971bff..2ba62a6 100644
--- a/avro/src/serde/ser_schema/mod.rs
+++ b/avro/src/serde/ser_schema/mod.rs
@@ -1928,6 +1928,9 @@ mod tests {
struct Foo {
a: String,
b: String,
+ c: i64,
+ d: f64,
+ e: i64,
}
let schema = Schema::parse_str(
r#"
@@ -1942,6 +1945,18 @@ mod tests {
{
"name":"a",
"type":"string"
+ },
+ {
+ "name":"d",
+ "type":"double"
+ },
+ {
+ "name":"e",
+ "type":"long"
+ },
+ {
+ "name":"c",
+ "type":"long"
}
]
}
@@ -1952,13 +1967,19 @@ mod tests {
let foo = Foo {
a: "Hello".into(),
b: "World".into(),
+ c: 42,
+ d: std::f64::consts::PI,
+ e: 5,
};
- // Serializing fields out of order is NOT supported
- assert_serialize_err(
+
+ assert_serialize(
foo,
&schema,
&names,
- r#"Missing default for skipped field 'b' of schema RecordSchema {
name: Name { name: "Foo", .. }, fields: [RecordField { name: "b", schema:
String, .. }, RecordField { name: "a", schema: String, .. }], .. }"#,
+ &[
+ 10, b'W', b'o', b'r', b'l', b'd', 10, b'H', b'e', b'l', b'l',
b'o', 24, 45, 68, 84,
+ 251, 33, 9, 64, 10, 84,
+ ],
);
Ok(())
diff --git a/avro/src/serde/ser_schema/record/mod.rs
b/avro/src/serde/ser_schema/record/mod.rs
index 0d44828..ac31391 100644
--- a/avro/src/serde/ser_schema/record/mod.rs
+++ b/avro/src/serde/ser_schema/record/mod.rs
@@ -26,12 +26,18 @@ use crate::{Error, Schema};
use serde::Serialize;
use serde::ser::{SerializeMap, SerializeStruct, SerializeStructVariant};
use std::borrow::Borrow;
+use std::cmp::Ordering;
+use std::collections::HashMap;
use std::io::Write;
pub struct RecordSerializer<'s, 'w, W: Write, S: Borrow<Schema>> {
writer: &'w mut W,
record: &'s RecordSchema,
config: Config<'s, S>,
+ /// Cache fields received out-of-order
+ cache: HashMap<usize, Vec<u8>>,
+ /// The position of the current map entry being written
+ map_position: Option<usize>,
/// The field that should be written now.
field_position: usize,
bytes_written: usize,
@@ -48,6 +54,8 @@ impl<'s, 'w, W: Write, S: Borrow<Schema>>
RecordSerializer<'s, 'w, W, S> {
writer,
record,
config,
+ cache: HashMap::new(),
+ map_position: None,
field_position: 0,
bytes_written: bytes_written.unwrap_or(0),
}
@@ -89,21 +97,49 @@ impl<'s, 'w, W: Write, S: Borrow<Schema>>
RecordSerializer<'s, 'w, W, S> {
position: usize,
value: &T,
) -> Result<(), Error> {
- // Serialize any skipped fields using their default value
- while self.field_position < position {
- self.serialize_default(self.field_position)?;
- }
let field = &self.record.fields[position];
- self.bytes_written += value
- .serialize(SchemaAwareSerializer::new(
- self.writer,
- &field.schema,
- self.config,
- )?)
- .map_err(|e| self.field_error(self.field_position, e))?;
- self.field_position += 1;
-
- Ok(())
+ match self.field_position.cmp(&position) {
+ Ordering::Equal => {
+ // Field received in the right order
+ self.bytes_written += value
+ .serialize(SchemaAwareSerializer::new(
+ self.writer,
+ &field.schema,
+ self.config,
+ )?)
+ .map_err(|e| self.field_error(self.field_position, e))?;
+ self.field_position += 1;
+
+ // Write any fields that were already received and can now be
written
+ while let Some(bytes) =
self.cache.remove(&self.field_position) {
+
self.writer.write_all(&bytes).map_err(Details::WriteBytes)?;
+ self.bytes_written += bytes.len();
+ self.field_position += 1;
+ }
+
+ Ok(())
+ }
+ Ordering::Less => {
+ // Another field needs to be written first, so cache this field
+ let mut bytes = Vec::new();
+ value
+ .serialize(SchemaAwareSerializer::new(
+ &mut bytes,
+ &field.schema,
+ self.config,
+ )?)
+ .map_err(|e| self.field_error(self.field_position, e))?;
+ if self.cache.insert(position, bytes).is_some() {
+ Err(Details::FieldNameDuplicate(field.name.clone()).into())
+ } else {
+ Ok(())
+ }
+ }
+ Ordering::Greater => {
+ // This field is already written to the writer so we got a
duplicate
+ Err(Details::FieldNameDuplicate(field.name.clone()).into())
+ }
+ }
}
fn serialize_default(&mut self, position: usize) -> Result<(), Error> {
@@ -171,10 +207,7 @@ impl<'s, 'w, W: Write, S: Borrow<Schema>> SerializeMap for
RecordSerializer<'s,
{
let name = key.serialize(StringSerializer)?;
if let Some(position) = self.record.lookup.get(&name).copied() {
- // Write any skipped fields now, so that `serialize_value` can
just call `serialize_next_field`
- while self.field_position < position {
- self.serialize_default(self.field_position)?;
- }
+ self.map_position = Some(position);
Ok(())
} else {
Err(Details::FieldName(name.to_string()).into())
@@ -185,13 +218,29 @@ impl<'s, 'w, W: Write, S: Borrow<Schema>> SerializeMap
for RecordSerializer<'s,
where
T: ?Sized + Serialize,
{
- // `serialize_key` made sure that all skipped fields have been written
- self.serialize_next_field(self.field_position, value)
+ self.serialize_next_field(
+ self.map_position
+ .expect("serialze_value called without calling serialize_key"),
+ value,
+ )
}
fn end(self) -> Result<Self::Ok, Self::Error> {
self.end()
}
+
+ fn serialize_entry<K, V>(&mut self, key: &K, value: &V) -> Result<(),
Self::Error>
+ where
+ K: ?Sized + Serialize,
+ V: ?Sized + Serialize,
+ {
+ let name = key.serialize(StringSerializer)?;
+ if let Some(position) = self.record.lookup.get(&name).copied() {
+ self.serialize_next_field(position, value)
+ } else {
+ Err(Details::FieldName(name.to_string()).into())
+ }
+ }
}
impl<'s, 'w, W: Write, S: Borrow<Schema>> SerializeStructVariant
diff --git a/avro/src/serde/with.rs b/avro/src/serde/with.rs
index 74c0a3a..1d0074e 100644
--- a/avro/src/serde/with.rs
+++ b/avro/src/serde/with.rs
@@ -814,9 +814,11 @@ pub mod array_opt {
#[cfg(test)]
mod tests {
+ #[expect(deprecated)]
use crate::{Schema, from_value, to_value, types::Value};
use serde::{Deserialize, Serialize};
+ #[expect(deprecated)]
#[test]
fn avro_3631_validate_schema_for_struct_with_byte_types() {
#[derive(Debug, Serialize)]
@@ -884,6 +886,7 @@ mod tests {
assert!(value.validate(&schema));
}
+ #[expect(deprecated)]
#[test]
fn avro_3631_deserialize_value_to_struct_with_byte_types() {
#[derive(Debug, Deserialize, PartialEq)]
@@ -1010,6 +1013,7 @@ mod tests {
assert_eq!(expected, from_value(&value).unwrap());
}
+ #[expect(deprecated)]
#[test]
fn avro_3631_serialize_struct_to_value_with_byte_types() {
#[derive(Debug, Serialize)]
diff --git a/avro/src/types.rs b/avro/src/types.rs
index b6f658c..2af67c9 100644
--- a/avro/src/types.rs
+++ b/avro/src/types.rs
@@ -1228,6 +1228,7 @@ impl Value {
#[cfg(test)]
mod tests {
+ #[expect(deprecated)]
use super::*;
use crate::{
duration::{Days, Millis, Months},
@@ -2788,6 +2789,7 @@ Field with name '"b"' is not a member of the map items"#,
Ok(())
}
+ #[expect(deprecated)]
#[test]
fn test_avro_3460_validation_with_refs_real_struct() -> TestResult {
use serde::Serialize;
@@ -2874,6 +2876,7 @@ Field with name '"b"' is not a member of the map items"#,
Ok(())
}
+ #[expect(deprecated)]
fn avro_3674_with_or_without_namespace(with_namespace: bool) -> TestResult
{
use serde::Serialize;
@@ -2965,6 +2968,7 @@ Field with name '"b"' is not a member of the map items"#,
avro_3674_with_or_without_namespace(true)
}
+ #[expect(deprecated)]
fn avro_3688_schema_resolution_panic(set_field_b: bool) -> TestResult {
use serde::{Deserialize, Serialize};
diff --git a/avro/tests/avro-rs-226.rs b/avro/tests/avro-rs-226.rs
index fd1b6d2..45d6f1e 100644
--- a/avro/tests/avro-rs-226.rs
+++ b/avro/tests/avro-rs-226.rs
@@ -15,7 +15,9 @@
// specific language governing permissions and limitations
// under the License.
-use apache_avro::{AvroSchema, Schema, Writer, from_value};
+use apache_avro::{
+ AvroSchema, Schema, reader::datum::GenericDatumReader,
writer::datum::GenericDatumWriter,
+};
use apache_avro_test_helper::TestResult;
use serde::{Deserialize, Serialize, de::DeserializeOwned};
use std::fmt::Debug;
@@ -24,17 +26,13 @@ fn ser_deser<T>(schema: &Schema, record: T) -> TestResult
where
T: Serialize + DeserializeOwned + Debug + PartialEq + Clone,
{
- let record2 = record.clone();
- let mut writer = Writer::new(schema, vec![])?;
- writer.append_ser(record)?;
- let bytes_written = writer.into_inner()?;
-
- let reader = apache_avro::Reader::new(&bytes_written[..])?;
- for value in reader {
- let value = value?;
- let deserialized = from_value::<T>(&value)?;
- assert_eq!(deserialized, record2);
- }
+ let serialized = GenericDatumWriter::builder(schema)
+ .build()?
+ .write_ser_to_vec(&record)?;
+ let deserialized: T = GenericDatumReader::builder(schema)
+ .build()?
+ .read_deser(&mut &serialized[..])?;
+ assert_eq!(deserialized, record);
Ok(())
}
diff --git a/avro/tests/avro-rs-285-bytes_deserialization.rs
b/avro/tests/avro-rs-285-bytes_deserialization.rs
index b9ebe80..5dd5e4e 100644
--- a/avro/tests/avro-rs-285-bytes_deserialization.rs
+++ b/avro/tests/avro-rs-285-bytes_deserialization.rs
@@ -15,10 +15,12 @@
// specific language governing permissions and limitations
// under the License.
+use apache_avro::Reader;
use apache_avro_test_helper::TestResult;
use serde::{Deserialize, Serialize};
#[derive(Debug, Deserialize, PartialEq, Serialize)]
+#[serde(rename = "SimpleRecord")]
struct ExampleByteArray {
#[serde(with = "apache_avro::serde::bytes_opt")]
data_bytes: Option<Vec<u8>>,
@@ -26,6 +28,7 @@ struct ExampleByteArray {
}
#[derive(Deserialize, Serialize)]
+#[serde(rename = "SimpleRecord")]
struct ExampleByteArrayFiltered {
description: Option<String>,
}
@@ -70,10 +73,9 @@ fn avro_rs_285_bytes_deserialization_round_trip() ->
TestResult {
let avro_data = writer.into_inner()?;
// deserialize Avro binary data back into ExampleByteArray structs
- let reader = apache_avro::Reader::new(&avro_data[..])?;
- let deserialized_records: Vec<ExampleByteArray> = reader
- .map(|value|
apache_avro::from_value::<ExampleByteArray>(&value.unwrap()).unwrap())
- .collect();
+ let deserialized_records = Reader::new(&avro_data[..])?
+ .into_deser_iter()
+ .collect::<Result<Vec<ExampleByteArray>, _>>()?;
assert_eq!(records, deserialized_records);
Ok(())
@@ -118,10 +120,9 @@ fn avro_rs_285_bytes_deserialization_filtered_round_trip()
-> TestResult {
let avro_data = writer.into_inner()?;
// deserialize Avro binary data back into ExampleByteArrayFiltered structs
- let reader = apache_avro::Reader::new(&avro_data[..])?;
- let deserialized_records: Vec<ExampleByteArrayFiltered> = reader
- .map(|value|
apache_avro::from_value::<ExampleByteArrayFiltered>(&value.unwrap()).unwrap())
- .collect();
+ let deserialized_records = Reader::new(&avro_data[..])?
+ .into_deser_iter()
+ .collect::<Result<Vec<ExampleByteArrayFiltered>, _>>()?;
assert_eq!(records.len(), deserialized_records.len());
diff --git a/avro/tests/schema.rs b/avro/tests/schema.rs
index 89e328a..0c322aa 100644
--- a/avro/tests/schema.rs
+++ b/avro/tests/schema.rs
@@ -15,14 +15,13 @@
// specific language governing permissions and limitations
// under the License.
+use apache_avro::to_value;
use apache_avro::writer::datum::GenericDatumWriter;
use apache_avro::{
Codec, Error, Reader, Schema, Writer,
error::Details,
- from_value,
reader::datum::GenericDatumReader,
schema::{EnumSchema, FixedSchema, Name, RecordField, RecordSchema},
- to_value,
types::{Record, Value},
};
use apache_avro_test_helper::{
@@ -837,7 +836,7 @@ fn avro_old_issue_47() -> TestResult {
let schema_str = r#"
{
"type": "record",
- "name": "my_record",
+ "name": "MyRecord",
"fields": [
{"name": "a", "type": "long"},
{"name": "b", "type": "string"}
@@ -858,15 +857,13 @@ fn avro_old_issue_47() -> TestResult {
a: 1,
};
- let ser_value = to_value(record.clone())?;
let serialized_bytes = GenericDatumWriter::builder(&schema)
.build()?
- .write_value_to_vec(ser_value)?;
+ .write_ser_to_vec(&record)?;
- let de_value = GenericDatumReader::builder(&schema)
+ let deserialized_record: MyRecord = GenericDatumReader::builder(&schema)
.build()?
- .read_value(&mut &*serialized_bytes)?;
- let deserialized_record = from_value::<MyRecord>(&de_value)?;
+ .read_deser(&mut &*serialized_bytes)?;
assert_eq!(record, deserialized_record);
Ok(())
diff --git a/avro/tests/union_schema.rs b/avro/tests/union_schema.rs
index 892b69b..04a9709 100644
--- a/avro/tests/union_schema.rs
+++ b/avro/tests/union_schema.rs
@@ -15,8 +15,11 @@
// specific language governing permissions and limitations
// under the License.
-use apache_avro::{AvroResult, Codec, Reader, Schema, Writer, from_value};
+use apache_avro::{Schema, reader::datum::GenericDatumReader,
writer::datum::GenericDatumWriter};
+use apache_avro_test_helper::TestResult;
+use pretty_assertions::assert_eq;
use serde::{Deserialize, Serialize, de::DeserializeOwned};
+use std::fmt::Debug;
static SCHEMA_A_STR: &str = r#"{
"name": "A",
@@ -65,26 +68,25 @@ struct C {
field_c: String,
}
-fn encode_decode<T>(input: &T, schema: &Schema, schemata: &[Schema]) ->
AvroResult<T>
+#[track_caller]
+fn assert_roundtrip<T>(input: &T, schema: &Schema, schemata: &[Schema]) ->
TestResult
where
- T: DeserializeOwned + Serialize,
+ T: DeserializeOwned + Serialize + PartialEq + Debug,
{
- let mut encoded: Vec<u8> = Vec::new();
- let mut writer =
- Writer::with_schemata(schema, schemata.iter().collect(), &mut encoded,
Codec::Null)?;
- writer.append_ser(input)?;
- writer.flush()?;
- drop(writer); //drop the writer so that `encoded` is no more referenced
mutably
-
- let mut reader = Reader::builder(encoded.as_slice())
- .reader_schema(schema)
- .schemata(schemata.iter().collect())
- .build()?;
- from_value::<T>(&reader.next().expect("")?)
+ let serialized = GenericDatumWriter::builder(schema)
+ .schemata(schemata.iter().collect())?
+ .build()?
+ .write_ser_to_vec(input)?;
+ let deserialized: T = GenericDatumReader::builder(schema)
+ .writer_schemata(schemata.iter().collect())?
+ .build()?
+ .read_deser(&mut &serialized[..])?;
+ assert_eq!(&deserialized, input);
+ Ok(())
}
#[test]
-fn test_avro_3901_union_schema_round_trip_no_null() -> AvroResult<()> {
+fn test_avro_3901_union_schema_round_trip_no_null() -> TestResult {
let schemata: Vec<Schema> =
Schema::parse_list([SCHEMA_A_STR, SCHEMA_B_STR,
SCHEMA_C_STR]).expect("parsing schemata");
@@ -92,15 +94,13 @@ fn test_avro_3901_union_schema_round_trip_no_null() ->
AvroResult<()> {
field_union: (UnionAB::A(A { field_a: 45.5 })),
field_c: "foo".to_string(),
};
- let output = encode_decode(&input, &schemata[2], &schemata)?;
- assert_eq!(input, output);
+ assert_roundtrip(&input, &schemata[2], &schemata)?;
let input = C {
field_union: (UnionAB::B(B { field_b: 73 })),
field_c: "bar".to_string(),
};
- let output = encode_decode(&input, &schemata[2], &schemata)?;
- assert_eq!(input, output);
+ assert_roundtrip(&input, &schemata[2], &schemata)?;
Ok(())
}
@@ -128,7 +128,7 @@ struct D {
}
#[test]
-fn test_avro_3901_union_schema_round_trip_null_at_start() -> AvroResult<()> {
+fn test_avro_3901_union_schema_round_trip_null_at_start() -> TestResult {
let schemata: Vec<Schema> =
Schema::parse_list([SCHEMA_A_STR, SCHEMA_B_STR,
SCHEMA_D_STR]).expect("parsing schemata");
@@ -136,22 +136,19 @@ fn test_avro_3901_union_schema_round_trip_null_at_start()
-> AvroResult<()> {
field_union: UnionNoneAB::A(A { field_a: 54.25 }),
field_d: "fooy".to_string(),
};
- let output = encode_decode(&input, &schemata[2], &schemata)?;
- assert_eq!(input, output);
+ assert_roundtrip(&input, &schemata[2], &schemata)?;
let input = D {
field_union: UnionNoneAB::None,
field_d: "fooyy".to_string(),
};
- let output = encode_decode(&input, &schemata[2], &schemata)?;
- assert_eq!(input, output);
+ assert_roundtrip(&input, &schemata[2], &schemata)?;
let input = D {
field_union: UnionNoneAB::B(B { field_b: 103 }),
field_d: "foov".to_string(),
};
- let output = encode_decode(&input, &schemata[2], &schemata)?;
- assert_eq!(input, output);
+ assert_roundtrip(&input, &schemata[2], &schemata)?;
Ok(())
}
@@ -179,7 +176,7 @@ struct E {
}
#[test]
-fn test_avro_3901_union_schema_round_trip_with_out_of_order_null() ->
AvroResult<()> {
+fn test_avro_3901_union_schema_round_trip_with_out_of_order_null() ->
TestResult {
let schemata: Vec<Schema> =
Schema::parse_list([SCHEMA_A_STR, SCHEMA_B_STR,
SCHEMA_E_STR]).expect("parsing schemata");
@@ -187,22 +184,19 @@ fn
test_avro_3901_union_schema_round_trip_with_out_of_order_null() -> AvroResult
field_union: UnionANoneB::A(A { field_a: 23.75 }),
field_e: "barme".to_string(),
};
- let output = encode_decode(&input, &schemata[2], &schemata)?;
- assert_eq!(input, output);
+ assert_roundtrip(&input, &schemata[2], &schemata)?;
let input = E {
field_union: UnionANoneB::None,
field_e: "barme2".to_string(),
};
- let output = encode_decode(&input, &schemata[2], &schemata)?;
- assert_eq!(input, output);
+ assert_roundtrip(&input, &schemata[2], &schemata)?;
let input = E {
field_union: UnionANoneB::B(B { field_b: 89 }),
field_e: "barme3".to_string(),
};
- let output = encode_decode(&input, &schemata[2], &schemata)?;
- assert_eq!(input, output);
+ assert_roundtrip(&input, &schemata[2], &schemata)?;
Ok(())
}
@@ -230,7 +224,7 @@ struct F {
}
#[test]
-fn test_avro_3901_union_schema_round_trip_with_end_null() -> AvroResult<()> {
+fn test_avro_3901_union_schema_round_trip_with_end_null() -> TestResult {
let schemata: Vec<Schema> =
Schema::parse_list([SCHEMA_A_STR, SCHEMA_B_STR,
SCHEMA_F_STR]).expect("parsing schemata");
@@ -238,22 +232,19 @@ fn test_avro_3901_union_schema_round_trip_with_end_null()
-> AvroResult<()> {
field_union: UnionABNone::A(A { field_a: 23.75 }),
field_f: "aoe".to_string(),
};
- let output = encode_decode(&input, &schemata[2], &schemata)?;
- assert_eq!(input, output);
+ assert_roundtrip(&input, &schemata[2], &schemata)?;
let input = F {
field_union: UnionABNone::B(B { field_b: 89 }),
field_f: "aoe3".to_string(),
};
- let output = encode_decode(&input, &schemata[2], &schemata)?;
- assert_eq!(input, output);
+ assert_roundtrip(&input, &schemata[2], &schemata)?;
let input = F {
field_union: UnionABNone::None,
field_f: "aoee2".to_string(),
};
- let output = encode_decode(&input, &schemata[2], &schemata)?;
- assert_eq!(input, output);
+ assert_roundtrip(&input, &schemata[2], &schemata)?;
Ok(())
}
@@ -321,22 +312,20 @@ struct H {
}
#[test]
-fn test_avro_3901_union_schema_as_optional() -> AvroResult<()> {
+fn test_avro_3901_union_schema_as_optional() -> TestResult {
let schemata: Vec<Schema> =
Schema::parse_list([SCHEMA_H_STR]).expect("parsing schemata");
let input = H {
field_union: Some(23),
field_h: "aaa".to_string(),
};
- let output = encode_decode(&input, &schemata[0], &schemata)?;
- assert_eq!(input, output);
+ assert_roundtrip(&input, &schemata[0], &schemata)?;
let input = H {
field_union: None,
field_h: "bbb".to_string(),
};
- let output = encode_decode(&input, &schemata[0], &schemata)?;
- assert_eq!(input, output);
+ assert_roundtrip(&input, &schemata[0], &schemata)?;
Ok(())
}
