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

Zip64ExtendedInformationTest::dataProvider() D
last analyzed 2018-04-13 22:37 UTC

↳ Parent: Zip64ExtendedInformationTest

Complexity

Conditions	9
Paths	20

Size

Total Lines	99
Code Lines	76

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	9
eloc	76
nc	20
nop	0
dl	0
loc	99
rs	4.8531
c	0
b	0
f	0

How to fix Long Method

<?php

namespace morgue\zip\extraField;

use morgue\zip\CentralDirectoryHeader;
use morgue\zip\ExtraField;
use const morgue\zip\MAX_INT_16;
use const morgue\zip\MAX_INT_32;
use PHPUnit\Framework\TestCase;

final class Zip64ExtendedInformationTest extends TestCase
{
    public function dataProvider()
    {
        // originalSize, compressedSize, relativeHeaderOffset, diskNumber
        $sizesLong = [
            0,
            12345,
            MAX_INT_16,
            MAX_INT_32,
            64*1024*1024*1024,
            \PHP_INT_MAX
        ];

        $sizesShort = [
            0,
            12345,
            MAX_INT_16,
            2*1024*1024*1024,
            0x7FFFFFFF,
        ];

        $data = [];
        foreach ($sizesLong as $originalSize) {
            foreach ($sizesLong as $compressedSize) {
                foreach ($sizesLong as $relativeHeaderOffset) {
                    foreach ($sizesShort as $diskNumber) {
                        $name = $originalSize . ', ' . $compressedSize . ', ' . $relativeHeaderOffset . ', ' . $diskNumber;
                        $dataSize = 0;
                        $encoded = '';

                        if ($originalSize >= MAX_INT_32) {
                            $dataSize += 8;
                            $encoded .= \pack('P', $originalSize);
                            $parameterOriginalSize = $originalSize;
                            $legacyOriginalSize = MAX_INT_32;
                        } else {
                            $legacyOriginalSize = $originalSize;
                            $parameterOriginalSize = null;
                        }

                        if ($compressedSize >= MAX_INT_32) {
                            $dataSize += 8;
                            $encoded .= \pack('P', $compressedSize);
                            $legacyCompressedSize = MAX_INT_32;
                            $parameterCompressedSize = $compressedSize;
                        } else {
                            $legacyCompressedSize = $compressedSize;
                            $parameterCompressedSize = null;
                        }

                        if ($relativeHeaderOffset >= MAX_INT_32) {
                            $dataSize += 8;
                            $encoded .= \pack('P', $relativeHeaderOffset);
                            $legacyRelativeHeaderOffset = MAX_INT_32;
                            $parameterRelativeHeaderOffset = $relativeHeaderOffset;
                        } else {
                            $legacyRelativeHeaderOffset = $relativeHeaderOffset;
                            $parameterRelativeHeaderOffset = null;
                        }

                        if ($diskNumber >= MAX_INT_16) {
                            $dataSize += 4;
                            $encoded .= \pack('V', $diskNumber);
                            $legacyDiskNumber = MAX_INT_16;
                            $parameterDiskNumber = $diskNumber;
                        } else {
                            $legacyDiskNumber = $diskNumber;
                            $parameterDiskNumber = null;
                        }

                        $encoded = \pack('vv', Zip64ExtendedInformation::ID, $dataSize) . $encoded;

                        $data[$name] = [
                            $parameterOriginalSize,
                            $parameterCompressedSize,
                            $parameterRelativeHeaderOffset,
                            $parameterDiskNumber,
                            new CentralDirectoryHeader(
                                0,
                                0,
                                0,
                                0,
                                0,
                                0,
                                0,
                                $legacyCompressedSize,
                                $legacyOriginalSize,
                                $legacyDiskNumber,
                                0,
                                0,
                                $legacyRelativeHeaderOffset
                            ),
                            $encoded
                        ];
                    }
                }
            }
        }
        return $data;
    }

    /**
     * @dataProvider dataProvider
     */
    public function testExtraFieldParsing(int $originalSize = null, int $compressedSize = null, int $relativeHeaderOffset = null, int $diskNumber = null, CentralDirectoryHeader $context, string $expectedOutput)
    {
        $extendedField = Zip64ExtendedInformation::parse($expectedOutput, $context);
        $this->assertSame($originalSize, $extendedField->getOriginalSize(), 'Parsed original size');
        $this->assertSame($compressedSize, $extendedField->getCompressedSize(), 'Parsed compressed size');
        $this->assertSame($relativeHeaderOffset, $extendedField->getRelativeHeaderOffset(), 'Parsed relative header offset');
        $this->assertSame($diskNumber, $extendedField->getDiskStartNumber(), 'Parsed disk start number');
    }

    /**
     * @dataProvider dataProvider
     */
    public function testExtraFieldGeneration(int $originalSize = null, int $compressedSize = null, int $relativeHeaderOffset = null, int $diskNumber = null, CentralDirectoryHeader $context, string $expectedOutput)

    {
        $extendedField = new Zip64ExtendedInformation($originalSize, $compressedSize, $relativeHeaderOffset, $diskNumber);
        $this->assertSame($expectedOutput, ExtraField::marshal($extendedField), 'Generated field data');
    }

    public function testImmutability()
    {
        $old = new Zip64ExtendedInformation();

        // Compressed size
        $new = $old->setCompressedSize(12345);
        $this->assertNotSame($old, $new);
        $this->assertNull($old->getCompressedSize());
        $this->assertSame(12345, $new->getCompressedSize());

        $old = $new;
        $new = $old->setOriginalSize(23456);
        $this->assertNotSame($old, $new);
        $this->assertNull($old->getOriginalSize());
        $this->assertSame(23456, $new->getOriginalSize());

        $old = $new;
        $new = $old->setRelativeHeaderOffset(34567);
        $this->assertNotSame($old, $new);
        $this->assertNull($old->getRelativeHeaderOffset());
        $this->assertSame(34567, $new->getRelativeHeaderOffset());

        $old = $new;
        $new = $old->setDiskStartNumber(45678);
        $this->assertNotSame($old, $new);
        $this->assertNull($old->getDiskStartNumber());
        $this->assertSame(45678, $new->getDiskStartNumber());
    }

    public function testInvalidLength()
    {
        $input = \pack('vv', Zip64ExtendedInformation::ID, 0);
        $context = new CentralDirectoryHeader(0,0,0,0,0,0,0,MAX_INT_32,0,0,0,0,0);

        $this->expectException(\InvalidArgumentException::class);
        Zip64ExtendedInformation::parse($input, $context);
    }

    public function testInvalidHeaderId()
    {
        $input = \pack('vv', 12345, 0);
        $context = new CentralDirectoryHeader(0,0,0,0,0,0,0,0,0,0,0,0,0);

        $this->expectException(\InvalidArgumentException::class);
        Zip64ExtendedInformation::parse($input, $context);
    }
}


1			<?php
2
3			namespace morgue\zip\extraField;
4
5			use morgue\zip\CentralDirectoryHeader;
6			use morgue\zip\ExtraField;
7			use const morgue\zip\MAX_INT_16;
8			use const morgue\zip\MAX_INT_32;
9			use PHPUnit\Framework\TestCase;
10
11			final class Zip64ExtendedInformationTest extends TestCase
12			{
13			public function dataProvider()
14			{
15			// originalSize, compressedSize, relativeHeaderOffset, diskNumber
16			$sizesLong = [
17			0,
18			12345,
19			MAX_INT_16,
20			MAX_INT_32,
21			6410241024*1024,
22			\PHP_INT_MAX
23			];
24
25			$sizesShort = [
26			0,
27			12345,
28			MAX_INT_16,
29			210241024*1024,
30			0x7FFFFFFF,
31			];
32
33			$data = [];
34			foreach ($sizesLong as $originalSize) {
35			foreach ($sizesLong as $compressedSize) {
36			foreach ($sizesLong as $relativeHeaderOffset) {
37			foreach ($sizesShort as $diskNumber) {
38			$name = $originalSize . ', ' . $compressedSize . ', ' . $relativeHeaderOffset . ', ' . $diskNumber;
39			$dataSize = 0;
40			$encoded = '';
41
42			if ($originalSize >= MAX_INT_32) {
43			$dataSize += 8;
44			$encoded .= \pack('P', $originalSize);
45			$parameterOriginalSize = $originalSize;
46			$legacyOriginalSize = MAX_INT_32;
47			} else {
48			$legacyOriginalSize = $originalSize;
49			$parameterOriginalSize = null;
50			}
51
52			if ($compressedSize >= MAX_INT_32) {
53			$dataSize += 8;
54			$encoded .= \pack('P', $compressedSize);
55			$legacyCompressedSize = MAX_INT_32;
56			$parameterCompressedSize = $compressedSize;
57			} else {
58			$legacyCompressedSize = $compressedSize;
59			$parameterCompressedSize = null;
60			}
61
62			if ($relativeHeaderOffset >= MAX_INT_32) {
63			$dataSize += 8;
64			$encoded .= \pack('P', $relativeHeaderOffset);
65			$legacyRelativeHeaderOffset = MAX_INT_32;
66			$parameterRelativeHeaderOffset = $relativeHeaderOffset;
67			} else {
68			$legacyRelativeHeaderOffset = $relativeHeaderOffset;
69			$parameterRelativeHeaderOffset = null;
70			}
71
72			if ($diskNumber >= MAX_INT_16) {
73			$dataSize += 4;
74			$encoded .= \pack('V', $diskNumber);
75			$legacyDiskNumber = MAX_INT_16;
76			$parameterDiskNumber = $diskNumber;
77			} else {
78			$legacyDiskNumber = $diskNumber;
79			$parameterDiskNumber = null;
80			}
81
82			$encoded = \pack('vv', Zip64ExtendedInformation::ID, $dataSize) . $encoded;
83
84			$data[$name] = [
85			$parameterOriginalSize,
86			$parameterCompressedSize,
87			$parameterRelativeHeaderOffset,
88			$parameterDiskNumber,
89			new CentralDirectoryHeader(
90			0,
91			0,
92			0,
93			0,
94			0,
95			0,
96			0,
97			$legacyCompressedSize,
98			$legacyOriginalSize,
99			$legacyDiskNumber,
100			0,
101			0,
102			$legacyRelativeHeaderOffset
103			),
104			$encoded
105			];
106			}
107			}
108			}
109			}
110			return $data;
111			}
112
113			/**
114			* @dataProvider dataProvider
115			*/
116			public function testExtraFieldParsing(int $originalSize = null, int $compressedSize = null, int $relativeHeaderOffset = null, int $diskNumber = null, CentralDirectoryHeader $context, string $expectedOutput)
117			{
118			$extendedField = Zip64ExtendedInformation::parse($expectedOutput, $context);
119			$this->assertSame($originalSize, $extendedField->getOriginalSize(), 'Parsed original size');
120			$this->assertSame($compressedSize, $extendedField->getCompressedSize(), 'Parsed compressed size');
121			$this->assertSame($relativeHeaderOffset, $extendedField->getRelativeHeaderOffset(), 'Parsed relative header offset');
122			$this->assertSame($diskNumber, $extendedField->getDiskStartNumber(), 'Parsed disk start number');
123			}
124
125			/**
126			* @dataProvider dataProvider
127			*/
128			public function testExtraFieldGeneration(int $originalSize = null, int $compressedSize = null, int $relativeHeaderOffset = null, int $diskNumber = null, CentralDirectoryHeader $context, string $expectedOutput)
			0 ignored issues – show Unused Code introduced 2018-04-13 21:56 UTC by Report Bug Copy Issue Report The parameter `$context` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
129			{
130			$extendedField = new Zip64ExtendedInformation($originalSize, $compressedSize, $relativeHeaderOffset, $diskNumber);
131			$this->assertSame($expectedOutput, ExtraField::marshal($extendedField), 'Generated field data');
132			}
133
134			public function testImmutability()
135			{
136			$old = new Zip64ExtendedInformation();
137
138			// Compressed size
139			$new = $old->setCompressedSize(12345);
140			$this->assertNotSame($old, $new);
141			$this->assertNull($old->getCompressedSize());
142			$this->assertSame(12345, $new->getCompressedSize());
143
144			$old = $new;
145			$new = $old->setOriginalSize(23456);
146			$this->assertNotSame($old, $new);
147			$this->assertNull($old->getOriginalSize());
148			$this->assertSame(23456, $new->getOriginalSize());
149
150			$old = $new;
151			$new = $old->setRelativeHeaderOffset(34567);
152			$this->assertNotSame($old, $new);
153			$this->assertNull($old->getRelativeHeaderOffset());
154			$this->assertSame(34567, $new->getRelativeHeaderOffset());
155
156			$old = $new;
157			$new = $old->setDiskStartNumber(45678);
158			$this->assertNotSame($old, $new);
159			$this->assertNull($old->getDiskStartNumber());
160			$this->assertSame(45678, $new->getDiskStartNumber());
161			}
162
163			public function testInvalidLength()
164			{
165			$input = \pack('vv', Zip64ExtendedInformation::ID, 0);
166			$context = new CentralDirectoryHeader(0,0,0,0,0,0,0,MAX_INT_32,0,0,0,0,0);
167
168			$this->expectException(\InvalidArgumentException::class);
169			Zip64ExtendedInformation::parse($input, $context);
170			}
171
172			public function testInvalidHeaderId()
173			{
174			$input = \pack('vv', 12345, 0);
175			$context = new CentralDirectoryHeader(0,0,0,0,0,0,0,0,0,0,0,0,0);
176
177			$this->expectException(\InvalidArgumentException::class);
178			Zip64ExtendedInformation::parse($input, $context);
179			}
180			}
181

iqb / Morgue

Zip64ExtendedInformationTest::dataProvider() D last analyzed 2018-04-13 22:37 UTC

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like

Zip64ExtendedInformationTest::dataProvider() D
last analyzed 2018-04-13 22:37 UTC