if ( this.inputData != null ) {
            this.inputData.decode(buffer, inputOffset, inputCount);
        }
        bufferIndex = Math.max(inputOffset + inputCount, bufferIndex);

        if ( this.outputBuffer != null ) {
            if ( outputCount > this.outputBuffer.length ) {

    // simple string tests
    assertEquals("", e.escape(""));
    assertEquals("safestring", e.escape("safestring"));
    assertEquals("embedded%00null", e.escape("embedded\0null"));
    assertEquals("max%EF%BF%BFchar", e.escape("max\uffffchar"));
  }

  /** Tests the various ways that the space character can be handled */
  public void testPlusForSpace() {
    UnicodeEscaper basicEscaper = new PercentEscaper("", false);

import static java.lang.Double.doubleToRawLongBits;
import static java.lang.Double.isNaN;
import static java.lang.Double.longBitsToDouble;
import static java.lang.Math.getExponent;
import static java.lang.Math.max;

import com.google.common.annotations.GwtIncompatible;
import com.google.common.annotations.VisibleForTesting;
import java.math.BigInteger;

/**
 * Utilities for {@code double} primitives.
 *

constraints.Digits.message      = {item} is numeric value out of bounds (<{integer} digits>.<{fraction} digits> expected).
constraints.Future.message      = {item} must be in the future.
constraints.Max.message         = {item} must be less than or equal to {value}.
constraints.Min.message         = {item} must be greater than or equal to {value}.
constraints.NotNull.message     = {item} may not be null.

constraints.Digits.message      = {item} is numeric value out of bounds (<{integer} digits>.<{fraction} digits> expected).
constraints.Future.message      = {item} must be in the future.
constraints.Max.message         = {item} must be less than or equal to {value}.
constraints.Min.message         = {item} must be greater than or equal to {value}.
constraints.NotNull.message     = {item} may not be null.

        Integer nid = null;
        int max = this.transportContext.getConfig().getWinsServers().length;

        if ( max == 0 ) {
            max = 1; /* No WINs, try only bcast addr */
        }

        synchronized ( response ) {
            while ( max-- > 0 ) {
                try {
                    synchronized ( this.LOCK ) {

    protected static final String ACCESS_CONTROL_ALLOW_CREDENTIALS = "Access-Control-Allow-Credentials";

    protected static final String ACCESS_CONTROL_MAX_AGE = "Access-Control-Max-Age";

    public abstract void process(String origin, ServletRequest request, ServletResponse response);

      }
    }
  }


  public void testValueOfBigInteger() {
    BigInteger min = BigInteger.ZERO;
    BigInteger max = UnsignedLong.MAX_VALUE.bigIntegerValue();
    for (BigInteger big : TEST_BIG_INTEGERS) {
      boolean expectSuccess = big.compareTo(min) >= 0 && big.compareTo(max) <= 0;
      try {
        assertThat(UnsignedLong.valueOf(big).bigIntegerValue()).isEqualTo(big);
        assertThat(expectSuccess).isTrue();

    this.loadFactor = loadFactor;

    this.keys = new @Nullable Object[expectedSize];
    this.values = new int[expectedSize];

    this.entries = newEntries(expectedSize);
    this.threshold = Math.max(1, (int) (buckets * loadFactor));
  }

  private static int[] newTable(int size) {
    int[] array = new int[size];
    Arrays.fill(array, UNSET);
    return array;
  }

import jakarta.validation.constraints.Size;

/**
 * @author Keiichi Watanabe
 */
public class EditForm extends CreateForm {

    @Required
    @Size(max = 1000)
    public String id;

    @Required
    @ValidateTypeFailure
    public Integer versionNo;