Full unit test coverage for all classes in Wrappers.java

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");
+  }
+}

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();
+  }
 }

xrpl4j-core/src/test/java/org/xrpl/xrpl4j/model/transactions/AssetPriceTest.java

@@ -1,13 +1,15 @@
 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;
@@ -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);

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();
+
+  }
+}