Mojom compiler: Move RuntimeTypeInfo from mojom_files.mojom to mojom_types.mojom.

mojom/mojom_parser/serialization/serialization_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 serialization
 
 import (
         "fmt"
         "mojo/public/go/bindings"
         "mojom/mojom_parser/generated/mojom_files"
@@ skipping 1251 matching lines @@
 }
 
 ////////////////////////////////////////////
 /// Serialized Runtime Type Info Tests
 ///////////////////////////////////////////
 
 type runtimeTypeInfoTestCase struct {
         // The contents of the two files
         mojomContentsA           string
         mojomContentsB           string
-        expectedRuntimeTypeInfoA *mojom_files.RuntimeTypeInfo
-        expectedRuntimeTypeInfoB *mojom_files.RuntimeTypeInfo
+        expectedRuntimeTypeInfoA *mojom_types.RuntimeTypeInfo
+        expectedRuntimeTypeInfoB *mojom_types.RuntimeTypeInfo
 }
 
 type runtimeTypeInfoTest struct {
         cases       []runtimeTypeInfoTestCase
         testCaseNum int
 }
 
-func (t *runtimeTypeInfoTest) expectedRuntimeTypeInfoA() *mojom_files.RuntimeTypeInfo {
+func (t *runtimeTypeInfoTest) expectedRuntimeTypeInfoA() *mojom_types.RuntimeTypeInfo {
         return t.cases[t.testCaseNum].expectedRuntimeTypeInfoA
 }
 
-func (t *runtimeTypeInfoTest) expectedRuntimeTypeInfoB() *mojom_files.RuntimeTypeInfo {
+func (t *runtimeTypeInfoTest) expectedRuntimeTypeInfoB() *mojom_types.RuntimeTypeInfo {
         return t.cases[t.testCaseNum].expectedRuntimeTypeInfoB
 }
 
 func (test *runtimeTypeInfoTest) addTestCase(contentsA, contentsB string) {
-        test.cases = append(test.cases, runtimeTypeInfoTestCase{contentsA, contentsB, new(mojom_files.RuntimeTypeInfo), new(mojom_files.RuntimeTypeInfo)})
-        test.expectedRuntimeTypeInfoA().ServicesByName = make(map[string]mojom_files.ServiceTypeInfo)
+        test.cases = append(test.cases, runtimeTypeInfoTestCase{contentsA, contentsB, new(mojom_types.RuntimeTypeInfo), new(mojom_types.RuntimeTypeInfo)})
+        test.expectedRuntimeTypeInfoA().ServicesByName = make(map[string]mojom_types.ServiceTypeInfo)
         test.expectedRuntimeTypeInfoA().TypeMap = make(map[string]mojom_types.UserDefinedType)
-        test.expectedRuntimeTypeInfoB().ServicesByName = make(map[string]mojom_files.ServiceTypeInfo)
+        test.expectedRuntimeTypeInfoB().ServicesByName = make(map[string]mojom_types.ServiceTypeInfo)
         test.expectedRuntimeTypeInfoB().TypeMap = make(map[string]mojom_types.UserDefinedType)
 }
 
 func (test *runtimeTypeInfoTest) fileNameA() string {
         return fmt.Sprintf("file%dA", test.testCaseNum)
 }
 
 func (test *runtimeTypeInfoTest) fileNameB() string {
         return fmt.Sprintf("file%dB", test.testCaseNum)
 }
@@ skipping 165 matching lines @@
         };
 
         interface InterfaceB {
         DoIt(a.b.c.FooA x) => (FooB? y);
     };
 
         `
                 test.addTestCase(contentsA, contentsB)
 
                 // ServicesByName for file A
-                test.expectedRuntimeTypeInfoA().ServicesByName["AwesomeService"] = mojom_files.ServiceTypeInfo{
+                test.expectedRuntimeTypeInfoA().ServicesByName["AwesomeService"] = mojom_types.ServiceTypeInfo{
                         TopLevelInterface: "TYPE_KEY:a.b.c.InterfaceA",
                         CompleteTypeSet:   []string{"TYPE_KEY:a.b.c.FooA", "TYPE_KEY:a.b.c.InterfaceA", "TYPE_KEY:b.c.d.FooB"},
                 }
 
                 // TypeMap for file A
 
                 // FooA
                 test.expectedRuntimeTypeInfoA().TypeMap["TYPE_KEY:a.b.c.FooA"] = &mojom_types.UserDefinedTypeStructType{mojom_types.MojomStruct{
                         DeclData: newDeclData(test.fileNameA(), "FooA", "a.b.c.FooA"),
                         Fields:   []mojom_types.StructField{}}}
@@ skipping 95 matching lines @@
 
         [ServiceName = 42]
         interface InterfaceB {
         DoIt(a.b.c.FooA x) => (FooB? y);
     };
 
         `
                 test.addTestCase(contentsA, contentsB)
 
                 // ServicesByName for file A
-                test.expectedRuntimeTypeInfoA().ServicesByName["AwesomeService"] = mojom_files.ServiceTypeInfo{
+                test.expectedRuntimeTypeInfoA().ServicesByName["AwesomeService"] = mojom_types.ServiceTypeInfo{
                         TopLevelInterface: "TYPE_KEY:a.b.c.InterfaceA",
                         CompleteTypeSet:   []string{"TYPE_KEY:a.b.c.FooA", "TYPE_KEY:a.b.c.InterfaceA", "TYPE_KEY:b.c.d.FooB"},
                 }
 
                 // TypeMap for file A
 
                 // FooA
                 test.expectedRuntimeTypeInfoA().TypeMap["TYPE_KEY:a.b.c.FooA"] = &mojom_types.UserDefinedTypeStructType{mojom_types.MojomStruct{
                         DeclData: newDeclData(test.fileNameA(), "FooA", "a.b.c.FooA"),
                         Fields:   []mojom_types.StructField{}}}
@@ skipping 104 matching lines @@
         };
 
         interface InterfaceB {
         DoIt(a.b.c.FooA x) => (FooB? y, Enum2 z);
     };
 
         `
                 test.addTestCase(contentsA, contentsB)
 
                 // ServicesByName for file A
-                test.expectedRuntimeTypeInfoA().ServicesByName["AwesomeService"] = mojom_files.ServiceTypeInfo{
+                test.expectedRuntimeTypeInfoA().ServicesByName["AwesomeService"] = mojom_types.ServiceTypeInfo{
                         TopLevelInterface: "TYPE_KEY:a.b.c.InterfaceA",
                         CompleteTypeSet:   []string{"TYPE_KEY:a.b.c.FooA", "TYPE_KEY:a.b.c.InterfaceA", "TYPE_KEY:b.c.d.Enum1", "TYPE_KEY:b.c.d.FooB"},
                 }
 
                 // TypeMap for file A
 
                 // FooA
                 test.expectedRuntimeTypeInfoA().TypeMap["TYPE_KEY:a.b.c.FooA"] = &mojom_types.UserDefinedTypeStructType{mojom_types.MojomStruct{
                         DeclData: newDeclData(test.fileNameA(), "FooA", "a.b.c.FooA"),
                         Fields:   []mojom_types.StructField{}}}
@@ skipping 141 matching lines @@
                         continue
                 }
 
                 // Deserialize
                 decoder := bindings.NewDecoder(bytes, nil)
                 fileGraph := mojom_files.MojomFileGraph{}
                 fileGraph.Decode(decoder)
 
                 // Deserialize  RuntimeTypeInfo A
                 decoder = bindings.NewDecoder(*fileGraph.Files[fileNameA].SerializedRuntimeTypeInfo, nil)
-                runtimeTypeInfoA := mojom_files.RuntimeTypeInfo{}
+                runtimeTypeInfoA := mojom_types.RuntimeTypeInfo{}
                 runtimeTypeInfoA.Decode(decoder)
 
                 // Deserialize  RuntimeTypeInfo B
                 decoder = bindings.NewDecoder(*fileGraph.Files[fileNameB].SerializedRuntimeTypeInfo, nil)
-                runtimeTypeInfoB := mojom_files.RuntimeTypeInfo{}
+                runtimeTypeInfoB := mojom_types.RuntimeTypeInfo{}
                 runtimeTypeInfoB.Decode(decoder)
 
                 // Compare A
                 if err := compareTwoGoObjects(c.expectedRuntimeTypeInfoA, &runtimeTypeInfoA); err != nil {
                         t.Errorf("case %d A:\n%s", i, err.Error())
                 }
 
                 // Compare B
                 if err := compareTwoGoObjects(c.expectedRuntimeTypeInfoB, &runtimeTypeInfoB); err != nil {
                         t.Errorf("case %d B:\n%s", i, err.Error())
@@ skipping 29 matching lines @@
                         }
                         return fmt.Errorf("*****\nexpected=\n*****\n%q\n*****\nactual=\n*****\n%q\n*****\n"+
                                 "match failed at position %d: expected=\n*****\n%q\n******\nactual=\n*****\n%q\n******\n",
                                 expectedString, actualString, diffPos, mismatchExpected, mismatchActual)
                 } else {
                         return fmt.Errorf("expected != actual but the two printed equal.")
                 }
         }
         return nil
 }