* b, c}}.
   *
   * @param arrays zero or more {@code boolean} arrays
   * @return a single array containing all the values from the source arrays, in order
   * @throws IllegalArgumentException if the total number of elements in {@code arrays} does not fit
   *     in an {@code int}
   */
  public static boolean[] concat(boolean[]... arrays) {
    long length = 0;
    for (boolean[] array : arrays) {

     */
    public byte[] encrypt(final byte[] clearText) {

        final int length = clearText.length;

        if (length % 8 != 0) {
            // DES requires 8-byte blocks
            throw new IllegalArgumentException("Array must be a multiple of 8 bytes for DES encryption");
        }

        final byte[] cipherText = new byte[length];
        final int count = length / 8;

        for (int i = 0; i < count; i++) {

    return create(16);
  }

  /**
   * Constructs a new, empty bimap with the specified expected size.
   *
   * @param expectedSize the expected number of entries
   * @throws IllegalArgumentException if the specified expected size is negative
   */
  public static <K extends @Nullable Object, V extends @Nullable Object> HashBiMap<K, V> create(
      int expectedSize) {
    return new HashBiMap<>(expectedSize);

  @MapFeature.Require(SUPPORTS_PUT)
  @CollectionSize.Require(ZERO)
  public void testPutWithSameValueFails() {
    getMap().put(k0(), v0());
    assertThrows(IllegalArgumentException.class, () -> getMap().put(k1(), v0()));
    // verify that the bimap is unchanged
    expectAdded(e0());
  }

  @MapFeature.Require(SUPPORTS_PUT)
  @CollectionSize.Require(ZERO)

            // Assign a unique address to each buffer instance
            return bufferAddresses.computeIfAbsent(buffer, b -> addressCounter.getAndIncrement());
        } else {
            throw new IllegalArgumentException("Only direct ByteBuffers are supported for RDMA");
        }
    }

    /**
     * Convert RDMA access flags to DiSNI flags
     *
     * @param access RDMA access flags

            subprojects = JsonBasedGradleSubprojectProvider(File("./subprojects.json")),
        )
    val testClassDataJson = File(System.getProperty("inputTestClassDataJson") ?: throw IllegalArgumentException("Input file not found!"))
    val generatedBucketsJson = File(System.getProperty("outputBucketSplitJson", "./test-buckets.json"))

    FunctionalTestBucketGenerator(model, testClassDataJson).generate(generatedBucketsJson)

     * <code>NbtAddress</code>.
     *
     * @param addr
     *            wrapped address
     */
    public UniAddress(final Object addr) {
        if (addr == null) {
            throw new IllegalArgumentException();
        }
        this.addr = addr;
    }

    /**
     * Return the IP address of this address as a 32 bit integer.
     */

    @Override
    public int hashCode() {

                                        }
                                    }
                                }
                            } catch (IllegalArgumentException | IllegalAccessException e) {
                                throw new ModelInterpolationException(
                                        "Failed to interpolate field: " + field + " on class: " + cls.getName(), e);

    }

    /**
     * Test getRootCause() method (deprecated).
     */
    @Test
    void testGetRootCause() {
        Throwable cause = new IllegalArgumentException("Invalid argument.");
        DcerpcException exception = new DcerpcException("Error with cause.", cause);
        assertEquals(cause, exception.getRootCause(), "getRootCause() should return the original cause.");
    }

      "ResponseBodyEnd",
      "RequestBodyEnd",
      "ConnectionReleased",
      "CallEnd",
    )
  }

  @Test
  fun upgradeRequestMustNotHaveABody() {
    val e =
      assertFailsWith<IllegalArgumentException> {
        Request
          .Builder()
          .url(server.url("/"))
          .header("Connection", "upgrade")
          .post("Hello".toRequestBody())
          .build()
      }