t.Helper()
	i, err := New(ctx, nsConfig)
	if err != nil {
		t.Fatalf("namespace.NewOrFail: %v", err)
	}
	return i
}

// GetAll returns all namespaces that have exist in the context.
func GetAll(ctx resource.Context) ([]Instance, error) {
	var out []Instance
	if err := ctx.GetResource(&out); err != nil {
		return nil, err
	}
	return out, nil
}

        return developerConnection;
    }

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

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

		return ErrBatchFull
	}

	if _, ok := b.items[key]; !ok {
		b.keys = append(b.keys, key)
	}
	b.items[key] = item

	return nil
}

// GetAll fetches the items and resets the batch
// Returned items are not referenced by the batch
func (b *Batch[K, T]) GetAll() (orderedKeys []K, orderedItems []T, err error) {
	b.Lock()
	defer b.Unlock()

	orderedKeys = append([]K(nil), b.keys...)
	for _, key := range orderedKeys {

              <exclude>org.apache.maven.toolchain.DefaultToolchain#getLog():METHOD_RETURN_TYPE_CHANGED</exclude>
              <exclude>org.apache.maven.toolchain.DefaultToolchain#DefaultToolchain(org.apache.maven.toolchain.model.ToolchainModel,org.codehaus.plexus.logging.Logger):CONSTRUCTOR_REMOVED</exclude>

                @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;