public void Serialization_NotSet()
        {
            var stream  = new MemoryStream();
            var message = new TestProto3Optional();

            message.WriteTo(stream);
            Assert.AreEqual(0, stream.Length);
        }
        public void Equality_IgnoresPresence()
        {
            var message1 = new TestProto3Optional {
                OptionalInt32 = 0
            };
            var message2 = new TestProto3Optional();

            Assert.IsTrue(message1.Equals(message2));
            message1.ClearOptionalInt32();
        }
        public void Serialization_SetToDefault()
        {
            var stream  = new MemoryStream();
            var message = new TestProto3Optional {
                OptionalInt32 = 0
            };

            message.WriteTo(stream);
            Assert.AreEqual(2, stream.Length); // Tag and value
        }
        public void WithFormatDefaultValues_DoesNotAffectProto3OptionalFields()
        {
            var message = new TestProto3Optional {
                OptionalInt32 = 0
            };
            var formatter = new JsonFormatter(JsonFormatter.Settings.Default.WithFormatDefaultValues(true));
            var json      = formatter.Format(message);

            // The non-optional proto3 fields are formatted, as is the optional-but-specified field.
            AssertJson("{ 'optionalInt32': 0, 'singularInt32': 0, 'singularInt64': '0' }", json);
        }
        public void Clone()
        {
            var original = new TestProto3Optional {
                OptionalInt64 = 0L
            };

            var clone = original.Clone();

            Assert.False(clone.HasOptionalInt32);
            Assert.AreEqual(0, clone.OptionalInt32);
            Assert.True(clone.HasOptionalInt64);
            Assert.AreEqual(0L, clone.OptionalInt64);
        }
        public void HasValue_Proto3_Primitive_Optional()
        {
            var message  = new TestProto3Optional();
            var accessor = ((IMessage)message).Descriptor.Fields[TestProto3Optional.OptionalInt64FieldNumber].Accessor;

            Assert.IsFalse(accessor.HasValue(message));
            message.OptionalInt64 = 5L;
            Assert.IsTrue(accessor.HasValue(message));
            message.ClearOptionalInt64();
            Assert.IsFalse(accessor.HasValue(message));
            message.OptionalInt64 = 0L;
            Assert.IsTrue(accessor.HasValue(message));
        }
Beispiel #7
0
        public void HasValue_Proto3Optional()
        {
            IMessage message = new TestProto3Optional
            {
                OptionalInt32     = 0,
                LazyNestedMessage = new TestProto3Optional.Types.NestedMessage()
            };
            var fields = message.Descriptor.Fields;

            Assert.IsFalse(fields[TestProto3Optional.OptionalInt64FieldNumber].Accessor.HasValue(message));
            Assert.IsFalse(fields[TestProto3Optional.OptionalNestedMessageFieldNumber].Accessor.HasValue(message));
            Assert.IsTrue(fields[TestProto3Optional.LazyNestedMessageFieldNumber].Accessor.HasValue(message));
            Assert.IsTrue(fields[TestProto3Optional.OptionalInt32FieldNumber].Accessor.HasValue(message));
        }
Beispiel #8
0
        public void Clear_Proto3Optional()
        {
            TestProto3Optional message = new TestProto3Optional
            {
                OptionalInt32         = 0,
                OptionalNestedMessage = new TestProto3Optional.Types.NestedMessage()
            };
            var primitiveField = TestProto3Optional.Descriptor.Fields[TestProto3Optional.OptionalInt32FieldNumber];
            var messageField   = TestProto3Optional.Descriptor.Fields[TestProto3Optional.OptionalNestedMessageFieldNumber];

            Assert.True(message.HasOptionalInt32);
            Assert.NotNull(message.OptionalNestedMessage);

            primitiveField.Accessor.Clear(message);
            messageField.Accessor.Clear(message);

            Assert.False(message.HasOptionalInt32);
            Assert.Null(message.OptionalNestedMessage);
        }
        public void OptionalInt32FieldLifecycle()
        {
            var message = new TestProto3Optional();

            Assert.IsFalse(message.HasOptionalInt32);
            Assert.AreEqual(0, message.OptionalInt32);

            message.OptionalInt32 = 5;
            Assert.IsTrue(message.HasOptionalInt32);
            Assert.AreEqual(5, message.OptionalInt32);

            message.OptionalInt32 = 0;
            Assert.IsTrue(message.HasOptionalInt32);
            Assert.AreEqual(0, message.OptionalInt32);

            message.ClearOptionalInt32();
            Assert.IsFalse(message.HasOptionalInt32);
            Assert.AreEqual(0, message.OptionalInt32);
        }
        public void Serialization_Roundtrip()
        {
            var original = new TestProto3Optional {
                OptionalInt64 = 0L, OptionalFixed32 = 5U
            };
            var stream = new MemoryStream();

            original.WriteTo(stream);
            stream.Position = 0;
            var deserialized = TestProto3Optional.Parser.ParseFrom(stream);

            Assert.AreEqual(0, deserialized.OptionalInt32);
            Assert.IsFalse(deserialized.HasOptionalInt32);

            Assert.AreEqual(0L, deserialized.OptionalInt64);
            Assert.IsTrue(deserialized.HasOptionalInt64);

            Assert.AreEqual(5U, deserialized.OptionalFixed32);
            Assert.IsTrue(deserialized.HasOptionalFixed32);
        }
        public void OptionalStringFieldLifecycle()
        {
            var message = new TestProto3Optional();

            Assert.IsFalse(message.HasOptionalString);
            Assert.AreEqual("", message.OptionalString);

            message.OptionalString = "x";
            Assert.IsTrue(message.HasOptionalString);
            Assert.AreEqual("x", message.OptionalString);

            message.OptionalString = "";
            Assert.IsTrue(message.HasOptionalString);
            Assert.AreEqual("", message.OptionalString);

            message.ClearOptionalString();
            Assert.IsFalse(message.HasOptionalString);
            Assert.AreEqual("", message.OptionalString);

            Assert.Throws <ArgumentNullException>(() => message.OptionalString = null);
        }