TEST_F(FPDFViewEmbeddertest, Page) {
  EXPECT_TRUE(OpenDocument("about_blank.pdf"));
  FPDF_PAGE page = LoadPage(0);
  EXPECT_NE(nullptr, page);
  EXPECT_EQ(612.0, FPDF_GetPageWidth(page));
  EXPECT_EQ(792.0, FPDF_GetPageHeight(page));
  UnloadPage(page);
  EXPECT_EQ(nullptr, LoadPage(1));
}

Status FillPersistentMemory(Reference reference, int count, byte data)
{
    Status result = OK;
    int pageIndex = reference / FLASH_PAGE_SIZE;
    int pageOffset = pageIndex * FLASH_PAGE_SIZE;
    Reference pageBase = pageOffset;
    int workIndex = reference - pageOffset;

    while ((result == OK) && (count > 0))
    {
        int i;
        int end = workIndex + count;
        if (end > FLASH_PAGE_SIZE)
        {
            end = FLASH_PAGE_SIZE;
        }
        LoadPage(pageBase);
        for (i = workIndex; i < end; ++i)
        {
            workMemory[i] = data;
        }
        result = StorePage(pageBase);
        workIndex = 0;
        pageBase += FLASH_PAGE_SIZE;
        count -= end - workIndex;
    }
    return result;
}

void CGUIManager::PushPage(const CStrW& pageName, shared_ptr<ScriptInterface::StructuredClone> initData)
{
	m_PageStack.push_back(SGUIPage());
	m_PageStack.back().name = pageName;
	m_PageStack.back().initData = initData;
	LoadPage(m_PageStack.back());
}

int OGRESRIFeatureServiceDataset::LoadNextPage()
{
    if( !poCurrent->HasOtherPages() )
        return FALSE;
    nLastOffset += poCurrent->GetLayer(0)->GetFeatureCount();
    return LoadPage();
}

Status WritePage(Reference pageBase, int index, int length, void* buffer, int* written)
{
    LoadPage(pageBase);
    *written = (index + length <= FLASH_PAGE_SIZE) ? length : FLASH_PAGE_SIZE - index;
    ModifyPageData(index, *written, buffer);
    return StorePage(pageBase);
}

TEST_F(FPDFParserEmbeddertest, Bug_481363) {
  // Test colorspace object with malformed dictionary.
  EXPECT_TRUE(OpenDocument("testing/resources/bug_481363.pdf"));
  FPDF_PAGE page = LoadPage(0);
  EXPECT_NE(nullptr, page);
  UnloadPage(page);
}

SceneryPage* SceneryZone::GetOrCreatePage(const SceneryPageKey& key)
{
	PAGEMAP::iterator it = mPages.find(key);
	if(it != mPages.end())
		return &it->second;

	return LoadPage(key);
}

//---------------------------------------------------------------------------
void GUI_Main_HTML::GUI_Refresh()
{
    std::string Temp(wxConvUTF8.cWX2MB(C->Inform_Get().c_str()));
    wxFileSystem::AddHandler(new wxMemoryFSHandler);
    wxMemoryFSHandler::AddFile(__T("index.html"), Temp.c_str(), Temp.size());
    LoadPage(__T("memory:index.html"));
    wxMemoryFSHandler::RemoveFile(__T("index.html"));
}

WebPageWindow::WebPageWindow(QString givenUrl,QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::WebPageWindow)
{
    m_pUrl = new QUrl(givenUrl); 
    this->Init();
    LoadPage();
}

/// Retrieve BLOB from storage
TThinMIn TPgBlob::Get(const TPgBlobPt& Pt) {
    char* Pg = LoadPage(Pt);
    TPgBlobPageItem* Item = GetItemRec(Pg, Pt.GetIIx());
    char* Data;
    int Len = Item->Len;
    GetItem(Pg, Pt.GetIIx(), &Data, Len);
    return TThinMIn(Data, Len);
}

TEST_F(FXGETextEmbedderTest, BadItalic) {
  // Shouldn't crash.
  EXPECT_TRUE(OpenDocument("bug_601362.pdf"));
  FPDF_PAGE page = LoadPage(0);
  EXPECT_NE(nullptr, page);
  FPDF_BITMAP bitmap = RenderPage(page);
  FPDFBitmap_Destroy(bitmap);
  UnloadPage(page);
}

TEST_F(FXCodecEmbeddertest, Bug_631912) {
  // Test jbig2 image in PDF file can be loaded successfully.
  // Should not crash.
  EXPECT_TRUE(OpenDocument("bug_631912.pdf"));
  FPDF_PAGE page = LoadPage(0);
  EXPECT_NE(nullptr, page);
  FPDF_BITMAP bitmap = RenderPage(page);
  FPDFBitmap_Destroy(bitmap);
  UnloadPage(page);
}

TEST_F(FPDFRenderLoadImageEmbeddertest, Bug_557223) {
  // Should not crash
  EXPECT_TRUE(OpenDocument("bug_557223.pdf"));
  FPDF_PAGE page = LoadPage(0);
  EXPECT_NE(nullptr, page);
  FPDF_BITMAP bitmap = RenderPage(page);
  CompareBitmap(bitmap, 24, 24, "dc0ea1b743c2edb22c597cadc8537f7b");
  FPDFBitmap_Destroy(bitmap);
  UnloadPage(page);
}

/// Create new page and return pointers to it
void TPgBlob::CreateNewPage(TPgBlobPgPt& Pt, char** Bf) {
    // determine if last file is empty
    if (Files.Len() > 0) {
        // try to add to last file
        long Pg = Files.Last()->CreateNewPage();
        if (Pg >= 0) {
            Pt.Set(Files.Len() - 1, (uint32)Pg);
            *Bf = LoadPage(Pt, false);
            InitPageP(*Bf);
            return;
        }
    }
    TStr NewFNm = FNm + ".bin" + TStr::GetNrNumFExt(Files.Len());
    Files.Add(TPgBlobFile::New(NewFNm, TFAccess::faCreate, MxBlobFLen));
    long Pg = Files.Last()->CreateNewPage();
    EAssert(Pg >= 0);
    Pt.Set(Files.Len() - 1, (uint32)Pg);
    *Bf = LoadPage(Pt, false);
    InitPageP(*Bf);
}

int OGRESRIFeatureServiceDataset::ResetReading()
{
    if( nLastOffset > nFirstOffset )
    {
        nLastOffset = nFirstOffset;
        return LoadPage();
    }

    poCurrent->GetLayer(0)->ResetReading();
    return TRUE;
}

// Test that the page has characters despite a bad stream length.
TEST_F(FPDFTextEmbeddertest, StreamLengthPastEndOfFile) {
  EXPECT_TRUE(OpenDocument("testing/resources/bug_57.pdf"));
  FPDF_PAGE page = LoadPage(0);
  EXPECT_NE(nullptr, page);

  FPDF_TEXTPAGE textpage = FPDFText_LoadPage(page);
  EXPECT_NE(nullptr, textpage);
  EXPECT_EQ(13, FPDFText_CountChars(textpage));

  FPDFText_ClosePage(textpage);
  UnloadPage(page);
}

// NOTE: this must be called after all the other settings
//       to have the window and its controls displayed properly
void CResizableSheet::EnableSaveRestore(LPCTSTR pszSection, BOOL bRectOnly, BOOL bWithPage)
{
	m_sSection = pszSection;
	m_bSavePage = bWithPage;

	m_bEnableSaveRestore = TRUE;
	m_bRectOnly = bRectOnly;

	// restore immediately
	LoadWindowRect(pszSection, bRectOnly);
	LoadPage();
}