| OLD | NEW |
|---|
| (Empty) |
| 1 #!/usr/bin/env python | |
| 2 # Copyright (c) 2012 The Chromium Authors. All rights reserved. | |
| 3 # Use of this source code is governed by a BSD-style license that can be | |
| 4 # found in the LICENSE file. | |
| 5 | |
| 6 '''Unit tests for base.Node functionality (as used in various subclasses)''' | |
| 7 | |
| 8 | |
| 9 import os | |
| 10 import sys | |
| 11 if __name__ == '__main__': | |
| 12 sys.path.append(os.path.join(os.path.dirname(__file__), '../..')) | |
| 13 | |
| 14 import StringIO | |
| 15 import unittest | |
| 16 | |
| 17 from grit import grd_reader | |
| 18 from grit import util | |
| 19 from grit.node import base | |
| 20 from grit.node import message | |
| 21 | |
| 22 | |
| 23 def MakePlaceholder(phname='BINGO'): | |
| 24 ph = message.PhNode() | |
| 25 ph.StartParsing(u'ph', None) | |
| 26 ph.HandleAttribute(u'name', phname) | |
| 27 ph.AppendContent(u'bongo') | |
| 28 ph.EndParsing() | |
| 29 return ph | |
| 30 | |
| 31 | |
| 32 class NodeUnittest(unittest.TestCase): | |
| 33 def testWhitespaceHandling(self): | |
| 34 # We test using the Message node type. | |
| 35 node = message.MessageNode() | |
| 36 node.StartParsing(u'hello', None) | |
| 37 node.HandleAttribute(u'name', u'bla') | |
| 38 node.AppendContent(u" ''' two spaces ") | |
| 39 node.EndParsing() | |
| 40 self.failUnless(node.GetCdata() == u' two spaces') | |
| 41 | |
| 42 node = message.MessageNode() | |
| 43 node.StartParsing(u'message', None) | |
| 44 node.HandleAttribute(u'name', u'bla') | |
| 45 node.AppendContent(u" two spaces ''' ") | |
| 46 node.EndParsing() | |
| 47 self.failUnless(node.GetCdata() == u'two spaces ') | |
| 48 | |
| 49 def testWhitespaceHandlingWithChildren(self): | |
| 50 # We test using the Message node type. | |
| 51 node = message.MessageNode() | |
| 52 node.StartParsing(u'message', None) | |
| 53 node.HandleAttribute(u'name', u'bla') | |
| 54 node.AppendContent(u" ''' two spaces ") | |
| 55 node.AddChild(MakePlaceholder()) | |
| 56 node.AppendContent(u' space before and after ') | |
| 57 node.AddChild(MakePlaceholder('BONGO')) | |
| 58 node.AppendContent(u" space before two after '''") | |
| 59 node.EndParsing() | |
| 60 self.failUnless(node.mixed_content[0] == u' two spaces ') | |
| 61 self.failUnless(node.mixed_content[2] == u' space before and after ') | |
| 62 self.failUnless(node.mixed_content[-1] == u' space before two after ') | |
| 63 | |
| 64 def testXmlFormatMixedContent(self): | |
| 65 # Again test using the Message node type, because it is the only mixed | |
| 66 # content node. | |
| 67 node = message.MessageNode() | |
| 68 node.StartParsing(u'message', None) | |
| 69 node.HandleAttribute(u'name', u'name') | |
| 70 node.AppendContent(u'Hello <young> ') | |
| 71 | |
| 72 ph = message.PhNode() | |
| 73 ph.StartParsing(u'ph', None) | |
| 74 ph.HandleAttribute(u'name', u'USERNAME') | |
| 75 ph.AppendContent(u'$1') | |
| 76 ex = message.ExNode() | |
| 77 ex.StartParsing(u'ex', None) | |
| 78 ex.AppendContent(u'Joi') | |
| 79 ex.EndParsing() | |
| 80 ph.AddChild(ex) | |
| 81 ph.EndParsing() | |
| 82 | |
| 83 node.AddChild(ph) | |
| 84 node.EndParsing() | |
| 85 | |
| 86 non_indented_xml = node.FormatXml() | |
| 87 self.failUnless(non_indented_xml == u'<message name="name">\n Hello ' | |
| 88 u'<young> <ph name="USERNAME">$1<ex>Joi</ex></ph>' | |
| 89 u'\n</message>') | |
| 90 | |
| 91 indented_xml = node.FormatXml(u' ') | |
| 92 self.failUnless(indented_xml == u' <message name="name">\n Hello ' | |
| 93 u'<young> <ph name="USERNAME">$1<ex>Joi</ex></ph>' | |
| 94 u'\n </message>') | |
| 95 | |
| 96 def testXmlFormatMixedContentWithLeadingWhitespace(self): | |
| 97 # Again test using the Message node type, because it is the only mixed | |
| 98 # content node. | |
| 99 node = message.MessageNode() | |
| 100 node.StartParsing(u'message', None) | |
| 101 node.HandleAttribute(u'name', u'name') | |
| 102 node.AppendContent(u"''' Hello <young> ") | |
| 103 | |
| 104 ph = message.PhNode() | |
| 105 ph.StartParsing(u'ph', None) | |
| 106 ph.HandleAttribute(u'name', u'USERNAME') | |
| 107 ph.AppendContent(u'$1') | |
| 108 ex = message.ExNode() | |
| 109 ex.StartParsing(u'ex', None) | |
| 110 ex.AppendContent(u'Joi') | |
| 111 ex.EndParsing() | |
| 112 ph.AddChild(ex) | |
| 113 ph.EndParsing() | |
| 114 | |
| 115 node.AddChild(ph) | |
| 116 node.AppendContent(u" yessiree '''") | |
| 117 node.EndParsing() | |
| 118 | |
| 119 non_indented_xml = node.FormatXml() | |
| 120 self.failUnless(non_indented_xml == | |
| 121 u"<message name=\"name\">\n ''' Hello" | |
| 122 u' <young> <ph name="USERNAME">$1<ex>Joi</ex></ph>' | |
| 123 u" yessiree '''\n</message>") | |
| 124 | |
| 125 indented_xml = node.FormatXml(u' ') | |
| 126 self.failUnless(indented_xml == | |
| 127 u" <message name=\"name\">\n ''' Hello" | |
| 128 u' <young> <ph name="USERNAME">$1<ex>Joi</ex></ph>' | |
| 129 u" yessiree '''\n </message>") | |
| 130 | |
| 131 self.failUnless(node.GetNodeById('name')) | |
| 132 | |
| 133 def testXmlFormatContentWithEntities(self): | |
| 134 '''Tests a bug where would not be escaped correctly.''' | |
| 135 from grit import tclib | |
| 136 msg_node = message.MessageNode.Construct(None, tclib.Message( | |
| 137 text = 'BEGIN_BOLDHelloWHITESPACEthere!END_BOLD Bingo!', | |
| 138 placeholders = [ | |
| 139 tclib.Placeholder('BEGIN_BOLD', '<b>', 'bla'), | |
| 140 tclib.Placeholder('WHITESPACE', ' ', 'bla'), | |
| 141 tclib.Placeholder('END_BOLD', '</b>', 'bla')]), | |
| 142 'BINGOBONGO') | |
| 143 xml = msg_node.FormatXml() | |
| 144 self.failUnless(xml.find(' ') == -1, 'should have no entities') | |
| 145 | |
| 146 def testIter(self): | |
| 147 # First build a little tree of message and ph nodes. | |
| 148 node = message.MessageNode() | |
| 149 node.StartParsing(u'message', None) | |
| 150 node.HandleAttribute(u'name', u'bla') | |
| 151 node.AppendContent(u" ''' two spaces ") | |
| 152 node.AppendContent(u' space before and after ') | |
| 153 ph = message.PhNode() | |
| 154 ph.StartParsing(u'ph', None) | |
| 155 ph.AddChild(message.ExNode()) | |
| 156 ph.HandleAttribute(u'name', u'BINGO') | |
| 157 ph.AppendContent(u'bongo') | |
| 158 node.AddChild(ph) | |
| 159 node.AddChild(message.PhNode()) | |
| 160 node.AppendContent(u" space before two after '''") | |
| 161 | |
| 162 order = [message.MessageNode, message.PhNode, message.ExNode, message.PhNode
] | |
| 163 for n in node: | |
| 164 self.failUnless(type(n) == order[0]) | |
| 165 order = order[1:] | |
| 166 self.failUnless(len(order) == 0) | |
| 167 | |
| 168 def testGetChildrenOfType(self): | |
| 169 xml = '''<?xml version="1.0" encoding="UTF-8"?> | |
| 170 <grit latest_public_release="2" source_lang_id="en-US" | |
| 171 current_release="3" base_dir="."> | |
| 172 <outputs> | |
| 173 <output filename="resource.h" type="rc_header" /> | |
| 174 <output filename="en/generated_resources.rc" type="rc_all" | |
| 175 lang="en" /> | |
| 176 <if expr="pp_if('NOT_TRUE')"> | |
| 177 <output filename="de/generated_resources.rc" type="rc_all" | |
| 178 lang="de" /> | |
| 179 </if> | |
| 180 </outputs> | |
| 181 <release seq="3"> | |
| 182 <messages> | |
| 183 <message name="ID_HELLO">Hello!</message> | |
| 184 </messages> | |
| 185 </release> | |
| 186 </grit>''' | |
| 187 grd = grd_reader.Parse(StringIO.StringIO(xml), | |
| 188 util.PathFromRoot('grit/test/data')) | |
| 189 from grit.node import io | |
| 190 output_nodes = grd.GetChildrenOfType(io.OutputNode) | |
| 191 self.failUnlessEqual(len(output_nodes), 3) | |
| 192 self.failUnlessEqual(output_nodes[2].attrs['filename'], | |
| 193 'de/generated_resources.rc') | |
| 194 | |
| 195 def testEvaluateExpression(self): | |
| 196 def AssertExpr(expected_value, expr, defs, target_platform, | |
| 197 extra_variables): | |
| 198 self.failUnlessEqual(expected_value, base.Node.EvaluateExpression( | |
| 199 expr, defs, target_platform, extra_variables)) | |
| 200 | |
| 201 AssertExpr(True, "True", {}, 'linux', {}) | |
| 202 AssertExpr(False, "False", {}, 'linux', {}) | |
| 203 AssertExpr(True, "True or False", {}, 'linux', {}) | |
| 204 AssertExpr(False, "True and False", {}, 'linux', {}) | |
| 205 AssertExpr(True, "os == 'linux'", {}, 'linux', {}) | |
| 206 AssertExpr(False, "os == 'linux'", {}, 'ios', {}) | |
| 207 AssertExpr(True, "'foo' in defs", {'foo': 'bar'}, 'ios', {}) | |
| 208 AssertExpr(False, "'foo' in defs", {'baz': 'bar'}, 'ios', {}) | |
| 209 AssertExpr(False, "'foo' in defs", {}, 'ios', {}) | |
| 210 AssertExpr(True, "is_linux", {}, 'linux2', {}) | |
| 211 AssertExpr(False, "is_linux", {}, 'win32', {}) | |
| 212 AssertExpr(True, "is_macosx", {}, 'darwin', {}) | |
| 213 AssertExpr(False, "is_macosx", {}, 'ios', {}) | |
| 214 AssertExpr(True, "is_win", {}, 'win32', {}) | |
| 215 AssertExpr(False, "is_win", {}, 'darwin', {}) | |
| 216 AssertExpr(True, "is_android", {}, 'android', {}) | |
| 217 AssertExpr(False, "is_android", {}, 'linux3', {}) | |
| 218 AssertExpr(True, "is_ios", {}, 'ios', {}) | |
| 219 AssertExpr(False, "is_ios", {}, 'darwin', {}) | |
| 220 AssertExpr(True, "is_posix", {}, 'linux2', {}) | |
| 221 AssertExpr(True, "is_posix", {}, 'darwin', {}) | |
| 222 AssertExpr(True, "is_posix", {}, 'android', {}) | |
| 223 AssertExpr(True, "is_posix", {}, 'ios', {}) | |
| 224 AssertExpr(True, "is_posix", {}, 'freebsd7', {}) | |
| 225 AssertExpr(False, "is_posix", {}, 'win32', {}) | |
| 226 AssertExpr(True, "pp_ifdef('foo')", {'foo': True}, 'win32', {}) | |
| 227 AssertExpr(True, "pp_ifdef('foo')", {'foo': False}, 'win32', {}) | |
| 228 AssertExpr(False, "pp_ifdef('foo')", {'bar': True}, 'win32', {}) | |
| 229 AssertExpr(True, "pp_if('foo')", {'foo': True}, 'win32', {}) | |
| 230 AssertExpr(False, "pp_if('foo')", {'foo': False}, 'win32', {}) | |
| 231 AssertExpr(False, "pp_if('foo')", {'bar': True}, 'win32', {}) | |
| 232 AssertExpr(True, "foo", {'foo': True}, 'win32', {}) | |
| 233 AssertExpr(False, "foo", {'foo': False}, 'win32', {}) | |
| 234 AssertExpr(False, "foo", {'bar': True}, 'win32', {}) | |
| 235 AssertExpr(True, "foo == 'baz'", {'foo': 'baz'}, 'win32', {}) | |
| 236 AssertExpr(False, "foo == 'baz'", {'foo': True}, 'win32', {}) | |
| 237 AssertExpr(False, "foo == 'baz'", {}, 'win32', {}) | |
| 238 AssertExpr(True, "lang == 'de'", {}, 'win32', {'lang': 'de'}) | |
| 239 AssertExpr(False, "lang == 'de'", {}, 'win32', {'lang': 'fr'}) | |
| 240 AssertExpr(False, "lang == 'de'", {}, 'win32', {}) | |
| 241 | |
| 242 # Test a couple more complex expressions for good measure. | |
| 243 AssertExpr(True, "is_ios and (lang in ['de', 'fr'] or foo)", | |
| 244 {'foo': 'bar'}, 'ios', {'lang': 'fr', 'context': 'today'}) | |
| 245 AssertExpr(False, "is_ios and (lang in ['de', 'fr'] or foo)", | |
| 246 {'foo': False}, 'linux2', {'lang': 'fr', 'context': 'today'}) | |
| 247 AssertExpr(False, "is_ios and (lang in ['de', 'fr'] or foo)", | |
| 248 {'baz': 'bar'}, 'ios', {'lang': 'he', 'context': 'today'}) | |
| 249 AssertExpr(True, "foo == 'bar' or not baz", | |
| 250 {'foo': 'bar', 'fun': True}, 'ios', {'lang': 'en'}) | |
| 251 AssertExpr(True, "foo == 'bar' or not baz", | |
| 252 {}, 'ios', {'lang': 'en', 'context': 'java'}) | |
| 253 AssertExpr(False, "foo == 'bar' or not baz", | |
| 254 {'foo': 'ruz', 'baz': True}, 'ios', {'lang': 'en'}) | |
| 255 | |
| 256 if __name__ == '__main__': | |
| 257 unittest.main() | |
| 258 | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1442863002:
Remove contents of grit's SVN repository. (Closed)
Base URL: http://grit-i18n.googlecode.com/svn/trunk/