}
  ~WritableFileRawStream() override = default;

  uint64_t current_pos() const override {
    int64_t position;
    if (file->Tell(&position).ok()) {
      return position;
    } else {
      // MLIR uses os.tell() to determine whether something was written by
      // a subroutine or not, so it's important we have a working current_pos().
      LOG(WARNING)

struct WritableFileRawStream : public llvm::raw_ostream {
  explicit WritableFileRawStream(WritableFile* file) : file(file) {
    SetUnbuffered();
  }
  ~WritableFileRawStream() override = default;
  uint64_t current_pos() const override { return 0; }

  void write_impl(const char* ptr, size_t size) override {
    // If an error is encountered, null out the file.
    if (file) {
      Status s = file->Append(StringPiece(ptr, size));

static const char* kTestInstrumentationSearch = "tf.Identity";

struct StringStream : public llvm::raw_ostream {
  StringStream() { SetUnbuffered(); }
  ~StringStream() override = default;
  uint64_t current_pos() const override { return 0; }

  void write_impl(const char* ptr, size_t size) override {
    ss.write(ptr, size);
  }
  std::stringstream ss;
};

class TestPassInstrumentation : public ::testing::Test {

  }
  ~WritableFileRawStream() override = default;

  uint64_t current_pos() const override {
    int64_t position;
    if (file->Tell(&position).ok()) {
      return position;
    } else {
      // MLIR uses os.tell() to determine whether something was written by
      // a subroutine or not, so it's important we have a working current_pos().
      LOG(WARNING)

  }

 private:
  explicit WritableFileWrapper(std::unique_ptr<tsl::WritableFile> file)
      : file_(std::move(file)) {
    SetBuffered();
  }

  uint64_t current_pos() const override {
    int64_t position;
    if (file_->Tell(&position).ok()) {
      return position;
    } else {
      return -1;
    }
  }

  void write_impl(const char* ptr, size_t size) override {

import org.gradle.internal.os.OperatingSystem;
import org.gradle.nativeplatform.OperatingSystemFamily;

public class DefaultOperatingSystem implements OperatingSystemInternal {
    private static final OperatingSystem CURRENT_OS = OperatingSystem.current();

    private final String name;
    private final OperatingSystem internalOs;

    public DefaultOperatingSystem(String name) {
        this(name, OperatingSystem.forName(name));
    }

        def currentOs = OperatingSystem.current()
        if (currentOs.macOsX) {
            // macOS coalesces the changes if the are in short succession
            return numberOfChangedFiles * numberOfChangesPerFile * LOST_EVENTS_RATIO_MAC_OS
        } else if (currentOs.linux) {
            // the JDK watchers only capture one event per watched path

				ReadMerges:     420084,
				ReadSectors:    66247626,
				ReadTicks:      2398227,
				WriteIOs:       7077314,
				WriteMerges:    8720147,
				WriteSectors:   157049224,
				WriteTicks:     7469810,
				CurrentIOs:     0,
				TotalTicks:     7580552,
				ReqTicks:       9869354,
				DiscardIOs:     46037,
				DiscardMerges:  0,
				DiscardSectors: 41695120,
				DiscardTicks:   1315,
				FlushIOs:       0,

            int remaining = max;
            int currentPos = offset;
            while (remaining > 0) {
                int count = Math.min(remaining, buffer.remaining());
                if (count > 0) {
                    buffer.put(src, currentPos, count);
                    remaining -= count;
                    currentPos += count;
                }
                while (buffer.remaining() == 0) {

    }

    public static OperatingSystem current() {
        if (currentOs == null) {
            currentOs = forName(System.getProperty("os.name"));
        }
        return currentOs;
    }

    // for testing current()
    static void resetCurrent() {
        currentOs = null;
    }

    public static OperatingSystem forName(String os) {