public void DictionarySerializeNested()
{
var serialized = LightWeight.Serialize(new Dictionary <UInt32, Dictionary <UInt32, String> > {
{
1, new Dictionary <UInt32, String> {
{ 2, "cake" },
{ 3, "food" }
}
}, {
2, new Dictionary <UInt32, String> {
{ 4, "fork" },
{ 5, "food" }
}
}
});
Assert.Equal(new Byte[] {
0x03, // HEADER Count=2
0x01, // 1=U
0x03, // HEADER Count=2
0x02, // 2=
0x05, (Byte)'c', (Byte)'a', (Byte)'k', (Byte)'e', // cake
0x03, // 3=
0x05, (Byte)'f', (Byte)'o', (Byte)'o', (Byte)'d', // food
0x02, // 2=
0x03, // HEADER Count=2
0x04, // 4=
0x05, (Byte)'f', (Byte)'o', (Byte)'r', (Byte)'k', // fork
0x05, // 5=
0x05, (Byte)'f', (Byte)'o', (Byte)'o', (Byte)'d', // food
}.ToHexString(), serialized.ToHexString());
}
public void FloorSerializeMin()
{
var encoded = LightWeight.Serialize(new One()
{
U8 = 5,
U16 = 5,
U32 = 5,
U64 = 5,
S8 = 5,
S16 = 5,
S32 = 5,
S64 = 5
});
Assert.Equal(new Byte[] {
0x09, // HEADER Length=8
0x00, // [U8]=5
0x00, // [U16]=5
0x00, // [U32]=5
0x00, // [U64]=5
0x00, // [S8]=5
0x00, // [S16]=5
0x00, // [S32]=5
0x00, // [S64]=5
}.ToHexString(), encoded.ToHexString());
}
public void FloorSerializeMinPlus1()
{
var encoded = LightWeight.Serialize(new One()
{
U8 = 6,
U16 = 6,
U32 = 6,
U64 = 6,
S8 = 6,
S16 = 6,
S32 = 6,
S64 = 6
});
Assert.Equal(new Byte[] {
0x09, // HEADER Length=8
0x01, // [U8]=6
0x01, // [U16]=6
0x01, // [U32]=6
0x01, // [U64]=6
0x01, // [S8]=6 TODO: need to check this value is correct
0x02, // [S16]=6
0x02, // [S32]=6
0x02, // [S64]=6
}.ToHexString(), encoded.ToHexString());
}
public void ListSerializeEmpty()
{
var encoded = LightWeight.Serialize(new List <Int32>());
Assert.Equal(new Byte[] {
0x01 // HEADER Count=0
}, encoded);
}
public void ArrayDeserializeEmpty()
{
var result = LightWeight.Deserialize <Int32[]>(new Byte[] {
0x01 // HEADER Count=0
});
Assert.Equal(new Int32[] { }, result);
}
public void ListDeserializeNull()
{
var result = LightWeight.Deserialize <List <Int32> >(new Byte[] {
0x00 // HEADER Null
});
Assert.Null(result);
}
public void DictionaryDeserializeEmpty()
{
var decoded = LightWeight.Deserialize <Dictionary <Int32, String> >(new Byte[] {
0x01 // HEADER Count=0
});
Assert.Equal(new Dictionary <Int32, String>(), decoded);
}
public void DictionaryDeserializeNull()
{
var decoded = LightWeight.Deserialize <Dictionary <Int32, String> >(new Byte[] {
0x00 // HEADER NULL
});
Assert.Null(decoded);
}
public void ListSerializeNull()
{
var encoded = LightWeight.Serialize <List <Int32> >(null);
Assert.Equal(new Byte[] {
0x00 // HEADER Null
}, encoded);
}
public void DictionarySerializeNull()
{
var encoded = LightWeight.Serialize <Dictionary <Int32, String> >(null);
Assert.Equal(new Byte[] {
0x00 // HEADER NULL
}, encoded);
}
public void ArraySerializeNull1()
{
var encoded = LightWeight.Serialize <Boolean[]>(null);
Assert.Equal(new Byte[] {
0x00 // HEADER NULL
}, encoded);
}
public void DictionarySerializeEmpty()
{
var encoded = LightWeight.Serialize(new Dictionary <Int32, String>());
Assert.Equal(new Byte[] {
0x01 // HEADER Count=0
}, encoded);
}
public void ArrayDeserializeNull1()
{
var result = LightWeight.Deserialize <Boolean[]>(new Byte[] {
0x00 // HEADER NULL
});
Assert.Null(result);
}
public void ClassDeserializeNull()
{
var decoded = LightWeight.Deserialize <One>(new Byte[] {
0x00 // HEADER NULL
});
Assert.Null(decoded);
}
public void ClassSerializeNull()
{
var encoded = LightWeight.Serialize <One>(null);
Assert.Equal(new Byte[] {
0x00 // HEADER NULL
}, encoded);
}
public void ArraySerializeEmpty()
{
var encoded = LightWeight.Serialize(new Int32[] { });
Assert.Equal(new Byte[] {
0x01 // HEADER Count=0
}, encoded);
}
public void ArraySerializeNull2()
{
var encoded = LightWeight.Serialize(new ArrayNullClass());
Assert.Equal(new Byte[] {
0x02, // HEADER Length=1
0x00 // HEADER NULL
}, encoded);
}
public void ArrayDeserializeNull2()
{
var result = LightWeight.Deserialize <ArrayNullClass>(new Byte[] {
0x02, // HEADER Length=1
0x00 // HEADER NULL
});
Assert.Null(result.B);
}
public void ListDeserializeEmpty()
{
var result = LightWeight.Deserialize <List <Int32> >(new Byte[] {
0x01 // HEADER Count=0
});
Assert.Equal(new List <Int32> {
}, result);
}
public void ClassDeserializeEmpty()
{
var encoded = LightWeight.Deserialize <NoIndexs>(new Byte[] {
0x01 // HEADER Length=0
});
Assert.Equal((UInt32)0, encoded.A);
Assert.Equal((UInt32)0, encoded.B);
Assert.Equal((UInt32)0, encoded.C);
}
public void FloorSerializeUnsupported()
{
Assert.Throws <UnsupportedDataTypeException>(() =>
{
LightWeight.Serialize(new Unsupported()
{
ValueString = "asdf"
});
});
}
public void FloorDeserializeUnsupported()
{
Assert.Throws <UnsupportedDataTypeException>(() =>
{
LightWeight.Deserialize <Unsupported>(new Byte[] {
0x02, // HEADER Length=1
0x01, // [Value]=6
});
});
}
public void ArrayDeserializeBoolean()
{
var result = LightWeight.Deserialize <Boolean[]>(new Byte[] {
0x04, // HEADER Count=3
0x01, // [0]=true
0x01, // [1]=true
0x00 // [2]=false
});
Assert.Equal(new[] { true, true, false }, result);
}
public void ArrayDeserializeSInt32()
{
var result = LightWeight.Deserialize <UInt32[]>(new Byte[] {
0x04, // HEADER Count=3
0x01, // [0]=1
0x02, // [1]=2
0xE8, 0x06 // [3]=1000
});
Assert.Equal(new UInt32[] { 1, 2, 1000 }, result);
}
public void ArraySerializeBoolean()
{
var serialized = LightWeight.Serialize(new[] { true, true, false });
Assert.Equal(new Byte[] {
0x04, // HEADER Length=3
0x01, // [0]=true
0x01, // [1]=true,
0x00 // [2]=false
}, serialized);
}
public void ArraySerializeSInt32()
{
var serialized = LightWeight.Serialize(new UInt32[] { 1, 2, 1000 });
Assert.Equal(new Byte[] {
0x04, // HEADER Count=3
0x01, // [0]=1
0x02, // [1]=2
0xE8, 0x06 // [2]=1000
}, serialized);
}
public void SerializeDeserialize_Int32_Neg1000_1000()
{
var lw = new LightWeight();
for (var input = -10000; input < 10000; input++)
{
var encoded = lw.Encode(input);
var output = lw.Decode <Int32>(encoded);
Assert.Equal(input, output);
}
}
public void ListDeserializeInt32()
{
var result = LightWeight.Deserialize <List <UInt32> >(new Byte[] {
0x04, // HEADER Count=3
0x01, // [0]=1,
0x02, // [1]=2,
0xE8, 0x06 // [2]=1000
});
Assert.Equal(new List <UInt32> {
1, 2, 1000
}, result);
}
public void ListSerializeInt32()
{
var encoded = LightWeight.Serialize(new List <UInt32> {
1, 2, 1000
});
Assert.Equal(new Byte[] {
0x04, // HEADER Count=3
0x01, // [0]=1,
0x02, // [1]=2,
0xE8, 0x06 // [2]=1000
}, encoded);
}
public void ClassSerializeEmpty()
{
var encoded = LightWeight.Serialize(new NoIndexs
{
A = 1,
B = 9,
C = 1000
});
Assert.Equal(new Byte[] {
0x01 // HEADER Length=0
}, encoded);
}
