ppapi/generators/idl_namespace.py

   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 """
   7 IDLNamespace for PPAPI
   8
   9 This file defines the behavior of the AST namespace which allows for resolving
  10 a symbol as one or more AST nodes given a release or range of releases.
  11 """
  12
  13 import sys
  14
  15 from idl_option import GetOption, Option, ParseOptions
  16 from idl_log import ErrOut, InfoOut, WarnOut
  17 from idl_release import IDLRelease, IDLReleaseList
  18
  19 Option('label', 'Use the specifed label blocks.', default='Chrome')
  20 Option('namespace_debug', 'Use the specified release')
  21
  22
  23 #
  24 # IDLNamespace
  25 #
  26 # IDLNamespace provides a mapping between a symbol name and an IDLReleaseList
  27 # which contains IDLRelease objects.  It provides an interface for fetching
  28 # one or more IDLNodes based on a release or range of releases.
  29 #
  30 class IDLNamespace(object):
  31   def __init__(self, parent):
  32     self._name_to_releases = {}
  33     self._parent = parent
  34
  35   def Dump(self):
  36     for name in self._name_to_releases:
  37       InfoOut.Log('NAME=%s' % name)
  38       for cver in self._name_to_releases[name].GetReleases():
  39         InfoOut.Log('  %s' % cver)
  40       InfoOut.Log('')
  41
  42   def FindRelease(self, name, release):
  43     verlist = self._name_to_releases.get(name, None)
  44     if verlist == None:
  45       if self._parent:
  46         return self._parent.FindRelease(name, release)
  47       else:
  48         return None
  49     return verlist.FindRelease(release)
  50
  51   def FindRange(self, name, rmin, rmax):
  52     verlist = self._name_to_releases.get(name, None)
  53     if verlist == None:
  54       if self._parent:
  55         return self._parent.FindRange(name, rmin, rmax)
  56       else:
  57         return []
  58     return verlist.FindRange(rmin, rmax)
  59
  60   def FindList(self, name):
  61     verlist = self._name_to_releases.get(name, None)
  62     if verlist == None:
  63       if self._parent:
  64         return self._parent.FindList(name)
  65     return verlist
  66
  67   def AddNode(self, node):
  68     name = node.GetName()
  69     verlist = self._name_to_releases.setdefault(name,IDLReleaseList())
  70     if GetOption('namespace_debug'):
  71         print "Adding to namespace: %s" % node
  72     return verlist.AddNode(node)
  73
  74
  75 #
  76 # Testing Code
  77 #
  78
  79 #
  80 # MockNode
  81 #
  82 # Mocks the IDLNode to support error, warning handling, and string functions.
  83 #
  84 class MockNode(IDLRelease):
  85   def __init__(self, name, rmin, rmax):
  86     self.name = name
  87     self.rmin = rmin
  88     self.rmax = rmax
  89     self.errors = []
  90     self.warns = []
  91     self.properties = {
  92         'NAME': name,
  93         'release': rmin,
  94         'deprecate' : rmax
  95         }
  96
  97   def __str__(self):
  98     return '%s (%s : %s)' % (self.name, self.rmin, self.rmax)
  99
 100   def GetName(self):
 101     return self.name
 102
 103   def Error(self, msg):
 104     if GetOption('release_debug'): print 'Error: %s' % msg
 105     self.errors.append(msg)
 106
 107   def Warn(self, msg):
 108     if GetOption('release_debug'): print 'Warn: %s' % msg
 109     self.warns.append(msg)
 110
 111   def GetProperty(self, name):
 112     return self.properties.get(name, None)
 113
 114 errors = 0
 115 #
 116 # DumpFailure
 117 #
 118 # Dumps all the information relevant  to an add failure.
 119 def DumpFailure(namespace, node, msg):
 120   global errors
 121   print '\n******************************'
 122   print 'Failure: %s %s' % (node, msg)
 123   for warn in node.warns:
 124     print '  WARN: %s' % warn
 125   for err in node.errors:
 126     print '  ERROR: %s' % err
 127   print '\n'
 128   namespace.Dump()
 129   print '******************************\n'
 130   errors += 1
 131
 132 # Add expecting no errors or warnings
 133 def AddOkay(namespace, node):
 134   okay = namespace.AddNode(node)
 135   if not okay or node.errors or node.warns:
 136     DumpFailure(namespace, node, 'Expected success')
 137
 138 # Add expecting a specific warning
 139 def AddWarn(namespace, node, msg):
 140   okay = namespace.AddNode(node)
 141   if not okay or node.errors or not node.warns:
 142     DumpFailure(namespace, node, 'Expected warnings')
 143   if msg not in node.warns:
 144     DumpFailure(namespace, node, 'Expected warning: %s' % msg)
 145
 146 # Add expecting a specific error any any number of warnings
 147 def AddError(namespace, node, msg):
 148   okay = namespace.AddNode(node)
 149   if okay or not node.errors:
 150     DumpFailure(namespace, node, 'Expected errors')
 151   if msg not in node.errors:
 152     DumpFailure(namespace, node, 'Expected error: %s' % msg)
 153     print ">>%s<<\n>>%s<<\n" % (node.errors[0], msg)
 154
 155 # Verify that a FindRelease call on the namespace returns the expected node.
 156 def VerifyFindOne(namespace, name, release, node):
 157   global errors
 158   if (namespace.FindRelease(name, release) != node):
 159     print "Failed to find %s as release %f of %s" % (node, release, name)
 160     namespace.Dump()
 161     print "\n"
 162     errors += 1
 163
 164 # Verify that a FindRage call on the namespace returns a set of expected nodes.
 165 def VerifyFindAll(namespace, name, rmin, rmax, nodes):
 166   global errors
 167   out = namespace.FindRange(name, rmin, rmax)
 168   if (out != nodes):
 169     print "Found [%s] instead of[%s] for releases %f to %f of %s" % (
 170         ' '.join([str(x) for x in out]),
 171         ' '.join([str(x) for x in nodes]),
 172         rmin,
 173         rmax,
 174         name)
 175     namespace.Dump()
 176     print "\n"
 177     errors += 1
 178
 179 def Main(args):
 180   global errors
 181   ParseOptions(args)
 182
 183   InfoOut.SetConsole(True)
 184
 185   namespace = IDLNamespace(None)
 186
 187   FooXX = MockNode('foo', None, None)
 188   Foo1X = MockNode('foo', 1.0, None)
 189   Foo2X = MockNode('foo', 2.0, None)
 190   Foo3X = MockNode('foo', 3.0, None)
 191
 192   # Verify we succeed with undeprecated adds
 193   AddOkay(namespace, FooXX)
 194   AddOkay(namespace, Foo1X)
 195   AddOkay(namespace, Foo3X)
 196   # Verify we fail to add a node between undeprecated releases
 197   AddError(namespace, Foo2X,
 198            'Overlap in releases: 3.0 vs 2.0 when adding foo (2.0 : None)')
 199
 200   BarXX = MockNode('bar', None, None)
 201   Bar12 = MockNode('bar', 1.0, 2.0)
 202   Bar23 = MockNode('bar', 2.0, 3.0)
 203   Bar34 = MockNode('bar', 3.0, 4.0)
 204
 205
 206   # Verify we succeed with fully qualified releases
 207   namespace = IDLNamespace(namespace)
 208   AddOkay(namespace, BarXX)
 209   AddOkay(namespace, Bar12)
 210   # Verify we warn when detecting a gap
 211   AddWarn(namespace, Bar34, 'Gap in release numbers.')
 212   # Verify we fail when inserting into this gap
 213   # (NOTE: while this could be legal, it is sloppy so we disallow it)
 214   AddError(namespace, Bar23, 'Declarations out of order.')
 215
 216   # Verify local namespace
 217   VerifyFindOne(namespace, 'bar', 0.0, BarXX)
 218   VerifyFindAll(namespace, 'bar', 0.5, 1.5, [BarXX, Bar12])
 219
 220   # Verify the correct release of the object is found recursively
 221   VerifyFindOne(namespace, 'foo', 0.0, FooXX)
 222   VerifyFindOne(namespace, 'foo', 0.5, FooXX)
 223   VerifyFindOne(namespace, 'foo', 1.0, Foo1X)
 224   VerifyFindOne(namespace, 'foo', 1.5, Foo1X)
 225   VerifyFindOne(namespace, 'foo', 3.0, Foo3X)
 226   VerifyFindOne(namespace, 'foo', 100.0, Foo3X)
 227
 228   # Verify the correct range of objects is found
 229   VerifyFindAll(namespace, 'foo', 0.0, 1.0, [FooXX])
 230   VerifyFindAll(namespace, 'foo', 0.5, 1.0, [FooXX])
 231   VerifyFindAll(namespace, 'foo', 1.0, 1.1, [Foo1X])
 232   VerifyFindAll(namespace, 'foo', 0.5, 1.5, [FooXX, Foo1X])
 233   VerifyFindAll(namespace, 'foo', 0.0, 3.0, [FooXX, Foo1X])
 234   VerifyFindAll(namespace, 'foo', 3.0, 100.0, [Foo3X])
 235
 236   FooBar = MockNode('foobar', 1.0, 2.0)
 237   namespace = IDLNamespace(namespace)
 238   AddOkay(namespace, FooBar)
 239
 240   if errors:
 241     print 'Test failed with %d errors.' % errors
 242   else:
 243     print 'Passed.'
 244   return errors
 245
 246
 247 if __name__ == '__main__':
 248   sys.exit(Main(sys.argv[1:]))
 249