func (z *ServerSystemConfig) EncodeMsg(en *msgp.Writer) (err error) {
	// map header, size 4
	// write "NEndpoints"
	err = en.Append(0x84, 0xaa, 0x4e, 0x45, 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x73)
	if err != nil {
		return
	}
	err = en.WriteInt(z.NEndpoints)
	if err != nil {
		err = msgp.WrapError(err, "NEndpoints")
		return
	}
	// write "CmdLines"

		"Overall write quorum across pools and sets")
	erasureSetOverallHealthMD = NewGaugeMD(erasureSetOverallHealth,
		"Overall health across pools and sets (1=healthy, 0=unhealthy)")
	erasureSetReadQuorumMD = NewGaugeMD(erasureSetReadQuorum,
		"Read quorum for the erasure set in a pool", poolIDL, setIDL)
	erasureSetWriteQuorumMD = NewGaugeMD(erasureSetWriteQuorum,
		"Write quorum for the erasure set in a pool", poolIDL, setIDL)

    this.out = out;
  }

  @Override
  public void write(int c) throws IOException {
    super.write(c);
    flush(); // flush write to TestOutputStream to get its behavior
  }

  @Override
  public void write(char[] cbuf, int off, int len) throws IOException {
    super.write(cbuf, off, len);
    flush();
  }

  @Override
  public void write(String str, int off, int len) throws IOException {

      val body = part.body

      sink!!.write(DASHDASH)
      sink.write(boundaryByteString)
      sink.write(CRLF)

      if (headers != null) {
        for (h in 0 until headers.size) {
          sink
            .writeUtf8(headers.name(h))
            .write(COLONSPACE)
            .writeUtf8(headers.value(h))
            .write(CRLF)
        }
      }

				write(v.Raw, stmt.Table)
			} else if stmt.AddError(stmt.Parse(stmt.Model)) == nil {
				write(v.Raw, stmt.Table)
			}
		} else {
			write(v.Raw, v.Name)
		}

		if v.Alias != "" {
			writer.WriteByte(' ')
			write(v.Raw, v.Alias)
		}
	case clause.Column:
		if v.Table != "" {
			if v.Table == clause.CurrentTable {
				write(v.Raw, stmt.Table)
			} else {
				write(v.Raw, v.Table)
			}

func (z *ChecksumInfo) EncodeMsg(en *msgp.Writer) (err error) {
	// map header, size 3
	// write "PartNumber"
	err = en.Append(0x83, 0xaa, 0x50, 0x61, 0x72, 0x74, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72)
	if err != nil {
		return
	}
	err = en.WriteInt(z.PartNumber)
	if err != nil {
		err = msgp.WrapError(err, "PartNumber")
		return
	}
	// write "Algorithm"

public class SMBUtil {

    /**
     * Private constructor to prevent instantiation of utility class.
     */
    private SMBUtil() {
    }

    /**
     * Writes a 16-bit integer value to a byte array in little-endian format
     * @param val the value to write
     * @param dst the destination byte array
     * @param dstIndex the starting index in the destination array
     */

   *
   * 1. visibility of the writes to these fields to Fire.run:
   *
   * The initial write to delegateRef is made definitely visible via the semantics of
   * addListener/SES.schedule. The later racy write in cancel() is not guaranteed to be observed,
   * however that is fine since the correctness is based on the atomic state in our base class. The

        // size8 method aligns to 8-byte boundary
        int alignedSize = (expectedSize + 7) & ~7;
        assertEquals(alignedSize, size);
    }

    @Test
    @DisplayName("Should write correct bytes to wire format")
    void testWriteBytesWireFormat() {
        // Given
        Configuration mockConfig = mock(Configuration.class);

	}
	for i := 0; i < chunks; i++ {
		_, err := f.Write(chunk)
		if err != nil {
			t.Fatal("write chunk:", err)
		}
	}
	if frag := int(size % chunkSize); frag > 0 {
		_, err := f.Write(chunk[:frag])
		if err != nil {
			t.Fatal("write chunk:", err)
		}
	}
	end := []byte("END\n")
	_, err = f.Write(end)
	if err != nil {
		t.Fatal("write end:", err)
	}
	if err := w.Close(); err != nil {