try {
            URI relativeLocation = projectRootDir.toURI().relativize(file.toURI());
            return new URI("https://github.com/gradle/gradle/blob/" + commitId + "/" + relativeLocation);
        } catch (URISyntaxException e) {
            throw new RuntimeException(e);
        }
    }

    private static DokkaExtension getDokkaExtension(Project project) {

    }

    @Override
    final boolean isDone() {
      return CombinedFuture.this.isDone();
    }

    final void execute() {
      try {
        listenerExecutor.execute(this);
      } catch (RejectedExecutionException e) {
        CombinedFuture.this.setException(e);
      }
    }

    @Override
    final void afterRanInterruptiblySuccess(@ParametricNullness T result) {
      /*

            }

            pos += writeSecurityBufferContent(type1, pos, domOffOff, domain);
            pos += writeSecurityBufferContent(type1, pos, wsOffOff, workstation);
            return type1;
        } catch (final IOException ex) {
            throw new IllegalStateException(ex.getMessage());
        }
    }

    @Override
    public String toString() {

        try {
            assertNotNull(NetbiosName.class.getMethod("getName"));
            assertNotNull(NetbiosName.class.getMethod("getScope"));
            assertNotNull(NetbiosName.class.getMethod("getNameType"));
        } catch (NoSuchMethodException e) {
            fail("Method not found: " + e.getMessage());
        }
    }

    @Test
    @DisplayName("Should handle getName() method")
    void testGetName() {
        // Given

            out.write(buffer, 0, ssp0.writeWireFormat(buffer, 0));

            setSoTimeout(soTimeout);
            type = SessionServicePacket.readPacketType(in, buffer, 0);
        } catch (final IOException ioe) {
            close();
            throw ioe;
        }

        switch (type) {
        case SessionServicePacket.POSITIVE_SESSION_RESPONSE:
            if (LogStream.level > 2) {

            ArtifactResolutionResult result = repositorySystem.resolve(request);

            try {
                resolutionErrorHandler.throwErrors(request, result);
            } catch (MultipleArtifactsNotFoundException e) {

                Collection<Artifact> missing = new HashSet<>(e.getMissingArtifacts());

                for (Iterator<Artifact> it = missing.iterator(); it.hasNext(); ) {

                    // accessibility controls here.
                    f.setAccessible(true);
                    f.set(null, null);
                } catch (IllegalAccessException e) {
                    throw new RuntimeException(e);
                }
            });
        }

        public void setRuntimeJavaHome(File runtimeJavaHome) {

                            parentFile.mkdirs()
                            writeBytes(classWriter.toByteArray())
                        }
                    } catch (exception: Exception) {
                        throw ClassAnalysisException("Could not transform class from $file", exception)
                    }
                }
            }
        )
    }
}

      .matchesPredicate { it == null || it is RejectedExecutionException }
  }

  private fun sleep(delayMillis: Int) {
    try {
      Thread.sleep(delayMillis.toLong())
    } catch (e: InterruptedException) {
      Thread.currentThread().interrupt()
    }
  }

  private fun interruptLater(delayMillis: Int) {
    val toInterrupt = Thread.currentThread()
    val interruptingCow =

              + " is not yet supported by ReflectionFreeAssertThrows. Add an entry for it in the"
              + " map in that class.");
    }
    Object result;
    try {
      result = supplier.get();
    } catch (Throwable t) {
      if (predicate.apply(t)) {
        // We are careful to set up INSTANCE_OF to match each Predicate to its target Class.
        @SuppressWarnings("unchecked")
        T caught = (T) t;