*/
public enum HandleType {
    /**
     * No durability - standard handle
     */
    NONE(0),

    /**
     * SMB 2.1 durable handle - survives network loss
     */
    DURABLE_V1(1),

    /**
     * SMB 3.0 durable handle V2 - with timeout configuration
     */
    DURABLE_V2(2),

    /**
     * SMB 3.0 persistent handle - survives server reboot
     */

            }
            return URLConnection.guessContentTypeFromName(path);
        } catch (final IOException e) {
            throw new IORuntimeException(e);
        } finally {
            CloseableUtil.close(is);
        }
    }

OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

HSPLokio/ForwardingSink;-><init>(Lokio/Sink;)V
HSPLokio/ForwardingSink;->close()V
HSPLokio/ForwardingSink;->write(Lokio/Buffer;J)V
HSPLokio/ForwardingSource;-><init>(Lokio/Source;)V
HSPLokio/ForwardingSource;->close()V
HSPLokio/GzipSource;-><init>(Lokio/Source;)V
HSPLokio/GzipSource;->checkEqual(Ljava/lang/String;II)V
HSPLokio/GzipSource;->close()V
HSPLokio/GzipSource;->read(Lokio/Buffer;J)J

    synchronized (lock) {
      if (record != null) {
        list.add(record);
      }
    }
  }

  @Override
  public void flush() {}

  @Override
  public void close() {}

  public void clear() {
    synchronized (lock) {
      list.clear();
    }
  }

  /** Returns a snapshot of the logged records. */
  /*

        }
    }

    /**
     * Closes this SAM domain handle.
     *
     * @throws IOException if an I/O error occurs during handle closure
     */
    public void close() throws IOException {
        final MsrpcSamrCloseHandle rpc = new MsrpcSamrCloseHandle(this);
        handle.sendrecv(rpc);
        if (rpc.retval != 0) {
            throw new SmbException(rpc.retval, false);
        }

            handle.sendrecv(rpc2);
        }
    }

    /**
     * Closes this SAM policy handle.
     *
     * @throws IOException if an I/O error occurs during handle closure
     */
    public void close() throws IOException {
        final MsrpcSamrCloseHandle rpc = new MsrpcSamrCloseHandle(this);
        handle.sendrecv(rpc);
        if (rpc.retval != 0) {
            throw new SmbException(rpc.retval, false);
        }

		if err != nil {
			log.Fatal(err)
		}
		if _, err := w.Write(data); err != nil {
			log.Fatal(err)
		}
		seen[name] = true
		return nil
	})
	if err != nil {
		log.Fatal(err)
	}
	if err := zw.Close(); err != nil {
		log.Fatal(err)
	}
	if len(seen) == 0 {
		log.Fatalf("did not find any files to add")
	}
	if !seen["US/Eastern"] {
		log.Fatalf("did not find US/Eastern to add")
	}

import org.junit.jupiter.api.Test

class AddressTest {
  private val factory =
    TestValueFactory().apply {
      uriHost = "example.com"
      uriPort = 80
    }

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

  @Test fun equalsAndHashcode() {
    val a = factory.newAddress()
    val b = factory.newAddress()
    assertThat(b).isEqualTo(a)
    assertThat(b.hashCode()).isEqualTo(a.hashCode())
  }

	}
	if err := tw.WriteHeader(hdr); err != nil {
		t.Fatalf("tw.WriteHeader: %v", err)
	}
	if _, err := tw.Write(data); err != nil {
		t.Fatalf("tw.Write: %v", err)
	}
	if err := tw.Close(); err != nil {
		t.Fatalf("tw.Close: %v", err)
	}

	// Read it back.
	tr := NewReader(&b)
	rHdr, err := tr.Next()
	if err != nil {
		t.Fatalf("tr.Next: %v", err)
	}
	if !reflect.DeepEqual(rHdr, hdr) {