*/
@NullMarked
@GwtCompatible
public class SignedBytesTest extends TestCase {
  private static final byte[] EMPTY = {};
  private static final byte[] ARRAY1 = {(byte) 1};

  private static final byte LEAST = Byte.MIN_VALUE;
  private static final byte GREATEST = Byte.MAX_VALUE;

  private static final byte[] VALUES = {LEAST, -1, 0, 1, GREATEST};

  public void testCheckedCast() {
    for (byte value : VALUES) {

    assertHash(-1653689534, murmur3_32().hashInt(Integer.MAX_VALUE));
  }

  public void testKnownLongInputs() {
    assertHash(1669671676, murmur3_32().hashLong(0L));
    assertHash(-846261623, murmur3_32().hashLong(-42L));
    assertHash(1871679806, murmur3_32().hashLong(42L));
    assertHash(1366273829, murmur3_32().hashLong(Long.MIN_VALUE));

    for (int i = -3; i <= 3; i++) {
      testIntsBuilder
          .add(i)
          .add(force32(Integer.MIN_VALUE + i))
          .add(force32(Integer.MAX_VALUE + i));
      testLongsBuilder
          .add((long) i)
          .add((long) Integer.MIN_VALUE + i)
          .add((long) Integer.MAX_VALUE + i)
          .add((1L << 32) + i);
    }
    TEST_INTS = testIntsBuilder.build();

        assertTrue(info.toString().contains("endOfFile=" + endOfFile));
    }

    @ParameterizedTest
    @ValueSource(longs = { 0L, 1L, 100L, 1024L, Long.MAX_VALUE, -1L, Long.MIN_VALUE })
    @DisplayName("Test constructor with various end of file values")
    void testConstructorWithVariousValues(long endOfFile) {
        FileEndOfFileInformation info = new FileEndOfFileInformation(endOfFile);

   * thread safe.
   *
   * <p>The initial state of the builder is such that:
   *
   * <ul>
   *   <li>There are no replacement mappings
   *   <li>{@code safeMin == Character.MIN_VALUE}
   *   <li>{@code safeMax == Character.MAX_VALUE}
   *   <li>{@code unsafeReplacement == null}
   * </ul>
   *
   * <p>For performance reasons escapers created by this builder are not Unicode aware and will not

    void testDecodeWithMinIndexNumber() throws SMBProtocolDecodingException {
        // Prepare test data
        byte[] buffer = new byte[8];
        long expectedIndexNumber = Long.MIN_VALUE;

        // Encode test data
        SMBUtil.writeInt8(expectedIndexNumber, buffer, 0);

        // Decode
        int bytesDecoded = fileInternalInfo.decode(buffer, 0, buffer.length);

        // Verify

        0.1,
        0.5,
        1.0,
        Double.MAX_VALUE,
        GREATEST,
        Double.MIN_NORMAL,
        -Double.MIN_NORMAL,
        Double.MIN_VALUE,
        -Double.MIN_VALUE,
        Integer.MIN_VALUE,
        Integer.MAX_VALUE,
        Long.MIN_VALUE,
        Long.MAX_VALUE
      };

  private static final double[] VALUES = Doubles.concat(NUMBERS, new double[] {NaN});

    }
  }

  public static final class FloatsAsListHeadSubListGenerator extends TestFloatListGenerator {
    @Override
    protected List<Float> create(Float[] elements) {
      Float[] suffix = {Float.MIN_VALUE, Float.MAX_VALUE};
      Float[] all = concat(elements, suffix);
      return asList(all).subList(0, elements.length);
    }
  }

    }
  }

  public static final class FloatsAsListHeadSubListGenerator extends TestFloatListGenerator {
    @Override
    protected List<Float> create(Float[] elements) {
      Float[] suffix = {Float.MIN_VALUE, Float.MAX_VALUE};
      Float[] all = concat(elements, suffix);
      return asList(all).subList(0, elements.length);
    }
  }

    }
  }

  public static final class IntsAsListHeadSubListGenerator extends TestIntegerListGenerator {
    @Override
    protected List<Integer> create(Integer[] elements) {
      Integer[] suffix = {Integer.MIN_VALUE, Integer.MAX_VALUE};
      Integer[] all = concat(elements, suffix);
      return asList(all).subList(0, elements.length);
    }
  }