return RANDOM_SOURCE.nextBoolean() ? result : result.negate();
  }

  /**
   * Chooses a number in (-2^numBits, 2^numBits) at random, with density concentrated in numbers of
   * lower magnitude.
   */
  static BigInteger randomBigInteger(int numBits) {
    while (true) {
      if (RANDOM_SOURCE.nextBoolean()) {
        return randomNonNegativeBigInteger(numBits);
      }

type Error struct {
	Code    int    // The HTTP status code returned to the client
	APICode string // The API error code identifying the error
	Err     string // The error message returned to the client
	Cause   error  // Optional, lower level error cause.
}

func (e Error) Error() string {
	if e.Cause == nil {
		return e.Err
	}
	return fmt.Sprintf("%s: %v", e.Err, e.Cause)
}

func errKeyCreationFailed(err error) Error {
	return Error{

    }

    private val seenProjectsCount: Int
        get() = projectsWithNullAwayEnabled.size + projectsWithUncheckedDeps.size + projectsToEnableNullaway.size

    override fun close() {
        require(seenProjectsCount > 0) {
            "NullawayStatusService was created but no status tasks have run"
        }

        printResult {

        handle.sendrecv(rpc);
        if (rpc.retval != 0) {
            throw new SmbException(rpc.retval, false);
        }
        this.opened = true;
    }

    @Override
    public synchronized void close() throws IOException {
        if (this.opened) {
            this.opened = false;
            final MsrpcSamrCloseHandle rpc = new MsrpcSamrCloseHandle(this);
            this.handle.sendrecv(rpc);

        doExecute(session, mojoExecution, dependencyContext);
    }

    protected static class NoLock implements NoExceptionCloseable {
        public NoLock() {}

        @Override
        public void close() {}
    }

    /**
     * Aggregating mojo executions (possibly) modify all MavenProjects, including those that are currently in use

        super.setUp(testInfo);
    }

    @Override
    public void tearDown(final TestInfo testInfo) throws Exception {
        super.tearDown(testInfo);
        // close runner
        runner.close();
        // delete all files
        runner.clean();
    }

    @Test
    public void test_addIncludeUrlFilter_singleTx() {
        final String sessionId = "session1";

  private val routeB1 = factory.newRoute(addressB)
  private val addressC = factory.newAddress("c")
  private val routeC1 = factory.newRoute(addressC)

  @AfterEach fun tearDown() {
    factory.close()
    peer.close()
  }

  @Test fun connectionsEvictedWhenIdleLongEnough() {
    val pool = factory.newConnectionPool()
    val c1 = factory.newConnection(pool, routeA1, 50L)

  @Test fun readNameValueBlockDropsForbiddenHeadersHttp2() {
    val headerBlock =
      headersOf(
        ":status",
        "200 OK",
        ":version",
        "HTTP/1.1",
        "connection",
        "close",
      )
    val request = Request.Builder().url("http://square.com/").build()
    val response = readHttp2HeadersList(headerBlock, Protocol.HTTP_2).request(request).build()
    val headers = response.headers

 * It releases the tree ID and terminates access to the share.
 */
public class SmbComTreeDisconnect extends ServerMessageBlock {

    /**
     * Constructs a tree disconnect request to close a connection to a shared resource.
     *
     * @param config the configuration to use
     */
    public SmbComTreeDisconnect(final Configuration config) {
        super(config, SMB_COM_TREE_DISCONNECT);
    }

        return lookup;
    }

    @Override
    public Optional<ClassLoader> currentThreadClassLoader() {
        return Optional.of(plexusContainer.getContainerRealm());
    }

    @Override
    public void close() {
        try {
            plexusContainer.dispose();
        } finally {
            Thread.currentThread().setContextClassLoader(previousClassLoader);
        }
    }