summaryrefslogtreecommitdiff
path: root/csharp/src/Google.Protobuf.Test/WellKnownTypes/WrappersTest.cs
diff options
context:
space:
mode:
Diffstat (limited to 'csharp/src/Google.Protobuf.Test/WellKnownTypes/WrappersTest.cs')
-rw-r--r--csharp/src/Google.Protobuf.Test/WellKnownTypes/WrappersTest.cs421
1 files changed, 0 insertions, 421 deletions
diff --git a/csharp/src/Google.Protobuf.Test/WellKnownTypes/WrappersTest.cs b/csharp/src/Google.Protobuf.Test/WellKnownTypes/WrappersTest.cs
deleted file mode 100644
index 5b7185dc..00000000
--- a/csharp/src/Google.Protobuf.Test/WellKnownTypes/WrappersTest.cs
+++ /dev/null
@@ -1,421 +0,0 @@
-#region Copyright notice and license
-// Protocol Buffers - Google's data interchange format
-// Copyright 2015 Google Inc. All rights reserved.
-// https://developers.google.com/protocol-buffers/
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-// * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-// * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-// * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-#endregion
-
-using System;
-using Google.Protobuf.TestProtos;
-using NUnit.Framework;
-using System.Collections;
-using System.IO;
-
-namespace Google.Protobuf.WellKnownTypes
-{
- public class WrappersTest
- {
- [Test]
- public void NullIsDefault()
- {
- var message = new TestWellKnownTypes();
- Assert.IsNull(message.StringField);
- Assert.IsNull(message.BytesField);
- Assert.IsNull(message.BoolField);
- Assert.IsNull(message.FloatField);
- Assert.IsNull(message.DoubleField);
- Assert.IsNull(message.Int32Field);
- Assert.IsNull(message.Int64Field);
- Assert.IsNull(message.Uint32Field);
- Assert.IsNull(message.Uint64Field);
- }
-
- [Test]
- public void NonDefaultSingleValues()
- {
- var message = new TestWellKnownTypes
- {
- StringField = "x",
- BytesField = ByteString.CopyFrom(1, 2, 3),
- BoolField = true,
- FloatField = 12.5f,
- DoubleField = 12.25d,
- Int32Field = 1,
- Int64Field = 2,
- Uint32Field = 3,
- Uint64Field = 4
- };
-
- var bytes = message.ToByteArray();
- var parsed = TestWellKnownTypes.Parser.ParseFrom(bytes);
-
- Assert.AreEqual("x", parsed.StringField);
- Assert.AreEqual(ByteString.CopyFrom(1, 2, 3), parsed.BytesField);
- Assert.AreEqual(true, parsed.BoolField);
- Assert.AreEqual(12.5f, parsed.FloatField);
- Assert.AreEqual(12.25d, parsed.DoubleField);
- Assert.AreEqual(1, parsed.Int32Field);
- Assert.AreEqual(2L, parsed.Int64Field);
- Assert.AreEqual(3U, parsed.Uint32Field);
- Assert.AreEqual(4UL, parsed.Uint64Field);
- }
-
- [Test]
- public void NonNullDefaultIsPreservedThroughSerialization()
- {
- var message = new TestWellKnownTypes
- {
- StringField = "",
- BytesField = ByteString.Empty,
- BoolField = false,
- FloatField = 0f,
- DoubleField = 0d,
- Int32Field = 0,
- Int64Field = 0,
- Uint32Field = 0,
- Uint64Field = 0
- };
-
- var bytes = message.ToByteArray();
- var parsed = TestWellKnownTypes.Parser.ParseFrom(bytes);
-
- Assert.AreEqual("", parsed.StringField);
- Assert.AreEqual(ByteString.Empty, parsed.BytesField);
- Assert.AreEqual(false, parsed.BoolField);
- Assert.AreEqual(0f, parsed.FloatField);
- Assert.AreEqual(0d, parsed.DoubleField);
- Assert.AreEqual(0, parsed.Int32Field);
- Assert.AreEqual(0L, parsed.Int64Field);
- Assert.AreEqual(0U, parsed.Uint32Field);
- Assert.AreEqual(0UL, parsed.Uint64Field);
- }
-
- [Test]
- public void RepeatedWrappersProhibitNullItems()
- {
- var message = new RepeatedWellKnownTypes();
- Assert.Throws<ArgumentNullException>(() => message.BoolField.Add((bool?) null));
- Assert.Throws<ArgumentNullException>(() => message.Int32Field.Add((int?) null));
- Assert.Throws<ArgumentNullException>(() => message.StringField.Add((string) null));
- Assert.Throws<ArgumentNullException>(() => message.BytesField.Add((ByteString) null));
- }
-
- [Test]
- public void RepeatedWrappersSerializeDeserialize()
- {
- var message = new RepeatedWellKnownTypes
- {
- BoolField = { true, false },
- BytesField = { ByteString.CopyFrom(1, 2, 3), ByteString.CopyFrom(4, 5, 6), ByteString.Empty },
- DoubleField = { 12.5, -1.5, 0d },
- FloatField = { 123.25f, -20f, 0f },
- Int32Field = { int.MaxValue, int.MinValue, 0 },
- Int64Field = { long.MaxValue, long.MinValue, 0L },
- StringField = { "First", "Second", "" },
- Uint32Field = { uint.MaxValue, uint.MinValue, 0U },
- Uint64Field = { ulong.MaxValue, ulong.MinValue, 0UL },
- };
- var bytes = message.ToByteArray();
- var parsed = RepeatedWellKnownTypes.Parser.ParseFrom(bytes);
-
- Assert.AreEqual(message, parsed);
- // Just to test a single value for sanity...
- Assert.AreEqual("Second", message.StringField[1]);
- }
-
- [Test]
- public void RepeatedWrappersBinaryFormat()
- {
- // At one point we accidentally used a packed format for repeated wrappers, which is wrong (and weird).
- // This test is just to prove that we use the right format.
-
- var rawOutput = new MemoryStream();
- var output = new CodedOutputStream(rawOutput);
- // Write a value of 5
- output.WriteTag(RepeatedWellKnownTypes.Int32FieldFieldNumber, WireFormat.WireType.LengthDelimited);
- output.WriteLength(2);
- output.WriteTag(WrappersReflection.WrapperValueFieldNumber, WireFormat.WireType.Varint);
- output.WriteInt32(5);
- // Write a value of 0 (empty message)
- output.WriteTag(RepeatedWellKnownTypes.Int32FieldFieldNumber, WireFormat.WireType.LengthDelimited);
- output.WriteLength(0);
- output.Flush();
- var expectedBytes = rawOutput.ToArray();
-
- var message = new RepeatedWellKnownTypes { Int32Field = { 5, 0 } };
- var actualBytes = message.ToByteArray();
- Assert.AreEqual(expectedBytes, actualBytes);
- }
-
- [Test]
- public void MapWrappersSerializeDeserialize()
- {
- // Note: no null values here, as they are prohibited in map fields
- // (despite being representable).
- var message = new MapWellKnownTypes
- {
- BoolField = { { 10, false }, { 20, true } },
- BytesField = {
- { -1, ByteString.CopyFrom(1, 2, 3) },
- { 10, ByteString.CopyFrom(4, 5, 6) },
- { 1000, ByteString.Empty },
- },
- DoubleField = { { 1, 12.5 }, { 10, -1.5 }, { 20, 0d } },
- FloatField = { { 2, 123.25f }, { 3, -20f }, { 4, 0f } },
- Int32Field = { { 5, int.MaxValue }, { 6, int.MinValue }, { 7, 0 } },
- Int64Field = { { 8, long.MaxValue }, { 9, long.MinValue }, { 10, 0L } },
- StringField = { { 11, "First" }, { 12, "Second" }, { 13, "" } },
- Uint32Field = { { 15, uint.MaxValue }, { 16, uint.MinValue }, { 17, 0U } },
- Uint64Field = { { 18, ulong.MaxValue }, { 19, ulong.MinValue }, { 20, 0UL } },
- };
-
- var bytes = message.ToByteArray();
- var parsed = MapWellKnownTypes.Parser.ParseFrom(bytes);
-
- Assert.AreEqual(message, parsed);
- // Just to test a single value for sanity...
- Assert.AreEqual("Second", message.StringField[12]);
- }
-
- [Test]
- public void Reflection_SingleValues()
- {
- var message = new TestWellKnownTypes
- {
- StringField = "x",
- BytesField = ByteString.CopyFrom(1, 2, 3),
- BoolField = true,
- FloatField = 12.5f,
- DoubleField = 12.25d,
- Int32Field = 1,
- Int64Field = 2,
- Uint32Field = 3,
- Uint64Field = 4
- };
- var fields = TestWellKnownTypes.Descriptor.Fields;
-
- Assert.AreEqual("x", fields[TestWellKnownTypes.StringFieldFieldNumber].Accessor.GetValue(message));
- Assert.AreEqual(ByteString.CopyFrom(1, 2, 3), fields[TestWellKnownTypes.BytesFieldFieldNumber].Accessor.GetValue(message));
- Assert.AreEqual(true, fields[TestWellKnownTypes.BoolFieldFieldNumber].Accessor.GetValue(message));
- Assert.AreEqual(12.5f, fields[TestWellKnownTypes.FloatFieldFieldNumber].Accessor.GetValue(message));
- Assert.AreEqual(12.25d, fields[TestWellKnownTypes.DoubleFieldFieldNumber].Accessor.GetValue(message));
- Assert.AreEqual(1, fields[TestWellKnownTypes.Int32FieldFieldNumber].Accessor.GetValue(message));
- Assert.AreEqual(2L, fields[TestWellKnownTypes.Int64FieldFieldNumber].Accessor.GetValue(message));
- Assert.AreEqual(3U, fields[TestWellKnownTypes.Uint32FieldFieldNumber].Accessor.GetValue(message));
- Assert.AreEqual(4UL, fields[TestWellKnownTypes.Uint64FieldFieldNumber].Accessor.GetValue(message));
-
- // And a couple of null fields...
- message.StringField = null;
- message.FloatField = null;
- Assert.IsNull(fields[TestWellKnownTypes.StringFieldFieldNumber].Accessor.GetValue(message));
- Assert.IsNull(fields[TestWellKnownTypes.FloatFieldFieldNumber].Accessor.GetValue(message));
- }
-
- [Test]
- public void Reflection_RepeatedFields()
- {
- // Just a single example... note that we can't have a null value here
- var message = new RepeatedWellKnownTypes { Int32Field = { 1, 2 } };
- var fields = RepeatedWellKnownTypes.Descriptor.Fields;
- var list = (IList) fields[RepeatedWellKnownTypes.Int32FieldFieldNumber].Accessor.GetValue(message);
- CollectionAssert.AreEqual(new[] { 1, 2 }, list);
- }
-
- [Test]
- public void Reflection_MapFields()
- {
- // Just a single example... note that we can't have a null value here despite the value type being int?
- var message = new MapWellKnownTypes { Int32Field = { { 1, 2 } } };
- var fields = MapWellKnownTypes.Descriptor.Fields;
- var dictionary = (IDictionary) fields[MapWellKnownTypes.Int32FieldFieldNumber].Accessor.GetValue(message);
- Assert.AreEqual(2, dictionary[1]);
- }
-
- [Test]
- public void Oneof()
- {
- var message = new OneofWellKnownTypes { EmptyField = new Empty() };
- // Start off with a non-wrapper
- Assert.AreEqual(OneofWellKnownTypes.OneofFieldOneofCase.EmptyField, message.OneofFieldCase);
- AssertOneofRoundTrip(message);
-
- message.StringField = "foo";
- Assert.AreEqual(OneofWellKnownTypes.OneofFieldOneofCase.StringField, message.OneofFieldCase);
- AssertOneofRoundTrip(message);
-
- message.StringField = "foo";
- Assert.AreEqual(OneofWellKnownTypes.OneofFieldOneofCase.StringField, message.OneofFieldCase);
- AssertOneofRoundTrip(message);
-
- message.DoubleField = 0.0f;
- Assert.AreEqual(OneofWellKnownTypes.OneofFieldOneofCase.DoubleField, message.OneofFieldCase);
- AssertOneofRoundTrip(message);
-
- message.DoubleField = 1.0f;
- Assert.AreEqual(OneofWellKnownTypes.OneofFieldOneofCase.DoubleField, message.OneofFieldCase);
- AssertOneofRoundTrip(message);
-
- message.ClearOneofField();
- Assert.AreEqual(OneofWellKnownTypes.OneofFieldOneofCase.None, message.OneofFieldCase);
- AssertOneofRoundTrip(message);
- }
-
- private void AssertOneofRoundTrip(OneofWellKnownTypes message)
- {
- // Normal roundtrip, but explicitly checking the case...
- var bytes = message.ToByteArray();
- var parsed = OneofWellKnownTypes.Parser.ParseFrom(bytes);
- Assert.AreEqual(message, parsed);
- Assert.AreEqual(message.OneofFieldCase, parsed.OneofFieldCase);
- }
-
- [Test]
- [TestCase("x", "y", "y")]
- [TestCase("x", "", "x")]
- [TestCase("x", null, "x")]
- [TestCase("", "y", "y")]
- [TestCase("", "", "")]
- [TestCase("", null, "")]
- [TestCase(null, "y", "y")]
- [TestCase(null, "", "")]
- [TestCase(null, null, null)]
- public void Merging(string original, string merged, string expected)
- {
- var originalMessage = new TestWellKnownTypes { StringField = original };
- var mergingMessage = new TestWellKnownTypes { StringField = merged };
- originalMessage.MergeFrom(mergingMessage);
- Assert.AreEqual(expected, originalMessage.StringField);
-
- // Try it using MergeFrom(CodedInputStream) too...
- originalMessage = new TestWellKnownTypes { StringField = original };
- originalMessage.MergeFrom(mergingMessage.ToByteArray());
- Assert.AreEqual(expected, originalMessage.StringField);
- }
-
- // Merging is odd with wrapper types, due to the way that default values aren't emitted in
- // the binary stream. In fact we cheat a little bit - a message with an explicitly present default
- // value will have that default value ignored. See issue 615. Fixing this would require significant upheaval to
- // the FieldCodec side of things.
- [Test]
- public void MergingStreamExplicitValue()
- {
- var message = new TestWellKnownTypes { Int32Field = 5 };
-
- // Create a byte array which has the data of an Int32Value explicitly containing a value of 0.
- // This wouldn't normally happen.
- byte[] bytes;
- var wrapperTag = WireFormat.MakeTag(TestWellKnownTypes.Int32FieldFieldNumber, WireFormat.WireType.LengthDelimited);
- var valueTag = WireFormat.MakeTag(Int32Value.ValueFieldNumber, WireFormat.WireType.Varint);
- using (var stream = new MemoryStream())
- {
- var coded = new CodedOutputStream(stream);
- coded.WriteTag(wrapperTag);
- coded.WriteLength(2); // valueTag + a value 0, each one byte
- coded.WriteTag(valueTag);
- coded.WriteInt32(0);
- coded.Flush();
- bytes = stream.ToArray();
- }
-
- message.MergeFrom(bytes);
- // A normal implementation would have 0 now, as the explicit default would have been overwritten the 5.
- // With the FieldCodec for Nullable<int>, we can't tell the difference between an implicit 0 and an explicit 0.
- Assert.AreEqual(5, message.Int32Field);
- }
-
- [Test]
- public void MergingStreamNoValue()
- {
- var message = new TestWellKnownTypes { Int32Field = 5 };
-
- // Create a byte array which an Int32 field, but with no value.
- var bytes = new TestWellKnownTypes { Int32Field = 0 }.ToByteArray();
- Assert.AreEqual(2, bytes.Length); // The tag for Int32Field is a single byte, then a byte indicating a 0-length message.
- message.MergeFrom(bytes);
-
- // The "implicit" 0 did *not* overwrite the value.
- // (This is the correct behaviour.)
- Assert.AreEqual(5, message.Int32Field);
- }
-
- // All permutations of origin/merging value being null, zero (default) or non-default.
- // As this is the in-memory version, we don't need to worry about the difference between implicit and explicit 0.
- [Test]
- [TestCase(null, null, null)]
- [TestCase(null, 0, 0)]
- [TestCase(null, 5, 5)]
- [TestCase(0, null, 0)]
- [TestCase(0, 0, 0)]
- [TestCase(0, 5, 5)]
- [TestCase(5, null, 5)]
- [TestCase(5, 0, 5)]
- [TestCase(5, 10, 10)]
- public void MergingMessageWithZero(int? originValue, int? mergingValue, int? expectedResult)
- {
- // This differs from the MergingStreamCornerCase because when we merge message *objects*,
- // we ignore default values from the "source".
- var message1 = new TestWellKnownTypes { Int32Field = originValue };
- var message2 = new TestWellKnownTypes { Int32Field = mergingValue };
- message1.MergeFrom(message2);
- Assert.AreEqual(expectedResult, message1.Int32Field);
- }
-
- [Test]
- public void UnknownFieldInWrapper()
- {
- var stream = new MemoryStream();
- var output = new CodedOutputStream(stream);
- var wrapperTag = WireFormat.MakeTag(TestWellKnownTypes.Int32FieldFieldNumber, WireFormat.WireType.LengthDelimited);
- var unknownTag = WireFormat.MakeTag(15, WireFormat.WireType.Varint);
- var valueTag = WireFormat.MakeTag(Int32Value.ValueFieldNumber, WireFormat.WireType.Varint);
-
- output.WriteTag(wrapperTag);
- output.WriteLength(4); // unknownTag + value 5 + valueType + value 6, each 1 byte
- output.WriteTag(unknownTag);
- output.WriteInt32((int) valueTag); // Sneakily "pretend" it's a tag when it's really a value
- output.WriteTag(valueTag);
- output.WriteInt32(6);
-
- output.Flush();
- stream.Position = 0;
-
- var message = TestWellKnownTypes.Parser.ParseFrom(stream);
- Assert.AreEqual(6, message.Int32Field);
- }
-
- [Test]
- public void ClearWithReflection()
- {
- // String and Bytes are the tricky ones here, as the CLR type of the property
- // is the same between the wrapper and non-wrapper types.
- var message = new TestWellKnownTypes { StringField = "foo" };
- TestWellKnownTypes.Descriptor.Fields[TestWellKnownTypes.StringFieldFieldNumber].Accessor.Clear(message);
- Assert.IsNull(message.StringField);
- }
- }
-}
generated by cgit v1.2.3 (git 2.25.1) at 2024-05-28 21:33:51 +0000