Upgrade gtest to r267 and gmock to r173.

testing/gmock/scripts/generator/cpp/ast.py

 #!/usr/bin/env python
 #
 # Copyright 2007 Neal Norwitz
 # Portions Copyright 2007 Google Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
 #
 #      http://www.apache.org/licenses/LICENSE-2.0
@@ skipping 764 matching lines @@
                 else:
                     temp_tokens2, last_token = \
                         self._GetVarTokensUpTo(tokenize.SYNTAX, ';')
                     temp_tokens.extend(temp_tokens2)
 
             if last_token.name == ';':
                 # Handle data, this isn't a method.
                 parts = self.converter.DeclarationToParts(temp_tokens, True)
                 (name, type_name, templated_types, modifiers, default,
                  unused_other_tokens) = parts
-                      
+
                 t0 = temp_tokens[0]
                 names = [t.name for t in temp_tokens]
                 if templated_types:
                     start, end = self.converter.GetTemplateIndices(names)
                     names = names[:start] + names[end:]
                 default = ''.join([t.name for t in default])
                 return self._CreateVariable(t0, name, type_name, modifiers,
                                             names, templated_types, default)
             if last_token.name == '{':
                 self._AddBackTokens(temp_tokens[1:])
@@ skipping 748 matching lines @@
 
     def handle_namespace(self):
         token = self._GetNextToken()
         # Support anonymous namespaces.
         name = None
         if token.token_type == tokenize.NAME:
             name = token.name
             token = self._GetNextToken()
         self.namespace_stack.append(name)
         assert token.token_type == tokenize.SYNTAX, token
+        # Create an internal token that denotes when the namespace is complete.
+        internal_token = tokenize.Token(_INTERNAL_TOKEN, _NAMESPACE_POP,
+                                        None, None)
+        internal_token.whence = token.whence
         if token.name == '=':
             # TODO(nnorwitz): handle aliasing namespaces.
             name, next_token = self.GetName()
             assert next_token.name == ';', next_token
+            self._AddBackToken(internal_token)
         else:
             assert token.name == '{', token
             tokens = list(self.GetScope())
-            del tokens[-1]              # Remove trailing '}'.
+            # Replace the trailing } with the internal namespace pop token.
+            tokens[-1] = internal_token
             # Handle namespace with nothing in it.
             self._AddBackTokens(tokens)
-        token = tokenize.Token(_INTERNAL_TOKEN, _NAMESPACE_POP, None, None)
-        self._AddBackToken(token)
         return None
 
     def handle_using(self):
         tokens = self._GetTokensUpTo(tokenize.SYNTAX, ';')
         assert tokens
         return Using(tokens[0].start, tokens[0].end, tokens)
 
     def handle_explicit(self):
         assert self.in_class
         # Nothing much to do.
@@ skipping 89 matching lines @@
         sys.stderr.write('Unable to find: %s\n' % filename)
         return
 
     #print('Processing %s' % actual_filename)
     builder = BuilderFromSource(source, filename)
     try:
         for node in builder.Generate():
             if should_print(node):
                 print(node.name)
     except KeyboardInterrupt:
-      return
+        return
     except:
         pass
 
 
 def PrintAllIndentifiers(filenames, should_print):
     """Prints all identifiers for each C++ source file in filenames.
 
     Args:
       filenames: ['file1', 'file2', ...]
       should_print: predicate with signature: bool Function(token)
@@ skipping 18 matching lines @@
             # Already printed a warning, print the traceback and continue.
             traceback.print_exc()
         else:
             if utils.DEBUG:
                 for ast in entire_ast:
                     print(ast)
 
 
 if __name__ == '__main__':
     main(sys.argv)