1 * target.text >> 'content'
        0 * target._
    }

    def fetchesAndCachesContentWhenContentQueriedAsReader() {
        when:
        assert resource.asReader.text == 'content'
        assert resource.exists
        assert resource.asReader.text == 'content'

        then:
        1 * target.text >> 'content'
        0 * target._
    }

    def fetchesAndCachesContentWhenContentIsEmptyIsChecked() {

        /**
         * See {@code org.gradle.api.internal.project.taskfactory.TaskIdentity#uniqueId}.
         */
        long getTaskId();

        boolean isReplacement();

        boolean isEager();
    }

    public interface Result {
    }

    private RealizeTaskBuildOperationType() {
    }

                <tr>
                    <td>Name</td>
                </tr>
            </thead>
            <tr>
                <td>asString</td>
            </tr>
            <tr>
                <td>asReader</td>
            </tr>
            <tr>
                <td>asFile</td>
            </tr>
        </table>
    </section>

    public TextResource getTemplate() {
        return template;
    }

    private String generateStartScriptContentFromTemplate(final Map<String, String> binding) {
        try (Reader reader = getTemplate().asReader()) {
            SimpleTemplateEngine engine = new SimpleTemplateEngine();
            Template template = engine.createTemplate(reader);
            String output = template.make(binding).toString();

        serializedModel = interpolate(serializedModel, model, projectDir, config, debugEnabled);

        StringReader sReader = new StringReader(serializedModel);

        MavenStaxReader modelReader = new MavenStaxReader();
        try {
            model = new Model(modelReader.read(sReader));
        } catch (XMLStreamException e) {
            throw new ModelInterpolationException(

					if err := controlHandler(hdr, &wsReader); err != nil {
						return nil, err
					}
					continue
				}
				if hdr.OpCode&want == 0 {
					if err := wsReader.Discard(); err != nil {
						return nil, err
					}
					continue
				}
				if int64(cap(dst)) < hdr.Length+1 {
					dst = make([]byte, 0, hdr.Length+hdr.Length>>3)
				}
				return readAllInto(dst[:0], &wsReader)
			}
		}

    -l ${ADDON_MANAGER_LABEL}=EnsureExists --recursive 2>&1 | grep -v AlreadyExists

  log INFO "== Kubernetes addon ensure completed at $(date -Is) =="
}

function is_leader() {
  # In multi-master setup, only one addon manager should be running. We use
  # existing leader election in kube-controller-manager instead of implementing
  # a separate mechanism here.

            return identity.uniqueId;
        }

        @Override
        public boolean isReplacement() {
            return replacement;
        }

        @Override
        public boolean isEager() {
            return eager;
        }

    }

    private static final class RegisterDetails implements RegisterTaskBuildOperationType.Details {

        private final TaskIdentity<?> identity;