* byte-based hashcode. Otherwise it returns {@link HashCode#asBytes}. Do <i>not</i> mutate this
   * array or else you will break the immutability contract of {@code HashCode}.
   */
  byte[] getBytesInternal() {
    return asBytes();
  }

  /**
   * Returns whether this {@code HashCode} and that {@code HashCode} have the same value, given that

    assertThat(hashCode.toString()).isEqualTo("cdab0000");

    bytes[0] = (byte) 0x00;

    assertEquals(0x0000ab00, hashCode.asInt());
    assertThat(hashCode.toString()).isEqualTo("00ab0000");
  }

  public void testGetBytesInternal_noCloneOccurs() {
    byte[] bytes = new byte[] {(byte) 0xcd, (byte) 0xab, (byte) 0x00, (byte) 0x00};
    HashCode hashCode = HashCode.fromBytes(bytes);

        result = 31 * result + a.getGroupId().hashCode();
        result = 31 * result + a.getArtifactId().hashCode();
        result = 31 * result + a.getType().hashCode();
        if (a.getVersion() != null) {
            result = 31 * result + a.getVersion().hashCode();
        }
        result = 31 * result + (a.getClassifier() != null ? a.getClassifier().hashCode() : 0);

        // Same inputs and output should have same hash code
        assertEquals(item1.hashCode(), item2.hashCode());

        // Different inputs should have different hash code
        assertNotSame(item1.hashCode(), item3.hashCode());

        // Same inputs but different output should have different hash code
        assertNotSame(item1.hashCode(), item4.hashCode());
    }

    @Test
    public void test_hashCode_withNullOutput() {

    assertThat(hashCode.toString()).isEqualTo("cdab0000");

    bytes[0] = (byte) 0x00;

    assertEquals(0x0000ab00, hashCode.asInt());
    assertThat(hashCode.toString()).isEqualTo("00ab0000");
  }

  public void testGetBytesInternal_noCloneOccurs() {
    byte[] bytes = new byte[] {(byte) 0xcd, (byte) 0xab, (byte) 0x00, (byte) 0x00};
    HashCode hashCode = HashCode.fromBytes(bytes);

      assertErrorMessage(
          e,
          "the Object#hashCode ("
              + a.hashCode()
              + ") of "
              + a
              + " [group 1, item 1] must be equal to the Object#hashCode ("
              + b.hashCode()
              + ") of "
              + b);
      return;
    }
    fail("Should get invalid hashCode error");
  }

  public void testNullEqualityGroup() {

    checkSameResult(HashCode.fromLong(1), 1);
    checkSameResult(HashCode.fromLong(0x9999999999999999L), 0x9999999999999999L);
    checkSameResult(HashCode.fromInt(0x99999999), 0x0000000099999999L);
  }

  public void checkSameResult(HashCode hashCode, long equivLong) {
    assertEquals(Hashing.consistentHash(equivLong, 5555), Hashing.consistentHash(hashCode, 5555));
  }

  /**

 *
 * <h3>Relationship to {@link Object#hashCode}</h3>
 *
 * <p>Java's baked-in concept of hash codes is constrained to 32 bits, and provides no separation
 * between hash algorithms and the data they act on, so alternate hash algorithms can't be easily
 * substituted. Also, implementations of {@code hashCode} tend to be poor-quality, in part because

        // Different input should have different hashCode
        assertNotSame(item1.hashCode(), item4.hashCode());
    }

    @Test
    public void test_hashCode_withNullInput() {
        // Test hashCode with null input - should not throw, returns consistent hash for null
        StopwordsItem item1 = new StopwordsItem(1, null);
        StopwordsItem item2 = new StopwordsItem(2, null);

      assertErrorMessage(
          e,
          "the Object#hashCode ("
              + a.hashCode()
              + ") of "
              + a
              + " [group 1, item 1] must be equal to the Object#hashCode ("
              + b.hashCode()
              + ") of "
              + b);
      return;
    }
    fail("Should get invalid hashCode error");
  }

  public void testNullEqualityGroup() {