code.grnet.gr Git - pithos-ms-client/blob - trunk/hammock/src/net35/ICSharpCode.SharpZipLib.Silverlight.Tests/GZip/GZipTests.cs

   1 using System;
   2 using System.IO;
   3 using System.Threading;
   4 using ICSharpCode.SharpZipLib.Silverlight.GZip;
   5 using NUnit.Framework;
   6
   7 using ICSharpCode.SharpZipLib.Tests.TestSupport;
   8
   9 namespace ICSharpCode.SharpZipLib.Tests.GZip
  10 {
  11         /// <summary>
  12         /// This class contains test cases for GZip compression
  13         /// </summary>
  14         [TestFixture]
  15         public class GZipTestSuite
  16         {
  17                 /// <summary>
  18                 /// Basic compress/decompress test
  19                 /// </summary>
  20                 [Test]
  21                 [Category("GZip")]
  22                 public void TestGZip()
  23                 {
  24                         MemoryStream ms = new MemoryStream();
  25                         GZipOutputStream outStream = new GZipOutputStream(ms);
  26
  27                         byte[] buf = new byte[100000];
  28                         System.Random rnd = new Random();
  29                         rnd.NextBytes(buf);
  30
  31                         outStream.Write(buf, 0, buf.Length);
  32                         outStream.Flush();
  33                         outStream.Finish();
  34
  35                         ms.Seek(0, SeekOrigin.Begin);
  36
  37                         GZipInputStream inStream = new GZipInputStream(ms);
  38                         byte[] buf2 = new byte[buf.Length];
  39                         int currentIndex = 0;
  40                         int count = buf2.Length;
  41
  42                         while (true) {
  43                                 int numRead = inStream.Read(buf2, currentIndex, count);
  44                                 if (numRead <= 0) {
  45                                         break;
  46                                 }
  47                                 currentIndex += numRead;
  48                                 count -= numRead;
  49                         }
  50
  51                         Assert.AreEqual(0, count);
  52
  53                         for (int i = 0; i < buf.Length; ++i) {
  54                                 Assert.AreEqual(buf2[i], buf[i]);
  55                         }
  56                 }
  57
  58                 /// <summary>
  59                 /// Writing GZip headers is delayed so that this stream can be used with HTTP/IIS.
  60                 /// </summary>
  61                 [Test]
  62                 [Category("GZip")]
  63                 public void DelayedHeaderWriteNoData()
  64                 {
  65                         MemoryStream ms = new MemoryStream();
  66                         Assert.AreEqual(0, ms.Length);
  67
  68                         using (GZipOutputStream outStream = new GZipOutputStream(ms)) {
  69                                 Assert.AreEqual(0, ms.Length);
  70                         }
  71
  72                         byte[] data = ms.ToArray();
  73
  74                         Assert.IsTrue(data.Length > 0);
  75                 }
  76
  77                 /// <summary>
  78                 /// Writing GZip headers is delayed so that this stream can be used with HTTP/IIS.
  79                 /// </summary>
  80                 [Test]
  81                 [Category("GZip")]
  82                 public void DelayedHeaderWriteWithData()
  83                 {
  84                         MemoryStream ms = new MemoryStream();
  85                         Assert.AreEqual(0, ms.Length);
  86                         using (GZipOutputStream outStream = new GZipOutputStream(ms)) {
  87                                 Assert.AreEqual(0, ms.Length);
  88                                 outStream.WriteByte(45);
  89
  90                                 // Should in fact contain header right now with
  91                                 // 1 byte in the compression pipeline
  92                                 Assert.AreEqual(10, ms.Length);
  93                         }
  94                         byte[] data = ms.ToArray();
  95
  96                         Assert.IsTrue(data.Length > 0);
  97                 }
  98
  99                 [Test]
 100                 [Category("GZip")]
 101                 public void ZeroLengthInputStream()
 102                 {
 103                         GZipInputStream gzi = new GZipInputStream(new MemoryStream());
 104                         bool exception = false;
 105                         try {
 106                                 gzi.ReadByte();
 107                         }
 108                         catch {
 109                                 exception = true;
 110                         }
 111
 112                         Assert.IsTrue(exception, "reading from an empty stream should cause an exception");
 113                 }
 114
 115                 [Test]
 116                 [Category("GZip")]
 117                 public void OutputStreamOwnership()
 118                 {
 119                         MemoryStreamEx memStream = new MemoryStreamEx();
 120                         GZipOutputStream s = new GZipOutputStream(memStream);
 121
 122                         Assert.IsFalse(memStream.IsClosed, "Shouldnt be closed initially");
 123                         Assert.IsFalse(memStream.IsDisposed, "Shouldnt be disposed initially");
 124
 125                         s.Close();
 126
 127                         Assert.IsTrue(memStream.IsClosed, "Should be closed after parent owner close");
 128                         Assert.IsTrue(memStream.IsDisposed, "Should be disposed after parent owner close");
 129
 130                         memStream = new MemoryStreamEx();
 131                         s = new GZipOutputStream(memStream);
 132
 133                         Assert.IsFalse(memStream.IsClosed, "Shouldnt be closed initially");
 134                         Assert.IsFalse(memStream.IsDisposed, "Shouldnt be disposed initially");
 135
 136                         s.IsStreamOwner = false;
 137                         s.Close();
 138
 139                         Assert.IsFalse(memStream.IsClosed, "Should not be closed after parent owner close");
 140                         Assert.IsFalse(memStream.IsDisposed, "Should not be disposed after parent owner close");
 141                 }
 142
 143                 [Test]
 144                 [Category("GZip")]
 145                 public void InputStreamOwnership()
 146                 {
 147                         MemoryStreamEx memStream = new MemoryStreamEx();
 148                         GZipInputStream s = new GZipInputStream(memStream);
 149
 150                         Assert.IsFalse(memStream.IsClosed, "Shouldnt be closed initially");
 151                         Assert.IsFalse(memStream.IsDisposed, "Shouldnt be disposed initially");
 152
 153                         s.Close();
 154
 155                         Assert.IsTrue(memStream.IsClosed, "Should be closed after parent owner close");
 156                         Assert.IsTrue(memStream.IsDisposed, "Should be disposed after parent owner close");
 157
 158                         memStream = new MemoryStreamEx();
 159                         s = new GZipInputStream(memStream);
 160
 161                         Assert.IsFalse(memStream.IsClosed, "Shouldnt be closed initially");
 162                         Assert.IsFalse(memStream.IsDisposed, "Shouldnt be disposed initially");
 163
 164                         s.IsStreamOwner = false;
 165                         s.Close();
 166
 167                         Assert.IsFalse(memStream.IsClosed, "Should not be closed after parent owner close");
 168                         Assert.IsFalse(memStream.IsDisposed, "Should not be disposed after parent owner close");
 169
 170                 }
 171
 172                 [Test]
 173                 [Category("GZip")]
 174                 [Category("Long Running")]
 175                 public void BigStream()
 176                 {
 177                         window_ = new WindowedStream(0x3ffff);
 178                         outStream_ = new GZipOutputStream(window_);
 179                         inStream_ = new GZipInputStream(window_);
 180
 181                         long target = 0x10000000;
 182                         readTarget_ = writeTarget_ = target;
 183
 184                         Thread reader = new Thread(Reader);
 185                         reader.Name = "Reader";
 186                         reader.Start();
 187
 188                         Thread writer = new Thread(Writer);
 189                         writer.Name = "Writer";
 190
 191                         DateTime startTime = DateTime.Now;
 192                         writer.Start();
 193
 194                         writer.Join();
 195                         reader.Join();
 196
 197                         DateTime endTime = DateTime.Now;
 198
 199                         TimeSpan span = endTime - startTime;
 200                         Console.WriteLine("Time {0}  processes {1} KB/Sec", span, (target / 1024) / span.TotalSeconds);
 201                 }
 202
 203                 void Reader()
 204                 {
 205                         const int Size = 8192;
 206                         int readBytes = 1;
 207                         byte[] buffer = new byte[Size];
 208
 209                         long passifierLevel = readTarget_ - 0x10000000;
 210
 211                         while ( (readTarget_ > 0) && (readBytes > 0) ) {
 212                                 int count = Size;
 213                                 if (count > readTarget_) {
 214                                         count = (int)readTarget_;
 215                                 }
 216
 217                                 readBytes = inStream_.Read(buffer, 0, count);
 218                                 readTarget_ -= readBytes;
 219
 220                                 if (readTarget_ <= passifierLevel) {
 221                                         Console.WriteLine("Reader {0} bytes remaining", readTarget_);
 222                                         passifierLevel = readTarget_ - 0x10000000;
 223                                 }
 224                         }
 225
 226                         Assert.IsTrue(window_.IsClosed, "Window should be closed");
 227
 228                         // This shouldnt read any data but should read the footer
 229                         readBytes = inStream_.Read(buffer, 0, 1);
 230                         Assert.AreEqual(0, readBytes, "Stream should be empty");
 231                         Assert.AreEqual(0, window_.Length, "Window should be closed");
 232                         inStream_.Close();
 233                 }
 234
 235                 void Writer()
 236                 {
 237                         const int Size = 8192;
 238
 239                         byte[] buffer = new byte[Size];
 240
 241                         while (writeTarget_ > 0) {
 242                                 int thisTime = Size;
 243                                 if (thisTime > writeTarget_) {
 244                                         thisTime = (int)writeTarget_;
 245                                 }
 246
 247                                 outStream_.Write(buffer, 0, thisTime);
 248                                 writeTarget_-= thisTime;
 249                         }
 250                         outStream_.Close();
 251                 }
 252
 253                 WindowedStream window_;
 254                 GZipOutputStream outStream_;
 255                 GZipInputStream inStream_;
 256                 long readTarget_;
 257                 long writeTarget_;
 258         }
 259 }