*/
  public static boolean[] concat(boolean[]... arrays) {
    long length = 0;
    for (boolean[] array : arrays) {
      length += array.length;
    }
    boolean[] result = new boolean[checkNoOverflow(length)];
    int pos = 0;
    for (boolean[] array : arrays) {
      System.arraycopy(array, 0, result, pos, array.length);
      pos += array.length;
    }
    return result;
  }

    assertEquals(expected.length(), reader.skip(Long.MAX_VALUE));
    assertFullyRead(reader);

    // skip 5 and read the rest
    if (expected.length() > 5) {
      reader = new CharSequenceReader(charSequence);
      assertEquals(5, reader.skip(5));

      buf = new char[expected.length() - 5];
      assertEquals(buf.length, reader.read(buf, 0, buf.length));

    }

    /**
     * Returns the length of data in the buffer.
     *
     * @return the data length
     */
    public int getLength() {
        return deferred.length;
    }

    /**
     * Sets the length of data in the buffer.
     *
     * @param length the new data length
     */
    public void setLength(final int length) {
        deferred.length = length;
    }

    /**

        HMACT64 clonedHmac = (HMACT64) originalHmac.clone();

        assertNotNull(clonedHmac);
        assertNotSame(originalHmac, clonedHmac);

        // Both should produce the same result when given the same remaining data
        originalHmac.engineUpdate(TEST_DATA, TEST_DATA.length / 2, TEST_DATA.length - TEST_DATA.length / 2);

      return asList(all).subList(2, elements.length + 2);
    }
  }

  private static Double[] concat(Double[] left, Double[] right) {
    Double[] result = new Double[left.length + right.length];
    System.arraycopy(left, 0, result, 0, left.length);
    System.arraycopy(right, 0, result, left.length, right.length);
    return result;
  }

        // Combine all data
        int totalLength = avFlagsData.length + avTimestampData.length + avTargetNameData.length + eolData.length;
        byte[] fullData = new byte[totalLength];
        int pos = 0;
        System.arraycopy(avFlagsData, 0, fullData, pos, avFlagsData.length);
        pos += avFlagsData.length;
        System.arraycopy(avTimestampData, 0, fullData, pos, avTimestampData.length);
        pos += avTimestampData.length;

        final int result = copy(is, os);
        assertThat(result, is(srcBytes.length));
        assertThat(os.toByteArray(), is(srcBytes));
    }

    /**
     * @throws Exception
     */
    @Test
    public void testReaderToWriter() throws Exception {
        final int result = copy(reader, writer);
        assertThat(result, is(srcString.length()));
        assertThat(writer.toString(), is(srcString));
    }

    /**

            assertNull(mock.getName());
        }

        @Test
        @DisplayName("Negative length is allowed via mock")
        void negativeLength() {
            FileEntry mock = mock(FileEntry.class);
            when(mock.length()).thenReturn(-10L);
            assertEquals(-10L, mock.length());
        }
    }

    @ParameterizedTest(name = "getType returns {0}")

        if (blob != null) {
            System.arraycopy(blob, 0, dst, dstIndex, blob.length);
            dstIndex += blob.length;
        } else {
            System.arraycopy(lmHash, 0, dst, dstIndex, lmHash.length);
            dstIndex += lmHash.length;
            System.arraycopy(ntHash, 0, dst, dstIndex, ntHash.length);
            dstIndex += ntHash.length;

            dstIndex += writeString(accountName, dst, dstIndex);

    @Override
    public Entry<K, V>[] createArray(int length) {
      return generator.createArray(length);
    }

    @Override
    public Iterable<Entry<K, V>> order(List<Entry<K, V>> insertionOrder) {
      return generator.order(insertionOrder);
    }

    @SuppressWarnings("unchecked")
    @Override
    public K[] createKeyArray(int length) {
      return (K[]) new Object[length];
    }

    @SuppressWarnings("unchecked")