}
			continue
		} else {
			if !test.ok {
				t.Fatalf("SetComment: unexpected success, want error")
			}
		}

		if err := w.Close(); test.ok == (err != nil) {
			t.Fatal(err)
		}

		if w.closed != test.ok {
			t.Fatalf("Writer.closed: got %v, want %v", w.closed, test.ok)
		}

		// skip read test in failure cases
		if !test.ok {
			continue
		}

		// read it back

        this.onRequestStart = socketEffect
      }

    /**
     * Process the response without even attempting to reading the request body. For HTTP/2 this
     * will close the response stream after the response body or trailers. For HTTP/1 this will
     * close the socket after the response body or trailers.
     */
    public fun doNotReadRequestBody(): Builder =
      apply {
        doNotReadRequestBody = true

			bytesReturned := atomic.LoadInt64(&writer.bytesReturned)
			if !writer.write(newProgressMessage(bytesScanned, bytesProcessed, bytesReturned)) {
				quitFlag = true
			}
		}
	}
	close(writer.doneCh)

	recordStagingTicker.Stop()
	keepAliveTicker.Stop()
	if progressTicker != nil {
		progressTicker.Stop()
	}

	// Whatever drain the payloadCh to prevent from memory leaking.

	<div class="offcanvas-header">
		<h5 class="offcanvas-title" id="facetOffcanvasLabel"><la:message key="labels.facet_filter_button" /></h5>
		<button type="button" class="btn-close" data-bs-dismiss="offcanvas" aria-label="Close"></button>
	</div>
	<div class="offcanvas-body">
		<c:forEach var="fieldData" items="${facetResponse.fieldList}">
			<c:if test="${fieldData.name == 'label' && fieldData.valueCountMap.size() > 0}">

              return read == 0 ? -1 : read;
            }
            buf[i] = (byte) b;
          }
          return i - off;
        }

        @Override
        public void close() throws IOException {
          reader.close();
        }
      };
    }

    @Override
    public BaseEncoding omitPadding() {
      return (paddingChar == null) ? this : newInstance(alphabet, null);
    }

        this.eventQueue = new ArrayBlockingQueue<>(queueSize);
        this.closed = new AtomicBoolean(false);
        this.updater = new Thread(this::feedConsumer, "simplex-transfer-listener");
        updater.setDaemon(true);
        updater.start();
    }

    @Override
    public void close() {
        if (closed.compareAndSet(false, true)) {
            updater.interrupt();
        }
    }

            log.warn("Error during witness client shutdown", e);
        }
        
        // Shutdown scheduler
        scheduler.shutdown();
        
        // Close RPC client
        if (rpcClient != null) {
            rpcClient.close();
        }
    }
}
```

### 4.4 Witness RPC Client
```java
package jcifs.internal.witness;

import jcifs.dcerpc.*;
import jcifs.dcerpc.rpc.*;

    class SamrCloseHandleTests {

        @Test
        @DisplayName("Should construct with correct opnum")
        void testConstructorAndOpnum() {
            // When: Creating close handle message
            samr.SamrCloseHandle message = new samr.SamrCloseHandle(mockPolicyHandle);

            // Then: Should have correct opnum and handle
            assertEquals(0x01, message.getOpnum());

 *  Fix: Improve recovery from failed routes.
 *  Fix: Accommodate tunneling proxies that close the connection after an auth
    challenge.
 *  Fix: Use the proxy authenticator when authenticating HTTP proxies. This
    regression was introduced in OkHttp 3.0.
 *  Fix: Fail fast if network interceptors transform the response body such that
    closing it doesn't also close the underlying stream. We had a bug where

                try {
                    handler.processResource(entryName.substring(pos), is);
                } finally {
                    CloseableUtil.close(is);
                }
            }
        }
    }

    /**
     * Traverses resources contained in a ZIP file input stream.
     *
     * @param zipInputStream