Mojo: Mojom: Change order of default values and ordinals.

mojo/public/tools/bindings/pylib/mojom_tests/parse/parser_unittest.py

 # Copyright 2014 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 import imp
 import os.path
 import sys
 import unittest
 
 # Disable lint check for finding modules:
@@ skipping 193 matching lines @@
       parser.Parse(source, "my_file.mojom")
 
   def testSimpleOrdinals(self):
     """Tests that (valid) ordinal values are scanned correctly."""
     source = """\
 module my_module {
 
 // This isn't actually valid .mojom, but the problem (missing ordinals) should
 // be handled at a different level.
 struct MyStruct {
-  int32 a0 @0;
-  int32 a1 @1;
-  int32 a2 @2;
-  int32 a9 @9;
+  int32 a0@0;
+  int32 a1@1;
+  int32 a2@2;
+  int32 a9@9;
   int32 a10 @10;
   int32 a11 @11;
   int32 a29 @29;
   int32 a1234567890 @1234567890;
 };
 
 }  // module my_module
 """
     expected = \
 [('MODULE',
@@ skipping 11 matching lines @@
      ('FIELD', 'int32', 'a29', ast.Ordinal(29), None),
      ('FIELD', 'int32', 'a1234567890', ast.Ordinal(1234567890), None)])])]
     self.assertEquals(parser.Parse(source, "my_file.mojom"), expected)
 
   def testInvalidOrdinals(self):
     """Tests that (lexically) invalid ordinals are correctly detected."""
     source1 = """\
 module my_module {
 
 struct MyStruct {
-  int32 a_missing @;
+  int32 a_missing@;
 };
 
 }  // module my_module
 """
     with self.assertRaisesRegexp(
         lexer.LexError,
         r"^my_file\.mojom:4: Error: Missing ordinal value$"):
       parser.Parse(source1, "my_file.mojom")
 
     source2 = """\
 module my_module {
 
 struct MyStruct {
-  int32 a_octal @01;
+  int32 a_octal@01;
 };
 
 }  // module my_module
 """
     with self.assertRaisesRegexp(
         lexer.LexError,
         r"^my_file\.mojom:4: Error: "
             r"Octal and hexadecimal ordinal values not allowed$"):
       parser.Parse(source2, "my_file.mojom")
 
     source3 = """\
-module my_module { struct MyStruct { int32 a_invalid_octal @08; }; }
+module my_module { struct MyStruct { int32 a_invalid_octal@08; }; }
 """
     with self.assertRaisesRegexp(
         lexer.LexError,
         r"^my_file\.mojom:1: Error: "
             r"Octal and hexadecimal ordinal values not allowed$"):
       parser.Parse(source3, "my_file.mojom")
 
     source4 = """\
-module my_module { struct MyStruct { int32 a_hex @0x1aB9; }; }
+module my_module { struct MyStruct { int32 a_hex@0x1aB9; }; }
 """
     with self.assertRaisesRegexp(
         lexer.LexError,
         r"^my_file\.mojom:1: Error: "
             r"Octal and hexadecimal ordinal values not allowed$"):
       parser.Parse(source4, "my_file.mojom")
 
     source5 = """\
-module my_module { struct MyStruct { int32 a_hex @0X0; }; }
+module my_module { struct MyStruct { int32 a_hex@0X0; }; }
 """
     with self.assertRaisesRegexp(
         lexer.LexError,
         r"^my_file\.mojom:1: Error: "
             r"Octal and hexadecimal ordinal values not allowed$"):
       parser.Parse(source5, "my_file.mojom")
 
     source6 = """\
 struct MyStruct {
-  int32 a_too_big @999999999999;
+  int32 a_too_big@999999999999;
 };
 """
     with self.assertRaisesRegexp(
         parser.ParseError,
         r"^my_file\.mojom:2: Error: "
             r"Ordinal value 999999999999 too large:\n"
-            r"  int32 a_too_big @999999999999;$"):
+            r"  int32 a_too_big@999999999999;$"):
       parser.Parse(source6, "my_file.mojom")
 
   def testNestedNamespace(self):
     """Tests that "nested" namespaces work."""
     source = """\
 module my.mod {
 
 struct MyStruct {
   int32 a;
 };
@@ skipping 47 matching lines @@
     with self.assertRaisesRegexp(
         parser.ParseError,
         r"^my_file\.mojom:2: Error: "
             r"Invalid handle type 'wtf_is_this':\n"
             r"  handle<wtf_is_this> foo;$"):
       parser.Parse(source, "my_file.mojom")
 
 
 if __name__ == "__main__":
   unittest.main()