Imports System
Imports System.IO
Imports System.IO.Compression



Public Class GZipTest
    Shared msg As String
    Private Const buffer_size As Integer = 100

    Public Shared Function ReadAllBytesFromStream(ByVal stream As Stream, ByVal buffer() As Byte) As Integer
        ' Use this method is used to read all bytes from a stream.
        Dim offset As Integer = 0
        Dim totalCount As Integer = 0
        While True
            Dim bytesRead As Integer = stream.Read(buffer, offset, buffer_size)
            If bytesRead = 0 Then
                Exit While
            End If
            offset += bytesRead
            totalCount += bytesRead
        End While
        Return totalCount
    End Function 'ReadAllBytesFromStream


    Public Shared Function CompareData(ByVal buf1() As Byte, ByVal len1 As Integer, ByVal buf2() As Byte, ByVal len2 As Integer) As Boolean
        ' Use this method to compare data from two different buffers.
        If len1 <> len2 Then
            msg = "Number of bytes in two buffer are different" & len1 & ":" & len2
            MsgBox(msg)
            Return False
        End If

        Dim i As Integer
        For i = 0 To len1 - 1
            If buf1(i) <> buf2(i) Then
                msg = "byte " & i & " is different " & buf1(i) & "|" & buf2(i)
                MsgBox(msg)
                Return False
            End If
        Next i
        msg = "All bytes compare."
        MsgBox(msg)
        Return True
    End Function 'CompareData


    Public Shared Sub GZipCompressDecompress(ByVal filename As String)
        msg = "Test compression and decompression on file " & filename
        MsgBox(msg)

        Dim infile As FileStream
        Try
            ' Open the file as a FileStream object.
            infile = New FileStream(filename, FileMode.Open, FileAccess.Read, FileShare.Read)
            Dim buffer(infile.Length - 1) As Byte
            ' Read the file to ensure it is readable.
            Dim count As Integer = infile.Read(buffer, 0, buffer.Length)
            If count <> buffer.Length Then
                infile.Close()
                msg = "Test Failed: Unable to read data from file"
                MsgBox(msg)
                Return
            End If
            infile.Close()
            Dim ms As New MemoryStream()
            ' Use the newly created memory stream for the compressed data.
            Dim compressedzipStream As New GZipStream(ms, CompressionMode.Compress, True)
            compressedzipStream.Write(buffer, 0, buffer.Length)
            ' Close the stream.
            compressedzipStream.Close()

            msg = "Original size: " & buffer.Length & ", Compressed size: " & ms.Length
            MsgBox(msg)

            ' Reset the memory stream position to begin decompression.
            ms.Position = 0
            Dim zipStream As New GZipStream(ms, CompressionMode.Decompress)
            Dim decompressedBuffer(buffer.Length + buffer_size) As Byte
            ' Use the ReadAllBytesFromStream to read the stream.
            Dim totalCount As Integer = GZipTest.ReadAllBytesFromStream(zipStream, decompressedBuffer)
            msg = "Decompressed " & totalCount & " bytes"
            MsgBox(msg)

            If Not GZipTest.CompareData(buffer, buffer.Length, decompressedBuffer, totalCount) Then
                msg = "Error. The two buffers did not compare."
                MsgBox(msg)

            End If
            zipStream.Close()
        Catch e As Exception
            msg = "Error: The file being read contains invalid data."
            MsgBox(msg)
        End Try

    End Sub 'GZipCompressDecompress

    Public Shared Sub Main(ByVal args() As String)
        Dim usageText As String = "Usage: GZIPTEST <inputfilename>"
        'If no file name is specified, write usage text.
        If args.Length = 0 Then
            Console.WriteLine(usageText)
        Else
            If File.Exists(args(0)) Then
                GZipCompressDecompress(args(0))
            End If
        End If
    End Sub 'Main
End Class 'GZipTest 

using System;
using System.IO;
using System.IO.Compression;

public class GZipTest
{
    private const int buffer_size = 100;

    public static int ReadAllBytesFromStream(Stream stream, byte[] buffer)
    {
        // Use this method is used to read all bytes from a stream.
        int offset = 0;
        int totalCount = 0;
        while (true)
        {
            int bytesRead = stream.Read(buffer, offset, buffer_size);
            if (bytesRead == 0)
            {
                break;
            }
            offset += bytesRead;
            totalCount += bytesRead;
        }
        return totalCount;
    }

    public static bool CompareData(byte[] buf1, int len1, byte[] buf2, int len2)
    {
        // Use this method to compare data from two different buffers.
        if (len1 != len2)
        {
            Console.WriteLine("Number of bytes in two buffer are different {0}:{1}", len1, len2);
            return false;
        }

        for (int i = 0; i < len1; i++)
        {
            if (buf1[i] != buf2[i])
            {
                Console.WriteLine("byte {0} is different {1}|{2}", i, buf1[i], buf2[i]);
                return false;
            }
        }
        Console.WriteLine("All bytes compare.");
        return true;
    }

    public static void GZipCompressDecompress(string filename)
    {
        Console.WriteLine("Test compression and decompression on file {0}", filename);
        FileStream infile;
        try
        {
            // Open the file as a FileStream object.
            infile = new FileStream(filename, FileMode.Open, FileAccess.Read, FileShare.Read);
            byte[] buffer = new byte[infile.Length];
            // Read the file to ensure it is readable.
            int count = infile.Read(buffer, 0, buffer.Length);
            if (count != buffer.Length)
            {
                infile.Close();
                Console.WriteLine("Test Failed: Unable to read data from file");
                return;
            }
            infile.Close();
            MemoryStream ms = new MemoryStream();
            // Use the newly created memory stream for the compressed data.
            GZipStream compressedzipStream = new GZipStream(ms, CompressionMode.Compress, true);
            Console.WriteLine("Compression");
            compressedzipStream.Write(buffer, 0, buffer.Length);
            // Close the stream.
            compressedzipStream.Close();
            Console.WriteLine("Original size: {0}, Compressed size: {1}", buffer.Length, ms.Length);

            // Reset the memory stream position to begin decompression.
            ms.Position = 0;
            GZipStream zipStream = new GZipStream(ms, CompressionMode.Decompress);
            Console.WriteLine("Decompression");
            byte[] decompressedBuffer = new byte[buffer.Length + buffer_size];
            // Use the ReadAllBytesFromStream to read the stream.
            int totalCount = GZipTest.ReadAllBytesFromStream(zipStream, decompressedBuffer);
            Console.WriteLine("Decompressed {0} bytes", totalCount);

            if (!GZipTest.CompareData(buffer, buffer.Length, decompressedBuffer, totalCount))
            {
                Console.WriteLine("Error. The two buffers did not compare.");
            }
            zipStream.Close();
        } // end try
        catch (InvalidDataException)
        {
            Console.WriteLine("Error: The file being read contains invalid data.");
        }
        catch (FileNotFoundException)
        {
            Console.WriteLine("Error:The file specified was not found.");
        }
        catch (ArgumentException)
        {
            Console.WriteLine("Error: path is a zero-length string, contains only white space, or contains one or more invalid characters");
        }
        catch (PathTooLongException)
        {
            Console.WriteLine("Error: The specified path, file name, or both exceed the system-defined maximum length. For example, on Windows-based platforms, paths must be less than 248 characters, and file names must be less than 260 characters.");
        }
        catch (DirectoryNotFoundException)
        {
            Console.WriteLine("Error: The specified path is invalid, such as being on an unmapped drive.");
        }
        catch (IOException)
        {
            Console.WriteLine("Error: An I/O error occurred while opening the file.");
        }
        catch (UnauthorizedAccessException)
        {
            Console.WriteLine("Error: path specified a file that is read-only, the path is a directory, or caller does not have the required permissions.");
        }
        catch (IndexOutOfRangeException)
        {
            Console.WriteLine("Error: You must provide parameters for MyGZIP.");
        }
    }

    public static void Main(string[] args)
    {
        string usageText = "Usage: MYGZIP <inputfilename>";
        //If no file name is specified, write usage text.
        if (args.Length == 0)
        {
            Console.WriteLine(usageText);
        }
        else
        {
            if (File.Exists(args[0]))
                GZipCompressDecompress(args[0]);
        }
    }
}
    

#using <System.dll>

using namespace System;
using namespace System::IO;
using namespace System::IO::Compression;
int ReadAllBytesFromStream( Stream^ stream, array<Byte>^buffer )
{

   // Use this method is used to read all bytes from a stream.
   int offset = 0;
   int totalCount = 0;
   for ( ; ;  )
   {
      int bytesRead = stream->Read( buffer, offset, 100 );
      if ( bytesRead == 0 )
      {
         break;
      }

      offset += bytesRead;
      totalCount += bytesRead;

   }
   return totalCount;
}

bool CompareData( array<Byte>^buf1, int len1, array<Byte>^buf2, int len2 )
{

   // Use this method to compare data from two different buffers.
   if ( len1 != len2 )
   {
      Console::WriteLine( "Number of bytes in two buffer are different {0}:{1}", len1, len2 );
      return false;
   }

   for ( int i = 0; i < len1; i++ )
   {
      if ( buf1[ i ] != buf2[ i ] )
      {
         Console::WriteLine( "byte {0} is different {1}|{2}", i, buf1[ i ], buf2[ i ] );
         return false;
      }

   }
   Console::WriteLine( "All bytes compare." );
   return true;
}

void GZipCompressDecompress( String^ filename )
{
   Console::WriteLine( "Test compression and decompression on file {0}", filename );
   FileStream^ infile;
   try
   {

      // Open the file as a FileStream object.
      infile = gcnew FileStream( filename,FileMode::Open,FileAccess::Read,FileShare::Read );
      array<Byte>^buffer = gcnew array<Byte>((int)infile->Length);

      // Read the file to ensure it is readable.
      int count = infile->Read( buffer, 0, buffer->Length );
      if ( count != buffer->Length )
      {
         infile->Close();
         Console::WriteLine( "Test Failed: Unable to read data from file" );
         return;
      }
      infile->Close();
      MemoryStream^ ms = gcnew MemoryStream;

      // Use the newly created memory stream for the compressed data.
      GZipStream ^ compressedzipStream = gcnew GZipStream( ms,CompressionMode::Compress,true );
      Console::WriteLine( "Compression" );
      compressedzipStream->Write( buffer, 0, buffer->Length );

      // Close the stream.
      compressedzipStream->Close();
      Console::WriteLine( "Original size: {0}, Compressed size: {1}", buffer->Length, ms->Length );

      // Reset the memory stream position to begin decompression.
      ms->Position = 0;
      GZipStream ^ zipStream = gcnew GZipStream( ms,CompressionMode::Decompress );
      Console::WriteLine( "Decompression" );
      array<Byte>^decompressedBuffer = gcnew array<Byte>(buffer->Length + 100);

      // Use the ReadAllBytesFromStream to read the stream.
      int totalCount = ReadAllBytesFromStream( zipStream, decompressedBuffer );
      Console::WriteLine( "Decompressed {0} bytes", totalCount );
      if (  !CompareData( buffer, buffer->Length, decompressedBuffer, totalCount ) )
      {
         Console::WriteLine( "Error. The two buffers did not compare." );
      }
      zipStream->Close();
   }
   catch ( InvalidDataException ^ ) 
   {
      Console::WriteLine( "Error: The file being read contains invalid data." );
   }
   catch ( FileNotFoundException^ ) 
   {
      Console::WriteLine( "Error:The file specified was not found." );
   }
   catch ( ArgumentException^ ) 
   {
      Console::WriteLine( "Error: path is a zero-length string, contains only white space, or contains one or more invalid characters" );
   }
   catch ( PathTooLongException^ ) 
   {
      Console::WriteLine( "Error: The specified path, file name, or both exceed the system-defined maximum length."
      " For example, on Windows-based platforms, paths must be less than 248 characters, and file names must be less than 260 characters." );
   }
   catch ( DirectoryNotFoundException^ ) 
   {
      Console::WriteLine( "Error: The specified path is invalid, such as being on an unmapped drive." );
   }
   catch ( IOException^ ) 
   {
      Console::WriteLine( "Error: An I/O error occurred while opening the file." );
   }
   catch ( UnauthorizedAccessException^ ) 
   {
      Console::WriteLine( "Error: path specified a file that is read-only, the path is a directory, or caller does not have the required permissions." );
   }
   catch ( IndexOutOfRangeException^ ) 
   {
      Console::WriteLine( "Error: You must provide parameters for MyGZIP." );
   }

}

int main()
{
   array<String^>^args = Environment::GetCommandLineArgs();
   String^ usageText = "Usage: MYGZIP <inputfilename>";

   //If no file name is specified, write usage text.
   if ( args->Length == 1 )
   {
      Console::WriteLine( usageText );
   }
   else
   {
      if ( File::Exists( args[ 1 ] ) )
            GZipCompressDecompress( args[ 1 ] );
   }
}