diff --git a/xrpl4j-core/src/test/java/org/xrpl/xrpl4j/model/immutables/WrapperTest.java b/xrpl4j-core/src/test/java/org/xrpl/xrpl4j/model/immutables/WrapperTest.java new file mode 100644 index 000000000..79f0c76e2 --- /dev/null +++ b/xrpl4j-core/src/test/java/org/xrpl/xrpl4j/model/immutables/WrapperTest.java @@ -0,0 +1,148 @@ +package org.xrpl.xrpl4j.model.immutables; + +/*- + * ========================LICENSE_START================================= + * xrpl4j :: model + * %% + * Copyright (C) 2020 - 2022 XRPL Foundation and its contributors + * %% + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * =========================LICENSE_END================================== + */ + +import static org.assertj.core.api.Assertions.assertThat; + +import com.google.common.primitives.UnsignedInteger; +import org.junit.jupiter.api.Test; +import org.xrpl.xrpl4j.model.transactions.Hash256; +import org.xrpl.xrpl4j.model.transactions.NetworkId; + +/** + * Unit tests for {@link Wrapper}. + */ +class WrapperTest { + + private static final Hash256 HASH_256_MAX = Hash256.of( + "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"); + private static final Hash256 HASH_256_ZERO = Hash256.of( + "0000000000000000000000000000000000000000000000000000000000000000"); + + private static final NetworkId NETWORK_ID = NetworkId.of(1000); + + @Test + void testValue() { + assertThat(HASH_256_MAX.value()).isEqualTo("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"); + assertThat(NETWORK_ID.value()).isEqualTo(UnsignedInteger.valueOf(1000)); + } + + @Test + void testCompareTo() { + // Test with Hash256 (String wrapper) + Hash256 hash1 = HASH_256_ZERO; + Hash256 hash2 = HASH_256_MAX; + Hash256 hash3 = HASH_256_ZERO; + + // hash1 < hash2 + assertThat(hash1.compareTo(hash2)).isLessThan(0); + // hash2 > hash1 + assertThat(hash2.compareTo(hash1)).isGreaterThan(0); + // hash1 == hash3 + assertThat(hash1.compareTo(hash3)).isEqualTo(0); + + // Test with NetworkId (UnsignedInteger wrapper) + NetworkId networkId1 = NetworkId.of(UnsignedInteger.valueOf(100)); + NetworkId networkId2 = NetworkId.of(UnsignedInteger.valueOf(200)); + NetworkId networkId3 = NetworkId.of(UnsignedInteger.valueOf(100)); + + // networkId1 < networkId2 + assertThat(networkId1.compareTo(networkId2)).isLessThan(0); + // networkId2 > networkId1 + assertThat(networkId2.compareTo(networkId1)).isGreaterThan(0); + // networkId1 == networkId3 + assertThat(networkId1.compareTo(networkId3)).isEqualTo(0); + } + + @Test + void testEqualsWithNull() { + assertThat(HASH_256_MAX.equals(null)).isFalse(); + } + + @Test + void testEqualsWithSameObject() { + assertThat(HASH_256_MAX.equals(HASH_256_MAX)).isTrue(); + } + + @Test + void testEqualsWithDifferentType() { + assertThat(HASH_256_MAX.equals("not a wrapper")).isFalse(); + assertThat(HASH_256_MAX.equals(123)).isFalse(); + } + + @Test + void testEqualsWithDifferentWrapperType() { + NetworkId networkId = NetworkId.of(UnsignedInteger.valueOf(1000)); + + // Different wrapper types should not be equal even if values might be related + assertThat(HASH_256_MAX.equals(networkId)).isFalse(); + } + + @Test + void testEqualsWithDifferentValues() { + Hash256 hash1 = HASH_256_ZERO; + Hash256 hash2 = HASH_256_MAX; + assertThat(hash1.equals(hash2)).isFalse(); + + NetworkId networkId1 = NetworkId.of(UnsignedInteger.valueOf(100)); + NetworkId networkId2 = NetworkId.of(UnsignedInteger.valueOf(200)); + assertThat(networkId1.equals(networkId2)).isFalse(); + } + + @Test + void testEqualsWithSameValues() { + Hash256 hash1 = HASH_256_MAX; + Hash256 hash2 = HASH_256_MAX; + assertThat(hash1.equals(hash2)).isTrue(); + + NetworkId networkId1 = NetworkId.of(UnsignedInteger.valueOf(1000)); + NetworkId networkId2 = NetworkId.of(UnsignedInteger.valueOf(1000)); + assertThat(networkId1.equals(networkId2)).isTrue(); + } + + @Test + void testHashCode() { + // Equal objects should have equal hashCodes + Hash256 hash1 = HASH_256_MAX; + Hash256 hash2 = HASH_256_MAX; + assertThat(hash1.hashCode()).isEqualTo(hash2.hashCode()); + + NetworkId networkId1 = NetworkId.of(UnsignedInteger.valueOf(1000)); + NetworkId networkId2 = NetworkId.of(UnsignedInteger.valueOf(1000)); + assertThat(networkId1.hashCode()).isEqualTo(networkId2.hashCode()); + + // Different objects should (generally) have different hashCodes + Hash256 hash3 = HASH_256_ZERO; + assertThat(hash1.hashCode()).isNotEqualTo(hash3.hashCode()); + + NetworkId networkId3 = NetworkId.of(UnsignedInteger.valueOf(2000)); + assertThat(networkId1.hashCode()).isNotEqualTo(networkId3.hashCode()); + } + + @Test + void testToString() { + // Hash256 overrides toString() to return just the value + assertThat(HASH_256_MAX.toString()).isEqualTo("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"); + + // NetworkId overrides toString() to return the value's toString + assertThat(NETWORK_ID.toString()).isEqualTo("1000"); + } +} diff --git a/xrpl4j-core/src/test/java/org/xrpl/xrpl4j/model/transactions/AddressTest.java b/xrpl4j-core/src/test/java/org/xrpl/xrpl4j/model/transactions/AddressTest.java index f6c0a8724..6a59d74bf 100644 --- a/xrpl4j-core/src/test/java/org/xrpl/xrpl4j/model/transactions/AddressTest.java +++ b/xrpl4j-core/src/test/java/org/xrpl/xrpl4j/model/transactions/AddressTest.java @@ -9,9 +9,9 @@ * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at - * + * * http://www.apache.org/licenses/LICENSE-2.0 - * + * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. @@ -20,15 +20,57 @@ * =========================LICENSE_END================================== */ +import static org.assertj.core.api.Assertions.assertThat; import static org.junit.jupiter.api.Assertions.assertThrows; +import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.fasterxml.jackson.databind.annotation.JsonDeserialize; +import com.fasterxml.jackson.databind.annotation.JsonSerialize; +import org.assertj.core.api.AssertionsForClassTypes; +import org.immutables.value.Value; +import org.json.JSONException; import org.junit.jupiter.api.Test; +import org.skyscreamer.jsonassert.JSONAssert; +import org.skyscreamer.jsonassert.JSONCompareMode; +import org.xrpl.xrpl4j.crypto.keys.Seed; +import org.xrpl.xrpl4j.model.jackson.ObjectMapperFactory; +/** + * Unit tests for {@link Address}. + */ public class AddressTest { + private final ObjectMapper objectMapper = ObjectMapperFactory.create(); + private static final Address ADDRESS = Seed.ed25519Seed().deriveKeyPair().publicKey().deriveAddress(); + @Test - public void addressWithBadPrefix() { + void testNull() { + assertThrows(NullPointerException.class, () -> Address.of(null)); + } + + @Test + void testEquality() { + AssertionsForClassTypes.assertThat(ADDRESS).isEqualTo(ADDRESS); + AssertionsForClassTypes.assertThat(ADDRESS).isNotEqualTo(new Object()); + AssertionsForClassTypes.assertThat(ADDRESS.equals(null)).isFalse(); + } + + @Test + void testToString() { + Address address = Address.of("rN7n7otQDd6FczFgLdlqtyMVrn3HMfXoKk"); + assertThat(address.toString()).isEqualTo("rN7n7otQDd6FczFgLdlqtyMVrn3HMfXoKk"); + } + + @Test + void testHashCode() { + Address address1 = Address.of("rN7n7otQDd6FczFgLdlqtyMVrn3HMfXoKk"); + Address address2 = Address.of("rN7n7otQDd6FczFgLdlqtyMVrn3HMfXoKk"); + assertThat(address1.hashCode()).isEqualTo(address2.hashCode()); + } + @Test + public void addressWithBadPrefix() { assertThrows( IllegalArgumentException.class, () -> Address.of("c9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59"), @@ -38,7 +80,6 @@ public void addressWithBadPrefix() { @Test public void addressOfIncorrectLength() { - assertThrows( IllegalArgumentException.class, () -> Address.of("r9cZA1mLK5R"), @@ -50,4 +91,30 @@ public void addressOfIncorrectLength() { "Classic Addresses must be (25,35) characters long inclusive." ); } + + @Test + void testJsonSerialization() throws JsonProcessingException, JSONException { + Address address = Address.of("rN7n7otQDd6FczFgLdlqtyMVrn3HMfXoKk"); + AddressWrapper wrapper = ImmutableAddressWrapper.builder() + .address(address) + .build(); + + String json = "{\"address\":\"rN7n7otQDd6FczFgLdlqtyMVrn3HMfXoKk\"}"; + assertSerializesAndDeserializes(wrapper, json); + } + + private void assertSerializesAndDeserializes(AddressWrapper wrapper, String json) + throws JsonProcessingException, JSONException { + String serialized = objectMapper.writeValueAsString(wrapper); + JSONAssert.assertEquals(json, serialized, JSONCompareMode.STRICT); + AddressWrapper deserialized = objectMapper.readValue(serialized, AddressWrapper.class); + assertThat(deserialized).isEqualTo(wrapper); + } + + @Value.Immutable + @JsonSerialize(as = ImmutableAddressWrapper.class) + @JsonDeserialize(as = ImmutableAddressWrapper.class) + interface AddressWrapper { + Address address(); + } } diff --git a/xrpl4j-core/src/test/java/org/xrpl/xrpl4j/model/transactions/AssetPriceTest.java b/xrpl4j-core/src/test/java/org/xrpl/xrpl4j/model/transactions/AssetPriceTest.java index 274699ecc..238c37ca9 100644 --- a/xrpl4j-core/src/test/java/org/xrpl/xrpl4j/model/transactions/AssetPriceTest.java +++ b/xrpl4j-core/src/test/java/org/xrpl/xrpl4j/model/transactions/AssetPriceTest.java @@ -1,6 +1,7 @@ package org.xrpl.xrpl4j.model.transactions; import static org.assertj.core.api.AssertionsForClassTypes.assertThat; +import static org.junit.jupiter.api.Assertions.assertThrows; import com.fasterxml.jackson.core.JsonProcessingException; import com.fasterxml.jackson.databind.ObjectMapper; @@ -8,6 +9,7 @@ import com.fasterxml.jackson.databind.annotation.JsonSerialize; import com.google.common.primitives.UnsignedLong; import org.assertj.core.api.Assertions; +import org.assertj.core.api.AssertionsForClassTypes; import org.immutables.value.Value; import org.json.JSONException; import org.junit.jupiter.api.Test; @@ -20,8 +22,22 @@ */ public class AssetPriceTest { + private static final AssetPrice ZERO_ASSET_PRICE = AssetPrice.of(UnsignedLong.ZERO); + ObjectMapper objectMapper = ObjectMapperFactory.create(); + @Test + void testNull() { + assertThrows(NullPointerException.class, () -> AssetPrice.of(null)); + } + + @Test + void testEquality() { + AssertionsForClassTypes.assertThat(ZERO_ASSET_PRICE).isEqualTo(ZERO_ASSET_PRICE); + AssertionsForClassTypes.assertThat(ZERO_ASSET_PRICE).isNotEqualTo(new Object()); + AssertionsForClassTypes.assertThat(ZERO_ASSET_PRICE.equals(null)).isFalse(); + } + @Test void testToString() { AssetPrice count = AssetPrice.of(UnsignedLong.ZERO); diff --git a/xrpl4j-core/src/test/java/org/xrpl/xrpl4j/model/transactions/AssetScaleTest.java b/xrpl4j-core/src/test/java/org/xrpl/xrpl4j/model/transactions/AssetScaleTest.java index 0095de132..cf2d25dfd 100644 --- a/xrpl4j-core/src/test/java/org/xrpl/xrpl4j/model/transactions/AssetScaleTest.java +++ b/xrpl4j-core/src/test/java/org/xrpl/xrpl4j/model/transactions/AssetScaleTest.java @@ -22,14 +22,35 @@ import static org.assertj.core.api.Assertions.assertThat; +import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.fasterxml.jackson.databind.annotation.JsonDeserialize; +import com.fasterxml.jackson.databind.annotation.JsonSerialize; import com.google.common.primitives.UnsignedInteger; +import org.assertj.core.api.Assertions; +import org.immutables.value.Value; +import org.json.JSONException; import org.junit.jupiter.api.Test; +import org.skyscreamer.jsonassert.JSONAssert; +import org.skyscreamer.jsonassert.JSONCompareMode; +import org.xrpl.xrpl4j.model.jackson.ObjectMapperFactory; /** * Unit tests for {@link AssetScale}. */ public class AssetScaleTest { + ObjectMapper objectMapper = ObjectMapperFactory.create(); + + @Test + void testBounds() { + AssetScale assetScale = AssetScale.of(UnsignedInteger.ZERO); + assertThat(assetScale.value()).isEqualTo(UnsignedInteger.ZERO); + + assetScale = AssetScale.of(UnsignedInteger.MAX_VALUE); + assertThat(assetScale.value()).isEqualTo(UnsignedInteger.MAX_VALUE); + } + @Test void testToString() { AssetScale assetScale = AssetScale.of(UnsignedInteger.ZERO); @@ -41,5 +62,38 @@ void testToString() { assetScale = AssetScale.of(UnsignedInteger.MAX_VALUE); assertThat(assetScale.toString()).isEqualTo(UnsignedInteger.MAX_VALUE.toString()); } -} + @Test + void testJson() throws JsonProcessingException, JSONException { + AssetScale assetScale = AssetScale.of(UnsignedInteger.valueOf(5)); + AssetScaleWrapper wrapper = AssetScaleWrapper.of(assetScale); + + String json = "{\"assetScale\": 5}"; + assertSerializesAndDeserializes(wrapper, json); + } + + private void assertSerializesAndDeserializes( + AssetScaleWrapper wrapper, + String json + ) throws JsonProcessingException, JSONException { + String serialized = objectMapper.writeValueAsString(wrapper); + JSONAssert.assertEquals(json, serialized, JSONCompareMode.STRICT); + AssetScaleWrapper deserialized = objectMapper.readValue( + serialized, AssetScaleWrapper.class + ); + Assertions.assertThat(deserialized).isEqualTo(wrapper); + } + + @Value.Immutable + @JsonSerialize(as = ImmutableAssetScaleWrapper.class) + @JsonDeserialize(as = ImmutableAssetScaleWrapper.class) + interface AssetScaleWrapper { + + static AssetScaleWrapper of(AssetScale assetScale) { + return ImmutableAssetScaleWrapper.builder().assetScale(assetScale).build(); + } + + AssetScale assetScale(); + + } +} diff --git a/xrpl4j-core/src/test/java/org/xrpl/xrpl4j/model/transactions/DidDataTest.java b/xrpl4j-core/src/test/java/org/xrpl/xrpl4j/model/transactions/DidDataTest.java index 74650d3aa..daa484033 100644 --- a/xrpl4j-core/src/test/java/org/xrpl/xrpl4j/model/transactions/DidDataTest.java +++ b/xrpl4j-core/src/test/java/org/xrpl/xrpl4j/model/transactions/DidDataTest.java @@ -1,12 +1,14 @@ package org.xrpl.xrpl4j.model.transactions; import static org.assertj.core.api.AssertionsForClassTypes.assertThat; +import static org.junit.jupiter.api.Assertions.assertThrows; import com.fasterxml.jackson.core.JsonProcessingException; import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.databind.annotation.JsonDeserialize; import com.fasterxml.jackson.databind.annotation.JsonSerialize; import org.assertj.core.api.Assertions; +import org.assertj.core.api.AssertionsForClassTypes; import org.immutables.value.Value; import org.json.JSONException; import org.junit.jupiter.api.Test; @@ -16,21 +18,35 @@ public class DidDataTest { + private static final DidData EMPTY_DID_DATA = DidData.of(""); + ObjectMapper objectMapper = ObjectMapperFactory.create(); + @Test + void testNull() { + assertThrows(NullPointerException.class, () -> DidData.of(null)); + } + + @Test + void testEquality() { + AssertionsForClassTypes.assertThat(EMPTY_DID_DATA).isEqualTo(EMPTY_DID_DATA); + AssertionsForClassTypes.assertThat(EMPTY_DID_DATA).isNotEqualTo(new Object()); + AssertionsForClassTypes.assertThat(EMPTY_DID_DATA.equals(null)).isFalse(); + } + @Test void testToString() { - DidData count = DidData.of(""); - assertThat(count.toString()).isEqualTo(""); + DidData didData = DidData.of(""); + assertThat(didData.toString()).isEqualTo(""); - DidData countMax = DidData.of("ABCDEFG"); - assertThat(countMax.toString()).isEqualTo("ABCDEFG"); + DidData didDataMax = DidData.of("ABCDEFG"); + assertThat(didDataMax.toString()).isEqualTo("ABCDEFG"); } @Test void testJson() throws JsonProcessingException, JSONException { - DidData count = DidData.of("ABCDEF"); - DidDataWrapper wrapper = DidDataWrapper.of(count); + DidData didData = DidData.of("ABCDEF"); + DidDataWrapper wrapper = DidDataWrapper.of(didData); String json = "{\"value\": \"ABCDEF\"}"; assertSerializesAndDeserializes(wrapper, json); @@ -38,22 +54,18 @@ void testJson() throws JsonProcessingException, JSONException { @Test void testEmptyValueJson() throws JSONException, JsonProcessingException { - DidData count = DidData.of(""); - DidDataWrapper wrapper = DidDataWrapper.of(count); + DidData didData = DidData.of(""); + DidDataWrapper wrapper = DidDataWrapper.of(didData); String json = "{\"value\": \"\"}"; assertSerializesAndDeserializes(wrapper, json); } - private void assertSerializesAndDeserializes( - DidDataWrapper wrapper, - String json - ) throws JsonProcessingException, JSONException { + private void assertSerializesAndDeserializes(DidDataWrapper wrapper, String json) + throws JsonProcessingException, JSONException { String serialized = objectMapper.writeValueAsString(wrapper); JSONAssert.assertEquals(json, serialized, JSONCompareMode.STRICT); - DidDataWrapper deserialized = objectMapper.readValue( - serialized, DidDataWrapper.class - ); + DidDataWrapper deserialized = objectMapper.readValue(serialized, DidDataWrapper.class); Assertions.assertThat(deserialized).isEqualTo(wrapper); } diff --git a/xrpl4j-core/src/test/java/org/xrpl/xrpl4j/model/transactions/DidDocumentTest.java b/xrpl4j-core/src/test/java/org/xrpl/xrpl4j/model/transactions/DidDocumentTest.java index 0ea670ee7..3ad60a46d 100644 --- a/xrpl4j-core/src/test/java/org/xrpl/xrpl4j/model/transactions/DidDocumentTest.java +++ b/xrpl4j-core/src/test/java/org/xrpl/xrpl4j/model/transactions/DidDocumentTest.java @@ -1,13 +1,14 @@ package org.xrpl.xrpl4j.model.transactions; import static org.assertj.core.api.AssertionsForClassTypes.assertThat; +import static org.junit.jupiter.api.Assertions.assertThrows; import com.fasterxml.jackson.core.JsonProcessingException; import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.databind.annotation.JsonDeserialize; import com.fasterxml.jackson.databind.annotation.JsonSerialize; -import com.google.common.primitives.UnsignedLong; import org.assertj.core.api.Assertions; +import org.assertj.core.api.AssertionsForClassTypes; import org.immutables.value.Value; import org.json.JSONException; import org.junit.jupiter.api.Test; @@ -17,21 +18,34 @@ public class DidDocumentTest { + private static final DidDocument EMPTY_DID_DOCUMENT = DidDocument.of(""); + ObjectMapper objectMapper = ObjectMapperFactory.create(); + @Test + void testNull() { + assertThrows(NullPointerException.class, () -> DidDocument.of(null)); + } + + @Test + void testEquality() { + AssertionsForClassTypes.assertThat(EMPTY_DID_DOCUMENT).isEqualTo(EMPTY_DID_DOCUMENT); + AssertionsForClassTypes.assertThat(EMPTY_DID_DOCUMENT).isNotEqualTo(new Object()); + AssertionsForClassTypes.assertThat(EMPTY_DID_DOCUMENT.equals(null)).isFalse(); + } + @Test void testToString() { - DidDocument count = DidDocument.of(""); - assertThat(count.toString()).isEqualTo(""); + assertThat(EMPTY_DID_DOCUMENT.toString()).isEqualTo(""); - DidDocument countMax = DidDocument.of("ABCDEFG"); - assertThat(countMax.toString()).isEqualTo("ABCDEFG"); + DidDocument didDocumentMax = DidDocument.of("ABCDEFG"); + assertThat(didDocumentMax.toString()).isEqualTo("ABCDEFG"); } @Test void testJson() throws JsonProcessingException, JSONException { - DidDocument count = DidDocument.of("ABCDEF"); - DidDocumentWrapper wrapper = DidDocumentWrapper.of(count); + DidDocument didDocument = DidDocument.of("ABCDEF"); + DidDocumentWrapper wrapper = DidDocumentWrapper.of(didDocument); String json = "{\"value\": \"ABCDEF\"}"; assertSerializesAndDeserializes(wrapper, json); @@ -39,8 +53,8 @@ void testJson() throws JsonProcessingException, JSONException { @Test void testEmptyValueJson() throws JSONException, JsonProcessingException { - DidDocument count = DidDocument.of(""); - DidDocumentWrapper wrapper = DidDocumentWrapper.of(count); + DidDocument didDocument = DidDocument.of(""); + DidDocumentWrapper wrapper = DidDocumentWrapper.of(didDocument); String json = "{\"value\": \"\"}"; assertSerializesAndDeserializes(wrapper, json); diff --git a/xrpl4j-core/src/test/java/org/xrpl/xrpl4j/model/transactions/DidUriTest.java b/xrpl4j-core/src/test/java/org/xrpl/xrpl4j/model/transactions/DidUriTest.java index b2edfbaec..dce44f166 100644 --- a/xrpl4j-core/src/test/java/org/xrpl/xrpl4j/model/transactions/DidUriTest.java +++ b/xrpl4j-core/src/test/java/org/xrpl/xrpl4j/model/transactions/DidUriTest.java @@ -1,6 +1,7 @@ package org.xrpl.xrpl4j.model.transactions; import static org.assertj.core.api.AssertionsForClassTypes.assertThat; +import static org.junit.jupiter.api.Assertions.assertThrows; import com.fasterxml.jackson.core.JsonProcessingException; import com.fasterxml.jackson.databind.ObjectMapper; @@ -16,21 +17,34 @@ public class DidUriTest { + private static final DidUri EMPTY_DID_URI = DidUri.of(""); + ObjectMapper objectMapper = ObjectMapperFactory.create(); + @Test + void testNull() { + assertThrows(NullPointerException.class, () -> DidUri.of(null)); + } + + @Test + void testEquality() { + assertThat(EMPTY_DID_URI).isEqualTo(EMPTY_DID_URI); + assertThat(EMPTY_DID_URI).isNotEqualTo(new Object()); + } + @Test void testToString() { - DidUri count = DidUri.of(""); - assertThat(count.toString()).isEqualTo(""); + assertThat(EMPTY_DID_URI.toString()).isEqualTo(""); + assertThat(EMPTY_DID_URI.equals(null)).isFalse(); - DidUri countMax = DidUri.of("ABCDEFG"); - assertThat(countMax.toString()).isEqualTo("ABCDEFG"); + DidUri didUriMax = DidUri.of("ABCDEFG"); + assertThat(didUriMax.toString()).isEqualTo("ABCDEFG"); } @Test void testJson() throws JsonProcessingException, JSONException { - DidUri count = DidUri.of("ABCDEF"); - DidUriWrapper wrapper = DidUriWrapper.of(count); + DidUri didUri = DidUri.of("ABCDEF"); + DidUriWrapper wrapper = DidUriWrapper.of(didUri); String json = "{\"value\": \"ABCDEF\"}"; assertSerializesAndDeserializes(wrapper, json); @@ -38,8 +52,8 @@ void testJson() throws JsonProcessingException, JSONException { @Test void testEmptyValueJson() throws JSONException, JsonProcessingException { - DidUri count = DidUri.of(""); - DidUriWrapper wrapper = DidUriWrapper.of(count); + DidUri didUri = DidUri.of(""); + DidUriWrapper wrapper = DidUriWrapper.of(didUri); String json = "{\"value\": \"\"}"; assertSerializesAndDeserializes(wrapper, json); diff --git a/xrpl4j-core/src/test/java/org/xrpl/xrpl4j/model/transactions/MarkerTest.java b/xrpl4j-core/src/test/java/org/xrpl/xrpl4j/model/transactions/MarkerTest.java index a7a7d9e2d..acbbb7bbf 100644 --- a/xrpl4j-core/src/test/java/org/xrpl/xrpl4j/model/transactions/MarkerTest.java +++ b/xrpl4j-core/src/test/java/org/xrpl/xrpl4j/model/transactions/MarkerTest.java @@ -22,13 +22,24 @@ import static org.assertj.core.api.Assertions.assertThat; +import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.fasterxml.jackson.databind.annotation.JsonDeserialize; +import com.fasterxml.jackson.databind.annotation.JsonSerialize; +import org.immutables.value.Value; +import org.json.JSONException; import org.junit.jupiter.api.Test; +import org.skyscreamer.jsonassert.JSONAssert; +import org.skyscreamer.jsonassert.JSONCompareMode; +import org.xrpl.xrpl4j.model.jackson.ObjectMapperFactory; /** * Unit tests for {@link Marker}. */ public class MarkerTest { + private final ObjectMapper objectMapper = ObjectMapperFactory.create(); + @Test void testToString() { Marker marker = Marker.of(""); @@ -40,5 +51,37 @@ void testToString() { marker = Marker.of("{\"ledger\":123,\"seq\":456}"); assertThat(marker.toString()).isEqualTo("{\"ledger\":123,\"seq\":456}"); } -} + @Test + void testWithValidValue() { + Marker marker = Marker.of("test_marker_value"); + assertThat(marker.value()).isEqualTo("test_marker_value"); + assertThat(marker.toString()).isEqualTo("test_marker_value"); + assertThat(marker.equals(null)).isFalse(); + } + + @Test + void testJsonSerialization() throws JsonProcessingException, JSONException { + Marker marker = Marker.of("marker123"); + MarkerWrapper wrapper = MarkerWrapper.of(marker); + + String json = "{\"marker\":\"marker123\"}"; + String serialized = objectMapper.writeValueAsString(wrapper); + JSONAssert.assertEquals(json, serialized, JSONCompareMode.STRICT); + + MarkerWrapper deserialized = objectMapper.readValue(serialized, MarkerWrapper.class); + assertThat(deserialized).isEqualTo(wrapper); + } + + @Value.Immutable + @JsonSerialize(as = ImmutableMarkerWrapper.class) + @JsonDeserialize(as = ImmutableMarkerWrapper.class) + public interface MarkerWrapper { + + static MarkerWrapper of(Marker marker) { + return ImmutableMarkerWrapper.builder().marker(marker).build(); + } + + Marker marker(); + } +} diff --git a/xrpl4j-core/src/test/java/org/xrpl/xrpl4j/model/transactions/MpTokenMetadataTest.java b/xrpl4j-core/src/test/java/org/xrpl/xrpl4j/model/transactions/MpTokenMetadataTest.java index c041e9279..6ea680586 100644 --- a/xrpl4j-core/src/test/java/org/xrpl/xrpl4j/model/transactions/MpTokenMetadataTest.java +++ b/xrpl4j-core/src/test/java/org/xrpl/xrpl4j/model/transactions/MpTokenMetadataTest.java @@ -22,13 +22,24 @@ import static org.assertj.core.api.Assertions.assertThat; +import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.fasterxml.jackson.databind.annotation.JsonDeserialize; +import com.fasterxml.jackson.databind.annotation.JsonSerialize; +import org.immutables.value.Value; +import org.json.JSONException; import org.junit.jupiter.api.Test; +import org.skyscreamer.jsonassert.JSONAssert; +import org.skyscreamer.jsonassert.JSONCompareMode; +import org.xrpl.xrpl4j.model.jackson.ObjectMapperFactory; /** * Unit tests for {@link MpTokenMetadata}. */ public class MpTokenMetadataTest { + private final ObjectMapper objectMapper = ObjectMapperFactory.create(); + @Test void testToString() { MpTokenMetadata metadata = MpTokenMetadata.of(""); @@ -40,5 +51,36 @@ void testToString() { metadata = MpTokenMetadata.of("48656C6C6F20576F726C64"); assertThat(metadata.toString()).isEqualTo("48656C6C6F20576F726C64"); } -} + @Test + void testWithValidValue() { + MpTokenMetadata metadata = MpTokenMetadata.of("68747470733A2F2F6578616D706C652E636F6D"); + assertThat(metadata.value()).isEqualTo("68747470733A2F2F6578616D706C652E636F6D"); + assertThat(metadata.equals(null)).isFalse(); + } + + @Test + void testJsonSerialization() throws JsonProcessingException, JSONException { + MpTokenMetadata metadata = MpTokenMetadata.of("ABCDEF1234567890"); + MpTokenMetadataWrapper wrapper = MpTokenMetadataWrapper.of(metadata); + + String json = "{\"metadata\":\"ABCDEF1234567890\"}"; + String serialized = objectMapper.writeValueAsString(wrapper); + JSONAssert.assertEquals(json, serialized, JSONCompareMode.STRICT); + + MpTokenMetadataWrapper deserialized = objectMapper.readValue(serialized, MpTokenMetadataWrapper.class); + assertThat(deserialized).isEqualTo(wrapper); + } + + @Value.Immutable + @JsonSerialize(as = ImmutableMpTokenMetadataWrapper.class) + @JsonDeserialize(as = ImmutableMpTokenMetadataWrapper.class) + public interface MpTokenMetadataWrapper { + + static MpTokenMetadataWrapper of(MpTokenMetadata metadata) { + return ImmutableMpTokenMetadataWrapper.builder().metadata(metadata).build(); + } + + MpTokenMetadata metadata(); + } +} diff --git a/xrpl4j-core/src/test/java/org/xrpl/xrpl4j/model/transactions/MpTokenNumericAmountTest.java b/xrpl4j-core/src/test/java/org/xrpl/xrpl4j/model/transactions/MpTokenNumericAmountTest.java index 56bb7773d..652a0ddac 100644 --- a/xrpl4j-core/src/test/java/org/xrpl/xrpl4j/model/transactions/MpTokenNumericAmountTest.java +++ b/xrpl4j-core/src/test/java/org/xrpl/xrpl4j/model/transactions/MpTokenNumericAmountTest.java @@ -22,14 +22,35 @@ import static org.assertj.core.api.Assertions.assertThat; +import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.fasterxml.jackson.databind.annotation.JsonDeserialize; +import com.fasterxml.jackson.databind.annotation.JsonSerialize; import com.google.common.primitives.UnsignedLong; +import org.assertj.core.api.Assertions; +import org.immutables.value.Value; +import org.json.JSONException; import org.junit.jupiter.api.Test; +import org.skyscreamer.jsonassert.JSONAssert; +import org.skyscreamer.jsonassert.JSONCompareMode; +import org.xrpl.xrpl4j.model.jackson.ObjectMapperFactory; /** * Unit tests for {@link MpTokenNumericAmount}. */ public class MpTokenNumericAmountTest { + ObjectMapper objectMapper = ObjectMapperFactory.create(); + + @Test + void testBounds() { + MpTokenNumericAmount amount = MpTokenNumericAmount.of(UnsignedLong.ZERO); + assertThat(amount.value()).isEqualTo(UnsignedLong.ZERO); + + amount = MpTokenNumericAmount.of(UnsignedLong.MAX_VALUE); + assertThat(amount.value()).isEqualTo(UnsignedLong.MAX_VALUE); + } + @Test void testToString() { MpTokenNumericAmount amount = MpTokenNumericAmount.of(UnsignedLong.ZERO); @@ -41,5 +62,53 @@ void testToString() { amount = MpTokenNumericAmount.of(UnsignedLong.MAX_VALUE); assertThat(amount.toString()).isEqualTo("18446744073709551615"); } -} + @Test + void testOfLong() { + MpTokenNumericAmount amount = MpTokenNumericAmount.of(500L); + assertThat(amount.value()).isEqualTo(UnsignedLong.valueOf(500)); + } + + @Test + void testJson() throws JsonProcessingException, JSONException { + MpTokenNumericAmount amount = MpTokenNumericAmount.of(UnsignedLong.valueOf(999)); + MpTokenNumericAmountWrapper wrapper = MpTokenNumericAmountWrapper.of(amount); + + String json = "{\"amount\": \"999\"}"; + assertSerializesAndDeserializes(wrapper, json); + } + + @Test + void testMaxJson() throws JSONException, JsonProcessingException { + MpTokenNumericAmount amount = MpTokenNumericAmount.of(UnsignedLong.MAX_VALUE); + MpTokenNumericAmountWrapper wrapper = MpTokenNumericAmountWrapper.of(amount); + + String json = "{\"amount\": \"18446744073709551615\"}"; + assertSerializesAndDeserializes(wrapper, json); + } + + private void assertSerializesAndDeserializes( + MpTokenNumericAmountWrapper wrapper, + String json + ) throws JsonProcessingException, JSONException { + String serialized = objectMapper.writeValueAsString(wrapper); + JSONAssert.assertEquals(json, serialized, JSONCompareMode.STRICT); + MpTokenNumericAmountWrapper deserialized = objectMapper.readValue( + serialized, MpTokenNumericAmountWrapper.class + ); + Assertions.assertThat(deserialized).isEqualTo(wrapper); + } + + @Value.Immutable + @JsonSerialize(as = ImmutableMpTokenNumericAmountWrapper.class) + @JsonDeserialize(as = ImmutableMpTokenNumericAmountWrapper.class) + interface MpTokenNumericAmountWrapper { + + static MpTokenNumericAmountWrapper of(MpTokenNumericAmount amount) { + return ImmutableMpTokenNumericAmountWrapper.builder().amount(amount).build(); + } + + MpTokenNumericAmount amount(); + + } +} diff --git a/xrpl4j-core/src/test/java/org/xrpl/xrpl4j/model/transactions/NetworkIdTest.java b/xrpl4j-core/src/test/java/org/xrpl/xrpl4j/model/transactions/NetworkIdTest.java index 23a68032d..3e68fab22 100644 --- a/xrpl4j-core/src/test/java/org/xrpl/xrpl4j/model/transactions/NetworkIdTest.java +++ b/xrpl4j-core/src/test/java/org/xrpl/xrpl4j/model/transactions/NetworkIdTest.java @@ -2,6 +2,7 @@ import static org.assertj.core.api.AssertionsForClassTypes.assertThat; import static org.assertj.core.api.AssertionsForClassTypes.assertThatThrownBy; +import static org.junit.jupiter.api.Assertions.assertThrows; import com.fasterxml.jackson.core.JsonProcessingException; import com.fasterxml.jackson.databind.ObjectMapper; @@ -16,10 +17,27 @@ import org.skyscreamer.jsonassert.JSONCompareMode; import org.xrpl.xrpl4j.model.jackson.ObjectMapperFactory; +/** + * Unit tests for {@link NetworkId}. + */ public class NetworkIdTest { + private static final NetworkId NETWORK_ID_ONE = NetworkId.of(UnsignedInteger.ONE); + ObjectMapper objectMapper = ObjectMapperFactory.create(); + @Test + void testNull() { + assertThrows(NullPointerException.class, () -> NetworkId.of(null)); + } + + @Test + void testEquality() { + assertThat(NETWORK_ID_ONE).isEqualTo(NETWORK_ID_ONE); + assertThat(NETWORK_ID_ONE).isNotEqualTo(new Object()); + assertThat(NETWORK_ID_ONE.equals(null)).isFalse(); + } + @Test void testBounds() { NetworkId networkId = NetworkId.of(UnsignedInteger.ZERO); @@ -33,6 +51,7 @@ void testBounds() { void testToString() { NetworkId networkId = NetworkId.of(UnsignedInteger.valueOf(1024)); assertThat(networkId.toString()).isEqualTo("1024"); + assertThat(networkId.equals(null)).isFalse(); } @Test diff --git a/xrpl4j-core/src/test/java/org/xrpl/xrpl4j/model/transactions/OracleDocumentIdTest.java b/xrpl4j-core/src/test/java/org/xrpl/xrpl4j/model/transactions/OracleDocumentIdTest.java index 976ef71b2..89d754c0d 100644 --- a/xrpl4j-core/src/test/java/org/xrpl/xrpl4j/model/transactions/OracleDocumentIdTest.java +++ b/xrpl4j-core/src/test/java/org/xrpl/xrpl4j/model/transactions/OracleDocumentIdTest.java @@ -1,6 +1,7 @@ package org.xrpl.xrpl4j.model.transactions; import static org.assertj.core.api.AssertionsForClassTypes.assertThat; +import static org.junit.jupiter.api.Assertions.assertThrows; import com.fasterxml.jackson.core.JsonProcessingException; import com.fasterxml.jackson.databind.ObjectMapper; @@ -8,7 +9,6 @@ import com.fasterxml.jackson.databind.annotation.JsonSerialize; import com.google.common.primitives.UnsignedInteger; import org.assertj.core.api.Assertions; -import org.immutables.value.Value; import org.immutables.value.Value.Immutable; import org.json.JSONException; import org.junit.jupiter.api.Test; @@ -21,18 +21,30 @@ */ public class OracleDocumentIdTest { + private static final OracleDocumentId ORACLE_DOCUMENT_ID = OracleDocumentId.of(UnsignedInteger.ONE); + ObjectMapper objectMapper = ObjectMapperFactory.create(); + @Test + void testNull() { + assertThrows(NullPointerException.class, () -> OracleDocumentId.of(null)); + } + + @Test + void testEquality() { + assertThat(ORACLE_DOCUMENT_ID).isEqualTo(ORACLE_DOCUMENT_ID); + assertThat(ORACLE_DOCUMENT_ID).isNotEqualTo(new Object()); + assertThat(ORACLE_DOCUMENT_ID.equals(null)).isFalse(); + } + @Test void testToString() { - OracleDocumentId count = OracleDocumentId.of(UnsignedInteger.ONE); - assertThat(count.toString()).isEqualTo("1"); + assertThat(ORACLE_DOCUMENT_ID.toString()).isEqualTo("1"); } @Test void testJson() throws JsonProcessingException, JSONException { - OracleDocumentId count = OracleDocumentId.of(UnsignedInteger.ONE); - OracleDocumentIdWrapper wrapper = OracleDocumentIdWrapper.of(count); + OracleDocumentIdWrapper wrapper = OracleDocumentIdWrapper.of(ORACLE_DOCUMENT_ID); String json = "{\"value\": 1}"; assertSerializesAndDeserializes(wrapper, json); diff --git a/xrpl4j-core/src/test/java/org/xrpl/xrpl4j/model/transactions/OracleProviderTest.java b/xrpl4j-core/src/test/java/org/xrpl/xrpl4j/model/transactions/OracleProviderTest.java index 024c11de5..d5fc833f0 100644 --- a/xrpl4j-core/src/test/java/org/xrpl/xrpl4j/model/transactions/OracleProviderTest.java +++ b/xrpl4j-core/src/test/java/org/xrpl/xrpl4j/model/transactions/OracleProviderTest.java @@ -1,12 +1,12 @@ package org.xrpl.xrpl4j.model.transactions; import static org.assertj.core.api.AssertionsForClassTypes.assertThat; +import static org.junit.jupiter.api.Assertions.assertThrows; import com.fasterxml.jackson.core.JsonProcessingException; import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.databind.annotation.JsonDeserialize; import com.fasterxml.jackson.databind.annotation.JsonSerialize; -import com.google.common.primitives.UnsignedInteger; import org.assertj.core.api.Assertions; import org.immutables.value.Value.Immutable; import org.json.JSONException; @@ -17,18 +17,30 @@ public class OracleProviderTest { + private static final OracleProvider ORACLE_PROVIDER = OracleProvider.of("ABCD"); + ObjectMapper objectMapper = ObjectMapperFactory.create(); + @Test + void testNull() { + assertThrows(NullPointerException.class, () -> OracleProvider.of(null)); + } + + @Test + void testEquality() { + assertThat(ORACLE_PROVIDER).isEqualTo(ORACLE_PROVIDER); + assertThat(ORACLE_PROVIDER).isNotEqualTo(new Object()); + assertThat(ORACLE_PROVIDER.equals(null)).isFalse(); + } + @Test void testToString() { - OracleProvider count = OracleProvider.of("ABCD"); - assertThat(count.toString()).isEqualTo("ABCD"); + assertThat(ORACLE_PROVIDER.toString()).isEqualTo("ABCD"); } @Test void testJson() throws JsonProcessingException, JSONException { - OracleProvider count = OracleProvider.of("ABCD"); - OracleProviderWrapper wrapper = OracleProviderWrapper.of(count); + OracleProviderWrapper wrapper = OracleProviderWrapper.of(ORACLE_PROVIDER); String json = "{\"value\": \"ABCD\"}"; assertSerializesAndDeserializes(wrapper, json); diff --git a/xrpl4j-core/src/test/java/org/xrpl/xrpl4j/model/transactions/OracleUriTest.java b/xrpl4j-core/src/test/java/org/xrpl/xrpl4j/model/transactions/OracleUriTest.java index 84d4acac9..c2d051f1a 100644 --- a/xrpl4j-core/src/test/java/org/xrpl/xrpl4j/model/transactions/OracleUriTest.java +++ b/xrpl4j-core/src/test/java/org/xrpl/xrpl4j/model/transactions/OracleUriTest.java @@ -1,6 +1,7 @@ package org.xrpl.xrpl4j.model.transactions; import static org.assertj.core.api.AssertionsForClassTypes.assertThat; +import static org.junit.jupiter.api.Assertions.assertThrows; import com.fasterxml.jackson.core.JsonProcessingException; import com.fasterxml.jackson.databind.ObjectMapper; @@ -19,18 +20,30 @@ */ public class OracleUriTest { + private static final OracleUri ORACLE_URI = OracleUri.of("ABCD"); + ObjectMapper objectMapper = ObjectMapperFactory.create(); + @Test + void testNull() { + assertThrows(NullPointerException.class, () -> OracleUri.of(null)); + } + + @Test + void testEquality() { + assertThat(ORACLE_URI).isEqualTo(ORACLE_URI); + assertThat(ORACLE_URI).isNotEqualTo(new Object()); + assertThat(ORACLE_URI.equals(null)).isFalse(); + } + @Test void testToString() { - OracleUri count = OracleUri.of("ABCD"); - assertThat(count.toString()).isEqualTo("ABCD"); + assertThat(ORACLE_URI.toString()).isEqualTo("ABCD"); } @Test void testJson() throws JsonProcessingException, JSONException { - OracleUri count = OracleUri.of("ABCD"); - OracleUriWrapper wrapper = OracleUriWrapper.of(count); + OracleUriWrapper wrapper = OracleUriWrapper.of(ORACLE_URI); String json = "{\"value\": \"ABCD\"}"; assertSerializesAndDeserializes(wrapper, json); diff --git a/xrpl4j-core/src/test/java/org/xrpl/xrpl4j/model/transactions/TradingFeeTest.java b/xrpl4j-core/src/test/java/org/xrpl/xrpl4j/model/transactions/TradingFeeTest.java index 16aa2f272..a10124853 100644 --- a/xrpl4j-core/src/test/java/org/xrpl/xrpl4j/model/transactions/TradingFeeTest.java +++ b/xrpl4j-core/src/test/java/org/xrpl/xrpl4j/model/transactions/TradingFeeTest.java @@ -2,7 +2,7 @@ import static org.assertj.core.api.AssertionsForClassTypes.assertThat; import static org.assertj.core.api.AssertionsForClassTypes.assertThatThrownBy; -import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; +import static org.junit.jupiter.api.Assertions.assertThrows; import com.fasterxml.jackson.core.JsonProcessingException; import com.fasterxml.jackson.databind.ObjectMapper; @@ -19,15 +19,32 @@ import java.math.BigDecimal; +/** + * Unit tests for {@link TradingFee}. + */ public class TradingFeeTest { + private static final TradingFee TRADING_FEE = TradingFee.of(UnsignedInteger.ONE); ObjectMapper objectMapper = ObjectMapperFactory.create(); + @Test + void testNull() { + assertThrows(NullPointerException.class, () -> TradingFee.of(null)); + assertThatThrownBy(() -> TradingFee.ofPercent(null)) + .isInstanceOf(NullPointerException.class); + } + + @Test + void testEquality() { + assertThat(TRADING_FEE).isEqualTo(TRADING_FEE); + assertThat(TRADING_FEE).isNotEqualTo(new Object()); + assertThat(TRADING_FEE.equals(null)).isFalse(); + } + @Test void fromUnsignedInteger() { - TradingFee fee = TradingFee.of(UnsignedInteger.ONE); - assertThat(fee.toString()).isEqualTo("1"); - assertThat(fee.value()).isEqualTo(UnsignedInteger.ONE); + assertThat(TRADING_FEE.toString()).isEqualTo("1"); + assertThat(TRADING_FEE.value()).isEqualTo(UnsignedInteger.ONE); } @Test diff --git a/xrpl4j-core/src/test/java/org/xrpl/xrpl4j/model/transactions/TransferFeeTest.java b/xrpl4j-core/src/test/java/org/xrpl/xrpl4j/model/transactions/TransferFeeTest.java index 2cf53a3f4..9a94e50e1 100644 --- a/xrpl4j-core/src/test/java/org/xrpl/xrpl4j/model/transactions/TransferFeeTest.java +++ b/xrpl4j-core/src/test/java/org/xrpl/xrpl4j/model/transactions/TransferFeeTest.java @@ -9,9 +9,9 @@ * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at - * + * * http://www.apache.org/licenses/LICENSE-2.0 - * + * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. @@ -30,7 +30,7 @@ import com.fasterxml.jackson.databind.annotation.JsonDeserialize; import com.fasterxml.jackson.databind.annotation.JsonSerialize; import com.google.common.primitives.UnsignedInteger; -import org.assertj.core.api.Assertions; +import org.assertj.core.api.AssertionsForClassTypes; import org.immutables.value.Value; import org.json.JSONException; import org.junit.jupiter.api.Test; @@ -40,10 +40,27 @@ import java.math.BigDecimal; +/** + * Unit tests for {@link TransferFee}. + */ public class TransferFeeTest { + private static final TransferFee TRANSFER_FEE = TransferFee.of(UnsignedInteger.ONE); + ObjectMapper objectMapper = ObjectMapperFactory.create(); + @Test + void testNull() { + assertThrows(NullPointerException.class, () -> TransferFee.of(null)); + } + + @Test + void testEquality() { + AssertionsForClassTypes.assertThat(TRANSFER_FEE).isEqualTo(TRANSFER_FEE); + AssertionsForClassTypes.assertThat(TRANSFER_FEE).isNotEqualTo(new Object()); + AssertionsForClassTypes.assertThat(TRANSFER_FEE.equals(null)).isFalse(); + } + @Test void ofPercent() { assertThat(TransferFee.ofPercent(BigDecimal.valueOf(0)).value()).isEqualTo(UnsignedInteger.valueOf(0)); diff --git a/xrpl4j-core/src/test/java/org/xrpl/xrpl4j/model/transactions/VoteWeightTest.java b/xrpl4j-core/src/test/java/org/xrpl/xrpl4j/model/transactions/VoteWeightTest.java index 1c7180276..468b24d27 100644 --- a/xrpl4j-core/src/test/java/org/xrpl/xrpl4j/model/transactions/VoteWeightTest.java +++ b/xrpl4j-core/src/test/java/org/xrpl/xrpl4j/model/transactions/VoteWeightTest.java @@ -1,6 +1,7 @@ package org.xrpl.xrpl4j.model.transactions; import static org.assertj.core.api.AssertionsForClassTypes.assertThat; +import static org.junit.jupiter.api.Assertions.assertThrows; import com.fasterxml.jackson.core.JsonProcessingException; import com.fasterxml.jackson.databind.ObjectMapper; @@ -8,6 +9,7 @@ import com.fasterxml.jackson.databind.annotation.JsonSerialize; import com.google.common.primitives.UnsignedInteger; import org.assertj.core.api.Assertions; +import org.assertj.core.api.AssertionsForClassTypes; import org.immutables.value.Value; import org.json.JSONException; import org.junit.jupiter.api.Test; @@ -17,9 +19,26 @@ import java.math.BigDecimal; +/** + * Unit tests for {@link VoteWeight}. + */ public class VoteWeightTest { - ObjectMapper objectMapper = ObjectMapperFactory.create(); + private static final VoteWeight VOTE_WEIGHT = VoteWeight.of(UnsignedInteger.ZERO); + + private ObjectMapper objectMapper = ObjectMapperFactory.create(); + + @Test + void testNull() { + assertThrows(NullPointerException.class, () -> VoteWeight.of(null)); + } + + @Test + void testEquality() { + AssertionsForClassTypes.assertThat(VOTE_WEIGHT).isEqualTo(VOTE_WEIGHT); + AssertionsForClassTypes.assertThat(VOTE_WEIGHT).isNotEqualTo(new Object()); + AssertionsForClassTypes.assertThat(VOTE_WEIGHT.equals(null)).isFalse(); + } @Test void bigDecimalValue() { @@ -41,8 +60,7 @@ void bigDecimalValue() { @Test void testToString() { - VoteWeight weight = VoteWeight.of(UnsignedInteger.ZERO); - assertThat(weight.toString()).isEqualTo(UnsignedInteger.ZERO.toString()); + assertThat(VOTE_WEIGHT.toString()).isEqualTo(UnsignedInteger.ZERO.toString()); } @Test diff --git a/xrpl4j-core/src/test/java/org/xrpl/xrpl4j/model/transactions/WrappersTest.java b/xrpl4j-core/src/test/java/org/xrpl/xrpl4j/model/transactions/WrappersTest.java new file mode 100644 index 000000000..50d292348 --- /dev/null +++ b/xrpl4j-core/src/test/java/org/xrpl/xrpl4j/model/transactions/WrappersTest.java @@ -0,0 +1,11 @@ +package org.xrpl.xrpl4j.model.transactions; + +/** + * Unit tests for {@link Wrappers}. + * + *

NOTE: Unit tests for classes defined in `Wrappers.java` are spread across multiple test files in this package. + */ +class WrappersTest { + + // NOTE: Unit tests for classes defined in `Wrappers.java` are spread across multiple test files in this package. +} diff --git a/xrpl4j-core/src/test/java/org/xrpl/xrpl4j/model/transactions/XAddressTest.java b/xrpl4j-core/src/test/java/org/xrpl/xrpl4j/model/transactions/XAddressTest.java new file mode 100644 index 000000000..77800ef27 --- /dev/null +++ b/xrpl4j-core/src/test/java/org/xrpl/xrpl4j/model/transactions/XAddressTest.java @@ -0,0 +1,84 @@ +package org.xrpl.xrpl4j.model.transactions; + +/*- + * ========================LICENSE_START================================= + * xrpl4j :: core + * %% + * Copyright (C) 2020 - 2023 XRPL Foundation and its contributors + * %% + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * =========================LICENSE_END================================== + */ + +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.api.Assertions.assertThrows; + +import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.fasterxml.jackson.databind.annotation.JsonDeserialize; +import com.fasterxml.jackson.databind.annotation.JsonSerialize; +import org.assertj.core.api.AssertionsForClassTypes; +import org.immutables.value.Value; +import org.json.JSONException; +import org.junit.jupiter.api.Test; +import org.skyscreamer.jsonassert.JSONAssert; +import org.skyscreamer.jsonassert.JSONCompareMode; +import org.xrpl.xrpl4j.model.jackson.ObjectMapperFactory; + +/** + * Unit tests for {@link XAddress}. + */ +public class XAddressTest { + + private final ObjectMapper objectMapper = ObjectMapperFactory.create(); + + private static final XAddress X_ADDRESS = XAddress.of("X7AcgcsBL6XDcUb289X4mJ8djcdyKaB5hJDWMArnXr61cqZ"); + + @Test + void testNull() { + assertThrows(NullPointerException.class, () -> XAddress.of(null)); + AssertionsForClassTypes.assertThat(X_ADDRESS.equals(null)).isFalse(); + } + + @Test + void testWithValidValue() { + assertThat(X_ADDRESS.value()).isEqualTo("X7AcgcsBL6XDcUb289X4mJ8djcdyKaB5hJDWMArnXr61cqZ"); + assertThat(X_ADDRESS.toString()).isEqualTo("X7AcgcsBL6XDcUb289X4mJ8djcdyKaB5hJDWMArnXr61cqZ"); + assertThat(X_ADDRESS.equals(null)).isFalse(); + } + + @Test + void testJsonSerialization() throws JsonProcessingException, JSONException { + XAddressWrapper wrapper = XAddressWrapper.of(X_ADDRESS); + + // XAddress uses default Immutables serialization (as an object with "value" field) + String json = "{\"value\":{\"value\":\"X7AcgcsBL6XDcUb289X4mJ8djcdyKaB5hJDWMArnXr61cqZ\"}}"; + String serialized = objectMapper.writeValueAsString(wrapper); + JSONAssert.assertEquals(json, serialized, JSONCompareMode.STRICT); + + XAddressWrapper deserialized = objectMapper.readValue(serialized, XAddressWrapper.class); + assertThat(deserialized).isEqualTo(wrapper); + } + + @Value.Immutable + @JsonSerialize(as = ImmutableXAddressWrapper.class) + @JsonDeserialize(as = ImmutableXAddressWrapper.class) + public interface XAddressWrapper { + + static XAddressWrapper of(XAddress value) { + return ImmutableXAddressWrapper.builder().value(value).build(); + } + + XAddress value(); + } +} diff --git a/xrpl4j-core/src/test/java/org/xrpl/xrpl4j/model/transactions/XChainClaimIdTest.java b/xrpl4j-core/src/test/java/org/xrpl/xrpl4j/model/transactions/XChainClaimIdTest.java index afe177207..e0be81836 100644 --- a/xrpl4j-core/src/test/java/org/xrpl/xrpl4j/model/transactions/XChainClaimIdTest.java +++ b/xrpl4j-core/src/test/java/org/xrpl/xrpl4j/model/transactions/XChainClaimIdTest.java @@ -1,6 +1,7 @@ package org.xrpl.xrpl4j.model.transactions; import static org.assertj.core.api.AssertionsForClassTypes.assertThat; +import static org.junit.jupiter.api.Assertions.assertThrows; import com.fasterxml.jackson.core.JsonProcessingException; import com.fasterxml.jackson.databind.ObjectMapper; @@ -9,6 +10,7 @@ import com.google.common.primitives.UnsignedInteger; import com.google.common.primitives.UnsignedLong; import org.assertj.core.api.Assertions; +import org.assertj.core.api.AssertionsForClassTypes; import org.immutables.value.Value; import org.json.JSONException; import org.junit.jupiter.api.Test; @@ -18,15 +20,30 @@ import java.math.BigDecimal; +/** + * Unit tests for {@link XChainClaimId}. + */ public class XChainClaimIdTest { + private static final XChainClaimId ZERO_XCHAIN_CLAIM_ID = XChainClaimId.of(UnsignedLong.ZERO); + ObjectMapper objectMapper = ObjectMapperFactory.create(); @Test - void testToString() { - XChainClaimId claimId = XChainClaimId.of(UnsignedLong.ZERO); - assertThat(claimId.toString()).isEqualTo("0"); + void testNull() { + assertThrows(NullPointerException.class, () -> XChainClaimId.of(null)); + } + + @Test + void testEquality() { + AssertionsForClassTypes.assertThat(ZERO_XCHAIN_CLAIM_ID).isEqualTo(ZERO_XCHAIN_CLAIM_ID); + AssertionsForClassTypes.assertThat(ZERO_XCHAIN_CLAIM_ID).isNotEqualTo(new Object()); + AssertionsForClassTypes.assertThat(ZERO_XCHAIN_CLAIM_ID.equals(null)).isFalse(); + } + @Test + void testToString() { + assertThat(ZERO_XCHAIN_CLAIM_ID.toString()).isEqualTo("0"); XChainClaimId claimIdMax = XChainClaimId.of(UnsignedLong.MAX_VALUE); assertThat(claimIdMax.toString()).isEqualTo("18446744073709551615"); } diff --git a/xrpl4j-core/src/test/java/org/xrpl/xrpl4j/model/transactions/XChainCountTest.java b/xrpl4j-core/src/test/java/org/xrpl/xrpl4j/model/transactions/XChainCountTest.java index dffade43f..a028c17f4 100644 --- a/xrpl4j-core/src/test/java/org/xrpl/xrpl4j/model/transactions/XChainCountTest.java +++ b/xrpl4j-core/src/test/java/org/xrpl/xrpl4j/model/transactions/XChainCountTest.java @@ -1,6 +1,7 @@ package org.xrpl.xrpl4j.model.transactions; import static org.assertj.core.api.AssertionsForClassTypes.assertThat; +import static org.junit.jupiter.api.Assertions.assertThrows; import com.fasterxml.jackson.core.JsonProcessingException; import com.fasterxml.jackson.databind.ObjectMapper; @@ -8,6 +9,7 @@ import com.fasterxml.jackson.databind.annotation.JsonSerialize; import com.google.common.primitives.UnsignedLong; import org.assertj.core.api.Assertions; +import org.assertj.core.api.AssertionsForClassTypes; import org.immutables.value.Value; import org.json.JSONException; import org.junit.jupiter.api.Test; @@ -15,15 +17,30 @@ import org.skyscreamer.jsonassert.JSONCompareMode; import org.xrpl.xrpl4j.model.jackson.ObjectMapperFactory; +/** + * Unit tests for {@link XChainCount}. + */ public class XChainCountTest { + private static final XChainCount ZERO_XCHAIN_COUNT = XChainCount.of(UnsignedLong.ZERO); + ObjectMapper objectMapper = ObjectMapperFactory.create(); @Test - void testToString() { - XChainCount count = XChainCount.of(UnsignedLong.ZERO); - assertThat(count.toString()).isEqualTo("0"); + void testNull() { + assertThrows(NullPointerException.class, () -> XChainCount.of(null)); + } + + @Test + void testEquality() { + AssertionsForClassTypes.assertThat(ZERO_XCHAIN_COUNT).isEqualTo(ZERO_XCHAIN_COUNT); + AssertionsForClassTypes.assertThat(ZERO_XCHAIN_COUNT).isNotEqualTo(new Object()); + AssertionsForClassTypes.assertThat(ZERO_XCHAIN_COUNT.equals(null)).isFalse(); + } + @Test + void testToString() { + assertThat(ZERO_XCHAIN_COUNT.toString()).isEqualTo("0"); XChainCount countMax = XChainCount.of(UnsignedLong.MAX_VALUE); assertThat(countMax.toString()).isEqualTo("18446744073709551615"); } diff --git a/xrpl4j-core/src/test/java/org/xrpl/xrpl4j/model/transactions/XrpCurrencyAmountTest.java b/xrpl4j-core/src/test/java/org/xrpl/xrpl4j/model/transactions/XrpCurrencyAmountTest.java index 4eb05a4eb..38f8781f1 100644 --- a/xrpl4j-core/src/test/java/org/xrpl/xrpl4j/model/transactions/XrpCurrencyAmountTest.java +++ b/xrpl4j-core/src/test/java/org/xrpl/xrpl4j/model/transactions/XrpCurrencyAmountTest.java @@ -489,4 +489,6 @@ interface XrpCurrencyAmountWrapper { XrpCurrencyAmount value(); } + + }