public void CanReadAndWriteStringWithNullChar()
{
const int STR_LEN = 32;
int rnd = RandomTools.RNG.Next(STR_LEN);
string p1 = RandomTools.GetAlphaString(rnd);
rnd = RandomTools.RNG.Next(STR_LEN);
string p2 = RandomTools.GetAlphaString(rnd);
string test = p1 + (char)0 + p2;
using (MemoryStream ms = new MemoryStream())
{
EZWriter.Write(ms, test);
ms.Seek(0, SeekOrigin.Begin);
string comp = EZReader.ReadString(ms);
Assert.AreEqual(test, comp, "Strings don't match!");
}
}
public void CanReadAndWriteString()
{
const int SIZE = 100;
// The first string is null, because we need to be able to support this concept.
List <string> testStrings = new List <string>()
{
null
};
for (int i = 0; i < MAX_TEST; i++)
{
string test = RandomTools.GetAlphaString(SIZE);
testStrings.Add(test);
}
foreach (var test in testStrings)
{
using (var ms = new MemoryStream())
{
EZWriter.Write(ms, test);
ms.Seek(0, SeekOrigin.Begin);
string comp = EZReader.ReadString(ms);
Assert.AreEqual(test, comp, "The strings should be the same!");
}
}
}
public void CanReadAndWriteBools()
{
const int MAX = 5;
bool[] myBoools = new bool[MAX];
for (int i = 0; i < MAX; i++)
{
myBoools[i] = RandomTools.FiftyFifty();
}
// Write the data, then read it back in.
using (MemoryStream ms = new MemoryStream())
{
for (int i = 0; i < MAX; i++)
{
EZWriter.Write(ms, myBoools[i]);
}
ms.Seek(0, SeekOrigin.Begin);
for (int i = 0; i < MAX; i++)
{
bool nextBool = EZReader.ReadBool(ms);
Assert.AreEqual(myBoools[i], nextBool, "Invalid boolean at index #{0}", i);
}
}
}
// --------------------------------------------------------------------------------------------------------------------------
public static void WriteEZList <T>(Stream s, EZList <T> data, Action <Stream, T> writeFunc)
{
EZList <T> res = new EZList <T>();
uint count = (uint)data.Count;
EZWriter.Write(s, count);
for (int i = 0; i < count; i++)
{
T next = data[i];
writeFunc(s, next);
res.Add(next);
}
}
public void CanReadWriteInt32()
{
const int MAX = 100;
for (int i = 0; i < MAX; i++)
{
Int32 next = RandomTools.RNG.Next(int.MinValue, int.MaxValue);
using (var ms = new MemoryStream())
{
EZWriter.Write(ms, next);
ms.Seek(0, SeekOrigin.Begin);
int comp = EZReader.ReadInt32(ms);
Assert.AreEqual(next, comp);
}
}
}
public void CanReadAndWriteUint()
{
// const uint test = 0xF00010FF;
for (int i = 0; i < MAX_TEST; i++)
{
// WOW! The C# preference for int over everything sure is annoying!
uint test = (uint)RandomTools.RNG.Next((int)uint.MinValue, int.MaxValue);
using (var ms = new MemoryStream())
{
EZWriter.Write(ms, test);
ms.Seek(0, SeekOrigin.Begin);
uint comp = EZReader.ReadUInt32(ms);
Assert.AreEqual(test, comp, "The uints should be the same!");
}
}
}
public void CanReadWriteInt64()
{
const int MAX = 100;
for (int i = 0; i < MAX; i++)
{
byte[] data = new byte[sizeof(Int64)];
RandomTools.RNG.NextBytes(data);
Int64 next = BitConverter.ToInt64(data, 0);
using (var ms = new MemoryStream())
{
EZWriter.Write(ms, next);
ms.Seek(0, SeekOrigin.Begin);
Int64 comp = EZReader.ReadInt64(ms);
Assert.AreEqual <Int64>(next, comp);
}
}
}
public void CanReadWriteList()
{
// MethodInfo writer = typeof(EZWriter).GetMethod("Write", new Type[] { typeof(Stream), typeof(T) });
// writer.Invoke(null, new object[] { ms, data });
// TODO: when it works, use 'ReadWriteTest(x)'
List <string> strList = new List <string>()
{
"ABC", "DEF", "GHI"
};
using (var ms = new MemoryStream())
{
EZWriter.Write(ms, strList);
ms.Seek(0, SeekOrigin.Begin);
List <string> comp = EZReader.ReadList <string>(ms);
ObjectInspector inspector = new ObjectInspector();
inspector.CompareObjects(strList, comp, true);
}
List <int> intList = new List <int>()
{
1, 2, 3, 4, 5
};
using (var ms = new MemoryStream())
{
EZWriter.Write(ms, intList);
ms.Seek(0, SeekOrigin.Begin);
List <int> comp = EZReader.ReadList <int>(ms);
ObjectInspector inspector = new ObjectInspector();
inspector.CompareObjects(intList, comp, true);
}
}
public void CanUseGenericEZReaderMethod()
{
// A more difficult one...
const int MAX = 10;
Int32[] data = new Int32[MAX];
for (int i = 0; i < MAX; i++)
{
data[i] = i;
}
MemoryStream m = new MemoryStream();
EZWriter.Write(m, data);
m.Seek(0, SeekOrigin.Begin);
Int32[] comp = EZReader.Read <Int32[]>(m);
ObjectInspector oi = new ObjectInspector();
var result = oi.CompareArrays <int>(data, comp);
// Make sure that it matches!
Assert.IsTrue(result.Item1, result.Item2);
// Let's do a string to make sure!
string testString = RandomTools.GetRandomCharString(MAX);
m = new MemoryStream();
EZWriter.Write(m, testString);
m.Seek(0, SeekOrigin.Begin);
string compString = EZReader.Read <string>(m);
Assert.AreEqual(testString, compString);
}
public void CanSerializeDoubles()
{
double[] testDoubles = new[] { 1.25d, 0.546d, 21.581d };
using (var ms = new MemoryStream())
{
foreach (var item in testDoubles)
{
EZWriter.Write(ms, item);
}
ms.Seek(0, SeekOrigin.Begin);
double[] others = new double[testDoubles.Length];
for (int i = 0; i < others.Length; i++)
{
others[i] = EZReader.ReadDouble(ms);
}
ObjectInspector inspector = new ObjectInspector();
inspector.CompareObjects <double[]>(testDoubles, others, true);
}
}
public void CanSerializeFloats()
{
float[] testFloats = new[] { 1.25f, 0.546f, 21.581f };
using (var ms = new MemoryStream())
{
foreach (var item in testFloats)
{
EZWriter.Write(ms, item);
}
ms.Seek(0, SeekOrigin.Begin);
float[] others = new float[testFloats.Length];
for (int i = 0; i < others.Length; i++)
{
others[i] = EZReader.ReadFloat(ms);
}
ObjectInspector inspector = new ObjectInspector();
inspector.CompareObjects(testFloats, others, true);
}
}
