}
        return acceptOrReject(c, changes, Violation.error(c, " introduces internal or incubating interfaces"))
    }

    private Map<String, CtClass> collectImplementedInterfaces(CtClass c) {
        Map<String, CtClass> result = [:]
        collect(result, c)
        return result
    }

    private void collect(Map<String, CtClass> result, CtClass c) {
        c.interfaces.each { result.put(it.name, it) }

 */
@NullUnmarked
public final class HostSpecifierTest extends TestCase {

  private static final ImmutableList<String> GOOD_IPS =
      ImmutableList.of("1.2.3.4", "2001:db8::1", "[2001:db8::1]");

  private static final ImmutableList<String> BAD_IPS =
      ImmutableList.of("1.2.3", "2001:db8::1::::::0", "[2001:db8::1", "[::]:80");

  private static final ImmutableList<String> GOOD_DOMAINS =

    private List<String> blackList = new ArrayList<>();

    private Map<String, BuildFailure> buildFailuresByProject = new HashMap<>();

    private Map<String, Map<String, Map>> pluginContextsByProjectAndPluginKey = new HashMap<>();

    private String failureBehavior = FAIL_FAST;

    private final ProjectSorter sorter;

    private final Logger log = LoggerFactory.getLogger(getClass());

    private final DefaultPluginDependenciesResolver pluginDependenciesResolver;

    private final RepositorySystemSessionFactory repositorySystemSessionFactory;

    private final CoreExports coreExports;

    private final ClassWorld classWorld;

    private final ClassRealm parentRealm;

   */

  private static boolean hasConstructorUsableByGetChecked(
      Class<? extends Exception> exceptionClass) {
    try {
      Exception unused = newWithCause(exceptionClass, new Exception());
      return true;
    } catch (Throwable t) { // sneaky checked exception
      return false;
    }
  }

)

class StatisticsBasedPerformanceTestBucketProvider(
    private val model: CIBuildModel,
    performanceTestDurationsJson: File,
    performanceTestsCiJson: File,
) : PerformanceTestBucketProvider {
    private val objectMapper = ObjectMapper().registerKotlinModule()
    private val performanceTestConfigurations = readPerformanceTestConfigurations(performanceTestsCiJson)

    private final Logger log = LoggerFactory.getLogger(getClass());

    private final DefaultPluginDependenciesResolver pluginDependenciesResolver;

    private final RepositorySystemSessionFactory repositorySystemSessionFactory;

    private final CoreExports coreExports;

    private final ClassWorld classWorld;

    private final ClassRealm parentRealm;

        }

        private static class DefaultModelBuilderRequest extends BaseRequest<Session> implements ModelBuilderRequest {
            private final RequestType requestType;
            private final boolean locationTracking;
            private final boolean recursive;
            private final ModelSource source;
            private final Collection<Profile> profiles;

  private PairedStatsAccumulator manyValuesAccumulator;
  private PairedStatsAccumulator manyValuesAccumulatorByAddAllPartitionedPairedStats;
  private PairedStatsAccumulator horizontalValuesAccumulator;
  private PairedStatsAccumulator horizontalValuesAccumulatorByAddAllPartitionedPairedStats;
  private PairedStatsAccumulator verticalValuesAccumulator;
  private PairedStatsAccumulator verticalValuesAccumulatorByAddAllPartitionedPairedStats;

```
2018/11/21 10:16:18 wrote public.crt
2018/11/21 10:16:18 wrote private.key
```

### 3.2 Use OpenSSL to Generate a Certificate

Use one of the following methods to generate a certificate using `openssl`:

* 3.2.1 [Generate a private key with ECDSA](#generate-private-key-with-ecdsa)
* 3.2.2 [Generate a private key with RSA](#generate-private-key-with-rsa)