Example #1
0
        public void LegacyGeneratedCodeThrowsWithReadOnlySequence()
        {
            var message = new ParseContextEnabledMessageB
            {
                A = new LegacyGeneratedCodeMessageA
                {
                    Bb = new ParseContextEnabledMessageB {
                        OptionalInt32 = 12345
                    }
                },
                OptionalInt32 = 6789
            };
            var data = message.ToByteArray();

            // if parsing started using ReadOnlySequence and we don't have a CodedInputStream
            // instance at hand, we cannot fall back to the legacy MergeFrom(CodedInputStream)
            // method and parsing will fail. As a consequence, one can only use parsing
            // from ReadOnlySequence if all the messages in the parsing tree have their generated
            // code up to date.
            var exception = Assert.Throws <InvalidProtocolBufferException>(() =>
            {
                ParseContext.Initialize(new ReadOnlySequence <byte>(data), out ParseContext parseCtx);
                var parsed = new ParseContextEnabledMessageB();
                ParsingPrimitivesMessages.ReadRawMessage(ref parseCtx, parsed);
            });

            Assert.AreEqual($"Message {typeof(LegacyGeneratedCodeMessageA).Name} doesn't provide the generated method that enables ParseContext-based parsing. You might need to regenerate the generated protobuf code.", exception.Message);
        }
Example #2
0
        public void IntermixingOfNewAndLegacyGeneratedCodeWorksWithCodedInputStream()
        {
            var message = new ParseContextEnabledMessageB
            {
                A = new LegacyGeneratedCodeMessageA
                {
                    Bb = new ParseContextEnabledMessageB {
                        OptionalInt32 = 12345
                    }
                },
                OptionalInt32 = 6789
            };
            var data = message.ToByteArray();

            // when parsing started using CodedInputStream and a message with legacy generated code
            // is encountered somewhere in the parse tree, we still need to be able to use its
            // MergeFrom(CodedInputStream) method to parse correctly.
            var codedInput = new CodedInputStream(data);
            var parsed     = new ParseContextEnabledMessageB();

            codedInput.ReadRawMessage(parsed);
            Assert.IsTrue(codedInput.IsAtEnd);

            Assert.AreEqual(12345, parsed.A.Bb.OptionalInt32);
            Assert.AreEqual(6789, parsed.OptionalInt32);
        }
Example #3
0
        public void LegacyGeneratedCodeThrowsWithIBufferWriter()
        {
            // if serialization started using IBufferWriter and we don't have a CodedOutputStream
            // instance at hand, we cannot fall back to the legacy WriteTo(CodedOutputStream)
            // method and serializatin will fail. As a consequence, one can only use serialization
            // to IBufferWriter if all the messages in the parsing tree have their generated
            // code up to date.
            var message = new ParseContextEnabledMessageB
            {
                A = new LegacyGeneratedCodeMessageA
                {
                    Bb = new ParseContextEnabledMessageB {
                        OptionalInt32 = 12345
                    }
                },
                OptionalInt32 = 6789
            };
            var exception = Assert.Throws <InvalidProtocolBufferException>(() =>
            {
                WriteContext.Initialize(new TestArrayBufferWriter <byte>(), out WriteContext writeCtx);
                ((IBufferMessage)message).InternalWriteTo(ref writeCtx);
            });

            Assert.AreEqual($"Message {typeof(LegacyGeneratedCodeMessageA).Name} doesn't provide the generated method that enables WriteContext-based serialization. You might need to regenerate the generated protobuf code.", exception.Message);
        }
Example #4
0
        public void IntermixingOfNewAndLegacyGeneratedCodeWorksWithCodedOutputStream()
        {
            // when serialization started using CodedOutputStream and a message with legacy generated code
            // is encountered somewhere in the parse tree, we still need to be able to use its
            // WriteTo(CodedOutputStream) method to serialize correctly.
            var ms          = new MemoryStream();
            var codedOutput = new CodedOutputStream(ms);
            var message     = new ParseContextEnabledMessageB
            {
                A = new LegacyGeneratedCodeMessageA
                {
                    Bb = new ParseContextEnabledMessageB {
                        OptionalInt32 = 12345
                    }
                },
                OptionalInt32 = 6789
            };

            message.WriteTo(codedOutput);
            codedOutput.Flush();

            var codedInput = new CodedInputStream(ms.ToArray());
            var parsed     = new ParseContextEnabledMessageB();

            codedInput.ReadRawMessage(parsed);
            Assert.IsTrue(codedInput.IsAtEnd);

            Assert.AreEqual(12345, parsed.A.Bb.OptionalInt32);
            Assert.AreEqual(6789, parsed.OptionalInt32);
        }
Example #5
0
            public void MergeFrom(pb::CodedInputStream input)
            {
                uint tag;

                while ((tag = input.ReadTag()) != 0)
                {
                    switch (tag)
                    {
                    default:
                        _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
                        break;

                    case 10: {
                        if (bb_ == null)
                        {
                            Bb = new ParseContextEnabledMessageB();
                        }
                        input.ReadMessage(Bb);
                        break;
                    }
                    }
                }
            }