@Override
    @BeforeEach
    public void setUp() throws Exception {
        super.setUp();

        ArtifactResolver resolver = getContainer().lookup(ArtifactResolver.class, "classpath");
        DefaultArtifactDescriptorReader pomReader =
                (DefaultArtifactDescriptorReader) getContainer().lookup(ArtifactDescriptorReader.class);
        Field field = DefaultArtifactDescriptorReader.class.getDeclaredField("artifactResolver");

    public LastaCrawlerContainer() {
        initialize();
    }

    @Override
    public <T> T getComponent(final String name) {
        return SingletonLaContainerFactory.getContainer().getComponent(name);
    }

    @Override
    public boolean available() {
        return SingletonLaContainerFactory.hasContainer();
    }

    @Override
    public void destroy() {

        return new DefaultModelResolver(
                this.session,
                null,
                this.getClass().getName(),
                getContainer().lookup(ArtifactResolver.class),
                getContainer().lookup(VersionRangeResolver.class),
                getContainer().lookup(RemoteRepositoryManager.class),
                Arrays.asList(newTestRepository()));
    }

    container = "";
    shared_name = global.getSymName();
  } else if (auto handle = llvm::dyn_cast<TF::VarHandleOp>(source)) {
    container = handle.getContainer();
    shared_name = handle.getSharedName();
  } else if (auto it = llvm::dyn_cast<TF::IteratorOp>(source)) {
    container = it.getContainer();
    shared_name = it.getSharedName();
  } else {
    // Can't happen, as long as this file and resource_dataflow.cc are in sync.
    return;

				Port:   intstr.FromInt32(8080),
				Scheme: "scheme",
			},
			TCPSocket: &v1.TCPSocketAction{
				Port: intstr.FromString("80"),
			},
		},
	}
	container := &v1.Container{
		Name:                   "test_container",
		TerminationMessagePath: "/somepath",
		Lifecycle:              lifecycle,
	}
	pod := &v1.Pod{
		ObjectMeta: metav1.ObjectMeta{
			Name:                       "test_pod",

    protected String getProjectsDirectory() {
        return "src/test/projects/lifecycle-listener";
    }

    @Test
    void testDependencyInjection() throws Exception {
        PlexusContainer container = getContainer();

        ComponentDescriptor<? extends AbstractMavenLifecycleParticipant> cd =
                new ComponentDescriptor<>(InjectDependencyLifecycleListener.class, container.getContainerRealm());

        MavenSession session = new MavenSession(
                getContainer(), configuration.getRepositorySession(), request, new DefaultMavenExecutionResult());
        session.setProjects(projects);
        session.setAllProjects(session.getProjects());
        session.setSession(defaultSessionFactory.newSession(session));

        SessionScope sessionScope = getContainer().lookup(SessionScope.class);
        sessionScope.enter();

limitations under the License.
*/

package container

import (
	"encoding/json"
	"testing"

	"k8s.io/api/core/v1"
)

var (
	sampleContainer = `
{
  "name": "test_container",
  "image": "foo/image:v1",
  "command": [
    "/bin/testcmd"
  ],
  "args": [
    "/bin/sh",
    "-c",
    "echo abc"
  ],
  "ports": [
    {
      "containerPort": 8001
    }
  ],

        {mlir::cast<TensorType>(ref_qtype)}, builder.getContext()));
    auto new_var_handle_op = builder.create<VarHandleOp>(
        var_handle_op.getLoc(), output_type, var_handle_op.getContainer(),
        var_handle_op.getSharedName());
    var_handle_op->replaceAllUsesWith(new_var_handle_op);
    var_handle_op.erase();
  }
}

void QuantizeVariablesPass::runOnOperation() {

        SingletonLaContainerFactory.getContainer().register(CrawlingInfoHelper.class, "crawlingInfoHelper");
        SingletonLaContainerFactory.getContainer().register(PathMappingHelper.class, "pathMappingHelper");
        SingletonLaContainerFactory.getContainer().register(CrawlingConfigHelper.class, "crawlingConfigHelper");
        SingletonLaContainerFactory.getContainer().register(SystemHelper.class, "systemHelper");