public void ConstructorTest() { byte[] data = { 1, 2, 3 }; var stream = new FastStreamReader(data); // Make sure data is copied/cloned data[0] = 255; Helper.ComparePrivateField(stream, "data", new byte[] { 1, 2, 3 }); Helper.ComparePrivateField(stream, "position", 0); }
public void ConstructorTest() { byte[] data = { 1, 2, 3 }; var stream = new FastStreamReader(data); // Make sure data is NOT cloned (default behavior) data[0] = 255; Helper.ComparePrivateField(stream, "data", new byte[] { 255, 2, 3 }); Helper.ComparePrivateField(stream, "position", 0); }
public void TryDeserialize_FailTest(FastStreamReader stream, MockDeserializableSigScript scr, string expErr) { var tx = new TxIn() { SigScript = scr }; bool b = tx.TryDeserialize(stream, out string error); Assert.False(b); Assert.Equal(expErr, error); }
public void TryRead_Fail_SmallStreamTest() { FastStreamReader stream = new FastStreamReader(new byte[3] { 1, 2, 3 }); bool b = LockTime.TryRead(stream, out LockTime actual, out string error); Assert.False(b); Assert.Equal(Err.EndOfStream, error); Helper.ComparePrivateField(actual, "value", 0U); }
public void TryReadByteArrayTest() { var stream = new FastStreamReader(Helper.GetBytes(12)); bool b = stream.TryReadByteArray(10, out byte[] actual); byte[] expected = Helper.GetBytes(10); Assert.True(b); Assert.Equal(expected, actual); Assert.Equal(10, stream.GetCurrentIndex()); }
public void GetRemainingBytesCountTest() { var stream = new FastStreamReader(new byte[10]); Assert.Equal(10, stream.GetRemainingBytesCount()); _ = stream.TryReadByteArray(2, out _); Assert.Equal(8, stream.GetRemainingBytesCount()); _ = stream.TryReadByteArray(1, out _); Assert.Equal(7, stream.GetRemainingBytesCount()); _ = stream.TryReadByteArray(7, out _); Assert.Equal(0, stream.GetRemainingBytesCount()); }
public void CompareBytesTest(byte[] data, byte[] other, bool skip, bool expected) { var stream = new FastStreamReader(data); if (skip) { stream.SkipOneByte(); } bool actual = stream.CompareBytes(other); Assert.Equal(expected, actual); }
public void TryDeserialize_InvalidServiceTest() { NetworkAddress addr = new NetworkAddress(); var stream = new FastStreamReader(Helper.HexToBytes("ffffffffffffffff00000000000000000000ffffc0000233208d")); bool b = addr.TryDeserialize(stream, out string error); Assert.True(b, error); Assert.Null(error); Assert.Equal(ulong.MaxValue, (ulong)addr.NodeServices); Assert.Equal(IPAddress.Parse("192.0.2.51"), addr.NodeIP); Assert.Equal((ushort)8333, addr.NodePort); }
public void SizeTest() { // MainNet block #557991 containing 2 txs with witness var blk = new Block(); var stream = new FastStreamReader(Helper.HexToBytes("000080206689707b09f987d19036a404af1cba3e4abe93fc216931000000000000000000f789b5842f2ff0d1e3ebb4e8321fb53f14b9ee22d2e0def211e3f681e1322f7ca8d5375ca51832177894b5eb02010000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff5503a783081c4d696e656420627920416e74506f6f6c31323052000102205c37d5a8fabe6d6db555462795a64abe912fd1c529d8a154aff792f7ec154c6a959c449047d1898404000000000000006019000045dc0000ffffffff021889814a000000001976a914edf10a7fac6b32e24daa5305c723f3de58db1bc888ac0000000000000000266a24aa21a9ed02a7c90fe9795d0af5206b29acea5111d03eb8219fff0a67577a5c948244186901200000000000000000000000000000000000000000000000000000000000000000000000000100000000010145140fe1397a86a940a55e5207d719593143bc23e5fa12ab84c5e61a1b9d852012000000171600140cdda6079ebeaf15d6c6ae29a04b71aeb9842c8affffffff0228e525000000000016001481cf43e0c29625336d275db4e586701c052bafcfb88c2900000000001976a914206e6b76851048928bf7d84ace3b94239ccdf53888ac02473044022056fa2da21a28b2ab9d83dc0cdb18f2d207a7a12af24c1e958056ba28dd29247d02203be11e97bbc3ff43d8907091cb3c5e665ae08947723d11e0d53392e7b0f03634012103cd354d51e44ad77599ba9fce6727c08e5925b9dcaedcea8e5be0bca25e65af9200000000")); bool b = blk.TryDeserialize(stream, out string error); Assert.True(b, error); Assert.Equal(582, blk.TotalSize); Assert.Equal(437, blk.StrippedSize); Assert.Equal(1893, blk.Weight); }
public void TryDeserializeTest() { PingPayload ping = new PingPayload(); FastStreamReader stream = new FastStreamReader(new byte[8] { 2, 0, 0, 0, 0, 0, 0, 0 }); bool b = ping.TryDeserialize(stream, out string error); Assert.True(b, error); Assert.Null(error); Assert.Equal(2L, ping.Nonce); }
public void SkipOneByteTest() { var stream = new FastStreamReader(new byte[5]); Assert.Equal(0, stream.GetCurrentIndex()); stream.SkipOneByte(); Assert.Equal(1, stream.GetCurrentIndex()); stream.SkipOneByte(); Assert.Equal(2, stream.GetCurrentIndex()); }
public void GetCurrentIndexTest() { var stream = new FastStreamReader(new byte[10]); Assert.Equal(0, stream.GetCurrentIndex()); _ = stream.TryReadByteArray(3, out _); Assert.Equal(3, stream.GetCurrentIndex()); _ = stream.TryReadByteArray(5, out _); Assert.Equal(8, stream.GetCurrentIndex()); _ = stream.TryReadByteArray(2, out _); Assert.Equal(10, stream.GetCurrentIndex()); }
public void TryDeserializeTest() { var addr = new NetworkAddressWithTime(); var stream = new FastStreamReader(Helper.HexToBytes("d91f4854010000000000000000000000000000000000ffffc0000233208d")); bool b = addr.TryDeserialize(stream, out string error); Assert.True(b, error); Assert.Null(error); Assert.Equal(1414012889U, addr.Time); Assert.Equal(NodeServiceFlags.NodeNetwork, addr.NodeServices); Assert.Equal(IPAddress.Parse("192.0.2.51"), addr.NodeIP); Assert.Equal((ushort)8333, addr.NodePort); }
public void CheckRemainingTest() { var stream = new FastStreamReader(new byte[5]); Assert.True(stream.CheckRemaining(1)); Assert.True(stream.CheckRemaining(5)); Assert.False(stream.CheckRemaining(6)); _ = stream.TryReadByteArray(2, out _); Assert.True(stream.CheckRemaining(1)); Assert.False(stream.CheckRemaining(5)); Assert.False(stream.CheckRemaining(6)); }
public void TryDeserialize_FailTest(FastStreamReader stream, MockDeserializableTx tx, string expErr) { TxPayload pl = new TxPayload() { Tx = tx }; bool b = pl.TryDeserialize(stream, out string error); Assert.False(b); Assert.Equal(expErr, error); // Mock tx has its own tests. }
public void TryDeserializeTest() { FeeFilterPayload pl = new FeeFilterPayload(); FastStreamReader stream = new FastStreamReader(new byte[8] { 0x7c, 0xbd, 0, 0, 0, 0, 0, 0 }); bool b = pl.TryDeserialize(stream, out string error); Assert.True(b, error); Assert.Null(error); Assert.Equal(48_508UL, pl.FeeRate); Assert.Equal(PayloadType.FeeFilter, pl.PayloadType); }
public void TryDeserialize_FailTest(FastStreamReader stream, MockDeserializableBlock block, string expErr) { BlockPayload pl = new BlockPayload() { BlockData = block }; bool b = pl.TryDeserialize(stream, out string error); Assert.False(b); Assert.Equal(expErr, error); // Mock block has its own tests. }
/// <summary> /// Creates a new instance of <see cref="Signature"/> by reading it from a DER encoded byte array with loose rules. /// Return value indicates success. /// </summary> /// <param name="derSig">Signature bytes encoded using DER encoding</param> /// <param name="result">Resulting signature (null in case of failure)</param> /// <param name="error">Error message (null if sucessful, otherwise contains information about the failure)</param> /// <returns>True if successful, otherwise false.</returns> public static bool TryReadLoose(byte[] derSig, out Signature result, out string error) { result = null; if (derSig == null) { error = "Byte array can not be null."; return(false); } // Min = 3006[0201(01)0201(01)]-01 if (derSig.Length < 9) { // This also handles the Length == 0 case error = "Invalid DER encoding length."; return(false); } FastStreamReader stream = new FastStreamReader(derSig); if (!stream.TryReadByte(out byte seqTag) || seqTag != SequenceTag) { error = "Sequence tag was not found in DER encoded signature."; return(false); } if (!stream.TryReadDerLength(out int seqLen)) { error = "Invalid sequence length."; return(false); } if (seqLen < 6 || !stream.CheckRemaining(seqLen + 1)) // +1 is the SigHash byte (at least 1 byte) { error = "Invalid total length according to sequence length."; return(false); } if (!stream.TryReadByte(out byte intTag1) || intTag1 != IntegerTag) { error = "First integer tag was not found in DER encoded signature."; return(false); } if (!stream.TryReadDerLength(out int rLen) || rLen == 0) { error = "Invalid R length."; return(false); } if (!stream.TryReadByteArray(rLen, out byte[] rBa))
public void TryDeserializeTest() { BlockPayload pl = new BlockPayload() { BlockData = new MockDeserializableBlock(0, 3) }; FastStreamReader stream = new FastStreamReader(new byte[3]); bool b = pl.TryDeserialize(stream, out string error); Assert.True(b, error); Assert.Null(error); // Mock block has its own tests. Assert.Equal(PayloadType.Block, pl.PayloadType); }
public void TryDeserializeTest() { TxPayload pl = new TxPayload() { Tx = new MockDeserializableTx(0, 3) }; FastStreamReader stream = new FastStreamReader(new byte[3]); bool b = pl.TryDeserialize(stream, out string error); Assert.True(b, error); Assert.Null(error); // Mock tx has its own tests. Assert.Equal(PayloadType.Tx, pl.PayloadType); }
public override bool TryDeserialize(FastStreamReader stream, out string error) { int actualIndex = stream.GetCurrentIndex(); Assert.Equal(expectedIndex, actualIndex); if (!stream.TryReadByteArray(bytesToRead, out _)) { Assert.True(false, "Stream doesn't have enough bytes."); } error = retError; return(string.IsNullOrEmpty(retError)); }
public void TryDeserializeTest() { byte[] mockBlkHash = Helper.GetBytes(32); // 2 random small size tx taken from a block explorer: string tx1 = "0100000001defccf0ab6f1ce363820fd8ffc59e1a455e520ad37ed2b4b781fddbffbe0b1fd00000000025200ffffffff01151605000000000017a914de2b27afd4498dc5688f5b511a8be5aad26820338700000000"; string tx2 = "0100000001310f060f19fd067aed414c3902ac70693c67f753dcc34e6bddcfe4fabe6aa32000000000025100ffffffff01ee340200000000001976a9145c0189a6094fe13177cd47b9a9ee0ec92509365388ac00000000"; var stream = new FastStreamReader(Helper.HexToBytes($"{Helper.GetBytesHex(32)}02{tx1}{tx2}")); var pl = new BlockTxnPayload(); bool b = pl.TryDeserialize(stream, out string error); Assert.True(b, error); Assert.Null(error); Assert.Equal(mockBlkHash, pl.BlockHash); Assert.Equal(2, pl.Transactions.Length); }
public void TryDeserializeTest(Inventory[] items, byte[] data) { var pl = new InvPayload(); var stream = new FastStreamReader(data); bool success = pl.TryDeserialize(stream, out string error); Assert.True(success, error); Assert.Null(error); Assert.Equal(items.Length, pl.InventoryList.Length); for (int i = 0; i < items.Length; i++) { Assert.Equal(items[i].InvType, pl.InventoryList[i].InvType); Assert.Equal(items[i].Hash, pl.InventoryList[i].Hash); } }
public void TryDeserializeTest() { GetBlocksPayload pl = new GetBlocksPayload(); FastStreamReader stream = new FastStreamReader(Helper.HexToBytes(PayloadHex)); bool b = pl.TryDeserialize(stream, out string error); byte[] hd1 = Helper.HexToBytes(Header1); byte[] hd2 = Helper.HexToBytes(Header2); Assert.True(b, error); Assert.Null(error); Assert.Equal(Version, pl.Version); Assert.Equal(new byte[][] { hd1, hd2 }, pl.Hashes); Assert.Equal(new byte[32], pl.StopHash); Assert.Equal(PayloadType.GetBlocks, pl.PayloadType); }
public void TryDeserializeTest(byte[] data, MockDeserializableSigScript scr, byte[] expHash, uint expIndex, uint expSeq) { TxIn tx = new TxIn() { SigScript = scr }; FastStreamReader stream = new FastStreamReader(data); bool b = tx.TryDeserialize(stream, out string error); Assert.True(b, error); Assert.Null(error); Assert.Equal(expHash, tx.TxHash); Assert.Equal(expIndex, tx.Index); Assert.Equal(expSeq, tx.Sequence); // Mock script has its own tests. }
private static object Deserialize(FastStreamReader streamReader) { using (PersistReader reader = new PersistReader()) { bool enableTypeRemapping = Persist.EnableTypeRemapping; Persist.EnableTypeRemapping = false; bool requireAllPersistable = Persist.RequireAllPersistable; Persist.RequireAllPersistable = true; try { reader.Load(streamReader, null); } finally { Persist.EnableTypeRemapping = enableTypeRemapping; Persist.RequireAllPersistable = requireAllPersistable; } return((reader.Count > 0) ? reader[0] : null); } }
public void SkipTest() { var stream = new FastStreamReader(new byte[10]); Assert.Equal(0, stream.GetCurrentIndex()); stream.Skip(0); Assert.Equal(0, stream.GetCurrentIndex()); stream.Skip(1); Assert.Equal(1, stream.GetCurrentIndex()); stream.Skip(4); Assert.Equal(5, stream.GetCurrentIndex()); stream.Skip(7); Assert.Equal(12, stream.GetCurrentIndex()); Assert.False(stream.CheckRemaining(1)); }
/// <summary> /// Loads data that was written to the game cache with the given tag, /// and deserializes it back into an object instance. /// </summary> /// <param name="tag">A unique string that identifies the cached data to be loaded.</param> /// <returns>The deserialized object instance that was stored in the game cache.</returns> public object LoadTuningData(string tag) { if (!this.mIsCacheVerified) { this.VerifyCache(); } if (!this.mIsCachingEnabled) { return(null); } uint handle = CacheManager_ReadCachedDataAsStream(tag); if (handle == 0) { return(null); } using (FastStreamReader reader = new FastStreamReader(handle)) { return(Deserialize(reader)); } }
public void TryDeserializeTest() { AddrPayload pl = new AddrPayload(); FastStreamReader stream = new FastStreamReader(Helper.HexToBytes("02" + addr1Hex + addr2Hex)); bool b = pl.TryDeserialize(stream, out string error); Assert.True(b, error); Assert.Null(error); Assert.Equal(2, pl.Addresses.Length); Assert.Equal(addr1.Time, pl.Addresses[0].Time); Assert.Equal(addr1.NodeServices, pl.Addresses[0].NodeServices); Assert.Equal(addr1.NodeIP, pl.Addresses[0].NodeIP); Assert.Equal(addr1.NodePort, pl.Addresses[0].NodePort); Assert.Equal(addr2.Time, pl.Addresses[1].Time); Assert.Equal(addr2.NodeServices, pl.Addresses[1].NodeServices); Assert.Equal(addr2.NodeIP, pl.Addresses[1].NodeIP); Assert.Equal(addr2.NodePort, pl.Addresses[1].NodePort); Assert.Equal(PayloadType.Addr, pl.PayloadType); }
/// <inheritdoc/> public override bool TryDeserialize(FastStreamReader stream, out string error) { if (stream is null) { error = "Stream can not be null."; return(false); } if (!CompactInt.TryRead(stream, out CompactInt count, out error)) { return(false); } Headers = new Block[count]; for (int i = 0; i < (int)count; i++) { Block temp = new Block(); if (!temp.TryDeserializeHeader(stream, out error)) { return(false); } Headers[i] = temp; if (!stream.TryReadByte(out byte zero)) { error = Err.EndOfStream; return(false); } if (zero != 0) { error = "Transaction count in a headers message must be zero."; return(false); } } error = null; return(true); }
public void Read(FastStreamReader reader, IPersistReader persistReader) { int position = reader.Position; reader.ReadUInt32(); uint num2 = reader.ReadUInt32(); uint num3 = reader.ReadUInt32(); uint num4 = reader.ReadUInt32(); uint num5 = reader.ReadUInt32(); int[] numArray = new int[num2]; reader.Seek(position + ((int)num3), SeekOrigin.Begin); for (uint i = 0x0; i < num2; i++) { numArray[i] = reader.ReadInt32(); } reader.Seek(position + ((int)num5), SeekOrigin.Begin); mMethodList.Capacity = (int)num4; mMethodList.Clear(); for (uint j = 0x0; j < num4; j++) { MethodEntry entry; MethodInfo methodInfo = (MethodInfo)persistReader.ReadReferenceForceLive(); if (ScriptCore.ExceptionTrap.GetOption("ResetTaskStates") == 1) { entry.checksum = 0; } else { entry.checksum = reader.ReadUInt32(); } if (methodInfo != null) { uint num8; entry.handle = methodInfo.MethodHandle; if (!ScriptCore.TaskControl.GetMethodChecksum(entry.handle, out num8)) { entry.handle = new RuntimeMethodHandle(); } else if (num8 != entry.checksum) { entry.handle = new RuntimeMethodHandle(); } else if (!this.IsMethodSaveSafe(methodInfo)) { } } else { entry.handle = new RuntimeMethodHandle(); } this.mMethodList.Add(entry); } this.mSavedTaskContexts = new ScriptCore.SavedTaskContext[num2]; for (uint k = 0x0; k < num2; k++) { int num10 = numArray[k]; if (num10 == 0x0) { this.mSavedTaskContexts[k] = InvalidSavedTaskContext; } else if (num10 >= 0x0) { reader.Seek(position + num10, SeekOrigin.Begin); ScriptCore.SavedTaskContext invalidSavedTaskContext = ReadTask(reader, persistReader); if (invalidSavedTaskContext == null) { invalidSavedTaskContext = InvalidSavedTaskContext; } this.mSavedTaskContexts[k] = invalidSavedTaskContext; } } }
/* .method public hidebysig newslot virtual final instance void Read(class Sims3.SimIFace.FastStreamReader reader, class Sims3.SimIFace.IPersistReader persistReader) cil managed * * object V_4, class [mscorlib]System.Type V_5, class [mscorlib]System.Reflection.MethodInfo V_6, object[] V_7) IL_0000: ldarg.2 IL_0001: callvirt instance object [SimIFace]Sims3.SimIFace.IPersistReader::ReadReference() IL_0006: castclass [mscorlib]System.Type IL_000b: stloc.0 IL_000c: ldarg.1 IL_000d: callvirt instance string [SimIFace]Sims3.SimIFace.FastStreamReader::ReadString() IL_0012: stloc.1 IL_0013: ldarg.2 IL_0014: callvirt instance object [SimIFace]Sims3.SimIFace.IPersistReader::ReadReference() IL_0019: stloc.2 IL_001a: ldloc.0 IL_001b: brfalse.s IL_0099 IL_001d: ldnull IL_001e: stloc.3 IL_001f: ldloc.0 IL_0020: ldloc.1 IL_0021: ldc.i4.s 56 IL_0023: callvirt instance class [mscorlib]System.Reflection.FieldInfo [mscorlib]System.Type::GetField(string, valuetype [mscorlib]System.Reflection.BindingFlags) IL_0028: stloc.3 IL_0029: ldloc.3 IL_002a: brfalse.s IL_0099 IL_002c: ldloc.3 IL_002d: callvirt instance bool [mscorlib]System.Reflection.FieldInfo::get_IsStatic() IL_0032: brfalse.s IL_0099 IL_0034: ldloc.3 IL_0035: call bool [SimIFace]Sims3.SimIFace.PersistStatic::IsFieldSerializable(class [mscorlib]System.Reflection.FieldInfo) IL_003a: brfalse.s IL_0099 .try { IL_003c: ldloc.3 IL_003d: ldnull IL_003e: ldloc.2 IL_003f: callvirt instance void [mscorlib]System.Reflection.FieldInfo::SetValue(object, object) IL_0044: ldloc.3 IL_0045: ldnull IL_0046: callvirt instance object [mscorlib]System.Reflection.FieldInfo::GetValue(object) IL_004b: stloc.s V_4 IL_004d: ldstr "ScriptCore.ExceptionTrap, ScriptCore" IL_0052: call class [mscorlib]System.Type [mscorlib]System.Type::GetType(string) IL_0057: stloc.s V_5 IL_0059: ldloc.s V_5 IL_005b: brfalse.s IL_0094 IL_005d: ldloc.s V_5 IL_005f: ldstr "ExternalLoadReference" IL_0064: ldc.i4.s 24 IL_0066: callvirt instance class [mscorlib]System.Reflection.MethodInfo [mscorlib]System.Type::GetMethod(string, valuetype [mscorlib]System.Reflection.BindingFlags) IL_006b: stloc.s V_6 IL_006d: ldloc.s V_6 IL_006f: brfalse.s IL_0094 IL_0071: ldloc.s V_6 IL_0073: ldnull IL_0074: ldc.i4.3 IL_0075: newarr [mscorlib]System.Object IL_007a: stloc.s V_7 IL_007c: ldloc.s V_7 IL_007e: ldc.i4.0 IL_007f: ldloc.2 IL_0080: stelem.ref IL_0081: ldloc.s V_7 IL_0083: ldc.i4.1 IL_0084: ldloc.s V_4 IL_0086: stelem.ref IL_0087: ldloc.s V_7 IL_0089: ldc.i4.2 IL_008a: ldloc.3 IL_008b: stelem.ref IL_008c: ldloc.s V_7 IL_008e: callvirt instance object [mscorlib]System.Reflection.MethodBase::Invoke(object, object[]) IL_0093: pop IL_0094: leave.s IL_0099 } // end .try catch [mscorlib]System.ArgumentException { IL_0096: pop IL_0097: leave.s IL_0099 } // end handler IL_0099: ret */ public void Read(FastStreamReader reader, IPersistReader persistReader) { Type type = (Type)persistReader.ReadReference(); string name = reader.ReadString(); object obj2 = persistReader.ReadReference(); if (type != null) { FieldInfo fieldInfo = null; fieldInfo = type.GetField(name, BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static); if (((fieldInfo != null) && fieldInfo.IsStatic) && PersistStatic.IsFieldSerializable(fieldInfo)) { try { fieldInfo.SetValue(null, obj2); object parent = fieldInfo.GetValue(null); Type exceptionTrap = Type.GetType("ScriptCore.ExceptionTrap, ScriptCore"); if (exceptionTrap != null) { MethodInfo loadReference = exceptionTrap.GetMethod("ExternalLoadReference", BindingFlags.Public | BindingFlags.Static); if (loadReference != null) { loadReference.Invoke(null, new object[] { obj2, parent, fieldInfo }); } } } catch (ArgumentException) { } } } }