.setShowErrors(true)
                .setPluginGroups(Arrays.asList("org.apache.maven.plugins"))
                .setLocalRepository(getLocalRepository())
                .setRemoteRepositories(getRemoteRepositories())
                .setPluginArtifactRepositories(getPluginArtifactRepositories())
                .setGoals(Arrays.asList("package"));

        if (pom != null) {

                    if (StringUtil.isBlank(s)) {
                        return false;
                    }
                    if (Arrays.stream(webProtocols).anyMatch(p -> s.startsWith(p))) {
                        return web;
                    }
                    if (Arrays.stream(fileProtocols).anyMatch(p -> s.startsWith(p))) {
                        return file;
                    }
                    return true;

    File asciiFile = getTestFile("ascii.txt");
    File i18nFile = getTestFile("i18n.txt");
    assertTrue(Arrays.equals(ASCII.getBytes(US_ASCII), Files.toByteArray(asciiFile)));
    assertTrue(Arrays.equals(I18N.getBytes(UTF_8), Files.toByteArray(i18nFile)));
    assertTrue(Arrays.equals(I18N.getBytes(UTF_8), Files.asByteSource(i18nFile).read()));
  }

  @Test
  fun responseBodyFailHttp1OverHttps() {
    enableTlsWithTunnel()
    server.protocols = Arrays.asList(Protocol.HTTP_1_1)
    responseBodyFail(Protocol.HTTP_1_1)
  }

  @Test
  fun responseBodyFailHttp2OverHttps() {
    platform.assumeHttp2Support()
    enableTlsWithTunnel()
    server.protocols = Arrays.asList(Protocol.HTTP_2, Protocol.HTTP_1_1)
    responseBodyFail(Protocol.HTTP_2)
  }

        assertArrayEquals(new byte[] { 0x05, 0x06, 0x07, 0x08 }, responseBuffer);
    }

    @Test
    @DisplayName("Test with empty buffers")
    void testWithEmptyBuffers() {
        // Test with empty byte arrays
        byte[] emptyRequestBuffer = new byte[0];
        byte[] emptyResponseBuffer = new byte[0];

   *
   * <p>The returned comparator is inconsistent with {@link Object#equals(Object)} (since arrays
   * support only identity equality), but it is consistent with {@link Arrays#equals(int[], int[])}.
   *
   * <p><b>Java 9+ users:</b> Use {@link Arrays#compareUnsigned(int[], int[])
   * Arrays::compareUnsigned}.
   */
  public static Comparator<int[]> lexicographicalComparator() {

 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
package org.apache.maven.artifact.resolver;

import java.util.Arrays;
import java.util.List;

import org.junit.jupiter.api.Test;

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

/**
 * Test the artifact resolution exception message
 *
 */

        rpc.sid_t s = new rpc.sid_t();
        s.revision = revision;
        s.sub_authority_count = (byte) subs.length;
        s.identifier_authority = Arrays.copyOf(identAuth, 6);
        s.sub_authority = Arrays.copyOf(subs, subs.length);
        return s;
    }

    @Nested
    @DisplayName("Basic Constructor and Utility Tests")
    class BasicTests {

        @Test

 * either express or implied. See the License for the specific language
 * governing permissions and limitations under the License.
 */
package org.codelibs.fess.opensearch.config.exentity;

import java.util.Arrays;

import org.codelibs.fess.opensearch.config.bsentity.BsRelatedQuery;

/**
 * @author ESFlute (using FreeGen)
 */
public class RelatedQuery extends BsRelatedQuery {

  private static void testSortDescending(byte[] input, byte[] expectedOutput) {
    input = Arrays.copyOf(input, input.length);
    SignedBytes.sortDescending(input);
    assertThat(input).isEqualTo(expectedOutput);
  }

  private static void testSortDescending(
      byte[] input, int fromIndex, int toIndex, byte[] expectedOutput) {
    input = Arrays.copyOf(input, input.length);
    SignedBytes.sortDescending(input, fromIndex, toIndex);