// 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() {

        registry.realize("parent") // TODO - should not need this: parent mutations should be applied before mutating element

        expect:
        registry.realize("parent.bar", Bean).value == "prefix: bar"
        registry.realize("parent.foo", String) == "ignore me"
        registry.realize("parent.bar.child1", Bean).value == "prefix: baz"
        registry.realize("parent.bar.child2", String) == "ignore me too"

    }

    void realize() {
        registry.realizeNode(path)
    }

    void selfClose() {
        registry.atState(path, ModelNode.State.SelfClosed)
    }

    ModelMap<T> realizeAsModelMap() {
        registry.realize(path, modelMapType)
    }

    T realizeChild(String name) {
        registry.realize(path.child(name), itemType)
    }