// But before Java 9, our only way not to inherit ThreadLocals is to zap them after the thread
  // is created, by accessing a private field.
  private static final @Nullable Constructor<Thread> bigThreadConstructor =
      getBigThreadConstructor();

  private static final @Nullable Field inheritableThreadLocals =
      (bigThreadConstructor == null) ? getInheritableThreadLocalsField() : null;

     */
    private void resetHandlerState() throws Exception {
        // Reset the static factory field
        Field factoryField = Handler.class.getDeclaredField("factory");
        factoryField.setAccessible(true);
        factoryField.set(null, null);

        // Clear the protocol handlers cache
        Field handlersField = Handler.class.getDeclaredField("PROTOCOL_HANDLERS");
        handlersField.setAccessible(true);

        doc.put("lang", "ja");
        doc.put("title", "タイトル");
        // content field is missing

        languageHelper.updateDocument(doc);

        assertEquals("ja", doc.get("lang"));
        assertEquals("タイトル", doc.get("title_ja"));
        assertNull(doc.get("content_ja")); // content field was not present
    }

    @Test
    public void test_getSupportedLanguage_withWhitespace() {

            }));
            return list;
        });
    }

    /**
     * Updates a specific field in a document.
     *
     * @param index the index name
     * @param id    the document ID
     * @param field the field name to update
     * @param value the new field value
     * @return true if the update was successful, false otherwise

package jcifs.smb1.smb1;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;

import java.lang.reflect.Field;
import java.util.Arrays;

import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;

import jcifs.smb1.util.Hexdump;

/**
 * Unit test for {@link Trans2QueryFSInformation}. The class contains mostly

        namesAndValues.removeAt(i) // name
        namesAndValues.removeAt(i) // value
        i -= 2
      }
      i += 2
    }
  }

/**
 * Set a field with the specified value. If the field is not found, it is added. If the field is
 * found, the existing values are replaced.
 */
internal fun Headers.Builder.commonSet(
  name: String,
  value: String,
) = apply {
  headersCheckName(name)

 *
 * <p>Example usage:</p>
 * <pre>
 * ICUNormalizer normalizer = new ICUNormalizer("Any-Latin; NFD; [:Nonspacing Mark:] Remove; NFC");
 * String normalizedText = normalizer.normalize("text to normalize", "field");
 * </pre>
 *
 * @see com.ibm.icu.text.Transliterator
 */
public class ICUNormalizer implements Normalizer {
    /** The transliterator used for normalization. */
    private final Transliterator transliterator;

            assertEquals(error, echoResponse.getException());
        }
    }

    // Helper methods to set protected fields via reflection
    private void setStatus(ServerMessageBlock2 smb, int status) throws Exception {
        Field statusField = ServerMessageBlock2.class.getDeclaredField("status");
        statusField.setAccessible(true);
        statusField.setInt(smb, status);
    }

    }
  }

  @J2ktIncompatible
  @GwtIncompatible // reflection
  public void testConstants_charset() throws Exception {
    for (Field field : getConstantFields()) {
      Optional<Charset> charset = ((MediaType) field.get(null)).charset();
      if (field.getName().endsWith("_UTF_8")) {
        assertThat(charset).hasValue(UTF_8);
      } else {
        assertThat(charset).isAbsent();
      }
    }
  }

    // our test by setting a static field. We are changing the field in the parallel version of FRQ
    // and each test creates its own one of those, so there is no test interference here.
    Class<?> sepFrqSystemLoaderC =
        sepLoader.loadClass(FinalizableReferenceQueue.SystemLoader.class.getName());
    Field disabled = sepFrqSystemLoaderC.getDeclaredField("disabled");