TF_NewShapeAndTypeList(input_shapes_vec.size());
    for (size_t i = 0; i < input_shapes_vec.size(); ++i) {
      const auto& input_shape = input_shapes_vec[i];
      if (input_shape.has_value()) {
        TF_ShapeAndTypeListSetShape(input_shapes, i, input_shape->data(),
                                    input_shape->size());
      } else {
        TF_ShapeAndTypeListSetUnknownShape(input_shapes, i);

      tensorflow::EvaluateConstantTensorRunner{
          graph->graph.op_registry(),
          graph->graph.versions().producer(),
      });
  if (!status_or.ok() || !status_or->has_value()) {
    *result = nullptr;
    status->status = std::move(status_or).status();
    return false;
  }
  *result = TF_TensorFromTensor(**status_or, &status->status);
  return status->status.ok();
}

        // Trigger integer overflow prevention
        try {
            validator.safeAdd(Integer.MAX_VALUE, Integer.MAX_VALUE);
        } catch (SmbException e) {
            // Expected
        }

        try {
            validator.safeMultiply(Integer.MAX_VALUE, 2);
        } catch (SmbException e) {
            // Expected
        }

        when(negotiationResponse.getSendBufferSize()).thenReturn(Integer.MAX_VALUE);
        when(negotiationResponse.getReceiveBufferSize()).thenReturn(Integer.MAX_VALUE);
        when(negotiationResponse.getTransactionBufferSize()).thenReturn(Integer.MAX_VALUE);

        assertEquals(Integer.MAX_VALUE, negotiationResponse.getSendBufferSize());
        assertEquals(Integer.MAX_VALUE, negotiationResponse.getReceiveBufferSize());

internal fun Long.commonClampToInt(): Int =
  when {
    this > Int.MAX_VALUE -> Int.MAX_VALUE
    else -> toInt()
  }

internal fun CacheControl.Companion.commonForceNetwork() =
  CacheControl
    .Builder()
    .noCache()
    .build()

internal fun CacheControl.Companion.commonForceCache() =
  CacheControl
    .Builder()
    .onlyIfCached()
    .maxStale(Int.MAX_VALUE.seconds)
    .build()

    assertEquals(
        Integer.MAX_VALUE, ImmutableCollection.Builder.expandedCapacity(0, Integer.MAX_VALUE));
    assertEquals(
        Integer.MAX_VALUE, ImmutableCollection.Builder.expandedCapacity(1, Integer.MAX_VALUE));
    assertEquals(
        Integer.MAX_VALUE,
        ImmutableCollection.Builder.expandedCapacity(Integer.MAX_VALUE - 1, Integer.MAX_VALUE));

        assertEquals("EndOfFileInformation[endOfFile=0]", info2.toString());

        // Test max value
        FileEndOfFileInformation info3 = new FileEndOfFileInformation(Long.MAX_VALUE);
        assertEquals("EndOfFileInformation[endOfFile=" + Long.MAX_VALUE + "]", info3.toString());
    }

    @Test
    @DisplayName("Test multiple encode operations")
    void testMultipleEncodeOperations() {

            // 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);

  }

  /*
   * binomial(biggestBinomials[k], k) fits in a long, but not binomial(biggestBinomials[k] + 1, k).
   */
  static final int[] biggestBinomials = {
    Integer.MAX_VALUE,
    Integer.MAX_VALUE,
    Integer.MAX_VALUE,
    3810779,
    121977,
    16175,
    4337,
    1733,
    887,
    534,
    361,
    265,
    206,
    169,
    143,
    125,
    111,

        String value = null;
        boolean haveValue = false;
        if (encoding != null) {
            try {
                value = item.getString(encoding);
                haveValue = true;
            } catch (final Exception e) {}
        }
        if (!haveValue) {
            try {
                value = item.getString(Charset.forName("ISO-8859-1"));