Example #1
0
        public void FixedArrayOversizedException()
        {
            long[] bytes   = new long[] { 1, 4546, long.MaxValue, 0, 1, 2 };
            var    encoder = EncoderFactory.LoadEncoder("int64[5]", bytes, EncoderFactory.LoadEncoder("int64", default(long)));

            Assert.Throws <ArgumentOutOfRangeException>(() => encoder.ToEncodedHex());
        }
Example #2
0
        internal DbfRecord(BinaryReader reader, DbfHeader header, List <DbfField> fields, byte[] memoData, Encoding encoding)
        {
            this.fields = fields;
            Data        = new List <object>();

            // Read record marker.
            byte marker = reader.ReadByte();

            // Read entire record as sequence of bytes.
            // Note that record length includes marker.
            byte[] row = reader.ReadBytes(header.RecordLength - 1);

            // Read data for each field.
            int offset = 0;

            foreach (DbfField field in fields)
            {
                // Copy bytes from record buffer into field buffer.
                byte[] buffer = new byte[field.Length];
                Array.Copy(row, offset, buffer, 0, field.Length);
                offset += field.Length;

                IEncoder encoder = EncoderFactory.GetEncoder(field.Type);
                Data.Add(encoder.Decode(buffer, memoData, encoding));
            }
        }
Example #3
0
        public static async Task RunServerAsync(int port, EncoderFactory encryptor, DecoderFactory decryptor, bool isWorldClient)
        {
            MultithreadEventLoopGroup bossGroup   = new MultithreadEventLoopGroup(1);
            MultithreadEventLoopGroup workerGroup = new MultithreadEventLoopGroup();

            try
            {
                ServerBootstrap bootstrap = new ServerBootstrap();
                bootstrap
                .Group(bossGroup, workerGroup)
                .Channel <TcpServerSocketChannel>()
                .ChildHandler(new ActionChannelInitializer <ISocketChannel>(channel =>
                {
                    SessionFactory.Instance.Sessions[channel.Id.AsLongText()] = 0;
                    IChannelPipeline pipeline = channel.Pipeline;
                    pipeline.AddLast((MessageToMessageDecoder <IByteBuffer>)decryptor.GetDecoder());
                    pipeline.AddLast(new ClientSession(channel, isWorldClient));
                    pipeline.AddLast((MessageToMessageEncoder <string>)encryptor.GetEncoder());
                }));

                IChannel bootstrapChannel = await bootstrap.BindAsync(port).ConfigureAwait(false);

                Console.ReadLine();

                await bootstrapChannel.CloseAsync().ConfigureAwait(false);
            }
            catch (Exception ex)
            {
                Logger.Log.Error(ex.Message);
            }
            finally
            {
                Task.WaitAll(bossGroup.ShutdownGracefullyAsync(), workerGroup.ShutdownGracefullyAsync());
            }
        }
Example #4
0
        public virtual void writeCompressed(ExtendedDataOutput output)
        {
            int dataType            = (int)this.getDataType();
            int unitLength          = getUnitLength(this.getDataType());
            int elementCount        = this.rows();
            int maxCompressedLength = this.rows() * sizeof(long) * 8 * 2 + 64 * 3;

            ByteBuffer outBuffer = ByteBuffer.Allocate(Math.Max(maxCompressedLength, 65536));

            outBuffer.order(output.GetType() == typeof(LittleEndianDataOutputStream));
            short flag = (short)((short)DATA_FORM.DF_VECTOR << 8 | (short)DATA_TYPE.DT_COMPRESS & 0xff);

            outBuffer.WriteShort(flag);
            outBuffer.WriteInt(0);                     // compressedBytes
            outBuffer.WriteInt(1);                     // cols
            outBuffer.WriteByte((byte)0);              // version
            outBuffer.WriteByte((byte)1);              // flag bit0:littleEndian bit1:containChecksum
            outBuffer.WriteByte(unchecked ((byte)-1)); // charcode
            outBuffer.WriteByte((byte)compressedMethod);
            outBuffer.WriteByte((byte)dataType);
            outBuffer.WriteByte((byte)unitLength);
            outBuffer.WriteByte((byte)0);
            outBuffer.WriteByte((byte)0);
            outBuffer.WriteInt(-1); //extra
            outBuffer.WriteInt(elementCount);
            outBuffer.WriteInt(-1); //TODO: checkSum
            EncoderFactory.Get(compressedMethod).compress(this, elementCount, unitLength, maxCompressedLength, outBuffer);
            int compressedLength = outBuffer.ReadableBytes - 10;

            outBuffer.PutInt(compressedLength, 2);
            byte[] tmp = new byte[outBuffer.ReadableBytes];
            output.write(outBuffer.ToArray());
        }
Example #5
0
        public void FunctionDataDecode_MixedParamTypes()
        {
            var encoded = "0x00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000100ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd4920000000000000000000000000000000000000000000000000000000000000140000000000000000000000000000000000000000000000000000000000000006300000000000000000000000000000000000000000000000000000000000000090000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffffffffffffff00000000000000000000000000000000000000000000000000000000000000096d7920737472696e670000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000300000000000000000000000098e4625b2d7424c403b46366150ab28df406340800000000000000000000000040515114eea1497d753659dff85910f838c6b234000000000000000000000000df0270a6bff43e7a3fd92372dfb549292d683d22";
            var ethFunc = EthFunc.Create <bool, string, long, Address[], byte, ulong[]>(
                null, null,
                "bool", DecoderFactory.Decode,
                "string", DecoderFactory.Decode,
                "int56", DecoderFactory.Decode,
                "address[]", DecoderFactory.GetArrayDecoder(EncoderFactory.LoadEncoder("address", default(Address))),
                "uint8", DecoderFactory.Decode,
                "uint64[3]", DecoderFactory.GetArrayDecoder(EncoderFactory.LoadEncoder("uint64", default(ulong))));

            var p1 = true;
            var p2 = "my string";
            var p3 = (long)-11118;
            var p4 = new Address[] { "0x98E4625b2d7424C403B46366150AB28Df4063408", "0x40515114eEa1497D753659DFF85910F838c6B234", "0xDf0270A6BFf43e7A3Fd92372DfB549292D683D22" };
            var p5 = (byte)99;
            var p6 = new ulong[] { 9, 0, ulong.MaxValue };

            var(r1, r2, r3, r4, r5, r6) = ethFunc.ParseReturnData(encoded.HexToBytes());

            Assert.Equal(p1, r1);
            Assert.Equal(p2, r2);
            Assert.Equal(p3, r3);
            Assert.Equal(p4, r4);
            Assert.Equal(p5, r5);
            Assert.Equal(p6, r6);
        }
        public void NextTest(bool increment)
        {
            if (_count == 5)
            {
                this.Controls.Clear();
                Controls.Add(new FinishControl(0, 5));
            }

            var function = RandomGenerator.NextTrithemiusFunction();
            var key      = RandomGenerator.NextKey();
            var message  = RandomGenerator.NextENGMessage();

            IAlphabetEncoder trithemius = EncoderFactory
                                          .CreateEncoder(EncoderType.Trithemius)
                                          .SetMonoAlphabet(Alphabet.GetMono(MonoAlphabet.ENG))
                                          .Configure(key, (Func <int, int>)function);

            _enc = trithemius;
            _mes = message;

            label7.Text        = function.ToString();
            label8.Text        = key.ToString();
            lbDescription.Text = message;

            if (increment)
            {
                _count++;
            }

            lbCurrentTask.Text = _count.ToString();
        }
        public void Setup()
        {
            factory = new EncoderFactory();
            request = new Mock<HttpRequestBase>();
            headers = new NameValueCollection();

            request.Setup(r => r.Headers).Returns(headers);
        }
Example #8
0
        static void Main(string[] args)
        {
            var ENG_ALPHA = Alphabet.GetMono(MonoAlphabet.ENG);
            var UTF16     = Alphabet.GetMono(MonoAlphabet.UTF16);

            IAlphabetEncoder caesar = EncoderFactory
                                      .CreateEncoder(EncoderType.Caesar)
                                      .SetMonoAlphabet(UTF16)
                                      .Configure(1);

            IAlphabetEncoder trithemius = EncoderFactory
                                          .CreateEncoder(EncoderType.Trithemius)
                                          .SetMonoAlphabet(ENG_ALPHA)
                                          .Configure(2, new Func <int, int>(x => x + 1));

            IAlphabetEncoder vigener = EncoderFactory
                                       .CreateEncoder(EncoderType.Vigenere)
                                       .Configure("Lemon");

            IAlphabetEncoder diffiHelman = EncoderFactory
                                           .CreateEncoder(EncoderType.DiffiHelman)
                                           .Configure(5, 23, new List <int>()
            {
                23, 43
            });
            IAlphabetEncoder elgamal = EncoderFactory
                                       .CreateEncoder(EncoderType.Elgamal)
                                       .Configure(11, 2, 8, 9);

            IAlphabetEncoder des = EncoderFactory
                                   .CreateBitEncoder(BitEncodingType.Des)
                                   .Configure("чр3Ъ");

            Console.WriteLine(caesar.Encode("Azb12365.,&^%$@"));

            Console.WriteLine(trithemius.Decode(trithemius.Encode("Azb")));

            Console.WriteLine(vigener.Encode("ATTACKATDAWN"));
            Console.WriteLine(diffiHelman.Decode(null));
            Console.WriteLine(elgamal.Decode("5"));
            Console.WriteLine(elgamal.Encode("6,9"));

            string input = "Input";

            BitMessage mess   = BitMessage.Parse(input);
            string     binary = mess.ToBinaryString();

            string output = mess.ToString();

            Console.WriteLine($"\n{input}\n{binary}\n{output}");
            byte[] b   = new UnicodeEncoding().GetBytes(des.Encode("Do you know"));
            string str = new UnicodeEncoding().GetString(b);

            Console.WriteLine(str);
            b.ToList().ForEach(x => Console.WriteLine(x));

            Console.ReadLine();
        }
Example #9
0
        /// <summary>
        /// Return the encoded contents, including mime
        /// header.
        /// </summary>
        /// <returns></returns>
        public String ToDataString()
        {
            IEncoder      encoder = EncoderFactory.GetEncoder(Encoding);
            StringBuilder sb      = new StringBuilder();

            sb.Append(GetInternalMimeHeader(encoder));
            sb.Append(GetEncodedContents(encoder));
            return(sb.ToString());
        }
Example #10
0
 /// <exception cref="System.IO.IOException"/>
 internal EventWriter(FSDataOutputStream @out)
 {
     this.@out = @out;
     @out.WriteBytes(Version);
     @out.WriteBytes("\n");
     @out.WriteBytes(Event.Schema$.ToString());
     @out.WriteBytes("\n");
     this.encoder = EncoderFactory.Get().JsonEncoder(Event.Schema$, @out);
 }
Example #11
0
        public void ExportSubfile(string arcname, string name, string path)
        {
            var subfile = GetSubfile(arcname, name);

            using (FileStream fs = new FileStream(path, FileMode.Create))
                using (IEncoder encoder = EncoderFactory.GetEncoder(subfile, Archive))
                    using (Stream stream = encoder.Decode())
                        stream.CopyTo(fs);
        }
        /// <summary>
        /// Deploys the contract.  <para/>
        /// </summary>
        /// <param name = "total"><c>uint256</c></param>
        /// <param name = "rpcClient">The RPC client to be used for this contract instance.</param>
        /// <param name = "defaultFromAccount">If null then the first account returned by eth_accounts will be used.</param>
        /// <returns>An contract instance pointed at the deployed contract address.</returns>
        public static async Task <ERC20Basic> Deploy(Meadow.Core.EthTypes.UInt256 total, Meadow.JsonRpc.Client.IJsonRpcClient rpcClient, Meadow.JsonRpc.Types.TransactionParams transactionParams = null, Meadow.Core.EthTypes.Address?defaultFromAccount = null)
        {
            transactionParams      = transactionParams ?? new Meadow.JsonRpc.Types.TransactionParams();
            defaultFromAccount     = defaultFromAccount ?? transactionParams.From ?? (await rpcClient.Accounts())[0];
            transactionParams.From = transactionParams.From ?? defaultFromAccount;
            var encodedParams = Meadow.Core.AbiEncoding.EncoderUtil.Encode(EncoderFactory.LoadEncoder("uint256", total));
            var contractAddr  = await ContractFactory.Deploy(rpcClient, BYTECODE_BYTES.Value, transactionParams, encodedParams);

            return(new ERC20Basic(rpcClient, contractAddr, defaultFromAccount.Value));
        }
Example #13
0
        public Stream ReadSubfile(string archiveName, string name)
        {
            var file = GetSubfile(archiveName, name);

            if (file == null)
            {
                throw new Exception("Couldn't find the subfile " + archiveName + "/" + name);
            }

            using (IEncoder encoder = EncoderFactory.GetEncoder(file, Archive))
                return(encoder.Decode());
        }
Example #14
0
        public void FunctionDataEncode_MultipleStringParams()
        {
            var funcSig  = "echoMultipleDynamic(string,string,string)";
            var strP1    = "first string";
            var strP2    = "asdf";
            var strP3    = "utf8; 4 bytes: 𠾴; 3 bytes: ⏰ works!";
            var callData = EncoderUtil.GetFunctionCallBytes(
                funcSig,
                EncoderFactory.LoadEncoder("string", strP1),
                EncoderFactory.LoadEncoder("string", strP2),
                EncoderFactory.LoadEncoder("string", strP3));
            var expectedEncode = "0x14d6b8fa000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000e0000000000000000000000000000000000000000000000000000000000000000c666972737420737472696e670000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000461736466000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000028757466383b20342062797465733a20f0a0beb43b20332062797465733a20e28fb020776f726b7321000000000000000000000000000000000000000000000000";

            Assert.Equal(expectedEncode, callData.ToHexString(hexPrefix: true));
        }
        public CalculationResult Calculate(string input)
        {
            var result = CalculationResult.StartCalculations
                             (input, _monoAlphabet, EncoderType.Trithemius, _codingType, out IMonoAlphabet alpha);

            IAlphabetEncoder trithemius = EncoderFactory
                                          .CreateEncoder(EncoderType.Trithemius)
                                          .SetMonoAlphabet(alpha)
                                          .Configure(_key, (Func <int, int>)_map);

            var output = _codingType == CodingType.Encoding
                ? trithemius.Encode(input) : trithemius.Decode(input);

            return(result.WithKey(_key.ToString()).WithFunction(_map).EndCalculations(output));
        }
        public CalculationResult Calculate(string input)
        {
            var result = CalculationResult.StartCalculations
                             (input, _monoAlphabet, EncoderType.Caesar, _codingType, out IMonoAlphabet alpha);

            IAlphabetEncoder caesar = EncoderFactory
                                      .CreateEncoder(EncoderType.Caesar)
                                      .SetMonoAlphabet(alpha)
                                      .Configure(_key);

            var output = _codingType == CodingType.Encoding
                ? caesar.Encode(input) : caesar.Decode(input);

            return(result.WithKey(_key.ToString()).EndCalculations(output));
        }
Example #17
0
        internal void Write(BinaryWriter writer)
        {
            // Write marker (always "not deleted")
            writer.Write((byte)0x20);

            int index = 0;

            foreach (DbfField field in fields)
            {
                IEncoder encoder = EncoderFactory.GetEncoder(field.Type);
                byte[]   buffer  = encoder.Encode(field, data[index]);
                writer.Write(buffer);
                index++;
            }
        }
Example #18
0
        /// <exception cref="System.Exception"/>
        public static void TestReflect(object value, Type type, string schema)
        {
            // check that schema matches expected
            Schema s = ((ReflectData)ReflectData.Get()).GetSchema(type);

            Assert.Equal(Schema.Parse(schema), s);
            // check that value is serialized correctly
            ReflectDatumWriter <object> writer = new ReflectDatumWriter <object>(s);
            ByteArrayOutputStream       @out   = new ByteArrayOutputStream();

            writer.Write(value, EncoderFactory.Get().DirectBinaryEncoder(@out, null));
            ReflectDatumReader <object> reader = new ReflectDatumReader <object>(s);
            object after = reader.Read(null, DecoderFactory.Get().BinaryDecoder(@out.ToByteArray
                                                                                    (), null));

            Assert.Equal(value, after);
        }
Example #19
0
        public void Int56()
        {
            var num     = (long)-11118;
            var encoder = EncoderFactory.LoadEncoder("int56", num);

            Assert.IsType <Int64Encoder>(encoder);
            var encodedSize = encoder.GetEncodedSize();

            Assert.Equal(32, encodedSize);
            Span <byte> data = new byte[encodedSize];
            var         buff = new AbiEncodeBuffer(data, "int56");

            encoder.Encode(ref buff);
            Assert.Equal(0, buff.HeadCursor.Length);
            var result = HexUtil.GetHexFromBytes(data, hexPrefix: false);

            Assert.Equal("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd492", result);
        }
Example #20
0
        public void Int256_2()
        {
            BigInteger num     = 4294923588;
            var        encoder = EncoderFactory.LoadEncoder("int256", num);

            Assert.IsType <Int256Encoder>(encoder);
            var encodedSize = encoder.GetEncodedSize();

            Assert.Equal(32, encodedSize);
            Span <byte> data = new byte[encodedSize];
            var         buff = new AbiEncodeBuffer(data, "int256");

            encoder.Encode(ref buff);
            Assert.Equal(0, buff.HeadCursor.Length);
            var result = HexUtil.GetHexFromBytes(data, hexPrefix: false);

            Assert.Equal("00000000000000000000000000000000000000000000000000000000ffff5544", result);
        }
Example #21
0
        public void Address()
        {
            Address myAddr  = "0x11f4d0A3c12e86B4b5F39B213F7E19D048276DAe";
            var     encoder = EncoderFactory.LoadEncoder("address", myAddr);

            Assert.IsType <AddressEncoder>(encoder);
            var encodedSize = encoder.GetEncodedSize();

            Assert.Equal(32, encodedSize);
            Span <byte> data   = new byte[encodedSize];
            var         buffer = new AbiEncodeBuffer(data, "address");

            encoder.Encode(ref buffer);
            Assert.Equal(0, buffer.HeadCursor.Length);
            var result = HexUtil.GetHexFromBytes(data, hexPrefix: false);

            Assert.Equal("00000000000000000000000011f4d0a3c12e86b4b5f39b213f7e19d048276dae", result);
        }
Example #22
0
        public void Int24_1()
        {
            int num     = 77216;
            var encoder = EncoderFactory.LoadEncoder("int24", num);

            Assert.IsType <Int32Encoder>(encoder);
            var encodedSize = encoder.GetEncodedSize();

            Assert.Equal(32, encodedSize);
            Span <byte> data = new byte[encodedSize];
            var         buff = new AbiEncodeBuffer(data, "int24");

            encoder.Encode(ref buff);
            Assert.Equal(0, buff.HeadCursor.Length);
            var result = HexUtil.GetHexFromBytes(data, hexPrefix: false);

            Assert.Equal("0000000000000000000000000000000000000000000000000000000000012da0", result);
        }
Example #23
0
        /// <summary>
        /// From a RIFF wave. WIP.
        /// </summary>
        /// <param name="r"></param>
        public FISP(RiffWave r)
        {
            regions = new List <RegionInfo>();
            tracks  = new List <TrackInfo>();
            data    = new DataInfo();
            stream  = new StreamInfo();

            //Data.
            if (r.fmt.bitsPerSample == 16)
            {
                short[][] pcm16 = new short[r.data.channels.Count][];
                for (int i = 0; i < r.data.channels.Count; i++)
                {
                    pcm16[i] = r.data.channels[i].pcm16.ToArray();
                }
                data.data = pcm16.ToList();
            }
            else
            {
                byte[][] pcm8 = new byte[r.data.channels.Count][];
                for (int i = 0; i < r.data.channels.Count; i++)
                {
                    pcm8[i] = r.data.channels[i].pcm8.ToArray();
                }
                data.data = EncoderFactory.Pcm8ToPcm16(pcm8).ToList();
            }

            //Stream info.
            stream.sampleRate = r.fmt.sampleRate;
            stream.encoding   = 2;
            if (data.data.Count > 0)
            {
                stream.loopEnd = (uint)data.data[0].Length;
            }
            if (r.smpl != null)
            {
                if (r.smpl.loops.Count > 0)
                {
                    stream.isLoop    = true;
                    stream.loopStart = stream.originalLoopStart = r.smpl.loops[0].startSample;
                    stream.loopEnd   = stream.originalLoopEnd = r.smpl.loops[0].endSample;
                }
            }
        }
Example #24
0
        public void UInt8FixedArray()
        {
            byte[] bytes   = HexUtil.HexToBytes("072696e746");
            var    encoder = EncoderFactory.LoadEncoder("uint8[5]", bytes, EncoderFactory.LoadEncoder("uint8", default(byte)));

            Assert.IsType <FixedArrayEncoder <byte> >(encoder);
            var encodedSize = encoder.GetEncodedSize();

            Assert.True(encodedSize % 32 == 0);
            Assert.Equal(160, encodedSize);
            Span <byte> data = new byte[encodedSize];
            var         buff = new AbiEncodeBuffer(data, "uint8[5]");

            encoder.Encode(ref buff);
            Assert.Equal(0, buff.HeadCursor.Length);
            var result = HexUtil.GetHexFromBytes(data);

            Assert.Equal("00000000000000000000000000000000000000000000000000000000000000070000000000000000000000000000000000000000000000000000000000000026000000000000000000000000000000000000000000000000000000000000009600000000000000000000000000000000000000000000000000000000000000e70000000000000000000000000000000000000000000000000000000000000046", result);
        }
Example #25
0
        public void String()
        {
            var str     = "Hello, world!";
            var encoder = EncoderFactory.LoadEncoder("string", str);

            Assert.IsType <StringEncoder>(encoder);
            var encodedSize = encoder.GetEncodedSize();

            Assert.True(encodedSize % 32 == 0);
            Assert.Equal(96, encodedSize);
            Span <byte> data = new byte[encodedSize];
            var         buff = new AbiEncodeBuffer(data, "string");

            encoder.Encode(ref buff);
            Assert.Equal(0, buff.HeadCursor.Length);
            var result = HexUtil.GetHexFromBytes(data);

            Assert.Equal("0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000d48656c6c6f2c20776f726c642100000000000000000000000000000000000000", result);
        }
Example #26
0
        public void StringUnicode()
        {
            var str     = "utf8; 4 bytes: 𠾴; 3 bytes: ⏰ works!";
            var encoder = EncoderFactory.LoadEncoder("string", str);

            Assert.IsType <StringEncoder>(encoder);
            var encodedSize = encoder.GetEncodedSize();

            Assert.True(encodedSize % 32 == 0);
            Assert.Equal(128, encodedSize);
            Span <byte> data = new byte[encodedSize];
            var         buff = new AbiEncodeBuffer(data, "string");

            encoder.Encode(ref buff);
            Assert.Equal(0, buff.HeadCursor.Length);
            var result = HexUtil.GetHexFromBytes(data);

            Assert.Equal("00000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000028757466383b20342062797465733a20f0a0beb43b20332062797465733a20e28fb020776f726b7321000000000000000000000000000000000000000000000000", result);
        }
Example #27
0
        public Tuple <AnswerType, string> CheckAnswer(
            IQuestion currentQuestion,
            MonoAlphabet mono,
            PolyAlphabet poly,
            params object[] args)
        {
            IAlphabetEncoder encoder = EncoderFactory
                                       .CreateEncoder(currentQuestion.EncodingType)
                                       .SetMonoAlphabet(Alphabet.GetMono(mono))
                                       .Configure(args);
            string answer = String.Empty;

            switch (currentQuestion.CodingType)
            {
            case CodingType.Decoding:
                answer =
                    encoder.Decode(currentQuestion.Description.Description);

                if (currentQuestion.Answer.Answer.ToLower()
                    .Equals(answer.ToLower()))
                {
                    return(new Tuple <AnswerType, string>
                               (AnswerType.Correct, answer));
                }
                break;

            case CodingType.Encoding:
                answer =
                    encoder.Encode(currentQuestion.Description.Description);

                if (currentQuestion.Answer.Answer.ToLower()
                    .Equals(answer.ToLower()))
                {
                    return(new Tuple <AnswerType, string>
                               (AnswerType.Correct, answer));
                }
                break;
            }


            return(new Tuple <AnswerType, string>
                       (AnswerType.NotCorrect, answer));
        }
Example #28
0
        public void LargeString()
        {
            var str     = "Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book.";
            var encoder = EncoderFactory.LoadEncoder("string", str);

            Assert.IsType <StringEncoder>(encoder);
            var encodedSize = encoder.GetEncodedSize();

            Assert.True(encodedSize % 32 == 0);
            Assert.Equal(320, encodedSize);
            Span <byte> data = new byte[encodedSize];
            var         buff = new AbiEncodeBuffer(data, "string");

            encoder.Encode(ref buff);
            Assert.Equal(0, buff.HeadCursor.Length);
            var result = HexUtil.GetHexFromBytes(data);

            Assert.Equal("000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000f54c6f72656d20497073756d2069732073696d706c792064756d6d792074657874206f6620746865207072696e74696e6720616e64207479706573657474696e6720696e6475737472792e204c6f72656d20497073756d20686173206265656e2074686520696e6475737472792773207374616e646172642064756d6d79207465787420657665722073696e6365207468652031353030732c207768656e20616e20756e6b6e6f776e207072696e74657220746f6f6b20612067616c6c6579206f66207479706520616e6420736372616d626c656420697420746f206d616b65206120747970652073706563696d656e20626f6f6b2e0000000000000000000000", result);
        }
Example #29
0
        public void Bytes()
        {
            byte[] bytes   = HexUtil.HexToBytes("207072696e74657220746f6f6b20612067616c6c6579206f66207479706520616e6420736372616d626c656420697420746f206d616b65206120747970");
            var    encoder = EncoderFactory.LoadEncoder("bytes", bytes);

            Assert.IsType <BytesEncoder>(encoder);
            var encodedSize = encoder.GetEncodedSize();

            Assert.True(encodedSize % 32 == 0);
            Assert.Equal(128, encodedSize);
            Span <byte> data = new byte[encodedSize];
            var         buff = new AbiEncodeBuffer(data, "bytes");

            encoder.Encode(ref buff);
            Assert.Equal(0, buff.HeadCursor.Length);
            var result = HexUtil.GetHexFromBytes(data);

            Assert.Equal("0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000003d207072696e74657220746f6f6b20612067616c6c6579206f66207479706520616e6420736372616d626c656420697420746f206d616b65206120747970000000", result);
        }
Example #30
0
        public void Int64FixedArray()
        {
            long[] bytes   = new long[] { 1, 4546, long.MaxValue, 0, long.MaxValue };
            var    encoder = EncoderFactory.LoadEncoder("int64[5]", bytes, EncoderFactory.LoadEncoder("int64", default(long)));

            Assert.IsType <FixedArrayEncoder <long> >(encoder);
            var encodedSize = encoder.GetEncodedSize();

            Assert.True(encodedSize % 32 == 0);
            Assert.Equal(160, encodedSize);
            Span <byte> data = new byte[encodedSize];
            var         buff = new AbiEncodeBuffer(data, "int64[5]");

            encoder.Encode(ref buff);
            Assert.Equal(0, buff.HeadCursor.Length);
            var result = HexUtil.GetHexFromBytes(data);

            Assert.Equal("000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000011c20000000000000000000000000000000000000000000000007fffffffffffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007fffffffffffffff", result);
        }
Example #31
0
        public void Bytes_M()
        {
            byte[] bytes   = HexUtil.HexToBytes("072696e74657220746f6f6b20612067616c6c6579206");
            var    encoder = EncoderFactory.LoadEncoder("bytes22", bytes);

            Assert.IsType <BytesMEncoder>(encoder);
            var encodedSize = encoder.GetEncodedSize();

            Assert.True(encodedSize % 32 == 0);
            Assert.Equal(32, encodedSize);
            Span <byte> data = new byte[encodedSize];
            var         buff = new AbiEncodeBuffer(data, "bytes22");

            encoder.Encode(ref buff);
            Assert.Equal(0, buff.HeadCursor.Length);
            var result = HexUtil.GetHexFromBytes(data);

            Assert.Equal("072696e74657220746f6f6b20612067616c6c657920600000000000000000000", result);
        }