new RoundToDoubleTester(maxDoubleAsBigInteger)
        .setExpectation(Double.MAX_VALUE, values())
        .test();
  }

  @J2ktIncompatible
  @GwtIncompatible
  public void testRoundToDouble_maxDoublePlusOne() {
    BigInteger maxDoubleAsBigInteger =
        DoubleMath.roundToBigInteger(Double.MAX_VALUE, UNNECESSARY).add(BigInteger.ONE);

      }
    }
  }

  public void testSaturatedAbs() {
    assertEquals(Long.MAX_VALUE, LongMath.saturatedAbs(Long.MIN_VALUE));
    assertEquals(Long.MAX_VALUE, LongMath.saturatedAbs(Long.MAX_VALUE));
    assertEquals(Long.MAX_VALUE, LongMath.saturatedAbs(-Long.MAX_VALUE));
    assertEquals(0, LongMath.saturatedAbs(0));
    assertEquals(1, LongMath.saturatedAbs(1));

            int bytesDecoded = response.decode(buffer, 0, buffer.length);

            assertEquals(12, bytesDecoded);
            assertEquals(Integer.MAX_VALUE, response.getChunksWritten());
            assertEquals(Integer.MAX_VALUE, response.getChunkBytesWritten());
            assertEquals(Integer.MAX_VALUE, response.getTotalBytesWritten());
        }

        SMBUtil.writeTime(maxTime, buffer, 32); // changeTime
        SMBUtil.writeInt8(Long.MAX_VALUE, buffer, 40); // endOfFile
        SMBUtil.writeInt8(Long.MAX_VALUE, buffer, 48); // allocationSize
        SMBUtil.writeInt4(Integer.MAX_VALUE, buffer, 56); // extFileAttributes
        SMBUtil.writeInt4(Integer.MAX_VALUE, buffer, 64); // eaSize

        // Decode
        fileBothDirectoryInfo.decode(buffer, 0, buffer.length);

            byte[] buffer = createValidWriteResponse(Integer.MAX_VALUE, Integer.MAX_VALUE);

            int bytesRead = response.readBytesWireFormat(buffer, 0);

            assertEquals(16, bytesRead);
            assertEquals(Integer.MAX_VALUE, response.getCount());
            assertEquals(Integer.MAX_VALUE, response.getRemaining());
        }

        @Test

        return Long.MAX_VALUE;
      }
      if (end < start && result > 0) { // underflow
        return Long.MIN_VALUE;
      }
      return result;
    }

    @Override
    public Long minValue() {
      return Long.MIN_VALUE;
    }

    @Override
    public Long maxValue() {
      return Long.MAX_VALUE;
    }

    private Object readResolve() {

        assertEquals(-456L, dictionaryItem.getId());
    }

    public void test_getId_maxValue() {
        // Test with maximum Long value
        dictionaryItem.id = Long.MAX_VALUE;
        assertEquals(Long.MAX_VALUE, dictionaryItem.getId());
    }

    public void test_getId_minValue() {
        // Test with minimum Long value
        dictionaryItem.id = Long.MIN_VALUE;

        SMBUtil.writeInt4(Integer.MAX_VALUE, buffer, bufferIndex + 3);
        SMBUtil.writeInt4(Integer.MAX_VALUE, buffer, bufferIndex + 7);
        SMBUtil.writeInt4(Integer.MAX_VALUE, buffer, bufferIndex + 11);
        SMBUtil.writeInt4(Integer.MAX_VALUE, buffer, bufferIndex + 15);
        SMBUtil.writeInt4(Integer.MAX_VALUE, buffer, bufferIndex + 19);
        SMBUtil.writeInt4(Integer.MAX_VALUE, buffer, bufferIndex + 23);

      int n = rand.nextInt(Integer.MAX_VALUE);
      assertEquals(LongMath.isPrime(n), IntMath.isPrime(n));
    }
  }

  public void testSaturatedAbs() {
    assertEquals(Integer.MAX_VALUE, IntMath.saturatedAbs(Integer.MIN_VALUE));
    assertEquals(Integer.MAX_VALUE, IntMath.saturatedAbs(Integer.MAX_VALUE));
    assertEquals(Integer.MAX_VALUE, IntMath.saturatedAbs(-Integer.MAX_VALUE));
    assertEquals(0, IntMath.saturatedAbs(0));

            // Given
            byte[] maxKey = new byte[SOURCE_KEY_SIZE];
            Arrays.fill(maxKey, (byte) 0xFF);
            SrvCopychunk chunk = new SrvCopychunk(Long.MAX_VALUE, Long.MAX_VALUE, Integer.MAX_VALUE);
            SrvCopychunkCopy copy = new SrvCopychunkCopy(maxKey, chunk);
            byte[] buffer = new byte[100];

            // When
            int bytesWritten = copy.encode(buffer, 0);