Skip to content

Commit 53ace23

Browse files
elbertronnieelbertronnie
committed
Added tests for FromReflectError
1 parent 7e1d30f commit 53ace23

File tree

1 file changed

+317
-0
lines changed

1 file changed

+317
-0
lines changed

‎crates/bevy_reflect/src/from_reflect.rs

+317
Original file line numberDiff line numberDiff line change
@@ -464,3 +464,320 @@ impl FromReflectError {
464464
}
465465
}
466466
}
467+
468+
#[cfg(test)]
469+
mod tests {
470+
use crate as bevy_reflect;
471+
use crate::{
472+
DynamicEnum, DynamicList, DynamicMap, DynamicStruct, DynamicTuple, DynamicTupleStruct,
473+
DynamicVariant, FromReflect, FromReflectError, Reflect, ReflectKind, TypeInfo,
474+
};
475+
use bevy_utils::HashMap;
476+
use std::borrow::Cow;
477+
478+
#[test]
479+
fn check_invalid_type() {
480+
#[derive(Reflect, FromReflect)]
481+
struct Rectangle {
482+
height: i32,
483+
width: i32,
484+
}
485+
486+
let result = Rectangle::from_reflect(&vec![1, 2, 3, 4, 5]);
487+
488+
assert!(
489+
matches!(
490+
result,
491+
Err(FromReflectError::InvalidType {
492+
from_type: TypeInfo::List(_),
493+
from_kind: ReflectKind::List,
494+
to_type: TypeInfo::Struct(_),
495+
})
496+
),
497+
"Incorrect error handling of FromReflectError::InvalidType"
498+
);
499+
}
500+
501+
#[test]
502+
fn check_invalid_length() {
503+
let result = <[i32; 10]>::from_reflect(&[1, 2, 3, 4, 5]);
504+
505+
assert!(
506+
matches!(
507+
result,
508+
Err(FromReflectError::InvalidLength {
509+
from_type: TypeInfo::Array(_),
510+
from_kind: ReflectKind::Array,
511+
to_type: TypeInfo::Array(_),
512+
from_len: 5,
513+
to_len: 10,
514+
})
515+
),
516+
"Incorrect error handling of FromReflectError::InvalidLength"
517+
);
518+
}
519+
520+
#[test]
521+
fn check_missing_named_field() {
522+
#[derive(Reflect, FromReflect)]
523+
struct Rectangle {
524+
height: i32,
525+
width: i32,
526+
}
527+
528+
let mut dyn_struct = DynamicStruct::default();
529+
dyn_struct.insert("height", 5);
530+
531+
let result = Rectangle::from_reflect(&dyn_struct);
532+
533+
assert!(
534+
matches!(
535+
result,
536+
Err(FromReflectError::MissingNamedField {
537+
from_type: TypeInfo::Dynamic(_),
538+
from_kind: ReflectKind::Struct,
539+
to_type: TypeInfo::Struct(_),
540+
field: "width",
541+
})
542+
),
543+
"Incorrect error handling of FromReflectError::MissingNamedField"
544+
);
545+
}
546+
547+
#[test]
548+
fn check_missing_unnamed_field() {
549+
#[derive(Reflect, FromReflect)]
550+
struct Rectangle(i32, i32);
551+
552+
let mut dyn_tuple_struct = DynamicTupleStruct::default();
553+
dyn_tuple_struct.insert(5);
554+
555+
let result = Rectangle::from_reflect(&dyn_tuple_struct);
556+
557+
assert!(
558+
matches!(
559+
result,
560+
Err(FromReflectError::MissingUnnamedField {
561+
from_type: TypeInfo::Dynamic(_),
562+
from_kind: ReflectKind::TupleStruct,
563+
to_type: TypeInfo::TupleStruct(_),
564+
index: 1,
565+
})
566+
),
567+
"Incorrect error handling of FromReflectError::MissingUnnamedField"
568+
);
569+
}
570+
571+
#[test]
572+
fn check_missing_index() {
573+
let mut dyn_tuple = DynamicTuple::default();
574+
dyn_tuple.insert(5);
575+
576+
let result = <(i32, i32)>::from_reflect(&dyn_tuple);
577+
578+
assert!(
579+
matches!(
580+
result,
581+
Err(FromReflectError::MissingIndex {
582+
from_type: TypeInfo::Dynamic(_),
583+
from_kind: ReflectKind::Tuple,
584+
to_type: TypeInfo::Tuple(_),
585+
index: 1,
586+
})
587+
),
588+
"Incorrect error handling of FromReflectError::MissingIndex"
589+
);
590+
}
591+
592+
#[test]
593+
fn check_missing_variant() {
594+
#[derive(Reflect, FromReflect)]
595+
enum Shape {
596+
Point,
597+
Circle(i32),
598+
Rectangle { height: i32, width: i32 },
599+
}
600+
601+
let dyn_enum = DynamicEnum::new("Shape", "None", DynamicVariant::Unit);
602+
let result = Shape::from_reflect(&dyn_enum);
603+
604+
assert!(
605+
matches!(
606+
result,
607+
Err(FromReflectError::MissingVariant {
608+
from_type: TypeInfo::Dynamic(_),
609+
from_kind: ReflectKind::Enum,
610+
to_type: TypeInfo::Enum(_),
611+
variant: Cow::Owned(x),
612+
}) if x.as_str() == "None"
613+
),
614+
"Incorrect error handling of FromReflectError::MissingVariant"
615+
);
616+
}
617+
618+
#[test]
619+
fn check_named_field_error() {
620+
#[derive(Reflect, FromReflect)]
621+
struct Rectangle {
622+
height: i32,
623+
width: i32,
624+
}
625+
626+
let mut dyn_struct = DynamicStruct::default();
627+
dyn_struct.insert("height", 5);
628+
dyn_struct.insert("width", 3.2);
629+
630+
let result = Rectangle::from_reflect(&dyn_struct);
631+
632+
assert!(
633+
matches!(
634+
result,
635+
Err(FromReflectError::NamedFieldError {
636+
from_type: TypeInfo::Dynamic(_),
637+
from_kind: ReflectKind::Struct,
638+
to_type: TypeInfo::Struct(_),
639+
field: "width",
640+
source,
641+
}) if matches!(*source, FromReflectError::InvalidType { .. })
642+
),
643+
"Incorrect error handling of FromReflectError::NamedFieldError"
644+
);
645+
}
646+
647+
#[test]
648+
fn check_unnamed_field_error() {
649+
#[derive(Reflect, FromReflect)]
650+
struct Rectangle(i32, i32);
651+
652+
let mut dyn_tuple_struct = DynamicTupleStruct::default();
653+
dyn_tuple_struct.insert(5);
654+
dyn_tuple_struct.insert(3.2);
655+
656+
let result = Rectangle::from_reflect(&dyn_tuple_struct);
657+
658+
assert!(
659+
matches!(
660+
result,
661+
Err(FromReflectError::UnnamedFieldError {
662+
from_type: TypeInfo::Dynamic(_),
663+
from_kind: ReflectKind::TupleStruct,
664+
to_type: TypeInfo::TupleStruct(_),
665+
index: 1,
666+
source,
667+
}) if matches!(*source, FromReflectError::InvalidType { .. })
668+
),
669+
"Incorrect error handling of FromReflectError::UnnamedFieldError"
670+
);
671+
}
672+
673+
#[test]
674+
fn check_index_error() {
675+
#[derive(Reflect, FromReflect)]
676+
struct Rectangle(i32, i32);
677+
678+
let mut dyn_list = DynamicList::default();
679+
dyn_list.push(1);
680+
dyn_list.push(2);
681+
dyn_list.push(3.2);
682+
683+
let result = Vec::<i32>::from_reflect(&dyn_list);
684+
685+
assert!(
686+
matches!(
687+
result,
688+
Err(FromReflectError::IndexError {
689+
from_type: TypeInfo::Dynamic(_),
690+
from_kind: ReflectKind::List,
691+
to_type: TypeInfo::List(_),
692+
index: 2,
693+
source,
694+
}) if matches!(*source, FromReflectError::InvalidType { .. })
695+
),
696+
"Incorrect error handling of FromReflectError::IndexError"
697+
);
698+
}
699+
700+
#[test]
701+
fn check_variant_error() {
702+
#[derive(Reflect, FromReflect)]
703+
enum Shape {
704+
Point,
705+
Circle(i32),
706+
Rectangle { height: i32, width: i32 },
707+
}
708+
709+
let mut dyn_struct = DynamicStruct::default();
710+
dyn_struct.insert("height", 5);
711+
dyn_struct.insert("width", 3.2);
712+
let dyn_enum = DynamicEnum::new("Shape", "Rectangle", DynamicVariant::Struct(dyn_struct));
713+
714+
let result = Shape::from_reflect(&dyn_enum);
715+
716+
assert!(
717+
matches!(
718+
result,
719+
Err(FromReflectError::VariantError {
720+
from_type: TypeInfo::Dynamic(_),
721+
from_kind: ReflectKind::Enum,
722+
to_type: TypeInfo::Enum(_),
723+
variant: Cow::Borrowed("Rectangle"),
724+
source,
725+
}) if matches!(
726+
&*source,
727+
FromReflectError::NamedFieldError {
728+
from_type: TypeInfo::Dynamic(_),
729+
from_kind: ReflectKind::Enum,
730+
to_type: TypeInfo::Enum(_),
731+
field: "width",
732+
source: inner_source,
733+
} if matches!(**inner_source, FromReflectError::InvalidType { .. })
734+
)
735+
),
736+
"Incorrect error handling of FromReflectError::VariantError"
737+
);
738+
}
739+
740+
#[test]
741+
fn check_key_error() {
742+
let mut dyn_map = DynamicMap::default();
743+
dyn_map.insert(String::from("a"), 5);
744+
dyn_map.insert(9, 2);
745+
746+
let result = HashMap::<String, i32>::from_reflect(&dyn_map);
747+
748+
assert!(
749+
matches!(
750+
result,
751+
Err(FromReflectError::KeyError {
752+
from_type: TypeInfo::Dynamic(_),
753+
from_kind: ReflectKind::Map,
754+
to_type: TypeInfo::Map(_),
755+
source,
756+
}) if matches!(*source, FromReflectError::InvalidType { .. })
757+
),
758+
"Incorrect error handling of FromReflectError::KeyError"
759+
);
760+
}
761+
762+
#[test]
763+
fn check_value_error() {
764+
let mut dyn_map = DynamicMap::default();
765+
dyn_map.insert(String::from("a"), 5);
766+
dyn_map.insert(String::from("b"), 3.2);
767+
768+
let result = HashMap::<String, i32>::from_reflect(&dyn_map);
769+
770+
assert!(
771+
matches!(
772+
result,
773+
Err(FromReflectError::ValueError {
774+
from_type: TypeInfo::Dynamic(_),
775+
from_kind: ReflectKind::Map,
776+
to_type: TypeInfo::Map(_),
777+
source,
778+
}) if matches!(*source, FromReflectError::InvalidType { .. })
779+
),
780+
"Incorrect error handling of FromReflectError::ValueError"
781+
);
782+
}
783+
}

0 commit comments

Comments
 (0)