diff options
author | Jon Skeet <jonskeet@google.com> | 2015-05-12 09:47:19 +0100 |
---|---|---|
committer | Jon Skeet <jonskeet@google.com> | 2015-05-12 09:48:02 +0100 |
commit | 90c8932fc7316b5afaae350395624b6fd2e73a97 (patch) | |
tree | 080924d0a9fd8f52d88b1ee4fb76f9aa3bd802cd /csharp/src/ProtocolBuffers.Test/CodedOutputStreamTest.cs | |
parent | c58b2c66448f83c25da0251fe6cf5b12299fa581 (diff) | |
download | protobuf-90c8932fc7316b5afaae350395624b6fd2e73a97.tar.gz protobuf-90c8932fc7316b5afaae350395624b6fd2e73a97.tar.bz2 protobuf-90c8932fc7316b5afaae350395624b6fd2e73a97.zip |
Convert back to using NUnit, which is now loaded via NuGet.
This includes the NUnit test adapter which allows NUnit tests to be run under VS without any extra plugins.
Unfortunate the compatibility tests using the abstract test fixture class show up as "external" tests, and aren't well presented - but they do run.
Diffstat (limited to 'csharp/src/ProtocolBuffers.Test/CodedOutputStreamTest.cs')
-rw-r--r-- | csharp/src/ProtocolBuffers.Test/CodedOutputStreamTest.cs | 222 |
1 files changed, 111 insertions, 111 deletions
diff --git a/csharp/src/ProtocolBuffers.Test/CodedOutputStreamTest.cs b/csharp/src/ProtocolBuffers.Test/CodedOutputStreamTest.cs index d9f53d74..4d5b8302 100644 --- a/csharp/src/ProtocolBuffers.Test/CodedOutputStreamTest.cs +++ b/csharp/src/ProtocolBuffers.Test/CodedOutputStreamTest.cs @@ -38,7 +38,7 @@ using System; using System.Collections.Generic;
using System.IO;
using Google.ProtocolBuffers.TestProtos;
-using Xunit;
+using NUnit.Framework;
namespace Google.ProtocolBuffers
{
@@ -57,9 +57,9 @@ namespace Google.ProtocolBuffers CodedOutputStream output = CodedOutputStream.CreateInstance(rawOutput);
output.WriteRawVarint32((uint) value);
output.Flush();
- Assert.Equal(data, rawOutput.ToArray());
+ Assert.AreEqual(data, rawOutput.ToArray());
// Also try computing size.
- Assert.Equal(data.Length, CodedOutputStream.ComputeRawVarint32Size((uint) value));
+ Assert.AreEqual(data.Length, CodedOutputStream.ComputeRawVarint32Size((uint) value));
}
{
@@ -67,10 +67,10 @@ namespace Google.ProtocolBuffers CodedOutputStream output = CodedOutputStream.CreateInstance(rawOutput);
output.WriteRawVarint64(value);
output.Flush();
- Assert.Equal(data, rawOutput.ToArray());
+ Assert.AreEqual(data, rawOutput.ToArray());
// Also try computing size.
- Assert.Equal(data.Length, CodedOutputStream.ComputeRawVarint64Size(value));
+ Assert.AreEqual(data.Length, CodedOutputStream.ComputeRawVarint64Size(value));
}
// Try different buffer sizes.
@@ -84,7 +84,7 @@ namespace Google.ProtocolBuffers CodedOutputStream.CreateInstance(rawOutput, bufferSize);
output.WriteRawVarint32((uint) value);
output.Flush();
- Assert.Equal(data, rawOutput.ToArray());
+ Assert.AreEqual(data, rawOutput.ToArray());
}
{
@@ -92,7 +92,7 @@ namespace Google.ProtocolBuffers CodedOutputStream output = CodedOutputStream.CreateInstance(rawOutput, bufferSize);
output.WriteRawVarint64(value);
output.Flush();
- Assert.Equal(data, rawOutput.ToArray());
+ Assert.AreEqual(data, rawOutput.ToArray());
}
}
}
@@ -100,7 +100,7 @@ namespace Google.ProtocolBuffers /// <summary>
/// Tests WriteRawVarint32() and WriteRawVarint64()
/// </summary>
- [Fact]
+ [Test]
public void WriteVarint()
{
AssertWriteVarint(new byte[] {0x00}, 0);
@@ -142,7 +142,7 @@ namespace Google.ProtocolBuffers CodedOutputStream output = CodedOutputStream.CreateInstance(rawOutput);
output.WriteRawLittleEndian32(value);
output.Flush();
- Assert.Equal(data, rawOutput.ToArray());
+ Assert.AreEqual(data, rawOutput.ToArray());
// Try different buffer sizes.
for (int bufferSize = 1; bufferSize <= 16; bufferSize *= 2)
@@ -151,7 +151,7 @@ namespace Google.ProtocolBuffers output = CodedOutputStream.CreateInstance(rawOutput, bufferSize);
output.WriteRawLittleEndian32(value);
output.Flush();
- Assert.Equal(data, rawOutput.ToArray());
+ Assert.AreEqual(data, rawOutput.ToArray());
}
}
@@ -165,7 +165,7 @@ namespace Google.ProtocolBuffers CodedOutputStream output = CodedOutputStream.CreateInstance(rawOutput);
output.WriteRawLittleEndian64(value);
output.Flush();
- Assert.Equal(data, rawOutput.ToArray());
+ Assert.AreEqual(data, rawOutput.ToArray());
// Try different block sizes.
for (int blockSize = 1; blockSize <= 16; blockSize *= 2)
@@ -174,14 +174,14 @@ namespace Google.ProtocolBuffers output = CodedOutputStream.CreateInstance(rawOutput, blockSize);
output.WriteRawLittleEndian64(value);
output.Flush();
- Assert.Equal(data, rawOutput.ToArray());
+ Assert.AreEqual(data, rawOutput.ToArray());
}
}
/// <summary>
/// Tests writeRawLittleEndian32() and writeRawLittleEndian64().
/// </summary>
- [Fact]
+ [Test]
public void WriteLittleEndian()
{
AssertWriteLittleEndian32(new byte[] {0x78, 0x56, 0x34, 0x12}, 0x12345678);
@@ -195,7 +195,7 @@ namespace Google.ProtocolBuffers 0x9abcdef012345678UL);
}
- [Fact]
+ [Test]
public void WriteWholeMessage()
{
TestAllTypes message = TestUtil.GetAllSet();
@@ -219,7 +219,7 @@ namespace Google.ProtocolBuffers /// Tests writing a whole message with every packed field type. Ensures the
/// wire format of packed fields is compatible with C++.
/// </summary>
- [Fact]
+ [Test]
public void WriteWholePackedFieldsMessage()
{
TestPackedTypes message = TestUtil.GetPackedSet();
@@ -229,97 +229,97 @@ namespace Google.ProtocolBuffers rawBytes);
}
- [Fact]
+ [Test]
public void EncodeZigZag32()
{
- Assert.Equal(0u, CodedOutputStream.EncodeZigZag32(0));
- Assert.Equal(1u, CodedOutputStream.EncodeZigZag32(-1));
- Assert.Equal(2u, CodedOutputStream.EncodeZigZag32(1));
- Assert.Equal(3u, CodedOutputStream.EncodeZigZag32(-2));
- Assert.Equal(0x7FFFFFFEu, CodedOutputStream.EncodeZigZag32(0x3FFFFFFF));
- Assert.Equal(0x7FFFFFFFu, CodedOutputStream.EncodeZigZag32(unchecked((int) 0xC0000000)));
- Assert.Equal(0xFFFFFFFEu, CodedOutputStream.EncodeZigZag32(0x7FFFFFFF));
- Assert.Equal(0xFFFFFFFFu, CodedOutputStream.EncodeZigZag32(unchecked((int) 0x80000000)));
+ Assert.AreEqual(0u, CodedOutputStream.EncodeZigZag32(0));
+ Assert.AreEqual(1u, CodedOutputStream.EncodeZigZag32(-1));
+ Assert.AreEqual(2u, CodedOutputStream.EncodeZigZag32(1));
+ Assert.AreEqual(3u, CodedOutputStream.EncodeZigZag32(-2));
+ Assert.AreEqual(0x7FFFFFFEu, CodedOutputStream.EncodeZigZag32(0x3FFFFFFF));
+ Assert.AreEqual(0x7FFFFFFFu, CodedOutputStream.EncodeZigZag32(unchecked((int) 0xC0000000)));
+ Assert.AreEqual(0xFFFFFFFEu, CodedOutputStream.EncodeZigZag32(0x7FFFFFFF));
+ Assert.AreEqual(0xFFFFFFFFu, CodedOutputStream.EncodeZigZag32(unchecked((int) 0x80000000)));
}
- [Fact]
+ [Test]
public void EncodeZigZag64()
{
- Assert.Equal(0u, CodedOutputStream.EncodeZigZag64(0));
- Assert.Equal(1u, CodedOutputStream.EncodeZigZag64(-1));
- Assert.Equal(2u, CodedOutputStream.EncodeZigZag64(1));
- Assert.Equal(3u, CodedOutputStream.EncodeZigZag64(-2));
- Assert.Equal(0x000000007FFFFFFEuL,
+ Assert.AreEqual(0u, CodedOutputStream.EncodeZigZag64(0));
+ Assert.AreEqual(1u, CodedOutputStream.EncodeZigZag64(-1));
+ Assert.AreEqual(2u, CodedOutputStream.EncodeZigZag64(1));
+ Assert.AreEqual(3u, CodedOutputStream.EncodeZigZag64(-2));
+ Assert.AreEqual(0x000000007FFFFFFEuL,
CodedOutputStream.EncodeZigZag64(unchecked((long) 0x000000003FFFFFFFUL)));
- Assert.Equal(0x000000007FFFFFFFuL,
+ Assert.AreEqual(0x000000007FFFFFFFuL,
CodedOutputStream.EncodeZigZag64(unchecked((long) 0xFFFFFFFFC0000000UL)));
- Assert.Equal(0x00000000FFFFFFFEuL,
+ Assert.AreEqual(0x00000000FFFFFFFEuL,
CodedOutputStream.EncodeZigZag64(unchecked((long) 0x000000007FFFFFFFUL)));
- Assert.Equal(0x00000000FFFFFFFFuL,
+ Assert.AreEqual(0x00000000FFFFFFFFuL,
CodedOutputStream.EncodeZigZag64(unchecked((long) 0xFFFFFFFF80000000UL)));
- Assert.Equal(0xFFFFFFFFFFFFFFFEL,
+ Assert.AreEqual(0xFFFFFFFFFFFFFFFEL,
CodedOutputStream.EncodeZigZag64(unchecked((long) 0x7FFFFFFFFFFFFFFFUL)));
- Assert.Equal(0xFFFFFFFFFFFFFFFFL,
+ Assert.AreEqual(0xFFFFFFFFFFFFFFFFL,
CodedOutputStream.EncodeZigZag64(unchecked((long) 0x8000000000000000UL)));
}
- [Fact]
+ [Test]
public void RoundTripZigZag32()
{
// Some easier-to-verify round-trip tests. The inputs (other than 0, 1, -1)
// were chosen semi-randomly via keyboard bashing.
- Assert.Equal(0, CodedInputStream.DecodeZigZag32(CodedOutputStream.EncodeZigZag32(0)));
- Assert.Equal(1, CodedInputStream.DecodeZigZag32(CodedOutputStream.EncodeZigZag32(1)));
- Assert.Equal(-1, CodedInputStream.DecodeZigZag32(CodedOutputStream.EncodeZigZag32(-1)));
- Assert.Equal(14927, CodedInputStream.DecodeZigZag32(CodedOutputStream.EncodeZigZag32(14927)));
- Assert.Equal(-3612, CodedInputStream.DecodeZigZag32(CodedOutputStream.EncodeZigZag32(-3612)));
+ Assert.AreEqual(0, CodedInputStream.DecodeZigZag32(CodedOutputStream.EncodeZigZag32(0)));
+ Assert.AreEqual(1, CodedInputStream.DecodeZigZag32(CodedOutputStream.EncodeZigZag32(1)));
+ Assert.AreEqual(-1, CodedInputStream.DecodeZigZag32(CodedOutputStream.EncodeZigZag32(-1)));
+ Assert.AreEqual(14927, CodedInputStream.DecodeZigZag32(CodedOutputStream.EncodeZigZag32(14927)));
+ Assert.AreEqual(-3612, CodedInputStream.DecodeZigZag32(CodedOutputStream.EncodeZigZag32(-3612)));
}
- [Fact]
+ [Test]
public void RoundTripZigZag64()
{
- Assert.Equal(0, CodedInputStream.DecodeZigZag64(CodedOutputStream.EncodeZigZag64(0)));
- Assert.Equal(1, CodedInputStream.DecodeZigZag64(CodedOutputStream.EncodeZigZag64(1)));
- Assert.Equal(-1, CodedInputStream.DecodeZigZag64(CodedOutputStream.EncodeZigZag64(-1)));
- Assert.Equal(14927, CodedInputStream.DecodeZigZag64(CodedOutputStream.EncodeZigZag64(14927)));
- Assert.Equal(-3612, CodedInputStream.DecodeZigZag64(CodedOutputStream.EncodeZigZag64(-3612)));
+ Assert.AreEqual(0, CodedInputStream.DecodeZigZag64(CodedOutputStream.EncodeZigZag64(0)));
+ Assert.AreEqual(1, CodedInputStream.DecodeZigZag64(CodedOutputStream.EncodeZigZag64(1)));
+ Assert.AreEqual(-1, CodedInputStream.DecodeZigZag64(CodedOutputStream.EncodeZigZag64(-1)));
+ Assert.AreEqual(14927, CodedInputStream.DecodeZigZag64(CodedOutputStream.EncodeZigZag64(14927)));
+ Assert.AreEqual(-3612, CodedInputStream.DecodeZigZag64(CodedOutputStream.EncodeZigZag64(-3612)));
- Assert.Equal(856912304801416L,
+ Assert.AreEqual(856912304801416L,
CodedInputStream.DecodeZigZag64(CodedOutputStream.EncodeZigZag64(856912304801416L)));
- Assert.Equal(-75123905439571256L,
+ Assert.AreEqual(-75123905439571256L,
CodedInputStream.DecodeZigZag64(CodedOutputStream.EncodeZigZag64(-75123905439571256L)));
}
- [Fact]
+ [Test]
public void TestNegativeEnumNoTag()
{
- Assert.Equal(10, CodedOutputStream.ComputeInt32SizeNoTag(-2));
- Assert.Equal(10, CodedOutputStream.ComputeEnumSizeNoTag(-2));
+ Assert.AreEqual(10, CodedOutputStream.ComputeInt32SizeNoTag(-2));
+ Assert.AreEqual(10, CodedOutputStream.ComputeEnumSizeNoTag(-2));
byte[] bytes = new byte[10];
CodedOutputStream output = CodedOutputStream.CreateInstance(bytes);
output.WriteEnumNoTag(-2);
- Assert.Equal(0, output.SpaceLeft);
- Assert.Equal("FE-FF-FF-FF-FF-FF-FF-FF-FF-01", BitConverter.ToString(bytes));
+ Assert.AreEqual(0, output.SpaceLeft);
+ Assert.AreEqual("FE-FF-FF-FF-FF-FF-FF-FF-FF-01", BitConverter.ToString(bytes));
}
- [Fact]
+ [Test]
public void TestNegativeEnumWithTag()
{
- Assert.Equal(11, CodedOutputStream.ComputeInt32Size(8, -2));
- Assert.Equal(11, CodedOutputStream.ComputeEnumSize(8, -2));
+ Assert.AreEqual(11, CodedOutputStream.ComputeInt32Size(8, -2));
+ Assert.AreEqual(11, CodedOutputStream.ComputeEnumSize(8, -2));
byte[] bytes = new byte[11];
CodedOutputStream output = CodedOutputStream.CreateInstance(bytes);
output.WriteEnum(8, "", -2, -2);
- Assert.Equal(0, output.SpaceLeft);
+ Assert.AreEqual(0, output.SpaceLeft);
//fyi, 0x40 == 0x08 << 3 + 0, field num + wire format shift
- Assert.Equal("40-FE-FF-FF-FF-FF-FF-FF-FF-FF-01", BitConverter.ToString(bytes));
+ Assert.AreEqual("40-FE-FF-FF-FF-FF-FF-FF-FF-FF-01", BitConverter.ToString(bytes));
}
- [Fact]
+ [Test]
public void TestNegativeEnumArrayPacked()
{
int arraySize = 1 + (10 * 5);
@@ -328,22 +328,22 @@ namespace Google.ProtocolBuffers CodedOutputStream output = CodedOutputStream.CreateInstance(bytes);
output.WritePackedEnumArray(8, "", arraySize, new int[] { 0, -1, -2, -3, -4, -5 });
- Assert.Equal(0, output.SpaceLeft);
+ Assert.AreEqual(0, output.SpaceLeft);
CodedInputStream input = CodedInputStream.CreateInstance(bytes);
uint tag;
string name;
- Assert.True(input.ReadTag(out tag, out name));
+ Assert.IsTrue(input.ReadTag(out tag, out name));
List<int> values = new List<int>();
input.ReadInt32Array(tag, name, values);
- Assert.Equal(6, values.Count);
+ Assert.AreEqual(6, values.Count);
for (int i = 0; i > -6; i--)
- Assert.Equal(i, values[Math.Abs(i)]);
+ Assert.AreEqual(i, values[Math.Abs(i)]);
}
- [Fact]
+ [Test]
public void TestNegativeEnumArray()
{
int arraySize = 1 + 1 + (11 * 5);
@@ -352,22 +352,22 @@ namespace Google.ProtocolBuffers CodedOutputStream output = CodedOutputStream.CreateInstance(bytes);
output.WriteEnumArray(8, "", new int[] { 0, -1, -2, -3, -4, -5 });
- Assert.Equal(0, output.SpaceLeft);
+ Assert.AreEqual(0, output.SpaceLeft);
CodedInputStream input = CodedInputStream.CreateInstance(bytes);
uint tag;
string name;
- Assert.True(input.ReadTag(out tag, out name));
+ Assert.IsTrue(input.ReadTag(out tag, out name));
List<int> values = new List<int>();
input.ReadInt32Array(tag, name, values);
- Assert.Equal(6, values.Count);
+ Assert.AreEqual(6, values.Count);
for (int i = 0; i > -6; i--)
- Assert.Equal(i, values[Math.Abs(i)]);
+ Assert.AreEqual(i, values[Math.Abs(i)]);
}
- [Fact]
+ [Test]
public void TestCodedInputOutputPosition()
{
byte[] content = new byte[110];
@@ -380,19 +380,19 @@ namespace Google.ProtocolBuffers CodedOutputStream cout = CodedOutputStream.CreateInstance(ms, 20);
// Field 11: numeric value: 500
cout.WriteTag(11, WireFormat.WireType.Varint);
- Assert.Equal(1, cout.Position);
+ Assert.AreEqual(1, cout.Position);
cout.WriteInt32NoTag(500);
- Assert.Equal(3, cout.Position);
+ Assert.AreEqual(3, cout.Position);
//Field 12: length delimited 120 bytes
cout.WriteTag(12, WireFormat.WireType.LengthDelimited);
- Assert.Equal(4, cout.Position);
+ Assert.AreEqual(4, cout.Position);
cout.WriteBytesNoTag(ByteString.CopyFrom(content));
- Assert.Equal(115, cout.Position);
+ Assert.AreEqual(115, cout.Position);
// Field 13: fixed numeric value: 501
cout.WriteTag(13, WireFormat.WireType.Fixed32);
- Assert.Equal(116, cout.Position);
+ Assert.AreEqual(116, cout.Position);
cout.WriteSFixed32NoTag(501);
- Assert.Equal(120, cout.Position);
+ Assert.AreEqual(120, cout.Position);
cout.Flush();
}
@@ -401,19 +401,19 @@ namespace Google.ProtocolBuffers CodedOutputStream cout = CodedOutputStream.CreateInstance(bytes);
// Field 1: numeric value: 500
cout.WriteTag(1, WireFormat.WireType.Varint);
- Assert.Equal(1, cout.Position);
+ Assert.AreEqual(1, cout.Position);
cout.WriteInt32NoTag(500);
- Assert.Equal(3, cout.Position);
+ Assert.AreEqual(3, cout.Position);
//Field 2: length delimited 120 bytes
cout.WriteTag(2, WireFormat.WireType.LengthDelimited);
- Assert.Equal(4, cout.Position);
+ Assert.AreEqual(4, cout.Position);
cout.WriteBytesNoTag(ByteString.CopyFrom(child));
- Assert.Equal(125, cout.Position);
+ Assert.AreEqual(125, cout.Position);
// Field 3: fixed numeric value: 500
cout.WriteTag(3, WireFormat.WireType.Fixed32);
- Assert.Equal(126, cout.Position);
+ Assert.AreEqual(126, cout.Position);
cout.WriteSFixed32NoTag(501);
- Assert.Equal(130, cout.Position);
+ Assert.AreEqual(130, cout.Position);
cout.Flush();
}
//Now test Input stream:
@@ -422,49 +422,49 @@ namespace Google.ProtocolBuffers uint tag;
int intValue = 0;
string ignore;
- Assert.Equal(0, cin.Position);
+ Assert.AreEqual(0, cin.Position);
// Field 1:
- Assert.True(cin.ReadTag(out tag, out ignore) && tag >> 3 == 1);
- Assert.Equal(1, cin.Position);
- Assert.True(cin.ReadInt32(ref intValue) && intValue == 500);
- Assert.Equal(3, cin.Position);
+ Assert.IsTrue(cin.ReadTag(out tag, out ignore) && tag >> 3 == 1);
+ Assert.AreEqual(1, cin.Position);
+ Assert.IsTrue(cin.ReadInt32(ref intValue) && intValue == 500);
+ Assert.AreEqual(3, cin.Position);
//Field 2:
- Assert.True(cin.ReadTag(out tag, out ignore) && tag >> 3 == 2);
- Assert.Equal(4, cin.Position);
+ Assert.IsTrue(cin.ReadTag(out tag, out ignore) && tag >> 3 == 2);
+ Assert.AreEqual(4, cin.Position);
uint childlen = cin.ReadRawVarint32();
- Assert.Equal(120u, childlen);
- Assert.Equal(5, cin.Position);
+ Assert.AreEqual(120u, childlen);
+ Assert.AreEqual(5, cin.Position);
int oldlimit = cin.PushLimit((int)childlen);
- Assert.Equal(5, cin.Position);
+ Assert.AreEqual(5, cin.Position);
// Now we are reading child message
{
// Field 11: numeric value: 500
- Assert.True(cin.ReadTag(out tag, out ignore) && tag >> 3 == 11);
- Assert.Equal(6, cin.Position);
- Assert.True(cin.ReadInt32(ref intValue) && intValue == 500);
- Assert.Equal(8, cin.Position);
+ Assert.IsTrue(cin.ReadTag(out tag, out ignore) && tag >> 3 == 11);
+ Assert.AreEqual(6, cin.Position);
+ Assert.IsTrue(cin.ReadInt32(ref intValue) && intValue == 500);
+ Assert.AreEqual(8, cin.Position);
//Field 12: length delimited 120 bytes
- Assert.True(cin.ReadTag(out tag, out ignore) && tag >> 3 == 12);
- Assert.Equal(9, cin.Position);
+ Assert.IsTrue(cin.ReadTag(out tag, out ignore) && tag >> 3 == 12);
+ Assert.AreEqual(9, cin.Position);
ByteString bstr = null;
- Assert.True(cin.ReadBytes(ref bstr) && bstr.Length == 110 && bstr.ToByteArray()[109] == 109);
- Assert.Equal(120, cin.Position);
+ Assert.IsTrue(cin.ReadBytes(ref bstr) && bstr.Length == 110 && bstr.ToByteArray()[109] == 109);
+ Assert.AreEqual(120, cin.Position);
// Field 13: fixed numeric value: 501
- Assert.True(cin.ReadTag(out tag, out ignore) && tag >> 3 == 13);
+ Assert.IsTrue(cin.ReadTag(out tag, out ignore) && tag >> 3 == 13);
// ROK - Previously broken here, this returned 126 failing to account for bufferSizeAfterLimit
- Assert.Equal(121, cin.Position);
- Assert.True(cin.ReadSFixed32(ref intValue) && intValue == 501);
- Assert.Equal(125, cin.Position);
- Assert.True(cin.IsAtEnd);
+ Assert.AreEqual(121, cin.Position);
+ Assert.IsTrue(cin.ReadSFixed32(ref intValue) && intValue == 501);
+ Assert.AreEqual(125, cin.Position);
+ Assert.IsTrue(cin.IsAtEnd);
}
cin.PopLimit(oldlimit);
- Assert.Equal(125, cin.Position);
+ Assert.AreEqual(125, cin.Position);
// Field 3: fixed numeric value: 501
- Assert.True(cin.ReadTag(out tag, out ignore) && tag >> 3 == 3);
- Assert.Equal(126, cin.Position);
- Assert.True(cin.ReadSFixed32(ref intValue) && intValue == 501);
- Assert.Equal(130, cin.Position);
- Assert.True(cin.IsAtEnd);
+ Assert.IsTrue(cin.ReadTag(out tag, out ignore) && tag >> 3 == 3);
+ Assert.AreEqual(126, cin.Position);
+ Assert.IsTrue(cin.ReadSFixed32(ref intValue) && intValue == 501);
+ Assert.AreEqual(130, cin.Position);
+ Assert.IsTrue(cin.IsAtEnd);
}
}
}
|