1 // Copyright (c) 2012 The Chromium Embedded Framework Authors. All rights
2 // reserved. Use of this source code is governed by a BSD-style license that
3 // can be found in the LICENSE file.
4
5 #include "tests/ceftests/test_util.h"
6 #include "include/cef_command_line.h"
7 #include "include/cef_request_context_handler.h"
8 #include "tests/gtest/include/gtest/gtest.h"
9
TestMapEqual(const CefRequest::HeaderMap & map1,const CefRequest::HeaderMap & map2,bool allowExtras)10 void TestMapEqual(const CefRequest::HeaderMap& map1,
11 const CefRequest::HeaderMap& map2,
12 bool allowExtras) {
13 if (!allowExtras) {
14 EXPECT_EQ(map1.size(), map2.size());
15 }
16
17 TestMapNoDuplicates(map1);
18 TestMapNoDuplicates(map2);
19
20 CefRequest::HeaderMap::const_iterator it1, it2;
21
22 for (it1 = map1.begin(); it1 != map1.end(); ++it1) {
23 bool found = false;
24 std::string name1 = it1->first;
25 std::transform(name1.begin(), name1.end(), name1.begin(), ::tolower);
26 for (it2 = map2.begin(); it2 != map2.end(); ++it2) {
27 std::string name2 = it2->first;
28 std::transform(name2.begin(), name2.end(), name2.begin(), ::tolower);
29 if (name1 == name2 && it1->second == it2->second) {
30 found = true;
31 break;
32 }
33 }
34 EXPECT_TRUE(found) << "No entry for " << it1->first.ToString() << ": "
35 << it1->second.ToString();
36 }
37 }
38
TestMapNoDuplicates(const CefRequest::HeaderMap & map)39 void TestMapNoDuplicates(const CefRequest::HeaderMap& map) {
40 CefRequest::HeaderMap::const_iterator it1 = map.begin();
41 for (; it1 != map.end(); ++it1) {
42 CefRequest::HeaderMap::const_iterator it2 = it1;
43 for (++it2; it2 != map.end(); ++it2) {
44 EXPECT_FALSE(it1->first == it2->first && it1->second == it2->second)
45 << "Duplicate entry for " << it1->first.ToString() << ": "
46 << it1->second.ToString();
47 }
48 }
49 }
50
TestPostDataElementEqual(CefRefPtr<CefPostDataElement> elem1,CefRefPtr<CefPostDataElement> elem2)51 void TestPostDataElementEqual(CefRefPtr<CefPostDataElement> elem1,
52 CefRefPtr<CefPostDataElement> elem2) {
53 EXPECT_TRUE(elem1.get());
54 EXPECT_TRUE(elem2.get());
55
56 EXPECT_EQ(elem1->GetType(), elem2->GetType());
57 switch (elem1->GetType()) {
58 case PDE_TYPE_BYTES: {
59 EXPECT_EQ(elem1->GetBytesCount(), elem2->GetBytesCount());
60 size_t bytesCt = elem1->GetBytesCount();
61 char* buff1 = new char[bytesCt];
62 char* buff2 = new char[bytesCt];
63 elem1->GetBytes(bytesCt, buff1);
64 elem2->GetBytes(bytesCt, buff2);
65 EXPECT_TRUE(!memcmp(buff1, buff2, bytesCt));
66 delete[] buff1;
67 delete[] buff2;
68 } break;
69 case PDE_TYPE_FILE:
70 EXPECT_EQ(elem1->GetFile(), elem2->GetFile());
71 break;
72 default:
73 break;
74 }
75 }
76
TestPostDataEqual(CefRefPtr<CefPostData> postData1,CefRefPtr<CefPostData> postData2)77 void TestPostDataEqual(CefRefPtr<CefPostData> postData1,
78 CefRefPtr<CefPostData> postData2) {
79 EXPECT_TRUE(postData1.get());
80 EXPECT_TRUE(postData2.get());
81
82 EXPECT_EQ(postData1->GetElementCount(), postData2->GetElementCount());
83
84 CefPostData::ElementVector ev1, ev2;
85 postData1->GetElements(ev1);
86 postData1->GetElements(ev2);
87 ASSERT_EQ(ev1.size(), ev2.size());
88
89 CefPostData::ElementVector::const_iterator it1 = ev1.begin();
90 CefPostData::ElementVector::const_iterator it2 = ev2.begin();
91 for (; it1 != ev1.end() && it2 != ev2.end(); ++it1, ++it2)
92 TestPostDataElementEqual((*it1), (*it2));
93 }
94
TestRequestEqual(CefRefPtr<CefRequest> request1,CefRefPtr<CefRequest> request2,bool allowExtras)95 void TestRequestEqual(CefRefPtr<CefRequest> request1,
96 CefRefPtr<CefRequest> request2,
97 bool allowExtras) {
98 EXPECT_TRUE(request1.get());
99 EXPECT_TRUE(request2.get());
100
101 EXPECT_STREQ(request1->GetURL().ToString().c_str(),
102 request2->GetURL().ToString().c_str());
103 EXPECT_STREQ(request1->GetMethod().ToString().c_str(),
104 request2->GetMethod().ToString().c_str());
105
106 EXPECT_STREQ(request1->GetReferrerURL().ToString().c_str(),
107 request2->GetReferrerURL().ToString().c_str());
108 EXPECT_EQ(request1->GetReferrerPolicy(), request2->GetReferrerPolicy());
109
110 CefRequest::HeaderMap headers1, headers2;
111 request1->GetHeaderMap(headers1);
112 request2->GetHeaderMap(headers2);
113 TestMapEqual(headers1, headers2, allowExtras);
114
115 CefRefPtr<CefPostData> postData1 = request1->GetPostData();
116 CefRefPtr<CefPostData> postData2 = request2->GetPostData();
117 EXPECT_EQ(!!(postData1.get()), !!(postData2.get()));
118 if (postData1.get() && postData2.get())
119 TestPostDataEqual(postData1, postData2);
120 }
121
TestResponseEqual(CefRefPtr<CefResponse> response1,CefRefPtr<CefResponse> response2,bool allowExtras)122 void TestResponseEqual(CefRefPtr<CefResponse> response1,
123 CefRefPtr<CefResponse> response2,
124 bool allowExtras) {
125 EXPECT_TRUE(response1.get());
126 EXPECT_TRUE(response2.get());
127
128 EXPECT_EQ(response1->GetStatus(), response2->GetStatus());
129 EXPECT_STREQ(response1->GetStatusText().ToString().c_str(),
130 response2->GetStatusText().ToString().c_str());
131 EXPECT_STREQ(response1->GetMimeType().ToString().c_str(),
132 response2->GetMimeType().ToString().c_str());
133
134 CefRequest::HeaderMap headers1, headers2;
135 response1->GetHeaderMap(headers1);
136 response2->GetHeaderMap(headers2);
137 TestMapEqual(headers1, headers2, allowExtras);
138 }
139
TestBinaryEqual(CefRefPtr<CefBinaryValue> val1,CefRefPtr<CefBinaryValue> val2)140 void TestBinaryEqual(CefRefPtr<CefBinaryValue> val1,
141 CefRefPtr<CefBinaryValue> val2) {
142 EXPECT_TRUE(val1.get());
143 EXPECT_TRUE(val2.get());
144
145 EXPECT_TRUE(val1->IsEqual(val2));
146 EXPECT_TRUE(val2->IsEqual(val1));
147
148 size_t data_size = val1->GetSize();
149 EXPECT_EQ(data_size, val2->GetSize());
150
151 EXPECT_GT(data_size, (size_t)0);
152
153 char* data1 = new char[data_size + 1];
154 char* data2 = new char[data_size + 1];
155
156 EXPECT_EQ(data_size, val1->GetData(data1, data_size, 0));
157 data1[data_size] = 0;
158 EXPECT_EQ(data_size, val2->GetData(data2, data_size, 0));
159 data2[data_size] = 0;
160
161 EXPECT_STREQ(data1, data2);
162
163 delete[] data1;
164 delete[] data2;
165 }
166
TestDictionaryEqual(CefRefPtr<CefDictionaryValue> val1,CefRefPtr<CefDictionaryValue> val2)167 void TestDictionaryEqual(CefRefPtr<CefDictionaryValue> val1,
168 CefRefPtr<CefDictionaryValue> val2) {
169 EXPECT_TRUE(val1.get());
170 EXPECT_TRUE(val2.get());
171
172 EXPECT_TRUE(val1->IsEqual(val2));
173 EXPECT_TRUE(val2->IsEqual(val1));
174
175 EXPECT_EQ(val1->GetSize(), val2->GetSize());
176
177 CefDictionaryValue::KeyList keys;
178 EXPECT_TRUE(val1->GetKeys(keys));
179
180 CefDictionaryValue::KeyList::const_iterator it = keys.begin();
181 for (; it != keys.end(); ++it) {
182 CefString key = *it;
183 EXPECT_TRUE(val2->HasKey(key));
184 CefValueType type = val1->GetType(key);
185 EXPECT_EQ(type, val2->GetType(key));
186 switch (type) {
187 case VTYPE_INVALID:
188 case VTYPE_NULL:
189 break;
190 case VTYPE_BOOL:
191 EXPECT_EQ(val1->GetBool(key), val2->GetBool(key));
192 break;
193 case VTYPE_INT:
194 EXPECT_EQ(val1->GetInt(key), val2->GetInt(key));
195 break;
196 case VTYPE_DOUBLE:
197 EXPECT_EQ(val1->GetDouble(key), val2->GetDouble(key));
198 break;
199 case VTYPE_STRING:
200 EXPECT_EQ(val1->GetString(key), val2->GetString(key));
201 break;
202 case VTYPE_BINARY:
203 TestBinaryEqual(val1->GetBinary(key), val2->GetBinary(key));
204 break;
205 case VTYPE_DICTIONARY:
206 TestDictionaryEqual(val1->GetDictionary(key), val2->GetDictionary(key));
207 break;
208 case VTYPE_LIST:
209 TestListEqual(val1->GetList(key), val2->GetList(key));
210 break;
211 }
212 }
213 }
214
TestListEqual(CefRefPtr<CefListValue> val1,CefRefPtr<CefListValue> val2)215 void TestListEqual(CefRefPtr<CefListValue> val1, CefRefPtr<CefListValue> val2) {
216 EXPECT_TRUE(val1.get());
217 EXPECT_TRUE(val2.get());
218
219 EXPECT_TRUE(val1->IsEqual(val2));
220 EXPECT_TRUE(val2->IsEqual(val1));
221
222 size_t size = val1->GetSize();
223 EXPECT_EQ(size, val2->GetSize());
224
225 for (size_t i = 0; i < size; ++i) {
226 CefValueType type = val1->GetType(i);
227 EXPECT_EQ(type, val2->GetType(i));
228 switch (type) {
229 case VTYPE_INVALID:
230 case VTYPE_NULL:
231 break;
232 case VTYPE_BOOL:
233 EXPECT_EQ(val1->GetBool(i), val2->GetBool(i));
234 break;
235 case VTYPE_INT:
236 EXPECT_EQ(val1->GetInt(i), val2->GetInt(i));
237 break;
238 case VTYPE_DOUBLE:
239 EXPECT_EQ(val1->GetDouble(i), val2->GetDouble(i));
240 break;
241 case VTYPE_STRING:
242 EXPECT_EQ(val1->GetString(i), val2->GetString(i));
243 break;
244 case VTYPE_BINARY:
245 TestBinaryEqual(val1->GetBinary(i), val2->GetBinary(i));
246 break;
247 case VTYPE_DICTIONARY:
248 TestDictionaryEqual(val1->GetDictionary(i), val2->GetDictionary(i));
249 break;
250 case VTYPE_LIST:
251 TestListEqual(val1->GetList(i), val2->GetList(i));
252 break;
253 }
254 }
255 }
256
TestProcessMessageEqual(CefRefPtr<CefProcessMessage> val1,CefRefPtr<CefProcessMessage> val2)257 void TestProcessMessageEqual(CefRefPtr<CefProcessMessage> val1,
258 CefRefPtr<CefProcessMessage> val2) {
259 EXPECT_TRUE(val1.get());
260 EXPECT_TRUE(val2.get());
261 EXPECT_EQ(val1->GetName(), val2->GetName());
262
263 TestListEqual(val1->GetArgumentList(), val2->GetArgumentList());
264 }
265
TestStringVectorEqual(const std::vector<CefString> & val1,const std::vector<CefString> & val2)266 void TestStringVectorEqual(const std::vector<CefString>& val1,
267 const std::vector<CefString>& val2) {
268 EXPECT_EQ(val1.size(), val2.size());
269
270 for (size_t i = 0; i < val1.size(); ++i)
271 EXPECT_STREQ(val1[i].ToString().c_str(), val2[i].ToString().c_str());
272 }
273
TestOldResourceAPI()274 bool TestOldResourceAPI() {
275 static int state = -1;
276 if (state == -1) {
277 CefRefPtr<CefCommandLine> command_line =
278 CefCommandLine::GetGlobalCommandLine();
279 state = command_line->HasSwitch("test-old-resource-api") ? 1 : 0;
280 }
281 return state ? true : false;
282 }
283
IsChromeRuntimeEnabled()284 bool IsChromeRuntimeEnabled() {
285 static int state = -1;
286 if (state == -1) {
287 CefRefPtr<CefCommandLine> command_line =
288 CefCommandLine::GetGlobalCommandLine();
289 state = command_line->HasSwitch("enable-chrome-runtime") ? 1 : 0;
290 }
291 return state ? true : false;
292 }
293
IgnoreURL(const std::string & url)294 bool IgnoreURL(const std::string& url) {
295 return IsChromeRuntimeEnabled() &&
296 url.find("/favicon.ico") != std::string::npos;
297 }
298
CreateTestRequestContext(TestRequestContextMode mode,const std::string & cache_path)299 CefRefPtr<CefRequestContext> CreateTestRequestContext(
300 TestRequestContextMode mode,
301 const std::string& cache_path) {
302 EXPECT_TRUE(cache_path.empty() || mode == TEST_RC_MODE_CUSTOM ||
303 mode == TEST_RC_MODE_CUSTOM_WITH_HANDLER);
304
305 if (mode == TEST_RC_MODE_NONE)
306 return nullptr;
307 if (mode == TEST_RC_MODE_GLOBAL)
308 return CefRequestContext::GetGlobalContext();
309
310 CefRefPtr<CefRequestContextHandler> rc_handler;
311 if (mode == TEST_RC_MODE_GLOBAL_WITH_HANDLER ||
312 mode == TEST_RC_MODE_CUSTOM_WITH_HANDLER) {
313 class Handler : public CefRequestContextHandler {
314 public:
315 Handler() {}
316
317 private:
318 IMPLEMENT_REFCOUNTING(Handler);
319 };
320 rc_handler = new Handler();
321 }
322
323 if (mode == TEST_RC_MODE_CUSTOM || mode == TEST_RC_MODE_CUSTOM_WITH_HANDLER) {
324 CefRequestContextSettings settings;
325 if (!cache_path.empty())
326 CefString(&settings.cache_path) = cache_path;
327 return CefRequestContext::CreateContext(settings, rc_handler);
328 }
329
330 EXPECT_EQ(mode, TEST_RC_MODE_GLOBAL_WITH_HANDLER);
331 return CefRequestContext::CreateContext(CefRequestContext::GetGlobalContext(),
332 rc_handler);
333 }
334