repo stringlengths 7 63 | file_url stringlengths 81 284 | file_path stringlengths 5 200 | content stringlengths 0 32.8k | language stringclasses 1
value | license stringclasses 7
values | commit_sha stringlengths 40 40 | retrieved_at stringdate 2026-01-04 15:02:33 2026-01-05 05:24:06 | truncated bool 2
classes |
|---|---|---|---|---|---|---|---|---|
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/CondNumFmtTest.php | tests/PhpSpreadsheetTests/Reader/Xlsx/CondNumFmtTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\Style\Conditional;
use PHPUnit\Framework\TestCase;
class CondNumFmtTest extends TestCase
{
public function testLoadCondNumFmt(): void
{
$filename = 'tests/data/Reader/XLSX/condfmtnum.xlsx';
$reader = new Xlsx();
$spreadsheet = $reader->load($filename);
$worksheet = $spreadsheet->getActiveSheet();
// NumberFormat explicitly set in following conditional style
$conditionalStyle = $worksheet->getConditionalStyles('A1:A3');
self::assertNotEmpty($conditionalStyle);
$conditionalRule = $conditionalStyle[0];
$conditions = $conditionalRule->getConditions();
self::assertNotEmpty($conditions);
self::assertEquals(Conditional::CONDITION_EXPRESSION, $conditionalRule->getConditionType());
self::assertEquals('MONTH(A1)=10', $conditions[0]);
$numfmt = $conditionalRule->getStyle()->getNumberFormat()->getFormatCode();
self::assertEquals('yyyy/mm/dd', $numfmt);
// NumberFormat not set in following conditional style
$conditionalStyle = $worksheet->getConditionalStyles('B1');
self::assertNotEmpty($conditionalStyle);
$conditionalRule = $conditionalStyle[0];
$conditions = $conditionalRule->getConditions();
self::assertNotEmpty($conditions);
self::assertEquals(Conditional::CONDITION_EXPRESSION, $conditionalRule->getConditionType());
self::assertEquals('AND(B1>=2000,B1<3000)', $conditions[0]);
$numfmt = $conditionalRule->getStyle()->getNumberFormat()->getFormatCode();
self::assertEquals('', $numfmt);
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/Issue2331Test.php | tests/PhpSpreadsheetTests/Reader/Xlsx/Issue2331Test.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use DateTimeZone;
use PhpOffice\PhpSpreadsheet\IOFactory;
use PhpOffice\PhpSpreadsheet\Shared\Date;
use PHPUnit\Framework\TestCase;
class Issue2331Test extends TestCase
{
public function testIssue2331(): void
{
// Leading space instead of 0 in month and/or day of timestamp.
$filename = 'tests/data/Reader/XLSX/issue.2331c.xlsx';
$reader = IOFactory::createReader('Xlsx');
$spreadsheet = $reader->load($filename);
$properties = $spreadsheet->getProperties();
$created = (string) $properties->getCreated();
$modified = (string) $properties->getModified();
self::assertEquals('2021-08-02', Date::formattedDateTimeFromTimestamp($created, 'Y-m-d', new DateTimeZone('UTC')));
self::assertEquals('2021-09-03', Date::formattedDateTimeFromTimestamp($modified, 'Y-m-d', new DateTimeZone('UTC')));
$spreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/DefaultFontTest.php | tests/PhpSpreadsheetTests/Reader/Xlsx/DefaultFontTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\IOFactory;
use PHPUnit\Framework\TestCase;
class DefaultFontTest extends TestCase
{
public function testDefaultConditionalFont(): void
{
// default fill pattern for a conditional style where the filltype is not defined
$filename = 'tests/data/Reader/XLSX/pr2050cf-fill.xlsx';
$reader = IOFactory::createReader('Xlsx');
$spreadsheet = $reader->load($filename);
$style = $spreadsheet->getActiveSheet()->getConditionalStyles('A1')[0]->getStyle();
self::assertSame('9C0006', $style->getFont()->getColor()->getRGB());
self::assertNull($style->getFont()->getName());
self::assertNull($style->getFont()->getSize());
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/Issue2581Test.php | tests/PhpSpreadsheetTests/Reader/Xlsx/Issue2581Test.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx;
use PHPUnit\Framework\TestCase;
class Issue2581Test extends TestCase
{
private static string $testbook = 'tests/data/Reader/XLSX/issue.2581.xlsx';
public function testIssue2581(): void
{
// CELL function (unimplemented) embedded in another function
$filename = self::$testbook;
$reader = new Xlsx();
$spreadsheet = $reader->load($filename);
$sheet = $spreadsheet->getActiveSheet();
self::assertSame('=CONCATENATE("Prefix ",MID(CELL("filename"),FIND("]",CELL("filename"))+1,255), " Suffix")', $sheet->getCell('B1')->getValue());
self::assertSame('Prefix SomeName Suffix', $sheet->getCell('B1')->getCalculatedValue());
$spreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/ConditionalColorScaleTest.php | tests/PhpSpreadsheetTests/Reader/Xlsx/ConditionalColorScaleTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\IOFactory;
use PhpOffice\PhpSpreadsheetTests\Functional\AbstractFunctional;
class ConditionalColorScaleTest extends AbstractFunctional
{
public function testColorScale(): void
{
$filename = 'tests/data/Reader/XLSX/colorscale.xlsx';
$reader = IOFactory::createReader('Xlsx');
$spreadsheet = $reader->load($filename);
$reloadedSpreadsheet = $this->writeAndReload($spreadsheet, 'Xlsx');
$spreadsheet->disconnectWorksheets();
$worksheet = $reloadedSpreadsheet->getActiveSheet();
$styles = $worksheet->getConditionalStyles('A1:A10');
self::assertCount(1, $styles);
$colorScale = $styles[0]->getColorScale();
self::assertNotNull($colorScale);
self::assertNotNull($colorScale->getMinimumConditionalFormatValueObject());
self::assertNotNull($colorScale->getMidpointConditionalFormatValueObject());
self::assertSame('50', $colorScale->getMidpointConditionalFormatValueObject()->getValue());
self::assertNotNull($colorScale->getMaximumConditionalFormatValueObject());
self::assertSame('FFF8696B', $colorScale->getMinimumColor()?->getARGB());
self::assertSame('FFFFEB84', $colorScale->getMidpointColor()?->getARGB());
self::assertSame('FF63BE7B', $colorScale->getMaximumColor()?->getARGB());
$reloadedSpreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/Issue1637Test.php | tests/PhpSpreadsheetTests/Reader/Xlsx/Issue1637Test.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx;
use PHPUnit\Framework\TestCase;
class Issue1637Test extends TestCase
{
private static string $testbook = 'tests/data/Reader/XLSX/issue.1637.xlsx';
public function testXludf(): void
{
$reader = new Xlsx();
$spreadsheet = $reader->load(self::$testbook);
$sheet = $spreadsheet->getActiveSheet();
self::assertSame(
'=IFERROR(__xludf.DUMMYFUNCTION("flatten(A1:A5, B1:B5)"),1.0)',
$sheet->getCell('C1')->getValue()
);
self::assertSame(1.0, $sheet->getCell('C1')->getCalculatedValue());
$spreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/PageSetupTest.php | tests/PhpSpreadsheetTests/Reader/Xlsx/PageSetupTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\Worksheet\PageSetup;
use PHPUnit\Framework\TestCase;
class PageSetupTest extends TestCase
{
private const MARGIN_PRECISION = 0.00000001;
private const MARGIN_UNIT_CONVERSION = 2.54; // Inches to cm
private const FILENAME = 'tests/data/Reader/XLSX/PageSetup.xlsx';
public function testPageSetup(): void
{
$reader = new Xlsx();
$spreadsheet = $reader->load(self::FILENAME);
$assertions = $this->pageSetupAssertions();
foreach ($spreadsheet->getAllSheets() as $worksheet) {
if (!array_key_exists($worksheet->getTitle(), $assertions)) {
continue;
}
$sheetAssertions = $assertions[$worksheet->getTitle()];
foreach ($sheetAssertions as $test => $expectedResult) {
$testMethodName = 'get' . ucfirst($test);
$actualResult = $worksheet->getPageSetup()->$testMethodName();
self::assertSame(
$expectedResult,
$actualResult,
"Failed assertion for Worksheet '{$worksheet->getTitle()}' {$test}"
);
}
}
$spreadsheet->disconnectWorksheets();
}
public function testPageMargins(): void
{
$reader = new Xlsx();
$spreadsheet = $reader->load(self::FILENAME);
$assertions = $this->pageMarginAssertions();
foreach ($spreadsheet->getAllSheets() as $worksheet) {
if (!array_key_exists($worksheet->getTitle(), $assertions)) {
continue;
}
$sheetAssertions = $assertions[$worksheet->getTitle()];
foreach ($sheetAssertions as $test => $expectedResult) {
$testMethodName = 'get' . ucfirst($test);
$actualResult = $worksheet->getPageMargins()->$testMethodName();
self::assertEqualsWithDelta(
$expectedResult,
$actualResult,
self::MARGIN_PRECISION,
"Failed assertion for Worksheet '{$worksheet->getTitle()}' {$test} margin"
);
}
}
$spreadsheet->disconnectWorksheets();
}
/** @return array<array{orientation: string, scale: int, horizontalCentered: bool, verticalCentered: bool, pageOrder: string}> */
private function pageSetupAssertions(): array
{
return [
'Sheet1' => [
'orientation' => PageSetup::ORIENTATION_PORTRAIT,
'scale' => 75,
'horizontalCentered' => true,
'verticalCentered' => false,
'pageOrder' => PageSetup::PAGEORDER_DOWN_THEN_OVER,
],
'Sheet2' => [
'orientation' => PageSetup::ORIENTATION_LANDSCAPE,
'scale' => 100,
'horizontalCentered' => false,
'verticalCentered' => true,
'pageOrder' => PageSetup::PAGEORDER_OVER_THEN_DOWN,
],
'Sheet3' => [
'orientation' => PageSetup::ORIENTATION_PORTRAIT,
'scale' => 90,
'horizontalCentered' => true,
'verticalCentered' => true,
'pageOrder' => PageSetup::PAGEORDER_DOWN_THEN_OVER,
],
'Sheet4' => [
// Default Settings
'orientation' => PageSetup::ORIENTATION_DEFAULT,
'scale' => 100,
'horizontalCentered' => false,
'verticalCentered' => false,
'pageOrder' => PageSetup::PAGEORDER_DOWN_THEN_OVER,
],
];
}
/** @return array<array{top: float, header: float, left: float, right: float, bottom: float, footer: float}> */
private function pageMarginAssertions(): array
{
return [
'Sheet1' => [
// Here the values are in cm, so we convert to inches for comparison with internal uom
'top' => 2.4 / self::MARGIN_UNIT_CONVERSION,
'header' => 0.8 / self::MARGIN_UNIT_CONVERSION,
'left' => 1.3 / self::MARGIN_UNIT_CONVERSION,
'right' => 1.3 / self::MARGIN_UNIT_CONVERSION,
'bottom' => 1.9 / self::MARGIN_UNIT_CONVERSION,
'footer' => 0.8 / self::MARGIN_UNIT_CONVERSION,
],
'Sheet2' => [
// Here the values are in cm, so we convert to inches for comparison with internal uom
'top' => 1.9 / self::MARGIN_UNIT_CONVERSION,
'header' => 0.8 / self::MARGIN_UNIT_CONVERSION,
'left' => 1.8 / self::MARGIN_UNIT_CONVERSION,
'right' => 1.8 / self::MARGIN_UNIT_CONVERSION,
'bottom' => 1.9 / self::MARGIN_UNIT_CONVERSION,
'footer' => 0.8 / self::MARGIN_UNIT_CONVERSION,
],
'Sheet3' => [
// Here the values are in cm, so we convert to inches for comparison with internal uom
'top' => 2.4 / self::MARGIN_UNIT_CONVERSION,
'header' => 1.3 / self::MARGIN_UNIT_CONVERSION,
'left' => 1.8 / self::MARGIN_UNIT_CONVERSION,
'right' => 1.8 / self::MARGIN_UNIT_CONVERSION,
'bottom' => 2.4 / self::MARGIN_UNIT_CONVERSION,
'footer' => 1.3 / self::MARGIN_UNIT_CONVERSION,
],
'Sheet4' => [
// Default Settings (already in inches for comparison)
'top' => 0.75,
'header' => 0.3,
'left' => 0.7,
'right' => 0.7,
'bottom' => 0.75,
'footer' => 0.3,
],
];
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/WorksheetInfoNamesTest.php | tests/PhpSpreadsheetTests/Reader/Xlsx/WorksheetInfoNamesTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx;
use PHPUnit\Framework\TestCase;
class WorksheetInfoNamesTest extends TestCase
{
public function testListWorksheetInfo(): void
{
$filename = 'tests/data/Reader/XLSX/rowColumnAttributeTest.xlsx';
$reader = new Xlsx();
$actual = $reader->listWorksheetInfo($filename);
$expected = [
[
'worksheetName' => 'Sheet1',
'lastColumnLetter' => 'F',
'lastColumnIndex' => 5,
'totalRows' => '6',
'totalColumns' => 6,
'sheetState' => 'visible',
],
];
self::assertEquals($expected, $actual);
}
public function testListWorksheetInfoNamespace(): void
{
$filename = 'tests/data/Reader/XLSX/namespaces.xlsx';
$file = 'zip://';
$file .= $filename;
$file .= '#xl/workbook.xml';
$data = file_get_contents($file);
// confirm that file contains expected namespaced xml tag
if ($data === false) {
self::fail('Unable to read file');
} else {
self::assertStringContainsString('<x:workbook ', $data);
}
$reader = new Xlsx();
$actual = $reader->listWorksheetInfo($filename);
$expected = [
[
'worksheetName' => 'transactions',
'lastColumnLetter' => 'K',
'lastColumnIndex' => 10,
'totalRows' => 2,
'totalColumns' => 11,
'sheetState' => 'visible',
],
];
self::assertEquals($expected, $actual);
}
public function testListWorksheetNames(): void
{
$filename = 'tests/data/Reader/XLSX/rowColumnAttributeTest.xlsx';
$reader = new Xlsx();
$actual = $reader->listWorksheetNames($filename);
$expected = ['Sheet1'];
self::assertEquals($expected, $actual);
}
public function testListWorksheetNamesNamespace(): void
{
$filename = 'tests/data/Reader/XLSX/namespaces.xlsx';
$reader = new Xlsx();
$actual = $reader->listWorksheetNames($filename);
$expected = ['transactions'];
self::assertEquals($expected, $actual);
}
public function testListWorksheetNamesChartSheet(): void
{
$filename = 'tests/data/Reader/XLSX/ChartSheet.xlsx';
$reader = new Xlsx();
$actual = $reader->listWorksheetNames($filename);
$expected = ['Sheet1', 'Chart1'];
self::assertEquals($expected, $actual);
}
public function testListWorksheetInfoChartSheet(): void
{
$filename = 'tests/data/Reader/XLSX/ChartSheet.xlsx';
$reader = new Xlsx();
$actual = $reader->listWorksheetInfo($filename);
$chartSheetInfo = $actual[1];
self::assertSame('Chart1', $chartSheetInfo['worksheetName']);
self::assertSame(-1, $chartSheetInfo['lastColumnIndex']);
self::assertSame(0, $chartSheetInfo['totalRows']);
self::assertSame(0, $chartSheetInfo['totalColumns']);
}
public function testListWorksheetMissingRows(): void
{
$filename = 'tests/data/Reader/XLSX/issue.3255.xlsx';
$reader = new Xlsx();
$actual = $reader->listWorksheetInfo($filename);
self::assertSame(4, $actual[0]['totalColumns']);
self::assertSame(1048576, $actual[0]['totalRows']);
$reader->setReadEmptyCells(false);
$actual = $reader->listWorksheetInfo($filename);
self::assertSame(3, $actual[0]['totalColumns'], 'all cells in D have no data');
self::assertSame(15, $actual[0]['totalRows'], 'rows 16 and 1048576 have no cells with data');
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/IgnoredErrorTest.php | tests/PhpSpreadsheetTests/Reader/Xlsx/IgnoredErrorTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\Cell\DataType;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheetTests\Functional\AbstractFunctional;
class IgnoredErrorTest extends AbstractFunctional
{
private const FILENAME = 'tests/data/Reader/XLSX/ignoreerror.xlsx';
public function testIgnoredError(): void
{
$reader = new Xlsx();
$originalSpreadsheet = $reader->load(self::FILENAME);
$spreadsheet = $this->writeAndReload($originalSpreadsheet, 'Xlsx');
$originalSpreadsheet->disconnectWorksheets();
$sheet = $spreadsheet->getActiveSheet();
self::assertFalse($sheet->getCell('A1')->getIgnoredErrors()->getNumberStoredAsText());
self::assertTrue($sheet->getCell('A2')->getIgnoredErrors()->getNumberStoredAsText());
self::assertFalse($sheet->getCell('A3')->getIgnoredErrors()->getNumberStoredAsText());
self::assertTrue($sheet->getCell('A4')->getIgnoredErrors()->getNumberStoredAsText());
self::assertFalse($sheet->getCell('H2')->getIgnoredErrors()->getNumberStoredAsText());
self::assertTrue($sheet->getCell('H3')->getIgnoredErrors()->getNumberStoredAsText());
self::assertFalse($sheet->getCell('I2')->getIgnoredErrors()->getNumberStoredAsText());
self::assertTrue($sheet->getCell('I3')->getIgnoredErrors()->getNumberStoredAsText());
self::assertFalse($sheet->getCell('H3')->getIgnoredErrors()->getFormula());
self::assertFalse($sheet->getCell('D2')->getIgnoredErrors()->getFormula());
self::assertTrue($sheet->getCell('D3')->getIgnoredErrors()->getFormula());
self::assertFalse($sheet->getCell('A11')->getIgnoredErrors()->getTwoDigitTextYear());
self::assertTrue($sheet->getCell('A12')->getIgnoredErrors()->getTwoDigitTextYear());
self::assertFalse($sheet->getCell('C12')->getIgnoredErrors()->getEvalError());
self::assertTrue($sheet->getCell('C11')->getIgnoredErrors()->getEvalError());
self::assertFalse($sheet->getCell('E14')->getIgnoredErrors()->getFormulaRange());
self::assertTrue($sheet->getCell('F14')->getIgnoredErrors()->getFormulaRange());
$sheetLast = $spreadsheet->getSheetByNameOrThrow('Last');
self::assertFalse($sheetLast->getCell('D2')->getIgnoredErrors()->getFormula());
self::assertFalse($sheetLast->getCell('D3')->getIgnoredErrors()->getFormula(), 'prior sheet ignoredErrors shouldn\'t bleed');
self::assertFalse($sheetLast->getCell('A1')->getIgnoredErrors()->getNumberStoredAsText());
self::assertFalse($sheetLast->getCell('A2')->getIgnoredErrors()->getNumberStoredAsText());
self::assertTrue($sheetLast->getCell('A3')->getIgnoredErrors()->getNumberStoredAsText());
self::assertFalse($sheetLast->getCell('A4')->getIgnoredErrors()->getNumberStoredAsText(), 'prior sheet numberStoredAsText shouldn\'t bleed');
$spreadsheet->disconnectWorksheets();
}
public function testSetIgnoredError(): void
{
$originalSpreadsheet = new Spreadsheet();
$originalSheet = $originalSpreadsheet->getActiveSheet();
$originalSheet->getCell('A1')->setValueExplicit('0', DataType::TYPE_STRING);
$originalSheet->getCell('A2')->setValueExplicit('1', DataType::TYPE_STRING);
$originalSheet->getStyle('A1:A2')->setQuotePrefix(true);
$originalSheet->getCell('A2')->getIgnoredErrors()->setNumberStoredAsText(true);
$spreadsheet = $this->writeAndReload($originalSpreadsheet, 'Xlsx');
$originalSpreadsheet->disconnectWorksheets();
$sheet = $spreadsheet->getActiveSheet();
self::assertSame('0', $sheet->getCell('A1')->getValue());
self::assertSame('1', $sheet->getCell('A2')->getValue());
self::assertFalse($sheet->getCell('A1')->getIgnoredErrors()->getNumberStoredAsText());
self::assertTrue($sheet->getCell('A2')->getIgnoredErrors()->getNumberStoredAsText());
$spreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/DateReaderTest.php | tests/PhpSpreadsheetTests/Reader/Xlsx/DateReaderTest.php | <?php
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\Shared\Date;
use PHPUnit\Framework\TestCase;
class DateReaderTest extends TestCase
{
protected function tearDown(): void
{
Date::setExcelCalendar(Date::CALENDAR_WINDOWS_1900);
}
public function testReadExcel1900Spreadsheet(): void
{
$filename = 'tests/data/Reader/XLSX/1900_Calendar.xlsx';
$reader = new Xlsx();
$spreadsheet = $reader->load($filename);
self::assertSame(Date::CALENDAR_WINDOWS_1900, $spreadsheet->getExcelCalendar());
$worksheet = $spreadsheet->getActiveSheet();
self::assertSame(44562, $worksheet->getCell('A1')->getValue());
self::assertSame('2022-01-01', $worksheet->getCell('A1')->getFormattedValue());
self::assertSame(44926, $worksheet->getCell('A2')->getValue());
self::assertSame('2022-12-31', $worksheet->getCell('A2')->getFormattedValue());
self::assertSame(44561, $worksheet->getCell('B1')->getCalculatedValue());
self::assertSame('2021-12-31', $worksheet->getCell('B1')->getFormattedValue());
self::assertSame(44927, $worksheet->getCell('B2')->getCalculatedValue());
self::assertSame('2023-01-01', $worksheet->getCell('B2')->getFormattedValue());
$spreadsheet->disconnectWorksheets();
}
public function testReadExcel1904Spreadsheet(): void
{
$filename = 'tests/data/Reader/XLSX/1904_Calendar.xlsx';
$reader = new Xlsx();
$spreadsheet = $reader->load($filename);
self::assertSame(Date::CALENDAR_MAC_1904, $spreadsheet->getExcelCalendar());
$worksheet = $spreadsheet->getActiveSheet();
self::assertSame(43100, $worksheet->getCell('A1')->getValue());
self::assertSame('2022-01-01', $worksheet->getCell('A1')->getFormattedValue());
self::assertSame(43464, $worksheet->getCell('A2')->getValue());
self::assertSame('2022-12-31', $worksheet->getCell('A2')->getFormattedValue());
self::assertSame(43099, $worksheet->getCell('B1')->getCalculatedValue());
self::assertSame('2021-12-31', $worksheet->getCell('B1')->getFormattedValue());
self::assertSame(43465, $worksheet->getCell('B2')->getCalculatedValue());
self::assertSame('2023-01-01', $worksheet->getCell('B2')->getFormattedValue());
$spreadsheet->disconnectWorksheets();
}
public function testNewDateInLoadedExcel1900Spreadsheet(): void
{
$filename = 'tests/data/Reader/XLSX/1900_Calendar.xlsx';
$reader = new Xlsx();
$spreadsheet = $reader->load($filename);
$worksheet = $spreadsheet->getActiveSheet();
$worksheet->getCell('A4')->setValue('=DATE(2023,1,1)');
self::assertEquals(44927, $worksheet->getCell('A4')->getCalculatedValue());
$spreadsheet->disconnectWorksheets();
}
public function testNewDateInLoadedExcel1904Spreadsheet(): void
{
$filename = 'tests/data/Reader/XLSX/1904_Calendar.xlsx';
$reader = new Xlsx();
$spreadsheet = $reader->load($filename);
$worksheet = $spreadsheet->getActiveSheet();
$worksheet->getCell('A4')->setValue('=DATE(2023,1,1)');
self::assertEquals(43465, $worksheet->getCell('A4')->getCalculatedValue());
$spreadsheet->disconnectWorksheets();
}
public function testSwitchCalendars(): void
{
$filename1904 = 'tests/data/Reader/XLSX/1904_Calendar.xlsx';
$reader1904 = new Xlsx();
$spreadsheet1904 = $reader1904->load($filename1904);
$worksheet1904 = $spreadsheet1904->getActiveSheet();
$date1 = Date::convertIsoDate('2022-01-01');
self::assertSame(43100.0, $date1);
$filename1900 = 'tests/data/Reader/XLSX/1900_Calendar.xlsx';
$reader1900 = new Xlsx();
$spreadsheet1900 = $reader1900->load($filename1900);
$worksheet1900 = $spreadsheet1900->getActiveSheet();
$date2 = Date::convertIsoDate('2022-01-01');
self::assertSame(44562.0, $date2);
self::assertSame(44562, $worksheet1900->getCell('A1')->getValue());
self::assertSame('2022-01-01', $worksheet1900->getCell('A1')->getFormattedValue());
self::assertSame(44926, $worksheet1900->getCell('A2')->getValue());
self::assertSame('2022-12-31', $worksheet1900->getCell('A2')->getFormattedValue());
self::assertSame(44561, $worksheet1900->getCell('B1')->getCalculatedValue());
self::assertSame('2021-12-31', $worksheet1900->getCell('B1')->getFormattedValue());
self::assertSame(44927, $worksheet1900->getCell('B2')->getCalculatedValue());
self::assertSame('2023-01-01', $worksheet1900->getCell('B2')->getFormattedValue());
self::assertSame(43100, $worksheet1904->getCell('A1')->getValue());
self::assertSame('2022-01-01', $worksheet1904->getCell('A1')->getFormattedValue());
self::assertSame(43464, $worksheet1904->getCell('A2')->getValue());
self::assertSame('2022-12-31', $worksheet1904->getCell('A2')->getFormattedValue());
self::assertSame(43099, $worksheet1904->getCell('B1')->getCalculatedValue());
self::assertSame('2021-12-31', $worksheet1904->getCell('B1')->getFormattedValue());
self::assertSame(43465, $worksheet1904->getCell('B2')->getCalculatedValue());
self::assertSame('2023-01-01', $worksheet1904->getCell('B2')->getFormattedValue());
// Check that accessing date values from one spreadsheet doesn't break accessing correct values from another
self::assertSame(44561, $worksheet1900->getCell('B1')->getCalculatedValue());
self::assertSame('2021-12-31', $worksheet1900->getCell('B1')->getFormattedValue());
self::assertSame(44927, $worksheet1900->getCell('B2')->getCalculatedValue());
self::assertSame('2023-01-01', $worksheet1900->getCell('B2')->getFormattedValue());
self::assertSame(44562, $worksheet1900->getCell('A1')->getValue());
self::assertSame('2022-01-01', $worksheet1900->getCell('A1')->getFormattedValue());
self::assertSame(44926, $worksheet1900->getCell('A2')->getValue());
self::assertSame('2022-12-31', $worksheet1900->getCell('A2')->getFormattedValue());
self::assertSame(43099, $worksheet1904->getCell('B1')->getCalculatedValue());
self::assertSame('2021-12-31', $worksheet1904->getCell('B1')->getFormattedValue());
self::assertSame(43465, $worksheet1904->getCell('B2')->getCalculatedValue());
self::assertSame('2023-01-01', $worksheet1904->getCell('B2')->getFormattedValue());
self::assertSame(43100, $worksheet1904->getCell('A1')->getValue());
self::assertSame('2022-01-01', $worksheet1904->getCell('A1')->getFormattedValue());
self::assertSame(43464, $worksheet1904->getCell('A2')->getValue());
self::assertSame('2022-12-31', $worksheet1904->getCell('A2')->getFormattedValue());
$spreadsheet1900->disconnectWorksheets();
$spreadsheet1904->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/Issue3553Test.php | tests/PhpSpreadsheetTests/Reader/Xlsx/Issue3553Test.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx;
class Issue3553Test extends \PHPUnit\Framework\TestCase
{
private static string $testbook = 'tests/data/Reader/XLSX/issue.3553.xlsx';
public function testPreliminaries(): void
{
$file = 'zip://';
$file .= self::$testbook;
$file .= '#_rels/.rels';
$data = file_get_contents($file);
// confirm that file contains expected namespaced xml tag
if ($data === false) {
self::fail('Unable to read file');
} else {
self::assertStringContainsString('<Relationship Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument" Target="/xl/workbook.xml" Id="rId2" />', $data, 'Unexpected leading slash in Target attribute');
}
}
public function testIssue3553(): void
{
$reader = new Xlsx();
$spreadsheet = $reader->load(self::$testbook);
$sheet = $spreadsheet->getActiveSheet();
self::assertSame('https://microsoft.com/', $sheet->getCell('B2')->getHyperlink()->getUrl());
$spreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/AutoFilter2Test.php | tests/PhpSpreadsheetTests/Reader/Xlsx/AutoFilter2Test.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\IOFactory;
use PhpOffice\PhpSpreadsheet\Worksheet\AutoFilter\Column\Rule;
use PhpOffice\PhpSpreadsheet\Worksheet\Worksheet;
use PHPUnit\Framework\TestCase;
class AutoFilter2Test extends TestCase
{
private const TESTBOOK = 'tests/data/Reader/XLSX/autofilter2.xlsx';
/** @return int[] */
public function getVisibleSheet(?Worksheet $sheet, int $maxRow): array
{
$actualVisible = [];
if ($sheet !== null) {
for ($row = 2; $row <= $maxRow; ++$row) {
if ($sheet->getRowDimension($row)->getVisible()) {
$actualVisible[] = $row;
}
}
}
return $actualVisible;
}
public function testReadDateRange(): void
{
$spreadsheet = IOFactory::load(self::TESTBOOK);
$sheet = $spreadsheet->getSheetByNameOrThrow('daterange');
$filter = $sheet->getAutoFilter();
$maxRow = 30;
self::assertSame("A1:A$maxRow", $filter->getRange());
$columns = $filter->getColumns();
self::assertCount(1, $columns);
$column = $columns['A'] ?? null;
self::assertNotNull($column);
$ruleset = $column->getRules();
self::assertCount(1, $ruleset);
$rule = $ruleset[0];
self::assertSame(Rule::AUTOFILTER_RULETYPE_DATEGROUP, $rule->getRuleType());
$value = $rule->getValue();
self::assertIsArray($value);
self::assertCount(6, $value);
self::assertSame('2002', $value['year']);
self::assertSame('', $value['month']);
self::assertSame('', $value['day']);
self::assertSame('', $value['hour']);
self::assertSame('', $value['minute']);
self::assertSame('', $value['second']);
self::assertSame(
[25, 26, 27, 28, 29, 30],
$this->getVisibleSheet($sheet, $maxRow)
);
$spreadsheet->disconnectWorksheets();
}
public function testReadTopTen(): void
{
$spreadsheet = IOFactory::load(self::TESTBOOK);
$sheet = $spreadsheet->getSheetByNameOrThrow('top10');
$filter = $sheet->getAutoFilter();
$maxRow = 65;
self::assertSame("A1:A$maxRow", $filter->getRange());
$columns = $filter->getColumns();
self::assertCount(1, $columns);
$column = $columns['A'] ?? null;
self::assertNotNull($column);
$ruleset = $column->getRules();
self::assertCount(1, $ruleset);
$rule = $ruleset[0];
self::assertSame(Rule::AUTOFILTER_RULETYPE_TOPTENFILTER, $rule->getRuleType());
$value = $rule->getValue();
self::assertSame('10', $value);
self::assertSame(
[56, 57, 58, 59, 60, 61, 62, 63, 64, 65],
$this->getVisibleSheet($sheet, $maxRow)
);
$spreadsheet->disconnectWorksheets();
}
public function testReadDynamic(): void
{
$spreadsheet = IOFactory::load(self::TESTBOOK);
$sheet = $spreadsheet->getSheetByNameOrThrow('dynamic');
$filter = $sheet->getAutoFilter();
$maxRow = 30;
self::assertSame("A1:A$maxRow", $filter->getRange());
$columns = $filter->getColumns();
self::assertCount(1, $columns);
$column = $columns['A'] ?? null;
self::assertNotNull($column);
$ruleset = $column->getRules();
self::assertCount(1, $ruleset);
$rule = $ruleset[0];
self::assertSame(Rule::AUTOFILTER_RULETYPE_DYNAMICFILTER, $rule->getRuleType());
self::assertSame('M4', $rule->getGrouping());
self::assertSame(
[5, 17, 28],
$this->getVisibleSheet($sheet, $maxRow)
);
$spreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/DataValidationTest.php | tests/PhpSpreadsheetTests/Reader/Xlsx/DataValidationTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\Cell\DataValidation;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx;
use PHPUnit\Framework\TestCase;
class DataValidationTest extends TestCase
{
public function testLoadXlsxDataValidation(): void
{
$filename = 'tests/data/Reader/XLSX/dataValidationTest.xlsx';
$reader = new Xlsx();
$spreadsheet = $reader->load($filename);
$worksheet = $spreadsheet->getActiveSheet();
self::assertTrue($worksheet->getCell('B3')->hasDataValidation());
$spreadsheet->disconnectWorksheets();
}
/**
* Test for load drop down lists of another sheet.
* Pull #2150, issue #2149. Also issue #2677.
*/
#[\PHPUnit\Framework\Attributes\DataProvider('providerExternalSheet')]
public function testDataValidationOfAnotherSheet(string $expectedB14, string $filename): void
{
$reader = new Xlsx();
$spreadsheet = $reader->load($filename);
$worksheet = $spreadsheet->getActiveSheet();
// same sheet
$validationCell = $worksheet->getCell('B5');
self::assertTrue($validationCell->hasDataValidation());
self::assertSame(DataValidation::TYPE_LIST, $validationCell->getDataValidation()->getType());
self::assertSame('$A$5:$A$7', $validationCell->getDataValidation()->getFormula1());
// another sheet
$validationCell = $worksheet->getCell('B14');
self::assertTrue($validationCell->hasDataValidation());
self::assertSame(DataValidation::TYPE_LIST, $validationCell->getDataValidation()->getType());
self::assertSame($expectedB14, $validationCell->getDataValidation()->getFormula1());
$spreadsheet->disconnectWorksheets();
}
public static function providerExternalSheet(): array
{
return [
'standard spreadsheet' => ['Feuil2!$A$3:$A$5', 'tests/data/Reader/XLSX/dataValidation2Test.xlsx'],
'alternate namespace prefix' => ['Feuil2!$A$3:$A$5', 'tests/data/Reader/XLSX/issue.2677.namespace.xlsx'],
'missing formula' => ['', 'tests/data/Reader/XLSX/issue.2677.removeformula1.xlsx'],
];
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/LoadSheetsOnlyTest.php | tests/PhpSpreadsheetTests/Reader/Xlsx/LoadSheetsOnlyTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\Exception as PhpSpreadsheetException;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PHPUnit\Framework\TestCase;
class LoadSheetsOnlyTest extends TestCase
{
private ?Spreadsheet $spreadsheet = null;
private static string $testbook = 'tests/data/Reader/XLSX/HiddenSheet.xlsx';
protected function tearDown(): void
{
if ($this->spreadsheet !== null) {
$this->spreadsheet->disconnectWorksheets();
$this->spreadsheet = null;
}
}
public function testLoadSheet1Only(): void
{
$filename = self::$testbook;
$reader = new Xlsx();
//$reader->setLoadSheetsOnly(['Sheet1']);
$names = $reader->listWorksheetNames($filename);
$reader->setLoadSheetsOnly([$names[0]]);
$spreadsheet = $this->spreadsheet = $reader->load($filename);
self::assertSame(1, $spreadsheet->getSheetCount());
self::assertSame('Sheet1', $spreadsheet->getActiveSheet()->getTitle());
}
public function testLoadSheet2Only(): void
{
$filename = self::$testbook;
$reader = new Xlsx();
$reader->setLoadSheetsOnly(['Sheet2']);
$spreadsheet = $this->spreadsheet = $reader->load($filename);
self::assertSame(1, $spreadsheet->getSheetCount());
self::assertSame('Sheet2', $spreadsheet->getActiveSheet()->getTitle());
}
public function testLoadNoSheet(): void
{
$this->expectException(PhpSpreadsheetException::class);
$this->expectExceptionMessage('You tried to set a sheet active by the out of bounds index');
$filename = self::$testbook;
$reader = new Xlsx();
$reader->setLoadSheetsOnly(['Sheet3']);
$reader->load($filename);
}
public function testLoadMultipleSheets(): void
{
$filename = 'tests/data/Reader/XLSX/threesheets.xlsx';
$reader = new Xlsx();
$reader->setLoadSheetsOnly(['Sheet3', 'Sheet1']);
$spreadsheet = $this->spreadsheet = $reader->load($filename);
self::assertSame(2, $spreadsheet->getSheetCount());
$sheet = $spreadsheet->getSheetByNameOrThrow('Sheet1');
self::assertSame('First', $sheet->getCell('A1')->getValue());
$sheet = $spreadsheet->getSheetByNameOrThrow('Sheet3');
self::assertSame('Third', $sheet->getCell('A1')->getValue());
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/Issue2490Test.php | tests/PhpSpreadsheetTests/Reader/Xlsx/Issue2490Test.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\IOFactory;
use PHPUnit\Framework\TestCase;
class Issue2490Test extends TestCase
{
private static string $testbook = 'tests/data/Reader/XLSX/issue.2490.xlsx';
private static string $testbook3093 = 'tests/data/Reader/XLSX/issue.3093.xlsx';
public function testPreliminaries(): void
{
$file = 'zip://';
$file .= self::$testbook;
$file .= '#xl/styles.xml';
$data = file_get_contents($file);
// confirm that file contains expected color index tag
if ($data === false) {
self::fail('Unable to read file');
} else {
self::assertStringContainsString('<colors><indexedColors><rgbColor rgb="00000000"/>', $data);
self::assertSame(64, substr_count($data, '<rgbColor'));
}
}
public function testIssue2490(): void
{
// Spreadsheet with its own color palette.
$filename = self::$testbook;
$reader = IOFactory::createReader('Xlsx');
$spreadsheet = $reader->load($filename);
$sheet = $spreadsheet->getActiveSheet();
self::assertSame('00FFFFFF', $sheet->getCell('A3')->getStyle()->getFill()->getStartColor()->getArgb());
self::assertSame('00F0FBFF', $sheet->getCell('A1')->getStyle()->getFill()->getStartColor()->getArgb());
self::assertSame('00F0F0F0', $sheet->getCell('B1')->getStyle()->getFill()->getStartColor()->getArgb());
$spreadsheet->disconnectWorksheets();
}
public function testPreliminaries3093(): void
{
$file = 'zip://';
$file .= self::$testbook3093;
$file .= '#xl/styles.xml';
$data = file_get_contents($file);
// confirm that file contains expected color index tag
if ($data === false) {
self::fail('Unable to read file');
} else {
self::assertStringContainsString('<colors><indexedColors><rgbColor rgb="ff000000"/>', $data);
self::assertSame(15, substr_count($data, '<rgbColor'));
}
}
public function testIssue3093(): void
{
// Same as above, except with fewer than 64 entries.
// (And with colors in lowercase hex and alpha set to ff.)
$filename = self::$testbook3093;
$reader = IOFactory::createReader('Xlsx');
$spreadsheet = $reader->load($filename);
$sheet = $spreadsheet->getActiveSheet();
self::assertSame('ffc0c0c0', $sheet->getCell('B2')->getStyle()->getFill()->getStartColor()->getArgb());
self::assertSame('ffffff00', $sheet->getCell('D2')->getStyle()->getFill()->getStartColor()->getArgb());
self::assertSame('ffdfa7a6', $sheet->getCell('F2')->getStyle()->getFill()->getStartColor()->getArgb());
self::assertSame('ff7ba0cd', $sheet->getCell('H2')->getStyle()->getFill()->getStartColor()->getArgb());
$spreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/HyperlinkTest.php | tests/PhpSpreadsheetTests/Reader/Xlsx/HyperlinkTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\NamedRange;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheetTests\Functional\AbstractFunctional;
class HyperlinkTest extends AbstractFunctional
{
public function testReadAndWriteHyperlinks(): void
{
$spreadsheet = new Spreadsheet();
$sheet1 = $spreadsheet->getActiveSheet();
$sheet1->setTitle('Sheet One');
$sheet1->getCell('A1')->setValue(100);
$sheet1->getCell('B1')->setValue('this is b1');
$spreadsheet->addNamedRange(new NamedRange('namedb1', $sheet1, '$B$1'));
$sheet1->setCellValue('A2', 'link to same sheet');
$sheet1->getCell('A2')->getHyperlink()
->setUrl("sheet://'Sheet One'!A1");
$sheet1->getStyle('A2')->getFont()->setHyperlinkTheme();
$sheet1->setCellValue('A3', 'link to defined name');
$sheet1->getCell('A3')->getHyperlink()
->setUrl('sheet://namedb1');
$sheet1->getStyle('A3')->getFont()->setHyperlinkTheme();
$sheet2 = $spreadsheet->createSheet();
$sheet2->setTitle('Sheet Two');
$sheet2->setCellValue('A2', 'link to other sheet');
$sheet2->getCell('A2')->getHyperlink()
->setUrl("sheet://'Sheet One'!A1");
$sheet2->getStyle('A2')->getFont()->setHyperlinkTheme();
$sheet2->setCellValue('A3', 'external link');
$sheet2->getCell('A3')->getHyperlink()
->setUrl('https://www.example.com');
$sheet2->getStyle('A3')->getFont()->setHyperlinkTheme();
$sheet2->setCellValue('A4', 'external link with anchor');
$sheet2->getCell('A4')->getHyperlink()
->setUrl('https://www.example.com#anchor');
$sheet2->getCell('A4')->getHyperlink()->setTooltip('go to anchor tag on example.com');
$sheet2->getStyle('A4')->getFont()->setHyperlinkTheme();
$reloadedSpreadsheet = $this->writeAndReload($spreadsheet, 'Xlsx');
$spreadsheet->disconnectWorksheets();
$rsheet1 = $reloadedSpreadsheet->getSheet(0);
self::assertSame('link to same sheet', $rsheet1->getCell('A2')->getValue());
self::assertSame("sheet://'Sheet One'!A1", $rsheet1->getCell('A2')->getHyperlink()->getUrl());
self::assertSame('link to defined name', $rsheet1->getCell('A3')->getValue());
self::assertSame('sheet://namedb1', $rsheet1->getCell('A3')->getHyperlink()->getUrl());
$rsheet2 = $reloadedSpreadsheet->getSheet(1);
self::assertSame('link to other sheet', $rsheet2->getCell('A2')->getValue());
self::assertSame("sheet://'Sheet One'!A1", $rsheet2->getCell('A2')->getHyperlink()->getUrl());
self::assertSame(
'FF0000FF',
$rsheet2
->getStyle('A2')
->getFont()->getColor()->getARGB(),
'argb is set in addition to theme'
);
self::assertSame('external link', $rsheet2->getCell('A3')->getValue());
self::assertSame('https://www.example.com', $rsheet2->getCell('A3')->getHyperlink()->getUrl());
self::assertSame('https://www.example.com#anchor', $rsheet2->getCell('A4')->getHyperlink()->getUrl());
self::assertSame('external link with anchor', $rsheet2->getCell('A4')->getValue());
self::assertSame('go to anchor tag on example.com', $rsheet2->getCell('A4')->getHyperlink()->getToolTip());
$testCells = [
[0, 'A2'],
[0, 'A3'],
[0, 'A2'],
[1, 'A3'],
[1, 'A4'],
];
foreach ($testCells as $sheetAndCell) {
[$sheetIndex, $cell] = $sheetAndCell;
$rsheet = $reloadedSpreadsheet->getSheet($sheetIndex);
self::assertSame(
10,
$rsheet->getStyle($cell)
->getFont()->getColor()->getTheme(),
"theme sheet $sheetIndex cell $cell"
);
self::assertSame(
'single',
$rsheet->getStyle('A2')->getFont()->getUnderline(),
"underline sheet $sheetIndex cell $cell"
);
}
$reloadedSpreadsheet->disconnectWorksheets();
}
public function testDisplay(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->getCell('A1')->setValue('A1 text');
$hy1 = $sheet->getCell('A1')->getHyperlink();
$hy1->setUrl('http://www.example.com');
$hy1->setTooltip('Go to example.com');
$sheet->getCell('A2')->setValue('A2 text');
$hy2 = $sheet->getCell('A2')->getHyperlink();
$hy2->setUrl('http://www.example.org');
$hy2->setTooltip('Go to example.org');
$hy2->setDisplay('A2 display');
$reloadedSpreadsheet = $this->writeAndReload($spreadsheet, 'Xlsx');
$spreadsheet->disconnectWorksheets();
$rsheet = $reloadedSpreadsheet->getActiveSheet();
self::assertSame('A1 text', $rsheet->getCell('A1')->getValue());
$rhy1 = $rsheet->getCell('A1')->getHyperlink();
self::assertSame('http://www.example.com', $rhy1->getUrl());
self::assertSame('Go to example.com', $rhy1->getTooltip());
self::assertSame('Go to example.com', $rhy1->getDisplay(), 'display is set to tooltip if unset');
self::assertSame('A2 text', $rsheet->getCell('A2')->getValue());
$rhy2 = $rsheet->getCell('A2')->getHyperlink();
self::assertSame('http://www.example.org', $rhy2->getUrl());
self::assertSame('Go to example.org', $rhy2->getTooltip());
self::assertSame('A2 display', $rhy2->getDisplay(), 'display is explicitly set');
$reloadedSpreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/Issue4505Test.php | tests/PhpSpreadsheetTests/Reader/Xlsx/Issue4505Test.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx as XlsxReader;
use PHPUnit\Framework\TestCase;
class Issue4505Test extends TestCase
{
private static string $file = 'tests/data/Reader/XLSX/issue.4505.namespace.xlsx';
public function testVmlProcessingWithXAndONamespaces(): void
{
$reader = new XlsxReader();
$spreadsheet = $reader->load(self::$file);
$sheet = $spreadsheet->getActiveSheet();
$comments = $sheet->getComments();
self::assertArrayHasKey('A1', $comments);
self::assertSame('right', $comments['A1']->getAlignment());
self::assertSame("Some User:\nHello", (string) $comments['A1']->getText());
$spreadsheet->disconnectWorksheets();
}
public function testVmlFileContainsRequiredNamespaces(): void
{
$file = 'zip://' . self::$file . '#xl/drawings/vmlDrawing1.vml';
$data = (string) file_get_contents($file);
self::assertStringContainsString('<ns1:shape ', $data); // usually v:shape
self::assertStringContainsString('<ns3:shapelayout ns1:ext="edit">', $data); // usually o:shapelayout v:ext
self::assertStringContainsString('<ns2:ClientData ObjectType="Note">', $data); // usually x:ClientData
self::assertStringContainsString('ns3:insetmode', $data); // usually o:insetmode
self::assertStringContainsString(
'<ns2:TextHAlign>Right</ns2:TextHAlign>', // usually x:TextHAlign
$data
);
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/GroupByLimitedTest.php | tests/PhpSpreadsheetTests/Reader/Xlsx/GroupByLimitedTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx;
use PhpOffice\PhpSpreadsheetTests\Functional\AbstractFunctional;
class GroupByLimitedTest extends AbstractFunctional
{
private static string $testbook = 'tests/data/Reader/XLSX/excel-groupby-one.xlsx';
public function testRowBreaks(): void
{
$reader = new Xlsx();
$spreadsheet = $reader->load(self::$testbook);
$reloadedSpreadsheet = $this->writeAndReload($spreadsheet, 'Xlsx');
$spreadsheet->disconnectWorksheets();
$reloadedSheet = $reloadedSpreadsheet->getActiveSheet();
self::assertSame(['t' => 'array', 'ref' => 'E3:F7'], $reloadedSheet->getCell('E3')->getFormulaAttributes());
$expected = [
['Design', '$505,000 '],
['Development', '$346,000 '],
['Marketing', '$491,000 '],
['Research', '$573,000 '],
['Total', '$1,915,000 '],
[null, null],
];
self::assertSame($expected, $reloadedSheet->rangeToArray('E3:F8'));
$reloadedSpreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/Issue3679ImgTest.php | tests/PhpSpreadsheetTests/Reader/Xlsx/Issue3679ImgTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx;
use PhpOffice\PhpSpreadsheetTests\Functional\AbstractFunctional;
use SimpleXMLElement;
class Issue3679ImgTest extends AbstractFunctional
{
public function testCroppedPicture(): void
{
$file = 'tests/data/Reader/XLSX/issue.3679.img.xlsx';
$reader = new Xlsx();
$spreadsheet = $reader->load($file);
$reloadedSpreadsheet = $this->writeAndReload($spreadsheet, 'Xlsx');
$spreadsheet->disconnectWorksheets();
$sheet = $reloadedSpreadsheet->getActiveSheet();
$drawings = $sheet->getDrawingCollection();
self::assertCount(1, $drawings);
if ($drawings[0] === null) {
self::fail('Unexpected null drawing');
} else {
/** @var SimpleXMLElement */
$srcRect = $drawings[0]->getSrcRect();
self::assertSame('448', (string) ($srcRect['r'] ?? ''));
self::assertSame('65769', (string) ($srcRect['b'] ?? ''));
}
$reloadedSpreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/GridlinesTest.php | tests/PhpSpreadsheetTests/Reader/Xlsx/GridlinesTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheetTests\Functional\AbstractFunctional;
class GridlinesTest extends AbstractFunctional
{
#[\PHPUnit\Framework\Attributes\DataProvider('loadDataProvider')]
public function testGridlines(bool $display, bool $print): void
{
$spreadsheet = new Spreadsheet();
$sheet1 = $spreadsheet->getActiveSheet();
$sheet2 = $spreadsheet->createSheet();
$sheet2->setTitle('deliberatelyblank');
$sheet1->setShowGridlines($display);
$sheet1->setPrintGridlines($print);
$sheet1->fromArray(
[
[1, 2, 3],
[4, 5, 6],
[7, 8, 9],
]
);
$reloadedSpreadsheet = $this->writeAndReload($spreadsheet, 'Xlsx');
$spreadsheet->disconnectWorksheets();
$rsheet1 = $reloadedSpreadsheet->getSheet(0);
$rsheet2 = $reloadedSpreadsheet->getSheet(1);
self::assertSame($display, $rsheet1->getShowGridlines());
self::assertSame($print, $rsheet1->getPrintGridlines());
self::assertTrue($rsheet2->getShowGridlines());
self::assertFalse($rsheet2->getPrintGridlines());
$reloadedSpreadsheet->disconnectWorksheets();
}
public static function loadDataProvider(): array
{
return [
[true, true],
[true, false],
[false, true],
[false, false],
];
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/XlsxRootZipFilesTest.php | tests/PhpSpreadsheetTests/Reader/Xlsx/XlsxRootZipFilesTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\RichText\RichText;
use PHPUnit\Framework\TestCase;
class XlsxRootZipFilesTest extends TestCase
{
private static string $testbook = 'tests/data/Reader/XLSX/rootZipFiles.xlsx';
public function testXlsxRootZipFiles(): void
{
$filename = self::$testbook;
$reader = new Xlsx();
$spreadsheet = $reader->load($filename);
$sheet = $spreadsheet->getActiveSheet();
/** @var RichText */
$value = $sheet->getCell('A1')->getValue();
self::assertSame('TEST CELL', $value->getPlainText());
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/RowBreakTest.php | tests/PhpSpreadsheetTests/Reader/Xlsx/RowBreakTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx as XlsxReader;
use PhpOffice\PhpSpreadsheet\Shared\StringHelper;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Worksheet\Worksheet;
use PhpOffice\PhpSpreadsheet\Writer\Xlsx as XlsxWriter;
use PHPUnit\Framework\TestCase;
class RowBreakTest extends TestCase
{
public function testReadAndWriteRowBreak(): void
{
$file = 'tests/data/Reader/XLSX/issue.3143a.xlsx';
$reader = new XlsxReader();
$spreadsheet = $reader->load($file);
$sheet = $spreadsheet->getActiveSheet();
$writer = new XlsxWriter($spreadsheet);
$writerWorksheet = new XlsxWriter\Worksheet($writer);
$data = $writerWorksheet->writeWorksheet($sheet, []);
$expected = '<rowBreaks count="1" manualBreakCount="1"><brk id="25" man="1" max="11"/></rowBreaks>';
self::assertStringContainsString($expected, $data);
$spreadsheet->disconnectWorksheets();
}
public function testWriteRowBreakInPrintAreaWithMax(): void
{
// This test specifies max for setBreak and appears correct.
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
for ($row = 1; $row < 60; ++$row) {
for ($column = 'A'; $column !== 'L'; StringHelper::stringIncrement($column)) {
$cell = $column . $row;
$sheet->getCell($cell)->setValue($cell);
}
}
$sheet->getPageSetup()->setPrintArea('B2:J55');
$sheet->setBreak('A25', Worksheet::BREAK_ROW, Worksheet::BREAK_ROW_MAX_COLUMN);
$writer = new XlsxWriter($spreadsheet);
$writerWorksheet = new XlsxWriter\Worksheet($writer);
$data = $writerWorksheet->writeWorksheet($sheet, []);
$expected = '<rowBreaks count="1" manualBreakCount="1"><brk id="25" man="1" max="16383"/></rowBreaks>';
self::assertStringContainsString($expected, $data);
$spreadsheet->disconnectWorksheets();
}
public function testWriteRowBreakInPrintAreaWithoutMax(): void
{
// This test does not specify max for setBreak,
// and appears incorrect. Probable Excel bug.
// See issue #1275, which now has a fix.
// And I agree that the fix probably indicates an Excel bug.
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
for ($row = 1; $row < 60; ++$row) {
for ($column = 'A'; $column !== 'L'; StringHelper::stringIncrement($column)) {
$cell = $column . $row;
$sheet->getCell($cell)->setValue($cell);
}
}
$sheet->getPageSetup()->setPrintArea('B2:J55');
$sheet->setBreak('A25', Worksheet::BREAK_ROW);
$writer = new XlsxWriter($spreadsheet);
$writerWorksheet = new XlsxWriter\Worksheet($writer);
$data = $writerWorksheet->writeWorksheet($sheet, []);
$expected = '<rowBreaks count="1" manualBreakCount="1"><brk id="25" man="1" max="11"/></rowBreaks>';
self::assertStringContainsString($expected, $data);
$spreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/TableTest.php | tests/PhpSpreadsheetTests/Reader/Xlsx/TableTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\Worksheet\Table;
use PhpOffice\PhpSpreadsheet\Worksheet\Table\TableStyle;
use PHPUnit\Framework\TestCase;
class TableTest extends TestCase
{
public function testLoadTable(): void
{
$filename = 'tests/data/Reader/XLSX/tableTest.xlsx';
$reader = new Xlsx();
$spreadsheet = $reader->load($filename);
$worksheet = $spreadsheet->getActiveSheet();
$tables = $worksheet->getTableCollection();
self::assertCount(1, $tables);
$table = $tables->offsetGet(0);
self::assertInstanceOf(Table::class, $table);
self::assertEquals('SalesData', $table->getName());
self::assertEquals('A1:G16', $table->getRange());
self::assertTrue($table->getShowHeaderRow(), 'ShowHeaderRow');
self::assertTrue($table->getShowTotalsRow(), 'ShowTotalsRow');
self::assertTrue($table->getAllowFilter(), 'Allow Filter');
self::assertEquals('Total', $table->getColumn('B')->getTotalsRowLabel());
self::assertEquals('sum', $table->getColumn('G')->getTotalsRowFunction());
self::assertEquals('SUM(SalesData[[#This Row],[Q1]:[Q4]])', $table->getColumn('G')->getColumnFormula());
$tableStyle = $table->getStyle();
self::assertEquals(TableStyle::TABLE_STYLE_MEDIUM4, $tableStyle->getTheme());
self::assertTrue($tableStyle->getShowRowStripes(), 'ShowRowStripes');
self::assertFalse($tableStyle->getShowColumnStripes(), 'ShowColumnStripes');
self::assertFalse($tableStyle->getShowFirstColumn(), 'ShowFirstColumn');
self::assertTrue($tableStyle->getShowLastColumn(), 'ShowLastColumn');
}
public function testLoadTableNoFilter(): void
{
$filename = 'tests/data/Reader/XLSX/TableWithoutFilter.xlsx';
$reader = new Xlsx();
$spreadsheet = $reader->load($filename);
$worksheet = $spreadsheet->getActiveSheet();
$tables = $worksheet->getTableCollection();
self::assertCount(1, $tables);
$table = $tables->offsetGet(0);
self::assertInstanceOf(Table::class, $table);
self::assertFalse($table->getAllowFilter(), 'Allow Filter');
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/URLImageTest.php | tests/PhpSpreadsheetTests/Reader/Xlsx/URLImageTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\Exception as SpreadsheetException;
use PhpOffice\PhpSpreadsheet\IOFactory;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx as XlsxReader;
use PhpOffice\PhpSpreadsheet\Worksheet\Drawing;
use PhpOffice\PhpSpreadsheetTests\Reader\Utility\File;
use PHPUnit\Framework\TestCase;
class URLImageTest extends TestCase
{
public function testDefault(): void
{
$reader = new XlsxReader();
self::assertFalse($reader->getAllowExternalImages());
}
public function testURLImageSourceAllowed(): void
{
if (getenv('SKIP_URL_IMAGE_TEST') === '1') {
self::markTestSkipped('Skipped due to setting of environment variable');
}
$filename = realpath(__DIR__ . '/../../../data/Reader/XLSX/urlImage.xlsx');
self::assertNotFalse($filename);
$reader = IOFactory::createReader('Xlsx');
$reader->setAllowExternalImages(true);
$spreadsheet = $reader->load($filename);
$worksheet = $spreadsheet->getActiveSheet();
$collection = $worksheet->getDrawingCollection();
self::assertCount(1, $collection);
foreach ($collection as $drawing) {
self::assertInstanceOf(Drawing::class, $drawing);
// Check if the source is a URL or a file path
self::assertTrue($drawing->getIsURL());
self::assertSame('https://phpspreadsheet.readthedocs.io/en/latest/topics/images/01-03-filter-icon-1.png', $drawing->getPath());
self::assertSame(IMAGETYPE_PNG, $drawing->getType());
self::assertSame(84, $drawing->getWidth());
self::assertSame(44, $drawing->getHeight());
}
$spreadsheet->disconnectWorksheets();
}
public function testURLImageSourceAllowedFlag(): void
{
if (getenv('SKIP_URL_IMAGE_TEST') === '1') {
self::markTestSkipped('Skipped due to setting of environment variable');
}
$filename = realpath(__DIR__ . '/../../../data/Reader/XLSX/urlImage.xlsx');
self::assertNotFalse($filename);
$reader = IOFactory::createReader('Xlsx');
$spreadsheet = $reader->load($filename, XlsxReader::ALLOW_EXTERNAL_IMAGES);
$worksheet = $spreadsheet->getActiveSheet();
$collection = $worksheet->getDrawingCollection();
self::assertCount(1, $collection);
foreach ($collection as $drawing) {
self::assertInstanceOf(Drawing::class, $drawing);
// Check if the source is a URL or a file path
self::assertTrue($drawing->getIsURL());
self::assertSame('https://phpspreadsheet.readthedocs.io/en/latest/topics/images/01-03-filter-icon-1.png', $drawing->getPath());
self::assertSame(IMAGETYPE_PNG, $drawing->getType());
self::assertSame(84, $drawing->getWidth());
self::assertSame(44, $drawing->getHeight());
}
$spreadsheet->disconnectWorksheets();
}
public function testURLImageSourceNotAllowed(): void
{
$filename = realpath(__DIR__ . '/../../../data/Reader/XLSX/urlImage.xlsx');
self::assertNotFalse($filename);
$reader = IOFactory::createReader('Xlsx');
$reader->setAllowExternalImages(false);
self::assertFalse($reader->getAllowExternalImages());
$spreadsheet = $reader->load($filename);
$worksheet = $spreadsheet->getActiveSheet();
$collection = $worksheet->getDrawingCollection();
self::assertCount(0, $collection);
$spreadsheet->disconnectWorksheets();
}
public function testURLImageSourceNotFoundAllowed(): void
{
if (getenv('SKIP_URL_IMAGE_TEST') === '1') {
self::markTestSkipped('Skipped due to setting of environment variable');
}
$filename = realpath(__DIR__ . '/../../../data/Reader/XLSX/urlImage.notfound.xlsx');
self::assertNotFalse($filename);
$reader = IOFactory::createReader('Xlsx');
$reader->setAllowExternalImages(true);
$spreadsheet = $reader->load($filename);
$worksheet = $spreadsheet->getActiveSheet();
$collection = $worksheet->getDrawingCollection();
self::assertCount(0, $collection);
$spreadsheet->disconnectWorksheets();
}
public function testURLImageSourceNotFoundNotAllowed(): void
{
$filename = realpath(__DIR__ . '/../../../data/Reader/XLSX/urlImage.notfound.xlsx');
self::assertNotFalse($filename);
$reader = IOFactory::createReader('Xlsx');
$reader->setAllowExternalImages(false);
$spreadsheet = $reader->load($filename);
$worksheet = $spreadsheet->getActiveSheet();
$collection = $worksheet->getDrawingCollection();
self::assertCount(0, $collection);
$spreadsheet->disconnectWorksheets();
}
public function testURLImageSourceNotFoundNotAllowedFlag(): void
{
$filename = realpath(__DIR__ . '/../../../data/Reader/XLSX/urlImage.notfound.xlsx');
self::assertNotFalse($filename);
$reader = IOFactory::createReader('Xlsx');
$spreadsheet = $reader->load($filename, XlsxReader::DONT_ALLOW_EXTERNAL_IMAGES);
$worksheet = $spreadsheet->getActiveSheet();
$collection = $worksheet->getDrawingCollection();
self::assertCount(0, $collection);
$spreadsheet->disconnectWorksheets();
}
public function testURLImageSourceBadProtocol(): void
{
$filename = realpath(__DIR__ . '/../../../data/Reader/XLSX/urlImage.bad.dontuse');
self::assertNotFalse($filename);
$this->expectException(SpreadsheetException::class);
$this->expectExceptionMessage('Invalid protocol for linked drawing');
$reader = IOFactory::createReader('Xlsx');
$reader->load($filename);
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/SplitsTest.php | tests/PhpSpreadsheetTests/Reader/Xlsx/SplitsTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx;
use PhpOffice\PhpSpreadsheetTests\Functional\AbstractFunctional;
class SplitsTest extends AbstractFunctional
{
private static string $testbook = 'tests/data/Reader/XLSX/splits.xlsx';
public function testSplits(): void
{
$reader = new Xlsx();
$spreadsheet = $reader->load(self::$testbook);
$reloadedSpreadsheet = $this->writeAndReload($spreadsheet, 'Xlsx');
$spreadsheet->disconnectWorksheets();
$sheet = $reloadedSpreadsheet->getSheetByNameOrThrow('Freeze');
self::assertSame('E7', $sheet->getFreezePane());
self::assertSame('frozen', $sheet->getPaneState());
self::assertSame('L7', $sheet->getPaneTopLeftCell());
self::assertSame('L7', $sheet->getTopLeftCell());
self::assertSame('L7', $sheet->getSelectedCells());
$sheet = $reloadedSpreadsheet->getSheetByNameOrThrow('SplitVertical');
self::assertNull($sheet->getFreezePane());
self::assertSame('G1', $sheet->getTopLeftCell());
self::assertSame('E1', $sheet->getPaneTopLeftCell());
self::assertSame('E1', $sheet->getSelectedCells());
self::assertNotEquals(0, $sheet->getXSplit());
self::assertEquals(0, $sheet->getYSplit());
self::assertNotNull($sheet->getPane('topRight'));
$sheet = $reloadedSpreadsheet->getSheetByNameOrThrow('SplitHorizontal');
self::assertNull($sheet->getFreezePane());
self::assertSame('A3', $sheet->getTopLeftCell());
self::assertSame('A6', $sheet->getPaneTopLeftCell());
self::assertSame('A7', $sheet->getSelectedCells());
self::assertEquals(0, $sheet->getXSplit());
self::assertNotEquals(0, $sheet->getYSplit());
self::assertNotNull($sheet->getPane('bottomLeft'));
$sheet = $reloadedSpreadsheet->getSheetByNameOrThrow('SplitBoth');
self::assertNull($sheet->getFreezePane());
self::assertSame('H3', $sheet->getTopLeftCell());
self::assertSame('E19', $sheet->getPaneTopLeftCell());
self::assertSame('E20', $sheet->getSelectedCells());
self::assertNotEquals(0, $sheet->getXSplit());
self::assertNotEquals(0, $sheet->getYSplit());
self::assertNotNull($sheet->getPane('bottomLeft'));
self::assertNotNull($sheet->getPane('bottomRight'));
self::assertNotNull($sheet->getPane('topRight'));
$sheet = $reloadedSpreadsheet->getSheetByNameOrThrow('NoFreezeNorSplit');
self::assertNull($sheet->getFreezePane());
self::assertSame('D3', $sheet->getTopLeftCell());
self::assertSame('', $sheet->getPaneTopLeftCell());
self::assertSame('D5', $sheet->getSelectedCells());
self::assertNull($sheet->getPane('bottomLeft'));
self::assertNull($sheet->getPane('bottomRight'));
self::assertNull($sheet->getPane('topRight'));
$sheet = $reloadedSpreadsheet->getSheetByNameOrThrow('FrozenSplit');
self::assertSame('B4', $sheet->getFreezePane());
self::assertSame('frozenSplit', $sheet->getPaneState());
self::assertSame('B4', $sheet->getPaneTopLeftCell());
self::assertSame('B4', $sheet->getTopLeftCell());
self::assertSame('B4', $sheet->getSelectedCells());
$reloadedSpreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/Issue4416Test.php | tests/PhpSpreadsheetTests/Reader/Xlsx/Issue4416Test.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx as XlsxReader;
use PHPUnit\Framework\TestCase;
class Issue4416Test extends TestCase
{
private static string $file = 'tests/data/Reader/XLSX/issue.4416.smallauto.xlsx';
public function testNoFilter(): void
{
$file = self::$file;
$reader = new XlsxReader();
$spreadsheet = $reader->load($file);
$sheet = $spreadsheet->getActiveSheet();
self::assertEqualsWithDelta(
16.5430,
$sheet->getColumnDimension('A')->getWidth(),
1E-4
);
self::assertEqualsWithDelta(
6.0,
$sheet->getColumnDimension('B')->getWidth(),
1E-4
);
self::assertEqualsWithDelta(
11.3633,
$sheet->getColumnDimension('C')->getWidth(),
1E-4
);
self::assertEqualsWithDelta(
41.0898,
$sheet->getColumnDimension('D')->getWidth(),
1E-4
);
self::assertEqualsWithDelta(
28.5,
$sheet->getRowDimension(6)->getRowHeight(),
1E-4
);
$spreadsheet->disconnectWorksheets();
}
public function testWithFilter(): void
{
$file = self::$file;
$reader = new XlsxReader();
$reader->setReadFilter(new Issue4416Filter());
$spreadsheet = $reader->load($file);
$sheet = $spreadsheet->getActiveSheet();
self::assertEqualsWithDelta(
16.5430,
$sheet->getColumnDimension('A')->getWidth(),
1E-4
);
self::assertEqualsWithDelta(
6.0,
$sheet->getColumnDimension('B')->getWidth(),
1E-4
);
self::assertEqualsWithDelta(
11.3633,
$sheet->getColumnDimension('C')->getWidth(),
1E-4
);
self::assertEqualsWithDelta(
41.0898,
$sheet->getColumnDimension('D')->getWidth(),
1E-4
);
self::assertEquals(
-1,
$sheet->getRowDimension(6)->getRowHeight(),
'row has been filtered away'
);
$spreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/Issue3767Test.php | tests/PhpSpreadsheetTests/Reader/Xlsx/Issue3767Test.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx as XlsxReader;
use PhpOffice\PhpSpreadsheet\Shared\File;
use PhpOffice\PhpSpreadsheet\Writer\Xlsx as XlsxWriter;
use PhpOffice\PhpSpreadsheetTests\Functional\AbstractFunctional;
class Issue3767Test extends AbstractFunctional
{
// some weirdness with this file, including the fact that it has a
// title ('Chart Title') which I cannot find anywhere in the xml.
private static string $testbook = 'tests/data/Reader/XLSX/issue.3767.xlsx';
private string $tempfile = '';
protected function tearDown(): void
{
if ($this->tempfile !== '') {
unlink($this->tempfile);
$this->tempfile = '';
}
}
public function readCharts(XlsxReader $reader): void
{
$reader->setIncludeCharts(true);
}
public function writeCharts(XlsxWriter $writer): void
{
$writer->setIncludeCharts(true);
}
public function testReadWithoutCharts(): void
{
$reader = new XlsxReader();
//$this->readCharts($reader); // Commented out - don't want to read charts.
$spreadsheet = $reader->load(self::$testbook);
$sheet = $spreadsheet->getActiveSheet();
$charts = $sheet->getChartCollection();
self::assertCount(0, $charts);
$this->tempfile = File::temporaryFileName();
$writer = new XlsxWriter($spreadsheet);
$this->writeCharts($writer);
$writer->save($this->tempfile);
$spreadsheet->disconnectWorksheets();
$file = 'zip://';
$file .= $this->tempfile;
$file .= '#xl/worksheets/_rels/sheet1.xml.rels';
$data = (string) file_get_contents($file);
// PhpSpreadsheet still generates this target even though charts aren't included
self::assertStringContainsString('Target="../drawings/drawing1.xml"', $data);
$file = 'zip://';
$file .= $this->tempfile;
$file .= '#xl/drawings/drawing1.xml';
$data = file_get_contents($file);
self::assertSame('<xml></xml>', $data); // fake file because rels needs it
}
public function testReadWithCharts(): void
{
$reader = new XlsxReader();
$this->readCharts($reader);
$spreadsheet = $reader->load(self::$testbook);
$xsheet = $spreadsheet->getActiveSheet();
$xcharts = $xsheet->getChartCollection();
self::assertCount(1, $xcharts);
/** @var callable */
$callableReader = [$this, 'readCharts'];
/** @var callable */
$callableWriter = [$this, 'writeCharts'];
$reloadedSpreadsheet = $this->writeAndReload($spreadsheet, 'Xlsx', $callableReader, $callableWriter);
$spreadsheet->disconnectWorksheets();
$sheet = $reloadedSpreadsheet->getActiveSheet();
$charts = $xsheet->getChartCollection();
self::assertCount(1, $charts);
// In Excel, a default title ('Chart Title') is shown.
// I can't find that anywhere in the Xml.
self::assertSame('', $charts[0]?->getTitle()?->getCaptionText());
// Just test anything on the chart.
self::assertSame($sheet->getCell('B2')->getValue(), $charts[0]->getPlotArea()?->getPlotGroup()[0]?->getPlotValues()[0]?->getDataValues()[0] ?? null);
$reloadedSpreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/Issue4063Test.php | tests/PhpSpreadsheetTests/Reader/Xlsx/Issue4063Test.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\IOFactory;
use PHPUnit\Framework\TestCase;
class Issue4063Test extends TestCase
{
private static string $testbook = 'tests/data/Reader/XLSX/issue.4063.xlsx';
public function testSharedStringsWithEmptyString(): void
{
$spreadsheet = IOFactory::load(self::$testbook);
$sheet = $spreadsheet->getActiveSheet();
$data = $sheet->toArray(null, true, true, true);
$nbsp = "\u{00a0}";
self::assertSame(['A' => '226', 'B' => '', 'C' => $nbsp], $data[17]);
self::assertSame(['A' => '38873', 'B' => 'gg', 'C' => ' '], $data[22]);
$spreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/Issue3770Test.php | tests/PhpSpreadsheetTests/Reader/Xlsx/Issue3770Test.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx;
class Issue3770Test extends \PHPUnit\Framework\TestCase
{
private static string $testbook = 'tests/data/Reader/XLSX/issue.3770.xlsx';
public function testPreliminaries(): void
{
$file = 'zip://';
$file .= self::$testbook;
$file .= '#xl/_rels/workbook.xml.rels';
$data = file_get_contents($file);
// rels file points to non-existent theme file
if ($data === false) {
self::fail('Unable to read file');
} else {
self::assertStringContainsString('Target="theme/theme1.xml"', $data);
self::assertStringContainsString('Target="worksheets/sheet1.xml"', $data);
}
$file = 'zip://';
$file .= self::$testbook;
$file .= '#xl/theme/theme1.xml';
$data = @file_get_contents($file);
self::assertFalse($data);
$file = 'zip://';
$file .= self::$testbook;
$file .= '#xl/worksheets/sheet1.xml';
$data = file_get_contents($file);
self::assertNotFalse($data);
}
public function testLoadable(): void
{
$reader = new Xlsx();
$spreadsheet = $reader->load(self::$testbook);
$sheet = $spreadsheet->getActiveSheet();
// Assert anything to confirm read succeeded
self::assertSame('Универсальный передаточный документ', $sheet->getCell('A1')->getValue());
$spreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/MySpreadsheet.php | tests/PhpSpreadsheetTests/Reader/Xlsx/MySpreadsheet.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
class MySpreadsheet extends Spreadsheet
{
public function calcSquare(string $cellAddress): float|int|string
{
$value = $this->getActiveSheet()
->getCell($cellAddress)
->getValue();
if (is_numeric($value)) {
return $value * $value;
}
return '#VALUE!';
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/UnderscoreTest.php | tests/PhpSpreadsheetTests/Reader/Xlsx/UnderscoreTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\Cell\DataType;
use PhpOffice\PhpSpreadsheet\Cell\DefaultValueBinder;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx as XlsxReader;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheetTests\Functional\AbstractFunctional;
use PHPUnit\Framework\Attributes\DataProvider;
class UnderscoreTest extends AbstractFunctional
{
private ?Spreadsheet $spreadsheet = null;
private ?Spreadsheet $reloadedSpreadsheet = null;
private const TEST_FILE = 'tests/data/Reader/XLSX/issue.4724.xlsx';
protected function tearDown(): void
{
if ($this->spreadsheet !== null) {
$this->spreadsheet->disconnectWorksheets();
$this->spreadsheet = null;
}
if ($this->reloadedSpreadsheet !== null) {
$this->reloadedSpreadsheet->disconnectWorksheets();
$this->reloadedSpreadsheet = null;
}
}
#[DataProvider('underscoreProvider')]
public function testUnderscore(string $value): void
{
$this->spreadsheet = new Spreadsheet();
$sheet = $this->spreadsheet->getActiveSheet();
$sheet->setCellValue('A1', $value);
$this->reloadedSpreadsheet = $this->writeAndReload($this->spreadsheet, 'Xlsx');
$rsheet = $this->reloadedSpreadsheet->getActiveSheet();
self::assertSame($value, $rsheet->getCell('A1')->getValue());
}
#[DataProvider('underscoreProvider')]
public function testUnderscoreInline(string $value): void
{
$this->spreadsheet = new Spreadsheet();
$sheet = $this->spreadsheet->getActiveSheet();
$sheet->setCellValueExplicit('A1', $value, DataType::TYPE_INLINE);
$this->reloadedSpreadsheet = $this->writeAndReload($this->spreadsheet, 'Xlsx');
$rsheet = $this->reloadedSpreadsheet->getActiveSheet();
self::assertSame($value, $rsheet->getCell('A1')->getValueString());
}
public static function underscoreProvider(): array
{
return [
['A_x0030_'],
['A_x0030_B'],
['A_B'],
];
}
public function testPreliminaries(): void
{
$file = 'zip://';
$file .= self::TEST_FILE;
$file .= '#xl/sharedStrings.xml';
$data = file_get_contents($file);
if ($data === false) {
self::fail('Unable to read file');
} else {
self::assertStringContainsString('count="8"', $data);
self::assertStringContainsString(
"<t>line_x000D_\nwith_x000D_\nbreaks</t>",
$data
);
self::assertStringContainsString('<t>A_x005F_x0030_B</t>', $data);
self::assertStringContainsString(
'<t>ABC_x0031__x0032__x0033_DEF</t>',
$data
);
self::assertStringContainsString('<t>_xC1EF_</t>', $data);
self::assertStringContainsString('<t>_xD801__xDC05_</t>', $data);
self::assertStringContainsString('<t>_xD801__x0038_</t>', $data);
self::assertStringContainsString('<t>_x0039__xDC05_</t>', $data);
self::assertStringContainsString('<t>_xDF39__xDC05_</t>', $data);
}
}
public function testX000dPreserved(): void
{
$reader = new XlsxReader();
$binder = new DefaultValueBinder();
$binder->setPreserveCr(true);
$reader->setValueBinder($binder);
$infile = self::TEST_FILE;
$this->spreadsheet = $reader->load($infile);
$sheet = $this->spreadsheet->getActiveSheet();
$expected = "line\r\nwith\r\nbreaks";
self::assertSame($expected, $sheet->getCell('A1')->getValue());
$expected = 'A_x0030_B';
self::assertSame($expected, $sheet->getCell('A2')->getValue());
$expected = 'ABC123DEF';
self::assertSame($expected, $sheet->getCell('A3')->getValue());
$expected = '쇯';
self::assertSame($expected, $sheet->getCell('A4')->getValue());
$expected = '𐐅';
self::assertSame($expected, $sheet->getCell('A5')->getValue(), 'outside BMP');
$expected = '�8';
self::assertSame($expected, $sheet->getCell('A6')->getValue(), 'high surrogate without low');
$expected = '9�';
self::assertSame($expected, $sheet->getCell('A7')->getValue(), 'low surrogate without high');
$expected = '�';
self::assertSame($expected, $sheet->getCell('A8')->getValue(), '2 low surrogates');
}
public function testX000dNotPreserved(): void
{
$reader = new XlsxReader();
$infile = self::TEST_FILE;
$this->spreadsheet = $reader->load($infile);
$sheet = $this->spreadsheet->getActiveSheet();
$expected = "line\nwith\nbreaks";
self::assertSame($expected, $sheet->getCell('A1')->getValue());
$expected = 'A_x0030_B';
self::assertSame($expected, $sheet->getCell('A2')->getValue());
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/Issue2387Test.php | tests/PhpSpreadsheetTests/Reader/Xlsx/Issue2387Test.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\IOFactory;
use PhpOffice\PhpSpreadsheet\Style\Fill;
use PHPUnit\Framework\TestCase;
class Issue2387Test extends TestCase
{
public function testIssue2387(): void
{
// Theme was not being handled.
$filename = 'tests/data/Reader/XLSX/issue.2387.xlsx';
$reader = IOFactory::createReader('Xlsx');
$spreadsheet = $reader->load($filename);
$sheet = $spreadsheet->getActiveSheet();
// Font color being tested uses theme color with tint.
// Excel shows final color as 305496.
$expectedColor = '305496';
$calculatedColor = $sheet->getCell('B2')->getStyle()->getFont()->getColor()->getRgb();
self::assertSame($expectedColor, RgbTintTest::compareColors($calculatedColor, $expectedColor));
self::assertSame(Fill::FILL_NONE, $sheet->getCell('B2')->getStyle()->getFill()->getFillType());
self::assertSame('FFFFFF', $sheet->getCell('C2')->getStyle()->getFont()->getColor()->getRgb());
self::assertSame('000000', $sheet->getCell('C2')->getStyle()->getFill()->getStartColor()->getRgb());
self::assertSame(Fill::FILL_SOLID, $sheet->getCell('C2')->getStyle()->getFill()->getFillType());
$spreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/EmptyFileTest.php | tests/PhpSpreadsheetTests/Reader/Xlsx/EmptyFileTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\Reader\Exception as ReaderException;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\Shared\File;
use PHPUnit\Framework\TestCase;
class EmptyFileTest extends TestCase
{
private string $tempfile = '';
protected function tearDown(): void
{
if ($this->tempfile !== '') {
unlink($this->tempfile);
$this->tempfile = '';
}
}
public function testEmptyFileLoad(): void
{
$this->expectException(ReaderException::class);
$this->expectExceptionMessage('Could not find zip member');
$this->tempfile = $temp = File::temporaryFileName();
file_put_contents($temp, '');
$reader = new Xlsx();
$reader->load($temp);
}
public function testEmptyFileNames(): void
{
$this->expectException(ReaderException::class);
$this->expectExceptionMessage('Could not find zip member');
$this->tempfile = $temp = File::temporaryFileName();
file_put_contents($temp, '');
$reader = new Xlsx();
$reader->listWorksheetNames($temp);
}
public function testEmptyInfo(): void
{
$this->expectException(ReaderException::class);
$this->expectExceptionMessage('Could not find zip member');
$this->tempfile = $temp = File::temporaryFileName();
file_put_contents($temp, '');
$reader = new Xlsx();
$reader->listWorksheetInfo($temp);
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/ConditionalFormattingDataBarXlsxTest.php | tests/PhpSpreadsheetTests/Reader/Xlsx/ConditionalFormattingDataBarXlsxTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\IOFactory;
use PhpOffice\PhpSpreadsheet\Shared\File;
use PhpOffice\PhpSpreadsheet\Style\Color;
use PhpOffice\PhpSpreadsheet\Style\Conditional;
use PhpOffice\PhpSpreadsheet\Style\ConditionalFormatting\ConditionalDataBar;
use PhpOffice\PhpSpreadsheet\Style\ConditionalFormatting\ConditionalFormatValueObject;
use PhpOffice\PhpSpreadsheet\Worksheet\Worksheet;
use PHPUnit\Framework\TestCase;
class ConditionalFormattingDataBarXlsxTest extends TestCase
{
public function testLoadXlsxConditionalFormattingDataBar(): void
{
// Make sure Conditionals are read correctly from existing file
$filename = 'tests/data/Reader/XLSX/conditionalFormattingDataBarTest.xlsx';
$reader = IOFactory::createReader('Xlsx');
$spreadsheet = $reader->load($filename);
$worksheet = $spreadsheet->getActiveSheet();
$this->pattern1Assertion($worksheet);
$this->pattern2Assertion($worksheet);
$this->pattern3Assertion($worksheet);
$this->pattern4Assertion($worksheet);
}
public function testReloadXlsxConditionalFormattingDataBar(): void
{
// Make sure conditionals from existing file are maintained across save
$filename = 'tests/data/Reader/XLSX/conditionalFormattingDataBarTest.xlsx';
$outfile = File::temporaryFilename();
$reader = IOFactory::createReader('Xlsx');
$spreadshee1 = $reader->load($filename);
$writer = IOFactory::createWriter($spreadshee1, 'Xlsx');
$writer->save($outfile);
$spreadsheet = $reader->load($outfile);
unlink($outfile);
$worksheet = $spreadsheet->getActiveSheet();
$this->pattern1Assertion($worksheet);
$this->pattern2Assertion($worksheet);
$this->pattern3Assertion($worksheet);
$this->pattern4Assertion($worksheet);
}
public function testNewXlsxConditionalFormattingDataBar(): void
{
// Make sure blanks/non-blanks added by PhpSpreadsheet are handled correctly
$outfile = File::temporaryFilename();
$spreadshee1 = new \PhpOffice\PhpSpreadsheet\Spreadsheet();
$sheet = $spreadshee1->getActiveSheet();
$sheet->setCellValue('A1', 1);
$sheet->setCellValue('A2', 2);
$sheet->setCellValue('A3', 3);
$sheet->setCellValue('A4', 4);
$sheet->setCellValue('A5', 5);
$cond1 = new Conditional();
$cond1->setConditionType(Conditional::CONDITION_DATABAR);
$cond1->setDataBar(new ConditionalDataBar());
$dataBar = $cond1->getDataBar();
self::assertNotNull($dataBar);
$dataBar
->setMinimumConditionalFormatValueObject(new ConditionalFormatValueObject('min'))
->setMaximumConditionalFormatValueObject(new ConditionalFormatValueObject('max'))
->setColor(Color::COLOR_GREEN);
$cond = [$cond1];
$sheet->getStyle('A1:A5')->setConditionalStyles($cond);
$writer = IOFactory::createWriter($spreadshee1, 'Xlsx');
$writer->save($outfile);
$reader = IOFactory::createReader('Xlsx');
$spreadsheet = $reader->load($outfile);
unlink($outfile);
$worksheet = $spreadsheet->getActiveSheet();
$conditionalStyle = $worksheet->getConditionalStyles('A1:A5');
self::assertNotEmpty($conditionalStyle);
/** @var Conditional $conditionalRule */
$conditionalRule = $conditionalStyle[0];
$conditions = $conditionalRule->getConditions();
self::assertNotEmpty($conditions);
self::assertEquals(Conditional::CONDITION_DATABAR, $conditionalRule->getConditionType());
self::assertNotEmpty($conditionalRule->getDataBar());
$dataBar = $conditionalRule->getDataBar();
self::assertNotNull($dataBar->getMinimumConditionalFormatValueObject());
self::assertNotNull($dataBar->getMaximumConditionalFormatValueObject());
self::assertEquals('min', $dataBar->getMinimumConditionalFormatValueObject()->getType());
self::assertEquals('max', $dataBar->getMaximumConditionalFormatValueObject()->getType());
self::assertEquals(Color::COLOR_GREEN, $dataBar->getColor());
}
private function pattern1Assertion(Worksheet $worksheet): void
{
self::assertEquals(
"Type: Automatic, Automatic\nDirection: Automatic\nFills: Gradient\nAxis Position: Automatic",
$worksheet->getCell('A2')->getValue()
);
$conditionalStyle = $worksheet->getConditionalStyles('A3:A23');
self::assertNotEmpty($conditionalStyle);
/** @var Conditional $conditionalRule */
$conditionalRule = $conditionalStyle[0];
$dataBar = $conditionalRule->getDataBar();
self::assertNotEmpty($dataBar);
self::assertEquals(Conditional::CONDITION_DATABAR, $conditionalRule->getConditionType());
self::assertNotNull($dataBar->getMinimumConditionalFormatValueObject());
self::assertNotNull($dataBar->getMaximumConditionalFormatValueObject());
self::assertEquals('min', $dataBar->getMinimumConditionalFormatValueObject()->getType());
self::assertEquals('max', $dataBar->getMaximumConditionalFormatValueObject()->getType());
self::assertEquals('FF638EC6', $dataBar->getColor());
self::assertNotEmpty($dataBar->getConditionalFormattingRuleExt());
//ext
$rule1ext = $dataBar->getConditionalFormattingRuleExt();
self::assertEquals('{72C64AE0-5CD9-164F-83D1-AB720F263E79}', $rule1ext->getId());
self::assertEquals('dataBar', $rule1ext->getCfRule());
self::assertEquals('A3:A23', $rule1ext->getSqref());
$extDataBar = $rule1ext->getDataBarExt();
self::assertNotEmpty($extDataBar);
$pattern1 = [
'minLength' => 0,
'maxLength' => 100,
'border' => true,
'gradient' => null,
'direction' => null,
'axisPosition' => null,
'negativeBarBorderColorSameAsPositive' => false,
'borderColor' => 'FF638EC6',
'negativeFillColor' => 'FFFF0000',
'negativeBorderColor' => 'FFFF0000',
];
foreach ($pattern1 as $key => $value) {
$funcName = 'get' . ucwords($key);
self::assertEquals($value, $extDataBar->$funcName(), __METHOD__ . '::' . $funcName . ' function patten');
}
self::assertNotEmpty($extDataBar->getMinimumConditionalFormatValueObject());
self::assertNotEmpty($extDataBar->getMaximumConditionalFormatValueObject());
self::assertEquals('autoMin', $extDataBar->getMinimumConditionalFormatValueObject()->getType());
self::assertEquals('autoMax', $extDataBar->getMaximumConditionalFormatValueObject()->getType());
self::assertEquals('FF000000', $extDataBar->getAxisColor()['rgb']);
}
private function pattern2Assertion(Worksheet $worksheet): void
{
self::assertEquals(
"Type: Number, Number\nValue: -5, 5\nDirection: Automatic\nFills: Solid\nAxis Position: Automatic",
$worksheet->getCell('B2')->getValue()
);
$conditionalStyle = $worksheet->getConditionalStyles('B3:B23');
self::assertNotEmpty($conditionalStyle);
/** @var Conditional $conditionalRule */
$conditionalRule = $conditionalStyle[0];
$dataBar = $conditionalRule->getDataBar();
self::assertNotEmpty($dataBar);
self::assertEquals(Conditional::CONDITION_DATABAR, $conditionalRule->getConditionType());
self::assertNotNull($dataBar->getMinimumConditionalFormatValueObject());
self::assertNotNull($dataBar->getMaximumConditionalFormatValueObject());
self::assertEquals('num', $dataBar->getMinimumConditionalFormatValueObject()->getType());
self::assertEquals('num', $dataBar->getMaximumConditionalFormatValueObject()->getType());
self::assertEquals('-5', $dataBar->getMinimumConditionalFormatValueObject()->getValue());
self::assertEquals('5', $dataBar->getMaximumConditionalFormatValueObject()->getValue());
self::assertEquals('FF63C384', $dataBar->getColor());
self::assertNotEmpty($dataBar->getConditionalFormattingRuleExt());
//ext
$rule1ext = $dataBar->getConditionalFormattingRuleExt();
self::assertEquals('{98904F60-57F0-DF47-B480-691B20D325E3}', $rule1ext->getId());
self::assertEquals('dataBar', $rule1ext->getCfRule());
self::assertEquals('B3:B23', $rule1ext->getSqref());
$extDataBar = $rule1ext->getDataBarExt();
self::assertNotEmpty($extDataBar);
$pattern1 = [
'minLength' => 0,
'maxLength' => 100,
'border' => null,
'gradient' => false,
'direction' => null,
'axisPosition' => null,
'negativeBarBorderColorSameAsPositive' => null,
'borderColor' => null,
'negativeFillColor' => 'FFFF0000',
'negativeBorderColor' => null,
];
foreach ($pattern1 as $key => $value) {
$funcName = 'get' . ucwords($key);
self::assertEquals($value, $extDataBar->$funcName(), $funcName . ' function patten');
}
self::assertNotEmpty($extDataBar->getMinimumConditionalFormatValueObject());
self::assertNotEmpty($extDataBar->getMaximumConditionalFormatValueObject());
self::assertEquals('num', $extDataBar->getMinimumConditionalFormatValueObject()->getType());
self::assertEquals('num', $extDataBar->getMaximumConditionalFormatValueObject()->getType());
self::assertEquals('-5', $extDataBar->getMinimumConditionalFormatValueObject()->getCellFormula());
self::assertEquals('5', $extDataBar->getMaximumConditionalFormatValueObject()->getCellFormula());
self::assertEquals('FF000000', $extDataBar->getAxisColor()['rgb']);
}
private function pattern3Assertion(Worksheet $worksheet): void
{
self::assertEquals(
"Type: Automatic, Automatic\nDirection: rightToLeft\nFills: Solid\nAxis Position: None",
$worksheet->getCell('C2')->getValue()
);
$conditionalStyle = $worksheet->getConditionalStyles('C3:C23');
self::assertNotEmpty($conditionalStyle);
/** @var Conditional $conditionalRule */
$conditionalRule = $conditionalStyle[0];
$dataBar = $conditionalRule->getDataBar();
self::assertNotEmpty($dataBar);
self::assertEquals(Conditional::CONDITION_DATABAR, $conditionalRule->getConditionType());
self::assertNotNull($dataBar->getMinimumConditionalFormatValueObject());
self::assertNotNull($dataBar->getMaximumConditionalFormatValueObject());
self::assertEquals('min', $dataBar->getMinimumConditionalFormatValueObject()->getType());
self::assertEquals('max', $dataBar->getMaximumConditionalFormatValueObject()->getType());
self::assertEmpty($dataBar->getMinimumConditionalFormatValueObject()->getValue());
self::assertEmpty($dataBar->getMaximumConditionalFormatValueObject()->getValue());
self::assertEquals('FFFF555A', $dataBar->getColor());
self::assertNotEmpty($dataBar->getConditionalFormattingRuleExt());
//ext
$rule1ext = $dataBar->getConditionalFormattingRuleExt();
self::assertEquals('{453C04BA-7ABD-8548-8A17-D9CFD2BDABE9}', $rule1ext->getId());
self::assertEquals('dataBar', $rule1ext->getCfRule());
self::assertEquals('C3:C23', $rule1ext->getSqref());
$extDataBar = $rule1ext->getDataBarExt();
self::assertNotEmpty($extDataBar);
$pattern1 = [
'minLength' => 0,
'maxLength' => 100,
'border' => null,
'gradient' => false,
'direction' => 'rightToLeft',
'axisPosition' => 'none',
'negativeBarBorderColorSameAsPositive' => null,
'borderColor' => null,
'negativeFillColor' => 'FFFF0000',
'negativeBorderColor' => null,
];
foreach ($pattern1 as $key => $value) {
$funcName = 'get' . ucwords($key);
self::assertEquals($value, $extDataBar->$funcName(), $funcName . ' function patten');
}
self::assertNotEmpty($extDataBar->getMinimumConditionalFormatValueObject());
self::assertNotEmpty($extDataBar->getMaximumConditionalFormatValueObject());
self::assertEquals('autoMin', $extDataBar->getMinimumConditionalFormatValueObject()->getType());
self::assertEquals('autoMax', $extDataBar->getMaximumConditionalFormatValueObject()->getType());
self::assertEmpty($extDataBar->getMinimumConditionalFormatValueObject()->getCellFormula());
self::assertEmpty($extDataBar->getMaximumConditionalFormatValueObject()->getCellFormula());
self::assertEmpty($extDataBar->getAxisColor()['rgb']);
}
private function pattern4Assertion(Worksheet $worksheet): void
{
self::assertEquals(
"type: formula, formula\nValue: =2+3, =10+10\nDirection: leftToRight\nShowDataBarOnly\nFills: Solid\nBorder: Solid\nAxis Position: Midpoint",
$worksheet->getCell('D2')->getValue()
);
$conditionalStyle = $worksheet->getConditionalStyles('D3:D23');
self::assertNotEmpty($conditionalStyle);
/** @var Conditional $conditionalRule */
$conditionalRule = $conditionalStyle[0];
$dataBar = $conditionalRule->getDataBar();
self::assertNotEmpty($dataBar);
self::assertEquals(Conditional::CONDITION_DATABAR, $conditionalRule->getConditionType());
self::assertTrue($dataBar->getShowValue());
self::assertNotNull($dataBar->getMinimumConditionalFormatValueObject());
self::assertNotNull($dataBar->getMaximumConditionalFormatValueObject());
self::assertEquals('formula', $dataBar->getMinimumConditionalFormatValueObject()->getType());
self::assertEquals('formula', $dataBar->getMaximumConditionalFormatValueObject()->getType());
self::assertEquals('3+2', $dataBar->getMinimumConditionalFormatValueObject()->getValue());
self::assertEquals('10+10', $dataBar->getMaximumConditionalFormatValueObject()->getValue());
self::assertEquals('FFFF555A', $dataBar->getColor());
self::assertNotEmpty($dataBar->getConditionalFormattingRuleExt());
//ext
$rule1ext = $dataBar->getConditionalFormattingRuleExt();
self::assertEquals('{6C1E066A-E240-3D4A-98F8-8CC218B0DFD2}', $rule1ext->getId());
self::assertEquals('dataBar', $rule1ext->getCfRule());
self::assertEquals('D3:D23', $rule1ext->getSqref());
$extDataBar = $rule1ext->getDataBarExt();
self::assertNotEmpty($extDataBar);
$pattern1 = [
'minLength' => 0,
'maxLength' => 100,
'border' => true,
'gradient' => false,
'direction' => 'leftToRight',
'axisPosition' => 'middle',
'negativeBarBorderColorSameAsPositive' => null,
'borderColor' => 'FF000000',
'negativeFillColor' => 'FFFF0000',
'negativeBorderColor' => null,
];
foreach ($pattern1 as $key => $value) {
$funcName = 'get' . ucwords($key);
self::assertEquals($value, $extDataBar->$funcName(), $funcName . ' function patten');
}
self::assertNotEmpty($extDataBar->getMaximumConditionalFormatValueObject());
self::assertNotEmpty($extDataBar->getMinimumConditionalFormatValueObject());
self::assertEquals('formula', $extDataBar->getMinimumConditionalFormatValueObject()->getType());
self::assertEquals('formula', $extDataBar->getMaximumConditionalFormatValueObject()->getType());
self::assertEquals('3+2', $extDataBar->getMinimumConditionalFormatValueObject()->getCellFormula());
self::assertEquals('10+10', $extDataBar->getMaximumConditionalFormatValueObject()->getCellFormula());
self::assertEquals('FF000000', $extDataBar->getAxisColor()['rgb']);
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/Issue3145Test.php | tests/PhpSpreadsheetTests/Reader/Xlsx/Issue3145Test.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\IOFactory;
use PHPUnit\Framework\TestCase;
class Issue3145Test extends TestCase
{
public function testIssue3145(): void
{
$filename = 'tests/data/Reader/XLSX/issue.3145.xlsx';
$reader = IOFactory::createReader('Xlsx');
$spreadsheet = $reader->load($filename);
$sheet = $spreadsheet->getActiveSheet();
self::assertEquals('Headline A', $sheet->getCell('A1')->getValue());
self::assertEquals('Configdential B', $sheet->getCell('A2')->getValue());
self::assertSame('OFFSET(INDIRECT(SUBSTITUTE($A2," ","")),0,0,COUNTA(INDIRECT(SUBSTITUTE($A2," ","")&"Col")),1)', $sheet->getCell('B2')->getDataValidation()->getFormula1());
$spreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/DirectorySeparatorTest.php | tests/PhpSpreadsheetTests/Reader/Xlsx/DirectorySeparatorTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\IOFactory;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx;
use PHPUnit\Framework\TestCase;
class DirectorySeparatorTest extends TestCase
{
#[\PHPUnit\Framework\Attributes\DataProvider('providerDirectorySeparator')]
public function testDirectorySeparatorIdentify(string $fileName): void
{
$filename = "tests/data/Reader/XLSX/{$fileName}";
$reader = IOFactory::identify($filename);
self::assertSame('Xlsx', $reader);
}
#[\PHPUnit\Framework\Attributes\DataProvider('providerDirectorySeparator')]
public function testDirectorySeparatorWorksheetNames(string $fileName): void
{
$filename = "tests/data/Reader/XLSX/{$fileName}";
$reader = new Xlsx();
$sheetList = $reader->listWorksheetNames($filename);
self::assertCount(1, $sheetList);
self::assertSame('Sheet', $sheetList[0]);
}
#[\PHPUnit\Framework\Attributes\DataProvider('providerDirectorySeparator')]
public function testDirectorySeparatorWorksheetInfo(string $fileName): void
{
$filename = "tests/data/Reader/XLSX/{$fileName}";
$reader = new Xlsx();
$sheetData = $reader->listWorksheetInfo($filename);
self::assertCount(1, $sheetData);
self::assertSame('Sheet', $sheetData[0]['worksheetName']);
self::assertSame(3, (int) $sheetData[0]['totalRows']);
self::assertSame(21, (int) $sheetData[0]['totalColumns']);
}
#[\PHPUnit\Framework\Attributes\DataProvider('providerDirectorySeparator')]
public function testDirectorySeparatorLoad(string $fileName): void
{
$filename = "tests/data/Reader/XLSX/{$fileName}";
$reader = new Xlsx();
$spreadsheet = $reader->load($filename);
$cellValue = $spreadsheet->getActiveSheet()->getCell('A1')->getValue();
self::assertSame('Key ID', $cellValue);
}
public static function providerDirectorySeparator(): array
{
return [
['Zip-Linux-Directory-Separator.xlsx'],
['Zip-Windows-Directory-Separator.xlsx'],
];
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/AutoFilterEvaluateTest.php | tests/PhpSpreadsheetTests/Reader/Xlsx/AutoFilterEvaluateTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Worksheet\AutoFilter\Column;
use PhpOffice\PhpSpreadsheet\Worksheet\AutoFilter\Column\Rule;
use PhpOffice\PhpSpreadsheet\Worksheet\Worksheet;
use PhpOffice\PhpSpreadsheetTests\Functional\AbstractFunctional;
class AutoFilterEvaluateTest extends AbstractFunctional
{
/** @return int[] */
private function getVisibleSheet(Worksheet $sheet): array
{
$actualVisible = [];
for ($row = 2; $row <= $sheet->getHighestRow(); ++$row) {
if ($sheet->getRowDimension($row)->getVisible()) {
$actualVisible[] = $row;
}
}
return $actualVisible;
}
private function initializeSpreadsheet(): Spreadsheet
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->getCell('A1')->setValue('Filtered');
for ($row = 2; $row <= 15; ++$row) {
$sheet->getCell("A$row")->setValue($row % 5);
}
$autoFilter = $sheet->getAutoFilter();
$autoFilter->setRange('A1:A15');
$columnFilter = $autoFilter->getColumn('A');
$columnFilter->setFilterType(Column::AUTOFILTER_FILTERTYPE_FILTER);
$columnFilter->createRule()->setRule(Rule::AUTOFILTER_COLUMN_RULE_EQUAL, 1);
$columnFilter->createRule()->setRule(Rule::AUTOFILTER_COLUMN_RULE_EQUAL, 3);
$sheet->getCell('A16')->setValue(2); // outside of range
return $spreadsheet;
}
public function testAutoFilterUnevaluated(): void
{
$spreadsheet = $this->initializeSpreadsheet();
$sheet = $spreadsheet->getActiveSheet();
//$sheet->getAutoFilter->showHideRows();
$sheet->getRowDimension(6)->setVisible(false);
//$columnFilter->setFilterType(Column::AUTOFILTER_FILTERTYPE_FILTER);
// Because showHideRows isn't executed beforehand, it will be executed
// at write time, causing row 6 to be visible.
$reloadedSpreadsheet = $this->writeAndReload($spreadsheet, 'Xlsx');
$spreadsheet->disconnectWorksheets();
$rsheet = $reloadedSpreadsheet->getSheet(0);
self::assertSame([3, 6, 8, 11, 13, 16], $this->getVisibleSheet($rsheet));
$reloadedSpreadsheet->disconnectWorksheets();
}
public function testAutoFilterEvaluated(): void
{
$spreadsheet = $this->initializeSpreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->getAutoFilter()->showHideRows();
$sheet->getRowDimension(6)->setVisible(false);
//$columnFilter->setFilterType(Column::AUTOFILTER_FILTERTYPE_FILTER);
// Because showHideRows is executed beforehand, it won't be executed
// at write time, so row 6 will remain hidden.
$reloadedSpreadsheet = $this->writeAndReload($spreadsheet, 'Xlsx');
$spreadsheet->disconnectWorksheets();
$rsheet = $reloadedSpreadsheet->getSheet(0);
self::assertSame([3, 8, 11, 13, 16], $this->getVisibleSheet($rsheet));
$reloadedSpreadsheet->disconnectWorksheets();
}
public function testAutoFilterReevaluated(): void
{
$spreadsheet = $this->initializeSpreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->getAutoFilter()->showHideRows();
$sheet->getRowDimension(6)->setVisible(false);
$sheet->getAutoFilter()->getColumn('A')->setFilterType(Column::AUTOFILTER_FILTERTYPE_FILTER);
// Because filter is changed after showHideRows, it will be reevaluated
// at write time, so row 6 will be visible.
$reloadedSpreadsheet = $this->writeAndReload($spreadsheet, 'Xlsx');
$spreadsheet->disconnectWorksheets();
$rsheet = $reloadedSpreadsheet->getSheet(0);
self::assertSame([3, 6, 8, 11, 13, 16], $this->getVisibleSheet($rsheet));
$reloadedSpreadsheet->disconnectWorksheets();
}
public function testAutoFilterSetRangeMax(): void
{
$spreadsheet = $this->initializeSpreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->getCell('A1')->setValue('Filtered');
$sheet->getAutoFilter()->setRangeToMaxRow();
$sheet->getAutoFilter()->showHideRows();
$sheet->getRowDimension(6)->setVisible(false);
$sheet->getAutoFilter()->getColumn('A')->setFilterType(Column::AUTOFILTER_FILTERTYPE_FILTER);
// Because filter is changed after showHideRows, it will be reevaluated
// at write time, so row 6 will be visible.
$reloadedSpreadsheet = $this->writeAndReload($spreadsheet, 'Xlsx');
$spreadsheet->disconnectWorksheets();
$rsheet = $reloadedSpreadsheet->getSheet(0);
self::assertSame([3, 6, 8, 11, 13], $this->getVisibleSheet($rsheet));
$reloadedSpreadsheet->disconnectWorksheets();
}
public function testAutoFilterSpreadsheetReevaluate(): void
{
$spreadsheet = $this->initializeSpreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->getCell('A1')->setValue('Filtered');
$sheet->getAutoFilter()->showHideRows();
$sheet->getRowDimension(6)->setVisible(false);
$spreadsheet->reevaluateAutoFilters(false);
// Because filter is changed after showHideRows, it will be reevaluated
// at write time, so row 6 will be visible.
$reloadedSpreadsheet = $this->writeAndReload($spreadsheet, 'Xlsx');
$spreadsheet->disconnectWorksheets();
$rsheet = $reloadedSpreadsheet->getSheet(0);
self::assertSame([3, 6, 8, 11, 13, 16], $this->getVisibleSheet($rsheet));
$reloadedSpreadsheet->disconnectWorksheets();
}
public function testAutoFilterSpreadsheetReevaluateResetMax(): void
{
$spreadsheet = $this->initializeSpreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->getCell('A1')->setValue('Filtered');
$sheet->getAutoFilter()->showHideRows();
$sheet->getRowDimension(6)->setVisible(false);
$spreadsheet->reevaluateAutoFilters(true);
// Because filter is changed after showHideRows, it will be reevaluated
// at write time, so row 6 will be visible.
$reloadedSpreadsheet = $this->writeAndReload($spreadsheet, 'Xlsx');
$spreadsheet->disconnectWorksheets();
$rsheet = $reloadedSpreadsheet->getSheet(0);
self::assertSame([3, 6, 8, 11, 13], $this->getVisibleSheet($rsheet));
$reloadedSpreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/ConditionalPriorityTest.php | tests/PhpSpreadsheetTests/Reader/Xlsx/ConditionalPriorityTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\IOFactory;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Style\Conditional;
use PhpOffice\PhpSpreadsheet\Style\Fill;
use PhpOffice\PhpSpreadsheetTests\Functional\AbstractFunctional;
class ConditionalPriorityTest extends AbstractFunctional
{
public function testConditionalPriority(): void
{
$filename = 'tests/data/Reader/XLSX/issue.4312c.xlsx';
$reader = IOFactory::createReader('Xlsx');
$spreadsheet = $reader->load($filename);
$reloadedSpreadsheet = $this->writeAndReload($spreadsheet, 'Xlsx');
$spreadsheet->disconnectWorksheets();
$worksheet = $reloadedSpreadsheet->getActiveSheet();
$priorities = [];
foreach ($worksheet->getConditionalStylesCollection() as $conditionalStyles) {
foreach ($conditionalStyles as $conditional) {
$priorities[] = $conditional->getPriority();
}
}
$expected = [27, 2, 3, 4, 1, 22, 14, 5, 6, 7, 20];
self::assertSame($expected, $priorities);
$reloadedSpreadsheet->disconnectWorksheets();
}
public function testZeroPriority(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->fromArray([
[1, 1, 1, 1],
[2, 2, 2, 2],
[3, 3, 3, 3],
[4, 4, 4, 4],
[5, 5, 5, 5],
]);
$range = 'A1:A5';
$styles = [];
$new = new Conditional();
$new->setConditionType(Conditional::CONDITION_CELLIS)
->setOperatorType(Conditional::OPERATOR_EQUAL)
->setPriority(30)
->setConditions(['3'])
->getStyle()
->getFill()
->setFillType(Fill::FILL_SOLID)
->getStartColor()
->setArgb('FFC00000');
$styles[] = $new;
$sheet->setConditionalStyles($range, $styles);
$range = 'B1:B5';
$styles = [];
$new = new Conditional();
$new->setConditionType(Conditional::CONDITION_EXPRESSION)
->setConditions('=MOD(A1,2)=0')
->getStyle()
->getFill()
->setFillType(Fill::FILL_SOLID)
->getStartColor()
->setArgb('FF00B0F0');
$styles[] = $new;
$new = new Conditional();
$new->setConditionType(Conditional::CONDITION_CELLIS)
->setOperatorType(Conditional::OPERATOR_EQUAL)
->setPriority(40)
->setConditions(['4'])
->getStyle()
->getFill()
->setFillType(Fill::FILL_SOLID)
->getStartColor()
->setArgb('FFFFC000');
$styles[] = $new;
$sheet->setConditionalStyles($range, $styles);
$range = 'C1:C5';
$styles = [];
$new = new Conditional();
$new->setConditionType(Conditional::CONDITION_CELLIS)
->setOperatorType(Conditional::OPERATOR_EQUAL)
->setPriority(20)
->setConditions(['2'])
->getStyle()
->getFill()
->setFillType(Fill::FILL_SOLID)
->getStartColor()
->setArgb('FFFFFF00');
$styles[] = $new;
$new = new Conditional();
$new->setConditionType(Conditional::CONDITION_CELLIS)
->setOperatorType(Conditional::OPERATOR_EQUAL)
->setConditions(['5'])
->getStyle()
->getFill()
->setFillType(Fill::FILL_SOLID)
->getStartColor()
->setArgb('FF008080');
$styles[] = $new;
$sheet->setConditionalStyles($range, $styles);
$reloadedSpreadsheet = $this->writeAndReload($spreadsheet, 'Xlsx');
$spreadsheet->disconnectWorksheets();
$worksheet = $reloadedSpreadsheet->getActiveSheet();
$priorities = [];
foreach ($worksheet->getConditionalStylesCollection() as $conditionalStyles) {
foreach ($conditionalStyles as $conditional) {
$priorities[] = $conditional->getPriority();
}
}
// B1:B5 is written in order 41, 40, but Reader sorts them
$expected = [30, 40, 41, 20, 42];
self::assertSame($expected, $priorities);
$styles = $worksheet->getConditionalStyles('B1:B5');
self::assertSame(Conditional::CONDITION_CELLIS, $styles[0]->getConditionType());
self::assertSame(40, $styles[0]->getPriority());
self::assertSame(Conditional::CONDITION_EXPRESSION, $styles[1]->getConditionType());
self::assertSame(41, $styles[1]->getPriority());
$reloadedSpreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/HiddenMergeCellsTest.php | tests/PhpSpreadsheetTests/Reader/Xlsx/HiddenMergeCellsTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx;
use PHPUnit\Framework\TestCase;
class HiddenMergeCellsTest extends TestCase
{
private const FILENAME = 'tests/data/Reader/XLSX/HiddenMergeCellsTest.xlsx';
public function testHiddenMergeCells(): void
{
$reader = new Xlsx();
$spreadsheet = $reader->load(self::FILENAME);
$c2InMergeRange = $spreadsheet->getActiveSheet()->getCell('C2')->isInMergeRange();
self::assertTrue($c2InMergeRange);
$a2InMergeRange = $spreadsheet->getActiveSheet()->getCell('A2')->isInMergeRange();
self::assertTrue($a2InMergeRange);
$a2MergeRangeValue = $spreadsheet->getActiveSheet()->getCell('A2')->isMergeRangeValueCell();
self::assertTrue($a2MergeRangeValue);
$cellArray = $spreadsheet->getActiveSheet()->rangeToArray('A2:C2');
self::assertSame([['12', '4', '3']], $cellArray);
$cellArray = $spreadsheet->getActiveSheet()->rangeToArray('A2:C2', null, true, false);
self::assertSame([[12, 4, 3]], $cellArray);
$spreadsheet->disconnectWorksheets();
}
public function testUnmergeHiddenMergeCells(): void
{
$reader = new Xlsx();
$spreadsheet = $reader->load(self::FILENAME);
$spreadsheet->getActiveSheet()->unmergeCells('A2:C2');
$c2InMergeRange = $spreadsheet->getActiveSheet()->getCell('C2')->isInMergeRange();
self::assertFalse($c2InMergeRange);
$a2InMergeRange = $spreadsheet->getActiveSheet()->getCell('A2')->isInMergeRange();
self::assertFalse($a2InMergeRange);
$cellArray = $spreadsheet->getActiveSheet()->rangeToArray('A2:C2', null, false, false, false);
self::assertSame([[12, '=6-B1', '=A2/B2']], $cellArray);
$spreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/Issue3534Test.php | tests/PhpSpreadsheetTests/Reader/Xlsx/Issue3534Test.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx as XlsxReader;
use PhpOffice\PhpSpreadsheet\Style\Fill;
class Issue3534Test extends \PHPUnit\Framework\TestCase
{
private static string $testbook = 'tests/data/Reader/XLSX/issue.3534.xlsx';
public function testReadColumnStyles(): void
{
$reader = new XlsxReader();
$spreadsheet = $reader->load(self::$testbook);
$sheet = $spreadsheet->getActiveSheet();
self::assertSame(['B4', 'C4'], $sheet->getCellCollection()->getCoordinates(), 'explicitly defined despite no value because differ from row style');
self::assertSame(1, $sheet->getColumnDimension('A')->getXfIndex());
self::assertNull($sheet->getRowDimension(1)->getXfIndex());
$sheet->getCell('A1')->setValue('a1');
self::assertSame(['B4', 'C4', 'A1'], $sheet->getCellCollection()->getCoordinates());
self::assertSame(1, $sheet->getCell('A1')->getXfIndex(), 'no row style so apply column style');
$sheet->getCell('A4')->setValue('a4');
$sheet->getCell('C1')->setValue('c1');
self::assertSame('ED7D31', $sheet->getStyle('A1')->getFill()->getStartColor()->getRgb(), 'no row style so apply column style');
self::assertSame('FFC000', $sheet->getStyle('A4')->getFill()->getStartColor()->getRgb(), 'style for row is applied');
self::assertSame('9DC3E6', $sheet->getStyle('C1')->getFill()->getStartColor()->getRgb(), 'no row style so apply column style');
self::assertSame('9DC3E6', $sheet->getStyle('C4')->getFill()->getStartColor()->getRgb(), 'style was already set in xml');
self::assertSame(Fill::FILL_NONE, $sheet->getStyle('B4')->getFill()->getFillType(), 'style implicitly default in xml');
$spreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/AlignmentTest.php | tests/PhpSpreadsheetTests/Reader/Xlsx/AlignmentTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Style\Alignment;
use PhpOffice\PhpSpreadsheetTests\Functional\AbstractFunctional;
class AlignmentTest extends AbstractFunctional
{
private ?Spreadsheet $spreadsheet = null;
private ?Spreadsheet $reloadedSpreadsheet = null;
protected function tearDown(): void
{
if ($this->spreadsheet !== null) {
$this->spreadsheet->disconnectWorksheets();
$this->spreadsheet = null;
}
if ($this->reloadedSpreadsheet !== null) {
$this->reloadedSpreadsheet->disconnectWorksheets();
$this->reloadedSpreadsheet = null;
}
}
public function testJustifyLastLine(): void
{
$this->spreadsheet = new Spreadsheet();
$sheet = $this->spreadsheet->getActiveSheet();
$sheet->setCellValue('A1', 'ABC');
$sheet->setCellValue('A2', 'DEF');
$sheet->setCellValue('A3', 'GHI');
$sheet->getStyle('A1')
->getAlignment()
->setHorizontal(Alignment::HORIZONTAL_DISTRIBUTED)
->setJustifyLastLine(true);
$sheet->getStyle('A2')
->getAlignment()
->setHorizontal(Alignment::HORIZONTAL_DISTRIBUTED)
->setJustifyLastLine(false);
$sheet->getStyle('A3')
->getAlignment()
->setHorizontal(Alignment::HORIZONTAL_DISTRIBUTED);
$this->reloadedSpreadsheet = $this->writeAndReload($this->spreadsheet, 'Xlsx');
$rsheet = $this->reloadedSpreadsheet->getActiveSheet();
self::assertTrue(
$rsheet->getStyle('A1')
->getAlignment()
->getJustifyLastLine()
);
self::assertFalse(
$rsheet->getStyle('A2')
->getAlignment()
->getJustifyLastLine()
);
self::assertNull(
$rsheet->getStyle('A3')
->getAlignment()
->getJustifyLastLine()
);
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/OutlineTest.php | tests/PhpSpreadsheetTests/Reader/Xlsx/OutlineTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx as XlsxReader;
use PhpOffice\PhpSpreadsheet\Writer\Xlsx as XlsxWriter;
use PHPUnit\Framework\TestCase;
class OutlineTest extends TestCase
{
public function testOutline(): void
{
$filename = 'tests/data/Reader/XLSX/outline.xlsx';
$reader = new XlsxReader();
$spreadsheet = $reader->load($filename);
$sheet = $spreadsheet->getActiveSheet();
self::assertSame(0, $sheet->getRowDimension(1)->getOutlineLevel());
self::assertSame(2, $sheet->getRowDimension(2)->getOutlineLevel());
self::assertFalse($sheet->getRowDimension(2)->getCollapsed());
self::assertTrue($sheet->getRowDimension(2)->getVisible());
self::assertSame('=SUBTOTAL(9,B2:B4)', $sheet->getCell('B5')->getValue());
self::assertSame(2, $sheet->getRowDimension(6)->getOutlineLevel());
self::assertFalse($sheet->getRowDimension(6)->getCollapsed());
self::assertFalse($sheet->getRowDimension(6)->getVisible());
self::assertSame(1, $sheet->getRowDimension(8)->getOutlineLevel());
self::assertTrue($sheet->getRowDimension(8)->getCollapsed());
self::assertTrue($sheet->getRowDimension(8)->getVisible());
$fake = new XlsxReader\ColumnAndRowAttributes($sheet, null);
self::assertFalse($fake->load());
$writer = new XlsxWriter($spreadsheet);
$writerWorksheet = new XlsxWriter\Worksheet($writer);
$data = $writerWorksheet->writeWorksheet($sheet, []);
self::assertStringContainsString('<row r="7" spans="1:2" hidden="true" outlineLevel="2">', $data);
self::assertStringContainsString('<row r="8" spans="1:2" collapsed="true" outlineLevel="1">', $data);
$spreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/Issue2542Test.php | tests/PhpSpreadsheetTests/Reader/Xlsx/Issue2542Test.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\RichText\RichText;
use PHPUnit\Framework\TestCase;
class Issue2542Test extends TestCase
{
private static string $testbook = 'tests/data/Reader/XLSX/issue.2542.xlsx';
public function testPreliminaries(): void
{
// Rich text without 'sz' tag
$file = 'zip://';
$file .= self::$testbook;
$file .= '#xl/sharedStrings.xml';
$data = file_get_contents($file);
// confirm that file contains expected namespaced xml tag
if ($data === false) {
self::fail('Unable to read file sharedStrings.xml');
} else {
self::assertStringContainsString('<si><r><rPr><rFont val="Arial"/><b/><color theme="1"/></rPr><t xml:space="preserve">Factor group
</t></r><r><rPr><rFont val="Arial"/><b val="0"/><color theme="1"/></rPr><t>(for Rental items only)</t></r></si>', $data);
}
}
public function testIssue2542(): void
{
$filename = self::$testbook;
$reader = new Xlsx();
$spreadsheet = $reader->load($filename);
$sheet = $spreadsheet->getActiveSheet();
$value = $sheet->getCell('P1')->getValue();
if ($value instanceof RichText) {
self::assertSame("Factor group\n(for Rental items only)", $value->getPlainText());
} else {
self::fail('Cell P1 is not RichText');
}
$spreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/PageSetup2Test.php | tests/PhpSpreadsheetTests/Reader/Xlsx/PageSetup2Test.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\IOFactory;
use PhpOffice\PhpSpreadsheet\Worksheet\Worksheet;
use PHPUnit\Framework\TestCase;
class PageSetup2Test extends TestCase
{
private const TESTBOOK = 'tests/data/Reader/XLSX/autofilter2.xlsx';
public function testHeaderFooter(): void
{
$spreadsheet = IOFactory::load(self::TESTBOOK);
$sheets = 0;
foreach ($spreadsheet->getAllSheets() as $worksheet) {
++$sheets;
$hf = $worksheet->getHeaderFooter();
self::assertTrue($hf->getDifferentOddEven());
self::assertTrue($hf->getDifferentFirst());
}
self::assertSame(4, $sheets);
$spreadsheet->disconnectWorksheets();
}
public function testColumnBreak(): void
{
$spreadsheet = IOFactory::load(self::TESTBOOK);
$sheet = $spreadsheet->getSheetByNameOrThrow('colbreak');
$breaks = $sheet->getBreaks();
self::assertCount(1, $breaks);
$break = $breaks['D1'] ?? null;
self::assertNotNull($break);
self::assertSame($break, Worksheet::BREAK_COLUMN);
$spreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/Issue3665Test.php | tests/PhpSpreadsheetTests/Reader/Xlsx/Issue3665Test.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx;
class Issue3665Test extends \PHPUnit\Framework\TestCase
{
private static string $testbook = 'tests/data/Reader/XLSX/issue.3665.xlsx';
public function testPreliminaries(): void
{
$file = 'zip://';
$file .= self::$testbook;
$file .= '#xl/tables/table1.xml';
$data = file_get_contents($file);
// confirm that file contains expected namespaced xml tag
if ($data === false) {
self::fail('Unable to read table file');
} else {
self::assertStringContainsString('<x:table id="5" name="Table5" displayName="Table5" ref="A3:M4" tableType="xml" totalsRowShown="0" xmlns:x="http://schemas.openxmlformats.org/spreadsheetml/2006/main">', $data);
self::assertStringContainsString('<x:autoFilter ref="A3:M4" />', $data);
}
$file = 'zip://';
$file .= self::$testbook;
$file .= '#xl/worksheets/_rels/sheet1.xml.rels';
$data = file_get_contents($file);
// confirm absolute path as reference
if ($data === false) {
self::fail('Unable to read rels file');
} else {
self::assertStringContainsString('Target="/xl/comments1.xml"', $data);
}
}
public function testTable(): void
{
$reader = new Xlsx();
$spreadsheet = $reader->load(self::$testbook);
$sheet = $spreadsheet->getActiveSheet();
$tables = $sheet->getTableCollection();
self::assertCount(1, $tables);
$table = $tables->offsetGet(0);
if ($table === null) {
self::fail('Unexpected failure obtaining table');
} else {
self::assertEquals('Table5', $table->getName());
self::assertEquals('A3:M4', $table->getRange());
self::assertTrue($table->getAllowFilter());
self::assertSame('A3:M4', $table->getAutoFilter()->getRange());
}
$comment = $sheet->getComment('A3');
self::assertSame('Code20', (string) $comment);
$comment = $sheet->getComment('B3');
self::assertSame('Text100', (string) $comment);
$spreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/Issue731Test.php | tests/PhpSpreadsheetTests/Reader/Xlsx/Issue731Test.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx;
use PhpOffice\PhpSpreadsheetTests\Functional\AbstractFunctional;
class Issue731Test extends AbstractFunctional
{
private static string $testbook = 'tests/data/Reader/XLSX/issue.731.xlsx';
public function testRotateAndFlipImages(): void
{
$reader = new Xlsx();
$spreadsheet = $reader->load(self::$testbook);
$reloadedSpreadsheet = $this->writeAndReload($spreadsheet, 'Xlsx');
$spreadsheet->disconnectWorksheets();
$reloadedSheet = $reloadedSpreadsheet->getActiveSheet();
$expected = [
[0, false, false],
[90, false, false],
[270, false, false],
[0, false, true],
[0, true, false],
[20, false, false],
[20, false, true],
[0, true, true],
];
$actual = [];
foreach ($reloadedSheet->getDrawingCollection() as $drawing) {
$actual[] = [$drawing->getRotation(), $drawing->getFlipHorizontal(), $drawing->getFlipVertical()];
}
self::assertSame($expected, $actual);
$reloadedSpreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/DrawingOneCellAnchorTest.php | tests/PhpSpreadsheetTests/Reader/Xlsx/DrawingOneCellAnchorTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\IOFactory;
use PhpOffice\PhpSpreadsheet\Worksheet\BaseDrawing;
use PHPUnit\Framework\TestCase;
class DrawingOneCellAnchorTest extends TestCase
{
public function testGetDrawing(): void
{
$filename = __DIR__ . '/../../../data/Reader/XLSX/drawingOneCellAnchor.xlsx';
$reader = IOFactory::createReader('Xlsx');
$spreadsheet = $reader->load($filename);
$worksheet = $spreadsheet->getActiveSheet();
$collection = $worksheet->getDrawingCollection();
self::assertCount(1, $collection);
/** @var BaseDrawing $drawing */
$drawing = $collection[0];
self::assertEquals('A2', $drawing->getCoordinates());
self::assertEquals(10, $drawing->getOffsetX());
self::assertEquals(10, $drawing->getOffsetY());
self::assertEquals(150, $drawing->getHeight());
self::assertEquals(150, $drawing->getWidth());
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/ConditionalPriority2Test.php | tests/PhpSpreadsheetTests/Reader/Xlsx/ConditionalPriority2Test.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\IOFactory;
use PhpOffice\PhpSpreadsheetTests\Functional\AbstractFunctional;
class ConditionalPriority2Test extends AbstractFunctional
{
public function testConditionalPriority(): void
{
$filename = 'tests/data/Reader/XLSX/issue.4318.xlsx';
$reader = IOFactory::createReader('Xlsx');
$spreadsheet = $reader->load($filename);
$reloadedSpreadsheet = $this->writeAndReload($spreadsheet, 'Xlsx');
$spreadsheet->disconnectWorksheets();
$sheet = $reloadedSpreadsheet->getActiveSheet();
$rules = $sheet->getConditionalStyles('E5', false);
self::assertCount(4, $rules);
self::assertSame(2, $rules[0]->getPriority());
self::assertSame(['$B$2<2'], $rules[0]->getConditions());
self::assertSame(3, $rules[1]->getPriority());
self::assertSame(['$B$2=""'], $rules[1]->getConditions());
self::assertSame(4, $rules[2]->getPriority());
self::assertSame(['$B$2=3'], $rules[2]->getConditions());
self::assertSame(5, $rules[3]->getPriority());
self::assertSame(['$B$2=2'], $rules[3]->getConditions());
$reloadedSpreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/SharedFormulaeTest.php | tests/PhpSpreadsheetTests/Reader/Xlsx/SharedFormulaeTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\IOFactory;
use PHPUnit\Framework\TestCase;
class SharedFormulaeTest extends TestCase
{
public function testSharedFormulae(): void
{
// Boolean functions were not handled correctly.
$filename = 'tests/data/Reader/XLSX/sharedformulae.xlsx';
$reader = IOFactory::createReader('Xlsx');
$spreadsheet = $reader->load($filename);
$sheet = $spreadsheet->getActiveSheet();
$expected = [
[1, '=A1+1', '=A1>3', '="x"&A1'],
[2, '=A2+1', '=A2>3', '="x"&A2'],
[3, '=A3+1', '=A3>3', '="x"&A3'],
[4, '=A4+1', '=A4>3', '="x"&A4'],
[5, '=A5+1', '=A5>3', '="x"&A5'],
];
self::assertSame($expected, $sheet->toArray(null, false, false));
$expected = [
[1, 2, false, 'x1'],
[2, 3, false, 'x2'],
[3, 4, false, 'x3'],
[4, 5, true, 'x4'],
[5, 6, true, 'x5'],
];
self::assertSame($expected, $sheet->toArray(null, true, false));
$spreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/ConditionalNoFormatSetTest.php | tests/PhpSpreadsheetTests/Reader/Xlsx/ConditionalNoFormatSetTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx as XlsxReader;
use PhpOffice\PhpSpreadsheet\Shared\File;
use PhpOffice\PhpSpreadsheet\Writer\Xlsx as XlsxWriter;
use PHPUnit\Framework\TestCase;
class ConditionalNoFormatSetTest extends TestCase
{
public function testNoFormatTest(): void
{
$testfile = 'tests/data/Reader/XLSX/issue.3202.xlsx';
$file = 'zip://';
$file .= $testfile;
$file .= '#xl/worksheets/sheet1.xml';
$data = file_get_contents($file);
$expected = '<conditionalFormatting sqref="A1:A5">'
. '<cfRule type="expression" dxfId="1" priority="2" stopIfTrue="1">'
. '<formula>$A1>5</formula>'
. '</cfRule>'
. '<cfRule type="expression" dxfId="0" priority="3">'
. '<formula>$A1>1</formula>'
. '</cfRule>'
. '<cfRule type="expression" priority="1" stopIfTrue="1">'
. '<formula>$A1=3</formula>'
. '</cfRule>'
. '</conditionalFormatting>';
self::assertStringContainsString($expected, $data);
$reader = new XlsxReader();
$spreadsheet = $reader->load($testfile);
$sheet = $spreadsheet->getactiveSheet();
$collection = $sheet->getConditionalStylesCollection();
self::assertCount(1, $collection);
$conditionalArray = $collection['A1:A5'];
self::assertCount(3, $conditionalArray);
$conditions = $conditionalArray[0]->getConditions();
self::assertCount(1, $conditions);
self::assertSame('$A1=3', $conditions[0]);
self::assertTrue($conditionalArray[0]->getNoFormatSet());
self::assertTrue($conditionalArray[0]->getStopIfTrue());
$conditions = $conditionalArray[1]->getConditions();
self::assertCount(1, $conditions);
self::assertSame('$A1>5', $conditions[0]);
self::assertFalse($conditionalArray[1]->getNoFormatSet());
self::assertTrue($conditionalArray[1]->getStopIfTrue());
$conditions = $conditionalArray[2]->getConditions();
self::assertCount(1, $conditions);
self::assertSame('$A1>1', $conditions[0]);
self::assertFalse($conditionalArray[2]->getNoFormatSet());
self::assertFalse($conditionalArray[2]->getStopIfTrue());
$outfile = File::temporaryFilename();
$writer = new XlsxWriter($spreadsheet);
$writer->save($outfile);
$spreadsheet->disconnectWorksheets();
$file = 'zip://';
$file .= $outfile;
$file .= '#xl/worksheets/sheet1.xml';
$data = file_get_contents($file);
unlink($outfile);
$expected = '<conditionalFormatting sqref="A1:A5">'
. '<cfRule type="expression" priority="1" stopIfTrue="1">'
. '<formula>$A1=3</formula>'
. '</cfRule>'
. '<cfRule type="expression" dxfId="1" priority="2" stopIfTrue="1">'
. '<formula>$A1>5</formula>'
. '</cfRule>'
. '<cfRule type="expression" dxfId="2" priority="3">'
. '<formula>$A1>1</formula>'
. '</cfRule>'
. '</conditionalFormatting>';
self::assertStringContainsString($expected, $data);
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/NamespaceNonStdTest.php | tests/PhpSpreadsheetTests/Reader/Xlsx/NamespaceNonStdTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\Style\Border;
use PhpOffice\PhpSpreadsheet\Style\Fill;
use PhpOffice\PhpSpreadsheet\Style\Font;
class NamespaceNonStdTest extends \PHPUnit\Framework\TestCase
{
private static string $testbook = 'tests/data/Reader/XLSX/namespacenonstd.xlsx';
public function testPreliminaries(): void
{
$file = 'zip://';
$file .= self::$testbook;
$file .= '#xl/workbook.xml';
$data = file_get_contents($file);
// confirm that file contains expected namespaced xml tag
if ($data === false) {
self::fail('Unable to read file');
} else {
if (!str_contains(__FILE__, 'NonStd')) {
self::assertStringNotContainsString('nonstd', self::$testbook);
self::assertStringContainsString('<workbook ', $data);
} else {
self::assertStringContainsString('nonstd', self::$testbook);
self::assertStringContainsString('<x:workbook ', $data);
}
}
}
public function testInfo(): void
{
$reader = new Xlsx();
$workSheetInfo = $reader->listWorkSheetInfo(self::$testbook);
$info0 = $workSheetInfo[0];
self::assertEquals('SylkTest', $info0['worksheetName']);
self::assertEquals('J', $info0['lastColumnLetter']);
self::assertEquals(9, $info0['lastColumnIndex']);
self::assertEquals(18, $info0['totalRows']);
self::assertEquals(10, $info0['totalColumns']);
}
public function testSheetNames(): void
{
$reader = new Xlsx();
$worksheetNames = $reader->listWorksheetNames(self::$testbook);
self::assertEquals(['SylkTest', 'Second'], $worksheetNames);
}
public function testActive(): void
{
$reader = new Xlsx();
$spreadsheet = $reader->load(self::$testbook);
$sheet = $spreadsheet->getActiveSheet();
self::assertSame('Second', $sheet->getTitle());
self::assertSame('A2', $sheet->getFreezePane());
self::assertSame('A2', $sheet->getTopLeftCell());
self::assertSame('B3', $sheet->getSelectedCells());
$sheet = $spreadsheet->getSheetByNameOrThrow('SylkTest');
self::assertNull($sheet->getFreezePane());
self::assertNull($sheet->getTopLeftCell());
}
public function testLoadXlsx(): void
{
$reader = new Xlsx();
$spreadsheet = $reader->load(self::$testbook);
$sheet = $spreadsheet->getSheet(0);
self::assertEquals('SylkTest', $sheet->getTitle());
//if (strpos(__FILE__, 'NonStd') !== false) {
// self::markTestIncomplete('Not yet ready');
//}
self::assertEquals('FFFF0000', $sheet->getCell('A1')->getStyle()->getFont()->getColor()->getARGB());
self::assertEquals(Fill::FILL_PATTERN_GRAY125, $sheet->getCell('A2')->getStyle()->getFill()->getFillType());
self::assertEquals(Font::UNDERLINE_SINGLE, $sheet->getCell('A4')->getStyle()->getFont()->getUnderline());
self::assertEquals('Test with (;) in string', $sheet->getCell('A4')->getValue());
self::assertEquals(22269, $sheet->getCell('A10')->getValue());
self::assertEquals('dd/mm/yyyy', $sheet->getCell('A10')->getStyle()->getNumberFormat()->getFormatCode());
self::assertEquals('19/12/1960', $sheet->getCell('A10')->getFormattedValue());
self::assertEquals(1.5, $sheet->getCell('A11')->getValue());
self::assertEquals('# ?/?', $sheet->getCell('A11')->getStyle()->getNumberFormat()->getFormatCode());
self::assertEquals('1 1/2', $sheet->getCell('A11')->getFormattedValue());
self::assertEquals('=B1+C1', $sheet->getCell('H1')->getValue());
self::assertEquals('=E2&F2', $sheet->getCell('J2')->getValue());
self::assertEquals('=SUM(C1:C4)', $sheet->getCell('I5')->getValue());
self::assertEquals('=MEDIAN(B6:B8)', $sheet->getCell('B9')->getValue());
self::assertEquals(11, $sheet->getCell('E1')->getStyle()->getFont()->getSize());
self::assertTrue($sheet->getCell('E1')->getStyle()->getFont()->getBold());
self::assertTrue($sheet->getCell('E1')->getStyle()->getFont()->getItalic());
self::assertEquals(Font::UNDERLINE_SINGLE, $sheet->getCell('E1')->getStyle()->getFont()->getUnderline());
self::assertFalse($sheet->getCell('E2')->getStyle()->getFont()->getBold());
self::assertFalse($sheet->getCell('E2')->getStyle()->getFont()->getItalic());
self::assertEquals(Font::UNDERLINE_NONE, $sheet->getCell('E2')->getStyle()->getFont()->getUnderline());
self::assertTrue($sheet->getCell('E3')->getStyle()->getFont()->getBold());
self::assertFalse($sheet->getCell('E3')->getStyle()->getFont()->getItalic());
self::assertEquals(Font::UNDERLINE_NONE, $sheet->getCell('E3')->getStyle()->getFont()->getUnderline());
self::assertFalse($sheet->getCell('E4')->getStyle()->getFont()->getBold());
self::assertTrue($sheet->getCell('E4')->getStyle()->getFont()->getItalic());
self::assertEquals(Font::UNDERLINE_NONE, $sheet->getCell('E4')->getStyle()->getFont()->getUnderline());
self::assertTrue($sheet->getCell('F1')->getStyle()->getFont()->getBold());
self::assertFalse($sheet->getCell('F1')->getStyle()->getFont()->getItalic());
self::assertEquals(Font::UNDERLINE_SINGLE, $sheet->getCell('F1')->getStyle()->getFont()->getUnderline());
self::assertFalse($sheet->getCell('F2')->getStyle()->getFont()->getBold());
self::assertFalse($sheet->getCell('F2')->getStyle()->getFont()->getItalic());
self::assertEquals(Font::UNDERLINE_NONE, $sheet->getCell('F2')->getStyle()->getFont()->getUnderline());
self::assertTrue($sheet->getCell('F3')->getStyle()->getFont()->getBold());
self::assertTrue($sheet->getCell('F3')->getStyle()->getFont()->getItalic());
self::assertEquals(Font::UNDERLINE_NONE, $sheet->getCell('F3')->getStyle()->getFont()->getUnderline());
self::assertFalse($sheet->getCell('F4')->getStyle()->getFont()->getBold());
self::assertFalse($sheet->getCell('F4')->getStyle()->getFont()->getItalic());
self::assertEquals(Font::UNDERLINE_NONE, $sheet->getCell('F4')->getStyle()->getFont()->getUnderline());
self::assertEquals(Border::BORDER_THIN, $sheet->getCell('C10')->getStyle()->getBorders()->getTop()->getBorderStyle());
self::assertEquals(Border::BORDER_NONE, $sheet->getCell('C10')->getStyle()->getBorders()->getRight()->getBorderStyle());
self::assertEquals(Border::BORDER_NONE, $sheet->getCell('C10')->getStyle()->getBorders()->getBottom()->getBorderStyle());
self::assertEquals(Border::BORDER_NONE, $sheet->getCell('C10')->getStyle()->getBorders()->getLeft()->getBorderStyle());
self::assertEquals(Border::BORDER_NONE, $sheet->getCell('C12')->getStyle()->getBorders()->getTop()->getBorderStyle());
self::assertEquals(Border::BORDER_NONE, $sheet->getCell('C12')->getStyle()->getBorders()->getRight()->getBorderStyle());
self::assertEquals(Border::BORDER_THIN, $sheet->getCell('C12')->getStyle()->getBorders()->getBottom()->getBorderStyle());
self::assertEquals(Border::BORDER_NONE, $sheet->getCell('C12')->getStyle()->getBorders()->getLeft()->getBorderStyle());
self::assertEquals(Border::BORDER_NONE, $sheet->getCell('C14')->getStyle()->getBorders()->getTop()->getBorderStyle());
self::assertEquals(Border::BORDER_NONE, $sheet->getCell('C14')->getStyle()->getBorders()->getRight()->getBorderStyle());
self::assertEquals(Border::BORDER_NONE, $sheet->getCell('C14')->getStyle()->getBorders()->getBottom()->getBorderStyle());
self::assertEquals(Border::BORDER_THIN, $sheet->getCell('C14')->getStyle()->getBorders()->getLeft()->getBorderStyle());
self::assertEquals(Border::BORDER_NONE, $sheet->getCell('C16')->getStyle()->getBorders()->getTop()->getBorderStyle());
self::assertEquals(Border::BORDER_THIN, $sheet->getCell('C16')->getStyle()->getBorders()->getRight()->getBorderStyle());
self::assertEquals(Border::BORDER_NONE, $sheet->getCell('C16')->getStyle()->getBorders()->getBottom()->getBorderStyle());
self::assertEquals(Border::BORDER_NONE, $sheet->getCell('C16')->getStyle()->getBorders()->getLeft()->getBorderStyle());
self::assertEquals(Border::BORDER_THIN, $sheet->getCell('C18')->getStyle()->getBorders()->getTop()->getBorderStyle());
self::assertEquals(Border::BORDER_THIN, $sheet->getCell('C18')->getStyle()->getBorders()->getRight()->getBorderStyle());
self::assertEquals(Border::BORDER_THIN, $sheet->getCell('C18')->getStyle()->getBorders()->getBottom()->getBorderStyle());
self::assertEquals(Border::BORDER_THIN, $sheet->getCell('C18')->getStyle()->getBorders()->getLeft()->getBorderStyle());
}
public function testLoadXlsxSheet2Contents(): void
{
$reader = new Xlsx();
$spreadsheet = $reader->load(self::$testbook);
$sheet = $spreadsheet->getSheet(1);
self::assertEquals('Second', $sheet->getTitle());
self::assertSame('Hyperlink', $sheet->getCell('B2')->getValue());
$hyper = $sheet->getCell('B2')->getHyperlink();
self::assertSame('http://www.example.com/', $hyper->getUrl());
self::assertSame('Comment', $sheet->getCell('B3')->getValue());
$comment = $sheet->getComment('B3');
// Created as "threaded comment" with Excel 365, not quite as expected.
self::assertStringContainsString('This is a comment', (string) $comment);
}
public function testLoadXlsxSheet2Styles(): void
{
$reader = new Xlsx();
$spreadsheet = $reader->load(self::$testbook);
$sheet = $spreadsheet->getSheet(1);
self::assertEquals('Second', $sheet->getTitle());
//if (strpos(__FILE__, 'NonStd') !== false) {
// self::markTestIncomplete('Not yet ready');
//}
self::assertEquals('center', $sheet->getCell('A2')->getStyle()->getAlignment()->getHorizontal());
self::assertSame('inherit', $sheet->getCell('A2')->getStyle()->getProtection()->getLocked());
self::assertEquals('top', $sheet->getCell('A3')->getStyle()->getAlignment()->getVertical());
self::assertSame('unprotected', $sheet->getCell('A3')->getStyle()->getProtection()->getLocked());
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/Issue4375Test.php | tests/PhpSpreadsheetTests/Reader/Xlsx/Issue4375Test.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx as XlsxReader;
use PHPUnit\Framework\TestCase;
class Issue4375Test extends TestCase
{
private static string $file = 'tests/data/Reader/XLSX/issue.4375.small.xlsx';
public function testPreliminaries(): void
{
$file = 'zip://';
$file .= self::$file;
$file .= '#xl/worksheets/sheet1.xml';
$data = file_get_contents($file) ?: '';
$expected = '<ignoredErrors><ignoredError sqref="A2:B5 B1:F1" numberStoredAsText="1"/></ignoredErrors>';
self::assertStringContainsString($expected, $data);
}
public function testDataOnly(): void
{
$file = self::$file;
$reader = new XlsxReader();
$reader->setReadDataOnly(true);
$spreadsheet = $reader->load($file);
$sheet = $spreadsheet->getActiveSheet();
self::assertSame('0', $sheet->getCell('A2')->getValue());
self::assertFalse(
$sheet->getCell('A2')
->getIgnoredErrors()
->getNumberStoredAsText()
);
self::assertFalse($sheet->cellExists('A3'));
$spreadsheet->disconnectWorksheets();
}
public function testNormalRead(): void
{
$file = self::$file;
$reader = new XlsxReader();
$spreadsheet = $reader->load($file);
$sheet = $spreadsheet->getActiveSheet();
self::assertSame('0', $sheet->getCell('A2')->getValue());
self::assertTrue(
$sheet->getCell('A2')
->getIgnoredErrors()
->getNumberStoredAsText()
);
self::assertFalse($sheet->cellExists('A3'));
$spreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/NamespaceOpenpyxl35Test.php | tests/PhpSpreadsheetTests/Reader/Xlsx/NamespaceOpenpyxl35Test.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\Worksheet\Worksheet;
class NamespaceOpenpyxl35Test extends \PHPUnit\Framework\TestCase
{
private static string $testbook = 'tests/data/Reader/XLSX/namespaces.openpyxl35.xlsx';
public function testPreliminaries(): void
{
$file = 'zip://';
$file .= self::$testbook;
$file .= '#xl/workbook.xml';
$data = file_get_contents($file);
// confirm that file contains expected namespaced xml tag
if ($data === false) {
self::fail('Unable to read file');
} else {
self::assertStringContainsString('<s:workbook ', $data);
}
}
public function testInfo(): void
{
$reader = new Xlsx();
$workSheetInfo = $reader->listWorkSheetInfo(self::$testbook);
$info0 = $workSheetInfo[0];
self::assertEquals('Shofar 5781', $info0['worksheetName']);
self::assertEquals('D', $info0['lastColumnLetter']);
self::assertEquals(3, $info0['lastColumnIndex']);
self::assertEquals(30, $info0['totalRows']);
self::assertEquals(4, $info0['totalColumns']);
}
public function testSheetNames(): void
{
$reader = new Xlsx();
$worksheetNames = $reader->listWorksheetNames(self::$testbook);
self::assertEquals(['Shofar 5781', 'Shofar 5782', 'Shofar 5783'], $worksheetNames);
}
public function testActive(): void
{
$reader = new Xlsx();
$spreadsheet = $reader->load(self::$testbook);
$sheet = $spreadsheet->getActiveSheet();
self::assertSame('Shofar 5781', $sheet->getTitle());
self::assertSame('A2', $sheet->getFreezePane());
self::assertSame('A2', $sheet->getTopLeftCell());
self::assertSame('D2', $sheet->getSelectedCells());
$spreadsheet->disconnectWorksheets();
}
private static function getCellValue(Worksheet $sheet, string $cell): string
{
$result = $sheet->getCell($cell)->getValue();
if (is_scalar($result) || (is_object($result) && method_exists($result, '__toString'))) {
return (string) $result;
}
return '';
}
public function testLoadXlsx(): void
{
$reader = new Xlsx();
$spreadsheet = $reader->load(self::$testbook);
$sheet = $spreadsheet->getSheet(0);
self::assertEquals('Shofar 5781', $sheet->getTitle());
$expectedArray = [
'Shofar 5781' => [
'A1' => 'Weekday',
'B6' => 'August 13',
'A14' => 'Saturday',
'C14' => 'Elul 13',
'D30' => 'N/A',
'B30' => 'September 6',
],
'Shofar 5782' => [
'C1' => 'Jewish Date',
'B6' => 'September 1',
'A14' => 'Friday',
'C14' => 'Elul 13',
'D28' => '',
'B30' => 'September 25',
],
'Shofar 5783' => [
'B1' => 'Civil Date',
'B6' => 'August 22',
'A14' => 'Wednesday',
'C14' => 'Elul 13',
'D30' => 'N/A',
'B30' => 'September 15',
],
];
foreach ($expectedArray as $sheetName => $array1) {
$sheet = $spreadsheet->getSheetByNameOrThrow($sheetName);
foreach ($array1 as $key => $value) {
self::assertSame($value, self::getCellValue($sheet, $key), "error in sheet $sheetName cell $key");
}
}
$spreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/Issue3552Test.php | tests/PhpSpreadsheetTests/Reader/Xlsx/Issue3552Test.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Worksheet\Worksheet;
use PhpOffice\PhpSpreadsheetTests\Functional\AbstractFunctional;
class Issue3552Test extends AbstractFunctional
{
private static string $testbook = 'tests/data/Reader/XLSX/issue.3552.xlsx';
public function testRowBreaks(): void
{
$reader = new Xlsx();
$spreadsheet = $reader->load(self::$testbook);
$sheet = $spreadsheet->getActiveSheet();
self::assertSame(['A92', 'A184', 'A276', 'A368', 'A417', 'A511', 'A554'], array_keys($sheet->getRowBreaks()));
$sheet->insertNewRowBefore(397, 1);
$reloadedSpreadsheet = $this->writeAndReload($spreadsheet, 'Xlsx');
$spreadsheet->disconnectWorksheets();
$reloadedSheet = $reloadedSpreadsheet->getActiveSheet();
self::assertSame(['A92', 'A184', 'A276', 'A368', 'A418', 'A512', 'A555'], array_keys($reloadedSheet->getRowBreaks()));
$reloadedSpreadsheet->disconnectWorksheets();
}
public function testColumnBreaks(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->setBreak('Z1', Worksheet::BREAK_COLUMN);
$sheet->setBreak('H1', Worksheet::BREAK_COLUMN);
$sheet->setBreak('P1', Worksheet::BREAK_COLUMN);
self::assertSame(['H1', 'P1', 'Z1'], array_keys($sheet->getColumnBreaks()));
$sheet->insertNewColumnBefore('N', 2);
self::assertSame(['H1', 'R1', 'AB1'], array_keys($sheet->getColumnBreaks()));
$spreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/AbsolutePathTest.php | tests/PhpSpreadsheetTests/Reader/Xlsx/AbsolutePathTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx;
use PHPUnit\Framework\TestCase;
class AbsolutePathTest extends TestCase
{
public static function testPr1869(): void
{
$xlsxFile = 'tests/data/Reader/XLSX/pr1769e.xlsx';
$reader = new Xlsx();
$result = $reader->listWorksheetInfo($xlsxFile);
self::assertEquals(3, $result[0]['totalRows']);
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/Issue1482Test.php | tests/PhpSpreadsheetTests/Reader/Xlsx/Issue1482Test.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx;
class Issue1482Test extends \PHPUnit\Framework\TestCase
{
private static string $testbook = 'tests/data/Reader/XLSX/issue.1482.xlsx';
public function testPreliminaries(): void
{
$file = 'zip://';
$file .= self::$testbook;
$file .= '#xl/worksheets/sheet.xml';
$data = file_get_contents($file);
// confirm that file contains expected namespaced xml tag
if ($data === false) {
self::fail('Unable to read file');
} else {
self::assertStringContainsString('<x:drawing r:id="rId1" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships" />', $data);
}
}
public function testLoadXlsx(): void
{
$reader = new Xlsx();
$spreadsheet = $reader->load(self::$testbook);
$sheet = $spreadsheet->getSheet(0);
$expectedColWidths = [
0.95,
7.45,
0.6,
4.4,
5.91,
3.92,
7.71,
2.12,
2.56,
6.94,
9.6,
1.82,
3.01,
8.63,
10.37,
2.09,
];
$columnDimensions = $sheet->getColumnDimensions();
$actualColWidths = [];
foreach ($columnDimensions as $columnDimension) {
$actualColWidths[] = $columnDimension->getWidth();
}
self::assertSame($expectedColWidths, $actualColWidths);
$expectedRowHeights = [
14.0,
7.0,
14.0,
80.0,
234.0,
63.0,
13.0,
19.0,
18.0,
18.0,
18.0,
18.0,
18.0,
18.0,
18.0,
18.0,
];
$rowHeights = $sheet->getRowDimensions();
$actualRowHeights = [];
foreach ($rowHeights as $rowDimension) {
$actualRowHeights[] = $rowDimension->getRowHeight();
}
self::assertSame($expectedRowHeights, $actualRowHeights);
$expectedMergeCells = [
'B1:E1',
'F1:G1',
'J1:L1',
'M1:N1',
'B3:E3',
'F3:G3',
'B5:O5',
'A7:C7',
'D7:M7',
'A8:B8',
'C8:D8',
'E8:F8',
'G8:H8',
'I8:J8',
'L8:P8',
'A9:B9',
'C9:D9',
'E9:F9',
'G9:H9',
'I9:J9',
'L9:P9',
'A10:B10',
'C10:D10',
'E10:F10',
'G10:H10',
'I10:J10',
'L10:P10',
'A11:B11',
'C11:D11',
'E11:F11',
'G11:H11',
'I11:J11',
'L11:P11',
'A12:B12',
'C12:D12',
'E12:F12',
'G12:H12',
'I12:J12',
'L12:P12',
'A13:B13',
'C13:D13',
'E13:F13',
'G13:H13',
'I13:J13',
'L13:P13',
'A14:B14',
'C14:D14',
'E14:F14',
'G14:H14',
'I14:J14',
'L14:P14',
'A15:B15',
'C15:D15',
'E15:F15',
'G15:H15',
'I15:J15',
'L15:P15',
'A16:B16',
'C16:D16',
'E16:F16',
'G16:H16',
'I16:J16',
'L16:P16',
];
self::assertSame($expectedMergeCells, array_keys($sheet->getMergeCells()));
$drawingCollection = $sheet->getDrawingCollection();
self::assertCount(1, $drawingCollection);
$drawing = $drawingCollection[0];
if ($drawing === null) {
self::fail('Unexpected null instead of drawing');
} else {
self::assertSame('B5', $drawing->getCoordinates());
self::assertSame('', $drawing->getCoordinates2());
self::assertFalse($drawing->getResizeProportional());
self::assertSame(600, $drawing->getWidth());
self::assertSame(312, $drawing->getHeight());
}
// no name, no description, no type
$spreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/OddColumnReadFilter.php | tests/PhpSpreadsheetTests/Reader/Xlsx/OddColumnReadFilter.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\Reader\IReadFilter;
/**
* Show only cells from odd columns.
*/
class OddColumnReadFilter implements IReadFilter
{
public function readCell(string $columnAddress, int $row, string $worksheetName = ''): bool
{
return (\ord(\substr($columnAddress, -1, 1)) % 2) === 1;
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/CoverageGapsTest.php | tests/PhpSpreadsheetTests/Reader/Xlsx/CoverageGapsTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Style\Alignment;
use PhpOffice\PhpSpreadsheet\Style\Border;
use PhpOffice\PhpSpreadsheet\Style\Borders;
use PhpOffice\PhpSpreadsheet\Style\Protection;
use PhpOffice\PhpSpreadsheetTests\Functional\AbstractFunctional;
class CoverageGapsTest extends AbstractFunctional
{
public function testCoverageGaps(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet
->getStyle('A1')
->getBorders()
->setDiagonalDirection(Borders::DIAGONAL_BOTH)
->getDiagonal()
->setBorderStyle(Border::BORDER_DASHDOTDOT);
$sheet
->getStyle('A2')
->getProtection()
->setLocked(Protection::PROTECTION_PROTECTED);
$sheet
->getStyle('A3')
->getAlignment()
->setTextRotation(Alignment::TEXTROTATION_STACK_EXCEL);
$reloadedSpreadsheet = $this->writeAndReload($spreadsheet, 'Xlsx');
$spreadsheet->disconnectWorksheets();
$rsheet = $reloadedSpreadsheet->getActiveSheet();
self::assertSame(Borders::DIAGONAL_BOTH, $rsheet->getStyle('A1')->getBorders()->getDiagonalDirection());
self::assertSame(Border::BORDER_DASHDOTDOT, $rsheet->getStyle('A1')->getBorders()->getDiagonal()->getBorderStyle());
self::assertSame(Protection::PROTECTION_PROTECTED, $rsheet->getStyle('A2')->getProtection()->getLocked());
self::assertSame(Alignment::TEXTROTATION_STACK_PHPSPREADSHEET, $rsheet->getStyle('A3')->getAlignment()->getTextRotation());
$reloadedSpreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/Issue2488Test.php | tests/PhpSpreadsheetTests/Reader/Xlsx/Issue2488Test.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\IOFactory;
use PHPUnit\Framework\TestCase;
class Issue2488Test extends TestCase
{
private static string $testbook = 'tests/data/Reader/XLSX/issue.2488.xlsx';
public function testPreliminaries(): void
{
$file = 'zip://';
$file .= self::$testbook;
$file .= '#xl/worksheets/sheet1.xml';
$data = file_get_contents($file);
// confirm that file contains expected namespaced xml tag
if ($data === false) {
self::fail('Unable to read file');
} else {
self::assertStringContainsString('<c r="E1" t="n" />', $data);
self::assertStringContainsString('<c r="E2" t="s" />', $data);
self::assertStringContainsString('<c r="D3" t="b" />', $data);
}
}
public function testIssue2488(): void
{
// Cell explicitly typed as numeric but without value.
$filename = self::$testbook;
$reader = IOFactory::createReader('Xlsx');
$spreadsheet = $reader->load($filename);
$sheet = $spreadsheet->getActiveSheet();
// E1 and D3 are numeric/boolean without value.
// So is E2, but I don't see a practical difference
// between null string and null in that case.
$expected = [
['1', '2', '3', '0', null, '-1', '-2', '-3'],
['a', 'b', 'c', 'xxx', '', 'd', 'e', 'f'],
['FALSE', 'FALSE', 'FALSE', null, 'TRUE', 'TRUE', 'TRUE', 'TRUE'],
];
self::assertSame($expected, $sheet->toArray());
$expected = [
['1', '2', '3', '0', '', '-1', '-2', '-3'],
['a', 'b', 'c', 'xxx', '', 'd', 'e', 'f'],
['FALSE', 'FALSE', 'FALSE', '', 'TRUE', 'TRUE', 'TRUE', 'TRUE'],
];
self::assertSame($expected, $sheet->toArray(''));
$expected = [
[1, 2, 3, 0, null, -1, -2, -3],
['a', 'b', 'c', 'xxx', '', 'd', 'e', 'f'],
[false, false, false, null, true, true, true, true],
];
self::assertSame($expected, $sheet->toArray(null, true, false));
$spreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/Issue4049Test.php | tests/PhpSpreadsheetTests/Reader/Xlsx/Issue4049Test.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx;
use PhpOffice\PhpSpreadsheetTests\Functional\AbstractFunctional;
class Issue4049Test extends AbstractFunctional
{
public function testColorScale(): void
{
$xlsxFile = 'tests/data/Reader/XLSX/issue.4049.xlsx';
$reader = new Xlsx();
$oldSpreadsheet = $reader->load($xlsxFile);
$spreadsheet = $this->writeAndReload($oldSpreadsheet, 'Xlsx');
$oldSpreadsheet->disconnectWorksheets();
$sheet = $spreadsheet->getActiveSheet();
$conditionals = $sheet->getConditionalStylesCollection();
self::assertCount(1, $conditionals);
self::assertSame('E9:E14', array_keys($conditionals)[0]);
$cond1 = $conditionals['E9:E14'];
self::assertCount(1, $cond1);
self::assertSame('colorScale', $cond1[0]->getConditionType());
$colorScale = $cond1[0]->getColorScale();
self::assertNotNull($colorScale);
$min = $colorScale->getMinimumConditionalFormatValueObject();
self::assertNotNull($min);
self::assertSame('formula', $min->getType());
self::assertSame('25', $min->getCellFormula());
self::assertNull($colorScale->getMidpointConditionalFormatValueObject());
$max = $colorScale->getMaximumConditionalFormatValueObject();
self::assertNotNull($max);
self::assertSame('max', $max->getType());
self::assertNull($max->getValue());
$spreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/Issue2778Test.php | tests/PhpSpreadsheetTests/Reader/Xlsx/Issue2778Test.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx;
use PHPUnit\Framework\TestCase;
class Issue2778Test extends TestCase
{
private static string $testbook = 'tests/data/Reader/XLSX/issue.2778.xlsx';
public function testIssue2778(): void
{
$filename = self::$testbook;
$reader = new Xlsx();
$spreadsheet = $reader->load($filename);
$sheet = $spreadsheet->getActiveSheet();
self::assertSame(6, $sheet->getCell('D1')->getCalculatedValue());
self::assertSame(63, $sheet->getCell('F1')->getCalculatedValue());
self::assertSame(10, $sheet->getCell('C10')->getCalculatedValue());
$spreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/DefaultFillTest.php | tests/PhpSpreadsheetTests/Reader/Xlsx/DefaultFillTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\IOFactory;
use PHPUnit\Framework\TestCase;
class DefaultFillTest extends TestCase
{
public function testDefaultFill(): void
{
// default fill pattern doesn't specify filltype
$filename = 'tests/data/Reader/XLSX/pr1769g.py.xlsx';
$file = 'zip://';
$file .= $filename;
$file .= '#xl/styles.xml';
$data = file_get_contents($file);
// confirm that file contains expected empty xml tag
if ($data === false) {
self::fail('Unable to read file');
} else {
self::assertStringContainsString('<patternFill/>', $data);
}
$reader = IOFactory::createReader('Xlsx');
$spreadsheet = $reader->load($filename);
$sheet = $spreadsheet->getActiveSheet();
self::assertSame('none', $sheet->getCell('A1')->getStyle()->getFill()->getFillType());
self::assertSame('none', $sheet->getCell('D4')->getStyle()->getFill()->getFillType());
self::assertSame('none', $sheet->getCell('J16')->getStyle()->getFill()->getFillType());
self::assertSame('solid', $sheet->getCell('C2')->getStyle()->getFill()->getFillType());
}
public function testDefaultConditionalFill(): void
{
// default fill pattern for a conditional style where the filltype is not defined
$filename = 'tests/data/Reader/XLSX/pr2050cf-fill.xlsx';
$reader = IOFactory::createReader('Xlsx');
$spreadsheet = $reader->load($filename);
$style = $spreadsheet->getActiveSheet()->getConditionalStyles('A1')[0]->getStyle();
self::assertSame('', $style->getFill()->getFillType());
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/VmlTest.php | tests/PhpSpreadsheetTests/Reader/Xlsx/VmlTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx as XlsxReader;
use PhpOffice\PhpSpreadsheet\Shared\File;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Writer\Xlsx as XlsxWriter;
use PHPUnit\Framework\TestCase;
class VmlTest extends TestCase
{
private string $outfile1 = '';
private string $outfile2 = '';
protected function tearDown(): void
{
if ($this->outfile1 !== '') {
unlink($this->outfile1);
$this->outfile1 = '';
}
if ($this->outfile2 !== '') {
unlink($this->outfile2);
$this->outfile2 = '';
}
}
public function testAddComments(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->getComment('A1')->getText()->createText('top left cell');
$writer = new XlsxWriter($spreadsheet);
$writer->setUseDiskCaching(true, sys_get_temp_dir());
$this->outfile1 = File::temporaryFileName();
$writer->save($this->outfile1);
$spreadsheet->disconnectWorksheets();
$reader = new XlsxReader();
$file = 'zip://' . $this->outfile1 . '#xl/worksheets/sheet1.xml';
$sheetContents = file_get_contents($file) ?: '';
self::assertStringContainsString('<legacyDrawing ', $sheetContents);
$file = 'zip://' . $this->outfile1 . '#xl/drawings/vmlDrawing1.vml';
$vmlContents = file_get_contents($file) ?: '';
$count = substr_count($vmlContents, '<v:shape ');
self::assertSame(1, $count);
$count = substr_count($vmlContents, '<x:ClientData ObjectType="Note">');
self::assertSame(1, $count);
$spreadsheet2 = $reader->load($this->outfile1);
$sheet2 = $spreadsheet2->getActiveSheet();
self::assertSame('top left cell', $sheet2->getComment('A1')->getText()->getPlainText());
self::assertNull($spreadsheet2->getLegacyDrawing($sheet2));
$sheet2->getComment('H1')->getText()->createText('Show me');
$sheet2->getComment('H2')->getText()->createText('Hide me');
$sheet2->getComment('H1')->setVisible(true);
$writer = new XlsxWriter($spreadsheet2);
$this->outfile2 = File::temporaryFileName();
$writer->save($this->outfile2);
$spreadsheet2->disconnectWorksheets();
$file = 'zip://' . $this->outfile2 . '#xl/worksheets/sheet1.xml';
$sheetContents = file_get_contents($file) ?: '';
self::assertStringContainsString('<legacyDrawing ', $sheetContents);
$file = 'zip://' . $this->outfile2 . '#xl/drawings/vmlDrawing1.vml';
$vmlContents = file_get_contents($file) ?: '';
$count = substr_count($vmlContents, '<v:shape ');
self::assertSame(3, $count);
$count = substr_count($vmlContents, '<x:ClientData ObjectType="Note">');
self::assertSame(3, $count);
$reader = new XlsxReader();
$spreadsheet3 = $reader->load($this->outfile2);
$sheet3 = $spreadsheet3->getActiveSheet();
self::assertSame('top left cell', $sheet3->getComment('A1')->getText()->getPlainText());
self::assertSame('Show me', $sheet3->getComment('H1')->getText()->getPlainText());
self::assertSame('Hide me', $sheet3->getComment('H2')->getText()->getPlainText());
self::assertNull($spreadsheet3->getLegacyDrawing($sheet3));
self::assertTrue($sheet3->getComment('H1')->getVisible());
self::assertFalse($sheet3->getComment('H2')->getVisible());
$spreadsheet3->disconnectWorksheets();
}
public function testDeleteNullLegacy(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->getComment('A1')->getText()->createText('top left cell');
self::assertNull($spreadsheet->getLegacyDrawing($sheet));
$spreadsheet->deleteLegacyDrawing($sheet);
$writer = new XlsxWriter($spreadsheet);
$this->outfile1 = File::temporaryFileName();
$writer->save($this->outfile1);
$spreadsheet->disconnectWorksheets();
$reader = new XlsxReader();
$file = 'zip://' . $this->outfile1 . '#xl/worksheets/sheet1.xml';
$sheetContents = file_get_contents($file) ?: '';
self::assertStringContainsString('<legacyDrawing ', $sheetContents);
$file = 'zip://' . $this->outfile1 . '#xl/drawings/vmlDrawing1.vml';
$vmlContents = file_get_contents($file) ?: '';
$count = substr_count($vmlContents, '<v:shape ');
self::assertSame(1, $count);
$count = substr_count($vmlContents, '<x:ClientData ObjectType="Note">');
self::assertSame(1, $count);
$spreadsheet2 = $reader->load($this->outfile1);
$sheet2 = $spreadsheet2->getActiveSheet();
self::assertSame('top left cell', $sheet2->getComment('A1')->getText()->getPlainText());
$spreadsheet2->disconnectWorksheets();
}
public function testAddCommentDeleteFormControls(): void
{
$infile = 'samples/Reader2/sampleData/formscomments.xlsx';
$reader = new XlsxReader();
$reader->setLoadSheetsOnly('FormsComments');
$spreadsheet = $reader->load($infile);
$sheet = $spreadsheet->getActiveSheet();
self::assertSame('row1', $sheet->getCell('H1')->getValue());
self::assertStringContainsString('Hello', $sheet->getComment('F1')->getText()->getPlainText());
$vmlContents = $spreadsheet->getLegacyDrawing($sheet) ?? '';
$count = substr_count($vmlContents, '<v:shape ');
self::assertSame(4, $count);
$count = substr_count($vmlContents, '<x:ClientData ');
self::assertSame(4, $count);
$count = substr_count($vmlContents, '<x:ClientData ObjectType="Note"');
self::assertSame(1, $count);
$spreadsheet->deleteLegacyDrawing($sheet);
$sheet->getComment('F2')->getText()->createText('Goodbye');
$writer = new XlsxWriter($spreadsheet);
$this->outfile1 = File::temporaryFileName();
$writer->save($this->outfile1);
$spreadsheet->disconnectWorksheets();
$reader2 = new XlsxReader();
$spreadsheet2 = $reader2->load($this->outfile1);
$sheet2 = $spreadsheet2->getActiveSheet();
self::assertNull($spreadsheet2->getLegacyDrawing($sheet2));
self::assertSame('row1', $sheet2->getCell('H1')->getValue());
self::assertStringContainsString('Hello', $sheet2->getComment('F1')->getText()->getPlainText());
self::assertStringContainsString('Goodbye', $sheet2->getComment('F2')->getText()->getPlainText());
$spreadsheet2->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/RibbonTest.php | tests/PhpSpreadsheetTests/Reader/Xlsx/RibbonTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\IOFactory;
use PhpOffice\PhpSpreadsheetTests\Functional\AbstractFunctional;
class RibbonTest extends AbstractFunctional
{
/**
* Test read/rewrite spreadsheet with ribbon data.
*/
public function testRibbon(): void
{
// The following file is downloaded, with the author's
// permission, from:
// https://www.rondebruin.nl/win/s2/win003.htm
// It is renamed, including changing its extension to zip.
$filename = 'tests/data/Reader/XLSX/ribbon.donotopen.zip';
$reader = IOFactory::createReader('Xlsx');
$spreadsheet = $reader->load($filename);
self::assertTrue($spreadsheet->hasRibbon());
$target = $spreadsheet->getRibbonXMLData('target');
self::assertSame('customUI/customUI.xml', $target);
$data = $spreadsheet->getRibbonXMLData('data');
self::assertIsString($data);
self::assertSame(1522, strlen($data));
$vbaCode = (string) $spreadsheet->getMacrosCode();
self::assertSame(13312, strlen($vbaCode));
self::assertNull($spreadsheet->getRibbonBinObjects());
foreach (['names', 'data', 'xxxxx'] as $type) {
self::assertNull($spreadsheet->getRibbonBinObjects($type), "Expecting null when type is $type");
}
self::assertEmpty($spreadsheet->getRibbonBinObjects('types'));
$reloadedSpreadsheet = $this->writeAndReload($spreadsheet, 'Xlsx');
$spreadsheet->disconnectWorksheets();
self::assertTrue($reloadedSpreadsheet->hasRibbon());
$ribbonData = $reloadedSpreadsheet->getRibbonXmlData();
self::assertIsArray($ribbonData);
self::assertSame($target, $ribbonData['target'] ?? '');
self::assertSame($data, $ribbonData['data'] ?? '');
self::assertSame($vbaCode, $reloadedSpreadsheet->getMacrosCode());
self::assertNull($reloadedSpreadsheet->getRibbonBinObjects());
$reloadedSpreadsheet->disconnectWorksheets();
}
/**
* Same as above but discard macros.
*/
public function testDiscardMacros(): void
{
$filename = 'tests/data/Reader/XLSX/ribbon.donotopen.zip';
$reader = IOFactory::createReader('Xlsx');
$spreadsheet = $reader->load($filename);
self::assertTrue($spreadsheet->hasRibbon());
$target = $spreadsheet->getRibbonXMLData('target');
self::assertSame('customUI/customUI.xml', $target);
$data = $spreadsheet->getRibbonXMLData('data');
self::assertIsString($data);
self::assertSame(1522, strlen($data));
$vbaCode = (string) $spreadsheet->getMacrosCode();
self::assertSame(13312, strlen($vbaCode));
$spreadsheet->discardMacros();
$reloadedSpreadsheet = $this->writeAndReload($spreadsheet, 'Xlsx');
$spreadsheet->disconnectWorksheets();
self::assertTrue($reloadedSpreadsheet->hasRibbon());
$ribbonData = $reloadedSpreadsheet->getRibbonXmlData();
self::assertIsArray($ribbonData);
self::assertSame($target, $ribbonData['target'] ?? '');
self::assertSame($data, $ribbonData['data'] ?? '');
self::assertNull($reloadedSpreadsheet->getMacrosCode());
self::assertNull($reloadedSpreadsheet->getRibbonBinObjects());
$reloadedSpreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/Issue4629Test.php | tests/PhpSpreadsheetTests/Reader/Xlsx/Issue4629Test.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx as XlsxReader;
use PHPUnit\Framework\TestCase;
class Issue4629Test extends TestCase
{
public function testExternalAndInternalCondionalStyles(): void
{
$infile = 'tests/data/Reader/XLSX/issue.4629.xlsx';
$reader = new XlsxReader();
$spreadsheet = $reader->load($infile);
$sheet = $spreadsheet->getSheetByNameOrThrow('top');
$conditionals = $sheet->getStyle('A1:A20')->getConditionalStyles();
self::assertCount(3, $conditionals);
$conditional = $conditionals[0];
self::assertSame('expression', $conditional->getConditionType());
self::assertFalse($conditional->getStopIfTrue());
self::assertSame(['$A1<>$B1'], $conditional->getConditions());
self::assertSame(2, $conditional->getPriority());
$conditional = $conditionals[1];
self::assertSame('expression', $conditional->getConditionType());
self::assertFalse($conditional->getStopIfTrue());
self::assertSame(['AND($A1="cheese", $C1="yogurt")'], $conditional->getConditions());
self::assertSame(3, $conditional->getPriority());
$conditional = $conditionals[2]; // defined within <ext>
self::assertSame('expression', $conditional->getConditionType());
self::assertTrue($conditional->getStopIfTrue());
self::assertSame(['A1<>bottom!A1'], $conditional->getConditions());
self::assertSame(1, $conditional->getPriority());
self::assertSame('FF9C5700', $conditional->getStyle()->getFont()->getColor()->getArgb());
$spreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/SheetProtectionTest.php | tests/PhpSpreadsheetTests/Reader/Xlsx/SheetProtectionTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx;
use PhpOffice\PhpSpreadsheetTests\Functional\AbstractFunctional;
class SheetProtectionTest extends AbstractFunctional
{
private const FILENAME = 'tests/data/Reader/XLSX/sheetprotect.xlsx';
public function testSheetProtection(): void
{
$reader = new Xlsx();
$originalSpreadsheet = $reader->load(self::FILENAME);
$spreadsheet = $this->writeAndReload($originalSpreadsheet, 'Xlsx');
$originalSpreadsheet->disconnectWorksheets();
$assertions = $this->pageSetupAssertions();
foreach ($spreadsheet->getAllSheets() as $worksheet) {
if (!array_key_exists($worksheet->getTitle(), $assertions)) {
continue;
}
$sheetAssertions = $assertions[$worksheet->getTitle()];
foreach ($sheetAssertions as $test => $expectedResult) {
$testMethodName = 'get' . ucfirst($test);
$actualResult = $worksheet->getProtection()->$testMethodName();
self::assertSame(
$expectedResult,
$actualResult,
"Failed assertion for Worksheet '{$worksheet->getTitle()}' {$test}"
);
}
}
$protection0 = $spreadsheet->getSheet(0)->getProtection();
self::assertTrue($protection0->verify('password'));
self::assertFalse($protection0->verify('passwordx'));
$protection1 = $spreadsheet->getSheet(1)->getProtection();
self::assertTrue($protection1->verify('anything'), 'no password so anything works');
$spreadsheet->disconnectWorksheets();
}
/** @return array<array{sheet: ?bool, autoFilter: ?bool, formatCells: ?bool, formatColumns: ?bool, formatRows: ?bool, insertColumns: ?bool, insertHyperlinks: ?bool, insertRows: ?bool, deleteColumns: ?bool, deleteRows: ?bool, objects: ?bool, pivotTables: ?bool, scenarios: ?bool, selectLockedCells: ?bool, selectUnlockedCells: ?bool, sort: ?bool, algorithm: string, spinCount: int}> */
private function pageSetupAssertions(): array
{
return [
'Sheet1' => [
'sheet' => true,
'autoFilter' => null,
'formatCells' => null,
'formatColumns' => null,
'formatRows' => false,
'insertColumns' => null,
'insertHyperlinks' => null,
'insertRows' => null,
'deleteColumns' => false,
'deleteRows' => null,
'objects' => true,
'pivotTables' => null,
'scenarios' => null,
'selectLockedCells' => null,
'selectUnlockedCells' => null,
'sort' => false,
'algorithm' => 'SHA-512',
'spinCount' => 100000,
],
'Sheet2' => [
'sheet' => true,
'autoFilter' => null,
'formatCells' => false,
'formatColumns' => false,
'formatRows' => false,
'insertColumns' => false,
'insertHyperlinks' => null,
'insertRows' => null,
'deleteColumns' => null,
'deleteRows' => null,
'objects' => true,
'pivotTables' => null,
'scenarios' => true,
'selectLockedCells' => null,
'selectUnlockedCells' => null,
'sort' => null,
'algorithm' => '',
'spinCount' => 10000,
],
'Sheet3' => [
'sheet' => true,
'autoFilter' => null,
'formatCells' => null,
'formatColumns' => null,
'formatRows' => null,
'insertColumns' => null,
'insertHyperlinks' => false,
'insertRows' => null,
'deleteColumns' => null,
'deleteRows' => null,
'objects' => null,
'pivotTables' => null,
'scenarios' => true,
'selectLockedCells' => true,
'selectUnlockedCells' => true,
'sort' => null,
'algorithm' => '',
'spinCount' => 10000,
],
'Sheet4' => [
'sheet' => null,
'autoFilter' => null,
'formatCells' => null,
'formatColumns' => null,
'formatRows' => null,
'insertColumns' => null,
'insertHyperlinks' => null,
'insertRows' => null,
'deleteColumns' => null,
'deleteRows' => null,
'objects' => null,
'pivotTables' => null,
'scenarios' => null,
'selectLockedCells' => null,
'selectUnlockedCells' => null,
'sort' => null,
'algorithm' => '',
'spinCount' => 10000,
],
];
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/ReplaceBuiltinNumberFormatTest.php | tests/PhpSpreadsheetTests/Reader/Xlsx/ReplaceBuiltinNumberFormatTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Style\NumberFormat;
use PhpOffice\PhpSpreadsheetTests\Functional\AbstractFunctional;
class ReplaceBuiltinNumberFormatTest extends AbstractFunctional
{
private ?Spreadsheet $spreadsheet = null;
private ?Spreadsheet $reloadedSpreadsheet = null;
protected function tearDown(): void
{
if ($this->spreadsheet !== null) {
$this->spreadsheet->disconnectWorksheets();
$this->spreadsheet = null;
}
if ($this->reloadedSpreadsheet !== null) {
$this->reloadedSpreadsheet->disconnectWorksheets();
$this->reloadedSpreadsheet = null;
}
}
public function testReplaceBuiltinNumberFormat(): void
{
$spreadsheet = $this->spreadsheet = new Spreadsheet();
$sheet = $this->spreadsheet->getActiveSheet();
$sheet->fromArray([45486, 1023, 45487, 45488, 45489]);
$sheet->getStyle('A1')->getNumberFormat()
->setBuiltInFormatCode(NumberFormat::SHORT_DATE_INDEX);
$sheet->getStyle('B1')->getNumberFormat()
->setFormatCode('#,##0.00');
$sheet->getStyle('C1')->getNumberFormat()
->setBuiltInFormatCode(NumberFormat::SHORT_DATE_INDEX);
$sheet->getStyle('D1')->getNumberFormat()
->setFormatCode('dd-MMM-yyyy');
$sheet->getStyle('E1')->getNumberFormat()
->setBuiltInFormatCode(16);
$values = $sheet->toArray();
$expected = [[
'7/13/2024', // builtin style 14
'1,023.00', // #,##0.00
'7/14/2024', // builtin style 14
'15-Jul-2024', // dd-MMM-yyyy
'16-Jul', // builtin style 16
]];
self::assertSame($expected, $values);
$this->reloadedSpreadsheet = $this->writeAndReload($spreadsheet, 'Xlsx');
$this->reloadedSpreadsheet->replaceBuiltinNumberFormat(
NumberFormat::SHORT_DATE_INDEX,
'yyyy-mm-dd'
);
$rsheet = $this->reloadedSpreadsheet->getActiveSheet();
$newValues = $rsheet->toArray();
$newExpected = [[
'2024-07-13', // yyyy-mm-dd changed from builtin style 14
'1,023.00', // unchanged #,##0.00
'2024-07-14', // yyyy-mm-dd changed from builtin style 14
'15-Jul-2024', // unchanged dd-MMM-yyyy
'16-Jul', // unchanged builtin style 16
]];
self::assertSame($newExpected, $newValues);
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/HiddenWorksheetTest.php | tests/PhpSpreadsheetTests/Reader/Xlsx/HiddenWorksheetTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\Worksheet\Worksheet;
use PHPUnit\Framework\TestCase;
class HiddenWorksheetTest extends TestCase
{
public function testPageSetup(): void
{
$filename = 'tests/data/Reader/XLSX/HiddenSheet.xlsx';
$reader = new Xlsx();
$spreadsheet = $reader->load($filename);
$assertions = $this->worksheetAssertions();
foreach ($spreadsheet->getAllSheets() as $worksheet) {
if (!array_key_exists($worksheet->getTitle(), $assertions)) {
continue;
}
$sheetAssertions = $assertions[$worksheet->getTitle()];
foreach ($sheetAssertions as $test => $expectedResult) {
$actualResult = $worksheet->getSheetState();
self::assertSame(
$expectedResult,
$actualResult,
"Failed asserting sheet state {$expectedResult} for Worksheet '{$worksheet->getTitle()}' {$test}"
);
}
}
$spreadsheet->disconnectWorksheets();
}
/** @return array<array{sheetState: string}> */
private function worksheetAssertions(): array
{
return [
'Sheet1' => [
'sheetState' => Worksheet::SHEETSTATE_VISIBLE,
],
'Sheet2' => [
'sheetState' => Worksheet::SHEETSTATE_HIDDEN,
],
];
}
public function testListWorksheetInfo(): void
{
$filename = 'tests/data/Reader/XLSX/visibility.xlsx';
$reader = new Xlsx();
$expected = [
[
'worksheetName' => 'Sheet1',
'lastColumnLetter' => 'A',
'lastColumnIndex' => 0,
'totalRows' => 1,
'totalColumns' => 1,
'sheetState' => 'visible',
],
[
'worksheetName' => 'Sheet2',
'lastColumnLetter' => 'A',
'lastColumnIndex' => 0,
'totalRows' => 1,
'totalColumns' => 1,
'sheetState' => 'hidden',
],
[
'worksheetName' => 'Sheet3',
'lastColumnLetter' => 'A',
'lastColumnIndex' => 0,
'totalRows' => 1,
'totalColumns' => 1,
'sheetState' => 'visible',
],
[
'worksheetName' => 'Sheet4',
'lastColumnLetter' => 'B',
'lastColumnIndex' => 1,
'totalRows' => 1,
'totalColumns' => 2,
'sheetState' => 'veryHidden',
],
];
self::assertSame($expected, $reader->listWorksheetInfo($filename));
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/Xlsx2Test.php | tests/PhpSpreadsheetTests/Reader/Xlsx/Xlsx2Test.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\IOFactory;
use PhpOffice\PhpSpreadsheet\Shared\File;
use PhpOffice\PhpSpreadsheet\Style\Color;
use PhpOffice\PhpSpreadsheet\Style\Conditional;
use PhpOffice\PhpSpreadsheet\Style\Fill;
use PHPUnit\Framework\TestCase;
class Xlsx2Test extends TestCase
{
public function testLoadXlsxConditionalFormatting2(): void
{
// Make sure Conditionals are read correctly from existing file
$filename = 'tests/data/Reader/XLSX/conditionalFormatting2Test.xlsx';
$reader = IOFactory::createReader('Xlsx');
$spreadsheet = $reader->load($filename);
$worksheet = $spreadsheet->getActiveSheet();
$conditionalStyle = $worksheet->getConditionalStyles('A2:A8');
self::assertNotEmpty($conditionalStyle);
$conditionalRule = $conditionalStyle[0];
$conditions = $conditionalRule->getConditions();
self::assertNotEmpty($conditions);
self::assertEquals(Conditional::CONDITION_NOTCONTAINSBLANKS, $conditionalRule->getConditionType());
self::assertEquals('LEN(TRIM(A2))>0', $conditions[0]);
$conditionalStyle = $worksheet->getConditionalStyles('B2:B8');
self::assertNotEmpty($conditionalStyle);
$conditionalRule = $conditionalStyle[0];
$conditions = $conditionalRule->getConditions();
self::assertNotEmpty($conditions);
self::assertEquals(Conditional::CONDITION_CONTAINSBLANKS, $conditionalRule->getConditionType());
self::assertEquals('LEN(TRIM(B2))=0', $conditions[0]);
$conditionalStyle = $worksheet->getConditionalStyles('C2:C8');
self::assertNotEmpty($conditionalStyle);
$conditionalRule = $conditionalStyle[0];
$conditions = $conditionalRule->getConditions();
self::assertNotEmpty($conditions);
self::assertEquals(Conditional::CONDITION_CELLIS, $conditionalRule->getConditionType());
self::assertEquals(Conditional::OPERATOR_GREATERTHAN, $conditionalRule->getOperatorType());
self::assertEquals('5', $conditions[0]);
}
public function testReloadXlsxConditionalFormatting2(): void
{
// Make sure conditionals from existing file are maintained across save
$filename = 'tests/data/Reader/XLSX/conditionalFormatting2Test.xlsx';
$outfile = File::temporaryFilename();
$reader = IOFactory::createReader('Xlsx');
$spreadshee1 = $reader->load($filename);
$writer = IOFactory::createWriter($spreadshee1, 'Xlsx');
$writer->save($outfile);
$spreadsheet = $reader->load($outfile);
unlink($outfile);
$worksheet = $spreadsheet->getActiveSheet();
$conditionalStyle = $worksheet->getConditionalStyles('A2:A8');
self::assertNotEmpty($conditionalStyle);
$conditionalRule = $conditionalStyle[0];
$conditions = $conditionalRule->getConditions();
self::assertNotEmpty($conditions);
self::assertEquals(Conditional::CONDITION_NOTCONTAINSBLANKS, $conditionalRule->getConditionType());
self::assertEquals('LEN(TRIM(A2))>0', $conditions[0]);
$conditionalStyle = $worksheet->getConditionalStyles('B2:B8');
self::assertNotEmpty($conditionalStyle);
$conditionalRule = $conditionalStyle[0];
$conditions = $conditionalRule->getConditions();
self::assertNotEmpty($conditions);
self::assertEquals(Conditional::CONDITION_CONTAINSBLANKS, $conditionalRule->getConditionType());
self::assertEquals('LEN(TRIM(B2))=0', $conditions[0]);
$conditionalStyle = $worksheet->getConditionalStyles('C2:C8');
self::assertNotEmpty($conditionalStyle);
$conditionalRule = $conditionalStyle[0];
$conditions = $conditionalRule->getConditions();
self::assertNotEmpty($conditions);
self::assertEquals(Conditional::CONDITION_CELLIS, $conditionalRule->getConditionType());
self::assertEquals(Conditional::OPERATOR_GREATERTHAN, $conditionalRule->getOperatorType());
self::assertEquals('5', $conditions[0]);
}
public function testNewXlsxConditionalFormatting2(): void
{
// Make sure blanks/non-blanks added by PhpSpreadsheet are handled correctly
$outfile = File::temporaryFilename();
$spreadshee1 = new \PhpOffice\PhpSpreadsheet\Spreadsheet();
$sheet = $spreadshee1->getActiveSheet();
$sheet->setCellValue('A2', 'a2');
$sheet->setCellValue('A4', 'a4');
$sheet->setCellValue('A6', 'a6');
$cond1 = new Conditional();
$cond1->setConditionType(Conditional::CONDITION_CONTAINSBLANKS);
$cond1->getStyle()->getFill()->setFillType(Fill::FILL_SOLID);
$cond1->getStyle()->getFill()->getStartColor()->setARGB(Color::COLOR_RED);
$cond = [$cond1];
$sheet->getStyle('A1:A6')->setConditionalStyles($cond);
$writer = IOFactory::createWriter($spreadshee1, 'Xlsx');
$writer->save($outfile);
$reader = IOFactory::createReader('Xlsx');
$spreadsheet = $reader->load($outfile);
unlink($outfile);
$worksheet = $spreadsheet->getActiveSheet();
$conditionalStyle = $worksheet->getConditionalStyles('A1:A6');
self::assertNotEmpty($conditionalStyle);
$conditionalRule = $conditionalStyle[0];
$conditions = $conditionalRule->getConditions();
self::assertNotEmpty($conditions);
self::assertEquals(Conditional::CONDITION_CONTAINSBLANKS, $conditionalRule->getConditionType());
self::assertEquals('LEN(TRIM(A1))=0', $conditions[0]);
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/Issue4477Test.php | tests/PhpSpreadsheetTests/Reader/Xlsx/Issue4477Test.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx as XlsxReader;
use PhpOffice\PhpSpreadsheet\Shared\File;
use PhpOffice\PhpSpreadsheet\Writer\Xlsx as XlsxWriter;
use PHPUnit\Framework\TestCase;
use ZipArchive;
class Issue4477Test extends TestCase
{
private string $tempfile = '';
protected function tearDown(): void
{
if ($this->tempfile !== '') {
unlink($this->tempfile);
$this->tempfile = '';
}
}
public function testDataonlyNoPrinter(): void
{
// Need to ignore printer settings when Read Dataonly
$infile = 'tests/data/Reader/XLSX/issue.4477.disclaimer.xlsx';
$zip = new ZipArchive();
if ($zip->open($infile) !== true) {
self::fail("failed to open $infile");
}
$num = $zip->numFiles;
$foundPrinter = $foundWorksheet = false;
for ($i = 0; $i < $num; ++$i) {
$filename = (string) $zip->getNameIndex($i);
if (str_contains($filename, 'printer')) {
$foundPrinter = true;
} elseif ($filename === 'xl/worksheets/sheet1.xml') {
$foundWorksheet = true;
}
}
$zip->close();
self::assertTrue($foundPrinter);
self::assertTrue($foundWorksheet);
$reader = new XlsxReader();
$reader->setReadDataOnly(true);
$spreadsheet = $reader->load($infile);
$writer = new XlsxWriter($spreadsheet);
$this->tempfile = File::temporaryFileName();
$writer->save($this->tempfile);
$spreadsheet->disconnectWorksheets();
$zip = new ZipArchive();
if ($zip->open($this->tempfile) !== true) {
self::fail("failed to open {$infile}");
}
$num = $zip->numFiles;
$foundPrinter = $foundWorksheet = false;
for ($i = 0; $i < $num; ++$i) {
$filename = (string) $zip->getNameIndex($i);
if (str_contains($filename, 'printer')) {
$foundPrinter = true;
} elseif ($filename === 'xl/worksheets/sheet1.xml') {
$foundWorksheet = true;
}
}
$zip->close();
self::assertFalse($foundPrinter);
self::assertTrue($foundWorksheet);
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/NamespacePurlTest.php | tests/PhpSpreadsheetTests/Reader/Xlsx/NamespacePurlTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx;
class NamespacePurlTest extends \PHPUnit\Framework\TestCase
{
private static string $testbook = 'tests/data/Reader/XLSX/namespacepurl.xlsx';
public function testPreliminaries(): void
{
$file = 'zip://';
$file .= self::$testbook;
$file .= '#xl/workbook.xml';
$data = file_get_contents($file);
// confirm that file contains expected namespaced xml tag
if ($data === false) {
self::fail('Unable to read file');
} else {
self::assertStringContainsString('http://purl.oclc.org/ooxml/', $data);
}
}
public function testPurlNamespace(): void
{
$filename = self::$testbook;
$reader = new Xlsx();
$actual = $reader->canRead($filename);
self::assertTrue($actual);
$sheets = $reader->listWorksheetNames($filename);
self::assertEquals(['ml_out'], $sheets);
$actual = $reader->listWorksheetInfo($filename);
$expected = [
[
'worksheetName' => 'ml_out',
'lastColumnLetter' => 'R',
'lastColumnIndex' => 17,
'totalRows' => 76,
'totalColumns' => 18,
'sheetState' => 'visible',
],
];
self::assertEquals($expected, $actual);
}
public function testPurlLoad(): void
{
$filename = self::$testbook;
$reader = new Xlsx();
$spreadsheet = $reader->load($filename);
$sheet = $spreadsheet->getActiveSheet();
self::assertSame('ml_out', $sheet->getTitle());
self::assertSame('Item', $sheet->getCell('A1')->getValue());
self::assertEquals(97.91, $sheet->getCell('G3')->getValue());
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/Issue4248Test.php | tests/PhpSpreadsheetTests/Reader/Xlsx/Issue4248Test.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx as XlsxReader;
use PhpOffice\PhpSpreadsheet\Shared\File;
use PhpOffice\PhpSpreadsheet\Writer\Html as HtmlWriter;
use PhpOffice\PhpSpreadsheet\Writer\Xlsx as XlsxWriter;
use PHPUnit\Framework\TestCase;
class Issue4248Test extends TestCase
{
private string $outfile = '';
protected function tearDown(): void
{
if ($this->outfile !== '') {
unlink($this->outfile);
$this->outfile = '';
}
}
public function testStyles(): void
{
$file = 'tests/data/Reader/XLSX/issue.4248.xlsx';
$reader = new XlsxReader();
$spreadsheet = $reader->load($file);
$writer = new XlsxWriter($spreadsheet);
$writer->setUseDiskCaching(true, sys_get_temp_dir());
$this->outfile = File::temporaryFilename();
$writer->save($this->outfile);
$spreadsheet->disconnectWorksheets();
$file = 'zip://';
$file .= $this->outfile;
$file .= '#xl/styles.xml';
$data = file_get_contents($file) ?: '';
$expected = '<fill>'
. '<patternFill patternType="darkDown"/>'
. '</fill>';
self::assertStringContainsString($expected, $data, 'neither fgColor nor bgColor');
$expected = '<fill>'
. '<patternFill patternType="darkDown">'
. '<bgColor rgb="FFBDD7EE"/>'
. '</patternFill></fill>';
self::assertStringContainsString($expected, $data, 'bgColor but no fgColor');
$expected = '<dxfs count="15">'
. '<dxf>' // dxfId 1 - fill color for Oui
. '<fill>'
. '<patternFill><bgColor rgb="FF00B050"/></patternFill>'
. '</fill>'
. '<border/>'
. '</dxf>'
. '<dxf>' // dxfId 2 - fill color for Non
. '<font><color rgb="FF9C0006"/></font>'
. '<fill>'
. '<patternFill><bgColor rgb="FFFFC7CE"/></patternFill>'
. '</fill>'
. '<border/>'
. '</dxf>';
self::assertStringContainsString($expected, $data, 'conditional fill styles');
$file = 'zip://';
$file .= $this->outfile;
$file .= '#xl/worksheets/sheet1.xml';
$data = file_get_contents($file) ?: '';
$expected = '<conditionalFormatting sqref="C16:C38 E17:H18 I17:J37 D18 J23:J38 E38 I38">'
. '<cfRule type="containsText" dxfId="0" priority="15" operator="containsText" text="Oui">'
. '<formula>NOT(ISERROR(SEARCH("Oui",C16)))</formula>'
. '</cfRule>'
. '</conditionalFormatting>';
self::assertStringContainsString($expected, $data, 'first condition for D18');
$expected = '<conditionalFormatting sqref="C16:C38 I17:J37 E17:H18 D18 J23:J38 E38 I38">'
. '<cfRule type="containsText" dxfId="1" priority="14" operator="containsText" text="Non">'
. '<formula>NOT(ISERROR(SEARCH("Non",C16)))</formula>'
. '</cfRule>'
. '</conditionalFormatting>';
self::assertStringContainsString($expected, $data, 'second condition for D18');
}
public function testHtml(): void
{
$file = 'tests/data/Reader/XLSX/issue.4248.xlsx';
$reader = new XlsxReader();
$spreadsheet = $reader->load($file);
$writer = new HtmlWriter($spreadsheet);
$file = 'zip://';
$file .= $this->outfile;
$file .= '#xl/styles.xml';
$data = str_replace(["\r", "\n"], '', $writer->generateHtmlAll());
$expected = ' <tr class="row17">' // Cell D18
. ' <td class="column0 style0"> </td>'
. ' <td class="column1 style28 null"> </td>'
. ' <td class="column2 style35 s">Eligible </td>'
. ' <td class="column3 style70 s">Non</td>';
self::assertStringContainsString($expected, $data, 'Cell D18 style');
$expected = ' td.style70, th.style70 { vertical-align:middle; text-align:center; border-bottom:1px solid #000000 !important; border-top:2px solid #000000 !important; border-left:2px solid #000000 !important; border-right:1px solid #000000 !important; font-weight:bold; color:#000000; font-family:\'Calibri\'; font-size:16pt; background-color:#BDD7EE }';
self::assertStringContainsString($expected, $data, 'background color');
$spreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/NumericCellTypeTest.php | tests/PhpSpreadsheetTests/Reader/Xlsx/NumericCellTypeTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\Cell\Cell;
use PhpOffice\PhpSpreadsheet\Cell\DataType;
use PhpOffice\PhpSpreadsheet\Cell\IValueBinder;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx as Reader;
use PhpOffice\PhpSpreadsheet\Shared\File;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Writer\Xlsx as Writer;
use PHPUnit\Framework\TestCase;
class NumericCellTypeTest extends TestCase
{
private IValueBinder $oldBinder;
private string $filename = '';
protected function setUp(): void
{
$this->oldBinder = Cell::getValueBinder();
$binder = new class () implements IValueBinder {
public function bindValue(Cell $cell, mixed $value): bool
{
if (is_float($value) || is_int($value)) {
$type = DataType::TYPE_NUMERIC;
} elseif (is_string($value)) {
$type = DataType::TYPE_STRING;
} else {
return false;
}
$cell->setValueExplicit($value, $type);
return true;
}
};
Cell::setValueBinder($binder);
}
protected function tearDown(): void
{
Cell::setValueBinder($this->oldBinder);
if ($this->filename !== '') {
unlink($this->filename);
$this->filename = '';
}
}
public function testCellShouldHaveNumericTypeAttribute(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$array = [
['1.0'],
[1.0],
['-1.0'],
[-1.0],
['0'],
[0],
['0.0'],
[0.0],
['1e1'],
[1e1],
];
$sheet->fromArray($array, null, 'A1', true);
$this->filename = File::temporaryFilename();
$writer = new Writer($spreadsheet);
$writer->save($this->filename);
$spreadsheet->disconnectWorksheets();
$reader = new Reader();
$spreadsheet2 = $reader->load($this->filename);
$sheet2 = $spreadsheet2->getActiveSheet();
self::assertSame($array, $sheet2->toArray(null, false, false));
$spreadsheet2->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/Issue3720Test.php | tests/PhpSpreadsheetTests/Reader/Xlsx/Issue3720Test.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\Style\Protection;
use PhpOffice\PhpSpreadsheet\Worksheet\Drawing;
class Issue3720Test extends \PHPUnit\Framework\TestCase
{
private static string $testbook = 'tests/data/Reader/XLSX/issue.3720.xlsx';
public function testPreliminaries(): void
{
$file = 'zip://';
$file .= self::$testbook;
$file .= '#xl/_rels/workbook.xml.rels';
$data = file_get_contents($file);
// confirm that file contains expected namespaced xml tag
if ($data === false) {
self::fail('Unable to read file');
} else {
self::assertStringContainsString('<ns3:Relationships ', $data);
}
}
public function testInfo(): void
{
$reader = new Xlsx();
$workSheetInfo = $reader->listWorkSheetInfo(self::$testbook);
$info1 = $workSheetInfo[1];
self::assertEquals('Welcome', $info1['worksheetName']);
self::assertEquals('H', $info1['lastColumnLetter']);
self::assertEquals(7, $info1['lastColumnIndex']);
self::assertEquals(49, $info1['totalRows']);
self::assertEquals(8, $info1['totalColumns']);
}
public function testSheetNames(): void
{
$reader = new Xlsx();
$worksheetNames = $reader->listWorksheetNames(self::$testbook);
$expected = [
'Data',
'Welcome',
'Sheet 1',
'Sheet 2',
'Sheet 3',
'Sheet 4',
'Sheet 5',
'Sheet 6',
'Sheet 7',
'Sheet 8',
'Sheet 9',
'Sheet 10',
];
self::assertEquals($expected, $worksheetNames);
}
public function testLoadXlsx(): void
{
$reader = new Xlsx();
$spreadsheet = $reader->load(self::$testbook);
$sheets = $spreadsheet->getAllSheets();
self::assertCount(12, $sheets);
$sheet = $spreadsheet->getSheetByNameOrThrow('Sheet 1');
$sheetProtection = $sheet->getProtection();
self::assertTrue($sheetProtection->getSheet());
self::assertSame(' FILL IN WHITE CELLS ONLY', $sheet->getCell('B3')->getValue());
// inherit because cell style is inherit.
// effectively protected because sheet is locked.
self::assertTrue($sheet->cellExists('A12'));
self::assertSame(Protection::PROTECTION_INHERIT, $sheet->getStyle('A12')->getProtection()->getLocked());
self::assertTrue($sheet->getCell('A12')->isLocked());
// unprotected because column is unprotected (no cell or row dimension style)
self::assertFalse($sheet->cellExists('B12'));
self::assertFalse($sheet->rowDimensionExists(12));
self::assertTrue($sheet->columnDimensionExists('B'));
$dxf = $sheet->getColumnDimension('B')->getXfIndex();
if ($dxf === null) {
self::fail('Unexpected null column xfIndex');
} else {
self::assertSame(Protection::PROTECTION_UNPROTECTED, $spreadsheet->getCellXfByIndex($dxf)->getProtection()->getLocked());
}
self::assertFalse($sheet->getCell('B12')->isLocked());
// inherit because cell doesn't exist, no row dimension, no column dimension.
// effectively protected because sheet is locked.
self::assertFalse($sheet->cellExists('W8'));
self::assertFalse($sheet->rowDimensionExists(8));
self::assertFalse($sheet->columnDimensionExists('W'));
self::assertTrue($sheet->getCell('W8')->isLocked());
// inherit because cell doesn't exist, row dimension exists without style, no column dimension.
// effectively protected because sheet is locked.
self::assertFalse($sheet->cellExists('X11'));
self::assertTrue($sheet->rowDimensionExists(11));
$dxf = $sheet->getRowDimension(11)->getXfIndex();
self::assertNull($dxf);
self::assertFalse($sheet->columnDimensionExists('X'));
self::assertTrue($sheet->getCell('X11')->isLocked());
$sheet = $spreadsheet->getSheetByNameOrThrow('Welcome');
$drawings = $sheet->getDrawingCollection();
self::assertCount(1, $drawings);
$draw0 = $drawings[0] ?? new Drawing();
self::assertSame('Picture 1', $draw0->getName());
self::assertSame('C3', $draw0->getCoordinates());
self::assertSame('C10', $draw0->getCoordinates2());
self::assertSame('oneCell', $draw0->getEditAs());
$spreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/ApostropheTest.php | tests/PhpSpreadsheetTests/Reader/Xlsx/ApostropheTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\Calculation\Calculation;
use PhpOffice\PhpSpreadsheet\NamedRange;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheetTests\Functional\AbstractFunctional;
class ApostropheTest extends AbstractFunctional
{
public function testApostropheInSheetName(): void
{
$spreadsheet = new Spreadsheet();
Calculation::getInstance($spreadsheet)
->setInstanceArrayReturnType(
Calculation::RETURN_ARRAY_AS_ARRAY
);
$sheet = $spreadsheet->getActiveSheet();
$sheet->setTitle('sheet1');
$sheet->getCell('A1')->setValue(1);
$sheet->getCell('A2')->setValue(2);
$sheet->getCell('A3')->setValue(3);
$sheet->getCell('A4')->setValue(4);
$spreadsheet->addNamedRange(new NamedRange('sheet14cells', $sheet, '$A$1:$A$4'));
$sheet->getCell('C1')
->setValue('=sheet14cells*sheet14cells');
$sheet->getCell('E1')->setValue('=ANCHORARRAY(sheet1!C1)');
$sheet->getCell('G1')->setValue('=SINGLE(sheet1!C1:C4)');
$sheet1 = $spreadsheet->createSheet();
$sheet1->setTitle("Apo'strophe");
$sheet1->getCell('A1')->setValue(2);
$sheet1->getCell('A2')->setValue(3);
$sheet1->getCell('A3')->setValue(4);
$sheet1->getCell('A4')->setValue(5);
$spreadsheet->addNamedRange(new NamedRange('sheet24cells', $sheet1, '$A$1:$A$4'));
$sheet1->getCell('C1')
->setValue('=sheet24cells*sheet24cells');
$sheet1->getCell('E1')->setValue("=ANCHORARRAY('Apo''strophe'!C1)");
$sheet1->getCell('G1')->setValue("=SINGLE('Apo''strophe'!C1:C4)");
$reloadedSpreadsheet = $this->writeAndReload($spreadsheet, 'Xlsx');
$spreadsheet->disconnectWorksheets();
Calculation::getInstance($reloadedSpreadsheet)
->setInstanceArrayReturnType(
Calculation::RETURN_ARRAY_AS_ARRAY
);
$rsheet = $reloadedSpreadsheet->getSheet(0);
// make sure results aren't from cache
$rsheet->getCell('E1')->setCalculatedValue(-1);
$rsheet->getCell('G1')->setCalculatedValue(-1);
self::assertSame([[1], [4], [9], [16]], $rsheet->getCell('C1')->getCalculatedValue());
self::assertSame([[1], [4], [9], [16]], $rsheet->getCell('E1')->getCalculatedValue());
self::assertSame(1, $rsheet->getCell('G1')->getCalculatedValue());
$rsheet1 = $reloadedSpreadsheet->getSheet(1);
// make sure results aren't from cache
$rsheet1->getCell('E1')->setCalculatedValue(-1);
$rsheet1->getCell('G1')->setCalculatedValue(-1);
self::assertSame([[4], [9], [16], [25]], $rsheet1->getCell('C1')->getCalculatedValue());
self::assertSame([[4], [9], [16], [25]], $rsheet1->getCell('E1')->getCalculatedValue());
self::assertSame(4, $rsheet1->getCell('G1')->getCalculatedValue());
$reloadedSpreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/Issue2494Test.php | tests/PhpSpreadsheetTests/Reader/Xlsx/Issue2494Test.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\IOFactory;
use PHPUnit\Framework\TestCase;
class Issue2494Test extends TestCase
{
public function testIssue2494(): void
{
// Fill style incorrect.
$filename = 'tests/data/Reader/XLSX/issue.2494.xlsx';
$reader = IOFactory::createReader('Xlsx');
$spreadsheet = $reader->load($filename);
$sheet = $spreadsheet->getActiveSheet();
self::assertTrue($sheet->getCell('C3')->getStyle()->getFont()->getBold());
self::assertSame('FFBFBFBF', $sheet->getCell('D8')->getStyle()->getFill()->getStartColor()->getArgb());
$spreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/RichTextTest.php | tests/PhpSpreadsheetTests/Reader/Xlsx/RichTextTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\RichText\RichText;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheetTests\Functional\AbstractFunctional;
class RichTextTest extends AbstractFunctional
{
public function testRichTextColors(): void
{
$spreadsheetOld = new Spreadsheet();
$sheet = $spreadsheetOld->getActiveSheet();
$richText = new RichText();
$part1 = $richText->createTextRun('Red');
$font1 = $part1->getFont();
if ($font1 !== null) {
$font1->setName('Courier New');
$font1->getColor()->setArgb('FFFF0000');
}
$part2 = $richText->createTextRun('Blue');
$font2 = $part2->getFont();
if ($font2 !== null) {
$font2->setName('Times New Roman');
$font2->setItalic(true);
$font2->getColor()->setArgb('FF0000FF');
}
$sheet->setCellValue('A1', $richText);
$spreadsheet = $this->writeAndReload($spreadsheetOld, 'Xlsx');
$spreadsheetOld->disconnectWorksheets();
$rsheet = $spreadsheet->getActiveSheet();
$value = $rsheet->getCell('A1')->getValue();
if ($value instanceof RichText) {
$elements = $value->getRichTextElements();
self::assertCount(2, $elements);
$font1a = $elements[0]->getFont();
$font2a = $elements[1]->getFont();
self::assertNotNull($font1a);
self::assertNotNull($font2a);
self::assertSame('Courier New', $font1a->getName());
self::assertSame('FFFF0000', $font1a->getColor()->getArgb());
self::assertFalse($font1a->getItalic());
self::assertSame('Times New Roman', $font2a->getName());
self::assertSame('FF0000FF', $font2a->getColor()->getArgb());
self::assertTrue($font2a->getItalic());
} else {
self::fail('Did not see expected RichText');
}
$spreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/Issue2516Test.php | tests/PhpSpreadsheetTests/Reader/Xlsx/Issue2516Test.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx;
use PHPUnit\Framework\TestCase;
class Issue2516Test extends TestCase
{
private static string $testbook = 'tests/data/Reader/XLSX/issue.2516b.xlsx';
public function testPreliminaries(): void
{
$file = 'zip://';
$file .= self::$testbook;
$file .= '#docProps/thumbnail.wmf';
$data = file_get_contents($file);
// confirm that file exists
self::assertNotFalse($data, 'thumbnail.wmf not exists');
$file = 'zip://';
$file .= self::$testbook;
$file .= '#_rels/.rels';
$data = file_get_contents($file);
// confirm that file contains expected namespaced xml tag
if ($data === false) {
self::fail('Unable to read file .rels');
} else {
self::assertStringContainsString('Type="http://schemas.openxmlformats.org/package/2006/relationships/metadata/thumbnail" Target="docProps/thumbnail.wmf"', $data);
}
}
public function testIssue2516a(): void
{
$filename = self::$testbook;
$reader = new Xlsx();
$names = $reader->listWorksheetNames($filename);
$expected = ['Sheet1'];
self::assertSame($expected, $names);
}
public function testIssue2516b(): void
{
$filename = self::$testbook;
$reader = new Xlsx();
$infos = $reader->listWorksheetInfo($filename);
$expected = [
[
'worksheetName' => 'Sheet1',
'lastColumnLetter' => 'B',
'lastColumnIndex' => 1,
'totalRows' => 6,
'totalColumns' => 2,
'sheetState' => 'visible',
],
];
self::assertSame($expected, $infos);
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/Issue3730Test.php | tests/PhpSpreadsheetTests/Reader/Xlsx/Issue3730Test.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx;
class Issue3730Test extends \PHPUnit\Framework\TestCase
{
private static string $testbook = 'tests/data/Reader/XLSX/issue.3730.xlsx';
public function testPreliminaries(): void
{
$file = 'zip://';
$file .= self::$testbook;
$file .= '#xl\_rels\workbook.xml.rels'; // no idea why backslash
$data = file_get_contents($file);
// confirm that file contains expected absolute reference
if ($data === false) {
self::fail('Unable to read file');
} else {
self::assertStringContainsString('Target="/xl/sharedStrings.xml"', $data);
self::assertStringContainsString('Target="/xl/styles.xml"', $data);
self::assertStringContainsString('Target="/xl/worksheets/sheet0.xml"', $data);
}
}
public function testInfo(): void
{
$reader = new Xlsx();
$workSheetInfo = $reader->listWorkSheetInfo(self::$testbook);
$info1 = $workSheetInfo[0];
self::assertEquals('promedia postlogs wk 2-12', $info1['worksheetName']);
self::assertEquals('O', $info1['lastColumnLetter']);
self::assertEquals(14, $info1['lastColumnIndex']);
self::assertEquals(99, $info1['totalRows']);
self::assertEquals(15, $info1['totalColumns']);
}
public function testSheetNames(): void
{
$reader = new Xlsx();
$worksheetNames = $reader->listWorksheetNames(self::$testbook);
$expected = [
'promedia postlogs wk 2-12',
];
self::assertEquals($expected, $worksheetNames);
}
public function testLoadXlsx(): void
{
$reader = new Xlsx();
$spreadsheet = $reader->load(self::$testbook);
$sheets = $spreadsheet->getAllSheets();
self::assertCount(1, $sheets);
$sheet = $spreadsheet->getSheetByNameOrThrow('promedia postlogs wk 2-12');
self::assertSame('ProMedia Group - DR', $sheet->getCell('G7')->getValue());
self::assertSame('Arial', $sheet->getStyle('G7')->getFont()->getName());
self::assertEquals(8, $sheet->getStyle('G7')->getFont()->getSize());
$spreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/ColorTabTest.php | tests/PhpSpreadsheetTests/Reader/Xlsx/ColorTabTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx;
use PHPUnit\Framework\TestCase;
class ColorTabTest extends TestCase
{
public function testIssue2316(): void
{
$filename = 'tests/data/Reader/XLSX/colortabs.xlsx';
$reader = new Xlsx();
$spreadsheet = $reader->load($filename);
// theme color
self::assertSame('FF548135', $spreadsheet->getSheet(0)->getTabColor()->getArgb());
// rgb color
self::assertSame('FFFFC000', $spreadsheet->getSheet(1)->getTabColor()->getArgb());
$spreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/MyXlsxReader.php | tests/PhpSpreadsheetTests/Reader/Xlsx/MyXlsxReader.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx as XlsxReader;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
class MyXlsxReader extends XlsxReader
{
protected function newSpreadsheet(): Spreadsheet
{
return new MySpreadsheet();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/DataValidationBooleanValueTest.php | tests/PhpSpreadsheetTests/Reader/Xlsx/DataValidationBooleanValueTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx;
use PHPUnit\Framework\TestCase;
class DataValidationBooleanValueTest extends TestCase
{
public static function testPr2225TrueFalse(): void
{
//This file is created with LibreOffice
$xlsxFile = 'tests/data/Reader/XLSX/pr2225-datavalidation-truefalse.xlsx';
$reader = new Xlsx();
$spreadsheet = $reader->load($xlsxFile);
$a1 = $spreadsheet->getActiveSheet()->getDataValidation('A1');
$a2 = $spreadsheet->getActiveSheet()->getDataValidation('A2');
//<dataValidation allowBlank="false" showDropDown="false" showErrorMessage="true" showInputMessage="true" sqref="A1" type="list">
//<dataValidation allowBlank="true" showDropDown="true" showErrorMessage="false" showInputMessage="false" sqref="A2" type="list">
self::assertFalse($a1->getAllowBlank(), 'A1 validation does not allow blanks, flag should be false');
self::assertTrue($a1->getShowDropDown(), 'A1 is set to show the drop down in Excel, which is false in the file');
self::assertTrue($a1->getShowErrorMessage(), 'A1 Shows error message, flag should be true');
self::assertTrue($a1->getShowInputMessage(), 'A1 Shows input message, flag should be true');
self::assertTrue($a2->getAllowBlank(), 'A2 validation allows blanks, flag should be true');
self::assertFalse($a2->getShowDropDown(), 'A2 is set to not show the drop down in Excel, which is true in the file');
self::assertFalse($a2->getShowErrorMessage(), 'A2 does not show error message, flag should be false');
self::assertFalse($a2->getShowInputMessage(), 'A2 does not show input message, flag should be false');
}
//This file was created with Google Sheets export to XLSX
public static function testPr2225OneZero(): void
{
$xlsxFile = 'tests/data/Reader/XLSX/pr2225-datavalidation-onezero.xlsx';
$reader = new Xlsx();
$spreadsheet = $reader->load($xlsxFile);
$a1 = $spreadsheet->getActiveSheet()->getDataValidation('A1');
$a2 = $spreadsheet->getActiveSheet()->getDataValidation('A2');
//<dataValidation allowBlank="1" showErrorMessage="1" showInputMessage="1" sqref="A1" type="list">
//<dataValidation allowBlank="1" showDropDown="0" sqref="A2" type="list">
self::assertTrue($a1->getAllowBlank(), 'A1 validation allows blanks, flag should be true');
self::assertTrue($a1->getShowDropDown(), 'A1 is set to show the drop down in Excel, which is false in the file');
self::assertTrue($a1->getShowErrorMessage(), 'A1 Shows error message, flag should be true');
self::assertTrue($a1->getShowInputMessage(), 'A1 Shows input message, flag should be true');
self::assertTrue($a2->getAllowBlank(), 'A2 validation allows blanks, flag should be true');
self::assertFalse($a2->getShowDropDown(), 'A2 is set to not show the drop down in Excel, which is true in the file');
self::assertFalse($a2->getShowErrorMessage(), 'A2 does not show error message, flag should be false');
self::assertFalse($a2->getShowInputMessage(), 'A2 does not show input message, flag should be false');
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/Issue2301Test.php | tests/PhpSpreadsheetTests/Reader/Xlsx/Issue2301Test.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\IOFactory;
use PhpOffice\PhpSpreadsheet\RichText\RichText;
class Issue2301Test extends \PHPUnit\Framework\TestCase
{
private static string $testbook = 'tests/data/Reader/XLSX/issue.2301.xlsx';
public static function testReadRichText(): void
{
$spreadsheet = IOFactory::load(self::$testbook);
$sheet = $spreadsheet->getActiveSheet();
$value = $sheet->getCell('B45')->getValue();
self::assertInstanceOf(RichText::class, $value);
$richtext = $value->getRichTextElements();
$font = $richtext[1]->getFont();
self::assertNotNull($font);
self::assertSame('Arial CE', $font->getName());
self::assertSame(9.0, $font->getSize());
self::assertSame('protected', $sheet->getCell('BT10')->getStyle()->getProtection()->getHidden());
$spreadsheet->disconnectWorksheets();
unset($spreadsheet);
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/RgbTintTest.php | tests/PhpSpreadsheetTests/Reader/Xlsx/RgbTintTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\IOFactory;
use PHPUnit\Framework\TestCase;
class RgbTintTest extends TestCase
{
public static function compareColors(string $style, string $text): string
{
$styleRed = hexdec(substr($style, 0, 2));
$styleGreen = hexdec(substr($style, 2, 2));
$styleBlue = hexdec(substr($style, 4, 2));
$textRed = hexdec(substr($text, 0, 2));
$textGreen = hexdec(substr($text, 2, 2));
$textBlue = hexdec(substr($text, 4, 2));
$maxDiff = 3;
if (abs($styleRed - $textRed) > $maxDiff) {
return $style;
}
if (abs($styleGreen - $textGreen) > $maxDiff) {
return $style;
}
if (abs($styleBlue - $textBlue) > $maxDiff) {
return $style;
}
return $text;
}
public function testRgbTint(): void
{
$filename = 'tests/data/Reader/XLSX/RgbTint.xlsx';
$reader = IOFactory::createReader('Xlsx');
$spreadsheet = $reader->load($filename);
$sheet = $spreadsheet->getActiveSheet();
$row = 0;
while (true) {
++$row;
$text = (string) $sheet->getCell("B$row");
if ($text === '') {
break;
}
$style = $sheet->getStyle("A$row")->getFill()->getStartColor()->getRgb();
self::assertSame($text, self::compareColors($style, $text), "row $row");
}
$spreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/CommentTest.php | tests/PhpSpreadsheetTests/Reader/Xlsx/CommentTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx;
use PHPUnit\Framework\TestCase;
class CommentTest extends TestCase
{
public function testIssue2316(): void
{
$filename = 'tests/data/Reader/XLSX/issue.2316.xlsx';
$reader = new Xlsx();
$spreadsheet = $reader->load($filename);
$sheet = $spreadsheet->getActiveSheet();
$comment = $sheet->getComment('A1');
$commentString = (string) $comment;
self::assertStringContainsString('編號長度限制：', $commentString);
self::assertSame('jill.chen', $comment->getAuthor());
$comment = $sheet->getComment('E1');
$commentString = (string) $comment;
self::assertStringContainsString('若為宅配物流僅能選「純配送」', $commentString);
self::assertSame('Anderson Chen 陳宗棠', $comment->getAuthor());
}
public function testIssue3654(): void
{
// Reader was ignoring comments.
$filename = 'tests/data/Reader/XLSX/issue.3654.xlsx';
$reader = new Xlsx();
$spreadsheet = $reader->load($filename);
$sheet = $spreadsheet->getActiveSheet();
$expectedComments = [
'X4', 'AD4', 'AN4',
'X5', 'AD5', 'AN5',
'AN6', // X6 and AD6 are uncommented on original
'X7', 'AD7', 'AN7',
'X8', 'AD8', 'AN8',
'X9', 'AD9', 'AN9',
'X10', 'AD10', 'AN10',
'X11', 'AD11', 'AN11',
'X12', 'AD12', 'AN12',
];
self::assertEquals($expectedComments, array_keys($sheet->getComments()));
self::assertStringContainsString('.png', $sheet->getComment('X4')->getBackgroundImage()->getPath());
self::assertStringContainsString('.jpeg', $sheet->getComment('AN12')->getBackgroundImage()->getPath());
$spreadsheet->disconnectWorksheets();
}
public function testIssue3654c(): void
{
// Reader was ignoring comments.
$filename = 'tests/data/Reader/XLSX/issue.3654c.xlsx';
$reader = new Xlsx();
$spreadsheet = $reader->load($filename);
$sheet = $spreadsheet->getActiveSheet();
$comments = $sheet->getComments();
self::assertCount(326, $comments);
self::assertStringContainsString('.png', $sheet->getComment('X4')->getBackgroundImage()->getPath());
self::assertStringContainsString('.jpeg', $sheet->getComment('AN12')->getBackgroundImage()->getPath());
// Spreadsheet generated by Flexcel. Make sure we managed
// to locate printerSettings since it used an unexpected link.
/** @var mixed[][][][][] */
$unparsedLoadedData = $spreadsheet->getUnparsedLoadedData();
/** @var string */
$pageSetupRel = $unparsedLoadedData['sheets']['Worksheet']['pageSetupRelId'] ?? '';
self::assertSame('flId1ps', $pageSetupRel);
$pageSetupPath = $unparsedLoadedData['sheets']['Worksheet']['printerSettings'][substr($pageSetupRel, 3)]['filePath'] ?? '';
self::assertSame('xl/printerSettings/printerSettings1.bin', $pageSetupPath);
$spreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/Issue3435Test.php | tests/PhpSpreadsheetTests/Reader/Xlsx/Issue3435Test.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx;
class Issue3435Test extends \PHPUnit\Framework\TestCase
{
private static string $testbook = 'tests/data/Reader/XLSX/issue.3435.xlsx';
public function testPreliminaries(): void
{
$file = 'zip://';
$file .= self::$testbook;
$file .= '#xl/styles.xml';
$data = file_get_contents($file);
// confirm that file contains expected namespaced xml tag
if ($data === false) {
self::fail('Unable to read file');
} else {
$expected = <<<EOF
<xf numFmtId="0" fontId="0" fillId="0" borderId="0" xfId="0"/>
<xf numFmtId="0" fontId="0" fillId="0" borderId="0" xfId="0" quotePrefix="1"/>
<xf numFmtId="0" fontId="1" fillId="2" borderId="1" xfId="0" quotePrefix="0" applyFont="1" applyFill="1" applyBorder="1"/>
EOF;
self::assertStringContainsString($expected, $data);
}
}
public function testQuotePrefix(): void
{
// Parsing of quotePrefix="0" was incorrect, now corrected.
$reader = new Xlsx();
$spreadsheet = $reader->load(self::$testbook);
$sheet = $spreadsheet->getActiveSheet();
self::assertTrue($sheet->getStyle('A1')->getQuotePrefix());
self::assertFalse($sheet->getStyle('A2')->getQuotePrefix());
self::assertFalse($sheet->getStyle('A3')->getQuotePrefix());
$spreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/OctothorpeTest.php | tests/PhpSpreadsheetTests/Reader/Xlsx/OctothorpeTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\IOFactory;
use PHPUnit\Framework\TestCase;
class OctothorpeTest extends TestCase
{
public function testOctothorpeInName(): void
{
// Permit # in file name.
$filename = 'tests/data/Reader/XLSX/octo#thorpe.xlsx';
$reader = IOFactory::createReader('Xlsx');
$spreadsheet = $reader->load($filename);
$sheet = $spreadsheet->getActiveSheet();
self::assertSame('xyz', $sheet->getCell('A1')->getValue());
$spreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/ReadDynamTest.php | tests/PhpSpreadsheetTests/Reader/Xlsx/ReadDynamTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\Calculation\Calculation;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Writer\Xlsx as XlsxWriter;
use PhpOffice\PhpSpreadsheetTests\Functional\AbstractFunctional;
class ReadDynamTest extends AbstractFunctional
{
public function writeCse(XlsxWriter $writer): void
{
$writer->setUseCSEArrays(true);
}
public function testCse(): void
{
$spreadsheetOld = new Spreadsheet();
$sheetOld = $spreadsheetOld->getActiveSheet();
$calcOld = Calculation::getInstance($spreadsheetOld);
$calcOld->setInstanceArrayReturnType(
Calculation::RETURN_ARRAY_AS_ARRAY
);
$sheetOld->fromArray(
[1, 2, 2, 4, 3, 2, 1, 3, 3, 3, 5],
null,
'A14',
true
);
$sheetOld->setCellValue('A15', '=UNIQUE(A14:K14, TRUE)');
/** @var callable */
$callableWriter = [$this, 'writeCse'];
$spreadsheet = $this->writeAndReload($spreadsheetOld, 'Xlsx', null, $callableWriter);
$spreadsheetOld->disconnectWorksheets();
$calc = Calculation::getInstance($spreadsheet);
self::assertSame(
Calculation::RETURN_ARRAY_AS_VALUE,
$calc->getInstanceArrayReturnType()
);
$spreadsheet->disconnectWorksheets();
}
public function testDynam(): void
{
$spreadsheetOld = new Spreadsheet();
$sheetOld = $spreadsheetOld->getActiveSheet();
$calcOld = Calculation::getInstance($spreadsheetOld);
$calcOld->setInstanceArrayReturnType(
Calculation::RETURN_ARRAY_AS_ARRAY
);
$sheetOld->fromArray(
[1, 2, 2, 4, 3, 2, 1, 3, 3, 3, 5],
null,
'A14',
true
);
$sheetOld->setCellValue('A15', '=UNIQUE(A14:K14, TRUE)');
$reloadedSpreadsheet = $this->writeAndReload($spreadsheetOld, 'Xlsx');
$spreadsheet = $this->writeAndReload($spreadsheetOld, 'Xlsx');
$spreadsheetOld->disconnectWorksheets();
$calc = Calculation::getInstance($spreadsheet);
self::assertSame(
Calculation::RETURN_ARRAY_AS_ARRAY,
$calc->getInstanceArrayReturnType()
);
$spreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/Issue4356Test.php | tests/PhpSpreadsheetTests/Reader/Xlsx/Issue4356Test.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\NamedRange;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheetTests\Functional\AbstractFunctional;
class Issue4356Test extends AbstractFunctional
{
public function testIssue4356(): void
{
// Reader couldn't handle sheet title with apostrophe for defined name
$nameDefined = 'CELLNAME';
$originalSpreadsheet = new Spreadsheet();
$originalSheet = $originalSpreadsheet->getActiveSheet();
$originalSheet->setTitle("Goodn't sheet name");
$originalSpreadsheet->addNamedRange(
new NamedRange($nameDefined, $originalSheet, '$A$1')
);
$originalSheet->setCellValue('A1', 'This is a named cell.');
$originalSheet->getStyle($nameDefined)
->getFont()
->setItalic(true);
$spreadsheet = $this->writeAndReload($originalSpreadsheet, 'Xlsx');
$originalSpreadsheet->disconnectWorksheets();
$sheet = $spreadsheet->getActiveSheet();
$sheet->setCellValue('C1', "=$nameDefined");
self::assertSame('This is a named cell.', $sheet->getCell('C1')->getCalculatedValue());
$namedRange2 = $spreadsheet->getNamedRange($nameDefined);
self::assertNotNull($namedRange2);
$sheetx = $namedRange2->getWorksheet();
self::assertNotNull($sheetx);
$style = $sheetx->getStyle($nameDefined);
self::assertTrue($style->getFont()->getItalic());
$style->getFont()->setItalic(false);
$spreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/Issue4415Test.php | tests/PhpSpreadsheetTests/Reader/Xlsx/Issue4415Test.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx as XlsxReader;
use PHPUnit\Framework\TestCase;
class Issue4415Test extends TestCase
{
private static string $file = 'tests/data/Reader/XLSX/issue.4415.xlsx';
public function testPreliminaries(): void
{
$file = 'zip://';
$file .= self::$file;
$file .= '#xl/drawings/drawing1.xml';
$data = file_get_contents($file) ?: '';
$expected = '<a:alpha val="72600"/>';
self::assertStringContainsString($expected, $data);
$expected = '<a:alpha val="90100"/>';
self::assertStringContainsString($expected, $data);
self::assertSame(2, substr_count($data, '<a:alpha '), 'number of drawings with alpha');
self::assertSame(2, substr_count($data, '<xdr:oneCellAnchor>'), 'first 2 drawings');
self::assertSame(1, substr_count($data, '<xdr:twoCellAnchor>'), 'third drawings');
}
public function testFractionalAlpha(): void
{
$file = self::$file;
$reader = new XlsxReader();
$spreadsheet = $reader->load($file);
$sheet = $spreadsheet->getActiveSheet();
$drawings = $sheet->getDrawingCollection();
self::assertCount(3, $drawings);
self::assertNotNull($drawings[0]);
self::assertNotNull($drawings[1]);
self::assertNotNull($drawings[2]);
self::assertSame(50, $drawings[0]->getShadow()->getAlpha());
self::assertSame(72, $drawings[1]->getShadow()->getAlpha());
self::assertSame('', $drawings[1]->getCoordinates2(), 'one cell anchor');
self::assertSame(90, $drawings[2]->getShadow()->getAlpha());
self::assertNotEquals('', $drawings[2]->getCoordinates2(), 'two cell anchor');
$spreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/Issue4039Test.php | tests/PhpSpreadsheetTests/Reader/Xlsx/Issue4039Test.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Style\Conditional;
use PhpOffice\PhpSpreadsheetTests\Functional\AbstractFunctional;
class Issue4039Test extends AbstractFunctional
{
private static string $testbook = 'tests/data/Style/ConditionalFormatting/CellMatcher.xlsx';
public function testUnionRange(): void
{
$reader = new Xlsx();
$spreadsheet = $reader->load(self::$testbook);
$sheet = $spreadsheet->getSheetByNameOrThrow('cellIs Expression');
$expected = [
'A12:D17,A20', // split range
'A22:D27',
'A2:E6',
];
self::assertSame($expected, array_keys($sheet->getConditionalStylesCollection()));
self::assertSame($expected[0], $sheet->getConditionalRange('A20'));
self::assertSame($expected[0], $sheet->getConditionalRange('C15'));
self::assertNull($sheet->getConditionalRange('A19'));
self::assertSame($expected[1], $sheet->getConditionalRange('D25'));
$spreadsheet->disconnectWorksheets();
}
public function testIntersectionRange(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->fromArray([
[1, 2, 3, 4, 5],
[2, 3, 4, 5, 6],
[3, 4, 5, 6, 7],
]);
$condition1 = new Conditional();
$condition1->setConditionType(Conditional::CONDITION_CELLIS);
$condition1->setOperatorType(Conditional::OPERATOR_BETWEEN);
$condition1->setConditions([2, 3]);
$condition1->getStyle()->getFont()
->setBold(true);
$conditionalStyles = [$condition1];
// Writer will change this range to equivalent 'B1,B2,B3'
$sheet->setConditionalStyles('A1:C3 B1:B3', $conditionalStyles);
$robj = $this->writeAndReload($spreadsheet, 'Xlsx');
$spreadsheet->disconnectWorksheets();
$sheet0 = $robj->getActiveSheet();
$conditionals = $sheet0->getConditionalStylesCollection();
self::assertSame(['B1,B2,B3'], array_keys($conditionals));
$cond1 = $conditionals['B1,B2,B3'][0];
self::assertSame(Conditional::CONDITION_CELLIS, $cond1->getConditionType());
self::assertSame(Conditional::OPERATOR_BETWEEN, $cond1->getOperatorType());
self::assertSame(['2', '3'], $cond1->getConditions());
$font1 = $cond1->getStyle()->getFont();
self::assertTrue($font1->getBold());
$robj->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/PropertiesTest.php | tests/PhpSpreadsheetTests/Reader/Xlsx/PropertiesTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use DateTimeZone;
use PhpOffice\PhpSpreadsheet\Document\Properties;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\Shared\Date;
use PhpOffice\PhpSpreadsheetTests\Functional\AbstractFunctional;
class PropertiesTest extends AbstractFunctional
{
public function testLoadXlsxWorkbookProperties(): void
{
$customPropertySet = [
'Publisher' => ['type' => Properties::PROPERTY_TYPE_STRING, 'value' => 'PHPOffice Suite'],
'Tested' => ['type' => Properties::PROPERTY_TYPE_BOOLEAN, 'value' => true],
'Counter' => ['type' => Properties::PROPERTY_TYPE_INTEGER, 'value' => 15],
'Rate' => ['type' => Properties::PROPERTY_TYPE_FLOAT, 'value' => 1.15],
'Refactor Date' => ['type' => Properties::PROPERTY_TYPE_DATE, 'value' => '2019-06-10'],
];
$filename = 'tests/data/Reader/XLSX/propertyTest.xlsx';
$reader = new Xlsx();
$spreadsheet = $reader->load($filename);
$properties = $spreadsheet->getProperties();
// Core Properties
self::assertSame('Mark Baker', $properties->getCreator());
self::assertSame('Unit Testing', $properties->getTitle());
self::assertSame('Property Test', $properties->getSubject());
// Extended Properties
self::assertSame('PHPOffice', $properties->getCompany());
self::assertSame('The Big Boss', $properties->getManager());
// Custom Properties
$customProperties = $properties->getCustomProperties();
$customProperties = array_flip($customProperties);
self::assertArrayHasKey('Publisher', $customProperties);
foreach ($customPropertySet as $propertyName => $testData) {
self::assertTrue($properties->isCustomPropertySet($propertyName));
self::assertSame($testData['type'], $properties->getCustomPropertyType($propertyName));
/** @var float|int */
$result = $properties->getCustomPropertyValue($propertyName);
if ($properties->getCustomPropertyType($propertyName) == Properties::PROPERTY_TYPE_DATE) {
$result = Date::formattedDateTimeFromTimestamp("$result", 'Y-m-d', new DateTimeZone('UTC'));
}
self::assertSame($testData['value'], $result);
}
}
public function testReloadXlsxWorkbookProperties(): void
{
$customPropertySet = [
'Publisher' => ['type' => Properties::PROPERTY_TYPE_STRING, 'value' => 'PHPOffice Suite'],
'Tested' => ['type' => Properties::PROPERTY_TYPE_BOOLEAN, 'value' => true],
'Counter' => ['type' => Properties::PROPERTY_TYPE_INTEGER, 'value' => 15],
'Rate' => ['type' => Properties::PROPERTY_TYPE_FLOAT, 'value' => 1.15],
'Refactor Date' => ['type' => Properties::PROPERTY_TYPE_DATE, 'value' => '2019-06-10'],
];
$filename = 'tests/data/Reader/XLSX/propertyTest.xlsx';
$reader = new Xlsx();
$spreadsheetOld = $reader->load($filename);
$spreadsheet = $this->writeAndReload($spreadsheetOld, 'Xlsx');
$properties = $spreadsheet->getProperties();
// Core Properties
self::assertSame('Mark Baker', $properties->getCreator());
self::assertSame('Unit Testing', $properties->getTitle());
self::assertSame('Property Test', $properties->getSubject());
// Extended Properties
self::assertSame('PHPOffice', $properties->getCompany());
self::assertSame('The Big Boss', $properties->getManager());
// Custom Properties
$customProperties = $properties->getCustomProperties();
$customProperties = array_flip($customProperties);
self::assertArrayHasKey('Publisher', $customProperties);
foreach ($customPropertySet as $propertyName => $testData) {
self::assertTrue($properties->isCustomPropertySet($propertyName));
self::assertSame($testData['type'], $properties->getCustomPropertyType($propertyName));
/** @var float|int */
$result = $properties->getCustomPropertyValue($propertyName);
if ($properties->getCustomPropertyType($propertyName) == Properties::PROPERTY_TYPE_DATE) {
$result = Date::formattedDateTimeFromTimestamp("$result", 'Y-m-d', new DateTimeZone('UTC'));
}
self::assertSame($testData['value'], $result);
}
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/NamespaceIssue2109bTest.php | tests/PhpSpreadsheetTests/Reader/Xlsx/NamespaceIssue2109bTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\Worksheet\Worksheet;
class NamespaceIssue2109bTest extends \PHPUnit\Framework\TestCase
{
private static string $testbook = 'tests/data/Reader/XLSX/issue2109b.xlsx';
public function testPreliminaries(): void
{
$file = 'zip://';
$file .= self::$testbook;
$file .= '#xl/workbook.xml';
$data = file_get_contents($file);
// confirm that file contains expected namespaced xml tag
if ($data === false) {
self::fail('Unable to read file');
} else {
self::assertStringContainsString('<x:workbook ', $data);
}
}
public function testInfo(): void
{
$reader = new Xlsx();
$workSheetInfo = $reader->listWorkSheetInfo(self::$testbook);
$info0 = $workSheetInfo[0];
self::assertEquals('Sheet1', $info0['worksheetName']);
self::assertEquals('AF', $info0['lastColumnLetter']);
self::assertEquals(31, $info0['lastColumnIndex']);
self::assertEquals(4, $info0['totalRows']);
self::assertEquals(32, $info0['totalColumns']);
}
public function testSheetNames(): void
{
$reader = new Xlsx();
$worksheetNames = $reader->listWorksheetNames(self::$testbook);
self::assertEquals(['Sheet1'], $worksheetNames);
}
public function testActive(): void
{
$reader = new Xlsx();
$spreadsheet = $reader->load(self::$testbook);
$sheet = $spreadsheet->getActiveSheet();
self::assertSame('Sheet1', $sheet->getTitle());
self::assertNull($sheet->getFreezePane());
self::assertNull($sheet->getTopLeftCell());
self::assertSame('A1', $sheet->getSelectedCells());
$spreadsheet->disconnectWorksheets();
}
private static function getCellValue(Worksheet $sheet, string $cell): string
{
$result = $sheet->getCell($cell)->getValue();
if (is_scalar($result) || (is_object($result) && method_exists($result, '__toString'))) {
return (string) $result;
}
return '';
}
public function testLoadXlsx(): void
{
$reader = new Xlsx();
$spreadsheet = $reader->load(self::$testbook);
$sheet = $spreadsheet->getSheet(0);
self::assertEquals('Sheet1', $sheet->getTitle());
$expectedArray = [
'A1' => 'Channel Name = Cartoon Network RSE',
'B2' => 'Event ID',
'C3' => '2021-05-17 03:00',
'F4' => 'The Internet',
'AF3' => '902476',
'AF4' => '902477',
'J2' => 'Episode Synopsis',
'J3' => 'Gumball and Darwin\'s reputation is challenged and they really couldn\'t care less...',
'J4' => 'Gumball accidentally uploads a video of himself and wants it gone.',
];
foreach ($expectedArray as $key => $value) {
self::assertSame($value, self::getCellValue($sheet, $key), "error in cell $key");
}
$spreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/Issue3126Test.php | tests/PhpSpreadsheetTests/Reader/Xlsx/Issue3126Test.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx as XlsxReader;
use PhpOffice\PhpSpreadsheet\Shared\File;
use PhpOffice\PhpSpreadsheet\Writer\Xlsx as XlsxWriter;
use PHPUnit\Framework\TestCase;
class Issue3126Test extends TestCase
{
public function testReloadXlsxWorkbookProperties(): void
{
$filename = 'tests/data/Reader/XLSX/issue.3126.xlsx';
$reader = new XlsxReader();
$generation1 = $reader->load($filename);
$gen1sheet = $generation1->getActiveSheet();
$gen1hf = $gen1sheet->getHeaderFooter();
$gen1Images = $gen1hf->getImages();
self::assertCount(1, $gen1Images);
$gen1hfName = array_key_exists('LF', $gen1Images) ? $gen1Images['LF']->getName() : '';
self::assertSame('fleche-verte-up-right', $gen1hfName);
/** @var mixed[][][][][] */
$unparsedLoadedData = $generation1->getUnparsedLoadedData();
/** @var string */
$pageSetupRel = $unparsedLoadedData['sheets']['Worksheet']['pageSetupRelId'] ?? '';
self::assertSame('rId1ps', $pageSetupRel);
$pageSetupPath = $unparsedLoadedData['sheets']['Worksheet']['printerSettings'][substr($pageSetupRel, 3)]['filePath'] ?? '';
self::assertSame('xl/printerSettings/printerSettings1.bin', $pageSetupPath);
$generation2Name = File::temporaryFilename();
$writer = new XlsxWriter($generation1);
$writer->save($generation2Name);
$generation1->disconnectWorksheets();
$reader2 = new XlsxReader();
$generation2 = $reader2->load($generation2Name);
$gen2sheet = $generation2->getActiveSheet();
$gen2hf = $gen2sheet->getHeaderFooter();
$gen2Images = $gen2hf->getImages();
self::assertCount(1, $gen2Images);
$gen2hfName = array_key_exists('LF', $gen2Images) ? $gen2Images['LF']->getName() : '';
self::assertSame('fleche-verte-up-right', $gen2hfName);
/** @var mixed[][][][][] */
$unparsedLoadedData = $generation2->getUnparsedLoadedData();
/** @var string */
$pageSetupRel = $unparsedLoadedData['sheets']['Worksheet']['pageSetupRelId'] ?? '';
self::assertSame('rId1ps', $pageSetupRel);
$pageSetupPath = $unparsedLoadedData['sheets']['Worksheet']['printerSettings'][substr($pageSetupRel, 3)]['filePath'] ?? '';
self::assertSame('xl/printerSettings/printerSettings1.bin', $pageSetupPath);
$generation3Name = File::temporaryFilename();
$writer = new XlsxWriter($generation2);
$writer->setUseDiskCaching(true, sys_get_temp_dir());
$writer->save($generation3Name);
$generation2->disconnectWorksheets();
$reader3 = new XlsxReader();
$generation3 = $reader3->load($generation3Name);
$gen3sheet = $generation3->getActiveSheet();
$gen3hf = $gen3sheet->getHeaderFooter();
$gen3Images = $gen3hf->getImages();
self::assertCount(1, $gen3Images);
$gen3hfName = array_key_exists('LF', $gen3Images) ? $gen3Images['LF']->getName() : '';
self::assertSame('fleche-verte-up-right', $gen3hfName);
/** @var mixed[][][][][] */
$unparsedLoadedData = $generation3->getUnparsedLoadedData();
/** @var string */
$pageSetupRel = $unparsedLoadedData['sheets']['Worksheet']['pageSetupRelId'] ?? '';
self::assertSame('rId1ps', $pageSetupRel);
$pageSetupPath = $unparsedLoadedData['sheets']['Worksheet']['printerSettings'][substr($pageSetupRel, 3)]['filePath'] ?? '';
self::assertSame('xl/printerSettings/printerSettings1.bin', $pageSetupPath);
unlink($generation2Name);
unlink($generation3Name);
$generation3->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/NamedRangeTest.php | tests/PhpSpreadsheetTests/Reader/Xlsx/NamedRangeTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx;
use PHPUnit\Framework\TestCase;
class NamedRangeTest extends TestCase
{
public static function testBug1686b(): void
{
$xlsxFile = 'tests/data/Reader/XLSX/bug1686b.xlsx';
$reader = new Xlsx();
$spreadsheet = $reader->load($xlsxFile);
$sheet = $spreadsheet->getActiveSheet();
self::assertEquals(2.1, $sheet->getCell('A1')->getCalculatedValue());
self::assertEquals('#REF!', $sheet->getCell('A2')->getCalculatedValue());
self::assertEquals('#REF!', $sheet->getCell('A3')->getCalculatedValue());
self::assertEquals('#NAME?', $sheet->getCell('A4')->getCalculatedValue());
self::assertEquals('#REF!', $sheet->getCell('A5')->getCalculatedValue());
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/Issue4416Filter.php | tests/PhpSpreadsheetTests/Reader/Xlsx/Issue4416Filter.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\Reader\IReadFilter;
class Issue4416Filter implements IReadFilter
{
public function readCell(string $columnAddress, int $row, string $worksheetName = ''): bool
{
$allowedColumns = ['A', 'B', 'C', 'D'];
$allowedRows = range(1, 5);
return in_array($columnAddress, $allowedColumns, true) && in_array($row, $allowedRows, true);
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/Issue2362Test.php | tests/PhpSpreadsheetTests/Reader/Xlsx/Issue2362Test.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\IOFactory;
use PhpOffice\PhpSpreadsheet\RichText\RichText;
use PHPUnit\Framework\TestCase;
use ZipArchive;
class Issue2362Test extends TestCase
{
public function testPreliminaries(): void
{
// ZipArchive says file is 'inconsistent',
// but Excel has no problem with it.
$filename = 'tests/data/Reader/XLSX/issue.2362.xlsx';
$zip = new ZipArchive();
$res = $zip->open($filename, ZipArchive::CHECKCONS);
self::assertSame(ZipArchive::ER_INCONS, $res);
}
public function testIssue2362(): void
{
$filename = 'tests/data/Reader/XLSX/issue.2362.xlsx';
$reader = IOFactory::createReader('Xlsx');
$spreadsheet = $reader->load($filename);
$sheet = $spreadsheet->getActiveSheet();
$value = $sheet->getCell('A1')->getValue();
if ($value instanceof RichText) {
self::assertSame('Дата', (string) $value);
} else {
self::fail('A1 is not RichText');
}
$value = $sheet->getCell('D21')->getValue();
if ($value instanceof RichText) {
self::assertSame('391800, Рязанская область, г. Скопин, ул. Ленина, д. 40', (string) $value);
} else {
self::fail('D21 is not RichText');
}
$spreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/ExplicitDateTest.php | tests/PhpSpreadsheetTests/Reader/Xlsx/ExplicitDateTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\IOFactory;
class ExplicitDateTest extends \PHPUnit\Framework\TestCase
{
private static string $testbook = 'tests/data/Reader/XLSX/explicitdate.xlsx';
public function testPreliminaries(): void
{
$file = 'zip://';
$file .= self::$testbook;
$file .= '#xl/worksheets/sheet1.xml';
$data = file_get_contents($file);
if ($data === false) {
self::fail('Unable to read file');
} else {
// confirm that file contains type "d" cells
self::assertStringContainsString('<c r="A3" s="1" t="d"><v>2021-12-31T23:44:51.894</v></c>', $data);
self::assertStringContainsString('<c r="B3" s="2" t="d"><v>2021-12-31</v></c>', $data);
self::assertStringContainsString('<c r="C3" s="3" t="d"><v>23:44:51.894</v></c>', $data);
}
}
public static function testExplicitDate(): void
{
$spreadsheet = IOFactory::load(self::$testbook);
$sheet = $spreadsheet->getActiveSheet();
// DateTime
$value = $sheet->getCell('A3')->getValue();
$formatted = $sheet->getCell('A3')->getFormattedValue();
self::assertEqualsWithDelta(44561.98948, $value, 0.00001);
self::assertSame('2021-12-31 23:44:52', $formatted);
// Date only
$value = $sheet->getCell('B3')->getValue();
$formatted = $sheet->getCell('B3')->getFormattedValue();
self::assertEquals(44561, $value);
self::assertSame('2021-12-31', $formatted);
// Time only
$value = $sheet->getCell('C3')->getValue();
$formatted = $sheet->getCell('C3')->getFormattedValue();
self::assertEqualsWithDelta(0.98948, $value, 0.00001);
self::assertSame('23:44:52', $formatted);
$spreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/ChartSheetTest.php | tests/PhpSpreadsheetTests/Reader/Xlsx/ChartSheetTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx;
use PHPUnit\Framework\TestCase;
class ChartSheetTest extends TestCase
{
public function testLoadChartSheetWithCharts(): void
{
$filename = 'tests/data/Reader/XLSX/ChartSheet.xlsx';
$reader = new Xlsx();
$reader->setIncludeCharts(true);
$spreadsheet = $reader->load($filename);
self::assertCount(2, $spreadsheet->getAllSheets());
$chartSheet = $spreadsheet->getSheetByNameOrThrow('Chart1');
self::assertSame(1, $chartSheet->getChartCount());
}
public function testLoadChartSheetWithoutCharts(): void
{
$filename = 'tests/data/Reader/XLSX/ChartSheet.xlsx';
$reader = new Xlsx();
$reader->setIncludeCharts(false);
$spreadsheet = $reader->load($filename);
self::assertCount(1, $spreadsheet->getAllSheets());
self::assertNull($spreadsheet->getSheetByName('Chart1'));
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Reader/Xlsx/Issue3982Test.php | tests/PhpSpreadsheetTests/Reader/Xlsx/Issue3982Test.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\IOFactory;
use PhpOffice\PhpSpreadsheet\Reader\IReader;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx as XlsxReader;
use PHPUnit\Framework\TestCase;
class Issue3982Test extends TestCase
{
private static string $testbook = 'tests/data/Reader/XLSX/issue.3982.xlsx';
/**
* This routine comes nowhere close to out-of-memory (uses 45MB).
* Yet it goes out of memory in PhpUnit 10 (uses 2GB!).
* Works fine in PhpUnit9-.
* We can mitigate the problem by changing entirely-null rows
* to empty rows in rangeToArrayYieldRows. (uses 455MB).
* That's a breaking change, but might be worth considering.
*/
public function testLoadAllRows(): void
{
if (!method_exists(TestCase::class, 'setOutputCallback')) {
self::markTestSkipped('Memory loop in Phpunit 10');
}
$spreadsheet = IOFactory::load(self::$testbook);
$sheet = $spreadsheet->getActiveSheet();
$data = $sheet->toArray(null, true, false, true);
self::assertCount(1048576, $data);
$spreadsheet->disconnectWorksheets();
}
public function testIgnoreCellsWithNoRows(): void
{
$spreadsheet = IOFactory::load(self::$testbook, IReader::IGNORE_ROWS_WITH_NO_CELLS);
$sheet = $spreadsheet->getActiveSheet();
$data = $sheet->toArray(null, true, false, true);
self::assertSame([1, 2, 3, 4, 5, 6], array_keys($data));
$spreadsheet->disconnectWorksheets();
}
public function testDefaultSetting(): void
{
$reader = new XlsxReader();
self::assertFalse($reader->getIgnoreRowsWithNoCells());
self::assertFalse($reader->getReadDataOnly());
self::assertFalse($reader->getIncludeCharts());
self::assertTrue($reader->getReadEmptyCells());
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.