log.println( "TransTransactNamedPipe data too long for buffer" );
            return 0;
        }
        System.arraycopy( pipeData, pipeDataOff, dst, dstIndex, pipeDataLen );
        return pipeDataLen;
    }
    int readParametersWireFormat( byte[] buffer, int bufferIndex, int len ) {
        return 0;
    }
    int readDataWireFormat( byte[] buffer, int bufferIndex, int len ) {
        return 0;
    }

            logger.info("");

            MessageBuilder buffer = builder().strong(">>> ");
            append(buffer, event.getMojoExecution());
            buffer.strong(" > ");
            appendForkInfo(buffer, event.getMojoExecution().getMojoDescriptor());
            append(buffer, event.getProject());
            buffer.strong(" >>>");

            logger.info(buffer.toString());
        }
    }

    }


    @Override
    protected int readSetupWireFormat ( byte[] buffer, int bufferIndex, int len ) {
        return 0;
    }


    @Override
    protected int readParametersWireFormat ( byte[] buffer, int bufferIndex, int len ) {
        return 0;
    }


    @Override
    protected int readDataWireFormat ( byte[] buffer, int bufferIndex, int len ) throws SMBProtocolDecodingException {

        return 0;
    }
    int readParameterWordsWireFormat( byte[] buffer, int bufferIndex ) {
        if( wordCount == 0 ) {
            return 0;
        }
        fileAttributes = readInt2( buffer, bufferIndex );
        bufferIndex += 2;
        lastWriteTime = readUTime( buffer, bufferIndex );
        bufferIndex += 4;
        fileSize = readInt4( buffer, bufferIndex );
        return 20;
    }

                    + execution.getGoal());
            buffer.a(' ').strong('(' + execution.getExecutionId() + ')');
        }

        if (project != null) {
            buffer.a(" on project ");
            buffer.project(project.getArtifactId());
        }

        if (cause != null) {
            buffer.a(": ").failure(cause.getMessage());
        }

        return buffer.toString();
    }

     */
    @Override
    public int decode ( byte[] buffer, int bufferIndex, int len ) throws SMBProtocolDecodingException {
        int start = bufferIndex;

        // Read total allocation units.
        this.alloc = SMBUtil.readInt8(buffer, bufferIndex);
        bufferIndex += 8;

        // read caller available allocation units
        this.free = SMBUtil.readInt8(buffer, bufferIndex);
        bufferIndex += 8;

    }
    int readHeaderWireFormat( InputStream in,
                                byte[] buffer,
                                int bufferIndex )
                                throws IOException {
        type = buffer[bufferIndex++] & 0xFF;
        length = (( buffer[bufferIndex] & 0x01 ) << 16 ) + readInt2( buffer, bufferIndex + 1 );
        return HEADER_LENGTH;
    }

	// Confirm that when Reader panics, the empty buffer remains empty
	var buf2 Buffer
	defer func() {
		recover()
		check(t, "TestReadFromPanicReader (2)", &buf2, "")
	}()
	buf2.ReadFrom(panicReader{panic: true})
}

func TestReadFromNegativeReader(t *testing.T) {
	var b Buffer
	defer func() {
		switch err := recover().(type) {
		case nil:
			t.Fatal("bytes.Buffer.ReadFrom didn't panic")
		case error:

      derWriter.writeUtf8("a".repeat(201))
    }

    assertThat(buffer.readByteString(3)).isEqualTo("1e81c9".decodeHex())
    assertThat(buffer.readUtf8()).isEqualTo("a".repeat(201))
  }

  @Test fun `decode primitive bit string`() {
    val buffer =
      Buffer()
        .write("0307040A3B5F291CD0".decodeHex())

    val derReader = DerReader(buffer)

    derReader.read("test") { header ->

            e.name = readString( buffer, bufferIndex, 16, false );
            bufferIndex += 16;
            e.versionMajor = (int)( buffer[bufferIndex++] & 0xFF );
            e.versionMinor = (int)( buffer[bufferIndex++] & 0xFF );
            e.type = readInt4( buffer, bufferIndex );
            bufferIndex += 4;
            int off = readInt4( buffer, bufferIndex );
            bufferIndex += 4;