* Test with data that has exact boundary conditions
     */
    @Test
    @DisplayName("Handle exact boundary data size")
    void testExactBoundarySize() throws CIFSException {
        // Test with data that ends exactly at the position where EOL should be checked
        byte[] data = new byte[0];
        byte[] avPairData = createAvPairData(AvPair.MsvAvTargetName, data);
        byte[] eolData = createEolData();

	}

	// Query IAM

	res, err := globalIAMSys.QueryLDAPPolicyEntities(r.Context(), q)
	if err != nil {
		writeErrorResponseJSON(ctx, w, toAdminAPIErr(ctx, err), r.URL)
		return
	}

	// Encode result and send response.

	data, err := json.Marshal(res)
	if err != nil {
		writeErrorResponseJSON(ctx, w, toAdminAPIErr(ctx, err), r.URL)
		return
	}
	password := cred.SecretKey

// implied by the type argument. If t is nil, clear is a no-op.
func clear[T ~[]Type | ~map[Type]Type1](t T)

// The close built-in function closes a channel, which must be either
// bidirectional or send-only. It should be executed only by the sender,
// never the receiver, and has the effect of shutting down the channel after
// the last sent value is received. After the last value has been received

        button.html('<i class="fa fa-times"></i> ' + config.labels.copyFailed);
        setTimeout(function() {
            button.html(originalHtml);
        }, 2000);
    }

    /**
     * Send a message
     */
    function sendMessage() {
        // Check for IME composition
        if (elements.chatInput.data('composing')) {
            return;
        }

// handlers:
//
// - updates request context with `logger.ReqInfo` and api name based on the
// name of the function handler passed (this handler must be a method of
// `adminAPIHandlers`).
//
// - sets up call to send AuditLog
//
// While this is a middleware function (i.e. it takes a handler function and
// returns one), due to flags being passed based on required conditions, it is
// done per-"handler function registration" in the router.

		reqInfo := (&logger.ReqInfo{}).AppendTags("peerAddress", thisAddr.String())
		ctx := logger.SetReqInfo(ctx, reqInfo)
		bugLogIf(ctx, err)
		return profilingDataFound
	}

	profilingDataFound = true

	// Send profiling data to zip as file
	for typ, data := range data {
		err := embedFileInZip(zipWriter, fmt.Sprintf("profile-%s-%s", thisAddr, typ), data, 0o600)
		internalLogIf(ctx, err)
	}

	return profilingDataFound

    call: Call,
    request: Request,
  ) {
  }

  /**
   * Invoked just prior to sending a request body.  Will only be invoked for request allowing and
   * having a request body to send.
   *
   * The connection is implicit, and will generally relate to the last [connectionAcquired] event.
   *
   * This can be invoked more than 1 time for a single [Call]. For example, if the response to the

    assertThat(cookie.matches("http://www.example.com".toHttpUrl())).isTrue()
    assertThat(cookie.matches("http://square.com".toHttpUrl())).isFalse()
  }

  /** Ignore the entire attribute if the domain ends with `.`.  */
  @Test fun domainIgnoredWithTrailingDot() {
    val cookie = parse(url, "a=b; domain=example.com.")
    assertThat(cookie!!.matches("http://example.com".toHttpUrl())).isTrue()

    testRotate(new double[] {1}, 1, 0, 1, new double[] {1});
    testRotate(new double[] {1}, 1, 1, 1, new double[] {1});

    // Rotate the central 5 elements, leaving the ends as-is
    testRotate(new double[] {0, 1, 2, 3, 4, 5, 6}, -6, 1, 6, new double[] {0, 2, 3, 4, 5, 1, 6});
    testRotate(new double[] {0, 1, 2, 3, 4, 5, 6}, -1, 1, 6, new double[] {0, 2, 3, 4, 5, 1, 6});

		{[]byte(`<FilterRule><Name></Name><Value></Value></FilterRule>`), nil, true},
		{[]byte(`<FilterRule><Name>Prefix</Name><Value>Hello/世界</Value></FilterRule>`), nil, true},
		{[]byte(`<FilterRule><Name>ends</Name><Value>foo/bar</Value></FilterRule>`), nil, true},
		{[]byte(`<FilterRule><Name>prefix</Name><Value>Hello/世界</Value></FilterRule>`), &FilterRule{"prefix", "Hello/世界"}, false},