Add tests of the cost of cloning EvaluatedBlock.

Cargo.toml

@@ -24,6 +24,7 @@ members = [
 resolver = "2"
 
 [workspace.dependencies]
+allocation-counter = "0.8.1"
 anyhow = "1.0.70"
 # Each use should be { optional = true }.
 arbitrary = { version = "1.1.6", features = ["derive"] }

all-is-cubes/Cargo.toml

@@ -112,6 +112,7 @@ yield-progress = { workspace = true }
 euclid = { version = "0.22.9", default-features = false, features = ["libm", "mint"] }
 
 [dev-dependencies]
+allocation-counter = { workspace = true }
 criterion = { workspace = true }
 pretty_assertions = { workspace = true }
 serde_json = { workspace = true }

all-is-cubes/src/block/attributes.rs

@@ -26,6 +26,8 @@ pub struct BlockAttributes {
     ///
     /// The default value is the empty string. The empty string should be considered a
     /// reasonable choice for solid-color blocks with no special features.
+    // ---
+    // TODO: Make this a refcounted type so we can make cloning O(1).
     pub display_name: Cow<'static, str>,
 
     /// Whether players' [cursors](crate::character::Cursor) target it or pass through it.

all-is-cubes/tests/alloc.rs

@@ -0,0 +1,70 @@
+//! Tests of memory allocation behavior.
+//!
+//! In a separate test crate to avoid modifying the global allocator elsewhere.
+
+use std::borrow::Cow;
+
+use all_is_cubes::universe::Universe;
+use allocation_counter::{measure, AllocationInfo};
+
+use all_is_cubes::block::{self, BlockAttributes};
+
+/// TODO: Make the name refcounted so this count goes to zero.
+#[test]
+fn clone_block_attributes() {
+    let display_name: Cow<'static, str> = String::from("hello").into();
+    let original = BlockAttributes {
+        // This field will allocate when cloned
+        display_name: display_name.clone(),
+
+        // TODO: This field could allocate when cloned but we're not worrying about that now
+        tick_action: None,
+
+        // These fields currently will never allocate when cloned
+        selectable: true,
+        rotation_rule: block::RotationPlacementRule::Never,
+        animation_hint: block::AnimationHint::UNCHANGING,
+    };
+    let mut clone = None;
+
+    assert_eq!(
+        measure(|| {
+            clone = Some(original.clone());
+        }),
+        AllocationInfo {
+            count_total: 1,
+            count_current: 1,
+            count_max: 1,
+            bytes_total: display_name.len() as u64,
+            bytes_current: display_name.len() as i64,
+            bytes_max: display_name.len() as u64
+        }
+    )
+}
+
+/// Test that cloning an `EvaluatedBlock`, with voxels, allocates nothing (except
+/// BlockAttributes as tested above).
+#[test]
+fn clone_evaluated_block() {
+    let universe = &mut Universe::new();
+    let [block] = all_is_cubes::content::make_some_voxel_blocks(universe);
+
+    let original = block.evaluate().unwrap();
+    // TODO: should be zero
+    let expected_bytes = original.attributes.display_name.len() as u64;
+    let mut clone = None;
+
+    assert_eq!(
+        measure(|| {
+            clone = Some(original.clone());
+        }),
+        AllocationInfo {
+            count_total: 1,
+            count_current: 1,
+            count_max: 1,
+            bytes_total: expected_bytes,
+            bytes_current: expected_bytes as i64,
+            bytes_max: expected_bytes
+        }
+    )
+}