@Override
    public void setUp() throws Exception {
        super.setUp();
        final File propFile = File.createTempFile("project", ".properties");
        propFile.deleteOnExit();
        FileUtil.writeBytes(propFile.getAbsolutePath(), "fess.version=98.76.5".getBytes());
        final File desginJspRootFile = File.createTempFile("jsp", "");
        desginJspRootFile.delete();
        desginJspRootFile.deleteOnExit();

func (z *connectReq) EncodeMsg(en *msgp.Writer) (err error) {
	// map header, size 4
	// write "ID"
	err = en.Append(0x84, 0xa2, 0x49, 0x44)
	if err != nil {
		return
	}
	err = en.WriteBytes((z.ID)[:])
	if err != nil {
		err = msgp.WrapError(err, "ID")
		return
	}
	// write "Host"
	err = en.Append(0xa4, 0x48, 0x6f, 0x73, 0x74)
	if err != nil {
		return
	}

		err = msgp.WrapError(err, "VersionID")
		return
	}
	// write "Versions"
	err = en.Append(0xa8, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x73)
	if err != nil {
		return
	}
	err = en.WriteBytes(z.Versions)
	if err != nil {
		err = msgp.WrapError(err, "Versions")
		return
	}
	// write "SetIndex"
	err = en.Append(0xa8, 0x53, 0x65, 0x74, 0x49, 0x6e, 0x64, 0x65, 0x78)
	if err != nil {
		return

    // TODO
    /*
    private File file1;
    @Override
    public void setUp() throws Exception {
        super.setUp();
        file1 = File.createTempFile("synonym", ".txt");
        FileUtil.writeBytes(file1.getAbsolutePath(),
                "a1=>A1\nb1,b2 => B1\nc1 => C1, C2\nx1,X1\ny1, Y1, y2"
                        .getBytes(Constants.UTF_8));
        // TODO set up opensearch and dictionaryManager

    @Override
    public void setUp() throws Exception {
        super.setUp();
        final File propFile = File.createTempFile("system", ".properties");
        propFile.deleteOnExit();
        FileUtil.writeBytes(propFile.getAbsolutePath(), "".getBytes());
        ComponentUtil.register(new DynamicProperties(propFile), "systemProperties");
        crawlingConfigHelper = new CrawlingConfigHelper();
        crawlingConfigHelper.init();

                }
            }
            return new String(buf, 0, size);
        } catch (final IOException e) {
            throw new IORuntimeException(e);
        }
    }

    public static void writeBytes(final String pathname, final byte[] bytes) {
        try (FileOutputStream fos = OutputStreamUtil.create(new File(pathname))) {
            ChannelUtil.write(fos.getChannel(), ByteBuffer.wrap(bytes));

      }
    }

    @Override
    public void writeByte(int v) {
      try {
        output.writeByte(v);
      } catch (IOException impossible) {
        throw new AssertionError(impossible);
      }
    }

    @Override
    public void writeBytes(String s) {
      try {
        output.writeBytes(s);
      } catch (IOException impossible) {

    @Override
    public final void writeDouble ( double v ) throws SmbException {
        Encdec.enc_doublebe(v, this.tmp, 0);
        write(this.tmp, 0, 8);
    }


    @Override
    public final void writeBytes ( String s ) throws SmbException {
        byte[] b = s.getBytes();
        write(b, 0, b.length);
    }


    @Override
    public final void writeChars ( String s ) throws SmbException {

	}
}

type readFromWriter struct {
	buf           []byte
	writeBytes    int
	readFromBytes int
}

func (w *readFromWriter) Write(p []byte) (int, error) {
	w.buf = append(w.buf, p...)
	w.writeBytes += len(p)
	return len(p), nil
}

func (w *readFromWriter) ReadFrom(r io.Reader) (int64, error) {
	b, err := io.ReadAll(r)

		err = msgp.WrapError(err, "ReplicationState")
		return
	}
	if z.Data == nil { // allownil: if nil
		err = en.WriteNil()
		if err != nil {
			return
		}
	} else {
		err = en.WriteBytes(z.Data)
		if err != nil {
			err = msgp.WrapError(err, "Data")
			return
		}
	}
	err = en.WriteInt(z.NumVersions)
	if err != nil {
		err = msgp.WrapError(err, "NumVersions")
		return