9#include "build/build_config.h"
10#include "core/fxge/fx_font.h"
11#include "public/cpp/fpdf_scopers.h"
12#include "public/fpdf_doc.h"
13#include "public/fpdf_text.h"
14#include "public/fpdf_transformpage.h"
15#include "public/fpdfview.h"
16#include "testing/embedder_test.h"
17#include "testing/fx_string_testhelpers.h"
18#include "testing/gtest/include/gtest/gtest.h"
22constexpr char kHelloGoodbyeText[] =
"Hello, world!\r\nGoodbye, world!";
23constexpr int kHelloGoodbyeTextSize =
std::size(kHelloGoodbyeText);
25bool check_unsigned_shorts(
const char* expected,
26 const unsigned short* actual,
28 if (length > strlen(expected) + 1)
31 for (size_t i = 0; i < length; ++i) {
32 if (actual[i] !=
static_cast<
unsigned short>(expected[i]))
43 ASSERT_TRUE(OpenDocument(
"hello_world.pdf"));
44 FPDF_PAGE page = LoadPage(0);
48 ASSERT_TRUE(textpage);
50 unsigned short buffer[128];
51 memset(buffer, 0xbd,
sizeof(buffer));
58 EXPECT_EQ(0, buffer[0]);
61 memset(buffer, 0xbd,
sizeof(buffer));
63 EXPECT_EQ(kHelloGoodbyeText[0], buffer[0]);
64 EXPECT_EQ(0, buffer[1]);
68 ASSERT_EQ(kHelloGoodbyeTextSize, num_chars);
70 check_unsigned_shorts(kHelloGoodbyeText, buffer, kHelloGoodbyeTextSize));
74 for (size_t i = 0; i < kHelloGoodbyeTextSize - 1; ++i) {
75 EXPECT_EQ(
static_cast<
unsigned int>(kHelloGoodbyeText[i]),
76 FPDFText_GetUnicode(textpage, i))
83 static const char kSmallExpected[] =
"Hello";
84 unsigned short small_buffer[12];
85 memset(buffer, 0xbd,
sizeof(buffer));
87 EXPECT_TRUE(check_unsigned_shorts(kSmallExpected, small_buffer,
88 sizeof(kSmallExpected)));
98 EXPECT_DOUBLE_EQ(1.0, left);
99 EXPECT_DOUBLE_EQ(2.0, right);
100 EXPECT_DOUBLE_EQ(3.0, bottom);
101 EXPECT_DOUBLE_EQ(4.0, top);
103 EXPECT_DOUBLE_EQ(1.0, left);
104 EXPECT_DOUBLE_EQ(2.0, right);
105 EXPECT_DOUBLE_EQ(3.0, bottom);
106 EXPECT_DOUBLE_EQ(4.0, top);
108 EXPECT_DOUBLE_EQ(1.0, left);
109 EXPECT_DOUBLE_EQ(2.0, right);
110 EXPECT_DOUBLE_EQ(3.0, bottom);
111 EXPECT_DOUBLE_EQ(4.0, top);
122 EXPECT_NEAR(41.120, left, 0.001);
123 EXPECT_NEAR(46.208, right, 0.001);
124 EXPECT_NEAR(49.892, bottom, 0.001);
125 EXPECT_NEAR(55.652, top, 0.001);
127 FS_RECTF rect = {4.0f, 1.0f, 3.0f, 2.0f};
129 EXPECT_FLOAT_EQ(4.0f, rect.left);
130 EXPECT_FLOAT_EQ(3.0f, rect.right);
131 EXPECT_FLOAT_EQ(2.0f, rect.bottom);
132 EXPECT_FLOAT_EQ(1.0f, rect.top);
134 EXPECT_FLOAT_EQ(4.0f, rect.left);
135 EXPECT_FLOAT_EQ(3.0f, rect.right);
136 EXPECT_FLOAT_EQ(2.0f, rect.bottom);
137 EXPECT_FLOAT_EQ(1.0f, rect.top);
139 EXPECT_FLOAT_EQ(4.0f, rect.left);
140 EXPECT_FLOAT_EQ(3.0f, rect.right);
141 EXPECT_FLOAT_EQ(2.0f, rect.bottom);
142 EXPECT_FLOAT_EQ(1.0f, rect.top);
146 EXPECT_FLOAT_EQ(40.664001f, rect.left);
147 EXPECT_FLOAT_EQ(46.664001f, rect.right);
148 EXPECT_FLOAT_EQ(47.667271f, rect.bottom);
149 EXPECT_FLOAT_EQ(59.667271f, rect.top);
154 EXPECT_NEAR(40.664, x, 0.001);
155 EXPECT_NEAR(50.000, y, 0.001);
174 EXPECT_NEAR(20.800, left, 0.001);
175 EXPECT_NEAR(135.040, right, 0.001);
176 EXPECT_NEAR(96.688, bottom, 0.001);
177 EXPECT_NEAR(111.600, top, 0.001);
185 EXPECT_EQ(0.0, left);
186 EXPECT_EQ(0.0, right);
187 EXPECT_EQ(0.0, bottom);
195 EXPECT_EQ(0.0, left);
196 EXPECT_EQ(0.0, right);
197 EXPECT_EQ(0.0, bottom);
204 memset(buffer, 0xbd,
sizeof(buffer));
207 EXPECT_TRUE(check_unsigned_shorts(kHelloGoodbyeText + 4, buffer, 1));
208 EXPECT_EQ(0xbdbd, buffer[1]);
210 memset(buffer, 0xbd,
sizeof(buffer));
213 EXPECT_TRUE(check_unsigned_shorts(kHelloGoodbyeText + 4, buffer, 8));
214 EXPECT_EQ(0xbdbd, buffer[9]);
216 memset(buffer, 0xbd,
sizeof(buffer));
219 EXPECT_TRUE(check_unsigned_shorts(kHelloGoodbyeText + 4, buffer, 9));
220 EXPECT_EQ(0u, buffer[9]);
221 EXPECT_EQ(0xbdbd, buffer[10]);
228 ASSERT_TRUE(OpenDocument(
"vertical_text.pdf"));
229 FPDF_PAGE page = LoadPage(0);
233 ASSERT_TRUE(textpage);
240 EXPECT_NEAR(6.664, x, 0.001);
241 EXPECT_NEAR(171.508, y, 0.001);
244 EXPECT_NEAR(8.668, x, 0.001);
245 EXPECT_NEAR(160.492, y, 0.001);
249 EXPECT_NEAR(4, rect.left, 0.001);
250 EXPECT_NEAR(16, rect.right, 0.001);
251 EXPECT_NEAR(178.984, rect.bottom, 0.001);
252 EXPECT_NEAR(170.308, rect.top, 0.001);
255 EXPECT_NEAR(4, rect.left, 0.001);
256 EXPECT_NEAR(16, rect.right, 0.001);
257 EXPECT_NEAR(170.308, rect.bottom, 0.001);
258 EXPECT_NEAR(159.292, rect.top, 0.001);
265 ASSERT_TRUE(OpenDocument(
"hebrew_mirrored.pdf"));
266 FPDF_PAGE page = LoadPage(0);
270 ScopedFPDFTextPage textpage(FPDFText_LoadPage(page));
271 ASSERT_TRUE(textpage);
273 constexpr int kCharCount = 10;
274 ASSERT_EQ(kCharCount, FPDFText_CountChars(textpage.get()));
276 unsigned short buffer[kCharCount + 1];
277 memset(buffer, 0x42,
sizeof(buffer));
278 EXPECT_EQ(kCharCount + 1,
279 FPDFText_GetText(textpage.get(), 0, kCharCount, buffer));
280 EXPECT_EQ(0x05d1, buffer[0]);
281 EXPECT_EQ(0x05e0, buffer[1]);
282 EXPECT_EQ(0x05d9, buffer[2]);
283 EXPECT_EQ(0x05de, buffer[3]);
284 EXPECT_EQ(0x05d9, buffer[4]);
285 EXPECT_EQ(0x05df, buffer[5]);
286 EXPECT_EQ(0x000d, buffer[6]);
287 EXPECT_EQ(0x000a, buffer[7]);
288 EXPECT_EQ(0x05df, buffer[8]);
289 EXPECT_EQ(0x05d1, buffer[9]);
296 ASSERT_TRUE(OpenDocument(
"hello_world.pdf"));
297 FPDF_PAGE page = LoadPage(0);
301 ASSERT_TRUE(textpage);
303 ScopedFPDFWideString nope = GetFPDFWideString(L"nope");
304 ScopedFPDFWideString world = GetFPDFWideString(L"world");
305 ScopedFPDFWideString world_caps = GetFPDFWideString(L"WORLD");
306 ScopedFPDFWideString world_substr = GetFPDFWideString(L"orld");
310 ScopedFPDFTextFind search(FPDFText_FindStart(textpage, nope.get(), 0, 0));
312 EXPECT_EQ(0, FPDFText_GetSchResultIndex(search.get()));
313 EXPECT_EQ(0, FPDFText_GetSchCount(search.get()));
316 EXPECT_FALSE(FPDFText_FindNext(search.get()));
317 EXPECT_EQ(0, FPDFText_GetSchResultIndex(search.get()));
318 EXPECT_EQ(0, FPDFText_GetSchCount(search.get()));
321 EXPECT_FALSE(FPDFText_FindPrev(search.get()));
322 EXPECT_EQ(0, FPDFText_GetSchResultIndex(search.get()));
323 EXPECT_EQ(0, FPDFText_GetSchCount(search.get()));
328 ScopedFPDFTextFind search(FPDFText_FindStart(textpage, world.get(), 0, 2));
332 EXPECT_EQ(0, FPDFText_GetSchResultIndex(search.get()));
333 EXPECT_EQ(0, FPDFText_GetSchCount(search.get()));
336 EXPECT_TRUE(FPDFText_FindNext(search.get()));
337 EXPECT_EQ(7, FPDFText_GetSchResultIndex(search.get()));
338 EXPECT_EQ(5, FPDFText_GetSchCount(search.get()));
341 EXPECT_TRUE(FPDFText_FindNext(search.get()));
342 EXPECT_EQ(24, FPDFText_GetSchResultIndex(search.get()));
343 EXPECT_EQ(5, FPDFText_GetSchCount(search.get()));
346 EXPECT_FALSE(FPDFText_FindNext(search.get()));
347 EXPECT_EQ(24, FPDFText_GetSchResultIndex(search.get()));
348 EXPECT_EQ(5, FPDFText_GetSchCount(search.get()));
351 EXPECT_TRUE(FPDFText_FindPrev(search.get()));
352 EXPECT_EQ(7, FPDFText_GetSchResultIndex(search.get()));
353 EXPECT_EQ(5, FPDFText_GetSchCount(search.get()));
356 EXPECT_FALSE(FPDFText_FindPrev(search.get()));
357 EXPECT_EQ(7, FPDFText_GetSchResultIndex(search.get()));
358 EXPECT_EQ(5, FPDFText_GetSchCount(search.get()));
363 ScopedFPDFTextFind search(FPDFText_FindStart(
366 EXPECT_TRUE(FPDFText_FindNext(search.get()));
367 EXPECT_EQ(7, FPDFText_GetSchResultIndex(search.get()));
368 EXPECT_EQ(5, FPDFText_GetSchCount(search.get()));
373 ScopedFPDFTextFind search(
374 FPDFText_FindStart(textpage, world_caps.get(), 0, 0));
376 EXPECT_TRUE(FPDFText_FindNext(search.get()));
377 EXPECT_EQ(7, FPDFText_GetSchResultIndex(search.get()));
378 EXPECT_EQ(5, FPDFText_GetSchCount(search.get()));
383 ScopedFPDFTextFind search(
384 FPDFText_FindStart(textpage, world_caps.get(),
FPDF_MATCHCASE, 0));
385 EXPECT_FALSE(FPDFText_FindNext(search.get()));
386 EXPECT_EQ(0, FPDFText_GetSchResultIndex(search.get()));
387 EXPECT_EQ(0, FPDFText_GetSchCount(search.get()));
392 ScopedFPDFTextFind search(
393 FPDFText_FindStart(textpage, world_substr.get(), 0, 0));
394 EXPECT_TRUE(FPDFText_FindNext(search.get()));
395 EXPECT_EQ(8, FPDFText_GetSchResultIndex(search.get()));
396 EXPECT_EQ(4, FPDFText_GetSchCount(search.get()));
401 ScopedFPDFTextFind search(FPDFText_FindStart(textpage, world_substr.get(),
403 EXPECT_FALSE(FPDFText_FindNext(search.get()));
412 ASSERT_TRUE(OpenDocument(
"find_text_consecutive.pdf"));
413 FPDF_PAGE page = LoadPage(0);
417 ASSERT_TRUE(textpage);
419 ScopedFPDFWideString aaaa = GetFPDFWideString(L"aaaa");
423 ScopedFPDFTextFind search(FPDFText_FindStart(textpage, aaaa.get(), 0, 0));
427 EXPECT_EQ(0, FPDFText_GetSchResultIndex(search.get()));
428 EXPECT_EQ(0, FPDFText_GetSchCount(search.get()));
431 EXPECT_TRUE(FPDFText_FindNext(search.get()));
432 EXPECT_EQ(0, FPDFText_GetSchResultIndex(search.get()));
433 EXPECT_EQ(4, FPDFText_GetSchCount(search.get()));
436 EXPECT_TRUE(FPDFText_FindNext(search.get()));
437 EXPECT_EQ(4, FPDFText_GetSchResultIndex(search.get()));
438 EXPECT_EQ(4, FPDFText_GetSchCount(search.get()));
441 EXPECT_FALSE(FPDFText_FindNext(search.get()));
442 EXPECT_EQ(4, FPDFText_GetSchResultIndex(search.get()));
443 EXPECT_EQ(4, FPDFText_GetSchCount(search.get()));
446 EXPECT_TRUE(FPDFText_FindPrev(search.get()));
447 EXPECT_EQ(0, FPDFText_GetSchResultIndex(search.get()));
448 EXPECT_EQ(4, FPDFText_GetSchCount(search.get()));
451 EXPECT_FALSE(FPDFText_FindPrev(search.get()));
452 EXPECT_EQ(0, FPDFText_GetSchResultIndex(search.get()));
453 EXPECT_EQ(4, FPDFText_GetSchCount(search.get()));
459 ScopedFPDFTextFind search(
464 EXPECT_EQ(0, FPDFText_GetSchResultIndex(search.get()));
465 EXPECT_EQ(0, FPDFText_GetSchCount(search.get()));
468 for (
int i = 0; i < 7; ++i) {
469 EXPECT_TRUE(FPDFText_FindNext(search.get()));
470 EXPECT_EQ(i, FPDFText_GetSchResultIndex(search.get()));
471 EXPECT_EQ(4, FPDFText_GetSchCount(search.get()));
475 EXPECT_FALSE(FPDFText_FindNext(search.get()));
476 EXPECT_EQ(6, FPDFText_GetSchResultIndex(search.get()));
477 EXPECT_EQ(4, FPDFText_GetSchCount(search.get()));
479 for (
int i = 5; i >= 0; --i) {
480 EXPECT_TRUE(FPDFText_FindPrev(search.get()));
481 EXPECT_EQ(i, FPDFText_GetSchResultIndex(search.get()));
482 EXPECT_EQ(4, FPDFText_GetSchCount(search.get()));
486 EXPECT_FALSE(FPDFText_FindPrev(search.get()));
487 EXPECT_EQ(0, FPDFText_GetSchResultIndex(search.get()));
488 EXPECT_EQ(4, FPDFText_GetSchCount(search.get()));
496 ASSERT_TRUE(OpenDocument(
"hello_world.pdf"));
497 FPDF_PAGE page = LoadPage(0);
501 ScopedFPDFTextPage textpage(FPDFText_LoadPage(page));
502 ASSERT_TRUE(textpage);
504 ScopedFPDFWideString search_term = GetFPDFWideString(L"world!");
505 ScopedFPDFTextFind search(
506 FPDFText_FindStart(textpage.get(), search_term.get(), 0, 0));
508 EXPECT_EQ(0, FPDFText_GetSchResultIndex(search.get()));
509 EXPECT_EQ(0, FPDFText_GetSchCount(search.get()));
511 EXPECT_TRUE(FPDFText_FindNext(search.get()));
512 EXPECT_EQ(7, FPDFText_GetSchResultIndex(search.get()));
513 EXPECT_EQ(6, FPDFText_GetSchCount(search.get()));
515 EXPECT_TRUE(FPDFText_FindNext(search.get()));
516 EXPECT_EQ(24, FPDFText_GetSchResultIndex(search.get()));
517 EXPECT_EQ(6, FPDFText_GetSchCount(search.get()));
524 ASSERT_TRUE(OpenDocument(
"hello_world.pdf"));
525 FPDF_PAGE page = LoadPage(0);
529 ScopedFPDFTextPage textpage(FPDFText_LoadPage(page));
530 ASSERT_TRUE(textpage);
532 ScopedFPDFWideString search_term = GetFPDFWideString(L" Good");
533 ScopedFPDFTextFind search(
534 FPDFText_FindStart(textpage.get(), search_term.get(), 0, 0));
536 EXPECT_EQ(0, FPDFText_GetSchResultIndex(search.get()));
537 EXPECT_EQ(0, FPDFText_GetSchCount(search.get()));
539 EXPECT_TRUE(FPDFText_FindNext(search.get()));
540 EXPECT_EQ(14, FPDFText_GetSchResultIndex(search.get()));
541 EXPECT_EQ(5, FPDFText_GetSchCount(search.get()));
543 EXPECT_FALSE(FPDFText_FindNext(search.get()));
550 ASSERT_TRUE(OpenDocument(
"hello_world.pdf"));
551 FPDF_PAGE page = LoadPage(0);
555 ScopedFPDFTextPage textpage(FPDFText_LoadPage(page));
556 ASSERT_TRUE(textpage);
558 ScopedFPDFWideString search_term = GetFPDFWideString(L"ld! ");
559 ScopedFPDFTextFind search(
560 FPDFText_FindStart(textpage.get(), search_term.get(), 0, 0));
562 EXPECT_EQ(0, FPDFText_GetSchResultIndex(search.get()));
563 EXPECT_EQ(0, FPDFText_GetSchCount(search.get()));
565 EXPECT_TRUE(FPDFText_FindNext(search.get()));
566 EXPECT_EQ(10, FPDFText_GetSchResultIndex(search.get()));
567 EXPECT_EQ(4, FPDFText_GetSchCount(search.get()));
569 EXPECT_FALSE(FPDFText_FindNext(search.get()));
576 ASSERT_TRUE(OpenDocument(
"hello_world.pdf"));
577 FPDF_PAGE page = LoadPage(0);
581 ScopedFPDFTextPage textpage(FPDFText_LoadPage(page));
582 ASSERT_TRUE(textpage);
584 ScopedFPDFWideString search_term = GetFPDFWideString(L"ld! G");
585 ScopedFPDFTextFind search(
586 FPDFText_FindStart(textpage.get(), search_term.get(), 0, 0));
588 EXPECT_EQ(0, FPDFText_GetSchResultIndex(search.get()));
589 EXPECT_EQ(0, FPDFText_GetSchCount(search.get()));
591 EXPECT_TRUE(FPDFText_FindNext(search.get()));
592 EXPECT_EQ(10, FPDFText_GetSchResultIndex(search.get()));
596 EXPECT_EQ(6, FPDFText_GetSchCount(search.get()));
598 EXPECT_FALSE(FPDFText_FindNext(search.get()));
606#define MAYBE_TextSearchLatinExtended DISABLED_TextSearchLatinExtended
608#define MAYBE_TextSearchLatinExtended TextSearchLatinExtended
611 ASSERT_TRUE(OpenDocument(
"latin_extended.pdf"));
612 FPDF_PAGE page = LoadPage(0);
616 ASSERT_TRUE(textpage);
619 constexpr FPDF_WCHAR kNeedleUpper[] = {0x0102, 0x0000};
620 constexpr FPDF_WCHAR kNeedleLower[] = {0x0103, 0x0000};
622 for (
const auto* needle : {kNeedleUpper, kNeedleLower}) {
623 ScopedFPDFTextFind search(FPDFText_FindStart(textpage, needle, 0, 0));
625 EXPECT_EQ(0, FPDFText_GetSchResultIndex(search.get()));
626 EXPECT_EQ(0, FPDFText_GetSchCount(search.get()));
629 EXPECT_TRUE(FPDFText_FindNext(search.get()));
630 EXPECT_EQ(2, FPDFText_GetSchResultIndex(search.get()));
631 EXPECT_EQ(1, FPDFText_GetSchCount(search.get()));
632 EXPECT_TRUE(FPDFText_FindNext(search.get()));
633 EXPECT_EQ(3, FPDFText_GetSchResultIndex(search.get()));
634 EXPECT_EQ(1, FPDFText_GetSchCount(search.get()));
636 EXPECT_FALSE(FPDFText_FindNext(search.get()));
645 ASSERT_TRUE(OpenDocument(
"bug_57.pdf"));
646 FPDF_PAGE page = LoadPage(0);
650 ASSERT_TRUE(textpage);
658 ASSERT_TRUE(OpenDocument(
"weblinks.pdf"));
659 FPDF_PAGE page = LoadPage(0);
663 ASSERT_TRUE(textpage);
666 ScopedFPDFPageLink pagelink(FPDFLink_LoadWebLinks(textpage));
667 EXPECT_TRUE(pagelink);
670 EXPECT_EQ(2, FPDFLink_CountWebLinks(pagelink.get()));
673 EXPECT_EQ(1, FPDFLink_GetURL(pagelink.get(), 2,
nullptr, 0));
674 EXPECT_EQ(1, FPDFLink_GetURL(pagelink.get(), 1400,
nullptr, 0));
675 EXPECT_EQ(1, FPDFLink_GetURL(pagelink.get(), -1,
nullptr, 0));
679 EXPECT_TRUE(pagelink);
685 static const char expected_url[] =
"http://example.com?q=foo";
686 static const size_t expected_len =
sizeof(expected_url);
687 unsigned short buffer[128];
692 memset(buffer, 0xbd,
sizeof(buffer));
694 EXPECT_TRUE(check_unsigned_shorts(expected_url, buffer, 1));
695 EXPECT_EQ(0xbdbd, buffer[1]);
698 memset(buffer, 0xbd,
sizeof(buffer));
699 EXPECT_EQ(
static_cast<
int>(expected_len - 1),
700 FPDFLink_GetURL(pagelink, 0, buffer, expected_len - 1));
701 EXPECT_TRUE(check_unsigned_shorts(expected_url, buffer, expected_len - 1));
702 EXPECT_EQ(0xbdbd, buffer[expected_len - 1]);
705 memset(buffer, 0xbd,
sizeof(buffer));
706 EXPECT_EQ(
static_cast<
int>(expected_len),
707 FPDFLink_GetURL(pagelink, 0, buffer, expected_len));
708 EXPECT_TRUE(check_unsigned_shorts(expected_url, buffer, expected_len));
709 EXPECT_EQ(0u, buffer[expected_len - 1]);
710 EXPECT_EQ(0xbdbd, buffer[expected_len]);
713 memset(buffer, 0xbd,
sizeof(buffer));
714 EXPECT_EQ(
static_cast<
int>(expected_len),
716 EXPECT_TRUE(check_unsigned_shorts(expected_url, buffer, expected_len));
717 EXPECT_EQ(0u, buffer[expected_len - 1]);
718 EXPECT_EQ(0xbdbd, buffer[expected_len]);
735 EXPECT_NEAR(50.828, left, 0.001);
736 EXPECT_NEAR(187.904, right, 0.001);
737 EXPECT_NEAR(97.516, bottom, 0.001);
738 EXPECT_NEAR(108.700, top, 0.001);
746 EXPECT_EQ(-1.0, left);
747 EXPECT_EQ(-1.0, right);
748 EXPECT_EQ(-1.0, bottom);
749 EXPECT_EQ(-1.0, top);
757 EXPECT_EQ(-2.0, left);
758 EXPECT_EQ(-2.0, right);
759 EXPECT_EQ(-2.0, bottom);
760 EXPECT_EQ(-2.0, top);
768 ASSERT_TRUE(OpenDocument(
"weblinks_across_lines.pdf"));
769 FPDF_PAGE page = LoadPage(0);
773 ASSERT_TRUE(textpage);
776 EXPECT_TRUE(pagelink);
778 static const char*
const kExpectedUrls[] = {
779 "http://example.com",
780 "http://example.com/",
781 "http://example.com/test-foo",
782 "http://abc.com/test-foo",
784 "http://example.com/",
785 "http://www.abc.com",
787 static const int kNumLinks =
static_cast<
int>(
std::size(kExpectedUrls));
791 unsigned short buffer[128];
792 for (
int i = 0; i < kNumLinks; i++) {
793 const size_t expected_len = strlen(kExpectedUrls[i]) + 1;
794 memset(buffer, 0,
sizeof(buffer));
795 EXPECT_EQ(
static_cast<
int>(expected_len),
797 EXPECT_EQ(
static_cast<
int>(expected_len),
798 FPDFLink_GetURL(pagelink, i, buffer,
std::size(buffer)));
799 EXPECT_TRUE(check_unsigned_shorts(kExpectedUrls[i], buffer, expected_len));
808 ASSERT_TRUE(OpenDocument(
"bug_650.pdf"));
809 FPDF_PAGE page = LoadPage(0);
813 ASSERT_TRUE(textpage);
816 EXPECT_TRUE(pagelink);
819 unsigned short buffer[128] = {0};
820 static const char kExpectedUrl[] =
821 "http://tutorial45.com/learn-autocad-basics-day-166/";
822 static const int kUrlSize =
static_cast<
int>(
sizeof(kExpectedUrl));
825 EXPECT_EQ(kUrlSize, FPDFLink_GetURL(pagelink, 1, buffer,
std::size(buffer)));
826 EXPECT_TRUE(check_unsigned_shorts(kExpectedUrl, buffer, kUrlSize));
834 ASSERT_TRUE(OpenDocument(
"weblinks.pdf"));
835 FPDF_PAGE page = LoadPage(0);
839 ASSERT_TRUE(text_page);
842 EXPECT_TRUE(page_link);
845 int start_char_index;
849 EXPECT_EQ(35, start_char_index);
850 EXPECT_EQ(24, char_count);
853 start_char_index = -10;
857 EXPECT_EQ(start_char_index, -10);
858 EXPECT_EQ(char_count, -8);
861 start_char_index = -10;
865 EXPECT_EQ(start_char_index, -10);
866 EXPECT_EQ(char_count, -8);
869 start_char_index = -10;
873 EXPECT_EQ(start_char_index, -10);
874 EXPECT_EQ(char_count, -8);
882 ASSERT_TRUE(OpenDocument(
"annots.pdf"));
883 FPDF_PAGE page = LoadPage(0);
888 ASSERT_EQ(9, annot_count);
889 int annot_subtype_link_count = 0;
890 for (
int i = 0; i < annot_count; ++i) {
891 ScopedFPDFAnnotation annot(FPDFPage_GetAnnot(page, i));
893 ++annot_subtype_link_count;
896 EXPECT_EQ(4, annot_subtype_link_count);
900 FPDF_LINK link_annot;
903 ASSERT_TRUE(link_annot);
904 if (start_pos == 1 || start_pos == 2) {
907 FPDF_DEST link_dest = FPDFLink_GetDest(document(), link_annot);
908 EXPECT_TRUE(link_dest);
909 EXPECT_EQ(start_pos - 1,
910 FPDFDest_GetDestPageIndex(document(), link_dest));
911 }
else if (start_pos == 3) {
914 EXPECT_NEAR(66.0, link_rect.left, 0.001);
915 EXPECT_NEAR(544.0, link_rect.top, 0.001);
916 EXPECT_NEAR(196.0, link_rect.right, 0.001);
917 EXPECT_NEAR(529.0, link_rect.bottom, 0.001);
918 }
else if (start_pos == 4) {
920 EXPECT_EQ(1, quad_point_count);
921 FS_QUADPOINTSF quad_points;
923 EXPECT_NEAR(83.0, quad_points.x1, 0.001);
924 EXPECT_NEAR(453.0, quad_points.y1, 0.001);
925 EXPECT_NEAR(178.0, quad_points.x2, 0.001);
926 EXPECT_NEAR(453.0, quad_points.y2, 0.001);
927 EXPECT_NEAR(83.0, quad_points.x3, 0.001);
928 EXPECT_NEAR(440.0, quad_points.y3, 0.001);
929 EXPECT_NEAR(178.0, quad_points.x4, 0.001);
930 EXPECT_NEAR(440.0, quad_points.y4, 0.001);
934 EXPECT_NEAR(link_rect.left, quad_points.x1, 0.001);
935 EXPECT_NEAR(link_rect.top, quad_points.y1, 0.001);
936 EXPECT_NEAR(link_rect.right, quad_points.x4, 0.001);
937 EXPECT_NEAR(link_rect.bottom, quad_points.y4, 0.001);
941 EXPECT_EQ(annot_subtype_link_count, link_count);
947 ASSERT_TRUE(OpenDocument(
"hello_world.pdf"));
948 FPDF_PAGE page = LoadPage(0);
952 ASSERT_TRUE(textpage);
954 const double kExpectedFontsSizes[] = {12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
955 12, 12, 12, 1, 1, 16, 16, 16, 16, 16,
956 16, 16, 16, 16, 16, 16, 16, 16, 16, 16};
959 ASSERT_EQ(
std::size(kExpectedFontsSizes),
static_cast<size_t>(count));
960 for (
int i = 0; i < count; ++i)
968 ASSERT_TRUE(OpenDocument(
"hello_world.pdf"));
969 FPDF_PAGE page = LoadPage(0);
973 ASSERT_TRUE(textpage);
974 std::vector<
char> font_name;
975 size_t num_chars1 = strlen(
"Hello, world!");
976 const char kExpectedFontName1[] =
"Times-Roman";
978 for (size_t i = 0; i < num_chars1; i++) {
980 unsigned long length =
981 FPDFText_GetFontInfo(textpage, i,
nullptr, 0, &flags);
982 static constexpr unsigned long expected_length =
sizeof(kExpectedFontName1);
983 ASSERT_EQ(expected_length, length);
985 font_name.resize(length);
986 std::fill(font_name.begin(), font_name.end(),
'a');
988 EXPECT_EQ(expected_length,
989 FPDFText_GetFontInfo(textpage, i, font_name.data(),
990 font_name.size(), &flags));
991 EXPECT_STREQ(kExpectedFontName1, font_name.data());
996 font_name.pop_back();
997 std::fill(font_name.begin(), font_name.end(),
'a');
998 EXPECT_EQ(
sizeof(kExpectedFontName1),
999 FPDFText_GetFontInfo(textpage, 0, font_name.data(),
1000 font_name.size(),
nullptr));
1001 for (
char a : font_name)
1006 EXPECT_EQ(0u, FPDFText_GetFontInfo(textpage, num_chars1, font_name.data(),
1007 font_name.size(),
nullptr));
1008 EXPECT_EQ(0u, FPDFText_GetFontInfo(textpage, num_chars1 + 1, font_name.data(),
1009 font_name.size(),
nullptr));
1011 size_t num_chars2 = strlen(
"Goodbye, world!");
1012 const char kExpectedFontName2[] =
"Helvetica";
1013 for (size_t i = num_chars1 + 2; i < num_chars1 + num_chars2 + 2; i++) {
1015 unsigned long length =
1016 FPDFText_GetFontInfo(textpage, i,
nullptr, 0, &flags);
1017 static constexpr unsigned long expected_length =
sizeof(kExpectedFontName2);
1018 ASSERT_EQ(expected_length, length);
1020 font_name.resize(length);
1021 std::fill(font_name.begin(), font_name.end(),
'a');
1023 EXPECT_EQ(expected_length,
1024 FPDFText_GetFontInfo(textpage, i, font_name.data(),
1025 font_name.size(), &flags));
1026 EXPECT_STREQ(kExpectedFontName2, font_name.data());
1033 EXPECT_EQ(0u, FPDFText_GetFontInfo(
nullptr, 0, font_name.data(),
1034 font_name.size(),
nullptr));
1036 EXPECT_EQ(
sizeof(kExpectedFontName1),
1039 EXPECT_EQ(0u, FPDFText_GetFontInfo(textpage, -1, font_name.data(),
1040 font_name.size(),
nullptr));
1042 EXPECT_EQ(0u, FPDFText_GetFontInfo(textpage, 1000, font_name.data(),
1043 font_name.size(),
nullptr));
1050 ASSERT_TRUE(OpenDocument(
"bug_583.pdf"));
1051 FPDF_PAGE page = LoadPage(0);
1055 ASSERT_TRUE(textpage);
1065 ASSERT_TRUE(OpenDocument(
"hello_world.pdf"));
1066 FPDF_PAGE page = LoadPage(0);
1070 ScopedFPDFTextPage textpage(FPDFText_LoadPage(page));
1071 ASSERT_TRUE(textpage);
1073 EXPECT_EQ(
static_cast<
unsigned int>(
'H'),
1074 FPDFText_GetUnicode(textpage.get(), 0));
1075 EXPECT_EQ(0, FPDFText_IsGenerated(textpage.get(), 0));
1076 EXPECT_EQ(
static_cast<
unsigned int>(
' '),
1077 FPDFText_GetUnicode(textpage.get(), 6));
1078 EXPECT_EQ(0, FPDFText_IsGenerated(textpage.get(), 6));
1080 EXPECT_EQ(
static_cast<
unsigned int>(
'\r'),
1081 FPDFText_GetUnicode(textpage.get(), 13));
1082 EXPECT_EQ(1, FPDFText_IsGenerated(textpage.get(), 13));
1083 EXPECT_EQ(
static_cast<
unsigned int>(
'\n'),
1084 FPDFText_GetUnicode(textpage.get(), 14));
1085 EXPECT_EQ(1, FPDFText_IsGenerated(textpage.get(), 14));
1087 EXPECT_EQ(-1, FPDFText_IsGenerated(textpage.get(), -1));
1088 EXPECT_EQ(-1, FPDFText_IsGenerated(textpage.get(), kHelloGoodbyeTextSize));
1096 ASSERT_TRUE(OpenDocument(
"bug_781804.pdf"));
1097 FPDF_PAGE page = LoadPage(0);
1101 ScopedFPDFTextPage textpage(FPDFText_LoadPage(page));
1102 ASSERT_TRUE(textpage);
1104 EXPECT_EQ(
static_cast<
unsigned int>(
'V'),
1105 FPDFText_GetUnicode(textpage.get(), 0));
1106 EXPECT_EQ(0, FPDFText_IsHyphen(textpage.get(), 0));
1107 EXPECT_EQ(
static_cast<
unsigned int>(
'\2'),
1108 FPDFText_GetUnicode(textpage.get(), 6));
1109 EXPECT_EQ(1, FPDFText_IsHyphen(textpage.get(), 6));
1111 EXPECT_EQ(
static_cast<
unsigned int>(
'U'),
1112 FPDFText_GetUnicode(textpage.get(), 14));
1113 EXPECT_EQ(0, FPDFText_IsHyphen(textpage.get(), 14));
1114 EXPECT_EQ(
static_cast<
unsigned int>(L'\u2010'),
1115 FPDFText_GetUnicode(textpage.get(), 18));
1116 EXPECT_EQ(0, FPDFText_IsHyphen(textpage.get(), 18));
1118 EXPECT_EQ(-1, FPDFText_IsHyphen(textpage.get(), -1));
1119 EXPECT_EQ(-1, FPDFText_IsHyphen(textpage.get(), 1000));
1127 ASSERT_TRUE(OpenDocument(
"bug_1388_2.pdf"));
1128 FPDF_PAGE page = LoadPage(0);
1132 constexpr int kExpectedCharCount = 5;
1133 ScopedFPDFTextPage textpage(FPDFText_LoadPage(page));
1134 ASSERT_TRUE(textpage);
1135 EXPECT_EQ(kExpectedCharCount, FPDFText_CountChars(textpage.get()));
1137 EXPECT_EQ(
static_cast<
unsigned int>(
'X'),
1138 FPDFText_GetUnicode(textpage.get(), 0));
1139 EXPECT_EQ(0, FPDFText_HasUnicodeMapError(textpage.get(), 0));
1140 EXPECT_EQ(
static_cast<
unsigned int>(
' '),
1141 FPDFText_GetUnicode(textpage.get(), 1));
1142 EXPECT_EQ(0, FPDFText_HasUnicodeMapError(textpage.get(), 1));
1144 EXPECT_EQ(31u, FPDFText_GetUnicode(textpage.get(), 2));
1145 EXPECT_EQ(1, FPDFText_HasUnicodeMapError(textpage.get(), 2));
1147 EXPECT_EQ(-1, FPDFText_HasUnicodeMapError(textpage.get(), -1));
1149 FPDFText_HasUnicodeMapError(textpage.get(), kExpectedCharCount));
1157 ASSERT_TRUE(OpenDocument(
"bug_921.pdf"));
1158 FPDF_PAGE page = LoadPage(0);
1162 ASSERT_TRUE(textpage);
1164 static constexpr unsigned int kData[] = {
1165 1095, 1077, 1083, 1086, 1074, 1077, 1095, 1077, 1089, 1082, 1086, 1077,
1166 32, 1089, 1090, 1088, 1072, 1076, 1072, 1085, 1080, 1077, 46, 32};
1167 static constexpr int kStartIndex = 238;
1170 for (size_t i = 0; i <
std::size(kData); ++i)
1171 EXPECT_EQ(kData[i], FPDFText_GetUnicode(textpage, kStartIndex + i));
1173 unsigned short buffer[
std::size(kData) + 1];
1174 memset(buffer, 0xbd,
sizeof(buffer));
1175 int count = FPDFText_GetText(textpage, kStartIndex,
std::size(kData), buffer);
1176 ASSERT_GT(count, 0);
1177 ASSERT_EQ(
std::size(kData) + 1,
static_cast<size_t>(count));
1178 for (size_t i = 0; i <
std::size(kData); ++i)
1179 EXPECT_EQ(kData[i], buffer[i]);
1180 EXPECT_EQ(0, buffer[
std::size(kData)]);
1187 ASSERT_TRUE(OpenDocument(
"bug_781804.pdf"));
1188 FPDF_PAGE page = LoadPage(0);
1192 ASSERT_TRUE(textpage);
1198 constexpr unsigned short soft_expected[] = {
1199 0x0056, 0x0065, 0x0072, 0x0069, 0x0074, 0x0061, 0xfffe,
1200 0x0073, 0x0065, 0x0072, 0x0075, 0x006D, 0x0000};
1202 constexpr int count =
std::size(soft_expected) - 1;
1203 unsigned short buffer[
std::size(soft_expected)];
1204 memset(buffer, 0,
sizeof(buffer));
1206 EXPECT_EQ(count + 1, FPDFText_GetText(textpage, 0, count, buffer));
1207 for (
int i = 0; i < count; i++)
1208 EXPECT_EQ(soft_expected[i], buffer[i]);
1215 constexpr size_t offset = std::size(soft_expected) + 1;
1218 constexpr unsigned short hard_expected[] = {
1219 0x0055, 0x0073, 0x0065, 0x0072, 0x2010, 0x000d, 0x000a, 0x0067, 0x0065,
1220 0x006e, 0x0065, 0x0072, 0x0061, 0x0074, 0x0065, 0x0064, 0x0000};
1221 constexpr int count =
std::size(hard_expected) - 1;
1222 unsigned short buffer[
std::size(hard_expected)];
1224 EXPECT_EQ(count + 1, FPDFText_GetText(textpage, offset, count, buffer));
1225 for (
int i = 0; i < count; i++)
1226 EXPECT_EQ(hard_expected[i], buffer[i]);
1235 ASSERT_TRUE(OpenDocument(
"bug_782596.pdf"));
1236 FPDF_PAGE page = LoadPage(0);
1239 ASSERT_TRUE(textpage);
1245 ASSERT_TRUE(OpenDocument(
"control_characters.pdf"));
1246 FPDF_PAGE page = LoadPage(0);
1250 ASSERT_TRUE(textpage);
1253 unsigned short buffer[128];
1254 memset(buffer, 0xbd,
sizeof(buffer));
1256 ASSERT_EQ(kHelloGoodbyeTextSize, num_chars);
1258 check_unsigned_shorts(kHelloGoodbyeText, buffer, kHelloGoodbyeTextSize));
1261 static const char expected_substring[] =
"Goodbye, world!";
1264 static const int offset = 17;
1265 memset(buffer, 0xbd,
sizeof(buffer));
1268 ASSERT_GE(num_chars, 0);
1269 EXPECT_EQ(
sizeof(expected_substring),
static_cast<size_t>(num_chars));
1270 EXPECT_TRUE(check_unsigned_shorts(expected_substring, buffer,
1271 sizeof(expected_substring)));
1280 ASSERT_TRUE(OpenDocument(
"bug_1029.pdf"));
1281 FPDF_PAGE page = LoadPage(0);
1285 ASSERT_TRUE(textpage);
1287 constexpr int page_range_offset = 171;
1288 constexpr int page_range_length = 56;
1296 constexpr unsigned int expected[] = {
1297 0x004d, 0x0045, 0x0054, 0x0041, 0x0044, 0x0041, 0x0054, 0x0041,
1298 0x0020, 0x0074, 0x0061, 0x0062, 0x006c, 0x0065, 0x002e, 0x0020,
1299 0x0057, 0x0068, 0x0065, 0x006e, 0x0020, 0x0074, 0x0068, 0x0065,
1300 0x0020, 0x0073, 0x0070, 0x006c, 0x0069, 0x0074, 0x0020, 0x0068,
1301 0x0061, 0x0073, 0x0020, 0x0063, 0x006f, 0x006d, 0x006d, 0x0069,
1302 0x0074, 0x0074, 0x0065, 0x0064, 0x002c, 0x0020, 0x0069, 0x0074,
1303 0x0020, 0x006e, 0x006f, 0x0074, 0x0069, 0x0002, 0x0066, 0x0069};
1304 static_assert(page_range_length ==
std::size(expected),
1305 "Expected should be the same size as the range being "
1306 "extracted from page.");
1307 EXPECT_LT(page_range_offset + page_range_length,
1310 for (
int i = 0; i < page_range_length; ++i) {
1311 EXPECT_EQ(expected[i],
1320 ASSERT_TRUE(OpenDocument(
"hello_world.pdf"));
1321 FPDF_PAGE page = LoadPage(0);
1325 ASSERT_TRUE(textpage);
1330 unsigned short buffer[128];
1332 ASSERT_EQ(kHelloGoodbyeTextSize, num_chars);
1333 EXPECT_TRUE(check_unsigned_shorts(kHelloGoodbyeText, buffer,
1334 kHelloGoodbyeTextSize));
1338 static const int kHelloWorldEnd = strlen(
"Hello, world!");
1339 static const int kGoodbyeWorldStart = kHelloWorldEnd + 2;
1340 for (
int start = 0; start < kHelloWorldEnd; ++start) {
1353 int expected_value = start ? 2 : 1;
1354 EXPECT_EQ(expected_value,
1363 for (
int start = 0; start < kHelloWorldEnd; ++start) {
1369 const int kExpectedLength = strlen(kHelloGoodbyeText);
1370 for (
int start = kGoodbyeWorldStart + 1; start < kExpectedLength; ++start) {
1379 for (
int start = kExpectedLength; start < 100; ++start) {
1392 ASSERT_TRUE(OpenDocument(
"hello_world.pdf"));
1393 FPDF_PAGE page = LoadPage(0);
1397 ASSERT_TRUE(text_page);
1401 ASSERT_TRUE(text_object);
1404 constexpr char kHelloText[] =
"Hello, world!";
1406 constexpr unsigned long kHelloUTF16Size =
std::size(kHelloText) * 2;
1407 constexpr wchar_t kHelloWideText[] = L"Hello, world!";
1409 ASSERT_EQ(kHelloUTF16Size, size);
1411 std::vector<
unsigned short> buffer(size);
1413 FPDFTextObj_GetText(text_object, text_page, buffer.data(), size));
1414 ASSERT_EQ(kHelloWideText, GetPlatformWString(buffer.data()));
1426 FPDFTextObj_GetText(text_object, text_page, buffer.data(), buffer.size());
1427 ASSERT_EQ(kHelloUTF16Size, size);
1428 ASSERT_EQ(
'x', buffer[0]);
1429 ASSERT_EQ(
'\0', buffer[1]);
1436 static constexpr int kPageCount = 4;
1437 static constexpr FS_RECTF kBoxes[kPageCount] = {
1438 {50.0f, 150.0f, 150.0f, 50.0f},
1439 {50.0f, 150.0f, 150.0f, 50.0f},
1440 {60.0f, 150.0f, 150.0f, 60.0f},
1441 {60.0f, 150.0f, 150.0f, 60.0f},
1443 static constexpr const char* kExpectedText[kPageCount] = {
1444 " world!\r\ndbye, world!",
1445 " world!\r\ndbye, world!",
1450 ASSERT_TRUE(OpenDocument(
"cropped_text.pdf"));
1451 ASSERT_EQ(kPageCount, FPDF_GetPageCount(document()));
1453 for (
int i = 0; i < kPageCount; ++i) {
1454 FPDF_PAGE page = LoadPage(i);
1459 EXPECT_EQ(kBoxes[i].left, box.left);
1460 EXPECT_EQ(kBoxes[i].top, box.top);
1461 EXPECT_EQ(kBoxes[i].right, box.right);
1462 EXPECT_EQ(kBoxes[i].bottom, box.bottom);
1465 ScopedFPDFTextPage textpage(FPDFText_LoadPage(page));
1466 ASSERT_TRUE(textpage);
1468 unsigned short buffer[128];
1469 memset(buffer, 0xbd,
sizeof(buffer));
1470 int num_chars = FPDFText_GetText(textpage.get(), 0, 128, buffer);
1471 ASSERT_EQ(kHelloGoodbyeTextSize, num_chars);
1472 EXPECT_TRUE(check_unsigned_shorts(kHelloGoodbyeText, buffer,
1473 kHelloGoodbyeTextSize));
1475 int expected_char_count = strlen(kExpectedText[i]);
1476 ASSERT_EQ(expected_char_count,
1477 FPDFText_GetBoundedText(textpage.get(), box.left, box.top,
1478 box.right, box.bottom,
nullptr, 0));
1480 memset(buffer, 0xbd,
sizeof(buffer));
1481 ASSERT_EQ(expected_char_count + 1,
1482 FPDFText_GetBoundedText(textpage.get(), box.left, box.top,
1483 box.right, box.bottom, buffer, 128));
1485 check_unsigned_shorts(kExpectedText[i], buffer, expected_char_count));
1493 ASSERT_TRUE(OpenDocument(
"bug_1139.pdf"));
1494 FPDF_PAGE page = LoadPage(0);
1498 ASSERT_TRUE(text_page);
1506 unsigned short buffer[128];
1508 ASSERT_EQ(kHelloGoodbyeTextSize, num_chars);
1510 check_unsigned_shorts(kHelloGoodbyeText, buffer, kHelloGoodbyeTextSize));
1516 ASSERT_TRUE(OpenDocument(
"bug_642.pdf"));
1517 FPDF_PAGE page = LoadPage(0);
1520 ScopedFPDFTextPage text_page(FPDFText_LoadPage(page));
1521 ASSERT_TRUE(text_page);
1523 constexpr char kText[] =
"ABCD";
1524 constexpr size_t kTextSize = std::size(kText);
1526 EXPECT_EQ(
static_cast<
int>(kTextSize) - 1,
1527 FPDFText_CountChars(text_page.get()));
1529 unsigned short buffer[kTextSize];
1531 FPDFText_GetText(text_page.get(), 0,
std::size(buffer) - 1, buffer);
1532 ASSERT_EQ(
static_cast<
int>(kTextSize), num_chars);
1533 EXPECT_TRUE(check_unsigned_shorts(kText, buffer, kTextSize));
1540 ASSERT_TRUE(OpenDocument(
"rotated_text.pdf"));
1541 FPDF_PAGE page = LoadPage(0);
1545 ASSERT_TRUE(text_page);
1547 static constexpr int kSubstringsSize[] = {
1548 std::size(
"Hello,"),
std::size(
" world!\r\n"),
std::size(
"Goodbye,")};
1556 EXPECT_FLOAT_EQ(-1.0f,
1562 FPDFText_GetCharAngle(text_page, kSubstringsSize[0]), 0.001);
1565 FPDFText_GetCharAngle(text_page, kSubstringsSize[0] + kSubstringsSize[1]),
1569 FPDFText_GetCharAngle(text_page, kSubstringsSize[0] + kSubstringsSize[1] +
1570 kSubstringsSize[2]),
1578 ASSERT_TRUE(OpenDocument(
"font_weight.pdf"));
1579 FPDF_PAGE page = LoadPage(0);
1583 ASSERT_TRUE(text_page);
1605 ASSERT_TRUE(OpenDocument(
"text_render_mode.pdf"));
1606 FPDF_PAGE page = LoadPage(0);
1610 ASSERT_TRUE(text_page);
1614 ASSERT_EQ(FPDF_TEXTRENDERMODE_UNKNOWN,
1616 ASSERT_EQ(FPDF_TEXTRENDERMODE_UNKNOWN,
1618 ASSERT_EQ(FPDF_TEXTRENDERMODE_UNKNOWN,
1623 ASSERT_EQ(FPDF_TEXTRENDERMODE_STROKE,
1631 ASSERT_TRUE(OpenDocument(
"text_color.pdf"));
1632 FPDF_PAGE page = LoadPage(0);
1636 ASSERT_TRUE(text_page);
1654 ASSERT_EQ(0xffu, r);
1657 ASSERT_EQ(0xffu, a);
1664 ASSERT_TRUE(OpenDocument(
"text_color.pdf"));
1665 FPDF_PAGE page = LoadPage(0);
1669 ASSERT_TRUE(text_page);
1688 ASSERT_EQ(0xffu, g);
1690 ASSERT_EQ(0xffu, a);
1697 constexpr char kExpectedText[] =
"A1\r\nA2\r\nA3";
1698 constexpr size_t kExpectedTextSize = std::size(kExpectedText);
1699 constexpr FS_MATRIX kExpectedMatrices[] = {
1700 {12.0f, 0.0f, 0.0f, 10.0f, 66.0f, 90.0f},
1701 {12.0f, 0.0f, 0.0f, 10.0f, 66.0f, 90.0f},
1702 {1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f},
1703 {1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f},
1704 {12.0f, 0.0f, 0.0f, 10.0f, 38.0f, 60.0f},
1705 {12.0f, 0.0f, 0.0f, 10.0f, 38.0f, 60.0f},
1706 {1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f},
1707 {1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f},
1708 {1.0f, 0.0f, 0.0f, 0.833333, 60.0f, 130.0f},
1709 {1.0f, 0.0f, 0.0f, 0.833333, 60.0f, 130.0f},
1711 constexpr size_t kExpectedCount = std::size(kExpectedMatrices);
1712 static_assert(kExpectedCount + 1 == kExpectedTextSize,
1713 "Bad expected matrix size");
1715 ASSERT_TRUE(OpenDocument(
"font_matrix.pdf"));
1716 FPDF_PAGE page = LoadPage(0);
1720 ScopedFPDFTextPage text_page(FPDFText_LoadPage(page));
1721 ASSERT_TRUE(text_page);
1722 ASSERT_EQ(
static_cast<
int>(kExpectedCount),
1723 FPDFText_CountChars(text_page.get()));
1727 unsigned short buffer[kExpectedTextSize];
1728 ASSERT_EQ(
static_cast<
int>(kExpectedTextSize),
1729 FPDFText_GetText(text_page.get(), 0, kExpectedCount, buffer));
1731 check_unsigned_shorts(kExpectedText, buffer, kExpectedTextSize));
1736 for (size_t i = 0; i < kExpectedCount; ++i) {
1737 ASSERT_TRUE(FPDFText_GetMatrix(text_page.get(), i, &matrix)) << i;
1738 EXPECT_FLOAT_EQ(kExpectedMatrices[i].a, matrix.a) << i;
1739 EXPECT_FLOAT_EQ(kExpectedMatrices[i].b, matrix.b) << i;
1740 EXPECT_FLOAT_EQ(kExpectedMatrices[i].c, matrix.c) << i;
1741 EXPECT_FLOAT_EQ(kExpectedMatrices[i].d, matrix.d) << i;
1742 EXPECT_FLOAT_EQ(kExpectedMatrices[i].e, matrix.e) << i;
1743 EXPECT_FLOAT_EQ(kExpectedMatrices[i].f, matrix.f) << i;
1748 EXPECT_FALSE(FPDFText_GetMatrix(text_page.get(), 10, &matrix));
1749 EXPECT_FALSE(FPDFText_GetMatrix(text_page.get(), -1, &matrix));
1750 EXPECT_FALSE(FPDFText_GetMatrix(text_page.get(), 0,
nullptr));
1758 constexpr double kExpectedCharWidth = 8.460;
1759 constexpr double kExpectedCharHeight = 6.600;
1760 constexpr float kExpectedLooseCharWidth = 8.664f;
1761 constexpr float kExpectedLooseCharHeight = 12.0f;
1763 ASSERT_TRUE(OpenDocument(
"font_matrix.pdf"));
1764 FPDF_PAGE page = LoadPage(0);
1768 ScopedFPDFTextPage text_page(FPDFText_LoadPage(page));
1769 ASSERT_TRUE(text_page);
1777 FPDFText_GetCharBox(text_page.get(), 0, &left, &right, &bottom, &top));
1778 EXPECT_NEAR(kExpectedCharWidth, right - left, 0.001);
1779 EXPECT_NEAR(kExpectedCharHeight, top - bottom, 0.001);
1781 FPDFText_GetCharBox(text_page.get(), 4, &left, &right, &bottom, &top));
1782 EXPECT_NEAR(kExpectedCharWidth, right - left, 0.001);
1783 EXPECT_NEAR(kExpectedCharHeight, top - bottom, 0.001);
1785 FPDFText_GetCharBox(text_page.get(), 8, &left, &right, &bottom, &top));
1786 EXPECT_NEAR(kExpectedCharWidth, right - left, 0.001);
1787 EXPECT_NEAR(kExpectedCharHeight, top - bottom, 0.001);
1791 ASSERT_TRUE(FPDFText_GetLooseCharBox(text_page.get(), 0, &rect));
1792 EXPECT_FLOAT_EQ(kExpectedLooseCharWidth, rect.right - rect.left);
1793 EXPECT_FLOAT_EQ(kExpectedLooseCharHeight, rect.top - rect.bottom);
1794 ASSERT_TRUE(FPDFText_GetLooseCharBox(text_page.get(), 4, &rect));
1795 EXPECT_FLOAT_EQ(kExpectedLooseCharWidth, rect.right - rect.left);
1796 EXPECT_FLOAT_EQ(kExpectedLooseCharHeight, rect.top - rect.bottom);
1797 ASSERT_TRUE(FPDFText_GetLooseCharBox(text_page.get(), 8, &rect));
1798 EXPECT_FLOAT_EQ(kExpectedLooseCharWidth, rect.right - rect.left);
1799 EXPECT_NEAR(kExpectedLooseCharHeight, rect.top - rect.bottom, 0.00001);
1806 ASSERT_TRUE(OpenDocument(
"bug_1591.pdf"));
1807 FPDF_PAGE page = LoadPage(0);
1811 ScopedFPDFTextPage text_page(FPDFText_LoadPage(page));
1812 ASSERT_TRUE(text_page);
1813 ASSERT_EQ(5, FPDFText_CountChars(text_page.get()));
1815 EXPECT_EQ(49u, FPDFText_GetUnicode(text_page.get(), 0));
1816 EXPECT_EQ(32u, FPDFText_GetUnicode(text_page.get(), 1));
1817 EXPECT_EQ(50u, FPDFText_GetUnicode(text_page.get(), 2));
1818 EXPECT_EQ(32u, FPDFText_GetUnicode(text_page.get(), 3));
1819 EXPECT_EQ(49u, FPDFText_GetUnicode(text_page.get(), 4));
1827 FPDFText_GetCharBox(text_page.get(), 0, &left, &right, &bottom, &top));
1828 EXPECT_DOUBLE_EQ(63.439998626708984, left);
1829 EXPECT_DOUBLE_EQ(65.360000610351562, right);
1830 EXPECT_DOUBLE_EQ(50.0, bottom);
1831 EXPECT_DOUBLE_EQ(61.520000457763672, top);
1833 FPDFText_GetCharBox(text_page.get(), 1, &left, &right, &bottom, &top));
1834 EXPECT_DOUBLE_EQ(62.007999420166016, left);
1835 EXPECT_DOUBLE_EQ(62.007999420166016, right);
1836 EXPECT_DOUBLE_EQ(50.0, bottom);
1837 EXPECT_DOUBLE_EQ(50.0, top);
1839 FPDFText_GetCharBox(text_page.get(), 2, &left, &right, &bottom, &top));
1840 EXPECT_DOUBLE_EQ(86.0, left);
1841 EXPECT_DOUBLE_EQ(88.400001525878906, right);
1842 EXPECT_DOUBLE_EQ(50.0, bottom);
1843 EXPECT_DOUBLE_EQ(50.240001678466797, top);
1845 FPDFText_GetCharBox(text_page.get(), 3, &left, &right, &bottom, &top));
1846 EXPECT_DOUBLE_EQ(86.010002136230469, left);
1847 EXPECT_DOUBLE_EQ(86.010002136230469, right);
1848 EXPECT_DOUBLE_EQ(50.0, bottom);
1849 EXPECT_DOUBLE_EQ(50.0, top);
1851 FPDFText_GetCharBox(text_page.get(), 4, &left, &right, &bottom, &top));
1852 EXPECT_DOUBLE_EQ(99.44000244140625, left);
1853 EXPECT_DOUBLE_EQ(101.36000061035156, right);
1854 EXPECT_DOUBLE_EQ(50.0, bottom);
1855 EXPECT_DOUBLE_EQ(61.520000457763672, top);
1862 constexpr char kExpectedText[] =
1863 "{fay,jeff,sanjay,wilsonh,kerr,m3b,tushar,\x02k es,gruber}@google.com";
1864 constexpr int kExpectedTextCount =
std::size(kExpectedText) - 1;
1866 ASSERT_TRUE(OpenDocument(
"bigtable_mini.pdf"));
1867 FPDF_PAGE page = LoadPage(0);
1871 ScopedFPDFTextPage text_page(FPDFText_LoadPage(page));
1872 ASSERT_TRUE(text_page);
1873 int char_count = FPDFText_CountChars(text_page.get());
1874 ASSERT_GE(char_count, 0);
1875 ASSERT_EQ(kExpectedTextCount, char_count);
1877 for (
int i = 0; i < kExpectedTextCount; ++i) {
1878 EXPECT_EQ(
static_cast<uint32_t>(kExpectedText[i]),
1879 FPDFText_GetUnicode(text_page.get(), i));
1887 ASSERT_TRUE(OpenDocument(
"bug_1769.pdf"));
1888 FPDF_PAGE page = LoadPage(0);
1892 ScopedFPDFTextPage textpage(FPDFText_LoadPage(page));
1893 ASSERT_TRUE(textpage);
1895 unsigned short buffer[128] = {};
1900 ASSERT_EQ(10, FPDFText_GetText(textpage.get(), 0, 128, buffer));
1901 EXPECT_TRUE(check_unsigned_shorts(
"wo d wo d", buffer, 10));
FPDF_EXPORT int FPDF_CALLCONV FPDFPage_GetAnnotCount(FPDF_PAGE page)
FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FPDFLink_GetAnnotRect(FPDF_LINK link_annot, FS_RECTF *rect)
FPDF_EXPORT int FPDF_CALLCONV FPDFLink_CountQuadPoints(FPDF_LINK link_annot)
FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FPDFLink_GetQuadPoints(FPDF_LINK link_annot, int quad_index, FS_QUADPOINTSF *quad_points)
FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FPDFLink_Enumerate(FPDF_PAGE page, int *start_pos, FPDF_LINK *link_annot)
FPDF_EXPORT unsigned long FPDF_CALLCONV FPDFTextObj_GetText(FPDF_PAGEOBJECT text_object, FPDF_TEXTPAGE text_page, FPDF_WCHAR *buffer, unsigned long length)
FPDF_EXPORT FPDF_PAGEOBJECT FPDF_CALLCONV FPDFPage_GetObject(FPDF_PAGE page, int index)
FPDF_EXPORT int FPDF_CALLCONV FPDFPage_CountObjects(FPDF_PAGE page)
FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FPDFText_GetStrokeColor(FPDF_TEXTPAGE text_page, int index, unsigned int *R, unsigned int *G, unsigned int *B, unsigned int *A)
FPDF_EXPORT int FPDF_CALLCONV FPDFLink_GetURL(FPDF_PAGELINK link_page, int link_index, unsigned short *buffer, int buflen)
FPDF_EXPORT int FPDF_CALLCONV FPDFText_GetText(FPDF_TEXTPAGE page, int start_index, int char_count, unsigned short *result)
FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FPDFLink_GetTextRange(FPDF_PAGELINK link_page, int link_index, int *start_char_index, int *char_count)
FPDF_EXPORT int FPDF_CALLCONV FPDFText_IsGenerated(FPDF_TEXTPAGE text_page, int index)
FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FPDFText_GetCharOrigin(FPDF_TEXTPAGE text_page, int index, double *x, double *y)
FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FPDFText_GetFillColor(FPDF_TEXTPAGE text_page, int index, unsigned int *R, unsigned int *G, unsigned int *B, unsigned int *A)
FPDF_EXPORT int FPDF_CALLCONV FPDFText_IsHyphen(FPDF_TEXTPAGE text_page, int index)
FPDF_EXPORT int FPDF_CALLCONV FPDFText_GetCharIndexAtPos(FPDF_TEXTPAGE text_page, double x, double y, double xTolerance, double yTolerance)
FPDF_EXPORT void FPDF_CALLCONV FPDFLink_CloseWebLinks(FPDF_PAGELINK link_page)
FPDF_EXPORT float FPDF_CALLCONV FPDFText_GetCharAngle(FPDF_TEXTPAGE text_page, int index)
FPDF_EXPORT int FPDF_CALLCONV FPDFText_HasUnicodeMapError(FPDF_TEXTPAGE text_page, int index)
FPDF_EXPORT int FPDF_CALLCONV FPDFText_GetBoundedText(FPDF_TEXTPAGE text_page, double left, double top, double right, double bottom, unsigned short *buffer, int buflen)
FPDF_EXPORT int FPDF_CALLCONV FPDFLink_CountRects(FPDF_PAGELINK link_page, int link_index)
FPDF_EXPORT int FPDF_CALLCONV FPDFText_GetFontWeight(FPDF_TEXTPAGE text_page, int index)
FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FPDFText_GetLooseCharBox(FPDF_TEXTPAGE text_page, int index, FS_RECTF *rect)
FPDF_EXPORT double FPDF_CALLCONV FPDFText_GetFontSize(FPDF_TEXTPAGE text_page, int index)
FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FPDFText_GetCharBox(FPDF_TEXTPAGE text_page, int index, double *left, double *right, double *bottom, double *top)
FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FPDFLink_GetRect(FPDF_PAGELINK link_page, int link_index, int rect_index, double *left, double *top, double *right, double *bottom)
FPDF_EXPORT FPDF_TEXT_RENDERMODE FPDF_CALLCONV FPDFText_GetTextRenderMode(FPDF_TEXTPAGE text_page, int index)
FPDF_EXPORT int FPDF_CALLCONV FPDFText_CountRects(FPDF_TEXTPAGE text_page, int start, int count)
FPDF_EXPORT int FPDF_CALLCONV FPDFText_CountChars(FPDF_TEXTPAGE text_page)
FPDF_EXPORT FPDF_TEXTPAGE FPDF_CALLCONV FPDFText_LoadPage(FPDF_PAGE page)
FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FPDFText_GetMatrix(FPDF_TEXTPAGE text_page, int index, FS_MATRIX *matrix)
FPDF_EXPORT void FPDF_CALLCONV FPDFText_ClosePage(FPDF_TEXTPAGE text_page)
FPDF_EXPORT FPDF_PAGELINK FPDF_CALLCONV FPDFLink_LoadWebLinks(FPDF_TEXTPAGE text_page)
FPDF_EXPORT unsigned long FPDF_CALLCONV FPDFText_GetFontInfo(FPDF_TEXTPAGE text_page, int index, void *buffer, unsigned long buflen, int *flags)
FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FPDFText_GetRect(FPDF_TEXTPAGE text_page, int rect_index, double *left, double *top, double *right, double *bottom)
FPDF_EXPORT unsigned int FPDF_CALLCONV FPDFText_GetUnicode(FPDF_TEXTPAGE text_page, int index)
FPDF_EXPORT int FPDF_CALLCONV FPDFLink_CountWebLinks(FPDF_PAGELINK link_page)
#define FPDF_MATCHWHOLEWORD
#define MAYBE_TextSearchLatinExtended
TEST_F(FPDFTextEmbedderTest, Text)
FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FPDF_GetPageBoundingBox(FPDF_PAGE page, FS_RECTF *rect)
#define FXFONT_NONSYMBOLIC