itsscb/tokio
1
0
Fork 0
mirror of https://github.com/tokio-rs/tokio.git synced 2025-09-25 12:00:35 +00:00
Code Issues Packages Projects Releases Wiki Activity

chore: update *::{max, min}_value() to const *::MAX and *::MIN respectively (#3794)

Browse Source
This commit is contained in:
Folyd 2021-05-17 18:31:58 +08:00 committed by GitHub
parent 652f0ae728
commit f3ed064a26
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
12 changed files with 31 additions and 43 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
tokio-stream/tests/stream_chain.rs
View File

@ -89,12 +89,12 @@ fn size_overflow() {
}
fn size_hint(&self) -> (usize, Option<usize>) {
(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));
}

4
tokio-stream/tests/stream_merge.rs
View File

@ -72,12 +72,12 @@ fn size_overflow() {
}
fn size_hint(&self) -> (usize, Option<usize>) {
(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));
}

4
tokio/src/io/util/async_read_ext.rs
View File

@ -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(())
/// }
/// ```

12
tokio/src/io/util/async_write_ext.rs
View File

@ -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,

2
tokio/src/io/util/buf_reader.rs
View File

@ -198,7 +198,7 @@ impl<R: AsyncRead + AsyncSeek> AsyncSeek for BufReader<R> {
// 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()

2
tokio/src/net/unix/ucred.rs
View File

@ -73,7 +73,7 @@ pub(crate) mod impl_linux {
// These paranoid checks should be optimized-out
assert!(mem::size_of::<u32>() <= mem::size_of::<usize>());
assert!(ucred_size <= u32::max_value() as usize);
assert!(ucred_size <= u32::MAX as usize);
let mut ucred_size = ucred_size as socklen_t;

4
tokio/src/runtime/queue.rs
View File

@ -617,7 +617,7 @@ fn set_next(header: NonNull<task::Header>, val: Option<NonNull<task::Header>>) {
/// 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);
}

4
tokio/src/runtime/task/state.rs
View File

@ -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;
}

2
tokio/src/runtime/tests/task.rs
View File

@ -79,7 +79,7 @@ static CURRENT: TryLock<Option<Runtime>> = 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 {

12
tokio/src/time/driver/entry.rs
View File

@ -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<TimerResult>,
@ -125,7 +125,7 @@ impl StateCell {
fn when(&self) -> Option<u64> {
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) => {

2
tokio/src/time/driver/wheel/mod.rs
View File

@ -119,7 +119,7 @@ impl Wheel {
pub(crate) unsafe fn remove(&mut self, item: NonNull<TimerShared>) {
unsafe {
let when = item.as_ref().cached_when();
if when == u64::max_value() {
if when == u64::MAX {
self.pending.remove(item);
} else {
debug_assert!(

22
tokio/tests/io_buf_reader.rs
View File

@ -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][..]);