Action<XmlProvider> elementAction = Mock()
        Action<XmlProvider> stringAction2 = Mock()
        transformer.addAction(stringAction)
        transformer.addAction(elementAction)
        transformer.addAction(nodeAction)
        transformer.addAction(stringAction2)

        when:
        def result = transformer.transform('<root/>')

        then:
        stringAction.execute(_) >> { XmlProvider provider ->

    }

    TestFile getArtifactTransformCacheDir() {
        return getGradleVersionedCacheDir().file(CacheLayout.TRANSFORMS.getName())
    }

    /**
     * Finds all cached transformed JARs named {@code jarName}.
     * @param jarName the name of the JAR to look
     * @return the list of transformed JARs in the cache
     */
    List<File> getArtifactTransformJarsByName(String jarName) {

	exprCall
	exprConvert
	exprNew
	exprMake
	exprSizeof
	exprAlignof
	exprOffsetof
	exprZero
	exprFuncInst
	exprRecv
	exprReshape
	exprRuntimeBuiltin // a reference to a runtime function from transformed syntax. Followed by string name, e.g., "panicrangeexit"
)

type codeAssign int

func (c codeAssign) Marker() pkgbits.SyncMarker { return pkgbits.SyncAssign }

    const QuantizationConfig& user_provided_config);

// Returns a copy of `QuantizationConfig` where presets are expanded and
// transformed into other fields in `QuantizationConfig`.
//
// The expansion rules are as follows:
// * StaticRangePtqPreset
//   - The preset's `representative_datasets` field will be transferred to
//   `QuantizationConfig.calibration_options.representative_datasets`, unless

    }

    def "compileModules is a transformed view of compile"() {
        given:
        compile.incoming >> incoming

        when:
        binary.compileModules.files

        then:
        1 * incoming.artifacts >> Stub(ArtifactCollection)
    }

        this.root = root;
        this.chain = chain;
    }

    /**
     * @return The transformed variant which results from applying the transform chain to the root variant.
     */
    public VariantDefinition getTransformedVariantDefinition() {
        return chain;
    }

    /**
     * @return The transform chain to apply to the root producer variant.
     */
    public TransformChain getTransformChain() {

      // Uniform Quantized op requires weights of tf.DepthwiseConv2dNative to
      // be transformed from [H,W,C,M] to [H,W,1,CxM] where
      // H=height,W=width,C=channel,M=multiplier. Therefore, a reshape op is
      // inserted between the constant op and the function op so that the
      // constant is safely transformed for the multi-use cases as well. Note

        }
        realize()

        then:
        realizeChild("foo").other == "changed"
        specialItemClass.isInstance(realizeChild("bar"))
    }

    def "can create item using transformed DSL rule closure"() {
        // DSL rules are represented using DeferredModelAction
        def action = mockDeferredModelAction()

        given:

     *
     * @return the extra info for the module
     */
    ImmutableMap<NamespaceId, String> getExtraAttributes();

    /**
     * Returns this metadata with all dependencies transformed to use the dynamic constraint version.
     */
    IvyModuleResolveMetadata withDynamicConstraintVersions();

    ImmutableList<IvyDependencyDescriptor> getDependencies();

    Table<String, Integer, String> table = HashBasedTable.create();
    checkArgument(data.length % 3 == 0);
    for (int i = 0; i < data.length; i += 3) {
      String value = (data[i + 2] == null) ? null : (data[i + 2] + "transformed");
      table.put((String) data[i], (Integer) data[i + 1], value);
    }
    return Tables.transformValues(table, FIRST_CHARACTER);
  }

  // Null support depends on the underlying table and function.