source is a memory reference, then it is a load.

MOV{B,H,W,D} variations identify the size as byte, halfword, word, doubleword.

Adding 'Z' to the opcode for a load indicates zero extend; if omitted it is sign extend.
Adding 'U' to a load or store indicates an update of the base register with the offset.
Adding 'BR' to an opcode indicates byte-reversed load or store, or the order opposite

1. *Specify a file on the command line* with the option `-I` or `--init-script` followed by the path to the script.
+
The command line option can appear more than once, each time adding another init script. The build will fail if any files specified on the command line do not exist.
2. *Put a file called `init.gradle(.kts)`* in the `__$<<directory_layout.adoc#dir:gradle_user_home,GRADLE_USER_HOME>>__/` directory.

        file('gradle/javadocs/jetbrains-annotations/package-list') << ''

        expect:
        succeeds("javadoc")
    }

    @Issue("https://github.com/gradle/gradle/issues/4841")
    def "adding custom javadoc options makes task out-of-date"() {
        given: "a javadoc task without custom options"
        buildFile << """
            task javadoc(type: Javadoc) {

                "reference a platform (" + DOCUMENTATION_REGISTRY.getDocumentationRecommendationFor("platforms", "platforms") + "). " +
                "Disable this check by adding 'dependencies-without-versions' to the suppressed validations of the " + taskPath + " task.");
        }
    }

    public void validateAttributes(String variant, String group, String name, AttributeContainer attributes) {

	if runtime.GOOS == "windows" {
		t.Skip("Skipping test that fails on Windows")
	}

	dsw := NewDesiredStateOfWorld()
	socketPath := "/var/lib/kubelet/device-plugins/test-plugin.sock"
	// Adding the plugin for the first time
	err := dsw.AddOrUpdatePlugin(socketPath)
	if err != nil {
		t.Fatalf("AddOrUpdatePlugin failed. Expected: <no error> Actual: <%v>", err)
	}

Each dialect consists of a set of defined operations which have invariants
placed on them, like: “This is a binary operator, and the inputs and outputs
have the same types.”

## Adding to MLIR

MLIR has no fixed/built-in list of globally known operations (no “intrinsics”).
Dialects can define entirely custom types, which is how MLIR can model things

     *
     * #### Examples
     *
     *  - The name of the module is being changed.
     *  - The module's content roots are being changed, such as adding another source folder to a source module.
     *  - If module A depends on module B and module B is being removed, in addition to the removal event for module B, module A also
     *    receives an update event.
     */

type NewInformerFunc func(versioned.Interface, time.Duration) cache.SharedIndexInformer

// SharedInformerFactory a small interface to allow for adding an informer without an import cycle
type SharedInformerFactory interface {
	Start(stopCh <-chan struct{})
	InformerFor(obj runtime.Object, newFunc NewInformerFunc) cache.SharedIndexInformer
}

        }

        @Override
        public PatternSet create() {
            return new InternalPatternSet(patternSpecFactory);
        }
    }

    // This is only required to avoid adding a new public constructor to the public `PatternSet` type.
    private static class InternalPatternSet extends PatternSet {
        public InternalPatternSet(PatternSpecFactory patternSpecFactory) {

import org.gradle.util.TestUtil
import spock.lang.Specification

class EclipseProjectTest extends Specification {

    def eclipseProject = TestUtil.newInstance(EclipseProject, Mock(XmlFileContentMerger))

    def "allows adding linked resources"() {
        when:
        eclipseProject.linkedResource(name: 'foo', type: 'folder', location: '/stuff/foo')
        eclipseProject.linkedResource(name: 'bar', type: 'uri', locationUri: 'file:///stuff/bar')