Added more unit tests

Author: ReCore-sys

src/lib/world/src/chunk_format.rs

@@ -15,15 +15,15 @@ use std::io::Read;
 use tracing::{error, warn};
 use vanilla_chunk_format::BlockData;
 
-#[cfg(test)]
-const BLOCKSFILE: &[u8] = &[0];
+// #[cfg(test)]
+// const BLOCKSFILE: &[u8] = &[0];
 
 // If this file doesn't exist, you'll have to create it yourself. Download the 1.21.1 server from the
 // minecraft launcher, extract the blocks data (info here https://minecraft.wiki/w/Minecraft_Wiki:Projects/wiki.vg_merge/Data_Generators#Blocks_report)
 // , put the blocks.json file in the .etc folder, and run the blocks_parser.py script in the scripts
 // folder. This will generate the blockmappings.json file that is compressed with bzip2 and included
 // in the binary.
-#[cfg(not(test))]
+// #[cfg(not(test))]
 const BLOCKSFILE: &[u8] = include_bytes!("../../../../.etc/blockmappings.bz2");
 
 lazy_static! {
@@ -748,3 +748,90 @@ impl Section {
         Ok(())
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_chunk_set_block() {
+        let mut chunk = Chunk::new(0, 0, "overworld".to_string());
+        let block = BlockData {
+            name: "minecraft:stone".to_string(),
+            properties: None,
+        };
+        chunk.set_block(0, 0, 0, block.clone()).unwrap();
+        assert_eq!(chunk.get_block(0, 0, 0).unwrap(), block);
+    }
+
+    #[test]
+    fn test_chunk_fill() {
+        let mut chunk = Chunk::new(0, 0, "overworld".to_string());
+        let stone_block = BlockData {
+            name: "minecraft:stone".to_string(),
+            properties: None,
+        };
+        chunk.fill(stone_block.clone()).unwrap();
+        for section in &chunk.sections {
+            for (block, count) in &section.block_states.block_counts {
+                assert_eq!(*block, stone_block);
+                assert_eq!(count, &4096);
+            }
+        }
+    }
+
+    #[test]
+    fn test_section_fill() {
+        let mut section = Section {
+            y: 0,
+            block_states: BlockStates {
+                non_air_blocks: 0,
+                block_data: PaletteType::Single(VarInt::from(0)),
+                block_counts: HashMap::from([(BlockData::default(), 4096)]),
+            },
+            biome_states: BiomeStates {
+                bits_per_biome: 0,
+                data: vec![],
+                palette: vec![VarInt::from(0)],
+            },
+            block_light: vec![255; 2048],
+            sky_light: vec![255; 2048],
+        };
+        let stone_block = BlockData {
+            name: "minecraft:stone".to_string(),
+            properties: None,
+        };
+        section.fill(stone_block.clone()).unwrap();
+        assert_eq!(
+            section.block_states.block_data,
+            PaletteType::Single(VarInt::from(1))
+        );
+        assert_eq!(
+            section.block_states.block_counts.get(&stone_block).unwrap(),
+            &4096
+        );
+    }
+
+    #[test]
+    fn test_false_positive() {
+        let mut chunk = Chunk::new(0, 0, "overworld".to_string());
+        let block = BlockData {
+            name: "minecraft:stone".to_string(),
+            properties: None,
+        };
+        chunk.set_block(0, 0, 0, block.clone()).unwrap();
+        assert_ne!(chunk.get_block(0, 1, 0).unwrap(), block);
+    }
+
+    #[test]
+    fn test_doesnt_fail() {
+        let mut chunk = Chunk::new(0, 0, "overworld".to_string());
+        let block = BlockData {
+            name: "minecraft:stone".to_string(),
+            properties: None,
+        };
+        assert!(chunk.set_block(0, 0, 0, block.clone()).is_ok());
+        assert!(chunk.set_block(0, 0, 0, block.clone()).is_ok());
+        assert!(chunk.get_block(0, 0, 0).is_ok());
+    }
+}

src/lib/world_gen/Cargo.toml

@@ -7,6 +7,7 @@ edition = "2024"
 ferrumc-world = { workspace = true }
 thiserror = { workspace = true }
 noise = { workspace = true }
+rand = { workspace = true }
 
 [lints]
 workspace = true

src/lib/world_gen/src/biomes/plains.rs

@@ -40,11 +40,11 @@ impl BiomeGenerator for PlainsBiome {
         }
 
         // Then generate some heights
-        for chunk_x in 0..16 {
-            for chunk_z in 0..16 {
-                let global_x = x * 16 + chunk_x;
-                let global_z = z * 16 + chunk_z;
-                let height = noise.get_noise(f64::from(global_x), f64::from(global_z));
+        for chunk_x in 0..16i64 {
+            for chunk_z in 0..16i64 {
+                let global_x = i64::from(x) * 16 + chunk_x;
+                let global_z = i64::from(z) * 16 + chunk_z;
+                let height = noise.get_noise(global_x as f64, global_z as f64);
                 let height = (height * 64.0) as i32 + 64;
                 heights.push((global_x, global_z, height));
             }
@@ -64,19 +64,19 @@ impl BiomeGenerator for PlainsBiome {
                 for y in 0..height {
                     if y + above_filled_sections <= 64 {
                         chunk.set_block(
-                            global_x & 0xF,
+                            global_x as i32 & 0xF,
                             y + above_filled_sections,
-                            global_z & 0xF,
+                            global_z as i32 & 0xF,
                             BlockData {
                                 name: "minecraft:sand".to_string(),
                                 properties: None,
                             },
                         )?;
                     } else {
                         chunk.set_block(
-                            global_x & 0xF,
+                            global_x as i32 & 0xF,
                             y + above_filled_sections,
-                            global_z & 0xF,
+                            global_z as i32 & 0xF,
                             BlockData {
                                 name: "minecraft:grass_block".to_string(),
                                 properties: Some(BTreeMap::from([(
@@ -93,3 +93,52 @@ impl BiomeGenerator for PlainsBiome {
         Ok(chunk)
     }
 }
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_is_ok() {
+        let generator = PlainsBiome {};
+        let noise = NoiseGenerator::new(0);
+        assert!(generator.generate_chunk(0, 0, &noise).is_ok());
+    }
+
+    #[test]
+    fn test_random_chunk_generation() {
+        let generator = PlainsBiome {};
+        let noise = NoiseGenerator::new(0);
+        for _ in 0..100 {
+            let x = rand::random::<i32>();
+            let z = rand::random::<i32>();
+            assert!(generator.generate_chunk(x, z, &noise).is_ok());
+        }
+    }
+
+    #[test]
+    fn test_very_high_coordinates() {
+        let generator = PlainsBiome {};
+        let noise = NoiseGenerator::new(0);
+        assert!(
+            generator
+                .generate_chunk(1610612735, 1610612735, &noise)
+                .is_ok()
+        );
+        assert!(
+            generator
+                .generate_chunk(-1610612735, -1610612735, &noise)
+                .is_ok()
+        );
+    }
+
+    #[test]
+    fn test_random_seeds() {
+        for _ in 0..100 {
+            let generator = PlainsBiome {};
+            let seed = rand::random::<u64>();
+            let noise = NoiseGenerator::new(seed);
+            assert!(generator.generate_chunk(0, 0, &noise).is_ok());
+        }
+    }
+}