ArchiveEntryTest::testSourceStringExceptionStreamSet() - Code Metrics - iqb/Morgue - Measure and Improve Code Quality continuously with Scrutinizer

testSourceStringExceptionStreamSet() A
last analyzed 2018-04-13 22:37 UTC

↳ Parent: ArchiveEntryTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	6
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	4
nc	1
nop	0
dl	0
loc	6
rs	9.4285
c	0
b	0
f	0

<?php

/*
 * (c) 2018 Dennis Birkholz <[email protected]>
 *
 * $Id$
 * Author:    $Format:%an <%ae>, %ai$
 * Committer: $Format:%cn <%ce>, %ci$
 */

namespace morgue\archive;

use PHPUnit\Framework\TestCase;

/**
 * @coversDefaultClass \morgue\archive\ArchiveEntry
 */
final class ArchiveEntryTest extends TestCase
{
    public function testImmutability()
    {
        $old = new ArchiveEntry('name');

        $value = 'new name';
        $this->assertNotSame($value, $old->getName());
        $new = $old->withName($value);
        $this->assertNotSame($old, $new);
        $this->assertNotSame($old->getName(), $new->getName());
        $this->assertSame($value, $new->getName());
        $old = $new;

        $value = 12345;
        $this->assertNotSame($value, $old->getUncompressedSize());
        $new = $old->withUncompressedSize($value);
        $this->assertNotSame($old, $new);
        $this->assertNotSame($old->getUncompressedSize(), $new->getUncompressedSize());
        $this->assertSame($value, $new->getUncompressedSize());
        $old = $new;

        $value = 23456;
        $this->assertNotSame($value, $old->getSourceSize());
        $new = $old->withSourceSize($value);
        $this->assertNotSame($old, $new);
        $this->assertNotSame($old->getSourceSize(), $new->getSourceSize());
        $this->assertSame($value, $new->getSourceSize());
        $old = $new;

        $value = 34567;
        $this->assertNotSame($value, $old->getTargetSize());
        $new = $old->withTargetSize($value);
        $this->assertNotSame($old, $new);
        $this->assertNotSame($old->getTargetSize(), $new->getTargetSize());
        $this->assertSame($value, $new->getTargetSize());
        $old = $new;

        $value = new \DateTimeImmutable();
        $this->assertNotSame($value, $old->getCreationTime());
        $new = $old->withCreationTime($value);
        $this->assertNotSame($old, $new);
        $this->assertNotSame($old->getCreationTime(), $new->getCreationTime());
        $this->assertSame($value, $new->getCreationTime());
        $old = $new;

        $value = new \DateTimeImmutable();
        $this->assertNotSame($value, $old->getModificationTime());
        $new = $old->withModificationTime($value);
        $this->assertNotSame($old, $new);
        $this->assertNotSame($old->getModificationTime(), $new->getModificationTime());
        $this->assertSame($value, $new->getModificationTime());
        $old = $new;

        $value = 45678;
        $this->assertNotSame($value, $old->getChecksumCrc32());
        $new = $old->withChecksumCrc32($value);
        $this->assertNotSame($old, $new);
        $this->assertNotSame($old->getChecksumCrc32(), $new->getChecksumCrc32());
        $this->assertSame($value, $new->getChecksumCrc32());
        $old = $new;

        $value = 'another comment';
        $this->assertNotSame($value, $old->getComment());
        $new = $old->withComment($value);
        $this->assertNotSame($old, $new);
        $this->assertNotSame($old->getComment(), $new->getComment());
        $this->assertSame($value, $new->getComment());
        $old = $new;

        $value = COMPRESSION_METHOD_LZMA;
        $this->assertNotSame($value, $old->getSourceCompressionMethod());
        $new = $old->withSourceCompressionMethod($value);
        $this->assertNotSame($old, $new);
        $this->assertNotSame($old->getSourceCompressionMethod(), $new->getSourceCompressionMethod());
        $this->assertSame($value, $new->getSourceCompressionMethod());
        $old = $new;

        $value = COMPRESSION_METHOD_BZIP2;
        $this->assertNotSame($value, $old->getTargetCompressionMethod());
        $new = $old->withTargetCompressionMethod($value);
        $this->assertNotSame($old, $new);
        $this->assertNotSame($old->getTargetCompressionMethod(), $new->getTargetCompressionMethod());
        $this->assertSame($value, $new->getTargetCompressionMethod());
        $old = $new;

        $value = 56789;
        $this->assertNotSame($value, $old->getDosAttributes());
        $new = $old->withDosAttributes($value);
        $this->assertNotSame($old, $new);
        $this->assertNotSame($old->getDosAttributes(), $new->getDosAttributes());
        $this->assertSame($value, $new->getDosAttributes());
        $old = $new;

        $value = 67890;
        $this->assertNotSame($value, $old->getUnixAttributes());
        $new = $old->withUnixAttributes($value);
        $this->assertNotSame($old, $new);
        $this->assertNotSame($old->getUnixAttributes(), $new->getUnixAttributes());
        $this->assertSame($value, $new->getUnixAttributes());
    }

    /**
     * @covers ::getSourcePath()
     * @covers ::withSourcePath()
     * @covers ::importStat()
     */
    public function testSourcePath()

    {
        $filename = __DIR__ . '/ipsum.txt';
        $stat = \stat($filename);

        $entryEmpty = new ArchiveEntry(\basename($filename));
        $entry = $entryEmpty->withSourcePath($filename, COMPRESSION_METHOD_STORE);

        $this->assertNotSame($entryEmpty, $entry);
        $this->assertSame($filename, $entry->getSourcePath());
        $this->assertNull($entry->getSourceStream());
        $this->assertNull($entry->getSourceString());
        $this->assertSame(COMPRESSION_METHOD_STORE, $entry->getSourceCompressionMethod());
        $this->assertSame($stat['size'], $entry->getSourceSize());
        $this->assertSame($stat['size'], $entry->getUncompressedSize());
        $this->assertSame($stat['mode'], $entry->getUnixAttributes());
        $this->assertSame($stat['ctime'], $entry->getCreationTime()->getTimestamp());
        $this->assertSame($stat['mtime'], $entry->getModificationTime()->getTimestamp());
    }

    /**
     * @covers ::getSourcePath()
     * @covers ::withSourcePath()
     * @covers ::importStat()
     */
    public function testSourcePathDirectory()
    {
        $filename = __DIR__;
        $stat = \stat($filename);

        $entryEmpty = new ArchiveEntry(\basename($filename));
        $entry = $entryEmpty->withSourcePath($filename);

        $this->assertNotSame($entryEmpty, $entry);
        $this->assertSame($filename, $entry->getSourcePath());
        $this->assertNull($entry->getSourceStream());
        $this->assertNull($entry->getSourceString());
        $this->assertSame(COMPRESSION_METHOD_STORE, $entry->getSourceCompressionMethod());
        $this->assertSame(COMPRESSION_METHOD_STORE, $entry->getTargetCompressionMethod());
        $this->assertSame(0, $entry->getSourceSize());
        $this->assertSame(0, $entry->getTargetSize());
        $this->assertSame(0, $entry->getUncompressedSize());
        $this->assertSame($stat['mode'], $entry->getUnixAttributes());
        $this->assertSame($stat['ctime'], $entry->getCreationTime()->getTimestamp());
        $this->assertSame($stat['mtime'], $entry->getModificationTime()->getTimestamp());
    }

    /**
     * @covers ::getSourceStream()
     * @covers ::withSourceStream()
     * @covers ::importStat()
     */
    public function testSourceStream()

    {
        $filename = __DIR__ . '/ipsum.txt';
        $stream = \fopen($filename, 'r');
        $stat = \fstat($stream);

        $entryEmpty = new ArchiveEntry(\basename($filename));
        $entry = $entryEmpty->withSourceStream($stream, COMPRESSION_METHOD_STORE);

        $this->assertNotSame($entryEmpty, $entry);
        $this->assertNull($entry->getSourcePath());
        $this->assertSame($stream, $entry->getSourceStream());
        $this->assertNull($entry->getSourceString());
        $this->assertSame(COMPRESSION_METHOD_STORE, $entry->getSourceCompressionMethod());
        $this->assertSame($stat['size'], $entry->getSourceSize());
        $this->assertSame($stat['size'], $entry->getUncompressedSize());
        $this->assertSame($stat['mode'], $entry->getUnixAttributes());
        $this->assertSame($stat['ctime'], $entry->getCreationTime()->getTimestamp());
        $this->assertSame($stat['mtime'], $entry->getModificationTime()->getTimestamp());
    }

    /**
     * @covers ::getSourceString()
     * @covers ::withSourceString()
     */
    public function testSourceString()
    {
        $filename = __DIR__ . '/ipsum.txt';
        $string = \file_get_contents($filename);

        $entryEmpty = new ArchiveEntry(\basename($filename));
        $timestamp1 = \time();
        $entry = $entryEmpty->withSourceString($string, COMPRESSION_METHOD_STORE);
        $timestamp2 = \time();

        $this->assertNotSame($entryEmpty, $entry);
        $this->assertNull($entry->getSourcePath());
        $this->assertNull($entry->getSourceStream());
        $this->assertSame($string, $entry->getSourceString());
        $this->assertSame(COMPRESSION_METHOD_STORE, $entry->getSourceCompressionMethod());
        $this->assertSame(\strlen($string), $entry->getSourceSize());
        $this->assertSame(\strlen($string), $entry->getUncompressedSize());
        $this->assertNull($entry->getUnixAttributes());
        $this->assertTrue($timestamp1 <= $entry->getCreationTime()->getTimestamp() && $entry->getCreationTime()->getTimestamp() <= $timestamp2);
        $this->assertTrue($timestamp1 <= $entry->getModificationTime()->getTimestamp() && $entry->getCreationTime()->getTimestamp() <= $timestamp2);
    }

    /**
     * @covers ::withSourcePath()
     * @expectedException \InvalidArgumentException
     */
    public function testSourcePathExceptionInvalidFile()
    {
        $entry = new ArchiveEntry('entry');
        $entry->withSourcePath(__DIR__ . '/non-existing-file');
    }

    /**
     * @covers ::withSourcePath()
     * @expectedException \InvalidArgumentException
     */
    public function testSourcePathExceptionPathSet()
    {
        $entryEmpty = new ArchiveEntry('entry');
        $entry = $entryEmpty->withSourcePath(__DIR__ . '/ipsum.txt');
        $entry->withSourcePath(__FILE__);
    }

    /**
     * @covers ::withSourcePath()
     * @expectedException \InvalidArgumentException
     */
    public function testSourcePathExceptionStreamSet()
    {
        $entryEmpty = new ArchiveEntry('entry');
        $entry = $entryEmpty->withSourceStream(\fopen('php://memory', 'r'));
        $entry->withSourcePath(__FILE__);
    }

    /**
     * @covers ::withSourcePath()
     * @expectedException \InvalidArgumentException
     */
    public function testSourcePathExceptionStringSet()
    {
        $entryEmpty = new ArchiveEntry('entry');
        $entry = $entryEmpty->withSourceString('content');
        $entry->withSourcePath(__FILE__);
    }

    /**
     * @covers ::withSourceStream()
     * @expectedException \InvalidArgumentException
     */
    public function testSourceStreamExceptionPathSet()
    {
        $entryEmpty = new ArchiveEntry('entry');
        $entry = $entryEmpty->withSourcePath(__DIR__ . '/ipsum.txt');
        $entry->withSourceStream(\fopen('php://memory', 'r'));
    }

    /**
     * @covers ::withSourceStream()
     * @expectedException \InvalidArgumentException
     */
    public function testSourceStreamExceptionStreamSet()
    {
        $entryEmpty = new ArchiveEntry('entry');
        $entry = $entryEmpty->withSourceStream(\fopen('php://memory', 'r'));
        $entry->withSourceStream(\fopen('php://memory', 'r'));
    }

    /**
     * @covers ::withSourceStream()
     * @expectedException \InvalidArgumentException
     */
    public function testSourceStreamExceptionStringSet()
    {
        $entryEmpty = new ArchiveEntry('entry');
        $entry = $entryEmpty->withSourceString('content');
        $entry->withSourceStream(\fopen('php://memory', 'r'));
    }

    /**
     * @covers ::withSourceString()
     * @expectedException \InvalidArgumentException
     */
    public function testSourceStringExceptionPathSet()
    {
        $entryEmpty = new ArchiveEntry('entry');
        $entry = $entryEmpty->withSourcePath(__DIR__ . '/ipsum.txt');
        $entry->withSourceString('content');
    }

    /**
     * @covers ::withSourceString()
     * @expectedException \InvalidArgumentException
     */
    public function testSourceStringExceptionStreamSet()
    {
        $entryEmpty = new ArchiveEntry('entry');
        $entry = $entryEmpty->withSourceStream(\fopen('php://memory', 'r'));
        $entry->withSourceString('content');
    }

    /**
     * @covers ::withSourceString()
     * @expectedException \InvalidArgumentException
     */
    public function testSourceStringExceptionStringSet()
    {
        $entryEmpty = new ArchiveEntry('entry');
        $entry = $entryEmpty->withSourceString('content');
        $entry->withSourceString('content');
    }

    /**
     * @covers ::getSourceAsStream()
     */
    public function testGetSourceAsStreamFromPath()

    {
        $filename = __DIR__ . '/ipsum.txt';
        $stream = (new ArchiveEntry(\basename($filename)))->withSourcePath($filename)->getSourceAsStream();

        $this->assertTrue(\is_resource($stream));
        $this->assertSame(\file_get_contents($filename), \stream_get_contents($stream));
    }

    /**
     * @covers ::getSourceAsStream()
     */
    public function testGetSourceAsStreamFromStream()

    {
        $filename = __DIR__ . '/ipsum.txt';
        $stream = (new ArchiveEntry(\basename($filename)))->withSourceStream(\fopen($filename, 'r'))->getSourceAsStream();

        $this->assertTrue(\is_resource($stream));
        $this->assertSame(\file_get_contents($filename), \stream_get_contents($stream));
    }

    /**
     * @covers ::getSourceAsStream()
     */
    public function testGetSourceAsStreamFromString()

    {
        $filename = __DIR__ . '/ipsum.txt';
        $stream = (new ArchiveEntry(\basename($filename)))->withSourceString(\file_get_contents($filename))->getSourceAsStream();

        $this->assertTrue(\is_resource($stream));
        $this->assertSame(\file_get_contents($filename), \stream_get_contents($stream));
    }
}


1		<?php
2
3		/*
4		* (c) 2018 Dennis Birkholz <[email protected]>
5		*
6		* $Id$
7		* Author: $Format:%an <%ae>, %ai$
8		* Committer: $Format:%cn <%ce>, %ci$
9		*/
10
11		namespace morgue\archive;
12
13		use PHPUnit\Framework\TestCase;
14
15		/**
16		* @coversDefaultClass \morgue\archive\ArchiveEntry
17		*/
18		final class ArchiveEntryTest extends TestCase
19		{
20		public function testImmutability()
21		{
22		$old = new ArchiveEntry('name');
23
24		$value = 'new name';
25		$this->assertNotSame($value, $old->getName());
26		$new = $old->withName($value);
27		$this->assertNotSame($old, $new);
28		$this->assertNotSame($old->getName(), $new->getName());
29		$this->assertSame($value, $new->getName());
30		$old = $new;
31
32		$value = 12345;
33		$this->assertNotSame($value, $old->getUncompressedSize());
34		$new = $old->withUncompressedSize($value);
35		$this->assertNotSame($old, $new);
36		$this->assertNotSame($old->getUncompressedSize(), $new->getUncompressedSize());
37		$this->assertSame($value, $new->getUncompressedSize());
38		$old = $new;
39
40		$value = 23456;
41		$this->assertNotSame($value, $old->getSourceSize());
42		$new = $old->withSourceSize($value);
43		$this->assertNotSame($old, $new);
44		$this->assertNotSame($old->getSourceSize(), $new->getSourceSize());
45		$this->assertSame($value, $new->getSourceSize());
46		$old = $new;
47
48		$value = 34567;
49		$this->assertNotSame($value, $old->getTargetSize());
50		$new = $old->withTargetSize($value);
51		$this->assertNotSame($old, $new);
52		$this->assertNotSame($old->getTargetSize(), $new->getTargetSize());
53		$this->assertSame($value, $new->getTargetSize());
54		$old = $new;
55
56		$value = new \DateTimeImmutable();
57		$this->assertNotSame($value, $old->getCreationTime());
58		$new = $old->withCreationTime($value);
59		$this->assertNotSame($old, $new);
60		$this->assertNotSame($old->getCreationTime(), $new->getCreationTime());
61		$this->assertSame($value, $new->getCreationTime());
62		$old = $new;
63
64		$value = new \DateTimeImmutable();
65		$this->assertNotSame($value, $old->getModificationTime());
66		$new = $old->withModificationTime($value);
67		$this->assertNotSame($old, $new);
68		$this->assertNotSame($old->getModificationTime(), $new->getModificationTime());
69		$this->assertSame($value, $new->getModificationTime());
70		$old = $new;
71
72		$value = 45678;
73		$this->assertNotSame($value, $old->getChecksumCrc32());
74		$new = $old->withChecksumCrc32($value);
75		$this->assertNotSame($old, $new);
76		$this->assertNotSame($old->getChecksumCrc32(), $new->getChecksumCrc32());
77		$this->assertSame($value, $new->getChecksumCrc32());
78		$old = $new;
79
80		$value = 'another comment';
81		$this->assertNotSame($value, $old->getComment());
82		$new = $old->withComment($value);
83		$this->assertNotSame($old, $new);
84		$this->assertNotSame($old->getComment(), $new->getComment());
85		$this->assertSame($value, $new->getComment());
86		$old = $new;
87
88		$value = COMPRESSION_METHOD_LZMA;
89		$this->assertNotSame($value, $old->getSourceCompressionMethod());
90		$new = $old->withSourceCompressionMethod($value);
91		$this->assertNotSame($old, $new);
92		$this->assertNotSame($old->getSourceCompressionMethod(), $new->getSourceCompressionMethod());
93		$this->assertSame($value, $new->getSourceCompressionMethod());
94		$old = $new;
95
96		$value = COMPRESSION_METHOD_BZIP2;
97		$this->assertNotSame($value, $old->getTargetCompressionMethod());
98		$new = $old->withTargetCompressionMethod($value);
99		$this->assertNotSame($old, $new);
100		$this->assertNotSame($old->getTargetCompressionMethod(), $new->getTargetCompressionMethod());
101		$this->assertSame($value, $new->getTargetCompressionMethod());
102		$old = $new;
103
104		$value = 56789;
105		$this->assertNotSame($value, $old->getDosAttributes());
106		$new = $old->withDosAttributes($value);
107		$this->assertNotSame($old, $new);
108		$this->assertNotSame($old->getDosAttributes(), $new->getDosAttributes());
109		$this->assertSame($value, $new->getDosAttributes());
110		$old = $new;
111
112		$value = 67890;
113		$this->assertNotSame($value, $old->getUnixAttributes());
114		$new = $old->withUnixAttributes($value);
115		$this->assertNotSame($old, $new);
116		$this->assertNotSame($old->getUnixAttributes(), $new->getUnixAttributes());
117		$this->assertSame($value, $new->getUnixAttributes());
118		}
119
120		/**
121		* @covers ::getSourcePath()
122		* @covers ::withSourcePath()
123		* @covers ::importStat()
124		*/
125	View Code Duplication	public function testSourcePath()
		0 ignored issues – show Duplication introduced 2018-04-13 21:56 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
126		{
127		$filename = __DIR__ . '/ipsum.txt';
128		$stat = \stat($filename);
129
130		$entryEmpty = new ArchiveEntry(\basename($filename));
131		$entry = $entryEmpty->withSourcePath($filename, COMPRESSION_METHOD_STORE);
132
133		$this->assertNotSame($entryEmpty, $entry);
134		$this->assertSame($filename, $entry->getSourcePath());
135		$this->assertNull($entry->getSourceStream());
136		$this->assertNull($entry->getSourceString());
137		$this->assertSame(COMPRESSION_METHOD_STORE, $entry->getSourceCompressionMethod());
138		$this->assertSame($stat['size'], $entry->getSourceSize());
139		$this->assertSame($stat['size'], $entry->getUncompressedSize());
140		$this->assertSame($stat['mode'], $entry->getUnixAttributes());
141		$this->assertSame($stat['ctime'], $entry->getCreationTime()->getTimestamp());
142		$this->assertSame($stat['mtime'], $entry->getModificationTime()->getTimestamp());
143		}
144
145		/**
146		* @covers ::getSourcePath()
147		* @covers ::withSourcePath()
148		* @covers ::importStat()
149		*/
150		public function testSourcePathDirectory()
151		{
152		$filename = __DIR__;
153		$stat = \stat($filename);
154
155		$entryEmpty = new ArchiveEntry(\basename($filename));
156		$entry = $entryEmpty->withSourcePath($filename);
157
158		$this->assertNotSame($entryEmpty, $entry);
159		$this->assertSame($filename, $entry->getSourcePath());
160		$this->assertNull($entry->getSourceStream());
161		$this->assertNull($entry->getSourceString());
162		$this->assertSame(COMPRESSION_METHOD_STORE, $entry->getSourceCompressionMethod());
163		$this->assertSame(COMPRESSION_METHOD_STORE, $entry->getTargetCompressionMethod());
164		$this->assertSame(0, $entry->getSourceSize());
165		$this->assertSame(0, $entry->getTargetSize());
166		$this->assertSame(0, $entry->getUncompressedSize());
167		$this->assertSame($stat['mode'], $entry->getUnixAttributes());
168		$this->assertSame($stat['ctime'], $entry->getCreationTime()->getTimestamp());
169		$this->assertSame($stat['mtime'], $entry->getModificationTime()->getTimestamp());
170		}
171
172		/**
173		* @covers ::getSourceStream()
174		* @covers ::withSourceStream()
175		* @covers ::importStat()
176		*/
177	View Code Duplication	public function testSourceStream()
		0 ignored issues – show Duplication introduced 2018-04-13 21:56 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
178		{
179		$filename = __DIR__ . '/ipsum.txt';
180		$stream = \fopen($filename, 'r');
181		$stat = \fstat($stream);
182
183		$entryEmpty = new ArchiveEntry(\basename($filename));
184		$entry = $entryEmpty->withSourceStream($stream, COMPRESSION_METHOD_STORE);
185
186		$this->assertNotSame($entryEmpty, $entry);
187		$this->assertNull($entry->getSourcePath());
188		$this->assertSame($stream, $entry->getSourceStream());
189		$this->assertNull($entry->getSourceString());
190		$this->assertSame(COMPRESSION_METHOD_STORE, $entry->getSourceCompressionMethod());
191		$this->assertSame($stat['size'], $entry->getSourceSize());
192		$this->assertSame($stat['size'], $entry->getUncompressedSize());
193		$this->assertSame($stat['mode'], $entry->getUnixAttributes());
194		$this->assertSame($stat['ctime'], $entry->getCreationTime()->getTimestamp());
195		$this->assertSame($stat['mtime'], $entry->getModificationTime()->getTimestamp());
196		}
197
198		/**
199		* @covers ::getSourceString()
200		* @covers ::withSourceString()
201		*/
202		public function testSourceString()
203		{
204		$filename = __DIR__ . '/ipsum.txt';
205		$string = \file_get_contents($filename);
206
207		$entryEmpty = new ArchiveEntry(\basename($filename));
208		$timestamp1 = \time();
209		$entry = $entryEmpty->withSourceString($string, COMPRESSION_METHOD_STORE);
210		$timestamp2 = \time();
211
212		$this->assertNotSame($entryEmpty, $entry);
213		$this->assertNull($entry->getSourcePath());
214		$this->assertNull($entry->getSourceStream());
215		$this->assertSame($string, $entry->getSourceString());
216		$this->assertSame(COMPRESSION_METHOD_STORE, $entry->getSourceCompressionMethod());
217		$this->assertSame(\strlen($string), $entry->getSourceSize());
218		$this->assertSame(\strlen($string), $entry->getUncompressedSize());
219		$this->assertNull($entry->getUnixAttributes());
220		$this->assertTrue($timestamp1 <= $entry->getCreationTime()->getTimestamp() && $entry->getCreationTime()->getTimestamp() <= $timestamp2);
221		$this->assertTrue($timestamp1 <= $entry->getModificationTime()->getTimestamp() && $entry->getCreationTime()->getTimestamp() <= $timestamp2);
222		}
223
224		/**
225		* @covers ::withSourcePath()
226		* @expectedException \InvalidArgumentException
227		*/
228		public function testSourcePathExceptionInvalidFile()
229		{
230		$entry = new ArchiveEntry('entry');
231		$entry->withSourcePath(__DIR__ . '/non-existing-file');
232		}
233
234		/**
235		* @covers ::withSourcePath()
236		* @expectedException \InvalidArgumentException
237		*/
238		public function testSourcePathExceptionPathSet()
239		{
240		$entryEmpty = new ArchiveEntry('entry');
241		$entry = $entryEmpty->withSourcePath(__DIR__ . '/ipsum.txt');
242		$entry->withSourcePath(__FILE__);
243		}
244
245		/**
246		* @covers ::withSourcePath()
247		* @expectedException \InvalidArgumentException
248		*/
249		public function testSourcePathExceptionStreamSet()
250		{
251		$entryEmpty = new ArchiveEntry('entry');
252		$entry = $entryEmpty->withSourceStream(\fopen('php://memory', 'r'));
253		$entry->withSourcePath(__FILE__);
254		}
255
256		/**
257		* @covers ::withSourcePath()
258		* @expectedException \InvalidArgumentException
259		*/
260		public function testSourcePathExceptionStringSet()
261		{
262		$entryEmpty = new ArchiveEntry('entry');
263		$entry = $entryEmpty->withSourceString('content');
264		$entry->withSourcePath(__FILE__);
265		}
266
267		/**
268		* @covers ::withSourceStream()
269		* @expectedException \InvalidArgumentException
270		*/
271		public function testSourceStreamExceptionPathSet()
272		{
273		$entryEmpty = new ArchiveEntry('entry');
274		$entry = $entryEmpty->withSourcePath(__DIR__ . '/ipsum.txt');
275		$entry->withSourceStream(\fopen('php://memory', 'r'));
276		}
277
278		/**
279		* @covers ::withSourceStream()
280		* @expectedException \InvalidArgumentException
281		*/
282		public function testSourceStreamExceptionStreamSet()
283		{
284		$entryEmpty = new ArchiveEntry('entry');
285		$entry = $entryEmpty->withSourceStream(\fopen('php://memory', 'r'));
286		$entry->withSourceStream(\fopen('php://memory', 'r'));
287		}
288
289		/**
290		* @covers ::withSourceStream()
291		* @expectedException \InvalidArgumentException
292		*/
293		public function testSourceStreamExceptionStringSet()
294		{
295		$entryEmpty = new ArchiveEntry('entry');
296		$entry = $entryEmpty->withSourceString('content');
297		$entry->withSourceStream(\fopen('php://memory', 'r'));
298		}
299
300		/**
301		* @covers ::withSourceString()
302		* @expectedException \InvalidArgumentException
303		*/
304		public function testSourceStringExceptionPathSet()
305		{
306		$entryEmpty = new ArchiveEntry('entry');
307		$entry = $entryEmpty->withSourcePath(__DIR__ . '/ipsum.txt');
308		$entry->withSourceString('content');
309		}
310
311		/**
312		* @covers ::withSourceString()
313		* @expectedException \InvalidArgumentException
314		*/
315		public function testSourceStringExceptionStreamSet()
316		{
317		$entryEmpty = new ArchiveEntry('entry');
318		$entry = $entryEmpty->withSourceStream(\fopen('php://memory', 'r'));
319		$entry->withSourceString('content');
320		}
321
322		/**
323		* @covers ::withSourceString()
324		* @expectedException \InvalidArgumentException
325		*/
326		public function testSourceStringExceptionStringSet()
327		{
328		$entryEmpty = new ArchiveEntry('entry');
329		$entry = $entryEmpty->withSourceString('content');
330		$entry->withSourceString('content');
331		}
332
333		/**
334		* @covers ::getSourceAsStream()
335		*/
336	View Code Duplication	public function testGetSourceAsStreamFromPath()
		0 ignored issues – show Duplication introduced 2018-04-13 21:56 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
337		{
338		$filename = __DIR__ . '/ipsum.txt';
339		$stream = (new ArchiveEntry(\basename($filename)))->withSourcePath($filename)->getSourceAsStream();
340
341		$this->assertTrue(\is_resource($stream));
342		$this->assertSame(\file_get_contents($filename), \stream_get_contents($stream));
343		}
344
345		/**
346		* @covers ::getSourceAsStream()
347		*/
348	View Code Duplication	public function testGetSourceAsStreamFromStream()
		0 ignored issues – show Duplication introduced 2018-04-13 21:56 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
349		{
350		$filename = __DIR__ . '/ipsum.txt';
351		$stream = (new ArchiveEntry(\basename($filename)))->withSourceStream(\fopen($filename, 'r'))->getSourceAsStream();
352
353		$this->assertTrue(\is_resource($stream));
354		$this->assertSame(\file_get_contents($filename), \stream_get_contents($stream));
355		}
356
357		/**
358		* @covers ::getSourceAsStream()
359		*/
360	View Code Duplication	public function testGetSourceAsStreamFromString()
		0 ignored issues – show Duplication introduced 2018-04-13 21:56 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
361		{
362		$filename = __DIR__ . '/ipsum.txt';
363		$stream = (new ArchiveEntry(\basename($filename)))->withSourceString(\file_get_contents($filename))->getSourceAsStream();
364
365		$this->assertTrue(\is_resource($stream));
366		$this->assertSame(\file_get_contents($filename), \stream_get_contents($stream));
367		}
368		}
369

iqb / Morgue

testSourceStringExceptionStreamSet() A last analyzed 2018-04-13 22:37 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

testSourceStringExceptionStreamSet() A
last analyzed 2018-04-13 22:37 UTC