Use MAX associated const (#9196)

* Use MAX associated const

substrate/primitives/runtime/src/curve.rs

@@ -112,17 +112,17 @@ fn test_multiply_by_rational_saturating() {
 	for value in 0..=div {
 		for p in 0..=div {
 			for q in 1..=div {
-				let value: u64 = (value as u128 * u64::max_value() as u128 / div as u128)
+				let value: u64 = (value as u128 * u64::MAX as u128 / div as u128)
 					.try_into().unwrap();
-				let p = (p as u64 * u32::max_value() as u64 / div as u64)
+				let p = (p as u64 * u32::MAX as u64 / div as u64)
 					.try_into().unwrap();
-				let q = (q as u64 * u32::max_value() as u64 / div as u64)
+				let q = (q as u64 * u32::MAX as u64 / div as u64)
 					.try_into().unwrap();
 
 				assert_eq!(
 					multiply_by_rational_saturating(value, p, q),
 					(value as u128 * p as u128 / q as u128)
-						.try_into().unwrap_or(u64::max_value())
+						.try_into().unwrap_or(u64::MAX)
 				);
 			}
 		}
@@ -153,9 +153,9 @@ fn test_calculate_for_fraction_times_denominator() {
 	let div = 100u32;
 	for d in 0..=div {
 		for n in 0..=d {
-			let d: u64 = (d as u128 * u64::max_value() as u128 / div as u128)
+			let d: u64 = (d as u128 * u64::MAX as u128 / div as u128)
 				.try_into().unwrap();
-			let n: u64 = (n as u128 * u64::max_value() as u128 / div as u128)
+			let n: u64 = (n as u128 * u64::MAX as u128 / div as u128)
 				.try_into().unwrap();
 
 			let res = curve.calculate_for_fraction_times_denominator(n, d);

substrate/primitives/runtime/src/generic/era.rs

@@ -97,7 +97,7 @@ impl Era {
 	/// Get the block number of the first block at which the era has ended.
 	pub fn death(self, current: u64) -> u64 {
 		match self {
-			Self::Immortal => u64::max_value(),
+			Self::Immortal => u64::MAX,
 			Self::Mortal(period, _) => self.birth(current) + period,
 		}
 	}
@@ -145,11 +145,11 @@ mod tests {
 	fn immortal_works() {
 		let e = Era::immortal();
 		assert_eq!(e.birth(0), 0);
-		assert_eq!(e.death(0), u64::max_value());
+		assert_eq!(e.death(0), u64::MAX);
 		assert_eq!(e.birth(1), 0);
-		assert_eq!(e.death(1), u64::max_value());
-		assert_eq!(e.birth(u64::max_value()), 0);
-		assert_eq!(e.death(u64::max_value()), u64::max_value());
+		assert_eq!(e.death(1), u64::MAX);
+		assert_eq!(e.birth(u64::MAX), 0);
+		assert_eq!(e.death(u64::MAX), u64::MAX);
 		assert!(e.is_immortal());
 
 		assert_eq!(e.encode(), vec![0u8]);

substrate/primitives/runtime/src/generic/header.rs

@@ -200,8 +200,8 @@ mod tests {
 
 		assert_eq!(serialize(0), "\"0x0\"".to_owned());
 		assert_eq!(serialize(1), "\"0x1\"".to_owned());
-		assert_eq!(serialize(u64::max_value() as u128), "\"0xffffffffffffffff\"".to_owned());
-		assert_eq!(serialize(u64::max_value() as u128 + 1), "\"0x10000000000000000\"".to_owned());
+		assert_eq!(serialize(u64::MAX as u128), "\"0xffffffffffffffff\"".to_owned());
+		assert_eq!(serialize(u64::MAX as u128 + 1), "\"0x10000000000000000\"".to_owned());
 	}
 
 	#[test]
@@ -213,7 +213,7 @@ mod tests {
 
 		assert_eq!(deserialize("\"0x0\""), 0);
 		assert_eq!(deserialize("\"0x1\""), 1);
-		assert_eq!(deserialize("\"0xffffffffffffffff\""), u64::max_value() as u128);
-		assert_eq!(deserialize("\"0x10000000000000000\""), u64::max_value() as u128 + 1);
+		assert_eq!(deserialize("\"0xffffffffffffffff\""), u64::MAX as u128);
+		assert_eq!(deserialize("\"0x10000000000000000\""), u64::MAX as u128 + 1);
 	}
 }

substrate/primitives/runtime/src/random_number_generator.rs

@@ -76,7 +76,7 @@ impl<Hashing: Hash> RandomNumberGenerator<Hashing> {
 			self.offset += needed as u32;
 			let raw = u32::decode(&mut TrailingZeroInput::new(data)).unwrap_or(0);
 			if raw <= top {
-				break if max < u32::max_value() {
+				break if max < u32::MAX {
 					raw % (max + 1)
 				} else {
 					raw