import org.gradle.internal.buildoption.BuildOptionSet;

import java.util.Map;

public class BuildOptionBackedConverter<T> {
    private final BuildOptionSet<T> buildOptions;

    public BuildOptionBackedConverter(BuildOptionSet<T> buildOptions) {
        this.buildOptions = buildOptions;
    }

    public void configure(CommandLineParser parser) {
        buildOptions.commandLineConverter().configure(parser);
    }

    @Rule TestNameTestDirectoryProvider tmpDir = new TestNameTestDirectoryProvider(getClass())
    final buildOptions = Mock(ToolchainConfiguration)

    @Subject
    def supplier = new LocationListInstallationSupplier(buildOptions, new IdentityFileResolver())

    def "supplies no installations for empty property"() {
        when:
        buildOptions.installationsFromPaths >> []
        def directories = supplier.get()

        then:

    private final ToolchainConfiguration buildOptions;
    private final FileResolver fileResolver;
    private final Map<String, String> environment;

    @Inject
    public EnvironmentVariableListInstallationSupplier(ToolchainConfiguration buildOptions, FileResolver fileResolver, Map<String, String> environment) {
        this.buildOptions = buildOptions;
        this.fileResolver = fileResolver;

    private final ToolchainConfiguration buildOptions;
    private final FileResolver fileResolver;

    @Inject
    public LocationListInstallationSupplier(ToolchainConfiguration buildOptions, FileResolver fileResolver) {
        this.buildOptions = buildOptions;
        this.fileResolver = fileResolver;
    }

    @Override
    public String getSourceName() {

    final buildOptions = Mock(ToolchainConfiguration)
    final jdk8 = tmpDir.createDir("jdk8")
    final jdk9 = tmpDir.createDir("jdk9")
    final Map<String, String> environment = [JDK8: jdk8.absolutePath, JDK9: jdk9.absolutePath]

    @Subject
    def supplier =  new EnvironmentVariableListInstallationSupplier(buildOptions, new IdentityFileResolver(), environment)

        }
        DiagnosticCollector<JavaFileObject> ds = new DiagnosticCollector<>();
        try (StandardJavaFileManager mgr = compiler.getStandardFileManager(ds, null, null)) {
            List<String> options = buildOptions(dstDir, classPath);
            List<File> filesToCompile = outputSourceFilesToSourceDir(srcDir, classes);
            if (dstDir.exists() || dstDir.mkdirs()) {

		_, err := rb.Build(resolver.Target{URL: url.URL{
			Scheme: "xds",
			Path:   "/" + net.JoinHostPort(testSvcHost, xdsPorts),
		}},
			&testClientConn{stateCh: stateCh, errorCh: errorCh}, resolver.BuildOptions{
				Authority: testSvcHost,
			})
		if err != nil {
			t.Fatal("Failed to resolve XDS ", err)
		}
		tm := time.After(10 * time.Second)
		select {
		case s := <-stateCh:
			t.Log("Got state ", s)

 * 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 org.gradle.internal.buildoption;

import org.gradle.cli.CommandLineParser;
import org.gradle.cli.ParsedCommandLine;

import javax.annotation.Nullable;
import java.util.Map;

/**

import static org.gradle.internal.buildoption.BuildOptionFixture.SHORT_OPTION
import static org.gradle.internal.buildoption.BuildOptionFixture.assertDeprecatedDescription
import static org.gradle.internal.buildoption.BuildOptionFixture.assertDescription
import static org.gradle.internal.buildoption.BuildOptionFixture.assertSingleArgument

class IntegerBuildOptionTest extends Specification {

  xla::ExecutableBuildOptions build_options;
  if (result.collective_info) {
    build_options.set_num_replicas(result.collective_info->group_size);
  }
  if (options.device_ordinal != -1) {
    build_options.set_device_ordinal(options.device_ordinal);
  } else if (default_device_ordinal != -1) {
    build_options.set_device_ordinal(default_device_ordinal);
  }
  build_options.set_result_layout(result.xla_output_shape);