| 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 "gpu/np_utils/np_object_mock.h" | |
| 6 #include "gpu/np_utils/np_browser_stub.h" | |
| 7 #include "gpu/np_utils/np_utils.h" | |
| 8 #include "testing/gmock/include/gmock/gmock.h" | |
| 9 #include "testing/gtest/include/gtest/gtest.h" | |
| 10 | |
| 11 using testing::_; | |
| 12 using testing::DoAll; | |
| 13 using testing::MakeMatcher; | |
| 14 using testing::Matcher; | |
| 15 using testing::Pointee; | |
| 16 using testing::Return; | |
| 17 using testing::SetArgumentPointee; | |
| 18 using testing::StrictMock; | |
| 19 | |
| 20 namespace np_utils { | |
| 21 | |
| 22 class NPUtilsTest : public testing::Test { | |
| 23 protected: | |
| 24 StubNPBrowser stub_browser_; | |
| 25 NPP_t npp_; | |
| 26 NPVariant variant_; | |
| 27 }; | |
| 28 | |
| 29 TEST_F(NPUtilsTest, TestBoolNPVariantToValue) { | |
| 30 bool v; | |
| 31 | |
| 32 BOOLEAN_TO_NPVARIANT(false, variant_); | |
| 33 EXPECT_TRUE(NPVariantToValue(&v, variant_)); | |
| 34 EXPECT_FALSE(v); | |
| 35 | |
| 36 BOOLEAN_TO_NPVARIANT(true, variant_); | |
| 37 EXPECT_TRUE(NPVariantToValue(&v, variant_)); | |
| 38 EXPECT_TRUE(v); | |
| 39 | |
| 40 INT32_TO_NPVARIANT(7, variant_); | |
| 41 EXPECT_FALSE(NPVariantToValue(&v, variant_)); | |
| 42 } | |
| 43 | |
| 44 TEST_F(NPUtilsTest, TestIntNPVariantToValue) { | |
| 45 INT32_TO_NPVARIANT(7, variant_); | |
| 46 | |
| 47 int v1; | |
| 48 EXPECT_TRUE(NPVariantToValue(&v1, variant_)); | |
| 49 EXPECT_EQ(7, v1); | |
| 50 | |
| 51 float v2; | |
| 52 EXPECT_TRUE(NPVariantToValue(&v2, variant_)); | |
| 53 EXPECT_EQ(7.0f, v2); | |
| 54 | |
| 55 double v3; | |
| 56 EXPECT_TRUE(NPVariantToValue(&v3, variant_)); | |
| 57 EXPECT_EQ(7.0, v3); | |
| 58 | |
| 59 BOOLEAN_TO_NPVARIANT(false, variant_); | |
| 60 EXPECT_FALSE(NPVariantToValue(&v1, variant_)); | |
| 61 } | |
| 62 | |
| 63 TEST_F(NPUtilsTest, TestFloatNPVariantToValue) { | |
| 64 float v; | |
| 65 | |
| 66 DOUBLE_TO_NPVARIANT(7.0, variant_); | |
| 67 EXPECT_TRUE(NPVariantToValue(&v, variant_)); | |
| 68 EXPECT_EQ(7.0f, v); | |
| 69 | |
| 70 BOOLEAN_TO_NPVARIANT(false, variant_); | |
| 71 EXPECT_FALSE(NPVariantToValue(&v, variant_)); | |
| 72 } | |
| 73 | |
| 74 TEST_F(NPUtilsTest, TestDoubleNPVariantToValue) { | |
| 75 double v; | |
| 76 | |
| 77 DOUBLE_TO_NPVARIANT(7.0, variant_); | |
| 78 EXPECT_TRUE(NPVariantToValue(&v, variant_)); | |
| 79 EXPECT_EQ(7.0, v); | |
| 80 | |
| 81 BOOLEAN_TO_NPVARIANT(false, variant_); | |
| 82 EXPECT_FALSE(NPVariantToValue(&v, variant_)); | |
| 83 } | |
| 84 | |
| 85 TEST_F(NPUtilsTest, TestStringNPVariantToValue) { | |
| 86 std::string v; | |
| 87 | |
| 88 STRINGZ_TO_NPVARIANT("hello", variant_); | |
| 89 EXPECT_TRUE(NPVariantToValue(&v, variant_)); | |
| 90 EXPECT_EQ(std::string("hello"), v); | |
| 91 | |
| 92 BOOLEAN_TO_NPVARIANT(false, variant_); | |
| 93 EXPECT_FALSE(NPVariantToValue(&v, variant_)); | |
| 94 } | |
| 95 | |
| 96 TEST_F(NPUtilsTest, TestObjectNPVariantToValue) { | |
| 97 NPObjectPointer<NPObject> object = | |
| 98 NPCreateObject<StrictMock<MockNPObject> >(NULL); | |
| 99 NPObjectPointer<NPObject> v; | |
| 100 | |
| 101 OBJECT_TO_NPVARIANT(object.Get(), variant_); | |
| 102 EXPECT_TRUE(NPVariantToValue(&v, variant_)); | |
| 103 EXPECT_EQ(object, v); | |
| 104 | |
| 105 BOOLEAN_TO_NPVARIANT(false, variant_); | |
| 106 EXPECT_FALSE(NPVariantToValue(&v, variant_)); | |
| 107 } | |
| 108 | |
| 109 TEST_F(NPUtilsTest, TestNullNPVariantToValue) { | |
| 110 NPObjectPointer<NPObject> v; | |
| 111 | |
| 112 NULL_TO_NPVARIANT(variant_); | |
| 113 EXPECT_TRUE(NPVariantToValue(&v, variant_)); | |
| 114 EXPECT_TRUE(NPObjectPointer<NPObject>() == v); | |
| 115 | |
| 116 BOOLEAN_TO_NPVARIANT(false, variant_); | |
| 117 EXPECT_FALSE(NPVariantToValue(&v, variant_)); | |
| 118 } | |
| 119 | |
| 120 TEST_F(NPUtilsTest, TestDerivedObjectNPVariantToValue) { | |
| 121 NPObjectPointer<NPObject> object = | |
| 122 NPCreateObject<StrictMock<MockNPObject> >(NULL); | |
| 123 NPObjectPointer<StrictMock<MockNPObject> > v; | |
| 124 | |
| 125 OBJECT_TO_NPVARIANT(object.Get(), variant_); | |
| 126 EXPECT_TRUE(NPVariantToValue(&v, variant_)); | |
| 127 EXPECT_EQ(object, v); | |
| 128 } | |
| 129 | |
| 130 TEST_F(NPUtilsTest, | |
| 131 TestDerivedObjectNPVariantToValueFailsIfValueHasDifferentType) { | |
| 132 NPObjectPointer<NPObject> object = | |
| 133 NPCreateObject<StrictMock<MockNPObject> >(NULL); | |
| 134 NPObjectPointer<MockNPObject> v; | |
| 135 | |
| 136 OBJECT_TO_NPVARIANT(object.Get(), variant_); | |
| 137 EXPECT_FALSE(NPVariantToValue(&v, variant_)); | |
| 138 } | |
| 139 | |
| 140 TEST_F(NPUtilsTest, TestBoolValueToNPVariant) { | |
| 141 ValueToNPVariant(true, &variant_); | |
| 142 EXPECT_TRUE(NPVARIANT_IS_BOOLEAN(variant_)); | |
| 143 EXPECT_TRUE(NPVARIANT_TO_BOOLEAN(variant_)); | |
| 144 | |
| 145 ValueToNPVariant(false, &variant_); | |
| 146 EXPECT_TRUE(NPVARIANT_IS_BOOLEAN(variant_)); | |
| 147 EXPECT_FALSE(NPVARIANT_TO_BOOLEAN(variant_)); | |
| 148 } | |
| 149 | |
| 150 TEST_F(NPUtilsTest, TestIntValueToNPVariant) { | |
| 151 ValueToNPVariant(7, &variant_); | |
| 152 EXPECT_TRUE(NPVARIANT_IS_INT32(variant_)); | |
| 153 EXPECT_EQ(7, NPVARIANT_TO_INT32(variant_)); | |
| 154 } | |
| 155 | |
| 156 TEST_F(NPUtilsTest, TestFloatValueToNPVariant) { | |
| 157 ValueToNPVariant(7.0f, &variant_); | |
| 158 EXPECT_TRUE(NPVARIANT_IS_DOUBLE(variant_)); | |
| 159 EXPECT_EQ(7.0, NPVARIANT_TO_DOUBLE(variant_)); | |
| 160 } | |
| 161 | |
| 162 TEST_F(NPUtilsTest, TestDoubleValueToNPVariant) { | |
| 163 ValueToNPVariant(7.0, &variant_); | |
| 164 EXPECT_TRUE(NPVARIANT_IS_DOUBLE(variant_)); | |
| 165 EXPECT_EQ(7.0, NPVARIANT_TO_DOUBLE(variant_)); | |
| 166 } | |
| 167 | |
| 168 TEST_F(NPUtilsTest, TestStringValueToNPVariant) { | |
| 169 ValueToNPVariant(std::string("hello"), &variant_); | |
| 170 EXPECT_TRUE(NPVARIANT_IS_STRING(variant_)); | |
| 171 EXPECT_EQ(std::string("hello"), | |
| 172 std::string(variant_.value.stringValue.UTF8Characters, | |
| 173 variant_.value.stringValue.UTF8Length)); | |
| 174 } | |
| 175 | |
| 176 TEST_F(NPUtilsTest, TestObjectValueToNPVariant) { | |
| 177 NPObjectPointer<NPObject> object = | |
| 178 NPCreateObject<StrictMock<MockNPObject> >(NULL); | |
| 179 | |
| 180 ValueToNPVariant(object, &variant_); | |
| 181 EXPECT_TRUE(NPVARIANT_IS_OBJECT(variant_)); | |
| 182 EXPECT_EQ(object.Get(), NPVARIANT_TO_OBJECT(variant_)); | |
| 183 | |
| 184 NPBrowser::get()->ReleaseVariantValue(&variant_); | |
| 185 } | |
| 186 | |
| 187 TEST_F(NPUtilsTest, TestNullValueToNPVariant) { | |
| 188 ValueToNPVariant(NPObjectPointer<NPObject>(), &variant_); | |
| 189 EXPECT_TRUE(NPVARIANT_IS_NULL(variant_)); | |
| 190 } | |
| 191 | |
| 192 TEST_F(NPUtilsTest, CanCopyObjectSmartVariant) { | |
| 193 NPObjectPointer<NPObject> object = | |
| 194 NPCreateObject<StrictMock<MockNPObject> >(NULL); | |
| 195 EXPECT_EQ(1, object->referenceCount); | |
| 196 { | |
| 197 SmartNPVariant v1(object); | |
| 198 EXPECT_EQ(2, object->referenceCount); | |
| 199 { | |
| 200 SmartNPVariant v2(v1); | |
| 201 EXPECT_EQ(3, object->referenceCount); | |
| 202 } | |
| 203 EXPECT_EQ(2, object->referenceCount); | |
| 204 } | |
| 205 EXPECT_EQ(1, object->referenceCount); | |
| 206 } | |
| 207 | |
| 208 TEST_F(NPUtilsTest, CanCopyStringSmartVariant) { | |
| 209 SmartNPVariant v1(std::string("hello")); | |
| 210 SmartNPVariant v2(v1); | |
| 211 std::string r; | |
| 212 EXPECT_TRUE(NPVariantToValue(&r, v2)); | |
| 213 EXPECT_EQ(std::string("hello"), r); | |
| 214 EXPECT_NE(v1.value.stringValue.UTF8Characters, | |
| 215 v2.value.stringValue.UTF8Characters); | |
| 216 } | |
| 217 | |
| 218 TEST_F(NPUtilsTest, CanReleaseSmartVariant) { | |
| 219 SmartNPVariant variant(std::string("hello")); | |
| 220 EXPECT_FALSE(variant.IsVoid()); | |
| 221 variant.Release(); | |
| 222 EXPECT_TRUE(variant.IsVoid()); | |
| 223 } | |
| 224 | |
| 225 template <typename T> | |
| 226 class VariantMatcher : public testing::MatcherInterface<const NPVariant&> { | |
| 227 public: | |
| 228 explicit VariantMatcher(const T& value) : value_(value) { | |
| 229 } | |
| 230 | |
| 231 virtual bool Matches(const NPVariant& variant) const { | |
| 232 T other_value; | |
| 233 return NPVariantToValue(&other_value, variant) && other_value == value_; | |
| 234 } | |
| 235 | |
| 236 virtual void DescribeTo(::std::ostream* os) const { | |
| 237 *os << "equals " << value_; | |
| 238 } | |
| 239 | |
| 240 virtual void DescribeNegationTo(::std::ostream* os) const { | |
| 241 *os << "does not equal " << value_; | |
| 242 } | |
| 243 | |
| 244 private: | |
| 245 T value_; | |
| 246 }; | |
| 247 | |
| 248 template <typename T> | |
| 249 Matcher<const NPVariant&> VariantMatches(const T& value) { | |
| 250 return MakeMatcher(new VariantMatcher<T>(value)); | |
| 251 } | |
| 252 | |
| 253 TEST_F(NPUtilsTest, CanDetermineIfObjectHasMethod) { | |
| 254 NPIdentifier name = NPBrowser::get()->GetStringIdentifier("foo"); | |
| 255 NPObjectPointer<MockNPObject> object = | |
| 256 NPCreateObject<StrictMock<MockNPObject> >(NULL); | |
| 257 | |
| 258 EXPECT_CALL(*object, HasMethod(name)) | |
| 259 .WillOnce(Return(true)); | |
| 260 | |
| 261 EXPECT_TRUE(NPHasMethod(NULL, object, "foo")); | |
| 262 } | |
| 263 | |
| 264 TEST_F(NPUtilsTest, CanInvokeVoidMethodWithNativeTypes) { | |
| 265 NPIdentifier name = NPBrowser::get()->GetStringIdentifier("foo"); | |
| 266 NPObjectPointer<MockNPObject> object = | |
| 267 NPCreateObject<StrictMock<MockNPObject> >(NULL); | |
| 268 | |
| 269 VOID_TO_NPVARIANT(variant_); | |
| 270 | |
| 271 EXPECT_CALL(*object, Invoke(name, Pointee(VariantMatches<int32>(7)), 1, _)) | |
| 272 .WillOnce(DoAll(SetArgumentPointee<3>(variant_), | |
| 273 Return(true))); | |
| 274 | |
| 275 EXPECT_TRUE(NPInvokeVoid(NULL, object, "foo", 7)); | |
| 276 } | |
| 277 | |
| 278 TEST_F(NPUtilsTest, InvokeVoidMethodCanFail) { | |
| 279 NPIdentifier name = NPBrowser::get()->GetStringIdentifier("foo"); | |
| 280 NPObjectPointer<MockNPObject> object = | |
| 281 NPCreateObject<StrictMock<MockNPObject> >(NULL); | |
| 282 | |
| 283 VOID_TO_NPVARIANT(variant_); | |
| 284 | |
| 285 EXPECT_CALL(*object, Invoke(name, Pointee(VariantMatches<int32>(7)), 1, _)) | |
| 286 .WillOnce(DoAll(SetArgumentPointee<3>(variant_), | |
| 287 Return(false))); | |
| 288 | |
| 289 EXPECT_FALSE(NPInvokeVoid(NULL, object, "foo", 7)); | |
| 290 } | |
| 291 | |
| 292 TEST_F(NPUtilsTest, CanInvokeNonVoidMethodWithNativeTypes) { | |
| 293 NPIdentifier name = NPBrowser::get()->GetStringIdentifier("foo"); | |
| 294 NPObjectPointer<MockNPObject> object = | |
| 295 NPCreateObject<StrictMock<MockNPObject> >(NULL); | |
| 296 | |
| 297 DOUBLE_TO_NPVARIANT(1.5, variant_); | |
| 298 | |
| 299 EXPECT_CALL(*object, Invoke(name, Pointee(VariantMatches<int32>(7)), 1, _)) | |
| 300 .WillOnce(DoAll(SetArgumentPointee<3>(variant_), | |
| 301 Return(true))); | |
| 302 | |
| 303 double r; | |
| 304 EXPECT_TRUE(NPInvoke(NULL, object, "foo", 7, &r)); | |
| 305 EXPECT_EQ(1.5, r); | |
| 306 } | |
| 307 | |
| 308 TEST_F(NPUtilsTest, InvokeNonVoidMethodCanFail) { | |
| 309 NPIdentifier name = NPBrowser::get()->GetStringIdentifier("foo"); | |
| 310 NPObjectPointer<MockNPObject> object = | |
| 311 NPCreateObject<StrictMock<MockNPObject> >(NULL); | |
| 312 | |
| 313 DOUBLE_TO_NPVARIANT(1.5, variant_); | |
| 314 | |
| 315 EXPECT_CALL(*object, Invoke(name, Pointee(VariantMatches<int32>(7)), 1, _)) | |
| 316 .WillOnce(DoAll(SetArgumentPointee<3>(variant_), | |
| 317 Return(false))); | |
| 318 | |
| 319 double r; | |
| 320 EXPECT_FALSE(NPInvoke(NULL, object, "foo", 7, &r)); | |
| 321 } | |
| 322 | |
| 323 TEST_F(NPUtilsTest, InvokeNonVoidMethodFailsIfResultIsIncompatible) { | |
| 324 NPIdentifier name = NPBrowser::get()->GetStringIdentifier("foo"); | |
| 325 NPObjectPointer<MockNPObject> object = | |
| 326 NPCreateObject<StrictMock<MockNPObject> >(NULL); | |
| 327 | |
| 328 DOUBLE_TO_NPVARIANT(1.5, variant_); | |
| 329 | |
| 330 EXPECT_CALL(*object, Invoke(name, Pointee(VariantMatches<int32>(7)), 1, _)) | |
| 331 .WillOnce(DoAll(SetArgumentPointee<3>(variant_), | |
| 332 Return(true))); | |
| 333 | |
| 334 int r; | |
| 335 EXPECT_FALSE(NPInvoke(NULL, object, "foo", 7, &r)); | |
| 336 } | |
| 337 | |
| 338 TEST_F(NPUtilsTest, CanDetermineIfObjectHasProperty) { | |
| 339 NPIdentifier name = NPBrowser::get()->GetStringIdentifier("foo"); | |
| 340 NPObjectPointer<MockNPObject> object = | |
| 341 NPCreateObject<StrictMock<MockNPObject> >(NULL); | |
| 342 | |
| 343 EXPECT_CALL(*object, HasProperty(name)) | |
| 344 .WillOnce(Return(true)); | |
| 345 | |
| 346 EXPECT_TRUE(NPHasProperty(NULL, object, "foo")); | |
| 347 } | |
| 348 | |
| 349 TEST_F(NPUtilsTest, CanGetPropertyValue) { | |
| 350 NPIdentifier name = NPBrowser::get()->GetStringIdentifier("foo"); | |
| 351 NPObjectPointer<MockNPObject> object = | |
| 352 NPCreateObject<StrictMock<MockNPObject> >(NULL); | |
| 353 | |
| 354 DOUBLE_TO_NPVARIANT(1.5, variant_); | |
| 355 | |
| 356 EXPECT_CALL(*object, GetProperty(name, _)) | |
| 357 .WillOnce(DoAll(SetArgumentPointee<1>(variant_), | |
| 358 Return(true))); | |
| 359 | |
| 360 double r; | |
| 361 EXPECT_TRUE(NPGetProperty(NULL, object, "foo", &r)); | |
| 362 } | |
| 363 | |
| 364 TEST_F(NPUtilsTest, NPGetPropertyReportsFailureIfResultTypeIsDifferent) { | |
| 365 NPIdentifier name = NPBrowser::get()->GetStringIdentifier("foo"); | |
| 366 NPObjectPointer<MockNPObject> object = | |
| 367 NPCreateObject<StrictMock<MockNPObject> >(NULL); | |
| 368 | |
| 369 DOUBLE_TO_NPVARIANT(1.5, variant_); | |
| 370 | |
| 371 EXPECT_CALL(*object, GetProperty(name, _)) | |
| 372 .WillOnce(DoAll(SetArgumentPointee<1>(variant_), | |
| 373 Return(true))); | |
| 374 | |
| 375 bool r; | |
| 376 EXPECT_FALSE(NPGetProperty(NULL, object, "foo", &r)); | |
| 377 } | |
| 378 | |
| 379 TEST_F(NPUtilsTest, NPGetPropertyReportsFailureFromGetProperty) { | |
| 380 NPIdentifier name = NPBrowser::get()->GetStringIdentifier("foo"); | |
| 381 NPObjectPointer<MockNPObject> object = | |
| 382 NPCreateObject<StrictMock<MockNPObject> >(NULL); | |
| 383 | |
| 384 EXPECT_CALL(*object, GetProperty(name, _)) | |
| 385 .WillOnce(Return(false)); | |
| 386 | |
| 387 double r; | |
| 388 EXPECT_FALSE(NPGetProperty(NULL, object, "foo", &r)); | |
| 389 } | |
| 390 | |
| 391 TEST_F(NPUtilsTest, CanSetPropertyValue) { | |
| 392 NPIdentifier name = NPBrowser::get()->GetStringIdentifier("foo"); | |
| 393 NPObjectPointer<MockNPObject> object = | |
| 394 NPCreateObject<StrictMock<MockNPObject> >(NULL); | |
| 395 | |
| 396 EXPECT_CALL(*object, SetProperty(name, Pointee(VariantMatches(1.5)))) | |
| 397 .WillOnce(Return(true)); | |
| 398 | |
| 399 EXPECT_TRUE(NPSetProperty(NULL, object, "foo", 1.5)); | |
| 400 } | |
| 401 | |
| 402 TEST_F(NPUtilsTest, NPSetPropertyReportsFailureFromSetProperty) { | |
| 403 NPIdentifier name = NPBrowser::get()->GetStringIdentifier("foo"); | |
| 404 NPObjectPointer<MockNPObject> object = | |
| 405 NPCreateObject<StrictMock<MockNPObject> >(NULL); | |
| 406 | |
| 407 EXPECT_CALL(*object, SetProperty(name, Pointee(VariantMatches(1.5)))) | |
| 408 .WillOnce(Return(false)); | |
| 409 | |
| 410 EXPECT_FALSE(NPSetProperty(NULL, object, "foo", 1.5)); | |
| 411 } | |
| 412 | |
| 413 TEST_F(NPUtilsTest, CanRemovePropertyValue) { | |
| 414 NPIdentifier name = NPBrowser::get()->GetStringIdentifier("foo"); | |
| 415 NPObjectPointer<MockNPObject> object = | |
| 416 NPCreateObject<StrictMock<MockNPObject> >(NULL); | |
| 417 | |
| 418 EXPECT_CALL(*object, RemoveProperty(name)) | |
| 419 .WillOnce(Return(true)); | |
| 420 | |
| 421 EXPECT_TRUE(NPRemoveProperty(NULL, object, "foo")); | |
| 422 } | |
| 423 | |
| 424 } // namespace np_utils | |
| OLD | NEW |
|---|
Chromium Code Reviews
