diff --git a/pom.xml b/pom.xml index 38384f7f..8ecb6c66 100644 --- a/pom.xml +++ b/pom.xml @@ -58,7 +58,6 @@ UTF-8 UTF-8 3.25.8 - 5.18.0 -XX:+EnableDynamicAgentLoading @@ -76,6 +75,20 @@ pom import + + org.junit + junit-bom + 5.13.4 + pom + import + + + org.mockito + mockito-bom + 5.19.0 + pom + import + @@ -101,24 +114,39 @@ test + + org.junit.jupiter + junit-jupiter-api + test + + + + org.junit.jupiter + junit-jupiter-params + test + + org.junit.jupiter junit-jupiter-engine - 5.13.4 test org.mockito mockito-core - ${mockito.version} test org.mockito mockito-junit-jupiter - ${mockito.version} + test + + + com.google.truth + truth + [1.4.4,) test diff --git a/src/main/java/org/eclipse/uprotocol/uuid/factory/UuidUtils.java b/src/main/java/org/eclipse/uprotocol/uuid/factory/UuidUtils.java index 7367a42a..8b3c54a0 100644 --- a/src/main/java/org/eclipse/uprotocol/uuid/factory/UuidUtils.java +++ b/src/main/java/org/eclipse/uprotocol/uuid/factory/UuidUtils.java @@ -12,7 +12,6 @@ */ package org.eclipse.uprotocol.uuid.factory; -import com.github.f4b6a3.uuid.enums.UuidVariant; import com.github.f4b6a3.uuid.util.UuidTime; import com.github.f4b6a3.uuid.util.UuidUtil; import org.eclipse.uprotocol.v1.UUID; @@ -22,55 +21,66 @@ /** * Utility methods for uProtocol UUIDs. */ -public interface UuidUtils { +public final class UuidUtils { - /** - * Fetch the UUID version. - * - * @param uuid The UUID to fetch the version from. - * @return the UUID version from the UUID object or Optional.empty() if the uuid - * is null. - */ - static Optional getVersion(UUID uuid) { + private static final int VARIANT_RFC_9562 = 0b10; + private static final int VERSION_UUIDV6 = 6; + private static final int VERSION_UPROTOCOL = 7; + + private UuidUtils() { + // Utility class + } + + private static byte getVersion(UUID uuid) { // Version is bits masked by 0x000000000000F000 in MS long - return uuid == null ? Optional.empty() : Version.getVersion((int) ((uuid.getMsb() >> 12) & 0x0f)); + return (byte) ((uuid.getMsb() >> 12) & 0x0f); } /** - * Fetch the Variant from the passed UUID. + * Checks if a UUID is in the RFC 9562 variant. * - * @param uuid The UUID to fetch the variant from. - * @return UUID variant or Empty if uuid is null. + * @param uuid The UUID to check. + * @return {@code true} if the UUID is in the RFC 9562 variant, {@code false} if uuid is {@code null}. */ - static Optional getVariant(UUID uuid) { - return uuid == null ? Optional.empty() - : Optional.of( - (int) ((uuid.getLsb() >>> (64 - (uuid.getLsb() >>> 62))) & (uuid.getLsb() >> 63))); + public static boolean isRfc9562Variant(UUID uuid) { + return Optional.ofNullable(uuid) + .map(id -> (byte) (id.getLsb() >>> 62)) + .map(variant -> variant == VARIANT_RFC_9562) + .orElse(false); } /** - * Verify if version is a formal UUIDv7 uProtocol ID. + * Checks if a UUID is a uProtocol UUID. * * @param uuid The UUID to check. - * @return true if is a uProtocol UUID or false if uuid passed is null - * or the UUID is not uProtocol format. + * @return {@code true} if is a uProtocol UUID or {@code false} if uuid is {@code null} + * or is not a v7 UUID. + * @see RFC 9562 + * @see + * uProtocol UUID specification */ - static boolean isUProtocol(UUID uuid) { - final Optional version = getVersion(uuid); - return uuid != null && version.isPresent() && version.get() == Version.VERSION_UPROTOCOL; + public static boolean isUProtocol(UUID uuid) { + return Optional.ofNullable(uuid) + .filter(UuidUtils::isRfc9562Variant) + .map(UuidUtils::getVersion) + .map(version -> version == VERSION_UPROTOCOL) + .orElse(false); } /** - * Verify if version is UUIDv6. + * Checks if a UUID is a v6 UUID. * * @param uuid The UUID to check. - * @return true if is UUID version 6 or false if uuid is null or not version 6 + * @return {@code true} if is a v6 UUID or {@code false} if uuid is {@code null} + * or is not a v6 UUID. + * @see RFC 9562 */ - static boolean isUuidv6(UUID uuid) { - final Optional version = getVersion(uuid); - final Optional variant = getVariant(uuid); - return uuid != null && version.isPresent() && version.get() == Version.VERSION_TIME_ORDERED - && variant.get() == UuidVariant.VARIANT_RFC_4122.getValue(); + public static boolean isUuidv6(UUID uuid) { + return Optional.ofNullable(uuid) + .filter(UuidUtils::isRfc9562Variant) + .map(UuidUtils::getVersion) + .map(version -> version == VERSION_UUIDV6) + .orElse(false); } /** @@ -79,41 +89,39 @@ static boolean isUuidv6(UUID uuid) { * @param uuid The UUID to check. * @return true if is UUID version 6 or 7 */ - static boolean isUuid(UUID uuid) { + public static boolean isUuid(UUID uuid) { return isUProtocol(uuid) || isUuidv6(uuid); } /** - * Return the number of milliseconds since unix epoch from a passed UUID. + * Gets the number of milliseconds since unix epoch contained in a UUID. * - * @param uuid passed uuid to fetch the time. - * @return number of milliseconds since unix epoch or empty if uuid is null. + * @param uuid The UUID. + * @return The number of milliseconds, or empty if uuid is null or does not contain + * a timestamp. */ - static Optional getTime(UUID uuid) { - Long time = null; - Optional version = getVersion(uuid); - if (uuid == null || version.isEmpty()) { + public static Optional getTime(UUID uuid) { + if (uuid == null) { return Optional.empty(); } - switch (version.get()) { + final var version = getVersion(uuid); + + switch (version) { case VERSION_UPROTOCOL: - time = uuid.getMsb() >> 16; - break; - case VERSION_TIME_ORDERED: + return Optional.of(uuid.getMsb() >> 16); + case VERSION_UUIDV6: // convert Ticks to Millis try { java.util.UUID uuidJava = new java.util.UUID(uuid.getMsb(), uuid.getLsb()); - time = UuidTime.toUnixTimestamp(UuidUtil.getTimestamp(uuidJava)) / UuidTime.TICKS_PER_MILLI; + return Optional.of(UuidTime.toUnixTimestamp( + UuidUtil.getTimestamp(uuidJava)) / UuidTime.TICKS_PER_MILLI); } catch (IllegalArgumentException e) { return Optional.empty(); } - break; default: - break; + return Optional.empty(); } - - return Optional.ofNullable(time); } /** @@ -123,7 +131,7 @@ static Optional getTime(UUID uuid) { * @return An Optional containing the elapsed time in milliseconds, * or an empty Optional if the creation time cannot be determined. */ - static Optional getElapsedTime(UUID id) { + public static Optional getElapsedTime(UUID id) { final long creationTime = getTime(id).orElse(-1L); if (creationTime < 0) { return Optional.empty(); @@ -144,7 +152,7 @@ static Optional getElapsedTime(UUID id) { * or an empty Optional if the UUID is null, TTL is non-positive, or the * creation time cannot be determined. */ - static Optional getRemainingTime(UUID id, int ttl) { + public static Optional getRemainingTime(UUID id, int ttl) { if (id == null || ttl <= 0) { return Optional.empty(); } @@ -161,56 +169,7 @@ static Optional getRemainingTime(UUID id, int ttl) { * is non-positive or creation time * cannot be determined. */ - static boolean isExpired(UUID id, int ttl) { + public static boolean isExpired(UUID id, int ttl) { return ttl > 0 && getRemainingTime(id, ttl).isEmpty(); } - - /** - * The supported UUID versions. - */ - enum Version { - - /** - * An unknown version. - */ - VERSION_UNKNOWN(0), - /** - * The randomly or pseudo-randomly generated version specified in RFC-4122. - */ - VERSION_RANDOM_BASED(4), - /** - * The time-ordered version with gregorian epoch proposed by Peabody and Davis. - */ - VERSION_TIME_ORDERED(6), - /** - * The custom or free-form version proposed by Peabody and Davis. - */ - VERSION_UPROTOCOL(7); - - private final int value; - - Version(int value) { - this.value = value; - } - - /** - * Get the Version from the passed integer representation of the version. - * - * @param value The integer representation of the version. - * @return The Version object or Optional.empty() if the value is not a valid - * version. - */ - public static Optional getVersion(int value) { - for (Version version : values()) { - if (version.getValue() == value) { - return Optional.of(version); - } - } - return Optional.empty(); - } - - public int getValue() { - return this.value; - } - } -} \ No newline at end of file +} diff --git a/src/main/java/org/eclipse/uprotocol/uuid/validate/UuidValidator.java b/src/main/java/org/eclipse/uprotocol/uuid/validate/UuidValidator.java index 25a2839b..c851f362 100644 --- a/src/main/java/org/eclipse/uprotocol/uuid/validate/UuidValidator.java +++ b/src/main/java/org/eclipse/uprotocol/uuid/validate/UuidValidator.java @@ -18,8 +18,6 @@ import org.eclipse.uprotocol.v1.UCode; import org.eclipse.uprotocol.validation.ValidationResult; -import com.github.f4b6a3.uuid.enums.UuidVariant; - import java.util.Optional; import java.util.stream.Collectors; import java.util.stream.Stream; @@ -42,7 +40,6 @@ public static UuidValidator getValidator(UUID uuid) { public enum Validators { UNKNOWN(new UuidValidator.InvalidValidator()), UUIDV6(new UuidValidator.UUIDv6Validator()), - UPROTOCOL(new UuidValidator.UUIDv7Validator()); private final UuidValidator uuidValidator; @@ -57,12 +54,12 @@ public UuidValidator validator() { } public UStatus validate(UUID uuid) { - final String errorMessage = Stream.of(validateVersion(uuid), - validateVariant(uuid), + final String errorMessage = Stream.of( + validateVersion(uuid), validateTime(uuid)) .filter(ValidationResult::isFailure) - .map(ValidationResult::getMessage) - .collect(Collectors.joining(",")); + .map(ValidationResult::getMessage) + .collect(Collectors.joining(",")); return errorMessage.isBlank() ? ValidationResult.success().toStatus() : UStatus.newBuilder().setCode(UCode.INVALID_ARGUMENT).setMessage(errorMessage).build(); } @@ -75,51 +72,29 @@ public ValidationResult validateTime(UUID uuid) { : ValidationResult.failure(String.format("Invalid UUID Time")); } - public abstract ValidationResult validateVariant(UUID uuid); - private static class InvalidValidator extends UuidValidator { @Override public ValidationResult validateVersion(UUID uuid) { return ValidationResult.failure(String.format("Invalid UUID Version")); } - - @Override - public ValidationResult validateVariant(UUID uuid) { - return ValidationResult.failure(String.format("Invalid UUID Variant")); - } } private static class UUIDv6Validator extends UuidValidator { @Override public ValidationResult validateVersion(UUID uuid) { - final Optional version = UuidUtils.getVersion(uuid); - return version.isPresent() && version.get() == UuidUtils.Version.VERSION_TIME_ORDERED + return UuidUtils.isUuidv6(uuid) ? ValidationResult.success() : ValidationResult.failure(String.format("Not a UUIDv6 Version")); } - - @Override - public ValidationResult validateVariant(UUID uuid) { - final Optional variant = UuidUtils.getVariant(uuid); - return variant.isPresent() && (variant.get() == UuidVariant.VARIANT_RFC_4122.getValue()) - ? ValidationResult.success() - : ValidationResult.failure(String.format("Invalid UUIDv6 variant")); - } } private static class UUIDv7Validator extends UuidValidator { @Override public ValidationResult validateVersion(UUID uuid) { - final Optional version = UuidUtils.getVersion(uuid); - return version.isPresent() && version.get() == UuidUtils.Version.VERSION_UPROTOCOL + return UuidUtils.isUProtocol(uuid) ? ValidationResult.success() : ValidationResult.failure(String.format("Invalid UUIDv7 Version")); } - - @Override - public ValidationResult validateVariant(UUID uuid) { - return ValidationResult.success(); - } } -} \ No newline at end of file +} diff --git a/src/test/java/org/eclipse/uprotocol/uuid/factory/UUIDFactoryTest.java b/src/test/java/org/eclipse/uprotocol/uuid/factory/UUIDFactoryTest.java index 57713093..9077e890 100644 --- a/src/test/java/org/eclipse/uprotocol/uuid/factory/UUIDFactoryTest.java +++ b/src/test/java/org/eclipse/uprotocol/uuid/factory/UUIDFactoryTest.java @@ -32,7 +32,6 @@ public class UUIDFactoryTest { void testUuidv7Creation() { final Instant now = Instant.now(); final UUID uuid = UuidFactory.Factories.UPROTOCOL.factory().create(now); - final Optional version = UuidUtils.getVersion(uuid); final Optional time = UuidUtils.getTime(uuid); final String uuidString = UuidSerializer.serialize(uuid); @@ -40,7 +39,6 @@ void testUuidv7Creation() { assertTrue(UuidUtils.isUProtocol(uuid)); assertTrue(UuidUtils.isUuid(uuid)); assertFalse(UuidUtils.isUuidv6(uuid)); - assertTrue(version.isPresent()); assertTrue(time.isPresent()); assertEquals(time.get(), now.toEpochMilli()); @@ -55,7 +53,6 @@ void testUuidv7Creation() { @DisplayName("Test UUIDv7 Creation with null Instant") void testUuidv7CreationWithNullInstant() { final UUID uuid = UuidFactory.Factories.UPROTOCOL.factory().create(null); - final Optional version = UuidUtils.getVersion(uuid); final Optional time = UuidUtils.getTime(uuid); final String uuidString = UuidSerializer.serialize(uuid); @@ -63,7 +60,6 @@ void testUuidv7CreationWithNullInstant() { assertTrue(UuidUtils.isUProtocol(uuid)); assertTrue(UuidUtils.isUuid(uuid)); assertFalse(UuidUtils.isUuidv6(uuid)); - assertTrue(version.isPresent()); assertTrue(time.isPresent()); assertFalse(uuidString.isBlank()); @@ -80,7 +76,6 @@ void testUuidv7CreationWithNullInstant() { void testUuidv6CreationWithInstant() { final Instant now = Instant.now(); final UUID uuid = UuidFactory.Factories.UUIDV6.factory().create(now); - final Optional version = UuidUtils.getVersion(uuid); final Optional time = UuidUtils.getTime(uuid); final String uuidString = UuidSerializer.serialize(uuid); @@ -88,7 +83,6 @@ void testUuidv6CreationWithInstant() { assertTrue(UuidUtils.isUuidv6(uuid)); assertTrue(UuidUtils.isUuid(uuid)); assertFalse(UuidUtils.isUProtocol(uuid)); - assertTrue(version.isPresent()); assertTrue(time.isPresent()); assertEquals(time.get(), now.toEpochMilli()); assertFalse(uuidString.isBlank()); @@ -101,7 +95,6 @@ void testUuidv6CreationWithInstant() { @DisplayName("Test UUIDv6 creation with null Instant") void testUuidv6CreationWithNullInstant() { final UUID uuid = UuidFactory.Factories.UUIDV6.factory().create(null); - final Optional version = UuidUtils.getVersion(uuid); final Optional time = UuidUtils.getTime(uuid); final String uuidString = UuidSerializer.serialize(uuid); @@ -109,7 +102,6 @@ void testUuidv6CreationWithNullInstant() { assertTrue(UuidUtils.isUuidv6(uuid)); assertFalse(UuidUtils.isUProtocol(uuid)); assertTrue(UuidUtils.isUuid(uuid)); - assertTrue(version.isPresent()); assertTrue(time.isPresent()); assertFalse(uuidString.isBlank()); @@ -124,7 +116,6 @@ void testUuidutilsForRandomUuid() { final java.util.UUID uuid_java = java.util.UUID.randomUUID(); final UUID uuid = UUID.newBuilder().setMsb(uuid_java.getMostSignificantBits()) .setLsb(uuid_java.getLeastSignificantBits()).build(); - final Optional version = UuidUtils.getVersion(uuid); final Optional time = UuidUtils.getTime(uuid); final String uuidString = UuidSerializer.serialize(uuid); @@ -132,7 +123,6 @@ void testUuidutilsForRandomUuid() { assertFalse(UuidUtils.isUuidv6(uuid)); assertFalse(UuidUtils.isUProtocol(uuid)); assertFalse(UuidUtils.isUuid(uuid)); - assertTrue(version.isPresent()); assertFalse(time.isPresent()); assertFalse(uuidString.isBlank()); @@ -146,20 +136,14 @@ void testUuidutilsForRandomUuid() { @DisplayName("Test UUIDUtils for empty UUID") void testUuidutilsForEmptyUuid() { final UUID uuid = UUID.newBuilder().setMsb(0L).setLsb(0L).build(); - final Optional version = UuidUtils.getVersion(uuid); final Optional time = UuidUtils.getTime(uuid); final String uuidString = UuidSerializer.serialize(uuid); assertNotNull(uuid); assertFalse(UuidUtils.isUuidv6(uuid)); assertFalse(UuidUtils.isUProtocol(uuid)); - assertTrue(version.isPresent()); - assertEquals(version.get(), UuidUtils.Version.VERSION_UNKNOWN); assertFalse(time.isPresent()); assertFalse(uuidString.isBlank()); - assertFalse(UuidUtils.isUuidv6(null)); - assertFalse(UuidUtils.isUProtocol(null)); - assertFalse(UuidUtils.isUuid(null)); final UUID uuid2 = UuidSerializer.deserialize(uuidString); assertTrue(uuid2.equals(UUID.getDefaultInstance())); @@ -169,7 +153,6 @@ void testUuidutilsForEmptyUuid() { @Test @DisplayName("Test UUIDUtils for a null UUID") void testUuidutilsForNullUuid() { - assertFalse(UuidUtils.getVersion(null).isPresent()); assertTrue(UuidSerializer.serialize(null).isBlank()); assertFalse(UuidUtils.isUuidv6(null)); assertFalse(UuidUtils.isUProtocol(null)); @@ -182,7 +165,6 @@ void testUuidutilsForNullUuid() { void testUuidutilsFromInvalidUuid() { final UUID uuid = UUID.newBuilder().setMsb(9 << 12).setLsb(0L).build(); // Invalid UUID type - assertFalse(UuidUtils.getVersion(uuid).isPresent()); assertFalse(UuidUtils.getTime(uuid).isPresent()); assertFalse(UuidSerializer.serialize(uuid).isBlank()); assertFalse(UuidUtils.isUuidv6(uuid)); diff --git a/src/test/java/org/eclipse/uprotocol/uuid/factory/UuidUtilsTest.java b/src/test/java/org/eclipse/uprotocol/uuid/factory/UuidUtilsTest.java index 882fe73a..0daba948 100644 --- a/src/test/java/org/eclipse/uprotocol/uuid/factory/UuidUtilsTest.java +++ b/src/test/java/org/eclipse/uprotocol/uuid/factory/UuidUtilsTest.java @@ -15,16 +15,85 @@ import org.eclipse.uprotocol.v1.UUID; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; import static org.junit.jupiter.api.Assertions.*; import java.time.Instant; +import java.util.stream.Stream; -public class UuidUtilsTest { +class UuidUtilsTest { private static final int DELTA = 30; private static final int DELAY_MS = 100; private static final int TTL = 10000; + private static Stream provideUuidsForIsUuidv6() { + return Stream.of( + Arguments.of(UUID.newBuilder() + .setMsb(0x0000000000006000L) + .setLsb(0xA000000000000000L) + .build(), true), + Arguments.of(UUID.newBuilder() + .setMsb(0x0000000000007000L) + .setLsb(0xA000000000000000L) + .build(), false), + Arguments.of(UUID.newBuilder() + .setMsb(0x0000000000006000L) + .setLsb(0xC000000000000000L) + .build(), false), + Arguments.of(UUID.newBuilder() + .setMsb(0x0000000000007000L) + .setLsb(0xC000000000000000L) + .build(), false), + Arguments.of(null, false) + ); + } + + @ParameterizedTest(name = "Test isUuidv6 {index} - {0}") + @MethodSource("provideUuidsForIsUuidv6") + void testIsUuidv6(UUID uuid, boolean expected) { + assertEquals(expected, UuidUtils.isUuidv6(uuid)); + } + + private static Stream provideUuidsForIsUProtocol() { + return Stream.of( + Arguments.of(UUID.newBuilder() + .setMsb(0x0000000000006000L) + .setLsb(0xA000000000000000L) + .build(), false), + Arguments.of(UUID.newBuilder() + .setMsb(0x0000000000007000L) + .setLsb(0xA000000000000000L) + .build(), true), + Arguments.of(UUID.newBuilder() + .setMsb(0x0000000000006000L) + .setLsb(0xC000000000000000L) + .build(), false), + Arguments.of(UUID.newBuilder() + .setMsb(0x0000000000007000L) + .setLsb(0xC000000000000000L) + .build(), false), + Arguments.of(null, false) + ); + } + + @ParameterizedTest(name = "Test isUProtocol {index} - {0}") + @MethodSource("provideUuidsForIsUProtocol") + void testIsUProtocol(UUID uuid, boolean expected) { + assertEquals(expected, UuidUtils.isUProtocol(uuid)); + } + + @Test + void testIsRfc9562Variant() { + // variant 0b10 (RFC9562) + UUID id = UUID.newBuilder().setLsb(0xA000000000000000L).build(); + assertTrue(UuidUtils.isRfc9562Variant(id)); + // variant 0b11 (Reserved. Microsoft Corporation backward compatibility.) + id = UUID.newBuilder().setLsb(0xC000000000000000L).build(); + assertFalse(UuidUtils.isRfc9562Variant(id)); + } @Test public void testGetElapsedTime() throws InterruptedException { @@ -97,6 +166,4 @@ public void testGetElapsedTimePast() throws InterruptedException { final UUID id = UuidFactory.Factories.UPROTOCOL.factory().create(now); assertTrue(UuidUtils.getElapsedTime(id).isEmpty()); } - - } diff --git a/src/test/java/org/eclipse/uprotocol/uuid/serializer/UuidSerializerTest.java b/src/test/java/org/eclipse/uprotocol/uuid/serializer/UuidSerializerTest.java new file mode 100644 index 00000000..38f52002 --- /dev/null +++ b/src/test/java/org/eclipse/uprotocol/uuid/serializer/UuidSerializerTest.java @@ -0,0 +1,33 @@ +/** + * SPDX-FileCopyrightText: 2025 Contributors to the Eclipse Foundation + * + * See the NOTICE file(s) distributed with this work for additional + * information regarding copyright ownership. + * + * This program and the accompanying materials are made available under the + * terms of the Apache License Version 2.0 which is available at + * https://www.apache.org/licenses/LICENSE-2.0 + * + * SPDX-License-Identifier: Apache-2.0 + */ +package org.eclipse.uprotocol.uuid.serializer; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +import org.eclipse.uprotocol.v1.UUID; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.EmptySource; +import org.junit.jupiter.params.provider.NullSource; +import org.junit.jupiter.params.provider.ValueSource; + +class UuidSerializerTest { + + @ParameterizedTest(name = "Test deserializing an invalid UUID string [{index}]: {arguments}") + @NullSource + @EmptySource + @ValueSource(strings = {"invalid-uuid-string"}) + void testDeserializeHandlesInvalidString(String uuidString) { + final var uuid = UuidSerializer.deserialize(uuidString); + assertEquals(UUID.getDefaultInstance(), uuid); + } +} diff --git a/src/test/java/org/eclipse/uprotocol/uuid/validator/UuidValidatorTest.java b/src/test/java/org/eclipse/uprotocol/uuid/validator/UuidValidatorTest.java index a9d4f897..c9c79433 100644 --- a/src/test/java/org/eclipse/uprotocol/uuid/validator/UuidValidatorTest.java +++ b/src/test/java/org/eclipse/uprotocol/uuid/validator/UuidValidatorTest.java @@ -50,7 +50,7 @@ void testInvalidUuid() { final UUID uuid = UUID.newBuilder().setMsb(0L).setLsb(0L).build(); final UStatus status = UuidValidator.getValidator(uuid).validate(uuid); assertEquals(UCode.INVALID_ARGUMENT, status.getCode()); - assertEquals("Invalid UUID Version,Invalid UUID Variant,Invalid UUID Time", status.getMessage()); + assertEquals("Invalid UUID Version,Invalid UUID Time", status.getMessage()); } @Test @@ -117,7 +117,7 @@ void testUuidv6WithBadVariant() { final UuidValidator validator = UuidValidator.getValidator(uuid); assertNotNull(validator); final UStatus status = validator.validate(uuid); - assertEquals("Invalid UUID Version,Invalid UUID Variant,Invalid UUID Time", status.getMessage()); + assertEquals("Invalid UUID Version,Invalid UUID Time", status.getMessage()); assertEquals(UCode.INVALID_ARGUMENT, status.getCode()); } @@ -129,7 +129,7 @@ void testUuidv6WithInvalidUuid() { final UuidValidator validator = UuidValidator.Validators.UUIDV6.validator(); assertNotNull(validator); final UStatus status = validator.validate(uuid); - assertEquals("Not a UUIDv6 Version,Invalid UUIDv6 variant,Invalid UUID Time", status.getMessage()); + assertEquals("Not a UUIDv6 Version,Invalid UUID Time", status.getMessage()); assertEquals(UCode.INVALID_ARGUMENT, status.getCode()); } @@ -140,7 +140,7 @@ void testUuidv6WithNullUuid() { final UuidValidator validator = UuidValidator.Validators.UUIDV6.validator(); assertNotNull(validator); final UStatus status = validator.validate(null); - assertEquals("Not a UUIDv6 Version,Invalid UUIDv6 variant,Invalid UUID Time", status.getMessage()); + assertEquals("Not a UUIDv6 Version,Invalid UUID Time", status.getMessage()); assertEquals(UCode.INVALID_ARGUMENT, status.getCode()); }