bcarrella/cef
1
0
Fork 0
mirror of https://bitbucket.org/chromiumembedded/cef synced 2025-02-09 08:38:41 +01:00
Code Issues Packages Projects Releases Wiki Activity

Minor improvements to unit test framework.

Browse Source 
git-svn-id: https://chromiumembedded.googlecode.com/svn/trunk@92 5089003a-bbd8-11dd-ad1f-f1f9622dbc98
This commit is contained in:
Marshall Greenblatt 2010-07-24 17:28:00 +00:00
parent 06ceab7447
commit 9ab2eca392
4 changed files with 378 additions and 384 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

658
tests/unittests/request_unittest.cc
View File

@ -1,245 +1,245 @@
// Copyright (c) 2009 The Chromium Embedded Framework Authors. All rights // Copyright (c) 2009 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that // reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file. // can be found in the LICENSE file.
#include "include/cef.h" #include "include/cef.h"
#include "testing/gtest/include/gtest/gtest.h" #include "testing/gtest/include/gtest/gtest.h"
#include "test_handler.h" #include "test_handler.h"
// Verify that CefRequest::HeaderMap objects are equal // Verify that CefRequest::HeaderMap objects are equal
// If |allowExtras| is true then additional header fields will be allowed in // If |allowExtras| is true then additional header fields will be allowed in
// |map2|. // |map2|.
static void VerifyMapEqual(CefRequest::HeaderMap &map1, static void VerifyMapEqual(CefRequest::HeaderMap &map1,
CefRequest::HeaderMap &map2, CefRequest::HeaderMap &map2,
bool allowExtras) bool allowExtras)
{ {
if(!allowExtras) if(!allowExtras)
ASSERT_EQ(map1.size(), map2.size()); ASSERT_EQ(map1.size(), map2.size());
CefRequest::HeaderMap::const_iterator it1, it2; CefRequest::HeaderMap::const_iterator it1, it2;
for(it1 = map1.begin(); it1 != map1.end(); ++it1) { for(it1 = map1.begin(); it1 != map1.end(); ++it1) {
it2 = map2.find(it1->first); it2 = map2.find(it1->first);
ASSERT_TRUE(it2 != map2.end()); ASSERT_TRUE(it2 != map2.end());
ASSERT_EQ(it1->second, it2->second); ASSERT_EQ(it1->second, it2->second);
} }
} }
// Verify that CefPostDataElement objects are equal // Verify that CefPostDataElement objects are equal
static void VerifyPostDataElementEqual(CefRefPtr<CefPostDataElement> elem1, static void VerifyPostDataElementEqual(CefRefPtr<CefPostDataElement> elem1,
CefRefPtr<CefPostDataElement> elem2) CefRefPtr<CefPostDataElement> elem2)
{ {
ASSERT_EQ(elem1->GetType(), elem2->GetType()); ASSERT_EQ(elem1->GetType(), elem2->GetType());
switch(elem1->GetType()) { switch(elem1->GetType()) {
case PDE_TYPE_BYTES: { case PDE_TYPE_BYTES: {
ASSERT_EQ(elem1->GetBytesCount(), elem2->GetBytesCount()); ASSERT_EQ(elem1->GetBytesCount(), elem2->GetBytesCount());
char *buff1, *buff2; char *buff1, *buff2;
size_t bytesCt = elem1->GetBytesCount(); size_t bytesCt = elem1->GetBytesCount();
buff1 = new char[bytesCt]; buff1 = new char[bytesCt];
buff2 = new char[bytesCt]; buff2 = new char[bytesCt];
elem1->GetBytes(bytesCt, buff1); elem1->GetBytes(bytesCt, buff1);
elem2->GetBytes(bytesCt, buff2); elem2->GetBytes(bytesCt, buff2);
ASSERT_TRUE(!memcmp(buff1, buff2, bytesCt)); ASSERT_TRUE(!memcmp(buff1, buff2, bytesCt));
delete [] buff1; delete [] buff1;
delete [] buff2; delete [] buff2;
} break; } break;
case PDE_TYPE_FILE: case PDE_TYPE_FILE:
ASSERT_EQ(elem1->GetFile(), elem2->GetFile()); ASSERT_EQ(elem1->GetFile(), elem2->GetFile());
break; break;
} }
} }
// Verify that CefPostData objects are equal // Verify that CefPostData objects are equal
static void VerifyPostDataEqual(CefRefPtr<CefPostData> postData1, static void VerifyPostDataEqual(CefRefPtr<CefPostData> postData1,
CefRefPtr<CefPostData> postData2) CefRefPtr<CefPostData> postData2)
{ {
ASSERT_TRUE(!(postData1.get()) == !(postData2.get())); ASSERT_TRUE(!(postData1.get()) == !(postData2.get()));
ASSERT_EQ(postData1->GetElementCount(), postData2->GetElementCount()); ASSERT_EQ(postData1->GetElementCount(), postData2->GetElementCount());
CefPostData::ElementVector ev1, ev2; CefPostData::ElementVector ev1, ev2;
postData1->GetElements(ev1); postData1->GetElements(ev1);
postData1->GetElements(ev2); postData1->GetElements(ev2);
ASSERT_EQ(ev1.size(), ev2.size()); ASSERT_EQ(ev1.size(), ev2.size());
CefPostData::ElementVector::const_iterator it1 = ev1.begin(); CefPostData::ElementVector::const_iterator it1 = ev1.begin();
CefPostData::ElementVector::const_iterator it2 = ev2.begin(); CefPostData::ElementVector::const_iterator it2 = ev2.begin();
for(; it1 != ev1.end() && it2 != ev2.end(); ++it1, ++it2) for(; it1 != ev1.end() && it2 != ev2.end(); ++it1, ++it2)
VerifyPostDataElementEqual((*it1), (*it2)); VerifyPostDataElementEqual((*it1), (*it2));
} }
// Verify that CefRequest objects are equal // Verify that CefRequest objects are equal
// If |allowExtras| is true then additional header fields will be allowed in // If |allowExtras| is true then additional header fields will be allowed in
// |request2|. // |request2|.
static void VerifyRequestEqual(CefRefPtr<CefRequest> request1, static void VerifyRequestEqual(CefRefPtr<CefRequest> request1,
CefRefPtr<CefRequest> request2, CefRefPtr<CefRequest> request2,
bool allowExtras) bool allowExtras)
{ {
ASSERT_EQ(request1->GetURL(), request2->GetURL()); ASSERT_EQ(request1->GetURL(), request2->GetURL());
ASSERT_EQ(request1->GetMethod(), request2->GetMethod()); ASSERT_EQ(request1->GetMethod(), request2->GetMethod());
CefRequest::HeaderMap headers1, headers2; CefRequest::HeaderMap headers1, headers2;
request1->GetHeaderMap(headers1); request1->GetHeaderMap(headers1);
request2->GetHeaderMap(headers2); request2->GetHeaderMap(headers2);
VerifyMapEqual(headers1, headers2, allowExtras); VerifyMapEqual(headers1, headers2, allowExtras);
VerifyPostDataEqual(request1->GetPostData(), request2->GetPostData()); VerifyPostDataEqual(request1->GetPostData(), request2->GetPostData());
} }
// Verify Set/Get methods for CefRequest, CefPostData and CefPostDataElement. // Verify Set/Get methods for CefRequest, CefPostData and CefPostDataElement.
TEST(RequestTest, SetGet) TEST(RequestTest, SetGet)
{ {
// CefRequest CreateRequest // CefRequest CreateRequest
CefRefPtr<CefRequest> request(CefRequest::CreateRequest()); CefRefPtr<CefRequest> request(CefRequest::CreateRequest());
ASSERT_TRUE(request.get() != NULL); ASSERT_TRUE(request.get() != NULL);
std::wstring url = L"http://tests/run.html"; std::wstring url = L"http://tests/run.html";
std::wstring method = L"POST"; std::wstring method = L"POST";
CefRequest::HeaderMap setHeaders, getHeaders; CefRequest::HeaderMap setHeaders, getHeaders;
setHeaders.insert(std::make_pair(L"HeaderA", L"ValueA")); setHeaders.insert(std::make_pair(L"HeaderA", L"ValueA"));
setHeaders.insert(std::make_pair(L"HeaderB", L"ValueB")); setHeaders.insert(std::make_pair(L"HeaderB", L"ValueB"));
// CefPostData CreatePostData // CefPostData CreatePostData
CefRefPtr<CefPostData> postData(CefPostData::CreatePostData()); CefRefPtr<CefPostData> postData(CefPostData::CreatePostData());
ASSERT_TRUE(postData.get() != NULL); ASSERT_TRUE(postData.get() != NULL);
// CefPostDataElement CreatePostDataElement // CefPostDataElement CreatePostDataElement
CefRefPtr<CefPostDataElement> element1( CefRefPtr<CefPostDataElement> element1(
CefPostDataElement::CreatePostDataElement()); CefPostDataElement::CreatePostDataElement());
ASSERT_TRUE(element1.get() != NULL); ASSERT_TRUE(element1.get() != NULL);
CefRefPtr<CefPostDataElement> element2( CefRefPtr<CefPostDataElement> element2(
CefPostDataElement::CreatePostDataElement()); CefPostDataElement::CreatePostDataElement());
ASSERT_TRUE(element2.get() != NULL); ASSERT_TRUE(element2.get() != NULL);
// CefPostDataElement SetToFile // CefPostDataElement SetToFile
std::wstring file = L"c:\\path\\to\\file.ext"; std::wstring file = L"c:\\path\\to\\file.ext";
element1->SetToFile(file); element1->SetToFile(file);
ASSERT_EQ(PDE_TYPE_FILE, element1->GetType()); ASSERT_EQ(PDE_TYPE_FILE, element1->GetType());
ASSERT_EQ(file, element1->GetFile()); ASSERT_EQ(file, element1->GetFile());
// CefPostDataElement SetToBytes // CefPostDataElement SetToBytes
char bytes[] = "Test Bytes"; char bytes[] = "Test Bytes";
element2->SetToBytes(sizeof(bytes), bytes); element2->SetToBytes(sizeof(bytes), bytes);
ASSERT_EQ(PDE_TYPE_BYTES, element2->GetType()); ASSERT_EQ(PDE_TYPE_BYTES, element2->GetType());
ASSERT_EQ(sizeof(bytes), element2->GetBytesCount()); ASSERT_EQ(sizeof(bytes), element2->GetBytesCount());
char bytesOut[sizeof(bytes)]; char bytesOut[sizeof(bytes)];
element2->GetBytes(sizeof(bytes), bytesOut); element2->GetBytes(sizeof(bytes), bytesOut);
ASSERT_TRUE(!memcmp(bytes, bytesOut, sizeof(bytes))); ASSERT_TRUE(!memcmp(bytes, bytesOut, sizeof(bytes)));
// CefPostData AddElement // CefPostData AddElement
postData->AddElement(element1); postData->AddElement(element1);
postData->AddElement(element2); postData->AddElement(element2);
ASSERT_EQ(2, postData->GetElementCount()); ASSERT_EQ(2, postData->GetElementCount());
// CefPostData RemoveElement // CefPostData RemoveElement
postData->RemoveElement(element1); postData->RemoveElement(element1);
ASSERT_EQ(1, postData->GetElementCount()); ASSERT_EQ(1, postData->GetElementCount());
// CefPostData RemoveElements // CefPostData RemoveElements
postData->RemoveElements(); postData->RemoveElements();
ASSERT_EQ(0, postData->GetElementCount()); ASSERT_EQ(0, postData->GetElementCount());
postData->AddElement(element1); postData->AddElement(element1);
postData->AddElement(element2); postData->AddElement(element2);
ASSERT_EQ(2, postData->GetElementCount()); ASSERT_EQ(2, postData->GetElementCount());
CefPostData::ElementVector elements; CefPostData::ElementVector elements;
postData->GetElements(elements); postData->GetElements(elements);
CefPostData::ElementVector::const_iterator it = elements.begin(); CefPostData::ElementVector::const_iterator it = elements.begin();
for(size_t i = 0; it != elements.end(); ++it, ++i) { for(size_t i = 0; it != elements.end(); ++it, ++i) {
if(i == 0) if(i == 0)
VerifyPostDataElementEqual(element1, (*it).get()); VerifyPostDataElementEqual(element1, (*it).get());
else if(i == 1) else if(i == 1)
VerifyPostDataElementEqual(element2, (*it).get()); VerifyPostDataElementEqual(element2, (*it).get());
} }
// CefRequest SetURL // CefRequest SetURL
request->SetURL(url); request->SetURL(url);
ASSERT_EQ(url, request->GetURL()); ASSERT_EQ(url, request->GetURL());
// CefRequest SetMethod // CefRequest SetMethod
request->SetMethod(method); request->SetMethod(method);
ASSERT_EQ(method, request->GetMethod()); ASSERT_EQ(method, request->GetMethod());
// CefRequest SetHeaderMap // CefRequest SetHeaderMap
request->SetHeaderMap(setHeaders); request->SetHeaderMap(setHeaders);
request->GetHeaderMap(getHeaders); request->GetHeaderMap(getHeaders);
VerifyMapEqual(setHeaders, getHeaders, false); VerifyMapEqual(setHeaders, getHeaders, false);
getHeaders.clear(); getHeaders.clear();
// CefRequest SetPostData // CefRequest SetPostData
request->SetPostData(postData); request->SetPostData(postData);
VerifyPostDataEqual(postData, request->GetPostData()); VerifyPostDataEqual(postData, request->GetPostData());
request = CefRequest::CreateRequest(); request = CefRequest::CreateRequest();
ASSERT_TRUE(request.get() != NULL); ASSERT_TRUE(request.get() != NULL);
// CefRequest Set // CefRequest Set
request->Set(url, method, postData, setHeaders); request->Set(url, method, postData, setHeaders);
ASSERT_EQ(url, request->GetURL()); ASSERT_EQ(url, request->GetURL());
ASSERT_EQ(method, request->GetMethod()); ASSERT_EQ(method, request->GetMethod());
request->GetHeaderMap(getHeaders); request->GetHeaderMap(getHeaders);
VerifyMapEqual(setHeaders, getHeaders, false); VerifyMapEqual(setHeaders, getHeaders, false);
getHeaders.clear(); getHeaders.clear();
VerifyPostDataEqual(postData, request->GetPostData()); VerifyPostDataEqual(postData, request->GetPostData());
} }
static void CreateRequest(CefRefPtr<CefRequest>& request) static void CreateRequest(CefRefPtr<CefRequest>& request)
{ {
request = CefRequest::CreateRequest(); request = CefRequest::CreateRequest();
ASSERT_TRUE(request.get() != NULL); ASSERT_TRUE(request.get() != NULL);
request->SetURL(L"http://tests/run.html"); request->SetURL(L"http://tests/run.html");
request->SetMethod(L"POST"); request->SetMethod(L"POST");
CefRequest::HeaderMap headers; CefRequest::HeaderMap headers;
headers.insert(std::make_pair(L"HeaderA", L"ValueA")); headers.insert(std::make_pair(L"HeaderA", L"ValueA"));
headers.insert(std::make_pair(L"HeaderB", L"ValueB")); headers.insert(std::make_pair(L"HeaderB", L"ValueB"));
request->SetHeaderMap(headers); request->SetHeaderMap(headers);
CefRefPtr<CefPostData> postData(CefPostData::CreatePostData()); CefRefPtr<CefPostData> postData(CefPostData::CreatePostData());
ASSERT_TRUE(postData.get() != NULL); ASSERT_TRUE(postData.get() != NULL);
CefRefPtr<CefPostDataElement> element1( CefRefPtr<CefPostDataElement> element1(
CefPostDataElement::CreatePostDataElement()); CefPostDataElement::CreatePostDataElement());
ASSERT_TRUE(element1.get() != NULL); ASSERT_TRUE(element1.get() != NULL);
element1->SetToFile(L"c:\\path\\to\\file.ext"); element1->SetToFile(L"c:\\path\\to\\file.ext");
postData->AddElement(element1); postData->AddElement(element1);
CefRefPtr<CefPostDataElement> element2( CefRefPtr<CefPostDataElement> element2(
CefPostDataElement::CreatePostDataElement()); CefPostDataElement::CreatePostDataElement());
ASSERT_TRUE(element2.get() != NULL); ASSERT_TRUE(element2.get() != NULL);
char bytes[] = "Test Bytes"; char bytes[] = "Test Bytes";
element2->SetToBytes(sizeof(bytes), bytes); element2->SetToBytes(sizeof(bytes), bytes);
postData->AddElement(element2); postData->AddElement(element2);
request->SetPostData(postData); request->SetPostData(postData);
} }
bool g_RequestSendRecvTestHandlerHandleBeforeBrowseCalled; bool g_RequestSendRecvTestHandlerHandleBeforeBrowseCalled;
bool g_RequestSendRecvTestHandlerHandleBeforeResourceLoadCalled; bool g_RequestSendRecvTestHandlerHandleBeforeResourceLoadCalled;
class RequestSendRecvTestHandler : public TestHandler class RequestSendRecvTestHandler : public TestHandler
{ {
public: public:
RequestSendRecvTestHandler() {} RequestSendRecvTestHandler() {}
virtual void RunTest() virtual void RunTest()
{ {
// Create the test request // Create the test request
CreateRequest(request_); CreateRequest(request_);
// Create the browser // Create the browser
CreateBrowser(std::wstring()); CreateBrowser(std::wstring());
} }
virtual RetVal HandleAfterCreated(CefRefPtr<CefBrowser> browser) virtual RetVal HandleAfterCreated(CefRefPtr<CefBrowser> browser)
{ {
TestHandler::HandleAfterCreated(browser); TestHandler::HandleAfterCreated(browser);
// Load the test request // Load the test request
browser->GetMainFrame()->LoadRequest(request_); browser->GetMainFrame()->LoadRequest(request_);
return RV_CONTINUE; return RV_CONTINUE;
} }
virtual RetVal HandleBeforeBrowse(CefRefPtr<CefBrowser> browser, virtual RetVal HandleBeforeBrowse(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame, CefRefPtr<CefFrame> frame,
CefRefPtr<CefRequest> request, CefRefPtr<CefRequest> request,
@ -251,77 +251,78 @@ public:
VerifyRequestEqual(request_, request, true); VerifyRequestEqual(request_, request, true);
return RV_CONTINUE; return RV_CONTINUE;
} }
virtual RetVal HandleBeforeResourceLoad(CefRefPtr<CefBrowser> browser, virtual RetVal HandleBeforeResourceLoad(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefRequest> request, CefRefPtr<CefRequest> request,
std::wstring& redirectUrl, std::wstring& redirectUrl,
CefRefPtr<CefStreamReader>& resourceStream, CefRefPtr<CefStreamReader>& resourceStream,
std::wstring& mimeType, std::wstring& mimeType,
int loadFlags) int loadFlags)
{ {
g_RequestSendRecvTestHandlerHandleBeforeResourceLoadCalled = true; g_RequestSendRecvTestHandlerHandleBeforeResourceLoadCalled = true;
// Verify that the request is the same // Verify that the request is the same
VerifyRequestEqual(request_, request, true); VerifyRequestEqual(request_, request, true);
// No results // No results
return RV_HANDLED; return RV_HANDLED;
} }
virtual RetVal HandleLoadEnd(CefRefPtr<CefBrowser> browser, virtual RetVal HandleLoadEnd(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame) CefRefPtr<CefFrame> frame)
{ {
if(!browser->IsPopup() && !frame.get()) if(!browser->IsPopup() && !frame.get())
NotifyTestComplete(); DestroyTest();
return RV_CONTINUE; return RV_CONTINUE;
} }
CefRefPtr<CefRequest> request_; CefRefPtr<CefRequest> request_;
}; };
// Verify send and recieve // Verify send and recieve
TEST(RequestTest, SendRecv) TEST(RequestTest, SendRecv)
{ {
g_RequestSendRecvTestHandlerHandleBeforeBrowseCalled = false; g_RequestSendRecvTestHandlerHandleBeforeBrowseCalled = false;
g_RequestSendRecvTestHandlerHandleBeforeResourceLoadCalled = false; g_RequestSendRecvTestHandlerHandleBeforeResourceLoadCalled = false;
RequestSendRecvTestHandler* handler = new RequestSendRecvTestHandler(); CefRefPtr<RequestSendRecvTestHandler> handler =
handler->ExecuteTest(); new RequestSendRecvTestHandler();
handler->ExecuteTest();
ASSERT_TRUE(g_RequestSendRecvTestHandlerHandleBeforeBrowseCalled);
ASSERT_TRUE(g_RequestSendRecvTestHandlerHandleBeforeResourceLoadCalled); ASSERT_TRUE(g_RequestSendRecvTestHandlerHandleBeforeBrowseCalled);
} ASSERT_TRUE(g_RequestSendRecvTestHandlerHandleBeforeResourceLoadCalled);
}
bool g_RequestHistoryNavTestDidLoadRequest;
bool g_RequestHistoryNavTestDidReloadRequest; bool g_RequestHistoryNavTestDidLoadRequest;
bool g_RequestHistoryNavTestDidReloadRequest;
class RequestHistoryNavTestHandler : public TestHandler
{ class RequestHistoryNavTestHandler : public TestHandler
public: {
RequestHistoryNavTestHandler() : navigated_(false) {} public:
RequestHistoryNavTestHandler() : navigated_(false) {}
virtual void RunTest()
{ virtual void RunTest()
// Create the test request {
CreateRequest(request_); // Create the test request
CreateRequest(request_);
// Add the resource that we will navigate to/from
AddResource(L"http://tests/goto.html", "<html>To</html>", L"text/html"); // Add the resource that we will navigate to/from
AddResource(L"http://tests/goto.html", "<html>To</html>", L"text/html");
// Create the browser
CreateBrowser(std::wstring()); // Create the browser
} CreateBrowser(std::wstring());
}
virtual RetVal HandleAfterCreated(CefRefPtr<CefBrowser> browser)
{ virtual RetVal HandleAfterCreated(CefRefPtr<CefBrowser> browser)
TestHandler::HandleAfterCreated(browser); {
TestHandler::HandleAfterCreated(browser);
// Load the test request
browser->GetMainFrame()->LoadRequest(request_); // Load the test request
return RV_CONTINUE; browser->GetMainFrame()->LoadRequest(request_);
} return RV_CONTINUE;
}
virtual RetVal HandleBeforeBrowse(CefRefPtr<CefBrowser> browser, virtual RetVal HandleBeforeBrowse(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame, CefRefPtr<CefFrame> frame,
CefRefPtr<CefRequest> request, CefRefPtr<CefRequest> request,
@ -335,15 +336,15 @@ public:
} }
return RV_CONTINUE; return RV_CONTINUE;
} }
virtual RetVal HandleBeforeResourceLoad(CefRefPtr<CefBrowser> browser, virtual RetVal HandleBeforeResourceLoad(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefRequest> request, CefRefPtr<CefRequest> request,
std::wstring& redirectUrl, std::wstring& redirectUrl,
CefRefPtr<CefStreamReader>& resourceStream, CefRefPtr<CefStreamReader>& resourceStream,
std::wstring& mimeType, std::wstring& mimeType,
int loadFlags) int loadFlags)
{ {
std::wstring url = request->GetURL(); std::wstring url = request->GetURL();
if(url == L"http://tests/run.html") if(url == L"http://tests/run.html")
{ {
@ -357,7 +358,7 @@ public:
} }
else else
{ {
// Re-loading the request // Re-loading the request
g_RequestHistoryNavTestDidReloadRequest = true; g_RequestHistoryNavTestDidReloadRequest = true;
} }
@ -366,16 +367,16 @@ public:
resourceStream = CefStreamReader::CreateForData((void*)output.c_str(), resourceStream = CefStreamReader::CreateForData((void*)output.c_str(),
output.length()); output.length());
mimeType = L"text/html"; mimeType = L"text/html";
return RV_CONTINUE; return RV_CONTINUE;
} }
else else
{ {
// Pass to the default handler to return the to/from page // Pass to the default handler to return the to/from page
return TestHandler::HandleBeforeResourceLoad(browser, request, return TestHandler::HandleBeforeResourceLoad(browser, request,
redirectUrl, resourceStream, mimeType, loadFlags); redirectUrl, resourceStream, mimeType, loadFlags);
} }
} }
virtual RetVal HandleLoadEnd(CefRefPtr<CefBrowser> browser, virtual RetVal HandleLoadEnd(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame) CefRefPtr<CefFrame> frame)
{ {
@ -393,7 +394,7 @@ public:
else else
{ {
// Resource re-load, end the test // Resource re-load, end the test
NotifyTestComplete(); DestroyTest();
} }
} }
else else
@ -403,22 +404,23 @@ public:
} }
} }
return RV_CONTINUE; return RV_CONTINUE;
} }
CefRefPtr<CefRequest> request_; CefRefPtr<CefRequest> request_;
bool navigated_; bool navigated_;
}; };
// Verify history navigation // Verify history navigation
// This test will only pass if the patches for issue #42 are applied. // This test will only pass if the patches for issue #42 are applied.
TEST(RequestTest, HistoryNav) TEST(RequestTest, HistoryNav)
{ {
g_RequestHistoryNavTestDidLoadRequest = false; g_RequestHistoryNavTestDidLoadRequest = false;
g_RequestHistoryNavTestDidReloadRequest = false; g_RequestHistoryNavTestDidReloadRequest = false;
RequestHistoryNavTestHandler* handler = new RequestHistoryNavTestHandler(); CefRefPtr<RequestHistoryNavTestHandler> handler =
handler->ExecuteTest(); new RequestHistoryNavTestHandler();
handler->ExecuteTest();
ASSERT_TRUE(g_RequestHistoryNavTestDidLoadRequest);
ASSERT_TRUE(g_RequestHistoryNavTestDidReloadRequest); ASSERT_TRUE(g_RequestHistoryNavTestDidLoadRequest);
} ASSERT_TRUE(g_RequestHistoryNavTestDidReloadRequest);
}

41
tests/unittests/test_handler.h
View File

@ -6,13 +6,14 @@
#define _TEST_HANDLER_H #define _TEST_HANDLER_H
#include "include/cef.h" #include "include/cef.h"
#include "base/waitable_event.h"
#include "testing/gtest/include/gtest/gtest.h" #include "testing/gtest/include/gtest/gtest.h"
// Base implementation of CefHandler for unit tests. // Base implementation of CefHandler for unit tests.
class TestHandler : public CefThreadSafeBase<CefHandler> class TestHandler : public CefThreadSafeBase<CefHandler>
{ {
public: public:
TestHandler() : browser_hwnd_(NULL), completion_event_(NULL) TestHandler() : browser_hwnd_(NULL), completion_event_(true, false)
{ {
} }
@ -177,8 +178,8 @@ public:
browser_ = NULL; browser_ = NULL;
browser_hwnd_ = NULL; browser_hwnd_ = NULL;
// Just in case it wasn't called already // Signal that the test is now complete.
NotifyTestComplete(); completion_event_.Signal();
} }
Unlock(); Unlock();
return RV_CONTINUE; return RV_CONTINUE;
@ -232,47 +233,33 @@ public:
// returns. // returns.
void ExecuteTest() void ExecuteTest()
{ {
// Add a reference
AddRef();
// Create the notification event
Lock();
completion_event_ = CreateEvent(NULL, TRUE, FALSE, NULL);
ASSERT_TRUE(completion_event_ != NULL);
Unlock();
// Run the test // Run the test
RunTest(); RunTest();
// Wait for the test to complete // Wait for the test to complete
WaitForSingleObject(completion_event_, INFINITE); completion_event_.Wait();
Lock();
CloseHandle(completion_event_);
completion_event_ = NULL;
Unlock();
// Remove the reference
Release();
} }
protected: protected:
// Called by the implementing class when the test is complete // Destroy the browser window. Once the window is destroyed test completion
void NotifyTestComplete() // will be signaled.
void DestroyTest()
{ {
// Notify that the test is complete
Lock(); Lock();
if(completion_event_ != NULL) #if defined(OS_WIN)
SetEvent(completion_event_);
if(browser_hwnd_ != NULL) if(browser_hwnd_ != NULL)
PostMessage(browser_hwnd_, WM_CLOSE, 0, 0); PostMessage(browser_hwnd_, WM_CLOSE, 0, 0);
#endif
Unlock(); Unlock();
} }
void CreateBrowser(const std::wstring& url) void CreateBrowser(const std::wstring& url)
{ {
CefWindowInfo windowInfo; CefWindowInfo windowInfo;
#if defined(OS_WIN)
windowInfo.SetAsPopup(NULL, L"CefUnitTest"); windowInfo.SetAsPopup(NULL, L"CefUnitTest");
windowInfo.m_dwStyle |= WS_VISIBLE; windowInfo.m_dwStyle |= WS_VISIBLE;
#endif
CefBrowser::CreateBrowser(windowInfo, false, this, url); CefBrowser::CreateBrowser(windowInfo, false, this, url);
} }
@ -292,10 +279,10 @@ private:
CefRefPtr<CefBrowser> browser_; CefRefPtr<CefBrowser> browser_;
// The browser window handle // The browser window handle
HWND browser_hwnd_; CefWindowHandle browser_hwnd_;
// Handle used to notify when the test is complete // Handle used to notify when the test is complete
HANDLE completion_event_; base::WaitableEvent completion_event_;
// Map of resources that can be automatically loaded // Map of resources that can be automatically loaded
typedef std::map<std::wstring, std::pair<std::string, std::wstring>> ResourceMap; typedef std::map<std::wstring, std::pair<std::string, std::wstring>> ResourceMap;

59
tests/unittests/test_suite.h
View File

@ -1,30 +1,35 @@
// Copyright (c) 2009 The Chromium Embedded Framework Authors. All rights // Copyright (c) 2009 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that // reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file. // can be found in the LICENSE file.
#ifndef _CEF_TEST_SUITE_H #ifndef _CEF_TEST_SUITE_H
#define _CEF_TEST_SUITE_H #define _CEF_TEST_SUITE_H
#include "build/build_config.h" #include "build/build_config.h"
#include "base/test/test_suite.h" #include "base/platform_thread.h"
#include "include/cef.h" #include "base/test/test_suite.h"
#include "include/cef.h"
class CefTestSuite : public TestSuite {
public: class CefTestSuite : public TestSuite {
CefTestSuite(int argc, char** argv) : TestSuite(argc, argv) { public:
} CefTestSuite(int argc, char** argv) : TestSuite(argc, argv) {
}
protected:
protected:
virtual void Initialize() {
TestSuite::Initialize(); virtual void Initialize() {
CefInitialize(true, std::wstring()); TestSuite::Initialize();
} CefInitialize(true, std::wstring());
}
virtual void Shutdown() {
CefShutdown(); virtual void Shutdown() {
TestSuite::Shutdown(); // Delay a bit so that the system has a chance to finish destroying windows
} // before CefShutdown() checks for memory leaks.
}; PlatformThread::Sleep(500);
#endif // _CEF_TEST_SUITE_H CefShutdown();
TestSuite::Shutdown();
}
};
#endif // _CEF_TEST_SUITE_H

4
tests/unittests/v8_unittest.cc
View File

@ -244,7 +244,7 @@ public:
CefRefPtr<CefFrame> frame) CefRefPtr<CefFrame> frame)
{ {
if(!browser->IsPopup() && !frame.get()) if(!browser->IsPopup() && !frame.get())
NotifyTestComplete(); DestroyTest();
return RV_CONTINUE; return RV_CONTINUE;
} }
}; };
@ -271,7 +271,7 @@ TEST(V8Test, Extension)
L"})();"; L"})();";
CefRegisterExtension(L"v8/test", extensionCode, new V8TestV8Handler(false)); CefRegisterExtension(L"v8/test", extensionCode, new V8TestV8Handler(false));
V8TestHandler* handler = new V8TestHandler(); CefRefPtr<V8TestHandler> handler = new V8TestHandler();
handler->ExecuteTest(); handler->ExecuteTest();
ASSERT_TRUE(g_V8TestV8HandlerExecuteCalled); ASSERT_TRUE(g_V8TestV8HandlerExecuteCalled);