bool smuggle_disallowed_ops);

// This function is a common entry point for all graph optimizations that are
// not specific to any hardware. It legalizes SHLO->MHLO, does MHLO->MHLO
// optimizations by calling `AddMhloOptimizationPasses` internally, and
// legalizes MHLO->SHLO
void AddStablehloOptimizationPasses(OpPassManager& pm);

// Adds all the backend-agonstic stableHLO optimization passes

      Value value, const std::string& name, unsigned buffer_idx,
      const std::optional<BufferOffset<tflite::QuantizationParameters>>&
          quant_parameters);

  // TODO(b/137395003): Legalize tf.IfOp to TFLite dialect, and change the
  // following method to handle TFL::IfOp.
  BufferOffset<tflite::Operator> BuildIfOperator(
      mlir::TF::IfOp op, const std::vector<int32_t>& operands,

// Create a pass that legalizes MHLO to TF dialect.
std::unique_ptr<OperationPass<ModuleOp>> CreateLegalizeHloToTfPass();

// Creates a pass which replaces a splat constant tensor with a BroadcastInDim
// op.
std::unique_ptr<OperationPass<ModuleOp>> CreateUnfoldSplatConstantPass();

// Create a pass that legalizes MHLO to TFLite dialect.

        }

        then:
        def list = registry.realize(collectionPath, collectionType)
        list == checkable(['bar'])
    }

    def "can remove all elements"() {
        when:
        mutate {
            add 'foo'
            add 'bar'
            clear()
        }

        then:
        def list = registry.realize(collectionPath, collectionType)
        list == checkable([])
    }

//
// For more details on backpropagation for convolution of which `AvgPoolGrad`
// is a special case see `tensorflow/core/kernels/conv_grad_ops.h`.
// `tensorflow/compiler/mlir/xla/tests/legalize-tf.mlir` has more
// examples for different cases.
template <typename OpTy, int num_dims>
class ConvertAvgPoolGradOp : public OpRewritePattern<OpTy> {
  using DimVector = SmallVector<int64_t, num_dims>;

            remove(1)
        }

        then:
        def list = registry.realize(collectionPath, collectionType)
        list == checkable(['foo', 'baz'])
    }

    def "can add using index"() {
        when:
        mutate {
            add 'foo'
            add(0, 'bar')
        }

        then:
        def list = registry.realize(collectionPath, collectionType)
        list == ['bar', 'foo']

    }

        registry.registerWithInitializer("foo", NamedThingInterface, nodeInitializerRegistry)

        then:
        registry.realize("foo", NamedThingInterface).name == "foo"

        when:
        registry.registerWithInitializer("bar", NamedThingInterface, nodeInitializerRegistry)

        then:
        registry.realize("bar", NamedThingInterface).name == "bar"
    }


    @Managed
    static abstract class NonNamedThing {

        then:
        def set = registry.realize(collectionPath, collectionType)
        def e1 = set.find { it.name == '1' }
        def e2 = set.find { it.name == '1' }
        e1.is(e2)
    }

    def "can query set size"() {
        when:
        mutate {
            create { name = '1' }
            create { name = '2' }
        }

        then:
        !registry.realize(collectionPath, collectionType).isEmpty()

    if (IsSupportedTFCustomOp(op)) return WalkResult::advance();

    // Check for ops that are legalized to TFLite.
    if (op->getDialect()->getNamespace() == "tfl") {
      return WalkResult::advance();
    }
    // Check for ops that are not legalized to TFLite.
    if (IsSupportedTFDataForwardingOp(op)) {
      return WalkResult::advance();
    }

        final Calendar local = CalendarConversionUtil.localize(calendar);
        assertEquals(TimeZone.getDefault(), local.getTimeZone());
    }

    /**
     * Test method for
     * {@link org.codelibs.core.convert.CalendarConversionUtil#localize(Calendar)}
     * .
     */
    @Test
    public void testCreateAndCopySrcNull() {