throw new IllegalArgumentException("Data buffer cannot be null");
        }
        if (offset < 0 || length < 0) {
            throw new IllegalArgumentException("Offset and length must be non-negative");
        }
        if (offset + length > data.length) {
            throw new IllegalArgumentException("Offset + length exceeds data buffer size");
        }

import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestSuite;
import org.jspecify.annotations.Nullable;

/**
 * Tests {@link MapTestSuiteBuilder} by using it against maps that have various negative behaviors.
 *
 * @author George van den Driessche
 */
@AndroidIncompatible // test-suite builders
public final class MapTestSuiteBuilderTests extends TestCase {
  private MapTestSuiteBuilderTests() {}

   * @return a new, empty {@code CompactLinkedHashMap} with enough capacity to hold {@code
   *     expectedSize} elements without resizing
   * @throws IllegalArgumentException if {@code expectedSize} is negative
   */
  public static <K extends @Nullable Object, V extends @Nullable Object>
      CompactLinkedHashMap<K, V> createWithExpectedSize(int expectedSize) {
    return new CompactLinkedHashMap<>(expectedSize);
  }

		nodes[i] = httptest.NewServer(router)
	}
}

const WriteLock = -1

type lockServer struct {
	mutex sync.Mutex
	// Map of locks, with negative value indicating (exclusive) write lock
	// and positive values indicating number of read locks
	lockMap map[string]int64

	// Refresh returns lock not found if set to true
	lockNotFound bool

    void testTimeReadWriteZero() {
        byte[] buffer = new byte[8];
        ServerMessageBlock.writeTime(0, buffer, 0);
        // When zero is written, it stays as zero in buffer
        // When read back, it converts to negative Unix time due to Windows FileTime conversion
        long expectedTime = -SmbConstants.MILLISECONDS_BETWEEN_1970_AND_1601;
        assertEquals(expectedTime, ServerMessageBlock.readTime(buffer, 0));
    }

    @Test

    if (localInputFuture != null) {
      String message = "inputFuture=[" + localInputFuture + "]";
      if (localTimer != null) {
        long delay = localTimer.getDelay(MILLISECONDS);
        // Negative delays look confusing in an error message
        if (delay > 0) {
          message += ", remaining delay=[" + delay + " ms]";
        }
      }
      return message;
    }
    return null;
  }

//     the request is rejected.
func validateListObjectsArgs(prefix, marker, delimiter, encodingType string, maxKeys int) APIErrorCode {
	// Max keys cannot be negative.
	if maxKeys < 0 {
		return ErrInvalidMaxKeys
	}

	if encodingType != "" {
		// AWS S3 spec only supports 'url' encoding type
		if !strings.EqualFold(encodingType, "url") {
			return ErrInvalidEncodingMethod

      encodings[ 0x12] = encoding // Device Control 2
      encodings[ 0x13] = encoding // Device Control 3 (oft. XOFF)
      encodings[ 0x14] = encoding // Device Control 4
      encodings[ 0x15] = encoding // Negative Acknowledgment
      encodings[ 0x16] = encoding // Synchronous idle
      encodings[ 0x17] = encoding // End of Transmission Block
      encodings[ 0x18] = encoding // Cancel
      encodings[ 0x19] = encoding // End of Medium

          negativeToMaxValue(loadExceptionCount.sum()),
          negativeToMaxValue(totalLoadTime.sum()),
          negativeToMaxValue(evictionCount.sum()));
    }

    /** Returns {@code value}, if non-negative. Otherwise, returns {@link Long#MAX_VALUE}. */
    private static long negativeToMaxValue(long value) {
      return (value >= 0) ? value : Long.MAX_VALUE;
    }

      }
    }
    return s;
  }

  /** Escapes the given Unicode code point in UTF-8. */
  @Override
  protected char @Nullable [] escape(int cp) {
    // We should never get negative values here but if we do it will throw an
    // IndexOutOfBoundsException, so at least it will get spotted.
    if (cp < safeOctets.length && safeOctets[cp]) {
      return null;
    } else if (cp == ' ' && plusForSpace) {