total = settings.size();
            return this;
        }

        /**
         * Sets the total number of configuration settings.
         * @param total The total number of configuration settings.
         * @return The ApiConfigsResponse instance.
         */
        public ApiConfigsResponse<T> total(final long total) {
            this.total = total;
            return this;

    }
    checkPositionIndexes(off, off + len, b.length);
    int total = 0;
    while (total < len) {
      int result = in.read(b, off + total, len - total);
      if (result == -1) {
        break;
      }
      total += result;
    }
    return total;
  }

  /** Compares the contents of the two {@link InputStream}s for equality. */

        String details = testableJob.testFormatDetails(events);

        assertNotNull(details);
        assertTrue(details.contains("Total: 1 event(s)"));
        assertTrue(details.contains("ERROR"));
        assertTrue(details.contains("org.codelibs.fess.TestClass"));
        assertTrue(details.contains("Something went wrong"));
    }

    @Test

/*
 [Log Notification]
*/
subject: [FESS] /*pmb.level*/ Log Alert: /*pmb.hostname*/
>>>
--- Server Info ---
Host Name: /*pmb.hostname:orElse('Unknown')*/

--- Log Summary ---
Level: /*pmb.level*/
Total: /*pmb.count*/ event(s) in the last /*pmb.interval*/ seconds

--- Log Details ---
/*pmb.details*/

        assertTrue(doneLatch.await(30, TimeUnit.SECONDS));
        executor.shutdown();

        // Drain remaining
        totalDrained.addAndGet(helper.drainAll().size());

        // Total drained should be <= total offered (some may be dropped at capacity)
        int totalOffered = numThreads * eventsPerThread;
        assertTrue(totalDrained.get() > 0);
        assertTrue(totalDrained.get() <= totalOffered);
    }

    for (Construction<T> pathway : constructions) {
      smallCounter.zero();
      pathway.create(haveSameHashesSmall);
      long smallOps = smallCounter.total();

      largeCounter.zero();
      pathway.create(haveSameHashesLarge);
      long largeOps = largeCounter.total();

      double ratio = (double) largeOps / smallOps;
      assertWithMessage(

   * c}}.
   *
   * @param arrays zero or more {@code float} 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 float[] concat(float[]... arrays) {
    long length = 0;
    for (float[] array : arrays) {

   * c}}.
   *
   * @param arrays zero or more {@code double} 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 double[] concat(double[]... arrays) {
    long length = 0;
    for (double[] array : arrays) {

        final int totalCount = events.size();
        final int displayCount = Math.min(totalCount, maxDisplayEvents);
        final StringBuilder sb = new StringBuilder();
        sb.append("Total: ").append(totalCount).append(" event(s)");
        if (totalCount > displayCount) {
            sb.append(" (showing ").append(displayCount).append(')');
        }
        sb.append("\n\n");

    /** Number of results per page */
    public String pageSize;

    /** Current page number for pagination */
    public String currentPageNumber;

    /** Total number of records found */
    public String allRecordCount;

    /** Total number of pages for pagination */
    public String allPageCount;

    /** Flag indicating if there is a next page */
    public boolean existNextPage;