def testGetIdentifierStart(self):
tokens = testutil.TokenizeSource("""
start1 . // comment
prototype. /* another comment */
end1
['edge'][case].prototype.
end2 = function() {}
""")
def _GetTokenStartingWith(token_starts_with):
for t in tokens:
if t.string.startswith(token_starts_with):
return t
self.assertEquals(
'start1',
tokenutil.GetIdentifierStart(_GetTokenStartingWith('end1')).string)
self.assertEquals(
'start1',
tokenutil.GetIdentifierStart(_GetTokenStartingWith('start1')).string)
self.assertEquals(
None,
tokenutil.GetIdentifierStart(_GetTokenStartingWith('end2')))
def testGetMissingProvides_privatefunction(self):
"""Tests that unprovided private functions don't cause a missing provide."""
input_lines = ['package.Foo_ = function() {};']
token = testutil.TokenizeSource(input_lines)
namespaces_info = self._GetInitializedNamespacesInfo(
token, ['package'], [])
self.assertEquals(0, len(namespaces_info.GetMissingProvides()))
def testGetMissingRequires_required(self):
"""Tests that required namespaces don't cause a missing require."""
input_lines = ['goog.require(\'package.Foo\');', 'package.Foo();']
token = testutil.TokenizeSource(input_lines)
namespaces_info = self._GetInitializedNamespacesInfo(
token, ['package'], [])
self.assertEquals(0, len(namespaces_info.GetMissingProvides()))
def testIsExtraRequire_notClosurized(self):
"""Tests that requires of non-closurized namespaces are not extra."""
input_lines = ['goog.require(\'notclosurized.Foo\');']
token = testutil.TokenizeSource(input_lines)
namespaces_info = self._GetInitializedNamespacesInfo(
token, ['package'], [])
self.assertFalse(namespaces_info.IsExtraRequire(token),
'Should not be extra since it is not closurized.')
def testGetMissingProvides_unprovided(self):
"""Tests that unprovided functions cause a missing provide."""
input_lines = ['package.Foo = function() {};']
token = testutil.TokenizeSource(input_lines)
namespaces_info = self._GetInitializedNamespacesInfo(
token, ['package'], [])
self.assertEquals(1, len(namespaces_info.GetMissingProvides()))
self.assertTrue('package.Foo' in namespaces_info.GetMissingProvides())
def testIsExtraProvide_notCreated(self):
"""Tests that provides for non-created namespaces are extra."""
input_lines = ['goog.provide(\'package.Foo\');']
token = testutil.TokenizeSource(input_lines)
namespaces_info = self._GetInitializedNamespacesInfo(
token, ['package'], [])
self.assertTrue(namespaces_info.IsExtraProvide(token),
'Should be extra since it is not created.')
def testGetMissingRequires_unrequired(self):
"""Tests that unrequired namespaces cause a missing require."""
input_lines = ['package.Foo();']
token = testutil.TokenizeSource(input_lines)
namespaces_info = self._GetInitializedNamespacesInfo(
token, ['package'], [])
self.assertEquals(1, len(namespaces_info.GetMissingRequires()))
self.assertTrue('package.Foo' in namespaces_info.GetMissingRequires())
def testIsExtraRequire_notUsed(self):
"""Tests that requires for unused namespaces are extra."""
input_lines = ['goog.require(\'package.Foo\');']
token = testutil.TokenizeSource(input_lines)
namespaces_info = self._GetInitializedNamespacesInfo(
token, ['package'], [])
self.assertTrue(namespaces_info.IsExtraRequire(token),
'Should be extra since it is not used.')
def testIsExtraRequire_defaults(self):
"""Tests that there are no warnings about extra requires for test utils"""
input_lines = ['goog.require(\'goog.testing.jsunit\');']
token = testutil.TokenizeSource(input_lines)
namespaces_info = self._GetInitializedNamespacesInfo(
token, ['goog'], [])
self.assertFalse(namespaces_info.IsExtraRequire(token),
'Should not be extra since it is for testing.')
def testGetWholeIdentifierString(self):
"""Tests that created identifiers satisfy usage of the identifier."""
input_lines = ['package.Foo.', ' veryLong.', ' identifier;']
token = testutil.TokenizeSource(input_lines)
self.assertEquals('package.Foo.veryLong.identifier',
tokenutil.GetIdentifierForToken(token))
self.assertEquals(None, tokenutil.GetIdentifierForToken(token.next))
def testGetMissingRequires_createdIdentifier(self):
"""Tests that created identifiers satisfy usage of the identifier."""
input_lines = [
'package.Foo.methodName = function();', 'package.Foo.methodName();'
]
token = testutil.TokenizeSource(input_lines)
namespaces_info = self._GetInitializedNamespacesInfo(
token, ['package'], [])
self.assertEquals(0, len(namespaces_info.GetMissingRequires()))
def testGetMissingRequires_provided(self):
"""Tests that provided namespaces satisfy identifiers on that namespace."""
input_lines = [
'goog.provide(\'package.Foo\');', 'package.Foo.methodName();'
]
token = testutil.TokenizeSource(input_lines)
namespaces_info = self._GetInitializedNamespacesInfo(
token, ['package'], [])
self.assertEquals(0, len(namespaces_info.GetMissingRequires()))
def testIsFirstProvide(self):
"""Tests operation of the isFirstProvide method."""
input_lines = [
'goog.provide(\'package.Foo\');', 'package.Foo.methodName();'
]
token = testutil.TokenizeSource(input_lines)
namespaces_info = self._GetInitializedNamespacesInfo(
token, ['package'], [])
self.assertTrue(namespaces_info.IsFirstProvide(token))
def testGetMissingProvides_providedIdentifier(self):
"""Tests that provided identifiers don't cause a missing provide."""
input_lines = [
'goog.provide(\'package.Foo.methodName\');',
'package.Foo.methodName = function() {};'
]
token = testutil.TokenizeSource(input_lines)
namespaces_info = self._GetInitializedNamespacesInfo(
token, ['package'], [])
self.assertEquals(0, len(namespaces_info.GetMissingProvides()))
def testGetWholeIdentifierString(self):
"""Tests that created identifiers satisfy usage of the identifier."""
input_lines = ['package.Foo.', ' veryLong.', ' identifier;']
token = testutil.TokenizeSource(input_lines)
namespaces_info = closurizednamespacesinfo.ClosurizedNamespacesInfo([],
[])
self.assertEquals('package.Foo.veryLong.identifier',
namespaces_info._GetWholeIdentifierString(token))
self.assertEquals(
None, namespaces_info._GetWholeIdentifierString(token.next))
def testIsExtraProvide_created(self):
"""Tests that provides for created namespaces are not extra."""
input_lines = [
'goog.provide(\'package.Foo\');', 'package.Foo = function() {};'
]
token = testutil.TokenizeSource(input_lines)
namespaces_info = self._GetInitializedNamespacesInfo(
token, ['package'], [])
self.assertFalse(namespaces_info.IsExtraProvide(token),
'Should not be extra since it is created.')
def testGetMissingRequires_requiredParentClass(self):
"""Tests that requiring a parent class of an object is sufficient to prevent
a missing require on that object."""
input_lines = [
'goog.require(\'package.Foo\');', 'package.Foo.methodName();',
'package.Foo.methodName(package.Foo.ObjectName);'
]
token = testutil.TokenizeSource(input_lines)
namespaces_info = self._GetInitializedNamespacesInfo(
token, ['package'], [])
self.assertEquals(0, len(namespaces_info.GetMissingRequires()))
def testIsExtraRequire_used(self):
"""Tests that requires for used namespaces are not extra."""
input_lines = [
'goog.require(\'package.Foo\');',
'var x = package.Foo.methodName();'
]
token = testutil.TokenizeSource(input_lines)
namespaces_info = self._GetInitializedNamespacesInfo(
token, ['package'], [])
self.assertFalse(namespaces_info.IsExtraRequire(token),
'Should not be extra since it is used.')
def testIsExtraRequire_methodNotOnClass(self):
"""Tests that requiring a method not on a class is OK."""
input_lines = [
'goog.require(\'package.subpackage.method\');',
'var x = package.subpackage.method()',
]
token = testutil.TokenizeSource(input_lines)
namespaces_info = self._GetInitializedNamespacesInfo(
token, ['package'], [])
self.assertFalse(namespaces_info.IsExtraRequire(token),
'Methods can be required except on classes.')
def testIsExtraRequire_constantOnClass(self):
"""Tests that requiring a constant on a class is extra."""
input_lines = [
'goog.require(\'package.Foo.CONSTANT\');',
'var x = package.Foo.CONSTANT',
]
token = testutil.TokenizeSource(input_lines)
namespaces_info = self._GetInitializedNamespacesInfo(
token, ['package'], [])
self.assertTrue(namespaces_info.IsExtraRequire(token),
'The class, not the constant, should be required.')
def testIsExtraRequire_objectOnClass(self):
"""Tests that requiring an object on a class is extra."""
input_lines = [
'goog.require(\'package.Foo.Enum\');',
'var x = package.Foo.Enum.VALUE1;',
]
token = testutil.TokenizeSource(input_lines)
namespaces_info = self._GetInitializedNamespacesInfo(
token, ['package'], [])
self.assertTrue(
namespaces_info.IsExtraRequire(token),
'The whole class, not the object, should be required.')
def testGetMissingProvides_providedParentIdentifier(self):
"""Tests that provided identifiers on a class don't cause a missing provide
on objects attached to that class."""
input_lines = [
'goog.provide(\'package.foo.ClassName\');',
'package.foo.ClassName.methodName = function() {};',
'package.foo.ClassName.ObjectName = 1;',
]
token = testutil.TokenizeSource(input_lines)
namespaces_info = self._GetInitializedNamespacesInfo(
token, ['package'], [])
self.assertEquals(0, len(namespaces_info.GetMissingProvides()))
def testIsExtraRequire_usedIdentifier(self):
"""Tests that requires for used methods on classes are extra."""
input_lines = [
'goog.require(\'package.Foo.methodName\');',
'var x = package.Foo.methodName();'
]
token = testutil.TokenizeSource(input_lines)
namespaces_info = self._GetInitializedNamespacesInfo(
token, ['package'], [])
self.assertTrue(
namespaces_info.IsExtraRequire(token),
'Should require the package, not the method specifically.')
def testGetMissingRequires_objectOnClass(self):
"""Tests that we should require a class, not the object on the class."""
input_lines = [
'goog.require(\'package.Foo.Enum\');',
'var x = package.Foo.Enum.VALUE1;',
]
token = testutil.TokenizeSource(input_lines)
namespaces_info = self._GetInitializedNamespacesInfo(
token, ['package'], [])
self.assertEquals(
1, len(namespaces_info.GetMissingRequires()),
'The whole class, not the object, should be required.')
def testIsExtraProvide_duplicate(self):
"""Tests that providing a namespace twice makes the second one extra."""
input_lines = [
'goog.provide(\'package.Foo\');', 'goog.provide(\'package.Foo\');',
'package.Foo = function() {};'
]
token = testutil.TokenizeSource(input_lines)
namespaces_info = self._GetInitializedNamespacesInfo(
token, ['package'], [])
# Advance to the second goog.provide token.
token = tokenutil.Search(token.next, TokenType.IDENTIFIER)
self.assertTrue(namespaces_info.IsExtraProvide(token),
'Should be extra since it is already provided.')
def testGetPreviousCodeToken(self):
tokens = testutil.TokenizeSource("""
start1. // comment
/* another comment */
end1
""")
def _GetTokenStartingWith(token_starts_with):
for t in tokens:
if t.string.startswith(token_starts_with):
return t
self.assertEquals(
None,
tokenutil.GetPreviousCodeToken(_GetTokenStartingWith('start1')))
self.assertEquals(
'start1.',
tokenutil.GetPreviousCodeToken(_GetTokenStartingWith('end1')).string)
def _GetRequireTokens(self, namespace):
"""Returns a list of tokens for a goog.require of the given namespace."""
line_text = 'goog.require(\'' + namespace + '\');\n'
return testutil.TokenizeSource([line_text])
def _GetStartTokenAndNamespacesInfoForScript(self, script,
closurized_namespaces):
token = testutil.TokenizeSource(script)
return token, self._GetInitializedNamespacesInfo(
token, closurized_namespaces, [])
def testGetIdentifierForToken(self):
tokens = testutil.TokenizeSource("""
start1.abc.def.prototype.
onContinuedLine
(start2.abc.def
.hij.klm
.nop)
start3.abc.def
.hij = function() {};
// An absurd multi-liner.
start4.abc.def.
hij.
klm = function() {};
start5 . aaa . bbb . ccc
shouldntBePartOfThePreviousSymbol
start6.abc.def ghi.shouldntBePartOfThePreviousSymbol
var start7 = 42;
function start8() {
}
start9.abc. // why is there a comment here?
def /* another comment */
shouldntBePart
start10.abc // why is there a comment here?
.def /* another comment */
shouldntBePart
start11.abc. middle1.shouldNotBeIdentifier
""")
def _GetTokenStartingWith(token_starts_with):
for t in tokens:
if t.string.startswith(token_starts_with):
return t
self.assertEquals(
'start1.abc.def.prototype.onContinuedLine',
tokenutil.GetIdentifierForToken(_GetTokenStartingWith('start1')))
self.assertEquals(
'start2.abc.def.hij.klm.nop',
tokenutil.GetIdentifierForToken(_GetTokenStartingWith('start2')))
self.assertEquals(
'start3.abc.def.hij',
tokenutil.GetIdentifierForToken(_GetTokenStartingWith('start3')))
self.assertEquals(
'start4.abc.def.hij.klm',
tokenutil.GetIdentifierForToken(_GetTokenStartingWith('start4')))
self.assertEquals(
'start5.aaa.bbb.ccc',
tokenutil.GetIdentifierForToken(_GetTokenStartingWith('start5')))
self.assertEquals(
'start6.abc.def',
tokenutil.GetIdentifierForToken(_GetTokenStartingWith('start6')))
self.assertEquals(
'start7',
tokenutil.GetIdentifierForToken(_GetTokenStartingWith('start7')))
self.assertEquals(
'start8',
tokenutil.GetIdentifierForToken(_GetTokenStartingWith('start8')))
self.assertEquals(
'start9.abc.def',
tokenutil.GetIdentifierForToken(_GetTokenStartingWith('start9')))
self.assertEquals(
'start10.abc.def',
tokenutil.GetIdentifierForToken(_GetTokenStartingWith('start10')))
self.assertIsNone(
tokenutil.GetIdentifierForToken(_GetTokenStartingWith('middle1')))
