return err
	}
	return d.disk.AppendFile(ctx, volume, path, buf)
}

func (d *naughtyDisk) RenameData(ctx context.Context, srcVolume, srcPath string, fi FileInfo, dstVolume, dstPath string, opts RenameOptions) (RenameDataResp, error) {
	if err := d.calcError(); err != nil {
		return RenameDataResp{}, err
	}
	return d.disk.RenameData(ctx, srcVolume, srcPath, fi, dstVolume, dstPath, opts)
}

func MkdirAll(dirPath string, mode os.FileMode, baseDir string) (err error) {
	defer updateOSMetrics(osMetricMkdirAll, dirPath)(err)
	return osMkdirAll(dirPath, mode, baseDir)
}

// Rename captures time taken to call os.Rename
func Rename(src, dst string) (err error) {
	defer updateOSMetrics(osMetricRename, src, dst)(err)
	return RenameSys(src, dst)
}

// OpenFile captures time taken to call os.OpenFile

            }
        }
    }

    private
    fun relocate(location: File): File {
        val newLocation = location.parentFile.resolve(location.name + "-relocated")
        location.renameTo(newLocation)
        return newLocation
    }

        then:
        targetFile.text == "Hello Old World!"
        executedAndNotSkipped ":run"

        expect:
        succeeds "clean"

        when:
        originalDir.renameTo(renamedDir)
        settingsFile.text = buildCache.localCacheConfiguration()
        buildFile.text = buildFileContents
        sourceFile.text = "Hello New World!"

        runWithWatchingEnabled "run"

                String renamed = entry.getPath().getLastName();
                if (renamed.startsWith(RemappingScriptSource.MAPPED_SCRIPT)) {
                    renamed = className + renamed.substring(RemappingScriptSource.MAPPED_SCRIPT.length());
                }
                byte[] content = classData.getClassContent();

# This test simulates a process watching for changes and reading files in
# module cache as a module is extracted.
#
# Before Go 1.16, we extracted each module zip to a temporary directory with
# a random name, then renamed that into place with os.Rename. On Windows,
# this failed with ERROR_ACCESS_DENIED when another process (usually an
# anti-virus scanner) opened files in the temporary directory. This test
# simulates that behavior, verifying golang.org/issue/36568.

            public class NotATest {}
        """
    }

    @Override
    void renameTests() {
        def newTest = file("src/test/java/NewTest.java")
        file('src/test/java/SomeOtherTest.java').renameTo(newTest)
        newTest.text = newTest.text.replaceAll("SomeOtherTest", "NewTest")
    }

    @Override
    String getTestTaskName() {
        return "test"
    }

    @Override

                ":consumer:generateExternalPluginSpecBuilders"
            )
        }

        existing("producer/src/main/kotlin/changing-producer-plugin.gradle.kts").run {
            renameTo(resolveSibling("changed-producer-plugin.gradle.kts"))
        }

        build("assemble").run {
            assertTaskExecuted(
                ":consumer:generateExternalPluginSpecBuilders"
            )

// An Index represents a bitstream element index within a particular
// section.
type Index int32

// A relocEnt (relocation entry) is an entry in an element's local
// reference table.
//
// TODO(mdempsky): Rename this too.
type RelocEnt struct {
	Kind RelocKind
	Idx  Index
}

// Reserved indices within the meta relocation section.
const (
	PublicRootIdx  Index = 0
	PrivateRootIdx Index = 1
)

const (

// successive occurrences of the "any" placeholder in the
// type syntax expression n.Type.
func substArgTypes(old *ir.Name, types_ ...*types.Type) *ir.Name {
	for _, t := range types_ {
		types.CalcSize(t)
	}
	n := ir.NewNameAt(old.Pos(), old.Sym(), types.SubstAny(old.Type(), &types_))
	n.Class = old.Class
	n.Func = old.Func
	if len(types_) > 0 {
		base.Fatalf("SubstArgTypes: too many argument types")
	}
	return n
}