public void TestNegativeEnumNoTag()
        {
            Assert.AreEqual(10, CodedOutputStream.ComputeInt32Size(-2));
            Assert.AreEqual(10, CodedOutputStream.ComputeEnumSize((int) SampleEnum.NegativeValue));

            byte[] bytes = new byte[10];
            CodedOutputStream output = CodedOutputStream.CreateInstance(bytes);
            output.WriteEnum((int) SampleEnum.NegativeValue);

            Assert.AreEqual(0, output.SpaceLeft);
            Assert.AreEqual("FE-FF-FF-FF-FF-FF-FF-FF-FF-01", BitConverter.ToString(bytes));
        }
        public void MapWithOnlyKey_MessageValue()
        {
            // Hand-craft the stream to contain a single entry with just a key.
            var memoryStream = new MemoryStream();
            var output       = new CodedOutputStream(memoryStream);

            output.WriteTag(TestMap.MapInt32ForeignMessageFieldNumber, WireFormat.WireType.LengthDelimited);
            int key = 10;

            output.WriteLength(1 + CodedOutputStream.ComputeInt32Size(key));
            output.WriteTag(1, WireFormat.WireType.Varint);
            output.WriteInt32(key);
            output.Flush();

            var parsed = TestMap.Parser.ParseFrom(memoryStream.ToArray());

            Assert.AreEqual(new ForeignMessage(), parsed.MapInt32ForeignMessage[key]);
        }
Esempio n. 3
0
                public int CalculateSize()
                {
                    int num = 0;

                    if (this.Start != 0)
                    {
                        goto IL_5A;
                    }
                    goto IL_90;
                    uint arg_64_0;

                    while (true)
                    {
IL_5F:
                        uint num2;
                        switch ((num2 = (arg_64_0 ^ 2294297653u)) % 5u)
                        {
                        case 0u:
                            goto IL_5A;

                        case 1u:
                            num     += 1 + CodedOutputStream.ComputeInt32Size(this.Start);
                            arg_64_0 = (num2 * 2965579311u ^ 3280985325u);
                            continue;

                        case 3u:
                            num     += 1 + CodedOutputStream.ComputeInt32Size(this.End);
                            arg_64_0 = (num2 * 1126898946u ^ 1656968638u);
                            continue;

                        case 4u:
                            goto IL_90;
                        }
                        break;
                    }
                    return(num);

IL_5A:
                    arg_64_0 = 3483054291u;
                    goto IL_5F;
IL_90:
                    arg_64_0 = ((this.End == 0) ? 3136078798u : 4250872589u);
                    goto IL_5F;
                }
        public void MapWithOnlyKey_PrimitiveValue()
        {
            // Hand-craft the stream to contain a single entry with just a key.
            var memoryStream = new MemoryStream();
            var output       = new CodedOutputStream(memoryStream);

            output.WriteTag(TestMap.MapInt32DoubleFieldNumber, WireFormat.WireType.LengthDelimited);
            int key = 10;

            output.WriteLength(1 + CodedOutputStream.ComputeInt32Size(key));
            output.WriteTag(1, WireFormat.WireType.Varint);
            output.WriteInt32(key);
            output.Flush();

            MessageParsingHelpers.AssertReadingMessage(
                TestMap.Parser,
                memoryStream.ToArray(),
                parsed =>
            {
                Assert.AreEqual(0.0, parsed.MapInt32Double[key]);
            });
        }
Esempio n. 5
0
 public static int ComputeEnumSize(int value)
 {
     return(CodedOutputStream.ComputeInt32Size(value));
 }