This source file includes following definitions.
- m_baseUrl
- SetUp
- TearDown
- setBaseUrl
- setBaseFolder
- registerURL
- registerErrorURL
- serialize
- getResources
- getResource
- isSerialized
- getSerializedData
- configureSettings
- TEST_F
- TEST_F
- TEST_F
- TEST_F
#include "config.h"
#include "FrameTestHelpers.h"
#include "URLTestHelpers.h"
#include "WebFrameImpl.h"
#include "WebSettings.h"
#include "WebViewImpl.h"
#include <gtest/gtest.h>
#include "core/page/Page.h"
#include "core/page/PageSerializer.h"
#include "platform/SerializedResource.h"
#include "public/platform/Platform.h"
#include "public/platform/WebString.h"
#include "public/platform/WebThread.h"
#include "public/platform/WebURL.h"
#include "public/platform/WebURLRequest.h"
#include "public/platform/WebURLResponse.h"
#include "public/platform/WebUnitTestSupport.h"
#include "wtf/Vector.h"
using namespace WebCore;
using namespace blink;
using blink::FrameTestHelpers::runPendingTasks;
using blink::URLTestHelpers::toKURL;
using blink::URLTestHelpers::registerMockedURLLoad;
namespace {
class PageSerializerTest : public testing::Test {
public:
PageSerializerTest()
: m_folder(WebString::fromUTF8("pageserializer/"))
, m_baseUrl(toKURL("http://www.test.com"))
{
}
protected:
virtual void SetUp()
{
m_helper.initialize(true, 0, 0, &configureSettings);
}
virtual void TearDown()
{
Platform::current()->unitTestSupport()->unregisterAllMockedURLs();
}
void setBaseUrl(const char* url)
{
m_baseUrl = toKURL(url);
}
void setBaseFolder(const char* folder)
{
m_folder = WebString::fromUTF8(folder);
}
void registerURL(const char* file, const char* mimeType)
{
registerMockedURLLoad(KURL(m_baseUrl, file), WebString::fromUTF8(file), m_folder, WebString::fromUTF8(mimeType));
}
void registerErrorURL(const char* file, int statusCode)
{
WebURLError error;
error.reason = 0xdead + statusCode;
error.domain = "PageSerializerTest";
WebURLResponse response;
response.initialize();
response.setMIMEType("text/html");
response.setHTTPStatusCode(statusCode);
Platform::current()->unitTestSupport()->registerMockedErrorURL(KURL(m_baseUrl, file), response, error);
}
void serialize(const char* url)
{
WebURLRequest urlRequest;
urlRequest.initialize();
urlRequest.setURL(KURL(m_baseUrl, url));
m_helper.webView()->mainFrame()->loadRequest(urlRequest);
Platform::current()->unitTestSupport()->serveAsynchronousMockedRequests();
runPendingTasks();
Platform::current()->unitTestSupport()->serveAsynchronousMockedRequests();
PageSerializer serializer(&m_resources);
serializer.serialize(m_helper.webViewImpl()->mainFrameImpl()->frame()->page());
}
Vector<SerializedResource>& getResources()
{
return m_resources;
}
const SerializedResource* getResource(const char* url, const char* mimeType)
{
KURL kURL = KURL(m_baseUrl, url);
String mime(mimeType);
for (size_t i = 0; i < m_resources.size(); ++i) {
const SerializedResource& resource = m_resources[i];
if (resource.url == kURL && !resource.data->isEmpty()
&& (mime.isNull() || equalIgnoringCase(resource.mimeType, mime)))
return &resource;
}
return 0;
}
bool isSerialized(const char* url, const char* mimeType = 0)
{
return getResource(url, mimeType);
}
String getSerializedData(const char* url, const char* mimeType = 0)
{
const SerializedResource* resource = getResource(url, mimeType);
if (resource)
return String(resource->data->data(), resource->data->size());
return String();
}
private:
static void configureSettings(WebSettings* settings)
{
settings->setImagesEnabled(true);
settings->setLoadsImagesAutomatically(true);
settings->setJavaScriptEnabled(true);
}
FrameTestHelpers::WebViewHelper m_helper;
WebString m_folder;
KURL m_baseUrl;
Vector<SerializedResource> m_resources;
};
TEST_F(PageSerializerTest, InputImage)
{
setBaseFolder("pageserializer/input-image/");
registerURL("input-image.html", "text/html");
registerURL("button.png", "image/png");
registerErrorURL("non-existing-button.png", 404);
serialize("input-image.html");
EXPECT_TRUE(isSerialized("button.png", "image/png"));
EXPECT_FALSE(isSerialized("non-existing-button.png", "image/png"));
}
TEST_F(PageSerializerTest, XMLDeclaration)
{
setBaseFolder("pageserializer/xmldecl/");
registerURL("xmldecl.xml", "text/xml");
serialize("xmldecl.xml");
String expectedStart("<?xml version=\"1.0\" encoding=\"UTF-8\"?>");
EXPECT_TRUE(getSerializedData("xmldecl.xml").startsWith(expectedStart));
}
TEST_F(PageSerializerTest, DTD)
{
setBaseFolder("pageserializer/dtd/");
registerURL("dtd.html", "text/html");
serialize("dtd.html");
String expectedStart("<!DOCTYPE html>");
EXPECT_TRUE(getSerializedData("dtd.html").startsWith(expectedStart));
}
TEST_F(PageSerializerTest, Font)
{
setBaseFolder("pageserializer/font/");
registerURL("font.html", "text/html");
registerURL("font.ttf", "application/octet-stream");
serialize("font.html");
EXPECT_TRUE(isSerialized("font.ttf", "application/octet-stream"));
}
}