public void TestMergeCodedInput()
{
var message = SampleMessages.CreateFullTestAllTypes();
var emptyMessage = new TestEmptyMessage();
emptyMessage.MergeFrom(message.ToByteArray());
Assert.AreEqual(message.CalculateSize(), emptyMessage.CalculateSize());
Assert.AreEqual(message.ToByteArray(), emptyMessage.ToByteArray());
var newMessage = new TestAllTypes();
newMessage.MergeFrom(emptyMessage.ToByteArray());
Assert.AreEqual(message, newMessage);
Assert.AreEqual(message.CalculateSize(), newMessage.CalculateSize());
}
public void ReadWholeMessage_VaryingBlockSizes()
{
TestAllTypes message = SampleMessages.CreateFullTestAllTypes();
byte[] rawBytes = message.ToByteArray();
Assert.AreEqual(rawBytes.Length, message.CalculateSize());
TestAllTypes message2 = TestAllTypes.Parser.ParseFrom(rawBytes);
Assert.AreEqual(message, message2);
// Try different block sizes.
for (int blockSize = 1; blockSize < 256; blockSize *= 2)
{
message2 = TestAllTypes.Parser.ParseFrom(new SmallBlockInputStream(rawBytes, blockSize));
Assert.AreEqual(message, message2);
}
}
public void ReadWholeMessage_VaryingBlockSizes_FromSequence()
{
TestAllTypes message = SampleMessages.CreateFullTestAllTypes();
byte[] rawBytes = message.ToByteArray();
Assert.AreEqual(rawBytes.Length, message.CalculateSize());
TestAllTypes message2 = TestAllTypes.Parser.ParseFrom(rawBytes);
Assert.AreEqual(message, message2);
// Try different block sizes.
for (int blockSize = 1; blockSize < 256; blockSize *= 2)
{
message2 = TestAllTypes.Parser.ParseFrom(ReadOnlySequenceFactory.CreateWithContent(rawBytes, blockSize));
Assert.AreEqual(message, message2);
}
}
private void TestManyChangesWithSnapshot(TestAllTypes root, TestAllTypes allTypes)
{
for (int i = 0; i < 10; i++)
{
var i1 = i;
AssertEventsStableWithSnapshot(root, () => { SetSingular(allTypes, i1); });
AssertEventsStableWithSnapshot(root, () => { SetEnums(allTypes, i1); });
AssertEventsStableWithSnapshot(root, () => { SetNestedMessages(allTypes, i1); });
AssertEventsStableWithSnapshot(root, () => { UpdateNestedMessages(allTypes, i1); });
AssertEventsStableWithSnapshot(root, () => { ClearRepeated(allTypes); });
AssertEventsStableWithSnapshot(root, () => { AddRepeated(allTypes, i1); });
AssertEventsStableWithSnapshot(root, () => { RemoveRepeated(allTypes, i1); });
AssertEventsStableWithSnapshot(root, () => { AddRepeated(allTypes, i1); });
AssertEventsStableWithSnapshot(root, () => { RemoveAtRepeated(allTypes, 0); });
AssertEventsStableWithSnapshot(root, () => { AddRepeated(allTypes, i1); });
AssertEventsStableWithSnapshot(root, () => { ReplaceRepeated(allTypes, 0, i1); }, false);
AssertEventsStableWithSnapshot(root, () => { ReplaceRepeated(allTypes, 0, i1 + 1); });
AssertEventsStableWithSnapshot(root, () => { InsertRepeated(allTypes, 0, i1 + 2); });
AssertEventsStableWithSnapshot(root, () => { ClearRepeated(allTypes); });
AssertEventsStableWithSnapshot(root, () => { AddRepeated(allTypes, i1); });
AssertEventsStableWithSnapshot(root, () => { UpdateRepeated(allTypes, 0, i1 + 1); });
AssertEventsStableWithSnapshot(root, () => { ClearMap(allTypes); });
AssertEventsStableWithSnapshot(root, () => { AddMap(allTypes, i1, i1); });
AssertEventsStableWithSnapshot(root, () => { RemoveMap(allTypes, i1); });
AssertEventsStableWithSnapshot(root, () => { AddMap(allTypes, i1, i1); });
AssertEventsStableWithSnapshot(root, () => { ReplaceMap(allTypes, i1, i1); }, false);
AssertEventsStableWithSnapshot(root, () => { ReplaceMap(allTypes, i1, i1 + 1); });
AssertEventsStableWithSnapshot(root, () => { ClearMap(allTypes); });
AssertEventsStableWithSnapshot(root, () => { AddMap(allTypes, i1, i1); });
AssertEventsStableWithSnapshot(root, () => { UpdateMap(allTypes, i1, i1 + 1); });
AssertEventsStableWithSnapshot(root, () => { allTypes.OneofUint32 = UintValue(i1); });
AssertEventsStableWithSnapshot(root, () => { allTypes.OneofNestedMessage = NestedMessageValue(i1); });
AssertEventsStableWithSnapshot(root, () => { allTypes.OneofString = StringValue(i1); });
AssertEventsStableWithSnapshot(root, () => { allTypes.OneofBytes = ByteValue(i1); });
AssertEventsStableWithSnapshot(root, () => { allTypes.OneofForeignMessage = ForeignMessageValue(i1); });
AssertEventsStableWithSnapshot(root, () => { allTypes.OneofForeignMessageNoEvents = ForeignMessageNoEventsValue(i1); });
AssertEventsStableWithSnapshot(root, () => { allTypes.OneofAllTypes = TestAllTypesValue(i1); });
AssertEventsStableWithSnapshot(root, () => { allTypes.OneofAllTypesNoEvents = TestAllTypesNoEventsValue(i1); });
AssertEventsStableWithSnapshot(root, () => { allTypes.AllTypes = TestAllTypesValue(i1 * 2); });
AssertEventsStableWithSnapshot(root, () => { SetSingular(allTypes.AllTypes, i1 * 2 + 1); });
AssertEventsStableWithSnapshot(root, () => { allTypes.AllTypesNoEvents = TestAllTypesNoEventsValue(i1); });
}
// list only changes
for (int i = 0; i < 10; i++)
{
var i1 = i;
AssertEventsStableWithClone(root, () => { AddRepeated(allTypes, i1); });
}
for (int i = 0; i < 10; i++)
{
var i1 = i;
AssertEventsStableWithClone(root, () => { UpdateRepeated(allTypes, i1, i1 + 1); });
}
// map only changes
for (int i = 0; i < 10; i++)
{
var i1 = i;
AssertEventsStableWithClone(root, () => { ReplaceMap(allTypes, i1, i1); });
}
for (int i = 0; i < 10; i++)
{
var i1 = i;
AssertEventsStableWithClone(root, () => { UpdateMap(allTypes, i1, i1 + 1); });
}
// just some basic sanity that these methods don't throw exceptions
Assert.True(root.CalculateSize() > 0);
Assert.True(root.GetHashCode() != 1);
}
