public void TestIBuilderLiteWeakBuildUninitialized()
        {
            IBuilderLite builder = TestRequiredLite.CreateBuilder();

            Assert.IsFalse(builder.IsInitialized);
            builder.WeakBuild();
        }
        public void TestIBuilderLiteWeakBuildUninitialized()
        {
            IBuilderLite builder = TestRequiredLite.CreateBuilder();

            Assert.IsFalse(builder.IsInitialized);
            Assert.Throws <UninitializedMessageException>(() => builder.WeakBuild());
        }
        public void TestIBuilderLiteWeakBuild()
        {
            IBuilderLite builder = TestRequiredLite.CreateBuilder()
                                   .SetD(0)
                                   .SetEn(ExtraEnum.EXLITE_BAZ);

            Assert.IsTrue(builder.IsInitialized);
            builder.WeakBuild();
        }
        public void TestMessageLiteWeakToBuilder()
        {
            IMessageLite msg = TestRequiredLite.CreateBuilder()
                               .SetD(42)
                               .SetEn(ExtraEnum.EXLITE_BAZ)
                               .Build();

            IMessageLite copy = msg.WeakToBuilder().WeakBuild();

            Assert.AreEqual(msg.ToByteArray(), copy.ToByteArray());
        }
        public void TestIBuilderLiteWeakClone()
        {
            TestRequiredLite msg = TestRequiredLite.CreateBuilder()
                                   .SetD(1).SetEn(ExtraEnum.EXLITE_BAR).Build();

            Assert.IsTrue(msg.IsInitialized);

            IMessageLite copy = ((IBuilderLite)msg.ToBuilder()).WeakClone().WeakBuild();

            Assert.AreEqual(msg.ToByteArray(), copy.ToByteArray());
        }
        public void TestMessageLiteWriteTo()
        {
            TestRequiredLite msg = TestRequiredLite.CreateBuilder()
                                   .SetD(42)
                                   .SetEn(ExtraEnum.EXLITE_BAZ)
                                   .Build();

            MemoryStream ms = new MemoryStream();

            msg.WriteTo(ms);
            Assert.AreEqual(msg.ToByteArray(), ms.ToArray());
        }
        public void TestMessageLiteToByteArray()
        {
            TestRequiredLite msg = TestRequiredLite.CreateBuilder()
                                   .SetD(42)
                                   .SetEn(ExtraEnum.EXLITE_BAZ)
                                   .Build();

            ByteString b    = msg.ToByteString();
            ByteString copy = ByteString.CopyFrom(msg.ToByteArray());

            Assert.AreEqual(b, copy);
        }
        public void TestIBuilderLiteWeakBuildPartial()
        {
            IBuilderLite builder = TestRequiredLite.CreateBuilder();

            Assert.IsFalse(builder.IsInitialized);

            IMessageLite msg = builder.WeakBuildPartial();

            Assert.IsFalse(msg.IsInitialized);

            Assert.AreEqual(msg.ToByteArray(), TestRequiredLite.DefaultInstance.ToByteArray());
        }
        public void TestMessageLiteToByteString()
        {
            TestRequiredLite msg = TestRequiredLite.CreateBuilder()
                                   .SetD(42)
                                   .SetEn(ExtraEnum.EXLITE_BAZ)
                                   .Build();

            ByteString b = msg.ToByteString();

            Assert.AreEqual(4, b.Length);
            Assert.AreEqual(TestRequiredLite.DFieldNumber << 3, b[0]);
            Assert.AreEqual(42, b[1]);
            Assert.AreEqual(TestRequiredLite.EnFieldNumber << 3, b[2]);
            Assert.AreEqual((int)ExtraEnum.EXLITE_BAZ, b[3]);
        }
        public void TestPlainBuilder()
        {
            TestRequiredLite.Builder builder = TestRequiredLite.CreateBuilder()
                                               .SetD(42)
            ;

            MemoryStream ms = new MemoryStream();

            new BinaryFormatter().Serialize(ms, builder);

            ms.Position = 0;
            TestRequiredLite.Builder copy = (TestRequiredLite.Builder) new BinaryFormatter().Deserialize(ms);

            Assert.AreEqual(builder.BuildPartial(), copy.BuildPartial());
        }
        public void TestPlainMessage()
        {
            TestRequiredLite message = TestRequiredLite.CreateBuilder()
                                       .SetD(42)
                                       .BuildPartial();

            MemoryStream ms = new MemoryStream();

            new BinaryFormatter().Serialize(ms, message);

            ms.Position = 0;
            TestRequiredLite copy = (TestRequiredLite) new BinaryFormatter().Deserialize(ms);

            Assert.AreEqual(message, copy);
        }
        public void TestMessageLiteWriteDelimitedTo()
        {
            TestRequiredLite msg = TestRequiredLite.CreateBuilder()
                                   .SetD(42)
                                   .SetEn(ExtraEnum.EXLITE_BAZ)
                                   .Build();

            MemoryStream ms = new MemoryStream();

            msg.WriteDelimitedTo(ms);
            byte[] buffer = ms.ToArray();

            Assert.AreEqual(5, buffer.Length);
            Assert.AreEqual(4, buffer[0]);
            byte[] msgBytes = new byte[4];
            Array.Copy(buffer, 1, msgBytes, 0, 4);
            Assert.AreEqual(msg.ToByteArray(), msgBytes);
        }
 public void TestIBuilderLiteWeakDefaultInstance()
 {
     Assert.IsTrue(ReferenceEquals(TestRequiredLite.DefaultInstance,
                                   ((IBuilderLite)TestRequiredLite.CreateBuilder()).WeakDefaultInstanceForType));
 }