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