}

func (w *teststringwriter) WriteString(s string) (int, error) {
	w.writeString += s
	return len(s), nil
}

func (w *teststringwriter) check(t *testing.T, write, writeString string) {
	t.Helper()
	if w.write != write {
		t.Errorf("write: expected %q, got %q", write, w.write)
	}
	if w.writeString != writeString {
		t.Errorf("writeString: expected %q, got %q", writeString, w.writeString)
	}
}

        Path mavenUserProps = mavenConf.resolve("maven.properties");
        Files.writeString(mavenUserProps, "${includes} = ?\"/user/ma ven.properties\",  ?/foo/bar\n");
        Path userDirectory = fs.getPath("/user");
        Files.createDirectories(userDirectory);
        Path propsPath = userDirectory.resolve("ma ven.properties");
        Files.writeString(propsPath, "${includes} = another.properties\nfro = ${bar}z\n");

	if err != nil {
		err = msgp.WrapError(err, "Scanning")
		return
	}
	err = en.WriteString(z.Endpoint)
	if err != nil {
		err = msgp.WrapError(err, "Endpoint")
		return
	}
	err = en.WriteString(z.MountPath)
	if err != nil {
		err = msgp.WrapError(err, "MountPath")
		return
	}
	err = en.WriteString(z.ID)
	if err != nil {
		err = msgp.WrapError(err, "ID")
		return
	}

                          </dependency>
                        </dependencies>

                    </project>
                    """;
        Path pom = cwd.resolve("pom.xml").toAbsolutePath();
        Files.writeString(pom, pomString);

        String appJavaString =
                """
                package org.apache.maven.samples.sample;

                public class App {

		if err != nil {
			err = msgp.WrapError(err, "Checksums")
			return
		}
		for za0001, za0002 := range z.Checksums {
			err = en.WriteString(za0001)
			if err != nil {
				err = msgp.WrapError(err, "Checksums")
				return
			}
			err = en.WriteString(za0002)
			if err != nil {
				err = msgp.WrapError(err, "Checksums", za0001)
				return
			}
		}
	}

        Files.writeString(mavenUserProps, "${includes} = ?${session.rootDirectory}/.mvn/maven.properties\n");
        Path rootDirectory = fs.getPath("C:\\myRootDirectory");
        Path topDirectory = rootDirectory.resolve("myTopDirectory");
        Path mvn = rootDirectory.resolve(".mvn");
        Files.createDirectories(mvn);
        Files.writeString(
                mvn.resolve("maven.properties"),

type FileParseError struct{}

const FileParseString = "Some files couldn't be parsed."

func (f AnalyzerFoundIssuesError) Error() string {
	var sb strings.Builder
	sb.WriteString(fmt.Sprintf("Analyzers found issues when analyzing %s.\n", analyzeTargetAsString()))
	sb.WriteString(fmt.Sprintf("See %s for more information about causes and resolutions.", url.ConfigAnalysis))
	return sb.String()
}

func (f FileParseError) Error() string {

        return sb.toString();
    }

    @Test
    void testOptionsAsHtml() throws IOException {
        Path options = Paths.get("target/test-classes/options.html");
        Files.writeString(options, getOptionsAsHtml(), StandardCharsets.UTF_8);
    }

	if !ok {
		m = b.grow(len(p))
	}
	return copy(b.buf[m:], p), nil
}

// WriteString appends the contents of s to the buffer, growing the buffer as
// needed. The return value n is the length of s; err is always nil. If the
// buffer becomes too large, WriteString will panic with [ErrTooLarge].
func (b *Buffer) WriteString(s string) (n int, err error) {
	b.lastRead = opInvalid
	m, ok := b.tryGrowByReslice(len(s))

		if err != nil {
			err = msgp.WrapError(err, "MetaUser")
			return
		}
		for za0011, za0012 := range z.MetaUser {
			err = en.WriteString(za0011)
			if err != nil {
				err = msgp.WrapError(err, "MetaUser")
				return
			}
			err = en.WriteString(za0012)
			if err != nil {
				err = msgp.WrapError(err, "MetaUser", za0011)
				return
			}
		}
	}
	return
}