Implementing better fallback algorithm....

chrome/common/extensions/extension_message_bundle_unittest.cc

 // Copyright (c) 2009 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 "chrome/common/extensions/extension_message_bundle.h"
 
 #include <string>
+#include <vector>
 
+#include "base/linked_ptr.h"
 #include "base/scoped_ptr.h"
 #include "base/string_util.h"
 #include "base/values.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
 // Helper method for dictionary building.
 void SetDictionary(const std::wstring name,
                    DictionaryValue* target,
@@ skipping 23 matching lines @@
                        const std::string& message,
                        bool create_placeholder_subtree,
                        DictionaryValue* dict) {
   DictionaryValue* message_tree = new DictionaryValue;
   if (create_placeholder_subtree)
     CreatePlaceholdersTree(message_tree);
   message_tree->SetString(ExtensionMessageBundle::kMessageKey, message);
   SetDictionary(name, dict, message_tree);
 }
 
-void CreateGoodDictionary(DictionaryValue* dict) {
-  dict->Clear();
+// Caller owns the memory.
+DictionaryValue* CreateGoodDictionary() {
+  DictionaryValue* dict = new DictionaryValue;
   CreateMessageTree(L"n1", "message1 $a$ $b$", true, dict);
   CreateMessageTree(L"n2", "message2 $c$", true, dict);
   CreateMessageTree(L"n3", "message3", false, dict);
+  return dict;
 }
 
 enum BadDictionary {
   INVALID_NAME,
   NAME_NOT_A_TREE,
   EMPTY_NAME_TREE,
   MISSING_MESSAGE,
   PLACEHOLDER_NOT_A_TREE,
   EMPTY_PLACEHOLDER_TREE,
   CONTENT_MISSING,
   MESSAGE_PLACEHOLDER_DOESNT_MATCH,
 };
 
-void CreateBadDictionary(DictionaryValue* dict,
-                         enum BadDictionary what_is_bad) {
-  CreateGoodDictionary(dict);
+// Caller owns the memory.
+DictionaryValue* CreateBadDictionary(enum BadDictionary what_is_bad) {
+  DictionaryValue* dict = CreateGoodDictionary();
   // Now remove/break things.
   switch (what_is_bad) {
     case INVALID_NAME:
       CreateMessageTree(L"n 5", "nevermind", false, dict);
       break;
     case NAME_NOT_A_TREE:
       dict->SetString(L"n4", "whatever");
       break;
     case EMPTY_NAME_TREE: {
         DictionaryValue* empty_tree = new DictionaryValue;
@@ skipping 14 matching lines @@
     case CONTENT_MISSING:
        dict->Remove(L"n1.placeholders.a.content", NULL);
       break;
     case MESSAGE_PLACEHOLDER_DOESNT_MATCH:
       DictionaryValue* value;
       dict->Remove(L"n1.placeholders.a", NULL);
       dict->GetDictionary(L"n1.placeholders", &value);
       CreateContentTree(L"x", "X", value);
       break;
   }
+
+  return dict;
 }
 
 TEST(ExtensionMessageBundle, InitEmptyDictionaries) {
-  DictionaryValue default_dict;
-  DictionaryValue app_dict;
+  std::vector<linked_ptr<DictionaryValue> > catalogs;
   std::string error;
   scoped_ptr<ExtensionMessageBundle> handler(
-      ExtensionMessageBundle::Create(default_dict, app_dict, &error));
+      ExtensionMessageBundle::Create(catalogs, &error));
 
   EXPECT_TRUE(handler.get() != NULL);
   EXPECT_EQ(0U, handler->size());
 }
 
-TEST(ExtensionMessageBundle, InitGoodDefaultDictEmptyAppDict) {
-  DictionaryValue default_dict;
-  DictionaryValue app_dict;
+TEST(ExtensionMessageBundle, InitGoodDefaultDict) {
+  std::vector<linked_ptr<DictionaryValue> > catalogs;
+  catalogs.push_back(linked_ptr<DictionaryValue>(CreateGoodDictionary()));
+
   std::string error;
-
-  CreateGoodDictionary(&default_dict);
   scoped_ptr<ExtensionMessageBundle> handler(
-      ExtensionMessageBundle::Create(default_dict, app_dict, &error));
+      ExtensionMessageBundle::Create(catalogs, &error));
 
   EXPECT_TRUE(handler.get() != NULL);
   EXPECT_EQ(3U, handler->size());
 
   EXPECT_EQ("message1 A B", handler->GetL10nMessage("n1"));
   EXPECT_EQ("message2 C", handler->GetL10nMessage("n2"));
   EXPECT_EQ("message3", handler->GetL10nMessage("n3"));
 }
 
 TEST(ExtensionMessageBundle, InitAppDictConsultedFirst) {
-  DictionaryValue default_dict;
-  DictionaryValue app_dict;
+  std::vector<linked_ptr<DictionaryValue> > catalogs;
+  catalogs.push_back(linked_ptr<DictionaryValue>(CreateGoodDictionary()));
+  catalogs.push_back(linked_ptr<DictionaryValue>(CreateGoodDictionary()));
+
+  DictionaryValue* app_dict = catalogs[0].get();
+  // Flip placeholders in message of n1 tree.
+  app_dict->SetString(L"n1.message", "message1 $b$ $a$");
+  // Remove one message from app dict.
+  app_dict->Remove(L"n2", NULL);
+  // Replace n3 with N3.
+  app_dict->Remove(L"n3", NULL);
+  CreateMessageTree(L"N3", "message3_app_dict", false, app_dict);
+
   std::string error;
-
-  CreateGoodDictionary(&default_dict);
-  CreateGoodDictionary(&app_dict);
-  // Flip placeholders in message of n1 tree.
-  app_dict.SetString(L"n1.message", "message1 $b$ $a$");
-  // Remove one message from app dict.
-  app_dict.Remove(L"n2", NULL);
-  // Replace n3 with N3.
-  app_dict.Remove(L"n3", NULL);
-  CreateMessageTree(L"N3", "message3_app_dict", false, &app_dict);
-
   scoped_ptr<ExtensionMessageBundle> handler(
-      ExtensionMessageBundle::Create(default_dict, app_dict, &error));
+      ExtensionMessageBundle::Create(catalogs, &error));
 
   EXPECT_TRUE(handler.get() != NULL);
   EXPECT_EQ(3U, handler->size());
 
   EXPECT_EQ("message1 B A", handler->GetL10nMessage("n1"));
   EXPECT_EQ("message2 C", handler->GetL10nMessage("n2"));
   EXPECT_EQ("message3_app_dict", handler->GetL10nMessage("n3"));
 }
 
 TEST(ExtensionMessageBundle, InitBadAppDict) {
-  DictionaryValue default_dict;
-  DictionaryValue app_dict;
+  std::vector<linked_ptr<DictionaryValue> > catalogs;
+  catalogs.push_back(
+      linked_ptr<DictionaryValue>(CreateBadDictionary(INVALID_NAME)));
+  catalogs.push_back(linked_ptr<DictionaryValue>(CreateGoodDictionary()));
+
   std::string error;
-
-  CreateBadDictionary(&app_dict, INVALID_NAME);
   scoped_ptr<ExtensionMessageBundle> handler(
-      ExtensionMessageBundle::Create(default_dict, app_dict, &error));
+      ExtensionMessageBundle::Create(catalogs, &error));
 
   EXPECT_TRUE(handler.get() == NULL);
   EXPECT_EQ("Name of a key \"n 5\" is invalid. Only ASCII [a-z], "
             "[A-Z], [0-9] and \"_\" are allowed.", error);
 
-  CreateBadDictionary(&app_dict, NAME_NOT_A_TREE);
-  handler.reset(ExtensionMessageBundle::Create(default_dict, app_dict, &error));
+  catalogs[0].reset(CreateBadDictionary(NAME_NOT_A_TREE));
+  handler.reset(ExtensionMessageBundle::Create(catalogs, &error));
   EXPECT_TRUE(handler.get() == NULL);
   EXPECT_EQ("Not a valid tree for key n4.", error);
 
-  CreateBadDictionary(&app_dict, EMPTY_NAME_TREE);
-  handler.reset(ExtensionMessageBundle::Create(default_dict, app_dict, &error));
+  catalogs[0].reset(CreateBadDictionary(EMPTY_NAME_TREE));
+  handler.reset(ExtensionMessageBundle::Create(catalogs, &error));
   EXPECT_TRUE(handler.get() == NULL);
   EXPECT_EQ("There is no \"message\" element for key n4.", error);
 
-  CreateBadDictionary(&app_dict, MISSING_MESSAGE);
-  handler.reset(ExtensionMessageBundle::Create(default_dict, app_dict, &error));
+  catalogs[0].reset(CreateBadDictionary(MISSING_MESSAGE));
+  handler.reset(ExtensionMessageBundle::Create(catalogs, &error));
   EXPECT_TRUE(handler.get() == NULL);
   EXPECT_EQ("There is no \"message\" element for key n1.", error);
 
-  CreateBadDictionary(&app_dict, PLACEHOLDER_NOT_A_TREE);
-  handler.reset(ExtensionMessageBundle::Create(default_dict, app_dict, &error));
+  catalogs[0].reset(CreateBadDictionary(PLACEHOLDER_NOT_A_TREE));
+  handler.reset(ExtensionMessageBundle::Create(catalogs, &error));
   EXPECT_TRUE(handler.get() == NULL);
   EXPECT_EQ("Not a valid \"placeholders\" element for key n1.", error);
 
-  CreateBadDictionary(&app_dict, EMPTY_PLACEHOLDER_TREE);
-  handler.reset(ExtensionMessageBundle::Create(default_dict, app_dict, &error));
+  catalogs[0].reset(CreateBadDictionary(EMPTY_PLACEHOLDER_TREE));
+  handler.reset(ExtensionMessageBundle::Create(catalogs, &error));
   EXPECT_TRUE(handler.get() == NULL);
   EXPECT_EQ("Variable $a$ used but not defined.", error);
 
-  CreateBadDictionary(&app_dict, CONTENT_MISSING);
-  handler.reset(ExtensionMessageBundle::Create(default_dict, app_dict, &error));
+  catalogs[0].reset(CreateBadDictionary(CONTENT_MISSING));
+  handler.reset(ExtensionMessageBundle::Create(catalogs, &error));
   EXPECT_TRUE(handler.get() == NULL);
   EXPECT_EQ("Invalid \"content\" element for key n1.", error);
 
-  CreateBadDictionary(&app_dict, MESSAGE_PLACEHOLDER_DOESNT_MATCH);
-  handler.reset(ExtensionMessageBundle::Create(default_dict, app_dict, &error));
+  catalogs[0].reset(CreateBadDictionary(MESSAGE_PLACEHOLDER_DOESNT_MATCH));
+  handler.reset(ExtensionMessageBundle::Create(catalogs, &error));
   EXPECT_TRUE(handler.get() == NULL);
   EXPECT_EQ("Variable $a$ used but not defined.", error);
 }
 
 struct ReplaceVariables {
   const char* original;
   const char* result;
   const char* error;
   const char* begin_delimiter;
   const char* end_delimiter;
@@ skipping 61 matching lines @@
       ExtensionMessageBundle::ReplaceVariables(messages,
                                                test_cases[i].begin_delimiter,
                                                test_cases[i].end_delimiter,
                                                &text,
                                                &error));
     EXPECT_EQ(test_cases[i].result, text);
   }
 }
 
 }  // namespace