| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2006-2008 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include <string> | |
| 6 | |
| 7 #include "gpu/np_utils/default_np_object.h" | |
| 8 #include "gpu/np_utils/np_browser_stub.h" | |
| 9 #include "gpu/np_utils/np_dispatcher.h" | |
| 10 #include "gpu/np_utils/np_object_mock.h" | |
| 11 #include "testing/gmock/include/gmock/gmock.h" | |
| 12 #include "testing/gtest/include/gtest/gtest.h" | |
| 13 | |
| 14 using testing::Return; | |
| 15 using testing::StrictMock; | |
| 16 | |
| 17 namespace np_utils { | |
| 18 | |
| 19 // This mock class has a dispatcher chain with an entry for each mocked | |
| 20 // function. The tests that follow that invoking an NPAPI method calls the | |
| 21 // corresponding mocked member function. | |
| 22 class MockDispatchedNPObject : public DefaultNPObject<NPObject> { | |
| 23 public: | |
| 24 explicit MockDispatchedNPObject(NPP npp) { | |
| 25 } | |
| 26 | |
| 27 MOCK_METHOD0(VoidReturnNoParams, void()); | |
| 28 MOCK_METHOD1(VoidReturnBoolParam, void(bool)); | |
| 29 MOCK_METHOD1(VoidReturnIntParam, void(int)); | |
| 30 MOCK_METHOD1(VoidReturnFloatParam, void(float)); | |
| 31 MOCK_METHOD1(VoidReturnDoubleParam, void(double)); | |
| 32 MOCK_METHOD1(VoidReturnStringParam, void(std::string)); | |
| 33 MOCK_METHOD1(VoidReturnObjectParam, void(NPObjectPointer<NPObject>)); | |
| 34 MOCK_METHOD2(VoidReturnTwoParams, void(bool, int)); | |
| 35 MOCK_METHOD0(Overloaded, void()); | |
| 36 MOCK_METHOD1(Overloaded, void(bool)); | |
| 37 MOCK_METHOD1(Overloaded, void(std::string)); | |
| 38 MOCK_METHOD0(BoolReturn, bool()); | |
| 39 MOCK_METHOD0(IntReturn, int()); | |
| 40 MOCK_METHOD0(FloatReturn, float()); | |
| 41 MOCK_METHOD0(DoubleReturn, double()); | |
| 42 MOCK_METHOD0(StringReturn, std::string()); | |
| 43 MOCK_METHOD0(ObjectReturn, NPObjectPointer<NPObject>()); | |
| 44 | |
| 45 NP_UTILS_BEGIN_DISPATCHER_CHAIN(MockDispatchedNPObject, DefaultNPObject<NPObje
ct>) | |
| 46 NP_UTILS_DISPATCHER(VoidReturnNoParams, void()) | |
| 47 NP_UTILS_DISPATCHER(VoidReturnBoolParam, void(bool)) | |
| 48 NP_UTILS_DISPATCHER(VoidReturnIntParam, void(int)) | |
| 49 NP_UTILS_DISPATCHER(VoidReturnFloatParam, void(float)) | |
| 50 NP_UTILS_DISPATCHER(VoidReturnDoubleParam, void(double)) | |
| 51 NP_UTILS_DISPATCHER(VoidReturnStringParam, void(std::string)) | |
| 52 NP_UTILS_DISPATCHER(VoidReturnObjectParam, void(NPObjectPointer<NPObject>)) | |
| 53 NP_UTILS_DISPATCHER(VoidReturnTwoParams, void(bool, int)) | |
| 54 NP_UTILS_DISPATCHER(Overloaded, void()) | |
| 55 NP_UTILS_DISPATCHER(Overloaded, void(bool)) | |
| 56 NP_UTILS_DISPATCHER(Overloaded, void(std::string)) | |
| 57 NP_UTILS_DISPATCHER(BoolReturn, bool()) | |
| 58 NP_UTILS_DISPATCHER(IntReturn, int()) | |
| 59 NP_UTILS_DISPATCHER(FloatReturn, float()) | |
| 60 NP_UTILS_DISPATCHER(DoubleReturn, double()) | |
| 61 NP_UTILS_DISPATCHER(StringReturn, std::string()) | |
| 62 NP_UTILS_DISPATCHER(ObjectReturn, NPObjectPointer<NPObject>()); | |
| 63 NP_UTILS_END_DISPATCHER_CHAIN | |
| 64 }; | |
| 65 | |
| 66 class DispatchedNPObjectTest : public testing::Test { | |
| 67 protected: | |
| 68 virtual void SetUp() { | |
| 69 object_ = NPCreateObject<StrictMock<MockDispatchedNPObject> >(NULL); | |
| 70 passed_object_ = NPCreateObject<MockNPObject>(NULL); | |
| 71 | |
| 72 for (int i = 0; i != arraysize(args_); ++i) { | |
| 73 NULL_TO_NPVARIANT(args_[i]); | |
| 74 } | |
| 75 NULL_TO_NPVARIANT(result_); | |
| 76 } | |
| 77 | |
| 78 StubNPBrowser stub_browser_; | |
| 79 NPVariant args_[3]; | |
| 80 NPVariant result_; | |
| 81 NPObjectPointer<MockDispatchedNPObject> object_; | |
| 82 NPObjectPointer<NPObject> passed_object_; | |
| 83 }; | |
| 84 | |
| 85 TEST_F(DispatchedNPObjectTest, CannotInvokeMissingFunction) { | |
| 86 EXPECT_FALSE(object_->Invoke( | |
| 87 NPBrowser::get()->GetStringIdentifier("missing"), | |
| 88 NULL, | |
| 89 0, | |
| 90 &result_)); | |
| 91 EXPECT_TRUE(NPVARIANT_IS_VOID(result_)); | |
| 92 } | |
| 93 | |
| 94 TEST_F(DispatchedNPObjectTest, CanInvokeVoidReturnNoParams) { | |
| 95 EXPECT_CALL(*object_, VoidReturnNoParams()); | |
| 96 | |
| 97 EXPECT_TRUE(object_->Invoke( | |
| 98 NPBrowser::get()->GetStringIdentifier("voidReturnNoParams"), | |
| 99 NULL, | |
| 100 0, | |
| 101 &result_)); | |
| 102 EXPECT_TRUE(NPVARIANT_IS_VOID(result_)); | |
| 103 } | |
| 104 | |
| 105 TEST_F(DispatchedNPObjectTest, | |
| 106 CannotInvokeVoidReturnNoParamsWithTooManyParams) { | |
| 107 EXPECT_FALSE(object_->Invoke( | |
| 108 NPBrowser::get()->GetStringIdentifier("voidReturnNoParams"), | |
| 109 args_, | |
| 110 1, | |
| 111 &result_)); | |
| 112 EXPECT_TRUE(NPVARIANT_IS_VOID(result_)); | |
| 113 } | |
| 114 | |
| 115 TEST_F(DispatchedNPObjectTest, CanInvokeVoidReturnIntParam) { | |
| 116 EXPECT_CALL(*object_, VoidReturnIntParam(7)); | |
| 117 | |
| 118 INT32_TO_NPVARIANT(7, args_[0]); | |
| 119 | |
| 120 EXPECT_TRUE(object_->Invoke( | |
| 121 NPBrowser::get()->GetStringIdentifier("voidReturnIntParam"), | |
| 122 args_, | |
| 123 1, | |
| 124 &result_)); | |
| 125 EXPECT_TRUE(NPVARIANT_IS_VOID(result_)); | |
| 126 } | |
| 127 | |
| 128 TEST_F(DispatchedNPObjectTest, CanInvokeVoidReturnBoolParam) { | |
| 129 EXPECT_CALL(*object_, VoidReturnBoolParam(true)); | |
| 130 | |
| 131 BOOLEAN_TO_NPVARIANT(true, args_[0]); | |
| 132 | |
| 133 EXPECT_TRUE(object_->Invoke( | |
| 134 NPBrowser::get()->GetStringIdentifier("voidReturnBoolParam"), | |
| 135 args_, | |
| 136 1, | |
| 137 &result_)); | |
| 138 EXPECT_TRUE(NPVARIANT_IS_VOID(result_)); | |
| 139 } | |
| 140 | |
| 141 TEST_F(DispatchedNPObjectTest, CanInvokeVoidReturnFloatParamWithDoubleParam) { | |
| 142 EXPECT_CALL(*object_, VoidReturnFloatParam(7.0f)); | |
| 143 | |
| 144 DOUBLE_TO_NPVARIANT(7.0, args_[0]); | |
| 145 | |
| 146 EXPECT_TRUE(object_->Invoke( | |
| 147 NPBrowser::get()->GetStringIdentifier("voidReturnFloatParam"), | |
| 148 args_, | |
| 149 1, | |
| 150 &result_)); | |
| 151 EXPECT_TRUE(NPVARIANT_IS_VOID(result_)); | |
| 152 } | |
| 153 | |
| 154 TEST_F(DispatchedNPObjectTest, CanInvokeVoidReturnFloatParamWithIntParam) { | |
| 155 EXPECT_CALL(*object_, VoidReturnFloatParam(7.0f)); | |
| 156 | |
| 157 INT32_TO_NPVARIANT(7, args_[0]); | |
| 158 | |
| 159 EXPECT_TRUE(object_->Invoke( | |
| 160 NPBrowser::get()->GetStringIdentifier("voidReturnFloatParam"), | |
| 161 args_, | |
| 162 1, | |
| 163 &result_)); | |
| 164 EXPECT_TRUE(NPVARIANT_IS_VOID(result_)); | |
| 165 } | |
| 166 | |
| 167 TEST_F(DispatchedNPObjectTest, CanInvokeVoidReturnDoubleParamWithDoubleParam) { | |
| 168 EXPECT_CALL(*object_, VoidReturnDoubleParam(7.0)); | |
| 169 | |
| 170 DOUBLE_TO_NPVARIANT(7.0, args_[0]); | |
| 171 | |
| 172 EXPECT_TRUE(object_->Invoke( | |
| 173 NPBrowser::get()->GetStringIdentifier("voidReturnDoubleParam"), | |
| 174 args_, | |
| 175 1, | |
| 176 &result_)); | |
| 177 EXPECT_TRUE(NPVARIANT_IS_VOID(result_)); | |
| 178 } | |
| 179 | |
| 180 TEST_F(DispatchedNPObjectTest, CanInvokeVoidReturnDoubleParamWithIntParam) { | |
| 181 EXPECT_CALL(*object_, VoidReturnDoubleParam(7.0f)); | |
| 182 | |
| 183 INT32_TO_NPVARIANT(7, args_[0]); | |
| 184 | |
| 185 EXPECT_TRUE(object_->Invoke( | |
| 186 NPBrowser::get()->GetStringIdentifier("voidReturnDoubleParam"), | |
| 187 args_, | |
| 188 1, | |
| 189 &result_)); | |
| 190 EXPECT_TRUE(NPVARIANT_IS_VOID(result_)); | |
| 191 } | |
| 192 | |
| 193 TEST_F(DispatchedNPObjectTest, CanInvokeVoidReturnStringParam) { | |
| 194 EXPECT_CALL(*object_, VoidReturnStringParam(std::string("hello"))); | |
| 195 | |
| 196 STRINGZ_TO_NPVARIANT("hello", args_[0]); | |
| 197 | |
| 198 EXPECT_TRUE(object_->Invoke( | |
| 199 NPBrowser::get()->GetStringIdentifier("voidReturnStringParam"), | |
| 200 args_, | |
| 201 1, | |
| 202 &result_)); | |
| 203 EXPECT_TRUE(NPVARIANT_IS_VOID(result_)); | |
| 204 } | |
| 205 | |
| 206 TEST_F(DispatchedNPObjectTest, CanInvokeVoidReturnObjectParamWithObject) { | |
| 207 EXPECT_CALL(*object_, VoidReturnObjectParam(passed_object_)); | |
| 208 | |
| 209 OBJECT_TO_NPVARIANT(passed_object_.Get(), args_[0]); | |
| 210 | |
| 211 EXPECT_TRUE(object_->Invoke( | |
| 212 NPBrowser::get()->GetStringIdentifier("voidReturnObjectParam"), | |
| 213 args_, | |
| 214 1, | |
| 215 &result_)); | |
| 216 EXPECT_TRUE(NPVARIANT_IS_VOID(result_)); | |
| 217 } | |
| 218 | |
| 219 TEST_F(DispatchedNPObjectTest, CanInvokeVoidReturnObjectParamWithNull) { | |
| 220 EXPECT_CALL( | |
| 221 *object_, | |
| 222 VoidReturnObjectParam(NPObjectPointer<NPObject>())); | |
| 223 | |
| 224 NULL_TO_NPVARIANT(args_[0]); | |
| 225 | |
| 226 EXPECT_TRUE(object_->Invoke( | |
| 227 NPBrowser::get()->GetStringIdentifier("voidReturnObjectParam"), | |
| 228 args_, | |
| 229 1, | |
| 230 &result_)); | |
| 231 EXPECT_TRUE(NPVARIANT_IS_VOID(result_)); | |
| 232 } | |
| 233 | |
| 234 TEST_F(DispatchedNPObjectTest, CanInvokeVoidReturnTwoParams) { | |
| 235 EXPECT_CALL(*object_, VoidReturnTwoParams(false, 7)); | |
| 236 | |
| 237 BOOLEAN_TO_NPVARIANT(false, args_[0]); | |
| 238 INT32_TO_NPVARIANT(7, args_[1]); | |
| 239 | |
| 240 EXPECT_TRUE(object_->Invoke( | |
| 241 NPBrowser::get()->GetStringIdentifier("voidReturnTwoParams"), | |
| 242 args_, | |
| 243 2, | |
| 244 &result_)); | |
| 245 EXPECT_TRUE(NPVARIANT_IS_VOID(result_)); | |
| 246 } | |
| 247 | |
| 248 TEST_F(DispatchedNPObjectTest, CanInvokeOverloadedWithNoParams) { | |
| 249 EXPECT_CALL(*object_, Overloaded()); | |
| 250 | |
| 251 EXPECT_TRUE(object_->Invoke( | |
| 252 NPBrowser::get()->GetStringIdentifier("overloaded"), | |
| 253 NULL, | |
| 254 0, | |
| 255 &result_)); | |
| 256 EXPECT_TRUE(NPVARIANT_IS_VOID(result_)); | |
| 257 } | |
| 258 | |
| 259 TEST_F(DispatchedNPObjectTest, CanInvokeOverloadedWithOneStringParam) { | |
| 260 EXPECT_CALL(*object_, Overloaded(std::string("hello"))); | |
| 261 | |
| 262 STRINGZ_TO_NPVARIANT("hello", args_[0]); | |
| 263 | |
| 264 EXPECT_TRUE(object_->Invoke( | |
| 265 NPBrowser::get()->GetStringIdentifier("overloaded"), | |
| 266 args_, | |
| 267 1, | |
| 268 &result_)); | |
| 269 EXPECT_TRUE(NPVARIANT_IS_VOID(result_)); | |
| 270 } | |
| 271 | |
| 272 TEST_F(DispatchedNPObjectTest, CanInvokeOverloadedWithOneBoolParam) { | |
| 273 EXPECT_CALL(*object_, Overloaded(true)); | |
| 274 | |
| 275 BOOLEAN_TO_NPVARIANT(true, args_[0]); | |
| 276 | |
| 277 EXPECT_TRUE(object_->Invoke( | |
| 278 NPBrowser::get()->GetStringIdentifier("overloaded"), | |
| 279 args_, | |
| 280 1, | |
| 281 &result_)); | |
| 282 EXPECT_TRUE(NPVARIANT_IS_VOID(result_)); | |
| 283 } | |
| 284 | |
| 285 TEST_F(DispatchedNPObjectTest, CanInvokeBoolReturn) { | |
| 286 EXPECT_CALL(*object_, BoolReturn()).WillOnce(Return(true)); | |
| 287 | |
| 288 EXPECT_TRUE(object_->Invoke( | |
| 289 NPBrowser::get()->GetStringIdentifier("boolReturn"), | |
| 290 NULL, | |
| 291 0, | |
| 292 &result_)); | |
| 293 EXPECT_TRUE(NPVARIANT_IS_BOOLEAN(result_)); | |
| 294 EXPECT_TRUE(NPVARIANT_TO_BOOLEAN(result_)); | |
| 295 } | |
| 296 | |
| 297 TEST_F(DispatchedNPObjectTest, CanInvokeIntReturn) { | |
| 298 EXPECT_CALL(*object_, IntReturn()).WillOnce(Return(7)); | |
| 299 | |
| 300 EXPECT_TRUE(object_->Invoke( | |
| 301 NPBrowser::get()->GetStringIdentifier("intReturn"), | |
| 302 NULL, | |
| 303 0, | |
| 304 &result_)); | |
| 305 EXPECT_TRUE(NPVARIANT_IS_INT32(result_)); | |
| 306 EXPECT_EQ(7, NPVARIANT_TO_INT32(result_)); | |
| 307 } | |
| 308 | |
| 309 TEST_F(DispatchedNPObjectTest, CanInvokeFloatReturn) { | |
| 310 EXPECT_CALL(*object_, FloatReturn()).WillOnce(Return(7.0f)); | |
| 311 | |
| 312 EXPECT_TRUE(object_->Invoke( | |
| 313 NPBrowser::get()->GetStringIdentifier("floatReturn"), | |
| 314 NULL, | |
| 315 0, | |
| 316 &result_)); | |
| 317 EXPECT_TRUE(NPVARIANT_IS_DOUBLE(result_)); | |
| 318 EXPECT_EQ(7.0, NPVARIANT_TO_DOUBLE(result_)); | |
| 319 } | |
| 320 | |
| 321 TEST_F(DispatchedNPObjectTest, CanInvokeDoubleReturn) { | |
| 322 EXPECT_CALL(*object_, DoubleReturn()).WillOnce(Return(7.0)); | |
| 323 | |
| 324 EXPECT_TRUE(object_->Invoke( | |
| 325 NPBrowser::get()->GetStringIdentifier("doubleReturn"), | |
| 326 NULL, | |
| 327 0, | |
| 328 &result_)); | |
| 329 EXPECT_TRUE(NPVARIANT_IS_DOUBLE(result_)); | |
| 330 EXPECT_EQ(7.0, NPVARIANT_TO_DOUBLE(result_)); | |
| 331 } | |
| 332 | |
| 333 TEST_F(DispatchedNPObjectTest, CanInvokeStringReturn) { | |
| 334 EXPECT_CALL(*object_, StringReturn()).WillOnce(Return(std::string("hello"))); | |
| 335 | |
| 336 EXPECT_TRUE(object_->Invoke( | |
| 337 NPBrowser::get()->GetStringIdentifier("stringReturn"), | |
| 338 NULL, | |
| 339 0, | |
| 340 &result_)); | |
| 341 EXPECT_TRUE(NPVARIANT_IS_STRING(result_)); | |
| 342 | |
| 343 NPString& str = NPVARIANT_TO_STRING(result_); | |
| 344 EXPECT_EQ(std::string("hello"), | |
| 345 std::string(str.UTF8Characters, str.UTF8Length)); | |
| 346 | |
| 347 // Callee is responsible for releasing string. | |
| 348 NPBrowser::get()->ReleaseVariantValue(&result_); | |
| 349 } | |
| 350 | |
| 351 TEST_F(DispatchedNPObjectTest, CanInvokeObjectReturnWithObject) { | |
| 352 EXPECT_CALL(*object_, ObjectReturn()).WillOnce(Return(passed_object_)); | |
| 353 | |
| 354 EXPECT_TRUE(object_->Invoke( | |
| 355 NPBrowser::get()->GetStringIdentifier("objectReturn"), | |
| 356 NULL, | |
| 357 0, | |
| 358 &result_)); | |
| 359 EXPECT_TRUE(NPVARIANT_IS_OBJECT(result_)); | |
| 360 EXPECT_EQ(passed_object_.Get(), NPVARIANT_TO_OBJECT(result_)); | |
| 361 | |
| 362 NPBrowser::get()->ReleaseVariantValue(&result_); | |
| 363 } | |
| 364 | |
| 365 TEST_F(DispatchedNPObjectTest, CanInvokeObjectReturnWithNull) { | |
| 366 EXPECT_CALL(*object_, ObjectReturn()) | |
| 367 .WillOnce(Return(NPObjectPointer<NPObject>())); | |
| 368 | |
| 369 EXPECT_TRUE(object_->Invoke( | |
| 370 NPBrowser::get()->GetStringIdentifier("objectReturn"), | |
| 371 NULL, | |
| 372 0, | |
| 373 &result_)); | |
| 374 EXPECT_TRUE(NPVARIANT_IS_NULL(result_)); | |
| 375 } | |
| 376 | |
| 377 TEST_F(DispatchedNPObjectTest, HasMethodReturnsTrueIfMatchingMemberVariable) { | |
| 378 EXPECT_TRUE(object_->HasMethod( | |
| 379 NPBrowser::get()->GetStringIdentifier("objectReturn"))); | |
| 380 } | |
| 381 | |
| 382 TEST_F(DispatchedNPObjectTest, HasMethodReturnsTrueIfNoMatchingMemberVariable) { | |
| 383 EXPECT_FALSE(object_->HasMethod( | |
| 384 NPBrowser::get()->GetStringIdentifier("missing"))); | |
| 385 } | |
| 386 | |
| 387 TEST_F(DispatchedNPObjectTest, EnumeratesAllAvailableMethods) { | |
| 388 NPIdentifier* names; | |
| 389 uint32_t num_names; | |
| 390 ASSERT_TRUE(object_->Enumerate(&names, &num_names)); | |
| 391 | |
| 392 // Don't compare all of them; this test would need to change every time new | |
| 393 // dispatchers were added to the test NPObject class. Just compare the first | |
| 394 // registered (last in the dispatcher chain) and that more than one is | |
| 395 // returned. | |
| 396 EXPECT_GT(num_names, 1u); | |
| 397 EXPECT_EQ(NPBrowser::get()->GetStringIdentifier("voidReturnNoParams"), | |
| 398 names[num_names - 1]); | |
| 399 | |
| 400 NPBrowser::get()->MemFree(names); | |
| 401 } | |
| 402 | |
| 403 } // namespace np_utils | |
| OLD | NEW |
|---|
Chromium Code Reviews
