milksad
/
rust-bitcoin-unsafe-fast
14
0
Fork 0
Code Issues Pull Requests Activity

Merge rust-bitcoin/rust-bitcoin#1829: Remove `min_value` and `max_value` 

6cab7beba3 Deprecate min/max_value methods (Tobin C. Harding)
5fbbd483ea Use MIN/MAX consts instead of min/max_value (Tobin C. Harding)
3885f4d430 Add MIN/MAX consts to amounts (Tobin C. Harding)

Pull request description:

  The new MSRV (1.48.0) uses associated consts MAX/MIN instead of functions, we had functions to be compliant with the old MSRV.

  ~Remove all methods `min_value` and `max_value` including calls to these methods on stdlib types.~

  PR is now split into three patches:
  - patch 1: Add missing associated consts MIN/MAX as needed
  - patch 2: Use consts instead of method calls
  - patch 3: Deprecate methods `min_value` and `max_value`

ACKs for top commit:
  sanket1729:
    ACK 6cab7beba3
  apoelstra:
    ACK 6cab7beba3
  Kixunil:
    ACK 6cab7beba3

Tree-SHA512: 60949d1bb971e0dfbab7f573b4447f889b5fa1a5f1c9ac9325a2970fe17a19ccc93418dba57f07bed7e13864b130de48b6b3741d1d80266c6144237dd4565ff7
This commit is contained in:
Andrew Poelstra 2023-05-04 12:20:15 +00:00
parent 23d80bf1ab 6cab7beba3
commit ac664106be
No known key found for this signature in database
GPG Key ID: C588D63CE41B97C1
13 changed files with 81 additions and 62 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

73
bitcoin/src/amount.rs
View File

@ -494,6 +494,10 @@ impl Amount {
pub const ONE_BTC: Amount = Amount(100_000_000);
/// The maximum value allowed as an amount. Useful for sanity checking.
pub const MAX_MONEY: Amount = Amount(21_000_000 * 100_000_000);
/// The minimum value of an amount.
pub const MIN: Amount = Amount::ZERO;
/// The maximum value of an amount.
pub const MAX: Amount = Amount(u64::MAX);
/// Create an [Amount] with satoshi precision and the given number of satoshis.
pub const fn from_sat(satoshi: u64) -> Amount { Amount(satoshi) }
@ -502,9 +506,11 @@ impl Amount {
pub fn to_sat(self) -> u64 { self.0 }
/// The maximum value of an [Amount].
#[deprecated(since = "0.31.0", note = "Use Self::MAX instead")]
pub const fn max_value() -> Amount { Amount(u64::max_value()) }
/// The minimum value of an [Amount].
#[deprecated(since = "0.31.0", note = "Use Self::MIN instead")]
pub const fn min_value() -> Amount { Amount(u64::min_value()) }
/// Convert from a value expressing bitcoins to an [Amount].
@ -521,7 +527,7 @@ impl Amount {
if negative {
return Err(ParseAmountError::Negative);
}
if satoshi > i64::max_value() as u64 {
if satoshi > i64::MAX as u64 {
return Err(ParseAmountError::TooBig);
}
Ok(Amount::from_sat(satoshi))
@ -646,7 +652,7 @@ impl Amount {
/// Convert to a signed amount.
pub fn to_signed(self) -> Result<SignedAmount, ParseAmountError> {
if self.to_sat() > SignedAmount::max_value().to_sat() as u64 {
if self.to_sat() > SignedAmount::MAX.to_sat() as u64 {
Err(ParseAmountError::TooBig)
} else {
Ok(SignedAmount::from_sat(self.to_sat() as i64))
@ -829,6 +835,10 @@ impl SignedAmount {
pub const ONE_BTC: SignedAmount = SignedAmount(100_000_000);
/// The maximum value allowed as an amount. Useful for sanity checking.
pub const MAX_MONEY: SignedAmount = SignedAmount(21_000_000 * 100_000_000);
/// The minimum value of an amount.
pub const MIN: SignedAmount = SignedAmount(i64::MIN);
/// The maximum value of an amount.
pub const MAX: SignedAmount = SignedAmount(i64::MAX);
/// Create an [SignedAmount] with satoshi precision and the given number of satoshis.
pub const fn from_sat(satoshi: i64) -> SignedAmount { SignedAmount(satoshi) }
@ -837,9 +847,11 @@ impl SignedAmount {
pub fn to_sat(self) -> i64 { self.0 }
/// The maximum value of an [SignedAmount].
#[deprecated(since = "0.31.0", note = "Use Self::MAX instead")]
pub const fn max_value() -> SignedAmount { SignedAmount(i64::max_value()) }
/// The minimum value of an [SignedAmount].
#[deprecated(since = "0.31.0", note = "Use Self::MIN instead")]
pub const fn min_value() -> SignedAmount { SignedAmount(i64::min_value()) }
/// Convert from a value expressing bitcoins to an [SignedAmount].
@ -853,7 +865,7 @@ impl SignedAmount {
/// with denomination, use [FromStr].
pub fn from_str_in(s: &str, denom: Denomination) -> Result<SignedAmount, ParseAmountError> {
let (negative, satoshi) = parse_signed_to_satoshi(s, denom)?;
if satoshi > i64::max_value() as u64 {
if satoshi > i64::MAX as u64 {
return Err(ParseAmountError::TooBig);
}
Ok(match negative {
@ -972,7 +984,7 @@ impl SignedAmount {
pub fn is_negative(self) -> bool { self.0.is_negative() }
/// Get the absolute value of this [SignedAmount].
/// Returns [None] if overflow occurred. (`self == min_value()`)
/// Returns [None] if overflow occurred. (`self == MIN`)
pub fn checked_abs(self) -> Option<SignedAmount> { self.0.checked_abs().map(SignedAmount) }
/// Checked addition.
@ -1575,7 +1587,7 @@ mod tests {
#[test]
fn test_overflows() {
// panic on overflow
let result = panic::catch_unwind(|| Amount::max_value() + Amount::from_sat(1));
let result = panic::catch_unwind(|| Amount::MAX + Amount::from_sat(1));
assert!(result.is_err());
let result = panic::catch_unwind(|| Amount::from_sat(8446744073709551615) * 3);
assert!(result.is_err());
@ -1586,10 +1598,10 @@ mod tests {
let sat = Amount::from_sat;
let ssat = SignedAmount::from_sat;
assert_eq!(SignedAmount::max_value().checked_add(ssat(1)), None);
assert_eq!(SignedAmount::min_value().checked_sub(ssat(1)), None);
assert_eq!(Amount::max_value().checked_add(sat(1)), None);
assert_eq!(Amount::min_value().checked_sub(sat(1)), None);
assert_eq!(SignedAmount::MAX.checked_add(ssat(1)), None);
assert_eq!(SignedAmount::MIN.checked_sub(ssat(1)), None);
assert_eq!(Amount::MAX.checked_add(sat(1)), None);
assert_eq!(Amount::MIN.checked_sub(sat(1)), None);
assert_eq!(sat(5).checked_div(2), Some(sat(2))); // integer division
assert_eq!(ssat(-6).checked_div(2), Some(ssat(-3)));
@ -1618,11 +1630,11 @@ mod tests {
assert_eq!(sf(-184467440738.0, D::Bitcoin), Err(ParseAmountError::TooBig));
assert_eq!(f(18446744073709551617.0, D::Satoshi), Err(ParseAmountError::TooBig));
assert_eq!(
f(SignedAmount::max_value().to_float_in(D::Satoshi) + 1.0, D::Satoshi),
f(SignedAmount::MAX.to_float_in(D::Satoshi) + 1.0, D::Satoshi),
Err(ParseAmountError::TooBig)
);
assert_eq!(
f(Amount::max_value().to_float_in(D::Satoshi) + 1.0, D::Satoshi),
f(Amount::MAX.to_float_in(D::Satoshi) + 1.0, D::Satoshi),
Err(ParseAmountError::TooBig)
);
@ -1651,7 +1663,7 @@ mod tests {
assert_eq!(p("-1.0x", btc), Err(E::InvalidCharacter('x')));
assert_eq!(p("0.0 ", btc), Err(ParseAmountError::InvalidCharacter(' ')));
assert_eq!(p("0.000.000", btc), Err(E::InvalidFormat));
let more_than_max = format!("1{}", Amount::max_value());
let more_than_max = format!("1{}", Amount::MAX);
assert_eq!(p(&more_than_max, btc), Err(E::TooBig));
assert_eq!(p("0.000000042", btc), Err(E::TooPrecise));
@ -1668,8 +1680,8 @@ mod tests {
Ok(Amount::from_sat(12_345_678_901__123_456_78))
);
// make sure satoshi > i64::max_value() is checked.
let amount = Amount::from_sat(i64::max_value() as u64);
// make sure satoshi > i64::MAX is checked.
let amount = Amount::from_sat(i64::MAX as u64);
assert_eq!(Amount::from_str_in(&amount.to_string_in(sat), sat), Ok(amount));
assert_eq!(
Amount::from_str_in(&(amount + Amount(1)).to_string_in(sat), sat),
@ -1900,16 +1912,13 @@ mod tests {
let sa = SignedAmount::from_sat;
let ua = Amount::from_sat;
assert_eq!(Amount::max_value().to_signed(), Err(E::TooBig));
assert_eq!(ua(i64::max_value() as u64).to_signed(), Ok(sa(i64::max_value())));
assert_eq!(ua(i64::max_value() as u64 + 1).to_signed(), Err(E::TooBig));
assert_eq!(Amount::MAX.to_signed(), Err(E::TooBig));
assert_eq!(ua(i64::MAX as u64).to_signed(), Ok(sa(i64::MAX)));
assert_eq!(ua(i64::MAX as u64 + 1).to_signed(), Err(E::TooBig));
assert_eq!(sa(i64::max_value()).to_unsigned(), Ok(ua(i64::max_value() as u64)));
assert_eq!(sa(i64::MAX).to_unsigned(), Ok(ua(i64::MAX as u64)));
assert_eq!(
sa(i64::max_value()).to_unsigned().unwrap().to_signed(),
Ok(sa(i64::max_value()))
);
assert_eq!(sa(i64::MAX).to_unsigned().unwrap().to_signed(), Ok(sa(i64::MAX)));
}
#[test]
@ -1997,7 +2006,7 @@ mod tests {
Ok(ua_sat(1_000_000_000_000))
);
assert_eq!(
ua_str(&ua_sat(u64::max_value()).to_string_in(D::MilliBitcoin), D::MilliBitcoin),
ua_str(&ua_sat(u64::MAX).to_string_in(D::MilliBitcoin), D::MilliBitcoin),
Err(ParseAmountError::TooBig)
);
@ -2007,12 +2016,12 @@ mod tests {
);
assert_eq!(
sa_str(&sa_sat(i64::max_value()).to_string_in(D::Satoshi), D::MicroBitcoin),
sa_str(&sa_sat(i64::MAX).to_string_in(D::Satoshi), D::MicroBitcoin),
Err(ParseAmountError::TooBig)
);
// Test an overflow bug in `abs()`
assert_eq!(
sa_str(&sa_sat(i64::min_value()).to_string_in(D::Satoshi), D::MicroBitcoin),
sa_str(&sa_sat(i64::MIN).to_string_in(D::Satoshi), D::MicroBitcoin),
Err(ParseAmountError::TooBig)
);
@ -2021,11 +2030,11 @@ mod tests {
Ok(sa_sat(-1))
);
assert_eq!(
sa_str(&sa_sat(i64::max_value()).to_string_in(D::Satoshi), D::NanoBitcoin),
sa_str(&sa_sat(i64::MAX).to_string_in(D::Satoshi), D::NanoBitcoin),
Err(ParseAmountError::TooPrecise)
);
assert_eq!(
sa_str(&sa_sat(i64::min_value()).to_string_in(D::Satoshi), D::NanoBitcoin),
sa_str(&sa_sat(i64::MIN).to_string_in(D::Satoshi), D::NanoBitcoin),
Err(ParseAmountError::TooPrecise)
);
@ -2034,11 +2043,11 @@ mod tests {
Ok(sa_sat(-1))
);
assert_eq!(
sa_str(&sa_sat(i64::max_value()).to_string_in(D::Satoshi), D::PicoBitcoin),
sa_str(&sa_sat(i64::MAX).to_string_in(D::Satoshi), D::PicoBitcoin),
Err(ParseAmountError::TooPrecise)
);
assert_eq!(
sa_str(&sa_sat(i64::min_value()).to_string_in(D::Satoshi), D::PicoBitcoin),
sa_str(&sa_sat(i64::MIN).to_string_in(D::Satoshi), D::PicoBitcoin),
Err(ParseAmountError::TooPrecise)
);
}
@ -2240,12 +2249,12 @@ mod tests {
assert_eq!(Some(Amount::from_sat(1400)), sum);
let amounts =
vec![Amount::from_sat(u64::max_value()), Amount::from_sat(1337), Amount::from_sat(21)];
vec![Amount::from_sat(u64::MAX), Amount::from_sat(1337), Amount::from_sat(21)];
let sum = amounts.into_iter().checked_sum();
assert_eq!(None, sum);
let amounts = vec![
SignedAmount::from_sat(i64::min_value()),
SignedAmount::from_sat(i64::MIN),
SignedAmount::from_sat(-1),
SignedAmount::from_sat(21),
];
@ -2253,7 +2262,7 @@ mod tests {
assert_eq!(None, sum);
let amounts = vec![
SignedAmount::from_sat(i64::max_value()),
SignedAmount::from_sat(i64::MAX),
SignedAmount::from_sat(1),
SignedAmount::from_sat(21),
];

8
bitcoin/src/blockdata/fee_rate.rs
View File

@ -28,10 +28,10 @@ impl FeeRate {
/// Minimum possible value (0 sat/kwu).
///
/// Equivalent to [`ZERO`](Self::ZERO), may better express intent in some contexts.
pub const MIN: FeeRate = FeeRate(u64::min_value());
pub const MIN: FeeRate = FeeRate::ZERO;
/// Maximum possible value.
pub const MAX: FeeRate = FeeRate(u64::max_value());
pub const MAX: FeeRate = FeeRate(u64::MAX);
/// Minimum fee rate required to broadcast a transaction.
///
@ -128,8 +128,8 @@ mod tests {
#[test]
fn fee_rate_const_test() {
assert_eq!(0, FeeRate::ZERO.to_sat_per_kwu());
assert_eq!(u64::min_value(), FeeRate::MIN.to_sat_per_kwu());
assert_eq!(u64::max_value(), FeeRate::MAX.to_sat_per_kwu());
assert_eq!(u64::MIN, FeeRate::MIN.to_sat_per_kwu());
assert_eq!(u64::MAX, FeeRate::MAX.to_sat_per_kwu());
assert_eq!(250, FeeRate::BROADCAST_MIN.to_sat_per_kwu());
assert_eq!(750, FeeRate::DUST.to_sat_per_kwu());
}

4
bitcoin/src/blockdata/locktime/absolute.rs
View File

@ -397,11 +397,13 @@ impl Height {
/// The minimum absolute block height (0), the genesis block.
///
/// This is provided for consistency with Rust 1.41.1, newer code should use [`Height::MIN`].
#[deprecated(since = "0.31.0", note = "Use Self::MIN instead")]
pub const fn min_value() -> Self { Self::MIN }
/// The maximum absolute block height.
///
/// This is provided for consistency with Rust 1.41.1, newer code should use [`Height::MAX`].
#[deprecated(since = "0.31.0", note = "Use Self::MAX instead")]
pub const fn max_value() -> Self { Self::MAX }
/// Constructs a new block height.
@ -477,11 +479,13 @@ impl Time {
/// The minimum absolute block time.
///
/// This is provided for consistency with Rust 1.41.1, newer code should use [`Time::MIN`].
#[deprecated(since = "0.31.0", note = "Use Self::MIN instead")]
pub const fn min_value() -> Self { Self::MIN }
/// The maximum absolute block time.
///
/// This is provided for consistency with Rust 1.41.1, newer code should use [`Time::MAX`].
#[deprecated(since = "0.31.0", note = "Use Self::MAX instead")]
pub const fn max_value() -> Self { Self::MAX }
/// Constructs a new block time.

4
bitcoin/src/blockdata/locktime/relative.rs
View File

@ -210,11 +210,13 @@ impl Height {
/// The minimum relative block height (0), can be included in any block.
///
/// This is provided for consistency with Rust 1.41.1, newer code should use [`Height::MIN`].
#[deprecated(since = "0.31.0", note = "Use Self::MIN instead")]
pub const fn min_value() -> Self { Self::MIN }
/// The maximum relative block height.
///
/// This is provided for consistency with Rust 1.41.1, newer code should use [`Height::MAX`].
#[deprecated(since = "0.31.0", note = "Use Self::MAX instead")]
pub const fn max_value() -> Self { Self::MAX }
/// Returns the inner `u16` value.
@ -254,11 +256,13 @@ impl Time {
/// The minimum relative block time.
///
/// This is provided for consistency with Rust 1.41.1, newer code should use [`Time::MIN`].
#[deprecated(since = "0.31.0", note = "Use Self::MIN instead")]
pub const fn min_value() -> Self { Self::MIN }
/// The maximum relative block time.
///
/// This is provided for consistency with Rust 1.41.1, newer code should use [`Time::MAX`].
#[deprecated(since = "0.31.0", note = "Use Self::MAX instead")]
pub const fn max_value() -> Self { Self::MAX }
/// Create a [`Time`] using time intervals where each interval is equivalent to 512 seconds.

2
bitcoin/src/blockdata/script/instruction.rs
View File

@ -88,7 +88,7 @@ impl<'a> Instructions<'a> {
// We do exhaustive matching to not forget to handle new variants if we extend
// `UintError` type.
// Overflow actually means early end of script (script is definitely shorter
// than `usize::max_value()`)
// than `usize::MAX`)
Err(UintError::EarlyEndOfScript) | Err(UintError::NumericOverflow) => {
self.kill();
return Some(Err(Error::EarlyEndOfScript));

8
bitcoin/src/blockdata/script/mod.rs
View File

@ -187,11 +187,11 @@ pub fn read_scriptbool(v: &[u8]) -> bool {
/// This function returns an error in these cases:
///
/// * `data` is shorter than `size` => `EarlyEndOfScript`
/// * `size` is greater than `u16::max_value / 8` (8191) => `NumericOverflow`
/// * `size` is greater than `u16::MAX / 8` (8191) => `NumericOverflow`
/// * The number being read overflows `usize` => `NumericOverflow`
///
/// Note that this does **not** return an error for `size` between `core::size_of::<usize>()`
/// and `u16::max_value / 8` if there's no overflow.
/// and `u16::MAX / 8` if there's no overflow.
#[inline]
#[deprecated(since = "0.30.0", note = "bitcoin integers are signed 32 bits, use read_scriptint")]
pub fn read_uint(data: &[u8], size: usize) -> Result<usize, Error> {
@ -203,7 +203,7 @@ pub fn read_uint(data: &[u8], size: usize) -> Result<usize, Error> {
fn read_uint_iter(data: &mut core::slice::Iter<'_, u8>, size: usize) -> Result<usize, UintError> {
if data.len() < size {
Err(UintError::EarlyEndOfScript)
} else if size > usize::from(u16::max_value() / 8) {
} else if size > usize::from(u16::MAX / 8) {
// Casting to u32 would overflow
Err(UintError::NumericOverflow)
} else {
@ -596,7 +596,7 @@ pub(super) fn bytes_to_asm_fmt(script: &[u8], f: &mut dyn fmt::Write) -> fmt::Re
$formatter.write_str("<unexpected end>")?;
break;
}
// We got the data in a slice which implies it being shorter than `usize::max_value()`
// We got the data in a slice which implies it being shorter than `usize::MAX`
// So if we got overflow, we can confidently say the number is higher than length of
// the slice even though we don't know the exact number. This implies attempt to push
// past end.

3
bitcoin/src/blockdata/transaction.rs
View File

@ -61,7 +61,7 @@ impl OutPoint {
///
/// This value is used for coinbase transactions because they don't have any previous outputs.
#[inline]
pub fn null() -> OutPoint { OutPoint { txid: Hash::all_zeros(), vout: u32::max_value() } }
pub fn null() -> OutPoint { OutPoint { txid: Hash::all_zeros(), vout: u32::MAX } }
/// Checks if an `OutPoint` is "null".
///
@ -305,6 +305,7 @@ impl Sequence {
/// The maximum allowable sequence number.
///
/// This is provided for consistency with Rust 1.41.1, newer code should use [`Sequence::MAX`].
#[deprecated(since = "0.31.0", note = "Use Self::MAX instead")]
pub const fn max_value() -> Self { Self::MAX }
/// Returns `true` if the sequence number enables absolute lock-time ([`Transaction::lock_time`]).

10
bitcoin/src/blockdata/weight.rs
View File

@ -26,10 +26,10 @@ impl Weight {
/// Minimum possible value (0 wu).
///
/// Equivalent to [`ZERO`](Self::ZERO), may better express intent in some contexts.
pub const MIN: Weight = Weight(u64::min_value());
pub const MIN: Weight = Weight(u64::MIN);
/// Maximum possible value.
pub const MAX: Weight = Weight(u64::max_value());
pub const MAX: Weight = Weight(u64::MAX);
/// The maximum allowed weight for a block, see BIP 141 (network rule).
pub const MAX_BLOCK: Weight = Weight(4_000_000);
@ -124,7 +124,7 @@ mod tests {
#[test]
#[should_panic]
fn kilo_weight_constructor_panic_test() {
Weight::from_kwu(u64::max_value()).expect("expected weight unit");
Weight::from_kwu(u64::MAX).expect("expected weight unit");
}
#[test]
@ -132,7 +132,7 @@ mod tests {
let vb = Weight::from_vb(1).expect("expected weight unit");
assert_eq!(Weight(4), vb);
let vb = Weight::from_vb(u64::max_value());
let vb = Weight::from_vb(u64::MAX);
assert_eq!(None, vb);
}
@ -144,7 +144,7 @@ mod tests {
#[test]
#[should_panic]
fn from_vb_unchecked_panic_test() { Weight::from_vb_unchecked(u64::max_value()); }
fn from_vb_unchecked_panic_test() { Weight::from_vb_unchecked(u64::MAX); }
#[test]
fn from_witness_data_size_test() {

4
bitcoin/src/blockdata/witness.rs
View File

@ -82,12 +82,12 @@ impl Decodable for Witness {
let required_len = cursor
.checked_add(element_size)
.ok_or(self::Error::OversizedVectorAllocation {
requested: usize::max_value(),
requested: usize::MAX,
max: MAX_VEC_SIZE,
})?
.checked_add(element_size_varint_len)
.ok_or(self::Error::OversizedVectorAllocation {
requested: usize::max_value(),
requested: usize::MAX,
max: MAX_VEC_SIZE,
})?;

2
bitcoin/src/consensus/encode.rs
View File

@ -895,7 +895,7 @@ mod tests {
test_varint_len(VarInt(0x10000), 5);
test_varint_len(VarInt(0xFFFFFFFF), 5);
test_varint_len(VarInt(0xFFFFFFFF + 1), 9);
test_varint_len(VarInt(u64::max_value()), 9);
test_varint_len(VarInt(u64::MAX), 9);
}
fn test_varint_len(varint: VarInt, expected: usize) {

19
bitcoin/src/pow.rs
View File

@ -133,6 +133,7 @@ impl Target {
/// The maximum possible target (see [`Target::MAX`]).
///
/// This is provided for consistency with Rust 1.41.1, newer code should use [`Target::MAX`].
#[deprecated(since = "0.31.0", note = "Use Self::MAX instead")]
pub const fn max_value() -> Self { Target::MAX }
/// Computes the [`Target`] value from a compact representation.
@ -363,7 +364,7 @@ impl U256 {
fn is_one(&self) -> bool { self.0 == 0 && self.1 == 1 }
#[cfg_attr(all(test, mutate), mutate)]
fn is_max(&self) -> bool { self.0 == u128::max_value() && self.1 == u128::max_value() }
fn is_max(&self) -> bool { self.0 == u128::MAX && self.1 == u128::MAX }
/// Returns the low 32 bits.
fn low_u32(&self) -> u32 { self.low_u128() as u32 }
@ -377,8 +378,8 @@ impl U256 {
/// Returns `self` as a `u128` saturating to `u128::MAX` if `self` is too big.
// Matagen gives false positive because >= and > both return u128::MAX
fn saturating_to_u128(&self) -> u128 {
if *self > U256::from(u128::max_value()) {
u128::max_value()
if *self > U256::from(u128::MAX) {
u128::MAX
} else {
self.low_u128()
}
@ -937,7 +938,7 @@ mod tests {
assert_eq!(U256::from(60000_u64).bits(), 16);
assert_eq!(U256::from(70000_u64).bits(), 17);
let u = U256::from(u128::max_value()) << 1;
let u = U256::from(u128::MAX) << 1;
assert_eq!(u.bits(), 129);
// Try to read the following lines out loud quickly
@ -1009,7 +1010,7 @@ mod tests {
fn u256_display() {
assert_eq!(format!("{}", U256::from(100_u32)), "100",);
assert_eq!(format!("{}", U256::ZERO), "0",);
assert_eq!(format!("{}", U256::from(u64::max_value())), format!("{}", u64::max_value()),);
assert_eq!(format!("{}", U256::from(u64::MAX)), format!("{}", u64::MAX),);
assert_eq!(
format!("{}", U256::MAX),
"115792089237316195423570985008687907853269984665640564039457584007913129639935",
@ -1324,7 +1325,7 @@ mod tests {
#[test]
fn u256_addition() {
let x = U256::from(u128::max_value());
let x = U256::from(u128::MAX);
let (add, overflow) = x.overflowing_add(U256::ONE);
assert!(!overflow);
assert_eq!(add, U256(1, 0));
@ -1342,7 +1343,7 @@ mod tests {
let x = U256(1, 0);
let (sub, overflow) = x.overflowing_sub(U256::ONE);
assert!(!overflow);
assert_eq!(sub, U256::from(u128::max_value()));
assert_eq!(sub, U256::from(u128::MAX));
}
#[test]
@ -1475,7 +1476,7 @@ mod tests {
#[test]
fn u256_is_max_correct_negative() {
let tc = vec![U256::ZERO, U256::ONE, U256::from(u128::max_value())];
let tc = vec![U256::ZERO, U256::ONE, U256::from(u128::MAX)];
for t in tc {
assert!(!t.is_max())
}
@ -1485,7 +1486,7 @@ mod tests {
fn u256_is_max_correct_positive() {
assert!(U256::MAX.is_max());
let u = u128::max_value();
let u = u128::MAX;
assert!(((U256::from(u) << 128) + U256::from(u)).is_max());
}

4
bitcoin/src/psbt/mod.rs
View File

@ -1769,8 +1769,8 @@ mod tests {
e => panic!("unexpected error: {:?}", e),
}
// overflow
t.unsigned_tx.output[0].value = u64::max_value();
t.unsigned_tx.output[1].value = u64::max_value();
t.unsigned_tx.output[0].value = u64::MAX;
t.unsigned_tx.output[1].value = u64::MAX;
match t.fee().unwrap_err() {
Error::FeeOverflow => {}
e => panic!("unexpected error: {:?}", e),

2
internals/src/hex/display.rs
View File

@ -220,7 +220,7 @@ macro_rules! fmt_hex_exact {
($formatter:expr, $len:expr, $bytes:expr, $case:expr) => {{
// statically check $len
#[allow(deprecated)]
const _: () = [()][($len > usize::max_value() / 2) as usize];
const _: () = [()][($len > usize::MAX / 2) as usize];
assert_eq!($bytes.len(), $len);
let mut buf = [0u8; $len * 2];
let buf = $crate::hex::buf_encoder::AsOutBytes::as_mut_out_bytes(&mut buf);