update and add tests for new next incrementing method

crates/bevy_reflect/src/array.rs

@@ -467,3 +467,32 @@ pub fn array_debug(dyn_array: &dyn Array, f: &mut std::fmt::Formatter<'_>) -> st
  }
  debug.finish()
 }
+#[cfg(test)]
+mod tests {
+ use crate::{Reflect, ReflectRef};
+ #[test]
+ fn next_index_increment() {
+ const SIZE: usize = if cfg!(debug_assertions) {
+ 4
+ } else {
+ // If compiled in release mode, verify we dont overflow
+ usize::MAX
+ };
+
+ let b = Box::new([(); SIZE]).into_reflect();
+
+ let ReflectRef::Array(array) = b.reflect_ref() else {
+ panic!("Not an array...");
+ };
+
+ let mut iter = array.iter();
+ iter.index = SIZE - 1;
+ assert!(iter.next().is_some());
+
+ // When None we should no longer increase index
+ assert!(iter.next().is_none());
+ assert!(iter.index == SIZE);
+ assert!(iter.next().is_none());
+ assert!(iter.index == SIZE);
+ }
+}

crates/bevy_reflect/src/enums/enum_trait.rs

@@ -312,3 +312,58 @@ impl<'a> VariantField<'a> {
  }
  }
 }
+
+// Tests that need access to internal fields have to go here rather than in mod.rs
+#[cfg(test)]
+mod tests {
+ use crate as bevy_reflect;
+ use crate::*;
+
+ #[derive(Reflect, Debug, PartialEq)]
+ enum MyEnum {
+ A,
+ B(usize, i32),
+ C { foo: f32, bar: bool },
+ }
+ #[test]
+ fn next_index_increment() {
+ // unit enums always return none, so index should stay at 0
+ let unit_enum = MyEnum::A;
+ let mut iter = unit_enum.iter_fields();
+ let size = iter.len();
+ for _ in 0..2 {
+ assert!(iter.next().is_none());
+ assert_eq!(size, iter.index);
+ }
+ // tuple enums we iter over each value (unnamed fields), stop after that
+ let tuple_enum = MyEnum::B(0, 1);
+ let mut iter = tuple_enum.iter_fields();
+ let size = iter.len();
+ for _ in 0..2 {
+ let prev_index = iter.index;
+ assert!(iter.next().is_some());
+ assert_eq!(prev_index, iter.index - 1);
+ }
+ for _ in 0..2 {
+ assert!(iter.next().is_none());
+ assert_eq!(size, iter.index);
+ }
+
+ // struct enums, we iterate over each field in the struct
+ let struct_enum = MyEnum::C {
+ foo: 0.,
+ bar: false,
+ };
+ let mut iter = struct_enum.iter_fields();
+ let size = iter.len();
+ for _ in 0..2 {
+ let prev_index = iter.index;
+ assert!(iter.next().is_some());
+ assert_eq!(prev_index, iter.index - 1);
+ }
+ for _ in 0..2 {
+ assert!(iter.next().is_none());
+ assert_eq!(size, iter.index);
+ }
+ }
+}

crates/bevy_reflect/src/list.rs

@@ -508,7 +508,6 @@ pub fn list_debug(dyn_list: &dyn List, f: &mut Formatter<'_>) -> std::fmt::Resul
 #[cfg(test)]
 mod tests {
  use super::DynamicList;
- #[cfg(not(debug_assertions))]
  use crate::{Reflect, ReflectRef};
  use std::assert_eq;
 
@@ -525,22 +524,28 @@ mod tests {
  }
  }
 
- #[cfg(not(debug_assertions))]
  #[test]
- fn list_avoid_wrap_in_release() {
- let b = Box::new(vec![(); usize::MAX]).into_reflect();
+ fn next_index_increment() {
+ const SIZE: usize = if cfg!(debug_assertions) {
+ 4
+ } else {
+ // If compiled in release mode, verify we dont overflow
+ usize::MAX
+ };
+ let b = Box::new(vec![(); SIZE]).into_reflect();
 
  let ReflectRef::List(list) = b.reflect_ref() else {
  panic!("Not a list...");
  };
 
  let mut iter = list.iter();
- iter.index = usize::MAX - 1;
+ iter.index = SIZE - 1;
  assert!(iter.next().is_some());
+
+ // When None we should no longer increase index
  assert!(iter.next().is_none());
- assert!(iter.index == usize::MAX);
- // let's do it again to see we are indeed not moving
+ assert!(iter.index == SIZE);
  assert!(iter.next().is_none());
- assert!(iter.index == usize::MAX);
+ assert!(iter.index == SIZE);
  }
 }

crates/bevy_reflect/src/map.rs

@@ -594,4 +594,27 @@ mod tests {
 
  assert!(map.get_at(2).is_none());
  }
+
+ #[test]
+ fn next_index_increment() {
+ let values = ["first", "last"];
+ let mut map = DynamicMap::default();
+ map.insert(0usize, values[0]);
+ map.insert(1usize, values[1]);
+
+ let mut iter = map.iter();
+ let size = iter.len();
+
+ for _ in 0..2 {
+ let prev_index = iter.index;
+ assert!(iter.next().is_some());
+ assert_eq!(prev_index, iter.index - 1);
+ }
+
+ // When None we should no longer increase index
+ for _ in 0..2 {
+ assert!(iter.next().is_none());
+ assert_eq!(size, iter.index);
+ }
+ }
 }

crates/bevy_reflect/src/struct_trait.rs

@@ -557,3 +557,31 @@ pub fn struct_debug(dyn_struct: &dyn Struct, f: &mut Formatter<'_>) -> std::fmt:
  }
  debug.finish()
 }
+
+#[cfg(test)]
+mod tests {
+ use crate as bevy_reflect;
+ use crate::*;
+ #[derive(Reflect, Default)]
+ struct MyStruct {
+ a: (),
+ b: (),
+ c: (),
+ }
+ #[test]
+ fn next_index_increment() {
+ let my_struct = MyStruct::default();
+ let mut iter = my_struct.iter_fields();
+ iter.index = iter.len() - 1;
+ let prev_index = iter.index;
+ assert!(iter.next().is_some());
+ assert_eq!(prev_index, iter.index - 1);
+
+ // When None we should no longer increase index
+ let prev_index = iter.index;
+ assert!(iter.next().is_none());
+ assert_eq!(prev_index, iter.index);
+ assert!(iter.next().is_none());
+ assert_eq!(prev_index, iter.index);
+ }
+}

crates/bevy_reflect/src/tuple.rs

@@ -683,3 +683,24 @@ macro_rules! impl_type_path_tuple {
 }
 
 all_tuples!(impl_type_path_tuple, 0, 12, P);
+
+#[cfg(test)]
+mod tests {
+ use super::Tuple;
+
+ #[test]
+ fn next_index_increment() {
+ let mut iter = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11).iter_fields();
+ let size = iter.len();
+ iter.index = size - 1;
+ let prev_index = iter.index;
+ assert!(iter.next().is_some());
+ assert_eq!(prev_index, iter.index - 1);
+
+ // When None we should no longer increase index
+ assert!(iter.next().is_none());
+ assert_eq!(size, iter.index);
+ assert!(iter.next().is_none());
+ assert_eq!(size, iter.index);
+ }
+}

crates/bevy_reflect/src/tuple_struct.rs

@@ -469,3 +469,26 @@ pub fn tuple_struct_debug(
  }
  debug.finish()
 }
+
+#[cfg(test)]
+mod tests {
+ use crate as bevy_reflect;
+ use crate::*;
+ #[derive(Reflect)]
+ struct Ts(u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8);
+ #[test]
+ fn next_index_increment() {
+ let mut iter = Ts(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11).iter_fields();
+ let size = iter.len();
+ iter.index = size - 1;
+ let prev_index = iter.index;
+ assert!(iter.next().is_some());
+ assert_eq!(prev_index, iter.index - 1);
+
+ // When None we should no longer increase index
+ assert!(iter.next().is_none());
+ assert_eq!(size, iter.index);
+ assert!(iter.next().is_none());
+ assert_eq!(size, iter.index);
+ }
+}