TF_CAPI_EXPORT extern TF_AttrType TFE_OpNameGetAttrType(
    TFE_Context* ctx, const char* op_or_function_name, const char* attr_name,
    unsigned char* is_list, TF_Status* status);

TF_CAPI_EXPORT extern void TFE_OpSetAttrString(TFE_Op* op,
                                               const char* attr_name,
                                               const void* value,

                                          const char* attr_name,
                                          unsigned char value);
TF_CAPI_EXPORT extern void TF_SetAttrBoolList(TF_OperationDescription* desc,
                                              const char* attr_name,
                                              const unsigned char* values,
                                              int num_values);

  // original character value.
  @VisibleForTesting
  static char[][] createReplacementArray(Map<Character, String> map) {
    checkNotNull(map); // GWT specific check (do not optimize)
    if (map.isEmpty()) {
      return EMPTY_REPLACEMENT_ARRAY;
    }
    char max = max(map.keySet());
    char[][] replacements = new char[max + 1][];
    for (Character c : map.keySet()) {

   */
  public static char toLowerCase(char c) {
    return isUpperCase(c) ? (char) (c ^ CASE_MASK) : c;
  }

  /**
   * Returns a copy of the input string in which all {@linkplain #isLowerCase(char) lowercase ASCII
   * characters} have been converted to uppercase. All other characters are copied without
   * modification.
   */
  public static String toUpperCase(String string) {
    int length = string.length();

        Field passwordField = NtlmPasswordAuthenticator.class.getDeclaredField("password");
        passwordField.setAccessible(true);

        char[] originalPassword = (char[]) passwordField.get(authenticator);
        char[] clonedPassword = (char[]) passwordField.get(cloned);

        assertNotSame(originalPassword, clonedPassword, "Cloned password should be a different array instance");

  /**
   * Convert this builder into an array of char[]s where the maximum index is the value of the
   * highest character that has been seen. The array will be sparse in the sense that any unseen
   * index will default to null.
   *
   * @return a "sparse" array that holds the replacement mappings.
   */
  public char[] @Nullable [] toArray() {
    char[][] result = new char[max + 1][];

      }
    }
  }

  private static String mikeRepeat(String string, int count) {
    int len = string.length();
    char[] strCopy = new char[len * Integer.highestOneBit(count)];
    string.getChars(0, len, strCopy, 0);

    char[] array = new char[len * count];

    int strCopyLen = len;
    int pos = 0;
    while (count != 0) {
      if ((count & 1) != 0) {

  absl::Status Reset(const char* op, const char* raw_device_name) override {
    if (op_) {
      return errors::FailedPrecondition("Reset called on already built op.");
    }
    if (raw_device_name) {
      device_name_ = raw_device_name;
    }
    op_type_ = op;
    return absl::OkStatus();
  }
  absl::Status SetOpName(const char* const op_name) override {
    if (op_) {

      assertThat(expected.message)
        .isEqualTo("Unexpected char 0xe9 at 1 in header name: héader1")
    }
  }

  @Test fun builderRejectsUnicodeInHeaderValue() {
    assertFailsWith<IllegalArgumentException> {
      Headers.Builder().add("header1", "valué1")
    }.also { expected ->
      assertThat(expected.message)
        .isEqualTo("Unexpected char 0xe9 at 4 in header1 value: valué1")
    }
  }

    }

    /**
     * Test password in equals method
     */
    @Test
    public void testEqualsWithSecurePassword() {
        char[] password1 = "TestPass123!".toCharArray();
        char[] password2 = "TestPass123!".toCharArray();
        char[] password3 = "DifferentPass!".toCharArray();

        NtlmPasswordAuthenticator auth1 = new NtlmPasswordAuthenticator("DOMAIN", "user", password1);