List<ReportSet> src = source.getReportSets();
        if (!src.isEmpty()) {
            List<ReportSet> tgt = target.getReportSets();
            Map<Object, ReportSet> merged = new LinkedHashMap<>((src.size() + tgt.size()) * 2);

            for (ReportSet rset : src) {

                    plugin.setVersion(val);
                }
                // ReportSets
                for (ReportSet reportSet : plugin.getReportSets()) {
                    visit(reportSet);
                }
            }
        }

        private void visit(ReportSet reportSet) {
            if (reportSet != null) {
                String org, val;
                // Inherited

            }
        }
        return false;
    }

    /**
     * Returns total count of problems reported.
     */
    default int totalProblemsReported() {
        return problemsReportedFor(BuilderProblem.Severity.values());
    }

    /**
     * Returns count of problems reported for given severities.
     *
     * @param severities the severity levels to count problems for

            if (validationReportLevel == ValidationReportLevel.VERBOSE) {
                logger.warn(
                        "Fix reported issues by adjusting plugin configuration or by upgrading above listed plugins. If no upgrade available, please notify plugin maintainers about reported issues.");
            }
            logger.warn(

        // Act
        int available = stream.available();

        // Assert
        assertEquals(7, available, "Should return available bytes reported by server");

        // Interactions: ensure open, use tree, send IOCTL and close resources
        InOrder inOrder = inOrder(handle, fd, tree);
        inOrder.verify(handle, times(1)).ensureOpen();

   * href="http://gee.cs.oswego.edu/dl/html/StreamParallelGuidance.html">efficiently splittable</a>
   * if and only if {@code stream} was efficiently splittable and its underlying spliterator
   * reported {@link Spliterator#SUBSIZED}. This is generally the case if the underlying stream
   * comes from a data structure supporting efficient indexed random access, typically an array or
   * list.
   *

      for (String message : expectedMessages) {
        assertThat(expected).hasMessageThat().contains(message);
      }
      return;
    }
    fail("expected failure not reported");
  }

  private class ForwardingRunnable implements Runnable {

    private final Runnable runnable;

    ForwardingRunnable(Runnable runnable) {
      this.runnable = runnable;
    }

   * href="http://gee.cs.oswego.edu/dl/html/StreamParallelGuidance.html">efficiently splittable</a>
   * if and only if {@code stream} was efficiently splittable and its underlying spliterator
   * reported {@link Spliterator#SUBSIZED}. This is generally the case if the underlying stream
   * comes from a data structure supporting efficient indexed random access, typically an array or
   * list.
   *

  val oldName = currentThread.name
  currentThread.name = name
  try {
    block()
  } finally {
    currentThread.name = oldName
  }
}

/** Returns the Content-Length as reported by the response headers. */
internal fun Response.headersContentLength(): Long = headers["Content-Length"]?.toLongOrDefault(-1L) ?: -1L

/** Returns an immutable wrap of this. */
@Suppress("NOTHING_TO_INLINE")

        resp.command = ServerMessageBlock.SMB_COM_NT_CREATE_ANDX;
        resp.isExtended = true;

        byte[] buf = new byte[256];
        buf[33] = 34; // baseline wordCount reported by server
        buf[34] = (byte) 0xFF; // no further andx
        // byteCount at 33 + 1 + 34*2 = 102
        ServerMessageBlock.writeInt2(0, buf, 102);

        int n = resp.decode(buf, 0);