public void DeserializeArray()
        {
            string    sArrayOne    = "[]";
            LLSDArray llsdArrayOne = (LLSDArray)LLSDParser.DeserializeNotation(sArrayOne);

            Assert.AreEqual(LLSDType.Array, llsdArrayOne.Type);
            Assert.AreEqual(0, llsdArrayOne.Count);

            string    sArrayTwo    = "[ i0 ]";
            LLSDArray llsdArrayTwo = (LLSDArray)LLSDParser.DeserializeNotation(sArrayTwo);

            Assert.AreEqual(LLSDType.Array, llsdArrayTwo.Type);
            Assert.AreEqual(1, llsdArrayTwo.Count);
            LLSDInteger llsdIntOne = (LLSDInteger)llsdArrayTwo[0];

            Assert.AreEqual(LLSDType.Integer, llsdIntOne.Type);
            Assert.AreEqual(0, llsdIntOne.AsInteger());

            string    sArrayThree    = "[ i0, i1 ]";
            LLSDArray llsdArrayThree = (LLSDArray)LLSDParser.DeserializeNotation(sArrayThree);

            Assert.AreEqual(LLSDType.Array, llsdArrayThree.Type);
            Assert.AreEqual(2, llsdArrayThree.Count);
            LLSDInteger llsdIntTwo = (LLSDInteger)llsdArrayThree[0];

            Assert.AreEqual(LLSDType.Integer, llsdIntTwo.Type);
            Assert.AreEqual(0, llsdIntTwo.AsInteger());
            LLSDInteger llsdIntThree = (LLSDInteger)llsdArrayThree[1];

            Assert.AreEqual(LLSDType.Integer, llsdIntThree.Type);
            Assert.AreEqual(1, llsdIntThree.AsInteger());

            string    sArrayFour    = " [ \"testtest\", \"aha\",t,f,i1, r1.2, [ i1] ] ";
            LLSDArray llsdArrayFour = (LLSDArray)LLSDParser.DeserializeNotation(sArrayFour);

            Assert.AreEqual(LLSDType.Array, llsdArrayFour.Type);
            Assert.AreEqual(7, llsdArrayFour.Count);
            Assert.AreEqual("testtest", llsdArrayFour[0].AsString());
            Assert.AreEqual("aha", llsdArrayFour[1].AsString());
            Assert.AreEqual(true, llsdArrayFour[2].AsBoolean());
            Assert.AreEqual(false, llsdArrayFour[3].AsBoolean());
            Assert.AreEqual(1, llsdArrayFour[4].AsInteger());
            Assert.AreEqual(1.2d, llsdArrayFour[5].AsReal());
            Assert.AreEqual(LLSDType.Array, llsdArrayFour[6].Type);
            LLSDArray llsdArrayFive = (LLSDArray)llsdArrayFour[6];

            Assert.AreEqual(1, llsdArrayFive[0].AsInteger());
        }
Ejemplo n.º 2
0
        public void DeserializeIntegers()
        {
            LLSD        theLLSD = null;
            LLSDArray   array   = null;
            LLSDInteger tempInt = null;

            String testLLSD = @"<?xml version='1.0' encoding='UTF-8'?>
            <llsd>
                <array>
                    <integer>2147483647</integer>
		            <integer>-2147483648</integer>
		            <integer>0</integer>
                    <integer>013</integer>
                    <integer/>
                </array>
            </llsd>";

            //Deserialize the string
            byte[] bytes = Encoding.UTF8.GetBytes(testLLSD);
            theLLSD = LLSDParser.DeserializeXml(bytes);

            Assert.IsTrue(theLLSD is LLSDArray);
            array = (LLSDArray)theLLSD;

            Assert.AreEqual(LLSDType.Integer, array[0].Type);
            tempInt = (LLSDInteger)array[0];
            Assert.AreEqual(2147483647, tempInt.AsInteger());

            Assert.AreEqual(LLSDType.Integer, array[1].Type);
            tempInt = (LLSDInteger)array[1];
            Assert.AreEqual(-2147483648, tempInt.AsInteger());

            Assert.AreEqual(LLSDType.Integer, array[2].Type);
            tempInt = (LLSDInteger)array[2];
            Assert.AreEqual(0, tempInt.AsInteger());

            Assert.AreEqual(LLSDType.Integer, array[3].Type);
            tempInt = (LLSDInteger)array[3];
            Assert.AreEqual(13, tempInt.AsInteger());

            Assert.AreEqual(LLSDType.Integer, array[4].Type);
            tempInt = (LLSDInteger)array[4];
            Assert.AreEqual(0, tempInt.AsInteger());
        }
Ejemplo n.º 3
0
        public void DeserializeNestedComposite()
        {
            LLSD llsdNested = LLSDParser.DeserializeBinary(binaryNested);

            Assert.AreEqual(LLSDType.Array, llsdNested.Type);
            LLSDArray llsdArray = (LLSDArray)llsdNested;

            Assert.AreEqual(3, llsdArray.Count);

            LLSDMap llsdMap = (LLSDMap)llsdArray[0];

            Assert.AreEqual(LLSDType.Map, llsdMap.Type);
            Assert.AreEqual(2, llsdMap.Count);

            LLSDArray llsdNestedArray = (LLSDArray)llsdMap["t0st"];

            Assert.AreEqual(LLSDType.Array, llsdNestedArray.Type);
            LLSDInteger llsdNestedIntOne = (LLSDInteger)llsdNestedArray[0];

            Assert.AreEqual(LLSDType.Integer, llsdNestedIntOne.Type);
            Assert.AreEqual(1, llsdNestedIntOne.AsInteger());
            LLSDInteger llsdNestedIntTwo = (LLSDInteger)llsdNestedArray[1];

            Assert.AreEqual(LLSDType.Integer, llsdNestedIntTwo.Type);
            Assert.AreEqual(2, llsdNestedIntTwo.AsInteger());

            LLSDString llsdString = (LLSDString)llsdMap["test"];

            Assert.AreEqual(LLSDType.String, llsdString.Type);
            Assert.AreEqual("what", llsdString.AsString());

            LLSDInteger llsdIntOne = (LLSDInteger)llsdArray[1];

            Assert.AreEqual(LLSDType.Integer, llsdIntOne.Type);
            Assert.AreEqual(124, llsdIntOne.AsInteger());
            LLSDInteger llsdIntTwo = (LLSDInteger)llsdArray[2];

            Assert.AreEqual(LLSDType.Integer, llsdIntTwo.Type);
            Assert.AreEqual(987, llsdIntTwo.AsInteger());
        }