Merge remote-tracking branch 'origin/master' into bevy-0.19

Author: Shatur

benches/replication.rs

@@ -64,7 +64,7 @@ fn changes_send<C: BenchmarkComponent>(iter: u64, clients_count: usize) -> Durat
             client_app.update();
 
             let mut remote = client_app.world_mut().query::<&Remote>();
-            assert_eq!(remote.iter(client_app.world()).count(), ENTITIES);
+            assert_eq!(remote.iter(client_app.world()).len(), ENTITIES);
         }
     }
 
@@ -93,7 +93,7 @@ fn mutations_send<C: BenchmarkComponent>(iter: u64, clients_count: usize) -> Dur
         client_app.update();
 
         let mut remote = client_app.world_mut().query::<&Remote>();
-        assert_eq!(remote.iter(client_app.world()).count(), ENTITIES);
+        assert_eq!(remote.iter(client_app.world()).len(), ENTITIES);
     }
 
     let mut elapsed = Duration::ZERO;
@@ -111,7 +111,7 @@ fn mutations_send<C: BenchmarkComponent>(iter: u64, clients_count: usize) -> Dur
             client_app.update();
 
             let mut remote = client_app.world_mut().query::<&Remote>();
-            assert_eq!(remote.iter(client_app.world()).count(), ENTITIES);
+            assert_eq!(remote.iter(client_app.world()).len(), ENTITIES);
         }
     }
 
@@ -138,7 +138,7 @@ fn changes_receive<C: BenchmarkComponent>(iter: u64) -> Duration {
         elapsed += instant.elapsed();
 
         let mut remote = client_app.world_mut().query::<&Remote>();
-        assert_eq!(remote.iter(client_app.world()).count(), ENTITIES);
+        assert_eq!(remote.iter(client_app.world()).len(), ENTITIES);
     }
 
     elapsed
@@ -159,7 +159,7 @@ fn mutations_receive<C: BenchmarkComponent>(iter: u64) -> Duration {
     server_app.exchange_with_client(&mut client_app);
     client_app.update();
     let mut remote = client_app.world_mut().query::<&Remote>();
-    assert_eq!(remote.iter(client_app.world()).count(), ENTITIES);
+    assert_eq!(remote.iter(client_app.world()).len(), ENTITIES);
 
     let mut elapsed = Duration::ZERO;
     for _ in 0..iter {
@@ -176,7 +176,7 @@ fn mutations_receive<C: BenchmarkComponent>(iter: u64) -> Duration {
         elapsed += instant.elapsed();
 
         let mut remote = client_app.world_mut().query::<&Remote>();
-        assert_eq!(remote.iter(client_app.world()).count(), ENTITIES);
+        assert_eq!(remote.iter(client_app.world()).len(), ENTITIES);
     }
 
     elapsed

src/shared/backend/server_messages.rs

@@ -102,7 +102,7 @@ impl ServerMessages {
     /// Should only be called from the messaging backend.
     ///
     /// </div>
-    pub fn drain_sent(&mut self) -> impl Iterator<Item = (Entity, usize, Bytes)> + '_ {
+    pub fn drain_sent(&mut self) -> impl ExactSizeIterator<Item = (Entity, usize, Bytes)> + '_ {
         self.sent_messages.drain(..)
     }
 

tests/connection.rs

@@ -113,7 +113,7 @@ fn custom_auth() {
     let mut clients = server_app
         .world_mut()
         .query_filtered::<&ConnectedClient, Without<AuthorizedClient>>();
-    assert_eq!(clients.iter(server_app.world()).count(), 1);
+    assert_eq!(clients.iter(server_app.world()).len(), 1);
 }
 
 #[test]

tests/despawn.rs

@@ -146,7 +146,7 @@ fn after_spawn() {
 
     let mut messages = server_app.world_mut().resource_mut::<ServerMessages>();
     assert_eq!(
-        messages.drain_sent().count(),
+        messages.drain_sent().len(),
         0,
         "client shouldn't receive anything for a despawned entity"
     );
@@ -254,7 +254,7 @@ fn signature_with_hierarchy() {
 
     let mut remote = client_app.world_mut().query::<&Remote>();
     assert_eq!(
-        remote.iter(client_app.world()).count(),
+        remote.iter(client_app.world()).len(),
         2,
         "entities should be replicated as new due to removal from the signature map"
     );
@@ -292,7 +292,7 @@ fn hidden_entity() {
 
     let mut messages = server_app.world_mut().resource_mut::<ServerMessages>();
     assert_eq!(
-        messages.drain_sent().count(),
+        messages.drain_sent().len(),
         0,
         "client shouldn't receive anything for a hidden entity"
     );
@@ -418,7 +418,7 @@ fn with_visibility_gain_and_signature() {
     server_app.update();
 
     let mut messages = server_app.world_mut().resource_mut::<ServerMessages>();
-    assert_eq!(messages.drain_sent().count(), 0);
+    assert_eq!(messages.drain_sent().len(), 0);
 }
 
 #[derive(Component, Deserialize, Serialize)]

tests/insertion.rs

@@ -49,7 +49,7 @@ fn table_storage() {
     client_app.update();
 
     let mut components = client_app.world_mut().query::<&Table>();
-    assert_eq!(components.iter(client_app.world()).count(), 1);
+    assert_eq!(components.iter(client_app.world()).len(), 1);
 }
 
 #[test]
@@ -85,7 +85,7 @@ fn sparse_set_storage() {
     client_app.update();
 
     let mut components = client_app.world_mut().query::<&SparseSet>();
-    assert_eq!(components.iter(client_app.world()).count(), 1);
+    assert_eq!(components.iter(client_app.world()).len(), 1);
 }
 
 #[test]
@@ -226,7 +226,7 @@ fn mapped_new_entity() {
     assert!(client_app.world().get_entity(mapped_component.0).is_ok());
 
     let mut remote = client_app.world_mut().query::<&Remote>();
-    assert_eq!(remote.iter(client_app.world()).count(), 1);
+    assert_eq!(remote.iter(client_app.world()).len(), 1);
 }
 
 #[test]
@@ -265,7 +265,7 @@ fn multiple_components() {
     client_app.update();
 
     let mut components = client_app.world_mut().query::<(&A, &B)>();
-    assert_eq!(components.iter(client_app.world()).count(), 1);
+    assert_eq!(components.iter(client_app.world()).len(), 1);
     assert_eq!(
         client_app.world().archetypes().len() - before_archetypes,
         1,
@@ -309,7 +309,7 @@ fn multiple_components_sequential() {
     client_app.update();
 
     let mut components = client_app.world_mut().query::<(&Remote, &A, &B)>();
-    assert_eq!(components.iter(client_app.world()).count(), 1);
+    assert_eq!(components.iter(client_app.world()).len(), 1);
 }
 
 #[test]
@@ -336,7 +336,7 @@ fn rule_split_across_ticks() {
     server_app.exchange_with_client(&mut client_app);
 
     let mut a_components = client_app.world_mut().query::<&A>();
-    assert_eq!(a_components.iter(client_app.world()).count(), 0);
+    assert_eq!(a_components.iter(client_app.world()).len(), 0);
 
     // Insert component that should trigger replication of another component.
     server_app.world_mut().entity_mut(server_entity).insert(B);
@@ -346,7 +346,7 @@ fn rule_split_across_ticks() {
     client_app.update();
 
     let mut all_components = client_app.world_mut().query::<(&A, &B)>();
-    assert_eq!(all_components.iter(client_app.world()).count(), 1);
+    assert_eq!(all_components.iter(client_app.world()).len(), 1);
 }
 
 #[test]
@@ -385,7 +385,7 @@ fn receive_fns() {
     let mut components = client_app
         .world_mut()
         .query_filtered::<&Replaced, Without<Original>>();
-    assert_eq!(components.iter(client_app.world()).count(), 1);
+    assert_eq!(components.iter(client_app.world()).len(), 1);
 }
 
 #[test]
@@ -471,7 +471,7 @@ fn group() {
     client_app.update();
 
     let mut groups = client_app.world_mut().query::<(&A, &B)>();
-    assert_eq!(groups.iter(client_app.world()).count(), 1);
+    assert_eq!(groups.iter(client_app.world()).len(), 1);
 }
 
 #[test]
@@ -503,7 +503,7 @@ fn not_replicated() {
     client_app.update();
 
     let mut components = client_app.world_mut().query::<&A>();
-    assert_eq!(components.iter(client_app.world()).count(), 0);
+    assert_eq!(components.iter(client_app.world()).len(), 0);
 }
 
 #[test]
@@ -541,7 +541,7 @@ fn after_removal() {
     client_app.update();
 
     let mut components = client_app.world_mut().query::<&A>();
-    assert_eq!(components.iter(client_app.world()).count(), 1);
+    assert_eq!(components.iter(client_app.world()).len(), 1);
 
     let mut system_state: SystemState<RemovedComponents<A>> =
         SystemState::new(client_app.world_mut());
@@ -680,7 +680,7 @@ fn hidden_entity() {
 
     let mut messages = server_app.world_mut().resource_mut::<ServerMessages>();
     assert_eq!(
-        messages.drain_sent().count(),
+        messages.drain_sent().len(),
         0,
         "client shouldn't receive insertion for a hidden entity"
     );
@@ -719,7 +719,7 @@ fn hidden_component() {
 
     let mut messages = server_app.world_mut().resource_mut::<ServerMessages>();
     assert_eq!(
-        messages.drain_sent().count(),
+        messages.drain_sent().len(),
         0,
         "client shouldn't receive insertion for a hidden component"
     );
@@ -752,7 +752,7 @@ fn visibility_gain() {
     server_app.exchange_with_client(&mut client_app);
 
     let mut components = client_app.world_mut().query::<&A>();
-    assert_eq!(components.iter(client_app.world()).count(), 0);
+    assert_eq!(components.iter(client_app.world()).len(), 0);
 
     let client = **client_app.world().resource::<TestClientEntity>();
     server_app
@@ -764,7 +764,7 @@ fn visibility_gain() {
     server_app.exchange_with_client(&mut client_app);
     client_app.update();
 
-    assert_eq!(components.iter(client_app.world()).count(), 1);
+    assert_eq!(components.iter(client_app.world()).len(), 1);
 }
 
 #[derive(Component, Deserialize, Serialize)]

tests/mutations.rs

@@ -726,7 +726,7 @@ fn many_entities() {
     server_app.exchange_with_client(&mut client_app);
 
     let mut remote = client_app.world_mut().query::<&Remote>();
-    assert_eq!(remote.iter(client_app.world()).count(), ENTITIES_COUNT);
+    assert_eq!(remote.iter(client_app.world()).len(), ENTITIES_COUNT);
 
     for mut component in server_app
         .world_mut()

tests/priority.rs

@@ -117,7 +117,7 @@ fn with_miss() {
 
     // Take and drop the mutation message.
     let mut messages = server_app.world_mut().resource_mut::<ServerMessages>();
-    assert_eq!(messages.drain_sent().count(), 1);
+    assert_eq!(messages.drain_sent().len(), 1);
 
     server_app.exchange_with_client(&mut client_app);
     client_app.update();

tests/removal.rs

@@ -519,7 +519,7 @@ fn hidden_entity() {
 
     let mut messages = server_app.world_mut().resource_mut::<ServerMessages>();
     assert_eq!(
-        messages.drain_sent().count(),
+        messages.drain_sent().len(),
         0,
         "client shouldn't receive removal for a hidden entity"
     );
@@ -561,7 +561,7 @@ fn hidden_component() {
 
     let mut messages = server_app.world_mut().resource_mut::<ServerMessages>();
     assert_eq!(
-        messages.drain_sent().count(),
+        messages.drain_sent().len(),
         0,
         "client shouldn't receive removal for a hidden component"
     );

tests/spawn.rs

@@ -71,7 +71,7 @@ fn component() {
     client_app.update();
 
     let mut components = client_app.world_mut().query::<(&Remote, &A)>();
-    assert_eq!(components.iter(client_app.world()).count(), 1);
+    assert_eq!(components.iter(client_app.world()).len(), 1);
 }
 
 #[test]
@@ -100,7 +100,7 @@ fn multiple_components() {
     client_app.update();
 
     let mut components = client_app.world_mut().query::<(&Remote, &A, &B)>();
-    assert_eq!(components.iter(client_app.world()).count(), 1);
+    assert_eq!(components.iter(client_app.world()).len(), 1);
     assert_eq!(
         client_app.world().archetypes().len() - before_archetypes,
         1,
@@ -146,7 +146,7 @@ fn old_component() {
     client_app.update();
 
     let mut components = client_app.world_mut().query::<(&Remote, &A)>();
-    assert_eq!(components.iter(client_app.world()).count(), 1);
+    assert_eq!(components.iter(client_app.world()).len(), 1);
 }
 
 #[test]
@@ -233,7 +233,7 @@ fn empty_before_connection() {
     client_app.update();
 
     let mut remote = client_app.world_mut().query::<&Remote>();
-    assert_eq!(remote.iter(client_app.world()).count(), 1);
+    assert_eq!(remote.iter(client_app.world()).len(), 1);
 }
 
 #[test]
@@ -262,7 +262,7 @@ fn before_connection() {
     client_app.update();
 
     let mut components = client_app.world_mut().query::<(&Remote, &A)>();
-    assert_eq!(components.iter(client_app.world()).count(), 1);
+    assert_eq!(components.iter(client_app.world()).len(), 1);
 }
 
 #[test]
@@ -319,7 +319,7 @@ fn signature() {
 
     let mut remote = client_app.world_mut().query::<&Remote>();
     assert_eq!(
-        remote.iter(client_app.world()).count(),
+        remote.iter(client_app.world()).len(),
         1,
         "new entity shouldn't be spawned on client"
     );
@@ -377,7 +377,7 @@ fn signature_before_replication() {
     server_app.update();
 
     let mut server_messages = server_app.world_mut().resource_mut::<ServerMessages>();
-    assert_eq!(server_messages.drain_sent().count(), 0);
+    assert_eq!(server_messages.drain_sent().len(), 0);
 
     server_app
         .world_mut()
@@ -456,7 +456,7 @@ fn before_started_replication() {
 
     let mut components = client_app.world_mut().query::<&A>();
     assert_eq!(
-        components.iter(client_app.world()).count(),
+        components.iter(client_app.world()).len(),
         0,
         "no entities should have been sent to the client"
     );
@@ -472,7 +472,7 @@ fn before_started_replication() {
     client_app.update();
     server_app.exchange_with_client(&mut client_app);
 
-    assert_eq!(components.iter(client_app.world()).count(), 1);
+    assert_eq!(components.iter(client_app.world()).len(), 1);
 }
 
 #[test]
@@ -514,7 +514,7 @@ fn after_started_replication() {
     server_app.exchange_with_client(&mut client_app);
 
     let mut components = client_app.world_mut().query::<&A>();
-    assert_eq!(components.iter(client_app.world()).count(), 1);
+    assert_eq!(components.iter(client_app.world()).len(), 1);
 }
 
 #[test]
@@ -608,7 +608,7 @@ fn visibility_gain_with_signature() {
     server_app.update();
 
     let mut server_messages = server_app.world_mut().resource_mut::<ServerMessages>();
-    assert_eq!(server_messages.drain_sent().count(), 0);
+    assert_eq!(server_messages.drain_sent().len(), 0);
 
     let client = **client_app.world().resource::<TestClientEntity>();
     server_app