when:
        def javaToolchain = new JavaToolchain(metadata, TestFiles.fileFactory(), Mock(JavaToolchainInput) {
            getLanguageVersion() >> JavaLanguageVersion.of(languageVersion)
            getVendor() >> DefaultJvmVendorSpec.any().toString()
            getImplementation() >> JvmImplementation.VENDOR_SPECIFIC.toString()
        }, false)
        then:
        javaToolchain.languageVersion.asInt() == languageVersion

        DefaultSwiftcMetadata(String versionString, VersionNumber version) {
            this.versionString = versionString;
            this.version = version;
        }

        @Override
        public String getVendor() {
            return versionString;
        }

        @Override
        public VersionNumber getVersion() {
            return version;
        }
    }

            getJavaHome() >> getJavaHome(implementationVersion, isJdk, installPath).toPath()
            hasCapability(JvmInstallationMetadata.JavaInstallationCapability.JAVA_COMPILER) >> isJdk
            getVendor() >> jvmVendor.asJvmVendor()
            getJavaVersion() >> implementationVersion
        }
    }

        when:
        def spec = TestUtil.objectFactory().newInstance(DefaultToolchainSpec)
        spec.getLanguageVersion().set(JavaLanguageVersion.of(javaVersion.getMajorVersion()))
        spec.getVendor().set(vendor)
        spec.getImplementation().set(implementation)

        then:
        new JvmInstallationMetadataMatcher(spec).test(metadata)

        where:

        return new VersionAwareCompiler<T>(compiler, new DefaultCompilerVersion(
            metadataProvider.getCompilerType().getIdentifier(),
            gccMetadata.getComponent().getVendor(),
            gccMetadata.getComponent().getVersion())
        );
    }

    @Override
    protected Compiler<CCompileSpec> createCCompiler() {

    }

    public static String getInstallFolderName(JvmInstallationMetadata metadata) {
        String vendor = metadata.getJvmVendor();
        if (vendor == null || vendor.isEmpty()) {
            vendor = metadata.getVendor().getRawVendor();
        }
        String version = metadata.getLanguageVersion().getMajorVersion();
        String architecture = metadata.getArchitecture();
        String os = OperatingSystem.current().getFamilyName();

        }

        @Override
        public ArchitectureInternal getDefaultArchitecture() {
            return architecture;
        }

        @Override
        public String getVendor() {
            return scrapedVendor;
        }
    }

            @Override
            public VersionNumber getVisualStudioVersion() {
                return visualStudio.getVersion();
            }

            @Override
            public String getVendor() {
                return "Microsoft";
            }

            @Override
            public VersionNumber getVersion() {
                return visualCpp.getImplementationVersion();
            }

  Tensor out;
  test::GetTensor(root, c1, &out);
  test::ExpectTensorEqual<float>(out, Tensor(DT_FLOAT, {0}));

  auto c2 = ops::Const(root, {{}});
  TF_CHECK_OK(root.status());
  test::GetTensor(root, c2, &out);
  test::ExpectTensorEqual<float>(out, Tensor(DT_FLOAT, {1, 0}));

  auto c3 = ops::Const(root, {{{}, {}}});
  TF_CHECK_OK(root.status());
  test::GetTensor(root, c3, &out);

namespace test {

void GetTensors(const Scope& scope, OutputList tensors,
                std::vector<Tensor>* out) {
  ClientSession session(scope);
  TF_CHECK_OK(session.Run(tensors, out));
}

void GetTensor(const Scope& scope, Output tensor, Tensor* out) {
  std::vector<Tensor> outputs;
  GetTensors(scope, {std::move(tensor)}, &outputs);
  *out = outputs[0];
}