bcarrella/cef
1
0
Fork 0
mirror of https://bitbucket.org/chromiumembedded/cef synced 2025-06-05 21:39:12 +02:00
Code Issues Packages Projects Releases Wiki Activity

Introduce CefString and cef_string_t implementations that support string type conversions and customization of the API string type (issue #146).

Browse Source 
git-svn-id: https://chromiumembedded.googlecode.com/svn/trunk@145 5089003a-bbd8-11dd-ad1f-f1f9622dbc98
This commit is contained in:
Marshall Greenblatt
2010-11-22 17:49:46 +00:00
parent 1e1c2ad8d7
commit 7d60642638
121 changed files with 2598 additions and 3209 deletions
Download Patch File Download Diff File Expand all files Collapse all files

50
tests/unittests/request_unittest.cc
View File

@ -94,11 +94,11 @@ TEST(RequestTest, SetGet)
CefRefPtr<CefRequest> request(CefRequest::CreateRequest());
ASSERT_TRUE(request.get() != NULL);
std::wstring url = L"http://tests/run.html";
std::wstring method = L"POST";
CefString url = "http://tests/run.html";
CefString method = "POST";
CefRequest::HeaderMap setHeaders, getHeaders;
setHeaders.insert(std::make_pair(L"HeaderA", L"ValueA"));
setHeaders.insert(std::make_pair(L"HeaderB", L"ValueB"));
setHeaders.insert(std::make_pair("HeaderA", "ValueA"));
setHeaders.insert(std::make_pair("HeaderB", "ValueB"));
// CefPostData CreatePostData
CefRefPtr<CefPostData> postData(CefPostData::CreatePostData());
@ -113,7 +113,7 @@ TEST(RequestTest, SetGet)
ASSERT_TRUE(element2.get() != NULL);
// CefPostDataElement SetToFile
std::wstring file = L"c:\\path\\to\\file.ext";
CefString file = "c:\\path\\to\\file.ext";
element1->SetToFile(file);
ASSERT_EQ(PDE_TYPE_FILE, element1->GetType());
ASSERT_EQ(file, element1->GetFile());
@ -189,12 +189,12 @@ static void CreateRequest(CefRefPtr<CefRequest>& request)
request = CefRequest::CreateRequest();
ASSERT_TRUE(request.get() != NULL);
request->SetURL(L"http://tests/run.html");
request->SetMethod(L"POST");
request->SetURL("http://tests/run.html");
request->SetMethod("POST");
CefRequest::HeaderMap headers;
headers.insert(std::make_pair(L"HeaderA", L"ValueA"));
headers.insert(std::make_pair(L"HeaderB", L"ValueB"));
headers.insert(std::make_pair("HeaderA", "ValueA"));
headers.insert(std::make_pair("HeaderB", "ValueB"));
request->SetHeaderMap(headers);
CefRefPtr<CefPostData> postData(CefPostData::CreatePostData());
@ -203,7 +203,7 @@ static void CreateRequest(CefRefPtr<CefRequest>& request)
CefRefPtr<CefPostDataElement> element1(
CefPostDataElement::CreatePostDataElement());
ASSERT_TRUE(element1.get() != NULL);
element1->SetToFile(L"c:\\path\\to\\file.ext");
element1->SetToFile("c:\\path\\to\\file.ext");
postData->AddElement(element1);
CefRefPtr<CefPostDataElement> element2(
@ -230,7 +230,7 @@ public:
CreateRequest(request_);
// Create the browser
CreateBrowser(std::wstring());
CreateBrowser(CefString());
}
virtual RetVal HandleAfterCreated(CefRefPtr<CefBrowser> browser)
@ -257,9 +257,9 @@ public:
virtual RetVal HandleBeforeResourceLoad(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefRequest> request,
std::wstring& redirectUrl,
CefString& redirectUrl,
CefRefPtr<CefStreamReader>& resourceStream,
std::wstring& mimeType,
CefString& mimeType,
int loadFlags)
{
g_RequestSendRecvTestHandlerHandleBeforeResourceLoadCalled = true;
@ -310,10 +310,10 @@ public:
CreateRequest(request_);
// Add the resource that we will navigate to/from
AddResource(L"http://tests/goto.html", "<html>To</html>", L"text/html");
AddResource("http://tests/goto.html", "<html>To</html>", "text/html");
// Create the browser
CreateBrowser(std::wstring());
CreateBrowser(CefString());
}
virtual RetVal HandleAfterCreated(CefRefPtr<CefBrowser> browser)
@ -330,8 +330,8 @@ public:
CefRefPtr<CefRequest> request,
NavType navType, bool isRedirect)
{
std::wstring url = request->GetURL();
if(url == L"http://tests/run.html")
CefString url = request->GetURL();
if(url == "http://tests/run.html")
{
// Verify that the request is the same
VerifyRequestEqual(request_, request, true);
@ -342,13 +342,13 @@ public:
virtual RetVal HandleBeforeResourceLoad(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefRequest> request,
std::wstring& redirectUrl,
CefString& redirectUrl,
CefRefPtr<CefStreamReader>& resourceStream,
std::wstring& mimeType,
CefString& mimeType,
int loadFlags)
{
std::wstring url = request->GetURL();
if(url == L"http://tests/run.html")
CefString url = request->GetURL();
if(url == "http://tests/run.html")
{
// Verify that the request is the same
VerifyRequestEqual(request_, request, true);
@ -368,7 +368,7 @@ public:
std::string output = "<html>Request</html>";
resourceStream = CefStreamReader::CreateForData((void*)output.c_str(),
output.length());
mimeType = L"text/html";
mimeType = "text/html";
return RV_CONTINUE;
}
else
@ -384,14 +384,14 @@ public:
{
if(!browser->IsPopup() && !frame.get())
{
std::wstring url = browser->GetMainFrame()->GetURL();
if(url == L"http://tests/run.html")
CefString url = browser->GetMainFrame()->GetURL();
if(url == "http://tests/run.html")
{
if(!navigated_)
{
// First resource load, go to the next page
navigated_ = true;
browser->GetMainFrame()->LoadURL(L"http://tests/goto.html");
browser->GetMainFrame()->LoadURL("http://tests/goto.html");
}
else
{

4
tests/unittests/stream_unittest.cc
View File

@ -71,7 +71,7 @@ static void VerifyStreamWriteBehavior(CefRefPtr<CefStreamWriter> stream,
TEST(StreamTest, ReadFile)
{
const char* fileName = "StreamTest.VerifyReadFile.txt";
std::wstring fileNameStr = L"StreamTest.VerifyReadFile.txt";
CefString fileNameStr = "StreamTest.VerifyReadFile.txt";
std::string contents = "This is my test\ncontents for the file";
// Create the file
@ -116,7 +116,7 @@ TEST(StreamTest, ReadData)
TEST(StreamTest, WriteFile)
{
const char* fileName = "StreamTest.VerifyWriteFile.txt";
std::wstring fileNameStr = L"StreamTest.VerifyWriteFile.txt";
CefString fileNameStr = "StreamTest.VerifyWriteFile.txt";
std::string contents = "This is my test\ncontents for the file";
// Test the stream

64
tests/unittests/test_handler.h
View File

@ -28,7 +28,7 @@ public:
CefWindowInfo& createInfo, bool popup,
const CefPopupFeatures& popupFeatures,
CefRefPtr<CefHandler>& handler,
std::wstring& url,
CefString& url,
CefBrowserSettings& settings)
{
return RV_CONTINUE;
@ -49,13 +49,13 @@ public:
virtual RetVal HandleAddressChange(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame,
const std::wstring& url)
const CefString& url)
{
return RV_CONTINUE;
}
virtual RetVal HandleTitleChange(CefRefPtr<CefBrowser> browser,
const std::wstring& title)
const CefString& title)
{
return RV_CONTINUE;
}
@ -83,22 +83,22 @@ public:
virtual RetVal HandleLoadError(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame,
ErrorCode errorCode,
const std::wstring& failedUrl,
std::wstring& errorText)
const CefString& failedUrl,
CefString& errorText)
{
return RV_CONTINUE;
}
virtual RetVal HandleBeforeResourceLoad(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefRequest> request,
std::wstring& redirectUrl,
CefString& redirectUrl,
CefRefPtr<CefStreamReader>& resourceStream,
std::wstring& mimeType,
CefString& mimeType,
int loadFlags)
{
Lock();
if(resource_map_.size() > 0) {
std::wstring url = request->GetURL();
CefString url = request->GetURL();
ResourceMap::const_iterator it = resource_map_.find(url);
if(it != resource_map_.end()) {
// Return the previously mapped resource
@ -113,8 +113,8 @@ public:
}
virtual RetVal HandleDownloadResponse(CefRefPtr<CefBrowser> browser,
const std::wstring& mimeType,
const std::wstring& fileName,
const CefString& mimeType,
const CefString& fileName,
int64 contentLength,
CefRefPtr<CefDownloadHandler>& handler)
{
@ -129,7 +129,7 @@ public:
virtual RetVal HandleGetMenuLabel(CefRefPtr<CefBrowser> browser,
MenuId menuId, std::wstring& label)
MenuId menuId, CefString& label)
{
return RV_CONTINUE;
}
@ -149,39 +149,39 @@ public:
virtual RetVal HandlePrintHeaderFooter(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame,
CefPrintInfo& printInfo,
const std::wstring& url,
const std::wstring& title,
const CefString& url,
const CefString& title,
int currentPage, int maxPages,
std::wstring& topLeft,
std::wstring& topCenter,
std::wstring& topRight,
std::wstring& bottomLeft,
std::wstring& bottomCenter,
std::wstring& bottomRight)
CefString& topLeft,
CefString& topCenter,
CefString& topRight,
CefString& bottomLeft,
CefString& bottomCenter,
CefString& bottomRight)
{
return RV_CONTINUE;
}
virtual RetVal HandleJSAlert(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame,
const std::wstring& message)
const CefString& message)
{
return RV_CONTINUE;
}
virtual RetVal HandleJSConfirm(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame,
const std::wstring& message, bool& retval)
const CefString& message, bool& retval)
{
return RV_CONTINUE;
}
virtual RetVal HandleJSPrompt(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame,
const std::wstring& message,
const std::wstring& defaultValue,
const CefString& message,
const CefString& defaultValue,
bool& retval,
std::wstring& result)
CefString& result)
{
return RV_CONTINUE;
}
@ -228,14 +228,14 @@ public:
}
virtual RetVal HandleTooltip(CefRefPtr<CefBrowser> browser,
std::wstring& text)
CefString& text)
{
return RV_CONTINUE;
}
virtual RetVal HandleConsoleMessage(CefRefPtr<CefBrowser> browser,
const std::wstring& message,
const std::wstring& source, int line)
const CefString& message,
const CefString& source, int line)
{
return RV_CONTINUE;
}
@ -283,18 +283,18 @@ protected:
Unlock();
}
void CreateBrowser(const std::wstring& url)
void CreateBrowser(const CefString& url)
{
CefWindowInfo windowInfo;
#if defined(OS_WIN)
windowInfo.SetAsPopup(NULL, L"CefUnitTest");
windowInfo.SetAsPopup(NULL, "CefUnitTest");
windowInfo.m_dwStyle |= WS_VISIBLE;
#endif
CefBrowser::CreateBrowser(windowInfo, false, this, url);
}
void AddResource(const std::wstring& key, const std::string& value,
const std::wstring& mimeType)
void AddResource(const CefString& key, const std::string& value,
const CefString& mimeType)
{
resource_map_.insert(std::make_pair(key, std::make_pair(value, mimeType)));
}
@ -315,7 +315,7 @@ private:
base::WaitableEvent completion_event_;
// Map of resources that can be automatically loaded
typedef std::map<std::wstring, std::pair<std::string, std::wstring> > ResourceMap;
typedef std::map<CefString, std::pair<std::string, CefString> > ResourceMap;
ResourceMap resource_map_;
};

106
tests/unittests/v8_unittest.cc
View File

@ -14,23 +14,23 @@ class V8TestV8Handler : public CefThreadSafeBase<CefV8Handler>
public:
V8TestV8Handler(bool bindingTest) { binding_test_ = bindingTest; }
virtual bool Execute(const std::wstring& name,
virtual bool Execute(const CefString& name,
CefRefPtr<CefV8Value> object,
const CefV8ValueList& arguments,
CefRefPtr<CefV8Value>& retval,
std::wstring& exception)
CefString& exception)
{
TestExecute(name, object, arguments, retval, exception);
return true;
}
void TestExecute(const std::wstring& name,
void TestExecute(const CefString& name,
CefRefPtr<CefV8Value> object,
const CefV8ValueList& arguments,
CefRefPtr<CefV8Value>& retval,
std::wstring& exception)
CefString& exception)
{
if(name == L"execute") {
if(name == "execute") {
g_V8TestV8HandlerExecuteCalled = true;
ASSERT_EQ((size_t)8, arguments.size());
@ -50,7 +50,7 @@ public:
argct++;
ASSERT_TRUE(arguments[argct]->IsString());
ASSERT_EQ(L"test string", arguments[argct]->GetStringValue());
ASSERT_EQ(arguments[argct]->GetStringValue(), "test string");
argct++;
CefRefPtr<CefV8Value> value;
@ -81,7 +81,7 @@ public:
value = arguments[argct]->GetValue(subargct);
ASSERT_TRUE(value.get() != NULL);
ASSERT_TRUE(value->IsString());
ASSERT_EQ(L"another string", value->GetStringValue());
ASSERT_EQ(value->GetStringValue(), "another string");
subargct++;
}
argct++;
@ -89,25 +89,25 @@ public:
// object
ASSERT_TRUE(arguments[argct]->IsObject());
{
value = arguments[argct]->GetValue(L"arg0");
value = arguments[argct]->GetValue("arg0");
ASSERT_TRUE(value.get() != NULL);
ASSERT_TRUE(value->IsInt());
ASSERT_EQ(2, value->GetIntValue());
value = arguments[argct]->GetValue(L"arg1");
value = arguments[argct]->GetValue("arg1");
ASSERT_TRUE(value.get() != NULL);
ASSERT_TRUE(value->IsDouble());
ASSERT_EQ(3.433, value->GetDoubleValue());
value = arguments[argct]->GetValue(L"arg2");
value = arguments[argct]->GetValue("arg2");
ASSERT_TRUE(value.get() != NULL);
ASSERT_TRUE(value->IsBool());
ASSERT_EQ(true, value->GetBoolValue());
value = arguments[argct]->GetValue(L"arg3");
value = arguments[argct]->GetValue("arg3");
ASSERT_TRUE(value.get() != NULL);
ASSERT_TRUE(value->IsString());
ASSERT_EQ(L"some string", value->GetStringValue());
ASSERT_EQ(value->GetStringValue(), "some string");
}
argct++;
@ -118,9 +118,9 @@ public:
args.push_back(CefV8Value::CreateInt(5));
args.push_back(CefV8Value::CreateDouble(3.5));
args.push_back(CefV8Value::CreateBool(true));
args.push_back(CefV8Value::CreateString(L"10"));
args.push_back(CefV8Value::CreateString("10"));
CefRefPtr<CefV8Value> rv;
std::wstring exception;
CefString exception;
ASSERT_TRUE(arguments[argct]->ExecuteFunction(
arguments[argct], args, rv, exception));
ASSERT_TRUE(rv.get() != NULL);
@ -136,37 +136,37 @@ public:
args.push_back(CefV8Value::CreateDouble(5));
args.push_back(CefV8Value::CreateDouble(0));
CefRefPtr<CefV8Value> rv;
std::wstring exception;
CefString exception;
ASSERT_TRUE(arguments[argct]->ExecuteFunction(
arguments[argct], args, rv, exception));
ASSERT_EQ(L"Uncaught My Exception", exception);
ASSERT_EQ(exception, "Uncaught My Exception");
}
argct++;
if(binding_test_)
{
// values
value = object->GetValue(L"intVal");
value = object->GetValue("intVal");
ASSERT_TRUE(value.get() != NULL);
ASSERT_TRUE(value->IsInt());
ASSERT_EQ(12, value->GetIntValue());
value = object->GetValue(L"doubleVal");
value = object->GetValue("doubleVal");
ASSERT_TRUE(value.get() != NULL);
ASSERT_TRUE(value->IsDouble());
ASSERT_EQ(5.432, value->GetDoubleValue());
value = object->GetValue(L"boolVal");
value = object->GetValue("boolVal");
ASSERT_TRUE(value.get() != NULL);
ASSERT_TRUE(value->IsBool());
ASSERT_EQ(true, value->GetBoolValue());
value = object->GetValue(L"stringVal");
value = object->GetValue("stringVal");
ASSERT_TRUE(value.get() != NULL);
ASSERT_TRUE(value->IsString());
ASSERT_EQ(L"the string", value->GetStringValue());
ASSERT_EQ(value->GetStringValue(), "the string");
value = object->GetValue(L"arrayVal");
value = object->GetValue("arrayVal");
ASSERT_TRUE(value.get() != NULL);
ASSERT_TRUE(value->IsArray());
{
@ -193,13 +193,13 @@ public:
value2 = value->GetValue(subargct);
ASSERT_TRUE(value2.get() != NULL);
ASSERT_TRUE(value2->IsString());
ASSERT_EQ(L"a string", value2->GetStringValue());
ASSERT_EQ(value2->GetStringValue(), "a string");
subargct++;
}
}
retval = CefV8Value::CreateInt(5);
} else if(name == L"execute2") {
} else if(name == "execute2") {
g_V8TestV8HandlerExecute2Called = true;
// check the result of calling the "execute" function
@ -242,8 +242,8 @@ public:
"</script>"
"</body></html>";
AddResource(L"http://tests/run.html", testHtml.str(), L"text/html");
CreateBrowser(L"http://tests/run.html");
AddResource("http://tests/run.html", testHtml.str(), "text/html");
CreateBrowser("http://tests/run.html");
}
virtual RetVal HandleLoadEnd(CefRefPtr<CefBrowser> browser,
@ -272,7 +272,7 @@ public:
// Create the new V8 object
CefRefPtr<CefV8Value> testObj = CefV8Value::CreateObject(NULL);
ASSERT_TRUE(testObj.get() != NULL);
ASSERT_TRUE(object->SetValue(L"test", testObj));
ASSERT_TRUE(object->SetValue("test", testObj));
// Create an instance of V8ExecuteV8Handler
CefRefPtr<CefV8Handler> testHandler(new V8TestV8Handler(true));
@ -280,30 +280,30 @@ public:
// Add the functions
CefRefPtr<CefV8Value> testFunc;
testFunc = CefV8Value::CreateFunction(L"execute", testHandler);
testFunc = CefV8Value::CreateFunction("execute", testHandler);
ASSERT_TRUE(testFunc.get() != NULL);
ASSERT_TRUE(testObj->SetValue(L"execute", testFunc));
testFunc = CefV8Value::CreateFunction(L"execute2", testHandler);
ASSERT_TRUE(testObj->SetValue("execute", testFunc));
testFunc = CefV8Value::CreateFunction("execute2", testHandler);
ASSERT_TRUE(testFunc.get() != NULL);
ASSERT_TRUE(testObj->SetValue(L"execute2", testFunc));
ASSERT_TRUE(testObj->SetValue("execute2", testFunc));
// Add the values
ASSERT_TRUE(testObj->SetValue(L"intVal",
ASSERT_TRUE(testObj->SetValue("intVal",
CefV8Value::CreateInt(12)));
ASSERT_TRUE(testObj->SetValue(L"doubleVal",
ASSERT_TRUE(testObj->SetValue("doubleVal",
CefV8Value::CreateDouble(5.432)));
ASSERT_TRUE(testObj->SetValue(L"boolVal",
ASSERT_TRUE(testObj->SetValue("boolVal",
CefV8Value::CreateBool(true)));
ASSERT_TRUE(testObj->SetValue(L"stringVal",
CefV8Value::CreateString(L"the string")));
ASSERT_TRUE(testObj->SetValue("stringVal",
CefV8Value::CreateString("the string")));
CefRefPtr<CefV8Value> testArray(CefV8Value::CreateArray());
ASSERT_TRUE(testArray.get() != NULL);
ASSERT_TRUE(testObj->SetValue(L"arrayVal", testArray));
ASSERT_TRUE(testObj->SetValue("arrayVal", testArray));
ASSERT_TRUE(testArray->SetValue(0, CefV8Value::CreateInt(4)));
ASSERT_TRUE(testArray->SetValue(1, CefV8Value::CreateDouble(120.43)));
ASSERT_TRUE(testArray->SetValue(2, CefV8Value::CreateBool(true)));
ASSERT_TRUE(testArray->SetValue(3, CefV8Value::CreateString(L"a string")));
ASSERT_TRUE(testArray->SetValue(3, CefV8Value::CreateString("a string")));
}
bool binding_test_;
@ -328,21 +328,21 @@ TEST(V8Test, Extension)
g_V8TestV8HandlerExecuteCalled = false;
g_V8TestV8HandlerExecute2Called = false;
std::wstring extensionCode =
L"var test;"
L"if (!test)"
L" test = {};"
L"(function() {"
L" test.execute = function(a,b,c,d,e,f,g,h) {"
L" native function execute();"
L" return execute(a,b,c,d,e,f,g,h);"
L" };"
L" test.execute2 = function(a) {"
L" native function execute2();"
L" return execute2(a);"
L" };"
L"})();";
CefRegisterExtension(L"v8/test", extensionCode, new V8TestV8Handler(false));
std::string extensionCode =
"var test;"
"if (!test)"
" test = {};"
"(function() {"
" test.execute = function(a,b,c,d,e,f,g,h) {"
" native function execute();"
" return execute(a,b,c,d,e,f,g,h);"
" };"
" test.execute2 = function(a) {"
" native function execute2();"
" return execute2(a);"
" };"
"})();";
CefRegisterExtension("v8/test", extensionCode, new V8TestV8Handler(false));
CefRefPtr<V8TestHandler> handler = new V8TestHandler(false);
handler->ExecuteTest();

334
tests/unittests/xml_reader_unittest.cc
View File

@ -40,40 +40,40 @@ TEST(XmlReaderTest, Read)
// Create the XML reader.
CefRefPtr<CefXmlReader> reader(
CefXmlReader::Create(stream, XML_ENCODING_NONE,
L"http://www.example.org/example.xml"));
"http://www.example.org/example.xml"));
ASSERT_TRUE(reader.get() != NULL);
// Move to the processing instruction node.
ASSERT_TRUE(reader->MoveToNextNode());
ASSERT_EQ(reader->GetDepth(), 0);
ASSERT_EQ(reader->GetType(), XML_NODE_PROCESSING_INSTRUCTION);
ASSERT_EQ(reader->GetLocalName(), L"my_instruction");
ASSERT_EQ(reader->GetQualifiedName(), L"my_instruction");
ASSERT_EQ(reader->GetLocalName(), "my_instruction");
ASSERT_EQ(reader->GetQualifiedName(), "my_instruction");
ASSERT_TRUE(reader->HasValue());
ASSERT_EQ(reader->GetValue(), L"my_value");
ASSERT_EQ(reader->GetValue(), "my_value");
// Move to the DOCTYPE node.
ASSERT_TRUE(reader->MoveToNextNode());
ASSERT_EQ(reader->GetDepth(), 0);
ASSERT_EQ(reader->GetType(), XML_NODE_DOCUMENT_TYPE);
ASSERT_EQ(reader->GetLocalName(), L"my_document");
ASSERT_EQ(reader->GetQualifiedName(), L"my_document");
ASSERT_EQ(reader->GetLocalName(), "my_document");
ASSERT_EQ(reader->GetQualifiedName(), "my_document");
ASSERT_FALSE(reader->HasValue());
// Move to ns:obj element start node.
ASSERT_TRUE(reader->MoveToNextNode());
ASSERT_EQ(reader->GetDepth(), 0);
ASSERT_EQ(reader->GetType(), XML_NODE_ELEMENT_START);
ASSERT_EQ(reader->GetLocalName(), L"obj");
ASSERT_EQ(reader->GetPrefix(), L"ns");
ASSERT_EQ(reader->GetQualifiedName(), L"ns:obj");
ASSERT_EQ(reader->GetNamespaceURI(), L"http://www.example.org/ns");
ASSERT_EQ(reader->GetLocalName(), "obj");
ASSERT_EQ(reader->GetPrefix(), "ns");
ASSERT_EQ(reader->GetQualifiedName(), "ns:obj");
ASSERT_EQ(reader->GetNamespaceURI(), "http://www.example.org/ns");
ASSERT_TRUE(reader->HasAttributes());
ASSERT_EQ(reader->GetAttributeCount(), (size_t)1);
ASSERT_EQ(reader->GetAttribute(0), L"http://www.example.org/ns");
ASSERT_EQ(reader->GetAttribute(L"xmlns:ns"), L"http://www.example.org/ns");
ASSERT_EQ(reader->GetAttribute(L"ns", L"http://www.w3.org/2000/xmlns/"),
L"http://www.example.org/ns");
ASSERT_EQ(reader->GetAttribute(0), "http://www.example.org/ns");
ASSERT_EQ(reader->GetAttribute("xmlns:ns"), "http://www.example.org/ns");
ASSERT_EQ(reader->GetAttribute("ns", "http://www.w3.org/2000/xmlns/"),
"http://www.example.org/ns");
// Move to the whitespace node.
ASSERT_TRUE(reader->MoveToNextNode());
@ -83,10 +83,10 @@ TEST(XmlReaderTest, Read)
ASSERT_TRUE(reader->MoveToNextNode());
ASSERT_EQ(reader->GetDepth(), 1);
ASSERT_EQ(reader->GetType(), XML_NODE_ELEMENT_START);
ASSERT_EQ(reader->GetLocalName(), L"objA");
ASSERT_EQ(reader->GetPrefix(), L"ns");
ASSERT_EQ(reader->GetQualifiedName(), L"ns:objA");
ASSERT_EQ(reader->GetNamespaceURI(), L"http://www.example.org/ns");
ASSERT_EQ(reader->GetLocalName(), "objA");
ASSERT_EQ(reader->GetPrefix(), "ns");
ASSERT_EQ(reader->GetQualifiedName(), "ns:objA");
ASSERT_EQ(reader->GetNamespaceURI(), "http://www.example.org/ns");
ASSERT_FALSE(reader->IsEmptyElement());
ASSERT_FALSE(reader->HasAttributes());
ASSERT_FALSE(reader->HasValue());
@ -95,19 +95,19 @@ TEST(XmlReaderTest, Read)
ASSERT_TRUE(reader->MoveToNextNode());
ASSERT_EQ(reader->GetDepth(), 2);
ASSERT_EQ(reader->GetType(), XML_NODE_TEXT);
ASSERT_EQ(reader->GetLocalName(), L"#text");
ASSERT_EQ(reader->GetQualifiedName(), L"#text");
ASSERT_EQ(reader->GetLocalName(), "#text");
ASSERT_EQ(reader->GetQualifiedName(), "#text");
ASSERT_TRUE(reader->HasValue());
ASSERT_EQ(reader->GetValue(), L"value A");
ASSERT_EQ(reader->GetValue(), "value A");
// Move to the ns:objA element ending node.
ASSERT_TRUE(reader->MoveToNextNode());
ASSERT_EQ(reader->GetDepth(), 1);
ASSERT_EQ(reader->GetType(), XML_NODE_ELEMENT_END);
ASSERT_EQ(reader->GetLocalName(), L"objA");
ASSERT_EQ(reader->GetPrefix(), L"ns");
ASSERT_EQ(reader->GetQualifiedName(), L"ns:objA");
ASSERT_EQ(reader->GetNamespaceURI(), L"http://www.example.org/ns");
ASSERT_EQ(reader->GetLocalName(), "objA");
ASSERT_EQ(reader->GetPrefix(), "ns");
ASSERT_EQ(reader->GetQualifiedName(), "ns:objA");
ASSERT_EQ(reader->GetNamespaceURI(), "http://www.example.org/ns");
ASSERT_FALSE(reader->IsEmptyElement());
ASSERT_FALSE(reader->HasAttributes());
ASSERT_FALSE(reader->HasValue());
@ -121,10 +121,10 @@ TEST(XmlReaderTest, Read)
ASSERT_TRUE(reader->MoveToNextNode());
ASSERT_EQ(reader->GetDepth(), 1);
ASSERT_EQ(reader->GetType(), XML_NODE_COMMENT);
ASSERT_EQ(reader->GetLocalName(), L"#comment");
ASSERT_EQ(reader->GetQualifiedName(), L"#comment");
ASSERT_EQ(reader->GetLocalName(), "#comment");
ASSERT_EQ(reader->GetQualifiedName(), "#comment");
ASSERT_TRUE(reader->HasValue());
ASSERT_EQ(reader->GetValue(), L" my comment ");
ASSERT_EQ(reader->GetValue(), " my comment ");
// Move to the whitespace node.
ASSERT_TRUE(reader->MoveToNextNode());
@ -134,10 +134,10 @@ TEST(XmlReaderTest, Read)
ASSERT_TRUE(reader->MoveToNextNode());
ASSERT_EQ(reader->GetDepth(), 1);
ASSERT_EQ(reader->GetType(), XML_NODE_ELEMENT_START);
ASSERT_EQ(reader->GetLocalName(), L"objB");
ASSERT_EQ(reader->GetPrefix(), L"ns");
ASSERT_EQ(reader->GetQualifiedName(), L"ns:objB");
ASSERT_EQ(reader->GetNamespaceURI(), L"http://www.example.org/ns");
ASSERT_EQ(reader->GetLocalName(), "objB");
ASSERT_EQ(reader->GetPrefix(), "ns");
ASSERT_EQ(reader->GetQualifiedName(), "ns:objB");
ASSERT_EQ(reader->GetNamespaceURI(), "http://www.example.org/ns");
ASSERT_FALSE(reader->IsEmptyElement());
ASSERT_FALSE(reader->HasAttributes());
ASSERT_FALSE(reader->HasValue());
@ -150,10 +150,10 @@ TEST(XmlReaderTest, Read)
ASSERT_TRUE(reader->MoveToNextNode());
ASSERT_EQ(reader->GetDepth(), 2);
ASSERT_EQ(reader->GetType(), XML_NODE_ELEMENT_START);
ASSERT_EQ(reader->GetLocalName(), L"objB_1");
ASSERT_EQ(reader->GetPrefix(), L"ns");
ASSERT_EQ(reader->GetQualifiedName(), L"ns:objB_1");
ASSERT_EQ(reader->GetNamespaceURI(), L"http://www.example.org/ns");
ASSERT_EQ(reader->GetLocalName(), "objB_1");
ASSERT_EQ(reader->GetPrefix(), "ns");
ASSERT_EQ(reader->GetQualifiedName(), "ns:objB_1");
ASSERT_EQ(reader->GetNamespaceURI(), "http://www.example.org/ns");
ASSERT_FALSE(reader->IsEmptyElement());
ASSERT_FALSE(reader->HasAttributes());
ASSERT_FALSE(reader->HasValue());
@ -163,16 +163,16 @@ TEST(XmlReaderTest, Read)
ASSERT_EQ(reader->GetDepth(), 3);
ASSERT_EQ(reader->GetType(), XML_NODE_TEXT);
ASSERT_TRUE(reader->HasValue());
ASSERT_EQ(reader->GetValue(), L"value B1");
ASSERT_EQ(reader->GetValue(), "value B1");
// Move to the ns:objB_1 element ending node.
ASSERT_TRUE(reader->MoveToNextNode());
ASSERT_EQ(reader->GetDepth(), 2);
ASSERT_EQ(reader->GetType(), XML_NODE_ELEMENT_END);
ASSERT_EQ(reader->GetLocalName(), L"objB_1");
ASSERT_EQ(reader->GetPrefix(), L"ns");
ASSERT_EQ(reader->GetQualifiedName(), L"ns:objB_1");
ASSERT_EQ(reader->GetNamespaceURI(), L"http://www.example.org/ns");
ASSERT_EQ(reader->GetLocalName(), "objB_1");
ASSERT_EQ(reader->GetPrefix(), "ns");
ASSERT_EQ(reader->GetQualifiedName(), "ns:objB_1");
ASSERT_EQ(reader->GetNamespaceURI(), "http://www.example.org/ns");
ASSERT_FALSE(reader->IsEmptyElement());
ASSERT_FALSE(reader->HasAttributes());
ASSERT_FALSE(reader->HasValue());
@ -185,10 +185,10 @@ TEST(XmlReaderTest, Read)
ASSERT_TRUE(reader->MoveToNextNode());
ASSERT_EQ(reader->GetDepth(), 2);
ASSERT_EQ(reader->GetType(), XML_NODE_ELEMENT_START);
ASSERT_EQ(reader->GetLocalName(), L"objB_2");
ASSERT_EQ(reader->GetPrefix(), L"ns");
ASSERT_EQ(reader->GetQualifiedName(), L"ns:objB_2");
ASSERT_EQ(reader->GetNamespaceURI(), L"http://www.example.org/ns");
ASSERT_EQ(reader->GetLocalName(), "objB_2");
ASSERT_EQ(reader->GetPrefix(), "ns");
ASSERT_EQ(reader->GetQualifiedName(), "ns:objB_2");
ASSERT_EQ(reader->GetNamespaceURI(), "http://www.example.org/ns");
ASSERT_FALSE(reader->IsEmptyElement());
ASSERT_FALSE(reader->HasAttributes());
ASSERT_FALSE(reader->HasValue());
@ -198,16 +198,16 @@ TEST(XmlReaderTest, Read)
ASSERT_EQ(reader->GetDepth(), 3);
ASSERT_EQ(reader->GetType(), XML_NODE_CDATA);
ASSERT_TRUE(reader->HasValue());
ASSERT_EQ(reader->GetValue(), L"some <br/> data");
ASSERT_EQ(reader->GetValue(), "some <br/> data");
// Move to the ns:objB_2 element ending node.
ASSERT_TRUE(reader->MoveToNextNode());
ASSERT_EQ(reader->GetDepth(), 2);
ASSERT_EQ(reader->GetType(), XML_NODE_ELEMENT_END);
ASSERT_EQ(reader->GetLocalName(), L"objB_2");
ASSERT_EQ(reader->GetPrefix(), L"ns");
ASSERT_EQ(reader->GetQualifiedName(), L"ns:objB_2");
ASSERT_EQ(reader->GetNamespaceURI(), L"http://www.example.org/ns");
ASSERT_EQ(reader->GetLocalName(), "objB_2");
ASSERT_EQ(reader->GetPrefix(), "ns");
ASSERT_EQ(reader->GetQualifiedName(), "ns:objB_2");
ASSERT_EQ(reader->GetNamespaceURI(), "http://www.example.org/ns");
ASSERT_FALSE(reader->IsEmptyElement());
ASSERT_FALSE(reader->HasAttributes());
ASSERT_FALSE(reader->HasValue());
@ -220,10 +220,10 @@ TEST(XmlReaderTest, Read)
ASSERT_TRUE(reader->MoveToNextNode());
ASSERT_EQ(reader->GetDepth(), 2);
ASSERT_EQ(reader->GetType(), XML_NODE_ELEMENT_START);
ASSERT_EQ(reader->GetLocalName(), L"objB_3");
ASSERT_EQ(reader->GetPrefix(), L"ns");
ASSERT_EQ(reader->GetQualifiedName(), L"ns:objB_3");
ASSERT_EQ(reader->GetNamespaceURI(), L"http://www.example.org/ns");
ASSERT_EQ(reader->GetLocalName(), "objB_3");
ASSERT_EQ(reader->GetPrefix(), "ns");
ASSERT_EQ(reader->GetQualifiedName(), "ns:objB_3");
ASSERT_EQ(reader->GetNamespaceURI(), "http://www.example.org/ns");
ASSERT_FALSE(reader->IsEmptyElement());
ASSERT_FALSE(reader->HasAttributes());
ASSERT_FALSE(reader->HasValue());
@ -232,19 +232,19 @@ TEST(XmlReaderTest, Read)
ASSERT_TRUE(reader->MoveToNextNode());
ASSERT_EQ(reader->GetDepth(), 3);
ASSERT_EQ(reader->GetType(), XML_NODE_ENTITY_REFERENCE);
ASSERT_EQ(reader->GetLocalName(), L"EB");
ASSERT_EQ(reader->GetQualifiedName(), L"EB");
ASSERT_EQ(reader->GetLocalName(), "EB");
ASSERT_EQ(reader->GetQualifiedName(), "EB");
ASSERT_TRUE(reader->HasValue());
ASSERT_EQ(reader->GetValue(), L"EB Value");
ASSERT_EQ(reader->GetValue(), "EB Value");
// Move to the ns:objB_3 element ending node.
ASSERT_TRUE(reader->MoveToNextNode());
ASSERT_EQ(reader->GetDepth(), 2);
ASSERT_EQ(reader->GetType(), XML_NODE_ELEMENT_END);
ASSERT_EQ(reader->GetLocalName(), L"objB_3");
ASSERT_EQ(reader->GetPrefix(), L"ns");
ASSERT_EQ(reader->GetQualifiedName(), L"ns:objB_3");
ASSERT_EQ(reader->GetNamespaceURI(), L"http://www.example.org/ns");
ASSERT_EQ(reader->GetLocalName(), "objB_3");
ASSERT_EQ(reader->GetPrefix(), "ns");
ASSERT_EQ(reader->GetQualifiedName(), "ns:objB_3");
ASSERT_EQ(reader->GetNamespaceURI(), "http://www.example.org/ns");
ASSERT_FALSE(reader->IsEmptyElement());
ASSERT_FALSE(reader->HasAttributes());
ASSERT_FALSE(reader->HasValue());
@ -257,24 +257,24 @@ TEST(XmlReaderTest, Read)
ASSERT_TRUE(reader->MoveToNextNode());
ASSERT_EQ(reader->GetDepth(), 2);
ASSERT_EQ(reader->GetType(), XML_NODE_ELEMENT_START);
ASSERT_EQ(reader->GetLocalName(), L"objB_4");
ASSERT_EQ(reader->GetPrefix(), L"ns");
ASSERT_EQ(reader->GetQualifiedName(), L"ns:objB_4");
ASSERT_EQ(reader->GetNamespaceURI(), L"http://www.example.org/ns");
ASSERT_EQ(reader->GetLocalName(), "objB_4");
ASSERT_EQ(reader->GetPrefix(), "ns");
ASSERT_EQ(reader->GetQualifiedName(), "ns:objB_4");
ASSERT_EQ(reader->GetNamespaceURI(), "http://www.example.org/ns");
ASSERT_FALSE(reader->IsEmptyElement());
ASSERT_FALSE(reader->HasAttributes());
ASSERT_FALSE(reader->HasValue());
ASSERT_EQ(reader->GetInnerXml(), L"<b>this is</b> mixed content &EA;");
ASSERT_EQ(reader->GetInnerXml(), "<b>this is</b> mixed content &EA;");
ASSERT_EQ(reader->GetOuterXml(),
L"<ns:objB_4 xmlns:ns=\"http://www.example.org/ns\">"
L"<b>this is</b> mixed content &EA;</ns:objB_4>");
"<ns:objB_4 xmlns:ns=\"http://www.example.org/ns\">"
"<b>this is</b> mixed content &EA;</ns:objB_4>");
// Move to the <b> element node.
ASSERT_TRUE(reader->MoveToNextNode());
ASSERT_EQ(reader->GetDepth(), 3);
ASSERT_EQ(reader->GetType(), XML_NODE_ELEMENT_START);
ASSERT_EQ(reader->GetLocalName(), L"b");
ASSERT_EQ(reader->GetQualifiedName(), L"b");
ASSERT_EQ(reader->GetLocalName(), "b");
ASSERT_EQ(reader->GetQualifiedName(), "b");
ASSERT_FALSE(reader->IsEmptyElement());
ASSERT_FALSE(reader->HasAttributes());
ASSERT_FALSE(reader->HasValue());
@ -283,44 +283,44 @@ TEST(XmlReaderTest, Read)
ASSERT_TRUE(reader->MoveToNextNode());
ASSERT_EQ(reader->GetDepth(), 4);
ASSERT_EQ(reader->GetType(), XML_NODE_TEXT);
ASSERT_EQ(reader->GetLocalName(), L"#text");
ASSERT_EQ(reader->GetQualifiedName(), L"#text");
ASSERT_EQ(reader->GetLocalName(), "#text");
ASSERT_EQ(reader->GetQualifiedName(), "#text");
ASSERT_TRUE(reader->HasValue());
ASSERT_EQ(reader->GetValue(), L"this is");
ASSERT_EQ(reader->GetValue(), "this is");
// Move to the </b> element node.
ASSERT_TRUE(reader->MoveToNextNode());
ASSERT_EQ(reader->GetDepth(), 3);
ASSERT_EQ(reader->GetType(), XML_NODE_ELEMENT_END);
ASSERT_EQ(reader->GetLocalName(), L"b");
ASSERT_EQ(reader->GetQualifiedName(), L"b");
ASSERT_EQ(reader->GetLocalName(), "b");
ASSERT_EQ(reader->GetQualifiedName(), "b");
// Move to the text node.
ASSERT_TRUE(reader->MoveToNextNode());
ASSERT_EQ(reader->GetDepth(), 3);
ASSERT_EQ(reader->GetType(), XML_NODE_TEXT);
ASSERT_EQ(reader->GetLocalName(), L"#text");
ASSERT_EQ(reader->GetQualifiedName(), L"#text");
ASSERT_EQ(reader->GetLocalName(), "#text");
ASSERT_EQ(reader->GetQualifiedName(), "#text");
ASSERT_TRUE(reader->HasValue());
ASSERT_EQ(reader->GetValue(), L" mixed content ");
ASSERT_EQ(reader->GetValue(), " mixed content ");
// Move to the EA entity reference node.
ASSERT_TRUE(reader->MoveToNextNode());
ASSERT_EQ(reader->GetDepth(), 3);
ASSERT_EQ(reader->GetType(), XML_NODE_ENTITY_REFERENCE);
ASSERT_EQ(reader->GetLocalName(), L"EA");
ASSERT_EQ(reader->GetQualifiedName(), L"EA");
ASSERT_EQ(reader->GetLocalName(), "EA");
ASSERT_EQ(reader->GetQualifiedName(), "EA");
ASSERT_TRUE(reader->HasValue());
ASSERT_EQ(reader->GetValue(), L"EA Value");
ASSERT_EQ(reader->GetValue(), "EA Value");
// Move to the ns:objB_4 element ending node.
ASSERT_TRUE(reader->MoveToNextNode());
ASSERT_EQ(reader->GetDepth(), 2);
ASSERT_EQ(reader->GetType(), XML_NODE_ELEMENT_END);
ASSERT_EQ(reader->GetLocalName(), L"objB_4");
ASSERT_EQ(reader->GetPrefix(), L"ns");
ASSERT_EQ(reader->GetQualifiedName(), L"ns:objB_4");
ASSERT_EQ(reader->GetNamespaceURI(), L"http://www.example.org/ns");
ASSERT_EQ(reader->GetLocalName(), "objB_4");
ASSERT_EQ(reader->GetPrefix(), "ns");
ASSERT_EQ(reader->GetQualifiedName(), "ns:objB_4");
ASSERT_EQ(reader->GetNamespaceURI(), "http://www.example.org/ns");
ASSERT_FALSE(reader->IsEmptyElement());
ASSERT_FALSE(reader->HasAttributes());
ASSERT_FALSE(reader->HasValue());
@ -333,10 +333,10 @@ TEST(XmlReaderTest, Read)
ASSERT_TRUE(reader->MoveToNextNode());
ASSERT_EQ(reader->GetDepth(), 1);
ASSERT_EQ(reader->GetType(), XML_NODE_ELEMENT_END);
ASSERT_EQ(reader->GetLocalName(), L"objB");
ASSERT_EQ(reader->GetPrefix(), L"ns");
ASSERT_EQ(reader->GetQualifiedName(), L"ns:objB");
ASSERT_EQ(reader->GetNamespaceURI(), L"http://www.example.org/ns");
ASSERT_EQ(reader->GetLocalName(), "objB");
ASSERT_EQ(reader->GetPrefix(), "ns");
ASSERT_EQ(reader->GetQualifiedName(), "ns:objB");
ASSERT_EQ(reader->GetNamespaceURI(), "http://www.example.org/ns");
ASSERT_FALSE(reader->IsEmptyElement());
ASSERT_FALSE(reader->HasAttributes());
ASSERT_FALSE(reader->HasValue());
@ -349,48 +349,48 @@ TEST(XmlReaderTest, Read)
ASSERT_TRUE(reader->MoveToNextNode());
ASSERT_EQ(reader->GetDepth(), 1);
ASSERT_EQ(reader->GetType(), XML_NODE_ELEMENT_START);
ASSERT_EQ(reader->GetLocalName(), L"objC");
ASSERT_EQ(reader->GetPrefix(), L"ns");
ASSERT_EQ(reader->GetQualifiedName(), L"ns:objC");
ASSERT_EQ(reader->GetNamespaceURI(), L"http://www.example.org/ns");
ASSERT_EQ(reader->GetLocalName(), "objC");
ASSERT_EQ(reader->GetPrefix(), "ns");
ASSERT_EQ(reader->GetQualifiedName(), "ns:objC");
ASSERT_EQ(reader->GetNamespaceURI(), "http://www.example.org/ns");
ASSERT_TRUE(reader->IsEmptyElement());
ASSERT_TRUE(reader->HasAttributes());
ASSERT_FALSE(reader->HasValue());
ASSERT_EQ(reader->GetAttributeCount(), (size_t)2);
ASSERT_EQ(reader->GetAttribute(0), L"value C1");
ASSERT_EQ(reader->GetAttribute(L"ns:attr1"), L"value C1");
ASSERT_EQ(reader->GetAttribute(L"attr1", L"http://www.example.org/ns"),
L"value C1");
ASSERT_EQ(reader->GetAttribute(1), L"value C2");
ASSERT_EQ(reader->GetAttribute(L"ns:attr2"), L"value C2");
ASSERT_EQ(reader->GetAttribute(L"attr2", L"http://www.example.org/ns"),
L"value C2");
ASSERT_EQ(reader->GetAttribute(0), "value C1");
ASSERT_EQ(reader->GetAttribute("ns:attr1"), "value C1");
ASSERT_EQ(reader->GetAttribute("attr1", "http://www.example.org/ns"),
"value C1");
ASSERT_EQ(reader->GetAttribute(1), "value C2");
ASSERT_EQ(reader->GetAttribute("ns:attr2"), "value C2");
ASSERT_EQ(reader->GetAttribute("attr2", "http://www.example.org/ns"),
"value C2");
// Move to the ns:attr1 attribute.
ASSERT_TRUE(reader->MoveToFirstAttribute());
ASSERT_EQ(reader->GetDepth(), 2);
ASSERT_EQ(reader->GetType(), XML_NODE_ATTRIBUTE);
ASSERT_EQ(reader->GetLocalName(), L"attr1");
ASSERT_EQ(reader->GetPrefix(), L"ns");
ASSERT_EQ(reader->GetQualifiedName(), L"ns:attr1");
ASSERT_EQ(reader->GetNamespaceURI(), L"http://www.example.org/ns");
ASSERT_EQ(reader->GetLocalName(), "attr1");
ASSERT_EQ(reader->GetPrefix(), "ns");
ASSERT_EQ(reader->GetQualifiedName(), "ns:attr1");
ASSERT_EQ(reader->GetNamespaceURI(), "http://www.example.org/ns");
ASSERT_TRUE(reader->HasValue());
ASSERT_FALSE(reader->IsEmptyElement());
ASSERT_FALSE(reader->HasAttributes());
ASSERT_EQ(reader->GetValue(), L"value C1");
ASSERT_EQ(reader->GetValue(), "value C1");
// Move to the ns:attr2 attribute.
ASSERT_TRUE(reader->MoveToNextAttribute());
ASSERT_EQ(reader->GetDepth(), 2);
ASSERT_EQ(reader->GetType(), XML_NODE_ATTRIBUTE);
ASSERT_EQ(reader->GetLocalName(), L"attr2");
ASSERT_EQ(reader->GetPrefix(), L"ns");
ASSERT_EQ(reader->GetQualifiedName(), L"ns:attr2");
ASSERT_EQ(reader->GetNamespaceURI(), L"http://www.example.org/ns");
ASSERT_EQ(reader->GetLocalName(), "attr2");
ASSERT_EQ(reader->GetPrefix(), "ns");
ASSERT_EQ(reader->GetQualifiedName(), "ns:attr2");
ASSERT_EQ(reader->GetNamespaceURI(), "http://www.example.org/ns");
ASSERT_TRUE(reader->HasValue());
ASSERT_FALSE(reader->IsEmptyElement());
ASSERT_FALSE(reader->HasAttributes());
ASSERT_EQ(reader->GetValue(), L"value C2");
ASSERT_EQ(reader->GetValue(), "value C2");
// No more attributes.
ASSERT_FALSE(reader->MoveToNextAttribute());
@ -399,60 +399,60 @@ TEST(XmlReaderTest, Read)
ASSERT_TRUE(reader->MoveToCarryingElement());
ASSERT_EQ(reader->GetDepth(), 1);
ASSERT_EQ(reader->GetType(), XML_NODE_ELEMENT_START);
ASSERT_EQ(reader->GetQualifiedName(), L"ns:objC");
ASSERT_EQ(reader->GetQualifiedName(), "ns:objC");
// Move to the ns:attr1 attribute.
ASSERT_TRUE(reader->MoveToAttribute(0));
ASSERT_EQ(reader->GetDepth(), 2);
ASSERT_EQ(reader->GetType(), XML_NODE_ATTRIBUTE);
ASSERT_EQ(reader->GetLocalName(), L"attr1");
ASSERT_EQ(reader->GetPrefix(), L"ns");
ASSERT_EQ(reader->GetQualifiedName(), L"ns:attr1");
ASSERT_EQ(reader->GetNamespaceURI(), L"http://www.example.org/ns");
ASSERT_EQ(reader->GetLocalName(), "attr1");
ASSERT_EQ(reader->GetPrefix(), "ns");
ASSERT_EQ(reader->GetQualifiedName(), "ns:attr1");
ASSERT_EQ(reader->GetNamespaceURI(), "http://www.example.org/ns");
ASSERT_TRUE(reader->HasValue());
ASSERT_FALSE(reader->IsEmptyElement());
ASSERT_FALSE(reader->HasAttributes());
ASSERT_EQ(reader->GetValue(), L"value C1");
ASSERT_EQ(reader->GetValue(), "value C1");
// Return to the ns:objC element start node.
ASSERT_TRUE(reader->MoveToCarryingElement());
ASSERT_EQ(reader->GetDepth(), 1);
ASSERT_EQ(reader->GetType(), XML_NODE_ELEMENT_START);
ASSERT_EQ(reader->GetQualifiedName(), L"ns:objC");
ASSERT_EQ(reader->GetQualifiedName(), "ns:objC");
// Move to the ns:attr2 attribute.
ASSERT_TRUE(reader->MoveToAttribute(L"ns:attr2"));
ASSERT_TRUE(reader->MoveToAttribute("ns:attr2"));
ASSERT_EQ(reader->GetDepth(), 2);
ASSERT_EQ(reader->GetType(), XML_NODE_ATTRIBUTE);
ASSERT_EQ(reader->GetLocalName(), L"attr2");
ASSERT_EQ(reader->GetPrefix(), L"ns");
ASSERT_EQ(reader->GetQualifiedName(), L"ns:attr2");
ASSERT_EQ(reader->GetNamespaceURI(), L"http://www.example.org/ns");
ASSERT_EQ(reader->GetLocalName(), "attr2");
ASSERT_EQ(reader->GetPrefix(), "ns");
ASSERT_EQ(reader->GetQualifiedName(), "ns:attr2");
ASSERT_EQ(reader->GetNamespaceURI(), "http://www.example.org/ns");
ASSERT_TRUE(reader->HasValue());
ASSERT_FALSE(reader->IsEmptyElement());
ASSERT_FALSE(reader->HasAttributes());
ASSERT_EQ(reader->GetValue(), L"value C2");
ASSERT_EQ(reader->GetValue(), "value C2");
// Move to the ns:attr1 attribute without returning to the ns:objC element.
ASSERT_TRUE(reader->MoveToAttribute(L"attr1", L"http://www.example.org/ns"));
ASSERT_TRUE(reader->MoveToAttribute("attr1", "http://www.example.org/ns"));
ASSERT_EQ(reader->GetDepth(), 2);
ASSERT_EQ(reader->GetType(), XML_NODE_ATTRIBUTE);
ASSERT_EQ(reader->GetLocalName(), L"attr1");
ASSERT_EQ(reader->GetPrefix(), L"ns");
ASSERT_EQ(reader->GetQualifiedName(), L"ns:attr1");
ASSERT_EQ(reader->GetNamespaceURI(), L"http://www.example.org/ns");
ASSERT_EQ(reader->GetLocalName(), "attr1");
ASSERT_EQ(reader->GetPrefix(), "ns");
ASSERT_EQ(reader->GetQualifiedName(), "ns:attr1");
ASSERT_EQ(reader->GetNamespaceURI(), "http://www.example.org/ns");
ASSERT_TRUE(reader->HasValue());
ASSERT_FALSE(reader->IsEmptyElement());
ASSERT_FALSE(reader->HasAttributes());
ASSERT_EQ(reader->GetValue(), L"value C1");
ASSERT_EQ(reader->GetValue(), "value C1");
// Move to the ns:objD element start node.
ASSERT_TRUE(reader->MoveToNextNode());
ASSERT_EQ(reader->GetDepth(), 1);
ASSERT_EQ(reader->GetType(), XML_NODE_ELEMENT_START);
ASSERT_EQ(reader->GetLocalName(), L"objD");
ASSERT_EQ(reader->GetPrefix(), L"ns");
ASSERT_EQ(reader->GetQualifiedName(), L"ns:objD");
ASSERT_EQ(reader->GetLocalName(), "objD");
ASSERT_EQ(reader->GetPrefix(), "ns");
ASSERT_EQ(reader->GetQualifiedName(), "ns:objD");
ASSERT_FALSE(reader->IsEmptyElement());
ASSERT_FALSE(reader->HasAttributes());
ASSERT_FALSE(reader->HasValue());
@ -461,9 +461,9 @@ TEST(XmlReaderTest, Read)
ASSERT_TRUE(reader->MoveToNextNode());
ASSERT_EQ(reader->GetDepth(), 1);
ASSERT_EQ(reader->GetType(), XML_NODE_ELEMENT_END);
ASSERT_EQ(reader->GetLocalName(), L"objD");
ASSERT_EQ(reader->GetPrefix(), L"ns");
ASSERT_EQ(reader->GetQualifiedName(), L"ns:objD");
ASSERT_EQ(reader->GetLocalName(), "objD");
ASSERT_EQ(reader->GetPrefix(), "ns");
ASSERT_EQ(reader->GetQualifiedName(), "ns:objD");
ASSERT_FALSE(reader->IsEmptyElement());
ASSERT_FALSE(reader->HasAttributes());
ASSERT_FALSE(reader->HasValue());
@ -476,10 +476,10 @@ TEST(XmlReaderTest, Read)
ASSERT_TRUE(reader->MoveToNextNode());
ASSERT_EQ(reader->GetDepth(), 0);
ASSERT_EQ(reader->GetType(), XML_NODE_ELEMENT_END);
ASSERT_EQ(reader->GetLocalName(), L"obj");
ASSERT_EQ(reader->GetPrefix(), L"ns");
ASSERT_EQ(reader->GetQualifiedName(), L"ns:obj");
ASSERT_EQ(reader->GetNamespaceURI(), L"http://www.example.org/ns");
ASSERT_EQ(reader->GetLocalName(), "obj");
ASSERT_EQ(reader->GetPrefix(), "ns");
ASSERT_EQ(reader->GetQualifiedName(), "ns:obj");
ASSERT_EQ(reader->GetNamespaceURI(), "http://www.example.org/ns");
ASSERT_FALSE(reader->IsEmptyElement());
ASSERT_TRUE(reader->HasAttributes());
ASSERT_FALSE(reader->HasValue());
@ -509,7 +509,7 @@ TEST(XmlReaderTest, ReadError)
// Create the XML reader.
CefRefPtr<CefXmlReader> reader(
CefXmlReader::Create(stream, XML_ENCODING_NONE,
L"http://www.example.org/example.xml"));
"http://www.example.org/example.xml"));
ASSERT_TRUE(reader.get() != NULL);
// Move to the processing instruction node and generate parser error.
@ -526,22 +526,22 @@ TEST(XmlReaderTest, ObjectLoad)
ASSERT_TRUE(stream.get() != NULL);
// Create the XML reader.
CefRefPtr<CefXmlObject> object(new CefXmlObject(L"object"));
CefRefPtr<CefXmlObject> object(new CefXmlObject("object"));
ASSERT_TRUE(object->Load(stream, XML_ENCODING_NONE,
L"http://www.example.org/example.xml", NULL));
"http://www.example.org/example.xml", NULL));
ASSERT_FALSE(object->HasAttributes());
ASSERT_TRUE(object->HasChildren());
ASSERT_EQ(object->GetChildCount(), (size_t)1);
CefRefPtr<CefXmlObject> obj(object->FindChild(L"ns:obj"));
CefRefPtr<CefXmlObject> obj(object->FindChild("ns:obj"));
ASSERT_TRUE(obj.get());
ASSERT_TRUE(obj->HasChildren());
ASSERT_EQ(obj->GetChildCount(), (size_t)4);
CefRefPtr<CefXmlObject> obj_child(obj->FindChild(L"ns:objC"));
CefRefPtr<CefXmlObject> obj_child(obj->FindChild("ns:objC"));
ASSERT_TRUE(obj_child.get());
ASSERT_EQ(obj_child->GetName(), L"ns:objC");
ASSERT_EQ(obj_child->GetName(), "ns:objC");
ASSERT_FALSE(obj_child->HasChildren());
ASSERT_FALSE(obj_child->HasValue());
ASSERT_TRUE(obj_child->HasAttributes());
@ -556,26 +556,26 @@ TEST(XmlReaderTest, ObjectLoad)
ASSERT_TRUE(obj_child.get());
if (ct == 0) {
// ns:objA
ASSERT_EQ(obj_child->GetName(), L"ns:objA");
ASSERT_EQ(obj_child->GetName(), "ns:objA");
ASSERT_FALSE(obj_child->HasChildren());
ASSERT_TRUE(obj_child->HasValue());
ASSERT_FALSE(obj_child->HasAttributes());
ASSERT_EQ(obj_child->GetValue(), L"value A");
ASSERT_EQ(obj_child->GetValue(), "value A");
} else if (ct == 1) {
// ns:objB
ASSERT_EQ(obj_child->GetName(), L"ns:objB");
ASSERT_EQ(obj_child->GetName(), "ns:objB");
ASSERT_TRUE(obj_child->HasChildren());
ASSERT_FALSE(obj_child->HasValue());
ASSERT_FALSE(obj_child->HasAttributes());
ASSERT_EQ(obj_child->GetChildCount(), (size_t)4);
obj_child = obj_child->FindChild(L"ns:objB_4");
obj_child = obj_child->FindChild("ns:objB_4");
ASSERT_TRUE(obj_child.get());
ASSERT_TRUE(obj_child->HasValue());
ASSERT_EQ(obj_child->GetValue(),
L"<b>this is</b> mixed content EA Value");
"<b>this is</b> mixed content EA Value");
} else if (ct == 2) {
// ns:objC
ASSERT_EQ(obj_child->GetName(), L"ns:objC");
ASSERT_EQ(obj_child->GetName(), "ns:objC");
ASSERT_FALSE(obj_child->HasChildren());
ASSERT_FALSE(obj_child->HasValue());
ASSERT_TRUE(obj_child->HasAttributes());
@ -583,17 +583,17 @@ TEST(XmlReaderTest, ObjectLoad)
CefXmlObject::AttributeMap attribs;
ASSERT_EQ(obj_child->GetAttributes(attribs), (size_t)2);
ASSERT_EQ(attribs.size(), (size_t)2);
ASSERT_EQ(attribs[L"ns:attr1"], L"value C1");
ASSERT_EQ(attribs[L"ns:attr2"], L"value C2");
ASSERT_EQ(attribs["ns:attr1"], "value C1");
ASSERT_EQ(attribs["ns:attr2"], "value C2");
ASSERT_EQ(obj_child->GetAttributeCount(), (size_t)2);
ASSERT_TRUE(obj_child->HasAttribute(L"ns:attr1"));
ASSERT_EQ(obj_child->GetAttributeValue(L"ns:attr1"), L"value C1");
ASSERT_TRUE(obj_child->HasAttribute(L"ns:attr2"));
ASSERT_EQ(obj_child->GetAttributeValue(L"ns:attr2"), L"value C2");
ASSERT_TRUE(obj_child->HasAttribute("ns:attr1"));
ASSERT_EQ(obj_child->GetAttributeValue("ns:attr1"), "value C1");
ASSERT_TRUE(obj_child->HasAttribute("ns:attr2"));
ASSERT_EQ(obj_child->GetAttributeValue("ns:attr2"), "value C2");
} else if (ct == 3) {
// ns:objD
ASSERT_EQ(obj_child->GetName(), L"ns:objD");
ASSERT_EQ(obj_child->GetName(), "ns:objD");
ASSERT_FALSE(obj_child->HasChildren());
ASSERT_FALSE(obj_child->HasValue());
ASSERT_FALSE(obj_child->HasAttributes());
@ -613,14 +613,14 @@ TEST(XmlReaderTest, ObjectLoadError)
CefStreamReader::CreateForData(error_xml, sizeof(error_xml) - 1));
ASSERT_TRUE(stream.get() != NULL);
std::wstring error_str;
CefString error_str;
// Create the XML reader.
CefRefPtr<CefXmlObject> object(new CefXmlObject(L"object"));
CefRefPtr<CefXmlObject> object(new CefXmlObject("object"));
ASSERT_FALSE(object->Load(stream, XML_ENCODING_NONE,
L"http://www.example.org/example.xml", &error_str));
"http://www.example.org/example.xml", &error_str));
ASSERT_EQ(error_str,
L"Opening and ending tag mismatch: foo line 2 and obj, line 3");
"Opening and ending tag mismatch: foo line 2 and obj, line 3");
}
// Test value following child error.
@ -632,13 +632,13 @@ TEST(XmlReaderTest, ObjectLoadError)
CefStreamReader::CreateForData(error_xml, sizeof(error_xml) - 1));
ASSERT_TRUE(stream.get() != NULL);
std::wstring error_str;
CefString error_str;
// Create the XML reader.
CefRefPtr<CefXmlObject> object(new CefXmlObject(L"object"));
CefRefPtr<CefXmlObject> object(new CefXmlObject("object"));
ASSERT_FALSE(object->Load(stream, XML_ENCODING_NONE,
L"http://www.example.org/example.xml", &error_str));
"http://www.example.org/example.xml", &error_str));
ASSERT_EQ(error_str,
L"Value following child element, line 4");
"Value following child element, line 4");
}
}

50
tests/unittests/zip_reader_unittest.cc
View File

@ -139,57 +139,57 @@ TEST(ZipReaderTest, Read)
// Walk through the archive contents.
ASSERT_TRUE(reader->MoveToFirstFile());
ASSERT_EQ(reader->GetFileName(), L"test_archive/");
ASSERT_EQ(reader->GetFileName(), "test_archive/");
ASSERT_EQ(reader->GetFileSize(), 0);
ASSERT_TRUE(reader->MoveToNextFile());
ASSERT_EQ(reader->GetFileName(), L"test_archive/file 1.txt");
ASSERT_EQ(reader->GetFileName(), "test_archive/file 1.txt");
ASSERT_EQ(reader->GetFileSize(), 19);
ASSERT_TRUE(reader->OpenFile(L""));
ASSERT_TRUE(reader->OpenFile(""));
ASSERT_EQ(reader->ReadFile(buff, sizeof(buff)), 19);
ASSERT_TRUE(!strncmp(buff, "Contents of file 1.", 19));
ASSERT_TRUE(reader->MoveToNextFile());
ASSERT_EQ(reader->GetFileName(), L"test_archive/folder 1/");
ASSERT_EQ(reader->GetFileName(), "test_archive/folder 1/");
ASSERT_EQ(reader->GetFileSize(), 0);
ASSERT_TRUE(reader->MoveToNextFile());
ASSERT_EQ(reader->GetFileName(), L"test_archive/folder 1/file 1a.txt");
ASSERT_EQ(reader->GetFileName(), "test_archive/folder 1/file 1a.txt");
ASSERT_EQ(reader->GetFileSize(), 20);
ASSERT_TRUE(reader->OpenFile(L""));
ASSERT_TRUE(reader->OpenFile(""));
ASSERT_EQ(reader->ReadFile(buff, sizeof(buff)), 20);
ASSERT_TRUE(reader->CloseFile());
ASSERT_TRUE(!strncmp(buff, "Contents of file 1A.", 20));
ASSERT_TRUE(reader->MoveToNextFile());
ASSERT_EQ(reader->GetFileName(), L"test_archive/folder 1/file 1b.txt");
ASSERT_EQ(reader->GetFileName(), "test_archive/folder 1/file 1b.txt");
ASSERT_EQ(reader->GetFileSize(), 20);
ASSERT_TRUE(reader->OpenFile(L""));
ASSERT_TRUE(reader->OpenFile(""));
ASSERT_EQ(reader->ReadFile(buff, sizeof(buff)), 20);
ASSERT_TRUE(reader->CloseFile());
ASSERT_TRUE(!strncmp(buff, "Contents of file 1B.", 20));
ASSERT_TRUE(reader->MoveToNextFile());
ASSERT_EQ(reader->GetFileName(), L"test_archive/folder 1/folder 1a/");
ASSERT_EQ(reader->GetFileName(), "test_archive/folder 1/folder 1a/");
ASSERT_EQ(reader->GetFileSize(), 0);
ASSERT_TRUE(reader->MoveToNextFile());
ASSERT_EQ(reader->GetFileName(),
L"test_archive/folder 1/folder 1a/file 1a1.txt");
"test_archive/folder 1/folder 1a/file 1a1.txt");
ASSERT_EQ(reader->GetFileSize(), 21);
ASSERT_TRUE(reader->OpenFile(L""));
ASSERT_TRUE(reader->OpenFile(""));
ASSERT_EQ(reader->ReadFile(buff, sizeof(buff)), 21);
ASSERT_TRUE(reader->CloseFile());
ASSERT_TRUE(!strncmp(buff, "Contents of file 1A1.", 21));
ASSERT_TRUE(reader->MoveToNextFile());
ASSERT_EQ(reader->GetFileName(), L"test_archive/folder 2/");
ASSERT_EQ(reader->GetFileName(), "test_archive/folder 2/");
ASSERT_EQ(reader->GetFileSize(), 0);
ASSERT_TRUE(reader->MoveToNextFile());
ASSERT_EQ(reader->GetFileName(), L"test_archive/folder 2/file 2a.txt");
ASSERT_EQ(reader->GetFileName(), "test_archive/folder 2/file 2a.txt");
ASSERT_EQ(reader->GetFileSize(), 20);
ASSERT_TRUE(reader->OpenFile(L""));
ASSERT_TRUE(reader->OpenFile(""));
ASSERT_EQ(reader->ReadFile(buff, sizeof(buff)), 20);
ASSERT_TRUE(reader->CloseFile());
ASSERT_TRUE(!strncmp(buff, "Contents of file 2A.", 20));
@ -197,16 +197,16 @@ TEST(ZipReaderTest, Read)
ASSERT_FALSE(reader->MoveToNextFile());
// Try seeking a particular file
ASSERT_TRUE(reader->MoveToFile(L"TEST_ARCHIVE/FOLDER 1/FILE 1B.TXT", false));
ASSERT_EQ(reader->GetFileName(), L"test_archive/folder 1/file 1b.txt");
ASSERT_TRUE(reader->MoveToFile("TEST_ARCHIVE/FOLDER 1/FILE 1B.TXT", false));
ASSERT_EQ(reader->GetFileName(), "test_archive/folder 1/file 1b.txt");
ASSERT_EQ(reader->GetFileSize(), 20);
ASSERT_TRUE(reader->OpenFile(L""));
ASSERT_TRUE(reader->OpenFile(""));
ASSERT_EQ(reader->ReadFile(buff, sizeof(buff)), 20);
ASSERT_TRUE(reader->CloseFile());
ASSERT_TRUE(!strncmp(buff, "Contents of file 1B.", 20));
ASSERT_TRUE(reader->MoveToFile(L"test_archive/folder 1/file 1b.txt", true));
ASSERT_FALSE(reader->MoveToFile(L"test_archive/folder 1/FILE 1B.txt", true));
ASSERT_TRUE(reader->MoveToFile("test_archive/folder 1/file 1b.txt", true));
ASSERT_FALSE(reader->MoveToFile("test_archive/folder 1/FILE 1B.txt", true));
ASSERT_TRUE(reader->Close());
}
@ -224,15 +224,15 @@ TEST(ZipReaderTest, ReadArchive)
ASSERT_EQ(archive->Load(stream, false), (size_t)5);
ASSERT_TRUE(archive->HasFile(L"test_archive/file 1.txt"));
ASSERT_TRUE(archive->HasFile(L"test_archive/folder 1/file 1a.txt"));
ASSERT_TRUE(archive->HasFile(L"test_archive/FOLDER 1/file 1b.txt"));
ASSERT_TRUE(archive->HasFile(L"test_archive/folder 1/folder 1a/file 1a1.txt"));
ASSERT_TRUE(archive->HasFile(L"test_archive/folder 2/file 2a.txt"));
ASSERT_TRUE(archive->HasFile("test_archive/file 1.txt"));
ASSERT_TRUE(archive->HasFile("test_archive/folder 1/file 1a.txt"));
ASSERT_TRUE(archive->HasFile("test_archive/FOLDER 1/file 1b.txt"));
ASSERT_TRUE(archive->HasFile("test_archive/folder 1/folder 1a/file 1a1.txt"));
ASSERT_TRUE(archive->HasFile("test_archive/folder 2/file 2a.txt"));
// Test content retrieval.
CefRefPtr<CefZipArchive::File> file;
file = archive->GetFile(L"test_archive/folder 2/file 2a.txt");
file = archive->GetFile("test_archive/folder 2/file 2a.txt");
ASSERT_TRUE(file.get());
ASSERT_EQ(file->GetDataSize(), (size_t)20);