home *** CD-ROM | disk | FTP | other *** search
/ Turbo Toolbox / Turbo_Toolbox.iso / extra18 / compress / test3. < prev   
Encoding:
Text File  |  1991-12-04  |  5.5 KB  |  155 lines
  1. (* ------------------------------------------------- *)
  2. (*                      TEST.PAS                     *)
  3. (*                                                   *)
  4. (* »Test1« ist ein Test- und Demoprogramm für die    *)
  5. (* Unit »CompressU«.                                 *)
  6. (* Das Programm komprimiert drei Dateien um sie an-  *)
  7. (* schließend gleich wieder zu dekomprimieren. Die   *)
  8. (* dekomprimierte Datei wird daraufhin mit dem       *)
  9. (* Original verglichen. Zu jeder Datei wird ein      *)
  10. (* Testergebnis ausgegeben, das auch den Kompres-    *)
  11. (* sionsgrad angibt.                                 *)
  12. (* »Test1« bildet einen Nachfahren von dem Objekt    *)
  13. (* »compressOBJ« und definiert die Methoden          *)
  14. (* »Read_bytes« und »Write_bytes«.                   *)
  15. (*                                                   *)
  16. (*       (c) 1991 Uwe Dirksen & DMV-Verlag           *)
  17. (* ------------------------------------------------- *)
  18. PROGRAM Test;
  19.  
  20. USES Crt, CompressU;
  21.  
  22. CONST
  23.   testanzahl      = 3;
  24.   start           = 1;
  25.   ende            = testanzahl;
  26.   max_feldgroesse = 24096;
  27.                     (* Größe der Vergleichsfelder    *)
  28.   puffergroesse   = 64000;
  29.                     (* Größe des dynamischen Puffers *)
  30.   filename : ARRAY [1..testanzahl] OF STRING =
  31.                     ('TEST1.DAT', 'TEST2.DAT');
  32.   fname    : ARRAY [1..testanzahl] OF STRING =
  33.                     ('TEST1', 'TEST2');
  34.  
  35. TYPE
  36.   fileptrTYP = ^FILE;
  37.   _compressOBJ = OBJECT (compressOBJ)
  38.  
  39.     CONSTRUCTOR Init(VAR io_file : FILE);
  40.     PROCEDURE   Read_bytes(VAR database;
  41.                            VAR laenge : WORD); VIRTUAL;
  42.     PROCEDURE   Write_bytes(VAR database;
  43.                             VAR laenge : WORD);VIRTUAL;
  44.     PRIVATE
  45.     fileptr : fileptrTYP;
  46.   END;
  47.  
  48. VAR
  49.   bytes_read, bytes_read2, bytes_write,
  50.   durchgang, vergleich, data_seg, data_ofs : WORD;
  51.   inputfile, inputfile2, outputfile        : FILE;
  52.   max_memory, laenge, fehler               : LONGINT;
  53.   kompressionsgrad                         : REAL;
  54.   datenptr                                 : POINTER;
  55.  
  56.   daten1, daten2 : ARRAY [1..max_feldgroesse] OF BYTE;
  57.   compress       : _compressOBJ;
  58.  
  59.   CONSTRUCTOR _compressOBJ.Init(VAR io_file : FILE);
  60.   BEGIN
  61.     compressOBJ.Init;
  62.     fileptr := Ptr(Seg(io_file), Ofs(io_file));
  63.   END;
  64.  
  65.   PROCEDURE _compressOBJ.Read_bytes(VAR database;
  66.                                     VAR laenge : WORD);
  67.   BEGIN
  68.     BlockRead(fileptr^, database, laenge, laenge);
  69.   END;
  70.  
  71.   PROCEDURE _compressOBJ.Write_bytes(VAR database;
  72.                                     VAR laenge : WORD);
  73.   BEGIN
  74.     BlockWrite(fileptr^, database, laenge, laenge);
  75.   END;
  76.  
  77. BEGIN
  78.   ClrScr; 
  79.   max_memory := MaxAvail;
  80.   IF max_memory > puffergroesse THEN
  81.     max_memory := puffergroesse;
  82.   GetMem(datenptr, max_memory);
  83.   data_seg := Seg(datenptr^);
  84.   data_ofs := Ofs (datenptr^);
  85.   FOR durchgang := start TO ende DO BEGIN
  86.     Assign(inputfile, filename[durchgang]);
  87.     Reset(inputfile, 1);
  88.     Assign(outputfile, fname[durchgang] + '.CPR');
  89.     Rewrite(outputfile, 1);
  90.     compress.Init(outputfile);
  91.     WriteLn('Datei : ', filename[durchgang]);
  92.     WriteLn('   Kompressionsvorgang läuft');
  93.     REPEAT
  94.       BlockRead(inputfile, MEM[data_seg:data_ofs],
  95.                            max_memory, bytes_read);
  96.       compress.Compress(MEM[data_seg:data_ofs],
  97.                             bytes_read);
  98.     UNTIL bytes_read < max_memory;
  99.     kompressionsgrad:= FileSize(outputfile)*100 /
  100.                        FileSize(inputfile);
  101.     Close(inputfile);
  102.     Close(outputfile);
  103.     WriteLn('   Kompressionsvorgang beendet');
  104.     Assign(inputfile, fname[durchgang] + '.CPR');
  105.     Reset (inputfile, 1);
  106.     Assign(outputfile, fname[durchgang] + '.DPR');
  107.     Rewrite(outputfile, 1);
  108.     compress.Init(inputfile);
  109.     laenge := max_memory - 351;
  110.     bytes_read := laenge;
  111.     WriteLn('   Dekompressionsvorgang läuft');
  112.     REPEAT
  113.       compress.Decompress(MEM[data_seg:data_ofs],
  114.                               bytes_read);
  115.       BlockWrite(outputfile, MEM[data_seg:data_ofs],
  116.                              bytes_read,bytes_write);
  117.     UNTIL bytes_read < laenge;
  118.     Close(inputfile);
  119.     Close(outputfile);
  120.     WriteLn('   Dekompressionsvorgang beendet');
  121.     Assign(inputfile, filename[durchgang]);
  122.     Reset(inputfile, 1);
  123.     Assign(inputfile2, fname[durchgang] + '.DPR');
  124.     Reset(inputfile2, 1);
  125.     fehler := 0;
  126.     WriteLn('   Der Vergleich läuft');
  127.     REPEAT
  128.       BlockRead(inputfile, daten1, max_feldgroesse,
  129.                            bytes_read);
  130.       BlockRead(inputfile2, daten2, max_feldgroesse,
  131.                             bytes_read2);
  132.       FOR vergleich:= 1 TO bytes_read DO
  133.         IF daten1[vergleich] <> daten2[vergleich] THEN
  134.           INC(fehler);
  135.     UNTIL (bytes_read <> max_feldgroesse) OR
  136.           (bytes_read <> bytes_read2);
  137.     Close(inputfile);
  138.     Close(inputfile2);
  139.     WriteLn('  Fehler : ', fehler);
  140.     IF bytes_read < bytes_read2 THEN
  141.       WriteLn('  Die dekomprimierte Datei ist größer '+
  142.               'als das Original !')
  143.     ELSE IF bytes_read2 < bytes_read THEN
  144.       WriteLn('  Die dekomprimierte Datei ist '+
  145.               'kleiner als das Original !');
  146.     WriteLn('  Die Datei wurde auf ',
  147.             kompressionsgrad:4:1,
  148.             ' Prozent verkleinert !');
  149.   END;
  150.   FreeMem(datenptr, max_memory);
  151.   REPEAT UNTIL KeyPressed;
  152. END.
  153. (* ------------------------------------------------- *)
  154. (*                 Ende von TEST.PAS                 *)
  155.