return developerConnection;
    }

    @Override
    public Property<String> getUrl() {
        return url;
    }

    @Override
    public Property<String> getTag() {
        return tag;
    }

                @Nested
                public abstract Params getParams();

                @TaskAction
                public void run() {
                    System.out.println("flag = " + getParams().getFlag().get());
                }
            }
        """
    }

                    params = objectFactory.newInstance(Params.class);
                }

                @TaskAction
                public void run() {
                    System.out.println("flag = " + getParams().getFlag().get());
                }
            }
        """
    }

        given:
        file('src/main/java/Test.java') << """
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

public class Test {
    private static final Log logger = LogFactory.getLog(Test.class);
}
"""

        and:
        buildFile << """
apply plugin: 'java'

${mavenCentralRepository()}

dependencies {
    compileOnly 'commons-logging:commons-logging:1.2'
}
"""

    @Override
    public int size() {
        return 1;
    }

    @Override
    public boolean isFixedSize() {
        return true;
    }

    @Override
    public Set<ConfigurationInternal> getAll() {
        return ImmutableSet.of(theOnlyConfiguration);
    }

    @Override
    public void visitAll(Consumer<ConfigurationInternal> visitor) {
        visitor.accept(theOnlyConfiguration);
    }

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.api.publish.ivy.internal.dependency;

public interface IvyExcludeRule {
    String getOrg();
    String getModule();
    String getConf();

  auto pflr = std::make_unique<ProcessFunctionLibraryRuntime>(
      nullptr, options.session_options->env, /*config=*/nullptr,
      TF_GRAPH_DEF_VERSION, options.flib_def, opts);
  FunctionLibraryRuntime* flr =
      pflr->GetFLR(ProcessFunctionLibraryRuntime::kDefaultFLRDevice);

  for (Node* node : graph->nodes()) {
    if (CanCreateXlaKernel(node->def())) {
      const FunctionBody* fbody = nullptr;
      std::vector<int> constant_arg_indices;

				RouteRule:        "tcp",
				ServiceIndex:     i,
				DestinationIndex: j,
				Destination:      rd.GetDestination(),
			})
		}
	}
	for i, r := range vs.GetTls() {
		for j, rd := range r.GetRoute() {
			destinations = append(destinations, &AnnotatedDestination{
				RouteRule:        "tls",
				ServiceIndex:     i,
				DestinationIndex: j,

        withConnection {
            it.newBuild().forTasks(":a:taskC")
                .addProgressListener(events, OperationType.BUILD_PHASE)
                .run()
        }

        then:
        events.getAll().isEmpty()
    }

    def setupProject() {
        settingsFile << """
            rootProject.name = 'root'
            include 'a'
        """
        file("a/build.gradle") << """
            task taskA {}

                for (GradleModuleServices services : servicesProviders) {
                    services.registerGlobalServices(registration);
                }
            }
        });
        ServiceRegistry services = builder.build();
        this.typeSchemes = services.getAll(TypeScheme.class);
    }