// verify both parent flags and the child flag are visible by default
	parent.SetArgs([]string{"child", "--help"})
	if err := parent.Execute(); err != nil {
		t.Fatal(err)
	}
	got := out.String()
	out.Reset()
	checkHelpForFlag(t, got, parentFlag0, true)
	checkHelpForFlag(t, got, parentFlag1, true)
	checkHelpForFlag(t, got, parentFlag2, true)
	checkHelpForFlag(t, got, childFlag2, true)

        if ( n != null ) {
            n.prepare(next);
        }
    }


    /**
     * {@inheritDoc}
     *
     * @see jcifs.internal.smb2.ServerMessageBlock2#reset()
     */
    @Override
    public void reset () {
        super.reset();
        this.received = false;
    }


    /**
     * {@inheritDoc}
     *
     * @see jcifs.util.transport.Response#received()
     */
    @Override

func (u UUIDHash) Write(p []byte) (n int, err error) {
	return len(p), nil
}

// Sum -  implement md5.Sum
func (u UUIDHash) Sum(b []byte) []byte {
	return u.uuid
}

// Reset -  implement hash.Hash Reset
func (u UUIDHash) Reset() {
	return
}

// Size -  implement hash.Hash Size
func (u UUIDHash) Size() int {
	return len(u.uuid)
}

// BlockSize -  implement hash.Hash BlockSize

            }

            if ( ( msg.flags & ( DCERPC_FIRST_FRAG | DCERPC_LAST_FRAG ) ) != ( DCERPC_FIRST_FRAG | DCERPC_LAST_FRAG ) ) {
                buf.start = off;
                buf.reset();
                msg.encode_header(buf);
                buf.enc_ndr_long(msg.alloc_hint);
                buf.enc_ndr_short(0); /* context id */
                buf.enc_ndr_short(msg.getOpnum());
            }

		case <-callhomeTimer.C:
			if !globalCallhomeConfig.Enabled() {
				// Stop the processing as callhome got disabled
				return false
			}

			performCallhome(ctx)

			// Reset the timer for next cycle.
			callhomeTimer.Reset(globalCallhomeConfig.FrequencyDur())
		}
	}
}

func performCallhome(ctx context.Context) {
	deadline := 10 * time.Second // Default deadline is 10secs for callhome

        maxParameterCount = 8;
        maxDataCount = 16384;
        maxSetupCount = (byte)0x00;
        setupCount = 0;
        timeout = 5000;
    }

    void reset( int key, String lastName ) {
        super.reset();
        this.lastName = lastName;
    }

    int writeSetupWireFormat( byte[] dst, int dstIndex ) {
        return 0;
    }
    int writeParametersWireFormat( byte[] dst, int dstIndex ) {

		levelToString[InfoLevel],
		levelToString[WarningLevel],
		levelToString[ErrorLevel],
		levelToString[CriticalLevel],
		levelToString[OffLevel])

	logCmd.PersistentFlags().BoolVarP(&reset, "reset", "r", reset, "Reset levels to default value (warning).")
	logCmd.PersistentFlags().StringVarP(&labelSelector, "selector", "l", "", "Label selector")
	logCmd.PersistentFlags().StringVar(&loggerLevelString, "level", loggerLevelString,

            if ( request != null ) {
                log.debug("Restting request");
                request.reset();
            }
            if ( rpath != null ) {
                // resolveDfs() and tree.send() modify the request packet.
                // I want to restore it before retrying. request.reset()
                // restores almost everything that was modified, except the path.
                rpath.setPath(savedPath);

		t.Log("WARNING: TestEncodeDecodeBucketReplicationStat Msgsize() is inaccurate")
	}

	vn := BucketReplicationStat{}
	err := msgp.Decode(&buf, &vn)
	if err != nil {
		t.Error(err)
	}

	buf.Reset()
	msgp.Encode(&buf, &v)
	err = msgp.NewReader(&buf).Skip()
	if err != nil {
		t.Error(err)
	}
}

func BenchmarkEncodeBucketReplicationStat(b *testing.B) {
	v := BucketReplicationStat{}

		// Use bufio Writer to prevent csv.Writer from allocating a new buffer.
		bufioWriter := bufioWriterPool.Get().(*bufio.Writer)
		defer func() {
			bufioWriter.Reset(xioutil.Discard)
			bufioWriterPool.Put(bufioWriter)
		}()

		bufioWriter.Reset(buf)
		opts := sql.WriteCSVOpts{
			FieldDelimiter: []rune(s3Select.Output.CSVArgs.FieldDelimiter)[0],
			Quote:          []rune(s3Select.Output.CSVArgs.QuoteCharacter)[0],