New Mojom parser: Don't allow enum variables to be assigned int values.

mojom/mojom_parser/parser/resolution_test.go

 // Copyright 2015 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.
 
 package parser
 
 import (
         "fmt"
         "mojom/mojom_parser/mojom"
         "strings"
@@ skipping 624 matching lines @@
 
 // TestSingleFileTypeValidationErrors() test the method UserTypeRef.validateAfterResolution().
 // It is similar to TestSingleFileValueValidationErrors()
 // except that it tests the validation of types phase which occurs before the validation
 // of values phase. This phase detects errors that may not be detected during parsing
 // but that may be detected without resolving value references.
 func TestSingleFileTypeValidationErrors(t *testing.T) {
         test := singleFileTest{}
 
         ////////////////////////////////////////////////////////////
+        // Group 1: Left-hand-side is a struct
+        ////////////////////////////////////////////////////////////
+
+        ////////////////////////////////////////////////////////////
         // Test Case: Use struct as constant type
         ////////////////////////////////////////////////////////////
         {
                 contents := `
         struct Foo{
         };
 
     const Foo MyFoo = 3;
         `
                 test.addTestCase(contents, []string{
                         "The type Foo is not allowed as the type of a declared constant.",
                         "Only simple types, strings and enum types may be used"})
         }
 
         ////////////////////////////////////////////////////////////
-        // Test Case: Assign struct as map key
+        // Test Case: Use struct as map key
         ////////////////////////////////////////////////////////////
         {
                 contents := `
         struct Foo{
         };
 
     struct Bar{
         map<Foo, int32> x;
     };
         `
@@ skipping 13 matching lines @@
     struct Bar{
         Foo x = 42;
     };
         `
                 test.addTestCase(contents, []string{
                         "Illegal assignment",
                         "Field x of type Foo may not be assigned the value 42 of type int8"})
         }
 
         ////////////////////////////////////////////////////////////
+        // Group 2: Left-hand-side is an enum
+        ////////////////////////////////////////////////////////////
+
+        ////////////////////////////////////////////////////////////
+        // Test Case: Assign an integer to an enum variable in a struct field.
+        ////////////////////////////////////////////////////////////
+        {
+                contents := `
+        enum Hats {
+                COWBOY,
+                TOP
+        };
+
+    struct Bar{
+        Hats my_hat = 1;
+    };
+        `
+                test.addTestCase(contents, []string{
+                        "Illegal assignment",
+                        "Field my_hat of type Hats may not be assigned the value 1 of type int8."})
+        }
+
+        ////////////////////////////////////////////////////////////
+        // Test Case: Assign an integer to an enum variable in a constant.
+        ////////////////////////////////////////////////////////////
+        {
+                contents := `
+        enum Hats {
+                COWBOY,
+                TOP
+        };
+
+    const Hats MY_HAT = 1;
+        `
+                test.addTestCase(contents, []string{
+                        "Illegal assignment",
+                        "Const MY_HAT of type Hats may not be assigned the value 1 of type int8."})
+        }
+
+        ////////////////////////////////////////////////////////////
         // Execute all of the test cases.
         ////////////////////////////////////////////////////////////
         for i, c := range test.cases {
                 // Parse and resolve the mojom input.
                 descriptor := mojom.NewMojomDescriptor()
                 parser := MakeParser(c.fileName, c.mojomContents, descriptor, c.importedFrom)
                 parser.Parse()
                 if !parser.OK() {
                         t.Errorf("Parsing error for %s: %s", c.fileName, parser.GetError().Error())
                         continue
                 }
                 err := descriptor.Resolve()
                 if err == nil {
                         t.Errorf("Resolution unexpectedly succeeded for test case %d.", i)
                         continue
                 }
                 got := err.Error()
                 for _, expected := range c.expectedErrors {
                         if !strings.Contains(got, expected) {
                                 t.Errorf("%s:\n*****expected to contain:\n%s\n****actual\n%s", c.fileName, expected, got)
                         }
                 }
 
         }
 }