}

        @Override
        public long getDocumentSize() {
            return documentCount.get();
        }

        @Override
        public long getExecuteTime() {
            executeTime.set(System.currentTimeMillis() - startTime);
            return executeTime.get();
        }

        @Override
        public void commit() {
            committed.set(true);

 * with the methods in {@link Futures} or, if necessary, to extend {@link AbstractFuture}.
 *
 * <p>Occasionally, an API will return a plain {@code Future} and it will be impossible to change
 * the return type. For this case, we provide a more expensive workaround in {@code
 * JdkFutureAdapters}. However, when possible, it is more efficient and reliable to create a {@code

        }
    }

    /**
     * Extracts text from the input stream using the API endpoint.
     *
     * @param in the input stream to extract text from
     * @param params additional parameters
     * @return the extracted data
     * @throws ExtractException if extraction fails
     */
    @Override
    public ExtractData getText(final InputStream in, final Map<String, String> params) {
        if (logger.isDebugEnabled()) {

          <code>
            <![CDATA[
    /**
     * Gets the identifier of the extension.
     *
     * @return The extension id in the form {@code <groupId>:<artifactId>:<version>}, never {@code null}.
     */
    public String getId() {
        return (getGroupId() == null ? "[unknown-group-id]" : getGroupId())
            + ":" + (getArtifactId() == null ? "[unknown-artifact-id]" : getArtifactId())

     * Note that the artifact need not actually exist yet at
     * the returned location, the path merely indicates where
     * the artifact would eventually be stored.
     *
     * @param session The session to use, must not be {@code null}.
     * @param artifact The artifact for which to determine the path, must not be {@code null}.
     * @return The path, resolved against the local repository's base directory.
     */
    @Nonnull

	for scanner.Scan() {
		f := strings.Fields(scanner.Text())
		if len(f) < 3 {
			continue
		}
		syms[f[2]] = f[0]
	}
	if err := scanner.Err(); err != nil {
		t.Fatalf("error reading symbols: %v", err)
	}
	return syms
}

func runAddr2Line(t *testing.T, dbgExePath, addr string) (funcname, path, lineno string) {
	cmd := testenv.Command(t, testenv.Executable(t), dbgExePath)
	cmd.Stdin = strings.NewReader(addr)

)

type badDisk struct{ StorageAPI }

func (a badDisk) String() string {
	return "bad-disk"
}

func (a badDisk) AppendFile(ctx context.Context, volume string, path string, buf []byte) error {
	return errFaultyDisk
}

func (a badDisk) ReadFileStream(ctx context.Context, volume, path string, offset, length int64) (io.ReadCloser, error) {
	return nil, errFaultyDisk
}

        switch (status) {
        case INITIALIZING:
            return "Crawler is initializing";
        case RUNNING:
            return "Crawler is running";
        case DONE:
            return "Crawler has completed";
        default:
            fail("Unexpected status: " + status);
            return null;
        }
    }

    /**
     * Test state transitions (typical workflow)

  }

  absl::optional<std::vector<int64_t>> make_shape(
      std::vector<int64_t>&& dims) const {
    return absl::make_optional(dims);
  }

  absl::optional<std::vector<int64_t>> unknown_shape() const {
    return absl::nullopt;
  }

  static constexpr int64_t kUnknownDim =
      shape_inference::InferenceContext::kUnknownDim;
  TF_Status* status_;

        SMBUtil.writeInt4(this.length, dst, dstIndex);
        dstIndex += 4;
        dstIndex += 4; // reserved
        return dstIndex - start;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.Encodable#size()
     */
    @Override
    public int size() {
        return 24;
    }