public static CreateInstance ( Stream input ) : |
||
input | Stream | |
return |
public void ReadMaliciouslyLargeBlob() { MemoryStream ms = new MemoryStream(); CodedOutputStream output = CodedOutputStream.CreateInstance(ms); uint tag = WireFormat.MakeTag(1, WireFormat.WireType.LengthDelimited); output.WriteRawVarint32(tag); output.WriteRawVarint32(0x7FFFFFFF); output.WriteRawBytes(new byte[32]); // Pad with a few random bytes. output.Flush(); ms.Position = 0; CodedInputStream input = CodedInputStream.CreateInstance(ms); uint testtag; string ignore; Assert.IsTrue(input.ReadTag(out testtag, out ignore)); Assert.AreEqual(tag, testtag); ByteString bytes = null; // TODO(jonskeet): Should this be ArgumentNullException instead? Assert.Throws <InvalidProtocolBufferException>(() => input.ReadBytes(ref bytes)); }
public void TestNegativeEnumArray() { int arraySize = 1 + 1 + (11 * 5); int msgSize = arraySize; byte[] bytes = new byte[msgSize]; CodedOutputStream output = CodedOutputStream.CreateInstance(bytes); output.WriteEnumArray(8, "", new int[] { 0, -1, -2, -3, -4, -5 }); Assert.AreEqual(0, output.SpaceLeft); CodedInputStream input = CodedInputStream.CreateInstance(bytes); uint tag; string name; Assert.IsTrue(input.ReadTag(out tag, out name)); List <int> values = new List <int>(); input.ReadInt32Array(tag, name, values); Assert.AreEqual(6, values.Count); for (int i = 0; i > -6; i--) { Assert.AreEqual(i, values[Math.Abs(i)]); } }
public void TestSlowPathAvoidance() { using (var ms = new MemoryStream()) { CodedOutputStream output = CodedOutputStream.CreateInstance(ms); output.WriteField(FieldType.Bytes, 1, "bytes", ByteString.CopyFrom(new byte[100])); output.WriteField(FieldType.Bytes, 2, "bytes", ByteString.CopyFrom(new byte[100])); output.Flush(); ms.Position = 0; CodedInputStream input = CodedInputStream.CreateInstance(ms, new byte[ms.Length / 2]); uint tag; string ignore; ByteString value; Assert.IsTrue(input.ReadTag(out tag, out ignore)); Assert.AreEqual(1, WireFormat.GetTagFieldNumber(tag)); value = ByteString.Empty; Assert.IsTrue(input.ReadBytes(ref value) && value.Length == 100); Assert.IsTrue(input.ReadTag(out tag, out ignore)); Assert.AreEqual(2, WireFormat.GetTagFieldNumber(tag)); value = ByteString.Empty; Assert.IsTrue(input.ReadBytes(ref value) && value.Length == 100); } }
public void ReadInvalidUtf8() { MemoryStream ms = new MemoryStream(); CodedOutputStream output = CodedOutputStream.CreateInstance(ms); uint tag = WireFormat.MakeTag(1, WireFormat.WireType.LengthDelimited); output.WriteRawVarint32(tag); output.WriteRawVarint32(1); output.WriteRawBytes(new byte[] { 0x80 }); output.Flush(); ms.Position = 0; CodedInputStream input = CodedInputStream.CreateInstance(ms); uint testtag; string ignored; Assert.IsTrue(input.ReadTag(out testtag, out ignored)); Assert.AreEqual(tag, testtag); string text = null; input.ReadString(ref text); Assert.AreEqual('\ufffd', text[0]); }
/// <summary> /// Parses the given bytes using ReadRawVarint32() and ReadRawVarint64() and /// </summary> private static void AssertReadVarint(byte[] data, ulong value) { CodedInputStream input = CodedInputStream.CreateInstance(data); Assert.AreEqual((uint)value, input.ReadRawVarint32()); input = CodedInputStream.CreateInstance(data); Assert.AreEqual(value, input.ReadRawVarint64()); Assert.IsTrue(input.IsAtEnd); // Try different block sizes. for (int bufferSize = 1; bufferSize <= 16; bufferSize *= 2) { input = CodedInputStream.CreateInstance(new SmallBlockInputStream(data, bufferSize)); Assert.AreEqual((uint)value, input.ReadRawVarint32()); input = CodedInputStream.CreateInstance(new SmallBlockInputStream(data, bufferSize)); Assert.AreEqual(value, input.ReadRawVarint64()); Assert.IsTrue(input.IsAtEnd); } // Try reading directly from a MemoryStream. We want to verify that it // doesn't read past the end of the input, so write an extra byte - this // lets us test the position at the end. MemoryStream memoryStream = new MemoryStream(); memoryStream.Write(data, 0, data.Length); memoryStream.WriteByte(0); memoryStream.Position = 0; Assert.AreEqual((uint)value, CodedInputStream.ReadRawVarint32(memoryStream)); Assert.AreEqual(data.Length, memoryStream.Position); }
public void SkipWholeMessage() { TestAllTypes message = TestUtil.GetAllSet(); byte[] rawBytes = message.ToByteArray(); // Create two parallel inputs. Parse one as unknown fields while using // skipField() to skip each field on the other. Expect the same tags. CodedInputStream input1 = CodedInputStream.CreateInstance(rawBytes); CodedInputStream input2 = CodedInputStream.CreateInstance(rawBytes); UnknownFieldSet.Builder unknownFields = UnknownFieldSet.CreateBuilder(); uint tag; string name; while (input1.ReadTag(out tag, out name)) { uint tag2; Assert.IsTrue(input2.ReadTag(out tag2, out name)); Assert.AreEqual(tag, tag2); unknownFields.MergeFieldFrom(tag, input1); input2.SkipField(); } }
/// <summary> /// Parses the given bytes using ReadRawVarint32() and ReadRawVarint64() and /// expects them to fail with an InvalidProtocolBufferException whose /// description matches the given one. /// </summary> private static void AssertReadVarintFailure(InvalidProtocolBufferException expected, byte[] data) { CodedInputStream input = CodedInputStream.CreateInstance(data); try { input.ReadRawVarint32(); Assert.Fail("Should have thrown an exception."); } catch (InvalidProtocolBufferException e) { Assert.AreEqual(expected.Message, e.Message); } input = CodedInputStream.CreateInstance(data); try { input.ReadRawVarint64(); Assert.Fail("Should have thrown an exception."); } catch (InvalidProtocolBufferException e) { Assert.AreEqual(expected.Message, e.Message); } // Make sure we get the same error when reading directly from a Stream. try { CodedInputStream.ReadRawVarint32(new MemoryStream(data)); Assert.Fail("Should have thrown an exception."); } catch (InvalidProtocolBufferException e) { Assert.AreEqual(expected.Message, e.Message); } }
public void TestBufferRefillIssue() { var ms = new MemoryStream(); BucketOfBytes.CreateBuilder() .SetValue(ByteString.CopyFrom(new byte[3000])) .Build().WriteDelimitedTo(ms); BucketOfBytesEx.CreateBuilder() .SetValue(ByteString.CopyFrom(new byte[1000])) .SetValue2(ByteString.CopyFrom(new byte[1100])) .Build().WriteDelimitedTo(ms); BucketOfBytes.CreateBuilder() .SetValue(ByteString.CopyFrom(new byte[100])) .Build().WriteDelimitedTo(ms); ms.Position = 0; 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); input.ReadMessage(builder, ExtensionRegistry.Empty); Assert.AreEqual(5114, input.Position); Assert.AreEqual(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); }
public void TestNegativeEnumArray() { int arraySize = 1 + 1 + (11 * 5); int msgSize = arraySize; byte[] bytes = new byte[msgSize]; CodedOutputStream output = CodedOutputStream.CreateInstance(bytes); output.WriteInt32Array(8, "", new int[] { 0, -1, -2, -3, -4, -5 }); Assert.AreEqual(0, output.SpaceLeft); CodedInputStream input = CodedInputStream.CreateInstance(bytes); uint tag; string name; Assert.IsTrue(input.ReadTag(out tag, out name)); List <TestNegEnum> values = new List <TestNegEnum>(); ICollection <object> unk; input.ReadEnumArray(tag, name, values, out unk); Assert.AreEqual(2, values.Count); Assert.AreEqual(TestNegEnum.None, values[0]); Assert.AreEqual(TestNegEnum.Value, values[1]); Assert.IsNotNull(unk); Assert.AreEqual(4, unk.Count); }
public IEnumerator <TMessage> GetEnumerator() { using (Stream stream = streamProvider()) { CodedInputStream input = CodedInputStream.CreateInstance(stream); input.SetSizeLimit(sizeLimit); uint tag; string name; while (input.ReadTag(out tag, out name)) { if ((tag == 0 && name == "item") || (tag == ExpectedTag)) { IBuilder builder = defaultMessageInstance.WeakCreateBuilderForType(); input.ReadMessage(builder, extensionRegistry); yield return((TMessage)builder.WeakBuild()); } else { throw InvalidProtocolBufferException.InvalidMessageStreamTag(); } input.ResetSizeCounter(); } } }
public void ResetSizeCounter() { CodedInputStream input = CodedInputStream.CreateInstance( new SmallBlockInputStream(new byte[256], 8)); input.SetSizeLimit(16); input.ReadRawBytes(16); try { input.ReadRawByte(); Assert.Fail("Should have thrown an exception!"); } catch (InvalidProtocolBufferException) { // Success. } input.ResetSizeCounter(); input.ReadRawByte(); // No exception thrown. try { input.ReadRawBytes(16); // Hits limit again. Assert.Fail("Should have thrown an exception!"); } catch (InvalidProtocolBufferException) { // Success. } }
public void ReadMaliciouslyLargeBlob() { MemoryStream ms = new MemoryStream(); CodedOutputStream output = CodedOutputStream.CreateInstance(ms); uint tag = WireFormat.MakeTag(1, WireFormat.WireType.LengthDelimited); output.WriteRawVarint32(tag); output.WriteRawVarint32(0x7FFFFFFF); output.WriteRawBytes(new byte[32]); // Pad with a few random bytes. output.Flush(); ms.Position = 0; CodedInputStream input = CodedInputStream.CreateInstance(ms); uint testtag; string ignore; Assert.IsTrue(input.ReadTag(out testtag, out ignore)); Assert.AreEqual(tag, testtag); try { ByteString bytes = null; input.ReadBytes(ref bytes); Assert.Fail("Should have thrown an exception!"); } catch (InvalidProtocolBufferException) { // success. } }
public TBuilder MergeFrom(Stream input, ExtensionRegistry extensionRegistry) { CodedInputStream codedInput = CodedInputStream.CreateInstance(input); MergeFrom(codedInput, extensionRegistry); codedInput.CheckLastTagWas(0); return(ThisBuilder); }
/// <summary> /// Parses <paramref name="data"/> as an UnknownFieldSet and merge it /// with the set being built. This is just a small wrapper around /// MergeFrom(ICodedInputStream). /// </summary> public Builder MergeFrom(byte[] data) { CodedInputStream input = CodedInputStream.CreateInstance(data); MergeFrom(input); input.CheckLastTagWas(0); return(this); }
public TBuilder MergeFrom(byte[] data, ExtensionRegistry extensionRegistry) { CodedInputStream codedInputStream = CodedInputStream.CreateInstance(data); this.MergeFrom(codedInputStream, extensionRegistry); codedInputStream.CheckLastTagWas(0u); return(this.ThisBuilder); }
/// <summary> /// Parses <paramref name="input"/> as an UnknownFieldSet and merge it /// with the set being built. This is just a small wrapper around /// MergeFrom(ICodedInputStream). /// </summary> public Builder MergeFrom(Stream input) { CodedInputStream codedInput = CodedInputStream.CreateInstance(input); MergeFrom(codedInput); codedInput.CheckLastTagWas(0); return(this); }
public TBuilder MergeFrom(Stream input) { CodedInputStream codedInputStream = CodedInputStream.CreateInstance(input); this.MergeFrom(codedInputStream); codedInputStream.CheckLastTagWas(0u); return(this.ThisBuilder); }
public TBuilder MergeFrom(byte[] data, ExtensionRegistry extensionRegistry) { CodedInputStream input = CodedInputStream.CreateInstance(data); MergeFrom(input, extensionRegistry); input.CheckLastTagWas(0); return(ThisBuilder); }
byte[] IWireTransfer.Execute(string method, byte[] message) { //now when we recieve a wire transmission to invoke a method by name with a byte[] or stream payload //we just simply call the sub: IMessageLite response = _stub.CallMethod(method, CodedInputStream.CreateInstance(message), ExtensionRegistry.Empty); //now we return the expected response message: return(response.ToByteArray()); }
public void SizeLimit() { // Have to use a Stream rather than ByteString.CreateCodedInput as SizeLimit doesn't // apply to the latter case. MemoryStream ms = new MemoryStream(TestUtil.GetAllSet().ToByteString().ToByteArray()); CodedInputStream input = CodedInputStream.CreateInstance(ms); input.SetSizeLimit(16); Assert.Throws <InvalidProtocolBufferException>(() => TestAllTypes.ParseFrom(input)); }
public void SkipRawBytesBug() { byte[] rawBytes = new byte[] { 1, 2 }; CodedInputStream input = CodedInputStream.CreateInstance(rawBytes); int limit = input.PushLimit(1); input.SkipRawBytes(1); input.PopLimit(limit); Assert.AreEqual(2, input.ReadRawByte()); }
public void TestBuilderLiteMergeFromCodedInputStream() { TestAllTypesLite copy, msg = TestAllTypesLite.CreateBuilder() .SetOptionalString("Should be merged.").Build(); copy = TestAllTypesLite.DefaultInstance; Assert.AreNotEqual(msg.ToByteArray(), copy.ToByteArray()); copy = copy.ToBuilder().MergeFrom(CodedInputStream.CreateInstance(new MemoryStream(msg.ToByteArray()))).Build(); Assert.AreEqual(msg.ToByteArray(), copy.ToByteArray()); }
public void TestNegativeEnum() { byte[] bytes = new byte[10] { 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x01 }; CodedInputStream input = CodedInputStream.CreateInstance(bytes); object unk; TestNegEnum val = TestNegEnum.None; Assert.IsTrue(input.ReadEnum(ref val, out unk)); Assert.IsTrue(input.IsAtEnd); Assert.AreEqual(TestNegEnum.Value, val); }
/// <summary> /// Parses the given bytes using ReadRawLittleEndian64() and checks /// that the result matches the given value. /// </summary> private static void AssertReadLittleEndian64(byte[] data, ulong value) { CodedInputStream input = CodedInputStream.CreateInstance(data); Assert.AreEqual(value, input.ReadRawLittleEndian64()); // Try different block sizes. for (int blockSize = 1; blockSize <= 16; blockSize *= 2) { input = CodedInputStream.CreateInstance( new SmallBlockInputStream(data, blockSize)); Assert.AreEqual(value, input.ReadRawLittleEndian64()); } }
public IEnumerator <TMessage> GetEnumerator() { using (Stream stream = streamProvider()) { CodedInputStream input = CodedInputStream.CreateInstance(stream); uint tag; while ((tag = input.ReadTag()) != 0) { if (tag != ExpectedTag) { throw InvalidProtocolBufferException.InvalidMessageStreamTag(); } yield return(messageReader(input, extensionRegistry)); } } }
public void TestMergeFromCodedInputStream() { TestAllTypesLite copy, msg = TestAllTypesLite.CreateBuilder() .SetOptionalUint32(uint.MaxValue).Build(); copy = TestAllTypesLite.DefaultInstance; Assert.AreNotEqual(msg.ToByteArray(), copy.ToByteArray()); using (MemoryStream ms = new MemoryStream(msg.ToByteArray())) { CodedInputStream ci = CodedInputStream.CreateInstance(ms); copy = copy.ToBuilder().MergeFrom(ci).Build(); } Assert.AreEqual(msg.ToByteArray(), copy.ToByteArray()); }
public void ResetSizeCounter() { CodedInputStream input = CodedInputStream.CreateInstance( new SmallBlockInputStream(new byte[256], 8)); input.SetSizeLimit(16); input.ReadRawBytes(16); Assert.Throws <InvalidProtocolBufferException>(() => input.ReadRawByte()); input.ResetSizeCounter(); input.ReadRawByte(); // No exception thrown. Assert.Throws <InvalidProtocolBufferException>(() => input.ReadRawBytes(16)); }
/// <summary> /// Parses the given bytes using ReadRawVarint32() and ReadRawVarint64() and /// expects them to fail with an InvalidProtocolBufferException whose /// description matches the given one. /// </summary> private static void AssertReadVarintFailure(InvalidProtocolBufferException expected, byte[] data) { CodedInputStream input = CodedInputStream.CreateInstance(data); var exception = Assert.Throws <InvalidProtocolBufferException>(() => input.ReadRawVarint32()); Assert.AreEqual(expected.Message, exception.Message); input = CodedInputStream.CreateInstance(data); exception = Assert.Throws <InvalidProtocolBufferException>(() => input.ReadRawVarint64()); Assert.AreEqual(expected.Message, exception.Message); // Make sure we get the same error when reading directly from a Stream. exception = Assert.Throws <InvalidProtocolBufferException>(() => CodedInputStream.ReadRawVarint32(new MemoryStream(data))); Assert.AreEqual(expected.Message, exception.Message); }
public void SizeLimit() { // Have to use a Stream rather than ByteString.CreateCodedInput as SizeLimit doesn't // apply to the latter case. MemoryStream ms = new MemoryStream(TestUtil.GetAllSet().ToByteString().ToByteArray()); CodedInputStream input = CodedInputStream.CreateInstance(ms); input.SetSizeLimit(16); try { TestAllTypes.ParseFrom(input); Assert.Fail("Should have thrown an exception!"); } catch (InvalidProtocolBufferException) { // success. } }
/// <summary> /// Parses the given bytes using ReadRawVarint32() and ReadRawVarint64() and /// expects them to fail with an InvalidProtocolBufferException whose /// description matches the given one. /// </summary> private void AssertReadVarintFailure(InvalidProtocolBufferException expected, byte[] data) { CodedInputStream input = CodedInputStream.CreateInstance(data); try { input.ReadRawVarint32(); Assert.Fail("Should have thrown an exception."); } catch (InvalidProtocolBufferException e) { Assert.AreEqual(expected.Message, e.Message); } input = CodedInputStream.CreateInstance(data); try { input.ReadRawVarint64(); Assert.Fail("Should have thrown an exception."); } catch (InvalidProtocolBufferException e) { Assert.AreEqual(expected.Message, e.Message); } }