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/Helper/SampleCoverageTest.php | tests/PhpSpreadsheetTests/Helper/SampleCoverageTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Helper;
use PhpOffice\PhpSpreadsheet\Helper\Sample;
use PHPUnit\Framework\TestCase;
use RuntimeException;
#[\PHPUnit\Framework\Attributes\CoversClass(Sample::class)]
class SampleCoverageTest extends TestCase
{
public function testSample(): void
{
$helper = new Sample();
$samples = $helper->getSamples();
self::assertArrayHasKey('Basic', $samples);
$basic = $samples['Basic'];
self::assertArrayHasKey('02 Types', $basic);
self::assertSame('Basic/02_Types.php', $basic['02 Types']);
self::assertSame('phpunit', $helper->getPageTitle());
self::assertSame('<h1>phpunit</h1>', $helper->getPageHeading());
}
public function testDirectoryFail(): void
{
$this->expectException(RuntimeException::class);
$helper = $this->getMockBuilder(Sample::class)
->onlyMethods(['isDirOrMkdir'])
->getMock();
$helper->expects(self::once())
->method('isDirOrMkdir')
->willReturn(false);
$helper->getFilename('a.xlsx');
}
public function testTitles(): void
{
$helper = new Sample();
ob_start();
$helper->titles('Category', 'FunctionName');
$output = (string) ob_get_clean();
$output = str_replace("\r", '', $output);
self::assertStringContainsString("Function: FunctionName()\n", $output);
ob_start();
$helper->titles('Category', 'FunctionName', 'Description');
$output = (string) ob_get_clean();
$output = str_replace("\r", '', $output);
self::assertStringContainsString("Function: FunctionName() - Description.\n", $output);
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Helper/DimensionTest.php | tests/PhpSpreadsheetTests/Helper/DimensionTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Helper;
use PhpOffice\PhpSpreadsheet\Exception;
use PhpOffice\PhpSpreadsheet\Helper\Dimension;
use PhpOffice\PhpSpreadsheet\Helper\Size;
use PHPUnit\Framework\Attributes\DataProvider;
use PHPUnit\Framework\TestCase;
class DimensionTest extends TestCase
{
#[DataProvider('providerCellWidth')]
public function testCreateDimension(float $expectedResult, string $dimension): void
{
$result = (new Dimension($dimension))->width();
self::assertSame($expectedResult, $result);
}
#[DataProvider('providerConvertUoM')]
public function testConvertDimension(float $expectedResult, string $dimension, string $unitOfMeasure): void
{
$result = (new Dimension($dimension))->toUnit($unitOfMeasure);
self::assertEqualsWithDelta($expectedResult, $result, 1.0e-12);
}
public function testSizeAndUnit(): void
{
$size = new Size('10px');
self::assertTrue($size->valid());
self::assertSame('10', $size->size());
self::assertSame('px', $size->unit());
$size = new Size('9.3');
self::assertTrue($size->valid());
self::assertSame('9.3', $size->size());
self::assertSame('pt', $size->unit());
$size = new Size('8whatever');
self::assertFalse($size->valid());
}
public function testConvertDimensionInvalidUoM(): void
{
$this->expectException(Exception::class);
$this->expectExceptionMessage('pikachu is not a vaid unit of measure');
(new Dimension('999'))->toUnit('pikachu');
}
public static function providerCellWidth(): array
{
return [
[12.0, '12'],
[2.2852, '12pt'],
[4.5703, '24 pt'],
[5.1416, '36px'],
[5.7129, '2.5pc'],
[13.7109, '2.54cm'],
[13.7109, '25.4mm'],
[13.7109, '1in'],
[4.27, '50%'],
[3.7471, '3.2em'],
[2.3419, '2ch'],
[4.6838, '4ex'],
[14.0515, '12rem'],
];
}
public static function providerConvertUoM(): array
{
return [
[60, '8.54', Dimension::UOM_PIXELS],
[100, '100px', Dimension::UOM_PIXELS],
[150, '200px', Dimension::UOM_POINTS],
[45, '8.54', Dimension::UOM_POINTS],
[12.5, '200px', Dimension::UOM_PICA],
[3.75, '8.54', Dimension::UOM_PICA],
[3.125, '300px', Dimension::UOM_INCHES],
[0.625, '8.54', Dimension::UOM_INCHES],
[7.9375, '300px', Dimension::UOM_CENTIMETERS],
[1.5875, '8.54', Dimension::UOM_CENTIMETERS],
[79.375, '300px', Dimension::UOM_MILLIMETERS],
[15.875, '8.54', Dimension::UOM_MILLIMETERS],
];
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Helper/HandlerTest.php | tests/PhpSpreadsheetTests/Helper/HandlerTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Helper;
use Exception;
use PhpOffice\PhpSpreadsheet\Helper\Handler;
use PHPUnit\Framework\TestCase;
class HandlerTest extends TestCase
{
public function testSuppressed(): void
{
self::assertTrue(Handler::suppressed());
}
public function testDeprecated(): void
{
$this->expectException(Exception::class);
$this->expectExceptionMessageMatches('/Invalid characters/');
Handler::deprecated();
}
public function testNotice(): void
{
$this->expectException(Exception::class);
$this->expectExceptionMessageMatches('/Timezone/');
Handler::notice('invalidtz');
}
public function testWarning(): void
{
$this->expectException(Exception::class);
$this->expectExceptionMessageMatches('/ailed to open stream/');
Handler::warning();
}
public function testUserDeprecated(): void
{
$this->expectException(Exception::class);
$this->expectExceptionMessageMatches('/hello/');
Handler::userDeprecated();
}
public function testUserNotice(): void
{
$this->expectException(Exception::class);
$this->expectExceptionMessageMatches('/userNotice/');
Handler::userNotice();
}
public function testUserWarning(): void
{
$this->expectException(Exception::class);
$this->expectExceptionMessageMatches('/userWarning/');
Handler::userWarning();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Helper/HtmlTest.php | tests/PhpSpreadsheetTests/Helper/HtmlTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Helper;
use DOMElement;
use PhpOffice\PhpSpreadsheet\Helper\Html;
use PHPUnit\Framework\TestCase;
class HtmlTest extends TestCase
{
#[\PHPUnit\Framework\Attributes\DataProvider('providerUtf8EncodingSupport')]
public function testUtf8EncodingSupport(string $expected, string $input): void
{
$html = new Html();
$actual = $html->toRichTextObject($input);
self::assertSame($expected, $actual->getPlainText());
}
public static function providerUtf8EncodingSupport(): array
{
return [
['foo', 'foo'],
['können', 'können'],
['русский', 'русский'],
["foo\nbar", '<p>foo</p><p>bar</p>'],
'issue2810' => ['0', '0'],
["Hello\nItem 1Item 2Goodbye", 'Hello<ul><li>Item 1</li><li>Item 2</li></ul>Goodbye'],
];
}
public function testLiTag(): void
{
$html = new Html();
$htmlBreakTag = $html->breakTag(...);
$html->addStartTagCallback('li', function (DOMElement $tag, Html $object): void {
$object->stringData .= "\u{00A0}\u{2022} \u{00A0}";
});
$html->addEndTagCallback('li', $htmlBreakTag);
$input = 'Hello<ul><li>Item 1</li><li>Item 2</li></ul>Goodbye';
$expected = "Hello\n\u{00A0}\u{2022} \u{00A0}Item 1\n\u{00A0}\u{2022} \u{00A0}Item 2\nGoodbye";
$actual = $html->toRichTextObject($input);
self::assertSame($expected, $actual->getPlainText());
}
public function testSTag(): void
{
$html = new Html();
$input = 'Hello <s>test</s>world';
$richText = $html->toRichTextObject($input);
$elements = $richText->getRichTextElements();
self::assertSame(count($elements), 3);
self::assertSame($elements[0]->getText(), 'Hello ');
self::assertNotNull($elements[0]->getFont());
self::assertFalse($elements[0]->getFont()->getStrikethrough());
self::assertSame($elements[1]->getText(), 'test');
self::assertNotNull($elements[1]->getFont());
self::assertTrue($elements[1]->getFont()->getStrikethrough());
self::assertSame($elements[2]->getText(), 'world');
self::assertNotNull($elements[2]->getFont());
self::assertFalse($elements[2]->getFont()->getStrikethrough());
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Helper/TextGridTest.php | tests/PhpSpreadsheetTests/Helper/TextGridTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Helper;
use PhpOffice\PhpSpreadsheet\Helper\TextGrid;
use PhpOffice\PhpSpreadsheet\Helper\TextGridRightAlign;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PHPUnit\Framework\Attributes\DataProvider;
use PHPUnit\Framework\TestCase;
class TextGridTest extends TestCase
{
/** @param mixed[] $expected */
#[DataProvider('providerTextGrid')]
public function testTextGrid(
bool $cli,
bool $rowDividers,
bool $rowHeaders,
bool $columnHeaders,
array $expected
): void {
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->fromArray([
[6, '=TEXT(A1,"yyyy-mm-dd hh:mm")', null, 0.572917],
['="6"', '=TEXT(A2,"yyyy-mm-dd hh:mm")', null, '1<>2'],
['xyz', '=TEXT(A3,"yyyy-mm-dd hh:mm")'],
], strictNullComparison: true);
/** @var mixed[][] */
$temp = $sheet->toArray(null, true, true, true);
$textGrid = new TextGrid(
$temp,
$cli,
rowDividers: $rowDividers,
rowHeaders: $rowHeaders,
columnHeaders: $columnHeaders
);
$result = $textGrid->render();
// Note that, for cli, string will end with PHP_EOL,
// so explode will add an extra null-string element
// to its array output.
$lines = explode(PHP_EOL, $result);
self::assertSame($expected, $lines);
$spreadsheet->disconnectWorksheets();
}
public static function providerTextGrid(): array
{
return [
'cli default values' => [
true, false, true, true,
[
' +-----+------------------+---+----------+',
' | A | B | C | D |',
'+---+-----+------------------+---+----------+',
'| 1 | 6 | 1900-01-06 00:00 | | 0.572917 |',
'| 2 | 6 | 1900-01-06 00:00 | | 1<>2 |',
'| 3 | xyz | xyz | | |',
'+---+-----+------------------+---+----------+',
'',
],
],
'html default values' => [
false, false, true, true,
[
'<pre>',
' +-----+------------------+---+----------+',
' | A | B | C | D |',
'+---+-----+------------------+---+----------+',
'| 1 | 6 | 1900-01-06 00:00 | | 0.572917 |',
'| 2 | 6 | 1900-01-06 00:00 | | 1<>2 |',
'| 3 | xyz | xyz | | |',
'+---+-----+------------------+---+----------+',
'</pre>',
],
],
'cli rowDividers' => [
true, true, true, true,
[
' +-----+------------------+---+----------+',
' | A | B | C | D |',
'+---+-----+------------------+---+----------+',
'| 1 | 6 | 1900-01-06 00:00 | | 0.572917 |',
'+---+-----+------------------+---+----------+',
'| 2 | 6 | 1900-01-06 00:00 | | 1<>2 |',
'+---+-----+------------------+---+----------+',
'| 3 | xyz | xyz | | |',
'+---+-----+------------------+---+----------+',
'',
],
],
'cli no columnHeaders' => [
true, false, true, false,
[
'+---+-----+------------------+--+----------+',
'| 1 | 6 | 1900-01-06 00:00 | | 0.572917 |',
'| 2 | 6 | 1900-01-06 00:00 | | 1<>2 |',
'| 3 | xyz | xyz | | |',
'+---+-----+------------------+--+----------+',
'',
],
],
'cli no row headers' => [
true, false, false, true,
[
'+-----+------------------+---+----------+',
'| A | B | C | D |',
'+-----+------------------+---+----------+',
'| 6 | 1900-01-06 00:00 | | 0.572917 |',
'| 6 | 1900-01-06 00:00 | | 1<>2 |',
'| xyz | xyz | | |',
'+-----+------------------+---+----------+',
'',
],
],
'cli row dividers, no row nor column headers' => [
true, true, false, false,
[
'+-----+------------------+--+----------+',
'| 6 | 1900-01-06 00:00 | | 0.572917 |',
'+-----+------------------+--+----------+',
'| 6 | 1900-01-06 00:00 | | 1<>2 |',
'+-----+------------------+--+----------+',
'| xyz | xyz | | |',
'+-----+------------------+--+----------+',
'',
],
],
];
}
public function testBool(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->fromArray([
[0, 1],
[true, false],
[true, true],
], strictNullComparison: true);
/** @var mixed[][] */
$temp = $sheet->toArray(null, true, false, true);
$textGrid = new TextGrid(
$temp,
true,
rowDividers: false,
rowHeaders: false,
columnHeaders: false,
);
$expected = [
'+------+-------+',
'| 0 | 1 |',
'| TRUE | FALSE |',
'| TRUE | TRUE |',
'+------+-------+',
'',
];
$result = $textGrid->render();
$lines = explode(PHP_EOL, $result);
self::assertSame($expected, $lines);
$spreadsheet->disconnectWorksheets();
}
public function testNumbersDefault(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->fromArray([
[0, 1, 'string1'],
[18, 13.25, 'string2'],
[100, 2.5, 'string12'],
], strictNullComparison: true);
$sheet->getStyle('B1:B3')->getNumberFormat()
->setFormatCode('0.00');
/** @var mixed[][] */
$temp = $sheet->toArray(null, true, true, true);
$textGrid = new TextGrid(
$temp,
true,
rowDividers: false,
rowHeaders: false,
columnHeaders: false,
);
$expected = [
'+-----+-------+----------+',
'| 0 | 1.00 | string1 |',
'| 18 | 13.25 | string2 |',
'| 100 | 2.50 | string12 |',
'+-----+-------+----------+',
'',
];
$result = $textGrid->render();
$lines = explode(PHP_EOL, $result);
self::assertSame($expected, $lines);
$spreadsheet->disconnectWorksheets();
}
public function testNumbersRight(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->fromArray([
[0, 1, '$1,234.56'],
[18, 13.25, 'string2'],
[100, 2.5, 'string123456'],
], strictNullComparison: true);
$sheet->getStyle('B1:B3')->getNumberFormat()
->setFormatCode('0.00');
/** @var mixed[][] */
$temp = $sheet->toArray(null, true, true, true);
$textGrid = new TextGrid(
$temp,
true,
rowDividers: false,
rowHeaders: false,
columnHeaders: false,
numbersRight: TextGridRightAlign::numeric,
);
$expected = [
'+-----+-------+--------------+',
'| 0 | 1.00 | $1,234.56 |',
'| 18 | 13.25 | string2 |',
'| 100 | 2.50 | string123456 |',
'+-----+-------+--------------+',
'',
];
$result = $textGrid->render();
$lines = explode(PHP_EOL, $result);
self::assertSame($expected, $lines);
$spreadsheet->disconnectWorksheets();
}
public function testExtendedNumbersRight(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->fromArray([
[0, 1, '$1,234.56'],
[18, 13.25, 'string2'],
[100, 2.5, 'string123456'],
], strictNullComparison: true);
$sheet->getStyle('B1:B3')->getNumberFormat()
->setFormatCode('0.00');
/** @var mixed[][] */
$temp = $sheet->toArray(null, true, true, true);
$textGrid = new TextGridExtended(
$temp,
true,
rowDividers: false,
rowHeaders: false,
columnHeaders: false,
);
$textGrid->setNumbersRight(TextGridRightAlign::numeric);
$expected = [
'+-----+-------+--------------+',
'| 0 | 1.00 | $1,234.56 |',
'| 18 | 13.25 | string2 |',
'| 100 | 2.50 | string123456 |',
'+-----+-------+--------------+',
'',
];
$result = $textGrid->render();
$lines = explode(PHP_EOL, $result);
self::assertSame($expected, $lines);
$spreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Helper/TextGridExtended.php | tests/PhpSpreadsheetTests/Helper/TextGridExtended.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Helper;
use PhpOffice\PhpSpreadsheet\Helper\TextGrid;
use PhpOffice\PhpSpreadsheet\Helper\TextGridRightAlign;
class TextGridExtended extends TextGrid
{
protected function rightAlign(string $displayCell, mixed $cell = null): bool
{
// regexp is imperfect, but good enough for test purposes
return is_int($cell) || is_float($cell) || ($this->numbersRight === TextGridRightAlign::numeric && preg_match('/^[-+$,.0-9]+$/', $displayCell));
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Helper/SampleTest.php | tests/PhpSpreadsheetTests/Helper/SampleTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Helper;
use PhpOffice\PhpSpreadsheet\Helper\Sample;
use PHPUnit\Framework\Attributes;
use PHPUnit\Framework\TestCase;
class SampleTest extends TestCase
{
private static bool $alwaysTrue = true;
#[Attributes\RunInSeparateProcess]
#[Attributes\PreserveGlobalState(false)]
#[Attributes\DataProvider('providerSample')]
public function testSample(string $sample): void
{
ob_start();
require $sample;
ob_end_clean();
self::assertTrue(self::$alwaysTrue);
}
public static function providerSample(): array
{
$skipped = [
];
// Unfortunately some tests are too long to run with code-coverage
// analysis on GitHub Actions, so we need to exclude them
/** @var string[] */
global $argv;
if (in_array('--coverage-clover', $argv)) {
$tooLongToBeCovered = [
'Basic/06_Largescale.php',
];
$skipped = array_merge($skipped, $tooLongToBeCovered);
}
$helper = new Sample();
$result = [];
foreach ($helper->getSamples() as $samples) {
foreach ($samples as $sample) {
if (!in_array($sample, $skipped)) {
$file = 'samples/' . $sample;
$result[$sample] = [$file];
}
}
}
return $result;
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Cell/StringableObject.php | tests/PhpSpreadsheetTests/Cell/StringableObject.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Cell;
class StringableObject
{
private int|string $value;
public function __construct(int|string $value = 'abc')
{
$this->value = $value;
}
public function __toString(): string
{
return (string) $this->value;
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Cell/DataValidationTest.php | tests/PhpSpreadsheetTests/Cell/DataValidationTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Cell;
use PhpOffice\PhpSpreadsheet\Cell\DataValidation;
use PHPUnit\Framework\TestCase;
class DataValidationTest extends TestCase
{
public function testNoValidation(): void
{
$dataValidation = new DataValidation();
self::assertSame('090624f04837265d79323c4a1b7e89d1', $dataValidation->getHashCode());
$dataValidation->setType(DataValidation::TYPE_CUSTOM);
self::assertSame('778f6c9e0ffcd5eaa7d8e1432d67f919', $dataValidation->getHashCode());
self::assertSame('778f6c9e0ffcd5eaa7d8e1432d67f919', $dataValidation->getHashCode(), 'getHashCode() should not have side effect');
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Cell/HyperlinkTest.php | tests/PhpSpreadsheetTests/Cell/HyperlinkTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Cell;
use PhpOffice\PhpSpreadsheet\Cell\Hyperlink;
use PHPUnit\Framework\TestCase;
class HyperlinkTest extends TestCase
{
public function testGetUrl(): void
{
$urlValue = 'https://www.example.com';
$testInstance = new Hyperlink($urlValue);
$result = $testInstance->getUrl();
self::assertEquals($urlValue, $result);
}
public function testSetUrl(): void
{
$initialUrlValue = 'https://www.example.com';
$newUrlValue = 'http://github.com/PHPOffice/PhpSpreadsheet';
$testInstance = new Hyperlink($initialUrlValue);
$testInstance->setUrl($newUrlValue);
$result = $testInstance->getUrl();
self::assertEquals($newUrlValue, $result);
}
public function testGetTooltip(): void
{
$tooltipValue = 'PhpSpreadsheet Web Site';
$testInstance = new Hyperlink('', $tooltipValue);
$result = $testInstance->getTooltip();
self::assertEquals($tooltipValue, $result);
}
public function testSetTooltip(): void
{
$initialTooltipValue = 'PhpSpreadsheet Web Site';
$newTooltipValue = 'PhpSpreadsheet Repository on Github';
$testInstance = new Hyperlink('', $initialTooltipValue);
$testInstance->setTooltip($newTooltipValue);
$result = $testInstance->getTooltip();
self::assertEquals($newTooltipValue, $result);
}
public function testIsInternal(): void
{
$initialUrlValue = 'https://www.example.com';
$newUrlValue = 'sheet://Worksheet1!A1';
$testInstance = new Hyperlink($initialUrlValue);
$result = $testInstance->isInternal();
self::assertFalse($result);
$testInstance->setUrl($newUrlValue);
$result = $testInstance->isInternal();
self::assertTrue($result);
}
public function testGetHashCode(): void
{
$url1 = 'https://www.example.com';
$tooltip1 = 'PhpSpreadsheet Web Site';
$url2 = 'https://www.example.com';
$tooltip2 = 'PhpSpreadsheet Web Site';
$url3 = 'https://www.example.com';
$tooltip3 = 'PhpSpreadsheet Web Site '; // note extra space
$hy1 = new Hyperlink($url1, $tooltip1);
$hy2 = new Hyperlink($url2, $tooltip2);
$hy3 = new Hyperlink($url3, $tooltip3);
self::assertNotSame($hy1, $hy2);
self::assertSame($hy1->getHashCode(), $hy2->getHashCode());
self::assertNotEquals($hy1->getHashCode(), $hy3->getHashCode());
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Cell/CoordinateTest.php | tests/PhpSpreadsheetTests/Cell/CoordinateTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Cell;
use PhpOffice\PhpSpreadsheet\Cell\Coordinate;
use PhpOffice\PhpSpreadsheet\Exception;
use PHPUnit\Framework\Attributes\DataProvider;
use PHPUnit\Framework\TestCase;
use TypeError;
class CoordinateTest extends TestCase
{
#[DataProvider('providerColumnString')]
public function testColumnIndexFromString(mixed $expectedResult, string $string): void
{
$columnIndex = Coordinate::columnIndexFromString($string);
self::assertEquals($expectedResult, $columnIndex);
$stringBack = Coordinate::stringFromColumnIndex($columnIndex);
self::assertEquals($stringBack, $string, 'should be able to get the original input with opposite method');
}
public static function providerColumnString(): array
{
return require 'tests/data/ColumnString.php';
}
public function testColumnIndexFromStringTooLong(): void
{
$this->expectException(Exception::class);
$this->expectExceptionMessage('Column string index can not be longer than 3 characters');
Coordinate::columnIndexFromString('ABCD');
}
public function testColumnIndexFromStringTooShort(): void
{
$this->expectException(Exception::class);
$this->expectExceptionMessage('Column string index can not be empty');
Coordinate::columnIndexFromString('');
}
#[DataProvider('providerColumnIndex')]
public function testStringFromColumnIndex(mixed $expectedResult, int $columnIndex): void
{
$string = Coordinate::stringFromColumnIndex($columnIndex);
self::assertEquals($expectedResult, $string);
$columnIndexBack = Coordinate::columnIndexFromString($string);
self::assertEquals($columnIndexBack, $columnIndex, 'should be able to get the original input with opposite method');
}
public static function providerColumnIndex(): array
{
return require 'tests/data/ColumnIndex.php';
}
#[DataProvider('providerCoordinates')]
public function testCoordinateFromString(mixed $expectedResult, string $rangeSet): void
{
$result = Coordinate::coordinateFromString($rangeSet);
self::assertEquals($expectedResult, $result);
}
public static function providerCoordinates(): array
{
return require 'tests/data/CellCoordinates.php';
}
/** @param mixed[] $expectedResult */
#[DataProvider('providerIndexesFromString')]
public function testIndexesFromString(array $expectedResult, string $rangeSet): void
{
$result = Coordinate::indexesFromString($rangeSet);
self::assertSame($expectedResult, $result);
}
public static function providerIndexesFromString(): array
{
return require 'tests/data/Cell/IndexesFromString.php';
}
public function testCoordinateFromStringWithRangeAddress(): void
{
$cellAddress = 'A1:AI2012';
try {
Coordinate::coordinateFromString($cellAddress);
} catch (\Exception $e) {
self::assertInstanceOf(Exception::class, $e);
self::assertEquals($e->getMessage(), 'Cell coordinate string can not be a range of cells');
return;
}
self::fail('An expected exception has not been raised.');
}
public function testCoordinateFromStringWithEmptyAddress(): void
{
$cellAddress = '';
try {
Coordinate::coordinateFromString($cellAddress);
} catch (\Exception $e) {
self::assertInstanceOf(Exception::class, $e);
self::assertEquals($e->getMessage(), 'Cell coordinate can not be zero-length string');
return;
}
self::fail('An expected exception has not been raised.');
}
public function testCoordinateFromStringWithInvalidAddress(): void
{
$cellAddress = 'AI';
try {
Coordinate::coordinateFromString($cellAddress);
} catch (\Exception $e) {
self::assertInstanceOf(Exception::class, $e);
self::assertEquals($e->getMessage(), 'Invalid cell coordinate ' . $cellAddress);
return;
}
self::fail('An expected exception has not been raised.');
}
#[DataProvider('providerAbsoluteCoordinates')]
public function testAbsoluteCoordinateFromString(string $expectedResult, string $rangeSet): void
{
$result = Coordinate::absoluteCoordinate($rangeSet);
self::assertEquals($expectedResult, $result);
}
public static function providerAbsoluteCoordinates(): array
{
return require 'tests/data/CellAbsoluteCoordinate.php';
}
public function testAbsoluteCoordinateFromStringWithRangeAddress(): void
{
$cellAddress = 'A1:AI2012';
try {
Coordinate::absoluteCoordinate($cellAddress);
} catch (\Exception $e) {
self::assertInstanceOf(Exception::class, $e);
self::assertEquals($e->getMessage(), 'Cell coordinate string can not be a range of cells');
return;
}
self::fail('An expected exception has not been raised.');
}
#[DataProvider('providerAbsoluteReferences')]
public function testAbsoluteReferenceFromString(mixed $expectedResult, int|string $rangeSet): void
{
$result = Coordinate::absoluteReference((string) $rangeSet);
self::assertEquals($expectedResult, $result);
}
public static function providerAbsoluteReferences(): array
{
return require 'tests/data/CellAbsoluteReference.php';
}
public function testAbsoluteReferenceFromStringWithRangeAddress(): void
{
$cellAddress = 'A1:AI2012';
try {
Coordinate::absoluteReference($cellAddress);
} catch (\Exception $e) {
self::assertInstanceOf(Exception::class, $e);
self::assertEquals($e->getMessage(), 'Cell coordinate string can not be a range of cells');
return;
}
self::fail('An expected exception has not been raised.');
}
/** @param mixed[] $expectedResult */
#[DataProvider('providerSplitRange')]
public function testSplitRange(array $expectedResult, string $rangeSet): void
{
$result = Coordinate::splitRange($rangeSet);
foreach ($result as $key => $split) {
if (!is_array($expectedResult[$key])) {
self::assertEquals($expectedResult[$key], $split[0]);
} else {
self::assertEquals($expectedResult[$key], $split);
}
}
}
public static function providerSplitRange(): array
{
return require 'tests/data/CellSplitRange.php';
}
/** @param mixed[] $rangeSets */
#[DataProvider('providerBuildRange')]
public function testBuildRange(mixed $expectedResult, array $rangeSets): void
{
$result = Coordinate::buildRange($rangeSets);
self::assertEquals($expectedResult, $result);
}
public static function providerBuildRange(): array
{
return require 'tests/data/CellBuildRange.php';
}
public function testBuildRangeInvalid(): void
{
$this->expectException(TypeError::class);
$cellRange = null;
// @phpstan-ignore-next-line
Coordinate::buildRange($cellRange);
}
public function testBuildRangeInvalid2(): void
{
$this->expectException(Exception::class);
$this->expectExceptionMessage('Range does not contain any information');
$cellRange = [];
Coordinate::buildRange($cellRange);
}
#[DataProvider('providerRangeBoundaries')]
public function testRangeBoundaries(mixed $expectedResult, string $rangeSet): void
{
$result = Coordinate::rangeBoundaries($rangeSet);
self::assertEquals($expectedResult, $result);
}
public static function providerRangeBoundaries(): array
{
return require 'tests/data/CellRangeBoundaries.php';
}
#[DataProvider('providerRangeDimension')]
public function testRangeDimension(mixed $expectedResult, string $rangeSet): void
{
$result = Coordinate::rangeDimension($rangeSet);
self::assertEquals($expectedResult, $result);
}
public static function providerRangeDimension(): array
{
return require 'tests/data/CellRangeDimension.php';
}
#[DataProvider('providerGetRangeBoundaries')]
public function testGetRangeBoundaries(mixed $expectedResult, string $rangeSet): void
{
$result = Coordinate::getRangeBoundaries($rangeSet);
self::assertEquals($expectedResult, $result);
}
public static function providerGetRangeBoundaries(): array
{
return require 'tests/data/CellGetRangeBoundaries.php';
}
#[DataProvider('providerCoordinateIsInsideRange')]
public static function testCoordinateIsInsideRange(bool $expectedResult, string $range, string $coordinate): void
{
$result = Coordinate::coordinateIsInsideRange($range, $coordinate);
self::assertEquals($result, $expectedResult);
}
public static function providerCoordinateIsInsideRange(): array
{
return require 'tests/data/Cell/CoordinateIsInsideRange.php';
}
#[DataProvider('providerCoordinateIsInsideRangeException')]
public static function testCoordinateIsInsideRangeException(string $expectedResult, string $range, string $coordinate): void
{
try {
Coordinate::coordinateIsInsideRange($range, $coordinate);
} catch (\Exception $e) {
self::assertInstanceOf(Exception::class, $e);
self::assertEquals($e->getMessage(), $expectedResult);
return;
}
self::fail('An expected exception has not been raised.');
}
public static function providerCoordinateIsInsideRangeException(): array
{
return require 'tests/data/Cell/CoordinateIsInsideRangeException.php';
}
/** @param mixed[] $expectedResult */
#[DataProvider('providerExtractAllCellReferencesInRange')]
public function testExtractAllCellReferencesInRange(array $expectedResult, string $rangeSet): void
{
$result = Coordinate::extractAllCellReferencesInRange($rangeSet);
self::assertEquals($expectedResult, $result);
}
public static function providerExtractAllCellReferencesInRange(): array
{
return require 'tests/data/CellExtractAllCellReferencesInRange.php';
}
#[DataProvider('providerInvalidRange')]
public function testExtractAllCellReferencesInRangeInvalidRange(string $range): void
{
$this->expectException(Exception::class);
$this->expectExceptionMessage('Invalid range: "' . $range . '"');
Coordinate::extractAllCellReferencesInRange($range);
}
public static function providerInvalidRange(): array
{
return [['Z1:A1'], ['A4:A1'], ['B1:A1'], ['AA1:Z1']];
}
/** @param array<string, mixed> $rangeSets */
#[DataProvider('providerMergeRangesInCollection')]
public function testMergeRangesInCollection(mixed $expectedResult, array $rangeSets): void
{
$result = Coordinate::mergeRangesInCollection($rangeSets);
self::assertEquals($expectedResult, $result);
}
public static function providerMergeRangesInCollection(): array
{
return require 'tests/data/CellMergeRangesInCollection.php';
}
#[DataProvider('providerCoordinateIsRange')]
public function testCoordinateIsRange(mixed $expectedResult, string $rangeSet): void
{
$result = Coordinate::coordinateIsRange($rangeSet);
self::assertEquals($expectedResult, $result);
}
public static function providerCoordinateIsRange(): array
{
return require 'tests/data/CoordinateIsRange.php';
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Cell/ValueBinderWithOverriddenDataTypeForValue.php | tests/PhpSpreadsheetTests/Cell/ValueBinderWithOverriddenDataTypeForValue.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Cell;
use PhpOffice\PhpSpreadsheet\Cell\DefaultValueBinder;
class ValueBinderWithOverriddenDataTypeForValue extends DefaultValueBinder
{
public static bool $called = false;
public static function dataTypeForValue(mixed $value): string
{
self::$called = true;
return parent::dataTypeForValue($value);
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Cell/StringValueBinder2Test.php | tests/PhpSpreadsheetTests/Cell/StringValueBinder2Test.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Cell;
use DateTime;
use PhpOffice\PhpSpreadsheet\Cell\Cell;
use PhpOffice\PhpSpreadsheet\Cell\DataType;
use PhpOffice\PhpSpreadsheet\Cell\IValueBinder;
use PhpOffice\PhpSpreadsheet\Cell\StringValueBinder;
use PhpOffice\PhpSpreadsheet\RichText\RichText;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PHPUnit\Framework\TestCase;
class StringValueBinder2Test extends TestCase
{
private IValueBinder $valueBinder;
protected function setUp(): void
{
$this->valueBinder = Cell::getValueBinder();
}
protected function tearDown(): void
{
Cell::setValueBinder($this->valueBinder);
}
public function testStringValueBinderIgnoredErrorsDefault(): void
{
$valueBinder = new StringValueBinder();
Cell::setValueBinder($valueBinder);
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$richText = new RichText();
$richText->createTextRun('6');
$richText2 = new RichText();
$richText2->createTextRun('a');
$sheet->fromArray([
[1, 'x', 3.2],
['y', -5, 'z'],
[new DateTime(), $richText, $richText2],
[new StringableObject('a'), new StringableObject(2), 'z'],
]);
$ignoredCells = [];
foreach ($sheet->getRowIterator() as $row) {
foreach ($row->getCellIterator() as $cell) {
$coordinate = $cell->getCoordinate();
$dataType = $cell->getDataType();
if ($dataType !== DataType::TYPE_INLINE) {
self::assertSame(DataType::TYPE_STRING, $dataType, "not string for cell $coordinate");
}
if ($cell->getIgnoredErrors()->getNumberStoredAsText()) {
$ignoredCells[] = $coordinate;
}
}
}
self::assertSame([], $ignoredCells);
$spreadsheet->disconnectWorksheets();
}
public function testStringValueBinderIgnoredErrorsTrue(): void
{
$valueBinder = new StringValueBinder();
$valueBinder->setSetIgnoredErrors(true);
Cell::setValueBinder($valueBinder);
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$richText = new RichText();
$richText->createTextRun('6');
$richText2 = new RichText();
$richText2->createTextRun('a');
$sheet->fromArray([
[1, 'x', 3.2],
['y', -5, 'z'],
[new DateTime(), $richText, $richText2],
[new StringableObject('a'), new StringableObject(2), 'z'],
]);
$ignoredCells = [];
foreach ($sheet->getRowIterator() as $row) {
foreach ($row->getCellIterator() as $cell) {
$coordinate = $cell->getCoordinate();
$dataType = $cell->getDataType();
if ($dataType !== DataType::TYPE_INLINE) {
self::assertSame(DataType::TYPE_STRING, $dataType, "not string for cell $coordinate");
}
if ($cell->getIgnoredErrors()->getNumberStoredAsText()) {
$ignoredCells[] = $coordinate;
}
}
}
self::assertSame(['A1', 'C1', 'B2', 'B3', 'B4'], $ignoredCells);
$spreadsheet->disconnectWorksheets();
}
public function testStringValueBinderPreserveNumeric(): void
{
$valueBinder = new StringValueBinder();
$valueBinder->setNumericConversion(false);
$valueBinder->setSetIgnoredErrors(true);
Cell::setValueBinder($valueBinder);
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$richText = new RichText();
$richText->createTextRun('6');
$richText2 = new RichText();
$richText2->createTextRun('a');
$sheet->fromArray([
[1, 'x', 3.2],
['y', -5, 'z'],
[new DateTime(), $richText, $richText2],
[new StringableObject('a'), new StringableObject(2), 'z'],
]);
$ignoredCells = [];
foreach ($sheet->getRowIterator() as $row) {
foreach ($row->getCellIterator() as $cell) {
$coordinate = $cell->getCoordinate();
$expected = (is_int($cell->getValue()) || is_float($cell->getValue())) ? DataType::TYPE_NUMERIC : (($cell->getValue() instanceof RichText) ? DataType::TYPE_INLINE : DataType::TYPE_STRING);
self::assertSame($expected, $cell->getDataType(), "wrong type for cell $coordinate");
if ($cell->getIgnoredErrors()->getNumberStoredAsText()) {
$ignoredCells[] = $coordinate;
}
}
}
self::assertSame(['B3', 'B4'], $ignoredCells);
$spreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Cell/StringValueBinderTest.php | tests/PhpSpreadsheetTests/Cell/StringValueBinderTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Cell;
use DateTime;
use DateTimeZone;
use PhpOffice\PhpSpreadsheet\Cell\Cell;
use PhpOffice\PhpSpreadsheet\Cell\DataType;
use PhpOffice\PhpSpreadsheet\Cell\StringValueBinder;
use PhpOffice\PhpSpreadsheet\Exception as SpreadsheetException;
use PhpOffice\PhpSpreadsheet\RichText\RichText;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PHPUnit\Framework\Attributes\DataProvider;
use PHPUnit\Framework\TestCase;
class StringValueBinderTest extends TestCase
{
private \PhpOffice\PhpSpreadsheet\Cell\IValueBinder $valueBinder;
protected function setUp(): void
{
$this->valueBinder = Cell::getValueBinder();
}
protected function tearDown(): void
{
Cell::setValueBinder($this->valueBinder);
}
#[DataProvider('providerDataValuesDefault')]
public function testStringValueBinderDefaultBehaviour(
mixed $value,
mixed $expectedValue,
string $expectedDataType
): void {
Cell::setValueBinder(new StringValueBinder());
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$cell = $sheet->getCell('A1');
$cell->setValue($value);
self::assertSame($expectedValue, $cell->getValue());
self::assertSame($expectedDataType, $cell->getDataType());
$spreadsheet->disconnectWorksheets();
}
public static function providerDataValuesDefault(): array
{
return [
[null, '', DataType::TYPE_STRING],
[true, '1', DataType::TYPE_STRING],
[false, '', DataType::TYPE_STRING],
['', '', DataType::TYPE_STRING],
['123', '123', DataType::TYPE_STRING],
['123.456', '123.456', DataType::TYPE_STRING],
['0.123', '0.123', DataType::TYPE_STRING],
['.123', '.123', DataType::TYPE_STRING],
['-0.123', '-0.123', DataType::TYPE_STRING],
['-.123', '-.123', DataType::TYPE_STRING],
['1.23e-4', '1.23e-4', DataType::TYPE_STRING],
['ABC', 'ABC', DataType::TYPE_STRING],
['=SUM(A1:C3)', '=SUM(A1:C3)', DataType::TYPE_STRING],
[123, '123', DataType::TYPE_STRING],
[123.456, '123.456', DataType::TYPE_STRING],
[0.123, '0.123', DataType::TYPE_STRING],
[.123, '0.123', DataType::TYPE_STRING],
[-0.123, '-0.123', DataType::TYPE_STRING],
[-.123, '-0.123', DataType::TYPE_STRING],
[1.23e-4, '0.000123', DataType::TYPE_STRING],
[1.23e-24, '1.23E-24', DataType::TYPE_STRING],
[new DateTime('2021-06-01 00:00:00', new DateTimeZone('UTC')), '2021-06-01 00:00:00', DataType::TYPE_STRING],
];
}
public function testNonStringableBindValue(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
Cell::setValueBinder(new StringValueBinder());
try {
$sheet->getCell('A1')->setValue($this);
self::fail('Did not receive expected Exception');
} catch (SpreadsheetException $e) {
self::assertStringContainsString('Unable to bind unstringable', $e->getMessage());
}
$sheet->getCell('A2')->setValue(new StringableObject());
self::assertSame('abc', $sheet->getCell('A2')->getValue());
try {
$sheet->getCell('A3')->setValue([1, 2, 3]);
self::fail('Did not receive expected Exception');
} catch (SpreadsheetException $e) {
self::assertStringContainsString('Unable to bind unstringable', $e->getMessage());
}
$spreadsheet->disconnectWorksheets();
}
#[DataProvider('providerDataValuesSuppressNullConversion')]
public function testStringValueBinderSuppressNullConversion(
mixed $value,
mixed $expectedValue,
string $expectedDataType
): void {
$binder = new StringValueBinder();
$binder->setNullConversion(false);
Cell::setValueBinder($binder);
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$cell = $sheet->getCell('A1');
$cell->setValue($value);
self::assertSame($expectedValue, $cell->getValue());
self::assertSame($expectedDataType, $cell->getDataType());
$spreadsheet->disconnectWorksheets();
}
public static function providerDataValuesSuppressNullConversion(): array
{
return [
[null, null, DataType::TYPE_NULL],
[true, '1', DataType::TYPE_STRING],
[123, '123', DataType::TYPE_STRING],
];
}
#[DataProvider('providerDataValuesSuppressBooleanConversion')]
public function testStringValueBinderSuppressBooleanConversion(
mixed $value,
mixed $expectedValue,
string $expectedDataType
): void {
$binder = new StringValueBinder();
$binder->setBooleanConversion(false);
Cell::setValueBinder($binder);
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$cell = $sheet->getCell('A1');
$cell->setValue($value);
self::assertSame($expectedValue, $cell->getValue());
self::assertSame($expectedDataType, $cell->getDataType());
$spreadsheet->disconnectWorksheets();
}
public static function providerDataValuesSuppressBooleanConversion(): array
{
return [
[true, true, DataType::TYPE_BOOL],
[false, false, DataType::TYPE_BOOL],
[null, '', DataType::TYPE_STRING],
[123, '123', DataType::TYPE_STRING],
];
}
#[DataProvider('providerDataValuesSuppressNumericConversion')]
public function testStringValueBinderSuppressNumericConversion(
mixed $value,
mixed $expectedValue,
string $expectedDataType
): void {
$binder = new StringValueBinder();
$binder->setNumericConversion(false);
Cell::setValueBinder($binder);
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$cell = $sheet->getCell('A1');
$cell->setValue($value);
self::assertSame($expectedValue, $cell->getValue());
self::assertSame($expectedDataType, $cell->getDataType());
$spreadsheet->disconnectWorksheets();
}
public static function providerDataValuesSuppressNumericConversion(): array
{
return [
[123, 123, DataType::TYPE_NUMERIC],
[123.456, 123.456, DataType::TYPE_NUMERIC],
[0.123, 0.123, DataType::TYPE_NUMERIC],
[.123, 0.123, DataType::TYPE_NUMERIC],
[-0.123, -0.123, DataType::TYPE_NUMERIC],
[-.123, -0.123, DataType::TYPE_NUMERIC],
[1.23e-4, 0.000123, DataType::TYPE_NUMERIC],
[1.23e-24, 1.23E-24, DataType::TYPE_NUMERIC],
[true, '1', DataType::TYPE_STRING],
[false, '', DataType::TYPE_STRING],
[null, '', DataType::TYPE_STRING],
'Issue 4766 very large positive exponent scientific notation ignored' => ['4E433', '4E433', DataType::TYPE_STRING],
'Issue 4766 very large negative exponent scientific notation ignored' => ['4E-433', '4E-433', DataType::TYPE_STRING],
'Issue 4766 small exponent scientific ignored' => ['4E4', '4E4', DataType::TYPE_STRING],
];
}
#[DataProvider('providerDataValuesSuppressFormulaConversion')]
public function testStringValueBinderSuppressFormulaConversion(
mixed $value,
mixed $expectedValue,
string $expectedDataType
): void {
$binder = new StringValueBinder();
$binder->setFormulaConversion(false);
Cell::setValueBinder($binder);
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$cell = $sheet->getCell('A1');
$cell->setValue($value);
self::assertSame($expectedValue, $cell->getValue());
self::assertSame($expectedDataType, $cell->getDataType());
if ($expectedDataType === DataType::TYPE_FORMULA) {
self::assertFalse($sheet->getStyle('A1')->getQuotePrefix());
} else {
self::assertTrue($sheet->getStyle('A1')->getQuotePrefix());
}
$spreadsheet->disconnectWorksheets();
}
public static function providerDataValuesSuppressFormulaConversion(): array
{
return [
'normal formula' => ['=SUM(A1:C3)', '=SUM(A1:C3)', DataType::TYPE_FORMULA],
'issue 1310' => ['======', '======', DataType::TYPE_STRING],
];
}
#[DataProvider('providerDataValuesSuppressAllConversion')]
public function testStringValueBinderSuppressAllConversion(
mixed $value,
mixed $expectedValue,
string $expectedDataType
): void {
$binder = new StringValueBinder();
$binder->setConversionForAllValueTypes(false);
Cell::setValueBinder($binder);
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$cell = $sheet->getCell('A1');
$cell->setValue($value);
self::assertSame($expectedValue, $cell->getValue());
self::assertSame($expectedDataType, $cell->getDataType());
$spreadsheet->disconnectWorksheets();
}
public static function providerDataValuesSuppressAllConversion(): array
{
return [
[null, null, DataType::TYPE_NULL],
[true, true, DataType::TYPE_BOOL],
[false, false, DataType::TYPE_BOOL],
['', '', DataType::TYPE_STRING],
['123', '123', DataType::TYPE_STRING],
['123.456', '123.456', DataType::TYPE_STRING],
['0.123', '0.123', DataType::TYPE_STRING],
['.123', '.123', DataType::TYPE_STRING],
['-0.123', '-0.123', DataType::TYPE_STRING],
['-.123', '-.123', DataType::TYPE_STRING],
['1.23e-4', '1.23e-4', DataType::TYPE_STRING],
['ABC', 'ABC', DataType::TYPE_STRING],
['=SUM(A1:C3)', '=SUM(A1:C3)', DataType::TYPE_FORMULA],
[123, 123, DataType::TYPE_NUMERIC],
[123.456, 123.456, DataType::TYPE_NUMERIC],
[0.123, 0.123, DataType::TYPE_NUMERIC],
[.123, 0.123, DataType::TYPE_NUMERIC],
[-0.123, -0.123, DataType::TYPE_NUMERIC],
[-.123, -0.123, DataType::TYPE_NUMERIC],
[1.23e-4, 0.000123, DataType::TYPE_NUMERIC],
[1.23e-24, 1.23E-24, DataType::TYPE_NUMERIC],
];
}
public function testStringValueBinderForRichTextObject(): void
{
$objRichText = new RichText();
$objRichText->createText('Hello World');
$binder = new StringValueBinder();
$binder->setConversionForAllValueTypes(false);
Cell::setValueBinder($binder);
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$cell = $sheet->getCell('A1');
$cell->setValue($objRichText);
self::assertSame('inlineStr', $cell->getDataType());
self::assertSame('Hello World', $cell->getCalculatedValue());
$spreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Cell/RowRangeTest.php | tests/PhpSpreadsheetTests/Cell/RowRangeTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Cell;
use PhpOffice\PhpSpreadsheet\Cell\RowRange;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PHPUnit\Framework\TestCase;
class RowRangeTest extends TestCase
{
public function testCreateRowRange(): void
{
$rowRange = new RowRange(3, 5);
self::assertSame(3, $rowRange->from());
self::assertSame(5, $rowRange->to());
self::assertSame('3:5', (string) $rowRange);
self::assertSame(3, $rowRange->rowCount());
self::assertSame('A3:XFD5', (string) $rowRange->toCellRange());
}
public function testCreateSingleRowRange(): void
{
$rowRange = new RowRange(3);
self::assertSame(3, $rowRange->from());
self::assertSame(3, $rowRange->to());
self::assertSame('3:3', (string) $rowRange);
self::assertSame(1, $rowRange->rowCount());
}
public function testCreateRowRangeWithWorksheet(): void
{
$spreadsheet = new Spreadsheet();
$worksheet = $spreadsheet->getActiveSheet();
$worksheet->setTitle("Mark's Worksheet");
$rowRange = new RowRange(3, 5, $worksheet);
self::assertSame(3, $rowRange->from());
self::assertSame(5, $rowRange->to());
self::assertSame("'Mark''s Worksheet'!3:5", (string) $rowRange);
$spreadsheet->disconnectWorksheets();
}
public function testCreateRowRangeFromArray(): void
{
$rowRange = RowRange::fromArray([3, 5]);
self::assertSame(3, $rowRange->from());
self::assertSame(5, $rowRange->to());
self::assertSame('3:5', (string) $rowRange);
self::assertSame(3, $rowRange->rowCount());
self::assertSame('A3:XFD5', (string) $rowRange->toCellRange());
}
public function testRowRangeNext(): void
{
$rowRange = new RowRange(3, 5);
$rowRangeNext = $rowRange->shiftRight(3);
self::assertSame(6, $rowRangeNext->from());
self::assertSame(8, $rowRangeNext->to());
// Check that original Row Range isn't changed
self::assertSame('3:5', (string) $rowRange);
}
public function testRowRangePrevious(): void
{
$rowRange = new RowRange(3, 5);
$rowRangeNext = $rowRange->shiftLeft();
self::assertSame(2, $rowRangeNext->from());
self::assertSame(4, $rowRangeNext->to());
// Check that original Row Range isn't changed
self::assertSame('3:5', (string) $rowRange);
}
public function testIssue4309(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$rowRange = new RowRange(1, 1);
$rowStyle = $sheet->getStyle($rowRange);
$rowStyle->applyFromArray([
'font' => ['name' => 'Arial'],
]);
$rowXf = $sheet->getRowDimension(1)->getXfIndex();
self::assertNotNull($rowXf);
self::assertSame('Arial', $spreadsheet->getCellXfByIndex($rowXf)->getFont()->getName());
$spreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Cell/DataTypeTest.php | tests/PhpSpreadsheetTests/Cell/DataTypeTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Cell;
use PhpOffice\PhpSpreadsheet\Cell\DataType;
use PhpOffice\PhpSpreadsheet\RichText\RichText;
use PHPUnit\Framework\TestCase;
class DataTypeTest extends TestCase
{
public function testGetErrorCodes(): void
{
$result = DataType::getErrorCodes();
self::assertGreaterThan(0, count($result));
self::assertArrayHasKey('#NULL!', $result);
}
public function testCheckString(): void
{
$richText = new RichText();
$result1 = DataType::checkString($richText);
self::assertSame($richText, $result1);
$stringLimit = 32767;
$randString = $this->randr($stringLimit + 10);
$result2 = DataType::checkString($randString);
self::assertIsString($result2);
self::assertSame($stringLimit, strlen($result2));
$dirtyString = "bla bla\r\n bla\r test\n";
$expected = "bla bla\n bla\n test\n";
$result3 = DataType::checkString($dirtyString);
self::assertSame($expected, $result3);
}
private function randr(int $length = 8): string
{
$string = '';
for ($i = 0; $i < $length; ++$i) {
$x = mt_rand(0, 2);
switch ($x) {
case 0:
$string .= chr(mt_rand(97, 122));
break;
case 1:
$string .= chr(mt_rand(65, 90));
break;
case 2:
$string .= chr(mt_rand(48, 57));
break;
}
}
return $string;
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Cell/CellFormulaTest.php | tests/PhpSpreadsheetTests/Cell/CellFormulaTest.php | <?php
namespace PhpOffice\PhpSpreadsheetTests\Cell;
use PhpOffice\PhpSpreadsheet\Calculation\Calculation;
use PhpOffice\PhpSpreadsheet\Cell\DataType;
use PhpOffice\PhpSpreadsheet\Exception as SpreadsheetException;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PHPUnit\Framework\TestCase;
class CellFormulaTest extends TestCase
{
public function testSetFormulaExplicit(): void
{
$formula = '=A2+B2';
$spreadsheet = new Spreadsheet();
$cell = $spreadsheet->getActiveSheet()->getCell('A1');
$cell->setValueExplicit($formula, DataType::TYPE_FORMULA);
self::assertSame($formula, $cell->getValue());
self::assertTrue($cell->isFormula());
$spreadsheet->disconnectWorksheets();
}
public function testSetFormulaDeterminedByBinder(): void
{
$formula = '=A2+B2';
$spreadsheet = new Spreadsheet();
$cell = $spreadsheet->getActiveSheet()->getCell('A1');
$cell->setValue($formula);
self::assertSame($formula, $cell->getValue());
self::assertTrue($cell->isFormula());
$spreadsheet->disconnectWorksheets();
}
public function testSetFormulaInvalidValue(): void
{
$formula = (object) true;
$spreadsheet = new Spreadsheet();
$cell = $spreadsheet->getActiveSheet()->getCell('A1');
try {
$cell->setValueExplicit($formula, DataType::TYPE_FORMULA);
self::fail('setValueExplicit should have thrown exception');
} catch (SpreadsheetException $e) {
self::assertStringContainsString('Unable to convert to string', $e->getMessage());
}
$spreadsheet->disconnectWorksheets();
}
public function testSetArrayFormulaExplicitNoArray(): void
{
$formula = '=SUM(B2:B6*C2:C6)';
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->fromArray(
[
[1, 6],
[2, 7],
[3, 8],
[4, 9],
[5, 10],
],
null,
'B2'
);
$sheet->getCell('A1')->setValueExplicit($formula, DataType::TYPE_FORMULA);
self::assertSame($formula, $sheet->getCell('A1')->getValue());
self::assertTrue($sheet->getCell('A1')->isFormula());
self::assertSame(130, $sheet->getCell('A1')->getCalculatedValue());
self::assertEmpty($sheet->getCell('A1')->getFormulaAttributes());
$spreadsheet->disconnectWorksheets();
}
public function testSetArrayFormulaExplicitWithRange(): void
{
$formula = '=SEQUENCE(3,3,-10,2.5)';
$spreadsheet = new Spreadsheet();
Calculation::getInstance($spreadsheet)->setInstanceArrayReturnType(Calculation::RETURN_ARRAY_AS_ARRAY);
$cell = $spreadsheet->getActiveSheet()->getCell('A1');
$cell->setValueExplicit($formula, DataType::TYPE_FORMULA);
self::assertSame($formula, $cell->getValue());
self::assertTrue($cell->isFormula());
$expected = [
[-10.0, -7.5, -5.0],
[-2.5, 0.0, 2.5],
[5.0, 7.5, 10.0],
];
self::assertSame($expected, $cell->getCalculatedValue());
self::assertSame(['t' => 'array', 'ref' => 'A1:C3'], $cell->getFormulaAttributes());
$spreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Cell/CellDetachTest.php | tests/PhpSpreadsheetTests/Cell/CellDetachTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Cell;
use PhpOffice\PhpSpreadsheet\Cell\Cell;
use PhpOffice\PhpSpreadsheet\Exception as SpreadsheetException;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PHPUnit\Framework\TestCase;
class CellDetachTest extends TestCase
{
private ?Spreadsheet $spreadsheet = null;
protected function tearDown(): void
{
if ($this->spreadsheet !== null) {
$this->spreadsheet->disconnectWorksheets();
$this->spreadsheet = null;
}
}
#[\PHPUnit\Framework\Attributes\DataProvider('providerMethodName')]
public function testDetach(string $method): void
{
$this->expectException(SpreadsheetException::class);
$this->expectExceptionMessage('is not bound to a worksheet');
$this->spreadsheet = new Spreadsheet();
$sheet = $this->spreadsheet->getActiveSheet();
$sheet->getCell('A1')->detach();
if (method_exists(Cell::class, $method)) {
$sheet->getCell('A1')->$method();
} else {
self::fail("Cell method $method does not exist");
}
}
public static function providerMethodName(): array
{
return [
['updateInCollection'],
['getColumn'],
['getRow'],
['hasDataValidation'],
['getDataValidation'],
['hasHyperlink'],
['getHyperlink'],
];
}
#[\PHPUnit\Framework\Attributes\DataProvider('providerMethodNameSet')]
public function testDetachSet(string $method): void
{
$this->expectException(SpreadsheetException::class);
$this->expectExceptionMessage('is not bound to a worksheet');
$this->spreadsheet = new Spreadsheet();
$sheet = $this->spreadsheet->getActiveSheet();
$sheet->getCell('A1')->detach();
if (method_exists(Cell::class, $method)) {
$sheet->getCell('A1')->$method(null);
} else {
self::fail("Cell method $method does not exist");
}
}
public static function providerMethodNameSet(): array
{
return [
['setDataValidation'],
['setHyperlink'],
['setValue'],
];
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Cell/AddressHelperTest.php | tests/PhpSpreadsheetTests/Cell/AddressHelperTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Cell;
use PhpOffice\PhpSpreadsheet\Cell\AddressHelper;
use PhpOffice\PhpSpreadsheet\Exception;
use PHPUnit\Framework\TestCase;
class AddressHelperTest extends TestCase
{
#[\PHPUnit\Framework\Attributes\DataProvider('providerR1C1ConversionToA1Absolute')]
public function testR1C1ConversionToA1Absolute(string $expectedValue, string $address): void
{
$actualValue = AddressHelper::convertToA1($address);
self::assertSame($expectedValue, $actualValue);
}
public static function providerR1C1ConversionToA1Absolute(): array
{
return require 'tests/data/Cell/R1C1ConversionToA1Absolute.php';
}
#[\PHPUnit\Framework\Attributes\DataProvider('providerR1C1ConversionToA1Relative')]
public function testR1C1ConversionToA1Relative(
string $expectedValue,
string $address,
?int $row = null,
?int $column = null
): void {
if ($row === null) {
if ($column === null) {
$actualValue = AddressHelper::convertToA1($address);
} else {
$actualValue = AddressHelper::convertToA1($address, $column);
}
} elseif ($column === null) {
$actualValue = AddressHelper::convertToA1($address, $row);
} else {
$actualValue = AddressHelper::convertToA1($address, $row, $column);
}
self::assertSame($expectedValue, $actualValue);
}
public static function providerR1C1ConversionToA1Relative(): array
{
return require 'tests/data/Cell/R1C1ConversionToA1Relative.php';
}
#[\PHPUnit\Framework\Attributes\DataProvider('providerR1C1ConversionToA1Exception')]
public function testR1C1ConversionToA1Exception(string $address): void
{
$this->expectException(Exception::class);
AddressHelper::convertToA1($address);
}
public static function providerR1C1ConversionToA1Exception(): array
{
return require 'tests/data/Cell/R1C1ConversionToA1Exception.php';
}
#[\PHPUnit\Framework\Attributes\DataProvider('providerA1ConversionToR1C1Absolute')]
public function testA1ConversionToR1C1Absolute(string $expectedValue, string $address): void
{
$actualValue = AddressHelper::convertToR1C1($address);
self::assertSame($expectedValue, $actualValue);
}
public static function providerA1ConversionToR1C1Absolute(): array
{
return require 'tests/data/Cell/A1ConversionToR1C1Absolute.php';
}
#[\PHPUnit\Framework\Attributes\DataProvider('providerA1ConversionToR1C1Relative')]
public function testA1ConversionToR1C1Relative(string $expectedValue, string $address, ?int $row = null, ?int $column = null): void
{
$actualValue = AddressHelper::convertToR1C1($address, $row, $column);
self::assertSame($expectedValue, $actualValue);
}
public static function providerA1ConversionToR1C1Relative(): array
{
return require 'tests/data/Cell/A1ConversionToR1C1Relative.php';
}
#[\PHPUnit\Framework\Attributes\DataProvider('providerA1ConversionToR1C1Exception')]
public function testA1ConversionToR1C1Exception(string $address): void
{
$this->expectException(Exception::class);
AddressHelper::convertToR1C1($address);
}
public static function providerA1ConversionToR1C1Exception(): array
{
return require 'tests/data/Cell/A1ConversionToR1C1Exception.php';
}
#[\PHPUnit\Framework\Attributes\DataProvider('providerConvertFormulaToA1FromSpreadsheetXml')]
public function testConvertFormulaToA1SpreadsheetXml(string $expectedValue, string $formula): void
{
$actualValue = AddressHelper::convertFormulaToA1($formula);
self::assertSame($expectedValue, $actualValue);
}
public static function providerConvertFormulaToA1FromSpreadsheetXml(): array
{
return require 'tests/data/Cell/ConvertFormulaToA1FromSpreadsheetXml.php';
}
#[\PHPUnit\Framework\Attributes\DataProvider('providerConvertFormulaToA1FromR1C1Absolute')]
public function testConvertFormulaToA1R1C1Absolute(string $expectedValue, string $formula): void
{
$actualValue = AddressHelper::convertFormulaToA1($formula);
self::assertSame($expectedValue, $actualValue);
}
public static function providerConvertFormulaToA1FromR1C1Absolute(): array
{
return require 'tests/data/Cell/ConvertFormulaToA1FromR1C1Absolute.php';
}
#[\PHPUnit\Framework\Attributes\DataProvider('providerConvertFormulaToA1FromR1C1Relative')]
public function testConvertFormulaToA1FromR1C1Relative(string $expectedValue, string $formula, int $row, int $column): void
{
$actualValue = AddressHelper::convertFormulaToA1($formula, $row, $column);
self::assertSame($expectedValue, $actualValue);
}
public static function providerConvertFormulaToA1FromR1C1Relative(): array
{
return require 'tests/data/Cell/ConvertFormulaToA1FromR1C1Relative.php';
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Cell/CellTest.php | tests/PhpSpreadsheetTests/Cell/CellTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Cell;
use PhpOffice\PhpSpreadsheet\Cell\AdvancedValueBinder;
use PhpOffice\PhpSpreadsheet\Cell\Cell;
use PhpOffice\PhpSpreadsheet\Cell\DataType;
use PhpOffice\PhpSpreadsheet\Cell\DefaultValueBinder;
use PhpOffice\PhpSpreadsheet\Cell\StringValueBinder;
use PhpOffice\PhpSpreadsheet\Exception;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Style\Color;
use PhpOffice\PhpSpreadsheet\Style\ConditionalFormatting\Wizard;
use PhpOffice\PhpSpreadsheet\Style\Fill;
use PhpOffice\PhpSpreadsheet\Style\Style;
use PHPUnit\Framework\Attributes\DataProvider;
use PHPUnit\Framework\TestCase;
class CellTest extends TestCase
{
private ?Spreadsheet $spreadsheet = null;
protected function setUp(): void
{
Cell::setValueBinder(new DefaultValueBinder());
}
protected function tearDown(): void
{
Cell::setValueBinder(new DefaultValueBinder());
if ($this->spreadsheet !== null) {
$this->spreadsheet->disconnectWorksheets();
$this->spreadsheet = null;
}
}
private function createSolidFillStyle(string $color): Style
{
$style = new Style(false, true);
$style->getFill()
->setFillType(Fill::FILL_SOLID)
->getStartColor()->setARGB($color);
return $style;
}
public function testSetValueBinderOverride(): void
{
$value = '12.5%';
$spreadsheet = new Spreadsheet();
$cell = $spreadsheet->getActiveSheet()->getCell('A1');
$cell->setValue($value); // Using the Default Value Binder
self::assertSame('12.5%', $cell->getValue());
self::assertSame('General', $cell->getStyle()->getNumberFormat()->getFormatCode());
$cell = $spreadsheet->getActiveSheet()->getCell('A2');
$cell->setValue($value, new AdvancedValueBinder()); // Overriding the Default Value Binder
self::assertSame(0.125, $cell->getValue());
self::assertSame('0.00%', $cell->getStyle()->getNumberFormat()->getFormatCode());
$spreadsheet->disconnectWorksheets();
}
public function testSetValueBinderOverride2(): void
{
$value = '12.5%';
$spreadsheet = new Spreadsheet();
Cell::setValueBinder(new AdvancedValueBinder());
$cell = $spreadsheet->getActiveSheet()->getCell('A1');
$cell->setValue($value); // Using the Advanced Value Binder
self::assertSame(0.125, $cell->getValue());
self::assertSame('0.00%', $cell->getStyle()->getNumberFormat()->getFormatCode());
$cell = $spreadsheet->getActiveSheet()->getCell('A2');
$cell->setValue($value, new StringValueBinder()); // Overriding the Advanced Value Binder
self::assertSame('12.5%', $cell->getValue());
self::assertSame('General', $cell->getStyle()->getNumberFormat()->getFormatCode());
$spreadsheet->disconnectWorksheets();
}
#[DataProvider('providerSetValueExplicit')]
public function testSetValueExplicit(mixed $expected, mixed $value, string $dataType): void
{
$spreadsheet = new Spreadsheet();
$cell = $spreadsheet->getActiveSheet()->getCell('A1');
$cell->setValueExplicit($value, $dataType);
self::assertSame($expected, $cell->getValue());
$spreadsheet->disconnectWorksheets();
}
public static function providerSetValueExplicit(): array
{
return require 'tests/data/Cell/SetValueExplicit.php';
}
public function testInvalidIsoDateSetValueExplicit(): void
{
$this->spreadsheet = new Spreadsheet();
$cell = $this->spreadsheet->getActiveSheet()->getCell('A1');
$dateValue = '2022-02-29'; // Invalid leap year
$this->expectException(Exception::class);
$this->expectExceptionMessage("Invalid string {$dateValue} supplied for datatype Date");
$cell->setValueExplicit($dateValue, DataType::TYPE_ISO_DATE);
}
#[DataProvider('providerSetValueExplicitException')]
public function testSetValueExplicitException(mixed $value, string $dataType, string $message): void
{
$this->expectException(Exception::class);
$this->expectExceptionMessage($message);
$this->spreadsheet = new Spreadsheet();
$cell = $this->spreadsheet->getActiveSheet()->getCell('A1');
$cell->setValueExplicit($value, $dataType);
}
public static function providerSetValueExplicitException(): array
{
return require 'tests/data/Cell/SetValueExplicitException.php';
}
public function testNoChangeToActiveSheet(): void
{
$spreadsheet = new Spreadsheet();
$sheet1 = $spreadsheet->getActiveSheet();
$sheet1->setTitle('Sheet 1');
$sheet3 = $spreadsheet->createSheet();
$sheet3->setTitle('Sheet 3');
$sheet1->setCellValue('C1', 123);
$sheet1->setCellValue('D1', 124);
$sheet3->setCellValue('A1', "='Sheet 1'!C1+'Sheet 1'!D1");
$sheet1->setCellValue('A1', "='Sheet 3'!A1");
$spreadsheet->setActiveSheetIndex(0);
self::assertSame(0, $spreadsheet->getActiveSheetIndex());
$value = $spreadsheet->getActiveSheet()->getCell('A1')->getCalculatedValue();
self::assertSame(0, $spreadsheet->getActiveSheetIndex());
self::assertSame(247, $value);
$spreadsheet->disconnectWorksheets();
}
public function testDestroyWorksheet(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$cell = $sheet->getCell('A1');
self::assertSame($sheet, $cell->getWorksheet());
$this->expectException(Exception::class);
$this->expectExceptionMessage('Worksheet no longer exists');
$spreadsheet->disconnectWorksheets();
$cell->getWorksheet();
}
public function testDestroyCell1(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$cell = $sheet->getCell('A1');
self::assertSame('A1', $cell->getCoordinate());
$this->expectException(Exception::class);
$this->expectExceptionMessage('Coordinate no longer exists');
$spreadsheet->disconnectWorksheets();
$cell->getCoordinate();
}
public function testDestroyCell2(): void
{
$this->spreadsheet = new Spreadsheet();
$sheet = $this->spreadsheet->getActiveSheet();
$cell = $sheet->getCell('A1');
self::assertSame('A1', $cell->getCoordinate());
$this->expectException(Exception::class);
$this->expectExceptionMessage('Coordinate no longer exists');
$parent = $cell->getParent();
self::assertNotNull($parent, 'Parent should not be null');
$parent->delete('A1');
$cell->getCoordinate();
}
public function testAppliedStyleWithRange(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->setCellValue('A1', -1);
$sheet->setCellValue('A2', 0);
$sheet->setCellValue('A3', 1);
$cellRange = 'A1:A3';
$sheet->getStyle($cellRange)->getFont()->setBold(true);
$yellowStyle = $this->createSolidFillStyle(Color::COLOR_YELLOW);
$greenStyle = $this->createSolidFillStyle(Color::COLOR_GREEN);
$redStyle = $this->createSolidFillStyle(Color::COLOR_RED);
$wizardFactory = new Wizard($cellRange);
/** @var Wizard\CellValue $cellWizard */
$cellWizard = $wizardFactory->newRule(Wizard::CELL_VALUE);
$conditionalStyles = [];
$cellWizard->equals(0)->setStyle($yellowStyle);
$conditionalStyles[] = $cellWizard->getConditional();
$cellWizard->greaterThan(0)->setStyle($greenStyle);
$conditionalStyles[] = $cellWizard->getConditional();
$cellWizard->lessThan(0)->setStyle($redStyle);
$conditionalStyles[] = $cellWizard->getConditional();
$sheet->getStyle($cellWizard->getCellRange())
->setConditionalStyles($conditionalStyles);
$style = $sheet->getCell('A1')->getAppliedStyle();
self::assertTrue($style->getFont()->getBold());
self::assertSame($redStyle->getFill()->getFillType(), $style->getFill()->getFillType());
self::assertSame($redStyle->getFill()->getStartColor()->getARGB(), $style->getFill()->getStartColor()->getARGB());
$style = $sheet->getCell('A2')->getAppliedStyle();
self::assertTrue($style->getFont()->getBold());
self::assertSame($yellowStyle->getFill()->getFillType(), $style->getFill()->getFillType());
self::assertSame(
$yellowStyle->getFill()->getStartColor()->getARGB(),
$style->getFill()->getStartColor()->getARGB()
);
$style = $sheet->getCell('A3')->getAppliedStyle();
self::assertTrue($style->getFont()->getBold());
self::assertSame($greenStyle->getFill()->getFillType(), $style->getFill()->getFillType());
self::assertSame(
$greenStyle->getFill()->getStartColor()->getARGB(),
$style->getFill()->getStartColor()->getARGB()
);
$spreadsheet->disconnectWorksheets();
}
#[DataProvider('appliedStylingProvider')]
public function testAppliedStyleSingleCell(string $cellAddress, string $fillStyle, ?string $fillColor): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->setCellValue('A1', -1);
$sheet->setCellValue('A2', 0);
$sheet->setCellValue('B1', 0);
$sheet->setCellValue('C1', 1);
$sheet->setCellValue('C2', -1);
$cellRange = 'A1:C2';
$sheet->getStyle($cellRange)->getFont()->setBold(true);
$yellowStyle = $this->createSolidFillStyle(Color::COLOR_YELLOW);
$redStyle = $this->createSolidFillStyle(Color::COLOR_RED);
$conditionalCellRange = 'A1:C1';
$conditionalStyles = [];
$wizardFactory = new Wizard($conditionalCellRange);
/** @var Wizard\CellValue $cellWizard */
$cellWizard = $wizardFactory->newRule(Wizard::CELL_VALUE);
$cellWizard->equals(0)->setStyle($yellowStyle);
$conditionalStyles[] = $cellWizard->getConditional();
$cellWizard->lessThan(0)->setStyle($redStyle);
$conditionalStyles[] = $cellWizard->getConditional();
$sheet->getStyle($cellWizard->getCellRange())
->setConditionalStyles($conditionalStyles);
$style = $sheet->getCell($cellAddress)->getAppliedStyle();
self::assertTrue($style->getFont()->getBold());
self::assertSame($fillStyle, $style->getFill()->getFillType());
if ($fillStyle === Fill::FILL_SOLID) {
self::assertSame($fillColor, $style->getFill()->getStartColor()->getARGB());
}
$spreadsheet->disconnectWorksheets();
}
public static function appliedStylingProvider(): array
{
return [
'A1 - Conditional with Match' => ['A1', Fill::FILL_SOLID, Color::COLOR_RED],
'A2 - No Conditionals' => ['A2', Fill::FILL_NONE, null],
'B1 - Conditional with Match' => ['B1', Fill::FILL_SOLID, Color::COLOR_YELLOW],
'C1 - Conditionals, but No Match' => ['C1', Fill::FILL_NONE, null],
'C2 - No Conditionals' => ['C2', Fill::FILL_NONE, null],
];
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Cell/SetValueExplicitCellTest.php | tests/PhpSpreadsheetTests/Cell/SetValueExplicitCellTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Cell;
use ArgumentCountError;
use PhpOffice\PhpSpreadsheet\Cell\Cell;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PHPUnit\Framework\Attributes\DataProvider;
use PHPUnit\Framework\TestCase;
use ReflectionMethod;
class SetValueExplicitCellTest extends TestCase
{
protected string $method = 'setValueExplicit';
protected int $requiredParameters = 1;
public function testRequired(): void
{
$reflectionMethod = new ReflectionMethod(Cell::class, $this->method);
$requiredParameters = $reflectionMethod->getNumberOfRequiredParameters();
self::assertSame($this->requiredParameters, $requiredParameters);
}
public static function setValueExplicitTypeArgumentProvider(): array
{
return require 'tests/data/Cell/SetValueExplicitTypeArguments.php';
}
#[DataProvider('setValueExplicitTypeArgumentProvider')]
public function testSetValueExplicitTypeArgumentHandling(
mixed $value,
?string $dataType,
mixed $expectedValue,
string $expectedDataType
): void {
$spreadsheet = new Spreadsheet();
$worksheet = $spreadsheet->getActiveSheet();
$coordinate = 'A1';
$cell = $worksheet->getCell($coordinate);
try {
if ($dataType !== null) {
$cell->{$this->method}($value, $dataType);
} else {
$cell->{$this->method}($value);
self::assertSame(1, $this->requiredParameters);
}
self::assertSame($expectedValue, $cell->getValue());
self::assertSame($expectedDataType, $cell->getDataType());
} catch (ArgumentCountError) {
self::assertSame(2, $this->requiredParameters);
self::assertNull($dataType);
}
$spreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Cell/AdvancedValueBinderTest.php | tests/PhpSpreadsheetTests/Cell/AdvancedValueBinderTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Cell;
use PhpOffice\PhpSpreadsheet\Cell\AdvancedValueBinder;
use PhpOffice\PhpSpreadsheet\Cell\Cell;
use PhpOffice\PhpSpreadsheet\Cell\DataType;
use PhpOffice\PhpSpreadsheet\Cell\IValueBinder;
use PhpOffice\PhpSpreadsheet\Settings;
use PhpOffice\PhpSpreadsheet\Shared\StringHelper;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PHPUnit\Framework\Attributes\DataProvider;
use PHPUnit\Framework\TestCase;
class AdvancedValueBinderTest extends TestCase
{
const AVB_PRECISION = 1.0E-8;
private string $originalLocale;
private IValueBinder $valueBinder;
protected function setUp(): void
{
$this->originalLocale = Settings::getLocale();
$this->valueBinder = Cell::getValueBinder();
Cell::setValueBinder(new AdvancedValueBinder());
}
protected function tearDown(): void
{
StringHelper::setCurrencyCode(null);
StringHelper::setDecimalSeparator(null);
StringHelper::setThousandsSeparator(null);
Settings::setLocale($this->originalLocale);
Cell::setValueBinder($this->valueBinder);
}
public function testNullValue(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->getCell('A1')->setValue(null);
self::assertNull($sheet->getCell('A1')->getValue());
$spreadsheet->disconnectWorksheets();
}
public function testBoolean(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->getCell('A1')->setValue(true);
self::assertTrue($sheet->getCell('A1')->getValue());
$sheet->getCell('A2')->setValue(false);
self::assertFalse($sheet->getCell('A2')->getValue());
$sheet->getCell('A3')->setValue('true');
self::assertTrue($sheet->getCell('A3')->getValue());
$sheet->getCell('A4')->setValue('false');
self::assertFalse($sheet->getCell('A4')->getValue());
$spreadsheet->disconnectWorksheets();
}
public function testBooleanLocale(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
Settings::setLocale('nl_NL');
$sheet->getCell('A1')->setValue('Waar');
self::assertTrue($sheet->getCell('A1')->getValue());
$sheet->getCell('A2')->setValue('OnWaar');
self::assertFalse($sheet->getCell('A2')->getValue());
$spreadsheet->disconnectWorksheets();
}
#[DataProvider('currencyProvider')]
public function testCurrency(string $value, float $valueBinded, string $thousandsSeparator, string $decimalSeparator, string $currencyCode): void
{
StringHelper::setCurrencyCode($currencyCode);
StringHelper::setDecimalSeparator($decimalSeparator);
StringHelper::setThousandsSeparator($thousandsSeparator);
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->getCell('A1')->setValue($value);
self::assertEquals($valueBinded, $sheet->getCell('A1')->getValue());
$spreadsheet->disconnectWorksheets();
}
public static function currencyProvider(): array
{
return [
['$10.11', 10.11, ',', '.', '$'],
['$1,010.12', 1010.12, ',', '.', '$'],
['$20,20', 20.2, '.', ',', '$'],
['$2.020,20', 2020.2, '.', ',', '$'],
['€2.020,20', 2020.2, '.', ',', '€'],
['€ 2.020,20', 2020.2, '.', ',', '€'],
['€2,020.22', 2020.22, ',', '.', '€'],
['$10.11', 10.11, ',', '.', '€'],
['€2,020.20', 2020.2, ',', '.', '$'],
'slash as group separator' => ['€2/020.20', 2020.2, '/', '.', '$'],
'slash as decimal separator' => ['€2,020/20', 2020.2, ',', '/', '$'],
['-2,020.20€', -2020.2, ',', '.', '$'],
['- 2,020.20 € ', -2020.2, ',', '.', '$'],
];
}
#[DataProvider('fractionProvider')]
public function testFractions(mixed $value, mixed $valueBinded): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->getCell('A1')->setValue($value);
self::assertEquals($valueBinded, $sheet->getCell('A1')->getValue());
$spreadsheet->disconnectWorksheets();
}
public static function fractionProvider(): array
{
return [
['1/5', 0.2],
['-1/5', -0.2],
['- 1/5', -0.2],
['12/5', 2.4],
['2/100', 0.02],
['15/12', 1.25],
['20/100', 0.2],
['1 3/5', 1.6],
['-1 3/5', -1.6],
['1 4/20', 1.2],
['1 16/20', 1.8],
['12 20/100', 12.2],
['-1 4/20', -1.2],
['407 / ', '407 / '],
['407 /', '407 /'],
['407 3/', '407 3/'],
['-407 /4', -101.75],
[' /', ' /'],
[' / ', ' / '],
];
}
#[DataProvider('percentageProvider')]
public function testPercentages(mixed $value, mixed $valueBinded): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->getCell('A1')->setValue($value);
self::assertEquals($valueBinded, $sheet->getCell('A1')->getValue());
$spreadsheet->disconnectWorksheets();
}
public static function percentageProvider(): array
{
return [
['10%', 0.1],
['-12%', -0.12],
['120%', 1.2],
['12.5%', 0.125],
['-12.5%', -0.125],
['12,345%', 123.45],
['12,345.67%', 123.4567],
];
}
#[DataProvider('timeProvider')]
public function testTimes(mixed $value, mixed $valueBinded): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->getCell('A1')->setValue($value);
self::assertEqualsWithDelta($valueBinded, $sheet->getCell('A1')->getValue(), self::AVB_PRECISION);
$spreadsheet->disconnectWorksheets();
}
public static function timeProvider(): array
{
return [
['1:20', 0.05555555556],
['09:17', 0.386805555556],
['15:00', 0.625],
['17:12:35', 0.71707175926],
['23:58:20', 0.99884259259],
];
}
#[DataProvider('stringProvider')]
public function testStringWrapping(string $value): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->getCell('A1')->setValue($value);
self::assertEquals($value, $sheet->getCell('A1')->getValue());
$spreadsheet->disconnectWorksheets();
}
public static function stringProvider(): array
{
return [
['Hello World'],
["Hello\nWorld"],
];
}
#[DataProvider('formulaProvider')]
public function testFormula(string $value, string $dataType): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->getCell('A1')->setValue($value);
self::assertSame($dataType, $sheet->getCell('A1')->getDataType());
if ($dataType === DataType::TYPE_FORMULA) {
self::assertFalse($sheet->getStyle('A1')->getQuotePrefix());
} else {
self::assertTrue($sheet->getStyle('A1')->getQuotePrefix());
}
$spreadsheet->disconnectWorksheets();
}
public static function formulaProvider(): array
{
return [
'normal formula' => ['=SUM(A1:C3)', DataType::TYPE_FORMULA],
'issue 1310' => ['======', DataType::TYPE_STRING],
];
}
#[DataProvider('nativeProvider')]
public function testNative(mixed $value, mixed $expected = null): void
{
$expected ??= $value;
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->getCell('A1')->setValue($value);
self::assertSame($expected, $sheet->getCell('A1')->getValue());
$spreadsheet->disconnectWorksheets();
}
public static function nativeProvider(): array
{
return [
'int' => [2],
'float' => [3.0],
'numeric string' => ['15', 15],
'scientific notation' => ['2.5E1', 25.0],
'issue4766 large exponent' => ['4E433'],
'issue4766 large negative exponent' => ['4E-433', 0.0],
'boolean' => [false],
'string' => ['xyz'],
];
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Cell/DataValidator2Test.php | tests/PhpSpreadsheetTests/Cell/DataValidator2Test.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Cell;
use PhpOffice\PhpSpreadsheet\Cell\DataValidation;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\Style\Conditional;
use PhpOffice\PhpSpreadsheetTests\Functional\AbstractFunctional;
class DataValidator2Test extends AbstractFunctional
{
public function testList(): void
{
$reader = new Xlsx();
$spreadsheet = $reader->load('tests/data/Reader/XLSX/issue.1432b.xlsx');
$sheet = $spreadsheet->getActiveSheet();
self::assertSame('H1', $sheet->getTopLeftCell());
self::assertSame('K3', $sheet->getSelectedCells());
$testCell = $sheet->getCell('K3');
$validation = $testCell->getDataValidation();
self::assertSame(DataValidation::TYPE_LIST, $validation->getType());
$testCell = $sheet->getCell('R2');
$validation = $testCell->getDataValidation();
self::assertSame(DataValidation::TYPE_LIST, $validation->getType());
$reloadedSpreadsheet = $this->writeAndReload($spreadsheet, 'Xlsx');
$sheet = $reloadedSpreadsheet->getActiveSheet();
$cell = 'K3';
$testCell = $sheet->getCell($cell);
$validation = $testCell->getDataValidation();
self::assertSame(DataValidation::TYPE_LIST, $validation->getType());
$testCell->setValue('Y');
self::assertTrue($testCell->hasValidValue(), 'K3 other sheet has valid value');
$testCell = $sheet->getCell($cell);
$testCell->setValue('X');
self::assertFalse($testCell->hasValidValue(), 'K3 other sheet has invalid value');
$cell = 'J2';
$testCell = $sheet->getCell($cell);
$validation = $testCell->getDataValidation();
self::assertSame(DataValidation::TYPE_LIST, $validation->getType());
$testCell = $sheet->getCell($cell);
$testCell->setValue('GBP');
self::assertTrue($testCell->hasValidValue(), 'J2 other sheet has valid value');
$testCell = $sheet->getCell($cell);
$testCell->setValue('XYZ');
self::assertFalse($testCell->hasValidValue(), 'J2 other sheet has invalid value');
$cell = 'R2';
$testCell = $sheet->getCell($cell);
$validation = $testCell->getDataValidation();
self::assertSame(DataValidation::TYPE_LIST, $validation->getType());
$testCell->setValue('ListItem2');
self::assertTrue($testCell->hasValidValue(), 'R2 same sheet has valid value');
$testCell = $sheet->getCell($cell);
$testCell->setValue('ListItem99');
self::assertFalse($testCell->hasValidValue(), 'R2 same sheet has invalid value');
$styles = $sheet->getConditionalStyles('I1:I1048576');
self::assertCount(1, $styles);
$style = $styles[0];
self::assertSame(Conditional::CONDITION_CELLIS, $style->getConditionType());
self::assertSame(Conditional::OPERATOR_BETWEEN, $style->getOperatorType());
$conditions = $style->getConditions();
self::assertSame('10', $conditions[0]);
self::assertSame('20', $conditions[1]);
self::assertSame('FF70AD47', $style->getStyle()->getFill()->getEndColor()->getARGB());
$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/Cell/CellArrayFormulaTest.php | tests/PhpSpreadsheetTests/Cell/CellArrayFormulaTest.php | <?php
namespace PhpOffice\PhpSpreadsheetTests\Cell;
use PhpOffice\PhpSpreadsheet\Calculation\Calculation;
use PhpOffice\PhpSpreadsheet\Exception;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PHPUnit\Framework\TestCase;
class CellArrayFormulaTest extends TestCase
{
private bool $skipUpdateInSpillageRange = true;
public function testSetValueArrayFormulaNoSpillage(): void
{
$spreadsheet = new Spreadsheet();
Calculation::getInstance($spreadsheet)->setInstanceArrayReturnType(Calculation::RETURN_ARRAY_AS_ARRAY);
$cell = $spreadsheet->getActiveSheet()->getCell('A1');
$cell->setValue('=MAX(ABS({5, -3; 1, -12}))');
self::assertSame(12, $cell->getCalculatedValue());
$spreadsheet->disconnectWorksheets();
}
public function testSetValueArrayFormulaWithSpillage(): void
{
$spreadsheet = new Spreadsheet();
Calculation::getInstance($spreadsheet)->setInstanceArrayReturnType(Calculation::RETURN_ARRAY_AS_ARRAY);
$cell = $spreadsheet->getActiveSheet()->getCell('A1');
$cell->setValue('=SEQUENCE(3, 3, 1, 1)');
self::assertSame([[1, 2, 3], [4, 5, 6], [7, 8, 9]], $cell->getCalculatedValue());
$spreadsheet->disconnectWorksheets();
}
public function testSetValueInSpillageRangeCell(): void
{
$spreadsheet = new Spreadsheet();
Calculation::getInstance($spreadsheet)->setInstanceArrayReturnType(Calculation::RETURN_ARRAY_AS_ARRAY);
$sheet = $spreadsheet->getActiveSheet();
$cell = $sheet->getCell('A1');
$cell->setValue('=SEQUENCE(3, 3, 1, 1)');
$cellAddress = 'C3';
$sheet->getCell($cellAddress)->setValue('x');
self::assertSame('#SPILL!', $sheet->getCell('A1')->getCalculatedValue());
self::assertSame('x', $sheet->getCell('C3')->getCalculatedValue());
$spreadsheet->disconnectWorksheets();
}
public function testUpdateValueInSpillageRangeCell(): void
{
$spreadsheet = new Spreadsheet();
Calculation::getInstance($spreadsheet)->setInstanceArrayReturnType(Calculation::RETURN_ARRAY_AS_ARRAY);
$sheet = $spreadsheet->getActiveSheet();
$sheet->getCell('A1')->setValue('=SEQUENCE(3, 3, 1, 1)');
$sheet->getCell('A1')->getCalculatedValue();
$attributes = $sheet->getCell('A1')->getFormulaAttributes();
if (!isset($attributes, $attributes['ref'])) {
self::fail('No formula attributes for cell A1');
}
$cellRange = $attributes['ref'];
$cellAddress = 'C3';
self::assertTrue($sheet->getCell($cellAddress)->isInRange($cellRange));
if ($this->skipUpdateInSpillageRange) {
$spreadsheet->disconnectWorksheets();
self::markTestIncomplete('Preventing update in spill range not yet implemented');
}
$this->expectException(Exception::class);
$this->expectExceptionMessage("Cell {$cellAddress} is within the spillage range of a formula, and cannot be changed");
$sheet->getCell($cellAddress)->setValue('PHP');
$spreadsheet->disconnectWorksheets();
}
public function testUpdateArrayFormulaForSpillageRange(): void
{
$spreadsheet = new Spreadsheet();
$calculation = Calculation::getInstance($spreadsheet);
$calculation->setInstanceArrayReturnType(Calculation::RETURN_ARRAY_AS_ARRAY);
$sheet = $spreadsheet->getActiveSheet();
$sheet->getCell('A1')->setValue('=SEQUENCE(3, 3, 1, 1)');
$sheet->getCell('A1')->getCalculatedValue();
self::assertSame([[1, 2, 3], [4, 5, 6], [7, 8, 9]], $sheet->toArray(formatData: false, reduceArrays: true));
$sheet->getCell('A1')->setValue('=SEQUENCE(2, 2, 4, -1)');
$calculation->clearCalculationCache();
$sheet->getCell('A1')->getCalculatedValue();
self::assertSame([[4, 3, null], [2, 1, null], [null, null, null]], $sheet->toArray(formatData: false, reduceArrays: true));
$cellAddress = 'C3';
$sheet->getCell($cellAddress)->setValue('PHP');
self::assertSame('PHP', $sheet->getCell($cellAddress)->getValue(), 'change cell formerly in spill range');
$spreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Cell/DataValidatorTest.php | tests/PhpSpreadsheetTests/Cell/DataValidatorTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Cell;
use PhpOffice\PhpSpreadsheet\Cell\DataValidation;
use PhpOffice\PhpSpreadsheet\NamedRange;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PHPUnit\Framework\TestCase;
class DataValidatorTest extends TestCase
{
public function testNoValidation(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$testCell = $sheet->getCell('A1');
self::assertTrue($testCell->hasValidValue(), 'a cell without any validation data is always valid');
$spreadsheet->disconnectWorksheets();
}
public function testUnsupportedType(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$testCell = $sheet->getCell('A1');
$validation = $testCell->getDataValidation();
$validation->setType(DataValidation::TYPE_CUSTOM);
$validation->setAllowBlank(true);
self::assertFalse($testCell->hasValidValue(), 'cannot assert that value is valid when the validation type is not supported');
$spreadsheet->disconnectWorksheets();
}
public function testList(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$testCell = $sheet->getCell('A1');
$validation = $testCell->getDataValidation();
$validation->setType(DataValidation::TYPE_LIST);
// blank value
$testCell->setValue('');
$validation->setAllowBlank(true);
self::assertTrue($testCell->hasValidValue(), 'cell can be empty');
$validation->setAllowBlank(false);
self::assertFalse($testCell->hasValidValue(), 'cell can not be empty');
// inline list
$validation->setFormula1('"yes,no"');
$testCell->setValue('foo');
self::assertFalse($testCell->hasValidValue(), "cell value ('foo') is not allowed");
$testCell->setValue('yes');
self::assertTrue($testCell->hasValidValue(), "cell value ('yes') has to be allowed");
// list from cells
$sheet->getCell('B1')->setValue(5);
$sheet->getCell('B2')->setValue(6);
$sheet->getCell('B3')->setValue(7);
$testCell = $sheet->getCell('A1'); // redefine $testCell, because it has broken coordinates after using other cells
$validation->setFormula1('$B$1:$B$3');
$testCell->setValue('10');
self::assertFalse($testCell->hasValidValue(), "cell value ('10') is not allowed");
$testCell = $sheet->getCell('A1'); // redefine $testCell, because it has broken coordinates after using other cells
$testCell->setValue('5');
self::assertTrue($testCell->hasValidValue(), "cell value ('5') has to be allowed");
$testCell = $sheet->getCell('A1'); // redefine $testCell, because it has broken coordinates after using other cells
$validation->setFormula1('broken : cell : coordinates');
self::assertFalse($testCell->hasValidValue(), 'invalid formula should not throw exceptions');
$spreadsheet->disconnectWorksheets();
}
public function testInvalidNumeric(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$validation = $sheet->getCell('A1')->getDataValidation();
$validation->setType(DataValidation::TYPE_WHOLE)
->setOperator(DataValidation::OPERATOR_EQUAL)
->setFormula1('broken : cell : coordinates');
$sheet->getCell('A1')->setValue(0);
self::assertFalse($sheet->getCell('A1')->hasValidValue(), 'invalid formula should return false');
$validation->setOperator('invalid operator')
->setFormula1('0');
self::assertFalse($sheet->getCell('A1')->hasValidValue(), 'invalid operator should return false');
$spreadsheet->disconnectWorksheets();
}
public function testDefinedNameAsList(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->getCell('A1')->setValue(1);
$sheet->getCell('A2')->setValue(3);
$sheet->getCell('A3')->setValue(5);
$sheet->getCell('A4')->setValue(7);
$spreadsheet->addNamedRange(new NamedRange('listvalues', $sheet, '$A$1:$A$4'));
$validation = $sheet->getCell('D4')->getDataValidation();
$validation->setType(DataValidation::TYPE_LIST)
->setFormula1('listvalues');
$sheet->getCell('D4')->setValue(2);
self::assertFalse($sheet->getCell('D4')->hasValidValue());
$sheet->getCell('D4')->setValue(3);
self::assertTrue($sheet->getCell('D4')->hasValidValue());
$spreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Cell/DefaultValueBinderTest.php | tests/PhpSpreadsheetTests/Cell/DefaultValueBinderTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Cell;
use DateTime;
use DateTimeImmutable;
use PhpOffice\PhpSpreadsheet\Cell\DataType;
use PhpOffice\PhpSpreadsheet\Cell\DefaultValueBinder;
use PhpOffice\PhpSpreadsheet\Exception as SpreadsheetException;
use PhpOffice\PhpSpreadsheet\RichText\RichText;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PHPUnit\Framework\Attributes\DataProvider;
use PHPUnit\Framework\TestCase;
class DefaultValueBinderTest extends TestCase
{
#[DataProvider('binderProvider')]
public function testBindValue(null|string|bool|int|float|DateTime|DateTimeImmutable $value): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$cell = $sheet->getCell('A1');
$binder = new DefaultValueBinder();
$result = $binder->bindValue($cell, $value);
self::assertTrue($result);
$spreadsheet->disconnectWorksheets();
}
public static function binderProvider(): array
{
return [
[null],
[''],
['ABC'],
['=SUM(A1:B2)'],
[true],
[false],
[123],
[-123.456],
['123'],
['-123.456'],
['#REF!'],
[new DateTime()],
[new DateTimeImmutable()],
['123456\n'],
];
}
public function testNonStringableBindValue(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
try {
$sheet->getCell('A1')->setValue($this);
self::fail('Did not receive expected Exception');
} catch (SpreadsheetException $e) {
self::assertStringContainsString('Unable to bind unstringable', $e->getMessage());
}
$sheet->getCell('A2')->setValue(new StringableObject());
self::assertSame('abc', $sheet->getCell('A2')->getValue());
try {
$sheet->getCell('A3')->setValue(fopen(__FILE__, 'rb'));
self::fail('Did not receive expected Exception');
} catch (SpreadsheetException $e) {
self::assertStringContainsString('Unable to bind unstringable', $e->getMessage());
}
$spreadsheet->disconnectWorksheets();
}
#[DataProvider('providerDataTypeForValue')]
public function testDataTypeForValue(mixed $expectedResult, mixed $value): void
{
$result = DefaultValueBinder::dataTypeForValue($value);
self::assertEquals($expectedResult, $result);
}
public static function providerDataTypeForValue(): array
{
return require 'tests/data/Cell/DefaultValueBinder.php';
}
public function testDataTypeForRichTextObject(): void
{
$objRichText = new RichText();
$objRichText->createText('Hello World');
$expectedResult = DataType::TYPE_INLINE;
$result = DefaultValueBinder::dataTypeForValue($objRichText);
self::assertEquals($expectedResult, $result);
}
public function testCanOverrideStaticMethodWithoutOverridingBindValue(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$cell = $sheet->getCell('A1');
$binder = new ValueBinderWithOverriddenDataTypeForValue();
self::assertFalse($binder::$called);
$binder->bindValue($cell, 123);
self::assertTrue($binder::$called);
$spreadsheet->disconnectWorksheets();
}
public function testDataTypeForValueExceptions(): void
{
try {
self::assertSame('s', DefaultValueBinder::dataTypeForValue(new SpreadsheetException()));
} catch (SpreadsheetException $e) {
self::fail('Should not have failed for stringable');
}
try {
DefaultValueBinder::dataTypeForValue([]);
self::fail('Should have failed for array');
} catch (SpreadsheetException $e) {
self::assertStringContainsString('unusable type array', $e->getMessage());
}
try {
DefaultValueBinder::dataTypeForValue(new DateTime());
self::fail('Should have failed for DateTime');
} catch (SpreadsheetException $e) {
self::assertStringContainsString('unusable type DateTime', $e->getMessage());
}
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Cell/CellRangeTest.php | tests/PhpSpreadsheetTests/Cell/CellRangeTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Cell;
use PhpOffice\PhpSpreadsheet\Cell\CellAddress;
use PhpOffice\PhpSpreadsheet\Cell\CellRange;
use PhpOffice\PhpSpreadsheet\Exception;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Worksheet\Worksheet;
use PHPUnit\Framework\TestCase;
class CellRangeTest extends TestCase
{
public function testCreateCellRange(): void
{
$from = CellAddress::fromCellAddress('B5');
$to = CellAddress::fromCellAddress('E2');
$cellRange = new CellRange($from, $to);
self::assertSame('B2:E5', (string) $cellRange);
}
public function testCreateCellRangeWithWorksheet(): void
{
$spreadsheet = new Spreadsheet();
$worksheet = $spreadsheet->getActiveSheet();
$worksheet->setTitle("Mark's Worksheet");
$from = CellAddress::fromCellAddress('B5', $worksheet);
$to = CellAddress::fromCellAddress('E2');
$cellRange = new CellRange($from, $to);
self::assertSame("'Mark''s Worksheet'!B2:E5", (string) $cellRange);
}
public function testCreateCellRangeWithWorksheets(): void
{
$spreadsheet = new Spreadsheet();
$worksheet = $spreadsheet->getActiveSheet();
$worksheet->setTitle("Mark's Worksheet");
$from = CellAddress::fromCellAddress('B5', $worksheet);
$to = CellAddress::fromCellAddress('E2', $worksheet);
$cellRange = new CellRange($from, $to);
self::assertSame("'Mark''s Worksheet'!B2:E5", (string) $cellRange);
}
public function testSingleCellRange(): void
{
$from = CellAddress::fromCellAddress('C3');
$to = CellAddress::fromCellAddress('C3');
$cellRange = new CellRange($from, $to);
self::assertSame('C3', (string) $cellRange);
}
public function testSingleCellRangeWithWorksheet(): void
{
$spreadsheet = new Spreadsheet();
$worksheet = $spreadsheet->getActiveSheet();
$worksheet->setTitle("Mark's Worksheet");
$from = CellAddress::fromCellAddress('C3', $worksheet);
$to = CellAddress::fromCellAddress('C3');
$cellRange = new CellRange($from, $to);
self::assertSame("'Mark''s Worksheet'!C3", (string) $cellRange);
}
public function testRangeFrom(): void
{
$from = CellAddress::fromCellAddress('B5');
$to = CellAddress::fromCellAddress('E2');
$cellRange = new CellRange($from, $to);
self::assertSame('B2', (string) $cellRange->from());
}
public function testRangeTo(): void
{
$from = CellAddress::fromCellAddress('B5');
$to = CellAddress::fromCellAddress('E2');
$cellRange = new CellRange($from, $to);
self::assertSame('E5', (string) $cellRange->to());
}
public function testCreateCellRangeWithMismatchedWorksheets(): void
{
$spreadsheet = new Spreadsheet();
$worksheet = $spreadsheet->getActiveSheet();
$worksheet->setTitle("Mark's Worksheet");
$secondWorksheet = new Worksheet($spreadsheet, 'A Second Worksheet');
$this->expectException(Exception::class);
$this->expectExceptionMessage('3d Cell Ranges are not supported');
$from = CellAddress::fromCellAddress('B5', $worksheet);
$to = CellAddress::fromCellAddress('E2', $secondWorksheet);
new CellRange($from, $to);
}
public function testCreateCellRangeWithMismatchedSpreadsheets(): void
{
$spreadsheet1 = new Spreadsheet();
$worksheet1 = $spreadsheet1->getActiveSheet();
$worksheet1->setTitle("Mark's Worksheet");
$spreadsheet2 = new Spreadsheet();
$worksheet2 = $spreadsheet2->getActiveSheet();
$worksheet2->setTitle("Mark's Worksheet");
$this->expectException(Exception::class);
$this->expectExceptionMessage('Worksheets must be in the same spreadsheet');
$from = CellAddress::fromCellAddress('B5', $worksheet1);
$to = CellAddress::fromCellAddress('E2', $worksheet2);
new CellRange($from, $to);
}
public function testShiftRangeTo(): void
{
$from = CellAddress::fromCellAddress('B5');
$to = CellAddress::fromCellAddress('E2');
$cellRange = new CellRange($from, $to);
self::assertSame('B2:E5', (string) $cellRange);
$cellRange->to()
->nextColumn(2)
->nextRow(2);
self::assertSame('B2', (string) $cellRange->from());
self::assertSame('G7', (string) $cellRange->to());
self::assertSame('B2:G7', (string) $cellRange);
$cellRange->to()
->previousColumn()
->previousRow();
self::assertSame('B2', (string) $cellRange->from());
self::assertSame('F6', (string) $cellRange->to());
self::assertSame('B2:F6', (string) $cellRange);
}
public function testShiftRangeFrom(): void
{
$from = CellAddress::fromCellAddress('B5');
$to = CellAddress::fromCellAddress('E2');
$cellRange = new CellRange($from, $to);
self::assertSame('B2:E5', (string) $cellRange);
$cellRange->from()
->nextColumn(5)
->nextRow(5);
self::assertSame('E5', (string) $cellRange->from());
self::assertSame('G7', (string) $cellRange->to());
self::assertSame('E5:G7', (string) $cellRange);
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Cell/DataType2Test.php | tests/PhpSpreadsheetTests/Cell/DataType2Test.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Cell;
use PhpOffice\PhpSpreadsheet\Cell\DataType;
use PhpOffice\PhpSpreadsheet\Exception as PhpSpreadsheetException;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PHPUnit\Framework\TestCase;
class DataType2Test extends TestCase
{
public function testSetDataType(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->getCell('A1')->setValue(28.1);
self::assertSame(28.1, $sheet->getCell('A1')->getValue());
self::assertSame('28.1', (string) $sheet->getCell('A1'));
$sheet->getCell('A1')->setDataType(DataType::TYPE_STRING);
self::assertSame('28.1', $sheet->getCell('A1')->getValue());
$sheet->getCell('A1')->setDataType(DataType::TYPE_NUMERIC);
self::assertSame(28.1, $sheet->getCell('A1')->getValue());
$sheet->getCell('A1')->setDataType(DataType::TYPE_STRING2);
self::assertSame('28.1', $sheet->getCell('A1')->getValue());
$sheet->getCell('A1')->setDataType(DataType::TYPE_INLINE);
self::assertSame('28.1', $sheet->getCell('A1')->getValue());
$sheet->getCell('A1')->setDataType(DataType::TYPE_BOOL);
self::assertTrue($sheet->getCell('A1')->getValue());
$sheet->getCell('A1')->setDataType(DataType::TYPE_NUMERIC);
self::assertSame(1, $sheet->getCell('A1')->getValue());
$sheet->getCell('A2')->setValue('X');
try {
$sheet->getCell('A2')->setDataType(DataType::TYPE_NUMERIC);
} catch (PhpSpreadsheetException $e) {
self::assertSame('Invalid numeric value for datatype Numeric', $e->getMessage());
}
$spreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Cell/ConvertSpecialArrayTest.php | tests/PhpSpreadsheetTests/Cell/ConvertSpecialArrayTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Cell;
use PhpOffice\PhpSpreadsheet\Cell\Cell;
use PHPUnit\Framework\Attributes\DataProvider;
use PHPUnit\Framework\TestCase;
use ReflectionMethod;
class ConvertSpecialArrayTest extends TestCase
{
/**
* @param mixed[] $expected
* @param mixed[] $inArray
*/
#[DataProvider('providerSpecialArrays')]
public function testConvertSpecialArray(array $expected, array $inArray): void
{
$reflectionMethod = new ReflectionMethod(Cell::class, 'convertSpecialArray');
$result = $reflectionMethod->invokeArgs(null, [$inArray]);
self::assertSame($expected, $result);
}
public static function providerSpecialArrays(): array
{
return [
'expected form row index to array indexed by column' => [
[
[1, 2],
[3, 4],
],
[
1 => ['A' => 1, 'B' => 2],
2 => ['A' => 3, 'B' => 4],
],
],
'standard array unchanged' => [
[
1 => [1, 2],
2 => [3, 4],
],
[
1 => [1, 2],
2 => [3, 4],
],
],
'uses index 0 so unchanged' => [
[
['A' => 1, 'B' => 2],
['A' => 3, 'B' => 4],
],
[
['A' => 1, 'B' => 2],
['A' => 3, 'B' => 4],
],
],
];
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Cell/DataValidator3Test.php | tests/PhpSpreadsheetTests/Cell/DataValidator3Test.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Cell;
use PhpOffice\PhpSpreadsheet\Calculation\Calculation;
use PhpOffice\PhpSpreadsheet\Cell\DataValidation;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PHPUnit\Framework\TestCase;
class DataValidator3Test extends TestCase
{
public function testArrayFunctionAsList(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->getCell('A1')->setValue(1);
$sheet->getCell('A2')->setValue(3);
$sheet->getCell('A3')->setValue(5);
$sheet->getCell('A4')->setValue(7);
Calculation::getInstance($spreadsheet)
->setInstanceArrayReturnType(
Calculation::RETURN_ARRAY_AS_ARRAY
);
$sheet->getCell('G1')->setValue('=UNIQUE(A1:A4)');
$validation = $sheet->getCell('H4')->getDataValidation();
$validation->setType(DataValidation::TYPE_LIST)
->setFormula1('ANCHORARRAY(G1)');
$sheet->getCell('H4')->setValue(2);
self::assertFalse($sheet->getCell('H4')->hasValidValue());
$sheet->getCell('H4')->setValue(3);
self::assertTrue($sheet->getCell('H4')->hasValidValue());
$spreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Cell/CellAddressTest.php | tests/PhpSpreadsheetTests/Cell/CellAddressTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Cell;
use PhpOffice\PhpSpreadsheet\Cell\CellAddress;
use PhpOffice\PhpSpreadsheet\Exception;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PHPUnit\Framework\Attributes\DataProvider;
use PHPUnit\Framework\TestCase;
class CellAddressTest extends TestCase
{
#[DataProvider('providerCreateFromCellAddress')]
public function testCreateFromCellAddress(
string $cellAddress,
string $expectedColumnName,
int $expectedColumnId,
int $expectedRowId
): void {
$cellAddressObject = CellAddress::fromCellAddress($cellAddress);
self::assertSame($cellAddress, (string) $cellAddressObject);
self::assertSame($cellAddress, $cellAddressObject->cellAddress());
self::assertSame($expectedRowId, $cellAddressObject->rowId());
self::assertSame($expectedColumnId, $cellAddressObject->columnId());
self::assertSame($expectedColumnName, $cellAddressObject->columnName());
}
public static function providerCreateFromCellAddress(): array
{
return [
['A1', 'A', 1, 1],
['C5', 'C', 3, 5],
['IV256', 'IV', 256, 256],
];
}
#[DataProvider('providerCreateFromCellAddressException')]
public function testCreateFromCellAddressException(string $cellAddress): void
{
$this->expectException(Exception::class);
$this->expectExceptionMessage(
$cellAddress === ''
? 'Cell coordinate can not be zero-length string'
: "Invalid cell coordinate {$cellAddress}"
);
CellAddress::fromCellAddress($cellAddress);
}
public static function providerCreateFromCellAddressException(): array
{
return [
['INVALID'],
[''],
['IV'],
['12'],
];
}
#[DataProvider('providerCreateFromColumnAndRow')]
public function testCreateFromColumnAndRow(
int $columnId,
int $rowId,
string $expectedCellAddress,
string $expectedColumnName
): void {
$cellAddressObject = CellAddress::fromColumnAndRow($columnId, $rowId);
self::assertSame($expectedCellAddress, (string) $cellAddressObject);
self::assertSame($expectedCellAddress, $cellAddressObject->cellAddress());
self::assertSame($rowId, $cellAddressObject->rowId());
self::assertSame($columnId, $cellAddressObject->columnId());
self::assertSame($expectedColumnName, $cellAddressObject->columnName());
}
#[DataProvider('providerCreateFromColumnRowException')]
public function testCreateFromColumnRowException(int|string $columnId, int|string $rowId): void
{
$this->expectException(Exception::class);
$this->expectExceptionMessage('Row and Column Ids must be positive integer values');
CellAddress::fromColumnAndRow($columnId, $rowId);
}
public static function providerCreateFromColumnAndRow(): array
{
return [
[1, 1, 'A1', 'A'],
[3, 5, 'C5', 'C'],
[256, 256, 'IV256', 'IV'],
];
}
#[DataProvider('providerCreateFromColumnRowArray')]
public function testCreateFromColumnRowArray(
int $columnId,
int $rowId,
string $expectedCellAddress,
string $expectedColumnName
): void {
$columnRowArray = [$columnId, $rowId];
$cellAddressObject = CellAddress::fromColumnRowArray($columnRowArray);
self::assertSame($expectedCellAddress, (string) $cellAddressObject);
self::assertSame($expectedCellAddress, $cellAddressObject->cellAddress());
self::assertSame($rowId, $cellAddressObject->rowId());
self::assertSame($columnId, $cellAddressObject->columnId());
self::assertSame($expectedColumnName, $cellAddressObject->columnName());
}
public static function providerCreateFromColumnRowArray(): array
{
return [
[1, 1, 'A1', 'A'],
[3, 5, 'C5', 'C'],
[256, 256, 'IV256', 'IV'],
];
}
#[DataProvider('providerCreateFromColumnRowException')]
public function testCreateFromColumnRowArrayException(mixed $columnId, mixed $rowId): void
{
$this->expectException(Exception::class);
$this->expectExceptionMessage('Row and Column Ids must be positive integer values');
$columnRowArray = [$columnId, $rowId];
// Phpstan is right to complain about next line, but we need to test it anyhow
CellAddress::fromColumnRowArray($columnRowArray); //* @phpstan-ignore-line
}
public static function providerCreateFromColumnRowException(): array
{
return [
[-1, 1],
[3, 'A'],
];
}
#[DataProvider('providerCreateFromCellAddressWithWorksheet')]
public function testCreateFromCellAddressWithWorksheet(
string $cellAddress,
string $expectedCellAddress,
string $expectedColumnName,
int $expectedColumnId,
int $expectedRowId
): void {
$spreadsheet = new Spreadsheet();
$worksheet = $spreadsheet->getActiveSheet();
$worksheet->setTitle("Mark's Worksheet");
$cellAddressObject = CellAddress::fromCellAddress($cellAddress, $worksheet);
self::assertSame($expectedCellAddress, (string) $cellAddressObject);
self::assertSame($cellAddress, $cellAddressObject->cellAddress());
self::assertSame($expectedRowId, $cellAddressObject->rowId());
self::assertSame($expectedColumnId, $cellAddressObject->columnId());
self::assertSame($expectedColumnName, $cellAddressObject->columnName());
}
public static function providerCreateFromCellAddressWithWorksheet(): array
{
return [
['A1', "'Mark''s Worksheet'!A1", 'A', 1, 1],
['C5', "'Mark''s Worksheet'!C5", 'C', 3, 5],
['IV256', "'Mark''s Worksheet'!IV256", 'IV', 256, 256],
];
}
public function testNextRow(): void
{
$cellAddress = CellAddress::fromCellAddress('C5');
// default single row
$cellAddressC6 = $cellAddress->nextRow();
self::assertSame('C6', (string) $cellAddressC6);
// multiple rows
$cellAddressC9 = $cellAddress->nextRow(4);
self::assertSame('C9', (string) $cellAddressC9);
// negative rows
$cellAddressC3 = $cellAddress->nextRow(-2);
self::assertSame('C3', (string) $cellAddressC3);
// negative beyond the minimum
$cellAddressC1 = $cellAddress->nextRow(-10);
self::assertSame('C1', (string) $cellAddressC1);
// Check that the original object is still unchanged
self::assertSame('C5', (string) $cellAddress);
}
public function testPreviousRow(): void
{
$cellAddress = CellAddress::fromCellAddress('C5');
// default single row
$cellAddressC4 = $cellAddress->previousRow();
self::assertSame('C4', (string) $cellAddressC4);
}
public function testNextColumn(): void
{
$cellAddress = CellAddress::fromCellAddress('C5');
// default single row
$cellAddressD5 = $cellAddress->nextColumn();
self::assertSame('D5', (string) $cellAddressD5);
// multiple rows
$cellAddressG5 = $cellAddress->nextColumn(4);
self::assertSame('G5', (string) $cellAddressG5);
// negative rows
$cellAddressB5 = $cellAddress->nextColumn(-1);
self::assertSame('B5', (string) $cellAddressB5);
// negative beyond the minimum
$cellAddressA5 = $cellAddress->nextColumn(-10);
self::assertSame('A5', (string) $cellAddressA5);
// Check that the original object is still unchanged
self::assertSame('C5', (string) $cellAddress);
}
public function testPreviousColumn(): void
{
$cellAddress = CellAddress::fromCellAddress('C5');
// default single row
$cellAddressC4 = $cellAddress->previousColumn();
self::assertSame('B5', (string) $cellAddressC4);
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Cell/ColumnRangeTest.php | tests/PhpSpreadsheetTests/Cell/ColumnRangeTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Cell;
use PhpOffice\PhpSpreadsheet\Cell\ColumnRange;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PHPUnit\Framework\TestCase;
class ColumnRangeTest extends TestCase
{
public function testCreateColumnRange(): void
{
$columnRange = new ColumnRange('C', 'E');
self::assertSame('C', $columnRange->from());
self::assertSame('E', $columnRange->to());
self::assertSame(3, $columnRange->fromIndex());
self::assertSame(5, $columnRange->toIndex());
self::assertSame('C:E', (string) $columnRange);
self::assertSame(3, $columnRange->columnCount());
self::assertSame('C1:E1048576', (string) $columnRange->toCellRange());
}
public function testCreateSingleColumnRange(): void
{
$columnRange = new ColumnRange('E');
self::assertSame('E', $columnRange->from());
self::assertSame('E', $columnRange->to());
self::assertSame('E:E', (string) $columnRange);
self::assertSame(1, $columnRange->columnCount());
self::assertSame('E1:E1048576', (string) $columnRange->toCellRange());
}
public function testCreateColumnRangeWithWorksheet(): void
{
$spreadsheet = new Spreadsheet();
$worksheet = $spreadsheet->getActiveSheet();
$worksheet->setTitle("Mark's Worksheet");
$columnRange = new ColumnRange('C', 'E', $worksheet);
self::assertSame('C', $columnRange->from());
self::assertSame('E', $columnRange->to());
self::assertSame("'Mark''s Worksheet'!C:E", (string) $columnRange);
self::assertSame("'Mark''s Worksheet'!C1:E1048576", (string) $columnRange->toCellRange());
$spreadsheet->disconnectWorksheets();
}
public function testCreateColumnRangeFromArray(): void
{
$columnRange = ColumnRange::fromArray(['C', 'E']);
self::assertSame('C', $columnRange->from());
self::assertSame('E', $columnRange->to());
self::assertSame('C:E', (string) $columnRange);
self::assertSame(3, $columnRange->columnCount());
self::assertSame('C1:E1048576', (string) $columnRange->toCellRange());
}
public function testCreateColumnRangeFromIndexes(): void
{
$columnRange = ColumnRange::fromColumnIndexes(3, 5);
self::assertSame('C', $columnRange->from());
self::assertSame('E', $columnRange->to());
self::assertSame('C:E', (string) $columnRange);
self::assertSame(3, $columnRange->columnCount());
self::assertSame('C1:E1048576', (string) $columnRange->toCellRange());
}
public function testColumnRangeNext(): void
{
$columnRange = new ColumnRange('C', 'E');
$columnRangeNext = $columnRange->shiftDown(3);
self::assertSame('F', $columnRangeNext->from());
self::assertSame('H', $columnRangeNext->to());
// Check that original Column Range isn't changed
self::assertSame('C:E', (string) $columnRange);
}
public function testColumnRangePrevious(): void
{
$columnRange = new ColumnRange('C', 'E');
$columnRangeNext = $columnRange->shiftUp();
self::assertSame('B', $columnRangeNext->from());
self::assertSame('D', $columnRangeNext->to());
// Check that original Column Range isn't changed
self::assertSame('C:E', (string) $columnRange);
}
public function testIssue4309(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$columnRange = new ColumnRange('A', 'A');
$columnStyle = $sheet->getStyle($columnRange);
$columnStyle->applyFromArray([
'font' => ['bold' => true],
]);
$columnXf = $sheet->getColumnDimension('A')->getXfIndex();
self::assertNotNull($columnXf);
self::assertTrue(
$spreadsheet->getCellXfByIndex($columnXf)
->getFont()->getBold()
);
$spreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Features/AutoFilter/Xlsx/BasicLoadTest.php | tests/PhpSpreadsheetTests/Features/AutoFilter/Xlsx/BasicLoadTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Features\AutoFilter\Xlsx;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\Worksheet\AutoFilter\Column\Rule;
use PhpOffice\PhpSpreadsheet\Worksheet\Table;
use PHPUnit\Framework\TestCase;
class BasicLoadTest extends TestCase
{
public function testLoadAutoFilter(): void
{
$filename = 'tests/data/Features/AutoFilter/Xlsx/AutoFilter_Basic.xlsx';
$reader = new Xlsx();
$spreadsheet = $reader->load($filename);
$worksheet = $spreadsheet->getActiveSheet();
self::assertSame('A1:D57', $worksheet->getAutoFilter()->getRange());
self::assertSame(2, $worksheet->getAutoFilter()->getColumn('C')->ruleCount());
self::assertSame(
Rule::AUTOFILTER_COLUMN_RULE_EQUAL,
$worksheet->getAutoFilter()->getColumn('C')->getRules()[0]->getOperator()
);
self::assertSame('UK', $worksheet->getAutoFilter()->getColumn('C')->getRules()[0]->getValue());
self::assertSame(
Rule::AUTOFILTER_COLUMN_RULE_EQUAL,
$worksheet->getAutoFilter()->getColumn('C')->getRules()[1]->getOperator()
);
self::assertSame('United States', $worksheet->getAutoFilter()->getColumn('C')->getRules()[1]->getValue());
self::assertSame(2, $worksheet->getAutoFilter()->getColumn('D')->ruleCount());
self::assertSame(
Rule::AUTOFILTER_COLUMN_RULE_GREATERTHAN,
$worksheet->getAutoFilter()->getColumn('D')->getRules()[0]->getOperator()
);
self::assertSame('650', $worksheet->getAutoFilter()->getColumn('D')->getRules()[0]->getValue());
self::assertSame(
Rule::AUTOFILTER_COLUMN_RULE_LESSTHAN,
$worksheet->getAutoFilter()->getColumn('D')->getRules()[1]->getOperator()
);
self::assertSame('800', $worksheet->getAutoFilter()->getColumn('D')->getRules()[1]->getValue());
}
public function testLoadOffice365AutoFilter(): void
{
$filename = 'tests/data/Features/AutoFilter/Xlsx/AutoFilter_Basic_Office365.xlsx';
$reader = new Xlsx();
$spreadsheet = $reader->load($filename);
$worksheet = $spreadsheet->getActiveSheet();
$tables = $worksheet->getTableCollection();
self::assertCount(1, $tables);
$table = $tables->offsetGet(0);
self::assertInstanceOf(Table::class, $table);
self::assertSame('A1:D57', $table->getAutoFilter()->getRange());
self::assertSame(2, $table->getAutoFilter()->getColumn('C')->ruleCount());
self::assertSame(
Rule::AUTOFILTER_COLUMN_RULE_EQUAL,
$table->getAutoFilter()->getColumn('C')->getRules()[0]->getOperator()
);
self::assertSame('UK', $table->getAutoFilter()->getColumn('C')->getRules()[0]->getValue());
self::assertSame(
Rule::AUTOFILTER_COLUMN_RULE_EQUAL,
$table->getAutoFilter()->getColumn('C')->getRules()[1]->getOperator()
);
self::assertSame('United States', $table->getAutoFilter()->getColumn('C')->getRules()[1]->getValue());
self::assertSame(2, $table->getAutoFilter()->getColumn('D')->ruleCount());
self::assertSame(
Rule::AUTOFILTER_COLUMN_RULE_GREATERTHAN,
$table->getAutoFilter()->getColumn('D')->getRules()[0]->getOperator()
);
self::assertSame('650', $table->getAutoFilter()->getColumn('D')->getRules()[0]->getValue());
self::assertSame(
Rule::AUTOFILTER_COLUMN_RULE_LESSTHAN,
$table->getAutoFilter()->getColumn('D')->getRules()[1]->getOperator()
);
self::assertSame('800', $table->getAutoFilter()->getColumn('D')->getRules()[1]->getValue());
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/RetainSelectedCellsTest.php | tests/PhpSpreadsheetTests/Writer/RetainSelectedCellsTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer;
use PhpOffice\PhpSpreadsheet\IOFactory;
use PhpOffice\PhpSpreadsheet\Shared\File;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheetTests\Functional\AbstractFunctional;
class RetainSelectedCellsTest extends AbstractFunctional
{
private string $fileName = '';
protected function tearDown(): void
{
if ($this->fileName !== '') {
unlink($this->fileName);
$this->fileName = '';
}
}
public static function providerFormats(): array
{
return [
['Xls'],
['Xlsx'],
['Ods'],
['Csv'],
['Html'],
];
}
/**
* Test selected cell is retained in memory and in file written to disk.
*/
#[\PHPUnit\Framework\Attributes\DataProvider('providerFormats')]
public function testRetainSelectedCells(string $format): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->setCellValue('A1', '=SIN(1)')
->setCellValue('A2', '=SIN(2)')
->setCellValue('A3', '=SIN(3)')
->setCellValue('B1', '=SIN(4)')
->setCellValue('B2', '=SIN(5)')
->setCellValue('B3', '=SIN(6)')
->setCellValue('C1', '=SIN(7)')
->setCellValue('C2', '=SIN(8)')
->setCellValue('C3', '=SIN(9)');
$sheet->setSelectedCell('A3');
$sheet = $spreadsheet->createSheet();
$sheet->setCellValue('A1', '=SIN(1)')
->setCellValue('A2', '=SIN(2)')
->setCellValue('A3', '=SIN(3)')
->setCellValue('B1', '=SIN(4)')
->setCellValue('B2', '=SIN(5)')
->setCellValue('B3', '=SIN(6)')
->setCellValue('C1', '=SIN(7)')
->setCellValue('C2', '=SIN(8)')
->setCellValue('C3', '=SIN(9)');
$sheet->setSelectedCell('B1');
$sheet = $spreadsheet->createSheet();
$sheet->setCellValue('A1', '=SIN(1)')
->setCellValue('A2', '=SIN(2)')
->setCellValue('A3', '=SIN(3)')
->setCellValue('B1', '=SIN(4)')
->setCellValue('B2', '=SIN(5)')
->setCellValue('B3', '=SIN(6)')
->setCellValue('C1', '=SIN(7)')
->setCellValue('C2', '=SIN(8)')
->setCellValue('C3', '=SIN(9)');
$sheet->setSelectedCell('C2');
$spreadsheet->setActiveSheetIndex(1);
$reloaded = $this->writeAndReload($spreadsheet, $format);
self::assertEquals('A3', $spreadsheet->getSheet(0)->getSelectedCells());
self::assertEquals('B1', $spreadsheet->getSheet(1)->getSelectedCells());
self::assertEquals('C2', $spreadsheet->getSheet(2)->getSelectedCells());
self::assertEquals(1, $spreadsheet->getActiveSheetIndex());
// SelectedCells and ActiveSheet don't make sense for Html, Csv.
if ($format === 'Xlsx' || $format === 'Xls' || $format === 'Ods') {
self::assertEquals('A3', $reloaded->getSheet(0)->getSelectedCells());
self::assertEquals('B1', $reloaded->getSheet(1)->getSelectedCells());
self::assertEquals('C2', $reloaded->getSheet(2)->getSelectedCells());
self::assertEquals(1, $reloaded->getActiveSheetIndex());
}
}
#[\PHPUnit\Framework\Attributes\DataProvider('providerFormats')]
public function testRetainAutoSize(string $type): void
{
$spreadsheet = new Spreadsheet();
$sheet1 = $spreadsheet->getActiveSheet();
$array = [
[1, 2, 3, 4, 5],
[11, 12, 13, 14, 15],
[21, 22, 23, 24, 25],
[31, 32, 33, 34, 35],
];
$sheet1->fromArray($array);
$sheet2 = $spreadsheet->createSheet();
$sheet2->fromArray($array);
$sheet3 = $spreadsheet->createSheet();
$sheet3->fromArray($array);
$sheet1->getStyle('A1')->getFont()->setName('Arial');
$sheet2->getStyle('A1')->getFont()->setName('Arial');
$sheet3->getStyle('A1')->getFont()->setName('Arial');
$sheet1->getColumnDimension('A')->setAutoSize(true);
$sheet2->getColumnDimension('A')->setAutoSize(true);
$sheet3->getColumnDimension('A')->setAutoSize(true);
$sheet1->setSelectedCells('B2');
$sheet2->setSelectedCells('C3');
$sheet3->setSelectedCells('D4');
$spreadsheet->setActiveSheetIndex(1);
$activeCellSheet1 = $sheet1->getActiveCell();
$activeCellSheet2 = $sheet2->getActiveCell();
$activeCellSheet3 = $sheet3->getActiveCell();
$this->fileName = File::temporaryFilename();
$writer = IOFactory::createWriter($spreadsheet, $type);
$writer->save($this->fileName);
self::assertSame(1, $spreadsheet->getActiveSheetIndex());
self::assertSame('B2', $spreadsheet->getSheet(0)->getSelectedCells());
self::assertSame('C3', $spreadsheet->getSheet(1)->getSelectedCells());
self::assertSame('D4', $spreadsheet->getSheet(2)->getSelectedCells());
self::assertSame($activeCellSheet1, $spreadsheet->getSheet(0)->getActiveCell());
self::assertSame($activeCellSheet2, $spreadsheet->getSheet(1)->getActiveCell());
self::assertSame($activeCellSheet3, $spreadsheet->getSheet(2)->getActiveCell());
$spreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/PreCalcTest.php | tests/PhpSpreadsheetTests/Writer/PreCalcTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer;
use PhpOffice\PhpSpreadsheet\Calculation\Calculation;
use PhpOffice\PhpSpreadsheet\IOFactory;
use PhpOffice\PhpSpreadsheet\Shared\File;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Worksheet\ColumnDimension;
use PhpOffice\PhpSpreadsheetTests\Functional\AbstractFunctional;
use PHPUnit\Framework\Attributes\DataProvider;
class PreCalcTest extends AbstractFunctional
{
private string $outfile = '';
protected function tearDown(): void
{
if ($this->outfile !== '') {
unlink($this->outfile);
$this->outfile = '';
}
}
public static function providerPreCalc(): array
{
return [
[true, 'Xlsx'],
[false, 'Xlsx'],
[null, 'Xlsx'],
[true, 'Xls'],
[false, 'Xls'],
[null, 'Xls'],
[true, 'Ods'],
[false, 'Ods'],
[null, 'Ods'],
[true, 'Html'],
[false, 'Html'],
[null, 'Html'],
[true, 'Csv'],
[false, 'Csv'],
[null, 'Csv'],
];
}
private static function autoSize(?ColumnDimension $columnDimension): void
{
if ($columnDimension === null) {
self::fail('Unable to getColumnDimension');
} else {
$columnDimension->setAutoSize(true);
}
}
private static function verifyA2(Calculation $calculation, string $title, ?bool $preCalc): void
{
$cellValue = 0;
// A2 has no cached calculation value if preCalc is false
if ($preCalc === false) {
self::assertFalse($calculation->getValueFromCache("$title!A2", $cellValue));
} else {
self::assertTrue($calculation->getValueFromCache("$title!A2", $cellValue));
self::assertSame(3, $cellValue);
}
}
private const AUTOSIZE_TYPES = ['Xlsx', 'Xls', 'Html', 'Ods'];
private static function verifyA3B2(Calculation $calculation, string $title, ?bool $preCalc, string $type): void
{
$cellValue = 0;
if (in_array($type, self::AUTOSIZE_TYPES) || $preCalc !== false) {
// These 3 types support auto-sizing.
// A3 has cached calculation value because it is used in B2 calculation
self::assertTrue($calculation->getValueFromCache("$title!A3", $cellValue));
self::assertSame(11, $cellValue);
// B2 has cached calculation value because its column is auto-sized
self::assertTrue($calculation->getValueFromCache("$title!B2", $cellValue));
self::assertSame(14, $cellValue);
} else {
self::assertFalse($calculation->getValueFromCache("$title!A3", $cellValue));
self::assertFalse($calculation->getValueFromCache("$title!B2", $cellValue));
}
}
private static function readFile(string $file): string
{
$dataOut = '';
$data = file_get_contents($file);
// confirm that file contains B2 pre-calculated or not as appropriate
if ($data === false) {
self::fail("Unable to read $file");
} else {
$dataOut = $data;
}
return $dataOut;
}
private function verifyXlsx(?bool $preCalc, string $type): void
{
if ($type === 'Xlsx') {
$file = 'zip://';
$file .= $this->outfile;
$file .= '#xl/worksheets/sheet1.xml';
$data = self::readFile($file);
// confirm that file contains B2 pre-calculated or not as appropriate
if ($preCalc === false) {
self::assertStringContainsString('<c r="B2" t="str"><f>3+A3</f></c>', $data);
} else {
self::assertStringContainsString('<c r="B2"><f>3+A3</f><v>14</v></c>', $data);
}
$file = 'zip://';
$file .= $this->outfile;
$file .= '#xl/workbook.xml';
$data = self::readFile($file);
// confirm whether workbook is set to recalculate
if ($preCalc === false) {
self::assertStringContainsString('<calcPr calcId="999999" calcMode="auto" calcCompleted="0" fullCalcOnLoad="1" forceFullCalc="0"/>', $data);
} else {
self::assertStringContainsString('<calcPr calcId="999999" calcMode="auto" calcCompleted="1" fullCalcOnLoad="0" forceFullCalc="0"/>', $data);
}
}
}
private function verifyOds(?bool $preCalc, string $type): void
{
if ($type === 'Ods') {
$file = 'zip://';
$file .= $this->outfile;
$file .= '#content.xml';
$data = self::readFile($file);
// confirm that file contains B2 pre-calculated or not as appropriate
if ($preCalc === false) {
self::assertStringContainsString('table:formula="of:=3+[.A3]" office:value-type="string" office:value="=3+A3"', $data);
} else {
self::assertStringContainsString(' table:formula="of:=3+[.A3]" office:value-type="float" office:value="14"', $data);
}
}
}
private function verifyHtml(?bool $preCalc, string $type): void
{
if ($type === 'Html') {
$data = self::readFile($this->outfile);
// confirm that file contains B2 pre-calculated or not as appropriate
if ($preCalc === false) {
self::assertStringContainsString('>=1+2</td>', $data);
self::assertStringContainsString('>=3+A3</td>', $data);
self::assertStringContainsString('>=5+6</td>', $data);
} else {
self::assertStringContainsString('>3</td>', $data);
self::assertStringContainsString('>14</td>', $data);
self::assertStringContainsString('>11</td>', $data);
}
}
}
private function verifyCsv(?bool $preCalc, string $type): void
{
if ($type === 'Csv') {
$data = self::readFile($this->outfile);
// confirm that file contains B2 pre-calculated or not as appropriate
if ($preCalc === false) {
self::assertStringContainsString('"=1+2"', $data);
self::assertStringContainsString('"=3+A3"', $data);
self::assertStringContainsString('"=5+6"', $data);
} else {
self::assertStringContainsString('"3"', $data);
self::assertStringContainsString('"14"', $data);
self::assertStringContainsString('"11"', $data);
}
}
}
#[DataProvider('providerPreCalc')]
public function testPreCalc(?bool $preCalc, string $type): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->getCell('A1')->setValue('Column not set to autoSize');
$sheet->getCell('B1')->setValue('Column set to autoSize');
$sheet->getCell('A2')->setValue('=1+2');
$sheet->getCell('A3')->setValue('=5+6');
$sheet->getCell('B2')->setValue('=3+A3');
$columnDimension = $sheet->getColumnDimension('B');
self::autoSize($columnDimension);
$writer = IOFactory::createWriter($spreadsheet, $type);
if ($preCalc !== null) {
$writer->setPreCalculateFormulas($preCalc);
}
$this->outfile = File::temporaryFilename();
$writer->save($this->outfile);
$title = $sheet->getTitle();
$calculation = Calculation::getInstance($spreadsheet);
// verify values in Calculation cache
self::verifyA2($calculation, $title, $preCalc);
self::verifyA3B2($calculation, $title, $preCalc, $type);
// verify values in output file
$this->verifyXlsx($preCalc, $type);
$this->verifyOds($preCalc, $type);
$this->verifyHtml($preCalc, $type);
$this->verifyCsv($preCalc, $type);
$spreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Mpdf/TextRotationTest.php | tests/PhpSpreadsheetTests/Writer/Mpdf/TextRotationTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Mpdf;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Writer\Pdf\Mpdf;
use PHPUnit\Framework\TestCase;
class TextRotationTest extends TestCase
{
public function testTextRotation(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->setPrintGridlines(true);
$sheet->getStyle('A7')->getAlignment()->setTextRotation(90);
$sheet->setCellValue('A7', 'Lorem Ipsum');
$writer = new Mpdf($spreadsheet);
$html = $writer->generateHtmlAll();
self::assertStringContainsString(' text-rotate:90;', $html);
$spreadsheet->disconnectWorksheets();
unset($spreadsheet);
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Mpdf/MergedBorderTest.php | tests/PhpSpreadsheetTests/Writer/Mpdf/MergedBorderTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Mpdf;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Style\Border;
use PhpOffice\PhpSpreadsheet\Writer\Pdf\Mpdf;
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 Mpdf($spreadsheet);
$html = $writer->generateHtmlAll();
self::assertSame(0, preg_match('/border-(top|bottom|right|left):none #000000;/', $html));
self::assertSame(1, preg_match('/border-top:1px solid #FF0000 !important; border-left:1px solid #FF0000 !important;/', $html));
self::assertSame(1, preg_match('/border-bottom:1px solid #FF0000 !important; border-left:1px solid #FF0000 !important;/', $html));
self::assertSame(1, preg_match('/border-top:1px solid #FF0000 !important; border-right:1px solid #FF0000 !important;/', $html));
self::assertSame(1, preg_match('/border-bottom:1px solid #FF0000 !important; border-right:1px solid #FF0000 !important;/', $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/Mpdf/OrientationTest.php | tests/PhpSpreadsheetTests/Writer/Mpdf/OrientationTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Mpdf;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Worksheet\PageSetup;
use PhpOffice\PhpSpreadsheet\Writer\Pdf\Mpdf;
use PHPUnit\Framework\TestCase;
class OrientationTest extends TestCase
{
private const INITARRAY = [
[1, 2, 3, 4, 5],
[6, 7, 8, 9, 10],
[11, 12, 13, 14, 15],
];
private static function setupSheet(): Spreadsheet
{
$spreadsheet = new Spreadsheet();
$sheet1 = $spreadsheet->getActiveSheet();
$sheet1->fromArray(self::INITARRAY);
$sheet1->getPageSetup()->setOrientation(PageSetup::ORIENTATION_LANDSCAPE);
$sheet2 = $spreadsheet->createSheet();
$sheet2->fromArray(self::INITARRAY);
$sheet2->getPageSetup()->setOrientation(PageSetup::ORIENTATION_PORTRAIT);
$sheet3 = $spreadsheet->createSheet();
$sheet3->fromArray(self::INITARRAY);
$sheet3->getPageSetup()->setOrientation(PageSetup::ORIENTATION_LANDSCAPE);
return $spreadsheet;
}
public static function testSheetOrientation(): void
{
$spreadsheet = self::setupSheet();
$writer = new Mpdf($spreadsheet);
//$writer->setOrientation( PageSetup::ORIENTATION_LANDSCAPE );
$writer->writeAllSheets();
$html = $writer->generateHtmlAll();
self::assertSame(2, substr_count($html, 'size: landscape;'));
self::assertSame(1, substr_count($html, 'size: portrait;'));
$spreadsheet->disconnectWorksheets();
}
public static function testLandscape(): void
{
$spreadsheet = self::setupSheet();
$writer = new Mpdf($spreadsheet);
$writer->setOrientation(PageSetup::ORIENTATION_LANDSCAPE);
$writer->writeAllSheets();
$html = $writer->generateHtmlAll();
self::assertSame(3, substr_count($html, 'size: landscape;'));
self::assertSame(0, substr_count($html, 'size: portrait;'));
$spreadsheet->disconnectWorksheets();
}
public static function testPortrait(): void
{
$spreadsheet = self::setupSheet();
$writer = new Mpdf($spreadsheet);
$writer->setOrientation(PageSetup::ORIENTATION_PORTRAIT);
$writer->writeAllSheets();
$html = $writer->generateHtmlAll();
self::assertSame(0, substr_count($html, 'size: landscape;'));
self::assertSame(3, substr_count($html, 'size: portrait;'));
$spreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Mpdf/ImageCopyPdfTest.php | tests/PhpSpreadsheetTests/Writer/Mpdf/ImageCopyPdfTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Mpdf;
use PhpOffice\PhpSpreadsheet\Reader\Xls as XlsReader;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx as XlsxReader;
use PhpOffice\PhpSpreadsheet\Shared\File;
use PhpOffice\PhpSpreadsheet\Writer\Pdf\Mpdf;
use PhpOffice\PhpSpreadsheet\Writer\Xlsx as XlsxWriter;
use PhpOffice\PhpSpreadsheetTests\Functional;
class ImageCopyPdfTest extends Functional\AbstractFunctional
{
private string $xlsxFile = '';
protected function tearDown(): void
{
if ($this->xlsxFile !== '') {
unlink($this->xlsxFile);
$this->xlsxFile = '';
}
}
public function testImageCopyXls(): void
{
$file = 'samples/templates/27template.xls';
$reader = new XlsReader();
$reloadedSpreadsheet = $reader->load($file);
$this->xlsxFile = File::temporaryFilename();
$writer = new Mpdf($reloadedSpreadsheet);
self::assertFalse($writer->getEmbedImages());
$html = $writer->generateHTMLAll();
self::assertSame(4, substr_count($html, '<img'));
self::assertSame(0, substr_count($html, 'zip://'));
// all 4 images converted to png
self::assertSame(4, substr_count($html, 'data:image/png;base64'));
$this->writeAndReload($reloadedSpreadsheet, 'Html');
$reloadedSpreadsheet->disconnectWorksheets();
}
public function testImageCopyXlsx(): void
{
$file = 'samples/templates/27template.xls';
$reader = new XlsReader();
$spreadsheet = $reader->load($file);
$this->xlsxFile = File::temporaryFilename();
$writer = new XlsxWriter($spreadsheet);
$writer->save($this->xlsxFile);
$spreadsheet->disconnectWorksheets();
$reader2 = new XlsxReader();
$reloadedSpreadsheet = $reader2->load($this->xlsxFile);
$writer = new Mpdf($reloadedSpreadsheet);
self::assertFalse($writer->getEmbedImages());
$html = $writer->generateHTMLAll();
self::assertSame(4, substr_count($html, '<img'));
self::assertSame(0, substr_count($html, 'zip://'));
// "gif" is actually stored as png in this file
self::assertSame(2, substr_count($html, 'data:image/png;base64'));
//self::assertSame(1, substr_count($html, 'data:image/gif;base64'));
self::assertSame(2, substr_count($html, 'data:image/jpeg;base64'));
$this->writeAndReload($reloadedSpreadsheet, 'Html');
$reloadedSpreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Mpdf/PrintAreaTest.php | tests/PhpSpreadsheetTests/Writer/Mpdf/PrintAreaTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Mpdf;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Writer\Pdf\Mpdf as MpdfWriter;
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 MpdfWriter($spreadsheet);
$html = $writer->generateHtmlAll();
$html = preg_replace('/^ +/m', '', $html) ?? $html;
$expectedArray = [
'<tbody>',
'<tr class="row1">',
'<td class="column1 style0 n" style="width:42pt">7</td>',
'<td class="column2 style0 n" style="width:42pt">8</td>',
'<td class="column3 style0 n" style="width:42pt">9</td>',
'</tr>',
'<tr class="row2">',
'<td class="column1 style0 n" style="width:42pt">12</td>',
'<td class="column2 style0 n" style="width:42pt">13</td>',
'<td class="column3 style0 n" style="width:42pt">14</td>',
'</tr>',
'<tr class="row3">',
'<td class="column1 style0 n" style="width:42pt">17</td>',
'<td class="column2 style0 n" style="width:42pt">18</td>',
'<td class="column3 style0 n" style="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/Mpdf/HideTest.php | tests/PhpSpreadsheetTests/Writer/Mpdf/HideTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Mpdf;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Writer\Pdf\Mpdf;
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 Mpdf($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/Mpdf/HideMergeTest.php | tests/PhpSpreadsheetTests/Writer/Mpdf/HideMergeTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Mpdf;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Style\Alignment;
use PhpOffice\PhpSpreadsheet\Style\Border;
use PhpOffice\PhpSpreadsheet\Style\Color;
use PhpOffice\PhpSpreadsheet\Writer\Pdf\Mpdf;
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);
$mpdf = new Mpdf($spreadsheet);
$html = $mpdf->generateHtmlAll();
$html = preg_replace('/^\s+/m', '', $html) ?? $html;
$html = preg_replace('/[\n\r]/', '', $html) ?? $html;
self::assertStringContainsString(
'<tr class="row0">'
. '<td class="column1 style0 s" style="width:42pt; height:17pt">B</td>'
. '<td class="column2 style0 s" style="width:42pt; height:17pt">C</td>'
. '</tr>',
$html
);
self::assertStringContainsString(
'<tr class="row1">'
. '<td class="column1 style1 s style1" colspan="2" rowspan="2" style="width:84pt; height:17pt">Hello World Headline</td>'
. '</tr>',
$html
);
self::assertStringContainsString(
'<tr class="row2">'
. '</tr>',
$html
);
self::assertStringContainsString(
'<tr class="row3">'
. '<td class="column1 style2 s style2" rowspan="2" style="width:42pt; height:17pt">Label 1</td>'
. '<td class="column2 style3 s style3" rowspan="2" style="width:42pt; height:17pt">Text 1</td>'
. '</tr>',
$html
);
self::assertStringContainsString(
'<tr class="row4">'
. '</tr>',
$html
);
self::assertStringContainsString(
'<tr class="row5">'
. '<td class="column1 style2 s style2" rowspan="2" style="width:42pt; height:17pt">Label 2</td>'
. '<td class="column2 style3 s style3" rowspan="2" style="width:42pt; height:17pt">Text 2</td>'
. '</tr>',
$html
);
self::assertStringContainsString(
'<tr class="row6">'
. '</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/Xls/XlsGifBmpTest.php | tests/PhpSpreadsheetTests/Writer/Xls/XlsGifBmpTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Xls;
use DateTime;
use PhpOffice\PhpSpreadsheet\Reader\Exception as ReaderException;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Worksheet\Drawing;
use PhpOffice\PhpSpreadsheet\Worksheet\MemoryDrawing;
use PhpOffice\PhpSpreadsheet\Worksheet\Worksheet;
use PhpOffice\PhpSpreadsheetTests\Functional\AbstractFunctional;
class XlsGifBmpTest extends AbstractFunctional
{
private string $filename = '';
protected function tearDown(): void
{
if ($this->filename) {
unlink($this->filename);
}
$this->filename = '';
}
public function testBmp(): void
{
$pgmstart = (float) (new DateTime())->format('U');
$spreadsheet = new Spreadsheet();
$filstart = $spreadsheet->getProperties()->getModified();
self::assertLessThanOrEqual($filstart, $pgmstart);
// Add a drawing to the worksheet
$drawing = new Drawing();
$drawing->setName('Letters B, M, and P');
$drawing->setDescription('Handwritten B, M, and P');
$drawing->setPath(__DIR__ . '/../../../../samples/images/bmp.bmp');
$drawing->setHeight(36);
$drawing->setWorksheet($spreadsheet->getActiveSheet());
$drawing->setCoordinates('A1');
$reloadedSpreadsheet = $this->writeAndReload($spreadsheet, 'Xls');
$spreadsheet->disconnectWorksheets();
$creationDatestamp = $reloadedSpreadsheet->getProperties()->getCreated();
$filstart = $creationDatestamp;
$worksheet = $reloadedSpreadsheet->getActiveSheet();
$drawings = $worksheet->getDrawingCollection();
self::assertCount(1, $drawings);
foreach ($worksheet->getDrawingCollection() as $drawing) {
$mimeType = ($drawing instanceof MemoryDrawing) ? $drawing->getMimeType() : 'notmemorydrawing';
self::assertEquals('image/png', $mimeType);
}
$pgmend = (float) (new DateTime())->format('U');
self::assertLessThanOrEqual($pgmend, $pgmstart);
self::assertLessThanOrEqual($pgmend, $filstart);
self::assertLessThanOrEqual($filstart, $pgmstart);
$reloadedSpreadsheet->disconnectWorksheets();
}
public function testGif(): void
{
$spreadsheet = new Spreadsheet();
// Add a drawing to the worksheet
$drawing = new Drawing();
$drawing->setName('Letters G, I, and G');
$drawing->setDescription('Handwritten G, I, and F');
$drawing->setPath(__DIR__ . '/../../../../samples/images/gif.gif');
$drawing->setHeight(36);
$drawing->setWorksheet($spreadsheet->getActiveSheet());
$drawing->setCoordinates('A1');
$reloadedSpreadsheet = $this->writeAndReload($spreadsheet, 'Xls');
$spreadsheet->disconnectWorksheets();
$worksheet = $reloadedSpreadsheet->getActiveSheet();
$drawings = $worksheet->getDrawingCollection();
self::assertCount(1, $drawings);
foreach ($worksheet->getDrawingCollection() as $drawing) {
$mimeType = ($drawing instanceof MemoryDrawing) ? $drawing->getMimeType() : 'notmemorydrawing';
self::assertEquals('image/png', $mimeType);
}
$reloadedSpreadsheet->disconnectWorksheets();
}
public function testGifIssue4112(): void
{
$spreadsheet = new Spreadsheet();
$spreadsheet->removeSheetByIndex(0);
$sheet = new Worksheet($spreadsheet, 'Insured List');
$spreadsheet->addSheet($sheet, 0);
// Add a drawing to the worksheet
$drawing = new Drawing();
$drawing->setName('Letters G, I, and G');
$drawing->setDescription('Handwritten G, I, and F');
$drawing->setPath(__DIR__ . '/../../../../samples/images/gif.gif');
$drawing->setHeight(36);
$drawing->setWorksheet($sheet);
$drawing->setCoordinates('A1');
$reloadedSpreadsheet = $this->writeAndReload($spreadsheet, 'Xls');
$spreadsheet->disconnectWorksheets();
$worksheet = $reloadedSpreadsheet->getActiveSheet();
$drawings = $worksheet->getDrawingCollection();
self::assertCount(1, $drawings);
foreach ($worksheet->getDrawingCollection() as $drawing) {
$mimeType = ($drawing instanceof MemoryDrawing) ? $drawing->getMimeType() : 'notmemorydrawing';
self::assertEquals('image/png', $mimeType);
}
$reloadedSpreadsheet->disconnectWorksheets();
}
public function testInvalidTimestamp(): void
{
$this->expectException(ReaderException::class);
$this->expectExceptionMessage('Expecting 8 byte string');
\PhpOffice\PhpSpreadsheet\Shared\OLE::OLE2LocalDate(' ');
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Xls/DimensionsRecordTest.php | tests/PhpSpreadsheetTests/Writer/Xls/DimensionsRecordTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Xls;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Writer\Xls;
use PHPUnit\Framework\TestCase;
class DimensionsRecordTest extends TestCase
{
/**
* Test that DIMENSIONS record uses 0-based indices for both rows and columns.
*
* This test verifies that the BIFF8 DIMENSIONS record correctly uses 0-based
* indices for both rows and columns. Prior to the fix, 1-based values were
* written directly to the DIMENSIONS record, causing issues with old XLS parsers
* that expect 0-based indices per the BIFF8 specification.
*
* The DIMENSIONS record structure (BIFF8):
* - Offset 0-3: Index to first used row (0-based)
* - Offset 4-7: Index to last used row + 1 (0-based)
* - Offset 8-9: Index to first used column (0-based)
* - Offset 10-11: Index to last used column + 1 (0-based)
* - Offset 12-13: Not used
*
* Note: All indices in the DIMENSIONS record are 0-based, meaning Excel row 1
* is stored as 0, row 5 as 4, column A as 0, column D as 3, etc.
*/
public function testDimensionsRecordUsesZeroBasedColumnIndices(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
// Set values in columns A through D (should be indices 0-3 in 0-based)
$sheet->setCellValue('A1', 'Column A');
$sheet->setCellValue('B1', 'Column B');
$sheet->setCellValue('C1', 'Column C');
$sheet->setCellValue('D1', 'Column D');
$sheet->setCellValue('A5', 'Row 5');
// Write to XLS format
$filename = tempnam(sys_get_temp_dir(), 'phpspreadsheet-test-');
$writer = new Xls($spreadsheet);
$writer->save($filename);
$spreadsheet->disconnectWorksheets();
// Read the binary file and find the DIMENSIONS record
$fileContent = file_get_contents($filename);
self::assertIsString($fileContent, 'Failed to read XLS file');
unlink($filename);
// Find the DIMENSIONS record: 0x0200 (2 bytes) + length 0x000E (2 bytes)
$recordSignature = pack('v', 0x0200) . pack('v', 0x000E);
$pos = strpos($fileContent, $recordSignature);
self::assertIsInt($pos, 'DIMENSIONS record not found in XLS file');
// Parse the DIMENSIONS record (skip 4-byte header)
$dataPos = $pos + 4;
$dimensionsData = substr($fileContent, $dataPos, 14);
// Unpack DIMENSIONS record
$data = unpack('VrwMic/VrwMac/vcolMic/vcolMac/vreserved', $dimensionsData);
self::assertIsArray($data, 'Failed to unpack DIMENSIONS record');
// Verify the values are correct (0-based for both rows and columns)
// First used row is 1 (Excel UI), which is 0 in 0-based indexing
self::assertSame(0, $data['rwMic'], 'First row should be 0 (0-based)');
// Last used row is 5 (Excel UI), which is 4 in 0-based, so rwMac should be 5 (4 + 1)
self::assertSame(5, $data['rwMac'], 'Last row + 1 should be 5 (0-based row 4 + 1)');
// First column is A (Excel UI), which is 0 in 0-based indexing
// BEFORE FIX: This would be 1 (because columnIndexFromString('A') returns 1)
// AFTER FIX: This is 0 (because we subtract 1)
self::assertSame(0, $data['colMic'], 'First column should be 0 (0-based for column A)');
// Last column is D (Excel UI), which is 3 in 0-based, so colMac should be 4 (3 + 1)
// BEFORE FIX: This would be 5 (columnIndexFromString('D') = 4, not adjusted to 0-based)
// AFTER FIX: This is 4 (columnIndexFromString('D') - 1 = 3, + 1 = 4)
self::assertSame(4, $data['colMac'], 'Last column + 1 should be 4 (0-based column 3 + 1)');
}
/**
* Test that DIMENSIONS record correctly handles columns near the BIFF8 limit.
*
* BIFF8 format supports columns up to IV (256 columns, 0-based index 0-255).
* This test ensures that the lastColumnIndex is correctly capped at 255.
*/
public function testDimensionsRecordCapsColumnIndexAt255(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
// Set value in column IV (column 256, 0-based index 255)
$sheet->setCellValue('IV1', 'Last BIFF8 Column');
// Write to XLS format
$filename = tempnam(sys_get_temp_dir(), 'phpspreadsheet-test-');
$writer = new Xls($spreadsheet);
$writer->save($filename);
$spreadsheet->disconnectWorksheets();
// Read the binary file and find the DIMENSIONS record
$fileContent = file_get_contents($filename);
self::assertIsString($fileContent, 'Failed to read XLS file');
unlink($filename);
// Find the DIMENSIONS record: 0x0200 (2 bytes) + length 0x000E (2 bytes)
$recordSignature = pack('v', 0x0200) . pack('v', 0x000E);
$pos = strpos($fileContent, $recordSignature);
self::assertIsInt($pos, 'DIMENSIONS record not found in XLS file');
// Parse the DIMENSIONS record (skip 4-byte header)
$dataPos = $pos + 4;
$dimensionsData = substr($fileContent, $dataPos, 14);
// Unpack DIMENSIONS record
$data = unpack('VrwMic/VrwMac/vcolMic/vcolMac/vreserved', $dimensionsData);
self::assertIsArray($data, 'Failed to unpack DIMENSIONS record');
// Last column should be capped at 256 (255 + 1 for "last used + 1")
// The min(255, ...) ensures we don't exceed the BIFF8 limit
self::assertLessThanOrEqual(256, $data['colMac'], 'Last column index should not exceed 256');
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Xls/DataValidationTest.php | tests/PhpSpreadsheetTests/Writer/Xls/DataValidationTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Xls;
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, 'Xls');
$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/Xls/HyperlinkTest.php | tests/PhpSpreadsheetTests/Writer/Xls/HyperlinkTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Xls;
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, 'Xls');
$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/Xls/ConditionalFontColorTest.php | tests/PhpSpreadsheetTests/Writer/Xls/ConditionalFontColorTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Xls;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Style\Conditional;
use PhpOffice\PhpSpreadsheet\Style\Fill;
use PhpOffice\PhpSpreadsheetTests\Functional\AbstractFunctional;
class ConditionalFontColorTest extends AbstractFunctional
{
public function testConditionalFontColor(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->getCell('A1')->setValue(10);
$condition1 = new Conditional();
$condition1->setConditionType(Conditional::CONDITION_CELLIS);
$condition1->setOperatorType(Conditional::OPERATOR_LESSTHAN);
$condition1->addCondition(20);
$condition1->getStyle()->getFill()
->setFillType(Fill::FILL_SOLID)
->getStartColor()->setARGB('FF2345FA');
$condition1->getStyle()->getFont()
->setBold(true);
$condition1->getStyle()->getFont()->getColor()
->setARGB('FFFF8193');
$conditionalStyles = [$condition1];
$sheet->getStyle('A1')->setConditionalStyles($conditionalStyles);
$robj = $this->writeAndReload($spreadsheet, 'Xls');
$spreadsheet->disconnectWorksheets();
$sheet0 = $robj->setActiveSheetIndex(0);
$conditionals = $sheet0->getConditionalStylesCollection();
self::assertCount(1, $conditionals);
self::assertArrayHasKey('A1', $conditionals);
$font = $conditionals['A1'][0]->getStyle()->getFont();
self::assertSame('FFFF8193', $font->getColor()->getARGB());
$fill = $conditionals['A1'][0]->getStyle()->getFill();
self::assertSame('FF2345FA', $fill->getStartColor()->getARGB());
self::assertSame(Fill::FILL_SOLID, $fill->getFillType());
$robj->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Xls/Sample19Test.php | tests/PhpSpreadsheetTests/Writer/Xls/Sample19Test.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Xls;
use PhpOffice\PhpSpreadsheetTests\Functional\AbstractFunctional;
class Sample19Test extends AbstractFunctional
{
public function testSample19Xls(): void
{
$spreadsheet = new \PhpOffice\PhpSpreadsheet\Spreadsheet();
$spreadsheet->setActiveSheetIndex(0);
$spreadsheet->getActiveSheet()->setCellValue('A1', 'Firstname:')
->setCellValue('A2', 'Lastname:')
->setCellValue('A3', 'Fullname:')
->setCellValue('B1', 'Maarten')
->setCellValue('B2', 'Balliauw')
->setCellValue('B3', '=B1 & " " & B2')
->setCellValue('C1', '=A2&A3&A3&A2&B1');
$robj = $this->writeAndReload($spreadsheet, 'Xls');
$sheet0 = $robj->setActiveSheetIndex(0);
// Xls parser eliminates unneeded whitespace
self::assertEquals('=B1&" "&B2', $sheet0->getCell('B3')->getValue());
self::assertEquals('Maarten Balliauw', $sheet0->getCell('B3')->getCalculatedValue());
self::assertEquals('Lastname:Fullname:Fullname:Lastname:Maarten', $sheet0->getCell('C1')->getCalculatedValue());
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Xls/FormulaErrTest.php | tests/PhpSpreadsheetTests/Writer/Xls/FormulaErrTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Xls;
use PhpOffice\PhpSpreadsheet\NamedRange;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Writer\Exception as WriterException;
use PhpOffice\PhpSpreadsheet\Writer\Xls\Worksheet;
use PhpOffice\PhpSpreadsheetTests\Functional\AbstractFunctional;
class FormulaErrTest extends AbstractFunctional
{
private ?Spreadsheet $spreadsheet = null;
private ?Spreadsheet $reloadedSpreadsheet = null;
private bool $allowThrow;
protected function setUp(): void
{
$this->allowThrow = Worksheet::getAllowThrow();
}
protected function tearDown(): void
{
Worksheet::setAllowThrow($this->allowThrow);
if ($this->spreadsheet !== null) {
$this->spreadsheet->disconnectWorksheets();
$this->spreadsheet = null;
}
if ($this->reloadedSpreadsheet !== null) {
$this->reloadedSpreadsheet->disconnectWorksheets();
$this->reloadedSpreadsheet = null;
}
}
private function xtestFormulaError(bool $allowThrow): void
{
Worksheet::setAllowThrow($allowThrow);
$this->spreadsheet = $obj = new Spreadsheet();
$sheet0 = $obj->setActiveSheetIndex(0);
$sheet0->setCellValue('A1', 2);
$obj->addNamedRange(new NamedRange('DEFNAM', $sheet0, '$A$1'));
$sheet0->setCellValue('B1', '=2*DEFNAM');
$sheet0->setCellValue('C1', '=DEFNAM=2');
$sheet0->setCellValue('D1', '=CONCATENATE("X",DEFNAM)');
$this->reloadedSpreadsheet = $robj = $this->writeAndReload($obj, 'Xls');
$sheet0 = $robj->setActiveSheetIndex(0);
$a1 = $sheet0->getCell('A1')->getCalculatedValue();
self::assertEquals(2, $a1);
$b1 = $sheet0->getCell('B1')->getCalculatedValue();
self::assertEquals(4, $b1);
$c1 = $sheet0->getCell('C1')->getCalculatedValue();
$tru = true;
self::assertEquals($tru, $c1);
$d1 = $sheet0->getCell('D1')->getCalculatedValue();
self::assertEquals('X2', $d1);
}
public function testFormulaErrorWithThrow(): void
{
$this->expectException(WriterException::class);
$this->expectExceptionMessage('Cannot yet write formulae with defined names to Xls');
$this->xtestFormulaError(true);
}
public function testFormulaError(): void
{
$this->xtestFormulaError(false);
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Xls/Issue4584Test.php | tests/PhpSpreadsheetTests/Writer/Xls/Issue4584Test.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Xls;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheetTests\Functional\AbstractFunctional;
class Issue4584Test extends AbstractFunctional
{
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, 'Xls');
$spreadsheet->disconnectWorksheets();
$rsheet = $reloadedSpreadsheet->getActiveSheet();
self::assertSame(20.0, $rsheet->getDefaultRowDimension()->getRowHeight());
$row1 = $rsheet->getRowDimension(1);
self::assertTrue($row1->getCustomFormat());
self::assertSame(-1.0, $row1->getRowHeight());
$row2 = $rsheet->getRowDimension(2);
self::assertFalse($row2->getCustomFormat());
self::assertSame(-1.0, $row2->getRowHeight());
$row4 = $rsheet->getRowDimension(4);
self::assertFalse($row4->getCustomFormat());
self::assertSame(-1.0, $row4->getRowHeight());
$reloadedSpreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Xls/ParserTest.php | tests/PhpSpreadsheetTests/Writer/Xls/ParserTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Xls;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Writer\Exception as WriterException;
use PhpOffice\PhpSpreadsheet\Writer\Xls\Parser;
use PHPUnit\Framework\Attributes\DataProvider;
use PHPUnit\Framework\TestCase;
class ParserTest extends TestCase
{
private ?Spreadsheet $spreadsheet = null;
protected function tearDown(): void
{
if ($this->spreadsheet !== null) {
$this->spreadsheet->disconnectWorksheets();
$this->spreadsheet = null;
}
}
public function testNonArray(): void
{
$this->expectException(WriterException::class);
$this->expectExceptionMessage('Unexpected non-array');
$this->spreadsheet = new Spreadsheet();
$parser = new Parser($this->spreadsheet);
$parser->toReversePolish();
}
public function testMissingIndex(): void
{
$this->expectException(WriterException::class);
$this->expectExceptionMessage('Unexpected non-array');
$this->spreadsheet = new Spreadsheet();
$parser = new Parser($this->spreadsheet);
$parser->toReversePolish(['left' => 0]);
}
public function testParseError(): void
{
$this->expectException(WriterException::class);
$this->expectExceptionMessage('Unknown token +');
$this->spreadsheet = new Spreadsheet();
$parser = new Parser($this->spreadsheet);
$parser->toReversePolish(['left' => 1, 'right' => 2, 'value' => '+']);
}
public function testGoodParse(): void
{
$this->spreadsheet = new Spreadsheet();
$parser = new Parser($this->spreadsheet);
self::assertSame('1e01001e02001e0300', bin2hex($parser->toReversePolish(['left' => 1, 'right' => 2, 'value' => 3])));
}
#[DataProvider('cellSheetnameQuotedProvider')]
public function testCellSheetnameQuoted(bool $expected, string $address): void
{
self::assertSame($expected, Parser::matchCellSheetnameQuoted($address));
}
public static function cellSheetnameQuotedProvider(): array
{
return [
[true, '\'TS GK Mustermann Hans 2\'!$N$1'],
[true, '\'TS GK Mustermann Hans 2\'!N15'],
[true, '\'TS GK Mus\'\'termann Hans 2\'!N15'],
[false, '\'TS GK Mus\'termann Hans 2\'!N15'],
[false, '\'TS GK Mustermann Hans 2\'!N15:P16'],
[false, '\'TS GK Mustermann Hans 2\'!$N$15:$P$16'],
[false, 'sheet1!N15'],
[false, 'sheet1!N15:P16'],
[false, 'N15'],
[false, 'N15:P16'],
];
}
#[DataProvider('rangeSheetnameQuotedProvider')]
public function testRangeSheetnameQuoted(bool $expected, string $address): void
{
self::assertSame($expected, Parser::matchRangeSheetnameQuoted($address));
}
public static function rangeSheetnameQuotedProvider(): array
{
return [
[false, '\'TS GK Mustermann Hans 2\'!$N$1'],
[false, '\'TS GK Mustermann Hans 2\'!N15'],
[false, '\'TS GK Mus\'\'termann Hans 2\'!N15'],
[false, '\'TS GK Mus\'termann Hans 2\'!N15'],
[true, '\'TS GK Mustermann Hans 2\'!N15:P16'],
[true, '\'TS GK Mustermann Hans 2\'!$N$15:$P$16'],
[false, 'sheet1!N15'],
[false, 'sheet1!N15:P16'],
[false, 'N15'],
[false, 'N15:P16'],
];
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Xls/ReadOrderTest.php | tests/PhpSpreadsheetTests/Writer/Xls/ReadOrderTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Xls;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Style\Alignment;
use PhpOffice\PhpSpreadsheetTests\Functional\AbstractFunctional;
class ReadOrderTest extends AbstractFunctional
{
public function testBooleanLiteral(): void
{
// Issue 850 - Xls Reader/Writer didn't support Alignment ReadOrder
$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->setCellValue('A5', 'hello');
$spreadsheet->getActiveSheet()->getStyle('A5')
->getAlignment()->setIndent(2);
$robj = $this->writeAndReload($spreadsheet, 'Xls');
$spreadsheet->disconnectWorksheets();
$sheet0 = $robj->setActiveSheetIndex(0);
self::assertSame(
Alignment::READORDER_RTL,
$sheet0->getStyle('A1')->getAlignment()->getReadOrder()
);
self::assertSame(
Alignment::READORDER_LTR,
$sheet0->getStyle('A2')->getAlignment()->getReadOrder()
);
self::assertSame(
Alignment::READORDER_CONTEXT,
$sheet0->getStyle('A3')->getAlignment()->getReadOrder()
);
self::assertSame(
2,
$sheet0->getStyle('A5')->getAlignment()->getIndent()
);
$robj->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Xls/RichTextTest.php | tests/PhpSpreadsheetTests/Writer/Xls/RichTextTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Xls;
use PhpOffice\PhpSpreadsheet\Reader\Xls as XlsReader;
use PhpOffice\PhpSpreadsheet\RichText\RichText;
use PhpOffice\PhpSpreadsheet\Shared\File;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Writer\Xls as XlsWriter;
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 XlsWriter($spreadsheet);
$writer->save($this->filename);
$spreadsheet->disconnectWorksheets();
$this->readfile();
}
private function readfile(): void
{
$reader = new XlsReader();
$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/Xls/Issue918Test.php | tests/PhpSpreadsheetTests/Writer/Xls/Issue918Test.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Xls;
use PhpOffice\PhpSpreadsheet\Helper\Html as HtmlHelper;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheetTests\Functional\AbstractFunctional;
class Issue918Test extends AbstractFunctional
{
public function testEmptyRichText(): void
{
// Issue 918 - Xls Writer creates corrupt file with empty RichText.
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$helper = new HtmlHelper();
$html = '<div></div>';
$richValue = $helper->toRichTextObject($html);
self::assertCount(0, $richValue->getRichTextElements());
$sheet->getCell('A1')->setValue($richValue);
$robj = $this->writeAndReload($spreadsheet, 'Xls');
$spreadsheet->disconnectWorksheets();
$sheet0 = $robj->getActiveSheet();
self::assertNull($sheet0->getCell('A1')->getValue(), 'empty text object has been changed to null');
$robj->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Xls/Issue4331Test.php | tests/PhpSpreadsheetTests/Writer/Xls/Issue4331Test.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Xls;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheetTests\Functional\AbstractFunctional;
class Issue4331Test extends AbstractFunctional
{
public function testIssue4331(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$c3 = '=VLOOKUP(B3,$B$10:$C$13,2,FALSE)';
$d3 = '=VLOOKUP("intermediate",$B$10:$C$13,2,TRUE)';
$c4 = '=VLOOKUP(B3,$B$10:$C$13,2,FALSE())';
$d4 = '=VLOOKUP("intermediate",$B$10:$C$13,2,TRUE())';
$sheet->fromArray(
[
['level', 'result'],
['medium', $c3, $d3],
[null, $c4, $d4],
],
null,
'B2',
true
);
$sheet->fromArray(
[
['high', 6],
['low', 2],
['medium', 4],
['none', 0],
],
null,
'B10',
true
);
$reloadedSpreadsheet = $this->writeAndReload($spreadsheet, 'Xls');
$spreadsheet->disconnectWorksheets();
$worksheet = $reloadedSpreadsheet->getActiveSheet();
self::assertSame($c3, $worksheet->getCell('C3')->getValue());
self::assertSame(4, $worksheet->getCell('C3')->getCalculatedValue());
self::assertSame($d3, $worksheet->getCell('D3')->getValue());
self::assertSame(6, $worksheet->getCell('D3')->getCalculatedValue());
self::assertSame($c4, $worksheet->getCell('C4')->getValue());
self::assertSame(4, $worksheet->getCell('C4')->getCalculatedValue());
self::assertSame($d4, $worksheet->getCell('D4')->getValue());
self::assertSame(6, $worksheet->getCell('D4')->getCalculatedValue());
$reloadedSpreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Xls/Calendar1904Test.php | tests/PhpSpreadsheetTests/Writer/Xls/Calendar1904Test.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Xls;
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, 'Xls');
$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/Xls/MicrosecondsTest.php | tests/PhpSpreadsheetTests/Writer/Xls/MicrosecondsTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Xls;
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, 'Xls');
$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/Xls/VisibilityTest.php | tests/PhpSpreadsheetTests/Writer/Xls/VisibilityTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Xls;
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, 'Xls');
$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 => true, 2 => false, 3 => false, 4 => true, 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, 'Xls');
$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' => true, 'B' => false, 'C' => false, 'D' => true, '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, 'Xls');
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/Xls/Issue642Test.php | tests/PhpSpreadsheetTests/Writer/Xls/Issue642Test.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Xls;
use PhpOffice\PhpSpreadsheet\Shared\File;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Writer\Xls;
use PHPUnit\Framework\TestCase;
class Issue642Test extends TestCase
{
public function testCharOutsideBMP(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$stringUtf8 = "Hello\u{1f600}goodbye";
$stringUtf16 = (string) iconv('UTF-8', 'UTF-16LE', $stringUtf8);
self::assertSame(28, strlen($stringUtf16)); // each character requires 2 bytes except for non-BMP which requires 4
$sheet->getCell('A1')->setValue($stringUtf8);
$outputFilename = File::temporaryFilename();
$writer = new Xls($spreadsheet);
$writer->save($outputFilename);
$spreadsheet->disconnectWorksheets();
$contents = (string) file_get_contents($outputFilename);
unlink($outputFilename);
$expected = "\x00\x0e\x00\x01" . $stringUtf16; // length is 14 (0e), not 13
self::assertStringContainsString($expected, $contents);
$unexpected = "\x00\x0d\x00\x01" . $stringUtf16; // length is 14 (0e), not 13
self::assertStringNotContainsString($unexpected, $contents);
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Xls/ConditionalLimitsTest.php | tests/PhpSpreadsheetTests/Writer/Xls/ConditionalLimitsTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Xls;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Style\Color;
use PhpOffice\PhpSpreadsheet\Style\Conditional;
use PhpOffice\PhpSpreadsheet\Style\Style;
use PhpOffice\PhpSpreadsheetTests\Functional\AbstractFunctional;
class ConditionalLimitsTest extends AbstractFunctional
{
public function testLimits(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->fromArray(
[
['Cell', 0, null, null, 'Col Rng', -2, -1],
[null, null, null, null, null, 0, 1],
['Cell Rng', -2, -1, 0, null, 2, 3],
[null, 1, 2, 3, null, 4, -1],
[],
['Row Rng'],
[-2, -1, 0],
[1, 2, 3],
],
strictNullComparison: true
);
$redStyle = new Style(false, true);
$redStyle->getFont()->setColor(new Color(Color::COLOR_RED));
$condition1 = new Conditional();
$condition1->setConditionType(Conditional::CONDITION_CELLIS)
->setOperatorType(Conditional::OPERATOR_BETWEEN)
->addCondition(-1)
->addCondition(1)
->setStyle($redStyle);
$conditionalStyles = [$condition1];
$cellRange = 'B1';
$sheet->getStyle($cellRange)->setConditionalStyles($conditionalStyles);
$condition2 = new Conditional();
$condition2->setConditionType(Conditional::CONDITION_CELLIS)
->setOperatorType(Conditional::OPERATOR_BETWEEN)
->addCondition(-1.5)
->addCondition(1.5)
->setStyle($redStyle);
$conditionalStyles = [$condition2];
$cellRange = 'F:G';
$sheet->getStyle($cellRange)->setConditionalStyles($conditionalStyles);
$condition3 = new Conditional();
$condition3->setConditionType(Conditional::CONDITION_CELLIS)
->setOperatorType(Conditional::OPERATOR_BETWEEN)
->addCondition(-1)
->addCondition(70000)
->setStyle($redStyle);
$conditionalStyles = [$condition3];
$cellRange = '7:8';
$sheet->getStyle($cellRange)->setConditionalStyles($conditionalStyles);
$cellRange = 'B3:D4';
$sheet->getStyle($cellRange)->setConditionalStyles($conditionalStyles);
$sheet->setSelectedCells('A1');
$keys = array_keys($sheet->getConditionalStylesCollection());
self::assertSame(['B1', 'F1:G1048576', 'A7:XFD8', 'B3:D4'], $keys);
$robj = $this->writeAndReload($spreadsheet, 'Xls');
$spreadsheet->disconnectWorksheets();
$sheet0 = $robj->getActiveSheet();
$conditionals = $sheet0->getConditionalStylesCollection();
self::assertSame(['B1', 'F1:G65536', 'A7:IV8', 'B3:D4'], array_keys($conditionals));
$b1 = $conditionals['B1'][0];
self::assertSame([-1, 1], $b1->getConditions());
$b1 = $conditionals['F1:G65536'][0];
self::assertSame([-1.5, 1.5], $b1->getConditions());
$b1 = $conditionals['A7:IV8'][0];
self::assertSame([-1, 70000], $b1->getConditions());
$b1 = $conditionals['B3:D4'][0];
self::assertSame([-1, 70000], $b1->getConditions());
$robj->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Xls/BooleanLiteralTest.php | tests/PhpSpreadsheetTests/Writer/Xls/BooleanLiteralTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Xls;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheetTests\Functional\AbstractFunctional;
class BooleanLiteralTest extends AbstractFunctional
{
public function testBooleanLiteral(): void
{
// Issue 3369 - Xls Writer Parser unable to handle
// TRUE (or FALSE) when specified as function arguments.
$formula = '=AND(true,true(),fAlse,false())';
$spreadsheet = new Spreadsheet();
$spreadsheet->setActiveSheetIndex(0);
$spreadsheet->getActiveSheet()->setCellValue('A1', $formula);
$robj = $this->writeAndReload($spreadsheet, 'Xls');
$spreadsheet->disconnectWorksheets();
$sheet0 = $robj->setActiveSheetIndex(0);
self::assertSame(strtoupper($formula), $sheet0->getCell('A1')->getValue());
$robj->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Xls/WorkbookTest.php | tests/PhpSpreadsheetTests/Writer/Xls/WorkbookTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Xls;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Writer\Xls\Parser;
use PhpOffice\PhpSpreadsheet\Writer\Xls\Workbook;
use PHPUnit\Framework\TestCase;
use ReflectionClass;
class WorkbookTest extends TestCase
{
private Workbook $workbook;
private ?Spreadsheet $spreadsheet = null;
protected function tearDown(): void
{
if ($this->spreadsheet !== null) {
$this->spreadsheet->disconnectWorksheets();
$this->spreadsheet = null;
}
}
private function setUpWorkbook(): void
{
if ($this->spreadsheet !== null) {
$this->spreadsheet->disconnectWorksheets();
}
$this->spreadsheet = $spreadsheet = new Spreadsheet();
$strTotal = 0;
$strUnique = 0;
$str_table = [];
$colors = [];
$parser = new Parser($spreadsheet);
$this->workbook = new Workbook($spreadsheet, $strTotal, $strUnique, $str_table, $colors, $parser);
}
/**
* @param string[] $testColors
* @param string[] $expectedResult
*/
public function xtestAddColor(array $testColors, array $expectedResult): void
{
$workbookReflection = new ReflectionClass(Workbook::class);
$methodAddColor = $workbookReflection->getMethod('addColor');
$propertyPalette = $workbookReflection->getProperty('palette');
foreach ($testColors as $testColor) {
$methodAddColor->invoke($this->workbook, $testColor);
}
$palette = $propertyPalette->getValue($this->workbook);
self::assertEquals($expectedResult, $palette);
}
public function testAddColor(): void
{
$i = 0;
$arrayEntries = $this->arrayAddColor();
while ($i < count($arrayEntries)) {
/** @var string[] */
$entry0 = $arrayEntries[$i][0];
/** @var string[] */
$entry1 = $arrayEntries[$i][1];
$this->xtestAddColor($entry0, $entry1);
++$i;
$arrayEntries = $this->arrayAddColor();
}
}
/** @return array<int, array<int, array<mixed>>> */
public function arrayAddColor(): array
{
$this->setUpWorkbook();
$workbookReflection = new ReflectionClass(Workbook::class);
$propertyPalette = $workbookReflection->getProperty('palette');
$palette = $propertyPalette->getValue($this->workbook);
self::assertIsArray($palette);
$newColor1 = [0x00, 0x00, 0x01, 0x00];
$newColor2 = [0x00, 0x00, 0x02, 0x00];
$newColor3 = [0x00, 0x00, 0x03, 0x00];
// Add one new color
$paletteTestOne = $palette;
$paletteTestOne[8] = $newColor1;
// Add one new color + one existing color after index 8
$paletteTestTwo = $paletteTestOne;
// Add one new color + one existing color before index 9
$paletteTestThree = $paletteTestOne;
$paletteTestThree[9] = $palette[8];
// Add three new color
$paletteTestFour = $palette;
$paletteTestFour[8] = $newColor1;
$paletteTestFour[9] = $newColor2;
$paletteTestFour[10] = $newColor3;
// Add all existing color
$colorsAdd = array_map([$this, 'paletteToColor'], $palette);
$paletteTestFive = $palette;
// Add new color after all existing color
$colorsAddTwo = array_map([$this, 'paletteToColor'], $palette);
$colorsAddTwo[] = $this->paletteToColor($newColor1);
$paletteTestSix = $palette;
// Add one existing color
$paletteTestSeven = $palette;
// Add two existing color
$paletteTestHeight = $palette;
// Add last existing color and add one new color
$keyPalette = array_keys($palette);
$last = end($keyPalette);
self::assertIsArray($palette[8]);
self::assertIsArray($palette[10]);
self::assertIsArray($palette[12]);
self::assertIsArray($palette[25]);
self::assertIsArray($palette[$last]);
$lastColor = $this->paletteToColor($palette[$last]);
$paletteTestNine = $palette;
return [
[[$this->paletteToColor($newColor1)], $paletteTestOne],
[[$this->paletteToColor($newColor1), $this->paletteToColor($palette[12])], $paletteTestTwo],
[[$this->paletteToColor($newColor1), $this->paletteToColor($palette[8])], $paletteTestThree],
[[$this->paletteToColor($newColor1), $this->paletteToColor($newColor2), $this->paletteToColor($newColor3)], $paletteTestFour],
[$colorsAdd, $paletteTestFive],
[$colorsAddTwo, $paletteTestSix],
[[$this->paletteToColor($palette[8])], $paletteTestSeven],
[[$this->paletteToColor($palette[25]), $this->paletteToColor($palette[10])], $paletteTestHeight],
[[$lastColor, $this->paletteToColor($newColor1)], $paletteTestNine],
];
}
/**
* Change palette color to rgb string.
*
* @param array<mixed, mixed> $palette
*/
private function paletteToColor(array $palette): string
{
return $this->right('00' . self::dec2hex($palette[0]), 2)
. $this->right('00' . self::dec2hex($palette[1]), 2)
. $this->right('00' . self::dec2hex($palette[2]), 2);
}
private static function dec2hex(mixed $value): string
{
return is_numeric($value) ? dechex((int) $value) : '0';
}
/**
* Return n right character in string.
*
* @param string $value text to get right character
* @param int $nbchar number of char at right of string
*/
private function right(string $value, int $nbchar): string
{
return mb_substr($value, mb_strlen($value) - $nbchar, $nbchar);
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Xls/NonLatinFormulasTest.php | tests/PhpSpreadsheetTests/Writer/Xls/NonLatinFormulasTest.php | <?php
namespace PhpOffice\PhpSpreadsheetTests\Writer\Xls;
use PhpOffice\PhpSpreadsheet\Cell\DataValidation;
use PhpOffice\PhpSpreadsheet\Cell\DataValidator;
use PhpOffice\PhpSpreadsheet\NamedRange;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheetTests\Functional\AbstractFunctional;
class NonLatinFormulasTest extends AbstractFunctional
{
public function testNonLatin(): void
{
$spreadsheet = new Spreadsheet();
$worksheet = $spreadsheet->getActiveSheet();
$validation = $worksheet->getCell('B1')->getDataValidation();
$validation->setType(DataValidation::TYPE_LIST);
$validation->setErrorStyle(DataValidation::STYLE_STOP);
$validation->setAllowBlank(false);
$validation->setShowInputMessage(true);
$validation->setShowErrorMessage(true);
$validation->setShowDropDown(true);
$validation->setFormula1('"слово, сло"');
$dataValidator = new DataValidator();
$worksheet->getCell('B1')->setValue('слово');
self::assertTrue(
$dataValidator->isValid($worksheet->getCell('B1'))
);
$worksheet->getCell('B1')->setValue('слов');
self::assertFalse(
$dataValidator->isValid($worksheet->getCell('B1'))
);
$worksheet->setTitle('словслов');
$worksheet->getCell('A1')->setValue('=словслов!B1');
$worksheet->getCell('A2')->setValue("='словслов'!B1");
$spreadsheet->addNamedRange(new NamedRange('слсл', $worksheet, '$B$1'));
$worksheet->getCell('A3')->setValue('=слсл');
$robj = $this->writeAndReload($spreadsheet, 'Xls');
$spreadsheet->disconnectWorksheets();
$sheet0 = $robj->getActiveSheet();
self::assertSame('словслов', $sheet0->getTitle());
self::assertSame('=словслов!B1', $sheet0->getCell('A1')->getValue());
self::assertSame('слов', $sheet0->getCell('A1')->getCalculatedValue());
// Quotes around sheet name are stripped off - harmless
//self::assertSame("='словслов'!B1", $sheet0->getCell('A2')->getValue());
self::assertSame('слов', $sheet0->getCell('A2')->getCalculatedValue());
// Formulas with defined names don't work in Xls Writer
//self::assertSame('=слсл', $sheet0->getCell('A3')->getValue());
// But result should be accurate
self::assertSame('слов', $sheet0->getCell('A3')->getCalculatedValue());
$names = $robj->getDefinedNames();
self::assertCount(1, $names);
// name has been uppercased
$namedRange = $names['СЛСЛ'] ?? null;
self::assertInstanceOf(NamedRange::class, $namedRange);
self::assertSame('$B$1', $namedRange->getRange());
$robj->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Xls/ConditionalUnionTest.php | tests/PhpSpreadsheetTests/Writer/Xls/ConditionalUnionTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Xls;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Style\Conditional;
use PhpOffice\PhpSpreadsheetTests\Functional\AbstractFunctional;
class ConditionalUnionTest extends AbstractFunctional
{
public function testConditionalUnion(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->fromArray([
[1, 2, 3, 4, 5],
[2, 3, 4, 5, 6],
[3, 4, 5, 6, 7],
]);
$condition1 = new Conditional();
$condition1->setConditionType(Conditional::CONDITION_CELLIS);
$condition1->setOperatorType(Conditional::OPERATOR_BETWEEN);
$condition1->setConditions([2, 4]);
$condition1->getStyle()->getFont()
->setBold(true);
$conditionalStyles = [$condition1];
$sheet->setConditionalStyles('A1:A3,C1:E3', $conditionalStyles);
$robj = $this->writeAndReload($spreadsheet, 'Xls');
$spreadsheet->disconnectWorksheets();
$sheet0 = $robj->getActiveSheet();
$conditionals = $sheet0->getConditionalStylesCollection();
self::assertSame(['A1:A3', 'C1:E3'], array_keys($conditionals));
$cond1 = $conditionals['A1:A3'][0];
self::assertSame(Conditional::CONDITION_CELLIS, $cond1->getConditionType());
self::assertSame(Conditional::OPERATOR_BETWEEN, $cond1->getOperatorType());
self::assertSame([2, 4], $cond1->getConditions());
$font1 = $cond1->getStyle()->getFont();
self::assertTrue($font1->getBold());
$cond2 = $conditionals['C1:E3'][0];
self::assertSame(Conditional::CONDITION_CELLIS, $cond2->getConditionType());
self::assertSame(Conditional::OPERATOR_BETWEEN, $cond2->getOperatorType());
self::assertSame([2, 4], $cond2->getConditions());
$font2 = $cond2->getStyle()->getFont();
self::assertTrue($font2->getBold());
$robj->disconnectWorksheets();
}
public function testIntersectionRange(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->fromArray([
[1, 2, 3, 4, 5],
[2, 3, 4, 5, 6],
[3, 4, 5, 6, 7],
]);
$condition1 = new Conditional();
$condition1->setConditionType(Conditional::CONDITION_CELLIS);
$condition1->setOperatorType(Conditional::OPERATOR_BETWEEN);
$condition1->setConditions([2, 3]);
$condition1->getStyle()->getFont()
->setBold(true);
$conditionalStyles = [$condition1];
$sheet->setConditionalStyles('A1:B5,D1:E5 B2:D4', $conditionalStyles);
$robj = $this->writeAndReload($spreadsheet, 'Xls');
$spreadsheet->disconnectWorksheets();
$sheet0 = $robj->getActiveSheet();
$conditionals = $sheet0->getConditionalStylesCollection();
self::assertSame(['A1:B5', 'D2', 'D3', 'D4'], array_keys($conditionals));
$cond1 = $conditionals['A1:B5'][0];
self::assertSame(Conditional::CONDITION_CELLIS, $cond1->getConditionType());
self::assertSame(Conditional::OPERATOR_BETWEEN, $cond1->getOperatorType());
self::assertSame([2, 3], $cond1->getConditions());
$font1 = $cond1->getStyle()->getFont();
self::assertTrue($font1->getBold());
$cond2 = $conditionals['D2'][0];
self::assertSame(Conditional::CONDITION_CELLIS, $cond2->getConditionType());
self::assertSame(Conditional::OPERATOR_BETWEEN, $cond2->getOperatorType());
self::assertSame([2, 3], $cond2->getConditions());
$font2 = $cond2->getStyle()->getFont();
self::assertTrue($font2->getBold());
$robj->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Dompdf/TextRotationTest.php | tests/PhpSpreadsheetTests/Writer/Dompdf/TextRotationTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Dompdf;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Writer\Pdf\Dompdf;
use PHPUnit\Framework\TestCase;
class TextRotationTest extends TestCase
{
public function testTextRotation(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->setPrintGridlines(true);
$sheet->getStyle('A7')->getAlignment()->setTextRotation(90);
$sheet->setCellValue('A7', 'Lorem Ipsum');
$writer = new Dompdf($spreadsheet);
$html = $writer->generateHtmlAll();
self::assertStringContainsString(' transform:rotate(90deg);', $html);
$spreadsheet->disconnectWorksheets();
unset($spreadsheet);
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Dompdf/PrintAreaTest.php | tests/PhpSpreadsheetTests/Writer/Dompdf/PrintAreaTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Dompdf;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Writer\Pdf\Dompdf as DompdfWriter;
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 DompdfWriter($spreadsheet);
$html = $writer->generateHtmlAll();
$html = preg_replace('/^ +/m', '', $html) ?? $html;
$expectedArray = [
'<tbody>',
'<tr class="row1">',
'<td class="column0 style0 n" style="width:42pt">7</td>',
'<td class="column1 style0 n" style="width:42pt">8</td>',
'<td class="column2 style0 n" style="width:42pt">9</td>',
'</tr>',
'<tr class="row2">',
'<td class="column0 style0 n" style="width:42pt">12</td>',
'<td class="column1 style0 n" style="width:42pt">13</td>',
'<td class="column2 style0 n" style="width:42pt">14</td>',
'</tr>',
'<tr class="row3">',
'<td class="column0 style0 n" style="width:42pt">17</td>',
'<td class="column1 style0 n" style="width:42pt">18</td>',
'<td class="column2 style0 n" style="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/Dompdf/HideTest.php | tests/PhpSpreadsheetTests/Writer/Dompdf/HideTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Dompdf;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Writer\Pdf\Dompdf;
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 Dompdf($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/Dompdf/HideMergeTest.php | tests/PhpSpreadsheetTests/Writer/Dompdf/HideMergeTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Dompdf;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Style\Alignment;
use PhpOffice\PhpSpreadsheet\Style\Border;
use PhpOffice\PhpSpreadsheet\Style\Color;
use PhpOffice\PhpSpreadsheet\Writer\Pdf\Dompdf;
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 Dompdf($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" style="width:42pt; height:17pt">A</td>'
. '<td class="column1 style0 s" style="width:42pt; height:17pt">B</td>'
. '<td class="column2 style0 s" style="width:42pt; height:17pt">C</td>'
. '</tr>',
$html
);
self::assertStringContainsString(
'<tr class="row1">'
. '<td class="column0 style0" style="width:42pt; height:17pt"> </td>'
. '<td class="column1 style1 s style1" colspan="2" rowspan="2" style="width:84pt; height:17pt">Hello World Headline</td>'
. '</tr>',
$html
);
self::assertStringContainsString(
'<tr class="row2">'
. '<td class="column0 style0" style="width:42pt; height:17pt"> </td>'
. '</tr>',
$html
);
self::assertStringContainsString(
'<tr class="row3">'
. '<td class="column0 style0" style="width:42pt; height:17pt"> </td>'
. '<td class="column1 style2 s style2" rowspan="2" style="width:42pt; height:17pt">Label 1</td>'
. '<td class="column2 style3 s style3" rowspan="2" style="width:42pt; height:17pt">Text 1</td>'
. '</tr>',
$html
);
self::assertStringContainsString(
'<tr class="row4">'
. '<td class="column0 style0" style="width:42pt; height:17pt"> </td>'
. '</tr>',
$html
);
self::assertStringContainsString(
'<tr class="row5">'
. '<td class="column0 style0" style="width:42pt; height:17pt"> </td>'
. '<td class="column1 style2 s style2" rowspan="2" style="width:42pt; height:17pt">Label 2</td>'
. '<td class="column2 style3 s style3" rowspan="2" style="width:42pt; height:17pt">Text 2</td>'
. '</tr>',
$html
);
self::assertStringContainsString(
'<tr class="row6">'
. '<td class="column0 style0" style="width:42pt; height:17pt"> </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/Dompdf/PaperSizeArrayTest.php | tests/PhpSpreadsheetTests/Writer/Dompdf/PaperSizeArrayTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Dompdf;
use PhpOffice\PhpSpreadsheet\Shared\File;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Worksheet\PageSetup;
use PhpOffice\PhpSpreadsheet\Writer\Pdf\Dompdf;
use PHPUnit\Framework\TestCase;
class PaperSizeArrayTest extends TestCase
{
private string $outfile = '';
protected function tearDown(): void
{
if ($this->outfile !== '') {
unlink($this->outfile);
$this->outfile = '';
}
}
public function testPaperSizeArray(): void
{
// Issue 1713 - array in PhpSpreadsheet is 2 elements,
// but in Dompdf it is 4 elements, first 2 are zero.
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
// TABLOID is a 2-element array in Writer/Pdf.php $paperSizes
$size = PageSetup::PAPERSIZE_TABLOID;
$sheet->getPageSetup()->setPaperSize($size);
$sheet->setPrintGridlines(true);
$sheet->getStyle('A7')->getAlignment()->setTextRotation(90);
$sheet->setCellValue('A7', 'Lorem Ipsum');
$writer = new Dompdf($spreadsheet);
$this->outfile = File::temporaryFilename();
$writer->save($this->outfile);
$spreadsheet->disconnectWorksheets();
unset($spreadsheet);
$contents = file_get_contents($this->outfile);
self::assertNotFalse($contents);
self::assertStringContainsString('/MediaBox [0.000 0.000 792.000 1224.000]', $contents);
}
public function testPaperSizeNotArray(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
// LETTER is a string in Writer/Pdf.php $paperSizes
$size = PageSetup::PAPERSIZE_LETTER;
$sheet->getPageSetup()->setPaperSize($size);
$sheet->setPrintGridlines(true);
$sheet->getStyle('A7')->getAlignment()->setTextRotation(90);
$sheet->setCellValue('A7', 'Lorem Ipsum');
$writer = new Dompdf($spreadsheet);
$this->outfile = File::temporaryFilename();
$writer->save($this->outfile);
$spreadsheet->disconnectWorksheets();
unset($spreadsheet);
$contents = file_get_contents($this->outfile);
self::assertNotFalse($contents);
self::assertStringContainsString('/MediaBox [0.000 0.000 612.000 792.000]', $contents);
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Html/BetterBooleanTest.php | tests/PhpSpreadsheetTests/Writer/Html/BetterBooleanTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Html;
use PhpOffice\PhpSpreadsheet\Calculation\Calculation;
use PhpOffice\PhpSpreadsheet\Cell\DataType;
use PhpOffice\PhpSpreadsheet\Reader\Html as HtmlReader;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Writer\Html as HtmlWriter;
use PhpOffice\PhpSpreadsheetTests\Functional;
class BetterBooleanTest extends Functional\AbstractFunctional
{
private string $locale;
protected function setUp(): void
{
$calculation = Calculation::getInstance();
$this->locale = $calculation->getLocale();
}
protected function tearDown(): void
{
$calculation = Calculation::getInstance();
$calculation->setLocale($this->locale);
}
public function testDefault(): void
{
$spreadsheet = new Spreadsheet();
$writer = new HtmlWriter($spreadsheet);
// Default change with release 4.0.0
self::assertTrue($writer->getBetterBoolean());
$spreadsheet->disconnectWorksheets();
}
public function setBetter(HtmlWriter $writer): void
{
$writer->setBetterBoolean(true);
}
public function setNotBetter(HtmlWriter $writer): void
{
$writer->setBetterBoolean(false);
}
public function testBetterBoolean(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->getCell('A1')->setValue(1);
$sheet->getCell('B1')->setValue('Hello');
$sheet->getCell('C1')->setValue(true);
$sheet->getCell('D1')->setValue('=IF(1>2, TRUE, FALSE)');
$sheet->getCell('E1')->setValueExplicit(1, DataType::TYPE_STRING);
$sheet->getCell('F1')->setValue('="A"&"B"');
$sheet->getCell('G1')->setValue('=1+2');
$reloaded = $this->writeAndReload($spreadsheet, 'Html');
$falseTrue = Calculation::getInstance($spreadsheet)->getFalseTrueArray();
$countPortTrue = 0;
$portTrue = 'VERDADEIRO';
$portFalse = 'FALSO';
$countArray = count($falseTrue[1]);
for ($i = 0; $i < $countArray; ++$i) {
if ($falseTrue[1][$i] === $portTrue) {
++$countPortTrue;
self::assertSame($portFalse, $falseTrue[0][$i]);
}
}
self::assertSame(2, $countPortTrue, '1 for pt, 1 for pt-br');
$spreadsheet->disconnectWorksheets();
$rsheet = $reloaded->getActiveSheet();
self::assertSame(1, $rsheet->getCell('A1')->getValue());
self::assertSame('Hello', $rsheet->getCell('B1')->getValue());
self::assertTrue($rsheet->getCell('C1')->getValue());
self::assertFalse($rsheet->getCell('D1')->getValue());
self::assertSame('1', $rsheet->getCell('E1')->getValue());
self::assertSame('AB', $rsheet->getCell('F1')->getValue());
self::assertSame(3, $rsheet->getCell('G1')->getValue());
$reloaded->disconnectWorksheets();
}
public function testNotBetterBoolean(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->getCell('A1')->setValue(1);
$sheet->getCell('B1')->setValue('Hello');
$sheet->getCell('C1')->setValue(true);
$sheet->getCell('D1')->setValue('=IF(1>2, TRUE, FALSE)');
$sheet->getCell('E1')->setValueExplicit(1, DataType::TYPE_STRING);
$sheet->getCell('F1')->setValue('="A"&"B"');
$sheet->getCell('G1')->setValue('=1+2');
$reloaded = $this->writeAndReload($spreadsheet, 'Html', null, $this->setNotBetter(...));
$spreadsheet->disconnectWorksheets();
$rsheet = $reloaded->getActiveSheet();
self::assertSame(1, $rsheet->getCell('A1')->getValue());
self::assertSame('Hello', $rsheet->getCell('B1')->getValue());
self::assertSame(1, $rsheet->getCell('C1')->getValue());
self::assertNull($rsheet->getCell('D1')->getValue());
self::assertSame(1, $rsheet->getCell('E1')->getValue());
self::assertSame('AB', $rsheet->getCell('F1')->getValue());
self::assertSame(3, $rsheet->getCell('G1')->getValue());
$reloaded->disconnectWorksheets();
}
public function testLocale(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->getCell('A1')->setValue(1);
$sheet->getCell('B1')->setValue('Hello');
$sheet->getCell('C1')->setValue(true);
$sheet->getCell('D1')->setValue('=IF(1>2, TRUE, FALSE)');
$sheet->getCell('E1')->setValueExplicit(1, DataType::TYPE_STRING);
$sheet->getCell('F1')->setValue('="A"&"B"');
$sheet->getCell('G1')->setValue('=1+2');
$calc = Calculation::getInstance();
$calc->setLocale('fr');
$writer = new HtmlWriter($spreadsheet);
$writer->setBetterBoolean(true);
$html = $writer->generateHtmlAll();
self::assertStringNotContainsString('TRUE', $html);
self::assertStringContainsString('<td data-type="b" class="column2 style0 b">VRAI</td>', $html);
self::assertStringContainsString('<td data-type="b" class="column3 style0 b">FAUX</td>', $html);
self::assertStringContainsString('<td data-type="s" class="column4 style0 s">1</td>', $html);
self::assertStringContainsString('<td class="column5 style0 s">AB</td>', $html);
self::assertStringContainsString('<td class="column6 style0 n">3</td>', $html);
$reloaded = $this->writeAndReload($spreadsheet, 'Html', null, $this->setBetter(...));
$spreadsheet->disconnectWorksheets();
$rsheet = $reloaded->getActiveSheet();
self::assertSame(1, $rsheet->getCell('A1')->getValue());
self::assertSame('Hello', $rsheet->getCell('B1')->getValue());
self::assertTrue($rsheet->getCell('C1')->getValue());
self::assertFalse($rsheet->getCell('D1')->getValue());
self::assertSame('1', $rsheet->getCell('E1')->getValue());
self::assertSame('AB', $rsheet->getCell('F1')->getValue());
self::assertSame(3, $rsheet->getCell('G1')->getValue());
$reloaded->disconnectWorksheets();
}
public function testInline(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->setPrintGridlines(true);
$sheet->getCell('A1')->setValue(1);
$sheet->getCell('B1')->setValue('Hello');
$sheet->getCell('C1')->setValue(true);
$sheet->getCell('D1')->setValue('=IF(1>2, TRUE, FALSE)');
$sheet->getCell('E1')->setValueExplicit(1, DataType::TYPE_STRING);
$sheet->getCell('F1')->setValue('="A"&"B"');
$sheet->getCell('G1')->setValue('=1+2');
$calc = Calculation::getInstance();
$calc->setLocale('fr');
$writer = new HtmlWriter($spreadsheet);
$writer->setBetterBoolean(true);
$writer->setUseInlineCss(true);
$html = $writer->generateHtmlAll();
$html = str_replace('vertical-align:bottom; color:#000000; font-family:\'Calibri\'; font-size:11pt; ', '', $html);
$html = str_replace(' width:42pt"', '"', $html);
self::assertStringNotContainsString('TRUE', $html);
self::assertStringContainsString('<td class="gridlines gridlinesp" style="text-align:right;">1</td>', $html);
self::assertStringContainsString('<td class="gridlines gridlinesp" style="text-align:left;">Hello</td>', $html);
self::assertStringContainsString('<td data-type="b" class="gridlines gridlinesp" style="text-align:center;">VRAI</td>', $html);
self::assertStringContainsString('<td data-type="b" class="gridlines gridlinesp" style="text-align:center;">FAUX</td>', $html);
self::assertStringContainsString('<td data-type="s" class="gridlines gridlinesp" style="text-align:left;">1</td>', $html);
self::assertStringContainsString('<td class="gridlines gridlinesp" style="text-align:left;">AB</td>', $html);
self::assertStringContainsString('<td class="gridlines gridlinesp" style="text-align:right;">3</td>', $html);
$reloaded = $this->writeAndReload($spreadsheet, 'Html', null, $this->setBetter(...));
$spreadsheet->disconnectWorksheets();
$rsheet = $reloaded->getActiveSheet();
self::assertSame(1, $rsheet->getCell('A1')->getValue());
self::assertSame('Hello', $rsheet->getCell('B1')->getValue());
self::assertTrue($rsheet->getCell('C1')->getValue());
self::assertFalse($rsheet->getCell('D1')->getValue());
self::assertSame('1', $rsheet->getCell('E1')->getValue());
self::assertSame('AB', $rsheet->getCell('F1')->getValue());
self::assertSame(3, $rsheet->getCell('G1')->getValue());
$reloaded->disconnectWorksheets();
}
public function testForeignNoLocale(): void
{
$fragment = '<table><tbody><tr>'
. '<td>1</td>'
. '<td>Hello</td>'
. '<td data-type="b">ИСТИНА</td>' // Bulgarian TRUE
. '<td data-type="b">EPÄTOSI</td>' // Finnish FALSE
. '<td data-type="b">whatever</td>'
. '<td data-type="b">tRuE</td>'
. '<td data-type="s">1</td>'
. '</tr></tbody></table>';
$reader = new HtmlReader();
$spreadsheet = $reader->loadFromString($fragment);
$sheet = $spreadsheet->getActiveSheet();
self::assertSame(1, $sheet->getCell('A1')->getValue());
self::assertSame('Hello', $sheet->getCell('B1')->getValue());
self::assertTrue($sheet->getCell('C1')->getValue());
self::assertFalse($sheet->getCell('D1')->getValue());
self::assertSame('whatever', $sheet->getCell('E1')->getValue());
self::assertTrue($sheet->getCell('F1')->getValue());
self::assertSame('1', $sheet->getCell('G1')->getValue());
$spreadsheet->disconnectWorksheets();
}
public function testNoPreCalc(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->setCellValue('A1', true);
$writer = new HtmlWriter($spreadsheet);
$writer->setPreCalculateFormulas(false);
$writer->setBetterBoolean(true);
$html = $writer->generateHtmlAll();
self::assertStringContainsString('<td data-type="b" class="column0 style0 b">TRUE</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/TextRotationTest.php | tests/PhpSpreadsheetTests/Writer/Html/TextRotationTest.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 TextRotationTest extends TestCase
{
public function testTextRotation(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->setPrintGridlines(true);
$sheet->getStyle('A7')->getAlignment()->setTextRotation(90);
$sheet->setCellValue('A7', 'Lorem Ipsum');
$writer = new Html($spreadsheet);
$html = $writer->generateHtmlAll();
self::assertStringContainsString(' transform:rotate(90deg);', $html);
$spreadsheet->disconnectWorksheets();
unset($spreadsheet);
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Html/TransparentDrawingsTest.php | tests/PhpSpreadsheetTests/Writer/Html/TransparentDrawingsTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Html;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Worksheet\Drawing;
use PhpOffice\PhpSpreadsheet\Worksheet\MemoryDrawing;
use PhpOffice\PhpSpreadsheet\Writer\Html as HtmlWriter;
use PHPUnit\Framework\TestCase;
class TransparentDrawingsTest extends TestCase
{
public function testHtmlTransparentDrawing(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->setShowGridLines(false);
$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->setCoordinates2('E8');
$drawing->setOpacity(25000);
$drawing->setWorksheet($sheet);
$writer = new HtmlWriter($spreadsheet);
$content = $writer->generateHTMLAll();
self::assertStringContainsString('opacity:0.25;', $content);
$spreadsheet->disconnectWorksheets();
}
public function testHtmlTransparentMemoryDrawing(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->setShowGridLines(false);
$contents = file_get_contents('tests/data/Writer/XLSX/blue_square.png');
$drawing = MemoryDrawing::fromString("$contents");
$drawing->setName('Blue Square');
self::assertEquals($drawing->getWidth(), 100);
self::assertEquals($drawing->getHeight(), 100);
$drawing->setCoordinates('A1');
$drawing->setCoordinates2('E8');
$drawing->setOpacity(25000);
$drawing->setWorksheet($sheet);
$writer = new HtmlWriter($spreadsheet);
$content = $writer->generateHTMLAll();
self::assertStringContainsString('opacity:0.25;', $content);
$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/CalcErrorTest.php | tests/PhpSpreadsheetTests/Writer/Html/CalcErrorTest.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 CalcErrorTest extends TestCase
{
public function testCalcError(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->setCellValue('A1', '={');
$writer = new HtmlWriter($spreadsheet);
$html = $writer->generateHtmlAll();
self::assertStringContainsString('<td data-type="e" class="column0 style0 e">#ERROR</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/HtmlNumberFormatTest.php | tests/PhpSpreadsheetTests/Writer/Html/HtmlNumberFormatTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Html;
use DOMDocument;
use PhpOffice\PhpSpreadsheet\Settings;
use PhpOffice\PhpSpreadsheet\Shared\StringHelper;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Writer\Html;
use PhpOffice\PhpSpreadsheetTests\Functional;
use PHPUnit\Framework\Attributes\DataProvider;
class HtmlNumberFormatTest extends Functional\AbstractFunctional
{
protected function setUp(): void
{
StringHelper::setCurrencyCode('$');
StringHelper::setDecimalSeparator('.');
StringHelper::setThousandsSeparator(',');
}
protected function tearDown(): void
{
StringHelper::setCurrencyCode(null);
StringHelper::setDecimalSeparator(null);
StringHelper::setThousandsSeparator(null);
}
public function testColorNumberFormat(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->setCellValue('A1', -50);
$sheet->setCellValue('A2', 3000);
$sheet->setCellValue('A3', 0);
$sheet->setCellValue('A4', '<br>');
$fmt = '[Blue]$#,##0;[Red]$#,##0;$#,##0';
$sheet->getStyle('A1:A4')->getNumberFormat()->setFormatCode($fmt);
$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');
$tabl = $divs->item(0)?->getElementsByTagName('table');
$tbod = $tabl?->item(0)?->getElementsByTagName('tbody');
$rows = $tbod?->item(0)?->getElementsByTagName('tr');
self::assertCount(4, $rows);
$tds = $rows?->item(0)?->getElementsByTagName('td');
self::assertCount(1, $tds);
$spans = $tds?->item(0)?->getElementsByTagName('span');
self::assertCount(1, $spans);
$style = $spans?->item(0)?->getAttribute('style');
self::assertSame(1, preg_match('/color:red/', "$style"));
self::assertSame('$50', $spans?->item(0)?->textContent);
$tds = $rows?->item(1)?->getElementsByTagName('td');
self::assertCount(1, $tds);
$spans = $tds?->item(0)?->getElementsByTagName('span');
self::assertCount(1, $spans);
$style = $spans?->item(0)?->getAttribute('style');
self::assertSame(1, preg_match('/color:blue/', "$style"));
self::assertSame('$3,000', $spans?->item(0)?->textContent);
$tds = $rows?->item(2)?->getElementsByTagName('td');
self::assertCount(1, $tds);
$spans = $tds?->item(0)?->getElementsByTagName('span');
self::assertCount(0, $spans);
self::assertSame('$0', $tds?->item(0)?->textContent);
$tds = $rows?->item(3)?->getElementsByTagName('td');
self::assertCount(1, $tds);
$spans = $tds?->item(0)?->getElementsByTagName('span');
self::assertCount(0, $spans);
self::assertEquals('<br>', $tds?->item(0)?->textContent);
$rls = $this->writeAndReload($spreadsheet, 'Html');
$spreadsheet->disconnectWorksheets();
$rls->disconnectWorksheets();
}
public function testColorNumberFormatComplex(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->setCellValue('A1', -50);
$sheet->setCellValue('A2', 3000.75);
$sheet->setCellValue('A3', 0);
$sheet->setCellValue('A4', 3000.25);
$fmt = '[Blue][>=3000.5]$#,##0.00;[Red][<0]$#,##0.00;$#,##0.00';
$sheet->getStyle('A1:A4')->getNumberFormat()->setFormatCode($fmt);
$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');
$tabl = $divs->item(0)?->getElementsByTagName('table');
$tbod = $tabl?->item(0)?->getElementsByTagName('tbody');
$rows = $tbod?->item(0)?->getElementsByTagName('tr');
self::assertCount(4, $rows);
$tds = $rows?->item(0)?->getElementsByTagName('td');
self::assertCount(1, $tds);
$spans = $tds?->item(0)?->getElementsByTagName('span');
self::assertCount(1, $spans);
$style = $spans?->item(0)?->getAttribute('style');
self::assertSame(1, preg_match('/color:red/', "$style"));
self::assertSame('$50.00', $spans?->item(0)?->textContent);
$tds = $rows?->item(1)?->getElementsByTagName('td');
self::assertCount(1, $tds);
$spans = $tds?->item(0)?->getElementsByTagName('span');
self::assertCount(1, $spans);
$style = $spans?->item(0)?->getAttribute('style');
self::assertSame(1, preg_match('/color:blue/', "$style"));
self::assertSame('$3,000.75', $spans?->item(0)?->textContent);
$tds = $rows?->item(2)?->getElementsByTagName('td');
self::assertCount(1, $tds);
$spans = $tds?->item(0)?->getElementsByTagName('span');
self::assertCount(0, $spans);
self::assertSame('$0.00', $tds?->item(0)?->textContent);
$tds = $rows?->item(3)?->getElementsByTagName('td');
self::assertCount(1, $tds);
$spans = $tds?->item(0)?->getElementsByTagName('span');
self::assertCount(0, $spans);
self::assertSame('$3,000.25', $tds?->item(0)?->textContent);
$rls = $this->writeAndReload($spreadsheet, 'Html');
$spreadsheet->disconnectWorksheets();
$rls->disconnectWorksheets();
}
#[DataProvider('numberFormatProvider')]
public function testFormatValueWithMask(mixed $expectedResult, mixed $val, string $fmt): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->getCell('A1')->setValue($val)->getStyle()->getNumberFormat()->setFormatCode($fmt);
$writer = new Html($spreadsheet);
$html = $writer->generateHTMLAll();
$html = str_replace('> <', '><', $html); // clear empty cells
$dom = new DOMDocument();
$dom->loadHTML($html);
$body = $dom->getElementsByTagName('body')->item(0);
self::assertNotNull($body);
$divs = $body->getElementsByTagName('div');
$tabl = $divs->item(0)?->getElementsByTagName('table');
$tbod = $tabl?->item(0)?->getElementsByTagName('tbody');
$rows = $tbod?->item(0)?->getElementsByTagName('tr');
$tds = $rows?->item(0)?->getElementsByTagName('td');
$nbsp = html_entity_decode(' ', Settings::htmlEntityFlags());
self::assertEquals($expectedResult, str_replace($nbsp, ' ', (string) $tds?->item(0)?->textContent));
$rls = $this->writeAndReload($spreadsheet, 'Html');
$spreadsheet->disconnectWorksheets();
$rls->disconnectWorksheets();
}
/** @return mixed[] */
public static function numberFormatProvider(): array
{
/** @var mixed[] */
$retVal = require __DIR__ . '/../../../data/Style/NumberFormat.php';
return $retVal;
}
#[DataProvider('numberFormatDatesProvider')]
public function testFormatValueWithMaskDate(mixed $expectedResult, mixed $val, string $fmt): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->getCell('A1')->setValue($val)->getStyle()->getNumberFormat()->setFormatCode($fmt);
$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');
$tabl = $divs->item(0)?->getElementsByTagName('table');
$tbod = $tabl?->item(0)?->getElementsByTagName('tbody');
$rows = $tbod?->item(0)?->getElementsByTagName('tr');
$tds = $rows?->item(0)?->getElementsByTagName('td');
$nbsp = html_entity_decode(' ', Settings::htmlEntityFlags());
self::assertSame($expectedResult, str_replace($nbsp, ' ', (string) $tds?->item(0)?->textContent));
$rls = $this->writeAndReload($spreadsheet, 'Html');
$spreadsheet->disconnectWorksheets();
$rls->disconnectWorksheets();
}
/** @return mixed[] */
public static function numberFormatDatesProvider(): array
{
/** @var mixed[] */
$retVal = require __DIR__ . '/../../../data/Style/NumberFormatDates.php';
return $retVal;
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Html/NoJavascriptLinksTest.php | tests/PhpSpreadsheetTests/Writer/Html/NoJavascriptLinksTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Html;
use PhpOffice\PhpSpreadsheet\Cell\Hyperlink;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Writer\Html;
use PHPUnit\Framework\TestCase;
class NoJavascriptLinksTest extends TestCase
{
public function testNoJavascriptLinks(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->getCell('A1')->setValue('Click me');
$hyperlink = new Hyperlink('http://www.example.com');
$sheet->getCell('A1')->setHyperlink($hyperlink);
$sheet->getCell('A2')->setValue('JS link');
$hyperlink2 = new Hyperlink('javascript:alert(\'hello1\')');
$sheet->getCell('A2')->setHyperlink($hyperlink2);
$sheet->getCell('A3')->setValue('=HYPERLINK("javascript:alert(\'hello2\')", "jsfunc click")');
$writer = new Html($spreadsheet);
$html = $writer->generateHTMLAll();
self::assertStringContainsString('<td class="column0 style0 s"><a href="http://www.example.com">Click me</a></td>', $html, 'http hyperlink retained');
self::assertStringContainsString('<td class="column0 style0 s">javascript:alert(\'hello1\')</td>', $html, 'javascript hyperlink dropped');
self::assertStringContainsString('<td class="column0 style0 s">javascript:alert(\'hello2\')</td>', $html, 'javascript hyperlink function dropped');
$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/HtmlCommentsTest.php | tests/PhpSpreadsheetTests/Writer/Html/HtmlCommentsTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Html;
use PhpOffice\PhpSpreadsheet\RichText\RichText;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Writer\Html;
use PhpOffice\PhpSpreadsheetTests\Functional;
use PHPUnit\Framework\Attributes\DataProvider;
class HtmlCommentsTest extends Functional\AbstractFunctional
{
public static function providerCommentRichText(): array
{
$valueSingle = 'I am comment.';
$valueMulti = 'I am ' . PHP_EOL . 'multi-line' . PHP_EOL . 'comment.';
$plainSingle = new RichText();
$plainSingle->createText($valueSingle);
$plainMulti = new RichText();
$plainMulti->createText($valueMulti);
$richSingle = new RichText();
$font = $richSingle->createTextRun($valueSingle)->getFont();
self::assertNotNull($font);
$font->setBold(true);
$richMultiSimple = new RichText();
$font = $richMultiSimple->createTextRun($valueMulti)->getFont();
self::assertNotNull($font);
$font->setBold(true);
$richMultiMixed = new RichText();
$richMultiMixed->createText('I am' . PHP_EOL);
$font = $richMultiMixed->createTextRun('multi-line')->getFont();
self::assertNotNull($font);
$font->setBold(true);
$richMultiMixed->createText(PHP_EOL . 'comment!');
$richMultiMixed = new RichText();
$richMultiMixed->createText('I am' . PHP_EOL);
$font = $richMultiMixed->createTextRun('multi-line')->getFont();
self::assertNotNull($font);
$font->setBold(true);
$richMultiMixed->createText(PHP_EOL . 'comment!');
$scriptTextSingle = 'I am <script>alert("Hello")</script>';
$scriptSingle = new RichText();
$scriptSingle->createText($scriptTextSingle);
return [
'single line plain text' => [$plainSingle, '<td class="column0 style0 s"><a class="comment-indicator"></a><div class="comment">'
. 'I am comment.</div>' . PHP_EOL
. 'Comment</td>'],
'multi-line plain text' => [$plainMulti, '<td class="column0 style0 s"><a class="comment-indicator"></a><div class="comment">'
. 'I am <br />' . PHP_EOL
. 'multi-line<br />' . PHP_EOL
. 'comment.</div>' . PHP_EOL
. 'Comment</td>'],
'single line simple rich text' => [$richSingle, '<td class="column0 style0 s"><a class="comment-indicator"></a><div class="comment">'
. "<span style=\"font-weight:bold; text-decoration:normal; font-style:normal; color:#000000; font-family:'Calibri'; font-size:11pt\">I am comment.</span></div>" . PHP_EOL
. 'Comment</td>'],
'multi-line simple rich text' => [$richMultiSimple, '<td class="column0 style0 s"><a class="comment-indicator"></a><div class="comment">'
. "<span style=\"font-weight:bold; text-decoration:normal; font-style:normal; color:#000000; font-family:'Calibri'; font-size:11pt\">I am <br />" . PHP_EOL
. 'multi-line<br />' . PHP_EOL
. 'comment.</span></div>' . PHP_EOL
. 'Comment</td>'],
'multi-line mixed rich text' => [$richMultiMixed, '<td class="column0 style0 s"><a class="comment-indicator"></a><div class="comment">I am<br />' . PHP_EOL
. "<span style=\"font-weight:bold; text-decoration:normal; font-style:normal; color:#000000; font-family:'Calibri'; font-size:11pt\">multi-line</span><br />" . PHP_EOL
. 'comment!</div>' . PHP_EOL
. 'Comment</td>'],
'script single' => [$scriptSingle, '<td class="column0 style0 s"><a class="comment-indicator"></a><div class="comment">'
. 'I am <script>alert("Hello")</script></div>' . PHP_EOL
. 'Comment</td>'],
];
}
#[DataProvider('providerCommentRichText')]
public function testComments(RichText $richText, string $expected): void
{
$spreadsheet = new Spreadsheet();
$spreadsheet->getActiveSheet()
->getCell('A1')
->setValue('Comment');
$spreadsheet->getActiveSheet()
->getComment('A1')
->setText($richText);
$writer = new Html($spreadsheet);
$output = $writer->generateHtmlAll();
self::assertStringContainsString($expected, $output);
$reloadedSpreadsheet = $this->writeAndReload($spreadsheet, 'Html');
$spreadsheet->disconnectWorksheets();
$actual = $reloadedSpreadsheet->getActiveSheet()->getComment('A1')->getText()->getPlainText();
self::assertSame($richText->getPlainText(), $actual);
$reloadedSpreadsheet->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Html/Issue1319Test.php | tests/PhpSpreadsheetTests/Writer/Html/Issue1319Test.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\Alignment;
use PhpOffice\PhpSpreadsheet\Writer\Html as HtmlWriter;
use PHPUnit\Framework\TestCase;
class Issue1319Test extends TestCase
{
public static function testFromExcelFile(): void
{
$file = 'tests/data/Reader/XLSX/issue.1319.bug2.xlsx';
$reader = new XlsxReader();
$spreadsheet = $reader->load($file);
$writer = new HtmlWriter($spreadsheet);
$html = $writer->generateHtmlAll();
$html = (string) preg_replace('/\r?\n\s+/m', '', $html);
$spreadsheet->disconnectWorksheets();
$expectedArray = [
'table.sheet0 col.col0 { width:42pt }',
'table.sheet0 col.col1 { width:42pt }',
'table.sheet0 col.col2 { width:42pt }',
'table.sheet0 col.col3 { width:42pt }',
'table.sheet0 col.col4 { width:42pt }',
'<tr class="row0"><td class="column0 style1 s style1" colspan="5" rowspan="3">test</td></tr>',
'<tr class="row1"></tr>',
'<tr class="row2"></tr>',
];
foreach ($expectedArray as $expected) {
self::assertStringContainsString($expected, $html);
}
}
public static function testFromScratch(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->getCell('A1')->setValue('test');
$sheet->mergeCells('A1:E3');
$sheet->getStyle('A1')->getFont()
->setBold(true)
->setSize(18);
$sheet->getStyle('A1')->getAlignment()
->setHorizontal(Alignment::HORIZONTAL_CENTER)
->setVertical(Alignment::VERTICAL_CENTER);
// Following not needed when reading Excel, only from scratch.
// columnDimension needed, rowDimension not needed
//$sheet->getRowDimension(3);
$sheet->getColumnDimension('E');
$writer = new HtmlWriter($spreadsheet);
$html = $writer->generateHtmlAll();
$html = (string) preg_replace('/\r?\n\s+/m', '', $html);
$spreadsheet->disconnectWorksheets();
$expectedArray = [
'<col class="col0" />',
'<col class="col1" />',
'<col class="col2" />',
'<col class="col3" />',
'<col class="col4" />',
'<tr class="row0"><td class="column0 style1 s style0" colspan="5" rowspan="3">test</td></tr>',
'<tr class="row1"></tr>',
'<tr class="row2"></tr>',
];
foreach ($expectedArray as $expected) {
self::assertStringContainsString($expected, $html);
}
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Html/CommentAlignmentTest.php | tests/PhpSpreadsheetTests/Writer/Html/CommentAlignmentTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Html;
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 = 'Html';
$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 = 'Html';
$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/Html/GridlinesTest.php | tests/PhpSpreadsheetTests/Writer/Html/GridlinesTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Html;
use DOMDocument;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Style\Color;
use PhpOffice\PhpSpreadsheet\Writer\Html;
use PhpOffice\PhpSpreadsheetTests\Functional;
class GridlinesTest extends Functional\AbstractFunctional
{
public function testGridlines(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->setShowGridlines(true)->setPrintGridlines(true);
$sheet->setCellValue('A1', 1);
$sheet = $spreadsheet->createSheet();
$sheet->setShowGridlines(true)->setPrintGridlines(false);
$sheet->setCellValue('A1', 1);
$sheet = $spreadsheet->createSheet();
$sheet->setShowGridlines(false)->setPrintGridlines(true);
$sheet->setCellValue('A1', 1);
$sheet = $spreadsheet->createSheet();
$sheet->setShowGridlines(false)->setPrintGridlines(false);
$sheet->setCellValue('A1', 1);
$writer = new Html($spreadsheet);
$writer->writeAllSheets();
$html = $writer->generateHTMLAll();
$dom = new DOMDocument();
$dom->loadHTML($html);
$body = $dom->getElementsByTagName('body')->item(0);
self::assertNotNull($body);
$divs = $body->getElementsByTagName('div');
self::assertCount(4, $divs);
$tbl = $divs->item(0)?->getElementsByTagName('table')->item(0);
$cls = $tbl?->getAttribute('class');
self::assertSame('sheet0 gridlines gridlinesp', $cls);
$tbl = $divs->item(1)?->getElementsByTagName('table')->item(0);
$cls = $tbl?->getAttribute('class');
self::assertSame('sheet1 gridlines', $cls);
$tbl = $divs->item(2)?->getElementsByTagName('table')->item(0);
$cls = $tbl?->getAttribute('class');
self::assertSame('sheet2 gridlinesp', $cls);
$tbl = $divs->item(3)?->getElementsByTagName('table')->item(0);
$cls = $tbl?->getAttribute('class');
self::assertSame('sheet3', $cls);
$rls = $this->writeAndReload($spreadsheet, 'Html');
$spreadsheet->disconnectWorksheets();
$rls->disconnectWorksheets();
}
public function testGridlinesInline(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->setShowGridlines(true)->setPrintGridlines(true);
$sheet->setCellValue('A1', 1);
$sheet = $spreadsheet->createSheet();
$sheet->setShowGridlines(true)->setPrintGridlines(false);
$sheet->setCellValue('A1', 1);
$sheet = $spreadsheet->createSheet();
$sheet->setShowGridlines(false)->setPrintGridlines(true);
$sheet->setCellValue('A1', 1);
$sheet = $spreadsheet->createSheet();
$sheet->setShowGridlines(false)->setPrintGridlines(false);
$sheet->setCellValue('A1', 1);
$writer = new Html($spreadsheet);
$writer->writeAllSheets();
$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');
self::assertCount(4, $divs);
$tbl = $divs->item(0)?->getElementsByTagName('table')->item(0);
self::assertNotNull($tbl);
$cls = $tbl->getAttribute('class');
self::assertSame('gridlines gridlinesp', $cls);
$tbl = $divs->item(1)?->getElementsByTagName('table')->item(0);
self::assertNotNull($tbl);
$cls = $tbl->getAttribute('class');
self::assertSame('gridlines', $cls);
$tbl = $divs->item(2)?->getElementsByTagName('table')->item(0);
$cls = $tbl?->getAttribute('class');
self::assertEquals('gridlinesp', $cls);
$tbl = $divs->item(3)?->getElementsByTagName('table')->item(0);
$cls = $tbl?->getAttribute('class');
self::assertSame('', $cls);
$rls = $this->writeAndReload($spreadsheet, 'Html');
$spreadsheet->disconnectWorksheets();
$rls->disconnectWorksheets();
}
public function testRichText(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$emc2 = new \PhpOffice\PhpSpreadsheet\RichText\RichText();
$part1 = $emc2->createTextRun('e=mc');
$font = $part1->getFont();
self::assertNotNull($font);
$font->getColor()->setARGB(Color::COLOR_BLUE);
$part2 = $emc2->createTextRun('2');
$font = $part2->getFont();
self::assertNotNull($font);
$font->getColor()->setARGB(Color::COLOR_DARKGREEN);
$font->setSuperScript(true);
$sheet->setCellValue('A1', $emc2);
$h2o = new \PhpOffice\PhpSpreadsheet\RichText\RichText();
$h2o->createTextRun('H');
$part2 = $h2o->createTextRun('2');
$font = $part2->getFont();
self::assertNotNull($font);
$font->setSubScript(true);
$font->getColor()->setARGB(Color::COLOR_RED);
$h2o->createTextRun('O');
$sheet->setCellValue('A2', $h2o);
$h2so4 = new \PhpOffice\PhpSpreadsheet\RichText\RichText();
$h2so4->createTextRun('H');
$part2 = $h2so4->createTextRun('2');
$font = $part2->getFont();
self::assertNotNull($font);
$font->setSubScript(true);
$h2so4->createTextRun('SO');
$part4 = $h2so4->createTextRun('4');
$font = $part4->getFont();
self::assertNotNull($font);
$font->setSubScript(true);
$sheet->setCellValue('A3', $h2so4);
$sheet->setCellValue('A4', '5');
$sheet->getCell('A4')->getStyle()->getFont()->setSuperScript(true);
$sheet->setCellValue('A5', '6');
$sheet->getCell('A5')->getStyle()->getFont()->setSubScript(true);
$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');
self::assertCount(1, $divs);
$tabl = $divs->item(0)?->getElementsByTagName('table');
self::assertNotNull($tabl);
$tbod = $tabl->item(0)?->getElementsByTagName('tbody');
self::assertNotNull($tbod);
$rows = $tbod->item(0)?->getElementsByTagName('tr');
self::assertNotNull($rows);
self::assertCount(5, $rows);
$tds = $rows->item(0)?->getElementsByTagName('td');
self::assertNotNull($tds);
self::assertCount(1, $tds);
$spans = $tds->item(0)?->getElementsByTagName('span');
self::assertNotNull($spans);
self::assertCount(2, $spans);
self::assertEquals('e=mc', $spans->item(0)?->textContent);
$style = $spans->item(0)?->getAttribute('style');
self::assertEquals(1, preg_match('/color:#0000FF/', "$style"));
$style = $spans->item(1)?->getAttribute('style');
self::assertEquals(1, preg_match('/color:#008000/', "$style"));
$sups = $spans->item(1)?->getElementsByTagName('sup');
self::assertCount(1, $sups);
self::assertSame('2', $sups?->item(0)?->textContent);
$tds = $rows->item(1)?->getElementsByTagName('td');
self::assertCount(1, $tds);
$spans = $tds?->item(0)?->getElementsByTagName('span');
self::assertCount(3, $spans);
self::assertSame('H', $spans?->item(0)?->textContent);
$style = $spans->item(1)?->getAttribute('style');
self::assertSame(1, preg_match('/color:#FF0000/', "$style"));
$subs = $spans->item(1)?->getElementsByTagName('sub');
self::assertCount(1, $subs);
self::assertSame('2', $subs?->item(0)?->textContent);
self::assertSame('O', $spans->item(2)?->textContent);
$tds = $rows->item(2)?->getElementsByTagName('td');
self::assertCount(1, $tds);
$spans = $tds?->item(0)?->getElementsByTagName('span');
self::assertCount(4, $spans);
self::assertEquals('H', $spans?->item(0)?->textContent);
$subs = $spans?->item(1)?->getElementsByTagName('sub');
self::assertCount(1, $subs);
self::assertEquals('2', $subs?->item(0)?->textContent);
self::assertEquals('SO', $spans?->item(2)?->textContent);
$subs = $spans?->item(3)?->getElementsByTagName('sub');
self::assertCount(1, $subs);
self::assertEquals('4', $subs?->item(0)?->textContent);
$tds = $rows->item(3)?->getElementsByTagName('td');
self::assertCount(1, $tds);
$spans = $tds?->item(0)?->getElementsByTagName('span');
self::assertCount(0, $spans);
$sups = $tds?->item(0)?->getElementsByTagName('sup');
self::assertCount(1, $sups);
self::assertEquals('5', $sups?->item(0)?->textContent);
$tds = $rows->item(4)?->getElementsByTagName('td');
self::assertCount(1, $tds);
$spans = $tds?->item(0)?->getElementsByTagName('span');
self::assertCount(0, $spans);
$subs = $tds?->item(0)?->getElementsByTagName('sub');
self::assertCount(1, $subs);
self::assertEquals('6', $subs?->item(0)?->textContent);
$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/BackgroundImageTest.php | tests/PhpSpreadsheetTests/Writer/Html/BackgroundImageTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Html;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Writer\Html;
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());
$writer = new Html($spreadsheet);
$header = $writer->generateHTMLHeader(true);
self::assertStringContainsString('table.sheet0 { background-image:url(data:image/png;base64,', $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/DirectionTest.php | tests/PhpSpreadsheetTests/Writer/Html/DirectionTest.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 DirectionTest extends TestCase
{
public function testMixedRtlAndLtr(): void
{
$spreadsheet = new Spreadsheet();
$sheet1 = $spreadsheet->getActiveSheet();
$sheet1->setRightToLeft(true);
$sheet2 = $spreadsheet->createSheet();
$sheet3 = $spreadsheet->createSheet();
$sheet3->setRightToLeft(true);
$cells = [
['a1', 'b1', 'c1'],
['a2', 'b2', 'c2'],
];
$sheet1->fromArray($cells);
$sheet2->fromArray($cells);
$sheet3->fromArray($cells);
$writer = new Html($spreadsheet);
$writer->writeAllSheets();
$html = $writer->generateHTMLall();
$rtlCount = substr_count($html, "dir='rtl'");
self::assertSame(2, $rtlCount);
$ltrCount = substr_count($html, "dir='ltr'");
self::assertSame(1, $ltrCount);
$spreadsheet->disconnectWorksheets();
}
public function testNoRtl(): void
{
$spreadsheet = new Spreadsheet();
$sheet1 = $spreadsheet->getActiveSheet();
$sheet2 = $spreadsheet->createSheet();
$sheet3 = $spreadsheet->createSheet();
$cells = [
['a1', 'b1', 'c1'],
['a2', 'b2', 'c2'],
];
$sheet1->fromArray($cells);
$sheet2->fromArray($cells);
$sheet3->fromArray($cells);
$writer = new Html($spreadsheet);
$writer->writeAllSheets();
$html = $writer->generateHTMLall();
$rtlCount = substr_count($html, "dir='rtl'");
self::assertSame(0, $rtlCount);
$ltrCount = substr_count($html, "dir='ltr'");
self::assertSame(0, $ltrCount);
$spreadsheet->disconnectWorksheets();
}
public function testOnlyRtl(): void
{
$spreadsheet = new Spreadsheet();
$sheet1 = $spreadsheet->getActiveSheet();
$sheet2 = $spreadsheet->createSheet();
$sheet3 = $spreadsheet->createSheet();
$cells = [
['a1', 'b1', 'c1'],
['a2', 'b2', 'c2'],
];
$sheet1->fromArray($cells);
$sheet1->setRightToLeft(true);
$sheet2->fromArray($cells);
$sheet2->setRightToLeft(true);
$sheet3->fromArray($cells);
$sheet3->setRightToLeft(true);
$writer = new Html($spreadsheet);
$writer->writeAllSheets();
$html = $writer->generateHTMLall();
$rtlCount = substr_count($html, "dir='rtl'");
self::assertSame(4, $rtlCount, '3 sheets plus html tag');
$ltrCount = substr_count($html, "dir='ltr'");
self::assertSame(0, $ltrCount);
$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/NavigationBadTitleTest.php | tests/PhpSpreadsheetTests/Writer/Html/NavigationBadTitleTest.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 NavigationBadTitleTest extends TestCase
{
public function testNavigationTitle(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->getCell('A1')->setValue(1);
$sheet2 = $spreadsheet->createSheet();
$sheet2->setTitle('<img src=x onerror=alert(1)>');
$sheet2->getCell('A2')->setValue(2);
$writer = new HtmlWriter($spreadsheet);
$writer->writeAllSheets();
$html = $writer->generateHTMLAll();
$expected = '<ul class="navigation">'
. PHP_EOL
. ' <li class="sheet0"><a href="#sheet0">Worksheet</a></li>'
. PHP_EOL
. ' <li class="sheet1"><a href="#sheet1"><img src=x onerror=alert(1)></a></li>'
. PHP_EOL
. '</ul>';
self::assertStringContainsString($expected, $html, 'appropriate characters are escaped');
$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/HtmlTableFormatWithConditionalTest.php | tests/PhpSpreadsheetTests/Writer/Html/HtmlTableFormatWithConditionalTest.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 HtmlTableFormatWithConditionalTest 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);
self::assertFalse($writer->getTableFormats());
self::assertFalse($writer->getConditionalFormatting());
$writer->setTableFormats(true);
$writer->setConditionalFormatting(true);
self::assertTrue($writer->getTableFormats());
self::assertTrue($writer->getConditionalFormatting());
$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:#B7E1CD;">70<', 'conditional style for cell J3'], // as conditional calculations are on
['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);
}
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Html/ImageEmbedTest.php | tests/PhpSpreadsheetTests/Writer/Html/ImageEmbedTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Html;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Worksheet\Drawing;
use PhpOffice\PhpSpreadsheet\Writer\Html as HtmlWriter;
use PHPUnit\Framework\TestCase;
class ImageEmbedTest extends TestCase
{
public function testImageEmbed(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$drawing = new Drawing();
$drawing->setName('Not an image');
$drawing->setDescription('Non-image');
$drawing->setPath(__FILE__, false);
$drawing->setCoordinates('A1');
$drawing->setCoordinates2('E4');
$drawing->setWorksheet($sheet);
$drawing = new Drawing();
$drawing->setName('Blue Square');
$drawing->setPath('tests/data/Writer/XLSX/blue_square.png');
$drawing->setCoordinates('A5');
$drawing->setCoordinates2('E8');
$drawing->setWorksheet($sheet);
$writer = new HtmlWriter($spreadsheet);
$writer->setEmbedImages(true);
$html = $writer->generateHTMLAll();
self::assertSame(1, substr_count($html, '<img'));
self::assertSame(1, substr_count($html, 'src="data'));
self::assertSame(1, substr_count($html, 'src="data:image/png;base64,'));
self::assertSame(0, substr_count($html, 'blue_square.png'));
//self::assertSame(1, substr_count($html, 'src="data:," alt="Non-image"'));
$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/ExtendForChartsAndImagesTest.php | tests/PhpSpreadsheetTests/Writer/Html/ExtendForChartsAndImagesTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Html;
use PhpOffice\PhpSpreadsheet\Exception as PhpSpreadsheetException;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Worksheet\Drawing;
use PhpOffice\PhpSpreadsheet\Writer\Html;
use PhpOffice\PhpSpreadsheetTests\Functional;
class ExtendForChartsAndImagesTest extends Functional\AbstractFunctional
{
public function testEmptySheet(): void
{
$spreadsheet = new Spreadsheet();
$this->assertMaxColumnAndMaxRow($spreadsheet, 1, 1);
}
public function testSimpleSheet(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->setCellValue('B3', 'foo');
$this->assertMaxColumnAndMaxRow($spreadsheet, 2, 3);
}
public function testSheetWithExtraColumnDimensions(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->setCellValue('B3', 'foo');
// Artificially expend the sheet column count without any real cells
$sheet->getColumnDimension('E');
$this->assertMaxColumnAndMaxRow($spreadsheet, 2, 3);
}
public function testSheetWithExtraRowDimensions(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->setCellValue('B3', 'foo');
// Artificially expend the sheet row count without any real cells
$sheet->getRowDimension(5);
$this->assertMaxColumnAndMaxRow($spreadsheet, 2, 3);
}
public function testSheetWithImageBelowData(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->setCellValue('B3', 'foo');
// Add a drawing to the worksheet
$drawing = new Drawing();
$path = 'tests/data/Writer/XLSX/blue_square.png';
$drawing->setPath($path);
self::assertSame($path, $drawing->getPath());
$drawing->setCoordinates('A5');
$drawing->setWorksheet($sheet);
$this->assertMaxColumnAndMaxRow($spreadsheet, 2, 5);
}
public function testSheetWithImageRightOfData(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->setCellValue('B3', 'foo');
// Add a drawing to the worksheet
$drawing = new Drawing();
$path = 'tests/data/Writer/XLSX/blue_square.png';
$drawing->setPath($path);
self::assertSame($path, $drawing->getPath());
$drawing->setCoordinates('E1');
$drawing->setWorksheet($sheet);
$this->assertMaxColumnAndMaxRow($spreadsheet, 5, 3);
}
public function testSheetWithBadImageRightOfData(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->setCellValue('B3', 'foo');
// Add a drawing to the worksheet
$drawing = new Drawing();
$path = 'tests/data/Writer/XLSX/xblue_square.png';
$drawing->setPath($path, false);
self::assertSame('', $drawing->getPath());
$drawing->setCoordinates('E1');
$drawing->setWorksheet($sheet);
$this->assertMaxColumnAndMaxRow($spreadsheet, 2, 3);
}
public function testSheetWithBadImageRightOfDataThrow(): void
{
$this->expectException(PhpSpreadsheetException::class);
$this->expectExceptionMessage('not found!');
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->setCellValue('B3', 'foo');
// Add a drawing to the worksheet
$drawing = new Drawing();
$path = 'tests/data/Writer/XLSX/xblue_square.png';
$drawing->setPath($path);
self::assertSame('', $drawing->getPath());
$drawing->setCoordinates('E1');
$drawing->setWorksheet($sheet);
$this->assertMaxColumnAndMaxRow($spreadsheet, 2, 3);
}
private function assertMaxColumnAndMaxRow(Spreadsheet $spreadsheet, int $expectedColumnCount, int $expectedRowCount): void
{
$writer = new Html($spreadsheet);
$html = $writer->generateHtmlAll();
$rowCount = substr_count($html, '<tr ');
self::assertSame($expectedRowCount, $rowCount);
$columnCount = substr_count($html, '<td ') / $rowCount;
self::assertSame($expectedColumnCount, $columnCount);
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Html/AllOrOneSheetTest.php | tests/PhpSpreadsheetTests/Writer/Html/AllOrOneSheetTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Html;
use DOMDocument;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Writer\Html;
use PhpOffice\PhpSpreadsheet\Writer\Pdf\Mpdf;
use PhpOffice\PhpSpreadsheet\Writer\Pdf\Tcpdf;
use PhpOffice\PhpSpreadsheetTests\Functional;
class AllOrOneSheetTest extends Functional\AbstractFunctional
{
public function testWriteAllSheets(): void
{
$spreadsheet = new Spreadsheet();
$sheet1 = $spreadsheet->getActiveSheet();
$sheet1->setCellValue('A1', 'first');
$sheet2 = $spreadsheet->createSheet();
$sheet2->setCellValue('A1', 'second');
$writer = new Html($spreadsheet);
self::assertFalse($writer->getEmbedImages());
$writer->writeAllSheets();
self::assertTrue($writer->getGenerateSheetNavigationBlock());
$html = $writer->generateHTMLAll();
$dom = new DOMDocument();
$dom->loadHTML($html);
$body = $dom->getElementsByTagName('body')->item(0);
self::assertNotNull($body);
$divs = $body->getElementsByTagName('ul'); // sheet navigation
self::assertCount(1, $divs);
$divs = $body->getElementsByTagName('div');
self::assertCount(2, $divs);
$divsItem0 = $divs->item(0);
self::assertNotNull($divsItem0);
$divsItem1 = $divs->item(1);
self::assertNotNull($divsItem1);
self::assertEquals('page: page0', $divsItem0->getAttribute('style'));
$tbl = $divsItem0->getElementsByTagName('table');
$tblItem0 = $tbl->item(0);
self::assertNotNull($tblItem0);
self::assertEquals('sheet0', $tblItem0->getAttribute('id'));
self::assertEquals('sheet0 gridlines', $tblItem0->getAttribute('class'));
$tbl = $divsItem1->getElementsByTagName('table');
$tblItem0 = $tbl->item(0);
self::assertNotNull($tblItem0);
self::assertEquals('page: page1', $divsItem1->getAttribute('style'));
self::assertEquals('sheet1', $tblItem0->getAttribute('id'));
self::assertEquals('sheet1 gridlines', $tblItem0->getAttribute('class'));
$rls = $this->writeAndReload($spreadsheet, 'Html');
$spreadsheet->disconnectWorksheets();
$rls->disconnectWorksheets();
}
public function testWriteAllSheetsNoNav(): void
{
$spreadsheet = new Spreadsheet();
$sheet1 = $spreadsheet->getActiveSheet();
$sheet1->setCellValue('A1', 'first');
$sheet2 = $spreadsheet->createSheet();
$sheet2->setCellValue('A1', 'second');
$writer = new Html($spreadsheet);
$writer->writeAllSheets();
$writer->setGenerateSheetNavigationBlock(false);
$html = $writer->generateHTMLAll();
$dom = new DOMDocument();
$dom->loadHTML($html);
$body = $dom->getElementsByTagName('body')->item(0);
self::assertNotNull($body);
$divs = $body->getElementsByTagName('ul'); // sheet navigation
self::assertCount(0, $divs);
$divs = $body->getElementsByTagName('div');
self::assertCount(2, $divs);
$divsItem0 = $divs->item(0);
self::assertNotNull($divsItem0);
self::assertEquals('page: page0', $divsItem0->getAttribute('style'));
$tbl = $divsItem0->getElementsByTagName('table');
$tblItem0 = $tbl->item(0);
self::assertNotNull($tblItem0);
self::assertEquals('sheet0', $tblItem0->getAttribute('id'));
self::assertEquals('sheet0 gridlines', $tblItem0->getAttribute('class'));
$divsItem1 = $divs->item(1);
self::assertNotNull($divsItem1);
$tbl = $divsItem1->getElementsByTagName('table');
self::assertEquals('page: page1', $divsItem1->getAttribute('style'));
$tblItem0 = $tbl->item(0);
self::assertNotNull($tblItem0);
self::assertEquals('sheet1', $tblItem0->getAttribute('id'));
self::assertEquals('sheet1 gridlines', $tblItem0->getAttribute('class'));
$rls = $this->writeAndReload($spreadsheet, 'Html');
$spreadsheet->disconnectWorksheets();
$rls->disconnectWorksheets();
}
public function testWriteAllSheetsPdf(): void
{
$spreadsheet = new Spreadsheet();
$sheet1 = $spreadsheet->getActiveSheet();
$sheet1->setCellValue('A1', 'first');
$sheet2 = $spreadsheet->createSheet();
$sheet2->setCellValue('A1', 'second');
$writer = new Mpdf($spreadsheet);
$writer->writeAllSheets();
$html = $writer->generateHTMLAll();
$dom = new DOMDocument();
$dom->loadHTML($html);
$body = $dom->getElementsByTagName('body')->item(0);
self::assertNotNull($body);
$divs = $body->getElementsByTagName('ul'); // sheet navigation
self::assertCount(0, $divs);
$divs = $body->getElementsByTagName('div');
$divsItem0 = $divs->item(0);
self::assertNotNull($divsItem0);
self::assertCount(2, $divs);
self::assertEquals('page: page0', $divsItem0->getAttribute('style'));
$tbl = $divsItem0->getElementsByTagName('table');
$tblItem0 = $tbl->item(0);
self::assertNotNull($tblItem0);
self::assertEquals('sheet0', $tblItem0->getAttribute('id'));
self::assertEquals('sheet0 gridlines', $tblItem0->getAttribute('class'));
$divsItem1 = $divs->item(1);
self::assertNotNull($divsItem1);
$tbl = $divsItem1->getElementsByTagName('table');
self::assertEquals('page: page1', $divsItem1->getAttribute('style'));
$tblItem0 = $tbl->item(0);
self::assertNotNull($tblItem0);
self::assertEquals('sheet1', $tblItem0->getAttribute('id'));
self::assertEquals('sheet1 gridlines', $tblItem0->getAttribute('class'));
$spreadsheet->disconnectWorksheets();
}
public function testWriteOneSheet(): void
{
$spreadsheet = new Spreadsheet();
$sheet1 = $spreadsheet->getActiveSheet();
$sheet1->setCellValue('A1', 'first');
$sheet2 = $spreadsheet->createSheet();
$sheet2->setCellValue('A1', 'second');
$writer = new Html($spreadsheet);
$writer->setSheetIndex(1);
$html = $writer->generateHTMLAll();
$dom = new DOMDocument();
$dom->loadHTML($html);
$body = $dom->getElementsByTagName('body')->item(0);
self::assertNotNull($body);
$divs = $body->getElementsByTagName('ul'); // sheet navigation
self::assertCount(0, $divs);
$divs = $body->getElementsByTagName('div');
self::assertCount(1, $divs);
$divsItem0 = $divs->item(0);
self::assertNotNull($divsItem0);
self::assertEquals('page: page1', $divsItem0->getAttribute('style'));
$tbl = $divsItem0->getElementsByTagName('table');
$tblItem0 = $tbl->item(0);
self::assertNotNull($tblItem0);
self::assertEquals('sheet1', $tblItem0->getAttribute('id'));
self::assertEquals('sheet1 gridlines', $tblItem0->getAttribute('class'));
$rls = $this->writeAndReload($spreadsheet, 'Html');
$spreadsheet->disconnectWorksheets();
$rls->disconnectWorksheets();
}
public function testPageBreak(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->setShowGridlines(true)->setPrintGridlines(true);
$sheet->setCellValue('A1', 1);
$sheet->setCellValue('A2', 'before page break');
$sheet->setBreak('A2', \PhpOffice\PhpSpreadsheet\Worksheet\Worksheet::BREAK_ROW);
$sheet->setCellValue('A3', 'after page break');
$sheet->setCellValue('A4', 4);
$sheet = $spreadsheet->createSheet();
$sheet->setCellValue('A1', 'new sheet');
$writer = new Html($spreadsheet);
$writer->writeAllSheets();
$html = $writer->generateHTMLAll();
$dom = new DOMDocument();
$dom->loadHTML($html);
$body = $dom->getElementsByTagName('body')->item(0);
self::assertNotNull($body);
$divs = $body->getElementsByTagName('div');
self::assertCount(3, $divs);
$divsItem0 = $divs->item(0);
$divsItem1 = $divs->item(1);
$divsItem2 = $divs->item(2);
self::assertNotNull($divsItem0);
self::assertNotNull($divsItem1);
self::assertNotNull($divsItem2);
$sty = $divsItem0->getAttribute('style');
$cls = $divsItem0->getAttribute('class');
self::assertEquals('page: page0', $sty);
self::assertEquals('', $cls);
$sty = $divsItem1->getAttribute('style');
$cls = $divsItem1->getAttribute('class');
self::assertEquals('page: page0', $sty);
self::assertEquals('scrpgbrk', $cls);
$sty = $divsItem2->getAttribute('style');
$cls = $divsItem2->getAttribute('class');
self::assertEquals('page: page1', $sty);
self::assertEquals('', $cls);
$rls = $this->writeAndReload($spreadsheet, 'Html');
$spreadsheet->disconnectWorksheets();
$rls->disconnectWorksheets();
}
public function testTcpdfPageBreak(): void
{
$spreadsheet = new Spreadsheet();
$sheet1 = $spreadsheet->getActiveSheet();
$sheet1->setCellValue('A1', 'First sheet');
$sheet2 = $spreadsheet->createSheet();
$sheet2->setCellValue('A2', 'Second sheet');
$sheet2->setCellValue('A2', 'before page break');
$sheet2->setBreak('A2', \PhpOffice\PhpSpreadsheet\Worksheet\Worksheet::BREAK_ROW);
$sheet2->setCellValue('A3', 'after page break');
$writer = new Tcpdf($spreadsheet);
$writer->writeAllSheets();
$html = $writer->generateHtmlAll();
$dom = new DOMDocument();
$dom->loadHTML($html);
$body = $dom->getElementsByTagName('body')->item(0);
self::assertNotNull($body);
$divs = $body->getElementsByTagName('div');
self::assertCount(5, $divs);
self::assertEquals('page: page0', $divs->item(0)?->getAttribute('style'));
self::assertEquals('page: page1', $divs->item(2)?->getAttribute('style'));
self::assertEquals('page: page1', $divs->item(4)?->getAttribute('style'));
self::assertEquals('page-break-before:always', $divs->item(1)?->getAttribute('style'));
self::assertEquals('page-break-before:always', $divs->item(3)?->getAttribute('style'));
$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/ImageCopyTest.php | tests/PhpSpreadsheetTests/Writer/Html/ImageCopyTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Html;
use PhpOffice\PhpSpreadsheet\Reader\Xls as XlsReader;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx as XlsxReader;
use PhpOffice\PhpSpreadsheet\Shared\File;
use PhpOffice\PhpSpreadsheet\Writer\Exception as WriterException;
use PhpOffice\PhpSpreadsheet\Writer\Html;
use PhpOffice\PhpSpreadsheet\Writer\Xlsx as XlsxWriter;
use PhpOffice\PhpSpreadsheetTests\Functional;
class ImageCopyTest extends Functional\AbstractFunctional
{
private string $xlsxFile = '';
protected function tearDown(): void
{
if ($this->xlsxFile !== '') {
unlink($this->xlsxFile);
$this->xlsxFile = '';
}
}
public function testImageCopyXls(): void
{
$file = 'samples/templates/27template.xls';
$reader = new XlsReader();
$reloadedSpreadsheet = $reader->load($file);
$writer = new Html($reloadedSpreadsheet);
$writer->writeAllSheets();
self::assertFalse($writer->getEmbedImages());
$html = $writer->generateHTMLAll();
self::assertSame(4, substr_count($html, '<img'));
self::assertSame(0, substr_count($html, 'zip://'));
// all 4 images converted to png
self::assertSame(4, substr_count($html, 'data:image/png;base64'));
$this->writeAndReload($reloadedSpreadsheet, 'Html');
$reloadedSpreadsheet->disconnectWorksheets();
}
public function testImageCopyXlsx(): void
{
$file = 'samples/templates/27template.xls';
$reader = new XlsReader();
$spreadsheet = $reader->load($file);
$this->xlsxFile = File::temporaryFilename();
$writer = new XlsxWriter($spreadsheet);
$writer->save($this->xlsxFile);
$spreadsheet->disconnectWorksheets();
$reader2 = new XlsxReader();
$reloadedSpreadsheet = $reader2->load($this->xlsxFile);
$writer = new Html($reloadedSpreadsheet);
$writer->writeAllSheets();
self::assertFalse($writer->getEmbedImages());
$html = $writer->generateHTMLAll();
self::assertSame(4, substr_count($html, '<img'));
self::assertSame(0, substr_count($html, 'zip://'));
// "gif" is actually stored as png in this file
self::assertSame(2, substr_count($html, 'data:image/png;base64'));
//self::assertSame(1, substr_count($html, 'data:image/gif;base64'));
self::assertSame(2, substr_count($html, 'data:image/jpeg;base64'));
$this->writeAndReload($reloadedSpreadsheet, 'Html');
$reloadedSpreadsheet->disconnectWorksheets();
}
public function testSimulateFailedClose(): void
{
$this->expectException(WriterException::class);
$this->expectExceptionMessage('Could not close file ');
$file = 'samples/templates/27template.xls';
$reader = new XlsReader();
$spreadsheet = $reader->load($file);
$this->xlsxFile = File::temporaryFilename();
$writer = new HtmlExtend2($spreadsheet);
$writer->save($this->xlsxFile);
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Html/ReadOrderTest.php | tests/PhpSpreadsheetTests/Writer/Html/ReadOrderTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Html;
use PhpOffice\PhpSpreadsheet\Reader\Html as HtmlReader;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Style\Alignment;
use PhpOffice\PhpSpreadsheet\Writer\Html as HtmlWriter;
use PHPUnit\Framework\TestCase;
class ReadOrderTest extends TestCase
{
public function testInline(): 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');
$sheet->setCellValue('A5', 'hello');
$sheet->getStyle('A5')->getFont()->setName('Tahoma');
$sheet->getStyle('A5')
->getAlignment()->setIndent(2);
$writer = new HtmlWriter($spreadsheet);
$writer->setUseInlineCss(true);
$html = $writer->generateHtmlAll();
self::assertStringContainsString(
'<td class="gridlines" style="vertical-align:bottom; direction:rtl; color:#000000; font-family:\'Calibri\';',
$html
);
self::assertStringContainsString(
'<td class="gridlines" style="vertical-align:bottom; direction:ltr; color:#000000; font-family:\'Arial\';',
$html
);
self::assertStringContainsString(
'<td class="gridlines" style="vertical-align:bottom; color:#000000; font-family:\'Times New Roman\';',
$html
);
self::assertStringContainsString(
'> </td>',
$html
);
self::assertStringContainsString(
'<td class="gridlines" style="vertical-align:bottom; text-indent:18px; color:#000000; font-family:\'Tahoma\';',
$html
);
$spreadsheet->disconnectWorksheets();
$reader = new HtmlReader();
$spreadsheet2 = $reader->loadFromString($html);
$sheet0 = $spreadsheet2->getActiveSheet();
self::assertSame(
Alignment::READORDER_RTL,
$sheet0->getStyle('A1')->getAlignment()->getReadOrder()
);
self::assertSame(
Alignment::READORDER_LTR,
$sheet0->getStyle('A2')->getAlignment()->getReadOrder()
);
self::assertSame(
Alignment::READORDER_CONTEXT,
$sheet0->getStyle('A3')->getAlignment()->getReadOrder()
);
self::assertSame(
2,
$sheet0->getStyle('A5')->getAlignment()->getIndent()
);
$spreadsheet2->disconnectWorksheets();
}
public function testNotInline(): 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');
$sheet->setCellValue('A5', 'hello');
$sheet->getStyle('A5')->getFont()->setName('Tahoma');
$sheet->getStyle('A5')
->getAlignment()->setIndent(2);
$writer = new HtmlWriter($spreadsheet);
$html = $writer->generateHtmlAll();
self::assertStringContainsString(
'td.style1, th.style1 { vertical-align:bottom; direction:rtl; border-bottom',
$html
);
self::assertStringContainsString(
'td.style2, th.style2 { vertical-align:bottom; direction:ltr; border-bottom',
$html
);
self::assertStringContainsString(
'td.style3, th.style3 { vertical-align:bottom; border-bottom',
$html
);
self::assertStringContainsString(
'> </td>',
$html
);
self::assertStringContainsString(
'td.style4, th.style4 { vertical-align:bottom; text-indent:18px;',
$html
);
$spreadsheet->disconnectWorksheets();
// PhpSpreadsheet does not read non-inline styles
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Html/InvalidFileNameTest.php | tests/PhpSpreadsheetTests/Writer/Html/InvalidFileNameTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Html;
use PhpOffice\PhpSpreadsheet\Shared\File;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Worksheet\PageSetup;
use PhpOffice\PhpSpreadsheet\Writer\Exception as WriterException;
use PhpOffice\PhpSpreadsheet\Writer\Html;
use PhpOffice\PhpSpreadsheet\Writer\Pdf\Mpdf;
use PhpOffice\PhpSpreadsheetTests\Functional;
class InvalidFileNameTest extends Functional\AbstractFunctional
{
public function testEmptyFileName(): void
{
$this->expectException(WriterException::class);
$spreadsheet = new Spreadsheet();
$spreadsheet->getActiveSheet()->getCell('A1')->setValue('Cell 1');
$writer = new Html($spreadsheet);
$writer->save('');
}
public function testEmptyFileNamePdf(): void
{
$this->expectException(WriterException::class);
$spreadsheet = new Spreadsheet();
$spreadsheet->getActiveSheet()->getCell('A1')->setValue('Cell 1');
$writer = new Mpdf($spreadsheet);
$writer->save('');
}
public function testNotEmptyTempdirNamePdf(): void
{
$spreadsheet = new Spreadsheet();
$spreadsheet->getActiveSheet()->getCell('A1')->setValue('Cell 1');
$writer = new Mpdf($spreadsheet);
$writer->setFont('Helvetica');
self::assertEquals('Helvetica', $writer->getFont());
$writer->setPaperSize(PageSetup::PAPERSIZE_LEDGER);
self::assertEquals($writer->getPaperSize(), PageSetup::PAPERSIZE_LEDGER);
self::assertEquals(File::sysGetTempDir() . '/phpsppdf', $writer->getTempDir());
$writer->setTempDir(File::sysGetTempDir());
self::assertEquals(File::sysGetTempDir(), $writer->getTempDir());
}
public function testEmptyTempdirNamePdf(): void
{
$this->expectException(WriterException::class);
$spreadsheet = new Spreadsheet();
$spreadsheet->getActiveSheet()->getCell('A1')->setValue('Cell 1');
$writer = new Mpdf($spreadsheet);
$writer->setTempDir('');
}
public function testWinFileNames(): void
{
self::assertEquals('file:///C:/temp/filename.xlsx', Html::winFileToUrl('C:\temp\filename.xlsx'));
self::assertEquals('/tmp/filename.xlsx', Html::winFileToUrl('/tmp/filename.xlsx'));
self::assertEquals('a:bfile', Html::winFileToUrl('a:bfile'));
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Html/HtmlColourScaleTest.php | tests/PhpSpreadsheetTests/Writer/Html/HtmlColourScaleTest.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 HtmlColourScaleTest extends TestCase
{
private string $data = '';
protected function setUp(): void
{
$file = 'samples/templates/ColourScale.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 testColourScaleHtmlOutput(): void
{
$expectedMatches = [
['E1', 'background-color:#B4CA76;">5<', 'cell E1'],
['F1', 'background-color:#CBCD71;">6<', 'cell F1'],
['G1', 'background-color:#E3D16C;">7<', 'cell G1'],
['D2', 'background-color:#57BB8A;">4<', 'cell D2'],
['E2', 'background-color:#A1C77A;">5<', 'cell E2'],
['F2', 'background-color:#F1A36D;">6<', 'cell F2'],
['D3', 'background-color:#FFD666;">4<', 'cell D3'],
['G3', 'background-color:#EC926F;">7<', 'cell G3'],
['H3', 'background-color:#E67C73;">8<', 'cell H3'],
['A4', 'background-color:#57BB8A;">1<', 'cell A4'],
['I4', 'null"> <', 'empty cell I4'],
['J4', 'background-color:#E67C73;">10<', 'cell J4'],
];
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/BadHyperlinkTest.php | tests/PhpSpreadsheetTests/Writer/Html/BadHyperlinkTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Html;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx as XlsxReader;
use PhpOffice\PhpSpreadsheet\Reader\Xml as XmlReader;
use PhpOffice\PhpSpreadsheet\Writer\Html as HtmlWriter;
use PHPUnit\Framework\TestCase;
class BadHyperlinkTest extends TestCase
{
public function testBadHyperlink(): void
{
$reader = new XlsxReader();
$infile = 'tests/data/Reader/XLSX/sec-j47r.dontuse';
$spreadsheet = $reader->load($infile);
$writer = new HtmlWriter($spreadsheet);
$html = $writer->generateHtmlAll();
self::assertStringContainsString('<td class="column0 style1 s">jav	ascript:alert()</td>', $html);
$spreadsheet->disconnectWorksheets();
}
public function testControlCharacter(): void
{
$reader = new XmlReader();
$infile = 'tests/data/Reader/Xml/sec-w24f.dontuse';
$spreadsheet = $reader->load($infile);
$writer = new HtmlWriter($spreadsheet);
$html = $writer->generateHtmlAll();
self::assertStringContainsString('<td class="column0 style0 s">j avascript:alert(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/HtmlArrayTest.php | tests/PhpSpreadsheetTests/Writer/Html/HtmlArrayTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Html;
use PhpOffice\PhpSpreadsheet\Calculation\Calculation;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheetTests\Functional\AbstractFunctional;
class HtmlArrayTest 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, 'Html');
$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/Html/RichTextTest.php | tests/PhpSpreadsheetTests/Writer/Html/RichTextTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Html;
use PhpOffice\PhpSpreadsheet\RichText\RichText;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Writer\Html as HtmlWriter;
use PHPUnit\Framework\TestCase;
class RichTextTest extends TestCase
{
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());
$writer = new HtmlWriter($spreadsheet);
$html = $writer->generateHtmlAll();
self::assertStringContainsString('td.style1, th.style1 { vertical-align:bottom; border-bottom:none #000000; border-top:none #000000; border-left:none #000000; border-right:none #000000; font-weight:bold; color:#000000; font-family:\'Calibri\'; font-size:11pt }', $html, 'cell style');
self::assertStringContainsString('<td class="column0 style1 inlineStr"><span style="font-weight:bold; text-decoration:normal; font-style:normal; color:#000000; font-family:\'Calibri\'; font-size:11pt">~Cell Style~</span>', $html, 'cell style and first text element');
self::assertStringContainsString('<span style="font-weight:normal; text-decoration:normal; font-style:italic; color:#000000; font-family:\'Calibri\'; font-size:11pt">~RTF Style~</span>', $html, 'second text element');
self::assertStringContainsString('<span style="font-weight:bold; text-decoration:normal; font-style:normal; color:#000000; font-family:\'Calibri\'; font-size:11pt">~No Style~</span></td>', $html, 'third text element');
$spreadsheet->disconnectWorksheets();
}
public function testNoFont(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$rtf = new RichText();
$rtf->createTextRun('no font')->setFont(null);
$sheet->setCellValue('A1', $rtf);
$writer = new HtmlWriter($spreadsheet);
$html = $writer->generateHtmlAll();
self::assertStringContainsString('<td class="column0 style0 inlineStr"><span>no font</span></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/Issue4539Test.php | tests/PhpSpreadsheetTests/Writer/Html/Issue4539Test.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Html;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx as XlsxReader;
use PhpOffice\PhpSpreadsheet\Writer\Html;
use PHPUnit\Framework\TestCase;
class Issue4539Test extends TestCase
{
public function testInlineAndNot(): void
{
$infile = 'tests/data/Reader/XLSX/issue.4539.xlsx';
$reader = new XlsxReader();
$spreadsheet = $reader->load($infile);
$writer = new Html($spreadsheet);
$writer->setConditionalFormatting(true);
$writer->setUseInlineCss(true);
$html = $writer->generateHtmlAll();
$expected = '<td style="vertical-align:bottom; color:#000000; font-family:\'Aptos Narrow\'; font-size:12pt; text-align:right; width:102pt; color:#000000;background-color:#5A8AC6;">5</td>';
self::assertStringContainsString($expected, $html, 'inline conditional style');
$expected = '<td style="vertical-align:bottom; font-weight:bold; color:#000000; font-family:\'Aptos Narrow\'; font-size:12pt; text-align:left; width:102pt">Column Heading</td>';
self::assertStringContainsString($expected, $html, 'inline no conditional style');
$expected = '<td style="vertical-align:bottom; color:#000000; font-family:\'Aptos Narrow\'; font-size:12pt; text-align:right; width:102pt; border-top:1px solid #92D050 !important;color:#000000;">1</td>';
self::assertStringContainsString($expected, $html, 'inline border-top');
$expected = '<td style="vertical-align:bottom; color:#000000; font-family:\'Aptos Narrow\'; font-size:12pt; text-align:right; width:102pt; border-top:1px solid #FF0000 !important;font-weight:bold;color:#000000;">2</td>';
self::assertStringContainsString($expected, $html, 'inline border-top and bold');
$expected = '<td style="vertical-align:bottom; color:#000000; font-family:\'Aptos Narrow\'; font-size:12pt; text-align:right; width:102pt">3</td>';
self::assertStringContainsString($expected, $html, 'inline nomatch');
$writer->setUseInlineCss(false);
$html = $writer->generateHtmlAll();
$expected = '<td class="column0 style0 n" style="color:#000000;background-color:#5A8AC6;">5</td>';
self::assertStringContainsString($expected, $html, 'notinline conditional style');
$expected = '<td class="column0 style1 s">Column Heading</td>';
self::assertStringContainsString($expected, $html, 'notinline no conditional style');
$expected = '<td class="column0 style0 n" style="border-top:1px solid #92D050 !important;color:#000000;">1</td>';
self::assertStringContainsString($expected, $html, 'notinline border-top');
$expected = '<td class="column0 style0 n" style="border-top:1px solid #FF0000 !important;font-weight:bold;color:#000000;">2</td>';
self::assertStringContainsString($expected, $html, 'notinline border-top bold');
$expected = '<td class="column0 style0 n">3</td>';
self::assertStringContainsString($expected, $html, 'notinline nomatch');
$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/XssVulnerabilityTest.php | tests/PhpSpreadsheetTests/Writer/Html/XssVulnerabilityTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Html;
use PhpOffice\PhpSpreadsheet\RichText\RichText;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Writer\Html;
use PhpOffice\PhpSpreadsheetTests\Functional;
class XssVulnerabilityTest extends Functional\AbstractFunctional
{
public static function providerXssRichText(): array
{
return [
'basic text no problem' => ['Hello, I am safely viewing your site', 'Hello, I am safely viewing your site'],
'link eliminated' => ["<a href='Visit Google'>Google is here</a>", "<a href='Visit Google'>Google is here</a>"],
'script tag' => ["Hello, I am trying to <script>alert('Hack');</script> your site", "Hello, I am trying to <script>alert('Hack');</script> your site"],
'script tag with quotes' => ['Hello, I am trying to <script>alert("Hack");</script> your site', 'Hello, I am trying to <script>alert("Hack");</script> your site'],
'javascript tag no hex' => ["<a href='javascript:alert(1)'>CLICK</a>", "<a href='javascript:alert(1)'>CLICK</a>"],
'javascript tag' => ["<a href=' javascript:alert(1)'>CLICK</a>", "<a href='&#x2000;javascript:alert(1)'>CLICK</a>"],
'with unicode' => ['<a href="\u0001java\u0003script:alert(1)">CLICK</a>', '<a href="\u0001java\u0003script:alert(1)">CLICK</a>'],
'inline css' => ['<li style="list-style-image: url(javascript:alert(0))">', '<li style="list-style-image: url(javascript:alert(0))">'],
'char value chevron' => ["\x3cscript src=http://www.example.com/malicious-code.js\x3e\x3c/script\x3e", '<script src=http://www.example.com/malicious-code.js></script>'],
'hexadecimal html' => ['<IMG SRC=javasmript:alert('XSS')>', '<IMG SRC=&#106&#x61&#x76&#x61&#x73&#109&#x72&#x69&#x70&#x74&#x3A&#x61&#x6C&#x65&#x72&#x74&#x28&#x27&#x58&#x53&#x53&#x27&#x29>'],
'iframe' => ['<iframe width="560" onclick="alert(\'xss\')" height="315" src="https://www.youtube.com/embed/whatever?rel=0&controls=0&showinfo=0" frameborder="0" allowfullscreen></iframe>', '<iframe width="560" onclick="alert(\'xss\')" height="315" src="https://www.youtube.com/embed/whatever?rel=0&controls=0&showinfo=0" frameborder="0" allowfullscreen></iframe>'],
];
}
#[\PHPUnit\Framework\Attributes\DataProvider('providerXssRichText')]
public function testXssInComment(string $xssTextString, ?string $expected = null): void
{
$spreadsheet = new Spreadsheet();
$startCell = '<td class="column0 style0 s">';
$cellText = 'XSS Test';
$endCell = $cellText . '</td>';
if ($expected === null) { // whole comment stripped away
$expected = $startCell . $endCell;
} else {
$expected = $startCell . '<a class="comment-indicator"></a><div class="comment">' . $expected . '</div>' . PHP_EOL . $endCell;
}
$richText = new RichText();
$richText->createText($xssTextString);
$spreadsheet->getActiveSheet()->getCell('A1')->setValue($cellText);
$spreadsheet->getActiveSheet()
->getComment('A1')
->setText($richText);
$writer = new Html($spreadsheet);
$verify = $writer->generateHtmlAll();
// Ensure that executable js has been stripped from the comments
self::assertStringContainsString($expected, $verify);
$spreadsheet->disconnectWorksheets();
}
public function testXssInFontName(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->getCell('A1')->setValue('here');
$used = 'Calibri</style><script type="text/javascript">alert("hello");</script><style type="text/css">';
$expected = "font-family:'Calibri</style><script type="text/javascript">alert("hello");</script><style type="text/css">'";
$sheet->getStyle('A1')->getFont()->setName($used);
$writer = new Html($spreadsheet);
$verify = $writer->generateHtmlAll();
// Ensure that executable js has been stripped
self::assertStringNotContainsString($used, $verify);
self::assertStringContainsString($expected, $verify);
$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/PrintAreaTest.php | tests/PhpSpreadsheetTests/Writer/Html/PrintAreaTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Html;
use PhpOffice\PhpSpreadsheet\Reader\Html as HtmlReader;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Writer\Html as HtmlWriter;
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 HtmlWriter($spreadsheet);
$html = $writer->generateHtmlAll();
self::assertStringContainsString(
"<table border='0' cellpadding='0' cellspacing='0' data-printarea='B2:D4' id='sheet0' class='sheet0 gridlines'>",
$html
);
$expectedArray = [
'@media print {',
' table.sheet0 tr.row0 td { display:none }',
' table.sheet0 tr.row4 td { display:none }',
' table.sheet0 tr.row5 td { display:none }',
' table.sheet0 td.column0 { display:none }',
' table.sheet0 td.column4 { display:none }',
'}',
];
$expectedString = implode(PHP_EOL, $expectedArray);
self::assertStringContainsString(
$expectedString,
$html
);
$spreadsheet->disconnectWorksheets();
$reader = new HtmlReader();
$spreadsheet2 = $reader->loadFromString($html);
$sheet2 = $spreadsheet2->getActiveSheet();
self::assertSame('B2:D4', $sheet2->getPageSetup()->getPrintArea());
self::assertSame($inArray, $sheet2->toArray(null, false, false));
$spreadsheet2->disconnectWorksheets();
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Html/ImagesRootTest.php | tests/PhpSpreadsheetTests/Writer/Html/ImagesRootTest.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 ImagesRootTest extends Functional\AbstractFunctional
{
private string $curdir = '';
protected function setUp(): void
{
$curdir = getcwd();
if ($curdir === false) {
self::fail('Unable to obtain current directory');
} else {
$this->curdir = $curdir;
}
}
protected function tearDown(): void
{
chdir($this->curdir);
}
public function testImagesRoot(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$drawing = new \PhpOffice\PhpSpreadsheet\Worksheet\Drawing();
$drawing->setName('Test');
$drawing->setDescription('Test');
$root = 'http://www.example.com';
$newdir = __DIR__ . '/../../../data/Reader/HTML';
$stub = 'image.jpg';
$imagePath = "./$stub";
chdir($newdir);
self::assertFileExists($imagePath);
$drawing->setPath($imagePath);
$desc = 'Test <img> tag';
$drawing->setDescription($desc);
$drawing->setHeight(36);
$drawing->setWorksheet($spreadsheet->getActiveSheet());
$drawing->setCoordinates('A1');
$sheet->setCellValue('A2', 'Image Above?');
$writer = new Html($spreadsheet);
$writer->setImagesRoot($root);
$html = $writer->generateHTMLAll();
$dom = new DOMDocument();
$dom->loadHTML($html);
$body = $dom->getElementsByTagName('body')->item(0);
self::assertNotNull($body);
$divs = $body->getElementsByTagName('div');
$tabl = $divs->item(0)?->getElementsByTagName('table');
$tbod = $tabl?->item(0)?->getElementsByTagName('tbody');
$rows = $tbod?->item(0)?->getElementsByTagName('tr');
self::assertCount(2, $rows);
$tds = $rows?->item(0)?->getElementsByTagName('td');
self::assertCount(1, $tds);
$img = $tds?->item(0)?->getElementsByTagName('img');
self::assertCount(1, $img);
self::assertSame("$root/$stub", $img?->item(0)?->getAttribute('src'));
self::assertSame($desc, $img->item(0)->getAttribute('alt'));
$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/BadCustomPropertyTest.php | tests/PhpSpreadsheetTests/Writer/Html/BadCustomPropertyTest.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 BadCustomPropertyTest extends TestCase
{
public function testBadCustomProperty(): void
{
$reader = new XlsxReader();
$infile = 'tests/data/Reader/XLSX/sec-q229.dontuse';
$spreadsheet = $reader->load($infile);
$writer = new HtmlWriter($spreadsheet);
$html = $writer->generateHtmlAll();
self::assertStringContainsString('<meta name="custom.string.custom_property"><img src=1 onerror=alert()>" content="test" />', $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/LongTitleTest.php | tests/PhpSpreadsheetTests/Writer/Html/LongTitleTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Html;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheetTests\Functional\AbstractFunctional;
class LongTitleTest extends AbstractFunctional
{
#[\PHPUnit\Framework\Attributes\DataProvider('providerTitles')]
public function testLongTitle(string $expected, string $title): void
{
$spreadsheet = new Spreadsheet();
$spreadsheet
->getProperties()
->setTitle($title);
$sheet = $spreadsheet->getActiveSheet();
$sheet->setCellValue('A1', 1);
$reloadedSpreadsheet = $this->writeAndReload($spreadsheet, 'Html');
$spreadsheet->disconnectWorksheets();
self::assertSame($expected, $reloadedSpreadsheet->getActiveSheet()->getTitle());
$reloadedSpreadsheet->disconnectWorksheets();
}
public static function providerTitles(): array
{
return [
['Worksheet', 'This title is just a bit too long'],
['Worksheet', 'Invalid * character'],
['Legitimate Title', 'Legitimate Title'],
];
}
}
| php | MIT | e33834b4ea2a02088becbb41fb8954d915b46b12 | 2026-01-04T15:02:44.305364Z | false |
PHPOffice/PhpSpreadsheet | https://github.com/PHPOffice/PhpSpreadsheet/blob/e33834b4ea2a02088becbb41fb8954d915b46b12/tests/PhpSpreadsheetTests/Writer/Html/VisibilityTest.php | tests/PhpSpreadsheetTests/Writer/Html/VisibilityTest.php | <?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Writer\Html;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Style\Font;
use PhpOffice\PhpSpreadsheet\Writer\Html;
use PhpOffice\PhpSpreadsheetTests\Functional;
class VisibilityTest extends Functional\AbstractFunctional
{
public function testVisibility1(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->setCellValue('A1', 1);
$sheet->setCellValue('A2', 2);
$sheet->setCellValue('A3', 3);
$sheet->setCellValue('B1', 4);
$sheet->setCellValue('B2', 5);
$sheet->setCellValue('B3', 6);
$sheet->setCellValue('C1', 7);
$sheet->setCellValue('C2', 8);
$sheet->setCellValue('C3', 9);
$sheet->getColumnDimension('B')->setVisible(false);
$sheet->getRowDimension(2)->setVisible(false);
$writer = new Html($spreadsheet);
$html = $writer->generateHTMLAll();
$reg = '/^\s*table[.]sheet0 tr { display:none; visibility:hidden }\s*$/m';
$rowsrch = preg_match($reg, $html);
self::assertEquals($rowsrch, 0);
$reg = '/^\s*table[.]sheet0 tr[.]row1 { display:none; visibility:hidden }\s*$/m';
$rowsrch = preg_match($reg, $html);
self::assertEquals($rowsrch, 1);
$reg = '/^\s*table[.]sheet0 [.]column1 [{] display:none [}]\s*$/m';
$colsrch = preg_match($reg, $html);
self::assertEquals($colsrch, 1);
$this->writeAndReload($spreadsheet, 'Html');
}
public function testVisibility2(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->setCellValue('A1', 1);
$sheet->setCellValue('A2', 2);
$sheet->setCellValue('A3', 3);
$sheet->setCellValue('B1', 4);
$sheet->setCellValue('B2', 5);
$sheet->setCellValue('B3', 6);
$sheet->setCellValue('C1', 7);
$sheet->setCellValue('C2', 8);
$sheet->setCellValue('C3', 9);
$sheet->getDefaultRowDimension()->setVisible(false);
$sheet->getColumnDimension('B')->setVisible(false);
$sheet->getRowDimension(1)->setVisible(true);
$sheet->getRowDimension(3)->setVisible(true);
$writer = new Html($spreadsheet);
$html = $writer->generateHTMLAll();
$reg = '/^\s*table[.]sheet0 tr { height:15pt; display:none; visibility:hidden }\s*$/m';
$rowsrch = preg_match($reg, $html);
self::assertEquals($rowsrch, 1);
$reg = '/^\s*table[.]sheet0 tr[.]row1 { display:none; visibility:hidden }\s*$/m';
$rowsrch = preg_match($reg, $html);
self::assertEquals($rowsrch, 0);
$reg = '/^\s*table[.]sheet0 [.]column1 [{] display:none [}]\s*$/m';
$colsrch = preg_match($reg, $html);
self::assertEquals($colsrch, 1);
$this->writeAndReload($spreadsheet, 'Html');
}
public function testDefaultRowHeight(): void
{
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->setCellValue('A1', 1);
$sheet->getStyle('A1')->getFont()->setStrikethrough(true);
$sheet->setCellValue('A2', 2);
$sheet->setCellValue('A3', 3);
$sheet->getStyle('A3')->getFont()->setStrikethrough(true)->setUnderline(Font::UNDERLINE_SINGLE);
$sheet->setCellValue('B1', 4);
$sheet->setCellValue('B2', 5);
$sheet->setCellValue('B3', 6);
$sheet->setCellValue('C1', 7);
$sheet->setCellValue('C2', 8);
$sheet->setCellValue('C3', 9);
$sheet->getStyle('C3')->getFont()->setUnderline(Font::UNDERLINE_SINGLE);
$sheet->getDefaultRowDimension()->setRowHeight(20);
$sheet->getRowDimension(2)->setRowHeight(25);
$writer = new Html($spreadsheet);
$html = $writer->generateHTMLAll();
self::assertEquals(1, substr_count($html, 'height:20pt'));
self::assertEquals(1, substr_count($html, 'height:25pt'));
$rowsrch = preg_match('/^\s*table[.]sheet0 tr [{] height:20pt [}]\s*$/m', $html);
self::assertEquals(1, $rowsrch);
$rowsrch = preg_match('/^\s*table[.]sheet0 tr[.]row1 [{] height:25pt [}]\s*$/m', $html);
self::assertEquals(1, $rowsrch);
$rowsrch = preg_match('/^\s*td[.]style1, th[.]style1 [{].*text-decoration:line-through;.*[}]\s*$/m', $html);
self::assertEquals(1, $rowsrch);
$rowsrch = preg_match('/^\s*td[.]style2, th[.]style2 [{].*text-decoration:underline line-through;.*[}]\s*$/m', $html);
self::assertEquals(1, $rowsrch);
$rowsrch = preg_match('/^\s*td[.]style3, th[.]style3 [{].*text-decoration:underline;.*[}]\s*$/m', $html);
self::assertEquals(1, $rowsrch);
$this->writeAndReload($spreadsheet, 'Html');
}
}
| 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.