diff options
| author |  Jon Skeet <jonskeet@google.com> | 2015-04-30 11:05:36 +0100 |
|---|---|---|
| committer | Jon Skeet <jonskeet@google.com> | 2015-04-30 11:29:35 +0100 |
| commit | c56475088d2d36d29a2640f35b9a8621796c051c (patch) | |
| tree | eee4106598d0faf92b566f7e03930f25df38a56c /csharp/src/ProtocolBuffersLite.Test | |
| parent | ce97e686826147e2a071fd2321555f7d40ec5d93 (diff) | |
Change to using xUnit for all unit tests, and fetch that via NuGet.
This includes fetching the VS unit test runner package, so that tests can be run from Visual Studio's Test Explorer.
Diffstat (limited to 'csharp/src/ProtocolBuffersLite.Test')
12 files changed, 434 insertions, 489 deletions
diff --git a/csharp/src/ProtocolBuffersLite.Test/AbstractBuilderLiteTest.cs b/csharp/src/ProtocolBuffersLite.Test/AbstractBuilderLiteTest.cs index f3a7789e..e0199202 100644 --- a/csharp/src/ProtocolBuffersLite.Test/AbstractBuilderLiteTest.cs +++ b/csharp/src/ProtocolBuffersLite.Test/AbstractBuilderLiteTest.cs @@ -34,19 +34,15 @@ #endregion
-using System;
-using System.Collections.Generic;
using System.IO;
-using Google.ProtocolBuffers;
using Google.ProtocolBuffers.TestProtos;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Xunit;
namespace Google.ProtocolBuffers
{
- [TestClass]
public class AbstractBuilderLiteTest
{
- [TestMethod]
+ [Fact]
public void TestMergeFromCodedInputStream()
{
TestAllTypesLite copy,
@@ -54,7 +50,7 @@ namespace Google.ProtocolBuffers .SetOptionalUint32(uint.MaxValue).Build();
copy = TestAllTypesLite.DefaultInstance;
- Assert.AreNotEqual(msg.ToByteArray(), copy.ToByteArray());
+ Assert.NotEqual(msg.ToByteArray(), copy.ToByteArray());
using (MemoryStream ms = new MemoryStream(msg.ToByteArray()))
{
@@ -62,22 +58,22 @@ namespace Google.ProtocolBuffers copy = copy.ToBuilder().MergeFrom(ci).Build();
}
- TestUtil.AssertBytesEqual(msg.ToByteArray(), copy.ToByteArray());
+ Assert.Equal(msg.ToByteArray(), copy.ToByteArray());
}
- [TestMethod]
+ [Fact]
public void TestIBuilderLiteWeakClear()
{
TestAllTypesLite copy, msg = TestAllTypesLite.DefaultInstance;
copy = msg.ToBuilder().SetOptionalString("Should be removed.").Build();
- Assert.AreNotEqual(msg.ToByteArray(), copy.ToByteArray());
+ Assert.NotEqual(msg.ToByteArray(), copy.ToByteArray());
copy = (TestAllTypesLite) ((IBuilderLite) copy.ToBuilder()).WeakClear().WeakBuild();
- TestUtil.AssertBytesEqual(msg.ToByteArray(), copy.ToByteArray());
+ Assert.Equal(msg.ToByteArray(), copy.ToByteArray());
}
- [TestMethod]
+ [Fact]
public void TestBuilderLiteMergeFromCodedInputStream()
{
TestAllTypesLite copy,
@@ -85,14 +81,14 @@ namespace Google.ProtocolBuffers .SetOptionalString("Should be merged.").Build();
copy = TestAllTypesLite.DefaultInstance;
- Assert.AreNotEqual(msg.ToByteArray(), copy.ToByteArray());
+ Assert.NotEqual(msg.ToByteArray(), copy.ToByteArray());
copy =
copy.ToBuilder().MergeFrom(CodedInputStream.CreateInstance(new MemoryStream(msg.ToByteArray()))).Build();
- TestUtil.AssertBytesEqual(msg.ToByteArray(), copy.ToByteArray());
+ Assert.Equal(msg.ToByteArray(), copy.ToByteArray());
}
- [TestMethod]
+ [Fact]
public void TestBuilderLiteMergeDelimitedFrom()
{
TestAllTypesLite copy,
@@ -100,15 +96,15 @@ namespace Google.ProtocolBuffers .SetOptionalString("Should be merged.").Build();
copy = TestAllTypesLite.DefaultInstance;
- Assert.AreNotEqual(msg.ToByteArray(), copy.ToByteArray());
+ Assert.NotEqual(msg.ToByteArray(), copy.ToByteArray());
Stream s = new MemoryStream();
msg.WriteDelimitedTo(s);
s.Position = 0;
copy = copy.ToBuilder().MergeDelimitedFrom(s).Build();
- TestUtil.AssertBytesEqual(msg.ToByteArray(), copy.ToByteArray());
+ Assert.Equal(msg.ToByteArray(), copy.ToByteArray());
}
- [TestMethod]
+ [Fact]
public void TestBuilderLiteMergeDelimitedFromExtensions()
{
TestAllExtensionsLite copy,
@@ -117,7 +113,7 @@ namespace Google.ProtocolBuffers "Should be merged.").Build();
copy = TestAllExtensionsLite.DefaultInstance;
- Assert.AreNotEqual(msg.ToByteArray(), copy.ToByteArray());
+ Assert.NotEqual(msg.ToByteArray(), copy.ToByteArray());
Stream s = new MemoryStream();
msg.WriteDelimitedTo(s);
@@ -127,11 +123,11 @@ namespace Google.ProtocolBuffers UnittestLite.RegisterAllExtensions(registry);
copy = copy.ToBuilder().MergeDelimitedFrom(s, registry).Build();
- TestUtil.AssertBytesEqual(msg.ToByteArray(), copy.ToByteArray());
- Assert.AreEqual("Should be merged.", copy.GetExtension(UnittestLite.OptionalStringExtensionLite));
+ Assert.Equal(msg.ToByteArray(), copy.ToByteArray());
+ Assert.Equal("Should be merged.", copy.GetExtension(UnittestLite.OptionalStringExtensionLite));
}
- [TestMethod]
+ [Fact]
public void TestBuilderLiteMergeFromStream()
{
TestAllTypesLite copy,
@@ -139,15 +135,15 @@ namespace Google.ProtocolBuffers .SetOptionalString("Should be merged.").Build();
copy = TestAllTypesLite.DefaultInstance;
- Assert.AreNotEqual(msg.ToByteArray(), copy.ToByteArray());
+ Assert.NotEqual(msg.ToByteArray(), copy.ToByteArray());
Stream s = new MemoryStream();
msg.WriteTo(s);
s.Position = 0;
copy = copy.ToBuilder().MergeFrom(s).Build();
- TestUtil.AssertBytesEqual(msg.ToByteArray(), copy.ToByteArray());
+ Assert.Equal(msg.ToByteArray(), copy.ToByteArray());
}
- [TestMethod]
+ [Fact]
public void TestBuilderLiteMergeFromStreamExtensions()
{
TestAllExtensionsLite copy,
@@ -156,7 +152,7 @@ namespace Google.ProtocolBuffers "Should be merged.").Build();
copy = TestAllExtensionsLite.DefaultInstance;
- Assert.AreNotEqual(msg.ToByteArray(), copy.ToByteArray());
+ Assert.NotEqual(msg.ToByteArray(), copy.ToByteArray());
Stream s = new MemoryStream();
msg.WriteTo(s);
@@ -166,11 +162,11 @@ namespace Google.ProtocolBuffers UnittestLite.RegisterAllExtensions(registry);
copy = copy.ToBuilder().MergeFrom(s, registry).Build();
- TestUtil.AssertBytesEqual(msg.ToByteArray(), copy.ToByteArray());
- Assert.AreEqual("Should be merged.", copy.GetExtension(UnittestLite.OptionalStringExtensionLite));
+ Assert.Equal(msg.ToByteArray(), copy.ToByteArray());
+ Assert.Equal("Should be merged.", copy.GetExtension(UnittestLite.OptionalStringExtensionLite));
}
- [TestMethod]
+ [Fact]
public void TestIBuilderLiteWeakMergeFromIMessageLite()
{
TestAllTypesLite copy,
@@ -178,13 +174,13 @@ namespace Google.ProtocolBuffers .SetOptionalString("Should be merged.").Build();
copy = TestAllTypesLite.DefaultInstance;
- Assert.AreNotEqual(msg.ToByteArray(), copy.ToByteArray());
+ Assert.NotEqual(msg.ToByteArray(), copy.ToByteArray());
copy = (TestAllTypesLite) ((IBuilderLite) copy.ToBuilder()).WeakMergeFrom((IMessageLite) msg).WeakBuild();
- TestUtil.AssertBytesEqual(msg.ToByteArray(), copy.ToByteArray());
+ Assert.Equal(msg.ToByteArray(), copy.ToByteArray());
}
- [TestMethod]
+ [Fact]
public void TestIBuilderLiteWeakMergeFromByteString()
{
TestAllTypesLite copy,
@@ -192,13 +188,13 @@ namespace Google.ProtocolBuffers .SetOptionalString("Should be merged.").Build();
copy = TestAllTypesLite.DefaultInstance;
- Assert.AreNotEqual(msg.ToByteArray(), copy.ToByteArray());
+ Assert.NotEqual(msg.ToByteArray(), copy.ToByteArray());
copy = (TestAllTypesLite) ((IBuilderLite) copy.ToBuilder()).WeakMergeFrom(msg.ToByteString()).WeakBuild();
- TestUtil.AssertBytesEqual(msg.ToByteArray(), copy.ToByteArray());
+ Assert.Equal(msg.ToByteArray(), copy.ToByteArray());
}
- [TestMethod]
+ [Fact]
public void TestIBuilderLiteWeakMergeFromByteStringExtensions()
{
TestAllExtensionsLite copy,
@@ -207,12 +203,12 @@ namespace Google.ProtocolBuffers "Should be merged.").Build();
copy = TestAllExtensionsLite.DefaultInstance;
- Assert.AreNotEqual(msg.ToByteArray(), copy.ToByteArray());
+ Assert.NotEqual(msg.ToByteArray(), copy.ToByteArray());
copy =
(TestAllExtensionsLite)
((IBuilderLite) copy.ToBuilder()).WeakMergeFrom(msg.ToByteString(), ExtensionRegistry.Empty).WeakBuild();
- Assert.AreNotEqual(msg.ToByteArray(), copy.ToByteArray());
+ Assert.NotEqual(msg.ToByteArray(), copy.ToByteArray());
ExtensionRegistry registry = ExtensionRegistry.CreateInstance();
UnittestLite.RegisterAllExtensions(registry);
@@ -220,11 +216,11 @@ namespace Google.ProtocolBuffers copy =
(TestAllExtensionsLite)
((IBuilderLite) copy.ToBuilder()).WeakMergeFrom(msg.ToByteString(), registry).WeakBuild();
- TestUtil.AssertBytesEqual(msg.ToByteArray(), copy.ToByteArray());
- Assert.AreEqual("Should be merged.", copy.GetExtension(UnittestLite.OptionalStringExtensionLite));
+ Assert.Equal(msg.ToByteArray(), copy.ToByteArray());
+ Assert.Equal("Should be merged.", copy.GetExtension(UnittestLite.OptionalStringExtensionLite));
}
- [TestMethod]
+ [Fact]
public void TestIBuilderLiteWeakMergeFromCodedInputStream()
{
TestAllTypesLite copy,
@@ -232,7 +228,7 @@ namespace Google.ProtocolBuffers .SetOptionalUint32(uint.MaxValue).Build();
copy = TestAllTypesLite.DefaultInstance;
- Assert.AreNotEqual(msg.ToByteArray(), copy.ToByteArray());
+ Assert.NotEqual(msg.ToByteArray(), copy.ToByteArray());
using (MemoryStream ms = new MemoryStream(msg.ToByteArray()))
{
@@ -240,58 +236,58 @@ namespace Google.ProtocolBuffers copy = (TestAllTypesLite) ((IBuilderLite) copy.ToBuilder()).WeakMergeFrom(ci).WeakBuild();
}
- TestUtil.AssertBytesEqual(msg.ToByteArray(), copy.ToByteArray());
+ Assert.Equal(msg.ToByteArray(), copy.ToByteArray());
}
- [TestMethod]
+ [Fact]
public void TestIBuilderLiteWeakBuildPartial()
{
IBuilderLite builder = TestRequiredLite.CreateBuilder();
- Assert.IsFalse(builder.IsInitialized);
+ Assert.False(builder.IsInitialized);
IMessageLite msg = builder.WeakBuildPartial();
- Assert.IsFalse(msg.IsInitialized);
+ Assert.False(msg.IsInitialized);
- TestUtil.AssertBytesEqual(msg.ToByteArray(), TestRequiredLite.DefaultInstance.ToByteArray());
+ Assert.Equal(msg.ToByteArray(), TestRequiredLite.DefaultInstance.ToByteArray());
}
- [TestMethod, ExpectedException(typeof(UninitializedMessageException))]
+ [Fact]
public void TestIBuilderLiteWeakBuildUninitialized()
{
IBuilderLite builder = TestRequiredLite.CreateBuilder();
- Assert.IsFalse(builder.IsInitialized);
- builder.WeakBuild();
+ Assert.False(builder.IsInitialized);
+ Assert.Throws<UninitializedMessageException>(() => builder.WeakBuild());
}
- [TestMethod]
+ [Fact]
public void TestIBuilderLiteWeakBuild()
{
IBuilderLite builder = TestRequiredLite.CreateBuilder()
.SetD(0)
.SetEn(ExtraEnum.EXLITE_BAZ);
- Assert.IsTrue(builder.IsInitialized);
+ Assert.True(builder.IsInitialized);
builder.WeakBuild();
}
- [TestMethod]
+ [Fact]
public void TestIBuilderLiteWeakClone()
{
TestRequiredLite msg = TestRequiredLite.CreateBuilder()
.SetD(1).SetEn(ExtraEnum.EXLITE_BAR).Build();
- Assert.IsTrue(msg.IsInitialized);
+ Assert.True(msg.IsInitialized);
IMessageLite copy = ((IBuilderLite) msg.ToBuilder()).WeakClone().WeakBuild();
- TestUtil.AssertBytesEqual(msg.ToByteArray(), copy.ToByteArray());
+ Assert.Equal(msg.ToByteArray(), copy.ToByteArray());
}
- [TestMethod]
+ [Fact]
public void TestIBuilderLiteWeakDefaultInstance()
{
- Assert.IsTrue(ReferenceEquals(TestRequiredLite.DefaultInstance,
+ Assert.True(ReferenceEquals(TestRequiredLite.DefaultInstance,
((IBuilderLite) TestRequiredLite.CreateBuilder()).WeakDefaultInstanceForType));
}
- [TestMethod]
+ [Fact]
public void TestGeneratedBuilderLiteAddRange()
{
TestAllTypesLite copy,
@@ -303,11 +299,11 @@ namespace Google.ProtocolBuffers .Build();
copy = msg.DefaultInstanceForType.ToBuilder().MergeFrom(msg).Build();
- TestUtil.AssertBytesEqual(msg.ToByteArray(), copy.ToByteArray());
+ Assert.Equal(msg.ToByteArray(), copy.ToByteArray());
}
// ROK 5/7/2013 Issue #54: should retire all bytes in buffer (bufferSize)
- [TestMethod]
+ [Fact]
public void TestBufferRefillIssue()
{
var ms = new MemoryStream();
@@ -326,15 +322,15 @@ namespace Google.ProtocolBuffers var input = CodedInputStream.CreateInstance(ms);
var builder = BucketOfBytes.CreateBuilder();
input.ReadMessage(builder, ExtensionRegistry.Empty);
- Assert.AreEqual(3005L, input.Position);
- Assert.AreEqual(3000, builder.Value.Length);
+ Assert.Equal(3005L, input.Position);
+ Assert.Equal(3000, builder.Value.Length);
input.ReadMessage(builder, ExtensionRegistry.Empty);
- Assert.AreEqual(5114, input.Position);
- Assert.AreEqual(1000, builder.Value.Length);
+ Assert.Equal(5114, input.Position);
+ Assert.Equal(1000, builder.Value.Length);
input.ReadMessage(builder, ExtensionRegistry.Empty);
- Assert.AreEqual(5217L, input.Position);
- Assert.AreEqual(input.Position, ms.Length);
- Assert.AreEqual(100, builder.Value.Length);
+ Assert.Equal(5217L, input.Position);
+ Assert.Equal(input.Position, ms.Length);
+ Assert.Equal(100, builder.Value.Length);
}
}
}
\ No newline at end of file diff --git a/csharp/src/ProtocolBuffersLite.Test/AbstractMessageLiteTest.cs b/csharp/src/ProtocolBuffersLite.Test/AbstractMessageLiteTest.cs index bead60fb..f6a4e94b 100644 --- a/csharp/src/ProtocolBuffersLite.Test/AbstractMessageLiteTest.cs +++ b/csharp/src/ProtocolBuffersLite.Test/AbstractMessageLiteTest.cs @@ -35,18 +35,15 @@ #endregion
using System;
-using System.Collections.Generic;
using System.IO;
-using Google.ProtocolBuffers;
using Google.ProtocolBuffers.TestProtos;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Xunit;
namespace Google.ProtocolBuffers
{
- [TestClass]
public class AbstractMessageLiteTest
{
- [TestMethod]
+ [Fact]
public void TestMessageLiteToByteString()
{
TestRequiredLite msg = TestRequiredLite.CreateBuilder()
@@ -55,14 +52,14 @@ namespace Google.ProtocolBuffers .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]);
+ Assert.Equal(4, b.Length);
+ Assert.Equal(TestRequiredLite.DFieldNumber << 3, b[0]);
+ Assert.Equal(42, b[1]);
+ Assert.Equal(TestRequiredLite.EnFieldNumber << 3, b[2]);
+ Assert.Equal((int) ExtraEnum.EXLITE_BAZ, b[3]);
}
- [TestMethod]
+ [Fact]
public void TestMessageLiteToByteArray()
{
TestRequiredLite msg = TestRequiredLite.CreateBuilder()
@@ -72,10 +69,10 @@ namespace Google.ProtocolBuffers ByteString b = msg.ToByteString();
ByteString copy = ByteString.CopyFrom(msg.ToByteArray());
- Assert.AreEqual(b, copy);
+ Assert.Equal(b, copy);
}
- [TestMethod]
+ [Fact]
public void TestMessageLiteWriteTo()
{
TestRequiredLite msg = TestRequiredLite.CreateBuilder()
@@ -85,10 +82,10 @@ namespace Google.ProtocolBuffers MemoryStream ms = new MemoryStream();
msg.WriteTo(ms);
- TestUtil.AssertBytesEqual(msg.ToByteArray(), ms.ToArray());
+ Assert.Equal(msg.ToByteArray(), ms.ToArray());
}
- [TestMethod]
+ [Fact]
public void TestMessageLiteWriteDelimitedTo()
{
TestRequiredLite msg = TestRequiredLite.CreateBuilder()
@@ -100,21 +97,21 @@ namespace Google.ProtocolBuffers msg.WriteDelimitedTo(ms);
byte[] buffer = ms.ToArray();
- Assert.AreEqual(5, buffer.Length);
- Assert.AreEqual(4, buffer[0]);
+ Assert.Equal(5, buffer.Length);
+ Assert.Equal(4, buffer[0]);
byte[] msgBytes = new byte[4];
Array.Copy(buffer, 1, msgBytes, 0, 4);
- TestUtil.AssertBytesEqual(msg.ToByteArray(), msgBytes);
+ Assert.Equal(msg.ToByteArray(), msgBytes);
}
- [TestMethod]
+ [Fact]
public void TestIMessageLiteWeakCreateBuilderForType()
{
IMessageLite msg = TestRequiredLite.DefaultInstance;
- Assert.AreEqual(typeof(TestRequiredLite.Builder), msg.WeakCreateBuilderForType().GetType());
+ Assert.Equal(typeof(TestRequiredLite.Builder), msg.WeakCreateBuilderForType().GetType());
}
- [TestMethod]
+ [Fact]
public void TestMessageLiteWeakToBuilder()
{
IMessageLite msg = TestRequiredLite.CreateBuilder()
@@ -123,14 +120,14 @@ namespace Google.ProtocolBuffers .Build();
IMessageLite copy = msg.WeakToBuilder().WeakBuild();
- TestUtil.AssertBytesEqual(msg.ToByteArray(), copy.ToByteArray());
+ Assert.Equal(msg.ToByteArray(), copy.ToByteArray());
}
- [TestMethod]
+ [Fact]
public void TestMessageLiteWeakDefaultInstanceForType()
{
IMessageLite msg = TestRequiredLite.DefaultInstance;
- Assert.IsTrue(Object.ReferenceEquals(TestRequiredLite.DefaultInstance, msg.WeakDefaultInstanceForType));
+ Assert.True(Object.ReferenceEquals(TestRequiredLite.DefaultInstance, msg.WeakDefaultInstanceForType));
}
}
}
\ No newline at end of file diff --git a/csharp/src/ProtocolBuffersLite.Test/ExtendableBuilderLiteTest.cs b/csharp/src/ProtocolBuffersLite.Test/ExtendableBuilderLiteTest.cs index 0430c4a1..5377ea6a 100644 --- a/csharp/src/ProtocolBuffersLite.Test/ExtendableBuilderLiteTest.cs +++ b/csharp/src/ProtocolBuffersLite.Test/ExtendableBuilderLiteTest.cs @@ -35,34 +35,31 @@ #endregion
using System;
-using System.Collections;
using System.Collections.Generic;
-using Google.ProtocolBuffers;
using Google.ProtocolBuffers.TestProtos;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Xunit;
namespace Google.ProtocolBuffers
{
- [TestClass]
public class ExtendableBuilderLiteTest
{
- [TestMethod]
+ [Fact]
public void TestHasExtensionT()
{
TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder()
.SetExtension(UnittestLite.OptionalInt32ExtensionLite, 123);
- Assert.IsTrue(builder.HasExtension(UnittestLite.OptionalInt32ExtensionLite));
+ Assert.True(builder.HasExtension(UnittestLite.OptionalInt32ExtensionLite));
}
- [TestMethod]
+ [Fact]
public void TestHasExtensionTMissing()
{
TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder();
- Assert.IsFalse(builder.HasExtension(UnittestLite.OptionalInt32ExtensionLite));
+ Assert.False(builder.HasExtension(UnittestLite.OptionalInt32ExtensionLite));
}
- [TestMethod]
+ [Fact]
public void TestGetExtensionCountT()
{
TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder()
@@ -70,41 +67,41 @@ namespace Google.ProtocolBuffers .AddExtension(UnittestLite.RepeatedInt32ExtensionLite, 2)
.AddExtension(UnittestLite.RepeatedInt32ExtensionLite, 3);
- Assert.AreEqual(3, builder.GetExtensionCount(UnittestLite.RepeatedInt32ExtensionLite));
+ Assert.Equal(3, builder.GetExtensionCount(UnittestLite.RepeatedInt32ExtensionLite));
}
- [TestMethod]
+ [Fact]
public void TestGetExtensionCountTEmpty()
{
TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder();
- Assert.AreEqual(0, builder.GetExtensionCount(UnittestLite.RepeatedInt32ExtensionLite));
+ Assert.Equal(0, builder.GetExtensionCount(UnittestLite.RepeatedInt32ExtensionLite));
}
- [TestMethod]
+ [Fact]
public void TestGetExtensionTNull()
{
TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder();
string value = builder.GetExtension(UnittestLite.OptionalStringExtensionLite);
- Assert.IsNull(value);
+ Assert.Null(value);
}
- [TestMethod]
+ [Fact]
public void TestGetExtensionTValue()
{
TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder()
.SetExtension(UnittestLite.OptionalInt32ExtensionLite, 3);
- Assert.AreEqual(3, builder.GetExtension(UnittestLite.OptionalInt32ExtensionLite));
+ Assert.Equal(3, builder.GetExtension(UnittestLite.OptionalInt32ExtensionLite));
}
- [TestMethod]
+ [Fact]
public void TestGetExtensionTEmpty()
{
TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder();
- Assert.AreEqual(0, builder.GetExtension(UnittestLite.RepeatedInt32ExtensionLite).Count);
+ Assert.Equal(0, builder.GetExtension(UnittestLite.RepeatedInt32ExtensionLite).Count);
}
- [TestMethod]
+ [Fact]
public void TestGetExtensionTList()
{
TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder()
@@ -113,10 +110,10 @@ namespace Google.ProtocolBuffers .AddExtension(UnittestLite.RepeatedInt32ExtensionLite, 3);
IList<int> values = builder.GetExtension(UnittestLite.RepeatedInt32ExtensionLite);
- Assert.AreEqual(3, values.Count);
+ Assert.Equal(3, values.Count);
}
- [TestMethod]
+ [Fact]
public void TestGetExtensionTIndex()
{
TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder()
@@ -125,17 +122,17 @@ namespace Google.ProtocolBuffers .AddExtension(UnittestLite.RepeatedInt32ExtensionLite, 2);
for (int i = 0; i < 3; i++)
- Assert.AreEqual(i, builder.GetExtension(UnittestLite.RepeatedInt32ExtensionLite, i));
+ Assert.Equal(i, builder.GetExtension(UnittestLite.RepeatedInt32ExtensionLite, i));
}
- [TestMethod, ExpectedException(typeof(ArgumentOutOfRangeException))]
+ [Fact]
public void TestGetExtensionTIndexOutOfRange()
{
TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder();
- builder.GetExtension(UnittestLite.RepeatedInt32ExtensionLite, 0);
+ Assert.Throws<ArgumentOutOfRangeException>(() => builder.GetExtension(UnittestLite.RepeatedInt32ExtensionLite, 0));
}
- [TestMethod]
+ [Fact]
public void TestSetExtensionTIndex()
{
TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder()
@@ -144,107 +141,107 @@ namespace Google.ProtocolBuffers .AddExtension(UnittestLite.RepeatedInt32ExtensionLite, 2);
for (int i = 0; i < 3; i++)
- Assert.AreEqual(i, builder.GetExtension(UnittestLite.RepeatedInt32ExtensionLite, i));
+ Assert.Equal(i, builder.GetExtension(UnittestLite.RepeatedInt32ExtensionLite, i));
builder.SetExtension(UnittestLite.RepeatedInt32ExtensionLite, 0, 5);
builder.SetExtension(UnittestLite.RepeatedInt32ExtensionLite, 1, 6);
builder.SetExtension(UnittestLite.RepeatedInt32ExtensionLite, 2, 7);
for (int i = 0; i < 3; i++)
- Assert.AreEqual(5 + i, builder.GetExtension(UnittestLite.RepeatedInt32ExtensionLite, i));
+ Assert.Equal(5 + i, builder.GetExtension(UnittestLite.RepeatedInt32ExtensionLite, i));
}
- [TestMethod, ExpectedException(typeof(ArgumentOutOfRangeException))]
+ [Fact]
public void TestSetExtensionTIndexOutOfRange()
{
TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder();
- builder.SetExtension(UnittestLite.RepeatedInt32ExtensionLite, 0, -1);
+ Assert.Throws<ArgumentOutOfRangeException>(() => builder.SetExtension(UnittestLite.RepeatedInt32ExtensionLite, 0, -1));
}
- [TestMethod]
+ [Fact]
public void TestClearExtensionTList()
{
TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder()
.AddExtension(UnittestLite.RepeatedInt32ExtensionLite, 0);
- Assert.AreEqual(1, builder.GetExtensionCount(UnittestLite.RepeatedInt32ExtensionLite));
+ Assert.Equal(1, builder.GetExtensionCount(UnittestLite.RepeatedInt32ExtensionLite));
builder.ClearExtension(UnittestLite.RepeatedInt32ExtensionLite);
- Assert.AreEqual(0, builder.GetExtensionCount(UnittestLite.RepeatedInt32ExtensionLite));
+ Assert.Equal(0, builder.GetExtensionCount(UnittestLite.RepeatedInt32ExtensionLite));
}
- [TestMethod]
+ [Fact]
public void TestClearExtensionTValue()
{
TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder()
.SetExtension(UnittestLite.OptionalInt32ExtensionLite, 0);
- Assert.IsTrue(builder.HasExtension(UnittestLite.OptionalInt32ExtensionLite));
+ Assert.True(builder.HasExtension(UnittestLite.OptionalInt32ExtensionLite));
builder.ClearExtension(UnittestLite.OptionalInt32ExtensionLite);
- Assert.IsFalse(builder.HasExtension(UnittestLite.OptionalInt32ExtensionLite));
+ Assert.False(builder.HasExtension(UnittestLite.OptionalInt32ExtensionLite));
}
- [TestMethod]
+ [Fact]
public void TestIndexedByDescriptor()
{
TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder();
- Assert.IsFalse(builder.HasExtension(UnittestLite.OptionalInt32ExtensionLite));
+ Assert.False(builder.HasExtension(UnittestLite.OptionalInt32ExtensionLite));
builder[UnittestLite.OptionalInt32ExtensionLite.Descriptor] = 123;
- Assert.IsTrue(builder.HasExtension(UnittestLite.OptionalInt32ExtensionLite));
- Assert.AreEqual(123, builder.GetExtension(UnittestLite.OptionalInt32ExtensionLite));
+ Assert.True(builder.HasExtension(UnittestLite.OptionalInt32ExtensionLite));
+ Assert.Equal(123, builder.GetExtension(UnittestLite.OptionalInt32ExtensionLite));
}
- [TestMethod]
+ [Fact]
public void TestIndexedByDescriptorAndOrdinal()
{
TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder()
.AddExtension(UnittestLite.RepeatedInt32ExtensionLite, 0);
- Assert.AreEqual(1, builder.GetExtensionCount(UnittestLite.RepeatedInt32ExtensionLite));
+ Assert.Equal(1, builder.GetExtensionCount(UnittestLite.RepeatedInt32ExtensionLite));
IFieldDescriptorLite f = UnittestLite.RepeatedInt32ExtensionLite.Descriptor;
builder[f, 0] = 123;
- Assert.AreEqual(1, builder.GetExtensionCount(UnittestLite.RepeatedInt32ExtensionLite));
- Assert.AreEqual(123, builder.GetExtension(UnittestLite.RepeatedInt32ExtensionLite, 0));
+ Assert.Equal(1, builder.GetExtensionCount(UnittestLite.RepeatedInt32ExtensionLite));
+ Assert.Equal(123, builder.GetExtension(UnittestLite.RepeatedInt32ExtensionLite, 0));
}
- [TestMethod, ExpectedException(typeof(ArgumentOutOfRangeException))]
+ [Fact]
public void TestIndexedByDescriptorAndOrdinalOutOfRange()
{
TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder();
- Assert.AreEqual(0, builder.GetExtensionCount(UnittestLite.RepeatedInt32ExtensionLite));
+ Assert.Equal(0, builder.GetExtensionCount(UnittestLite.RepeatedInt32ExtensionLite));
IFieldDescriptorLite f = UnittestLite.RepeatedInt32ExtensionLite.Descriptor;
- builder[f, 0] = 123;
+ Assert.Throws<ArgumentOutOfRangeException>(() => builder[f, 0] = 123);
}
- [TestMethod]
+ [Fact]
public void TestClearFieldByDescriptor()
{
TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder()
.AddExtension(UnittestLite.RepeatedInt32ExtensionLite, 0);
- Assert.AreEqual(1, builder.GetExtensionCount(UnittestLite.RepeatedInt32ExtensionLite));
+ Assert.Equal(1, builder.GetExtensionCount(UnittestLite.RepeatedInt32ExtensionLite));
IFieldDescriptorLite f = UnittestLite.RepeatedInt32ExtensionLite.Descriptor;
builder.ClearField(f);
- Assert.AreEqual(0, builder.GetExtensionCount(UnittestLite.RepeatedInt32ExtensionLite));
+ Assert.Equal(0, builder.GetExtensionCount(UnittestLite.RepeatedInt32ExtensionLite));
}
- [TestMethod]
+ [Fact]
public void TestAddRepeatedFieldByDescriptor()
{
TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder()
.AddExtension(UnittestLite.RepeatedInt32ExtensionLite, 0);
- Assert.AreEqual(1, builder.GetExtensionCount(UnittestLite.RepeatedInt32ExtensionLite));
+ Assert.Equal(1, builder.GetExtensionCount(UnittestLite.RepeatedInt32ExtensionLite));
IFieldDescriptorLite f = UnittestLite.RepeatedInt32ExtensionLite.Descriptor;
builder.AddRepeatedField(f, 123);
- Assert.AreEqual(2, builder.GetExtensionCount(UnittestLite.RepeatedInt32ExtensionLite));
- Assert.AreEqual(123, builder.GetExtension(UnittestLite.RepeatedInt32ExtensionLite, 1));
+ Assert.Equal(2, builder.GetExtensionCount(UnittestLite.RepeatedInt32ExtensionLite));
+ Assert.Equal(123, builder.GetExtension(UnittestLite.RepeatedInt32ExtensionLite, 1));
}
- [TestMethod]
+ [Fact]
public void TestMissingExtensionsLite()
{
const int optionalInt32 = 12345678;
@@ -255,21 +252,21 @@ namespace Google.ProtocolBuffers builder.AddExtension(UnittestLite.RepeatedDoubleExtensionLite, 1.3);
TestAllExtensionsLite msg = builder.Build();
- Assert.IsTrue(msg.HasExtension(UnittestLite.OptionalInt32ExtensionLite));
- Assert.AreEqual(3, msg.GetExtensionCount(UnittestLite.RepeatedDoubleExtensionLite));
+ Assert.True(msg.HasExtension(UnittestLite.OptionalInt32ExtensionLite));
+ Assert.Equal(3, msg.GetExtensionCount(UnittestLite.RepeatedDoubleExtensionLite));
byte[] bits = msg.ToByteArray();
TestAllExtensionsLite copy = TestAllExtensionsLite.ParseFrom(bits);
- Assert.IsFalse(copy.HasExtension(UnittestLite.OptionalInt32ExtensionLite));
- Assert.AreEqual(0, copy.GetExtensionCount(UnittestLite.RepeatedDoubleExtensionLite));
- Assert.AreNotEqual(msg, copy);
+ Assert.False(copy.HasExtension(UnittestLite.OptionalInt32ExtensionLite));
+ Assert.Equal(0, copy.GetExtensionCount(UnittestLite.RepeatedDoubleExtensionLite));
+ Assert.NotEqual(msg, copy);
//The lite runtime removes all unknown fields and extensions
byte[] copybits = copy.ToByteArray();
- Assert.AreEqual(0, copybits.Length);
+ Assert.Equal(0, copybits.Length);
}
- [TestMethod]
+ [Fact]
public void TestMissingFieldsLite()
{
TestAllTypesLite msg = TestAllTypesLite.CreateBuilder()
@@ -278,12 +275,14 @@ namespace Google.ProtocolBuffers .Build();
byte[] bits = msg.ToByteArray();
- TestAllExtensionsLite copy = TestAllExtensionsLite.ParseFrom(bits);
- Assert.AreNotEqual(msg, copy);
+ IMessageLite copy = TestAllExtensionsLite.ParseFrom(bits);
+ // Use explicit call to Equals to avoid xUnit checking for type equality.
+ Assert.False(msg.Equals(copy));
+ Assert.False(copy.Equals(msg));
//The lite runtime removes all unknown fields and extensions
byte[] copybits = copy.ToByteArray();
- Assert.AreEqual(0, copybits.Length);
+ Assert.Equal(0, copybits.Length);
}
}
}
\ No newline at end of file diff --git a/csharp/src/ProtocolBuffersLite.Test/ExtendableMessageLiteTest.cs b/csharp/src/ProtocolBuffersLite.Test/ExtendableMessageLiteTest.cs index b31fb754..78127445 100644 --- a/csharp/src/ProtocolBuffersLite.Test/ExtendableMessageLiteTest.cs +++ b/csharp/src/ProtocolBuffersLite.Test/ExtendableMessageLiteTest.cs @@ -39,11 +39,10 @@ using System.Collections.Generic; using System.Text;
using Google.ProtocolBuffers;
using Google.ProtocolBuffers.TestProtos;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Xunit;
namespace Google.ProtocolBuffers
{
- [TestClass]
public class ExtendableMessageLiteTest
{
//The lite framework does not make this assertion
@@ -55,7 +54,7 @@ namespace Google.ProtocolBuffers // ForeignMessageLite.DefaultInstance;
//}
- [TestMethod]
+ [Fact]
public void ExtensionWriterTestMessages()
{
TestAllExtensionsLite.Builder b = TestAllExtensionsLite.CreateBuilder().SetExtension(
@@ -67,20 +66,20 @@ namespace Google.ProtocolBuffers UnittestLite.RegisterAllExtensions(registry);
copy = TestAllExtensionsLite.ParseFrom(msg.ToByteArray(), registry);
- TestUtil.AssertBytesEqual(msg.ToByteArray(), copy.ToByteArray());
+ Assert.Equal(msg.ToByteArray(), copy.ToByteArray());
}
- [TestMethod]
+ [Fact]
public void ExtensionWriterIsInitialized()
{
- Assert.IsTrue(ForeignMessageLite.DefaultInstance.IsInitialized);
- Assert.IsTrue(TestPackedExtensionsLite.CreateBuilder().IsInitialized);
- Assert.IsTrue(TestAllExtensionsLite.CreateBuilder().SetExtension(
+ Assert.True(ForeignMessageLite.DefaultInstance.IsInitialized);
+ Assert.True(TestPackedExtensionsLite.CreateBuilder().IsInitialized);
+ Assert.True(TestAllExtensionsLite.CreateBuilder().SetExtension(
UnittestLite.OptionalForeignMessageExtensionLite, ForeignMessageLite.DefaultInstance)
.IsInitialized);
}
- [TestMethod]
+ [Fact]
public void ExtensionWriterTestSetExtensionLists()
{
TestAllExtensionsLite msg, copy;
@@ -96,13 +95,13 @@ namespace Google.ProtocolBuffers UnittestLite.RegisterAllExtensions(registry);
copy = TestAllExtensionsLite.ParseFrom(msg.ToByteArray(), registry);
- TestUtil.AssertBytesEqual(msg.ToByteArray(), copy.ToByteArray());
+ Assert.Equal(msg.ToByteArray(), copy.ToByteArray());
- Assert.AreEqual(ForeignEnumLite.FOREIGN_LITE_FOO,
+ Assert.Equal(ForeignEnumLite.FOREIGN_LITE_FOO,
copy.GetExtension(UnittestLite.RepeatedForeignEnumExtensionLite, 1));
}
- [TestMethod]
+ [Fact]
public void ExtensionWriterTest()
{
TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder()
@@ -181,82 +180,82 @@ namespace Google.ProtocolBuffers TestAllExtensionsLite.CreateBuilder().MergeFrom(msg.ToByteArray(), registry);
TestAllExtensionsLite copy = copyBuilder.Build();
- TestUtil.AssertBytesEqual(msg.ToByteArray(), copy.ToByteArray());
+ Assert.Equal(msg.ToByteArray(), copy.ToByteArray());
- Assert.AreEqual(true, copy.GetExtension(UnittestLite.DefaultBoolExtensionLite));
- Assert.AreEqual(ByteString.CopyFromUtf8("123"),
+ Assert.Equal(true, copy.GetExtension(UnittestLite.DefaultBoolExtensionLite));
+ Assert.Equal(ByteString.CopyFromUtf8("123"),
copy.GetExtension(UnittestLite.DefaultBytesExtensionLite));
- Assert.AreEqual("123", copy.GetExtension(UnittestLite.DefaultCordExtensionLite));
- Assert.AreEqual(123, copy.GetExtension(UnittestLite.DefaultDoubleExtensionLite));
- Assert.AreEqual(123u, copy.GetExtension(UnittestLite.DefaultFixed32ExtensionLite));
- Assert.AreEqual(123u, copy.GetExtension(UnittestLite.DefaultFixed64ExtensionLite));
- Assert.AreEqual(123, copy.GetExtension(UnittestLite.DefaultFloatExtensionLite));
- Assert.AreEqual(ForeignEnumLite.FOREIGN_LITE_BAZ,
+ Assert.Equal("123", copy.GetExtension(UnittestLite.DefaultCordExtensionLite));
+ Assert.Equal(123, copy.GetExtension(UnittestLite.DefaultDoubleExtensionLite));
+ Assert.Equal(123u, copy.GetExtension(UnittestLite.DefaultFixed32ExtensionLite));
+ Assert.Equal(123u, copy.GetExtension(UnittestLite.DefaultFixed64ExtensionLite));
+ Assert.Equal(123, copy.GetExtension(UnittestLite.DefaultFloatExtensionLite));
+ Assert.Equal(ForeignEnumLite.FOREIGN_LITE_BAZ,
copy.GetExtension(UnittestLite.DefaultForeignEnumExtensionLite));
- Assert.AreEqual(ImportEnumLite.IMPORT_LITE_BAZ,
+ Assert.Equal(ImportEnumLite.IMPORT_LITE_BAZ,
copy.GetExtension(UnittestLite.DefaultImportEnumExtensionLite));
- Assert.AreEqual(123, copy.GetExtension(UnittestLite.DefaultInt32ExtensionLite));
- Assert.AreEqual(123, copy.GetExtension(UnittestLite.DefaultInt64ExtensionLite));
- Assert.AreEqual(TestAllTypesLite.Types.NestedEnum.FOO,
+ Assert.Equal(123, copy.GetExtension(UnittestLite.DefaultInt32ExtensionLite));
+ Assert.Equal(123, copy.GetExtension(UnittestLite.DefaultInt64ExtensionLite));
+ Assert.Equal(TestAllTypesLite.Types.NestedEnum.FOO,
copy.GetExtension(UnittestLite.DefaultNestedEnumExtensionLite));
- Assert.AreEqual(123, copy.GetExtension(UnittestLite.DefaultSfixed32ExtensionLite));
- Assert.AreEqual(123, copy.GetExtension(UnittestLite.DefaultSfixed64ExtensionLite));
- Assert.AreEqual(123, copy.GetExtension(UnittestLite.DefaultSint32ExtensionLite));
- Assert.AreEqual(123, copy.GetExtension(UnittestLite.DefaultSint64ExtensionLite));
- Assert.AreEqual("123", copy.GetExtension(UnittestLite.DefaultStringExtensionLite));
- Assert.AreEqual("123", copy.GetExtension(UnittestLite.DefaultStringPieceExtensionLite));
- Assert.AreEqual(123u, copy.GetExtension(UnittestLite.DefaultUint32ExtensionLite));
- Assert.AreEqual(123u, copy.GetExtension(UnittestLite.DefaultUint64ExtensionLite));
-
- Assert.AreEqual(true, copy.GetExtension(UnittestLite.OptionalBoolExtensionLite));
- Assert.AreEqual(ByteString.CopyFromUtf8("123"),
+ Assert.Equal(123, copy.GetExtension(UnittestLite.DefaultSfixed32ExtensionLite));
+ Assert.Equal(123, copy.GetExtension(UnittestLite.DefaultSfixed64ExtensionLite));
+ Assert.Equal(123, copy.GetExtension(UnittestLite.DefaultSint32ExtensionLite));
+ Assert.Equal(123, copy.GetExtension(UnittestLite.DefaultSint64ExtensionLite));
+ Assert.Equal("123", copy.GetExtension(UnittestLite.DefaultStringExtensionLite));
+ Assert.Equal("123", copy.GetExtension(UnittestLite.DefaultStringPieceExtensionLite));
+ Assert.Equal(123u, copy.GetExtension(UnittestLite.DefaultUint32ExtensionLite));
+ Assert.Equal(123u, copy.GetExtension(UnittestLite.DefaultUint64ExtensionLite));
+
+ Assert.Equal(true, copy.GetExtension(UnittestLite.OptionalBoolExtensionLite));
+ Assert.Equal(ByteString.CopyFromUtf8("123"),
copy.GetExtension(UnittestLite.OptionalBytesExtensionLite));
- Assert.AreEqual("123", copy.GetExtension(UnittestLite.OptionalCordExtensionLite));
- Assert.AreEqual(123, copy.GetExtension(UnittestLite.OptionalDoubleExtensionLite));
- Assert.AreEqual(123u, copy.GetExtension(UnittestLite.OptionalFixed32ExtensionLite));
- Assert.AreEqual(123u, copy.GetExtension(UnittestLite.OptionalFixed64ExtensionLite));
- Assert.AreEqual(123, copy.GetExtension(UnittestLite.OptionalFloatExtensionLite));
- Assert.AreEqual(ForeignEnumLite.FOREIGN_LITE_BAZ,
+ Assert.Equal("123", copy.GetExtension(UnittestLite.OptionalCordExtensionLite));
+ Assert.Equal(123, copy.GetExtension(UnittestLite.OptionalDoubleExtensionLite));
+ Assert.Equal(123u, copy.GetExtension(UnittestLite.OptionalFixed32ExtensionLite));
+ Assert.Equal(123u, copy.GetExtension(UnittestLite.OptionalFixed64ExtensionLite));
+ Assert.Equal(123, copy.GetExtension(UnittestLite.OptionalFloatExtensionLite));
+ Assert.Equal(ForeignEnumLite.FOREIGN_LITE_BAZ,
copy.GetExtension(UnittestLite.OptionalForeignEnumExtensionLite));
- Assert.AreEqual(ImportEnumLite.IMPORT_LITE_BAZ,
+ Assert.Equal(ImportEnumLite.IMPORT_LITE_BAZ,
copy.GetExtension(UnittestLite.OptionalImportEnumExtensionLite));
- Assert.AreEqual(123, copy.GetExtension(UnittestLite.OptionalInt32ExtensionLite));
- Assert.AreEqual(123, copy.GetExtension(UnittestLite.OptionalInt64ExtensionLite));
- Assert.AreEqual(TestAllTypesLite.Types.NestedEnum.FOO,
+ Assert.Equal(123, copy.GetExtension(UnittestLite.OptionalInt32ExtensionLite));
+ Assert.Equal(123, copy.GetExtension(UnittestLite.OptionalInt64ExtensionLite));
+ Assert.Equal(TestAllTypesLite.Types.NestedEnum.FOO,
copy.GetExtension(UnittestLite.OptionalNestedEnumExtensionLite));
- Assert.AreEqual(123, copy.GetExtension(UnittestLite.OptionalSfixed32ExtensionLite));
- Assert.AreEqual(123, copy.GetExtension(UnittestLite.OptionalSfixed64ExtensionLite));
- Assert.AreEqual(123, copy.GetExtension(UnittestLite.OptionalSint32ExtensionLite));
- Assert.AreEqual(123, copy.GetExtension(UnittestLite.OptionalSint64ExtensionLite));
- Assert.AreEqual("123", copy.GetExtension(UnittestLite.OptionalStringExtensionLite));
- Assert.AreEqual("123", copy.GetExtension(UnittestLite.OptionalStringPieceExtensionLite));
- Assert.AreEqual(123u, copy.GetExtension(UnittestLite.OptionalUint32ExtensionLite));
- Assert.AreEqual(123u, copy.GetExtension(UnittestLite.OptionalUint64ExtensionLite));
-
- Assert.AreEqual(true, copy.GetExtension(UnittestLite.RepeatedBoolExtensionLite, 0));
- Assert.AreEqual(ByteString.CopyFromUtf8("123"),
+ Assert.Equal(123, copy.GetExtension(UnittestLite.OptionalSfixed32ExtensionLite));
+ Assert.Equal(123, copy.GetExtension(UnittestLite.OptionalSfixed64ExtensionLite));
+ Assert.Equal(123, copy.GetExtension(UnittestLite.OptionalSint32ExtensionLite));
+ Assert.Equal(123, copy.GetExtension(UnittestLite.OptionalSint64ExtensionLite));
+ Assert.Equal("123", copy.GetExtension(UnittestLite.OptionalStringExtensionLite));
+ Assert.Equal("123", copy.GetExtension(UnittestLite.OptionalStringPieceExtensionLite));
+ Assert.Equal(123u, copy.GetExtension(UnittestLite.OptionalUint32ExtensionLite));
+ Assert.Equal(123u, copy.GetExtension(UnittestLite.OptionalUint64ExtensionLite));
+
+ Assert.Equal(true, copy.GetExtension(UnittestLite.RepeatedBoolExtensionLite, 0));
+ Assert.Equal(ByteString.CopyFromUtf8("123"),
copy.GetExtension(UnittestLite.RepeatedBytesExtensionLite, 0));
- Assert.AreEqual("123", copy.GetExtension(UnittestLite.RepeatedCordExtensionLite, 0));
- Assert.AreEqual(123, copy.GetExtension(UnittestLite.RepeatedDoubleExtensionLite, 0));
- Assert.AreEqual(123u, copy.GetExtension(UnittestLite.RepeatedFixed32ExtensionLite, 0));
- Assert.AreEqual(123u, copy.GetExtension(UnittestLite.RepeatedFixed64ExtensionLite, 0));
- Assert.AreEqual(123, copy.GetExtension(UnittestLite.RepeatedFloatExtensionLite, 0));
- Assert.AreEqual(ForeignEnumLite.FOREIGN_LITE_BAZ,
+ Assert.Equal("123", copy.GetExtension(UnittestLite.RepeatedCordExtensionLite, 0));
+ Assert.Equal(123, copy.GetExtension(UnittestLite.RepeatedDoubleExtensionLite, 0));
+ Assert.Equal(123u, copy.GetExtension(UnittestLite.RepeatedFixed32ExtensionLite, 0));
+ Assert.Equal(123u, copy.GetExtension(UnittestLite.RepeatedFixed64ExtensionLite, 0));
+ Assert.Equal(123, copy.GetExtension(UnittestLite.RepeatedFloatExtensionLite, 0));
+ Assert.Equal(ForeignEnumLite.FOREIGN_LITE_BAZ,
copy.GetExtension(UnittestLite.RepeatedForeignEnumExtensionLite, 0));
- Assert.AreEqual(ImportEnumLite.IMPORT_LITE_BAZ,
+ Assert.Equal(ImportEnumLite.IMPORT_LITE_BAZ,
copy.GetExtension(UnittestLite.RepeatedImportEnumExtensionLite, 0));
- Assert.AreEqual(123, copy.GetExtension(UnittestLite.RepeatedInt32ExtensionLite, 0));
- Assert.AreEqual(123, copy.GetExtension(UnittestLite.RepeatedInt64ExtensionLite, 0));
- Assert.AreEqual(TestAllTypesLite.Types.NestedEnum.FOO,
+ Assert.Equal(123, copy.GetExtension(UnittestLite.RepeatedInt32ExtensionLite, 0));
+ Assert.Equal(123, copy.GetExtension(UnittestLite.RepeatedInt64ExtensionLite, 0));
+ Assert.Equal(TestAllTypesLite.Types.NestedEnum.FOO,
copy.GetExtension(UnittestLite.RepeatedNestedEnumExtensionLite, 0));
- Assert.AreEqual(123, copy.GetExtension(UnittestLite.RepeatedSfixed32ExtensionLite, 0));
- Assert.AreEqual(123, copy.GetExtension(UnittestLite.RepeatedSfixed64ExtensionLite, 0));
- Assert.AreEqual(123, copy.GetExtension(UnittestLite.RepeatedSint32ExtensionLite, 0));
- Assert.AreEqual(123, copy.GetExtension(UnittestLite.RepeatedSint64ExtensionLite, 0));
- Assert.AreEqual("123", copy.GetExtension(UnittestLite.RepeatedStringExtensionLite, 0));
- Assert.AreEqual("123", copy.GetExtension(UnittestLite.RepeatedStringPieceExtensionLite, 0));
- Assert.AreEqual(123u, copy.GetExtension(UnittestLite.RepeatedUint32ExtensionLite, 0));
- Assert.AreEqual(123u, copy.GetExtension(UnittestLite.RepeatedUint64ExtensionLite, 0));
+ Assert.Equal(123, copy.GetExtension(UnittestLite.RepeatedSfixed32ExtensionLite, 0));
+ Assert.Equal(123, copy.GetExtension(UnittestLite.RepeatedSfixed64ExtensionLite, 0));
+ Assert.Equal(123, copy.GetExtension(UnittestLite.RepeatedSint32ExtensionLite, 0));
+ Assert.Equal(123, copy.GetExtension(UnittestLite.RepeatedSint64ExtensionLite, 0));
+ Assert.Equal("123", copy.GetExtension(UnittestLite.RepeatedStringExtensionLite, 0));
+ Assert.Equal("123", copy.GetExtension(UnittestLite.RepeatedStringPieceExtensionLite, 0));
+ Assert.Equal(123u, copy.GetExtension(UnittestLite.RepeatedUint32ExtensionLite, 0));
+ Assert.Equal(123u, copy.GetExtension(UnittestLite.RepeatedUint64ExtensionLite, 0));
}
private TestPackedExtensionsLite BuildPackedExtensions()
@@ -295,36 +294,36 @@ namespace Google.ProtocolBuffers private void AssertPackedExtensions(TestPackedExtensionsLite copy)
{
- Assert.AreEqual(true, copy.GetExtension(UnittestLite.PackedBoolExtensionLite, 0));
- Assert.AreEqual(123, copy.GetExtension(UnittestLite.PackedDoubleExtensionLite, 0));
- Assert.AreEqual(123u, copy.GetExtension(UnittestLite.PackedFixed32ExtensionLite, 0));
- Assert.AreEqual(123u, copy.GetExtension(UnittestLite.PackedFixed64ExtensionLite, 0));
- Assert.AreEqual(123, copy.GetExtension(UnittestLite.PackedFloatExtensionLite, 0));
- Assert.AreEqual(123, copy.GetExtension(UnittestLite.PackedInt32ExtensionLite, 0));
- Assert.AreEqual(123, copy.GetExtension(UnittestLite.PackedInt64ExtensionLite, 0));
- Assert.AreEqual(123, copy.GetExtension(UnittestLite.PackedSfixed32ExtensionLite, 0));
- Assert.AreEqual(123, copy.GetExtension(UnittestLite.PackedSfixed64ExtensionLite, 0));
- Assert.AreEqual(123, copy.GetExtension(UnittestLite.PackedSint32ExtensionLite, 0));
- Assert.AreEqual(123, copy.GetExtension(UnittestLite.PackedSint64ExtensionLite, 0));
- Assert.AreEqual(123u, copy.GetExtension(UnittestLite.PackedUint32ExtensionLite, 0));
- Assert.AreEqual(123u, copy.GetExtension(UnittestLite.PackedUint64ExtensionLite, 0));
-
- Assert.AreEqual(true, copy.GetExtension(UnittestLite.PackedBoolExtensionLite, 1));
- Assert.AreEqual(123, copy.GetExtension(UnittestLite.PackedDoubleExtensionLite, 1));
- Assert.AreEqual(123u, copy.GetExtension(UnittestLite.PackedFixed32ExtensionLite, 1));
- Assert.AreEqual(123u, copy.GetExtension(UnittestLite.PackedFixed64ExtensionLite, 1));
- Assert.AreEqual(123, copy.GetExtension(UnittestLite.PackedFloatExtensionLite, 1));
- Assert.AreEqual(123, copy.GetExtension(UnittestLite.PackedInt32ExtensionLite, 1));
- Assert.AreEqual(123, copy.GetExtension(UnittestLite.PackedInt64ExtensionLite, 1));
- Assert.AreEqual(123, copy.GetExtension(UnittestLite.PackedSfixed32ExtensionLite, 1));
- Assert.AreEqual(123, copy.GetExtension(UnittestLite.PackedSfixed64ExtensionLite, 1));
- Assert.AreEqual(123, copy.GetExtension(UnittestLite.PackedSint32ExtensionLite, 1));
- Assert.AreEqual(123, copy.GetExtension(UnittestLite.PackedSint64ExtensionLite, 1));
- Assert.AreEqual(123u, copy.GetExtension(UnittestLite.PackedUint32ExtensionLite, 1));
- Assert.AreEqual(123u, copy.GetExtension(UnittestLite.PackedUint64ExtensionLite, 1));
+ Assert.Equal(true, copy.GetExtension(UnittestLite.PackedBoolExtensionLite, 0));
+ Assert.Equal(123, copy.GetExtension(UnittestLite.PackedDoubleExtensionLite, 0));
+ Assert.Equal(123u, copy.GetExtension(UnittestLite.PackedFixed32ExtensionLite, 0));
+ Assert.Equal(123u, copy.GetExtension(UnittestLite.PackedFixed64ExtensionLite, 0));
+ Assert.Equal(123, copy.GetExtension(UnittestLite.PackedFloatExtensionLite, 0));
+ Assert.Equal(123, copy.GetExtension(UnittestLite.PackedInt32ExtensionLite, 0));
+ Assert.Equal(123, copy.GetExtension(UnittestLite.PackedInt64ExtensionLite, 0));
+ Assert.Equal(123, copy.GetExtension(UnittestLite.PackedSfixed32ExtensionLite, 0));
+ Assert.Equal(123, copy.GetExtension(UnittestLite.PackedSfixed64ExtensionLite, 0));
+ Assert.Equal(123, copy.GetExtension(UnittestLite.PackedSint32ExtensionLite, 0));
+ Assert.Equal(123, copy.GetExtension(UnittestLite.PackedSint64ExtensionLite, 0));
+ Assert.Equal(123u, copy.GetExtension(UnittestLite.PackedUint32ExtensionLite, 0));
+ Assert.Equal(123u, copy.GetExtension(UnittestLite.PackedUint64ExtensionLite, 0));
+
+ Assert.Equal(true, copy.GetExtension(UnittestLite.PackedBoolExtensionLite, 1));
+ Assert.Equal(123, copy.GetExtension(UnittestLite.PackedDoubleExtensionLite, 1));
+ Assert.Equal(123u, copy.GetExtension(UnittestLite.PackedFixed32ExtensionLite, 1));
+ Assert.Equal(123u, copy.GetExtension(UnittestLite.PackedFixed64ExtensionLite, 1));
+ Assert.Equal(123, copy.GetExtension(UnittestLite.PackedFloatExtensionLite, 1));
+ Assert.Equal(123, copy.GetExtension(UnittestLite.PackedInt32ExtensionLite, 1));
+ Assert.Equal(123, copy.GetExtension(UnittestLite.PackedInt64ExtensionLite, 1));
+ Assert.Equal(123, copy.GetExtension(UnittestLite.PackedSfixed32ExtensionLite, 1));
+ Assert.Equal(123, copy.GetExtension(UnittestLite.PackedSfixed64ExtensionLite, 1));
+ Assert.Equal(123, copy.GetExtension(UnittestLite.PackedSint32ExtensionLite, 1));
+ Assert.Equal(123, copy.GetExtension(UnittestLite.PackedSint64ExtensionLite, 1));
+ Assert.Equal(123u, copy.GetExtension(UnittestLite.PackedUint32ExtensionLite, 1));
+ Assert.Equal(123u, copy.GetExtension(UnittestLite.PackedUint64ExtensionLite, 1));
}
- [TestMethod]
+ [Fact]
public void ExtensionWriterTestPacked()
{
TestPackedExtensionsLite msg = BuildPackedExtensions();
@@ -336,12 +335,12 @@ namespace Google.ProtocolBuffers TestPackedExtensionsLite.CreateBuilder().MergeFrom(msg.ToByteArray(), registry);
TestPackedExtensionsLite copy = copyBuilder.Build();
- TestUtil.AssertBytesEqual(msg.ToByteArray(), copy.ToByteArray());
+ Assert.Equal(msg.ToByteArray(), copy.ToByteArray());
AssertPackedExtensions(copy);
}
- [TestMethod]
+ [Fact]
public void TestUnpackedAndPackedExtensions()
{
TestPackedExtensionsLite original = BuildPackedExtensions();
@@ -355,19 +354,19 @@ namespace Google.ProtocolBuffers TestPackedExtensionsLite packed = TestPackedExtensionsLite.ParseFrom(unpacked.ToByteArray(), registry);
- Assert.AreEqual(original, packed);
- TestUtil.AssertBytesEqual(original.ToByteArray(), packed.ToByteArray());
+ Assert.Equal(original, packed);
+ Assert.Equal(original.ToByteArray(), packed.ToByteArray());
AssertPackedExtensions(packed);
}
- [TestMethod]
+ [Fact]
public void TestUnpackedFromPackedInput()
{
byte[] packedData = BuildPackedExtensions().ToByteArray();
TestUnpackedTypesLite unpacked = TestUnpackedTypesLite.ParseFrom(packedData);
TestPackedTypesLite packed = TestPackedTypesLite.ParseFrom(unpacked.ToByteArray());
- TestUtil.AssertBytesEqual(packedData, packed.ToByteArray());
+ Assert.Equal(packedData, packed.ToByteArray());
unpacked = TestUnpackedTypesLite.ParseFrom(packed.ToByteArray());
diff --git a/csharp/src/ProtocolBuffersLite.Test/InteropLiteTest.cs b/csharp/src/ProtocolBuffersLite.Test/InteropLiteTest.cs index 0640a445..7feb0448 100644 --- a/csharp/src/ProtocolBuffersLite.Test/InteropLiteTest.cs +++ b/csharp/src/ProtocolBuffersLite.Test/InteropLiteTest.cs @@ -35,31 +35,28 @@ #endregion
using System;
-using System.Collections.Generic;
-using Google.ProtocolBuffers;
using Google.ProtocolBuffers.TestProtos;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Xunit;
namespace Google.ProtocolBuffers
{
- [TestClass]
public class InteropLiteTest
{
- [TestMethod]
+ [Fact]
public void TestConvertFromFullMinimal()
{
TestInteropPerson person = TestInteropPerson.CreateBuilder()
.SetId(123)
.SetName("abc")
.Build();
- Assert.IsTrue(person.IsInitialized);
+ Assert.True(person.IsInitialized);
TestInteropPersonLite copy = TestInteropPersonLite.ParseFrom(person.ToByteArray());
- TestUtil.AssertBytesEqual(person.ToByteArray(), copy.ToByteArray());
+ Assert.Equal(person.ToByteArray(), copy.ToByteArray());
}
- [TestMethod]
+ [Fact]
public void TestConvertFromFullComplete()
{
TestInteropPerson person = TestInteropPerson.CreateBuilder()
@@ -75,7 +72,7 @@ namespace Google.ProtocolBuffers .SetExtension(UnittestExtrasFull.EmployeeId,
TestInteropEmployeeId.CreateBuilder().SetNumber("123").Build())
.Build();
- Assert.IsTrue(person.IsInitialized);
+ Assert.True(person.IsInitialized);
ExtensionRegistry registry = ExtensionRegistry.CreateInstance();
UnittestExtrasLite.RegisterAllExtensions(registry);
@@ -84,24 +81,24 @@ namespace Google.ProtocolBuffers TestInteropPersonLite copy = TestInteropPersonLite.ParseFrom(fullBytes, registry);
byte[] liteBytes = copy.ToByteArray();
- TestUtil.AssertBytesEqual(fullBytes, liteBytes);
+ Assert.Equal(fullBytes, liteBytes);
}
- [TestMethod]
+ [Fact]
public void TestConvertFromLiteMinimal()
{
TestInteropPersonLite person = TestInteropPersonLite.CreateBuilder()
.SetId(123)
.SetName("abc")
.Build();
- Assert.IsTrue(person.IsInitialized);
+ Assert.True(person.IsInitialized);
TestInteropPerson copy = TestInteropPerson.ParseFrom(person.ToByteArray());
- TestUtil.AssertBytesEqual(person.ToByteArray(), copy.ToByteArray());
+ Assert.Equal(person.ToByteArray(), copy.ToByteArray());
}
- [TestMethod]
+ [Fact]
public void TestConvertFromLiteComplete()
{
TestInteropPersonLite person = TestInteropPersonLite.CreateBuilder()
@@ -117,14 +114,14 @@ namespace Google.ProtocolBuffers .SetExtension(UnittestExtrasLite.EmployeeIdLite,
TestInteropEmployeeIdLite.CreateBuilder().SetNumber("123").Build())
.Build();
- Assert.IsTrue(person.IsInitialized);
+ Assert.True(person.IsInitialized);
ExtensionRegistry registry = ExtensionRegistry.CreateInstance();
UnittestExtrasFull.RegisterAllExtensions(registry);
TestInteropPerson copy = TestInteropPerson.ParseFrom(person.ToByteArray(), registry);
- TestUtil.AssertBytesEqual(person.ToByteArray(), copy.ToByteArray());
+ Assert.Equal(person.ToByteArray(), copy.ToByteArray());
}
public ByteString AllBytes
@@ -138,7 +135,7 @@ namespace Google.ProtocolBuffers }
}
- [TestMethod]
+ [Fact]
public void TestCompareStringValues()
{
TestInteropPersonLite person = TestInteropPersonLite.CreateBuilder()
@@ -156,14 +153,14 @@ namespace Google.ProtocolBuffers .SetExtension(UnittestExtrasLite.EmployeeIdLite,
TestInteropEmployeeIdLite.CreateBuilder().SetNumber("123").Build())
.Build();
- Assert.IsTrue(person.IsInitialized);
+ Assert.True(person.IsInitialized);
ExtensionRegistry registry = ExtensionRegistry.CreateInstance();
UnittestExtrasFull.RegisterAllExtensions(registry);
TestInteropPerson copy = TestInteropPerson.ParseFrom(person.ToByteArray(), registry);
- TestUtil.AssertBytesEqual(person.ToByteArray(), copy.ToByteArray());
+ Assert.Equal(person.ToByteArray(), copy.ToByteArray());
TestInteropPerson.Builder copyBuilder = TestInteropPerson.CreateBuilder();
TextFormat.Merge(
@@ -171,7 +168,7 @@ namespace Google.ProtocolBuffers "[protobuf_unittest_extra.employee_id]"), registry, copyBuilder);
copy = copyBuilder.Build();
- TestUtil.AssertBytesEqual(person.ToByteArray(), copy.ToByteArray());
+ Assert.Equal(person.ToByteArray(), copy.ToByteArray());
string liteText = person.ToString().TrimEnd().Replace("\r", "");
string fullText = copy.ToString().TrimEnd().Replace("\r", "");
@@ -179,10 +176,10 @@ namespace Google.ProtocolBuffers liteText = liteText.Replace("[protobuf_unittest_extra.employee_id_lite]",
"[protobuf_unittest_extra.employee_id]");
//lite version does not indent
- while (fullText.IndexOf("\n ") >= 0)
+ while (fullText.IndexOf("\n ", StringComparison.Ordinal) >= 0)
fullText = fullText.Replace("\n ", "\n");
- Assert.AreEqual(fullText, liteText);
+ Assert.Equal(fullText, liteText);
}
}
}
\ No newline at end of file diff --git a/csharp/src/ProtocolBuffersLite.Test/LiteTest.cs b/csharp/src/ProtocolBuffersLite.Test/LiteTest.cs index 9ef5cc84..8ffd3ee2 100644 --- a/csharp/src/ProtocolBuffersLite.Test/LiteTest.cs +++ b/csharp/src/ProtocolBuffersLite.Test/LiteTest.cs @@ -34,12 +34,8 @@ #endregion
-using System;
-using System.Collections.Generic;
-using System.IO;
-using Google.ProtocolBuffers.Descriptors;
using Google.ProtocolBuffers.TestProtos;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Xunit;
namespace Google.ProtocolBuffers
{
@@ -47,10 +43,9 @@ namespace Google.ProtocolBuffers /// Miscellaneous tests for message operations that apply to both
/// generated and dynamic messages.
/// </summary>
- [TestClass]
public class LiteTest
{
- [TestMethod]
+ [Fact]
public void TestLite()
{
// Since lite messages are a subset of regular messages, we can mostly
@@ -73,13 +68,13 @@ namespace Google.ProtocolBuffers TestAllTypesLite message2 = TestAllTypesLite.ParseFrom(data);
- Assert.AreEqual(123, message2.OptionalInt32);
- Assert.AreEqual(1, message2.RepeatedStringCount);
- Assert.AreEqual("hello", message2.RepeatedStringList[0]);
- Assert.AreEqual(7, message2.OptionalNestedMessage.Bb);
+ Assert.Equal(123, message2.OptionalInt32);
+ Assert.Equal(1, message2.RepeatedStringCount);
+ Assert.Equal("hello", message2.RepeatedStringList[0]);
+ Assert.Equal(7, message2.OptionalNestedMessage.Bb);
}
- [TestMethod]
+ [Fact]
public void TestLiteExtensions()
{
// TODO(kenton): Unlike other features of the lite library, extensions are
@@ -101,17 +96,17 @@ namespace Google.ProtocolBuffers // writing, parsing hasn't been implemented yet.
TestAllExtensionsLite message2 = message.ToBuilder().Build();
- Assert.AreEqual(123, (int) message2.GetExtension(
+ Assert.Equal(123, (int) message2.GetExtension(
UnittestLite.OptionalInt32ExtensionLite));
- Assert.AreEqual(1, message2.GetExtensionCount(
+ Assert.Equal(1, message2.GetExtensionCount(
UnittestLite.RepeatedStringExtensionLite));
- Assert.AreEqual(1, message2.GetExtension(
+ Assert.Equal(1, message2.GetExtension(
UnittestLite.RepeatedStringExtensionLite).Count);
- Assert.AreEqual("hello", message2.GetExtension(
+ Assert.Equal("hello", message2.GetExtension(
UnittestLite.RepeatedStringExtensionLite, 0));
- Assert.AreEqual(TestAllTypesLite.Types.NestedEnum.BAZ, message2.GetExtension(
+ Assert.Equal(TestAllTypesLite.Types.NestedEnum.BAZ, message2.GetExtension(
UnittestLite.OptionalNestedEnumExtensionLite));
- Assert.AreEqual(7, message2.GetExtension(
+ Assert.Equal(7, message2.GetExtension(
UnittestLite.OptionalNestedMessageExtensionLite).Bb);
}
}
diff --git a/csharp/src/ProtocolBuffersLite.Test/MissingFieldAndExtensionTest.cs b/csharp/src/ProtocolBuffersLite.Test/MissingFieldAndExtensionTest.cs index b70635d5..b9680e68 100644 --- a/csharp/src/ProtocolBuffersLite.Test/MissingFieldAndExtensionTest.cs +++ b/csharp/src/ProtocolBuffersLite.Test/MissingFieldAndExtensionTest.cs @@ -34,17 +34,14 @@ #endregion
-using System.IO;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-using System.Collections.Generic;
using Google.ProtocolBuffers.TestProtos;
+using Xunit;
namespace Google.ProtocolBuffers
{
- [TestClass]
public class MissingFieldAndExtensionTest
{
- [TestMethod]
+ [Fact]
public void TestRecoverMissingExtensions()
{
const int optionalInt32 = 12345678;
@@ -55,42 +52,42 @@ namespace Google.ProtocolBuffers builder.AddExtension(Unittest.RepeatedDoubleExtension, 1.3);
TestAllExtensions msg = builder.Build();
- Assert.IsTrue(msg.HasExtension(Unittest.OptionalInt32Extension));
- Assert.AreEqual(3, msg.GetExtensionCount(Unittest.RepeatedDoubleExtension));
+ Assert.True(msg.HasExtension(Unittest.OptionalInt32Extension));
+ Assert.Equal(3, msg.GetExtensionCount(Unittest.RepeatedDoubleExtension));
byte[] bits = msg.ToByteArray();
TestAllExtensions copy = TestAllExtensions.ParseFrom(bits);
- Assert.IsFalse(copy.HasExtension(Unittest.OptionalInt32Extension));
- Assert.AreEqual(0, copy.GetExtensionCount(Unittest.RepeatedDoubleExtension));
- Assert.AreNotEqual(msg, copy);
+ Assert.False(copy.HasExtension(Unittest.OptionalInt32Extension));
+ Assert.Equal(0, copy.GetExtensionCount(Unittest.RepeatedDoubleExtension));
+ Assert.NotEqual(msg, copy);
//Even though copy does not understand the typees they serialize correctly
byte[] copybits = copy.ToByteArray();
- TestUtil.AssertBytesEqual(bits, copybits);
+ Assert.Equal(bits, copybits);
ExtensionRegistry registry = ExtensionRegistry.CreateInstance();
Unittest.RegisterAllExtensions(registry);
//Now we can take those copy bits and restore the full message with extensions
copy = TestAllExtensions.ParseFrom(copybits, registry);
- Assert.IsTrue(copy.HasExtension(Unittest.OptionalInt32Extension));
- Assert.AreEqual(3, copy.GetExtensionCount(Unittest.RepeatedDoubleExtension));
+ Assert.True(copy.HasExtension(Unittest.OptionalInt32Extension));
+ Assert.Equal(3, copy.GetExtensionCount(Unittest.RepeatedDoubleExtension));
- Assert.AreEqual(msg, copy);
- TestUtil.AssertBytesEqual(bits, copy.ToByteArray());
+ Assert.Equal(msg, copy);
+ Assert.Equal(bits, copy.ToByteArray());
//If we modify the object this should all continue to work as before
copybits = copy.ToBuilder().Build().ToByteArray();
- TestUtil.AssertBytesEqual(bits, copybits);
+ Assert.Equal(bits, copybits);
//If we replace extension the object this should all continue to work as before
copybits = copy.ToBuilder()
.SetExtension(Unittest.OptionalInt32Extension, optionalInt32)
.Build().ToByteArray();
- TestUtil.AssertBytesEqual(bits, copybits);
+ Assert.Equal(bits, copybits);
}
- [TestMethod]
+ [Fact]
public void TestRecoverMissingFields()
{
TestMissingFieldsA msga = TestMissingFieldsA.CreateBuilder()
@@ -101,53 +98,53 @@ namespace Google.ProtocolBuffers //serialize to type B and verify all fields exist
TestMissingFieldsB msgb = TestMissingFieldsB.ParseFrom(msga.ToByteArray());
- Assert.AreEqual(1001, msgb.Id);
- Assert.AreEqual("Name", msgb.Name);
- Assert.IsFalse(msgb.HasWebsite);
- Assert.AreEqual(1, msgb.UnknownFields.FieldDictionary.Count);
- Assert.AreEqual("missing@field.value",
+ Assert.Equal(1001, msgb.Id);
+ Assert.Equal("Name", msgb.Name);
+ Assert.False(msgb.HasWebsite);
+ Assert.Equal(1, msgb.UnknownFields.FieldDictionary.Count);
+ Assert.Equal("missing@field.value",
msgb.UnknownFields[TestMissingFieldsA.EmailFieldNumber].LengthDelimitedList[0].ToStringUtf8());
//serializes exactly the same (at least for this simple example)
- TestUtil.AssertBytesEqual(msga.ToByteArray(), msgb.ToByteArray());
- Assert.AreEqual(msga, TestMissingFieldsA.ParseFrom(msgb.ToByteArray()));
+ Assert.Equal(msga.ToByteArray(), msgb.ToByteArray());
+ Assert.Equal(msga, TestMissingFieldsA.ParseFrom(msgb.ToByteArray()));
//now re-create an exact copy of A from serialized B
TestMissingFieldsA copya = TestMissingFieldsA.ParseFrom(msgb.ToByteArray());
- Assert.AreEqual(msga, copya);
- Assert.AreEqual(1001, copya.Id);
- Assert.AreEqual("Name", copya.Name);
- Assert.AreEqual("missing@field.value", copya.Email);
+ Assert.Equal(msga, copya);
+ Assert.Equal(1001, copya.Id);
+ Assert.Equal("Name", copya.Name);
+ Assert.Equal("missing@field.value", copya.Email);
//Now we modify B... and try again
msgb = msgb.ToBuilder().SetWebsite("http://new.missing.field").Build();
//Does B still have the missing field?
- Assert.AreEqual(1, msgb.UnknownFields.FieldDictionary.Count);
+ Assert.Equal(1, msgb.UnknownFields.FieldDictionary.Count);
//Convert back to A and see if all fields are there?
copya = TestMissingFieldsA.ParseFrom(msgb.ToByteArray());
- Assert.AreNotEqual(msga, copya);
- Assert.AreEqual(1001, copya.Id);
- Assert.AreEqual("Name", copya.Name);
- Assert.AreEqual("missing@field.value", copya.Email);
- Assert.AreEqual(1, copya.UnknownFields.FieldDictionary.Count);
- Assert.AreEqual("http://new.missing.field",
+ Assert.NotEqual(msga, copya);
+ Assert.Equal(1001, copya.Id);
+ Assert.Equal("Name", copya.Name);
+ Assert.Equal("missing@field.value", copya.Email);
+ Assert.Equal(1, copya.UnknownFields.FieldDictionary.Count);
+ Assert.Equal("http://new.missing.field",
copya.UnknownFields[TestMissingFieldsB.WebsiteFieldNumber].LengthDelimitedList[0].
ToStringUtf8());
//Lastly we can even still trip back to type B and see all fields:
TestMissingFieldsB copyb = TestMissingFieldsB.ParseFrom(copya.ToByteArray());
- Assert.AreEqual(copya.ToByteArray().Length, copyb.ToByteArray().Length); //not exact order.
- Assert.AreEqual(1001, copyb.Id);
- Assert.AreEqual("Name", copyb.Name);
- Assert.AreEqual("http://new.missing.field", copyb.Website);
- Assert.AreEqual(1, copyb.UnknownFields.FieldDictionary.Count);
- Assert.AreEqual("missing@field.value",
+ Assert.Equal(copya.ToByteArray().Length, copyb.ToByteArray().Length); //not exact order.
+ Assert.Equal(1001, copyb.Id);
+ Assert.Equal("Name", copyb.Name);
+ Assert.Equal("http://new.missing.field", copyb.Website);
+ Assert.Equal(1, copyb.UnknownFields.FieldDictionary.Count);
+ Assert.Equal("missing@field.value",
copyb.UnknownFields[TestMissingFieldsA.EmailFieldNumber].LengthDelimitedList[0].ToStringUtf8
());
}
- [TestMethod]
+ [Fact]
public void TestRecoverMissingMessage()
{
TestMissingFieldsA.Types.SubA suba =
@@ -161,52 +158,52 @@ namespace Google.ProtocolBuffers //serialize to type B and verify all fields exist
TestMissingFieldsB msgb = TestMissingFieldsB.ParseFrom(msga.ToByteArray());
- Assert.AreEqual(1001, msgb.Id);
- Assert.AreEqual("Name", msgb.Name);
- Assert.AreEqual(1, msgb.UnknownFields.FieldDictionary.Count);
- Assert.AreEqual(suba.ToString(),
+ Assert.Equal(1001, msgb.Id);
+ Assert.Equal("Name", msgb.Name);
+ Assert.Equal(1, msgb.UnknownFields.FieldDictionary.Count);
+ Assert.Equal(suba.ToString(),
TestMissingFieldsA.Types.SubA.ParseFrom(
msgb.UnknownFields[TestMissingFieldsA.TestAFieldNumber].LengthDelimitedList[0]).ToString
());
//serializes exactly the same (at least for this simple example)
- TestUtil.AssertBytesEqual(msga.ToByteArray(), msgb.ToByteArray());
- Assert.AreEqual(msga, TestMissingFieldsA.ParseFrom(msgb.ToByteArray()));
+ Assert.Equal(msga.ToByteArray(), msgb.ToByteArray());
+ Assert.Equal(msga, TestMissingFieldsA.ParseFrom(msgb.ToByteArray()));
//now re-create an exact copy of A from serialized B
TestMissingFieldsA copya = TestMissingFieldsA.ParseFrom(msgb.ToByteArray());
- Assert.AreEqual(msga, copya);
- Assert.AreEqual(1001, copya.Id);
- Assert.AreEqual("Name", copya.Name);
- Assert.AreEqual(suba, copya.TestA);
+ Assert.Equal(msga, copya);
+ Assert.Equal(1001, copya.Id);
+ Assert.Equal("Name", copya.Name);
+ Assert.Equal(suba, copya.TestA);
//Now we modify B... and try again
TestMissingFieldsB.Types.SubB subb =
TestMissingFieldsB.Types.SubB.CreateBuilder().AddValues("test-b").Build();
msgb = msgb.ToBuilder().SetTestB(subb).Build();
//Does B still have the missing field?
- Assert.AreEqual(1, msgb.UnknownFields.FieldDictionary.Count);
+ Assert.Equal(1, msgb.UnknownFields.FieldDictionary.Count);
//Convert back to A and see if all fields are there?
copya = TestMissingFieldsA.ParseFrom(msgb.ToByteArray());
- Assert.AreNotEqual(msga, copya);
- Assert.AreEqual(1001, copya.Id);
- Assert.AreEqual("Name", copya.Name);
- Assert.AreEqual(suba, copya.TestA);
- Assert.AreEqual(1, copya.UnknownFields.FieldDictionary.Count);
- TestUtil.AssertBytesEqual(subb.ToByteArray(),
+ Assert.NotEqual(msga, copya);
+ Assert.Equal(1001, copya.Id);
+ Assert.Equal("Name", copya.Name);
+ Assert.Equal(suba, copya.TestA);
+ Assert.Equal(1, copya.UnknownFields.FieldDictionary.Count);
+ Assert.Equal(subb.ToByteArray(),
copya.UnknownFields[TestMissingFieldsB.TestBFieldNumber].LengthDelimitedList[0].ToByteArray());
//Lastly we can even still trip back to type B and see all fields:
TestMissingFieldsB copyb = TestMissingFieldsB.ParseFrom(copya.ToByteArray());
- Assert.AreEqual(copya.ToByteArray().Length, copyb.ToByteArray().Length); //not exact order.
- Assert.AreEqual(1001, copyb.Id);
- Assert.AreEqual("Name", copyb.Name);
- Assert.AreEqual(subb, copyb.TestB);
- Assert.AreEqual(1, copyb.UnknownFields.FieldDictionary.Count);
+ Assert.Equal(copya.ToByteArray().Length, copyb.ToByteArray().Length); //not exact order.
+ Assert.Equal(1001, copyb.Id);
+ Assert.Equal("Name", copyb.Name);
+ Assert.Equal(subb, copyb.TestB);
+ Assert.Equal(1, copyb.UnknownFields.FieldDictionary.Count);
}
- [TestMethod]
+ [Fact]
public void TestRestoreFromOtherType()
{
TestInteropPerson person = TestInteropPerson.CreateBuilder()
@@ -222,19 +219,19 @@ namespace Google.ProtocolBuffers .SetExtension(UnittestExtrasFull.EmployeeId,
TestInteropEmployeeId.CreateBuilder().SetNumber("123").Build())
.Build();
- Assert.IsTrue(person.IsInitialized);
+ Assert.True(person.IsInitialized);
TestEmptyMessage temp = TestEmptyMessage.ParseFrom(person.ToByteArray());
- Assert.AreEqual(7, temp.UnknownFields.FieldDictionary.Count);
+ Assert.Equal(7, temp.UnknownFields.FieldDictionary.Count);
temp = temp.ToBuilder().Build();
- Assert.AreEqual(7, temp.UnknownFields.FieldDictionary.Count);
+ Assert.Equal(7, temp.UnknownFields.FieldDictionary.Count);
ExtensionRegistry registry = ExtensionRegistry.CreateInstance();
UnittestExtrasFull.RegisterAllExtensions(registry);
TestInteropPerson copy = TestInteropPerson.ParseFrom(temp.ToByteArray(), registry);
- Assert.AreEqual(person, copy);
- TestUtil.AssertBytesEqual(person.ToByteArray(), copy.ToByteArray());
+ Assert.Equal(person, copy);
+ Assert.Equal(person.ToByteArray(), copy.ToByteArray());
}
}
}
\ No newline at end of file diff --git a/csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLite.Test.csproj b/csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLite.Test.csproj index 12315442..8acc1fb1 100644 --- a/csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLite.Test.csproj +++ b/csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLite.Test.csproj @@ -1,9 +1,8 @@ <?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+ <Import Project="..\packages\xunit.runner.visualstudio.2.0.0\build\net20\xunit.runner.visualstudio.props" Condition="Exists('..\packages\xunit.runner.visualstudio.2.0.0\build\net20\xunit.runner.visualstudio.props')" />
+ <Import Project="..\packages\xunit.core.2.0.0\build\portable-net45+win+wpa81+wp80+monotouch+monoandroid+Xamarin.iOS\xunit.core.props" Condition="Exists('..\packages\xunit.core.2.0.0\build\portable-net45+win+wpa81+wp80+monotouch+monoandroid+Xamarin.iOS\xunit.core.props')" />
<PropertyGroup>
- <EnvironmentFlavor>CLIENTPROFILE</EnvironmentFlavor>
- <EnvironmentTemplate>NET35</EnvironmentTemplate>
- <EnvironmentProjectType>TEST</EnvironmentProjectType>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProductVersion>9.0.30729</ProductVersion>
@@ -13,12 +12,13 @@ <AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>Google.ProtocolBuffers</RootNamespace>
<AssemblyName>Google.ProtocolBuffersLite.Test</AssemblyName>
- <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
+ <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
<SignAssembly>true</SignAssembly>
<AssemblyOriginatorKeyFile>..\..\keys\Google.ProtocolBuffers.snk</AssemblyOriginatorKeyFile>
<OldToolsVersion>3.5</OldToolsVersion>
- <TargetFrameworkProfile>Client</TargetFrameworkProfile>
+ <TargetFrameworkProfile>
+ </TargetFrameworkProfile>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols>
@@ -32,6 +32,7 @@ <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
<NoStdLib>true</NoStdLib>
<GenerateSerializationAssemblies>Off</GenerateSerializationAssemblies>
+ <Prefer32Bit>false</Prefer32Bit>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType>
@@ -44,32 +45,23 @@ <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
<NoStdLib>true</NoStdLib>
<GenerateSerializationAssemblies>Off</GenerateSerializationAssemblies>
+ <Prefer32Bit>false</Prefer32Bit>
</PropertyGroup>
<ItemGroup>
<Reference Include="mscorlib" />
<Reference Include="System" />
<Reference Include="System.Xml" />
- </ItemGroup>
- <ItemGroup Condition=" '$(EnvironmentFlavor)' == 'CLIENTPROFILE' ">
- <Reference Include="nunit.framework">
- <SpecificVersion>False</SpecificVersion>
- <HintPath>..\..\lib\NUnit\lib\nunit.framework.dll</HintPath>
+ <Reference Include="xunit.abstractions">
+ <HintPath>..\packages\xunit.abstractions.2.0.0\lib\net35\xunit.abstractions.dll</HintPath>
</Reference>
- </ItemGroup>
- <ItemGroup Condition=" '$(EnvironmentFlavor)' != 'CLIENTPROFILE' ">
- <Reference Include="Microsoft.Silverlight.Testing, Version=2.0.5.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
- <SpecificVersion>False</SpecificVersion>
- <HintPath>..\..\lib\Microsoft.Silverlight.Testing\April2010\Microsoft.Silverlight.Testing.dll</HintPath>
+ <Reference Include="xunit.assert">
+ <HintPath>..\packages\xunit.assert.2.0.0\lib\portable-net45+win+wpa81+wp80+monotouch+monoandroid+Xamarin.iOS\xunit.assert.dll</HintPath>
</Reference>
- <Reference Include="Microsoft.VisualStudio.QualityTools.UnitTesting.Silverlight, Version=2.0.5.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
- <SpecificVersion>False</SpecificVersion>
- <HintPath>..\..\lib\Microsoft.Silverlight.Testing\April2010\Microsoft.VisualStudio.QualityTools.UnitTesting.Silverlight.dll</HintPath>
+ <Reference Include="xunit.core">
+ <HintPath>..\packages\xunit.extensibility.core.2.0.0\lib\portable-net45+win+wpa81+wp80+monotouch+monoandroid+Xamarin.iOS\xunit.core.dll</HintPath>
</Reference>
</ItemGroup>
<ItemGroup>
- <Compile Include="..\..\lib\NUnit-config\Microsoft.VisualStudio.TestTools.cs">
- <Link>Microsoft.VisualStudio.TestTools.cs</Link>
- </Compile>
<Compile Include="..\ProtocolBuffers.Test\Properties\AssemblyInfo.cs">
<Link>Properties\AssemblyInfo.cs</Link>
</Compile>
@@ -83,7 +75,6 @@ <Compile Include="TestProtos\UnittestImportLite.cs" />
<Compile Include="TestProtos\UnittestImportPublicLite.cs" />
<Compile Include="TestProtos\UnittestLite.cs" />
- <Compile Include="TestUtil.cs" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\ProtocolBuffers.Serialization\ProtocolBuffersLite.Serialization.csproj">
@@ -96,7 +87,9 @@ <Private>True</Private>
</ProjectReference>
</ItemGroup>
- <ItemGroup />
+ <ItemGroup>
+ <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
+ </ItemGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
@@ -105,10 +98,11 @@ <Target Name="AfterBuild">
</Target>
-->
- <PropertyGroup Condition=" '$(EnvironmentFlavor)' == 'CLIENTPROFILE' ">
- <StartAction>Program</StartAction>
- <StartProgram>$(ProjectDir)..\..\lib\NUnit\tools\nunit-console.exe</StartProgram>
- <StartArguments>/nologo /noshadow /labels /wait $(AssemblyName).dll</StartArguments>
- <StartWorkingDirectory>$(ProjectDir)$(OutputPath)</StartWorkingDirectory>
- </PropertyGroup>
+ <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
+ <PropertyGroup>
+ <ErrorText>This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them. For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.</ErrorText>
+ </PropertyGroup>
+ <Error Condition="!Exists('..\packages\xunit.core.2.0.0\build\portable-net45+win+wpa81+wp80+monotouch+monoandroid+Xamarin.iOS\xunit.core.props')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\xunit.core.2.0.0\build\portable-net45+win+wpa81+wp80+monotouch+monoandroid+Xamarin.iOS\xunit.core.props'))" />
+ <Error Condition="!Exists('..\packages\xunit.runner.visualstudio.2.0.0\build\net20\xunit.runner.visualstudio.props')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\xunit.runner.visualstudio.2.0.0\build\net20\xunit.runner.visualstudio.props'))" />
+ </Target>
</Project>
\ No newline at end of file diff --git a/csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLiteMixed.Test.csproj b/csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLiteMixed.Test.csproj index f7772f39..5f1a7ba3 100644 --- a/csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLiteMixed.Test.csproj +++ b/csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLiteMixed.Test.csproj @@ -1,9 +1,8 @@ <?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+ <Import Project="..\packages\xunit.runner.visualstudio.2.0.0\build\net20\xunit.runner.visualstudio.props" Condition="Exists('..\packages\xunit.runner.visualstudio.2.0.0\build\net20\xunit.runner.visualstudio.props')" />
+ <Import Project="..\packages\xunit.core.2.0.0\build\portable-net45+win+wpa81+wp80+monotouch+monoandroid+Xamarin.iOS\xunit.core.props" Condition="Exists('..\packages\xunit.core.2.0.0\build\portable-net45+win+wpa81+wp80+monotouch+monoandroid+Xamarin.iOS\xunit.core.props')" />
<PropertyGroup>
- <EnvironmentFlavor>CLIENTPROFILE</EnvironmentFlavor>
- <EnvironmentTemplate>NET35</EnvironmentTemplate>
- <EnvironmentProjectType>TEST</EnvironmentProjectType>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProductVersion>9.0.30729</ProductVersion>
@@ -13,12 +12,13 @@ <AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>Google.ProtocolBuffers</RootNamespace>
<AssemblyName>Google.ProtocolBuffersMixedLite.Test</AssemblyName>
- <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
+ <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
<SignAssembly>true</SignAssembly>
<AssemblyOriginatorKeyFile>..\..\keys\Google.ProtocolBuffers.snk</AssemblyOriginatorKeyFile>
<OldToolsVersion>3.5</OldToolsVersion>
- <TargetFrameworkProfile>Client</TargetFrameworkProfile>
+ <TargetFrameworkProfile>
+ </TargetFrameworkProfile>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols>
@@ -32,6 +32,7 @@ <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
<NoStdLib>true</NoStdLib>
<GenerateSerializationAssemblies>Off</GenerateSerializationAssemblies>
+ <Prefer32Bit>false</Prefer32Bit>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType>
@@ -44,32 +45,23 @@ <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
<NoStdLib>true</NoStdLib>
<GenerateSerializationAssemblies>Off</GenerateSerializationAssemblies>
+ <Prefer32Bit>false</Prefer32Bit>
</PropertyGroup>
<ItemGroup>
<Reference Include="mscorlib" />
<Reference Include="System" />
<Reference Include="System.Xml" />
- </ItemGroup>
- <ItemGroup Condition=" '$(EnvironmentFlavor)' == 'CLIENTPROFILE' ">
- <Reference Include="nunit.framework">
- <SpecificVersion>False</SpecificVersion>
- <HintPath>..\..\lib\NUnit\lib\nunit.framework.dll</HintPath>
+ <Reference Include="xunit.abstractions">
+ <HintPath>..\packages\xunit.abstractions.2.0.0\lib\net35\xunit.abstractions.dll</HintPath>
</Reference>
- </ItemGroup>
- <ItemGroup Condition=" '$(EnvironmentFlavor)' != 'CLIENTPROFILE' ">
- <Reference Include="Microsoft.Silverlight.Testing, Version=2.0.5.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
- <SpecificVersion>False</SpecificVersion>
- <HintPath>..\..\lib\Microsoft.Silverlight.Testing\April2010\Microsoft.Silverlight.Testing.dll</HintPath>
+ <Reference Include="xunit.assert">
+ <HintPath>..\packages\xunit.assert.2.0.0\lib\portable-net45+win+wpa81+wp80+monotouch+monoandroid+Xamarin.iOS\xunit.assert.dll</HintPath>
</Reference>
- <Reference Include="Microsoft.VisualStudio.QualityTools.UnitTesting.Silverlight, Version=2.0.5.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
- <SpecificVersion>False</SpecificVersion>
- <HintPath>..\..\lib\Microsoft.Silverlight.Testing\April2010\Microsoft.VisualStudio.QualityTools.UnitTesting.Silverlight.dll</HintPath>
+ <Reference Include="xunit.core">
+ <HintPath>..\packages\xunit.extensibility.core.2.0.0\lib\portable-net45+win+wpa81+wp80+monotouch+monoandroid+Xamarin.iOS\xunit.core.dll</HintPath>
</Reference>
</ItemGroup>
<ItemGroup>
- <Compile Include="..\..\lib\NUnit-config\Microsoft.VisualStudio.TestTools.cs">
- <Link>Microsoft.VisualStudio.TestTools.cs</Link>
- </Compile>
<Compile Include="..\ProtocolBuffers.Test\Properties\AssemblyInfo.cs">
<Link>Properties\AssemblyInfo.cs</Link>
</Compile>
@@ -90,7 +82,6 @@ <Compile Include="TestProtos\UnittestImportPublicLite.cs" />
<Compile Include="TestProtos\UnittestLite.cs" />
<Compile Include="TestProtos\UnittestLiteImportsNonlite.cs" />
- <Compile Include="TestUtil.cs" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\ProtocolBuffers\ProtocolBuffers.csproj">
@@ -98,7 +89,9 @@ <Name>ProtocolBuffers</Name>
</ProjectReference>
</ItemGroup>
- <ItemGroup />
+ <ItemGroup>
+ <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
+ </ItemGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
@@ -107,10 +100,11 @@ <Target Name="AfterBuild">
</Target>
-->
- <PropertyGroup Condition=" '$(EnvironmentFlavor)' == 'CLIENTPROFILE' ">
- <StartAction>Program</StartAction>
- <StartProgram>$(ProjectDir)..\..\lib\NUnit\tools\nunit-console.exe</StartProgram>
- <StartArguments>/nologo /noshadow /labels /wait $(AssemblyName).dll</StartArguments>
- <StartWorkingDirectory>$(ProjectDir)$(OutputPath)</StartWorkingDirectory>
- </PropertyGroup>
+ <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
+ <PropertyGroup>
+ <ErrorText>This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them. For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.</ErrorText>
+ </PropertyGroup>
+ <Error Condition="!Exists('..\packages\xunit.core.2.0.0\build\portable-net45+win+wpa81+wp80+monotouch+monoandroid+Xamarin.iOS\xunit.core.props')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\xunit.core.2.0.0\build\portable-net45+win+wpa81+wp80+monotouch+monoandroid+Xamarin.iOS\xunit.core.props'))" />
+ <Error Condition="!Exists('..\packages\xunit.runner.visualstudio.2.0.0\build\net20\xunit.runner.visualstudio.props')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\xunit.runner.visualstudio.2.0.0\build\net20\xunit.runner.visualstudio.props'))" />
+ </Target>
</Project>
\ No newline at end of file diff --git a/csharp/src/ProtocolBuffersLite.Test/TestLiteByApi.cs b/csharp/src/ProtocolBuffersLite.Test/TestLiteByApi.cs index e44a72a8..e4f9acff 100644 --- a/csharp/src/ProtocolBuffersLite.Test/TestLiteByApi.cs +++ b/csharp/src/ProtocolBuffersLite.Test/TestLiteByApi.cs @@ -35,67 +35,66 @@ #endregion
using Google.ProtocolBuffers.TestProtos;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Xunit;
namespace Google.ProtocolBuffers
{
- [TestClass]
public class TestLiteByApi
{
- [TestMethod]
+ [Fact]
public void TestAllTypesEquality()
{
TestAllTypesLite msg = TestAllTypesLite.DefaultInstance;
TestAllTypesLite copy = msg.ToBuilder().Build();
- Assert.AreEqual(msg.GetHashCode(), copy.GetHashCode());
- Assert.IsTrue(msg.Equals(copy));
+ Assert.Equal(msg.GetHashCode(), copy.GetHashCode());
+ Assert.True(msg.Equals(copy));
msg = msg.ToBuilder().SetOptionalString("Hi").Build();
- Assert.AreNotEqual(msg.GetHashCode(), copy.GetHashCode());
- Assert.IsFalse(msg.Equals(copy));
+ Assert.NotEqual(msg.GetHashCode(), copy.GetHashCode());
+ Assert.False(msg.Equals(copy));
copy = copy.ToBuilder().SetOptionalString("Hi").Build();
- Assert.AreEqual(msg.GetHashCode(), copy.GetHashCode());
- Assert.IsTrue(msg.Equals(copy));
+ Assert.Equal(msg.GetHashCode(), copy.GetHashCode());
+ Assert.True(msg.Equals(copy));
}
- [TestMethod]
+ [Fact]
public void TestEqualityOnExtensions()
{
TestAllExtensionsLite msg = TestAllExtensionsLite.DefaultInstance;
TestAllExtensionsLite copy = msg.ToBuilder().Build();
- Assert.AreEqual(msg.GetHashCode(), copy.GetHashCode());
- Assert.IsTrue(msg.Equals(copy));
+ Assert.Equal(msg.GetHashCode(), copy.GetHashCode());
+ Assert.True(msg.Equals(copy));
msg = msg.ToBuilder().SetExtension(UnittestLite.OptionalStringExtensionLite, "Hi").Build();
- Assert.AreNotEqual(msg.GetHashCode(), copy.GetHashCode());
- Assert.IsFalse(msg.Equals(copy));
+ Assert.NotEqual(msg.GetHashCode(), copy.GetHashCode());
+ Assert.False(msg.Equals(copy));
copy = copy.ToBuilder().SetExtension(UnittestLite.OptionalStringExtensionLite, "Hi").Build();
- Assert.AreEqual(msg.GetHashCode(), copy.GetHashCode());
- Assert.IsTrue(msg.Equals(copy));
+ Assert.Equal(msg.GetHashCode(), copy.GetHashCode());
+ Assert.True(msg.Equals(copy));
}
- [TestMethod]
+ [Fact]
public void TestAllTypesToString()
{
TestAllTypesLite msg = TestAllTypesLite.DefaultInstance;
TestAllTypesLite copy = msg.ToBuilder().Build();
- Assert.AreEqual(msg.ToString(), copy.ToString());
- Assert.AreEqual(0, msg.ToString().Length);
+ Assert.Equal(msg.ToString(), copy.ToString());
+ Assert.Equal(0, msg.ToString().Length);
msg = msg.ToBuilder().SetOptionalInt32(-1).Build();
- Assert.AreEqual("optional_int32: -1", msg.ToString().TrimEnd());
+ Assert.Equal("optional_int32: -1", msg.ToString().TrimEnd());
msg = msg.ToBuilder().SetOptionalString("abc123").Build();
- Assert.AreEqual("optional_int32: -1\noptional_string: \"abc123\"",
+ Assert.Equal("optional_int32: -1\noptional_string: \"abc123\"",
msg.ToString().Replace("\r", "").TrimEnd());
}
- [TestMethod]
+ [Fact]
public void TestAllTypesDefaultedRoundTrip()
{
TestAllTypesLite msg = TestAllTypesLite.DefaultInstance;
- Assert.IsTrue(msg.IsInitialized);
+ Assert.True(msg.IsInitialized);
TestAllTypesLite copy = TestAllTypesLite.CreateBuilder().MergeFrom(msg.ToByteArray()).Build();
- TestUtil.AssertBytesEqual(msg.ToByteArray(), copy.ToByteArray());
+ Assert.Equal(msg.ToByteArray(), copy.ToByteArray());
}
- [TestMethod]
+ [Fact]
public void TestAllTypesModifiedRoundTrip()
{
TestAllTypesLite msg = TestAllTypesLite.DefaultInstance;
@@ -115,7 +114,7 @@ namespace Google.ProtocolBuffers .AddRepeatedGroup(TestAllTypesLite.Types.RepeatedGroup.CreateBuilder().SetA('A').Build())
;
TestAllTypesLite copy = TestAllTypesLite.CreateBuilder().MergeFrom(msg.ToByteArray()).Build();
- TestUtil.AssertBytesEqual(msg.ToByteArray(), copy.ToByteArray());
+ Assert.Equal(msg.ToByteArray(), copy.ToByteArray());
}
}
}
\ No newline at end of file diff --git a/csharp/src/ProtocolBuffersLite.Test/TestUtil.cs b/csharp/src/ProtocolBuffersLite.Test/TestUtil.cs deleted file mode 100644 index 44c09b9c..00000000 --- a/csharp/src/ProtocolBuffersLite.Test/TestUtil.cs +++ /dev/null @@ -1,31 +0,0 @@ -using System;
-using System.Collections.Generic;
-using System.Text;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-
-namespace Google.ProtocolBuffers
-{
- class TestUtil
- {
- internal static void AssertBytesEqual(byte[] a, byte[] b)
- {
- if (a == null || b == null)
- {
- Assert.AreEqual<object>(a, b);
- }
- else
- {
- Assert.AreEqual(a.Length, b.Length, "The byte[] is not of the expected length.");
-
- for (int i = 0; i < a.Length; i++)
- {
- if (a[i] != b[i])
- {
- Assert.AreEqual(a[i], b[i], "Byte[] differs at index " + i);
- }
- }
- }
- }
-
- }
-}
diff --git a/csharp/src/ProtocolBuffersLite.Test/packages.config b/csharp/src/ProtocolBuffersLite.Test/packages.config new file mode 100644 index 00000000..6f1fb7f5 --- /dev/null +++ b/csharp/src/ProtocolBuffersLite.Test/packages.config @@ -0,0 +1,9 @@ +<?xml version="1.0" encoding="utf-8"?> +<packages> + <package id="xunit" version="2.0.0" targetFramework="net45" /> + <package id="xunit.abstractions" version="2.0.0" targetFramework="net45" /> + <package id="xunit.assert" version="2.0.0" targetFramework="net45" /> + <package id="xunit.core" version="2.0.0" targetFramework="net45" /> + <package id="xunit.extensibility.core" version="2.0.0" targetFramework="net45" /> + <package id="xunit.runner.visualstudio" version="2.0.0" targetFramework="net45" /> +</packages>
\ No newline at end of file |