You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2388 lines
86 KiB
2388 lines
86 KiB
// Copyright 2017 PDFium Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style license that can be
|
|
// found in the LICENSE file.
|
|
|
|
#include <algorithm>
|
|
#include <cwchar>
|
|
#include <memory>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
#include "build/build_config.h"
|
|
#include "constants/annotation_common.h"
|
|
#include "core/fxcrt/fx_system.h"
|
|
#include "public/cpp/fpdf_scopers.h"
|
|
#include "public/fpdf_annot.h"
|
|
#include "public/fpdf_edit.h"
|
|
#include "public/fpdf_formfill.h"
|
|
#include "public/fpdfview.h"
|
|
#include "testing/embedder_test.h"
|
|
#include "testing/fx_string_testhelpers.h"
|
|
#include "testing/gmock/include/gmock/gmock-matchers.h"
|
|
#include "testing/gtest/include/gtest/gtest.h"
|
|
#include "testing/utils/hash.h"
|
|
|
|
class FPDFAnnotEmbedderTest : public EmbedderTest {};
|
|
|
|
TEST_F(FPDFAnnotEmbedderTest, BadParams) {
|
|
ASSERT_TRUE(OpenDocument("hello_world.pdf"));
|
|
FPDF_PAGE page = LoadPage(0);
|
|
ASSERT_TRUE(page);
|
|
|
|
EXPECT_EQ(0, FPDFPage_GetAnnotCount(nullptr));
|
|
|
|
EXPECT_FALSE(FPDFPage_GetAnnot(nullptr, 0));
|
|
EXPECT_FALSE(FPDFPage_GetAnnot(nullptr, -1));
|
|
EXPECT_FALSE(FPDFPage_GetAnnot(nullptr, 1));
|
|
EXPECT_FALSE(FPDFPage_GetAnnot(page, -1));
|
|
EXPECT_FALSE(FPDFPage_GetAnnot(page, 1));
|
|
|
|
EXPECT_EQ(FPDF_ANNOT_UNKNOWN, FPDFAnnot_GetSubtype(nullptr));
|
|
|
|
EXPECT_EQ(0, FPDFAnnot_GetObjectCount(nullptr));
|
|
|
|
EXPECT_FALSE(FPDFAnnot_GetObject(nullptr, 0));
|
|
EXPECT_FALSE(FPDFAnnot_GetObject(nullptr, -1));
|
|
EXPECT_FALSE(FPDFAnnot_GetObject(nullptr, 1));
|
|
|
|
EXPECT_FALSE(FPDFAnnot_HasKey(nullptr, "foo"));
|
|
|
|
static const wchar_t kContents[] = L"Bar";
|
|
ScopedFPDFWideString text = GetFPDFWideString(kContents);
|
|
EXPECT_FALSE(FPDFAnnot_SetStringValue(nullptr, "foo", text.get()));
|
|
|
|
FPDF_WCHAR buffer[64];
|
|
EXPECT_EQ(0u, FPDFAnnot_GetStringValue(nullptr, "foo", nullptr, 0));
|
|
EXPECT_EQ(0u, FPDFAnnot_GetStringValue(nullptr, "foo", buffer, 0));
|
|
EXPECT_EQ(0u,
|
|
FPDFAnnot_GetStringValue(nullptr, "foo", buffer, sizeof(buffer)));
|
|
|
|
UnloadPage(page);
|
|
}
|
|
|
|
TEST_F(FPDFAnnotEmbedderTest, BadAnnotsEntry) {
|
|
ASSERT_TRUE(OpenDocument("bad_annots_entry.pdf"));
|
|
FPDF_PAGE page = LoadPage(0);
|
|
ASSERT_TRUE(page);
|
|
|
|
EXPECT_EQ(1, FPDFPage_GetAnnotCount(page));
|
|
EXPECT_FALSE(FPDFPage_GetAnnot(page, 0));
|
|
|
|
UnloadPage(page);
|
|
}
|
|
|
|
TEST_F(FPDFAnnotEmbedderTest, RenderAnnotWithOnlyRolloverAP) {
|
|
// Open a file with one annotation and load its first page.
|
|
ASSERT_TRUE(OpenDocument("annotation_highlight_rollover_ap.pdf"));
|
|
FPDF_PAGE page = LoadPage(0);
|
|
ASSERT_TRUE(page);
|
|
|
|
// This annotation has a malformed appearance stream, which does not have its
|
|
// normal appearance defined, only its rollover appearance. In this case, its
|
|
// normal appearance should be generated, allowing the highlight annotation to
|
|
// still display.
|
|
ScopedFPDFBitmap bitmap = RenderLoadedPageWithFlags(page, FPDF_ANNOT);
|
|
CompareBitmap(bitmap.get(), 612, 792, "dc98f06da047bd8aabfa99562d2cbd1e");
|
|
|
|
UnloadPage(page);
|
|
}
|
|
|
|
// TODO(crbug.com/pdfium/11): Fix this test and enable.
|
|
#if defined(_SKIA_SUPPORT_) || defined(_SKIA_SUPPORT_PATHS_)
|
|
#define MAYBE_RenderMultilineMarkupAnnotWithoutAP \
|
|
DISABLED_RenderMultilineMarkupAnnotWithoutAP
|
|
#else
|
|
#define MAYBE_RenderMultilineMarkupAnnotWithoutAP \
|
|
RenderMultilineMarkupAnnotWithoutAP
|
|
#endif
|
|
TEST_F(FPDFAnnotEmbedderTest, MAYBE_RenderMultilineMarkupAnnotWithoutAP) {
|
|
static const char kMd5[] = "76512832d88017668d9acc7aacd13dae";
|
|
// Open a file with multiline markup annotations.
|
|
ASSERT_TRUE(OpenDocument("annotation_markup_multiline_no_ap.pdf"));
|
|
FPDF_PAGE page = LoadPage(0);
|
|
ASSERT_TRUE(page);
|
|
|
|
ScopedFPDFBitmap bitmap = RenderLoadedPageWithFlags(page, FPDF_ANNOT);
|
|
CompareBitmap(bitmap.get(), 595, 842, kMd5);
|
|
|
|
UnloadPage(page);
|
|
}
|
|
|
|
TEST_F(FPDFAnnotEmbedderTest, ExtractHighlightLongContent) {
|
|
// Open a file with one annotation and load its first page.
|
|
ASSERT_TRUE(OpenDocument("annotation_highlight_long_content.pdf"));
|
|
FPDF_PAGE page = LoadPageNoEvents(0);
|
|
ASSERT_TRUE(page);
|
|
|
|
// Check that there is a total of 1 annotation on its first page.
|
|
EXPECT_EQ(1, FPDFPage_GetAnnotCount(page));
|
|
|
|
// Check that the annotation is of type "highlight".
|
|
{
|
|
ScopedFPDFAnnotation annot(FPDFPage_GetAnnot(page, 0));
|
|
ASSERT_TRUE(annot);
|
|
EXPECT_EQ(FPDF_ANNOT_HIGHLIGHT, FPDFAnnot_GetSubtype(annot.get()));
|
|
|
|
// Check that the annotation color is yellow.
|
|
unsigned int R;
|
|
unsigned int G;
|
|
unsigned int B;
|
|
unsigned int A;
|
|
ASSERT_TRUE(FPDFAnnot_GetColor(annot.get(), FPDFANNOT_COLORTYPE_Color, &R,
|
|
&G, &B, &A));
|
|
EXPECT_EQ(255u, R);
|
|
EXPECT_EQ(255u, G);
|
|
EXPECT_EQ(0u, B);
|
|
EXPECT_EQ(255u, A);
|
|
|
|
// Check that the author is correct.
|
|
static const char kAuthorKey[] = "T";
|
|
EXPECT_EQ(FPDF_OBJECT_STRING,
|
|
FPDFAnnot_GetValueType(annot.get(), kAuthorKey));
|
|
unsigned long length_bytes =
|
|
FPDFAnnot_GetStringValue(annot.get(), kAuthorKey, nullptr, 0);
|
|
ASSERT_EQ(28u, length_bytes);
|
|
std::vector<FPDF_WCHAR> buf = GetFPDFWideStringBuffer(length_bytes);
|
|
EXPECT_EQ(28u, FPDFAnnot_GetStringValue(annot.get(), kAuthorKey, buf.data(),
|
|
length_bytes));
|
|
EXPECT_EQ(L"Jae Hyun Park", GetPlatformWString(buf.data()));
|
|
|
|
// Check that the content is correct.
|
|
EXPECT_EQ(
|
|
FPDF_OBJECT_STRING,
|
|
FPDFAnnot_GetValueType(annot.get(), pdfium::annotation::kContents));
|
|
length_bytes = FPDFAnnot_GetStringValue(
|
|
annot.get(), pdfium::annotation::kContents, nullptr, 0);
|
|
ASSERT_EQ(2690u, length_bytes);
|
|
buf = GetFPDFWideStringBuffer(length_bytes);
|
|
EXPECT_EQ(2690u, FPDFAnnot_GetStringValue(annot.get(),
|
|
pdfium::annotation::kContents,
|
|
buf.data(), length_bytes));
|
|
static const wchar_t kContents[] =
|
|
L"This is a note for that highlight annotation. Very long highlight "
|
|
"annotation. Long long long Long long longLong long longLong long "
|
|
"longLong long longLong long longLong long longLong long longLong long "
|
|
"longLong long longLong long longLong long longLong long longLong long "
|
|
"longLong long longLong long longLong long longLong long longLong long "
|
|
"longLong long longLong long longLong long longLong long longLong long "
|
|
"longLong long longLong long longLong long longLong long longLong long "
|
|
"longLong long longLong long longLong long longLong long longLong long "
|
|
"longLong long longLong long longLong long longLong long longLong long "
|
|
"longLong long longLong long longLong long longLong long longLong long "
|
|
"longLong long longLong long longLong long longLong long longLong long "
|
|
"longLong long longLong long longLong long longLong long longLong long "
|
|
"longLong long longLong long longLong long longLong long longLong long "
|
|
"longLong long longLong long longLong long longLong long longLong long "
|
|
"longLong long longLong long longLong long longLong long longLong long "
|
|
"longLong long longLong long longLong long longLong long longLong long "
|
|
"longLong long longLong long longLong long longLong long longLong long "
|
|
"longLong long longLong long longLong long longLong long longLong long "
|
|
"longLong long longLong long longLong long longLong long longLong long "
|
|
"longLong long long. END";
|
|
EXPECT_EQ(kContents, GetPlatformWString(buf.data()));
|
|
|
|
// Check that the quadpoints are correct.
|
|
FS_QUADPOINTSF quadpoints;
|
|
ASSERT_TRUE(FPDFAnnot_GetAttachmentPoints(annot.get(), 0, &quadpoints));
|
|
EXPECT_EQ(115.802643f, quadpoints.x1);
|
|
EXPECT_EQ(718.913940f, quadpoints.y1);
|
|
EXPECT_EQ(157.211182f, quadpoints.x4);
|
|
EXPECT_EQ(706.264465f, quadpoints.y4);
|
|
}
|
|
UnloadPageNoEvents(page);
|
|
}
|
|
|
|
// TODO(crbug.com/pdfium/11): Fix this test and enable.
|
|
#if defined(_SKIA_SUPPORT_) || defined(_SKIA_SUPPORT_PATHS_)
|
|
#define MAYBE_ExtractInkMultiple DISABLED_ExtractInkMultiple
|
|
#else
|
|
#define MAYBE_ExtractInkMultiple ExtractInkMultiple
|
|
#endif
|
|
TEST_F(FPDFAnnotEmbedderTest, MAYBE_ExtractInkMultiple) {
|
|
// Open a file with three annotations and load its first page.
|
|
ASSERT_TRUE(OpenDocument("annotation_ink_multiple.pdf"));
|
|
FPDF_PAGE page = LoadPageNoEvents(0);
|
|
ASSERT_TRUE(page);
|
|
|
|
// Check that there is a total of 3 annotation on its first page.
|
|
EXPECT_EQ(3, FPDFPage_GetAnnotCount(page));
|
|
|
|
{
|
|
// Check that the third annotation is of type "ink".
|
|
ScopedFPDFAnnotation annot(FPDFPage_GetAnnot(page, 2));
|
|
ASSERT_TRUE(annot);
|
|
EXPECT_EQ(FPDF_ANNOT_INK, FPDFAnnot_GetSubtype(annot.get()));
|
|
|
|
// Check that the annotation color is blue with opacity.
|
|
unsigned int R;
|
|
unsigned int G;
|
|
unsigned int B;
|
|
unsigned int A;
|
|
ASSERT_TRUE(FPDFAnnot_GetColor(annot.get(), FPDFANNOT_COLORTYPE_Color, &R,
|
|
&G, &B, &A));
|
|
EXPECT_EQ(0u, R);
|
|
EXPECT_EQ(0u, G);
|
|
EXPECT_EQ(255u, B);
|
|
EXPECT_EQ(76u, A);
|
|
|
|
// Check that there is no content.
|
|
EXPECT_EQ(2u, FPDFAnnot_GetStringValue(
|
|
annot.get(), pdfium::annotation::kContents, nullptr, 0));
|
|
|
|
// Check that the rectangle coordinates are correct.
|
|
// Note that upon rendering, the rectangle coordinates will be adjusted.
|
|
FS_RECTF rect;
|
|
ASSERT_TRUE(FPDFAnnot_GetRect(annot.get(), &rect));
|
|
EXPECT_EQ(351.820404f, rect.left);
|
|
EXPECT_EQ(583.830688f, rect.bottom);
|
|
EXPECT_EQ(475.336090f, rect.right);
|
|
EXPECT_EQ(681.535034f, rect.top);
|
|
}
|
|
{
|
|
ScopedFPDFBitmap bitmap = RenderLoadedPageWithFlags(page, FPDF_ANNOT);
|
|
CompareBitmap(bitmap.get(), 612, 792, "354002e1c4386d38fdde29ef8d61074a");
|
|
}
|
|
UnloadPageNoEvents(page);
|
|
}
|
|
|
|
TEST_F(FPDFAnnotEmbedderTest, AddIllegalSubtypeAnnotation) {
|
|
// Open a file with one annotation and load its first page.
|
|
ASSERT_TRUE(OpenDocument("annotation_highlight_long_content.pdf"));
|
|
FPDF_PAGE page = LoadPage(0);
|
|
ASSERT_TRUE(page);
|
|
|
|
// Add an annotation with an illegal subtype.
|
|
ASSERT_FALSE(FPDFPage_CreateAnnot(page, -1));
|
|
|
|
UnloadPage(page);
|
|
}
|
|
|
|
TEST_F(FPDFAnnotEmbedderTest, AddFirstTextAnnotation) {
|
|
// Open a file with no annotation and load its first page.
|
|
ASSERT_TRUE(OpenDocument("hello_world.pdf"));
|
|
FPDF_PAGE page = LoadPage(0);
|
|
ASSERT_TRUE(page);
|
|
EXPECT_EQ(0, FPDFPage_GetAnnotCount(page));
|
|
|
|
{
|
|
// Add a text annotation to the page.
|
|
ScopedFPDFAnnotation annot(FPDFPage_CreateAnnot(page, FPDF_ANNOT_TEXT));
|
|
ASSERT_TRUE(annot);
|
|
|
|
// Check that there is now 1 annotations on this page.
|
|
EXPECT_EQ(1, FPDFPage_GetAnnotCount(page));
|
|
|
|
// Check that the subtype of the annotation is correct.
|
|
EXPECT_EQ(FPDF_ANNOT_TEXT, FPDFAnnot_GetSubtype(annot.get()));
|
|
}
|
|
|
|
{
|
|
ScopedFPDFAnnotation annot(FPDFPage_GetAnnot(page, 0));
|
|
ASSERT_TRUE(annot);
|
|
EXPECT_EQ(FPDF_ANNOT_TEXT, FPDFAnnot_GetSubtype(annot.get()));
|
|
|
|
// Set the color of the annotation.
|
|
ASSERT_TRUE(FPDFAnnot_SetColor(annot.get(), FPDFANNOT_COLORTYPE_Color, 51,
|
|
102, 153, 204));
|
|
// Check that the color has been set correctly.
|
|
unsigned int R;
|
|
unsigned int G;
|
|
unsigned int B;
|
|
unsigned int A;
|
|
ASSERT_TRUE(FPDFAnnot_GetColor(annot.get(), FPDFANNOT_COLORTYPE_Color, &R,
|
|
&G, &B, &A));
|
|
EXPECT_EQ(51u, R);
|
|
EXPECT_EQ(102u, G);
|
|
EXPECT_EQ(153u, B);
|
|
EXPECT_EQ(204u, A);
|
|
|
|
// Change the color of the annotation.
|
|
ASSERT_TRUE(FPDFAnnot_SetColor(annot.get(), FPDFANNOT_COLORTYPE_Color, 204,
|
|
153, 102, 51));
|
|
// Check that the color has been set correctly.
|
|
ASSERT_TRUE(FPDFAnnot_GetColor(annot.get(), FPDFANNOT_COLORTYPE_Color, &R,
|
|
&G, &B, &A));
|
|
EXPECT_EQ(204u, R);
|
|
EXPECT_EQ(153u, G);
|
|
EXPECT_EQ(102u, B);
|
|
EXPECT_EQ(51u, A);
|
|
|
|
// Set the annotation rectangle.
|
|
FS_RECTF rect;
|
|
ASSERT_TRUE(FPDFAnnot_GetRect(annot.get(), &rect));
|
|
EXPECT_EQ(0.f, rect.left);
|
|
EXPECT_EQ(0.f, rect.right);
|
|
rect.left = 35;
|
|
rect.bottom = 150;
|
|
rect.right = 53;
|
|
rect.top = 165;
|
|
ASSERT_TRUE(FPDFAnnot_SetRect(annot.get(), &rect));
|
|
// Check that the annotation rectangle has been set correctly.
|
|
ASSERT_TRUE(FPDFAnnot_GetRect(annot.get(), &rect));
|
|
EXPECT_EQ(35.f, rect.left);
|
|
EXPECT_EQ(150.f, rect.bottom);
|
|
EXPECT_EQ(53.f, rect.right);
|
|
EXPECT_EQ(165.f, rect.top);
|
|
|
|
// Set the content of the annotation.
|
|
static const wchar_t kContents[] = L"Hello! This is a customized content.";
|
|
ScopedFPDFWideString text = GetFPDFWideString(kContents);
|
|
ASSERT_TRUE(FPDFAnnot_SetStringValue(
|
|
annot.get(), pdfium::annotation::kContents, text.get()));
|
|
// Check that the content has been set correctly.
|
|
unsigned long length_bytes = FPDFAnnot_GetStringValue(
|
|
annot.get(), pdfium::annotation::kContents, nullptr, 0);
|
|
ASSERT_EQ(74u, length_bytes);
|
|
std::vector<FPDF_WCHAR> buf = GetFPDFWideStringBuffer(length_bytes);
|
|
EXPECT_EQ(74u, FPDFAnnot_GetStringValue(annot.get(),
|
|
pdfium::annotation::kContents,
|
|
buf.data(), length_bytes));
|
|
EXPECT_EQ(kContents, GetPlatformWString(buf.data()));
|
|
}
|
|
UnloadPage(page);
|
|
}
|
|
|
|
// TODO(crbug.com/pdfium/11): Fix this test and enable.
|
|
#if defined(_SKIA_SUPPORT_) || defined(_SKIA_SUPPORT_PATHS_)
|
|
#define MAYBE_AddAndSaveUnderlineAnnotation \
|
|
DISABLED_AddAndSaveUnderlineAnnotation
|
|
#else
|
|
#define MAYBE_AddAndSaveUnderlineAnnotation AddAndSaveUnderlineAnnotation
|
|
#endif
|
|
TEST_F(FPDFAnnotEmbedderTest, MAYBE_AddAndSaveUnderlineAnnotation) {
|
|
// Open a file with one annotation and load its first page.
|
|
ASSERT_TRUE(OpenDocument("annotation_highlight_long_content.pdf"));
|
|
FPDF_PAGE page = LoadPage(0);
|
|
ASSERT_TRUE(page);
|
|
|
|
// Check that there is a total of one annotation on its first page, and verify
|
|
// its quadpoints.
|
|
EXPECT_EQ(1, FPDFPage_GetAnnotCount(page));
|
|
FS_QUADPOINTSF quadpoints;
|
|
{
|
|
ScopedFPDFAnnotation annot(FPDFPage_GetAnnot(page, 0));
|
|
ASSERT_TRUE(annot);
|
|
ASSERT_TRUE(FPDFAnnot_GetAttachmentPoints(annot.get(), 0, &quadpoints));
|
|
EXPECT_EQ(115.802643f, quadpoints.x1);
|
|
EXPECT_EQ(718.913940f, quadpoints.y1);
|
|
EXPECT_EQ(157.211182f, quadpoints.x4);
|
|
EXPECT_EQ(706.264465f, quadpoints.y4);
|
|
}
|
|
|
|
// Add an underline annotation to the page and set its quadpoints.
|
|
{
|
|
ScopedFPDFAnnotation annot(
|
|
FPDFPage_CreateAnnot(page, FPDF_ANNOT_UNDERLINE));
|
|
ASSERT_TRUE(annot);
|
|
quadpoints.x1 = 140.802643f;
|
|
quadpoints.x3 = 140.802643f;
|
|
ASSERT_TRUE(FPDFAnnot_AppendAttachmentPoints(annot.get(), &quadpoints));
|
|
}
|
|
|
|
// Save the document, closing the page and document.
|
|
EXPECT_TRUE(FPDF_SaveAsCopy(document(), this, 0));
|
|
UnloadPage(page);
|
|
|
|
// Open the saved document.
|
|
static const char kMd5[] = "dba153419f67b7c0c0e3d22d3e8910d5";
|
|
|
|
ASSERT_TRUE(OpenSavedDocument());
|
|
page = LoadSavedPage(0);
|
|
VerifySavedRendering(page, 612, 792, kMd5);
|
|
|
|
// Check that the saved document has 2 annotations on the first page
|
|
EXPECT_EQ(2, FPDFPage_GetAnnotCount(page));
|
|
|
|
{
|
|
// Check that the second annotation is an underline annotation and verify
|
|
// its quadpoints.
|
|
ScopedFPDFAnnotation new_annot(FPDFPage_GetAnnot(page, 1));
|
|
ASSERT_TRUE(new_annot);
|
|
EXPECT_EQ(FPDF_ANNOT_UNDERLINE, FPDFAnnot_GetSubtype(new_annot.get()));
|
|
FS_QUADPOINTSF new_quadpoints;
|
|
ASSERT_TRUE(
|
|
FPDFAnnot_GetAttachmentPoints(new_annot.get(), 0, &new_quadpoints));
|
|
EXPECT_NEAR(quadpoints.x1, new_quadpoints.x1, 0.001f);
|
|
EXPECT_NEAR(quadpoints.y1, new_quadpoints.y1, 0.001f);
|
|
EXPECT_NEAR(quadpoints.x4, new_quadpoints.x4, 0.001f);
|
|
EXPECT_NEAR(quadpoints.y4, new_quadpoints.y4, 0.001f);
|
|
}
|
|
|
|
CloseSavedPage(page);
|
|
CloseSavedDocument();
|
|
}
|
|
|
|
TEST_F(FPDFAnnotEmbedderTest, GetAndSetQuadPoints) {
|
|
// Open a file with four annotations and load its first page.
|
|
ASSERT_TRUE(OpenDocument("annotation_highlight_square_with_ap.pdf"));
|
|
FPDF_PAGE page = LoadPage(0);
|
|
ASSERT_TRUE(page);
|
|
EXPECT_EQ(4, FPDFPage_GetAnnotCount(page));
|
|
|
|
// Retrieve the highlight annotation.
|
|
FPDF_ANNOTATION annot = FPDFPage_GetAnnot(page, 0);
|
|
ASSERT_TRUE(annot);
|
|
ASSERT_EQ(FPDF_ANNOT_HIGHLIGHT, FPDFAnnot_GetSubtype(annot));
|
|
|
|
FS_QUADPOINTSF quadpoints;
|
|
ASSERT_TRUE(FPDFAnnot_GetAttachmentPoints(annot, 0, &quadpoints));
|
|
|
|
{
|
|
// Verify the current one set of quadpoints.
|
|
ASSERT_EQ(1u, FPDFAnnot_CountAttachmentPoints(annot));
|
|
|
|
EXPECT_NEAR(72.0000f, quadpoints.x1, 0.001f);
|
|
EXPECT_NEAR(720.792f, quadpoints.y1, 0.001f);
|
|
EXPECT_NEAR(132.055f, quadpoints.x4, 0.001f);
|
|
EXPECT_NEAR(704.796f, quadpoints.y4, 0.001f);
|
|
}
|
|
|
|
{
|
|
// Update the quadpoints.
|
|
FS_QUADPOINTSF new_quadpoints = quadpoints;
|
|
new_quadpoints.y1 -= 20.f;
|
|
new_quadpoints.y2 -= 20.f;
|
|
new_quadpoints.y3 -= 20.f;
|
|
new_quadpoints.y4 -= 20.f;
|
|
ASSERT_TRUE(FPDFAnnot_SetAttachmentPoints(annot, 0, &new_quadpoints));
|
|
|
|
// Verify added quadpoint set
|
|
ASSERT_EQ(1u, FPDFAnnot_CountAttachmentPoints(annot));
|
|
ASSERT_TRUE(FPDFAnnot_GetAttachmentPoints(annot, 0, &quadpoints));
|
|
EXPECT_NEAR(new_quadpoints.x1, quadpoints.x1, 0.001f);
|
|
EXPECT_NEAR(new_quadpoints.y1, quadpoints.y1, 0.001f);
|
|
EXPECT_NEAR(new_quadpoints.x4, quadpoints.x4, 0.001f);
|
|
EXPECT_NEAR(new_quadpoints.y4, quadpoints.y4, 0.001f);
|
|
}
|
|
|
|
{
|
|
// Append a new set of quadpoints.
|
|
FS_QUADPOINTSF new_quadpoints = quadpoints;
|
|
new_quadpoints.y1 += 20.f;
|
|
new_quadpoints.y2 += 20.f;
|
|
new_quadpoints.y3 += 20.f;
|
|
new_quadpoints.y4 += 20.f;
|
|
ASSERT_TRUE(FPDFAnnot_AppendAttachmentPoints(annot, &new_quadpoints));
|
|
|
|
// Verify added quadpoint set
|
|
ASSERT_EQ(2u, FPDFAnnot_CountAttachmentPoints(annot));
|
|
ASSERT_TRUE(FPDFAnnot_GetAttachmentPoints(annot, 1, &quadpoints));
|
|
EXPECT_NEAR(new_quadpoints.x1, quadpoints.x1, 0.001f);
|
|
EXPECT_NEAR(new_quadpoints.y1, quadpoints.y1, 0.001f);
|
|
EXPECT_NEAR(new_quadpoints.x4, quadpoints.x4, 0.001f);
|
|
EXPECT_NEAR(new_quadpoints.y4, quadpoints.y4, 0.001f);
|
|
}
|
|
|
|
{
|
|
// Setting and getting quadpoints at out-of-bound index should fail
|
|
EXPECT_FALSE(FPDFAnnot_SetAttachmentPoints(annot, 300000, &quadpoints));
|
|
EXPECT_FALSE(FPDFAnnot_GetAttachmentPoints(annot, 300000, &quadpoints));
|
|
}
|
|
|
|
FPDFPage_CloseAnnot(annot);
|
|
|
|
// Retrieve the square annotation
|
|
FPDF_ANNOTATION squareAnnot = FPDFPage_GetAnnot(page, 2);
|
|
|
|
{
|
|
// Check that attempting to set its quadpoints would fail
|
|
ASSERT_TRUE(squareAnnot);
|
|
EXPECT_EQ(FPDF_ANNOT_SQUARE, FPDFAnnot_GetSubtype(squareAnnot));
|
|
EXPECT_EQ(0u, FPDFAnnot_CountAttachmentPoints(squareAnnot));
|
|
EXPECT_FALSE(FPDFAnnot_SetAttachmentPoints(squareAnnot, 0, &quadpoints));
|
|
}
|
|
|
|
FPDFPage_CloseAnnot(squareAnnot);
|
|
UnloadPage(page);
|
|
}
|
|
|
|
// TODO(crbug.com/pdfium/11): Fix this test and enable.
|
|
#if defined(_SKIA_SUPPORT_) || defined(_SKIA_SUPPORT_PATHS_)
|
|
#define MAYBE_ModifyRectQuadpointsWithAP DISABLED_ModifyRectQuadpointsWithAP
|
|
#else
|
|
#define MAYBE_ModifyRectQuadpointsWithAP ModifyRectQuadpointsWithAP
|
|
#endif
|
|
TEST_F(FPDFAnnotEmbedderTest, MAYBE_ModifyRectQuadpointsWithAP) {
|
|
#if defined(OS_MACOSX)
|
|
static const char kMd5Original[] = "63af8432fab95a67cdebb7cd0e514941";
|
|
static const char kMd5ModifiedHighlight[] =
|
|
"aec26075011349dec9bace891856b5f2";
|
|
static const char kMd5ModifiedSquare[] = "057f57a32be95975775e5ec513fdcb56";
|
|
#elif defined(OS_WIN)
|
|
static const char kMd5Original[] = "0e27376094f11490f74c65f3dc3a42c5";
|
|
static const char kMd5ModifiedHighlight[] =
|
|
"66f3caef3a7d488a4fa1ad37fc06310e";
|
|
static const char kMd5ModifiedSquare[] = "a456dad0bc6801ee2d6408a4394af563";
|
|
#else
|
|
static const char kMd5Original[] = "0e27376094f11490f74c65f3dc3a42c5";
|
|
static const char kMd5ModifiedHighlight[] =
|
|
"66f3caef3a7d488a4fa1ad37fc06310e";
|
|
static const char kMd5ModifiedSquare[] = "a456dad0bc6801ee2d6408a4394af563";
|
|
#endif
|
|
|
|
// Open a file with four annotations and load its first page.
|
|
ASSERT_TRUE(OpenDocument("annotation_highlight_square_with_ap.pdf"));
|
|
FPDF_PAGE page = LoadPage(0);
|
|
ASSERT_TRUE(page);
|
|
EXPECT_EQ(4, FPDFPage_GetAnnotCount(page));
|
|
|
|
// Check that the original file renders correctly.
|
|
{
|
|
ScopedFPDFBitmap bitmap = RenderLoadedPageWithFlags(page, FPDF_ANNOT);
|
|
CompareBitmap(bitmap.get(), 612, 792, kMd5Original);
|
|
}
|
|
|
|
FS_RECTF rect;
|
|
FS_RECTF new_rect;
|
|
|
|
// Retrieve the highlight annotation which has its AP stream already defined.
|
|
{
|
|
ScopedFPDFAnnotation annot(FPDFPage_GetAnnot(page, 0));
|
|
ASSERT_TRUE(annot);
|
|
EXPECT_EQ(FPDF_ANNOT_HIGHLIGHT, FPDFAnnot_GetSubtype(annot.get()));
|
|
|
|
// Check that color cannot be set when an AP stream is defined already.
|
|
EXPECT_FALSE(FPDFAnnot_SetColor(annot.get(), FPDFANNOT_COLORTYPE_Color, 51,
|
|
102, 153, 204));
|
|
|
|
// Verify its attachment points.
|
|
FS_QUADPOINTSF quadpoints;
|
|
ASSERT_TRUE(FPDFAnnot_GetAttachmentPoints(annot.get(), 0, &quadpoints));
|
|
EXPECT_NEAR(72.0000f, quadpoints.x1, 0.001f);
|
|
EXPECT_NEAR(720.792f, quadpoints.y1, 0.001f);
|
|
EXPECT_NEAR(132.055f, quadpoints.x4, 0.001f);
|
|
EXPECT_NEAR(704.796f, quadpoints.y4, 0.001f);
|
|
|
|
// Check that updating the attachment points would succeed.
|
|
quadpoints.x1 -= 50.f;
|
|
quadpoints.x2 -= 50.f;
|
|
quadpoints.x3 -= 50.f;
|
|
quadpoints.x4 -= 50.f;
|
|
ASSERT_TRUE(FPDFAnnot_SetAttachmentPoints(annot.get(), 0, &quadpoints));
|
|
FS_QUADPOINTSF new_quadpoints;
|
|
ASSERT_TRUE(FPDFAnnot_GetAttachmentPoints(annot.get(), 0, &new_quadpoints));
|
|
EXPECT_EQ(quadpoints.x1, new_quadpoints.x1);
|
|
EXPECT_EQ(quadpoints.y1, new_quadpoints.y1);
|
|
EXPECT_EQ(quadpoints.x4, new_quadpoints.x4);
|
|
EXPECT_EQ(quadpoints.y4, new_quadpoints.y4);
|
|
|
|
// Check that updating quadpoints does not change the annotation's position.
|
|
{
|
|
ScopedFPDFBitmap bitmap = RenderLoadedPageWithFlags(page, FPDF_ANNOT);
|
|
CompareBitmap(bitmap.get(), 612, 792, kMd5Original);
|
|
}
|
|
|
|
// Verify its annotation rectangle.
|
|
ASSERT_TRUE(FPDFAnnot_GetRect(annot.get(), &rect));
|
|
EXPECT_NEAR(67.7299f, rect.left, 0.001f);
|
|
EXPECT_NEAR(704.296f, rect.bottom, 0.001f);
|
|
EXPECT_NEAR(136.325f, rect.right, 0.001f);
|
|
EXPECT_NEAR(721.292f, rect.top, 0.001f);
|
|
|
|
// Check that updating the rectangle would succeed.
|
|
rect.left -= 60.f;
|
|
rect.right -= 60.f;
|
|
ASSERT_TRUE(FPDFAnnot_SetRect(annot.get(), &rect));
|
|
ASSERT_TRUE(FPDFAnnot_GetRect(annot.get(), &new_rect));
|
|
EXPECT_EQ(rect.right, new_rect.right);
|
|
}
|
|
|
|
// Check that updating the rectangle changes the annotation's position.
|
|
{
|
|
ScopedFPDFBitmap bitmap = RenderLoadedPageWithFlags(page, FPDF_ANNOT);
|
|
CompareBitmap(bitmap.get(), 612, 792, kMd5ModifiedHighlight);
|
|
}
|
|
|
|
{
|
|
// Retrieve the square annotation which has its AP stream already defined.
|
|
ScopedFPDFAnnotation annot(FPDFPage_GetAnnot(page, 2));
|
|
ASSERT_TRUE(annot);
|
|
EXPECT_EQ(FPDF_ANNOT_SQUARE, FPDFAnnot_GetSubtype(annot.get()));
|
|
|
|
// Check that updating the rectangle would succeed.
|
|
ASSERT_TRUE(FPDFAnnot_GetRect(annot.get(), &rect));
|
|
rect.left += 70.f;
|
|
rect.right += 70.f;
|
|
ASSERT_TRUE(FPDFAnnot_SetRect(annot.get(), &rect));
|
|
ASSERT_TRUE(FPDFAnnot_GetRect(annot.get(), &new_rect));
|
|
EXPECT_EQ(rect.right, new_rect.right);
|
|
|
|
// Check that updating the rectangle changes the square annotation's
|
|
// position.
|
|
ScopedFPDFBitmap bitmap = RenderLoadedPageWithFlags(page, FPDF_ANNOT);
|
|
CompareBitmap(bitmap.get(), 612, 792, kMd5ModifiedSquare);
|
|
}
|
|
|
|
UnloadPage(page);
|
|
}
|
|
|
|
TEST_F(FPDFAnnotEmbedderTest, CountAttachmentPoints) {
|
|
// Open a file with multiline markup annotations.
|
|
ASSERT_TRUE(OpenDocument("annotation_markup_multiline_no_ap.pdf"));
|
|
FPDF_PAGE page = LoadPage(0);
|
|
ASSERT_TRUE(page);
|
|
{
|
|
ScopedFPDFAnnotation annot(FPDFPage_GetAnnot(page, 0));
|
|
ASSERT_TRUE(annot);
|
|
|
|
// This is a three line annotation.
|
|
EXPECT_EQ(3u, FPDFAnnot_CountAttachmentPoints(annot.get()));
|
|
}
|
|
UnloadPage(page);
|
|
|
|
// null annotation should return 0
|
|
EXPECT_EQ(0u, FPDFAnnot_CountAttachmentPoints(nullptr));
|
|
}
|
|
|
|
TEST_F(FPDFAnnotEmbedderTest, RemoveAnnotation) {
|
|
// Open a file with 3 annotations on its first page.
|
|
ASSERT_TRUE(OpenDocument("annotation_ink_multiple.pdf"));
|
|
FPDF_PAGE page = LoadPageNoEvents(0);
|
|
ASSERT_TRUE(page);
|
|
EXPECT_EQ(3, FPDFPage_GetAnnotCount(page));
|
|
|
|
FS_RECTF rect;
|
|
|
|
// Check that the annotations have the expected rectangle coordinates.
|
|
{
|
|
ScopedFPDFAnnotation annot(FPDFPage_GetAnnot(page, 0));
|
|
ASSERT_TRUE(FPDFAnnot_GetRect(annot.get(), &rect));
|
|
EXPECT_NEAR(86.1971f, rect.left, 0.001f);
|
|
}
|
|
|
|
{
|
|
ScopedFPDFAnnotation annot(FPDFPage_GetAnnot(page, 1));
|
|
ASSERT_TRUE(FPDFAnnot_GetRect(annot.get(), &rect));
|
|
EXPECT_NEAR(149.8127f, rect.left, 0.001f);
|
|
}
|
|
|
|
{
|
|
ScopedFPDFAnnotation annot(FPDFPage_GetAnnot(page, 2));
|
|
ASSERT_TRUE(FPDFAnnot_GetRect(annot.get(), &rect));
|
|
EXPECT_NEAR(351.8204f, rect.left, 0.001f);
|
|
}
|
|
|
|
// Check that nothing happens when attempting to remove an annotation with an
|
|
// out-of-bound index.
|
|
EXPECT_FALSE(FPDFPage_RemoveAnnot(page, 4));
|
|
EXPECT_FALSE(FPDFPage_RemoveAnnot(page, -1));
|
|
EXPECT_EQ(3, FPDFPage_GetAnnotCount(page));
|
|
|
|
// Remove the second annotation.
|
|
EXPECT_TRUE(FPDFPage_RemoveAnnot(page, 1));
|
|
EXPECT_EQ(2, FPDFPage_GetAnnotCount(page));
|
|
EXPECT_FALSE(FPDFPage_GetAnnot(page, 2));
|
|
|
|
// Save the document, closing the page and document.
|
|
EXPECT_TRUE(FPDF_SaveAsCopy(document(), this, 0));
|
|
UnloadPageNoEvents(page);
|
|
|
|
// TODO(npm): VerifySavedRendering changes annot rect dimensions by 1??
|
|
// Open the saved document.
|
|
std::string new_file = GetString();
|
|
FPDF_FILEACCESS file_access;
|
|
memset(&file_access, 0, sizeof(file_access));
|
|
file_access.m_FileLen = new_file.size();
|
|
file_access.m_GetBlock = GetBlockFromString;
|
|
file_access.m_Param = &new_file;
|
|
FPDF_DOCUMENT new_doc = FPDF_LoadCustomDocument(&file_access, nullptr);
|
|
ASSERT_TRUE(new_doc);
|
|
FPDF_PAGE new_page = FPDF_LoadPage(new_doc, 0);
|
|
ASSERT_TRUE(new_page);
|
|
|
|
// Check that the saved document has 2 annotations on the first page.
|
|
EXPECT_EQ(2, FPDFPage_GetAnnotCount(new_page));
|
|
|
|
// Check that the remaining 2 annotations are the original 1st and 3rd ones
|
|
// by verifying their rectangle coordinates.
|
|
{
|
|
ScopedFPDFAnnotation annot(FPDFPage_GetAnnot(new_page, 0));
|
|
ASSERT_TRUE(FPDFAnnot_GetRect(annot.get(), &rect));
|
|
EXPECT_NEAR(86.1971f, rect.left, 0.001f);
|
|
}
|
|
|
|
{
|
|
ScopedFPDFAnnotation annot(FPDFPage_GetAnnot(new_page, 1));
|
|
ASSERT_TRUE(FPDFAnnot_GetRect(annot.get(), &rect));
|
|
EXPECT_NEAR(351.8204f, rect.left, 0.001f);
|
|
}
|
|
FPDF_ClosePage(new_page);
|
|
FPDF_CloseDocument(new_doc);
|
|
}
|
|
|
|
// TODO(crbug.com/pdfium/11): Fix this test and enable.
|
|
#if defined(_SKIA_SUPPORT_) || defined(_SKIA_SUPPORT_PATHS_)
|
|
#define MAYBE_AddAndModifyPath DISABLED_AddAndModifyPath
|
|
#else
|
|
#define MAYBE_AddAndModifyPath AddAndModifyPath
|
|
#endif
|
|
TEST_F(FPDFAnnotEmbedderTest, MAYBE_AddAndModifyPath) {
|
|
#if defined(OS_MACOSX)
|
|
static const char kMd5Original[] = "c35408717759562d1f8bf33d317483d2";
|
|
static const char kMd5ModifiedPath[] = "9059723a045e17478753d2f0eb33bc03";
|
|
static const char kMd5TwoPaths[] = "7eed0cfba780f1d4dd8068f717d3a6bf";
|
|
static const char kMd5NewAnnot[] = "1de8212d43b7066a6df042095c2aca61";
|
|
#elif defined(OS_WIN)
|
|
static const char kMd5Original[] = "6aa001a77ec05d0f1b0d1d22e28744d4";
|
|
static const char kMd5ModifiedPath[] = "a7a8d675a6ddbcbdfecee65a33ba19e1";
|
|
static const char kMd5TwoPaths[] = "7c0bdd4552329704c47a7cce47edbbd6";
|
|
static const char kMd5NewAnnot[] = "3c48d492b4f62941fed0fb62f729f31e";
|
|
#else
|
|
static const char kMd5Original[] = "b42cef463483e668eaf4055a65e4f1f5";
|
|
static const char kMd5ModifiedPath[] = "6ff77d6d1fec4ea571fabe0c7a19b517";
|
|
static const char kMd5TwoPaths[] = "ca37ad549e74ac5b359a055708f3e7b6";
|
|
static const char kMd5NewAnnot[] = "0d7a0e33fbf41ff7fa5d732ab2c5edff";
|
|
#endif
|
|
|
|
// Open a file with two annotations and load its first page.
|
|
ASSERT_TRUE(OpenDocument("annotation_stamp_with_ap.pdf"));
|
|
FPDF_PAGE page = LoadPage(0);
|
|
ASSERT_TRUE(page);
|
|
EXPECT_EQ(2, FPDFPage_GetAnnotCount(page));
|
|
|
|
// Check that the page renders correctly.
|
|
{
|
|
ScopedFPDFBitmap bitmap = RenderLoadedPageWithFlags(page, FPDF_ANNOT);
|
|
CompareBitmap(bitmap.get(), 595, 842, kMd5Original);
|
|
}
|
|
|
|
{
|
|
// Retrieve the stamp annotation which has its AP stream already defined.
|
|
ScopedFPDFAnnotation annot(FPDFPage_GetAnnot(page, 0));
|
|
ASSERT_TRUE(annot);
|
|
|
|
// Check that this annotation has one path object and retrieve it.
|
|
EXPECT_EQ(1, FPDFAnnot_GetObjectCount(annot.get()));
|
|
ASSERT_EQ(32, FPDFPage_CountObjects(page));
|
|
FPDF_PAGEOBJECT path = FPDFAnnot_GetObject(annot.get(), 1);
|
|
EXPECT_FALSE(path);
|
|
path = FPDFAnnot_GetObject(annot.get(), 0);
|
|
EXPECT_EQ(FPDF_PAGEOBJ_PATH, FPDFPageObj_GetType(path));
|
|
EXPECT_TRUE(path);
|
|
|
|
// Modify the color of the path object.
|
|
EXPECT_TRUE(FPDFPageObj_SetStrokeColor(path, 0, 0, 0, 255));
|
|
EXPECT_TRUE(FPDFAnnot_UpdateObject(annot.get(), path));
|
|
|
|
// Check that the page with the modified annotation renders correctly.
|
|
{
|
|
ScopedFPDFBitmap bitmap = RenderLoadedPageWithFlags(page, FPDF_ANNOT);
|
|
CompareBitmap(bitmap.get(), 595, 842, kMd5ModifiedPath);
|
|
}
|
|
|
|
// Add a second path object to the same annotation.
|
|
FPDF_PAGEOBJECT dot = FPDFPageObj_CreateNewPath(7, 84);
|
|
EXPECT_TRUE(FPDFPath_BezierTo(dot, 9, 86, 10, 87, 11, 88));
|
|
EXPECT_TRUE(FPDFPageObj_SetStrokeColor(dot, 255, 0, 0, 100));
|
|
EXPECT_TRUE(FPDFPageObj_SetStrokeWidth(dot, 14));
|
|
EXPECT_TRUE(FPDFPath_SetDrawMode(dot, 0, 1));
|
|
EXPECT_TRUE(FPDFAnnot_AppendObject(annot.get(), dot));
|
|
EXPECT_EQ(2, FPDFAnnot_GetObjectCount(annot.get()));
|
|
|
|
// The object is in the annontation, not in the page, so the page object
|
|
// array should not change.
|
|
ASSERT_EQ(32, FPDFPage_CountObjects(page));
|
|
|
|
// Check that the page with an annotation with two paths renders correctly.
|
|
{
|
|
ScopedFPDFBitmap bitmap = RenderLoadedPageWithFlags(page, FPDF_ANNOT);
|
|
CompareBitmap(bitmap.get(), 595, 842, kMd5TwoPaths);
|
|
}
|
|
|
|
// Delete the newly added path object.
|
|
EXPECT_TRUE(FPDFAnnot_RemoveObject(annot.get(), 1));
|
|
EXPECT_EQ(1, FPDFAnnot_GetObjectCount(annot.get()));
|
|
ASSERT_EQ(32, FPDFPage_CountObjects(page));
|
|
}
|
|
|
|
// Check that the page renders the same as before.
|
|
{
|
|
ScopedFPDFBitmap bitmap = RenderLoadedPageWithFlags(page, FPDF_ANNOT);
|
|
CompareBitmap(bitmap.get(), 595, 842, kMd5ModifiedPath);
|
|
}
|
|
|
|
FS_RECTF rect;
|
|
|
|
{
|
|
// Create another stamp annotation and set its annotation rectangle.
|
|
ScopedFPDFAnnotation annot(FPDFPage_CreateAnnot(page, FPDF_ANNOT_STAMP));
|
|
ASSERT_TRUE(annot);
|
|
rect.left = 200.f;
|
|
rect.bottom = 400.f;
|
|
rect.right = 500.f;
|
|
rect.top = 600.f;
|
|
EXPECT_TRUE(FPDFAnnot_SetRect(annot.get(), &rect));
|
|
|
|
// Add a new path to the annotation.
|
|
FPDF_PAGEOBJECT check = FPDFPageObj_CreateNewPath(200, 500);
|
|
EXPECT_TRUE(FPDFPath_LineTo(check, 300, 400));
|
|
EXPECT_TRUE(FPDFPath_LineTo(check, 500, 600));
|
|
EXPECT_TRUE(FPDFPath_MoveTo(check, 350, 550));
|
|
EXPECT_TRUE(FPDFPath_LineTo(check, 450, 450));
|
|
EXPECT_TRUE(FPDFPageObj_SetStrokeColor(check, 0, 255, 255, 180));
|
|
EXPECT_TRUE(FPDFPageObj_SetStrokeWidth(check, 8.35f));
|
|
EXPECT_TRUE(FPDFPath_SetDrawMode(check, 0, 1));
|
|
EXPECT_TRUE(FPDFAnnot_AppendObject(annot.get(), check));
|
|
EXPECT_EQ(1, FPDFAnnot_GetObjectCount(annot.get()));
|
|
|
|
// Check that the annotation's bounding box came from its rectangle.
|
|
FS_RECTF new_rect;
|
|
ASSERT_TRUE(FPDFAnnot_GetRect(annot.get(), &new_rect));
|
|
EXPECT_EQ(rect.left, new_rect.left);
|
|
EXPECT_EQ(rect.bottom, new_rect.bottom);
|
|
EXPECT_EQ(rect.right, new_rect.right);
|
|
EXPECT_EQ(rect.top, new_rect.top);
|
|
}
|
|
|
|
// Save the document, closing the page and document.
|
|
EXPECT_TRUE(FPDF_SaveAsCopy(document(), this, 0));
|
|
UnloadPage(page);
|
|
|
|
// Open the saved document.
|
|
ASSERT_TRUE(OpenSavedDocument());
|
|
page = LoadSavedPage(0);
|
|
VerifySavedRendering(page, 595, 842, kMd5NewAnnot);
|
|
|
|
// Check that the document has a correct count of annotations and objects.
|
|
EXPECT_EQ(3, FPDFPage_GetAnnotCount(page));
|
|
|
|
{
|
|
ScopedFPDFAnnotation annot(FPDFPage_GetAnnot(page, 2));
|
|
ASSERT_TRUE(annot);
|
|
EXPECT_EQ(1, FPDFAnnot_GetObjectCount(annot.get()));
|
|
|
|
// Check that the new annotation's rectangle is as defined.
|
|
FS_RECTF new_rect;
|
|
ASSERT_TRUE(FPDFAnnot_GetRect(annot.get(), &new_rect));
|
|
EXPECT_EQ(rect.left, new_rect.left);
|
|
EXPECT_EQ(rect.bottom, new_rect.bottom);
|
|
EXPECT_EQ(rect.right, new_rect.right);
|
|
EXPECT_EQ(rect.top, new_rect.top);
|
|
}
|
|
|
|
CloseSavedPage(page);
|
|
CloseSavedDocument();
|
|
}
|
|
|
|
TEST_F(FPDFAnnotEmbedderTest, ModifyAnnotationFlags) {
|
|
// Open a file with an annotation and load its first page.
|
|
ASSERT_TRUE(OpenDocument("annotation_highlight_rollover_ap.pdf"));
|
|
FPDF_PAGE page = LoadPage(0);
|
|
ASSERT_TRUE(page);
|
|
|
|
// Check that the page renders correctly.
|
|
{
|
|
ScopedFPDFBitmap bitmap = RenderLoadedPageWithFlags(page, FPDF_ANNOT);
|
|
CompareBitmap(bitmap.get(), 612, 792, "dc98f06da047bd8aabfa99562d2cbd1e");
|
|
}
|
|
|
|
{
|
|
// Retrieve the annotation.
|
|
ScopedFPDFAnnotation annot(FPDFPage_GetAnnot(page, 0));
|
|
ASSERT_TRUE(annot);
|
|
|
|
// Check that the original flag values are as expected.
|
|
int flags = FPDFAnnot_GetFlags(annot.get());
|
|
EXPECT_FALSE(flags & FPDF_ANNOT_FLAG_HIDDEN);
|
|
EXPECT_TRUE(flags & FPDF_ANNOT_FLAG_PRINT);
|
|
|
|
// Set the HIDDEN flag.
|
|
flags |= FPDF_ANNOT_FLAG_HIDDEN;
|
|
EXPECT_TRUE(FPDFAnnot_SetFlags(annot.get(), flags));
|
|
flags = FPDFAnnot_GetFlags(annot.get());
|
|
EXPECT_TRUE(flags & FPDF_ANNOT_FLAG_HIDDEN);
|
|
EXPECT_TRUE(flags & FPDF_ANNOT_FLAG_PRINT);
|
|
|
|
// Check that the page renders correctly without rendering the annotation.
|
|
{
|
|
ScopedFPDFBitmap bitmap = RenderLoadedPageWithFlags(page, FPDF_ANNOT);
|
|
CompareBitmap(bitmap.get(), 612, 792, "1940568c9ba33bac5d0b1ee9558c76b3");
|
|
}
|
|
|
|
// Unset the HIDDEN flag.
|
|
EXPECT_TRUE(FPDFAnnot_SetFlags(annot.get(), FPDF_ANNOT_FLAG_NONE));
|
|
EXPECT_FALSE(FPDFAnnot_GetFlags(annot.get()));
|
|
flags &= ~FPDF_ANNOT_FLAG_HIDDEN;
|
|
EXPECT_TRUE(FPDFAnnot_SetFlags(annot.get(), flags));
|
|
flags = FPDFAnnot_GetFlags(annot.get());
|
|
EXPECT_FALSE(flags & FPDF_ANNOT_FLAG_HIDDEN);
|
|
EXPECT_TRUE(flags & FPDF_ANNOT_FLAG_PRINT);
|
|
|
|
// Check that the page renders correctly as before.
|
|
{
|
|
ScopedFPDFBitmap bitmap = RenderLoadedPageWithFlags(page, FPDF_ANNOT);
|
|
CompareBitmap(bitmap.get(), 612, 792, "dc98f06da047bd8aabfa99562d2cbd1e");
|
|
}
|
|
}
|
|
|
|
UnloadPage(page);
|
|
}
|
|
|
|
// TODO(crbug.com/pdfium/11): Fix this test and enable.
|
|
#if defined(_SKIA_SUPPORT_) || defined(_SKIA_SUPPORT_PATHS_)
|
|
#define MAYBE_AddAndModifyImage DISABLED_AddAndModifyImage
|
|
#else
|
|
#define MAYBE_AddAndModifyImage AddAndModifyImage
|
|
#endif
|
|
TEST_F(FPDFAnnotEmbedderTest, MAYBE_AddAndModifyImage) {
|
|
#if defined(OS_MACOSX)
|
|
static const char kMd5Original[] = "c35408717759562d1f8bf33d317483d2";
|
|
static const char kMd5NewImage[] = "ff012f5697436dfcaec25b32d1333596";
|
|
static const char kMd5ModifiedImage[] = "86cf8cb2755a7a2046a543e66d9c1e61";
|
|
#elif defined(OS_WIN)
|
|
static const char kMd5Original[] = "6aa001a77ec05d0f1b0d1d22e28744d4";
|
|
static const char kMd5NewImage[] = "3d77d06a971bcb9fb54db082f1082c8b";
|
|
static const char kMd5ModifiedImage[] = "dc4f4afc26c345418330d31c065020e1";
|
|
#else
|
|
static const char kMd5Original[] = "b42cef463483e668eaf4055a65e4f1f5";
|
|
static const char kMd5NewImage[] = "528e6243dc29d54f36b61e0d3287d935";
|
|
static const char kMd5ModifiedImage[] = "6d9e59f3e57a1ff82fb258356b7eb731";
|
|
#endif
|
|
|
|
// Open a file with two annotations and load its first page.
|
|
ASSERT_TRUE(OpenDocument("annotation_stamp_with_ap.pdf"));
|
|
FPDF_PAGE page = LoadPage(0);
|
|
ASSERT_TRUE(page);
|
|
EXPECT_EQ(2, FPDFPage_GetAnnotCount(page));
|
|
|
|
// Check that the page renders correctly.
|
|
{
|
|
ScopedFPDFBitmap bitmap = RenderLoadedPageWithFlags(page, FPDF_ANNOT);
|
|
CompareBitmap(bitmap.get(), 595, 842, kMd5Original);
|
|
}
|
|
|
|
constexpr int kBitmapSize = 200;
|
|
FPDF_BITMAP image_bitmap;
|
|
|
|
{
|
|
// Create a stamp annotation and set its annotation rectangle.
|
|
ScopedFPDFAnnotation annot(FPDFPage_CreateAnnot(page, FPDF_ANNOT_STAMP));
|
|
ASSERT_TRUE(annot);
|
|
FS_RECTF rect;
|
|
rect.left = 200.f;
|
|
rect.bottom = 600.f;
|
|
rect.right = 400.f;
|
|
rect.top = 800.f;
|
|
EXPECT_TRUE(FPDFAnnot_SetRect(annot.get(), &rect));
|
|
|
|
// Add a solid-color translucent image object to the new annotation.
|
|
image_bitmap = FPDFBitmap_Create(kBitmapSize, kBitmapSize, 1);
|
|
FPDFBitmap_FillRect(image_bitmap, 0, 0, kBitmapSize, kBitmapSize,
|
|
0xeeeecccc);
|
|
EXPECT_EQ(kBitmapSize, FPDFBitmap_GetWidth(image_bitmap));
|
|
EXPECT_EQ(kBitmapSize, FPDFBitmap_GetHeight(image_bitmap));
|
|
FPDF_PAGEOBJECT image_object = FPDFPageObj_NewImageObj(document());
|
|
ASSERT_TRUE(FPDFImageObj_SetBitmap(&page, 0, image_object, image_bitmap));
|
|
ASSERT_TRUE(FPDFImageObj_SetMatrix(image_object, kBitmapSize, 0, 0,
|
|
kBitmapSize, 0, 0));
|
|
FPDFPageObj_Transform(image_object, 1, 0, 0, 1, 200, 600);
|
|
EXPECT_TRUE(FPDFAnnot_AppendObject(annot.get(), image_object));
|
|
}
|
|
|
|
// Check that the page renders correctly with the new image object.
|
|
{
|
|
ScopedFPDFBitmap bitmap = RenderLoadedPageWithFlags(page, FPDF_ANNOT);
|
|
CompareBitmap(bitmap.get(), 595, 842, kMd5NewImage);
|
|
}
|
|
|
|
{
|
|
// Retrieve the newly added stamp annotation and its image object.
|
|
ScopedFPDFAnnotation annot(FPDFPage_GetAnnot(page, 2));
|
|
ASSERT_TRUE(annot);
|
|
EXPECT_EQ(1, FPDFAnnot_GetObjectCount(annot.get()));
|
|
FPDF_PAGEOBJECT image_object = FPDFAnnot_GetObject(annot.get(), 0);
|
|
EXPECT_EQ(FPDF_PAGEOBJ_IMAGE, FPDFPageObj_GetType(image_object));
|
|
|
|
// Modify the image in the new annotation.
|
|
FPDFBitmap_FillRect(image_bitmap, 0, 0, kBitmapSize, kBitmapSize,
|
|
0xff000000);
|
|
ASSERT_TRUE(FPDFImageObj_SetBitmap(&page, 0, image_object, image_bitmap));
|
|
EXPECT_TRUE(FPDFAnnot_UpdateObject(annot.get(), image_object));
|
|
}
|
|
|
|
// Save the document, closing the page and document.
|
|
EXPECT_TRUE(FPDF_SaveAsCopy(document(), this, 0));
|
|
UnloadPage(page);
|
|
FPDFBitmap_Destroy(image_bitmap);
|
|
|
|
// Test that the saved document renders the modified image object correctly.
|
|
VerifySavedDocument(595, 842, kMd5ModifiedImage);
|
|
}
|
|
|
|
// TODO(crbug.com/pdfium/11): Fix this test and enable.
|
|
#if defined(_SKIA_SUPPORT_) || defined(_SKIA_SUPPORT_PATHS_)
|
|
#define MAYBE_AddAndModifyText DISABLED_AddAndModifyText
|
|
#else
|
|
#define MAYBE_AddAndModifyText AddAndModifyText
|
|
#endif
|
|
TEST_F(FPDFAnnotEmbedderTest, MAYBE_AddAndModifyText) {
|
|
#if defined(OS_MACOSX)
|
|
static const char kMd5Original[] = "c35408717759562d1f8bf33d317483d2";
|
|
static const char kMd5NewText[] = "60031c1b0330cf1e1575f7d46687d429";
|
|
static const char kMd5ModifiedText[] = "79f5cfb0b07caaf936f65f6a7a57ce77";
|
|
#elif defined(OS_WIN)
|
|
static const char kMd5Original[] = "6aa001a77ec05d0f1b0d1d22e28744d4";
|
|
static const char kMd5NewText[] = "204cc01749a70b8afc246a4ca33c7eb6";
|
|
static const char kMd5ModifiedText[] = "641261a45e8dfd68c89b80bfd237660d";
|
|
#else
|
|
static const char kMd5Original[] = "b42cef463483e668eaf4055a65e4f1f5";
|
|
static const char kMd5NewText[] = "00197ad6206f763febad5719e5935306";
|
|
static const char kMd5ModifiedText[] = "85853bc0aaa5a4e3af04e58b9cbfff23";
|
|
#endif
|
|
|
|
// Open a file with two annotations and load its first page.
|
|
ASSERT_TRUE(OpenDocument("annotation_stamp_with_ap.pdf"));
|
|
FPDF_PAGE page = LoadPage(0);
|
|
ASSERT_TRUE(page);
|
|
EXPECT_EQ(2, FPDFPage_GetAnnotCount(page));
|
|
|
|
// Check that the page renders correctly.
|
|
{
|
|
ScopedFPDFBitmap bitmap = RenderLoadedPageWithFlags(page, FPDF_ANNOT);
|
|
CompareBitmap(bitmap.get(), 595, 842, kMd5Original);
|
|
}
|
|
|
|
{
|
|
// Create a stamp annotation and set its annotation rectangle.
|
|
ScopedFPDFAnnotation annot(FPDFPage_CreateAnnot(page, FPDF_ANNOT_STAMP));
|
|
ASSERT_TRUE(annot);
|
|
FS_RECTF rect;
|
|
rect.left = 200.f;
|
|
rect.bottom = 550.f;
|
|
rect.right = 450.f;
|
|
rect.top = 650.f;
|
|
EXPECT_TRUE(FPDFAnnot_SetRect(annot.get(), &rect));
|
|
|
|
// Add a translucent text object to the new annotation.
|
|
FPDF_PAGEOBJECT text_object =
|
|
FPDFPageObj_NewTextObj(document(), "Arial", 12.0f);
|
|
EXPECT_TRUE(text_object);
|
|
ScopedFPDFWideString text =
|
|
GetFPDFWideString(L"I'm a translucent text laying on other text.");
|
|
EXPECT_TRUE(FPDFText_SetText(text_object, text.get()));
|
|
EXPECT_TRUE(FPDFPageObj_SetFillColor(text_object, 0, 0, 255, 150));
|
|
FPDFPageObj_Transform(text_object, 1, 0, 0, 1, 200, 600);
|
|
EXPECT_TRUE(FPDFAnnot_AppendObject(annot.get(), text_object));
|
|
}
|
|
|
|
// Check that the page renders correctly with the new text object.
|
|
{
|
|
ScopedFPDFBitmap bitmap = RenderLoadedPageWithFlags(page, FPDF_ANNOT);
|
|
CompareBitmap(bitmap.get(), 595, 842, kMd5NewText);
|
|
}
|
|
|
|
{
|
|
// Retrieve the newly added stamp annotation and its text object.
|
|
ScopedFPDFAnnotation annot(FPDFPage_GetAnnot(page, 2));
|
|
ASSERT_TRUE(annot);
|
|
EXPECT_EQ(1, FPDFAnnot_GetObjectCount(annot.get()));
|
|
FPDF_PAGEOBJECT text_object = FPDFAnnot_GetObject(annot.get(), 0);
|
|
EXPECT_EQ(FPDF_PAGEOBJ_TEXT, FPDFPageObj_GetType(text_object));
|
|
|
|
// Modify the text in the new annotation.
|
|
ScopedFPDFWideString new_text = GetFPDFWideString(L"New text!");
|
|
EXPECT_TRUE(FPDFText_SetText(text_object, new_text.get()));
|
|
EXPECT_TRUE(FPDFAnnot_UpdateObject(annot.get(), text_object));
|
|
}
|
|
|
|
// Check that the page renders correctly with the modified text object.
|
|
{
|
|
ScopedFPDFBitmap bitmap = RenderLoadedPageWithFlags(page, FPDF_ANNOT);
|
|
CompareBitmap(bitmap.get(), 595, 842, kMd5ModifiedText);
|
|
}
|
|
|
|
// Remove the new annotation, and check that the page renders as before.
|
|
EXPECT_TRUE(FPDFPage_RemoveAnnot(page, 2));
|
|
{
|
|
ScopedFPDFBitmap bitmap = RenderLoadedPageWithFlags(page, FPDF_ANNOT);
|
|
CompareBitmap(bitmap.get(), 595, 842, kMd5Original);
|
|
}
|
|
|
|
UnloadPage(page);
|
|
}
|
|
|
|
// TODO(crbug.com/pdfium/11): Fix this test and enable.
|
|
#if defined(_SKIA_SUPPORT_) || defined(_SKIA_SUPPORT_PATHS_)
|
|
#define MAYBE_GetSetStringValue DISABLED_GetSetStringValue
|
|
#else
|
|
#define MAYBE_GetSetStringValue GetSetStringValue
|
|
#endif
|
|
TEST_F(FPDFAnnotEmbedderTest, MAYBE_GetSetStringValue) {
|
|
// Open a file with four annotations and load its first page.
|
|
ASSERT_TRUE(OpenDocument("annotation_stamp_with_ap.pdf"));
|
|
FPDF_PAGE page = LoadPage(0);
|
|
ASSERT_TRUE(page);
|
|
|
|
static const wchar_t kNewDate[] = L"D:201706282359Z00'00'";
|
|
|
|
{
|
|
// Retrieve the first annotation.
|
|
ScopedFPDFAnnotation annot(FPDFPage_GetAnnot(page, 0));
|
|
ASSERT_TRUE(annot);
|
|
|
|
// Check that a non-existent key does not exist.
|
|
EXPECT_FALSE(FPDFAnnot_HasKey(annot.get(), "none"));
|
|
|
|
// Check that the string value of a non-string dictionary entry is empty.
|
|
EXPECT_TRUE(FPDFAnnot_HasKey(annot.get(), pdfium::annotation::kAP));
|
|
EXPECT_EQ(FPDF_OBJECT_REFERENCE,
|
|
FPDFAnnot_GetValueType(annot.get(), pdfium::annotation::kAP));
|
|
EXPECT_EQ(2u, FPDFAnnot_GetStringValue(annot.get(), pdfium::annotation::kAP,
|
|
nullptr, 0));
|
|
|
|
// Check that the string value of the hash is correct.
|
|
static const char kHashKey[] = "AAPL:Hash";
|
|
EXPECT_EQ(FPDF_OBJECT_NAME, FPDFAnnot_GetValueType(annot.get(), kHashKey));
|
|
unsigned long length_bytes =
|
|
FPDFAnnot_GetStringValue(annot.get(), kHashKey, nullptr, 0);
|
|
ASSERT_EQ(66u, length_bytes);
|
|
std::vector<FPDF_WCHAR> buf = GetFPDFWideStringBuffer(length_bytes);
|
|
EXPECT_EQ(66u, FPDFAnnot_GetStringValue(annot.get(), kHashKey, buf.data(),
|
|
length_bytes));
|
|
EXPECT_EQ(L"395fbcb98d558681742f30683a62a2ad",
|
|
GetPlatformWString(buf.data()));
|
|
|
|
// Check that the string value of the modified date is correct.
|
|
EXPECT_EQ(FPDF_OBJECT_NAME, FPDFAnnot_GetValueType(annot.get(), kHashKey));
|
|
length_bytes = FPDFAnnot_GetStringValue(annot.get(), pdfium::annotation::kM,
|
|
nullptr, 0);
|
|
ASSERT_EQ(44u, length_bytes);
|
|
buf = GetFPDFWideStringBuffer(length_bytes);
|
|
EXPECT_EQ(44u, FPDFAnnot_GetStringValue(annot.get(), pdfium::annotation::kM,
|
|
buf.data(), length_bytes));
|
|
EXPECT_EQ(L"D:201706071721Z00'00'", GetPlatformWString(buf.data()));
|
|
|
|
// Update the date entry for the annotation.
|
|
ScopedFPDFWideString text = GetFPDFWideString(kNewDate);
|
|
EXPECT_TRUE(FPDFAnnot_SetStringValue(annot.get(), pdfium::annotation::kM,
|
|
text.get()));
|
|
}
|
|
|
|
// Save the document, closing the page and document.
|
|
EXPECT_TRUE(FPDF_SaveAsCopy(document(), this, 0));
|
|
UnloadPage(page);
|
|
|
|
#if defined(OS_MACOSX)
|
|
static const char kMd5[] = "4d64e61c9c0f8c60ab3cc3234bb73b1c";
|
|
#elif defined(OS_WIN)
|
|
static const char kMd5[] = "20b612ebd46babcb44c48c903e2c5a48";
|
|
#else
|
|
static const char kMd5[] = "1d7bea2042c6fea0558ff2aef05811b5";
|
|
#endif
|
|
|
|
// Open the saved annotation.
|
|
ASSERT_TRUE(OpenSavedDocument());
|
|
page = LoadSavedPage(0);
|
|
VerifySavedRendering(page, 595, 842, kMd5);
|
|
{
|
|
ScopedFPDFAnnotation new_annot(FPDFPage_GetAnnot(page, 0));
|
|
|
|
// Check that the string value of the modified date is the newly-set value.
|
|
EXPECT_EQ(FPDF_OBJECT_STRING,
|
|
FPDFAnnot_GetValueType(new_annot.get(), pdfium::annotation::kM));
|
|
unsigned long length_bytes = FPDFAnnot_GetStringValue(
|
|
new_annot.get(), pdfium::annotation::kM, nullptr, 0);
|
|
ASSERT_EQ(44u, length_bytes);
|
|
std::vector<FPDF_WCHAR> buf = GetFPDFWideStringBuffer(length_bytes);
|
|
EXPECT_EQ(44u,
|
|
FPDFAnnot_GetStringValue(new_annot.get(), pdfium::annotation::kM,
|
|
buf.data(), length_bytes));
|
|
EXPECT_EQ(kNewDate, GetPlatformWString(buf.data()));
|
|
}
|
|
|
|
CloseSavedPage(page);
|
|
CloseSavedDocument();
|
|
}
|
|
|
|
TEST_F(FPDFAnnotEmbedderTest, GetNumberValue) {
|
|
// Open a file with four text annotations and load its first page.
|
|
ASSERT_TRUE(OpenDocument("text_form_multiple.pdf"));
|
|
FPDF_PAGE page = LoadPage(0);
|
|
ASSERT_TRUE(page);
|
|
{
|
|
// First two annotations do not have "MaxLen" attribute.
|
|
for (int i = 0; i < 2; i++) {
|
|
ScopedFPDFAnnotation annot(FPDFPage_GetAnnot(page, i));
|
|
ASSERT_TRUE(annot);
|
|
|
|
// Verify that no "MaxLen" key present.
|
|
EXPECT_FALSE(FPDFAnnot_HasKey(annot.get(), "MaxLen"));
|
|
|
|
float value;
|
|
EXPECT_FALSE(FPDFAnnot_GetNumberValue(annot.get(), "MaxLen", &value));
|
|
}
|
|
|
|
// Annotation in index 2 has "MaxLen" of 10.
|
|
ScopedFPDFAnnotation annot(FPDFPage_GetAnnot(page, 2));
|
|
ASSERT_TRUE(annot);
|
|
|
|
// Verify that "MaxLen" key present.
|
|
EXPECT_TRUE(FPDFAnnot_HasKey(annot.get(), "MaxLen"));
|
|
|
|
float value;
|
|
EXPECT_TRUE(FPDFAnnot_GetNumberValue(annot.get(), "MaxLen", &value));
|
|
EXPECT_FLOAT_EQ(10.0f, value);
|
|
|
|
// Check bad inputs.
|
|
EXPECT_FALSE(FPDFAnnot_GetNumberValue(nullptr, "MaxLen", &value));
|
|
EXPECT_FALSE(FPDFAnnot_GetNumberValue(annot.get(), nullptr, &value));
|
|
EXPECT_FALSE(FPDFAnnot_GetNumberValue(annot.get(), "MaxLen", nullptr));
|
|
// Ask for key that exists but is not a number.
|
|
EXPECT_FALSE(FPDFAnnot_GetNumberValue(annot.get(), "V", &value));
|
|
}
|
|
|
|
UnloadPage(page);
|
|
}
|
|
|
|
TEST_F(FPDFAnnotEmbedderTest, GetSetAP) {
|
|
// Open a file with four annotations and load its first page.
|
|
ASSERT_TRUE(OpenDocument("annotation_stamp_with_ap.pdf"));
|
|
FPDF_PAGE page = LoadPage(0);
|
|
ASSERT_TRUE(page);
|
|
|
|
{
|
|
static const char kMd5NormalAP[] = "be903df0343fd774fadab9c8900cdf4a";
|
|
static constexpr size_t kExpectNormalAPLength = 73970;
|
|
|
|
// Retrieve the first annotation.
|
|
ScopedFPDFAnnotation annot(FPDFPage_GetAnnot(page, 0));
|
|
ASSERT_TRUE(annot);
|
|
|
|
// Check that the string value of an AP returns the expected length.
|
|
unsigned long normal_length_bytes = FPDFAnnot_GetAP(
|
|
annot.get(), FPDF_ANNOT_APPEARANCEMODE_NORMAL, nullptr, 0);
|
|
ASSERT_EQ(kExpectNormalAPLength, normal_length_bytes);
|
|
|
|
// Check that the string value of an AP is not returned if the buffer is too
|
|
// small. The result buffer should be overwritten with an empty string.
|
|
std::vector<FPDF_WCHAR> buf = GetFPDFWideStringBuffer(normal_length_bytes);
|
|
// Write in the buffer to verify it's not overwritten.
|
|
memcpy(buf.data(), "abcdefgh", 8);
|
|
EXPECT_EQ(kExpectNormalAPLength,
|
|
FPDFAnnot_GetAP(annot.get(), FPDF_ANNOT_APPEARANCEMODE_NORMAL,
|
|
buf.data(), normal_length_bytes - 1));
|
|
EXPECT_EQ(0, memcmp(buf.data(), "abcdefgh", 8));
|
|
|
|
// Check that the string value of an AP is returned through a buffer that is
|
|
// the right size.
|
|
EXPECT_EQ(kExpectNormalAPLength,
|
|
FPDFAnnot_GetAP(annot.get(), FPDF_ANNOT_APPEARANCEMODE_NORMAL,
|
|
buf.data(), normal_length_bytes));
|
|
EXPECT_EQ(kMd5NormalAP,
|
|
GenerateMD5Base16(reinterpret_cast<uint8_t*>(buf.data()),
|
|
normal_length_bytes));
|
|
|
|
// Check that the string value of an AP is returned through a buffer that is
|
|
// larger than necessary.
|
|
buf = GetFPDFWideStringBuffer(normal_length_bytes + 2);
|
|
EXPECT_EQ(kExpectNormalAPLength,
|
|
FPDFAnnot_GetAP(annot.get(), FPDF_ANNOT_APPEARANCEMODE_NORMAL,
|
|
buf.data(), normal_length_bytes + 2));
|
|
EXPECT_EQ(kMd5NormalAP,
|
|
GenerateMD5Base16(reinterpret_cast<uint8_t*>(buf.data()),
|
|
normal_length_bytes));
|
|
|
|
// Check that getting an AP for a mode that does not have an AP returns an
|
|
// empty string.
|
|
unsigned long rollover_length_bytes = FPDFAnnot_GetAP(
|
|
annot.get(), FPDF_ANNOT_APPEARANCEMODE_ROLLOVER, nullptr, 0);
|
|
ASSERT_EQ(2u, rollover_length_bytes);
|
|
|
|
buf = GetFPDFWideStringBuffer(1000);
|
|
EXPECT_EQ(2u,
|
|
FPDFAnnot_GetAP(annot.get(), FPDF_ANNOT_APPEARANCEMODE_ROLLOVER,
|
|
buf.data(), 1000));
|
|
EXPECT_EQ(L"", GetPlatformWString(buf.data()));
|
|
|
|
// Check that setting the AP for an invalid appearance mode fails.
|
|
ScopedFPDFWideString ap_text = GetFPDFWideString(L"new test ap");
|
|
EXPECT_FALSE(FPDFAnnot_SetAP(annot.get(), -1, ap_text.get()));
|
|
EXPECT_FALSE(FPDFAnnot_SetAP(annot.get(), FPDF_ANNOT_APPEARANCEMODE_COUNT,
|
|
ap_text.get()));
|
|
EXPECT_FALSE(FPDFAnnot_SetAP(
|
|
annot.get(), FPDF_ANNOT_APPEARANCEMODE_COUNT + 1, ap_text.get()));
|
|
|
|
// Set the AP correctly now.
|
|
EXPECT_TRUE(FPDFAnnot_SetAP(annot.get(), FPDF_ANNOT_APPEARANCEMODE_ROLLOVER,
|
|
ap_text.get()));
|
|
|
|
// Check that the new annotation value is equal to the value we just set.
|
|
rollover_length_bytes = FPDFAnnot_GetAP(
|
|
annot.get(), FPDF_ANNOT_APPEARANCEMODE_ROLLOVER, nullptr, 0);
|
|
ASSERT_EQ(24u, rollover_length_bytes);
|
|
buf = GetFPDFWideStringBuffer(rollover_length_bytes);
|
|
EXPECT_EQ(24u,
|
|
FPDFAnnot_GetAP(annot.get(), FPDF_ANNOT_APPEARANCEMODE_ROLLOVER,
|
|
buf.data(), rollover_length_bytes));
|
|
EXPECT_EQ(L"new test ap", GetPlatformWString(buf.data()));
|
|
|
|
// Check that the Normal AP was not touched when the Rollover AP was set.
|
|
buf = GetFPDFWideStringBuffer(normal_length_bytes);
|
|
EXPECT_EQ(kExpectNormalAPLength,
|
|
FPDFAnnot_GetAP(annot.get(), FPDF_ANNOT_APPEARANCEMODE_NORMAL,
|
|
buf.data(), normal_length_bytes));
|
|
EXPECT_EQ(kMd5NormalAP,
|
|
GenerateMD5Base16(reinterpret_cast<uint8_t*>(buf.data()),
|
|
normal_length_bytes));
|
|
}
|
|
|
|
// Save the modified document, then reopen it.
|
|
EXPECT_TRUE(FPDF_SaveAsCopy(document(), this, 0));
|
|
UnloadPage(page);
|
|
|
|
ASSERT_TRUE(OpenSavedDocument());
|
|
page = LoadSavedPage(0);
|
|
{
|
|
ScopedFPDFAnnotation new_annot(FPDFPage_GetAnnot(page, 0));
|
|
|
|
// Check that the new annotation value is equal to the value we set before
|
|
// saving.
|
|
unsigned long rollover_length_bytes = FPDFAnnot_GetAP(
|
|
new_annot.get(), FPDF_ANNOT_APPEARANCEMODE_ROLLOVER, nullptr, 0);
|
|
ASSERT_EQ(24u, rollover_length_bytes);
|
|
std::vector<FPDF_WCHAR> buf =
|
|
GetFPDFWideStringBuffer(rollover_length_bytes);
|
|
EXPECT_EQ(24u, FPDFAnnot_GetAP(new_annot.get(),
|
|
FPDF_ANNOT_APPEARANCEMODE_ROLLOVER,
|
|
buf.data(), rollover_length_bytes));
|
|
EXPECT_EQ(L"new test ap", GetPlatformWString(buf.data()));
|
|
}
|
|
|
|
// Close saved document.
|
|
CloseSavedPage(page);
|
|
CloseSavedDocument();
|
|
}
|
|
|
|
TEST_F(FPDFAnnotEmbedderTest, RemoveOptionalAP) {
|
|
// Open a file with four annotations and load its first page.
|
|
ASSERT_TRUE(OpenDocument("annotation_stamp_with_ap.pdf"));
|
|
FPDF_PAGE page = LoadPage(0);
|
|
ASSERT_TRUE(page);
|
|
|
|
{
|
|
// Retrieve the first annotation.
|
|
ScopedFPDFAnnotation annot(FPDFPage_GetAnnot(page, 0));
|
|
ASSERT_TRUE(annot);
|
|
|
|
// Set Down AP. Normal AP is already set.
|
|
ScopedFPDFWideString ap_text = GetFPDFWideString(L"new test ap");
|
|
EXPECT_TRUE(FPDFAnnot_SetAP(annot.get(), FPDF_ANNOT_APPEARANCEMODE_DOWN,
|
|
ap_text.get()));
|
|
EXPECT_EQ(73970u,
|
|
FPDFAnnot_GetAP(annot.get(), FPDF_ANNOT_APPEARANCEMODE_NORMAL,
|
|
nullptr, 0));
|
|
EXPECT_EQ(24u, FPDFAnnot_GetAP(annot.get(), FPDF_ANNOT_APPEARANCEMODE_DOWN,
|
|
nullptr, 0));
|
|
|
|
// Check that setting the Down AP to null removes the Down entry but keeps
|
|
// Normal intact.
|
|
EXPECT_TRUE(
|
|
FPDFAnnot_SetAP(annot.get(), FPDF_ANNOT_APPEARANCEMODE_DOWN, nullptr));
|
|
EXPECT_EQ(73970u,
|
|
FPDFAnnot_GetAP(annot.get(), FPDF_ANNOT_APPEARANCEMODE_NORMAL,
|
|
nullptr, 0));
|
|
EXPECT_EQ(2u, FPDFAnnot_GetAP(annot.get(), FPDF_ANNOT_APPEARANCEMODE_DOWN,
|
|
nullptr, 0));
|
|
}
|
|
|
|
UnloadPage(page);
|
|
}
|
|
|
|
TEST_F(FPDFAnnotEmbedderTest, RemoveRequiredAP) {
|
|
// Open a file with four annotations and load its first page.
|
|
ASSERT_TRUE(OpenDocument("annotation_stamp_with_ap.pdf"));
|
|
FPDF_PAGE page = LoadPage(0);
|
|
ASSERT_TRUE(page);
|
|
|
|
{
|
|
// Retrieve the first annotation.
|
|
ScopedFPDFAnnotation annot(FPDFPage_GetAnnot(page, 0));
|
|
ASSERT_TRUE(annot);
|
|
|
|
// Set Down AP. Normal AP is already set.
|
|
ScopedFPDFWideString ap_text = GetFPDFWideString(L"new test ap");
|
|
EXPECT_TRUE(FPDFAnnot_SetAP(annot.get(), FPDF_ANNOT_APPEARANCEMODE_DOWN,
|
|
ap_text.get()));
|
|
EXPECT_EQ(73970u,
|
|
FPDFAnnot_GetAP(annot.get(), FPDF_ANNOT_APPEARANCEMODE_NORMAL,
|
|
nullptr, 0));
|
|
EXPECT_EQ(24u, FPDFAnnot_GetAP(annot.get(), FPDF_ANNOT_APPEARANCEMODE_DOWN,
|
|
nullptr, 0));
|
|
|
|
// Check that setting the Normal AP to null removes the whole AP dictionary.
|
|
EXPECT_TRUE(FPDFAnnot_SetAP(annot.get(), FPDF_ANNOT_APPEARANCEMODE_NORMAL,
|
|
nullptr));
|
|
EXPECT_EQ(2u, FPDFAnnot_GetAP(annot.get(), FPDF_ANNOT_APPEARANCEMODE_NORMAL,
|
|
nullptr, 0));
|
|
EXPECT_EQ(2u, FPDFAnnot_GetAP(annot.get(), FPDF_ANNOT_APPEARANCEMODE_DOWN,
|
|
nullptr, 0));
|
|
}
|
|
|
|
UnloadPage(page);
|
|
}
|
|
|
|
TEST_F(FPDFAnnotEmbedderTest, ExtractLinkedAnnotations) {
|
|
// Open a file with annotations and load its first page.
|
|
ASSERT_TRUE(OpenDocument("annotation_highlight_square_with_ap.pdf"));
|
|
FPDF_PAGE page = LoadPage(0);
|
|
ASSERT_TRUE(page);
|
|
EXPECT_EQ(-1, FPDFPage_GetAnnotIndex(page, nullptr));
|
|
|
|
{
|
|
// Retrieve the highlight annotation which has its popup defined.
|
|
ScopedFPDFAnnotation annot(FPDFPage_GetAnnot(page, 0));
|
|
ASSERT_TRUE(annot);
|
|
EXPECT_EQ(FPDF_ANNOT_HIGHLIGHT, FPDFAnnot_GetSubtype(annot.get()));
|
|
EXPECT_EQ(0, FPDFPage_GetAnnotIndex(page, annot.get()));
|
|
static const char kPopupKey[] = "Popup";
|
|
ASSERT_TRUE(FPDFAnnot_HasKey(annot.get(), kPopupKey));
|
|
ASSERT_EQ(FPDF_OBJECT_REFERENCE,
|
|
FPDFAnnot_GetValueType(annot.get(), kPopupKey));
|
|
|
|
// Retrieve and verify the popup of the highlight annotation.
|
|
ScopedFPDFAnnotation popup(
|
|
FPDFAnnot_GetLinkedAnnot(annot.get(), kPopupKey));
|
|
ASSERT_TRUE(popup);
|
|
EXPECT_EQ(FPDF_ANNOT_POPUP, FPDFAnnot_GetSubtype(popup.get()));
|
|
EXPECT_EQ(1, FPDFPage_GetAnnotIndex(page, popup.get()));
|
|
FS_RECTF rect;
|
|
ASSERT_TRUE(FPDFAnnot_GetRect(popup.get(), &rect));
|
|
EXPECT_NEAR(612.0f, rect.left, 0.001f);
|
|
EXPECT_NEAR(578.792, rect.bottom, 0.001f);
|
|
|
|
// Attempting to retrieve |annot|'s "IRT"-linked annotation would fail,
|
|
// since "IRT" is not a key in |annot|'s dictionary.
|
|
static const char kIRTKey[] = "IRT";
|
|
ASSERT_FALSE(FPDFAnnot_HasKey(annot.get(), kIRTKey));
|
|
EXPECT_FALSE(FPDFAnnot_GetLinkedAnnot(annot.get(), kIRTKey));
|
|
|
|
// Attempting to retrieve |annot|'s parent dictionary as an annotation
|
|
// would fail, since its parent is not an annotation.
|
|
ASSERT_TRUE(FPDFAnnot_HasKey(annot.get(), pdfium::annotation::kP));
|
|
EXPECT_EQ(FPDF_OBJECT_REFERENCE,
|
|
FPDFAnnot_GetValueType(annot.get(), pdfium::annotation::kP));
|
|
EXPECT_FALSE(FPDFAnnot_GetLinkedAnnot(annot.get(), pdfium::annotation::kP));
|
|
}
|
|
|
|
UnloadPage(page);
|
|
}
|
|
|
|
TEST_F(FPDFAnnotEmbedderTest, GetFormFieldFlagsTextField) {
|
|
// Open file with form text fields.
|
|
ASSERT_TRUE(OpenDocument("text_form_multiple.pdf"));
|
|
FPDF_PAGE page = LoadPage(0);
|
|
ASSERT_TRUE(page);
|
|
|
|
{
|
|
// Retrieve the first annotation: user-editable text field.
|
|
ScopedFPDFAnnotation annot(FPDFPage_GetAnnot(page, 0));
|
|
ASSERT_TRUE(annot);
|
|
|
|
// Check that the flag values are as expected.
|
|
int flags = FPDFAnnot_GetFormFieldFlags(form_handle(), annot.get());
|
|
EXPECT_FALSE(flags & FPDF_FORMFLAG_READONLY);
|
|
EXPECT_FALSE(flags & FPDF_FORMFLAG_TEXT_PASSWORD);
|
|
}
|
|
|
|
{
|
|
// Retrieve the second annotation: read-only text field.
|
|
ScopedFPDFAnnotation annot(FPDFPage_GetAnnot(page, 1));
|
|
ASSERT_TRUE(annot);
|
|
|
|
// Check that the flag values are as expected.
|
|
int flags = FPDFAnnot_GetFormFieldFlags(form_handle(), annot.get());
|
|
EXPECT_TRUE(flags & FPDF_FORMFLAG_READONLY);
|
|
EXPECT_FALSE(flags & FPDF_FORMFLAG_TEXT_PASSWORD);
|
|
}
|
|
|
|
{
|
|
// Retrieve the fourth annotation: user-editable password text field.
|
|
ScopedFPDFAnnotation annot(FPDFPage_GetAnnot(page, 3));
|
|
ASSERT_TRUE(annot);
|
|
|
|
// Check that the flag values are as expected.
|
|
int flags = FPDFAnnot_GetFormFieldFlags(form_handle(), annot.get());
|
|
EXPECT_FALSE(flags & FPDF_FORMFLAG_READONLY);
|
|
EXPECT_TRUE(flags & FPDF_FORMFLAG_TEXT_PASSWORD);
|
|
}
|
|
|
|
UnloadPage(page);
|
|
}
|
|
|
|
TEST_F(FPDFAnnotEmbedderTest, GetFormFieldFlagsComboBox) {
|
|
// Open file with form text fields.
|
|
ASSERT_TRUE(OpenDocument("combobox_form.pdf"));
|
|
FPDF_PAGE page = LoadPage(0);
|
|
ASSERT_TRUE(page);
|
|
|
|
{
|
|
// Retrieve the first annotation: user-editable combobox.
|
|
ScopedFPDFAnnotation annot(FPDFPage_GetAnnot(page, 0));
|
|
ASSERT_TRUE(annot);
|
|
|
|
// Check that the flag values are as expected.
|
|
int flags = FPDFAnnot_GetFormFieldFlags(form_handle(), annot.get());
|
|
EXPECT_FALSE(flags & FPDF_FORMFLAG_READONLY);
|
|
EXPECT_TRUE(flags & FPDF_FORMFLAG_CHOICE_COMBO);
|
|
EXPECT_TRUE(flags & FPDF_FORMFLAG_CHOICE_EDIT);
|
|
}
|
|
|
|
{
|
|
// Retrieve the second annotation: regular combobox.
|
|
ScopedFPDFAnnotation annot(FPDFPage_GetAnnot(page, 1));
|
|
ASSERT_TRUE(annot);
|
|
|
|
// Check that the flag values are as expected.
|
|
int flags = FPDFAnnot_GetFormFieldFlags(form_handle(), annot.get());
|
|
EXPECT_FALSE(flags & FPDF_FORMFLAG_READONLY);
|
|
EXPECT_TRUE(flags & FPDF_FORMFLAG_CHOICE_COMBO);
|
|
EXPECT_FALSE(flags & FPDF_FORMFLAG_CHOICE_EDIT);
|
|
}
|
|
|
|
{
|
|
// Retrieve the third annotation: read-only combobox.
|
|
ScopedFPDFAnnotation annot(FPDFPage_GetAnnot(page, 2));
|
|
ASSERT_TRUE(annot);
|
|
|
|
// Check that the flag values are as expected.
|
|
int flags = FPDFAnnot_GetFormFieldFlags(form_handle(), annot.get());
|
|
EXPECT_TRUE(flags & FPDF_FORMFLAG_READONLY);
|
|
EXPECT_TRUE(flags & FPDF_FORMFLAG_CHOICE_COMBO);
|
|
EXPECT_FALSE(flags & FPDF_FORMFLAG_CHOICE_EDIT);
|
|
}
|
|
|
|
UnloadPage(page);
|
|
}
|
|
|
|
TEST_F(FPDFAnnotEmbedderTest, GetFormAnnotNull) {
|
|
// Open file with form text fields.
|
|
EXPECT_TRUE(OpenDocument("text_form.pdf"));
|
|
FPDF_PAGE page = LoadPage(0);
|
|
ASSERT_TRUE(page);
|
|
|
|
// Attempt to get an annotation where no annotation exists on page.
|
|
static const FS_POINTF kOriginPoint = {0.0f, 0.0f};
|
|
EXPECT_FALSE(
|
|
FPDFAnnot_GetFormFieldAtPoint(form_handle(), page, &kOriginPoint));
|
|
|
|
static const FS_POINTF kValidPoint = {120.0f, 120.0f};
|
|
{
|
|
// Verify there is an annotation.
|
|
ScopedFPDFAnnotation annot(
|
|
FPDFAnnot_GetFormFieldAtPoint(form_handle(), page, &kValidPoint));
|
|
EXPECT_TRUE(annot);
|
|
}
|
|
|
|
// Try other bad inputs at a valid location.
|
|
EXPECT_FALSE(FPDFAnnot_GetFormFieldAtPoint(nullptr, nullptr, &kValidPoint));
|
|
EXPECT_FALSE(FPDFAnnot_GetFormFieldAtPoint(nullptr, page, &kValidPoint));
|
|
EXPECT_FALSE(
|
|
FPDFAnnot_GetFormFieldAtPoint(form_handle(), nullptr, &kValidPoint));
|
|
|
|
UnloadPage(page);
|
|
}
|
|
|
|
TEST_F(FPDFAnnotEmbedderTest, GetFormAnnotAndCheckFlagsTextField) {
|
|
// Open file with form text fields.
|
|
EXPECT_TRUE(OpenDocument("text_form_multiple.pdf"));
|
|
FPDF_PAGE page = LoadPage(0);
|
|
ASSERT_TRUE(page);
|
|
|
|
{
|
|
// Retrieve user-editable text field annotation.
|
|
static const FS_POINTF kPoint = {105.0f, 118.0f};
|
|
ScopedFPDFAnnotation annot(
|
|
FPDFAnnot_GetFormFieldAtPoint(form_handle(), page, &kPoint));
|
|
ASSERT_TRUE(annot);
|
|
|
|
// Check that interactive form annotation flag values are as expected.
|
|
int flags = FPDFAnnot_GetFormFieldFlags(form_handle(), annot.get());
|
|
EXPECT_FALSE(flags & FPDF_FORMFLAG_READONLY);
|
|
}
|
|
|
|
{
|
|
// Retrieve read-only text field annotation.
|
|
static const FS_POINTF kPoint = {105.0f, 202.0f};
|
|
ScopedFPDFAnnotation annot(
|
|
FPDFAnnot_GetFormFieldAtPoint(form_handle(), page, &kPoint));
|
|
ASSERT_TRUE(annot);
|
|
|
|
// Check that interactive form annotation flag values are as expected.
|
|
int flags = FPDFAnnot_GetFormFieldFlags(form_handle(), annot.get());
|
|
EXPECT_TRUE(flags & FPDF_FORMFLAG_READONLY);
|
|
}
|
|
|
|
UnloadPage(page);
|
|
}
|
|
|
|
TEST_F(FPDFAnnotEmbedderTest, GetFormAnnotAndCheckFlagsComboBox) {
|
|
// Open file with form comboboxes.
|
|
EXPECT_TRUE(OpenDocument("combobox_form.pdf"));
|
|
FPDF_PAGE page = LoadPage(0);
|
|
ASSERT_TRUE(page);
|
|
|
|
{
|
|
// Retrieve user-editable combobox annotation.
|
|
static const FS_POINTF kPoint = {102.0f, 363.0f};
|
|
ScopedFPDFAnnotation annot(
|
|
FPDFAnnot_GetFormFieldAtPoint(form_handle(), page, &kPoint));
|
|
ASSERT_TRUE(annot);
|
|
|
|
// Check that interactive form annotation flag values are as expected.
|
|
int flags = FPDFAnnot_GetFormFieldFlags(form_handle(), annot.get());
|
|
EXPECT_FALSE(flags & FPDF_FORMFLAG_READONLY);
|
|
EXPECT_TRUE(flags & FPDF_FORMFLAG_CHOICE_COMBO);
|
|
EXPECT_TRUE(flags & FPDF_FORMFLAG_CHOICE_EDIT);
|
|
}
|
|
|
|
{
|
|
// Retrieve regular combobox annotation.
|
|
static const FS_POINTF kPoint = {102.0f, 413.0f};
|
|
ScopedFPDFAnnotation annot(
|
|
FPDFAnnot_GetFormFieldAtPoint(form_handle(), page, &kPoint));
|
|
ASSERT_TRUE(annot);
|
|
|
|
// Check that interactive form annotation flag values are as expected.
|
|
int flags = FPDFAnnot_GetFormFieldFlags(form_handle(), annot.get());
|
|
EXPECT_FALSE(flags & FPDF_FORMFLAG_READONLY);
|
|
EXPECT_TRUE(flags & FPDF_FORMFLAG_CHOICE_COMBO);
|
|
EXPECT_FALSE(flags & FPDF_FORMFLAG_CHOICE_EDIT);
|
|
}
|
|
|
|
{
|
|
// Retrieve read-only combobox annotation.
|
|
static const FS_POINTF kPoint = {102.0f, 513.0f};
|
|
ScopedFPDFAnnotation annot(
|
|
FPDFAnnot_GetFormFieldAtPoint(form_handle(), page, &kPoint));
|
|
ASSERT_TRUE(annot);
|
|
|
|
// Check that interactive form annotation flag values are as expected.
|
|
int flags = FPDFAnnot_GetFormFieldFlags(form_handle(), annot.get());
|
|
EXPECT_TRUE(flags & FPDF_FORMFLAG_READONLY);
|
|
EXPECT_TRUE(flags & FPDF_FORMFLAG_CHOICE_COMBO);
|
|
EXPECT_FALSE(flags & FPDF_FORMFLAG_CHOICE_EDIT);
|
|
}
|
|
|
|
UnloadPage(page);
|
|
}
|
|
|
|
// TODO(crbug.com/pdfium/11): Fix this test and enable.
|
|
#if defined(_SKIA_SUPPORT_) || defined(_SKIA_SUPPORT_PATHS_)
|
|
#define MAYBE_BUG_1206 DISABLED_BUG_1206
|
|
#else
|
|
#define MAYBE_BUG_1206 BUG_1206
|
|
#endif
|
|
TEST_F(FPDFAnnotEmbedderTest, MAYBE_BUG_1206) {
|
|
static constexpr size_t kExpectedSize = 1609;
|
|
static const char kExpectedBitmap[] = "0d9fc05c6762fd788bd23fd87a4967bc";
|
|
|
|
ASSERT_TRUE(OpenDocument("bug_1206.pdf"));
|
|
|
|
FPDF_PAGE page = LoadPage(0);
|
|
ASSERT_TRUE(page);
|
|
|
|
ASSERT_TRUE(FPDF_SaveAsCopy(document(), this, 0));
|
|
EXPECT_EQ(kExpectedSize, GetString().size());
|
|
ClearString();
|
|
|
|
for (size_t i = 0; i < 10; ++i) {
|
|
ScopedFPDFBitmap bitmap = RenderLoadedPageWithFlags(page, FPDF_ANNOT);
|
|
CompareBitmap(bitmap.get(), 612, 792, kExpectedBitmap);
|
|
|
|
ASSERT_TRUE(FPDF_SaveAsCopy(document(), this, 0));
|
|
// TODO(https://crbug.com/pdfium/1206): This is wrong. The size should be
|
|
// equal, not bigger.
|
|
EXPECT_LT(kExpectedSize, GetString().size());
|
|
ClearString();
|
|
}
|
|
|
|
UnloadPage(page);
|
|
}
|
|
|
|
TEST_F(FPDFAnnotEmbedderTest, BUG_1212) {
|
|
ASSERT_TRUE(OpenDocument("hello_world.pdf"));
|
|
FPDF_PAGE page = LoadPage(0);
|
|
ASSERT_TRUE(page);
|
|
EXPECT_EQ(0, FPDFPage_GetAnnotCount(page));
|
|
|
|
static const char kTestKey[] = "test";
|
|
static const wchar_t kData[] = L"\xf6\xe4";
|
|
static const size_t kBufSize = 12;
|
|
std::vector<FPDF_WCHAR> buf = GetFPDFWideStringBuffer(kBufSize);
|
|
|
|
{
|
|
// Add a text annotation to the page.
|
|
ScopedFPDFAnnotation annot(FPDFPage_CreateAnnot(page, FPDF_ANNOT_TEXT));
|
|
ASSERT_TRUE(annot);
|
|
EXPECT_EQ(1, FPDFPage_GetAnnotCount(page));
|
|
EXPECT_EQ(FPDF_ANNOT_TEXT, FPDFAnnot_GetSubtype(annot.get()));
|
|
|
|
// Make sure there is no test key, add set a value there, and read it back.
|
|
std::fill(buf.begin(), buf.end(), 'x');
|
|
ASSERT_EQ(2u, FPDFAnnot_GetStringValue(annot.get(), kTestKey, buf.data(),
|
|
kBufSize));
|
|
EXPECT_EQ(L"", GetPlatformWString(buf.data()));
|
|
|
|
ScopedFPDFWideString text = GetFPDFWideString(kData);
|
|
EXPECT_TRUE(FPDFAnnot_SetStringValue(annot.get(), kTestKey, text.get()));
|
|
|
|
std::fill(buf.begin(), buf.end(), 'x');
|
|
ASSERT_EQ(6u, FPDFAnnot_GetStringValue(annot.get(), kTestKey, buf.data(),
|
|
kBufSize));
|
|
EXPECT_EQ(kData, GetPlatformWString(buf.data()));
|
|
}
|
|
|
|
{
|
|
ScopedFPDFAnnotation annot(FPDFPage_CreateAnnot(page, FPDF_ANNOT_STAMP));
|
|
ASSERT_TRUE(annot);
|
|
const FS_RECTF bounding_rect{206.0f, 753.0f, 339.0f, 709.0f};
|
|
EXPECT_TRUE(FPDFAnnot_SetRect(annot.get(), &bounding_rect));
|
|
EXPECT_EQ(2, FPDFPage_GetAnnotCount(page));
|
|
EXPECT_EQ(FPDF_ANNOT_STAMP, FPDFAnnot_GetSubtype(annot.get()));
|
|
// Also do the same test for its appearance string.
|
|
std::fill(buf.begin(), buf.end(), 'x');
|
|
ASSERT_EQ(2u,
|
|
FPDFAnnot_GetAP(annot.get(), FPDF_ANNOT_APPEARANCEMODE_ROLLOVER,
|
|
buf.data(), kBufSize));
|
|
EXPECT_EQ(L"", GetPlatformWString(buf.data()));
|
|
|
|
ScopedFPDFWideString text = GetFPDFWideString(kData);
|
|
EXPECT_TRUE(FPDFAnnot_SetAP(annot.get(), FPDF_ANNOT_APPEARANCEMODE_ROLLOVER,
|
|
text.get()));
|
|
|
|
std::fill(buf.begin(), buf.end(), 'x');
|
|
ASSERT_EQ(6u,
|
|
FPDFAnnot_GetAP(annot.get(), FPDF_ANNOT_APPEARANCEMODE_ROLLOVER,
|
|
buf.data(), kBufSize));
|
|
EXPECT_EQ(kData, GetPlatformWString(buf.data()));
|
|
}
|
|
|
|
UnloadPage(page);
|
|
|
|
{
|
|
// Save a copy, open the copy, and check the annotation again.
|
|
// Note that it renders the rotation.
|
|
EXPECT_TRUE(FPDF_SaveAsCopy(document(), this, 0));
|
|
ASSERT_TRUE(OpenSavedDocument());
|
|
FPDF_PAGE saved_page = LoadSavedPage(0);
|
|
ASSERT_TRUE(saved_page);
|
|
|
|
EXPECT_EQ(2, FPDFPage_GetAnnotCount(saved_page));
|
|
{
|
|
ScopedFPDFAnnotation annot(FPDFPage_GetAnnot(saved_page, 0));
|
|
ASSERT_TRUE(annot);
|
|
EXPECT_EQ(FPDF_ANNOT_TEXT, FPDFAnnot_GetSubtype(annot.get()));
|
|
|
|
std::fill(buf.begin(), buf.end(), 'x');
|
|
ASSERT_EQ(6u, FPDFAnnot_GetStringValue(annot.get(), kTestKey, buf.data(),
|
|
kBufSize));
|
|
EXPECT_EQ(kData, GetPlatformWString(buf.data()));
|
|
}
|
|
|
|
{
|
|
ScopedFPDFAnnotation annot(FPDFPage_GetAnnot(saved_page, 0));
|
|
ASSERT_TRUE(annot);
|
|
// TODO(thestig): This return FPDF_ANNOT_UNKNOWN for some reason.
|
|
// EXPECT_EQ(FPDF_ANNOT_TEXT, FPDFAnnot_GetSubtype(annot.get()));
|
|
|
|
std::fill(buf.begin(), buf.end(), 'x');
|
|
ASSERT_EQ(6u, FPDFAnnot_GetStringValue(annot.get(), kTestKey, buf.data(),
|
|
kBufSize));
|
|
EXPECT_EQ(kData, GetPlatformWString(buf.data()));
|
|
}
|
|
|
|
CloseSavedPage(saved_page);
|
|
CloseSavedDocument();
|
|
}
|
|
}
|
|
|
|
TEST_F(FPDFAnnotEmbedderTest, GetOptionCountCombobox) {
|
|
// Open a file with combobox widget annotations and load its first page.
|
|
ASSERT_TRUE(OpenDocument("combobox_form.pdf"));
|
|
FPDF_PAGE page = LoadPage(0);
|
|
ASSERT_TRUE(page);
|
|
|
|
{
|
|
ScopedFPDFAnnotation annot(FPDFPage_GetAnnot(page, 0));
|
|
ASSERT_TRUE(annot);
|
|
|
|
EXPECT_EQ(3, FPDFAnnot_GetOptionCount(form_handle(), annot.get()));
|
|
|
|
annot.reset(FPDFPage_GetAnnot(page, 1));
|
|
ASSERT_TRUE(annot);
|
|
|
|
EXPECT_EQ(26, FPDFAnnot_GetOptionCount(form_handle(), annot.get()));
|
|
|
|
// Check bad form handle / annot.
|
|
EXPECT_EQ(-1, FPDFAnnot_GetOptionCount(nullptr, nullptr));
|
|
EXPECT_EQ(-1, FPDFAnnot_GetOptionCount(form_handle(), nullptr));
|
|
EXPECT_EQ(-1, FPDFAnnot_GetOptionCount(nullptr, annot.get()));
|
|
}
|
|
|
|
UnloadPage(page);
|
|
}
|
|
|
|
TEST_F(FPDFAnnotEmbedderTest, GetOptionCountListbox) {
|
|
// Open a file with listbox widget annotations and load its first page.
|
|
ASSERT_TRUE(OpenDocument("listbox_form.pdf"));
|
|
FPDF_PAGE page = LoadPage(0);
|
|
ASSERT_TRUE(page);
|
|
|
|
{
|
|
ScopedFPDFAnnotation annot(FPDFPage_GetAnnot(page, 0));
|
|
ASSERT_TRUE(annot);
|
|
|
|
EXPECT_EQ(3, FPDFAnnot_GetOptionCount(form_handle(), annot.get()));
|
|
|
|
annot.reset(FPDFPage_GetAnnot(page, 1));
|
|
ASSERT_TRUE(annot);
|
|
|
|
EXPECT_EQ(26, FPDFAnnot_GetOptionCount(form_handle(), annot.get()));
|
|
}
|
|
|
|
UnloadPage(page);
|
|
}
|
|
|
|
TEST_F(FPDFAnnotEmbedderTest, GetOptionCountInvalidAnnotations) {
|
|
// Open a file with ink annotations and load its first page.
|
|
ASSERT_TRUE(OpenDocument("annotation_ink_multiple.pdf"));
|
|
FPDF_PAGE page = LoadPage(0);
|
|
ASSERT_TRUE(page);
|
|
|
|
{
|
|
// annotations do not have "Opt" array and will return -1
|
|
ScopedFPDFAnnotation annot(FPDFPage_GetAnnot(page, 0));
|
|
ASSERT_TRUE(annot);
|
|
|
|
EXPECT_EQ(-1, FPDFAnnot_GetOptionCount(form_handle(), annot.get()));
|
|
|
|
annot.reset(FPDFPage_GetAnnot(page, 1));
|
|
ASSERT_TRUE(annot);
|
|
|
|
EXPECT_EQ(-1, FPDFAnnot_GetOptionCount(form_handle(), annot.get()));
|
|
}
|
|
|
|
UnloadPage(page);
|
|
}
|
|
|
|
TEST_F(FPDFAnnotEmbedderTest, GetOptionLabelCombobox) {
|
|
// Open a file with combobox widget annotations and load its first page.
|
|
ASSERT_TRUE(OpenDocument("combobox_form.pdf"));
|
|
FPDF_PAGE page = LoadPage(0);
|
|
ASSERT_TRUE(page);
|
|
|
|
{
|
|
ScopedFPDFAnnotation annot(FPDFPage_GetAnnot(page, 0));
|
|
ASSERT_TRUE(annot);
|
|
|
|
int index = 0;
|
|
unsigned long length_bytes =
|
|
FPDFAnnot_GetOptionLabel(form_handle(), annot.get(), index, nullptr, 0);
|
|
ASSERT_EQ(8u, length_bytes);
|
|
std::vector<FPDF_WCHAR> buf = GetFPDFWideStringBuffer(length_bytes);
|
|
EXPECT_EQ(8u, FPDFAnnot_GetOptionLabel(form_handle(), annot.get(), index,
|
|
buf.data(), length_bytes));
|
|
EXPECT_EQ(L"Foo", GetPlatformWString(buf.data()));
|
|
|
|
annot.reset(FPDFPage_GetAnnot(page, 1));
|
|
ASSERT_TRUE(annot);
|
|
|
|
index = 0;
|
|
length_bytes =
|
|
FPDFAnnot_GetOptionLabel(form_handle(), annot.get(), index, nullptr, 0);
|
|
ASSERT_EQ(12u, length_bytes);
|
|
buf = GetFPDFWideStringBuffer(length_bytes);
|
|
EXPECT_EQ(12u, FPDFAnnot_GetOptionLabel(form_handle(), annot.get(), index,
|
|
buf.data(), length_bytes));
|
|
EXPECT_EQ(L"Apple", GetPlatformWString(buf.data()));
|
|
|
|
index = 25;
|
|
length_bytes =
|
|
FPDFAnnot_GetOptionLabel(form_handle(), annot.get(), index, nullptr, 0);
|
|
buf = GetFPDFWideStringBuffer(length_bytes);
|
|
EXPECT_EQ(18u, FPDFAnnot_GetOptionLabel(form_handle(), annot.get(), index,
|
|
buf.data(), length_bytes));
|
|
EXPECT_EQ(L"Zucchini", GetPlatformWString(buf.data()));
|
|
|
|
// Indices out of range
|
|
EXPECT_EQ(0u, FPDFAnnot_GetOptionLabel(form_handle(), annot.get(), -1,
|
|
nullptr, 0));
|
|
EXPECT_EQ(0u, FPDFAnnot_GetOptionLabel(form_handle(), annot.get(), 26,
|
|
nullptr, 0));
|
|
|
|
// Check bad form handle / annot.
|
|
EXPECT_EQ(0u, FPDFAnnot_GetOptionLabel(nullptr, nullptr, 0, nullptr, 0));
|
|
EXPECT_EQ(0u,
|
|
FPDFAnnot_GetOptionLabel(nullptr, annot.get(), 0, nullptr, 0));
|
|
EXPECT_EQ(0u,
|
|
FPDFAnnot_GetOptionLabel(form_handle(), nullptr, 0, nullptr, 0));
|
|
}
|
|
|
|
UnloadPage(page);
|
|
}
|
|
|
|
TEST_F(FPDFAnnotEmbedderTest, GetOptionLabelListbox) {
|
|
// Open a file with listbox widget annotations and load its first page.
|
|
ASSERT_TRUE(OpenDocument("listbox_form.pdf"));
|
|
FPDF_PAGE page = LoadPage(0);
|
|
ASSERT_TRUE(page);
|
|
|
|
{
|
|
ScopedFPDFAnnotation annot(FPDFPage_GetAnnot(page, 0));
|
|
ASSERT_TRUE(annot);
|
|
|
|
int index = 0;
|
|
unsigned long length_bytes =
|
|
FPDFAnnot_GetOptionLabel(form_handle(), annot.get(), index, nullptr, 0);
|
|
ASSERT_EQ(8u, length_bytes);
|
|
std::vector<FPDF_WCHAR> buf = GetFPDFWideStringBuffer(length_bytes);
|
|
EXPECT_EQ(8u, FPDFAnnot_GetOptionLabel(form_handle(), annot.get(), index,
|
|
buf.data(), length_bytes));
|
|
EXPECT_EQ(L"Foo", GetPlatformWString(buf.data()));
|
|
|
|
annot.reset(FPDFPage_GetAnnot(page, 1));
|
|
ASSERT_TRUE(annot);
|
|
|
|
index = 0;
|
|
length_bytes =
|
|
FPDFAnnot_GetOptionLabel(form_handle(), annot.get(), index, nullptr, 0);
|
|
ASSERT_EQ(12u, length_bytes);
|
|
buf = GetFPDFWideStringBuffer(length_bytes);
|
|
EXPECT_EQ(12u, FPDFAnnot_GetOptionLabel(form_handle(), annot.get(), index,
|
|
buf.data(), length_bytes));
|
|
EXPECT_EQ(L"Apple", GetPlatformWString(buf.data()));
|
|
|
|
index = 25;
|
|
length_bytes =
|
|
FPDFAnnot_GetOptionLabel(form_handle(), annot.get(), index, nullptr, 0);
|
|
ASSERT_EQ(18u, length_bytes);
|
|
buf = GetFPDFWideStringBuffer(length_bytes);
|
|
EXPECT_EQ(18u, FPDFAnnot_GetOptionLabel(form_handle(), annot.get(), index,
|
|
buf.data(), length_bytes));
|
|
EXPECT_EQ(L"Zucchini", GetPlatformWString(buf.data()));
|
|
|
|
// indices out of range
|
|
EXPECT_EQ(0u, FPDFAnnot_GetOptionLabel(form_handle(), annot.get(), -1,
|
|
nullptr, 0));
|
|
EXPECT_EQ(0u, FPDFAnnot_GetOptionLabel(form_handle(), annot.get(), 26,
|
|
nullptr, 0));
|
|
}
|
|
|
|
UnloadPage(page);
|
|
}
|
|
|
|
TEST_F(FPDFAnnotEmbedderTest, GetOptionLabelInvalidAnnotations) {
|
|
// Open a file with ink annotations and load its first page.
|
|
ASSERT_TRUE(OpenDocument("annotation_ink_multiple.pdf"));
|
|
FPDF_PAGE page = LoadPage(0);
|
|
ASSERT_TRUE(page);
|
|
|
|
{
|
|
// annotations do not have "Opt" array and will return 0
|
|
ScopedFPDFAnnotation annot(FPDFPage_GetAnnot(page, 0));
|
|
ASSERT_TRUE(annot);
|
|
|
|
EXPECT_EQ(0u, FPDFAnnot_GetOptionLabel(form_handle(), annot.get(), 0,
|
|
nullptr, 0));
|
|
|
|
annot.reset(FPDFPage_GetAnnot(page, 1));
|
|
ASSERT_TRUE(annot);
|
|
|
|
EXPECT_EQ(0u, FPDFAnnot_GetOptionLabel(form_handle(), annot.get(), 0,
|
|
nullptr, 0));
|
|
}
|
|
|
|
UnloadPage(page);
|
|
}
|
|
|
|
TEST_F(FPDFAnnotEmbedderTest, GetFontSizeCombobox) {
|
|
// Open a file with combobox annotations and load its first page.
|
|
ASSERT_TRUE(OpenDocument("combobox_form.pdf"));
|
|
FPDF_PAGE page = LoadPage(0);
|
|
ASSERT_TRUE(page);
|
|
|
|
{
|
|
// All 3 widgets have Tf font size 12.
|
|
ScopedFPDFAnnotation annot(FPDFPage_GetAnnot(page, 0));
|
|
ASSERT_TRUE(annot);
|
|
|
|
float value;
|
|
ASSERT_TRUE(FPDFAnnot_GetFontSize(form_handle(), annot.get(), &value));
|
|
EXPECT_EQ(12.0, value);
|
|
|
|
annot.reset(FPDFPage_GetAnnot(page, 1));
|
|
ASSERT_TRUE(annot);
|
|
|
|
float value_two;
|
|
ASSERT_TRUE(FPDFAnnot_GetFontSize(form_handle(), annot.get(), &value_two));
|
|
EXPECT_EQ(12.0, value_two);
|
|
|
|
annot.reset(FPDFPage_GetAnnot(page, 2));
|
|
ASSERT_TRUE(annot);
|
|
|
|
float value_three;
|
|
ASSERT_TRUE(
|
|
FPDFAnnot_GetFontSize(form_handle(), annot.get(), &value_three));
|
|
EXPECT_EQ(12.0, value_three);
|
|
}
|
|
|
|
UnloadPage(page);
|
|
}
|
|
|
|
TEST_F(FPDFAnnotEmbedderTest, GetFontSizeTextField) {
|
|
// Open a file with textfield annotations and load its first page.
|
|
ASSERT_TRUE(OpenDocument("text_form_multiple.pdf"));
|
|
FPDF_PAGE page = LoadPage(0);
|
|
ASSERT_TRUE(page);
|
|
|
|
{
|
|
// All 4 widgets have Tf font size 12.
|
|
ScopedFPDFAnnotation annot(FPDFPage_GetAnnot(page, 0));
|
|
ASSERT_TRUE(annot);
|
|
|
|
float value;
|
|
ASSERT_TRUE(FPDFAnnot_GetFontSize(form_handle(), annot.get(), &value));
|
|
EXPECT_EQ(12.0, value);
|
|
|
|
annot.reset(FPDFPage_GetAnnot(page, 1));
|
|
ASSERT_TRUE(annot);
|
|
|
|
float value_two;
|
|
ASSERT_TRUE(FPDFAnnot_GetFontSize(form_handle(), annot.get(), &value_two));
|
|
EXPECT_EQ(12.0, value_two);
|
|
|
|
annot.reset(FPDFPage_GetAnnot(page, 2));
|
|
ASSERT_TRUE(annot);
|
|
|
|
float value_three;
|
|
ASSERT_TRUE(
|
|
FPDFAnnot_GetFontSize(form_handle(), annot.get(), &value_three));
|
|
EXPECT_EQ(12.0, value_three);
|
|
|
|
float value_four;
|
|
ASSERT_TRUE(FPDFAnnot_GetFontSize(form_handle(), annot.get(), &value_four));
|
|
EXPECT_EQ(12.0, value_four);
|
|
}
|
|
|
|
UnloadPage(page);
|
|
}
|
|
|
|
TEST_F(FPDFAnnotEmbedderTest, GetFontSizeInvalidAnnotationTypes) {
|
|
// Open a file with ink annotations and load its first page.
|
|
ASSERT_TRUE(OpenDocument("annotation_ink_multiple.pdf"));
|
|
FPDF_PAGE page = LoadPage(0);
|
|
ASSERT_TRUE(page);
|
|
|
|
{
|
|
// Annotations that do not have variable text and will return -1.
|
|
ScopedFPDFAnnotation annot(FPDFPage_GetAnnot(page, 0));
|
|
ASSERT_TRUE(annot);
|
|
|
|
float value;
|
|
ASSERT_FALSE(FPDFAnnot_GetFontSize(form_handle(), annot.get(), &value));
|
|
|
|
annot.reset(FPDFPage_GetAnnot(page, 1));
|
|
ASSERT_TRUE(annot);
|
|
|
|
ASSERT_FALSE(FPDFAnnot_GetFontSize(form_handle(), annot.get(), &value));
|
|
}
|
|
|
|
UnloadPage(page);
|
|
}
|
|
|
|
TEST_F(FPDFAnnotEmbedderTest, GetFontSizeInvalidArguments) {
|
|
// Open a file with combobox annotations and load its first page.
|
|
ASSERT_TRUE(OpenDocument("combobox_form.pdf"));
|
|
FPDF_PAGE page = LoadPage(0);
|
|
ASSERT_TRUE(page);
|
|
|
|
{
|
|
ScopedFPDFAnnotation annot(FPDFPage_GetAnnot(page, 0));
|
|
ASSERT_TRUE(annot);
|
|
|
|
// Check bad form handle / annot.
|
|
float value;
|
|
ASSERT_FALSE(FPDFAnnot_GetFontSize(nullptr, annot.get(), &value));
|
|
ASSERT_FALSE(FPDFAnnot_GetFontSize(form_handle(), nullptr, &value));
|
|
ASSERT_FALSE(FPDFAnnot_GetFontSize(nullptr, nullptr, &value));
|
|
}
|
|
|
|
UnloadPage(page);
|
|
}
|
|
|
|
TEST_F(FPDFAnnotEmbedderTest, GetFontSizeNegative) {
|
|
// Open a file with textfield annotations and load its first page.
|
|
ASSERT_TRUE(OpenDocument("text_form_negative_fontsize.pdf"));
|
|
FPDF_PAGE page = LoadPage(0);
|
|
ASSERT_TRUE(page);
|
|
|
|
{
|
|
// Obtain the first annotation, a text field with negative font size, -12.
|
|
ScopedFPDFAnnotation annot(FPDFPage_GetAnnot(page, 0));
|
|
ASSERT_TRUE(annot);
|
|
|
|
float value;
|
|
ASSERT_TRUE(FPDFAnnot_GetFontSize(form_handle(), annot.get(), &value));
|
|
EXPECT_EQ(-12.0, value);
|
|
}
|
|
|
|
UnloadPage(page);
|
|
}
|
|
|
|
TEST_F(FPDFAnnotEmbedderTest, IsCheckedCheckbox) {
|
|
// Open a file with checkbox and radiobuttons widget annotations and load its
|
|
// first page.
|
|
ASSERT_TRUE(OpenDocument("click_form.pdf"));
|
|
FPDF_PAGE page = LoadPage(0);
|
|
ASSERT_TRUE(page);
|
|
|
|
{
|
|
ScopedFPDFAnnotation annot(FPDFPage_GetAnnot(page, 1));
|
|
ASSERT_TRUE(annot);
|
|
ASSERT_FALSE(FPDFAnnot_IsChecked(form_handle(), annot.get()));
|
|
}
|
|
|
|
UnloadPage(page);
|
|
}
|
|
|
|
TEST_F(FPDFAnnotEmbedderTest, IsCheckedCheckboxReadOnly) {
|
|
// Open a file with checkbox and radiobutton widget annotations and load its
|
|
// first page.
|
|
ASSERT_TRUE(OpenDocument("click_form.pdf"));
|
|
FPDF_PAGE page = LoadPage(0);
|
|
ASSERT_TRUE(page);
|
|
|
|
{
|
|
ScopedFPDFAnnotation annot(FPDFPage_GetAnnot(page, 0));
|
|
ASSERT_TRUE(annot);
|
|
ASSERT_TRUE(FPDFAnnot_IsChecked(form_handle(), annot.get()));
|
|
}
|
|
|
|
UnloadPage(page);
|
|
}
|
|
|
|
TEST_F(FPDFAnnotEmbedderTest, IsCheckedRadioButton) {
|
|
// Open a file with checkbox and radiobutton widget annotations and load its
|
|
// first page.
|
|
ASSERT_TRUE(OpenDocument("click_form.pdf"));
|
|
FPDF_PAGE page = LoadPage(0);
|
|
ASSERT_TRUE(page);
|
|
|
|
{
|
|
ScopedFPDFAnnotation annot(FPDFPage_GetAnnot(page, 5));
|
|
ASSERT_TRUE(annot);
|
|
ASSERT_FALSE(FPDFAnnot_IsChecked(form_handle(), annot.get()));
|
|
|
|
annot.reset(FPDFPage_GetAnnot(page, 6));
|
|
ASSERT_FALSE(FPDFAnnot_IsChecked(form_handle(), annot.get()));
|
|
|
|
annot.reset(FPDFPage_GetAnnot(page, 7));
|
|
ASSERT_TRUE(FPDFAnnot_IsChecked(form_handle(), annot.get()));
|
|
}
|
|
|
|
UnloadPage(page);
|
|
}
|
|
|
|
TEST_F(FPDFAnnotEmbedderTest, IsCheckedRadioButtonReadOnly) {
|
|
// Open a file with checkbox and radiobutton widget annotations and load its
|
|
// first page.
|
|
ASSERT_TRUE(OpenDocument("click_form.pdf"));
|
|
FPDF_PAGE page = LoadPage(0);
|
|
ASSERT_TRUE(page);
|
|
|
|
{
|
|
ScopedFPDFAnnotation annot(FPDFPage_GetAnnot(page, 2));
|
|
ASSERT_TRUE(annot);
|
|
ASSERT_FALSE(FPDFAnnot_IsChecked(form_handle(), annot.get()));
|
|
|
|
annot.reset(FPDFPage_GetAnnot(page, 3));
|
|
ASSERT_FALSE(FPDFAnnot_IsChecked(form_handle(), annot.get()));
|
|
|
|
annot.reset(FPDFPage_GetAnnot(page, 4));
|
|
ASSERT_TRUE(FPDFAnnot_IsChecked(form_handle(), annot.get()));
|
|
}
|
|
|
|
UnloadPage(page);
|
|
}
|
|
|
|
TEST_F(FPDFAnnotEmbedderTest, IsCheckedInvalidArguments) {
|
|
// Open a file with checkbox and radiobuttons widget annotations and load its
|
|
// first page.
|
|
ASSERT_TRUE(OpenDocument("click_form.pdf"));
|
|
FPDF_PAGE page = LoadPage(0);
|
|
ASSERT_TRUE(page);
|
|
|
|
{
|
|
ScopedFPDFAnnotation annot(FPDFPage_GetAnnot(page, 0));
|
|
ASSERT_TRUE(annot);
|
|
ASSERT_FALSE(FPDFAnnot_IsChecked(nullptr, annot.get()));
|
|
ASSERT_FALSE(FPDFAnnot_IsChecked(form_handle(), nullptr));
|
|
ASSERT_FALSE(FPDFAnnot_IsChecked(nullptr, nullptr));
|
|
}
|
|
|
|
UnloadPage(page);
|
|
}
|
|
|
|
TEST_F(FPDFAnnotEmbedderTest, IsCheckedInvalidWidgetType) {
|
|
// Open a file with text widget annotations and load its first page.
|
|
ASSERT_TRUE(OpenDocument("text_form.pdf"));
|
|
FPDF_PAGE page = LoadPage(0);
|
|
ASSERT_TRUE(page);
|
|
|
|
{
|
|
ScopedFPDFAnnotation annot(FPDFPage_GetAnnot(page, 0));
|
|
ASSERT_TRUE(annot);
|
|
ASSERT_FALSE(FPDFAnnot_IsChecked(form_handle(), annot.get()));
|
|
}
|
|
|
|
UnloadPage(page);
|
|
}
|
|
|
|
TEST_F(FPDFAnnotEmbedderTest, GetFormFieldTypeTextField) {
|
|
ASSERT_TRUE(OpenDocument("text_form.pdf"));
|
|
FPDF_PAGE page = LoadPage(0);
|
|
ASSERT_TRUE(page);
|
|
|
|
{
|
|
EXPECT_EQ(-1, FPDFAnnot_GetFormFieldType(form_handle(), nullptr));
|
|
|
|
ScopedFPDFAnnotation annot(FPDFPage_GetAnnot(page, 0));
|
|
ASSERT_TRUE(annot);
|
|
|
|
EXPECT_EQ(-1, FPDFAnnot_GetFormFieldType(nullptr, annot.get()));
|
|
|
|
EXPECT_EQ(FPDF_FORMFIELD_TEXTFIELD,
|
|
FPDFAnnot_GetFormFieldType(form_handle(), annot.get()));
|
|
}
|
|
UnloadPage(page);
|
|
}
|
|
|
|
TEST_F(FPDFAnnotEmbedderTest, GetFormFieldTypeComboBox) {
|
|
ASSERT_TRUE(OpenDocument("combobox_form.pdf"));
|
|
FPDF_PAGE page = LoadPage(0);
|
|
ASSERT_TRUE(page);
|
|
|
|
{
|
|
ScopedFPDFAnnotation annot(FPDFPage_GetAnnot(page, 0));
|
|
ASSERT_TRUE(annot);
|
|
EXPECT_EQ(FPDF_FORMFIELD_COMBOBOX,
|
|
FPDFAnnot_GetFormFieldType(form_handle(), annot.get()));
|
|
}
|
|
UnloadPage(page);
|
|
}
|
|
|
|
TEST_F(FPDFAnnotEmbedderTest, GetFormFieldValueTextField) {
|
|
ASSERT_TRUE(OpenDocument("text_form_multiple.pdf"));
|
|
FPDF_PAGE page = LoadPage(0);
|
|
ASSERT_TRUE(page);
|
|
|
|
{
|
|
EXPECT_EQ(0u,
|
|
FPDFAnnot_GetFormFieldValue(form_handle(), nullptr, nullptr, 0));
|
|
|
|
ScopedFPDFAnnotation annot(FPDFPage_GetAnnot(page, 0));
|
|
ASSERT_TRUE(annot);
|
|
|
|
EXPECT_EQ(0u,
|
|
FPDFAnnot_GetFormFieldValue(nullptr, annot.get(), nullptr, 0));
|
|
|
|
unsigned long length_bytes =
|
|
FPDFAnnot_GetFormFieldValue(form_handle(), annot.get(), nullptr, 0);
|
|
ASSERT_EQ(2u, length_bytes);
|
|
std::vector<FPDF_WCHAR> buf = GetFPDFWideStringBuffer(length_bytes);
|
|
EXPECT_EQ(2u, FPDFAnnot_GetFormFieldValue(form_handle(), annot.get(),
|
|
buf.data(), length_bytes));
|
|
EXPECT_EQ(L"", GetPlatformWString(buf.data()));
|
|
}
|
|
{
|
|
ScopedFPDFAnnotation annot(FPDFPage_GetAnnot(page, 2));
|
|
ASSERT_TRUE(annot);
|
|
|
|
unsigned long length_bytes =
|
|
FPDFAnnot_GetFormFieldValue(form_handle(), annot.get(), nullptr, 0);
|
|
ASSERT_EQ(18u, length_bytes);
|
|
std::vector<FPDF_WCHAR> buf = GetFPDFWideStringBuffer(length_bytes);
|
|
EXPECT_EQ(18u, FPDFAnnot_GetFormFieldValue(form_handle(), annot.get(),
|
|
buf.data(), length_bytes));
|
|
EXPECT_EQ(L"Elephant", GetPlatformWString(buf.data()));
|
|
}
|
|
UnloadPage(page);
|
|
}
|
|
|
|
TEST_F(FPDFAnnotEmbedderTest, GetFormFieldValueComboBox) {
|
|
ASSERT_TRUE(OpenDocument("combobox_form.pdf"));
|
|
FPDF_PAGE page = LoadPage(0);
|
|
ASSERT_TRUE(page);
|
|
|
|
{
|
|
ScopedFPDFAnnotation annot(FPDFPage_GetAnnot(page, 0));
|
|
ASSERT_TRUE(annot);
|
|
|
|
unsigned long length_bytes =
|
|
FPDFAnnot_GetFormFieldValue(form_handle(), annot.get(), nullptr, 0);
|
|
ASSERT_EQ(2u, length_bytes);
|
|
std::vector<FPDF_WCHAR> buf = GetFPDFWideStringBuffer(length_bytes);
|
|
EXPECT_EQ(2u, FPDFAnnot_GetFormFieldValue(form_handle(), annot.get(),
|
|
buf.data(), length_bytes));
|
|
EXPECT_EQ(L"", GetPlatformWString(buf.data()));
|
|
}
|
|
{
|
|
ScopedFPDFAnnotation annot(FPDFPage_GetAnnot(page, 1));
|
|
ASSERT_TRUE(annot);
|
|
|
|
unsigned long length_bytes =
|
|
FPDFAnnot_GetFormFieldValue(form_handle(), annot.get(), nullptr, 0);
|
|
ASSERT_EQ(14u, length_bytes);
|
|
std::vector<FPDF_WCHAR> buf = GetFPDFWideStringBuffer(length_bytes);
|
|
EXPECT_EQ(14u, FPDFAnnot_GetFormFieldValue(form_handle(), annot.get(),
|
|
buf.data(), length_bytes));
|
|
EXPECT_EQ(L"Banana", GetPlatformWString(buf.data()));
|
|
}
|
|
UnloadPage(page);
|
|
}
|
|
|
|
TEST_F(FPDFAnnotEmbedderTest, GetFormFieldNameTextField) {
|
|
ASSERT_TRUE(OpenDocument("text_form.pdf"));
|
|
FPDF_PAGE page = LoadPage(0);
|
|
ASSERT_TRUE(page);
|
|
|
|
{
|
|
EXPECT_EQ(0u,
|
|
FPDFAnnot_GetFormFieldName(form_handle(), nullptr, nullptr, 0));
|
|
|
|
ScopedFPDFAnnotation annot(FPDFPage_GetAnnot(page, 0));
|
|
ASSERT_TRUE(annot);
|
|
|
|
EXPECT_EQ(0u, FPDFAnnot_GetFormFieldName(nullptr, annot.get(), nullptr, 0));
|
|
|
|
unsigned long length_bytes =
|
|
FPDFAnnot_GetFormFieldName(form_handle(), annot.get(), nullptr, 0);
|
|
ASSERT_EQ(18u, length_bytes);
|
|
std::vector<FPDF_WCHAR> buf = GetFPDFWideStringBuffer(length_bytes);
|
|
EXPECT_EQ(18u, FPDFAnnot_GetFormFieldName(form_handle(), annot.get(),
|
|
buf.data(), length_bytes));
|
|
EXPECT_EQ(L"Text Box", GetPlatformWString(buf.data()));
|
|
}
|
|
UnloadPage(page);
|
|
}
|
|
|
|
TEST_F(FPDFAnnotEmbedderTest, GetFormFieldNameComboBox) {
|
|
ASSERT_TRUE(OpenDocument("combobox_form.pdf"));
|
|
FPDF_PAGE page = LoadPage(0);
|
|
ASSERT_TRUE(page);
|
|
|
|
{
|
|
ScopedFPDFAnnotation annot(FPDFPage_GetAnnot(page, 0));
|
|
ASSERT_TRUE(annot);
|
|
|
|
unsigned long length_bytes =
|
|
FPDFAnnot_GetFormFieldName(form_handle(), annot.get(), nullptr, 0);
|
|
ASSERT_EQ(30u, length_bytes);
|
|
std::vector<FPDF_WCHAR> buf = GetFPDFWideStringBuffer(length_bytes);
|
|
EXPECT_EQ(30u, FPDFAnnot_GetFormFieldName(form_handle(), annot.get(),
|
|
buf.data(), length_bytes));
|
|
EXPECT_EQ(L"Combo_Editable", GetPlatformWString(buf.data()));
|
|
}
|
|
UnloadPage(page);
|
|
}
|