MavenArtifact(String repositoryUrl, Resource resource) {
        if (repositoryUrl == null) {
            this.repositoryUrl = "";
        } else if (!repositoryUrl.endsWith("/") && !repositoryUrl.isEmpty()) {
            this.repositoryUrl = repositoryUrl + '/';
        } else {
            this.repositoryUrl = repositoryUrl;
        }
        this.resource = resource;

import org.apache.maven.api.cli.cisupport.CIInfo;

public class CIDetectorHelperRunner {
    public static void main(String[] args) {
        List<CIInfo> detect = CIDetectorHelper.detectCI();
        if (detect.isEmpty()) {
            System.out.print("NONE;");
        } else {
            detect.forEach(d -> System.out.print(d.name() + (d.isVerbose() ? "+VERBOSE" : "") + ";"));
        }
    }

          }
        }

        val becameIdle =
          (finishedCall != null || finishedAsyncCall != null) &&
            (executorIsShutdown || runningAsyncCalls.isEmpty()) &&
            runningSyncCalls.isEmpty()
        val idleCallbackToRun = if (becameIdle) idleCallback else null

        if (executorIsShutdown) {
          return@synchronized Effects(
            callsToExecute =

    public ImmutableBiMap<K, V> build() {
      return buildOrThrow();
    }

    @Override
    public ImmutableBiMap<K, V> buildOrThrow() {
      ImmutableMap<K, V> map = super.buildOrThrow();
      if (map.isEmpty()) {
        return of();
      }
      return new RegularImmutableBiMap<K, V>(super.buildOrThrow());
    }

    @Override
    ImmutableBiMap<K, V> buildJdkBacked() {
      return build();
    }

            return;
        }

        if (value instanceof Entity) {
            data.register(key, BeanUtil.copyBeanToNewMap(value));
        } else {
            if (value instanceof final Collection<?> coll && !coll.isEmpty()) {
                // care performance for List that the most frequent pattern
                final Object first = coll instanceof List<?> ? ((List<?>) coll).get(0) : coll.iterator().next();

        while (lines.hasNext()) {
            String line = lines.next();
            if (end.matcher(line).matches()) {
                return;
            }
            if (line.isEmpty()) {
                continue;
            }
            if (false == line.startsWith(leadingSpaces)) {
                log.accept(lines.lastLineNumber, "snippet line should start with [" + leadingSpaces + "]");

        multimap.asMap().entrySet(), immutableEntry(sampleKey, sampleValueAsCollection));

    // Test #values()

    assertMultimapRemainsUnmodified(multimap, originalEntries);
    if (!multimap.isEmpty()) {
      Collection<V> values = multimap.asMap().entrySet().iterator().next().getValue();

      assertCollectionIsUnmodifiable(values, sampleValue);
    }

    // Test #entries()

        });
    }

    public void start(final Map<String, Object> params) {
        ComponentUtil.getJobManager().findJobByUniqueOf(LaJobUnique.of(getId())).ifPresent(job -> {
            if (params != null && !params.isEmpty()) {
                job.launchNow(op -> {
                    params.forEach(op::param);
                });
            } else {
                job.launchNow();
            }
        }).orElse(() -> {

              .copy(fileName = storyResourceName)
          result.add(story)
          i++
        }
      } finally {
        storyInputStream.close()
      }
    }

    if (result.isEmpty()) {
      // missing files
      result.add(Story.MISSING)
    }

    return result
  }

    /**
     * Reads all stories in the folders provided, asserts if no story found.
     */
    @JvmStatic
    protected fun createStories(interopTests: Array<String>): List<Any> {
      if (interopTests.isEmpty()) return listOf<Any>(Story.MISSING)

      val result = mutableListOf<Any>()
      for (interopTestName in interopTests) {
        val stories = HpackJsonUtil.readStories(interopTestName)
        result.addAll(stories)