// Verify path length
        assertEquals(pathBytes.length, SMBUtil.readInt2(buffer, bodyOffset + 6));

        // Verify path content
        byte[] actualPath = new byte[pathBytes.length];
        System.arraycopy(buffer, bodyOffset + 8, actualPath, 0, pathBytes.length);
        assertArrayEquals(pathBytes, actualPath);
    }

    @Test

// Returns the length (number of tensors) of the input argument `input_name`
// found in the provided `op`.
TF_CAPI_EXPORT extern int TFE_OpGetInputLength(TFE_Op* op,
                                               const char* input_name,
                                               TF_Status* status);

// Returns the length (number of tensors) of the output argument `output_name`

            assertNotNull(utf16Bytes, "UTF-16LE bytes should not be null");
            assertTrue(utf8Bytes.length > 0, "UTF-8 bytes should not be empty");
            assertTrue(utf16Bytes.length > 0, "UTF-16LE bytes should not be empty");
            assertNotEquals(utf8Bytes.length, utf16Bytes.length, "Different encodings should produce different lengths");
        }

        @ParameterizedTest

            byte[] actualPathBytes = new byte[expectedPathBytes.length];
            System.arraycopy(dst, 2, actualPathBytes, 0, expectedPathBytes.length);
            assertArrayEquals(expectedPathBytes, actualPathBytes);

            // Check null terminator at the end
            int nullTerminatorIndex = 2 + expectedPathBytes.length;
            assertEquals(0, dst[nullTerminatorIndex]);

            trans2QueryFSInfo.writeDataWireFormat(buffer, 0);
            trans2QueryFSInfo.readSetupWireFormat(buffer, 0, buffer.length);
            trans2QueryFSInfo.readParametersWireFormat(buffer, 0, buffer.length);
            trans2QueryFSInfo.readDataWireFormat(buffer, 0, buffer.length);
        }

        // Object should still be in valid state
        String result = trans2QueryFSInfo.toString();

        int paramWritten = trans2SetFileInfo.writeParametersWireFormat(paramBuffer, 0);
        int dataWritten = trans2SetFileInfo.writeDataWireFormat(dataBuffer, 0);

        // Verify lengths
        assertEquals(2, setupWritten);
        assertEquals(6, paramWritten);
        assertEquals(56, dataWritten); // 50 + 6 padding

        // Verify setup content

}

void TFE_OpSetAttrStringList(TFE_Op* op, const char* attr_name,
                             const void* const* values, const size_t* lengths,
                             int num_values) {
  auto s = tensorflow::unwrap(op)->SetAttrStringList(attr_name, values, lengths,
                                                     num_values);
  if (!s.ok()) {
    LOG(WARNING) << "Unable to set attribute: " << attr_name;
  }
}

                      const void* value, size_t length) {
  absl::string_view s(static_cast<const char*>(value), length);
  desc->node_builder.Attr(attr_name, s);
}

void TF_SetAttrStringList(TF_OperationDescription* desc, const char* attr_name,
                          const void* const* values, const size_t* lengths,
                          int num_values) {

        // When
        boolean isError = response.isErrorResponseStatus();

        // Then
        assertFalse(isError);
    }

    @DisplayName("Should handle various data lengths")
    @ParameterizedTest
    @CsvSource({ "0, 0", "1, 10", "100, 200", "512, 1024" })
    void testReadBytesWireFormatVariousDataLengths(int dataLength, int dataRemaining) throws Exception {
        // Given

   * Equivalence}.
   *
   * <p>For example, given an {@link Equivalence} for {@link String strings} named {@code equiv}
   * that tests equivalence using their lengths:
   *
   * {@snippet :
   * equiv.wrap("a").equals(equiv.wrap("b")) // true
   * equiv.wrap("a").equals(equiv.wrap("hello")) // false
   * }
   *