)

// Test BoolFlag.String()
func TestBoolFlagString(t *testing.T) {
	var bf BoolFlag

	testCases := []struct {
		flag           BoolFlag
		expectedResult string
	}{
		{bf, "off"},
		{BoolFlag(true), "on"},
		{BoolFlag(false), "off"},
	}

	for _, testCase := range testCases {
		str := testCase.flag.String()
		if testCase.expectedResult != str {
			t.Fatalf("expected: %v, got: %v", testCase.expectedResult, str)
		}

class SmbComReadAndXResponse extends AndXServerMessageBlock {

    byte[] b;
    int off, dataCompactionMode, dataLength, dataOffset;

    SmbComReadAndXResponse() {
    }
    SmbComReadAndXResponse( byte[] b, int off ) {
        this.b = b;
        this.off = off;
    }

    void setParam( byte[] b, int off ) {
        this.b = b;
        this.off = off;
    }
    int writeParameterWordsWireFormat( byte[] dst, int dstIndex ) {

                MessageBuilder buff = MessageUtils.builder();
                buff.a("Message styles: ");
                buff.trace("trace").a(' ');
                buff.debug("debug").a(' ');
                buff.info("info").a(' ');
                buff.warning("warning").a(' ');
                buff.error("error").a(' ');
                buff.success("success").a(' ');

        }

        while ( off < length ) {
            int r = this.handle.recv(buf, off, length - off);
            if ( r == 0 ) {
                throw new IOException("Unexpected EOF");
            }
            off += r;
        }
        return off;
    }


    @Override
    public void close () throws IOException {
        super.close();
        try {
            this.handle.close();

	}
	buf := make([]byte, ss.Size())
	for off := int64(0); off < ss.Size(); off++ {
		for size := 1; size <= int(ss.Size()-off); size++ {
			readBuf := buf[:size]
			n, err := ss.ReadAt(readBuf, off)
			if off < ss.Size()-keep {
				if err != errDiscardedBytes {
					t.Errorf("off %d, size %d = %v, %v (%q); want errDiscardedBytes", off, size, n, err, readBuf[:n])
				}
				continue
			}

            bufferIndex += 14;
            e.type = readInt2( buffer, bufferIndex );
            bufferIndex += 2;
            int off = readInt4( buffer, bufferIndex );
            bufferIndex += 4;
            off = ( off & 0xFFFF ) - converter;
            off = start + off;
            e.remark = readString( buffer, off, 128, false );

            if (log.level >= 4)
                log.println( e );
        }

            e.type = SMBUtil.readInt2(buffer, bufferIndex);
            bufferIndex += 2;
            int off = SMBUtil.readInt4(buffer, bufferIndex);
            bufferIndex += 4;
            off = ( off & 0xFFFF ) - this.converter;
            off = start + off;
            e.remark = readString(buffer, off, 128, false);

            if ( log.isTraceEnabled() ) {
                log.trace(e.toString());
            }

			Description: "quietly ignore undelivered messages when set to 'off', default is 'on'",
			Optional:    true,
			Type:        "on|off",
		},
		config.HelpKV{
			Key:         target.AmqpDurable,
			Description: "persist queue across broker restarts when set to 'on', default is 'off'",
			Optional:    true,
			Type:        "on|off",
		},
		config.HelpKV{
			Key:         target.AmqpNoWait,

            file.log.println( "write: fid=" + file.fid + ",off=" + off + ",len=" + len );

        int w;
        do {
            w = len > writeSize ? writeSize : len;
            if( useNTSmbs ) {
                reqx.setParam( file.fid, fp, len - w, b, off, w );
if ((flags & 1) != 0) {
    reqx.setParam( file.fid, fp, len, b, off, w );
    reqx.writeMode = 0x8;
} else {
    reqx.writeMode = 0;
}

        # To allow special characters in headers
        ignore_invalid_headers off;
        # Allow any size file to be uploaded.
        # Set to a value such as 1000m; to restrict file size to a specific value
        client_max_body_size 0;
        # To disable buffering
        proxy_buffering off;
        proxy_request_buffering off;

        location / {
            proxy_set_header Host $http_host;