1996fanrui commented on code in PR #24670:
URL: https://github.com/apache/flink/pull/24670#discussion_r1596162533
##########
flink-core/src/test/java/org/apache/flink/util/AbstractIDTest.java:
##########
@@ -71,16 +67,16 @@ public void testCompare() throws Exception {
AbstractID id10 = new AbstractID(Long.MIN_VALUE, Long.MAX_VALUE);
// test self equality
- assertEquals(0,
id1.compareTo(CommonTestUtils.createCopySerializable(id1)));
- assertEquals(0,
id2.compareTo(CommonTestUtils.createCopySerializable(id2)));
- assertEquals(0,
id3.compareTo(CommonTestUtils.createCopySerializable(id3)));
- assertEquals(0,
id4.compareTo(CommonTestUtils.createCopySerializable(id4)));
- assertEquals(0,
id5.compareTo(CommonTestUtils.createCopySerializable(id5)));
- assertEquals(0,
id6.compareTo(CommonTestUtils.createCopySerializable(id6)));
- assertEquals(0,
id7.compareTo(CommonTestUtils.createCopySerializable(id7)));
- assertEquals(0,
id8.compareTo(CommonTestUtils.createCopySerializable(id8)));
- assertEquals(0,
id9.compareTo(CommonTestUtils.createCopySerializable(id9)));
- assertEquals(0,
id10.compareTo(CommonTestUtils.createCopySerializable(id10)));
+
assertThat(id1.compareTo(CommonTestUtils.createCopySerializable(id1))).isZero();
Review Comment:
```suggestion
assertThat(id1).isEqualByComparingTo(CommonTestUtils.createCopySerializable(id1));
```
The rest can be updated as well
##########
flink-core/src/test/java/org/apache/flink/util/TimeUtilsTest.java:
##########
@@ -20,173 +20,153 @@
import org.apache.flink.api.common.time.Time;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
import java.time.Duration;
import java.time.temporal.ChronoUnit;
import java.util.concurrent.TimeUnit;
-import static org.hamcrest.CoreMatchers.equalTo;
-import static org.hamcrest.CoreMatchers.is;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertThat;
-import static org.junit.Assert.fail;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
/** Tests for {@link TimeUtils}. */
-public class TimeUtilsTest {
+class TimeUtilsTest {
@Test
- public void testParseDurationNanos() {
- assertEquals(424562, TimeUtils.parseDuration("424562ns").getNano());
- assertEquals(424562, TimeUtils.parseDuration("424562nano").getNano());
- assertEquals(424562, TimeUtils.parseDuration("424562nanos").getNano());
- assertEquals(424562,
TimeUtils.parseDuration("424562nanosecond").getNano());
- assertEquals(424562,
TimeUtils.parseDuration("424562nanoseconds").getNano());
- assertEquals(424562, TimeUtils.parseDuration("424562 ns").getNano());
+ void testParseDurationNanos() {
+
assertThat(TimeUtils.parseDuration("424562ns").getNano()).isEqualTo(424562);
+
assertThat(TimeUtils.parseDuration("424562nano").getNano()).isEqualTo(424562);
+
assertThat(TimeUtils.parseDuration("424562nanos").getNano()).isEqualTo(424562);
+
assertThat(TimeUtils.parseDuration("424562nanosecond").getNano()).isEqualTo(424562);
+
assertThat(TimeUtils.parseDuration("424562nanoseconds").getNano()).isEqualTo(424562);
+ assertThat(TimeUtils.parseDuration("424562
ns").getNano()).isEqualTo(424562);
}
@Test
- public void testParseDurationMicros() {
- assertEquals(565731 * 1000L,
TimeUtils.parseDuration("565731µs").getNano());
- assertEquals(565731 * 1000L,
TimeUtils.parseDuration("565731micro").getNano());
- assertEquals(565731 * 1000L,
TimeUtils.parseDuration("565731micros").getNano());
- assertEquals(565731 * 1000L,
TimeUtils.parseDuration("565731microsecond").getNano());
- assertEquals(565731 * 1000L,
TimeUtils.parseDuration("565731microseconds").getNano());
- assertEquals(565731 * 1000L, TimeUtils.parseDuration("565731
µs").getNano());
+ void testParseDurationMicros() {
+
assertThat(TimeUtils.parseDuration("565731µs").getNano()).isEqualTo(565731 *
1000L);
+
assertThat(TimeUtils.parseDuration("565731micro").getNano()).isEqualTo(565731 *
1000L);
+
assertThat(TimeUtils.parseDuration("565731micros").getNano()).isEqualTo(565731
* 1000L);
+ assertThat(TimeUtils.parseDuration("565731microsecond").getNano())
+ .isEqualTo(565731 * 1000L);
+ assertThat(TimeUtils.parseDuration("565731microseconds").getNano())
+ .isEqualTo(565731 * 1000L);
+ assertThat(TimeUtils.parseDuration("565731
µs").getNano()).isEqualTo(565731 * 1000L);
}
@Test
- public void testParseDurationMillis() {
- assertEquals(1234, TimeUtils.parseDuration("1234").toMillis());
- assertEquals(1234, TimeUtils.parseDuration("1234ms").toMillis());
- assertEquals(1234, TimeUtils.parseDuration("1234milli").toMillis());
- assertEquals(1234, TimeUtils.parseDuration("1234millis").toMillis());
- assertEquals(1234,
TimeUtils.parseDuration("1234millisecond").toMillis());
- assertEquals(1234,
TimeUtils.parseDuration("1234milliseconds").toMillis());
- assertEquals(1234, TimeUtils.parseDuration("1234 ms").toMillis());
+ void testParseDurationMillis() {
+ assertThat(TimeUtils.parseDuration("1234").toMillis()).isEqualTo(1234);
+
assertThat(TimeUtils.parseDuration("1234ms").toMillis()).isEqualTo(1234);
+
assertThat(TimeUtils.parseDuration("1234milli").toMillis()).isEqualTo(1234);
+
assertThat(TimeUtils.parseDuration("1234millis").toMillis()).isEqualTo(1234);
+
assertThat(TimeUtils.parseDuration("1234millisecond").toMillis()).isEqualTo(1234);
+
assertThat(TimeUtils.parseDuration("1234milliseconds").toMillis()).isEqualTo(1234);
+ assertThat(TimeUtils.parseDuration("1234
ms").toMillis()).isEqualTo(1234);
}
@Test
- public void testParseDurationSeconds() {
- assertEquals(667766, TimeUtils.parseDuration("667766s").getSeconds());
- assertEquals(667766,
TimeUtils.parseDuration("667766sec").getSeconds());
- assertEquals(667766,
TimeUtils.parseDuration("667766secs").getSeconds());
- assertEquals(667766,
TimeUtils.parseDuration("667766second").getSeconds());
- assertEquals(667766,
TimeUtils.parseDuration("667766seconds").getSeconds());
- assertEquals(667766, TimeUtils.parseDuration("667766 s").getSeconds());
+ void testParseDurationSeconds() {
+
assertThat(TimeUtils.parseDuration("667766s").getSeconds()).isEqualTo(667766);
+
assertThat(TimeUtils.parseDuration("667766sec").getSeconds()).isEqualTo(667766);
+
assertThat(TimeUtils.parseDuration("667766secs").getSeconds()).isEqualTo(667766);
+
assertThat(TimeUtils.parseDuration("667766second").getSeconds()).isEqualTo(667766);
+
assertThat(TimeUtils.parseDuration("667766seconds").getSeconds()).isEqualTo(667766);
+ assertThat(TimeUtils.parseDuration("667766
s").getSeconds()).isEqualTo(667766);
}
@Test
- public void testParseDurationMinutes() {
- assertEquals(7657623, TimeUtils.parseDuration("7657623m").toMinutes());
- assertEquals(7657623,
TimeUtils.parseDuration("7657623min").toMinutes());
- assertEquals(7657623,
TimeUtils.parseDuration("7657623minute").toMinutes());
- assertEquals(7657623,
TimeUtils.parseDuration("7657623minutes").toMinutes());
- assertEquals(7657623, TimeUtils.parseDuration("7657623
min").toMinutes());
+ void testParseDurationMinutes() {
+
assertThat(TimeUtils.parseDuration("7657623m").toMinutes()).isEqualTo(7657623);
+
assertThat(TimeUtils.parseDuration("7657623min").toMinutes()).isEqualTo(7657623);
+
assertThat(TimeUtils.parseDuration("7657623minute").toMinutes()).isEqualTo(7657623);
+
assertThat(TimeUtils.parseDuration("7657623minutes").toMinutes()).isEqualTo(7657623);
+ assertThat(TimeUtils.parseDuration("7657623
min").toMinutes()).isEqualTo(7657623);
}
@Test
- public void testParseDurationHours() {
- assertEquals(987654, TimeUtils.parseDuration("987654h").toHours());
- assertEquals(987654, TimeUtils.parseDuration("987654hour").toHours());
- assertEquals(987654, TimeUtils.parseDuration("987654hours").toHours());
- assertEquals(987654, TimeUtils.parseDuration("987654 h").toHours());
+ void testParseDurationHours() {
+
assertThat(TimeUtils.parseDuration("987654h").toHours()).isEqualTo(987654);
+
assertThat(TimeUtils.parseDuration("987654hour").toHours()).isEqualTo(987654);
+
assertThat(TimeUtils.parseDuration("987654hours").toHours()).isEqualTo(987654);
+ assertThat(TimeUtils.parseDuration("987654
h").toHours()).isEqualTo(987654);
}
@Test
- public void testParseDurationDays() {
- assertEquals(987654, TimeUtils.parseDuration("987654d").toDays());
- assertEquals(987654, TimeUtils.parseDuration("987654day").toDays());
- assertEquals(987654, TimeUtils.parseDuration("987654days").toDays());
- assertEquals(987654, TimeUtils.parseDuration("987654 d").toDays());
+ void testParseDurationDays() {
+
assertThat(TimeUtils.parseDuration("987654d").toDays()).isEqualTo(987654);
+
assertThat(TimeUtils.parseDuration("987654day").toDays()).isEqualTo(987654);
+
assertThat(TimeUtils.parseDuration("987654days").toDays()).isEqualTo(987654);
+ assertThat(TimeUtils.parseDuration("987654
d").toDays()).isEqualTo(987654);
}
@Test
- public void testParseDurationUpperCase() {
- assertEquals(1L, TimeUtils.parseDuration("1 NS").toNanos());
- assertEquals(1000L, TimeUtils.parseDuration("1 MICRO").toNanos());
- assertEquals(1L, TimeUtils.parseDuration("1 MS").toMillis());
- assertEquals(1L, TimeUtils.parseDuration("1 S").getSeconds());
- assertEquals(1L, TimeUtils.parseDuration("1 MIN").toMinutes());
- assertEquals(1L, TimeUtils.parseDuration("1 H").toHours());
- assertEquals(1L, TimeUtils.parseDuration("1 D").toDays());
+ void testParseDurationUpperCase() {
+ assertThat(TimeUtils.parseDuration("1 NS").toNanos()).isEqualTo(1L);
+ assertThat(TimeUtils.parseDuration("1
MICRO").toNanos()).isEqualTo(1000L);
+ assertThat(TimeUtils.parseDuration("1 MS").toMillis()).isEqualTo(1L);
+ assertThat(TimeUtils.parseDuration("1 S").getSeconds()).isEqualTo(1L);
+ assertThat(TimeUtils.parseDuration("1 MIN").toMinutes()).isEqualTo(1L);
+ assertThat(TimeUtils.parseDuration("1 H").toHours()).isEqualTo(1L);
+ assertThat(TimeUtils.parseDuration("1 D").toDays()).isEqualTo(1L);
Review Comment:
Most of them can be updated to isOne().
##########
flink-core/src/test/java/org/apache/flink/util/ReferenceTest.java:
##########
@@ -18,39 +18,39 @@
package org.apache.flink.util;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import static org.assertj.core.api.Assertions.assertThat;
/** Tests for the {@link Reference}. */
@ExtendWith({TestLoggerExtension.class})
Review Comment:
TestLoggerExtension has been enabled at module level, so it can be removed
here.
##########
flink-core/src/test/java/org/apache/flink/util/MathUtilTest.java:
##########
@@ -18,155 +18,149 @@
package org.apache.flink.util;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
-import static org.hamcrest.Matchers.is;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertThat;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
/** Tests for the {@link MathUtils}. */
-public class MathUtilTest {
+class MathUtilTest {
@Test
- public void testLog2Computation() {
- assertEquals(0, MathUtils.log2floor(1));
- assertEquals(1, MathUtils.log2floor(2));
- assertEquals(1, MathUtils.log2floor(3));
- assertEquals(2, MathUtils.log2floor(4));
- assertEquals(2, MathUtils.log2floor(5));
- assertEquals(2, MathUtils.log2floor(7));
- assertEquals(3, MathUtils.log2floor(8));
- assertEquals(3, MathUtils.log2floor(9));
- assertEquals(4, MathUtils.log2floor(16));
- assertEquals(4, MathUtils.log2floor(17));
- assertEquals(13, MathUtils.log2floor((0x1 << 13) + 1));
- assertEquals(30, MathUtils.log2floor(Integer.MAX_VALUE));
- assertEquals(31, MathUtils.log2floor(-1));
+ void testLog2Computation() {
+ assertThat(MathUtils.log2floor(1)).isZero();
+ assertThat(MathUtils.log2floor(2)).isOne();
+ assertThat(MathUtils.log2floor(3)).isOne();
+ assertThat(MathUtils.log2floor(4)).isEqualTo(2);
+ assertThat(MathUtils.log2floor(5)).isEqualTo(2);
+ assertThat(MathUtils.log2floor(7)).isEqualTo(2);
+ assertThat(MathUtils.log2floor(8)).isEqualTo(3);
+ assertThat(MathUtils.log2floor(9)).isEqualTo(3);
+ assertThat(MathUtils.log2floor(16)).isEqualTo(4);
+ assertThat(MathUtils.log2floor(17)).isEqualTo(4);
+ assertThat(MathUtils.log2floor((0x1 << 13) + 1)).isEqualTo(13);
+ assertThat(MathUtils.log2floor(Integer.MAX_VALUE)).isEqualTo(30);
+ assertThat(MathUtils.log2floor(-1)).isEqualTo(31);
- try {
- MathUtils.log2floor(0);
- fail();
- } catch (ArithmeticException ignored) {
- }
+ assertThatThrownBy(() ->
MathUtils.log2floor(0)).isInstanceOf(ArithmeticException.class);
}
@Test
- public void testRoundDownToPowerOf2() {
- assertEquals(0, MathUtils.roundDownToPowerOf2(0));
- assertEquals(1, MathUtils.roundDownToPowerOf2(1));
- assertEquals(2, MathUtils.roundDownToPowerOf2(2));
- assertEquals(2, MathUtils.roundDownToPowerOf2(3));
- assertEquals(4, MathUtils.roundDownToPowerOf2(4));
- assertEquals(4, MathUtils.roundDownToPowerOf2(5));
- assertEquals(4, MathUtils.roundDownToPowerOf2(6));
- assertEquals(4, MathUtils.roundDownToPowerOf2(7));
- assertEquals(8, MathUtils.roundDownToPowerOf2(8));
- assertEquals(8, MathUtils.roundDownToPowerOf2(9));
- assertEquals(8, MathUtils.roundDownToPowerOf2(15));
- assertEquals(16, MathUtils.roundDownToPowerOf2(16));
- assertEquals(16, MathUtils.roundDownToPowerOf2(17));
- assertEquals(16, MathUtils.roundDownToPowerOf2(31));
- assertEquals(32, MathUtils.roundDownToPowerOf2(32));
- assertEquals(32, MathUtils.roundDownToPowerOf2(33));
- assertEquals(32, MathUtils.roundDownToPowerOf2(42));
- assertEquals(32, MathUtils.roundDownToPowerOf2(63));
- assertEquals(64, MathUtils.roundDownToPowerOf2(64));
- assertEquals(64, MathUtils.roundDownToPowerOf2(125));
- assertEquals(16384, MathUtils.roundDownToPowerOf2(25654));
- assertEquals(33554432, MathUtils.roundDownToPowerOf2(34366363));
- assertEquals(33554432, MathUtils.roundDownToPowerOf2(63463463));
- assertEquals(1073741824, MathUtils.roundDownToPowerOf2(1852987883));
- assertEquals(1073741824,
MathUtils.roundDownToPowerOf2(Integer.MAX_VALUE));
+ void testRoundDownToPowerOf2() {
+ assertThat(MathUtils.roundDownToPowerOf2(0)).isZero();
+ assertThat(MathUtils.roundDownToPowerOf2(1)).isOne();
+ assertThat(MathUtils.roundDownToPowerOf2(2)).isEqualTo(2);
+ assertThat(MathUtils.roundDownToPowerOf2(3)).isEqualTo(2);
+ assertThat(MathUtils.roundDownToPowerOf2(4)).isEqualTo(4);
+ assertThat(MathUtils.roundDownToPowerOf2(5)).isEqualTo(4);
+ assertThat(MathUtils.roundDownToPowerOf2(6)).isEqualTo(4);
+ assertThat(MathUtils.roundDownToPowerOf2(7)).isEqualTo(4);
+ assertThat(MathUtils.roundDownToPowerOf2(8)).isEqualTo(8);
+ assertThat(MathUtils.roundDownToPowerOf2(9)).isEqualTo(8);
+ assertThat(MathUtils.roundDownToPowerOf2(15)).isEqualTo(8);
+ assertThat(MathUtils.roundDownToPowerOf2(16)).isEqualTo(16);
+ assertThat(MathUtils.roundDownToPowerOf2(17)).isEqualTo(16);
+ assertThat(MathUtils.roundDownToPowerOf2(31)).isEqualTo(16);
+ assertThat(MathUtils.roundDownToPowerOf2(32)).isEqualTo(32);
+ assertThat(MathUtils.roundDownToPowerOf2(33)).isEqualTo(32);
+ assertThat(MathUtils.roundDownToPowerOf2(42)).isEqualTo(32);
+ assertThat(MathUtils.roundDownToPowerOf2(63)).isEqualTo(32);
+ assertThat(MathUtils.roundDownToPowerOf2(64)).isEqualTo(64);
+ assertThat(MathUtils.roundDownToPowerOf2(125)).isEqualTo(64);
+ assertThat(MathUtils.roundDownToPowerOf2(25654)).isEqualTo(16384);
+
assertThat(MathUtils.roundDownToPowerOf2(34366363)).isEqualTo(33554432);
+
assertThat(MathUtils.roundDownToPowerOf2(63463463)).isEqualTo(33554432);
+
assertThat(MathUtils.roundDownToPowerOf2(1852987883)).isEqualTo(1073741824);
+
assertThat(MathUtils.roundDownToPowerOf2(Integer.MAX_VALUE)).isEqualTo(1073741824);
}
@Test
- public void testRoundUpToPowerOf2() {
- assertEquals(0, MathUtils.roundUpToPowerOfTwo(0));
- assertEquals(1, MathUtils.roundUpToPowerOfTwo(1));
- assertEquals(2, MathUtils.roundUpToPowerOfTwo(2));
- assertEquals(4, MathUtils.roundUpToPowerOfTwo(3));
- assertEquals(4, MathUtils.roundUpToPowerOfTwo(4));
- assertEquals(8, MathUtils.roundUpToPowerOfTwo(5));
- assertEquals(8, MathUtils.roundUpToPowerOfTwo(6));
- assertEquals(8, MathUtils.roundUpToPowerOfTwo(7));
- assertEquals(8, MathUtils.roundUpToPowerOfTwo(8));
- assertEquals(16, MathUtils.roundUpToPowerOfTwo(9));
- assertEquals(16, MathUtils.roundUpToPowerOfTwo(15));
- assertEquals(16, MathUtils.roundUpToPowerOfTwo(16));
- assertEquals(32, MathUtils.roundUpToPowerOfTwo(17));
- assertEquals(32, MathUtils.roundUpToPowerOfTwo(31));
- assertEquals(32, MathUtils.roundUpToPowerOfTwo(32));
- assertEquals(64, MathUtils.roundUpToPowerOfTwo(33));
- assertEquals(64, MathUtils.roundUpToPowerOfTwo(42));
- assertEquals(64, MathUtils.roundUpToPowerOfTwo(63));
- assertEquals(64, MathUtils.roundUpToPowerOfTwo(64));
- assertEquals(128, MathUtils.roundUpToPowerOfTwo(125));
- assertEquals(32768, MathUtils.roundUpToPowerOfTwo(25654));
- assertEquals(67108864, MathUtils.roundUpToPowerOfTwo(34366363));
- assertEquals(67108864, MathUtils.roundUpToPowerOfTwo(67108863));
- assertEquals(67108864, MathUtils.roundUpToPowerOfTwo(67108864));
- assertEquals(0x40000000, MathUtils.roundUpToPowerOfTwo(0x3FFFFFFE));
- assertEquals(0x40000000, MathUtils.roundUpToPowerOfTwo(0x3FFFFFFF));
- assertEquals(0x40000000, MathUtils.roundUpToPowerOfTwo(0x40000000));
+ void testRoundUpToPowerOf2() {
+ assertThat(MathUtils.roundUpToPowerOfTwo(0)).isZero();
+ assertThat(MathUtils.roundUpToPowerOfTwo(1)).isOne();
+ assertThat(MathUtils.roundUpToPowerOfTwo(2)).isEqualTo(2);
+ assertThat(MathUtils.roundUpToPowerOfTwo(3)).isEqualTo(4);
+ assertThat(MathUtils.roundUpToPowerOfTwo(4)).isEqualTo(4);
+ assertThat(MathUtils.roundUpToPowerOfTwo(5)).isEqualTo(8);
+ assertThat(MathUtils.roundUpToPowerOfTwo(6)).isEqualTo(8);
+ assertThat(MathUtils.roundUpToPowerOfTwo(7)).isEqualTo(8);
+ assertThat(MathUtils.roundUpToPowerOfTwo(8)).isEqualTo(8);
+ assertThat(MathUtils.roundUpToPowerOfTwo(9)).isEqualTo(16);
+ assertThat(MathUtils.roundUpToPowerOfTwo(15)).isEqualTo(16);
+ assertThat(MathUtils.roundUpToPowerOfTwo(16)).isEqualTo(16);
+ assertThat(MathUtils.roundUpToPowerOfTwo(17)).isEqualTo(32);
+ assertThat(MathUtils.roundUpToPowerOfTwo(31)).isEqualTo(32);
+ assertThat(MathUtils.roundUpToPowerOfTwo(32)).isEqualTo(32);
+ assertThat(MathUtils.roundUpToPowerOfTwo(33)).isEqualTo(64);
+ assertThat(MathUtils.roundUpToPowerOfTwo(42)).isEqualTo(64);
+ assertThat(MathUtils.roundUpToPowerOfTwo(63)).isEqualTo(64);
+ assertThat(MathUtils.roundUpToPowerOfTwo(64)).isEqualTo(64);
+ assertThat(MathUtils.roundUpToPowerOfTwo(125)).isEqualTo(128);
+ assertThat(MathUtils.roundUpToPowerOfTwo(25654)).isEqualTo(32768);
+
assertThat(MathUtils.roundUpToPowerOfTwo(34366363)).isEqualTo(67108864);
+
assertThat(MathUtils.roundUpToPowerOfTwo(67108863)).isEqualTo(67108864);
+
assertThat(MathUtils.roundUpToPowerOfTwo(67108864)).isEqualTo(67108864);
+
assertThat(MathUtils.roundUpToPowerOfTwo(0x3FFFFFFE)).isEqualTo(0x40000000);
+
assertThat(MathUtils.roundUpToPowerOfTwo(0x3FFFFFFF)).isEqualTo(0x40000000);
+
assertThat(MathUtils.roundUpToPowerOfTwo(0x40000000)).isEqualTo(0x40000000);
}
@Test
- public void testPowerOfTwo() {
- assertTrue(MathUtils.isPowerOf2(1));
- assertTrue(MathUtils.isPowerOf2(2));
- assertTrue(MathUtils.isPowerOf2(4));
- assertTrue(MathUtils.isPowerOf2(8));
- assertTrue(MathUtils.isPowerOf2(32768));
- assertTrue(MathUtils.isPowerOf2(65536));
- assertTrue(MathUtils.isPowerOf2(1 << 30));
- assertTrue(MathUtils.isPowerOf2(1L + Integer.MAX_VALUE));
- assertTrue(MathUtils.isPowerOf2(1L << 41));
- assertTrue(MathUtils.isPowerOf2(1L << 62));
+ void testPowerOfTwo() {
+ assertThat(MathUtils.isPowerOf2(1)).isTrue();
+ assertThat(MathUtils.isPowerOf2(2)).isTrue();
+ assertThat(MathUtils.isPowerOf2(4)).isTrue();
+ assertThat(MathUtils.isPowerOf2(8)).isTrue();
+ assertThat(MathUtils.isPowerOf2(32768)).isTrue();
+ assertThat(MathUtils.isPowerOf2(65536)).isTrue();
+ assertThat(MathUtils.isPowerOf2(1 << 30)).isTrue();
+ assertThat(MathUtils.isPowerOf2(1L + Integer.MAX_VALUE)).isTrue();
+ assertThat(MathUtils.isPowerOf2(1L << 41)).isTrue();
+ assertThat(MathUtils.isPowerOf2(1L << 62)).isTrue();
- assertFalse(MathUtils.isPowerOf2(3));
- assertFalse(MathUtils.isPowerOf2(5));
- assertFalse(MathUtils.isPowerOf2(567923));
- assertFalse(MathUtils.isPowerOf2(Integer.MAX_VALUE));
- assertFalse(MathUtils.isPowerOf2(Long.MAX_VALUE));
+ assertThat(MathUtils.isPowerOf2(3)).isFalse();
+ assertThat(MathUtils.isPowerOf2(5)).isFalse();
+ assertThat(MathUtils.isPowerOf2(567923)).isFalse();
+ assertThat(MathUtils.isPowerOf2(Integer.MAX_VALUE)).isFalse();
+ assertThat(MathUtils.isPowerOf2(Long.MAX_VALUE)).isFalse();
}
@Test
- public void testFlipSignBit() {
- Assert.assertEquals(0L, MathUtils.flipSignBit(Long.MIN_VALUE));
- Assert.assertEquals(Long.MIN_VALUE, MathUtils.flipSignBit(0L));
- Assert.assertEquals(-1L, MathUtils.flipSignBit(Long.MAX_VALUE));
- Assert.assertEquals(Long.MAX_VALUE, MathUtils.flipSignBit(-1L));
- Assert.assertEquals(42L | Long.MIN_VALUE, MathUtils.flipSignBit(42L));
- Assert.assertEquals(-42L & Long.MAX_VALUE,
MathUtils.flipSignBit(-42L));
+ void testFlipSignBit() {
+ assertThat(MathUtils.flipSignBit(Long.MIN_VALUE)).isEqualTo(0L);
Review Comment:
```suggestion
assertThat(MathUtils.flipSignBit(Long.MIN_VALUE)).isZero();
```
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: [email protected]
For queries about this service, please contact Infrastructure at:
[email protected]
