// using System;
// using System.IO;
// using NUnit.Framework;

// namespace BCG
// {

//    /// <summary>
//    /// Tests the deserialization happening within the pubsub.
//    /// </summary>
//    [TestGroup]
//    public class CompressionSerializationTest
//    {
//       protected IBlueTableSchema mySchema;
//       protected BlueTable myTable;
//       protected IBlueDataSerializer mySer;
//       protected IPubsubDeserializer myPubsubDeser;
//       protected IClientDeserializer myClientDeser;


//       [Test]
//       public static void test_compression()
//       {
//          int n_len = 10000000;
//          for (int t = 0; t < 10; t++)
//          {
//             Random rnd = new Random(DateTime.Now.Millisecond);
//             byte[] data = new byte[n_len];
//             rnd.NextBytes(data);

//             BCG.Utilities.General.HighPerformanceTimer timer = new Utilities.General.HighPerformanceTimer();
//             timer.start();
//             byte[] compr = UtilityMethods.compress(new MemoryStream(data));
//             timer.stop();
//             Console.WriteLine("Time to compress {0} bytes {1} msecs ratio {2}", n_len, timer.lastIntervalTime, (1.0 * data.Length)/(1.0 * compr.Length));

//             timer.start();
//             Stream decompr_str = UtilityMethods.decompress(compr);
//             timer.stop();            
//             Console.WriteLine("Time to de-compress {0} bytes {1} msecs", n_len, timer.lastIntervalTime);

//             decompr_str.Position = 0;
//             Assert.AreEqual(data.Length, (int)decompr_str.Length);
//             for (int i = 0; i < data.Length; i++)
//                Assert.AreEqual(data[i], decompr_str.ReadByte());
//          }
//       }

//       public CompressionSerializationTest()
//       {
//          mySchema = new BlueTableSchema(myGetTableName(),
//                                           new ColumnInfo("id", 0, typeof(int)),
//                                           new ColumnInfo("i1", 1, typeof(int)),
//                                           new ColumnInfo("d1", 2, typeof(double)),
//                                           new ColumnInfo("dt", 3, typeof(DateTime)),
//                                           new ColumnInfo("x", 4, typeof(byte))
//             );
//          mySer = new CompressionSerializer(mySchema);
//          myClientDeser = new ClientDeserializationController();
//          myPubsubDeser = new PubsubDeserializationController();
//       }

//       protected virtual string myGetTableName()
//       {
//          return "testUniversal";
//       }

//       /// <summary>
//       /// Tests the entire cycle. This is done by 'publishing' data to the serializationController (ie a series of
//       /// adds, deletions, changes etc) and getting the bytes and feeding it into a pubsubDeseriazlier and a clientDeserializer. 
//       /// At every step the data is tested for consistency. At the end the getState is used to get all the data, and its passed
//       /// through the clientDeserializer to get all the rows.
//       /// </summary>
//       [Test]
//       public void testEntireProcess()
//       {
//          myTable = new BlueTable(mySchema);
//          byte[] data;
//          int id;
//          //create
//          for (id = 0; id < 100; id++)
//             myTable.addRow(myGetRow(id));

//          byte[] ops;
//          Array rows;
//          IBlueRowCollection del, add;
//          IBlueRowCollection[] receivedData;
//          IBlueRow r;

//          //create
//          mySer.serialize(StreamOpCode.create, new IBlueRowCollection[] { myTable }, out data);
//          myWrite(StreamOpCode.create, data);
//          myPubsubDeser.deserialize(new Stream[] { new MemoryStream(data) }, out ops, out rows);
//          myClientDeser.deserialize(new Stream[] { new MemoryStream(data) }, out ops, out rows);
//          Assert.AreEqual(1, ops.Length);
//          Assert.AreEqual(StreamOpCode.create, ops[0]);
//          Assert.AreEqual(1, rows.Length);
//          receivedData = rows.GetValue(0) as IBlueRowCollection[];
//          Assert.AreEqual(1, receivedData.Length);

//          BlueDataUtility.computeDifferences(receivedData[0], myTable, out del, out add);
//          Assert.AreEqual(0, del.Count);
//          Assert.AreEqual(0, add.Count);

//          //single add
//          r = myGetRow(id);
//          BlueTable temp = new BlueTable(mySchema);
//          myTable.addRow(r);
//          temp.addRow(r);
//          mySer.serialize(StreamOpCode.add, new IBlueRowCollection[] { temp }, out data);
//          myWrite(StreamOpCode.add, data);
//          myPubsubDeser.deserialize(new Stream[] { new MemoryStream(data) }, out ops, out rows);
//          myClientDeser.deserialize(new Stream[] { new MemoryStream(data) }, out ops, out rows);
//          Assert.AreEqual(1, ops.Length);
//          Assert.AreEqual(StreamOpCode.add, ops[0]);
//          Assert.AreEqual(1, rows.Length);
//          receivedData = rows.GetValue(0) as IBlueRowCollection[];
//          Assert.AreEqual(1, receivedData.Length);
//          BlueDataUtility.computeDifferences(receivedData[0], temp, out del, out add);
//          Assert.AreEqual(0, del.Count);
//          Assert.AreEqual(0, add.Count);

//          //single delete
//          r = myTable[0];   //delete row with id 0
//          temp = new BlueTable(mySchema);
//          myTable.deleteRow(0);
//          temp.addRow(r);
//          mySer.serialize(StreamOpCode.remove, new IBlueRowCollection[] { temp }, out data);
//          myWrite(StreamOpCode.remove, data);
//          myPubsubDeser.deserialize(new Stream[] { new MemoryStream(data) }, out ops, out rows);
//          myClientDeser.deserialize(new Stream[] { new MemoryStream(data) }, out ops, out rows);
//          Assert.AreEqual(1, ops.Length);
//          Assert.AreEqual(StreamOpCode.remove, ops[0]);
//          Assert.AreEqual(1, rows.Length);
//          receivedData = rows.GetValue(0) as IBlueRowCollection[];
//          Assert.AreEqual(1, receivedData.Length);
//          BlueDataUtility.computeDifferences(receivedData[0], temp, out del, out add);
//          Assert.AreEqual(0, del.Count);
//          Assert.AreEqual(0, add.Count);

//          //batch deletes and adds
//          //0 was removed earlier, so lets delete from 1 to 24 first, and then add 101 to 124
//          BlueTable delRows = new BlueTable(mySchema), addRows = new BlueTable(mySchema);
//          for (int i = 1; i < 25; i++)
//          {
//             delRows.addRow(myTable[i]);
//             myTable.deleteRow(i);
//          }
//          for (id = 101; id < 125; id++)
//          {
//             r = myGetRow(id);
//             addRows.addRow(r);
//             myTable.addRow(r);
//          }
//          for (int i = 25; i < 125; i++)
//             Assert.AreEqual(true, myTable.containsID(i));
//          Assert.AreEqual(100, myTable.Count);

//          mySer.serialize(StreamOpCode.multipleRemoveAdd, new IBlueRowCollection[] { delRows, addRows }, out data);
//          myWrite(StreamOpCode.multipleRemoveAdd, data);
//          myPubsubDeser.deserialize(new Stream[] { new MemoryStream(data) }, out ops, out rows);
//          myClientDeser.deserialize(new Stream[] { new MemoryStream(data) }, out ops, out rows);
//          Assert.AreEqual(1, ops.Length);
//          Assert.AreEqual(StreamOpCode.multipleRemoveAdd, ops[0]);
//          Assert.AreEqual(1, rows.Length);
//          receivedData = rows.GetValue(0) as IBlueRowCollection[];
//          Assert.AreEqual(2, receivedData.Length);
//          BlueDataUtility.computeDifferences(receivedData[0], delRows, out del, out add);
//          Assert.AreEqual(0, del.Count);
//          Assert.AreEqual(0, add.Count);
//          BlueDataUtility.computeDifferences(receivedData[1], addRows, out del, out add);
//          Assert.AreEqual(0, del.Count);
//          Assert.AreEqual(0, add.Count);

//          //pure changes only
//          //change the first 25, 25-49
//          BlueTable changedRows = new BlueTable(mySchema);
//          for (int i = 25; i < 50; i++)
//          {
//             MutableBlueRow mr = new MutableBlueRow(myTable[i]);
//             mr.setValue(4, Byte.MaxValue);
//             myTable.changeRow(mr);
//             changedRows.addRow(mr);
//          }
//          mySer.serialize(StreamOpCode.multipleChange, new IBlueRowCollection[] { changedRows }, out data);
//          myWrite(StreamOpCode.multipleChange, data);
//          myPubsubDeser.deserialize(new Stream[] { new MemoryStream(data) }, out ops, out rows);
//          myClientDeser.deserialize(new Stream[] { new MemoryStream(data) }, out ops, out rows);
//          Assert.AreEqual(1, ops.Length);
//          Assert.AreEqual(StreamOpCode.multipleChange, ops[0]);
//          Assert.AreEqual(1, rows.Length);
//          receivedData = rows.GetValue(0) as IBlueRowCollection[];
//          Assert.AreEqual(1, receivedData.Length);
//          BlueDataUtility.computeDifferences(receivedData[0], changedRows, out del, out add);
//          Assert.AreEqual(0, del.Count);
//          Assert.AreEqual(0, add.Count);

//          //final test
//          data = myPubsubDeser.getState();
//          new ClientDeserializationController().deserialize(new Stream[] { new MemoryStream(data) }, out ops, out rows);
//          Assert.AreEqual(1, ops.Length);
//          Assert.AreEqual(StreamOpCode.create, ops[0]);
//          Assert.AreEqual(1, rows.Length);
//          receivedData = rows.GetValue(0) as IBlueRowCollection[];
//          Assert.AreEqual(1, receivedData.Length);
//          BlueDataUtility.computeDifferences(receivedData[0], myTable, out del, out add);
//          Assert.AreEqual(0, del.Count);
//          Assert.AreEqual(0, add.Count);

//       }

//       private IBlueRow myGetRow(int id)
//       {
//          return new BlueRow(mySchema,                        // the day pp fixed this test. 
//                               id, id + 10, id * 3.0, new DateTime(2008, 6, 4, 0, 0, 0, DateTimeKind.Unspecified), Convert.ToByte(id));
//       }

//       private void myWrite(byte op, byte[] data)
//       {
//          string s = "";
//          if (op == StreamOpCode.add)
//             s = "add one row";
//          else if (op == StreamOpCode.change)
//             s = "change one row";
//          else if (op == StreamOpCode.create)
//             s = "create";
//          else if (op == StreamOpCode.multipleChange)
//             s = "multiple change";
//          else if (op == StreamOpCode.multipleRemoveAdd)
//             s = "multiple add remove";
//          else if (op == StreamOpCode.remove)
//             s = "remove one row";
//          Console.WriteLine("op = {0}, size = {1}", s, data.Length);
//       }
//    }
// }