Preconditions.checkArgument(pattern != null && !pattern.isEmpty(), "pattern must not be null or empty");
        return withPattern(Pattern.compile(pattern), 1);
    }

    public static ExpectedDeprecationWarning withMultiLinePattern(String pattern, int numLines) {
        Preconditions.checkArgument(pattern != null && !pattern.isEmpty(), "pattern must not be null or empty");

    Optional<Object> getOptional() {
      if (extras.isEmpty()) {
        return Optional.ofNullable(element);
      } else {
        throw multiples(false);
      }
    }

    Object getElement() {
      if (element == null) {
        throw new NoSuchElementException();
      } else if (extras.isEmpty()) {
        return element;
      } else {
        throw multiples(false);

        return evaluateAtConfigurationTime(() -> provide(credentialsType, identity.get()).get());
    }

    @Override
    public void graphPopulated(TaskExecutionGraph graph) {
        if (!missingProviderErrors.isEmpty()) {
            throw new ProjectConfigurationException("Credentials required for this build could not be resolved.",
                missingProviderErrors.stream().map(MissingValueException::new).collect(Collectors.toList()));

        }
    }

    public void validate() {
        if (variants.isEmpty()) {
            failWith("This publication must publish at least one variant");
        }
        checkVariantDependencyVersions();
        if (!errors.isEmpty()) {
            TreeFormatter formatter = new TreeFormatter();
            formatter.node("Invalid publication '" + publicationName + "'");

    if (expectedLines.isEmpty()) {
      assertNull(source.readFirstLine());
    } else {
      assertEquals(expectedLines.get(0), source.readFirstLine());
    }
  }

  public void testReadLines_toList() throws IOException {
    assertExpectedLines(source.readLines());
  }

  public void testIsEmpty() throws IOException {
    assertEquals(expected.isEmpty(), source.isEmpty());
  }

            while (state != State.Stopped && queue.isEmpty()) {
                try {
                    condition.await();
                } catch (InterruptedException e) {
                    interrupted = true;
                }
            }
            if (interrupted) {
                Thread.currentThread().interrupt();
            }
            if (!queue.isEmpty()) {
                T message = queue.remove();

            if (items.size() == 1) {
                return factory.anyOf(left, factory.moduleId(items.iterator().next()));
            }
            if (items.isEmpty()) {
                return left;
            }
            if (items.size() != ids.getModuleIds().size()) {
                return factory.anyOf(left, factory.moduleIdSet(items));
            }
        }

        String max = ConfigurationState.INSTANCE.getRangeSetting().getMaxVersion();
        return (min.compareTo(current) <= 0 || min.isEmpty()) && (max.compareTo(current) >= 0 || max.isEmpty());
    }

     * and their subtypes that live in the `org.gradle.` package.
     *
     * TODO: Rename to getInstrumentedSuperTypes();
     */
    Set<String> getSuperTypes(String type);

    boolean isEmpty();

    static InstrumentationTypeRegistry empty() {
        return EMPTY;
    }

    class EmptyInstrumentationTypeRegistry implements InstrumentationTypeRegistry {
        @Override

        callSiteStack.push(entryPoint);
        return entryPoint;
    }

    @Override
    public void leaveCall(EntryPointCallSite entryPoint) {
        if (callSiteStack.isEmpty()) {
            throwMismatchedLeaveCallException(entryPoint);
        }
        EntryPointCallSite top = callSiteStack.peek();
        if (top != entryPoint) {
            throwMismatchedLeaveCallException(entryPoint);