public void Dict()
{
Dictionary <object, object> dOne = new Dictionary <object, object> {
{ "Hello", 12 },
{ "Blah", 15 }
};
// Test Encode
var dump = Rencode.Encode(dOne);
Assert.AreEqual(((char)(RencodeConst.DICT_FIXED_START + 2)).ToString() +
((char)(RencodeConst.STR_FIXED_START + 5)).ToString() +
"Hello" +
((char)12) +
((char)(RencodeConst.STR_FIXED_START + 4)).ToString() +
"Blah" +
((char)15), Util.GetString(dump));
CollectionAssert.AreEqual(dOne, (ICollection)Rencode.Decode(dump));
Dictionary <object, object> dTwo = new Dictionary <object, object>();
for (int i = 0; i < 35; i++)
{
dTwo.Add(i.ToString(), i);
}
CollectionAssert.AreEqual(dTwo, (ICollection)Rencode.Decode(Rencode.Encode(dTwo)));
}
public void StringUnicode()
{
var utf8 = Encoding.UTF8.GetBytes("fööbar");
var utf8x = Encoding.UTF8.GetBytes((string)Rencode.Decode(Rencode.Encode("fööbar")));
Assert.AreEqual("fööbar", Rencode.Decode(Rencode.Encode("fööbar")));
}
public void Dict()
{
Dictionary <object, object> dOne = new Dictionary <object, object> {
{ "Hello", 12 },
{ "Blah", 15 }
};
// Test Encode
string dump = Rencode.EncodeToString(dOne);
Assert.AreEqual(((char)(RencodeTypeCode.EncodedLengthDictionary + 2)).ToString() +
((char)(RencodeTypeCode.EncodedLengthString + 5)).ToString() +
"Hello" +
((char)12) +
((char)(RencodeTypeCode.EncodedLengthString + 4)).ToString() +
"Blah" +
((char)15), dump);
Assert.AreEqual(dOne, Rencode.Decode(dump));
Dictionary <object, object> dTwo = new Dictionary <object, object>();
for (int i = 0; i < 35; i++)
{
dTwo.Add(i.ToString(), i);
}
Assert.AreEqual(dTwo, Rencode.Decode(Rencode.Encode(dTwo)));
}
protected override void OnDataReceived(string data)
{
base.OnDataReceived(data);
var decompressedData = CompressionHelper.Decompress(data);
var decodedData = Rencode.Decode(decompressedData) as Object[];
IRPCMessage message = DecodeMessage(decodedData);
switch (message.MessageType)
{
case MessageType.Response:
case MessageType.Error:
int requestId = (int)decodedData[1];
if (_messageCallbacks.TryGetValue(requestId, out Action <IRPCMessage> callback))
{
callback(message);
_messageCallbacks.Remove(requestId);
}
break;
case MessageType.Event:
Console.WriteLine("Event");
break;
default:
throw new NotSupportedException("Specified MessageType is not supported.");
}
}
public void Bool()
{
Assert.AreEqual(RencodeConst.CHR_TRUE, Rencode.Encode(true).Single());
Assert.AreEqual(RencodeConst.CHR_FALSE, Rencode.Encode(false).Single());
Assert.AreEqual(true, Rencode.Decode(Rencode.Encode(true)));
Assert.AreEqual(false, Rencode.Decode(Rencode.Encode(false)));
}
public void Bool()
{
Assert.AreEqual(((char)RencodeTypeCode.BooleanTrue).ToString(), Rencode.EncodeToString(true));
Assert.AreEqual(((char)RencodeTypeCode.BooleanFalse).ToString(), Rencode.EncodeToString(false));
Assert.AreEqual(true, Rencode.Decode(Rencode.Encode(true)));
Assert.AreEqual(false, Rencode.Decode(Rencode.Encode(false)));
}
public void Bool()
{
Assert.AreEqual(((char)RencodeConst.CHR_TRUE).ToString(), Rencode.Encode(true));
Assert.AreEqual(((char)RencodeConst.CHR_FALSE).ToString(), Rencode.Encode(false));
Assert.AreEqual(true, Rencode.Decode(Rencode.Encode(true)));
Assert.AreEqual(false, Rencode.Decode(Rencode.Encode(false)));
}
public void StringLarge()
{
var largeStr = new string(Enumerable.Repeat('f', 9000).ToArray());
var encoded = Rencode.Encode(largeStr);
var decoded = Rencode.Decode(encoded);
Assert.AreEqual(largeStr, decoded);
}
public void List()
{
Assert.AreEqual(new object[] { "one", "two", "three" },
Rencode.Decode(
Rencode.Encode(new object[] { "one", "two", "three" })
)
);
Assert.AreEqual(new object[] { 1, 2, 3 },
Rencode.Decode(
Rencode.Encode(new object[] { 1, 2, 3 })
)
);
Assert.AreEqual(new object[] { -1, -2, -3 },
Rencode.Decode(
Rencode.Encode(new object[] { -1, -2, -3 })
)
);
Assert.AreEqual(new object[] {
new object[] { "one", "two", "three" },
new object[] { "four", "five", "six" }
},
Rencode.Decode(
Rencode.Encode(new object[] {
new object[] { "one", "two", "three" },
new object[] { "four", "five", "six" }
})
)
);
Assert.AreEqual(new object[] {
new object[] { 1, 2, 3 },
new object[] { 4, 5, 6 }
},
Rencode.Decode(
Rencode.Encode(new object[] {
new object[] { 1, 2, 3 },
new object[] { 4, 5, 6 }
})
)
);
object[] non_fixed_list_test = new object[100];
Random rand = new Random();
for (int i = 0; i < 100; i++)
{
non_fixed_list_test[i] = rand.Next();
}
string dump = Rencode.EncodeToString(non_fixed_list_test);
Assert.AreEqual(RencodeTypeCode.List, (RencodeTypeCode)dump[0]);
Assert.AreEqual(RencodeTypeCode.Termination, (RencodeTypeCode)dump[dump.Length - 1]);
Assert.AreEqual(non_fixed_list_test, Rencode.Decode(dump));
}
public void Call(string method, object[] args, Dictionary <object, object> kwargs, Action <IRPCMessage> callback)
{
_messageCallbacks.Add(_requestId, callback);
object data = new object[] { new object[] { _requestId, method, args, kwargs } };
SendData(CompressionHelper.Compress(Rencode.Encode(data)));
_requestId++;
}
public void String()
{
// ENCODE STRING
Assert.AreEqual("\x85Hello", Rencode.EncodeToString("Hello"));
Assert.AreEqual("78:abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz", Rencode.EncodeToString("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"));
// DECODE STRING
Assert.AreEqual("Hello", Rencode.Decode("\x85Hello"));
Assert.AreEqual("abcdefghij", Rencode.Decode("10:abcdefghij"));
}
public void Decoding()
{
var dec = Rencode.Decode(Data);
var list = dec as List <object>;
Assert.NotNull(list);
Assert.Equal(16, list.Count);
var flenlist = list[0] as List <object>;
Assert.NotNull(flenlist);
Assert.Equal(3, flenlist.Count);
Assert.Equal("foo", flenlist[0]);
Assert.Equal("bar", flenlist[1]);
Assert.Equal("baz", flenlist[2]);
var vlenlist = list[1] as List <object>;
Assert.NotNull(vlenlist);
Assert.Equal(999, vlenlist.Count);
Assert.Equal(0, vlenlist[0]);
var flendict = list[2] as Dictionary <object, object>;
Assert.NotNull(flendict);
Assert.Equal(2, flendict.Count);
Assert.True(flendict.ContainsKey("foo"));
Assert.Equal(flendict["foo"], "bar");
Assert.True(flendict.ContainsKey("baz"));
Assert.Equal(flendict["baz"], "hax");
var vlendict = list[3] as Dictionary <object, object>;
Assert.NotNull(vlendict);
Assert.Equal(200, vlendict.Count);
Assert.True(vlendict.ContainsKey(0));
Assert.Equal(vlendict[0], "0");
Assert.Equal("test", list[4]);
Assert.Equal(new string('A', 200), list[5]);
Assert.Equal(15, list[6]);
Assert.Equal(-17, list[7]);
Assert.Equal(85, list[8]);
Assert.Equal(1233, list[9]);
Assert.Equal(1 << 29, list[10]);
Assert.Equal(1L << 37, list[11]);
Assert.Equal(2.75f, list[12]);
Assert.Equal(true, list[13]);
Assert.Equal(false, list[14]);
Assert.Equal(null, list[15]);
Assert.Equal(2.75, Rencode.Decode(DoubleData));
}
public void DeflateRencode()
{
var list = "hello_world";
string encode = Rencode.Encode(list);
byte[] encodedBytes = encode.Select(Convert.ToByte).ToArray();
byte[] bytes = Zlib.Deflate(encodedBytes);
string base64 = Base64.Encode(bytes);
}
public void EncodeList()
{
var list = new List <object>
{
1,
"hello_world",
new object[] { "foo", "bar" }
};
string encode = Rencode.Encode(list);
}
public void StringUnicode()
{
const string expectedString = "fööbar";
byte[] expectedBytes = Encoding.UTF8.GetBytes(expectedString);
string resultString = (string)Rencode.Decode(Rencode.Encode(expectedString));
var resultBytes = Encoding.UTF8.GetBytes(resultString);
Assert.AreEqual(expectedString, resultString);
CollectionAssert.AreEqual(expectedBytes, resultBytes);
}
public override async Task Send(IEnumerable <RpcRequest> requests)
{
CheckDisposed();
object formatted = FormatRequestMessages(requests);
string encoded = Rencode.Encode(formatted);
byte[] encodedBytes = encoded.Select(Convert.ToByte).ToArray();
using (var zlib = new ZlibStream(Stream, CompressionMode.Compress, true))
{
await zlib.WriteAsync(encodedBytes, 0, encodedBytes.Length);
}
}
public void List()
{
CollectionAssert.AreEqual(new object[] { "one", "two", "three" },
(ICollection)Rencode.Decode(
Rencode.Encode(new object[] { "one", "two", "three" })
)
);
CollectionAssert.AreEqual(new object[] { 1, 2, 3 },
(ICollection)Rencode.Decode(
Rencode.Encode(new object[] { 1, 2, 3 })
)
);
var decodedIntList = (ICollection)Rencode.Decode(Rencode.Encode(new object[] { -1, -2, -3 }));
CollectionAssert.AreEqual(new object[] { -1, -2, -3 }, decodedIntList);
var multiDimStrArr = new object[] {
new object[] { "one", "two", "three" },
new object[] { "four", "five", "six" }
};
var multiDimStrArrRoundTrip = ((ICollection)Rencode.Decode(
Rencode.Encode(new object[] {
new object[] { "one", "two", "three" },
new object[] { "four", "five", "six" }
})
)).Cast <object>().Select(s => (ICollection)s).ToArray();
CollectionAssert.AreEqual((ICollection)multiDimStrArr[0], multiDimStrArrRoundTrip[0]);
CollectionAssert.AreEqual((ICollection)multiDimStrArr[1], multiDimStrArrRoundTrip[1]);
var multiDimIntArr = new object[] {
new object[] { 1, 2, 3 },
new object[] { 4, 5, 6 }
};
var multiDimIntArrRoundTrip = ((ICollection)Rencode.Decode(
Rencode.Encode(new object[] {
new object[] { 1, 2, 3 },
new object[] { 4, 5, 6 }
})
)).Cast <object>().Select(s => (ICollection)s).ToArray();
CollectionAssert.AreEqual((ICollection)multiDimIntArr[0], multiDimIntArrRoundTrip[0]);
CollectionAssert.AreEqual((ICollection)multiDimIntArr[1], multiDimIntArrRoundTrip[1]);
}
public void ListNonFixed()
{
object[] non_fixed_list_test = new object[100];
Random rand = new Random();
for (int i = 0; i < non_fixed_list_test.Length; i++)
{
non_fixed_list_test[i] = rand.Next();
}
var dump = Rencode.Encode(non_fixed_list_test);
Assert.AreEqual(RencodeConst.CHR_LIST, dump[0]);
Assert.AreEqual(RencodeConst.CHR_TERM, dump[dump.Length - 1]);
CollectionAssert.AreEqual(non_fixed_list_test, (ICollection)Rencode.Decode(dump));
}
public override async Task <RpcMessage[]> Receive()
{
CheckDisposed();
var buffer = new byte[BufferSize];
while (true)
{
int read = await stream.ReadAsync(buffer, 0, BufferSize);
if (read == 0)
{
return(null);
}
IEnumerable <byte> bytesRead = buffer.Where((b, i) => i < read);
readBuffer.AddRange(bytesRead);
try
{
byte[] inflated = Zlib.Inflate(readBuffer.ToArray());
string encoded = string.Concat(inflated.Select(Convert.ToChar));
var result = Rencode.Decode(encoded) as object[];
if (result == null)
{
return(null);
}
var messages = new List <RpcMessage>();
const int partsPerMessage = 3;
for (int skip = 0; skip < result.Length; skip += partsPerMessage)
{
object[] messageParts = result.Skip(skip).Take(partsPerMessage).ToArray();
RpcMessage message = RpcMessage.Create(messageParts);
messages.Add(message);
}
readBuffer.Clear();
return(messages.ToArray());
}
catch
{
// Message is incomplete
}
}
}
public void Roundtrip()
{
Assert.Equal(true, Rencode.Decode(Rencode.Encode(true)));
Assert.Equal(false, Rencode.Decode(Rencode.Encode(false)));
Assert.Equal(null, Rencode.Decode(Rencode.Encode(null)));
Assert.Equal(0, Rencode.Decode(Rencode.Encode(0)));
Assert.Equal(17, Rencode.Decode(Rencode.Encode(17)));
Assert.Equal(-17, Rencode.Decode(Rencode.Encode(-17)));
Assert.Equal(0x4012, Rencode.Decode(Rencode.Encode(0x4012)));
Assert.Equal(0x40124012, Rencode.Decode(Rencode.Encode(0x40124012)));
Assert.Equal(0x4012401240124012L, Rencode.Decode(Rencode.Encode(0x4012401240124012L)));
Assert.Equal(0.5f, Rencode.Decode(Rencode.Encode(0.5f)));
Assert.Equal(0.5, Rencode.Decode(Rencode.Encode(0.5)));
Assert.Equal(Data, Rencode.Encode(Rencode.Decode(Data)));
}
public void Integer()
{
// ENCODE INT1
Assert.AreEqual((char)RencodeTypeCode.SByte + "\x78", Rencode.EncodeToString(120));
Assert.AreEqual((char)RencodeTypeCode.SByte + "\x88", Rencode.EncodeToString(-120));
// ENCODE INT2
Assert.AreEqual((char)RencodeTypeCode.Int16 + "\x06\x04", Rencode.EncodeToString(1540));
Assert.AreEqual((char)RencodeTypeCode.Int16 + "\xF9\xFC", Rencode.EncodeToString(-1540));
// ENCODE INT4
Assert.AreEqual((char)RencodeTypeCode.Int32 + "\x7F\xff\xff\xd0", Rencode.EncodeToString(2147483600));
Assert.AreEqual((char)RencodeTypeCode.Int32 + "\x80\x00\x00\x30", Rencode.EncodeToString(-2147483600));
// ENCODE INT8
Assert.AreEqual(65, Rencode.Encode(9223372036854700000L)[0]);
Assert.AreEqual(127, Rencode.Encode(9223372036854700000L)[1]);
Assert.AreEqual(255, Rencode.Encode(9223372036854700000L)[2]);
Assert.AreEqual(255, Rencode.Encode(9223372036854700000L)[3]);
Assert.AreEqual((char)RencodeTypeCode.Int64 + "\x7F\xFF\xFF\xFF\xFF\xFE\xD7\xE0", Rencode.EncodeToString(9223372036854700000L));
Assert.AreEqual((char)RencodeTypeCode.Int64 + "\x80\x00\x00\x00\x00\x01( ", Rencode.EncodeToString(-9223372036854700000L));
// DECODE INT
var bi = new BigInteger(long.MaxValue) * 2;
Assert.AreEqual(bi, Rencode.Decode((char)RencodeTypeCode.BigInteger + bi.ToString() + (char)RencodeTypeCode.Termination));
// DECODE INT1
Assert.AreEqual(120, Rencode.Decode((char)RencodeTypeCode.SByte + "\x78"));
Assert.AreEqual(-120, Rencode.Decode((char)RencodeTypeCode.SByte + "\x88"));
// DECODE INT2
Assert.AreEqual(1540, Rencode.Decode((char)RencodeTypeCode.Int16 + "\x06\x04"));
Assert.AreEqual(-1540, Rencode.Decode((char)RencodeTypeCode.Int16 + "\xF9\xFC"));
// DECODE INT4
Assert.AreEqual(2147483600, Rencode.Decode((char)RencodeTypeCode.Int32 + "\x7f\xff\xff\xd0"));
Assert.AreEqual(-2147483600, Rencode.Decode((char)RencodeTypeCode.Int32 + "\x80\x00\x00\x30"));
// DECODE INT8
Assert.AreEqual(9223372036854700000L, Rencode.Decode((char)RencodeTypeCode.Int64 + "\x7F\xFF\xFF\xFF\xFF\xFE\xD7\xE0"));
Assert.AreEqual(-9223372036854700000L, Rencode.Decode((char)RencodeTypeCode.Int64 + "\x80\x00\x00\x00\x00\x01( "));
}
public void Bytes()
{
byte[] data = new byte[] { 193, 196, 0, 140, 100, 97, 101, 109, 111, 110, 46, 108, 111, 103, 105, 110, 194, 136, 117, 115, 101, 114, 110, 97, 109, 101, 136, 112, 97, 115, 115, 119, 111, 114, 100, 102 };
// Decode string
var result = (object[])Rencode.Decode(data);
var parts = (object[])result[0];
var credentials = (object[])parts[2];
var options = (Dictionary <object, object>)parts[3];
// Validate result
Assert.AreEqual(0, parts[0]);
Assert.AreEqual("daemon.login", parts[1]);
Assert.AreEqual("username", credentials[0]);
Assert.AreEqual("password", credentials[1]);
Assert.AreEqual(0, options.Count);
}
public void Integer()
{
// ENCODE INT1
Assert.AreEqual((char)RencodeConst.CHR_INT1 + "\x78", Rencode.EncodeToString(120));
Assert.AreEqual((char)RencodeConst.CHR_INT1 + "\x88", Rencode.EncodeToString(-120));
// ENCODE INT2
Assert.AreEqual((char)RencodeConst.CHR_INT2 + "\x06\x04", Rencode.EncodeToString(1540));
Assert.AreEqual((char)RencodeConst.CHR_INT2 + "\xF9\xFC", Rencode.EncodeToString(-1540));
// ENCODE INT4
Assert.AreEqual((char)RencodeConst.CHR_INT4 + "\x7F\xff\xff\xd0", Rencode.EncodeToString(2147483600));
Assert.AreEqual((char)RencodeConst.CHR_INT4 + "\x80\x00\x00\x30", Rencode.EncodeToString(-2147483600));
// ENCODE INT8
Assert.AreEqual(65, Rencode.Encode(9223372036854700000L)[0]);
Assert.AreEqual(127, Rencode.Encode(9223372036854700000L)[1]);
Assert.AreEqual(255, Rencode.Encode(9223372036854700000L)[2]);
Assert.AreEqual(255, Rencode.Encode(9223372036854700000L)[3]);
Assert.AreEqual((char)RencodeConst.CHR_INT8 + "\x7F\xFF\xFF\xFF\xFF\xFE\xD7\xE0", Rencode.EncodeToString(9223372036854700000L));
Assert.AreEqual((char)RencodeConst.CHR_INT8 + "\x80\x00\x00\x00\x00\x01( ", Rencode.EncodeToString(-9223372036854700000L));
// DECODE INT
Assert.AreEqual((short)1000, Rencode.Decode((char)RencodeConst.CHR_INT + "1000" + (char)RencodeConst.CHR_TERM));
// DECODE INT1
Assert.AreEqual((sbyte)120, Rencode.Decode((char)RencodeConst.CHR_INT1 + "\x78"));
Assert.AreEqual((sbyte)-120, Rencode.Decode((char)RencodeConst.CHR_INT1 + "\x88"));
// DECODE INT2
Assert.AreEqual((short)1540, Rencode.Decode((char)RencodeConst.CHR_INT2 + "\x06\x04"));
Assert.AreEqual((short)-1540, Rencode.Decode((char)RencodeConst.CHR_INT2 + "\xF9\xFC"));
// DECODE INT4
Assert.AreEqual(2147483600, Rencode.Decode((char)RencodeConst.CHR_INT4 + "\x7f\xff\xff\xd0"));
Assert.AreEqual(-2147483600, Rencode.Decode((char)RencodeConst.CHR_INT4 + "\x80\x00\x00\x30"));
// DECODE INT8
Assert.AreEqual(9223372036854700000L, Rencode.Decode((char)RencodeConst.CHR_INT8 + "\x7F\xFF\xFF\xFF\xFF\xFE\xD7\xE0"));
Assert.AreEqual(-9223372036854700000L, Rencode.Decode((char)RencodeConst.CHR_INT8 + "\x80\x00\x00\x00\x00\x01( "));
}
public void Float()
{
Assert.AreEqual(0.005353f, Rencode.Decode(Rencode.Encode(0.005353f)));
Assert.AreEqual(-0.005353f, Rencode.Decode(Rencode.Encode(-0.005353f)));
}
public void Null()
{
Assert.AreEqual(((char)RencodeTypeCode.Null).ToString(), Rencode.EncodeToString(null));
Assert.AreEqual(null, Rencode.Decode(Rencode.Encode(null)));
}
public void Double()
{
Assert.AreEqual(0.005353d, Rencode.Decode(Rencode.Encode(0.005353d)));
Assert.AreEqual(-0.005353d, Rencode.Decode(Rencode.Encode(-0.005353d)));
}
public void Null()
{
Assert.AreEqual(((char)RencodeConst.CHR_NONE).ToString(), Rencode.EncodeToString(null));
Assert.AreEqual(null, Rencode.Decode(Rencode.Encode(null)));
}
private static byte[] EncodeAndCompressRpcRequest(RpcRequest request)
{
string encodedRequest = Rencode.Encode(new object[] { request.RequestId, request.Method, request.Arguments.ToArray(), request.KeyWordArguments });
return(ZlibStream.CompressString(encodedRequest));
}
