def test_string_array(self):
random_name = generate_random_string()
random_key = '{}[0]'.format(random_name)
random_string = generate_random_string()
random_openstring = OpenString(random_key, random_string, order=0)
random_hash = random_openstring.template_replacement
source_python_template = strip_leading_spaces(u'''
<resources>
<string-array name="{key}">
<item>{string}</item>
</string-array>
</resources>
''')
source = source_python_template.format(key=random_name,
string=random_string)
template, stringset = self.handler.parse(source)
compiled = self.handler.compile(template, [random_openstring])
self.assertEqual(
template,
source_python_template.format(key=random_name, string=random_hash))
self.assertEqual(len(stringset), 1)
self.assertEqual(stringset[0].__dict__, random_openstring.__dict__)
self.assertEqual(compiled, source)
def test_string(self):
random_key = generate_random_string()
random_string = generate_random_string()
random_openstring = OpenString(random_key,
random_string, order=0)
random_hash = random_openstring.template_replacement
source_python_template = u'''
<resources>
<string name="{key}">{string}</string>
</resources>
'''
source = source_python_template.format(key=random_key,
string=random_string)
template, stringset = self.handler.parse(source)
compiled = self.handler.compile(template, [random_openstring])
self.assertEqual(
template,
source_python_template.format(key=random_key, string=random_hash)
)
self.assertEqual(len(stringset), 1)
self.assertEqual(stringset[0].__dict__, random_openstring.__dict__)
self.assertEqual(compiled, source)
def test_missing_translated_plurals_removed(self):
random_key = generate_random_string()
random_singular = generate_random_string()
random_plural = generate_random_string()
source = strip_leading_spaces(u'''
<resources>
<plurals name="{key}">
<item quantity="one">{singular}</item>
<item quantity="other">{plural}</item>
</plurals>
</resources>
'''.format(key=random_key,
singular=random_singular,
plural=random_plural))
template, stringset = self.handler.parse(source)
compiled = self.handler.compile(template, [])
self.assertEqual(
compiled,
strip_leading_spaces(u'''
<resources>
</resources>
'''.format(key=random_key,
singular=random_singular,
plural=random_plural)))
def test_missing_translated_string_array_items_removed(self):
random_key = generate_random_string()
random_string1 = generate_random_string()
random_string2 = generate_random_string()
source = strip_leading_spaces(u'''
<resources>
<string-array name="{key}">
<item>{string1}</item>
<item>{string2}</item>
</string-array>
</resources>
'''.format(key=random_key,
string1=random_string1,
string2=random_string2))
template, stringset = self.handler.parse(source)
compiled = self.handler.compile(template, [stringset[0]])
self.assertEqual(
compiled,
strip_leading_spaces(u'''
<resources>
<string-array name="{key}">
<item>{string1}</item>
</string-array>
</resources>
'''.format(key=random_key, string1=random_string1)))
def test_tools_locale(self):
random_key = generate_random_string()
random_string = generate_random_string()
random_openstring = OpenString(random_key, random_string, order=0)
random_hash = random_openstring.template_replacement
source_python_template = u'''
<resources tools:locale="{language_code}">
<string name="{key}">{string}</string>
</resources>
'''
source = source_python_template.format(language_code="en",
key=random_key,
string=random_string)
template, stringset = self.handler.parse(source)
compiled = self.handler.compile(template, [random_openstring],
language_info={'code': "fr"})
self.assertEqual(
template,
source_python_template.format(language_code="en", key=random_key,
string=random_hash)
)
self.assertEqual(len(stringset), 1)
self.assertEqual(stringset[0].__dict__, random_openstring.__dict__)
self.assertEqual(compiled,
source_python_template.format(language_code="fr",
key=random_key,
string=random_string))
def test_compile_for_target_language_clears_untranslatable_strings(self):
string = OpenString(generate_random_string(), generate_random_string(),
order=0)
template = """
<resources>
<string name="untranslatable"
translatable="false">Untranslatable</string>
<string name="{key}">{string}</string>
</resources>
""".format(key=string.key, string=string.template_replacement)
# Try for source
compiled = self.handler.compile(template, [string], is_source=True)
self.assertEqual(compiled, """
<resources>
<string name="untranslatable"
translatable="false">Untranslatable</string>
<string name="{key}">{string}</string>
</resources>
""".format(key=string.key, string=string.string))
# Try for translation
compiled = self.handler.compile(template, [string], is_source=False)
self.assertEqual(compiled, """
<resources>
<string name="{key}">{string}</string>
</resources>
""".format(key=string.key, string=string.string))
def test_plurals(self):
random_key = generate_random_string()
random_singular = generate_random_string()
random_plural = generate_random_string()
random_openstring = OpenString(random_key,
{1: random_singular, 5: random_plural},
order=0)
random_hash = random_openstring.template_replacement
source = strip_leading_spaces(u"""
<resources>
<plurals name="{key}">
<item quantity="one">{singular}</item>
<item quantity="other">{plural}</item>
</plurals>
</resources>
""".format(key=random_key, singular=random_singular,
plural=random_plural))
template, stringset = self.handler.parse(source)
compiled = self.handler.compile(template, [random_openstring])
self.assertEqual(
template,
strip_leading_spaces(u'''
<resources>
<plurals name="{key}">
{hash_}
</plurals>
</resources>
'''.format(key=random_key, hash_=random_hash))
)
self.assertEqual(len(stringset), 1)
self.assertEqual(stringset[0].__dict__, random_openstring.__dict__)
self.assertEqual(compiled, source)
def test_single_string_array_item_skipped(self):
random_key = generate_random_string()
random_string = generate_random_string()
random_openstring = OpenString("{}[1]".format(random_key),
random_string, order=0)
random_hash = random_openstring.template_replacement
source_template = u'''
<resources>
<string-array name="{key}">
<item />
<item>{string}</item>
</string-array>
</resources>
'''
source = source_template.format(key=random_key, string=random_string)
template, stringset = self.handler.parse(source)
compiled = self.handler.compile(template, stringset)
self.assertEqual(template, source_template.format(key=random_key,
string=random_hash))
self.assertEqual(len(stringset), 1)
self.assertEqual(stringset[0].__dict__, random_openstring.__dict__)
self.assertEqual(compiled, source)
def test_plurals(self):
random_key = generate_random_string()
random_singular = generate_random_string()
random_plural = generate_random_string()
random_openstring = OpenString(random_key,
{1: random_singular, 5: random_plural},
order=0)
random_hash = random_openstring.template_replacement
source = strip_leading_spaces(u"""
<resources>
<plurals name="{key}">
<item quantity="one">{singular}</item>
<item quantity="other">{plural}</item>
</plurals>
</resources>
""".format(key=random_key, singular=random_singular,
plural=random_plural))
template, stringset = self.handler.parse(source)
compiled = self.handler.compile(template, [random_openstring])
self.assertEqual(
template,
strip_leading_spaces(u'''
<resources>
<plurals name="{key}">
{hash_}
</plurals>
</resources>
'''.format(key=random_key, hash_=random_hash))
)
self.assertEqual(len(stringset), 1)
self.assertEqual(stringset[0].__dict__, random_openstring.__dict__)
self.assertEqual(compiled, source)
def test_string_array(self):
random_name = generate_random_string()
random_key = '{}[0]'.format(random_name)
random_string = generate_random_string()
random_openstring = OpenString(random_key, random_string, order=0)
random_hash = random_openstring.template_replacement
source_python_template = strip_leading_spaces(u'''
<resources>
<string-array name="{key}">
<item>{string}</item>
</string-array>
</resources>
''')
source = source_python_template.format(key=random_name,
string=random_string)
template, stringset = self.handler.parse(source)
compiled = self.handler.compile(template, [random_openstring])
self.assertEqual(
template,
source_python_template.format(key=random_name, string=random_hash)
)
self.assertEqual(len(stringset), 1)
self.assertEqual(stringset[0].__dict__,
random_openstring.__dict__)
self.assertEqual(compiled, source)
def test_skip_middle_of_list(self):
string1 = self.random_string
string2 = generate_random_string()
string3 = generate_random_string()
openstring1 = OpenString('..0..', string1, order=0)
openstring3 = OpenString('..2..', string3, order=2)
source = '["%s", "%s", "%s"]' % (string1, string2, string3)
template, stringset = self.handler.parse(source)
compiled = self.handler.compile(template, [openstring1, openstring3])
self.assertEqual(compiled, '["%s", "%s"]' % (string1, string3))
def test_skip_middle_of_list(self):
string1 = self.random_string
string2 = generate_random_string()
string3 = generate_random_string()
openstring1 = OpenString('..0..', string1, order=0)
openstring3 = OpenString('..2..', string3, order=2)
source = '["%s", "%s", "%s"]' % (string1, string2, string3)
template, stringset = self.handler.parse(source)
compiled = self.handler.compile(template, [openstring1, openstring3])
self.assertEqual(compiled, '["%s", "%s"]' % (string1, string3))
def test_skip_middle_of_dict(self):
string1 = self.random_string
string2 = generate_random_string()
string3 = generate_random_string()
openstring1 = OpenString('a', string1, order=0)
openstring3 = OpenString('c', string3, order=2)
source = '{"a": "%s", "b": "%s", "c": "%s"}' % (string1, string2,
string3)
template, stringset = self.handler.parse(source)
compiled = self.handler.compile(template, [openstring1, openstring3])
self.assertEqual(compiled,
'{"a": "%s", "c": "%s"}' % (string1, string3))
def test_skip_middle_of_dict(self):
string1 = self.random_string
string2 = generate_random_string()
string3 = generate_random_string()
openstring1 = OpenString('a', string1, order=0)
openstring3 = OpenString('c', string3, order=2)
source = '{"a": "%s", "b": "%s", "c": "%s"}' % (string1, string2,
string3)
template, stringset = self.handler.parse(source)
compiled = self.handler.compile(template, [openstring1, openstring3])
self.assertEqual(compiled, '{"a": "%s", "c": "%s"}' % (string1,
string3))
def test_no_translatable(self):
random_key = generate_random_string()
random_string = generate_random_string()
source = strip_leading_spaces(u'''
<resources>
<string name="{key}" translatable="false">{string}</string>
</resources>
'''.format(key=random_key, string=random_string))
template, stringset = self.handler.parse(source)
compiled = self.handler.compile(template, [])
self.assertEqual(stringset, [])
self.assertEqual(template, source)
self.assertEqual(compiled, source)
def test_no_translatable(self):
random_key = generate_random_string()
random_string = generate_random_string()
source = strip_leading_spaces(u'''
<resources>
<string name="{key}" translatable="false">{string}</string>
</resources>
'''.format(key=random_key, string=random_string))
template, stringset = self.handler.parse(source)
compiled = self.handler.compile(template, [])
self.assertEqual(stringset, [])
self.assertEqual(template, source)
self.assertEqual(compiled, source)
def setUp(self):
super(JsonTestCase, self).setUp()
self.handler = JsonHandler()
self.random_string = generate_random_string()
self.random_openstring = OpenString("a", self.random_string, order=0)
self.random_hash = self.random_openstring.template_replacement
def setUp(self):
super(JsonTestCase, self).setUp()
self.handler = JsonHandler()
self.random_string = generate_random_string()
self.random_openstring = OpenString("a", self.random_string, order=0)
self.random_hash = self.random_openstring.template_replacement
def test_compile_ignores_removed_strings_for_dicts(self):
# The original JsonHandler, when compiling back from a template,
# removes any strings that are not passed as an argument in the
# compile() function. StructuredJsonHandler on the other hand, simply
# ignores those key-values and leave them as is in the template. This
# test ensures that this is the case.
# For more information, see _copy_until_and_remove_section() in both
# handlers.
string1 = self.random_string
string2 = generate_random_string()
openstring1 = self.random_openstring
openstring2 = OpenString("b", string2, order=1)
hash1 = self.random_hash
hash2 = openstring2.template_replacement
source = ('{"a": {"string":"%s"}, "b": {"string":"%s"}}' %
(string1, string2))
template, stringset = self.handler.parse(source)
compiled = self.handler.compile(template, [openstring1])
self.assertEqual(
template,
'{"a": {"string":"%s"}, "b": {"string":"%s"}}' % (hash1, hash2))
self.assertEqual(len(stringset), 2)
self.assertEqual(stringset[0].__dict__, openstring1.__dict__)
self.assertEqual(stringset[1].__dict__, openstring2.__dict__)
self.assertEqual(
compiled,
'{"a": {"string":"%s"}, "b": {"string":"%s"}}' % (string1, hash2))
def _create_openstring(self, pluralized, extra_context=None):
context_dict = extra_context if extra_context is not None else {}
context_dict.update({
'order': next(self.order_generator),
'pluralized': pluralized
})
key = generate_random_string()
if pluralized:
key = ':'.join([key, generate_random_string()])
openstring = OpenString(key, {
0: generate_random_string(),
1: generate_random_string()
} if pluralized else generate_random_string(), **context_dict)
openstring.string_hash
return openstring
def _create_pluralized_string(self):
context_dict = {
'main_key': generate_random_string(),
'secondary_key': generate_random_string(),
'singular': generate_random_string(),
'plural': generate_random_string()
}
openstring = OpenString(context_dict['main_key'], {
1: context_dict['singular'],
5: context_dict['plural']
},
order=0,
context=context_dict['secondary_key'],
pluralized=True)
context_dict['hash'] = openstring.template_replacement
return context_dict, openstring
def test_compile_ignores_removed_strings_for_dicts(self):
# The original JsonHandler, when compiling back from a template,
# removes any strings that are not passed as an argument in the
# compile() function. StructuredJsonHandler on the other hand, simply
# ignores those key-values and leave them as is in the template. This
# test ensures that this is the case.
# For more information, see _copy_until_and_remove_section() in both
# handlers.
string1 = self.random_string
string2 = generate_random_string()
openstring1 = self.random_openstring
openstring2 = OpenString("b", string2, order=1)
hash1 = self.random_hash
hash2 = openstring2.template_replacement
source = ('{"a": {"string":"%s"}, "b": {"string":"%s"}}' %
(string1, string2))
template, stringset = self.handler.parse(source)
compiled = self.handler.compile(template, [openstring1])
self.assertEqual(template,
'{"a": {"string":"%s"}, "b": {"string":"%s"}}' %
(hash1, hash2))
self.assertEqual(len(stringset), 2)
self.assertEqual(stringset[0].__dict__, openstring1.__dict__)
self.assertEqual(stringset[1].__dict__, openstring2.__dict__)
self.assertEqual(
compiled,
'{"a": {"string":"%s"}, "b": {"string":"%s"}}' % (string1, hash2)
)
def test_missing_translated_string_arrays_removed(self):
random_key = generate_random_string()
random_string = generate_random_string()
source = strip_leading_spaces(u'''
<resources>
<string-array name="{key}">
<item>{string}</item>
</string-array>
</resources>
'''.format(key=random_key, string=random_string))
template, stringset = self.handler.parse(source)
compiled = self.handler.compile(template, [])
self.assertEqual(compiled, strip_leading_spaces(u'''
<resources>
</resources>
'''))
def setUp(self):
super(ChromeI18nTestCase, self).setUp()
self.handler = ChromeI18nHandler()
self.random_string = generate_random_string()
self.random_openstring = OpenString("a.message", "%s" %
self.random_string, order=0)
self.random_hash = self.random_openstring.template_replacement
def test_compile_plurals_not_indented(self):
random_key = generate_random_string()
random_singular = generate_random_string()
random_plural = generate_random_string()
random_openstring = OpenString(random_key,
{1: random_singular, 5: random_plural},
order=0)
source = (u'<resources><plurals name="{key}"><item quantity="one">'
'{singular}</item><item quantity="other">{plural}</item>'
'</plurals></resources>').format(key=random_key,
singular=random_singular,
plural=random_plural)
template, stringset = self.handler.parse(source)
compiled = self.handler.compile(template, [random_openstring])
self.assertEqual(stringset[0].__dict__, random_openstring.__dict__)
self.assertEqual(compiled, source)
def setUp(self):
super(ChromeI18nTestCase, self).setUp()
self.handler = ChromeI18nHandler()
self.random_string = generate_random_string()
self.random_openstring = OpenString("a.message",
"%s" % self.random_string,
order=0)
self.random_hash = self.random_openstring.template_replacement
def test_compile_plurals_not_indented(self):
random_key = generate_random_string()
random_singular = generate_random_string()
random_plural = generate_random_string()
random_openstring = OpenString(random_key,
{1: random_singular, 5: random_plural},
order=0)
source = (u'<resources><plurals name="{key}"><item quantity="one">'
'{singular}</item><item quantity="other">{plural}</item>'
'</plurals></resources>').format(key=random_key,
singular=random_singular,
plural=random_plural)
template, stringset = self.handler.parse(source)
compiled = self.handler.compile(template, [random_openstring])
self.assertEqual(stringset[0].__dict__, random_openstring.__dict__)
self.assertEqual(compiled, source)
def setUp(self):
super(StructuredJsonTestCase, self).setUp()
self.handler = StructuredJsonHandler()
self.random_string = generate_random_string()
self.pluralized_string = "{ item_count, plural, one {You have {file_count} file.} other {You have {file_count} files.} }" # noqa
self.random_openstring = OpenString("a", self.random_string, order=0)
self.random_hash = self.random_openstring.template_replacement
def _create_pluralized_string(self):
context_dict = {
'main_key': generate_random_string(),
'secondary_key': generate_random_string(),
'singular': generate_random_string(),
'plural': generate_random_string()
}
openstring = OpenString(
context_dict['main_key'],
{
1: context_dict['singular'],
5: context_dict['plural']
},
order=0,
context=context_dict['secondary_key'],
pluralized=True
)
context_dict['hash'] = openstring.template_replacement
return context_dict, openstring
def setUp(self):
super(StructuredJsonTestCase, self).setUp()
self.handler = StructuredJsonHandler()
self.random_string = generate_random_string()
self.pluralized_string = "{ item_count, plural, one {You have {file_count} file.} other {You have {file_count} files.} }" # noqa
self.random_openstring = OpenString("a",
self.random_string, order=0)
self.random_hash = self.random_openstring.template_replacement
def test_skip_start_of_list(self):
string1 = self.random_string
string2 = generate_random_string()
source = '["%s", "%s"]' % (string1, string2)
template, stringset = self.handler.parse(source)
compiled = self.handler.compile(template, [stringset[1]])
self.assertEqual(compiled, '[ "%s"]' % string2)
def test_skip_start_of_list(self):
string1 = self.random_string
string2 = generate_random_string()
openstring2 = OpenString('..1..', string2, order=1)
source = '["%s", "%s"]' % (string1, string2)
template, stringset = self.handler.parse(source)
compiled = self.handler.compile(template, [openstring2])
self.assertEqual(compiled, '[ "%s"]' % string2)
def test_skip_end_of_dict(self):
string1 = self.random_string
string2 = generate_random_string()
openstring1 = OpenString('a', string1, order=1)
source = '{"a": "%s", "b": "%s"}' % (string1, string2)
template, stringset = self.handler.parse(source)
compiled = self.handler.compile(template, [openstring1])
self.assertEqual(compiled, '{"a": "%s"}' % string1)
def _create_openstring(self, pluralized, extra_context=None):
context_dict = extra_context if extra_context is not None else {}
context_dict.update({
'order': next(self.order_generator),
'pluralized': pluralized
})
key = generate_random_string()
if pluralized:
key = ':'.join([key, generate_random_string()])
openstring = OpenString(
key,
{
0: generate_random_string(),
1: generate_random_string()
} if pluralized else generate_random_string(),
**context_dict
)
openstring.string_hash
return openstring
def test_skip_end_of_dict(self):
string1 = self.random_string
string2 = generate_random_string()
openstring1 = OpenString('a', string1, order=1)
source = '{"a": "%s", "b": "%s"}' % (string1, string2)
template, stringset = self.handler.parse(source)
compiled = self.handler.compile(template, [openstring1])
self.assertEqual(compiled, '{"a": "%s"}' % string1)
def test_skip_start_of_list(self):
string1 = self.random_string
string2 = generate_random_string()
openstring2 = OpenString('..1..', string2, order=1)
source = '["%s", "%s"]' % (string1, string2)
template, stringset = self.handler.parse(source)
compiled = self.handler.compile(template, [openstring2])
self.assertEqual(compiled, '[ "%s"]' % string2)
def test_missing_translated_plurals_removed(self):
random_key = generate_random_string()
random_singular = generate_random_string()
random_plural = generate_random_string()
source = strip_leading_spaces(u'''
<resources>
<plurals name="{key}">
<item quantity="one">{singular}</item>
<item quantity="other">{plural}</item>
</plurals>
</resources>
'''.format(key=random_key, singular=random_singular,
plural=random_plural))
template, stringset = self.handler.parse(source)
compiled = self.handler.compile(template, [])
self.assertEqual(compiled, strip_leading_spaces(u'''
<resources>
</resources>
'''.format(key=random_key, singular=random_singular,
plural=random_plural)))
def test_empty_string_ignored(self):
random_key = generate_random_string()
source = strip_leading_spaces(u'''
<resources>
<string name="{key}"></string>
</resources>
'''.format(key=random_key))
template, stringset = self.handler.parse(source)
self.assertEqual(stringset, [])
self.assertEqual(template, source)
def test_empty_string_ignored(self):
random_key = generate_random_string()
source = strip_leading_spaces(u'''
<resources>
<string name="{key}"></string>
</resources>
'''.format(key=random_key))
template, stringset = self.handler.parse(source)
self.assertEqual(stringset, [])
self.assertEqual(template, source)
def test_string(self):
random_key = generate_random_string()
random_string = generate_random_string()
random_openstring = OpenString(random_key, random_string, order=0)
random_hash = random_openstring.template_replacement
source_python_template = u'''
<resources>
<string name="{key}">{string}</string>
</resources>
'''
source = source_python_template.format(key=random_key,
string=random_string)
template, stringset = self.handler.parse(source)
compiled = self.handler.compile(template, [random_openstring])
self.assertEqual(
template,
source_python_template.format(key=random_key, string=random_hash))
self.assertEqual(len(stringset), 1)
self.assertEqual(stringset[0].__dict__, random_openstring.__dict__)
self.assertEqual(compiled, source)
def test_empty_plural_ignored(self):
random_key = generate_random_string()
source = strip_leading_spaces(u'''
<resources>
<plurals name="{key}">
<item quantity="one"></item>
<item quantity="other"></item>
</plurals>
</resources>
'''.format(key=random_key))
template, stringset = self.handler.parse(source)
self.assertEqual(stringset, [])
self.assertEqual(template, source)
def test_empty_plural_ignored(self):
random_key = generate_random_string()
source = strip_leading_spaces(u'''
<resources>
<plurals name="{key}">
<item quantity="one"></item>
<item quantity="other"></item>
</plurals>
</resources>
'''.format(key=random_key))
template, stringset = self.handler.parse(source)
self.assertEqual(stringset, [])
self.assertEqual(template, source)
def test_compile_skips_removed_strings_for_dicts(self):
string1 = self.random_string
string2 = generate_random_string()
openstring1 = self.random_openstring
openstring2 = OpenString("b", string2, order=1)
hash1 = self.random_hash
hash2 = openstring2.template_replacement
source = '{"a": "%s", "b": "%s"}' % (string1, string2)
template, stringset = self.handler.parse(source)
compiled = self.handler.compile(template, [openstring1])
self.assertEqual(template, '{"a": "%s", "b": "%s"}' % (hash1, hash2))
self.assertEqual(len(stringset), 2)
self.assertEqual(stringset[0].__dict__, openstring1.__dict__)
self.assertEqual(stringset[1].__dict__, openstring2.__dict__)
self.assertEqual(compiled, '{"a": "%s"}' % string1)
def test_compile_skips_removed_strings_for_dicts(self):
string1 = self.random_string
string2 = generate_random_string()
openstring1 = self.random_openstring
openstring2 = OpenString("b", string2, order=1)
hash1 = self.random_hash
hash2 = openstring2.template_replacement
source = '{"a": "%s", "b": "%s"}' % (string1, string2)
template, stringset = self.handler.parse(source)
compiled = self.handler.compile(template, [openstring1])
self.assertEqual(template, '{"a": "%s", "b": "%s"}' % (hash1, hash2))
self.assertEqual(len(stringset), 2)
self.assertEqual(stringset[0].__dict__, openstring1.__dict__)
self.assertEqual(stringset[1].__dict__, openstring2.__dict__)
self.assertEqual(compiled, '{"a": "%s"}' % string1)
def test_compile_skips_removed_nested_dict(self):
string1 = self.random_string
string2 = generate_random_string()
openstring1 = OpenString("..0..", string1, order=0)
openstring2 = OpenString("..1...a", string2, order=1)
hash1 = openstring1.template_replacement
hash2 = openstring2.template_replacement
source = '["%s", {"a": "%s"}]' % (string1, string2)
template, stringset = self.handler.parse(source)
compiled = self.handler.compile(template, [openstring1])
self.assertEqual(template, '["%s", {"a": "%s"}]' % (hash1, hash2))
self.assertEqual(len(stringset), 2)
self.assertEqual(stringset[0].__dict__, openstring1.__dict__)
self.assertEqual(stringset[1].__dict__, openstring2.__dict__)
self.assertEqual(compiled, '["%s"]' % string1)
def test_compile_skips_removed_nested_dict(self):
string1 = self.random_string
string2 = generate_random_string()
openstring1 = OpenString("..0..", string1, order=0)
openstring2 = OpenString("..1...a", string2, order=1)
hash1 = openstring1.template_replacement
hash2 = openstring2.template_replacement
source = '["%s", {"a": "%s"}]' % (string1, string2)
template, stringset = self.handler.parse(source)
compiled = self.handler.compile(template, [openstring1])
self.assertEqual(template, '["%s", {"a": "%s"}]' % (hash1, hash2))
self.assertEqual(len(stringset), 2)
self.assertEqual(stringset[0].__dict__, openstring1.__dict__)
self.assertEqual(stringset[1].__dict__, openstring2.__dict__)
self.assertEqual(compiled, '["%s"]' % string1)
def setUp(self):
super(ChromeI18nV3TestCase, self).setUp()
self.random_string = generate_random_string()
self.random_openstring = OpenString('a', self.random_string, order=0,
developer_comment='')
