serializer_failure.rs (7354B)
1 use serde::Serialize; 2 use serde::ser::{self, SerializeStruct}; 3 4 #[derive(Clone, Copy)] 5 enum FailingSerializeFailure { 6 Start, 7 Field(usize), 8 End, 9 } 10 11 struct FailingStructSerializer { 12 failure: FailingSerializeFailure, 13 } 14 15 struct FailingSerializeStruct { 16 field_index: usize, 17 failure: FailingSerializeFailure, 18 } 19 20 #[derive(Debug)] 21 struct FailingSerializeError; 22 23 impl core::fmt::Display for FailingSerializeError { 24 fn fmt(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { 25 formatter.write_str("intentional serializer failure") 26 } 27 } 28 29 impl std::error::Error for FailingSerializeError {} 30 31 impl ser::Error for FailingSerializeError { 32 fn custom<T>(_message: T) -> Self 33 where 34 T: core::fmt::Display, 35 { 36 Self 37 } 38 } 39 40 impl FailingStructSerializer { 41 fn start() -> Self { 42 Self { 43 failure: FailingSerializeFailure::Start, 44 } 45 } 46 47 fn field(field_index: usize) -> Self { 48 Self { 49 failure: FailingSerializeFailure::Field(field_index), 50 } 51 } 52 53 fn end() -> Self { 54 Self { 55 failure: FailingSerializeFailure::End, 56 } 57 } 58 } 59 60 impl ser::Serializer for FailingStructSerializer { 61 type Ok = (); 62 type Error = FailingSerializeError; 63 type SerializeSeq = ser::Impossible<(), FailingSerializeError>; 64 type SerializeTuple = ser::Impossible<(), FailingSerializeError>; 65 type SerializeTupleStruct = ser::Impossible<(), FailingSerializeError>; 66 type SerializeTupleVariant = ser::Impossible<(), FailingSerializeError>; 67 type SerializeMap = ser::Impossible<(), FailingSerializeError>; 68 type SerializeStruct = FailingSerializeStruct; 69 type SerializeStructVariant = ser::Impossible<(), FailingSerializeError>; 70 71 fn serialize_bool(self, _value: bool) -> Result<Self::Ok, Self::Error> { 72 Err(FailingSerializeError) 73 } 74 75 fn serialize_i8(self, _value: i8) -> Result<Self::Ok, Self::Error> { 76 Err(FailingSerializeError) 77 } 78 79 fn serialize_i16(self, _value: i16) -> Result<Self::Ok, Self::Error> { 80 Err(FailingSerializeError) 81 } 82 83 fn serialize_i32(self, _value: i32) -> Result<Self::Ok, Self::Error> { 84 Err(FailingSerializeError) 85 } 86 87 fn serialize_i64(self, _value: i64) -> Result<Self::Ok, Self::Error> { 88 Err(FailingSerializeError) 89 } 90 91 fn serialize_u8(self, _value: u8) -> Result<Self::Ok, Self::Error> { 92 Err(FailingSerializeError) 93 } 94 95 fn serialize_u16(self, _value: u16) -> Result<Self::Ok, Self::Error> { 96 Err(FailingSerializeError) 97 } 98 99 fn serialize_u32(self, _value: u32) -> Result<Self::Ok, Self::Error> { 100 Err(FailingSerializeError) 101 } 102 103 fn serialize_u64(self, _value: u64) -> Result<Self::Ok, Self::Error> { 104 Err(FailingSerializeError) 105 } 106 107 fn serialize_f32(self, _value: f32) -> Result<Self::Ok, Self::Error> { 108 Err(FailingSerializeError) 109 } 110 111 fn serialize_f64(self, _value: f64) -> Result<Self::Ok, Self::Error> { 112 Err(FailingSerializeError) 113 } 114 115 fn serialize_char(self, _value: char) -> Result<Self::Ok, Self::Error> { 116 Err(FailingSerializeError) 117 } 118 119 fn serialize_str(self, _value: &str) -> Result<Self::Ok, Self::Error> { 120 Err(FailingSerializeError) 121 } 122 123 fn serialize_bytes(self, _value: &[u8]) -> Result<Self::Ok, Self::Error> { 124 Err(FailingSerializeError) 125 } 126 127 fn serialize_none(self) -> Result<Self::Ok, Self::Error> { 128 Err(FailingSerializeError) 129 } 130 131 fn serialize_some<T>(self, _value: &T) -> Result<Self::Ok, Self::Error> 132 where 133 T: ?Sized + Serialize, 134 { 135 Err(FailingSerializeError) 136 } 137 138 fn serialize_unit(self) -> Result<Self::Ok, Self::Error> { 139 Err(FailingSerializeError) 140 } 141 142 fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> { 143 Err(FailingSerializeError) 144 } 145 146 fn serialize_unit_variant( 147 self, 148 _name: &'static str, 149 _variant_index: u32, 150 _variant: &'static str, 151 ) -> Result<Self::Ok, Self::Error> { 152 Err(FailingSerializeError) 153 } 154 155 fn serialize_newtype_struct<T>( 156 self, 157 _name: &'static str, 158 _value: &T, 159 ) -> Result<Self::Ok, Self::Error> 160 where 161 T: ?Sized + Serialize, 162 { 163 Err(FailingSerializeError) 164 } 165 166 fn serialize_newtype_variant<T>( 167 self, 168 _name: &'static str, 169 _variant_index: u32, 170 _variant: &'static str, 171 _value: &T, 172 ) -> Result<Self::Ok, Self::Error> 173 where 174 T: ?Sized + Serialize, 175 { 176 Err(FailingSerializeError) 177 } 178 179 fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> { 180 Err(FailingSerializeError) 181 } 182 183 fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, Self::Error> { 184 Err(FailingSerializeError) 185 } 186 187 fn serialize_tuple_struct( 188 self, 189 _name: &'static str, 190 _len: usize, 191 ) -> Result<Self::SerializeTupleStruct, Self::Error> { 192 Err(FailingSerializeError) 193 } 194 195 fn serialize_tuple_variant( 196 self, 197 _name: &'static str, 198 _variant_index: u32, 199 _variant: &'static str, 200 _len: usize, 201 ) -> Result<Self::SerializeTupleVariant, Self::Error> { 202 Err(FailingSerializeError) 203 } 204 205 fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> { 206 Err(FailingSerializeError) 207 } 208 209 fn serialize_struct( 210 self, 211 _name: &'static str, 212 _len: usize, 213 ) -> Result<Self::SerializeStruct, Self::Error> { 214 match self.failure { 215 FailingSerializeFailure::Start => Err(FailingSerializeError), 216 failure => Ok(FailingSerializeStruct { 217 field_index: 0, 218 failure, 219 }), 220 } 221 } 222 223 fn serialize_struct_variant( 224 self, 225 _name: &'static str, 226 _variant_index: u32, 227 _variant: &'static str, 228 _len: usize, 229 ) -> Result<Self::SerializeStructVariant, Self::Error> { 230 Err(FailingSerializeError) 231 } 232 } 233 234 impl SerializeStruct for FailingSerializeStruct { 235 type Ok = (); 236 type Error = FailingSerializeError; 237 238 fn serialize_field<T>(&mut self, _key: &'static str, _value: &T) -> Result<(), Self::Error> 239 where 240 T: ?Sized + Serialize, 241 { 242 self.field_index += 1; 243 match self.failure { 244 FailingSerializeFailure::Field(field) if self.field_index == field => { 245 Err(FailingSerializeError) 246 } 247 _ => Ok(()), 248 } 249 } 250 251 fn end(self) -> Result<Self::Ok, Self::Error> { 252 match self.failure { 253 FailingSerializeFailure::End => Err(FailingSerializeError), 254 _ => Ok(()), 255 } 256 } 257 } 258 259 pub fn assert_struct_serialize_error_paths<T>(value: &T, field_count: usize) 260 where 261 T: Serialize, 262 { 263 value 264 .serialize(FailingStructSerializer::start()) 265 .expect_err("struct start failure"); 266 for field_index in 1..=field_count { 267 value 268 .serialize(FailingStructSerializer::field(field_index)) 269 .expect_err("struct field failure"); 270 } 271 value 272 .serialize(FailingStructSerializer::end()) 273 .expect_err("struct end failure"); 274 }