}

func TestRESTMapperAdmissionPlugin(t *testing.T) {
	initializer := initializer.New(nil, nil, nil, &TestAuthorizer{}, nil, nil, &doNothingRESTMapper{})
	wantsRESTMapperAdmission := &WantsRESTMapperAdmissionPlugin{}
	initializer.Initialize(wantsRESTMapperAdmission)

	if wantsRESTMapperAdmission.mapper == nil {
		t.Errorf("Expected REST mapper to be initialized but found nil")
	}
}

  "tf_saved_model.asset"() {filename = "assets/table.txt", sym_name = "v"} : () -> ()
  "tf_saved_model.session_initializer"() {initializers = [@NoOp_0, @NoOp_1]} : () -> ()
// Check that the initializer typed "init_op" is removed from initializers list.
// CHECK: "tf_saved_model.session_initializer"()
// CHECK-SAME: initializers = []

func.func @NoOp_0(%arg0: tensor<!tf_type.string> {tf_saved_model.bound_input = @v})

        protected Class<T> cls;

        protected Consumer<T> initializer;

        protected StandardCrawlerContainer container;

        private T instance;

        protected ComponentDef(final Class<T> cls, final Consumer<T> initializer, final StandardCrawlerContainer container) {
            this.cls = cls;
            this.initializer = initializer;
            this.container = container;
        }

module attributes {tf_saved_model.semantics} {
}

// -----

// Nothing happens when there are no initializer functions.

// CHECK-LABEL: module
module attributes {tf_saved_model.semantics} {
  "tf_saved_model.session_initializer"() {initializers = []} : () -> ()
}

// -----

// Nothing happens when the initializer function of type = "restore_op" is
// empty.

// CHECK-LABEL: module

class Input {
 public:
  /// Initializer enables constructing an Input object from various kinds of C++
  /// constants such as simple primitive constants and nested initializer lists
  /// representing a multi-dimensional array. Initializer constructors are all
  /// templates, so the aforementioned kinds of C++ constants can be used to
  /// construct an Initializer. Initializer stores the value it got constructed

namespace ops {

/// @defgroup const_op Const Op
/// @{

Output Const(const Scope& scope, const Input::Initializer& val);

Output ConstFromProto(const Scope& scope, const TensorProto& proto);

NodeBuilder::NodeOut AsNodeOut(const Scope& scope, const Input& inp);

template <typename T>
Output Const(const Scope& scope, const Input::Initializer& val) {
  auto orig_const_output = Const(scope, val);
  if (!scope.ok()) return Output();

// Returns the session initializer of this module if it exists. Returns null
// otherwise.
SessionInitializerOp GetSessionInitializerOp(ModuleOp module_op);

// Returns the exported name for the session initializer function.
SmallVector<StringRef, 2> GetSessionInitializerExportedName(ModuleOp module_op);

// Returns initializer function ops. These functions' symbols are in the

    }
  }
  return inputs;
}

Input::Initializer::Initializer(
    const std::initializer_list<Input::Initializer>& v) {
  if (v.size() < 1) {
    // Empty initializer list defaults to float tensor with shape (0,)
    tensor = Tensor(DT_FLOAT, TensorShape{0});
    return;
  }
  auto const& first = *v.begin();
  // Check to make sure that the constituent Initializers are all the same
  // type and same shape.

 */
public class GenerationSettings {
    private final BuildInitializer initializer;
    private final InitSettings settings;

    public GenerationSettings(BuildInitializer initializer, InitSettings settings) {
        this.initializer = initializer;
        this.settings = settings;
    }

    public BuildInitializer getInitializer() {
        return initializer;
    }

    public InitSettings getSettings() {

  StringRef getArgument() const override {
    return "quant-merge-initializer-function-ops-to-main";
  }

  StringRef getDescription() const override {
    return "Moves all ops from the initializer functions to the main function. "
           "A new `tf.NoOp` that has a control dependency to the initializer "
           "function for non-variable resources will be created. Its control "