SplFileInfoRepresentationTest::testConstructBlockDevice() - Code Metrics - Inspection of "SplFileInfoRepresentationTest" - jnvsor/kint - Measure and Improve Code Quality continuously with Scrutinizer

Test Setup Failed
Push — test ( d5b2bb...f2c6f9 )

by Jonathan
created 2018-04-06 22:06 UTC
testConstructBlockDevice() A

↳ Parent: SplFileInfoRepresentationTest
Complexity

Conditions	3
Paths	4
Size

Total Lines	50
Code Lines	42
Duplication

Lines	0
Ratio	0 %
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
cc	3
eloc	42
nc	4
nop	0
dl	0
loc	50
rs	9.3333
c	1
b	0
f	0
<?php

namespace Kint\Test\Object\Representation;

use DateTime;
use Kint\Object\Representation\SplFileInfoRepresentation;
use Kint\Test\KintTestCase;
use SplFileInfo;
use UnexpectedValueException;

class SplFileInfoRepresentationTest extends KintTestCase
{
    protected $socket;

    public function setUp()
    {
        symlink(dirname(__DIR__), __DIR__.'/testDirLink');
        symlink(__FILE__, __DIR__.'/testFileLink');
        symlink(__DIR__.'/testDirLink', __DIR__.'/testDirLink2');
        symlink(__DIR__.'/testFileLink', __DIR__.'/testFileLink2');

        posix_mkfifo(__DIR__.'/testPipe', 0777);

        $this->socket = socket_create(AF_UNIX, SOCK_STREAM, 0);
        socket_bind($this->socket, __DIR__.'/testSocket');
    }

    public function tearDown()
    {
        unlink(__DIR__.'/testDirLink2');
        unlink(__DIR__.'/testFileLink2');
        unlink(__DIR__.'/testDirLink');
        unlink(__DIR__.'/testFileLink');

        unlink(__DIR__.'/testPipe');

        socket_close($this->socket);
        unlink(__DIR__.'/testSocket');
    }

    /**
     * @covers \Kint\Object\Representation\SplFileInfoRepresentation::__construct
     */
    public function testConstructFile()

    {
        $r = new SplFileInfoRepresentation(new SplFileInfo(__FILE__));


        $this->assertSame(filesize(__FILE__), $r->size);
        $this->assertSame(filectime(__FILE__), $r->ctime);
        $this->assertSame(filemtime(__FILE__), $r->mtime);
        $this->assertSame(fileperms(__FILE__), $r->perms);
        $this->assertSame(fileowner(__FILE__), $r->owner);
        $this->assertSame(filegroup(__FILE__), $r->group);
        $this->assertSame('File', $r->typename);
        $this->assertSame('-', $r->typeflag);
        $this->assertSame(__FILE__, $r->path);
        $this->assertSame(__FILE__, $r->realpath);
        $this->assertNull($r->linktarget);

        if (filetype(__FILE__) === 'file') {
            $this->assertTrue($r->is_file);
            $this->assertFalse($r->is_dir);
            $this->assertFalse($r->is_link);
        } else {
            throw new UnexpectedValueException(__FILE__.' type is not "file"');
        }
    }

    /**
     * @covers \Kint\Object\Representation\SplFileInfoRepresentation::__construct
     */
    public function testConstructFileLink()

    {
        $f = __DIR__.'/testFileLink2';


        $r = new SplFileInfoRepresentation(new SplFileInfo($f));


        $this->assertSame(filesize($f), $r->size);
        $this->assertSame(filectime($f), $r->ctime);
        $this->assertSame(filemtime($f), $r->mtime);
        $this->assertSame(fileperms($f), $r->perms);
        $this->assertSame(fileowner($f), $r->owner);
        $this->assertSame(filegroup($f), $r->group);
        $this->assertSame('File symlink', $r->typename);
        $this->assertSame('l', $r->typeflag);
        $this->assertSame($f, $r->path);
        $this->assertSame(__FILE__, $r->realpath);
        $this->assertSame(__DIR__.'/testFileLink', $r->linktarget);

        if (filetype($f) === 'link') {
            $this->assertTrue($r->is_file);
            $this->assertFalse($r->is_dir);
            $this->assertTrue($r->is_link);
        } else {
            throw new UnexpectedValueException($f.' type is not "link"');
        }
    }

    /**
     * @covers \Kint\Object\Representation\SplFileInfoRepresentation::__construct
     */
    public function testConstructLinkedFile()

    {
        $f = __DIR__.'/testDirLink/'.basename(__DIR__).'/'.basename(__FILE__);


        $r = new SplFileInfoRepresentation(new SplFileInfo($f));


        $this->assertSame(filesize($f), $r->size);
        $this->assertSame(filectime($f), $r->ctime);
        $this->assertSame(filemtime($f), $r->mtime);
        $this->assertSame(fileperms($f), $r->perms);
        $this->assertSame(fileowner($f), $r->owner);
        $this->assertSame(filegroup($f), $r->group);
        $this->assertSame('File', $r->typename);
        $this->assertSame('-', $r->typeflag);
        $this->assertSame($f, $r->path);
        $this->assertSame(__FILE__, $r->realpath);
        $this->assertNull($r->linktarget);

        if (filetype($f) === 'file') {
            $this->assertTrue($r->is_file);
            $this->assertFalse($r->is_dir);
            $this->assertFalse($r->is_link);
        } else {
            throw new UnexpectedValueException($f.' type is not "file"');
        }
    }

    /**
     * @covers \Kint\Object\Representation\SplFileInfoRepresentation::__construct
     */
    public function testConstructDir()

    {
        $r = new SplFileInfoRepresentation(new SplFileInfo(__DIR__));


        $this->assertSame(filesize(__DIR__), $r->size);
        $this->assertSame(filectime(__DIR__), $r->ctime);
        $this->assertSame(filemtime(__DIR__), $r->mtime);
        $this->assertSame(fileperms(__DIR__), $r->perms);
        $this->assertSame(fileowner(__DIR__), $r->owner);
        $this->assertSame(filegroup(__DIR__), $r->group);
        $this->assertSame('Directory', $r->typename);
        $this->assertSame('d', $r->typeflag);
        $this->assertSame(__DIR__, $r->path);
        $this->assertSame(__DIR__, $r->realpath);
        $this->assertNull($r->linktarget);

        if (filetype(__DIR__) === 'dir') {
            $this->assertFalse($r->is_file);
            $this->assertTrue($r->is_dir);
            $this->assertFalse($r->is_link);
        } else {
            throw new UnexpectedValueException(__DIR__.' type is not "dir"');
        }
    }

    /**
     * @covers \Kint\Object\Representation\SplFileInfoRepresentation::__construct
     */
    public function testConstructDirLink()

    {
        $f = __DIR__.'/testDirLink2';


        $r = new SplFileInfoRepresentation(new SplFileInfo($f));


        $this->assertSame(filesize($f), $r->size);
        $this->assertSame(filectime($f), $r->ctime);
        $this->assertSame(filemtime($f), $r->mtime);
        $this->assertSame(fileperms($f), $r->perms);
        $this->assertSame(fileowner($f), $r->owner);
        $this->assertSame(filegroup($f), $r->group);
        $this->assertSame('Directory symlink', $r->typename);
        $this->assertSame('l', $r->typeflag);
        $this->assertSame($f, $r->path);
        $this->assertSame(dirname(__DIR__), $r->realpath);
        $this->assertSame(__DIR__.'/testDirLink', $r->linktarget);

        if (filetype($f) === 'link') {
            $this->assertFalse($r->is_file);
            $this->assertTrue($r->is_dir);
            $this->assertTrue($r->is_link);
        } else {
            throw new UnexpectedValueException($f.' type is not "link"');
        }
    }

    /**
     * @covers \Kint\Object\Representation\SplFileInfoRepresentation::__construct
     */
    public function testConstructLinkedDir()

    {
        $f = __DIR__.'/testDirLink/'.basename(__DIR__);


        $r = new SplFileInfoRepresentation(new SplFileInfo($f));


        $this->assertSame(filesize($f), $r->size);
        $this->assertSame(filectime($f), $r->ctime);
        $this->assertSame(filemtime($f), $r->mtime);
        $this->assertSame(fileperms($f), $r->perms);
        $this->assertSame(fileowner($f), $r->owner);
        $this->assertSame(filegroup($f), $r->group);
        $this->assertSame('Directory', $r->typename);
        $this->assertSame('d', $r->typeflag);
        $this->assertSame($f, $r->path);
        $this->assertSame(__DIR__, $r->realpath);
        $this->assertNull($r->linktarget);

        if (filetype($f) === 'dir') {
            $this->assertFalse($r->is_file);
            $this->assertTrue($r->is_dir);
            $this->assertFalse($r->is_link);
        } else {
            throw new UnexpectedValueException($f.' type is not "dir"');
        }
    }

    /**
     * @covers \Kint\Object\Representation\SplFileInfoRepresentation::__construct
     */
    public function testConstructPipe()

    {
        $f = __DIR__.'/testPipe';


        $r = new SplFileInfoRepresentation(new SplFileInfo($f));


        $this->assertSame(filesize($f), $r->size);
        $this->assertSame(filectime($f), $r->ctime);
        $this->assertSame(filemtime($f), $r->mtime);
        $this->assertSame(fileperms($f), $r->perms);
        $this->assertSame(fileowner($f), $r->owner);
        $this->assertSame(filegroup($f), $r->group);
        $this->assertSame('Named pipe', $r->typename);
        $this->assertSame('p', $r->typeflag);
        $this->assertSame($f, $r->path);
        $this->assertSame($f, $r->realpath);
        $this->assertNull($r->linktarget);

        if (filetype($f) === 'fifo') {
            $this->assertFalse($r->is_file);
            $this->assertFalse($r->is_dir);
            $this->assertFalse($r->is_link);
        } else {
            throw new UnexpectedValueException($f.' type is not "fifo"');
        }
    }

    /**
     * @covers \Kint\Object\Representation\SplFileInfoRepresentation::__construct
     */
    public function testConstructSocket()

    {
        $f = __DIR__.'/testSocket';


        $r = new SplFileInfoRepresentation(new SplFileInfo($f));


        $this->assertSame(filesize($f), $r->size);
        $this->assertSame(filectime($f), $r->ctime);
        $this->assertSame(filemtime($f), $r->mtime);
        $this->assertSame(fileperms($f), $r->perms);
        $this->assertSame(fileowner($f), $r->owner);
        $this->assertSame(filegroup($f), $r->group);
        $this->assertSame('Socket', $r->typename);
        $this->assertSame('s', $r->typeflag);
        $this->assertSame($f, $r->path);
        $this->assertSame($f, $r->realpath);
        $this->assertNull($r->linktarget);

        if (filetype($f) === 'socket') {
            $this->assertFalse($r->is_file);
            $this->assertFalse($r->is_dir);
            $this->assertFalse($r->is_link);
        } else {
            throw new UnexpectedValueException($f.' type is not "socket"');
        }
    }

    /**
     * @covers \Kint\Object\Representation\SplFileInfoRepresentation::__construct
     */
    public function testConstructCharacterDevice()

    {
        $f = '/dev/null';


        $r = new SplFileInfoRepresentation(new SplFileInfo($f));


        $this->assertSame(filesize($f), $r->size);
        $this->assertSame(filectime($f), $r->ctime);
        $this->assertSame(filemtime($f), $r->mtime);
        $this->assertSame(fileperms($f), $r->perms);
        $this->assertSame(fileowner($f), $r->owner);
        $this->assertSame(filegroup($f), $r->group);
        $this->assertSame('Character device', $r->typename);
        $this->assertSame('c', $r->typeflag);
        $this->assertSame($f, $r->path);
        $this->assertSame($f, $r->realpath);
        $this->assertNull($r->linktarget);

        if (filetype($f) === 'char') {
            $this->assertFalse($r->is_file);
            $this->assertFalse($r->is_dir);
            $this->assertFalse($r->is_link);
        } else {
            throw new UnexpectedValueException($f.' type is not "char"');
        }
    }

    /**
     * @covers \Kint\Object\Representation\SplFileInfoRepresentation::__construct
     */
    public function testConstructBlockDevice()
    {
        $f = '/dev/loop0';


        if (file_exists($f)) {
            $sfi = new SplFileInfo($f);
            $size = filesize($f);
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
            $ctime = filectime($f);
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
            $mtime = filemtime($f);
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
            $owner = fileowner($f);
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
            $group = filegroup($f);
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
            $perms = fileperms($f);
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
        } else {
            $mock = $this->prophesize('SplFileInfo');
            $mock->getSize()->willReturn($size = 0);
            $mock->getCTime()->willReturn($ctime = time());
            $mock->getMTime()->willReturn($mtime = time());
            $mock->getPerms()->willReturn($perms = 0x6444);
            $mock->getOwner()->willReturn($owner = fileowner(__FILE__));
            $mock->getGroup()->willReturn($group = filegroup(__FILE__));
            $mock->getPathname()->willReturn($f);
            $mock->getRealPath()->willReturn($f);
            $mock->isDir()->willReturn(false);
            $mock->isFile()->willReturn(false);
            $mock->isLink()->willReturn(false);
            $sfi = $mock->reveal();
        }

        $r = new SplFileInfoRepresentation($sfi);


        $this->assertSame(filesize($f), $r->size);
        $this->assertSame(filectime($f), $r->ctime);
        $this->assertSame(filemtime($f), $r->mtime);
        $this->assertSame(fileperms($f), $r->perms);
        $this->assertSame(fileowner($f), $r->owner);
        $this->assertSame(filegroup($f), $r->group);
        $this->assertSame('Block device', $r->typename);
        $this->assertSame('b', $r->typeflag);
        $this->assertSame($f, $r->path);
        $this->assertSame($f, $r->realpath);
        $this->assertNull($r->linktarget);

        if (filetype($f) === 'block') {
            $this->assertFalse($r->is_file);
            $this->assertFalse($r->is_dir);
            $this->assertFalse($r->is_link);
        } else {
            throw new UnexpectedValueException($f.' type is not "block"');
        }
    }

    /**
     * @covers \Kint\Object\Representation\SplFileInfoRepresentation::__construct
     */
    public function testConstructNone()
    {
        $r = new SplFileInfoRepresentation(new SplFileInfo(__FILE__.'/nonexistant'));


        $this->assertNull($r->size);
        $this->assertNull($r->ctime);
        $this->assertNull($r->mtime);
        $this->assertNull($r->perms);
        $this->assertNull($r->owner);
        $this->assertNull($r->group);
        $this->assertSame('Unknown file', $r->typename);
        $this->assertSame('-', $r->typeflag);
        $this->assertNull($r->path);
        $this->assertNull($r->realpath);
        $this->assertNull($r->linktarget);
        $this->assertFalse($r->is_file);
        $this->assertFalse($r->is_dir);
        $this->assertFalse($r->is_link);
    }

    /**
     * @covers \Kint\Object\Representation\SplFileInfoRepresentation::getLabel
     */
    public function testGetLabel()
    {
        $r = new SplFileInfoRepresentation(new SplFileInfo(__FILE__));


        $r->typename = 'test123';
        $r->size = 1100;

        $this->assertSame('test123 (1.07KB)', $r->getLabel());
    }

    /**
     * @covers \Kint\Object\Representation\SplFileInfoRepresentation::getSize
     */
    public function testGetSize()
    {
        $r = new SplFileInfoRepresentation(new SplFileInfo(__FILE__));


        $r->size = 0;
        $this->assertNull($r->getSize());

        $r->size = 42;
        $this->assertSame('42B', $r->getSize());

        $r->size = 1024;
        $this->assertSame('1KB', $r->getSize());

        $r->size = 1100;
        $this->assertSame('1.07KB', $r->getSize());

        $r->size = 1024 * 1024;
        $this->assertSame('1MB', $r->getSize());
    }

    /**
     * @covers \Kint\Object\Representation\SplFileInfoRepresentation::getMTime
     */
    public function testGetMTime()
    {
        $r = new SplFileInfoRepresentation(new SplFileInfo(__FILE__));

        $r->mtime = 0;

        $this->assertSame('Jan 01 1970', $r->getMTime());

        $dt = new DateTime('midnight +1 hour +23 minutes');

        $r->mtime = $dt->format('U');

        $this->assertSame(date('M d').' 01:23', $r->getMTime());
    }
}

1			<?php
2
3			namespace Kint\Test\Object\Representation;
4
5			use DateTime;
6			use Kint\Object\Representation\SplFileInfoRepresentation;
7			use Kint\Test\KintTestCase;
8			use SplFileInfo;
9			use UnexpectedValueException;
10
11			class SplFileInfoRepresentationTest extends KintTestCase
12			{
13			protected $socket;
14
15			public function setUp()
16			{
17			symlink(dirname(__DIR__), __DIR__.'/testDirLink');
18			symlink(__FILE__, __DIR__.'/testFileLink');
19			symlink(__DIR__.'/testDirLink', __DIR__.'/testDirLink2');
20			symlink(__DIR__.'/testFileLink', __DIR__.'/testFileLink2');
21
22			posix_mkfifo(__DIR__.'/testPipe', 0777);
23
24			$this->socket = socket_create(AF_UNIX, SOCK_STREAM, 0);
25			socket_bind($this->socket, __DIR__.'/testSocket');
26			}
27
28			public function tearDown()
29			{
30			unlink(__DIR__.'/testDirLink2');
31			unlink(__DIR__.'/testFileLink2');
32			unlink(__DIR__.'/testDirLink');
33			unlink(__DIR__.'/testFileLink');
34
35			unlink(__DIR__.'/testPipe');
36
37			socket_close($this->socket);
38			unlink(__DIR__.'/testSocket');
39			}
40
jnvsor / kint

Push — test ( d5b2bb...f2c6f9 )

testConstructBlockDevice() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
