*
   * <p>Instead of throwing {@link ArithmeticException}, this method silently saturates to either
   * {@link Long#MAX_VALUE} or {@link Long#MIN_VALUE}. This behavior can be useful when decomposing
   * a duration in order to call a legacy API which requires a {@code long, TimeUnit} pair.
   */
  static long toNanosSaturated(Duration duration) {

      ParameterizedType parameterizedType =
          requireNonNull((ParameterizedType) subclass.getGenericSuperclass());
      for (ClassOwnership behavior : ClassOwnership.values()) {
        if (behavior.getOwnerType(LocalClass.class) == parameterizedType.getOwnerType()) {
          return behavior;
        }
      }
      throw new AssertionError();
    }
  }

  /**

    this.out = out;
  }

  @Override
  public void write(int c) throws IOException {
    super.write(c);
    flush(); // flush write to TestOutputStream to get its behavior
  }

  @Override
  public void write(char[] cbuf, int off, int len) throws IOException {
    super.write(cbuf, off, len);
    flush();
  }

  @Override

import java.util.logging.Logger;
import org.jspecify.annotations.NullMarked;

/**
 * Simple utility for when you want to create a {@link TearDown} that may throw an exception but
 * should not fail a test when it does. (The behavior of a {@code TearDown} that throws an exception
 * varies; see its documentation for details.) Use it just like a {@code TearDown}, except override
 * {@link #sloppyTearDown()} instead.
 *
 * @author Luiz-Otavio Zorzella

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import org.jspecify.annotations.NullUnmarked;

/**
 * A byte sink for testing that has configurable behavior.
 *
 * @author Colin Decker
 */
@NullUnmarked
public class TestByteSink extends ByteSink implements TestStreamSupplier {

  private final ByteArrayOutputStream bytes = new ByteArrayOutputStream();

        // (getPreNTLMResponse, getNTLMResponse, or getLMv2Response all return 24 bytes)
        assertEquals(24, hash.length);
    }

    // Test getUnicodeHash behavior based on static LM_COMPATIBILITY setting
    @Test
    void testGetUnicodeHashWithDefaultLmCompatibility() {
        // With default lmCompatibility=3, getUnicodeHash returns empty array for NTLMv2

 *
 * @author Louis Wasserman
 */
public class OutsideEventBusTest extends TestCase {

  /*
   * If you do this test from common.eventbus.EventBusTest, it doesn't actually test the behavior.
   * That is, even if exactly the same method works from inside the common.eventbus package tests,
   * it can fail here.
   */
  public void testAnonymous() {
    AtomicReference<String> holder = new AtomicReference<>();

 * that order.
 *
 * <p>By default, {@code Splitter}'s behavior is simplistic and unassuming. The following
 * expression:
 *
 * {@snippet :
 * Splitter.on(',').split(" foo,,,  bar ,")
 * }
 *
 * ... yields the substrings {@code [" foo", "", "", " bar ", ""]}. If this is not the desired
 * behavior, use configuration methods to obtain a <i>new</i> splitter instance with modified
 * behavior:
 *
 * {@snippet :

   * {@code true}. The components are evaluated in order, and evaluation will be "short-circuited"
   * as soon as a false predicate is found. It defensively copies the iterable passed in, so future
   * changes to it won't alter the behavior of this predicate. If {@code components} is empty, the
   * returned predicate will always evaluate to {@code true}.
   *
   * <p><b>Discouraged:</b> Prefer using {@code first.and(second).and(third).and(...)}.
   */

import jakarta.validation.constraints.Size;

/**
 * Form class for creating new stemmer override dictionary entries.
 * This form handles the creation of stemmer override rules that modify
 * the stemming behavior for specific words.
 *
 */
public class CreateForm {

    /**
     * Creates a new CreateForm instance.
     */
    public CreateForm() {
    }