when:
        fileTree.visit(fileVisitor)
        rootDir.deleteDir()

        then:
        visitedFiles.size() == 3
        visitedFiles.each {
            assert !it.isDirectory() && it.getSize() == 5 && it.getLastModified() >= minimumTimestamp
        }
        visitedDirectories.size() == 2
        visitedDirectories.every {
            it.isDirectory()
        }
    }

    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "u3b9Xj8dPdXo"
      },
      "outputs": [],
      "source": [
        "print(str(os.path.getsize('/tmp/resnet50_quantized.tflite') \u003e\u003e 20) + 'MB')"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "private_outputs": true,
      "provenance": [
        {

            return !relativePath.isFile();
        }

        @Override
        public long getLastModified() {
            return file.lastModified();
        }

        @Override
        public long getSize() {
            return file.length();
        }

        @Override
        public InputStream open() {
            try {
                return Files.newInputStream(file.toPath());

  tflite::FinishModelBuffer(input_builder, input_model_location);

  std::string serialized_model(
      reinterpret_cast<const char*>(input_builder.GetBufferPointer()),
      input_builder.GetSize());

  OwningOpRef<mlir::ModuleOp> module = tflite::FlatBufferToMlir(
      serialized_model, &context, UnknownLoc::get(&context));
  if (!module) {
    LOG(ERROR) << "Couldn't import flatbuffer to MLIR.";

        }
    }

    protected void showFileFieldParameter(final FileItem item) {
        if (logger.isDebugEnabled()) {
            logger.debug("[param] {}:{name={}, size={}}", item.getFieldName(), item.getName(), item.getSize());
        }
    }

    protected void handleSizeLimitExceededException(final HttpServletRequest request, final SizeLimitExceededException e) {
        final long actual = e.getActualSize();

        return this.lastWriteTime;
    }


    @Override
    public long getLastAccessTime () {
        return this.lastAccessTime;
    }


    @Override
    public long getSize () {
        return 0L;
    }


    /**
     * {@inheritDoc}
     *
     * @see jcifs.Decodable#decode(byte[], int, int)
     */
    @Override

        keyRings.forEach(keyRing -> {
            Long keyId = keyRing.getPublicKey().getKeyID();
            PGPPublicKeyRing current = seenKeyIds.get(keyId);
            if (current == null || PGPUtils.getSize(current) < PGPUtils.getSize(keyRing)) {
                seenKeyIds.put(keyId, keyRing);
            }
        });
        return seenKeyIds.values();
    }

                file.delete();
            }
            encoder = null;
            file = null;
        }
    }

    File getFile() {
        return file;
    }

    long getSize() {
        return file.length();
    }

    public boolean isInUse() {
        return offset != -1;
    }

    private static class SimpleBinaryData implements BinaryStore.BinaryData {

	defer closeDisk()

	s := folderScanner{
		root:                  basePath,
		getSize:               getSize,
		oldCache:              cache,
		newCache:              dataUsageCache{Info: cache.Info},
		updateCache:           dataUsageCache{Info: cache.Info},
		dataUsageScannerDebug: false,
		healObjectSelect:      0,
		scanMode:              scanMode,

     */
    long getLastModified();

    /**
     * Returns the size of this file at the time of file traversal.
     *
     * @return The size, in bytes.
     */
    long getSize();

    /**
     * Opens this file as an input stream. Generally, calling this method is more performant than calling {@code new
     * FileInputStream(getFile())}.
     *