From f3ed064a269fd72711e40121dad1a9fd9f16bdc0 Mon Sep 17 00:00:00 2001 From: Folyd Date: Mon, 17 May 2021 18:31:58 +0800 Subject: [PATCH] chore: update `*::{max, min}_value()` to const `*::MAX` and `*::MIN` respectively (#3794) --- tokio-stream/tests/stream_chain.rs | 4 ++-- tokio-stream/tests/stream_merge.rs | 4 ++-- tokio/src/io/util/async_read_ext.rs | 4 ++-- tokio/src/io/util/async_write_ext.rs | 12 ++++++------ tokio/src/io/util/buf_reader.rs | 2 +- tokio/src/net/unix/ucred.rs | 2 +- tokio/src/runtime/queue.rs | 4 ++-- tokio/src/runtime/task/state.rs | 4 ++-- tokio/src/runtime/tests/task.rs | 2 +- tokio/src/time/driver/entry.rs | 12 ++++++------ tokio/src/time/driver/wheel/mod.rs | 2 +- tokio/tests/io_buf_reader.rs | 22 +++++----------------- 12 files changed, 31 insertions(+), 43 deletions(-) diff --git a/tokio-stream/tests/stream_chain.rs b/tokio-stream/tests/stream_chain.rs index 759de3068..f3b7edb16 100644 --- a/tokio-stream/tests/stream_chain.rs +++ b/tokio-stream/tests/stream_chain.rs @@ -89,12 +89,12 @@ fn size_overflow() { } fn size_hint(&self) -> (usize, Option) { - (usize::max_value(), Some(usize::max_value())) + (usize::MAX, Some(usize::MAX)) } } let m1 = Monster; let m2 = Monster; let m = m1.chain(m2); - assert_eq!(m.size_hint(), (usize::max_value(), None)); + assert_eq!(m.size_hint(), (usize::MAX, None)); } diff --git a/tokio-stream/tests/stream_merge.rs b/tokio-stream/tests/stream_merge.rs index 69cd568a6..f603bccf8 100644 --- a/tokio-stream/tests/stream_merge.rs +++ b/tokio-stream/tests/stream_merge.rs @@ -72,12 +72,12 @@ fn size_overflow() { } fn size_hint(&self) -> (usize, Option) { - (usize::max_value(), Some(usize::max_value())) + (usize::MAX, Some(usize::MAX)) } } let m1 = Monster; let m2 = Monster; let m = m1.merge(m2); - assert_eq!(m.size_hint(), (usize::max_value(), None)); + assert_eq!(m.size_hint(), (usize::MAX, None)); } diff --git a/tokio/src/io/util/async_read_ext.rs b/tokio/src/io/util/async_read_ext.rs index e715f9de3..8ca0d3f10 100644 --- a/tokio/src/io/util/async_read_ext.rs +++ b/tokio/src/io/util/async_read_ext.rs @@ -579,7 +579,7 @@ cfg_io_util! { /// async fn main() -> io::Result<()> { /// let mut reader = Cursor::new(vec![0x80, 0, 0, 0, 0, 0, 0, 0]); /// - /// assert_eq!(i64::min_value(), reader.read_i64().await?); + /// assert_eq!(i64::MIN, reader.read_i64().await?); /// Ok(()) /// } /// ``` @@ -659,7 +659,7 @@ cfg_io_util! { /// 0, 0, 0, 0, 0, 0, 0, 0 /// ]); /// - /// assert_eq!(i128::min_value(), reader.read_i128().await?); + /// assert_eq!(i128::MIN, reader.read_i128().await?); /// Ok(()) /// } /// ``` diff --git a/tokio/src/io/util/async_write_ext.rs b/tokio/src/io/util/async_write_ext.rs index 2510ccdea..4651a996b 100644 --- a/tokio/src/io/util/async_write_ext.rs +++ b/tokio/src/io/util/async_write_ext.rs @@ -621,8 +621,8 @@ cfg_io_util! { /// async fn main() -> io::Result<()> { /// let mut writer = Vec::new(); /// - /// writer.write_i64(i64::min_value()).await?; - /// writer.write_i64(i64::max_value()).await?; + /// writer.write_i64(i64::MIN).await?; + /// writer.write_i64(i64::MAX).await?; /// /// assert_eq!(writer, b"\x80\x00\x00\x00\x00\x00\x00\x00\x7f\xff\xff\xff\xff\xff\xff\xff"); /// Ok(()) @@ -699,7 +699,7 @@ cfg_io_util! { /// async fn main() -> io::Result<()> { /// let mut writer = Vec::new(); /// - /// writer.write_i128(i128::min_value()).await?; + /// writer.write_i128(i128::MIN).await?; /// /// assert_eq!(writer, vec![ /// 0x80, 0, 0, 0, 0, 0, 0, 0, @@ -930,8 +930,8 @@ cfg_io_util! { /// async fn main() -> io::Result<()> { /// let mut writer = Vec::new(); /// - /// writer.write_i64_le(i64::min_value()).await?; - /// writer.write_i64_le(i64::max_value()).await?; + /// writer.write_i64_le(i64::MIN).await?; + /// writer.write_i64_le(i64::MAX).await?; /// /// assert_eq!(writer, b"\x00\x00\x00\x00\x00\x00\x00\x80\xff\xff\xff\xff\xff\xff\xff\x7f"); /// Ok(()) @@ -1008,7 +1008,7 @@ cfg_io_util! { /// async fn main() -> io::Result<()> { /// let mut writer = Vec::new(); /// - /// writer.write_i128_le(i128::min_value()).await?; + /// writer.write_i128_le(i128::MIN).await?; /// /// assert_eq!(writer, vec![ /// 0, 0, 0, 0, 0, 0, 0, diff --git a/tokio/src/io/util/buf_reader.rs b/tokio/src/io/util/buf_reader.rs index cc65ef209..c4d6842d4 100644 --- a/tokio/src/io/util/buf_reader.rs +++ b/tokio/src/io/util/buf_reader.rs @@ -198,7 +198,7 @@ impl AsyncSeek for BufReader { // it should be safe to assume that remainder fits within an i64 as the alternative // means we managed to allocate 8 exbibytes and that's absurd. // But it's not out of the realm of possibility for some weird underlying reader to - // support seeking by i64::min_value() so we need to handle underflow when subtracting + // support seeking by i64::MIN so we need to handle underflow when subtracting // remainder. if let Some(offset) = n.checked_sub(remainder) { self.as_mut() diff --git a/tokio/src/net/unix/ucred.rs b/tokio/src/net/unix/ucred.rs index 5c7c1983a..b95a8f66a 100644 --- a/tokio/src/net/unix/ucred.rs +++ b/tokio/src/net/unix/ucred.rs @@ -73,7 +73,7 @@ pub(crate) mod impl_linux { // These paranoid checks should be optimized-out assert!(mem::size_of::() <= mem::size_of::()); - assert!(ucred_size <= u32::max_value() as usize); + assert!(ucred_size <= u32::MAX as usize); let mut ucred_size = ucred_size as socklen_t; diff --git a/tokio/src/runtime/queue.rs b/tokio/src/runtime/queue.rs index 6ea23c926..b300e1ae6 100644 --- a/tokio/src/runtime/queue.rs +++ b/tokio/src/runtime/queue.rs @@ -617,7 +617,7 @@ fn set_next(header: NonNull, val: Option>) { /// Split the head value into the real head and the index a stealer is working /// on. fn unpack(n: u32) -> (u16, u16) { - let real = n & u16::max_value() as u32; + let real = n & u16::MAX as u32; let steal = n >> 16; (steal as u16, real as u16) @@ -630,5 +630,5 @@ fn pack(steal: u16, real: u16) -> u32 { #[test] fn test_local_queue_capacity() { - assert!(LOCAL_QUEUE_CAPACITY - 1 <= u8::max_value() as usize); + assert!(LOCAL_QUEUE_CAPACITY - 1 <= u8::MAX as usize); } diff --git a/tokio/src/runtime/task/state.rs b/tokio/src/runtime/task/state.rs index 21e90430d..1e09f4230 100644 --- a/tokio/src/runtime/task/state.rs +++ b/tokio/src/runtime/task/state.rs @@ -306,7 +306,7 @@ impl State { let prev = self.val.fetch_add(REF_ONE, Relaxed); // If the reference count overflowed, abort. - if prev > isize::max_value() as usize { + if prev > isize::MAX as usize { process::abort(); } } @@ -410,7 +410,7 @@ impl Snapshot { } fn ref_inc(&mut self) { - assert!(self.0 <= isize::max_value() as usize); + assert!(self.0 <= isize::MAX as usize); self.0 += REF_ONE; } diff --git a/tokio/src/runtime/tests/task.rs b/tokio/src/runtime/tests/task.rs index a34526f31..45a3e9955 100644 --- a/tokio/src/runtime/tests/task.rs +++ b/tokio/src/runtime/tests/task.rs @@ -79,7 +79,7 @@ static CURRENT: TryLock> = TryLock::new(None); impl Runtime { fn tick(&self) -> usize { - self.tick_max(usize::max_value()) + self.tick_max(usize::MAX) } fn tick_max(&self, max: usize) -> usize { diff --git a/tokio/src/time/driver/entry.rs b/tokio/src/time/driver/entry.rs index 08edab31c..168e0b995 100644 --- a/tokio/src/time/driver/entry.rs +++ b/tokio/src/time/driver/entry.rs @@ -68,7 +68,7 @@ use std::{marker::PhantomPinned, pin::Pin, ptr::NonNull}; type TimerResult = Result<(), crate::time::error::Error>; -const STATE_DEREGISTERED: u64 = u64::max_value(); +const STATE_DEREGISTERED: u64 = u64::MAX; const STATE_PENDING_FIRE: u64 = STATE_DEREGISTERED - 1; const STATE_MIN_VALUE: u64 = STATE_PENDING_FIRE; @@ -85,10 +85,10 @@ const STATE_MIN_VALUE: u64 = STATE_PENDING_FIRE; /// requires only the driver lock. pub(super) struct StateCell { /// Holds either the scheduled expiration time for this timer, or (if the - /// timer has been fired and is unregistered), `u64::max_value()`. + /// timer has been fired and is unregistered), `u64::MAX`. state: AtomicU64, /// If the timer is fired (an Acquire order read on state shows - /// `u64::max_value()`), holds the result that should be returned from + /// `u64::MAX`), holds the result that should be returned from /// polling the timer. Otherwise, the contents are unspecified and reading /// without holding the driver lock is undefined behavior. result: UnsafeCell, @@ -125,7 +125,7 @@ impl StateCell { fn when(&self) -> Option { let cur_state = self.state.load(Ordering::Relaxed); - if cur_state == u64::max_value() { + if cur_state == u64::MAX { None } else { Some(cur_state) @@ -271,7 +271,7 @@ impl StateCell { /// ordering, but is conservative - if it returns false, the timer is /// definitely _not_ registered. pub(super) fn might_be_registered(&self) -> bool { - self.state.load(Ordering::Relaxed) != u64::max_value() + self.state.load(Ordering::Relaxed) != u64::MAX } } @@ -591,7 +591,7 @@ impl TimerHandle { match self.inner.as_ref().state.mark_pending(not_after) { Ok(()) => { // mark this as being on the pending queue in cached_when - self.inner.as_ref().set_cached_when(u64::max_value()); + self.inner.as_ref().set_cached_when(u64::MAX); Ok(()) } Err(tick) => { diff --git a/tokio/src/time/driver/wheel/mod.rs b/tokio/src/time/driver/wheel/mod.rs index 24bf517c7..5a40f6db8 100644 --- a/tokio/src/time/driver/wheel/mod.rs +++ b/tokio/src/time/driver/wheel/mod.rs @@ -119,7 +119,7 @@ impl Wheel { pub(crate) unsafe fn remove(&mut self, item: NonNull) { unsafe { let when = item.as_ref().cached_when(); - if when == u64::max_value() { + if when == u64::MAX { self.pending.remove(item); } else { debug_assert!( diff --git a/tokio/tests/io_buf_reader.rs b/tokio/tests/io_buf_reader.rs index ac5f11c72..c72c058d7 100644 --- a/tokio/tests/io_buf_reader.rs +++ b/tokio/tests/io_buf_reader.rs @@ -120,10 +120,7 @@ async fn test_buffered_reader_seek() { assert_eq!(reader.seek(SeekFrom::Start(3)).await.unwrap(), 3); assert_eq!(run_fill_buf!(reader).unwrap(), &[0, 1][..]); - assert!(reader - .seek(SeekFrom::Current(i64::min_value())) - .await - .is_err()); + assert!(reader.seek(SeekFrom::Current(i64::MIN)).await.is_err()); assert_eq!(run_fill_buf!(reader).unwrap(), &[0, 1][..]); assert_eq!(reader.seek(SeekFrom::Current(1)).await.unwrap(), 4); assert_eq!(run_fill_buf!(reader).unwrap(), &[1, 2][..]); @@ -163,7 +160,7 @@ async fn test_buffered_reader_seek_underflow() { self.pos = self.pos.wrapping_add(n as u64); } SeekFrom::End(n) => { - self.pos = u64::max_value().wrapping_add(n as u64); + self.pos = u64::MAX.wrapping_add(n as u64); } } Ok(()) @@ -175,18 +172,12 @@ async fn test_buffered_reader_seek_underflow() { let mut reader = BufReader::with_capacity(5, PositionReader { pos: 0 }); assert_eq!(run_fill_buf!(reader).unwrap(), &[0, 1, 2, 3, 4][..]); - assert_eq!( - reader.seek(SeekFrom::End(-5)).await.unwrap(), - u64::max_value() - 5 - ); + assert_eq!(reader.seek(SeekFrom::End(-5)).await.unwrap(), u64::MAX - 5); assert_eq!(run_fill_buf!(reader).unwrap().len(), 5); // the following seek will require two underlying seeks let expected = 9_223_372_036_854_775_802; assert_eq!( - reader - .seek(SeekFrom::Current(i64::min_value())) - .await - .unwrap(), + reader.seek(SeekFrom::Current(i64::MIN)).await.unwrap(), expected ); assert_eq!(run_fill_buf!(reader).unwrap().len(), 5); @@ -350,10 +341,7 @@ async fn maybe_pending_seek() { assert_eq!(reader.seek(SeekFrom::Current(3)).await.unwrap(), 3); assert_eq!(run_fill_buf!(reader).unwrap(), &[0, 1][..]); - assert!(reader - .seek(SeekFrom::Current(i64::min_value())) - .await - .is_err()); + assert!(reader.seek(SeekFrom::Current(i64::MIN)).await.is_err()); assert_eq!(run_fill_buf!(reader).unwrap(), &[0, 1][..]); assert_eq!(reader.seek(SeekFrom::Current(1)).await.unwrap(), 4); assert_eq!(run_fill_buf!(reader).unwrap(), &[1, 2][..]);