}
    } catch (e: IllegalArgumentException) {
      if ("Jar does not have a symbolic name" in e.message!!) {
        println("Skipped non-OSGi dependency: ${file.name}")
        return
      }
      throw e
    }
  }

  companion object {
    val fileSystem = FileSystem.SYSTEM

    /** Each is the Bundle-SymbolicName of an OkHttp module's OSGi configuration.  */

    tester.testStaticMethods(RateLimiter.class, Visibility.PACKAGE);
    tester.testInstanceMethods(RateLimiter.create(5.0, stopwatch), Visibility.PACKAGE);
  }

  public void testVerySmallDoubleValues() throws Exception {
    RateLimiter rateLimiter = RateLimiter.create(Double.MIN_VALUE, stopwatch);
    assertTrue("Should acquire initial permit", rateLimiter.tryAcquire());

    tester.testStaticMethods(RateLimiter.class, Visibility.PACKAGE);
    tester.testInstanceMethods(RateLimiter.create(5.0, stopwatch), Visibility.PACKAGE);
  }

  public void testVerySmallDoubleValues() throws Exception {
    RateLimiter rateLimiter = RateLimiter.create(Double.MIN_VALUE, stopwatch);
    assertTrue("Should acquire initial permit", rateLimiter.tryAcquire());

                                writer.write(hit.getSourceAsString());
                                writer.write("\n");
                            } catch (final IOException e) {
                                throw new IORuntimeException(e);
                            }
                            return true;
                        });
                        writer.flush();
                    }
                });

  }

  @ListFeature.Require(absent = SUPPORTS_ADD_WITH_INDEX)
  public void testAddAllAtIndex_unsupportedNothing() {
    try {
      assertFalse(
          "addAll(n, nothing) should return false or throw",
          getList().addAll(0, emptyCollection()));
    } catch (UnsupportedOperationException tolerated) {
    }
    expectUnchanged();
  }

  @ListFeature.Require(SUPPORTS_ADD_WITH_INDEX)

                    + "/"
                    + jdk.getBuild()
                    + "/GPL/openjdk-[revision]_[module]-[classifier]_bin.[ext]";
            }
        } else {
            throw new GradleException("Unknown JDK vendor [" + jdk.getVendor() + "]");
        }

        // Define the repository if we haven't already
        if (repositories.findByName(repoName) == null) {

                    visitTree(classDetails, classesDir, jarOutputStream, visited)
                }
            }
        } catch (exception: Exception) {
            throw ClassAnalysisException("Could not write shaded Jar $jarFile", exception)
        }
    }

    private
    fun visitTree(
        classDetails: ClassDetails,
        classesDir: File,

                            .getPluginDescriptor()
                            .getLifecycleMappings()
                            .values()));
                } catch (Exception e) {
                    throw new RuntimeException("Unable to load plugin lifecycles", e);
                }
            }

            @Override
            public ClassLoader getClassLoader() {

    public static MavenOptions layerMavenOptions(Collection<MavenOptions> options) {
        List<MavenOptions> o = options.stream().filter(Objects::nonNull).toList();
        if (o.isEmpty()) {
            throw new IllegalArgumentException("No options specified (or all were null)");
        } else if (o.size() == 1) {
            return o.get(0);
        } else {
            return new LayeredMavenOptions<>(o);
        }
    }

     * @param maxClientFactorySize The maximum size.
     */
    public void setMaxClientFactorySize(final int maxClientFactorySize) {
        if (maxClientFactorySize <= 0) {
            throw new IllegalArgumentException("maxClientFactorySize must be positive.");
        }
        this.maxClientFactorySize = maxClientFactorySize;
    }