From e9a9428f64c7e27333d3552ca89ec52a804225af Mon Sep 17 00:00:00 2001 From: forge-bot Date: Sat, 18 Jul 2026 11:16:33 +0000 Subject: [PATCH] =?UTF-8?q?[=EA=B3=B5=ED=86=B5]=20util=20=E2=86=92=20frame?= =?UTF-8?q?work=20=EC=9C=A0=ED=8B=B8=20(ACM-CM-002)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../acquirecore/framework/util/UtilTest.java | 217 ++++++++++++++++++ 1 file changed, 217 insertions(+) create mode 100644 boot/common-framework/src/test/java/com/klaro/acquirecore/framework/util/UtilTest.java diff --git a/boot/common-framework/src/test/java/com/klaro/acquirecore/framework/util/UtilTest.java b/boot/common-framework/src/test/java/com/klaro/acquirecore/framework/util/UtilTest.java new file mode 100644 index 0000000..f59d5a6 --- /dev/null +++ b/boot/common-framework/src/test/java/com/klaro/acquirecore/framework/util/UtilTest.java @@ -0,0 +1,217 @@ +package com.klaro.acquirecore.framework.util; + +import org.junit.jupiter.api.Test; +import java.math.BigDecimal; +import java.time.LocalDate; + +import static org.junit.jupiter.api.Assertions.*; + +class UtilTest { + + // DateUtil tests + @Test + void dateOf() { + LocalDate date = DateUtil.of(2024, 1, 15); + assertEquals(2024, date.getYear()); + assertEquals(1, date.getMonthValue()); + assertEquals(15, date.getDayOfMonth()); + } + + @Test + void dateToString() { + assertEquals("2024-06-20", DateUtil.toString(LocalDate.of(2024, 6, 20))); + assertNull(DateUtil.toString(null)); + } + + @Test + void dateFromString() { + LocalDate date = DateUtil.fromString("2024-03-25"); + assertEquals(2024, date.getYear()); + assertEquals(3, date.getMonthValue()); + assertEquals(25, date.getDayOfMonth()); + assertNull(DateUtil.fromString(null)); + assertNull(DateUtil.fromString("")); + } + + @Test + void dateDiffDays() { + assertEquals(9, DateUtil.diffDays(LocalDate.of(2024, 1, 10), LocalDate.of(2024, 1, 1))); + assertEquals(-9, DateUtil.diffDays(LocalDate.of(2024, 1, 1), LocalDate.of(2024, 1, 10))); + } + + @Test + void dateCompare() { + assertTrue(DateUtil.compare(LocalDate.of(2024, 2, 15), LocalDate.of(2024, 2, 10)) > 0); + assertTrue(DateUtil.compare(LocalDate.of(2024, 2, 10), LocalDate.of(2024, 2, 15)) < 0); + assertEquals(0, DateUtil.compare(LocalDate.of(2024, 2, 15), LocalDate.of(2024, 2, 15))); + } + + @Test + void dateAddDays() { + assertEquals(LocalDate.of(2024, 1, 25), DateUtil.addDays(LocalDate.of(2024, 1, 15), 10)); + assertEquals(LocalDate.of(2024, 1, 10), DateUtil.subtractDays(LocalDate.of(2024, 1, 15), 5)); + } + + @Test + void dateGetters() { + LocalDate date = LocalDate.of(2024, 6, 20); + assertEquals(2024, DateUtil.getYear(date)); + assertEquals(6, DateUtil.getMonth(date)); + assertEquals(20, DateUtil.getDay(date)); + } + + @Test + void dateIsBeforeAfter() { + assertTrue(DateUtil.isBefore(LocalDate.of(2024, 1, 10), LocalDate.of(2024, 1, 20))); + assertTrue(DateUtil.isAfter(LocalDate.of(2024, 1, 20), LocalDate.of(2024, 1, 10))); + } + + @Test + void dateIsEqual() { + assertTrue(DateUtil.isEqual(LocalDate.of(2024, 1, 15), LocalDate.of(2024, 1, 15))); + assertFalse(DateUtil.isEqual(LocalDate.of(2024, 1, 15), LocalDate.of(2024, 1, 20))); + assertTrue(DateUtil.isEqual(null, null)); + } + + // AmountUtil tests + @Test + void amountFromCents() { + assertEquals(new BigDecimal("100.50"), AmountUtil.fromCents(10050L)); + } + + @Test + void amountFromString() { + assertEquals(new BigDecimal("1234.56"), AmountUtil.fromString("1234.56")); + assertNull(AmountUtil.fromString(null)); + assertNull(AmountUtil.fromString("")); + } + + @Test + void amountToString() { + assertEquals("999.99", AmountUtil.toString(new BigDecimal("999.99"))); + assertNull(AmountUtil.toString(null)); + } + + @Test + void amountAdd() { + assertEquals(new BigDecimal("150.50"), AmountUtil.add(new BigDecimal("100.00"), new BigDecimal("50.50"))); + assertEquals(new BigDecimal("100.00"), AmountUtil.add(new BigDecimal("100.00"), null)); + } + + @Test + void amountSubtract() { + assertEquals(new BigDecimal("69.75"), AmountUtil.subtract(new BigDecimal("100.00"), new BigDecimal("30.25"))); + } + + @Test + void amountMultiply() { + assertEquals(new BigDecimal("150.00"), AmountUtil.multiply(new BigDecimal("100.00"), 1.5)); + assertEquals(new BigDecimal("10.00"), AmountUtil.multiply(new BigDecimal("100.00"), new BigDecimal("0.10"))); + } + + @Test + void amountDivide() { + assertEquals(new BigDecimal("25.00"), AmountUtil.divide(new BigDecimal("100.00"), new BigDecimal("4"))); + assertThrows(ArithmeticException.class, () -> AmountUtil.divide(new BigDecimal("100.00"), BigDecimal.ZERO)); + } + + @Test + void amountCompare() { + assertTrue(AmountUtil.compare(new BigDecimal("100.00"), new BigDecimal("50.00")) > 0); + assertEquals(0, AmountUtil.compare(null, null)); + } + + @Test + void amountToCents() { + assertEquals(12345L, AmountUtil.toCents(new BigDecimal("123.45"))); + assertEquals(0L, AmountUtil.toCents(null)); + } + + @Test + void amountIsZeroPositiveNegative() { + assertTrue(AmountUtil.isZero(BigDecimal.ZERO)); + assertTrue(AmountUtil.isPositive(new BigDecimal("1.00"))); + assertTrue(AmountUtil.isNegative(new BigDecimal("-1.00"))); + } + + @Test + void amountAbsNegate() { + assertEquals(new BigDecimal("50.00"), AmountUtil.abs(new BigDecimal("-50.00"))); + assertEquals(new BigDecimal("-50.00"), AmountUtil.negate(new BigDecimal("50.00"))); + } + + // MessageUtil tests + @Test + void msgCreate() { + byte[] data = MessageUtil.create("Hello"); + assertEquals(5, data.length); + assertNull(MessageUtil.create((String) null)); + } + + @Test + void msgToHex() { + assertEquals("ff00ab", MessageUtil.toHex(new byte[]{(byte) 0xFF, 0x00, (byte) 0xAB})); + assertNull(MessageUtil.toHex(null)); + } + + @Test + void msgFromHex() { + byte[] data = MessageUtil.fromHex("ff00ab"); + assertEquals(3, data.length); + assertNull(MessageUtil.fromHex(null)); + assertThrows(IllegalArgumentException.class, () -> MessageUtil.fromHex("abc")); + } + + @Test + void msgToBase64() { + assertEquals("SGVsbG8=", MessageUtil.toBase64("Hello".getBytes())); + assertNull(MessageUtil.toBase64(null)); + } + + @Test + void msgFromBase64() { + assertEquals("Hello", new String(MessageUtil.fromBase64("SGVsbG8="))); + assertNull(MessageUtil.fromBase64(null)); + } + + @Test + void msgGetLength() { + assertEquals(5, MessageUtil.getLength(new byte[]{1, 2, 3, 4, 5})); + assertEquals(0, MessageUtil.getLength(null)); + } + + @Test + void msgConcat() { + byte[] result = MessageUtil.concat(new byte[]{1, 2}, new byte[]{3, 4}); + assertArrayEquals(new byte[]{1, 2, 3, 4}, result); + assertNull(MessageUtil.concat(null, null)); + } + + @Test + void msgSubarray() { + byte[] result = MessageUtil.subarray(new byte[]{1, 2, 3, 4, 5}, 1, 3); + assertArrayEquals(new byte[]{2, 3, 4}, result); + assertThrows(IllegalArgumentException.class, () -> MessageUtil.subarray(new byte[]{1, 2, 3}, -1, 2)); + } + + @Test + void msgEquals() { + assertTrue(MessageUtil.equals(new byte[]{1, 2, 3}, new byte[]{1, 2, 3})); + assertFalse(MessageUtil.equals(new byte[]{1, 2, 3}, new byte[]{1, 2, 4})); + assertTrue(MessageUtil.equals(null, null)); + } + + @Test + void msgFill() { + byte[] data = new byte[3]; + MessageUtil.fill(data, (byte) 0xFF); + assertArrayEquals(new byte[]{(byte) 0xFF, (byte) 0xFF, (byte) 0xFF}, data); + } + + @Test + void msgRoundTrip() { + byte[] original = new byte[]{(byte) 0xDE, (byte) 0xAD, (byte) 0xBE, (byte) 0xEF}; + assertArrayEquals(original, MessageUtil.fromHex(MessageUtil.toHex(original))); + assertEquals("Test", new String(MessageUtil.fromBase64(MessageUtil.toBase64("Test".getBytes())))); + } +}