}

    boolean logoff(boolean inError, boolean inUse) {
        boolean wasInUse = false;
        try (SmbTransportImpl trans = getTransport()) {
            synchronized (trans) {
                if (!this.connectionState.compareAndSet(2, 3)) { // not-connected
                    return false;
                }

                if (log.isDebugEnabled()) {

    }
    return numOfBytesRead;
  }

  /**
   * mark() is not supported for HashingInputStream
   *
   * @return {@code false} always
   */
  @Override
  public boolean markSupported() {
    return false;
  }

  /** mark() is not supported for HashingInputStream */
  @Override
  public void mark(int readlimit) {}

  /**

    /**
     * Check if the personality is "maven3".
     */
    public static boolean mavenMaven3Personality(@Nullable Map<String, ?> userProperties) {
        return doGet(userProperties, Constants.MAVEN_MAVEN3_PERSONALITY, false);
    }

    /**
     * Check if the consumer POM feature is active.
     */
    public static boolean consumerPom(@Nullable Map<String, ?> userProperties) {

     * 4. We expect the client thread's interrupt state to be false.
     * 5. The client thread again makes a blocking call to get().
     * 6. Now the result becomes available.
     * 7. We expect get() to return this result.
     * 8. We expect the test thread's interrupt state to be false.
     */
    InterruptionUtil.requestInterruptIn(200, MILLISECONDS);

    assertFalse(Thread.interrupted());

      gradleProperties[Constants.BUNDLE_VERSION] = bundleVersion.get()
    }

    // Do not capture 'task' in gradleProperties to avoid serialization issues

    try {
      Builder(Processor(gradleProperties, false)).use { builder ->
        val temporaryBndFile = File.createTempFile("bnd", ".bnd", temporaryDir)
        IO.writer(temporaryBndFile).use { writer ->
          val bndFileVal = bndfile.asFile.getOrNull()

        MavenContext result = residentContext.computeIfAbsent(
                "resident",
                k -> new MavenContext(invokerRequest, false, (MavenOptions)
                        invokerRequest.options().orElse(null)));
        return copyIfDifferent(result, invokerRequest);
    }

      ByteSourceFactory sliced = SourceSinkFactories.asSlicedByteSourceFactory(factory, off, len);
      suite.addTest(suiteForBytes(sliced, bytes, name + ".slice[long, long]", desc, false));

      // test a slice() of the ByteSource starting at a random offset with a length of
      // Long.MAX_VALUE
      ByteSourceFactory slicedLongMaxValue =

	}
	keys = store.List()
	if len(keys) != 1 {
		t.Fatalf("expected len(store.List())=1; but got %v", len(keys))
	}
	key := keys[0]
	if !key.Compress {
		t.Fatal("expected key.Compress=true; but got false")
	}
	if key.ItemCount != int(limit) {
		t.Fatalf("expected key.ItemCount=%d; but got %v", limit, key.ItemCount)
	}
	items, err := store.GetMultiple(key)
	if err != nil {

    body.close()
  }

  /** An HTTP request body. */
  private inner class KnownLengthSink : Sink {
    private val timeout = ForwardingTimeout(socket.sink.timeout())
    private var closed: Boolean = false

    override fun timeout(): Timeout = timeout

    override fun write(
      source: Buffer,
      byteCount: Long,
    ) {
      check(!closed) { "closed" }

			sizeFilter: BatchJobSizeFilter{
				UpperBound: 10 << 20,
				LowerBound: 1 << 20,
			},
			want: false,
		},
		{
			// 11MiB > 10 MiB -> out of range from right
			objSize: 11 << 20,
			sizeFilter: BatchJobSizeFilter{
				UpperBound: 10 << 20,
				LowerBound: 1 << 20,
			},
			want: false,
		},
		{
			//  2MiB < 10MiB -> in range
			objSize: 2 << 20,
			sizeFilter: BatchJobSizeFilter{