diff options
Diffstat (limited to 'chromium/ppapi/shared_impl/var_value_conversions_unittest.cc')
| -rw-r--r-- | chromium/ppapi/shared_impl/var_value_conversions_unittest.cc | 396 |
1 files changed, 0 insertions, 396 deletions
diff --git a/chromium/ppapi/shared_impl/var_value_conversions_unittest.cc b/chromium/ppapi/shared_impl/var_value_conversions_unittest.cc deleted file mode 100644 index f8a0a3129e8..00000000000 --- a/chromium/ppapi/shared_impl/var_value_conversions_unittest.cc +++ /dev/null @@ -1,396 +0,0 @@ -// Copyright (c) 2013 The Chromium Authors. All rights reserved. -// Use of this source code is governed by a BSD-style license that can be -// found in the LICENSE file. - -#include "ppapi/shared_impl/var_value_conversions.h" - -#include <cmath> -#include <cstring> - -#include "base/logging.h" -#include "base/memory/ref_counted.h" -#include "base/memory/scoped_ptr.h" -#include "base/values.h" -#include "ppapi/c/pp_bool.h" -#include "ppapi/c/pp_var.h" -#include "ppapi/shared_impl/array_var.h" -#include "ppapi/shared_impl/dictionary_var.h" -#include "ppapi/shared_impl/ppapi_globals.h" -#include "ppapi/shared_impl/proxy_lock.h" -#include "ppapi/shared_impl/scoped_pp_var.h" -#include "ppapi/shared_impl/test_globals.h" -#include "ppapi/shared_impl/var.h" -#include "ppapi/shared_impl/var_tracker.h" -#include "testing/gtest/include/gtest/gtest.h" - -namespace ppapi { -namespace { - -bool Equals(const base::Value& value, const PP_Var& var) { - switch (value.GetType()) { - case base::Value::TYPE_NULL: { - return var.type == PP_VARTYPE_NULL || var.type == PP_VARTYPE_UNDEFINED; - } - case base::Value::TYPE_BOOLEAN: { - bool result = false; - return var.type == PP_VARTYPE_BOOL && - value.GetAsBoolean(&result) && - result == PP_ToBool(var.value.as_bool); - } - case base::Value::TYPE_INTEGER: { - int result = 0; - return var.type == PP_VARTYPE_INT32 && - value.GetAsInteger(&result) && - result == var.value.as_int; - } - case base::Value::TYPE_DOUBLE: { - double result = 0; - return var.type == PP_VARTYPE_DOUBLE && - value.GetAsDouble(&result) && - fabs(result - var.value.as_double) < 1.0e-4; - } - case base::Value::TYPE_STRING: { - std::string result; - StringVar* string_var = StringVar::FromPPVar(var); - return string_var && - value.GetAsString(&result) && - result == string_var->value(); - } - case base::Value::TYPE_BINARY: { - const base::BinaryValue& binary_value = - static_cast<const base::BinaryValue&>(value); - ArrayBufferVar* array_buffer_var = ArrayBufferVar::FromPPVar(var); - if (!array_buffer_var || - binary_value.GetSize() != array_buffer_var->ByteLength()) { - return false; - } - - bool result = !memcmp(binary_value.GetBuffer(), array_buffer_var->Map(), - binary_value.GetSize()); - array_buffer_var->Unmap(); - return result; - } - case base::Value::TYPE_DICTIONARY: { - const base::DictionaryValue& dict_value = - static_cast<const base::DictionaryValue&>(value); - DictionaryVar* dict_var = DictionaryVar::FromPPVar(var); - if (!dict_var) - return false; - - size_t count = 0; - for (DictionaryVar::KeyValueMap::const_iterator iter = - dict_var->key_value_map().begin(); - iter != dict_var->key_value_map().end(); - ++iter) { - if (iter->second.get().type == PP_VARTYPE_UNDEFINED || - iter->second.get().type == PP_VARTYPE_NULL) { - continue; - } - - ++count; - const base::Value* sub_value = NULL; - if (!dict_value.GetWithoutPathExpansion(iter->first, &sub_value) || - !Equals(*sub_value, iter->second.get())) { - return false; - } - } - return count == dict_value.size(); - } - case base::Value::TYPE_LIST: { - const base::ListValue& list_value = - static_cast<const base::ListValue&>(value); - ArrayVar* array_var = ArrayVar::FromPPVar(var); - if (!array_var || list_value.GetSize() != array_var->elements().size()) - return false; - - base::ListValue::const_iterator value_iter = list_value.begin(); - ArrayVar::ElementVector::const_iterator var_iter = - array_var->elements().begin(); - for (; value_iter != list_value.end() && - var_iter != array_var->elements().end(); - ++value_iter, ++var_iter) { - if (!Equals(**value_iter, var_iter->get())) - return false; - } - return true; - } - } - NOTREACHED(); - return false; -} - -bool ConvertVarAndVerify(const PP_Var& var) { - scoped_ptr<base::Value> value(CreateValueFromVar(var)); - if (value.get()) - return Equals(*value, var); - return false; -} - -bool ConvertValueAndVerify(const base::Value& value) { - ScopedPPVar var(ScopedPPVar::PassRef(), CreateVarFromValue(value)); - if (var.get().type != PP_VARTYPE_UNDEFINED) - return Equals(value, var.get()); - return false; -} - -class VarValueConversionsTest : public testing::Test { - public: - VarValueConversionsTest() { - } - virtual ~VarValueConversionsTest() { - } - - // testing::Test implementation. - virtual void SetUp() { - ProxyLock::EnableLockingOnThreadForTest(); - ProxyLock::Acquire(); - } - virtual void TearDown() { - ASSERT_TRUE(PpapiGlobals::Get()->GetVarTracker()->GetLiveVars().empty()); - ProxyLock::Release(); - } - - private: - TestGlobals globals_; -}; - -} // namespace - -TEST_F(VarValueConversionsTest, CreateValueFromVar) { - { - // Var holding a ref to itself is not a valid input. - scoped_refptr<DictionaryVar> dict_var(new DictionaryVar()); - ScopedPPVar var_1(ScopedPPVar::PassRef(), dict_var->GetPPVar()); - scoped_refptr<ArrayVar> array_var(new ArrayVar()); - ScopedPPVar var_2(ScopedPPVar::PassRef(), array_var->GetPPVar()); - - ASSERT_TRUE(dict_var->SetWithStringKey("key_1", var_2.get())); - ASSERT_TRUE(ConvertVarAndVerify(var_1.get())); - - ASSERT_TRUE(array_var->Set(0, var_1.get())); - scoped_ptr<base::Value> value(CreateValueFromVar(var_1.get())); - ASSERT_EQ(NULL, value.get()); - - // Make sure |var_1| doesn't indirectly hold a ref to itself, otherwise it - // is leaked. - dict_var->DeleteWithStringKey("key_1"); - } - - // Vars of null or undefined type are converted to null values. - { - ASSERT_TRUE(ConvertVarAndVerify(PP_MakeNull())); - ASSERT_TRUE(ConvertVarAndVerify(PP_MakeUndefined())); - } - - { - // Test empty dictionary. - scoped_refptr<DictionaryVar> dict_var(new DictionaryVar()); - ScopedPPVar var(ScopedPPVar::PassRef(), dict_var->GetPPVar()); - - ASSERT_TRUE(ConvertVarAndVerify(var.get())); - } - - { - // Key-value pairs whose value is undefined or null are ignored. - scoped_refptr<DictionaryVar> dict_var(new DictionaryVar()); - ASSERT_TRUE(dict_var->SetWithStringKey("key_1", PP_MakeUndefined())); - ASSERT_TRUE(dict_var->SetWithStringKey("key_2", PP_MakeInt32(1))); - ASSERT_TRUE(dict_var->SetWithStringKey("key_3", PP_MakeNull())); - ScopedPPVar var(ScopedPPVar::PassRef(), dict_var->GetPPVar()); - - ASSERT_TRUE(ConvertVarAndVerify(var.get())); - } - - { - // The same PP_Var is allowed to appear multiple times. - scoped_refptr<DictionaryVar> dict_var_1(new DictionaryVar()); - ScopedPPVar dict_pp_var_1(ScopedPPVar::PassRef(), dict_var_1->GetPPVar()); - scoped_refptr<DictionaryVar> dict_var_2(new DictionaryVar()); - ScopedPPVar dict_pp_var_2(ScopedPPVar::PassRef(), dict_var_2->GetPPVar()); - scoped_refptr<StringVar> string_var(new StringVar("string_value")); - ScopedPPVar string_pp_var(ScopedPPVar::PassRef(), string_var->GetPPVar()); - - ASSERT_TRUE(dict_var_1->SetWithStringKey("key_1", dict_pp_var_2.get())); - ASSERT_TRUE(dict_var_1->SetWithStringKey("key_2", dict_pp_var_2.get())); - ASSERT_TRUE(dict_var_1->SetWithStringKey("key_3", string_pp_var.get())); - ASSERT_TRUE(dict_var_2->SetWithStringKey("key_4", string_pp_var.get())); - - ASSERT_TRUE(ConvertVarAndVerify(dict_pp_var_1.get())); - } - - { - // Test basic cases for array. - scoped_refptr<ArrayVar> array_var(new ArrayVar()); - ScopedPPVar var(ScopedPPVar::PassRef(), array_var->GetPPVar()); - - ASSERT_TRUE(ConvertVarAndVerify(var.get())); - - ASSERT_TRUE(array_var->Set(0, PP_MakeDouble(1))); - - ASSERT_TRUE(ConvertVarAndVerify(var.get())); - } - - { - // Test more complex inputs. - scoped_refptr<DictionaryVar> dict_var_1(new DictionaryVar()); - ScopedPPVar dict_pp_var_1(ScopedPPVar::PassRef(), dict_var_1->GetPPVar()); - scoped_refptr<DictionaryVar> dict_var_2(new DictionaryVar()); - ScopedPPVar dict_pp_var_2(ScopedPPVar::PassRef(), dict_var_2->GetPPVar()); - scoped_refptr<ArrayVar> array_var(new ArrayVar()); - ScopedPPVar array_pp_var(ScopedPPVar::PassRef(), array_var->GetPPVar()); - scoped_refptr<StringVar> string_var(new StringVar("string_value")); - ScopedPPVar string_pp_var(ScopedPPVar::PassRef(), string_var->GetPPVar()); - - ASSERT_TRUE(dict_var_1->SetWithStringKey("null_key", PP_MakeNull())); - ASSERT_TRUE(dict_var_1->SetWithStringKey("string_key", - string_pp_var.get())); - ASSERT_TRUE(dict_var_1->SetWithStringKey("dict_key", dict_pp_var_2.get())); - - ASSERT_TRUE(dict_var_2->SetWithStringKey("undefined_key", - PP_MakeUndefined())); - ASSERT_TRUE(dict_var_2->SetWithStringKey("double_key", PP_MakeDouble(1))); - ASSERT_TRUE(dict_var_2->SetWithStringKey("array_key", array_pp_var.get())); - - ASSERT_TRUE(array_var->Set(0, PP_MakeInt32(2))); - ASSERT_TRUE(array_var->Set(1, PP_MakeBool(PP_TRUE))); - ASSERT_TRUE(array_var->SetLength(4)); - - ASSERT_TRUE(ConvertVarAndVerify(dict_pp_var_1.get())); - } - - { - // Test that dictionary keys containing '.' are handled correctly. - scoped_refptr<DictionaryVar> dict_var(new DictionaryVar()); - ScopedPPVar dict_pp_var(ScopedPPVar::PassRef(), dict_var->GetPPVar()); - - ASSERT_TRUE(dict_var->SetWithStringKey("double.key", PP_MakeDouble(1))); - ASSERT_TRUE(dict_var->SetWithStringKey("int.key..name", PP_MakeInt32(2))); - - ASSERT_TRUE(ConvertVarAndVerify(dict_pp_var.get())); - } -} - -TEST_F(VarValueConversionsTest, CreateVarFromValue) { - { - // Test basic cases for dictionary. - base::DictionaryValue dict_value; - ASSERT_TRUE(ConvertValueAndVerify(dict_value)); - - dict_value.SetInteger("int_key", 1); - ASSERT_TRUE(ConvertValueAndVerify(dict_value)); - } - - { - // Test basic cases for array. - base::ListValue list_value; - ASSERT_TRUE(ConvertValueAndVerify(list_value)); - - list_value.AppendInteger(1); - ASSERT_TRUE(ConvertValueAndVerify(list_value)); - } - - { - // Test more complex inputs. - base::DictionaryValue dict_value; - dict_value.SetString("string_key", "string_value"); - dict_value.SetDouble("dict_key.double_key", 1); - - scoped_ptr<base::ListValue> list_value(new base::ListValue()); - list_value->AppendInteger(2); - list_value->AppendBoolean(true); - list_value->Append(base::Value::CreateNullValue()); - - dict_value.Set("dict_key.array_key", list_value.release()); - - ASSERT_TRUE(ConvertValueAndVerify(dict_value)); - } -} - -TEST_F(VarValueConversionsTest, CreateListValueFromVarVector) { - { - // Test empty var vector. - scoped_ptr<base::ListValue> list_value( - CreateListValueFromVarVector(std::vector<PP_Var>())); - ASSERT_TRUE(list_value.get()); - ASSERT_EQ(0u, list_value->GetSize()); - } - - { - // Test more complex inputs. - scoped_refptr<StringVar> string_var(new StringVar("string_value")); - ScopedPPVar string_pp_var(ScopedPPVar::PassRef(), string_var->GetPPVar()); - - scoped_refptr<DictionaryVar> dict_var(new DictionaryVar()); - ScopedPPVar dict_pp_var(ScopedPPVar::PassRef(), dict_var->GetPPVar()); - ASSERT_TRUE(dict_var->SetWithStringKey("null_key", PP_MakeNull())); - ASSERT_TRUE(dict_var->SetWithStringKey("string_key", string_pp_var.get())); - - scoped_refptr<ArrayVar> array_var(new ArrayVar()); - ScopedPPVar array_pp_var(ScopedPPVar::PassRef(), array_var->GetPPVar()); - ASSERT_TRUE(array_var->Set(0, PP_MakeInt32(2))); - ASSERT_TRUE(array_var->Set(1, PP_MakeBool(PP_TRUE))); - ASSERT_TRUE(array_var->SetLength(4)); - - std::vector<PP_Var> vars; - vars.push_back(dict_pp_var.get()); - vars.push_back(string_pp_var.get()); - vars.push_back(array_pp_var.get()); - vars.push_back(PP_MakeDouble(1)); - vars.push_back(PP_MakeUndefined()); - vars.push_back(PP_MakeNull()); - - scoped_ptr<base::ListValue> list_value(CreateListValueFromVarVector(vars)); - - ASSERT_TRUE(list_value.get()); - ASSERT_EQ(vars.size(), list_value->GetSize()); - - for (size_t i = 0; i < list_value->GetSize(); ++i) { - const base::Value* value = NULL; - ASSERT_TRUE(list_value->Get(i, &value)); - ASSERT_TRUE(Equals(*value, vars[i])); - } - } -} - -TEST_F(VarValueConversionsTest, CreateVarVectorFromListValue) { - { - // Test empty list. - base::ListValue list_value; - std::vector<PP_Var> vars; - ASSERT_TRUE(CreateVarVectorFromListValue(list_value, &vars)); - ASSERT_EQ(0u, vars.size()); - } - - { - // Test more complex inputs. - base::ListValue list_value; - - scoped_ptr<base::DictionaryValue> dict_value(new base::DictionaryValue()); - dict_value->SetString("string_key", "string_value"); - - scoped_ptr<base::ListValue> sub_list_value(new base::ListValue()); - sub_list_value->AppendInteger(2); - sub_list_value->AppendBoolean(true); - - list_value.Append(dict_value.release()); - list_value.AppendString("string_value"); - list_value.Append(sub_list_value.release()); - list_value.AppendDouble(1); - list_value.Append(base::Value::CreateNullValue()); - - std::vector<PP_Var> vars; - ASSERT_TRUE(CreateVarVectorFromListValue(list_value, &vars)); - - ASSERT_EQ(list_value.GetSize(), vars.size()); - - for (size_t i = 0; i < list_value.GetSize(); ++i) { - const base::Value* value = NULL; - ASSERT_TRUE(list_value.Get(i, &value)); - ASSERT_TRUE(Equals(*value, vars[i])); - - PpapiGlobals::Get()->GetVarTracker()->ReleaseVar(vars[i]); - } - } -} - -} // namespace ppapi |