fileIdField.setAccessible(true);
        byte[] storedFileId = (byte[]) fileIdField.get(request);
        assertEquals(null, storedFileId);
    }

    @Test
    @DisplayName("setCloseFlags should update close flags")
    void testSetCloseFlags() throws Exception {
        int testFlags = 0x00000001; // SMB2_CLOSE_FLAG_POSTQUERY_ATTRIB
        request.setCloseFlags(testFlags);

    val source = response.body.source()
    while (!source.exhausted()) {
      out.write(source.buffer, source.buffer.size)
      out.flush()
    }

    response.body.close()
  } catch (e: IOException) {
    e.printStackTrace()
  } finally {
    close()
  }

        SocketException exception = new SocketException();
        exception.initCause(e);
        throw exception;
      }
    }

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

      MockResponse
        .Builder()
        .code(408)
        .addHeader("Connection", "Close")
        .body("You took too long!")
        .onResponseEnd(ShutdownConnection)
        .build(),
    )
    server.enqueue(
      MockResponse
        .Builder()
        .code(408)
        .addHeader("Connection", "Close")
        .body("You took too long!")
        .onResponseEnd(ShutdownConnection)

                                                    </h4>
                                                    <button type="button" class="close" data-dismiss="modal"
                                                            aria-label="Close">
                                                        <span aria-hidden="true">×</span>
                                                    </button>

          latch.countDown()
        }

        @Throws(IOException::class)
        override fun onResponse(
          call: Call,
          response: Response,
        ) {
          response.close()
          latch.countDown()
        }
      },
    )
    latch.await()
    assertThat(call.isCanceled()).isTrue()
    assertThat(exceptionRef.get()).isNotNull()
  }

  @Test

     */
    SmbPipeResource getPipe(String url, int pipeType) throws CIFSException;

    /**
     * Close all connections and release resources associated with this context
     *
     * @return whether any connection was still in use
     * @throws CIFSException if an error occurs during cleanup
     */
    boolean close() throws CIFSException;

    /**
     * Get the configuration object for this context
     *

				Quote:          '"',
				QuoteEscape:    '"',
				AlwaysQuote:    false,
			}
			record.WriteCSV(&result, opts)
			result.Truncate(result.Len() - 1)
			result.WriteString(c.recordDelimiter)
		}
		r.Close()
		if err != io.EOF {
			t.Fatalf("Case %d failed with %s", i, err)
		}

		if result.String() != c.content {
			t.Errorf("Case %d failed: expected %v result %v", i, c.content, result.String())
		}
	}
}

    dns["san.com"] = Dns.SYSTEM.lookup(server.hostName).subList(0, 1)
    assert200Http2Response(execute(url), server.hostName)

    // Simulate a stale connection in the pool.
    connection.get()!!.socket().close()
    val sanUrl = url.newBuilder().host("san.com").build()
    assert200Http2Response(execute(sanUrl), "san.com")
    assertThat(client.connectionPool.connectionCount()).isEqualTo(1)
  }

  /**

			return store.ErrNotConnected
		}
		return err
	}

	// Delete the event from store.
	return target.store.Del(key)
}

// Close - does nothing and available for interface compatibility.
func (target *ElasticsearchTarget) Close() error {
	close(target.quitCh)
	if target.client != nil {
		// Stops the background processes that the client is running.
		target.client.stop()
	}
	return nil
}