closure_linter: 2.3.4 => 2.3.14

third_party/closure_linter/closure_linter/closurizednamespacesinfo_test.py

Index: third_party/closure_linter/closure_linter/closurizednamespacesinfo_test.py
diff --git a/third_party/closure_linter/closure_linter/closurizednamespacesinfo_test.py b/third_party/closure_linter/closure_linter/closurizednamespacesinfo_test.py
index cec3376e12dfbf15bb9e0b77a397e1ab26ed5b6a..42499419efadab27309076e59ecf98fa7cf07722 100755
--- a/third_party/closure_linter/closure_linter/closurizednamespacesinfo_test.py
+++ b/third_party/closure_linter/closure_linter/closurizednamespacesinfo_test.py
@@ -19,13 +19,15 @@
 
 
 import unittest as googletest
+from closure_linter import aliaspass
 from closure_linter import closurizednamespacesinfo
+from closure_linter import ecmametadatapass
 from closure_linter import javascriptstatetracker
-from closure_linter import javascripttokenizer
 from closure_linter import javascripttokens
+from closure_linter import testutil
 from closure_linter import tokenutil
 
-# pylint: disable-msg=C6409
+# pylint: disable=g-bad-name
 TokenType = javascripttokens.JavaScriptTokenType
 
 
@@ -56,8 +58,6 @@ class ClosurizedNamespacesInfoTest(googletest.TestCase):
       'package.className.prototype.something.somethingElse': 'package.className'
   }
 
-  _tokenizer = javascripttokenizer.JavaScriptTokenizer()
-
   def testGetClosurizedNamespace(self):
     """Tests that the correct namespace is returned for various identifiers."""
     namespaces_info = closurizednamespacesinfo.ClosurizedNamespacesInfo(
@@ -93,8 +93,9 @@ class ClosurizedNamespacesInfoTest(googletest.TestCase):
         'goog.provide(\'package.Foo\');',
         'package.Foo = function() {};'
     ]
-    token = self._tokenizer.TokenizeFile(input_lines)
-    namespaces_info = self._GetInitializedNamespacesInfo(token, ['package'], [])
+
+    token, namespaces_info = self._GetStartTokenAndNamespacesInfoForScript(
+        input_lines, ['package'])
 
     self.assertFalse(namespaces_info.IsExtraProvide(token),
                      'Should not be extra since it is created.')
@@ -105,8 +106,9 @@ class ClosurizedNamespacesInfoTest(googletest.TestCase):
         'goog.provide(\'package.Foo.methodName\');',
         'package.Foo.methodName = function() {};'
     ]
-    token = self._tokenizer.TokenizeFile(input_lines)
-    namespaces_info = self._GetInitializedNamespacesInfo(token, ['package'], [])
+
+    token, namespaces_info = self._GetStartTokenAndNamespacesInfoForScript(
+        input_lines, ['package'])
 
     self.assertFalse(namespaces_info.IsExtraProvide(token),
                      'Should not be extra since it is created.')
@@ -114,8 +116,9 @@ class ClosurizedNamespacesInfoTest(googletest.TestCase):
   def testIsExtraProvide_notCreated(self):
     """Tests that provides for non-created namespaces are extra."""
     input_lines = ['goog.provide(\'package.Foo\');']
-    token = self._tokenizer.TokenizeFile(input_lines)
-    namespaces_info = self._GetInitializedNamespacesInfo(token, ['package'], [])
+
+    token, namespaces_info = self._GetStartTokenAndNamespacesInfoForScript(
+        input_lines, ['package'])
 
     self.assertTrue(namespaces_info.IsExtraProvide(token),
                     'Should be extra since it is not created.')
@@ -127,8 +130,9 @@ class ClosurizedNamespacesInfoTest(googletest.TestCase):
         'goog.provide(\'package.Foo\');',
         'package.Foo = function() {};'
     ]
-    token = self._tokenizer.TokenizeFile(input_lines)
-    namespaces_info = self._GetInitializedNamespacesInfo(token, ['package'], [])
+
+    token, namespaces_info = self._GetStartTokenAndNamespacesInfoForScript(
+        input_lines, ['package'])
 
     # Advance to the second goog.provide token.
     token = tokenutil.Search(token.next, TokenType.IDENTIFIER)
@@ -139,8 +143,9 @@ class ClosurizedNamespacesInfoTest(googletest.TestCase):
   def testIsExtraProvide_notClosurized(self):
     """Tests that provides of non-closurized namespaces are not extra."""
     input_lines = ['goog.provide(\'notclosurized.Foo\');']
-    token = self._tokenizer.TokenizeFile(input_lines)
-    namespaces_info = self._GetInitializedNamespacesInfo(token, ['package'], [])
+
+    token, namespaces_info = self._GetStartTokenAndNamespacesInfoForScript(
+        input_lines, ['package'])
 
     self.assertFalse(namespaces_info.IsExtraProvide(token),
                      'Should not be extra since it is not closurized.')
@@ -151,8 +156,9 @@ class ClosurizedNamespacesInfoTest(googletest.TestCase):
         'goog.require(\'package.Foo\');',
         'var x = package.Foo.methodName();'
     ]
-    token = self._tokenizer.TokenizeFile(input_lines)
-    namespaces_info = self._GetInitializedNamespacesInfo(token, ['package'], [])
+
+    token, namespaces_info = self._GetStartTokenAndNamespacesInfoForScript(
+        input_lines, ['package'])
 
     self.assertFalse(namespaces_info.IsExtraRequire(token),
                      'Should not be extra since it is used.')
@@ -163,8 +169,9 @@ class ClosurizedNamespacesInfoTest(googletest.TestCase):
         'goog.require(\'package.Foo.methodName\');',
         'var x = package.Foo.methodName();'
     ]
-    token = self._tokenizer.TokenizeFile(input_lines)
-    namespaces_info = self._GetInitializedNamespacesInfo(token, ['package'], [])
+
+    token, namespaces_info = self._GetStartTokenAndNamespacesInfoForScript(
+        input_lines, ['package'])
 
     self.assertTrue(namespaces_info.IsExtraRequire(token),
                     'Should require the package, not the method specifically.')
@@ -172,8 +179,9 @@ class ClosurizedNamespacesInfoTest(googletest.TestCase):
   def testIsExtraRequire_notUsed(self):
     """Tests that requires for unused namespaces are extra."""
     input_lines = ['goog.require(\'package.Foo\');']
-    token = self._tokenizer.TokenizeFile(input_lines)
-    namespaces_info = self._GetInitializedNamespacesInfo(token, ['package'], [])
+
+    token, namespaces_info = self._GetStartTokenAndNamespacesInfoForScript(
+        input_lines, ['package'])
 
     self.assertTrue(namespaces_info.IsExtraRequire(token),
                     'Should be extra since it is not used.')
@@ -181,8 +189,9 @@ class ClosurizedNamespacesInfoTest(googletest.TestCase):
   def testIsExtraRequire_notClosurized(self):
     """Tests that requires of non-closurized namespaces are not extra."""
     input_lines = ['goog.require(\'notclosurized.Foo\');']
-    token = self._tokenizer.TokenizeFile(input_lines)
-    namespaces_info = self._GetInitializedNamespacesInfo(token, ['package'], [])
+
+    token, namespaces_info = self._GetStartTokenAndNamespacesInfoForScript(
+        input_lines, ['package'])
 
     self.assertFalse(namespaces_info.IsExtraRequire(token),
                      'Should not be extra since it is not closurized.')
@@ -193,8 +202,9 @@ class ClosurizedNamespacesInfoTest(googletest.TestCase):
         'goog.require(\'package.Foo.Enum\');',
         'var x = package.Foo.Enum.VALUE1;',
     ]
-    token = self._tokenizer.TokenizeFile(input_lines)
-    namespaces_info = self._GetInitializedNamespacesInfo(token, ['package'], [])
+
+    token, namespaces_info = self._GetStartTokenAndNamespacesInfoForScript(
+        input_lines, ['package'])
 
     self.assertTrue(namespaces_info.IsExtraRequire(token),
                     'The whole class, not the object, should be required.');
@@ -205,8 +215,9 @@ class ClosurizedNamespacesInfoTest(googletest.TestCase):
         'goog.require(\'package.Foo.CONSTANT\');',
         'var x = package.Foo.CONSTANT',
     ]
-    token = self._tokenizer.TokenizeFile(input_lines)
-    namespaces_info = self._GetInitializedNamespacesInfo(token, ['package'], [])
+
+    token, namespaces_info = self._GetStartTokenAndNamespacesInfoForScript(
+        input_lines, ['package'])
 
     self.assertTrue(namespaces_info.IsExtraRequire(token),
                     'The class, not the constant, should be required.');
@@ -217,8 +228,9 @@ class ClosurizedNamespacesInfoTest(googletest.TestCase):
         'goog.require(\'package.subpackage.CONSTANT\');',
         'var x = package.subpackage.CONSTANT',
     ]
-    token = self._tokenizer.TokenizeFile(input_lines)
-    namespaces_info = self._GetInitializedNamespacesInfo(token, ['package'], [])
+
+    token, namespaces_info = self._GetStartTokenAndNamespacesInfoForScript(
+        input_lines, ['package'])
 
     self.assertFalse(namespaces_info.IsExtraRequire(token),
                     'Constants can be required except on classes.');
@@ -229,8 +241,9 @@ class ClosurizedNamespacesInfoTest(googletest.TestCase):
         'goog.require(\'package.subpackage.method\');',
         'var x = package.subpackage.method()',
     ]
-    token = self._tokenizer.TokenizeFile(input_lines)
-    namespaces_info = self._GetInitializedNamespacesInfo(token, ['package'], [])
+
+    token, namespaces_info = self._GetStartTokenAndNamespacesInfoForScript(
+        input_lines, ['package'])
 
     self.assertFalse(namespaces_info.IsExtraRequire(token),
                     'Methods can be required except on classes.');
@@ -238,8 +251,9 @@ class ClosurizedNamespacesInfoTest(googletest.TestCase):
   def testIsExtraRequire_defaults(self):
     """Tests that there are no warnings about extra requires for test utils"""
     input_lines = ['goog.require(\'goog.testing.jsunit\');']
-    token = self._tokenizer.TokenizeFile(input_lines)
-    namespaces_info = self._GetInitializedNamespacesInfo(token, ['goog'], [])
+
+    token, namespaces_info = self._GetStartTokenAndNamespacesInfoForScript(
+        input_lines, ['goog'])
 
     self.assertFalse(namespaces_info.IsExtraRequire(token),
                      'Should not be extra since it is for testing.')
@@ -250,8 +264,9 @@ class ClosurizedNamespacesInfoTest(googletest.TestCase):
         'goog.provide(\'package.Foo\');',
         'package.Foo = function() {};'
     ]
-    token = self._tokenizer.TokenizeFile(input_lines)
-    namespaces_info = self._GetInitializedNamespacesInfo(token, ['package'], [])
+
+    namespaces_info = self._GetNamespacesInfoForScript(
+        input_lines, ['package'])
 
     self.assertEquals(0, len(namespaces_info.GetMissingProvides()))
 
@@ -261,9 +276,8 @@ class ClosurizedNamespacesInfoTest(googletest.TestCase):
         'goog.provide(\'package.Foo.methodName\');',
         'package.Foo.methodName = function() {};'
     ]
-    token = self._tokenizer.TokenizeFile(input_lines)
-    namespaces_info = self._GetInitializedNamespacesInfo(token, ['package'], [])
 
+    namespaces_info = self._GetNamespacesInfoForScript(input_lines, ['package'])
     self.assertEquals(0, len(namespaces_info.GetMissingProvides()))
 
   def testGetMissingProvides_providedParentIdentifier(self):
@@ -274,26 +288,27 @@ class ClosurizedNamespacesInfoTest(googletest.TestCase):
         'package.foo.ClassName.methodName = function() {};',
         'package.foo.ClassName.ObjectName = 1;',
     ]
-    token = self._tokenizer.TokenizeFile(input_lines)
-    namespaces_info = self._GetInitializedNamespacesInfo(token, ['package'], [])
 
+    namespaces_info = self._GetNamespacesInfoForScript(input_lines, ['package'])
     self.assertEquals(0, len(namespaces_info.GetMissingProvides()))
 
   def testGetMissingProvides_unprovided(self):
     """Tests that unprovided functions cause a missing provide."""
     input_lines = ['package.Foo = function() {};']
-    token = self._tokenizer.TokenizeFile(input_lines)
-    namespaces_info = self._GetInitializedNamespacesInfo(token, ['package'], [])
 
-    self.assertEquals(1, len(namespaces_info.GetMissingProvides()))
-    self.assertTrue('package.Foo' in namespaces_info.GetMissingProvides())
+    namespaces_info = self._GetNamespacesInfoForScript(input_lines, ['package'])
+
+    missing_provides = namespaces_info.GetMissingProvides()
+    self.assertEquals(1, len(missing_provides))
+    missing_provide = missing_provides.popitem()
+    self.assertEquals('package.Foo', missing_provide[0])
+    self.assertEquals(1, missing_provide[1])
 
   def testGetMissingProvides_privatefunction(self):
     """Tests that unprovided private functions don't cause a missing provide."""
     input_lines = ['package.Foo_ = function() {};']
-    token = self._tokenizer.TokenizeFile(input_lines)
-    namespaces_info = self._GetInitializedNamespacesInfo(token, ['package'], [])
 
+    namespaces_info = self._GetNamespacesInfoForScript(input_lines, ['package'])
     self.assertEquals(0, len(namespaces_info.GetMissingProvides()))
 
   def testGetMissingProvides_required(self):
@@ -302,9 +317,8 @@ class ClosurizedNamespacesInfoTest(googletest.TestCase):
         'goog.require(\'package.Foo\');',
         'package.Foo.methodName = function() {};'
     ]
-    token = self._tokenizer.TokenizeFile(input_lines)
-    namespaces_info = self._GetInitializedNamespacesInfo(token, ['package'], [])
 
+    namespaces_info = self._GetNamespacesInfoForScript(input_lines, ['package'])
     self.assertEquals(0, len(namespaces_info.GetMissingProvides()))
 
   def testGetMissingRequires_required(self):
@@ -313,9 +327,8 @@ class ClosurizedNamespacesInfoTest(googletest.TestCase):
         'goog.require(\'package.Foo\');',
         'package.Foo();'
     ]
-    token = self._tokenizer.TokenizeFile(input_lines)
-    namespaces_info = self._GetInitializedNamespacesInfo(token, ['package'], [])
 
+    namespaces_info = self._GetNamespacesInfoForScript(input_lines, ['package'])
     self.assertEquals(0, len(namespaces_info.GetMissingProvides()))
 
   def testGetMissingRequires_requiredIdentifier(self):
@@ -324,9 +337,8 @@ class ClosurizedNamespacesInfoTest(googletest.TestCase):
         'goog.require(\'package.Foo\');',
         'package.Foo.methodName();'
     ]
-    token = self._tokenizer.TokenizeFile(input_lines)
-    namespaces_info = self._GetInitializedNamespacesInfo(token, ['package'], [])
 
+    namespaces_info = self._GetNamespacesInfoForScript(input_lines, ['package'])
     self.assertEquals(0, len(namespaces_info.GetMissingProvides()))
 
   def testGetMissingRequires_requiredParentClass(self):
@@ -337,19 +349,21 @@ class ClosurizedNamespacesInfoTest(googletest.TestCase):
         'package.Foo.methodName();',
         'package.Foo.methodName(package.Foo.ObjectName);'
     ]
-    token = self._tokenizer.TokenizeFile(input_lines)
-    namespaces_info = self._GetInitializedNamespacesInfo(token, ['package'], [])
 
+    namespaces_info = self._GetNamespacesInfoForScript(input_lines, ['package'])
     self.assertEquals(0, len(namespaces_info.GetMissingRequires()))
 
   def testGetMissingRequires_unrequired(self):
     """Tests that unrequired namespaces cause a missing require."""
     input_lines = ['package.Foo();']
-    token = self._tokenizer.TokenizeFile(input_lines)
-    namespaces_info = self._GetInitializedNamespacesInfo(token, ['package'], [])
 
-    self.assertEquals(1, len(namespaces_info.GetMissingRequires()))
-    self.assertTrue('package.Foo' in namespaces_info.GetMissingRequires())
+    namespaces_info = self._GetNamespacesInfoForScript(input_lines, ['package'])
+
+    missing_requires = namespaces_info.GetMissingRequires()
+    self.assertEquals(1, len(missing_requires))
+    missing_req = missing_requires.popitem()
+    self.assertEquals('package.Foo', missing_req[0])
+    self.assertEquals(1, missing_req[1])
 
   def testGetMissingRequires_provided(self):
     """Tests that provided namespaces satisfy identifiers on that namespace."""
@@ -357,22 +371,27 @@ class ClosurizedNamespacesInfoTest(googletest.TestCase):
         'goog.provide(\'package.Foo\');',
         'package.Foo.methodName();'
     ]
-    token = self._tokenizer.TokenizeFile(input_lines)
-    namespaces_info = self._GetInitializedNamespacesInfo(token, ['package'], [])
 
+    namespaces_info = self._GetNamespacesInfoForScript(input_lines, ['package'])
     self.assertEquals(0, len(namespaces_info.GetMissingRequires()))
 
   def testGetMissingRequires_created(self):
     """Tests that created namespaces do not satisfy usage of an identifier."""
     input_lines = [
         'package.Foo = function();',
-        'package.Foo.methodName();'
+        'package.Foo.methodName();',
+        'package.Foo.anotherMethodName1();',
+        'package.Foo.anotherMethodName2();'
     ]
-    token = self._tokenizer.TokenizeFile(input_lines)
-    namespaces_info = self._GetInitializedNamespacesInfo(token, ['package'], [])
 
-    self.assertEquals(1, len(namespaces_info.GetMissingRequires()))
-    self.assertTrue('package.Foo' in namespaces_info.GetMissingRequires())
+    namespaces_info = self._GetNamespacesInfoForScript(input_lines, ['package'])
+
+    missing_requires = namespaces_info.GetMissingRequires()
+    self.assertEquals(1, len(missing_requires))
+    missing_require = missing_requires.popitem()
+    self.assertEquals('package.Foo', missing_require[0])
+    # Make sure line number of first occurrence is reported
+    self.assertEquals(2, missing_require[1])
 
   def testGetMissingRequires_createdIdentifier(self):
     """Tests that created identifiers satisfy usage of the identifier."""
@@ -380,9 +399,8 @@ class ClosurizedNamespacesInfoTest(googletest.TestCase):
         'package.Foo.methodName = function();',
         'package.Foo.methodName();'
     ]
-    token = self._tokenizer.TokenizeFile(input_lines)
-    namespaces_info = self._GetInitializedNamespacesInfo(token, ['package'], [])
 
+    namespaces_info = self._GetNamespacesInfoForScript(input_lines, ['package'])
     self.assertEquals(0, len(namespaces_info.GetMissingRequires()))
 
   def testGetMissingRequires_objectOnClass(self):
@@ -391,11 +409,49 @@ class ClosurizedNamespacesInfoTest(googletest.TestCase):
         'goog.require(\'package.Foo.Enum\');',
         'var x = package.Foo.Enum.VALUE1;',
     ]
-    token = self._tokenizer.TokenizeFile(input_lines)
-    namespaces_info = self._GetInitializedNamespacesInfo(token, ['package'], [])
 
+    namespaces_info = self._GetNamespacesInfoForScript(input_lines, ['package'])
     self.assertEquals(1, len(namespaces_info.GetMissingRequires()),
-                    'The whole class, not the object, should be required.');
+                      'The whole class, not the object, should be required.')
+
+  def testGetMissingRequires_variableWithSameName(self):
+    """Tests that we should not goog.require variables and parameters.
+
+    b/5362203 Variables in scope are not missing namespaces.
+    """
+    input_lines = [
+        'goog.provide(\'Foo\');',
+        'Foo.A = function();',
+        'Foo.A.prototype.method = function(ab) {',
+        '  if (ab) {',
+        '    var docs;',
+        '    var lvalue = new Obj();',
+        '    // Variable in scope hence not goog.require here.',
+        '    docs.foo.abc = 1;',
+        '    lvalue.next();',
+        '  }',
+        '  // Since js is function scope this should also not goog.require.',
+        '  docs.foo.func();',
+        '  // Its not a variable in scope hence goog.require.',
+        '  dummy.xyz.reset();',
+        ' return this.method2();',
+        '};',
+        'Foo.A.prototype.method1 = function(docs, abcd, xyz) {',
+        '  // Parameter hence not goog.require.',
+        '  docs.nodes.length = 2;',
+        '  lvalue.abc.reset();',
+        '};'
+    ]
+
+    namespaces_info = self._GetNamespacesInfoForScript(input_lines, ['Foo',
+                                                                     'docs',
+                                                                     'lvalue',
+                                                                     'dummy'])
+    missing_requires = namespaces_info.GetMissingRequires()
+    self.assertEquals(2, len(missing_requires))
+    self.assertItemsEqual(
+        {'dummy.xyz': 14,
+         'lvalue.abc': 20}, missing_requires)
 
   def testIsFirstProvide(self):
     """Tests operation of the isFirstProvide method."""
@@ -403,9 +459,9 @@ class ClosurizedNamespacesInfoTest(googletest.TestCase):
         'goog.provide(\'package.Foo\');',
         'package.Foo.methodName();'
     ]
-    token = self._tokenizer.TokenizeFile(input_lines)
-    namespaces_info = self._GetInitializedNamespacesInfo(token, ['package'], [])
 
+    token, namespaces_info = self._GetStartTokenAndNamespacesInfoForScript(
+        input_lines, ['package'])
     self.assertTrue(namespaces_info.IsFirstProvide(token))
 
   def testGetWholeIdentifierString(self):
@@ -415,13 +471,100 @@ class ClosurizedNamespacesInfoTest(googletest.TestCase):
         '    veryLong.',
         '    identifier;'
     ]
-    token = self._tokenizer.TokenizeFile(input_lines)
-    namespaces_info = closurizednamespacesinfo.ClosurizedNamespacesInfo([], [])
+
+    token = testutil.TokenizeSource(input_lines)
 
     self.assertEquals('package.Foo.veryLong.identifier',
-                      namespaces_info._GetWholeIdentifierString(token))
+                      tokenutil.GetIdentifierForToken(token))
+
     self.assertEquals(None,
-                      namespaces_info._GetWholeIdentifierString(token.next))
+                      tokenutil.GetIdentifierForToken(token.next))
+
+  def testScopified(self):
+    """Tests that a goog.scope call is noticed."""
+    input_lines = [
+        'goog.scope(function() {',
+        '});'
+        ]
+
+    namespaces_info = self._GetNamespacesInfoForScript(input_lines, ['goog'])
+    self.assertTrue(namespaces_info._scopified_file)
+
+  def testScope_unusedAlias(self):
+    """Tests that an used alias symbol doesn't result in a require."""
+    input_lines = [
+        'goog.scope(function() {',
+        'var Event = goog.events.Event;',
+        '});'
+        ]
+
+    namespaces_info = self._GetNamespacesInfoForScript(input_lines, ['goog'])
+    missing_requires = namespaces_info.GetMissingRequires()
+    self.assertEquals({}, missing_requires)
+
+  def testScope_usedAlias(self):
+    """Tests that aliased symbols result in correct requires."""
+    input_lines = [
+        'goog.scope(function() {',
+        'var Event = goog.events.Event;',
+        'var dom = goog.dom;',
+        'Event(dom.classes.get);',
+        '});'
+        ]
+
+    namespaces_info = self._GetNamespacesInfoForScript(input_lines, ['goog'])
+    missing_requires = namespaces_info.GetMissingRequires()
+    self.assertEquals({'goog.dom.classes': 4, 'goog.events.Event': 4},
+                      missing_requires)
+
+  def testScope_provides(self):
+    """Tests that aliased symbols result in correct provides."""
+    input_lines = [
+        'goog.scope(function() {',
+        'goog.bar = {};',
+        'var bar = goog.bar;',
+        'bar.Foo = {};',
+        '});'
+        ]
+
+    namespaces_info = self._GetNamespacesInfoForScript(input_lines, ['goog'])
+    missing_provides = namespaces_info.GetMissingProvides()
+    self.assertEquals({'goog.bar.Foo': 4}, missing_provides)
+
+  def testSetTestOnlyNamespaces(self):
+    """Tests that a namespace in setTestOnly makes it a valid provide."""
+    namespaces_info = self._GetNamespacesInfoForScript([
+        'goog.setTestOnly(\'goog.foo.barTest\');'
+        ], ['goog'])
+
+    token = self._GetProvideTokens('goog.foo.barTest')
+    self.assertFalse(namespaces_info.IsExtraProvide(token))
+
+    token = self._GetProvideTokens('goog.foo.bazTest')
+    self.assertTrue(namespaces_info.IsExtraProvide(token))
+
+  def testSetTestOnlyComment(self):
+    """Ensure a comment in setTestOnly does not cause a created namespace."""
+    namespaces_info = self._GetNamespacesInfoForScript([
+        'goog.setTestOnly(\'this is a comment\');'
+        ], ['goog'])
+
+    self.assertEquals(
+        [], namespaces_info._created_namespaces,
+        'A comment in setTestOnly should not modify created namespaces.')
+
+  def _GetNamespacesInfoForScript(self, script, closurized_namespaces=None):
+    _, namespaces_info = self._GetStartTokenAndNamespacesInfoForScript(
+        script, closurized_namespaces)
+
+    return namespaces_info
+
+  def _GetStartTokenAndNamespacesInfoForScript(
+      self, script, closurized_namespaces):
+
+    token = testutil.TokenizeSource(script)
+    return token, self._GetInitializedNamespacesInfo(
+        token, closurized_namespaces, [])
 
   def _GetInitializedNamespacesInfo(self, token, closurized_namespaces,
                                     ignored_extra_namespaces):
@@ -431,8 +574,16 @@ class ClosurizedNamespacesInfoTest(googletest.TestCase):
         ignored_extra_namespaces=ignored_extra_namespaces)
     state_tracker = javascriptstatetracker.JavaScriptStateTracker()
 
+    ecma_pass = ecmametadatapass.EcmaMetaDataPass()
+    ecma_pass.Process(token)
+
+    alias_pass = aliaspass.AliasPass(closurized_namespaces)
+    alias_pass.Process(token)
+
     while token:
+      state_tracker.HandleToken(token, state_tracker.GetLastNonSpaceToken())
       namespaces_info.ProcessToken(token, state_tracker)
+      state_tracker.HandleAfterToken(token)
       token = token.next
 
     return namespaces_info
@@ -440,12 +591,12 @@ class ClosurizedNamespacesInfoTest(googletest.TestCase):
   def _GetProvideTokens(self, namespace):
     """Returns a list of tokens for a goog.require of the given namespace."""
     line_text = 'goog.require(\'' + namespace + '\');\n'
-    return javascripttokenizer.JavaScriptTokenizer().TokenizeFile([line_text])
+    return testutil.TokenizeSource([line_text])
 
   def _GetRequireTokens(self, namespace):
     """Returns a list of tokens for a goog.require of the given namespace."""
     line_text = 'goog.require(\'' + namespace + '\');\n'
-    return javascripttokenizer.JavaScriptTokenizer().TokenizeFile([line_text])
+    return testutil.TokenizeSource([line_text])
 
 if __name__ == '__main__':
   googletest.main()