result.component.baseDir == dir1
        result.component.version == VersionNumber.withPatchNumber().parse("10.0.10150.0")
    }

    def "uses newest ucrt found in registry"() {
        def dir1 = ucrtDir("ucrt", "10.0.10150.0")
        def dir2 = ucrtDir("ucrt", "10.0.10160.0")

        given:

    def visualCpp = Mock(VisualCpp)
    def windowsSdk = Mock(WindowsSdk)
    def ucrt = Mock(SystemLibraries)
    def visualStudioInstall = Mock(VisualStudioInstall)
    def toolProvider = new VisualCppPlatformToolProvider(Mock(BuildOperationExecutor), operatingSystem, [:], visualStudioInstall, visualCpp, windowsSdk, ucrt, Mock(ExecActionFactory), Mock(CompilerOutputFileNamingSchemeFactory), Mock(WorkerLeaseService))

        }
        WindowsSdk platformSdk = windowsSdk.forPlatform(targetPlatform);
        SystemLibraries cRuntime = ucrt == null ? new EmptySystemLibraries() : ucrt.getCRuntime(targetPlatform);

        DefaultVisualCppPlatformToolChain configurableToolChain = instantiator.newInstance(DefaultVisualCppPlatformToolChain.class, targetPlatform, instantiator);

public class DefaultUcrtLocator extends AbstractWindowsKitComponentLocator<UcrtInstall> implements UcrtLocator {
    private static final String DISPLAY_NAME = "Universal C Runtime";
    private static final String COMPONENT_NAME = "ucrt";

    public DefaultUcrtLocator(WindowsRegistry windowsRegistry) {
        super(windowsRegistry);
    }

    @Override
    public String getComponentName() {
        return COMPONENT_NAME;
    }

        private final VisualCpp visualCpp;
        private final WindowsSdk sdk;
        private final SystemLibraries ucrt;

        public CompositeLibraries(VisualCpp visualCpp, WindowsSdk sdk, SystemLibraries ucrt) {
            this.visualCpp = visualCpp;
            this.sdk = sdk;
            this.ucrt = ucrt;
        }

        @Override
        public VersionNumber getSdkVersion() {

        public List<File> getIncludeDirs() {
            return Collections.singletonList(new File(getBaseDir(), "Include/" + getVersion() + "/ucrt"));
        }

        @Override
        public List<File> getLibDirs() {
            return Collections.singletonList(new File(getBaseDir(), "Lib/" + getVersion() + "/ucrt/" + platformDirName));
        }

        @Override
        public Map<String, String> getPreprocessorMacros() {

func extractRoot(scrt *v1.Secret) (certInfo *credentials.CertInfo, err error) {
	ret := &credentials.CertInfo{}
	if hasValue(scrt.Data, GenericScrtCaCert) {
		ret.Cert = scrt.Data[GenericScrtCaCert]
		ret.CRL = scrt.Data[GenericScrtCRL]
		return ret, nil
	}
	if hasValue(scrt.Data, TLSSecretCaCert) {
		ret.Cert = scrt.Data[TLSSecretCaCert]
		ret.CRL = scrt.Data[TLSSecretCrl]
		return ret, nil
	}

func updateSecret(ingressType CallType, scrt *v1.Secret, ic IngressCredential, isCompoundAndNotGeneric bool) *v1.Secret {
	if ingressType == Mtls {
		if isCompoundAndNotGeneric {
			scrt.Data[tlsScrtCert] = []byte(ic.Certificate)
			scrt.Data[tlsScrtKey] = []byte(ic.PrivateKey)
			scrt.Data[tlsScrtCaCert] = []byte(ic.CaCert)
			scrt.Data[tlsScrtCaCrl] = []byte(ic.Crl)
		} else {
			scrt.Data[genericScrtCert] = []byte(ic.Certificate)

			got := map[string]Expected{}
			for _, scrt := range raw {
				got[scrt.Name] = Expected{
					Key:    string(scrt.GetTlsCertificate().GetPrivateKey().GetInlineBytes()),
					Cert:   string(scrt.GetTlsCertificate().GetCertificateChain().GetInlineBytes()),
					CaCert: string(scrt.GetValidationContext().GetTrustedCa().GetInlineBytes()),
					CaCrl:  string(scrt.GetValidationContext().GetCrl().GetInlineBytes()),
				}
			}

				"--client-ca-file=" + filepath.Join(testCertsDir, "ca.crt"),
				"--tls-cert-file=" + filepath.Join(testCertsDir, "apiserver.crt"),
				"--tls-private-key-file=" + filepath.Join(testCertsDir, "apiserver.key"),
				"--kubelet-client-certificate=" + filepath.Join(testCertsDir, "apiserver-kubelet-client.crt"),
				"--kubelet-client-key=" + filepath.Join(testCertsDir, "apiserver-kubelet-client.key"),