test_var_resource.cc 4.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133
  1. // Copyright 2013 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. #include "ppapi/tests/test_var_resource.h"
  5. #include <stdint.h>
  6. #include "ppapi/c/pp_resource.h"
  7. #include "ppapi/c/pp_var.h"
  8. #include "ppapi/cpp/instance.h"
  9. #include "ppapi/cpp/module.h"
  10. #include "ppapi/tests/testing_instance.h"
  11. REGISTER_TEST_CASE(VarResource);
  12. bool TestVarResource::Init() {
  13. core_interface_ = static_cast<const PPB_Core*>(
  14. pp::Module::Get()->GetBrowserInterface(PPB_CORE_INTERFACE));
  15. file_system_interface_ = static_cast<const PPB_FileSystem*>(
  16. pp::Module::Get()->GetBrowserInterface(PPB_FILESYSTEM_INTERFACE));
  17. var_interface_ = static_cast<const PPB_Var*>(
  18. pp::Module::Get()->GetBrowserInterface(PPB_VAR_INTERFACE));
  19. return core_interface_ && file_system_interface_ && var_interface_ &&
  20. CheckTestingInterface();
  21. }
  22. void TestVarResource::RunTests(const std::string& filter) {
  23. RUN_TEST(BasicResource, filter);
  24. RUN_TEST(InvalidAndEmpty, filter);
  25. RUN_TEST(WrongType, filter);
  26. }
  27. std::string TestVarResource::TestBasicResource() {
  28. uint32_t before_object = testing_interface_->GetLiveObjectsForInstance(
  29. instance_->pp_instance());
  30. {
  31. // Create an unopened FileSystem resource.
  32. PP_Resource file_system = file_system_interface_->Create(
  33. instance_->pp_instance(), PP_FILESYSTEMTYPE_LOCALTEMPORARY);
  34. ASSERT_NE(0, file_system);
  35. // Build a var to wrap the resource.
  36. PP_Var var = var_interface_->VarFromResource(file_system);
  37. ASSERT_EQ(PP_VARTYPE_RESOURCE, var.type);
  38. // Reading back the resource should work. This will increment the reference
  39. // on the resource, so we must release it afterwards.
  40. PP_Resource result = var_interface_->VarToResource(var);
  41. ASSERT_EQ(file_system, result);
  42. core_interface_->ReleaseResource(result);
  43. // Destroy the var, readback should now fail.
  44. var_interface_->Release(var);
  45. result = var_interface_->VarToResource(var);
  46. ASSERT_EQ(0, result);
  47. // Release the resource. There should be no more references to it.
  48. core_interface_->ReleaseResource(file_system);
  49. }
  50. // Make sure nothing leaked. This checks for both var and resource leaks.
  51. ASSERT_EQ(
  52. before_object,
  53. testing_interface_->GetLiveObjectsForInstance(instance_->pp_instance()));
  54. PASS();
  55. }
  56. std::string TestVarResource::TestInvalidAndEmpty() {
  57. uint32_t before_object = testing_interface_->GetLiveObjectsForInstance(
  58. instance_->pp_instance());
  59. {
  60. PP_Var invalid_resource;
  61. invalid_resource.type = PP_VARTYPE_RESOURCE;
  62. invalid_resource.value.as_id = 31415926;
  63. // Invalid resource vars should give 0 as the return value.
  64. PP_Resource result = var_interface_->VarToResource(invalid_resource);
  65. ASSERT_EQ(0, result);
  66. // Test writing and reading a non-existant resource.
  67. PP_Resource fake_resource = 27182818;
  68. PP_Var var = var_interface_->VarFromResource(fake_resource);
  69. if (testing_interface()->IsOutOfProcess()) {
  70. // An out-of-process plugin is expected to generate null in this case.
  71. ASSERT_EQ(PP_VARTYPE_NULL, var.type);
  72. result = var_interface_->VarToResource(var);
  73. ASSERT_EQ(0, result);
  74. } else {
  75. // An in-process plugin is expected to generate a valid resource var
  76. // (because it does not validate the resource).
  77. ASSERT_EQ(PP_VARTYPE_RESOURCE, var.type);
  78. result = var_interface_->VarToResource(var);
  79. ASSERT_EQ(fake_resource, result);
  80. var_interface_->Release(var);
  81. }
  82. // Note: Not necessary to release the resource, since it does not exist.
  83. // Write the resource 0; expect a valid resource var with 0.
  84. var = var_interface_->VarFromResource(0);
  85. ASSERT_EQ(PP_VARTYPE_RESOURCE, var.type);
  86. result = var_interface_->VarToResource(var);
  87. ASSERT_EQ(0, result);
  88. var_interface_->Release(var);
  89. }
  90. // Make sure nothing leaked. This checks for both var and resource leaks.
  91. ASSERT_EQ(
  92. before_object,
  93. testing_interface_->GetLiveObjectsForInstance(instance_->pp_instance()));
  94. PASS();
  95. }
  96. std::string TestVarResource::TestWrongType() {
  97. PP_Resource result = var_interface_->VarToResource(PP_MakeUndefined());
  98. ASSERT_EQ(0, result);
  99. result = var_interface_->VarToResource(PP_MakeNull());
  100. ASSERT_EQ(0, result);
  101. result = var_interface_->VarToResource(PP_MakeBool(PP_TRUE));
  102. ASSERT_EQ(0, result);
  103. result = var_interface_->VarToResource(PP_MakeInt32(42));
  104. ASSERT_EQ(0, result);
  105. result = var_interface_->VarToResource(PP_MakeDouble(1.0));
  106. ASSERT_EQ(0, result);
  107. PASS();
  108. }