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/Writer/Html/HtmlDifferentConditionalFormattingsTest.php | tests/PhpSpreadsheetTests/Writer/Html/HtmlDifferentConditionalFormattingsTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Html;
use PhpOffice\PhpSpreadsheet\Cell\Coordinate;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx as XlsxReader;
use PhpOffice\PhpSpreadsheet\Writer\Html as HtmlWriter;
use PHPUnit\Framework\TestCase;
class HtmlDifferentConditionalFormattingsTest extends TestCase
{
private string $data = '';
protected function setUp(): void
{
$file = 'samples/templates/ConditionalFormattingConditions.xlsx';
$reader = new XlsxReader();
$spreadsheet = $reader->load($file);
$writer = new HtmlWriter($spreadsheet);
$writer->setConditionalFormatting(true);
$this->data = $writer->generateHtmlAll();
$spreadsheet->disconnectWorksheets();
}
private function extractCell(string $coordinate): string
{
[$column, $row] = Coordinate::indexesFromString($coordinate);
--$column;
--$row;
// extract row into $matches
$match = preg_match('~<tr class="row' . $row . '".+?</tr>~s', $this->data, $matches);
if ($match !== 1) {
return 'unable to match row';
}
$rowData = $matches[0];
// extract cell into $matches
$match = preg_match('~<td class="column' . $column . ' .+?</td>~s', $rowData, $matches);
if ($match !== 1) {
return 'unable to match column';
}
return $matches[0];
}
public function testConditionalFormattingRulesHtml(): void
{
$expectedMatches = [
['A1', 'background-color:#B7E1CD;">1<', 'A1 equals hit'],
['B1', 'class="column1 style1 n">2<', 'B1 equals miss'],
['E1', 'background-color:#B7E1CD;">1<', 'E1 equals horizontal reference hit'],
['F1', 'class="column5 style1 n">2<', 'F1 equals horizontal reference miss'],
['G1', 'class="column6 style1 n">3<', 'G1 equals horizontal reference miss'],
['A2', 'background-color:#B7E1CD;">terve<', 'A2 text contains hit'],
['B2', 'class="column1 style1 s">moi<', 'B2 text contains miss'],
['A3', 'background-color:#B7E1CD;">terve<', 'A3 text does not contain hit'],
['B3', 'class="column1 style1 s">moi<', 'B2 text does not contain miss'],
['A4', 'background-color:#B7E1CD;">terve<', 'A4 text starts with hit'],
['B4', 'class="column1 style1 s">moi<', 'B2 text starts with miss'],
['A5', 'background-color:#B7E1CD;">terve<', 'A5 text ends with hit'],
['B5', 'class="column1 style1 s">moi<', 'B5 text ends with miss'],
['A6', 'background-color:#B7E1CD;">2025/01/01<', 'A6 date after hit'],
['B6', 'class="column1 style2 n">2020/01/01<', 'B6 date after miss'],
['A7', 'background-color:#B7E1CD;">terve vaan<', 'A7 text contains hit'],
['B7', 'class="column1 style1 s">moi<', 'B7 text contains miss'],
['A8', 'background-color:#B7E1CD;">terve<', 'A8 text does not contain hit'],
['B8', 'class="column1 style1 s">terve vaan<', 'B2 does not contain miss'],
['A9', 'background-color:#B7E1CD;">#DIV/0!<', 'A10 own formula is error hit'],
['B9', 'class="column1 style1 s">moi<', 'B9 own formula is error miss'],
['A10', 'background-color:#B7E1CD;">moi<', 'A10 own formula is not error hit'],
['B10', 'class="column1 style3 s">#DIV/0!<', 'B10 own formula is not error miss'],
['A11', 'background-color:#B7E1CD;">terve<', 'A11 own formula count instances of cell on line and hit when more than one hit'],
['B11', 'background-color:#B7E1CD;">terve<', 'B11 own formula count instances of cell on line and hit when more than one hit'],
['C11', 'class="column2 style1 s">moi<', 'C11 own formula count instances of cell on line and hit when more than one miss'],
['A12', 'background-color:#B7E1CD;">moi<', 'A12 own formula count instances of cell on line and hit when at most 1 hit'],
['B12', 'class="column1 style1 s">terve<', 'B12 own formula count instances of cell on line and hit when at most 1 miss'],
['C12', 'class="column2 style1 s">terve<', 'C11 own formula count instances of cell on line and hit when at most 1 miss'],
['A13', 'background-color:#B7E1CD;">12<', 'A13 own formula self reference hit'],
['B13', 'class="column1 style1 n">10<', 'B13 own formula self reference miss'],
['A14', 'background-color:#B7E1CD;">10<', 'A14 multiple conditional hits'],
['B14', 'class="column1 style1 n">1<', 'B14 multiple conditionals miss'],
['F7', 'background-color:#B7E1CD;">1<', 'F7 equals vertical reference hit'],
['F8', 'class="column5 style1 n">2<', 'F8 equals vertical reference miss'],
['F9', 'class="column5 style1 n">3<', 'F9 equals vertical reference miss'],
['F10', 'class="column5 style1 n">4<', 'F10 equals vertical reference miss'],
];
foreach ($expectedMatches as $expected) {
[$coordinate, $expectedString, $message] = $expected;
$string = $this->extractCell($coordinate);
self::assertStringContainsString($expectedString, $string, $message);
}
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Html/HideTest.php | tests/PhpSpreadsheetTests/Writer/Html/HideTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Html;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Writer\Html;
use PHPUnit\Framework\TestCase;
class HideTest extends TestCase
{
public function testHide(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->fromArray([
['a1', 'b1', 'c1', 'd1', 'e1', 'f1'],
['a2', 'b2', 'c2', 'd2', 'e2', 'f2'],
['a3', 'b3', 'c3', 'd3', 'e3', 'f3'],
['a4', 'b4', 'c4', 'd4', 'e4', 'f4'],
['a5', 'b5', 'c5', 'd5', 'e5', 'f5'],
['a6', 'b6', 'c6', 'd6', 'e6', 'f6'],
]);
$sheet->getColumnDimension('B')->setVisible(false);
$sheet->getRowDimension(3)->setVisible(false);
$writer = new Html($spreadsheet);
$html = $writer->generateHtmlAll();
self::assertStringContainsString('table.sheet0 .column1 { display:none }', $html);
self::assertStringContainsString('table.sheet0 tr.row2 { display:none; visibility:hidden }', $html);
self::assertStringContainsString('.navigation {display: none;}', $html);
$count = substr_count($html, 'display:none');
self::assertSame(3, $count);
$spreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Html/HtmlConditionalFormattingTest.php | tests/PhpSpreadsheetTests/Writer/Html/HtmlConditionalFormattingTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Html;
use PhpOffice\PhpSpreadsheet\Cell\Coordinate;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx as XlsxReader;
use PhpOffice\PhpSpreadsheet\Writer\Html as HtmlWriter;
use PHPUnit\Framework\TestCase;
class HtmlConditionalFormattingTest extends TestCase
{
private string $data = '';
protected function setUp(): void
{
$file = 'samples/templates/BasicConditionalFormatting.xlsx';
$reader = new XlsxReader();
$spreadsheet = $reader->load($file);
$writer = new HtmlWriter($spreadsheet);
$writer->setConditionalFormatting(true);
$this->data = $writer->generateHtmlAll();
$spreadsheet->disconnectWorksheets();
}
private function extractCell(string $coordinate): string
{
[$column, $row] = Coordinate::indexesFromString($coordinate);
--$column;
--$row;
// extract row into $matches
$match = preg_match('~<tr class="row' . $row . '".+?</tr>~s', $this->data, $matches);
if ($match !== 1) {
return 'unable to match row';
}
$rowData = $matches[0];
// extract cell into $matches
$match = preg_match('~<td class="column' . $column . ' .+?</td>~s', $rowData, $matches);
if ($match !== 1) {
return 'unable to match column';
}
return $matches[0];
}
public function testConditionalFormattingHtmLOutput(): void
{
$expectedMatches = [
['B1', 'class="column1 style1 s">Jan<', 'no conditional styling for B1'],
['F2', 'background-color:#C6EFCE;">120<', 'conditional style for F2'],
['H2', 'background-color:#FFEB9C;">90<', 'conditional style for H2'],
['F3', 'background-color:#C6EFCE;">70<', 'conditional style for cell F3'],
['H3', 'background-color:#FFEB9C;">60<', 'conditional style for cell H3'],
['F4', 'background-color:#C6EFCE;">1<', 'conditional style for cell F4'],
['L4', 'background-color:#FFC7CE;">5<', 'conditional style for cell L4'],
['F5', 'class="column5 style1 n">0<', 'no conditional styling for F5'],
];
foreach ($expectedMatches as $expected) {
[$coordinate, $expectedString, $message] = $expected;
$string = $this->extractCell($coordinate);
self::assertStringContainsString($expectedString, $string, $message);
}
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Html/Issue3678Test.php | tests/PhpSpreadsheetTests/Writer/Html/Issue3678Test.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Html;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Style\Fill;
use PhpOffice\PhpSpreadsheet\Writer\Html;
use PHPUnit\Framework\TestCase;
class Issue3678Test extends TestCase
{
public function testInlineAndNot(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->setShowGridlines(false);
$sheet->setPrintGridlines(true);
$sheet->getCell('A1')->setValue(1);
$styleArray = [
'fill' => [
'fillType' => Fill::FILL_SOLID,
'color' => ['rgb' => 'FFFF00'],
],
];
$sheet->getStyle('A1')->applyFromArray($styleArray);
$style1 = "vertical-align:bottom; border-bottom:none #000000; border-top:none #000000; border-left:none #000000; border-right:none #000000; color:#000000; font-family:'Calibri'; font-size:11pt; background-color:#FFFF00";
$style2 = "vertical-align:bottom; color:#000000; font-family:'Calibri'; font-size:11pt; background-color:#FFFF00";
$style2 .= '; text-align:right; width:42pt';
$writer = new Html($spreadsheet);
$html = $writer->generateHtmlAll();
self::assertStringContainsString('td.style1, th.style1 { ' . $style1 . ' }', $html);
self::assertStringContainsString('<td class="column0 style1 n">1</td>', $html);
self::assertStringContainsString('table.sheet0 col.col0 { width:42pt }', $html);
self::assertStringContainsString('.n { text-align:right }', $html);
$writer->setUseInlineCss(true);
$html = $writer->generateHtmlAll();
self::assertStringContainsString('<td class="gridlinesp" style="' . $style2 . '">1</td>', $html);
$sheet->setPrintGridlines(false);
$html = $writer->generateHtmlAll();
self::assertStringContainsString('<td style="' . $style2 . '">1</td>', $html);
$spreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Html/HtmlExtend2.php | tests/PhpSpreadsheetTests/Writer/Html/HtmlExtend2.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Html;
class HtmlExtend2 extends \PhpOffice\PhpSpreadsheet\Writer\Html
{
protected static bool $alwaysFalse = false;
protected function tryClose(): bool
{
return fclose($this->fileHandle) && self::$alwaysFalse;
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Html/HtmlTableFormatTest.php | tests/PhpSpreadsheetTests/Writer/Html/HtmlTableFormatTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Html;
use PhpOffice\PhpSpreadsheet\Cell\Coordinate;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx as XlsxReader;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Worksheet\Table;
use PhpOffice\PhpSpreadsheet\Worksheet\Table\TableStyle;
use PhpOffice\PhpSpreadsheet\Writer\Html as HtmlWriter;
use PHPUnit\Framework\TestCase;
class HtmlTableFormatTest extends TestCase
{
private string $data = '';
private function extractCell(string $coordinate): string
{
[$column, $row] = Coordinate::indexesFromString($coordinate);
--$column;
--$row;
// extract row into $matches
$match = preg_match('~<tr class="row' . $row . '".+?</tr>~s', $this->data, $matches);
if ($match !== 1) {
return 'unable to match row';
}
$rowData = $matches[0];
// extract cell into $matches
$match = preg_match('~<td class="column' . $column . ' .+?</td>~s', $rowData, $matches);
if ($match !== 1) {
return 'unable to match column';
}
return $matches[0];
}
public function testHtmlTableFormatOutput(): void
{
$file = 'samples/templates/TableFormat.xlsx';
$reader = new XlsxReader();
$spreadsheet = $reader->load($file);
$writer = new HtmlWriter($spreadsheet);
$writer->setTableFormats(true);
self::assertTrue($writer->getTableFormats());
$this->data = $writer->generateHtmlAll();
$spreadsheet->disconnectWorksheets();
$expectedMatches = [
['J1', 'background-color:#145F82;">Sep<', 'table style for header row cell J1'],
['J2', 'background-color:#C0E4F5;">110<', 'table style for cell J2'],
['I3', 'background-color:#82CAEB;">70<', 'table style for cell I3'],
['J3', 'background-color:#82CAEB;">70<', 'table style for cell J3'], // as conditional calculations are off
['K3', 'background-color:#82CAEB;">70<', 'table style for cell K3'],
['J4', 'background-color:#C0E4F5;">1<', 'table style for cell J4'],
['J5', 'background-color:#82CAEB;">1<', 'table style for cell J5'],
];
foreach ($expectedMatches as $expected) {
[$coordinate, $expectedString, $message] = $expected;
$string = $this->extractCell($coordinate);
self::assertStringContainsString($expectedString, $string, $message);
}
$spreadsheet->disconnectWorksheets();
}
public function testBuiltinApplied(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$dataArray = [
['Year', 'Quarter', 'Country', 'Sales'],
['2010', 'Q1', 'United States', 790],
['2010', 'Q2', 'United States', 730],
['2010', 'Q3', 'United States', 860],
['2010', 'Q4', 'United States', 850],
];
$sheet->fromArray($dataArray);
$table = new Table('A1:D5', 'Sales_Data');
$tableStyle = new TableStyle();
$tableStyle->setTheme(TableStyle::TABLE_STYLE_MEDIUM2);
$tableStyle->setShowRowStripes(true);
$tableStyle->setShowColumnStripes(true);
$tableStyle->setShowFirstColumn(true);
$tableStyle->setShowLastColumn(true);
$table->setStyle($tableStyle);
$sheet->addTable($table);
$writer = new HtmlWriter($spreadsheet);
$writer->setTableFormats(true); // format all tables using a default style for unstyled
$this->data = $writer->generateHtmlAll();
$expectedMatches = [
['A1', '<td class="column0 style0 s" style="color:#FFFFFF;background-color:#000000;">Year</td>', 'table style for header row cell A1'],
['B2', '<td class="column1 style0 s" style="color:#000000;background-color:#D9D9D9;">Q1</td>', 'table style for cell B2'],
['C3', '<td class="column2 style0 s">United States</td>', 'table style for cell C3'],
];
foreach ($expectedMatches as $expected) {
[$coordinate, $expectedString, $message] = $expected;
$string = $this->extractCell($coordinate);
self::assertStringContainsString($expectedString, $string, $message);
}
$spreadsheet->disconnectWorksheets();
}
public function testBuiltinNotApplied(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$dataArray = [
['Year', 'Quarter', 'Country', 'Sales'],
['2010', 'Q1', 'United States', 790],
['2010', 'Q2', 'United States', 730],
['2010', 'Q3', 'United States', 860],
['2010', 'Q4', 'United States', 850],
];
$sheet->fromArray($dataArray);
$table = new Table('A1:D5', 'Sales_Data');
$tableStyle = new TableStyle();
$tableStyle->setTheme(TableStyle::TABLE_STYLE_MEDIUM2);
$tableStyle->setShowRowStripes(true);
$tableStyle->setShowColumnStripes(true);
$tableStyle->setShowFirstColumn(true);
$tableStyle->setShowLastColumn(true);
$table->setStyle($tableStyle);
$sheet->addTable($table);
$writer = new HtmlWriter($spreadsheet);
$writer->setTableFormats(true, false); // format styled tables but not unstyled
$this->data = $writer->generateHtmlAll();
$expectedMatches = [
['A1', '<td class="column0 style0 s">Year</td>', 'table style for header row cell A1'],
['B2', '<td class="column1 style0 s">Q1</td>', 'table style for cell B2'],
['C3', '<td class="column2 style0 s">United States</td>', 'table style for cell C3'],
];
foreach ($expectedMatches as $expected) {
[$coordinate, $expectedString, $message] = $expected;
$string = $this->extractCell($coordinate);
self::assertStringContainsString($expectedString, $string, $message);
}
$spreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Html/NoTitleTest.php | tests/PhpSpreadsheetTests/Writer/Html/NoTitleTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Html;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx as XlsxReader;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Style\Border;
use PhpOffice\PhpSpreadsheet\Writer\Html;
use PHPUnit\Framework\TestCase;
class NoTitleTest extends TestCase
{
public function testNoTitle(): void
{
$file = 'tests/data/Reader/XLSX/blankcell.xlsx';
$reader = new XlsxReader();
$spreadsheet = $reader->load($file);
self::assertSame('', $spreadsheet->getProperties()->getTitle());
$writer = new Html($spreadsheet);
$writer->setUseInlineCss(true);
$html = $writer->generateHTMLAll();
self::assertStringContainsString('<title>Sheet1</title>', $html);
self::assertStringContainsString('<td class="gridlines" style="vertical-align:bottom; color:#000000; font-family:\'Calibri\'; font-size:11pt; text-align:left; width:42pt">C1</td>', $html);
$writer->setUseInlineCss(false);
$html = $writer->generateHTMLAll();
self::assertStringContainsString('<td class="column2 style0 s">C1</td>', $html);
$spreadsheet->disconnectWorksheets();
}
public function testHideSomeGridlines(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->fromArray(
[
[1, 2, 3, 4, 5, 6],
[7, 8, 9, 10, 11, 12],
[17, 18, 19, 20, 21, 22],
[27, 28, 29, 30, 31, 32],
[37, 38, 39, 40, 41, 42],
]
);
$sheet->getStyle('B2:D4')->getBorders()->applyFromArray(
[
'allBorders' => [
'borderStyle' => Border::BORDER_NONE,
'color' => ['rgb' => '808080'],
],
],
);
$writer = new Html($spreadsheet);
$writer->setUseInlineCss(true);
$html = $writer->generateHTMLAll();
self::assertStringContainsString('<td class="gridlines" style="vertical-align:bottom; color:#000000; font-family:\'Calibri\'; font-size:11pt; text-align:right; width:42pt">7</td>', $html);
self::assertStringContainsString('<td class="gridlines" style="vertical-align:bottom; border-bottom:none #808080; border-top:none #808080; border-left:none #808080; border-right:none #808080; color:#000000; font-family:\'Calibri\'; font-size:11pt; text-align:right; width:42pt">19</td>', $html);
$spreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Html/RepeatedRowsTest.php | tests/PhpSpreadsheetTests/Writer/Html/RepeatedRowsTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Html;
use DOMDocument;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Writer\Html;
use PhpOffice\PhpSpreadsheetTests\Functional;
class RepeatedRowsTest extends Functional\AbstractFunctional
{
public function testWriteRepeats(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->getPageSetup()->setRowsToRepeatAtTop([1, 2]);
$sheet->setCellValue('A1', 'Repeat1');
$sheet->setCellValue('A2', 'Repeat2');
for ($row = 3; $row <= 100; ++$row) {
$sheet->setCellValue("A$row", $row);
}
$writer = new Html($spreadsheet);
$html = $writer->generateHTMLall();
$dom = new DOMDocument();
$dom->loadHTML($html);
$body = $dom->getElementsByTagName('body')->item(0);
self::assertNotNull($body);
$divs = $body->getElementsByTagName('div');
$tbl = $divs->item(0)?->getElementsByTagName('table');
self::assertSame('', $tbl?->item(0)?->getAttribute('style'));
$thd = $divs->item(0)?->getElementsByTagName('thead');
self::assertCount(1, $thd);
$trw = $thd?->item(0)?->getElementsByTagName('tr');
self::assertCount(2, $trw);
$tbd = $divs->item(0)?->getElementsByTagName('tbody');
self::assertCount(1, $tbd);
$trw = $tbd?->item(0)?->getElementsByTagName('tr');
self::assertCount(98, $trw);
$rls = $this->writeAndReload($spreadsheet, 'Html');
$spreadsheet->disconnectWorksheets();
$rls->disconnectWorksheets();
}
public function testWriteNoRepeats(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
//$sheet->getPageSetup()->setRowsToRepeatAtTop([1, 2]);
$sheet->setCellValue('A1', 'Repeat1');
$sheet->setCellValue('A2', 'Repeat2');
for ($row = 3; $row <= 100; ++$row) {
$sheet->setCellValue("A$row", $row);
}
$writer = new Html($spreadsheet);
$html = $writer->generateHTMLall();
$dom = new DOMDocument();
$dom->loadHTML($html);
$body = $dom->getElementsByTagName('body')->item(0);
self::assertNotNull($body);
$divs = $body->getElementsByTagName('div');
$tbl = $divs->item(0)?->getElementsByTagName('table');
$thd = $tbl?->item(0)?->getElementsByTagName('thead');
self::assertCount(0, $thd);
//$trw = $thd->item(0)->getElementsByTagName('tr');
//self::assertCount(2, $trw);
$tbd = $divs->item(0)?->getElementsByTagName('tbody');
self::assertCount(1, $tbd);
$trw = $tbd?->item(0)?->getElementsByTagName('tr');
self::assertCount(100, $trw);
$rls = $this->writeAndReload($spreadsheet, 'Html');
$spreadsheet->disconnectWorksheets();
$rls->disconnectWorksheets();
}
public function testWriteRepeatsInline(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->getPageSetup()->setRowsToRepeatAtTop([1, 2]);
$sheet->setCellValue('A1', 'Repeat1');
$sheet->setCellValue('A2', 'Repeat2');
for ($row = 3; $row <= 100; ++$row) {
$sheet->setCellValue("A$row", $row);
}
$writer = new Html($spreadsheet);
self::assertFalse($writer->getUseInlineCss());
$writer->setUseInlineCss(true);
$html = $writer->generateHTMLall();
$dom = new DOMDocument();
$dom->loadHTML($html);
$body = $dom->getElementsByTagName('body')->item(0);
self::assertNotNull($body);
$divs = $body->getElementsByTagName('div');
$tbl = $divs->item(0)?->getElementsByTagName('table');
self::assertSame('border-collapse:collapse', $tbl?->item(0)?->getAttribute('style'));
$thd = $divs->item(0)?->getElementsByTagName('thead');
self::assertCount(1, $thd);
$trw = $thd?->item(0)?->getElementsByTagName('tr');
self::assertCount(2, $trw);
$tbd = $divs->item(0)?->getElementsByTagName('tbody');
self::assertCount(1, $tbd);
$trw = $tbd?->item(0)?->getElementsByTagName('tr');
self::assertCount(98, $trw);
$rls = $this->writeAndReload($spreadsheet, 'Html');
$spreadsheet->disconnectWorksheets();
$rls->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Html/HideMergeTest.php | tests/PhpSpreadsheetTests/Writer/Html/HideMergeTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Html;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Style\Alignment;
use PhpOffice\PhpSpreadsheet\Style\Border;
use PhpOffice\PhpSpreadsheet\Style\Color;
use PhpOffice\PhpSpreadsheet\Writer\Html;
use PHPUnit\Framework\TestCase;
class HideMergeTest extends TestCase
{
public function testHideWithMerge(): void
{
$spreadsheet = new Spreadsheet();
$worksheet = $spreadsheet->getActiveSheet();
// just some labels for better visualisation of the problem
$worksheet->setCellValue('A1', 'A');
$worksheet->setCellValue('B1', 'B');
$worksheet->setCellValue('C1', 'C');
// setting the row height to better visualize the problem
for ($i = 1; $i <= 10; ++$i) {
$worksheet->getRowDimension($i)->setRowHeight(17);
}
// Headline - merged over two cells AND two rows
$worksheet->mergeCells('B2:C3');
$worksheet->setCellValue('B2', 'Hello World Headline');
$worksheet->getStyle('B2:C3')->getFont()->setBold(true);
$worksheet->getStyle('B2:C3')
->getAlignment()
->setHorizontal(Alignment::HORIZONTAL_CENTER);
$worksheet->getStyle('B2:C3')
->getBorders()
->getAllBorders()
->setBorderStyle(Border::BORDER_THIN)
->setColor(new Color(Color::COLOR_BLACK));
// Content 1 - merge over two rows
$worksheet->mergeCells('B4:B5');
$worksheet->mergeCells('C4:C5');
$worksheet->setCellValue('B4', 'Label 1');
$worksheet->setCellValue('C4', 'Text 1');
$worksheet->getStyle('B4:B5')->getFont()->setBold(true);
$worksheet->getStyle('B4:C5')
->getAlignment()
->setVertical(Alignment::VERTICAL_CENTER);
$worksheet->getStyle('B4:B5')
->getBorders()
->getAllBorders()
->setBorderStyle(Border::BORDER_THIN)
->setColor(new Color(Color::COLOR_BLACK));
$worksheet->getStyle('C4:C5')
->getBorders()
->getAllBorders()
->setBorderStyle(Border::BORDER_THIN)
->setColor(new Color(Color::COLOR_BLACK));
// Content 2 - merge over two rows
$worksheet->mergeCells('B6:B7');
$worksheet->mergeCells('C6:C7');
$worksheet->setCellValue('B6', 'Label 2');
$worksheet->setCellValue('C6', 'Text 2');
$worksheet->getStyle('B6:B7')->getFont()->setBold(true);
$worksheet->getStyle('B6:C7')
->getAlignment()
->setVertical(Alignment::VERTICAL_CENTER);
$worksheet->getStyle('B6:B7')
->getBorders()
->getAllBorders()
->setBorderStyle(Border::BORDER_THIN)
->setColor(new Color(Color::COLOR_BLACK));
$worksheet->getStyle('C6:C7')
->getBorders()
->getAllBorders()
->setBorderStyle(Border::BORDER_THIN)
->setColor(new Color(Color::COLOR_BLACK));
// This is where the error was introduced (!!!)
$worksheet->getColumnDimension('A')->setVisible(false);
$Dompdf = new Html($spreadsheet);
$html = $Dompdf->generateHtmlAll();
$html = preg_replace('/^\s+/m', '', $html) ?? $html;
$html = preg_replace('/[\n\r]/', '', $html) ?? $html;
self::assertStringContainsString(
'table.sheet0 .column0 { display:none }',
$html
);
self::assertStringContainsString(
'<tr class="row0">'
. '<td class="column0 style0 s">A</td>'
. '<td class="column1 style0 s">B</td>'
. '<td class="column2 style0 s">C</td>'
. '</tr>',
$html
);
self::assertStringContainsString(
'<tr class="row1">'
. '<td class="column0 style0"> </td>'
. '<td class="column1 style1 s style1" colspan="2" rowspan="2">Hello World Headline</td>'
. '</tr>',
$html
);
self::assertStringContainsString(
'<tr class="row2">'
. '<td class="column0 style0"> </td>'
. '</tr>',
$html
);
self::assertStringContainsString(
'<tr class="row3">'
. '<td class="column0 style0"> </td>'
. '<td class="column1 style2 s style2" rowspan="2">Label 1</td>'
. '<td class="column2 style3 s style3" rowspan="2">Text 1</td>'
. '</tr>',
$html
);
self::assertStringContainsString(
'<tr class="row4">'
. '<td class="column0 style0"> </td>'
. '</tr>',
$html
);
self::assertStringContainsString(
'<tr class="row5">'
. '<td class="column0 style0"> </td>'
. '<td class="column1 style2 s style2" rowspan="2">Label 2</td>'
. '<td class="column2 style3 s style3" rowspan="2">Text 2</td>'
. '</tr>',
$html
);
self::assertStringContainsString(
'<tr class="row6">'
. '<td class="column0 style0"> </td>'
. '</tr>',
$html
);
$spreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Html/CallbackTest.php | tests/PhpSpreadsheetTests/Writer/Html/CallbackTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Html;
use PhpOffice\PhpSpreadsheet\Shared\File;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Writer\Html;
use PhpOffice\PhpSpreadsheetTests\Functional;
class CallbackTest extends Functional\AbstractFunctional
{
public function yellowBody(string $html): string
{
$newstyle = <<<EOF
<style type='text/css'>
body {
background-color: yellow;
}
</style>
EOF;
return preg_replace('~</head>~', "$newstyle</head>", $html) ?? '';
}
public function testSetAndReset(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->setCellValue('A1', '1');
$writer = new Html($spreadsheet);
$html1 = $writer->generateHTMLall();
$writer->setEditHtmlCallback([$this, 'yellowBody']);
$html2 = $writer->generateHTMLall();
$writer->setEditHtmlCallback(null);
$html3 = $writer->generateHTMLall();
self::assertFalse(strpos($html1, 'background-color: yellow'));
self::assertNotFalse(strpos($html2, 'background-color: yellow'));
self::assertFalse(strpos($html3, 'background-color: yellow'));
self::assertEquals($html3, $html1);
$writer->setEditHtmlCallback([$this, 'yellowBody']);
$oufil = File::temporaryFilename();
$writer->save($oufil);
$html4 = file_get_contents($oufil);
unlink($oufil);
self::assertNotFalse($html4);
self::assertNotFalse(strpos($html4, 'background-color: yellow'));
$this->writeAndReload($spreadsheet, 'Html');
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Html/MailtoTest.php | tests/PhpSpreadsheetTests/Writer/Html/MailtoTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Html;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Writer\Html as HtmlWriter;
use PHPUnit\Framework\TestCase;
class MailtoTest extends TestCase
{
public function testBadHyperlink(): void
{
$spreadsheet = new Spreadsheet();
$worksheet = $spreadsheet->getActiveSheet();
$worksheet->setCellValue('A1', 'Mail Me!');
$worksheet->getCell('A1')
->getHyperlink()
->setUrl('mailto:me@example.com');
$worksheet->setCellValue('A2', 'Mail You!');
$worksheet->getCell('A2')
->getHyperlink()
->setTooltip('go ahead')
->setUrl('mailto:you@example.com');
$writer = new HtmlWriter($spreadsheet);
$html = $writer->generateHtmlAll();
self::assertStringContainsString('<a href="mailto:me@example.com">Mail Me!</a>', $html);
self::assertStringContainsString('<a href="mailto:you@example.com" title="go ahead">Mail You!</a>', $html);
$spreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Html/MemoryDrawingOffsetTest.php | tests/PhpSpreadsheetTests/Writer/Html/MemoryDrawingOffsetTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Html;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Worksheet\MemoryDrawing;
use PhpOffice\PhpSpreadsheet\Writer\Html;
use PHPUnit\Framework\TestCase;
class MemoryDrawingOffsetTest extends TestCase
{
#[\PHPUnit\Framework\Attributes\DataProvider('dataProvider')]
public function testMemoryDrawingOffset(int $w, int $h, int $x, int $y): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$image = file_get_contents(__DIR__ . '/../../../data/Reader/HTML/memoryDrawingTest.jpg');
self::assertNotFalse($image, 'unable to read file');
$image = imagecreatefromstring($image);
self::assertNotFalse($image, 'unable to create image from string');
$drawing = new MemoryDrawing();
$drawing->setImageResource($image)
->setResizeProportional(false) //是否保持比例
->setWidthAndHeight($w, $h) //图片宽高,原始尺寸 100*100
->setOffsetX($x)
->setOffsetY($y)
->setWorksheet($sheet);
$writer = new Html($spreadsheet);
$html = $writer->generateHtmlAll();
self::assertStringContainsString('width:' . $w . 'px;left: ' . $x . 'px; top: ' . $y . 'px;position: absolute;', $html);
$spreadsheet->disconnectWorksheets();
unset($spreadsheet);
}
public static function dataProvider(): array
{
return [
[33, 19, 0, 20],
[129, 110, 12, -3],
[55, 110, 33, 42],
];
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Html/FixHeightTest.php | tests/PhpSpreadsheetTests/Writer/Html/FixHeightTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Html;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Writer\Html as Writer;
use PHPUnit\Framework\TestCase;
class FixHeightTest extends TestCase
{
public function testFixHeight(): void
{
$spreadsheet = new Spreadsheet();
//$sheet0 = $spreadsheet->getActiveSheet();
$sheet1 = $spreadsheet->createSheet();
$sheet2 = $spreadsheet->createSheet();
$sheet3 = $spreadsheet->createSheet();
$sheet1->getPageSetup()->setFitToHeight(1);
$sheet2->getPageSetup()->setFitToHeight(2);
$sheet3->getPageSetup()->setFitToPage(true);
$writer = new Writer($spreadsheet);
$writer->writeAllSheets();
$header = $writer->generateHTMLHeader(true);
self::assertStringContainsString('table.sheet0', $header);
self::assertStringContainsString('table.sheet1', $header);
self::assertStringContainsString('table.sheet2', $header);
self::assertStringContainsString('table.sheet3', $header);
$count = substr_count($header, 'break-inside');
self::assertSame(4, $count); // 2 for sheet1, 2 for sheet3
self::assertStringContainsString('table.sheet1 { page-break-inside:avoid; break-inside:avoid }', $header);
self::assertStringContainsString('table.sheet3 { page-break-inside:avoid; break-inside:avoid }', $header);
$spreadsheet->disconnectWorkSheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Html/BadHyperlinkBaseTest.php | tests/PhpSpreadsheetTests/Writer/Html/BadHyperlinkBaseTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Html;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx as XlsxReader;
use PhpOffice\PhpSpreadsheet\Writer\Html as HtmlWriter;
use PHPUnit\Framework\TestCase;
class BadHyperlinkBaseTest extends TestCase
{
public function testBadHyperlinkBase(): void
{
$reader = new XlsxReader();
$infile = 'tests/data/Reader/XLSX/sec-p66w.dontuse';
$spreadsheet = $reader->load($infile);
$writer = new HtmlWriter($spreadsheet);
$html = $writer->generateHtmlAll();
self::assertStringContainsString('<base href=""><img src=1 onerror=alert()>" />', $html);
$spreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Ods/ContentTest.php | tests/PhpSpreadsheetTests/Writer/Ods/ContentTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Ods;
use DOMDocument;
use DOMXPath;
use PhpOffice\PhpSpreadsheet\Calculation\Functions;
use PhpOffice\PhpSpreadsheet\Cell\DataType;
use PhpOffice\PhpSpreadsheet\Shared\Date;
use PhpOffice\PhpSpreadsheet\Shared\StringHelper;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Style\Border;
use PhpOffice\PhpSpreadsheet\Style\Color;
use PhpOffice\PhpSpreadsheet\Style\Fill;
use PhpOffice\PhpSpreadsheet\Style\Font;
use PhpOffice\PhpSpreadsheet\Style\NumberFormat;
use PhpOffice\PhpSpreadsheet\Worksheet\Worksheet;
use PhpOffice\PhpSpreadsheet\Writer\Ods;
use PhpOffice\PhpSpreadsheet\Writer\Ods\Content;
use PHPUnit\Framework\TestCase;
class ContentTest extends TestCase
{
private string $samplesPath = 'tests/data/Writer/Ods';
private string $compatibilityMode;
protected function setUp(): void
{
parent::setUp();
$this->compatibilityMode = Functions::getCompatibilityMode();
Functions::setCompatibilityMode(
Functions::COMPATIBILITY_OPENOFFICE
);
}
protected function tearDown(): void
{
parent::tearDown();
Functions::setCompatibilityMode($this->compatibilityMode);
}
public function testWriteEmptySpreadsheet(): void
{
$content = new Content(new Ods(new Spreadsheet()));
$xml = $content->write();
self::assertXmlStringEqualsXmlFile($this->samplesPath . '/content-empty.xml', $xml);
}
public function testWriteSpreadsheet(): void
{
$workbook = new Spreadsheet();
// Worksheet 1
$worksheet1 = $workbook->getActiveSheet();
$worksheet1->setCellValue('A1', 1); // Number
$worksheet1->setCellValue('B1', 12345.6789); // Number
$b1SimpleCast = '12345.6789';
$b1AccurateCast = StringHelper::convertToString(12345.6789);
$worksheet1->setCellValue('C1', '1'); // Number without cast
$worksheet1->setCellValueExplicit('D1', '01234', DataType::TYPE_STRING); // Number casted to string
$worksheet1->setCellValue('E1', 'Lorem ipsum'); // String
$worksheet1->setCellValue('A2', true); // Boolean
$worksheet1->setCellValue('B2', false); // Boolean
$worksheet1->setCellValueExplicit(
'C2',
'=IF(A3, CONCAT(A1, " ", A2), CONCAT(A2, " ", A1))',
DataType::TYPE_FORMULA
); // Formula
$worksheet1->setCellValue('D2', Date::PHPToExcel(1488635026)); // Date
$worksheet1->getStyle('D2')
->getNumberFormat()
->setFormatCode(NumberFormat::FORMAT_DATE_DATETIME);
/** @var float */
$d2SimpleCast = $worksheet1->getCell('D2')->getValue();
$d2SimpleCast = (string) $d2SimpleCast;
$d2AccurateCast = $worksheet1
->getCell('D2')->getValueString();
$worksheet1->setCellValueExplicit('F1', null, DataType::TYPE_ERROR);
$worksheet1->setCellValueExplicit('G1', 'Lorem ipsum', DataType::TYPE_INLINE);
// Styles
$worksheet1->getStyle('A1')->getFont()->setBold(true);
$worksheet1->getStyle('B1')->getFont()->setItalic(true);
$worksheet1->getStyle('C1')->getFont()->setName('Courier');
$worksheet1->getStyle('C1')->getFont()->setSize(14);
$worksheet1->getStyle('C1')->getFont()->setColor(new Color(Color::COLOR_BLUE));
$worksheet1->getStyle('C1')
->getFill()->setFillType(Fill::FILL_SOLID);
$worksheet1->getStyle('C1')
->getFill()->setStartColor(new Color(Color::COLOR_RED));
$worksheet1->getStyle('C1')->getFont()
->setUnderline(Font::UNDERLINE_SINGLE);
$worksheet1->getStyle('C2')->getFont()
->setUnderline(Font::UNDERLINE_DOUBLE);
$worksheet1->getStyle('D2')->getFont()
->setUnderline(Font::UNDERLINE_NONE);
// Worksheet 2
$worksheet2 = $workbook->createSheet();
$worksheet2->setTitle('New Worksheet');
$worksheet2->setCellValue('A1', 2);
// Write
$content = new Content(new Ods($workbook));
$xml = $content->write();
$xmlFile = $this->samplesPath . '/content-with-data.xml';
$xmlContents = (string) file_get_contents($xmlFile);
$xmlContents = str_replace($b1SimpleCast, $b1AccurateCast, $xmlContents);
$xmlContents = str_replace($d2SimpleCast, $d2AccurateCast, $xmlContents);
self::assertXmlStringEqualsXmlString($xmlContents, $xml);
$workbook->disconnectWorksheets();
}
public function testWriteWithHiddenWorksheet(): void
{
$workbook = new Spreadsheet();
// Worksheet 1
$worksheet1 = $workbook->getActiveSheet();
$worksheet1->setCellValue('A1', 1);
// Worksheet 2
$worksheet2 = $workbook->createSheet();
$worksheet2->setTitle('New Worksheet');
$worksheet2->setCellValue('A1', 2);
$worksheet2->setSheetState(Worksheet::SHEETSTATE_HIDDEN);
// Write
$content = new Content(new Ods($workbook));
$xml = $content->write();
self::assertXmlStringEqualsXmlFile($this->samplesPath . '/content-hidden-worksheet.xml', $xml);
$workbook->disconnectWorksheets();
}
public function testWriteBorderStyle(): void
{
$spreadsheet = new Spreadsheet();
$spreadsheet->getActiveSheet()
->getStyle('A1:B2')->applyFromArray([
'borders' => [
'outline' => [
'borderStyle' => Border::BORDER_THICK,
'color' => ['argb' => 'AA22DD00'],
],
],
]);
$content = new Content(new Ods($spreadsheet));
$xml = $content->write();
$xmlDoc = new DOMDocument();
$xmlDoc->loadXML($xml);
$xmlPath = new DOMXPath($xmlDoc);
foreach (['top', 'bottom'] as $keyRow => $row) {
foreach (['left', 'right'] as $keyCell => $cell) {
$styles = ['top' => '', 'bottom' => '', 'left' => '', 'right' => ''];
$styles[$row] = '2.5pt solid #22DD00';
$styles[$cell] = '2.5pt solid #22DD00';
$query = 'string(//office:document-content/office:body/office:spreadsheet/table:table/table:table-row[position()=' . ($keyRow + 1) . ']/table:table-cell[position()=' . ($keyCell + 1) . ']/@table:style-name)';
$idStyle = StringHelper::convertToString($xmlPath->evaluate($query));
foreach ($styles as $direction => $value) {
$query = 'string(//office:document-content/office:automatic-styles/style:style[@style:name="' . $idStyle . '"]/style:table-cell-properties/@fo:border-' . $direction . ')';
$style = $xmlPath->evaluate($query);
self::assertEquals($style, $value);
}
}
}
$spreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Ods/MergeRangeTest.php | tests/PhpSpreadsheetTests/Writer/Ods/MergeRangeTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Ods;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheetTests\Functional\AbstractFunctional;
class MergeRangeTest extends AbstractFunctional
{
public function testMergeRangeWriter(): void
{
$mergeRange = 'B2:C3';
$spreadsheet = new Spreadsheet();
$worksheet = $spreadsheet->getActiveSheet();
$worksheet->setCellValue('B2', "Merge Range {$mergeRange}");
$worksheet->mergeCells($mergeRange);
$reloaded = $this->writeAndReload($spreadsheet, 'Ods');
$cell = $reloaded->getActiveSheet()->getCell('B2');
self::assertTrue($cell->isInMergeRange());
self::assertSame($mergeRange, $cell->getMergeRange());
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Ods/ArrayTest.php | tests/PhpSpreadsheetTests/Writer/Ods/ArrayTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Ods;
use PhpOffice\PhpSpreadsheet\Calculation\Calculation;
use PhpOffice\PhpSpreadsheet\Calculation\Functions;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Writer\Ods;
use PhpOffice\PhpSpreadsheet\Writer\Ods\Content;
use PhpOffice\PhpSpreadsheetTests\Functional\AbstractFunctional;
class ArrayTest extends AbstractFunctional
{
private string $samplesPath = 'tests/data/Writer/Ods';
private string $compatibilityMode;
private bool $skipInline = true;
protected function setUp(): void
{
parent::setUp();
$this->compatibilityMode = Functions::getCompatibilityMode();
Functions::setCompatibilityMode(Functions::COMPATIBILITY_OPENOFFICE);
}
protected function tearDown(): void
{
parent::tearDown();
Functions::setCompatibilityMode($this->compatibilityMode);
}
public function testArrayXml(): void
{
$spreadsheet = new Spreadsheet();
Calculation::getInstance($spreadsheet)->setInstanceArrayReturnType(Calculation::RETURN_ARRAY_AS_ARRAY);
$sheet = $spreadsheet->getActiveSheet();
$sheet->getCell('A1')->setValue(1);
$sheet->getCell('A2')->setValue(1);
$sheet->getCell('A3')->setValue(3);
$sheet->getCell('B1')->setValue('=UNIQUE(A1:A3)');
$content = new Content(new Ods($spreadsheet));
$xml = $content->write();
self::assertXmlStringEqualsXmlFile($this->samplesPath . '/content-arrays.xml', $xml);
}
public function testArray(): void
{
$spreadsheet = new Spreadsheet();
Calculation::getInstance($spreadsheet)->setInstanceArrayReturnType(Calculation::RETURN_ARRAY_AS_ARRAY);
$sheet = $spreadsheet->getActiveSheet();
$sheet->getCell('A1')->setValue(1);
$sheet->getCell('A2')->setValue(1);
$sheet->getCell('A3')->setValue(3);
$sheet->getCell('B1')->setValue('=UNIQUE(A1:A3)');
$reloadedSpreadsheet = $this->writeAndReload($spreadsheet, 'Ods');
Calculation::getInstance($reloadedSpreadsheet)->setInstanceArrayReturnType(Calculation::RETURN_ARRAY_AS_ARRAY);
$sheet = $reloadedSpreadsheet->getActiveSheet();
self::assertSame(1, $sheet->getCell('A1')->getValue());
self::assertSame(1, $sheet->getCell('A2')->getValue());
self::assertSame(3, $sheet->getCell('A3')->getValue());
self::assertSame(3, $sheet->getCell('B2')->getValue());
self::assertTrue($sheet->getCell('B1')->isFormula());
self::assertSame(1, $sheet->getCell('B1')->getOldCalculatedValue());
self::assertNull($sheet->getCell('B3')->getValue());
self::assertEquals('=UNIQUE(A1:A3)', $sheet->getCell('B1')->getValue());
$cellFormulaAttributes = $sheet->getCell('B1')->getFormulaAttributes();
self::assertArrayHasKey('t', $cellFormulaAttributes);
self::assertSame('array', $cellFormulaAttributes['t']);
self::assertArrayHasKey('ref', $cellFormulaAttributes);
self::assertSame('B1:B2', $cellFormulaAttributes['ref']);
self::assertSame([[1], [3]], $sheet->getCell('B1')->getCalculatedValue());
$spreadsheet->disconnectWorksheets();
$reloadedSpreadsheet->disconnectWorksheets();
}
public function testInlineArrays(): void
{
if ($this->skipInline) {
self::markTestIncomplete('Ods Reader/Writer alter commas and semi-colons within formulas, interfering with inline arrays');
}
$spreadsheet = new Spreadsheet();
Calculation::getInstance($spreadsheet)->setInstanceArrayReturnType(Calculation::RETURN_ARRAY_AS_ARRAY);
$sheet = $spreadsheet->getActiveSheet();
$sheet->getCell('A1')->setValue('=UNIQUE({1;1;2;1;3;2;4;4;4})');
$sheet->getCell('D1')->setValue('=UNIQUE({1,1,2,1,3,2,4,4,4},true)');
$reloadedSpreadsheet = $this->writeAndReload($spreadsheet, 'Ods');
$spreadsheet->disconnectWorksheets();
$rsheet = $reloadedSpreadsheet->getActiveSheet();
$expected = [
['=UNIQUE({1,1,2,1,3,2,4,4,4})', null, null, '=UNIQUE({1,1,2,1,3,2,4,4,4},true)', 2, 3, 4],
[2, null, null, null, null, null, null],
[3, null, null, null, null, null, null],
[4, null, null, null, null, null, null],
];
self::assertSame($expected, $rsheet->toArray(null, false, false));
self::assertSame('1', $rsheet->getCell('A1')->getCalculatedValueString());
self::assertSame('1', $rsheet->getCell('D1')->getCalculatedValueString());
$reloadedSpreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Ods/DefinedNamesTest.php | tests/PhpSpreadsheetTests/Writer/Ods/DefinedNamesTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Ods;
use PhpOffice\PhpSpreadsheet\NamedFormula;
use PhpOffice\PhpSpreadsheet\NamedRange;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheetTests\Functional\AbstractFunctional;
class DefinedNamesTest extends AbstractFunctional
{
public function testDefinedNamesWriter(): void
{
$spreadsheet = new Spreadsheet();
$worksheet = $spreadsheet->getActiveSheet();
$dataSet = [
[7, 'x', 5],
['=', '=FORMULA'],
];
$worksheet->fromArray($dataSet, null, 'A1');
$spreadsheet->addDefinedName(new NamedRange('FIRST', $worksheet, '$A$1'));
$spreadsheet->addDefinedName(new NamedRange('SECOND', $worksheet, '$C$1'));
$spreadsheet->addDefinedName(new NamedFormula('FORMULA', $worksheet, '=FIRST*SECOND'));
$reloaded = $this->writeAndReload($spreadsheet, 'Ods');
self::assertSame(7, $reloaded->getActiveSheet()->getCell('FIRST')->getValue());
self::assertSame(5, $reloaded->getActiveSheet()->getCell('SECOND')->getValue());
self::assertSame(35, $reloaded->getActiveSheet()->getCell('B2')->getCalculatedValue());
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Ods/Issue4537Test.php | tests/PhpSpreadsheetTests/Writer/Ods/Issue4537Test.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Ods;
use PhpOffice\PhpSpreadsheet\Cell\DataType;
use PhpOffice\PhpSpreadsheet\Reader\Ods as OdsReader;
use PhpOffice\PhpSpreadsheet\RichText\RichText;
use PhpOffice\PhpSpreadsheet\RichText\TextElement;
use PhpOffice\PhpSpreadsheet\Shared\File;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Writer\Ods as OdsWriter;
use PHPUnit\Framework\TestCase;
class Issue4537Test extends TestCase
{
private string $outputFilename = '';
protected function tearDown(): void
{
if ($this->outputFilename !== '') {
unlink($this->outputFilename);
$this->outputFilename = '';
}
}
public function testBackgroundImage(): void
{
$this->outputFilename = File::temporaryFilename();
$testString = "\"He\": '<?>'";
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->getCell('A1')->setValueExplicit($testString, DataType::TYPE_INLINE);
$sheet->getCell('A2')->setValue($testString);
$richText = new RichText();
$richText->addText(new TextElement($testString));
$sheet->getCell('A3')->setValue($richText);
$writer = new OdsWriter($spreadsheet);
$writer->setUseDiskCaching(true, sys_get_temp_dir());
$writer->save($this->outputFilename);
$spreadsheet->disconnectWorksheets();
$reader = new OdsReader();
$reloadedSpreadsheet = $reader->load($this->outputFilename);
$rsheet = $reloadedSpreadsheet->getActiveSheet();
self::assertSame($testString, $rsheet->getCell('A1')->getValueString());
self::assertSame($testString, $rsheet->getCell('A2')->getValueString());
self::assertSame($testString, $rsheet->getCell('A3')->getValueString());
$reloadedSpreadsheet->disconnectWorksheets();
$file = 'zip://';
$file .= $this->outputFilename;
$file .= '#content.xml';
$data = file_get_contents($file);
// expected does not escape apostrophes
$expected = '<text:p>"He": \'<?>\'</text:p>';
if ($data === false) {
self::fail('Unable to read content file');
} else {
$count = substr_count($data, $expected);
self::assertSame(3, $count);
}
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Ods/AutoColorTest.php | tests/PhpSpreadsheetTests/Writer/Ods/AutoColorTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\ODS;
use PhpOffice\PhpSpreadsheet\Shared\File;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Writer\Ods as OdsWriter;
use PHPUnit\Framework\TestCase;
class AutoColorTest extends TestCase
{
private string $outputFile = '';
protected function tearDown(): void
{
if ($this->outputFile !== '') {
unlink($this->outputFile);
$this->outputFile = '';
}
}
public function testAutoColor(): void
{
// It's not clear to me what AutoColor does in Excel.
// However, LibreOffice Dark Mode
// can make use of a spreadsheet which uses it.
$spreadsheet = new Spreadsheet();
$spreadsheet->getDefaultStyle()->getFont()
->setAutoColor(true);
$sheet = $spreadsheet->getActiveSheet();
$sheet->setCellValue('A1', 'Hello World!');
$sheet->setCellValue('A2', 'Hello World!');
$sheet->getStyle('A2')->getFont()
->setBold(true);
$sheet->setCellValue('A3', 'Hello World!');
$sheet->getStyle('A3')->getFont()
->setItalic(true);
$sheet->setCellValue('B1', 'Hello World!');
$writer = new OdsWriter($spreadsheet);
$outputFile = $this->outputFile = File::temporaryFilename();
$writer->save($outputFile);
$spreadsheet->disconnectWorksheets();
$zipfile = "zip://$outputFile#content.xml";
$contents = file_get_contents($zipfile);
if ($contents === false) {
self::fail('Unable to open file');
} else {
self::assertStringContainsString('<style:text-properties style:use-window-font-color="true" fo:font-family="Calibri" fo:font-size="11.0pt"/>', $contents);
self::assertStringContainsString('<style:text-properties fo:font-weight="bold" style:font-weight-complex="bold" style:font-weight-asian="bold" style:use-window-font-color="true" fo:font-family="Calibri" fo:font-size="11.0pt"/>', $contents);
self::assertStringContainsString('<style:text-properties fo:font-style="italic" style:use-window-font-color="true" fo:font-family="Calibri" fo:font-size="11.0pt"/>', $contents);
}
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Ods/Issue4584Test.php | tests/PhpSpreadsheetTests/Writer/Ods/Issue4584Test.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Ods;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Writer\Ods as OdsWriter;
use PHPUnit\Framework\TestCase;
class Issue4584Test extends TestCase
{
public function testWriteRowDimensions(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->getDefaultRowDimension()->setRowHeight(20);
$sheet->setCellValue('A1', 'hello there world 1');
$sheet->getStyle('A1')->getAlignment()->setWrapText(true);
$sheet->getRowDimension(1)->setCustomFormat(true);
$sheet->setCellValue('A2', 'hello there world 2');
$sheet->setCellValue('A4', 'hello there world 4');
$writer = new OdsWriter($spreadsheet);
$writerWorksheet = new OdsWriter\Content($writer);
$data = $writerWorksheet->write();
self::assertStringContainsString(
'<style:style style:family="table-row" style:name="ro0"><style:table-row-properties style:row-height="0.706cm" style:use-optimal-row-height="false" fo:break-before="auto"/></style:style>',
$data
);
self::assertStringContainsString(
'<table:table-row><table:table-cell table:style-name="ce1" office:value-type="string"><text:p>hello there world 1</text:p></table:table-cell></table:table-row>',
$data
);
self::assertStringContainsString(
'<table:table-row table:style-name="ro0"><table:table-cell table:style-name="ce0" office:value-type="string"><text:p>hello there world 2</text:p></table:table-cell></table:table-row>',
$data
);
self::assertStringContainsString(
'<table:table-row table:number-rows-repeated="1"/><table:table-row table:style-name="ro0"><table:table-cell table:style-name="ce0" office:value-type="string"><text:p>hello there world 4</text:p></table:table-cell></table:table-row>',
$data
);
$spreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Ods/IndentTest.php | tests/PhpSpreadsheetTests/Writer/Ods/IndentTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Ods;
use PhpOffice\PhpSpreadsheet\Calculation\Functions;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Writer\Ods;
use PhpOffice\PhpSpreadsheet\Writer\Ods\Content;
use PHPUnit\Framework\TestCase;
class IndentTest extends TestCase
{
private string $compatibilityMode;
protected function setUp(): void
{
$this->compatibilityMode = Functions::getCompatibilityMode();
Functions::setCompatibilityMode(
Functions::COMPATIBILITY_OPENOFFICE
);
}
protected function tearDown(): void
{
parent::tearDown();
Functions::setCompatibilityMode($this->compatibilityMode);
}
public function testWriteSpreadsheet(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->setCellValue('A1', 'aa');
$sheet->setCellValue('B1', 'bb');
$sheet->setCellValue('A2', 'cc');
$sheet->setCellValue('B2', 'dd');
$sheet->getStyle('A1')->getAlignment()->setIndent(2);
$writer = new Ods($spreadsheet);
$content = new Content($writer);
$xml = $content->write();
self::assertStringContainsString(
'<style:style style:name="ce0" style:family="table-cell" style:parent-style-name="Default">'
. '<style:table-cell-properties style:vertical-align="bottom" style:rotation-align="none"/>'
. '<style:text-properties fo:color="#000000" fo:font-family="Calibri" fo:font-size="11.0pt"/>'
. '</style:style>',
$xml
);
self::assertStringContainsString(
'<style:style style:name="ce1" style:family="table-cell" style:parent-style-name="Default">'
. '<style:table-cell-properties style:vertical-align="bottom" style:rotation-align="none"/>'
. '<style:paragraph-properties fo:margin-left="0.2086in"/>' // fo:margin-left is what we're looking for
. '<style:text-properties fo:color="#000000" fo:font-family="Calibri" fo:font-size="11.0pt"/>'
. '</style:style>',
$xml
);
self::assertSame(3, substr_count($xml, 'table:style-name="ce0"'));
self::assertSame(1, substr_count($xml, 'table:style-name="ce1"'));
$spreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Ods/FreezeTest.php | tests/PhpSpreadsheetTests/Writer/Ods/FreezeTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Ods;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Writer\Ods as OdsWriter;
use PHPUnit\Framework\TestCase;
class FreezeTest extends TestCase
{
public static function testFreeze(): void
{
// We can write FreezePane data to Ods but we cannot yet read it.
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->fromArray([
['A', 'B', 'C', 'D'],
[1, 2, 3, 4],
]);
$sheet->freezePane('B2');
$writer = new OdsWriter($spreadsheet);
$writerSettings = new OdsWriter\Settings($writer);
$settings = $writerSettings->write();
// The items we are particular interested in below are:
// HorizontalSplitMode, HorizontalSplitPosition, PositionLeft, PositionRight
// VerticalSplitMode, VerticalSplitPosition, PositionTop, PositionBottom
$expected = '<config:config-item-map-entry config:name="Worksheet">'
. '<config:config-item config:name="CursorPositionX" config:type="int">0</config:config-item>'
. '<config:config-item config:name="CursorPositionY" config:type="int">0</config:config-item>'
. '<config:config-item config:name="HorizontalSplitMode" config:type="short">2</config:config-item>'
. '<config:config-item config:name="HorizontalSplitPosition" config:type="int">1</config:config-item>'
. '<config:config-item config:name="PositionLeft" config:type="short">0</config:config-item>'
. '<config:config-item config:name="PositionRight" config:type="short">1</config:config-item>'
. '<config:config-item config:name="VerticalSplitMode" config:type="short">2</config:config-item>'
. '<config:config-item config:name="VerticalSplitPosition" config:type="int">1</config:config-item>'
. '<config:config-item config:name="PositionTop" config:type="short">0</config:config-item>'
. '<config:config-item config:name="PositionBottom" config:type="short">1</config:config-item>'
. '<config:config-item config:name="ActiveSplitRange" config:type="short">3</config:config-item>'
. '</config:config-item-map-entry>';
self::assertStringContainsString($expected, $settings);
$spreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Ods/ReadOrderTest.php | tests/PhpSpreadsheetTests/Writer/Ods/ReadOrderTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Ods;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Style\Alignment;
use PhpOffice\PhpSpreadsheet\Writer\Ods;
use PhpOffice\PhpSpreadsheet\Writer\Ods\Content;
use PHPUnit\Framework\TestCase;
class ReadOrderTest extends TestCase
{
public function testReadOrder(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->setCellValue('A1', '1-' . 'منصور حسين الناصر');
$sheet->setCellValue('A2', '1-' . 'منصور حسين الناصر');
$sheet->setCellValue('A3', '1-' . 'منصور حسين الناصر');
$sheet->getStyle('A1')
->getAlignment()->setReadOrder(Alignment::READORDER_RTL);
$sheet->getStyle('A2')
->getAlignment()->setReadOrder(Alignment::READORDER_LTR);
$sheet->getStyle('A2')->getFont()->setName('Arial');
$sheet->getStyle('A3')->getFont()->setName('Times New Roman');
$content = new Content(new Ods($spreadsheet));
$xml = $content->write();
self::assertStringContainsString(
'<style:table-cell-properties style:vertical-align="bottom" style:rotation-align="none"/>'
. '<style:paragraph-properties style:writing-mode="rl-tb"/>'
. '<style:text-properties fo:color="#000000" fo:font-family="Calibri"',
$xml,
'explicit rtl direction in paragraph properties'
);
self::assertStringContainsString(
'<style:table-cell-properties style:vertical-align="bottom" style:rotation-align="none"/>'
. '<style:paragraph-properties style:writing-mode="lr-tb"/>'
. '<style:text-properties fo:color="#000000" fo:font-family="Arial"',
$xml,
'explicit ltr direction in paragraph properties'
);
self::assertStringContainsString(
'<style:table-cell-properties style:vertical-align="bottom" style:rotation-align="none"/>'
. '<style:text-properties fo:color="#000000" fo:font-family="Times New Roman"',
$xml,
'no paragraph properties'
);
$spreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Ods/MicrosecondsTest.php | tests/PhpSpreadsheetTests/Writer/Ods/MicrosecondsTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Ods;
use DateTime;
use PhpOffice\PhpSpreadsheet\Shared\Date;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheetTests\Functional\AbstractFunctional;
class MicrosecondsTest extends AbstractFunctional
{
/**
* Test save and load XLSX file for round-trip DateTime.
* Ods Writer does not support date formats,
* and Reader does not support styles, so this
* test is slightly different than its Xls/Xlsx counterparts.
*/
public function testIssue4476(): void
{
$date = '2020-10-21';
$time = '14:55:31';
$originalDateTime = new DateTime("{$date}T{$time}");
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->setCellValue('A1', Date::dateTimeToExcel($originalDateTime));
$reloadedSpreadsheet = $this->writeAndReload($spreadsheet, 'Ods');
$spreadsheet->disconnectWorksheets();
$rsheet = $reloadedSpreadsheet->getActiveSheet();
$rsheet->getStyle('A1')
->getNumberFormat()
->setFormatCode('yyyy-mm-dd hh:mm:ss.000');
/** @var float */
$reread = $rsheet->getCell('A1')->getValue();
$temp = Date::excelToDateTimeObject($reread)
->format('Y-m-d H:i:s.u');
self::assertSame("{$date} {$time}.000000", $temp, 'round trip works with float value');
$formatted = $rsheet->getCell('A1')->getFormattedValue();
self::assertSame("{$date} {$time}.000", $formatted, 'round trip works with formatted value');
/** @var float */
$temp = Date::stringToExcel($formatted);
$temp = Date::excelToDateTimeObject($temp)
->format('Y-m-d H:i:s.u');
self::assertSame("{$date} {$time}.000000", $temp, 'round trip works using stringToExcel on formatted value');
$reloadedSpreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Ods/AutoFilterTest.php | tests/PhpSpreadsheetTests/Writer/Ods/AutoFilterTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Ods;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheetTests\Functional\AbstractFunctional;
class AutoFilterTest extends AbstractFunctional
{
public function testAutoFilterWriter(): void
{
$spreadsheet = new Spreadsheet();
$worksheet = $spreadsheet->getActiveSheet();
$dataSet = [
['Year', 'Quarter', 'Sales'],
[2020, 'Q1', 100],
[2020, 'Q2', 120],
[2020, 'Q3', 140],
[2020, 'Q4', 160],
[2021, 'Q1', 180],
[2021, 'Q2', 75],
[2021, 'Q3', 0],
[2021, 'Q4', 0],
];
$worksheet->fromArray($dataSet, null, 'A1');
$worksheet->getAutoFilter()->setRange('A1:C9');
$reloaded = $this->writeAndReload($spreadsheet, 'Ods');
self::assertSame('A1:C9', $reloaded->getActiveSheet()->getAutoFilter()->getRange());
}
public function testPeriodInSheetNames(): void
{
$spreadsheet = new Spreadsheet();
$worksheet = $spreadsheet->getActiveSheet();
$worksheet->setTitle('work.sheet');
$dataSet = [
['Year', 'Quarter', 'Sales'],
[2020, 'Q1', 100],
[2020, 'Q2', 120],
[2020, 'Q3', 140],
[2020, 'Q4', 160],
[2021, 'Q1', 180],
[2021, 'Q2', 75],
[2021, 'Q3', 0],
[2021, 'Q4', 0],
];
$worksheet->fromArray($dataSet, null, 'A1');
$worksheet->getAutoFilter()->setRange('A1:C9');
$reloaded = $this->writeAndReload($spreadsheet, 'Ods');
self::assertSame('A1:C9', $reloaded->getActiveSheet()->getAutoFilter()->getRange());
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Csv/CsvOutputEncodingTest.php | tests/PhpSpreadsheetTests/Writer/Csv/CsvOutputEncodingTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Csv;
use PhpOffice\PhpSpreadsheet\Shared\File;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Writer\Csv as CsvWriter;
use PhpOffice\PhpSpreadsheetTests\Functional;
class CsvOutputEncodingTest extends Functional\AbstractFunctional
{
public function testEncoding(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->setCellValue('A1', 'こんにちは！');
$sheet->setCellValue('B1', 'Hello!');
$writer = new CsvWriter($spreadsheet);
$filename = File::temporaryFilename();
$writer->setUseBOM(false);
$writer->setOutputEncoding('SJIS-win');
$writer->save($filename);
$contents = file_get_contents($filename);
unlink($filename);
// self::assertStringContainsString(mb_convert_encoding('こんにちは！', 'SJIS-win'), $contents);
self::assertStringContainsString("\x82\xb1\x82\xf1\x82\xc9\x82\xbf\x82\xcd\x81\x49", $contents);
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Csv/CsvWriteTest.php | tests/PhpSpreadsheetTests/Writer/Csv/CsvWriteTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Csv;
use PhpOffice\PhpSpreadsheet\Reader\Csv as CsvReader;
use PhpOffice\PhpSpreadsheet\Shared\File;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Writer\Csv as CsvWriter;
use PhpOffice\PhpSpreadsheet\Writer\Exception as WriterException;
use PhpOffice\PhpSpreadsheetTests\Functional;
class CsvWriteTest extends Functional\AbstractFunctional
{
public function testNotFirstSheet(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->setCellValue('A1', 'First Sheet');
$sheet = $spreadsheet->createSheet();
$sheet->setCellValue('A1', 'Second Sheet');
$sheet = $spreadsheet->createSheet();
$sheet->setCellValue('A1', 'Third Sheet');
$writer = new CsvWriter($spreadsheet);
$writer->setSheetIndex(1);
self::assertEquals(1, $writer->getSheetIndex());
$filename = File::temporaryFilename();
$writer->save($filename);
$reader = new CsvReader();
$newspreadsheet = $reader->load($filename);
unlink($filename);
$sheet = $newspreadsheet->getActiveSheet();
self::assertEquals('Second Sheet', $sheet->getCell('A1')->getValue());
self::assertEquals(0, $newspreadsheet->getActiveSheetIndex());
}
public function testWriteEmptyFileName(): void
{
$this->expectException(WriterException::class);
$spreadsheet = new Spreadsheet();
$writer = new CsvWriter($spreadsheet);
$filename = '';
$writer->save($filename);
}
public function testDefaultSettings(): void
{
$spreadsheet = new Spreadsheet();
$writer = new CsvWriter($spreadsheet);
self::assertEquals('"', $writer->getEnclosure());
$writer->setEnclosure('\'');
self::assertEquals('\'', $writer->getEnclosure());
$writer->setEnclosure('');
self::assertEquals('', $writer->getEnclosure());
$writer->setEnclosure();
self::assertEquals('"', $writer->getEnclosure());
self::assertEquals(PHP_EOL, $writer->getLineEnding());
self::assertFalse($writer->getUseBOM());
self::assertFalse($writer->getIncludeSeparatorLine());
self::assertFalse($writer->getExcelCompatibility());
self::assertEquals(0, $writer->getSheetIndex());
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Csv/HyperlinkTest.php | tests/PhpSpreadsheetTests/Writer/Csv/HyperlinkTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Csv;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Writer\Csv;
use PHPUnit\Framework\TestCase;
class HyperlinkTest extends TestCase
{
public function testVariableColumns(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->setCellValue('A1', 3);
$sheet->setCellValue('B1', 4);
$sheet->setCellValue('C1', 5);
$sheet->setCellValue('A2', 6);
$sheet->setCellValue('B2', 'hyperlink');
$sheet->getCell('B2')->getHyperlink()
->setUrl('http://www.example.com');
$sheet->setCellValue('C2', 8);
$fh = fopen('php://memory', 'r+b');
self::assertNotFalse($fh);
$writer = new Csv($spreadsheet);
self::assertFalse($writer->getPreferHyperlinkToLabel());
$writer->setEnclosureRequired(false)->setLineEnding("\n");
$writer->save($fh);
rewind($fh);
self::assertSame(
"3,4,5\n6,hyperlink,8\n",
stream_get_contents($fh)
);
rewind($fh);
$writer->setPreferHyperlinkToLabel(true);
$writer->save($fh);
rewind($fh);
self::assertSame(
"3,4,5\n6,http://www.example.com,8\n",
stream_get_contents($fh)
);
fclose($fh);
$spreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Csv/VariableColumnsTest.php | tests/PhpSpreadsheetTests/Writer/Csv/VariableColumnsTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Csv;
use PhpOffice\PhpSpreadsheet\Shared\File;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Writer\Csv;
use PHPUnit\Framework\TestCase;
class VariableColumnsTest extends TestCase
{
public function testVariableColumns(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->fromArray(
[
[1, 2, 3, 4],
[1, 2],
[1, 2, 3, 4, 5],
[],
[1],
[1, 2, 3],
]
);
$filename = File::temporaryFilename();
$writer = new Csv($spreadsheet);
$writer->setVariableColumns(true);
$writer->save($filename);
$contents = (string) file_get_contents($filename);
unlink($filename);
$spreadsheet->disconnectWorksheets();
$rows = explode(PHP_EOL, $contents);
self::assertSame('"1","2","3","4"', $rows[0]);
self::assertSame('"1","2"', $rows[1]);
self::assertSame('"1","2","3","4","5"', $rows[2]);
self::assertSame('', $rows[3]);
self::assertSame('"1"', $rows[4]);
self::assertSame('"1","2","3"', $rows[5]);
}
public function testFixedColumns(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->fromArray(
[
[1, 2, 3, 4],
[1, 2],
[1, 2, 3, 4, 5],
[],
[1],
[1, 2, 3],
]
);
$filename = File::temporaryFilename();
$writer = new Csv($spreadsheet);
self::assertFalse($writer->getVariableColumns());
$writer->save($filename);
$contents = (string) file_get_contents($filename);
unlink($filename);
$spreadsheet->disconnectWorksheets();
$rows = explode(PHP_EOL, $contents);
self::assertSame('"1","2","3","4",""', $rows[0]);
self::assertSame('"1","2","","",""', $rows[1]);
self::assertSame('"1","2","3","4","5"', $rows[2]);
self::assertSame('"","","","",""', $rows[3]);
self::assertSame('"1","","","",""', $rows[4]);
self::assertSame('"1","2","3","",""', $rows[5]);
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Csv/CsvExcelCompatibilityTest.php | tests/PhpSpreadsheetTests/Writer/Csv/CsvExcelCompatibilityTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Csv;
use PhpOffice\PhpSpreadsheet\Reader\Csv as CsvReader;
use PhpOffice\PhpSpreadsheet\Shared\File;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Writer\Csv as CsvWriter;
use PhpOffice\PhpSpreadsheetTests\Functional;
class CsvExcelCompatibilityTest extends Functional\AbstractFunctional
{
// Excel seems to have changed with how they handle this.
// In particular, it does not recognize UTF-8 non-ASCII characters
// if a file is written with ExcelCompatibility on.
// The initial 'sep=;' line seems to confuse it, even though
// it has a BOM. The Unix "file" command also indicates a difference
// when the sep line is or is not included:
// UTF-8 Unicode (with BOM) text, with CRLF line terminators
// vs CSV text (without sep line, with or without BOM)
// So, this test has no UTF-8 yet while more research is conducted.
public function testExcelCompatibility(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->setCellValue('A1', '1');
$sheet->setCellValue('B1', '2');
$sheet->setCellValue('C1', '3');
$sheet->setCellValue('A2', '4');
$sheet->setCellValue('B2', '5');
$sheet->setCellValue('C2', '6');
$writer = new CsvWriter($spreadsheet);
$writer->setExcelCompatibility(true);
self::assertSame('', $writer->getOutputEncoding());
$filename = File::temporaryFilename();
$writer->save($filename);
$reader = new CsvReader();
$spreadsheet2 = $reader->load($filename);
$contents = file_get_contents($filename);
unlink($filename);
self::assertEquals(1, $spreadsheet2->getActiveSheet()->getCell('A1')->getValue());
self::assertEquals(6, $spreadsheet2->getActiveSheet()->getCell('C2')->getValue());
self::assertStringContainsString(CsvReader::UTF8_BOM, $contents);
self::assertStringContainsString("\r\n", $contents);
self::assertStringContainsString('sep=;', $contents);
self::assertStringContainsString('"1";"2";"3"', $contents);
self::assertStringContainsString('"4";"5";"6"', $contents);
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Csv/CsvEnclosureTest.php | tests/PhpSpreadsheetTests/Writer/Csv/CsvEnclosureTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Csv;
use PhpOffice\PhpSpreadsheet\Reader\Csv as CsvReader;
use PhpOffice\PhpSpreadsheet\Shared\File;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Writer\Csv as CsvWriter;
use PhpOffice\PhpSpreadsheetTests\Functional;
class CsvEnclosureTest extends Functional\AbstractFunctional
{
private const CELL_VALUES = [
'A1' => '2020-06-03',
'B1' => '000123',
'C1' => '06.53',
'D1' => 14.22,
'A2' => '2020-06-04',
'B2' => '000234',
'C2' => '07.12',
'D2' => '15.44',
];
private static function getFileData(string $filename): string
{
return file_get_contents($filename) ?: '';
}
public function testNormalEnclosure(): void
{
$delimiter = ';';
$enclosure = '"';
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
foreach (self::CELL_VALUES as $key => $value) {
$sheet->setCellValue($key, $value);
}
$writer = new CsvWriter($spreadsheet);
$writer->setDelimiter($delimiter);
$writer->setEnclosure($enclosure);
$filename = File::temporaryFilename();
$writer->save($filename);
$filedata = self::getFileData($filename);
$filedata = preg_replace('/\r?\n/', $delimiter, $filedata);
$reader = new CsvReader();
$reader->setDelimiter($delimiter);
$reader->setEnclosure($enclosure);
$newspreadsheet = $reader->load($filename);
unlink($filename);
$sheet = $newspreadsheet->getActiveSheet();
$expected = '';
foreach (self::CELL_VALUES as $key => $value) {
self::assertEquals($value, $sheet->getCell($key)->getValue());
$expected .= "$enclosure$value$enclosure$delimiter";
}
self::assertEquals($expected, $filedata);
$spreadsheet->disconnectWorksheets();
$newspreadsheet->disconnectWorksheets();
}
public function testNoEnclosure(): void
{
$delimiter = ';';
$enclosure = '';
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
foreach (self::CELL_VALUES as $key => $value) {
$sheet->setCellValue($key, $value);
}
$writer = new CsvWriter($spreadsheet);
$writer->setDelimiter($delimiter);
$writer->setEnclosure($enclosure);
self::assertEquals('', $writer->getEnclosure());
$filename = File::temporaryFilename();
$writer->save($filename);
$filedata = self::getFileData($filename);
$filedata = preg_replace('/\r?\n/', $delimiter, $filedata);
$reader = new CsvReader();
$reader->setDelimiter($delimiter);
$reader->setEnclosure($enclosure);
self::assertEquals('"', $reader->getEnclosure());
$newspreadsheet = $reader->load($filename);
unlink($filename);
$sheet = $newspreadsheet->getActiveSheet();
$expected = '';
foreach (self::CELL_VALUES as $key => $value) {
self::assertEquals($value, $sheet->getCell($key)->getValue());
$expected .= "$enclosure$value$enclosure$delimiter";
}
self::assertEquals($expected, $filedata);
$spreadsheet->disconnectWorksheets();
$newspreadsheet->disconnectWorksheets();
}
public function testNotRequiredEnclosure1(): void
{
$delimiter = ';';
$enclosure = '"';
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
foreach (self::CELL_VALUES as $key => $value) {
$sheet->setCellValue($key, $value);
}
$writer = new CsvWriter($spreadsheet);
self::assertTrue($writer->getEnclosureRequired());
$writer->setEnclosureRequired(false)->setDelimiter($delimiter)->setEnclosure($enclosure);
$filename = File::temporaryFilename();
$writer->save($filename);
$filedata = self::getFileData($filename);
$filedata = preg_replace('/\r?\n/', $delimiter, $filedata);
$reader = new CsvReader();
$reader->setDelimiter($delimiter);
$reader->setEnclosure($enclosure);
$newspreadsheet = $reader->load($filename);
unlink($filename);
$sheet = $newspreadsheet->getActiveSheet();
$expected = '';
foreach (self::CELL_VALUES as $key => $value) {
self::assertEquals($value, $sheet->getCell($key)->getValue());
$expected .= "$value$delimiter";
}
self::assertEquals($expected, $filedata);
$spreadsheet->disconnectWorksheets();
$newspreadsheet->disconnectWorksheets();
}
public function testNotRequiredEnclosure2(): void
{
$cellValues2 = [
'A1' => '2020-06-03',
'B1' => 'has,separator',
'C1' => 'has;non-separator',
'D1' => 'has"enclosure',
'A2' => 'has space',
'B2' => "has\nnewline",
'C2' => '',
'D2' => 15.44,
'A3' => ' leadingspace',
'B3' => 'trailingspace ',
'C3' => '=D2*2',
'D3' => ',leadingcomma',
'A4' => 'trailingquote"',
'B4' => 'unused',
'C4' => 'unused',
'D4' => 'unused',
'A5' => false,
'B5' => true,
'C5' => null,
'D5' => 0,
];
$calcc3 = '30.88';
$expected1 = '2020-06-03,"has,separator",has;non-separator,"has""enclosure"';
$expected2 = 'has space,"has' . "\n" . 'newline",,15.44';
$expected3 = ' leadingspace,trailingspace ,' . $calcc3 . ',",leadingcomma"';
$expected4 = '"trailingquote""",unused,unused,unused';
$expected5 = 'FALSE,TRUE,,0';
$expectedfile = "$expected1\n$expected2\n$expected3\n$expected4\n$expected5\n";
$delimiter = ',';
$enclosure = '"';
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
foreach ($cellValues2 as $key => $value) {
$sheet->setCellValue($key, $value);
}
$writer = new CsvWriter($spreadsheet);
self::assertTrue($writer->getEnclosureRequired());
$writer->setEnclosureRequired(false)->setDelimiter($delimiter)->setEnclosure($enclosure);
$filename = File::temporaryFilename();
$writer->save($filename);
$filedata = self::getFileData($filename);
$filedata = preg_replace('/\r/', '', $filedata);
$reader = new CsvReader();
$reader->setDelimiter($delimiter);
$reader->setEnclosure($enclosure);
$newspreadsheet = $reader->load($filename);
unlink($filename);
$sheet = $newspreadsheet->getActiveSheet();
foreach ($cellValues2 as $key => $value) {
self::assertEquals(($key === 'C3') ? $calcc3 : $value, $sheet->getCell($key)->getValue(), "Failure for cell $key");
}
self::assertEquals($expectedfile, $filedata);
$spreadsheet->disconnectWorksheets();
$newspreadsheet->disconnectWorksheets();
}
public function testRequiredEnclosure2(): void
{
$cellValues2 = [
'A1' => '2020-06-03',
'B1' => 'has,separator',
'C1' => 'has;non-separator',
'D1' => 'has"enclosure',
'A2' => 'has space',
'B2' => "has\nnewline",
'C2' => '',
'D2' => 15.44,
'A3' => ' leadingspace',
'B3' => 'trailingspace ',
'C3' => '=D2*2',
'D3' => ',leadingcomma',
'A4' => 'trailingquote"',
'B4' => 'unused',
'C4' => 'unused',
'D4' => 'unused',
'A5' => false,
'B5' => true,
'C5' => null,
'D5' => 0,
];
$calcc3 = '30.88';
$expected1 = '"2020-06-03","has,separator","has;non-separator","has""enclosure"';
$expected2 = '"has space","has' . "\n" . 'newline","","15.44"';
$expected3 = '" leadingspace","trailingspace ","' . $calcc3 . '",",leadingcomma"';
$expected4 = '"trailingquote""","unused","unused","unused"';
$expected5 = '"FALSE","TRUE","","0"';
$expectedfile = "$expected1\n$expected2\n$expected3\n$expected4\n$expected5\n";
$delimiter = ',';
$enclosure = '"';
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
foreach ($cellValues2 as $key => $value) {
$sheet->setCellValue($key, $value);
}
$writer = new CsvWriter($spreadsheet);
self::assertTrue($writer->getEnclosureRequired());
$writer->setEnclosureRequired(true)->setDelimiter($delimiter)->setEnclosure($enclosure);
$filename = File::temporaryFilename();
$writer->save($filename);
$filedata = self::getFileData($filename);
$filedata = preg_replace('/\r/', '', $filedata);
$reader = new CsvReader();
$reader->setDelimiter($delimiter);
$reader->setEnclosure($enclosure);
$newspreadsheet = $reader->load($filename);
unlink($filename);
$sheet = $newspreadsheet->getActiveSheet();
foreach ($cellValues2 as $key => $value) {
self::assertEquals(($key === 'C3') ? $calcc3 : $value, $sheet->getCell($key)->getValue(), "Failure for cell $key");
}
self::assertEquals($expectedfile, $filedata);
$spreadsheet->disconnectWorksheets();
$newspreadsheet->disconnectWorksheets();
}
public function testGoodReread(): void
{
$delimiter = ',';
$enclosure = '"';
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->setCellValue('A1', '1');
$sheet->setCellValue('B1', '2,3');
$sheet->setCellValue('C1', '4');
$writer = new CsvWriter($spreadsheet);
$writer->setEnclosureRequired(false)->setDelimiter($delimiter)->setEnclosure($enclosure);
$filename = File::temporaryFilename();
$writer->save($filename);
$reader = new CsvReader();
$reader->setDelimiter($delimiter);
$reader->setEnclosure($enclosure);
$newspreadsheet = $reader->load($filename);
unlink($filename);
$sheet = $newspreadsheet->getActiveSheet();
self::assertEquals('1', $sheet->getCell('A1')->getValue());
self::assertEquals('2,3', $sheet->getCell('B1')->getValue());
self::assertEquals('4', $sheet->getCell('C1')->getValue());
$spreadsheet->disconnectWorksheets();
$newspreadsheet->disconnectWorksheets();
}
public function testBadReread(): void
{
$delimiter = ',';
$enclosure = '';
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->setCellValue('A1', '1');
$sheet->setCellValue('B1', '2,3');
$sheet->setCellValue('C1', '4');
$writer = new CsvWriter($spreadsheet);
$writer->setDelimiter($delimiter)->setEnclosure($enclosure);
$filename = File::temporaryFilename();
$writer->save($filename);
$reader = new CsvReader();
$reader->setDelimiter($delimiter);
$reader->setEnclosure($enclosure);
$newspreadsheet = $reader->load($filename);
unlink($filename);
$sheet = $newspreadsheet->getActiveSheet();
self::assertEquals('1', $sheet->getCell('A1')->getValue());
self::assertEquals('2', $sheet->getCell('B1')->getValue());
self::assertEquals('3', $sheet->getCell('C1')->getValue());
self::assertEquals('4', $sheet->getCell('D1')->getValue());
$spreadsheet->disconnectWorksheets();
$newspreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Csv/CsvArrayTest.php | tests/PhpSpreadsheetTests/Writer/Csv/CsvArrayTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Csv;
use PhpOffice\PhpSpreadsheet\Calculation\Calculation;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheetTests\Functional\AbstractFunctional;
class CsvArrayTest extends AbstractFunctional
{
public function testArray(): void
{
$spreadsheet = new Spreadsheet();
Calculation::getInstance($spreadsheet)->setInstanceArrayReturnType(Calculation::RETURN_ARRAY_AS_ARRAY);
$sheet = $spreadsheet->getActiveSheet();
$sheet->getCell('A1')->setValue(1);
$sheet->getCell('A2')->setValue(1);
$sheet->getCell('A3')->setValue(3);
$sheet->getCell('B1')->setValue('=UNIQUE(A1:A3)');
$reloadedSpreadsheet = $this->writeAndReload($spreadsheet, 'Csv');
$sheet = $reloadedSpreadsheet->getActiveSheet();
self::assertEquals('1', $sheet->getCell('A1')->getValue());
self::assertEquals('1', $sheet->getCell('A2')->getValue());
self::assertEquals('3', $sheet->getCell('A3')->getValue());
self::assertEquals('1', $sheet->getCell('B1')->getValue());
self::assertEquals('3', $sheet->getCell('B2')->getValue());
self::assertNull($sheet->getCell('B3')->getValue());
$spreadsheet->disconnectWorksheets();
$reloadedSpreadsheet->disconnectWorksheets();
}
public function testInlineArrays(): void
{
$spreadsheet = new Spreadsheet();
Calculation::getInstance($spreadsheet)->setInstanceArrayReturnType(Calculation::RETURN_ARRAY_AS_ARRAY);
$sheet = $spreadsheet->getActiveSheet();
$sheet->getCell('A1')->setValue('=UNIQUE({1;1;2;1;3;2;4;4;4})');
$sheet->getCell('D1')->setValue('=UNIQUE({1,1,2,1,3,2,4,4,4},true)');
$reloadedSpreadsheet = $this->writeAndReload($spreadsheet, 'Csv');
$sheet = $reloadedSpreadsheet->getActiveSheet();
$expected = [
['1', null, null, '1', '2', '3', '4'],
['2', null, null, null, null, null, null],
['3', null, null, null, null, null, null],
['4', null, null, null, null, null, null],
];
self::assertSame($expected, $sheet->toArray());
$spreadsheet->disconnectWorksheets();
$reloadedSpreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Tcpdf/MergedBorderTest.php | tests/PhpSpreadsheetTests/Writer/Tcpdf/MergedBorderTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Tcpdf;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Style\Border;
use PhpOffice\PhpSpreadsheet\Writer\Pdf\Tcpdf;
use PHPUnit\Framework\TestCase;
class MergedBorderTest extends TestCase
{
public static function testMergedBorder(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$target = 'A2:B5';
$sheet->mergeCells($target);
$sheet->setCellValue('A2', 'Planning');
$sheet->getStyle($target)->applyFromArray([
'borders' => [
'outline' => [
'borderStyle' => Border::BORDER_HAIR,
'color' => ['rgb' => 'FF0000'],
],
],
]);
$sheet->setSelectedCells('D1');
$sheet->setCellValue('D1', 'Edge');
$sheet->setCellValue('D5', 'Edge');
$sheet->setShowGridlines(false);
$writer = new Tcpdf($spreadsheet);
$html = $writer->generateHtmlAll();
self::assertSame(1, preg_match('/ colspan="2" rowspan="4" style="vertical-align:bottom; border-bottom:1px solid #FF0000 !important; border-top:1px solid #FF0000 !important; border-left:1px solid #FF0000 !important; border-right:1px solid #FF0000 !important; color:#000000;[^>]+/', $html));
$spreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Tcpdf/NoDieTest.php | tests/PhpSpreadsheetTests/Writer/Tcpdf/NoDieTest.php | <?php
namespace PhpOffice\PhpSpreadsheetTests\Writer\Tcpdf;
use Exception;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Writer\Pdf\TcpdfNoDie;
use PHPUnit\Framework\Attributes;
class NoDieTest extends \PHPUnit\Framework\TestCase
{
private Spreadsheet $spreadsheet;
protected function setUp(): void
{
$this->spreadsheet = new Spreadsheet();
}
protected function tearDown(): void
{
unset($this->spreadsheet);
}
// Separate processes because of global defined names
#[Attributes\RunInSeparateProcess]
#[Attributes\PreserveGlobalState(false)]
public function testExceptionRatherThanDie(): void
{
$this->expectException(Exception::class);
$this->expectExceptionMessage('Could not include font definition file');
$sheet = $this->spreadsheet->getActiveSheet();
$sheet->setCellValue('A1', 'cell');
$writer = new TcpdfNoDie($this->spreadsheet);
$writer->setFont('xyz');
$writer->save('php://memory');
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Tcpdf/PrintAreaTest.php | tests/PhpSpreadsheetTests/Writer/Tcpdf/PrintAreaTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Tcpdf;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Writer\Pdf\Tcpdf as TcpdfWriter;
use PHPUnit\Framework\TestCase;
class PrintAreaTest extends TestCase
{
public function testPrintArea(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$inArray = [
[1, 2, 3, 4, 5],
[6, 7, 8, 9, 10],
[11, 12, 13, 14, 15],
[16, 17, 18, 19, 20],
[21, 22, 23, 24, 25],
[26, 27, 28, 29, 30],
];
$sheet->fromArray($inArray);
$sheet->getPageSetup()->setPrintArea('B2:D4');
$writer = new TcpdfWriter($spreadsheet);
$html = $writer->generateHtmlAll();
$html = preg_replace('/^ +/m', '', $html) ?? $html;
$expectedArray = [
'<tbody>',
'<tr>',
'<td></td>',
'<td style="vertical-align:bottom; color:#000000; font-family:\'Calibri\'; font-size:11pt; text-align:right; width:42pt">7</td>',
'<td style="vertical-align:bottom; color:#000000; font-family:\'Calibri\'; font-size:11pt; text-align:right; width:42pt">8</td>',
'<td style="vertical-align:bottom; color:#000000; font-family:\'Calibri\'; font-size:11pt; text-align:right; width:42pt">9</td>',
'</tr>',
'<tr>',
'<td></td>',
'<td style="vertical-align:bottom; color:#000000; font-family:\'Calibri\'; font-size:11pt; text-align:right; width:42pt">12</td>',
'<td style="vertical-align:bottom; color:#000000; font-family:\'Calibri\'; font-size:11pt; text-align:right; width:42pt">13</td>',
'<td style="vertical-align:bottom; color:#000000; font-family:\'Calibri\'; font-size:11pt; text-align:right; width:42pt">14</td>',
'</tr>',
'<tr>',
'<td></td>',
'<td style="vertical-align:bottom; color:#000000; font-family:\'Calibri\'; font-size:11pt; text-align:right; width:42pt">17</td>',
'<td style="vertical-align:bottom; color:#000000; font-family:\'Calibri\'; font-size:11pt; text-align:right; width:42pt">18</td>',
'<td style="vertical-align:bottom; color:#000000; font-family:\'Calibri\'; font-size:11pt; text-align:right; width:42pt">19</td>',
'</tr>',
'</tbody>',
];
$expectedString = implode(PHP_EOL, $expectedArray);
self::assertStringContainsString(
$expectedString,
$html
);
$spreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Tcpdf/HideTest.php | tests/PhpSpreadsheetTests/Writer/Tcpdf/HideTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Tcpdf;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Writer\Pdf\Tcpdf;
use PHPUnit\Framework\TestCase;
class HideTest extends TestCase
{
public function testHide(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->fromArray([
['a1', 'b1', 'c1', 'd1', 'e1', 'f1'],
['a2', 'b2', 'c2', 'd2', 'e2', 'f2'],
['a3', 'b3', 'c3', 'd3', 'e3', 'f3'],
['a4', 'b4', 'c4', 'd4', 'e4', 'f4'],
['a5', 'b5', 'c5', 'd5', 'e5', 'f5'],
['a6', 'b6', 'c6', 'd6', 'e6', 'f6'],
]);
$sheet->getColumnDimension('B')->setVisible(false);
$sheet->getRowDimension(3)->setVisible(false);
$writer = new Tcpdf($spreadsheet);
$html = $writer->generateHtmlAll();
self::assertStringNotContainsString('a3', $html);
self::assertStringNotContainsString('b1', $html);
self::assertStringContainsString('a1', $html);
$spreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Tcpdf/HideMergeTest.php | tests/PhpSpreadsheetTests/Writer/Tcpdf/HideMergeTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Tcpdf;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Style\Alignment;
use PhpOffice\PhpSpreadsheet\Style\Border;
use PhpOffice\PhpSpreadsheet\Style\Color;
use PhpOffice\PhpSpreadsheet\Writer\Pdf\Tcpdf;
use PHPUnit\Framework\TestCase;
class HideMergeTest extends TestCase
{
public function testHideWithMerge(): void
{
$spreadsheet = new Spreadsheet();
$worksheet = $spreadsheet->getActiveSheet();
$worksheet->setPrintGridlines(true);
// just some labels for better visualisation of the problem
$worksheet->setCellValue('A1', 'A');
$worksheet->setCellValue('B1', 'B');
$worksheet->setCellValue('C1', 'C');
// setting the row height to better visualize the problem
for ($i = 1; $i <= 10; ++$i) {
$worksheet->getRowDimension($i)->setRowHeight(17);
}
// Headline - merged over two cells AND two rows
$worksheet->mergeCells('B2:C3');
$worksheet->setCellValue('B2', 'Hello World Headline');
$worksheet->getStyle('B2:C3')->getFont()->setBold(true);
$worksheet->getStyle('B2:C3')
->getAlignment()
->setHorizontal(Alignment::HORIZONTAL_CENTER);
$worksheet->getStyle('B2:C3')
->getBorders()
->getAllBorders()
->setBorderStyle(Border::BORDER_THIN)
->setColor(new Color(Color::COLOR_BLACK));
// Content 1 - merge over two rows
$worksheet->mergeCells('B4:B5');
$worksheet->mergeCells('C4:C5');
$worksheet->setCellValue('B4', 'Label 1');
$worksheet->setCellValue('C4', 'Text 1');
$worksheet->getStyle('B4:B5')->getFont()->setBold(true);
$worksheet->getStyle('B4:C5')
->getAlignment()
->setVertical(Alignment::VERTICAL_CENTER);
$worksheet->getStyle('B4:B5')
->getBorders()
->getAllBorders()
->setBorderStyle(Border::BORDER_THIN)
->setColor(new Color(Color::COLOR_BLACK));
$worksheet->getStyle('C4:C5')
->getBorders()
->getAllBorders()
->setBorderStyle(Border::BORDER_THIN)
->setColor(new Color(Color::COLOR_BLACK));
// Content 2 - merge over two rows
$worksheet->mergeCells('B6:B7');
$worksheet->mergeCells('C6:C7');
$worksheet->setCellValue('B6', 'Label 2');
$worksheet->setCellValue('C6', 'Text 2');
$worksheet->getStyle('B6:B7')->getFont()->setBold(true);
$worksheet->getStyle('B6:C7')
->getAlignment()
->setVertical(Alignment::VERTICAL_CENTER);
$worksheet->getStyle('B6:B7')
->getBorders()
->getAllBorders()
->setBorderStyle(Border::BORDER_THIN)
->setColor(new Color(Color::COLOR_BLACK));
$worksheet->getStyle('C6:C7')
->getBorders()
->getAllBorders()
->setBorderStyle(Border::BORDER_THIN)
->setColor(new Color(Color::COLOR_BLACK));
// This is where the error was introduced (!!!)
$worksheet->getColumnDimension('A')->setVisible(false);
$Tcpdf = new Tcpdf($spreadsheet);
$html = $Tcpdf->generateHtmlAll();
$html = preg_replace('/^\s+/m', '', $html) ?? $html;
$html = preg_replace('/[\n\r]/', '', $html) ?? $html;
self::assertStringContainsString(
'<tbody><tr style="height:17pt">'
. '<td></td>'
. '<td class="gridlines gridlinesp" style="vertical-align:bottom; color:#000000; font-family:\'Calibri\'; font-size:11pt; text-align:left; width:42pt; height:17pt">B</td>'
. '<td class="gridlines gridlinesp" style="vertical-align:bottom; color:#000000; font-family:\'Calibri\'; font-size:11pt; text-align:left; width:42pt; height:17pt">C</td>'
. '</tr>',
$html
);
self::assertStringContainsString(
'<tr style="height:17pt">'
. '<td></td>'
. '<td class="gridlines gridlinesp" colspan="2" rowspan="2" style="vertical-align:bottom; text-align:center; border-bottom:1px solid #000000 !important; border-top:1px solid #000000 !important; border-left:1px solid #000000 !important; border-right:1px solid #000000 !important; font-weight:bold; color:#000000; font-family:\'Calibri\'; font-size:11pt; width:84pt; height:17pt">Hello World Headline</td>'
. '</tr>',
$html
);
$emptyRowCount = substr_count(
$html,
'<tr style="height:17pt">'
. '<td></td>'
. '</tr>'
);
self::assertSame(3, $emptyRowCount);
self::assertStringContainsString(
'<tr style="height:17pt">'
. '<td></td>'
. '<td class="gridlines gridlinesp" rowspan="2" style="vertical-align:middle; border-bottom:1px solid #000000 !important; border-top:1px solid #000000 !important; border-left:1px solid #000000 !important; border-right:1px solid #000000 !important; font-weight:bold; color:#000000; font-family:\'Calibri\'; font-size:11pt; text-align:left; width:42pt; height:17pt">Label 1</td>'
. '<td class="gridlines gridlinesp" rowspan="2" style="vertical-align:middle; border-bottom:1px solid #000000 !important; border-top:1px solid #000000 !important; border-left:1px solid #000000 !important; border-right:1px solid #000000 !important; color:#000000; font-family:\'Calibri\'; font-size:11pt; text-align:left; width:42pt; height:17pt">Text 1</td>'
. '</tr>',
$html
);
self::assertStringContainsString(
'<tr style="height:17pt">'
. '<td></td>'
. '<td class="gridlines gridlinesp" rowspan="2" style="vertical-align:middle; border-bottom:1px solid #000000 !important; border-top:1px solid #000000 !important; border-left:1px solid #000000 !important; border-right:1px solid #000000 !important; font-weight:bold; color:#000000; font-family:\'Calibri\'; font-size:11pt; text-align:left; width:42pt; height:17pt">Label 2</td>'
. '<td class="gridlines gridlinesp" rowspan="2" style="vertical-align:middle; border-bottom:1px solid #000000 !important; border-top:1px solid #000000 !important; border-left:1px solid #000000 !important; border-right:1px solid #000000 !important; color:#000000; font-family:\'Calibri\'; font-size:11pt; text-align:left; width:42pt; height:17pt">Text 2</td>'
. '</tr>',
$html
);
$spreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Xlsx/ArrayFunctions2Test.php | tests/PhpSpreadsheetTests/Writer/Xlsx/ArrayFunctions2Test.php | <?php
// not yet ready for prime time
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Xlsx;
use PhpOffice\PhpSpreadsheet\Calculation\Calculation;
use PhpOffice\PhpSpreadsheet\Cell\DataValidation;
use PhpOffice\PhpSpreadsheet\NamedRange;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Style\Alignment;
use PhpOffice\PhpSpreadsheet\Style\Border;
use PhpOffice\PhpSpreadsheet\Worksheet\Worksheet;
use PHPUnit\Framework\TestCase;
// TODO - I think the spreadsheet below is too difficult for PhpSpreadsheet to calculate correctly.
class ArrayFunctions2Test extends TestCase
{
private const STYLESIZE14 = [
'font' => [
'size' => 14,
],
];
private const STYLEBOLD = [
'font' => [
'bold' => true,
],
];
private const STYLEBOLD14 = [
'font' => [
'bold' => true,
'size' => 14,
],
];
private const STYLECENTER = [
'alignment' => [
'horizontal' => Alignment::HORIZONTAL_CENTER,
],
];
private const STYLETHICKBORDER = [
'borders' => [
'outline' => [
'borderStyle' => Border::BORDER_THICK,
'color' => ['argb' => '00000000'],
],
],
];
private array $trn;
private string $outputFile = '';
protected function tearDown(): void
{
if ($this->outputFile !== '') {
unlink($this->outputFile);
$this->outputFile = '';
}
}
private function odd(int $i): bool
{
return ($i % 2) === 1;
}
private function doPartijen(Worksheet $ws): int
{
$saring = explode("\n", $this->trn['PARINGEN']);
$s = $this->trn['PLAYERSNOID'];
$g = $this->trn['RONDEGAMES'];
$KD = $this->trn['KALENDERDATA'];
$si = $this->trn['PLAYERSIDS'];
$a = [
['Wit', null, null, null, 'Zwart', null, null, null, 'Wit', 'Uitslag', 'Zwart', 'Opmerking', 'Datum'],
['Winstpunten', 'Weerstandspunten', 'punten', 'Tegenpunten', 'Winstpunten', 'Weerstandspunten', 'punten', 'Tegenpunten'],
];
$ws->fromArray($a, null, 'A1');
$ws->getStyle('A1:L1')->applyFromArray(self::STYLEBOLD);
$ws->getStyle('A1:L1')->applyFromArray(self::STYLESIZE14);
$lijn = 1;
for ($i = 1; $i <= $this->trn['RONDEN']; ++$i) {//aantal ronden oneven->heen en even->terug
$countSaring = count($saring);
for ($j = 0; $j < $countSaring; ++$j) {//subronden
++$lijn;
if (isset($KD[(($i - 1) * $this->trn['SUB_RONDEN']) + $j], $KD[(($i - 1) * $this->trn['SUB_RONDEN']) + $j]['RONDE'])) {
$ws->setCellValue([9, $lijn], $KD[(($i - 1) * $this->trn['SUB_RONDEN']) + $j]['RONDE']);
} else {
$ws->setCellValue([9, $lijn], 'Kalenderdata zijn niet(volledig) ingevuld');
}
if (isset($KD[(($i - 1) * $this->trn['SUB_RONDEN']) + $j], $KD[(($i - 1) * $this->trn['SUB_RONDEN']) + $j]['TXT'])) {
$ws->setCellValue([10, $lijn], $KD[(($i - 1) * $this->trn['SUB_RONDEN']) + $j]['TXT']);
} else {
$ws->setCellValue([10, $lijn], 'Kalenderdata zijn niet(volledig) ingevuld');
}
$ws->getStyle('A' . $lijn . ':L' . $lijn . '')->applyFromArray(self::STYLEBOLD14);
$s2 = explode(' ', $saring[$j]);
$counts2 = count($s2);
for ($k = 0; $k < $counts2; ++$k) {//borden
if (trim($s2[$k]) == '') {
continue;
}
$s3 = explode('-', $s2[$k]); //wit-zwart
$s3[0] = (int) $s3[0];
$s3[1] = (int) $s3[1];
++$lijn;
$ws->setCellValue([1, $lijn], '=IF(SUBSTITUTE(TRIM($J' . $lijn . '),"-","")="","",XLOOKUP($K' . $lijn . ',Spelers!$B$2:$B$' . (count($s) + 1) . ',Spelers!$C$2:$C$' . (count($s) + 1) . ',FALSE) * VLOOKUP(J' . $lijn . ', PuntenLijst,4,FALSE))');
$ws->setCellValue([2, $lijn], '=IF(SUBSTITUTE(TRIM($J' . $lijn . '),"-","")="","",VLOOKUP($K' . $lijn . ',Spelers!$B$2:$D$' . (count($s) + 1) . ',3,FALSE) * VLOOKUP(J' . $lijn . ', PuntenLijst,5,FALSE))');
$ws->setCellValue([3, $lijn], '=IF(TRIM($J' . $lijn . ')="","",XLOOKUP($J' . $lijn . ', Punten!$A$2:$A$50,Punten!$B$2:$B$50,0,0))');
$ws->setCellValue([4, $lijn], '=IF(TRIM($J' . $lijn . ')="","",XLOOKUP($J' . $lijn . ', Punten!$A$2:$A$50,Punten!$G$2:$G$50,0,0))');
$ws->setCellValue([5, $lijn], '=IF(SUBSTITUTE(TRIM($J' . $lijn . '),"-","")="","",VLOOKUP($I' . $lijn . ',Spelers!$B$2:$D$' . (count($s) + 1) . ',3,FALSE) * VLOOKUP(J' . $lijn . ', PuntenLijst,6,FALSE))');
$ws->setCellValue([6, $lijn], '=IF(SUBSTITUTE(TRIM($J' . $lijn . '),"-","")="","",VLOOKUP($I' . $lijn . ',Spelers!$B$2:$D$' . (count($s) + 1) . ',3,FALSE) * VLOOKUP(J' . $lijn . ', PuntenLijst,5,FALSE))');
$ws->setCellValue([7, $lijn], '=IF(TRIM($J' . $lijn . ')="","",XLOOKUP($J' . $lijn . ', Punten!$A$2:$A$50,Punten!$C$2:$C$50,0,0))');
$ws->setCellValue([8, $lijn], '=IF(TRIM($J' . $lijn . ')="","",XLOOKUP($J' . $lijn . ', Punten!$A$2:$A$50,Punten!$H$2:$H$50,0,0))');
if ($this->odd($i)) {
if (
isset($g[$i][$si[((int) $s3[0]) - 1]][$si[((int) $s3[1]) - 1]])
) {
$pw = $g[$i][$si[((int) $s3[0]) - 1]][$si[((int) $s3[1]) - 1]];
} else {
$pw = ['SYMBOOLWIT' => '', 'SYMBOOLZWART' => '', 'UITSLAG' => '', 'OPMERKING' => '', 'DATUM' => ''];
}
$ws->setCellValue([9, $lijn], '=Spelers!$B$' . ($s3[0] + 1));
$ws->setCellValue([11, $lijn], '=Spelers!$B$' . ($s3[1] + 1));
} else {
if (
isset($g[$i][$si[((int) $s3[1]) - 1]][$si[((int) $s3[0]) - 1]])
) {
$pw = $g[$i][$si[((int) $s3[1]) - 1]][$si[((int) $s3[0]) - 1]];
} else {
$pw = ['SYMBOOLWIT' => '', 'SYMBOOLZWART' => '', 'UITSLAG' => '', 'OPMERKING' => '', 'DATUM' => ''];
}
$ws->setCellValue([9, $lijn], '=Spelers!$B$' . ($s3[1] + 1));
$ws->setCellValue([11, $lijn], '=Spelers!$B$' . ($s3[0] + 1));
}
if ($pw['SYMBOOLWIT'] != '') {
$ws->setCellValue([10, $lijn], $pw['SYMBOOLWIT'] . '-' . $pw['SYMBOOLZWART']);
}
$ws->setCellValue([13, $lijn], $pw['OPMERKING']);
$ws->setCellValue([14, $lijn], $pw['DATUM']);
$this->doValidationPunten($ws, 'J' . $lijn);
$ws->getRowDimension($lijn)->setOutlineLevel(1);
}
++$lijn;
}
++$lijn;
}
$ws->getStyle('J1:J' . $lijn)->applyFromArray(self::STYLECENTER);
$ws->getColumnDimension('A')->setVisible(false);
$ws->getColumnDimension('B')->setVisible(false);
$ws->getColumnDimension('C')->setVisible(false);
$ws->getColumnDimension('D')->setVisible(false);
$ws->getColumnDimension('E')->setVisible(false);
$ws->getColumnDimension('F')->setVisible(false);
$ws->getColumnDimension('G')->setVisible(false);
$ws->getColumnDimension('H')->setVisible(false);
for ($i = 65; $i < ord('M'); ++$i) {
$ws->getColumnDimension(chr($i))->setAutoSize(true);
}
$ws->setAutoFilter('A2:M' . $lijn);
$ws->setSelectedCell('A1');
return $lijn;
}
private function doValidationPunten(Worksheet $s, string $cel): void
{
$validation = $s->getCell($cel)->getDataValidation();
$validation->setType(DataValidation::TYPE_LIST);
$validation->setErrorStyle(DataValidation::STYLE_STOP);
$validation->setAllowBlank(false);
$validation->setShowInputMessage(false);
$validation->setShowErrorMessage(true);
$validation->setShowDropDown(true);
$validation->setFormula1('=punten');
}
private function doPunten(Spreadsheet $ss, Worksheet $ws): void
{
$ws->fromArray(['Uitslag', 'Wit', 'Zwart', 'Winstverhouding WIT', 'Weerstandverhouding', 'Winstverhouding ZWART', 'Tegenpunten Wit', 'Tegenpunten Zwart'], null, 'A1');
$ws->fromArray(['0-3', '0', '3', '0', '1', '1', '0', '0'], null, 'A2');
$ws->fromArray(['1-3', '1', '3', '0', '1', '1', '0', '-1'], null, 'A3');
$ws->fromArray(['2-3', '2', '3', '0', '1', '1', '0', '-2'], null, 'A4');
$ws->fromArray(['3-0', '3', '0', '1', '1', '0', '0', '0'], null, 'A5');
$ws->fromArray(['3-1', '3', '1', '1', '1', '0', '-1', '0'], null, 'A6');
$ws->fromArray(['3-2', '3', '2', '1', '1', '0', '-2', '0'], null, 'A7');
$ws->fromArray(['U-U', '0', '0', '0', '0', '0', '0', '0'], null, 'A8');
$ss->addNamedRange(new NamedRange('Punten', $ws, '=$A$2:$A$8'));
$ss->addNamedRange(new NamedRange('PuntenLijst', $ws, '=$A$2:$H$8'));
$ws->getStyle('A1:H1')->applyFromArray(self::STYLETHICKBORDER);
$ws->getStyle('A1:A8')->applyFromArray(self::STYLETHICKBORDER);
$ws->getStyle('B2:H8')->applyFromArray(self::STYLETHICKBORDER);
for ($i = 65; $i < ord('I'); ++$i) {
$ws->getColumnDimension(chr($i))->setAutoSize(true);
}
$ws->setSelectedCell('A1');
}
private function doSpelers(Worksheet $ws, int $maxLijn): void
{
$this->doKoppen($ws);
$i = 1;
foreach ($this->trn['SPELERS'] as $speler) {
$ws->setCellValue([1, ++$i], '=RANK(D' . $i . ',$D$2:$D$' . (count($this->trn['SPELERS']) + 1) . ',0)-1+COUNTIF($D$2:D' . $i . ',D' . $i . ')');
$ws->setCellValue([2, $i], $speler);
$ws->setCellValue([3, $i], '=COUNTIFS(Partijen!$I$3:$I$' . $maxLijn . ',$B' . $i . ',Partijen!$J$3:$J$' . $maxLijn . ',"<>")+COUNTIFS(Partijen!$K$3:$K$' . $maxLijn . ',Spelers!$B' . $i . ',Partijen!$J$3:$J$' . $maxLijn . ',"<>")'); // - SUM(H' . $i . ':I' . $i . ')
$ws->setCellValue([4, $i], '=SUMIFS(Partijen!C$3:C$' . $maxLijn . ',Partijen!$I$3:$I$' . $maxLijn . ',$B' . $i . ')+SUMIFS(Partijen!G$3:G$' . $maxLijn . ',Partijen!$K$3:$K$' . $maxLijn . ',$B' . $i . ')');
$ws->setCellValue([5, $i], '=SUMIFS(Partijen!D$3:D$' . $maxLijn . ',Partijen!$I$3:$I$' . $maxLijn . ',$B' . $i . ')+SUMIFS(Partijen!H$3:H$' . $maxLijn . ',Partijen!$K$3:$K$' . $maxLijn . ',$B' . $i . ')');
$ws->setCellValue([6, $i], '=SUMIFS(Partijen!A$3:A$' . $maxLijn . ',Partijen!$I$3:$I$' . $maxLijn . ',$B' . $i . ')+SUMIFS(Partijen!E$3:E$' . $maxLijn . ',Partijen!$K$3:$K$' . $maxLijn . ',$B' . $i . ')');
$ws->setCellValue([7, $i], '=SUMIFS(Partijen!B$3:B$' . $maxLijn . ',Partijen!$I$3:$I$' . $maxLijn . ',$B' . $i . ')+SUMIFS(Partijen!F$3:F$' . $maxLijn . ',Partijen!$K$3:$K$' . $maxLijn . ',$B' . $i . ')');
$ws->setCellValue([8, $i], '=C' . $i . '*MAX(Punten!$B$2:$B$50)-D' . $i . '');
}
$ws->setSelectedCell('A1');
}
private function doSort1(Worksheet $ws): void
{
$ws->setCellValue('A2', '=FILTER(SORTBY(Spelers!A2:H101,Spelers!D2:D101,-1,Spelers!E2:E101,1),(Spelers!B2:B101<>"Bye")*(NOT(ISBLANK(Spelers!B2:B101))))');
$this->doKoppen($ws);
$ws->setSelectedCell('A1');
}
private function doSort2(Worksheet $ws): void
{
$ws->setCellValue('A2', '=SORT(FILTER(Spelers!A2:H101,(Spelers!B2:B101<>"Bye") * (NOT(ISBLANK(Spelers!B2:B101)))),7,1,FALSE)');
$this->doKoppen($ws);
$ws->setSelectedCell('A1');
}
private function doKoppen(Worksheet $ws): void
{
$ws->setCellValue('A1', 'Plaats');
$ws->setCellValue('B1', 'Naam');
$ws->setCellValue('C1', 'Partijen');
$ws->setCellValue('D1', 'Punten');
$ws->setCellValue('E1', 'Tegenpunten');
$ws->setCellValue('F1', 'Winstpunten');
$ws->setCellValue('G1', 'Weerstandspunten');
$ws->setCellValue('H1', 'Verlorenpunten');
for ($i = 65; $i < ord('I'); ++$i) {
$ws->getColumnDimension(chr($i))->setAutoSize(true);
}
$ws->getStyle('A1:H1')->applyFromArray(self::STYLEBOLD);
}
public function testManyArraysOutput(): void
{
$json = file_get_contents('tests/data/Writer/XLSX/ArrayFunctions2.json');
self::assertNotFalse($json);
$trn = json_decode($json, true);
self::assertIsArray($trn);
$this->trn = $trn;
$spreadsheet = new Spreadsheet();
Calculation::getInstance($spreadsheet)->setInstanceArrayReturnType(Calculation::RETURN_ARRAY_AS_ARRAY);
$wsPartijen = $spreadsheet->getActiveSheet();
$wsPartijen->setTitle('Partijen');
$wsPunten = new Worksheet($spreadsheet, 'Punten');
$wsSpelers = new Worksheet($spreadsheet, 'Spelers');
$wsSort1 = new Worksheet($spreadsheet, 'Gesorteerd punten');
$wsSort2 = new Worksheet($spreadsheet, 'Gesorteerd verlorenpunten');
$wsPartijen->getTabColor()->setRGB('FF0000');
$wsPunten->getTabColor()->setRGB('00FF00');
$wsSpelers->getTabColor()->setRGB('0000FF');
$wsSort1->getTabColor()->setRGB('FFFF00');
$wsSort2->getTabColor()->setRGB('00FFFF');
foreach ([$wsPunten, $wsSpelers, $wsSort1, $wsSort2] as $ws) {
$spreadsheet->addSheet($ws);
}
$this->doPunten($spreadsheet, $wsPunten);
$maxLijn = $this->doPartijen($wsPartijen);
$this->doSpelers($wsSpelers, $maxLijn);
$this->doSort1($wsSort1);
$this->doSort2($wsSort2);
self::assertSame('Dirk', $wsPartijen->getCell('I3')->getCalculatedValue());
self::assertSame('Rudy', $wsPartijen->getCell('K4')->getCalculatedValue());
$calcArray = $wsSort2->getCell('A2')->getCalculatedValue();
self::assertCount(8, $calcArray);
$spreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Xlsx/Issue2082Test.php | tests/PhpSpreadsheetTests/Writer/Xlsx/Issue2082Test.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Xlsx;
use PhpOffice\PhpSpreadsheet\Shared\File;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Writer\Xlsx as Writer;
use PHPUnit\Framework\TestCase;
class Issue2082Test extends TestCase
{
public function testBoolWrite(): void
{
// Problem writing boolean function values is detected only when
// opening spreadsheet in Excel 2007-2016. Test verifies that
// value field is written correctly for those versions.
$outputFilename = File::temporaryFilename();
$spreadsheet = new Spreadsheet();
$worksheet = $spreadsheet->getActiveSheet();
$worksheet->fromArray(['A', 'B', 'C', 'D']);
$worksheet->getCell('A2')->setValue('=A1<>"A"');
$worksheet->getCell('A3')->setValue('=A1="A"');
$worksheet->getCell('B2')->setValue('=LEFT(B1, 0)');
$worksheet->getCell('B3')->setValue('=B2=""');
$writer = new Writer($spreadsheet);
$writer->save($outputFilename);
$zipfile = "zip://$outputFilename#xl/worksheets/sheet1.xml";
$contents = file_get_contents($zipfile);
unlink($outputFilename);
if ($contents === false) {
self::fail('Unable to open file');
} else {
self::assertStringContainsString('<c r="A2" t="b"><f>A1<>"A"</f><v>0</v></c>', $contents);
self::assertStringContainsString('<c r="A3" t="b"><f>A1="A"</f><v>1</v></c>', $contents);
self::assertStringContainsString('<c r="B2" t="str"><f>LEFT(B1, 0)</f><v></v></c>', $contents);
self::assertStringContainsString('<c r="B3" t="b"><f>B2=""</f><v>1</v></c>', $contents);
}
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Xlsx/TransparentDrawingsTest.php | tests/PhpSpreadsheetTests/Writer/Xlsx/TransparentDrawingsTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Xlsx;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Worksheet\Drawing;
use PhpOffice\PhpSpreadsheetTests\Functional\AbstractFunctional;
class TransparentDrawingsTest extends AbstractFunctional
{
/**
* Save and load XLSX with 2-cell anchor drawing with transparency.
*/
public function testTwoCellAnchorTransparent(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
// Add gif image that coordinates is two cell anchor.
$drawing = new Drawing();
$drawing->setName('Blue Square');
$drawing->setPath('tests/data/Writer/XLSX/blue_square.png');
self::assertEquals($drawing->getWidth(), 100);
self::assertEquals($drawing->getHeight(), 100);
$drawing->setCoordinates('A1');
$drawing->setOffsetX(30);
$drawing->setOffsetY(10);
$drawing->setCoordinates2('E8');
$drawing->setOffsetX2(-50);
$drawing->setOffsetY2(-20);
$drawing->setOpacity(40000);
$drawing->setWorksheet($sheet);
// Write file
$reloadedSpreadsheet = $this->writeAndReload($spreadsheet, 'Xlsx');
$spreadsheet->disconnectWorksheets();
$rsheet = $reloadedSpreadsheet->getActiveSheet();
// Check image coordinates.
$drawingCollection = $rsheet->getDrawingCollection();
self::assertCount(1, $drawingCollection);
$drawing = $drawingCollection[0];
self::assertNotNull($drawing);
self::assertSame(100, $drawing->getWidth());
self::assertSame(100, $drawing->getHeight());
self::assertSame('A1', $drawing->getCoordinates());
self::assertSame(30, $drawing->getOffsetX());
self::assertSame(10, $drawing->getOffsetY());
self::assertSame('E8', $drawing->getCoordinates2());
self::assertSame(-50, $drawing->getOffsetX2());
self::assertSame(-20, $drawing->getOffsetY2());
self::assertSame(40000, $drawing->getOpacity());
self::assertSame($rsheet, $drawing->getWorksheet());
$reloadedSpreadsheet->disconnectWorksheets();
}
/**
* Save and load XLSX with 1-cell anchor drawing with transparency.
*/
public function testOneCellAnchorTransparent(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
// Add gif image that coordinates is two cell anchor.
$drawing = new Drawing();
$drawing->setName('Blue Square');
$drawing->setPath('tests/data/Writer/XLSX/blue_square.png');
//self::assertEquals($drawing->getWidth(), 100);
//self::assertEquals($drawing->getHeight(), 100);
$drawing->setCoordinates('A1');
$drawing->setOpacity(40000);
$drawing->setWorksheet($sheet);
// Write file
$reloadedSpreadsheet = $this->writeAndReload($spreadsheet, 'Xlsx');
$spreadsheet->disconnectWorksheets();
$rsheet = $reloadedSpreadsheet->getActiveSheet();
// Check image coordinates.
$drawingCollection = $rsheet->getDrawingCollection();
self::assertCount(1, $drawingCollection);
$drawing = $drawingCollection[0];
self::assertNotNull($drawing);
self::assertSame(100, $drawing->getWidth());
self::assertSame(100, $drawing->getHeight());
self::assertSame('A1', $drawing->getCoordinates());
self::assertSame(40000, $drawing->getOpacity());
self::assertSame($rsheet, $drawing->getWorksheet());
$reloadedSpreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Xlsx/StartsWithHashTest.php | tests/PhpSpreadsheetTests/Writer/Xlsx/StartsWithHashTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Xlsx;
use PhpOffice\PhpSpreadsheet\Cell\DataType;
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;
use ZipArchive;
class StartsWithHashTest extends TestCase
{
public function testStartWithHash(): void
{
$outputFilename = File::temporaryFilename();
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->setCellValueExplicit('A1', '#define M', DataType::TYPE_STRING);
$sheet->setCellValue('A2', '=A1');
$sheet->setCellValue('A3', '=UNKNOWNFUNC()');
$writer = new Writer($spreadsheet);
$writer->save($outputFilename);
$reader = new Reader();
$sheet = $reader->load($outputFilename);
unlink($outputFilename);
self::assertSame('#define M', $sheet->getActiveSheet()->getCell('A1')->getValue());
self::assertSame('#define M', $sheet->getActiveSheet()->getCell('A2')->getCalculatedValue());
self::assertSame('f', $sheet->getActiveSheet()->getCell('A3')->getDataType());
self::assertSame('#NAME?', $sheet->getActiveSheet()->getCell('A3')->getCalculatedValue());
self::assertSame('f', $sheet->getActiveSheet()->getCell('A3')->getDataType());
}
public function testStartWithHashReadRaw(): void
{
// Make sure raw data indicates A3 is an error, but A2 isn't.
$outputFilename = File::temporaryFilename();
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->setCellValueExplicit('A1', '#define M', DataType::TYPE_STRING);
$sheet->setCellValue('A2', '=A1');
$sheet->setCellValue('A3', '=UNKNOWNFUNC()');
$writer = new Writer($spreadsheet);
$writer->save($outputFilename);
$zip = new ZipArchive();
$zip->open($outputFilename);
$resultSheet1Raw = $zip->getFromName('xl/worksheets/sheet1.xml');
$zip->close();
unlink($outputFilename);
self::assertStringContainsString('<c r="A3" t="e">', $resultSheet1Raw);
self::assertStringContainsString('<c r="A2" t="str">', $resultSheet1Raw);
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Xlsx/DataValidationTest.php | tests/PhpSpreadsheetTests/Writer/Xlsx/DataValidationTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Xlsx;
use PhpOffice\PhpSpreadsheet\Cell\DataValidation;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheetTests\Functional\AbstractFunctional;
class DataValidationTest extends AbstractFunctional
{
public function testWholeRow(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$dv = new DataValidation();
$dv->setType(DataValidation::TYPE_NONE);
$sheet->setDataValidation('C1:F1', $dv);
$dv = new DataValidation();
$dv->setType(DataValidation::TYPE_LIST)
->setShowDropDown(true)
->setFormula1('"Item A,Item B,Item C"')
->setErrorStyle(DataValidation::STYLE_STOP)
->setShowErrorMessage(true)
->setErrorTitle('Input Error')
->setError('Value is not a member of allowed list');
$sheet->setDataValidation('1:1', $dv);
$dv = new DataValidation();
$dv->setType(DataValidation::TYPE_NONE);
$sheet->setDataValidation('H1', $dv);
$robj = $this->writeAndReload($spreadsheet, 'Xlsx');
$spreadsheet->disconnectWorksheets();
$sheet0 = $robj->getActiveSheet();
self::assertSame(['H1', 'C1:F1', '1:1'], array_keys($sheet0->getDataValidationCollection()));
$robj->disconnectWorksheets();
}
public function testWholeColumn(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->getCell('C1')->setValue(1);
$sheet->getCell('C2')->setValue(2);
$sheet->getCell('C3')->setValue(3);
$dv = $sheet->getDataValidation('A5:A7');
$dv->setType(DataValidation::TYPE_NONE);
$dv = new DataValidation();
$dv->setType(DataValidation::TYPE_LIST)
->setShowDropDown(true)
->setFormula1('$C$1:$C$3')
->setErrorStyle(DataValidation::STYLE_STOP)
->setShowErrorMessage(true)
->setErrorTitle('Input Error')
->setError('Value is not a member of allowed list');
$sheet->setDataValidation('A:A', $dv);
$dv = new DataValidation();
$dv->setType(DataValidation::TYPE_NONE);
$sheet->setDataValidation('A9', $dv);
$robj = $this->writeAndReload($spreadsheet, 'Xlsx');
$spreadsheet->disconnectWorksheets();
$sheet0 = $robj->getActiveSheet();
self::assertSame(['A9', 'A5:A7', 'A:A'], array_keys($sheet0->getDataValidationCollection()));
$robj->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Xlsx/Issue3711Test.php | tests/PhpSpreadsheetTests/Writer/Xlsx/Issue3711Test.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Xlsx;
use PhpOffice\PhpSpreadsheet\Cell\DataType;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheetTests\Functional\AbstractFunctional;
class Issue3711Test extends AbstractFunctional
{
public function testIssue3711(): void
{
// Issue 3711 - float being used as index in StringTable.
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->getCell('A1')->setValue('21.5');
self::assertSame(21.5, $sheet->getCell('A1')->getValue());
$sheet->getCell('A1')->setDataType(DataType::TYPE_STRING);
$sheet->getCell('A2')->setValue('21');
self::assertSame(21, $sheet->getCell('A2')->getValue());
$sheet->getCell('A2')->setDataType(DataType::TYPE_STRING);
$reloadedSpreadsheet = $this->writeAndReload($spreadsheet, 'Xlsx');
$spreadsheet->disconnectWorksheets();
$rsheet = $reloadedSpreadsheet->getActiveSheet();
self::assertSame('21.5', $rsheet->getCell('A1')->getValue());
self::assertSame('21', $rsheet->getCell('A2')->getValue());
$reloadedSpreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Xlsx/ThemeFontsTest.php | tests/PhpSpreadsheetTests/Writer/Xlsx/ThemeFontsTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Xlsx;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheetTests\Functional\AbstractFunctional;
class ThemeFontsTest extends AbstractFunctional
{
public function testFont2(): void
{
$spreadsheet = new Spreadsheet();
$spreadsheet->getTheme()
->setThemeFontName('custom')
->setMajorFontValues('Arial', 'Arial', 'Arial', [])
->setMinorFontValues('Arial', 'Arial', 'Arial', []);
$spreadsheet->getDefaultStyle()
->getFont()
->setName('Arial')
->setScheme('minor');
$sheet = $spreadsheet->getActiveSheet();
$sheet->getCell('A1')->setValue('header');
$sheet->getStyle('A1')->getFont()->setScheme('major');
$sheet->getCell('A2')->setValue('body');
$sheet->getStyle('A2')->getFont()->setScheme('minor');
$sheet->getCell('A3')->setValue('default');
$sheet->getCell('A4')->setValue('noscheme');
$sheet->getStyle('A4')->getFont()->setScheme('');
$sheet->getCell('A5')->setValue('nottheme');
$sheet->getStyle('A5')->getFont()->setName('Courier New');
$sheet->getCell('A6')->setValue('dflt bold');
$sheet->getStyle('A6')->getFont()->setBold(true);
$reloadedSpreadsheet = $this->writeAndReload($spreadsheet, 'Xlsx');
$spreadsheet->disconnectWorksheets();
self::assertSame('Arial', $spreadsheet->getTheme()->getMajorFontLatin());
self::assertSame('Arial', $spreadsheet->getTheme()->getMinorFontLatin());
$rsheet = $reloadedSpreadsheet->getActiveSheet();
self::assertSame('Arial', $rsheet->getStyle('A1')->getFont()->getName());
self::assertSame('major', $rsheet->getStyle('A1')->getFont()->getScheme());
self::assertSame('Arial', $rsheet->getStyle('A2')->getFont()->getName());
self::assertSame('minor', $rsheet->getStyle('A2')->getFont()->getScheme());
self::assertSame('Arial', $rsheet->getStyle('A3')->getFont()->getName());
self::assertSame('minor', $rsheet->getStyle('A3')->getFont()->getScheme());
self::assertSame('Arial', $rsheet->getStyle('A4')->getFont()->getName());
self::assertSame('', $rsheet->getStyle('A4')->getFont()->getScheme());
self::assertSame('Courier New', $rsheet->getStyle('A5')->getFont()->getName());
self::assertSame('', $rsheet->getStyle('A5')->getFont()->getScheme(), 'setting name disables scheme');
self::assertSame('Arial', $rsheet->getStyle('A6')->getFont()->getName());
self::assertSame('minor', $rsheet->getStyle('A6')->getFont()->getScheme());
self::assertTrue($rsheet->getStyle('A6')->getFont()->getBold(), 'setting other properties does not disable scheme');
$reloadedSpreadsheet->getTheme()
->setThemeFontName('custom')
->setMajorFontValues('Times New Roman', 'Times New Roman', 'Times New Roman', [])
->setMinorFontValues('Tahoma', 'Tahoma', 'Tahoma', []);
$reloadedSpreadsheet->resetThemeFonts();
self::assertSame('Times New Roman', $rsheet->getStyle('A1')->getFont()->getName());
self::assertSame('major', $rsheet->getStyle('A1')->getFont()->getScheme());
self::assertSame('Tahoma', $rsheet->getStyle('A2')->getFont()->getName());
self::assertSame('minor', $rsheet->getStyle('A2')->getFont()->getScheme());
self::assertSame('Tahoma', $rsheet->getStyle('A3')->getFont()->getName());
self::assertSame('minor', $rsheet->getStyle('A3')->getFont()->getScheme());
self::assertSame('Arial', $rsheet->getStyle('A4')->getFont()->getName());
self::assertSame('', $rsheet->getStyle('A4')->getFont()->getScheme());
self::assertSame('Courier New', $rsheet->getStyle('A5')->getFont()->getName());
self::assertSame('', $rsheet->getStyle('A5')->getFont()->getScheme(), 'setting name disables scheme');
self::assertSame('Tahoma', $rsheet->getStyle('A6')->getFont()->getName());
self::assertSame('minor', $rsheet->getStyle('A6')->getFont()->getScheme());
self::assertTrue($rsheet->getStyle('A6')->getFont()->getBold(), 'setting other properties does not disable scheme');
$reloadedSpreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Xlsx/HyperlinkTest.php | tests/PhpSpreadsheetTests/Writer/Xlsx/HyperlinkTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Xlsx;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheetTests\Functional\AbstractFunctional;
class HyperlinkTest extends AbstractFunctional
{
public function testHyperlink(): void
{
$spreadsheet = new Spreadsheet();
$sheet1 = $spreadsheet->getActiveSheet();
$sheet1->setTitle('First');
$sheet2 = $spreadsheet->createSheet();
$sheet2->setTitle('Second');
$sheet2->setCellValue('A100', 'other sheet');
$sheet1->setCellValue('A100', 'this sheet');
$sheet1->setCellValue('A1', '=HYPERLINK("#A100", "here")');
$sheet1->setCellValue('A2', '=HYPERLINK("#Second!A100", "there")');
$sheet1->setCellValue('A3', '=HYPERLINK("http://example.com", "external")');
$sheet1->setCellValue('A4', 'gotoA101');
$sheet1->getCell('A4')
->getHyperlink()
->setUrl('#A101');
$robj = $this->writeAndReload($spreadsheet, 'Xlsx');
$spreadsheet->disconnectWorksheets();
$sheet0 = $robj->setActiveSheetIndex(0);
self::assertSame('sheet://#A100', $sheet0->getCell('A1')->getHyperlink()->getUrl());
self::assertSame('sheet://#Second!A100', $sheet0->getCell('A2')->getHyperlink()->getUrl());
self::assertSame('http://example.com', $sheet0->getCell('A3')->getHyperlink()->getUrl());
self::assertSame('sheet://#A101', $sheet0->getCell('A4')->getHyperlink()->getUrl());
$robj->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Xlsx/DrawingPassThroughTest.php | tests/PhpSpreadsheetTests/Writer/Xlsx/DrawingPassThroughTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\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;
use ZipArchive;
class DrawingPassThroughTest extends AbstractFunctional
{
private const DIRECTORY = 'tests/data/Writer/XLSX/';
private const TEMPLATE = self::DIRECTORY . 'issue.4037.xlsx';
/**
* Test that unsupported drawing elements (shapes, textboxes) are preserved
* when pass-through is enabled and no drawings are modified.
*/
public function testDrawingPassThroughPreservesUnsupportedElements(): void
{
// Load with pass-through enabled
$reader = new XlsxReader();
$reader->setEnableDrawingPassThrough(true);
$spreadsheet = $reader->load(self::TEMPLATE);
$sheet = $spreadsheet->getActiveSheet();
// Verify that drawing collection contains only the image (supported element)
$drawings = $sheet->getDrawingCollection();
self::assertCount(1, $drawings, 'Drawing collection should contain only the image (supported element)');
// Verify that unparsed data contains the original drawing XML with shapes
$unparsedData = $spreadsheet->getUnparsedLoadedData();
$codeName = $sheet->getCodeName();
self::assertArrayHasKey('sheets', $unparsedData);
self::assertIsArray($unparsedData['sheets']);
self::assertArrayHasKey($codeName, $unparsedData['sheets']);
self::assertIsArray($unparsedData['sheets'][$codeName]);
self::assertArrayHasKey('Drawings', $unparsedData['sheets'][$codeName]);
// Verify that the drawing XML contains shapes and textboxes
self::assertIsArray($unparsedData['sheets'][$codeName]['Drawings']);
$drawings = $unparsedData['sheets'][$codeName]['Drawings'];
$originalDrawingXml = reset($drawings);
self::assertIsString($originalDrawingXml);
self::assertStringContainsString('<xdr:sp', $originalDrawingXml, 'Original XML should contain shape element');
self::assertStringContainsString('<xdr:txBody>', $originalDrawingXml, 'Original XML should contain textbox element');
// Save to file
$tempFile = File::temporaryFilename();
$writer = new XlsxWriter($spreadsheet);
$writer->save($tempFile);
$spreadsheet->disconnectWorksheets();
// Verify that the saved XLSX file contains shapes by reading the drawing XML directly
$zip = new ZipArchive();
$zip->open($tempFile);
$drawingXml = $zip->getFromName('xl/drawings/drawing1.xml');
$zip->close();
unlink($tempFile);
self::assertNotFalse($drawingXml, 'Drawing XML should exist in saved file');
self::assertStringContainsString('<xdr:sp>', $drawingXml, 'Shapes should be preserved in saved file');
self::assertStringContainsString('<xdr:txBody>', $drawingXml, 'Textboxes should be preserved in saved file');
}
/**
* Test that WITHOUT Reader pass-through flag, shapes are NOT stored and are LOST.
* This test uses a file with both an image (supported) and a shape (unsupported).
*/
public function testWithoutReaderPassThroughShapesAreLost(): void
{
// First, verify that the original file contains a shape
// Load WITH pass-through to check file contents
$reader = new XlsxReader();
$reader->setEnableDrawingPassThrough(true);
$spreadsheet = $reader->load(self::TEMPLATE);
$unparsedData = $spreadsheet->getUnparsedLoadedData();
$codeName = $spreadsheet->getActiveSheet()->getCodeName();
self::assertIsArray($unparsedData['sheets']);
self::assertArrayHasKey($codeName, $unparsedData['sheets']);
self::assertIsArray($unparsedData['sheets'][$codeName]);
self::assertArrayHasKey('Drawings', $unparsedData['sheets'][$codeName], 'Original file should have drawings');
self::assertIsArray($unparsedData['sheets'][$codeName]['Drawings']);
$drawings = $unparsedData['sheets'][$codeName]['Drawings'];
$drawingXml = reset($drawings);
self::assertIsString($drawingXml);
self::assertStringContainsString('<xdr:sp', $drawingXml, 'Original file should contain shape');
$spreadsheet->disconnectWorksheets();
// Now test: Load WITHOUT Reader pass-through (XML not stored)
$reader = new XlsxReader();
// Don't enable pass-through!
$spreadsheet = $reader->load(self::TEMPLATE);
$sheet = $spreadsheet->getActiveSheet();
// Verify that image is in collection (supported element)
$drawings = $sheet->getDrawingCollection();
self::assertGreaterThan(0, count($drawings), 'Drawing collection should contain the image');
// Verify that shape XML is NOT stored (because pass-through disabled)
$unparsedData = $spreadsheet->getUnparsedLoadedData();
$codeName = $sheet->getCodeName();
self::assertIsArray($unparsedData['sheets']);
$sheetData = $unparsedData['sheets'][$codeName] ?? [];
self::assertArrayNotHasKey('Drawings', $sheetData, 'Drawings should NOT be stored without Reader pass-through flag');
// Save to file
$writer = new XlsxWriter($spreadsheet);
$tempFile = File::temporaryFilename();
$writer->save($tempFile);
$spreadsheet->disconnectWorksheets();
// Verify that shape is LOST by reading the drawing XML directly
$zip = new ZipArchive();
$zip->open($tempFile);
$drawingXml = $zip->getFromName('xl/drawings/drawing1.xml');
$zip->close();
unlink($tempFile);
// The saved file should have drawing XML (for the image) but NOT the shape or textbox
self::assertNotFalse($drawingXml, 'Drawing XML should exist (for the image)');
self::assertStringNotContainsString('<xdr:sp>', $drawingXml, 'Shape should be lost without Reader pass-through');
self::assertStringNotContainsString('<xdr:txBody>', $drawingXml, 'Textbox should be lost without Reader pass-through');
}
/**
* Test that pass-through preserves drawings when a comment is deleted.
* Comments are independent from drawings, so deleting a comment should not affect drawings.
*/
public function testDrawingPassThroughWithCommentDeletion(): void
{
// Load with pass-through enabled
$reader = new XlsxReader();
$reader->setEnableDrawingPassThrough(true);
$spreadsheet = $reader->load(self::TEMPLATE);
$sheet = $spreadsheet->getActiveSheet();
// Verify that image is in collection
$drawings = $sheet->getDrawingCollection();
self::assertGreaterThan(0, count($drawings), 'Drawing collection should contain the image');
// Verify that shapes and textboxes are in unparsed data
$unparsedData = $spreadsheet->getUnparsedLoadedData();
$codeName = $sheet->getCodeName();
self::assertIsArray($unparsedData['sheets']);
self::assertArrayHasKey($codeName, $unparsedData['sheets']);
self::assertIsArray($unparsedData['sheets'][$codeName]);
self::assertArrayHasKey('Drawings', $unparsedData['sheets'][$codeName]);
self::assertIsArray($unparsedData['sheets'][$codeName]['Drawings']);
$drawings = $unparsedData['sheets'][$codeName]['Drawings'];
$originalDrawingXml = reset($drawings);
self::assertIsString($originalDrawingXml);
self::assertStringContainsString('<xdr:sp', $originalDrawingXml, 'Original XML should contain shape');
self::assertStringContainsString('<xdr:txBody>', $originalDrawingXml, 'Original XML should contain textbox');
// Verify that a comment exists and delete it
$comments = $sheet->getComments();
self::assertGreaterThan(0, count($comments), 'Original file should have at least one comment');
$firstCommentCell = array_key_first($comments);
self::assertIsString($firstCommentCell, 'Comment cell should be a string');
$originalCommentText = $sheet->getComment($firstCommentCell)->getText()->getPlainText();
self::assertNotEmpty($originalCommentText, 'Comment should have text');
// Delete the comment
$sheet->removeComment($firstCommentCell);
// Save to file
$tempFile = File::temporaryFilename();
$writer = new XlsxWriter($spreadsheet);
$writer->save($tempFile);
$spreadsheet->disconnectWorksheets();
// Verify that shapes are still present and comment was deleted
$zip = new ZipArchive();
$zip->open($tempFile);
$drawingXml = $zip->getFromName('xl/drawings/drawing1.xml');
$commentsXml = $zip->getFromName('xl/comments1.xml');
$zip->close();
unlink($tempFile);
self::assertNotFalse($drawingXml, 'Drawing XML should exist in saved file');
self::assertStringContainsString('<xdr:sp>', $drawingXml, 'Shapes should be preserved after comment deletion');
self::assertStringContainsString('<xdr:txBody>', $drawingXml, 'Textboxes should be preserved after comment deletion');
// Verify that comment was deleted (comments XML should not exist or not contain the original comment)
if ($commentsXml !== false) {
self::assertStringNotContainsString($originalCommentText, $commentsXml, 'Original comment text should be deleted');
}
}
/**
* Test that WITH pass-through, drawing modifications are NOT applied.
* When pass-through is enabled, the Writer uses the stored XML instead of regenerating,
* so programmatic changes to drawings are ignored.
*/
public function testWithPassThroughDrawingModificationsAreIgnored(): void
{
// Load WITH pass-through
$reader = new XlsxReader();
$reader->setEnableDrawingPassThrough(true);
$spreadsheet = $reader->load(self::TEMPLATE);
$sheet = $spreadsheet->getActiveSheet();
// Verify that image is in collection
$drawings = $sheet->getDrawingCollection();
self::assertGreaterThan(0, count($drawings), 'Drawing collection should contain the image');
// Modify the drawing (change description)
$drawing = null;
foreach ($drawings as $d) {
$drawing = $d;
break;
}
self::assertNotNull($drawing, 'Should have at least one drawing');
$originalDescription = $drawing->getDescription();
$newDescription = 'Modified description by test';
$drawing->setDescription($newDescription);
self::assertNotSame($originalDescription, $newDescription, 'Description should be different');
// Save to file (with pass-through, Writer uses stored XML, modifications ignored)
$tempFile = File::temporaryFilename();
$writer = new XlsxWriter($spreadsheet);
$writer->save($tempFile);
$spreadsheet->disconnectWorksheets();
// Reload and verify that the modification was NOT applied (original description preserved)
$reloadReader = new XlsxReader();
$reloadedSpreadsheet = $reloadReader->load($tempFile);
unlink($tempFile);
$reloadedDrawings = $reloadedSpreadsheet->getActiveSheet()->getDrawingCollection();
self::assertGreaterThan(0, count($reloadedDrawings), 'Reloaded file should have drawings');
$reloadedDrawing = null;
foreach ($reloadedDrawings as $d) {
$reloadedDrawing = $d;
break;
}
self::assertNotNull($reloadedDrawing, 'Should have at least one reloaded drawing');
self::assertSame($originalDescription, $reloadedDrawing->getDescription(), 'Original description should be preserved (modification ignored with pass-through)');
self::assertNotSame($newDescription, $reloadedDrawing->getDescription(), 'Modified description should NOT be applied with pass-through');
$reloadedSpreadsheet->disconnectWorksheets();
}
/**
* Test that pass-through preserves drawings when columns are inserted,
* but coordinates are NOT adjusted.
*/
public function testDrawingPassThroughWithColumnInsertion(): void
{
// Load with pass-through enabled
$reader = new XlsxReader();
$reader->setEnableDrawingPassThrough(true);
$spreadsheet = $reader->load(self::TEMPLATE);
$sheet = $spreadsheet->getActiveSheet();
// Get original drawing coordinates from XML
$originalUnparsedData = $spreadsheet->getUnparsedLoadedData();
$codeName = $sheet->getCodeName();
self::assertIsArray($originalUnparsedData['sheets']);
self::assertArrayHasKey($codeName, $originalUnparsedData['sheets']);
self::assertIsArray($originalUnparsedData['sheets'][$codeName]);
self::assertArrayHasKey('Drawings', $originalUnparsedData['sheets'][$codeName]);
self::assertIsArray($originalUnparsedData['sheets'][$codeName]['Drawings']);
$originalDrawings = $originalUnparsedData['sheets'][$codeName]['Drawings'];
$originalDrawingXml = reset($originalDrawings);
self::assertIsString($originalDrawingXml);
// Extract original column coordinate
preg_match('/<xdr:col>(\d+)<\/xdr:col>/', $originalDrawingXml, $originalColMatches);
$originalCol = $originalColMatches[1] ?? null;
self::assertNotNull($originalCol, 'Original drawing should have column coordinate');
// Insert a column before B (which should shift drawings at B or later)
$sheet->insertNewColumnBefore('B', 1);
// Save to file
$tempFile = File::temporaryFilename();
$writer = new XlsxWriter($spreadsheet);
$writer->save($tempFile);
$spreadsheet->disconnectWorksheets();
// Read the drawing XML directly from the saved file
$zip = new ZipArchive();
$zip->open($tempFile);
$reloadedDrawingXml = $zip->getFromName('xl/drawings/drawing1.xml');
$zip->close();
unlink($tempFile);
self::assertNotFalse($reloadedDrawingXml, 'Drawing XML should exist in saved file');
// Extract reloaded column coordinate
preg_match('/<xdr:col>(\d+)<\/xdr:col>/', $reloadedDrawingXml, $reloadedColMatches);
$reloadedCol = $reloadedColMatches[1] ?? null;
// Coordinates are NOT adjusted
// The column coordinate should remain the same (not shifted)
self::assertSame($originalCol, $reloadedCol, 'Drawing column coordinate should NOT be adjusted');
}
/**
* Test that pass-through preserves drawings when rows are deleted,
* but coordinates are NOT adjusted.
*/
public function testDrawingPassThroughWithRowDeletion(): void
{
// Load with pass-through enabled
$reader = new XlsxReader();
$reader->setEnableDrawingPassThrough(true);
$spreadsheet = $reader->load(self::TEMPLATE);
$sheet = $spreadsheet->getActiveSheet();
// Get original drawing coordinates from XML
$originalUnparsedData = $spreadsheet->getUnparsedLoadedData();
$codeName = $sheet->getCodeName();
self::assertIsArray($originalUnparsedData['sheets']);
self::assertArrayHasKey($codeName, $originalUnparsedData['sheets']);
self::assertIsArray($originalUnparsedData['sheets'][$codeName]);
self::assertArrayHasKey('Drawings', $originalUnparsedData['sheets'][$codeName]);
self::assertIsArray($originalUnparsedData['sheets'][$codeName]['Drawings']);
$originalDrawings = $originalUnparsedData['sheets'][$codeName]['Drawings'];
$originalDrawingXml = reset($originalDrawings);
self::assertIsString($originalDrawingXml);
// Extract original row coordinate
preg_match('/<xdr:row>(\d+)<\/xdr:row>/', $originalDrawingXml, $originalRowMatches);
$originalRow = $originalRowMatches[1] ?? null;
self::assertNotNull($originalRow, 'Original drawing should have row coordinate');
// Delete row 1 (which should shift drawings at row 2 or later)
$sheet->removeRow(1, 1);
// Save to file
$tempFile = File::temporaryFilename();
$writer = new XlsxWriter($spreadsheet);
$writer->save($tempFile);
$spreadsheet->disconnectWorksheets();
// Read the drawing XML directly from the saved file
$zip = new ZipArchive();
$zip->open($tempFile);
$reloadedDrawingXml = $zip->getFromName('xl/drawings/drawing1.xml');
$zip->close();
unlink($tempFile);
self::assertNotFalse($reloadedDrawingXml, 'Drawing XML should exist in saved file');
// Extract reloaded row coordinate
preg_match('/<xdr:row>(\d+)<\/xdr:row>/', $reloadedDrawingXml, $reloadedRowMatches);
$reloadedRow = $reloadedRowMatches[1] ?? null;
// Coordinates are NOT adjusted
// The row coordinate should remain the same (not shifted)
self::assertSame($originalRow, $reloadedRow, 'Drawing row coordinate should NOT be adjusted after row deletion');
}
public function testDrawingPassThroughGetterSetter(): void
{
// Test Reader getter/setter
$reader = new XlsxReader();
// Default should be false
self::assertFalse($reader->getEnableDrawingPassThrough());
// Enable pass-through
$result = $reader->setEnableDrawingPassThrough(true);
self::assertInstanceOf(XlsxReader::class, $result);
self::assertTrue($reader->getEnableDrawingPassThrough());
// Disable pass-through
$reader->setEnableDrawingPassThrough(false);
self::assertFalse($reader->getEnableDrawingPassThrough());
}
/**
* Test that the drawingPassThroughEnabled flag is correctly set in unparsedLoadedData.
* This verifies the Reader sets the flag and the Writer's getPassThroughDrawingXml checks it.
*/
public function testDrawingPassThroughEnabledFlagIsSetCorrectly(): void
{
// Test 1: Load WITHOUT pass-through (default)
$reader = new XlsxReader();
self::assertFalse($reader->getEnableDrawingPassThrough(), 'Pass-through should be disabled by default');
$spreadsheet = $reader->load(self::TEMPLATE);
$sheet = $spreadsheet->getActiveSheet();
$unparsedData = $spreadsheet->getUnparsedLoadedData();
$codeName = $sheet->getCodeName();
// Verify that drawingPassThroughEnabled flag is NOT set when pass-through is disabled
self::assertArrayHasKey('sheets', $unparsedData);
self::assertIsArray($unparsedData['sheets']);
// The sheet may exist in unparsedData (legacy empty drawings), but the flag should be absent or false
if (isset($unparsedData['sheets'][$codeName])) {
$sheetData = $unparsedData['sheets'][$codeName];
self::assertIsArray($sheetData);
$flag = $sheetData['drawingPassThroughEnabled'] ?? false;
self::assertFalse($flag, 'drawingPassThroughEnabled should be false/absent when pass-through is disabled');
}
$spreadsheet->disconnectWorksheets();
// Test 2: Load WITH pass-through enabled
$reader2 = new XlsxReader();
$reader2->setEnableDrawingPassThrough(true);
self::assertTrue($reader2->getEnableDrawingPassThrough(), 'Pass-through should be enabled');
$spreadsheet2 = $reader2->load(self::TEMPLATE);
$sheet2 = $spreadsheet2->getActiveSheet();
$unparsedData2 = $spreadsheet2->getUnparsedLoadedData();
$codeName2 = $sheet2->getCodeName();
// Verify that drawingPassThroughEnabled flag IS set when pass-through is enabled
self::assertArrayHasKey('sheets', $unparsedData2);
self::assertIsArray($unparsedData2['sheets']);
self::assertArrayHasKey($codeName2, $unparsedData2['sheets']);
self::assertIsArray($unparsedData2['sheets'][$codeName2]);
self::assertArrayHasKey('drawingPassThroughEnabled', $unparsedData2['sheets'][$codeName2], 'drawingPassThroughEnabled flag should exist');
self::assertTrue($unparsedData2['sheets'][$codeName2]['drawingPassThroughEnabled'], 'drawingPassThroughEnabled should be true when pass-through is enabled');
// Verify that the drawing XML is also stored
self::assertArrayHasKey('Drawings', $unparsedData2['sheets'][$codeName2]);
self::assertIsArray($unparsedData2['sheets'][$codeName2]['Drawings']);
self::assertNotEmpty($unparsedData2['sheets'][$codeName2]['Drawings'], 'Drawing XML should be stored when pass-through is enabled');
$spreadsheet2->disconnectWorksheets();
}
/**
* Test that VML drawings (used by comments) and DrawingML (used by shapes/images)
* coexist without interference when pass-through is enabled.
* This addresses the concern that comments use the drawings folder with VML files.
* The template file already contains a comment in D1, so this test verifies that
* existing comments are preserved AND new comments can be added.
*/
public function testCommentsAndPassThroughCoexist(): void
{
// Load file with drawings (image + shape) and enable pass-through
// Note: The template already contains a comment in D1
$reader = new XlsxReader();
$reader->setEnableDrawingPassThrough(true);
$spreadsheet = $reader->load(self::TEMPLATE);
$sheet = $spreadsheet->getActiveSheet();
// Verify the existing comment is loaded
$existingComment = $sheet->getComment('D1');
$existingCommentText = $existingComment->getText()->getPlainText();
self::assertNotEmpty($existingCommentText, 'Template should contain a comment in D1');
// Add a new comment to the sheet
$sheet->getComment('A1')->getText()->createText('Test comment with pass-through');
$sheet->getComment('A1')->setAuthor('Test Author');
// Save the file
$tempFile = File::temporaryFilename();
$writer = new XlsxWriter($spreadsheet);
$writer->save($tempFile);
$spreadsheet->disconnectWorksheets();
// Verify the file structure contains both VML (for comments) and DrawingML (for shapes)
$zip = new ZipArchive();
$zip->open($tempFile);
// Check for VML drawing (used by comments)
$vmlDrawing = $zip->getFromName('xl/drawings/vmlDrawing1.vml');
self::assertNotFalse($vmlDrawing, 'VML drawing for comments should exist');
self::assertStringContainsString('urn:schemas-microsoft-com:vml', $vmlDrawing, 'VML should contain VML namespace');
// Check for DrawingML (used by shapes/images)
$drawingXml = $zip->getFromName('xl/drawings/drawing1.xml');
self::assertNotFalse($drawingXml, 'DrawingML for shapes/images should exist');
self::assertStringContainsString('<xdr:sp', $drawingXml, 'DrawingML should contain shape (preserved by pass-through)');
self::assertStringContainsString('<xdr:pic', $drawingXml, 'DrawingML should contain image');
// Check for comments XML (should contain both existing and new comments)
$commentsXml = $zip->getFromName('xl/comments1.xml');
self::assertNotFalse($commentsXml, 'Comments XML should exist');
self::assertStringContainsString('Test comment with pass-through', $commentsXml, 'New comment (A1) should be in comments XML');
self::assertStringContainsString($existingCommentText, $commentsXml, 'Existing comment (D1) should be preserved in comments XML');
$zip->close();
unlink($tempFile);
}
/**
* Test that pass-through preserves SVG images and their relationships.
* Excel stores SVG images with a PNG fallback using separate rIds.
* Without proper pass-through of relationships and media files, the rIds
* become misaligned and images break.
*
* File structure of merge.excel.xlsx:
* - xl/media/image1.png (PNG fallback for SVG)
* - xl/media/image2.svg (SVG image)
* - xl/media/image3.jpeg (JPEG image)
* - Drawing relationships: rId1=PNG, rId2=SVG, rId3=JPEG
*/
public function testDrawingPassThroughPreservesSvgImagesAndRelationships(): void
{
$template = self::DIRECTORY . 'merge.excel.xlsx';
// Load with pass-through enabled
$reader = new XlsxReader();
$reader->setEnableDrawingPassThrough(true);
$spreadsheet = $reader->load($template);
$sheet = $spreadsheet->getActiveSheet();
// Verify that drawing collection contains supported images (PNG and JPEG, not SVG)
$drawings = $sheet->getDrawingCollection();
self::assertGreaterThanOrEqual(1, count($drawings), 'Drawing collection should contain at least one supported image');
// Verify that pass-through data is stored
$unparsedData = $spreadsheet->getUnparsedLoadedData();
$codeName = $sheet->getCodeName();
self::assertArrayHasKey('sheets', $unparsedData);
self::assertIsArray($unparsedData['sheets']);
self::assertArrayHasKey($codeName, $unparsedData['sheets']);
self::assertIsArray($unparsedData['sheets'][$codeName]);
self::assertTrue($unparsedData['sheets'][$codeName]['drawingPassThroughEnabled'] ?? false);
// Verify that drawing relationships are stored
self::assertArrayHasKey('drawingRelationships', $unparsedData['sheets'][$codeName]);
$relsXml = $unparsedData['sheets'][$codeName]['drawingRelationships'];
self::assertIsString($relsXml);
self::assertStringContainsString('image1.png', $relsXml, 'Relationships should reference PNG');
self::assertStringContainsString('image2.svg', $relsXml, 'Relationships should reference SVG');
self::assertStringContainsString('image3.jpeg', $relsXml, 'Relationships should reference JPEG');
// Verify that media files paths are stored
self::assertArrayHasKey('drawingMediaFiles', $unparsedData['sheets'][$codeName]);
$mediaFiles = $unparsedData['sheets'][$codeName]['drawingMediaFiles'];
self::assertIsArray($mediaFiles);
self::assertGreaterThanOrEqual(3, count($mediaFiles), 'Should have at least 3 media files (PNG, SVG, JPEG)');
// Save to file
$tempFile = File::temporaryFilename();
$writer = new XlsxWriter($spreadsheet);
$writer->save($tempFile);
$spreadsheet->disconnectWorksheets();
// Verify that the saved file preserves all images and relationships
$zip = new ZipArchive();
$zip->open($tempFile);
// Check that all media files are present
$pngContent = $zip->getFromName('xl/media/image1.png');
$svgContent = $zip->getFromName('xl/media/image2.svg');
$jpegContent = $zip->getFromName('xl/media/image3.jpeg');
self::assertNotFalse($pngContent, 'PNG image should be preserved');
self::assertNotFalse($svgContent, 'SVG image should be preserved');
self::assertNotFalse($jpegContent, 'JPEG image should be preserved');
// Check that drawing relationships are correct
$drawingRels = $zip->getFromName('xl/drawings/_rels/drawing1.xml.rels');
self::assertNotFalse($drawingRels, 'Drawing relationships file should exist');
self::assertStringContainsString('image1.png', $drawingRels, 'Drawing rels should reference PNG');
self::assertStringContainsString('image2.svg', $drawingRels, 'Drawing rels should reference SVG');
self::assertStringContainsString('image3.jpeg', $drawingRels, 'Drawing rels should reference JPEG');
// Check that drawing XML references are intact
$drawingXml = $zip->getFromName('xl/drawings/drawing1.xml');
self::assertNotFalse($drawingXml, 'Drawing XML should exist');
// Verify SVG is referenced via svgBlip extension
self::assertStringContainsString('svgBlip', $drawingXml, 'Drawing should contain SVG blip reference');
$zip->close();
unlink($tempFile);
}
/**
* Test that WITHOUT pass-through, SVG images are lost due to rId misalignment.
* This documents the expected behavior without the fix.
*/
public function testWithoutPassThroughSvgImagesAreLost(): void
{
$template = self::DIRECTORY . 'merge.excel.xlsx';
// Verify that the original file contains SVG
$originalZip = new ZipArchive();
$originalZip->open($template);
$originalSvgContent = $originalZip->getFromName('xl/media/image2.svg');
$originalZip->close();
self::assertNotFalse($originalSvgContent, 'Original file should contain SVG');
// Load WITHOUT pass-through
$reader = new XlsxReader();
// Don't enable pass-through
$spreadsheet = $reader->load($template);
// Save to file
$tempFile = File::temporaryFilename();
$writer = new XlsxWriter($spreadsheet);
$writer->save($tempFile);
$spreadsheet->disconnectWorksheets();
// Verify that SVG is lost
$zip = new ZipArchive();
$zip->open($tempFile);
// SVG file should NOT be present (PhpSpreadsheet doesn't support SVG)
$svgContent = $zip->getFromName('xl/media/image2.svg');
self::assertFalse($svgContent, 'SVG image should NOT be present without pass-through');
// PNG and JPEG should still be present (supported formats)
// Note: filenames may be different as they are regenerated
$mediaFiles = [];
for ($i = 0; $i < $zip->numFiles; ++$i) {
$name = $zip->getNameIndex($i);
if ($name !== false && str_starts_with($name, 'xl/media/')) {
$mediaFiles[] = $name;
}
}
// Should have some media files but not SVG
self::assertNotEmpty($mediaFiles, 'Should have some media files');
foreach ($mediaFiles as $file) {
self::assertStringNotContainsString('.svg', $file, 'No SVG files should be present without pass-through');
}
$zip->close();
unlink($tempFile);
}
/**
* Test that pass-through preserves shapes (textboxes, rectangles, etc.)
* in addition to images with SVG.
*/
public function testDrawingPassThroughPreservesShapesAndSvg(): void
{
$template = self::DIRECTORY . 'merge.excel.xlsx';
// Load with pass-through enabled
$reader = new XlsxReader();
$reader->setEnableDrawingPassThrough(true);
$spreadsheet = $reader->load($template);
// Save to file
$tempFile = File::temporaryFilename();
$writer = new XlsxWriter($spreadsheet);
$writer->save($tempFile);
$spreadsheet->disconnectWorksheets();
// Verify shapes are preserved
$zip = new ZipArchive();
$zip->open($tempFile);
$drawingXml = $zip->getFromName('xl/drawings/drawing1.xml');
self::assertNotFalse($drawingXml, 'Drawing XML should exist');
// Check for shapes (xdr:sp elements)
self::assertStringContainsString('<xdr:sp', $drawingXml, 'Shapes should be preserved');
self::assertStringContainsString('<xdr:txBody>', $drawingXml, 'Textboxes should be preserved');
// Check for images (xdr:pic elements)
self::assertStringContainsString('<xdr:pic', $drawingXml, 'Images should be preserved');
// Check for SVG reference
self::assertStringContainsString('svgBlip', $drawingXml, 'SVG reference should be preserved');
$zip->close();
unlink($tempFile);
}
/**
* Test that pass-through preserves grouped images.
* Grouped images are not parsed into the drawing collection, so they would be lost
* without proper pass-through of drawing XML, relationships, and media files.
*
* File structure of grouped_images.xlsx:
* - Contains a group (xdr:grpSp) with 2 images inside
* - xl/media/image1.png and xl/media/image2.png
* - The images are referenced from within the group element
*/
public function testDrawingPassThroughPreservesGroupedImages(): void
{
$template = self::DIRECTORY . 'grouped_images.xlsx';
// Verify that the original file contains a group with images
$originalZip = new ZipArchive();
$originalZip->open($template);
$originalDrawingXml = $originalZip->getFromName('xl/drawings/drawing1.xml');
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | true |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Xlsx/CommentAlignmentTest.php | tests/PhpSpreadsheetTests/Writer/Xlsx/CommentAlignmentTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Xlsx;
use PhpOffice\PhpSpreadsheet\Comment;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Style\Alignment;
use PhpOffice\PhpSpreadsheetTests\Functional\AbstractFunctional;
class CommentAlignmentTest extends AbstractFunctional
{
public function testIssue4004(): void
{
$type = 'Xlsx';
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->getCell('A3')->setValue('A3');
$sheet->getCell('A4')->setValue('A4');
$sheet->getComment('A3')->getText()->createText('Comment');
$sheet->getComment('A4')->getText()->createText('שלום');
$sheet->getComment('A4')->setAlignment(Alignment::HORIZONTAL_RIGHT);
$reloadedSpreadsheet = $this->writeAndReload($spreadsheet, $type);
$spreadsheet->disconnectWorksheets();
self::assertCount(1, $reloadedSpreadsheet->getAllSheets());
$rsheet = $reloadedSpreadsheet->getActiveSheet();
$comment1 = $rsheet->getComment('A3');
self::assertSame('Comment', $comment1->getText()->getPlainText());
self::assertSame('general', $comment1->getAlignment());
$comment2 = $rsheet->getComment('A4');
self::assertSame('שלום', $comment2->getText()->getPlainText());
self::assertSame('right', $comment2->getAlignment());
$reloadedSpreadsheet->disconnectWorksheets();
}
public function testIssue4004td(): void
{
$type = 'Xlsx';
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->setRightToLeft(true);
$sheet->getCell('A1')->setValue('ברקוד');
$comment = $sheet->getComment('A1');
$comment->setTextboxDirection(Comment::TEXTBOX_DIRECTION_RTL);
$comment->setAlignment(Alignment::HORIZONTAL_RIGHT);
$text = <<<EOF
Report : ProductsExcel
סטטוס הגדרות בזמן הרצת הדו"ח
2024-06-04 21:07:04
תאריך התחלה :
תאריך סיום :
berber@berber.co.il
הצגת ברקוד מקוצר = 0
הצגת חנויות אינטרנט בתוצאות = 1
הצגת מחיר ליחידת מידה = 0
הצגת כל רשומות המחיר לתאריך = 0
רשומות עם מחיר בכל הרשתות = 0
% נפיצות מינימלית = 0
נפיצות מינימלית= 0
% נפיצות מקסימלית = 0
נפיצות מקסימלית= 0
פער אחוזי = 0
התעלמות מכלל המבצעים = 0
התעלמות ממבצעי אשראי = 0
התעלמות ממבצעי מועדון = 0
התעלמות ממבצעים המותנים בסכום מעל 100 ₪. = 0
התעלמות ממבצעים המותנים בקניה של 3 מוצרים ומעלה. = 0
ניתוח מבצעים
============
הצגת כל המבצעים = 0
מבצעי מועדון = 0
מבצעי אשראי = 0
מבצעי ארנק = 0
מחיר מוזל = 0
X יחידות ב-Y ₪ = 0
השני ב = 0
X+Y מתנה = 0
אחוז הנחה הפעלה = 0
אחוז הנחה מספר = 0
מוצרים חסרים - הגבלת חודשים - כמות= 0
EOF;
$comment->getText()->createTextRun($text);
$comment->setWidth('300pt');
$comment->setHeight('550pt');
$reloadedSpreadsheet = $this->writeAndReload($spreadsheet, $type);
$spreadsheet->disconnectWorksheets();
self::assertCount(1, $reloadedSpreadsheet->getAllSheets());
$rsheet = $reloadedSpreadsheet->getActiveSheet();
$comment1 = $rsheet->getComment('A1');
self::assertSame($text, $comment1->getText()->getPlainText());
$comment->setTextboxDirection(Comment::TEXTBOX_DIRECTION_RTL);
self::assertSame('right', $comment1->getAlignment());
self::assertSame('rtl', $comment1->getTextboxDirection());
$reloadedSpreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Xlsx/BackgroundImageTest.php | tests/PhpSpreadsheetTests/Writer/Xlsx/BackgroundImageTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Xlsx;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheetTests\Functional\AbstractFunctional;
class BackgroundImageTest extends AbstractFunctional
{
public function testBackgroundImage(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->getCell('A1')->setValue(1);
$sheet->getCell('B1')->setValue(2);
$sheet->getCell('A2')->setValue(3);
$sheet->getCell('B2')->setValue(4);
$imageFile = 'tests/data/Writer/XLSX/backgroundtest.png';
$image = (string) file_get_contents($imageFile);
$sheet->setBackgroundImage($image);
self::assertSame('image/png', $sheet->getBackgroundMime());
self::assertSame('png', $sheet->getBackgroundExtension());
$reloadedSpreadsheet = $this->writeAndReload($spreadsheet, 'Xlsx');
$spreadsheet->disconnectWorksheets();
$reloadedWorksheet = $reloadedSpreadsheet->getActiveSheet();
self::assertSame($image, $reloadedWorksheet->getBackgroundImage());
self::assertSame('image/png', $reloadedWorksheet->getBackgroundMime());
self::assertSame('png', $reloadedWorksheet->getBackgroundExtension());
self::assertSame(2, $reloadedWorksheet->getCell('B1')->getValue());
$reloadedSpreadsheet->disconnectWorksheets();
}
public function testInvalidImage(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->getCell('A1')->setValue(1);
$imageFile = __FILE__;
$image = (string) file_get_contents($imageFile);
self::assertNotSame('', $image);
$sheet->setBackgroundImage($image);
self::assertSame('', $sheet->getBackgroundImage());
self::assertSame('', $sheet->getBackgroundMime());
self::assertSame('', $sheet->getBackgroundExtension());
$spreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Xlsx/TableTest.php | tests/PhpSpreadsheetTests/Writer/Xlsx/TableTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Xlsx;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Worksheet\Table;
use PhpOffice\PhpSpreadsheet\Writer\Xlsx;
use PhpOffice\PhpSpreadsheetTests\Functional\AbstractFunctional;
class TableTest extends AbstractFunctional
{
protected function populateData(Spreadsheet $spreadsheet): Table
{
$worksheet = $spreadsheet->getActiveSheet();
$tableName = 'SalesData';
$columnFormula = "=SUM({$tableName}[[#This Row],[Q1]:[Q4]])";
$dataArray = [
['Year', 'Country', 'Q1', 'Q2', 'Q3', 'Q4', 'Sales'],
[2010, 'Belgium', 380, 390, 420, 460, $columnFormula],
[2010, 'France', 510, 490, 460, 590, $columnFormula],
[2010, 'Germany', 720, 680, 640, 660, $columnFormula],
[2010, 'Italy', 440, 410, 420, 450, $columnFormula],
[2010, 'Spain', 510, 490, 470, 420, $columnFormula],
[2010, 'UK', 690, 610, 620, 600, $columnFormula],
[2010, 'United States', 790, 730, 860, 850, $columnFormula],
[2011, 'Belgium', 400, 350, 450, 500, $columnFormula],
[2011, 'France', 620, 650, 415, 570, $columnFormula],
[2011, 'Germany', 680, 620, 710, 690, $columnFormula],
[2011, 'Italy', 430, 370, 350, 335, $columnFormula],
[2011, 'Spain', 460, 390, 430, 415, $columnFormula],
[2011, 'UK', 720, 650, 580, 510, $columnFormula],
[2011, 'United States', 800, 700, 900, 950, $columnFormula],
];
$worksheet->fromArray($dataArray, null, 'A1');
$rowColumnRange = "{$worksheet->getHighestDataColumn()}{$worksheet->getHighestDataRow()}";
$table = new Table("A1:{$rowColumnRange}", $tableName);
$table->setRange("A1:{$rowColumnRange}");
$table->getColumn('G')
->setTotalsRowLabel('Total')
->setColumnFormula($columnFormula);
$worksheet->getCell('A16')->setValue('Total');
$worksheet->getCell('G16')->setValue("=SUBTOTAL(109,{$tableName}[Sales])");
$spreadsheet->getActiveSheet()->addTable($table);
return $table;
}
public function testTableCreation(): void
{
$spreadsheet = new Spreadsheet();
$this->populateData($spreadsheet);
// TODO: We don't yet support Structured References in formulae, so we need to disable precalculation
// when writing.
$disablePrecalculation = function (Xlsx $writer): void {
$writer->setPreCalculateFormulas(false);
};
$reloadedSpreadsheet = $this->writeAndReload($spreadsheet, 'Xlsx', null, $disablePrecalculation);
$reloadedWorksheet = $reloadedSpreadsheet->getActiveSheet();
$reloadedTable = $reloadedWorksheet->getTableCollection()[0];
self::assertNotNull($reloadedTable);
}
public function testTableWithoutFilter(): void
{
$spreadsheet = new Spreadsheet();
$table = $this->populateData($spreadsheet);
$table->setAllowFilter(false);
// TODO: We don't yet support Structured References in formulae, so we need to disable precalc when writing
$disablePrecalculation = function (Xlsx $writer): void {
$writer->setPreCalculateFormulas(false);
};
$reloadedSpreadsheet = $this->writeAndReload($spreadsheet, 'Xlsx', null, $disablePrecalculation);
$reloadedWorksheet = $reloadedSpreadsheet->getActiveSheet();
$reloadedTable = $reloadedWorksheet->getTableCollection()[0];
self::assertInstanceOf(Table::class, $reloadedTable);
self::assertFalse($reloadedTable->getAllowFilter());
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Xlsx/Issue4025Test.php | tests/PhpSpreadsheetTests/Writer/Xlsx/Issue4025Test.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Xlsx;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Style\Alignment;
use PhpOffice\PhpSpreadsheet\Style\Conditional;
use PhpOffice\PhpSpreadsheet\Style\Fill;
use PhpOffice\PhpSpreadsheet\Worksheet\Worksheet;
use PhpOffice\PhpSpreadsheet\Writer\Xlsx as XlsxWriter;
use PHPUnit\Framework\TestCase;
class Issue4025Test extends TestCase
{
private static function merge(Worksheet $sheet, string $start, string $end): void
{
$sheet->mergeCells("$start:$end");
$sheet->getStyle($start)->getAlignment()->setHorizontal(Alignment::HORIZONTAL_CENTER);
$sheet->getStyle($start)->getAlignment()->setVertical(Alignment::VERTICAL_CENTER);
}
public function testIssue4025(): void
{
// Writing alignment in conditional style caused weirdness
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->setRightToLeft(true);
$sheet->setCellValue('E1', 'אושר עד');
$sheet->setCellValue('M1', 'ויקטורי');
$sheet->setCellValue('E2', '2024-05-01');
$sheet->setCellValue('H2', '2024-05-12');
$sheet->setCellValue('M2', '2024-05-01');
$sheet->setCellValue('P2', '2024-05-12');
$sheet->setCellValue('A3', 'ברקוד');
$sheet->setCellValue('B3', 'תיאור מוצר');
$sheet->setCellValue('C3', 'קטגוריה');
$sheet->setCellValue('D3', 'יצרן');
$sheet->setCellValue('E3', 'מחיר');
$sheet->setCellValue('F3', 'מבצע');
$sheet->setCellValue('G3', 'קובע');
$sheet->setCellValue('H3', 'מחיר');
$sheet->setCellValue('I3', 'מבצע');
$sheet->setCellValue('J3', 'קובע');
$sheet->setCellValue('K3', 'הפרש ב-₪');
$sheet->setCellValue('L3', 'הפרש ב-₪');
$sheet->setCellValue('M3', 'מחיר');
$sheet->setCellValue('N3', 'מבצע');
$sheet->setCellValue('O3', 'קובע');
$sheet->setCellValue('P3', 'מחיר');
$sheet->setCellValue('Q3', 'מבצע');
$sheet->setCellValue('R3', 'קובע');
$sheet->setCellValue('S3', 'הפרש ב-₪');
$sheet->setCellValue('T3', 'הפרש ב-₪');
$sheet->setCellValue('A4', '7290010945306');
$sheet->setCellValue('B4', 'חלב טרי בקרטון 3% בד"צ טרה 2 ליטר');
$sheet->setCellValue('C4', 'חלב טרי');
$sheet->setCellValue('D4', 'החברה המרכזית ל.מ.ק - טרה');
$sheet->setCellValue('E4', 13.50);
$sheet->setCellValue('F4', '-');
//$sheet->setCellValue('G4', 13.50);
$sheet->setCellValue('G4', 14.70);
$sheet->setCellValue('H4', 14.20);
$sheet->setCellValue('I4', '-');
$sheet->setCellValue('J4', 14.20);
$sheet->setCellValue('K4', 0.70);
$sheet->setCellValue('L4', 0.0519);
$sheet->setCellValue('M4', 13.62);
$sheet->setCellValue('N4', '-');
$sheet->setCellValue('O4', 13.62);
$sheet->setCellValue('P4', 14.22);
$sheet->setCellValue('Q4', '-');
$sheet->setCellValue('R4', 14.22);
$sheet->setCellValue('S4', 0.60);
$sheet->setCellValue('T4', 0.0441);
$sheet->setCellValue('E10', '=SUM(G4:G10)');
$sheet->setCellValue('H10', '=SUM(J4:J10)');
$sheet->setCellValue('K10', '=COUNTIF(K4:K9,">0")');
$sheet->setCellValue('M10', '=SUM(O4:O10)');
$sheet->setCellValue('P10', '=SUM(R4:R10)');
$sheet->setCellValue('S10', '=COUNTIF(S4:S9,">0")');
$sheet->setCellValue('H11', '=(SUM(J4:J10) / SUM(G4:G10) - 1)');
$sheet->setCellValue('K11', '=COUNTIF(K4:K9,"<0")');
$sheet->setCellValue('P11', '=(SUM(R4:R10) / SUM(O4:O10) - 1)');
$sheet->setCellValue('S11', '=COUNTIF(S4:S9,"<0")');
$sheet->setAutoFilter('A3:T3');
self::merge($sheet, 'E1', 'L1');
self::merge($sheet, 'E2', 'G2');
self::merge($sheet, 'H2', 'J2');
self::merge($sheet, 'K2', 'L2');
self::merge($sheet, 'M1', 'T1');
self::merge($sheet, 'M2', 'O2');
self::merge($sheet, 'P2', 'R2');
self::merge($sheet, 'S2', 'T2');
self::merge($sheet, 'E10', 'G10');
self::merge($sheet, 'H10', 'J10');
self::merge($sheet, 'H11', 'J11');
self::merge($sheet, 'M10', 'O10');
self::merge($sheet, 'P10', 'R10');
self::merge($sheet, 'P11', 'R11');
self::merge($sheet, 'K10', 'L10');
self::merge($sheet, 'K11', 'L11');
self::merge($sheet, 'S10', 'T10');
self::merge($sheet, 'S11', 'T11');
$sheet->getStyle('E4:K8')->getNumberFormat()->setFormatCode('0.00');
$sheet->getStyle('L4:L8')->getNumberFormat()->setFormatCode('0.00%');
$sheet->getStyle('M4:S8')->getNumberFormat()->setFormatCode('0.00');
$sheet->getStyle('T4:T8')->getNumberFormat()->setFormatCode('0.00%');
$sheet->getStyle('P10')->getNumberFormat()->setFormatCode('0.00');
$sheet->getStyle('P11')->getNumberFormat()->setFormatCode('0.00%');
$sheet->getStyle('H1')->getNumberFormat()->setFormatCode('0.00');
$sheet->getStyle('H11')->getNumberFormat()->setFormatCode('0.00%');
$center = [
'alignment' => ['horizontal' => Alignment::HORIZONTAL_CENTER],
];
$pink = [
'alignment' => ['horizontal' => Alignment::HORIZONTAL_CENTER, 'vertical' => Alignment::VERTICAL_CENTER],
'font' => ['color' => ['rgb' => 'FF0000']],
'fill' => ['fillType' => Fill::FILL_SOLID, 'endColor' => ['argb' => 'FFFFE5E8'], 'startColor' => ['argb' => 'FFFFE5E8']],
];
$green = [
'alignment' => ['horizontal' => Alignment::HORIZONTAL_CENTER, 'vertical' => Alignment::VERTICAL_CENTER],
'font' => ['color' => ['rgb' => '339966']],
'fill' => ['fillType' => Fill::FILL_SOLID, 'endColor' => ['argb' => 'ffccffcc'], 'startColor' => ['argb' => 'ffccffcc']],
];
//$sheet->getStyle('E4:T8')->getAlignment()->setHorizontal(Alignment::HORIZONTAL_CENTER);
$sheet->getStyle('E4:T8')->applyFromArray($center);
$sheet->getStyle('H4')->applyFromArray($pink);
$sheet->getStyle('J4:L4')->applyFromArray($pink);
$sheet->getStyle('P4')->applyFromArray($pink);
$sheet->getStyle('R4:T4')->applyFromArray($pink);
$sheet->getStyle('K10')->applyFromArray($pink);
$sheet->getStyle('S10')->applyFromArray($pink);
$sheet->getStyle('K11')->applyFromArray($green);
$sheet->getStyle('S11')->applyFromArray($green);
$condition1a = new Conditional();
$condition1a->setConditionType(Conditional::CONDITION_EXPRESSION);
$condition1a->addCondition('$H$10 < $E$10');
$condition1a->getStyle()->applyFromArray($green);
$condition1b = new Conditional();
$condition1b->setConditionType(Conditional::CONDITION_EXPRESSION);
$condition1b->addCondition('$H$10 > $E$10');
$condition1b->getStyle()->applyFromArray($pink);
$conditionalStyles = [$condition1a, $condition1b];
$sheet->getStyle('H10:H11')->setConditionalStyles($conditionalStyles);
$condition2a = new Conditional();
$condition2a->setConditionType(Conditional::CONDITION_EXPRESSION);
$condition2a->addCondition('$P$10 < $M$10');
$condition2a->getStyle()->applyFromArray($green);
$condition2b = new Conditional();
$condition2b->setConditionType(Conditional::CONDITION_EXPRESSION);
$condition2b->addCondition('$P$10 > $M$10');
$condition2b->getStyle()->applyFromArray($pink);
$conditionalStyles2 = [$condition2a, $condition2b];
$sheet->getStyle('P10:P11')->setConditionalStyles($conditionalStyles2);
$sheet->setSelectedCells('A1');
$writer = new XlsxWriter($spreadsheet);
$writer->getStylesConditionalHashTable()->addFromSource($writer->getWriterPartStyle()->allConditionalStyles($spreadsheet));
$writerStyle = new XlsxWriter\Style($writer);
$data = $writerStyle->writeStyles($spreadsheet);
$spreadsheet->disconnectWorksheets();
$preg = preg_match('~<dxfs.*</dxfs>~ms', $data, $matches);
if ($preg !== 1) {
self::fail('preg failed');
} else {
self::assertStringContainsString('<font', $matches[0]);
self::assertStringContainsString('<fill', $matches[0]);
self::assertStringNotContainsString('<align', $matches[0]);
}
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Xlsx/ArrayFunctionsTest.php | tests/PhpSpreadsheetTests/Writer/Xlsx/ArrayFunctionsTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Xlsx;
use PhpOffice\PhpSpreadsheet\Calculation\Calculation;
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 ArrayFunctionsTest extends TestCase
{
private string $outputFile = '';
protected function tearDown(): void
{
if ($this->outputFile !== '') {
unlink($this->outputFile);
$this->outputFile = '';
}
}
public function testArrayOutput(): void
{
$spreadsheet = new Spreadsheet();
Calculation::getInstance($spreadsheet)->setInstanceArrayReturnType(Calculation::RETURN_ARRAY_AS_ARRAY);
$sheet = $spreadsheet->getActiveSheet();
$columnArray = [
[41],
[57],
[51],
[54],
[49],
[43],
[35],
[35],
[44],
[47],
[48],
[26],
[57],
[34],
[61],
[34],
[28],
[29],
[41],
];
$sheet->fromArray($columnArray, 'A1');
$sheet->setCellValue('C1', '=UNIQUE(A1:A19)');
$sheet->setCellValue('D1', '=SORT(A1:A19)');
$writer = new XlsxWriter($spreadsheet);
$this->outputFile = File::temporaryFilename();
$writer->save($this->outputFile);
$spreadsheet->disconnectWorksheets();
$reader = new XlsxReader();
$spreadsheet2 = $reader->load($this->outputFile);
Calculation::getInstance($spreadsheet2)->setInstanceArrayReturnType(Calculation::RETURN_ARRAY_AS_ARRAY);
$sheet2 = $spreadsheet2->getActiveSheet();
$expectedUnique = [
[41],
[57],
[51],
[54],
[49],
[43],
[35],
[44],
[47],
[48],
[26],
[34],
[61],
[28],
[29],
];
self::assertSame($expectedUnique, $sheet2->getCell('C1')->getCalculatedValue());
for ($row = 2; $row <= 15; ++$row) {
self::assertSame($expectedUnique[$row - 1][0], $sheet2->getCell("C$row")->getCalculatedValue(), "cell C$row");
}
$expectedSort = [
[26],
[28],
[29],
[34],
[34],
[35],
[35],
[41],
[41],
[43],
[44],
[47],
[48],
[49],
[51],
[54],
[57],
[57],
[61],
];
self::assertSame($expectedSort, $sheet2->getCell('D1')->getCalculatedValue());
$spreadsheet2->disconnectWorksheets();
$file = 'zip://';
$file .= $this->outputFile;
$file .= '#xl/worksheets/sheet1.xml';
$data = file_get_contents($file);
if ($data === false) {
self::fail('Unable to read file');
} else {
self::assertStringContainsString('<c r="C1" cm="1"><f t="array" ref="C1:C15" aca="1" ca="1">_xlfn.UNIQUE(A1:A19)</f><v>41</v></c>', $data, '15 results for UNIQUE');
self::assertStringContainsString('<c r="D1" cm="1"><f t="array" ref="D1:D19" aca="1" ca="1">_xlfn._xlws.SORT(A1:A19)</f><v>26</v></c>', $data, '19 results for SORT');
}
$file = 'zip://';
$file .= $this->outputFile;
$file .= '#xl/metadata.xml';
$data = @file_get_contents($file);
self::assertNotFalse($data, 'metadata.xml should exist');
$file = 'zip://';
$file .= $this->outputFile;
$file .= '#[Content_Types].xml';
$data = file_get_contents($file);
self::assertStringContainsString('metadata', $data);
$file = 'zip://';
$file .= $this->outputFile;
$file .= '#xl/_rels/workbook.xml.rels';
$data = file_get_contents($file);
self::assertStringContainsString('metadata', $data);
}
public function testArrayOutputCSE(): void
{
$spreadsheet = new Spreadsheet();
Calculation::getInstance($spreadsheet)->setInstanceArrayReturnType(Calculation::RETURN_ARRAY_AS_ARRAY);
$sheet = $spreadsheet->getActiveSheet();
$columnArray = [
[41],
[57],
[51],
[54],
[49],
[43],
[35],
[35],
[44],
[47],
[48],
[26],
[57],
[34],
[61],
[34],
[28],
[29],
[41],
];
$sheet->fromArray($columnArray, 'A1');
$sheet->setCellValue('C1', '=UNIQUE(A1:A19)');
$sheet->setCellValue('D1', '=SORT(A1:A19)');
$writer = new XlsxWriter($spreadsheet);
$this->outputFile = File::temporaryFilename();
$writer->setUseCSEArrays(true);
$writer->save($this->outputFile);
$spreadsheet->disconnectWorksheets();
$reader = new XlsxReader();
$spreadsheet2 = $reader->load($this->outputFile);
Calculation::getInstance($spreadsheet2)->setInstanceArrayReturnType(Calculation::RETURN_ARRAY_AS_ARRAY);
$sheet2 = $spreadsheet2->getActiveSheet();
$expectedUnique = [
[41],
[57],
[51],
[54],
[49],
[43],
[35],
[44],
[47],
[48],
[26],
[34],
[61],
[28],
[29],
];
self::assertSame($expectedUnique, $sheet2->getCell('C1')->getCalculatedValue());
for ($row = 2; $row <= 15; ++$row) {
self::assertSame($expectedUnique[$row - 1][0], $sheet2->getCell("C$row")->getCalculatedValue(), "cell C$row");
}
$expectedSort = [
[26],
[28],
[29],
[34],
[34],
[35],
[35],
[41],
[41],
[43],
[44],
[47],
[48],
[49],
[51],
[54],
[57],
[57],
[61],
];
self::assertSame($expectedSort, $sheet2->getCell('D1')->getCalculatedValue());
$spreadsheet2->disconnectWorksheets();
$file = 'zip://';
$file .= $this->outputFile;
$file .= '#xl/worksheets/sheet1.xml';
$data = file_get_contents($file);
if ($data === false) {
self::fail('Unable to read file');
} else {
self::assertStringContainsString('<c r="C1"><f t="array" ref="C1:C15" aca="1" ca="1">_xlfn.UNIQUE(A1:A19)</f><v>41</v></c>', $data, '15 results for UNIQUE');
self::assertStringContainsString('<c r="D1"><f t="array" ref="D1:D19" aca="1" ca="1">_xlfn._xlws.SORT(A1:A19)</f><v>26</v></c>', $data, '19 results for SORT');
}
$file = 'zip://';
$file .= $this->outputFile;
$file .= '#xl/metadata.xml';
$data = @file_get_contents($file);
self::assertFalse($data, 'metadata.xml should not exist');
$file = 'zip://';
$file .= $this->outputFile;
$file .= '#[Content_Types].xml';
$data = file_get_contents($file);
self::assertStringNotContainsString('metadata', $data);
$file = 'zip://';
$file .= $this->outputFile;
$file .= '#xl/_rels/workbook.xml.rels';
$data = file_get_contents($file);
self::assertStringNotContainsString('metadata', $data);
}
public function testUnimplementedArrayOutput(): void
{
//Calculation::setArrayReturnType(Calculation::RETURN_ARRAY_AS_ARRAY); // not required for this test
$reader = new XlsxReader();
$spreadsheet = $reader->load('tests/data/Reader/XLSX/atsign.choosecols.xlsx');
$writer = new XlsxWriter($spreadsheet);
$this->outputFile = File::temporaryFilename();
$writer->save($this->outputFile);
$spreadsheet->disconnectWorksheets();
$reader = new XlsxReader();
$spreadsheet2 = $reader->load($this->outputFile);
$sheet2 = $spreadsheet2->getActiveSheet();
self::assertSame('=CHOOSECOLS(A1:C5,3,1)', $sheet2->getCell('F1')->getValue());
$expectedFG = [
['11', '1'],
['12', '2'],
['13', '3'],
['14', '4'],
['15', '5'],
];
$actualFG = $sheet2->rangeToArray('F1:G5');
self::assertSame($expectedFG, $actualFG);
self::assertSame('=CELL("width")', $sheet2->getCell('I1')->getValue());
self::assertSame(8, $sheet2->getCell('I1')->getCalculatedValue());
self::assertTrue($sheet2->getCell('J1')->getValue());
$spreadsheet2->disconnectWorksheets();
$file = 'zip://';
$file .= $this->outputFile;
$file .= '#xl/worksheets/sheet1.xml';
$data = file_get_contents($file);
if ($data === false) {
self::fail('Unable to read file');
} else {
self::assertStringContainsString('<f t="array" ref="F1:G5" aca="1" ca="1">_xlfn.CHOOSECOLS(A1:C5,3,1)</f><v>11</v>', $data);
self::assertStringContainsString('<f t="array" ref="I1:J1" aca="1" ca="1">CELL("width")</f><v>8</v></c><c r="J1" t="b"><v>1</v></c>', $data);
}
}
public function testArrayMultipleColumns(): void
{
$spreadsheet = new Spreadsheet();
Calculation::getInstance($spreadsheet)->setInstanceArrayReturnType(Calculation::RETURN_ARRAY_AS_ARRAY);
$sheet = $spreadsheet->getActiveSheet();
$columnArray = [
[100, 91],
[85, 1],
[100, 92],
[734, 12],
[100, 91],
[5, 2],
];
$sheet->fromArray($columnArray);
$sheet->setCellValue('H1', '=UNIQUE(A1:B6)');
$writer = new XlsxWriter($spreadsheet);
$this->outputFile = File::temporaryFilename();
$writer->save($this->outputFile);
$spreadsheet->disconnectWorksheets();
$reader = new XlsxReader();
$spreadsheet2 = $reader->load($this->outputFile);
Calculation::getInstance($spreadsheet2)->setInstanceArrayReturnType(Calculation::RETURN_ARRAY_AS_ARRAY);
$sheet2 = $spreadsheet2->getActiveSheet();
$expectedUnique = [
[100, 91],
[85, 1],
[100, 92],
[734, 12],
//[100, 91], // not unique
[5, 2],
];
self::assertSame($expectedUnique, $sheet2->getCell('H1')->getCalculatedValue());
for ($row = 1; $row <= 5; ++$row) {
if ($row > 1) {
self::assertSame($expectedUnique[$row - 1][0], $sheet2->getCell("H$row")->getValue(), "cell H$row");
} else {
self::assertTrue($sheet2->getCell("H$row")->isFormula());
self::assertSame($expectedUnique[$row - 1][0], $sheet2->getCell("H$row")->getOldCalculatedValue(), "cell H$row");
}
self::assertSame($expectedUnique[$row - 1][1], $sheet2->getCell("I$row")->getValue(), "cell I$row");
}
$cellFormulaAttributes = $sheet2->getCell('H1')->getFormulaAttributes();
self::assertArrayHasKey('t', $cellFormulaAttributes);
self::assertSame('array', $cellFormulaAttributes['t']);
self::assertArrayHasKey('ref', $cellFormulaAttributes);
self::assertSame('H1:I5', $cellFormulaAttributes['ref']);
$spreadsheet2->disconnectWorksheets();
}
public function testMetadataWritten(): void
{
$spreadsheet = new Spreadsheet();
Calculation::getInstance($spreadsheet)->setInstanceArrayReturnType(Calculation::RETURN_ARRAY_AS_ARRAY);
$writer = new XlsxWriter($spreadsheet);
$writerMetadata = new XlsxWriter\Metadata($writer);
self::assertNotEquals('', $writerMetadata->writeMetaData());
$writer->setUseCSEArrays(true);
$writerMetadata2 = new XlsxWriter\Metadata($writer);
self::assertSame('', $writerMetadata2->writeMetaData());
$spreadsheet->disconnectWorksheets();
}
public function testSpill(): void
{
$spreadsheet = new Spreadsheet();
Calculation::getInstance($spreadsheet)->setInstanceArrayReturnType(Calculation::RETURN_ARRAY_AS_ARRAY);
$sheet = $spreadsheet->getActiveSheet();
$sheet->getCell('A3')->setValue('x');
$sheet->getCell('A1')->setValue('=UNIQUE({1;2;3})');
$writer = new XlsxWriter($spreadsheet);
$this->outputFile = File::temporaryFilename();
$writer->save($this->outputFile);
$spreadsheet->disconnectWorksheets();
$reader = new XlsxReader();
$spreadsheet2 = $reader->load($this->outputFile);
Calculation::getInstance($spreadsheet2)->setInstanceArrayReturnType(Calculation::RETURN_ARRAY_AS_ARRAY);
$sheet2 = $spreadsheet2->getActiveSheet();
self::assertSame('#SPILL!', $sheet2->getCell('A1')->getOldCalculatedValue());
self::assertSame('=UNIQUE({1;2;3})', $sheet2->getCell('A1')->getValue());
self::assertNull($sheet2->getCell('A2')->getValue());
self::assertSame('x', $sheet2->getCell('A3')->getValue());
$spreadsheet2->disconnectWorksheets();
}
public function testArrayStringOutput(): void
{
$spreadsheet = new Spreadsheet();
Calculation::getInstance($spreadsheet)->setInstanceArrayReturnType(Calculation::RETURN_ARRAY_AS_ARRAY);
$sheet = $spreadsheet->getActiveSheet();
$columnArray = [
['item1'],
['item2'],
['item3'],
['item1'],
['item1'],
['item6'],
['item7'],
['item1'],
['item9'],
['item1'],
];
$sheet->fromArray($columnArray, 'A1');
$sheet->setCellValue('C1', '=UNIQUE(A1:A10)');
$writer = new XlsxWriter($spreadsheet);
$this->outputFile = File::temporaryFilename();
$writer->save($this->outputFile);
$spreadsheet->disconnectWorksheets();
$reader = new XlsxReader();
$spreadsheet2 = $reader->load($this->outputFile);
Calculation::getInstance($spreadsheet2)->setInstanceArrayReturnType(Calculation::RETURN_ARRAY_AS_ARRAY);
$sheet2 = $spreadsheet2->getActiveSheet();
$expectedUnique = [
['item1'],
['item2'],
['item3'],
['item6'],
['item7'],
['item9'],
];
self::assertSame($expectedUnique, $sheet2->getCell('C1')->getCalculatedValue());
self::assertSame($expectedUnique[0][0], $sheet2->getCell('C1')->getCalculatedValueString());
for ($row = 2; $row <= 6; ++$row) {
self::assertSame($expectedUnique[$row - 1][0], $sheet2->getCell("C$row")->getCalculatedValue(), "cell C$row");
}
$spreadsheet2->disconnectWorksheets();
$file = 'zip://';
$file .= $this->outputFile;
$file .= '#xl/worksheets/sheet1.xml';
$data = file_get_contents($file);
if ($data === false) {
self::fail('Unable to read file');
} else {
self::assertStringContainsString('<c r="C1" cm="1" t="str"><f t="array" ref="C1:C6" aca="1" ca="1">_xlfn.UNIQUE(A1:A10)</f><v>item1</v></c>', $data, '6 results for UNIQUE');
}
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Xlsx/Issue2266Test.php | tests/PhpSpreadsheetTests/Writer/Xlsx/Issue2266Test.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Xlsx;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx as Reader;
use PhpOffice\PhpSpreadsheetTests\Functional\AbstractFunctional;
class Issue2266Test extends AbstractFunctional
{
#[\PHPUnit\Framework\Attributes\DataProvider('providerType')]
public function testIssue2266(string $type): void
{
// Problem deleting sheet containing local defined name.
$reader = new Reader();
$spreadsheet = $reader->load('tests/data/Writer/XLSX/issue.2266f.xlsx');
self::assertCount(2, $spreadsheet->getAllSheets());
self::assertCount(1, $spreadsheet->getDefinedNames());
$index = 1;
$sheet = $spreadsheet->getSheet($index);
self::assertSame('Sheet2', $sheet->getTitle());
$definedName = $spreadsheet->getDefinedName('LocalName', $sheet);
self::assertNotNull($definedName);
self::assertTrue($definedName->getLocalOnly());
$spreadsheet->removeSheetByIndex($index);
$reloadedSpreadsheet = $this->writeAndReload($spreadsheet, $type);
$spreadsheet->disconnectWorksheets();
self::assertCount(1, $reloadedSpreadsheet->getAllSheets());
self::assertCount(0, $reloadedSpreadsheet->getDefinedNames());
self::assertNotEquals('Sheet2', $reloadedSpreadsheet->getSheet(0)->getTitle());
$reloadedSpreadsheet->disconnectWorksheets();
}
public static function providerType(): array
{
return [
['Xlsx'],
['Xls'],
['Ods'],
];
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Xlsx/PageBreakTest.php | tests/PhpSpreadsheetTests/Writer/Xlsx/PageBreakTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Xlsx;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Worksheet\Worksheet;
use PhpOffice\PhpSpreadsheet\Writer\Xlsx;
use PHPUnit\Framework\TestCase;
class PageBreakTest extends TestCase
{
public function testRows(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->setCellValue('B1', 'First Page');
$sheet->setCellValue('B2', 'Second Page');
$sheet->getPageSetup()->setPrintArea('B1:B2');
$sheet->setBreak('B1', Worksheet::BREAK_ROW);
$sheet->getColumnDimension('B')->setAutoSize(true);
$writer = new Xlsx($spreadsheet);
$writerWorksheet = new Xlsx\Worksheet($writer);
$data = $writerWorksheet->writeWorksheet($sheet, []);
self::assertStringContainsString('<rowBreaks count="1" manualBreakCount="1"><brk id="1" man="1" max="2"/></rowBreaks>', $data);
$spreadsheet->disconnectWorksheets();
}
public function testRowsNoPrintArea(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->setCellValue('B1', 'First Page');
$sheet->setCellValue('B2', 'Second Page');
$sheet->setBreak('B1', Worksheet::BREAK_ROW);
$sheet->getColumnDimension('B')->setAutoSize(true);
$writer = new Xlsx($spreadsheet);
$writerWorksheet = new Xlsx\Worksheet($writer);
$data = $writerWorksheet->writeWorksheet($sheet, []);
self::assertStringContainsString('<rowBreaks count="1" manualBreakCount="1"><brk id="1" man="1"/></rowBreaks>', $data);
$spreadsheet->disconnectWorksheets();
}
public function testCols(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->setCellValue('B1', 'First Page');
$sheet->setCellValue('C1', 'Second Page');
$sheet->getPageSetup()->setPrintArea('B1:C1');
$sheet->setBreak('C1', Worksheet::BREAK_COLUMN);
$sheet->getColumnDimension('B')->setAutoSize(true);
$sheet->getColumnDimension('C')->setAutoSize(true);
$writer = new Xlsx($spreadsheet);
$writerWorksheet = new Xlsx\Worksheet($writer);
$data = $writerWorksheet->writeWorksheet($sheet, []);
self::assertStringContainsString('<colBreaks count="1" manualBreakCount="1"><brk id="2" man="1" max="1"/></colBreaks>', $data);
$spreadsheet->disconnectWorksheets();
}
public function testColsNoPrintArea(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->setCellValue('B1', 'First Page');
$sheet->setCellValue('C1', 'Second Page');
$sheet->setBreak('C1', Worksheet::BREAK_COLUMN);
$sheet->getColumnDimension('B')->setAutoSize(true);
$sheet->getColumnDimension('C')->setAutoSize(true);
$writer = new Xlsx($spreadsheet);
$writerWorksheet = new Xlsx\Worksheet($writer);
$data = $writerWorksheet->writeWorksheet($sheet, []);
self::assertStringContainsString('<colBreaks count="1" manualBreakCount="1"><brk id="2" man="1"/></colBreaks>', $data);
$spreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Xlsx/ArrayFormulaValidationTest.php | tests/PhpSpreadsheetTests/Writer/Xlsx/ArrayFormulaValidationTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Xlsx;
use PhpOffice\PhpSpreadsheet\Calculation\Calculation;
use PhpOffice\PhpSpreadsheet\Cell\DataValidation;
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 ArrayFormulaValidationTest extends TestCase
{
private string $outputFile = '';
protected function tearDown(): void
{
if ($this->outputFile !== '') {
unlink($this->outputFile);
$this->outputFile = '';
}
}
#[\PHPUnit\Framework\Attributes\DataProvider('validationProvider')]
public function testWriteArrayFormulaValidation(string $formula): void
{
$spreadsheet = new Spreadsheet();
Calculation::getInstance($spreadsheet)
->setInstanceArrayReturnType(
Calculation::RETURN_ARRAY_AS_ARRAY
);
$sheet = $spreadsheet->getActiveSheet();
$sheet->setCellValue('C1', 1);
$sheet->setCellValue('C2', 2);
$sheet->setCellValue('C3', 3);
$sheet->setCellValue('C4', 3);
$sheet->setCellValue('C5', 5);
$sheet->setCellValue('C6', 6);
$sheet->setCellValue('B1', '=UNIQUE(C1:C6)');
$validation = $sheet->getCell('A1')->getDataValidation();
$validation->setType(DataValidation::TYPE_LIST);
$validation->setErrorStyle(DataValidation::STYLE_STOP);
$validation->setAllowBlank(true);
$validation->setShowDropDown(true);
$validation->setShowErrorMessage(true);
$validation->setError('Invalid input');
$validation->setFormula1($formula);
$sheet->getCell('A1')->setDataValidation($validation);
$this->outputFile = File::temporaryFilename();
$writer = new XlsxWriter($spreadsheet);
$writer->setUseDiskCaching(true, sys_get_temp_dir());
$writer->save($this->outputFile);
$spreadsheet->disconnectWorksheets();
$reader = new XlsxReader();
$spreadsheet2 = $reader->load($this->outputFile);
Calculation::getInstance($spreadsheet2)->setInstanceArrayReturnType(Calculation::RETURN_ARRAY_AS_ARRAY);
$sheet2 = $spreadsheet2->getActiveSheet();
$validation2 = $sheet2->getCell('A1')->getDataValidation();
self::assertSame('ANCHORARRAY($B$1)', $validation2->getFormula1());
$spreadsheet2->disconnectWorksheets();
$file = 'zip://';
$file .= $this->outputFile;
$file .= '#xl/worksheets/sheet1.xml';
$data = file_get_contents($file);
if ($data === false) {
self::fail('Unable to read file');
} else {
self::assertStringContainsString('<formula1>_xlfn.ANCHORARRAY($B$1)</formula1>', $data);
}
}
public static function validationProvider(): array
{
return [
['ANCHORARRAY($B$1)'],
['$B$1#'],
];
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Xlsx/DrawingsInsertRowsTest.php | tests/PhpSpreadsheetTests/Writer/Xlsx/DrawingsInsertRowsTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Xlsx;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx;
use PhpOffice\PhpSpreadsheetTests\Functional\AbstractFunctional;
class DrawingsInsertRowsTest extends AbstractFunctional
{
/**
* Test save and load XLSX file with drawing on 2nd worksheet.
*/
public function testSaveAfterInsertingRows(): void
{
// Read spreadsheet from file
$inputFilename = 'tests/data/Writer/XLSX/issue.2908.xlsx';
$reader = new Xlsx();
$spreadsheet = $reader->load($inputFilename);
$sheet = $spreadsheet->getActiveSheet();
$drawingCollection = $sheet->getDrawingCollection();
self::assertCount(1, $drawingCollection);
$drawing = $drawingCollection[0];
self::assertNotNull($drawing);
self::assertSame('D10', $drawing->getCoordinates());
self::assertSame('F11', $drawing->getCoordinates2());
self::assertSame('oneCell', $drawing->getEditAs());
$sheet->insertNewRowBefore(5);
$sheet->insertNewRowBefore(6);
// Save spreadsheet to file and read it back
$reloadedSpreadsheet = $this->writeAndReload($spreadsheet, 'Xlsx');
$spreadsheet->disconnectWorksheets();
$rsheet = $reloadedSpreadsheet->getActiveSheet();
$drawingCollection2 = $rsheet->getDrawingCollection();
self::assertCount(1, $drawingCollection2);
$drawing2 = $drawingCollection2[0];
self::assertNotNull($drawing2);
self::assertSame('D12', $drawing2->getCoordinates());
self::assertSame('F13', $drawing2->getCoordinates2());
self::assertSame('oneCell', $drawing2->getEditAs());
$reloadedSpreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Xlsx/MemoryDrawingTest.php | tests/PhpSpreadsheetTests/Writer/Xlsx/MemoryDrawingTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Xlsx;
use GdImage;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx as XlsxReader;
use PhpOffice\PhpSpreadsheet\Shared\File;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Worksheet\Drawing;
use PhpOffice\PhpSpreadsheet\Worksheet\MemoryDrawing;
use PhpOffice\PhpSpreadsheet\Writer\Xlsx as XlsxWriter;
use PhpOffice\PhpSpreadsheetTests\Functional\AbstractFunctional;
class MemoryDrawingTest extends AbstractFunctional
{
private string $outfile = '';
protected function tearDown(): void
{
if ($this->outfile !== '') {
unlink($this->outfile);
$this->outfile = '';
}
}
/**
* Test save and load XLSX file with transparent png.
*/
public function testIssue3624(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$contents = file_get_contents('tests/data/Writer/XLSX/issue.3624b.png');
$stamp = MemoryDrawing::fromString("$contents");
$stamp->setName('Stamp');
$stamp->setHeight(120);
$stamp->setCoordinates('A2');
$stamp->setWorksheet($sheet);
$this->outfile = File::temporaryFilename();
$writer = new XlsxWriter($spreadsheet);
$writer->save($this->outfile);
$spreadsheet->disconnectWorksheets();
$reader = new XlsxReader();
$reloadedSpreadsheet = $reader->load($this->outfile);
$rsheet = $reloadedSpreadsheet->getActiveSheet();
$drawings = $rsheet->getDrawingCollection();
self::assertCount(1, $drawings);
foreach ($drawings as $drawing) {
if ($drawing instanceof Drawing) {
$path = $drawing->getPath();
$contents = file_get_contents($path);
$gdImage = imagecreatefromstring("$contents");
if ($gdImage === false) {
self::fail('unexpected failure in imagecreatefromstring');
} else {
self::assertTrue(self::checkTransparent($gdImage));
}
} else {
self::fail('Unexpected drawing not in Drawing class');
}
}
$reloadedSpreadsheet->disconnectWorksheets();
}
/**
* Determine if image uses transparency.
*
* @see https://stackoverflow.com/questions/5495275/how-to-check-if-a-png-image-has-transparency-using-gd
*/
private static function checkTransparent(GdImage $im): bool
{
$width = imagesx($im); // Get the width of the image
$height = imagesy($im); // Get the height of the image
// We run the image pixel by pixel and as soon as we find a transparent pixel we stop and return true.
for ($i = 0; $i < $width; ++$i) {
for ($j = 0; $j < $height; ++$j) {
$rgba = imagecolorat($im, $i, $j);
if (($rgba & 0x7F000000) >> 24) {
return true;
}
}
}
// If we dont find any pixel the function will return false.
return false;
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Xlsx/Issue4537Test.php | tests/PhpSpreadsheetTests/Writer/Xlsx/Issue4537Test.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Xlsx;
use PhpOffice\PhpSpreadsheet\Cell\DataType;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx as XlsxReader;
use PhpOffice\PhpSpreadsheet\RichText\RichText;
use PhpOffice\PhpSpreadsheet\RichText\TextElement;
use PhpOffice\PhpSpreadsheet\Shared\File;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Writer\Xlsx as XlsxWriter;
use PHPUnit\Framework\TestCase;
class Issue4537Test extends TestCase
{
private string $outputFilename = '';
protected function tearDown(): void
{
if ($this->outputFilename !== '') {
unlink($this->outputFilename);
$this->outputFilename = '';
}
}
public function testBackgroundImage(): void
{
$this->outputFilename = File::temporaryFilename();
$testString = "\"He\": '<?>'";
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->getCell('A1')->setValueExplicit($testString, DataType::TYPE_INLINE);
$sheet->getCell('A2')->setValue($testString);
$richText = new RichText();
$richText->addText(new TextElement($testString));
$sheet->getCell('A3')->setValue($richText);
$writer = new XlsxWriter($spreadsheet);
$writer->save($this->outputFilename);
$spreadsheet->disconnectWorksheets();
$reader = new XlsxReader();
$reloadedSpreadsheet = $reader->load($this->outputFilename);
$rsheet = $reloadedSpreadsheet->getActiveSheet();
self::assertSame($testString, $rsheet->getCell('A1')->getValueString());
self::assertSame($testString, $rsheet->getCell('A2')->getValueString());
self::assertSame($testString, $rsheet->getCell('A3')->getValueString());
$reloadedSpreadsheet->disconnectWorksheets();
$file = 'zip://';
$file .= $this->outputFilename;
$file .= '#xl/worksheets/sheet1.xml';
$data = file_get_contents($file);
// expected, and expected1/2 below, do not escape apostrophes
$expected = 't="inlineStr"><is><t>"He": \'<?>\'</t></is>';
if ($data === false) {
self::fail('Unable to read worksheets file');
} else {
self::assertStringContainsString($expected, $data, 'inline string');
}
$file = 'zip://';
$file .= $this->outputFilename;
$file .= '#xl/sharedStrings.xml';
$data = file_get_contents($file);
$expected1 = '<t>"He": \'<?>\'</t>';
$expected2 = '<t xml:space="preserve">"He": \'<?>\'</t>';
if ($data === false) {
self::fail('Unable to read sharedStrings file');
} else {
self::assertStringContainsString($expected1, $data, 'string');
self::assertStringContainsString($expected2, $data, 'rich text');
}
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Xlsx/FontCharsetTest.php | tests/PhpSpreadsheetTests/Writer/Xlsx/FontCharsetTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Xlsx;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheetTests\Functional\AbstractFunctional;
class FontCharsetTest 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 testFontCharset(): void
{
$spreadsheet = $this->spreadsheet = new Spreadsheet();
$sheet = $this->spreadsheet->getActiveSheet();
$sheet->getStyle('A1')->getFont()->setName('Nazanin');
$spreadsheet->addFontCharset('Nazanin');
$spreadsheet2 = $this->reloadedSpreadsheet = $this->writeAndReload($spreadsheet, 'Xlsx');
$sheet2 = $spreadsheet2->getActiveSheet();
$sheet2->getStyle('B1')->getFont()->setName('B Nazanin');
$sheet2->getStyle('C1')->getFont()->setName('C Nazanin');
$sheet2->getStyle('D1')->getFont()->setName('D Nazanin');
$spreadsheet2->addFontCharset('C Nazanin');
// Do not add D Nazanin for this test.
self::assertSame(
[
'B Nazanin' => 178, // default entry
'Nazanin' => 178, // should have been set by Xlsx Reader
'C Nazanin' => 178, // explicitly set in this test
],
$spreadsheet2->getFontCharsets()
);
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Xlsx/Issue3843Test.php | tests/PhpSpreadsheetTests/Writer/Xlsx/Issue3843Test.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Xlsx;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx as XlsxReader;
use PhpOffice\PhpSpreadsheet\Worksheet\Drawing;
use PhpOffice\PhpSpreadsheetTests\Functional\AbstractFunctional;
class Issue3843Test extends AbstractFunctional
{
private const DIRECTORY = 'tests/data/Writer/XLSX/';
private const TEMPLATE = self::DIRECTORY . 'issue.3843a.template.xlsx';
private const IMAGE = self::DIRECTORY . 'issue.3843a.jpg';
public function testPreliminaries(): void
{
$file = 'zip://';
$file .= self::TEMPLATE;
$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('<drawing r:id="rId2"/>', $data);
}
}
public function testUnusedDrawingsInOriginal(): void
{
$reader = new XlsxReader();
$spreadsheet = $reader->load(self::TEMPLATE);
$sheet = $spreadsheet->getActiveSheet();
$drawings = $sheet->getDrawingCollection();
self::assertCount(0, $drawings);
$drawing = new Drawing();
$drawing->setName('TestDrawing');
$drawing->setPath(self::IMAGE);
$drawing->setCoordinates('A2');
$drawing->setWidth(100);
$drawing->setHeight(100);
$drawing->setResizeProportional(false);
$drawing->setWorksheet($sheet);
// Save spreadsheet to file and read it back
$reloadedSpreadsheet = $this->writeAndReload($spreadsheet, 'Xlsx');
$spreadsheet->disconnectWorksheets();
$drawings = $reloadedSpreadsheet->getActiveSheet()->getDrawingCollection();
self::assertCount(1, $drawings);
$drawing = $drawings[0];
self::assertSame('TestDrawing', $drawing?->getName());
$reloadedSpreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Xlsx/Issue993Test.php | tests/PhpSpreadsheetTests/Writer/Xlsx/Issue993Test.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Xlsx;
use PhpOffice\PhpSpreadsheet\Cell\Hyperlink;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx as XlsxReader;
use PhpOffice\PhpSpreadsheet\Shared\File;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Worksheet\Drawing;
use PhpOffice\PhpSpreadsheet\Writer\Xlsx as XlsxWriter;
use PHPUnit\Framework\TestCase;
class Issue993Test extends TestCase
{
private string $outputFile = '';
protected function tearDown(): void
{
if ($this->outputFile !== '') {
unlink($this->outputFile);
$this->outputFile = '';
}
}
public function testDrawingWithPoundUrl(): void
{
$path = 'samples/images/blue_square.png';
$spreadsheet = new Spreadsheet();
$sheet1 = $spreadsheet->getActiveSheet();
$sheet1->setTitle('sheet1');
$sheet2 = $spreadsheet->createSheet();
$sheet2->setTitle('sheet2');
$drawing = new Drawing();
$drawing->setWorksheet($sheet1);
$drawing->setName('Blue Square');
$drawing->setPath($path);
$drawing->setCoordinates('E1');
$drawing->setCoordinates2('F5');
$hyperlink = new Hyperlink('#sheet2!C3', 'Click here');
$drawing->setHyperlink($hyperlink);
$writer = new XlsxWriter($spreadsheet);
$this->outputFile = File::temporaryFilename();
$writer->save($this->outputFile);
$spreadsheet->disconnectWorksheets();
$file = 'zip://';
$file .= $this->outputFile;
$file .= '#xl/drawings/_rels/drawing1.xml.rels';
$data = file_get_contents($file);
self::assertNotFalse($data);
self::assertStringContainsString('<Relationship Id="rId2" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink" Target="#sheet2!C3"/>', $data, 'url unchanged by write');
$reader = new XlsxReader();
$reloadedSpreadsheet = $reader->load($this->outputFile);
$rsheet1 = $reloadedSpreadsheet->getSheetByName('sheet1');
self::assertNotNull($rsheet1);
$drawings = $rsheet1->getDrawingCollection();
self::assertCount(1, $drawings);
$drawing0 = $drawings[0];
self::assertSame('sheet://sheet2!C3', $drawing0?->getHyperlink()?->getUrl(), 'url was changed on read');
$reloadedSpreadsheet->disconnectWorksheets();
}
public function testDrawingWithSheetUrl(): void
{
$path = 'samples/images/blue_square.png';
$spreadsheet = new Spreadsheet();
$sheet1 = $spreadsheet->getActiveSheet();
$sheet1->setTitle('sheet1');
$sheet2 = $spreadsheet->createSheet();
$sheet2->setTitle('sheet2');
$drawing = new Drawing();
$drawing->setWorksheet($sheet1);
$drawing->setName('Blue Square');
$drawing->setPath($path);
$drawing->setCoordinates('E1');
$drawing->setCoordinates2('F5');
$hyperlink = new Hyperlink('sheet://sheet2!C3', 'Click here');
$drawing->setHyperlink($hyperlink);
$writer = new XlsxWriter($spreadsheet);
$this->outputFile = File::temporaryFilename();
$writer->save($this->outputFile);
$spreadsheet->disconnectWorksheets();
$file = 'zip://';
$file .= $this->outputFile;
$file .= '#xl/drawings/_rels/drawing1.xml.rels';
$data = file_get_contents($file);
self::assertNotFalse($data);
self::assertStringContainsString('<Relationship Id="rId2" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink" Target="#sheet2!C3"/>', $data, 'url changed by write');
$reader = new XlsxReader();
$reloadedSpreadsheet = $reader->load($this->outputFile);
$rsheet1 = $reloadedSpreadsheet->getSheetByName('sheet1');
self::assertNotNull($rsheet1);
$drawings = $rsheet1->getDrawingCollection();
self::assertCount(1, $drawings);
$drawing0 = $drawings[0];
self::assertSame('sheet://sheet2!C3', $drawing0?->getHyperlink()?->getUrl(), 'url was changed back on read');
$reloadedSpreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Xlsx/AutoColorTest.php | tests/PhpSpreadsheetTests/Writer/Xlsx/AutoColorTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\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 AutoColorTest extends TestCase
{
private string $outputFile = '';
protected function tearDown(): void
{
if ($this->outputFile !== '') {
unlink($this->outputFile);
$this->outputFile = '';
}
}
public function testAutoColor(): void
{
// It's not clear to me what AutoColor does in Excel.
// However, LibreOffice Dark Mode
// can make use of a spreadsheet which uses it.
$spreadsheet = new Spreadsheet();
$spreadsheet->getDefaultStyle()->getFont()
->setAutoColor(true);
$sheet = $spreadsheet->getActiveSheet();
$sheet->setCellValue('A1', 'Hello World!');
$sheet->setCellValue('A2', 'Hello World!');
$sheet->getStyle('A2')->getFont()
->setBold(true);
$sheet->setCellValue('A3', 'Hello World!');
$sheet->getStyle('A3')->getFont()
->setItalic(true);
$sheet->setCellValue('B1', 'Hello World!');
$writer = new XlsxWriter($spreadsheet);
$outputFile = $this->outputFile = File::temporaryFilename();
$writer->save($outputFile);
$spreadsheet->disconnectWorksheets();
$zipfile = "zip://$outputFile#xl/styles.xml";
$contents = file_get_contents($zipfile);
if ($contents === false) {
self::fail('Unable to open file');
} else {
self::assertStringContainsString('<fonts count="3">', $contents);
self::assertStringContainsString('<font><b val="0"/><i val="0"/><strike val="0"/><u val="none"/><sz val="11"/><auto val="1"/><name val="Calibri"/></font>', $contents);
self::assertStringContainsString('<font><b val="1"/><i val="0"/><strike val="0"/><u val="none"/><sz val="11"/><auto val="1"/><name val="Calibri"/></font>', $contents);
self::assertStringContainsString('<font><b val="0"/><i val="1"/><strike val="0"/><u val="none"/><sz val="11"/><auto val="1"/><name val="Calibri"/></font>', $contents);
}
$reader = new XlsxReader();
$spreadsheet2 = $reader->load($outputFile);
$sheet2 = $spreadsheet2->getActiveSheet();
self::assertTrue(
$sheet2->getStyle('A1')
->getFont()
->getAutoColor()
);
$spreadsheet2->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Xlsx/Issue4584Test.php | tests/PhpSpreadsheetTests/Writer/Xlsx/Issue4584Test.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Xlsx;
use PhpOffice\PhpSpreadsheet\Exception as PhpSpreadsheetException;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Writer\Xlsx as XlsxWriter;
use PhpOffice\PhpSpreadsheetTests\Functional\AbstractFunctional;
class Issue4584Test extends AbstractFunctional
{
public function testWriteRowDimensions(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->getDefaultRowDimension()->setRowHeight(20);
$sheet->setCellValue('A1', 'hello there world 1');
$sheet->getStyle('A1')->getAlignment()->setWrapText(true);
$sheet->getRowDimension(1)->setCustomFormat(true);
$sheet->setCellValue('A2', 'hello there world 2');
$sheet->setCellValue('A4', 'hello there world 4');
$writer = new XlsxWriter($spreadsheet);
$writerWorksheet = new XlsxWriter\Worksheet($writer);
$data = $writerWorksheet->writeWorksheet($sheet, []);
self::assertStringContainsString(
'<sheetFormatPr customHeight="true" defaultRowHeight="20" outlineLevelRow="0" outlineLevelCol="0"/>',
$data
);
self::assertStringContainsString(
'<row r="1" spans="1:1" customFormat="1" ht="-1">',
$data
);
self::assertStringContainsString(
'<row r="2" spans="1:1" customHeight="1">',
$data
);
self::assertStringContainsString(
'<row r="4" spans="1:1" customHeight="1">',
$data
);
$spreadsheet->disconnectWorksheets();
}
public function testWriteRowDimensionsNoCustom(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->getDefaultRowDimension()->setRowHeight(20);
$sheet->setCellValue('A1', 'hello there world 1');
$sheet->getStyle('A1')->getAlignment()->setWrapText(true);
//$sheet->getRowDimension(1)->setCustomFormat(true);
$sheet->setCellValue('A2', 'hello there world 2');
$sheet->setCellValue('A4', 'hello there world 4');
$writer = new XlsxWriter($spreadsheet);
$writerWorksheet = new XlsxWriter\Worksheet($writer);
$data = $writerWorksheet->writeWorksheet($sheet, []);
self::assertStringContainsString(
'<sheetFormatPr customHeight="true" defaultRowHeight="20" outlineLevelRow="0" outlineLevelCol="0"/>',
$data
);
self::assertStringContainsString(
'<row r="1" spans="1:1">',
$data
);
self::assertStringContainsString(
'<row r="2" spans="1:1">',
$data
);
self::assertStringContainsString(
'<row r="4" spans="1:1">',
$data
);
$spreadsheet->disconnectWorksheets();
}
public function testWriteAndReadRowDimension(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->getDefaultRowDimension()->setRowHeight(20);
$sheet->setCellValue('A1', 'hello there world 1');
$sheet->getStyle('A1')->getAlignment()->setWrapText(true);
$sheet->getRowDimension(1)->setCustomFormat(true);
$sheet->setCellValue('A2', 'hello there world 2');
$sheet->setCellValue('A4', 'hello there world 4');
$reloadedSpreadsheet = $this->writeAndReload($spreadsheet, 'Xlsx');
$spreadsheet->disconnectWorksheets();
$rsheet = $reloadedSpreadsheet->getActiveSheet();
$rwriter = new XlsxWriter($reloadedSpreadsheet);
$rwriterWorksheet = new XlsxWriter\Worksheet($rwriter);
$data = $rwriterWorksheet->writeWorksheet($rsheet, []);
self::assertStringContainsString(
'<sheetFormatPr customHeight="true" defaultRowHeight="20" outlineLevelRow="0" outlineLevelCol="0"/>',
$data
);
self::assertStringContainsString(
'<row r="1" spans="1:1" customFormat="1" ht="-1">',
$data
);
self::assertStringContainsString(
'<row r="2" spans="1:1" customHeight="1">',
$data
);
self::assertStringContainsString(
'<row r="4" spans="1:1" customHeight="1">',
$data
);
$reloadedSpreadsheet->disconnectWorksheets();
}
public function testBadOutlineLevel(): void
{
$this->expectException(PhpSpreadsheetException::class);
$this->expectExceptionMessage('Outline level must range between 0 and 7.');
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->getRowDimension(1)->setOutlineLevel(8);
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Xlsx/UnparsedDataTest.php | tests/PhpSpreadsheetTests/Writer/Xlsx/UnparsedDataTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Xlsx;
use Exception;
use PhpOffice\PhpSpreadsheet\Shared\File;
use PHPUnit\Framework\TestCase;
use ZipArchive;
class UnparsedDataTest extends TestCase
{
/**
* Test load and save Xlsx file with unparsed data (form elements, protected sheets, alternate contents, printer settings,..).
*/
public function testLoadSaveXlsxWithUnparsedData(): void
{
$sampleFilename = 'tests/data/Writer/XLSX/form_pass_print.xlsm';
$resultFilename = File::temporaryFilename();
$reader = new \PhpOffice\PhpSpreadsheet\Reader\Xlsx();
$excel = $reader->load($sampleFilename);
$excel->getSheet(1)->setCellValue('B1', '222');
$writer = new \PhpOffice\PhpSpreadsheet\Writer\Xlsx($excel);
$writer->setUseDiskCaching(true, sys_get_temp_dir());
$writer->save($resultFilename);
self::assertFileExists($resultFilename);
$resultZip = new ZipArchive();
$resultZip->open($resultFilename);
$resultContentTypesRaw = $resultZip->getFromName('[Content_Types].xml');
$resultControlPropRaw = $resultZip->getFromName('xl/ctrlProps/ctrlProp1.xml');
$resultDrawingRaw = $resultZip->getFromName('xl/drawings/drawing1.xml');
$resultVmlDrawingRaw = $resultZip->getFromName('xl/drawings/vmlDrawing1.vml');
$resultPrinterSettingsRaw = $resultZip->getFromName('xl/printerSettings/printerSettings1.bin');
$resultVbaProjectRaw = $resultZip->getFromName('xl/vbaProject.bin');
$resultWorkbookRaw = $resultZip->getFromName('xl/workbook.xml');
$resultSheet1RelsRaw = $resultZip->getFromName('xl/worksheets/_rels/sheet1.xml.rels');
$resultSheet1Raw = $resultZip->getFromName('xl/worksheets/sheet1.xml');
$resultSheet2Raw = $resultZip->getFromName('xl/worksheets/sheet2.xml');
if (false === $resultZip->close()) {
throw new Exception("Could not close zip file \"{$resultFilename}\".");
}
unlink($resultFilename);
// [Content_Types].xml
self::assertStringContainsString('application/vnd.openxmlformats-officedocument.spreadsheetml.printerSettings', $resultContentTypesRaw, 'Content type for printerSettings not found!');
self::assertStringContainsString('application/vnd.ms-office.vbaProject', $resultContentTypesRaw, 'Content type for VbaProject not found!');
self::assertStringContainsString('application/vnd.ms-excel.controlproperties+xml', $resultContentTypesRaw, 'Content type for ctrlProp not found!');
// xl/ctrlProps/ctrlProp1.xml
self::assertNotEmpty($resultControlPropRaw, 'ctrlProp not found!');
// xl/drawings/drawing1.xml
self::assertStringContainsString('<mc:AlternateContent', $resultDrawingRaw, 'AlternateContent at drawing.xml not found!');
// xl/drawings/vmlDrawing1.vml
self::assertNotEmpty($resultVmlDrawingRaw, 'vmlDrawing not found!');
// xl/printerSettings/printerSettings1.bin
self::assertNotEmpty($resultPrinterSettingsRaw, 'printerSettings.bin not found!');
// xl/vbaProject.bin
self::assertNotEmpty($resultVbaProjectRaw, 'vbaProject.bin not found!');
// xl/workbook.xml
$xmlWorkbook = simplexml_load_string($resultWorkbookRaw ?: '', 'SimpleXMLElement');
self::assertNotFalse($xmlWorkbook);
if (!$xmlWorkbook->workbookProtection) {
self::fail('workbook.xml/workbookProtection not found!');
} else {
self::assertEquals($xmlWorkbook->workbookProtection['workbookPassword'], 'CBEB', 'workbook.xml/workbookProtection[workbookPassword] is wrong!');
self::assertEquals($xmlWorkbook->workbookProtection['lockStructure'], 'true', 'workbook.xml/workbookProtection[lockStructure] is wrong!');
self::assertInstanceOf('SimpleXMLElement', $xmlWorkbook->sheets->sheet[0]);
self::assertInstanceOf('SimpleXMLElement', $xmlWorkbook->sheets->sheet[1]);
self::assertEquals($xmlWorkbook->sheets->sheet[0]['state'], '', 'workbook.xml/sheets/sheet[0][state] is wrong!');
self::assertNotNull($xmlWorkbook->sheets->sheet[1]);
self::assertEquals($xmlWorkbook->sheets->sheet[1]['state'], 'hidden', 'workbook.xml/sheets/sheet[1][state] is wrong!');
}
unset($xmlWorkbook);
// xl/worksheets/_rels/sheet1.xml.rels
self::assertStringContainsString('http://schemas.openxmlformats.org/officeDocument/2006/relationships/printerSettings', $resultSheet1RelsRaw, 'Sheet relation with printerSettings not found!');
self::assertStringContainsString('http://schemas.openxmlformats.org/officeDocument/2006/relationships/vmlDrawing', $resultSheet1RelsRaw, 'Sheet relation with vmlDrawing not found!');
self::assertStringContainsString('http://schemas.openxmlformats.org/officeDocument/2006/relationships/ctrlProp', $resultSheet1RelsRaw, 'Sheet relation with ctrlProp not found!');
// xl/worksheets/sheet1.xml
self::assertStringContainsString('<mc:AlternateContent', $resultSheet1Raw, 'AlternateContent at sheet1.xml not found!');
$xmlWorksheet = simplexml_load_string($resultSheet1Raw ?: '', 'SimpleXMLElement');
self::assertNotFalse($xmlWorksheet);
$pageSetupAttributes = $xmlWorksheet->pageSetup->attributes('http://schemas.openxmlformats.org/officeDocument/2006/relationships');
self::assertTrue(isset($pageSetupAttributes->id), 'sheet1.xml/pageSetup[r:id] not found!');
if (!$xmlWorksheet->sheetProtection) {
self::fail('sheet1.xml/sheetProtection not found!');
} else {
self::assertEquals($xmlWorksheet->sheetProtection['password'], 'CBEB', 'sheet1.xml/sheetProtection[password] is wrong!');
self::assertEquals($xmlWorksheet->sheetProtection['sheet'], '1', 'sheet1.xml/sheetProtection[sheet] is wrong!');
self::assertEquals($xmlWorksheet->sheetProtection['objects'], '1', 'sheet1.xml/sheetProtection[objects] is wrong!');
self::assertEquals($xmlWorksheet->sheetProtection['scenarios'], '1', 'sheet1.xml/sheetProtection[scenarios] is wrong!');
}
unset($xmlWorksheet);
// xl/worksheets/sheet2.xml
self::assertNotEmpty($resultSheet2Raw, 'sheet2.xml not found!');
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Xlsx/Issue3988Test.php | tests/PhpSpreadsheetTests/Writer/Xlsx/Issue3988Test.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Xlsx;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx as XlsxReader;
use PhpOffice\PhpSpreadsheet\Shared\File;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Worksheet\AutoFilter;
use PhpOffice\PhpSpreadsheet\Worksheet\Table;
use PhpOffice\PhpSpreadsheet\Writer\Xlsx as XlsxWriter;
use PHPUnit\Framework\TestCase;
class Issue3988Test extends TestCase
{
public function testIssue3988(): void
{
// code liberally borrowed from samples/Table/01_Table
$spreadsheet = new Spreadsheet();
$spreadsheet->setActiveSheetIndex(0);
$spreadsheet->getActiveSheet()->setCellValue('A1', 'Year')
->setCellValue('B1', 'Quarter')
->setCellValue('C1', 'Country')
->setCellValue('D1', 'Sales');
$dataArray = [
['2010', 'Q1', 'United States', 790],
['2010', 'Q2', 'United States', 730],
['2010', 'Q3', 'United States', 860],
['2010', 'Q4', 'United States', 850],
['2011', 'Q1', 'United States', 800],
['2011', 'Q2', 'United States', 700],
['2011', 'Q3', 'United States', 900],
['2011', 'Q4', 'United States', 950],
['2010', 'Q1', 'Belgium', 380],
['2010', 'Q2', 'Belgium', 390],
['2010', 'Q3', 'Belgium', 420],
['2010', 'Q4', 'Belgium', 460],
['2011', 'Q1', 'Belgium', 400],
['2011', 'Q2', 'Belgium', 350],
['2011', 'Q3', 'Belgium', 450],
['2011', 'Q4', 'Belgium', 500],
['2010', 'Q1', 'UK', 690],
['2010', 'Q2', 'UK', 610],
['2010', 'Q3', 'UK', 620],
['2010', 'Q4', 'UK', 600],
['2011', 'Q1', 'UK', 720],
['2011', 'Q2', 'UK', 650],
['2011', 'Q3', 'UK', 580],
['2011', 'Q4', 'UK', 510],
['2010', 'Q1', 'France', 510],
['2010', 'Q2', 'France', 490],
['2010', 'Q3', 'France', 460],
['2010', 'Q4', 'France', 590],
['2011', 'Q1', 'France', 620],
['2011', 'Q2', 'France', 650],
['2011', 'Q3', 'France', 415],
['2011', 'Q4', 'France', 570],
];
$spreadsheet->getActiveSheet()->fromArray($dataArray, null, 'A2');
$table = new Table('A1:D33', 'Sales_Data');
// Create Columns
$table->getColumn('D')->setShowFilterButton(false);
$table->getAutoFilter()->getColumn('A')
->setFilterType(AutoFilter\Column::AUTOFILTER_FILTERTYPE_CUSTOMFILTER)
->createRule()
->setRule(AutoFilter\Column\Rule::AUTOFILTER_COLUMN_RULE_GREATERTHANOREQUAL, 2011)
->setRuleType(AutoFilter\Column\Rule::AUTOFILTER_RULETYPE_CUSTOMFILTER);
$spreadsheet->getActiveSheet()->addTable($table);
$outfile = File::temporaryFilename();
$writer = new XlsxWriter($spreadsheet);
$writer->save($outfile);
$spreadsheet->disconnectWorksheets();
// Make sure Reader handles row visibility properly.
$reader = new XlsxReader();
$spreadsheet2 = $reader->load($outfile);
self::assertFalse($spreadsheet2->getActiveSheet()->getRowDimension(5)->getVisible());
self::assertTrue($spreadsheet2->getActiveSheet()->getRowDimension(6)->getVisible());
$spreadsheet2->disconnectWorksheets();
// Make sure filterColumn tags are children of autoFilter.
$file = 'zip://';
$file .= $outfile;
$file .= '#xl/tables/table1.xml';
$data = file_get_contents($file);
unlink($outfile);
$expected = '<autoFilter ref="A1:D33">'
. '<filterColumn colId="0">'
. '<customFilters>'
. '<customFilter operator="greaterThanOrEqual" val="2011"/>'
. '</customFilters>'
. '</filterColumn>'
. '<filterColumn colId="3" hiddenButton="1"/>'
. '</autoFilter>';
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/Writer/Xlsx/ThemeColorsTest.php | tests/PhpSpreadsheetTests/Writer/Xlsx/ThemeColorsTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Xlsx;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx as XlsxReader;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Style\Style;
use PhpOffice\PhpSpreadsheet\Theme as SpreadsheetTheme;
use PhpOffice\PhpSpreadsheetTests\Functional\AbstractFunctional;
class ThemeColorsTest extends AbstractFunctional
{
private const COLOR_SCHEME_2013_PLUS_NAME = 'Office 2013+';
public function testOffice2013Theme(): void
{
$spreadsheet = new Spreadsheet();
$spreadsheet->getTheme()
->setThemeColorName(
self::COLOR_SCHEME_2013_PLUS_NAME
);
$reloadedSpreadsheet = $this->writeAndReload($spreadsheet, 'Xlsx');
$spreadsheet->disconnectWorksheets();
self::assertSame(
SpreadsheetTheme::COLOR_SCHEME_2013_2022_NAME,
$reloadedSpreadsheet->getTheme()->getThemeColorName()
);
self::assertSame('FFC000', $reloadedSpreadsheet->getTheme()->getThemeColors()['accent4']);
self::assertSame('Calibri Light', $reloadedSpreadsheet->getTheme()->getMajorFontLatin());
self::assertSame('Calibri', $reloadedSpreadsheet->getTheme()->getMinorFontLatin());
$defaultFont2 = $reloadedSpreadsheet->getDefaultStyle()->getFont()->getName();
self::assertSame('Calibri', $defaultFont2);
$font3 = $reloadedSpreadsheet->getActiveSheet()
->getStyle('Z10')->getFont()->getName();
self::assertSame('Calibri', $font3);
$reloadedSpreadsheet->disconnectWorksheets();
}
public function testOffice2013Theme2(): void
{
$spreadsheet = new Spreadsheet();
$spreadsheet->getTheme()
->setThemeColorName(
SpreadsheetTheme::COLOR_SCHEME_2013_2022_NAME
);
$reloadedSpreadsheet = $this->writeAndReload($spreadsheet, 'Xlsx');
$spreadsheet->disconnectWorksheets();
self::assertSame(
SpreadsheetTheme::COLOR_SCHEME_2013_2022_NAME,
$reloadedSpreadsheet->getTheme()->getThemeColorName()
);
self::assertSame('FFC000', $reloadedSpreadsheet->getTheme()->getThemeColors()['accent4']);
self::assertSame('Calibri Light', $reloadedSpreadsheet->getTheme()->getMajorFontLatin());
self::assertSame('Calibri', $reloadedSpreadsheet->getTheme()->getMinorFontLatin());
$defaultFont2 = $reloadedSpreadsheet->getDefaultStyle()->getFont()->getName();
self::assertSame('Calibri', $defaultFont2);
$font3 = $reloadedSpreadsheet->getActiveSheet()
->getStyle('Z10')->getFont()->getName();
self::assertSame('Calibri', $font3);
$reloadedSpreadsheet->disconnectWorksheets();
}
public function testOffice2007Theme(): void
{
$spreadsheet = new Spreadsheet();
$spreadsheet->getTheme()->setThemeColorName(SpreadsheetTheme::COLOR_SCHEME_2007_2010_NAME);
$reloadedSpreadsheet = $this->writeAndReload($spreadsheet, 'Xlsx');
$spreadsheet->disconnectWorksheets();
self::assertSame('Office 2007-2010', $reloadedSpreadsheet->getTheme()->getThemeColorName());
self::assertSame('8064A2', $reloadedSpreadsheet->getTheme()->getThemeColors()['accent4']);
self::assertSame('Cambria', $reloadedSpreadsheet->getTheme()->getMajorFontLatin());
self::assertSame('Calibri', $reloadedSpreadsheet->getTheme()->getMinorFontLatin());
$defaultFont2 = $reloadedSpreadsheet->getDefaultStyle()->getFont()->getName();
self::assertSame('Calibri', $defaultFont2);
$font3 = $reloadedSpreadsheet->getActiveSheet()
->getStyle('Z10')->getFont()->getName();
self::assertSame('Calibri', $font3);
$reloadedSpreadsheet->disconnectWorksheets();
}
public function testDefaultTheme(): void
{
$spreadsheet = new Spreadsheet();
$reloadedSpreadsheet = $this->writeAndReload($spreadsheet, 'Xlsx');
$spreadsheet->disconnectWorksheets();
self::assertSame('Office', $reloadedSpreadsheet->getTheme()->getThemeColorName());
self::assertSame('8064A2', $reloadedSpreadsheet->getTheme()->getThemeColors()['accent4']);
self::assertSame('Cambria', $reloadedSpreadsheet->getTheme()->getMajorFontLatin());
self::assertSame('Calibri', $reloadedSpreadsheet->getTheme()->getMinorFontLatin());
$defaultFont2 = $reloadedSpreadsheet->getDefaultStyle()->getFont()->getName();
self::assertSame('Calibri', $defaultFont2);
$font3 = $reloadedSpreadsheet->getActiveSheet()
->getStyle('Z10')->getFont()->getName();
self::assertSame('Calibri', $font3);
$reloadedSpreadsheet->disconnectWorksheets();
}
public function testGalleryTheme(): void
{
$reader = new XlsxReader();
$spreadsheet = $reader->load('tests/data/Writer/XLSX/gallerytheme.xlsx');
$reloadedSpreadsheet = $this->writeAndReload($spreadsheet, 'Xlsx');
$spreadsheet->disconnectWorksheets();
self::assertSame('Gallery', $reloadedSpreadsheet->getTheme()->getThemeColorName());
self::assertSame('795FAF', $reloadedSpreadsheet->getTheme()->getThemeColors()['accent4']);
$reloadedSpreadsheet->disconnectWorksheets();
}
public function testOffice2023Theme(): void
{
$spreadsheet = new Spreadsheet();
$spreadsheet->getTheme()
->setThemeColorName(
SpreadsheetTheme::COLOR_SCHEME_2023_PLUS_NAME,
null,
$spreadsheet
);
self::assertSame('Aptos Narrow', $spreadsheet->getDefaultStyle()->getFont()->getName(), 'default style is attached to spreadsheet');
$style = new Style();
self::assertSame('Calibri', $style->getFont()->getName(), 'style not attached to spreadsheet');
$style2 = $spreadsheet->getActiveSheet()->getStyle('A7');
self::assertSame('Aptos Narrow', $style2->getFont()->getName(), 'font is attached to spreadsheet');
$reloadedSpreadsheet = $this->writeAndReload($spreadsheet, 'Xlsx');
$spreadsheet->disconnectWorksheets();
self::assertSame(
SpreadsheetTheme::COLOR_SCHEME_2023_PLUS_NAME,
$reloadedSpreadsheet->getTheme()->getThemeColorName()
);
self::assertSame('0F9ED5', $reloadedSpreadsheet->getTheme()->getThemeColors()['accent4']);
self::assertSame('Aptos Display', $reloadedSpreadsheet->getTheme()->getMajorFontLatin());
self::assertSame('Aptos Narrow', $reloadedSpreadsheet->getTheme()->getMinorFontLatin());
$defaultFont = $reloadedSpreadsheet->getDefaultStyle()->getFont()->getName();
self::assertSame('Aptos Narrow', $defaultFont);
$defaultFont2 = $reloadedSpreadsheet->getDefaultStyle()->getFont()->getName();
self::assertSame('Aptos Narrow', $defaultFont2);
$font3 = $reloadedSpreadsheet->getActiveSheet()
->getStyle('Z10')->getFont()->getName();
self::assertSame('Aptos Narrow', $font3);
$reloadedSpreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Xlsx/Issue484Test.php | tests/PhpSpreadsheetTests/Writer/Xlsx/Issue484Test.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Xlsx;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Worksheet\HeaderFooter;
use PhpOffice\PhpSpreadsheet\Worksheet\HeaderFooterDrawing;
use PhpOffice\PhpSpreadsheet\Worksheet\SheetView;
use PhpOffice\PhpSpreadsheetTests\Functional\AbstractFunctional;
class Issue484Test extends AbstractFunctional
{
public function testHeaderFooter(): void
{
$spreadsheet = new Spreadsheet();
$headerImage = new HeaderFooterDrawing();
$headerImage->setName('Header Logo');
$headerImage->setPath('samples/images/blue_square.png');
$headerImage->setHeight(12);
$footerImage = new HeaderFooterDrawing();
$footerImage->setName('Footer Logo');
$footerImage->setPath('samples/images/paid.png');
$footerImage->setHeight(12);
$worksheet = $spreadsheet->getActiveSheet();
$worksheet->getSheetView()
->setView(SheetView::SHEETVIEW_PAGE_LAYOUT);
$worksheet->getHeaderFooter()->setDifferentFirst(true);
$worksheet->getHeaderFooter()->setFirstHeader('&C&G&R&D');
$worksheet->getHeaderFooter()->addImage($headerImage, HeaderFooter::IMAGE_HEADER_CENTER_FIRST);
$worksheet->getHeaderFooter()->setDifferentOddEven(true);
$worksheet->getHeaderFooter()->setEvenHeader('&L&G&R&D');
$worksheet->getHeaderFooter()->addImage($headerImage, HeaderFooter::IMAGE_HEADER_LEFT_EVEN);
$worksheet->getHeaderFooter()->setEvenFooter('&C&G&R&D');
$worksheet->getHeaderFooter()->addImage($footerImage, HeaderFooter::IMAGE_FOOTER_CENTER_EVEN);
$worksheet->getHeaderFooter()->setOddHeader('&C&D');
for ($currentRow = 1; $currentRow < 130; ++$currentRow) {
$worksheet->setCellValue("A$currentRow", 'Bill');
$worksheet->setCellValue("B$currentRow", 'Smith');
}
// Save spreadsheet to file and read it back
$reloadedSpreadsheet = $this->writeAndReload($spreadsheet, 'Xlsx');
$spreadsheet->disconnectWorksheets();
$sheet = $reloadedSpreadsheet->getActiveSheet();
$images = $sheet->getHeaderFooter()->getImages();
self::assertSame(['LHEVEN', 'CHFIRST', 'CFEVEN'], array_keys($images));
$reloadedSpreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Xlsx/FloatsRetainedTest.php | tests/PhpSpreadsheetTests/Writer/Xlsx/FloatsRetainedTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Xlsx;
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\Attributes\DataProvider;
use PHPUnit\Framework\TestCase;
class FloatsRetainedTest extends TestCase
{
#[DataProvider('providerIntyFloatsRetainedByWriter')]
public function testIntyFloatsRetainedByWriter(float|int $value, mixed $expected = null): void
{
if ($expected === null) {
$expected = $value;
}
$outputFilename = File::temporaryFilename();
$spreadsheet = new Spreadsheet();
$spreadsheet->getActiveSheet()
->getCell('A1')->setValue($value);
$writer = new Writer($spreadsheet);
$writer->save($outputFilename);
$spreadsheet->disconnectWorksheets();
$reader = new Reader();
$spreadsheet2 = $reader->load($outputFilename);
unlink($outputFilename);
self::assertSame(
$expected,
$spreadsheet2->getActiveSheet()
->getCell('A1')->getValue()
);
$spreadsheet2->disconnectWorksheets();
}
public static function providerIntyFloatsRetainedByWriter(): array
{
return [
[-1.0],
[-1],
[0.0],
[0],
[1.0],
[1],
[1e-3],
[1.3e-10],
[1e10],
[3.00000000000000000001],
'int but too much precision for Excel' => [99_999_999_999_999_999, '99999999999999999'],
[99_999_999_999_999_999.0],
'int > PHP_INT_MAX so stored as float' => [999_999_999_999_999_999_999_999_999_999_999_999_999_999],
[999_999_999_999_999_999_999_999_999_999_999_999_999_999.0],
];
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Xlsx/Issue3951Test.php | tests/PhpSpreadsheetTests/Writer/Xlsx/Issue3951Test.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Xlsx;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheetTests\Functional\AbstractFunctional;
class Issue3951Test extends AbstractFunctional
{
#[\PHPUnit\Framework\Attributes\DataProvider('providerType')]
public function testIssue2266(string $type): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->setTitle('sorttrue');
$sheet->getCell('A1')->setValue(10);
$sheet->getCell('A2')->setValue(5);
$sheet->getCell('B1')->setValue(15);
$protection = $sheet->getProtection();
$protection->setPassword('testpassword');
$protection->setSheet(true);
$protection->setInsertRows(true);
$protection->setFormatCells(true);
$protection->setObjects(true);
$protection->setAutoFilter(false);
$protection->setSort(true);
$sheet = $spreadsheet->createSheet();
$sheet->setTitle('sortfalse');
$sheet->getCell('A1')->setValue(10);
$sheet->getCell('A2')->setValue(5);
$sheet->getCell('B1')->setValue(15);
$protection = $sheet->getProtection();
$protection->setPassword('testpassword');
$protection->setSheet(true);
$protection->setInsertRows(true);
$protection->setFormatCells(true);
$protection->setObjects(true);
$protection->setAutoFilter(false);
$protection->setSort(false);
$sheet = $spreadsheet->createSheet();
$sheet->setTitle('sortfalsenocolpw');
$sheet->getCell('A1')->setValue(10);
$sheet->getCell('A2')->setValue(5);
$sheet->getCell('C1')->setValue(15);
$protection = $sheet->getProtection();
$protection->setPassword('testpassword');
$protection->setSheet(true);
$protection->setInsertRows(true);
$protection->setFormatCells(true);
$protection->setObjects(true);
$protection->setAutoFilter(false);
$protection->setSort(false);
$sheet->protectCells('A:A');
$sheet = $spreadsheet->createSheet();
$sheet->setTitle('sortfalsecolpw');
$sheet->getCell('A1')->setValue(10);
$sheet->getCell('A2')->setValue(5);
$sheet->getCell('C1')->setValue(15);
$protection = $sheet->getProtection();
$protection->setPassword('testpassword');
$protection->setSheet(true);
$protection->setInsertRows(true);
$protection->setFormatCells(true);
$protection->setObjects(true);
$protection->setAutoFilter(false);
$protection->setSort(false);
$sheet->protectCells('A:A', 'sortpw', false, 'sortrange');
$reloadedSpreadsheet = $this->writeAndReload($spreadsheet, $type);
$spreadsheet->disconnectWorksheets();
self::assertCount(4, $reloadedSpreadsheet->getAllSheets());
$rsheet1 = $reloadedSpreadsheet->getSheetByNameOrThrow('sorttrue');
$protection = $rsheet1->getProtection();
self::assertNotEquals('', $protection->getPassword());
self::assertTrue($protection->getSort());
self::assertEmpty($rsheet1->getProtectedCellRanges());
$rsheet2 = $reloadedSpreadsheet->getSheetByNameOrThrow('sortfalse');
$protection = $rsheet2->getProtection();
self::assertNotEquals('', $protection->getPassword());
self::assertFalse($protection->getSort());
self::assertEmpty($rsheet2->getProtectedCellRanges());
$rsheet3 = $reloadedSpreadsheet->getSheetByNameOrThrow('sortfalsenocolpw');
$protection = $rsheet3->getProtection();
self::assertNotEquals('', $protection->getPassword());
self::assertFalse($protection->getSort());
$maxRow = ($type === 'Xlsx') ? 1048576 : 65536;
$testKey = "A1:A$maxRow";
$protectedCells = $rsheet3->getProtectedCellRanges();
self::assertCount(1, $protectedCells);
self::assertArrayHasKey($testKey, $protectedCells);
self::assertSame('', $protectedCells[$testKey]->getPassword());
$rsheet4 = $reloadedSpreadsheet->getSheetByNameOrThrow('sortfalsecolpw');
$protection = $rsheet4->getProtection();
self::assertNotEquals('', $protection->getPassword());
self::assertFalse($protection->getSort());
$maxRow = ($type === 'Xlsx') ? 1048576 : 65536;
$testKey = "A1:A$maxRow";
$protectedCells = $rsheet4->getProtectedCellRanges();
self::assertCount(1, $protectedCells);
self::assertArrayHasKey($testKey, $protectedCells);
self::assertNotEquals('', $protectedCells[$testKey]->getPassword());
if ($type === 'Xlsx') {
self::assertSame('sortrange', $protectedCells[$testKey]->getName());
}
$reloadedSpreadsheet->disconnectWorksheets();
}
public static function providerType(): array
{
return [
['Xlsx'],
['Xls'],
];
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Xlsx/StylesWriterTest.php | tests/PhpSpreadsheetTests/Writer/Xlsx/StylesWriterTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Xlsx;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Writer\Xlsx as XlsxWriter;
use PHPUnit\Framework\TestCase;
class StylesWriterTest extends TestCase
{
public function testStylesWriter(): void
{
$spreadsheet = new Spreadsheet();
$writer = new XlsxWriter($spreadsheet);
$writer->createStyleDictionaries();
$writerStyle = new XlsxWriter\Style($writer);
$data = $writerStyle->writeStyles($spreadsheet);
self::assertStringContainsString(
'<fonts count="1"><font><b val="0"/><i val="0"/><strike val="0"/><u val="none"/><sz val="11"/><color rgb="FF000000"/><name val="Calibri"/></font></fonts>',
$data
);
$spreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Xlsx/Issue4269Test.php | tests/PhpSpreadsheetTests/Writer/Xlsx/Issue4269Test.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Xlsx;
use PhpOffice\PhpSpreadsheet\Shared\File;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Writer\Xlsx as XlsxWriter;
use PHPUnit\Framework\Attributes\DataProvider;
use PHPUnit\Framework\TestCase;
class Issue4269Test extends TestCase
{
private string $outputFile = '';
private static bool $alwaysFalse = false;
protected function tearDown(): void
{
if ($this->outputFile !== '') {
unlink($this->outputFile);
$this->outputFile = '';
}
}
#[DataProvider('validationProvider')]
public function testWriteArrayFormulaTextJoin(
bool $preCalculateFormulas,
?bool $forceFullCalc,
string $expected
): void {
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->setCellValue('A1', '=A2*2');
$sheet->setCellValue('A2', 0);
$writer = new XlsxWriter($spreadsheet);
$writer->setForceFullCalc($forceFullCalc);
$this->outputFile = File::temporaryFilename();
if ($preCalculateFormulas) {
$writer->save($this->outputFile);
} else {
$writer->save($this->outputFile, XlsxWriter::DISABLE_PRECALCULATE_FORMULAE);
}
$spreadsheet->disconnectWorksheets();
$file = 'zip://';
$file .= $this->outputFile;
$file .= '#xl/workbook.xml';
$data = file_get_contents($file);
if ($data === false) {
self::fail('Unable to read file');
} else {
self::assertStringContainsString($expected, $data);
}
}
/** @return array<string, array<int, mixed>> */
public static function validationProvider(): array
{
return [
'normal case' => [true, null, 'calcMode="auto" calcCompleted="1" fullCalcOnLoad="0" forceFullCalc="0"'],
'issue 456' => [false, null, 'calcMode="auto" calcCompleted="0" fullCalcOnLoad="1" forceFullCalc="1"'],
'better choice for no precalc' => [false, false, 'calcMode="auto" calcCompleted="0" fullCalcOnLoad="1" forceFullCalc="0"'],
'unlikely use case' => [true, true, 'calcMode="auto" calcCompleted="1" fullCalcOnLoad="0" forceFullCalc="1"'],
];
}
public function testDefault(): void
{
self::assertSame(self::$alwaysFalse, XlsxWriter::DEFAULT_FORCE_FULL_CALC);
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Xlsx/Issue4179Test.php | tests/PhpSpreadsheetTests/Writer/Xlsx/Issue4179Test.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Xlsx;
use PhpOffice\PhpSpreadsheet\Shared\File;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Worksheet\Drawing;
use PhpOffice\PhpSpreadsheet\Writer\Xlsx as XlsxWriter;
use PHPUnit\Framework\TestCase;
use ZipArchive;
class Issue4179Test extends TestCase
{
private string $outputFile = '';
protected function tearDown(): void
{
if ($this->outputFile !== '') {
unlink($this->outputFile);
$this->outputFile = '';
}
}
public function testIssue4179(): void
{
// duplicate entry in ContentTypes
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$imageFile = 'tests/data/Writer/XLSX/backgroundtest.png';
$image = (string) file_get_contents($imageFile);
$sheet->setBackgroundImage($image);
$drawing = new Drawing();
$drawing->setName('Blue Square');
$drawing->setPath('tests/data/Writer/XLSX/blue_square.png');
$drawing->setCoordinates('A1');
$drawing->setWorksheet($sheet);
$writer = new XlsxWriter($spreadsheet);
$this->outputFile = File::temporaryFilename();
$writer->save($this->outputFile);
$spreadsheet->disconnectWorksheets();
$zip = new ZipArchive();
$open = $zip->open($this->outputFile, ZipArchive::RDONLY);
$pngCount = 0;
if ($open !== true) {
self::fail("zip open failed for {$this->outputFile}");
} else {
$contents = (string) $zip->getFromName('[Content_Types].xml');
$subCount = substr_count($contents, '"png"');
self::assertSame(1, $subCount);
for ($i = 0; $i < $zip->numFiles; ++$i) {
$filename = (string) $zip->getNameIndex($i);
if (preg_match('~^xl/media/\w+[.]png$~', $filename) === 1) {
++$pngCount;
}
}
}
self::assertSame(2, $pngCount);
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Xlsx/Issue4542Test.php | tests/PhpSpreadsheetTests/Writer/Xlsx/Issue4542Test.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Xlsx;
use PhpOffice\PhpSpreadsheet\Cell\DataType;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Worksheet\Table;
use PhpOffice\PhpSpreadsheet\Writer\Xlsx as XlsxWriter;
use PHPUnit\Framework\TestCase;
class Issue4542Test extends TestCase
{
public function testXmlSpace(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$string = ' Ye&ar ';
$trimString = trim($string);
$sheet->getCell('A1')->setValue($string);
$sheet->getCell('A2')->setValueExplicit($string, DataType::TYPE_INLINE);
$sheet->getCell('B1')->setValue($trimString);
$sheet->getCell('B2')->setValueExplicit($trimString, DataType::TYPE_INLINE);
$writer = new XlsxWriter($spreadsheet);
$writer->createStyleDictionaries();
$writerStyle = new XlsxWriter\Style($writer);
$data = $writerStyle->writeStyles($spreadsheet);
self::assertStringContainsString(
'<styleSheet',
$data
);
self::assertStringNotContainsString(
'xml:space',
$data
);
$writerWorkbook = new XlsxWriter\Workbook($writer);
$data = $writerWorkbook->writeWorkbook($spreadsheet);
self::assertStringContainsString(
'<workbook',
$data
);
self::assertStringNotContainsString(
'xml:space',
$data
);
$stringTable = $writer->createStringTable();
$writerStringTable = new XlsxWriter\StringTable($writer);
$data = $writerStringTable->writeStringTable($stringTable);
self::assertStringContainsString(
'<si><t xml:space="preserve"> Ye&ar </t></si>',
$data
);
self::assertStringContainsString(
'<si><t>Ye&ar</t></si>',
$data
);
$writerWorksheet = new XlsxWriter\Worksheet($writer);
$data = $writerWorksheet->writeWorksheet($sheet, []);
self::assertStringContainsString(
'<c r="A2" t="inlineStr"><is><t xml:space="preserve"> Ye&ar </t></is></c>',
$data
);
self::assertStringContainsString(
'<c r="B2" t="inlineStr"><is><t>Ye&ar</t></is></c>',
$data
);
$spreadsheet->disconnectWorksheets();
}
public function testTable(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->fromArray(
[
['MyCol', 'Colonne2', 'Colonne3'],
[10, 20],
[2],
[3],
[4],
],
null,
'B1',
true
);
$table = new Table('B1:D5', 'Tableau1');
$sheet->addTable($table);
$writer = new XlsxWriter($spreadsheet);
$writerTable = new XlsxWriter\Table($writer);
$data = $writerTable->writeTable($table, 1);
self::assertStringContainsString(
'<table ',
$data
);
self::assertStringNotContainsString(
'xml:space',
$data
);
$spreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Xlsx/ArrayFormulaPrefixTest.php | tests/PhpSpreadsheetTests/Writer/Xlsx/ArrayFormulaPrefixTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Xlsx;
use PhpOffice\PhpSpreadsheet\Cell\DataType;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Writer\Xlsx;
use PhpOffice\PhpSpreadsheetTests\Functional\AbstractFunctional;
class ArrayFormulaPrefixTest extends AbstractFunctional
{
/**
* Test to ensure that xlfn prefix is being added to functions
* included in an array formula, if appropriate.
*
* @throws \PhpOffice\PhpSpreadsheet\Exception
*/
public function testWriteArrayFormulaTextJoin(): void
{
$spreadsheet = new Spreadsheet();
$worksheet = $spreadsheet->getActiveSheet();
//Write data
$worksheet->getCell('A1')->setValue('Some Text');
$worksheet->getCell('A2')->setValue('Some More Text');
$worksheet->getCell('A3')->setValue(14.56);
$worksheet->getCell('A4')->setValue(17.24);
$worksheet->getCell('A5')->setValue(9.4);
$worksheet->getCell('A6')->setValue(5);
//Write formula
$cell = $worksheet->getCell('A7');
$cell->setValueExplicit('=TEXTJOIN("",TRUE,IF(ISNUMBER(A1:A6), A1:A6,""))', DataType::TYPE_FORMULA);
/** @var array<string, string> */
$attrs = $cell->getFormulaAttributes();
$attrs['t'] = 'array';
$cell->setFormulaAttributes($attrs);
$writer = new Xlsx($spreadsheet);
$writerWorksheet = new Xlsx\Worksheet($writer);
$data = $writerWorksheet->writeWorksheet($worksheet, []);
$expected = <<<XML
<f t="array" ref="A7" aca="1" ca="1">_xlfn.TEXTJOIN("",TRUE,IF(ISNUMBER(A1:A6), A1:A6,""))</f>
XML;
self::assertStringContainsString($expected, $data);
}
/**
* Certain functions do not have the xlfn prefix applied. Test an array formula
* that includes those functions to see if they are written properly.
*
* @throws \PhpOffice\PhpSpreadsheet\Exception
*/
public function testWriteArrayFormulaWithoutPrefix(): void
{
$spreadsheet = new Spreadsheet();
$worksheet = $spreadsheet->getActiveSheet();
//Write data
$worksheet->getCell('A1')->setValue('orange');
$worksheet->getCell('A2')->setValue('green');
$worksheet->getCell('A3')->setValue('blue');
$worksheet->getCell('A4')->setValue('yellow');
$worksheet->getCell('A5')->setValue('pink');
$worksheet->getCell('A6')->setValue('red');
//Write formula
$cell = $worksheet->getCell('A7');
$cell->setValueExplicit('=SUM(LEN(A1:A6))', DataType::TYPE_FORMULA);
/** @var array<string, string> */
$attrs = $cell->getFormulaAttributes();
$attrs['t'] = 'array';
$cell->setFormulaAttributes($attrs);
$writer = new Xlsx($spreadsheet);
$writerWorksheet = new Xlsx\Worksheet($writer);
$data = $writerWorksheet->writeWorksheet($worksheet, []);
$expected = <<<XML
<f t="array" ref="A7" aca="1" ca="1">SUM(LEN(A1:A6))</f>
XML;
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/Writer/Xlsx/RichTextTest.php | tests/PhpSpreadsheetTests/Writer/Xlsx/RichTextTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Xlsx;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx as XlsxReader;
use PhpOffice\PhpSpreadsheet\RichText\RichText;
use PhpOffice\PhpSpreadsheet\Shared\File;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Writer\Xlsx as XlsxWriter;
use PHPUnit\Framework\TestCase;
class RichTextTest extends TestCase
{
private string $filename = '';
protected function teardown(): void
{
if ($this->filename !== '') {
unlink($this->filename);
}
}
public function testRichText(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$rtf = new RichText();
$rtf->createText('~Cell Style~');
$rtf->createTextRun('~RTF Style~')->getFont()?->setItalic(true);
$rtf->createText('~No Style~');
$sheet->getCell('A1')->setValue($rtf);
$sheet->getStyle('A1')->getFont()->setBold(true);
$fontStyle = $sheet->getStyle('A1')->getFont();
self::assertTrue($fontStyle->getBold());
self::assertFalse($fontStyle->getItalic());
$a1Value = $sheet->getCell('A1')->getValue();
self::assertInstanceOf(RichText::class, $a1Value);
$elements = $a1Value->getRichTextElements();
self::assertCount(3, $elements);
self::assertNull($elements[0]->getFont());
$fontStyle = $elements[1]->getFont();
self::assertNotNull($fontStyle);
self::assertFalse($fontStyle->getBold());
self::assertTrue($fontStyle->getItalic());
self::assertNull($elements[0]->getFont());
$this->filename = File::temporaryFilename();
$writer = new XlsxWriter($spreadsheet);
$writer->save($this->filename);
$spreadsheet->disconnectWorksheets();
$this->readfile();
}
private function readfile(): void
{
$reader = new XlsxReader();
$spreadsheet = $reader->load($this->filename);
$sheet = $spreadsheet->getActiveSheet();
$fontStyle = $sheet->getStyle('A1')->getFont();
self::assertTrue($fontStyle->getBold());
self::assertFalse($fontStyle->getItalic());
$a1Value = $sheet->getCell('A1')->getValue();
self::assertInstanceOf(RichText::class, $a1Value);
$elements = $a1Value->getRichTextElements();
self::assertCount(3, $elements);
// write/read has changed text to run but no real difference
$fontStyle = $elements[0]->getFont();
self::assertNotNull($fontStyle);
self::assertTrue($fontStyle->getBold());
self::assertFalse($fontStyle->getItalic());
$fontStyle = $elements[1]->getFont();
self::assertNotNull($fontStyle);
self::assertFalse($fontStyle->getBold());
self::assertTrue($fontStyle->getItalic());
// write/read has changed text to run but no real difference
$fontStyle = $elements[2]->getFont();
self::assertNotNull($fontStyle);
self::assertTrue($fontStyle->getBold());
self::assertFalse($fontStyle->getItalic());
$spreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Xlsx/FunctionPrefixTest.php | tests/PhpSpreadsheetTests/Writer/Xlsx/FunctionPrefixTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Xlsx;
use PhpOffice\PhpSpreadsheet\Writer\Xlsx\FunctionPrefix;
use PHPUnit\Framework\Attributes\DataProvider;
use PHPUnit\Framework\TestCase;
class FunctionPrefixTest extends TestCase
{
#[DataProvider('functionPrefixProvider')]
public function testFunctionPrefix(string $expectedResult, string $functionString): void
{
$result = FunctionPrefix::addFunctionPrefix($functionString);
self::assertSame($expectedResult, $result);
$result = FunctionPrefix::addFunctionPrefixStripEquals("=$functionString");
self::assertSame($expectedResult, $result);
}
/** @return array<string, array<int, string>> */
public static function functionPrefixProvider(): array
{
return [
'Basic Legacy Function' => ['SUM()', 'SUM()'],
'New Function without Prefix' => ['_xlfn.ARABIC()', 'ARABIC()'],
'New Function already Prefixed' => ['_xlfn.ARABIC()', '_xlfn.ARABIC()'],
'New Function requiring Double-Prefix' => ['_xlfn._xlws.FILTER()', 'FILTER()'],
'New Function requiring Double-Prefix already partially Prefixed' => ['_xlfn._xlws.FILTER()', '_xlfn.FILTER()'],
'New Function requiring Double-Prefix already partially Prefixed #2' => ['_xlfn._xlws.FILTER()', '_xlws.FILTER()'],
'New Function requiring Double-Prefix already Fully Prefixed' => ['_xlfn._xlws.FILTER()', '_xlfn._xlws.FILTER()'],
'Multiple Functions' => ['_xlfn._xlws.SORT(_xlfn._xlws.FILTER(A:A, A:A<>""))', 'SORT(FILTER(A:A, A:A<>""))'],
'DAYS/NETWORKDAYS 1' => ['_xlfn.DAYS(DATE(2023,1,1),TODAY())', 'DAYS(DATE(2023,1,1),TODAY())'],
'DAYS/NETWORKDAYS 2' => ['_xlfn.DAYS(DATE(2023,1,1),TODAY())', '_xlfn.DAYS(DATE(2023,1,1),TODAY())'],
'DAYS/NETWORKDAYS 3' => ['ABS(_xlfn.DAYS(DATE(2023,1,1),TODAY()))', 'ABS(DAYS(DATE(2023,1,1),TODAY()))'],
'DAYS/NETWORKDAYS 4' => ['ABS(_xlfn.DAYS(DATE(2023,1,1),TODAY()))', 'ABS(_xlfn.DAYS(DATE(2023,1,1),TODAY()))'],
'DAYS/NETWORKDAYS 5' => ['NETWORKDAYS(DATE(2023,1,1),TODAY(), C:C)', 'NETWORKDAYS(DATE(2023,1,1),TODAY(), C:C)'],
'COUNTIFS reclassified as Legacy' => ['COUNTIFS()', 'COUNTIFS()'],
'SUMIFS reclassified as Legacy' => ['SUMIFS()', 'SUMIFS()'],
'BASE improperly classified by MS' => ['_xlfn.BASE()', 'BASE()'],
];
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Xlsx/Calendar1904Test.php | tests/PhpSpreadsheetTests/Writer/Xlsx/Calendar1904Test.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Xlsx;
use PhpOffice\PhpSpreadsheet\Shared\Date;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheetTests\Functional\AbstractFunctional;
class Calendar1904Test extends AbstractFunctional
{
public function testCalendar1904(): void
{
$spreadsheet = new Spreadsheet();
$spreadsheet->setExcelCalendar(Date::CALENDAR_MAC_1904);
$worksheet = $spreadsheet->getActiveSheet();
$worksheet->getCell('A1')->setValue('=DATE(1904,1,1)');
$worksheet->getStyle('A1')->getNumberFormat()
->setFormatCode('yyyy-mm-dd');
$reloadedSpreadsheet = $this->writeAndReload($spreadsheet, 'Xlsx');
$spreadsheet->disconnectWorksheets();
$rsheet = $reloadedSpreadsheet->getActiveSheet();
self::assertSame(0.0, $rsheet->getCell('A1')->getCalculatedValue());
self::assertSame('1904-01-01', $rsheet->getCell('A1')->getFormattedValue());
self::assertSame(Date::CALENDAR_MAC_1904, $reloadedSpreadsheet->getExcelCalendar());
$reloadedSpreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Xlsx/MicrosecondsTest.php | tests/PhpSpreadsheetTests/Writer/Xlsx/MicrosecondsTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Xlsx;
use DateTime;
use PhpOffice\PhpSpreadsheet\Shared\Date;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheetTests\Functional\AbstractFunctional;
class MicrosecondsTest extends AbstractFunctional
{
/**
* Test save and load XLSX file for round-trip DateTime.
*/
public function testIssue4476(): void
{
$date = '2020-10-21';
$time = '14:55:31';
$originalDateTime = new DateTime("{$date}T{$time}");
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->setCellValue('A1', Date::dateTimeToExcel($originalDateTime));
$sheet->getStyle('A1')
->getNumberFormat()
->setFormatCode('yyyy-mm-dd hh:mm:ss.000');
$reloadedSpreadsheet = $this->writeAndReload($spreadsheet, 'Xlsx');
$spreadsheet->disconnectWorksheets();
$rsheet = $reloadedSpreadsheet->getActiveSheet();
/** @var float */
$reread = $rsheet->getCell('A1')->getValue();
$temp = Date::excelToDateTimeObject($reread)
->format('Y-m-d H:i:s.u');
self::assertSame("{$date} {$time}.000000", $temp, 'round trip works with float value');
$formatted = $rsheet->getCell('A1')->getFormattedValue();
self::assertSame("{$date} {$time}.000", $formatted, 'round trip works with formatted value');
/** @var float */
$temp = Date::stringToExcel($formatted);
$temp = Date::excelToDateTimeObject($temp)
->format('Y-m-d H:i:s.u');
self::assertSame("{$date} {$time}.000000", $temp, 'round trip works using stringToExcel on formatted value');
$reloadedSpreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Xlsx/VisibilityTest.php | tests/PhpSpreadsheetTests/Writer/Xlsx/VisibilityTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Xlsx;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Worksheet\Worksheet;
use PhpOffice\PhpSpreadsheetTests\Functional\AbstractFunctional;
use PHPUnit\Framework\Attributes\DataProvider;
class VisibilityTest extends AbstractFunctional
{
/** @param array<int, bool> $visibleRows */
#[DataProvider('dataProviderRowVisibility')]
public function testRowVisibility(array $visibleRows): void
{
$spreadsheet = new Spreadsheet();
$worksheet = $spreadsheet->getActiveSheet();
foreach ($visibleRows as $row => $visibility) {
$worksheet->setCellValue("A{$row}", $row);
$worksheet->getRowDimension($row)->setVisible($visibility);
}
$reloadedSpreadsheet = $this->writeAndReload($spreadsheet, 'Xlsx');
$reloadedWorksheet = $reloadedSpreadsheet->getActiveSheet();
foreach ($visibleRows as $row => $visibility) {
self::assertSame($visibility, $reloadedWorksheet->getRowDimension($row)->getVisible());
}
}
/** @return array<int, array<int, array<int, bool>>> */
public static function dataProviderRowVisibility(): array
{
return [
[
[1 => false, 2 => false, 3 => true, 4 => false, 5 => true, 6 => false],
],
];
}
/** @param array<string, bool> $visibleColumns */
#[DataProvider('dataProviderColumnVisibility')]
public function testColumnVisibility(array $visibleColumns): void
{
$spreadsheet = new Spreadsheet();
$worksheet = $spreadsheet->getActiveSheet();
foreach ($visibleColumns as $column => $visibility) {
$worksheet->setCellValue("{$column}1", $column);
$worksheet->getColumnDimension($column)->setVisible($visibility);
}
$reloadedSpreadsheet = $this->writeAndReload($spreadsheet, 'Xlsx');
$reloadedWorksheet = $reloadedSpreadsheet->getActiveSheet();
foreach ($visibleColumns as $column => $visibility) {
self::assertSame($visibility, $reloadedWorksheet->getColumnDimension($column)->getVisible());
}
}
/** @return array<int, array<int, array<string, bool>>> */
public static function dataProviderColumnVisibility(): array
{
return [
[
['A' => false, 'B' => false, 'C' => true, 'D' => false, 'E' => true, 'F' => false],
],
];
}
/** @param array<string, string> $visibleSheets */
#[DataProvider('dataProviderSheetVisibility')]
public function testSheetVisibility(array $visibleSheets): void
{
$spreadsheet = new Spreadsheet();
$spreadsheet->removeSheetByIndex(0);
foreach ($visibleSheets as $sheetName => $visibility) {
$worksheet = $spreadsheet->addSheet(new Worksheet($spreadsheet, $sheetName));
$worksheet->setCellValue('A1', $sheetName);
$worksheet->setSheetState($visibility);
}
$reloadedSpreadsheet = $this->writeAndReload($spreadsheet, 'Xlsx');
foreach ($visibleSheets as $sheetName => $visibility) {
$reloadedWorksheet = $reloadedSpreadsheet->getSheetByNameOrThrow($sheetName);
self::assertSame($visibility, $reloadedWorksheet->getSheetState());
}
}
/** @return array<int, array<int, array<string, string>>> */
public static function dataProviderSheetVisibility(): array
{
return [
[
[
'Worksheet 1' => Worksheet::SHEETSTATE_HIDDEN,
'Worksheet 2' => Worksheet::SHEETSTATE_VERYHIDDEN,
'Worksheet 3' => Worksheet::SHEETSTATE_VISIBLE,
],
],
];
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Xlsx/LocaleFloatsTest.php | tests/PhpSpreadsheetTests/Writer/Xlsx/LocaleFloatsTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Xlsx;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx as XlsxReader;
use PhpOffice\PhpSpreadsheet\Settings;
use PhpOffice\PhpSpreadsheet\Shared\StringHelper;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Style\NumberFormat;
use PhpOffice\PhpSpreadsheetTests\Functional\AbstractFunctional;
class LocaleFloatsTest extends AbstractFunctional
{
private false|string $currentPhpLocale;
private string $originalLocale;
private ?Spreadsheet $spreadsheet = null;
private ?Spreadsheet $reloadedSpreadsheet = null;
protected function setUp(): void
{
$this->currentPhpLocale = setlocale(LC_ALL, '0');
$this->originalLocale = Settings::getLocale();
StringHelper::setDecimalSeparator(null);
StringHelper::setThousandsSeparator(null);
}
protected function tearDown(): void
{
StringHelper::setDecimalSeparator(null);
StringHelper::setThousandsSeparator(null);
Settings::setLocale($this->originalLocale);
if ($this->currentPhpLocale !== false) {
setlocale(LC_ALL, $this->currentPhpLocale);
}
if ($this->spreadsheet !== null) {
$this->spreadsheet->disconnectWorksheets();
$this->spreadsheet = null;
}
if ($this->reloadedSpreadsheet !== null) {
$this->reloadedSpreadsheet->disconnectWorksheets();
$this->reloadedSpreadsheet = null;
}
}
public function testLocaleFloatsCorrectlyConvertedByWriter(): void
{
if (!setlocale(LC_ALL, 'fr_FR.UTF-8', 'fra_fra.utf8')) {
self::markTestSkipped('Unable to set locale for testing.');
}
$localeconv = localeconv();
$decimalSeparator = $localeconv['decimal_point'];
self::assertIsString($decimalSeparator);
self::assertNotEquals('.', $decimalSeparator, 'unexpected change to French decimal separator');
$this->spreadsheet = $spreadsheet = new Spreadsheet();
$properties = $spreadsheet->getProperties();
$properties->setCustomProperty('Version', 1.2);
$spreadsheet->getActiveSheet()->setCellValue('A1', 1.1);
$this->reloadedSpreadsheet = $reloadedSpreadsheet = $this->writeAndReload($spreadsheet, 'Xlsx');
$result = $reloadedSpreadsheet->getActiveSheet()->getCell('A1')->getValue();
self::assertEqualsWithDelta(1.1, $result, 1.0E-8);
$prop = $reloadedSpreadsheet->getProperties()->getCustomPropertyValue('Version');
self::assertEqualsWithDelta(1.2, $prop, 1.0E-8);
$actual = $reloadedSpreadsheet->getActiveSheet()->getCell('A1')->getFormattedValue();
self::assertStringContainsString("1{$decimalSeparator}1", $actual);
}
public function testPercentageStoredAsString(): void
{
Settings::setLocale('fr_FR');
StringHelper::setDecimalSeparator(',');
StringHelper::setThousandsSeparator('.');
$reader = new XlsxReader();
$this->spreadsheet = $spreadsheet = $reader->load('tests/data/Writer/XLSX/issue.3811b.xlsx');
$sheet = $spreadsheet->getActiveSheet();
self::assertSame('48,34%', $sheet->getCell('L2')->getValue());
self::assertSame('=(10%+L2)/2', $sheet->getCell('L1')->getValue());
self::assertEqualsWithDelta(0.2917, $sheet->getCell('L1')->getCalculatedValue(), 1E-8);
self::assertIsFloat($sheet->getCell('L1')->getCalculatedValue());
self::assertEquals('29,17%', $sheet->getCell('L1')->getFormattedValue());
$sheet->getCell('A10')->setValue(3.2);
self::assertSame(NumberFormat::FORMAT_GENERAL, $sheet->getStyle('A10')->getNumberFormat()->getFormatCode());
self::assertSame('3,2', $sheet->getCell('A10')->getFormattedValue());
$sheet->getCell('A11')->setValue(1002.5);
$sheet->getStyle('A11')->getNumberFormat()->setFormatCode(NumberFormat::FORMAT_NUMBER_COMMA_SEPARATED1);
self::assertSame('1.002,50', $sheet->getCell('A11')->getFormattedValue());
$sheet->getCell('A12')->setValue(2.5);
$sheet->getStyle('A12')->getNumberFormat()->setFormatCode(NumberFormat::FORMAT_NUMBER_00);
self::assertSame('2,50', $sheet->getCell('A12')->getFormattedValue());
}
public function testPercentageStoredAsString2(): void
{
if (!setlocale(LC_ALL, 'fr_FR.UTF-8', 'fra_fra.utf8')) {
self::markTestSkipped('Unable to set locale for testing.');
}
$localeconv = localeconv();
$thousandsSeparator = $localeconv['thousands_sep'];
$decimalSeparator = $localeconv['decimal_point'];
self::assertIsString($decimalSeparator);
self::assertIsString($thousandsSeparator);
self::assertNotEquals('.', $decimalSeparator, 'unexpected change to French decimal separator');
self::assertNotEquals(',', $thousandsSeparator, 'unexpected change to French thousands separator');
$reader = new XlsxReader();
$this->spreadsheet = $spreadsheet = $reader->load('tests/data/Writer/XLSX/issue.3811b.xlsx');
$sheet = $spreadsheet->getActiveSheet();
self::assertSame('48,34%', $sheet->getCell('L2')->getValue());
self::assertSame('=(10%+L2)/2', $sheet->getCell('L1')->getValue());
self::assertEqualsWithDelta(0.2917, $sheet->getCell('L1')->getCalculatedValue(), 1E-8);
self::assertIsFloat($sheet->getCell('L1')->getCalculatedValue());
self::assertSame("29{$decimalSeparator}17%", $sheet->getCell('L1')->getFormattedValue());
$sheet->getCell('A10')->setValue(3.2);
self::assertSame(NumberFormat::FORMAT_GENERAL, $sheet->getStyle('A10')->getNumberFormat()->getFormatCode());
self::assertSame("3{$decimalSeparator}2", $sheet->getCell('A10')->getFormattedValue());
$sheet->getCell('A11')->setValue(1002.5);
$sheet->getStyle('A11')->getNumberFormat()->setFormatCode(NumberFormat::FORMAT_NUMBER_COMMA_SEPARATED1);
self::assertSame("1{$thousandsSeparator}002{$decimalSeparator}50", $sheet->getCell('A11')->getFormattedValue());
$sheet->getCell('A12')->setValue(2.5);
$sheet->getStyle('A12')->getNumberFormat()->setFormatCode(NumberFormat::FORMAT_NUMBER_00);
self::assertSame("2{$decimalSeparator}50", $sheet->getCell('A12')->getFormattedValue());
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Xlsx/Unparsed2396Test.php | tests/PhpSpreadsheetTests/Writer/Xlsx/Unparsed2396Test.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Xlsx;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx as Reader;
use PhpOffice\PhpSpreadsheet\Shared\File;
use PhpOffice\PhpSpreadsheet\Worksheet\BaseDrawing;
use PhpOffice\PhpSpreadsheet\Worksheet\Drawing;
use PhpOffice\PhpSpreadsheet\Writer\Xlsx as Writer;
use PHPUnit\Framework\TestCase;
class Unparsed2396Test extends TestCase
{
private string $filename = '';
protected function tearDown(): void
{
if ($this->filename !== '') {
unlink($this->filename);
$this->filename = '';
}
}
private function getContents(?BaseDrawing $drawing): string
{
$contents = '';
if ($drawing instanceof Drawing) {
$contents = (string) file_get_contents($drawing->getPath());
} else {
self::fail('Unexpected null or baseDrawing which is not Drawing');
}
self::assertNotSame('', $contents);
return $contents;
}
// Don't drop image as in issue 2396.
public function testUnparsed2396(): void
{
$sampleFilename = 'tests/data/Writer/XLSX/issue.2396.xlsx';
$reader = new Reader();
$excel = $reader->load($sampleFilename);
$outputFilename = $this->filename = File::temporaryFilename();
$writer = new Writer($excel);
$writer->save($outputFilename);
//$spreadsheet = $this->writeAndReload($excel, 'Xlsx');
$excel->disconnectWorksheets();
$reader = new Reader();
$spreadsheet = $reader->load($outputFilename);
$sheet = $spreadsheet->getSheet(0);
$drawing1 = $sheet->getDrawingCollection();
self::assertCount(1, $drawing1);
$hash = $this->getContents($drawing1[0]);
$sheet = $spreadsheet->getSheet(1);
$drawings = $sheet->getDrawingCollection();
self::assertCount(1, $drawings);
self::assertSame($hash, $this->getContents($drawings[0]));
$sheet = $spreadsheet->getSheet(2);
$drawings = $sheet->getDrawingCollection();
self::assertCount(0, $drawings);
//self::assertSame($hash, md5(file_get_contents($drawings[0]->getPath())));
$sheet = $spreadsheet->getSheet(3);
$drawings = $sheet->getDrawingCollection();
self::assertCount(1, $drawings);
self::assertSame($hash, $this->getContents($drawings[0]));
$sheet = $spreadsheet->getSheet(4);
$drawings = $sheet->getDrawingCollection();
self::assertCount(0, $drawings);
//self::assertSame($hash, md5(file_get_contents($drawings[0]->getPath())));
// The next 2 sheets have 'legacyDrawing', button, and listbox.
// If support is added for those, these tests may need adjustment.
$sheet = $spreadsheet->getSheet(5);
$drawings = $sheet->getDrawingCollection();
self::assertCount(0, $drawings);
//self::assertSame($hash, md5(file_get_contents($drawings[0]->getPath())));
$sheet = $spreadsheet->getSheet(6);
$drawings = $sheet->getDrawingCollection();
self::assertCount(1, $drawings);
self::assertSame($hash, $this->getContents($drawings[0]));
$spreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Xlsx/DrawingsTest.php | tests/PhpSpreadsheetTests/Writer/Xlsx/DrawingsTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Xlsx;
use PhpOffice\PhpSpreadsheet\Comment;
use PhpOffice\PhpSpreadsheet\Exception as PhpSpreadsheetException;
use PhpOffice\PhpSpreadsheet\IOFactory;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\Shared\File;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Worksheet\BaseDrawing;
use PhpOffice\PhpSpreadsheet\Worksheet\Drawing;
use PhpOffice\PhpSpreadsheet\Worksheet\MemoryDrawing;
use PhpOffice\PhpSpreadsheetTests\Functional\AbstractFunctional;
class DrawingsTest extends AbstractFunctional
{
/**
* Test save and load XLSX file with drawing on 2nd worksheet.
*/
public function testSaveLoadWithDrawingOn2ndWorksheet(): void
{
// Read spreadsheet from file
$inputFilename = 'tests/data/Writer/XLSX/drawing_on_2nd_page.xlsx';
$reader = new Xlsx();
$spreadsheet = $reader->load($inputFilename);
// Save spreadsheet to file and read it back
$reloadedSpreadsheet = $this->writeAndReload($spreadsheet, 'Xlsx');
$spreadsheet->disconnectWorksheets();
self::assertNotNull(
$reloadedSpreadsheet->getSheetByName('Sheet1 (2)')
);
$reloadedSpreadsheet->disconnectWorksheets();
}
/**
* Test save and load XLSX file with drawing with the same file name.
*/
public function testSaveLoadWithDrawingWithSamePath(): void
{
// Read spreadsheet from file
$originalFileName = 'tests/data/Writer/XLSX/saving_drawing_with_same_path.xlsx';
$originalFile = file_get_contents($originalFileName);
$tempFileName = File::sysGetTempDir() . '/saving_drawing_with_same_path';
file_put_contents($tempFileName, $originalFile);
$reader = new Xlsx();
$spreadsheet = $reader->load($tempFileName);
$spreadsheet->getActiveSheet()->setCellValue('D5', 'foo');
// Save spreadsheet to file to the same path. Success test case won't
// throw exception here
$writer = IOFactory::createWriter($spreadsheet, 'Xlsx');
$writer->save($tempFileName);
$reloadedSpreadsheet = $reader->load($tempFileName);
unlink($tempFileName);
$spreadsheet->disconnectWorksheets();
self::assertNotNull(
$reloadedSpreadsheet->getSheetByName('Worksheet')
);
$reloadedSpreadsheet->disconnectWorksheets();
}
/**
* Test save and load XLSX file with drawing in comment.
*/
public function testSaveLoadWithDrawingInComment(): void
{
// Read spreadsheet from file
$originalFileName = 'tests/data/Writer/XLSX/drawing_in_comment.xlsx';
$originalFile = file_get_contents($originalFileName);
$tempFileName = File::sysGetTempDir() . '/drawing_in_comment.xlsx';
file_put_contents($tempFileName, $originalFile);
// Load native xlsx file with drawing in comment background
$reader = new Xlsx();
$spreadsheet = $reader->load($tempFileName);
$sheet = $spreadsheet->getActiveSheet();
$comment = $sheet->getComment('A1');
self::assertTrue($comment->hasBackgroundImage());
self::assertEquals($comment->getBackgroundImage()->getWidth(), 178);
self::assertEquals($comment->getBackgroundImage()->getHeight(), 140);
self::assertEquals($comment->getBackgroundImage()->getType(), IMAGETYPE_JPEG);
$writer = IOFactory::createWriter($spreadsheet, 'Xlsx');
$writer->save($tempFileName);
$reloadedSpreadsheet = $reader->load($tempFileName);
unlink($tempFileName);
$spreadsheet->disconnectWorksheets();
$reloadedSpreadsheet->disconnectWorksheets();
}
/**
* Test save and load XLSX file with drawing in comment, image in BMP/GIF format saved as PNG.
*/
public function testDrawingInCommentImageFormatsConversions(): void
{
$reader = new Xlsx();
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
// Add gif image to comment background
$sheet->setCellValue('A1', '.gif');
$drawing = new Drawing();
$drawing->setName('Green Square');
$drawing->setPath('tests/data/Writer/XLSX/green_square.gif');
self::assertEquals($drawing->getWidth(), 150);
self::assertEquals($drawing->getHeight(), 150);
$comment = $sheet->getComment('A1');
$comment->setBackgroundImage($drawing);
$comment->setSizeAsBackgroundImage();
self::assertEquals($comment->getWidth(), '112.5pt');
self::assertEquals($comment->getHeight(), '112.5pt');
self::assertTrue($comment->hasBackgroundImage());
self::assertEquals($comment->getBackgroundImage()->getType(), IMAGETYPE_GIF);
// Add bmp image to comment background
$sheet->setCellValue('A2', '.bmp 16 colors');
$drawing = new Drawing();
$drawing->setName('Yellow Square');
$drawing->setPath('tests/data/Writer/XLSX/yellow_square_16.bmp');
self::assertEquals($drawing->getWidth(), 70);
self::assertEquals($drawing->getHeight(), 70);
$comment = $sheet->getComment('A2');
$comment->setBackgroundImage($drawing);
$comment->setSizeAsBackgroundImage();
self::assertEquals($comment->getWidth(), '52.5pt');
self::assertEquals($comment->getHeight(), '52.5pt');
self::assertTrue($comment->hasBackgroundImage());
self::assertEquals($comment->getBackgroundImage()->getType(), IMAGETYPE_BMP);
// Write file
$writer = IOFactory::createWriter($spreadsheet, 'Xlsx');
$tempFileName = File::sysGetTempDir() . '/drawings_in_comments_conversions.xlsx';
$writer->save($tempFileName);
// Read new file
$reloadedSpreadsheet = $reader->load($tempFileName);
$sheet = $reloadedSpreadsheet->getActiveSheet();
// Check first image in comment background
$comment = $sheet->getComment('A1');
self::assertEquals($comment->getWidth(), '112.5pt');
self::assertEquals($comment->getHeight(), '112.5pt');
self::assertTrue($comment->hasBackgroundImage());
self::assertEquals($comment->getBackgroundImage()->getWidth(), 150);
self::assertEquals($comment->getBackgroundImage()->getHeight(), 150);
self::assertEquals($comment->getBackgroundImage()->getType(), IMAGETYPE_PNG);
// Check second image in comment background
$comment = $sheet->getComment('A2');
self::assertEquals($comment->getWidth(), '52.5pt');
self::assertEquals($comment->getHeight(), '52.5pt');
self::assertTrue($comment->hasBackgroundImage());
self::assertEquals($comment->getBackgroundImage()->getWidth(), 70);
self::assertEquals($comment->getBackgroundImage()->getHeight(), 70);
self::assertEquals($comment->getBackgroundImage()->getType(), IMAGETYPE_PNG);
unlink($tempFileName);
$spreadsheet->disconnectWorksheets();
$reloadedSpreadsheet->disconnectWorksheets();
}
/**
* Test build and save XLSX with drawings in comments with comment size correction.
*/
public function testBuildWithDifferentImageFormats(): void
{
$reader = new Xlsx();
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
// Add png image to comment background
$sheet->setCellValue('A1', '.png');
$drawing = new Drawing();
$drawing->setName('Blue Square');
$drawing->setPath('tests/data/Writer/XLSX/blue_square.png');
self::assertEquals($drawing->getWidth(), 100);
self::assertEquals($drawing->getHeight(), 100);
$comment = $sheet->getComment('A1');
$comment->setBackgroundImage($drawing);
$comment->setSizeAsBackgroundImage();
self::assertEquals($comment->getWidth(), '75pt');
self::assertEquals($comment->getHeight(), '75pt');
$comment = $sheet->getComment('A1');
self::assertTrue($comment->hasBackgroundImage());
self::assertEquals($comment->getBackgroundImage()->getType(), IMAGETYPE_PNG);
// Add gif image to comment background
$sheet->setCellValue('A2', '.gif');
$drawing = new Drawing();
$drawing->setName('Green Square');
$drawing->setPath('tests/data/Writer/XLSX/green_square.gif');
self::assertEquals($drawing->getWidth(), 150);
self::assertEquals($drawing->getHeight(), 150);
$comment = $sheet->getComment('A2');
$comment->setBackgroundImage($drawing);
$comment->setSizeAsBackgroundImage();
self::assertEquals($comment->getWidth(), '112.5pt');
self::assertEquals($comment->getHeight(), '112.5pt');
$comment = $sheet->getComment('A2');
self::assertTrue($comment->hasBackgroundImage());
self::assertEquals($comment->getBackgroundImage()->getType(), IMAGETYPE_GIF);
// Add jpeg image to comment background
$sheet->setCellValue('A3', '.jpeg');
$drawing = new Drawing();
$drawing->setName('Red Square');
$drawing->setPath('tests/data/Writer/XLSX/red_square.jpeg');
self::assertEquals($drawing->getWidth(), 50);
self::assertEquals($drawing->getHeight(), 50);
$comment = $sheet->getComment('A3');
$comment->setBackgroundImage($drawing);
$comment->setSizeAsBackgroundImage();
self::assertEquals($comment->getWidth(), '37.5pt');
self::assertEquals($comment->getHeight(), '37.5pt');
$comment = $sheet->getComment('A3');
self::assertTrue($comment->hasBackgroundImage());
self::assertEquals($comment->getBackgroundImage()->getType(), IMAGETYPE_JPEG);
// Add bmp image to comment background
$sheet->setCellValue('A4', '.bmp 16 colors');
$drawing = new Drawing();
$drawing->setName('Yellow Square');
$drawing->setPath('tests/data/Writer/XLSX/yellow_square_16.bmp');
self::assertEquals($drawing->getWidth(), 70);
self::assertEquals($drawing->getHeight(), 70);
$comment = $sheet->getComment('A4');
$comment->setBackgroundImage($drawing);
$comment->setSizeAsBackgroundImage();
self::assertEquals($comment->getWidth(), '52.5pt');
self::assertEquals($comment->getHeight(), '52.5pt');
$comment = $sheet->getComment('A4');
self::assertTrue($comment->hasBackgroundImage());
self::assertEquals($comment->getBackgroundImage()->getType(), IMAGETYPE_BMP);
// Add bmp image to comment background
$sheet->setCellValue('A5', '.bmp 256 colors');
$drawing = new Drawing();
$drawing->setName('Brown Square');
$drawing->setPath('tests/data/Writer/XLSX/brown_square_256.bmp');
self::assertEquals($drawing->getWidth(), 70);
self::assertEquals($drawing->getHeight(), 70);
$comment = $sheet->getComment('A5');
$comment->setBackgroundImage($drawing);
$comment->setSizeAsBackgroundImage();
self::assertEquals($comment->getWidth(), '52.5pt');
self::assertEquals($comment->getHeight(), '52.5pt');
$comment = $sheet->getComment('A5');
self::assertTrue($comment->hasBackgroundImage());
self::assertEquals($comment->getBackgroundImage()->getType(), IMAGETYPE_BMP);
// Add bmp image to comment background
$sheet->setCellValue('A6', '.bmp 24 bit');
$drawing = new Drawing();
$drawing->setName('Orange Square');
$drawing->setPath('tests/data/Writer/XLSX/orange_square_24_bit.bmp');
self::assertEquals($drawing->getWidth(), 70);
self::assertEquals($drawing->getHeight(), 70);
self::assertSame(IMAGETYPE_PNG, $drawing->getImageTypeForSave());
$comment = $sheet->getComment('A6');
$comment->setBackgroundImage($drawing);
$comment->setSizeAsBackgroundImage();
self::assertEquals($comment->getWidth(), '52.5pt');
self::assertEquals($comment->getHeight(), '52.5pt');
$comment = $sheet->getComment('A6');
self::assertTrue($comment->hasBackgroundImage());
self::assertEquals($comment->getBackgroundImage()->getType(), IMAGETYPE_BMP);
// Add unsupported tiff image to comment background
$sheet->setCellValue('A7', '.tiff');
$drawing = new Drawing();
$drawing->setName('Purple Square');
$drawing->setPath('tests/data/Writer/XLSX/purple_square.tiff');
self::assertStringContainsString('purple_square.tiff', $drawing->getFilename());
self::assertFalse($drawing->getIsUrl());
$comment = $sheet->getComment('A7');
self::assertFalse($comment->hasBackgroundImage());
self::assertEquals($comment->getBackgroundImage()->getType(), IMAGETYPE_UNKNOWN);
try {
$comment->setBackgroundImage($drawing);
self::fail('Should throw exception when attempting to add tiff');
} catch (PhpSpreadsheetException $e) {
self::assertEquals($e->getMessage(), 'Unsupported image type in comment background. Supported types: PNG, JPEG, BMP, GIF.');
}
try {
$drawing->getImageTypeForSave();
self::fail('Should throw exception when attempting to get image type for tiff');
} catch (PhpSpreadsheetException $e) {
self::assertEquals($e->getMessage(), 'Unsupported image type in comment background. Supported types: PNG, JPEG, BMP, GIF.');
}
try {
$drawing->getMediaFilename();
self::fail('Should throw exception when attempting to get media file name for tiff');
} catch (PhpSpreadsheetException $e) {
self::assertEquals($e->getMessage(), 'Unsupported image type in comment background. Supported types: PNG, JPEG, BMP, GIF.');
}
try {
$drawing->getImageFileExtensionForSave();
self::fail('Should throw exception when attempting to get image file extension for tiff');
} catch (PhpSpreadsheetException $e) {
self::assertEquals($e->getMessage(), 'Unsupported image type in comment background. Supported types: PNG, JPEG, BMP, GIF.');
}
try {
$drawing->getImageMimeType();
self::fail('Should throw exception when attempting to get image mime type for tiff');
} catch (PhpSpreadsheetException $e) {
self::assertEquals($e->getMessage(), 'Unsupported image type in comment background. Supported types: PNG, JPEG, BMP, GIF.');
}
// Write file
$writer = IOFactory::createWriter($spreadsheet, 'Xlsx');
$tempFileName = File::sysGetTempDir() . '/drawings_in_comments.xlsx';
$writer->save($tempFileName);
// Read new file
$reloadedSpreadsheet = $reader->load($tempFileName);
$sheet = $reloadedSpreadsheet->getActiveSheet();
// Check first image in comment background
$comment = $sheet->getComment('A1');
self::assertEquals($comment->getWidth(), '75pt');
self::assertEquals($comment->getHeight(), '75pt');
self::assertTrue($comment->hasBackgroundImage());
self::assertEquals($comment->getBackgroundImage()->getWidth(), 100);
self::assertEquals($comment->getBackgroundImage()->getHeight(), 100);
self::assertEquals($comment->getBackgroundImage()->getType(), IMAGETYPE_PNG);
// Check second image in comment background
$comment = $sheet->getComment('A2');
self::assertEquals($comment->getWidth(), '112.5pt');
self::assertEquals($comment->getHeight(), '112.5pt');
self::assertTrue($comment->hasBackgroundImage());
self::assertEquals($comment->getBackgroundImage()->getWidth(), 150);
self::assertEquals($comment->getBackgroundImage()->getHeight(), 150);
self::assertEquals($comment->getBackgroundImage()->getType(), IMAGETYPE_PNG);
// Check third image in comment background
$comment = $sheet->getComment('A3');
self::assertEquals($comment->getWidth(), '37.5pt');
self::assertEquals($comment->getHeight(), '37.5pt');
self::assertTrue($comment->hasBackgroundImage());
self::assertEquals($comment->getBackgroundImage()->getWidth(), 50);
self::assertEquals($comment->getBackgroundImage()->getHeight(), 50);
self::assertEquals($comment->getBackgroundImage()->getType(), IMAGETYPE_JPEG);
// Check fourth image in comment background
$comment = $sheet->getComment('A4');
self::assertEquals($comment->getWidth(), '52.5pt');
self::assertEquals($comment->getHeight(), '52.5pt');
self::assertTrue($comment->hasBackgroundImage());
self::assertEquals($comment->getBackgroundImage()->getWidth(), 70);
self::assertEquals($comment->getBackgroundImage()->getHeight(), 70);
self::assertEquals($comment->getBackgroundImage()->getType(), IMAGETYPE_PNG);
// Check fifth image in comment background
$comment = $sheet->getComment('A5');
self::assertEquals($comment->getWidth(), '52.5pt');
self::assertEquals($comment->getHeight(), '52.5pt');
self::assertTrue($comment->hasBackgroundImage());
self::assertEquals($comment->getBackgroundImage()->getWidth(), 70);
self::assertEquals($comment->getBackgroundImage()->getHeight(), 70);
self::assertEquals($comment->getBackgroundImage()->getType(), IMAGETYPE_PNG);
// Check sixth image in comment background
$comment = $sheet->getComment('A6');
self::assertEquals($comment->getWidth(), '52.5pt');
self::assertEquals($comment->getHeight(), '52.5pt');
self::assertTrue($comment->hasBackgroundImage());
self::assertEquals($comment->getBackgroundImage()->getWidth(), 70);
self::assertEquals($comment->getBackgroundImage()->getHeight(), 70);
self::assertEquals($comment->getBackgroundImage()->getType(), IMAGETYPE_PNG);
// Check seventh image in comment background
$comment = $sheet->getComment('A7');
self::assertFalse($comment->hasBackgroundImage());
self::assertEquals($comment->getBackgroundImage()->getWidth(), 0);
self::assertEquals($comment->getBackgroundImage()->getHeight(), 0);
self::assertEquals($comment->getBackgroundImage()->getType(), IMAGETYPE_UNKNOWN);
unlink($tempFileName);
$spreadsheet->disconnectWorksheets();
$reloadedSpreadsheet->disconnectWorksheets();
}
/**
* Test save and load XLSX file with drawing image that coordinate is two cell anchor.
*/
public function testTwoCellAnchorDrawing(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
// Add gif image that coordinates is two cell anchor.
$drawing = new Drawing();
$drawing->setName('Green Square');
$drawing->setPath('tests/data/Writer/XLSX/green_square.gif');
self::assertEquals($drawing->getWidth(), 150);
self::assertEquals($drawing->getHeight(), 150);
$drawing->setCoordinates('A1');
$drawing->setOffsetX(30);
$drawing->setOffsetY(10);
$drawing->setCoordinates2('E8');
$drawing->setOffsetX2(-50);
$drawing->setOffsetY2(-20);
$drawing->setWorksheet($sheet);
// Write file
$reloadedSpreadsheet = $this->writeAndReload($spreadsheet, 'Xlsx');
$spreadsheet->disconnectWorksheets();
$rsheet = $reloadedSpreadsheet->getActiveSheet();
// Check image coordinates.
$drawingCollection = $rsheet->getDrawingCollection();
self::assertCount(1, $drawingCollection);
$drawing = $drawingCollection[0];
self::assertNotNull($drawing);
self::assertSame(150, $drawing->getWidth());
self::assertSame(150, $drawing->getHeight());
self::assertSame('A1', $drawing->getCoordinates());
self::assertSame(30, $drawing->getOffsetX());
self::assertSame(10, $drawing->getOffsetY());
self::assertSame('E8', $drawing->getCoordinates2());
self::assertSame(-50, $drawing->getOffsetX2());
self::assertSame(-20, $drawing->getOffsetY2());
self::assertSame($rsheet, $drawing->getWorksheet());
$reloadedSpreadsheet->disconnectWorksheets();
}
/**
* Test editAs attribute for two-cell anchors.
*/
#[\PHPUnit\Framework\Attributes\DataProvider('providerEditAs')]
public function testTwoCellEditAs(string $editAs, ?string $expectedResult = null): void
{
if ($expectedResult === null) {
$expectedResult = $editAs;
}
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
// Add gif image that coordinates is two cell anchor.
$drawing = new Drawing();
$drawing->setName('Green Square');
$drawing->setPath('tests/data/Writer/XLSX/green_square.gif');
self::assertEquals($drawing->getWidth(), 150);
self::assertEquals($drawing->getHeight(), 150);
$drawing->setCoordinates('A1');
$drawing->setOffsetX(30);
$drawing->setOffsetY(10);
$drawing->setCoordinates2('E8');
$drawing->setOffsetX2(-50);
$drawing->setOffsetY2(-20);
if ($editAs !== '') {
$drawing->setEditAs($editAs);
}
$drawing->setWorksheet($sheet);
// Write file
$reloadedSpreadsheet = $this->writeAndReload($spreadsheet, 'Xlsx');
$spreadsheet->disconnectWorksheets();
$rsheet = $reloadedSpreadsheet->getActiveSheet();
// Check image coordinates.
$drawingCollection = $rsheet->getDrawingCollection();
$drawing = $drawingCollection[0];
self::assertNotNull($drawing);
self::assertSame(150, $drawing->getWidth());
self::assertSame(150, $drawing->getHeight());
self::assertSame('A1', $drawing->getCoordinates());
self::assertSame(30, $drawing->getOffsetX());
self::assertSame(10, $drawing->getOffsetY());
self::assertSame('E8', $drawing->getCoordinates2());
self::assertSame(-50, $drawing->getOffsetX2());
self::assertSame(-20, $drawing->getOffsetY2());
self::assertSame($rsheet, $drawing->getWorksheet());
self::assertSame($expectedResult, $drawing->getEditAs());
$reloadedSpreadsheet->disconnectWorksheets();
}
public static function providerEditAs(): array
{
return [
'absolute' => ['absolute'],
'onecell' => ['oneCell'],
'twocell' => ['twoCell'],
'unset (will be treated as twoCell)' => [''],
'unknown (will be treated as twoCell)' => ['unknown', ''],
];
}
public function testMemoryDrawingDuplicateResource(): void
{
$gdImage = imagecreatetruecolor(120, 20);
$textColor = ($gdImage === false) ? false : imagecolorallocate($gdImage, 255, 255, 255);
if ($gdImage === false || $textColor === false) {
self::fail('imagecreatetruecolor or imagecolorallocate failed');
} else {
$spreadsheet = new Spreadsheet();
$aSheet = $spreadsheet->getActiveSheet();
imagestring($gdImage, 1, 5, 5, 'Created with PhpSpreadsheet', $textColor);
$listOfModes = [
BaseDrawing::EDIT_AS_TWOCELL,
BaseDrawing::EDIT_AS_ABSOLUTE,
BaseDrawing::EDIT_AS_ONECELL,
];
foreach ($listOfModes as $i => $mode) {
$drawing = new MemoryDrawing();
$drawing->setName('In-Memory image ' . $i);
$drawing->setDescription('In-Memory image ' . $i);
$drawing->setCoordinates('A' . ((4 * $i) + 1));
$drawing->setCoordinates2('D' . ((4 * $i) + 4));
$drawing->setEditAs($mode);
$drawing->setImageResource($gdImage);
$drawing->setRenderingFunction(
MemoryDrawing::RENDERING_JPEG
);
$drawing->setMimeType(MemoryDrawing::MIMETYPE_DEFAULT);
$drawing->setWorksheet($aSheet);
}
$reloadedSpreadsheet = $this->writeAndReload($spreadsheet, 'Xlsx');
$spreadsheet->disconnectWorksheets();
foreach ($reloadedSpreadsheet->getActiveSheet()->getDrawingCollection() as $index => $pDrawing) {
self::assertEquals($listOfModes[$index], $pDrawing->getEditAs(), 'functional test drawing twoCellAnchor');
}
$reloadedSpreadsheet->disconnectWorksheets();
}
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Xlsx/ArrayFunctionsInlineTest.php | tests/PhpSpreadsheetTests/Writer/Xlsx/ArrayFunctionsInlineTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Xlsx;
use PhpOffice\PhpSpreadsheet\Calculation\Calculation;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheetTests\Functional\AbstractFunctional;
class ArrayFunctionsInlineTest extends AbstractFunctional
{
public function testInlineArrays(): void
{
$spreadsheet = new Spreadsheet();
Calculation::getInstance($spreadsheet)->setInstanceArrayReturnType(Calculation::RETURN_ARRAY_AS_ARRAY);
$sheet = $spreadsheet->getActiveSheet();
$sheet->getCell('A1')->setValue('=UNIQUE({1;1;2;1;3;2;4;4;4})');
$sheet->getCell('D1')->setValue('=UNIQUE({1,1,2,1,3,2,4,4,4},true)');
$reloadedSpreadsheet = $this->writeAndReload($spreadsheet, 'Xlsx');
$spreadsheet->disconnectWorksheets();
$rsheet = $reloadedSpreadsheet->getActiveSheet();
Calculation::getInstance($reloadedSpreadsheet)->setInstanceArrayReturnType(Calculation::RETURN_ARRAY_AS_ARRAY);
$expected = [
['=UNIQUE({1;1;2;1;3;2;4;4;4})', null, null, '=UNIQUE({1,1,2,1,3,2,4,4,4},true)', 2, 3, 4],
[2, null, null, null, null, null, null],
[3, null, null, null, null, null, null],
[4, null, null, null, null, null, null],
];
self::assertSame($expected, $rsheet->toArray(null, false, false));
self::assertSame('1', $rsheet->getCell('A1')->getCalculatedValueString());
self::assertSame('1', $rsheet->getCell('D1')->getCalculatedValueString());
$reloadedSpreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Xlsx/ConditionalTest.php | tests/PhpSpreadsheetTests/Writer/Xlsx/ConditionalTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Xlsx;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Style\Conditional;
use PhpOffice\PhpSpreadsheet\Style\ConditionalFormatting\Wizard;
use PhpOffice\PhpSpreadsheet\Style\Fill;
use PhpOffice\PhpSpreadsheet\Style\Style;
use PhpOffice\PhpSpreadsheet\Writer\Xlsx;
use PhpOffice\PhpSpreadsheetTests\Functional\AbstractFunctional;
class ConditionalTest extends AbstractFunctional
{
protected string $cellRange;
protected Style $style;
protected function setUp(): void
{
parent::setUp();
$this->cellRange = 'C3:E5';
$this->style = new Style();
$this->style->applyFromArray([
'fill' => [
'color' => ['argb' => 'FFFFC000'],
'fillType' => Fill::FILL_SOLID,
],
]);
}
public function testWriteSimpleCellConditionalFromWizard(): void
{
$spreadsheet = new Spreadsheet();
$worksheet = $spreadsheet->getActiveSheet();
$wizard = new Wizard\CellValue($this->cellRange);
$wizard->greaterThan(5);
$condition = $wizard->getConditional();
$condition->setStyle($this->style);
$worksheet->setConditionalStyles($this->cellRange, [$condition]);
$writer = new Xlsx($spreadsheet);
$writerWorksheet = new Xlsx\Worksheet($writer);
$data = $writerWorksheet->writeWorksheet($worksheet, []);
$expected = <<<XML
<conditionalFormatting sqref="C3:E5"><cfRule type="cellIs" dxfId="" priority="1" operator="greaterThan"><formula>5</formula></cfRule></conditionalFormatting>
XML;
self::assertStringContainsString($expected, $data);
}
public function testWriteBetweenCellConditionalFromWizard(): void
{
$spreadsheet = new Spreadsheet();
$worksheet = $spreadsheet->getActiveSheet();
$wizard = new Wizard\CellValue($this->cellRange);
$wizard->between(-5)->and(5);
$condition = $wizard->getConditional();
$condition->setStyle($this->style);
$worksheet->setConditionalStyles($this->cellRange, [$condition]);
$writer = new Xlsx($spreadsheet);
$writerWorksheet = new Xlsx\Worksheet($writer);
$data = $writerWorksheet->writeWorksheet($worksheet, []);
$expected = <<<XML
<conditionalFormatting sqref="C3:E5"><cfRule type="cellIs" dxfId="" priority="1" operator="between"><formula>-5</formula><formula>5</formula></cfRule></conditionalFormatting>
XML;
self::assertStringContainsString($expected, $data);
}
public function testWriteTextConditionalFromWizard(): void
{
$spreadsheet = new Spreadsheet();
$worksheet = $spreadsheet->getActiveSheet();
$wizard = new Wizard\TextValue($this->cellRange);
$wizard->contains('PHP');
$condition = $wizard->getConditional();
$condition->setStyle($this->style);
$worksheet->setConditionalStyles($this->cellRange, [$condition]);
$writer = new Xlsx($spreadsheet);
$writerWorksheet = new Xlsx\Worksheet($writer);
$data = $writerWorksheet->writeWorksheet($worksheet, []);
$expected = <<<XML
<conditionalFormatting sqref="C3:E5"><cfRule type="containsText" dxfId="" priority="1" operator="containsText" text="PHP"><formula>NOT(ISERROR(SEARCH("PHP",C3)))</formula></cfRule></conditionalFormatting>
XML;
self::assertStringContainsString($expected, $data);
}
#[\PHPUnit\Framework\Attributes\DataProvider('textConditionalsProvider')]
public function testWriteTextConditionals(string $conditionType, string $operatorType, string $expected): void
{
$spreadsheet = new Spreadsheet();
$worksheet = $spreadsheet->getActiveSheet();
$condition = new Conditional();
$condition->setConditionType($conditionType);
$condition->setOperatorType($operatorType);
$condition->setText('PHP');
$condition->setStyle($this->style);
$worksheet->setConditionalStyles($this->cellRange, [$condition]);
$writer = new Xlsx($spreadsheet);
$writerWorksheet = new Xlsx\Worksheet($writer);
$data = $writerWorksheet->writeWorksheet($worksheet, []);
self::assertStringContainsString($expected, $data);
}
public static function textConditionalsProvider(): array
{
return [
'Contains' => [
Conditional::CONDITION_CONTAINSTEXT,
Conditional::OPERATOR_CONTAINSTEXT,
<<<XML
<conditionalFormatting sqref="C3:E5"><cfRule type="containsText" dxfId="" priority="1" operator="containsText" text="PHP"><formula>NOT(ISERROR(SEARCH("PHP",C3)))</formula></cfRule></conditionalFormatting>
XML
],
'Not Contains' => [
Conditional::CONDITION_NOTCONTAINSTEXT,
Conditional::OPERATOR_NOTCONTAINS,
<<<XML
<conditionalFormatting sqref="C3:E5"><cfRule type="notContainsText" dxfId="" priority="1" operator="notContains" text="PHP"><formula>ISERROR(SEARCH("PHP",C3))</formula></cfRule></conditionalFormatting>
XML
],
'Begins With' => [
Conditional::CONDITION_BEGINSWITH,
Conditional::OPERATOR_BEGINSWITH,
<<<XML
<conditionalFormatting sqref="C3:E5"><cfRule type="beginsWith" dxfId="" priority="1" operator="beginsWith" text="PHP"><formula>LEFT(C3,LEN("PHP"))="PHP"</formula></cfRule></conditionalFormatting>
XML
],
'Ends With' => [
Conditional::CONDITION_ENDSWITH,
Conditional::OPERATOR_ENDSWITH,
<<<XML
<conditionalFormatting sqref="C3:E5"><cfRule type="endsWith" dxfId="" priority="1" operator="endsWith" text="PHP"><formula>RIGHT(C3,LEN("PHP"))="PHP"</formula></cfRule></conditionalFormatting>
XML
],
];
}
public function testWriteDateConditionalFromWizard(): void
{
$spreadsheet = new Spreadsheet();
$worksheet = $spreadsheet->getActiveSheet();
$wizard = new Wizard\DateValue($this->cellRange);
$wizard->today();
$condition = $wizard->getConditional();
$condition->setStyle($this->style);
$worksheet->setConditionalStyles($this->cellRange, [$condition]);
$writer = new Xlsx($spreadsheet);
$writerWorksheet = new Xlsx\Worksheet($writer);
$data = $writerWorksheet->writeWorksheet($worksheet, []);
$expected = <<<XML
<conditionalFormatting sqref="C3:E5"><cfRule type="timePeriod" dxfId="" priority="1" timePeriod="today"><formula>FLOOR(C3,1)=TODAY()</formula></cfRule></conditionalFormatting>
XML;
self::assertStringContainsString($expected, $data);
}
#[\PHPUnit\Framework\Attributes\DataProvider('dateConditionalsProvider')]
public function testWriteDateConditionals(string $timePeriod, string $expected): void
{
$spreadsheet = new Spreadsheet();
$worksheet = $spreadsheet->getActiveSheet();
$condition = new Conditional();
$condition->setConditionType(Conditional::CONDITION_TIMEPERIOD);
$condition->setOperatorType($timePeriod);
$condition->setText($timePeriod);
$condition->setStyle($this->style);
$worksheet->setConditionalStyles($this->cellRange, [$condition]);
$writer = new Xlsx($spreadsheet);
$writerWorksheet = new Xlsx\Worksheet($writer);
$data = $writerWorksheet->writeWorksheet($worksheet, []);
self::assertStringContainsString($expected, $data);
}
public static function dateConditionalsProvider(): array
{
return [
'Yesterday' => [
Conditional::TIMEPERIOD_YESTERDAY,
<<<XML
<conditionalFormatting sqref="C3:E5"><cfRule type="timePeriod" dxfId="" priority="1" timePeriod="yesterday"><formula>FLOOR(C3)=TODAY()-1</formula></cfRule></conditionalFormatting>
XML
],
'Today' => [
Conditional::TIMEPERIOD_TODAY,
<<<XML
<conditionalFormatting sqref="C3:E5"><cfRule type="timePeriod" dxfId="" priority="1" timePeriod="today"><formula>FLOOR(C3)=TODAY()</formula></cfRule></conditionalFormatting>
XML
],
'Tomorrow' => [
Conditional::TIMEPERIOD_TOMORROW,
<<<XML
<conditionalFormatting sqref="C3:E5"><cfRule type="timePeriod" dxfId="" priority="1" timePeriod="tomorrow"><formula>FLOOR(C3)=TODAY()+1</formula></cfRule></conditionalFormatting>
XML
],
'Last 7 Days' => [
Conditional::TIMEPERIOD_LAST_7_DAYS,
<<<XML
<conditionalFormatting sqref="C3:E5"><cfRule type="timePeriod" dxfId="" priority="1" timePeriod="last7Days"><formula>AND(TODAY()-FLOOR(C3,1)<=6,FLOOR(C3,1)<=TODAY())</formula></cfRule></conditionalFormatting>
XML
],
'Last Week' => [
Conditional::TIMEPERIOD_LAST_WEEK,
<<<XML
<conditionalFormatting sqref="C3:E5"><cfRule type="timePeriod" dxfId="" priority="1" timePeriod="lastWeek"><formula>AND(TODAY()-ROUNDDOWN(C3,0)>=(WEEKDAY(TODAY())),TODAY()-ROUNDDOWN(C3,0)<(WEEKDAY(TODAY())+7))</formula></cfRule></conditionalFormatting>
XML
],
'This Week' => [
Conditional::TIMEPERIOD_THIS_WEEK,
<<<XML
<conditionalFormatting sqref="C3:E5"><cfRule type="timePeriod" dxfId="" priority="1" timePeriod="thisWeek"><formula>AND(TODAY()-ROUNDDOWN(C3,0)<=WEEKDAY(TODAY())-1,ROUNDDOWN(C3,0)-TODAY()<=7-WEEKDAY(TODAY()))</formula></cfRule></conditionalFormatting>
XML
],
'Next Week' => [
Conditional::TIMEPERIOD_NEXT_WEEK,
<<<XML
<conditionalFormatting sqref="C3:E5"><cfRule type="timePeriod" dxfId="" priority="1" timePeriod="nextWeek"><formula>AND(ROUNDDOWN(C3,0)-TODAY()>(7-WEEKDAY(TODAY())),ROUNDDOWN(C3,0)-TODAY()<(15-WEEKDAY(TODAY())))</formula></cfRule></conditionalFormatting>
XML
],
'Last Month' => [
Conditional::TIMEPERIOD_LAST_MONTH,
<<<XML
<conditionalFormatting sqref="C3:E5"><cfRule type="timePeriod" dxfId="" priority="1" timePeriod="lastMonth"><formula>AND(MONTH(C3)=MONTH(EDATE(TODAY(),0-1)),YEAR(C3)=YEAR(EDATE(TODAY(),0-1)))</formula></cfRule></conditionalFormatting>
XML
],
'This Month' => [
Conditional::TIMEPERIOD_THIS_MONTH,
<<<XML
<conditionalFormatting sqref="C3:E5"><cfRule type="timePeriod" dxfId="" priority="1" timePeriod="thisMonth"><formula>AND(MONTH(C3)=MONTH(TODAY()),YEAR(C3)=YEAR(TODAY()))</formula></cfRule></conditionalFormatting>
XML
],
'Next Month' => [
Conditional::TIMEPERIOD_NEXT_MONTH,
<<<XML
><conditionalFormatting sqref="C3:E5"><cfRule type="timePeriod" dxfId="" priority="1" timePeriod="nextMonth"><formula>AND(MONTH(C3)=MONTH(EDATE(TODAY(),0+1)),YEAR(C3)=YEAR(EDATE(TODAY(),0+1)))</formula></cfRule></conditionalFormatting>
XML
],
];
}
public function testWriteBlankConditionalFromWizard(): void
{
$spreadsheet = new Spreadsheet();
$worksheet = $spreadsheet->getActiveSheet();
$wizard = new Wizard\Blanks($this->cellRange);
$wizard->isBlank();
$condition = $wizard->getConditional();
$condition->setStyle($this->style);
$worksheet->setConditionalStyles($this->cellRange, [$condition]);
$writer = new Xlsx($spreadsheet);
$writerWorksheet = new Xlsx\Worksheet($writer);
$data = $writerWorksheet->writeWorksheet($worksheet, []);
$expected = <<<XML
<conditionalFormatting sqref="C3:E5"><cfRule type="containsBlanks" dxfId="" priority="1"><formula>LEN(TRIM(C3))=0</formula></cfRule></conditionalFormatting>
XML;
self::assertStringContainsString($expected, $data);
}
public function testWriteNonBlankConditionalFromWizard(): void
{
$spreadsheet = new Spreadsheet();
$worksheet = $spreadsheet->getActiveSheet();
$wizard = new Wizard\Blanks($this->cellRange);
$wizard->notBlank();
$condition = $wizard->getConditional();
$condition->setStyle($this->style);
$worksheet->setConditionalStyles($this->cellRange, [$condition]);
$writer = new Xlsx($spreadsheet);
$writerWorksheet = new Xlsx\Worksheet($writer);
$data = $writerWorksheet->writeWorksheet($worksheet, []);
$expected = <<<XML
<conditionalFormatting sqref="C3:E5"><cfRule type="notContainsBlanks" dxfId="" priority="1"><formula>LEN(TRIM(C3))>0</formula></cfRule></conditionalFormatting>
XML;
self::assertStringContainsString($expected, $data);
}
#[\PHPUnit\Framework\Attributes\DataProvider('blanksConditionalsProvider')]
public function testWriteBlanksConditionals(string $conditionalType, string $expected): void
{
$spreadsheet = new Spreadsheet();
$worksheet = $spreadsheet->getActiveSheet();
$condition = new Conditional();
$condition->setConditionType($conditionalType);
$condition->setStyle($this->style);
$worksheet->setConditionalStyles($this->cellRange, [$condition]);
$writer = new Xlsx($spreadsheet);
$writerWorksheet = new Xlsx\Worksheet($writer);
$data = $writerWorksheet->writeWorksheet($worksheet, []);
self::assertStringContainsString($expected, $data);
}
public static function blanksConditionalsProvider(): array
{
return [
'Blanks' => [
Conditional::CONDITION_CONTAINSBLANKS,
<<<XML
<conditionalFormatting sqref="C3:E5"><cfRule type="containsBlanks" dxfId="" priority="1"><formula>LEN(TRIM(C3))=0</formula></cfRule></conditionalFormatting>
XML
],
'Not Blanks' => [
Conditional::CONDITION_NOTCONTAINSBLANKS,
<<<XML
<conditionalFormatting sqref="C3:E5"><cfRule type="notContainsBlanks" dxfId="" priority="1"><formula>LEN(TRIM(C3))>0</formula></cfRule></conditionalFormatting>
XML
],
];
}
public function testWriteNonErrorConditionalFromWizard(): void
{
$spreadsheet = new Spreadsheet();
$worksheet = $spreadsheet->getActiveSheet();
$wizard = new Wizard\Errors($this->cellRange);
$wizard->notError();
$condition = $wizard->getConditional();
$condition->setStyle($this->style);
$worksheet->setConditionalStyles($this->cellRange, [$condition]);
$writer = new Xlsx($spreadsheet);
$writerWorksheet = new Xlsx\Worksheet($writer);
$data = $writerWorksheet->writeWorksheet($worksheet, []);
$expected = <<<XML
<conditionalFormatting sqref="C3:E5"><cfRule type="notContainsErrors" dxfId="" priority="1"><formula>NOT(ISERROR(C3))</formula></cfRule></conditionalFormatting>
XML;
self::assertStringContainsString($expected, $data);
}
public function testWriteErrorConditionalFromWizard(): void
{
$spreadsheet = new Spreadsheet();
$worksheet = $spreadsheet->getActiveSheet();
$wizard = new Wizard\Errors($this->cellRange);
$wizard->isError();
$condition = $wizard->getConditional();
$condition->setStyle($this->style);
$worksheet->setConditionalStyles($this->cellRange, [$condition]);
$writer = new Xlsx($spreadsheet);
$writerWorksheet = new Xlsx\Worksheet($writer);
$data = $writerWorksheet->writeWorksheet($worksheet, []);
$expected = <<<XML
<conditionalFormatting sqref="C3:E5"><cfRule type="containsErrors" dxfId="" priority="1"><formula>ISERROR(C3)</formula></cfRule></conditionalFormatting>
XML;
self::assertStringContainsString($expected, $data);
}
#[\PHPUnit\Framework\Attributes\DataProvider('errorsConditionalsProvider')]
public function testWriteErrorsConditionals(string $conditionalType, string $expected): void
{
$spreadsheet = new Spreadsheet();
$worksheet = $spreadsheet->getActiveSheet();
$condition = new Conditional();
$condition->setConditionType($conditionalType);
$condition->setStyle($this->style);
$worksheet->setConditionalStyles($this->cellRange, [$condition]);
$writer = new Xlsx($spreadsheet);
$writerWorksheet = new Xlsx\Worksheet($writer);
$data = $writerWorksheet->writeWorksheet($worksheet, []);
self::assertStringContainsString($expected, $data);
}
public static function errorsConditionalsProvider(): array
{
return [
'Errors' => [
Conditional::CONDITION_CONTAINSERRORS,
<<<XML
<conditionalFormatting sqref="C3:E5"><cfRule type="containsErrors" dxfId="" priority="1"><formula>ISERROR(C3)</formula></cfRule></conditionalFormatting>
XML
],
'Not Errors' => [
Conditional::CONDITION_NOTCONTAINSERRORS,
<<<XML
<conditionalFormatting sqref="C3:E5"><cfRule type="notContainsErrors" dxfId="" priority="1"><formula>NOT(ISERROR(C3))</formula></cfRule></conditionalFormatting>
XML
],
];
}
public function testWriteUniqueConditionalFromWizard(): void
{
$spreadsheet = new Spreadsheet();
$worksheet = $spreadsheet->getActiveSheet();
$wizard = new Wizard\Duplicates($this->cellRange);
$wizard->unique();
$condition = $wizard->getConditional();
$condition->setStyle($this->style);
$worksheet->setConditionalStyles($this->cellRange, [$condition]);
$writer = new Xlsx($spreadsheet);
$writerWorksheet = new Xlsx\Worksheet($writer);
$data = $writerWorksheet->writeWorksheet($worksheet, []);
$expected = <<<XML
<conditionalFormatting sqref="C3:E5"><cfRule type="uniqueValues" dxfId="" priority="1"/></conditionalFormatting>
XML;
self::assertStringContainsString($expected, $data);
}
public function testWriteDuplicateConditionalFromWizard(): void
{
$spreadsheet = new Spreadsheet();
$worksheet = $spreadsheet->getActiveSheet();
$wizard = new Wizard\Duplicates($this->cellRange);
$wizard->duplicates();
$condition = $wizard->getConditional();
$condition->setStyle($this->style);
$worksheet->setConditionalStyles($this->cellRange, [$condition]);
$writer = new Xlsx($spreadsheet);
$writerWorksheet = new Xlsx\Worksheet($writer);
$data = $writerWorksheet->writeWorksheet($worksheet, []);
$expected = <<<XML
<conditionalFormatting sqref="C3:E5"><cfRule type="duplicateValues" dxfId="" priority="1"/></conditionalFormatting>
XML;
self::assertStringContainsString($expected, $data);
}
#[\PHPUnit\Framework\Attributes\DataProvider('duplicatesConditionalsProvider')]
public function testWriteDuplicatesConditionals(string $conditionalType, string $expected): void
{
$spreadsheet = new Spreadsheet();
$worksheet = $spreadsheet->getActiveSheet();
$condition = new Conditional();
$condition->setConditionType($conditionalType);
$condition->setStyle($this->style);
$worksheet->setConditionalStyles($this->cellRange, [$condition]);
$writer = new Xlsx($spreadsheet);
$writerWorksheet = new Xlsx\Worksheet($writer);
$data = $writerWorksheet->writeWorksheet($worksheet, []);
self::assertStringContainsString($expected, $data);
}
public static function duplicatesConditionalsProvider(): array
{
return [
'Duplicates' => [
Conditional::CONDITION_DUPLICATES,
<<<XML
<conditionalFormatting sqref="C3:E5"><cfRule type="duplicateValues" dxfId="" priority="1"/></conditionalFormatting>
XML
],
'Unique' => [
Conditional::CONDITION_UNIQUE,
<<<XML
<conditionalFormatting sqref="C3:E5"><cfRule type="uniqueValues" dxfId="" priority="1"/></conditionalFormatting>
XML
],
];
}
public function testWriteExpressionConditionalFromWizard(): void
{
$spreadsheet = new Spreadsheet();
$worksheet = $spreadsheet->getActiveSheet();
$wizard = new Wizard\Expression($this->cellRange);
$wizard->expression('=ISODD(A1)');
$condition = $wizard->getConditional();
$condition->setStyle($this->style);
$worksheet->setConditionalStyles($this->cellRange, [$condition]);
$writer = new Xlsx($spreadsheet);
$writerWorksheet = new Xlsx\Worksheet($writer);
$data = $writerWorksheet->writeWorksheet($worksheet, []);
$expected = <<<XML
<conditionalFormatting sqref="C3:E5"><cfRule type="expression" dxfId="" priority="1"><formula>ISODD(C3)</formula></cfRule></conditionalFormatting>
XML;
self::assertStringContainsString($expected, $data);
}
#[\PHPUnit\Framework\Attributes\DataProvider('expressionsConditionalsProvider')]
public function testWriteExpressionConditionals(string $expression, string $expected): void
{
$spreadsheet = new Spreadsheet();
$worksheet = $spreadsheet->getActiveSheet();
$condition = new Conditional();
$condition->setConditionType(Conditional::CONDITION_EXPRESSION);
$condition->setStyle($this->style);
$condition->setConditions([$expression]);
$worksheet->setConditionalStyles($this->cellRange, [$condition]);
$writer = new Xlsx($spreadsheet);
$writerWorksheet = new Xlsx\Worksheet($writer);
$data = $writerWorksheet->writeWorksheet($worksheet, []);
self::assertStringContainsString($expected, $data);
}
public static function expressionsConditionalsProvider(): array
{
return [
'Odd' => [
'ISODD(C3)',
<<<XML
<conditionalFormatting sqref="C3:E5"><cfRule type="expression" dxfId="" priority="1"><formula>ISODD(C3)</formula></cfRule></conditionalFormatting>
XML
],
'Even' => [
'ISEVEN(C3)',
<<<XML
<conditionalFormatting sqref="C3:E5"><cfRule type="expression" dxfId="" priority="1"><formula>ISEVEN(C3)</formula></cfRule></conditionalFormatting>
XML
],
];
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Xlsx/ExplicitStyle0Test.php | tests/PhpSpreadsheetTests/Writer/Xlsx/ExplicitStyle0Test.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Xlsx;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx as XlsxReader;
use PhpOffice\PhpSpreadsheet\Shared\File;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Style\Alignment;
use PhpOffice\PhpSpreadsheet\Writer\Xlsx as XlsxWriter;
use PHPUnit\Framework\TestCase;
class ExplicitStyle0Test extends TestCase
{
private string $outputFile = '';
protected function tearDown(): void
{
if ($this->outputFile !== '') {
unlink($this->outputFile);
$this->outputFile = '';
}
}
public function testWithoutExplicitStyle0(): void
{
$spreadsheet = new Spreadsheet();
$defaultStyle = $spreadsheet->getDefaultStyle();
$defaultStyle->getFont()->setBold(true);
$defaultStyle->getAlignment()->setHorizontal(Alignment::HORIZONTAL_CENTER);
$sheet = $spreadsheet->getActiveSheet();
$sheet->getCell('A1')->setValue('bold');
$sheet->getCell('A2')->setValue('italic');
$sheet->getStyle('A2')->getFont()->setItalic(true);
$writer = new XlsxWriter($spreadsheet);
$this->outputFile = File::temporaryFilename();
$writer->save($this->outputFile);
$spreadsheet->disconnectWorksheets();
$reader = new XlsxReader();
$spreadsheet2 = $reader->load($this->outputFile);
$sheet2 = $spreadsheet2->getActiveSheet();
self::assertTrue($sheet2->getStyle('A1')->getFont()->getBold());
self::assertFalse($sheet2->getStyle('A1')->getFont()->getItalic());
self::assertSame(Alignment::HORIZONTAL_CENTER, $sheet2->getStyle('A1')->getAlignment()->getHorizontal());
self::assertTrue($sheet2->getStyle('A2')->getFont()->getBold());
self::assertTrue($sheet2->getStyle('A2')->getFont()->getItalic());
self::assertSame(Alignment::HORIZONTAL_CENTER, $sheet2->getStyle('A2')->getAlignment()->getHorizontal());
$spreadsheet2->disconnectWorksheets();
$file = 'zip://';
$file .= $this->outputFile;
$file .= '#xl/worksheets/sheet1.xml';
$data = file_get_contents($file);
if ($data === false) {
self::fail('Unable to read file');
} else {
self::assertStringContainsString('<c r="A1" t="s"><v>0</v></c>', $data, 'no s attribute in c tag');
self::assertStringContainsString('<c r="A2" s="1" t="s"><v>1</v></c>', $data);
}
}
public function testWithExplicitStyle0(): void
{
$spreadsheet = new Spreadsheet();
$defaultStyle = $spreadsheet->getDefaultStyle();
$defaultStyle->getFont()->setBold(true);
$defaultStyle->getAlignment()->setHorizontal(Alignment::HORIZONTAL_CENTER);
$sheet = $spreadsheet->getActiveSheet();
$sheet->getCell('A1')->setValue('bold');
$sheet->getCell('A2')->setValue('italic');
$sheet->getStyle('A2')->getFont()->setItalic(true);
$writer = new XlsxWriter($spreadsheet);
$writer->setExplicitStyle0(true);
$this->outputFile = File::temporaryFilename();
$writer->save($this->outputFile);
$spreadsheet->disconnectWorksheets();
$reader = new XlsxReader();
$spreadsheet2 = $reader->load($this->outputFile);
$sheet2 = $spreadsheet2->getActiveSheet();
self::assertTrue($sheet2->getStyle('A1')->getFont()->getBold());
self::assertFalse($sheet2->getStyle('A1')->getFont()->getItalic());
self::assertSame(Alignment::HORIZONTAL_CENTER, $sheet2->getStyle('A1')->getAlignment()->getHorizontal());
self::assertTrue($sheet2->getStyle('A2')->getFont()->getBold());
self::assertTrue($sheet2->getStyle('A2')->getFont()->getItalic());
self::assertSame(Alignment::HORIZONTAL_CENTER, $sheet2->getStyle('A2')->getAlignment()->getHorizontal());
$spreadsheet2->disconnectWorksheets();
$file = 'zip://';
$file .= $this->outputFile;
$file .= '#xl/worksheets/sheet1.xml';
$data = file_get_contents($file);
if ($data === false) {
self::fail('Unable to read file');
} else {
self::assertStringContainsString('<c r="A1" s="0" t="s"><v>0</v></c>', $data, 'has s attribute in c tag');
self::assertStringContainsString('<c r="A2" s="1" t="s"><v>1</v></c>', $data);
}
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Xlsx/Issue476Test.php | tests/PhpSpreadsheetTests/Writer/Xlsx/Issue476Test.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Xlsx;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx as XlsxReader;
use PhpOffice\PhpSpreadsheet\RichText\RichText;
use PhpOffice\PhpSpreadsheetTests\Functional\AbstractFunctional;
class Issue476Test extends AbstractFunctional
{
public function testIssue476(): void
{
// RichText written in a way usually used only by strings.
$reader = new XlsxReader();
$spreadsheet = $reader->load('tests/data/Writer/XLSX/issue.476.xlsx');
$reloadedSpreadsheet = $this->writeAndReload($spreadsheet, 'Xlsx');
$spreadsheet->disconnectWorksheets();
$sheet = $reloadedSpreadsheet->getActiveSheet();
$richText = $sheet->getCell('A1')->getValue();
self::assertInstanceOf(RichText::class, $richText);
$plainText = $richText->getPlainText();
self::assertSame("Art. 1A of the Geneva Refugee Convention and Protocol or other international or national instruments.\n", $plainText);
$reloadedSpreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Xlsx/ConditionalFormatIconSetTest.php | tests/PhpSpreadsheetTests/Writer/Xlsx/ConditionalFormatIconSetTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Xlsx;
use Generator;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Style\Conditional;
use PhpOffice\PhpSpreadsheet\Style\ConditionalFormatting\ConditionalFormatValueObject;
use PhpOffice\PhpSpreadsheet\Style\ConditionalFormatting\ConditionalIconSet;
use PhpOffice\PhpSpreadsheet\Style\ConditionalFormatting\IconSetValues;
use PhpOffice\PhpSpreadsheet\Writer\Xlsx;
use PhpOffice\PhpSpreadsheetTests\Functional\AbstractFunctional;
use PHPUnit\Framework\Attributes\DataProvider;
class ConditionalFormatIconSetTest extends AbstractFunctional
{
private const COORDINATE = 'A1:A3';
#[DataProvider('iconSetsProvider')]
public function testWriteIconSets(
string $expected,
?IconSetValues $type,
?bool $reverse = null,
?bool $showValue = null,
?bool $custom = null,
): void {
$condition = new Conditional();
$condition->setConditionType(Conditional::CONDITION_ICONSET);
$iconSet = $condition->setIconSet(new ConditionalIconSet())
->getIconSet();
self::assertNotNull($iconSet);
if ($type !== null) {
$iconSet->setIconSetType($type);
}
$iconSet->setCfvos([
new ConditionalFormatValueObject('percent', 0),
new ConditionalFormatValueObject('percent', 33),
new ConditionalFormatValueObject('percent', 67),
]);
if ($reverse !== null) {
$iconSet->setReverse($reverse);
}
if ($showValue !== null) {
$iconSet->setShowValue($showValue);
}
if ($custom !== null) {
$iconSet->setCustom($custom);
}
$spreadsheet = new Spreadsheet();
$worksheet = $spreadsheet->getActiveSheet();
$worksheet->setConditionalStyles(self::COORDINATE, [$condition]);
$writer = new Xlsx($spreadsheet);
$writerWorksheet = new Xlsx\Worksheet($writer);
$data = $writerWorksheet->writeWorksheet($worksheet, []);
$expected = preg_replace(['/^\s+/m', "/\n/"], '', $expected);
self::assertIsString($expected);
self::assertStringContainsString($expected, $data);
}
public static function iconSetsProvider(): Generator
{
$coordinate = self::COORDINATE;
$cfvos = <<<XML
<cfvo type="percent" val="0"/>
<cfvo type="percent" val="33"/>
<cfvo type="percent" val="67"/>
XML;
foreach (IconSetValues::cases() as $type) {
yield $type->name => [
<<<XML
<conditionalFormatting sqref="{$coordinate}">
<cfRule type="iconSet" priority="1">
<iconSet iconSet="{$type->value}">
{$cfvos}
</iconSet>
</cfRule>
</conditionalFormatting>
XML,
$type,
];
}
yield 'null' => [
<<<XML
<conditionalFormatting sqref="{$coordinate}">
<cfRule type="iconSet" priority="1">
<iconSet>
{$cfvos}
</iconSet>
</cfRule>
</conditionalFormatting>
XML,
null,
];
foreach ([1, 0] as $reverse) {
yield "null/reverse=$reverse" => [
<<<XML
<conditionalFormatting sqref="{$coordinate}">
<cfRule type="iconSet" priority="1">
<iconSet reverse="$reverse">
{$cfvos}
</iconSet>
</cfRule>
</conditionalFormatting>
XML,
null,
$reverse === 1,
];
}
foreach ([1, 0] as $showValue) {
yield "null/showValue=$showValue" => [
<<<XML
<conditionalFormatting sqref="{$coordinate}">
<cfRule type="iconSet" priority="1">
<iconSet showValue="$showValue">
{$cfvos}
</iconSet>
</cfRule>
</conditionalFormatting>
XML,
null,
null,
$showValue === 1,
];
}
foreach ([1, 0] as $custom) {
yield "null/custom=$custom" => [
<<<XML
<conditionalFormatting sqref="{$coordinate}">
<cfRule type="iconSet" priority="1">
<iconSet custom="$custom">
{$cfvos}
</iconSet>
</cfRule>
</conditionalFormatting>
XML,
null,
null,
null,
$custom === 1,
];
}
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Xlsx/BadParamExceptionTest.php | tests/PhpSpreadsheetTests/Writer/Xlsx/BadParamExceptionTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Xlsx;
use PhpOffice\PhpSpreadsheet\Shared\XMLWriter;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Writer\Exception as WriterException;
use PhpOffice\PhpSpreadsheet\Writer\Xlsx as XlsxWriter;
use PHPUnit\Framework\TestCase;
use ReflectionMethod;
class BadParamExceptionTest extends TestCase
{
public function testBadAddToXmlWorkbook(): void
{
$this->expectException(WriterException::class);
$this->expectExceptionMessage('Invalid parameters passed.');
$objWriter = new XMLWriter();
$spreadsheet = new Spreadsheet();
$writerXlsx = new XlsxWriter($spreadsheet);
$writerXlsxWorkbook = new XlsxWriter\Workbook($writerXlsx);
$reflectionMethod = new ReflectionMethod($writerXlsxWorkbook, 'writeSheet');
$reflectionMethod->invokeArgs($writerXlsxWorkbook, [$objWriter, '']);
}
public function testBadAddToXmlRels(): void
{
$this->expectException(WriterException::class);
$this->expectExceptionMessage('Invalid parameters passed.');
$objWriter = new XMLWriter();
$spreadsheet = new Spreadsheet();
$writerXlsx = new XlsxWriter($spreadsheet);
$writerXlsxRels = new XlsxWriter\Rels($writerXlsx);
$reflectionMethod = new ReflectionMethod($writerXlsxRels, 'writeRelationship');
$reflectionMethod->invokeArgs($writerXlsxRels, [$objWriter, '', '', '']);
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Xlsx/Issue2368Test.php | tests/PhpSpreadsheetTests/Writer/Xlsx/Issue2368Test.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Xlsx;
use PhpOffice\PhpSpreadsheet\Cell\DataValidation;
use PhpOffice\PhpSpreadsheet\IOFactory;
use PhpOffice\PhpSpreadsheet\Shared\File;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Writer\Xlsx as Writer;
use PhpOffice\PhpSpreadsheetTests\Functional\AbstractFunctional;
class Issue2368Test extends AbstractFunctional
{
public function testBoolWrite(): void
{
// DataValidations were incorrectly written twice.
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$validation = $sheet->getDataValidation('A1:A10');
$validation->setType(DataValidation::TYPE_LIST);
$validation->setShowDropDown(true);
$validation->setFormula1('"Option 1, Option 2"');
$outputFilename = File::temporaryFilename();
$writer = new Writer($spreadsheet);
$writer->save($outputFilename);
$zipfile = "zip://$outputFilename#xl/worksheets/sheet1.xml";
$contents = file_get_contents($zipfile);
unlink($outputFilename);
$spreadsheet->disconnectWorksheets();
if ($contents === false) {
self::fail('Unable to open file');
} else {
self::assertSame(0, substr_count($contents, '<extLst>'));
self::assertSame(2, substr_count($contents, 'dataValidations')); // start and end tags
}
}
public function testMultipleRange(): void
{
// DataValidations which were identical except for sqref were incorrectly merged.
$filename = 'tests/data/Writer/XLSX/issue.2368new.xlsx';
$reader = IOFactory::createReader('Xlsx');
$spreadsheet = $reader->load($filename);
$sheet = $spreadsheet->getActiveSheet();
$validations = $sheet->getDataValidationCollection();
self::assertSame(['A1:A5 A10:A14 A20:A24'], array_keys($validations));
self::assertSame('"yes,no"', $sheet->getCell('A3')->getDataValidation()->getFormula1());
self::assertSame('"yes,no"', $sheet->getCell('A10')->getDataValidation()->getFormula1());
self::assertSame('"yes,no"', $sheet->getCell('A24')->getDataValidation()->getFormula1());
$reloadedSpreadsheet = $this->writeAndReload($spreadsheet, 'Xlsx');
$spreadsheet->disconnectWorksheets();
$sheet2 = $reloadedSpreadsheet->getActiveSheet();
$validation2 = $sheet2->getDataValidationCollection();
self::assertSame(['A1:A5 A10:A14 A20:A24'], array_keys($validation2));
self::assertSame('"yes,no"', $sheet2->getCell('A3')->getDataValidation()->getFormula1());
self::assertSame('"yes,no"', $sheet2->getCell('A10')->getDataValidation()->getFormula1());
self::assertSame('"yes,no"', $sheet2->getCell('A24')->getDataValidation()->getFormula1());
$reloadedSpreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Xlsx/Issue4200Test.php | tests/PhpSpreadsheetTests/Writer/Xlsx/Issue4200Test.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Xlsx;
use PhpOffice\PhpSpreadsheet\Cell\DataType;
use PhpOffice\PhpSpreadsheet\RichText\RichText;
use PhpOffice\PhpSpreadsheet\Shared\File;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Worksheet\Drawing;
use PhpOffice\PhpSpreadsheet\Writer\Xlsx as XlsxWriter;
use PHPUnit\Framework\TestCase;
use ZipArchive;
class Issue4200Test extends TestCase
{
private string $outputFile = '';
protected function tearDown(): void
{
if ($this->outputFile !== '') {
unlink($this->outputFile);
$this->outputFile = '';
}
}
public function testIssue4200(): void
{
// ignoredErrors came after legacyDrawing
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->getCell('A1')->setValueExplicit('01', DataType::TYPE_STRING);
$sheet->getCell('A1')
->getIgnoredErrors()
->setNumberStoredAsText(true);
$richText = new RichText();
$richText->createText('hello');
$sheet->getComment('C1')
->setText($richText);
$writer = new XlsxWriter($spreadsheet);
$this->outputFile = File::temporaryFilename();
$writer->save($this->outputFile);
$spreadsheet->disconnectWorksheets();
$zip = new ZipArchive();
$open = $zip->open($this->outputFile, ZipArchive::RDONLY);
if ($open !== true) {
self::fail("zip open failed for {$this->outputFile}");
} else {
$contents = (string) $zip->getFromName('xl/worksheets/sheet1.xml');
self::assertStringContainsString(
'<ignoredErrors><ignoredError sqref="A1" numberStoredAsText="1"/></ignoredErrors><legacyDrawing r:id="rId_comments_vml1"/>',
$contents
);
}
}
public function testIssue4145(): void
{
// ignoredErrors came after drawing
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->getCell('A1')->setValueExplicit('01', DataType::TYPE_STRING);
$sheet->getCell('A1')
->getIgnoredErrors()
->setNumberStoredAsText(true);
$drawing = new Drawing();
$drawing->setName('Blue Square');
$drawing->setPath('tests/data/Writer/XLSX/blue_square.png');
$drawing->setCoordinates('C1');
$drawing->setWorksheet($sheet);
$writer = new XlsxWriter($spreadsheet);
$this->outputFile = File::temporaryFilename();
$writer->save($this->outputFile);
$spreadsheet->disconnectWorksheets();
$zip = new ZipArchive();
$open = $zip->open($this->outputFile, ZipArchive::RDONLY);
if ($open !== true) {
self::fail("zip open failed for {$this->outputFile}");
} else {
$contents = (string) $zip->getFromName('xl/worksheets/sheet1.xml');
self::assertStringContainsString(
'<ignoredErrors><ignoredError sqref="A1" numberStoredAsText="1"/></ignoredErrors><drawing r:id="rId1"/>',
$contents
);
}
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Xlsx/UnparsedDataCloneTest.php | tests/PhpSpreadsheetTests/Writer/Xlsx/UnparsedDataCloneTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Xlsx;
use PhpOffice\PhpSpreadsheet\Shared\File;
use PHPUnit\Framework\TestCase;
use ZipArchive;
class UnparsedDataCloneTest extends TestCase
{
/**
* Test load and save Xlsx file with unparsed data (form elements, protected sheets, alternate contents, printer settings,..).
*/
public function testLoadSaveXlsxWithUnparsedDataClone(): void
{
$sampleFilename = 'tests/data/Writer/XLSX/drawing_on_2nd_page.xlsx';
$resultFilename = File::temporaryFilename();
$reader = new \PhpOffice\PhpSpreadsheet\Reader\Xlsx();
$spreadsheet = $reader->load($sampleFilename);
$spreadsheet->setActiveSheetIndex(1);
$sheet = $spreadsheet->getActiveSheet();
$drawings = $sheet->getDrawingCollection();
self::assertCount(1, $drawings);
$sheetCodeName = $sheet->getCodeName();
/** @var array<array<array<mixed>>> */
$unparsedLoadedData = $spreadsheet->getUnparsedLoadedData();
self::assertArrayHasKey('printerSettings', $unparsedLoadedData['sheets']["$sheetCodeName"]);
self::assertCount(1, $unparsedLoadedData['sheets'][$sheetCodeName]['printerSettings']);
$clonedSheet = clone $spreadsheet->getActiveSheet();
$clonedSheet->setTitle('Clone');
$spreadsheet->addSheet($clonedSheet);
$writer = new \PhpOffice\PhpSpreadsheet\Writer\Xlsx($spreadsheet);
$writer->save($resultFilename);
$dupname = 'Unable to open saved file';
$zip = new ZipArchive();
if ($zip->open($resultFilename) === true) {
$names = [];
$dupname = '';
for ($index = 0; $index < $zip->numFiles; ++$index) {
$filename = $zip->getNameIndex($index);
if (in_array($filename, $names)) {
$dupname .= "$filename,";
} else {
$names[] = $filename;
}
}
$zip->close();
}
unlink($resultFilename);
self::assertEquals('', $dupname);
}
/**
* Test that saving twice with same writer works.
*/
public function testSaveTwice(): void
{
$sampleFilename = 'tests/data/Writer/XLSX/drawing_on_2nd_page.xlsx';
$resultFilename1 = File::temporaryFilename();
$resultFilename2 = File::temporaryFilename();
self::assertNotEquals($resultFilename1, $resultFilename2);
$reader = new \PhpOffice\PhpSpreadsheet\Reader\Xlsx();
$spreadsheet = $reader->load($sampleFilename);
$sheet = $spreadsheet->setActiveSheetIndex(1);
$sheet->setTitle('Original');
$clonedSheet = clone $spreadsheet->getActiveSheet();
$clonedSheet->setTitle('Clone');
$spreadsheet->addSheet($clonedSheet);
$clonedSheet->getCell('A8')->setValue('cloned');
$sheet->getCell('A8')->setValue('original');
$writer = new \PhpOffice\PhpSpreadsheet\Writer\Xlsx($spreadsheet);
$writer->save($resultFilename1);
$reader1 = new \PhpOffice\PhpSpreadsheet\Reader\Xlsx();
$spreadsheet1 = $reader1->load($resultFilename1);
unlink($resultFilename1);
$sheet1c = $spreadsheet1->getSheetByNameOrThrow('Clone');
$sheet1o = $spreadsheet1->getSheetByNameOrThrow('Original');
$writer->save($resultFilename2);
$reader2 = new \PhpOffice\PhpSpreadsheet\Reader\Xlsx();
$spreadsheet2 = $reader2->load($resultFilename2);
unlink($resultFilename2);
$sheet2c = $spreadsheet2->getSheetByNameOrThrow('Clone');
$sheet2o = $spreadsheet2->getSheetByNameOrThrow('Original');
self::assertEquals($spreadsheet1->getSheetCount(), $spreadsheet2->getSheetCount());
self::assertCount(1, $sheet1c->getDrawingCollection());
self::assertCount(1, $sheet1o->getDrawingCollection());
self::assertCount(1, $sheet2c->getDrawingCollection());
self::assertCount(1, $sheet2o->getDrawingCollection());
self::assertEquals('original', $sheet1o->getCell('A8')->getValue());
self::assertEquals('original', $sheet2o->getCell('A8')->getValue());
self::assertEquals('cloned', $sheet1c->getCell('A8')->getValue());
self::assertEquals('cloned', $sheet2c->getCell('A8')->getValue());
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Xlsx/ConditionalFillTest.php | tests/PhpSpreadsheetTests/Writer/Xlsx/ConditionalFillTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Xlsx;
use PhpOffice\PhpSpreadsheet\Shared\File;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Style\Conditional;
use PhpOffice\PhpSpreadsheet\Style\Fill;
use PhpOffice\PhpSpreadsheet\Writer\Xlsx as XlsxWriter;
use PHPUnit\Framework\TestCase;
class ConditionalFillTest extends TestCase
{
public function testFill(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->getCell('A1')->setValue(10);
$sheet->getCell('A2')->setValue(20);
$sheet->getCell('A3')->setValue(30);
$sheet->getCell('A4')->setValue(40);
$sheet->getStyle('A1')->getFill()->setFillType(Fill::FILL_SOLID);
$sheet->getStyle('A1')->getFill()->getStartColor()->setARGB('FFFF0000');
$sheet->getStyle('A2')->getFill()->setFillType(Fill::FILL_SOLID);
// Need to specify StartColor for desired effect
$sheet->getStyle('A2')->getFill()->getEndColor()->setARGB('FF00FF00');
$conditional1 = new Conditional();
$conditional1->setConditionType(Conditional::CONDITION_CELLIS);
$conditional1->setOperatorType(Conditional::OPERATOR_GREATERTHAN);
$conditional1->addCondition(35);
$conditional1->getStyle()->getFill()->setFillType(Fill::FILL_SOLID);
$conditional1->getStyle()->getFill()->getEndColor()->setARGB('FF0000FF');
$conditional2 = new Conditional();
$conditional2->setConditionType(Conditional::CONDITION_CELLIS);
$conditional2->setOperatorType(Conditional::OPERATOR_LESSTHAN);
$conditional2->addCondition(35);
$conditional2->getStyle()->getFill()->setFillType(Fill::FILL_SOLID);
// Before issue37303202, had needed to specify EndColor for desired effect.
// This was the opposite of non-Conditional style.
$conditional2->getStyle()->getFill()->getStartColor()->setARGB('FFFFFF00');
$conditionalStyles = $spreadsheet->getActiveSheet()->getStyle('A3:A4')->getConditionalStyles();
$conditionalStyles[] = $conditional1;
$conditionalStyles[] = $conditional2;
$spreadsheet->getActiveSheet()->getStyle('A3:A4')->setConditionalStyles($conditionalStyles);
$sheet->setSelectedCells('C1');
$outfile = File::temporaryFilename();
$writer = new XlsxWriter($spreadsheet);
$writer->setUseDiskCaching(true, sys_get_temp_dir());
$writer->save($outfile);
$spreadsheet->disconnectWorksheets();
$file = 'zip://';
$file .= $outfile;
$file .= '#xl/styles.xml';
$data = file_get_contents($file);
unlink($outfile);
$expected = '<fill>'
. '<patternFill patternType="solid">'
. '<fgColor rgb="FFFF0000"/>'
. '<bgColor rgb="FF000000"/>'
. '</patternFill>'
. '</fill>';
self::assertStringContainsString($expected, $data, 'style for A1');
$expected = '<fill>'
. '<patternFill patternType="solid">'
. '<fgColor rgb="FFFFFFFF"/>'
. '<bgColor rgb="FF00FF00"/>'
. '</patternFill>'
. '</fill>';
self::assertStringContainsString($expected, $data, 'style for A2');
$expected = '<dxf><fill>'
. '<patternFill patternType="solid">'
. '<bgColor rgb="FF0000FF"/>'
. '</patternFill>'
. '</fill>';
self::assertStringContainsString($expected, $data, 'conditional 1');
$expected = '<dxf><fill>'
. '<patternFill patternType="solid">'
. '<bgColor rgb="FFFFFF00"/>'
. '</patternFill>'
. '</fill>';
self::assertStringContainsString($expected, $data, 'conditional 2');
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Xlsx/Issue3443Test.php | tests/PhpSpreadsheetTests/Writer/Xlsx/Issue3443Test.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Xlsx;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Style\Alignment;
use PhpOffice\PhpSpreadsheetTests\Functional\AbstractFunctional;
class Issue3443Test extends AbstractFunctional
{
public function testNonDefaultAlign(): void
{
// Issue 3443 - default alignment not honored.
$spreadsheet = new Spreadsheet();
$styleArray = [
'alignment' => [
'horizontal' => Alignment::HORIZONTAL_CENTER,
'vertical' => Alignment::VERTICAL_CENTER,
'wrapText' => true,
],
'font' => [
'name' => 'Courier New',
],
];
$spreadsheet->getDefaultStyle()->applyFromArray($styleArray);
$sheet = $spreadsheet->getActiveSheet();
$sheet->getCell('A1')->setValue(1);
$sheet->getCell('A2')->setValue(2);
$sheet->getCell('A3')->setValue(3);
$sheet->getStyle('A2')->getAlignment()->setHorizontal(Alignment::HORIZONTAL_LEFT);
$sheet->getStyle('A3')->getFont()->setName('Tahoma');
$reloadedSpreadsheet = $this->writeAndReload($spreadsheet, 'Xlsx');
$spreadsheet->disconnectWorksheets();
$rsheet = $reloadedSpreadsheet->getActiveSheet();
$expected1 = [
'horizontal' => 'center',
'justifyLastLine' => null,
'indent' => 0,
'readOrder' => 0,
'shrinkToFit' => false,
'textRotation' => 0,
'vertical' => 'center',
'wrapText' => true,
];
self::assertSame($expected1, $rsheet->getStyle('A1')->getAlignment()->exportArray());
$expected2 = $expected1;
$expected2['horizontal'] = 'left';
self::assertSame($expected2, $rsheet->getStyle('A2')->getAlignment()->exportArray());
self::assertSame($expected1, $rsheet->getStyle('A3')->getAlignment()->exportArray());
self::assertSame('Courier New', $rsheet->getStyle('A1')->getFont()->getName());
self::assertSame('Courier New', $rsheet->getStyle('A2')->getFont()->getName());
self::assertSame('Tahoma', $rsheet->getStyle('A3')->getFont()->getName());
$reloadedSpreadsheet->disconnectWorksheets();
}
public function testDefaultAlign(): void
{
// Issue 3443 - default alignment not honored.
$spreadsheet = new Spreadsheet();
$styleArray = [
'font' => [
'name' => 'Courier New',
],
];
$spreadsheet->getDefaultStyle()->applyFromArray($styleArray);
$sheet = $spreadsheet->getActiveSheet();
$sheet->getCell('A1')->setValue(1);
$sheet->getCell('A2')->setValue(2);
$sheet->getCell('A3')->setValue(3);
$sheet->getStyle('A2')->getAlignment()->setHorizontal(Alignment::HORIZONTAL_LEFT);
$sheet->getStyle('A3')->getFont()->setName('Tahoma');
$reloadedSpreadsheet = $this->writeAndReload($spreadsheet, 'Xlsx');
$spreadsheet->disconnectWorksheets();
$rsheet = $reloadedSpreadsheet->getActiveSheet();
$expected1 = [
'horizontal' => 'general',
'justifyLastLine' => null,
'indent' => 0,
'readOrder' => 0,
'shrinkToFit' => false,
'textRotation' => 0,
'vertical' => 'bottom',
'wrapText' => false,
];
self::assertSame($expected1, $rsheet->getStyle('A1')->getAlignment()->exportArray());
$expected2 = $expected1;
$expected2['horizontal'] = 'left';
self::assertSame($expected2, $rsheet->getStyle('A2')->getAlignment()->exportArray());
self::assertSame($expected1, $rsheet->getStyle('A3')->getAlignment()->exportArray());
self::assertSame('Courier New', $rsheet->getStyle('A1')->getFont()->getName());
self::assertSame('Courier New', $rsheet->getStyle('A2')->getFont()->getName());
self::assertSame('Tahoma', $rsheet->getStyle('A3')->getFont()->getName());
$reloadedSpreadsheet->disconnectWorksheets();
}
public function testReadOrder(): void
{
$mixedString = 'xאבy'; // both LTR and RTL characters
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
// Following Cells will display differently depending on read order.
// PhpSpreadsheet will not show any differences, but Excel will.
$sheet->getCell('A1')->setValue($mixedString);
$sheet->getCell('A2')->setValue($mixedString);
$sheet->getCell('A3')->setValue($mixedString);
$sheet->getStyle('A2')->getAlignment()
->setReadOrder(Alignment::READORDER_LTR);
$sheet->getStyle('A3')->getAlignment()
->setReadOrder(Alignment::READORDER_RTL);
$reloadedSpreadsheet = $this->writeAndReload($spreadsheet, 'Xlsx');
$spreadsheet->disconnectWorksheets();
$rsheet = $reloadedSpreadsheet->getActiveSheet();
self::assertSame($mixedString, $rsheet->getCell('A1')->getFormattedValue());
self::assertSame($mixedString, $rsheet->getCell('A2')->getFormattedValue());
self::assertSame($mixedString, $rsheet->getCell('A3')->getFormattedValue());
self::assertSame(
Alignment::READORDER_CONTEXT,
$rsheet->getStyle('A1')->getAlignment()->getReadOrder()
);
self::assertSame(
Alignment::READORDER_LTR,
$rsheet->getStyle('A2')->getAlignment()->getReadOrder()
);
self::assertSame(
Alignment::READORDER_RTL,
$rsheet->getStyle('A3')->getAlignment()->getReadOrder()
);
$reloadedSpreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Xlsx/CalculationErrorTest.php | tests/PhpSpreadsheetTests/Writer/Xlsx/CalculationErrorTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Xlsx;
use PhpOffice\PhpSpreadsheet\Calculation\Calculation;
use PhpOffice\PhpSpreadsheet\Calculation\Exception as CalcException;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheetTests\Functional\AbstractFunctional;
class CalculationErrorTest 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 testCalculationExceptionSuppressed(): void
{
$spreadsheet = $this->spreadsheet = new Spreadsheet();
$sheet = $this->spreadsheet->getActiveSheet();
$calculation = Calculation::getInstance($spreadsheet);
self::assertFalse($calculation->getSuppressFormulaErrors());
$calculation->setSuppressFormulaErrors(true);
$sheet->getCell('A1')->setValue('=SUM(');
$sheet->getCell('A2')->setValue('=2+3');
$spreadsheet2 = $this->reloadedSpreadsheet = $this->writeAndReload($spreadsheet, 'Xlsx');
$rcalculation = Calculation::getInstance($this->reloadedSpreadsheet);
self::assertFalse($rcalculation->getSuppressFormulaErrors());
$rcalculation->setSuppressFormulaErrors(true);
$rsheet = $spreadsheet2->getActiveSheet();
self::assertSame('=SUM(', $rsheet->getCell('A1')->getValue());
self::assertFalse($rsheet->getCell('A1')->getCalculatedValue());
self::assertSame('=2+3', $rsheet->getCell('A2')->getValue());
self::assertSame(5, $rsheet->getCell('A2')->getCalculatedValue());
$calculation->setSuppressFormulaErrors(false);
$rcalculation->setSuppressFormulaErrors(false);
}
public function testCalculationException(): void
{
$this->expectException(CalcException::class);
$this->expectExceptionMessage("Formula Error: Expecting ')'");
$spreadsheet = $this->spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$calculation = Calculation::getInstance($spreadsheet);
self::assertFalse($calculation->getSuppressFormulaErrors());
$sheet->getCell('A1')->setValue('=SUM(');
$sheet->getCell('A2')->setValue('=2+3');
$this->reloadedSpreadsheet = $this->writeAndReload($spreadsheet, 'Xlsx');
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Xlsx/WmfTest.php | tests/PhpSpreadsheetTests/Writer/Xlsx/WmfTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Xlsx;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\Worksheet\Drawing;
use PhpOffice\PhpSpreadsheetTests\Functional\AbstractFunctional;
class WmfTest extends AbstractFunctional
{
/**
* Test save and load XLSX file with wmf image.
*/
public function testWmf(): void
{
// Read spreadsheet from file
$inputFilename = 'tests/data/Writer/XLSX/wmffile.xlsx';
$reader = new Xlsx();
$spreadsheet = $reader->load($inputFilename);
$drawings = $spreadsheet->getActiveSheet()->getDrawingCollection();
self::assertCount(1, $drawings);
$drawing = $drawings[0];
self::assertInstanceOf(Drawing::class, $drawing);
self::assertSame('wmf', $drawing->getExtension());
// Save spreadsheet to file and read it back
$reloadedSpreadsheet = $this->writeAndReload($spreadsheet, 'Xlsx');
$drawings = $reloadedSpreadsheet->getActiveSheet()->getDrawingCollection();
self::assertCount(1, $drawings);
$drawing = $drawings[0];
self::assertInstanceOf(Drawing::class, $drawing);
self::assertSame('wmf', $drawing->getExtension());
$spreadsheet->disconnectWorksheets();
$reloadedSpreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Chart/GridlinesShadowGlowTest.php | tests/PhpSpreadsheetTests/Chart/GridlinesShadowGlowTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Chart;
use PhpOffice\PhpSpreadsheet\Chart\Axis;
use PhpOffice\PhpSpreadsheet\Chart\Chart;
use PhpOffice\PhpSpreadsheet\Chart\ChartColor;
use PhpOffice\PhpSpreadsheet\Chart\DataSeries;
use PhpOffice\PhpSpreadsheet\Chart\DataSeriesValues;
use PhpOffice\PhpSpreadsheet\Chart\GridLines;
use PhpOffice\PhpSpreadsheet\Chart\Legend as ChartLegend;
use PhpOffice\PhpSpreadsheet\Chart\PlotArea;
use PhpOffice\PhpSpreadsheet\Chart\Title;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx as XlsxReader;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Writer\Xlsx as XlsxWriter;
use PhpOffice\PhpSpreadsheetTests\Functional\AbstractFunctional;
class GridlinesShadowGlowTest extends AbstractFunctional
{
public function readCharts(XlsxReader $reader): void
{
$reader->setIncludeCharts(true);
}
public function writeCharts(XlsxWriter $writer): void
{
$writer->setIncludeCharts(true);
}
public function testGlowY(): void
{
$spreadsheet = new Spreadsheet();
$worksheet = $spreadsheet->getActiveSheet();
$worksheet->fromArray(
[
['', 2010, 2011, 2012],
['Q1', 12, 15, 21],
['Q2', 56, 73, 86],
['Q3', 52, 61, 69],
['Q4', 30, 32, 0],
]
);
// Set the Labels for each data series we want to plot
// Datatype
// Cell reference for data
// Format Code
// Number of datapoints in series
// Data values
// Data Marker
$dataSeriesLabels = [
new DataSeriesValues(DataSeriesValues::DATASERIES_TYPE_STRING, 'Worksheet!$B$1', null, 1), // 2010
new DataSeriesValues(DataSeriesValues::DATASERIES_TYPE_STRING, 'Worksheet!$C$1', null, 1), // 2011
new DataSeriesValues(DataSeriesValues::DATASERIES_TYPE_STRING, 'Worksheet!$D$1', null, 1), // 2012
];
// Set the X-Axis Labels
// Datatype
// Cell reference for data
// Format Code
// Number of datapoints in series
// Data values
// Data Marker
$xAxisTickValues = [
new DataSeriesValues(DataSeriesValues::DATASERIES_TYPE_STRING, 'Worksheet!$A$2:$A$5', null, 4), // Q1 to Q4
];
// Set the Data values for each data series we want to plot
// Datatype
// Cell reference for data
// Format Code
// Number of datapoints in series
// Data values
// Data Marker
$dataSeriesValues = [
new DataSeriesValues(DataSeriesValues::DATASERIES_TYPE_NUMBER, 'Worksheet!$B$2:$B$5', null, 4),
new DataSeriesValues(DataSeriesValues::DATASERIES_TYPE_NUMBER, 'Worksheet!$C$2:$C$5', null, 4),
new DataSeriesValues(DataSeriesValues::DATASERIES_TYPE_NUMBER, 'Worksheet!$D$2:$D$5', null, 4),
];
// Build the dataseries
$series = new DataSeries(
DataSeries::TYPE_LINECHART, // plotType
DataSeries::GROUPING_PERCENT_STACKED, // plotGrouping
range(0, count($dataSeriesValues) - 1), // plotOrder
$dataSeriesLabels, // plotLabel
$xAxisTickValues, // plotCategory
$dataSeriesValues // plotValues
);
// Set the series in the plot area
$plotArea = new PlotArea(null, [$series]);
// Set the chart legend
$legend = new ChartLegend(ChartLegend::POSITION_TOPRIGHT, null, false);
$title = new Title('Test %age-Stacked Area Chart');
$yAxisLabel = new Title('Value ($k)');
$yAxis = new Axis();
$majorGridlines = new GridLines();
$yAxis->setMajorGridlines($majorGridlines);
$majorGlowSize = 10.0;
$majorGridlines->setGlowProperties($majorGlowSize, 'FFFF00', 30, ChartColor::EXCEL_COLOR_TYPE_RGB);
$softEdgeSize = 2.5;
$majorGridlines->setSoftEdges($softEdgeSize);
$expectedGlowColor = [
'type' => 'srgbClr',
'value' => 'FFFF00',
'alpha' => 30,
];
self::assertEquals($majorGlowSize, $majorGridlines->getGlowProperty('size'));
self::assertEquals($majorGlowSize, $majorGridlines->getGlowSize());
self::assertEquals($expectedGlowColor['value'], $majorGridlines->getGlowColor('value'));
self::assertEquals($expectedGlowColor, $majorGridlines->getGlowProperty('color'));
self::assertEquals($softEdgeSize, $majorGridlines->getSoftEdgesSize());
$minorGridlines = new GridLines();
$yAxis->setMinorGridlines($minorGridlines);
$expectedShadow = [
'effect' => 'outerShdw',
'algn' => 'tl',
'blur' => 4,
'direction' => 45,
'distance' => 3,
'rotWithShape' => 0,
'color' => [
'type' => ChartColor::EXCEL_COLOR_TYPE_STANDARD,
'value' => 'black',
'alpha' => 40,
],
];
foreach ($expectedShadow as $key => $value) {
$minorGridlines->setShadowProperty($key, $value);
}
foreach ($expectedShadow as $key => $value) {
self::assertEquals($value, $minorGridlines->getShadowProperty($key), $key);
}
$testShadow2 = $minorGridlines->getShadowArray();
self::assertNull($testShadow2['presets']);
self::assertEquals(['sx' => null, 'sy' => null, 'kx' => null, 'ky' => null], $testShadow2['size']);
unset($testShadow2['presets'], $testShadow2['size']);
self::assertEquals($expectedShadow, $testShadow2);
// Create the chart
$chart = new Chart(
'chart1', // name
$title, // title
$legend, // legend
$plotArea, // plotArea
true, // plotVisibleOnly
DataSeries::EMPTY_AS_GAP, // displayBlanksAs
null, // xAxisLabel
$yAxisLabel, // yAxisLabel
null, // xAxis
$yAxis // yAxis
);
$yAxis2 = $chart->getChartAxisY();
$majorGridlines2 = $yAxis2->getMajorGridlines();
self::assertNotNull($majorGridlines2);
self::assertEquals($majorGlowSize, $majorGridlines2->getGlowProperty('size'));
self::assertEquals($expectedGlowColor, $majorGridlines2->getGlowProperty('color'));
self::assertEquals($softEdgeSize, $majorGridlines2->getSoftEdgesSize());
$minorGridlines2 = $yAxis2->getMinorGridlines();
self::assertNotNull($minorGridlines2);
foreach ($expectedShadow as $key => $value) {
self::assertEquals($value, $minorGridlines2->getShadowProperty($key), $key);
}
// Set the position where the chart should appear in the worksheet
$chart->setTopLeftPosition('A7');
$chart->setBottomRightPosition('H20');
// Add the chart to the worksheet
$worksheet->addChart($chart);
/** @var callable */
$callableReader = [$this, 'readCharts'];
/** @var callable */
$callableWriter = [$this, 'writeCharts'];
$reloadedSpreadsheet = $this->writeAndReload($spreadsheet, 'Xlsx', $callableReader, $callableWriter);
$spreadsheet->disconnectWorksheets();
$sheet = $reloadedSpreadsheet->getActiveSheet();
$charts2 = $sheet->getChartCollection();
self::assertCount(1, $charts2);
$chart2 = $charts2[0];
self::assertNotNull($chart2);
$yAxis3 = $chart2->getChartAxisY();
$majorGridlines3 = $yAxis3->getMajorGridlines();
self::assertNotNull($majorGridlines3);
self::assertEquals($majorGlowSize, $majorGridlines3->getGlowProperty('size'));
self::assertEquals($expectedGlowColor, $majorGridlines3->getGlowProperty('color'));
self::assertEquals($softEdgeSize, $majorGridlines3->getSoftEdgesSize());
$minorGridlines3 = $yAxis3->getMinorGridlines();
self::assertNotNull($minorGridlines3);
foreach ($expectedShadow as $key => $value) {
self::assertEquals($value, $minorGridlines3->getShadowProperty($key), $key);
}
$reloadedSpreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Chart/Charts32XmlTest.php | tests/PhpSpreadsheetTests/Chart/Charts32XmlTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Chart;
use PhpOffice\PhpSpreadsheet\Chart\Properties;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx as XlsxReader;
use PhpOffice\PhpSpreadsheet\Writer\Xlsx as XlsxWriter;
use PHPUnit\Framework\TestCase;
class Charts32XmlTest extends TestCase
{
// These tests can only be performed by examining xml.
private const DIRECTORY = 'samples' . DIRECTORY_SEPARATOR . 'templates' . DIRECTORY_SEPARATOR;
#[\PHPUnit\Framework\Attributes\DataProvider('providerScatterCharts')]
public function testBezierCount(int $expectedCount, string $inputFile): void
{
$file = self::DIRECTORY . $inputFile;
$reader = new XlsxReader();
$reader->setIncludeCharts(true);
$spreadsheet = $reader->load($file);
$sheet = $spreadsheet->getActiveSheet();
$charts = $sheet->getChartCollection();
self::assertCount(1, $charts);
$chart = $charts[0];
self::assertNotNull($chart);
$writer = new XlsxWriter($spreadsheet);
$writer->setIncludeCharts(true);
$writerChart = new XlsxWriter\Chart($writer);
$data = $writerChart->writeChart($chart);
$spreadsheet->disconnectWorksheets();
self::assertSame(1, substr_count($data, '<c:scatterStyle val='));
self::assertSame($expectedCount ? 1 : 0, substr_count($data, '<c:scatterStyle val="smoothMarker"/>'));
self::assertSame($expectedCount, substr_count($data, '<c:smooth val="1"/>'));
}
public static function providerScatterCharts(): array
{
return [
'no line' => [0, '32readwriteScatterChart1.xlsx'],
'smooth line (Bezier)' => [3, '32readwriteScatterChart2.xlsx'],
'straight line' => [0, '32readwriteScatterChart3.xlsx'],
];
}
public function testAreaPercentageNoCat(): void
{
$file = self::DIRECTORY . '32readwriteAreaPercentageChart1.xlsx';
$reader = new XlsxReader();
$reader->setIncludeCharts(true);
$spreadsheet = $reader->load($file);
$sheet = $spreadsheet->getActiveSheet();
$charts = $sheet->getChartCollection();
self::assertCount(1, $charts);
$chart = $charts[0];
self::assertNotNull($chart);
$writer = new XlsxWriter($spreadsheet);
$writer->setIncludeCharts(true);
$writerChart = new XlsxWriter\Chart($writer);
$data = $writerChart->writeChart($chart);
$spreadsheet->disconnectWorksheets();
// confirm that file contains expected tags
self::assertSame(0, substr_count($data, '<c:cat>'));
}
#[\PHPUnit\Framework\Attributes\DataProvider('providerCatAxValAx')]
public function testCatAxValAx(?bool $numeric): void
{
$file = self::DIRECTORY . '32readwriteScatterChart1.xlsx';
$reader = new XlsxReader();
$reader->setIncludeCharts(true);
$spreadsheet = $reader->load($file);
$sheet = $spreadsheet->getActiveSheet();
$charts = $sheet->getChartCollection();
self::assertCount(1, $charts);
$chart = $charts[0];
self::assertNotNull($chart);
$xAxis = $chart->getChartAxisX();
$yAxis = $chart->getChartAxisY();
self::assertSame(Properties::FORMAT_CODE_GENERAL, $xAxis->getAxisNumberFormat());
if (is_bool($numeric)) {
$xAxis->setAxisNumberProperties(Properties::FORMAT_CODE_GENERAL, true);
}
self::assertSame('valAx', $yAxis->getAxisType());
self::assertSame('valAx', $xAxis->getAxisType());
self::assertSame(Properties::FORMAT_CODE_GENERAL, $yAxis->getAxisNumberFormat());
$xAxis->setAxisType('');
$yAxis->setAxisType('');
if (is_bool($numeric)) {
$xAxis->setAxisNumberProperties(Properties::FORMAT_CODE_GENERAL, $numeric);
$yAxis->setAxisNumberProperties(Properties::FORMAT_CODE_GENERAL, $numeric);
}
$writer = new XlsxWriter($spreadsheet);
$writer->setIncludeCharts(true);
$writerChart = new XlsxWriter\Chart($writer);
$data = $writerChart->writeChart($chart);
$spreadsheet->disconnectWorksheets();
if ($numeric === true) {
self::assertSame(0, substr_count($data, '<c:catAx>'));
self::assertSame(2, substr_count($data, '<c:valAx>'));
} else {
self::assertSame(1, substr_count($data, '<c:catAx>'));
self::assertSame(1, substr_count($data, '<c:valAx>'));
}
}
public static function providerCatAxValAx(): array
{
return [
[true],
[false],
[null],
];
}
public function testCatAxValAxFromRead(): void
{
$file = self::DIRECTORY . '32readwriteScatterChart1.xlsx';
$reader = new XlsxReader();
$reader->setIncludeCharts(true);
$spreadsheet = $reader->load($file);
$sheet = $spreadsheet->getActiveSheet();
$charts = $sheet->getChartCollection();
self::assertCount(1, $charts);
$chart = $charts[0];
self::assertNotNull($chart);
$xAxis = $chart->getChartAxisX();
$yAxis = $chart->getChartAxisY();
self::assertSame(Properties::FORMAT_CODE_GENERAL, $xAxis->getAxisNumberFormat());
self::assertSame('valAx', $yAxis->getAxisType());
self::assertSame('valAx', $xAxis->getAxisType());
self::assertSame(Properties::FORMAT_CODE_GENERAL, $yAxis->getAxisNumberFormat());
$writer = new XlsxWriter($spreadsheet);
$writer->setIncludeCharts(true);
$writerChart = new XlsxWriter\Chart($writer);
$data = $writerChart->writeChart($chart);
$spreadsheet->disconnectWorksheets();
self::assertSame(0, substr_count($data, '<c:catAx>'));
self::assertSame(2, substr_count($data, '<c:valAx>'));
}
public function testAreaPrstClr(): void
{
$file = self::DIRECTORY . '32readwriteAreaChart4.xlsx';
$reader = new XlsxReader();
$reader->setIncludeCharts(true);
$spreadsheet = $reader->load($file);
$sheet = $spreadsheet->getActiveSheet();
$charts = $sheet->getChartCollection();
self::assertCount(1, $charts);
$chart = $charts[0];
self::assertNotNull($chart);
$writer = new XlsxWriter($spreadsheet);
$writer->setIncludeCharts(true);
$writerChart = new XlsxWriter\Chart($writer);
$data = $writerChart->writeChart($chart);
$spreadsheet->disconnectWorksheets();
self::assertSame(
1,
substr_count(
$data,
'</c:tx><c:spPr><a:solidFill><a:prstClr val="red"/>'
)
);
}
public function testDateAx(): void
{
$file = self::DIRECTORY . '32readwriteLineDateAxisChart1.xlsx';
$reader = new XlsxReader();
$reader->setIncludeCharts(true);
$spreadsheet = $reader->load($file);
$sheet = $spreadsheet->getActiveSheet();
$charts = $sheet->getChartCollection();
self::assertCount(2, $charts);
$chart = $charts[1];
self::assertNotNull($chart);
$writer = new XlsxWriter($spreadsheet);
$writer->setIncludeCharts(true);
$writerChart = new XlsxWriter\Chart($writer);
$data = $writerChart->writeChart($chart);
$spreadsheet->disconnectWorksheets();
self::assertSame(
1,
substr_count(
$data,
'<c:baseTimeUnit val="days"/><c:majorTimeUnit val="months"/><c:minorTimeUnit val="months"/>'
)
);
self::assertSame(
1,
substr_count(
$data,
'<c:dateAx>'
)
);
self::assertSame(
1,
substr_count(
$data,
'<c:valAx>'
)
);
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Chart/RenderTest.php | tests/PhpSpreadsheetTests/Chart/RenderTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Chart;
use PhpOffice\PhpSpreadsheet\Chart\Chart;
use PHPUnit\Framework\TestCase;
class RenderTest extends TestCase
{
public function testNoRenderer(): void
{
$chart = new Chart('Chart1');
self::assertFalse($chart->render());
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Chart/ChartMethodTest.php | tests/PhpSpreadsheetTests/Chart/ChartMethodTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Chart;
use PhpOffice\PhpSpreadsheet\Chart\Axis;
use PhpOffice\PhpSpreadsheet\Chart\Chart;
use PhpOffice\PhpSpreadsheet\Chart\DataSeries;
use PhpOffice\PhpSpreadsheet\Chart\DataSeriesValues;
use PhpOffice\PhpSpreadsheet\Chart\Legend as ChartLegend;
use PhpOffice\PhpSpreadsheet\Chart\PlotArea;
use PhpOffice\PhpSpreadsheet\Chart\Title;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PHPUnit\Framework\TestCase;
class ChartMethodTest extends TestCase
{
public function testMethodVsConstructor(): void
{
$spreadsheet = new Spreadsheet();
$worksheet = $spreadsheet->getActiveSheet();
$worksheet->fromArray(
[
['', 2010, 2011, 2012],
['Q1', 12, 15, 21],
['Q2', 56, 73, 86],
['Q3', 52, 61, 69],
['Q4', 30, 32, 0],
]
);
// Set the Labels for each data series we want to plot
// Datatype
// Cell reference for data
// Format Code
// Number of datapoints in series
// Data values
// Data Marker
$dataSeriesLabels = [
new DataSeriesValues(DataSeriesValues::DATASERIES_TYPE_STRING, 'Worksheet!$B$1', null, 1), // 2010
new DataSeriesValues(DataSeriesValues::DATASERIES_TYPE_STRING, 'Worksheet!$C$1', null, 1), // 2011
new DataSeriesValues(DataSeriesValues::DATASERIES_TYPE_STRING, 'Worksheet!$D$1', null, 1), // 2012
];
// Set the X-Axis Labels
// Datatype
// Cell reference for data
// Format Code
// Number of datapoints in series
// Data values
// Data Marker
$xAxisTickValues = [
new DataSeriesValues(DataSeriesValues::DATASERIES_TYPE_STRING, 'Worksheet!$A$2:$A$5', null, 4), // Q1 to Q4
];
// Set the Data values for each data series we want to plot
// Datatype
// Cell reference for data
// Format Code
// Number of datapoints in series
// Data values
// Data Marker
$dataSeriesValues = [
new DataSeriesValues(DataSeriesValues::DATASERIES_TYPE_NUMBER, 'Worksheet!$B$2:$B$5', null, 4),
new DataSeriesValues(DataSeriesValues::DATASERIES_TYPE_NUMBER, 'Worksheet!$C$2:$C$5', null, 4),
new DataSeriesValues(DataSeriesValues::DATASERIES_TYPE_NUMBER, 'Worksheet!$D$2:$D$5', null, 4),
];
// Build the dataseries
$series = new DataSeries(
DataSeries::TYPE_LINECHART, // plotType
DataSeries::GROUPING_PERCENT_STACKED, // plotGrouping
range(0, count($dataSeriesValues) - 1), // plotOrder
$dataSeriesLabels, // plotLabel
$xAxisTickValues, // plotCategory
$dataSeriesValues // plotValues
);
// Set the series in the plot area
$plotArea = new PlotArea(null, [$series]);
$title = new Title('Method vs Constructor test');
$legend = new ChartLegend(ChartLegend::POSITION_TOPRIGHT, null, false);
$xAxis = new Axis();
$yAxis = new Axis();
$xAxisLabel = new Title('X-Axis label');
$yAxisLabel = new Title('Y-Axis label');
$chart1 = new Chart(
'chart1', // name
$title, // title
$legend, // legend
$plotArea, // plotArea
true, // plotVisibleOnly
DataSeries::EMPTY_AS_GAP, // displayBlanksAs
$xAxisLabel, // xAxisLabel
$yAxisLabel, // yAxisLabel
$xAxis, // xAxis
$yAxis // yAxis
);
$chart2 = new Chart('xyz');
$chart2
->setName('chart1')
->setLegend($legend)
->setPlotArea($plotArea)
->setPlotVisibleOnly(true)
->setDisplayBlanksAs(DataSeries::EMPTY_AS_GAP)
->setChartAxisX($xAxis)
->setChartAxisY($yAxis)
->setXAxisLabel($xAxisLabel)
->setYAxisLabel($yAxisLabel)
->setTitle($title);
self::assertEquals($chart1, $chart2);
$spreadsheet->disconnectWorksheets();
}
public function testPositions(): void
{
$chart = new Chart('chart1');
$chart->setTopLeftPosition('B3', 2, 4);
self::assertSame('B3', $chart->getTopLeftCell());
self::assertEquals(['X' => 2, 'Y' => 4], $chart->getTopLeftOffset());
self::assertEquals(2, $chart->getTopLeftXOffset());
self::assertEquals(4, $chart->getTopLeftYOffset());
$chart->setTopLeftCell('B5');
self::assertSame('B5', $chart->getTopLeftCell());
self::assertEquals(2, $chart->getTopLeftXOffset());
self::assertEquals(4, $chart->getTopLeftYOffset());
$chart->setTopLeftOffset(6, 8);
self::assertSame('B5', $chart->getTopLeftCell());
self::assertEquals(6, $chart->getTopLeftXOffset());
self::assertEquals(8, $chart->getTopLeftYOffset());
$chart->setbottomRightPosition('H9', 3, 5);
self::assertSame('H9', $chart->getBottomRightCell());
self::assertEquals(['X' => 3, 'Y' => 5], $chart->getBottomRightOffset());
self::assertEquals(3, $chart->getBottomRightXOffset());
self::assertEquals(5, $chart->getBottomRightYOffset());
$chart->setbottomRightCell('H11');
self::assertSame('H11', $chart->getBottomRightCell());
self::assertEquals(3, $chart->getBottomRightXOffset());
self::assertEquals(5, $chart->getBottomRightYOffset());
$chart->setbottomRightOffset(7, 9);
self::assertSame('H11', $chart->getBottomRightCell());
self::assertEquals(7, $chart->getBottomRightXOffset());
self::assertEquals(9, $chart->getBottomRightYOffset());
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Chart/Charts32DsvGlowTest.php | tests/PhpSpreadsheetTests/Chart/Charts32DsvGlowTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Chart;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx as XlsxReader;
use PhpOffice\PhpSpreadsheet\Writer\Xlsx as XlsxWriter;
use PhpOffice\PhpSpreadsheetTests\Functional\AbstractFunctional;
class Charts32DsvGlowTest extends AbstractFunctional
{
private const DIRECTORY = 'samples' . DIRECTORY_SEPARATOR . 'templates' . DIRECTORY_SEPARATOR;
public function readCharts(XlsxReader $reader): void
{
$reader->setIncludeCharts(true);
}
public function writeCharts(XlsxWriter $writer): void
{
$writer->setIncludeCharts(true);
}
public function testLine4(): void
{
$file = self::DIRECTORY . '32readwriteLineChart4.xlsx';
$reader = new XlsxReader();
$reader->setIncludeCharts(true);
$spreadsheet = $reader->load($file);
$sheet = $spreadsheet->getActiveSheet();
self::assertSame(1, $sheet->getChartCount());
/** @var callable */
$callableReader = [$this, 'readCharts'];
/** @var callable */
$callableWriter = [$this, 'writeCharts'];
$reloadedSpreadsheet = $this->writeAndReload($spreadsheet, 'Xlsx', $callableReader, $callableWriter);
$spreadsheet->disconnectWorksheets();
$sheet = $reloadedSpreadsheet->getActiveSheet();
$charts = $sheet->getChartCollection();
self::assertCount(1, $charts);
$chart = $charts[0];
self::assertNotNull($chart);
$plotArea = $chart->getPlotArea();
self::assertNotNull($plotArea);
$dataSeriesArray = $plotArea->getPlotGroup();
self::assertCount(1, $dataSeriesArray);
$dataSeries = $dataSeriesArray[0];
$dataSeriesValuesArray = $dataSeries->getPlotValues();
self::assertCount(3, $dataSeriesValuesArray);
$dataSeriesValues = $dataSeriesValuesArray[1];
self::assertEquals(5, $dataSeriesValues->getGlowSize());
self::assertSame('schemeClr', $dataSeriesValues->getGlowProperty(['color', 'type']));
self::assertSame('accent2', $dataSeriesValues->getGlowProperty(['color', 'value']));
self::assertSame(60, $dataSeriesValues->getGlowProperty(['color', 'alpha']));
$yAxis = $chart->getChartAxisY();
$majorGridlines = $yAxis->getMajorGridlines();
self::assertNotNull($majorGridlines);
self::assertSame('triangle', $majorGridlines->getLineStyleProperty(['arrow', 'head', 'type']));
self::assertSame('triangle', $majorGridlines->getLineStyleProperty(['arrow', 'end', 'type']));
$minorGridlines = $yAxis->getMinorGridlines();
self::assertNotNull($minorGridlines);
self::assertSame('sysDot', $minorGridlines->getLineStyleProperty('dash'));
self::assertSame('FFC000', $minorGridlines->getLineColor()->getValue());
$xAxis = $chart->getChartAxisX();
$majorGridlines = $xAxis->getMajorGridlines();
$minorGridlines = $xAxis->getMinorGridlines();
self::assertNotNull($majorGridlines);
self::assertSame('7030A0', $majorGridlines->getLineColor()->getValue());
self::assertNotNull($minorGridlines);
self::assertFalse($minorGridlines->getLineColor()->isUsable());
$reloadedSpreadsheet->disconnectWorksheets();
}
}
| 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.