@CanIgnoreReturnValue
  static int checkPositive(String role, int x) {
    if (x <= 0) {
      throw new IllegalArgumentException(role + " (" + x + ") must be > 0");
    }
    return x;
  }

  @CanIgnoreReturnValue
  static long checkPositive(String role, long x) {
    if (x <= 0) {
      throw new IllegalArgumentException(role + " (" + x + ") must be > 0");
    }
    return x;
  }

  @CanIgnoreReturnValue

                throw new CIFSException("Failed to decrypt MIC", e);
            }
        }

        final int expectSeq = this.verifySequence.getAndIncrement();
        if (expectSeq != seq) {
            throw new CIFSException(String.format("Invalid MIC sequence, expect %d have %d", expectSeq, seq));
        }

        final byte[] verify = new byte[8];
        System.arraycopy(mic, 4, verify, 0, 8);

  public final FluentIterable<T> preOrderTraversal(T root) {
    checkNotNull(root);
    return new FluentIterable<T>() {
      @Override
      public UnmodifiableIterator<T> iterator() {
        return preOrderIterator(root);
      }
    };
  }

  UnmodifiableIterator<T> preOrderIterator(T root) {
    return new PreOrderIterator(root);
  }

  private final class PreOrderIterator extends UnmodifiableIterator<T> {

        Map<String, ToolchainFactory> factories = new HashMap<>();
        factories.put("basic", toolchainFactoryBasicType);
        factories.put("rare", toolchainFactoryRareType);

        when(lookup.lookupMap(ToolchainFactory.class)).thenReturn(factories);
        when(lookup.lookupMap(org.apache.maven.toolchain.ToolchainFactory.class))
                .thenReturn(Map.of());

        Thread[] threads = new Thread[THREAD_COUNT];
        final boolean[] success = new boolean[THREAD_COUNT];

        for (int i = 0; i < THREAD_COUNT; i++) {
            final int index = i;
            threads[i] = new Thread(() -> {
                try {
                    // Each thread performs operations on the response
                    byte[] buffer = new byte[100];

        ArtifactMetadataSource mds = new ArtifactMetadataSource() {
            @Override
            public ResolutionGroup retrieve(
                    Artifact artifact,
                    ArtifactRepository localRepository,
                    List<ArtifactRepository> remoteRepositories) {
                Set<Artifact> dependencies = new HashSet<>();

        final int threadCount = 10;
        Thread[] threads = new Thread[threadCount];
        final boolean[] results = new boolean[threadCount];

        for (int i = 0; i < threadCount; i++) {
            final int index = i;
            threads[i] = new Thread(() -> {
                String thumbnailId = "concurrent-" + index;
                File outputFile = new File(tempDir.toFile(), "concurrent-" + index + ".png");

    Cache cache = new Cache(cacheDirectory, 1024 * 1024);
    cache.evictAll();

    client = new OkHttpClient.Builder()
        .cache(cache)
        .build();
  }

  public void run() throws Exception {
    for (int i = 0; i < 5; i++) {
      System.out.println("    Request: " + i);

      Request request = new Request.Builder()

                return new BigDecimal(new SimpleDateFormat(pattern).format(o));
            }
            return new BigDecimal(Long.toString(((java.util.Date) o).getTime()));
        } else if (o instanceof String) {
            final String s = (String) o;
            if (StringUtil.isEmpty(s)) {
                return null;
            }
            return normalize(new BigDecimal(s));
        } else {

        ArtifactFilter effectiveFilter = inheritedFilter;

        if (!dependency.getExclusions().isEmpty()) {
            effectiveFilter = new ExclusionArtifactFilter(dependency.getExclusions());

            if (inheritedFilter != null) {
                effectiveFilter = new AndArtifactFilter(Arrays.asList(inheritedFilter, effectiveFilter));
            }
        }

        return effectiveFilter;
    }