1
|
|
|
<?php |
2
|
|
|
|
3
|
|
|
/** |
4
|
|
|
* @file This file is part of the PdfParser library. |
5
|
|
|
* |
6
|
|
|
* @author Konrad Abicht <[email protected]> |
7
|
|
|
* |
8
|
|
|
* @date 2020-06-01 |
9
|
|
|
* |
10
|
|
|
* @author Sébastien MALOT <[email protected]> |
11
|
|
|
* |
12
|
|
|
* @date 2017-01-03 |
13
|
|
|
* |
14
|
|
|
* @license LGPLv3 |
15
|
|
|
* |
16
|
|
|
* @url <https://github.com/smalot/pdfparser> |
17
|
|
|
* |
18
|
|
|
* PdfParser is a pdf library written in PHP, extraction oriented. |
19
|
|
|
* Copyright (C) 2017 - Sébastien MALOT <[email protected]> |
20
|
|
|
* |
21
|
|
|
* This program is free software: you can redistribute it and/or modify |
22
|
|
|
* it under the terms of the GNU Lesser General Public License as published by |
23
|
|
|
* the Free Software Foundation, either version 3 of the License, or |
24
|
|
|
* (at your option) any later version. |
25
|
|
|
* |
26
|
|
|
* This program is distributed in the hope that it will be useful, |
27
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
28
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
29
|
|
|
* GNU Lesser General Public License for more details. |
30
|
|
|
* |
31
|
|
|
* You should have received a copy of the GNU Lesser General Public License |
32
|
|
|
* along with this program. |
33
|
|
|
* If not, see <http://www.pdfparser.org/sites/default/LICENSE.txt>. |
34
|
|
|
*/ |
35
|
|
|
|
36
|
|
|
namespace PHPUnitTests\Integration; |
37
|
|
|
|
38
|
|
|
use PHPUnitTests\TestCase; |
39
|
|
|
use Smalot\PdfParser\Document; |
40
|
|
|
use Smalot\PdfParser\PDFObject; |
41
|
|
|
|
42
|
|
|
class PDFObjectTest extends TestCase |
43
|
|
|
{ |
44
|
|
|
public const TYPE = 't'; |
45
|
|
|
|
46
|
|
|
public const OPERATOR = 'o'; |
47
|
|
|
|
48
|
|
|
public const COMMAND = 'c'; |
49
|
|
|
|
50
|
|
|
protected function getPdfObjectInstance($document): PDFObject |
51
|
|
|
{ |
52
|
|
|
return new PDFObject($document); |
53
|
|
|
} |
54
|
|
|
|
55
|
|
|
public function testGetCommandsText(): void |
56
|
|
|
{ |
57
|
|
|
$content = "BT /R14 30 Tf 0.999016 0 0 1 137.4 |
58
|
|
|
342.561 Tm |
59
|
|
|
[(A)-168.854( BC D)-220.905(\\(E\\))20.905<20>] |
60
|
|
|
TJ /R14 17.16 Tf <20> Tj |
61
|
|
|
0.999014 0 0 1 336.84 319.161 Tm T* ( \x00m)Tj |
62
|
|
|
/R14 20.04 Tf |
63
|
|
|
ET Q |
64
|
|
|
q -124.774 124.127 5.64213 5.67154 930.307 4436.95 cm |
65
|
|
|
BI"; |
66
|
|
|
|
67
|
|
|
$sections = $this->getPdfObjectInstance(new Document())->getSectionsText($content); |
68
|
|
|
|
69
|
|
|
$offset = 0; |
|
|
|
|
70
|
|
|
$parts = []; |
71
|
|
|
foreach ($sections as $section) { |
72
|
|
|
$parts[] = $this->getPdfObjectInstance(new Document())->getCommandsText($section)[0]; |
73
|
|
|
} |
74
|
|
|
|
75
|
|
|
$reference = [ |
76
|
|
|
[ |
77
|
|
|
self::TYPE => '', |
78
|
|
|
self::OPERATOR => 'BT', |
79
|
|
|
self::COMMAND => '', |
80
|
|
|
], |
81
|
|
|
[ |
82
|
|
|
self::TYPE => '/', |
83
|
|
|
self::OPERATOR => 'Tf', |
84
|
|
|
self::COMMAND => 'R14 30', |
85
|
|
|
], |
86
|
|
|
[ |
87
|
|
|
self::TYPE => '', |
88
|
|
|
self::OPERATOR => 'Tm', |
89
|
|
|
self::COMMAND => '0.999016 0 0 1 137.4 342.561', |
90
|
|
|
], |
91
|
|
|
[ |
92
|
|
|
self::TYPE => '[', |
93
|
|
|
self::OPERATOR => 'TJ', |
94
|
|
|
self::COMMAND => [ |
95
|
|
|
[ |
96
|
|
|
self::TYPE => '(', |
97
|
|
|
self::OPERATOR => 'TJ', |
98
|
|
|
self::COMMAND => 'A', |
99
|
|
|
], |
100
|
|
|
[ |
101
|
|
|
self::TYPE => 'n', |
102
|
|
|
self::OPERATOR => '', |
103
|
|
|
self::COMMAND => '-168.854', |
104
|
|
|
], |
105
|
|
|
[ |
106
|
|
|
self::TYPE => '(', |
107
|
|
|
self::OPERATOR => 'TJ', |
108
|
|
|
self::COMMAND => ' BC D', |
109
|
|
|
], |
110
|
|
|
[ |
111
|
|
|
self::TYPE => 'n', |
112
|
|
|
self::OPERATOR => '', |
113
|
|
|
self::COMMAND => '-220.905', |
114
|
|
|
], |
115
|
|
|
[ |
116
|
|
|
self::TYPE => '(', |
117
|
|
|
self::OPERATOR => 'TJ', |
118
|
|
|
self::COMMAND => '\\(E\\)', |
119
|
|
|
], |
120
|
|
|
[ |
121
|
|
|
self::TYPE => 'n', |
122
|
|
|
self::OPERATOR => '', |
123
|
|
|
self::COMMAND => '20.905', |
124
|
|
|
], |
125
|
|
|
[ |
126
|
|
|
self::TYPE => '<', |
127
|
|
|
self::OPERATOR => 'TJ', |
128
|
|
|
self::COMMAND => '20', |
129
|
|
|
], |
130
|
|
|
], |
131
|
|
|
], |
132
|
|
|
[ |
133
|
|
|
self::TYPE => '/', |
134
|
|
|
self::OPERATOR => 'Tf', |
135
|
|
|
self::COMMAND => 'R14 17.16', |
136
|
|
|
], |
137
|
|
|
[ |
138
|
|
|
self::TYPE => '<', |
139
|
|
|
self::OPERATOR => 'Tj', |
140
|
|
|
self::COMMAND => '20', |
141
|
|
|
], |
142
|
|
|
[ |
143
|
|
|
self::TYPE => '', |
144
|
|
|
self::OPERATOR => 'Tm', |
145
|
|
|
self::COMMAND => '0.999014 0 0 1 336.84 319.161', |
146
|
|
|
], |
147
|
|
|
[ |
148
|
|
|
self::TYPE => '', |
149
|
|
|
self::OPERATOR => 'T*', |
150
|
|
|
self::COMMAND => '', |
151
|
|
|
], |
152
|
|
|
[ |
153
|
|
|
self::TYPE => '(', |
154
|
|
|
self::OPERATOR => 'Tj', |
155
|
|
|
self::COMMAND => " \x00m", |
156
|
|
|
], |
157
|
|
|
[ |
158
|
|
|
self::TYPE => '/', |
159
|
|
|
self::OPERATOR => 'Tf', |
160
|
|
|
self::COMMAND => 'R14 20.04', |
161
|
|
|
], |
162
|
|
|
[ |
163
|
|
|
self::TYPE => '', |
164
|
|
|
self::OPERATOR => 'ET', |
165
|
|
|
self::COMMAND => '', |
166
|
|
|
], |
167
|
|
|
[ |
168
|
|
|
self::TYPE => '', |
169
|
|
|
self::OPERATOR => 'Q', |
170
|
|
|
self::COMMAND => '', |
171
|
|
|
], |
172
|
|
|
[ |
173
|
|
|
self::TYPE => '', |
174
|
|
|
self::OPERATOR => 'q', |
175
|
|
|
self::COMMAND => '', |
176
|
|
|
], |
177
|
|
|
[ |
178
|
|
|
self::TYPE => '', |
179
|
|
|
self::OPERATOR => 'cm', |
180
|
|
|
self::COMMAND => '-124.774 124.127 5.64213 5.67154 930.307 4436.95', |
181
|
|
|
], |
182
|
|
|
]; |
183
|
|
|
|
184
|
|
|
$this->assertEquals($parts, $reference); |
185
|
|
|
} |
186
|
|
|
|
187
|
|
|
public function testCleanContent(): void |
188
|
|
|
{ |
189
|
|
|
$content = '/Shape <</MCID << /Font<8>>> BT >>BDC |
190
|
|
|
Q |
191
|
|
|
/CS0 cs 1 1 0 scn |
192
|
|
|
1 i |
193
|
|
|
/GS0 gs |
194
|
|
|
BT |
195
|
|
|
/TT0 1 Tf |
196
|
|
|
0.0007 Tc 0.0018 Tw 0 Ts 100 Tz 0 Tr 24 0 0 24 51.3 639.26025 Tm |
197
|
|
|
(Modificatio[ns] au \\(14\\) septembre 2009 ET 2010)Tj |
198
|
|
|
EMC |
199
|
|
|
(ABC) Tj |
200
|
|
|
|
201
|
|
|
[ (a)-4.5(b)6(c)8.8 ( fsdfsdfsdf[]sd) ] TD |
202
|
|
|
|
203
|
|
|
ET |
204
|
|
|
/Shape <</MCID 2 >>BDC |
205
|
|
|
q |
206
|
|
|
0.03 841'; |
207
|
|
|
|
208
|
|
|
$expected = '_____________________________________ |
209
|
|
|
Q |
210
|
|
|
/CS0 cs 1 1 0 scn |
211
|
|
|
1 i |
212
|
|
|
/GS0 gs |
213
|
|
|
BT |
214
|
|
|
/TT0 1 Tf |
215
|
|
|
0.0007 Tc 0.0018 Tw 0 Ts 100 Tz 0 Tr 24 0 0 24 51.3 639.26025 Tm |
216
|
|
|
(________________________________________________)Tj |
217
|
|
|
___ |
218
|
|
|
(___) Tj |
219
|
|
|
|
220
|
|
|
[_____________________________________] TD |
221
|
|
|
|
222
|
|
|
ET |
223
|
|
|
______________________ |
224
|
|
|
q |
225
|
|
|
0.03 841'; |
226
|
|
|
|
227
|
|
|
$cleaned = $this->getPdfObjectInstance(new Document())->cleanContent($content, '_'); |
|
|
|
|
228
|
|
|
|
229
|
|
|
$this->assertEquals($cleaned, $expected); |
230
|
|
|
} |
231
|
|
|
|
232
|
|
|
public function testFormatContent(): void |
233
|
|
|
{ |
234
|
|
|
$content = '/Shape <</MCID << /Font<8>>> BT >>BDC Q /CS0 cs 1 1 0 scn 1 i |
235
|
|
|
/GS0 gs BT /TT0 1 Tf 0.0007 Tc 0.0018 Tw 0 Ts 100 Tz 0 Tr 24 0 0 24 51.3 639.26025 Tm |
236
|
|
|
(Modificatio[ns] au \\(14\\) septembre 2009 ET 2010)Tj EMC (ABC) Tj |
237
|
|
|
[ (a)-4.5(b)6(c)8.8 ( fsdfsdfsdf[]sd) ] TJ ET /Shape <</MCID 2 >>BDC q 0.03 841'; |
238
|
|
|
|
239
|
|
|
$expected = '/Shape <</MCID << /Font<8>>> BT >>BDC |
240
|
|
|
Q |
241
|
|
|
/CS0 cs |
242
|
|
|
1 1 0 scn |
243
|
|
|
1 i |
244
|
|
|
/GS0 gs |
245
|
|
|
BT |
246
|
|
|
/TT0 1 Tf |
247
|
|
|
0.0007 Tc |
248
|
|
|
0.0018 Tw |
249
|
|
|
0 Ts |
250
|
|
|
100 Tz |
251
|
|
|
0 Tr |
252
|
|
|
24 0 0 24 51.3 639.26025 Tm |
253
|
|
|
(Modificatio[ns] au \\(14\\) septembre 2009 ET 2010)Tj |
254
|
|
|
EMC |
255
|
|
|
(ABC) Tj |
256
|
|
|
[ (a)-4.5(b)6(c)8.8 ( fsdfsdfsdf[]sd) ] TJ |
257
|
|
|
ET |
258
|
|
|
/Shape <</MCID 2 >>BDC |
259
|
|
|
q |
260
|
|
|
0.03 841'; |
261
|
|
|
|
262
|
|
|
// Normalize line-endings |
263
|
|
|
$expected = str_replace(["\r\n", "\n"], ["\n", "\r\n"], $expected); |
264
|
|
|
|
265
|
|
|
$formatContent = new \ReflectionMethod('Smalot\PdfParser\PDFObject', 'formatContent'); |
266
|
|
|
$formatContent->setAccessible(true); |
267
|
|
|
$cleaned = $formatContent->invoke($this->getPdfObjectInstance(new Document()), $content); |
268
|
|
|
|
269
|
|
|
$this->assertEquals($expected, $cleaned); |
270
|
|
|
|
271
|
|
|
// Check that binary data is rejected |
272
|
|
|
$content = hex2bin('a670c89d4a324e47'); |
273
|
|
|
|
274
|
|
|
$cleaned = $formatContent->invoke($this->getPdfObjectInstance(new Document()), $content); |
275
|
|
|
|
276
|
|
|
$this->assertEquals('', $cleaned); |
277
|
|
|
|
278
|
|
|
// See: https://github.com/smalot/pdfparser/issues/668 |
279
|
|
|
$filename = $this->rootDir.'/samples/bugs/Issue668.pdf'; |
280
|
|
|
|
281
|
|
|
$parser = $this->getParserInstance(); |
282
|
|
|
$document = $parser->parseFile($filename); |
283
|
|
|
$pages = $document->getPages(); |
284
|
|
|
|
285
|
|
|
// Binary check is done before a regexp that causes an error |
286
|
|
|
$this->assertStringContainsString('Marko Nestorović PR', $pages[0]->getText()); |
287
|
|
|
|
288
|
|
|
// mb_check_encoding(..., 'UTF-8') returns true here, |
289
|
|
|
// necessitating a test for UTF-8 that's more strict |
290
|
|
|
$content = hex2bin('0101010101010101'); |
291
|
|
|
$cleaned = $formatContent->invoke($this->getPdfObjectInstance(new Document()), $content); |
292
|
|
|
|
293
|
|
|
$this->assertEquals('', $cleaned); |
294
|
|
|
} |
295
|
|
|
|
296
|
|
|
/** |
297
|
|
|
* Check that inline image data does not corrupt the stream |
298
|
|
|
* |
299
|
|
|
* @see: https://github.com/smalot/pdfparser/issues/691 |
300
|
|
|
*/ |
301
|
|
|
public function testFormatContentInlineImages(): void |
302
|
|
|
{ |
303
|
|
|
$formatContent = new \ReflectionMethod('Smalot\PdfParser\PDFObject', 'formatContent'); |
304
|
|
|
$formatContent->setAccessible(true); |
305
|
|
|
|
306
|
|
|
$cleaned = $formatContent->invoke( |
307
|
|
|
$this->getPdfObjectInstance(new Document()), |
308
|
|
|
'BT (This BI /W 258 /H 51 /should not trigger /as a /PDF command) TD ET q 65.30 0 0 18.00 412 707 cm BI /W 544 /H 150 |
309
|
|
|
/BPC 1 /IM true /F [/A85 /Fl] ID Gb"0F_$L6!$j/a\$:ma&h\'JnJJ9S?O_EA-W+%D^ClCH=FP3s5M-gStQm\'5/hc`C?<Q)riWgtEe:Po0dY_-er6$jM@#?n`E+#(sa"0Gk3&K>CqL(^pV$_-er6Ik`"-1]Q ;~> EI Q /F002 10.00 Tf 0.00 Tw 0 g' |
310
|
|
|
); |
311
|
|
|
|
312
|
|
|
// PdfParser should not be fooled by Q's in inline image data; |
313
|
|
|
// Only one 'Q' command should be found |
314
|
|
|
$commandQ = preg_match_all('/Q\r\n/', $cleaned); |
315
|
|
|
$this->assertEquals(1, $commandQ); |
316
|
|
|
|
317
|
|
|
// The 'BI' inside a string should not be interpreted as the |
318
|
|
|
// beginning of an inline image command |
319
|
|
|
$this->assertStringContainsString('(This BI /W 258 /H 51 /should not trigger /as a /PDF command) TD', $cleaned); |
320
|
|
|
|
321
|
|
|
$cleaned = $formatContent->invoke( |
322
|
|
|
$this->getPdfObjectInstance(new Document()), |
323
|
|
|
'BT (This BI /W 258 /H 51 /should not () \) trigger /as a /PDF command) TD (There is no ID inline image in this data) TD (Nothing but text EI should be found) TD ET' |
324
|
|
|
); |
325
|
|
|
|
326
|
|
|
$this->assertEquals('BT'."\r\n". |
327
|
|
|
'(This BI /W 258 /H 51 /should not () \) trigger /as a /PDF command) TD'."\r\n". |
328
|
|
|
'(There is no ID inline image in this data) TD'."\r\n". |
329
|
|
|
'(Nothing but text EI should be found) TD'."\r\n". |
330
|
|
|
'ET', $cleaned); |
331
|
|
|
} |
332
|
|
|
|
333
|
|
|
public function testGetSectionsText(): void |
334
|
|
|
{ |
335
|
|
|
$content = '/Shape <</MCID 1 >>BDC |
336
|
|
|
Q |
337
|
|
|
/CS0 cs 1 1 0 scn |
338
|
|
|
1 i |
339
|
|
|
/GS0 gs |
340
|
|
|
BT |
341
|
|
|
/TT0 1 Tf |
342
|
|
|
0.0007 Tc 0.0018 Tw 0 Ts 100 Tz 0 Tr 24 0 0 24 51.3 639.26025 Tm |
343
|
|
|
(Mod BT atio[ns] au \\(14\\) septembre 2009 ET 2010)Tj |
344
|
|
|
EMC |
345
|
|
|
(ABC) Tj |
346
|
|
|
|
347
|
|
|
[ (a)-4.5(b) 6(c)8.8 ( fsdfsdfsdf[ sd) ] TD |
348
|
|
|
|
349
|
|
|
ET |
350
|
|
|
/Shape <</MCID [BT] >>BDC BT /TT1 1.5 Tf (BT )Tj ET |
351
|
|
|
q |
352
|
|
|
0.03 841'; |
353
|
|
|
|
354
|
|
|
$sections = $this->getPdfObjectInstance(new Document())->getSectionsText($content); |
355
|
|
|
|
356
|
|
|
$this->assertEquals( |
357
|
|
|
[ |
358
|
|
|
'/Shape <</MCID 1 >>BDC', |
359
|
|
|
'Q', |
360
|
|
|
'BT', |
361
|
|
|
'/TT0 1 Tf', |
362
|
|
|
'0.0007 Tc', |
363
|
|
|
'0.0018 Tw', |
364
|
|
|
'0 Ts', |
365
|
|
|
'100 Tz', |
366
|
|
|
'0 Tr', |
367
|
|
|
'24 0 0 24 51.3 639.26025 Tm', |
368
|
|
|
'(Mod BT atio[ns] au \\(14\\) septembre 2009 ET 2010)Tj', |
369
|
|
|
'EMC', |
370
|
|
|
'(ABC) Tj', |
371
|
|
|
'[ (a)-4.5(b) 6(c)8.8 ( fsdfsdfsdf[ sd) ] TD', |
372
|
|
|
'ET', |
373
|
|
|
'/Shape <</MCID [BT] >>BDC', |
374
|
|
|
'BT', |
375
|
|
|
'/TT1 1.5 Tf', |
376
|
|
|
'(BT )Tj', |
377
|
|
|
'ET', |
378
|
|
|
'q', |
379
|
|
|
], |
380
|
|
|
$sections |
381
|
|
|
); |
382
|
|
|
|
383
|
|
|
// Test that a Name containing 'ET' doesn't close a 'BT' block |
384
|
|
|
// See: https://github.com/smalot/pdfparser/issues/474 |
385
|
|
|
$content = 'BT |
386
|
|
|
/FTxkPETkkj 8 Tf |
387
|
|
|
1 0 0 1 535.55 627.4 Tm |
388
|
|
|
(Hello World)TJ |
389
|
|
|
ET'; |
390
|
|
|
|
391
|
|
|
$sections = $this->getPdfObjectInstance(new Document())->getSectionsText($content); |
392
|
|
|
|
393
|
|
|
$this->assertNotEquals('/FTxkP', $sections[0]); |
394
|
|
|
$this->assertNotEquals('/FTxkP', $sections[1]); |
395
|
|
|
} |
396
|
|
|
|
397
|
|
|
public function testParseDictionary(): void |
398
|
|
|
{ |
399
|
|
|
$data = '<</ActualText(text)/XObject<</F2 6 0 R /F3 [/Sub /Array]>> /Array[/Parsed /Data/Actual]/Silent<>>>'; |
400
|
|
|
|
401
|
|
|
$dictionary = $this->getPdfObjectInstance(new Document())->parseDictionary($data); |
402
|
|
|
|
403
|
|
|
$this->assertArrayHasKey('ActualText', $dictionary); |
404
|
|
|
$this->assertArrayHasKey('XObject', $dictionary); |
405
|
|
|
$this->assertArrayHasKey('Array', $dictionary); |
406
|
|
|
$this->assertArrayHasKey('Silent', $dictionary); |
407
|
|
|
|
408
|
|
|
$this->assertCount(3, $dictionary['Array']); |
409
|
|
|
|
410
|
|
|
$this->assertEquals('<>', $dictionary['Silent']); |
411
|
|
|
} |
412
|
|
|
|
413
|
|
|
/** |
414
|
|
|
* Tests that graphics position (cm) is taken into account when |
415
|
|
|
* positioning text |
416
|
|
|
* |
417
|
|
|
* @see: https://github.com/smalot/pdfparser/issues/608 |
418
|
|
|
*/ |
419
|
|
|
public function testGraphicsPositioning(): void |
420
|
|
|
{ |
421
|
|
|
$filename = $this->rootDir.'/samples/bugs/Issue608.pdf'; |
422
|
|
|
|
423
|
|
|
$parser = $this->getParserInstance(); |
424
|
|
|
$document = $parser->parseFile($filename); |
425
|
|
|
$pages = $document->getPages(); |
426
|
|
|
|
427
|
|
|
// The \n is not added if 'cm' commands are ignored |
428
|
|
|
$this->assertStringContainsString("Heading 1 \nLorem ipsum", $pages[0]->getText()); |
429
|
|
|
} |
430
|
|
|
|
431
|
|
|
/** |
432
|
|
|
* Tests that ActualText text is printed for a block instead of the |
433
|
|
|
* contents of the Tj or TJ commands in the block. |
434
|
|
|
* |
435
|
|
|
* @see: https://github.com/smalot/pdfparser/issues/464 |
436
|
|
|
*/ |
437
|
|
|
public function testActualText(): void |
438
|
|
|
{ |
439
|
|
|
$filename = $this->rootDir.'/samples/bugs/Issue608.pdf'; |
440
|
|
|
|
441
|
|
|
$parser = $this->getParserInstance(); |
442
|
|
|
$document = $parser->parseFile($filename); |
443
|
|
|
$pages = $document->getPages(); |
444
|
|
|
|
445
|
|
|
// An ActualText command subs in the three literal characters |
446
|
|
|
// 'ffi' for the single character ligature here |
447
|
|
|
// In addition, if $last_written_position isn't used to store |
448
|
|
|
// the position to insert, \n's would be erroniously inserted |
449
|
|
|
// on either side of the 'ffi' |
450
|
|
|
$this->assertStringContainsString('efficitur', $pages[0]->getText()); |
451
|
|
|
} |
452
|
|
|
|
453
|
|
|
/** |
454
|
|
|
* Tests for the correct decoding of an Em-dash character in |
455
|
|
|
* certain font contexts |
456
|
|
|
* |
457
|
|
|
* See: https://github.com/smalot/pdfparser/issues/585 |
458
|
|
|
*/ |
459
|
|
|
public function testDecodeEmDash(): void |
460
|
|
|
{ |
461
|
|
|
$filename = $this->rootDir.'/samples/bugs/Issue585.pdf'; |
462
|
|
|
|
463
|
|
|
$parser = $this->getParserInstance(); |
464
|
|
|
$document = $parser->parseFile($filename); |
465
|
|
|
$pages = $document->getPages(); |
466
|
|
|
|
467
|
|
|
$this->assertStringContainsString('слева по ходу — веревка', $pages[0]->getText()); |
468
|
|
|
} |
469
|
|
|
|
470
|
|
|
/** |
471
|
|
|
* Tests behavior with reversed chars instruction. |
472
|
|
|
* |
473
|
|
|
* @see: https://github.com/smalot/pdfparser/issues/398 |
474
|
|
|
*/ |
475
|
|
|
public function testReversedChars(): void |
476
|
|
|
{ |
477
|
|
|
$filename = $this->rootDir.'/samples/bugs/Issue398.pdf'; |
478
|
|
|
|
479
|
|
|
$parser = $this->getParserInstance(); |
480
|
|
|
$document = $parser->parseFile($filename); |
481
|
|
|
$pages = $document->getPages(); |
482
|
|
|
|
483
|
|
|
$pageText = $pages[0]->getText(); |
484
|
|
|
|
485
|
|
|
$this->assertStringContainsString('שלומי טסט', $pageText); |
486
|
|
|
$this->assertStringContainsString('בנמל מספנות ישראל.', $pageText); |
487
|
|
|
} |
488
|
|
|
|
489
|
|
|
/** |
490
|
|
|
* Tests that a text stream with an improperly selected font code |
491
|
|
|
* page falls back to one that maps all characters. |
492
|
|
|
* |
493
|
|
|
* @see: https://github.com/smalot/pdfparser/issues/586 |
494
|
|
|
*/ |
495
|
|
|
public function testImproperFontFallback(): void |
496
|
|
|
{ |
497
|
|
|
$filename = $this->rootDir.'/samples/ImproperFontFallback.pdf'; |
498
|
|
|
|
499
|
|
|
$parser = $this->getParserInstance(); |
500
|
|
|
$document = $parser->parseFile($filename); |
501
|
|
|
$pages = $document->getPages(); |
502
|
|
|
|
503
|
|
|
$this->assertStringContainsString('сделал', $pages[0]->getText()); |
504
|
|
|
} |
505
|
|
|
|
506
|
|
|
/** |
507
|
|
|
* Tests that a font ID containing a hyphen / dash character was |
508
|
|
|
* correctly parsed |
509
|
|
|
* |
510
|
|
|
* @see: https://github.com/smalot/pdfparser/issues/145 |
511
|
|
|
*/ |
512
|
|
|
public function testFontIDWithHyphen(): void |
513
|
|
|
{ |
514
|
|
|
$pdfObject = $this->getPdfObjectInstance(new Document()); |
515
|
|
|
|
516
|
|
|
$fontCommandHyphen = $pdfObject->getCommandsText('/FID-01 15.00 Tf'); |
517
|
|
|
|
518
|
|
|
$this->assertEquals('/', $fontCommandHyphen[0]['t']); |
519
|
|
|
$this->assertEquals('Tf', $fontCommandHyphen[0]['o']); |
520
|
|
|
$this->assertEquals('FID-01 15.00', $fontCommandHyphen[0]['c']); |
521
|
|
|
} |
522
|
|
|
|
523
|
|
|
/** |
524
|
|
|
* Tests that an invalid command does not cause an error, but just |
525
|
|
|
* returns an empty array |
526
|
|
|
*/ |
527
|
|
|
public function testInvalidCommand(): void |
528
|
|
|
{ |
529
|
|
|
$pdfObject = $this->getPdfObjectInstance(new Document()); |
530
|
|
|
|
531
|
|
|
$validCommand = $pdfObject->getCommandsText('75 rg'); |
532
|
|
|
|
533
|
|
|
$this->assertEquals('', $validCommand[0]['t']); |
534
|
|
|
$this->assertEquals('rg', $validCommand[0]['o']); |
535
|
|
|
$this->assertEquals('75', $validCommand[0]['c']); |
536
|
|
|
|
537
|
|
|
$invalidCommand = $pdfObject->getCommandsText('75'); |
538
|
|
|
|
539
|
|
|
$this->assertEquals([], $invalidCommand); |
540
|
|
|
} |
541
|
|
|
} |
542
|
|
|
|