Message string `json:"message,omitempty"`
	// Path to the device attached. This field is valid only for attach calls.
	// ie: /dev/sdx
	DevicePath string `json:"device,omitempty"`
	// Cluster wide unique name of the volume.
	VolumeName string `json:"volumeName,omitempty"`
	// Represents volume is attached on the node
	Attached bool `json:"attached,omitempty"`
	// Returns capabilities of the driver.

  }'
  exit 0
elif [ "$1" == "getvolumename" -a $# -eq 4 ]; then
  echo -n '{
    "status": "Success",
    "volume": "fakevolume"
  }'
  exit 0
elif [ "$1" == "isattached" -a $# -eq 2 ]; then
  echo -n '{
    "status": "Success",
    "attached": true
  }'
  exit 0
fi

echo -n '{
  "status": "Not supported"
}'
exit 1

# Direct the arguments to a file to be tested against later

func TestIsVolumeAttached(tt *testing.T) {
	t := harness.For(tt)
	defer t.Close()

	spec := fakeVolumeSpec()

	plugin, _ := testPlugin(t)
	plugin.runner = fakeRunner(
		assertDriverCall(t, notSupportedOutput(), isAttached, specJSON(plugin, spec, nil), "localhost"),
	)
	a, _ := plugin.NewAttacher()
	specs := []*volume.Spec{spec}
	a.VolumesAreAttached(specs, "localhost")

		call := a.plugin.NewDriverCall(isAttached)
		call.AppendSpec(spec, a.plugin.host, nil)
		call.Append(string(nodeName))

		status, err := call.Run()
		if isCmdNotSupportedErr(err) {
			return nil, nil
		} else if err == nil {
			if !status.Attached {
				volumesAttachedCheck[spec] = false
				klog.V(2).Infof("VolumesAreAttached: check volume (%q) is no longer attached", spec.Name())
			}
		} else {

    ATTACHED(true),
    NOT_ATTACHED(false);

    private final boolean attached;

    FallbackConsoleMetaData(boolean attached) {
        this.attached = attached;
    }

    @Override
    public boolean isStdOut() {
        return attached;
    }

    @Override
    public boolean isStdErr() {
        return attached;
    }

    @Override

    }

    public List<ArtifactVersion> getAvailableVersions() {
        return parent.getAvailableVersions();
    }

    public void setAvailableVersions(List<ArtifactVersion> availableVersions) {
        throw new UnsupportedOperationException("Cannot change the version information for an attached artifact."

     */
    Plain,
    /**
     * Enable color and rich output when the current process is attached to a console, disable when not attached to a console.
     */
    Auto,
    /**
     * Enable color and rich output, regardless of whether the current process is attached to a console or not.
     * When not attached to a console, the color and rich output is encoded using ANSI control characters.
     */
    Rich,
    /**

public enum ConsoleAttachment {
    NOT_ATTACHED("not attached to a console", null),
    ATTACHED("console attached to both stdout and stderr", TestConsoleMetadata.BOTH),
    ATTACHED_STDOUT_ONLY("console attached to stdout only", TestConsoleMetadata.STDOUT_ONLY),
    ATTACHED_STDERR_ONLY("console attached to stderr only", TestConsoleMetadata.STDERR_ONLY);

    private final String description;

	newAttachment := va.DeepCopy()
	newAttachment.Status.Attached = true
	Strategy.PrepareForUpdate(context.TODO(), newAttachment, va)
	if newAttachment.Status.Attached {
		t.Errorf("expected status to be %v got %v", false, newAttachment.Status.Attached)
	}
}

func TestCreatePreventsStatusWrite(t *testing.T) {
	va := getValidVolumeAttachment("valid-attachment")
	va.Status.Attached = true
	Strategy.PrepareForCreate(context.TODO(), va)

            ProjectConnection connection ->
                connection.model(BuildInvocations).forTasks('assemble').addProgressListener(events).get()
        }

        then: "progress events must be forwarded to the attached listeners"
        events.assertIsABuild()
    }

    def "receive progress events when launching a build"() {
        given:
        goodCode()

        when: "launching a build"