getSize example

        return $this->stream->getMetadata($key);
    }

    public function detach()
    {
        return $this->stream->detach();
    }

    public function getSize(): ?int
    {
        return $this->stream->getSize();
    }

    public function eof(): bool
    {
        return $this->stream->eof();
    }

    public function tell(): int
    {
        return $this->stream->tell();
    }

    

// Save it, inserting a new record.     $file->save();

    // Check that the correct hooks were called.     $this->assertFileHooksCalled(['insert']);

    // Verify that a new file ID is set when saving a new file to the database.     $this->assertGreaterThan(0, $file->id());
    $loaded_file = File::load($file->id());
    $this->assertNotNull($loaded_file, 'Record exists in the database.');
    $this->assertEquals($file->isPermanent(), $loaded_file->isPermanent(), 'Status was saved correctly.');
    $this->assertEquals(filesize($file->getFileUri()), $file->getSize(), 'File size was set correctly.');
    // Verify that the new file size was set correctly.     $this->assertGreaterThan(1, $file->getChangedTime());
    $this->assertEquals('en', $loaded_file->langcode->value, 'Langcode was defaulted correctly.');

    // Resave the file, updating the existing record.     file_test_reset();
    $file->status->value = 7;
    $file->save();

    // Check that the correct hooks were called.     $this->assertFileHooksCalled(['load', 'update']);

    

return parent::getMetadata($media, $attribute_name);
    }
    switch ($attribute_name) {
      case static::METADATA_ATTRIBUTE_NAME:
      case 'default_name':
        return $file->getFilename();

      case static::METADATA_ATTRIBUTE_MIME:
        return $file->getMimeType();

      case static::METADATA_ATTRIBUTE_SIZE:
        return $file->getSize();

      case 'thumbnail_uri':
        return $this->getThumbnail($file) ?: parent::getMetadata($media, $attribute_name);

      default:
        return parent::getMetadata($media, $attribute_name);
    }
  }

  /** * Gets the thumbnail image URI based on a file entity. * * @param \Drupal\file\FileInterface $file * A file entity. * * @return string * File URI of the thumbnail image or NULL if there is no specific icon. */

  public function assertFileUnchanged(FileInterface $before, FileInterface $after) {
    $this->assertEquals($before->id(), $after->id(), 'File id is the same');
    $this->assertEquals($before->getOwner()->id(), $after->getOwner()->id(), 'File owner is the same');
    $this->assertEquals($before->getFilename(), $after->getFilename(), 'File name is the same');
    $this->assertEquals($before->getFileUri(), $after->getFileUri(), 'File path is the same');
    $this->assertEquals($before->getMimeType(), $after->getMimeType(), 'File MIME type is the same');
    $this->assertEquals($before->getSize(), $after->getSize(), 'File size is the same');
    $this->assertEquals($before->isPermanent(), $after->isPermanent(), 'File status is the same');
  }

  /** * Asserts that two files are not the same by comparing the fid and filepath. * * @param \Drupal\file\FileInterface $file1 * File object to compare. * @param \Drupal\file\FileInterface $file2 * File object to compare. */
  

return $this->filesystem->delete($path);
    }

    /** * {@inheritdoc} */
    public function getSize($path)
    {
        $this->migrateFileLive($path);
        $path = $this->strategy->encode($path);

        return $this->filesystem->getSize($path);
    }

    /** * {@inheritdoc} */
    public function rename($path, $newPath)
    {
        $this->migrateFileLive($path);
        $path = $this->strategy->encode($path);
        $newPath = $this->strategy->encode($newPath);

        

// Load the node and the file.     $node_storage->resetCache([$nid]);
    $node = $node_storage->load($nid);
    $file = File::load($node->{$field_name}->target_id);

    // Generate and test sanitized tokens.     $tests = [];
    $tests['[file:fid]'] = $file->id();
    $tests['[file:name]'] = Html::escape($file->getFilename());
    $tests['[file:path]'] = Html::escape($file->getFileUri());
    $tests['[file:mime]'] = Html::escape($file->getMimeType());
    $tests['[file:size]'] = format_size($file->getSize());
    $tests['[file:url]'] = Html::escape($file->createFileUrl(FALSE));
    $tests['[file:created]'] = $date_formatter->format($file->getCreatedTime(), 'medium', '', NULL, $language_interface->getId());
    $tests['[file:created:short]'] = $date_formatter->format($file->getCreatedTime(), 'short', '', NULL, $language_interface->getId());
    $tests['[file:changed]'] = $date_formatter->format($file->getChangedTime(), 'medium', '', NULL, $language_interface->getId());
    $tests['[file:changed:short]'] = $date_formatter->format($file->getChangedTime(), 'short', '', NULL, $language_interface->getId());
    $tests['[file:owner]'] = Html::escape($this->adminUser->getDisplayName());
    $tests['[file:owner:uid]'] = $file->getOwnerId();

    $base_bubbleable_metadata = BubbleableMetadata::createFromObject($file);
    $metadata_tests = [];
    $metadata_tests['[file:fid]'] = $base_bubbleable_metadata;
    

public $hints = ['fspath'];

    public function __construct(SplFileInfo $fileInfo)
    {
        parent::__construct('SplFileInfo');

        $this->path = $fileInfo->getPathname();

        try {
            if (\strlen($this->path) && $fileInfo->getRealPath()) {
                $this->perms = $fileInfo->getPerms();
                $this->size = $fileInfo->getSize();
                $this->owner = $fileInfo->getOwner();
                $this->group = $fileInfo->getGroup();
                $this->ctime = $fileInfo->getCTime();
                $this->mtime = $fileInfo->getMTime();
                $this->realpath = $fileInfo->getRealPath();
            }

            $this->is_dir = $fileInfo->isDir();
            $this->is_file = $fileInfo->isFile();
            $this->is_link = $fileInfo->isLink();

            

    public static function store64(SplFixedArray $x, $i, ParagonIE_Sodium_Core32_Int64 $u)
    {
        $v = clone $u;
        $maxLength = $x->getSize() - 1;
        for ($j = 0; $j < 8; ++$j) {
            $k = 3 - ($j >> 1);
            $x[$i] = $v->limbs[$k] & 0xff;
            if (++$i > $maxLength) {
                return;
            }
            $v->limbs[$k] >>= 8;
        }
    }

    /** * This just sets the $iv static variable. * * @internal You should not use this directly from another application * * @return void * @throws SodiumException * @throws TypeError */

return false;
        }

        return $this->stream->tell() >= $this->offset + $this->limit;
    }

    /** * Returns the size of the limited subset of data */
    public function getSize(): ?int
    {
        if (null === ($length = $this->stream->getSize())) {
            return null;
        } elseif ($this->limit === -1) {
            return $length - $this->offset;
        } else {
            return min($this->limit, $length - $this->offset);
        }
    }

    /** * Allow for a bounded seek on the read limited stream */
    

/** * Tries to calculate the size by adding the size of each stream. * * If any of the streams do not return a valid number, then the size of the * append stream cannot be determined and null is returned. */
    public function getSize(): ?int
    {
        $size = 0;

        foreach ($this->streams as $stream) {
            $s = $stream->getSize();
            if ($s === null) {
                return null;
            }
            $size += $s;
        }

        return $size;
    }

    public function eof(): bool
    {
        

$pool = [];

        foreach ($media as [
            'file' => $file,
            'alt' => $alt,
            'subtitles' => $subtitles,
            'category' => $category,
            'owners' => $extraOwners,
        ]) {
            $query = [
                'command' => 'INIT',
                'total_bytes' => $file->getSize(),
                'media_type' => $file->getContentType(),
            ];

            if ($category) {
                $query['media_category'] = $category;
            }

            if ($extraOwners) {
                $query['additional_owners'] = implode(',', $extraOwners);
            }

            

$this->repository->create(array_values($data), $this->context);

        foreach ($data as $expect) {
            $id = $expect['id'];
            $result = $this->repository->search(new Criteria([$id]), $this->context);
            $importExportFile = $result->get($id);
            static::assertEquals(1, $result->count());
            static::assertEquals($expect['originalName'], $importExportFile->getOriginalName());
            static::assertEquals($expect['path'], $importExportFile->getPath());
            static::assertEquals(new \DateTime($expect['expireDate']), $importExportFile->getExpireDate());
            static::assertEquals($expect['size'], $importExportFile->getSize());
            static::assertEquals($expect['accessToken'], $importExportFile->getAccessToken());
        }
    }

    public function testImportExportFileReadNoResult(): void
    {
        $num = 3;
        $data = $this->prepareImportExportFileTestData($num);

        $this->repository->create(array_values($data), $this->context);

        

$conf[\CURLOPT_HTTP_VERSION] = \CURL_HTTP_VERSION_2_0;
        } else {
            $conf[\CURLOPT_HTTP_VERSION] = \CURL_HTTP_VERSION_1_0;
        }

        return $conf;
    }

    private function applyMethod(EasyHandle $easy, array &$conf): void
    {
        $body = $easy->request->getBody();
        $size = $body->getSize();

        if ($size === null || $size > 0) {
            $this->applyBody($easy->request, $easy->options, $conf);

            return;
        }

        $method = $easy->request->getMethod();
        if ($method === 'PUT' || $method === 'POST') {
            // See https://tools.ietf.org/html/rfc7230#section-3.3.2             if (!$easy->request->hasHeader('Content-Length')) {
                

/** * get content length. */
    public function getContentLength(): int
    {
        if (is_string($this->binary)) {
            return strlen($this->binary);
        }

        if ($this->file instanceof File) {
            return $this->file->getSize();
        }

        return 0;
    }

    /** * Set content type by guessing mime type from file extension */
    private function setContentTypeByMimeType(): void
    {
        $mime    = null;
        

  protected function assertEntity(int $fid, string $name, int $size, string $uri, string $type, int $uid): void {
    /** @var \Drupal\file\FileInterface $file */
    $file = File::load($fid);
    $this->assertInstanceOf(FileInterface::class, $file);
    $this->assertSame($name, $file->getFilename());
    $this->assertSame($size, (int) $file->getSize());
    $this->assertSame($uri, $file->getFileUri());
    $this->assertSame($type, $file->getMimeType());
    $this->assertSame($uid, (int) $file->getOwnerId());
  }

  /** * Tests the Drupal 6 files to Drupal 8 migration. */
  public function testFiles() {
    $this->assertEntity(1, 'Image1.png', 39325, 'public://image-1.png', 'image/png', 1);
    $this->assertEntity(2, 'Image2.jpg', 1831, 'public://image-2.jpg', 'image/jpeg', 1);