case io.EOF:
			r.err = io.ErrUnexpectedEOF
			return metaCacheEntry{}, io.ErrUnexpectedEOF
		}
		r.err = err
		return metaCacheEntry{}, err
	}

	var err error
	if r.current.name, err = r.mr.ReadString(); err != nil {
		if err == io.EOF {
			err = io.ErrUnexpectedEOF
		}
		r.err = err
		return metaCacheEntry{}, err
	}
	r.current.metadata, err = r.mr.ReadBytes(r.current.metadata[:0])
	if err == io.EOF {

        writeString(value.pattern())
        writeInt(value.flags())
    }

    override suspend fun ReadContext.decode(): Pattern? {
        return Pattern.compile(readString(), readInt())
    }

        Map<String, ModuleConfigurationMetadata> configurations = Maps.newHashMapWithExpectedSize(configurationsCount);

        for (int i = 0; i < configurationsCount; i++) {
            String configurationName = decoder.readString();
            boolean transitive = true;
            boolean visible = true;
            ImmutableSet<String> hierarchy = ImmutableSet.of(configurationName);
            ImmutableList<ExcludeMetadata> excludes;

        encoder.writeString(value.getQuestion());
    }

    @Override
    public YesNoQuestionPromptEvent read(Decoder decoder) throws Exception {
        return new YesNoQuestionPromptEvent(decoder.readLong(), decoder.readString());
    }

			if err != nil {
				err = msgp.WrapError(err, "DiskIndex")
				return
			}
		case "Path":
			z.Path, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "Path")
				return
			}
		case "Endpoint":
			z.Endpoint, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "Endpoint")
				return
			}
		case "Started":
			z.Started, err = dc.ReadTime()

		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "ID":
			z.ID, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "ID")
				return
			}
		case "User":
			z.User, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "User")
				return
			}
		case "Started":
			z.Started, err = dc.ReadTime()

	}
	defer fd.Close()
	br := bufio.NewReader(fd)

	file, err := open(filename)
	if file == nil {
		t.Fatal(err)
	}
	defer file.close()

	lineno := 1
	byteno := 0
	for {
		bline, berr := br.ReadString('\n')
		if n := len(bline); n > 0 {
			bline = bline[0 : n-1]
		}
		line, ok := file.readLine()
		if (berr != nil) != !ok || bline != line {

        encoder.writeSmallInt(value.getDefaultValue());
    }

    @Override
    public IntQuestionPromptEvent read(Decoder decoder) throws Exception {
        return new IntQuestionPromptEvent(decoder.readLong(), decoder.readString(), decoder.readSmallInt(), decoder.readSmallInt());
    }

        encoder.writeSmallInt(value.getDefaultOption());
    }

    @Override
    public SelectOptionPromptEvent read(Decoder decoder) throws Exception {
        return new SelectOptionPromptEvent(decoder.readLong(), decoder.readString(), optionsSerializer.read(decoder), decoder.readSmallInt());
    }

                Assume.assumeTrue(JavaVersion.current().isJava11Compatible())
                """
                ((Supplier<String>) () -> {
                    try {
                        return Files.readString(new File("$filePath").toPath());
                    } catch (IOException e) {
                        throw new RuntimeException(e);
                    }
                }).get()
                """.stripIndent()