fix clippy

benches/block.rs

@@ -5,15 +5,15 @@ use valence::block::{BlockKind, BlockState, PropName, PropValue};
 use valence::ItemKind;
 
 #[divan::bench]
-pub fn from_kind(bencher: Bencher) {
+pub(crate) fn from_kind(bencher: Bencher) {
     bencher.bench(|| {
         for kind in black_box(BlockKind::ALL) {
             black_box(BlockState::from_kind(kind));
         }
     });
 }
 #[divan::bench]
-pub fn to_kind(bencher: Bencher) {
+pub(crate) fn to_kind(bencher: Bencher) {
     let states = BlockKind::ALL.map(BlockKind::to_state);
     bencher.bench(|| {
         for state in black_box(states) {
@@ -22,7 +22,7 @@ pub fn to_kind(bencher: Bencher) {
     });
 }
 #[divan::bench]
-pub fn get_prop(bencher: Bencher) {
+pub(crate) fn get_prop(bencher: Bencher) {
     let states = BlockKind::ALL.map(BlockKind::to_state);
     bencher.bench(|| {
         for state in black_box(states) {
@@ -31,7 +31,7 @@ pub fn get_prop(bencher: Bencher) {
     });
 }
 #[divan::bench]
-pub fn set_prop(bencher: Bencher) {
+pub(crate) fn set_prop(bencher: Bencher) {
     let states = BlockKind::ALL.map(BlockKind::to_state);
     bencher.bench(|| {
         for state in black_box(states) {
@@ -40,7 +40,7 @@ pub fn set_prop(bencher: Bencher) {
     });
 }
 #[divan::bench]
-pub fn is_liquid(bencher: Bencher) {
+pub(crate) fn is_liquid(bencher: Bencher) {
     let states = BlockKind::ALL.map(BlockKind::to_state);
     bencher.bench(|| {
         for state in black_box(states) {
@@ -49,7 +49,7 @@ pub fn is_liquid(bencher: Bencher) {
     });
 }
 #[divan::bench]
-pub fn is_opaque(bencher: Bencher) {
+pub(crate) fn is_opaque(bencher: Bencher) {
     let states = BlockKind::ALL.map(BlockKind::to_state);
     bencher.bench(|| {
         for state in black_box(states) {
@@ -58,7 +58,7 @@ pub fn is_opaque(bencher: Bencher) {
     });
 }
 #[divan::bench]
-pub fn is_replaceable(bencher: Bencher) {
+pub(crate) fn is_replaceable(bencher: Bencher) {
     let states = BlockKind::ALL.map(BlockKind::to_state);
     bencher.bench(|| {
         for state in black_box(states) {
@@ -67,7 +67,7 @@ pub fn is_replaceable(bencher: Bencher) {
     });
 }
 #[divan::bench]
-pub fn luminance(bencher: Bencher) {
+pub(crate) fn luminance(bencher: Bencher) {
     let states = BlockKind::ALL.map(BlockKind::to_state);
     bencher.bench(|| {
         for state in black_box(states) {
@@ -76,15 +76,15 @@ pub fn luminance(bencher: Bencher) {
     });
 }
 #[divan::bench]
-pub fn to_item_kind(bencher: Bencher) {
+pub(crate) fn to_item_kind(bencher: Bencher) {
     bencher.bench(|| {
         for kind in black_box(BlockKind::ALL) {
             black_box(kind.to_item_kind());
         }
     });
 }
 #[divan::bench]
-pub fn from_item_kind(bencher: Bencher) {
+pub(crate) fn from_item_kind(bencher: Bencher) {
     bencher.bench(|| {
         for kind in black_box(ItemKind::ALL) {
             black_box(BlockKind::from_item_kind(kind));

benches/decode_array.rs

@@ -4,7 +4,7 @@ use divan::Bencher;
 use valence::protocol::{Decode, Encode};
 
 #[divan::bench]
-pub fn decode_small_array(bencher: Bencher) {
+pub(crate) fn decode_small_array(bencher: Bencher) {
     let floats = [123.0, 456.0, 789.0];
     let mut buf = [0_u8; 24];
 
@@ -17,7 +17,7 @@ pub fn decode_small_array(bencher: Bencher) {
 }
 
 #[divan::bench]
-pub fn decode_large_array(bencher: Bencher) {
+pub(crate) fn decode_large_array(bencher: Bencher) {
     let bytes = [42; 4096];
 
     bencher.bench(|| {

benches/idle.rs

@@ -4,7 +4,7 @@ use valence::prelude::*;
 /// Benches the performance of a single server tick while nothing much is
 /// happening.
 #[divan::bench]
-pub fn idle_update(bencher: Bencher) {
+pub(crate) fn idle_update(bencher: Bencher) {
     let mut app = App::new();
 
     app.add_plugins(DefaultPlugins);

benches/packet.rs

@@ -12,7 +12,7 @@ use valence::text::IntoText;
 use valence_server::protocol::Velocity;
 use valence_server::CompressionThreshold;
 
-pub fn setup<'a>() -> (
+pub(crate) fn setup<'a>() -> (
     PacketEncoder,
     ChunkDataS2c<'a>,
     PlayerListHeaderS2c<'a>,

crates/valence_command/src/parsers.rs

@@ -175,28 +175,6 @@ impl<'a> ParseInput<'a> {
     }
 }
 
-#[test]
-fn test_parse_input() {
-    let mut input = ParseInput::new("The QuIck brown FOX jumps over the lazy dog");
-    assert_eq!(input.peek(), Some('T'));
-    assert_eq!(input.peek_n(0), "");
-    assert_eq!(input.peek_n(1), "T");
-    assert_eq!(input.peek_n(2), "Th");
-    assert_eq!(input.peek_n(3), "The");
-
-    assert_eq!(input.peek_word(), "The");
-    input.pop_word();
-    input.skip_whitespace();
-    assert_eq!(input.peek_word(), "QuIck");
-
-    assert!(input.match_next("quick"));
-    input.pop();
-    assert_eq!(input.peek_word(), "brown");
-
-    assert!(input.match_next("brown fox"));
-    assert_eq!(input.pop_all(), Some(" jumps over the lazy dog"));
-}
-
 #[derive(Debug, Error)]
 pub enum CommandArgParseError {
     // these should be player facing and not disclose internal information
@@ -249,58 +227,83 @@ where
     }
 }
 
-#[test]
-fn test_absolute_or_relative() {
-    let mut input = ParseInput::new("~");
-    assert_eq!(
-        AbsoluteOrRelative::<i32>::parse_arg(&mut input).unwrap(),
-        AbsoluteOrRelative::Relative(0)
-    );
-    assert!(input.is_done());
-
-    let mut input = ParseInput::new("~1");
-    assert_eq!(
-        AbsoluteOrRelative::<i32>::parse_arg(&mut input).unwrap(),
-        AbsoluteOrRelative::Relative(1)
-    );
-    assert!(input.is_done());
-
-    let mut input = ParseInput::new("~1.5");
-    assert_eq!(
-        AbsoluteOrRelative::<f32>::parse_arg(&mut input).unwrap(),
-        AbsoluteOrRelative::Relative(1.5)
-    );
-    assert!(input.is_done());
-
-    let mut input = ParseInput::new("1");
-    assert_eq!(
-        AbsoluteOrRelative::<i32>::parse_arg(&mut input).unwrap(),
-        AbsoluteOrRelative::Absolute(1)
-    );
-    assert!(input.is_done());
-
-    let mut input = ParseInput::new("1.5 ");
-    assert_eq!(
-        AbsoluteOrRelative::<f32>::parse_arg(&mut input).unwrap(),
-        AbsoluteOrRelative::Absolute(1.5)
-    );
-    assert!(!input.is_done());
-
-    let mut input = ParseInput::new("1.5 2");
-    assert_eq!(
-        AbsoluteOrRelative::<f32>::parse_arg(&mut input).unwrap(),
-        AbsoluteOrRelative::Absolute(1.5)
-    );
-    assert!(!input.is_done());
-    assert_eq!(
-        AbsoluteOrRelative::<f32>::parse_arg(&mut input).unwrap(),
-        AbsoluteOrRelative::Absolute(2.0)
-    );
-    assert!(input.is_done());
-}
-
 impl<T: Default> Default for AbsoluteOrRelative<T> {
     fn default() -> Self {
         AbsoluteOrRelative::Absolute(T::default())
     }
 }
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    #[test]
+    fn test_parse_input() {
+        let mut input = ParseInput::new("The QuIck brown FOX jumps over the lazy dog");
+        assert_eq!(input.peek(), Some('T'));
+        assert_eq!(input.peek_n(0), "");
+        assert_eq!(input.peek_n(1), "T");
+        assert_eq!(input.peek_n(2), "Th");
+        assert_eq!(input.peek_n(3), "The");
+
+        assert_eq!(input.peek_word(), "The");
+        input.pop_word();
+        input.skip_whitespace();
+        assert_eq!(input.peek_word(), "QuIck");
+
+        assert!(input.match_next("quick"));
+        input.pop();
+        assert_eq!(input.peek_word(), "brown");
+
+        assert!(input.match_next("brown fox"));
+        assert_eq!(input.pop_all(), Some(" jumps over the lazy dog"));
+    }
+    #[test]
+    fn test_absolute_or_relative() {
+        let mut input = ParseInput::new("~");
+        assert_eq!(
+            AbsoluteOrRelative::<i32>::parse_arg(&mut input).unwrap(),
+            AbsoluteOrRelative::Relative(0)
+        );
+        assert!(input.is_done());
+
+        let mut input = ParseInput::new("~1");
+        assert_eq!(
+            AbsoluteOrRelative::<i32>::parse_arg(&mut input).unwrap(),
+            AbsoluteOrRelative::Relative(1)
+        );
+        assert!(input.is_done());
+
+        let mut input = ParseInput::new("~1.5");
+        assert_eq!(
+            AbsoluteOrRelative::<f32>::parse_arg(&mut input).unwrap(),
+            AbsoluteOrRelative::Relative(1.5)
+        );
+        assert!(input.is_done());
+
+        let mut input = ParseInput::new("1");
+        assert_eq!(
+            AbsoluteOrRelative::<i32>::parse_arg(&mut input).unwrap(),
+            AbsoluteOrRelative::Absolute(1)
+        );
+        assert!(input.is_done());
+
+        let mut input = ParseInput::new("1.5 ");
+        assert_eq!(
+            AbsoluteOrRelative::<f32>::parse_arg(&mut input).unwrap(),
+            AbsoluteOrRelative::Absolute(1.5)
+        );
+        assert!(!input.is_done());
+
+        let mut input = ParseInput::new("1.5 2");
+        assert_eq!(
+            AbsoluteOrRelative::<f32>::parse_arg(&mut input).unwrap(),
+            AbsoluteOrRelative::Absolute(1.5)
+        );
+        assert!(!input.is_done());
+        assert_eq!(
+            AbsoluteOrRelative::<f32>::parse_arg(&mut input).unwrap(),
+            AbsoluteOrRelative::Absolute(2.0)
+        );
+        assert!(input.is_done());
+    }
+}

crates/valence_command/src/parsers/block_pos.rs

@@ -25,38 +25,43 @@ impl CommandArg for BlockPos {
     }
 }
 
-#[test]
-fn test_block_pos() {
-    let mut input = ParseInput::new("~-1 2 3");
-    assert_eq!(
-        BlockPos::parse_arg(&mut input).unwrap(),
-        BlockPos {
-            x: AbsoluteOrRelative::Relative(-1),
-            y: AbsoluteOrRelative::Absolute(2),
-            z: AbsoluteOrRelative::Absolute(3)
-        }
-    );
-    assert!(input.is_done());
-
-    let mut input = ParseInput::new("-1 ~2 3 ");
-    assert_eq!(
-        BlockPos::parse_arg(&mut input).unwrap(),
-        BlockPos {
-            x: AbsoluteOrRelative::Absolute(-1),
-            y: AbsoluteOrRelative::Relative(2),
-            z: AbsoluteOrRelative::Absolute(3)
-        }
-    );
-    assert!(!input.is_done());
-
-    let mut input = ParseInput::new("-1 2 ~3 4");
-    assert_eq!(
-        BlockPos::parse_arg(&mut input).unwrap(),
-        BlockPos {
-            x: AbsoluteOrRelative::Absolute(-1),
-            y: AbsoluteOrRelative::Absolute(2),
-            z: AbsoluteOrRelative::Relative(3)
-        }
-    );
-    assert!(!input.is_done());
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_block_pos() {
+        let mut input = ParseInput::new("~-1 2 3");
+        assert_eq!(
+            BlockPos::parse_arg(&mut input).unwrap(),
+            BlockPos {
+                x: AbsoluteOrRelative::Relative(-1),
+                y: AbsoluteOrRelative::Absolute(2),
+                z: AbsoluteOrRelative::Absolute(3)
+            }
+        );
+        assert!(input.is_done());
+
+        let mut input = ParseInput::new("-1 ~2 3 ");
+        assert_eq!(
+            BlockPos::parse_arg(&mut input).unwrap(),
+            BlockPos {
+                x: AbsoluteOrRelative::Absolute(-1),
+                y: AbsoluteOrRelative::Relative(2),
+                z: AbsoluteOrRelative::Absolute(3)
+            }
+        );
+        assert!(!input.is_done());
+
+        let mut input = ParseInput::new("-1 2 ~3 4");
+        assert_eq!(
+            BlockPos::parse_arg(&mut input).unwrap(),
+            BlockPos {
+                x: AbsoluteOrRelative::Absolute(-1),
+                y: AbsoluteOrRelative::Absolute(2),
+                z: AbsoluteOrRelative::Relative(3)
+            }
+        );
+        assert!(!input.is_done());
+    }
 }