GeneralRange<T> result = reverse;
    if (result == null) {
      result =
          new GeneralRange<>(
              reverseComparator(comparator),
              hasUpperBound,
              getUpperEndpoint(),
              getUpperBoundType(),
              hasLowerBound,
              getLowerEndpoint(),
              getLowerBoundType());
      result.reverse = this;

     */
    @Nonnull
    default Stream<P> problems() {
        Stream<P> result = Stream.empty();
        for (BuilderProblem.Severity severity : BuilderProblem.Severity.values()) {
            result = Stream.concat(result, problems(severity));
        }
        return result;
    }

    /**

        NegTokenTarg roundTrip = new NegTokenTarg(bytes);

        // Assert – all getters match the original values
        assertEquals(NegTokenTarg.ACCEPT_COMPLETED, roundTrip.getResult(), "result should roundtrip");
        assertEquals(mech, roundTrip.getMechanism(), "mechanism should roundtrip");
        assertArrayEquals(tokenArray, roundTrip.getMechanismToken(), "mechanism token should roundtrip");

    private final DependencyResolutionResult dependencyResolutionResult;

    /**
     * Creates a new result with the specified contents.
     *
     * @param project The project that was built, may be {@code null}.
     * @param problems The problems that were encountered, may be {@code null}.
     * @param dependencyResolutionResult The result of the resolution for the project dependencies, may be {@code null}.
     */
    DefaultProjectBuildingResult(

      }
    }

  private fun nameToFirstIndex(): Map<ByteString, Int> {
    val result = LinkedHashMap<ByteString, Int>(STATIC_HEADER_TABLE.size, 1.0F)
    for (i in STATIC_HEADER_TABLE.indices) {
      if (!result.containsKey(STATIC_HEADER_TABLE[i].name)) {
        result[STATIC_HEADER_TABLE[i].name] = i
      }
    }
    return result.unmodifiable()
  }

  class Writer
    @JvmOverloads
    constructor(

      if (initialBytes == null) {
        return checkNotNull(bytes);
      } else {
        byte[] result = new byte[initialBytes.length + bytes.length];
        System.arraycopy(initialBytes, 0, result, 0, initialBytes.length);
        System.arraycopy(bytes, 0, result, initialBytes.length, bytes.length);
        return result;
      }
    }

    @Override
    public byte[] getSinkContents() throws IOException {

    }
  }

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

  public abstract static class TestShortListGenerator implements TestListGenerator<Short> {
    @Override

    }
  }

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

  public abstract static class TestLongListGenerator implements TestListGenerator<Long> {
    @Override

          expectedThrowable
              + " is not yet supported by ReflectionFreeAssertThrows. Add an entry for it in the"
              + " map in that class.");
    }
    Object result;
    try {
      result = supplier.get();
    } catch (Throwable t) {
      if (predicate.apply(t)) {
        // We are careful to set up INSTANCE_OF to match each Predicate to its target Class.
        @SuppressWarnings("unchecked")

        result.setEffectiveModel(resultModel);

        for (ModelData currentData : lineage) {
            String modelId = (currentData != superData) ? currentData.getId() : "";

            result.addModelId(modelId);
            result.setActivePomProfiles(modelId, currentData.getActiveProfiles());
            result.setRawModel(modelId, currentData.getRawModel());
        }