moduleNode = bytecodeLevelConfiguration.appendNode("module");
                    setNodeAttribute(moduleNode, "name", module.getName());
                }
                setNodeAttribute(moduleNode, "target", moduleBytecodeVersionOverwrite.toString());
            }
        }
    }

    private void storeVcs() {
        if (!isNullOrEmpty(vcs)) {

                        for (Node moduleNode : Cast.<List<Node>>uncheckedCast(child.children())) {
                            String moduleNodeLocalName = localNameOf(moduleNode);
                            if (moduleNodeLocalName.equals("web")) {
                                String webUri = childNodeText(moduleNode, "web-uri");
                                String contextRoot = childNodeText(moduleNode, "context-root");

            return addNode(graph.moduleNode(moduleVersionId))
        }

        /**
         * Defines a dependency on the given external module. The closure delegates to a {@link NodeBuilder} instance that represents the target node.
         */
        NodeBuilder module(String moduleVersionId, @DelegatesTo(NodeBuilder) Closure cl) {
            def node = addNode(graph.moduleNode(moduleVersionId))
            applyTo(node, cl)

       NoVariablesSavedWhenNoInitializerFunction) {
  constexpr absl::string_view kModuleCode = R"mlir(
    module attributes {tf_saved_model.semantics} {
      "tf_saved_model.session_initializer"() {initializers = []} : () -> ()
    }
  )mlir";

  mlir::OwningOpRef<mlir::ModuleOp> module_op_ref =
      ParseModuleOpString(kModuleCode);

  const absl::StatusOr<std::string> checkpoint_prefix = MakeTempDir();

namespace {

using ::testing::NotNull;
using ::testing::SizeIs;

using ConstantFoldingTest = ::mlir::quant::QuantizationTestBase;

TEST_F(ConstantFoldingTest, FoldLargeConstant) {
  constexpr absl::string_view kModuleCode = R"mlir(
    module {
      func.func @test_fold_constant() -> (tensor<1024x24x24x3xf32>) {
        %zp = "tf.Const"() {value = dense<2> : tensor<i32>} : () -> tensor<i32>

		}
	}
	return ""
}

// ModuleMode specifies whether to prefer modules when looking up code sources.
type ModuleMode int

const (
	IgnoreMod ModuleMode = iota
	PreferMod
)

// RepoRootForImportPath analyzes importPath to determine the
// version control system, and code repository to use.
func RepoRootForImportPath(importPath string, mod ModuleMode, security web.SecurityMode) (*RepoRoot, error) {

                model.getProject().natures("org.eclipse.wst.common.project.facet.core.nature");
                model.getProject().natures("org.eclipse.wst.common.modulecore.ModuleCoreNature");
                model.getProject().natures("org.eclipse.jem.workbench.JavaEMFNature");
            }

        };
        project.getPlugins().withType(JavaPlugin.class, action);