sed -i -e 's|<<\(.*\)\.\(.*\)>>|link:../definitions#_\L\1_\2\E[\1.\2]|g' ./paths.adoc

# fix the link to <<any>>
sed -i -e 's|<<any>>|link:#_any[any]|g' ./definitions.adoc
sed -i -e 's|<<any>>|link:../definitions#_any[any]|g' ./paths.adoc

# change the title of paths.adoc from "paths" to "operations"
sed -i 's|== Paths|== Operations|g' ./paths.adoc

# $$ has special meaning in asciidoc, we need to escape it

async function modifyOpenAPIFile(filePath) {
  try {
    const data = await fs.promises.readFile(filePath)
    const openapiContent = JSON.parse(data)

    const paths = openapiContent.paths
    for (const pathKey of Object.keys(paths)) {
      const pathData = paths[pathKey]
      for (const method of Object.keys(pathData)) {
        const operation = pathData[method]
        if (operation.tags && operation.tags.length > 0) {

# https://golang.org/issue/44776
# The '+' character should be disallowed in module paths, but allowed in package
# paths within valid modules.

# 'go list' accepts package paths with pluses.
cp go.mod.orig go.mod
go get example.net/cmd
go list example.net/cmd/x++

# 'go list -m' rejects module paths with pluses.
! go list -versions -m 'example.net/bad++'
stderr '^go: malformed module path "example.net/bad\+\+": invalid char ''\+''$'

    }

    def "sorts paths depth-first case-insensitive"() {
        expect:
        paths(['a', 'b', 'A', 'abc']).sort() == paths(['A', 'a', 'abc', 'b'])
        paths([':a', ':b', ':b:a', ':B:a', ':', ':B', ':a:a']).sort() == paths([':', ':a', ':a:a', ':B', ':B:a', ':b', ':b:a'])
        paths(['b', 'b:a', 'a', 'a:a']).sort() == paths(['a', 'a:a', 'b', 'b:a'])
        paths([':', ':a', 'a']).sort() == paths(['a', ':', ':a'])

type reparseData struct {
	substituteName namePosition
	printName      namePosition
	pathBuf        []uint16
}

type namePosition struct {
	offset uint16
	length uint16
}

func (rd *reparseData) addUTF16s(s []uint16) (offset uint16) {
	off := len(rd.pathBuf) * 2
	rd.pathBuf = append(rd.pathBuf, s...)
	return uint16(off)
}

func (rd *reparseData) addString(s string) (offset, length uint16) {

        if (Files.exists(Paths.get(srcWebInfBase))) {
            return Paths.get(srcWebInfBase, names);
        }
        final String targetWebInfBase = "target/fess/" + root + base;
        if (Files.exists(Paths.get(targetWebInfBase))) {
            return Paths.get(targetWebInfBase, names);
        }
        return Paths.get(webinfBase, names);
    }

# argument doesn't have .go suffix and has no version
! go get test
! stderr 'arguments must be package or module paths'
! stderr 'exists as a file, but ''go get'' requires package arguments'

# argument has .go suffix and has version
! go get test.go@v1.0.0
! stderr 'arguments must be package or module paths'
! stderr 'exists as a file, but ''go get'' requires package arguments'

# argument has .go suffix, is a file and exists

    private
    fun createFromPaths(paths: List<String>, isCaseSensitive: Boolean = true): DefaultIgnoredConfigurationInputs {
        return DefaultIgnoredConfigurationInputs(paths.joinToString(";"), isCaseSensitive, rootDir)
    }

    @Test
    fun `if created with an empty or null paths list, does not recognize an empty string`() {
        val instance = createFromPaths(emptyList())

    private Object[] paths;
    private boolean followSymlinks;

    public DefaultDeleteSpec() {
        paths = new Object[0];
        followSymlinks = false;
    }

    @Override
    public Object[] getPaths() {
        return paths;
    }

    @Override
    public DefaultDeleteSpec delete(Object... files) {
        paths = files;
        return this;
    }

    @Override

// It should accept the following formats:
//   - UNC paths                              (e.g \\server\share\foo\bar)
//   - absolute paths                         (e.g C:\foo\bar)
//   - relative paths begin with drive letter (e.g C:foo\bar, C:..\foo\bar, C:.., C:.)
//   - relative paths begin with '\'          (e.g \foo\bar)
//   - relative paths begin without '\'       (e.g foo\bar, ..\foo\bar, .., .)
//