public void ShouldEqualExpect(byte obj, short version, Codec codec, int tag, int length)
{
var buffer = Unpooled.Buffer(1);
var options = new TarsConvertOptions()
{
Codec = codec,
Version = version,
Tag = tag
};
sut.Serialize(obj, buffer, options);
Assert.Equal(length, buffer.ReadableBytes);
var bytes = new byte[length];
buffer.ReadBytes(bytes);
Assert.Equal(obj, bytes.Last());
options.Tag = 0;
buffer = buffer.ResetReaderIndex();
headHandler.ReadHead(buffer, options);
var result = sut.Deserialize <byte>(buffer, options);
Assert.Equal(result, obj);
Assert.Equal(tag, options.Tag);
Assert.Equal(TarsStructType.Byte, options.TarsType);
}
public void WhenZeroShouldBeZERO_TAG(short version, Codec codec, int tag, int length, byte value)
{
var buffer = Unpooled.Buffer(1);
var options = new TarsConvertOptions()
{
Codec = codec,
Version = version,
Tag = tag
};
sut.Serialize(byte.MinValue, buffer, options);
Assert.Equal(length, buffer.ReadableBytes);
var bytes = new byte[length];
buffer.ReadBytes(bytes);
Assert.Equal(value, bytes.Last());
options.Tag = 0;
buffer = buffer.ResetReaderIndex();
headHandler.ReadHead(buffer, options);
var result = sut.Deserialize <byte>(buffer, options);
Assert.Equal(result, byte.MinValue);
Assert.Equal(tag, options.Tag);
Assert.Equal(TarsStructType.Zero, options.TarsType);
}
public void SameKeyShouldBeSingle(short version, Codec codec, int tag)
{
var buffer = Unpooled.Buffer(1);
var options = new TarsConvertOptions()
{
Codec = codec,
Version = version,
Tag = tag
};
headHandler.Reserve(buffer, 8);
headHandler.WriteHead(buffer, TarsStructType.Map, options.Tag);
buffer.WriteInt(2);
for (int i = 0; i < 2; i++)
{
options.Tag = 0;
sut.Serialize("str", buffer, options);
options.Tag = 1;
sut.Serialize("ok" + i.ToString(), buffer, options);
}
headHandler.ReadHead(buffer, options);
var result = sut.Deserialize <IDictionary <string, string> >(buffer, options);
Assert.Single(result);
Assert.Equal("ok1", result["str"]);
Assert.Equal(tag, options.Tag);
Assert.Equal(TarsStructType.Map, options.TarsType);
}
public void WhenByteEnumShouldEqualExpect(short version, Codec codec, int tag)
{
var enums = new ByteEnum[] { ByteEnum.A, ByteEnum.B, ByteEnum.C };
var types = new byte[] { TarsStructType.Zero, TarsStructType.Byte, TarsStructType.Byte };
for (int i = 0; i < enums.Length; i++)
{
var item = enums[i];
var buffer = Unpooled.Buffer(1);
var options = new TarsConvertOptions()
{
Codec = codec,
Version = version,
Tag = tag,
};
sut.Serialize(item, buffer, options);
Assert.True(options.HasValue);
Assert.True(buffer.ReadableBytes > 0);
options.Tag = 0;
headHandler.ReadHead(buffer, options);
Assert.Equal(types[i], options.TarsType);
Assert.Equal(tag, options.Tag);
Assert.Equal(item, sut.Deserialize <ByteEnum>(buffer, options));
}
}
public void ShouldEqualExpect(byte type, int tag)
{
var buffer = Unpooled.Buffer(2);
sut.WriteHead(buffer, type, tag);
var options = new TarsConvertOptions();
sut.ReadHead(buffer, options);
Assert.Equal(type, options.TarsType);
Assert.Equal(tag, options.Tag);
}
public void ShouldOnlyCanDeserializeByteArray(short version, Codec codec, byte tarsStructType, string error)
{
var buffer = Unpooled.WrappedBuffer(new byte[] { 255 });
var options = new TarsConvertOptions()
{
Codec = codec,
Version = version,
TarsType = tarsStructType
};
var ex = Assert.Throws <TarsDecodeException>(() => sut.Deserialize <IByteBuffer>(buffer, options));
Assert.Equal(error, ex.Message);
}
public void WhenNoValueShouldNoBytes(short version, Codec codec, int tag, byte value)
{
var buffer = Unpooled.Buffer(1);
var options = new TarsConvertOptions()
{
Codec = codec,
Version = version,
Tag = tag,
HasValue = false
};
sut.Serialize(value, buffer, options);
Assert.Equal(0, buffer.ReadableBytes);
}
public void WhenNullShouldBeNoBytes(short version, Codec codec, int tag)
{
var buffer = Unpooled.Buffer(1);
var options = new TarsConvertOptions()
{
Codec = codec,
Version = version,
Tag = tag,
};
sut.Serialize <IByteBuffer>(null, buffer, options);
Assert.True(options.HasValue);
Assert.Equal(0, buffer.ReadableBytes);
}
public void WhenNoValueShouldNoBytes(short version, Codec codec, int tag)
{
var buffer = Unpooled.Buffer(1);
var options = new TarsConvertOptions()
{
Codec = codec,
Version = version,
Tag = tag
};
string str = null;
sut.Serialize(str, buffer, options);
Assert.Equal(0, buffer.ReadableBytes);
}
public void WhenNullShouldBeEmpty(short version, Codec codec, int tag)
{
var buffer = Unpooled.Buffer(1);
var options = new TarsConvertOptions()
{
Codec = codec,
Version = version,
Tag = tag,
};
IDictionary <string, string> nullable = null;
sut.Serialize(nullable, buffer, options);
Assert.True(options.HasValue);
Assert.Equal(0, buffer.ReadableBytes);
}
public void UniAttributeArgumentExceptionTest(Codec codec, int tag)
{
var test = new TestTarsConvert();
var sut = new UniAttributeV2(test.ConvertRoot, test.HeadHandler)
{
Temp = new Dictionary <string, IDictionary <string, IByteBuffer> >(3)
};
var options = new TarsConvertOptions()
{
Codec = codec,
Version = TarsCodecsVersion.V2,
Tag = tag,
};
var ex = Assert.Throws <ArgumentException>(() => sut.Put(null, 1, typeof(int), options));
Assert.Equal("put key can not be null", ex.Message);
}
public void ShouldEqualExpect(long obj, short version, Codec codec, int tag, byte tarsStructType)
{
var buffer = Unpooled.Buffer(1);
var options = new TarsConvertOptions()
{
Codec = codec,
Version = version,
Tag = tag
};
sut.Serialize(Task.FromResult(obj), buffer, options);
headHandler.ReadHead(buffer, options);
var result = sut.Deserialize <Task <long> >(buffer, options);
Assert.Equal(obj, result.Result);
Assert.Equal(tag, options.Tag);
Assert.Equal(tarsStructType, options.TarsType);
}
public void WhenNullableShouldEqualExpect(long obj, short version, Codec codec, int tag, byte tarsStructType)
{
var buffer = Unpooled.Buffer(1);
var options = new TarsConvertOptions()
{
Codec = codec,
Version = version,
Tag = tag
};
long?nullable = obj;
sut.Serialize(nullable, buffer, options);
headHandler.ReadHead(buffer, options);
var result = sut.Deserialize <long?>(buffer, options);
Assert.Equal(obj, result);
Assert.Equal(tag, options.Tag);
Assert.Equal(tarsStructType, options.TarsType);
}
public void WhenHasBytesShouldNotEmpty(short version, Codec codec, int tag, string str)
{
var buffer = Unpooled.Buffer(1);
var options = new TarsConvertOptions()
{
Codec = codec,
Version = version,
Tag = tag,
};
sut.Serialize(Unpooled.WrappedBuffer(Encoding.UTF8.GetBytes(str)), buffer, options);
Assert.True(options.HasValue);
Assert.True(buffer.ReadableBytes > 0);
options.Tag = 0;
headHandler.ReadHead(buffer, options);
Assert.Equal(TarsStructType.ByteArray, options.TarsType);
Assert.Equal(tag, options.Tag);
Assert.Equal(str, Encoding.UTF8.GetString(sut.Deserialize <IByteBuffer>(buffer, options).Slice().Array));
}
public void WhenEmptyShouldBeEmpty(short version, Codec codec, int tag)
{
var buffer = Unpooled.Buffer(1);
var options = new TarsConvertOptions()
{
Codec = codec,
Version = version,
Tag = tag,
};
sut.Serialize(Unpooled.Empty, buffer, options);
Assert.True(options.HasValue);
Assert.True(buffer.ReadableBytes > 0);
options.Tag = 0;
headHandler.ReadHead(buffer, options);
Assert.Equal(TarsStructType.ByteArray, options.TarsType);
Assert.Equal(tag, options.Tag);
Assert.Equal(Unpooled.Empty, sut.Deserialize <IByteBuffer>(buffer, options));
}
public void ShouldEqualExpect(bool obj, short version, Codec codec, int tag, byte byteValue, byte tarsStructType)
{
var buffer = Unpooled.Buffer(1);
var options = new TarsConvertOptions()
{
Codec = codec,
Version = version,
Tag = tag
};
sut.Serialize(obj, buffer, options);
headHandler.ReadHead(buffer, options);
var result = sut.Deserialize <byte>(buffer, options);
Assert.Equal(byteValue, result);
Assert.Equal(tag, options.Tag);
Assert.Equal(tarsStructType, options.TarsType);
buffer = buffer.ResetReaderIndex();
headHandler.ReadHead(buffer, options);
Assert.Equal(obj, sut.Deserialize <bool>(buffer, options));
}
public void UniAttributeTest(Codec codec, int tag)
{
var test = new TestTarsConvert();
var sut = new UniAttributeV2(test.ConvertRoot, test.HeadHandler)
{
Temp = new Dictionary <string, IDictionary <string, IByteBuffer> >(3)
};
var options = new TarsConvertOptions()
{
Codec = codec,
Version = TarsCodecsVersion.V2,
Tag = tag,
};
sut.Put(string.Empty, 1, typeof(int), options);
sut.Put("23", "66", typeof(string), options);
sut.Put("23", "23", typeof(string), options);
sut.Put("dd", 0d, typeof(double), options);
sut.Put("ddd", 0d, typeof(double), options);
sut.Put("ddd", null, typeof(double), options);
var buf = Unpooled.Buffer(128);
sut.Serialize(buf, options);
sut.Temp = null;
headHandler.ReadHead(buf, options);
sut.Deserialize(buf, options);
Assert.Equal(3, sut.Temp.Count);
var buffer = sut.Temp[string.Empty][string.Empty];
test.HeadHandler.ReadHead(buffer, options);
Assert.Equal(1, test.ConvertRoot.Deserialize <int>(buffer, options));
buffer = sut.Temp["23"][string.Empty];
test.HeadHandler.ReadHead(buffer, options);
Assert.Equal("23", test.ConvertRoot.Deserialize <string>(buffer, options));
buffer = sut.Temp["dd"][string.Empty];
test.HeadHandler.ReadHead(buffer, options);
Assert.Equal(0d, test.ConvertRoot.Deserialize <double>(buffer, options));
}
public void DictShouldEqualExpect(short version, Codec codec, int tag)
{
var buffer = Unpooled.Buffer(1);
var options = new TarsConvertOptions()
{
Codec = codec,
Version = version,
Tag = tag
};
var dict = new Dictionary <string, string>
{
{ "str", "ok" }
};
sut.Serialize(dict, buffer, options);
headHandler.ReadHead(buffer, options);
var result = sut.Deserialize <Dictionary <string, string> >(buffer, options);
Assert.Single(result);
Assert.Equal("ok", result["str"]);
Assert.Equal(tag, options.Tag);
Assert.Equal(TarsStructType.Map, options.TarsType);
}
public void ShouldEqualExpect(short version, Codec codec, int tag, int age, string name)
{
var buffer = Unpooled.Buffer(1);
var options = new TarsConvertOptions()
{
Codec = codec,
Version = version,
Tag = tag
};
TestData data = new TestData()
{
Age = age,
Name = name
};
sut.Serialize(data, buffer, options);
headHandler.ReadHead(buffer, options);
var result = sut.Deserialize <TestData>(buffer, options);
Assert.Equal(tag, options.Tag);
Assert.Equal(age, result.Age);
Assert.Equal(name, result.Name);
}
public void ListShouldEqualExpect(short version, Codec codec, int tag)
{
var buffer = Unpooled.Buffer(1);
var options = new TarsConvertOptions()
{
Codec = codec,
Version = version,
Tag = tag
};
var list = new List <string>()
{
"str", "ok"
};
sut.Serialize(list, buffer, options);
headHandler.ReadHead(buffer, options);
var result = sut.Deserialize <List <string> >(buffer, options);
Assert.Equal(2, result.Count);
Assert.Equal("str", result[0]);
Assert.Equal("ok", result[1]);
Assert.Equal(tag, options.Tag);
Assert.Equal(TarsStructType.List, options.TarsType);
}
