return out[:size:size]
}

func (tr *Trace) STWReason(kindID uint64) STWReason {
	if tr.Version < 21 {
		if kindID == 0 || kindID == 1 {
			return STWReason(kindID + 1)
		} else {
			return STWUnknown
		}
	} else if tr.Version == 21 {
		if kindID < NumSTWReasons {
			return STWReason(kindID)
		} else {
			return STWUnknown
		}
	} else {
		return STWUnknown

            LOGGER.debug("Found {} {} at {}", getDisplayName(), version.toString(), windowsKitDir);
            File binDir = new File(windowsKitDir, "bin/" + versionDir);
            File unversionedBinDir = new File(windowsKitDir, "bin");
            if (isValidComponentBinDir(binDir)) {
                T component = newComponent(windowsKitDir, binDir, version, discoveryType);
                found.add(component);

		etcdctlVersioned := fmt.Sprintf("etcdctl-%s", opts.targetVersion)
		if err := copyFile(filepath.Join(opts.binDir, etcdVersioned), filepath.Join(opts.binDir, "etcd")); err != nil {
			klog.Fatalf("Failed to copy %s: %v", etcdVersioned, err)
		}
		if err := copyFile(filepath.Join(opts.binDir, etcdctlVersioned), filepath.Join(opts.binDir, "etcdctl")); err != nil {
			klog.Fatalf("Failed to copy %s: %v", etcdctlVersioned, err)
		}
	}
}

    @ToBeFixedForConfigurationCache
    def "can configure tool executables"() {
        def binDir = testDirectory.createDir("bin")
        wrapperTool(binDir, "c-compiler", toolChain.CCompiler, "-DFRENCH")
        wrapperTool(binDir, "static-lib", toolChain.staticLibArchiver)
        wrapperTool(binDir, "linker", toolChain.linker)

        when:
        buildFile << """
model {
    toolChains {

public class WindowsKitSdkInstall extends WindowsKitInstall implements WindowsSdkInstall {
    private final File binDir;
    private final SystemInfo systemInfo;

    public WindowsKitSdkInstall(File baseDir, VersionNumber version, File binDir, String name, SystemInfo systemInfo) {
        super(baseDir, version, name);
        this.binDir = binDir;
        this.systemInfo = systemInfo;
    }

    @Override

    public File getBinDir() {
        return binDir;
    }

    @Override
    public List<File> getPath() {
        return paths;
    }

    @Override
    public File getCompilerExecutable() {
        return new File(binDir, COMPILER_FILENAME);
    }

    @Override
    public File getLinkerExecutable() {
        return new File(binDir, LINKER_FILENAME);
    }

    @Override

// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package kind

            )
        }.toList()

    if (binDir != null) {
        writeFile(
            moduleFileFor(binDir, moduleName),
            moduleMetadataBytesFor(emittedClassNames)
        )
    }

    return emittedClassNames
}


internal
fun IO.makeAccessorOutputDirs(srcDir: File, binDir: File?, packagePath: String) = io {
    srcDir.resolve(packagePath).mkdirs()
    binDir?.apply {
        resolve(packagePath).mkdirs()

    }

    @Override
    String getDisplayName() {
        return DISPLAY_NAME;
    }

    @Override
    boolean isValidComponentBinDir(File binDir) {
        for (String platform : PLATFORMS) {
            if (!new File(binDir, platform + "/" + RC_EXE).exists()) {
                return false;
            }
        }
        return true;
    }

    @Override

        def binDir = file('fake-bin')

        then:
        def path
        if (OperatingSystem.current().windows) {
            path = ''
        } else {
            // Set up a fake bin directory, containing the things that the script needs, minus any java that might be in /usr/bin
            links.each { linkToBinary(it, binDir) }
            path = binDir.absolutePath
        }