示例#1
0
        public void ShouldCacheValidMapping()
        {
            var SinTDType = new SinTDStruct("testType");

            SinTDType.members.Add("i16", i16);
            SinTDType.CanBeAssignedFromType(typeof(List <nestedTestStruct>));
            Assert.Contains(typeof(List <nestedTestStruct>), SinTDType.validMappings.Keys);
            Assert.IsFalse(SinTDType.validMappings[typeof(List <nestedTestStruct>)]);
        }
示例#2
0
        public void InitTests()
        {
            i16 = new SinTDType("i16");

            i32 = new SinTDType("i32");

            i64 = new SinTDType("i64");

            ui16 = new SinTDType("u16");
            ui32 = new SinTDType("u32");
            ui64 = new SinTDType("u64");

            SinTD_double = new SinTDType("double");

            SinTD_float = new SinTDType("float");

            SinTD_string      = new SinTDType();
            SinTD_string.Name = "string";

            SinTD_bool      = new SinTDType();
            SinTD_bool.Name = "boolean";

            intStruct = new SinTDStruct("intStruct");
            intStruct.members["x"] = i32;
            intStruct.members["y"] = i32;

            nestedStruct = new SinTDStruct("nestedStruct");
            nestedStruct.members["name"] = SinTD_string;
            nestedStruct.members["b"]    = SinTD_bool;
            nestedStruct.members["s"]    = intStruct;

            SinTD_array             = new SinTDArray();
            SinTD_array.Name        = "array<int32>";
            SinTD_array.elementType = i32;

            map             = new SinTDMap();
            map.keyType     = SinTD_string;
            map.elementType = intStruct;

            SinTD_arrayOfStructs             = new SinTDArray();
            SinTD_arrayOfStructs.Name        = "array<nestedStruct>";
            SinTD_arrayOfStructs.elementType = nestedStruct;

            SinTD_mapWithStructElements             = new SinTDMap();
            SinTD_mapWithStructElements.elementType = nestedStruct;
            SinTD_mapWithStructElements.keyType     = SinTD_string;

            SinTD_mapWithStructKeys             = new SinTDMap();
            SinTD_mapWithStructKeys.elementType = SinTD_string;
            SinTD_mapWithStructKeys.keyType     = nestedStruct;

            Vector = new SinTDStruct("Vector");
            Vector.members.Add("x", SinTD_float);
            Vector.members.Add("y", SinTD_float);
            Vector.members.Add("z", SinTD_float);
        }
示例#3
0
        public void ShouldParseStructOfBaseTypes()
        {
            string idl = @"struct BaseStruct {
                            i32 intValue;
                            string name;
                         }";

            IDLParser.Instance.ParseIDL(idl);
            Assert.IsTrue(IDLParser.Instance.CurrentlyParsedSinTD.ContainsType("BaseStruct"));
            SinTDStruct baseStruct = IDLParser.Instance.CurrentlyParsedSinTD.GetSinTDType("BaseStruct") as SinTDStruct;

            Assert.Contains("intValue", baseStruct.members.Keys);
            Assert.AreEqual(IDLParser.Instance.CurrentlyParsedSinTD.GetSinTDType("i32"), baseStruct.members["intValue"]);
        }
示例#4
0
        public void ShouldParseStructWithArray()
        {
            string idl = @"struct ArrayStruct {
                            array<i16> testArray;
                         }";

            IDLParser.Instance.ParseIDL(idl);
            Assert.IsTrue(IDLParser.Instance.CurrentlyParsedSinTD.ContainsType("ArrayStruct"));
            SinTDStruct arrayStruct = IDLParser.Instance.CurrentlyParsedSinTD.GetSinTDType("ArrayStruct") as SinTDStruct;

            Assert.Contains("testArray", arrayStruct.members.Keys);

            var parsedArray = arrayStruct.members["testArray"];

            Assert.AreEqual(typeof(SinTDArray), parsedArray.GetType());
        }
示例#5
0
        public void ShouldParseStructWithMap()
        {
            string idl = @"struct MapStruct {
                            map<string, i16> testMap;
                         }";

            IDLParser.Instance.ParseIDL(idl);
            Assert.IsTrue(IDLParser.Instance.CurrentlyParsedSinTD.ContainsType("MapStruct"));
            SinTDStruct mapStruct = IDLParser.Instance.CurrentlyParsedSinTD.GetSinTDType("MapStruct") as SinTDStruct;

            Assert.Contains("testMap", mapStruct.members.Keys);

            var parsedMap = mapStruct.members["testMap"];

            Assert.AreEqual(typeof(SinTDMap), parsedMap.GetType());
        }
示例#6
0
        public void Setup()
        {
            SinTDInstance = new SinTD();
            SinTDInstance.SINFONIServices = new ServiceRegistry();

            i32          = SinTDInstance.GetSinTDType("i32");
            SinTD_string = SinTDInstance.GetSinTDType("string");

            intStruct = new SinTDStruct("intStruct");
            intStruct.members["x"] = i32;
            intStruct.members["y"] = i32;

            serviceFunction = new ServiceFunctionDescription("function", new SinTDType("void"));
            serviceFunction.Parameters.Add("intParameter", i32);
            serviceFunction.Parameters.Add("stringParameter", SinTD_string);

            service = new SINFONIService("service");
            service.serviceFunctions.Add("function", serviceFunction);

            SinTDInstance.SINFONIServices.services.Add("service", service);
            connection       = new TestConnection();
            connection.SinTD = SinTDInstance;
        }
示例#7
0
        public void TestSetUp()
        {
            i32         = SinTDInstance.GetSinTDType("i32");
            SinTDString = SinTDInstance.GetSinTDType("string");
            SinTDBool   = SinTDInstance.GetSinTDType("boolean");

            intStruct = new SinTDStruct("intStruct");
            intStruct.members["x"] = i32;
            intStruct.members["y"] = i32;

            aStruct = new SinTDStruct("arrayStruct");
            aStruct.members.Add("arr", new SinTDArray(i32));
            SinTDInstance.RegisterType(aStruct);

            mStruct = new SinTDStruct("mapStruct");
            mStruct.members.Add("map", new SinTDMap(SinTDString, SinTDBool));
            SinTDInstance.RegisterType(mStruct);

            sStruct = new SinTDStruct("structStruct");
            sStruct.members.Add("child", intStruct);
            SinTDInstance.RegisterType(sStruct);

            SinTDInstance = new SinTD();
        }