val length =
      when {
        length0 == 0b1000_0000 -> {
          throw ProtocolException("indefinite length not permitted for DER")
        }
        (length0 and 0b1000_0000) == 0b1000_0000 -> {
          // Length specified over multiple bytes.
          val lengthBytes = length0 and 0b0111_1111
          if (lengthBytes > 8) {
            throw ProtocolException("length encoded with more than 8 bytes is not supported")

    return byteSink.wasStreamClosed();
  }

  @Override
  public Writer openStream() throws IOException {
    // using TestByteSink's output stream to get option behavior, so flush to it on every write
    return new FilterWriter(new OutputStreamWriter(byteSink.openStream(), UTF_8)) {
      @Override
      public void write(int c) throws IOException {
        super.write(c);
        flush();
      }

      @Override

/** Unit tests for {@link Futures#getDone}. */
@GwtCompatible
@NullUnmarked
public class FuturesGetDoneTest extends TestCase {
  public void testSuccessful() throws ExecutionException {
    assertThat(getDone(immediateFuture("a"))).isEqualTo("a");
  }

  public void testSuccessfulNull() throws ExecutionException {
    assertThat(getDone(Futures.<@Nullable String>immediateFuture(null))).isEqualTo(null);
  }

  public void testFailed() {

 */
public class SmbPipeOutputStream extends SmbFileOutputStream {

    private final SmbPipeHandleImpl handle;

    /**
     * @param handle
     * @throws SmbException
     */
    SmbPipeOutputStream(final SmbPipeHandleImpl handle, final SmbTreeHandleImpl th) throws CIFSException {
        super(handle.getPipe(), th, null, 0, 0, 0);
        this.handle = handle;
    }

    /**
     * {@inheritDoc}
     *

    /**
     * Connects and performs logon to the tree using the specified context
     * @param tf the CIFS context to use for connection
     * @throws SmbException if an SMB error occurs during connection
     */
    @Deprecated
    void connectLogon(CIFSContext tf) throws SmbException;

    /**
     * Sends an SMB request and returns the response
     * @param <T> the response type
     * @param request the request to send

     * @return A configured toolchain instance
     * @throws ToolchainFactoryException if toolchain creation fails
     */
    @Nonnull
    Toolchain createToolchain(@Nonnull ToolchainModel model) throws ToolchainFactoryException;

    /**
     * Creates a default toolchain instance using system defaults.
     *
     * @return Optional containing the default toolchain if available

     * @param arg0 The domain.
     * @param arg1 The workstation.
     * @return The Type 1 message.
     * @throws NTLMEngineException if an NTLM engine error occurs.
     */
    @Override
    public String generateType1Msg(final String arg0, final String arg1) throws NTLMEngineException {
        // TODO Auto-generated method stub
        return null;
    }

    /**

  private byte[] data;

  @Override
  protected void setUp() throws Exception {
    super.setUp();

    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    DataOutputStream out = new DataOutputStream(baos);

    initializeData(out);

    data = baos.toByteArray();
  }

  private void initializeData(DataOutputStream out) throws IOException {
    /* Write out various test values NORMALLY */

    protected WagonManager wagonManager;

    @Override
    public void transformForResolve(
            Artifact artifact, List<ArtifactRepository> remoteRepositories, ArtifactRepository localRepository)
            throws ArtifactResolutionException, ArtifactNotFoundException {
        RepositoryRequest request = new DefaultRepositoryRequest();
        request.setLocalRepository(localRepository);

 *
 */
public class ThreadUtilTest {

    /**
     * @throws Exception
     */
    @Test
    public void test_sleep() throws Exception {
        ThreadUtil.sleep(1L);
        assertTrue(true);
        ThreadUtil.sleepQuietly(1L);
    }

    /**
     * @throws Exception
     */
    @Test
    public void test_sleepQuietly() throws Exception {
        ThreadUtil.sleepQuietly(1L);
        assertTrue(true);